channels/chan_local.c

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