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