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