Bridging: Fix orphaned bridge if neither of the joining channels can join.
[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         ast_channel_stage_snapshot(chan);
1155         pbx_builtin_setvar_helper(chan, "BRIDGEPEER", name);
1156         pbx_builtin_setvar_helper(chan, "BRIDGEPVTCALLID", pvtid);
1157         ast_channel_stage_snapshot_done(chan);
1158 }
1159
1160 /*!
1161  * \internal
1162  * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in a 2 party bridge.
1163  * \since 12.0.0
1164  *
1165  * \param c0 Party of the first part.
1166  * \param c1 Party of the second part.
1167  *
1168  * \note On entry, the bridge is already locked.
1169  * \note The bridge is expected to have exactly two parties.
1170  *
1171  * \return Nothing
1172  */
1173 static void set_bridge_peer_vars_2party(struct ast_channel *c0, struct ast_channel *c1)
1174 {
1175         const char *c0_name;
1176         const char *c1_name;
1177         const char *c0_pvtid = NULL;
1178         const char *c1_pvtid = NULL;
1179 #define UPDATE_BRIDGE_VARS_GET(chan, name, pvtid)                                                                       \
1180         do {                                                                                                                                                    \
1181                 name = ast_strdupa(ast_channel_name(chan));                                                                     \
1182                 if (ast_channel_tech(chan)->get_pvt_uniqueid) {                                                         \
1183                         pvtid = ast_strdupa(ast_channel_tech(chan)->get_pvt_uniqueid(chan));    \
1184                 }                                                                                                                                                       \
1185         } while (0)
1186
1187         ast_channel_lock(c1);
1188         UPDATE_BRIDGE_VARS_GET(c1, c1_name, c1_pvtid);
1189         ast_channel_unlock(c1);
1190
1191         ast_channel_lock(c0);
1192         update_bridge_vars_set(c0, c1_name, c1_pvtid);
1193         UPDATE_BRIDGE_VARS_GET(c0, c0_name, c0_pvtid);
1194         ast_channel_unlock(c0);
1195
1196         ast_channel_lock(c1);
1197         update_bridge_vars_set(c1, c0_name, c0_pvtid);
1198         ast_channel_unlock(c1);
1199 }
1200
1201 /*!
1202  * \internal
1203  * \brief Fill the BRIDGEPEER value buffer with a comma separated list of channel names.
1204  * \since 12.0.0
1205  *
1206  * \param buf Buffer to fill.  The caller must guarantee the buffer is large enough.
1207  * \param cur_idx Which index into names[] to skip.
1208  * \param names Channel names to put in the buffer.
1209  * \param num_names Number of names in the array.
1210  *
1211  * \return Nothing
1212  */
1213 static void fill_bridgepeer_buf(char *buf, unsigned int cur_idx, const char *names[], unsigned int num_names)
1214 {
1215         int need_separator = 0;
1216         unsigned int idx;
1217         const char *src;
1218         char *pos;
1219
1220         pos = buf;
1221         for (idx = 0; idx < num_names; ++idx) {
1222                 if (idx == cur_idx) {
1223                         continue;
1224                 }
1225
1226                 if (need_separator) {
1227                         *pos++ = ',';
1228                 }
1229                 need_separator = 1;
1230
1231                 /* Copy name into buffer. */
1232                 src = names[idx];
1233                 while (*src) {
1234                         *pos++ = *src++;
1235                 }
1236         }
1237         *pos = '\0';
1238 }
1239
1240 /*!
1241  * \internal
1242  * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in a multi-party bridge.
1243  * \since 12.0.0
1244  *
1245  * \param bridge What to operate on.
1246  *
1247  * \note On entry, the bridge is already locked.
1248  * \note The bridge is expected to have more than two parties.
1249  *
1250  * \return Nothing
1251  */
1252 static void set_bridge_peer_vars_multiparty(struct ast_bridge *bridge)
1253 {
1254 /*
1255  * Set a maximum number of channel names for the BRIDGEPEER
1256  * list.  The plus one is for the current channel which is not
1257  * put in the list.
1258  */
1259 #define MAX_BRIDGEPEER_CHANS    (10 + 1)
1260
1261         unsigned int idx;
1262         unsigned int num_names;
1263         unsigned int len;
1264         const char **names;
1265         char *buf;
1266         struct ast_bridge_channel *bridge_channel;
1267
1268         /* Get first MAX_BRIDGEPEER_CHANS channel names. */
1269         num_names = MIN(bridge->num_channels, MAX_BRIDGEPEER_CHANS);
1270         names = ast_alloca(num_names * sizeof(*names));
1271         idx = 0;
1272         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1273                 if (num_names <= idx) {
1274                         break;
1275                 }
1276                 ast_channel_lock(bridge_channel->chan);
1277                 names[idx++] = ast_strdupa(ast_channel_name(bridge_channel->chan));
1278                 ast_channel_unlock(bridge_channel->chan);
1279         }
1280
1281         /* Determine maximum buf size needed. */
1282         len = num_names;
1283         for (idx = 0; idx < num_names; ++idx) {
1284                 len += strlen(names[idx]);
1285         }
1286         buf = ast_alloca(len);
1287
1288         /* Set the bridge channel variables. */
1289         idx = 0;
1290         buf[0] = '\0';
1291         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1292                 if (idx < num_names) {
1293                         fill_bridgepeer_buf(buf, idx, names, num_names);
1294                 }
1295                 ++idx;
1296
1297                 ast_channel_lock(bridge_channel->chan);
1298                 update_bridge_vars_set(bridge_channel->chan, buf, NULL);
1299                 ast_channel_unlock(bridge_channel->chan);
1300         }
1301 }
1302
1303 /*!
1304  * \internal
1305  * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in a holding bridge.
1306  * \since 12.0.0
1307  *
1308  * \param bridge What to operate on.
1309  *
1310  * \note On entry, the bridge is already locked.
1311  *
1312  * \return Nothing
1313  */
1314 static void set_bridge_peer_vars_holding(struct ast_bridge *bridge)
1315 {
1316         struct ast_bridge_channel *bridge_channel;
1317
1318         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1319                 ast_channel_lock(bridge_channel->chan);
1320                 update_bridge_vars_set(bridge_channel->chan, NULL, NULL);
1321                 ast_channel_unlock(bridge_channel->chan);
1322         }
1323 }
1324
1325 /*!
1326  * \internal
1327  * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in the bridge.
1328  * \since 12.0.0
1329  *
1330  * \param bridge What to operate on.
1331  *
1332  * \note On entry, the bridge is already locked.
1333  *
1334  * \return Nothing
1335  */
1336 static void set_bridge_peer_vars(struct ast_bridge *bridge)
1337 {
1338         if (bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_HOLDING) {
1339                 set_bridge_peer_vars_holding(bridge);
1340                 return;
1341         }
1342         if (bridge->num_channels < 2) {
1343                 return;
1344         }
1345         if (bridge->num_channels == 2) {
1346                 set_bridge_peer_vars_2party(AST_LIST_FIRST(&bridge->channels)->chan,
1347                         AST_LIST_LAST(&bridge->channels)->chan);
1348         } else {
1349                 set_bridge_peer_vars_multiparty(bridge);
1350         }
1351 }
1352
1353 void bridge_reconfigured(struct ast_bridge *bridge, unsigned int colp_update)
1354 {
1355         if (!bridge->reconfigured) {
1356                 return;
1357         }
1358         bridge->reconfigured = 0;
1359         if (ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_SMART)
1360                 && smart_bridge_operation(bridge)) {
1361                 /* Smart bridge failed. */
1362                 bridge_dissolve(bridge, 0);
1363                 return;
1364         }
1365         bridge_complete_join(bridge);
1366
1367         if (bridge->dissolved) {
1368                 return;
1369         }
1370         check_bridge_play_sounds(bridge);
1371         set_bridge_peer_vars(bridge);
1372         ast_bridge_publish_state(bridge);
1373
1374         if (colp_update) {
1375                 bridge_reconfigured_connected_line_update(bridge);
1376         }
1377 }
1378
1379 struct ast_bridge_channel *bridge_find_channel(struct ast_bridge *bridge, struct ast_channel *chan)
1380 {
1381         struct ast_bridge_channel *bridge_channel;
1382
1383         AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
1384                 if (bridge_channel->chan == chan) {
1385                         break;
1386                 }
1387         }
1388
1389         return bridge_channel;
1390 }
1391
1392 void ast_bridge_notify_masquerade(struct ast_channel *chan)
1393 {
1394         struct ast_bridge_channel *bridge_channel;
1395         struct ast_bridge *bridge;
1396
1397         /* Safely get the bridge_channel pointer for the chan. */
1398         ast_channel_lock(chan);
1399         bridge_channel = ast_channel_get_bridge_channel(chan);
1400         ast_channel_unlock(chan);
1401         if (!bridge_channel) {
1402                 /* Not in a bridge */
1403                 return;
1404         }
1405
1406         ast_bridge_channel_lock_bridge(bridge_channel);
1407         bridge = bridge_channel->bridge;
1408         if (bridge_channel == bridge_find_channel(bridge, chan)) {
1409 /*
1410  * XXX ASTERISK-22366 this needs more work.  The channels need
1411  * to be made compatible again if the formats change. The
1412  * bridge_channel thread needs to monitor for this case.
1413  */
1414                 /* The channel we want to notify is still in a bridge. */
1415                 bridge->v_table->notify_masquerade(bridge, bridge_channel);
1416                 bridge_reconfigured(bridge, 1);
1417         }
1418         ast_bridge_unlock(bridge);
1419         ao2_ref(bridge_channel, -1);
1420 }
1421
1422 /*
1423  * XXX ASTERISK-21271 make ast_bridge_join() require features to be allocated just like ast_bridge_impart() and not expect the struct back.
1424  *
1425  * This change is really going to break ConfBridge.  All other
1426  * users are easily changed.  However, it is needed so the
1427  * bridging code can manipulate features on all channels
1428  * consistently no matter how they joined.
1429  *
1430  * Need to update the features parameter doxygen when this
1431  * change is made to be like ast_bridge_impart().
1432  */
1433 int ast_bridge_join(struct ast_bridge *bridge,
1434         struct ast_channel *chan,
1435         struct ast_channel *swap,
1436         struct ast_bridge_features *features,
1437         struct ast_bridge_tech_optimizations *tech_args,
1438         enum ast_bridge_join_flags flags)
1439 {
1440         struct ast_bridge_channel *bridge_channel;
1441         int res = 0;
1442
1443         bridge_channel = bridge_channel_internal_alloc(bridge);
1444         if (flags & AST_BRIDGE_JOIN_PASS_REFERENCE) {
1445                 ao2_ref(bridge, -1);
1446         }
1447         if (!bridge_channel) {
1448                 res = -1;
1449                 goto join_exit;
1450         }
1451 /* 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. */
1452         ast_assert(features != NULL);
1453         if (!features) {
1454                 ao2_ref(bridge_channel, -1);
1455                 res = -1;
1456                 goto join_exit;
1457         }
1458         if (tech_args) {
1459                 bridge_channel->tech_args = *tech_args;
1460         }
1461
1462         ast_channel_lock(chan);
1463         if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_ZOMBIE)) {
1464                 res = -1;
1465         } else {
1466                 ast_channel_internal_bridge_channel_set(chan, bridge_channel);
1467         }
1468         ast_channel_unlock(chan);
1469         bridge_channel->thread = pthread_self();
1470         bridge_channel->chan = chan;
1471         bridge_channel->swap = swap;
1472         bridge_channel->features = features;
1473         bridge_channel->inhibit_colp = !!(flags & AST_BRIDGE_JOIN_INHIBIT_JOIN_COLP);
1474
1475         if (!res) {
1476                 res = bridge_channel_internal_join(bridge_channel);
1477         }
1478
1479         /* Cleanup all the data in the bridge channel after it leaves the bridge. */
1480         ast_channel_lock(chan);
1481         ast_channel_internal_bridge_channel_set(chan, NULL);
1482         ast_channel_unlock(chan);
1483         bridge_channel->chan = NULL;
1484         bridge_channel->swap = NULL;
1485         bridge_channel->features = NULL;
1486
1487         ao2_ref(bridge_channel, -1);
1488
1489 join_exit:;
1490         ast_bridge_run_after_callback(chan);
1491         if (!(ast_channel_softhangup_internal_flag(chan) & AST_SOFTHANGUP_ASYNCGOTO)
1492                 && !ast_bridge_setup_after_goto(chan)) {
1493                 /* Claim the after bridge goto is an async goto destination. */
1494                 ast_channel_lock(chan);
1495                 ast_softhangup_nolock(chan, AST_SOFTHANGUP_ASYNCGOTO);
1496                 ast_channel_unlock(chan);
1497         }
1498         return res;
1499 }
1500
1501 /*! \brief Thread responsible for imparted bridged channels to be departed */
1502 static void *bridge_channel_depart_thread(void *data)
1503 {
1504         struct ast_bridge_channel *bridge_channel = data;
1505
1506         if (bridge_channel->callid) {
1507                 ast_callid_threadassoc_add(bridge_channel->callid);
1508         }
1509
1510         bridge_channel_internal_join(bridge_channel);
1511
1512         /* cleanup */
1513         bridge_channel->swap = NULL;
1514         ast_bridge_features_destroy(bridge_channel->features);
1515         bridge_channel->features = NULL;
1516
1517         ast_bridge_discard_after_callback(bridge_channel->chan, AST_BRIDGE_AFTER_CB_REASON_DEPART);
1518         ast_bridge_discard_after_goto(bridge_channel->chan);
1519
1520         return NULL;
1521 }
1522
1523 /*! \brief Thread responsible for independent imparted bridged channels */
1524 static void *bridge_channel_ind_thread(void *data)
1525 {
1526         struct ast_bridge_channel *bridge_channel = data;
1527         struct ast_channel *chan;
1528
1529         if (bridge_channel->callid) {
1530                 ast_callid_threadassoc_add(bridge_channel->callid);
1531         }
1532
1533         bridge_channel_internal_join(bridge_channel);
1534         chan = bridge_channel->chan;
1535
1536         /* cleanup */
1537         ast_channel_lock(chan);
1538         ast_channel_internal_bridge_channel_set(chan, NULL);
1539         ast_channel_unlock(chan);
1540         bridge_channel->chan = NULL;
1541         bridge_channel->swap = NULL;
1542         ast_bridge_features_destroy(bridge_channel->features);
1543         bridge_channel->features = NULL;
1544
1545         ao2_ref(bridge_channel, -1);
1546
1547         ast_bridge_run_after_callback(chan);
1548         ast_bridge_run_after_goto(chan);
1549         return NULL;
1550 }
1551
1552 int ast_bridge_impart(struct ast_bridge *bridge,
1553         struct ast_channel *chan,
1554         struct ast_channel *swap,
1555         struct ast_bridge_features *features,
1556         enum ast_bridge_impart_flags flags)
1557 {
1558         int res = 0;
1559         struct ast_bridge_channel *bridge_channel;
1560
1561         /* Imparted channels cannot have a PBX. */
1562         if (ast_channel_pbx(chan)) {
1563                 ast_log(AST_LOG_WARNING, "Channel %s has a PBX thread and cannot be imparted into bridge %s\n",
1564                         ast_channel_name(chan), bridge->uniqueid);
1565                 return -1;
1566         }
1567
1568         /* Supply an empty features structure if the caller did not. */
1569         if (!features) {
1570                 features = ast_bridge_features_new();
1571                 if (!features) {
1572                         return -1;
1573                 }
1574         }
1575
1576         /* Try to allocate a structure for the bridge channel */
1577         bridge_channel = bridge_channel_internal_alloc(bridge);
1578         if (!bridge_channel) {
1579                 ast_bridge_features_destroy(features);
1580                 return -1;
1581         }
1582
1583         ast_channel_lock(chan);
1584         if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_ZOMBIE)) {
1585                 ast_log(AST_LOG_NOTICE, "Channel %s is a zombie and cannot be imparted into bridge %s\n",
1586                         ast_channel_name(chan), bridge->uniqueid);
1587                 res = -1;
1588         } else {
1589                 ast_channel_internal_bridge_channel_set(chan, bridge_channel);
1590         }
1591         ast_channel_unlock(chan);
1592         bridge_channel->chan = chan;
1593         bridge_channel->swap = swap;
1594         bridge_channel->features = features;
1595         bridge_channel->inhibit_colp = !!(flags & AST_BRIDGE_IMPART_INHIBIT_JOIN_COLP);
1596         bridge_channel->depart_wait =
1597                 (flags & AST_BRIDGE_IMPART_CHAN_MASK) == AST_BRIDGE_IMPART_CHAN_DEPARTABLE;
1598         bridge_channel->callid = ast_read_threadstorage_callid();
1599
1600         /* Actually create the thread that will handle the channel */
1601         if (!res) {
1602                 if ((flags & AST_BRIDGE_IMPART_CHAN_MASK) == AST_BRIDGE_IMPART_CHAN_INDEPENDENT) {
1603                         res = ast_pthread_create_detached(&bridge_channel->thread, NULL,
1604                                 bridge_channel_ind_thread, bridge_channel);
1605                 } else {
1606                         res = ast_pthread_create(&bridge_channel->thread, NULL,
1607                                 bridge_channel_depart_thread, bridge_channel);
1608                 }
1609         }
1610
1611         if (res) {
1612                 /* cleanup */
1613                 ast_channel_lock(chan);
1614                 ast_channel_internal_bridge_channel_set(chan, NULL);
1615                 ast_channel_unlock(chan);
1616                 bridge_channel->chan = NULL;
1617                 bridge_channel->swap = NULL;
1618                 ast_bridge_features_destroy(bridge_channel->features);
1619                 bridge_channel->features = NULL;
1620
1621                 ao2_ref(bridge_channel, -1);
1622                 return -1;
1623         }
1624
1625         return 0;
1626 }
1627
1628 int ast_bridge_depart(struct ast_channel *chan)
1629 {
1630         struct ast_bridge_channel *bridge_channel;
1631         int departable;
1632
1633         ast_channel_lock(chan);
1634         bridge_channel = ast_channel_internal_bridge_channel(chan);
1635         departable = bridge_channel && bridge_channel->depart_wait;
1636         ast_channel_unlock(chan);
1637         if (!departable) {
1638                 ast_log(LOG_ERROR, "Channel %s cannot be departed.\n",
1639                         ast_channel_name(chan));
1640                 /*
1641                  * Should never happen.  It likely means that
1642                  * ast_bridge_depart() is called by two threads for the same
1643                  * channel, the channel was never imparted to be departed, or it
1644                  * has already been departed.
1645                  */
1646                 ast_assert(0);
1647                 return -1;
1648         }
1649
1650         /*
1651          * We are claiming the reference held by the depart bridge
1652          * channel thread.
1653          */
1654
1655         ast_bridge_channel_leave_bridge(bridge_channel,
1656                 BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, AST_CAUSE_NORMAL_CLEARING);
1657
1658         /* Wait for the depart thread to die */
1659         ast_debug(1, "Waiting for %p(%s) bridge thread to die.\n",
1660                 bridge_channel, ast_channel_name(bridge_channel->chan));
1661         pthread_join(bridge_channel->thread, NULL);
1662
1663         ast_channel_lock(chan);
1664         ast_channel_internal_bridge_channel_set(chan, NULL);
1665         ast_channel_unlock(chan);
1666
1667         /* We can get rid of the bridge_channel after the depart thread has died. */
1668         ao2_ref(bridge_channel, -1);
1669         return 0;
1670 }
1671
1672 int ast_bridge_remove(struct ast_bridge *bridge, struct ast_channel *chan)
1673 {
1674         struct ast_bridge_channel *bridge_channel;
1675
1676         ast_bridge_lock(bridge);
1677
1678         /* Try to find the channel that we want to remove */
1679         if (!(bridge_channel = bridge_find_channel(bridge, chan))) {
1680                 ast_bridge_unlock(bridge);
1681                 return -1;
1682         }
1683
1684         ast_bridge_channel_leave_bridge(bridge_channel,
1685                 BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, AST_CAUSE_NORMAL_CLEARING);
1686
1687         ast_bridge_unlock(bridge);
1688
1689         return 0;
1690 }
1691
1692 static void kick_it(struct ast_bridge_channel *bridge_channel, const void *payload, size_t payload_size)
1693 {
1694         ast_bridge_channel_kick(bridge_channel, AST_CAUSE_NORMAL_CLEARING);
1695 }
1696
1697 int ast_bridge_kick(struct ast_bridge *bridge, struct ast_channel *chan)
1698 {
1699         struct ast_bridge_channel *bridge_channel;
1700         int res;
1701
1702         ast_bridge_lock(bridge);
1703
1704         /* Try to find the channel that we want to kick. */
1705         if (!(bridge_channel = bridge_find_channel(bridge, chan))) {
1706                 ast_bridge_unlock(bridge);
1707                 return -1;
1708         }
1709
1710         res = ast_bridge_channel_queue_callback(bridge_channel, 0, kick_it, NULL, 0);
1711
1712         ast_bridge_unlock(bridge);
1713
1714         return res;
1715 }
1716
1717 /*!
1718  * \internal
1719  * \brief Point the bridge_channel to a new bridge.
1720  * \since 12.0.0
1721  *
1722  * \param bridge_channel What is to point to a new bridge.
1723  * \param new_bridge Where the bridge channel should point.
1724  *
1725  * \return Nothing
1726  */
1727 static void bridge_channel_change_bridge(struct ast_bridge_channel *bridge_channel, struct ast_bridge *new_bridge)
1728 {
1729         struct ast_bridge *old_bridge;
1730
1731         ao2_ref(new_bridge, +1);
1732         ast_bridge_channel_lock(bridge_channel);
1733         ast_channel_lock(bridge_channel->chan);
1734         old_bridge = bridge_channel->bridge;
1735         bridge_channel->bridge = new_bridge;
1736         ast_channel_internal_bridge_set(bridge_channel->chan, new_bridge);
1737         ast_channel_unlock(bridge_channel->chan);
1738         ast_bridge_channel_unlock(bridge_channel);
1739         ao2_ref(old_bridge, -1);
1740 }
1741
1742 void bridge_do_merge(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, struct ast_bridge_channel **kick_me, unsigned int num_kick,
1743         unsigned int optimized)
1744 {
1745         struct ast_bridge_channel *bridge_channel;
1746         unsigned int idx;
1747
1748         ast_debug(1, "Merging bridge %s into bridge %s\n",
1749                 src_bridge->uniqueid, dst_bridge->uniqueid);
1750
1751         ast_bridge_publish_merge(dst_bridge, src_bridge);
1752
1753         /*
1754          * Move channels from src_bridge over to dst_bridge.
1755          *
1756          * We must use AST_LIST_TRAVERSE_SAFE_BEGIN() because
1757          * bridge_channel_internal_pull() alters the list we are traversing.
1758          */
1759         AST_LIST_TRAVERSE_SAFE_BEGIN(&src_bridge->channels, bridge_channel, entry) {
1760                 if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
1761                         /*
1762                          * The channel is already leaving let it leave normally because
1763                          * pulling it may delete hooks that should run for this channel.
1764                          */
1765                         continue;
1766                 }
1767                 if (ast_test_flag(&bridge_channel->features->feature_flags,
1768                         AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE)) {
1769                         continue;
1770                 }
1771
1772                 if (kick_me) {
1773                         for (idx = 0; idx < num_kick; ++idx) {
1774                                 if (bridge_channel == kick_me[idx]) {
1775                                         ast_bridge_channel_leave_bridge(bridge_channel,
1776                                                 BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, AST_CAUSE_NORMAL_CLEARING);
1777                                         break;
1778                                 }
1779                         }
1780                 }
1781                 bridge_channel_internal_pull(bridge_channel);
1782                 if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
1783                         /*
1784                          * The channel died as a result of being pulled or it was
1785                          * kicked.  Leave it pointing to the original bridge.
1786                          */
1787                         continue;
1788                 }
1789
1790                 /* Point to new bridge.*/
1791                 bridge_channel_change_bridge(bridge_channel, dst_bridge);
1792
1793                 if (bridge_channel_internal_push(bridge_channel)) {
1794                         ast_bridge_features_remove(bridge_channel->features,
1795                                 AST_BRIDGE_HOOK_REMOVE_ON_PULL);
1796                         ast_bridge_channel_leave_bridge(bridge_channel,
1797                                 BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, bridge_channel->bridge->cause);
1798                 }
1799         }
1800         AST_LIST_TRAVERSE_SAFE_END;
1801
1802         if (kick_me) {
1803                 /*
1804                  * Now we can kick any channels in the dst_bridge without
1805                  * potentially dissolving the bridge.
1806                  */
1807                 for (idx = 0; idx < num_kick; ++idx) {
1808                         bridge_channel = kick_me[idx];
1809                         ast_bridge_channel_lock(bridge_channel);
1810                         if (bridge_channel->state == BRIDGE_CHANNEL_STATE_WAIT) {
1811                                 ast_bridge_channel_leave_bridge_nolock(bridge_channel,
1812                                         BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, AST_CAUSE_NORMAL_CLEARING);
1813                                 bridge_channel_internal_pull(bridge_channel);
1814                         }
1815                         ast_bridge_channel_unlock(bridge_channel);
1816                 }
1817         }
1818
1819         bridge_reconfigured(dst_bridge, !optimized);
1820         bridge_reconfigured(src_bridge, !optimized);
1821
1822         ast_debug(1, "Merged bridge %s into bridge %s\n",
1823                 src_bridge->uniqueid, dst_bridge->uniqueid);
1824 }
1825
1826 struct merge_direction {
1827         /*! Destination merge bridge. */
1828         struct ast_bridge *dest;
1829         /*! Source merge bridge. */
1830         struct ast_bridge *src;
1831 };
1832
1833 /*!
1834  * \internal
1835  * \brief Determine which bridge should merge into the other.
1836  * \since 12.0.0
1837  *
1838  * \param bridge1 A bridge for merging
1839  * \param bridge2 A bridge for merging
1840  *
1841  * \note The two bridges are assumed already locked.
1842  *
1843  * \return Which bridge merges into which or NULL bridges if cannot merge.
1844  */
1845 static struct merge_direction bridge_merge_determine_direction(struct ast_bridge *bridge1, struct ast_bridge *bridge2)
1846 {
1847         struct merge_direction merge = { NULL, NULL };
1848         int bridge1_priority;
1849         int bridge2_priority;
1850
1851         if (!ast_test_flag(&bridge1->feature_flags,
1852                         AST_BRIDGE_FLAG_MERGE_INHIBIT_TO | AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)
1853                 && !ast_test_flag(&bridge2->feature_flags,
1854                         AST_BRIDGE_FLAG_MERGE_INHIBIT_TO | AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
1855                 /*
1856                  * Can merge either way.  Merge to the higher priority merge
1857                  * bridge.  Otherwise merge to the larger bridge.
1858                  */
1859                 bridge1_priority = bridge1->v_table->get_merge_priority(bridge1);
1860                 bridge2_priority = bridge2->v_table->get_merge_priority(bridge2);
1861                 if (bridge2_priority < bridge1_priority) {
1862                         merge.dest = bridge1;
1863                         merge.src = bridge2;
1864                 } else if (bridge1_priority < bridge2_priority) {
1865                         merge.dest = bridge2;
1866                         merge.src = bridge1;
1867                 } else {
1868                         /* Merge to the larger bridge. */
1869                         if (bridge2->num_channels <= bridge1->num_channels) {
1870                                 merge.dest = bridge1;
1871                                 merge.src = bridge2;
1872                         } else {
1873                                 merge.dest = bridge2;
1874                                 merge.src = bridge1;
1875                         }
1876                 }
1877         } else if (!ast_test_flag(&bridge1->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO)
1878                 && !ast_test_flag(&bridge2->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
1879                 /* Can merge only one way. */
1880                 merge.dest = bridge1;
1881                 merge.src = bridge2;
1882         } else if (!ast_test_flag(&bridge2->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO)
1883                 && !ast_test_flag(&bridge1->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
1884                 /* Can merge only one way. */
1885                 merge.dest = bridge2;
1886                 merge.src = bridge1;
1887         }
1888
1889         return merge;
1890 }
1891
1892 /*!
1893  * \internal
1894  * \brief Merge two bridges together
1895  * \since 12.0.0
1896  *
1897  * \param dst_bridge Destination bridge of merge.
1898  * \param src_bridge Source bridge of merge.
1899  * \param merge_best_direction TRUE if don't care about which bridge merges into the other.
1900  * \param kick_me Array of channels to kick from the bridges.
1901  * \param num_kick Number of channels in the kick_me array.
1902  *
1903  * \note The dst_bridge and src_bridge are assumed already locked.
1904  *
1905  * \retval 0 on success
1906  * \retval -1 on failure
1907  */
1908 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)
1909 {
1910         struct merge_direction merge;
1911         struct ast_bridge_channel **kick_them = NULL;
1912
1913         /* Sanity check. */
1914         ast_assert(dst_bridge && src_bridge && dst_bridge != src_bridge && (!num_kick || kick_me));
1915
1916         if (dst_bridge->dissolved || src_bridge->dissolved) {
1917                 ast_debug(1, "Can't merge bridges %s and %s, at least one bridge is dissolved.\n",
1918                         src_bridge->uniqueid, dst_bridge->uniqueid);
1919                 return -1;
1920         }
1921         if (ast_test_flag(&dst_bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)
1922                 || ast_test_flag(&src_bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)) {
1923                 ast_debug(1, "Can't merge bridges %s and %s, masquerade only.\n",
1924                         src_bridge->uniqueid, dst_bridge->uniqueid);
1925                 return -1;
1926         }
1927         if (dst_bridge->inhibit_merge || src_bridge->inhibit_merge) {
1928                 ast_debug(1, "Can't merge bridges %s and %s, merging temporarily inhibited.\n",
1929                         src_bridge->uniqueid, dst_bridge->uniqueid);
1930                 return -1;
1931         }
1932
1933         if (merge_best_direction) {
1934                 merge = bridge_merge_determine_direction(dst_bridge, src_bridge);
1935         } else {
1936                 merge.dest = dst_bridge;
1937                 merge.src = src_bridge;
1938         }
1939
1940         if (!merge.dest
1941                 || ast_test_flag(&merge.dest->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO)
1942                 || ast_test_flag(&merge.src->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
1943                 ast_debug(1, "Can't merge bridges %s and %s, merging inhibited.\n",
1944                         src_bridge->uniqueid, dst_bridge->uniqueid);
1945                 return -1;
1946         }
1947         if (merge.src->num_channels < 2) {
1948                 /*
1949                  * For a two party bridge, a channel may be temporarily removed
1950                  * from the source bridge or the initial bridge members have not
1951                  * joined yet.
1952                  */
1953                 ast_debug(1, "Can't merge bridge %s into bridge %s, not enough channels in source bridge.\n",
1954                         merge.src->uniqueid, merge.dest->uniqueid);
1955                 return -1;
1956         }
1957         if (2 + num_kick < merge.dest->num_channels + merge.src->num_channels
1958                 && !(merge.dest->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX)
1959                 && (!ast_test_flag(&merge.dest->feature_flags, AST_BRIDGE_FLAG_SMART)
1960                         || !(merge.dest->allowed_capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX))) {
1961                 ast_debug(1, "Can't merge bridge %s into bridge %s, multimix is needed and it cannot be acquired.\n",
1962                         merge.src->uniqueid, merge.dest->uniqueid);
1963                 return -1;
1964         }
1965
1966         if (num_kick) {
1967                 unsigned int num_to_kick = 0;
1968                 unsigned int idx;
1969
1970                 kick_them = ast_alloca(num_kick * sizeof(*kick_them));
1971                 for (idx = 0; idx < num_kick; ++idx) {
1972                         kick_them[num_to_kick] = bridge_find_channel(merge.src, kick_me[idx]);
1973                         if (!kick_them[num_to_kick]) {
1974                                 kick_them[num_to_kick] = bridge_find_channel(merge.dest, kick_me[idx]);
1975                         }
1976                         if (kick_them[num_to_kick]) {
1977                                 ++num_to_kick;
1978                         }
1979                 }
1980
1981                 if (num_to_kick != num_kick) {
1982                         ast_debug(1, "Can't merge bridge %s into bridge %s, at least one kicked channel is not in either bridge.\n",
1983                                 merge.src->uniqueid, merge.dest->uniqueid);
1984                         return -1;
1985                 }
1986         }
1987
1988         bridge_do_merge(merge.dest, merge.src, kick_them, num_kick, 0);
1989         return 0;
1990 }
1991
1992 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)
1993 {
1994         int res;
1995
1996         /* Sanity check. */
1997         ast_assert(dst_bridge && src_bridge);
1998
1999         ast_bridge_lock_both(dst_bridge, src_bridge);
2000         res = bridge_merge_locked(dst_bridge, src_bridge, merge_best_direction, kick_me, num_kick);
2001         ast_bridge_unlock(src_bridge);
2002         ast_bridge_unlock(dst_bridge);
2003         return res;
2004 }
2005
2006 int bridge_do_move(struct ast_bridge *dst_bridge, struct ast_bridge_channel *bridge_channel, int attempt_recovery,
2007         unsigned int optimized)
2008 {
2009         struct ast_bridge *orig_bridge;
2010         int was_in_bridge;
2011         int res = 0;
2012
2013         if (bridge_channel->swap) {
2014                 ast_debug(1, "Moving %p(%s) into bridge %s swapping with %s\n",
2015                         bridge_channel, ast_channel_name(bridge_channel->chan), dst_bridge->uniqueid,
2016                         ast_channel_name(bridge_channel->swap));
2017         } else {
2018                 ast_debug(1, "Moving %p(%s) into bridge %s\n",
2019                         bridge_channel, ast_channel_name(bridge_channel->chan), dst_bridge->uniqueid);
2020         }
2021
2022         orig_bridge = bridge_channel->bridge;
2023         was_in_bridge = bridge_channel->in_bridge;
2024
2025         bridge_channel_internal_pull(bridge_channel);
2026         if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
2027                 /*
2028                  * The channel died as a result of being pulled.  Leave it
2029                  * pointing to the original bridge.
2030                  */
2031                 bridge_reconfigured(orig_bridge, 0);
2032                 return -1;
2033         }
2034
2035         /* Point to new bridge.*/
2036         ao2_ref(orig_bridge, +1);/* Keep a ref in case the push fails. */
2037         bridge_channel_change_bridge(bridge_channel, dst_bridge);
2038
2039         if (bridge_channel_internal_push(bridge_channel)) {
2040                 /* Try to put the channel back into the original bridge. */
2041                 ast_bridge_features_remove(bridge_channel->features,
2042                         AST_BRIDGE_HOOK_REMOVE_ON_PULL);
2043                 if (attempt_recovery && was_in_bridge) {
2044                         /* Point back to original bridge. */
2045                         bridge_channel_change_bridge(bridge_channel, orig_bridge);
2046
2047                         if (bridge_channel_internal_push(bridge_channel)) {
2048                                 ast_bridge_features_remove(bridge_channel->features,
2049                                         AST_BRIDGE_HOOK_REMOVE_ON_PULL);
2050                                 ast_bridge_channel_leave_bridge(bridge_channel,
2051                                         BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, bridge_channel->bridge->cause);
2052                                 bridge_channel_settle_owed_events(orig_bridge, bridge_channel);
2053                         }
2054                 } else {
2055                         ast_bridge_channel_leave_bridge(bridge_channel,
2056                                 BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, bridge_channel->bridge->cause);
2057                         bridge_channel_settle_owed_events(orig_bridge, bridge_channel);
2058                 }
2059                 res = -1;
2060         } else {
2061                 bridge_channel_settle_owed_events(orig_bridge, bridge_channel);
2062         }
2063
2064         bridge_reconfigured(dst_bridge, !optimized);
2065         bridge_reconfigured(orig_bridge, !optimized);
2066         ao2_ref(orig_bridge, -1);
2067         return res;
2068 }
2069
2070 /*!
2071  * \internal
2072  * \brief Move a channel from one bridge to another.
2073  * \since 12.0.0
2074  *
2075  * \param dst_bridge Destination bridge of bridge channel move.
2076  * \param src_bridge Source bridge of bridge channel move.
2077  * \param chan Channel to move.
2078  * \param swap Channel to replace in dst_bridge.
2079  * \param attempt_recovery TRUE if failure attempts to push channel back into original bridge.
2080  *
2081  * \note The dst_bridge and src_bridge are assumed already locked.
2082  *
2083  * \retval 0 on success.
2084  * \retval -1 on failure.
2085  */
2086 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)
2087 {
2088         struct ast_bridge_channel *bridge_channel;
2089
2090         if (dst_bridge->dissolved || src_bridge->dissolved) {
2091                 ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, at least one bridge is dissolved.\n",
2092                         ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
2093                 return -1;
2094         }
2095         if (ast_test_flag(&dst_bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)
2096                 || ast_test_flag(&src_bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)) {
2097                 ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, masquerade only.\n",
2098                         ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
2099                 return -1;
2100         }
2101         if (dst_bridge->inhibit_merge || src_bridge->inhibit_merge) {
2102                 ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, temporarily inhibited.\n",
2103                         ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
2104                 return -1;
2105         }
2106
2107         bridge_channel = bridge_find_channel(src_bridge, chan);
2108         if (!bridge_channel) {
2109                 ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, channel not in bridge.\n",
2110                         ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
2111                 return -1;
2112         }
2113         if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
2114                 ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, channel leaving bridge.\n",
2115                         ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
2116                 return -1;
2117         }
2118         if (ast_test_flag(&bridge_channel->features->feature_flags,
2119                 AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE)) {
2120                 ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, channel immovable.\n",
2121                         ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
2122                 return -1;
2123         }
2124
2125         if (swap) {
2126                 struct ast_bridge_channel *bridge_channel_swap;
2127
2128                 bridge_channel_swap = bridge_find_channel(dst_bridge, swap);
2129                 if (!bridge_channel_swap) {
2130                         ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, swap channel %s not in bridge.\n",
2131                                 ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid,
2132                                 ast_channel_name(swap));
2133                         return -1;
2134                 }
2135                 if (bridge_channel_swap->state != BRIDGE_CHANNEL_STATE_WAIT) {
2136                         ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, swap channel %s leaving bridge.\n",
2137                                 ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid,
2138                                 ast_channel_name(swap));
2139                         return -1;
2140                 }
2141         }
2142
2143         bridge_channel->swap = swap;
2144         return bridge_do_move(dst_bridge, bridge_channel, attempt_recovery, 0);
2145 }
2146
2147 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)
2148 {
2149         int res;
2150
2151         ast_bridge_lock_both(dst_bridge, src_bridge);
2152         res = bridge_move_locked(dst_bridge, src_bridge, chan, swap, attempt_recovery);
2153         ast_bridge_unlock(src_bridge);
2154         ast_bridge_unlock(dst_bridge);
2155         return res;
2156 }
2157
2158 int ast_bridge_add_channel(struct ast_bridge *bridge, struct ast_channel *chan,
2159         struct ast_bridge_features *features, int play_tone, const char *xfersound)
2160 {
2161         RAII_VAR(struct ast_bridge *, chan_bridge, NULL, ao2_cleanup);
2162         RAII_VAR(struct ast_channel *, yanked_chan, NULL, ao2_cleanup);
2163
2164         ast_channel_lock(chan);
2165         chan_bridge = ast_channel_get_bridge(chan);
2166         ast_channel_unlock(chan);
2167
2168         if (chan_bridge) {
2169                 struct ast_bridge_channel *bridge_channel;
2170
2171                 ast_bridge_lock_both(bridge, chan_bridge);
2172                 bridge_channel = bridge_find_channel(chan_bridge, chan);
2173
2174                 if (bridge_move_locked(bridge, chan_bridge, chan, NULL, 1)) {
2175                         ast_bridge_unlock(chan_bridge);
2176                         ast_bridge_unlock(bridge);
2177                         return -1;
2178                 }
2179
2180                 /*
2181                  * bridge_move_locked() will implicitly ensure that
2182                  * bridge_channel is not NULL.
2183                  */
2184                 ast_assert(bridge_channel != NULL);
2185
2186                 /*
2187                  * Additional checks if the channel we just stole dissolves the
2188                  * original bridge.
2189                  */
2190                 bridge_dissolve_check_stolen(chan_bridge, bridge_channel);
2191                 ast_bridge_unlock(chan_bridge);
2192                 ast_bridge_unlock(bridge);
2193
2194                 /* The channel was in a bridge so it is not getting any new features. */
2195                 ast_bridge_features_destroy(features);
2196         } else {
2197                 /* Slightly less easy case. We need to yank channel A from
2198                  * where he currently is and impart him into our bridge.
2199                  */
2200                 yanked_chan = ast_channel_yank(chan);
2201                 if (!yanked_chan) {
2202                         ast_log(LOG_WARNING, "Could not gain control of channel %s\n", ast_channel_name(chan));
2203                         return -1;
2204                 }
2205                 if (ast_channel_state(yanked_chan) != AST_STATE_UP) {
2206                         ast_answer(yanked_chan);
2207                 }
2208                 ast_channel_ref(yanked_chan);
2209                 if (ast_bridge_impart(bridge, yanked_chan, NULL, features,
2210                         AST_BRIDGE_IMPART_CHAN_INDEPENDENT)) {
2211                         /* It is possible for us to yank a channel and have some other
2212                          * thread start a PBX on the channl after we yanked it. In particular,
2213                          * this can theoretically happen on the ;2 of a Local channel if we
2214                          * yank it prior to the ;1 being answered. Make sure that it isn't
2215                          * executing a PBX before hanging it up.
2216                          */
2217                         if (ast_channel_pbx(yanked_chan)) {
2218                                 ast_channel_unref(yanked_chan);
2219                         } else {
2220                                 ast_hangup(yanked_chan);
2221                         }
2222                         return -1;
2223                 }
2224         }
2225
2226         if (play_tone && !ast_strlen_zero(xfersound)) {
2227                 struct ast_channel *play_chan = yanked_chan ?: chan;
2228                 RAII_VAR(struct ast_bridge_channel *, play_bridge_channel, NULL, ao2_cleanup);
2229
2230                 ast_channel_lock(play_chan);
2231                 play_bridge_channel = ast_channel_get_bridge_channel(play_chan);
2232                 ast_channel_unlock(play_chan);
2233
2234                 if (!play_bridge_channel) {
2235                         ast_log(LOG_WARNING, "Unable to play tone for channel %s. No longer in a bridge.\n",
2236                                 ast_channel_name(play_chan));
2237                 } else {
2238                         ast_bridge_channel_queue_playfile(play_bridge_channel, NULL, xfersound, NULL);
2239                 }
2240         }
2241         return 0;
2242 }
2243
2244 static int bridge_allows_optimization(struct ast_bridge *bridge)
2245 {
2246         return !(bridge->inhibit_merge
2247                 || bridge->dissolved
2248                 || ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY));
2249 }
2250
2251 /*!
2252  * \internal
2253  * \brief Lock the unreal channel stack for chan and prequalify it.
2254  * \since 12.0.0
2255  *
2256  * \param chan Unreal channel writing a frame into the channel driver.
2257  *
2258  * \note It is assumed that chan is already locked.
2259  *
2260  * \retval bridge on success with bridge and bridge_channel locked.
2261  * \retval NULL if cannot do optimization now.
2262  */
2263 static struct ast_bridge *optimize_lock_chan_stack(struct ast_channel *chan)
2264 {
2265         struct ast_bridge *bridge;
2266         struct ast_bridge_channel *bridge_channel;
2267
2268         if (!AST_LIST_EMPTY(ast_channel_readq(chan))) {
2269                 return NULL;
2270         }
2271         if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_EMULATE_DTMF)) {
2272                 return NULL;
2273         }
2274         if (ast_channel_has_audio_frame_or_monitor(chan)) {
2275                 /* Channel has an active monitor, audiohook, or framehook. */
2276                 return NULL;
2277         }
2278         bridge_channel = ast_channel_internal_bridge_channel(chan);
2279         if (!bridge_channel || ast_bridge_channel_trylock(bridge_channel)) {
2280                 return NULL;
2281         }
2282         bridge = bridge_channel->bridge;
2283         if (bridge_channel->activity != BRIDGE_CHANNEL_THREAD_SIMPLE
2284                 || bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT
2285                 || ast_bridge_trylock(bridge)) {
2286                 ast_bridge_channel_unlock(bridge_channel);
2287                 return NULL;
2288         }
2289         if (!bridge_channel_internal_allows_optimization(bridge_channel) ||
2290                         !bridge_allows_optimization(bridge)) {
2291                 ast_bridge_unlock(bridge);
2292                 ast_bridge_channel_unlock(bridge_channel);
2293                 return NULL;
2294         }
2295         return bridge;
2296 }
2297
2298 /*!
2299  * \internal
2300  * \brief Lock the unreal channel stack for peer and prequalify it.
2301  * \since 12.0.0
2302  *
2303  * \param peer Other unreal channel in the pair.
2304  *
2305  * \retval bridge on success with bridge, bridge_channel, and peer locked.
2306  * \retval NULL if cannot do optimization now.
2307  */
2308 static struct ast_bridge *optimize_lock_peer_stack(struct ast_channel *peer)
2309 {
2310         struct ast_bridge *bridge;
2311         struct ast_bridge_channel *bridge_channel;
2312
2313         if (ast_channel_trylock(peer)) {
2314                 return NULL;
2315         }
2316         if (!AST_LIST_EMPTY(ast_channel_readq(peer))) {
2317                 ast_channel_unlock(peer);
2318                 return NULL;
2319         }
2320         if (ast_test_flag(ast_channel_flags(peer), AST_FLAG_EMULATE_DTMF)) {
2321                 ast_channel_unlock(peer);
2322                 return NULL;
2323         }
2324         if (ast_channel_has_audio_frame_or_monitor(peer)) {
2325                 /* Peer has an active monitor, audiohook, or framehook. */
2326                 ast_channel_unlock(peer);
2327                 return NULL;
2328         }
2329         bridge_channel = ast_channel_internal_bridge_channel(peer);
2330         if (!bridge_channel || ast_bridge_channel_trylock(bridge_channel)) {
2331                 ast_channel_unlock(peer);
2332                 return NULL;
2333         }
2334         bridge = bridge_channel->bridge;
2335         if (bridge_channel->activity != BRIDGE_CHANNEL_THREAD_IDLE
2336                 || bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT
2337                 || ast_bridge_trylock(bridge)) {
2338                 ast_bridge_channel_unlock(bridge_channel);
2339                 ast_channel_unlock(peer);
2340                 return NULL;
2341         }
2342         if (!bridge_allows_optimization(bridge) ||
2343                         !bridge_channel_internal_allows_optimization(bridge_channel)) {
2344                 ast_bridge_unlock(bridge);
2345                 ast_bridge_channel_unlock(bridge_channel);
2346                 ast_channel_unlock(peer);
2347                 return NULL;
2348         }
2349         return bridge;
2350 }
2351
2352 /*!
2353  * \internal
2354  * \brief Indicates allowability of a swap optimization
2355  */
2356 enum bridge_allow_swap {
2357         /*! Bridges cannot allow for a swap optimization to occur */
2358         SWAP_PROHIBITED,
2359         /*! Bridge swap optimization can occur into the chan_bridge */
2360         SWAP_TO_CHAN_BRIDGE,
2361         /*! Bridge swap optimization can occur into the peer_bridge */
2362         SWAP_TO_PEER_BRIDGE,
2363 };
2364
2365 /*!
2366  * \internal
2367  * \brief Determine if two bridges allow for swap optimization to occur
2368  *
2369  * \param chan_bridge First bridge being tested
2370  * \param peer_bridge Second bridge being tested
2371  * \return Allowability of swap optimization
2372  */
2373 static enum bridge_allow_swap bridges_allow_swap_optimization(struct ast_bridge *chan_bridge,
2374                 struct ast_bridge *peer_bridge)
2375 {
2376         int chan_priority;
2377         int peer_priority;
2378
2379         if (!ast_test_flag(&chan_bridge->feature_flags,
2380                         AST_BRIDGE_FLAG_SWAP_INHIBIT_TO | AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM |
2381                         AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY)
2382                 && !ast_test_flag(&peer_bridge->feature_flags,
2383                         AST_BRIDGE_FLAG_SWAP_INHIBIT_TO | AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM |
2384                         AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY)) {
2385                 /*
2386                  * Can swap either way.  Swap to the higher priority merge
2387                  * bridge.
2388                  */
2389                 chan_priority = chan_bridge->v_table->get_merge_priority(chan_bridge);
2390                 peer_priority = peer_bridge->v_table->get_merge_priority(peer_bridge);
2391                 if (chan_bridge->num_channels == 2
2392                         && chan_priority <= peer_priority) {
2393                         return SWAP_TO_PEER_BRIDGE;
2394                 } else if (peer_bridge->num_channels == 2
2395                         && peer_priority <= chan_priority) {
2396                         return SWAP_TO_CHAN_BRIDGE;
2397                 }
2398         } else if (chan_bridge->num_channels == 2
2399                 && !ast_test_flag(&chan_bridge->feature_flags, AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM | AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY)
2400                 && !ast_test_flag(&peer_bridge->feature_flags, AST_BRIDGE_FLAG_SWAP_INHIBIT_TO)) {
2401                 /* Can swap optimize only one way. */
2402                 return SWAP_TO_PEER_BRIDGE;
2403         } else if (peer_bridge->num_channels == 2
2404                 && !ast_test_flag(&peer_bridge->feature_flags, AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM | AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY)
2405                 && !ast_test_flag(&chan_bridge->feature_flags, AST_BRIDGE_FLAG_SWAP_INHIBIT_TO)) {
2406                 /* Can swap optimize only one way. */
2407                 return SWAP_TO_CHAN_BRIDGE;
2408         }
2409
2410         return SWAP_PROHIBITED;
2411 }
2412
2413 /*!
2414  * \internal
2415  * \brief Check and attempt to swap optimize out the unreal channels.
2416  * \since 12.0.0
2417  *
2418  * \param chan_bridge
2419  * \param chan_bridge_channel
2420  * \param peer_bridge
2421  * \param peer_bridge_channel
2422  * \param pvt Unreal data containing callbacks to call if the optimization actually
2423  * happens
2424  *
2425  * \retval 1 if unreal channels failed to optimize out.
2426  * \retval 0 if unreal channels were not optimized out.
2427  * \retval -1 if unreal channels were optimized out.
2428  */
2429 static int try_swap_optimize_out(struct ast_bridge *chan_bridge,
2430         struct ast_bridge_channel *chan_bridge_channel, struct ast_bridge *peer_bridge,
2431         struct ast_bridge_channel *peer_bridge_channel,
2432         struct ast_unreal_pvt *pvt)
2433 {
2434         struct ast_bridge *dst_bridge;
2435         struct ast_bridge_channel *dst_bridge_channel;
2436         struct ast_bridge_channel *src_bridge_channel;
2437         struct ast_bridge_channel *other;
2438         int res = 1;
2439
2440         switch (bridges_allow_swap_optimization(chan_bridge, peer_bridge)) {
2441         case SWAP_TO_CHAN_BRIDGE:
2442                 dst_bridge = chan_bridge;
2443                 dst_bridge_channel = chan_bridge_channel;
2444                 src_bridge_channel = peer_bridge_channel;
2445                 break;
2446         case SWAP_TO_PEER_BRIDGE:
2447                 dst_bridge = peer_bridge;
2448                 dst_bridge_channel = peer_bridge_channel;
2449                 src_bridge_channel = chan_bridge_channel;
2450                 break;
2451         case SWAP_PROHIBITED:
2452         default:
2453                 return 0;
2454         }
2455
2456         other = ast_bridge_channel_peer(src_bridge_channel);
2457         if (other && other->state == BRIDGE_CHANNEL_STATE_WAIT) {
2458                 unsigned int id = ast_atomic_fetchadd_int((int *) &optimization_id, +1);
2459
2460                 ast_verb(3, "Move-swap optimizing %s <-- %s.\n",
2461                         ast_channel_name(dst_bridge_channel->chan),
2462                         ast_channel_name(other->chan));
2463
2464                 if (pvt && !ast_test_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN) && pvt->callbacks
2465                                 && pvt->callbacks->optimization_started) {
2466                         pvt->callbacks->optimization_started(pvt, other->chan,
2467                                         dst_bridge_channel->chan == pvt->owner ? AST_UNREAL_OWNER : AST_UNREAL_CHAN,
2468                                         id);
2469                         ast_set_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN);
2470                 }
2471                 other->swap = dst_bridge_channel->chan;
2472                 if (!bridge_do_move(dst_bridge, other, 1, 1)) {
2473                         ast_bridge_channel_leave_bridge(src_bridge_channel,
2474                                 BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, AST_CAUSE_NORMAL_CLEARING);
2475                         res = -1;
2476                 }
2477                 if (pvt && pvt->callbacks && pvt->callbacks->optimization_finished) {
2478                         pvt->callbacks->optimization_finished(pvt, res == 1, id);
2479                 }
2480         }
2481         return res;
2482 }
2483
2484 /*!
2485  * \internal
2486  * \brief Indicates allowability of a merge optimization
2487  */
2488 enum bridge_allow_merge {
2489         /*! Bridge properties prohibit merge optimization */
2490         MERGE_PROHIBITED,
2491         /*! Merge optimization cannot occur because the source bridge has too few channels */
2492         MERGE_NOT_ENOUGH_CHANNELS,
2493         /*! Merge optimization cannot occur because multimix capability could not be requested */
2494         MERGE_NO_MULTIMIX,
2495         /*! Merge optimization allowed between bridges */
2496         MERGE_ALLOWED,
2497 };
2498
2499 /*!
2500  * \internal
2501  * \brief Determines allowability of a merge optimization
2502  *
2503  * \note The merge output parameter is undefined if MERGE_PROHIBITED is returned. For success
2504  * and other failure returns, a merge direction was determined, and the parameter is safe to
2505  * access.
2506  *
2507  * \param chan_bridge First bridge being tested
2508  * \param peer_bridge Second bridge being tested
2509  * \param num_kick_channels The number of channels to remove from the bridges during merging
2510  * \param[out] merge Indicates the recommended direction for the bridge merge
2511  */
2512 static enum bridge_allow_merge bridges_allow_merge_optimization(struct ast_bridge *chan_bridge,
2513                 struct ast_bridge *peer_bridge, int num_kick_channels, struct merge_direction *merge)
2514 {
2515         *merge = bridge_merge_determine_direction(chan_bridge, peer_bridge);
2516         if (!merge->dest) {
2517                 return MERGE_PROHIBITED;
2518         }
2519         if (merge->src->num_channels < 2) {
2520                 return MERGE_NOT_ENOUGH_CHANNELS;
2521         } else if ((2 + num_kick_channels) < merge->dest->num_channels + merge->src->num_channels
2522                 && !(merge->dest->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX)
2523                 && (!ast_test_flag(&merge->dest->feature_flags, AST_BRIDGE_FLAG_SMART)
2524                         || !(merge->dest->allowed_capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX))) {
2525                 return MERGE_NO_MULTIMIX;
2526         }
2527
2528         return MERGE_ALLOWED;
2529 }
2530
2531 /*!
2532  * \internal
2533  * \brief Check and attempt to merge optimize out the unreal channels.
2534  * \since 12.0.0
2535  *
2536  * \param chan_bridge
2537  * \param chan_bridge_channel
2538  * \param peer_bridge
2539  * \param peer_bridge_channel
2540  * \param pvt Unreal data containing callbacks to call if the optimization actually
2541  * happens
2542  *
2543  * \retval 0 if unreal channels were not optimized out.
2544  * \retval -1 if unreal channels were optimized out.
2545  */
2546 static int try_merge_optimize_out(struct ast_bridge *chan_bridge,
2547         struct ast_bridge_channel *chan_bridge_channel, struct ast_bridge *peer_bridge,
2548         struct ast_bridge_channel *peer_bridge_channel,
2549         struct ast_unreal_pvt *pvt)
2550 {
2551         struct merge_direction merge;
2552         struct ast_bridge_channel *kick_me[] = {
2553                 chan_bridge_channel,
2554                 peer_bridge_channel,
2555         };
2556         unsigned int id;
2557
2558         switch (bridges_allow_merge_optimization(chan_bridge, peer_bridge, ARRAY_LEN(kick_me), &merge)) {
2559         case MERGE_ALLOWED:
2560                 break;
2561         case MERGE_PROHIBITED:
2562                 return 0;
2563         case MERGE_NOT_ENOUGH_CHANNELS:
2564                 ast_debug(4, "Can't optimize %s -- %s out, not enough channels in bridge %s.\n",
2565                         ast_channel_name(chan_bridge_channel->chan),
2566                         ast_channel_name(peer_bridge_channel->chan),
2567                         merge.src->uniqueid);
2568                 return 0;
2569         case MERGE_NO_MULTIMIX:
2570                 ast_debug(4, "Can't optimize %s -- %s out, multimix is needed and it cannot be acquired.\n",
2571                         ast_channel_name(chan_bridge_channel->chan),
2572                         ast_channel_name(peer_bridge_channel->chan));
2573                 return 0;
2574         }
2575
2576         ast_verb(3, "Merge optimizing %s -- %s out.\n",
2577                 ast_channel_name(chan_bridge_channel->chan),
2578                 ast_channel_name(peer_bridge_channel->chan));
2579
2580         id = ast_atomic_fetchadd_int((int *) &optimization_id, +1);
2581
2582         if (pvt && !ast_test_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN) && pvt->callbacks
2583                         && pvt->callbacks->optimization_started) {
2584                 pvt->callbacks->optimization_started(pvt, NULL,
2585                                 merge.dest == ast_channel_internal_bridge(pvt->owner) ? AST_UNREAL_OWNER : AST_UNREAL_CHAN,
2586                                 id);
2587                 ast_set_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN);
2588         }
2589         bridge_do_merge(merge.dest, merge.src, kick_me, ARRAY_LEN(kick_me), 1);
2590         if (pvt && pvt->callbacks && pvt->callbacks->optimization_finished) {
2591                 pvt->callbacks->optimization_finished(pvt, 1, id);
2592         }
2593
2594         return -1;
2595 }
2596
2597 int ast_bridge_unreal_optimize_out(struct ast_channel *chan, struct ast_channel *peer, struct ast_unreal_pvt *pvt)
2598 {
2599         struct ast_bridge *chan_bridge;
2600         struct ast_bridge *peer_bridge;
2601         struct ast_bridge_channel *chan_bridge_channel;
2602         struct ast_bridge_channel *peer_bridge_channel;
2603         int res = 0;
2604
2605         chan_bridge = optimize_lock_chan_stack(chan);
2606         if (!chan_bridge) {
2607                 return res;
2608         }
2609         chan_bridge_channel = ast_channel_internal_bridge_channel(chan);
2610
2611         peer_bridge = optimize_lock_peer_stack(peer);
2612         if (peer_bridge) {
2613                 peer_bridge_channel = ast_channel_internal_bridge_channel(peer);
2614
2615                 res = try_swap_optimize_out(chan_bridge, chan_bridge_channel,
2616                         peer_bridge, peer_bridge_channel, pvt);
2617                 if (!res) {
2618                         res = try_merge_optimize_out(chan_bridge, chan_bridge_channel,
2619                                 peer_bridge, peer_bridge_channel, pvt);
2620                 } else if (0 < res) {
2621                         res = 0;
2622                 }
2623
2624                 /* Release peer locks. */
2625                 ast_bridge_unlock(peer_bridge);
2626                 ast_bridge_channel_unlock(peer_bridge_channel);
2627                 ast_channel_unlock(peer);
2628         }
2629
2630         /* Release chan locks. */
2631         ast_bridge_unlock(chan_bridge);
2632         ast_bridge_channel_unlock(chan_bridge_channel);
2633
2634         return res;
2635 }
2636
2637 enum ast_bridge_optimization ast_bridges_allow_optimization(struct ast_bridge *chan_bridge,
2638                 struct ast_bridge *peer_bridge)
2639 {
2640         struct merge_direction merge;
2641
2642         if (!bridge_allows_optimization(chan_bridge) || !bridge_allows_optimization(peer_bridge)) {
2643                 return AST_BRIDGE_OPTIMIZE_PROHIBITED;
2644         }
2645
2646         switch (bridges_allow_swap_optimization(chan_bridge, peer_bridge)) {
2647         case SWAP_TO_CHAN_BRIDGE:
2648                 return AST_BRIDGE_OPTIMIZE_SWAP_TO_CHAN_BRIDGE;
2649         case SWAP_TO_PEER_BRIDGE:
2650                 return AST_BRIDGE_OPTIMIZE_SWAP_TO_PEER_BRIDGE;
2651         case SWAP_PROHIBITED:
2652         default:
2653                 break;
2654         }
2655
2656         /* Two channels will be kicked from the bridges, the unreal;1 and unreal;2 channels */
2657         if (bridges_allow_merge_optimization(chan_bridge, peer_bridge, 2, &merge) != MERGE_ALLOWED) {
2658                 return AST_BRIDGE_OPTIMIZE_PROHIBITED;
2659         }
2660
2661         if (merge.dest == chan_bridge) {
2662                 return AST_BRIDGE_OPTIMIZE_MERGE_TO_CHAN_BRIDGE;
2663         } else {
2664                 return AST_BRIDGE_OPTIMIZE_MERGE_TO_PEER_BRIDGE;
2665         }
2666 }
2667
2668 /*!
2669  * \internal
2670  * \brief Adjust the bridge merge inhibit request count.
2671  * \since 12.0.0
2672  *
2673  * \param bridge What to operate on.
2674  * \param request Inhibit request increment.
2675  *     (Positive to add requests.  Negative to remove requests.)
2676  *
2677  * \note This function assumes bridge is locked.
2678  *
2679  * \return Nothing
2680  */
2681 void bridge_merge_inhibit_nolock(struct ast_bridge *bridge, int request)
2682 {
2683         int new_request;
2684
2685         new_request = bridge->inhibit_merge + request;
2686         ast_assert(0 <= new_request);
2687         bridge->inhibit_merge = new_request;
2688 }
2689
2690 void ast_bridge_merge_inhibit(struct ast_bridge *bridge, int request)
2691 {
2692         ast_bridge_lock(bridge);
2693         bridge_merge_inhibit_nolock(bridge, request);
2694         ast_bridge_unlock(bridge);
2695 }
2696
2697 int ast_bridge_suspend(struct ast_bridge *bridge, struct ast_channel *chan)
2698 {
2699         struct ast_bridge_channel *bridge_channel;
2700 /* XXX ASTERISK-21271 the case of a disolved bridge while channel is suspended is not handled. */
2701 /* XXX ASTERISK-21271 suspend/unsuspend needs to be rethought. The caller must block until it has successfully suspended the channel for temporary control. */
2702 /* 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. */
2703
2704         ast_bridge_lock(bridge);
2705
2706         if (!(bridge_channel = bridge_find_channel(bridge, chan))) {
2707                 ast_bridge_unlock(bridge);
2708                 return -1;
2709         }
2710
2711         bridge_channel_internal_suspend_nolock(bridge_channel);
2712
2713         ast_bridge_unlock(bridge);
2714
2715         return 0;
2716 }
2717
2718 int ast_bridge_unsuspend(struct ast_bridge *bridge, struct ast_channel *chan)
2719 {
2720         struct ast_bridge_channel *bridge_channel;
2721 /* XXX ASTERISK-21271 the case of a disolved bridge while channel is suspended is not handled. */
2722
2723         ast_bridge_lock(bridge);
2724
2725         if (!(bridge_channel = bridge_find_channel(bridge, chan))) {
2726                 ast_bridge_unlock(bridge);
2727                 return -1;
2728         }
2729
2730         bridge_channel_internal_unsuspend_nolock(bridge_channel);
2731
2732         ast_bridge_unlock(bridge);
2733
2734         return 0;
2735 }
2736
2737 void ast_bridge_technology_suspend(struct ast_bridge_technology *technology)
2738 {
2739         technology->suspended = 1;
2740 }
2741
2742 void ast_bridge_technology_unsuspend(struct ast_bridge_technology *technology)
2743 {
2744         /*
2745          * XXX We may want the act of unsuspending a bridge technology
2746          * to prod all existing bridges to see if they should start
2747          * using it.
2748          */
2749         technology->suspended = 0;
2750 }
2751
2752 int ast_bridge_features_register(enum ast_bridge_builtin_feature feature, ast_bridge_hook_callback callback, const char *dtmf)
2753 {
2754         if (ARRAY_LEN(builtin_features_handlers) <= feature
2755                 || builtin_features_handlers[feature]) {
2756                 return -1;
2757         }
2758
2759         if (!ast_strlen_zero(dtmf)) {
2760                 ast_copy_string(builtin_features_dtmf[feature], dtmf, sizeof(builtin_features_dtmf[feature]));
2761         }
2762
2763         builtin_features_handlers[feature] = callback;
2764
2765         return 0;
2766 }
2767
2768 int ast_bridge_features_unregister(enum ast_bridge_builtin_feature feature)
2769 {
2770         if (ARRAY_LEN(builtin_features_handlers) <= feature
2771                 || !builtin_features_handlers[feature]) {
2772                 return -1;
2773         }
2774
2775         builtin_features_handlers[feature] = NULL;
2776
2777         return 0;
2778 }
2779
2780 int ast_bridge_features_do(enum ast_bridge_builtin_feature feature, struct ast_bridge_channel *bridge_channel, void *hook_pvt)
2781 {
2782         ast_bridge_hook_callback callback;
2783
2784         if (ARRAY_LEN(builtin_features_handlers) <= feature) {
2785                 return -1;
2786         }
2787
2788         callback = builtin_features_handlers[feature];
2789         if (!callback) {
2790                 return -1;
2791         }
2792         callback(bridge_channel, hook_pvt);
2793
2794         return 0;
2795 }
2796
2797 int ast_bridge_interval_register(enum ast_bridge_builtin_interval interval, ast_bridge_builtin_set_limits_fn callback)
2798 {
2799         if (ARRAY_LEN(builtin_interval_handlers) <= interval
2800                 || builtin_interval_handlers[interval]) {
2801                 return -1;
2802         }
2803
2804         builtin_interval_handlers[interval] = callback;
2805
2806         return 0;
2807 }
2808
2809 int ast_bridge_interval_unregister(enum ast_bridge_builtin_interval interval)
2810 {
2811         if (ARRAY_LEN(builtin_interval_handlers) <= interval
2812                 || !builtin_interval_handlers[interval]) {
2813                 return -1;
2814         }
2815
2816         builtin_interval_handlers[interval] = NULL;
2817
2818         return 0;
2819
2820 }
2821
2822 /*!
2823  * \internal
2824  * \brief Bridge hook destructor.
2825  * \since 12.0.0
2826  *
2827  * \param vhook Object to destroy.
2828  *
2829  * \return Nothing
2830  */
2831 static void bridge_hook_destroy(void *vhook)
2832 {
2833         struct ast_bridge_hook *hook = vhook;
2834
2835         if (hook->destructor) {
2836                 hook->destructor(hook->hook_pvt);
2837         }
2838 }
2839
2840 /*!
2841  * \internal
2842  * \brief Allocate and setup a generic bridge hook.
2843  * \since 12.0.0
2844  *
2845  * \param size How big an object to allocate.
2846  * \param callback Function to execute upon activation
2847  * \param hook_pvt Unique data
2848  * \param destructor Optional destructor callback for hook_pvt data
2849  * \param remove_flags Dictates what situations the hook should be removed.
2850  *
2851  * \retval hook on success.
2852  * \retval NULL on error.
2853  */
2854 static struct ast_bridge_hook *bridge_hook_generic(size_t size,
2855         ast_bridge_hook_callback callback,
2856         void *hook_pvt,
2857         ast_bridge_hook_pvt_destructor destructor,
2858         enum ast_bridge_hook_remove_flags remove_flags)
2859 {
2860         struct ast_bridge_hook *hook;
2861
2862         /* Allocate new hook and setup it's basic variables */
2863         hook = ao2_alloc_options(size, bridge_hook_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
2864         if (hook) {
2865                 hook->callback = callback;
2866                 hook->destructor = destructor;
2867                 hook->hook_pvt = hook_pvt;
2868                 ast_set_flag(&hook->remove_flags, remove_flags);
2869         }
2870
2871         return hook;
2872 }
2873
2874 int ast_bridge_dtmf_hook(struct ast_bridge_features *features,
2875         const char *dtmf,
2876         ast_bridge_hook_callback callback,
2877         void *hook_pvt,
2878         ast_bridge_hook_pvt_destructor destructor,
2879         enum ast_bridge_hook_remove_flags remove_flags)
2880 {
2881         struct ast_bridge_hook_dtmf *hook;
2882         int res;
2883
2884         /* Allocate new hook and setup it's various variables */
2885         hook = (struct ast_bridge_hook_dtmf *) bridge_hook_generic(sizeof(*hook), callback,
2886                 hook_pvt, destructor, remove_flags);
2887         if (!hook) {
2888                 return -1;
2889         }
2890         hook->generic.type = AST_BRIDGE_HOOK_TYPE_DTMF;
2891         ast_copy_string(hook->dtmf.code, dtmf, sizeof(hook->dtmf.code));
2892
2893         /* Once done we put it in the container. */
2894         res = ao2_link(features->dtmf_hooks, hook) ? 0 : -1;
2895         if (res) {
2896                 /*
2897                  * Could not link the hook into the container.
2898                  *
2899                  * Remove the hook_pvt destructor call from the hook since we
2900                  * are returning failure to install the hook.
2901                  */
2902                 hook->generic.destructor = NULL;
2903         }
2904         ao2_ref(hook, -1);
2905
2906         return res;
2907 }
2908
2909 /*!
2910  * \internal
2911  * \brief Attach an other hook to a bridge features structure
2912  *
2913  * \param features Bridge features structure
2914  * \param callback Function to execute upon activation
2915  * \param hook_pvt Unique data
2916  * \param destructor Optional destructor callback for hook_pvt data
2917  * \param remove_flags Dictates what situations the hook should be removed.
2918  * \param type What type of hook is being attached.
2919  *
2920  * \retval 0 on success
2921  * \retval -1 on failure (The caller must cleanup any hook_pvt resources.)
2922  */
2923 static int bridge_other_hook(struct ast_bridge_features *features,
2924         ast_bridge_hook_callback callback,
2925         void *hook_pvt,
2926         ast_bridge_hook_pvt_destructor destructor,
2927         enum ast_bridge_hook_remove_flags remove_flags,
2928         enum ast_bridge_hook_type type)
2929 {
2930         struct ast_bridge_hook *hook;
2931         int res;
2932
2933         /* Allocate new hook and setup it's various variables */
2934         hook = bridge_hook_generic(sizeof(*hook), callback, hook_pvt, destructor,
2935                 remove_flags);
2936         if (!hook) {
2937                 return -1;
2938         }
2939         hook->type = type;
2940
2941         /* Once done we put it in the container. */
2942         res = ao2_link(features->other_hooks, hook) ? 0 : -1;
2943         if (res) {
2944                 /*
2945                  * Could not link the hook into the container.
2946                  *
2947                  * Remove the hook_pvt destructor call from the hook since we
2948                  * are returning failure to install the hook.
2949                  */
2950                 hook->destructor = NULL;
2951         }
2952         ao2_ref(hook, -1);
2953
2954         return res;
2955 }
2956
2957 int ast_bridge_hangup_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_HANGUP);
2965 }
2966
2967 int ast_bridge_join_hook(struct ast_bridge_features *features,
2968         ast_bridge_hook_callback callback,
2969         void *hook_pvt,
2970         ast_bridge_hook_pvt_destructor destructor,
2971         enum ast_bridge_hook_remove_flags remove_flags)
2972 {
2973         return bridge_other_hook(features, callback, hook_pvt, destructor, remove_flags,
2974                 AST_BRIDGE_HOOK_TYPE_JOIN);
2975 }
2976
2977 int ast_bridge_leave_hook(struct ast_bridge_features *features,
2978         ast_bridge_hook_callback callback,
2979         void *hook_pvt,
2980         ast_bridge_hook_pvt_destructor destructor,
2981         enum ast_bridge_hook_remove_flags remove_flags)
2982 {
2983         return bridge_other_hook(features, callback, hook_pvt, destructor, remove_flags,
2984                 AST_BRIDGE_HOOK_TYPE_LEAVE);
2985 }
2986
2987 int ast_bridge_talk_detector_hook(struct ast_bridge_features *features,
2988         ast_bridge_talking_indicate_callback callback,
2989         void *hook_pvt,
2990         ast_bridge_hook_pvt_destructor destructor,
2991         enum ast_bridge_hook_remove_flags remove_flags)
2992 {
2993         ast_bridge_hook_callback hook_cb = (ast_bridge_hook_callback) callback;
2994
2995         return bridge_other_hook(features, hook_cb, hook_pvt, destructor, remove_flags,
2996                 AST_BRIDGE_HOOK_TYPE_TALK);
2997 }
2998
2999 int ast_bridge_interval_hook(struct ast_bridge_features *features,
3000         enum ast_bridge_hook_timer_option flags,
3001         unsigned int interval,
3002         ast_bridge_hook_callback callback,
3003         void *hook_pvt,
3004         ast_bridge_hook_pvt_destructor destructor,
3005         enum ast_bridge_hook_remove_flags remove_flags)
3006 {
3007         struct ast_bridge_hook_timer *hook;
3008         int res;
3009
3010         if (!features ||!interval || !callback) {
3011                 return -1;
3012         }
3013
3014         /* Allocate new hook and setup it's various variables */
3015         hook = (struct ast_bridge_hook_timer *) bridge_hook_generic(sizeof(*hook), callback,
3016                 hook_pvt, destructor, remove_flags);
3017         if (!hook) {
3018                 return -1;
3019         }
3020         hook->generic.type = AST_BRIDGE_HOOK_TYPE_TIMER;
3021         hook->timer.interval = interval;
3022         hook->timer.trip_time = ast_tvadd(ast_tvnow(), ast_samp2tv(interval, 1000));
3023         hook->timer.seqno = ast_atomic_fetchadd_int((int *) &features->interval_sequence, +1);
3024         hook->timer.flags = flags;
3025
3026         ast_debug(1, "Putting interval hook %p with interval %u in the heap on features %p\n",
3027                 hook, hook->timer.interval, features);
3028         ast_heap_wrlock(features->interval_hooks);
3029         res = ast_heap_push(features->interval_hooks, hook);
3030         ast_heap_unlock(features->interval_hooks);
3031         if (res) {
3032                 /*
3033                  * Could not push the hook into the heap
3034                  *
3035                  * Remove the hook_pvt destructor call from the hook since we
3036                  * are returning failure to install the hook.
3037                  */
3038                 hook->generic.destructor = NULL;
3039                 ao2_ref(hook, -1);
3040         }
3041
3042         return res ? -1 : 0;
3043 }
3044
3045 int ast_bridge_features_enable(struct ast_bridge_features *features,
3046         enum ast_bridge_builtin_feature feature,
3047         const char *dtmf,
3048         void *config,
3049         ast_bridge_hook_pvt_destructor destructor,
3050         enum ast_bridge_hook_remove_flags remove_flags)
3051 {
3052         if (ARRAY_LEN(builtin_features_handlers) <= feature
3053                 || !builtin_features_handlers[feature]) {
3054                 return -1;
3055         }
3056
3057         /* If no alternate DTMF stream was provided use the default one */
3058         if (ast_strlen_zero(dtmf)) {
3059                 dtmf = builtin_features_dtmf[feature];
3060                 /* If no DTMF is still available (ie: it has been disabled) then error out now */
3061                 if (ast_strlen_zero(dtmf)) {
3062                         ast_debug(1, "Failed to enable built in feature %d on %p, no DTMF string is available for it.\n",
3063                                 feature, features);
3064                         return -1;
3065                 }
3066         }
3067
3068         /*
3069          * The rest is basically pretty easy.  We create another hook
3070          * using the built in feature's DTMF callback.  Easy as pie.
3071          */
3072         return ast_bridge_dtmf_hook(features, dtmf, builtin_features_handlers[feature],
3073                 config, destructor, remove_flags);
3074 }
3075
3076 int ast_bridge_features_limits_construct(struct ast_bridge_features_limits *limits)
3077 {
3078         memset(limits, 0, sizeof(*limits));
3079
3080         if (ast_string_field_init(limits, 256)) {
3081                 return -1;
3082         }
3083
3084         return 0;
3085 }
3086
3087 void ast_bridge_features_limits_destroy(struct ast_bridge_features_limits *limits)
3088 {
3089         ast_string_field_free_memory(limits);
3090 }
3091
3092 int ast_bridge_features_set_limits(struct ast_bridge_features *features,
3093         struct ast_bridge_features_limits *limits,
3094         enum ast_bridge_hook_remove_flags remove_flags)
3095 {
3096         if (builtin_interval_handlers[AST_BRIDGE_BUILTIN_INTERVAL_LIMITS]) {
3097                 ast_bridge_builtin_set_limits_fn callback;
3098
3099                 callback = builtin_interval_handlers[AST_BRIDGE_BUILTIN_INTERVAL_LIMITS];
3100                 return callback(features, limits, remove_flags);
3101         }
3102
3103         ast_log(LOG_ERROR, "Attempted to set limits without an AST_BRIDGE_BUILTIN_INTERVAL_LIMITS callback registered.\n");
3104         return -1;
3105 }
3106
3107 void ast_bridge_features_set_flag(struct ast_bridge_features *features, unsigned int flag)
3108 {
3109         ast_set_flag(&features->feature_flags, flag);
3110         features->usable = 1;
3111 }
3112
3113 /*!
3114  * \internal
3115  * \brief ao2 object match hooks with appropriate remove_flags.
3116  * \since 12.0.0
3117  *
3118  * \param obj Feature hook object.
3119  * \param arg Removal flags
3120  * \param flags Not used
3121  *
3122  * \retval CMP_MATCH if hook's remove_flags match the removal flags set.
3123  * \retval 0 if not match.
3124  */
3125 static int hook_remove_match(void *obj, void *arg, int flags)
3126 {
3127         struct ast_bridge_hook *hook = obj;
3128         enum ast_bridge_hook_remove_flags *remove_flags = arg;
3129
3130         if (ast_test_flag(&hook->remove_flags, *remove_flags)) {
3131                 return CMP_MATCH;
3132         } else {
3133                 return 0;
3134         }
3135 }
3136
3137 /*!
3138  * \internal
3139  * \brief Remove all hooks with appropriate remove_flags in the container.
3140  * \since 12.0.0
3141  *
3142  * \param hooks Hooks container to work on.
3143  * \param remove_flags Determinator for whether hook is removed
3144  *
3145  * \return Nothing
3146  */
3147 static void hooks_remove_container(struct ao2_container *hooks, enum ast_bridge_hook_remove_flags remove_flags)
3148 {
3149         ao2_callback(hooks, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE,
3150                 hook_remove_match, &remove_flags);
3151 }
3152
3153 /*!
3154  * \internal
3155  * \brief Remove all hooks in the heap with appropriate remove_flags set.
3156  * \since 12.0.0
3157  *
3158  * \param hooks Hooks heap to work on.
3159  * \param remove_flags Determinator for whether hook is removed
3160  *
3161  * \return Nothing
3162  */
3163 static void hooks_remove_heap(struct ast_heap *hooks, enum ast_bridge_hook_remove_flags remove_flags)
3164 {
3165         struct ast_bridge_hook *hook;
3166         int changed;
3167
3168         ast_heap_wrlock(hooks);
3169         do {
3170                 int idx;
3171
3172                 changed = 0;
3173                 for (idx = ast_heap_size(hooks); idx; --idx) {
3174                         hook = ast_heap_peek(hooks, idx);
3175                         if (ast_test_flag(&hook->remove_flags, remove_flags)) {
3176                                 ast_heap_remove(hooks, hook);
3177                                 ao2_ref(hook, -1);
3178                                 changed = 1;
3179                         }
3180                 }
3181         } while (changed);
3182         ast_heap_unlock(hooks);
3183 }
3184
3185 void ast_bridge_features_remove(struct ast_bridge_features *features, enum ast_bridge_hook_remove_flags remove_flags)
3186 {
3187         hooks_remove_container(features->dtmf_hooks, remove_flags);
3188         hooks_remove_container(features->other_hooks, remove_flags);
3189         hooks_remove_heap(features->interval_hooks, remove_flags);
3190 }
3191
3192 static int interval_hook_time_cmp(void *a, void *b)
3193 {
3194         struct ast_bridge_hook_timer *hook_a = a;
3195         struct ast_bridge_hook_timer *hook_b = b;
3196         int cmp;
3197
3198         cmp = ast_tvcmp(hook_b->timer.trip_time, hook_a->timer.trip_time);
3199         if (cmp) {
3200                 return cmp;
3201         }
3202
3203         cmp = hook_b->timer.seqno - hook_a->timer.seqno;
3204         return cmp;
3205 }
3206
3207 /*!
3208  * \internal
3209  * \brief DTMF hook container sort comparison function.
3210  * \since 12.0.0
3211  *
3212  * \param obj_left pointer to the (user-defined part) of an object.
3213  * \param obj_right pointer to the (user-defined part) of an object.
3214  * \param flags flags from ao2_callback()
3215  *   OBJ_POINTER - if set, 'obj_right', is an object.
3216  *   OBJ_KEY - if set, 'obj_right', is a search key item that is not an object.
3217  *   OBJ_PARTIAL_KEY - if set, 'obj_right', is a partial search key item that is not an object.
3218  *
3219  * \retval <0 if obj_left < obj_right
3220  * \retval =0 if obj_left == obj_right
3221  * \retval >0 if obj_left > obj_right
3222  */
3223 static int bridge_dtmf_hook_sort(const void *obj_left, const void *obj_right, int flags)
3224 {
3225         const struct ast_bridge_hook_dtmf *hook_left = obj_left;
3226         const struct ast_bridge_hook_dtmf *hook_right = obj_right;
3227         const char *right_key = obj_right;
3228         int cmp;
3229
3230         switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
3231         default:
3232         case OBJ_POINTER:
3233                 right_key = hook_right->dtmf.code;
3234                 /* Fall through */
3235         case OBJ_KEY:
3236                 cmp = strcasecmp(hook_left->dtmf.code, right_key);
3237                 break;
3238         case OBJ_PARTIAL_KEY:
3239                 cmp = strncasecmp(hook_left->dtmf.code, right_key, strlen(right_key));
3240                 break;
3241         }
3242         return cmp;
3243 }
3244
3245 /* XXX ASTERISK-21271 make ast_bridge_features_init() static when make ast_bridge_join() requires features to be allocated. */
3246 int ast_bridge_features_init(struct ast_bridge_features *features)
3247 {
3248         /* Zero out the structure */
3249         memset(features, 0, sizeof(*features));
3250
3251         /* Initialize the DTMF hooks container */
3252         features->dtmf_hooks = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX,
3253                 AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE, bridge_dtmf_hook_sort, NULL);
3254         if (!features->dtmf_hooks) {
3255                 return -1;
3256         }
3257
3258         /* Initialize the miscellaneous other hooks container */
3259         features->other_hooks = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL,
3260                 NULL);
3261         if (!features->other_hooks) {
3262                 return -1;
3263         }
3264
3265         /* Initialize the interval hooks heap */
3266         features->interval_hooks = ast_heap_create(8, interval_hook_time_cmp,
3267                 offsetof(struct ast_bridge_hook_timer, timer.heap_index));
3268         if (!features->interval_hooks) {
3269                 return -1;
3270         }
3271
3272         features->dtmf_passthrough = 1;
3273
3274         return 0;
3275 }
3276
3277 /* XXX ASTERISK-21271 make ast_bridge_features_cleanup() static when make ast_bridge_join() requires features to be allocated. */
3278 void ast_bridge_features_cleanup(struct ast_bridge_features *features)
3279 {
3280         struct ast_bridge_hook_timer *hook;
3281
3282         /* Destroy the interval hooks heap. */
3283         if (features->interval_hooks) {
3284                 while ((hook = ast_heap_pop(features->interval_hooks))) {
3285                         ao2_ref(hook, -1);
3286                 }
3287                 features->interval_hooks = ast_heap_destroy(features->interval_hooks);
3288         }
3289
3290         /* Destroy the miscellaneous other hooks container. */
3291         ao2_cleanup(features->other_hooks);
3292         features->other_hooks = NULL;
3293
3294         /* Destroy the DTMF hooks container. */
3295         ao2_cleanup(features->dtmf_hooks);
3296         features->dtmf_hooks = NULL;
3297 }
3298
3299 void ast_bridge_features_destroy(struct ast_bridge_features *features)
3300 {
3301         if (!features) {
3302                 return;
3303         }
3304         ast_bridge_features_cleanup(features);
3305         ast_free(features);
3306 }
3307
3308 struct ast_bridge_features *ast_bridge_features_new(void)
3309 {
3310         struct ast_bridge_features *features;
3311
3312         features = ast_malloc(sizeof(*features));
3313         if (features) {
3314                 if (ast_bridge_features_init(features)) {
3315                         ast_bridge_features_destroy(features);
3316                         features = NULL;
3317                 }
3318         }
3319
3320         return features;
3321 }
3322
3323 void ast_bridge_set_mixing_interval(struct ast_bridge *bridge, unsigned int mixing_interval)
3324 {
3325         ast_bridge_lock(bridge);
3326         bridge->softmix.internal_mixing_interval = mixing_interval;
3327         ast_bridge_unlock(bridge);
3328 }
3329
3330 void ast_bridge_set_internal_sample_rate(struct ast_bridge *bridge, unsigned int sample_rate)
3331 {
3332         ast_bridge_lock(bridge);
3333         bridge->softmix.internal_sample_rate = sample_rate;
3334         ast_bridge_unlock(bridge);
3335 }
3336
3337 static void cleanup_video_mode(struct ast_bridge *bridge)
3338 {
3339         switch (bridge->softmix.video_mode.mode) {
3340         case AST_BRIDGE_VIDEO_MODE_NONE:
3341                 break;
3342         case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC:
3343                 if (bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc) {
3344                         ast_channel_unref(bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc);
3345                 }
3346                 break;
3347         case AST_BRIDGE_VIDEO_MODE_TALKER_SRC:
3348                 if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc) {
3349                         ast_channel_unref(bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc);
3350                 }
3351                 if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc) {
3352                         ast_channel_unref(bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc);
3353                 }
3354         }
3355         memset(&bridge->softmix.video_mode, 0, sizeof(bridge->softmix.video_mode));
3356 }
3357
3358 void ast_bridge_set_single_src_video_mode(struct ast_bridge *bridge, struct ast_channel *video_src_chan)
3359 {
3360         ast_bridge_lock(bridge);
3361         cleanup_video_mode(bridge);
3362         bridge->softmix.video_mode.mode = AST_BRIDGE_VIDEO_MODE_SINGLE_SRC;
3363         bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc = ast_channel_ref(video_src_chan);
3364         ast_test_suite_event_notify("BRIDGE_VIDEO_MODE", "Message: video mode set to single source\r\nVideo Mode: %d\r\nVideo Channel: %s",
3365                 bridge->softmix.video_mode.mode, ast_channel_name(video_src_chan));
3366         ast_indicate(video_src_chan, AST_CONTROL_VIDUPDATE);
3367         ast_bridge_unlock(bridge);
3368 }
3369
3370 void ast_bridge_set_talker_src_video_mode(struct ast_bridge *bridge)
3371 {
3372         ast_bridge_lock(bridge);
3373         cleanup_video_mode(bridge);
3374         bridge->softmix.video_mode.mode = AST_BRIDGE_VIDEO_MODE_TALKER_SRC;
3375         ast_test_suite_event_notify("BRIDGE_VIDEO_MODE", "Message: video mode set to talker source\r\nVideo Mode: %d",
3376                 bridge->softmix.video_mode.mode);
3377         ast_bridge_unlock(bridge);
3378 }
3379
3380 void ast_bridge_update_talker_src_video_mode(struct ast_bridge *bridge, struct ast_channel *chan, int talker_energy, int is_keyframe)
3381 {
3382         struct ast_bridge_video_talker_src_data *data;
3383
3384         /* If the channel doesn't support video, we don't care about it */
3385         if (!ast_format_cap_has_type(ast_channel_nativeformats(chan), AST_FORMAT_TYPE_VIDEO)) {
3386                 return;
3387         }
3388
3389         ast_bridge_lock(bridge);
3390         data = &bridge->softmix.video_mode.mode_data.talker_src_data;
3391
3392         if (data->chan_vsrc == chan) {
3393                 data->average_talking_energy = talker_energy;
3394         } else if ((data->average_talking_energy < talker_energy) && is_keyframe) {
3395                 if (data->chan_old_vsrc) {
3396                         ast_channel_unref(data->chan_old_vsrc);
3397                 }
3398                 if (data->chan_vsrc) {
3399                         data->chan_old_vsrc = data->chan_vsrc;
3400                         ast_indicate(data->chan_old_vsrc, AST_CONTROL_VIDUPDATE);
3401                 }
3402                 data->chan_vsrc = ast_channel_ref(chan);
3403                 data->average_talking_energy = talker_energy;