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