bed9eebdcdfae3dfbd120d311f476a3b20748892
[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;
863         struct ast_var_t *clone_var;
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                 clone_var = ast_var_assign(varptr->name, varptr->value);
921                 if (clone_var) {
922                         AST_LIST_INSERT_TAIL(ast_channel_varshead(chan), clone_var, entries);
923                 }
924         }
925         ast_channel_datastore_inherit(owner, chan);
926         /* If the local channel has /n or /b on the end of it,
927          * we need to lop that off for our argument to setting
928          * up the CC_INTERFACES variable
929          */
930         if ((slash = strrchr(reduced_dest, '/'))) {
931                 *slash = '\0';
932         }
933         ast_set_cc_interfaces_chanvar(chan, reduced_dest);
934
935         exten = ast_strdupa(ast_channel_exten(chan));
936         context = ast_strdupa(ast_channel_context(chan));
937
938         ao2_unlock(p);
939         pvt_locked = 0;
940
941         ast_channel_unlock(chan);
942
943         if (!ast_exists_extension(chan, context, exten, 1,
944                 S_COR(ast_channel_caller(owner)->id.number.valid, ast_channel_caller(owner)->id.number.str, NULL))) {
945                 ast_log(LOG_NOTICE, "No such extension/context %s@%s while calling Local channel\n", exten, context);
946                 res = -1;
947                 chan = ast_channel_unref(chan); /* we already unlocked it, so clear it hear so the cleanup label won't touch it. */
948                 goto return_cleanup;
949         }
950
951         manager_event(EVENT_FLAG_CALL, "LocalBridge",
952                       "Channel1: %s\r\n"
953                       "Channel2: %s\r\n"
954                       "Uniqueid1: %s\r\n"
955                       "Uniqueid2: %s\r\n"
956                       "Context: %s\r\n"
957                       "Exten: %s\r\n"
958                       "LocalOptimization: %s\r\n",
959                         ast_channel_name(p->owner), ast_channel_name(p->chan), ast_channel_uniqueid(p->owner), ast_channel_uniqueid(p->chan),
960                         p->context, p->exten,
961                         ast_test_flag(p, LOCAL_NO_OPTIMIZATION) ? "Yes" : "No");
962
963
964         /* Start switch on sub channel */
965         if (!(res = ast_pbx_start(chan))) {
966                 ao2_lock(p);
967                 ast_set_flag(p, LOCAL_LAUNCHED_PBX);
968                 ao2_unlock(p);
969         }
970         chan = ast_channel_unref(chan); /* chan is already unlocked, clear it here so the cleanup lable won't touch it. */
971
972 return_cleanup:
973         if (p) {
974                 if (pvt_locked) {
975                         ao2_unlock(p);
976                 }
977                 ao2_ref(p, -1);
978         }
979         if (chan) {
980                 ast_channel_unlock(chan);
981                 chan = ast_channel_unref(chan);
982         }
983
984         /* owner is supposed to be == to ast,  if it
985          * is, don't unlock it because ast must exit locked */
986         if (owner) {
987                 if (owner != ast) {
988                         ast_channel_unlock(owner);
989                         ast_channel_lock(ast);
990                 }
991                 owner = ast_channel_unref(owner);
992         } else {
993                 /* we have to exit with ast locked */
994                 ast_channel_lock(ast);
995         }
996
997         return res;
998 }
999
1000 /*! \brief Hangup a call through the local proxy channel */
1001 static int local_hangup(struct ast_channel *ast)
1002 {
1003         struct local_pvt *p = ast_channel_tech_pvt(ast);
1004         int isoutbound;
1005         int hangup_chan = 0;
1006         int res = 0;
1007         struct ast_frame f = { AST_FRAME_CONTROL, { AST_CONTROL_HANGUP }, .data.uint32 = ast_channel_hangupcause(ast) };
1008         struct ast_channel *owner = NULL;
1009         struct ast_channel *chan = NULL;
1010
1011         if (!p) {
1012                 return -1;
1013         }
1014
1015         /* give the pvt a ref since we are unlocking the channel. */
1016         ao2_ref(p, 1);
1017
1018         /* the pvt isn't going anywhere, we gave it a ref */
1019         ast_channel_unlock(ast);
1020
1021         /* lock everything */
1022         awesome_locking(p, &chan, &owner);
1023
1024         if (ast != chan && ast != owner) {
1025                 res = -1;
1026                 goto local_hangup_cleanup;
1027         }
1028
1029         isoutbound = IS_OUTBOUND(ast, p); /* just comparing pointer of ast */
1030
1031         if (p->chan && ast_test_flag(ast_channel_flags(ast), AST_FLAG_ANSWERED_ELSEWHERE)) {
1032                 ast_set_flag(ast_channel_flags(p->chan), AST_FLAG_ANSWERED_ELSEWHERE);
1033                 ast_debug(2, "This local call has the ANSWERED_ELSEWHERE flag set.\n");
1034         }
1035
1036         if (isoutbound) {
1037                 const char *status = pbx_builtin_getvar_helper(p->chan, "DIALSTATUS");
1038                 if ((status) && (p->owner)) {
1039                         ast_channel_hangupcause_set(p->owner, ast_channel_hangupcause(p->chan));
1040                         pbx_builtin_setvar_helper(p->owner, "CHANLOCALSTATUS", status);
1041                 }
1042
1043                 ast_clear_flag(p, LOCAL_LAUNCHED_PBX);
1044                 ast_module_user_remove(p->u_chan);
1045                 p->chan = NULL;
1046         } else {
1047                 ast_module_user_remove(p->u_owner);
1048                 if (p->chan) {
1049                         ast_queue_hangup(p->chan);
1050                 }
1051                 p->owner = NULL;
1052         }
1053
1054         ast_channel_tech_pvt_set(ast, NULL); /* this is one of our locked channels, doesn't matter which */
1055
1056         if (!p->owner && !p->chan) {
1057                 ao2_unlock(p);
1058                 /* Remove from list */
1059                 ao2_unlink(locals, p);
1060                 ao2_ref(p, -1);
1061                 p = NULL;
1062                 res = 0;
1063                 goto local_hangup_cleanup;
1064         }
1065         if (p->chan && !ast_test_flag(p, LOCAL_LAUNCHED_PBX)) {
1066                 /* Need to actually hangup since there is no PBX */
1067                 hangup_chan = 1;
1068         } else {
1069                 local_queue_frame(p, isoutbound, &f, NULL, 0);
1070         }
1071
1072 local_hangup_cleanup:
1073         if (p) {
1074                 ao2_unlock(p);
1075                 ao2_ref(p, -1);
1076         }
1077         if (chan) {
1078                 ast_channel_unlock(chan);
1079                 if (hangup_chan) {
1080                         ast_hangup(chan);
1081                 }
1082                 chan = ast_channel_unref(chan);
1083         }
1084         if (owner) {
1085                 ast_channel_unlock(owner);
1086                 owner = ast_channel_unref(owner);
1087         }
1088
1089         /* leave with the same stupid channel locked that came in */
1090         ast_channel_lock(ast);
1091         return res;
1092 }
1093
1094 static void local_destroy(void *obj)
1095 {
1096         struct local_pvt *pvt = obj;
1097         pvt->reqcap = ast_format_cap_destroy(pvt->reqcap);
1098 }
1099
1100 /*! \brief Create a call structure */
1101 static struct local_pvt *local_alloc(const char *data, struct ast_format_cap *cap)
1102 {
1103         struct local_pvt *tmp = NULL;
1104         char *c = NULL, *opts = NULL;
1105
1106         if (!(tmp = ao2_alloc(sizeof(*tmp), local_destroy))) {
1107                 return NULL;
1108         }
1109         if (!(tmp->reqcap = ast_format_cap_dup(cap))) {
1110                 ao2_ref(tmp, -1);
1111                 return NULL;
1112         }
1113
1114         /* Initialize private structure information */
1115         ast_copy_string(tmp->exten, data, sizeof(tmp->exten));
1116
1117         memcpy(&tmp->jb_conf, &g_jb_conf, sizeof(tmp->jb_conf));
1118
1119         /* Look for options */
1120         if ((opts = strchr(tmp->exten, '/'))) {
1121                 *opts++ = '\0';
1122                 if (strchr(opts, 'n'))
1123                         ast_set_flag(tmp, LOCAL_NO_OPTIMIZATION);
1124                 if (strchr(opts, 'j')) {
1125                         if (ast_test_flag(tmp, LOCAL_NO_OPTIMIZATION))
1126                                 ast_set_flag(&tmp->jb_conf, AST_JB_ENABLED);
1127                         else {
1128                                 ast_log(LOG_ERROR, "You must use the 'n' option for chan_local "
1129                                         "to use the 'j' option to enable the jitterbuffer\n");
1130                         }
1131                 }
1132                 if (strchr(opts, 'b')) {
1133                         ast_set_flag(tmp, LOCAL_BRIDGE);
1134                 }
1135                 if (strchr(opts, 'm')) {
1136                         ast_set_flag(tmp, LOCAL_MOH_PASSTHRU);
1137                 }
1138         }
1139
1140         /* Look for a context */
1141         if ((c = strchr(tmp->exten, '@')))
1142                 *c++ = '\0';
1143
1144         ast_copy_string(tmp->context, c ? c : "default", sizeof(tmp->context));
1145 #if 0
1146         /* We can't do this check here, because we don't know the CallerID yet, and
1147          * the CallerID could potentially affect what step is actually taken (or
1148          * even if that step exists). */
1149         if (!ast_exists_extension(NULL, tmp->context, tmp->exten, 1, NULL)) {
1150                 ast_log(LOG_NOTICE, "No such extension/context %s@%s creating local channel\n", tmp->exten, tmp->context);
1151                 tmp = local_pvt_destroy(tmp);
1152         } else {
1153 #endif
1154                 /* Add to list */
1155                 ao2_link(locals, tmp);
1156 #if 0
1157         }
1158 #endif
1159         return tmp; /* this is returned with a ref */
1160 }
1161
1162 /*! \brief Start new local channel */
1163 static struct ast_channel *local_new(struct local_pvt *p, int state, const char *linkedid)
1164 {
1165         struct ast_channel *tmp = NULL, *tmp2 = NULL;
1166         int randnum = ast_random() & 0xffff;
1167         struct ast_format fmt;
1168         const char *t;
1169         int ama;
1170
1171         /* Allocate two new Asterisk channels */
1172         /* safe accountcode */
1173         if (p->owner && ast_channel_accountcode(p->owner))
1174                 t = ast_channel_accountcode(p->owner);
1175         else
1176                 t = "";
1177
1178         if (p->owner)
1179                 ama = ast_channel_amaflags(p->owner);
1180         else
1181                 ama = 0;
1182
1183         /* Make sure that the ;2 channel gets the same linkedid as ;1. You can't pass linkedid to both
1184          * allocations since if linkedid isn't set, then each channel will generate its own linkedid. */
1185         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)) 
1186                 || !(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))) {
1187                 if (tmp) {
1188                         tmp = ast_channel_release(tmp);
1189                 }
1190                 ast_log(LOG_WARNING, "Unable to allocate channel structure(s)\n");
1191                 return NULL;
1192         }
1193
1194         ast_channel_tech_set(tmp, &local_tech);
1195         ast_channel_tech_set(tmp2, &local_tech);
1196
1197         ast_format_cap_copy(ast_channel_nativeformats(tmp), p->reqcap);
1198         ast_format_cap_copy(ast_channel_nativeformats(tmp2), p->reqcap);
1199
1200         /* Determine our read/write format and set it on each channel */
1201         ast_best_codec(p->reqcap, &fmt);
1202         ast_format_copy(ast_channel_writeformat(tmp), &fmt);
1203         ast_format_copy(ast_channel_writeformat(tmp2), &fmt);
1204         ast_format_copy(ast_channel_rawwriteformat(tmp), &fmt);
1205         ast_format_copy(ast_channel_rawwriteformat(tmp2), &fmt);
1206         ast_format_copy(ast_channel_readformat(tmp), &fmt);
1207         ast_format_copy(ast_channel_readformat(tmp2), &fmt);
1208         ast_format_copy(ast_channel_rawreadformat(tmp), &fmt);
1209         ast_format_copy(ast_channel_rawreadformat(tmp2), &fmt);
1210
1211         ast_channel_tech_pvt_set(tmp, p);
1212         ast_channel_tech_pvt_set(tmp2, p);
1213
1214         p->owner = tmp;
1215         p->chan = tmp2;
1216         p->u_owner = ast_module_user_add(p->owner);
1217         p->u_chan = ast_module_user_add(p->chan);
1218
1219         ast_channel_context_set(tmp, p->context);
1220         ast_channel_context_set(tmp2, p->context);
1221         ast_channel_exten_set(tmp2, p->exten);
1222         ast_channel_priority_set(tmp, 1);
1223         ast_channel_priority_set(tmp2, 1);
1224
1225         ast_jb_configure(tmp, &p->jb_conf);
1226
1227         return tmp;
1228 }
1229
1230 /*! \brief Part of PBX interface */
1231 static struct ast_channel *local_request(const char *type, struct ast_format_cap *cap, const struct ast_channel *requestor, const char *data, int *cause)
1232 {
1233         struct local_pvt *p;
1234         struct ast_channel *chan;
1235
1236         /* Allocate a new private structure and then Asterisk channel */
1237         p = local_alloc(data, cap);
1238         if (!p) {
1239                 return NULL;
1240         }
1241         chan = local_new(p, AST_STATE_DOWN, requestor ? ast_channel_linkedid(requestor) : NULL);
1242         if (!chan) {
1243                 ao2_unlink(locals, p);
1244         } else if (ast_channel_cc_params_init(chan, requestor ? ast_channel_get_cc_config_params((struct ast_channel *)requestor) : NULL)) {
1245                 ao2_unlink(locals, p);
1246                 p->owner = ast_channel_release(p->owner);
1247                 ast_module_user_remove(p->u_owner);
1248                 p->chan = ast_channel_release(p->chan);
1249                 ast_module_user_remove(p->u_chan);
1250                 chan = NULL;
1251         }
1252         ao2_ref(p, -1); /* kill the ref from the alloc */
1253
1254         return chan;
1255 }
1256
1257 /*! \brief CLI command "local show channels" */
1258 static char *locals_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1259 {
1260         struct local_pvt *p = NULL;
1261         struct ao2_iterator it;
1262
1263         switch (cmd) {
1264         case CLI_INIT:
1265                 e->command = "local show channels";
1266                 e->usage =
1267                         "Usage: local show channels\n"
1268                         "       Provides summary information on active local proxy channels.\n";
1269                 return NULL;
1270         case CLI_GENERATE:
1271                 return NULL;
1272         }
1273
1274         if (a->argc != 3) {
1275                 return CLI_SHOWUSAGE;
1276         }
1277
1278         if (ao2_container_count(locals) == 0) {
1279                 ast_cli(a->fd, "No local channels in use\n");
1280                 return RESULT_SUCCESS;
1281         }
1282
1283         it = ao2_iterator_init(locals, 0);
1284         while ((p = ao2_iterator_next(&it))) {
1285                 ao2_lock(p);
1286                 ast_cli(a->fd, "%s -- %s@%s\n", p->owner ? ast_channel_name(p->owner) : "<unowned>", p->exten, p->context);
1287                 ao2_unlock(p);
1288                 ao2_ref(p, -1);
1289         }
1290         ao2_iterator_destroy(&it);
1291
1292         return CLI_SUCCESS;
1293 }
1294
1295 static struct ast_cli_entry cli_local[] = {
1296         AST_CLI_DEFINE(locals_show, "List status of local channels"),
1297 };
1298
1299 static int manager_optimize_away(struct mansession *s, const struct message *m)
1300 {
1301         const char *channel;
1302         struct local_pvt *p, *tmp = NULL;
1303         struct ast_channel *c;
1304         int found = 0;
1305         struct ao2_iterator it;
1306
1307         channel = astman_get_header(m, "Channel");
1308
1309         if (ast_strlen_zero(channel)) {
1310                 astman_send_error(s, m, "'Channel' not specified.");
1311                 return 0;
1312         }
1313
1314         c = ast_channel_get_by_name(channel);
1315         if (!c) {
1316                 astman_send_error(s, m, "Channel does not exist.");
1317                 return 0;
1318         }
1319
1320         p = ast_channel_tech_pvt(c);
1321         ast_channel_unref(c);
1322         c = NULL;
1323
1324         it = ao2_iterator_init(locals, 0);
1325         while ((tmp = ao2_iterator_next(&it))) {
1326                 if (tmp == p) {
1327                         ao2_lock(tmp);
1328                         found = 1;
1329                         ast_clear_flag(tmp, LOCAL_NO_OPTIMIZATION);
1330                         ao2_unlock(tmp);
1331                         ao2_ref(tmp, -1);
1332                         break;
1333                 }
1334                 ao2_ref(tmp, -1);
1335         }
1336         ao2_iterator_destroy(&it);
1337
1338         if (found) {
1339                 astman_send_ack(s, m, "Queued channel to be optimized away");
1340         } else {
1341                 astman_send_error(s, m, "Unable to find channel");
1342         }
1343
1344         return 0;
1345 }
1346
1347
1348 static int locals_cmp_cb(void *obj, void *arg, int flags)
1349 {
1350         return (obj == arg) ? CMP_MATCH : 0;
1351 }
1352
1353 /*! \brief Load module into PBX, register channel */
1354 static int load_module(void)
1355 {
1356         if (!(local_tech.capabilities = ast_format_cap_alloc())) {
1357                 return AST_MODULE_LOAD_FAILURE;
1358         }
1359         ast_format_cap_add_all(local_tech.capabilities);
1360
1361         if (!(locals = ao2_container_alloc(BUCKET_SIZE, NULL, locals_cmp_cb))) {
1362                 ast_format_cap_destroy(local_tech.capabilities);
1363                 return AST_MODULE_LOAD_FAILURE;
1364         }
1365
1366         /* Make sure we can register our channel type */
1367         if (ast_channel_register(&local_tech)) {
1368                 ast_log(LOG_ERROR, "Unable to register channel class 'Local'\n");
1369                 ao2_ref(locals, -1);
1370                 ast_format_cap_destroy(local_tech.capabilities);
1371                 return AST_MODULE_LOAD_FAILURE;
1372         }
1373         ast_cli_register_multiple(cli_local, sizeof(cli_local) / sizeof(struct ast_cli_entry));
1374         ast_manager_register_xml("LocalOptimizeAway", EVENT_FLAG_SYSTEM|EVENT_FLAG_CALL, manager_optimize_away);
1375
1376         return AST_MODULE_LOAD_SUCCESS;
1377 }
1378
1379 /*! \brief Unload the local proxy channel from Asterisk */
1380 static int unload_module(void)
1381 {
1382         struct local_pvt *p = NULL;
1383         struct ao2_iterator it;
1384
1385         /* First, take us out of the channel loop */
1386         ast_cli_unregister_multiple(cli_local, sizeof(cli_local) / sizeof(struct ast_cli_entry));
1387         ast_manager_unregister("LocalOptimizeAway");
1388         ast_channel_unregister(&local_tech);
1389
1390         it = ao2_iterator_init(locals, 0);
1391         while ((p = ao2_iterator_next(&it))) {
1392                 if (p->owner) {
1393                         ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
1394                 }
1395                 ao2_ref(p, -1);
1396         }
1397         ao2_iterator_destroy(&it);
1398         ao2_ref(locals, -1);
1399
1400         ast_format_cap_destroy(local_tech.capabilities);
1401         return 0;
1402 }
1403
1404 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Local Proxy Channel (Note: used internally by other modules)",
1405                 .load = load_module,
1406                 .unload = unload_module,
1407                 .load_pri = AST_MODPRI_CHANNEL_DRIVER,
1408         );