Add documentation for new manager event in chan_local
[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, void *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, 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(void *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->tech_pvt)) {
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(void *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 = bridge->tech_pvt;
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                         chan->name, bridge->name);
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->tech_pvt)) {
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 && 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
726         ao2_ref(p, 1); /* ref for local_queue_frame */
727         ao2_lock(p);
728         isoutbound = IS_OUTBOUND(ast, p);
729         f.subclass.integer = digit;
730         res = local_queue_frame(p, isoutbound, &f, ast, 0);
731         ao2_unlock(p);
732         ao2_ref(p, -1);
733
734         return res;
735 }
736
737 static int local_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
738 {
739         struct local_pvt *p = ast->tech_pvt;
740         int res = -1;
741         struct ast_frame f = { AST_FRAME_DTMF_END, };
742         int isoutbound;
743
744         if (!p) {
745                 return -1;
746         }
747
748         ao2_ref(p, 1); /* ref for local_queue_frame */
749         ao2_lock(p);
750         isoutbound = IS_OUTBOUND(ast, p);
751         f.subclass.integer = digit;
752         f.len = duration;
753         res = local_queue_frame(p, isoutbound, &f, ast, 0);
754         ao2_unlock(p);
755         ao2_ref(p, -1);
756
757         return res;
758 }
759
760 static int local_sendtext(struct ast_channel *ast, const char *text)
761 {
762         struct local_pvt *p = ast->tech_pvt;
763         int res = -1;
764         struct ast_frame f = { AST_FRAME_TEXT, };
765         int isoutbound;
766
767         if (!p) {
768                 return -1;
769         }
770
771         ao2_lock(p);
772         ao2_ref(p, 1); /* ref for local_queue_frame */
773         isoutbound = IS_OUTBOUND(ast, p);
774         f.data.ptr = (char *) text;
775         f.datalen = strlen(text) + 1;
776         res = local_queue_frame(p, isoutbound, &f, ast, 0);
777         ao2_unlock(p);
778         ao2_ref(p, -1);
779         return res;
780 }
781
782 static int local_sendhtml(struct ast_channel *ast, int subclass, const char *data, int datalen)
783 {
784         struct local_pvt *p = ast->tech_pvt;
785         int res = -1;
786         struct ast_frame f = { AST_FRAME_HTML, };
787         int isoutbound;
788
789         if (!p) {
790                 return -1;
791         }
792
793         ao2_lock(p);
794         ao2_ref(p, 1); /* ref for local_queue_frame */
795         isoutbound = IS_OUTBOUND(ast, p);
796         f.subclass.integer = subclass;
797         f.data.ptr = (char *)data;
798         f.datalen = datalen;
799         res = local_queue_frame(p, isoutbound, &f, ast, 0);
800         ao2_unlock(p);
801         ao2_ref(p, -1);
802
803         return res;
804 }
805
806 /*! \brief Initiate new call, part of PBX interface 
807  *      dest is the dial string */
808 static int local_call(struct ast_channel *ast, char *dest, int timeout)
809 {
810         struct local_pvt *p = ast->tech_pvt;
811         int pvt_locked = 0;
812
813         struct ast_channel *owner = NULL;
814         struct ast_channel *chan = NULL;
815         int res;
816         struct ast_var_t *varptr = NULL, *new;
817         size_t len, namelen;
818         char *reduced_dest = ast_strdupa(dest);
819         char *slash;
820         const char *exten;
821         const char *context;
822
823         if (!p) {
824                 return -1;
825         }
826
827         /* since we are letting go of channel locks that were locked coming into
828          * this function, then we need to give the tech pvt a ref */
829         ao2_ref(p, 1);
830         ast_channel_unlock(ast);
831
832         awesome_locking(p, &chan, &owner);
833         pvt_locked = 1;
834
835         if (owner != ast) {
836                 res = -1;
837                 goto return_cleanup;
838         }
839
840         if (!owner || !chan) {
841                 res = -1;
842                 goto return_cleanup;
843         }
844
845         /*
846          * Note that cid_num and cid_name aren't passed in the ast_channel_alloc
847          * call, so it's done here instead.
848          *
849          * All these failure points just return -1. The individual strings will
850          * be cleared when we destroy the channel.
851          */
852         ast_party_redirecting_copy(&chan->redirecting, &owner->redirecting);
853
854         ast_party_dialed_copy(&chan->dialed, &owner->dialed);
855
856         ast_connected_line_copy_to_caller(&chan->caller, &owner->connected);
857         ast_connected_line_copy_from_caller(&chan->connected, &owner->caller);
858
859         ast_string_field_set(chan, language, owner->language);
860         ast_string_field_set(chan, accountcode, owner->accountcode);
861         ast_string_field_set(chan, musicclass, owner->musicclass);
862         ast_cdr_update(chan);
863
864         ast_channel_cc_params_init(chan, ast_channel_get_cc_config_params(owner));
865
866         /* Make sure we inherit the ANSWERED_ELSEWHERE flag if it's set on the queue/dial call request in the dialplan */
867         if (ast_test_flag(ast, AST_FLAG_ANSWERED_ELSEWHERE)) {
868                 ast_set_flag(chan, AST_FLAG_ANSWERED_ELSEWHERE);
869         }
870
871         /* copy the channel variables from the incoming channel to the outgoing channel */
872         /* Note that due to certain assumptions, they MUST be in the same order */
873         AST_LIST_TRAVERSE(&owner->varshead, varptr, entries) {
874                 namelen = strlen(varptr->name);
875                 len = sizeof(struct ast_var_t) + namelen + strlen(varptr->value) + 2;
876                 if ((new = ast_calloc(1, len))) {
877                         memcpy(new, varptr, len);
878                         new->value = &(new->name[0]) + namelen + 1;
879                         AST_LIST_INSERT_TAIL(&chan->varshead, new, entries);
880                 }
881         }
882         ast_channel_datastore_inherit(owner, chan);
883         /* If the local channel has /n or /b on the end of it,
884          * we need to lop that off for our argument to setting
885          * up the CC_INTERFACES variable
886          */
887         if ((slash = strrchr(reduced_dest, '/'))) {
888                 *slash = '\0';
889         }
890         ast_set_cc_interfaces_chanvar(chan, reduced_dest);
891
892         exten = ast_strdupa(chan->exten);
893         context = ast_strdupa(chan->context);
894
895         ao2_unlock(p);
896         pvt_locked = 0;
897
898         ast_channel_unlock(chan);
899
900         if (!ast_exists_extension(chan, context, exten, 1,
901                 S_COR(owner->caller.id.number.valid, owner->caller.id.number.str, NULL))) {
902                 ast_log(LOG_NOTICE, "No such extension/context %s@%s while calling Local channel\n", exten, context);
903                 res = -1;
904                 chan = ast_channel_unref(chan); /* we already unlocked it, so clear it hear so the cleanup label won't touch it. */
905                 goto return_cleanup;
906         }
907
908         manager_event(EVENT_FLAG_CALL, "LocalBridge",
909                       "Channel1: %s\r\n"
910                       "Channel2: %s\r\n"
911                       "Uniqueid1: %s\r\n"
912                       "Uniqueid2: %s\r\n"
913                       "Context: %s\r\n"
914                       "Exten: %s\r\n"
915                       "LocalOptimization: %s\n",
916                         p->owner->name, p->chan->name, p->owner->uniqueid, p->chan->uniqueid,
917                         p->context, p->exten,
918                         ast_test_flag(p, LOCAL_NO_OPTIMIZATION) ? "Yes" : "No");
919
920
921         /* Start switch on sub channel */
922         if (!(res = ast_pbx_start(chan))) {
923                 ao2_lock(p);
924                 ast_set_flag(p, LOCAL_LAUNCHED_PBX);
925                 ao2_unlock(p);
926         }
927         chan = ast_channel_unref(chan); /* chan is already unlocked, clear it here so the cleanup lable won't touch it. */
928
929 return_cleanup:
930         if (p) {
931                 if (pvt_locked) {
932                         ao2_unlock(p);
933                 }
934                 ao2_ref(p, -1);
935         }
936         if (chan) {
937                 ast_channel_unlock(chan);
938                 chan = ast_channel_unref(chan);
939         }
940
941         /* owner is supposed to be == to ast,  if it
942          * is, don't unlock it because ast must exit locked */
943         if (owner) {
944                 if (owner != ast) {
945                         ast_channel_unlock(owner);
946                         ast_channel_lock(ast);
947                 }
948                 owner = ast_channel_unref(owner);
949         } else {
950                 /* we have to exit with ast locked */
951                 ast_channel_lock(ast);
952         }
953
954         return res;
955 }
956
957 /*! \brief Hangup a call through the local proxy channel */
958 static int local_hangup(struct ast_channel *ast)
959 {
960         struct local_pvt *p = ast->tech_pvt;
961         int isoutbound;
962         int hangup_chan = 0;
963         int res = 0;
964         struct ast_frame f = { AST_FRAME_CONTROL, { AST_CONTROL_HANGUP }, .data.uint32 = ast->hangupcause };
965         struct ast_channel *owner = NULL;
966         struct ast_channel *chan = NULL;
967
968         if (!p) {
969                 return -1;
970         }
971
972         /* give the pvt a ref since we are unlocking the channel. */
973         ao2_ref(p, 1);
974
975         /* the pvt isn't going anywhere, we gave it a ref */
976         ast_channel_unlock(ast);
977
978         /* lock everything */
979         awesome_locking(p, &chan, &owner);
980
981         if (ast != chan && ast != owner) {
982                 res = -1;
983                 goto local_hangup_cleanup;
984         }
985
986         isoutbound = IS_OUTBOUND(ast, p); /* just comparing pointer of ast */
987
988         if (p->chan && ast_test_flag(ast, AST_FLAG_ANSWERED_ELSEWHERE)) {
989                 ast_set_flag(p->chan, AST_FLAG_ANSWERED_ELSEWHERE);
990                 ast_debug(2, "This local call has the ANSWERED_ELSEWHERE flag set.\n");
991         }
992
993         if (isoutbound) {
994                 const char *status = pbx_builtin_getvar_helper(p->chan, "DIALSTATUS");
995                 if ((status) && (p->owner)) {
996                         p->owner->hangupcause = p->chan->hangupcause;
997                         pbx_builtin_setvar_helper(p->owner, "CHANLOCALSTATUS", status);
998                 }
999
1000                 ast_clear_flag(p, LOCAL_LAUNCHED_PBX);
1001                 ast_module_user_remove(p->u_chan);
1002                 p->chan = NULL;
1003         } else {
1004                 ast_module_user_remove(p->u_owner);
1005                 if (p->chan) {
1006                         ast_queue_hangup(p->chan);
1007                 }
1008                 p->owner = NULL;
1009         }
1010
1011         ast->tech_pvt = NULL; /* this is one of our locked channels, doesn't matter which */
1012
1013         if (!p->owner && !p->chan) {
1014                 ao2_unlock(p);
1015                 /* Remove from list */
1016                 ao2_unlink(locals, p);
1017                 ao2_ref(p, -1);
1018                 p = NULL;
1019                 res = 0;
1020                 goto local_hangup_cleanup;
1021         }
1022         if (p->chan && !ast_test_flag(p, LOCAL_LAUNCHED_PBX)) {
1023                 /* Need to actually hangup since there is no PBX */
1024                 hangup_chan = 1;
1025         } else {
1026                 local_queue_frame(p, isoutbound, &f, NULL, 0);
1027         }
1028
1029 local_hangup_cleanup:
1030         if (p) {
1031                 ao2_unlock(p);
1032                 ao2_ref(p, -1);
1033         }
1034         if (chan) {
1035                 ast_channel_unlock(chan);
1036                 if (hangup_chan) {
1037                         ast_hangup(chan);
1038                 }
1039                 chan = ast_channel_unref(chan);
1040         }
1041         if (owner) {
1042                 ast_channel_unlock(owner);
1043                 owner = ast_channel_unref(owner);
1044         }
1045
1046         /* leave with the same stupid channel locked that came in */
1047         ast_channel_lock(ast);
1048         return res;
1049 }
1050
1051 static void local_destroy(void *obj)
1052 {
1053         struct local_pvt *pvt = obj;
1054         pvt->reqcap = ast_format_cap_destroy(pvt->reqcap);
1055 }
1056
1057 /*! \brief Create a call structure */
1058 static struct local_pvt *local_alloc(const char *data, struct ast_format_cap *cap)
1059 {
1060         struct local_pvt *tmp = NULL;
1061         char *c = NULL, *opts = NULL;
1062
1063         if (!(tmp = ao2_alloc(sizeof(*tmp), local_destroy))) {
1064                 return NULL;
1065         }
1066         if (!(tmp->reqcap = ast_format_cap_dup(cap))) {
1067                 ao2_ref(tmp, -1);
1068                 return NULL;
1069         }
1070
1071         /* Initialize private structure information */
1072         ast_copy_string(tmp->exten, data, sizeof(tmp->exten));
1073
1074         memcpy(&tmp->jb_conf, &g_jb_conf, sizeof(tmp->jb_conf));
1075
1076         /* Look for options */
1077         if ((opts = strchr(tmp->exten, '/'))) {
1078                 *opts++ = '\0';
1079                 if (strchr(opts, 'n'))
1080                         ast_set_flag(tmp, LOCAL_NO_OPTIMIZATION);
1081                 if (strchr(opts, 'j')) {
1082                         if (ast_test_flag(tmp, LOCAL_NO_OPTIMIZATION))
1083                                 ast_set_flag(&tmp->jb_conf, AST_JB_ENABLED);
1084                         else {
1085                                 ast_log(LOG_ERROR, "You must use the 'n' option for chan_local "
1086                                         "to use the 'j' option to enable the jitterbuffer\n");
1087                         }
1088                 }
1089                 if (strchr(opts, 'b')) {
1090                         ast_set_flag(tmp, LOCAL_BRIDGE);
1091                 }
1092                 if (strchr(opts, 'm')) {
1093                         ast_set_flag(tmp, LOCAL_MOH_PASSTHRU);
1094                 }
1095         }
1096
1097         /* Look for a context */
1098         if ((c = strchr(tmp->exten, '@')))
1099                 *c++ = '\0';
1100
1101         ast_copy_string(tmp->context, c ? c : "default", sizeof(tmp->context));
1102 #if 0
1103         /* We can't do this check here, because we don't know the CallerID yet, and
1104          * the CallerID could potentially affect what step is actually taken (or
1105          * even if that step exists). */
1106         if (!ast_exists_extension(NULL, tmp->context, tmp->exten, 1, NULL)) {
1107                 ast_log(LOG_NOTICE, "No such extension/context %s@%s creating local channel\n", tmp->exten, tmp->context);
1108                 tmp = local_pvt_destroy(tmp);
1109         } else {
1110 #endif
1111                 /* Add to list */
1112                 ao2_link(locals, tmp);
1113 #if 0
1114         }
1115 #endif
1116         return tmp; /* this is returned with a ref */
1117 }
1118
1119 /*! \brief Start new local channel */
1120 static struct ast_channel *local_new(struct local_pvt *p, int state, const char *linkedid)
1121 {
1122         struct ast_channel *tmp = NULL, *tmp2 = NULL;
1123         int randnum = ast_random() & 0xffff;
1124         struct ast_format fmt;
1125         const char *t;
1126         int ama;
1127
1128         /* Allocate two new Asterisk channels */
1129         /* safe accountcode */
1130         if (p->owner && p->owner->accountcode)
1131                 t = p->owner->accountcode;
1132         else
1133                 t = "";
1134
1135         if (p->owner)
1136                 ama = p->owner->amaflags;
1137         else
1138                 ama = 0;
1139         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)) 
1140                 || !(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))) {
1141                 if (tmp) {
1142                         tmp = ast_channel_release(tmp);
1143                 }
1144                 ast_log(LOG_WARNING, "Unable to allocate channel structure(s)\n");
1145                 return NULL;
1146         }
1147
1148         tmp2->tech = tmp->tech = &local_tech;
1149
1150         ast_format_cap_copy(tmp->nativeformats, p->reqcap);
1151         ast_format_cap_copy(tmp2->nativeformats, p->reqcap);
1152
1153         /* Determine our read/write format and set it on each channel */
1154         ast_best_codec(p->reqcap, &fmt);
1155         ast_format_copy(&tmp->writeformat, &fmt);
1156         ast_format_copy(&tmp2->writeformat, &fmt);
1157         ast_format_copy(&tmp->rawwriteformat, &fmt);
1158         ast_format_copy(&tmp2->rawwriteformat, &fmt);
1159         ast_format_copy(&tmp->readformat, &fmt);
1160         ast_format_copy(&tmp2->readformat, &fmt);
1161         ast_format_copy(&tmp->rawreadformat, &fmt);
1162         ast_format_copy(&tmp2->rawreadformat, &fmt);
1163
1164         tmp->tech_pvt = p;
1165         tmp2->tech_pvt = p;
1166
1167         p->owner = tmp;
1168         p->chan = tmp2;
1169         p->u_owner = ast_module_user_add(p->owner);
1170         p->u_chan = ast_module_user_add(p->chan);
1171
1172         ast_copy_string(tmp->context, p->context, sizeof(tmp->context));
1173         ast_copy_string(tmp2->context, p->context, sizeof(tmp2->context));
1174         ast_copy_string(tmp2->exten, p->exten, sizeof(tmp->exten));
1175         tmp->priority = 1;
1176         tmp2->priority = 1;
1177
1178         ast_jb_configure(tmp, &p->jb_conf);
1179
1180         return tmp;
1181 }
1182
1183 /*! \brief Part of PBX interface */
1184 static struct ast_channel *local_request(const char *type, struct ast_format_cap *cap, const struct ast_channel *requestor, void *data, int *cause)
1185 {
1186         struct local_pvt *p = NULL;
1187         struct ast_channel *chan = NULL;
1188
1189         /* Allocate a new private structure and then Asterisk channel */
1190         if ((p = local_alloc(data, cap))) {
1191                 if (!(chan = local_new(p, AST_STATE_DOWN, requestor ? requestor->linkedid : NULL))) {
1192                         ao2_unlink(locals, p);
1193                 }
1194                 if (chan && ast_channel_cc_params_init(chan, requestor ? ast_channel_get_cc_config_params((struct ast_channel *)requestor) : NULL)) {
1195                         chan = ast_channel_release(chan);
1196                         ao2_unlink(locals, p);
1197                 }
1198                 ao2_ref(p, -1); /* kill the ref from the alloc */
1199         }
1200
1201         return chan;
1202 }
1203
1204 /*! \brief CLI command "local show channels" */
1205 static char *locals_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1206 {
1207         struct local_pvt *p = NULL;
1208         struct ao2_iterator it;
1209
1210         switch (cmd) {
1211         case CLI_INIT:
1212                 e->command = "local show channels";
1213                 e->usage =
1214                         "Usage: local show channels\n"
1215                         "       Provides summary information on active local proxy channels.\n";
1216                 return NULL;
1217         case CLI_GENERATE:
1218                 return NULL;
1219         }
1220
1221         if (a->argc != 3)
1222                 return CLI_SHOWUSAGE;
1223
1224         if (ao2_container_count(locals) == 0) {
1225                 ast_cli(a->fd, "No local channels in use\n");
1226                 return RESULT_SUCCESS;
1227         }
1228
1229         it = ao2_iterator_init(locals, 0);
1230         while ((p = ao2_iterator_next(&it))) {
1231                 ao2_lock(p);
1232                 ast_cli(a->fd, "%s -- %s@%s\n", p->owner ? p->owner->name : "<unowned>", p->exten, p->context);
1233                 ao2_unlock(p);
1234                 ao2_ref(p, -1);
1235         }
1236         ao2_iterator_destroy(&it);
1237
1238         return CLI_SUCCESS;
1239 }
1240
1241 static struct ast_cli_entry cli_local[] = {
1242         AST_CLI_DEFINE(locals_show, "List status of local channels"),
1243 };
1244
1245 static int manager_optimize_away(struct mansession *s, const struct message *m)
1246 {
1247         const char *channel;
1248         struct local_pvt *p, *tmp = NULL;
1249         struct ast_channel *c;
1250         int found = 0;
1251         struct ao2_iterator it;
1252
1253         channel = astman_get_header(m, "Channel");
1254
1255         if (ast_strlen_zero(channel)) {
1256                 astman_send_error(s, m, "'Channel' not specified.");
1257                 return 0;
1258         }
1259
1260         c = ast_channel_get_by_name(channel);
1261         if (!c) {
1262                 astman_send_error(s, m, "Channel does not exist.");
1263                 return 0;
1264         }
1265
1266         p = c->tech_pvt;
1267         ast_channel_unref(c);
1268         c = NULL;
1269
1270         it = ao2_iterator_init(locals, 0);
1271         while ((tmp = ao2_iterator_next(&it))) {
1272                 if (tmp == p) {
1273                         ao2_lock(tmp);
1274                         found = 1;
1275                         ast_clear_flag(tmp, LOCAL_NO_OPTIMIZATION);
1276                         ao2_unlock(tmp);
1277                         ao2_ref(tmp, -1);
1278                         break;
1279                 }
1280                 ao2_ref(tmp, -1);
1281         }
1282         ao2_iterator_destroy(&it);
1283
1284         if (found) {
1285                 astman_send_ack(s, m, "Queued channel to be optimized away");
1286         } else {
1287                 astman_send_error(s, m, "Unable to find channel");
1288         }
1289
1290         return 0;
1291 }
1292
1293
1294 static int locals_cmp_cb(void *obj, void *arg, int flags)
1295 {
1296         return (obj == arg) ? CMP_MATCH : 0;
1297 }
1298
1299 /*! \brief Load module into PBX, register channel */
1300 static int load_module(void)
1301 {
1302         if (!(local_tech.capabilities = ast_format_cap_alloc())) {
1303                 return AST_MODULE_LOAD_FAILURE;
1304         }
1305         ast_format_cap_add_all(local_tech.capabilities);
1306
1307         if (!(locals = ao2_container_alloc(BUCKET_SIZE, NULL, locals_cmp_cb))) {
1308                 ast_format_cap_destroy(local_tech.capabilities);
1309                 return AST_MODULE_LOAD_FAILURE;
1310         }
1311
1312         /* Make sure we can register our channel type */
1313         if (ast_channel_register(&local_tech)) {
1314                 ast_log(LOG_ERROR, "Unable to register channel class 'Local'\n");
1315                 ao2_ref(locals, -1);
1316                 ast_format_cap_destroy(local_tech.capabilities);
1317                 return AST_MODULE_LOAD_FAILURE;
1318         }
1319         ast_cli_register_multiple(cli_local, sizeof(cli_local) / sizeof(struct ast_cli_entry));
1320         ast_manager_register_xml("LocalOptimizeAway", EVENT_FLAG_SYSTEM|EVENT_FLAG_CALL, manager_optimize_away);
1321
1322         return AST_MODULE_LOAD_SUCCESS;
1323 }
1324
1325 /*! \brief Unload the local proxy channel from Asterisk */
1326 static int unload_module(void)
1327 {
1328         struct local_pvt *p = NULL;
1329         struct ao2_iterator it;
1330
1331         /* First, take us out of the channel loop */
1332         ast_cli_unregister_multiple(cli_local, sizeof(cli_local) / sizeof(struct ast_cli_entry));
1333         ast_manager_unregister("LocalOptimizeAway");
1334         ast_channel_unregister(&local_tech);
1335
1336         it = ao2_iterator_init(locals, 0);
1337         while ((p = ao2_iterator_next(&it))) {
1338                 if (p->owner) {
1339                         ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
1340                 }
1341                 ao2_ref(p, -1);
1342         }
1343         ao2_iterator_destroy(&it);
1344         ao2_ref(locals, -1);
1345
1346         ast_format_cap_destroy(local_tech.capabilities);
1347         return 0;
1348 }
1349
1350 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Local Proxy Channel (Note: used internally by other modules)",
1351                 .load = load_module,
1352                 .unload = unload_module,
1353                 .load_pri = AST_MODPRI_CHANNEL_DRIVER,
1354         );