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