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