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