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