main/bridging.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2007 - 2009, Digium, Inc.
   5  *
   6  * Joshua Colp <jcolp@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  * \brief Channel Bridging API
  22  *
  23  * \author Joshua Colp <jcolp@digium.com>
  24  */
  25
  26 #include "asterisk.h"
  27
  28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  29
  30 #include <signal.h>
  31
  32 #include "asterisk/logger.h"
  33 #include "asterisk/channel.h"
  34 #include "asterisk/options.h"
  35 #include "asterisk/utils.h"
  36 #include "asterisk/lock.h"
  37 #include "asterisk/linkedlists.h"
  38 #include "asterisk/bridging.h"
  39 #include "asterisk/bridging_technology.h"
  40 #include "asterisk/app.h"
  41 #include "asterisk/file.h"
  42 #include "asterisk/module.h"
  43 #include "asterisk/astobj2.h"
  44
  45 static AST_RWLIST_HEAD_STATIC(bridge_technologies, ast_bridge_technology);
  46
  47 /* Initial starting point for the bridge array of channels */
  48 #define BRIDGE_ARRAY_START 128
  49
  50 /* Grow rate of bridge array of channels */
  51 #define BRIDGE_ARRAY_GROW 32
  52
  53 /*! Default DTMF keys for built in features */
  54 static char builtin_features_dtmf[AST_BRIDGE_BUILTIN_END][MAXIMUM_DTMF_FEATURE_STRING];
  55
  56 /*! Function handlers for the built in features */
  57 static void *builtin_features_handlers[AST_BRIDGE_BUILTIN_END];
  58
  59 int __ast_bridge_technology_register(struct ast_bridge_technology *technology, struct ast_module *module)
  60 {
  61         struct ast_bridge_technology *current = NULL;
  62
  63         /* Perform a sanity check to make sure the bridge technology conforms to our needed requirements */
  64         if (ast_strlen_zero(technology->name) || !technology->capabilities || !technology->write) {
  65                 ast_log(LOG_WARNING, "Bridge technology %s failed registration sanity check.\n", technology->name);
  66                 return -1;
  67         }
  68
  69         AST_RWLIST_WRLOCK(&bridge_technologies);
  70
  71         /* Look for duplicate bridge technology already using this name, or already registered */
  72         AST_RWLIST_TRAVERSE(&bridge_technologies, current, entry) {
  73                 if ((!strcasecmp(current->name, technology->name)) || (current == technology)) {
  74                         ast_log(LOG_WARNING, "A bridge technology of %s already claims to exist in our world.\n", technology->name);
  75                         AST_RWLIST_UNLOCK(&bridge_technologies);
  76                         return -1;
  77                 }
  78         }
  79
  80         /* Copy module pointer so reference counting can keep the module from unloading */
  81         technology->mod = module;
  82
  83         /* Insert our new bridge technology into the list and print out a pretty message */
  84         AST_RWLIST_INSERT_TAIL(&bridge_technologies, technology, entry);
  85
  86         AST_RWLIST_UNLOCK(&bridge_technologies);
  87
  88         if (option_verbose > 1) {
  89                 ast_verbose(VERBOSE_PREFIX_2 "Registered bridge technology %s\n", technology->name);
  90         }
  91
  92         return 0;
  93 }
  94
  95 int ast_bridge_technology_unregister(struct ast_bridge_technology *technology)
  96 {
  97         struct ast_bridge_technology *current = NULL;
  98
  99         AST_RWLIST_WRLOCK(&bridge_technologies);
 100
 101         /* Ensure the bridge technology is registered before removing it */
 102         AST_RWLIST_TRAVERSE_SAFE_BEGIN(&bridge_technologies, current, entry) {
 103                 if (current == technology) {
 104                         AST_RWLIST_REMOVE_CURRENT(entry);
 105                         if (option_verbose > 1) {
 106                                 ast_verbose(VERBOSE_PREFIX_2 "Unregistered bridge technology %s\n", technology->name);
 107                         }
 108                         break;
 109                 }
 110         }
 111         AST_RWLIST_TRAVERSE_SAFE_END;
 112
 113         AST_RWLIST_UNLOCK(&bridge_technologies);
 114
 115         return current ? 0 : -1;
 116 }
 117
 118 void ast_bridge_change_state(struct ast_bridge_channel *bridge_channel, enum ast_bridge_channel_state new_state)
 119 {
 120         /* Change the state on the bridge channel */
 121         bridge_channel->state = new_state;
 122
 123         /* Only poke the channel's thread if it is not us */
 124         if (!pthread_equal(pthread_self(), bridge_channel->thread)) {
 125                 pthread_kill(bridge_channel->thread, SIGURG);
 126                 ast_mutex_lock(&bridge_channel->lock);
 127                 ast_cond_signal(&bridge_channel->cond);
 128                 ast_mutex_unlock(&bridge_channel->lock);
 129         }
 130
 131         return;
 132 }
 133
 134 /*! \brief Helper function to poke the bridge thread */
 135 static void bridge_poke(struct ast_bridge *bridge)
 136 {
 137         /* Poke the thread just in case */
 138         if (bridge->thread != AST_PTHREADT_NULL && bridge->thread != AST_PTHREADT_STOP) {
 139                 pthread_kill(bridge->thread, SIGURG);
 140         }
 141
 142         return;
 143 }
 144
 145 /*! \brief Helper function to add a channel to the bridge array
 146  *
 147  * \note This function assumes the bridge is locked.
 148  */
 149 static void bridge_array_add(struct ast_bridge *bridge, struct ast_channel *chan)
 150 {
 151         /* We have to make sure the bridge thread is not using the bridge array before messing with it */
 152         while (bridge->waiting) {
 153                 bridge_poke(bridge);
 154                 sched_yield();
 155         }
 156
 157         bridge->array[bridge->array_num++] = chan;
 158
 159         ast_debug(1, "Added channel %s(%p) to bridge array on %p, new count is %d\n", chan->name, chan, bridge, (int)bridge->array_num);
 160
 161         /* If the next addition of a channel will exceed our array size grow it out */
 162         if (bridge->array_num == bridge->array_size) {
 163                 struct ast_channel **tmp;
 164                 ast_debug(1, "Growing bridge array on %p from %d to %d\n", bridge, (int)bridge->array_size, (int)bridge->array_size + BRIDGE_ARRAY_GROW);
 165                 if (!(tmp = ast_realloc(bridge->array, (bridge->array_size + BRIDGE_ARRAY_GROW) * sizeof(struct ast_channel *)))) {
 166                         ast_log(LOG_ERROR, "Failed to allocate more space for another channel on bridge '%p', this is not going to end well\n", bridge);
 167                         return;
 168                 }
 169                 bridge->array = tmp;
 170                 bridge->array_size += BRIDGE_ARRAY_GROW;
 171         }
 172
 173         return;
 174 }
 175
 176 /*! \brief Helper function to remove a channel from the bridge array
 177  *
 178  * \note This function assumes the bridge is locked.
 179  */
 180 static void bridge_array_remove(struct ast_bridge *bridge, struct ast_channel *chan)
 181 {
 182         int i;
 183
 184         /* We have to make sure the bridge thread is not using the bridge array before messing with it */
 185         while (bridge->waiting) {
 186                 bridge_poke(bridge);
 187                 sched_yield();
 188         }
 189
 190         for (i = 0; i < bridge->array_num; i++) {
 191                 if (bridge->array[i] == chan) {
 192                         bridge->array[i] = (bridge->array[(bridge->array_num - 1)] != chan ? bridge->array[(bridge->array_num - 1)] : NULL);
 193                         bridge->array[(bridge->array_num - 1)] = NULL;
 194                         bridge->array_num--;
 195                         ast_debug(1, "Removed channel %p from bridge array on %p, new count is %d\n", chan, bridge, (int)bridge->array_num);
 196                         break;
 197                 }
 198         }
 199
 200         return;
 201 }
 202
 203 /*! \brief Helper function to find a bridge channel given a channel */
 204 static struct ast_bridge_channel *find_bridge_channel(struct ast_bridge *bridge, struct ast_channel *chan)
 205 {
 206         struct ast_bridge_channel *bridge_channel = NULL;
 207
 208         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
 209                 if (bridge_channel->chan == chan) {
 210                         break;
 211                 }
 212         }
 213
 214         return bridge_channel;
 215 }
 216
 217 /*! \brief Internal function to see whether a bridge should dissolve, and if so do it */
 218 static void bridge_check_dissolve(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 219 {
 220         struct ast_bridge_channel *bridge_channel2 = NULL;
 221
 222         if (!ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_DISSOLVE) && (!bridge_channel->features || !bridge_channel->features->usable || !ast_test_flag(&bridge_channel->features->feature_flags, AST_BRIDGE_FLAG_DISSOLVE))) {
 223                 return;
 224         }
 225
 226         ast_debug(1, "Dissolving bridge %p\n", bridge);
 227
 228         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel2, entry) {
 229                 if (bridge_channel2->state != AST_BRIDGE_CHANNEL_STATE_END && bridge_channel2->state != AST_BRIDGE_CHANNEL_STATE_DEPART) {
 230                         ast_bridge_change_state(bridge_channel2, AST_BRIDGE_CHANNEL_STATE_HANGUP);
 231                 }
 232         }
 233
 234         /* Since all the channels are going away let's go ahead and stop our on thread */
 235         bridge->stop = 1;
 236
 237         return;
 238 }
 239
 240 /*! \brief Internal function to handle DTMF from a channel */
 241 static struct ast_frame *bridge_handle_dtmf(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
 242 {
 243         struct ast_bridge_features *features = (bridge_channel->features ? bridge_channel->features : &bridge->features);
 244         struct ast_bridge_features_hook *hook = NULL;
 245
 246         /* If the features structure we grabbed is not usable immediately return the frame */
 247         if (!features->usable) {
 248                 return frame;
 249         }
 250
 251         /* See if this DTMF matches the beginnings of any feature hooks, if so we switch to the feature state to either execute the feature or collect more DTMF */
 252         AST_LIST_TRAVERSE(&features->hooks, hook, entry) {
 253                 if (hook->dtmf[0] == frame->subclass) {
 254                         ast_frfree(frame);
 255                         frame = NULL;
 256                         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_FEATURE);
 257                         break;
 258                 }
 259         }
 260
 261         return frame;
 262 }
 263
 264 /*! \brief Internal function used to determine whether a control frame should be dropped or not */
 265 static int bridge_drop_control_frame(int subclass)
 266 {
 267         switch (subclass) {
 268         case AST_CONTROL_ANSWER:
 269         case -1:
 270                 return 1;
 271         default:
 272                 return 0;
 273         }
 274 }
 275
 276 void ast_bridge_handle_trip(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_channel *chan, int outfd)
 277 {
 278         /* If no bridge channel has been provided and the actual channel has been provided find it */
 279         if (chan && !bridge_channel) {
 280                 bridge_channel = find_bridge_channel(bridge, chan);
 281         }
 282
 283         /* If a bridge channel with actual channel is present read a frame and handle it */
 284         if (chan && bridge_channel) {
 285                 struct ast_frame *frame = (((bridge->features.mute) || (bridge_channel->features && bridge_channel->features->mute)) ? ast_read_noaudio(chan) : ast_read(chan));
 286
 287                 /* This is pretty simple... see if they hung up */
 288                 if (!frame || (frame->frametype == AST_FRAME_CONTROL && frame->subclass == AST_CONTROL_HANGUP)) {
 289                         /* Signal the thread that is handling the bridged channel that it should be ended */
 290                         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_END);
 291                 } else if (frame->frametype == AST_FRAME_CONTROL && bridge_drop_control_frame(frame->subclass)) {
 292                         ast_debug(1, "Dropping control frame from bridge channel %p\n", bridge_channel);
 293                 } else {
 294                         if (frame->frametype == AST_FRAME_DTMF_BEGIN) {
 295                                 frame = bridge_handle_dtmf(bridge, bridge_channel, frame);
 296                         }
 297                         /* Simply write the frame out to the bridge technology if it still exists */
 298                         if (frame) {
 299                                 bridge->technology->write(bridge, bridge_channel, frame);
 300                         }
 301                 }
 302
 303                 if (frame) {
 304                         ast_frfree(frame);
 305                 }
 306                 return;
 307         }
 308
 309         /* If a file descriptor actually tripped pass it off to the bridge technology */
 310         if (outfd > -1 && bridge->technology->fd) {
 311                 bridge->technology->fd(bridge, bridge_channel, outfd);
 312                 return;
 313         }
 314
 315         /* If all else fails just poke the bridge */
 316         if (bridge->technology->poke && bridge_channel) {
 317                 bridge->technology->poke(bridge, bridge_channel);
 318                 return;
 319         }
 320
 321         return;
 322 }
 323
 324 /*! \brief Generic thread loop, TODO: Rethink this/improve it */
 325 static int generic_thread_loop(struct ast_bridge *bridge)
 326 {
 327         while (!bridge->stop && !bridge->refresh && bridge->array_num) {
 328                 struct ast_channel *winner = NULL;
 329                 int to = -1;
 330
 331                 /* Move channels around for priority reasons if we have more than one channel in our array */
 332                 if (bridge->array_num > 1) {
 333                         struct ast_channel *first = bridge->array[0];
 334                         memmove(bridge->array, bridge->array + 1, sizeof(struct ast_channel *) * (bridge->array_num - 1));
 335                         bridge->array[(bridge->array_num - 1)] = first;
 336                 }
 337
 338                 /* Wait on the channels */
 339                 bridge->waiting = 1;
 340                 ao2_unlock(bridge);
 341                 winner = ast_waitfor_n(bridge->array, (int)bridge->array_num, &to);
 342                 bridge->waiting = 0;
 343                 ao2_lock(bridge);
 344
 345                 /* Process whatever they did */
 346                 ast_bridge_handle_trip(bridge, NULL, winner, -1);
 347         }
 348
 349         return 0;
 350 }
 351
 352 /*! \brief Bridge thread function */
 353 static void *bridge_thread(void *data)
 354 {
 355         struct ast_bridge *bridge = data;
 356         int res = 0;
 357
 358         ao2_lock(bridge);
 359
 360         ast_debug(1, "Started bridge thread for %p\n", bridge);
 361
 362         /* Loop around until we are told to stop */
 363         while (!bridge->stop && bridge->array_num && !res) {
 364                 /* In case the refresh bit was set simply set it back to off */
 365                 bridge->refresh = 0;
 366
 367                 ast_debug(1, "Launching bridge thread function %p for bridge %p\n", (bridge->technology->thread ? bridge->technology->thread : &generic_thread_loop), bridge);
 368
 369                 /* Execute the appropriate thread function. If the technology does not provide one we use the generic one */
 370                 res = (bridge->technology->thread ? bridge->technology->thread(bridge) : generic_thread_loop(bridge));
 371         }
 372
 373         ast_debug(1, "Ending bridge thread for %p\n", bridge);
 374
 375         /* Indicate the bridge thread is no longer active */
 376         bridge->thread = AST_PTHREADT_NULL;
 377         ao2_unlock(bridge);
 378
 379         ao2_ref(bridge, -1);
 380
 381         return NULL;
 382 }
 383
 384 /*! \brief Helper function used to find the "best" bridge technology given a specified capabilities */
 385 static struct ast_bridge_technology *find_best_technology(int capabilities)
 386 {
 387         struct ast_bridge_technology *current = NULL, *best = NULL;
 388
 389         AST_RWLIST_RDLOCK(&bridge_technologies);
 390         AST_RWLIST_TRAVERSE(&bridge_technologies, current, entry) {
 391                 ast_debug(1, "Bridge technology %s has capabilities %d and we want %d\n", current->name, current->capabilities, capabilities);
 392                 if (current->suspended) {
 393                         ast_debug(1, "Bridge technology %s is suspended. Skipping.\n", current->name);
 394                         continue;
 395                 }
 396                 if (!(current->capabilities & capabilities)) {
 397                         ast_debug(1, "Bridge technology %s does not have the capabilities we need.\n", current->name);
 398                         continue;
 399                 }
 400                 if (best && best->preference < current->preference) {
 401                         ast_debug(1, "Bridge technology %s has preference %d while %s has preference %d. Skipping.\n", current->name, current->preference, best->name, best->preference);
 402                         continue;
 403                 }
 404                 best = current;
 405         }
 406
 407         if (best) {
 408                 /* Increment it's module reference count if present so it does not get unloaded while in use */
 409                 if (best->mod) {
 410                         ast_module_ref(best->mod);
 411                 }
 412                 ast_debug(1, "Chose bridge technology %s\n", best->name);
 413         }
 414
 415         AST_RWLIST_UNLOCK(&bridge_technologies);
 416
 417         return best;
 418 }
 419
 420 static void destroy_bridge(void *obj)
 421 {
 422         struct ast_bridge *bridge = obj;
 423
 424         ast_debug(1, "Actually destroying bridge %p, nobody wants it anymore\n", bridge);
 425
 426         /* Pass off the bridge to the technology to destroy if needed */
 427         if (bridge->technology->destroy) {
 428                 ast_debug(1, "Giving bridge technology %s the bridge structure %p to destroy\n", bridge->technology->name, bridge);
 429                 if (bridge->technology->destroy(bridge)) {
 430                         ast_debug(1, "Bridge technology %s failed to destroy bridge structure %p... trying our best\n", bridge->technology->name, bridge);
 431                 }
 432         }
 433
 434         /* We are no longer using the bridge technology so decrement the module reference count on it */
 435         if (bridge->technology->mod) {
 436                 ast_module_unref(bridge->technology->mod);
 437         }
 438
 439         /* Last but not least clean up the features configuration */
 440         ast_bridge_features_cleanup(&bridge->features);
 441
 442         /* Drop the array of channels */
 443         ast_free(bridge->array);
 444
 445         return;
 446 }
 447
 448 struct ast_bridge *ast_bridge_new(int capabilities, int flags)
 449 {
 450         struct ast_bridge *bridge = NULL;
 451         struct ast_bridge_technology *bridge_technology = NULL;
 452
 453         /* If we need to be a smart bridge see if we can move between 1to1 and multimix bridges */
 454         if (flags & AST_BRIDGE_FLAG_SMART) {
 455                 struct ast_bridge *other_bridge;
 456
 457                 if (!(other_bridge = ast_bridge_new((capabilities & AST_BRIDGE_CAPABILITY_1TO1MIX) ? AST_BRIDGE_CAPABILITY_MULTIMIX : AST_BRIDGE_CAPABILITY_1TO1MIX, 0))) {
 458                         return NULL;
 459                 }
 460
 461                 ast_bridge_destroy(other_bridge);
 462         }
 463
 464         /* If capabilities were provided use our helper function to find the "best" bridge technology, otherwise we can
 465          * just look for the most basic capability needed, single 1to1 mixing. */
 466         bridge_technology = (capabilities ? find_best_technology(capabilities) : find_best_technology(AST_BRIDGE_CAPABILITY_1TO1MIX));
 467
 468         /* If no bridge technology was found we can't possibly do bridging so fail creation of the bridge */
 469         if (!bridge_technology) {
 470                 ast_debug(1, "Failed to find a bridge technology to satisfy capabilities %d\n", capabilities);
 471                 return NULL;
 472         }
 473
 474         /* We have everything we need to create this bridge... so allocate the memory, link things together, and fire her up! */
 475         if (!(bridge = ao2_alloc(sizeof(*bridge), destroy_bridge))) {
 476                 return NULL;
 477         }
 478
 479         bridge->technology = bridge_technology;
 480         bridge->thread = AST_PTHREADT_NULL;
 481
 482         /* Create an array of pointers for the channels that will be joining us */
 483         bridge->array = ast_calloc(BRIDGE_ARRAY_START, sizeof(struct ast_channel*));
 484         bridge->array_size = BRIDGE_ARRAY_START;
 485
 486         ast_set_flag(&bridge->feature_flags, flags);
 487
 488         /* Pass off the bridge to the technology to manipulate if needed */
 489         if (bridge->technology->create) {
 490                 ast_debug(1, "Giving bridge technology %s the bridge structure %p to setup\n", bridge->technology->name, bridge);
 491                 if (bridge->technology->create(bridge)) {
 492                         ast_debug(1, "Bridge technology %s failed to setup bridge structure %p\n", bridge->technology->name, bridge);
 493                         ao2_ref(bridge, -1);
 494                         bridge = NULL;
 495                 }
 496         }
 497
 498         return bridge;
 499 }
 500
 501 int ast_bridge_check(int capabilities)
 502 {
 503         struct ast_bridge_technology *bridge_technology = NULL;
 504
 505         if (!(bridge_technology = find_best_technology(capabilities))) {
 506                 return 0;
 507         }
 508
 509         ast_module_unref(bridge_technology->mod);
 510
 511         return 1;
 512 }
 513
 514 int ast_bridge_destroy(struct ast_bridge *bridge)
 515 {
 516         struct ast_bridge_channel *bridge_channel = NULL;
 517
 518         ao2_lock(bridge);
 519
 520         bridge->stop = 1;
 521
 522         bridge_poke(bridge);
 523
 524         ast_debug(1, "Telling all channels in bridge %p to end and leave the party\n", bridge);
 525
 526         /* Drop every bridged channel, the last one will cause the bridge thread (if it exists) to exit */
 527         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
 528                 ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_END);
 529         }
 530
 531         ao2_unlock(bridge);
 532
 533         ao2_ref(bridge, -1);
 534
 535         return 0;
 536 }
 537
 538 static int bridge_make_compatible(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 539 {
 540         int formats[2] = {bridge_channel->chan->readformat, bridge_channel->chan->writeformat};
 541
 542         /* Are the formats currently in use something ths bridge can handle? */
 543         if (!(bridge->technology->formats & bridge_channel->chan->readformat)) {
 544                 int best_format = ast_best_codec(bridge->technology->formats);
 545
 546                 /* Read format is a no go... */
 547                 if (option_debug) {
 548                         char codec_buf[512];
 549                         ast_getformatname_multiple(codec_buf, sizeof(codec_buf), bridge->technology->formats);
 550                         ast_debug(1, "Bridge technology %s wants to read any of formats %s(%d) but channel has %s(%d)\n", bridge->technology->name, codec_buf, bridge->technology->formats, ast_getformatname(formats[0]), formats[0]);
 551                 }
 552                 /* Switch read format to the best one chosen */
 553                 if (ast_set_read_format(bridge_channel->chan, best_format)) {
 554                         ast_log(LOG_WARNING, "Failed to set channel %s to read format %s(%d)\n", bridge_channel->chan->name, ast_getformatname(best_format), best_format);
 555                         return -1;
 556                 }
 557                 ast_debug(1, "Bridge %p put channel %s into read format %s(%d)\n", bridge, bridge_channel->chan->name, ast_getformatname(best_format), best_format);
 558         } else {
 559                 ast_debug(1, "Bridge %p is happy that channel %s already has read format %s(%d)\n", bridge, bridge_channel->chan->name, ast_getformatname(formats[0]), formats[0]);
 560         }
 561
 562         if (!(bridge->technology->formats & formats[1])) {
 563                 int best_format = ast_best_codec(bridge->technology->formats);
 564
 565                 /* Write format is a no go... */
 566                 if (option_debug) {
 567                         char codec_buf[512];
 568                         ast_getformatname_multiple(codec_buf, sizeof(codec_buf), bridge->technology->formats);
 569                         ast_debug(1, "Bridge technology %s wants to write any of formats %s(%d) but channel has %s(%d)\n", bridge->technology->name, codec_buf, bridge->technology->formats, ast_getformatname(formats[1]), formats[1]);
 570                 }
 571                 /* Switch write format to the best one chosen */
 572                 if (ast_set_write_format(bridge_channel->chan, best_format)) {
 573                         ast_log(LOG_WARNING, "Failed to set channel %s to write format %s(%d)\n", bridge_channel->chan->name, ast_getformatname(best_format), best_format);
 574                         return -1;
 575                 }
 576                 ast_debug(1, "Bridge %p put channel %s into write format %s(%d)\n", bridge, bridge_channel->chan->name, ast_getformatname(best_format), best_format);
 577         } else {
 578                 ast_debug(1, "Bridge %p is happy that channel %s already has write format %s(%d)\n", bridge, bridge_channel->chan->name, ast_getformatname(formats[1]), formats[1]);
 579         }
 580
 581         return 0;
 582 }
 583
 584 /*! \brief Perform the smart bridge operation. Basically sees if a new bridge technology should be used instead of the current one. */
 585 static int smart_bridge_operation(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, int count)
 586 {
 587         int new_capabilities = 0;
 588         struct ast_bridge_technology *new_technology = NULL, *old_technology = bridge->technology;
 589         struct ast_bridge temp_bridge = {
 590                 .technology = bridge->technology,
 591                 .bridge_pvt = bridge->bridge_pvt,
 592         };
 593         struct ast_bridge_channel *bridge_channel2 = NULL;
 594
 595         /* Based on current feature determine whether we want to change bridge technologies or not */
 596         if (bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_1TO1MIX) {
 597                 if (count <= 2) {
 598                         ast_debug(1, "Bridge %p channel count (%d) is within limits for bridge technology %s, not performing smart bridge operation.\n", bridge, count, bridge->technology->name);
 599                         return 0;
 600                 }
 601                 new_capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX;
 602         } else if (bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX) {
 603                 if (count > 2) {
 604                         ast_debug(1, "Bridge %p channel count (%d) is within limits for bridge technology %s, not performing smart bridge operation.\n", bridge, count, bridge->technology->name);
 605                         return 0;
 606                 }
 607                 new_capabilities = AST_BRIDGE_CAPABILITY_1TO1MIX;
 608         }
 609
 610         if (!new_capabilities) {
 611                 ast_debug(1, "Bridge '%p' has no new capabilities, not performing smart bridge operation.\n", bridge);
 612                 return 0;
 613         }
 614
 615         /* Attempt to find a new bridge technology to satisfy the capabilities */
 616         if (!(new_technology = find_best_technology(new_capabilities))) {
 617                 ast_debug(1, "Smart bridge operation was unable to find new bridge technology with capabilities %d to satisfy bridge %p\n", new_capabilities, bridge);
 618                 return -1;
 619         }
 620
 621         ast_debug(1, "Performing smart bridge operation on bridge %p, moving from bridge technology %s to %s\n", bridge, old_technology->name, new_technology->name);
 622
 623         /* If a thread is currently executing for the current technology tell it to stop */
 624         if (bridge->thread != AST_PTHREADT_NULL) {
 625                 /* If the new bridge technology also needs a thread simply tell the bridge thread to refresh itself. This has the benefit of not incurring the cost/time of tearing down and bringing up a new thread. */
 626                 if (new_technology->capabilities & AST_BRIDGE_CAPABILITY_THREAD) {
 627                         ast_debug(1, "Telling current bridge thread for bridge %p to refresh\n", bridge);
 628                         bridge->refresh = 1;
 629                 } else {
 630                         ast_debug(1, "Telling current bridge thread for bridge %p to stop\n", bridge);
 631                         bridge->stop = 1;
 632                 }
 633                 bridge_poke(bridge);
 634         }
 635
 636         /* Since we are soon going to pass this bridge to a new technology we need to NULL out the bridge_pvt pointer but don't worry as it still exists in temp_bridge, ditto for the old technology */
 637         bridge->bridge_pvt = NULL;
 638         bridge->technology = new_technology;
 639
 640         /* Pass the bridge to the new bridge technology so it can set it up */
 641         if (new_technology->create) {
 642                 ast_debug(1, "Giving bridge technology %s the bridge structure %p to setup\n", new_technology->name, bridge);
 643                 if (new_technology->create(bridge)) {
 644                         ast_debug(1, "Bridge technology %s failed to setup bridge structure %p\n", new_technology->name, bridge);
 645                 }
 646         }
 647
 648         /* Move existing channels over to the new technology, while taking them away from the old one */
 649         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel2, entry) {
 650                 /* Skip over channel that initiated the smart bridge operation */
 651                 if (bridge_channel == bridge_channel2) {
 652                         continue;
 653                 }
 654
 655                 /* First we part them from the old technology */
 656                 if (old_technology->leave) {
 657                         ast_debug(1, "Giving bridge technology %s notification that %p is leaving bridge %p (really %p)\n", old_technology->name, bridge_channel2, &temp_bridge, bridge);
 658                         if (old_technology->leave(&temp_bridge, bridge_channel2)) {
 659                                 ast_debug(1, "Bridge technology %s failed to allow %p (really %p) to leave bridge %p\n", old_technology->name, bridge_channel2, &temp_bridge, bridge);
 660                         }
 661                 }
 662
 663                 /* Second we make them compatible again with the bridge */
 664                 bridge_make_compatible(bridge, bridge_channel2);
 665
 666                 /* Third we join them to the new technology */
 667                 if (new_technology->join) {
 668                         ast_debug(1, "Giving bridge technology %s notification that %p is joining bridge %p\n", new_technology->name, bridge_channel2, bridge);
 669                         if (new_technology->join(bridge, bridge_channel2)) {
 670                                 ast_debug(1, "Bridge technology %s failed to join %p to bridge %p\n", new_technology->name, bridge_channel2, bridge);
 671                         }
 672                 }
 673
 674                 /* Fourth we tell them to wake up so they become aware that they above has happened */
 675                 pthread_kill(bridge_channel2->thread, SIGURG);
 676                 ast_mutex_lock(&bridge_channel2->lock);
 677                 ast_cond_signal(&bridge_channel2->cond);
 678                 ast_mutex_unlock(&bridge_channel2->lock);
 679         }
 680
 681         /* Now that all the channels have been moved over we need to get rid of all the information the old technology may have left around */
 682         if (old_technology->destroy) {
 683                 ast_debug(1, "Giving bridge technology %s the bridge structure %p (really %p) to destroy\n", old_technology->name, &temp_bridge, bridge);
 684                 if (old_technology->destroy(&temp_bridge)) {
 685                         ast_debug(1, "Bridge technology %s failed to destroy bridge structure %p (really %p)... some memory may have leaked\n", old_technology->name, &temp_bridge, bridge);
 686                 }
 687         }
 688
 689         /* Finally if the old technology has module referencing remove our reference, we are no longer going to use it */
 690         if (old_technology->mod) {
 691                 ast_module_unref(old_technology->mod);
 692         }
 693
 694         return 0;
 695 }
 696
 697 /*! \brief Run in a multithreaded model. Each joined channel does writing/reading in their own thread. TODO: Improve */
 698 static enum ast_bridge_channel_state bridge_channel_join_multithreaded(struct ast_bridge_channel *bridge_channel)
 699 {
 700         int fds[4] = { -1, }, nfds = 0, i = 0, outfd = -1, ms = -1;
 701         struct ast_channel *chan = NULL;
 702
 703         /* Add any file descriptors we may want to monitor */
 704         if (bridge_channel->bridge->technology->fd) {
 705                 for (i = 0; i < 4; i ++) {
 706                         if (bridge_channel->fds[i] >= 0) {
 707                                 fds[nfds++] = bridge_channel->fds[i];
 708                         }
 709                 }
 710         }
 711
 712         ao2_unlock(bridge_channel->bridge);
 713
 714         /* Wait for data to either come from the channel or us to be signalled */
 715         if (!bridge_channel->suspended) {
 716                 ast_debug(1, "Going into a multithreaded waitfor for bridge channel %p of bridge %p\n", bridge_channel, bridge_channel->bridge);
 717                 chan = ast_waitfor_nandfds(&bridge_channel->chan, 1, fds, nfds, NULL, &outfd, &ms);
 718         } else {
 719                 ast_mutex_lock(&bridge_channel->lock);
 720                 ast_debug(1, "Going into a multithreaded signal wait for bridge channel %p of bridge %p\n", bridge_channel, bridge_channel->bridge);
 721                 ast_cond_wait(&bridge_channel->cond, &bridge_channel->lock);
 722                 ast_mutex_unlock(&bridge_channel->lock);
 723         }
 724
 725         ao2_lock(bridge_channel->bridge);
 726
 727         if (!bridge_channel->suspended) {
 728                 ast_bridge_handle_trip(bridge_channel->bridge, bridge_channel, chan, outfd);
 729         }
 730
 731         return bridge_channel->state;
 732 }
 733
 734 /*! \brief Run in a singlethreaded model. Each joined channel yields itself to the main bridge thread. TODO: Improve */
 735 static enum ast_bridge_channel_state bridge_channel_join_singlethreaded(struct ast_bridge_channel *bridge_channel)
 736 {
 737         ao2_unlock(bridge_channel->bridge);
 738         ast_mutex_lock(&bridge_channel->lock);
 739         if (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_WAIT) {
 740                 ast_debug(1, "Going into a single threaded signal wait for bridge channel %p of bridge %p\n", bridge_channel, bridge_channel->bridge);
 741                 ast_cond_wait(&bridge_channel->cond, &bridge_channel->lock);
 742         }
 743         ast_mutex_unlock(&bridge_channel->lock);
 744         ao2_lock(bridge_channel->bridge);
 745
 746         return bridge_channel->state;
 747 }
 748
 749 /*! \brief Internal function that suspends a channel from a bridge */
 750 static void bridge_channel_suspend(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 751 {
 752         bridge_channel->suspended = 1;
 753
 754         bridge_array_remove(bridge, bridge_channel->chan);
 755
 756         if (bridge->technology->suspend) {
 757                 bridge->technology->suspend(bridge, bridge_channel);
 758         }
 759
 760         return;
 761 }
 762
 763 /*! \brief Internal function that unsuspends a channel from a bridge */
 764 static void bridge_channel_unsuspend(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 765 {
 766         bridge_channel->suspended =0;
 767
 768         bridge_array_add(bridge, bridge_channel->chan);
 769
 770         if (bridge->technology->unsuspend) {
 771                 bridge->technology->unsuspend(bridge, bridge_channel);
 772         }
 773
 774         return;
 775 }
 776
 777 /*! \brief Internal function that executes a feature on a bridge channel */
 778 static void bridge_channel_feature(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 779 {
 780         struct ast_bridge_features *features = (bridge_channel->features ? bridge_channel->features : &bridge->features);
 781         struct ast_bridge_features_hook *hook = NULL;
 782         char dtmf[MAXIMUM_DTMF_FEATURE_STRING] = "";
 783         int look_for_dtmf = 1, dtmf_len = 0;
 784
 785         /* The channel is now under our control and we don't really want any begin frames to do our DTMF matching so disable 'em at the core level */
 786         ast_set_flag(bridge_channel->chan, AST_FLAG_END_DTMF_ONLY);
 787
 788         /* Wait for DTMF on the channel and put it into a buffer. If the buffer matches any feature hook execute the hook. */
 789         while (look_for_dtmf) {
 790                 int res = ast_waitfordigit(bridge_channel->chan, 3000);
 791
 792                 /* If the above timed out simply exit */
 793                 if (!res) {
 794                         ast_debug(1, "DTMF feature string collection on bridge channel %p timed out\n", bridge_channel);
 795                         break;
 796                 } else if (res < 0) {
 797                         ast_debug(1, "DTMF feature string collection failed on bridge channel %p for some reason\n", bridge_channel);
 798                         break;
 799                 }
 800
 801                 /* Add the above DTMF into the DTMF string so we can do our matching */
 802                 dtmf[dtmf_len++] = res;
 803
 804                 ast_debug(1, "DTMF feature string on bridge channel %p is now '%s'\n", bridge_channel, dtmf);
 805
 806                 /* Assume that we do not want to look for DTMF any longer */
 807                 look_for_dtmf = 0;
 808
 809                 /* See if a DTMF feature hook matches or can match */
 810                 AST_LIST_TRAVERSE(&features->hooks, hook, entry) {
 811                         /* If this hook matches just break out now */
 812                         if (!strcmp(hook->dtmf, dtmf)) {
 813                                 ast_debug(1, "DTMF feature hook %p matched DTMF string '%s' on bridge channel %p\n", hook, dtmf, bridge_channel);
 814                                 break;
 815                         } else if (!strncmp(hook->dtmf, dtmf, dtmf_len)) {
 816                                 ast_debug(1, "DTMF feature hook %p can match DTMF string '%s', it wants '%s', on bridge channel %p\n", hook, dtmf, hook->dtmf, bridge_channel);
 817                                 look_for_dtmf = 1;
 818                         } else {
 819                                 ast_debug(1, "DTMF feature hook %p does not match DTMF string '%s', it wants '%s', on bridge channel %p\n", hook, dtmf, hook->dtmf, bridge_channel);
 820                         }
 821                 }
 822
 823                 /* If we have reached the maximum length of a DTMF feature string bail out */
 824                 if (dtmf_len == MAXIMUM_DTMF_FEATURE_STRING) {
 825                         break;
 826                 }
 827         }
 828
 829         /* Since we are done bringing DTMF in return to using both begin and end frames */
 830         ast_clear_flag(bridge_channel->chan, AST_FLAG_END_DTMF_ONLY);
 831
 832         /* If a hook was actually matched execute it on this channel, otherwise stream up the DTMF to the other channels */
 833         if (hook) {
 834                 hook->callback(bridge, bridge_channel, hook->hook_pvt);
 835         } else {
 836                 ast_bridge_dtmf_stream(bridge, dtmf, bridge_channel->chan);
 837                 ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_WAIT);
 838         }
 839
 840         return;
 841 }
 842
 843 /*! \brief Internal function that plays back DTMF on a bridge channel */
 844 static void bridge_channel_dtmf_stream(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 845 {
 846         char dtmf_q[8] = "";
 847
 848         ast_copy_string(dtmf_q, bridge_channel->dtmf_stream_q, sizeof(dtmf_q));
 849         bridge_channel->dtmf_stream_q[0] = '\0';
 850
 851         ast_debug(1, "Playing DTMF stream '%s' out to bridge channel %p\n", dtmf_q, bridge_channel);
 852         ast_dtmf_stream(bridge_channel->chan, NULL, dtmf_q, 250, 0);
 853
 854         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_WAIT);
 855
 856         return;
 857 }
 858
 859 /*! \brief Join a channel to a bridge and handle anything the bridge may want us to do */
 860 static enum ast_bridge_channel_state bridge_channel_join(struct ast_bridge_channel *bridge_channel)
 861 {
 862         int formats[2] = { bridge_channel->chan->readformat, bridge_channel->chan->writeformat };
 863         enum ast_bridge_channel_state state;
 864
 865         /* Record the thread that will be the owner of us */
 866         bridge_channel->thread = pthread_self();
 867
 868         ast_debug(1, "Joining bridge channel %p to bridge %p\n", bridge_channel, bridge_channel->bridge);
 869
 870         ao2_lock(bridge_channel->bridge);
 871
 872         state = bridge_channel->state;
 873
 874         /* Add channel into the bridge */
 875         AST_LIST_INSERT_TAIL(&bridge_channel->bridge->channels, bridge_channel, entry);
 876         bridge_channel->bridge->num++;
 877
 878         bridge_array_add(bridge_channel->bridge, bridge_channel->chan);
 879
 880         if (bridge_channel->swap) {
 881                 struct ast_bridge_channel *bridge_channel2 = NULL;
 882
 883                 /* If we are performing a swap operation we do not need to execute the smart bridge operation as the actual number of channels involved will not have changed, we just need to tell the other channel to leave */
 884                 if ((bridge_channel2 = find_bridge_channel(bridge_channel->bridge, bridge_channel->swap))) {
 885                         ast_debug(1, "Swapping bridge channel %p out from bridge %p so bridge channel %p can slip in\n", bridge_channel2, bridge_channel->bridge, bridge_channel);
 886                         ast_bridge_change_state(bridge_channel2, AST_BRIDGE_CHANNEL_STATE_HANGUP);
 887                 }
 888
 889                 bridge_channel->swap = NULL;
 890         } else if (ast_test_flag(&bridge_channel->bridge->feature_flags, AST_BRIDGE_FLAG_SMART)) {
 891                 /* Perform the smart bridge operation, basically see if we need to move around between technologies */
 892                 smart_bridge_operation(bridge_channel->bridge, bridge_channel, bridge_channel->bridge->num);
 893         }
 894
 895         /* Make the channel compatible with the bridge */
 896         bridge_make_compatible(bridge_channel->bridge, bridge_channel);
 897
 898         /* Tell the bridge technology we are joining so they set us up */
 899         if (bridge_channel->bridge->technology->join) {
 900                 ast_debug(1, "Giving bridge technology %s notification that %p is joining bridge %p\n", bridge_channel->bridge->technology->name, bridge_channel, bridge_channel->bridge);
 901                 if (bridge_channel->bridge->technology->join(bridge_channel->bridge, bridge_channel)) {
 902                         ast_debug(1, "Bridge technology %s failed to join %p to bridge %p\n", bridge_channel->bridge->technology->name, bridge_channel, bridge_channel->bridge);
 903                 }
 904         }
 905
 906         /* Actually execute the respective threading model, and keep our bridge thread alive */
 907         while (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_WAIT) {
 908                 /* Update bridge pointer on channel */
 909                 bridge_channel->chan->bridge = bridge_channel->bridge;
 910                 /* If the technology requires a thread and one is not running, start it up */
 911                 if (bridge_channel->bridge->thread == AST_PTHREADT_NULL && (bridge_channel->bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_THREAD)) {
 912                         bridge_channel->bridge->stop = 0;
 913                         ast_debug(1, "Starting a bridge thread for bridge %p\n", bridge_channel->bridge);
 914                         ao2_ref(bridge_channel->bridge, +1);
 915                         if (ast_pthread_create(&bridge_channel->bridge->thread, NULL, bridge_thread, bridge_channel->bridge)) {
 916                                 ast_debug(1, "Failed to create a bridge thread for bridge %p, giving it another go.\n", bridge_channel->bridge);
 917                                 ao2_ref(bridge_channel->bridge, -1);
 918                                 continue;
 919                         }
 920                 }
 921                 /* Execute the threading model */
 922                 state = (bridge_channel->bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTITHREADED ? bridge_channel_join_multithreaded(bridge_channel) : bridge_channel_join_singlethreaded(bridge_channel));
 923                 /* Depending on the above state see what we need to do */
 924                 if (state == AST_BRIDGE_CHANNEL_STATE_FEATURE) {
 925                         bridge_channel_suspend(bridge_channel->bridge, bridge_channel);
 926                         bridge_channel_feature(bridge_channel->bridge, bridge_channel);
 927                         bridge_channel_unsuspend(bridge_channel->bridge, bridge_channel);
 928                 } else if (state == AST_BRIDGE_CHANNEL_STATE_DTMF) {
 929                         bridge_channel_suspend(bridge_channel->bridge, bridge_channel);
 930                         bridge_channel_dtmf_stream(bridge_channel->bridge, bridge_channel);
 931                         bridge_channel_unsuspend(bridge_channel->bridge, bridge_channel);
 932                 }
 933         }
 934
 935         bridge_channel->chan->bridge = NULL;
 936
 937         /* See if we need to dissolve the bridge itself if they hung up */
 938         if (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_END) {
 939                 bridge_check_dissolve(bridge_channel->bridge, bridge_channel);
 940         }
 941
 942         /* Tell the bridge technology we are leaving so they tear us down */
 943         if (bridge_channel->bridge->technology->leave) {
 944                 ast_debug(1, "Giving bridge technology %s notification that %p is leaving bridge %p\n", bridge_channel->bridge->technology->name, bridge_channel, bridge_channel->bridge);
 945                 if (bridge_channel->bridge->technology->leave(bridge_channel->bridge, bridge_channel)) {
 946                         ast_debug(1, "Bridge technology %s failed to leave %p from bridge %p\n", bridge_channel->bridge->technology->name, bridge_channel, bridge_channel->bridge);
 947                 }
 948         }
 949
 950         /* Remove channel from the bridge */
 951         bridge_channel->bridge->num--;
 952         AST_LIST_REMOVE(&bridge_channel->bridge->channels, bridge_channel, entry);
 953
 954         bridge_array_remove(bridge_channel->bridge, bridge_channel->chan);
 955
 956         /* Perform the smart bridge operation if needed since a channel has left */
 957         if (ast_test_flag(&bridge_channel->bridge->feature_flags, AST_BRIDGE_FLAG_SMART)) {
 958                 smart_bridge_operation(bridge_channel->bridge, NULL, bridge_channel->bridge->num);
 959         }
 960
 961         ao2_unlock(bridge_channel->bridge);
 962
 963         /* Restore original formats of the channel as they came in */
 964         if (bridge_channel->chan->readformat != formats[0]) {
 965                 ast_debug(1, "Bridge is returning %p to read format %s(%d)\n", bridge_channel, ast_getformatname(formats[0]), formats[0]);
 966                 if (ast_set_read_format(bridge_channel->chan, formats[0])) {
 967                         ast_debug(1, "Bridge failed to return channel %p to read format %s(%d)\n", bridge_channel, ast_getformatname(formats[0]), formats[0]);
 968                 }
 969         }
 970         if (bridge_channel->chan->writeformat != formats[1]) {
 971                 ast_debug(1, "Bridge is returning %p to write format %s(%d)\n", bridge_channel, ast_getformatname(formats[1]), formats[1]);
 972                 if (ast_set_write_format(bridge_channel->chan, formats[1])) {
 973                         ast_debug(1, "Bridge failed to return channel %p to write format %s(%d)\n", bridge_channel, ast_getformatname(formats[1]), formats[1]);
 974                 }
 975         }
 976
 977         return bridge_channel->state;
 978 }
 979
 980 enum ast_bridge_channel_state ast_bridge_join(struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap, struct ast_bridge_features *features)
 981 {
 982         struct ast_bridge_channel bridge_channel = {
 983                 .chan = chan,
 984                 .swap = swap,
 985                 .bridge = bridge,
 986                 .features = features,
 987         };
 988         enum ast_bridge_channel_state state;
 989
 990         /* Initialize various other elements of the bridge channel structure that we can't do above */
 991         ast_mutex_init(&bridge_channel.lock);
 992         ast_cond_init(&bridge_channel.cond, NULL);
 993
 994         ao2_ref(bridge_channel.bridge, +1);
 995
 996         state = bridge_channel_join(&bridge_channel);
 997
 998         ao2_ref(bridge_channel.bridge, -1);
 999
1000         /* Destroy some elements of the bridge channel structure above */
1001         ast_mutex_destroy(&bridge_channel.lock);
1002         ast_cond_destroy(&bridge_channel.cond);
1003
1004         return state;
1005 }
1006
1007 /*! \brief Thread responsible for imparted bridged channels */
1008 static void *bridge_channel_thread(void *data)
1009 {
1010         struct ast_bridge_channel *bridge_channel = data;
1011         enum ast_bridge_channel_state state;
1012
1013         state = bridge_channel_join(bridge_channel);
1014
1015         ao2_ref(bridge_channel->bridge, -1);
1016
1017         /* If no other thread is going to take the channel then hang it up, or else we would have to service it until something else came along */
1018         if (state == AST_BRIDGE_CHANNEL_STATE_END || state == AST_BRIDGE_CHANNEL_STATE_HANGUP) {
1019                 ast_hangup(bridge_channel->chan);
1020         }
1021
1022         /* Destroy elements of the bridge channel structure and the bridge channel structure itself */
1023         ast_mutex_destroy(&bridge_channel->lock);
1024         ast_cond_destroy(&bridge_channel->cond);
1025         ast_free(bridge_channel);
1026
1027         return NULL;
1028 }
1029
1030 int ast_bridge_impart(struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap, struct ast_bridge_features *features)
1031 {
1032         struct ast_bridge_channel *bridge_channel = NULL;
1033
1034         /* Try to allocate a structure for the bridge channel */
1035         if (!(bridge_channel = ast_calloc(1, sizeof(*bridge_channel)))) {
1036                 return -1;
1037         }
1038
1039         /* Setup various parameters */
1040         bridge_channel->chan = chan;
1041         bridge_channel->swap = swap;
1042         bridge_channel->bridge = bridge;
1043         bridge_channel->features = features;
1044
1045         /* Initialize our mutex lock and condition */
1046         ast_mutex_init(&bridge_channel->lock);
1047         ast_cond_init(&bridge_channel->cond, NULL);
1048
1049         /* Bump up the reference count on the bridge, it'll get decremented later */
1050         ao2_ref(bridge, +1);
1051
1052         /* Actually create the thread that will handle the channel */
1053         if (ast_pthread_create(&bridge_channel->thread, NULL, bridge_channel_thread, bridge_channel)) {
1054                 ao2_ref(bridge, -1);
1055                 ast_cond_destroy(&bridge_channel->cond);
1056                 ast_mutex_destroy(&bridge_channel->lock);
1057                 ast_free(bridge_channel);
1058                 return -1;
1059         }
1060
1061         return 0;
1062 }
1063
1064 int ast_bridge_depart(struct ast_bridge *bridge, struct ast_channel *chan)
1065 {
1066         struct ast_bridge_channel *bridge_channel = NULL;
1067         pthread_t thread;
1068
1069         ao2_lock(bridge);
1070
1071         /* Try to find the channel that we want to depart */
1072         if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
1073                 ao2_unlock(bridge);
1074                 return -1;
1075         }
1076
1077         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_DEPART);
1078         thread = bridge_channel->thread;
1079
1080         ao2_unlock(bridge);
1081
1082         pthread_join(thread, NULL);
1083
1084         return 0;
1085 }
1086
1087 int ast_bridge_remove(struct ast_bridge *bridge, struct ast_channel *chan)
1088 {
1089         struct ast_bridge_channel *bridge_channel = NULL;
1090
1091         ao2_lock(bridge);
1092
1093         /* Try to find the channel that we want to remove */
1094         if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
1095                 ao2_unlock(bridge);
1096                 return -1;
1097         }
1098
1099         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
1100
1101         ao2_unlock(bridge);
1102
1103         return 0;
1104 }
1105
1106 int ast_bridge_merge(struct ast_bridge *bridge0, struct ast_bridge *bridge1)
1107 {
1108         struct ast_bridge_channel *bridge_channel = NULL;
1109
1110         ao2_lock(bridge0);
1111         ao2_lock(bridge1);
1112
1113         /* If the first bridge currently has 2 channels and is not capable of becoming a multimixing bridge we can not merge */
1114         if ((bridge0->num + bridge1->num) > 2 && (!(bridge0->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX) && !ast_test_flag(&bridge0->feature_flags, AST_BRIDGE_FLAG_SMART))) {
1115                 ao2_unlock(bridge1);
1116                 ao2_unlock(bridge0);
1117                 ast_debug(1, "Can't merge bridge %p into bridge %p, multimix is needed and it could not be acquired.\n", bridge1, bridge0);
1118                 return -1;
1119         }
1120
1121         ast_debug(1, "Merging channels from bridge %p into bridge %p\n", bridge1, bridge0);
1122
1123         /* Perform smart bridge operation on bridge we are merging into so it can change bridge technology if needed */
1124         if (smart_bridge_operation(bridge0, NULL, bridge0->num + bridge1->num)) {
1125                 ao2_unlock(bridge1);
1126                 ao2_unlock(bridge0);
1127                 ast_debug(1, "Can't merge bridge %p into bridge %p, tried to perform smart bridge operation and failed.\n", bridge1, bridge0);
1128                 return -1;
1129         }
1130
1131         /* If a thread is currently executing on bridge1 tell it to stop */
1132         if (bridge1->thread) {
1133                 ast_debug(1, "Telling bridge thread on bridge %p to stop as it is being merged into %p\n", bridge1, bridge0);
1134                 bridge1->thread = AST_PTHREADT_STOP;
1135         }
1136
1137         /* Move channels from bridge1 over to bridge0 */
1138         while ((bridge_channel = AST_LIST_REMOVE_HEAD(&bridge1->channels, entry))) {
1139                 /* Tell the technology handling bridge1 that the bridge channel is leaving */
1140                 if (bridge1->technology->leave) {
1141                         ast_debug(1, "Giving bridge technology %s notification that %p is leaving bridge %p\n", bridge1->technology->name, bridge_channel, bridge1);
1142                         if (bridge1->technology->leave(bridge1, bridge_channel)) {
1143                                 ast_debug(1, "Bridge technology %s failed to allow %p to leave bridge %p\n", bridge1->technology->name, bridge_channel, bridge1);
1144                         }
1145                 }
1146
1147                 /* Drop channel count and reference count on the bridge they are leaving */
1148                 bridge1->num--;
1149                 ao2_ref(bridge1, -1);
1150
1151                 bridge_array_remove(bridge1, bridge_channel->chan);
1152
1153                 /* Now add them into the bridge they are joining, increase channel count, and bump up reference count */
1154                 bridge_channel->bridge = bridge0;
1155                 AST_LIST_INSERT_TAIL(&bridge0->channels, bridge_channel, entry);
1156                 bridge0->num++;
1157                 ao2_ref(bridge0, +1);
1158
1159                 bridge_array_add(bridge0, bridge_channel->chan);
1160
1161                 /* Make the channel compatible with the new bridge it is joining or else formats would go amuck */
1162                 bridge_make_compatible(bridge0, bridge_channel);
1163
1164                 /* Tell the technology handling bridge0 that the bridge channel is joining */
1165                 if (bridge0->technology->join) {
1166                         ast_debug(1, "Giving bridge technology %s notification that %p is joining bridge %p\n", bridge0->technology->name, bridge_channel, bridge0);
1167                         if (bridge0->technology->join(bridge0, bridge_channel)) {
1168                                 ast_debug(1, "Bridge technology %s failed to join %p to bridge %p\n", bridge0->technology->name, bridge_channel, bridge0);
1169                         }
1170                 }
1171
1172                 /* Poke the bridge channel, this will cause it to wake up and execute the proper threading model for the new bridge it is in */
1173                 pthread_kill(bridge_channel->thread, SIGURG);
1174                 ast_mutex_lock(&bridge_channel->lock);
1175                 ast_cond_signal(&bridge_channel->cond);
1176                 ast_mutex_unlock(&bridge_channel->lock);
1177         }
1178
1179         ast_debug(1, "Merged channels from bridge %p into bridge %p\n", bridge1, bridge0);
1180
1181         ao2_unlock(bridge1);
1182         ao2_unlock(bridge0);
1183
1184         return 0;
1185 }
1186
1187 int ast_bridge_suspend(struct ast_bridge *bridge, struct ast_channel *chan)
1188 {
1189         struct ast_bridge_channel *bridge_channel;
1190
1191         ao2_lock(bridge);
1192
1193         if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
1194                 ao2_unlock(bridge);
1195                 return -1;
1196         }
1197
1198         bridge_channel_suspend(bridge, bridge_channel);
1199
1200         ao2_unlock(bridge);
1201
1202         return 0;
1203 }
1204
1205 int ast_bridge_unsuspend(struct ast_bridge *bridge, struct ast_channel *chan)
1206 {
1207         struct ast_bridge_channel *bridge_channel;
1208
1209         ao2_lock(bridge);
1210
1211         if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
1212                 ao2_unlock(bridge);
1213                 return -1;
1214         }
1215
1216         bridge_channel_unsuspend(bridge, bridge_channel);
1217
1218         ao2_unlock(bridge);
1219
1220         return 0;
1221 }
1222
1223 void ast_bridge_technology_suspend(struct ast_bridge_technology *technology)
1224 {
1225         technology->suspended = 1;
1226         return;
1227 }
1228
1229 void ast_bridge_technology_unsuspend(struct ast_bridge_technology *technology)
1230 {
1231         technology->suspended = 0;
1232         return;
1233 }
1234
1235 int ast_bridge_features_register(enum ast_bridge_builtin_feature feature, ast_bridge_features_hook_callback callback, const char *dtmf)
1236 {
1237         if (builtin_features_handlers[feature]) {
1238                 return -1;
1239         }
1240
1241         if (!ast_strlen_zero(dtmf)) {
1242                 ast_copy_string(builtin_features_dtmf[feature], dtmf, sizeof(builtin_features_dtmf[feature]));
1243         }
1244
1245         builtin_features_handlers[feature] = callback;
1246
1247         return 0;
1248 }
1249
1250 int ast_bridge_features_unregister(enum ast_bridge_builtin_feature feature)
1251 {
1252         if (!builtin_features_handlers[feature]) {
1253                 return -1;
1254         }
1255
1256         builtin_features_handlers[feature] = NULL;
1257
1258         return 0;
1259 }
1260
1261 int ast_bridge_features_hook(struct ast_bridge_features *features, const char *dtmf, ast_bridge_features_hook_callback callback, void *hook_pvt)
1262 {
1263         struct ast_bridge_features_hook *hook = NULL;
1264
1265         /* Allocate new memory and setup it's various variables */
1266         if (!(hook = ast_calloc(1, sizeof(*hook)))) {
1267                 return -1;
1268         }
1269
1270         ast_copy_string(hook->dtmf, dtmf, sizeof(hook->dtmf));
1271         hook->callback = callback;
1272         hook->hook_pvt = hook_pvt;
1273
1274         /* Once done we add it onto the list. Now it will be picked up when DTMF is used */
1275         AST_LIST_INSERT_TAIL(&features->hooks, hook, entry);
1276
1277         features->usable = 1;
1278
1279         return 0;
1280 }
1281
1282 int ast_bridge_features_enable(struct ast_bridge_features *features, enum ast_bridge_builtin_feature feature, const char *dtmf, void *config)
1283 {
1284         /* If no alternate DTMF stream was provided use the default one */
1285         if (ast_strlen_zero(dtmf)) {
1286                 dtmf = builtin_features_dtmf[feature];
1287                 /* If no DTMF is still available (ie: it has been disabled) then error out now */
1288                 if (ast_strlen_zero(dtmf)) {
1289                         ast_debug(1, "Failed to enable built in feature %d on %p, no DTMF string is available for it.\n", feature, features);
1290                         return -1;
1291                 }
1292         }
1293
1294         if (!builtin_features_handlers[feature]) {
1295                 return -1;
1296         }
1297
1298         /* The rest is basically pretty easy. We create another hook using the built in feature's callback and DTMF, easy as pie. */
1299         return ast_bridge_features_hook(features, dtmf, builtin_features_handlers[feature], config);
1300 }
1301
1302 int ast_bridge_features_set_flag(struct ast_bridge_features *features, enum ast_bridge_feature_flags flag)
1303 {
1304         ast_set_flag(&features->feature_flags, flag);
1305         features->usable = 1;
1306         return 0;
1307 }
1308
1309 int ast_bridge_features_init(struct ast_bridge_features *features)
1310 {
1311         /* Zero out the structure */
1312         memset(features, 0, sizeof(*features));
1313
1314         /* Initialize the hooks list, just in case */
1315         AST_LIST_HEAD_INIT_NOLOCK(&features->hooks);
1316
1317         return 0;
1318 }
1319
1320 int ast_bridge_features_cleanup(struct ast_bridge_features *features)
1321 {
1322         struct ast_bridge_features_hook *hook = NULL;
1323
1324         /* This is relatively simple, hooks are kept as a list on the features structure so we just pop them off and free them */
1325         while ((hook = AST_LIST_REMOVE_HEAD(&features->hooks, entry))) {
1326                 ast_free(hook);
1327         }
1328
1329         return 0;
1330 }
1331
1332 int ast_bridge_dtmf_stream(struct ast_bridge *bridge, const char *dtmf, struct ast_channel *chan)
1333 {
1334         struct ast_bridge_channel *bridge_channel = NULL;
1335
1336         ao2_lock(bridge);
1337
1338         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1339                 if (bridge_channel->chan == chan) {
1340                         continue;
1341                 }
1342                 ast_copy_string(bridge_channel->dtmf_stream_q, dtmf, sizeof(bridge_channel->dtmf_stream_q));
1343                 ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_DTMF);
1344         }
1345
1346         ao2_unlock(bridge);
1347
1348         return 0;
1349 }