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