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.integer) {
 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.integer == 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.integer)) {
 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(uint32_t 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                 if (current->suspended) {
 392                         ast_debug(1, "Bridge technology %s is suspended. Skipping.\n", current->name);
 393                         continue;
 394                 }
 395                 if (!(current->capabilities & capabilities)) {
 396                         ast_debug(1, "Bridge technology %s does not have the capabilities we need.\n", current->name);
 397                         continue;
 398                 }
 399                 if (best && best->preference < current->preference) {
 400                         ast_debug(1, "Bridge technology %s has preference %d while %s has preference %d. Skipping.\n", current->name, current->preference, best->name, best->preference);
 401                         continue;
 402                 }
 403                 best = current;
 404         }
 405
 406         if (best) {
 407                 /* Increment it's module reference count if present so it does not get unloaded while in use */
 408                 if (best->mod) {
 409                         ast_module_ref(best->mod);
 410                 }
 411                 ast_debug(1, "Chose bridge technology %s\n", best->name);
 412         }
 413
 414         AST_RWLIST_UNLOCK(&bridge_technologies);
 415
 416         return best;
 417 }
 418
 419 static void destroy_bridge(void *obj)
 420 {
 421         struct ast_bridge *bridge = obj;
 422
 423         ast_debug(1, "Actually destroying bridge %p, nobody wants it anymore\n", bridge);
 424
 425         /* Pass off the bridge to the technology to destroy if needed */
 426         if (bridge->technology->destroy) {
 427                 ast_debug(1, "Giving bridge technology %s the bridge structure %p to destroy\n", bridge->technology->name, bridge);
 428                 if (bridge->technology->destroy(bridge)) {
 429                         ast_debug(1, "Bridge technology %s failed to destroy bridge structure %p... trying our best\n", bridge->technology->name, bridge);
 430                 }
 431         }
 432
 433         /* We are no longer using the bridge technology so decrement the module reference count on it */
 434         if (bridge->technology->mod) {
 435                 ast_module_unref(bridge->technology->mod);
 436         }
 437
 438         /* Last but not least clean up the features configuration */
 439         ast_bridge_features_cleanup(&bridge->features);
 440
 441         /* Drop the array of channels */
 442         ast_free(bridge->array);
 443
 444         return;
 445 }
 446
 447 struct ast_bridge *ast_bridge_new(uint32_t capabilities, int flags)
 448 {
 449         struct ast_bridge *bridge = NULL;
 450         struct ast_bridge_technology *bridge_technology = NULL;
 451
 452         /* If we need to be a smart bridge see if we can move between 1to1 and multimix bridges */
 453         if (flags & AST_BRIDGE_FLAG_SMART) {
 454                 struct ast_bridge *other_bridge;
 455
 456                 if (!(other_bridge = ast_bridge_new((capabilities & AST_BRIDGE_CAPABILITY_1TO1MIX) ? AST_BRIDGE_CAPABILITY_MULTIMIX : AST_BRIDGE_CAPABILITY_1TO1MIX, 0))) {
 457                         return NULL;
 458                 }
 459
 460                 ast_bridge_destroy(other_bridge);
 461         }
 462
 463         /* If capabilities were provided use our helper function to find the "best" bridge technology, otherwise we can
 464          * just look for the most basic capability needed, single 1to1 mixing. */
 465         bridge_technology = (capabilities ? find_best_technology(capabilities) : find_best_technology(AST_BRIDGE_CAPABILITY_1TO1MIX));
 466
 467         /* If no bridge technology was found we can't possibly do bridging so fail creation of the bridge */
 468         if (!bridge_technology) {
 469                 return NULL;
 470         }
 471
 472         /* We have everything we need to create this bridge... so allocate the memory, link things together, and fire her up! */
 473         if (!(bridge = ao2_alloc(sizeof(*bridge), destroy_bridge))) {
 474                 return NULL;
 475         }
 476
 477         bridge->technology = bridge_technology;
 478         bridge->thread = AST_PTHREADT_NULL;
 479
 480         /* Create an array of pointers for the channels that will be joining us */
 481         bridge->array = ast_calloc(BRIDGE_ARRAY_START, sizeof(struct ast_channel*));
 482         bridge->array_size = BRIDGE_ARRAY_START;
 483
 484         ast_set_flag(&bridge->feature_flags, flags);
 485
 486         /* Pass off the bridge to the technology to manipulate if needed */
 487         if (bridge->technology->create) {
 488                 ast_debug(1, "Giving bridge technology %s the bridge structure %p to setup\n", bridge->technology->name, bridge);
 489                 if (bridge->technology->create(bridge)) {
 490                         ast_debug(1, "Bridge technology %s failed to setup bridge structure %p\n", bridge->technology->name, bridge);
 491                         ao2_ref(bridge, -1);
 492                         bridge = NULL;
 493                 }
 494         }
 495
 496         return bridge;
 497 }
 498
 499 int ast_bridge_check(uint32_t capabilities)
 500 {
 501         struct ast_bridge_technology *bridge_technology = NULL;
 502
 503         if (!(bridge_technology = find_best_technology(capabilities))) {
 504                 return 0;
 505         }
 506
 507         ast_module_unref(bridge_technology->mod);
 508
 509         return 1;
 510 }
 511
 512 int ast_bridge_destroy(struct ast_bridge *bridge)
 513 {
 514         struct ast_bridge_channel *bridge_channel = NULL;
 515
 516         ao2_lock(bridge);
 517
 518         bridge->stop = 1;
 519
 520         bridge_poke(bridge);
 521
 522         ast_debug(1, "Telling all channels in bridge %p to end and leave the party\n", bridge);
 523
 524         /* Drop every bridged channel, the last one will cause the bridge thread (if it exists) to exit */
 525         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
 526                 ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_END);
 527         }
 528
 529         ao2_unlock(bridge);
 530
 531         ao2_ref(bridge, -1);
 532
 533         return 0;
 534 }
 535
 536 static int bridge_make_compatible(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 537 {
 538         struct ast_format formats[2];
 539         ast_format_copy(&formats[0], &bridge_channel->chan->readformat);
 540         ast_format_copy(&formats[1], &bridge_channel->chan->writeformat);
 541
 542         /* Are the formats currently in use something ths bridge can handle? */
 543         if (!ast_format_cap_iscompatible(bridge->technology->format_capabilities, &bridge_channel->chan->readformat)) {
 544                 struct ast_format best_format;
 545                 ast_best_codec(bridge->technology->format_capabilities, &best_format);
 546
 547                 /* Read format is a no go... */
 548                 if (option_debug) {
 549                         char codec_buf[512];
 550                         ast_debug(1, "Bridge technology %s wants to read any of formats %s but channel has %s\n", bridge->technology->name,
 551                                 ast_getformatname_multiple(codec_buf, sizeof(codec_buf), bridge->technology->format_capabilities),
 552                                 ast_getformatname(&formats[0]));
 553                 }
 554                 /* Switch read format to the best one chosen */
 555                 if (ast_set_read_format(bridge_channel->chan, &best_format)) {
 556                         ast_log(LOG_WARNING, "Failed to set channel %s to read format %s\n", bridge_channel->chan->name, ast_getformatname(&best_format));
 557                         return -1;
 558                 }
 559                 ast_debug(1, "Bridge %p put channel %s into read format %s\n", bridge, bridge_channel->chan->name, ast_getformatname(&best_format));
 560         } else {
 561                 ast_debug(1, "Bridge %p is happy that channel %s already has read format %s\n", bridge, bridge_channel->chan->name, ast_getformatname(&formats[0]));
 562         }
 563
 564         if (!ast_format_cap_iscompatible(bridge->technology->format_capabilities, &formats[1])) {
 565                 struct ast_format best_format;
 566                 ast_best_codec(bridge->technology->format_capabilities, &best_format);
 567
 568                 /* Write format is a no go... */
 569                 if (option_debug) {
 570                         char codec_buf[512];
 571                         ast_debug(1, "Bridge technology %s wants to write any of formats %s but channel has %s\n", bridge->technology->name,
 572                                 ast_getformatname_multiple(codec_buf, sizeof(codec_buf), bridge->technology->format_capabilities),
 573                                 ast_getformatname(&formats[1]));
 574                 }
 575                 /* Switch write format to the best one chosen */
 576                 if (ast_set_write_format(bridge_channel->chan, &best_format)) {
 577                         ast_log(LOG_WARNING, "Failed to set channel %s to write format %s\n", bridge_channel->chan->name, ast_getformatname(&best_format));
 578                         return -1;
 579                 }
 580                 ast_debug(1, "Bridge %p put channel %s into write format %s\n", bridge, bridge_channel->chan->name, ast_getformatname(&best_format));
 581         } else {
 582                 ast_debug(1, "Bridge %p is happy that channel %s already has write format %s\n", bridge, bridge_channel->chan->name, ast_getformatname(&formats[1]));
 583         }
 584
 585         return 0;
 586 }
 587
 588 /*! \brief Perform the smart bridge operation. Basically sees if a new bridge technology should be used instead of the current one. */
 589 static int smart_bridge_operation(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, int count)
 590 {
 591         uint32_t new_capabilities = 0;
 592         struct ast_bridge_technology *new_technology = NULL, *old_technology = bridge->technology;
 593         struct ast_bridge temp_bridge = {
 594                 .technology = bridge->technology,
 595                 .bridge_pvt = bridge->bridge_pvt,
 596         };
 597         struct ast_bridge_channel *bridge_channel2 = NULL;
 598
 599         /* Based on current feature determine whether we want to change bridge technologies or not */
 600         if (bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_1TO1MIX) {
 601                 if (count <= 2) {
 602                         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);
 603                         return 0;
 604                 }
 605                 new_capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX;
 606         } else if (bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX) {
 607                 if (count > 2) {
 608                         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);
 609                         return 0;
 610                 }
 611                 new_capabilities = AST_BRIDGE_CAPABILITY_1TO1MIX;
 612         }
 613
 614         if (!new_capabilities) {
 615                 ast_debug(1, "Bridge '%p' has no new capabilities, not performing smart bridge operation.\n", bridge);
 616                 return 0;
 617         }
 618
 619         /* Attempt to find a new bridge technology to satisfy the capabilities */
 620         if (!(new_technology = find_best_technology(new_capabilities))) {
 621                 return -1;
 622         }
 623
 624         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);
 625
 626         /* If a thread is currently executing for the current technology tell it to stop */
 627         if (bridge->thread != AST_PTHREADT_NULL) {
 628                 /* 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. */
 629                 if (new_technology->capabilities & AST_BRIDGE_CAPABILITY_THREAD) {
 630                         ast_debug(1, "Telling current bridge thread for bridge %p to refresh\n", bridge);
 631                         bridge->refresh = 1;
 632                         bridge_poke(bridge);
 633                 } else {
 634                         pthread_t bridge_thread = bridge->thread;
 635                         ast_debug(1, "Telling current bridge thread for bridge %p to stop\n", bridge);
 636                         bridge->stop = 1;
 637                         bridge_poke(bridge);
 638                         ao2_unlock(bridge);
 639                         pthread_join(bridge_thread, NULL);
 640                         ao2_lock(bridge);
 641                 }
 642         }
 643
 644         /* 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 */
 645         bridge->bridge_pvt = NULL;
 646         bridge->technology = new_technology;
 647
 648         /* Pass the bridge to the new bridge technology so it can set it up */
 649         if (new_technology->create) {
 650                 ast_debug(1, "Giving bridge technology %s the bridge structure %p to setup\n", new_technology->name, bridge);
 651                 if (new_technology->create(bridge)) {
 652                         ast_debug(1, "Bridge technology %s failed to setup bridge structure %p\n", new_technology->name, bridge);
 653                 }
 654         }
 655
 656         /* Move existing channels over to the new technology, while taking them away from the old one */
 657         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel2, entry) {
 658                 /* Skip over channel that initiated the smart bridge operation */
 659                 if (bridge_channel == bridge_channel2) {
 660                         continue;
 661                 }
 662
 663                 /* First we part them from the old technology */
 664                 if (old_technology->leave) {
 665                         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);
 666                         if (old_technology->leave(&temp_bridge, bridge_channel2)) {
 667                                 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);
 668                         }
 669                 }
 670
 671                 /* Second we make them compatible again with the bridge */
 672                 bridge_make_compatible(bridge, bridge_channel2);
 673
 674                 /* Third we join them to the new technology */
 675                 if (new_technology->join) {
 676                         ast_debug(1, "Giving bridge technology %s notification that %p is joining bridge %p\n", new_technology->name, bridge_channel2, bridge);
 677                         if (new_technology->join(bridge, bridge_channel2)) {
 678                                 ast_debug(1, "Bridge technology %s failed to join %p to bridge %p\n", new_technology->name, bridge_channel2, bridge);
 679                         }
 680                 }
 681
 682                 /* Fourth we tell them to wake up so they become aware that they above has happened */
 683                 pthread_kill(bridge_channel2->thread, SIGURG);
 684                 ast_mutex_lock(&bridge_channel2->lock);
 685                 ast_cond_signal(&bridge_channel2->cond);
 686                 ast_mutex_unlock(&bridge_channel2->lock);
 687         }
 688
 689         /* 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 */
 690         if (old_technology->destroy) {
 691                 ast_debug(1, "Giving bridge technology %s the bridge structure %p (really %p) to destroy\n", old_technology->name, &temp_bridge, bridge);
 692                 if (old_technology->destroy(&temp_bridge)) {
 693                         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);
 694                 }
 695         }
 696
 697         /* Finally if the old technology has module referencing remove our reference, we are no longer going to use it */
 698         if (old_technology->mod) {
 699                 ast_module_unref(old_technology->mod);
 700         }
 701
 702         return 0;
 703 }
 704
 705 /*! \brief Run in a multithreaded model. Each joined channel does writing/reading in their own thread. TODO: Improve */
 706 static enum ast_bridge_channel_state bridge_channel_join_multithreaded(struct ast_bridge_channel *bridge_channel)
 707 {
 708         int fds[4] = { -1, }, nfds = 0, i = 0, outfd = -1, ms = -1;
 709         struct ast_channel *chan = NULL;
 710
 711         /* Add any file descriptors we may want to monitor */
 712         if (bridge_channel->bridge->technology->fd) {
 713                 for (i = 0; i < 4; i ++) {
 714                         if (bridge_channel->fds[i] >= 0) {
 715                                 fds[nfds++] = bridge_channel->fds[i];
 716                         }
 717                 }
 718         }
 719
 720         ao2_unlock(bridge_channel->bridge);
 721
 722         /* Wait for data to either come from the channel or us to be signalled */
 723         if (!bridge_channel->suspended) {
 724                 ast_debug(1, "Going into a multithreaded waitfor for bridge channel %p of bridge %p\n", bridge_channel, bridge_channel->bridge);
 725                 chan = ast_waitfor_nandfds(&bridge_channel->chan, 1, fds, nfds, NULL, &outfd, &ms);
 726         } else {
 727                 ast_mutex_lock(&bridge_channel->lock);
 728                 ast_debug(1, "Going into a multithreaded signal wait for bridge channel %p of bridge %p\n", bridge_channel, bridge_channel->bridge);
 729                 ast_cond_wait(&bridge_channel->cond, &bridge_channel->lock);
 730                 ast_mutex_unlock(&bridge_channel->lock);
 731         }
 732
 733         ao2_lock(bridge_channel->bridge);
 734
 735         if (!bridge_channel->suspended) {
 736                 ast_bridge_handle_trip(bridge_channel->bridge, bridge_channel, chan, outfd);
 737         }
 738
 739         return bridge_channel->state;
 740 }
 741
 742 /*! \brief Run in a singlethreaded model. Each joined channel yields itself to the main bridge thread. TODO: Improve */
 743 static enum ast_bridge_channel_state bridge_channel_join_singlethreaded(struct ast_bridge_channel *bridge_channel)
 744 {
 745         ao2_unlock(bridge_channel->bridge);
 746         ast_mutex_lock(&bridge_channel->lock);
 747         if (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_WAIT) {
 748                 ast_debug(1, "Going into a single threaded signal wait for bridge channel %p of bridge %p\n", bridge_channel, bridge_channel->bridge);
 749                 ast_cond_wait(&bridge_channel->cond, &bridge_channel->lock);
 750         }
 751         ast_mutex_unlock(&bridge_channel->lock);
 752         ao2_lock(bridge_channel->bridge);
 753
 754         return bridge_channel->state;
 755 }
 756
 757 /*! \brief Internal function that suspends a channel from a bridge */
 758 static void bridge_channel_suspend(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 759 {
 760         bridge_channel->suspended = 1;
 761
 762         bridge_array_remove(bridge, bridge_channel->chan);
 763
 764         if (bridge->technology->suspend) {
 765                 bridge->technology->suspend(bridge, bridge_channel);
 766         }
 767
 768         return;
 769 }
 770
 771 /*! \brief Internal function that unsuspends a channel from a bridge */
 772 static void bridge_channel_unsuspend(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 773 {
 774         bridge_channel->suspended =0;
 775
 776         bridge_array_add(bridge, bridge_channel->chan);
 777
 778         if (bridge->technology->unsuspend) {
 779                 bridge->technology->unsuspend(bridge, bridge_channel);
 780         }
 781
 782         return;
 783 }
 784
 785 /*! \brief Internal function that executes a feature on a bridge channel */
 786 static void bridge_channel_feature(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 787 {
 788         struct ast_bridge_features *features = (bridge_channel->features ? bridge_channel->features : &bridge->features);
 789         struct ast_bridge_features_hook *hook = NULL;
 790         char dtmf[MAXIMUM_DTMF_FEATURE_STRING] = "";
 791         int look_for_dtmf = 1, dtmf_len = 0;
 792
 793         /* 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 */
 794         ast_set_flag(bridge_channel->chan, AST_FLAG_END_DTMF_ONLY);
 795
 796         /* Wait for DTMF on the channel and put it into a buffer. If the buffer matches any feature hook execute the hook. */
 797         while (look_for_dtmf) {
 798                 int res = ast_waitfordigit(bridge_channel->chan, 3000);
 799
 800                 /* If the above timed out simply exit */
 801                 if (!res) {
 802                         ast_debug(1, "DTMF feature string collection on bridge channel %p timed out\n", bridge_channel);
 803                         break;
 804                 } else if (res < 0) {
 805                         ast_debug(1, "DTMF feature string collection failed on bridge channel %p for some reason\n", bridge_channel);
 806                         break;
 807                 }
 808
 809                 /* Add the above DTMF into the DTMF string so we can do our matching */
 810                 dtmf[dtmf_len++] = res;
 811
 812                 ast_debug(1, "DTMF feature string on bridge channel %p is now '%s'\n", bridge_channel, dtmf);
 813
 814                 /* Assume that we do not want to look for DTMF any longer */
 815                 look_for_dtmf = 0;
 816
 817                 /* See if a DTMF feature hook matches or can match */
 818                 AST_LIST_TRAVERSE(&features->hooks, hook, entry) {
 819                         /* If this hook matches just break out now */
 820                         if (!strcmp(hook->dtmf, dtmf)) {
 821                                 ast_debug(1, "DTMF feature hook %p matched DTMF string '%s' on bridge channel %p\n", hook, dtmf, bridge_channel);
 822                                 break;
 823                         } else if (!strncmp(hook->dtmf, dtmf, dtmf_len)) {
 824                                 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);
 825                                 look_for_dtmf = 1;
 826                         } else {
 827                                 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);
 828                         }
 829                 }
 830
 831                 /* If we have reached the maximum length of a DTMF feature string bail out */
 832                 if (dtmf_len == MAXIMUM_DTMF_FEATURE_STRING) {
 833                         break;
 834                 }
 835         }
 836
 837         /* Since we are done bringing DTMF in return to using both begin and end frames */
 838         ast_clear_flag(bridge_channel->chan, AST_FLAG_END_DTMF_ONLY);
 839
 840         /* If a hook was actually matched execute it on this channel, otherwise stream up the DTMF to the other channels */
 841         if (hook) {
 842                 hook->callback(bridge, bridge_channel, hook->hook_pvt);
 843         } else {
 844                 ast_bridge_dtmf_stream(bridge, dtmf, bridge_channel->chan);
 845                 ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_WAIT);
 846         }
 847
 848         return;
 849 }
 850
 851 /*! \brief Internal function that plays back DTMF on a bridge channel */
 852 static void bridge_channel_dtmf_stream(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
 853 {
 854         char dtmf_q[8] = "";
 855
 856         ast_copy_string(dtmf_q, bridge_channel->dtmf_stream_q, sizeof(dtmf_q));
 857         bridge_channel->dtmf_stream_q[0] = '\0';
 858
 859         ast_debug(1, "Playing DTMF stream '%s' out to bridge channel %p\n", dtmf_q, bridge_channel);
 860         ast_dtmf_stream(bridge_channel->chan, NULL, dtmf_q, 250, 0);
 861
 862         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_WAIT);
 863
 864         return;
 865 }
 866
 867 /*! \brief Join a channel to a bridge and handle anything the bridge may want us to do */
 868 static enum ast_bridge_channel_state bridge_channel_join(struct ast_bridge_channel *bridge_channel)
 869 {
 870         struct ast_format formats[2];
 871         enum ast_bridge_channel_state state;
 872         ast_format_copy(&formats[0], &bridge_channel->chan->readformat);
 873         ast_format_copy(&formats[1], &bridge_channel->chan->writeformat);
 874
 875         /* Record the thread that will be the owner of us */
 876         bridge_channel->thread = pthread_self();
 877
 878         ast_debug(1, "Joining bridge channel %p to bridge %p\n", bridge_channel, bridge_channel->bridge);
 879
 880         ao2_lock(bridge_channel->bridge);
 881
 882         state = bridge_channel->state;
 883
 884         /* Add channel into the bridge */
 885         AST_LIST_INSERT_TAIL(&bridge_channel->bridge->channels, bridge_channel, entry);
 886         bridge_channel->bridge->num++;
 887
 888         bridge_array_add(bridge_channel->bridge, bridge_channel->chan);
 889
 890         if (bridge_channel->swap) {
 891                 struct ast_bridge_channel *bridge_channel2 = NULL;
 892
 893                 /* 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 */
 894                 if ((bridge_channel2 = find_bridge_channel(bridge_channel->bridge, bridge_channel->swap))) {
 895                         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);
 896                         ast_bridge_change_state(bridge_channel2, AST_BRIDGE_CHANNEL_STATE_HANGUP);
 897                 }
 898
 899                 bridge_channel->swap = NULL;
 900         } else if (ast_test_flag(&bridge_channel->bridge->feature_flags, AST_BRIDGE_FLAG_SMART)) {
 901                 /* Perform the smart bridge operation, basically see if we need to move around between technologies */
 902                 smart_bridge_operation(bridge_channel->bridge, bridge_channel, bridge_channel->bridge->num);
 903         }
 904
 905         /* Make the channel compatible with the bridge */
 906         bridge_make_compatible(bridge_channel->bridge, bridge_channel);
 907
 908         /* Tell the bridge technology we are joining so they set us up */
 909         if (bridge_channel->bridge->technology->join) {
 910                 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);
 911                 if (bridge_channel->bridge->technology->join(bridge_channel->bridge, bridge_channel)) {
 912                         ast_debug(1, "Bridge technology %s failed to join %p to bridge %p\n", bridge_channel->bridge->technology->name, bridge_channel, bridge_channel->bridge);
 913                 }
 914         }
 915
 916         /* Actually execute the respective threading model, and keep our bridge thread alive */
 917         while (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_WAIT) {
 918                 /* Update bridge pointer on channel */
 919                 bridge_channel->chan->bridge = bridge_channel->bridge;
 920                 /* If the technology requires a thread and one is not running, start it up */
 921                 if (bridge_channel->bridge->thread == AST_PTHREADT_NULL && (bridge_channel->bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_THREAD)) {
 922                         bridge_channel->bridge->stop = 0;
 923                         ast_debug(1, "Starting a bridge thread for bridge %p\n", bridge_channel->bridge);
 924                         ao2_ref(bridge_channel->bridge, +1);
 925                         if (ast_pthread_create(&bridge_channel->bridge->thread, NULL, bridge_thread, bridge_channel->bridge)) {
 926                                 ast_debug(1, "Failed to create a bridge thread for bridge %p, giving it another go.\n", bridge_channel->bridge);
 927                                 ao2_ref(bridge_channel->bridge, -1);
 928                                 continue;
 929                         }
 930                 }
 931                 /* Execute the threading model */
 932                 state = (bridge_channel->bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTITHREADED ? bridge_channel_join_multithreaded(bridge_channel) : bridge_channel_join_singlethreaded(bridge_channel));
 933                 /* Depending on the above state see what we need to do */
 934                 if (state == AST_BRIDGE_CHANNEL_STATE_FEATURE) {
 935                         bridge_channel_suspend(bridge_channel->bridge, bridge_channel);
 936                         bridge_channel_feature(bridge_channel->bridge, bridge_channel);
 937                         bridge_channel_unsuspend(bridge_channel->bridge, bridge_channel);
 938                 } else if (state == AST_BRIDGE_CHANNEL_STATE_DTMF) {
 939                         bridge_channel_suspend(bridge_channel->bridge, bridge_channel);
 940                         bridge_channel_dtmf_stream(bridge_channel->bridge, bridge_channel);
 941                         bridge_channel_unsuspend(bridge_channel->bridge, bridge_channel);
 942                 }
 943         }
 944
 945         bridge_channel->chan->bridge = NULL;
 946
 947         /* See if we need to dissolve the bridge itself if they hung up */
 948         if (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_END) {
 949                 bridge_check_dissolve(bridge_channel->bridge, bridge_channel);
 950         }
 951
 952         /* Tell the bridge technology we are leaving so they tear us down */
 953         if (bridge_channel->bridge->technology->leave) {
 954                 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);
 955                 if (bridge_channel->bridge->technology->leave(bridge_channel->bridge, bridge_channel)) {
 956                         ast_debug(1, "Bridge technology %s failed to leave %p from bridge %p\n", bridge_channel->bridge->technology->name, bridge_channel, bridge_channel->bridge);
 957                 }
 958         }
 959
 960         /* Remove channel from the bridge */
 961         bridge_channel->bridge->num--;
 962         AST_LIST_REMOVE(&bridge_channel->bridge->channels, bridge_channel, entry);
 963
 964         bridge_array_remove(bridge_channel->bridge, bridge_channel->chan);
 965
 966         /* Perform the smart bridge operation if needed since a channel has left */
 967         if (ast_test_flag(&bridge_channel->bridge->feature_flags, AST_BRIDGE_FLAG_SMART)) {
 968                 smart_bridge_operation(bridge_channel->bridge, NULL, bridge_channel->bridge->num);
 969         }
 970
 971         ao2_unlock(bridge_channel->bridge);
 972
 973         /* Restore original formats of the channel as they came in */
 974         if (ast_format_cmp(&bridge_channel->chan->readformat, &formats[0]) == AST_FORMAT_CMP_NOT_EQUAL) {
 975                 ast_debug(1, "Bridge is returning %p to read format %s(%d)\n", bridge_channel, ast_getformatname(&formats[0]), formats[0].id);
 976                 if (ast_set_read_format(bridge_channel->chan, &formats[0])) {
 977                         ast_debug(1, "Bridge failed to return channel %p to read format %s(%d)\n", bridge_channel, ast_getformatname(&formats[0]), formats[0].id);
 978                 }
 979         }
 980         if (ast_format_cmp(&bridge_channel->chan->writeformat, &formats[1]) == AST_FORMAT_CMP_NOT_EQUAL) {
 981                 ast_debug(1, "Bridge is returning %p to write format %s(%d)\n", bridge_channel, ast_getformatname(&formats[1]), formats[1].id);
 982                 if (ast_set_write_format(bridge_channel->chan, &formats[1])) {
 983                         ast_debug(1, "Bridge failed to return channel %p to write format %s(%d)\n", bridge_channel, ast_getformatname(&formats[1]), formats[1].id);
 984                 }
 985         }
 986
 987         return bridge_channel->state;
 988 }
 989
 990 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)
 991 {
 992         struct ast_bridge_channel bridge_channel = {
 993                 .chan = chan,
 994                 .swap = swap,
 995                 .bridge = bridge,
 996                 .features = features,
 997         };
 998         enum ast_bridge_channel_state state;
 999
1000         /* Initialize various other elements of the bridge channel structure that we can't do above */
1001         ast_mutex_init(&bridge_channel.lock);
1002         ast_cond_init(&bridge_channel.cond, NULL);
1003
1004         ao2_ref(bridge_channel.bridge, +1);
1005
1006         state = bridge_channel_join(&bridge_channel);
1007
1008         ao2_ref(bridge_channel.bridge, -1);
1009
1010         /* Destroy some elements of the bridge channel structure above */
1011         ast_mutex_destroy(&bridge_channel.lock);
1012         ast_cond_destroy(&bridge_channel.cond);
1013
1014         return state;
1015 }
1016
1017 /*! \brief Thread responsible for imparted bridged channels */
1018 static void *bridge_channel_thread(void *data)
1019 {
1020         struct ast_bridge_channel *bridge_channel = data;
1021         enum ast_bridge_channel_state state;
1022
1023         state = bridge_channel_join(bridge_channel);
1024
1025         ao2_ref(bridge_channel->bridge, -1);
1026
1027         /* 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 */
1028         if (state == AST_BRIDGE_CHANNEL_STATE_END || state == AST_BRIDGE_CHANNEL_STATE_HANGUP) {
1029                 ast_hangup(bridge_channel->chan);
1030         }
1031
1032         /* Destroy elements of the bridge channel structure and the bridge channel structure itself */
1033         ast_mutex_destroy(&bridge_channel->lock);
1034         ast_cond_destroy(&bridge_channel->cond);
1035         ast_free(bridge_channel);
1036
1037         return NULL;
1038 }
1039
1040 int ast_bridge_impart(struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap, struct ast_bridge_features *features)
1041 {
1042         struct ast_bridge_channel *bridge_channel = NULL;
1043
1044         /* Try to allocate a structure for the bridge channel */
1045         if (!(bridge_channel = ast_calloc(1, sizeof(*bridge_channel)))) {
1046                 return -1;
1047         }
1048
1049         /* Setup various parameters */
1050         bridge_channel->chan = chan;
1051         bridge_channel->swap = swap;
1052         bridge_channel->bridge = bridge;
1053         bridge_channel->features = features;
1054
1055         /* Initialize our mutex lock and condition */
1056         ast_mutex_init(&bridge_channel->lock);
1057         ast_cond_init(&bridge_channel->cond, NULL);
1058
1059         /* Bump up the reference count on the bridge, it'll get decremented later */
1060         ao2_ref(bridge, +1);
1061
1062         /* Actually create the thread that will handle the channel */
1063         if (ast_pthread_create(&bridge_channel->thread, NULL, bridge_channel_thread, bridge_channel)) {
1064                 ao2_ref(bridge, -1);
1065                 ast_cond_destroy(&bridge_channel->cond);
1066                 ast_mutex_destroy(&bridge_channel->lock);
1067                 ast_free(bridge_channel);
1068                 return -1;
1069         }
1070
1071         return 0;
1072 }
1073
1074 int ast_bridge_depart(struct ast_bridge *bridge, struct ast_channel *chan)
1075 {
1076         struct ast_bridge_channel *bridge_channel = NULL;
1077         pthread_t thread;
1078
1079         ao2_lock(bridge);
1080
1081         /* Try to find the channel that we want to depart */
1082         if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
1083                 ao2_unlock(bridge);
1084                 return -1;
1085         }
1086
1087         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_DEPART);
1088         thread = bridge_channel->thread;
1089
1090         ao2_unlock(bridge);
1091
1092         pthread_join(thread, NULL);
1093
1094         return 0;
1095 }
1096
1097 int ast_bridge_remove(struct ast_bridge *bridge, struct ast_channel *chan)
1098 {
1099         struct ast_bridge_channel *bridge_channel = NULL;
1100
1101         ao2_lock(bridge);
1102
1103         /* Try to find the channel that we want to remove */
1104         if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
1105                 ao2_unlock(bridge);
1106                 return -1;
1107         }
1108
1109         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
1110
1111         ao2_unlock(bridge);
1112
1113         return 0;
1114 }
1115
1116 int ast_bridge_merge(struct ast_bridge *bridge0, struct ast_bridge *bridge1)
1117 {
1118         struct ast_bridge_channel *bridge_channel = NULL;
1119
1120         ao2_lock(bridge0);
1121         ao2_lock(bridge1);
1122
1123         /* If the first bridge currently has 2 channels and is not capable of becoming a multimixing bridge we can not merge */
1124         if ((bridge0->num + bridge1->num) > 2 && (!(bridge0->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX) && !ast_test_flag(&bridge0->feature_flags, AST_BRIDGE_FLAG_SMART))) {
1125                 ao2_unlock(bridge1);
1126                 ao2_unlock(bridge0);
1127                 ast_debug(1, "Can't merge bridge %p into bridge %p, multimix is needed and it could not be acquired.\n", bridge1, bridge0);
1128                 return -1;
1129         }
1130
1131         ast_debug(1, "Merging channels from bridge %p into bridge %p\n", bridge1, bridge0);
1132
1133         /* Perform smart bridge operation on bridge we are merging into so it can change bridge technology if needed */
1134         if (smart_bridge_operation(bridge0, NULL, bridge0->num + bridge1->num)) {
1135                 ao2_unlock(bridge1);
1136                 ao2_unlock(bridge0);
1137                 ast_debug(1, "Can't merge bridge %p into bridge %p, tried to perform smart bridge operation and failed.\n", bridge1, bridge0);
1138                 return -1;
1139         }
1140
1141         /* If a thread is currently executing on bridge1 tell it to stop */
1142         if (bridge1->thread) {
1143                 ast_debug(1, "Telling bridge thread on bridge %p to stop as it is being merged into %p\n", bridge1, bridge0);
1144                 bridge1->thread = AST_PTHREADT_STOP;
1145         }
1146
1147         /* Move channels from bridge1 over to bridge0 */
1148         while ((bridge_channel = AST_LIST_REMOVE_HEAD(&bridge1->channels, entry))) {
1149                 /* Tell the technology handling bridge1 that the bridge channel is leaving */
1150                 if (bridge1->technology->leave) {
1151                         ast_debug(1, "Giving bridge technology %s notification that %p is leaving bridge %p\n", bridge1->technology->name, bridge_channel, bridge1);
1152                         if (bridge1->technology->leave(bridge1, bridge_channel)) {
1153                                 ast_debug(1, "Bridge technology %s failed to allow %p to leave bridge %p\n", bridge1->technology->name, bridge_channel, bridge1);
1154                         }
1155                 }
1156
1157                 /* Drop channel count and reference count on the bridge they are leaving */
1158                 bridge1->num--;
1159                 ao2_ref(bridge1, -1);
1160
1161                 bridge_array_remove(bridge1, bridge_channel->chan);
1162
1163                 /* Now add them into the bridge they are joining, increase channel count, and bump up reference count */
1164                 bridge_channel->bridge = bridge0;
1165                 AST_LIST_INSERT_TAIL(&bridge0->channels, bridge_channel, entry);
1166                 bridge0->num++;
1167                 ao2_ref(bridge0, +1);
1168
1169                 bridge_array_add(bridge0, bridge_channel->chan);
1170
1171                 /* Make the channel compatible with the new bridge it is joining or else formats would go amuck */
1172                 bridge_make_compatible(bridge0, bridge_channel);
1173
1174                 /* Tell the technology handling bridge0 that the bridge channel is joining */
1175                 if (bridge0->technology->join) {
1176                         ast_debug(1, "Giving bridge technology %s notification that %p is joining bridge %p\n", bridge0->technology->name, bridge_channel, bridge0);
1177                         if (bridge0->technology->join(bridge0, bridge_channel)) {
1178                                 ast_debug(1, "Bridge technology %s failed to join %p to bridge %p\n", bridge0->technology->name, bridge_channel, bridge0);
1179                         }
1180                 }
1181
1182                 /* Poke the bridge channel, this will cause it to wake up and execute the proper threading model for the new bridge it is in */
1183                 pthread_kill(bridge_channel->thread, SIGURG);
1184                 ast_mutex_lock(&bridge_channel->lock);
1185                 ast_cond_signal(&bridge_channel->cond);
1186                 ast_mutex_unlock(&bridge_channel->lock);
1187         }
1188
1189         ast_debug(1, "Merged channels from bridge %p into bridge %p\n", bridge1, bridge0);
1190
1191         ao2_unlock(bridge1);
1192         ao2_unlock(bridge0);
1193
1194         return 0;
1195 }
1196
1197 int ast_bridge_suspend(struct ast_bridge *bridge, struct ast_channel *chan)
1198 {
1199         struct ast_bridge_channel *bridge_channel;
1200
1201         ao2_lock(bridge);
1202
1203         if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
1204                 ao2_unlock(bridge);
1205                 return -1;
1206         }
1207
1208         bridge_channel_suspend(bridge, bridge_channel);
1209
1210         ao2_unlock(bridge);
1211
1212         return 0;
1213 }
1214
1215 int ast_bridge_unsuspend(struct ast_bridge *bridge, struct ast_channel *chan)
1216 {
1217         struct ast_bridge_channel *bridge_channel;
1218
1219         ao2_lock(bridge);
1220
1221         if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
1222                 ao2_unlock(bridge);
1223                 return -1;
1224         }
1225
1226         bridge_channel_unsuspend(bridge, bridge_channel);
1227
1228         ao2_unlock(bridge);
1229
1230         return 0;
1231 }
1232
1233 void ast_bridge_technology_suspend(struct ast_bridge_technology *technology)
1234 {
1235         technology->suspended = 1;
1236         return;
1237 }
1238
1239 void ast_bridge_technology_unsuspend(struct ast_bridge_technology *technology)
1240 {
1241         technology->suspended = 0;
1242         return;
1243 }
1244
1245 int ast_bridge_features_register(enum ast_bridge_builtin_feature feature, ast_bridge_features_hook_callback callback, const char *dtmf)
1246 {
1247         if (builtin_features_handlers[feature]) {
1248                 return -1;
1249         }
1250
1251         if (!ast_strlen_zero(dtmf)) {
1252                 ast_copy_string(builtin_features_dtmf[feature], dtmf, sizeof(builtin_features_dtmf[feature]));
1253         }
1254
1255         builtin_features_handlers[feature] = callback;
1256
1257         return 0;
1258 }
1259
1260 int ast_bridge_features_unregister(enum ast_bridge_builtin_feature feature)
1261 {
1262         if (!builtin_features_handlers[feature]) {
1263                 return -1;
1264         }
1265
1266         builtin_features_handlers[feature] = NULL;
1267
1268         return 0;
1269 }
1270
1271 int ast_bridge_features_hook(struct ast_bridge_features *features, const char *dtmf, ast_bridge_features_hook_callback callback, void *hook_pvt)
1272 {
1273         struct ast_bridge_features_hook *hook = NULL;
1274
1275         /* Allocate new memory and setup it's various variables */
1276         if (!(hook = ast_calloc(1, sizeof(*hook)))) {
1277                 return -1;
1278         }
1279
1280         ast_copy_string(hook->dtmf, dtmf, sizeof(hook->dtmf));
1281         hook->callback = callback;
1282         hook->hook_pvt = hook_pvt;
1283
1284         /* Once done we add it onto the list. Now it will be picked up when DTMF is used */
1285         AST_LIST_INSERT_TAIL(&features->hooks, hook, entry);
1286
1287         features->usable = 1;
1288
1289         return 0;
1290 }
1291
1292 int ast_bridge_features_enable(struct ast_bridge_features *features, enum ast_bridge_builtin_feature feature, const char *dtmf, void *config)
1293 {
1294         /* If no alternate DTMF stream was provided use the default one */
1295         if (ast_strlen_zero(dtmf)) {
1296                 dtmf = builtin_features_dtmf[feature];
1297                 /* If no DTMF is still available (ie: it has been disabled) then error out now */
1298                 if (ast_strlen_zero(dtmf)) {
1299                         ast_debug(1, "Failed to enable built in feature %d on %p, no DTMF string is available for it.\n", feature, features);
1300                         return -1;
1301                 }
1302         }
1303
1304         if (!builtin_features_handlers[feature]) {
1305                 return -1;
1306         }
1307
1308         /* The rest is basically pretty easy. We create another hook using the built in feature's callback and DTMF, easy as pie. */
1309         return ast_bridge_features_hook(features, dtmf, builtin_features_handlers[feature], config);
1310 }
1311
1312 int ast_bridge_features_set_flag(struct ast_bridge_features *features, enum ast_bridge_feature_flags flag)
1313 {
1314         ast_set_flag(&features->feature_flags, flag);
1315         features->usable = 1;
1316         return 0;
1317 }
1318
1319 int ast_bridge_features_init(struct ast_bridge_features *features)
1320 {
1321         /* Zero out the structure */
1322         memset(features, 0, sizeof(*features));
1323
1324         /* Initialize the hooks list, just in case */
1325         AST_LIST_HEAD_INIT_NOLOCK(&features->hooks);
1326
1327         return 0;
1328 }
1329
1330 int ast_bridge_features_cleanup(struct ast_bridge_features *features)
1331 {
1332         struct ast_bridge_features_hook *hook = NULL;
1333
1334         /* This is relatively simple, hooks are kept as a list on the features structure so we just pop them off and free them */
1335         while ((hook = AST_LIST_REMOVE_HEAD(&features->hooks, entry))) {
1336                 ast_free(hook);
1337         }
1338
1339         return 0;
1340 }
1341
1342 int ast_bridge_dtmf_stream(struct ast_bridge *bridge, const char *dtmf, struct ast_channel *chan)
1343 {
1344         struct ast_bridge_channel *bridge_channel = NULL;
1345
1346         ao2_lock(bridge);
1347
1348         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1349                 if (bridge_channel->chan == chan) {
1350                         continue;
1351                 }
1352                 ast_copy_string(bridge_channel->dtmf_stream_q, dtmf, sizeof(bridge_channel->dtmf_stream_q));
1353                 ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_DTMF);
1354         }
1355
1356         ao2_unlock(bridge);
1357
1358         return 0;
1359 }