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