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