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