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