Fix local channel chains optimizing themselves out of a call.
[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 /*** MODULEINFO
29         <support_level>core</support_level>
30  ***/
31
32 #include "asterisk.h"
33
34 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
35
36 #include <fcntl.h>
37 #include <sys/signal.h>
38
39 #include "asterisk/lock.h"
40 #include "asterisk/channel.h"
41 #include "asterisk/config.h"
42 #include "asterisk/module.h"
43 #include "asterisk/pbx.h"
44 #include "asterisk/sched.h"
45 #include "asterisk/io.h"
46 #include "asterisk/acl.h"
47 #include "asterisk/callerid.h"
48 #include "asterisk/file.h"
49 #include "asterisk/cli.h"
50 #include "asterisk/app.h"
51 #include "asterisk/musiconhold.h"
52 #include "asterisk/manager.h"
53 #include "asterisk/stringfields.h"
54 #include "asterisk/devicestate.h"
55 #include "asterisk/astobj2.h"
56
57 /*** DOCUMENTATION
58         <manager name="LocalOptimizeAway" language="en_US">
59                 <synopsis>
60                         Optimize away a local channel when possible.
61                 </synopsis>
62                 <syntax>
63                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
64                         <parameter name="Channel" required="true">
65                                 <para>The channel name to optimize away.</para>
66                         </parameter>
67                 </syntax>
68                 <description>
69                         <para>A local channel created with "/n" will not automatically optimize away.
70                         Calling this command on the local channel will clear that flag and allow
71                         it to optimize away if it's bridged or when it becomes bridged.</para>
72                 </description>
73         </manager>
74  ***/
75
76 static const char tdesc[] = "Local Proxy Channel Driver";
77
78 #define IS_OUTBOUND(a,b) (a == b->chan ? 1 : 0)
79
80 /* right now we are treating the locals astobj2 container as a
81  * list.  If there is ever a reason to make this more efficient
82  * increasing the bucket size would help. */
83 static const int BUCKET_SIZE = 1;
84
85 static struct ao2_container *locals;
86
87 static struct ast_jb_conf g_jb_conf = {
88         .flags = 0,
89         .max_size = -1,
90         .resync_threshold = -1,
91         .impl = "",
92         .target_extra = -1,
93 };
94
95 static struct ast_channel *local_request(const char *type, struct ast_format_cap *cap, const struct ast_channel *requestor, const char *data, int *cause);
96 static int local_digit_begin(struct ast_channel *ast, char digit);
97 static int local_digit_end(struct ast_channel *ast, char digit, unsigned int duration);
98 static int local_call(struct ast_channel *ast, const char *dest, int timeout);
99 static int local_hangup(struct ast_channel *ast);
100 static int local_answer(struct ast_channel *ast);
101 static struct ast_frame *local_read(struct ast_channel *ast);
102 static int local_write(struct ast_channel *ast, struct ast_frame *f);
103 static int local_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen);
104 static int local_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
105 static int local_sendhtml(struct ast_channel *ast, int subclass, const char *data, int datalen);
106 static int local_sendtext(struct ast_channel *ast, const char *text);
107 static int local_devicestate(const char *data);
108 static struct ast_channel *local_bridgedchannel(struct ast_channel *chan, struct ast_channel *bridge);
109 static int local_queryoption(struct ast_channel *ast, int option, void *data, int *datalen);
110 static int local_setoption(struct ast_channel *chan, int option, void *data, int datalen);
111
112 /* PBX interface structure for channel registration */
113 static struct ast_channel_tech local_tech = {
114         .type = "Local",
115         .description = tdesc,
116         .requester = local_request,
117         .send_digit_begin = local_digit_begin,
118         .send_digit_end = local_digit_end,
119         .call = local_call,
120         .hangup = local_hangup,
121         .answer = local_answer,
122         .read = local_read,
123         .write = local_write,
124         .write_video = local_write,
125         .exception = local_read,
126         .indicate = local_indicate,
127         .fixup = local_fixup,
128         .send_html = local_sendhtml,
129         .send_text = local_sendtext,
130         .devicestate = local_devicestate,
131         .bridged_channel = local_bridgedchannel,
132         .queryoption = local_queryoption,
133         .setoption = local_setoption,
134 };
135
136 /*! \brief the local pvt structure for all channels
137
138         The local channel pvt has two ast_chan objects - the "owner" and the "next channel", the outbound channel
139
140         ast_chan owner -> local_pvt -> ast_chan chan -> yet-another-pvt-depending-on-channel-type
141
142 */
143 struct local_pvt {
144         unsigned int flags;             /*!< Private flags */
145         char context[AST_MAX_CONTEXT];  /*!< Context to call */
146         char exten[AST_MAX_EXTENSION];  /*!< Extension to call */
147         struct ast_format_cap *reqcap;  /*!< Requested format capabilities */
148         struct ast_jb_conf jb_conf;     /*!< jitterbuffer configuration for this local channel */
149         struct ast_channel *owner;      /*!< Master Channel - Bridging happens here */
150         struct ast_channel *chan;       /*!< Outbound channel - PBX is run here */
151         struct ast_module_user *u_owner;/*!< reference to keep the module loaded while in use */
152         struct ast_module_user *u_chan; /*!< reference to keep the module loaded while in use */
153 };
154
155 #define LOCAL_ALREADY_MASQED  (1 << 0) /*!< Already masqueraded */
156 #define LOCAL_LAUNCHED_PBX    (1 << 1) /*!< PBX was launched */
157 #define LOCAL_NO_OPTIMIZATION (1 << 2) /*!< Do not optimize using masquerading */
158 #define LOCAL_BRIDGE          (1 << 3) /*!< Report back the "true" channel as being bridged to */
159 #define LOCAL_MOH_PASSTHRU    (1 << 4) /*!< Pass through music on hold start/stop frames */
160
161 /* 
162  * \brief Send a pvt in with no locks held and get all locks
163  *
164  * \note NO locks should be held prior to calling this function
165  * \note The pvt must have a ref held before calling this function
166  * \note if outchan or outowner is set != NULL after calling this function
167  *       those channels are locked and reffed.
168  * \note Batman.
169  */
170 static void awesome_locking(struct local_pvt *p, struct ast_channel **outchan, struct ast_channel **outowner)
171 {
172         struct ast_channel *chan = NULL;
173         struct ast_channel *owner = NULL;
174
175         for (;;) {
176                 ao2_lock(p);
177                 if (p->chan) {
178                         chan = p->chan;
179                         ast_channel_ref(chan);
180                 }
181                 if (p->owner) {
182                         owner = p->owner;
183                         ast_channel_ref(owner);
184                 }
185                 ao2_unlock(p);
186
187                 /* if we don't have both channels, then this is very easy */
188                 if (!owner || !chan) {
189                         if (owner) {
190                                 ast_channel_lock(owner);
191                         } else if(chan) {
192                                 ast_channel_lock(chan);
193                         }
194                         ao2_lock(p);
195                 } else {
196                         /* lock both channels first, then get the pvt lock */
197                         ast_channel_lock_both(chan, owner);
198                         ao2_lock(p);
199                 }
200
201                 /* Now that we have all the locks, validate that nothing changed */
202                 if (p->owner != owner || p->chan != chan) {
203                         if (owner) {
204                                 ast_channel_unlock(owner);
205                                 owner = ast_channel_unref(owner);
206                         }
207                         if (chan) {
208                                 ast_channel_unlock(chan);
209                                 chan = ast_channel_unref(chan);
210                         }
211                         ao2_unlock(p);
212                         continue;
213                 }
214
215                 break;
216         }
217         *outowner = p->owner;
218         *outchan = p->chan;
219 }
220
221 /* Called with ast locked */
222 static int local_setoption(struct ast_channel *ast, int option, void * data, int datalen)
223 {
224         int res = 0;
225         struct local_pvt *p = NULL;
226         struct ast_channel *otherchan = NULL;
227         ast_chan_write_info_t *write_info;
228
229         if (option != AST_OPTION_CHANNEL_WRITE) {
230                 return -1;
231         }
232
233         write_info = data;
234
235         if (write_info->version != AST_CHAN_WRITE_INFO_T_VERSION) {
236                 ast_log(LOG_ERROR, "The chan_write_info_t type has changed, and this channel hasn't been updated!\n");
237                 return -1;
238         }
239
240         /* get the tech pvt */
241         if (!(p = ast_channel_tech_pvt(ast))) {
242                 return -1;
243         }
244         ao2_ref(p, 1);
245         ast_channel_unlock(ast); /* Held when called, unlock before locking another channel */
246
247         /* get the channel we are supposed to write to */
248         ao2_lock(p);
249         otherchan = (write_info->chan == p->owner) ? p->chan : p->owner;
250         if (!otherchan || otherchan == write_info->chan) {
251                 res = -1;
252                 otherchan = NULL;
253                 ao2_unlock(p);
254                 goto setoption_cleanup;
255         }
256         ast_channel_ref(otherchan);
257
258         /* clear the pvt lock before grabbing the channel */
259         ao2_unlock(p);
260
261         ast_channel_lock(otherchan);
262         res = write_info->write_fn(otherchan, write_info->function, write_info->data, write_info->value);
263         ast_channel_unlock(otherchan);
264
265 setoption_cleanup:
266         if (p) {
267                 ao2_ref(p, -1);
268         }
269         if (otherchan) {
270                 ast_channel_unref(otherchan);
271         }
272         ast_channel_lock(ast); /* Lock back before we leave */
273         return res;
274 }
275
276 /*! \brief Adds devicestate to local channels */
277 static int local_devicestate(const char *data)
278 {
279         char *exten = ast_strdupa(data);
280         char *context = NULL, *opts = NULL;
281         int res;
282         struct local_pvt *lp;
283         struct ao2_iterator it;
284
285         if (!(context = strchr(exten, '@'))) {
286                 ast_log(LOG_WARNING, "Someone used Local/%s somewhere without a @context. This is bad.\n", exten);
287                 return AST_DEVICE_INVALID;
288         }
289
290         *context++ = '\0';
291
292         /* Strip options if they exist */
293         if ((opts = strchr(context, '/')))
294                 *opts = '\0';
295
296         ast_debug(3, "Checking if extension %s@%s exists (devicestate)\n", exten, context);
297
298         res = ast_exists_extension(NULL, context, exten, 1, NULL);
299         if (!res)
300                 return AST_DEVICE_INVALID;
301
302         res = AST_DEVICE_NOT_INUSE;
303
304         it = ao2_iterator_init(locals, 0);
305         while ((lp = ao2_iterator_next(&it))) {
306                 if (!strcmp(exten, lp->exten) && !strcmp(context, lp->context) && lp->owner) {
307                         res = AST_DEVICE_INUSE;
308                         ao2_ref(lp, -1);
309                         break;
310                 }
311                 ao2_ref(lp, -1);
312         }
313         ao2_iterator_destroy(&it);
314
315         return res;
316 }
317
318 /*! \brief Return the bridged channel of a Local channel */
319 static struct ast_channel *local_bridgedchannel(struct ast_channel *chan, struct ast_channel *bridge)
320 {
321         struct local_pvt *p = ast_channel_tech_pvt(bridge);
322         struct ast_channel *bridged = bridge;
323
324         if (!p) {
325                 ast_debug(1, "Asked for bridged channel on '%s'/'%s', returning <none>\n",
326                         ast_channel_name(chan), ast_channel_name(bridge));
327                 return NULL;
328         }
329
330         ao2_lock(p);
331
332         if (ast_test_flag(p, LOCAL_BRIDGE)) {
333                 /* Find the opposite channel */
334                 bridged = (bridge == p->owner ? p->chan : p->owner);
335
336                 /* Now see if the opposite channel is bridged to anything */
337                 if (!bridged) {
338                         bridged = bridge;
339                 } else if (ast_channel_internal_bridged_channel(bridged)) {
340                         bridged = ast_channel_internal_bridged_channel(bridged);
341                 }
342         }
343
344         ao2_unlock(p);
345
346         return bridged;
347 }
348
349 /* Called with ast locked */
350 static int local_queryoption(struct ast_channel *ast, int option, void *data, int *datalen)
351 {
352         struct local_pvt *p;
353         struct ast_channel *bridged = NULL;
354         struct ast_channel *tmp = NULL;
355         int res = 0;
356
357         if (option != AST_OPTION_T38_STATE) {
358                 /* AST_OPTION_T38_STATE is the only supported option at this time */
359                 return -1;
360         }
361
362         /* for some reason the channel is not locked in channel.c when this function is called */
363         if (!(p = ast_channel_tech_pvt(ast))) {
364                 return -1;
365         }
366
367         ao2_lock(p);
368         if (!(tmp = IS_OUTBOUND(ast, p) ? p->owner : p->chan)) {
369                 ao2_unlock(p);
370                 return -1;
371         }
372         ast_channel_ref(tmp);
373         ao2_unlock(p);
374         ast_channel_unlock(ast); /* Held when called, unlock before locking another channel */
375
376         ast_channel_lock(tmp);
377         if (!(bridged = ast_bridged_channel(tmp))) {
378                 res = -1;
379                 ast_channel_unlock(tmp);
380                 goto query_cleanup;
381         }
382         ast_channel_ref(bridged);
383         ast_channel_unlock(tmp);
384
385 query_cleanup:
386         if (bridged) {
387                 res = ast_channel_queryoption(bridged, option, data, datalen, 0);
388                 bridged = ast_channel_unref(bridged);
389         }
390         if (tmp) {
391                 tmp = ast_channel_unref(tmp);
392         }
393         ast_channel_lock(ast); /* Lock back before we leave */
394
395         return res;
396 }
397
398 /*! \brief queue a frame on a to either the p->owner or p->chan
399  *
400  * \note the local_pvt MUST have it's ref count bumped before entering this function and
401  * decremented after this function is called.  This is a side effect of the deadlock
402  * avoidance that is necessary to lock 2 channels and a tech_pvt.  Without a ref counted
403  * local_pvt, it is impossible to guarantee it will not be destroyed by another thread
404  * during deadlock avoidance.
405  */
406 static int local_queue_frame(struct local_pvt *p, int isoutbound, struct ast_frame *f,
407         struct ast_channel *us, int us_locked)
408 {
409         struct ast_channel *other = NULL;
410
411         /* Recalculate outbound channel */
412         other = isoutbound ? p->owner : p->chan;
413
414         if (!other) {
415                 return 0;
416         }
417
418         /* do not queue frame if generator is on both local channels */
419         if (us && ast_channel_generator(us) && ast_channel_generator(other)) {
420                 return 0;
421         }
422
423         /* grab a ref on the channel before unlocking the pvt,
424          * other can not go away from us now regardless of locking */
425         ast_channel_ref(other);
426         if (us && us_locked) {
427                 ast_channel_unlock(us);
428         }
429         ao2_unlock(p);
430
431         if (f->frametype == AST_FRAME_CONTROL && f->subclass.integer == AST_CONTROL_RINGING) {
432                 ast_setstate(other, AST_STATE_RINGING);
433         }
434         ast_queue_frame(other, f);
435
436         other = ast_channel_unref(other);
437         if (us && us_locked) {
438                 ast_channel_lock(us);
439         }
440         ao2_lock(p);
441
442         return 0;
443 }
444
445 static int local_answer(struct ast_channel *ast)
446 {
447         struct local_pvt *p = ast_channel_tech_pvt(ast);
448         int isoutbound;
449         int res = -1;
450
451         if (!p) {
452                 return -1;
453         }
454
455         ao2_lock(p);
456         ao2_ref(p, 1);
457         isoutbound = IS_OUTBOUND(ast, p);
458         if (isoutbound) {
459                 /* Pass along answer since somebody answered us */
460                 struct ast_frame answer = { AST_FRAME_CONTROL, { AST_CONTROL_ANSWER } };
461                 res = local_queue_frame(p, isoutbound, &answer, ast, 1);
462         } else {
463                 ast_log(LOG_WARNING, "Huh?  Local is being asked to answer?\n");
464         }
465         ao2_unlock(p);
466         ao2_ref(p, -1);
467         return res;
468 }
469
470 /*!
471  * \internal
472  * \note This function assumes that we're only called from the "outbound" local channel side
473  *
474  * \note it is assummed p is locked and reffed before entering this function
475  */
476 static void check_bridge(struct ast_channel *ast, struct local_pvt *p)
477 {
478         struct ast_channel *owner;
479         struct ast_channel *chan;
480         struct ast_channel *bridged_chan;
481         struct ast_frame *f;
482
483         /* Do a few conditional checks early on just to see if this optimization is possible */
484         if (ast_test_flag(p, LOCAL_NO_OPTIMIZATION | LOCAL_ALREADY_MASQED)
485                 || !p->chan || !p->owner) {
486                 return;
487         }
488
489         /* Safely get the channel bridged to p->chan */
490         chan = ast_channel_ref(p->chan);
491
492         ao2_unlock(p); /* don't call bridged channel with the pvt locked */
493         bridged_chan = ast_bridged_channel(chan);
494         ao2_lock(p);
495
496         chan = ast_channel_unref(chan);
497
498         /* since we had to unlock p to get the bridged chan, validate our
499          * data once again and verify the bridged channel is what we expect
500          * it to be in order to perform this optimization */
501         if (ast_test_flag(p, LOCAL_NO_OPTIMIZATION | LOCAL_ALREADY_MASQED)
502                 || !p->chan || !p->owner
503                 || (ast_channel_internal_bridged_channel(p->chan) != bridged_chan)) {
504                 return;
505         }
506
507         /* only do the masquerade if we are being called on the outbound channel,
508            if it has been bridged to another channel and if there are no pending
509            frames on the owner channel (because they would be transferred to the
510            outbound channel during the masquerade)
511         */
512         if (!ast_channel_internal_bridged_channel(p->chan) /* Not ast_bridged_channel!  Only go one step! */
513                 || !AST_LIST_EMPTY(ast_channel_readq(p->owner))
514                 || ast != p->chan /* Sanity check (should always be false) */) {
515                 return;
516         }
517
518         /* Masquerade bridged channel into owner */
519         /* Lock everything we need, one by one, and give up if
520            we can't get everything.  Remember, we'll get another
521            chance in just a little bit */
522         if (ast_channel_trylock(ast_channel_internal_bridged_channel(p->chan))) {
523                 return;
524         }
525         if (ast_check_hangup(ast_channel_internal_bridged_channel(p->chan))
526                 || ast_channel_trylock(p->owner)) {
527                 ast_channel_unlock(ast_channel_internal_bridged_channel(p->chan));
528                 return;
529         }
530
531         /*
532          * At this point we have 4 locks:
533          * p, p->chan (same as ast), p->chan->_bridge, p->owner
534          *
535          * Flush a voice or video frame on the outbound channel to make
536          * the queue empty faster so we can get optimized out.
537          */
538         f = AST_LIST_FIRST(ast_channel_readq(p->chan));
539         if (f && (f->frametype == AST_FRAME_VOICE || f->frametype == AST_FRAME_VIDEO)) {
540                 AST_LIST_REMOVE_HEAD(ast_channel_readq(p->chan), frame_list);
541                 ast_frfree(f);
542                 f = AST_LIST_FIRST(ast_channel_readq(p->chan));
543         }
544
545         if (f
546                 || ast_check_hangup(p->owner)
547                 || ast_channel_masquerade(p->owner, ast_channel_internal_bridged_channel(p->chan))) {
548                 ast_channel_unlock(p->owner);
549                 ast_channel_unlock(ast_channel_internal_bridged_channel(p->chan));
550                 return;
551         }
552
553         /* Masquerade got setup. */
554         ast_debug(4, "Masquerading %s <- %s\n",
555                 ast_channel_name(p->owner),
556                 ast_channel_name(ast_channel_internal_bridged_channel(p->chan)));
557         if (ast_channel_monitor(p->owner)
558                 && !ast_channel_monitor(ast_channel_internal_bridged_channel(p->chan))) {
559                 struct ast_channel_monitor *tmp;
560
561                 /* If a local channel is being monitored, we don't want a masquerade
562                  * to cause the monitor to go away. Since the masquerade swaps the monitors,
563                  * pre-swapping the monitors before the masquerade will ensure that the monitor
564                  * ends up where it is expected.
565                  */
566                 tmp = ast_channel_monitor(p->owner);
567                 ast_channel_monitor_set(p->owner, ast_channel_monitor(ast_channel_internal_bridged_channel(p->chan)));
568                 ast_channel_monitor_set(ast_channel_internal_bridged_channel(p->chan), tmp);
569         }
570         if (ast_channel_audiohooks(p->chan)) {
571                 struct ast_audiohook_list *audiohooks_swapper;
572
573                 audiohooks_swapper = ast_channel_audiohooks(p->chan);
574                 ast_channel_audiohooks_set(p->chan, ast_channel_audiohooks(p->owner));
575                 ast_channel_audiohooks_set(p->owner, audiohooks_swapper);
576         }
577
578         /* If any Caller ID was set, preserve it after masquerade like above. We must check
579          * to see if Caller ID was set because otherwise we'll mistakingly copy info not
580          * set from the dialplan and will overwrite the real channel Caller ID. The reason
581          * for this whole preswapping action is because the Caller ID is set on the channel
582          * thread (which is the to be masqueraded away local channel) before both local
583          * channels are optimized away.
584          */
585         if (ast_channel_caller(p->owner)->id.name.valid || ast_channel_caller(p->owner)->id.number.valid
586                 || ast_channel_caller(p->owner)->id.subaddress.valid || ast_channel_caller(p->owner)->ani.name.valid
587                 || ast_channel_caller(p->owner)->ani.number.valid || ast_channel_caller(p->owner)->ani.subaddress.valid) {
588                 SWAP(*ast_channel_caller(p->owner), *ast_channel_caller(ast_channel_internal_bridged_channel(p->chan)));
589         }
590         if (ast_channel_redirecting(p->owner)->from.name.valid || ast_channel_redirecting(p->owner)->from.number.valid
591                 || ast_channel_redirecting(p->owner)->from.subaddress.valid || ast_channel_redirecting(p->owner)->to.name.valid
592                 || ast_channel_redirecting(p->owner)->to.number.valid || ast_channel_redirecting(p->owner)->to.subaddress.valid) {
593                 SWAP(*ast_channel_redirecting(p->owner), *ast_channel_redirecting(ast_channel_internal_bridged_channel(p->chan)));
594         }
595         if (ast_channel_dialed(p->owner)->number.str || ast_channel_dialed(p->owner)->subaddress.valid) {
596                 SWAP(*ast_channel_dialed(p->owner), *ast_channel_dialed(ast_channel_internal_bridged_channel(p->chan)));
597         }
598         ast_app_group_update(p->chan, p->owner);
599         ast_set_flag(p, LOCAL_ALREADY_MASQED);
600
601         ast_channel_unlock(p->owner);
602         ast_channel_unlock(ast_channel_internal_bridged_channel(p->chan));
603
604         /* Do the masquerade now. */
605         owner = ast_channel_ref(p->owner);
606         ao2_unlock(p);
607         ast_channel_unlock(ast);
608         ast_do_masquerade(owner);
609         ast_channel_unref(owner);
610         ast_channel_lock(ast);
611         ao2_lock(p);
612 }
613
614 static struct ast_frame  *local_read(struct ast_channel *ast)
615 {
616         return &ast_null_frame;
617 }
618
619 static int local_write(struct ast_channel *ast, struct ast_frame *f)
620 {
621         struct local_pvt *p = ast_channel_tech_pvt(ast);
622         int res = -1;
623         int isoutbound;
624
625         if (!p) {
626                 return -1;
627         }
628
629         /* Just queue for delivery to the other side */
630         ao2_ref(p, 1); /* ref for local_queue_frame */
631         ao2_lock(p);
632         isoutbound = IS_OUTBOUND(ast, p);
633
634         if (isoutbound
635                 && (f->frametype == AST_FRAME_VOICE || f->frametype == AST_FRAME_VIDEO)) {
636                 check_bridge(ast, p);
637         }
638
639         if (!ast_test_flag(p, LOCAL_ALREADY_MASQED)) {
640                 res = local_queue_frame(p, isoutbound, f, ast, 1);
641         } else {
642                 ast_debug(1, "Not posting to '%s' queue since already masqueraded out\n",
643                         ast_channel_name(ast));
644                 res = 0;
645         }
646         ao2_unlock(p);
647         ao2_ref(p, -1);
648
649         return res;
650 }
651
652 static int local_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
653 {
654         struct local_pvt *p = ast_channel_tech_pvt(newchan);
655
656         if (!p) {
657                 return -1;
658         }
659
660         ao2_lock(p);
661
662         if ((p->owner != oldchan) && (p->chan != oldchan)) {
663                 ast_log(LOG_WARNING, "Old channel wasn't %p but was %p/%p\n", oldchan, p->owner, p->chan);
664                 ao2_unlock(p);
665                 return -1;
666         }
667         if (p->owner == oldchan) {
668                 p->owner = newchan;
669         } else {
670                 p->chan = newchan;
671         }
672
673         /* Do not let a masquerade cause a Local channel to be bridged to itself! */
674         if (!ast_check_hangup(newchan) && ((p->owner && ast_channel_internal_bridged_channel(p->owner) == p->chan) || (p->chan && ast_channel_internal_bridged_channel(p->chan) == p->owner))) {
675                 ast_log(LOG_WARNING, "You can not bridge a Local channel to itself!\n");
676                 ao2_unlock(p);
677                 ast_queue_hangup(newchan);
678                 return -1;
679         }
680
681         ao2_unlock(p);
682         return 0;
683 }
684
685 static int local_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen)
686 {
687         struct local_pvt *p = ast_channel_tech_pvt(ast);
688         int res = 0;
689         struct ast_frame f = { AST_FRAME_CONTROL, };
690         int isoutbound;
691
692         if (!p) {
693                 return -1;
694         }
695
696         ao2_ref(p, 1); /* ref for local_queue_frame */
697
698         /* If this is an MOH hold or unhold, do it on the Local channel versus real channel */
699         if (!ast_test_flag(p, LOCAL_MOH_PASSTHRU) && condition == AST_CONTROL_HOLD) {
700                 ast_moh_start(ast, data, NULL);
701         } else if (!ast_test_flag(p, LOCAL_MOH_PASSTHRU) && condition == AST_CONTROL_UNHOLD) {
702                 ast_moh_stop(ast);
703         } else if (condition == AST_CONTROL_CONNECTED_LINE || condition == AST_CONTROL_REDIRECTING) {
704                 struct ast_channel *this_channel;
705                 struct ast_channel *the_other_channel;
706                 /* A connected line update frame may only contain a partial amount of data, such
707                  * as just a source, or just a ton, and not the full amount of information. However,
708                  * the collected information is all stored in the outgoing channel's connectedline
709                  * structure, so when receiving a connected line update on an outgoing local channel,
710                  * we need to transmit the collected connected line information instead of whatever
711                  * happens to be in this control frame. The same applies for redirecting information, which
712                  * is why it is handled here as well.*/
713                 ao2_lock(p);
714                 isoutbound = IS_OUTBOUND(ast, p);
715                 if (isoutbound) {
716                         this_channel = p->chan;
717                         the_other_channel = p->owner;
718                 } else {
719                         this_channel = p->owner;
720                         the_other_channel = p->chan;
721                 }
722                 if (the_other_channel) {
723                         unsigned char frame_data[1024];
724                         if (condition == AST_CONTROL_CONNECTED_LINE) {
725                                 if (isoutbound) {
726                                         ast_connected_line_copy_to_caller(ast_channel_caller(the_other_channel), ast_channel_connected(this_channel));
727                                 }
728                                 f.datalen = ast_connected_line_build_data(frame_data, sizeof(frame_data), ast_channel_connected(this_channel), NULL);
729                         } else {
730                                 f.datalen = ast_redirecting_build_data(frame_data, sizeof(frame_data), ast_channel_redirecting(this_channel), NULL);
731                         }
732                         f.subclass.integer = condition;
733                         f.data.ptr = frame_data;
734                         res = local_queue_frame(p, isoutbound, &f, ast, 1);
735                 }
736                 ao2_unlock(p);
737         } else {
738                 /* Queue up a frame representing the indication as a control frame */
739                 ao2_lock(p);
740                 /*
741                  * Block -1 stop tones events if we are to be optimized out.  We
742                  * don't need a flurry of these events on a local channel chain
743                  * when initially connected to slow the optimization process.
744                  */
745                 if (0 <= condition || ast_test_flag(p, LOCAL_NO_OPTIMIZATION)) {
746                         isoutbound = IS_OUTBOUND(ast, p);
747                         f.subclass.integer = condition;
748                         f.data.ptr = (void *) data;
749                         f.datalen = datalen;
750                         res = local_queue_frame(p, isoutbound, &f, ast, 1);
751                 } else {
752                         ast_debug(4, "Blocked indication %d\n", condition);
753                 }
754                 ao2_unlock(p);
755         }
756
757         ao2_ref(p, -1);
758         return res;
759 }
760
761 static int local_digit_begin(struct ast_channel *ast, char digit)
762 {
763         struct local_pvt *p = ast_channel_tech_pvt(ast);
764         int res = -1;
765         struct ast_frame f = { AST_FRAME_DTMF_BEGIN, };
766         int isoutbound;
767
768         if (!p) {
769                 return -1;
770         }
771
772         ao2_ref(p, 1); /* ref for local_queue_frame */
773         ao2_lock(p);
774         isoutbound = IS_OUTBOUND(ast, p);
775         f.subclass.integer = digit;
776         res = local_queue_frame(p, isoutbound, &f, ast, 0);
777         ao2_unlock(p);
778         ao2_ref(p, -1);
779
780         return res;
781 }
782
783 static int local_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
784 {
785         struct local_pvt *p = ast_channel_tech_pvt(ast);
786         int res = -1;
787         struct ast_frame f = { AST_FRAME_DTMF_END, };
788         int isoutbound;
789
790         if (!p) {
791                 return -1;
792         }
793
794         ao2_ref(p, 1); /* ref for local_queue_frame */
795         ao2_lock(p);
796         isoutbound = IS_OUTBOUND(ast, p);
797         f.subclass.integer = digit;
798         f.len = duration;
799         res = local_queue_frame(p, isoutbound, &f, ast, 0);
800         ao2_unlock(p);
801         ao2_ref(p, -1);
802
803         return res;
804 }
805
806 static int local_sendtext(struct ast_channel *ast, const char *text)
807 {
808         struct local_pvt *p = ast_channel_tech_pvt(ast);
809         int res = -1;
810         struct ast_frame f = { AST_FRAME_TEXT, };
811         int isoutbound;
812
813         if (!p) {
814                 return -1;
815         }
816
817         ao2_lock(p);
818         ao2_ref(p, 1); /* ref for local_queue_frame */
819         isoutbound = IS_OUTBOUND(ast, p);
820         f.data.ptr = (char *) text;
821         f.datalen = strlen(text) + 1;
822         res = local_queue_frame(p, isoutbound, &f, ast, 0);
823         ao2_unlock(p);
824         ao2_ref(p, -1);
825         return res;
826 }
827
828 static int local_sendhtml(struct ast_channel *ast, int subclass, const char *data, int datalen)
829 {
830         struct local_pvt *p = ast_channel_tech_pvt(ast);
831         int res = -1;
832         struct ast_frame f = { AST_FRAME_HTML, };
833         int isoutbound;
834
835         if (!p) {
836                 return -1;
837         }
838
839         ao2_lock(p);
840         ao2_ref(p, 1); /* ref for local_queue_frame */
841         isoutbound = IS_OUTBOUND(ast, p);
842         f.subclass.integer = subclass;
843         f.data.ptr = (char *)data;
844         f.datalen = datalen;
845         res = local_queue_frame(p, isoutbound, &f, ast, 0);
846         ao2_unlock(p);
847         ao2_ref(p, -1);
848
849         return res;
850 }
851
852 /*! \brief Initiate new call, part of PBX interface
853  *         dest is the dial string */
854 static int local_call(struct ast_channel *ast, const char *dest, int timeout)
855 {
856         struct local_pvt *p = ast_channel_tech_pvt(ast);
857         int pvt_locked = 0;
858
859         struct ast_channel *owner = NULL;
860         struct ast_channel *chan = NULL;
861         int res;
862         struct ast_var_t *varptr = NULL, *new;
863         size_t len, namelen;
864         char *reduced_dest = ast_strdupa(dest);
865         char *slash;
866         const char *exten;
867         const char *context;
868
869         if (!p) {
870                 return -1;
871         }
872
873         /* since we are letting go of channel locks that were locked coming into
874          * this function, then we need to give the tech pvt a ref */
875         ao2_ref(p, 1);
876         ast_channel_unlock(ast);
877
878         awesome_locking(p, &chan, &owner);
879         pvt_locked = 1;
880
881         if (owner != ast) {
882                 res = -1;
883                 goto return_cleanup;
884         }
885
886         if (!owner || !chan) {
887                 res = -1;
888                 goto return_cleanup;
889         }
890
891         /*
892          * Note that cid_num and cid_name aren't passed in the ast_channel_alloc
893          * call, so it's done here instead.
894          *
895          * All these failure points just return -1. The individual strings will
896          * be cleared when we destroy the channel.
897          */
898         ast_party_redirecting_copy(ast_channel_redirecting(chan), ast_channel_redirecting(owner));
899
900         ast_party_dialed_copy(ast_channel_dialed(chan), ast_channel_dialed(owner));
901
902         ast_connected_line_copy_to_caller(ast_channel_caller(chan), ast_channel_connected(owner));
903         ast_connected_line_copy_from_caller(ast_channel_connected(chan), ast_channel_caller(owner));
904
905         ast_channel_language_set(chan, ast_channel_language(owner));
906         ast_channel_accountcode_set(chan, ast_channel_accountcode(owner));
907         ast_channel_musicclass_set(chan, ast_channel_musicclass(owner));
908         ast_cdr_update(chan);
909
910         ast_channel_cc_params_init(chan, ast_channel_get_cc_config_params(owner));
911
912         /* Make sure we inherit the ANSWERED_ELSEWHERE flag if it's set on the queue/dial call request in the dialplan */
913         if (ast_test_flag(ast_channel_flags(ast), AST_FLAG_ANSWERED_ELSEWHERE)) {
914                 ast_set_flag(ast_channel_flags(chan), AST_FLAG_ANSWERED_ELSEWHERE);
915         }
916
917         /* copy the channel variables from the incoming channel to the outgoing channel */
918         /* Note that due to certain assumptions, they MUST be in the same order */
919         AST_LIST_TRAVERSE(ast_channel_varshead(owner), varptr, entries) {
920                 namelen = strlen(varptr->name);
921                 len = sizeof(struct ast_var_t) + namelen + strlen(varptr->value) + 2;
922                 if ((new = ast_calloc(1, len))) {
923                         memcpy(new, varptr, len);
924                         new->value = &(new->name[0]) + namelen + 1;
925                         AST_LIST_INSERT_TAIL(ast_channel_varshead(chan), new, entries);
926                 }
927         }
928         ast_channel_datastore_inherit(owner, chan);
929         /* If the local channel has /n or /b on the end of it,
930          * we need to lop that off for our argument to setting
931          * up the CC_INTERFACES variable
932          */
933         if ((slash = strrchr(reduced_dest, '/'))) {
934                 *slash = '\0';
935         }
936         ast_set_cc_interfaces_chanvar(chan, reduced_dest);
937
938         exten = ast_strdupa(ast_channel_exten(chan));
939         context = ast_strdupa(ast_channel_context(chan));
940
941         ao2_unlock(p);
942         pvt_locked = 0;
943
944         ast_channel_unlock(chan);
945
946         if (!ast_exists_extension(chan, context, exten, 1,
947                 S_COR(ast_channel_caller(owner)->id.number.valid, ast_channel_caller(owner)->id.number.str, NULL))) {
948                 ast_log(LOG_NOTICE, "No such extension/context %s@%s while calling Local channel\n", exten, context);
949                 res = -1;
950                 chan = ast_channel_unref(chan); /* we already unlocked it, so clear it hear so the cleanup label won't touch it. */
951                 goto return_cleanup;
952         }
953
954         manager_event(EVENT_FLAG_CALL, "LocalBridge",
955                       "Channel1: %s\r\n"
956                       "Channel2: %s\r\n"
957                       "Uniqueid1: %s\r\n"
958                       "Uniqueid2: %s\r\n"
959                       "Context: %s\r\n"
960                       "Exten: %s\r\n"
961                       "LocalOptimization: %s\r\n",
962                         ast_channel_name(p->owner), ast_channel_name(p->chan), ast_channel_uniqueid(p->owner), ast_channel_uniqueid(p->chan),
963                         p->context, p->exten,
964                         ast_test_flag(p, LOCAL_NO_OPTIMIZATION) ? "Yes" : "No");
965
966
967         /* Start switch on sub channel */
968         if (!(res = ast_pbx_start(chan))) {
969                 ao2_lock(p);
970                 ast_set_flag(p, LOCAL_LAUNCHED_PBX);
971                 ao2_unlock(p);
972         }
973         chan = ast_channel_unref(chan); /* chan is already unlocked, clear it here so the cleanup lable won't touch it. */
974
975 return_cleanup:
976         if (p) {
977                 if (pvt_locked) {
978                         ao2_unlock(p);
979                 }
980                 ao2_ref(p, -1);
981         }
982         if (chan) {
983                 ast_channel_unlock(chan);
984                 chan = ast_channel_unref(chan);
985         }
986
987         /* owner is supposed to be == to ast,  if it
988          * is, don't unlock it because ast must exit locked */
989         if (owner) {
990                 if (owner != ast) {
991                         ast_channel_unlock(owner);
992                         ast_channel_lock(ast);
993                 }
994                 owner = ast_channel_unref(owner);
995         } else {
996                 /* we have to exit with ast locked */
997                 ast_channel_lock(ast);
998         }
999
1000         return res;
1001 }
1002
1003 /*! \brief Hangup a call through the local proxy channel */
1004 static int local_hangup(struct ast_channel *ast)
1005 {
1006         struct local_pvt *p = ast_channel_tech_pvt(ast);
1007         int isoutbound;
1008         int hangup_chan = 0;
1009         int res = 0;
1010         struct ast_frame f = { AST_FRAME_CONTROL, { AST_CONTROL_HANGUP }, .data.uint32 = ast_channel_hangupcause(ast) };
1011         struct ast_channel *owner = NULL;
1012         struct ast_channel *chan = NULL;
1013
1014         if (!p) {
1015                 return -1;
1016         }
1017
1018         /* give the pvt a ref since we are unlocking the channel. */
1019         ao2_ref(p, 1);
1020
1021         /* the pvt isn't going anywhere, we gave it a ref */
1022         ast_channel_unlock(ast);
1023
1024         /* lock everything */
1025         awesome_locking(p, &chan, &owner);
1026
1027         if (ast != chan && ast != owner) {
1028                 res = -1;
1029                 goto local_hangup_cleanup;
1030         }
1031
1032         isoutbound = IS_OUTBOUND(ast, p); /* just comparing pointer of ast */
1033
1034         if (p->chan && ast_test_flag(ast_channel_flags(ast), AST_FLAG_ANSWERED_ELSEWHERE)) {
1035                 ast_set_flag(ast_channel_flags(p->chan), AST_FLAG_ANSWERED_ELSEWHERE);
1036                 ast_debug(2, "This local call has the ANSWERED_ELSEWHERE flag set.\n");
1037         }
1038
1039         if (isoutbound) {
1040                 const char *status = pbx_builtin_getvar_helper(p->chan, "DIALSTATUS");
1041                 if ((status) && (p->owner)) {
1042                         ast_channel_hangupcause_set(p->owner, ast_channel_hangupcause(p->chan));
1043                         pbx_builtin_setvar_helper(p->owner, "CHANLOCALSTATUS", status);
1044                 }
1045
1046                 ast_clear_flag(p, LOCAL_LAUNCHED_PBX);
1047                 ast_module_user_remove(p->u_chan);
1048                 p->chan = NULL;
1049         } else {
1050                 ast_module_user_remove(p->u_owner);
1051                 if (p->chan) {
1052                         ast_queue_hangup(p->chan);
1053                 }
1054                 p->owner = NULL;
1055         }
1056
1057         ast_channel_tech_pvt_set(ast, NULL); /* this is one of our locked channels, doesn't matter which */
1058
1059         if (!p->owner && !p->chan) {
1060                 ao2_unlock(p);
1061                 /* Remove from list */
1062                 ao2_unlink(locals, p);
1063                 ao2_ref(p, -1);
1064                 p = NULL;
1065                 res = 0;
1066                 goto local_hangup_cleanup;
1067         }
1068         if (p->chan && !ast_test_flag(p, LOCAL_LAUNCHED_PBX)) {
1069                 /* Need to actually hangup since there is no PBX */
1070                 hangup_chan = 1;
1071         } else {
1072                 local_queue_frame(p, isoutbound, &f, NULL, 0);
1073         }
1074
1075 local_hangup_cleanup:
1076         if (p) {
1077                 ao2_unlock(p);
1078                 ao2_ref(p, -1);
1079         }
1080         if (chan) {
1081                 ast_channel_unlock(chan);
1082                 if (hangup_chan) {
1083                         ast_hangup(chan);
1084                 }
1085                 chan = ast_channel_unref(chan);
1086         }
1087         if (owner) {
1088                 ast_channel_unlock(owner);
1089                 owner = ast_channel_unref(owner);
1090         }
1091
1092         /* leave with the same stupid channel locked that came in */
1093         ast_channel_lock(ast);
1094         return res;
1095 }
1096
1097 static void local_destroy(void *obj)
1098 {
1099         struct local_pvt *pvt = obj;
1100         pvt->reqcap = ast_format_cap_destroy(pvt->reqcap);
1101 }
1102
1103 /*! \brief Create a call structure */
1104 static struct local_pvt *local_alloc(const char *data, struct ast_format_cap *cap)
1105 {
1106         struct local_pvt *tmp = NULL;
1107         char *c = NULL, *opts = NULL;
1108
1109         if (!(tmp = ao2_alloc(sizeof(*tmp), local_destroy))) {
1110                 return NULL;
1111         }
1112         if (!(tmp->reqcap = ast_format_cap_dup(cap))) {
1113                 ao2_ref(tmp, -1);
1114                 return NULL;
1115         }
1116
1117         /* Initialize private structure information */
1118         ast_copy_string(tmp->exten, data, sizeof(tmp->exten));
1119
1120         memcpy(&tmp->jb_conf, &g_jb_conf, sizeof(tmp->jb_conf));
1121
1122         /* Look for options */
1123         if ((opts = strchr(tmp->exten, '/'))) {
1124                 *opts++ = '\0';
1125                 if (strchr(opts, 'n'))
1126                         ast_set_flag(tmp, LOCAL_NO_OPTIMIZATION);
1127                 if (strchr(opts, 'j')) {
1128                         if (ast_test_flag(tmp, LOCAL_NO_OPTIMIZATION))
1129                                 ast_set_flag(&tmp->jb_conf, AST_JB_ENABLED);
1130                         else {
1131                                 ast_log(LOG_ERROR, "You must use the 'n' option for chan_local "
1132                                         "to use the 'j' option to enable the jitterbuffer\n");
1133                         }
1134                 }
1135                 if (strchr(opts, 'b')) {
1136                         ast_set_flag(tmp, LOCAL_BRIDGE);
1137                 }
1138                 if (strchr(opts, 'm')) {
1139                         ast_set_flag(tmp, LOCAL_MOH_PASSTHRU);
1140                 }
1141         }
1142
1143         /* Look for a context */
1144         if ((c = strchr(tmp->exten, '@')))
1145                 *c++ = '\0';
1146
1147         ast_copy_string(tmp->context, c ? c : "default", sizeof(tmp->context));
1148 #if 0
1149         /* We can't do this check here, because we don't know the CallerID yet, and
1150          * the CallerID could potentially affect what step is actually taken (or
1151          * even if that step exists). */
1152         if (!ast_exists_extension(NULL, tmp->context, tmp->exten, 1, NULL)) {
1153                 ast_log(LOG_NOTICE, "No such extension/context %s@%s creating local channel\n", tmp->exten, tmp->context);
1154                 tmp = local_pvt_destroy(tmp);
1155         } else {
1156 #endif
1157                 /* Add to list */
1158                 ao2_link(locals, tmp);
1159 #if 0
1160         }
1161 #endif
1162         return tmp; /* this is returned with a ref */
1163 }
1164
1165 /*! \brief Start new local channel */
1166 static struct ast_channel *local_new(struct local_pvt *p, int state, const char *linkedid)
1167 {
1168         struct ast_channel *tmp = NULL, *tmp2 = NULL;
1169         int randnum = ast_random() & 0xffff;
1170         struct ast_format fmt;
1171         const char *t;
1172         int ama;
1173
1174         /* Allocate two new Asterisk channels */
1175         /* safe accountcode */
1176         if (p->owner && ast_channel_accountcode(p->owner))
1177                 t = ast_channel_accountcode(p->owner);
1178         else
1179                 t = "";
1180
1181         if (p->owner)
1182                 ama = ast_channel_amaflags(p->owner);
1183         else
1184                 ama = 0;
1185
1186         /* Make sure that the ;2 channel gets the same linkedid as ;1. You can't pass linkedid to both
1187          * allocations since if linkedid isn't set, then each channel will generate its own linkedid. */
1188         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)) 
1189                 || !(tmp2 = ast_channel_alloc(1, AST_STATE_RING, 0, 0, t, p->exten, p->context, ast_channel_linkedid(tmp), ama, "Local/%s@%s-%04x;2", p->exten, p->context, randnum))) {
1190                 if (tmp) {
1191                         tmp = ast_channel_release(tmp);
1192                 }
1193                 ast_log(LOG_WARNING, "Unable to allocate channel structure(s)\n");
1194                 return NULL;
1195         }
1196
1197         ast_channel_tech_set(tmp, &local_tech);
1198         ast_channel_tech_set(tmp2, &local_tech);
1199
1200         ast_format_cap_copy(ast_channel_nativeformats(tmp), p->reqcap);
1201         ast_format_cap_copy(ast_channel_nativeformats(tmp2), p->reqcap);
1202
1203         /* Determine our read/write format and set it on each channel */
1204         ast_best_codec(p->reqcap, &fmt);
1205         ast_format_copy(ast_channel_writeformat(tmp), &fmt);
1206         ast_format_copy(ast_channel_writeformat(tmp2), &fmt);
1207         ast_format_copy(ast_channel_rawwriteformat(tmp), &fmt);
1208         ast_format_copy(ast_channel_rawwriteformat(tmp2), &fmt);
1209         ast_format_copy(ast_channel_readformat(tmp), &fmt);
1210         ast_format_copy(ast_channel_readformat(tmp2), &fmt);
1211         ast_format_copy(ast_channel_rawreadformat(tmp), &fmt);
1212         ast_format_copy(ast_channel_rawreadformat(tmp2), &fmt);
1213
1214         ast_channel_tech_pvt_set(tmp, p);
1215         ast_channel_tech_pvt_set(tmp2, p);
1216
1217         p->owner = tmp;
1218         p->chan = tmp2;
1219         p->u_owner = ast_module_user_add(p->owner);
1220         p->u_chan = ast_module_user_add(p->chan);
1221
1222         ast_channel_context_set(tmp, p->context);
1223         ast_channel_context_set(tmp2, p->context);
1224         ast_channel_exten_set(tmp2, p->exten);
1225         ast_channel_priority_set(tmp, 1);
1226         ast_channel_priority_set(tmp2, 1);
1227
1228         ast_jb_configure(tmp, &p->jb_conf);
1229
1230         return tmp;
1231 }
1232
1233 /*! \brief Part of PBX interface */
1234 static struct ast_channel *local_request(const char *type, struct ast_format_cap *cap, const struct ast_channel *requestor, const char *data, int *cause)
1235 {
1236         struct local_pvt *p;
1237         struct ast_channel *chan;
1238
1239         /* Allocate a new private structure and then Asterisk channel */
1240         p = local_alloc(data, cap);
1241         if (!p) {
1242                 return NULL;
1243         }
1244         chan = local_new(p, AST_STATE_DOWN, requestor ? ast_channel_linkedid(requestor) : NULL);
1245         if (!chan) {
1246                 ao2_unlink(locals, p);
1247         } else if (ast_channel_cc_params_init(chan, requestor ? ast_channel_get_cc_config_params((struct ast_channel *)requestor) : NULL)) {
1248                 ao2_unlink(locals, p);
1249                 p->owner = ast_channel_release(p->owner);
1250                 ast_module_user_remove(p->u_owner);
1251                 p->chan = ast_channel_release(p->chan);
1252                 ast_module_user_remove(p->u_chan);
1253                 chan = NULL;
1254         }
1255         ao2_ref(p, -1); /* kill the ref from the alloc */
1256
1257         return chan;
1258 }
1259
1260 /*! \brief CLI command "local show channels" */
1261 static char *locals_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1262 {
1263         struct local_pvt *p = NULL;
1264         struct ao2_iterator it;
1265
1266         switch (cmd) {
1267         case CLI_INIT:
1268                 e->command = "local show channels";
1269                 e->usage =
1270                         "Usage: local show channels\n"
1271                         "       Provides summary information on active local proxy channels.\n";
1272                 return NULL;
1273         case CLI_GENERATE:
1274                 return NULL;
1275         }
1276
1277         if (a->argc != 3) {
1278                 return CLI_SHOWUSAGE;
1279         }
1280
1281         if (ao2_container_count(locals) == 0) {
1282                 ast_cli(a->fd, "No local channels in use\n");
1283                 return RESULT_SUCCESS;
1284         }
1285
1286         it = ao2_iterator_init(locals, 0);
1287         while ((p = ao2_iterator_next(&it))) {
1288                 ao2_lock(p);
1289                 ast_cli(a->fd, "%s -- %s@%s\n", p->owner ? ast_channel_name(p->owner) : "<unowned>", p->exten, p->context);
1290                 ao2_unlock(p);
1291                 ao2_ref(p, -1);
1292         }
1293         ao2_iterator_destroy(&it);
1294
1295         return CLI_SUCCESS;
1296 }
1297
1298 static struct ast_cli_entry cli_local[] = {
1299         AST_CLI_DEFINE(locals_show, "List status of local channels"),
1300 };
1301
1302 static int manager_optimize_away(struct mansession *s, const struct message *m)
1303 {
1304         const char *channel;
1305         struct local_pvt *p, *tmp = NULL;
1306         struct ast_channel *c;
1307         int found = 0;
1308         struct ao2_iterator it;
1309
1310         channel = astman_get_header(m, "Channel");
1311
1312         if (ast_strlen_zero(channel)) {
1313                 astman_send_error(s, m, "'Channel' not specified.");
1314                 return 0;
1315         }
1316
1317         c = ast_channel_get_by_name(channel);
1318         if (!c) {
1319                 astman_send_error(s, m, "Channel does not exist.");
1320                 return 0;
1321         }
1322
1323         p = ast_channel_tech_pvt(c);
1324         ast_channel_unref(c);
1325         c = NULL;
1326
1327         it = ao2_iterator_init(locals, 0);
1328         while ((tmp = ao2_iterator_next(&it))) {
1329                 if (tmp == p) {
1330                         ao2_lock(tmp);
1331                         found = 1;
1332                         ast_clear_flag(tmp, LOCAL_NO_OPTIMIZATION);
1333                         ao2_unlock(tmp);
1334                         ao2_ref(tmp, -1);
1335                         break;
1336                 }
1337                 ao2_ref(tmp, -1);
1338         }
1339         ao2_iterator_destroy(&it);
1340
1341         if (found) {
1342                 astman_send_ack(s, m, "Queued channel to be optimized away");
1343         } else {
1344                 astman_send_error(s, m, "Unable to find channel");
1345         }
1346
1347         return 0;
1348 }
1349
1350
1351 static int locals_cmp_cb(void *obj, void *arg, int flags)
1352 {
1353         return (obj == arg) ? CMP_MATCH : 0;
1354 }
1355
1356 /*! \brief Load module into PBX, register channel */
1357 static int load_module(void)
1358 {
1359         if (!(local_tech.capabilities = ast_format_cap_alloc())) {
1360                 return AST_MODULE_LOAD_FAILURE;
1361         }
1362         ast_format_cap_add_all(local_tech.capabilities);
1363
1364         if (!(locals = ao2_container_alloc(BUCKET_SIZE, NULL, locals_cmp_cb))) {
1365                 ast_format_cap_destroy(local_tech.capabilities);
1366                 return AST_MODULE_LOAD_FAILURE;
1367         }
1368
1369         /* Make sure we can register our channel type */
1370         if (ast_channel_register(&local_tech)) {
1371                 ast_log(LOG_ERROR, "Unable to register channel class 'Local'\n");
1372                 ao2_ref(locals, -1);
1373                 ast_format_cap_destroy(local_tech.capabilities);
1374                 return AST_MODULE_LOAD_FAILURE;
1375         }
1376         ast_cli_register_multiple(cli_local, sizeof(cli_local) / sizeof(struct ast_cli_entry));
1377         ast_manager_register_xml("LocalOptimizeAway", EVENT_FLAG_SYSTEM|EVENT_FLAG_CALL, manager_optimize_away);
1378
1379         return AST_MODULE_LOAD_SUCCESS;
1380 }
1381
1382 /*! \brief Unload the local proxy channel from Asterisk */
1383 static int unload_module(void)
1384 {
1385         struct local_pvt *p = NULL;
1386         struct ao2_iterator it;
1387
1388         /* First, take us out of the channel loop */
1389         ast_cli_unregister_multiple(cli_local, sizeof(cli_local) / sizeof(struct ast_cli_entry));
1390         ast_manager_unregister("LocalOptimizeAway");
1391         ast_channel_unregister(&local_tech);
1392
1393         it = ao2_iterator_init(locals, 0);
1394         while ((p = ao2_iterator_next(&it))) {
1395                 if (p->owner) {
1396                         ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
1397                 }
1398                 ao2_ref(p, -1);
1399         }
1400         ao2_iterator_destroy(&it);
1401         ao2_ref(locals, -1);
1402
1403         ast_format_cap_destroy(local_tech.capabilities);
1404         return 0;
1405 }
1406
1407 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Local Proxy Channel (Note: used internally by other modules)",
1408                 .load = load_module,
1409                 .unload = unload_module,
1410                 .load_pri = AST_MODPRI_CHANNEL_DRIVER,
1411         );