Asterisk - The Open Source Telephony Project GIT-master-f3e88d3
bridge_channel.c
Go to the documentation of this file.
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 Channel API
22 *
23 * \author Joshua Colp <jcolp@digium.com>
24 * \author Richard Mudgett <rmudgett@digium.com>
25 * \author Matt Jordan <mjordan@digium.com>
26 *
27 */
28
29/*** MODULEINFO
30 <support_level>core</support_level>
31 ***/
32
33#include "asterisk.h"
34
35#include <signal.h>
36
37#include "asterisk/heap.h"
38#include "asterisk/alertpipe.h"
39#include "asterisk/astobj2.h"
41#include "asterisk/app.h"
42#include "asterisk/pbx.h"
43#include "asterisk/channel.h"
44#include "asterisk/timing.h"
45#include "asterisk/bridge.h"
54#include "asterisk/parking.h"
55#include "asterisk/causes.h"
56#include "asterisk/test.h"
57#include "asterisk/sem.h"
58#include "asterisk/stream.h"
59#include "asterisk/message.h"
60#include "asterisk/core_local.h"
61
62/*!
63 * \brief Used to queue an action frame onto a bridge channel and write an action frame into a bridge.
64 * \since 12.0.0
65 *
66 * \param bridge_channel Which channel work with.
67 * \param action Type of bridge action frame.
68 * \param data Frame payload data to pass.
69 * \param datalen Frame payload data length to pass.
70 *
71 * \retval 0 on success.
72 * \retval -1 on error.
73 */
74typedef int (*ast_bridge_channel_post_action_data)(struct ast_bridge_channel *bridge_channel, enum bridge_channel_action_type action, const void *data, size_t datalen);
75
76/*!
77 * \brief Counter used for assigning synchronous bridge action IDs
78 */
79static int sync_ids;
80
81/*!
82 * \brief Frame payload for synchronous bridge actions.
83 *
84 * The payload serves as a wrapper around the actual payload of the
85 * frame, with the addition of an id used to find the associated
86 * bridge_sync object.
87 */
89 /*! Unique ID for this synchronous action */
90 unsigned int id;
91 /*! Actual frame data to process */
92 unsigned char data[0];
93};
94
95/*!
96 * \brief Synchronous bridge action object.
97 *
98 * Synchronous bridge actions require the ability for one thread to wait
99 * and for another thread to indicate that the action has completed. This
100 * structure facilitates that goal by providing synchronization structures.
101 */
103 /*! Unique ID of this synchronization object. Corresponds with ID in synchronous frame payload */
104 unsigned int id;
105 /*! Semaphore used for synchronization */
106 struct ast_sem sem;
107 /*! Pointer to next entry in the list */
109};
110
111/*!
112 * \brief List holding active synchronous action objects.
113 */
115
116/*!
117 * \brief Initialize a synchronous bridge object.
118 *
119 * This both initializes the structure and adds it to the list of
120 * synchronization structures.
121 *
122 * \param sync_struct The synchronization object to initialize.
123 * \param id ID to assign to the synchronization object.
124 */
125static void bridge_sync_init(struct bridge_sync *sync_struct, unsigned int id)
126{
127 memset(sync_struct, 0, sizeof(*sync_struct));
128 sync_struct->id = id;
129 ast_sem_init(&sync_struct->sem, 0, 0);
130
132 AST_RWLIST_INSERT_TAIL(&sync_structs, sync_struct, list);
134}
135
136/*!
137 * \brief Clean up a synchronization bridge object.
138 *
139 * This frees fields within the synchronization object and removes
140 * it from the list of active synchronization objects.
141 *
142 * Since synchronization objects are stack-allocated, it is vital
143 * that this is called before the synchronization object goes
144 * out of scope.
145 *
146 * \param sync_struct Synchronization object to clean up.
147 */
148static void bridge_sync_cleanup(struct bridge_sync *sync_struct)
149{
150 struct bridge_sync *iter;
151
154 if (iter->id == sync_struct->id) {
156 break;
157 }
158 }
161
162 ast_sem_destroy(&sync_struct->sem);
163}
164
165/*!
166 * \brief Failsafe for synchronous bridge action waiting.
167 *
168 * When waiting for a synchronous bridge action to complete,
169 * if there is a frame resource leak somewhere, it is possible
170 * that we will never get notified that the synchronous action
171 * completed.
172 *
173 * If a significant amount of time passes, then we will abandon
174 * waiting for the synchrnous bridge action to complete.
175 *
176 * This constant represents the number of milliseconds we will
177 * wait for the bridge action to complete.
178 */
179#define PLAYBACK_TIMEOUT (600 * 1000)
180
181/*!
182 * \brief Wait for a synchronous bridge action to complete.
183 *
184 * \param sync_struct Synchronization object corresponding to the bridge action.
185 */
186static void bridge_sync_wait(struct bridge_sync *sync_struct)
187{
188 struct timeval timeout_val = ast_tvadd(ast_tvnow(), ast_samp2tv(PLAYBACK_TIMEOUT, 1000));
189 struct timespec timeout_spec = {
190 .tv_sec = timeout_val.tv_sec,
191 .tv_nsec = timeout_val.tv_usec * 1000,
192 };
193
194 ast_sem_timedwait(&sync_struct->sem, &timeout_spec);
195}
196
197/*!
198 * \brief Signal that waiting for a synchronous bridge action is no longer necessary.
199 *
200 * This may occur for several reasons
201 * \li The synchronous bridge action has completed.
202 * \li The bridge channel has been removed from the bridge.
203 * \li The synchronous bridge action could not be queued.
204 *
205 * \param sync_struct Synchronization object corresponding to the bridge action.
206 */
207static void bridge_sync_signal(struct bridge_sync *sync_struct)
208{
209 ast_sem_post(&sync_struct->sem);
210}
211
213{
214 struct ast_channel *chan;
215
219
220 return chan;
221}
222
224{
225 struct ast_bridge *bridge;
226
227 for (;;) {
228 /* Safely get the bridge pointer */
229 ast_bridge_channel_lock(bridge_channel);
230 bridge = bridge_channel->bridge;
231 ao2_ref(bridge, +1);
232 ast_bridge_channel_unlock(bridge_channel);
233
234 /* Lock the bridge and see if it is still the bridge we need to lock. */
235 ast_bridge_lock(bridge);
236 if (bridge == bridge_channel->bridge) {
237 ao2_ref(bridge, -1);
238 return;
239 }
240 ast_bridge_unlock(bridge);
241 ao2_ref(bridge, -1);
242 }
243}
244
245int ast_bridge_channel_notify_talking(struct ast_bridge_channel *bridge_channel, int started_talking)
246{
247 struct ast_frame action = {
249 .subclass.integer = started_talking
251 };
252
253 return ast_bridge_channel_queue_frame(bridge_channel, &action);
254}
255
256/*!
257 * \internal
258 * \brief Poke the bridge_channel thread
259 */
260static void bridge_channel_poke(struct ast_bridge_channel *bridge_channel)
261{
262 if (!pthread_equal(pthread_self(), bridge_channel->thread)) {
263 /* Wake up the bridge channel thread. */
264 ast_queue_frame(bridge_channel->chan, &ast_null_frame);
265 }
266}
267
268/*!
269 * \internal
270 * \brief Set actual cause on channel.
271 * \since 12.0.0
272 *
273 * \param chan Channel to set cause.
274 * \param cause Cause to set on channel.
275 * If cause <= 0 then use cause on channel if cause still <= 0 use AST_CAUSE_NORMAL_CLEARING.
276 *
277 * \return Actual cause set on channel.
278 */
279static int channel_set_cause(struct ast_channel *chan, int cause)
280{
281 ast_channel_lock(chan);
282 if (cause <= 0) {
283 cause = ast_channel_hangupcause(chan);
284 if (cause <= 0) {
286 }
287 }
288 ast_channel_hangupcause_set(chan, cause);
289 ast_channel_unlock(chan);
290 return cause;
291}
292
293void ast_bridge_channel_leave_bridge_nolock(struct ast_bridge_channel *bridge_channel, enum bridge_channel_state new_state, int cause)
294{
295 if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
296 return;
297 }
298
299 ast_debug(1, "Setting %p(%s) state from:%u to:%u\n",
300 bridge_channel, ast_channel_name(bridge_channel->chan), bridge_channel->state,
301 new_state);
302
303 channel_set_cause(bridge_channel->chan, cause);
304
305 ast_channel_lock(bridge_channel->chan);
306 ast_bridge_vars_set(bridge_channel->chan, NULL, NULL);
307 ast_channel_unlock(bridge_channel->chan);
308
309 /* Change the state on the bridge channel */
310 bridge_channel->state = new_state;
311
312 bridge_channel_poke(bridge_channel);
313}
314
315void ast_bridge_channel_leave_bridge(struct ast_bridge_channel *bridge_channel, enum bridge_channel_state new_state, int cause)
316{
317 ast_bridge_channel_lock(bridge_channel);
318 ast_bridge_channel_leave_bridge_nolock(bridge_channel, new_state, cause);
319 ast_bridge_channel_unlock(bridge_channel);
320}
321
323{
324 struct ast_bridge *bridge = bridge_channel->bridge;
325 struct ast_bridge_channel *other = NULL;
326
327 if (bridge_channel->in_bridge && bridge->num_channels == 2) {
329 if (other != bridge_channel) {
330 break;
331 }
332 }
333 }
334
335 return other;
336}
337
339{
340 ast_assert(bridge_channel->read_format != NULL);
341 ast_assert(bridge_channel->write_format != NULL);
342
343 ast_channel_lock(bridge_channel->chan);
344
345 /* Restore original formats of the channel as they came in */
346 if (ast_format_cmp(ast_channel_readformat(bridge_channel->chan), bridge_channel->read_format) == AST_FORMAT_CMP_NOT_EQUAL) {
347 ast_debug(1, "Bridge is returning %p(%s) to read format %s\n",
348 bridge_channel, ast_channel_name(bridge_channel->chan),
349 ast_format_get_name(bridge_channel->read_format));
350 if (ast_set_read_format(bridge_channel->chan, bridge_channel->read_format)) {
351 ast_debug(1, "Bridge failed to return %p(%s) to read format %s\n",
352 bridge_channel, ast_channel_name(bridge_channel->chan),
353 ast_format_get_name(bridge_channel->read_format));
354 }
355 }
356 if (ast_format_cmp(ast_channel_writeformat(bridge_channel->chan), bridge_channel->write_format) == AST_FORMAT_CMP_NOT_EQUAL) {
357 ast_debug(1, "Bridge is returning %p(%s) to write format %s\n",
358 bridge_channel, ast_channel_name(bridge_channel->chan),
359 ast_format_get_name(bridge_channel->write_format));
360 if (ast_set_write_format(bridge_channel->chan, bridge_channel->write_format)) {
361 ast_debug(1, "Bridge failed to return %p(%s) to write format %s\n",
362 bridge_channel, ast_channel_name(bridge_channel->chan),
363 ast_format_get_name(bridge_channel->write_format));
364 }
365 }
366
367 ast_channel_unlock(bridge_channel->chan);
368}
369
371{
372 struct ast_bridge *bridge;
373
374 ast_bridge_channel_lock_bridge(bridge_channel);
375 bridge = bridge_channel->bridge;
376 ao2_ref(bridge, +1);
378 ast_bridge_unlock(bridge);
379 return bridge;
380}
381
383{
384 struct ast_bridge_channel *other;
385 struct ast_bridge *bridge = bridge_channel->bridge;
386 struct ast_channel *oldest_linkedid_chan = bridge_channel->chan;
387
389 if (other == swap) {
390 continue;
391 }
392 oldest_linkedid_chan = ast_channel_internal_oldest_linkedid(
393 oldest_linkedid_chan, other->chan);
394 }
395
400 if (other == swap) {
401 continue;
402 }
403 ast_channel_lock(other->chan);
404 ast_channel_internal_copy_linkedid(other->chan, oldest_linkedid_chan);
405 ast_channel_unlock(other->chan);
406 }
407}
408
409/*!
410 * \internal
411 * \brief Set dest's empty peeraccount with the src's non-empty accountcode.
412 * \since 12.5.0
413 *
414 * \param dest Channel to update peeraccount.
415 * \param src Channel to get accountcode from.
416 *
417 * \note Both channels are already locked.
418 */
419static void channel_fill_empty_peeraccount(struct ast_channel *dest, struct ast_channel *src)
420{
423 ast_debug(1, "Setting channel %s peeraccount with channel %s accountcode '%s'.\n",
424 ast_channel_name(dest),
426 ast_channel_peeraccount_set(dest, ast_channel_accountcode(src));
427 }
428}
429
430/*!
431 * \internal
432 * \brief Set dest's empty accountcode with the src's non-empty peeraccount.
433 * \since 12.5.0
434 *
435 * \param dest Channel to update accountcode.
436 * \param src Channel to get peeraccount from.
437 *
438 * \note Both channels are already locked.
439 */
440static void channel_fill_empty_accountcode(struct ast_channel *dest, struct ast_channel *src)
441{
444 ast_debug(1, "Setting channel %s accountcode with channel %s peeraccount '%s'.\n",
445 ast_channel_name(dest),
447 ast_channel_accountcode_set(dest, ast_channel_peeraccount(src));
448 }
449}
450
451/*!
452 * \internal
453 * \brief Set empty peeraccount and accountcode in a channel from the other channel.
454 * \since 12.5.0
455 *
456 * \param c0 First bridge channel to update.
457 * \param c1 Second bridge channel to update.
458 *
459 * \note Both channels are already locked.
460 */
461static void channel_set_empty_accountcodes(struct ast_channel *c0, struct ast_channel *c1)
462{
463 /* Set empty peeraccount from the other channel's accountcode. */
466
467 /* Set empty accountcode from the other channel's peeraccount. */
470}
471
472/*!
473 * \internal
474 * \brief Update dest's peeraccount with the src's different accountcode.
475 * \since 12.5.0
476 *
477 * \param dest Channel to update peeraccount.
478 * \param src Channel to get accountcode from.
479 *
480 * \note Both channels are already locked.
481 */
482static void channel_update_peeraccount(struct ast_channel *dest, struct ast_channel *src)
483{
484 if (strcmp(ast_channel_accountcode(src), ast_channel_peeraccount(dest))) {
485 ast_debug(1, "Changing channel %s peeraccount '%s' to match channel %s accountcode '%s'.\n",
488 ast_channel_peeraccount_set(dest, ast_channel_accountcode(src));
489 }
490}
491
492/*!
493 * \internal
494 * \brief Update peeraccounts to match the other channel's accountcode.
495 * \since 12.5.0
496 *
497 * \param c0 First channel to update.
498 * \param c1 Second channel to update.
499 *
500 * \note Both channels are already locked.
501 */
502static void channel_update_peeraccounts(struct ast_channel *c0, struct ast_channel *c1)
503{
506}
507
508/*!
509 * \internal
510 * \brief Update channel accountcodes because a channel is joining a bridge.
511 * \since 12.5.0
512 *
513 * \param joining Channel joining the bridge.
514 * \param swap Channel being replaced by the joining channel. May be NULL.
515 *
516 * \note The bridge must be locked prior to calling this function.
517 */
519{
520 struct ast_bridge *bridge = joining->bridge;
521 struct ast_bridge_channel *other;
522 unsigned int swap_in_bridge = 0;
523 unsigned int will_be_two_party;
524
525 /*
526 * Only update the peeraccount to match if the joining channel
527 * will make it a two party bridge.
528 */
529 if (bridge->num_channels <= 2 && swap) {
531 if (other == swap) {
532 swap_in_bridge = 1;
533 break;
534 }
535 }
536 }
537 will_be_two_party = (1 == bridge->num_channels - swap_in_bridge);
538
540 if (other == swap) {
541 continue;
542 }
543 ast_assert(joining != other);
544 ast_channel_lock_both(joining->chan, other->chan);
545 channel_set_empty_accountcodes(joining->chan, other->chan);
546 if (will_be_two_party) {
547 channel_update_peeraccounts(joining->chan, other->chan);
548 }
549 ast_channel_unlock(joining->chan);
550 ast_channel_unlock(other->chan);
551 }
552}
553
554/*!
555 * \internal
556 * \brief Update channel peeraccount codes because a channel has left a bridge.
557 * \since 12.5.0
558 *
559 * \param leaving Channel leaving the bridge. (Has already been removed actually)
560 *
561 * \note The bridge must be locked prior to calling this function.
562 */
564{
565 struct ast_bridge *bridge = leaving->bridge;
567 struct ast_bridge_channel *second;
568
569 if (bridge->num_channels != 2 || bridge->dissolved) {
570 return;
571 }
572
574 second = AST_LIST_LAST(&bridge->channels);
575 ast_assert(first && first != second);
576 ast_channel_lock_both(first->chan, second->chan);
578 channel_update_peeraccounts(first->chan, second->chan);
579 ast_channel_unlock(second->chan);
581}
582
584{
585 if (joining) {
587 } else {
589 }
590}
591
592void ast_bridge_channel_kick(struct ast_bridge_channel *bridge_channel, int cause)
593{
594 struct ast_bridge_features *features = bridge_channel->features;
595 struct ast_bridge_hook *hook;
596 struct ao2_iterator iter;
597
598 ast_bridge_channel_lock(bridge_channel);
599 if (bridge_channel->state == BRIDGE_CHANNEL_STATE_WAIT) {
600 channel_set_cause(bridge_channel->chan, cause);
601 cause = 0;
602 }
603 ast_bridge_channel_unlock(bridge_channel);
604
605 /* Run any hangup hooks. */
606 iter = ao2_iterator_init(features->other_hooks, 0);
607 for (; (hook = ao2_iterator_next(&iter)); ao2_ref(hook, -1)) {
608 int remove_me;
609
610 if (hook->type != AST_BRIDGE_HOOK_TYPE_HANGUP) {
611 continue;
612 }
613 remove_me = hook->callback(bridge_channel, hook->hook_pvt);
614 if (remove_me) {
615 ast_debug(1, "Hangup hook %p is being removed from %p(%s)\n",
616 hook, bridge_channel, ast_channel_name(bridge_channel->chan));
617 ao2_unlink(features->other_hooks, hook);
618 }
619 }
621
622 /* Default hangup action. */
624}
625
626/*!
627 * \internal
628 * \brief Write an \ref ast_frame into the bridge
629 * \since 12.0.0
630 *
631 * \param bridge_channel Which channel is queueing the frame.
632 * \param frame The frame to write into the bridge
633 *
634 * \retval 0 on success.
635 * \retval -1 on error.
636 */
637static int bridge_channel_write_frame(struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
638{
639 const struct ast_control_t38_parameters *t38_parameters;
640 int unmapped_stream_num;
641 int deferred;
642
644
645 ast_bridge_channel_lock_bridge(bridge_channel);
646
647 /*
648 * Map the frame to the bridge.
649 * We need to lock the bridge_channel to make sure that bridge_channel->chan
650 * isn't NULL and keep it locked while we do multistream processing.
651 */
652 ast_bridge_channel_lock(bridge_channel);
653 if (bridge_channel->chan && ast_channel_is_multistream(bridge_channel->chan)) {
654 unmapped_stream_num = frame->stream_num;
655 switch (frame->frametype) {
656 case AST_FRAME_VOICE:
657 case AST_FRAME_VIDEO:
658 case AST_FRAME_TEXT:
659 case AST_FRAME_IMAGE:
660 case AST_FRAME_RTCP:
661 /* These frames need to be mapped to an appropriate write stream */
662 if (frame->stream_num < 0) {
663 /* Map to default stream */
664 frame->stream_num = -1;
665 break;
666 }
667 if (frame->stream_num < (int)AST_VECTOR_SIZE(&bridge_channel->stream_map.to_bridge)) {
668 frame->stream_num = AST_VECTOR_GET(
669 &bridge_channel->stream_map.to_bridge, frame->stream_num);
670 if (0 <= frame->stream_num) {
671 break;
672 }
673 }
674 ast_bridge_channel_unlock(bridge_channel);
675 ast_bridge_unlock(bridge_channel->bridge);
676 /*
677 * Ignore frame because we don't know how to map the frame
678 * or the bridge is not expecting any media from that
679 * stream.
680 */
681 return 0;
684 /*
685 * XXX It makes sense that DTMF could be on any audio stream.
686 * For now we will only put it on the default audio stream.
687 */
688 default:
689 frame->stream_num = -1;
690 break;
691 }
692 } else {
693 unmapped_stream_num = -1;
694 frame->stream_num = -1;
695 }
696 ast_bridge_channel_unlock(bridge_channel);
697
698 deferred = bridge_channel->bridge->technology->write(bridge_channel->bridge, bridge_channel, frame);
699 if (deferred) {
700 struct ast_frame *dup;
701
702 dup = ast_frdup(frame);
703 if (dup) {
704 /*
705 * We have to unmap the deferred frame so it comes back
706 * in like a new frame.
707 */
708 dup->stream_num = unmapped_stream_num;
709 ast_bridge_channel_lock(bridge_channel);
710 AST_LIST_INSERT_HEAD(&bridge_channel->deferred_queue, dup, frame_list);
711 ast_bridge_channel_unlock(bridge_channel);
712 }
713 }
714
715 /* Remember any owed events to the bridge. */
716 switch (frame->frametype) {
718 bridge_channel->owed.dtmf_tv = ast_tvnow();
719 bridge_channel->owed.dtmf_digit = frame->subclass.integer;
720 break;
722 bridge_channel->owed.dtmf_digit = '\0';
723 break;
725 /*
726 * We explicitly will not remember HOLD/UNHOLD frames because
727 * things like attended transfers will handle them.
728 */
729 switch (frame->subclass.integer) {
731 t38_parameters = frame->data.ptr;
732 switch (t38_parameters->request_response) {
735 bridge_channel->owed.t38_terminate = 1;
736 break;
739 case AST_T38_REFUSED:
740 bridge_channel->owed.t38_terminate = 0;
741 break;
742 default:
743 break;
744 }
745 break;
746 default:
747 break;
748 }
749 break;
750 default:
751 break;
752 }
753 ast_bridge_unlock(bridge_channel->bridge);
754
755 /*
756 * Claim successful write to bridge. If deferred frame
757 * support is added, claim successfully deferred.
758 */
759 return 0;
760}
761
762/*!
763 * \internal
764 * \brief Cancel owed events by the channel to the bridge.
765 * \since 13.8.0
766 *
767 * \param bridge_channel Channel that owes events to the bridge.
768 *
769 * \note On entry, the bridge_channel->bridge is already locked.
770 */
771static void bridge_channel_cancel_owed_events(struct ast_bridge_channel *bridge_channel)
772{
773 bridge_channel->owed.dtmf_digit = '\0';
774 bridge_channel->owed.t38_terminate = 0;
775}
776
777void bridge_channel_settle_owed_events(struct ast_bridge *orig_bridge, struct ast_bridge_channel *bridge_channel)
778{
779 if (bridge_channel->owed.dtmf_digit) {
780 struct ast_frame frame = {
782 .subclass.integer = bridge_channel->owed.dtmf_digit,
783 .src = "Bridge channel owed DTMF",
784 };
785
786 frame.len = ast_tvdiff_ms(ast_tvnow(), bridge_channel->owed.dtmf_tv);
787 if (frame.len < option_dtmfminduration) {
789 }
790 ast_log(LOG_DTMF, "DTMF end '%c' simulated to bridge %s because %s left. Duration %ld ms.\n",
791 bridge_channel->owed.dtmf_digit, orig_bridge->uniqueid,
792 ast_channel_name(bridge_channel->chan), frame.len);
793 bridge_channel->owed.dtmf_digit = '\0';
794 orig_bridge->technology->write(orig_bridge, NULL, &frame);
795 }
796 if (bridge_channel->owed.t38_terminate) {
797 struct ast_control_t38_parameters t38_parameters = {
799 };
800 struct ast_frame frame = {
802 .subclass.integer = AST_CONTROL_T38_PARAMETERS,
803 .data.ptr = &t38_parameters,
804 .datalen = sizeof(t38_parameters),
805 .src = "Bridge channel owed T.38 terminate",
806 };
807
808 ast_debug(1, "T.38 terminate simulated to bridge %s because %s left.\n",
809 orig_bridge->uniqueid, ast_channel_name(bridge_channel->chan));
810 bridge_channel->owed.t38_terminate = 0;
811 orig_bridge->technology->write(orig_bridge, NULL, &frame);
812 }
813}
814
816{
817 struct ast_frame *frame;
818
819 ast_bridge_channel_lock(bridge_channel);
820 ast_channel_lock(bridge_channel->chan);
821 while ((frame = AST_LIST_REMOVE_HEAD(&bridge_channel->deferred_queue, frame_list))) {
822 ast_queue_frame_head(bridge_channel->chan, frame);
823 ast_frfree(frame);
824 }
825 ast_channel_unlock(bridge_channel->chan);
826 ast_bridge_channel_unlock(bridge_channel);
827}
828
830{
831 bridge_channel->suspended = 1;
832 if (bridge_channel->in_bridge) {
833 --bridge_channel->bridge->num_active;
834 }
835
836 /* Get technology bridge threads off of the channel. */
837 if (bridge_channel->bridge->technology->suspend) {
838 bridge_channel->bridge->technology->suspend(bridge_channel->bridge, bridge_channel);
839 }
840}
841
842/*!
843 * \internal
844 * \brief Suspend a channel from a bridge.
845 *
846 * \param bridge_channel Channel to suspend.
847 */
848static void bridge_channel_suspend(struct ast_bridge_channel *bridge_channel)
849{
850 ast_bridge_channel_lock_bridge(bridge_channel);
852 ast_bridge_unlock(bridge_channel->bridge);
853}
854
856{
857 bridge_channel->suspended = 0;
858 if (bridge_channel->in_bridge) {
859 ++bridge_channel->bridge->num_active;
860 }
861
862 /* Wake technology bridge threads to take care of channel again. */
863 if (bridge_channel->bridge->technology->unsuspend) {
864 bridge_channel->bridge->technology->unsuspend(bridge_channel->bridge, bridge_channel);
865 }
866
867 /* Wake suspended channel. */
868 ast_bridge_channel_lock(bridge_channel);
869 ast_cond_signal(&bridge_channel->cond);
870 ast_bridge_channel_unlock(bridge_channel);
871}
872
873/*!
874 * \internal
875 * \brief Unsuspend a channel from a bridge.
876 *
877 * \param bridge_channel Channel to unsuspend.
878 */
879static void bridge_channel_unsuspend(struct ast_bridge_channel *bridge_channel)
880{
881 ast_bridge_channel_lock_bridge(bridge_channel);
883 ast_bridge_unlock(bridge_channel->bridge);
884}
885
886/*!
887 * \internal
888 * \brief Queue an action frame onto the bridge channel with data.
889 * \since 12.0.0
890 *
891 * \param bridge_channel Which channel to queue the frame onto.
892 * \param action Type of bridge action frame.
893 * \param data Frame payload data to pass.
894 * \param datalen Frame payload data length to pass.
895 *
896 * \retval 0 on success.
897 * \retval -1 on error.
898 */
899static int bridge_channel_queue_action_data(struct ast_bridge_channel *bridge_channel,
900 enum bridge_channel_action_type action, const void *data, size_t datalen)
901{
902 struct ast_frame frame = {
904 .subclass.integer = action,
905 .datalen = datalen,
906 .data.ptr = (void *) data,
907 };
908
909 return ast_bridge_channel_queue_frame(bridge_channel, &frame);
910}
911
912/*!
913 * \internal
914 * \brief Queue an action frame onto the bridge channel with data synchronously.
915 * \since 12.2.0
916 *
917 * The function will not return until the queued frame is freed.
918 *
919 * \param bridge_channel Which channel to queue the frame onto.
920 * \param action Type of bridge action frame.
921 * \param data Frame payload data to pass.
922 * \param datalen Frame payload data length to pass.
923 *
924 * \retval 0 on success.
925 * \retval -1 on error.
926 */
928 enum bridge_channel_action_type action, const void *data, size_t datalen)
929{
931 int sync_payload_len = sizeof(*sync_payload) + datalen;
932 struct bridge_sync sync_struct;
933 struct ast_frame frame = {
935 .subclass.integer = action,
936 };
937
938 /* Make sure we don't end up trying to wait on ourself to deliver the frame */
939 ast_assert(!pthread_equal(pthread_self(), bridge_channel->thread));
940
941 sync_payload = ast_alloca(sync_payload_len);
943 memcpy(sync_payload->data, data, datalen);
944
945 frame.datalen = sync_payload_len;
946 frame.data.ptr = sync_payload;
947
948 bridge_sync_init(&sync_struct, sync_payload->id);
949 if (ast_bridge_channel_queue_frame(bridge_channel, &frame)) {
950 bridge_sync_cleanup(&sync_struct);
951 return -1;
952 }
953
954 bridge_sync_wait(&sync_struct);
955 bridge_sync_cleanup(&sync_struct);
956 return 0;
957}
958/*!
959 * \internal
960 * \brief Write an action frame onto the bridge channel with data.
961 * \since 12.0.0
962 *
963 * \param bridge_channel Which channel to queue the frame onto.
964 * \param action Type of bridge action frame.
965 * \param data Frame payload data to pass.
966 * \param datalen Frame payload data length to pass.
967 *
968 * \retval 0 on success.
969 * \retval -1 on error.
970 */
971static int bridge_channel_write_action_data(struct ast_bridge_channel *bridge_channel,
972 enum bridge_channel_action_type action, const void *data, size_t datalen)
973{
974 struct ast_frame frame = {
976 .subclass.integer = action,
977 .datalen = datalen,
978 .data.ptr = (void *) data,
979 };
980
981 return bridge_channel_write_frame(bridge_channel, &frame);
982}
983
984static void bridge_frame_free(struct ast_frame *frame)
985{
987 struct sync_payload *sync_payload = frame->data.ptr;
988 struct bridge_sync *sync;
989
992 if (sync->id == sync_payload->id) {
993 break;
994 }
995 }
996 if (sync) {
997 bridge_sync_signal(sync);
998 }
1000 }
1001
1002 ast_frfree(frame);
1003}
1004
1005int ast_bridge_channel_queue_frame(struct ast_bridge_channel *bridge_channel, struct ast_frame *fr)
1006{
1007 struct ast_frame *dup;
1008
1009 if (bridge_channel->suspended
1010 /* Also defer DTMF frames. */
1013 && !ast_is_deferrable_frame(fr)) {
1014 /* Drop non-deferable frames when suspended. */
1015 return 0;
1016 }
1017 if (fr->frametype == AST_FRAME_NULL) {
1018 /* "Accept" the frame and discard it. */
1019 return 0;
1020 }
1021
1022 if ((fr->frametype == AST_FRAME_VOICE || fr->frametype == AST_FRAME_VIDEO ||
1024 fr->frametype == AST_FRAME_RTCP) && fr->stream_num > -1) {
1025 int num = -1;
1026
1027 ast_bridge_channel_lock(bridge_channel);
1028 if (fr->stream_num < (int)AST_VECTOR_SIZE(&bridge_channel->stream_map.to_channel)) {
1029 num = AST_VECTOR_GET(&bridge_channel->stream_map.to_channel, fr->stream_num);
1030 }
1031 ast_bridge_channel_unlock(bridge_channel);
1032
1033 if (num == -1) {
1034 /* We don't have a mapped stream so just discard this frame. */
1035 return 0;
1036 }
1037 }
1038
1039 dup = ast_frdup(fr);
1040 if (!dup) {
1041 return -1;
1042 }
1043
1044 ast_bridge_channel_lock(bridge_channel);
1045 if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
1046 /* Drop frames on channels leaving the bridge. */
1047 ast_bridge_channel_unlock(bridge_channel);
1048 bridge_frame_free(dup);
1049 return 0;
1050 }
1051
1052 if ((fr->frametype == AST_FRAME_TEXT || fr->frametype == AST_FRAME_TEXT_DATA) &&
1053 !bridge_channel->features->text_messaging) {
1054 /* This channel is not accepting text messages. */
1055 ast_bridge_channel_unlock(bridge_channel);
1056 bridge_frame_free(dup);
1057 return 0;
1058 }
1059
1060 if (DEBUG_ATLEAST(1)) {
1061 if (fr->frametype == AST_FRAME_TEXT) {
1062 ast_log(LOG_DEBUG, "Queuing TEXT frame to '%s': %*.s\n", ast_channel_name(bridge_channel->chan),
1063 fr->datalen, (char *)fr->data.ptr);
1064 } else if (fr->frametype == AST_FRAME_TEXT_DATA) {
1065 struct ast_msg_data *msg = fr->data.ptr;
1066 ast_log(LOG_DEBUG, "Queueing TEXT_DATA frame from '%s' to '%s:%s': %s\n",
1069 ast_channel_name(bridge_channel->chan),
1071 }
1072 }
1073
1074 AST_LIST_INSERT_TAIL(&bridge_channel->wr_queue, dup, frame_list);
1075 if (ast_alertpipe_write(bridge_channel->alert_pipe)) {
1076 ast_log(LOG_ERROR, "We couldn't write alert pipe for %p(%s)... something is VERY wrong\n",
1077 bridge_channel, ast_channel_name(bridge_channel->chan));
1078 }
1079 ast_bridge_channel_unlock(bridge_channel);
1080 return 0;
1081}
1082
1083int ast_bridge_queue_everyone_else(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
1084{
1085 struct ast_bridge_channel *cur;
1086 int not_written = -1;
1087
1088 if (frame->frametype == AST_FRAME_NULL) {
1089 /* "Accept" the frame and discard it. */
1090 return 0;
1091 }
1092
1094 if (cur == bridge_channel) {
1095 continue;
1096 }
1097 if (!ast_bridge_channel_queue_frame(cur, frame)) {
1098 not_written = 0;
1099 }
1100 }
1101 return not_written;
1102}
1103
1104int ast_bridge_channel_queue_control_data(struct ast_bridge_channel *bridge_channel, enum ast_control_frame_type control, const void *data, size_t datalen)
1105{
1106 struct ast_frame frame = {
1108 .subclass.integer = control,
1109 .datalen = datalen,
1110 .data.ptr = (void *) data,
1111 };
1112
1113 return ast_bridge_channel_queue_frame(bridge_channel, &frame);
1114}
1115
1116int ast_bridge_channel_write_control_data(struct ast_bridge_channel *bridge_channel, enum ast_control_frame_type control, const void *data, size_t datalen)
1117{
1118 struct ast_frame frame = {
1120 .subclass.integer = control,
1121 .datalen = datalen,
1122 .data.ptr = (void *) data,
1123 };
1124
1125 return bridge_channel_write_frame(bridge_channel, &frame);
1126}
1127
1128int ast_bridge_channel_write_hold(struct ast_bridge_channel *bridge_channel, const char *moh_class)
1129{
1130 struct ast_json *blob;
1131 int res;
1132 size_t datalen;
1133
1134 if (!ast_strlen_zero(moh_class)) {
1135 datalen = strlen(moh_class) + 1;
1136
1137 blob = ast_json_pack("{s: s}",
1138 "musicclass", moh_class);
1139 } else {
1140 moh_class = NULL;
1141 datalen = 0;
1142 blob = NULL;
1143 }
1144
1146
1148 moh_class, datalen);
1149
1150 ast_json_unref(blob);
1151 return res;
1152}
1153
1155{
1157
1158 if (!chan) {
1159 return -1;
1160 }
1161
1163 ao2_ref(chan, -1);
1164
1166}
1167
1168/*!
1169 * \internal
1170 * \brief Helper function to kick off a PBX app on a bridge_channel
1171 */
1172static int run_app_helper(struct ast_channel *chan, const char *app_name, const char *app_args)
1173{
1174 int res = 0;
1175
1176 if (!strcasecmp("Gosub", app_name)) {
1177 ast_app_exec_sub(NULL, chan, app_args, 0);
1178 } else {
1179 res = ast_pbx_exec_application(chan, app_name, app_args);
1180 }
1181 return res;
1182}
1183
1184void ast_bridge_channel_run_app(struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
1185{
1186 if (moh_class) {
1188 }
1189 if (run_app_helper(bridge_channel->chan, app_name, S_OR(app_args, ""))) {
1190 /* Break the bridge if the app returns non-zero. */
1192 }
1193 if (moh_class) {
1195 }
1196}
1197
1199 /*! Offset into app_name[] where the MOH class name starts. (zero if no MOH) */
1201 /*! Offset into app_name[] where the application argument string starts. (zero if no arguments) */
1203 /*! Application name to run. */
1204 char app_name[0];
1205};
1206
1207/*!
1208 * \internal
1209 * \brief Handle the run application bridge action.
1210 * \since 12.0.0
1211 *
1212 * \param bridge_channel Which channel to run the application on.
1213 * \param data Action frame data to run the application.
1214 */
1215static void bridge_channel_run_app(struct ast_bridge_channel *bridge_channel, struct bridge_run_app *data)
1216{
1217 ast_bridge_channel_run_app(bridge_channel, data->app_name,
1218 data->app_args_offset ? &data->app_name[data->app_args_offset] : NULL,
1219 data->moh_offset ? &data->app_name[data->moh_offset] : NULL);
1220}
1221
1222/*!
1223 * \internal
1224 * \brief Marshal an application to be executed on a bridge_channel
1225 */
1227 struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
1228{
1229 struct bridge_run_app *app_data;
1230 size_t len_name = strlen(app_name) + 1;
1231 size_t len_args = ast_strlen_zero(app_args) ? 0 : strlen(app_args) + 1;
1232 size_t len_moh = !moh_class ? 0 : strlen(moh_class) + 1;
1233 size_t len_data = sizeof(*app_data) + len_name + len_args + len_moh;
1234
1235 /* Fill in application run frame data. */
1236 app_data = alloca(len_data);
1237 app_data->app_args_offset = len_args ? len_name : 0;
1238 app_data->moh_offset = len_moh ? len_name + len_args : 0;
1239 strcpy(app_data->app_name, app_name);/* Safe */
1240 if (len_args) {
1241 strcpy(&app_data->app_name[app_data->app_args_offset], app_args);/* Safe */
1242 }
1243 if (moh_class) {
1244 strcpy(&app_data->app_name[app_data->moh_offset], moh_class);/* Safe */
1245 }
1246
1247 return post_it(bridge_channel, BRIDGE_CHANNEL_ACTION_RUN_APP, app_data, len_data);
1248}
1249
1250int ast_bridge_channel_write_app(struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
1251{
1253 bridge_channel, app_name, app_args, moh_class);
1254}
1255
1256int ast_bridge_channel_queue_app(struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
1257{
1259 bridge_channel, app_name, app_args, moh_class);
1260}
1261
1262void ast_bridge_channel_playfile(struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
1263{
1264 if (moh_class) {
1265 ast_bridge_channel_write_hold(bridge_channel, moh_class);
1266 }
1267 if (custom_play) {
1268 custom_play(bridge_channel, playfile);
1269 } else {
1270 ast_stream_and_wait(bridge_channel->chan, playfile, AST_DIGIT_NONE);
1271 }
1272 if (moh_class) {
1273 ast_bridge_channel_write_unhold(bridge_channel);
1274 }
1275
1276 /*
1277 * It may be necessary to resume music on hold after we finish
1278 * playing the announcment.
1279 */
1280 if (ast_test_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_MOH)) {
1281 const char *latest_musicclass;
1282
1283 ast_channel_lock(bridge_channel->chan);
1284 latest_musicclass = ast_strdupa(ast_channel_latest_musicclass(bridge_channel->chan));
1285 ast_channel_unlock(bridge_channel->chan);
1286 ast_moh_start(bridge_channel->chan, latest_musicclass, NULL);
1287 }
1288}
1289
1291 /*! Call this function to play the playfile. (NULL if normal sound file to play) */
1293 /*! Offset into playfile[] where the MOH class name starts. (zero if no MOH)*/
1295 /*! Filename to play. */
1296 char playfile[0];
1297};
1298
1299/*!
1300 * \internal
1301 * \brief Handle the playfile bridge action.
1302 * \since 12.0.0
1303 *
1304 * \param bridge_channel Which channel to play a file on.
1305 * \param payload Action frame payload to play a file.
1306 */
1307static void bridge_channel_playfile(struct ast_bridge_channel *bridge_channel, struct bridge_playfile *payload)
1308{
1309 ast_bridge_channel_playfile(bridge_channel, payload->custom_play, payload->playfile,
1310 payload->moh_offset ? &payload->playfile[payload->moh_offset] : NULL);
1311}
1312
1313/*!
1314 * \internal
1315 * \brief Marshal a file to be played on a bridge_channel
1316 */
1318 struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
1319{
1320 struct bridge_playfile *payload;
1321 size_t len_name = strlen(playfile) + 1;
1322 size_t len_moh = !moh_class ? 0 : strlen(moh_class) + 1;
1323 size_t len_payload = sizeof(*payload) + len_name + len_moh;
1324
1325 /* Fill in play file frame data. */
1326 payload = ast_alloca(len_payload);
1327 payload->custom_play = custom_play;
1328 payload->moh_offset = len_moh ? len_name : 0;
1329 strcpy(payload->playfile, playfile);/* Safe */
1330 if (moh_class) {
1331 strcpy(&payload->playfile[payload->moh_offset], moh_class);/* Safe */
1332 }
1333
1334 return post_it(bridge_channel, BRIDGE_CHANNEL_ACTION_PLAY_FILE, payload, len_payload);
1335}
1336
1337int ast_bridge_channel_write_playfile(struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
1338{
1340 bridge_channel, custom_play, playfile, moh_class);
1341}
1342
1343int ast_bridge_channel_queue_playfile(struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
1344{
1346 bridge_channel, custom_play, playfile, moh_class);
1347}
1348
1350 ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
1351{
1353 bridge_channel, custom_play, playfile, moh_class);
1354}
1355
1357 /*! Call this function on the bridge channel thread. */
1359 /*! Size of the payload if it exists. A number otherwise. */
1361 /*! Option flags determining how callback is called. */
1362 unsigned int flags;
1363 /*! Nonzero if the payload exists. */
1365 /*! Payload to give to callback. */
1366 char payload[0];
1367};
1368
1369/*!
1370 * \internal
1371 * \brief Handle the do custom callback bridge action.
1372 * \since 12.0.0
1373 *
1374 * \param bridge_channel Which channel to call the callback on.
1375 * \param data Action frame data to call the callback.
1376 */
1377static void bridge_channel_do_callback(struct ast_bridge_channel *bridge_channel, struct bridge_custom_callback *data)
1378{
1380 bridge_channel_suspend(bridge_channel);
1381 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
1382 }
1383 data->callback(bridge_channel, data->payload_exists ? data->payload : NULL, data->payload_size);
1385 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
1386 bridge_channel_unsuspend(bridge_channel);
1387 }
1388}
1389
1390/*!
1391 * \internal
1392 * \brief Marshal a custom callback function to be called on a bridge_channel
1393 */
1395 struct ast_bridge_channel *bridge_channel,
1397 ast_bridge_custom_callback_fn callback, const void *payload, size_t payload_size)
1398{
1399 struct bridge_custom_callback *cb_data;
1400 size_t len_data = sizeof(*cb_data) + (payload ? payload_size : 0);
1401
1402 /* Sanity check. */
1403 if (!callback) {
1404 ast_assert(0);
1405 return -1;
1406 }
1407
1408 /* Fill in custom callback frame data. */
1409 cb_data = alloca(len_data);
1410 cb_data->callback = callback;
1411 cb_data->payload_size = payload_size;
1412 cb_data->flags = flags;
1413 cb_data->payload_exists = payload && payload_size;
1414 if (cb_data->payload_exists) {
1415 memcpy(cb_data->payload, payload, payload_size);/* Safe */
1416 }
1417
1418 return post_it(bridge_channel, BRIDGE_CHANNEL_ACTION_CALLBACK, cb_data, len_data);
1419}
1420
1424{
1426 bridge_channel, flags, callback, payload, payload_size);
1427}
1428
1432{
1434 bridge_channel, flags, callback, payload, payload_size);
1435}
1436
1440 /* buffer used for holding those strings */
1442};
1443
1444/*!
1445 * \internal
1446 * \brief Park a bridge_cahnnel
1447 */
1448static void bridge_channel_park(struct ast_bridge_channel *bridge_channel, struct bridge_park *payload)
1449{
1451 ast_log(AST_LOG_WARNING, "Unable to park %s: No parking provider loaded!\n",
1452 ast_channel_name(bridge_channel->chan));
1453 return;
1454 }
1455
1456 if (ast_parking_park_bridge_channel(bridge_channel, payload->parkee_uuid,
1457 &payload->parkee_uuid[payload->parker_uuid_offset],
1458 payload->app_data_offset ? &payload->parkee_uuid[payload->app_data_offset] : NULL)) {
1459 ast_log(AST_LOG_WARNING, "Error occurred while parking %s\n",
1460 ast_channel_name(bridge_channel->chan));
1461 }
1462}
1463
1464/*!
1465 * \internal
1466 * \brief Marshal a park action onto a bridge_channel
1467 */
1469 struct ast_bridge_channel *bridge_channel,
1470 const char *parkee_uuid,
1471 const char *parker_uuid,
1472 const char *app_data)
1473{
1474 struct bridge_park *payload;
1475 size_t len_parkee_uuid = strlen(parkee_uuid) + 1;
1476 size_t len_parker_uuid = strlen(parker_uuid) + 1;
1477 size_t len_app_data = !app_data ? 0 : strlen(app_data) + 1;
1478 size_t len_payload = sizeof(*payload) + len_parker_uuid + len_parkee_uuid + len_app_data;
1479
1480 payload = alloca(len_payload);
1481 payload->app_data_offset = len_app_data ? len_parkee_uuid + len_parker_uuid : 0;
1482 payload->parker_uuid_offset = len_parkee_uuid;
1483 strcpy(payload->parkee_uuid, parkee_uuid);
1484 strcpy(&payload->parkee_uuid[payload->parker_uuid_offset], parker_uuid);
1485 if (app_data) {
1486 strcpy(&payload->parkee_uuid[payload->app_data_offset], app_data);
1487 }
1488
1489 return post_it(bridge_channel, BRIDGE_CHANNEL_ACTION_PARK, payload, len_payload);
1490}
1491
1492int ast_bridge_channel_write_park(struct ast_bridge_channel *bridge_channel, const char *parkee_uuid, const char *parker_uuid, const char *app_data)
1493{
1495 bridge_channel, parkee_uuid, parker_uuid, app_data);
1496}
1497
1498/*!
1499 * \internal
1500 * \brief Handle bridge channel interval expiration.
1501 * \since 12.0.0
1502 *
1503 * \param bridge_channel Channel to run expired intervals on.
1504 */
1505static void bridge_channel_handle_interval(struct ast_bridge_channel *bridge_channel)
1506{
1507 struct ast_heap *interval_hooks;
1508 struct ast_bridge_hook_timer *hook;
1509 struct timeval start;
1510 int chan_suspended = 0;
1511
1512 interval_hooks = bridge_channel->features->interval_hooks;
1513 ast_heap_wrlock(interval_hooks);
1514 start = ast_tvnow();
1515 while ((hook = ast_heap_peek(interval_hooks, 1))) {
1516 int interval;
1517 unsigned int execution_time;
1518
1519 if (ast_tvdiff_ms(hook->timer.trip_time, start) > 0) {
1520 ast_debug(1, "Hook %p on %p(%s) wants to happen in the future, stopping our traversal\n",
1521 hook, bridge_channel, ast_channel_name(bridge_channel->chan));
1522 break;
1523 }
1524 ao2_ref(hook, +1);
1525 ast_heap_unlock(interval_hooks);
1526
1527 if (!chan_suspended
1529 chan_suspended = 1;
1530 bridge_channel_suspend(bridge_channel);
1531 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
1532 }
1533
1534 ast_debug(1, "Executing hook %p on %p(%s)\n",
1535 hook, bridge_channel, ast_channel_name(bridge_channel->chan));
1536 interval = hook->generic.callback(bridge_channel, hook->generic.hook_pvt);
1537
1538 ast_heap_wrlock(interval_hooks);
1539 if (ast_heap_peek(interval_hooks, hook->timer.heap_index) != hook
1540 || !ast_heap_remove(interval_hooks, hook)) {
1541 /* Interval hook is already removed from the bridge_channel. */
1542 ao2_ref(hook, -1);
1543 continue;
1544 }
1545 ao2_ref(hook, -1);
1546
1547 if (interval < 0) {
1548 ast_debug(1, "Removed interval hook %p from %p(%s)\n",
1549 hook, bridge_channel, ast_channel_name(bridge_channel->chan));
1550 ao2_ref(hook, -1);
1551 continue;
1552 }
1553 if (interval) {
1554 /* Set new interval for the hook. */
1555 hook->timer.interval = interval;
1556 }
1557
1558 ast_debug(1, "Updating interval hook %p with interval %u on %p(%s)\n",
1559 hook, hook->timer.interval, bridge_channel,
1560 ast_channel_name(bridge_channel->chan));
1561
1562 /* resetting start */
1563 start = ast_tvnow();
1564
1565 /*
1566 * Resetup the interval hook for the next interval. We may need
1567 * to skip over any missed intervals because the hook was
1568 * delayed or took too long.
1569 */
1570 execution_time = ast_tvdiff_ms(start, hook->timer.trip_time);
1571 while (hook->timer.interval < execution_time) {
1572 execution_time -= hook->timer.interval;
1573 }
1574 hook->timer.trip_time = ast_tvadd(start, ast_samp2tv(hook->timer.interval - execution_time, 1000));
1575 hook->timer.seqno = ast_atomic_fetchadd_int((int *) &bridge_channel->features->interval_sequence, +1);
1576
1577 if (ast_heap_push(interval_hooks, hook)) {
1578 /* Could not push the hook back onto the heap. */
1579 ao2_ref(hook, -1);
1580 }
1581 }
1582 ast_heap_unlock(interval_hooks);
1583
1584 if (chan_suspended) {
1585 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
1586 bridge_channel_unsuspend(bridge_channel);
1587 }
1588}
1589
1590/*!
1591 * \internal
1592 * \brief Write a DTMF stream out to a channel
1593 */
1594static int bridge_channel_write_dtmf_stream(struct ast_bridge_channel *bridge_channel, const char *dtmf)
1595{
1596 return bridge_channel_write_action_data(bridge_channel,
1597 BRIDGE_CHANNEL_ACTION_DTMF_STREAM, dtmf, strlen(dtmf) + 1);
1598}
1599
1600/*!
1601 * \internal
1602 * \brief Indicate to the testsuite a feature was successfully detected.
1603 *
1604 * Currently, this function only will relay built-in features to the testsuite,
1605 * but it could be modified to detect applicationmap items should the need arise.
1606 *
1607 * \param chan The channel that activated the feature
1608 * \param dtmf The DTMF sequence entered to activate the feature
1609 */
1610static void testsuite_notify_feature_success(struct ast_channel *chan, const char *dtmf)
1611{
1612#ifdef TEST_FRAMEWORK
1613 char *feature = "unknown";
1614 struct ast_featuremap_config *featuremap;
1615 struct ast_features_xfer_config *xfer;
1616
1617 ast_channel_lock(chan);
1618 featuremap = ast_get_chan_featuremap_config(chan);
1620 ast_channel_unlock(chan);
1621
1622 if (featuremap) {
1623 if (!strcmp(dtmf, featuremap->blindxfer)) {
1624 feature = "blindxfer";
1625 } else if (!strcmp(dtmf, featuremap->atxfer)) {
1626 feature = "atxfer";
1627 } else if (!strcmp(dtmf, featuremap->disconnect)) {
1628 feature = "disconnect";
1629 } else if (!strcmp(dtmf, featuremap->automixmon)) {
1630 feature = "automixmon";
1631 } else if (!strcmp(dtmf, featuremap->parkcall)) {
1632 feature = "parkcall";
1633 }
1634 }
1635 if (xfer) {
1636 if (!strcmp(dtmf, xfer->atxferthreeway)) {
1637 feature = "atxferthreeway";
1638 }
1639 }
1640
1641 ao2_cleanup(featuremap);
1642 ao2_cleanup(xfer);
1643
1644 ast_test_suite_event_notify("FEATURE_DETECTION",
1645 "Result: success\r\n"
1646 "Feature: %s", feature);
1647#endif /* TEST_FRAMEWORK */
1648}
1649
1651 struct ast_bridge_channel *bridge_channel, int digit, size_t dtmf_len)
1652{
1653 if (dtmf_len < ARRAY_LEN(bridge_channel->dtmf_hook_state.collected) - 1) {
1654 /* Add the new digit to the DTMF string so we can do our matching */
1655 bridge_channel->dtmf_hook_state.collected[dtmf_len++] = digit;
1656 bridge_channel->dtmf_hook_state.collected[dtmf_len] = '\0';
1657
1658 ast_debug(1, "DTMF feature string on %p(%s) is now '%s'\n",
1659 bridge_channel, ast_channel_name(bridge_channel->chan),
1660 bridge_channel->dtmf_hook_state.collected);
1661 }
1662
1663 return dtmf_len;
1664}
1665
1666static unsigned int bridge_channel_feature_digit_timeout(struct ast_bridge_channel *bridge_channel)
1667{
1668 unsigned int digit_timeout;
1669 struct ast_features_general_config *gen_cfg;
1670
1671 /* Determine interdigit timeout */
1672 ast_channel_lock(bridge_channel->chan);
1673 gen_cfg = ast_get_chan_features_general_config(bridge_channel->chan);
1674 ast_channel_unlock(bridge_channel->chan);
1675
1676 if (!gen_cfg) {
1677 ast_log(LOG_ERROR, "Unable to retrieve features configuration.\n");
1678 return 3000; /* Pick a reasonable failsafe timeout in ms */
1679 }
1680
1681 digit_timeout = gen_cfg->featuredigittimeout;
1682 ao2_ref(gen_cfg, -1);
1683
1684 return digit_timeout;
1685}
1686
1688{
1689 if (digit) {
1691 bridge_channel, digit, strlen(bridge_channel->dtmf_hook_state.collected));
1692 }
1693}
1694
1696{
1697 struct ast_bridge_features *features = bridge_channel->features;
1698 struct ast_bridge_hook_dtmf *hook = NULL;
1699 size_t dtmf_len;
1700
1701 struct sanity_check_of_dtmf_size {
1702 char check[1 / (ARRAY_LEN(bridge_channel->dtmf_hook_state.collected) == ARRAY_LEN(hook->dtmf.code))];
1703 };
1704
1705 dtmf_len = strlen(bridge_channel->dtmf_hook_state.collected);
1706 if (!dtmf_len && !digit) {
1707 /* Nothing to do */
1708 return;
1709 }
1710
1711 if (digit) {
1712 dtmf_len = bridge_channel_feature_digit_add(bridge_channel, digit, dtmf_len);
1713 }
1714
1715 while (digit) {
1716 /* See if a DTMF feature hook matches or can match */
1717 hook = ao2_find(features->dtmf_hooks, bridge_channel->dtmf_hook_state.collected,
1719 if (!hook) {
1720 ast_debug(1, "No DTMF feature hooks on %p(%s) match '%s'\n",
1721 bridge_channel, ast_channel_name(bridge_channel->chan),
1722 bridge_channel->dtmf_hook_state.collected);
1723 break;
1724 } else if (dtmf_len != strlen(hook->dtmf.code)) {
1725 unsigned int digit_timeout;
1726 /* Need more digits to match */
1727 ao2_ref(hook, -1);
1728 digit_timeout = bridge_channel_feature_digit_timeout(bridge_channel);
1729 bridge_channel->dtmf_hook_state.interdigit_timeout =
1730 ast_tvadd(ast_tvnow(), ast_samp2tv(digit_timeout, 1000));
1731 return;
1732 } else {
1733 int remove_me;
1734 int already_suspended;
1735
1736 ast_debug(1, "DTMF feature hook %p matched DTMF string '%s' on %p(%s)\n",
1737 hook, bridge_channel->dtmf_hook_state.collected, bridge_channel,
1738 ast_channel_name(bridge_channel->chan));
1739
1740 /*
1741 * Clear the collected digits before executing the hook
1742 * in case the hook starts another sequence.
1743 */
1744 bridge_channel->dtmf_hook_state.collected[0] = '\0';
1745
1746 ast_bridge_channel_lock_bridge(bridge_channel);
1747 already_suspended = bridge_channel->suspended;
1748 if (!already_suspended) {
1750 }
1751 ast_bridge_unlock(bridge_channel->bridge);
1752 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
1753
1754 /* Execute the matched hook on this channel. */
1755 remove_me = hook->generic.callback(bridge_channel, hook->generic.hook_pvt);
1756 if (remove_me) {
1757 ast_debug(1, "DTMF hook %p is being removed from %p(%s)\n",
1758 hook, bridge_channel, ast_channel_name(bridge_channel->chan));
1759 ao2_unlink(features->dtmf_hooks, hook);
1760 }
1761 testsuite_notify_feature_success(bridge_channel->chan, hook->dtmf.code);
1762 ao2_ref(hook, -1);
1763
1764 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
1765 if (!already_suspended) {
1766 bridge_channel_unsuspend(bridge_channel);
1767 }
1768
1769 /*
1770 * If we are handing the channel off to an external hook for
1771 * ownership, we are not guaranteed what kind of state it will
1772 * come back in. If the channel hungup, we need to detect that
1773 * here if the hook did not already change the state.
1774 */
1775 if (bridge_channel->chan && ast_check_hangup_locked(bridge_channel->chan)) {
1776 ast_bridge_channel_kick(bridge_channel, 0);
1777 bridge_channel->dtmf_hook_state.collected[0] = '\0';
1778 return;
1779 }
1780
1781 /* if there is dtmf that has been collected then loop back through,
1782 but set digit to -1 so it doesn't try to do an add since the dtmf
1783 is already in the buffer */
1784 dtmf_len = strlen(bridge_channel->dtmf_hook_state.collected);
1785 if (!dtmf_len) {
1786 return;
1787 }
1788 }
1789 }
1790
1791 if (!digit) {
1792 ast_debug(1, "DTMF feature string collection on %p(%s) timed out\n",
1793 bridge_channel, ast_channel_name(bridge_channel->chan));
1794 }
1795
1796 /* Timeout or DTMF digit didn't allow a match with any hooks. */
1797 if (features->dtmf_passthrough) {
1798 /* Stream the collected DTMF to the other channels. */
1799 bridge_channel_write_dtmf_stream(bridge_channel,
1800 bridge_channel->dtmf_hook_state.collected);
1801 }
1802 bridge_channel->dtmf_hook_state.collected[0] = '\0';
1803
1804 ast_test_suite_event_notify("FEATURE_DETECTION", "Result: fail");
1805}
1806
1807/*!
1808 * \internal
1809 * \brief Handle bridge channel DTMF feature timeout expiration.
1810 * \since 12.8.0
1811 *
1812 * \param bridge_channel Channel to check expired interdigit timer on.
1813 */
1815{
1816 if (!bridge_channel->dtmf_hook_state.collected[0]
1817 || 0 < ast_tvdiff_ms(bridge_channel->dtmf_hook_state.interdigit_timeout,
1818 ast_tvnow())) {
1819 /* Not within a sequence or not timed out. */
1820 return;
1821 }
1822
1823 ast_bridge_channel_feature_digit(bridge_channel, 0);
1824}
1825
1826/*!
1827 * \internal
1828 * \brief Indicate that a bridge_channel is talking
1829 */
1830static void bridge_channel_talking(struct ast_bridge_channel *bridge_channel, int talking)
1831{
1832 struct ast_bridge_features *features = bridge_channel->features;
1833 struct ast_bridge_hook *hook;
1834 struct ao2_iterator iter;
1835
1836 /* Run any talk detection hooks. */
1837 iter = ao2_iterator_init(features->other_hooks, 0);
1838 for (; (hook = ao2_iterator_next(&iter)); ao2_ref(hook, -1)) {
1839 int remove_me;
1841
1842 if (hook->type != AST_BRIDGE_HOOK_TYPE_TALK) {
1843 continue;
1844 }
1846 remove_me = talk_cb(bridge_channel, hook->hook_pvt, talking);
1847 if (remove_me) {
1848 ast_debug(1, "Talk detection hook %p is being removed from %p(%s)\n",
1849 hook, bridge_channel, ast_channel_name(bridge_channel->chan));
1850 ao2_unlink(features->other_hooks, hook);
1851 }
1852 }
1853 ao2_iterator_destroy(&iter);
1854}
1855
1856/*!
1857 * \internal
1858 * \brief Play back DTMF on a bridge channel
1859 */
1860static void bridge_channel_dtmf_stream(struct ast_bridge_channel *bridge_channel, const char *dtmf)
1861{
1862 ast_debug(1, "Playing DTMF stream '%s' out to %p(%s)\n",
1863 dtmf, bridge_channel, ast_channel_name(bridge_channel->chan));
1864 ast_dtmf_stream(bridge_channel->chan, NULL, dtmf, 0, 0);
1865}
1866
1867/*! \brief Data specifying where a blind transfer is going to */
1871};
1872
1873/*!
1874 * \internal
1875 * \brief Execute after bridge actions on a channel when it leaves a bridge
1876 */
1877static void after_bridge_move_channel(struct ast_channel *chan_bridged, void *data)
1878{
1879 RAII_VAR(struct ast_channel *, chan_target, data, ao2_cleanup);
1880 struct ast_party_connected_line connected_target;
1881 unsigned char connected_line_data[1024];
1882 int payload_size;
1883
1884 ast_party_connected_line_init(&connected_target);
1885
1886 ast_channel_lock(chan_target);
1887 ast_party_connected_line_copy(&connected_target, ast_channel_connected(chan_target));
1888 ast_channel_unlock(chan_target);
1889 ast_party_id_reset(&connected_target.priv);
1890
1891 if (ast_channel_move(chan_target, chan_bridged)) {
1892 ast_softhangup(chan_target, AST_SOFTHANGUP_DEV);
1893 ast_party_connected_line_free(&connected_target);
1894 return;
1895 }
1896
1897 /* The ast_channel_move function will end up updating the connected line information
1898 * on chan_target to the value we have here, but will not inform it. To ensure that
1899 * AST_FRAME_READ_ACTION_CONNECTED_LINE_MACRO is executed we wipe it away here. If
1900 * we don't do this then the change will be considered redundant, since the connected
1901 * line information is already there (despite the channel not being told).
1902 */
1903 ast_channel_lock(chan_target);
1906 ast_channel_unlock(chan_target);
1907
1908 if ((payload_size = ast_connected_line_build_data(connected_line_data,
1909 sizeof(connected_line_data), &connected_target, NULL)) != -1) {
1910 struct ast_control_read_action_payload *frame_payload;
1911 int frame_size;
1912
1913 frame_size = payload_size + sizeof(*frame_payload);
1914 frame_payload = ast_alloca(frame_size);
1916 frame_payload->payload_size = payload_size;
1917 memcpy(frame_payload->payload, connected_line_data, payload_size);
1918 ast_queue_control_data(chan_target, AST_CONTROL_READ_ACTION, frame_payload, frame_size);
1919 }
1920
1921 /* A connected line update is queued so that if chan_target is remotely involved with
1922 * anything (such as dialing a channel) the other channel(s) will be informed of the
1923 * new channel they are involved with.
1924 */
1925 ast_channel_lock(chan_target);
1926 ast_connected_line_copy_from_caller(&connected_target, ast_channel_caller(chan_target));
1927 ast_channel_queue_connected_line_update(chan_target, &connected_target, NULL);
1928 ast_channel_unlock(chan_target);
1929
1930 ast_party_connected_line_free(&connected_target);
1931}
1932
1933/*!
1934 * \internal
1935 * \brief Execute logic to cleanup when after bridge fails
1936 */
1938{
1939 RAII_VAR(struct ast_channel *, chan_target, data, ao2_cleanup);
1940
1941 ast_log(LOG_WARNING, "Unable to complete transfer: %s\n",
1943 ast_softhangup(chan_target, AST_SOFTHANGUP_DEV);
1944}
1945
1946/*!
1947 * \internal
1948 * \brief Perform a blind transfer on a channel in a bridge
1949 */
1950static void bridge_channel_blind_transfer(struct ast_bridge_channel *bridge_channel,
1951 struct blind_transfer_data *blind_data)
1952{
1953 ast_async_goto(bridge_channel->chan, blind_data->context, blind_data->exten, 1);
1955}
1956
1957/*!
1958 * \internal
1959 * \brief Perform an attended transfer on a channel in a bridge
1960 */
1961static void bridge_channel_attended_transfer(struct ast_bridge_channel *bridge_channel,
1962 const char *target_chan_name)
1963{
1964 RAII_VAR(struct ast_channel *, chan_target, NULL, ao2_cleanup);
1965 RAII_VAR(struct ast_channel *, chan_bridged, NULL, ao2_cleanup);
1966
1967 chan_target = ast_channel_get_by_name(target_chan_name);
1968 if (!chan_target) {
1969 /* Dang, it disappeared somehow */
1971 return;
1972 }
1973
1974 ast_bridge_channel_lock(bridge_channel);
1975 chan_bridged = bridge_channel->chan;
1976 ast_assert(chan_bridged != NULL);
1977 ao2_ref(chan_bridged, +1);
1978 ast_bridge_channel_unlock(bridge_channel);
1979
1982 ast_softhangup(chan_target, AST_SOFTHANGUP_DEV);
1983
1984 /* Release the ref we tried to pass to ast_bridge_set_after_callback(). */
1985 ast_channel_unref(chan_target);
1986 }
1988}
1989
1990/*!
1991 * \internal
1992 * \brief Handle bridge channel bridge action frame.
1993 * \since 12.0.0
1994 *
1995 * \param bridge_channel Channel to execute the action on.
1996 * \param action What to do.
1997 * \param data data from the action.
1998 */
1999static void bridge_channel_handle_action(struct ast_bridge_channel *bridge_channel,
2000 enum bridge_channel_action_type action, void *data)
2001{
2002 switch (action) {
2004 bridge_channel_suspend(bridge_channel);
2005 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2006 bridge_channel_dtmf_stream(bridge_channel, data);
2007 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2008 bridge_channel_unsuspend(bridge_channel);
2009 break;
2012 bridge_channel_talking(bridge_channel,
2014 break;
2016 bridge_channel_suspend(bridge_channel);
2017 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2018 bridge_channel_playfile(bridge_channel, data);
2019 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2020 bridge_channel_unsuspend(bridge_channel);
2021 break;
2023 bridge_channel_suspend(bridge_channel);
2024 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2025 bridge_channel_run_app(bridge_channel, data);
2026 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2027 bridge_channel_unsuspend(bridge_channel);
2028 break;
2030 bridge_channel_do_callback(bridge_channel, data);
2031 break;
2033 bridge_channel_suspend(bridge_channel);
2034 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2035 bridge_channel_park(bridge_channel, data);
2036 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2037 bridge_channel_unsuspend(bridge_channel);
2038 break;
2040 bridge_channel_blind_transfer(bridge_channel, data);
2041 break;
2043 bridge_channel_attended_transfer(bridge_channel, data);
2044 break;
2045 default:
2046 break;
2047 }
2048
2049 /* While invoking an action it is possible for the channel to be hung up. So
2050 * that the bridge respects this we check here and if hung up kick it out.
2051 */
2052 if (bridge_channel->chan && ast_check_hangup_locked(bridge_channel->chan)) {
2053 ast_bridge_channel_kick(bridge_channel, 0);
2054 }
2055}
2056
2057/*!
2058 * \internal
2059 * \brief Check if a bridge should dissolve and do it.
2060 * \since 12.0.0
2061 *
2062 * \param bridge_channel Channel causing the check.
2063 *
2064 * \note On entry, bridge_channel->bridge is already locked.
2065 */
2066static void bridge_channel_dissolve_check(struct ast_bridge_channel *bridge_channel)
2067{
2068 struct ast_bridge *bridge = bridge_channel->bridge;
2069
2070 if (bridge->dissolved) {
2071 return;
2072 }
2073
2074 if (!bridge->num_channels
2076 /* Last channel leaving the bridge turns off the lights. */
2077 bridge_dissolve(bridge, ast_channel_hangupcause(bridge_channel->chan));
2078 return;
2079 }
2080
2081 switch (bridge_channel->state) {
2083 /* Do we need to dissolve the bridge because this channel hung up? */
2085 || (bridge_channel->features->usable
2086 && ast_test_flag(&bridge_channel->features->feature_flags,
2088 bridge_dissolve(bridge, ast_channel_hangupcause(bridge_channel->chan));
2089 return;
2090 }
2091 break;
2092 default:
2093 break;
2094 }
2095
2096 if (bridge->num_lonely && bridge->num_lonely == bridge->num_channels) {
2097 /*
2098 * This will start a chain reaction where each channel leaving
2099 * enters this function and causes the next to leave as long as
2100 * there aren't non-lonely channels in the bridge.
2101 */
2104 ast_channel_hangupcause(bridge_channel->chan));
2105 }
2106}
2107
2109{
2110 struct ast_bridge *bridge = bridge_channel->bridge;
2111
2112 if (!bridge_channel->in_bridge) {
2113 return;
2114 }
2115 bridge_channel->in_bridge = 0;
2116
2117 ast_debug(1, "Bridge %s: pulling %p(%s)\n",
2118 bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan));
2119
2120 ast_verb(3, "Channel %s left '%s' %s-bridge <%s>\n",
2121 ast_channel_name(bridge_channel->chan),
2122 bridge->technology->name,
2123 bridge->v_table->name,
2124 bridge->uniqueid);
2125
2126 if (!bridge_channel->just_joined) {
2127 /* Tell the bridge technology we are leaving so they tear us down */
2128 ast_debug(1, "Bridge %s: %p(%s) is leaving %s technology\n",
2129 bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
2130 bridge->technology->name);
2131 if (bridge->technology->leave) {
2132 bridge->technology->leave(bridge, bridge_channel);
2133 }
2134 }
2135
2136 /* Remove channel from the bridge */
2137 if (!bridge_channel->suspended) {
2138 --bridge->num_active;
2139 }
2141 --bridge->num_lonely;
2142 }
2143 --bridge->num_channels;
2144 AST_LIST_REMOVE(&bridge->channels, bridge_channel, entry);
2145
2146 bridge_channel_dissolve_check(bridge_channel);
2147 bridge->v_table->pull(bridge, bridge_channel);
2148
2149 ast_bridge_channel_clear_roles(bridge_channel);
2150
2151 /* If we are not going to be hung up after leaving a bridge, and we were an
2152 * outgoing channel, clear the outgoing flag.
2153 */
2155 && (ast_channel_is_leaving_bridge(bridge_channel->chan)
2156 || bridge_channel->state == BRIDGE_CHANNEL_STATE_WAIT)) {
2157 ast_debug(2, "Channel %s will survive this bridge; clearing outgoing (dialed) flag\n", ast_channel_name(bridge_channel->chan));
2159 }
2160
2161 bridge->reconfigured = 1;
2162 ast_bridge_publish_leave(bridge, bridge_channel->chan);
2163}
2164
2165int bridge_channel_internal_push_full(struct ast_bridge_channel *bridge_channel, int optimized)
2166{
2167 struct ast_bridge *bridge = bridge_channel->bridge;
2168 struct ast_bridge_channel *swap;
2169
2170 ast_assert(!bridge_channel->in_bridge);
2171
2172 swap = bridge_find_channel(bridge, bridge_channel->swap);
2173 bridge_channel->swap = NULL;
2174
2175 if (swap) {
2176 ast_debug(1, "Bridge %s: pushing %p(%s) by swapping with %p(%s)\n",
2177 bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
2178 swap, ast_channel_name(swap->chan));
2179 } else {
2180 ast_debug(1, "Bridge %s: pushing %p(%s)\n",
2181 bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan));
2182 }
2183
2184 /* Add channel to the bridge */
2185 if (bridge->dissolved
2186 || bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT
2188 || bridge->v_table->push(bridge, bridge_channel, swap)) {
2189 ast_debug(1, "Bridge %s: pushing %p(%s) into bridge failed\n",
2190 bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan));
2191 return -1;
2192 }
2193
2194 ast_bridge_channel_establish_roles(bridge_channel);
2195
2196 if (swap) {
2198
2199 /* This flag is cleared so the act of this channel leaving does not cause it to dissolve if need be */
2201
2202 if (optimized) {
2204 }
2207
2209 }
2210
2211 bridge_channel->in_bridge = 1;
2212 bridge_channel->just_joined = 1;
2213 AST_LIST_INSERT_TAIL(&bridge->channels, bridge_channel, entry);
2216 ++bridge->num_lonely;
2217 }
2218 if (!bridge_channel->suspended) {
2219 ++bridge->num_active;
2220 }
2221
2222 ast_verb(3, "Channel %s %s%s%s '%s' %s-bridge <%s>\n",
2223 ast_channel_name(bridge_channel->chan),
2224 swap ? "swapped with " : "joined",
2225 swap ? ast_channel_name(swap->chan) : "",
2226 swap ? " into" : "",
2229 bridge->uniqueid);
2230
2231 ast_bridge_publish_enter(bridge, bridge_channel->chan, swap ? swap->chan : NULL);
2232
2233 /* Clear any BLINDTRANSFER,ATTENDEDTRANSFER and FORWARDERNAME since the transfer has completed. */
2234 pbx_builtin_setvar_helper(bridge_channel->chan, "BLINDTRANSFER", NULL);
2235 pbx_builtin_setvar_helper(bridge_channel->chan, "ATTENDEDTRANSFER", NULL);
2236 pbx_builtin_setvar_helper(bridge_channel->chan, "FORWARDERNAME", NULL);
2237
2238 /* Wake up the bridge channel thread to reevaluate any interval timers. */
2239 ast_queue_frame(bridge_channel->chan, &ast_null_frame);
2240
2241 bridge->reconfigured = 1;
2242 return 0;
2243}
2244
2246{
2247 return bridge_channel_internal_push_full(bridge_channel, 0);
2248}
2249
2250/*!
2251 * \internal
2252 * \brief Handle bridge channel control frame action.
2253 * \since 12.0.0
2254 *
2255 * \param bridge_channel Channel to execute the control frame action on.
2256 * \param fr Control frame to handle.
2257 */
2258static void bridge_channel_handle_control(struct ast_bridge_channel *bridge_channel, struct ast_frame *fr)
2259{
2260 struct ast_channel *chan;
2261 struct ast_option_header *aoh;
2262
2263 chan = bridge_channel->chan;
2264 switch (fr->subclass.integer) {
2266 if (ast_channel_redirecting_sub(NULL, chan, fr, 1)) {
2267 ast_indicate_data(chan, fr->subclass.integer, fr->data.ptr, fr->datalen);
2268 }
2269 break;
2271 if (ast_channel_connected_line_sub(NULL, chan, fr, 1)) {
2272 ast_indicate_data(chan, fr->subclass.integer, fr->data.ptr, fr->datalen);
2273 }
2274 break;
2275 case AST_CONTROL_OPTION:
2276 /*
2277 * Forward option Requests, but only ones we know are safe These
2278 * are ONLY sent by chan_iax2 and I'm not convinced that they
2279 * are useful. I haven't deleted them entirely because I just am
2280 * not sure of the ramifications of removing them.
2281 */
2282 aoh = fr->data.ptr;
2283 if (aoh && aoh->flag == AST_OPTION_FLAG_REQUEST) {
2284 switch (ntohs(aoh->option)) {
2286 case AST_OPTION_TDD:
2291 ast_channel_setoption(chan, ntohs(aoh->option), aoh->data,
2292 fr->datalen - sizeof(*aoh), 0);
2293 break;
2294 default:
2295 break;
2296 }
2297 }
2298 break;
2299 case AST_CONTROL_ANSWER:
2300 if (ast_channel_state(chan) != AST_STATE_UP) {
2301 ast_answer(chan);
2302 ast_bridge_channel_lock_bridge(bridge_channel);
2303 bridge_channel->bridge->reconfigured = 1;
2304 bridge_reconfigured(bridge_channel->bridge, 0);
2305 ast_bridge_unlock(bridge_channel->bridge);
2306 } else {
2307 ast_indicate(chan, -1);
2308 }
2309 break;
2311 /* Should never happen. */
2312 ast_assert(0);
2313 break;
2315 ast_indicate_data(chan, fr->subclass.integer, fr->data.ptr, fr->datalen);
2316 break;
2317 default:
2318 ast_indicate_data(chan, fr->subclass.integer, fr->data.ptr, fr->datalen);
2319 break;
2320 }
2321}
2322
2323/*!
2324 * \internal
2325 * \brief Ensure text data is zero terminated before sending
2326 *
2327 * \param chan Channel to send text to
2328 * \param f The frame containing the text data to send
2329 */
2330static void sendtext_safe(struct ast_channel *chan, const struct ast_frame *f)
2331{
2332 if (f->datalen) {
2333 char *text = f->data.ptr;
2334
2335 if (text[f->datalen - 1]) {
2336 /* Not zero terminated, we need to allocate */
2338 if (!text) {
2339 return;
2340 }
2341 }
2342
2343 ast_sendtext(chan, text);
2344
2345 if (text != f->data.ptr) {
2346 /* Only free if we allocated */
2347 ast_free(text);
2348 }
2349 } else {
2350 /* Special case if the frame length is zero (although I
2351 * am not sure this is possible?) */
2352 ast_sendtext(chan, "");
2353 }
2354}
2355
2356/*!
2357 * \internal
2358 * \brief Handle bridge channel write frame to channel.
2359 * \since 12.0.0
2360 *
2361 * \param bridge_channel Channel to write outgoing frame.
2362 */
2363static void bridge_channel_handle_write(struct ast_bridge_channel *bridge_channel)
2364{
2365 struct ast_frame *fr;
2366 struct sync_payload *sync_payload;
2367 int num;
2368 struct ast_msg_data *msg;
2369
2370 ast_bridge_channel_lock(bridge_channel);
2371
2372 /* It's not good to have unbalanced frames and alert_pipe alerts. */
2373 ast_assert(!AST_LIST_EMPTY(&bridge_channel->wr_queue));
2374 if (AST_LIST_EMPTY(&bridge_channel->wr_queue)) {
2375 /* No frame, flush the alert pipe of excess alerts. */
2376 ast_log(LOG_WARNING, "Weird. No frame from bridge for %s to process?\n",
2377 ast_channel_name(bridge_channel->chan));
2378 ast_alertpipe_read(bridge_channel->alert_pipe);
2379 ast_bridge_channel_unlock(bridge_channel);
2380 return;
2381 }
2382
2383 AST_LIST_TRAVERSE_SAFE_BEGIN(&bridge_channel->wr_queue, fr, frame_list) {
2384 if (bridge_channel->dtmf_hook_state.collected[0]) {
2385 switch (fr->frametype) {
2388 /* Defer processing these frames while DTMF is collected. */
2389 continue;
2390 default:
2391 break;
2392 }
2393 }
2394 ast_alertpipe_read(bridge_channel->alert_pipe);
2396 break;
2397 }
2399
2400 ast_bridge_channel_unlock(bridge_channel);
2401
2402 if (!fr) {
2403 /*
2404 * Wait some to reduce CPU usage from a tight loop
2405 * without any wait because we only have deferred
2406 * frames in the wr_queue.
2407 */
2408 usleep(1);
2409 return;
2410 }
2411
2412 switch (fr->frametype) {
2414 bridge_channel_handle_action(bridge_channel, fr->subclass.integer, fr->data.ptr);
2415 break;
2417 sync_payload = fr->data.ptr;
2419 break;
2420 case AST_FRAME_CONTROL:
2421 bridge_channel_handle_control(bridge_channel, fr);
2422 break;
2423 case AST_FRAME_NULL:
2424 break;
2425 case AST_FRAME_TEXT:
2426 ast_debug(1, "Sending TEXT frame to '%s': %*.s\n",
2427 ast_channel_name(bridge_channel->chan), fr->datalen, (char *)fr->data.ptr);
2428 sendtext_safe(bridge_channel->chan, fr);
2429 break;
2431 msg = (struct ast_msg_data *)fr->data.ptr;
2432 ast_debug(1, "Sending TEXT_DATA frame from '%s' to '%s:%s': %s\n",
2435 ast_channel_name(bridge_channel->chan),
2437 ast_sendtext_data(bridge_channel->chan, msg);
2438 break;
2439 default:
2440 /* Assume that there is no mapped stream for this */
2441 num = -1;
2442
2443 if (fr->stream_num > -1) {
2444 ast_bridge_channel_lock(bridge_channel);
2445 if (fr->stream_num < (int)AST_VECTOR_SIZE(&bridge_channel->stream_map.to_channel)) {
2446 num = AST_VECTOR_GET(&bridge_channel->stream_map.to_channel, fr->stream_num);
2447 }
2448 ast_bridge_channel_unlock(bridge_channel);
2449
2450 /* If there is no mapped stream after checking the mapping then there is nowhere
2451 * to write this frame to, so drop it.
2452 */
2453 if (num == -1) {
2454 break;
2455 }
2456 }
2457
2458 /* Write the frame to the channel. */
2459 bridge_channel->activity = BRIDGE_CHANNEL_THREAD_SIMPLE;
2460 ast_write_stream(bridge_channel->chan, num, fr);
2461 break;
2462 }
2464}
2465
2466/*!
2467 * \internal
2468 * \brief Handle DTMF from a channel
2469 */
2470static struct ast_frame *bridge_handle_dtmf(struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
2471{
2472 struct ast_bridge_features *features = bridge_channel->features;
2473 struct ast_bridge_hook_dtmf *hook = NULL;
2474 char dtmf[2];
2475
2476 /*
2477 * See if we are already matching a DTMF feature hook sequence or
2478 * if this DTMF matches the beginning of any DTMF feature hooks.
2479 */
2480 dtmf[0] = frame->subclass.integer;
2481 dtmf[1] = '\0';
2482 if (bridge_channel->dtmf_hook_state.collected[0]
2483 || (hook = ao2_find(features->dtmf_hooks, dtmf, OBJ_SEARCH_PARTIAL_KEY))) {
2484 enum ast_frame_type frametype = frame->frametype;
2485
2486 bridge_frame_free(frame);
2487 frame = NULL;
2488
2489 ao2_cleanup(hook);
2490
2491 switch (frametype) {
2493 /* Just eat the frame. */
2494 break;
2495 case AST_FRAME_DTMF_END:
2496 ast_bridge_channel_feature_digit(bridge_channel, dtmf[0]);
2497 break;
2498 default:
2499 /* Unexpected frame type. */
2500 ast_assert(0);
2501 break;
2502 }
2503#ifdef TEST_FRAMEWORK
2504 } else if (frame->frametype == AST_FRAME_DTMF_END) {
2505 /* Only transmit this event on DTMF end or else every DTMF
2506 * press will result in the event being broadcast twice
2507 */
2508 ast_test_suite_event_notify("FEATURE_DETECTION", "Result: fail");
2509#endif
2510 }
2511
2512 return frame;
2513}
2514
2515static const char *controls[] = {
2516 [AST_CONTROL_RINGING] = "RINGING",
2517 [AST_CONTROL_PROCEEDING] = "PROCEEDING",
2518 [AST_CONTROL_PROGRESS] = "PROGRESS",
2519 [AST_CONTROL_BUSY] = "BUSY",
2520 [AST_CONTROL_CONGESTION] = "CONGESTION",
2521 [AST_CONTROL_ANSWER] = "ANSWER",
2522};
2523
2524/*!
2525 * \internal
2526 * \brief Feed notification that a frame is waiting on a channel into the bridging core
2527 *
2528 * \param bridge_channel Bridge channel the notification was received on
2529 */
2530static void bridge_handle_trip(struct ast_bridge_channel *bridge_channel)
2531{
2532 struct ast_frame *frame;
2533 int blocked;
2534
2535 if (!ast_strlen_zero(ast_channel_call_forward(bridge_channel->chan))) {
2536 /* TODO If early bridging is ever used by anything other than ARI,
2537 * it's important that we actually attempt to handle the call forward
2538 * attempt, as well as expand features on a bridge channel to allow/disallow
2539 * call forwarding. For now, all we do is raise an event, showing that
2540 * a call forward is being attempted.
2541 */
2542 ast_channel_publish_dial_forward(NULL, bridge_channel->chan, NULL, NULL, "CANCEL",
2543 ast_channel_call_forward(bridge_channel->chan));
2544 }
2545
2546 if (bridge_channel->features->mute) {
2547 frame = ast_read_stream_noaudio(bridge_channel->chan);
2548 } else {
2549 frame = ast_read_stream(bridge_channel->chan);
2550 }
2551
2552 if (!frame) {
2553 ast_bridge_channel_kick(bridge_channel, 0);
2554 return;
2555 }
2556
2557 if (!ast_channel_is_multistream(bridge_channel->chan)) {
2558 /* This may not be initialized by non-multistream channel drivers */
2559 frame->stream_num = -1;
2560 }
2561
2562 switch (frame->frametype) {
2563 case AST_FRAME_CONTROL:
2564 switch (frame->subclass.integer) {
2566 case AST_CONTROL_BUSY:
2567 ast_channel_publish_dial(NULL, bridge_channel->chan, NULL, controls[frame->subclass.integer]);
2568 break;
2569 case AST_CONTROL_HANGUP:
2570 ast_bridge_channel_kick(bridge_channel, 0);
2571 bridge_frame_free(frame);
2572 return;
2576 case AST_CONTROL_ANSWER:
2577 ast_channel_publish_dial(NULL, bridge_channel->chan, NULL, controls[frame->subclass.integer]);
2578 break;
2580 ast_bridge_channel_lock_bridge(bridge_channel);
2581 blocked = bridge_channel->bridge->technology->stream_topology_request_change
2583 bridge_channel->bridge, bridge_channel);
2584 ast_bridge_unlock(bridge_channel->bridge);
2585 if (blocked) {
2586 /*
2587 * Topology change was intercepted by the bridge technology
2588 * so drop frame.
2589 */
2590 bridge_frame_free(frame);
2591 return;
2592 }
2593 break;
2595 /*
2596 * If a stream topology has changed then the bridge_channel's
2597 * media mapping needs to be updated.
2598 */
2599 ast_bridge_channel_lock_bridge(bridge_channel);
2600 if (bridge_channel->bridge->technology->stream_topology_changed) {
2601 bridge_channel->bridge->technology->stream_topology_changed(
2602 bridge_channel->bridge, bridge_channel);
2603 } else {
2604 ast_bridge_channel_stream_map(bridge_channel);
2605 }
2606 ast_bridge_unlock(bridge_channel->bridge);
2607 break;
2608 default:
2609 break;
2610 }
2611 break;
2613 case AST_FRAME_DTMF_END:
2614 frame = bridge_handle_dtmf(bridge_channel, frame);
2615 if (!frame) {
2616 return;
2617 }
2618 if (!bridge_channel->features->dtmf_passthrough) {
2619 bridge_frame_free(frame);
2620 return;
2621 }
2622 break;
2623 default:
2624 break;
2625 }
2626
2627 /* Simply write the frame out to the bridge technology. */
2628 bridge_channel_write_frame(bridge_channel, frame);
2629 bridge_frame_free(frame);
2630}
2631
2632/*!
2633 * \internal
2634 * \brief Determine how long till the next timer interval.
2635 * \since 12.0.0
2636 *
2637 * \param bridge_channel Channel to determine how long can wait.
2638 *
2639 * \retval ms Number of milliseconds to wait.
2640 * \retval -1 to wait forever.
2641 */
2642static int bridge_channel_next_interval(struct ast_bridge_channel *bridge_channel)
2643{
2644 struct ast_heap *interval_hooks = bridge_channel->features->interval_hooks;
2645 struct ast_bridge_hook_timer *hook;
2646 int ms;
2647
2648 ast_heap_wrlock(interval_hooks);
2649 hook = ast_heap_peek(interval_hooks, 1);
2650 if (hook) {
2651 ms = ast_tvdiff_ms(hook->timer.trip_time, ast_tvnow());
2652 if (ms < 0) {
2653 /* Expire immediately. An interval hook is ready to run. */
2654 ms = 0;
2655 }
2656 } else {
2657 /* No hook so wait forever. */
2658 ms = -1;
2659 }
2660 ast_heap_unlock(interval_hooks);
2661
2662 return ms;
2663}
2664
2665/*!
2666 * \internal
2667 * \brief Determine how long till the DTMF interdigit timeout.
2668 * \since 12.8.0
2669 *
2670 * \param bridge_channel Channel to determine how long can wait.
2671 *
2672 * \retval ms Number of milliseconds to wait.
2673 * \retval -1 to wait forever.
2674 */
2675static int bridge_channel_feature_timeout(struct ast_bridge_channel *bridge_channel)
2676{
2677 int ms;
2678
2679 if (bridge_channel->dtmf_hook_state.collected[0]) {
2681 ast_tvnow());
2682 if (ms < 0) {
2683 /* Expire immediately. */
2684 ms = 0;
2685 }
2686 } else {
2687 /* Timer is not active so wait forever. */
2688 ms = -1;
2689 }
2690
2691 return ms;
2692}
2693
2694/*!
2695 * \internal
2696 * \brief Determine how long till a timeout.
2697 * \since 12.8.0
2698 *
2699 * \param bridge_channel Channel to determine how long can wait.
2700 *
2701 * \retval ms Number of milliseconds to wait.
2702 * \retval -1 to wait forever.
2703 */
2704static int bridge_channel_next_timeout(struct ast_bridge_channel *bridge_channel)
2705{
2706 int ms_interval;
2707 int ms;
2708
2709 ms_interval = bridge_channel_next_interval(bridge_channel);
2710 ms = bridge_channel_feature_timeout(bridge_channel);
2711 if (ms < 0 || (0 <= ms_interval && ms_interval < ms)) {
2712 /* Interval hook timeout is next. */
2713 ms = ms_interval;
2714 }
2715
2716 return ms;
2717}
2718
2719/*!
2720 * \internal
2721 * \brief Wait for something to happen on the bridge channel and handle it.
2722 * \since 12.0.0
2723 *
2724 * \param bridge_channel Channel to wait.
2725 *
2726 * \note Each channel does writing/reading in their own thread.
2727 */
2728static void bridge_channel_wait(struct ast_bridge_channel *bridge_channel)
2729{
2730 int ms;
2731 int outfd;
2732 struct ast_channel *chan;
2733
2734 /* Wait for data to either come from the channel or us to be signaled */
2737 } else if (bridge_channel->suspended) {
2738/* XXX ASTERISK-21271 the external party use of suspended will go away as will these references because this is the bridge channel thread */
2739 ast_debug(1, "Bridge %s: %p(%s) is going into a signal wait\n",
2743 } else {
2745 outfd = -1;
2748 &bridge_channel->alert_pipe[0], 1, NULL, &outfd, &ms);
2755 }
2761 if (chan) {
2763 } else if (ms == 0) {
2764 /* An interdigit timeout or interval expired. */
2767 } else if (-1 < outfd) {
2768 /*
2769 * Must do this after checking timeouts or may have
2770 * an infinite loop due to deferring write queue
2771 * actions while trying to match DTMF feature hooks.
2772 */
2774 }
2775 }
2777 return;
2778 }
2780}
2781
2782/*!
2783 * \internal
2784 * \brief Handle bridge channel join/leave event.
2785 * \since 12.0.0
2786 *
2787 * \param bridge_channel Which channel is involved.
2788 * \param type Specified join/leave event.
2789 */
2791{
2792 struct ast_bridge_features *features = bridge_channel->features;
2793 struct ast_bridge_hook *hook;
2794 struct ao2_iterator iter;
2795
2796 /* Run the specified hooks. */
2797 iter = ao2_iterator_init(features->other_hooks, 0);
2798 for (; (hook = ao2_iterator_next(&iter)); ao2_ref(hook, -1)) {
2799 if (hook->type == type) {
2800 break;
2801 }
2802 }
2803 if (hook) {
2804 /* Found the first specified hook to run. */
2805 bridge_channel_suspend(bridge_channel);
2806 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2807 do {
2808 if (hook->type == type) {
2809 hook->callback(bridge_channel, hook->hook_pvt);
2810 ao2_unlink(features->other_hooks, hook);
2811 }
2812 ao2_ref(hook, -1);
2813 } while ((hook = ao2_iterator_next(&iter)));
2814 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
2815 bridge_channel_unsuspend(bridge_channel);
2816 }
2817 ao2_iterator_destroy(&iter);
2818}
2819
2821{
2822 int res = 0;
2823 uint8_t indicate_src_change = 0;
2824 struct ast_bridge_features *channel_features;
2825 struct ast_channel *peer;
2826 struct ast_channel *swap;
2827
2828 ast_debug(1, "Bridge %s: %p(%s) is joining\n",
2831
2832 /*
2833 * Directly locking the bridge is safe here because nobody else
2834 * knows about this bridge_channel yet.
2835 */
2837
2840
2841 if (peer) {
2842 struct ast_bridge *peer_bridge;
2843
2844 ast_channel_unlock(bridge_channel->chan);
2845
2846 ast_channel_lock(peer);
2847 peer_bridge = ast_channel_internal_bridge(peer);
2848 ast_channel_unlock(peer);
2849 ast_channel_unref(peer);
2850
2851 /* As we are only doing a pointer comparison we don't need the peer_bridge
2852 * to be reference counted or locked.
2853 */
2854 if (peer_bridge == bridge_channel->bridge) {
2855 ast_bridge_unlock(bridge_channel->bridge);
2856 ast_debug(1, "Bridge %s: %p(%s) denying Bridge join to prevent Local channel loop\n",
2857 bridge_channel->bridge->uniqueid,
2858 bridge_channel,
2859 ast_channel_name(bridge_channel->chan));
2860 return -1;
2861 }
2862
2863 ast_channel_lock(bridge_channel->chan);
2864 }
2865
2866 bridge_channel->read_format = ao2_bump(ast_channel_readformat(bridge_channel->chan));
2867 bridge_channel->write_format = ao2_bump(ast_channel_writeformat(bridge_channel->chan));
2868
2869 /* Make sure we're still good to be put into a bridge */
2870 if (ast_channel_internal_bridge(bridge_channel->chan)
2871 || ast_test_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_ZOMBIE)) {
2872 ast_channel_unlock(bridge_channel->chan);
2873 ast_bridge_unlock(bridge_channel->bridge);
2874 ast_debug(1, "Bridge %s: %p(%s) failed to join Bridge\n",
2875 bridge_channel->bridge->uniqueid,
2876 bridge_channel,
2877 ast_channel_name(bridge_channel->chan));
2878 return -1;
2879 }
2880 ast_channel_internal_bridge_set(bridge_channel->chan, bridge_channel->bridge);
2881
2882 /* Attach features requested by the channel */
2883 channel_features = ast_channel_feature_hooks_get(bridge_channel->chan);
2884 if (channel_features) {
2885 ast_bridge_features_merge(bridge_channel->features, channel_features);
2886 }
2887 ast_channel_unlock(bridge_channel->chan);
2888
2889 /* Add the jitterbuffer if the channel requires it */
2890 ast_jb_enable_for_channel(bridge_channel->chan);
2891
2892 if (!bridge_channel->bridge->callid) {
2893 bridge_channel->bridge->callid = ast_read_threadstorage_callid();
2894 }
2895
2896 /* Take the swap channel ref from the bridge_channel struct. */
2897 swap = bridge_channel->swap;
2898
2899 if (bridge_channel_internal_push(bridge_channel)) {
2900 int cause = bridge_channel->bridge->cause;
2901
2902 ast_bridge_unlock(bridge_channel->bridge);
2903 ast_bridge_channel_kick(bridge_channel, cause);
2904 ast_bridge_channel_lock_bridge(bridge_channel);
2905 ast_bridge_features_remove(bridge_channel->features,
2907 bridge_channel_dissolve_check(bridge_channel);
2908 res = -1;
2909 }
2910 bridge_reconfigured(bridge_channel->bridge, !bridge_channel->inhibit_colp);
2911
2912 if (bridge_channel->state == BRIDGE_CHANNEL_STATE_WAIT) {
2913 /*
2914 * Indicate a source change since this channel is entering the
2915 * bridge system only if the bridge technology is not MULTIMIX
2916 * capable. The MULTIMIX technology has already done it.
2917 */
2918 if (!(bridge_channel->bridge->technology->capabilities
2920 indicate_src_change = 1;
2921 }
2922
2923 bridge_channel_impart_signal(bridge_channel->chan);
2924 ast_bridge_unlock(bridge_channel->bridge);
2925
2926 /* Must release any swap ref after unlocking the bridge. */
2927 ao2_t_cleanup(swap, "Bridge push with swap successful");
2928 swap = NULL;
2929
2930 if (indicate_src_change) {
2931 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCCHANGE);
2932 }
2933
2935
2936 while (bridge_channel->state == BRIDGE_CHANNEL_STATE_WAIT) {
2937 /* Wait for something to do. */
2938 bridge_channel_wait(bridge_channel);
2939 }
2940
2941 /* Force a timeout on any accumulated DTMF hook digits. */
2942 ast_bridge_channel_feature_digit(bridge_channel, 0);
2943
2945 ast_bridge_channel_lock_bridge(bridge_channel);
2946 }
2947
2948 bridge_channel_internal_pull(bridge_channel);
2949 bridge_channel_settle_owed_events(bridge_channel->bridge, bridge_channel);
2950 bridge_reconfigured(bridge_channel->bridge, 1);
2951
2952 /* Remove ourselves if we are the video source */
2953 ast_bridge_remove_video_src(bridge_channel->bridge, bridge_channel->chan);
2954
2955 ast_bridge_unlock(bridge_channel->bridge);
2956
2957 /* Must release any swap ref after unlocking the bridge. */
2958 ao2_t_cleanup(swap, "Bridge push with swap failed or exited immediately");
2959
2960 /* Complete any active hold before exiting the bridge. */
2961 if (ast_channel_hold_state(bridge_channel->chan) == AST_CONTROL_HOLD) {
2962 ast_debug(1, "Channel %s simulating UNHOLD for bridge end.\n",
2963 ast_channel_name(bridge_channel->chan));
2964 ast_indicate(bridge_channel->chan, AST_CONTROL_UNHOLD);
2965 }
2966
2967 /* Complete any partial DTMF digit before exiting the bridge. */
2968 if (ast_channel_sending_dtmf_digit(bridge_channel->chan)) {
2969 ast_channel_end_dtmf(bridge_channel->chan,
2970 ast_channel_sending_dtmf_digit(bridge_channel->chan),
2971 ast_channel_sending_dtmf_tv(bridge_channel->chan), "bridge end");
2972 }
2973
2974 /* Complete any T.38 session before exiting the bridge. */
2975 if (ast_channel_is_t38_active(bridge_channel->chan)) {
2976 struct ast_control_t38_parameters t38_parameters = {
2978 };
2979
2980 ast_debug(1, "Channel %s simulating T.38 terminate for bridge end.\n",
2981 ast_channel_name(bridge_channel->chan));
2983 &t38_parameters, sizeof(t38_parameters));
2984 }
2985
2986 /* Indicate a source change since this channel is leaving the bridge system. */
2987 ast_indicate(bridge_channel->chan, AST_CONTROL_SRCCHANGE);
2988
2989 /*
2990 * Wait for any dual redirect to complete.
2991 *
2992 * Must be done while "still in the bridge" for ast_async_goto()
2993 * to work right.
2994 */
2996 sched_yield();
2997 }
2998 ast_channel_lock(bridge_channel->chan);
2999 ast_channel_internal_bridge_set(bridge_channel->chan, NULL);
3000 ast_channel_unlock(bridge_channel->chan);
3001
3002 ast_bridge_channel_restore_formats(bridge_channel);
3003
3004 return res;
3005}
3006
3008 const char *exten, const char *context,
3009 transfer_channel_cb new_channel_cb, void *user_data)
3010{
3011 RAII_VAR(struct ast_bridge_channel *, transferee_bridge_channel, NULL, ao2_cleanup);
3012 struct blind_transfer_data blind_data;
3013
3014 ast_channel_lock(transferee);
3015 transferee_bridge_channel = ast_channel_get_bridge_channel(transferee);
3016 ast_channel_unlock(transferee);
3017
3018 if (!transferee_bridge_channel) {
3019 return -1;
3020 }
3021
3022 if (new_channel_cb) {
3023 new_channel_cb(transferee, user_data, AST_BRIDGE_TRANSFER_SINGLE_PARTY);
3024 }
3025
3026 ast_copy_string(blind_data.exten, exten, sizeof(blind_data.exten));
3027 ast_copy_string(blind_data.context, context, sizeof(blind_data.context));
3028
3029 return bridge_channel_queue_action_data(transferee_bridge_channel,
3030 BRIDGE_CHANNEL_ACTION_BLIND_TRANSFER, &blind_data, sizeof(blind_data));
3031}
3032
3034 struct ast_channel *unbridged_chan)
3035{
3036 RAII_VAR(struct ast_bridge_channel *, transferee_bridge_channel, NULL, ao2_cleanup);
3037 char unbridged_chan_name[AST_CHANNEL_NAME];
3038
3039 ast_channel_lock(transferee);
3040 transferee_bridge_channel = ast_channel_get_bridge_channel(transferee);
3041 ast_channel_unlock(transferee);
3042
3043 if (!transferee_bridge_channel) {
3044 return -1;
3045 }
3046
3047 ast_copy_string(unbridged_chan_name, ast_channel_name(unbridged_chan),
3048 sizeof(unbridged_chan_name));
3049
3050 return bridge_channel_queue_action_data(transferee_bridge_channel,
3051 BRIDGE_CHANNEL_ACTION_ATTENDED_TRANSFER, unbridged_chan_name,
3052 sizeof(unbridged_chan_name));
3053}
3054
3056{
3057 return bridge_channel->in_bridge
3058 && AST_LIST_EMPTY(&bridge_channel->wr_queue);
3059}
3060
3061/* Destroy elements of the bridge channel structure and the bridge channel structure itself */
3062static void bridge_channel_destroy(void *obj)
3063{
3064 struct ast_bridge_channel *bridge_channel = obj;
3065 struct ast_frame *fr;
3066
3067 if (bridge_channel->callid) {
3068 bridge_channel->callid = 0;
3069 }
3070
3071 if (bridge_channel->bridge) {
3072 ao2_ref(bridge_channel->bridge, -1);
3073 bridge_channel->bridge = NULL;
3074 }
3075
3076 /* Flush any unhandled wr_queue frames. */
3077 while ((fr = AST_LIST_REMOVE_HEAD(&bridge_channel->wr_queue, frame_list))) {
3079 }
3080 ast_alertpipe_close(bridge_channel->alert_pipe);
3081
3082 /* Flush any unhandled deferred_queue frames. */
3083 while ((fr = AST_LIST_REMOVE_HEAD(&bridge_channel->deferred_queue, frame_list))) {
3084 ast_frfree(fr);
3085 }
3086
3087 ast_cond_destroy(&bridge_channel->cond);
3088
3089 ao2_cleanup(bridge_channel->write_format);
3090 ao2_cleanup(bridge_channel->read_format);
3091
3092 AST_VECTOR_FREE(&bridge_channel->stream_map.to_bridge);
3093 AST_VECTOR_FREE(&bridge_channel->stream_map.to_channel);
3094}
3095
3097{
3098 struct ast_bridge_channel *bridge_channel;
3099
3100 bridge_channel = ao2_alloc(sizeof(struct ast_bridge_channel), bridge_channel_destroy);
3101 if (!bridge_channel) {
3102 return NULL;
3103 }
3104 ast_cond_init(&bridge_channel->cond, NULL);
3105 if (ast_alertpipe_init(bridge_channel->alert_pipe)) {
3106 ao2_ref(bridge_channel, -1);
3107 return NULL;
3108 }
3109 if (bridge) {
3110 bridge_channel->bridge = bridge;
3111 ao2_ref(bridge_channel->bridge, +1);
3112 }
3113
3114 /* The stream_map is initialized later - see ast_bridge_channel_stream_map */
3115
3116 return bridge_channel;
3117}
3118
3120{
3121 ast_bridge_channel_lock(bridge_channel);
3122 ast_channel_lock(bridge_channel->chan);
3124 &bridge_channel->bridge->media_types, &bridge_channel->stream_map.to_bridge,
3125 &bridge_channel->stream_map.to_channel);
3126 ast_channel_unlock(bridge_channel->chan);
3127 ast_bridge_channel_unlock(bridge_channel);
3128}
void ast_jb_enable_for_channel(struct ast_channel *chan)
Sets a jitterbuffer frame hook on the channel based on the channel's stored jitterbuffer configuratio...
Definition: abstract_jb.c:585
void ast_alertpipe_close(int alert_pipe[2])
Close an alert pipe.
Definition: alertpipe.c:79
ssize_t ast_alertpipe_write(int alert_pipe[2])
Write an event to an alert pipe.
Definition: alertpipe.c:120
int ast_alertpipe_init(int alert_pipe[2])
Initialize an alert pipe.
Definition: alertpipe.c:38
ast_alert_status_t ast_alertpipe_read(int alert_pipe[2])
Read an event from an alert pipe.
Definition: alertpipe.c:102
char digit
char * text
Definition: app_queue.c:1639
enum queue_result id
Definition: app_queue.c:1638
struct sla_ringing_trunk * first
Definition: app_sla.c:332
Asterisk main include file. File version handling, generic pbx functions.
#define ast_alloca(size)
call __builtin_alloca to ensure we get gcc builtin semantics
Definition: astmm.h:288
#define ast_free(a)
Definition: astmm.h:180
#define ast_strndup(str, len)
A wrapper for strndup()
Definition: astmm.h:256
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:298
#define ast_log
Definition: astobj2.c:42
#define ao2_iterator_next(iter)
Definition: astobj2.h:1911
#define ao2_cleanup(obj)
Definition: astobj2.h:1934
#define ao2_unlink(container, obj)
Remove an object from a container.
Definition: astobj2.h:1578
#define ao2_find(container, arg, flags)
Definition: astobj2.h:1736
struct ao2_iterator ao2_iterator_init(struct ao2_container *c, int flags) attribute_warn_unused_result
Create an iterator for a container.
#define ao2_unlock(a)
Definition: astobj2.h:729
#define ao2_lock(a)
Definition: astobj2.h:717
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition: astobj2.h:459
#define ao2_t_cleanup(obj, tag)
Definition: astobj2.h:1935
void * ao2_object_get_lockaddr(void *obj)
Return the mutex lock address of an object.
Definition: astobj2.c:476
#define ao2_bump(obj)
Bump refcount on an AO2 object by one, returning the object.
Definition: astobj2.h:480
void ao2_iterator_destroy(struct ao2_iterator *iter)
Destroy a container iterator.
@ OBJ_SEARCH_PARTIAL_KEY
The arg parameter is a partial search key similar to OBJ_SEARCH_KEY.
Definition: astobj2.h:1116
#define ao2_alloc(data_size, destructor_fn)
Definition: astobj2.h:409
Bridging API.
void ast_bridge_features_remove(struct ast_bridge_features *features, enum ast_bridge_hook_remove_flags flags)
Remove marked bridge channel feature hooks.
Definition: bridge.c:3501
#define ast_bridge_unlock(bridge)
Unlock the bridge.
Definition: bridge.h:481
void ast_bridge_vars_set(struct ast_channel *chan, const char *name, const char *pvtid)
Sets BRIDGECHANNEL and BRIDGEPVTCALLID for a channel.
Definition: bridge.c:1212
@ AST_BRIDGE_CAPABILITY_MULTIMIX
Definition: bridge.h:94
@ AST_BRIDGE_TRANSFER_SINGLE_PARTY
Definition: bridge.h:1111
void(* transfer_channel_cb)(struct ast_channel *chan, struct transfer_channel_data *user_data, enum ast_transfer_type transfer_type)
Callback function type called during blind transfers.
Definition: bridge.h:1143
void ast_bridge_remove_video_src(struct ast_bridge *bridge, struct ast_channel *chan)
remove a channel as a source of video for the bridge.
Definition: bridge.c:3917
#define ast_bridge_lock(bridge)
Lock the bridge.
Definition: bridge.h:470
After Bridge Execution API.
ast_bridge_after_cb_reason
Definition: bridge_after.h:37
int ast_bridge_set_after_callback(struct ast_channel *chan, ast_bridge_after_cb callback, ast_bridge_after_cb_failed failed, void *data)
Setup an after bridge callback for when the channel leaves the bridging system.
Definition: bridge_after.c:251
const char * ast_bridge_after_cb_reason_string(enum ast_bridge_after_cb_reason reason)
Get a string representation of an after bridge callback reason.
Definition: bridge_after.c:288
void ast_bridge_channel_playfile(struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
Play a file on the bridge channel.
static void bridge_handle_trip(struct ast_bridge_channel *bridge_channel)
int ast_bridge_channel_write_app(struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
Write a bridge action run application frame into the bridge.
static void bridge_sync_init(struct bridge_sync *sync_struct, unsigned int id)
Initialize a synchronous bridge object.
static struct ast_frame * bridge_handle_dtmf(struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
void ast_bridge_channel_run_app(struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
Run an application on the bridge channel.
static int bridge_channel_next_timeout(struct ast_bridge_channel *bridge_channel)
void bridge_channel_internal_unsuspend_nolock(struct ast_bridge_channel *bridge_channel)
void ast_bridge_channel_update_linkedids(struct ast_bridge_channel *bridge_channel, struct ast_bridge_channel *swap)
void ast_bridge_channel_feature_digit_add(struct ast_bridge_channel *bridge_channel, int digit)
Add a DTMF digit to the collected digits.
struct ast_channel * ast_bridge_channel_get_chan(struct ast_bridge_channel *bridge_channel)
Get a ref to the bridge_channel's ast_channel.
static void bridge_channel_cancel_owed_events(struct ast_bridge_channel *bridge_channel)
static void sendtext_safe(struct ast_channel *chan, const struct ast_frame *f)
static int channel_set_cause(struct ast_channel *chan, int cause)
static void bridge_channel_update_accountcodes_joining(struct ast_bridge_channel *joining, struct ast_bridge_channel *swap)
static void bridge_frame_free(struct ast_frame *frame)
static void channel_fill_empty_peeraccount(struct ast_channel *dest, struct ast_channel *src)
static void channel_update_peeraccount(struct ast_channel *dest, struct ast_channel *src)
static void testsuite_notify_feature_success(struct ast_channel *chan, const char *dtmf)
void bridge_channel_internal_suspend_nolock(struct ast_bridge_channel *bridge_channel)
static void channel_fill_empty_accountcode(struct ast_channel *dest, struct ast_channel *src)
void bridge_channel_settle_owed_events(struct ast_bridge *orig_bridge, struct ast_bridge_channel *bridge_channel)
int ast_bridge_channel_write_unhold(struct ast_bridge_channel *bridge_channel)
Write an unhold frame into the bridge.
static void bridge_channel_run_app(struct ast_bridge_channel *bridge_channel, struct bridge_run_app *data)
int ast_bridge_channel_queue_app(struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
Queue a bridge action run application frame onto the bridge channel.
int bridge_channel_internal_push_full(struct ast_bridge_channel *bridge_channel, int optimized)
void ast_bridge_channel_update_accountcodes(struct ast_bridge_channel *joining, struct ast_bridge_channel *leaving)
int bridge_channel_internal_queue_blind_transfer(struct ast_channel *transferee, const char *exten, const char *context, transfer_channel_cb new_channel_cb, void *user_data)
static void bridge_channel_attended_transfer(struct ast_bridge_channel *bridge_channel, const char *target_chan_name)
static void bridge_channel_do_callback(struct ast_bridge_channel *bridge_channel, struct bridge_custom_callback *data)
static void channel_set_empty_accountcodes(struct ast_channel *c0, struct ast_channel *c1)
static void after_bridge_move_channel_fail(enum ast_bridge_after_cb_reason reason, void *data)
void ast_bridge_channel_feature_digit(struct ast_bridge_channel *bridge_channel, int digit)
Add a DTMF digit to the collected digits to match against DTMF features.
static const char * controls[]
static int bridge_channel_queue_action_data(struct ast_bridge_channel *bridge_channel, enum bridge_channel_action_type action, const void *data, size_t datalen)
static void bridge_channel_wait(struct ast_bridge_channel *bridge_channel)
static void bridge_channel_destroy(void *obj)
void ast_bridge_channel_lock_bridge(struct ast_bridge_channel *bridge_channel)
Lock the bridge associated with the bridge channel.
void ast_bridge_channel_kick(struct ast_bridge_channel *bridge_channel, int cause)
Kick the channel out of the bridge.
static int bridge_channel_queue_action_data_sync(struct ast_bridge_channel *bridge_channel, enum bridge_channel_action_type action, const void *data, size_t datalen)
int ast_bridge_channel_notify_talking(struct ast_bridge_channel *bridge_channel, int started_talking)
Lets the bridging indicate when a bridge channel has stopped or started talking.
static void bridge_channel_handle_interval(struct ast_bridge_channel *bridge_channel)
static void bridge_channel_unsuspend(struct ast_bridge_channel *bridge_channel)
static int bridge_channel_feature_timeout(struct ast_bridge_channel *bridge_channel)
static void bridge_channel_poke(struct ast_bridge_channel *bridge_channel)
int bridge_channel_internal_push(struct ast_bridge_channel *bridge_channel)
static void bridge_channel_dissolve_check(struct ast_bridge_channel *bridge_channel)
static void bridge_channel_event_join_leave(struct ast_bridge_channel *bridge_channel, enum ast_bridge_hook_type type)
int ast_bridge_channel_write_control_data(struct ast_bridge_channel *bridge_channel, enum ast_control_frame_type control, const void *data, size_t datalen)
Write a control frame into the bridge with data.
static void bridge_channel_dtmf_stream(struct ast_bridge_channel *bridge_channel, const char *dtmf)
static void bridge_channel_handle_write(struct ast_bridge_channel *bridge_channel)
int bridge_channel_internal_allows_optimization(struct ast_bridge_channel *bridge_channel)
static int bridge_channel_write_frame(struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
void ast_bridge_channel_stream_map(struct ast_bridge_channel *bridge_channel)
Maps a channel's stream topology to and from the bridge.
static void bridge_channel_blind_transfer(struct ast_bridge_channel *bridge_channel, struct blind_transfer_data *blind_data)
int bridge_channel_internal_queue_attended_transfer(struct ast_channel *transferee, struct ast_channel *unbridged_chan)
static void bridge_channel_park(struct ast_bridge_channel *bridge_channel, struct bridge_park *payload)
static void bridge_sync_wait(struct bridge_sync *sync_struct)
Wait for a synchronous bridge action to complete.
struct ast_bridge_channel * bridge_channel_internal_alloc(struct ast_bridge *bridge)
struct ast_bridge * ast_bridge_channel_merge_inhibit(struct ast_bridge_channel *bridge_channel, int request)
Adjust the bridge_channel's bridge merge inhibit request count.
static void bridge_channel_handle_feature_timeout(struct ast_bridge_channel *bridge_channel)
static void bridge_sync_cleanup(struct bridge_sync *sync_struct)
Clean up a synchronization bridge object.
struct ast_bridge_channel * ast_bridge_channel_peer(struct ast_bridge_channel *bridge_channel)
Get the peer bridge channel of a two party bridge.
void ast_bridge_channel_leave_bridge_nolock(struct ast_bridge_channel *bridge_channel, enum bridge_channel_state new_state, int cause)
Set bridge channel state to leave bridge (if not leaving already).
static int bridge_channel_write_action_data(struct ast_bridge_channel *bridge_channel, enum bridge_channel_action_type action, const void *data, size_t datalen)
int ast_bridge_channel_queue_frame(struct ast_bridge_channel *bridge_channel, struct ast_frame *fr)
Write a frame to the specified bridge_channel.
void bridge_channel_internal_pull(struct ast_bridge_channel *bridge_channel)
int ast_bridge_channel_queue_control_data(struct ast_bridge_channel *bridge_channel, enum ast_control_frame_type control, const void *data, size_t datalen)
Queue a control frame onto the bridge channel with data.
static void after_bridge_move_channel(struct ast_channel *chan_bridged, void *data)
int ast_bridge_channel_queue_playfile(struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
Queue a bridge action play file frame onto the bridge channel.
static void bridge_channel_update_accountcodes_leaving(struct ast_bridge_channel *leaving)
void ast_bridge_channel_restore_formats(struct ast_bridge_channel *bridge_channel)
Restore the formats of a bridge channel's channel to how they were before bridge_channel_internal_joi...
int ast_bridge_channel_queue_playfile_sync(struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
Synchronously queue a bridge action play file frame onto the bridge channel.
int bridge_channel_internal_join(struct ast_bridge_channel *bridge_channel)
static int sync_ids
Counter used for assigning synchronous bridge action IDs.
static int payload_helper_app(ast_bridge_channel_post_action_data post_it, struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
#define PLAYBACK_TIMEOUT
Failsafe for synchronous bridge action waiting.
static int payload_helper_playfile(ast_bridge_channel_post_action_data post_it, struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
int ast_bridge_channel_write_playfile(struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
Write a bridge action play file frame into the bridge.
void ast_bridge_channel_leave_bridge(struct ast_bridge_channel *bridge_channel, enum bridge_channel_state new_state, int cause)
Set bridge channel state to leave bridge (if not leaving already).
static void bridge_channel_playfile(struct ast_bridge_channel *bridge_channel, struct bridge_playfile *payload)
int ast_bridge_channel_write_hold(struct ast_bridge_channel *bridge_channel, const char *moh_class)
Write a hold frame into the bridge.
int ast_bridge_channel_queue_callback(struct ast_bridge_channel *bridge_channel, enum ast_bridge_channel_custom_callback_option flags, ast_bridge_custom_callback_fn callback, const void *payload, size_t payload_size)
Queue a bridge action custom callback frame onto the bridge channel.
static void bridge_channel_handle_control(struct ast_bridge_channel *bridge_channel, struct ast_frame *fr)
int ast_bridge_channel_write_callback(struct ast_bridge_channel *bridge_channel, enum ast_bridge_channel_custom_callback_option flags, ast_bridge_custom_callback_fn callback, const void *payload, size_t payload_size)
Write a bridge action custom callback frame into the bridge.
static int run_app_helper(struct ast_channel *chan, const char *app_name, const char *app_args)
static void bridge_sync_signal(struct bridge_sync *sync_struct)
Signal that waiting for a synchronous bridge action is no longer necessary.
static void bridge_channel_talking(struct ast_bridge_channel *bridge_channel, int talking)
int(* ast_bridge_channel_post_action_data)(struct ast_bridge_channel *bridge_channel, enum bridge_channel_action_type action, const void *data, size_t datalen)
Used to queue an action frame onto a bridge channel and write an action frame into a bridge.
static void bridge_channel_suspend(struct ast_bridge_channel *bridge_channel)
static int bridge_channel_write_dtmf_stream(struct ast_bridge_channel *bridge_channel, const char *dtmf)
static unsigned int bridge_channel_feature_digit_timeout(struct ast_bridge_channel *bridge_channel)
static int payload_helper_park(ast_bridge_channel_post_action_data post_it, struct ast_bridge_channel *bridge_channel, const char *parkee_uuid, const char *parker_uuid, const char *app_data)
static int bridge_channel_feature_digit_add(struct ast_bridge_channel *bridge_channel, int digit, size_t dtmf_len)
void bridge_channel_queue_deferred_frames(struct ast_bridge_channel *bridge_channel)
int ast_bridge_queue_everyone_else(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
Queue the given frame to everyone else.
static int bridge_channel_next_interval(struct ast_bridge_channel *bridge_channel)
static void bridge_channel_handle_action(struct ast_bridge_channel *bridge_channel, enum bridge_channel_action_type action, void *data)
int ast_bridge_channel_write_park(struct ast_bridge_channel *bridge_channel, const char *parkee_uuid, const char *parker_uuid, const char *app_data)
Have a bridge channel park a channel in the bridge.
static void channel_update_peeraccounts(struct ast_channel *c0, struct ast_channel *c1)
static int payload_helper_cb(ast_bridge_channel_post_action_data post_it, struct ast_bridge_channel *bridge_channel, enum ast_bridge_channel_custom_callback_option flags, ast_bridge_custom_callback_fn callback, const void *payload, size_t payload_size)
ast_bridge_channel_custom_callback_option
@ AST_BRIDGE_CHANNEL_CB_OPTION_MEDIA
#define ast_bridge_channel_unlock(bridge_channel)
Unlock the bridge_channel.
void(* ast_bridge_custom_callback_fn)(struct ast_bridge_channel *bridge_channel, const void *payload, size_t payload_size)
Custom callback run on a bridge channel.
#define ast_bridge_channel_lock(bridge_channel)
Lock the bridge_channel.
bridge_channel_state
State information about a bridged channel.
@ BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE
@ BRIDGE_CHANNEL_STATE_WAIT
@ BRIDGE_CHANNEL_STATE_END
@ BRIDGE_CHANNEL_THREAD_FRAME
@ BRIDGE_CHANNEL_THREAD_SIMPLE
@ BRIDGE_CHANNEL_THREAD_IDLE
void(* ast_bridge_custom_play_fn)(struct ast_bridge_channel *bridge_channel, const char *playfile)
Custom interpretation of the playfile name.
Private Bridging Channel API.
void bridge_channel_impart_signal(struct ast_channel *chan)
Definition: bridge.c:1582
bridge_channel_action_type
@ BRIDGE_CHANNEL_ACTION_ATTENDED_TRANSFER
@ BRIDGE_CHANNEL_ACTION_DTMF_STREAM
@ BRIDGE_CHANNEL_ACTION_TALKING_STOP
@ BRIDGE_CHANNEL_ACTION_PLAY_FILE
@ BRIDGE_CHANNEL_ACTION_TALKING_START
@ BRIDGE_CHANNEL_ACTION_BLIND_TRANSFER
@ BRIDGE_CHANNEL_ACTION_CALLBACK
@ BRIDGE_CHANNEL_ACTION_RUN_APP
@ BRIDGE_CHANNEL_ACTION_PARK
ast_bridge_hook_type
@ AST_BRIDGE_HOOK_TYPE_JOIN
@ AST_BRIDGE_HOOK_TYPE_HANGUP
@ AST_BRIDGE_HOOK_TYPE_LEAVE
@ AST_BRIDGE_HOOK_TYPE_TALK
@ AST_BRIDGE_HOOK_REMOVE_ON_PULL
@ AST_BRIDGE_FLAG_DISSOLVE_EMPTY
@ AST_BRIDGE_FLAG_DISSOLVE_HANGUP
void ast_bridge_features_merge(struct ast_bridge_features *into, const struct ast_bridge_features *from)
Merge one ast_bridge_features into another.
Definition: bridge.c:3595
@ AST_BRIDGE_HOOK_TIMER_OPTION_MEDIA
int(* ast_bridge_talking_indicate_callback)(struct ast_bridge_channel *bridge_channel, void *hook_pvt, int talking)
Talking indicator callback.
@ AST_BRIDGE_CHANNEL_FLAG_LONELY
@ AST_BRIDGE_CHANNEL_FLAG_DISSOLVE_HANGUP
Private Bridging API.
void bridge_dissolve(struct ast_bridge *bridge, int cause)
Definition: bridge.c:315
void bridge_reconfigured(struct ast_bridge *bridge, unsigned int colp_update)
Definition: bridge.c:1403
struct ast_bridge_channel * bridge_find_channel(struct ast_bridge *bridge, struct ast_channel *chan)
Definition: bridge.c:1429
void bridge_merge_inhibit_nolock(struct ast_bridge *bridge, int request)
Definition: bridge.c:2991
int ast_bridge_channel_establish_roles(struct ast_bridge_channel *bridge_channel)
Clone the roles from a bridge_channel's attached ast_channel onto the bridge_channel's role list.
Definition: bridge_roles.c:443
void ast_bridge_channel_clear_roles(struct ast_bridge_channel *bridge_channel)
Clear all roles from a bridge_channel's role list.
Definition: bridge_roles.c:491
Internal Asterisk hangup causes.
#define AST_CAUSE_NORMAL_CLEARING
Definition: causes.h:106
static const char type[]
Definition: chan_ooh323.c:109
static int request(void *obj)
Definition: chan_pjsip.c:2601
General Asterisk PBX channel definitions.
const char * ast_channel_name(const struct ast_channel *chan)
struct ast_bridge * ast_channel_internal_bridge(const struct ast_channel *chan)
void ast_channel_end_dtmf(struct ast_channel *chan, char digit, struct timeval start, const char *why)
Simulate a DTMF end on a broken bridge channel.
Definition: channel.c:10869
void ast_channel_internal_copy_linkedid(struct ast_channel *dest, struct ast_channel *source)
Copy the full linkedid channel id structure from one channel to another.
struct ast_channel * ast_waitfor_nandfds(struct ast_channel **c, int n, int *fds, int nfds, int *exception, int *outfd, int *ms)
Waits for activity on a group of channels.
Definition: channel.c:2988
void ast_channel_clear_flag(struct ast_channel *chan, unsigned int flag)
Clear a flag on a channel.
Definition: channel.c:11034
int ast_channel_connected_line_sub(struct ast_channel *autoservice_chan, struct ast_channel *sub_chan, const void *connected_info, int frame)
Run a connected line interception subroutine and update a channel's connected line information.
Definition: channel.c:10338
const char * ast_channel_latest_musicclass(const struct ast_channel *chan)
void ast_party_connected_line_free(struct ast_party_connected_line *doomed)
Destroy the connected line information contents.
Definition: channel.c:2072
int ast_sendtext_data(struct ast_channel *chan, struct ast_msg_data *msg)
Sends text to a channel in an ast_msg_data structure wrapper with ast_sendtext as fallback.
Definition: channel.c:4751
#define ast_channel_lock(chan)
Definition: channel.h:2922
struct timeval ast_channel_sending_dtmf_tv(const struct ast_channel *chan)
int ast_queue_frame_head(struct ast_channel *chan, struct ast_frame *f)
Queue one or more frames to the head of a channel's frame queue.
Definition: channel.c:1144
void ast_party_connected_line_copy(struct ast_party_connected_line *dest, const struct ast_party_connected_line *src)
Copy the source connected line information to the destination connected line.
Definition: channel.c:2031
struct ast_flags * ast_channel_flags(struct ast_channel *chan)
#define ast_channel_ref(c)
Increase channel reference count.
Definition: channel.h:2947
#define ast_channel_lock_both(chan1, chan2)
Lock two channels.
Definition: channel.h:2929
struct ast_party_connected_line * ast_channel_connected(struct ast_channel *chan)
int ast_queue_frame(struct ast_channel *chan, struct ast_frame *f)
Queue one or more frames to a channel's frame queue.
Definition: channel.c:1139
const char * ast_channel_accountcode(const struct ast_channel *chan)
int ast_check_hangup_locked(struct ast_channel *chan)
Definition: channel.c:459
int ast_queue_control_data(struct ast_channel *chan, enum ast_control_frame_type control, const void *data, size_t datalen)
Queue a control frame with payload.
Definition: channel.c:1238
struct ast_bridge_features * ast_channel_feature_hooks_get(struct ast_channel *chan)
Gets the channel-attached features a channel has access to upon being bridged.
Definition: channel.c:10903
int ast_channel_move(struct ast_channel *dest, struct ast_channel *source)
Move a channel from its current location to a new location.
Definition: channel.c:10666
int ast_sendtext(struct ast_channel *chan, const char *text)
Sends text to a channel.
Definition: channel.c:4809
struct ast_frame * ast_read_stream(struct ast_channel *chan)
Reads a frame, but does not filter to just the default streams.
Definition: channel.c:4262
const char * ast_channel_peeraccount(const struct ast_channel *chan)
int ast_channel_redirecting_sub(struct ast_channel *autoservice_chan, struct ast_channel *sub_chan, const void *redirecting_info, int is_frame)
Run a redirecting interception subroutine and update a channel's redirecting information.
Definition: channel.c:10383
struct ast_frame * ast_read_stream_noaudio(struct ast_channel *chan)
Reads a frame, but does not filter to just the default streams, returning AST_FRAME_NULL frame if aud...
Definition: channel.c:4272
int ast_set_read_format(struct ast_channel *chan, struct ast_format *format)
Sets read format on channel chan.
Definition: channel.c:5762
void ast_channel_internal_bridge_set(struct ast_channel *chan, struct ast_bridge *value)
struct ast_stream_topology * ast_channel_get_stream_topology(const struct ast_channel *chan)
Retrieve the topology of streams on a channel.
void ast_channel_set_unbridged(struct ast_channel *chan, int value)
Sets the unbridged flag and queues a NULL frame on the channel to trigger a check by bridge_channel_w...
int ast_channel_hangupcause(const struct ast_channel *chan)
int ast_indicate_data(struct ast_channel *chan, int condition, const void *data, size_t datalen)
Indicates condition of channel, with payload.
Definition: channel.c:4653
int ast_softhangup(struct ast_channel *chan, int cause)
Softly hangup up a channel.
Definition: channel.c:2471
void ast_party_id_reset(struct ast_party_id *id)
Destroy and initialize the given party id structure.
Definition: channel.c:1896
int ast_connected_line_build_data(unsigned char *data, size_t datalen, const struct ast_party_connected_line *connected, const struct ast_set_party_connected_line *update)
Build the connected line information data frame.
Definition: channel.c:8697
#define AST_CHANNEL_NAME
Definition: channel.h:171
#define ast_channel_unref(c)
Decrease channel reference count.
Definition: channel.h:2958
struct ast_format * ast_channel_writeformat(struct ast_channel *chan)
@ AST_SOFTHANGUP_DEV
Definition: channel.h:1121
int ast_set_write_format(struct ast_channel *chan, struct ast_format *format)
Sets write format on channel chan.
Definition: channel.c:5803
#define AST_MAX_CONTEXT
Definition: channel.h:135
int ast_channel_unbridged(struct ast_channel *chan)
This function will check if the bridge needs to be re-evaluated due to external changes.
void ast_party_connected_line_init(struct ast_party_connected_line *init)
Initialize the given connected line structure.
Definition: channel.c:2022
int ast_channel_is_leaving_bridge(struct ast_channel *chan)
Determine if a channel is leaving a bridge, but not hung up.
Definition: channel.c:10550
int ast_channel_hold_state(const struct ast_channel *chan)
struct ast_bridge_channel * ast_channel_get_bridge_channel(struct ast_channel *chan)
Get a reference to the channel's bridge pointer.
Definition: channel.c:10582
struct ast_party_connected_line * ast_channel_connected_indicated(struct ast_channel *chan)
void ast_connected_line_copy_from_caller(struct ast_party_connected_line *dest, const struct ast_party_caller *src)
Copy the caller information to the connected line information.
Definition: channel.c:8293
const char * ast_channel_call_forward(const struct ast_channel *chan)
@ AST_FLAG_BRIDGE_DUAL_REDIRECT_WAIT
Definition: channel.h:1035
@ AST_FLAG_ZOMBIE
Definition: channel.h:987
@ AST_FLAG_OUTGOING
Definition: channel.h:999
@ AST_FLAG_MOH
Definition: channel.h:991
int ast_channel_setoption(struct ast_channel *channel, int option, void *data, int datalen, int block)
Sets an option on a channel.
Definition: channel.c:7422
struct ast_party_caller * ast_channel_caller(struct ast_channel *chan)
void ast_channel_queue_connected_line_update(struct ast_channel *chan, const struct ast_party_connected_line *connected, const struct ast_set_party_connected_line *update)
Queue a connected line update frame on a channel.
Definition: channel.c:9106
char ast_channel_sending_dtmf_digit(const struct ast_channel *chan)
int ast_write_stream(struct ast_channel *chan, int stream_num, struct ast_frame *frame)
Write a frame to a stream This function writes the given frame to the indicated stream on the channel...
Definition: channel.c:5149
void ast_channel_hangupcause_set(struct ast_channel *chan, int value)
struct ast_channel * ast_channel_get_by_name(const char *name)
Find a channel by name.
Definition: channel.c:1454
int ast_answer(struct ast_channel *chan)
Answer a channel.
Definition: channel.c:2805
int ast_channel_is_multistream(struct ast_channel *chan)
Determine if a channel is multi-stream capable.
int ast_indicate(struct ast_channel *chan, int condition)
Indicates condition of channel.
Definition: channel.c:4277
int ast_is_deferrable_frame(const struct ast_frame *frame)
Should we keep this frame for later?
Definition: channel.c:1467
int ast_channel_is_t38_active(struct ast_channel *chan)
This function will check if T.38 is active on the channel.
#define ast_channel_unlock(chan)
Definition: channel.h:2923
#define AST_MAX_EXTENSION
Definition: channel.h:134
struct ast_channel * ast_channel_internal_oldest_linkedid(struct ast_channel *a, struct ast_channel *b)
Determine which channel has an older linkedid.
struct ast_format * ast_channel_readformat(struct ast_channel *chan)
ast_channel_state
ast_channel states
Definition: channelstate.h:35
@ AST_STATE_UP
Definition: channelstate.h:42
Local proxy channel special access.
struct ast_channel * ast_local_get_peer(struct ast_channel *ast)
Get the other local channel in the pair.
Definition: core_local.c:276
int ast_stream_and_wait(struct ast_channel *chan, const char *file, const char *digits)
stream file until digit If the file name is non-empty, try to play it.
Definition: file.c:1878
#define AST_DIGIT_NONE
Definition: file.h:47
enum ast_format_cmp_res ast_format_cmp(const struct ast_format *format1, const struct ast_format *format2)
Compare two formats.
Definition: format.c:201
@ AST_FORMAT_CMP_NOT_EQUAL
Definition: format.h:38
const char * ast_format_get_name(const struct ast_format *format)
Get the name associated with a format.
Definition: format.c:334
static int frame_size[4]
Definition: format_g726.c:52
struct stasis_message_type * ast_channel_hold_type(void)
Message type for when a channel is placed on hold.
void ast_channel_publish_cached_blob(struct ast_channel *chan, struct stasis_message_type *type, struct ast_json *blob)
Publish a channel blob message using the latest snapshot from the cache.
void ast_channel_publish_dial(struct ast_channel *caller, struct ast_channel *peer, const char *dialstring, const char *dialstatus)
Publish in the ast_channel_topic or ast_channel_topic_all topics a stasis message for the channels in...
struct stasis_message_type * ast_channel_unhold_type(void)
Message type for when a channel is removed from hold.
void ast_channel_publish_dial_forward(struct ast_channel *caller, struct ast_channel *peer, struct ast_channel *forwarded, const char *dialstring, const char *dialstatus, const char *forward)
Publish in the ast_channel_topic or ast_channel_topic_all topics a stasis message for the channels in...
const char * ast_msg_data_get_attribute(struct ast_msg_data *msg, enum ast_msg_data_attribute_type attribute_type)
Get attribute from ast_msg_data.
@ AST_MSG_DATA_ATTR_BODY
Definition: message.h:458
@ AST_MSG_DATA_ATTR_TO
Definition: message.h:455
@ AST_MSG_DATA_ATTR_FROM
Definition: message.h:456
unsigned int option_dtmfminduration
Definition: options.c:83
Max Heap data structure.
#define ast_heap_unlock(h)
Definition: heap.h:249
void * ast_heap_remove(struct ast_heap *h, void *elm)
Remove a specific element from a heap.
Definition: heap.c:251
#define ast_heap_push(h, elm)
Push an element on to a heap.
Definition: heap.h:125
#define ast_heap_wrlock(h)
Definition: heap.h:247
void * ast_heap_peek(struct ast_heap *h, unsigned int index)
Peek at an element on a heap.
Definition: heap.c:267
Application convenience functions, designed to give consistent look and feel to Asterisk apps.
int ast_app_exec_sub(struct ast_channel *autoservice_chan, struct ast_channel *sub_chan, const char *sub_args, int ignore_hangup)
Run a subroutine on a channel, placing an optional second channel into autoservice.
Definition: main/app.c:297
int ast_dtmf_stream(struct ast_channel *chan, struct ast_channel *peer, const char *digits, int between, unsigned int duration)
Send a string of DTMF digits to a channel.
Definition: main/app.c:1127
struct ast_features_general_config * ast_get_chan_features_general_config(struct ast_channel *chan)
Get the general configuration options for a channel.
struct ast_featuremap_config * ast_get_chan_featuremap_config(struct ast_channel *chan)
Get the featuremap configuration options for a channel.
struct ast_features_xfer_config * ast_get_chan_features_xfer_config(struct ast_channel *chan)
Get the transfer configuration options for a channel.
@ AST_T38_TERMINATED
@ AST_T38_REFUSED
@ AST_T38_REQUEST_TERMINATE
@ AST_T38_NEGOTIATED
@ AST_T38_REQUEST_NEGOTIATE
@ AST_FRAME_READ_ACTION_CONNECTED_LINE_MACRO
#define AST_OPTION_RELAXDTMF
#define AST_OPTION_TONE_VERIFY
#define ast_frdup(fr)
Copies a frame.
#define AST_OPTION_DIGIT_DETECT
#define ast_frfree(fr)
#define AST_OPTION_TDD
#define AST_OPTION_FLAG_REQUEST
#define AST_OPTION_FAX_DETECT
ast_frame_type
Frame types.
@ AST_FRAME_VIDEO
@ AST_FRAME_NULL
@ AST_FRAME_IMAGE
@ AST_FRAME_DTMF_END
@ AST_FRAME_DTMF_BEGIN
@ AST_FRAME_BRIDGE_ACTION_SYNC
@ AST_FRAME_VOICE
@ AST_FRAME_RTCP
@ AST_FRAME_TEXT_DATA
@ AST_FRAME_CONTROL
@ AST_FRAME_BRIDGE_ACTION
@ AST_FRAME_TEXT
ast_control_frame_type
Internal control frame subtype field values.
@ AST_CONTROL_SRCUPDATE
@ AST_CONTROL_PROGRESS
@ AST_CONTROL_BUSY
@ AST_CONTROL_UNHOLD
@ AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE
@ AST_CONTROL_PROCEEDING
@ AST_CONTROL_REDIRECTING
@ AST_CONTROL_T38_PARAMETERS
@ AST_CONTROL_READ_ACTION
@ AST_CONTROL_CONGESTION
@ AST_CONTROL_ANSWER
@ AST_CONTROL_RINGING
@ AST_CONTROL_HANGUP
@ AST_CONTROL_HOLD
@ AST_CONTROL_OPTION
@ AST_CONTROL_STREAM_TOPOLOGY_CHANGED
@ AST_CONTROL_CONNECTED_LINE
@ AST_CONTROL_SRCCHANGE
@ AST_CONTROL_MASQUERADE_NOTIFY
#define AST_OPTION_AUDIO_MODE
struct ast_frame ast_null_frame
Definition: main/frame.c:79
#define AST_LOG_WARNING
#define DEBUG_ATLEAST(level)
#define ast_debug(level,...)
Log a DEBUG message.
ast_callid ast_read_threadstorage_callid(void)
extracts the callerid from the thread
Definition: logger.c:2298
#define LOG_DEBUG
#define LOG_ERROR
#define ast_verb(level,...)
#define LOG_WARNING
#define LOG_DTMF
void ast_json_unref(struct ast_json *value)
Decrease refcount on value. If refcount reaches zero, value is freed.
Definition: json.c:73
struct ast_json * ast_json_pack(char const *format,...)
Helper for creating complex JSON values.
Definition: json.c:612
#define AST_RWLIST_RDLOCK(head)
Read locks a list.
Definition: linkedlists.h:78
#define AST_LIST_LAST(head)
Returns the last entry contained in a list.
Definition: linkedlists.h:429
#define AST_RWLIST_WRLOCK(head)
Write locks a list.
Definition: linkedlists.h:52
#define AST_RWLIST_UNLOCK(head)
Attempts to unlock a read/write based list.
Definition: linkedlists.h:151
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
Definition: linkedlists.h:491
#define AST_RWLIST_HEAD_STATIC(name, type)
Defines a structure to be used to hold a read/write list of specified type, statically initialized.
Definition: linkedlists.h:333
#define AST_LIST_EMPTY(head)
Checks whether the specified list contains any entries.
Definition: linkedlists.h:450
#define AST_LIST_INSERT_TAIL(head, elm, field)
Appends a list entry to the tail of a list.
Definition: linkedlists.h:731
#define AST_LIST_ENTRY(type)
Declare a forward link structure inside a list entry.
Definition: linkedlists.h:410
#define AST_LIST_TRAVERSE_SAFE_END
Closes a safe loop traversal block.
Definition: linkedlists.h:615
#define AST_RWLIST_TRAVERSE
Definition: linkedlists.h:494
#define AST_LIST_INSERT_HEAD(head, elm, field)
Inserts a list entry at the head of a list.
Definition: linkedlists.h:711
#define AST_LIST_REMOVE(head, elm, field)
Removes a specific entry from a list.
Definition: linkedlists.h:856
#define AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field)
Loops safely over (traverses) the entries in a list.
Definition: linkedlists.h:529
#define AST_LIST_REMOVE_CURRENT(field)
Removes the current entry from a list during a traversal.
Definition: linkedlists.h:557
#define AST_RWLIST_INSERT_TAIL
Definition: linkedlists.h:741
#define AST_LIST_REMOVE_HEAD(head, field)
Removes and returns the head entry from a list.
Definition: linkedlists.h:833
#define AST_LIST_FIRST(head)
Returns the first entry contained in a list.
Definition: linkedlists.h:421
#define ast_cond_destroy(cond)
Definition: lock.h:202
#define ast_cond_wait(cond, mutex)
Definition: lock.h:205
#define ast_cond_init(cond, attr)
Definition: lock.h:201
int ast_atomic_fetchadd_int(volatile int *p, int v)
Atomically add v to *p and return the previous value of *p.
Definition: lock.h:757
#define ast_cond_signal(cond)
Definition: lock.h:203
Out-of-call text message support.
Music on hold handling.
int ast_moh_start(struct ast_channel *chan, const char *mclass, const char *interpclass)
Turn on music on hold on a given channel.
Definition: channel.c:7766
Call Parking API.
int ast_parking_park_bridge_channel(struct ast_bridge_channel *parkee, const char *parkee_uuid, const char *parker_uuid, const char *app_data)
Perform a direct park on a channel in a bridge.
Definition: parking.c:126
int ast_parking_provider_registered(void)
Check whether a parking provider is registered.
Definition: parking.c:241
Core PBX routines and definitions.
int pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value)
Add a variable to the channel variable stack, removing the most recently set value for the same name.
int ast_pbx_exec_application(struct ast_channel *chan, const char *app_name, const char *app_args)
Execute an application.
Definition: pbx_app.c:501
int ast_async_goto(struct ast_channel *chan, const char *context, const char *exten, int priority)
Set the channel to next execute the specified dialplan location.
Definition: pbx.c:6969
const char * app_name(struct ast_app *app)
Definition: pbx_app.c:463
#define NULL
Definition: resample.c:96
Asterisk semaphore API.
int ast_sem_init(struct ast_sem *sem, int pshared, unsigned int value)
Initialize a semaphore.
int ast_sem_destroy(struct ast_sem *sem)
Destroy a semaphore.
int ast_sem_timedwait(struct ast_sem *sem, const struct timespec *abs_timeout)
Decrements the semaphore, waiting until abs_timeout.
int ast_sem_post(struct ast_sem *sem)
Increments the semaphore, unblocking a waiter if necessary.
void ast_bridge_publish_leave(struct ast_bridge *bridge, struct ast_channel *chan)
Publish a bridge channel leave event.
void ast_bridge_publish_enter(struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap)
Publish a bridge channel enter event.
Media Stream API.
void ast_stream_topology_map(const struct ast_stream_topology *topology, struct ast_vector_int *types, struct ast_vector_int *v0, struct ast_vector_int *v1)
Map a given topology's streams to the given types.
Definition: stream.c:985
#define S_OR(a, b)
returns the equivalent of logic or for strings: first one if not empty, otherwise second one.
Definition: strings.h:80
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:65
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:425
When we need to walk through a container, we use an ao2_iterator to keep track of the current positio...
Definition: astobj2.h:1821
Structure that contains information regarding a channel in a bridge.
struct ast_vector_int to_bridge
struct ast_bridge_channel::@198 stream_map
unsigned int suspended
struct ast_bridge_channel::@195 dtmf_hook_state
struct ast_channel * swap
struct ast_format * write_format
struct ast_bridge * bridge
Bridge this channel is participating in.
struct ast_bridge_channel::@194 owed
struct timeval interdigit_timeout
char collected[MAXIMUM_DTMF_FEATURE_STRING]
struct ast_bridge_features * features
struct timeval dtmf_tv
unsigned int just_joined
struct ast_channel * chan
struct ast_format * read_format
enum bridge_channel_state state
struct ast_vector_int to_channel
unsigned int inhibit_colp
enum bridge_channel_thread_state activity
The bridge channel thread activity.
struct ast_bridge_channel::@192 wr_queue
struct ast_bridge_channel::@193 deferred_queue
unsigned int in_bridge
Structure that contains features information.
struct ao2_container * other_hooks
struct ao2_container * dtmf_hooks
unsigned int interval_sequence
unsigned int dtmf_passthrough
struct ast_heap * interval_hooks
unsigned int text_messaging
struct ast_flags feature_flags
char code[MAXIMUM_DTMF_FEATURE_STRING]
struct ast_bridge_hook generic
struct ast_bridge_hook_dtmf_parms dtmf
struct ast_bridge_hook generic
struct ast_bridge_hook_timer_parms timer
Structure that is the essence of a feature hook.
enum ast_bridge_hook_type type
ast_bridge_hook_callback callback
ast_bridge_push_channel_fn push
Definition: bridge.h:265
const char * name
Definition: bridge.h:259
ast_bridge_pull_channel_fn pull
Definition: bridge.h:267
void(* unsuspend)(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
Unsuspend a channel on a bridging technology instance for a bridge.
int(* stream_topology_request_change)(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
Callback for when a request has been made to change a stream topology on a channel.
void(* stream_topology_changed)(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
Callback for when a stream topology changes on the channel.
int(* write)(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
Write a frame into the bridging technology instance for a bridge.
void(* suspend)(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
Suspend a channel on a bridging technology instance for a bridge.
void(* leave)(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
Remove a channel from a bridging technology instance for a bridge.
Structure that contains information about a bridge.
Definition: bridge.h:349
struct ast_vector_int media_types
Definition: bridge.h:404
const struct ast_bridge_methods * v_table
Definition: bridge.h:351
unsigned int reconfigured
Definition: bridge.h:388
unsigned int num_active
Definition: bridge.h:375
ast_callid callid
Definition: bridge.h:361
const ast_string_field uniqueid
Definition: bridge.h:401
struct ast_bridge_channels_list channels
Definition: bridge.h:363
unsigned int num_channels
Definition: bridge.h:373
unsigned int dissolved
Definition: bridge.h:390
int cause
Definition: bridge.h:386
struct ast_bridge_technology * technology
Definition: bridge.h:355
unsigned int num_lonely
Definition: bridge.h:377
struct ast_flags feature_flags
Definition: bridge.h:369
Main Channel structure associated with a channel.
struct ast_bridge_channel * bridge_channel
struct ast_bridge * bridge
enum ast_channel_state state
enum ast_frame_read_action action
enum ast_control_t38 request_response
Configuration for the builtin features.
General features configuration items.
Feature configuration relating to transfers.
Data structure associated with a single frame of data.
struct ast_frame_subclass subclass
union ast_frame::@226 data
enum ast_frame_type frametype
const char * src
Definition: heap.c:36
Abstract JSON element (object, array, string, int, ...).
Structure used to transport a message through the frame core.
Connected Line/Party information.
Definition: channel.h:456
struct ast_party_id priv
Private connected party ID.
Definition: channel.h:468
Definition: sem.h:81
Data specifying where a blind transfer is going to.
char exten[AST_MAX_EXTENSION]
char context[AST_MAX_CONTEXT]
ast_bridge_custom_callback_fn callback
char parkee_uuid[0]
ast_bridge_custom_play_fn custom_play
Synchronous bridge action object.
struct bridge_sync::@314 list
struct ast_sem sem
unsigned int id
Definition: search.h:40
Frame payload for synchronous bridge actions.
unsigned int id
unsigned char data[0]
List holding active synchronous action objects.
Test Framework API.
#define ast_test_suite_event_notify(s, f,...)
Definition: test.h:189
struct timeval ast_samp2tv(unsigned int _nsamp, unsigned int _rate)
Returns a timeval corresponding to the duration of n samples at rate r. Useful to convert samples to ...
Definition: time.h:282
struct timeval ast_tvadd(struct timeval a, struct timeval b)
Returns the sum of two timevals a + b.
Definition: extconf.c:2282
int64_t ast_tvdiff_ms(struct timeval end, struct timeval start)
Computes the difference (in milliseconds) between two struct timeval instances.
Definition: time.h:107
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition: time.h:159
Timing source management.
#define ast_test_flag(p, flag)
Definition: utils.h:63
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition: utils.h:941
#define ast_assert(a)
Definition: utils.h:739
#define ast_set2_flag(p, value, flag)
Definition: utils.h:94
#define ast_clear_flag(p, flag)
Definition: utils.h:77
#define ARRAY_LEN(a)
Definition: utils.h:666
#define AST_VECTOR_SIZE(vec)
Get the number of elements in a vector.
Definition: vector.h:609
#define AST_VECTOR_FREE(vec)
Deallocates this vector.
Definition: vector.h:174
#define AST_VECTOR_GET(vec, idx)
Get an element from a vector.
Definition: vector.h:680