Merged revisions 114621 via svnmerge from
[asterisk/asterisk.git] / channels / chan_local.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, Digium, Inc.
5  *
6  * Mark Spencer <markster@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 /*! \file
20  *
21  * \author Mark Spencer <markster@digium.com>
22  *
23  * \brief Local Proxy Channel
24  * 
25  * \ingroup channel_drivers
26  */
27
28 #include "asterisk.h"
29
30 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
31
32 #include <fcntl.h>
33 #include <sys/signal.h>
34
35 #include "asterisk/lock.h"
36 #include "asterisk/channel.h"
37 #include "asterisk/config.h"
38 #include "asterisk/module.h"
39 #include "asterisk/pbx.h"
40 #include "asterisk/sched.h"
41 #include "asterisk/io.h"
42 #include "asterisk/rtp.h"
43 #include "asterisk/acl.h"
44 #include "asterisk/callerid.h"
45 #include "asterisk/file.h"
46 #include "asterisk/cli.h"
47 #include "asterisk/app.h"
48 #include "asterisk/musiconhold.h"
49 #include "asterisk/manager.h"
50 #include "asterisk/stringfields.h"
51 #include "asterisk/devicestate.h"
52
53 static const char tdesc[] = "Local Proxy Channel Driver";
54
55 #define IS_OUTBOUND(a,b) (a == b->chan ? 1 : 0)
56
57 static struct ast_jb_conf g_jb_conf = {
58         .flags = 0,
59         .max_size = -1,
60         .resync_threshold = -1,
61         .impl = "",
62 };
63
64 static struct ast_channel *local_request(const char *type, int format, void *data, int *cause);
65 static int local_digit_begin(struct ast_channel *ast, char digit);
66 static int local_digit_end(struct ast_channel *ast, char digit, unsigned int duration);
67 static int local_call(struct ast_channel *ast, char *dest, int timeout);
68 static int local_hangup(struct ast_channel *ast);
69 static int local_answer(struct ast_channel *ast);
70 static struct ast_frame *local_read(struct ast_channel *ast);
71 static int local_write(struct ast_channel *ast, struct ast_frame *f);
72 static int local_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen);
73 static int local_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
74 static int local_sendhtml(struct ast_channel *ast, int subclass, const char *data, int datalen);
75 static int local_sendtext(struct ast_channel *ast, const char *text);
76 static int local_devicestate(void *data);
77 static struct ast_channel *local_bridgedchannel(struct ast_channel *chan, struct ast_channel *bridge);
78
79 /* PBX interface structure for channel registration */
80 static const struct ast_channel_tech local_tech = {
81         .type = "Local",
82         .description = tdesc,
83         .capabilities = -1,
84         .requester = local_request,
85         .send_digit_begin = local_digit_begin,
86         .send_digit_end = local_digit_end,
87         .call = local_call,
88         .hangup = local_hangup,
89         .answer = local_answer,
90         .read = local_read,
91         .write = local_write,
92         .write_video = local_write,
93         .exception = local_read,
94         .indicate = local_indicate,
95         .fixup = local_fixup,
96         .send_html = local_sendhtml,
97         .send_text = local_sendtext,
98         .devicestate = local_devicestate,
99         .bridged_channel = local_bridgedchannel,
100 };
101
102 struct local_pvt {
103         ast_mutex_t lock;                       /* Channel private lock */
104         unsigned int flags;                     /* Private flags */
105         char context[AST_MAX_CONTEXT];          /* Context to call */
106         char exten[AST_MAX_EXTENSION];          /* Extension to call */
107         int reqformat;                          /* Requested format */
108         struct ast_jb_conf jb_conf;             /*!< jitterbuffer configuration for this local channel */
109         struct ast_channel *owner;              /* Master Channel */
110         struct ast_channel *chan;               /* Outbound channel */
111         struct ast_module_user *u_owner;        /*! reference to keep the module loaded while in use */
112         struct ast_module_user *u_chan;         /*! reference to keep the module loaded while in use */
113         AST_LIST_ENTRY(local_pvt) list;         /* Next entity */
114 };
115
116 #define LOCAL_GLARE_DETECT    (1 << 0) /*!< Detect glare on hangup */
117 #define LOCAL_CANCEL_QUEUE    (1 << 1) /*!< Cancel queue */
118 #define LOCAL_ALREADY_MASQED  (1 << 2) /*!< Already masqueraded */
119 #define LOCAL_LAUNCHED_PBX    (1 << 3) /*!< PBX was launched */
120 #define LOCAL_NO_OPTIMIZATION (1 << 4) /*!< Do not optimize using masquerading */
121 #define LOCAL_BRIDGE          (1 << 5) /*!< Report back the "true" channel as being bridged to */
122
123 static AST_LIST_HEAD_STATIC(locals, local_pvt);
124
125 /*! \brief Adds devicestate to local channels */
126 static int local_devicestate(void *data)
127 {
128         char *exten = ast_strdupa(data);
129         char *context = NULL, *opts = NULL;
130         int res;
131         struct local_pvt *lp;
132
133         if (!(context = strchr(exten, '@'))) {
134                 ast_log(LOG_WARNING, "Someone used Local/%s somewhere without a @context. This is bad.\n", exten);
135                 return AST_DEVICE_INVALID;      
136         }
137
138         *context++ = '\0';
139
140         /* Strip options if they exist */
141         if ((opts = strchr(context, '/')))
142                 *opts = '\0';
143
144         ast_debug(3, "Checking if extension %s@%s exists (devicestate)\n", exten, context);
145
146         res = ast_exists_extension(NULL, context, exten, 1, NULL);
147         if (!res)               
148                 return AST_DEVICE_INVALID;
149         
150         res = AST_DEVICE_NOT_INUSE;
151         AST_LIST_LOCK(&locals);
152         AST_LIST_TRAVERSE(&locals, lp, list) {
153                 if (!strcmp(exten, lp->exten) && !strcmp(context, lp->context) && lp->owner) {
154                         res = AST_DEVICE_INUSE;
155                         break;
156                 }
157         }
158         AST_LIST_UNLOCK(&locals);
159
160         return res;
161 }
162
163 /*!
164  * \note Assumes the pvt is no longer in the pvts list
165  */
166 static struct local_pvt *local_pvt_destroy(struct local_pvt *pvt)
167 {
168         ast_mutex_destroy(&pvt->lock);
169         ast_free(pvt);
170         return NULL;
171 }
172
173 /*! \brief Return the bridged channel of a Local channel */
174 static struct ast_channel *local_bridgedchannel(struct ast_channel *chan, struct ast_channel *bridge)
175 {
176         struct local_pvt *p = bridge->tech_pvt;
177         struct ast_channel *bridged = bridge;
178
179         ast_mutex_lock(&p->lock);
180
181         if (ast_test_flag(p, LOCAL_BRIDGE)) {
182                 /* Find the opposite channel */
183                 bridged = (bridge == p->owner ? p->chan : p->owner);
184                 
185                 /* Now see if the opposite channel is bridged to anything */
186                 if (!bridged) {
187                         bridged = bridge;
188                 } else if (bridged->_bridge) {
189                         bridged = bridged->_bridge;
190                 }
191         }
192
193         ast_mutex_unlock(&p->lock);
194
195         return bridged;
196 }
197
198 static int local_queue_frame(struct local_pvt *p, int isoutbound, struct ast_frame *f, struct ast_channel *us)
199 {
200         struct ast_channel *other = NULL;
201
202         /* Recalculate outbound channel */
203         other = isoutbound ? p->owner : p->chan;
204
205         /* Set glare detection */
206         ast_set_flag(p, LOCAL_GLARE_DETECT);
207         if (ast_test_flag(p, LOCAL_CANCEL_QUEUE)) {
208                 /* We had a glare on the hangup.  Forget all this business,
209                 return and destroy p.  */
210                 ast_mutex_unlock(&p->lock);
211                 p = local_pvt_destroy(p);
212                 return -1;
213         }
214         if (!other) {
215                 ast_clear_flag(p, LOCAL_GLARE_DETECT);
216                 return 0;
217         }
218
219         /* Ensure that we have both channels locked */
220         while (other && ast_channel_trylock(other)) {
221                 ast_mutex_unlock(&p->lock);
222                 if (us)
223                         ast_channel_unlock(us);
224                 usleep(1);
225                 if (us)
226                         ast_channel_lock(us);
227                 ast_mutex_lock(&p->lock);
228                 other = isoutbound ? p->owner : p->chan;
229         }
230
231         if (other) {
232                 ast_queue_frame(other, f);
233                 ast_channel_unlock(other);
234         }
235
236         ast_clear_flag(p, LOCAL_GLARE_DETECT);
237
238         return 0;
239 }
240
241 static int local_answer(struct ast_channel *ast)
242 {
243         struct local_pvt *p = ast->tech_pvt;
244         int isoutbound;
245         int res = -1;
246
247         if (!p)
248                 return -1;
249
250         ast_mutex_lock(&p->lock);
251         isoutbound = IS_OUTBOUND(ast, p);
252         if (isoutbound) {
253                 /* Pass along answer since somebody answered us */
254                 struct ast_frame answer = { AST_FRAME_CONTROL, AST_CONTROL_ANSWER };
255                 res = local_queue_frame(p, isoutbound, &answer, ast);
256         } else
257                 ast_log(LOG_WARNING, "Huh?  Local is being asked to answer?\n");
258         if (!res)
259                 ast_mutex_unlock(&p->lock);
260         return res;
261 }
262
263 static void check_bridge(struct local_pvt *p, int isoutbound)
264 {
265         struct ast_channel_monitor *tmp;
266         if (ast_test_flag(p, LOCAL_ALREADY_MASQED) || ast_test_flag(p, LOCAL_NO_OPTIMIZATION) || !p->chan || !p->owner || (p->chan->_bridge != ast_bridged_channel(p->chan)))
267                 return;
268
269         /* only do the masquerade if we are being called on the outbound channel,
270            if it has been bridged to another channel and if there are no pending
271            frames on the owner channel (because they would be transferred to the
272            outbound channel during the masquerade)
273         */
274         if (isoutbound && p->chan->_bridge /* Not ast_bridged_channel!  Only go one step! */ && AST_LIST_EMPTY(&p->owner->readq)) {
275                 /* Masquerade bridged channel into owner */
276                 /* Lock everything we need, one by one, and give up if
277                    we can't get everything.  Remember, we'll get another
278                    chance in just a little bit */
279                 if (!ast_channel_trylock(p->chan->_bridge)) {
280                         if (!ast_check_hangup(p->chan->_bridge)) {
281                                 if (!ast_channel_trylock(p->owner)) {
282                                         if (!ast_check_hangup(p->owner)) {
283                                                 if(p->owner->monitor && !p->chan->_bridge->monitor) {
284                                                         /* If a local channel is being monitored, we don't want a masquerade
285                                                          * to cause the monitor to go away. Since the masquerade swaps the monitors,
286                                                          * pre-swapping the monitors before the masquerade will ensure that the monitor
287                                                          * ends up where it is expected.
288                                                          */
289                                                         tmp = p->owner->monitor;
290                                                         p->owner->monitor = p->chan->_bridge->monitor;
291                                                         p->chan->_bridge->monitor = tmp;
292                                                 }
293                                                 ast_channel_masquerade(p->owner, p->chan->_bridge);
294                                                 ast_set_flag(p, LOCAL_ALREADY_MASQED);
295                                         }
296                                         ast_channel_unlock(p->owner);
297                                 }
298                                 ast_channel_unlock(p->chan->_bridge);
299                         }
300                 }
301         /* We only allow masquerading in one 'direction'... it's important to preserve the state
302            (group variables, etc.) that live on p->chan->_bridge (and were put there by the dialplan)
303            when the local channels go away.
304         */
305 #if 0
306         } else if (!isoutbound && p->owner && p->owner->_bridge && p->chan && AST_LIST_EMPTY(&p->chan->readq)) {
307                 /* Masquerade bridged channel into chan */
308                 if (!ast_mutex_trylock(&(p->owner->_bridge)->lock)) {
309                         if (!ast_check_hangup(p->owner->_bridge)) {
310                                 if (!ast_mutex_trylock(&p->chan->lock)) {
311                                         if (!ast_check_hangup(p->chan)) {
312                                                 ast_channel_masquerade(p->chan, p->owner->_bridge);
313                                                 ast_set_flag(p, LOCAL_ALREADY_MASQED);
314                                         }
315                                         ast_mutex_unlock(&p->chan->lock);
316                                 }
317                         }
318                         ast_mutex_unlock(&(p->owner->_bridge)->lock);
319                 }
320 #endif
321         }
322 }
323
324 static struct ast_frame  *local_read(struct ast_channel *ast)
325 {
326         return &ast_null_frame;
327 }
328
329 static int local_write(struct ast_channel *ast, struct ast_frame *f)
330 {
331         struct local_pvt *p = ast->tech_pvt;
332         int res = -1;
333         int isoutbound;
334
335         if (!p)
336                 return -1;
337
338         /* Just queue for delivery to the other side */
339         ast_mutex_lock(&p->lock);
340         isoutbound = IS_OUTBOUND(ast, p);
341         if (f && (f->frametype == AST_FRAME_VOICE || f->frametype == AST_FRAME_VIDEO))
342                 check_bridge(p, isoutbound);
343         if (!ast_test_flag(p, LOCAL_ALREADY_MASQED))
344                 res = local_queue_frame(p, isoutbound, f, ast);
345         else {
346                 ast_debug(1, "Not posting to queue since already masked on '%s'\n", ast->name);
347                 res = 0;
348         }
349         if (!res)
350                 ast_mutex_unlock(&p->lock);
351         return res;
352 }
353
354 static int local_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
355 {
356         struct local_pvt *p = newchan->tech_pvt;
357
358         if (!p)
359                 return -1;
360
361         ast_mutex_lock(&p->lock);
362
363         if ((p->owner != oldchan) && (p->chan != oldchan)) {
364                 ast_log(LOG_WARNING, "Old channel wasn't %p but was %p/%p\n", oldchan, p->owner, p->chan);
365                 ast_mutex_unlock(&p->lock);
366                 return -1;
367         }
368         if (p->owner == oldchan)
369                 p->owner = newchan;
370         else
371                 p->chan = newchan;
372         ast_mutex_unlock(&p->lock);
373         return 0;
374 }
375
376 static int local_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen)
377 {
378         struct local_pvt *p = ast->tech_pvt;
379         int res = 0;
380         struct ast_frame f = { AST_FRAME_CONTROL, };
381         int isoutbound;
382
383         if (!p)
384                 return -1;
385
386         /* If this is an MOH hold or unhold, do it on the Local channel versus real channel */
387         if (condition == AST_CONTROL_HOLD) {
388                 ast_moh_start(ast, data, NULL);
389         } else if (condition == AST_CONTROL_UNHOLD) {
390                 ast_moh_stop(ast);
391         } else {
392                 /* Queue up a frame representing the indication as a control frame */
393                 ast_mutex_lock(&p->lock);
394                 isoutbound = IS_OUTBOUND(ast, p);
395                 f.subclass = condition;
396                 f.data = (void*)data;
397                 f.datalen = datalen;
398                 if (!(res = local_queue_frame(p, isoutbound, &f, ast)))
399                         ast_mutex_unlock(&p->lock);
400         }
401
402         return res;
403 }
404
405 static int local_digit_begin(struct ast_channel *ast, char digit)
406 {
407         struct local_pvt *p = ast->tech_pvt;
408         int res = -1;
409         struct ast_frame f = { AST_FRAME_DTMF_BEGIN, };
410         int isoutbound;
411
412         if (!p)
413                 return -1;
414
415         ast_mutex_lock(&p->lock);
416         isoutbound = IS_OUTBOUND(ast, p);
417         f.subclass = digit;
418         if (!(res = local_queue_frame(p, isoutbound, &f, ast)))
419                 ast_mutex_unlock(&p->lock);
420
421         return res;
422 }
423
424 static int local_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
425 {
426         struct local_pvt *p = ast->tech_pvt;
427         int res = -1;
428         struct ast_frame f = { AST_FRAME_DTMF_END, };
429         int isoutbound;
430
431         if (!p)
432                 return -1;
433
434         ast_mutex_lock(&p->lock);
435         isoutbound = IS_OUTBOUND(ast, p);
436         f.subclass = digit;
437         f.len = duration;
438         if (!(res = local_queue_frame(p, isoutbound, &f, ast)))
439                 ast_mutex_unlock(&p->lock);
440
441         return res;
442 }
443
444 static int local_sendtext(struct ast_channel *ast, const char *text)
445 {
446         struct local_pvt *p = ast->tech_pvt;
447         int res = -1;
448         struct ast_frame f = { AST_FRAME_TEXT, };
449         int isoutbound;
450
451         if (!p)
452                 return -1;
453
454         ast_mutex_lock(&p->lock);
455         isoutbound = IS_OUTBOUND(ast, p);
456         f.data = (char *) text;
457         f.datalen = strlen(text) + 1;
458         if (!(res = local_queue_frame(p, isoutbound, &f, ast)))
459                 ast_mutex_unlock(&p->lock);
460         return res;
461 }
462
463 static int local_sendhtml(struct ast_channel *ast, int subclass, const char *data, int datalen)
464 {
465         struct local_pvt *p = ast->tech_pvt;
466         int res = -1;
467         struct ast_frame f = { AST_FRAME_HTML, };
468         int isoutbound;
469
470         if (!p)
471                 return -1;
472         
473         ast_mutex_lock(&p->lock);
474         isoutbound = IS_OUTBOUND(ast, p);
475         f.subclass = subclass;
476         f.data = (char *)data;
477         f.datalen = datalen;
478         if (!(res = local_queue_frame(p, isoutbound, &f, ast)))
479                 ast_mutex_unlock(&p->lock);
480         return res;
481 }
482
483 /*! \brief Initiate new call, part of PBX interface 
484  *      dest is the dial string */
485 static int local_call(struct ast_channel *ast, char *dest, int timeout)
486 {
487         struct local_pvt *p = ast->tech_pvt;
488         int res;
489         struct ast_var_t *varptr = NULL, *new;
490         size_t len, namelen;
491
492         if (!p)
493                 return -1;
494         
495         ast_mutex_lock(&p->lock);
496
497         /*
498          * Note that cid_num and cid_name aren't passed in the ast_channel_alloc
499          * call, so it's done here instead.
500          */
501         p->chan->cid.cid_num = ast_strdup(p->owner->cid.cid_num);
502         p->chan->cid.cid_name = ast_strdup(p->owner->cid.cid_name);
503         p->chan->cid.cid_rdnis = ast_strdup(p->owner->cid.cid_rdnis);
504         p->chan->cid.cid_ani = ast_strdup(p->owner->cid.cid_ani);
505         p->chan->cid.cid_pres = p->owner->cid.cid_pres;
506         ast_string_field_set(p->chan, language, p->owner->language);
507         ast_string_field_set(p->chan, accountcode, p->owner->accountcode);
508         ast_cdr_update(p->chan);
509         p->chan->cdrflags = p->owner->cdrflags;
510
511         /* copy the channel variables from the incoming channel to the outgoing channel */
512         /* Note that due to certain assumptions, they MUST be in the same order */
513         AST_LIST_TRAVERSE(&p->owner->varshead, varptr, entries) {
514                 namelen = strlen(varptr->name);
515                 len = sizeof(struct ast_var_t) + namelen + strlen(varptr->value) + 2;
516                 if ((new = ast_calloc(1, len))) {
517                         memcpy(new, varptr, len);
518                         new->value = &(new->name[0]) + namelen + 1;
519                         AST_LIST_INSERT_TAIL(&p->chan->varshead, new, entries);
520                 }
521         }
522         ast_channel_datastore_inherit(p->owner, p->chan);
523
524         /* Start switch on sub channel */
525         if (!(res = ast_pbx_start(p->chan)))
526                 ast_set_flag(p, LOCAL_LAUNCHED_PBX);
527
528         ast_mutex_unlock(&p->lock);
529         return res;
530 }
531
532 /*! \brief Hangup a call through the local proxy channel */
533 static int local_hangup(struct ast_channel *ast)
534 {
535         struct local_pvt *p = ast->tech_pvt;
536         int isoutbound;
537         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
538         struct ast_channel *ochan = NULL;
539         int glaredetect = 0, res = 0;
540
541         if (!p)
542                 return -1;
543
544         ast_mutex_lock(&p->lock);
545         if (p->chan && ast_test_flag(ast, AST_FLAG_ANSWERED_ELSEWHERE)) 
546                 ast_set_flag(p->chan, AST_FLAG_ANSWERED_ELSEWHERE);
547         isoutbound = IS_OUTBOUND(ast, p);
548         if (isoutbound) {
549                 const char *status = pbx_builtin_getvar_helper(p->chan, "DIALSTATUS");
550                 if ((status) && (p->owner)) {
551                         /* Deadlock avoidance */
552                         while (p->owner && ast_channel_trylock(p->owner)) {
553                                 ast_mutex_unlock(&p->lock);
554                                 usleep(1);
555                                 ast_mutex_lock(&p->lock);
556                         }
557                         if (p->owner) {
558                                 pbx_builtin_setvar_helper(p->owner, "CHANLOCALSTATUS", status);
559                                 ast_channel_unlock(p->owner);
560                         }
561                 }
562                 p->chan = NULL;
563                 ast_clear_flag(p, LOCAL_LAUNCHED_PBX);
564                 ast_module_user_remove(p->u_chan);
565         } else {
566                 p->owner = NULL;
567                 ast_module_user_remove(p->u_owner);
568         }
569         
570         ast->tech_pvt = NULL;
571         
572         if (!p->owner && !p->chan) {
573                 /* Okay, done with the private part now, too. */
574                 glaredetect = ast_test_flag(p, LOCAL_GLARE_DETECT);
575                 /* If we have a queue holding, don't actually destroy p yet, but
576                    let local_queue do it. */
577                 if (glaredetect)
578                         ast_set_flag(p, LOCAL_CANCEL_QUEUE);
579                 ast_mutex_unlock(&p->lock);
580                 /* Remove from list */
581                 AST_LIST_LOCK(&locals);
582                 AST_LIST_REMOVE(&locals, p, list);
583                 AST_LIST_UNLOCK(&locals);
584                 /* Grab / release lock just in case */
585                 ast_mutex_lock(&p->lock);
586                 ast_mutex_unlock(&p->lock);
587                 /* And destroy */
588                 if (!glaredetect) {
589                         p = local_pvt_destroy(p);
590                 }
591                 return 0;
592         }
593         if (p->chan && !ast_test_flag(p, LOCAL_LAUNCHED_PBX))
594                 /* Need to actually hangup since there is no PBX */
595                 ochan = p->chan;
596         else
597                 res = local_queue_frame(p, isoutbound, &f, NULL);
598         if (!res)
599                 ast_mutex_unlock(&p->lock);
600         if (ochan)
601                 ast_hangup(ochan);
602         return 0;
603 }
604
605 /*! \brief Create a call structure */
606 static struct local_pvt *local_alloc(const char *data, int format)
607 {
608         struct local_pvt *tmp = NULL;
609         char *c = NULL, *opts = NULL;
610
611         if (!(tmp = ast_calloc(1, sizeof(*tmp))))
612                 return NULL;
613
614         /* Initialize private structure information */
615         ast_mutex_init(&tmp->lock);
616         ast_copy_string(tmp->exten, data, sizeof(tmp->exten));
617
618         memcpy(&tmp->jb_conf, &g_jb_conf, sizeof(tmp->jb_conf));
619
620         /* Look for options */
621         if ((opts = strchr(tmp->exten, '/'))) {
622                 *opts++ = '\0';
623                 if (strchr(opts, 'n'))
624                         ast_set_flag(tmp, LOCAL_NO_OPTIMIZATION);
625                 if (strchr(opts, 'j')) {
626                         if (ast_test_flag(tmp, LOCAL_NO_OPTIMIZATION))
627                                 ast_set_flag(&tmp->jb_conf, AST_JB_ENABLED);
628                         else {
629                                 ast_log(LOG_ERROR, "You must use the 'n' option for chan_local "
630                                         "to use the 'j' option to enable the jitterbuffer\n");
631                         }
632                 }
633                 if (strchr(opts, 'b')) {
634                         ast_set_flag(tmp, LOCAL_BRIDGE);
635                 }
636         }
637
638         /* Look for a context */
639         if ((c = strchr(tmp->exten, '@')))
640                 *c++ = '\0';
641
642         ast_copy_string(tmp->context, c ? c : "default", sizeof(tmp->context));
643
644         tmp->reqformat = format;
645
646         if (!ast_exists_extension(NULL, tmp->context, tmp->exten, 1, NULL)) {
647                 ast_log(LOG_NOTICE, "No such extension/context %s@%s creating local channel\n", tmp->exten, tmp->context);
648                 tmp = local_pvt_destroy(tmp);
649         } else {
650                 /* Add to list */
651                 AST_LIST_LOCK(&locals);
652                 AST_LIST_INSERT_HEAD(&locals, tmp, list);
653                 AST_LIST_UNLOCK(&locals);
654         }
655         
656         return tmp;
657 }
658
659 /*! \brief Start new local channel */
660 static struct ast_channel *local_new(struct local_pvt *p, int state)
661 {
662         struct ast_channel *tmp = NULL, *tmp2 = NULL;
663         int randnum = ast_random() & 0xffff, fmt = 0;
664         const char *t;
665         int ama;
666
667         /* Allocate two new Asterisk channels */
668         /* safe accountcode */
669         if (p->owner && p->owner->accountcode)
670                 t = p->owner->accountcode;
671         else
672                 t = "";
673
674         if (p->owner)
675                 ama = p->owner->amaflags;
676         else
677                 ama = 0;
678         if (!(tmp = ast_channel_alloc(1, state, 0, 0, t, p->exten, p->context, ama, "Local/%s@%s-%04x;1", p->exten, p->context, randnum)) 
679                         || !(tmp2 = ast_channel_alloc(1, AST_STATE_RING, 0, 0, t, p->exten, p->context, ama, "Local/%s@%s-%04x;2", p->exten, p->context, randnum))) {
680                 if (tmp)
681                         ast_channel_free(tmp);
682                 if (tmp2)
683                         ast_channel_free(tmp2);
684                 ast_log(LOG_WARNING, "Unable to allocate channel structure(s)\n");
685                 return NULL;
686         } 
687
688         tmp2->tech = tmp->tech = &local_tech;
689
690         tmp->nativeformats = p->reqformat;
691         tmp2->nativeformats = p->reqformat;
692
693         /* Determine our read/write format and set it on each channel */
694         fmt = ast_best_codec(p->reqformat);
695         tmp->writeformat = fmt;
696         tmp2->writeformat = fmt;
697         tmp->rawwriteformat = fmt;
698         tmp2->rawwriteformat = fmt;
699         tmp->readformat = fmt;
700         tmp2->readformat = fmt;
701         tmp->rawreadformat = fmt;
702         tmp2->rawreadformat = fmt;
703
704         tmp->tech_pvt = p;
705         tmp2->tech_pvt = p;
706
707         p->owner = tmp;
708         p->chan = tmp2;
709         p->u_owner = ast_module_user_add(p->owner);
710         p->u_chan = ast_module_user_add(p->chan);
711
712         ast_copy_string(tmp->context, p->context, sizeof(tmp->context));
713         ast_copy_string(tmp2->context, p->context, sizeof(tmp2->context));
714         ast_copy_string(tmp2->exten, p->exten, sizeof(tmp->exten));
715         tmp->priority = 1;
716         tmp2->priority = 1;
717
718         ast_jb_configure(tmp, &p->jb_conf);
719
720         return tmp;
721 }
722
723 /*! \brief Part of PBX interface */
724 static struct ast_channel *local_request(const char *type, int format, void *data, int *cause)
725 {
726         struct local_pvt *p = NULL;
727         struct ast_channel *chan = NULL;
728
729         /* Allocate a new private structure and then Asterisk channel */
730         if ((p = local_alloc(data, format))) {
731                 if (!(chan = local_new(p, AST_STATE_DOWN))) {
732                         AST_LIST_LOCK(&locals);
733                         AST_LIST_REMOVE(&locals, p, list);
734                         AST_LIST_UNLOCK(&locals);
735                         p = local_pvt_destroy(p);
736                 }
737         }
738
739         return chan;
740 }
741
742 /*! \brief CLI command "local show channels" */
743 static char *locals_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
744 {
745         struct local_pvt *p = NULL;
746
747         switch (cmd) {
748         case CLI_INIT:
749                 e->command = "local show channels";
750                 e->usage =
751                         "Usage: local show channels\n"
752                         "       Provides summary information on active local proxy channels.\n";
753                 return NULL;
754         case CLI_GENERATE:
755                 return NULL;
756         }
757
758         if (a->argc != 3)
759                 return CLI_SHOWUSAGE;
760
761         AST_LIST_LOCK(&locals);
762         if (!AST_LIST_EMPTY(&locals)) {
763                 AST_LIST_TRAVERSE(&locals, p, list) {
764                         ast_mutex_lock(&p->lock);
765                         ast_cli(a->fd, "%s -- %s@%s\n", p->owner ? p->owner->name : "<unowned>", p->exten, p->context);
766                         ast_mutex_unlock(&p->lock);
767                 }
768         } else
769                 ast_cli(a->fd, "No local channels in use\n");
770         AST_LIST_UNLOCK(&locals);
771
772         return CLI_SUCCESS;
773 }
774
775 static struct ast_cli_entry cli_local[] = {
776         AST_CLI_DEFINE(locals_show, "List status of local channels"),
777 };
778
779 /*! \brief Load module into PBX, register channel */
780 static int load_module(void)
781 {
782         /* Make sure we can register our channel type */
783         if (ast_channel_register(&local_tech)) {
784                 ast_log(LOG_ERROR, "Unable to register channel class 'Local'\n");
785                 return AST_MODULE_LOAD_FAILURE;
786         }
787         ast_cli_register_multiple(cli_local, sizeof(cli_local) / sizeof(struct ast_cli_entry));
788         return AST_MODULE_LOAD_SUCCESS;
789 }
790
791 /*! \brief Unload the local proxy channel from Asterisk */
792 static int unload_module(void)
793 {
794         struct local_pvt *p = NULL;
795
796         /* First, take us out of the channel loop */
797         ast_cli_unregister_multiple(cli_local, sizeof(cli_local) / sizeof(struct ast_cli_entry));
798         ast_channel_unregister(&local_tech);
799         if (!AST_LIST_LOCK(&locals)) {
800                 /* Hangup all interfaces if they have an owner */
801                 AST_LIST_TRAVERSE(&locals, p, list) {
802                         if (p->owner)
803                                 ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
804                 }
805                 AST_LIST_UNLOCK(&locals);
806                 AST_LIST_HEAD_DESTROY(&locals);
807         } else {
808                 ast_log(LOG_WARNING, "Unable to lock the monitor\n");
809                 return -1;
810         }               
811         return 0;
812 }
813
814 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Local Proxy Channel (Note: used internally by other modules)");