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