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