Bridge API: Set a cause code on a channel when it is ejected from a bridge.
[asterisk/asterisk.git] / main / bridge.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 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 "asterisk/logger.h"
35 #include "asterisk/channel.h"
36 #include "asterisk/options.h"
37 #include "asterisk/utils.h"
38 #include "asterisk/lock.h"
39 #include "asterisk/linkedlists.h"
40 #include "asterisk/bridge.h"
41 #include "asterisk/bridge_internal.h"
42 #include "asterisk/bridge_channel_internal.h"
43 #include "asterisk/bridge_features.h"
44 #include "asterisk/bridge_basic.h"
45 #include "asterisk/bridge_technology.h"
46 #include "asterisk/bridge_channel.h"
47 #include "asterisk/bridge_after.h"
48 #include "asterisk/stasis_bridges.h"
49 #include "asterisk/stasis_channels.h"
50 #include "asterisk/stasis_cache_pattern.h"
51 #include "asterisk/app.h"
52 #include "asterisk/file.h"
53 #include "asterisk/module.h"
54 #include "asterisk/astobj2.h"
55 #include "asterisk/pbx.h"
56 #include "asterisk/test.h"
57 #include "asterisk/_private.h"
58 #include "asterisk/heap.h"
59 #include "asterisk/say.h"
60 #include "asterisk/timing.h"
61 #include "asterisk/stringfields.h"
62 #include "asterisk/musiconhold.h"
63 #include "asterisk/features.h"
64 #include "asterisk/cli.h"
65 #include "asterisk/parking.h"
66 #include "asterisk/core_local.h"
67 #include "asterisk/core_unreal.h"
68 #include "asterisk/causes.h"
69
70 /*! All bridges container. */
71 static struct ao2_container *bridges;
72
73 static AST_RWLIST_HEAD_STATIC(bridge_technologies, ast_bridge_technology);
74
75 static unsigned int optimization_id;
76
77 /* Initial starting point for the bridge array of channels */
78 #define BRIDGE_ARRAY_START 128
79
80 /* Grow rate of bridge array of channels */
81 #define BRIDGE_ARRAY_GROW 32
82
83 static void cleanup_video_mode(struct ast_bridge *bridge);
84 static int bridge_make_compatible(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel);
85
86 /*! Default DTMF keys for built in features */
87 static char builtin_features_dtmf[AST_BRIDGE_BUILTIN_END][MAXIMUM_DTMF_FEATURE_STRING];
88
89 /*! Function handlers for the built in features */
90 static ast_bridge_hook_callback builtin_features_handlers[AST_BRIDGE_BUILTIN_END];
91
92 /*! Function handlers for built in interval features */
93 static ast_bridge_builtin_set_limits_fn builtin_interval_handlers[AST_BRIDGE_BUILTIN_INTERVAL_END];
94
95 /*! Bridge manager service request */
96 struct bridge_manager_request {
97         /*! List of bridge service requests. */
98         AST_LIST_ENTRY(bridge_manager_request) node;
99         /*! Refed bridge requesting service. */
100         struct ast_bridge *bridge;
101 };
102
103 struct bridge_manager_controller {
104         /*! Condition, used to wake up the bridge manager thread. */
105         ast_cond_t cond;
106         /*! Queue of bridge service requests. */
107         AST_LIST_HEAD_NOLOCK(, bridge_manager_request) service_requests;
108         /*! Manager thread */
109         pthread_t thread;
110         /*! TRUE if the manager needs to stop. */
111         unsigned int stop:1;
112 };
113
114 /*! Bridge manager controller. */
115 static struct bridge_manager_controller *bridge_manager;
116
117 /*!
118  * \internal
119  * \brief Request service for a bridge from the bridge manager.
120  * \since 12.0.0
121  *
122  * \param bridge Requesting service.
123  *
124  * \return Nothing
125  */
126 static void bridge_manager_service_req(struct ast_bridge *bridge)
127 {
128         struct bridge_manager_request *request;
129
130         ao2_lock(bridge_manager);
131         if (bridge_manager->stop) {
132                 ao2_unlock(bridge_manager);
133                 return;
134         }
135
136         /* Create the service request. */
137         request = ast_calloc(1, sizeof(*request));
138         if (!request) {
139                 /* Well. This isn't good. */
140                 ao2_unlock(bridge_manager);
141                 return;
142         }
143         ao2_ref(bridge, +1);
144         request->bridge = bridge;
145
146         /* Put request into the queue and wake the bridge manager. */
147         AST_LIST_INSERT_TAIL(&bridge_manager->service_requests, request, node);
148         ast_cond_signal(&bridge_manager->cond);
149         ao2_unlock(bridge_manager);
150 }
151
152 int __ast_bridge_technology_register(struct ast_bridge_technology *technology, struct ast_module *module)
153 {
154         struct ast_bridge_technology *current;
155
156         /* Perform a sanity check to make sure the bridge technology conforms to our needed requirements */
157         if (ast_strlen_zero(technology->name)
158                 || !technology->capabilities
159                 || !technology->write) {
160                 ast_log(LOG_WARNING, "Bridge technology %s failed registration sanity check.\n",
161                         technology->name);
162                 return -1;
163         }
164
165         AST_RWLIST_WRLOCK(&bridge_technologies);
166
167         /* Look for duplicate bridge technology already using this name, or already registered */
168         AST_RWLIST_TRAVERSE(&bridge_technologies, current, entry) {
169                 if ((!strcasecmp(current->name, technology->name)) || (current == technology)) {
170                         ast_log(LOG_WARNING, "A bridge technology of %s already claims to exist in our world.\n",
171                                 technology->name);
172                         AST_RWLIST_UNLOCK(&bridge_technologies);
173                         return -1;
174                 }
175         }
176
177         /* Copy module pointer so reference counting can keep the module from unloading */
178         technology->mod = module;
179
180         /* Insert our new bridge technology into the list and print out a pretty message */
181         AST_RWLIST_INSERT_TAIL(&bridge_technologies, technology, entry);
182
183         AST_RWLIST_UNLOCK(&bridge_technologies);
184
185         ast_verb(2, "Registered bridge technology %s\n", technology->name);
186
187         return 0;
188 }
189
190 int ast_bridge_technology_unregister(struct ast_bridge_technology *technology)
191 {
192         struct ast_bridge_technology *current;
193
194         AST_RWLIST_WRLOCK(&bridge_technologies);
195
196         /* Ensure the bridge technology is registered before removing it */
197         AST_RWLIST_TRAVERSE_SAFE_BEGIN(&bridge_technologies, current, entry) {
198                 if (current == technology) {
199                         AST_RWLIST_REMOVE_CURRENT(entry);
200                         ast_verb(2, "Unregistered bridge technology %s\n", technology->name);
201                         break;
202                 }
203         }
204         AST_RWLIST_TRAVERSE_SAFE_END;
205
206         AST_RWLIST_UNLOCK(&bridge_technologies);
207
208         return current ? 0 : -1;
209 }
210
211 /*!
212  * \internal
213  * \brief Put an action onto the specified bridge. Don't dup the action frame.
214  * \since 12.0.0
215  *
216  * \param bridge What to queue the action on.
217  * \param action What to do.
218  *
219  * \return Nothing
220  */
221 static void bridge_queue_action_nodup(struct ast_bridge *bridge, struct ast_frame *action)
222 {
223         ast_debug(1, "Bridge %s: queueing action type:%d sub:%d\n",
224                 bridge->uniqueid, action->frametype, action->subclass.integer);
225
226         ast_bridge_lock(bridge);
227         AST_LIST_INSERT_TAIL(&bridge->action_queue, action, frame_list);
228         ast_bridge_unlock(bridge);
229         bridge_manager_service_req(bridge);
230 }
231
232 int ast_bridge_queue_action(struct ast_bridge *bridge, struct ast_frame *action)
233 {
234         struct ast_frame *dup;
235
236         dup = ast_frdup(action);
237         if (!dup) {
238                 return -1;
239         }
240         bridge_queue_action_nodup(bridge, dup);
241         return 0;
242 }
243
244 void bridge_dissolve(struct ast_bridge *bridge, int cause)
245 {
246         struct ast_bridge_channel *bridge_channel;
247         struct ast_frame action = {
248                 .frametype = AST_FRAME_BRIDGE_ACTION,
249                 .subclass.integer = BRIDGE_CHANNEL_ACTION_DEFERRED_DISSOLVING,
250         };
251
252         if (bridge->dissolved) {
253                 return;
254         }
255         bridge->dissolved = 1;
256
257         if (cause <= 0) {
258                 cause = AST_CAUSE_NORMAL_CLEARING;
259         }
260         bridge->cause = cause;
261
262         ast_debug(1, "Bridge %s: dissolving bridge with cause %d(%s)\n",
263                 bridge->uniqueid, cause, ast_cause2str(cause));
264
265         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
266                 ast_bridge_channel_leave_bridge(bridge_channel,
267                         BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, cause);
268         }
269
270         /* Must defer dissolving bridge because it is already locked. */
271         ast_bridge_queue_action(bridge, &action);
272 }
273
274 /*!
275  * \internal
276  * \brief Check if a bridge should dissolve because of a stolen channel and do it.
277  * \since 12.0.0
278  *
279  * \param bridge Bridge to check.
280  * \param bridge_channel Stolen channel causing the check.  It is not in the bridge to check and may be in another bridge.
281  *
282  * \note On entry, bridge and bridge_channel->bridge are already locked.
283  *
284  * \return Nothing
285  */
286 static void bridge_dissolve_check_stolen(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
287 {
288         if (bridge->dissolved) {
289                 return;
290         }
291
292         if (bridge_channel->features->usable
293                 && ast_test_flag(&bridge_channel->features->feature_flags,
294                         AST_BRIDGE_CHANNEL_FLAG_DISSOLVE_HANGUP)) {
295                 /* The stolen channel controlled the bridge it was stolen from. */
296                 bridge_dissolve(bridge, 0);
297                 return;
298         }
299         if (bridge->num_channels < 2
300                 && ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_DISSOLVE_HANGUP)) {
301                 /*
302                  * The stolen channel has not left enough channels to keep the
303                  * bridge alive.  Assume the stolen channel hung up.
304                  */
305                 bridge_dissolve(bridge, 0);
306                 return;
307         }
308 }
309
310 /*!
311  * \internal
312  * \brief Update connected line information after a bridge has been reconfigured.
313  *
314  * \param bridge The bridge itself.
315  *
316  * \return Nothing
317  */
318 static void bridge_reconfigured_connected_line_update(struct ast_bridge *bridge)
319 {
320         struct ast_party_connected_line connected;
321         struct ast_bridge_channel *bridge_channel = AST_LIST_FIRST(&bridge->channels), *peer;
322         unsigned char data[1024];
323         size_t datalen;
324
325         if (!bridge_channel ||
326                 !(bridge->technology->capabilities & (AST_BRIDGE_CAPABILITY_1TO1MIX | AST_BRIDGE_CAPABILITY_NATIVE)) ||
327                 !(peer = ast_bridge_channel_peer(bridge_channel)) ||
328                 ast_test_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_ZOMBIE) ||
329                 ast_test_flag(ast_channel_flags(peer->chan), AST_FLAG_ZOMBIE) ||
330                 ast_check_hangup_locked(bridge_channel->chan) ||
331                 ast_check_hangup_locked(peer->chan)) {
332                 return;
333         }
334
335         ast_party_connected_line_init(&connected);
336
337         ast_channel_lock(bridge_channel->chan);
338         ast_connected_line_copy_from_caller(&connected, ast_channel_caller(bridge_channel->chan));
339         ast_channel_unlock(bridge_channel->chan);
340
341         if ((datalen = ast_connected_line_build_data(data, sizeof(data), &connected, NULL)) != (size_t) -1) {
342                 ast_bridge_channel_queue_control_data(peer, AST_CONTROL_CONNECTED_LINE, data, datalen);
343         }
344
345         ast_channel_lock(peer->chan);
346         ast_connected_line_copy_from_caller(&connected, ast_channel_caller(peer->chan));
347         ast_channel_unlock(peer->chan);
348
349         if ((datalen = ast_connected_line_build_data(data, sizeof(data), &connected, NULL)) != (size_t) -1) {
350                 ast_bridge_channel_queue_control_data(bridge_channel, AST_CONTROL_CONNECTED_LINE, data, datalen);
351         }
352
353         ast_party_connected_line_free(&connected);
354 }
355
356 /*!
357  * \internal
358  * \brief Complete joining a channel to the bridge.
359  * \since 12.0.0
360  *
361  * \param bridge What to operate upon.
362  * \param bridge_channel What is joining the bridge technology.
363  *
364  * \note On entry, bridge is already locked.
365  *
366  * \return Nothing
367  */
368 static void bridge_channel_complete_join(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
369 {
370         /* Make the channel compatible with the bridge */
371         bridge_make_compatible(bridge, bridge_channel);
372
373         /* Tell the bridge technology we are joining so they set us up */
374         ast_debug(1, "Bridge %s: %p(%s) is joining %s technology\n",
375                 bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
376                 bridge->technology->name);
377         if (bridge->technology->join
378                 && bridge->technology->join(bridge, bridge_channel)) {
379                 ast_debug(1, "Bridge %s: %p(%s) failed to join %s technology\n",
380                         bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
381                         bridge->technology->name);
382                 bridge_channel->just_joined = 1;
383                 return;
384         }
385
386         bridge_channel->just_joined = 0;
387 }
388
389 /*!
390  * \internal
391  * \brief Complete joining new channels to the bridge.
392  * \since 12.0.0
393  *
394  * \param bridge Check for new channels on this bridge.
395  *
396  * \note On entry, bridge is already locked.
397  *
398  * \return Nothing
399  */
400 static void bridge_complete_join(struct ast_bridge *bridge)
401 {
402         struct ast_bridge_channel *bridge_channel;
403
404         if (bridge->dissolved) {
405                 /*
406                  * No sense in completing the join on channels for a dissolved
407                  * bridge.  They are just going to be removed soon anyway.
408                  * However, we do have reason to abort here because the bridge
409                  * technology may not be able to handle the number of channels
410                  * still in the bridge.
411                  */
412                 return;
413         }
414
415         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
416                 if (!bridge_channel->just_joined) {
417                         continue;
418                 }
419                 bridge_channel_complete_join(bridge, bridge_channel);
420         }
421 }
422
423 /*! \brief Helper function used to find the "best" bridge technology given specified capabilities */
424 static struct ast_bridge_technology *find_best_technology(uint32_t capabilities, struct ast_bridge *bridge)
425 {
426         struct ast_bridge_technology *current;
427         struct ast_bridge_technology *best = NULL;
428
429         AST_RWLIST_RDLOCK(&bridge_technologies);
430         AST_RWLIST_TRAVERSE(&bridge_technologies, current, entry) {
431                 if (current->suspended) {
432                         ast_debug(1, "Bridge technology %s is suspended. Skipping.\n",
433                                 current->name);
434                         continue;
435                 }
436                 if (!(current->capabilities & capabilities)) {
437                         ast_debug(1, "Bridge technology %s does not have any capabilities we want.\n",
438                                 current->name);
439                         continue;
440                 }
441                 if (best && current->preference <= best->preference) {
442                         ast_debug(1, "Bridge technology %s has less preference than %s (%d <= %d). Skipping.\n",
443                                 current->name, best->name, current->preference, best->preference);
444                         continue;
445                 }
446                 if (current->compatible && !current->compatible(bridge)) {
447                         ast_debug(1, "Bridge technology %s is not compatible with properties of existing bridge.\n",
448                                 current->name);
449                         continue;
450                 }
451                 best = current;
452         }
453
454         if (best) {
455                 /* Increment it's module reference count if present so it does not get unloaded while in use */
456                 ast_module_ref(best->mod);
457                 ast_debug(1, "Chose bridge technology %s\n", best->name);
458         }
459
460         AST_RWLIST_UNLOCK(&bridge_technologies);
461
462         return best;
463 }
464
465 struct tech_deferred_destroy {
466         struct ast_bridge_technology *tech;
467         void *tech_pvt;
468 };
469
470 /*!
471  * \internal
472  * \brief Deferred destruction of bridge tech private structure.
473  * \since 12.0.0
474  *
475  * \param bridge What to execute the action on.
476  * \param action Deferred bridge tech destruction.
477  *
478  * \note On entry, bridge must not be locked.
479  *
480  * \return Nothing
481  */
482 static void bridge_tech_deferred_destroy(struct ast_bridge *bridge, struct ast_frame *action)
483 {
484         struct tech_deferred_destroy *deferred = action->data.ptr;
485         struct ast_bridge dummy_bridge = {
486                 .technology = deferred->tech,
487                 .tech_pvt = deferred->tech_pvt,
488                 };
489
490         ast_copy_string(dummy_bridge.uniqueid, bridge->uniqueid, sizeof(dummy_bridge.uniqueid));
491         ast_debug(1, "Bridge %s: calling %s technology destructor (deferred, dummy)\n",
492                 dummy_bridge.uniqueid, dummy_bridge.technology->name);
493         dummy_bridge.technology->destroy(&dummy_bridge);
494         ast_module_unref(dummy_bridge.technology->mod);
495 }
496
497 /*!
498  * \internal
499  * \brief Handle bridge action frame.
500  * \since 12.0.0
501  *
502  * \param bridge What to execute the action on.
503  * \param action What to do.
504  *
505  * \note On entry, bridge is already locked.
506  * \note Can be called by the bridge destructor.
507  *
508  * \return Nothing
509  */
510 static void bridge_action_bridge(struct ast_bridge *bridge, struct ast_frame *action)
511 {
512 #if 0   /* In case we need to know when the destructor is calling us. */
513         int in_destructor = !ao2_ref(bridge, 0);
514 #endif
515
516         switch (action->subclass.integer) {
517         case BRIDGE_CHANNEL_ACTION_DEFERRED_TECH_DESTROY:
518                 ast_bridge_unlock(bridge);
519                 bridge_tech_deferred_destroy(bridge, action);
520                 ast_bridge_lock(bridge);
521                 break;
522         case BRIDGE_CHANNEL_ACTION_DEFERRED_DISSOLVING:
523                 ast_bridge_unlock(bridge);
524                 bridge->v_table->dissolving(bridge);
525                 ast_bridge_lock(bridge);
526                 break;
527         default:
528                 /* Unexpected deferred action type.  Should never happen. */
529                 ast_assert(0);
530                 break;
531         }
532 }
533
534 /*!
535  * \internal
536  * \brief Do any pending bridge actions.
537  * \since 12.0.0
538  *
539  * \param bridge What to do actions on.
540  *
541  * \note On entry, bridge is already locked.
542  * \note Can be called by the bridge destructor.
543  *
544  * \return Nothing
545  */
546 static void bridge_handle_actions(struct ast_bridge *bridge)
547 {
548         struct ast_frame *action;
549
550         while ((action = AST_LIST_REMOVE_HEAD(&bridge->action_queue, frame_list))) {
551                 switch (action->frametype) {
552                 case AST_FRAME_BRIDGE_ACTION:
553                         bridge_action_bridge(bridge, action);
554                         break;
555                 default:
556                         /* Unexpected deferred frame type.  Should never happen. */
557                         ast_assert(0);
558                         break;
559                 }
560                 ast_frfree(action);
561         }
562 }
563
564 static struct stasis_message *create_bridge_snapshot_message(struct ast_bridge *bridge)
565 {
566         RAII_VAR(struct ast_bridge_snapshot *, snapshot, NULL, ao2_cleanup);
567
568         snapshot = ast_bridge_snapshot_create(bridge);
569         if (!snapshot) {
570                 return NULL;
571         }
572
573         return stasis_message_create(ast_bridge_snapshot_type(), snapshot);
574 }
575
576 static void destroy_bridge(void *obj)
577 {
578         struct ast_bridge *bridge = obj;
579
580         ast_debug(1, "Bridge %s: actually destroying %s bridge, nobody wants it anymore\n",
581                 bridge->uniqueid, bridge->v_table->name);
582
583         if (bridge->construction_completed) {
584                 RAII_VAR(struct stasis_message *, clear_msg, NULL, ao2_cleanup);
585
586                 clear_msg = create_bridge_snapshot_message(bridge);
587                 if (clear_msg) {
588                         RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
589
590                         msg = stasis_cache_clear_create(clear_msg);
591                         if (msg) {
592                                 stasis_publish(ast_bridge_topic(bridge), msg);
593                         }
594                 }
595         }
596
597         /* Do any pending actions in the context of destruction. */
598         ast_bridge_lock(bridge);
599         bridge_handle_actions(bridge);
600         ast_bridge_unlock(bridge);
601
602         /* There should not be any channels left in the bridge. */
603         ast_assert(AST_LIST_EMPTY(&bridge->channels));
604
605         ast_debug(1, "Bridge %s: calling %s bridge destructor\n",
606                 bridge->uniqueid, bridge->v_table->name);
607         bridge->v_table->destroy(bridge);
608
609         /* Pass off the bridge to the technology to destroy if needed */
610         if (bridge->technology) {
611                 ast_debug(1, "Bridge %s: calling %s technology stop\n",
612                         bridge->uniqueid, bridge->technology->name);
613                 if (bridge->technology->stop) {
614                         ast_bridge_lock(bridge);
615                         bridge->technology->stop(bridge);
616                         ast_bridge_unlock(bridge);
617                 }
618                 ast_debug(1, "Bridge %s: calling %s technology destructor\n",
619                         bridge->uniqueid, bridge->technology->name);
620                 if (bridge->technology->destroy) {
621                         bridge->technology->destroy(bridge);
622                 }
623                 ast_module_unref(bridge->technology->mod);
624                 bridge->technology = NULL;
625         }
626
627         if (bridge->callid) {
628                 bridge->callid = ast_callid_unref(bridge->callid);
629         }
630
631         cleanup_video_mode(bridge);
632
633         stasis_cp_single_unsubscribe(bridge->topics);
634 }
635
636 struct ast_bridge *bridge_register(struct ast_bridge *bridge)
637 {
638         if (bridge) {
639                 bridge->construction_completed = 1;
640                 ast_bridge_publish_state(bridge);
641                 if (!ao2_link(bridges, bridge)) {
642                         ast_bridge_destroy(bridge, 0);
643                         bridge = NULL;
644                 }
645         }
646         return bridge;
647 }
648
649 struct ast_bridge *bridge_alloc(size_t size, const struct ast_bridge_methods *v_table)
650 {
651         struct ast_bridge *bridge;
652
653         /* Check v_table that all methods are present. */
654         if (!v_table
655                 || !v_table->name
656                 || !v_table->destroy
657                 || !v_table->dissolving
658                 || !v_table->push
659                 || !v_table->pull
660                 || !v_table->notify_masquerade
661                 || !v_table->get_merge_priority) {
662                 ast_log(LOG_ERROR, "Virtual method table for bridge class %s not complete.\n",
663                         v_table && v_table->name ? v_table->name : "<unknown>");
664                 ast_assert(0);
665                 return NULL;
666         }
667
668         bridge = ao2_alloc(size, destroy_bridge);
669         if (bridge) {
670                 bridge->v_table = v_table;
671         }
672         return bridge;
673 }
674
675 struct ast_bridge *bridge_base_init(struct ast_bridge *self, uint32_t capabilities, unsigned int flags)
676 {
677         if (!self) {
678                 return NULL;
679         }
680
681         ast_uuid_generate_str(self->uniqueid, sizeof(self->uniqueid));
682         ast_set_flag(&self->feature_flags, flags);
683         self->allowed_capabilities = capabilities;
684
685         if (bridge_topics_init(self) != 0) {
686                 ast_log(LOG_WARNING, "Bridge %s: Could not initialize topics\n",
687                         self->uniqueid);
688                 ao2_ref(self, -1);
689                 return NULL;
690         }
691
692         /* Use our helper function to find the "best" bridge technology. */
693         self->technology = find_best_technology(capabilities, self);
694         if (!self->technology) {
695                 ast_log(LOG_WARNING, "Bridge %s: Could not create class %s.  No technology to support it.\n",
696                         self->uniqueid, self->v_table->name);
697                 ao2_ref(self, -1);
698                 return NULL;
699         }
700
701         /* Pass off the bridge to the technology to manipulate if needed */
702         ast_debug(1, "Bridge %s: calling %s technology constructor\n",
703                 self->uniqueid, self->technology->name);
704         if (self->technology->create && self->technology->create(self)) {
705                 ast_log(LOG_WARNING, "Bridge %s: failed to setup bridge technology %s\n",
706                         self->uniqueid, self->technology->name);
707                 ao2_ref(self, -1);
708                 return NULL;
709         }
710         ast_debug(1, "Bridge %s: calling %s technology start\n",
711                 self->uniqueid, self->technology->name);
712         if (self->technology->start && self->technology->start(self)) {
713                 ast_log(LOG_WARNING, "Bridge %s: failed to start bridge technology %s\n",
714                         self->uniqueid, self->technology->name);
715                 ao2_ref(self, -1);
716                 return NULL;
717         }
718
719         if (!ast_bridge_topic(self)) {
720                 ao2_ref(self, -1);
721                 return NULL;
722         }
723
724         return self;
725 }
726
727 /*!
728  * \internal
729  * \brief ast_bridge base class destructor.
730  * \since 12.0.0
731  *
732  * \param self Bridge to operate upon.
733  *
734  * \note Stub because of nothing to do.
735  *
736  * \return Nothing
737  */
738 static void bridge_base_destroy(struct ast_bridge *self)
739 {
740 }
741
742 /*!
743  * \internal
744  * \brief The bridge is being dissolved.
745  * \since 12.0.0
746  *
747  * \param self Bridge to operate upon.
748  *
749  * \return Nothing
750  */
751 static void bridge_base_dissolving(struct ast_bridge *self)
752 {
753         ao2_unlink(bridges, self);
754 }
755
756 /*!
757  * \internal
758  * \brief ast_bridge base push method.
759  * \since 12.0.0
760  *
761  * \param self Bridge to operate upon.
762  * \param bridge_channel Bridge channel to push.
763  * \param swap Bridge channel to swap places with if not NULL.
764  *
765  * \note On entry, self is already locked.
766  * \note Stub because of nothing to do.
767  *
768  * \retval 0 on success
769  * \retval -1 on failure
770  */
771 static int bridge_base_push(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct ast_bridge_channel *swap)
772 {
773         return 0;
774 }
775
776 /*!
777  * \internal
778  * \brief ast_bridge base pull method.
779  * \since 12.0.0
780  *
781  * \param self Bridge to operate upon.
782  * \param bridge_channel Bridge channel to pull.
783  *
784  * \note On entry, self is already locked.
785  *
786  * \return Nothing
787  */
788 static void bridge_base_pull(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel)
789 {
790         ast_bridge_features_remove(bridge_channel->features, AST_BRIDGE_HOOK_REMOVE_ON_PULL);
791 }
792
793 /*!
794  * \internal
795  * \brief ast_bridge base notify_masquerade method.
796  * \since 12.0.0
797  *
798  * \param self Bridge to operate upon.
799  * \param bridge_channel Bridge channel that was masqueraded.
800  *
801  * \note On entry, self is already locked.
802  *
803  * \return Nothing
804  */
805 static void bridge_base_notify_masquerade(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel)
806 {
807         self->reconfigured = 1;
808 }
809
810 /*!
811  * \internal
812  * \brief Get the merge priority of this bridge.
813  * \since 12.0.0
814  *
815  * \param self Bridge to operate upon.
816  *
817  * \note On entry, self is already locked.
818  *
819  * \return Merge priority
820  */
821 static int bridge_base_get_merge_priority(struct ast_bridge *self)
822 {
823         return 0;
824 }
825
826 struct ast_bridge_methods ast_bridge_base_v_table = {
827         .name = "base",
828         .destroy = bridge_base_destroy,
829         .dissolving = bridge_base_dissolving,
830         .push = bridge_base_push,
831         .pull = bridge_base_pull,
832         .notify_masquerade = bridge_base_notify_masquerade,
833         .get_merge_priority = bridge_base_get_merge_priority,
834 };
835
836 struct ast_bridge *ast_bridge_base_new(uint32_t capabilities, unsigned int flags)
837 {
838         void *bridge;
839
840         bridge = bridge_alloc(sizeof(struct ast_bridge), &ast_bridge_base_v_table);
841         bridge = bridge_base_init(bridge, capabilities, flags);
842         bridge = bridge_register(bridge);
843         return bridge;
844 }
845
846 int ast_bridge_destroy(struct ast_bridge *bridge, int cause)
847 {
848         ast_debug(1, "Bridge %s: telling all channels to leave the party\n", bridge->uniqueid);
849         ast_bridge_lock(bridge);
850         bridge_dissolve(bridge, cause);
851         ast_bridge_unlock(bridge);
852
853         ao2_ref(bridge, -1);
854
855         return 0;
856 }
857
858 static int bridge_make_compatible(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
859 {
860         struct ast_format read_format;
861         struct ast_format write_format;
862         struct ast_format best_format;
863         char codec_buf[512];
864
865         ast_format_copy(&read_format, ast_channel_readformat(bridge_channel->chan));
866         ast_format_copy(&write_format, ast_channel_writeformat(bridge_channel->chan));
867
868         /* Are the formats currently in use something this bridge can handle? */
869         if (!ast_format_cap_iscompatible(bridge->technology->format_capabilities, ast_channel_readformat(bridge_channel->chan))) {
870                 ast_best_codec(bridge->technology->format_capabilities, &best_format);
871
872                 /* Read format is a no go... */
873                 ast_debug(1, "Bridge technology %s wants to read any of formats %s but channel has %s\n",
874                         bridge->technology->name,
875                         ast_getformatname_multiple(codec_buf, sizeof(codec_buf), bridge->technology->format_capabilities),
876                         ast_getformatname(&read_format));
877
878                 /* Switch read format to the best one chosen */
879                 if (ast_set_read_format(bridge_channel->chan, &best_format)) {
880                         ast_log(LOG_WARNING, "Failed to set channel %s to read format %s\n",
881                                 ast_channel_name(bridge_channel->chan), ast_getformatname(&best_format));
882                         return -1;
883                 }
884                 ast_debug(1, "Bridge %s put channel %s into read format %s\n",
885                         bridge->uniqueid, ast_channel_name(bridge_channel->chan),
886                         ast_getformatname(&best_format));
887         } else {
888                 ast_debug(1, "Bridge %s is happy that channel %s already has read format %s\n",
889                         bridge->uniqueid, ast_channel_name(bridge_channel->chan),
890                         ast_getformatname(&read_format));
891         }
892
893         if (!ast_format_cap_iscompatible(bridge->technology->format_capabilities, &write_format)) {
894                 ast_best_codec(bridge->technology->format_capabilities, &best_format);
895
896                 /* Write format is a no go... */
897                 ast_debug(1, "Bridge technology %s wants to write any of formats %s but channel has %s\n",
898                         bridge->technology->name,
899                         ast_getformatname_multiple(codec_buf, sizeof(codec_buf), bridge->technology->format_capabilities),
900                         ast_getformatname(&write_format));
901
902                 /* Switch write format to the best one chosen */
903                 if (ast_set_write_format(bridge_channel->chan, &best_format)) {
904                         ast_log(LOG_WARNING, "Failed to set channel %s to write format %s\n",
905                                 ast_channel_name(bridge_channel->chan), ast_getformatname(&best_format));
906                         return -1;
907                 }
908                 ast_debug(1, "Bridge %s put channel %s into write format %s\n",
909                         bridge->uniqueid, ast_channel_name(bridge_channel->chan),
910                         ast_getformatname(&best_format));
911         } else {
912                 ast_debug(1, "Bridge %s is happy that channel %s already has write format %s\n",
913                         bridge->uniqueid, ast_channel_name(bridge_channel->chan),
914                         ast_getformatname(&write_format));
915         }
916
917         return 0;
918 }
919
920 /*!
921  * \internal
922  * \brief Perform the smart bridge operation.
923  * \since 12.0.0
924  *
925  * \param bridge Work on this bridge.
926  *
927  * \details
928  * Basically see if a new bridge technology should be used instead
929  * of the current one.
930  *
931  * \note On entry, bridge is already locked.
932  *
933  * \retval 0 on success.
934  * \retval -1 on error.
935  */
936 static int smart_bridge_operation(struct ast_bridge *bridge)
937 {
938         uint32_t new_capabilities;
939         struct ast_bridge_technology *new_technology;
940         struct ast_bridge_technology *old_technology = bridge->technology;
941         struct ast_bridge_channel *bridge_channel;
942         struct ast_frame *deferred_action;
943         struct ast_bridge dummy_bridge = {
944                 .technology = bridge->technology,
945                 .tech_pvt = bridge->tech_pvt,
946         };
947
948         if (bridge->dissolved) {
949                 ast_debug(1, "Bridge %s is dissolved, not performing smart bridge operation.\n",
950                         bridge->uniqueid);
951                 return 0;
952         }
953
954         /* Determine new bridge technology capabilities needed. */
955         if (2 < bridge->num_channels) {
956                 new_capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX;
957                 new_capabilities &= bridge->allowed_capabilities;
958         } else {
959                 new_capabilities = AST_BRIDGE_CAPABILITY_NATIVE | AST_BRIDGE_CAPABILITY_1TO1MIX;
960                 new_capabilities &= bridge->allowed_capabilities;
961                 if (!new_capabilities
962                         && (bridge->allowed_capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX)) {
963                         /* Allow switching between different multimix bridge technologies. */
964                         new_capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX;
965                 }
966         }
967
968         /* Find a bridge technology to satisfy the new capabilities. */
969         new_technology = find_best_technology(new_capabilities, bridge);
970         if (!new_technology) {
971                 int is_compatible = 0;
972
973                 if (old_technology->compatible) {
974                         is_compatible = old_technology->compatible(bridge);
975                 } else if (old_technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX) {
976                         is_compatible = 1;
977                 } else if (bridge->num_channels <= 2
978                         && (old_technology->capabilities & AST_BRIDGE_CAPABILITY_1TO1MIX)) {
979                         is_compatible = 1;
980                 }
981
982                 if (is_compatible) {
983                         ast_debug(1, "Bridge %s could not get a new technology, staying with old technology.\n",
984                                 bridge->uniqueid);
985                         return 0;
986                 }
987                 ast_log(LOG_WARNING, "Bridge %s has no technology available to support it.\n",
988                         bridge->uniqueid);
989                 return -1;
990         }
991         if (new_technology == old_technology) {
992                 ast_debug(1, "Bridge %s is already using the new technology.\n",
993                         bridge->uniqueid);
994                 ast_module_unref(old_technology->mod);
995                 return 0;
996         }
997
998         ast_copy_string(dummy_bridge.uniqueid, bridge->uniqueid, sizeof(dummy_bridge.uniqueid));
999
1000         if (old_technology->destroy) {
1001                 struct tech_deferred_destroy deferred_tech_destroy = {
1002                         .tech = dummy_bridge.technology,
1003                         .tech_pvt = dummy_bridge.tech_pvt,
1004                 };
1005                 struct ast_frame action = {
1006                         .frametype = AST_FRAME_BRIDGE_ACTION,
1007                         .subclass.integer = BRIDGE_CHANNEL_ACTION_DEFERRED_TECH_DESTROY,
1008                         .data.ptr = &deferred_tech_destroy,
1009                         .datalen = sizeof(deferred_tech_destroy),
1010                 };
1011
1012                 /*
1013                  * We need to defer the bridge technology destroy callback
1014                  * because we have the bridge locked.
1015                  */
1016                 deferred_action = ast_frdup(&action);
1017                 if (!deferred_action) {
1018                         ast_module_unref(new_technology->mod);
1019                         return -1;
1020                 }
1021         } else {
1022                 deferred_action = NULL;
1023         }
1024
1025         /*
1026          * We are now committed to changing the bridge technology.  We
1027          * must not release the bridge lock until we have installed the
1028          * new bridge technology.
1029          */
1030         ast_verb(4, "Bridge %s: switching from %s technology to %s\n",
1031                 bridge->uniqueid, old_technology->name, new_technology->name);
1032
1033         /*
1034          * Since we are soon going to pass this bridge to a new
1035          * technology we need to NULL out the tech_pvt pointer but
1036          * don't worry as it still exists in dummy_bridge, ditto for the
1037          * old technology.
1038          */
1039         bridge->tech_pvt = NULL;
1040         bridge->technology = new_technology;
1041
1042         /* Setup the new bridge technology. */
1043         ast_debug(1, "Bridge %s: calling %s technology constructor\n",
1044                 bridge->uniqueid, new_technology->name);
1045         if (new_technology->create && new_technology->create(bridge)) {
1046                 ast_log(LOG_WARNING, "Bridge %s: failed to setup bridge technology %s\n",
1047                         bridge->uniqueid, new_technology->name);
1048                 bridge->tech_pvt = dummy_bridge.tech_pvt;
1049                 bridge->technology = dummy_bridge.technology;
1050                 ast_module_unref(new_technology->mod);
1051                 return -1;
1052         }
1053
1054         ast_debug(1, "Bridge %s: calling %s technology stop\n",
1055                 dummy_bridge.uniqueid, old_technology->name);
1056         if (old_technology->stop) {
1057                 old_technology->stop(&dummy_bridge);
1058         }
1059
1060         /*
1061          * Move existing channels over to the new technology and
1062          * complete joining any new channels to the bridge.
1063          */
1064         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1065                 if (!bridge_channel->just_joined) {
1066                         /* Take existing channel from the old technology. */
1067                         ast_debug(1, "Bridge %s: %p(%s) is leaving %s technology (dummy)\n",
1068                                 dummy_bridge.uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
1069                                 old_technology->name);
1070                         if (old_technology->leave) {
1071                                 old_technology->leave(&dummy_bridge, bridge_channel);
1072                         }
1073                 }
1074
1075                 /* Add any new channels or re-add an existing channel to the bridge. */
1076                 bridge_channel_complete_join(bridge, bridge_channel);
1077         }
1078
1079         ast_debug(1, "Bridge %s: calling %s technology start\n",
1080                 bridge->uniqueid, new_technology->name);
1081         if (new_technology->start && new_technology->start(bridge)) {
1082                 ast_log(LOG_WARNING, "Bridge %s: failed to start bridge technology %s\n",
1083                         bridge->uniqueid, new_technology->name);
1084         }
1085
1086         /*
1087          * Now that all the channels have been moved over we need to get
1088          * rid of all the information the old technology may have left
1089          * around.
1090          */
1091         if (old_technology->destroy) {
1092                 ast_debug(1, "Bridge %s: deferring %s technology destructor\n",
1093                         dummy_bridge.uniqueid, old_technology->name);
1094                 bridge_queue_action_nodup(bridge, deferred_action);
1095         } else {
1096                 ast_debug(1, "Bridge %s: calling %s technology destructor\n",
1097                         dummy_bridge.uniqueid, old_technology->name);
1098                 ast_module_unref(old_technology->mod);
1099         }
1100
1101         return 0;
1102 }
1103
1104 /*!
1105  * \internal
1106  * \brief Bridge channel to check if a BRIDGE_PLAY_SOUND needs to be played.
1107  * \since 12.0.0
1108  *
1109  * \param bridge_channel What to check.
1110  *
1111  * \return Nothing
1112  */
1113 static void check_bridge_play_sound(struct ast_bridge_channel *bridge_channel)
1114 {
1115         const char *play_file;
1116
1117         ast_channel_lock(bridge_channel->chan);
1118         play_file = pbx_builtin_getvar_helper(bridge_channel->chan, "BRIDGE_PLAY_SOUND");
1119         if (!ast_strlen_zero(play_file)) {
1120                 play_file = ast_strdupa(play_file);
1121                 pbx_builtin_setvar_helper(bridge_channel->chan, "BRIDGE_PLAY_SOUND", NULL);
1122         } else {
1123                 play_file = NULL;
1124         }
1125         ast_channel_unlock(bridge_channel->chan);
1126
1127         if (play_file) {
1128                 ast_bridge_channel_queue_playfile(bridge_channel, NULL, play_file, NULL);
1129         }
1130 }
1131
1132 /*!
1133  * \internal
1134  * \brief Check for any BRIDGE_PLAY_SOUND channel variables in the bridge.
1135  * \since 12.0.0
1136  *
1137  * \param bridge What to operate on.
1138  *
1139  * \note On entry, the bridge is already locked.
1140  *
1141  * \return Nothing
1142  */
1143 static void check_bridge_play_sounds(struct ast_bridge *bridge)
1144 {
1145         struct ast_bridge_channel *bridge_channel;
1146
1147         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1148                 check_bridge_play_sound(bridge_channel);
1149         }
1150 }
1151
1152 static void update_bridge_vars_set(struct ast_channel *chan, const char *name, const char *pvtid)
1153 {
1154         pbx_builtin_setvar_helper(chan, "BRIDGEPEER", name);
1155         pbx_builtin_setvar_helper(chan, "BRIDGEPVTCALLID", pvtid);
1156 }
1157
1158 /*!
1159  * \internal
1160  * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in a 2 party bridge.
1161  * \since 12.0.0
1162  *
1163  * \param c0 Party of the first part.
1164  * \param c1 Party of the second part.
1165  *
1166  * \note On entry, the bridge is already locked.
1167  * \note The bridge is expected to have exactly two parties.
1168  *
1169  * \return Nothing
1170  */
1171 static void set_bridge_peer_vars_2party(struct ast_channel *c0, struct ast_channel *c1)
1172 {
1173         const char *c0_name;
1174         const char *c1_name;
1175         const char *c0_pvtid = NULL;
1176         const char *c1_pvtid = NULL;
1177 #define UPDATE_BRIDGE_VARS_GET(chan, name, pvtid)                                                                       \
1178         do {                                                                                                                                                    \
1179                 name = ast_strdupa(ast_channel_name(chan));                                                                     \
1180                 if (ast_channel_tech(chan)->get_pvt_uniqueid) {                                                         \
1181                         pvtid = ast_strdupa(ast_channel_tech(chan)->get_pvt_uniqueid(chan));    \
1182                 }                                                                                                                                                       \
1183         } while (0)
1184
1185         ast_channel_lock(c1);
1186         UPDATE_BRIDGE_VARS_GET(c1, c1_name, c1_pvtid);
1187         ast_channel_unlock(c1);
1188
1189         ast_channel_lock(c0);
1190         update_bridge_vars_set(c0, c1_name, c1_pvtid);
1191         UPDATE_BRIDGE_VARS_GET(c0, c0_name, c0_pvtid);
1192         ast_channel_unlock(c0);
1193
1194         ast_channel_lock(c1);
1195         update_bridge_vars_set(c1, c0_name, c0_pvtid);
1196         ast_channel_unlock(c1);
1197 }
1198
1199 /*!
1200  * \internal
1201  * \brief Fill the BRIDGEPEER value buffer with a comma separated list of channel names.
1202  * \since 12.0.0
1203  *
1204  * \param buf Buffer to fill.  The caller must guarantee the buffer is large enough.
1205  * \param cur_idx Which index into names[] to skip.
1206  * \param names Channel names to put in the buffer.
1207  * \param num_names Number of names in the array.
1208  *
1209  * \return Nothing
1210  */
1211 static void fill_bridgepeer_buf(char *buf, unsigned int cur_idx, const char *names[], unsigned int num_names)
1212 {
1213         int need_separator = 0;
1214         unsigned int idx;
1215         const char *src;
1216         char *pos;
1217
1218         pos = buf;
1219         for (idx = 0; idx < num_names; ++idx) {
1220                 if (idx == cur_idx) {
1221                         continue;
1222                 }
1223
1224                 if (need_separator) {
1225                         *pos++ = ',';
1226                 }
1227                 need_separator = 1;
1228
1229                 /* Copy name into buffer. */
1230                 src = names[idx];
1231                 while (*src) {
1232                         *pos++ = *src++;
1233                 }
1234         }
1235         *pos = '\0';
1236 }
1237
1238 /*!
1239  * \internal
1240  * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in a multi-party bridge.
1241  * \since 12.0.0
1242  *
1243  * \param bridge What to operate on.
1244  *
1245  * \note On entry, the bridge is already locked.
1246  * \note The bridge is expected to have more than two parties.
1247  *
1248  * \return Nothing
1249  */
1250 static void set_bridge_peer_vars_multiparty(struct ast_bridge *bridge)
1251 {
1252 /*
1253  * Set a maximum number of channel names for the BRIDGEPEER
1254  * list.  The plus one is for the current channel which is not
1255  * put in the list.
1256  */
1257 #define MAX_BRIDGEPEER_CHANS    (10 + 1)
1258
1259         unsigned int idx;
1260         unsigned int num_names;
1261         unsigned int len;
1262         const char **names;
1263         char *buf;
1264         struct ast_bridge_channel *bridge_channel;
1265
1266         /* Get first MAX_BRIDGEPEER_CHANS channel names. */
1267         num_names = MIN(bridge->num_channels, MAX_BRIDGEPEER_CHANS);
1268         names = ast_alloca(num_names * sizeof(*names));
1269         idx = 0;
1270         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1271                 if (num_names <= idx) {
1272                         break;
1273                 }
1274                 ast_channel_lock(bridge_channel->chan);
1275                 names[idx++] = ast_strdupa(ast_channel_name(bridge_channel->chan));
1276                 ast_channel_unlock(bridge_channel->chan);
1277         }
1278
1279         /* Determine maximum buf size needed. */
1280         len = num_names;
1281         for (idx = 0; idx < num_names; ++idx) {
1282                 len += strlen(names[idx]);
1283         }
1284         buf = ast_alloca(len);
1285
1286         /* Set the bridge channel variables. */
1287         idx = 0;
1288         buf[0] = '\0';
1289         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1290                 if (idx < num_names) {
1291                         fill_bridgepeer_buf(buf, idx, names, num_names);
1292                 }
1293                 ++idx;
1294
1295                 ast_channel_lock(bridge_channel->chan);
1296                 update_bridge_vars_set(bridge_channel->chan, buf, NULL);
1297                 ast_channel_unlock(bridge_channel->chan);
1298         }
1299 }
1300
1301 /*!
1302  * \internal
1303  * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in a holding bridge.
1304  * \since 12.0.0
1305  *
1306  * \param bridge What to operate on.
1307  *
1308  * \note On entry, the bridge is already locked.
1309  *
1310  * \return Nothing
1311  */
1312 static void set_bridge_peer_vars_holding(struct ast_bridge *bridge)
1313 {
1314         struct ast_bridge_channel *bridge_channel;
1315
1316         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1317                 ast_channel_lock(bridge_channel->chan);
1318                 update_bridge_vars_set(bridge_channel->chan, NULL, NULL);
1319                 ast_channel_unlock(bridge_channel->chan);
1320         }
1321 }
1322
1323 /*!
1324  * \internal
1325  * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in the bridge.
1326  * \since 12.0.0
1327  *
1328  * \param bridge What to operate on.
1329  *
1330  * \note On entry, the bridge is already locked.
1331  *
1332  * \return Nothing
1333  */
1334 static void set_bridge_peer_vars(struct ast_bridge *bridge)
1335 {
1336         if (bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_HOLDING) {
1337                 set_bridge_peer_vars_holding(bridge);
1338                 return;
1339         }
1340         if (bridge->num_channels < 2) {
1341                 return;
1342         }
1343         if (bridge->num_channels == 2) {
1344                 set_bridge_peer_vars_2party(AST_LIST_FIRST(&bridge->channels)->chan,
1345                         AST_LIST_LAST(&bridge->channels)->chan);
1346         } else {
1347                 set_bridge_peer_vars_multiparty(bridge);
1348         }
1349 }
1350
1351 void bridge_reconfigured(struct ast_bridge *bridge, unsigned int colp_update)
1352 {
1353         if (!bridge->reconfigured) {
1354                 return;
1355         }
1356         bridge->reconfigured = 0;
1357         if (ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_SMART)
1358                 && smart_bridge_operation(bridge)) {
1359                 /* Smart bridge failed. */
1360                 bridge_dissolve(bridge, 0);
1361                 return;
1362         }
1363         bridge_complete_join(bridge);
1364
1365         if (bridge->dissolved) {
1366                 return;
1367         }
1368         check_bridge_play_sounds(bridge);
1369         set_bridge_peer_vars(bridge);
1370         ast_bridge_publish_state(bridge);
1371
1372         if (colp_update) {
1373                 bridge_reconfigured_connected_line_update(bridge);
1374         }
1375 }
1376
1377 struct ast_bridge_channel *bridge_find_channel(struct ast_bridge *bridge, struct ast_channel *chan)
1378 {
1379         struct ast_bridge_channel *bridge_channel;
1380
1381         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1382                 if (bridge_channel->chan == chan) {
1383                         break;
1384                 }
1385         }
1386
1387         return bridge_channel;
1388 }
1389
1390 void ast_bridge_notify_masquerade(struct ast_channel *chan)
1391 {
1392         struct ast_bridge_channel *bridge_channel;
1393         struct ast_bridge *bridge;
1394
1395         /* Safely get the bridge_channel pointer for the chan. */
1396         ast_channel_lock(chan);
1397         bridge_channel = ast_channel_get_bridge_channel(chan);
1398         ast_channel_unlock(chan);
1399         if (!bridge_channel) {
1400                 /* Not in a bridge */
1401                 return;
1402         }
1403
1404         ast_bridge_channel_lock_bridge(bridge_channel);
1405         bridge = bridge_channel->bridge;
1406         if (bridge_channel == bridge_find_channel(bridge, chan)) {
1407 /*
1408  * XXX ASTERISK-22366 this needs more work.  The channels need
1409  * to be made compatible again if the formats change. The
1410  * bridge_channel thread needs to monitor for this case.
1411  */
1412                 /* The channel we want to notify is still in a bridge. */
1413                 bridge->v_table->notify_masquerade(bridge, bridge_channel);
1414                 bridge_reconfigured(bridge, 1);
1415         }
1416         ast_bridge_unlock(bridge);
1417         ao2_ref(bridge_channel, -1);
1418 }
1419
1420 /*
1421  * XXX ASTERISK-21271 make ast_bridge_join() require features to be allocated just like ast_bridge_impart() and not expect the struct back.
1422  *
1423  * This change is really going to break ConfBridge.  All other
1424  * users are easily changed.  However, it is needed so the
1425  * bridging code can manipulate features on all channels
1426  * consistently no matter how they joined.
1427  *
1428  * Need to update the features parameter doxygen when this
1429  * change is made to be like ast_bridge_impart().
1430  */
1431 int ast_bridge_join(struct ast_bridge *bridge,
1432         struct ast_channel *chan,
1433         struct ast_channel *swap,
1434         struct ast_bridge_features *features,
1435         struct ast_bridge_tech_optimizations *tech_args,
1436         int pass_reference)
1437 {
1438         struct ast_bridge_channel *bridge_channel;
1439         int res = 0;
1440
1441         bridge_channel = bridge_channel_internal_alloc(bridge);
1442         if (pass_reference) {
1443                 ao2_ref(bridge, -1);
1444         }
1445         if (!bridge_channel) {
1446                 res = -1;
1447                 goto join_exit;
1448         }
1449 /* XXX ASTERISK-21271 features cannot be NULL when passed in. When it is changed to allocated we can do like ast_bridge_impart() and allocate one. */
1450         ast_assert(features != NULL);
1451         if (!features) {
1452                 ao2_ref(bridge_channel, -1);
1453                 res = -1;
1454                 goto join_exit;
1455         }
1456         if (tech_args) {
1457                 bridge_channel->tech_args = *tech_args;
1458         }
1459
1460         ast_channel_lock(chan);
1461         if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_ZOMBIE)) {
1462                 res = -1;
1463         } else {
1464                 ast_channel_internal_bridge_channel_set(chan, bridge_channel);
1465         }
1466         ast_channel_unlock(chan);
1467         bridge_channel->thread = pthread_self();
1468         bridge_channel->chan = chan;
1469         bridge_channel->swap = swap;
1470         bridge_channel->features = features;
1471
1472         if (!res) {
1473                 res = bridge_channel_internal_join(bridge_channel);
1474         }
1475
1476         /* Cleanup all the data in the bridge channel after it leaves the bridge. */
1477         ast_channel_lock(chan);
1478         ast_channel_internal_bridge_channel_set(chan, NULL);
1479         ast_channel_unlock(chan);
1480         bridge_channel->chan = NULL;
1481         bridge_channel->swap = NULL;
1482         bridge_channel->features = NULL;
1483
1484         ao2_ref(bridge_channel, -1);
1485
1486 join_exit:;
1487         ast_bridge_run_after_callback(chan);
1488         if (!(ast_channel_softhangup_internal_flag(chan) & AST_SOFTHANGUP_ASYNCGOTO)
1489                 && !ast_bridge_setup_after_goto(chan)) {
1490                 /* Claim the after bridge goto is an async goto destination. */
1491                 ast_channel_lock(chan);
1492                 ast_softhangup_nolock(chan, AST_SOFTHANGUP_ASYNCGOTO);
1493                 ast_channel_unlock(chan);
1494         }
1495         return res;
1496 }
1497
1498 /*! \brief Thread responsible for imparted bridged channels to be departed */
1499 static void *bridge_channel_depart_thread(void *data)
1500 {
1501         struct ast_bridge_channel *bridge_channel = data;
1502
1503         if (bridge_channel->callid) {
1504                 ast_callid_threadassoc_add(bridge_channel->callid);
1505         }
1506
1507         bridge_channel_internal_join(bridge_channel);
1508
1509         /* cleanup */
1510         bridge_channel->swap = NULL;
1511         ast_bridge_features_destroy(bridge_channel->features);
1512         bridge_channel->features = NULL;
1513
1514         ast_bridge_discard_after_callback(bridge_channel->chan, AST_BRIDGE_AFTER_CB_REASON_DEPART);
1515         ast_bridge_discard_after_goto(bridge_channel->chan);
1516
1517         return NULL;
1518 }
1519
1520 /*! \brief Thread responsible for independent imparted bridged channels */
1521 static void *bridge_channel_ind_thread(void *data)
1522 {
1523         struct ast_bridge_channel *bridge_channel = data;
1524         struct ast_channel *chan;
1525
1526         if (bridge_channel->callid) {
1527                 ast_callid_threadassoc_add(bridge_channel->callid);
1528         }
1529
1530         bridge_channel_internal_join(bridge_channel);
1531         chan = bridge_channel->chan;
1532
1533         /* cleanup */
1534         ast_channel_lock(chan);
1535         ast_channel_internal_bridge_channel_set(chan, NULL);
1536         ast_channel_unlock(chan);
1537         bridge_channel->chan = NULL;
1538         bridge_channel->swap = NULL;
1539         ast_bridge_features_destroy(bridge_channel->features);
1540         bridge_channel->features = NULL;
1541
1542         ao2_ref(bridge_channel, -1);
1543
1544         ast_bridge_run_after_callback(chan);
1545         ast_bridge_run_after_goto(chan);
1546         return NULL;
1547 }
1548
1549 int ast_bridge_impart(struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap, struct ast_bridge_features *features, int independent)
1550 {
1551         int res = 0;
1552         struct ast_bridge_channel *bridge_channel;
1553
1554         /* Imparted channels cannot have a PBX. */
1555         if (ast_channel_pbx(chan)) {
1556                 ast_log(AST_LOG_WARNING, "Channel %s has a PBX thread and cannot be imparted into bridge %s\n",
1557                         ast_channel_name(chan), bridge->uniqueid);
1558                 return -1;
1559         }
1560
1561         /* Supply an empty features structure if the caller did not. */
1562         if (!features) {
1563                 features = ast_bridge_features_new();
1564                 if (!features) {
1565                         return -1;
1566                 }
1567         }
1568
1569         /* Try to allocate a structure for the bridge channel */
1570         bridge_channel = bridge_channel_internal_alloc(bridge);
1571         if (!bridge_channel) {
1572                 ast_bridge_features_destroy(features);
1573                 return -1;
1574         }
1575
1576         ast_channel_lock(chan);
1577         if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_ZOMBIE)) {
1578                 ast_log(AST_LOG_NOTICE, "Channel %s is a zombie and cannot be imparted into bridge %s\n",
1579                         ast_channel_name(chan), bridge->uniqueid);
1580                 res = -1;
1581         } else {
1582                 ast_channel_internal_bridge_channel_set(chan, bridge_channel);
1583         }
1584         ast_channel_unlock(chan);
1585         bridge_channel->chan = chan;
1586         bridge_channel->swap = swap;
1587         bridge_channel->features = features;
1588         bridge_channel->depart_wait = independent ? 0 : 1;
1589         bridge_channel->callid = ast_read_threadstorage_callid();
1590
1591         /* Actually create the thread that will handle the channel */
1592         if (!res) {
1593                 if (independent) {
1594                         res = ast_pthread_create_detached(&bridge_channel->thread, NULL,
1595                                 bridge_channel_ind_thread, bridge_channel);
1596                 } else {
1597                         res = ast_pthread_create(&bridge_channel->thread, NULL,
1598                                 bridge_channel_depart_thread, bridge_channel);
1599                 }
1600         }
1601
1602         if (res) {
1603                 /* cleanup */
1604                 ast_channel_lock(chan);
1605                 ast_channel_internal_bridge_channel_set(chan, NULL);
1606                 ast_channel_unlock(chan);
1607                 bridge_channel->chan = NULL;
1608                 bridge_channel->swap = NULL;
1609                 ast_bridge_features_destroy(bridge_channel->features);
1610                 bridge_channel->features = NULL;
1611
1612                 ao2_ref(bridge_channel, -1);
1613                 return -1;
1614         }
1615
1616         return 0;
1617 }
1618
1619 int ast_bridge_depart(struct ast_channel *chan)
1620 {
1621         struct ast_bridge_channel *bridge_channel;
1622         int departable;
1623
1624         ast_channel_lock(chan);
1625         bridge_channel = ast_channel_internal_bridge_channel(chan);
1626         departable = bridge_channel && bridge_channel->depart_wait;
1627         ast_channel_unlock(chan);
1628         if (!departable) {
1629                 ast_log(LOG_ERROR, "Channel %s cannot be departed.\n",
1630                         ast_channel_name(chan));
1631                 /*
1632                  * Should never happen.  It likely means that
1633                  * ast_bridge_depart() is called by two threads for the same
1634                  * channel, the channel was never imparted to be departed, or it
1635                  * has already been departed.
1636                  */
1637                 ast_assert(0);
1638                 return -1;
1639         }
1640
1641         /*
1642          * We are claiming the reference held by the depart bridge
1643          * channel thread.
1644          */
1645
1646         ast_bridge_channel_leave_bridge(bridge_channel,
1647                 BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, AST_CAUSE_NORMAL_CLEARING);
1648
1649         /* Wait for the depart thread to die */
1650         ast_debug(1, "Waiting for %p(%s) bridge thread to die.\n",
1651                 bridge_channel, ast_channel_name(bridge_channel->chan));
1652         pthread_join(bridge_channel->thread, NULL);
1653
1654         ast_channel_lock(chan);
1655         ast_channel_internal_bridge_channel_set(chan, NULL);
1656         ast_channel_unlock(chan);
1657
1658         /* We can get rid of the bridge_channel after the depart thread has died. */
1659         ao2_ref(bridge_channel, -1);
1660         return 0;
1661 }
1662
1663 int ast_bridge_remove(struct ast_bridge *bridge, struct ast_channel *chan)
1664 {
1665         struct ast_bridge_channel *bridge_channel;
1666
1667         ast_bridge_lock(bridge);
1668
1669         /* Try to find the channel that we want to remove */
1670         if (!(bridge_channel = bridge_find_channel(bridge, chan))) {
1671                 ast_bridge_unlock(bridge);
1672                 return -1;
1673         }
1674
1675         ast_bridge_channel_leave_bridge(bridge_channel,
1676                 BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, AST_CAUSE_NORMAL_CLEARING);
1677
1678         ast_bridge_unlock(bridge);
1679
1680         return 0;
1681 }
1682
1683 static void kick_it(struct ast_bridge_channel *bridge_channel, const void *payload, size_t payload_size)
1684 {
1685         ast_bridge_channel_kick(bridge_channel, AST_CAUSE_NORMAL_CLEARING);
1686 }
1687
1688 int ast_bridge_kick(struct ast_bridge *bridge, struct ast_channel *chan)
1689 {
1690         struct ast_bridge_channel *bridge_channel;
1691         int res;
1692
1693         ast_bridge_lock(bridge);
1694
1695         /* Try to find the channel that we want to kick. */
1696         if (!(bridge_channel = bridge_find_channel(bridge, chan))) {
1697                 ast_bridge_unlock(bridge);
1698                 return -1;
1699         }
1700
1701         res = ast_bridge_channel_queue_callback(bridge_channel, 0, kick_it, NULL, 0);
1702
1703         ast_bridge_unlock(bridge);
1704
1705         return res;
1706 }
1707
1708 /*!
1709  * \internal
1710  * \brief Point the bridge_channel to a new bridge.
1711  * \since 12.0.0
1712  *
1713  * \param bridge_channel What is to point to a new bridge.
1714  * \param new_bridge Where the bridge channel should point.
1715  *
1716  * \return Nothing
1717  */
1718 static void bridge_channel_change_bridge(struct ast_bridge_channel *bridge_channel, struct ast_bridge *new_bridge)
1719 {
1720         struct ast_bridge *old_bridge;
1721
1722         ao2_ref(new_bridge, +1);
1723         ast_bridge_channel_lock(bridge_channel);
1724         ast_channel_lock(bridge_channel->chan);
1725         old_bridge = bridge_channel->bridge;
1726         bridge_channel->bridge = new_bridge;
1727         ast_channel_internal_bridge_set(bridge_channel->chan, new_bridge);
1728         ast_channel_unlock(bridge_channel->chan);
1729         ast_bridge_channel_unlock(bridge_channel);
1730         ao2_ref(old_bridge, -1);
1731 }
1732
1733 void bridge_do_merge(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, struct ast_bridge_channel **kick_me, unsigned int num_kick,
1734         unsigned int optimized)
1735 {
1736         struct ast_bridge_channel *bridge_channel;
1737         unsigned int idx;
1738
1739         ast_debug(1, "Merging bridge %s into bridge %s\n",
1740                 src_bridge->uniqueid, dst_bridge->uniqueid);
1741
1742         ast_bridge_publish_merge(dst_bridge, src_bridge);
1743
1744         /*
1745          * Move channels from src_bridge over to dst_bridge.
1746          *
1747          * We must use AST_LIST_TRAVERSE_SAFE_BEGIN() because
1748          * bridge_channel_internal_pull() alters the list we are traversing.
1749          */
1750         AST_LIST_TRAVERSE_SAFE_BEGIN(&src_bridge->channels, bridge_channel, entry) {
1751                 if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
1752                         /*
1753                          * The channel is already leaving let it leave normally because
1754                          * pulling it may delete hooks that should run for this channel.
1755                          */
1756                         continue;
1757                 }
1758                 if (ast_test_flag(&bridge_channel->features->feature_flags,
1759                         AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE)) {
1760                         continue;
1761                 }
1762
1763                 if (kick_me) {
1764                         for (idx = 0; idx < num_kick; ++idx) {
1765                                 if (bridge_channel == kick_me[idx]) {
1766                                         ast_bridge_channel_leave_bridge(bridge_channel,
1767                                                 BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, AST_CAUSE_NORMAL_CLEARING);
1768                                         break;
1769                                 }
1770                         }
1771                 }
1772                 bridge_channel_internal_pull(bridge_channel);
1773                 if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
1774                         /*
1775                          * The channel died as a result of being pulled or it was
1776                          * kicked.  Leave it pointing to the original bridge.
1777                          */
1778                         continue;
1779                 }
1780
1781                 /* Point to new bridge.*/
1782                 bridge_channel_change_bridge(bridge_channel, dst_bridge);
1783
1784                 if (bridge_channel_internal_push(bridge_channel)) {
1785                         ast_bridge_channel_leave_bridge(bridge_channel,
1786                                 BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, bridge_channel->bridge->cause);
1787                 }
1788         }
1789         AST_LIST_TRAVERSE_SAFE_END;
1790
1791         if (kick_me) {
1792                 /*
1793                  * Now we can kick any channels in the dst_bridge without
1794                  * potentially dissolving the bridge.
1795                  */
1796                 for (idx = 0; idx < num_kick; ++idx) {
1797                         bridge_channel = kick_me[idx];
1798                         ast_bridge_channel_lock(bridge_channel);
1799                         if (bridge_channel->state == BRIDGE_CHANNEL_STATE_WAIT) {
1800                                 ast_bridge_channel_leave_bridge_nolock(bridge_channel,
1801                                         BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, AST_CAUSE_NORMAL_CLEARING);
1802                                 bridge_channel_internal_pull(bridge_channel);
1803                         }
1804                         ast_bridge_channel_unlock(bridge_channel);
1805                 }
1806         }
1807
1808         bridge_reconfigured(dst_bridge, !optimized);
1809         bridge_reconfigured(src_bridge, !optimized);
1810
1811         ast_debug(1, "Merged bridge %s into bridge %s\n",
1812                 src_bridge->uniqueid, dst_bridge->uniqueid);
1813 }
1814
1815 struct merge_direction {
1816         /*! Destination merge bridge. */
1817         struct ast_bridge *dest;
1818         /*! Source merge bridge. */
1819         struct ast_bridge *src;
1820 };
1821
1822 /*!
1823  * \internal
1824  * \brief Determine which bridge should merge into the other.
1825  * \since 12.0.0
1826  *
1827  * \param bridge1 A bridge for merging
1828  * \param bridge2 A bridge for merging
1829  *
1830  * \note The two bridges are assumed already locked.
1831  *
1832  * \return Which bridge merges into which or NULL bridges if cannot merge.
1833  */
1834 static struct merge_direction bridge_merge_determine_direction(struct ast_bridge *bridge1, struct ast_bridge *bridge2)
1835 {
1836         struct merge_direction merge = { NULL, NULL };
1837         int bridge1_priority;
1838         int bridge2_priority;
1839
1840         if (!ast_test_flag(&bridge1->feature_flags,
1841                         AST_BRIDGE_FLAG_MERGE_INHIBIT_TO | AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)
1842                 && !ast_test_flag(&bridge2->feature_flags,
1843                         AST_BRIDGE_FLAG_MERGE_INHIBIT_TO | AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
1844                 /*
1845                  * Can merge either way.  Merge to the higher priority merge
1846                  * bridge.  Otherwise merge to the larger bridge.
1847                  */
1848                 bridge1_priority = bridge1->v_table->get_merge_priority(bridge1);
1849                 bridge2_priority = bridge2->v_table->get_merge_priority(bridge2);
1850                 if (bridge2_priority < bridge1_priority) {
1851                         merge.dest = bridge1;
1852                         merge.src = bridge2;
1853                 } else if (bridge1_priority < bridge2_priority) {
1854                         merge.dest = bridge2;
1855                         merge.src = bridge1;
1856                 } else {
1857                         /* Merge to the larger bridge. */
1858                         if (bridge2->num_channels <= bridge1->num_channels) {
1859                                 merge.dest = bridge1;
1860                                 merge.src = bridge2;
1861                         } else {
1862                                 merge.dest = bridge2;
1863                                 merge.src = bridge1;
1864                         }
1865                 }
1866         } else if (!ast_test_flag(&bridge1->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO)
1867                 && !ast_test_flag(&bridge2->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
1868                 /* Can merge only one way. */
1869                 merge.dest = bridge1;
1870                 merge.src = bridge2;
1871         } else if (!ast_test_flag(&bridge2->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO)
1872                 && !ast_test_flag(&bridge1->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
1873                 /* Can merge only one way. */
1874                 merge.dest = bridge2;
1875                 merge.src = bridge1;
1876         }
1877
1878         return merge;
1879 }
1880
1881 /*!
1882  * \internal
1883  * \brief Merge two bridges together
1884  * \since 12.0.0
1885  *
1886  * \param dst_bridge Destination bridge of merge.
1887  * \param src_bridge Source bridge of merge.
1888  * \param merge_best_direction TRUE if don't care about which bridge merges into the other.
1889  * \param kick_me Array of channels to kick from the bridges.
1890  * \param num_kick Number of channels in the kick_me array.
1891  *
1892  * \note The dst_bridge and src_bridge are assumed already locked.
1893  *
1894  * \retval 0 on success
1895  * \retval -1 on failure
1896  */
1897 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)
1898 {
1899         struct merge_direction merge;
1900         struct ast_bridge_channel **kick_them = NULL;
1901
1902         /* Sanity check. */
1903         ast_assert(dst_bridge && src_bridge && dst_bridge != src_bridge && (!num_kick || kick_me));
1904
1905         if (dst_bridge->dissolved || src_bridge->dissolved) {
1906                 ast_debug(1, "Can't merge bridges %s and %s, at least one bridge is dissolved.\n",
1907                         src_bridge->uniqueid, dst_bridge->uniqueid);
1908                 return -1;
1909         }
1910         if (ast_test_flag(&dst_bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)
1911                 || ast_test_flag(&src_bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)) {
1912                 ast_debug(1, "Can't merge bridges %s and %s, masquerade only.\n",
1913                         src_bridge->uniqueid, dst_bridge->uniqueid);
1914                 return -1;
1915         }
1916         if (dst_bridge->inhibit_merge || src_bridge->inhibit_merge) {
1917                 ast_debug(1, "Can't merge bridges %s and %s, merging temporarily inhibited.\n",
1918                         src_bridge->uniqueid, dst_bridge->uniqueid);
1919                 return -1;
1920         }
1921
1922         if (merge_best_direction) {
1923                 merge = bridge_merge_determine_direction(dst_bridge, src_bridge);
1924         } else {
1925                 merge.dest = dst_bridge;
1926                 merge.src = src_bridge;
1927         }
1928
1929         if (!merge.dest
1930                 || ast_test_flag(&merge.dest->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO)
1931                 || ast_test_flag(&merge.src->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
1932                 ast_debug(1, "Can't merge bridges %s and %s, merging inhibited.\n",
1933                         src_bridge->uniqueid, dst_bridge->uniqueid);
1934                 return -1;
1935         }
1936         if (merge.src->num_channels < 2) {
1937                 /*
1938                  * For a two party bridge, a channel may be temporarily removed
1939                  * from the source bridge or the initial bridge members have not
1940                  * joined yet.
1941                  */
1942                 ast_debug(1, "Can't merge bridge %s into bridge %s, not enough channels in source bridge.\n",
1943                         merge.src->uniqueid, merge.dest->uniqueid);
1944                 return -1;
1945         }
1946         if (2 + num_kick < merge.dest->num_channels + merge.src->num_channels
1947                 && !(merge.dest->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX)
1948                 && (!ast_test_flag(&merge.dest->feature_flags, AST_BRIDGE_FLAG_SMART)
1949                         || !(merge.dest->allowed_capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX))) {
1950                 ast_debug(1, "Can't merge bridge %s into bridge %s, multimix is needed and it cannot be acquired.\n",
1951                         merge.src->uniqueid, merge.dest->uniqueid);
1952                 return -1;
1953         }
1954
1955         if (num_kick) {
1956                 unsigned int num_to_kick = 0;
1957                 unsigned int idx;
1958
1959                 kick_them = ast_alloca(num_kick * sizeof(*kick_them));
1960                 for (idx = 0; idx < num_kick; ++idx) {
1961                         kick_them[num_to_kick] = bridge_find_channel(merge.src, kick_me[idx]);
1962                         if (!kick_them[num_to_kick]) {
1963                                 kick_them[num_to_kick] = bridge_find_channel(merge.dest, kick_me[idx]);
1964                         }
1965                         if (kick_them[num_to_kick]) {
1966                                 ++num_to_kick;
1967                         }
1968                 }
1969
1970                 if (num_to_kick != num_kick) {
1971                         ast_debug(1, "Can't merge bridge %s into bridge %s, at least one kicked channel is not in either bridge.\n",
1972                                 merge.src->uniqueid, merge.dest->uniqueid);
1973                         return -1;
1974                 }
1975         }
1976
1977         bridge_do_merge(merge.dest, merge.src, kick_them, num_kick, 0);
1978         return 0;
1979 }
1980
1981 int ast_bridge_merge(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, int merge_best_direction, struct ast_channel **kick_me, unsigned int num_kick)
1982 {
1983         int res;
1984
1985         /* Sanity check. */
1986         ast_assert(dst_bridge && src_bridge);
1987
1988         ast_bridge_lock_both(dst_bridge, src_bridge);
1989         res = bridge_merge_locked(dst_bridge, src_bridge, merge_best_direction, kick_me, num_kick);
1990         ast_bridge_unlock(src_bridge);
1991         ast_bridge_unlock(dst_bridge);
1992         return res;
1993 }
1994
1995 int bridge_do_move(struct ast_bridge *dst_bridge, struct ast_bridge_channel *bridge_channel, int attempt_recovery,
1996         unsigned int optimized)
1997 {
1998         struct ast_bridge *orig_bridge;
1999         int was_in_bridge;
2000         int res = 0;
2001
2002         if (bridge_channel->swap) {
2003                 ast_debug(1, "Moving %p(%s) into bridge %s swapping with %s\n",
2004                         bridge_channel, ast_channel_name(bridge_channel->chan), dst_bridge->uniqueid,
2005                         ast_channel_name(bridge_channel->swap));
2006         } else {
2007                 ast_debug(1, "Moving %p(%s) into bridge %s\n",
2008                         bridge_channel, ast_channel_name(bridge_channel->chan), dst_bridge->uniqueid);
2009         }
2010
2011         orig_bridge = bridge_channel->bridge;
2012         was_in_bridge = bridge_channel->in_bridge;
2013
2014         bridge_channel_internal_pull(bridge_channel);
2015         if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
2016                 /*
2017                  * The channel died as a result of being pulled.  Leave it
2018                  * pointing to the original bridge.
2019                  */
2020                 bridge_reconfigured(orig_bridge, 0);
2021                 return -1;
2022         }
2023
2024         /* Point to new bridge.*/
2025         ao2_ref(orig_bridge, +1);/* Keep a ref in case the push fails. */
2026         bridge_channel_change_bridge(bridge_channel, dst_bridge);
2027
2028         if (bridge_channel_internal_push(bridge_channel)) {
2029                 /* Try to put the channel back into the original bridge. */
2030                 if (attempt_recovery && was_in_bridge) {
2031                         /* Point back to original bridge. */
2032                         bridge_channel_change_bridge(bridge_channel, orig_bridge);
2033
2034                         if (bridge_channel_internal_push(bridge_channel)) {
2035                                 ast_bridge_channel_leave_bridge(bridge_channel,
2036                                         BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, bridge_channel->bridge->cause);
2037                         }
2038                 } else {
2039                         ast_bridge_channel_leave_bridge(bridge_channel,
2040                                 BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, bridge_channel->bridge->cause);
2041                 }
2042                 res = -1;
2043         }
2044
2045         bridge_reconfigured(dst_bridge, !optimized);
2046         bridge_reconfigured(orig_bridge, !optimized);
2047         ao2_ref(orig_bridge, -1);
2048         return res;
2049 }
2050
2051 /*!
2052  * \internal
2053  * \brief Move a channel from one bridge to another.
2054  * \since 12.0.0
2055  *
2056  * \param dst_bridge Destination bridge of bridge channel move.
2057  * \param src_bridge Source bridge of bridge channel move.
2058  * \param chan Channel to move.
2059  * \param swap Channel to replace in dst_bridge.
2060  * \param attempt_recovery TRUE if failure attempts to push channel back into original bridge.
2061  *
2062  * \note The dst_bridge and src_bridge are assumed already locked.
2063  *
2064  * \retval 0 on success.
2065  * \retval -1 on failure.
2066  */
2067 static int bridge_move_locked(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, struct ast_channel *chan, struct ast_channel *swap, int attempt_recovery)
2068 {
2069         struct ast_bridge_channel *bridge_channel;
2070
2071         if (dst_bridge->dissolved || src_bridge->dissolved) {
2072                 ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, at least one bridge is dissolved.\n",
2073                         ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
2074                 return -1;
2075         }
2076         if (ast_test_flag(&dst_bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)
2077                 || ast_test_flag(&src_bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)) {
2078                 ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, masquerade only.\n",
2079                         ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
2080                 return -1;
2081         }
2082         if (dst_bridge->inhibit_merge || src_bridge->inhibit_merge) {
2083                 ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, temporarily inhibited.\n",
2084                         ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
2085                 return -1;
2086         }
2087
2088         bridge_channel = bridge_find_channel(src_bridge, chan);
2089         if (!bridge_channel) {
2090                 ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, channel not in bridge.\n",
2091                         ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
2092                 return -1;
2093         }
2094         if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
2095                 ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, channel leaving bridge.\n",
2096                         ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
2097                 return -1;
2098         }
2099         if (ast_test_flag(&bridge_channel->features->feature_flags,
2100                 AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE)) {
2101                 ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, channel immovable.\n",
2102                         ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
2103                 return -1;
2104         }
2105
2106         if (swap) {
2107                 struct ast_bridge_channel *bridge_channel_swap;
2108
2109                 bridge_channel_swap = bridge_find_channel(dst_bridge, swap);
2110                 if (!bridge_channel_swap) {
2111                         ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, swap channel %s not in bridge.\n",
2112                                 ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid,
2113                                 ast_channel_name(swap));
2114                         return -1;
2115                 }
2116                 if (bridge_channel_swap->state != BRIDGE_CHANNEL_STATE_WAIT) {
2117                         ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, swap channel %s leaving bridge.\n",
2118                                 ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid,
2119                                 ast_channel_name(swap));
2120                         return -1;
2121                 }
2122         }
2123
2124         bridge_channel->swap = swap;
2125         return bridge_do_move(dst_bridge, bridge_channel, attempt_recovery, 0);
2126 }
2127
2128 int ast_bridge_move(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, struct ast_channel *chan, struct ast_channel *swap, int attempt_recovery)
2129 {
2130         int res;
2131
2132         ast_bridge_lock_both(dst_bridge, src_bridge);
2133         res = bridge_move_locked(dst_bridge, src_bridge, chan, swap, attempt_recovery);
2134         ast_bridge_unlock(src_bridge);
2135         ast_bridge_unlock(dst_bridge);
2136         return res;
2137 }
2138
2139 int ast_bridge_add_channel(struct ast_bridge *bridge, struct ast_channel *chan,
2140         struct ast_bridge_features *features, int play_tone, const char *xfersound)
2141 {
2142         RAII_VAR(struct ast_bridge *, chan_bridge, NULL, ao2_cleanup);
2143         RAII_VAR(struct ast_channel *, yanked_chan, NULL, ao2_cleanup);
2144
2145         ast_channel_lock(chan);
2146         chan_bridge = ast_channel_get_bridge(chan);
2147         ast_channel_unlock(chan);
2148
2149         if (chan_bridge) {
2150                 struct ast_bridge_channel *bridge_channel;
2151
2152                 ast_bridge_lock_both(bridge, chan_bridge);
2153                 bridge_channel = bridge_find_channel(chan_bridge, chan);
2154
2155                 if (bridge_move_locked(bridge, chan_bridge, chan, NULL, 1)) {
2156                         ast_bridge_unlock(chan_bridge);
2157                         ast_bridge_unlock(bridge);
2158                         return -1;
2159                 }
2160
2161                 /*
2162                  * bridge_move_locked() will implicitly ensure that
2163                  * bridge_channel is not NULL.
2164                  */
2165                 ast_assert(bridge_channel != NULL);
2166
2167                 /*
2168                  * Additional checks if the channel we just stole dissolves the
2169                  * original bridge.
2170                  */
2171                 bridge_dissolve_check_stolen(chan_bridge, bridge_channel);
2172                 ast_bridge_unlock(chan_bridge);
2173                 ast_bridge_unlock(bridge);
2174
2175                 /* The channel was in a bridge so it is not getting any new features. */
2176                 ast_bridge_features_destroy(features);
2177         } else {
2178                 /* Slightly less easy case. We need to yank channel A from
2179                  * where he currently is and impart him into our bridge.
2180                  */
2181                 yanked_chan = ast_channel_yank(chan);
2182                 if (!yanked_chan) {
2183                         ast_log(LOG_WARNING, "Could not gain control of channel %s\n", ast_channel_name(chan));
2184                         return -1;
2185                 }
2186                 if (ast_channel_state(yanked_chan) != AST_STATE_UP) {
2187                         ast_answer(yanked_chan);
2188                 }
2189                 ast_channel_ref(yanked_chan);
2190                 if (ast_bridge_impart(bridge, yanked_chan, NULL, features, 1)) {
2191                         /* It is possible for us to yank a channel and have some other
2192                          * thread start a PBX on the channl after we yanked it. In particular,
2193                          * this can theoretically happen on the ;2 of a Local channel if we
2194                          * yank it prior to the ;1 being answered. Make sure that it isn't
2195                          * executing a PBX before hanging it up.
2196                          */
2197                         if (ast_channel_pbx(yanked_chan)) {
2198                                 ast_channel_unref(yanked_chan);
2199                         } else {
2200                                 ast_hangup(yanked_chan);
2201                         }
2202                         return -1;
2203                 }
2204         }
2205
2206         if (play_tone && !ast_strlen_zero(xfersound)) {
2207                 struct ast_channel *play_chan = yanked_chan ?: chan;
2208                 RAII_VAR(struct ast_bridge_channel *, play_bridge_channel, NULL, ao2_cleanup);
2209
2210                 ast_channel_lock(play_chan);
2211                 play_bridge_channel = ast_channel_get_bridge_channel(play_chan);
2212                 ast_channel_unlock(play_chan);
2213
2214                 if (!play_bridge_channel) {
2215                         ast_log(LOG_WARNING, "Unable to play tone for channel %s. No longer in a bridge.\n",
2216                                 ast_channel_name(play_chan));
2217                 } else {
2218                         ast_bridge_channel_queue_playfile(play_bridge_channel, NULL, xfersound, NULL);
2219                 }
2220         }
2221         return 0;
2222 }
2223
2224 static int bridge_allows_optimization(struct ast_bridge *bridge)
2225 {
2226         return !(bridge->inhibit_merge
2227                 || bridge->dissolved
2228                 || ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY));
2229 }
2230
2231 /*!
2232  * \internal
2233  * \brief Lock the unreal channel stack for chan and prequalify it.
2234  * \since 12.0.0
2235  *
2236  * \param chan Unreal channel writing a frame into the channel driver.
2237  *
2238  * \note It is assumed that chan is already locked.
2239  *
2240  * \retval bridge on success with bridge and bridge_channel locked.
2241  * \retval NULL if cannot do optimization now.
2242  */
2243 static struct ast_bridge *optimize_lock_chan_stack(struct ast_channel *chan)
2244 {
2245         struct ast_bridge *bridge;
2246         struct ast_bridge_channel *bridge_channel;
2247
2248         if (!AST_LIST_EMPTY(ast_channel_readq(chan))) {
2249                 return NULL;
2250         }
2251         if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_EMULATE_DTMF)) {
2252                 return NULL;
2253         }
2254         if (ast_channel_has_audio_frame_or_monitor(chan)) {
2255                 /* Channel has an active monitor, audiohook, or framehook. */
2256                 return NULL;
2257         }
2258         bridge_channel = ast_channel_internal_bridge_channel(chan);
2259         if (!bridge_channel || ast_bridge_channel_trylock(bridge_channel)) {
2260                 return NULL;
2261         }
2262         bridge = bridge_channel->bridge;
2263         if (bridge_channel->activity != BRIDGE_CHANNEL_THREAD_SIMPLE
2264                 || bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT
2265                 || ast_bridge_trylock(bridge)) {
2266                 ast_bridge_channel_unlock(bridge_channel);
2267                 return NULL;
2268         }
2269         if (!bridge_channel_internal_allows_optimization(bridge_channel) ||
2270                         !bridge_allows_optimization(bridge)) {
2271                 ast_bridge_unlock(bridge);
2272                 ast_bridge_channel_unlock(bridge_channel);
2273                 return NULL;
2274         }
2275         return bridge;
2276 }
2277
2278 /*!
2279  * \internal
2280  * \brief Lock the unreal channel stack for peer and prequalify it.
2281  * \since 12.0.0
2282  *
2283  * \param peer Other unreal channel in the pair.
2284  *
2285  * \retval bridge on success with bridge, bridge_channel, and peer locked.
2286  * \retval NULL if cannot do optimization now.
2287  */
2288 static struct ast_bridge *optimize_lock_peer_stack(struct ast_channel *peer)
2289 {
2290         struct ast_bridge *bridge;
2291         struct ast_bridge_channel *bridge_channel;
2292
2293         if (ast_channel_trylock(peer)) {
2294                 return NULL;
2295         }
2296         if (!AST_LIST_EMPTY(ast_channel_readq(peer))) {
2297                 ast_channel_unlock(peer);
2298                 return NULL;
2299         }
2300         if (ast_test_flag(ast_channel_flags(peer), AST_FLAG_EMULATE_DTMF)) {
2301                 ast_channel_unlock(peer);
2302                 return NULL;
2303         }
2304         if (ast_channel_has_audio_frame_or_monitor(peer)) {
2305                 /* Peer has an active monitor, audiohook, or framehook. */
2306                 ast_channel_unlock(peer);
2307                 return NULL;
2308         }
2309         bridge_channel = ast_channel_internal_bridge_channel(peer);
2310         if (!bridge_channel || ast_bridge_channel_trylock(bridge_channel)) {
2311                 ast_channel_unlock(peer);
2312                 return NULL;
2313         }
2314         bridge = bridge_channel->bridge;
2315         if (bridge_channel->activity != BRIDGE_CHANNEL_THREAD_IDLE
2316                 || bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT
2317                 || ast_bridge_trylock(bridge)) {
2318                 ast_bridge_channel_unlock(bridge_channel);
2319                 ast_channel_unlock(peer);
2320                 return NULL;
2321         }
2322         if (!bridge_allows_optimization(bridge) ||
2323                         !bridge_channel_internal_allows_optimization(bridge_channel)) {
2324                 ast_bridge_unlock(bridge);
2325                 ast_bridge_channel_unlock(bridge_channel);
2326                 ast_channel_unlock(peer);
2327                 return NULL;
2328         }
2329         return bridge;
2330 }
2331
2332 /*!
2333  * \internal
2334  * \brief Indicates allowability of a swap optimization
2335  */
2336 enum bridge_allow_swap {
2337         /*! Bridges cannot allow for a swap optimization to occur */
2338         SWAP_PROHIBITED,
2339         /*! Bridge swap optimization can occur into the chan_bridge */
2340         SWAP_TO_CHAN_BRIDGE,
2341         /*! Bridge swap optimization can occur into the peer_bridge */
2342         SWAP_TO_PEER_BRIDGE,
2343 };
2344
2345 /*!
2346  * \internal
2347  * \brief Determine if two bridges allow for swap optimization to occur
2348  *
2349  * \param chan_bridge First bridge being tested
2350  * \param peer_bridge Second bridge being tested
2351  * \return Allowability of swap optimization
2352  */
2353 static enum bridge_allow_swap bridges_allow_swap_optimization(struct ast_bridge *chan_bridge,
2354                 struct ast_bridge *peer_bridge)
2355 {
2356         int chan_priority;
2357         int peer_priority;
2358
2359         if (!ast_test_flag(&chan_bridge->feature_flags,
2360                         AST_BRIDGE_FLAG_SWAP_INHIBIT_TO | AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM |
2361                         AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY)
2362                 && !ast_test_flag(&peer_bridge->feature_flags,
2363                         AST_BRIDGE_FLAG_SWAP_INHIBIT_TO | AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM |
2364                         AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY)) {
2365                 /*
2366                  * Can swap either way.  Swap to the higher priority merge
2367                  * bridge.
2368                  */
2369                 chan_priority = chan_bridge->v_table->get_merge_priority(chan_bridge);
2370                 peer_priority = peer_bridge->v_table->get_merge_priority(peer_bridge);
2371                 if (chan_bridge->num_channels == 2
2372                         && chan_priority <= peer_priority) {
2373                         return SWAP_TO_PEER_BRIDGE;
2374                 } else if (peer_bridge->num_channels == 2
2375                         && peer_priority <= chan_priority) {
2376                         return SWAP_TO_CHAN_BRIDGE;
2377                 }
2378         } else if (chan_bridge->num_channels == 2
2379                 && !ast_test_flag(&chan_bridge->feature_flags, AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM | AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY)
2380                 && !ast_test_flag(&peer_bridge->feature_flags, AST_BRIDGE_FLAG_SWAP_INHIBIT_TO)) {
2381                 /* Can swap optimize only one way. */
2382                 return SWAP_TO_PEER_BRIDGE;
2383         } else if (peer_bridge->num_channels == 2
2384                 && !ast_test_flag(&peer_bridge->feature_flags, AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM | AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY)
2385                 && !ast_test_flag(&chan_bridge->feature_flags, AST_BRIDGE_FLAG_SWAP_INHIBIT_TO)) {
2386                 /* Can swap optimize only one way. */
2387                 return SWAP_TO_CHAN_BRIDGE;
2388         }
2389
2390         return SWAP_PROHIBITED;
2391 }
2392
2393 /*!
2394  * \internal
2395  * \brief Check and attempt to swap optimize out the unreal channels.
2396  * \since 12.0.0
2397  *
2398  * \param chan_bridge
2399  * \param chan_bridge_channel
2400  * \param peer_bridge
2401  * \param peer_bridge_channel
2402  * \param pvt Unreal data containing callbacks to call if the optimization actually
2403  * happens
2404  *
2405  * \retval 1 if unreal channels failed to optimize out.
2406  * \retval 0 if unreal channels were not optimized out.
2407  * \retval -1 if unreal channels were optimized out.
2408  */
2409 static int try_swap_optimize_out(struct ast_bridge *chan_bridge,
2410         struct ast_bridge_channel *chan_bridge_channel, struct ast_bridge *peer_bridge,
2411         struct ast_bridge_channel *peer_bridge_channel,
2412         struct ast_unreal_pvt *pvt)
2413 {
2414         struct ast_bridge *dst_bridge;
2415         struct ast_bridge_channel *dst_bridge_channel;
2416         struct ast_bridge_channel *src_bridge_channel;
2417         struct ast_bridge_channel *other;
2418         int res = 1;
2419
2420         switch (bridges_allow_swap_optimization(chan_bridge, peer_bridge)) {
2421         case SWAP_TO_CHAN_BRIDGE:
2422                 dst_bridge = chan_bridge;
2423                 dst_bridge_channel = chan_bridge_channel;
2424                 src_bridge_channel = peer_bridge_channel;
2425                 break;
2426         case SWAP_TO_PEER_BRIDGE:
2427                 dst_bridge = peer_bridge;
2428                 dst_bridge_channel = peer_bridge_channel;
2429                 src_bridge_channel = chan_bridge_channel;
2430                 break;
2431         case SWAP_PROHIBITED:
2432         default:
2433                 return 0;
2434         }
2435
2436         other = ast_bridge_channel_peer(src_bridge_channel);
2437         if (other && other->state == BRIDGE_CHANNEL_STATE_WAIT) {
2438                 unsigned int id = ast_atomic_fetchadd_int((int *) &optimization_id, +1);
2439
2440                 ast_verb(3, "Move-swap optimizing %s <-- %s.\n",
2441                         ast_channel_name(dst_bridge_channel->chan),
2442                         ast_channel_name(other->chan));
2443
2444                 if (pvt && !ast_test_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN) && pvt->callbacks
2445                                 && pvt->callbacks->optimization_started) {
2446                         pvt->callbacks->optimization_started(pvt, other->chan,
2447                                         dst_bridge_channel->chan == pvt->owner ? AST_UNREAL_OWNER : AST_UNREAL_CHAN,
2448                                         id);
2449                         ast_set_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN);
2450                 }
2451                 other->swap = dst_bridge_channel->chan;
2452                 if (!bridge_do_move(dst_bridge, other, 1, 1)) {
2453                         ast_bridge_channel_leave_bridge(src_bridge_channel,
2454                                 BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, AST_CAUSE_NORMAL_CLEARING);
2455                         res = -1;
2456                 }
2457                 if (pvt && pvt->callbacks && pvt->callbacks->optimization_finished) {
2458                         pvt->callbacks->optimization_finished(pvt, res == 1, id);
2459                 }
2460         }
2461         return res;
2462 }
2463
2464 /*!
2465  * \internal
2466  * \brief Indicates allowability of a merge optimization
2467  */
2468 enum bridge_allow_merge {
2469         /*! Bridge properties prohibit merge optimization */
2470         MERGE_PROHIBITED,
2471         /*! Merge optimization cannot occur because the source bridge has too few channels */
2472         MERGE_NOT_ENOUGH_CHANNELS,
2473         /*! Merge optimization cannot occur because multimix capability could not be requested */
2474         MERGE_NO_MULTIMIX,
2475         /*! Merge optimization allowed between bridges */
2476         MERGE_ALLOWED,
2477 };
2478
2479 /*!
2480  * \internal
2481  * \brief Determines allowability of a merge optimization
2482  *
2483  * \note The merge output parameter is undefined if MERGE_PROHIBITED is returned. For success
2484  * and other failure returns, a merge direction was determined, and the parameter is safe to
2485  * access.
2486  *
2487  * \param chan_bridge First bridge being tested
2488  * \param peer_bridge Second bridge being tested
2489  * \param num_kick_channels The number of channels to remove from the bridges during merging
2490  * \param[out] merge Indicates the recommended direction for the bridge merge
2491  */
2492 static enum bridge_allow_merge bridges_allow_merge_optimization(struct ast_bridge *chan_bridge,
2493                 struct ast_bridge *peer_bridge, int num_kick_channels, struct merge_direction *merge)
2494 {
2495         *merge = bridge_merge_determine_direction(chan_bridge, peer_bridge);
2496         if (!merge->dest) {
2497                 return MERGE_PROHIBITED;
2498         }
2499         if (merge->src->num_channels < 2) {
2500                 return MERGE_NOT_ENOUGH_CHANNELS;
2501         } else if ((2 + num_kick_channels) < merge->dest->num_channels + merge->src->num_channels
2502                 && !(merge->dest->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX)
2503                 && (!ast_test_flag(&merge->dest->feature_flags, AST_BRIDGE_FLAG_SMART)
2504                         || !(merge->dest->allowed_capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX))) {
2505                 return MERGE_NO_MULTIMIX;
2506         }
2507
2508         return MERGE_ALLOWED;
2509 }
2510
2511 /*!
2512  * \internal
2513  * \brief Check and attempt to merge optimize out the unreal channels.
2514  * \since 12.0.0
2515  *
2516  * \param chan_bridge
2517  * \param chan_bridge_channel
2518  * \param peer_bridge
2519  * \param peer_bridge_channel
2520  * \param pvt Unreal data containing callbacks to call if the optimization actually
2521  * happens
2522  *
2523  * \retval 0 if unreal channels were not optimized out.
2524  * \retval -1 if unreal channels were optimized out.
2525  */
2526 static int try_merge_optimize_out(struct ast_bridge *chan_bridge,
2527         struct ast_bridge_channel *chan_bridge_channel, struct ast_bridge *peer_bridge,
2528         struct ast_bridge_channel *peer_bridge_channel,
2529         struct ast_unreal_pvt *pvt)
2530 {
2531         struct merge_direction merge;
2532         struct ast_bridge_channel *kick_me[] = {
2533                 chan_bridge_channel,
2534                 peer_bridge_channel,
2535         };
2536         unsigned int id;
2537
2538         switch (bridges_allow_merge_optimization(chan_bridge, peer_bridge, ARRAY_LEN(kick_me), &merge)) {
2539         case MERGE_ALLOWED:
2540                 break;
2541         case MERGE_PROHIBITED:
2542                 return 0;
2543         case MERGE_NOT_ENOUGH_CHANNELS:
2544                 ast_debug(4, "Can't optimize %s -- %s out, not enough channels in bridge %s.\n",
2545                         ast_channel_name(chan_bridge_channel->chan),
2546                         ast_channel_name(peer_bridge_channel->chan),
2547                         merge.src->uniqueid);
2548                 return 0;
2549         case MERGE_NO_MULTIMIX:
2550                 ast_debug(4, "Can't optimize %s -- %s out, multimix is needed and it cannot be acquired.\n",
2551                         ast_channel_name(chan_bridge_channel->chan),
2552                         ast_channel_name(peer_bridge_channel->chan));
2553                 return 0;
2554         }
2555
2556         ast_verb(3, "Merge optimizing %s -- %s out.\n",
2557                 ast_channel_name(chan_bridge_channel->chan),
2558                 ast_channel_name(peer_bridge_channel->chan));
2559
2560         id = ast_atomic_fetchadd_int((int *) &optimization_id, +1);
2561
2562         if (pvt && !ast_test_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN) && pvt->callbacks
2563                         && pvt->callbacks->optimization_started) {
2564                 pvt->callbacks->optimization_started(pvt, NULL,
2565                                 merge.dest == ast_channel_internal_bridge(pvt->owner) ? AST_UNREAL_OWNER : AST_UNREAL_CHAN,
2566                                 id);
2567                 ast_set_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN);
2568         }
2569         bridge_do_merge(merge.dest, merge.src, kick_me, ARRAY_LEN(kick_me), 1);
2570         if (pvt && pvt->callbacks && pvt->callbacks->optimization_finished) {
2571                 pvt->callbacks->optimization_finished(pvt, 1, id);
2572         }
2573
2574         return -1;
2575 }
2576
2577 int ast_bridge_unreal_optimize_out(struct ast_channel *chan, struct ast_channel *peer, struct ast_unreal_pvt *pvt)
2578 {
2579         struct ast_bridge *chan_bridge;
2580         struct ast_bridge *peer_bridge;
2581         struct ast_bridge_channel *chan_bridge_channel;
2582         struct ast_bridge_channel *peer_bridge_channel;
2583         int res = 0;
2584
2585         chan_bridge = optimize_lock_chan_stack(chan);
2586         if (!chan_bridge) {
2587                 return res;
2588         }
2589         chan_bridge_channel = ast_channel_internal_bridge_channel(chan);
2590
2591         peer_bridge = optimize_lock_peer_stack(peer);
2592         if (peer_bridge) {
2593                 peer_bridge_channel = ast_channel_internal_bridge_channel(peer);
2594
2595                 res = try_swap_optimize_out(chan_bridge, chan_bridge_channel,
2596                         peer_bridge, peer_bridge_channel, pvt);
2597                 if (!res) {
2598                         res = try_merge_optimize_out(chan_bridge, chan_bridge_channel,
2599                                 peer_bridge, peer_bridge_channel, pvt);
2600                 } else if (0 < res) {
2601                         res = 0;
2602                 }
2603
2604                 /* Release peer locks. */
2605                 ast_bridge_unlock(peer_bridge);
2606                 ast_bridge_channel_unlock(peer_bridge_channel);
2607                 ast_channel_unlock(peer);
2608         }
2609
2610         /* Release chan locks. */
2611         ast_bridge_unlock(chan_bridge);
2612         ast_bridge_channel_unlock(chan_bridge_channel);
2613
2614         return res;
2615 }
2616
2617 enum ast_bridge_optimization ast_bridges_allow_optimization(struct ast_bridge *chan_bridge,
2618                 struct ast_bridge *peer_bridge)
2619 {
2620         struct merge_direction merge;
2621
2622         if (!bridge_allows_optimization(chan_bridge) || !bridge_allows_optimization(peer_bridge)) {
2623                 return AST_BRIDGE_OPTIMIZE_PROHIBITED;
2624         }
2625
2626         switch (bridges_allow_swap_optimization(chan_bridge, peer_bridge)) {
2627         case SWAP_TO_CHAN_BRIDGE:
2628                 return AST_BRIDGE_OPTIMIZE_SWAP_TO_CHAN_BRIDGE;
2629         case SWAP_TO_PEER_BRIDGE:
2630                 return AST_BRIDGE_OPTIMIZE_SWAP_TO_PEER_BRIDGE;
2631         case SWAP_PROHIBITED:
2632         default:
2633                 break;
2634         }
2635
2636         /* Two channels will be kicked from the bridges, the unreal;1 and unreal;2 channels */
2637         if (bridges_allow_merge_optimization(chan_bridge, peer_bridge, 2, &merge) != MERGE_ALLOWED) {
2638                 return AST_BRIDGE_OPTIMIZE_PROHIBITED;
2639         }
2640
2641         if (merge.dest == chan_bridge) {
2642                 return AST_BRIDGE_OPTIMIZE_MERGE_TO_CHAN_BRIDGE;
2643         } else {
2644                 return AST_BRIDGE_OPTIMIZE_MERGE_TO_PEER_BRIDGE;
2645         }
2646 }
2647
2648 /*!
2649  * \internal
2650  * \brief Adjust the bridge merge inhibit request count.
2651  * \since 12.0.0
2652  *
2653  * \param bridge What to operate on.
2654  * \param request Inhibit request increment.
2655  *     (Positive to add requests.  Negative to remove requests.)
2656  *
2657  * \note This function assumes bridge is locked.
2658  *
2659  * \return Nothing
2660  */
2661 void bridge_merge_inhibit_nolock(struct ast_bridge *bridge, int request)
2662 {
2663         int new_request;
2664
2665         new_request = bridge->inhibit_merge + request;
2666         ast_assert(0 <= new_request);
2667         bridge->inhibit_merge = new_request;
2668 }
2669
2670 void ast_bridge_merge_inhibit(struct ast_bridge *bridge, int request)
2671 {
2672         ast_bridge_lock(bridge);
2673         bridge_merge_inhibit_nolock(bridge, request);
2674         ast_bridge_unlock(bridge);
2675 }
2676
2677 int ast_bridge_suspend(struct ast_bridge *bridge, struct ast_channel *chan)
2678 {
2679         struct ast_bridge_channel *bridge_channel;
2680 /* XXX ASTERISK-21271 the case of a disolved bridge while channel is suspended is not handled. */
2681 /* XXX ASTERISK-21271 suspend/unsuspend needs to be rethought. The caller must block until it has successfully suspended the channel for temporary control. */
2682 /* XXX ASTERISK-21271 external suspend/unsuspend needs to be eliminated. The channel may be playing a file at the time and stealing it then is not good. */
2683
2684         ast_bridge_lock(bridge);
2685
2686         if (!(bridge_channel = bridge_find_channel(bridge, chan))) {
2687                 ast_bridge_unlock(bridge);
2688                 return -1;
2689         }
2690
2691         bridge_channel_internal_suspend_nolock(bridge_channel);
2692
2693         ast_bridge_unlock(bridge);
2694
2695         return 0;
2696 }
2697
2698 int ast_bridge_unsuspend(struct ast_bridge *bridge, struct ast_channel *chan)
2699 {
2700         struct ast_bridge_channel *bridge_channel;
2701 /* XXX ASTERISK-21271 the case of a disolved bridge while channel is suspended is not handled. */
2702
2703         ast_bridge_lock(bridge);
2704
2705         if (!(bridge_channel = bridge_find_channel(bridge, chan))) {
2706                 ast_bridge_unlock(bridge);
2707                 return -1;
2708         }
2709
2710         bridge_channel_internal_unsuspend_nolock(bridge_channel);
2711
2712         ast_bridge_unlock(bridge);
2713
2714         return 0;
2715 }
2716
2717 void ast_bridge_technology_suspend(struct ast_bridge_technology *technology)
2718 {
2719         technology->suspended = 1;
2720 }
2721
2722 void ast_bridge_technology_unsuspend(struct ast_bridge_technology *technology)
2723 {
2724         /*
2725          * XXX We may want the act of unsuspending a bridge technology
2726          * to prod all existing bridges to see if they should start
2727          * using it.
2728          */
2729         technology->suspended = 0;
2730 }
2731
2732 int ast_bridge_features_register(enum ast_bridge_builtin_feature feature, ast_bridge_hook_callback callback, const char *dtmf)
2733 {
2734         if (ARRAY_LEN(builtin_features_handlers) <= feature
2735                 || builtin_features_handlers[feature]) {
2736                 return -1;
2737         }
2738
2739         if (!ast_strlen_zero(dtmf)) {
2740                 ast_copy_string(builtin_features_dtmf[feature], dtmf, sizeof(builtin_features_dtmf[feature]));
2741         }
2742
2743         builtin_features_handlers[feature] = callback;
2744
2745         return 0;
2746 }
2747
2748 int ast_bridge_features_unregister(enum ast_bridge_builtin_feature feature)
2749 {
2750         if (ARRAY_LEN(builtin_features_handlers) <= feature
2751                 || !builtin_features_handlers[feature]) {
2752                 return -1;
2753         }
2754
2755         builtin_features_handlers[feature] = NULL;
2756
2757         return 0;
2758 }
2759
2760 int ast_bridge_features_do(enum ast_bridge_builtin_feature feature, struct ast_bridge_channel *bridge_channel, void *hook_pvt)
2761 {
2762         ast_bridge_hook_callback callback;
2763
2764         if (ARRAY_LEN(builtin_features_handlers) <= feature) {
2765                 return -1;
2766         }
2767
2768         callback = builtin_features_handlers[feature];
2769         if (!callback) {
2770                 return -1;
2771         }
2772         callback(bridge_channel, hook_pvt);
2773
2774         return 0;
2775 }
2776
2777 int ast_bridge_interval_register(enum ast_bridge_builtin_interval interval, ast_bridge_builtin_set_limits_fn callback)
2778 {
2779         if (ARRAY_LEN(builtin_interval_handlers) <= interval
2780                 || builtin_interval_handlers[interval]) {
2781                 return -1;
2782         }
2783
2784         builtin_interval_handlers[interval] = callback;
2785
2786         return 0;
2787 }
2788
2789 int ast_bridge_interval_unregister(enum ast_bridge_builtin_interval interval)
2790 {
2791         if (ARRAY_LEN(builtin_interval_handlers) <= interval
2792                 || !builtin_interval_handlers[interval]) {
2793                 return -1;
2794         }
2795
2796         builtin_interval_handlers[interval] = NULL;
2797
2798         return 0;
2799
2800 }
2801
2802 /*!
2803  * \internal
2804  * \brief Bridge hook destructor.
2805  * \since 12.0.0
2806  *
2807  * \param vhook Object to destroy.
2808  *
2809  * \return Nothing
2810  */
2811 static void bridge_hook_destroy(void *vhook)
2812 {
2813         struct ast_bridge_hook *hook = vhook;
2814
2815         if (hook->destructor) {
2816                 hook->destructor(hook->hook_pvt);
2817         }
2818 }
2819
2820 /*!
2821  * \internal
2822  * \brief Allocate and setup a generic bridge hook.
2823  * \since 12.0.0
2824  *
2825  * \param size How big an object to allocate.
2826  * \param callback Function to execute upon activation
2827  * \param hook_pvt Unique data
2828  * \param destructor Optional destructor callback for hook_pvt data
2829  * \param remove_flags Dictates what situations the hook should be removed.
2830  *
2831  * \retval hook on success.
2832  * \retval NULL on error.
2833  */
2834 static struct ast_bridge_hook *bridge_hook_generic(size_t size,
2835         ast_bridge_hook_callback callback,
2836         void *hook_pvt,
2837         ast_bridge_hook_pvt_destructor destructor,
2838         enum ast_bridge_hook_remove_flags remove_flags)
2839 {
2840         struct ast_bridge_hook *hook;
2841
2842         /* Allocate new hook and setup it's basic variables */
2843         hook = ao2_alloc_options(size, bridge_hook_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
2844         if (hook) {
2845                 hook->callback = callback;
2846                 hook->destructor = destructor;
2847                 hook->hook_pvt = hook_pvt;
2848                 ast_set_flag(&hook->remove_flags, remove_flags);
2849         }
2850
2851         return hook;
2852 }
2853
2854 int ast_bridge_dtmf_hook(struct ast_bridge_features *features,
2855         const char *dtmf,
2856         ast_bridge_hook_callback callback,
2857         void *hook_pvt,
2858         ast_bridge_hook_pvt_destructor destructor,
2859         enum ast_bridge_hook_remove_flags remove_flags)
2860 {
2861         struct ast_bridge_hook_dtmf *hook;
2862         int res;
2863
2864         /* Allocate new hook and setup it's various variables */
2865         hook = (struct ast_bridge_hook_dtmf *) bridge_hook_generic(sizeof(*hook), callback,
2866                 hook_pvt, destructor, remove_flags);
2867         if (!hook) {
2868                 return -1;
2869         }
2870         hook->generic.type = AST_BRIDGE_HOOK_TYPE_DTMF;
2871         ast_copy_string(hook->dtmf.code, dtmf, sizeof(hook->dtmf.code));
2872
2873         /* Once done we put it in the container. */
2874         res = ao2_link(features->dtmf_hooks, hook) ? 0 : -1;
2875         if (res) {
2876                 /*
2877                  * Could not link the hook into the container.
2878                  *
2879                  * Remove the hook_pvt destructor call from the hook since we
2880                  * are returning failure to install the hook.
2881                  */
2882                 hook->generic.destructor = NULL;
2883         }
2884         ao2_ref(hook, -1);
2885
2886         return res;
2887 }
2888
2889 /*!
2890  * \internal
2891  * \brief Attach an other hook to a bridge features structure
2892  *
2893  * \param features Bridge features structure
2894  * \param callback Function to execute upon activation
2895  * \param hook_pvt Unique data
2896  * \param destructor Optional destructor callback for hook_pvt data
2897  * \param remove_flags Dictates what situations the hook should be removed.
2898  * \param type What type of hook is being attached.
2899  *
2900  * \retval 0 on success
2901  * \retval -1 on failure (The caller must cleanup any hook_pvt resources.)
2902  */
2903 static int bridge_other_hook(struct ast_bridge_features *features,
2904         ast_bridge_hook_callback callback,
2905         void *hook_pvt,
2906         ast_bridge_hook_pvt_destructor destructor,
2907         enum ast_bridge_hook_remove_flags remove_flags,
2908         enum ast_bridge_hook_type type)
2909 {
2910         struct ast_bridge_hook *hook;
2911         int res;
2912
2913         /* Allocate new hook and setup it's various variables */
2914         hook = bridge_hook_generic(sizeof(*hook), callback, hook_pvt, destructor,
2915                 remove_flags);
2916         if (!hook) {
2917                 return -1;
2918         }
2919         hook->type = type;
2920
2921         /* Once done we put it in the container. */
2922         res = ao2_link(features->other_hooks, hook) ? 0 : -1;
2923         if (res) {
2924                 /*
2925                  * Could not link the hook into the container.
2926                  *
2927                  * Remove the hook_pvt destructor call from the hook since we
2928                  * are returning failure to install the hook.
2929                  */
2930                 hook->destructor = NULL;
2931         }
2932         ao2_ref(hook, -1);
2933
2934         return res;
2935 }
2936
2937 int ast_bridge_hangup_hook(struct ast_bridge_features *features,
2938         ast_bridge_hook_callback callback,
2939         void *hook_pvt,
2940         ast_bridge_hook_pvt_destructor destructor,
2941         enum ast_bridge_hook_remove_flags remove_flags)
2942 {
2943         return bridge_other_hook(features, callback, hook_pvt, destructor, remove_flags,
2944                 AST_BRIDGE_HOOK_TYPE_HANGUP);
2945 }
2946
2947 int ast_bridge_join_hook(struct ast_bridge_features *features,
2948         ast_bridge_hook_callback callback,
2949         void *hook_pvt,
2950         ast_bridge_hook_pvt_destructor destructor,
2951         enum ast_bridge_hook_remove_flags remove_flags)
2952 {
2953         return bridge_other_hook(features, callback, hook_pvt, destructor, remove_flags,
2954                 AST_BRIDGE_HOOK_TYPE_JOIN);
2955 }
2956
2957 int ast_bridge_leave_hook(struct ast_bridge_features *features,
2958         ast_bridge_hook_callback callback,
2959         void *hook_pvt,
2960         ast_bridge_hook_pvt_destructor destructor,
2961         enum ast_bridge_hook_remove_flags remove_flags)
2962 {
2963         return bridge_other_hook(features, callback, hook_pvt, destructor, remove_flags,
2964                 AST_BRIDGE_HOOK_TYPE_LEAVE);
2965 }
2966
2967 int ast_bridge_talk_detector_hook(struct ast_bridge_features *features,
2968         ast_bridge_talking_indicate_callback callback,
2969         void *hook_pvt,
2970         ast_bridge_hook_pvt_destructor destructor,
2971         enum ast_bridge_hook_remove_flags remove_flags)
2972 {
2973         ast_bridge_hook_callback hook_cb = (ast_bridge_hook_callback) callback;
2974
2975         return bridge_other_hook(features, hook_cb, hook_pvt, destructor, remove_flags,
2976                 AST_BRIDGE_HOOK_TYPE_TALK);
2977 }
2978
2979 int ast_bridge_interval_hook(struct ast_bridge_features *features,
2980         enum ast_bridge_hook_timer_option flags,
2981         unsigned int interval,
2982         ast_bridge_hook_callback callback,
2983         void *hook_pvt,
2984         ast_bridge_hook_pvt_destructor destructor,
2985         enum ast_bridge_hook_remove_flags remove_flags)
2986 {
2987         struct ast_bridge_hook_timer *hook;
2988         int res;
2989
2990         if (!features ||!interval || !callback) {
2991                 return -1;
2992         }
2993
2994         /* Allocate new hook and setup it's various variables */
2995         hook = (struct ast_bridge_hook_timer *) bridge_hook_generic(sizeof(*hook), callback,
2996                 hook_pvt, destructor, remove_flags);
2997         if (!hook) {
2998                 return -1;
2999         }
3000         hook->generic.type = AST_BRIDGE_HOOK_TYPE_TIMER;
3001         hook->timer.interval = interval;
3002         hook->timer.trip_time = ast_tvadd(ast_tvnow(), ast_samp2tv(interval, 1000));
3003         hook->timer.seqno = ast_atomic_fetchadd_int((int *) &features->interval_sequence, +1);
3004         hook->timer.flags = flags;
3005
3006         ast_debug(1, "Putting interval hook %p with interval %u in the heap on features %p\n",
3007                 hook, hook->timer.interval, features);
3008         ast_heap_wrlock(features->interval_hooks);
3009         res = ast_heap_push(features->interval_hooks, hook);
3010         ast_heap_unlock(features->interval_hooks);
3011         if (res) {
3012                 /*
3013                  * Could not push the hook into the heap
3014                  *
3015                  * Remove the hook_pvt destructor call from the hook since we
3016                  * are returning failure to install the hook.
3017                  */
3018                 hook->generic.destructor = NULL;
3019                 ao2_ref(hook, -1);
3020         }
3021
3022         return res ? -1 : 0;
3023 }
3024
3025 int ast_bridge_features_enable(struct ast_bridge_features *features,
3026         enum ast_bridge_builtin_feature feature,
3027         const char *dtmf,
3028         void *config,
3029         ast_bridge_hook_pvt_destructor destructor,
3030         enum ast_bridge_hook_remove_flags remove_flags)
3031 {
3032         if (ARRAY_LEN(builtin_features_handlers) <= feature
3033                 || !builtin_features_handlers[feature]) {
3034                 return -1;
3035         }
3036
3037         /* If no alternate DTMF stream was provided use the default one */
3038         if (ast_strlen_zero(dtmf)) {
3039                 dtmf = builtin_features_dtmf[feature];
3040                 /* If no DTMF is still available (ie: it has been disabled) then error out now */
3041                 if (ast_strlen_zero(dtmf)) {
3042                         ast_debug(1, "Failed to enable built in feature %d on %p, no DTMF string is available for it.\n",
3043                                 feature, features);
3044                         return -1;
3045                 }
3046         }
3047
3048         /*
3049          * The rest is basically pretty easy.  We create another hook
3050          * using the built in feature's DTMF callback.  Easy as pie.
3051          */
3052         return ast_bridge_dtmf_hook(features, dtmf, builtin_features_handlers[feature],
3053                 config, destructor, remove_flags);
3054 }
3055
3056 int ast_bridge_features_limits_construct(struct ast_bridge_features_limits *limits)
3057 {
3058         memset(limits, 0, sizeof(*limits));
3059
3060         if (ast_string_field_init(limits, 256)) {
3061                 return -1;
3062         }
3063
3064         return 0;
3065 }
3066
3067 void ast_bridge_features_limits_destroy(struct ast_bridge_features_limits *limits)
3068 {
3069         ast_string_field_free_memory(limits);
3070 }
3071
3072 int ast_bridge_features_set_limits(struct ast_bridge_features *features,
3073         struct ast_bridge_features_limits *limits,
3074         enum ast_bridge_hook_remove_flags remove_flags)
3075 {
3076         if (builtin_interval_handlers[AST_BRIDGE_BUILTIN_INTERVAL_LIMITS]) {
3077                 ast_bridge_builtin_set_limits_fn callback;
3078
3079                 callback = builtin_interval_handlers[AST_BRIDGE_BUILTIN_INTERVAL_LIMITS];
3080                 return callback(features, limits, remove_flags);
3081         }
3082
3083         ast_log(LOG_ERROR, "Attempted to set limits without an AST_BRIDGE_BUILTIN_INTERVAL_LIMITS callback registered.\n");
3084         return -1;
3085 }
3086
3087 void ast_bridge_features_set_flag(struct ast_bridge_features *features, unsigned int flag)
3088 {
3089         ast_set_flag(&features->feature_flags, flag);
3090         features->usable = 1;
3091 }
3092
3093 /*!
3094  * \internal
3095  * \brief ao2 object match hooks with appropriate remove_flags.
3096  * \since 12.0.0
3097  *
3098  * \param obj Feature hook object.
3099  * \param arg Removal flags
3100  * \param flags Not used
3101  *
3102  * \retval CMP_MATCH if hook's remove_flags match the removal flags set.
3103  * \retval 0 if not match.
3104  */
3105 static int hook_remove_match(void *obj, void *arg, int flags)
3106 {
3107         struct ast_bridge_hook *hook = obj;
3108         enum ast_bridge_hook_remove_flags *remove_flags = arg;
3109
3110         if (ast_test_flag(&hook->remove_flags, *remove_flags)) {
3111                 return CMP_MATCH;
3112         } else {
3113                 return 0;
3114         }
3115 }
3116
3117 /*!
3118  * \internal
3119  * \brief Remove all hooks with appropriate remove_flags in the container.
3120  * \since 12.0.0
3121  *
3122  * \param hooks Hooks container to work on.
3123  * \param remove_flags Determinator for whether hook is removed
3124  *
3125  * \return Nothing
3126  */
3127 static void hooks_remove_container(struct ao2_container *hooks, enum ast_bridge_hook_remove_flags remove_flags)
3128 {
3129         ao2_callback(hooks, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE,
3130                 hook_remove_match, &remove_flags);
3131 }
3132
3133 /*!
3134  * \internal
3135  * \brief Remove all hooks in the heap with appropriate remove_flags set.
3136  * \since 12.0.0
3137  *
3138  * \param hooks Hooks heap to work on.
3139  * \param remove_flags Determinator for whether hook is removed
3140  *
3141  * \return Nothing
3142  */
3143 static void hooks_remove_heap(struct ast_heap *hooks, enum ast_bridge_hook_remove_flags remove_flags)
3144 {
3145         struct ast_bridge_hook *hook;
3146         int changed;
3147
3148         ast_heap_wrlock(hooks);
3149         do {
3150                 int idx;
3151
3152                 changed = 0;
3153                 for (idx = ast_heap_size(hooks); idx; --idx) {
3154                         hook = ast_heap_peek(hooks, idx);
3155                         if (ast_test_flag(&hook->remove_flags, remove_flags)) {
3156                                 ast_heap_remove(hooks, hook);
3157                                 ao2_ref(hook, -1);
3158                                 changed = 1;
3159                         }
3160                 }
3161         } while (changed);
3162         ast_heap_unlock(hooks);
3163 }
3164
3165 void ast_bridge_features_remove(struct ast_bridge_features *features, enum ast_bridge_hook_remove_flags remove_flags)
3166 {
3167         hooks_remove_container(features->dtmf_hooks, remove_flags);
3168         hooks_remove_container(features->other_hooks, remove_flags);
3169         hooks_remove_heap(features->interval_hooks, remove_flags);
3170 }
3171
3172 static int interval_hook_time_cmp(void *a, void *b)
3173 {
3174         struct ast_bridge_hook_timer *hook_a = a;
3175         struct ast_bridge_hook_timer *hook_b = b;
3176         int cmp;
3177
3178         cmp = ast_tvcmp(hook_b->timer.trip_time, hook_a->timer.trip_time);
3179         if (cmp) {
3180                 return cmp;
3181         }
3182
3183         cmp = hook_b->timer.seqno - hook_a->timer.seqno;
3184         return cmp;
3185 }
3186
3187 /*!
3188  * \internal
3189  * \brief DTMF hook container sort comparison function.
3190  * \since 12.0.0
3191  *
3192  * \param obj_left pointer to the (user-defined part) of an object.
3193  * \param obj_right pointer to the (user-defined part) of an object.
3194  * \param flags flags from ao2_callback()
3195  *   OBJ_POINTER - if set, 'obj_right', is an object.
3196  *   OBJ_KEY - if set, 'obj_right', is a search key item that is not an object.
3197  *   OBJ_PARTIAL_KEY - if set, 'obj_right', is a partial search key item that is not an object.
3198  *
3199  * \retval <0 if obj_left < obj_right
3200  * \retval =0 if obj_left == obj_right
3201  * \retval >0 if obj_left > obj_right
3202  */
3203 static int bridge_dtmf_hook_sort(const void *obj_left, const void *obj_right, int flags)
3204 {
3205         const struct ast_bridge_hook_dtmf *hook_left = obj_left;
3206         const struct ast_bridge_hook_dtmf *hook_right = obj_right;
3207         const char *right_key = obj_right;
3208         int cmp;
3209
3210         switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
3211         default:
3212         case OBJ_POINTER:
3213                 right_key = hook_right->dtmf.code;
3214                 /* Fall through */
3215         case OBJ_KEY:
3216                 cmp = strcasecmp(hook_left->dtmf.code, right_key);
3217                 break;
3218         case OBJ_PARTIAL_KEY:
3219                 cmp = strncasecmp(hook_left->dtmf.code, right_key, strlen(right_key));
3220                 break;
3221         }
3222         return cmp;
3223 }
3224
3225 /* XXX ASTERISK-21271 make ast_bridge_features_init() static when make ast_bridge_join() requires features to be allocated. */
3226 int ast_bridge_features_init(struct ast_bridge_features *features)
3227 {
3228         /* Zero out the structure */
3229         memset(features, 0, sizeof(*features));
3230
3231         /* Initialize the DTMF hooks container */
3232         features->dtmf_hooks = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX,
3233                 AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE, bridge_dtmf_hook_sort, NULL);
3234         if (!features->dtmf_hooks) {
3235                 return -1;
3236         }
3237
3238         /* Initialize the miscellaneous other hooks container */
3239         features->other_hooks = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL,
3240                 NULL);
3241         if (!features->other_hooks) {
3242                 return -1;
3243         }
3244
3245         /* Initialize the interval hooks heap */
3246         features->interval_hooks = ast_heap_create(8, interval_hook_time_cmp,
3247                 offsetof(struct ast_bridge_hook_timer, timer.heap_index));
3248         if (!features->interval_hooks) {
3249                 return -1;
3250         }
3251
3252         features->dtmf_passthrough = 1;
3253
3254         return 0;
3255 }
3256
3257 /* XXX ASTERISK-21271 make ast_bridge_features_cleanup() static when make ast_bridge_join() requires features to be allocated. */
3258 void ast_bridge_features_cleanup(struct ast_bridge_features *features)
3259 {
3260         struct ast_bridge_hook_timer *hook;
3261
3262         /* Destroy the interval hooks heap. */
3263         if (features->interval_hooks) {
3264                 while ((hook = ast_heap_pop(features->interval_hooks))) {
3265                         ao2_ref(hook, -1);
3266                 }
3267                 features->interval_hooks = ast_heap_destroy(features->interval_hooks);
3268         }
3269
3270         /* Destroy the miscellaneous other hooks container. */
3271         ao2_cleanup(features->other_hooks);
3272         features->other_hooks = NULL;
3273
3274         /* Destroy the DTMF hooks container. */
3275         ao2_cleanup(features->dtmf_hooks);
3276         features->dtmf_hooks = NULL;
3277 }
3278
3279 void ast_bridge_features_destroy(struct ast_bridge_features *features)
3280 {
3281         if (!features) {
3282                 return;
3283         }
3284         ast_bridge_features_cleanup(features);
3285         ast_free(features);
3286 }
3287
3288 struct ast_bridge_features *ast_bridge_features_new(void)
3289 {
3290         struct ast_bridge_features *features;
3291
3292         features = ast_malloc(sizeof(*features));
3293         if (features) {
3294                 if (ast_bridge_features_init(features)) {
3295                         ast_bridge_features_destroy(features);
3296                         features = NULL;
3297                 }
3298         }
3299
3300         return features;
3301 }
3302
3303 void ast_bridge_set_mixing_interval(struct ast_bridge *bridge, unsigned int mixing_interval)
3304 {
3305         ast_bridge_lock(bridge);
3306         bridge->softmix.internal_mixing_interval = mixing_interval;
3307         ast_bridge_unlock(bridge);
3308 }
3309
3310 void ast_bridge_set_internal_sample_rate(struct ast_bridge *bridge, unsigned int sample_rate)
3311 {
3312         ast_bridge_lock(bridge);
3313         bridge->softmix.internal_sample_rate = sample_rate;
3314         ast_bridge_unlock(bridge);
3315 }
3316
3317 static void cleanup_video_mode(struct ast_bridge *bridge)
3318 {
3319         switch (bridge->softmix.video_mode.mode) {
3320         case AST_BRIDGE_VIDEO_MODE_NONE:
3321                 break;
3322         case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC:
3323                 if (bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc) {
3324                         ast_channel_unref(bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc);
3325                 }
3326                 break;
3327         case AST_BRIDGE_VIDEO_MODE_TALKER_SRC:
3328                 if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc) {
3329                         ast_channel_unref(bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc);
3330                 }
3331                 if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc) {
3332                         ast_channel_unref(bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc);
3333                 }
3334         }
3335         memset(&bridge->softmix.video_mode, 0, sizeof(bridge->softmix.video_mode));
3336 }
3337
3338 void ast_bridge_set_single_src_video_mode(struct ast_bridge *bridge, struct ast_channel *video_src_chan)
3339 {
3340         ast_bridge_lock(bridge);
3341         cleanup_video_mode(bridge);
3342         bridge->softmix.video_mode.mode = AST_BRIDGE_VIDEO_MODE_SINGLE_SRC;
3343         bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc = ast_channel_ref(video_src_chan);
3344         ast_test_suite_event_notify("BRIDGE_VIDEO_MODE", "Message: video mode set to single source\r\nVideo Mode: %d\r\nVideo Channel: %s",
3345                 bridge->softmix.video_mode.mode, ast_channel_name(video_src_chan));
3346         ast_indicate(video_src_chan, AST_CONTROL_VIDUPDATE);
3347         ast_bridge_unlock(bridge);
3348 }
3349
3350 void ast_bridge_set_talker_src_video_mode(struct ast_bridge *bridge)
3351 {
3352         ast_bridge_lock(bridge);
3353         cleanup_video_mode(bridge);
3354         bridge->softmix.video_mode.mode = AST_BRIDGE_VIDEO_MODE_TALKER_SRC;
3355         ast_test_suite_event_notify("BRIDGE_VIDEO_MODE", "Message: video mode set to talker source\r\nVideo Mode: %d",
3356                 bridge->softmix.video_mode.mode);
3357         ast_bridge_unlock(bridge);
3358 }
3359
3360 void ast_bridge_update_talker_src_video_mode(struct ast_bridge *bridge, struct ast_channel *chan, int talker_energy, int is_keyframe)
3361 {
3362         struct ast_bridge_video_talker_src_data *data;
3363
3364         /* If the channel doesn't support video, we don't care about it */
3365         if (!ast_format_cap_has_type(ast_channel_nativeformats(chan), AST_FORMAT_TYPE_VIDEO)) {
3366                 return;
3367         }
3368
3369         ast_bridge_lock(bridge);
3370         data = &bridge->softmix.video_mode.mode_data.talker_src_data;
3371
3372         if (data->chan_vsrc == chan) {
3373                 data->average_talking_energy = talker_energy;
3374         } else if ((data->average_talking_energy < talker_energy) && is_keyframe) {
3375                 if (data->chan_old_vsrc) {
3376                         ast_channel_unref(data->chan_old_vsrc);
3377                 }
3378                 if (data->chan_vsrc) {
3379                         data->chan_old_vsrc = data->chan_vsrc;
3380                         ast_indicate(data->chan_old_vsrc, AST_CONTROL_VIDUPDATE);
3381                 }
3382                 data->chan_vsrc = ast_channel_ref(chan);
3383                 data->average_talking_energy = talker_energy;
3384                 ast_test_suite_event_notify("BRIDGE_VIDEO_SRC", "Message: video source updated\r\nVideo Channel: %s", ast_channel_name(data->chan_vsrc));
3385                 ast_indicate(data->chan_vsrc, AST_CONTROL_VIDUPDATE);
3386         } else if ((data->average_talking_energy < talker_energy) && !is_keyframe) {
3387                 ast_indicate(chan, AST_CONTROL_VIDUPDATE);
3388         } else if (!data->chan_vsrc && is_keyframe) {
3389                 data->chan_vsrc = ast_channel_ref(chan);
3390                 data->average_talking_energy = talker_energy;
3391                 ast_test_suite_event_notify("BRIDGE_VIDEO_SRC", "Message: video source updated\r\nVideo Channel: %s", ast_channel_name(data->chan_vsrc));
3392                 ast_indicate(chan, AST_CONTROL_VIDUPDATE);
3393         } else if (!data->chan_old_vsrc && is_keyframe) {
3394                 data->chan_old_vsrc = ast_channel_ref(chan);
3395                 ast_indicate(chan, AST_CONTROL_VIDUPDATE);
3396         }
3397         ast_bridge_unlock(bridge);
3398 }
3399
3400 int ast_bridge_number_video_src(struct ast_bridge *bridge)
3401 {
3402         int res = 0;
3403
3404         ast_bridge_lock(bridge);
3405         switch (bridge->softmix.video_mode.mode) {