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