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