0045a2f5ebfddd6b048c0f14ce484b86daa56fb2
[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 /*** MODULEINFO
27         <support_level>core</support_level>
28  ***/
29
30 #include "asterisk.h"
31
32 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
33
34 #include <signal.h>
35
36 #include "asterisk/logger.h"
37 #include "asterisk/channel.h"
38 #include "asterisk/options.h"
39 #include "asterisk/utils.h"
40 #include "asterisk/lock.h"
41 #include "asterisk/linkedlists.h"
42 #include "asterisk/bridging.h"
43 #include "asterisk/bridging_basic.h"
44 #include "asterisk/bridging_technology.h"
45 #include "asterisk/stasis_bridging.h"
46 #include "asterisk/stasis_channels.h"
47 #include "asterisk/app.h"
48 #include "asterisk/file.h"
49 #include "asterisk/module.h"
50 #include "asterisk/astobj2.h"
51 #include "asterisk/pbx.h"
52 #include "asterisk/test.h"
53 #include "asterisk/_private.h"
54
55 #include "asterisk/heap.h"
56 #include "asterisk/say.h"
57 #include "asterisk/timing.h"
58 #include "asterisk/stringfields.h"
59 #include "asterisk/musiconhold.h"
60 #include "asterisk/features.h"
61 #include "asterisk/cli.h"
62 #include "asterisk/parking.h"
63 #include "asterisk/core_local.h"
64 #include "asterisk/features_config.h"
65
66 /*! All bridges container. */
67 static struct ao2_container *bridges;
68
69 static AST_RWLIST_HEAD_STATIC(bridge_technologies, ast_bridge_technology);
70
71 /* Initial starting point for the bridge array of channels */
72 #define BRIDGE_ARRAY_START 128
73
74 /* Grow rate of bridge array of channels */
75 #define BRIDGE_ARRAY_GROW 32
76
77 static void cleanup_video_mode(struct ast_bridge *bridge);
78 static int bridge_make_compatible(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel);
79 static void bridge_features_remove(struct ast_bridge_features *features, enum ast_bridge_hook_remove_flags remove_flags);
80
81 /*! Default DTMF keys for built in features */
82 static char builtin_features_dtmf[AST_BRIDGE_BUILTIN_END][MAXIMUM_DTMF_FEATURE_STRING];
83
84 /*! Function handlers for the built in features */
85 static void *builtin_features_handlers[AST_BRIDGE_BUILTIN_END];
86
87 /*! Function handlers for built in interval features */
88 static ast_bridge_builtin_set_limits_fn builtin_interval_handlers[AST_BRIDGE_BUILTIN_INTERVAL_END];
89
90 /*! Bridge manager service request */
91 struct bridge_manager_request {
92         /*! List of bridge service requests. */
93         AST_LIST_ENTRY(bridge_manager_request) node;
94         /*! Refed bridge requesting service. */
95         struct ast_bridge *bridge;
96 };
97
98 struct bridge_manager_controller {
99         /*! Condition, used to wake up the bridge manager thread. */
100         ast_cond_t cond;
101         /*! Queue of bridge service requests. */
102         AST_LIST_HEAD_NOLOCK(, bridge_manager_request) service_requests;
103         /*! Manager thread */
104         pthread_t thread;
105         /*! TRUE if the manager needs to stop. */
106         unsigned int stop:1;
107 };
108
109 /*! Bridge manager controller. */
110 static struct bridge_manager_controller *bridge_manager;
111
112 /*!
113  * \internal
114  * \brief Request service for a bridge from the bridge manager.
115  * \since 12.0.0
116  *
117  * \param bridge Requesting service.
118  *
119  * \return Nothing
120  */
121 static void bridge_manager_service_req(struct ast_bridge *bridge)
122 {
123         struct bridge_manager_request *request;
124
125         ao2_lock(bridge_manager);
126         if (bridge_manager->stop) {
127                 ao2_unlock(bridge_manager);
128                 return;
129         }
130
131         /* Create the service request. */
132         request = ast_calloc(1, sizeof(*request));
133         if (!request) {
134                 /* Well. This isn't good. */
135                 ao2_unlock(bridge_manager);
136                 return;
137         }
138         ao2_ref(bridge, +1);
139         request->bridge = bridge;
140
141         /* Put request into the queue and wake the bridge manager. */
142         AST_LIST_INSERT_TAIL(&bridge_manager->service_requests, request, node);
143         ast_cond_signal(&bridge_manager->cond);
144         ao2_unlock(bridge_manager);
145 }
146
147 int __ast_bridge_technology_register(struct ast_bridge_technology *technology, struct ast_module *module)
148 {
149         struct ast_bridge_technology *current;
150
151         /* Perform a sanity check to make sure the bridge technology conforms to our needed requirements */
152         if (ast_strlen_zero(technology->name)
153                 || !technology->capabilities
154                 || !technology->write) {
155                 ast_log(LOG_WARNING, "Bridge technology %s failed registration sanity check.\n",
156                         technology->name);
157                 return -1;
158         }
159
160         AST_RWLIST_WRLOCK(&bridge_technologies);
161
162         /* Look for duplicate bridge technology already using this name, or already registered */
163         AST_RWLIST_TRAVERSE(&bridge_technologies, current, entry) {
164                 if ((!strcasecmp(current->name, technology->name)) || (current == technology)) {
165                         ast_log(LOG_WARNING, "A bridge technology of %s already claims to exist in our world.\n",
166                                 technology->name);
167                         AST_RWLIST_UNLOCK(&bridge_technologies);
168                         return -1;
169                 }
170         }
171
172         /* Copy module pointer so reference counting can keep the module from unloading */
173         technology->mod = module;
174
175         /* Insert our new bridge technology into the list and print out a pretty message */
176         AST_RWLIST_INSERT_TAIL(&bridge_technologies, technology, entry);
177
178         AST_RWLIST_UNLOCK(&bridge_technologies);
179
180         ast_verb(2, "Registered bridge technology %s\n", technology->name);
181
182         return 0;
183 }
184
185 int ast_bridge_technology_unregister(struct ast_bridge_technology *technology)
186 {
187         struct ast_bridge_technology *current;
188
189         AST_RWLIST_WRLOCK(&bridge_technologies);
190
191         /* Ensure the bridge technology is registered before removing it */
192         AST_RWLIST_TRAVERSE_SAFE_BEGIN(&bridge_technologies, current, entry) {
193                 if (current == technology) {
194                         AST_RWLIST_REMOVE_CURRENT(entry);
195                         ast_verb(2, "Unregistered bridge technology %s\n", technology->name);
196                         break;
197                 }
198         }
199         AST_RWLIST_TRAVERSE_SAFE_END;
200
201         AST_RWLIST_UNLOCK(&bridge_technologies);
202
203         return current ? 0 : -1;
204 }
205
206 void ast_bridge_channel_lock_bridge(struct ast_bridge_channel *bridge_channel)
207 {
208         struct ast_bridge *bridge;
209
210         for (;;) {
211                 /* Safely get the bridge pointer */
212                 ast_bridge_channel_lock(bridge_channel);
213                 bridge = bridge_channel->bridge;
214                 ao2_ref(bridge, +1);
215                 ast_bridge_channel_unlock(bridge_channel);
216
217                 /* Lock the bridge and see if it is still the bridge we need to lock. */
218                 ast_bridge_lock(bridge);
219                 if (bridge == bridge_channel->bridge) {
220                         ao2_ref(bridge, -1);
221                         return;
222                 }
223                 ast_bridge_unlock(bridge);
224                 ao2_ref(bridge, -1);
225         }
226 }
227
228 static void bridge_channel_poke(struct ast_bridge_channel *bridge_channel)
229 {
230         if (!pthread_equal(pthread_self(), bridge_channel->thread)) {
231                 while (bridge_channel->waiting) {
232                         pthread_kill(bridge_channel->thread, SIGURG);
233                         sched_yield();
234                 }
235         }
236 }
237
238 void ast_bridge_change_state_nolock(struct ast_bridge_channel *bridge_channel, enum ast_bridge_channel_state new_state)
239 {
240 /* BUGBUG need cause code for the bridge_channel leaving the bridge. */
241         if (bridge_channel->state != AST_BRIDGE_CHANNEL_STATE_WAIT) {
242                 return;
243         }
244
245         ast_debug(1, "Setting %p(%s) state from:%d to:%d\n",
246                 bridge_channel, ast_channel_name(bridge_channel->chan), bridge_channel->state,
247                 new_state);
248
249         /* Change the state on the bridge channel */
250         bridge_channel->state = new_state;
251
252         bridge_channel_poke(bridge_channel);
253 }
254
255 void ast_bridge_change_state(struct ast_bridge_channel *bridge_channel, enum ast_bridge_channel_state new_state)
256 {
257         ast_bridge_channel_lock(bridge_channel);
258         ast_bridge_change_state_nolock(bridge_channel, new_state);
259         ast_bridge_channel_unlock(bridge_channel);
260 }
261
262 /*!
263  * \internal
264  * \brief Put an action onto the specified bridge. Don't dup the action frame.
265  * \since 12.0.0
266  *
267  * \param bridge What to queue the action on.
268  * \param action What to do.
269  *
270  * \return Nothing
271  */
272 static void bridge_queue_action_nodup(struct ast_bridge *bridge, struct ast_frame *action)
273 {
274         ast_debug(1, "Bridge %s: queueing action type:%d sub:%d\n",
275                 bridge->uniqueid, action->frametype, action->subclass.integer);
276
277         ast_bridge_lock(bridge);
278         AST_LIST_INSERT_TAIL(&bridge->action_queue, action, frame_list);
279         ast_bridge_unlock(bridge);
280         bridge_manager_service_req(bridge);
281 }
282
283 int ast_bridge_queue_action(struct ast_bridge *bridge, struct ast_frame *action)
284 {
285         struct ast_frame *dup;
286
287         dup = ast_frdup(action);
288         if (!dup) {
289                 return -1;
290         }
291         bridge_queue_action_nodup(bridge, dup);
292         return 0;
293 }
294
295 int ast_bridge_channel_queue_frame(struct ast_bridge_channel *bridge_channel, struct ast_frame *fr)
296 {
297         struct ast_frame *dup;
298         char nudge = 0;
299
300         if (bridge_channel->suspended
301                 /* Also defer DTMF frames. */
302                 && fr->frametype != AST_FRAME_DTMF_BEGIN
303                 && fr->frametype != AST_FRAME_DTMF_END
304                 && !ast_is_deferrable_frame(fr)) {
305                 /* Drop non-deferable frames when suspended. */
306                 return 0;
307         }
308
309         dup = ast_frdup(fr);
310         if (!dup) {
311                 return -1;
312         }
313
314         ast_bridge_channel_lock(bridge_channel);
315         if (bridge_channel->state != AST_BRIDGE_CHANNEL_STATE_WAIT) {
316                 /* Drop frames on channels leaving the bridge. */
317                 ast_bridge_channel_unlock(bridge_channel);
318                 ast_frfree(dup);
319                 return 0;
320         }
321
322         AST_LIST_INSERT_TAIL(&bridge_channel->wr_queue, dup, frame_list);
323         if (write(bridge_channel->alert_pipe[1], &nudge, sizeof(nudge)) != sizeof(nudge)) {
324                 ast_log(LOG_ERROR, "We couldn't write alert pipe for %p(%s)... something is VERY wrong\n",
325                         bridge_channel, ast_channel_name(bridge_channel->chan));
326         }
327         ast_bridge_channel_unlock(bridge_channel);
328         return 0;
329 }
330
331 void ast_bridge_channel_queue_action_data(struct ast_bridge_channel *bridge_channel, enum ast_bridge_action_type action, const void *data, size_t datalen)
332 {
333         struct ast_frame frame = {
334                 .frametype = AST_FRAME_BRIDGE_ACTION,
335                 .subclass.integer = action,
336                 .datalen = datalen,
337                 .data.ptr = (void *) data,
338         };
339
340         ast_bridge_channel_queue_frame(bridge_channel, &frame);
341 }
342
343 void ast_bridge_channel_queue_control_data(struct ast_bridge_channel *bridge_channel, enum ast_control_frame_type control, const void *data, size_t datalen)
344 {
345         struct ast_frame frame = {
346                 .frametype = AST_FRAME_CONTROL,
347                 .subclass.integer = control,
348                 .datalen = datalen,
349                 .data.ptr = (void *) data,
350         };
351
352         ast_bridge_channel_queue_frame(bridge_channel, &frame);
353 }
354
355 void ast_bridge_channel_restore_formats(struct ast_bridge_channel *bridge_channel)
356 {
357         /* Restore original formats of the channel as they came in */
358         if (ast_format_cmp(ast_channel_readformat(bridge_channel->chan), &bridge_channel->read_format) == AST_FORMAT_CMP_NOT_EQUAL) {
359                 ast_debug(1, "Bridge is returning %p(%s) to read format %s\n",
360                         bridge_channel, ast_channel_name(bridge_channel->chan),
361                         ast_getformatname(&bridge_channel->read_format));
362                 if (ast_set_read_format(bridge_channel->chan, &bridge_channel->read_format)) {
363                         ast_debug(1, "Bridge failed to return %p(%s) to read format %s\n",
364                                 bridge_channel, ast_channel_name(bridge_channel->chan),
365                                 ast_getformatname(&bridge_channel->read_format));
366                 }
367         }
368         if (ast_format_cmp(ast_channel_writeformat(bridge_channel->chan), &bridge_channel->write_format) == AST_FORMAT_CMP_NOT_EQUAL) {
369                 ast_debug(1, "Bridge is returning %p(%s) to write format %s\n",
370                         bridge_channel, ast_channel_name(bridge_channel->chan),
371                         ast_getformatname(&bridge_channel->write_format));
372                 if (ast_set_write_format(bridge_channel->chan, &bridge_channel->write_format)) {
373                         ast_debug(1, "Bridge failed to return %p(%s) to write format %s\n",
374                                 bridge_channel, ast_channel_name(bridge_channel->chan),
375                                 ast_getformatname(&bridge_channel->write_format));
376                 }
377         }
378 }
379
380 /*!
381  * \internal
382  * \brief Helper function to find a bridge channel given a channel.
383  *
384  * \param bridge What to search
385  * \param chan What to search for.
386  *
387  * \note On entry, bridge is already locked.
388  *
389  * \retval bridge_channel if channel is in the bridge.
390  * \retval NULL if not in bridge.
391  */
392 static struct ast_bridge_channel *find_bridge_channel(struct ast_bridge *bridge, struct ast_channel *chan)
393 {
394         struct ast_bridge_channel *bridge_channel;
395
396         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
397                 if (bridge_channel->chan == chan) {
398                         break;
399                 }
400         }
401
402         return bridge_channel;
403 }
404
405 /*!
406  * \internal
407  * \brief Dissolve the bridge.
408  * \since 12.0.0
409  *
410  * \param bridge Bridge to eject all channels
411  *
412  * \details
413  * Force out all channels that are not already going out of the
414  * bridge.  Any new channels joining will leave immediately.
415  *
416  * \note On entry, bridge is already locked.
417  *
418  * \return Nothing
419  */
420 static void bridge_dissolve(struct ast_bridge *bridge)
421 {
422         struct ast_bridge_channel *bridge_channel;
423         struct ast_frame action = {
424                 .frametype = AST_FRAME_BRIDGE_ACTION,
425                 .subclass.integer = AST_BRIDGE_ACTION_DEFERRED_DISSOLVING,
426         };
427
428         if (bridge->dissolved) {
429                 return;
430         }
431         bridge->dissolved = 1;
432
433         ast_debug(1, "Bridge %s: dissolving bridge\n", bridge->uniqueid);
434
435 /* BUGBUG need a cause code on the bridge for the later ejected channels. */
436         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
437                 ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
438         }
439
440         /* Must defer dissolving bridge because it is already locked. */
441         ast_bridge_queue_action(bridge, &action);
442 }
443
444 /*!
445  * \internal
446  * \brief Check if a bridge should dissolve and do it.
447  * \since 12.0.0
448  *
449  * \param bridge_channel Channel causing the check.
450  *
451  * \note On entry, bridge_channel->bridge is already locked.
452  *
453  * \return Nothing
454  */
455 static void bridge_dissolve_check(struct ast_bridge_channel *bridge_channel)
456 {
457         struct ast_bridge *bridge = bridge_channel->bridge;
458
459         if (bridge->dissolved) {
460                 return;
461         }
462
463         if (!bridge->num_channels
464                 && ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_DISSOLVE_EMPTY)) {
465                 /* Last channel leaving the bridge turns off the lights. */
466                 bridge_dissolve(bridge);
467                 return;
468         }
469
470         switch (bridge_channel->state) {
471         case AST_BRIDGE_CHANNEL_STATE_END:
472                 /* Do we need to dissolve the bridge because this channel hung up? */
473                 if (ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_DISSOLVE_HANGUP)
474                         || (bridge_channel->features->usable
475                                 && ast_test_flag(&bridge_channel->features->feature_flags,
476                                         AST_BRIDGE_CHANNEL_FLAG_DISSOLVE_HANGUP))) {
477                         bridge_dissolve(bridge);
478                         return;
479                 }
480                 break;
481         default:
482                 break;
483         }
484 /* BUGBUG need to implement AST_BRIDGE_CHANNEL_FLAG_LONELY support here */
485 }
486
487 /*!
488  * \internal
489  * \brief Pull the bridge channel out of its current bridge.
490  * \since 12.0.0
491  *
492  * \param bridge_channel Channel to pull.
493  *
494  * \note On entry, bridge_channel->bridge is already locked.
495  *
496  * \return Nothing
497  */
498 static void bridge_channel_pull(struct ast_bridge_channel *bridge_channel)
499 {
500         struct ast_bridge *bridge = bridge_channel->bridge;
501
502         if (!bridge_channel->in_bridge) {
503                 return;
504         }
505         bridge_channel->in_bridge = 0;
506
507         ast_debug(1, "Bridge %s: pulling %p(%s)\n",
508                 bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan));
509
510 /* BUGBUG This is where incoming HOLD/UNHOLD memory should write UNHOLD into bridge. (if not local optimizing) */
511 /* BUGBUG This is where incoming DTMF begin/end memory should write DTMF end into bridge. (if not local optimizing) */
512         if (!bridge_channel->just_joined) {
513                 /* Tell the bridge technology we are leaving so they tear us down */
514                 ast_debug(1, "Bridge %s: %p(%s) is leaving %s technology\n",
515                         bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
516                         bridge->technology->name);
517                 if (bridge->technology->leave) {
518                         bridge->technology->leave(bridge, bridge_channel);
519                 }
520         }
521
522         /* Remove channel from the bridge */
523         if (!bridge_channel->suspended) {
524                 --bridge->num_active;
525         }
526         --bridge->num_channels;
527         AST_LIST_REMOVE(&bridge->channels, bridge_channel, entry);
528         bridge->v_table->pull(bridge, bridge_channel);
529
530         ast_bridge_channel_clear_roles(bridge_channel);
531
532         bridge_dissolve_check(bridge_channel);
533
534         bridge->reconfigured = 1;
535         ast_bridge_publish_leave(bridge, bridge_channel->chan);
536 }
537
538 /*!
539  * \internal
540  * \brief Push the bridge channel into its specified bridge.
541  * \since 12.0.0
542  *
543  * \param bridge_channel Channel to push.
544  *
545  * \note On entry, bridge_channel->bridge is already locked.
546  *
547  * \retval 0 on success.
548  * \retval -1 on failure.  The channel did not get pushed.
549  */
550 static int bridge_channel_push(struct ast_bridge_channel *bridge_channel)
551 {
552         struct ast_bridge *bridge = bridge_channel->bridge;
553         struct ast_bridge_channel *swap;
554
555         ast_assert(!bridge_channel->in_bridge);
556
557         swap = find_bridge_channel(bridge, bridge_channel->swap);
558         bridge_channel->swap = NULL;
559
560         if (swap) {
561                 ast_debug(1, "Bridge %s: pushing %p(%s) by swapping with %p(%s)\n",
562                         bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
563                         swap, ast_channel_name(swap->chan));
564         } else {
565                 ast_debug(1, "Bridge %s: pushing %p(%s)\n",
566                         bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan));
567         }
568
569         /* Add channel to the bridge */
570         if (bridge->dissolved
571                 || bridge_channel->state != AST_BRIDGE_CHANNEL_STATE_WAIT
572                 || (swap && swap->state != AST_BRIDGE_CHANNEL_STATE_WAIT)
573                 || bridge->v_table->push(bridge, bridge_channel, swap)
574                 || ast_bridge_channel_establish_roles(bridge_channel)) {
575                 ast_debug(1, "Bridge %s: pushing %p(%s) into bridge failed\n",
576                         bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan));
577                 return -1;
578         }
579         bridge_channel->in_bridge = 1;
580         bridge_channel->just_joined = 1;
581         AST_LIST_INSERT_TAIL(&bridge->channels, bridge_channel, entry);
582         ++bridge->num_channels;
583         if (!bridge_channel->suspended) {
584                 ++bridge->num_active;
585         }
586         if (swap) {
587                 ast_bridge_change_state(swap, AST_BRIDGE_CHANNEL_STATE_HANGUP);
588                 bridge_channel_pull(swap);
589         }
590
591         /* Clear any BLINDTRANSFER since the transfer has completed. */
592         pbx_builtin_setvar_helper(bridge_channel->chan, "BLINDTRANSFER", NULL);
593
594         bridge->reconfigured = 1;
595         ast_bridge_publish_enter(bridge, bridge_channel->chan);
596         return 0;
597 }
598
599 /*! \brief Internal function to handle DTMF from a channel */
600 static struct ast_frame *bridge_handle_dtmf(struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
601 {
602         struct ast_bridge_features *features = bridge_channel->features;
603         struct ast_bridge_hook *hook;
604         char dtmf[2];
605
606 /* BUGBUG the feature hook matching needs to be done here.  Any matching feature hook needs to be queued onto the bridge_channel.  Also the feature hook digit timeout needs to be handled. */
607 /* BUGBUG the AMI atxfer action just sends DTMF end events to initiate DTMF atxfer and dial the extension.  Another reason the DTMF hook matching needs rework. */
608         /* 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 */
609         dtmf[0] = frame->subclass.integer;
610         dtmf[1] = '\0';
611         hook = ao2_find(features->dtmf_hooks, dtmf, OBJ_PARTIAL_KEY);
612         if (hook) {
613                 struct ast_frame action = {
614                         .frametype = AST_FRAME_BRIDGE_ACTION,
615                         .subclass.integer = AST_BRIDGE_ACTION_FEATURE,
616                 };
617
618                 ast_frfree(frame);
619                 frame = NULL;
620                 ast_bridge_channel_queue_frame(bridge_channel, &action);
621                 ao2_ref(hook, -1);
622         }
623
624         return frame;
625 }
626
627 /*!
628  * \internal
629  * \brief Handle bridge hangup event.
630  * \since 12.0.0
631  *
632  * \param bridge_channel Which channel is hanging up.
633  *
634  * \return Nothing
635  */
636 static void bridge_handle_hangup(struct ast_bridge_channel *bridge_channel)
637 {
638         struct ast_bridge_features *features = bridge_channel->features;
639         struct ast_bridge_hook *hook;
640         struct ao2_iterator iter;
641
642         /* Run any hangup hooks. */
643         iter = ao2_iterator_init(features->hangup_hooks, 0);
644         for (; (hook = ao2_iterator_next(&iter)); ao2_ref(hook, -1)) {
645                 int failed;
646
647                 failed = hook->callback(bridge_channel->bridge, bridge_channel, hook->hook_pvt);
648                 if (failed) {
649                         ast_debug(1, "Hangup hook %p is being removed from %p(%s)\n",
650                                 hook, bridge_channel, ast_channel_name(bridge_channel->chan));
651                         ao2_unlink(features->hangup_hooks, hook);
652                 }
653         }
654         ao2_iterator_destroy(&iter);
655
656         /* Default hangup action. */
657         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_END);
658 }
659
660 static int bridge_channel_interval_ready(struct ast_bridge_channel *bridge_channel)
661 {
662         struct ast_bridge_features *features = bridge_channel->features;
663         struct ast_bridge_hook *hook;
664         int ready;
665
666         ast_heap_wrlock(features->interval_hooks);
667         hook = ast_heap_peek(features->interval_hooks, 1);
668         ready = hook && ast_tvdiff_ms(hook->parms.timer.trip_time, ast_tvnow()) <= 0;
669         ast_heap_unlock(features->interval_hooks);
670
671         return ready;
672 }
673
674 void ast_bridge_notify_talking(struct ast_bridge_channel *bridge_channel, int started_talking)
675 {
676         struct ast_frame action = {
677                 .frametype = AST_FRAME_BRIDGE_ACTION,
678                 .subclass.integer = started_talking
679                         ? AST_BRIDGE_ACTION_TALKING_START : AST_BRIDGE_ACTION_TALKING_STOP,
680         };
681
682         ast_bridge_channel_queue_frame(bridge_channel, &action);
683 }
684
685 static void bridge_channel_write_frame(struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
686 {
687         ast_bridge_channel_lock_bridge(bridge_channel);
688 /*
689  * BUGBUG need to implement a deferred write queue for when there is no peer channel in the bridge (yet or it was kicked).
690  *
691  * The tech decides if a frame needs to be pushed back for deferral.
692  * simple_bridge/native_bridge are likely the only techs that will do this.
693  */
694         bridge_channel->bridge->technology->write(bridge_channel->bridge, bridge_channel, frame);
695         ast_bridge_unlock(bridge_channel->bridge);
696 }
697
698 void ast_bridge_channel_write_action_data(struct ast_bridge_channel *bridge_channel, enum ast_bridge_action_type action, const void *data, size_t datalen)
699 {
700         struct ast_frame frame = {
701                 .frametype = AST_FRAME_BRIDGE_ACTION,
702                 .subclass.integer = action,
703                 .datalen = datalen,
704                 .data.ptr = (void *) data,
705         };
706
707         bridge_channel_write_frame(bridge_channel, &frame);
708 }
709
710 void ast_bridge_channel_write_control_data(struct ast_bridge_channel *bridge_channel, enum ast_control_frame_type control, const void *data, size_t datalen)
711 {
712         struct ast_frame frame = {
713                 .frametype = AST_FRAME_CONTROL,
714                 .subclass.integer = control,
715                 .datalen = datalen,
716                 .data.ptr = (void *) data,
717         };
718
719         bridge_channel_write_frame(bridge_channel, &frame);
720 }
721
722 void ast_bridge_channel_write_hold(struct ast_bridge_channel *bridge_channel, const char *moh_class)
723 {
724         RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
725         size_t datalen;
726
727         if (!ast_strlen_zero(moh_class)) {
728                 datalen = strlen(moh_class) + 1;
729
730                 blob = ast_json_pack("{s: s}",
731                         "musicclass", moh_class);
732         } else {
733                 moh_class = NULL;
734                 datalen = 0;
735         }
736
737         ast_channel_publish_blob(bridge_channel->chan, ast_channel_hold_type(), blob);
738         ast_bridge_channel_write_control_data(bridge_channel, AST_CONTROL_HOLD, moh_class,
739                 datalen);
740 }
741
742 void ast_bridge_channel_write_unhold(struct ast_bridge_channel *bridge_channel)
743 {
744         ast_channel_publish_blob(bridge_channel->chan, ast_channel_unhold_type(), NULL);
745         ast_bridge_channel_write_control_data(bridge_channel, AST_CONTROL_UNHOLD, NULL, 0);
746 }
747
748 static int run_app_helper(struct ast_channel *chan, const char *app_name, const char *app_args)
749 {
750         int res = 0;
751
752         if (!strcasecmp("Gosub", app_name)) {
753                 ast_app_exec_sub(NULL, chan, app_args, 0);
754         } else if (!strcasecmp("Macro", app_name)) {
755                 ast_app_exec_macro(NULL, chan, app_args);
756         } else {
757                 struct ast_app *app;
758
759                 app = pbx_findapp(app_name);
760                 if (!app) {
761                         ast_log(LOG_WARNING, "Could not find application (%s)\n", app_name);
762                 } else {
763                         res = pbx_exec(chan, app, app_args);
764                 }
765         }
766         return res;
767 }
768
769 void ast_bridge_channel_run_app(struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
770 {
771         if (moh_class) {
772                 ast_bridge_channel_write_hold(bridge_channel, moh_class);
773         }
774         if (run_app_helper(bridge_channel->chan, app_name, S_OR(app_args, ""))) {
775                 /* Break the bridge if the app returns non-zero. */
776                 bridge_handle_hangup(bridge_channel);
777         }
778         if (moh_class) {
779                 ast_bridge_channel_write_unhold(bridge_channel);
780         }
781 }
782
783 struct bridge_run_app {
784         /*! Offset into app_name[] where the MOH class name starts.  (zero if no MOH) */
785         int moh_offset;
786         /*! Offset into app_name[] where the application argument string starts. (zero if no arguments) */
787         int app_args_offset;
788         /*! Application name to run. */
789         char app_name[0];
790 };
791
792 /*!
793  * \internal
794  * \brief Handle the run application bridge action.
795  * \since 12.0.0
796  *
797  * \param bridge_channel Which channel to run the application on.
798  * \param data Action frame data to run the application.
799  *
800  * \return Nothing
801  */
802 static void bridge_channel_run_app(struct ast_bridge_channel *bridge_channel, struct bridge_run_app *data)
803 {
804         ast_bridge_channel_run_app(bridge_channel, data->app_name,
805                 data->app_args_offset ? &data->app_name[data->app_args_offset] : NULL,
806                 data->moh_offset ? &data->app_name[data->moh_offset] : NULL);
807 }
808
809 static void payload_helper_app(ast_bridge_channel_post_action_data post_it,
810         struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
811 {
812         struct bridge_run_app *app_data;
813         size_t len_name = strlen(app_name) + 1;
814         size_t len_args = ast_strlen_zero(app_args) ? 0 : strlen(app_args) + 1;
815         size_t len_moh = !moh_class ? 0 : strlen(moh_class) + 1;
816         size_t len_data = sizeof(*app_data) + len_name + len_args + len_moh;
817
818         /* Fill in application run frame data. */
819         app_data = alloca(len_data);
820         app_data->app_args_offset = len_args ? len_name : 0;
821         app_data->moh_offset = len_moh ? len_name + len_args : 0;
822         strcpy(app_data->app_name, app_name);/* Safe */
823         if (len_args) {
824                 strcpy(&app_data->app_name[app_data->app_args_offset], app_args);/* Safe */
825         }
826         if (moh_class) {
827                 strcpy(&app_data->app_name[app_data->moh_offset], moh_class);/* Safe */
828         }
829
830         post_it(bridge_channel, AST_BRIDGE_ACTION_RUN_APP, app_data, len_data);
831 }
832
833 void ast_bridge_channel_write_app(struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
834 {
835         payload_helper_app(ast_bridge_channel_write_action_data,
836                 bridge_channel, app_name, app_args, moh_class);
837 }
838
839 void ast_bridge_channel_queue_app(struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
840 {
841         payload_helper_app(ast_bridge_channel_queue_action_data,
842                 bridge_channel, app_name, app_args, moh_class);
843 }
844
845 void ast_bridge_channel_playfile(struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
846 {
847         if (moh_class) {
848                 ast_bridge_channel_write_hold(bridge_channel, moh_class);
849         }
850         if (custom_play) {
851                 custom_play(bridge_channel, playfile);
852         } else {
853                 ast_stream_and_wait(bridge_channel->chan, playfile, AST_DIGIT_NONE);
854         }
855         if (moh_class) {
856                 ast_bridge_channel_write_unhold(bridge_channel);
857         }
858
859         /*
860          * It may be necessary to resume music on hold after we finish
861          * playing the announcment.
862          *
863          * XXX We have no idea what MOH class was in use before playing
864          * the file.
865          */
866         if (ast_test_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_MOH)) {
867                 ast_moh_start(bridge_channel->chan, NULL, NULL);
868         }
869 }
870
871 struct bridge_playfile {
872         /*! Call this function to play the playfile. (NULL if normal sound file to play) */
873         ast_bridge_custom_play_fn custom_play;
874         /*! Offset into playfile[] where the MOH class name starts.  (zero if no MOH)*/
875         int moh_offset;
876         /*! Filename to play. */
877         char playfile[0];
878 };
879
880 /*!
881  * \internal
882  * \brief Handle the playfile bridge action.
883  * \since 12.0.0
884  *
885  * \param bridge_channel Which channel to play a file on.
886  * \param payload Action frame payload to play a file.
887  *
888  * \return Nothing
889  */
890 static void bridge_channel_playfile(struct ast_bridge_channel *bridge_channel, struct bridge_playfile *payload)
891 {
892         ast_bridge_channel_playfile(bridge_channel, payload->custom_play, payload->playfile,
893                 payload->moh_offset ? &payload->playfile[payload->moh_offset] : NULL);
894 }
895
896 static void payload_helper_playfile(ast_bridge_channel_post_action_data post_it,
897         struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
898 {
899         struct bridge_playfile *payload;
900         size_t len_name = strlen(playfile) + 1;
901         size_t len_moh = !moh_class ? 0 : strlen(moh_class) + 1;
902         size_t len_payload = sizeof(*payload) + len_name + len_moh;
903
904         /* Fill in play file frame data. */
905         payload = alloca(len_payload);
906         payload->custom_play = custom_play;
907         payload->moh_offset = len_moh ? len_name : 0;
908         strcpy(payload->playfile, playfile);/* Safe */
909         if (moh_class) {
910                 strcpy(&payload->playfile[payload->moh_offset], moh_class);/* Safe */
911         }
912
913         post_it(bridge_channel, AST_BRIDGE_ACTION_PLAY_FILE, payload, len_payload);
914 }
915
916 void ast_bridge_channel_write_playfile(struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
917 {
918         payload_helper_playfile(ast_bridge_channel_write_action_data,
919                 bridge_channel, custom_play, playfile, moh_class);
920 }
921
922 void ast_bridge_channel_queue_playfile(struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
923 {
924         payload_helper_playfile(ast_bridge_channel_queue_action_data,
925                 bridge_channel, custom_play, playfile, moh_class);
926 }
927
928 struct bridge_custom_callback {
929         /*! Call this function on the bridge channel thread. */
930         ast_bridge_custom_callback_fn callback;
931         /*! Size of the payload if it exists.  A number otherwise. */
932         size_t payload_size;
933         /*! Nonzero if the payload exists. */
934         char payload_exists;
935         /*! Payload to give to callback. */
936         char payload[0];
937 };
938
939 /*!
940  * \internal
941  * \brief Handle the do custom callback bridge action.
942  * \since 12.0.0
943  *
944  * \param bridge_channel Which channel to run the application on.
945  * \param data Action frame data to run the application.
946  *
947  * \return Nothing
948  */
949 static void bridge_channel_do_callback(struct ast_bridge_channel *bridge_channel, struct bridge_custom_callback *data)
950 {
951         data->callback(bridge_channel, data->payload_exists ? data->payload : NULL, data->payload_size);
952 }
953
954 static void payload_helper_cb(ast_bridge_channel_post_action_data post_it,
955         struct ast_bridge_channel *bridge_channel, ast_bridge_custom_callback_fn callback, const void *payload, size_t payload_size)
956 {
957         struct bridge_custom_callback *cb_data;
958         size_t len_data = sizeof(*cb_data) + (payload ? payload_size : 0);
959
960         /* Sanity check. */
961         if (!callback) {
962                 ast_assert(0);
963                 return;
964         }
965
966         /* Fill in custom callback frame data. */
967         cb_data = alloca(len_data);
968         cb_data->callback = callback;
969         cb_data->payload_size = payload_size;
970         cb_data->payload_exists = payload && payload_size;
971         if (cb_data->payload_exists) {
972                 memcpy(cb_data->payload, payload, payload_size);/* Safe */
973         }
974
975         post_it(bridge_channel, AST_BRIDGE_ACTION_CALLBACK, cb_data, len_data);
976 }
977
978 void ast_bridge_channel_write_callback(struct ast_bridge_channel *bridge_channel, ast_bridge_custom_callback_fn callback, const void *payload, size_t payload_size)
979 {
980         payload_helper_cb(ast_bridge_channel_write_action_data,
981                 bridge_channel, callback, payload, payload_size);
982 }
983
984 void ast_bridge_channel_queue_callback(struct ast_bridge_channel *bridge_channel, ast_bridge_custom_callback_fn callback, const void *payload, size_t payload_size)
985 {
986         payload_helper_cb(ast_bridge_channel_queue_action_data,
987                 bridge_channel, callback, payload, payload_size);
988 }
989
990 struct bridge_park {
991         int parker_uuid_offset;
992         int app_data_offset;
993         /* buffer used for holding those strings */
994         char parkee_uuid[0];
995 };
996
997 static void bridge_channel_park(struct ast_bridge_channel *bridge_channel, struct bridge_park *payload)
998 {
999         ast_bridge_channel_park(bridge_channel, payload->parkee_uuid,
1000                 &payload->parkee_uuid[payload->parker_uuid_offset],
1001                 payload->app_data_offset ? &payload->parkee_uuid[payload->app_data_offset] : NULL);
1002 }
1003
1004 static void payload_helper_park(ast_bridge_channel_post_action_data post_it,
1005         struct ast_bridge_channel *bridge_channel,
1006         const char *parkee_uuid,
1007         const char *parker_uuid,
1008         const char *app_data)
1009 {
1010         struct bridge_park *payload;
1011         size_t len_parkee_uuid = strlen(parkee_uuid) + 1;
1012         size_t len_parker_uuid = strlen(parker_uuid) + 1;
1013         size_t len_app_data = !app_data ? 0 : strlen(app_data) + 1;
1014         size_t len_payload = sizeof(*payload) + len_parker_uuid + len_parkee_uuid + len_app_data;
1015
1016         payload = alloca(len_payload);
1017         payload->app_data_offset = len_app_data ? len_parkee_uuid + len_parker_uuid : 0;
1018         payload->parker_uuid_offset = len_parkee_uuid;
1019         strcpy(payload->parkee_uuid, parkee_uuid);
1020         strcpy(&payload->parkee_uuid[payload->parker_uuid_offset], parker_uuid);
1021         if (app_data) {
1022                 strcpy(&payload->parkee_uuid[payload->app_data_offset], app_data);
1023         }
1024
1025         post_it(bridge_channel, AST_BRIDGE_ACTION_PARK, payload, len_payload);
1026 }
1027
1028 void ast_bridge_channel_write_park(struct ast_bridge_channel *bridge_channel, const char *parkee_uuid, const char *parker_uuid, const char *app_data)
1029 {
1030         payload_helper_park(ast_bridge_channel_write_action_data,
1031                 bridge_channel, parkee_uuid, parker_uuid, app_data);
1032 }
1033
1034 /*!
1035  * \internal
1036  * \brief Feed notification that a frame is waiting on a channel into the bridging core
1037  *
1038  * \param bridge_channel Bridge channel the notification was received on
1039  */
1040 static void bridge_handle_trip(struct ast_bridge_channel *bridge_channel)
1041 {
1042         struct ast_frame *frame;
1043
1044         if (bridge_channel->features->mute) {
1045                 frame = ast_read_noaudio(bridge_channel->chan);
1046         } else {
1047                 frame = ast_read(bridge_channel->chan);
1048         }
1049
1050         if (!frame) {
1051                 bridge_handle_hangup(bridge_channel);
1052                 return;
1053         }
1054         switch (frame->frametype) {
1055         case AST_FRAME_NULL:
1056                 /* Just discard it. */
1057                 ast_frfree(frame);
1058                 return;
1059         case AST_FRAME_CONTROL:
1060                 switch (frame->subclass.integer) {
1061                 case AST_CONTROL_HANGUP:
1062                         bridge_handle_hangup(bridge_channel);
1063                         ast_frfree(frame);
1064                         return;
1065 /* BUGBUG This is where incoming HOLD/UNHOLD memory should register.  Write UNHOLD into bridge when this channel is pulled. */
1066                 default:
1067                         break;
1068                 }
1069                 break;
1070         case AST_FRAME_DTMF_BEGIN:
1071                 frame = bridge_handle_dtmf(bridge_channel, frame);
1072                 if (!frame) {
1073                         return;
1074                 }
1075                 /* Fall through */
1076         case AST_FRAME_DTMF_END:
1077                 if (!bridge_channel->features->dtmf_passthrough) {
1078                         ast_frfree(frame);
1079                         return;
1080                 }
1081 /* BUGBUG This is where incoming DTMF begin/end memory should register.  Write DTMF end into bridge when this channel is pulled. */
1082                 break;
1083         default:
1084                 break;
1085         }
1086
1087 /* BUGBUG bridge join or impart needs to do CONNECTED_LINE updates if the channels are being swapped and it is a 1-1 bridge. */
1088
1089         /* Simply write the frame out to the bridge technology. */
1090 /* BUGBUG The tech is where AST_CONTROL_ANSWER hook should go. (early bridge) */
1091 /* BUGBUG The tech is where incoming BUSY/CONGESTION hangup should happen? (early bridge) */
1092         bridge_channel_write_frame(bridge_channel, frame);
1093         ast_frfree(frame);
1094 }
1095
1096 /*!
1097  * \internal
1098  * \brief Complete joining a channel to the bridge.
1099  * \since 12.0.0
1100  *
1101  * \param bridge What to operate upon.
1102  * \param bridge_channel What is joining the bridge technology.
1103  *
1104  * \note On entry, bridge is already locked.
1105  *
1106  * \return Nothing
1107  */
1108 static void bridge_channel_complete_join(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
1109 {
1110         /* Make the channel compatible with the bridge */
1111         bridge_make_compatible(bridge, bridge_channel);
1112
1113         /* Tell the bridge technology we are joining so they set us up */
1114         ast_debug(1, "Bridge %s: %p(%s) is joining %s technology\n",
1115                 bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
1116                 bridge->technology->name);
1117         if (bridge->technology->join
1118                 && bridge->technology->join(bridge, bridge_channel)) {
1119                 ast_debug(1, "Bridge %s: %p(%s) failed to join %s technology\n",
1120                         bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
1121                         bridge->technology->name);
1122                 bridge_channel->just_joined = 1;
1123                 return;
1124         }
1125
1126         bridge_channel->just_joined = 0;
1127 }
1128
1129 /*!
1130  * \internal
1131  * \brief Complete joining new channels to the bridge.
1132  * \since 12.0.0
1133  *
1134  * \param bridge Check for new channels on this bridge.
1135  *
1136  * \note On entry, bridge is already locked.
1137  *
1138  * \return Nothing
1139  */
1140 static void bridge_complete_join(struct ast_bridge *bridge)
1141 {
1142         struct ast_bridge_channel *bridge_channel;
1143
1144         if (bridge->dissolved) {
1145                 /*
1146                  * No sense in completing the join on channels for a dissolved
1147                  * bridge.  They are just going to be removed soon anyway.
1148                  * However, we do have reason to abort here because the bridge
1149                  * technology may not be able to handle the number of channels
1150                  * still in the bridge.
1151                  */
1152                 return;
1153         }
1154
1155         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1156                 if (!bridge_channel->just_joined) {
1157                         continue;
1158                 }
1159                 bridge_channel_complete_join(bridge, bridge_channel);
1160         }
1161 }
1162
1163 /*! \brief Helper function used to find the "best" bridge technology given specified capabilities */
1164 static struct ast_bridge_technology *find_best_technology(uint32_t capabilities, struct ast_bridge *bridge)
1165 {
1166         struct ast_bridge_technology *current;
1167         struct ast_bridge_technology *best = NULL;
1168
1169         AST_RWLIST_RDLOCK(&bridge_technologies);
1170         AST_RWLIST_TRAVERSE(&bridge_technologies, current, entry) {
1171                 if (current->suspended) {
1172                         ast_debug(1, "Bridge technology %s is suspended. Skipping.\n",
1173                                 current->name);
1174                         continue;
1175                 }
1176                 if (!(current->capabilities & capabilities)) {
1177                         ast_debug(1, "Bridge technology %s does not have any capabilities we want.\n",
1178                                 current->name);
1179                         continue;
1180                 }
1181                 if (best && current->preference <= best->preference) {
1182                         ast_debug(1, "Bridge technology %s has less preference than %s (%d <= %d). Skipping.\n",
1183                                 current->name, best->name, current->preference, best->preference);
1184                         continue;
1185                 }
1186                 if (current->compatible && !current->compatible(bridge)) {
1187                         ast_debug(1, "Bridge technology %s is not compatible with properties of existing bridge.\n",
1188                                 current->name);
1189                         continue;
1190                 }
1191                 best = current;
1192         }
1193
1194         if (best) {
1195                 /* Increment it's module reference count if present so it does not get unloaded while in use */
1196                 ast_module_ref(best->mod);
1197                 ast_debug(1, "Chose bridge technology %s\n", best->name);
1198         }
1199
1200         AST_RWLIST_UNLOCK(&bridge_technologies);
1201
1202         return best;
1203 }
1204
1205 struct tech_deferred_destroy {
1206         struct ast_bridge_technology *tech;
1207         void *tech_pvt;
1208 };
1209
1210 /*!
1211  * \internal
1212  * \brief Deferred destruction of bridge tech private structure.
1213  * \since 12.0.0
1214  *
1215  * \param bridge What to execute the action on.
1216  * \param action Deferred bridge tech destruction.
1217  *
1218  * \note On entry, bridge must not be locked.
1219  *
1220  * \return Nothing
1221  */
1222 static void bridge_tech_deferred_destroy(struct ast_bridge *bridge, struct ast_frame *action)
1223 {
1224         struct tech_deferred_destroy *deferred = action->data.ptr;
1225         struct ast_bridge dummy_bridge = {
1226                 .technology = deferred->tech,
1227                 .tech_pvt = deferred->tech_pvt,
1228                 };
1229
1230         ast_copy_string(dummy_bridge.uniqueid, bridge->uniqueid, sizeof(dummy_bridge.uniqueid));
1231         ast_debug(1, "Bridge %s: calling %s technology destructor (deferred, dummy)\n",
1232                 dummy_bridge.uniqueid, dummy_bridge.technology->name);
1233         dummy_bridge.technology->destroy(&dummy_bridge);
1234         ast_module_unref(dummy_bridge.technology->mod);
1235 }
1236
1237 /*!
1238  * \internal
1239  * \brief Handle bridge action frame.
1240  * \since 12.0.0
1241  *
1242  * \param bridge What to execute the action on.
1243  * \param action What to do.
1244  *
1245  * \note On entry, bridge is already locked.
1246  * \note Can be called by the bridge destructor.
1247  *
1248  * \return Nothing
1249  */
1250 static void bridge_action_bridge(struct ast_bridge *bridge, struct ast_frame *action)
1251 {
1252 #if 0   /* In case we need to know when the destructor is calling us. */
1253         int in_destructor = !ao2_ref(bridge, 0);
1254 #endif
1255
1256         switch (action->subclass.integer) {
1257         case AST_BRIDGE_ACTION_DEFERRED_TECH_DESTROY:
1258                 ast_bridge_unlock(bridge);
1259                 bridge_tech_deferred_destroy(bridge, action);
1260                 ast_bridge_lock(bridge);
1261                 break;
1262         case AST_BRIDGE_ACTION_DEFERRED_DISSOLVING:
1263                 ast_bridge_unlock(bridge);
1264                 bridge->v_table->dissolving(bridge);
1265                 ast_bridge_lock(bridge);
1266                 break;
1267         default:
1268                 /* Unexpected deferred action type.  Should never happen. */
1269                 ast_assert(0);
1270                 break;
1271         }
1272 }
1273
1274 /*!
1275  * \internal
1276  * \brief Do any pending bridge actions.
1277  * \since 12.0.0
1278  *
1279  * \param bridge What to do actions on.
1280  *
1281  * \note On entry, bridge is already locked.
1282  * \note Can be called by the bridge destructor.
1283  *
1284  * \return Nothing
1285  */
1286 static void bridge_handle_actions(struct ast_bridge *bridge)
1287 {
1288         struct ast_frame *action;
1289
1290         while ((action = AST_LIST_REMOVE_HEAD(&bridge->action_queue, frame_list))) {
1291                 switch (action->frametype) {
1292                 case AST_FRAME_BRIDGE_ACTION:
1293                         bridge_action_bridge(bridge, action);
1294                         break;
1295                 default:
1296                         /* Unexpected deferred frame type.  Should never happen. */
1297                         ast_assert(0);
1298                         break;
1299                 }
1300                 ast_frfree(action);
1301         }
1302 }
1303
1304 static struct stasis_message *create_bridge_snapshot_message(struct ast_bridge *bridge)
1305 {
1306         RAII_VAR(struct ast_bridge_snapshot *, snapshot, NULL, ao2_cleanup);
1307         snapshot = ast_bridge_snapshot_create(bridge);
1308         if (!snapshot) {
1309                 return NULL;
1310         }
1311
1312         return stasis_message_create(ast_bridge_snapshot_type(), snapshot);
1313 }
1314
1315 static void destroy_bridge(void *obj)
1316 {
1317         struct ast_bridge *bridge = obj;
1318         RAII_VAR(struct stasis_message *, clear_msg, NULL, ao2_cleanup);
1319
1320         ast_debug(1, "Bridge %s: actually destroying %s bridge, nobody wants it anymore\n",
1321                 bridge->uniqueid, bridge->v_table->name);
1322
1323         clear_msg = create_bridge_snapshot_message(bridge);
1324         if (clear_msg) {
1325                 RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
1326                 msg = stasis_cache_clear_create(clear_msg);
1327                 if (msg) {
1328                         stasis_publish(ast_bridge_topic(bridge), msg);
1329                 }
1330         }
1331
1332         /* Do any pending actions in the context of destruction. */
1333         ast_bridge_lock(bridge);
1334         bridge_handle_actions(bridge);
1335         ast_bridge_unlock(bridge);
1336
1337         /* There should not be any channels left in the bridge. */
1338         ast_assert(AST_LIST_EMPTY(&bridge->channels));
1339
1340         ast_debug(1, "Bridge %s: calling %s bridge destructor\n",
1341                 bridge->uniqueid, bridge->v_table->name);
1342         bridge->v_table->destroy(bridge);
1343
1344         /* Pass off the bridge to the technology to destroy if needed */
1345         if (bridge->technology) {
1346                 ast_debug(1, "Bridge %s: calling %s technology stop\n",
1347                         bridge->uniqueid, bridge->technology->name);
1348                 if (bridge->technology->stop) {
1349                         ast_bridge_lock(bridge);
1350                         bridge->technology->stop(bridge);
1351                         ast_bridge_unlock(bridge);
1352                 }
1353                 ast_debug(1, "Bridge %s: calling %s technology destructor\n",
1354                         bridge->uniqueid, bridge->technology->name);
1355                 if (bridge->technology->destroy) {
1356                         bridge->technology->destroy(bridge);
1357                 }
1358                 ast_module_unref(bridge->technology->mod);
1359                 bridge->technology = NULL;
1360         }
1361
1362         if (bridge->callid) {
1363                 bridge->callid = ast_callid_unref(bridge->callid);
1364         }
1365
1366         cleanup_video_mode(bridge);
1367 }
1368
1369 struct ast_bridge *ast_bridge_register(struct ast_bridge *bridge)
1370 {
1371         if (bridge) {
1372                 ast_bridge_publish_state(bridge);
1373                 if (!ao2_link(bridges, bridge)) {
1374                         ast_bridge_destroy(bridge);
1375                         bridge = NULL;
1376                 }
1377         }
1378         return bridge;
1379 }
1380
1381 struct ast_bridge *ast_bridge_alloc(size_t size, const struct ast_bridge_methods *v_table)
1382 {
1383         struct ast_bridge *bridge;
1384
1385         /* Check v_table that all methods are present. */
1386         if (!v_table
1387                 || !v_table->name
1388                 || !v_table->destroy
1389                 || !v_table->dissolving
1390                 || !v_table->push
1391                 || !v_table->pull
1392                 || !v_table->notify_masquerade
1393                 || !v_table->get_merge_priority) {
1394                 ast_log(LOG_ERROR, "Virtual method table for bridge class %s not complete.\n",
1395                         v_table && v_table->name ? v_table->name : "<unknown>");
1396                 ast_assert(0);
1397                 return NULL;
1398         }
1399
1400         bridge = ao2_alloc(size, destroy_bridge);
1401         if (bridge) {
1402                 bridge->v_table = v_table;
1403         }
1404         return bridge;
1405 }
1406
1407 struct ast_bridge *ast_bridge_base_init(struct ast_bridge *self, uint32_t capabilities, unsigned int flags)
1408 {
1409         if (!self) {
1410                 return NULL;
1411         }
1412
1413         ast_uuid_generate_str(self->uniqueid, sizeof(self->uniqueid));
1414         ast_set_flag(&self->feature_flags, flags);
1415         self->allowed_capabilities = capabilities;
1416
1417         /* Use our helper function to find the "best" bridge technology. */
1418         self->technology = find_best_technology(capabilities, self);
1419         if (!self->technology) {
1420                 ast_debug(1, "Bridge %s: Could not create.  No technology available to support it.\n",
1421                         self->uniqueid);
1422                 ao2_ref(self, -1);
1423                 return NULL;
1424         }
1425
1426         /* Pass off the bridge to the technology to manipulate if needed */
1427         ast_debug(1, "Bridge %s: calling %s technology constructor\n",
1428                 self->uniqueid, self->technology->name);
1429         if (self->technology->create && self->technology->create(self)) {
1430                 ast_debug(1, "Bridge %s: failed to setup %s technology\n",
1431                         self->uniqueid, self->technology->name);
1432                 ao2_ref(self, -1);
1433                 return NULL;
1434         }
1435         ast_debug(1, "Bridge %s: calling %s technology start\n",
1436                 self->uniqueid, self->technology->name);
1437         if (self->technology->start && self->technology->start(self)) {
1438                 ast_debug(1, "Bridge %s: failed to start %s technology\n",
1439                         self->uniqueid, self->technology->name);
1440                 ao2_ref(self, -1);
1441                 return NULL;
1442         }
1443
1444         if (!ast_bridge_topic(self)) {
1445                 ao2_ref(self, -1);
1446                 return NULL;
1447         }
1448
1449         return self;
1450 }
1451
1452 /*!
1453  * \internal
1454  * \brief ast_bridge base class destructor.
1455  * \since 12.0.0
1456  *
1457  * \param self Bridge to operate upon.
1458  *
1459  * \note Stub because of nothing to do.
1460  *
1461  * \return Nothing
1462  */
1463 static void bridge_base_destroy(struct ast_bridge *self)
1464 {
1465 }
1466
1467 /*!
1468  * \internal
1469  * \brief The bridge is being dissolved.
1470  * \since 12.0.0
1471  *
1472  * \param self Bridge to operate upon.
1473  *
1474  * \return Nothing
1475  */
1476 static void bridge_base_dissolving(struct ast_bridge *self)
1477 {
1478         ao2_unlink(bridges, self);
1479 }
1480
1481 /*!
1482  * \internal
1483  * \brief ast_bridge base push method.
1484  * \since 12.0.0
1485  *
1486  * \param self Bridge to operate upon.
1487  * \param bridge_channel Bridge channel to push.
1488  * \param swap Bridge channel to swap places with if not NULL.
1489  *
1490  * \note On entry, self is already locked.
1491  * \note Stub because of nothing to do.
1492  *
1493  * \retval 0 on success
1494  * \retval -1 on failure
1495  */
1496 static int bridge_base_push(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct ast_bridge_channel *swap)
1497 {
1498         return 0;
1499 }
1500
1501 /*!
1502  * \internal
1503  * \brief ast_bridge base pull method.
1504  * \since 12.0.0
1505  *
1506  * \param self Bridge to operate upon.
1507  * \param bridge_channel Bridge channel to pull.
1508  *
1509  * \note On entry, self is already locked.
1510  *
1511  * \return Nothing
1512  */
1513 static void bridge_base_pull(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel)
1514 {
1515         bridge_features_remove(bridge_channel->features, AST_BRIDGE_HOOK_REMOVE_ON_PULL);
1516 }
1517
1518 /*!
1519  * \internal
1520  * \brief ast_bridge base notify_masquerade method.
1521  * \since 12.0.0
1522  *
1523  * \param self Bridge to operate upon.
1524  * \param bridge_channel Bridge channel that was masqueraded.
1525  *
1526  * \note On entry, self is already locked.
1527  *
1528  * \return Nothing
1529  */
1530 static void bridge_base_notify_masquerade(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel)
1531 {
1532         self->reconfigured = 1;
1533 }
1534
1535 /*!
1536  * \internal
1537  * \brief Get the merge priority of this bridge.
1538  * \since 12.0.0
1539  *
1540  * \param self Bridge to operate upon.
1541  *
1542  * \note On entry, self is already locked.
1543  *
1544  * \return Merge priority
1545  */
1546 static int bridge_base_get_merge_priority(struct ast_bridge *self)
1547 {
1548         return 0;
1549 }
1550
1551 struct ast_bridge_methods ast_bridge_base_v_table = {
1552         .name = "base",
1553         .destroy = bridge_base_destroy,
1554         .dissolving = bridge_base_dissolving,
1555         .push = bridge_base_push,
1556         .pull = bridge_base_pull,
1557         .notify_masquerade = bridge_base_notify_masquerade,
1558         .get_merge_priority = bridge_base_get_merge_priority,
1559 };
1560
1561 struct ast_bridge *ast_bridge_base_new(uint32_t capabilities, unsigned int flags)
1562 {
1563         void *bridge;
1564
1565         bridge = ast_bridge_alloc(sizeof(struct ast_bridge), &ast_bridge_base_v_table);
1566         bridge = ast_bridge_base_init(bridge, capabilities, flags);
1567         bridge = ast_bridge_register(bridge);
1568         return bridge;
1569 }
1570
1571 int ast_bridge_destroy(struct ast_bridge *bridge)
1572 {
1573         ast_debug(1, "Bridge %s: telling all channels to leave the party\n", bridge->uniqueid);
1574         ast_bridge_lock(bridge);
1575         bridge_dissolve(bridge);
1576         ast_bridge_unlock(bridge);
1577
1578         ao2_ref(bridge, -1);
1579
1580         return 0;
1581 }
1582
1583 static int bridge_make_compatible(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
1584 {
1585         struct ast_format read_format;
1586         struct ast_format write_format;
1587         struct ast_format best_format;
1588         char codec_buf[512];
1589
1590         ast_format_copy(&read_format, ast_channel_readformat(bridge_channel->chan));
1591         ast_format_copy(&write_format, ast_channel_writeformat(bridge_channel->chan));
1592
1593         /* Are the formats currently in use something this bridge can handle? */
1594         if (!ast_format_cap_iscompatible(bridge->technology->format_capabilities, ast_channel_readformat(bridge_channel->chan))) {
1595                 ast_best_codec(bridge->technology->format_capabilities, &best_format);
1596
1597                 /* Read format is a no go... */
1598                 ast_debug(1, "Bridge technology %s wants to read any of formats %s but channel has %s\n",
1599                         bridge->technology->name,
1600                         ast_getformatname_multiple(codec_buf, sizeof(codec_buf), bridge->technology->format_capabilities),
1601                         ast_getformatname(&read_format));
1602
1603                 /* Switch read format to the best one chosen */
1604                 if (ast_set_read_format(bridge_channel->chan, &best_format)) {
1605                         ast_log(LOG_WARNING, "Failed to set channel %s to read format %s\n",
1606                                 ast_channel_name(bridge_channel->chan), ast_getformatname(&best_format));
1607                         return -1;
1608                 }
1609                 ast_debug(1, "Bridge %s put channel %s into read format %s\n",
1610                         bridge->uniqueid, ast_channel_name(bridge_channel->chan),
1611                         ast_getformatname(&best_format));
1612         } else {
1613                 ast_debug(1, "Bridge %s is happy that channel %s already has read format %s\n",
1614                         bridge->uniqueid, ast_channel_name(bridge_channel->chan),
1615                         ast_getformatname(&read_format));
1616         }
1617
1618         if (!ast_format_cap_iscompatible(bridge->technology->format_capabilities, &write_format)) {
1619                 ast_best_codec(bridge->technology->format_capabilities, &best_format);
1620
1621                 /* Write format is a no go... */
1622                 ast_debug(1, "Bridge technology %s wants to write any of formats %s but channel has %s\n",
1623                         bridge->technology->name,
1624                         ast_getformatname_multiple(codec_buf, sizeof(codec_buf), bridge->technology->format_capabilities),
1625                         ast_getformatname(&write_format));
1626
1627                 /* Switch write format to the best one chosen */
1628                 if (ast_set_write_format(bridge_channel->chan, &best_format)) {
1629                         ast_log(LOG_WARNING, "Failed to set channel %s to write format %s\n",
1630                                 ast_channel_name(bridge_channel->chan), ast_getformatname(&best_format));
1631                         return -1;
1632                 }
1633                 ast_debug(1, "Bridge %s put channel %s into write format %s\n",
1634                         bridge->uniqueid, ast_channel_name(bridge_channel->chan),
1635                         ast_getformatname(&best_format));
1636         } else {
1637                 ast_debug(1, "Bridge %s is happy that channel %s already has write format %s\n",
1638                         bridge->uniqueid, ast_channel_name(bridge_channel->chan),
1639                         ast_getformatname(&write_format));
1640         }
1641
1642         return 0;
1643 }
1644
1645 /*!
1646  * \internal
1647  * \brief Perform the smart bridge operation.
1648  * \since 12.0.0
1649  *
1650  * \param bridge Work on this bridge.
1651  *
1652  * \details
1653  * Basically see if a new bridge technology should be used instead
1654  * of the current one.
1655  *
1656  * \note On entry, bridge is already locked.
1657  *
1658  * \retval 0 on success.
1659  * \retval -1 on error.
1660  */
1661 static int smart_bridge_operation(struct ast_bridge *bridge)
1662 {
1663         uint32_t new_capabilities;
1664         struct ast_bridge_technology *new_technology;
1665         struct ast_bridge_technology *old_technology = bridge->technology;
1666         struct ast_bridge_channel *bridge_channel;
1667         struct ast_frame *deferred_action;
1668         struct ast_bridge dummy_bridge = {
1669                 .technology = bridge->technology,
1670                 .tech_pvt = bridge->tech_pvt,
1671         };
1672
1673         if (bridge->dissolved) {
1674                 ast_debug(1, "Bridge %s is dissolved, not performing smart bridge operation.\n",
1675                         bridge->uniqueid);
1676                 return 0;
1677         }
1678
1679         /* Determine new bridge technology capabilities needed. */
1680         if (2 < bridge->num_channels) {
1681                 new_capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX;
1682                 new_capabilities &= bridge->allowed_capabilities;
1683         } else {
1684                 new_capabilities = AST_BRIDGE_CAPABILITY_NATIVE | AST_BRIDGE_CAPABILITY_1TO1MIX;
1685                 new_capabilities &= bridge->allowed_capabilities;
1686                 if (!new_capabilities
1687                         && (bridge->allowed_capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX)) {
1688                         /* Allow switching between different multimix bridge technologies. */
1689                         new_capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX;
1690                 }
1691         }
1692
1693         /* Find a bridge technology to satisfy the new capabilities. */
1694         new_technology = find_best_technology(new_capabilities, bridge);
1695         if (!new_technology) {
1696                 int is_compatible = 0;
1697
1698                 if (old_technology->compatible) {
1699                         is_compatible = old_technology->compatible(bridge);
1700                 } else if (old_technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX) {
1701                         is_compatible = 1;
1702                 } else if (bridge->num_channels <= 2
1703                         && (old_technology->capabilities & AST_BRIDGE_CAPABILITY_1TO1MIX)) {
1704                         is_compatible = 1;
1705                 }
1706
1707                 if (is_compatible) {
1708                         ast_debug(1, "Bridge %s could not get a new technology, staying with old technology.\n",
1709                                 bridge->uniqueid);
1710                         return 0;
1711                 }
1712                 ast_log(LOG_WARNING, "Bridge %s has no technology available to support it.\n",
1713                         bridge->uniqueid);
1714                 return -1;
1715         }
1716         if (new_technology == old_technology) {
1717                 ast_debug(1, "Bridge %s is already using the new technology.\n",
1718                         bridge->uniqueid);
1719                 ast_module_unref(old_technology->mod);
1720                 return 0;
1721         }
1722
1723         ast_copy_string(dummy_bridge.uniqueid, bridge->uniqueid, sizeof(dummy_bridge.uniqueid));
1724
1725         if (old_technology->destroy) {
1726                 struct tech_deferred_destroy deferred_tech_destroy = {
1727                         .tech = dummy_bridge.technology,
1728                         .tech_pvt = dummy_bridge.tech_pvt,
1729                 };
1730                 struct ast_frame action = {
1731                         .frametype = AST_FRAME_BRIDGE_ACTION,
1732                         .subclass.integer = AST_BRIDGE_ACTION_DEFERRED_TECH_DESTROY,
1733                         .data.ptr = &deferred_tech_destroy,
1734                         .datalen = sizeof(deferred_tech_destroy),
1735                 };
1736
1737                 /*
1738                  * We need to defer the bridge technology destroy callback
1739                  * because we have the bridge locked.
1740                  */
1741                 deferred_action = ast_frdup(&action);
1742                 if (!deferred_action) {
1743                         ast_module_unref(new_technology->mod);
1744                         return -1;
1745                 }
1746         } else {
1747                 deferred_action = NULL;
1748         }
1749
1750         /*
1751          * We are now committed to changing the bridge technology.  We
1752          * must not release the bridge lock until we have installed the
1753          * new bridge technology.
1754          */
1755         ast_debug(1, "Bridge %s: switching %s technology to %s\n",
1756                 bridge->uniqueid, old_technology->name, new_technology->name);
1757
1758         /*
1759          * Since we are soon going to pass this bridge to a new
1760          * technology we need to NULL out the tech_pvt pointer but
1761          * don't worry as it still exists in dummy_bridge, ditto for the
1762          * old technology.
1763          */
1764         bridge->tech_pvt = NULL;
1765         bridge->technology = new_technology;
1766
1767         /* Setup the new bridge technology. */
1768         ast_debug(1, "Bridge %s: calling %s technology constructor\n",
1769                 bridge->uniqueid, new_technology->name);
1770         if (new_technology->create && new_technology->create(bridge)) {
1771                 ast_log(LOG_WARNING, "Bridge %s: failed to setup bridge technology %s\n",
1772                         bridge->uniqueid, new_technology->name);
1773                 bridge->tech_pvt = dummy_bridge.tech_pvt;
1774                 bridge->technology = dummy_bridge.technology;
1775                 ast_module_unref(new_technology->mod);
1776                 return -1;
1777         }
1778
1779         ast_debug(1, "Bridge %s: calling %s technology stop\n",
1780                 dummy_bridge.uniqueid, old_technology->name);
1781         if (old_technology->stop) {
1782                 old_technology->stop(&dummy_bridge);
1783         }
1784
1785         /*
1786          * Move existing channels over to the new technology and
1787          * complete joining any new channels to the bridge.
1788          */
1789         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1790                 if (!bridge_channel->just_joined) {
1791                         /* Take existing channel from the old technology. */
1792                         ast_debug(1, "Bridge %s: %p(%s) is leaving %s technology (dummy)\n",
1793                                 dummy_bridge.uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
1794                                 old_technology->name);
1795                         if (old_technology->leave) {
1796                                 old_technology->leave(&dummy_bridge, bridge_channel);
1797                         }
1798                 }
1799
1800                 /* Add any new channels or re-add an existing channel to the bridge. */
1801                 bridge_channel_complete_join(bridge, bridge_channel);
1802         }
1803
1804         ast_debug(1, "Bridge %s: calling %s technology start\n",
1805                 bridge->uniqueid, new_technology->name);
1806         if (new_technology->start && new_technology->start(bridge)) {
1807                 ast_log(LOG_WARNING, "Bridge %s: failed to start bridge technology %s\n",
1808                         bridge->uniqueid, new_technology->name);
1809         }
1810
1811         /*
1812          * Now that all the channels have been moved over we need to get
1813          * rid of all the information the old technology may have left
1814          * around.
1815          */
1816         if (old_technology->destroy) {
1817                 ast_debug(1, "Bridge %s: deferring %s technology destructor\n",
1818                         dummy_bridge.uniqueid, old_technology->name);
1819                 bridge_queue_action_nodup(bridge, deferred_action);
1820         } else {
1821                 ast_debug(1, "Bridge %s: calling %s technology destructor\n",
1822                         dummy_bridge.uniqueid, old_technology->name);
1823                 ast_module_unref(old_technology->mod);
1824         }
1825
1826         return 0;
1827 }
1828
1829 /*!
1830  * \internal
1831  * \brief Bridge channel to check if a BRIDGE_PLAY_SOUND needs to be played.
1832  * \since 12.0.0
1833  *
1834  * \param bridge_channel What to check.
1835  *
1836  * \return Nothing
1837  */
1838 static void check_bridge_play_sound(struct ast_bridge_channel *bridge_channel)
1839 {
1840         const char *play_file;
1841
1842         ast_channel_lock(bridge_channel->chan);
1843         play_file = pbx_builtin_getvar_helper(bridge_channel->chan, "BRIDGE_PLAY_SOUND");
1844         if (!ast_strlen_zero(play_file)) {
1845                 play_file = ast_strdupa(play_file);
1846                 pbx_builtin_setvar_helper(bridge_channel->chan, "BRIDGE_PLAY_SOUND", NULL);
1847         } else {
1848                 play_file = NULL;
1849         }
1850         ast_channel_unlock(bridge_channel->chan);
1851
1852         if (play_file) {
1853                 ast_bridge_channel_queue_playfile(bridge_channel, NULL, play_file, NULL);
1854         }
1855 }
1856
1857 /*!
1858  * \internal
1859  * \brief Check for any BRIDGE_PLAY_SOUND channel variables in the bridge.
1860  * \since 12.0.0
1861  *
1862  * \param bridge What to operate on.
1863  *
1864  * \note On entry, the bridge is already locked.
1865  *
1866  * \return Nothing
1867  */
1868 static void check_bridge_play_sounds(struct ast_bridge *bridge)
1869 {
1870         struct ast_bridge_channel *bridge_channel;
1871
1872         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1873                 check_bridge_play_sound(bridge_channel);
1874         }
1875 }
1876
1877 static void update_bridge_vars_set(struct ast_channel *chan, const char *name, const char *pvtid)
1878 {
1879         pbx_builtin_setvar_helper(chan, "BRIDGEPEER", name);
1880         pbx_builtin_setvar_helper(chan, "BRIDGEPVTCALLID", pvtid);
1881 }
1882
1883 /*!
1884  * \internal
1885  * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in a 2 party bridge.
1886  * \since 12.0.0
1887  *
1888  * \param c0 Party of the first part.
1889  * \param c1 Party of the second part.
1890  *
1891  * \note On entry, the bridge is already locked.
1892  * \note The bridge is expected to have exactly two parties.
1893  *
1894  * \return Nothing
1895  */
1896 static void set_bridge_peer_vars_2party(struct ast_channel *c0, struct ast_channel *c1)
1897 {
1898         const char *c0_name;
1899         const char *c1_name;
1900         const char *c0_pvtid = NULL;
1901         const char *c1_pvtid = NULL;
1902 #define UPDATE_BRIDGE_VARS_GET(chan, name, pvtid)                                                                       \
1903         do {                                                                                                                                                    \
1904                 name = ast_strdupa(ast_channel_name(chan));                                                                     \
1905                 if (ast_channel_tech(chan)->get_pvt_uniqueid) {                                                         \
1906                         pvtid = ast_strdupa(ast_channel_tech(chan)->get_pvt_uniqueid(chan));    \
1907                 }                                                                                                                                                       \
1908         } while (0)
1909
1910         ast_channel_lock(c1);
1911         UPDATE_BRIDGE_VARS_GET(c1, c1_name, c1_pvtid);
1912         ast_channel_unlock(c1);
1913
1914         ast_channel_lock(c0);
1915         update_bridge_vars_set(c0, c1_name, c1_pvtid);
1916         UPDATE_BRIDGE_VARS_GET(c0, c0_name, c0_pvtid);
1917         ast_channel_unlock(c0);
1918
1919         ast_channel_lock(c1);
1920         update_bridge_vars_set(c1, c0_name, c0_pvtid);
1921         ast_channel_unlock(c1);
1922 }
1923
1924 /*!
1925  * \internal
1926  * \brief Fill the BRIDGEPEER value buffer with a comma separated list of channel names.
1927  * \since 12.0.0
1928  *
1929  * \param buf Buffer to fill.  The caller must guarantee the buffer is large enough.
1930  * \param cur_idx Which index into names[] to skip.
1931  * \param names Channel names to put in the buffer.
1932  * \param num_names Number of names in the array.
1933  *
1934  * \return Nothing
1935  */
1936 static void fill_bridgepeer_buf(char *buf, unsigned int cur_idx, const char *names[], unsigned int num_names)
1937 {
1938         int need_separator = 0;
1939         unsigned int idx;
1940         const char *src;
1941         char *pos;
1942
1943         pos = buf;
1944         for (idx = 0; idx < num_names; ++idx) {
1945                 if (idx == cur_idx) {
1946                         continue;
1947                 }
1948
1949                 if (need_separator) {
1950                         *pos++ = ',';
1951                 }
1952                 need_separator = 1;
1953
1954                 /* Copy name into buffer. */
1955                 src = names[idx];
1956                 while (*src) {
1957                         *pos++ = *src++;
1958                 }
1959         }
1960         *pos = '\0';
1961 }
1962
1963 /*!
1964  * \internal
1965  * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in a multi-party bridge.
1966  * \since 12.0.0
1967  *
1968  * \param bridge What to operate on.
1969  *
1970  * \note On entry, the bridge is already locked.
1971  * \note The bridge is expected to have more than two parties.
1972  *
1973  * \return Nothing
1974  */
1975 static void set_bridge_peer_vars_multiparty(struct ast_bridge *bridge)
1976 {
1977 /*
1978  * Set a maximum number of channel names for the BRIDGEPEER
1979  * list.  The plus one is for the current channel which is not
1980  * put in the list.
1981  */
1982 #define MAX_BRIDGEPEER_CHANS    (10 + 1)
1983
1984         unsigned int idx;
1985         unsigned int num_names;
1986         unsigned int len;
1987         const char **names;
1988         char *buf;
1989         struct ast_bridge_channel *bridge_channel;
1990
1991         /* Get first MAX_BRIDGEPEER_CHANS channel names. */
1992         num_names = MIN(bridge->num_channels, MAX_BRIDGEPEER_CHANS);
1993         names = ast_alloca(num_names * sizeof(*names));
1994         idx = 0;
1995         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1996                 if (num_names <= idx) {
1997                         break;
1998                 }
1999                 ast_channel_lock(bridge_channel->chan);
2000                 names[idx++] = ast_strdupa(ast_channel_name(bridge_channel->chan));
2001                 ast_channel_unlock(bridge_channel->chan);
2002         }
2003
2004         /* Determine maximum buf size needed. */
2005         len = num_names;
2006         for (idx = 0; idx < num_names; ++idx) {
2007                 len += strlen(names[idx]);
2008         }
2009         buf = ast_alloca(len);
2010
2011         /* Set the bridge channel variables. */
2012         idx = 0;
2013         buf[0] = '\0';
2014         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
2015                 if (idx < num_names) {
2016                         fill_bridgepeer_buf(buf, idx, names, num_names);
2017                 }
2018                 ++idx;
2019
2020                 ast_channel_lock(bridge_channel->chan);
2021                 update_bridge_vars_set(bridge_channel->chan, buf, NULL);
2022                 ast_channel_unlock(bridge_channel->chan);
2023         }
2024 }
2025
2026 /*!
2027  * \internal
2028  * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in a holding bridge.
2029  * \since 12.0.0
2030  *
2031  * \param bridge What to operate on.
2032  *
2033  * \note On entry, the bridge is already locked.
2034  *
2035  * \return Nothing
2036  */
2037 static void set_bridge_peer_vars_holding(struct ast_bridge *bridge)
2038 {
2039         struct ast_bridge_channel *bridge_channel;
2040
2041         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
2042                 ast_channel_lock(bridge_channel->chan);
2043                 update_bridge_vars_set(bridge_channel->chan, NULL, NULL);
2044                 ast_channel_unlock(bridge_channel->chan);
2045         }
2046 }
2047
2048 /*!
2049  * \internal
2050  * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in the bridge.
2051  * \since 12.0.0
2052  *
2053  * \param bridge What to operate on.
2054  *
2055  * \note On entry, the bridge is already locked.
2056  *
2057  * \return Nothing
2058  */
2059 static void set_bridge_peer_vars(struct ast_bridge *bridge)
2060 {
2061         if (bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_HOLDING) {
2062                 set_bridge_peer_vars_holding(bridge);
2063                 return;
2064         }
2065         if (bridge->num_channels < 2) {
2066                 return;
2067         }
2068         if (bridge->num_channels == 2) {
2069                 set_bridge_peer_vars_2party(AST_LIST_FIRST(&bridge->channels)->chan,
2070                         AST_LIST_LAST(&bridge->channels)->chan);
2071         } else {
2072                 set_bridge_peer_vars_multiparty(bridge);
2073         }
2074 }
2075
2076 /*!
2077  * \internal
2078  * \brief Notify the bridge that it has been reconfigured.
2079  * \since 12.0.0
2080  *
2081  * \param bridge Reconfigured bridge.
2082  *
2083  * \details
2084  * After a series of bridge_channel_push and
2085  * bridge_channel_pull calls, you need to call this function
2086  * to cause the bridge to complete restruturing for the change
2087  * in the channel makeup of the bridge.
2088  *
2089  * \note On entry, the bridge is already locked.
2090  *
2091  * \return Nothing
2092  */
2093 static void bridge_reconfigured(struct ast_bridge *bridge)
2094 {
2095         if (!bridge->reconfigured) {
2096                 return;
2097         }
2098         bridge->reconfigured = 0;
2099         if (ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_SMART)
2100                 && smart_bridge_operation(bridge)) {
2101                 /* Smart bridge failed. */
2102                 bridge_dissolve(bridge);
2103                 return;
2104         }
2105         bridge_complete_join(bridge);
2106
2107         if (bridge->dissolved) {
2108                 return;
2109         }
2110         check_bridge_play_sounds(bridge);
2111         set_bridge_peer_vars(bridge);
2112 }
2113
2114 /*!
2115  * \internal
2116  * \brief Suspend a channel from a bridge.
2117  *
2118  * \param bridge_channel Channel to suspend.
2119  *
2120  * \note This function assumes bridge_channel->bridge is locked.
2121  *
2122  * \return Nothing
2123  */
2124 static void bridge_channel_suspend_nolock(struct ast_bridge_channel *bridge_channel)
2125 {
2126         bridge_channel->suspended = 1;
2127         if (bridge_channel->in_bridge) {
2128                 --bridge_channel->bridge->num_active;
2129         }
2130
2131         /* Get technology bridge threads off of the channel. */
2132         if (bridge_channel->bridge->technology->suspend) {
2133                 bridge_channel->bridge->technology->suspend(bridge_channel->bridge, bridge_channel);
2134         }
2135 }
2136
2137 /*!
2138  * \internal
2139  * \brief Suspend a channel from a bridge.
2140  *
2141  * \param bridge_channel Channel to suspend.
2142  *
2143  * \return Nothing
2144  */
2145 static void bridge_channel_suspend(struct ast_bridge_channel *bridge_channel)
2146 {
2147         ast_bridge_channel_lock_bridge(bridge_channel);
2148         bridge_channel_suspend_nolock(bridge_channel);
2149         ast_bridge_unlock(bridge_channel->bridge);
2150 }
2151
2152 /*!
2153  * \internal
2154  * \brief Unsuspend a channel from a bridge.
2155  *
2156  * \param bridge_channel Channel to unsuspend.
2157  *
2158  * \note This function assumes bridge_channel->bridge is locked.
2159  *
2160  * \return Nothing
2161  */
2162 static void bridge_channel_unsuspend_nolock(struct ast_bridge_channel *bridge_channel)
2163 {
2164         bridge_channel->suspended = 0;
2165         if (bridge_channel->in_bridge) {
2166                 ++bridge_channel->bridge->num_active;
2167         }
2168
2169         /* Wake technology bridge threads to take care of channel again. */
2170         if (bridge_channel->bridge->technology->unsuspend) {
2171                 bridge_channel->bridge->technology->unsuspend(bridge_channel->bridge, bridge_channel);
2172         }
2173
2174         /* Wake suspended channel. */
2175         ast_bridge_channel_lock(bridge_channel);
2176         ast_cond_signal(&bridge_channel->cond);
2177         ast_bridge_channel_unlock(bridge_channel);
2178 }
2179
2180 /*!
2181  * \internal
2182  * \brief Unsuspend a channel from a bridge.
2183  *
2184  * \param bridge_channel Channel to unsuspend.
2185  *
2186  * \return Nothing
2187  */
2188 static void bridge_channel_unsuspend(struct ast_bridge_channel *bridge_channel)
2189 {
2190         ast_bridge_channel_lock_bridge(bridge_channel);
2191         bridge_channel_unsuspend_nolock(bridge_channel);
2192         ast_bridge_unlock(bridge_channel->bridge);
2193 }
2194
2195 /*! \brief Internal function that activates interval hooks on a bridge channel */
2196 static void bridge_channel_interval(struct ast_bridge_channel *bridge_channel)
2197 {
2198         struct ast_bridge_hook *hook;
2199         struct timeval start;
2200
2201         ast_heap_wrlock(bridge_channel->features->interval_hooks);
2202         start = ast_tvnow();
2203         while ((hook = ast_heap_peek(bridge_channel->features->interval_hooks, 1))) {
2204                 int interval;
2205                 unsigned int execution_time;
2206
2207                 if (ast_tvdiff_ms(hook->parms.timer.trip_time, start) > 0) {
2208                         ast_debug(1, "Hook %p on %p(%s) wants to happen in the future, stopping our traversal\n",
2209                                 hook, bridge_channel, ast_channel_name(bridge_channel->chan));
2210                         break;
2211                 }
2212                 ao2_ref(hook, +1);
2213                 ast_heap_unlock(bridge_channel->features->interval_hooks);
2214
2215                 ast_debug(1, "Executing hook %p on %p(%s)\n",
2216                         hook, bridge_channel, ast_channel_name(bridge_channel->chan));
2217                 interval = hook->callback(bridge_channel->bridge, bridge_channel, hook->hook_pvt);
2218
2219                 ast_heap_wrlock(bridge_channel->features->interval_hooks);
2220                 if (ast_heap_peek(bridge_channel->features->interval_hooks,
2221                         hook->parms.timer.heap_index) != hook
2222                         || !ast_heap_remove(bridge_channel->features->interval_hooks, hook)) {
2223                         /* Interval hook is already removed from the bridge_channel. */
2224                         ao2_ref(hook, -1);
2225                         continue;
2226                 }
2227                 ao2_ref(hook, -1);
2228
2229                 if (interval < 0) {
2230                         ast_debug(1, "Removed interval hook %p from %p(%s)\n",
2231                                 hook, bridge_channel, ast_channel_name(bridge_channel->chan));
2232                         ao2_ref(hook, -1);
2233                         continue;
2234                 }
2235                 if (interval) {
2236                         /* Set new interval for the hook. */
2237                         hook->parms.timer.interval = interval;
2238                 }
2239
2240                 ast_debug(1, "Updating interval hook %p with interval %u on %p(%s)\n",
2241                         hook, hook->parms.timer.interval, bridge_channel,
2242                         ast_channel_name(bridge_channel->chan));
2243
2244                 /* resetting start */
2245                 start = ast_tvnow();
2246
2247                 /*
2248                  * Resetup the interval hook for the next interval.  We may need
2249                  * to skip over any missed intervals because the hook was
2250                  * delayed or took too long.
2251                  */
2252                 execution_time = ast_tvdiff_ms(start, hook->parms.timer.trip_time);
2253                 while (hook->parms.timer.interval < execution_time) {
2254                         execution_time -= hook->parms.timer.interval;
2255                 }
2256                 hook->parms.timer.trip_time = ast_tvadd(start, ast_samp2tv(hook->parms.timer.interval - execution_time, 1000));
2257                 hook->parms.timer.seqno = ast_atomic_fetchadd_int((int *) &bridge_channel->features->interval_sequence, +1);
2258
2259                 if (ast_heap_push(bridge_channel->features->interval_hooks, hook)) {
2260                         /* Could not push the hook back onto the heap. */
2261                         ao2_ref(hook, -1);
2262                 }
2263         }
2264         ast_heap_unlock(bridge_channel->features->interval_hooks);
2265 }
2266
2267 static void bridge_channel_write_dtmf_stream(struct ast_bridge_channel *bridge_channel, const char *dtmf)
2268 {
2269         ast_bridge_channel_write_action_data(bridge_channel,
2270                 AST_BRIDGE_ACTION_DTMF_STREAM, dtmf, strlen(dtmf) + 1);
2271 }
2272
2273 /*!
2274  * \brief Internal function that executes a feature on a bridge channel
2275  * \note Neither the bridge nor the bridge_channel locks should be held when entering
2276  * this function.
2277  */
2278 static void bridge_channel_feature(struct ast_bridge_channel *bridge_channel)
2279 {
2280         struct ast_bridge_features *features = bridge_channel->features;
2281         struct ast_bridge_hook *hook = NULL;
2282         char dtmf[MAXIMUM_DTMF_FEATURE_STRING] = "";
2283         size_t dtmf_len = 0;
2284         unsigned int digit_timeout;
2285         RAII_VAR(struct ast_features_general_config *, gen_cfg, NULL, ao2_cleanup);
2286
2287         ast_channel_lock(bridge_channel->chan);
2288         gen_cfg = ast_get_chan_features_general_config(bridge_channel->chan);
2289         if (!gen_cfg) {
2290                 ast_log(LOG_ERROR, "Unable to retrieve features configuration.\n");
2291                 ast_channel_unlock(bridge_channel->chan);
2292                 return;
2293         }
2294         digit_timeout = gen_cfg->featuredigittimeout;
2295         ast_channel_unlock(bridge_channel->chan);
2296
2297         /* 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 */
2298         ast_set_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_END_DTMF_ONLY);
2299
2300         /* Wait for DTMF on the channel and put it into a buffer. If the buffer matches any feature hook execute the hook. */
2301         do {
2302                 int res;
2303
2304                 /* If the above timed out simply exit */
2305                 res = ast_waitfordigit(bridge_channel->chan, digit_timeout);
2306                 if (!res) {
2307                         ast_debug(1, "DTMF feature string collection on %p(%s) timed out\n",
2308                                 bridge_channel, ast_channel_name(bridge_channel->chan));
2309                         break;
2310                 }
2311                 if (res < 0) {
2312                         ast_debug(1, "DTMF feature string collection failed on %p(%s) for some reason\n",
2313                                 bridge_channel, ast_channel_name(bridge_channel->chan));
2314                         break;
2315                 }
2316
2317 /* BUGBUG need to record the duration of DTMF digits so when the string is played back, they are reproduced. */
2318                 /* Add the above DTMF into the DTMF string so we can do our matching */
2319                 dtmf[dtmf_len++] = res;
2320                 ast_debug(1, "DTMF feature string on %p(%s) is now '%s'\n",
2321                         bridge_channel, ast_channel_name(bridge_channel->chan), dtmf);
2322
2323                 /* See if a DTMF feature hook matches or can match */
2324                 hook = ao2_find(features->dtmf_hooks, dtmf, OBJ_PARTIAL_KEY);
2325                 if (!hook) {
2326                         ast_debug(1, "No DTMF feature hooks on %p(%s) match '%s'\n",
2327                                 bridge_channel, ast_channel_name(bridge_channel->chan), dtmf);
2328                         break;
2329                 }
2330                 if (strlen(hook->parms.dtmf.code) == dtmf_len) {
2331                         ast_debug(1, "DTMF feature hook %p matched DTMF string '%s' on %p(%s)\n",
2332                                 hook, dtmf, bridge_channel, ast_channel_name(bridge_channel->chan));
2333                         break;
2334                 }
2335                 ao2_ref(hook, -1);
2336                 hook = NULL;
2337
2338                 /* Stop if we have reached the maximum length of a DTMF feature string. */
2339         } while (dtmf_len < ARRAY_LEN(dtmf) - 1);
2340
2341         /* Since we are done bringing DTMF in return to using both begin and end frames */
2342         ast_clear_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_END_DTMF_ONLY);
2343
2344         /* If a hook was actually matched execute it on this channel, otherwise stream up the DTMF to the other channels */
2345         if (hook) {
2346                 int failed;
2347
2348                 failed = hook->callback(bridge_channel->bridge, bridge_channel, hook->hook_pvt);
2349                 if (failed) {
2350                         ast_debug(1, "DTMF hook %p is being removed from %p(%s)\n",
2351                                 hook, bridge_channel, ast_channel_name(bridge_channel->chan));
2352                         ao2_unlink(features->dtmf_hooks, hook);
2353                 }
2354                 ao2_ref(hook, -1);
2355
2356                 /*
2357                  * If we are handing the channel off to an external hook for
2358                  * ownership, we are not guaranteed what kind of state it will
2359                  * come back in.  If the channel hungup, we need to detect that
2360                  * here if the hook did not already change the state.
2361                  */
2362                 if (bridge_channel->chan && ast_check_hangup_locked(bridge_channel->chan)) {
2363                         bridge_handle_hangup(bridge_channel);
2364                 }
2365         } else if (features->dtmf_passthrough) {
2366                 bridge_channel_write_dtmf_stream(bridge_channel, dtmf);
2367         }
2368 }
2369
2370 static void bridge_channel_talking(struct ast_bridge_channel *bridge_channel, int talking)
2371 {
2372         struct ast_bridge_features *features = bridge_channel->features;
2373
2374         if (features->talker_cb) {
2375                 features->talker_cb(bridge_channel, features->talker_pvt_data, talking);
2376         }
2377 }
2378
2379 /*! \brief Internal function that plays back DTMF on a bridge channel */
2380 static void bridge_channel_dtmf_stream(struct ast_bridge_channel *bridge_channel, const char *dtmf)
2381 {
2382         ast_debug(1, "Playing DTMF stream '%s' out to %p(%s)\n",
2383                 dtmf, bridge_channel, ast_channel_name(bridge_channel->chan));
2384         ast_dtmf_stream(bridge_channel->chan, NULL, dtmf, 0, 0);
2385 }
2386
2387 struct blind_transfer_data {
2388         char exten[AST_MAX_EXTENSION];
2389         char context[AST_MAX_CONTEXT];
2390 };
2391
2392 static void bridge_channel_blind_transfer(struct ast_bridge_channel *bridge_channel,
2393                 struct blind_transfer_data *blind_data)
2394 {
2395         ast_async_goto(bridge_channel->chan, blind_data->context, blind_data->exten, 1);
2396         bridge_handle_hangup(bridge_channel);
2397 }
2398
2399 static void after_bridge_move_channel(struct ast_channel *chan_bridged, void *data)
2400 {
2401         RAII_VAR(struct ast_channel *, chan_target, data, ao2_cleanup);
2402
2403         if (ast_channel_move(chan_target, chan_bridged)) {
2404                 ast_softhangup(chan_target, AST_SOFTHANGUP_DEV);
2405         }
2406 }
2407
2408 static void after_bridge_move_channel_fail(enum ast_after_bridge_cb_reason reason, void *data)
2409 {
2410         RAII_VAR(struct ast_channel *, chan_target, data, ao2_cleanup);
2411
2412         ast_log(LOG_WARNING, "Unable to complete transfer: %s\n",
2413                 ast_after_bridge_cb_reason_string(reason));
2414         ast_softhangup(chan_target, AST_SOFTHANGUP_DEV);
2415 }
2416
2417 static void bridge_channel_attended_transfer(struct ast_bridge_channel *bridge_channel,
2418                 const char *target_chan_name)
2419 {
2420         RAII_VAR(struct ast_channel *, chan_target, NULL, ao2_cleanup);
2421         RAII_VAR(struct ast_channel *, chan_bridged, NULL, ao2_cleanup);
2422
2423         chan_target = ast_channel_get_by_name(target_chan_name);
2424         if (!chan_target) {
2425                 /* Dang, it disappeared somehow */
2426                 bridge_handle_hangup(bridge_channel);
2427                 return;
2428         }
2429
2430         ast_bridge_channel_lock(bridge_channel);
2431         chan_bridged = bridge_channel->chan;
2432         ast_assert(chan_bridged != NULL);
2433         ao2_ref(chan_bridged, +1);
2434         ast_bridge_channel_unlock(bridge_channel);
2435
2436         if (ast_after_bridge_callback_set(chan_bridged, after_bridge_move_channel,
2437                 after_bridge_move_channel_fail, ast_channel_ref(chan_target))) {
2438                 ast_softhangup(chan_target, AST_SOFTHANGUP_DEV);
2439
2440                 /* Release the ref we tried to pass to ast_after_bridge_callback_set(). */
2441                 ast_channel_unref(chan_target);
2442         }
2443         bridge_handle_hangup(bridge_channel);
2444 }
2445
2446 /*!
2447  * \internal
2448  * \brief Handle bridge channel bridge action frame.
2449  * \since 12.0.0
2450  *
2451  * \param bridge_channel Channel to execute the action on.
2452  * \param action What to do.
2453  *
2454  * \return Nothing
2455  */
2456 static void bridge_channel_handle_action(struct ast_bridge_channel *bridge_channel, struct ast_frame *action)
2457 {
2458         switch (action->subclass.integer) {
2459         case AST_BRIDGE_ACTION_INTERVAL:
2460                 bridge_channel_suspend(bridge_channel);
2461                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2462                 bridge_channel_interval(bridge_channel);
2463                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2464                 bridge_channel_unsuspend(bridge_channel);
2465                 break;
2466         case AST_BRIDGE_ACTION_FEATURE:
2467                 bridge_channel_suspend(bridge_channel);
2468                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2469                 bridge_channel_feature(bridge_channel);
2470                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2471                 bridge_channel_unsuspend(bridge_channel);
2472                 break;
2473         case AST_BRIDGE_ACTION_DTMF_STREAM:
2474                 bridge_channel_suspend(bridge_channel);
2475                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2476                 bridge_channel_dtmf_stream(bridge_channel, action->data.ptr);
2477                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2478                 bridge_channel_unsuspend(bridge_channel);
2479                 break;
2480         case AST_BRIDGE_ACTION_TALKING_START:
2481         case AST_BRIDGE_ACTION_TALKING_STOP:
2482                 bridge_channel_talking(bridge_channel,
2483                         action->subclass.integer == AST_BRIDGE_ACTION_TALKING_START);
2484                 break;
2485         case AST_BRIDGE_ACTION_PLAY_FILE:
2486                 bridge_channel_suspend(bridge_channel);
2487                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2488                 bridge_channel_playfile(bridge_channel, action->data.ptr);
2489                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2490                 bridge_channel_unsuspend(bridge_channel);
2491                 break;
2492         case AST_BRIDGE_ACTION_RUN_APP:
2493                 bridge_channel_suspend(bridge_channel);
2494                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2495                 bridge_channel_run_app(bridge_channel, action->data.ptr);
2496                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2497                 bridge_channel_unsuspend(bridge_channel);
2498                 break;
2499         case AST_BRIDGE_ACTION_CALLBACK:
2500                 bridge_channel_suspend(bridge_channel);
2501                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2502                 bridge_channel_do_callback(bridge_channel, action->data.ptr);
2503                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2504                 bridge_channel_unsuspend(bridge_channel);
2505                 break;
2506         case AST_BRIDGE_ACTION_PARK:
2507                 bridge_channel_suspend(bridge_channel);
2508                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2509                 bridge_channel_park(bridge_channel, action->data.ptr);
2510                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2511                 bridge_channel_unsuspend(bridge_channel);
2512                 break;
2513         case AST_BRIDGE_ACTION_BLIND_TRANSFER:
2514                 bridge_channel_blind_transfer(bridge_channel, action->data.ptr);
2515                 break;
2516         case AST_BRIDGE_ACTION_ATTENDED_TRANSFER:
2517                 bridge_channel_attended_transfer(bridge_channel, action->data.ptr);
2518                 break;
2519         default:
2520                 break;
2521         }
2522 }
2523
2524 /*!
2525  * \internal
2526  * \brief Handle bridge channel control frame action.
2527  * \since 12.0.0
2528  *
2529  * \param bridge_channel Channel to execute the control frame action on.
2530  * \param fr Control frame to handle.
2531  *
2532  * \return Nothing
2533  */
2534 static void bridge_channel_handle_control(struct ast_bridge_channel *bridge_channel, struct ast_frame *fr)
2535 {
2536         struct ast_channel *chan;
2537         struct ast_option_header *aoh;
2538         int is_caller;
2539         int intercept_failed;
2540
2541         chan = bridge_channel->chan;
2542         switch (fr->subclass.integer) {
2543         case AST_CONTROL_REDIRECTING:
2544                 is_caller = !ast_test_flag(ast_channel_flags(chan), AST_FLAG_OUTGOING);
2545                 bridge_channel_suspend(bridge_channel);
2546                 intercept_failed = ast_channel_redirecting_sub(NULL, chan, fr, 1)
2547                         && ast_channel_redirecting_macro(NULL, chan, fr, is_caller, 1);
2548                 bridge_channel_unsuspend(bridge_channel);
2549                 if (intercept_failed) {
2550                         ast_indicate_data(chan, fr->subclass.integer, fr->data.ptr, fr->datalen);
2551                 }
2552                 break;
2553         case AST_CONTROL_CONNECTED_LINE:
2554                 is_caller = !ast_test_flag(ast_channel_flags(chan), AST_FLAG_OUTGOING);
2555                 bridge_channel_suspend(bridge_channel);
2556                 intercept_failed = ast_channel_connected_line_sub(NULL, chan, fr, 1)
2557                         && ast_channel_connected_line_macro(NULL, chan, fr, is_caller, 1);
2558                 bridge_channel_unsuspend(bridge_channel);
2559                 if (intercept_failed) {
2560                         ast_indicate_data(chan, fr->subclass.integer, fr->data.ptr, fr->datalen);
2561                 }
2562                 break;
2563         case AST_CONTROL_HOLD:
2564         case AST_CONTROL_UNHOLD:
2565 /*
2566  * BUGBUG bridge_channels should remember sending/receiving an outstanding HOLD to/from the bridge
2567  *
2568  * When the sending channel is pulled from the bridge it needs to write into the bridge an UNHOLD before being pulled.
2569  * When the receiving channel is pulled from the bridge it needs to generate its own UNHOLD.
2570  * Something similar needs to be done for DTMF begin/end.
2571  */
2572         case AST_CONTROL_VIDUPDATE:
2573         case AST_CONTROL_SRCUPDATE:
2574         case AST_CONTROL_SRCCHANGE:
2575         case AST_CONTROL_T38_PARAMETERS:
2576 /* BUGBUG may have to do something with a jitter buffer for these. */
2577                 ast_indicate_data(chan, fr->subclass.integer, fr->data.ptr, fr->datalen);
2578                 break;
2579         case AST_CONTROL_OPTION:
2580                 /*
2581                  * Forward option Requests, but only ones we know are safe These
2582                  * are ONLY sent by chan_iax2 and I'm not convinced that they
2583                  * are useful. I haven't deleted them entirely because I just am
2584                  * not sure of the ramifications of removing them.
2585                  */
2586                 aoh = fr->data.ptr;
2587                 if (aoh && aoh->flag == AST_OPTION_FLAG_REQUEST) {
2588                         switch (ntohs(aoh->option)) {
2589                         case AST_OPTION_TONE_VERIFY:
2590                         case AST_OPTION_TDD:
2591                         case AST_OPTION_RELAXDTMF:
2592                         case AST_OPTION_AUDIO_MODE:
2593                         case AST_OPTION_DIGIT_DETECT:
2594                         case AST_OPTION_FAX_DETECT:
2595                                 ast_channel_setoption(chan, ntohs(aoh->option), aoh->data,
2596                                         fr->datalen - sizeof(*aoh), 0);
2597                                 break;
2598                         default:
2599                                 break;
2600                         }
2601                 }
2602                 break;
2603         case AST_CONTROL_ANSWER:
2604                 if (ast_channel_state(chan) != AST_STATE_UP) {
2605                         ast_answer(chan);
2606                 } else {
2607                         ast_indicate(chan, -1);
2608                 }
2609                 break;
2610         default:
2611                 ast_indicate_data(chan, fr->subclass.integer, fr->data.ptr, fr->datalen);
2612                 break;
2613         }
2614 }
2615
2616 /*!
2617  * \internal
2618  * \brief Handle bridge channel write frame to channel.
2619  * \since 12.0.0
2620  *
2621  * \param bridge_channel Channel to write outgoing frame.
2622  *
2623  * \return Nothing
2624  */
2625 static void bridge_channel_handle_write(struct ast_bridge_channel *bridge_channel)
2626 {
2627         struct ast_frame *fr;
2628         char nudge;
2629
2630         ast_bridge_channel_lock(bridge_channel);
2631         if (read(bridge_channel->alert_pipe[0], &nudge, sizeof(nudge)) < 0) {
2632                 if (errno != EINTR && errno != EAGAIN) {
2633                         ast_log(LOG_WARNING, "read() failed for alert pipe on %p(%s): %s\n",
2634                                 bridge_channel, ast_channel_name(bridge_channel->chan), strerror(errno));
2635                 }
2636         }
2637         fr = AST_LIST_REMOVE_HEAD(&bridge_channel->wr_queue, frame_list);
2638         ast_bridge_channel_unlock(bridge_channel);
2639         if (!fr) {
2640                 return;
2641         }
2642         switch (fr->frametype) {
2643         case AST_FRAME_BRIDGE_ACTION:
2644                 bridge_channel_handle_action(bridge_channel, fr);
2645                 break;
2646         case AST_FRAME_CONTROL:
2647                 bridge_channel_handle_control(bridge_channel, fr);
2648                 break;
2649         case AST_FRAME_NULL:
2650                 break;
2651         default:
2652                 /* Write the frame to the channel. */
2653                 bridge_channel->activity = AST_BRIDGE_CHANNEL_THREAD_SIMPLE;
2654                 ast_write(bridge_channel->chan, fr);
2655                 break;
2656         }
2657         ast_frfree(fr);
2658 }
2659
2660 /*!
2661  * \internal
2662  * \brief Handle bridge channel interval expiration.
2663  * \since 12.0.0
2664  *
2665  * \param bridge_channel Channel to check interval on.
2666  *
2667  * \return Nothing
2668  */
2669 static void bridge_channel_handle_interval(struct ast_bridge_channel *bridge_channel)
2670 {
2671         struct ast_timer *interval_timer;
2672
2673         interval_timer = bridge_channel->features->interval_timer;
2674         if (interval_timer) {
2675                 if (ast_wait_for_input(ast_timer_fd(interval_timer), 0) == 1) {
2676                         ast_timer_ack(interval_timer, 1);
2677                         if (bridge_channel_interval_ready(bridge_channel)) {
2678 /* BUGBUG since this is now only run by the channel thread, there is no need to queue the action once this intervals become a first class wait item in bridge_channel_wait(). */
2679                                 struct ast_frame interval_action = {
2680                                         .frametype = AST_FRAME_BRIDGE_ACTION,
2681                                         .subclass.integer = AST_BRIDGE_ACTION_INTERVAL,
2682                                 };
2683
2684                                 ast_bridge_channel_queue_frame(bridge_channel, &interval_action);
2685                         }
2686                 }
2687         }
2688 }
2689
2690 /*!
2691  * \internal
2692  * \brief Wait for something to happen on the bridge channel and handle it.
2693  * \since 12.0.0
2694  *
2695  * \param bridge_channel Channel to wait.
2696  *
2697  * \note Each channel does writing/reading in their own thread.
2698  *
2699  * \return Nothing
2700  */
2701 static void bridge_channel_wait(struct ast_bridge_channel *bridge_channel)
2702 {
2703         int ms = -1;
2704         int outfd;
2705         struct ast_channel *chan;
2706
2707         /* Wait for data to either come from the channel or us to be signaled */
2708         ast_bridge_channel_lock(bridge_channel);
2709         if (bridge_channel->state != AST_BRIDGE_CHANNEL_STATE_WAIT) {
2710         } else if (bridge_channel->suspended) {
2711 /* BUGBUG the external party use of suspended will go away as will these references because this is the bridge channel thread */
2712                 ast_debug(1, "Bridge %s: %p(%s) is going into a signal wait\n",
2713                         bridge_channel->bridge->uniqueid, bridge_channel,
2714                         ast_channel_name(bridge_channel->chan));
2715                 ast_cond_wait(&bridge_channel->cond, ao2_object_get_lockaddr(bridge_channel));
2716         } else {
2717                 ast_debug(10, "Bridge %s: %p(%s) is going into a waitfor\n",
2718                         bridge_channel->bridge->uniqueid, bridge_channel,
2719                         ast_channel_name(bridge_channel->chan));
2720                 bridge_channel->waiting = 1;
2721                 ast_bridge_channel_unlock(bridge_channel);
2722                 outfd = -1;
2723 /* BUGBUG need to make the next expiring active interval setup ms timeout rather than holding up the chan reads. */
2724                 chan = ast_waitfor_nandfds(&bridge_channel->chan, 1,
2725                         &bridge_channel->alert_pipe[0], 1, NULL, &outfd, &ms);
2726                 bridge_channel->waiting = 0;
2727                 if (ast_channel_softhangup_internal_flag(bridge_channel->chan) & AST_SOFTHANGUP_UNBRIDGE) {
2728                         ast_channel_clear_softhangup(bridge_channel->chan, AST_SOFTHANGUP_UNBRIDGE);
2729                         ast_bridge_channel_lock_bridge(bridge_channel);
2730                         bridge_channel->bridge->reconfigured = 1;
2731                         bridge_reconfigured(bridge_channel->bridge);
2732                         ast_bridge_unlock(bridge_channel->bridge);
2733                 }
2734                 ast_bridge_channel_lock(bridge_channel);
2735                 bridge_channel->activity = AST_BRIDGE_CHANNEL_THREAD_FRAME;
2736                 ast_bridge_channel_unlock(bridge_channel);
2737                 if (!bridge_channel->suspended
2738                         && bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_WAIT) {
2739                         if (chan) {
2740                                 bridge_channel_handle_interval(bridge_channel);
2741                                 bridge_handle_trip(bridge_channel);
2742                         } else if (-1 < outfd) {
2743                                 bridge_channel_handle_write(bridge_channel);
2744                         }
2745                 }
2746                 bridge_channel->activity = AST_BRIDGE_CHANNEL_THREAD_IDLE;
2747                 return;
2748         }
2749         ast_bridge_channel_unlock(bridge_channel);
2750 }
2751
2752 /*!
2753  * \internal
2754  * \brief Handle bridge channel join event.
2755  * \since 12.0.0
2756  *
2757  * \param bridge_channel Which channel is joining.
2758  *
2759  * \return Nothing
2760  */
2761 static void bridge_channel_handle_join(struct ast_bridge_channel *bridge_channel)
2762 {
2763         struct ast_bridge_features *features = bridge_channel->features;
2764         struct ast_bridge_hook *hook;
2765         struct ao2_iterator iter;
2766
2767         /* Run any join hooks. */
2768         iter = ao2_iterator_init(features->join_hooks, AO2_ITERATOR_UNLINK);
2769         hook = ao2_iterator_next(&iter);
2770         if (hook) {
2771                 bridge_channel_suspend(bridge_channel);
2772                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2773                 do {
2774                         hook->callback(bridge_channel->bridge, bridge_channel, hook->hook_pvt);
2775                         ao2_ref(hook, -1);
2776                 } while ((hook = ao2_iterator_next(&iter)));
2777                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2778                 bridge_channel_unsuspend(bridge_channel);
2779         }
2780         ao2_iterator_destroy(&iter);
2781 }
2782
2783 /*!
2784  * \internal
2785  * \brief Handle bridge channel leave event.
2786  * \since 12.0.0
2787  *
2788  * \param bridge_channel Which channel is leaving.
2789  *
2790  * \return Nothing
2791  */
2792 static void bridge_channel_handle_leave(struct ast_bridge_channel *bridge_channel)
2793 {
2794         struct ast_bridge_features *features = bridge_channel->features;
2795         struct ast_bridge_hook *hook;
2796         struct ao2_iterator iter;
2797
2798         /* Run any leave hooks. */
2799         iter = ao2_iterator_init(features->leave_hooks, AO2_ITERATOR_UNLINK);
2800         hook = ao2_iterator_next(&iter);
2801         if (hook) {
2802                 bridge_channel_suspend(bridge_channel);
2803                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2804                 do {
2805                         hook->callback(bridge_channel->bridge, bridge_channel, hook->hook_pvt);
2806                         ao2_ref(hook, -1);
2807                 } while ((hook = ao2_iterator_next(&iter)));
2808                 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2809                 bridge_channel_unsuspend(bridge_channel);
2810         }
2811         ao2_iterator_destroy(&iter);
2812 }
2813
2814 /*! \brief Join a channel to a bridge and handle anything the bridge may want us to do */
2815 static void bridge_channel_join(struct ast_bridge_channel *bridge_channel)
2816 {
2817         ast_format_copy(&bridge_channel->read_format, ast_channel_readformat(bridge_channel->chan));
2818         ast_format_copy(&bridge_channel->write_format, ast_channel_writeformat(bridge_channel->chan));
2819
2820         ast_debug(1, "Bridge %s: %p(%s) is joining\n",
2821                 bridge_channel->bridge->uniqueid,
2822                 bridge_channel, ast_channel_name(bridge_channel->chan));
2823
2824         /*
2825          * Get "in the bridge" before pushing the channel for any
2826          * masquerades on the channel to happen before bridging.
2827          */
2828         ast_channel_lock(bridge_channel->chan);
2829         ast_channel_internal_bridge_set(bridge_channel->chan, bridge_channel->bridge);
2830         ast_channel_unlock(bridge_channel->chan);
2831
2832         /* Add the jitterbuffer if the channel requires it */
2833         ast_jb_enable_for_channel(bridge_channel->chan);
2834
2835         /*
2836          * Directly locking the bridge is safe here because nobody else
2837          * knows about this bridge_channel yet.
2838          */
2839         ast_bridge_lock(bridge_channel->bridge);
2840
2841         if (!bridge_channel->bridge->callid) {
2842                 bridge_channel->bridge->callid = ast_read_threadstorage_callid();
2843         }
2844
2845         if (bridge_channel_push(bridge_channel)) {
2846                 ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
2847         }
2848         bridge_reconfigured(bridge_channel->bridge);
2849
2850         if (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_WAIT) {
2851                 /*
2852                  * Indicate a source change since this channel is entering the
2853                  * bridge system only if the bridge technology is not MULTIMIX
2854                  * capable.  The MULTIMIX technology has already done it.
2855                  */
2856                 if (!(bridge_channel->bridge->technology->capabilities
2857                         & AST_BRIDGE_CAPABILITY_MULTIMIX)) {
2858                         ast_indicate(bridge_channel->chan, AST_CONTROL_SRCCHANGE);
2859                 }
2860
2861                 ast_bridge_unlock(bridge_channel->bridge);
2862                 bridge_channel_handle_join(bridge_channel);
2863                 while (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_WAIT) {
2864                         /* Wait for something to do. */
2865                         bridge_channel_wait(bridge_channel);
2866                 }
2867                 bridge_channel_handle_leave(bridge_channel);
2868                 ast_bridge_channel_lock_bridge(bridge_channel);
2869         }
2870
2871         bridge_channel_pull(bridge_channel);
2872         bridge_reconfigured(bridge_channel->bridge);
2873
2874         ast_bridge_unlock(bridge_channel->bridge);
2875
2876         /* Indicate a source change since this channel is leaving the bridge system. */
2877         ast_indicate(bridge_channel->chan, AST_CONTROL_SRCCHANGE);
2878
2879 /* BUGBUG Revisit in regards to moving channels between bridges and local channel optimization. */
2880 /* BUGBUG This is where outgoing HOLD/UNHOLD memory should write UNHOLD to channel. */
2881         /* Complete any partial DTMF digit before exiting the bridge. */
2882         if (ast_channel_sending_dtmf_digit(bridge_channel->chan)) {
2883                 ast_bridge_end_dtmf(bridge_channel->chan,
2884                         ast_channel_sending_dtmf_digit(bridge_channel->chan),
2885                         ast_channel_sending_dtmf_tv(bridge_channel->chan), "bridge end");
2886         }
2887
2888         /*
2889          * Wait for any dual redirect to complete.
2890          *
2891          * Must be done while "still in the bridge" for ast_async_goto()
2892          * to work right.
2893          */
2894         while (ast_test_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_BRIDGE_DUAL_REDIRECT_WAIT)) {
2895                 sched_yield();
2896         }
2897         ast_channel_lock(bridge_channel->chan);
2898         ast_channel_internal_bridge_set(bridge_channel->chan, NULL);
2899         ast_channel_unlock(bridge_channel->chan);
2900
2901         ast_bridge_channel_restore_formats(bridge_channel);
2902 }
2903
2904 /*!
2905  * \internal
2906  * \brief Close a pipe.
2907  * \since 12.0.0
2908  *
2909  * \param my_pipe What to close.
2910  *
2911  * \return Nothing
2912  */
2913 static void pipe_close(int *my_pipe)
2914 {
2915         if (my_pipe[0] > -1) {
2916                 close(my_pipe[0]);
2917                 my_pipe[0] = -1;
2918         }
2919         if (my_pipe[1] > -1) {
2920                 close(my_pipe[1]);
2921                 my_pipe[1] = -1;
2922         }
2923 }
2924
2925 /*!
2926  * \internal
2927  * \brief Initialize a pipe as non-blocking.
2928  * \since 12.0.0
2929  *
2930  * \param my_pipe What to initialize.
2931  *
2932  * \retval 0 on success.
2933  * \retval -1 on error.
2934  */
2935 static int pipe_init_nonblock(int *my_pipe)
2936 {
2937         int flags;
2938
2939         my_pipe[0] = -1;
2940         my_pipe[1] = -1;
2941         if (pipe(my_pipe)) {
2942                 ast_log(LOG_WARNING, "Can't create pipe! Try increasing max file descriptors with ulimit -n\n");
2943                 return -1;
2944         }
2945         flags = fcntl(my_pipe[0], F_GETFL);
2946         if (fcntl(my_pipe[0], F_SETFL, flags | O_NONBLOCK) < 0) {
2947                 ast_log(LOG_WARNING, "Unable to set read pipe nonblocking! (%d: %s)\n",
2948                         errno, strerror(errno));
2949                 return -1;
2950         }
2951         flags = fcntl(my_pipe[1], F_GETFL);
2952         if (fcntl(my_pipe[1], F_SETFL, flags | O_NONBLOCK) < 0) {
2953                 ast_log(LOG_WARNING, "Unable to set write pipe nonblocking! (%d: %s)\n",
2954                         errno, strerror(errno));
2955                 return -1;
2956         }
2957         return 0;
2958 }
2959
2960 /* Destroy elements of the bridge channel structure and the bridge channel structure itself */
2961 static void bridge_channel_destroy(void *obj)
2962 {
2963         struct ast_bridge_channel *bridge_channel = obj;
2964         struct ast_frame *fr;
2965
2966         if (bridge_channel->callid) {
2967                 bridge_channel->callid = ast_callid_unref(bridge_channel->callid);
2968         }
2969
2970         if (bridge_channel->bridge) {
2971                 ao2_ref(bridge_channel->bridge, -1);
2972                 bridge_channel->bridge = NULL;
2973         }
2974
2975         /* Flush any unhandled wr_queue frames. */
2976         while ((fr = AST_LIST_REMOVE_HEAD(&bridge_channel->wr_queue, frame_list))) {
2977                 ast_frfree(fr);
2978         }
2979         pipe_close(bridge_channel->alert_pipe);
2980
2981         ast_cond_destroy(&bridge_channel->cond);
2982 }
2983
2984 static struct ast_bridge_channel *bridge_channel_alloc(struct ast_bridge *bridge)
2985 {
2986         struct ast_bridge_channel *bridge_channel;
2987
2988         bridge_channel = ao2_alloc(sizeof(struct ast_bridge_channel), bridge_channel_destroy);
2989         if (!bridge_channel) {
2990                 return NULL;
2991         }
2992         ast_cond_init(&bridge_channel->cond, NULL);
2993         if (pipe_init_nonblock(bridge_channel->alert_pipe)) {
2994                 ao2_ref(bridge_channel, -1);
2995                 return NULL;
2996         }
2997         if (bridge) {
2998                 bridge_channel->bridge = bridge;
2999                 ao2_ref(bridge_channel->bridge, +1);
3000         }
3001
3002         return bridge_channel;
3003 }
3004
3005 struct after_bridge_cb_ds {
3006         /*! Desired callback function. */
3007         ast_after_bridge_cb callback;
3008         /*! After bridge callback will not be called and destroy any resources data may contain. */
3009         ast_after_bridge_cb_failed failed;
3010         /*! Extra data to pass to the callback. */
3011         void *data;
3012 };
3013
3014 /*!
3015  * \internal
3016  * \brief Destroy the after bridge callback datastore.
3017  * \since 12.0.0
3018  *
3019  * \param data After bridge callback data to destroy.
3020  *
3021  * \return Nothing
3022  */
3023 static void after_bridge_cb_destroy(void *data)
3024 {
3025         struct after_bridge_cb_ds *after_bridge = data;
3026
3027         if (after_bridge->failed) {
3028                 after_bridge->failed(AST_AFTER_BRIDGE_CB_REASON_DESTROY, after_bridge->data);
3029                 after_bridge->failed = NULL;
3030         }
3031 }
3032
3033 /*!
3034  * \internal
3035  * \brief Fixup the after bridge callback datastore.
3036  * \since 12.0.0
3037  *
3038  * \param data After bridge callback data to fixup.
3039  * \param old_chan The datastore is moving from this channel.
3040  * \param new_chan The datastore is moving to this channel.
3041  *
3042  * \return Nothing
3043  */
3044 static void after_bridge_cb_fixup(void *data, struct ast_channel *old_chan, struct ast_channel *new_chan)
3045 {
3046         /* There can be only one.  Discard any already on the new channel. */
3047         ast_after_bridge_callback_discard(new_chan, AST_AFTER_BRIDGE_CB_REASON_MASQUERADE);
3048 }
3049
3050 static const struct ast_datastore_info after_bridge_cb_info = {
3051         .type = "after-bridge-cb",
3052         .destroy = after_bridge_cb_destroy,
3053         .chan_fixup = after_bridge_cb_fixup,
3054 };
3055
3056 /*!
3057  * \internal
3058  * \brief Remove channel after the bridge callback and return it.
3059  * \since 12.0.0
3060  *
3061  * \param chan Channel to remove after bridge callback.
3062  *
3063  * \retval datastore on success.
3064  * \retval NULL on error or not found.
3065  */
3066 static struct ast_datastore *after_bridge_cb_remove(struct ast_channel *chan)
3067 {
3068         struct ast_datastore *datastore;
3069
3070         ast_channel_lock(chan);
3071         datastore = ast_channel_datastore_find(chan, &after_bridge_cb_info, NULL);
3072         if (datastore && ast_channel_datastore_remove(chan, datastore)) {
3073                 datastore = NULL;
3074         }
3075         ast_channel_unlock(chan);
3076
3077         return datastore;
3078 }
3079
3080 void ast_after_bridge_callback_discard(struct ast_channel *chan, enum ast_after_bridge_cb_reason reason)
3081 {
3082         struct ast_datastore *datastore;
3083
3084         datastore = after_bridge_cb_remove(chan);
3085         if (datastore) {
3086                 struct after_bridge_cb_ds *after_bridge = datastore->data;
3087
3088                 if (after_bridge && after_bridge->failed) {
3089                         after_bridge->failed(reason, after_bridge->data);
3090                         after_bridge->failed = NULL;
3091                 }
3092                 ast_datastore_free(datastore);
3093         }
3094 }
3095
3096 /*!
3097  * \internal
3098  * \brief Run any after bridge callback if possible.
3099  * \since 12.0.0
3100  *
3101  * \param chan Channel to run after bridge callback.
3102  *
3103  * \return Nothing
3104  */
3105 static void after_bridge_callback_run(struct ast_channel *chan)
3106 {
3107         struct ast_datastore *datastore;
3108         struct after_bridge_cb_ds *after_bridge;
3109
3110         if (ast_check_hangup(chan)) {
3111                 return;
3112         }
3113
3114         /* Get after bridge goto datastore. */
3115         datastore = after_bridge_cb_remove(chan);
3116         if (!datastore) {
3117                 return;
3118         }
3119
3120         after_bridge = datastore->data;
3121         if (after_bridge) {
3122                 after_bridge->failed = NULL;
3123                 after_bridge->callback(chan, after_bridge->data);
3124         }
3125
3126         /* Discard after bridge callback datastore. */
3127         ast_datastore_free(datastore);
3128 }
3129
3130 int ast_after_bridge_callback_set(struct ast_channel *chan, ast_after_bridge_cb callback, ast_after_bridge_cb_failed failed, void *data)
3131 {
3132         struct ast_datastore *datastore;
3133         struct after_bridge_cb_ds *after_bridge;
3134
3135         /* Sanity checks. */
3136         ast_assert(chan != NULL);
3137         if (!chan || !callback) {
3138                 return -1;
3139         }
3140
3141         /* Create a new datastore. */
3142         datastore = ast_datastore_alloc(&after_bridge_cb_info, NULL);
3143         if (!datastore) {
3144                 return -1;
3145         }
3146         after_bridge = ast_calloc(1, sizeof(*after_bridge));
3147         if (!after_bridge) {
3148                 ast_datastore_free(datastore);
3149                 return -1;
3150         }
3151
3152         /* Initialize it. */
3153         after_bridge->callback = callback;
3154         after_bridge->failed = failed;
3155         after_bridge->data = data;
3156         datastore->data = after_bridge;
3157
3158         /* Put it on the channel replacing any existing one. */
3159         ast_channel_lock(chan);
3160         ast_after_bridge_callback_discard(chan, AST_AFTER_BRIDGE_CB_REASON_REPLACED);
3161         ast_channel_datastore_add(chan, datastore);
3162         ast_channel_unlock(chan);
3163
3164         return 0;
3165 }
3166
3167 const char *reason_strings[] = {
3168         [AST_AFTER_BRIDGE_CB_REASON_DESTROY] = "Bridge Destroyed",
3169         [AST_AFTER_BRIDGE_CB_REASON_REPLACED] = "Channel replaced",
3170         [AST_AFTER_BRIDGE_CB_REASON_MASQUERADE] = "Channel masqueraded",
3171         [AST_AFTER_BRIDGE_CB_REASON_DEPART] = "Channel departed",
3172         [AST_AFTER_BRIDGE_CB_REASON_REMOVED] = "Channel removed",
3173 };
3174
3175 const char *ast_after_bridge_cb_reason_string(enum ast_after_bridge_cb_reason reason)
3176 {
3177         if (reason < AST_AFTER_BRIDGE_CB_REASON_DESTROY || reason > AST_AFTER_BRIDGE_CB_REASON_REMOVED) {
3178                 return "Unknown";
3179         }
3180
3181         return reason_strings[reason];
3182 }
3183
3184 struct after_bridge_goto_ds {
3185         /*! Goto string that can be parsed by ast_parseable_goto(). */
3186         const char *parseable_goto;
3187         /*! Specific goto context or default context for parseable_goto. */
3188         const char *context;
3189         /*! Specific goto exten or default exten for parseable_goto. */
3190         const char *exten;
3191         /*! Specific goto priority or default priority for parseable_goto. */
3192         int priority;
3193         /*! TRUE if the peer should run the h exten. */
3194         unsigned int run_h_exten:1;
3195         /*! Specific goto location */
3196         unsigned int specific:1;
3197 };
3198
3199 /*!
3200  * \internal
3201  * \brief Destroy the after bridge goto datastore.
3202  * \since 12.0.0
3203  *
3204  * \param data After bridge goto data to destroy.
3205  *
3206  * \return Nothing
3207  */
3208 static void after_bridge_goto_destroy(void *data)
3209 {
3210         struct after_bridge_goto_ds *after_bridge = data;
3211
3212         ast_free((char *) after_bridge->parseable_goto);
3213         ast_free((char *) after_bridge->context);
3214         ast_free((char *) after_bridge->exten);
3215 }
3216
3217 /*!
3218  * \internal
3219  * \brief Fixup the after bridge goto datastore.
3220  * \since 12.0.0
3221  *
3222  * \param data After bridge goto data to fixup.
3223  * \param old_chan The datastore is moving from this channel.
3224  * \param new_chan The datastore is moving to this channel.
3225  *
3226  * \return Nothing
3227  */
3228 static void after_bridge_goto_fixup(void *data, struct ast_channel *old_chan, struct ast_channel *new_chan)
3229 {
3230         /* There can be only one.  Discard any already on the new channel. */
3231         ast_after_bridge_goto_discard(new_chan);
3232 }
3233
3234 static const struct ast_datastore_info after_bridge_goto_info = {
3235         .type = "after-bridge-goto",
3236         .destroy = after_bridge_goto_destroy,
3237         .chan_fixup = after_bridge_goto_fixup,
3238 };
3239
3240 /*!
3241  * \internal
3242  * \brief Remove channel goto location after the bridge and return it.
3243  * \since 12.0.0
3244  *
3245  * \param chan Channel to remove after bridge goto location.
3246  *
3247  * \retval datastore on success.
3248  * \retval NULL on error or not found.
3249  */
3250 static struct ast_datastore *after_bridge_goto_remove(struct ast_channel *chan)
3251 {
3252         struct ast_datastore *datastore;
3253
3254         ast_channel_lock(chan);
3255         datastore = ast_channel_datastore_find(chan, &after_bridge_goto_info, NULL);
3256         if (datastore && ast_channel_datastore_remove(chan, datastore)) {
3257                 datastore = NULL;
3258         }
3259         ast_channel_unlock(chan);
3260
3261         return datastore;
3262 }
3263
3264 void ast_after_bridge_goto_discard(struct ast_channel *chan)
3265 {
3266         struct ast_datastore *datastore;
3267
3268         datastore = after_bridge_goto_remove(chan);
3269         if (datastore) {
3270                 ast_datastore_free(datastore);
3271         }
3272 }
3273
3274 int ast_after_bridge_goto_setup(struct ast_channel *chan)
3275 {
3276         struct ast_datastore *datastore;
3277         struct after_bridge_goto_ds *after_bridge;
3278         int goto_failed = -1;
3279
3280         /* Determine if we are going to setup a dialplan location and where. */
3281         if (ast_channel_softhangup_internal_flag(chan) & AST_SOFTHANGUP_ASYNCGOTO) {
3282                 /* An async goto has already setup a location. */
3283                 ast_channel_clear_softhangup(chan, AST_SOFTHANGUP_ASYNCGOTO);
3284                 if (!ast_check_hangup(chan)) {
3285                         goto_failed = 0;
3286                 }
3287                 return goto_failed;
3288         }
3289
3290         /* Get after bridge goto datastore. */
3291         datastore = after_bridge_goto_remove(chan);
3292         if (!datastore) {
3293                 return goto_failed;
3294         }
3295
3296         after_bridge = datastore->data;
3297         if (after_bridge->run_h_exten) {
3298                 if (ast_exists_extension(chan, after_bridge->context, "h", 1,
3299                         S_COR(ast_channel_caller(chan)->id.number.valid,
3300                                 ast_channel_caller(chan)->id.number.str, NULL))) {
3301                         ast_debug(1, "Running after bridge goto h exten %s,h,1\n",
3302                                 ast_channel_context(chan));
3303                         ast_pbx_h_exten_run(chan, after_bridge->context);
3304                 }
3305         } else if (!ast_check_hangup(chan)) {
3306                 if (after_bridge->specific) {
3307                         goto_failed = ast_explicit_goto(chan, after_bridge->context,
3308                                 after_bridge->exten, after_bridge->priority);
3309                 } else if (!ast_strlen_zero(after_bridge->parseable_goto)) {
3310                         char *context;
3311                         char *exten;
3312                         int priority;
3313
3314                         /* Option F(x) for Bridge(), Dial(), and Queue() */
3315
3316                         /* Save current dialplan location in case of failure. */
3317                         context = ast_strdupa(ast_channel_context(chan));
3318                         exten = ast_strdupa(ast_channel_exten(chan));
3319                         priority = ast_channel_priority(chan);
3320
3321                         /* Set current dialplan position to default dialplan position */
3322                         ast_explicit_goto(chan, after_bridge->context, after_bridge->exten,
3323                                 after_bridge->priority);
3324
3325                         /* Then perform the goto */
3326                         goto_failed = ast_parseable_goto(chan, after_bridge->parseable_goto);
3327                         if (goto_failed) {
3328                                 /* Restore original dialplan location. */
3329                                 ast_channel_context_set(chan, context);
3330                                 ast_channel_exten_set(chan, exten);
3331                                 ast_channel_priority_set(chan, priority);
3332                         }
3333                 } else {
3334                         /* Option F() for Bridge(), Dial(), and Queue() */
3335                         goto_failed = ast_goto_if_exists(chan, after_bridge->context,
3336                                 after_bridge->exten, after_bridge->priority + 1);
3337                 }
3338                 if (!goto_failed) {
3339                         ast_debug(1, "Setup after bridge goto location to %s,%s,%d.\n",
3340                                 ast_channel_context(chan),
3341                                 ast_channel_exten(chan),
3342                                 ast_channel_priority(chan));
3343                 }
3344         }
3345
3346         /* Discard after bridge goto datastore. */
3347         ast_datastore_free(datastore);
3348
3349         return goto_failed;
3350 }
3351
3352 void ast_after_bridge_goto_run(struct ast_channel *chan)
3353 {
3354         int goto_failed;
3355
3356         goto_failed = ast_after_bridge_goto_setup(chan);
3357         if (goto_failed || ast_pbx_run(chan)) {
3358                 ast_hangup(chan);
3359         }
3360 }
3361
3362 /*!
3363  * \internal
3364  * \brief Set after bridge goto location of channel.
3365  * \since 12.0.0
3366  *
3367  * \param chan Channel to setup after bridge goto location.
3368  * \param run_h_exten TRUE if the h exten should be run.
3369  * \param specific TRUE if the context/exten/priority is exactly specified.
3370  * \param context Context to goto after bridge.
3371  * \param exten Exten to goto after bridge. (Could be NULL if run_h_exten)
3372  * \param priority Priority to goto after bridge.
3373  * \param parseable_goto User specified goto string. (Could be NULL)
3374  *
3375  * \details Add a channel datastore to setup the goto location
3376  * when the channel leaves the bridge and run a PBX from there.
3377  *
3378  * If run_h_exten then execute the h exten found in the given context.
3379  * Else if specific then goto the given context/exten/priority.
3380  * Else if parseable_goto then use the given context/exten/priority
3381  *   as the relative position for the parseable_goto.
3382  * Else goto the given context/exten/priority+1.
3383  *
3384  * \return Nothing
3385  */
3386 static void __after_bridge_set_goto(struct ast_channel *chan, int run_h_exten, int specific, const char *context, const char *exten, int priority, const char *parseable_goto)
3387 {
3388         struct ast_datastore *datastore;
3389         struct after_bridge_goto_ds *after_bridge;
3390
3391         /* Sanity checks. */
3392         ast_assert(chan != NULL);
3393         if (!chan) {
3394                 return;
3395         }
3396         if (run_h_exten) {
3397                 ast_assert(run_h_exten && context);
3398                 if (!context) {
3399                         return;
3400                 }
3401         } else {
3402                 ast_assert(context && exten && 0 < priority);
3403                 if (!context || !exten || priority < 1) {
3404                         return;
3405                 }
3406         }
3407
3408         /* Create a new datastore. */
3409         datastore = ast_datastore_alloc(&after_bridge_goto_info, NULL);
3410         if (!datastore) {
3411                 return;
3412         }
3413         after_bridge = ast_calloc(1, sizeof(*after_bridge));
3414         if (!after_bridge) {
3415                 ast_datastore_free(datastore);
3416                 return;
3417         }
3418
3419         /* Initialize it. */
3420         after_bridge->parseable_goto = ast_strdup(parseable_goto);
3421         after_bridge->context = ast_strdup(context);
3422         after_bridge->exten = ast_strdup(exten);
3423         after_bridge->priority = priority;
3424         after_bridge->run_h_exten = run_h_exten ? 1 : 0;
3425         after_bridge->specific = specific ? 1 : 0;
3426         datastore->data = after_bridge;
3427         if ((parseable_goto && !after_bridge->parseable_goto)
3428                 || (context && !after_bridge->context)
3429                 || (exten && !after_bridge->exten)) {
3430                 ast_datastore_free(datastore);
3431                 return;
3432         }
3433
3434         /* Put it on the channel replacing any existing one. */
3435         ast_channel_lock(chan);
3436         ast_after_bridge_goto_discard(chan);
3437         ast_channel_datastore_add(chan, datastore);
3438         ast_channel_unlock(chan);
3439 }
3440
3441 void ast_after_bridge_set_goto(struct ast_channel *chan, const char *context, const char *exten, int priority)
3442 {
3443         __after_bridge_set_goto(chan, 0, 1, context, exten, priority, NULL);
3444 }
3445
3446 void ast_after_bridge_set_h(struct ast_channel *chan, const char *context)
3447 {
3448         __after_bridge_set_goto(chan, 1, 0, context, NULL, 1, NULL);
3449 }
3450
3451 void ast_after_bridge_set_go_on(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *parseable_goto)
3452 {
3453         char *p_goto;
3454
3455         if (!ast_strlen_zero(parseable_goto)) {
3456                 p_goto = ast_strdupa(parseable_goto);
3457                 ast_replace_subargument_delimiter(p_goto);
3458         } else {
3459                 p_goto = NULL;
3460         }
3461         __after_bridge_set_goto(chan, 0, 0, context, exten, priority, p_goto);
3462 }
3463
3464 void ast_bridge_notify_masquerade(struct ast_channel *chan)
3465 {
3466         struct ast_bridge_channel *bridge_channel;
3467         struct ast_bridge *bridge;
3468
3469         /* Safely get the bridge_channel pointer for the chan. */
3470         ast_channel_lock(chan);
3471         bridge_channel = ast_channel_get_bridge_channel(chan);
3472         ast_channel_unlock(chan);
3473         if (!bridge_channel) {
3474                 /* Not in a bridge */
3475                 return;
3476         }
3477
3478         ast_bridge_channel_lock_bridge(bridge_channel);
3479         bridge = bridge_channel->bridge;
3480         if (bridge_channel == find_bridge_channel(bridge, chan)) {
3481 /* BUGBUG this needs more work.  The channels need to be made compatible again if the formats change. The bridge_channel thread needs to monitor for this case. */
3482                 /* The channel we want to notify is still in a bridge. */
3483                 bridge->v_table->notify_masquerade(bridge, bridge_channel);
3484                 bridge_reconfigured(bridge);
3485         }
3486         ast_bridge_unlock(bridge);
3487         ao2_ref(bridge_channel, -1);
3488 }
3489
3490 /*
3491  * BUGBUG make ast_bridge_join() require features to be allocated just like ast_bridge_impart() and not expect the struct back.
3492  *
3493  * This change is really going to break ConfBridge.  All other
3494  * users are easily changed.  However, it is needed so the
3495  * bridging code can manipulate features on all channels
3496  * consistently no matter how they joined.
3497  *
3498  * Need to update the features parameter doxygen when this
3499  * change is made to be like ast_bridge_impart().
3500  */
3501 enum ast_bridge_channel_state ast_bridge_join(struct ast_bridge *bridge,
3502         struct ast_channel *chan,
3503         struct ast_channel *swap,
3504         struct ast_bridge_features *features,
3505         struct ast_bridge_tech_optimizations *tech_args,
3506         int pass_reference)
3507 {
3508         struct ast_bridge_channel *bridge_channel;
3509         enum ast_bridge_channel_state state;
3510
3511         bridge_channel = bridge_channel_alloc(bridge);
3512         if (pass_reference) {
3513                 ao2_ref(bridge, -1);
3514         }
3515         if (!bridge_channel) {
3516                 state = AST_BRIDGE_CHANNEL_STATE_HANGUP;
3517                 goto join_exit;
3518         }
3519 /* BUGBUG features cannot be NULL when passed in. When it is changed to allocated we can do like ast_bridge_impart() and allocate one. */
3520         ast_assert(features != NULL);
3521         if (!features) {
3522                 ao2_ref(bridge_channel, -1);
3523                 state = AST_BRIDGE_CHANNEL_STATE_HANGUP;
3524                 goto join_exit;
3525         }
3526         if (tech_args) {
3527                 bridge_channel->tech_args = *tech_args;
3528         }
3529
3530         /* Initialize various other elements of the bridge channel structure that we can't do above */
3531         ast_channel_lock(chan);
3532         ast_channel_internal_bridge_channel_set(chan, bridge_channel);
3533         ast_channel_unlock(chan);
3534         bridge_channel->thread = pthread_self();
3535         bridge_channel->chan = chan;
3536         bridge_channel->swap = swap;
3537         bridge_channel->features = features;
3538
3539         bridge_channel_join(bridge_channel);
3540         state = bridge_channel->state;
3541
3542         /* Cleanup all the data in the bridge channel after it leaves the bridge. */
3543         ast_channel_lock(chan);
3544         ast_channel_internal_bridge_channel_set(chan, NULL);
3545         ast_channel_unlock(chan);
3546         bridge_channel->chan = NULL;
3547         bridge_channel->swap = NULL;
3548         bridge_channel->features = NULL;
3549
3550         ao2_ref(bridge_channel, -1);
3551
3552 join_exit:;
3553 /* BUGBUG this is going to cause problems for DTMF atxfer attended bridge between B & C.  Maybe an ast_bridge_join_internal() that does not do the after bridge goto for this case. */
3554         after_bridge_callback_run(chan);
3555         if (!(ast_channel_softhangup_internal_flag(chan) & AST_SOFTHANGUP_ASYNCGOTO)
3556                 && !ast_after_bridge_goto_setup(chan)) {
3557                 /* Claim the after bridge goto is an async goto destination. */
3558                 ast_channel_lock(chan);
3559                 ast_softhangup_nolock(chan, AST_SOFTHANGUP_ASYNCGOTO);
3560                 ast_channel_unlock(chan);
3561         }
3562         return state;
3563 }
3564
3565 /*! \brief Thread responsible for imparted bridged channels to be departed */
3566 static void *bridge_channel_depart_thread(void *data)
3567 {
3568         struct ast_bridge_channel *bridge_channel = data;
3569
3570         if (bridge_channel->callid) {
3571                 ast_callid_threadassoc_add(bridge_channel->callid);
3572         }
3573
3574         bridge_channel_join(bridge_channel);
3575
3576         /* cleanup */
3577         bridge_channel->swap = NULL;
3578         ast_bridge_features_destroy(bridge_channel->features);
3579         bridge_channel->features = NULL;
3580
3581         ast_after_bridge_callback_discard(bridge_channel->chan, AST_AFTER_BRIDGE_CB_REASON_DEPART);
3582         ast_after_bridge_goto_discard(bridge_channel->chan);
3583
3584         return NULL;
3585 }
3586
3587 /*! \brief Thread responsible for independent imparted bridged channels */
3588 static void *bridge_channel_ind_thread(void *data)
3589 {
3590         struct ast_bridge_channel *bridge_channel = data;
3591         struct ast_channel *chan;
3592
3593         if (bridge_channel->callid) {
3594                 ast_callid_threadassoc_add(bridge_channel->callid);
3595         }
3596
3597         bridge_channel_join(bridge_channel);
3598         chan = bridge_channel->chan;
3599
3600         /* cleanup */
3601         ast_channel_lock(chan);
3602         ast_channel_internal_bridge_channel_set(chan, NULL);
3603         ast_channel_unlock(chan);
3604         bridge_channel->chan = NULL;
3605         bridge_channel->swap = NULL;
3606         ast_bridge_features_destroy(bridge_channel->features);
3607         bridge_channel->features = NULL;
3608
3609         ao2_ref(bridge_channel, -1);
3610
3611         after_bridge_callback_run(chan);
3612         ast_after_bridge_goto_run(chan);
3613         return NULL;
3614 }
3615
3616 int ast_bridge_impart(struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap, struct ast_bridge_features *features, int independent)
3617 {
3618         int res;
3619         struct ast_bridge_channel *bridge_channel;
3620
3621         /* Supply an empty features structure if the caller did not. */
3622         if (!features) {
3623                 features = ast_bridge_features_new();
3624                 if (!features) {
3625                         return -1;
3626                 }
3627         }
3628
3629         /* Try to allocate a structure for the bridge channel */
3630         bridge_channel = bridge_channel_alloc(bridge);
3631         if (!bridge_channel) {
3632                 ast_bridge_features_destroy(features);
3633                 return -1;
3634         }
3635
3636         /* Setup various parameters */
3637         ast_channel_lock(chan);
3638         ast_channel_internal_bridge_channel_set(chan, bridge_channel);
3639         ast_channel_unlock(chan);
3640         bridge_channel->chan = chan;
3641         bridge_channel->swap = swap;
3642         bridge_channel->features = features;
3643         bridge_channel->depart_wait = independent ? 0 : 1;
3644         bridge_channel->callid = ast_read_threadstorage_callid();
3645
3646         /* Actually create the thread that will handle the channel */
3647         if (independent) {
3648                 /* Independently imparted channels cannot have a PBX. */
3649                 ast_assert(!ast_channel_pbx(chan));
3650
3651                 res = ast_pthread_create_detached(&bridge_channel->thread, NULL,
3652                         bridge_channel_ind_thread, bridge_channel);
3653         } else {
3654                 /* Imparted channels to be departed should not have a PBX either. */
3655                 ast_assert(!ast_channel_pbx(chan));
3656
3657                 res = ast_pthread_create(&bridge_channel->thread, NULL,
3658                         bridge_channel_depart_thread, bridge_channel);
3659         }
3660
3661         if (res) {
3662                 /* cleanup */
3663                 ast_channel_lock(chan);
3664                 ast_channel_internal_bridge_channel_set(chan, NULL);
3665                 ast_channel_unlock(chan);
3666                 bridge_channel->chan = NULL;
3667                 bridge_channel->swap = NULL;
3668                 ast_bridge_features_destroy(bridge_channel->features);
3669                 bridge_channel->features = NULL;
3670
3671                 ao2_ref(bridge_channel, -1);
3672                 return -1;
3673         }
3674
3675         return 0;
3676 }
3677
3678 int ast_bridge_depart(struct ast_channel *chan)
3679 {
3680         struct ast_bridge_channel *bridge_channel;
3681         int departable;
3682
3683         ast_channel_lock(chan);
3684         bridge_channel = ast_channel_internal_bridge_channel(chan);
3685         departable = bridge_channel && bridge_channel->depart_wait;
3686         ast_channel_unlock(chan);
3687         if (!departable) {
3688                 ast_log(LOG_ERROR, "Channel %s cannot be departed.\n",
3689                         ast_channel_name(chan));
3690                 /*
3691                  * Should never happen.  It likely means that
3692                  * ast_bridge_depart() is called by two threads for the same
3693                  * channel, the channel was never imparted to be departed, or it
3694                  * has already been departed.
3695                  */
3696                 ast_assert(0);
3697                 return -1;
3698         }
3699
3700         /*
3701          * We are claiming the reference held by the depart bridge
3702          * channel thread.
3703          */
3704
3705         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
3706
3707         /* Wait for the depart thread to die */
3708         ast_debug(1, "Waiting for %p(%s) bridge thread to die.\n",
3709                 bridge_channel, ast_channel_name(bridge_channel->chan));
3710         pthread_join(bridge_channel->thread, NULL);
3711
3712         ast_channel_lock(chan);
3713         ast_channel_internal_bridge_channel_set(chan, NULL);
3714         ast_channel_unlock(chan);
3715
3716         /* We can get rid of the bridge_channel after the depart thread has died. */
3717         ao2_ref(bridge_channel, -1);
3718         return 0;
3719 }
3720
3721 int ast_bridge_remove(struct ast_bridge *bridge, struct ast_channel *chan)
3722 {
3723         struct ast_bridge_channel *bridge_channel;
3724
3725         ast_bridge_lock(bridge);
3726
3727         /* Try to find the channel that we want to remove */
3728         if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
3729                 ast_bridge_unlock(bridge);
3730                 return -1;
3731         }
3732
3733         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
3734
3735         ast_bridge_unlock(bridge);
3736
3737         return 0;
3738 }
3739
3740 /*!
3741  * \internal
3742  * \brief Point the bridge_channel to a new bridge.
3743  * \since 12.0.0
3744  *
3745  * \param bridge_channel What is to point to a new bridge.
3746  * \param new_bridge Where the bridge channel should point.
3747  *
3748  * \return Nothing
3749  */
3750 static void bridge_channel_change_bridge(struct ast_bridge_channel *bridge_channel, struct ast_bridge *new_bridge)
3751 {
3752         struct ast_bridge *old_bridge;
3753
3754         ao2_ref(new_bridge, +1);
3755         ast_bridge_channel_lock(bridge_channel);
3756         ast_channel_lock(bridge_channel->chan);
3757         old_bridge = bridge_channel->bridge;
3758         bridge_channel->bridge = new_bridge;
3759         ast_channel_internal_bridge_set(bridge_channel->chan, new_bridge);
3760         ast_channel_unlock(bridge_channel->chan);
3761         ast_bridge_channel_unlock(bridge_channel);
3762         ao2_ref(old_bridge, -1);
3763 }
3764
3765 /*!
3766  * \internal
3767  * \brief Do the merge of two bridges.
3768  * \since 12.0.0
3769  *
3770  * \param dst_bridge Destination bridge of merge.
3771  * \param src_bridge Source bridge of merge.
3772  * \param kick_me Array of channels to kick from the bridges.
3773  * \param num_kick Number of channels in the kick_me array.
3774  *
3775  * \return Nothing
3776  *
3777  * \note The two bridges are assumed already locked.
3778  *
3779  * This moves the channels in src_bridge into the bridge pointed
3780  * to by dst_bridge.
3781  */
3782 static void bridge_merge_do(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, struct ast_bridge_channel **kick_me, unsigned int num_kick)
3783 {
3784         struct ast_bridge_channel *bridge_channel;
3785         unsigned int idx;
3786
3787         ast_debug(1, "Merging bridge %s into bridge %s\n",
3788                 src_bridge->uniqueid, dst_bridge->uniqueid);
3789
3790         ast_bridge_publish_merge(dst_bridge, src_bridge);
3791
3792         /*
3793          * Move channels from src_bridge over to dst_bridge.
3794          *
3795          * We must use AST_LIST_TRAVERSE_SAFE_BEGIN() because
3796          * bridge_channel_pull() alters the list we are traversing.
3797          */
3798         AST_LIST_TRAVERSE_SAFE_BEGIN(&src_bridge->channels, bridge_channel, entry) {
3799                 if (bridge_channel->state != AST_BRIDGE_CHANNEL_STATE_WAIT) {
3800                         /*
3801                          * The channel is already leaving let it leave normally because
3802                          * pulling it may delete hooks that should run for this channel.
3803                          */
3804                         continue;
3805                 }
3806                 if (ast_test_flag(&bridge_channel->features->feature_flags,
3807                         AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE)) {
3808                         continue;
3809                 }
3810
3811                 if (kick_me) {
3812                         for (idx = 0; idx < num_kick; ++idx) {
3813                                 if (bridge_channel == kick_me[idx]) {
3814                                         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
3815                                         break;
3816                                 }
3817                         }
3818                 }
3819                 bridge_channel_pull(bridge_channel);
3820                 if (bridge_channel->state != AST_BRIDGE_CHANNEL_STATE_WAIT) {
3821                         /*
3822                          * The channel died as a result of being pulled or it was
3823                          * kicked.  Leave it pointing to the original bridge.
3824                          */
3825                         continue;
3826                 }
3827
3828                 /* Point to new bridge.*/
3829                 bridge_channel_change_bridge(bridge_channel, dst_bridge);
3830
3831                 if (bridge_channel_push(bridge_channel)) {
3832                         ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
3833                 }
3834         }
3835         AST_LIST_TRAVERSE_SAFE_END;
3836
3837         if (kick_me) {
3838                 /*
3839                  * Now we can kick any channels in the dst_bridge without
3840                  * potentially dissolving the bridge.
3841                  */
3842                 for (idx = 0; idx < num_kick; ++idx) {
3843                         bridge_channel = kick_me[idx];
3844                         ast_bridge_channel_lock(bridge_channel);
3845                         if (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_WAIT) {
3846                                 ast_bridge_change_state_nolock(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
3847                                 bridge_channel_pull(bridge_channel);
3848                         }
3849                         ast_bridge_channel_unlock(bridge_channel);
3850                 }
3851         }
3852
3853         bridge_reconfigured(dst_bridge);
3854         bridge_reconfigured(src_bridge);
3855
3856         ast_debug(1, "Merged bridge %s into bridge %s\n",
3857                 src_bridge->uniqueid, dst_bridge->uniqueid);
3858 }
3859
3860 struct merge_direction {
3861         /*! Destination merge bridge. */
3862         struct ast_bridge *dest;
3863         /*! Source merge bridge. */
3864         struct ast_bridge *src;
3865 };
3866
3867 /*!
3868  * \internal
3869  * \brief Determine which bridge should merge into the other.
3870  * \since 12.0.0
3871  *
3872  * \param bridge1 A bridge for merging
3873  * \param bridge2 A bridge for merging
3874  *
3875  * \note The two bridges are assumed already locked.
3876  *
3877  * \return Which bridge merges into which or NULL bridges if cannot merge.
3878  */
3879 static struct merge_direction bridge_merge_determine_direction(struct ast_bridge *bridge1, struct ast_bridge *bridge2)
3880 {
3881         struct merge_direction merge = { NULL, NULL };
3882         int bridge1_priority;
3883         int bridge2_priority;
3884
3885         if (!ast_test_flag(&bridge1->feature_flags,
3886                         AST_BRIDGE_FLAG_MERGE_INHIBIT_TO | AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)
3887                 && !ast_test_flag(&bridge2->feature_flags,
3888                         AST_BRIDGE_FLAG_MERGE_INHIBIT_TO | AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
3889                 /*
3890                  * Can merge either way.  Merge to the higher priority merge
3891                  * bridge.  Otherwise merge to the larger bridge.
3892                  */
3893                 bridge1_priority = bridge1->v_table->get_merge_priority(bridge1);
3894                 bridge2_priority = bridge2->v_table->get_merge_priority(bridge2);
3895                 if (bridge2_priority < bridge1_priority) {
3896                         merge.dest = bridge1;
3897                         merge.src = bridge2;
3898                 } else if (bridge1_priority < bridge2_priority) {
3899                         merge.dest = bridge2;
3900                         merge.src = bridge1;
3901                 } else {
3902                         /* Merge to the larger bridge. */
3903                         if (bridge2->num_channels <= bridge1->num_channels) {
3904                                 merge.dest = bridge1;
3905                                 merge.src = bridge2;
3906                         } else {
3907                                 merge.dest = bridge2;
3908                                 merge.src = bridge1;
3909                         }
3910                 }
3911         } else if (!ast_test_flag(&bridge1->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO)
3912                 && !ast_test_flag(&bridge2->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
3913                 /* Can merge only one way. */
3914                 merge.dest = bridge1;
3915                 merge.src = bridge2;
3916         } else if (!ast_test_flag(&bridge2->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO)
3917                 && !ast_test_flag(&bridge1->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
3918                 /* Can merge only one way. */
3919                 merge.dest = bridge2;
3920                 merge.src = bridge1;
3921         }
3922
3923         return merge;
3924 }
3925
3926 /*!
3927  * \internal
3928  * \brief Merge two bridges together
3929  * \since 12.0.0
3930  *
3931  * \param dst_bridge Destination bridge of merge.
3932  * \param src_bridge Source bridge of merge.
3933  * \param merge_best_direction TRUE if don't care about which bridge merges into the other.
3934  * \param kick_me Array of channels to kick from the bridges.
3935  * \param num_kick Number of channels in the kick_me array.
3936  *
3937  * \note The dst_bridge and src_bridge are assumed already locked.
3938  *
3939  * \retval 0 on success
3940  * \retval -1 on failure
3941  */
3942 static int bridge_merge_locked(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, int merge_best_direction, struct ast_channel **kick_me, unsigned int num_kick)
3943 {
3944         struct merge_direction merge;
3945         struct ast_bridge_channel **kick_them = NULL;
3946
3947         /* Sanity check. */
3948         ast_assert(dst_bridge && src_bridge && dst_bridge != src_bridge && (!num_kick || kick_me));
3949
3950         if (dst_bridge->dissolved || src_bridge->dissolved) {
3951                 ast_debug(1, "Can't merge bridges %s and %s, at least one bridge is dissolved.\n",
3952                         src_bridge->uniqueid, dst_bridge->uniqueid);