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