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