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