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