7d62e6235c0e6aa8176193f23a903df11c7593d8
[asterisk/asterisk.git] / channels / chan_console.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2006 - 2008, Digium, Inc.
5  *
6  * Russell Bryant <russell@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! 
20  * \file 
21  * \brief Cross-platform console channel driver 
22  *
23  * \author Russell Bryant <russell@digium.com>
24  *
25  * \note Some of the code in this file came from chan_oss and chan_alsa.
26  *       chan_oss,  Mark Spencer <markster@digium.com>
27  *       chan_oss,  Luigi Rizzo
28  *       chan_alsa, Matthew Fredrickson <creslin@digium.com>
29  * 
30  * \ingroup channel_drivers
31  *
32  * \extref Portaudio http://www.portaudio.com/
33  *
34  * To install portaudio v19 from svn, check it out using the following command:
35  *  - svn co https://www.portaudio.com/repos/portaudio/branches/v19-devel
36  *
37  * \note Since this works with any audio system that libportaudio supports,
38  * including ALSA and OSS, this may someday deprecate chan_alsa and chan_oss.
39  * However, before that can be done, it needs to *at least* have all of the
40  * features that these other channel drivers have.  The features implemented
41  * in at least one of the other console channel drivers that are not yet
42  * implemented here are:
43  *
44  * - Set Auto-answer from the dialplan
45  * - transfer CLI command
46  * - boost CLI command and .conf option
47  * - console_video support
48  */
49
50 /*** MODULEINFO
51         <depend>portaudio</depend>
52  ***/
53
54 #include "asterisk.h"
55
56 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
57
58 #include <sys/signal.h>  /* SIGURG */
59
60 #include <portaudio.h>
61
62 #include "asterisk/module.h"
63 #include "asterisk/channel.h"
64 #include "asterisk/pbx.h"
65 #include "asterisk/causes.h"
66 #include "asterisk/cli.h"
67 #include "asterisk/musiconhold.h"
68 #include "asterisk/callerid.h"
69 #include "asterisk/astobj2.h"
70
71 /*! 
72  * \brief The sample rate to request from PortAudio 
73  *
74  * \todo Make this optional.  If this is only going to talk to 8 kHz endpoints,
75  *       then it makes sense to use 8 kHz natively.
76  */
77 #define SAMPLE_RATE      16000
78
79 /*! 
80  * \brief The number of samples to configure the portaudio stream for
81  *
82  * 320 samples (20 ms) is the most common frame size in Asterisk.  So, the code
83  * in this module reads 320 sample frames from the portaudio stream and queues
84  * them up on the Asterisk channel.  Frames of any size can be written to a
85  * portaudio stream, but the portaudio documentation does say that for high
86  * performance applications, the data should be written to Pa_WriteStream in
87  * the same size as what is used to initialize the stream.
88  */
89 #define NUM_SAMPLES      320
90
91 /*! \brief Mono Input */
92 #define INPUT_CHANNELS   1
93
94 /*! \brief Mono Output */
95 #define OUTPUT_CHANNELS  1
96
97 /*! 
98  * \brief Maximum text message length
99  * \note This should be changed if there is a common definition somewhere
100  *       that defines the maximum length of a text message.
101  */
102 #define TEXT_SIZE       256
103
104 #ifndef MIN
105 #define MIN(a,b) ((a) < (b) ? (a) : (b))
106 #endif
107 #ifndef MAX
108 #define MAX(a,b) ((a) > (b) ? (a) : (b))
109 #endif
110
111 /*! \brief Dance, Kirby, Dance! @{ */
112 #define V_BEGIN " --- <(\"<) --- "
113 #define V_END   " --- (>\")> ---\n"
114 /*! @} */
115
116 static const char config_file[] = "console.conf";
117
118 /*!
119  * \brief Console pvt structure
120  *
121  * Currently, this is a singleton object.  However, multiple instances will be
122  * needed when this module is updated for multiple device support.
123  */
124 static struct console_pvt {
125         AST_DECLARE_STRING_FIELDS(
126                 /*! Name of the device */
127                 AST_STRING_FIELD(name);
128                 AST_STRING_FIELD(input_device);
129                 AST_STRING_FIELD(output_device);
130                 /*! Default context for outgoing calls */
131                 AST_STRING_FIELD(context);
132                 /*! Default extension for outgoing calls */
133                 AST_STRING_FIELD(exten);
134                 /*! Default CallerID number */
135                 AST_STRING_FIELD(cid_num);
136                 /*! Default CallerID name */
137                 AST_STRING_FIELD(cid_name);
138                 /*! Default MOH class to listen to, if:
139                  *    - No MOH class set on the channel
140                  *    - Peer channel putting this device on hold did not suggest a class */
141                 AST_STRING_FIELD(mohinterpret);
142                 /*! Default language */
143                 AST_STRING_FIELD(language);
144         );
145         /*! Current channel for this device */
146         struct ast_channel *owner;
147         /*! Current PortAudio stream for this device */
148         PaStream *stream;
149         /*! A frame for preparing to queue on to the channel */
150         struct ast_frame fr;
151         /*! Running = 1, Not running = 0 */
152         unsigned int streamstate:1;
153         /*! On-hook = 0, Off-hook = 1 */
154         unsigned int hookstate:1;
155         /*! Unmuted = 0, Muted = 1 */
156         unsigned int muted:1;
157         /*! Automatically answer incoming calls */
158         unsigned int autoanswer:1;
159         /*! Ignore context in the console dial CLI command */
160         unsigned int overridecontext:1;
161         /*! Set during a reload so that we know to destroy this if it is no longer
162          *  in the configuration file. */
163         unsigned int destroy:1;
164         /*! ID for the stream monitor thread */
165         pthread_t thread;
166 } globals;
167
168 AST_MUTEX_DEFINE_STATIC(globals_lock);
169
170 static struct ao2_container *pvts;
171 #define NUM_PVT_BUCKETS 7
172
173 static struct console_pvt *active_pvt;
174 AST_RWLOCK_DEFINE_STATIC(active_lock);
175
176 /*! 
177  * \brief Global jitterbuffer configuration 
178  *
179  * \note Disabled by default.
180  */
181 static struct ast_jb_conf default_jbconf = {
182         .flags = 0,
183         .max_size = -1,
184         .resync_threshold = -1,
185         .impl = ""
186 };
187 static struct ast_jb_conf global_jbconf;
188
189 /*! Channel Technology Callbacks @{ */
190 static struct ast_channel *console_request(const char *type, int format, 
191         void *data, int *cause);
192 static int console_digit_begin(struct ast_channel *c, char digit);
193 static int console_digit_end(struct ast_channel *c, char digit, unsigned int duration);
194 static int console_text(struct ast_channel *c, const char *text);
195 static int console_hangup(struct ast_channel *c);
196 static int console_answer(struct ast_channel *c);
197 static struct ast_frame *console_read(struct ast_channel *chan);
198 static int console_call(struct ast_channel *c, char *dest, int timeout);
199 static int console_write(struct ast_channel *chan, struct ast_frame *f);
200 static int console_indicate(struct ast_channel *chan, int cond, 
201         const void *data, size_t datalen);
202 static int console_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
203 /*! @} */
204
205 /*!
206  * \brief Formats natively supported by this module.
207  */
208 #define SUPPORTED_FORMATS ( AST_FORMAT_SLINEAR16 )
209
210 static const struct ast_channel_tech console_tech = {
211         .type = "Console",
212         .description = "Console Channel Driver",
213         .capabilities = SUPPORTED_FORMATS,
214         .requester = console_request,
215         .send_digit_begin = console_digit_begin,
216         .send_digit_end = console_digit_end,
217         .send_text = console_text,
218         .hangup = console_hangup,
219         .answer = console_answer,
220         .read = console_read,
221         .call = console_call,
222         .write = console_write,
223         .indicate = console_indicate,
224         .fixup = console_fixup,
225 };
226
227 /*! \brief lock a console_pvt struct */
228 #define console_pvt_lock(pvt) ao2_lock(pvt)
229
230 /*! \brief unlock a console_pvt struct */
231 #define console_pvt_unlock(pvt) ao2_unlock(pvt)
232
233 static inline struct console_pvt *ref_pvt(struct console_pvt *pvt)
234 {
235         if (pvt)
236                 ao2_ref(pvt, +1);
237         return pvt;
238 }
239
240 static inline struct console_pvt *unref_pvt(struct console_pvt *pvt)
241 {
242         ao2_ref(pvt, -1);
243         return NULL;
244 }
245
246 static struct console_pvt *find_pvt(const char *name)
247 {
248         struct console_pvt tmp_pvt = {
249                 .name = name,
250         };
251
252         return ao2_find(pvts, &tmp_pvt, OBJ_POINTER);
253 }
254
255 /*!
256  * \brief Stream monitor thread 
257  *
258  * \arg data A pointer to the console_pvt structure that contains the portaudio
259  *      stream that needs to be monitored.
260  *
261  * This function runs in its own thread to monitor data coming in from a
262  * portaudio stream.  When enough data is available, it is queued up to
263  * be read from the Asterisk channel.
264  */
265 static void *stream_monitor(void *data)
266 {
267         struct console_pvt *pvt = data;
268         char buf[NUM_SAMPLES * sizeof(int16_t)];
269         PaError res;
270         struct ast_frame f = {
271                 .frametype = AST_FRAME_VOICE,
272                 .subclass = AST_FORMAT_SLINEAR16,
273                 .src = "console_stream_monitor",
274                 .data = buf,
275                 .datalen = sizeof(buf),
276                 .samples = sizeof(buf) / sizeof(int16_t),
277         };
278
279         for (;;) {
280                 pthread_testcancel();
281                 res = Pa_ReadStream(pvt->stream, buf, sizeof(buf) / sizeof(int16_t));
282                 pthread_testcancel();
283
284                 if (res == paNoError)
285                         ast_queue_frame(pvt->owner, &f);
286         }
287
288         return NULL;
289 }
290
291 static int open_stream(struct console_pvt *pvt)
292 {
293         int res = paInternalError;
294
295         if (!strcasecmp(pvt->input_device, "default") && 
296                 !strcasecmp(pvt->output_device, "default")) {
297                 res = Pa_OpenDefaultStream(&pvt->stream, INPUT_CHANNELS, OUTPUT_CHANNELS, 
298                         paInt16, SAMPLE_RATE, NUM_SAMPLES, NULL, NULL);
299         } else {
300                 PaStreamParameters input_params = { 
301                         .channelCount = 1,
302                         .sampleFormat = paInt16,
303                         .suggestedLatency = (1.0 / 50.0), /* 20 ms */
304                         .device = paNoDevice,
305                 };
306                 PaStreamParameters output_params = { 
307                         .channelCount = 1, 
308                         .sampleFormat = paInt16,
309                         .suggestedLatency = (1.0 / 50.0), /* 20 ms */
310                         .device = paNoDevice,
311                 };
312                 PaDeviceIndex index, num_devices, def_input, def_output;
313
314                 if (!(num_devices = Pa_GetDeviceCount()))
315                         return res;
316
317                 def_input = Pa_GetDefaultInputDevice();
318                 def_output = Pa_GetDefaultOutputDevice();
319
320                 for (index = 0; 
321                         index < num_devices && (input_params.device == paNoDevice 
322                                 || output_params.device == paNoDevice); 
323                         index++) 
324                 {
325                         const PaDeviceInfo *dev = Pa_GetDeviceInfo(index);
326
327                         if (dev->maxInputChannels) {
328                                 if ( (index == def_input && !strcasecmp(pvt->input_device, "default")) ||
329                                         !strcasecmp(pvt->input_device, dev->name) )
330                                         input_params.device = index;
331                         }
332
333                         if (dev->maxOutputChannels) {
334                                 if ( (index == def_output && !strcasecmp(pvt->output_device, "default")) ||
335                                         !strcasecmp(pvt->output_device, dev->name) )
336                                         output_params.device = index;
337                         }
338                 }
339
340                 if (input_params.device == paNoDevice)
341                         ast_log(LOG_ERROR, "No input device found for console device '%s'\n", pvt->name);
342                 if (output_params.device == paNoDevice)
343                         ast_log(LOG_ERROR, "No output device found for console device '%s'\n", pvt->name);
344
345                 res = Pa_OpenStream(&pvt->stream, &input_params, &output_params,
346                         SAMPLE_RATE, NUM_SAMPLES, paNoFlag, NULL, NULL);
347         }
348
349         return res;
350 }
351
352 static int start_stream(struct console_pvt *pvt)
353 {
354         PaError res;
355         int ret_val = 0;
356
357         console_pvt_lock(pvt);
358
359         if (pvt->streamstate)
360                 goto return_unlock;
361
362         pvt->streamstate = 1;
363         ast_debug(1, "Starting stream\n");
364
365         res = open_stream(pvt);
366         if (res != paNoError) {
367                 ast_log(LOG_WARNING, "Failed to open stream - (%d) %s\n",
368                         res, Pa_GetErrorText(res));
369                 ret_val = -1;
370                 goto return_unlock;
371         }
372
373         res = Pa_StartStream(pvt->stream);
374         if (res != paNoError) {
375                 ast_log(LOG_WARNING, "Failed to start stream - (%d) %s\n",
376                         res, Pa_GetErrorText(res));
377                 ret_val = -1;
378                 goto return_unlock;
379         }
380
381         if (ast_pthread_create_background(&pvt->thread, NULL, stream_monitor, pvt)) {
382                 ast_log(LOG_ERROR, "Failed to start stream monitor thread\n");
383                 ret_val = -1;
384         }
385
386 return_unlock:
387         console_pvt_unlock(pvt);
388
389         return ret_val;
390 }
391
392 static int stop_stream(struct console_pvt *pvt)
393 {
394         if (!pvt->streamstate)
395                 return 0;
396
397         pthread_cancel(pvt->thread);
398         pthread_kill(pvt->thread, SIGURG);
399         pthread_join(pvt->thread, NULL);
400
401         console_pvt_lock(pvt);
402         Pa_AbortStream(pvt->stream);
403         Pa_CloseStream(pvt->stream);
404         pvt->stream = NULL;
405         pvt->streamstate = 0;
406         console_pvt_unlock(pvt);
407
408         return 0;
409 }
410
411 /*!
412  * \note Called with the pvt struct locked
413  */
414 static struct ast_channel *console_new(struct console_pvt *pvt, const char *ext, const char *ctx, int state)
415 {
416         struct ast_channel *chan;
417
418         if (!(chan = ast_channel_alloc(1, state, pvt->cid_num, pvt->cid_name, NULL, 
419                 ext, ctx, 0, "Console/%s", pvt->name))) {
420                 return NULL;
421         }
422
423         chan->tech = &console_tech;
424         chan->nativeformats = AST_FORMAT_SLINEAR16;
425         chan->readformat = AST_FORMAT_SLINEAR16;
426         chan->writeformat = AST_FORMAT_SLINEAR16;
427         chan->tech_pvt = ref_pvt(pvt);
428
429         pvt->owner = chan;
430
431         if (!ast_strlen_zero(pvt->language))
432                 ast_string_field_set(chan, language, pvt->language);
433
434         ast_jb_configure(chan, &global_jbconf);
435
436         if (state != AST_STATE_DOWN) {
437                 if (ast_pbx_start(chan)) {
438                         chan->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
439                         ast_hangup(chan);
440                         chan = NULL;
441                 } else
442                         start_stream(pvt);
443         }
444
445         return chan;
446 }
447
448 static struct ast_channel *console_request(const char *type, int format, void *data, int *cause)
449 {
450         int oldformat = format;
451         struct ast_channel *chan = NULL;
452         struct console_pvt *pvt;
453
454         if (!(pvt = find_pvt(data))) {
455                 ast_log(LOG_ERROR, "Console device '%s' not found\n", (char *) data);
456                 return NULL;
457         }
458
459         format &= SUPPORTED_FORMATS;
460         if (!format) {
461                 ast_log(LOG_NOTICE, "Channel requested with unsupported format(s): '%d'\n", oldformat);
462                 goto return_unref;
463         }
464
465         if (pvt->owner) {
466                 ast_log(LOG_NOTICE, "Console channel already active!\n");
467                 *cause = AST_CAUSE_BUSY;
468                 goto return_unref;
469         }
470
471         console_pvt_lock(pvt);
472         chan = console_new(pvt, NULL, NULL, AST_STATE_DOWN);
473         console_pvt_unlock(pvt);
474
475         if (!chan)
476                 ast_log(LOG_WARNING, "Unable to create new Console channel!\n");
477
478 return_unref:
479         unref_pvt(pvt);
480
481         return chan;
482 }
483
484 static int console_digit_begin(struct ast_channel *c, char digit)
485 {
486         ast_verb(1, V_BEGIN "Console Received Beginning of Digit %c" V_END, digit);
487
488         return -1; /* non-zero to request inband audio */
489 }
490
491 static int console_digit_end(struct ast_channel *c, char digit, unsigned int duration)
492 {
493         ast_verb(1, V_BEGIN "Console Received End of Digit %c (duration %u)" V_END, 
494                 digit, duration);
495
496         return -1; /* non-zero to request inband audio */
497 }
498
499 static int console_text(struct ast_channel *c, const char *text)
500 {
501         ast_verb(1, V_BEGIN "Console Received Text '%s'" V_END, text);
502
503         return 0;
504 }
505
506 static int console_hangup(struct ast_channel *c)
507 {
508         struct console_pvt *pvt = c->tech_pvt;
509
510         ast_verb(1, V_BEGIN "Hangup on Console" V_END);
511
512         pvt->hookstate = 0;
513         pvt->owner = NULL;
514         stop_stream(pvt);
515
516         c->tech_pvt = unref_pvt(pvt);
517
518         return 0;
519 }
520
521 static int console_answer(struct ast_channel *c)
522 {
523         struct console_pvt *pvt = c->tech_pvt;
524
525         ast_verb(1, V_BEGIN "Call from Console has been Answered" V_END);
526
527         ast_setstate(c, AST_STATE_UP);
528
529         return start_stream(pvt);
530 }
531
532 /*
533  * \brief Implementation of the ast_channel_tech read() callback
534  *
535  * Calling this function is harmless.  However, if it does get called, it
536  * is an indication that something weird happened that really shouldn't
537  * have and is worth looking into.
538  * 
539  * Why should this function not get called?  Well, let me explain.  There are
540  * a couple of ways to pass on audio that has come from this channel.  The way
541  * that this channel driver uses is that once the audio is available, it is
542  * wrapped in an ast_frame and queued onto the channel using ast_queue_frame().
543  *
544  * The other method would be signalling to the core that there is audio waiting,
545  * and that it needs to call the channel's read() callback to get it.  The way
546  * the channel gets signalled is that one or more file descriptors are placed
547  * in the fds array on the ast_channel which the core will poll() on.  When the
548  * fd indicates that input is available, the read() callback is called.  This
549  * is especially useful when there is a dedicated file descriptor where the
550  * audio is read from.  An example would be the socket for an RTP stream.
551  */
552 static struct ast_frame *console_read(struct ast_channel *chan)
553 {
554         ast_debug(1, "I should not be called ...\n");
555
556         return &ast_null_frame;
557 }
558
559 static int console_call(struct ast_channel *c, char *dest, int timeout)
560 {
561         struct ast_frame f = { 0, };
562         struct console_pvt *pvt = c->tech_pvt;
563
564         ast_verb(1, V_BEGIN "Call to device '%s' on console from '%s' <%s>" V_END,
565                 dest, c->cid.cid_name, c->cid.cid_num);
566
567         console_pvt_lock(pvt);
568
569         if (pvt->autoanswer) {
570                 pvt->hookstate = 1;
571                 console_pvt_unlock(pvt);
572                 ast_verb(1, V_BEGIN "Auto-answered" V_END);
573                 f.frametype = AST_FRAME_CONTROL;
574                 f.subclass = AST_CONTROL_ANSWER;
575         } else {
576                 console_pvt_unlock(pvt);
577                 ast_verb(1, V_BEGIN "Type 'console answer' to answer, or use the 'autoanswer' option "
578                                 "for future calls" V_END);
579                 f.frametype = AST_FRAME_CONTROL;
580                 f.subclass = AST_CONTROL_RINGING;
581                 ast_indicate(c, AST_CONTROL_RINGING);
582         }
583
584         ast_queue_frame(c, &f);
585
586         return start_stream(pvt);
587 }
588
589 static int console_write(struct ast_channel *chan, struct ast_frame *f)
590 {
591         struct console_pvt *pvt = chan->tech_pvt;
592
593         Pa_WriteStream(pvt->stream, f->data, f->samples);
594
595         return 0;
596 }
597
598 static int console_indicate(struct ast_channel *chan, int cond, const void *data, size_t datalen)
599 {
600         struct console_pvt *pvt = chan->tech_pvt;
601         int res = 0;
602
603         switch (cond) {
604         case AST_CONTROL_BUSY:
605         case AST_CONTROL_CONGESTION:
606         case AST_CONTROL_RINGING:
607         case -1:
608                 res = -1;  /* Ask for inband indications */
609                 break;
610         case AST_CONTROL_PROGRESS:
611         case AST_CONTROL_PROCEEDING:
612         case AST_CONTROL_VIDUPDATE:
613         case AST_CONTROL_SRCUPDATE:
614                 break;
615         case AST_CONTROL_HOLD:
616                 ast_verb(1, V_BEGIN "Console Has Been Placed on Hold" V_END);
617                 ast_moh_start(chan, data, pvt->mohinterpret);
618                 break;
619         case AST_CONTROL_UNHOLD:
620                 ast_verb(1, V_BEGIN "Console Has Been Retrieved from Hold" V_END);
621                 ast_moh_stop(chan);
622                 break;
623         default:
624                 ast_log(LOG_WARNING, "Don't know how to display condition %d on %s\n", 
625                         cond, chan->name);
626                 /* The core will play inband indications for us if appropriate */
627                 res = -1;
628         }
629
630         return res;
631 }
632
633 static int console_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
634 {
635         struct console_pvt *pvt = newchan->tech_pvt;
636
637         pvt->owner = newchan;
638
639         return 0;
640 }
641
642 /*!
643  * split a string in extension-context, returns pointers to malloc'ed
644  * strings.
645  * If we do not have 'overridecontext' then the last @ is considered as
646  * a context separator, and the context is overridden.
647  * This is usually not very necessary as you can play with the dialplan,
648  * and it is nice not to need it because you have '@' in SIP addresses.
649  * Return value is the buffer address.
650  *
651  * \note came from chan_oss
652  */
653 static char *ast_ext_ctx(struct console_pvt *pvt, const char *src, char **ext, char **ctx)
654 {
655         if (ext == NULL || ctx == NULL)
656                 return NULL;                    /* error */
657
658         *ext = *ctx = NULL;
659
660         if (src && *src != '\0')
661                 *ext = ast_strdup(src);
662
663         if (*ext == NULL)
664                 return NULL;
665
666         if (!pvt->overridecontext) {
667                 /* parse from the right */
668                 *ctx = strrchr(*ext, '@');
669                 if (*ctx)
670                         *(*ctx)++ = '\0';
671         }
672
673         return *ext;
674 }
675
676 static struct console_pvt *get_active_pvt(void)
677 {
678         struct console_pvt *pvt;
679
680         ast_rwlock_rdlock(&active_lock);
681         pvt = ref_pvt(active_pvt);      
682         ast_rwlock_unlock(&active_lock);
683
684         return pvt;
685 }
686
687 static char *cli_console_autoanswer(struct ast_cli_entry *e, int cmd, 
688         struct ast_cli_args *a)
689 {
690         struct console_pvt *pvt = get_active_pvt();
691         char *res = CLI_SUCCESS;
692
693         switch (cmd) {
694         case CLI_INIT:
695                 e->command = "console set autoanswer [on|off]";
696                 e->usage =
697                         "Usage: console set autoanswer [on|off]\n"
698                         "       Enables or disables autoanswer feature.  If used without\n"
699                         "       argument, displays the current on/off status of autoanswer.\n"
700                         "       The default value of autoanswer is in 'oss.conf'.\n";
701                 return NULL;
702
703         case CLI_GENERATE:
704                 return NULL;
705         }
706
707         if (!pvt) {
708                 ast_cli(a->fd, "No console device is set as active.\n");
709                 return CLI_FAILURE;
710         }
711
712         if (a->argc == e->args - 1) {
713                 ast_cli(a->fd, "Auto answer is %s.\n", pvt->autoanswer ? "on" : "off");
714                 unref_pvt(pvt);
715                 return CLI_SUCCESS;
716         }
717
718         if (a->argc != e->args) {
719                 unref_pvt(pvt);
720                 return CLI_SHOWUSAGE;
721         }
722
723         if (!strcasecmp(a->argv[e->args-1], "on"))
724                 pvt->autoanswer = 1;
725         else if (!strcasecmp(a->argv[e->args - 1], "off"))
726                 pvt->autoanswer = 0;
727         else
728                 res = CLI_SHOWUSAGE;
729
730         unref_pvt(pvt);
731
732         return CLI_SUCCESS;
733 }
734
735 static char *cli_console_flash(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
736 {
737         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_FLASH };
738         struct console_pvt *pvt = get_active_pvt();
739
740         if (cmd == CLI_INIT) {
741                 e->command = "console flash";
742                 e->usage =
743                         "Usage: console flash\n"
744                         "       Flashes the call currently placed on the console.\n";
745                 return NULL;
746         } else if (cmd == CLI_GENERATE)
747                 return NULL;
748
749         if (!pvt) {
750                 ast_cli(a->fd, "No console device is set as active\n");
751                 return CLI_FAILURE;
752         }
753
754         if (a->argc != e->args)
755                 return CLI_SHOWUSAGE;
756
757         if (!pvt->owner) {
758                 ast_cli(a->fd, "No call to flash\n");
759                 unref_pvt(pvt);
760                 return CLI_FAILURE;
761         }
762
763         pvt->hookstate = 0;
764
765         ast_queue_frame(pvt->owner, &f);
766
767         unref_pvt(pvt);
768
769         return CLI_SUCCESS;
770 }
771
772 static char *cli_console_dial(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
773 {
774         char *s = NULL;
775         const char *mye = NULL, *myc = NULL; 
776         struct console_pvt *pvt = get_active_pvt();
777
778         if (cmd == CLI_INIT) {
779                 e->command = "console dial";
780                 e->usage =
781                         "Usage: console dial [extension[@context]]\n"
782                         "       Dials a given extension (and context if specified)\n";
783                 return NULL;
784         } else if (cmd == CLI_GENERATE)
785                 return NULL;
786
787         if (!pvt) {
788                 ast_cli(a->fd, "No console device is currently set as active\n");
789                 return CLI_FAILURE;
790         }
791         
792         if (a->argc > e->args + 1)
793                 return CLI_SHOWUSAGE;
794
795         if (pvt->owner) {       /* already in a call */
796                 int i;
797                 struct ast_frame f = { AST_FRAME_DTMF, 0 };
798
799                 if (a->argc == e->args) {       /* argument is mandatory here */
800                         ast_cli(a->fd, "Already in a call. You can only dial digits until you hangup.\n");
801                         unref_pvt(pvt);
802                         return CLI_FAILURE;
803                 }
804                 s = a->argv[e->args];
805                 /* send the string one char at a time */
806                 for (i = 0; i < strlen(s); i++) {
807                         f.subclass = s[i];
808                         ast_queue_frame(pvt->owner, &f);
809                 }
810                 unref_pvt(pvt);
811                 return CLI_SUCCESS;
812         }
813
814         /* if we have an argument split it into extension and context */
815         if (a->argc == e->args + 1) {
816                 char *ext = NULL, *con = NULL;
817                 s = ast_ext_ctx(pvt, a->argv[e->args], &ext, &con);
818                 ast_debug(1, "provided '%s', exten '%s' context '%s'\n", 
819                         a->argv[e->args], mye, myc);
820                 mye = ext;
821                 myc = con;
822         }
823
824         /* supply default values if needed */
825         if (ast_strlen_zero(mye))
826                 mye = pvt->exten;
827         if (ast_strlen_zero(myc))
828                 myc = pvt->context;
829
830         if (ast_exists_extension(NULL, myc, mye, 1, NULL)) {
831                 console_pvt_lock(pvt);
832                 pvt->hookstate = 1;
833                 console_new(pvt, mye, myc, AST_STATE_RINGING);
834                 console_pvt_unlock(pvt);
835         } else
836                 ast_cli(a->fd, "No such extension '%s' in context '%s'\n", mye, myc);
837
838         if (s)
839                 free(s);
840
841         unref_pvt(pvt);
842
843         return CLI_SUCCESS;
844 }
845
846 static char *cli_console_hangup(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
847 {
848         struct console_pvt *pvt = get_active_pvt();
849
850         if (cmd == CLI_INIT) {
851                 e->command = "console hangup";
852                 e->usage =
853                         "Usage: console hangup\n"
854                         "       Hangs up any call currently placed on the console.\n";
855                 return NULL;
856         } else if (cmd == CLI_GENERATE)
857                 return NULL;
858
859         if (!pvt) {
860                 ast_cli(a->fd, "No console device is set as active\n");
861                 return CLI_FAILURE;
862         }
863         
864         if (a->argc != e->args)
865                 return CLI_SHOWUSAGE;
866
867         if (!pvt->owner && !pvt->hookstate) {
868                 ast_cli(a->fd, "No call to hang up\n");
869                 unref_pvt(pvt);
870                 return CLI_FAILURE;
871         }
872
873         pvt->hookstate = 0;
874         if (pvt->owner)
875                 ast_queue_hangup(pvt->owner);
876
877         unref_pvt(pvt);
878
879         return CLI_SUCCESS;
880 }
881
882 static char *cli_console_mute(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
883 {
884         char *s;
885         struct console_pvt *pvt = get_active_pvt();
886         char *res = CLI_SUCCESS;
887
888         if (cmd == CLI_INIT) {
889                 e->command = "console {mute|unmute}";
890                 e->usage =
891                         "Usage: console {mute|unmute}\n"
892                         "       Mute/unmute the microphone.\n";
893                 return NULL;
894         } else if (cmd == CLI_GENERATE)
895                 return NULL;
896
897         if (!pvt) {
898                 ast_cli(a->fd, "No console device is set as active\n");
899                 return CLI_FAILURE;
900         }
901
902         if (a->argc != e->args)
903                 return CLI_SHOWUSAGE;
904
905         s = a->argv[e->args-1];
906         if (!strcasecmp(s, "mute"))
907                 pvt->muted = 1;
908         else if (!strcasecmp(s, "unmute"))
909                 pvt->muted = 0;
910         else
911                 res = CLI_SHOWUSAGE;
912
913         ast_verb(1, V_BEGIN "The Console is now %s" V_END, 
914                 pvt->muted ? "Muted" : "Unmuted");
915
916         unref_pvt(pvt);
917
918         return res;
919 }
920
921 static char *cli_list_available(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
922 {
923         PaDeviceIndex index, num, def_input, def_output;
924
925         if (cmd == CLI_INIT) {
926                 e->command = "console list available";
927                 e->usage =
928                         "Usage: console list available\n"
929                         "       List all available devices.\n";
930                 return NULL;
931         } else if (cmd == CLI_GENERATE)
932                 return NULL;
933
934         if (a->argc != e->args)
935                 return CLI_SHOWUSAGE;
936
937         ast_cli(a->fd, "\n"
938                     "=============================================================\n"
939                     "=== Available Devices =======================================\n"
940                     "=============================================================\n"
941                     "===\n");
942
943         num = Pa_GetDeviceCount();
944         if (!num) {
945                 ast_cli(a->fd, "(None)\n");
946                 return CLI_SUCCESS;
947         }
948
949         def_input = Pa_GetDefaultInputDevice();
950         def_output = Pa_GetDefaultOutputDevice();
951         for (index = 0; index < num; index++) {
952                 const PaDeviceInfo *dev = Pa_GetDeviceInfo(index);
953                 if (!dev)
954                         continue;
955                 ast_cli(a->fd, "=== ---------------------------------------------------------\n"
956                                "=== Device Name: %s\n", dev->name);
957                 if (dev->maxInputChannels)
958                         ast_cli(a->fd, "=== ---> %sInput Device\n", (index == def_input) ? "Default " : "");
959                 if (dev->maxOutputChannels)
960                         ast_cli(a->fd, "=== ---> %sOutput Device\n", (index == def_output) ? "Default " : "");
961                 ast_cli(a->fd, "=== ---------------------------------------------------------\n===\n");
962         }
963
964         ast_cli(a->fd, "=============================================================\n\n");
965
966         return CLI_SUCCESS;
967 }
968
969 static char *cli_list_devices(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
970 {
971         struct ao2_iterator i;
972         struct console_pvt *pvt;
973
974         if (cmd == CLI_INIT) {
975                 e->command = "console list devices";
976                 e->usage =
977                         "Usage: console list devices\n"
978                         "       List all configured devices.\n";
979                 return NULL;
980         } else if (cmd == CLI_GENERATE)
981                 return NULL;
982
983         if (a->argc != e->args)
984                 return CLI_SHOWUSAGE;
985
986         ast_cli(a->fd, "\n"
987                     "=============================================================\n"
988                     "=== Configured Devices ======================================\n"
989                     "=============================================================\n"
990                     "===\n");
991
992         i = ao2_iterator_init(pvts, 0);
993         while ((pvt = ao2_iterator_next(&i))) {
994                 console_pvt_lock(pvt);
995
996                 ast_cli(a->fd, "=== ---------------------------------------------------------\n"
997                                "=== Device Name: %s\n"
998                                "=== ---> Active:           %s\n"
999                                "=== ---> Input Device:     %s\n"
1000                                "=== ---> Output Device:    %s\n"
1001                                "=== ---> Context:          %s\n"
1002                                "=== ---> Extension:        %s\n"
1003                                "=== ---> CallerID Num:     %s\n"
1004                                "=== ---> CallerID Name:    %s\n"
1005                                "=== ---> MOH Interpret:    %s\n"
1006                                "=== ---> Language:         %s\n"
1007                                "=== ---> Muted:            %s\n"
1008                                "=== ---> Auto-Answer:      %s\n"
1009                                "=== ---> Override Context: %s\n"
1010                                "=== ---------------------------------------------------------\n===\n",
1011                         pvt->name, (pvt == active_pvt) ? "Yes" : "No",
1012                         pvt->input_device, pvt->output_device, pvt->context,
1013                         pvt->exten, pvt->cid_num, pvt->cid_name, pvt->mohinterpret,
1014                         pvt->language, pvt->muted ? "Yes" : "No", pvt->autoanswer ? "Yes" : "No",
1015                         pvt->overridecontext ? "Yes" : "No");
1016
1017                 console_pvt_unlock(pvt);
1018                 unref_pvt(pvt);
1019         }
1020
1021         ast_cli(a->fd, "=============================================================\n\n");
1022
1023         return CLI_SUCCESS;
1024 }
1025 /*!
1026  * \brief answer command from the console
1027  */
1028 static char *cli_console_answer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1029 {
1030         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_ANSWER };
1031         struct console_pvt *pvt = get_active_pvt();
1032
1033         switch (cmd) {
1034         case CLI_INIT:
1035                 e->command = "console answer";
1036                 e->usage =
1037                         "Usage: console answer\n"
1038                         "       Answers an incoming call on the console channel.\n";
1039                 return NULL;
1040
1041         case CLI_GENERATE:
1042                 return NULL;    /* no completion */
1043         }
1044
1045         if (!pvt) {
1046                 ast_cli(a->fd, "No console device is set as active\n");
1047                 return CLI_FAILURE;
1048         }
1049
1050         if (a->argc != e->args) {
1051                 unref_pvt(pvt);
1052                 return CLI_SHOWUSAGE;
1053         }
1054
1055         if (!pvt->owner) {
1056                 ast_cli(a->fd, "No one is calling us\n");
1057                 unref_pvt(pvt);
1058                 return CLI_FAILURE;
1059         }
1060
1061         pvt->hookstate = 1;
1062
1063         ast_indicate(pvt->owner, -1);
1064
1065         ast_queue_frame(pvt->owner, &f);
1066
1067         unref_pvt(pvt);
1068
1069         return CLI_SUCCESS;
1070 }
1071
1072 /*!
1073  * \brief Console send text CLI command
1074  *
1075  * \note concatenate all arguments into a single string. argv is NULL-terminated
1076  * so we can use it right away
1077  */
1078 static char *cli_console_sendtext(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1079 {
1080         char buf[TEXT_SIZE];
1081         struct console_pvt *pvt = get_active_pvt();
1082         struct ast_frame f = {
1083                 .frametype = AST_FRAME_TEXT,
1084                 .data = buf,
1085                 .src = "console_send_text",
1086         };
1087         int len;
1088
1089         if (cmd == CLI_INIT) {
1090                 e->command = "console send text";
1091                 e->usage =
1092                         "Usage: console send text <message>\n"
1093                         "       Sends a text message for display on the remote terminal.\n";
1094                 return NULL;
1095         } else if (cmd == CLI_GENERATE)
1096                 return NULL;
1097
1098         if (!pvt) {
1099                 ast_cli(a->fd, "No console device is set as active\n");
1100                 return CLI_FAILURE;
1101         }
1102
1103         if (a->argc < e->args + 1) {
1104                 unref_pvt(pvt);
1105                 return CLI_SHOWUSAGE;
1106         }
1107
1108         if (!pvt->owner) {
1109                 ast_cli(a->fd, "Not in a call\n");
1110                 unref_pvt(pvt);
1111                 return CLI_FAILURE;
1112         }
1113
1114         ast_join(buf, sizeof(buf) - 1, a->argv + e->args);
1115         if (ast_strlen_zero(buf)) {
1116                 unref_pvt(pvt);
1117                 return CLI_SHOWUSAGE;
1118         }
1119
1120         len = strlen(buf);
1121         buf[len] = '\n';
1122         f.datalen = len + 1;
1123
1124         ast_queue_frame(pvt->owner, &f);
1125
1126         unref_pvt(pvt);
1127
1128         return CLI_SUCCESS;
1129 }
1130
1131 static void set_active(struct console_pvt *pvt, const char *value)
1132 {
1133         if (pvt == &globals) {
1134                 ast_log(LOG_ERROR, "active is only valid as a per-device setting\n");
1135                 return;
1136         }
1137
1138         if (!ast_true(value))
1139                 return;
1140
1141         ast_rwlock_wrlock(&active_lock);
1142         if (active_pvt)
1143                 unref_pvt(active_pvt);
1144         active_pvt = ref_pvt(pvt);
1145         ast_rwlock_unlock(&active_lock);
1146 }
1147
1148 static char *cli_console_active(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1149 {
1150         struct console_pvt *pvt;
1151
1152         switch (cmd) {
1153         case CLI_INIT:
1154                 e->command = "console active";
1155                 e->usage =
1156                         "Usage: console active [device]\n"
1157                         "       If no device is specified.  The active console device will be shown.\n"
1158                         "Otherwise, the specified device will become the console device active for\n"
1159                         "the Asterisk CLI.\n";
1160                 return NULL;
1161         case CLI_GENERATE:
1162                 if (a->pos == e->args) {
1163                         struct ao2_iterator i;
1164                         int x = 0;
1165                         char *res = NULL;
1166                         i = ao2_iterator_init(pvts, 0);
1167                         while ((pvt = ao2_iterator_next(&i))) {
1168                                 if (++x > a->n && !strncasecmp(pvt->name, a->word, strlen(a->word)))
1169                                         res = ast_strdup(pvt->name);
1170                                 unref_pvt(pvt);
1171                                 if (res)
1172                                         return res;
1173                         }
1174                 }
1175                 return NULL;
1176         }
1177
1178         if (a->argc < e->args)
1179                 return CLI_SHOWUSAGE;
1180
1181         if (a->argc == e->args) {
1182                 pvt = get_active_pvt();
1183
1184                 if (!pvt)
1185                         ast_cli(a->fd, "No device is currently set as the active console device.\n");
1186                 else {
1187                         console_pvt_lock(pvt);
1188                         ast_cli(a->fd, "The active console device is '%s'.\n", pvt->name);
1189                         console_pvt_unlock(pvt);
1190                         pvt = unref_pvt(pvt);
1191                 }
1192
1193                 return CLI_SUCCESS;
1194         }
1195
1196         if (!(pvt = find_pvt(a->argv[e->args]))) {
1197                 ast_cli(a->fd, "Could not find a device called '%s'.\n", a->argv[e->args]);
1198                 return CLI_FAILURE;
1199         }
1200
1201         set_active(pvt, "yes");
1202
1203         console_pvt_lock(pvt);
1204         ast_cli(a->fd, "The active console device has been set to '%s'\n", pvt->name);
1205         console_pvt_unlock(pvt);
1206
1207         unref_pvt(pvt);
1208
1209         return CLI_SUCCESS;
1210 }
1211
1212 static struct ast_cli_entry cli_console[] = {
1213         AST_CLI_DEFINE(cli_console_dial,       "Dial an extension from the console"),
1214         AST_CLI_DEFINE(cli_console_hangup,     "Hangup a call on the console"),
1215         AST_CLI_DEFINE(cli_console_mute,       "Disable/Enable mic input"),
1216         AST_CLI_DEFINE(cli_console_answer,     "Answer an incoming console call"),
1217         AST_CLI_DEFINE(cli_console_sendtext,   "Send text to a connected party"),
1218         AST_CLI_DEFINE(cli_console_flash,      "Send a flash to the connected party"),
1219         AST_CLI_DEFINE(cli_console_autoanswer, "Turn autoanswer on or off"),
1220         AST_CLI_DEFINE(cli_list_available,     "List available devices"),
1221         AST_CLI_DEFINE(cli_list_devices,       "List configured devices"),
1222         AST_CLI_DEFINE(cli_console_active,     "View or Set the active console device"),
1223 };
1224
1225 /*!
1226  * \brief Set default values for a pvt struct
1227  *
1228  * \note This function expects the pvt lock to be held.
1229  */
1230 static void set_pvt_defaults(struct console_pvt *pvt)
1231 {
1232         if (pvt == &globals) {
1233                 ast_string_field_set(pvt, mohinterpret, "default");
1234                 ast_string_field_set(pvt, context, "default");
1235                 ast_string_field_set(pvt, exten, "s");
1236                 ast_string_field_set(pvt, language, "");
1237                 ast_string_field_set(pvt, cid_num, "");
1238                 ast_string_field_set(pvt, cid_name, "");
1239         
1240                 pvt->overridecontext = 0;
1241                 pvt->autoanswer = 0;
1242         } else {
1243                 ast_mutex_lock(&globals_lock);
1244
1245                 ast_string_field_set(pvt, mohinterpret, globals.mohinterpret);
1246                 ast_string_field_set(pvt, context, globals.context);
1247                 ast_string_field_set(pvt, exten, globals.exten);
1248                 ast_string_field_set(pvt, language, globals.language);
1249                 ast_string_field_set(pvt, cid_num, globals.cid_num);
1250                 ast_string_field_set(pvt, cid_name, globals.cid_name);
1251
1252                 pvt->overridecontext = globals.overridecontext;
1253                 pvt->autoanswer = globals.autoanswer;
1254
1255                 ast_mutex_unlock(&globals_lock);
1256         }
1257 }
1258
1259 static void store_callerid(struct console_pvt *pvt, const char *value)
1260 {
1261         char cid_name[256];
1262         char cid_num[256];
1263
1264         ast_callerid_split(value, cid_name, sizeof(cid_name), 
1265                 cid_num, sizeof(cid_num));
1266
1267         ast_string_field_set(pvt, cid_name, cid_name);
1268         ast_string_field_set(pvt, cid_num, cid_num);
1269 }
1270
1271 /*!
1272  * \brief Store a configuration parameter in a pvt struct
1273  *
1274  * \note This function expects the pvt lock to be held.
1275  */
1276 static void store_config_core(struct console_pvt *pvt, const char *var, const char *value)
1277 {
1278         if (pvt == &globals && !ast_jb_read_conf(&global_jbconf, var, value))
1279                 return;
1280
1281         CV_START(var, value);
1282
1283         CV_STRFIELD("context", pvt, context);
1284         CV_STRFIELD("extension", pvt, exten);
1285         CV_STRFIELD("mohinterpret", pvt, mohinterpret);
1286         CV_STRFIELD("language", pvt, language);
1287         CV_F("callerid", store_callerid(pvt, value));
1288         CV_BOOL("overridecontext", pvt->overridecontext);
1289         CV_BOOL("autoanswer", pvt->autoanswer);
1290
1291         if (pvt != &globals) {
1292                 CV_F("active", set_active(pvt, value))
1293                 CV_STRFIELD("input_device", pvt, input_device);
1294                 CV_STRFIELD("output_device", pvt, output_device);
1295         }
1296
1297         ast_log(LOG_WARNING, "Unknown option '%s'\n", var);
1298
1299         CV_END;
1300 }
1301
1302 static void pvt_destructor(void *obj)
1303 {
1304         struct console_pvt *pvt = obj;
1305
1306         ast_string_field_free_memory(pvt);
1307 }
1308
1309 static int init_pvt(struct console_pvt *pvt, const char *name)
1310 {
1311         pvt->thread = AST_PTHREADT_NULL;
1312
1313         if (ast_string_field_init(pvt, 32))
1314                 return -1;
1315
1316         ast_string_field_set(pvt, name, S_OR(name, ""));
1317
1318         return 0;
1319 }
1320
1321 static void build_device(struct ast_config *cfg, const char *name)
1322 {
1323         struct ast_variable *v;
1324         struct console_pvt *pvt;
1325         int new = 0;
1326
1327         if ((pvt = find_pvt(name))) {
1328                 console_pvt_lock(pvt);
1329                 set_pvt_defaults(pvt);
1330                 pvt->destroy = 0;
1331         } else {
1332                 if (!(pvt = ao2_alloc(sizeof(*pvt), pvt_destructor)))
1333                         return;
1334                 init_pvt(pvt, name);
1335                 set_pvt_defaults(pvt);
1336                 new = 1;
1337         }
1338
1339         for (v = ast_variable_browse(cfg, name); v; v = v->next)
1340                 store_config_core(pvt, v->name, v->value);
1341
1342         if (new)
1343                 ao2_link(pvts, pvt);
1344         else
1345                 console_pvt_unlock(pvt);
1346         
1347         unref_pvt(pvt);
1348 }
1349
1350 static int pvt_mark_destroy_cb(void *obj, void *arg, int flags)
1351 {
1352         struct console_pvt *pvt = obj;
1353         pvt->destroy = 1;
1354         return 0;
1355 }
1356
1357 static void destroy_pvts(void)
1358 {
1359         struct ao2_iterator i;
1360         struct console_pvt *pvt;
1361
1362         i = ao2_iterator_init(pvts, 0);
1363         while ((pvt = ao2_iterator_next(&i))) {
1364                 if (pvt->destroy) {
1365                         ao2_unlink(pvts, pvt);
1366                         ast_rwlock_wrlock(&active_lock);
1367                         if (active_pvt == pvt)
1368                                 active_pvt = unref_pvt(pvt);
1369                         ast_rwlock_unlock(&active_lock);
1370                 }
1371                 unref_pvt(pvt);
1372         }
1373 }
1374
1375 /*!
1376  * \brief Load the configuration
1377  * \param reload if this was called due to a reload
1378  * \retval 0 succcess
1379  * \retval -1 failure
1380  */
1381 static int load_config(int reload)
1382 {
1383         struct ast_config *cfg;
1384         struct ast_variable *v;
1385         struct ast_flags config_flags = { 0 };
1386         char *context = NULL;
1387
1388         /* default values */
1389         memcpy(&global_jbconf, &default_jbconf, sizeof(global_jbconf));
1390         ast_mutex_lock(&globals_lock);
1391         set_pvt_defaults(&globals);
1392         ast_mutex_unlock(&globals_lock);
1393
1394         if (!(cfg = ast_config_load(config_file, config_flags))) {
1395                 ast_log(LOG_NOTICE, "Unable to open configuration file %s!\n", config_file);
1396                 return -1;
1397         }
1398         
1399         ao2_callback(pvts, 0, pvt_mark_destroy_cb, NULL);
1400
1401         ast_mutex_lock(&globals_lock);
1402         for (v = ast_variable_browse(cfg, "general"); v; v = v->next)
1403                 store_config_core(&globals, v->name, v->value);
1404         ast_mutex_unlock(&globals_lock);
1405
1406         while ((context = ast_category_browse(cfg, context))) {
1407                 if (strcasecmp(context, "general"))
1408                         build_device(cfg, context);
1409         }
1410
1411         ast_config_destroy(cfg);
1412
1413         destroy_pvts();
1414
1415         return 0;
1416 }
1417
1418 static int pvt_hash_cb(const void *obj, const int flags)
1419 {
1420         const struct console_pvt *pvt = obj;
1421
1422         return ast_str_hash(pvt->name);
1423 }
1424
1425 static int pvt_cmp_cb(void *obj, void *arg, int flags)
1426 {
1427         struct console_pvt *pvt = obj, *pvt2 = arg;
1428
1429         return !strcasecmp(pvt->name, pvt2->name) ? CMP_MATCH : 0;
1430 }
1431
1432 static void stop_streams(void)
1433 {
1434         struct console_pvt *pvt;
1435         struct ao2_iterator i;
1436
1437         i = ao2_iterator_init(pvts, 0);
1438         while ((pvt = ao2_iterator_next(&i))) {
1439                 if (pvt->hookstate)
1440                         stop_stream(pvt);
1441                 unref_pvt(pvt);
1442         }
1443 }
1444
1445 static int unload_module(void)
1446 {
1447         ast_channel_unregister(&console_tech);
1448         ast_cli_unregister_multiple(cli_console, ARRAY_LEN(cli_console));
1449
1450         stop_streams();
1451
1452         Pa_Terminate();
1453
1454         /* Will unref all the pvts so they will get destroyed, too */
1455         ao2_ref(pvts, -1);
1456
1457         pvt_destructor(&globals);
1458
1459         return 0;
1460 }
1461
1462 static int load_module(void)
1463 {
1464         PaError res;
1465
1466         init_pvt(&globals, NULL);
1467
1468         if (!(pvts = ao2_container_alloc(NUM_PVT_BUCKETS, pvt_hash_cb, pvt_cmp_cb)))
1469                 goto return_error;
1470
1471         if (load_config(0))
1472                 goto return_error;
1473
1474         res = Pa_Initialize();
1475         if (res != paNoError) {
1476                 ast_log(LOG_WARNING, "Failed to initialize audio system - (%d) %s\n",
1477                         res, Pa_GetErrorText(res));
1478                 goto return_error_pa_init;
1479         }
1480
1481         if (ast_channel_register(&console_tech)) {
1482                 ast_log(LOG_ERROR, "Unable to register channel type 'Console'\n");
1483                 goto return_error_chan_reg;
1484         }
1485
1486         if (ast_cli_register_multiple(cli_console, ARRAY_LEN(cli_console)))
1487                 goto return_error_cli_reg;
1488
1489         return AST_MODULE_LOAD_SUCCESS;
1490
1491 return_error_cli_reg:
1492         ast_cli_unregister_multiple(cli_console, ARRAY_LEN(cli_console));
1493 return_error_chan_reg:
1494         ast_channel_unregister(&console_tech);
1495 return_error_pa_init:
1496         Pa_Terminate();
1497 return_error:
1498         if (pvts)
1499                 ao2_ref(pvts, -1);
1500         pvt_destructor(&globals);
1501
1502         return AST_MODULE_LOAD_DECLINE;
1503 }
1504
1505 static int reload(void)
1506 {
1507         return load_config(1);
1508 }
1509
1510 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Console Channel Driver",
1511                 .load = load_module,
1512                 .unload = unload_module,
1513                 .reload = reload,
1514 );