Conference Bridge application. More...

#include "asterisk.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include "asterisk/cli.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/lock.h"
#include "asterisk/bridge.h"
#include "asterisk/musiconhold.h"
#include "asterisk/say.h"
#include "asterisk/audiohook.h"
#include "asterisk/astobj2.h"
#include "confbridge/include/confbridge.h"
#include "asterisk/paths.h"
#include "asterisk/manager.h"
#include "asterisk/test.h"
#include "asterisk/stasis.h"
#include "asterisk/stasis_bridges.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/json.h"
#include "asterisk/format_cache.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/stream.h"
#include "asterisk/message.h"

Include dependency graph for app_confbridge.c:

Go to the source code of this file.

Data Structures
struct	async_datastore_data

struct	async_delete_name_rec_task_data

struct	async_playback_task_data

struct	confbridge_hook_data

struct	hangup_data

struct	playback_task_data

Macros
#define	CONFERENCE_BRIDGE_BUCKETS 53

#define	RECORD_FILENAME_INITIAL_SPACE 128

Functions
static void	__reg_module (void)

static void	__unreg_module (void)

static int	action_confbridgekick (struct mansession s, const struct message m)

static int	action_confbridgelist (struct mansession s, const struct message m)

static int	action_confbridgelist_item (struct mansession s, const char id_text, struct confbridge_conference conference, struct confbridge_user user, int waiting)

static int	action_confbridgelistrooms (struct mansession s, const struct message m)

static int	action_confbridgelock (struct mansession s, const struct message m)

static int	action_confbridgemute (struct mansession s, const struct message m)

static int	action_confbridgesetsinglevideosrc (struct mansession s, const struct message m)

static int	action_confbridgestartrecord (struct mansession s, const struct message m)

static int	action_confbridgestoprecord (struct mansession s, const struct message m)

static int	action_confbridgeunlock (struct mansession s, const struct message m)

static int	action_confbridgeunmute (struct mansession s, const struct message m)

static int	action_dialplan_exec (struct ast_bridge_channel bridge_channel, struct conf_menu_action menu_action)

static int	action_kick_last (struct confbridge_conference conference, struct ast_bridge_channel bridge_channel, struct confbridge_user *user)

static int	action_lock_unlock_helper (struct mansession s, const struct message m, int lock)

static int	action_mute_unmute_helper (struct mansession s, const struct message m, int mute)

static int	action_playback (struct ast_bridge_channel bridge_channel, const char playback_file)

static int	action_playback_and_continue (struct confbridge_conference conference, struct confbridge_user user, struct ast_bridge_channel bridge_channel, struct conf_menu menu, const char playback_file, const char cur_dtmf, int *stop_prompts)

static int	action_toggle_binaural (struct confbridge_conference conference, struct confbridge_user user, struct ast_bridge_channel *bridge_channel)

static int	action_toggle_mute (struct confbridge_conference conference, struct confbridge_user user, struct ast_bridge_channel *bridge_channel)

static int	action_toggle_mute_participants (struct confbridge_conference conference, struct confbridge_user user)

static int	alloc_playback_chan (struct confbridge_conference *conference)

static int	announce_user_count (struct confbridge_conference conference, struct confbridge_user user, struct ast_bridge_channel *bridge_channel)
	Announce number of users in the conference bridge to the caller. More...

struct ast_module *	AST_MODULE_SELF_SYM (void)

static struct async_datastore_data *	async_datastore_data_alloc (void)

static void	async_datastore_data_destroy (void *data)

static int	async_delete_name_rec (struct confbridge_conference conference, const char filename)

static int	async_delete_name_rec_task (void *data)
	Delete user's name file asynchronously. More...

static struct async_delete_name_rec_task_data *	async_delete_name_rec_task_data_alloc (struct confbridge_conference conference, const char filename)

static void	async_delete_name_rec_task_data_destroy (struct async_delete_name_rec_task_data *atd)

int	async_play_sound_file (struct confbridge_conference conference, const char filename, struct ast_channel *initiator)
	Play sound file into conference bridge asynchronously. More...

static int	async_play_sound_helper (struct confbridge_conference conference, const char filename, int say_number, struct ast_channel *initiator)

void	async_play_sound_ready (struct ast_channel *chan)
	Indicate the initiator of an async sound file is ready for it to play. More...

static int	async_playback_task (void *data)
	Play an announcement into a confbridge asynchronously. More...

static struct async_playback_task_data *	async_playback_task_data_alloc (struct confbridge_conference conference, const char filename, int say_number, struct ast_channel *initiator)

static void	async_playback_task_data_destroy (struct async_playback_task_data *aptd)

static int	cli_mute_unmute_helper (int mute, struct ast_cli_args *a)

static char *	complete_confbridge_name (const char line, const char word, int pos, int state)

static char *	complete_confbridge_participant (const char conference_name, const char line, const char *word, int pos, int state)

int	conf_add_post_join_action (struct confbridge_user user, int(func)(struct confbridge_user *user))
	Queue a function to run with the given conference bridge user as an argument once the state transition is complete. More...

void	conf_add_user_active (struct confbridge_conference conference, struct confbridge_user user)
	Add a conference bridge user as an unmarked active user of the conference. More...

void	conf_add_user_marked (struct confbridge_conference conference, struct confbridge_user user)
	Add a conference bridge user as a marked active user of the conference. More...

void	conf_add_user_waiting (struct confbridge_conference conference, struct confbridge_user user)
	Add a conference bridge user as an waiting user of the conference. More...

void	conf_ended (struct confbridge_conference *conference)
	Callback to be called when the conference has become empty. More...

struct confbridge_conference *	conf_find_bridge (const char *conference_name)
	Find a confbridge by name. More...

static int	conf_get_pin (struct ast_channel chan, struct confbridge_user user)

const char *	conf_get_sound (enum conf_sounds sound, struct bridge_profile_sounds *custom_sounds)
	Looks to see if sound file is stored in bridge profile sounds, if not default sound is provided. More...

int	conf_handle_dtmf (struct ast_bridge_channel bridge_channel, struct confbridge_user user, struct conf_menu_entry menu_entry, struct conf_menu menu)
	Once a DTMF sequence matches a sequence in the user's DTMF menu, this function will get called to perform the menu action. More...

void	conf_handle_first_join (struct confbridge_conference *conference)
	Callback to execute any time we transition from zero to one active users. More...

int	conf_handle_inactive_waitmarked (struct confbridge_user *user)
	Handle actions every time a waitmarked user joins w/o a marked user present. More...

int	conf_handle_only_person (struct confbridge_user *user)
	Handle actions whenever an user joins an empty conference. More...

void	conf_handle_second_active (struct confbridge_conference *conference)
	Handle when a conference moves to having more than one active participant. More...

static int	conf_handle_talker_cb (struct ast_bridge_channel bridge_channel, void hook_pvt, int talking)

static int	conf_is_recording (struct confbridge_conference *conference)

void	conf_moh_start (struct confbridge_user *user)
	Start MOH for the conference user. More...

void	conf_moh_stop (struct confbridge_user *user)
	Stop MOH for the conference user. More...

static void	conf_moh_suspend (struct confbridge_user *user)

static void	conf_moh_unsuspend (struct confbridge_user *user)

void	conf_mute_only_active (struct confbridge_conference *conference)
	Attempt to mute/play MOH to the only user in the conference if they require it. More...

static int	conf_rec_name (struct confbridge_user user, const char conf_name)

void	conf_remove_user_active (struct confbridge_conference conference, struct confbridge_user user)
	Remove a conference bridge user from the unmarked active conference users in the conference. More...

void	conf_remove_user_marked (struct confbridge_conference conference, struct confbridge_user user)
	Remove a conference bridge user from the marked active conference users in the conference. More...

void	conf_remove_user_waiting (struct confbridge_conference conference, struct confbridge_user user)
	Remove a conference bridge user from the waiting conference users in the conference. More...

static int	conf_start_record (struct confbridge_conference *conference)

static int	conf_stop_record (struct confbridge_conference *conference)

void	conf_update_user_mute (struct confbridge_user *user)
	Update the actual mute status of the user and set it on the bridge. More...

static int	confbridge_exec (struct ast_channel chan, const char data)
	The ConfBridge application. More...

void	confbridge_handle_atxfer (struct ast_attended_transfer_message *msg)
	Create join/leave events for attended transfers. More...

static void	confbridge_unlock_and_unref (void *obj)

static int	conference_bridge_cmp_cb (void obj, void arg, int flags)
	Comparison function used for conference bridges container. More...

static int	conference_bridge_hash_cb (const void *obj, const int flags)
	Hashing function used for conference bridges container. More...

static int	confkick_exec (struct ast_channel chan, const char data)

static void	destroy_conference_bridge (void *obj)
	Destroy a conference bridge. More...

static int	execute_menu_entry (struct confbridge_conference conference, struct confbridge_user user, struct ast_bridge_channel bridge_channel, struct conf_menu_entry menu_entry, struct conf_menu *menu)

static int	func_confbridge_info (struct ast_channel chan, const char cmd, char data, char buf, size_t len)

static int	generic_lock_unlock_helper (int lock, const char *conference_name)

static int	generic_mute_unmute_helper (int mute, const char conference_name, const char chan_name)

static void	generic_mute_unmute_user (struct confbridge_conference conference, struct confbridge_user user, int mute)

static char *	handle_cli_confbridge_kick (struct ast_cli_entry e, int cmd, struct ast_cli_args a)

static char *	handle_cli_confbridge_list (struct ast_cli_entry e, int cmd, struct ast_cli_args a)

static void	handle_cli_confbridge_list_item (struct ast_cli_args a, struct confbridge_user user, int waiting)

static char *	handle_cli_confbridge_lock (struct ast_cli_entry e, int cmd, struct ast_cli_args a)

static char *	handle_cli_confbridge_mute (struct ast_cli_entry e, int cmd, struct ast_cli_args a)

static char *	handle_cli_confbridge_start_record (struct ast_cli_entry e, int cmd, struct ast_cli_args a)

static char *	handle_cli_confbridge_stop_record (struct ast_cli_entry e, int cmd, struct ast_cli_args a)

static char *	handle_cli_confbridge_unlock (struct ast_cli_entry e, int cmd, struct ast_cli_args a)

static char *	handle_cli_confbridge_unmute (struct ast_cli_entry e, int cmd, struct ast_cli_args a)

static int	handle_conf_user_join (struct confbridge_user *user)
	Call the proper join event handler for the user for the conference bridge's current state. More...

static int	handle_conf_user_leave (struct confbridge_user *user)
	Call the proper leave event handler for the user for the conference bridge's current state. More...

static void	handle_video_on_exit (struct confbridge_conference conference, struct ast_channel chan)

static void	handle_video_on_join (struct confbridge_conference conference, struct ast_channel chan, int marked)

static void	hangup_data_destroy (struct hangup_data *hangup)

static void	hangup_data_init (struct hangup_data hangup, struct confbridge_conference conference)

static int	hangup_playback (void *data)
	Hang up the announcer channel. More...

static int	is_new_rec_file (const char rec_file, struct ast_str *orig_rec_file)

static int	join_callback (struct ast_bridge_channel bridge_channel, void ignore)

static struct confbridge_conference *	join_conference_bridge (const char conference_name, struct confbridge_user user)
	Join a conference bridge. More...

static int	kick_conference_participant (struct confbridge_conference conference, const char channel)

static void	leave_conference (struct confbridge_user *user)
	Leave a conference. More...

static int	load_module (void)
	Load the module. More...

static int	play_file (struct ast_bridge_channel bridge_channel, struct ast_channel channel, const char *filename)

static int	play_prompt_to_user (struct confbridge_user user, const char filename)
	Play back an audio file to a channel. More...

int	play_sound_file (struct confbridge_conference conference, const char filename)
	Play sound file into conference bridge. More...

static int	play_sound_helper (struct confbridge_conference conference, const char filename, int say_number)

static int	play_sound_number (struct confbridge_conference *conference, int say_number)
	Play number into the conference bridge. More...

static void	playback_common (struct confbridge_conference conference, const char filename, int say_number)

static int	playback_task (void *data)
	Play an announcement into a confbridge. More...

static void	playback_task_data_destroy (struct playback_task_data *ptd)

static void	playback_task_data_init (struct playback_task_data ptd, struct confbridge_conference conference, const char *filename, int say_number)

static int	push_announcer (struct confbridge_conference *conference)
	Push the announcer channel into the bridge. More...

static int	register_channel_tech (struct ast_channel_tech *tech)

static int	reload (void)

static void	send_conf_end_event (struct confbridge_conference *conference)

static void	send_conf_start_event (struct confbridge_conference *conference)

static void	send_conf_stasis (struct confbridge_conference conference, struct ast_channel chan, struct stasis_message_type type, struct ast_json extras, int channel_topic)

static void	send_conf_stasis_snapshots (struct confbridge_conference conference, struct ast_channel_snapshot chan_snapshot, struct stasis_message_type type, struct ast_json extras)

static int	send_event_hook_callback (struct ast_bridge_channel bridge_channel, void data)

static void	send_join_event (struct confbridge_user user, struct confbridge_conference conference)

static void	send_leave_event (struct confbridge_user user, struct confbridge_conference conference)

static void	send_mute_event (struct confbridge_user user, struct confbridge_conference conference)

static void	send_start_record_event (struct confbridge_conference *conference)

static void	send_stop_record_event (struct confbridge_conference *conference)

static void	send_unmute_event (struct confbridge_user user, struct confbridge_conference conference)

static void	set_rec_filename (struct confbridge_conference conference, struct ast_str *filename, int is_new)

static int	setup_async_playback_datastore (struct ast_channel *initiator)
	Prepare the async playback datastore. More...

static int	sound_file_exists (const char *filename)

static int	unload_module (void)
	Called when module is being unloaded. More...

static void	unregister_channel_tech (struct ast_channel_tech *tech)

static int	user_timeout (struct ast_bridge_channel bridge_channel, void ignore)

static void	wait_for_initiator (struct ast_channel *initiator)
	Wait for the initiator of an async playback to be ready. More...

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Conference Bridge Application" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_DEVSTATE_PROVIDER, .optional_modules = "codec_speex,func_jitterbuffer", }

static const char	app [] = "ConfBridge"

static const char	app2 [] = "ConfKick"

static const struct ast_module_info *	ast_module_info = &__mod_info

static struct ast_datastore_info	async_datastore_info
	Datastore used for timing of async announcement playback. More...

static struct ast_cli_entry	cli_confbridge []

static struct ast_custom_function	confbridge_function

static struct ast_custom_function	confbridge_info_function

struct ao2_container *	conference_bridges
	Container to hold all conference bridges in progress. More...

Detailed Description

Conference Bridge application.

Author

Joshua Colp <[email protected]>

David Vossel <[email protected]>

This is a conference bridge application utilizing the bridging core.

Definition in file app_confbridge.c.

Macro Definition Documentation

◆ CONFERENCE_BRIDGE_BUCKETS

#define CONFERENCE_BRIDGE_BUCKETS 53

Number of buckets our conference bridges container can have

Definition at line 463 of file app_confbridge.c.

Referenced by load_module().

◆ RECORD_FILENAME_INITIAL_SPACE

#define RECORD_FILENAME_INITIAL_SPACE 128

Initial recording filename space.

Definition at line 466 of file app_confbridge.c.

Referenced by is_new_rec_file(), and join_conference_bridge().

Function Documentation

◆ __reg_module()

static void __reg_module ( void )

static

Definition at line 4504 of file app_confbridge.c.

◆ __unreg_module()

static void __unreg_module ( void )

static

Definition at line 4504 of file app_confbridge.c.

◆ action_confbridgekick()

static int action_confbridgekick	(	struct mansession *	s,
		const struct message *	m
	)

static

Definition at line 4037 of file app_confbridge.c.

References ao2_container_count(), ao2_find, ao2_ref, ast_strlen_zero, astman_get_header(), astman_send_ack(), astman_send_error(), hangup_data::conference, kick_conference_participant(), and OBJ_KEY.

Referenced by load_module().

 {
  const char *conference_name = astman_get_header(m, "Conference");
  const char *channel = astman_get_header(m, "Channel");
  struct confbridge_conference *conference;
  int found;
 
  if (ast_strlen_zero(conference_name)) {
  astman_send_error(s, m, "No Conference name provided.");
  return 0;
  }
  if (!ao2_container_count(conference_bridges)) {
  astman_send_error(s, m, "No active conferences.");
  return 0;
  }
 
  conference = ao2_find(conference_bridges, conference_name, OBJ_KEY);
  if (!conference) {
  astman_send_error(s, m, "No Conference by that name found.");
  return 0;
  }
 
  found = !kick_conference_participant(conference, channel);
  ao2_ref(conference, -1);
 
  if (found) {
  astman_send_ack(s, m, !strcmp("all", channel) ? "All participants kicked" : "User kicked");
  } else {
  astman_send_error(s, m, "No Channel by that name found in Conference.");
  }
  return 0;
 }

◆ action_confbridgelist()

static int action_confbridgelist	(	struct mansession *	s,
		const struct message *	m
	)

static

Definition at line 3869 of file app_confbridge.c.

References action_confbridgelist_item(), confbridge_conference::active_list, ao2_container_count(), ao2_find, ao2_lock, ao2_ref, ao2_unlock, AST_LIST_TRAVERSE, ast_strlen_zero, astman_get_header(), astman_send_error(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), hangup_data::conference, OBJ_KEY, total, user, and confbridge_conference::waiting_list.

Referenced by load_module().

 {
  const char *actionid = astman_get_header(m, "ActionID");
  const char *conference_name = astman_get_header(m, "Conference");
  struct confbridge_user *user;
  struct confbridge_conference *conference;
  char id_text[80];
  int total = 0;
 
  id_text[0] = '\0';
  if (!ast_strlen_zero(actionid)) {
  snprintf(id_text, sizeof(id_text), "ActionID: %s\r\n", actionid);
  }
  if (ast_strlen_zero(conference_name)) {
  astman_send_error(s, m, "No Conference name provided.");
  return 0;
  }
  if (!ao2_container_count(conference_bridges)) {
  astman_send_error(s, m, "No active conferences.");
  return 0;
  }
  conference = ao2_find(conference_bridges, conference_name, OBJ_KEY);
  if (!conference) {
  astman_send_error(s, m, "No Conference by that name found.");
  return 0;
  }
 
  astman_send_listack(s, m, "Confbridge user list will follow", "start");
 
  ao2_lock(conference);
  AST_LIST_TRAVERSE(&conference->active_list, user, list) {
  total += action_confbridgelist_item(s, id_text, conference, user, 0);
  }
  AST_LIST_TRAVERSE(&conference->waiting_list, user, list) {
  total += action_confbridgelist_item(s, id_text, conference, user, 1);
  }
  ao2_unlock(conference);
  ao2_ref(conference, -1);
 
  astman_send_list_complete_start(s, m, "ConfbridgeListComplete", total);
  astman_send_list_complete_end(s);
 
  return 0;
 }

◆ action_confbridgelist_item()

static int action_confbridgelist_item	(	struct mansession *	s,
		const char *	id_text,
		struct confbridge_conference *	conference,
		struct confbridge_user *	user,
		int	waiting
	)

static

Definition at line 3821 of file app_confbridge.c.

References ao2_ref, ast_channel_get_up_time(), ast_channel_snapshot_get_latest(), ast_channel_uniqueid(), ast_free, ast_manager_build_channel_state_string(), ast_str_buffer(), ast_test_flag, AST_YESNO, astman_append(), confbridge_user::chan, confbridge_user::muted, confbridge_conference::name, confbridge_user::talking, confbridge_user::u_profile, USER_OPT_ADMIN, USER_OPT_ENDMARKED, USER_OPT_MARKEDUSER, and USER_OPT_WAITMARKED.

Referenced by action_confbridgelist().

 {
  struct ast_channel_snapshot *snapshot;
  struct ast_str *snap_str;
 
  snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(user->chan));
  if (!snapshot) {
  return 0;
  }
 
  snap_str = ast_manager_build_channel_state_string(snapshot);
  if (!snap_str) {
  ao2_ref(snapshot, -1);
  return 0;
  }
 
  astman_append(s,
  "Event: ConfbridgeList\r\n"
  "%s"
  "Conference: %s\r\n"
  "Admin: %s\r\n"
  "MarkedUser: %s\r\n"
  "WaitMarked: %s\r\n"
  "EndMarked: %s\r\n"
  "Waiting: %s\r\n"
  "Muted: %s\r\n"
  "Talking: %s\r\n"
  "AnsweredTime: %d\r\n"
  "%s"
  "\r\n",
  id_text,
  conference->name,
  AST_YESNO(ast_test_flag(&user->u_profile, USER_OPT_ADMIN)),
  AST_YESNO(ast_test_flag(&user->u_profile, USER_OPT_MARKEDUSER)),
  AST_YESNO(ast_test_flag(&user->u_profile, USER_OPT_WAITMARKED)),
  AST_YESNO(ast_test_flag(&user->u_profile, USER_OPT_ENDMARKED)),
  AST_YESNO(waiting),
  AST_YESNO(user->muted),
  AST_YESNO(user->talking),
  ast_channel_get_up_time(user->chan),
  ast_str_buffer(snap_str));
 
  ast_free(snap_str);
  ao2_ref(snapshot, -1);
 
  return 1;
 }

◆ action_confbridgelistrooms()

static int action_confbridgelistrooms	(	struct mansession *	s,
		const struct message *	m
	)

static

Definition at line 3914 of file app_confbridge.c.

References confbridge_conference::activeusers, ao2_container_count(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_strlen_zero, AST_YESNO, astman_append(), astman_get_header(), astman_send_error(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), hangup_data::conference, confbridge_conference::locked, confbridge_conference::markedusers, confbridge_conference::muted, confbridge_conference::name, and confbridge_conference::waitingusers.

Referenced by load_module().

 {
  const char *actionid = astman_get_header(m, "ActionID");
  struct confbridge_conference *conference;
  struct ao2_iterator iter;
  char id_text[512] = "";
  int totalitems = 0;
 
  if (!ast_strlen_zero(actionid)) {
  snprintf(id_text, sizeof(id_text), "ActionID: %s\r\n", actionid);
  }
 
  if (!ao2_container_count(conference_bridges)) {
  astman_send_error(s, m, "No active conferences.");
  return 0;
  }
 
  astman_send_listack(s, m, "Confbridge conferences will follow", "start");
 
  /* Traverse the conference list */
  iter = ao2_iterator_init(conference_bridges, 0);
  while ((conference = ao2_iterator_next(&iter))) {
  totalitems++;
 
  ao2_lock(conference);
  astman_append(s,
  "Event: ConfbridgeListRooms\r\n"
  "%s"
  "Conference: %s\r\n"
  "Parties: %u\r\n"
  "Marked: %u\r\n"
  "Locked: %s\r\n"
  "Muted: %s\r\n"
  "\r\n",
  id_text,
  conference->name,
  conference->activeusers + conference->waitingusers,
  conference->markedusers,
  AST_YESNO(conference->locked),
  AST_YESNO(conference->muted));
  ao2_unlock(conference);
 
  ao2_ref(conference, -1);
  }
  ao2_iterator_destroy(&iter);
 
  /* Send final confirmation */
  astman_send_list_complete_start(s, m, "ConfbridgeListRoomsComplete", totalitems);
  astman_send_list_complete_end(s);
  return 0;
 }

◆ action_confbridgelock()

static int action_confbridgelock	(	struct mansession *	s,
		const struct message *	m
	)

static

Definition at line 4032 of file app_confbridge.c.

References action_lock_unlock_helper().

Referenced by load_module().

 {
  return action_lock_unlock_helper(s, m, 1);
 }

◆ action_confbridgemute()

static int action_confbridgemute	(	struct mansession *	s,
		const struct message *	m
	)

static

Definition at line 4003 of file app_confbridge.c.

References action_mute_unmute_helper().

Referenced by load_module().

 {
  return action_mute_unmute_helper(s, m, 1);
 }

◆ action_confbridgesetsinglevideosrc()

static int action_confbridgesetsinglevideosrc	(	struct mansession *	s,
		const struct message *	m
	)

static

Definition at line 4149 of file app_confbridge.c.

References confbridge_conference::active_list, ao2_container_count(), ao2_find, ao2_lock, ao2_ref, ao2_unlock, ast_bridge_set_single_src_video_mode(), ast_channel_name(), AST_LIST_TRAVERSE, ast_strlen_zero, astman_get_header(), astman_send_ack(), astman_send_error(), confbridge_conference::bridge, confbridge_user::chan, hangup_data::conference, OBJ_KEY, and user.

Referenced by load_module().

 {
  const char *conference_name = astman_get_header(m, "Conference");
  const char *channel = astman_get_header(m, "Channel");
  struct confbridge_user *user;
  struct confbridge_conference *conference;
 
  if (ast_strlen_zero(conference_name)) {
  astman_send_error(s, m, "No Conference name provided.");
  return 0;
  }
  if (ast_strlen_zero(channel)) {
  astman_send_error(s, m, "No channel name provided.");
  return 0;
  }
  if (!ao2_container_count(conference_bridges)) {
  astman_send_error(s, m, "No active conferences.");
  return 0;
  }
 
  conference = ao2_find(conference_bridges, conference_name, OBJ_KEY);
  if (!conference) {
  astman_send_error(s, m, "No Conference by that name found.");
  return 0;
  }
 
  /* find channel and set as video src. */
  ao2_lock(conference);
  AST_LIST_TRAVERSE(&conference->active_list, user, list) {
  if (!strncmp(channel, ast_channel_name(user->chan), strlen(channel))) {
  ast_bridge_set_single_src_video_mode(conference->bridge, user->chan);
  break;
  }
  }
  ao2_unlock(conference);
  ao2_ref(conference, -1);
 
  /* do not access user after conference unlock. We are just
  * using this check to see if it was found or not */
  if (!user) {
  astman_send_error(s, m, "No channel by that name found in conference.");
  return 0;
  }
  astman_send_ack(s, m, "Conference single video source set.");
  return 0;
 }

◆ action_confbridgestartrecord()

static int action_confbridgestartrecord	(	struct mansession *	s,
		const struct message *	m
	)

static

Definition at line 4070 of file app_confbridge.c.

References ao2_container_count(), ao2_find, ao2_lock, ao2_ref, ao2_unlock, ast_copy_string(), ast_strlen_zero, astman_get_header(), astman_send_ack(), astman_send_error(), confbridge_conference::b_profile, conf_is_recording(), conf_start_record(), hangup_data::conference, OBJ_KEY, and bridge_profile::rec_file.

Referenced by load_module().

 {
  const char *conference_name = astman_get_header(m, "Conference");
  const char *recordfile = astman_get_header(m, "RecordFile");
  struct confbridge_conference *conference;
 
  if (ast_strlen_zero(conference_name)) {
  astman_send_error(s, m, "No Conference name provided.");
  return 0;
  }
  if (!ao2_container_count(conference_bridges)) {
  astman_send_error(s, m, "No active conferences.");
  return 0;
  }
 
  conference = ao2_find(conference_bridges, conference_name, OBJ_KEY);
  if (!conference) {
  astman_send_error(s, m, "No Conference by that name found.");
  return 0;
  }
 
  ao2_lock(conference);
  if (conf_is_recording(conference)) {
  astman_send_error(s, m, "Conference is already being recorded.");
  ao2_unlock(conference);
  ao2_ref(conference, -1);
  return 0;
  }
 
  if (!ast_strlen_zero(recordfile)) {
  ast_copy_string(conference->b_profile.rec_file, recordfile, sizeof(conference->b_profile.rec_file));
  }
 
  if (conf_start_record(conference)) {
  astman_send_error(s, m, "Internal error starting conference recording.");
  ao2_unlock(conference);
  ao2_ref(conference, -1);
  return 0;
  }
  ao2_unlock(conference);
 
  ao2_ref(conference, -1);
  astman_send_ack(s, m, "Conference Recording Started.");
  return 0;
 }

◆ action_confbridgestoprecord()

static int action_confbridgestoprecord	(	struct mansession *	s,
		const struct message *	m
	)

static

Definition at line 4115 of file app_confbridge.c.

References ao2_container_count(), ao2_find, ao2_lock, ao2_ref, ao2_unlock, ast_strlen_zero, astman_get_header(), astman_send_ack(), astman_send_error(), conf_stop_record(), hangup_data::conference, and OBJ_KEY.

Referenced by load_module().

 {
  const char *conference_name = astman_get_header(m, "Conference");
  struct confbridge_conference *conference;
 
  if (ast_strlen_zero(conference_name)) {
  astman_send_error(s, m, "No Conference name provided.");
  return 0;
  }
  if (!ao2_container_count(conference_bridges)) {
  astman_send_error(s, m, "No active conferences.");
  return 0;
  }
 
  conference = ao2_find(conference_bridges, conference_name, OBJ_KEY);
  if (!conference) {
  astman_send_error(s, m, "No Conference by that name found.");
  return 0;
  }
 
  ao2_lock(conference);
  if (conf_stop_record(conference)) {
  ao2_unlock(conference);
  astman_send_error(s, m, "Internal error while stopping recording.");
  ao2_ref(conference, -1);
  return 0;
  }
  ao2_unlock(conference);
 
  ao2_ref(conference, -1);
  astman_send_ack(s, m, "Conference Recording Stopped.");
  return 0;
 }

◆ action_confbridgeunlock()

static int action_confbridgeunlock	(	struct mansession *	s,
		const struct message *	m
	)

static

Definition at line 4028 of file app_confbridge.c.

References action_lock_unlock_helper().

Referenced by load_module().

 {
  return action_lock_unlock_helper(s, m, 0);
 }

◆ action_confbridgeunmute()

static int action_confbridgeunmute	(	struct mansession *	s,
		const struct message *	m
	)

static

Definition at line 3999 of file app_confbridge.c.

References action_mute_unmute_helper().

Referenced by load_module().

 {
  return action_mute_unmute_helper(s, m, 0);
 }

◆ action_dialplan_exec()

static int action_dialplan_exec	(	struct ast_bridge_channel *	bridge_channel,
		struct conf_menu_action *	menu_action
	)

static

Definition at line 3059 of file app_confbridge.c.

References ast_channel_context(), ast_channel_context_set(), ast_channel_exten(), ast_channel_exten_set(), ast_channel_lock, ast_channel_pbx(), ast_channel_pbx_set(), ast_channel_priority(), ast_channel_priority_set(), ast_channel_unlock, ast_pbx_run_args(), ast_strdupa, ast_bridge_channel::chan, context, conf_menu_action::data, conf_menu_action::dialplan_args, exten, ast_pbx_args::no_hangup_chan, NULL, and priority.

Referenced by execute_menu_entry().

 {
  struct ast_pbx_args args;
  struct ast_pbx *pbx;
  char *exten;
  char *context;
  int priority;
  int res;
 
  memset(&args, 0, sizeof(args));
  args.no_hangup_chan = 1;
 
  ast_channel_lock(bridge_channel->chan);
 
  /*save off*/
  exten = ast_strdupa(ast_channel_exten(bridge_channel->chan));
  context = ast_strdupa(ast_channel_context(bridge_channel->chan));
  priority = ast_channel_priority(bridge_channel->chan);
  pbx = ast_channel_pbx(bridge_channel->chan);
  ast_channel_pbx_set(bridge_channel->chan, NULL);
 
  /*set new*/
  ast_channel_exten_set(bridge_channel->chan, menu_action->data.dialplan_args.exten);
  ast_channel_context_set(bridge_channel->chan, menu_action->data.dialplan_args.context);
  ast_channel_priority_set(bridge_channel->chan, menu_action->data.dialplan_args.priority);
 
  ast_channel_unlock(bridge_channel->chan);
 
  /*execute*/
  res = ast_pbx_run_args(bridge_channel->chan, &args);
 
  /*restore*/
  ast_channel_lock(bridge_channel->chan);
 
  ast_channel_exten_set(bridge_channel->chan, exten);
  ast_channel_context_set(bridge_channel->chan, context);
  ast_channel_priority_set(bridge_channel->chan, priority);
  ast_channel_pbx_set(bridge_channel->chan, pbx);
 
  ast_channel_unlock(bridge_channel->chan);
 
  return res;
 }

◆ action_kick_last()

static int action_kick_last	(	struct confbridge_conference *	conference,
		struct ast_bridge_channel *	bridge_channel,
		struct confbridge_user *	user
	)

static

Definition at line 3022 of file app_confbridge.c.

References confbridge_conference::active_list, ao2_lock, ao2_unlock, ast_bridge_remove(), ast_channel_name(), AST_LIST_LAST, ast_log, ast_test_flag, confbridge_conference::b_profile, confbridge_conference::bridge, ast_bridge_channel::chan, confbridge_user::chan, conf_get_sound(), CONF_SOUND_ERROR_MENU, confbridge_user::kicked, LOG_WARNING, confbridge_conference::name, NULL, pbx_builtin_setvar_helper(), play_file(), bridge_profile::sounds, confbridge_user::u_profile, and USER_OPT_ADMIN.

Referenced by execute_menu_entry().

 {
  struct confbridge_user *last_user = NULL;
  int isadmin = ast_test_flag(&user->u_profile, USER_OPT_ADMIN);
 
  if (!isadmin) {
  play_file(bridge_channel, NULL,
  conf_get_sound(CONF_SOUND_ERROR_MENU, conference->b_profile.sounds));
  ast_log(LOG_WARNING, "Only admin users can use the kick_last menu action. Channel %s of conf %s is not an admin.\n",
  ast_channel_name(bridge_channel->chan),
  conference->name);
  return -1;
  }
 
  ao2_lock(conference);
  last_user = AST_LIST_LAST(&conference->active_list);
  if (!last_user) {
  ao2_unlock(conference);
  return 0;
  }
 
  if (last_user == user || ast_test_flag(&last_user->u_profile, USER_OPT_ADMIN)) {
  ao2_unlock(conference);
  play_file(bridge_channel, NULL,
  conf_get_sound(CONF_SOUND_ERROR_MENU, conference->b_profile.sounds));
  } else if (!last_user->kicked) {
  last_user->kicked = 1;
  pbx_builtin_setvar_helper(last_user->chan, "CONFBRIDGE_RESULT", "KICKED");
  ast_bridge_remove(conference->bridge, last_user->chan);
  ao2_unlock(conference);
  }
 
  return 0;
 }

◆ action_lock_unlock_helper()

static int action_lock_unlock_helper	(	struct mansession *	s,
		const struct message *	m,
		int	lock
	)

static

Definition at line 4008 of file app_confbridge.c.

References ao2_container_count(), ast_strlen_zero, astman_get_header(), astman_send_ack(), astman_send_error(), and generic_lock_unlock_helper().

Referenced by action_confbridgelock(), and action_confbridgeunlock().

 {
  const char *conference_name = astman_get_header(m, "Conference");
  int res = 0;
 
  if (ast_strlen_zero(conference_name)) {
  astman_send_error(s, m, "No Conference name provided.");
  return 0;
  }
  if (!ao2_container_count(conference_bridges)) {
  astman_send_error(s, m, "No active conferences.");
  return 0;
  }
  if ((res = generic_lock_unlock_helper(lock, conference_name))) {
  astman_send_error(s, m, "No Conference by that name found.");
  return 0;
  }
  astman_send_ack(s, m, lock ? "Conference locked" : "Conference unlocked");
  return 0;
 }

◆ action_mute_unmute_helper()

static int action_mute_unmute_helper	(	struct mansession *	s,
		const struct message *	m,
		int	mute
	)

static

Definition at line 3966 of file app_confbridge.c.

References ao2_container_count(), ast_strlen_zero, astman_get_header(), astman_send_ack(), astman_send_error(), and generic_mute_unmute_helper().

Referenced by action_confbridgemute(), and action_confbridgeunmute().

 {
  const char *conference_name = astman_get_header(m, "Conference");
  const char *channel_name = astman_get_header(m, "Channel");
  int res = 0;
 
  if (ast_strlen_zero(conference_name)) {
  astman_send_error(s, m, "No Conference name provided.");
  return 0;
  }
  if (ast_strlen_zero(channel_name)) {
  astman_send_error(s, m, "No channel name provided.");
  return 0;
  }
  if (!ao2_container_count(conference_bridges)) {
  astman_send_error(s, m, "No active conferences.");
  return 0;
  }
 
  res = generic_mute_unmute_helper(mute, conference_name, channel_name);
 
  if (res == -1) {
  astman_send_error(s, m, "No Conference by that name found.");
  return 0;
  } else if (res == -2) {
  astman_send_error(s, m, "No Channel by that name found in Conference.");
  return 0;
  }
 
  astman_send_ack(s, m, mute ? "User muted" : "User unmuted");
  return 0;
 }

◆ action_playback()

static int action_playback	(	struct ast_bridge_channel *	bridge_channel,
		const char *	playback_file
	)

static

Definition at line 2937 of file app_confbridge.c.

References ast_log, ast_strdupa, ast_stream_and_wait(), ast_bridge_channel::chan, make_ari_stubs::file, LOG_WARNING, NULL, and strsep().

Referenced by execute_menu_entry().

 {
  char *file_copy = ast_strdupa(playback_file);
  char *file = NULL;
 
  while ((file = strsep(&file_copy, "&"))) {
  if (ast_stream_and_wait(bridge_channel->chan, file, "")) {
  ast_log(LOG_WARNING, "Failed to playback file %s to channel\n", file);
  return -1;
  }
  }
  return 0;
 }

◆ action_playback_and_continue()

static int action_playback_and_continue	(	struct confbridge_conference *	conference,
		struct confbridge_user *	user,
		struct ast_bridge_channel *	bridge_channel,
		struct conf_menu *	menu,
		const char *	playback_file,
		const char *	cur_dtmf,
		int *	stop_prompts
	)

static

Definition at line 2951 of file app_confbridge.c.

References ast_channel_language(), ast_copy_string(), AST_DIGIT_ANY, ast_log, ast_stopstream(), ast_strdupa, ast_streamfile(), ast_waitstream(), ast_bridge_channel::chan, conf_find_menu_entry_by_sequence(), conf_menu_entry_destroy(), digit, execute_menu_entry(), make_ari_stubs::file, LOG_WARNING, MAXIMUM_DTMF_FEATURE_STRING, NULL, and strsep().

Referenced by execute_menu_entry().

 {
  int i;
  int digit = 0;
  char dtmf[MAXIMUM_DTMF_FEATURE_STRING];
  struct conf_menu_entry new_menu_entry = { { 0, }, };
  char *file_copy = ast_strdupa(playback_file);
  char *file = NULL;
 
  while ((file = strsep(&file_copy, "&"))) {
  if (ast_streamfile(bridge_channel->chan, file, ast_channel_language(bridge_channel->chan))) {
  ast_log(LOG_WARNING, "Failed to playback file %s to channel\n", file);
  return -1;
  }
 
  /* now wait for more digits. */
  if (!(digit = ast_waitstream(bridge_channel->chan, AST_DIGIT_ANY))) {
  /* streaming finished and no DTMF was entered */
  continue;
  } else if (digit == -1) {
  /* error */
  return -1;
  } else {
  break; /* dtmf was entered */
  }
  }
  if (!digit) {
  /* streaming finished on all files and no DTMF was entered */
  return -1;
  }
  ast_stopstream(bridge_channel->chan);
 
  /* If we get here, then DTMF has been entered, This means no
  * additional prompts should be played for this menu entry */
  *stop_prompts = 1;
 
  /* If a digit was pressed during the payback, update
  * the dtmf string and look for a new menu entry in the
  * menu structure */
  ast_copy_string(dtmf, cur_dtmf, sizeof(dtmf));
  for (i = 0; i < (MAXIMUM_DTMF_FEATURE_STRING - 1); i++) {
  dtmf[i] = cur_dtmf[i];
  if (!dtmf[i]) {
  dtmf[i] = (char) digit;
  dtmf[i + 1] = '\0';
  i = -1;
  break;
  }
  }
  /* If i is not -1 then the new dtmf digit was _NOT_ added to the string.
  * If this is the case, no new DTMF sequence should be looked for. */
  if (i != -1) {
  return 0;
  }
 
  if (conf_find_menu_entry_by_sequence(dtmf, menu, &new_menu_entry)) {
  execute_menu_entry(conference,
  user,
  bridge_channel,
  &new_menu_entry, menu);
  conf_menu_entry_destroy(&new_menu_entry);
  }
  return 0;
 }

◆ action_toggle_binaural()

static int action_toggle_binaural	(	struct confbridge_conference *	conference,
		struct confbridge_user *	user,
		struct ast_bridge_channel *	bridge_channel
	)

static

Definition at line 2881 of file app_confbridge.c.

References ast_bridge_channel_lock_bridge(), ast_bridge_unlock, confbridge_user::b_profile, ast_bridge_channel::binaural_suspended, ast_bridge_channel::bridge, conf_get_sound(), CONF_SOUND_BINAURAL_OFF, CONF_SOUND_BINAURAL_ON, NULL, play_file(), and bridge_profile::sounds.

Referenced by execute_menu_entry().

 {
  unsigned int binaural;
  ast_bridge_channel_lock_bridge(bridge_channel);
  binaural = !bridge_channel->binaural_suspended;
  bridge_channel->binaural_suspended = binaural;
  ast_bridge_unlock(bridge_channel->bridge);
  return play_file(bridge_channel, NULL, (binaural ?
  conf_get_sound(CONF_SOUND_BINAURAL_OFF, user->b_profile.sounds) :
  conf_get_sound(CONF_SOUND_BINAURAL_ON, user->b_profile.sounds))) < 0;
 }

◆ action_toggle_mute()

static int action_toggle_mute	(	struct confbridge_conference *	conference,
		struct confbridge_user *	user,
		struct ast_bridge_channel *	bridge_channel
	)

static

Definition at line 2866 of file app_confbridge.c.

References confbridge_conference::b_profile, conf_get_sound(), CONF_SOUND_MUTED, CONF_SOUND_UNMUTED, generic_mute_unmute_user(), mute, confbridge_user::muted, NULL, play_file(), and bridge_profile::sounds.

Referenced by execute_menu_entry().

 {
  int mute;
 
  /* Toggle user level mute request. */
  mute = !user->muted;
  generic_mute_unmute_user(conference, user, mute);
 
  return play_file(bridge_channel, NULL,
  conf_get_sound(mute ? CONF_SOUND_MUTED : CONF_SOUND_UNMUTED,
  conference->b_profile.sounds)) < 0;
 }

◆ action_toggle_mute_participants()

static int action_toggle_mute_participants	(	struct confbridge_conference *	conference,
		struct confbridge_user *	user
	)

static

Definition at line 2895 of file app_confbridge.c.

References confbridge_conference::active_list, ao2_lock, ao2_unlock, ast_autoservice_start(), ast_autoservice_stop(), ast_channel_language(), AST_LIST_TRAVERSE, ast_stream_and_wait(), ast_test_flag, async_play_sound_file(), confbridge_conference::b_profile, confbridge_user::chan, conf_get_sound(), CONF_SOUND_PARTICIPANTS_MUTED, CONF_SOUND_PARTICIPANTS_UNMUTED, conf_update_user_mute(), bridge_profile::language, confbridge_user::list, mute, confbridge_conference::muted, confbridge_user::muted, NULL, play_sound_file(), bridge_profile::sounds, confbridge_user::u_profile, and USER_OPT_ADMIN.

Referenced by execute_menu_entry().

 {
  struct confbridge_user *cur_user = NULL;
  const char *sound_to_play;
  int mute;
 
  ao2_lock(conference);
 
  /* Toggle bridge level mute request. */
  mute = !conference->muted;
  conference->muted = mute;
 
  AST_LIST_TRAVERSE(&conference->active_list, cur_user, list) {
  if (!ast_test_flag(&cur_user->u_profile, USER_OPT_ADMIN)) {
  /* Set user level to bridge level mute request. */
  cur_user->muted = mute;
  conf_update_user_mute(cur_user);
  }
  }
 
  ao2_unlock(conference);
 
  sound_to_play = conf_get_sound(
  mute ? CONF_SOUND_PARTICIPANTS_MUTED : CONF_SOUND_PARTICIPANTS_UNMUTED,
  conference->b_profile.sounds);
 
  if (strcmp(conference->b_profile.language, ast_channel_language(user->chan))) {
  /* The host needs to hear it seperately, as they don't get the audio from play_sound_helper */
  ast_stream_and_wait(user->chan, sound_to_play, "");
 
  /* Announce to the group that all participants are muted */
  ast_autoservice_start(user->chan);
  play_sound_file(conference, sound_to_play);
  ast_autoservice_stop(user->chan);
  } else {
  /* Playing the sound asynchronously lets the sound be heard by everyone at once */
  async_play_sound_file(conference, sound_to_play, user->chan);
  }
 
  return 0;
 }

◆ alloc_playback_chan()

static int alloc_playback_chan ( struct confbridge_conference * conference )

static

Definition at line 1496 of file app_confbridge.c.

References ao2_ref, ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_debug, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_slin, ast_hangup(), ast_request(), ast_taskprocessor_build_name(), ast_taskprocessor_get(), AST_TASKPROCESSOR_MAX_NAME, confbridge_conference::b_profile, bridge_profile::language, confbridge_conference::name, NULL, confbridge_conference::playback_chan, confbridge_conference::playback_queue, and TPS_REF_DEFAULT.

Referenced by join_conference_bridge().

 {
  struct ast_format_cap *cap;
  char taskprocessor_name[AST_TASKPROCESSOR_MAX_NAME + 1];
 
  cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
  if (!cap) {
  return -1;
  }
  ast_format_cap_append(cap, ast_format_slin, 0);
  conference->playback_chan = ast_request("CBAnn", cap, NULL, NULL,
  conference->name, NULL);
  ao2_ref(cap, -1);
  if (!conference->playback_chan) {
  return -1;
  }
 
  /* To make sure playback_chan has the same language as the bridge */
  ast_channel_lock(conference->playback_chan);
  ast_channel_language_set(conference->playback_chan, conference->b_profile.language);
  ast_channel_unlock(conference->playback_chan);
 
  ast_debug(1, "Created announcer channel '%s' to conference bridge '%s'\n",
  ast_channel_name(conference->playback_chan), conference->name);
 
  ast_taskprocessor_build_name(taskprocessor_name, sizeof(taskprocessor_name),
  "Confbridge/%s", conference->name);
  conference->playback_queue = ast_taskprocessor_get(taskprocessor_name, TPS_REF_DEFAULT);
  if (!conference->playback_queue) {
  ast_hangup(conference->playback_chan);
  conference->playback_chan = NULL;
  return -1;
  }
  return 0;
 }

◆ announce_user_count()

static int announce_user_count	(	struct confbridge_conference *	conference,
		struct confbridge_user *	user,
		struct ast_bridge_channel *	bridge_channel
	)

static

Announce number of users in the conference bridge to the caller.

Parameters

conference	Conference bridge to peek at
user	Optional Caller
bridge_channel	The bridged channel involved

Note: if caller is NULL, the announcment will be sent to all participants in the conference.

Returns: Returns 0 on success, -1 if the user hung up

Definition at line 985 of file app_confbridge.c.

References confbridge_conference::activeusers, ast_channel_language(), ast_say_number(), ast_stream_and_wait(), confbridge_conference::b_profile, confbridge_user::chan, conf_get_sound(), CONF_SOUND_ONLY_ONE, CONF_SOUND_OTHER_IN_PARTY, CONF_SOUND_THERE_ARE, NULL, play_file(), play_sound_file(), play_sound_number(), sound_file_exists(), and bridge_profile::sounds.

Referenced by execute_menu_entry(), and join_conference_bridge().

 {
  const char *other_in_party = conf_get_sound(CONF_SOUND_OTHER_IN_PARTY, conference->b_profile.sounds);
  const char *only_one = conf_get_sound(CONF_SOUND_ONLY_ONE, conference->b_profile.sounds);
  const char *there_are = conf_get_sound(CONF_SOUND_THERE_ARE, conference->b_profile.sounds);
 
  if (conference->activeusers <= 1) {
  /* Awww we are the only person in the conference bridge OR we only have waitmarked users */
  return 0;
  } else if (conference->activeusers == 2) {
  if (user) {
  /* Eep, there is one other person */
  if (play_file(bridge_channel, user->chan, only_one) < 0) {
  return -1;
  }
  } else {
  play_sound_file(conference, only_one);
  }
  } else {
  /* Alas multiple others in here */
  if (user) {
  if (ast_stream_and_wait(user->chan,
  there_are,
  "")) {
  return -1;
  }
  if (ast_say_number(user->chan, conference->activeusers - 1, "", ast_channel_language(user->chan), NULL)) {
  return -1;
  }
  if (play_file(bridge_channel, user->chan, other_in_party) < 0) {
  return -1;
  }
  } else if (sound_file_exists(there_are) && sound_file_exists(other_in_party)) {
  play_sound_file(conference, there_are);
  play_sound_number(conference, conference->activeusers - 1);
  play_sound_file(conference, other_in_party);
  }
  }
  return 0;
 }

◆ AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM ( void )

Definition at line 4504 of file app_confbridge.c.

◆ async_datastore_data_alloc()

static struct async_datastore_data* async_datastore_data_alloc ( void )

static

Definition at line 2085 of file app_confbridge.c.

References ast_cond_init, ast_malloc, ast_mutex_init, async_datastore_data::cond, async_datastore_data::lock, NULL, and async_datastore_data::wait.

Referenced by setup_async_playback_datastore().

 {
  struct async_datastore_data *add;
 
  add = ast_malloc(sizeof(*add));
  if (!add) {
  return NULL;
  }
 
  ast_mutex_init(&add->lock);
  ast_cond_init(&add->cond, NULL);
  add->wait = 1;
 
  return add;
 }

◆ async_datastore_data_destroy()

static void async_datastore_data_destroy ( void * data )

static

Definition at line 2053 of file app_confbridge.c.

References ast_cond_destroy, ast_free, ast_mutex_destroy, async_datastore_data::cond, and async_datastore_data::lock.

 {
  struct async_datastore_data *add = data;
 
  ast_mutex_destroy(&add->lock);
  ast_cond_destroy(&add->cond);
 
  ast_free(add);
 }

◆ async_delete_name_rec()

static int async_delete_name_rec	(	struct confbridge_conference *	conference,
		const char *	filename
	)

static

Definition at line 2492 of file app_confbridge.c.

References ast_log, ast_strlen_zero, ast_taskprocessor_push(), async_delete_name_rec_task(), async_delete_name_rec_task_data_alloc(), async_delete_name_rec_task_data_destroy(), LOG_WARNING, confbridge_conference::name, confbridge_conference::playback_queue, and sound_file_exists().

Referenced by confbridge_exec().

 {
  struct async_delete_name_rec_task_data *atd;
 
  if (ast_strlen_zero(filename)) {
  return 0;
  } else if (!sound_file_exists(filename)) {
  return 0;
  }
 
  atd = async_delete_name_rec_task_data_alloc(conference, filename);
  if (!atd) {
  return -1;
  }
 
  if (ast_taskprocessor_push(conference->playback_queue, async_delete_name_rec_task, atd)) {
  ast_log(LOG_WARNING, "Conference '%s' was unable to remove user name file '%s'\n",
  conference->name, filename);
  async_delete_name_rec_task_data_destroy(atd);
  return -1;
  }
 
  return 0;
 }

◆ async_delete_name_rec_task()

static int async_delete_name_rec_task ( void * data )

static

Delete user's name file asynchronously.

This runs in the playback queue taskprocessor. This ensures that sound file is removed after playback is finished and not before.

Parameters

data	An async_delete_name_rec_task_data

Returns: 0

Definition at line 2480 of file app_confbridge.c.

References ast_filedelete(), ast_log, async_delete_name_rec_task_data_destroy(), async_delete_name_rec_task_data::conference, async_delete_name_rec_task_data::filename, LOG_DEBUG, confbridge_conference::name, and NULL.

Referenced by async_delete_name_rec().

 {
  struct async_delete_name_rec_task_data *atd = data;
 
  ast_filedelete(atd->filename, NULL);
  ast_log(LOG_DEBUG, "Conference '%s' removed user name file '%s'\n",
  atd->conference->name, atd->filename);
 
  async_delete_name_rec_task_data_destroy(atd);
  return 0;
 }

◆ async_delete_name_rec_task_data_alloc()

static struct async_delete_name_rec_task_data* async_delete_name_rec_task_data_alloc	(	struct confbridge_conference *	conference,
		const char *	filename
	)

static

Definition at line 2449 of file app_confbridge.c.

References ast_malloc, hangup_data::conference, async_delete_name_rec_task_data::conference, async_delete_name_rec_task_data::filename, and NULL.

Referenced by async_delete_name_rec().

 {
  struct async_delete_name_rec_task_data *atd;
 
  atd = ast_malloc(sizeof(*atd) + strlen(filename) + 1);
  if (!atd) {
  return NULL;
  }
 
  /* Safe */
  strcpy(atd->filename, filename);
  atd->conference = conference;
 
  return atd;
 }

◆ async_delete_name_rec_task_data_destroy()

static void async_delete_name_rec_task_data_destroy ( struct async_delete_name_rec_task_data * atd )

static

Definition at line 2466 of file app_confbridge.c.

References ast_free.

Referenced by async_delete_name_rec(), and async_delete_name_rec_task().

 {
  ast_free(atd);
 }

◆ async_play_sound_file()

int async_play_sound_file	(	struct confbridge_conference *	conference,
		const char *	filename,
		struct ast_channel *	initiator
	)

Play sound file into conference bridge asynchronously.

If the initiator parameter is non-NULL, then the playback will wait for that initiator channel to get back in the bridge before playing the sound file. This way, the initiator has no danger of hearing a "clipped" file.

Parameters

conference	The conference bridge to play sound file into
filename	Sound file to play
initiator	Channel that initiated playback.

Return values

0	success
-1	failure

Definition at line 2282 of file app_confbridge.c.

References async_play_sound_helper().

Referenced by action_toggle_mute_participants(), confbridge_exec(), and leave_marked().

 {
  return async_play_sound_helper(conference, filename, -1, initiator);
 }

◆ async_play_sound_helper()

static int async_play_sound_helper	(	struct confbridge_conference *	conference,
		const char *	filename,
		int	say_number,
		struct ast_channel *	initiator
	)

static

Definition at line 2248 of file app_confbridge.c.

References ast_log, ast_strlen_zero, ast_taskprocessor_push(), async_playback_task(), async_playback_task_data_alloc(), async_playback_task_data_destroy(), LOG_WARNING, confbridge_conference::name, confbridge_conference::playback_queue, and sound_file_exists().

Referenced by async_play_sound_file().

 {
  struct async_playback_task_data *aptd;
 
  /* Do not waste resources trying to play files that do not exist */
  if (ast_strlen_zero(filename)) {
  if (say_number < 0) {
  return 0;
  }
  } else if (!sound_file_exists(filename)) {
  return 0;
  }
 
  aptd = async_playback_task_data_alloc(conference, filename, say_number, initiator);
  if (!aptd) {
  return -1;
  }
 
  if (ast_taskprocessor_push(conference->playback_queue, async_playback_task, aptd)) {
  if (!ast_strlen_zero(filename)) {
  ast_log(LOG_WARNING, "Unable to play file '%s' to conference '%s'\n",
  filename, conference->name);
  } else {
  ast_log(LOG_WARNING, "Unable to say number '%d' to conference '%s'\n",
  say_number, conference->name);
  }
  async_playback_task_data_destroy(aptd);
  return -1;
  }
 
  return 0;
 }

◆ async_play_sound_ready()

void async_play_sound_ready ( struct ast_channel * chan )

Indicate the initiator of an async sound file is ready for it to play.

When playing an async sound file, the initiator is typically either out of the bridge or not in a position to hear the queued announcement. This function lets the announcement thread know that the initiator is now ready for the sound to play.

If an async announcement was queued and no initiator channel was provided, then this is a no-op

Parameters

chan	The channel that initiated the async announcement

Definition at line 2288 of file app_confbridge.c.

References ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, async_datastore_data::cond, ast_datastore::data, async_datastore_data::lock, NULL, and async_datastore_data::wait.

Referenced by conf_handle_dtmf(), confbridge_exec(), and join_callback().

 {
  struct ast_datastore *async_datastore;
  struct async_datastore_data *add;
 
  ast_channel_lock(chan);
  async_datastore = ast_channel_datastore_find(chan, &async_datastore_info, NULL);
  ast_channel_unlock(chan);
  if (!async_datastore) {
  return;
  }
 
  add = async_datastore->data;
 
  ast_mutex_lock(&add->lock);
  add->wait = 0;
  ast_cond_signal(&add->cond);
  ast_mutex_unlock(&add->lock);
 }

◆ async_playback_task()

static int async_playback_task ( void * data )

static

Play an announcement into a confbridge asynchronously.

This runs in the playback queue taskprocessor. This ensures that all playbacks are handled in sequence and do not play over top one another.

Parameters

data	An async_playback_task_data

Returns: 0

Definition at line 2233 of file app_confbridge.c.

References async_playback_task_data_destroy(), async_playback_task_data::conference, async_playback_task_data::filename, async_playback_task_data::initiator, playback_common(), async_playback_task_data::say_number, and wait_for_initiator().

Referenced by async_play_sound_helper().

 {
  struct async_playback_task_data *aptd = data;
 
  /* Wait for the initiator to get back in the bridge or be hung up */
  if (aptd->initiator) {
  wait_for_initiator(aptd->initiator);
  }
 
  playback_common(aptd->conference, aptd->filename, aptd->say_number);
 
  async_playback_task_data_destroy(aptd);
  return 0;
 }

◆ async_playback_task_data_alloc()

static struct async_playback_task_data* async_playback_task_data_alloc	(	struct confbridge_conference *	conference,
		const char *	filename,
		int	say_number,
		struct ast_channel *	initiator
	)

static

Definition at line 2141 of file app_confbridge.c.

References ast_channel_lock, ast_channel_ref, ast_channel_unlock, ast_malloc, hangup_data::conference, async_playback_task_data::conference, async_playback_task_data::filename, async_playback_task_data::initiator, NULL, async_playback_task_data::say_number, and setup_async_playback_datastore().

Referenced by async_play_sound_helper().

 {
  struct async_playback_task_data *aptd;
 
  aptd = ast_malloc(sizeof(*aptd) + strlen(filename) + 1);
  if (!aptd) {
  return NULL;
  }
 
  /* Safe */
  strcpy(aptd->filename, filename);
  aptd->say_number = say_number;
 
  /* You may think that we need to bump the conference refcount since we are pushing
  * this task to the taskprocessor.
  *
  * In this case, that actually causes a problem. The destructor for the conference
  * pushes a hangup task into the taskprocessor and waits for it to complete before
  * continuing. If the destructor gets called from a taskprocessor task, we're
  * deadlocked.
  *
  * So is there a risk of the conference being freed out from under us? No. Since
  * the destructor pushes a task into the taskprocessor and waits for it to complete,
  * the destructor cannot free the conference out from under us. No further tasks
  * can be queued onto the taskprocessor after the hangup since no channels are referencing
  * the conference at that point any more.
  */
  aptd->conference = conference;
 
  aptd->initiator = initiator;
  if (initiator) {
  ast_channel_ref(initiator);
  ast_channel_lock(aptd->initiator);
  /* We don't really care if this fails. If the datastore fails to get set up
  * we'll still play the announcement. It's possible that the sound will be
  * clipped for the initiator, but that's not the end of the world.
  */
  setup_async_playback_datastore(aptd->initiator);
  ast_channel_unlock(aptd->initiator);
  }
 
  return aptd;
 }

◆ async_playback_task_data_destroy()

static void async_playback_task_data_destroy ( struct async_playback_task_data * aptd )

static

Definition at line 2187 of file app_confbridge.c.

References ast_channel_cleanup, ast_free, and async_playback_task_data::initiator.

Referenced by async_play_sound_helper(), and async_playback_task().

 {
  ast_channel_cleanup(aptd->initiator);
  ast_free(aptd);
 }

◆ cli_mute_unmute_helper()

static int cli_mute_unmute_helper	(	int	mute,
		struct ast_cli_args *	a
	)

static

Definition at line 3574 of file app_confbridge.c.

References ast_cli_args::argv, ast_cli(), ast_cli_args::fd, and generic_mute_unmute_helper().

Referenced by handle_cli_confbridge_mute(), and handle_cli_confbridge_unmute().

 {
  int res = generic_mute_unmute_helper(mute, a->argv[2], a->argv[3]);
 
  if (res == -1) {
  ast_cli(a->fd, "No conference bridge named '%s' found!\n", a->argv[2]);
  return -1;
  } else if (res == -2) {
  if (!strcasecmp("all", a->argv[3]) || !strcasecmp("participants", a->argv[3])) {
  ast_cli(a->fd, "No participants found in conference %s\n", a->argv[2]);
  } else {
  ast_cli(a->fd, "No channel named '%s' found in conference %s\n", a->argv[3], a->argv[2]);
  }
  return -1;
  }
  ast_cli(a->fd, "%s %s from confbridge %s\n", mute ? "Muting" : "Unmuting", a->argv[3], a->argv[2]);
  return 0;
 }

◆ complete_confbridge_name()

static char* complete_confbridge_name	(	const char *	line,
		const char *	word,
		int	pos,
		int	state
	)

static

Definition at line 3280 of file app_confbridge.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_strdup, hangup_data::conference, confbridge_conference::name, and NULL.

Referenced by handle_cli_confbridge_kick(), handle_cli_confbridge_list(), handle_cli_confbridge_lock(), handle_cli_confbridge_mute(), handle_cli_confbridge_start_record(), handle_cli_confbridge_stop_record(), handle_cli_confbridge_unlock(), and handle_cli_confbridge_unmute().

 {
  int which = 0;
  struct confbridge_conference *conference;
  char *res = NULL;
  int wordlen = strlen(word);
  struct ao2_iterator iter;
 
  iter = ao2_iterator_init(conference_bridges, 0);
  while ((conference = ao2_iterator_next(&iter))) {
  if (!strncasecmp(conference->name, word, wordlen) && ++which > state) {
  res = ast_strdup(conference->name);
  ao2_ref(conference, -1);
  break;
  }
  ao2_ref(conference, -1);
  }
  ao2_iterator_destroy(&iter);
 
  return res;
 }

◆ complete_confbridge_participant()

static char* complete_confbridge_participant	(	const char *	conference_name,
		const char *	line,
		const char *	word,
		int	pos,
		int	state
	)

static

Definition at line 3302 of file app_confbridge.c.

References confbridge_conference::active_list, ao2_cleanup, ao2_find, ast_channel_name(), AST_LIST_TRAVERSE, ast_strdup, confbridge_user::chan, hangup_data::conference, confbridge_user::list, NULL, OBJ_KEY, RAII_VAR, SCOPED_AO2LOCK, user, and confbridge_conference::waiting_list.

Referenced by handle_cli_confbridge_kick(), handle_cli_confbridge_mute(), and handle_cli_confbridge_unmute().

 {
  int which = 0;
  RAII_VAR(struct confbridge_conference *, conference, NULL, ao2_cleanup);
  struct confbridge_user *user;
  char *res = NULL;
  int wordlen = strlen(word);
 
  conference = ao2_find(conference_bridges, conference_name, OBJ_KEY);
  if (!conference) {
  return NULL;
  }
 
  if (!strncasecmp("all", word, wordlen) && ++which > state) {
  return ast_strdup("all");
  }
 
  if (!strncasecmp("participants", word, wordlen) && ++which > state) {
  return ast_strdup("participants");
  }
 
  {
  SCOPED_AO2LOCK(bridge_lock, conference);
  AST_LIST_TRAVERSE(&conference->active_list, user, list) {
  if (!strncasecmp(ast_channel_name(user->chan), word, wordlen) && ++which > state) {
  res = ast_strdup(ast_channel_name(user->chan));
  return res;
  }
  }
  AST_LIST_TRAVERSE(&conference->waiting_list, user, list) {
  if (!strncasecmp(ast_channel_name(user->chan), word, wordlen) && ++which > state) {
  res = ast_strdup(ast_channel_name(user->chan));
  return res;
  }
  }
  }
 
  return NULL;
 }

◆ conf_add_post_join_action()

int conf_add_post_join_action	(	struct confbridge_user *	user,
		int()(struct confbridge_user user)	func
	)

Queue a function to run with the given conference bridge user as an argument once the state transition is complete.

Parameters

user	The conference bridge user to pass to the function
func	The function to queue

Return values

0	success
non-zero	failure

Definition at line 1445 of file app_confbridge.c.

References ast_calloc, AST_LIST_INSERT_TAIL, post_join_action::func, post_join_action::list, and confbridge_user::post_join_list.

Referenced by conf_default_join_waitmarked(), join_marked(), join_unmarked(), and transition_to_marked().

 {
  struct post_join_action *action;
  if (!(action = ast_calloc(1, sizeof(*action)))) {
  return -1;
  }
  action->func = func;
  AST_LIST_INSERT_TAIL(&user->post_join_list, action, list);
  return 0;
 }

◆ conf_add_user_active()

void conf_add_user_active	(	struct confbridge_conference *	conference,
		struct confbridge_user *	user
	)

Add a conference bridge user as an unmarked active user of the conference.

Parameters

conference	The conference bridge to add the user to
user	The conference bridge user to add to the conference

Definition at line 4303 of file app_confbridge.c.

References confbridge_conference::active_list, confbridge_conference::activeusers, and AST_LIST_INSERT_TAIL.

Referenced by join_active(), and join_unmarked().

 {
  AST_LIST_INSERT_TAIL(&conference->active_list, user, list);
  conference->activeusers++;
 }

◆ conf_add_user_marked()

void conf_add_user_marked	(	struct confbridge_conference *	conference,
		struct confbridge_user *	user
	)

Add a conference bridge user as a marked active user of the conference.

Parameters

conference	The conference bridge to add the user to
user	The conference bridge user to add to the conference

Definition at line 4309 of file app_confbridge.c.

References confbridge_conference::active_list, confbridge_conference::activeusers, AST_LIST_INSERT_TAIL, and confbridge_conference::markedusers.

Referenced by join_marked().

 {
  AST_LIST_INSERT_TAIL(&conference->active_list, user, list);
  conference->activeusers++;
  conference->markedusers++;
 }

◆ conf_add_user_waiting()

void conf_add_user_waiting	(	struct confbridge_conference *	conference,
		struct confbridge_user *	user
	)

Add a conference bridge user as an waiting user of the conference.

Parameters

conference	The conference bridge to add the user to
user	The conference bridge user to add to the conference

Definition at line 4316 of file app_confbridge.c.

References AST_LIST_INSERT_TAIL, confbridge_conference::waiting_list, and confbridge_conference::waitingusers.

Referenced by conf_default_join_waitmarked().

 {
  AST_LIST_INSERT_TAIL(&conference->waiting_list, user, list);
  conference->waitingusers++;
 }

◆ conf_ended()

void conf_ended ( struct confbridge_conference * conference )

Callback to be called when the conference has become empty.

Parameters

conference The conference bridge

Definition at line 1473 of file app_confbridge.c.

References ao2_lock, ao2_unlink, ao2_unlock, ast_context_remove_extension(), ast_strlen_zero, confbridge_conference::b_profile, conf_stop_record(), E_MATCH, confbridge_conference::name, NULL, pbx_find_extension(), bridge_profile::regcontext, send_conf_end_event(), and pbx_find_info::stacklen.

Referenced by transition_to_empty().

 {
  struct pbx_find_info q = { .stacklen = 0 };
 
  /* Called with a reference to conference */
  ao2_unlink(conference_bridges, conference);
  send_conf_end_event(conference);
  if (!ast_strlen_zero(conference->b_profile.regcontext) &&
  pbx_find_extension(NULL, NULL, &q, conference->b_profile.regcontext,
  conference->name, 1, NULL, "", E_MATCH)) {
  ast_context_remove_extension(conference->b_profile.regcontext,
  conference->name, 1, NULL);
  }
  ao2_lock(conference);
  conf_stop_record(conference);
  ao2_unlock(conference);
 }

◆ conf_find_bridge()

struct confbridge_conference* conf_find_bridge ( const char * conference_name )

Find a confbridge by name.

Since: 13.22.0; 15.5.0

Parameters

confbridge_name The name to search for

Returns: ConfBridge (which must be unreffed) or NULL.

Definition at line 787 of file app_confbridge.c.

References ao2_find, and OBJ_KEY.

Referenced by confbridge_publish_manager_event().

 {
  return ao2_find(conference_bridges, conference_name, OBJ_KEY);
 }

◆ conf_get_pin()

static int conf_get_pin	(	struct ast_channel *	chan,
		struct confbridge_user *	user
	)

static

Definition at line 2350 of file app_confbridge.c.

References ast_app_getdata(), ast_channel_language(), AST_DIGIT_ANY, ast_streamfile(), ast_waitstream(), confbridge_user::b_profile, conf_get_sound(), CONF_SOUND_GET_PIN, CONF_SOUND_INVALID_PIN, len(), MAX_PIN, user_profile::pin, bridge_profile::sounds, tmp(), and confbridge_user::u_profile.

Referenced by confbridge_exec().

 {
  char pin_guess[MAX_PIN+1] = { 0, };
  const char *pin = user->u_profile.pin;
  char *tmp = pin_guess;
  int i, res;
  unsigned int len = MAX_PIN;
 
  /*
  * NOTE: We have not joined a conference yet so we have to use
  * the bridge profile requested by the user.
  */
 
  /* give them three tries to get the pin right */
  for (i = 0; i < 3; i++) {
  if (ast_app_getdata(chan,
  conf_get_sound(CONF_SOUND_GET_PIN, user->b_profile.sounds),
  tmp, len, 0) >= 0) {
  if (!strcasecmp(pin, pin_guess)) {
  return 0;
  }
  }
  ast_streamfile(chan,
  conf_get_sound(CONF_SOUND_INVALID_PIN, user->b_profile.sounds),
  ast_channel_language(chan));
  res = ast_waitstream(chan, AST_DIGIT_ANY);
  if (res > 0) {
  /* Account for digit already read during ivalid pin playback
  * resetting pin buf. */
  pin_guess[0] = res;
  pin_guess[1] = '\0';
  tmp = pin_guess + 1;
  len = MAX_PIN - 1;
  } else {
  /* reset pin buf as empty buffer. */
  tmp = pin_guess;
  len = MAX_PIN;
  }
  }
  return -1;
 }

◆ conf_get_sound()

const char* conf_get_sound	(	enum conf_sounds	sound,
		struct bridge_profile_sounds *	custom_sounds
	)

Looks to see if sound file is stored in bridge profile sounds, if not default sound is provided.

Definition at line 526 of file app_confbridge.c.

Referenced by action_kick_last(), action_toggle_binaural(), action_toggle_mute(), action_toggle_mute_participants(), announce_user_count(), conf_get_pin(), conf_handle_inactive_waitmarked(), conf_handle_only_person(), confbridge_exec(), execute_menu_entry(), handle_cli_confbridge_show_bridge_profile(), join_conference_bridge(), leave_marked(), and post_join_play_begin().

 {
  switch (sound) {
  case CONF_SOUND_HAS_JOINED:
  return S_OR(custom_sounds->hasjoin, "conf-hasjoin");
  case CONF_SOUND_HAS_LEFT:
  return S_OR(custom_sounds->hasleft, "conf-hasleft");
  case CONF_SOUND_KICKED:
  return S_OR(custom_sounds->kicked, "conf-kicked");
  case CONF_SOUND_MUTED:
  return S_OR(custom_sounds->muted, "conf-muted");
  case CONF_SOUND_UNMUTED:
  return S_OR(custom_sounds->unmuted, "conf-unmuted");
  case CONF_SOUND_BINAURAL_ON:
  return S_OR(custom_sounds->binauralon, "confbridge-binaural-on");
  case CONF_SOUND_BINAURAL_OFF:
  return S_OR(custom_sounds->binauraloff, "confbridge-binaural-off");
  case CONF_SOUND_ONLY_ONE:
  return S_OR(custom_sounds->onlyone, "conf-onlyone");
  case CONF_SOUND_THERE_ARE:
  return S_OR(custom_sounds->thereare, "conf-thereare");
  case CONF_SOUND_OTHER_IN_PARTY:
  return S_OR(custom_sounds->otherinparty, "conf-otherinparty");
  case CONF_SOUND_PLACE_IN_CONF:
  return S_OR(custom_sounds->placeintoconf, "conf-placeintoconf");
  case CONF_SOUND_WAIT_FOR_LEADER:
  return S_OR(custom_sounds->waitforleader, "conf-waitforleader");
  case CONF_SOUND_LEADER_HAS_LEFT:
  return S_OR(custom_sounds->leaderhasleft, "conf-leaderhasleft");
  case CONF_SOUND_GET_PIN:
  return S_OR(custom_sounds->getpin, "conf-getpin");
  case CONF_SOUND_INVALID_PIN:
  return S_OR(custom_sounds->invalidpin, "conf-invalidpin");
  case CONF_SOUND_ONLY_PERSON:
  return S_OR(custom_sounds->onlyperson, "conf-onlyperson");
  case CONF_SOUND_LOCKED:
  return S_OR(custom_sounds->locked, "conf-locked");
  case CONF_SOUND_LOCKED_NOW:
  return S_OR(custom_sounds->lockednow, "conf-lockednow");
  case CONF_SOUND_UNLOCKED_NOW:
  return S_OR(custom_sounds->unlockednow, "conf-unlockednow");
  case CONF_SOUND_ERROR_MENU:
  return S_OR(custom_sounds->errormenu, "conf-errormenu");
  case CONF_SOUND_JOIN:
  return S_OR(custom_sounds->join, "confbridge-join");
  case CONF_SOUND_LEAVE:
  return S_OR(custom_sounds->leave, "confbridge-leave");
  case CONF_SOUND_PARTICIPANTS_MUTED:
  return S_OR(custom_sounds->participantsmuted, "conf-now-muted");
  case CONF_SOUND_PARTICIPANTS_UNMUTED:
  return S_OR(custom_sounds->participantsunmuted, "conf-now-unmuted");
  case CONF_SOUND_BEGIN:
  return S_OR(custom_sounds->begin, "confbridge-conf-begin");
  }
 
  return "";
 }

◆ conf_handle_dtmf()

int conf_handle_dtmf	(	struct ast_bridge_channel *	bridge_channel,
		struct confbridge_user *	user,
		struct conf_menu_entry *	menu_entry,
		struct conf_menu *	menu
	)

Once a DTMF sequence matches a sequence in the user's DTMF menu, this function will get called to perform the menu action.

Parameters

bridge_channel	Bridged channel this is involving
user	the conference user to perform the action on.
menu_entry	the menu entry that invoked this callback to occur.
menu	an AO2 referenced pointer to the entire menu structure the menu_entry derived from.

Note: The menu_entry is a deep copy of the entry found in the menu structure. This allows for the menu_entry to be accessed without requiring the menu lock. If the menu must be accessed, the menu lock must be held. Reference counting of the menu structure is handled outside of the scope of this function.

Return values

0	success
-1	failure

Definition at line 3214 of file app_confbridge.c.

References async_play_sound_ready(), ast_bridge_channel::chan, conf_moh_suspend(), conf_moh_unsuspend(), confbridge_user::conference, and execute_menu_entry().

Referenced by menu_hook_callback().

 {
  /* See if music on hold is playing */
  conf_moh_suspend(user);
 
  /* execute the list of actions associated with this menu entry */
  execute_menu_entry(user->conference, user, bridge_channel, menu_entry, menu);
 
  /* See if music on hold needs to be started back up again */
  conf_moh_unsuspend(user);
 
  async_play_sound_ready(bridge_channel->chan);
 
  return 0;
 }

◆ conf_handle_first_join()

void conf_handle_first_join ( struct confbridge_conference * conference )

Callback to execute any time we transition from zero to one active users.

Parameters

conference The conference bridge with a single active user joined

Return values

0	success
-1	failure

Definition at line 1457 of file app_confbridge.c.

References AST_DEVICE_INUSE, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), and confbridge_conference::name.

Referenced by join_marked(), join_unmarked(), and join_waitmarked().

 {
  ast_devstate_changed(AST_DEVICE_INUSE, AST_DEVSTATE_CACHABLE, "confbridge:%s", conference->name);
 }

◆ conf_handle_inactive_waitmarked()

int conf_handle_inactive_waitmarked ( struct confbridge_user * user )

Handle actions every time a waitmarked user joins w/o a marked user present.

Parameters

user	The waitmarked user

Return values

0	success
-1	failure

Definition at line 1421 of file app_confbridge.c.

References ast_test_flag, confbridge_conference::b_profile, conf_get_sound(), CONF_SOUND_WAIT_FOR_LEADER, confbridge_user::conference, play_prompt_to_user(), bridge_profile::sounds, confbridge_user::u_profile, and USER_OPT_QUIET.

Referenced by conf_default_join_waitmarked().

 {
  /* If we have not been quieted play back that they are waiting for the leader */
  if (!ast_test_flag(&user->u_profile, USER_OPT_QUIET) && play_prompt_to_user(user,
  conf_get_sound(CONF_SOUND_WAIT_FOR_LEADER, user->conference->b_profile.sounds))) {
  /* user hungup while the sound was playing */
  return -1;
  }
  return 0;
 }

◆ conf_handle_only_person()

int conf_handle_only_person ( struct confbridge_user * user )

Handle actions whenever an user joins an empty conference.

Parameters

user The user

Definition at line 1432 of file app_confbridge.c.

References ast_test_flag, confbridge_conference::b_profile, conf_get_sound(), CONF_SOUND_ONLY_PERSON, confbridge_user::conference, play_prompt_to_user(), bridge_profile::sounds, confbridge_user::u_profile, USER_OPT_NOONLYPERSON, and USER_OPT_QUIET.

Referenced by join_marked(), and join_unmarked().

 {
  /* If audio prompts have not been quieted or this prompt quieted play it on out */
  if (!ast_test_flag(&user->u_profile, USER_OPT_QUIET | USER_OPT_NOONLYPERSON)) {
  if (play_prompt_to_user(user,
  conf_get_sound(CONF_SOUND_ONLY_PERSON, user->conference->b_profile.sounds))) {
  /* user hungup while the sound was playing */
  return -1;
  }
  }
  return 0;
 }

◆ conf_handle_second_active()

void conf_handle_second_active ( struct confbridge_conference * conference )

Handle when a conference moves to having more than one active participant.

Parameters

conference The conference bridge with more than one active participant

Definition at line 1462 of file app_confbridge.c.

References confbridge_conference::active_list, AST_LIST_FIRST, ast_test_flag, conf_moh_stop(), conf_update_user_mute(), confbridge_user::u_profile, and USER_OPT_MUSICONHOLD.

Referenced by join_active(), join_marked(), and join_unmarked().

 {
  /* If we are the second participant we may need to stop music on hold on the first */
  struct confbridge_user *first_user = AST_LIST_FIRST(&conference->active_list);
 
  if (ast_test_flag(&first_user->u_profile, USER_OPT_MUSICONHOLD)) {
  conf_moh_stop(first_user);
  }
  conf_update_user_mute(first_user);
 }

◆ conf_handle_talker_cb()

static int conf_handle_talker_cb	(	struct ast_bridge_channel *	bridge_channel,
		void *	hook_pvt,
		int	talking
	)

static

Definition at line 2322 of file app_confbridge.c.

References ao2_cleanup, ao2_find, ao2_lock, ao2_unlock, ast_json_pack(), ast_json_unref(), ast_test_flag, ast_bridge_channel::chan, confbridge_talking_type(), confbridge_user::conference, hangup_data::conference, confbridge_conference::name, NULL, OBJ_KEY, RAII_VAR, send_conf_stasis(), confbridge_user::talking, confbridge_user::u_profile, and USER_OPT_ADMIN.

Referenced by confbridge_exec().

 {
  struct confbridge_user *user = hook_pvt;
  RAII_VAR(struct confbridge_conference *, conference, NULL, ao2_cleanup);
  struct ast_json *talking_extras;
 
  conference = ao2_find(conference_bridges, user->conference->name, OBJ_KEY);
  if (!conference) {
  /* Remove the hook since the conference does not exist. */
  return -1;
  }
 
  ao2_lock(conference);
  user->talking = talking;
  ao2_unlock(conference);
 
  talking_extras = ast_json_pack("{s: s, s: b}",
  "talking_status", talking ? "on" : "off",
  "admin", ast_test_flag(&user->u_profile, USER_OPT_ADMIN));
  if (!talking_extras) {
  return 0;
  }
 
  send_conf_stasis(conference, bridge_channel->chan, confbridge_talking_type(), talking_extras, 0);
  ast_json_unref(talking_extras);
  return 0;
 }

◆ conf_is_recording()

static int conf_is_recording ( struct confbridge_conference * conference )

static

Definition at line 803 of file app_confbridge.c.

References NULL, and confbridge_conference::record_chan.

Referenced by action_confbridgestartrecord(), conf_start_record(), conf_stop_record(), and handle_cli_confbridge_start_record().

 {
  return conference->record_chan != NULL;
 }

◆ conf_moh_start()

void conf_moh_start ( struct confbridge_user * user )

Start MOH for the conference user.

Parameters

user	Conference user to start MOH on.

Returns: Nothing

Definition at line 1360 of file app_confbridge.c.

References ast_bridge_lock, ast_bridge_suspend(), ast_bridge_unlock, ast_bridge_unsuspend(), ast_moh_start(), confbridge_conference::bridge, confbridge_user::chan, confbridge_user::conference, user_profile::moh_class, NULL, confbridge_user::playing_moh, confbridge_user::suspended_moh, and confbridge_user::u_profile.

Referenced by conf_mute_moh_inactive_waitmarked(), conf_mute_only_active(), and leave_marked().

 {
  user->playing_moh = 1;
  if (!user->suspended_moh) {
  int in_bridge;
 
  /*
  * Locking the ast_bridge here is the only way to hold off the
  * call to ast_bridge_join() in confbridge_exec() from
  * interfering with the bridge and MOH operations here.
  */
  ast_bridge_lock(user->conference->bridge);
 
  /*
  * Temporarily suspend the user from the bridge so we have
  * control to start MOH if needed.
  */
  in_bridge = !ast_bridge_suspend(user->conference->bridge, user->chan);
  ast_moh_start(user->chan, user->u_profile.moh_class, NULL);
  if (in_bridge) {
  ast_bridge_unsuspend(user->conference->bridge, user->chan);
  }
 
  ast_bridge_unlock(user->conference->bridge);
  }
 }

◆ conf_moh_stop()

void conf_moh_stop ( struct confbridge_user * user )

Stop MOH for the conference user.

Parameters

user	Conference user to stop MOH on.

Returns: Nothing

Definition at line 1333 of file app_confbridge.c.

References ast_bridge_lock, ast_bridge_suspend(), ast_bridge_unlock, ast_bridge_unsuspend(), ast_moh_stop(), confbridge_conference::bridge, confbridge_user::chan, confbridge_user::conference, confbridge_user::playing_moh, and confbridge_user::suspended_moh.

Referenced by conf_default_leave_waitmarked(), conf_handle_second_active(), leave_marked(), leave_unmarked(), and transition_to_marked().

 {
  user->playing_moh = 0;
  if (!user->suspended_moh) {
  int in_bridge;
 
  /*
  * Locking the ast_bridge here is the only way to hold off the
  * call to ast_bridge_join() in confbridge_exec() from
  * interfering with the bridge and MOH operations here.
  */
  ast_bridge_lock(user->conference->bridge);
 
  /*
  * Temporarily suspend the user from the bridge so we have
  * control to stop MOH if needed.
  */
  in_bridge = !ast_bridge_suspend(user->conference->bridge, user->chan);
  ast_moh_stop(user->chan);
  if (in_bridge) {
  ast_bridge_unsuspend(user->conference->bridge, user->chan);
  }
 
  ast_bridge_unlock(user->conference->bridge);
  }
 }

◆ conf_moh_suspend()

static void conf_moh_suspend ( struct confbridge_user * user )

static

Definition at line 1412 of file app_confbridge.c.

References ao2_lock, ao2_unlock, ast_moh_stop(), confbridge_user::chan, confbridge_user::conference, confbridge_user::playing_moh, and confbridge_user::suspended_moh.

Referenced by conf_handle_dtmf().

 {
  ao2_lock(user->conference);
  if (user->suspended_moh++ == 0 && user->playing_moh) {
  ast_moh_stop(user->chan);
  }
  ao2_unlock(user->conference);
 }

◆ conf_moh_unsuspend()

static void conf_moh_unsuspend ( struct confbridge_user * user )

static

Definition at line 1395 of file app_confbridge.c.

References ao2_lock, ao2_unlock, ast_moh_start(), confbridge_user::chan, confbridge_user::conference, user_profile::moh_class, NULL, confbridge_user::playing_moh, confbridge_user::suspended_moh, and confbridge_user::u_profile.

Referenced by conf_handle_dtmf(), and confbridge_exec().

 {
  ao2_lock(user->conference);
  if (--user->suspended_moh == 0 && user->playing_moh) {
  ast_moh_start(user->chan, user->u_profile.moh_class, NULL);
  }
  ao2_unlock(user->conference);
 }

◆ conf_mute_only_active()

void conf_mute_only_active ( struct confbridge_conference * conference )

Attempt to mute/play MOH to the only user in the conference if they require it.

Parameters

conference A conference bridge containing a single user

Definition at line 4335 of file app_confbridge.c.

References confbridge_conference::active_list, AST_LIST_FIRST, ast_test_flag, conf_moh_start(), conf_update_user_mute(), confbridge_user::u_profile, and USER_OPT_MUSICONHOLD.

Referenced by transition_to_single(), and transition_to_single_marked().

 {
  struct confbridge_user *only_user = AST_LIST_FIRST(&conference->active_list);
 
  /* Turn on MOH if the single participant is set up for it */
  if (ast_test_flag(&only_user->u_profile, USER_OPT_MUSICONHOLD)) {
  conf_moh_start(only_user);
  }
  conf_update_user_mute(only_user);
 }

◆ conf_rec_name()

static int conf_rec_name	(	struct confbridge_user *	user,
		const char *	conf_name
	)

static

Definition at line 2399 of file app_confbridge.c.

References ast_channel_uniqueid(), ast_config_AST_SPOOL_DIR, ast_dsp_get_threshold_from_settings(), ast_filedelete(), ast_log, ast_mkdir(), ast_play_and_record(), ast_record_review(), ast_test_flag, confbridge_user::chan, errno, LOG_WARNING, confbridge_user::name_rec_location, NULL, PATH_MAX, THRESHOLD_SILENCE, confbridge_user::u_profile, and USER_OPT_ANNOUNCE_JOIN_LEAVE_REVIEW.

Referenced by confbridge_exec().

 {
  char destdir[PATH_MAX];
  int res;
  int duration = 20;
 
  snprintf(destdir, sizeof(destdir), "%s/confbridge", ast_config_AST_SPOOL_DIR);
 
  if (ast_mkdir(destdir, 0777) != 0) {
  ast_log(LOG_WARNING, "mkdir '%s' failed: %s\n", destdir, strerror(errno));
  return -1;
  }
  snprintf(user->name_rec_location, sizeof(user->name_rec_location),
  "%s/confbridge-name-%s-%s", destdir,
  conf_name, ast_channel_uniqueid(user->chan));
 
  if (!(ast_test_flag(&user->u_profile, USER_OPT_ANNOUNCE_JOIN_LEAVE_REVIEW))) {
  res = ast_play_and_record(user->chan,
  "vm-rec-name",
  user->name_rec_location,
  10,
  "sln",
  &duration,
  NULL,
  ast_dsp_get_threshold_from_settings(THRESHOLD_SILENCE),
  0,
  NULL);
  } else {
  res = ast_record_review(user->chan,
  "vm-rec-name",
  user->name_rec_location,
  10,
  "sln",
  &duration,
  NULL);
  }
 
  if (res == -1) {
  ast_filedelete(user->name_rec_location, NULL);
  user->name_rec_location[0] = '\0';
  return -1;
  }
  return 0;
 }

◆ conf_remove_user_active()

void conf_remove_user_active	(	struct confbridge_conference *	conference,
		struct confbridge_user *	user
	)

Remove a conference bridge user from the unmarked active conference users in the conference.

Parameters

conference	The conference bridge to remove the user from
user	The conference bridge user to remove from the conference

Definition at line 4322 of file app_confbridge.c.

References confbridge_conference::active_list, confbridge_conference::activeusers, and AST_LIST_REMOVE.

Referenced by leave_active(), and leave_unmarked().

 {
  AST_LIST_REMOVE(&conference->active_list, user, list);
  conference->activeusers--;
 }

◆ conf_remove_user_marked()

void conf_remove_user_marked	(	struct confbridge_conference *	conference,
		struct confbridge_user *	user
	)

Remove a conference bridge user from the marked active conference users in the conference.

Parameters

conference	The conference bridge to remove the user from
user	The conference bridge user to remove from the conference

Definition at line 4328 of file app_confbridge.c.

References confbridge_conference::active_list, confbridge_conference::activeusers, AST_LIST_REMOVE, and confbridge_conference::markedusers.

Referenced by leave_marked().

 {
  AST_LIST_REMOVE(&conference->active_list, user, list);
  conference->activeusers--;
  conference->markedusers--;
 }

◆ conf_remove_user_waiting()

void conf_remove_user_waiting	(	struct confbridge_conference *	conference,
		struct confbridge_user *	user
	)

Remove a conference bridge user from the waiting conference users in the conference.

Parameters

conference	The conference bridge to remove the user from
user	The conference bridge user to remove from the conference

Definition at line 4346 of file app_confbridge.c.

References AST_LIST_REMOVE, confbridge_user::list, confbridge_conference::waiting_list, and confbridge_conference::waitingusers.

Referenced by conf_default_leave_waitmarked().

 {
  AST_LIST_REMOVE(&conference->waiting_list, user, list);
  conference->waitingusers--;
 }

◆ conf_start_record()

static int conf_start_record ( struct confbridge_conference * conference )

static

Definition at line 851 of file app_confbridge.c.

References ao2_ref, ast_answer(), AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE, ast_bridge_features_destroy(), ast_bridge_features_new(), ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_INDEPENDENT, ast_channel_ref, ast_channel_unref, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_slin, ast_hangup(), ast_log, ast_request(), ast_set_flag, ast_str_buffer(), ast_test_suite_event_notify, confbridge_conference::b_profile, confbridge_conference::bridge, conf_is_recording(), ast_bridge_features::feature_flags, is_new_rec_file(), LOG_WARNING, bridge_profile::name, confbridge_conference::name, NULL, confbridge_conference::orig_rec_file, pbx_exec(), pbx_findapp(), bridge_profile::rec_file, confbridge_conference::record_chan, confbridge_conference::record_filename, send_start_record_event(), and set_rec_filename().

Referenced by action_confbridgestartrecord(), handle_cli_confbridge_start_record(), and join_conference_bridge().

 {
  struct ast_app *mixmonapp;
  struct ast_channel *chan;
  struct ast_format_cap *cap;
  struct ast_bridge_features *features;
 
  if (conf_is_recording(conference)) {
  return -1;
  }
 
  mixmonapp = pbx_findapp("MixMonitor");
  if (!mixmonapp) {
  ast_log(LOG_WARNING, "Cannot record ConfBridge, MixMonitor app is not installed\n");
  return -1;
  }
 
  features = ast_bridge_features_new();
  if (!features) {
  return -1;
  }
  ast_set_flag(&features->feature_flags, AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE);
 
  cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
  if (!cap) {
  ast_bridge_features_destroy(features);
  return -1;
  }
  ast_format_cap_append(cap, ast_format_slin, 0);
 
  /* Create the recording channel. */
  chan = ast_request("CBRec", cap, NULL, NULL, conference->name, NULL);
  ao2_ref(cap, -1);
  if (!chan) {
  ast_bridge_features_destroy(features);
  return -1;
  }
 
  /* Start recording. */
  set_rec_filename(conference, &conference->record_filename,
  is_new_rec_file(conference->b_profile.rec_file, &conference->orig_rec_file));
  ast_answer(chan);
  pbx_exec(chan, mixmonapp, ast_str_buffer(conference->record_filename));
 
  /* Put the channel into the conference bridge. */
  ast_channel_ref(chan);
  conference->record_chan = chan;
  if (ast_bridge_impart(conference->bridge, chan, NULL, features,
  AST_BRIDGE_IMPART_CHAN_INDEPENDENT)) {
  ast_hangup(chan);
  ast_channel_unref(chan);
  conference->record_chan = NULL;
  return -1;
  }
 
  ast_test_suite_event_notify("CONF_START_RECORD", "Message: started conference recording channel\r\nConference: %s", conference->b_profile.name);
  send_start_record_event(conference);
 
  return 0;
 }

◆ conf_stop_record()

static int conf_stop_record ( struct confbridge_conference * conference )

static

Definition at line 819 of file app_confbridge.c.

References ast_channel_unref, AST_CONTROL_HANGUP, AST_FRAME_CONTROL, ast_queue_frame(), ast_test_suite_event_notify, confbridge_conference::b_profile, conf_is_recording(), bridge_profile::name, NULL, confbridge_conference::record_chan, and send_stop_record_event().

Referenced by action_confbridgestoprecord(), conf_ended(), and handle_cli_confbridge_stop_record().

 {
  struct ast_channel *chan;
  struct ast_frame f = { AST_FRAME_CONTROL, .subclass.integer = AST_CONTROL_HANGUP };
 
  if (!conf_is_recording(conference)) {
  return -1;
  }
 
  /* Remove the recording channel from the conference bridge. */
  chan = conference->record_chan;
  conference->record_chan = NULL;
  ast_queue_frame(chan, &f);
  ast_channel_unref(chan);
 
  ast_test_suite_event_notify("CONF_STOP_RECORD", "Message: stopped conference recording channel\r\nConference: %s", conference->b_profile.name);
  send_stop_record_event(conference);
 
  return 0;
 }

◆ conf_update_user_mute()

void conf_update_user_mute ( struct confbridge_user * user )

Update the actual mute status of the user and set it on the bridge.

Parameters

user	User to update the mute status.

Returns: Nothing

Definition at line 1275 of file app_confbridge.c.

References ast_channel_name(), ast_debug, ast_test_flag, ast_test_suite_event_notify, confbridge_conference::b_profile, confbridge_user::chan, confbridge_user::conference, confbridge_user::features, confbridge_conference::markedusers, ast_bridge_features::mute, confbridge_user::muted, bridge_profile::name, confbridge_user::playing_moh, confbridge_user::u_profile, and USER_OPT_WAITMARKED.

Referenced by action_toggle_mute_participants(), conf_handle_second_active(), conf_mute_moh_inactive_waitmarked(), conf_mute_only_active(), generic_mute_unmute_user(), join_active(), join_marked(), join_unmarked(), leave_marked(), and transition_to_marked().

 {
  int mute_user;
  int mute_system;
  int mute_effective;
 
  /* User level mute request. */
  mute_user = user->muted;
 
  /* System level mute request. */
  mute_system = user->playing_moh
  /*
  * Do not allow waitmarked users to talk to anyone unless there
  * is a marked user present.
  */
  || (!user->conference->markedusers
  && ast_test_flag(&user->u_profile, USER_OPT_WAITMARKED));
 
  mute_effective = mute_user || mute_system;
 
  ast_debug(1, "User %s is %s: user:%d system:%d.\n",
  ast_channel_name(user->chan), mute_effective ? "muted" : "unmuted",
  mute_user, mute_system);
  user->features.mute = mute_effective;
  ast_test_suite_event_notify("CONF_MUTE_UPDATE",
  "Mode: %s\r\n"
  "Conference: %s\r\n"
  "Channel: %s",
  mute_effective ? "muted" : "unmuted",
  user->conference->b_profile.name,
  ast_channel_name(user->chan));
 }

◆ confbridge_exec()

static int confbridge_exec	(	struct ast_channel *	chan,
		const char *	data
	)

static

The ConfBridge application.

Definition at line 2544 of file app_confbridge.c.

References app, args, ast_answer(), AST_APP_ARG, AST_AUDIOHOOK_DIRECTION_READ, AST_AUDIOHOOK_DIRECTION_WRITE, ast_audiohook_volume_get(), ast_audiohook_volume_set(), ast_autoservice_start(), ast_autoservice_stop(), ast_bridge_features_cleanup(), ast_bridge_features_init(), AST_BRIDGE_HOOK_REMOVE_ON_PULL, AST_BRIDGE_HOOK_TYPE_JOIN, AST_BRIDGE_HOOK_TYPE_LEAVE, ast_bridge_interval_hook(), ast_bridge_join(), ast_bridge_join_hook(), ast_bridge_leave_hook(), ast_bridge_talk_detector_hook(), ast_channel_language(), ast_channel_name(), ast_check_hangup(), AST_DECLARE_APP_ARGS, ast_filedelete(), ast_free, ast_free_ptr(), ast_func_write(), ast_log, ast_malloc, ast_shutting_down(), AST_STANDARD_APP_ARGS, AST_STATE_UP, ast_strdupa, ast_stream_and_wait(), ast_strlen_zero, ast_test_flag, async_delete_name_rec(), async_play_sound_file(), async_play_sound_ready(), confbridge_conference::b_profile, confbridge_user::b_profile, confbridge_conference::bridge, confbridge_user::chan, hangup_data::chan, conf_bridge_profile_destroy(), conf_find_bridge_profile(), conf_find_user_profile(), conf_get_pin(), conf_get_sound(), conf_handle_talker_cb(), conf_moh_unsuspend(), conf_rec_name(), conf_set_menu_to_user(), CONF_SOUND_HAS_JOINED, CONF_SOUND_HAS_LEFT, CONF_SOUND_JOIN, CONF_SOUND_KICKED, CONF_SOUND_LEAVE, hangup_data::conference, confbridge_hook_data::conference, DEFAULT_BRIDGE_PROFILE, DEFAULT_MENU_PROFILE, DEFAULT_SILENCE_THRESHOLD, DEFAULT_TALKING_THRESHOLD, DEFAULT_USER_PROFILE, ast_bridge_tech_optimizations::drop_silence, ast_bridge_features::dtmf_passthrough, confbridge_user::features, handle_video_on_exit(), handle_video_on_join(), confbridge_hook_data::hook_type, join_callback(), join_conference_bridge(), confbridge_user::kicked, bridge_profile::language, leave_conference(), LOG_ERROR, LOG_WARNING, MAX_CONF_NAME, confbridge_user::name_rec_location, NULL, parse(), pbx_builtin_setvar_helper(), user_profile::pin, play_sound_file(), quiet, send_event_hook_callback(), ast_bridge_tech_optimizations::silence_threshold, user_profile::silence_threshold, bridge_profile::sounds, ast_bridge_tech_optimizations::talking_threshold, user_profile::talking_threshold, confbridge_user::tech_args, ast_bridge_features::text_messaging, user_profile::timeout, confbridge_user::u_profile, user, confbridge_hook_data::user, USER_OPT_ANNOUNCE_JOIN_LEAVE, USER_OPT_ANNOUNCE_JOIN_LEAVE_REVIEW, USER_OPT_ANSWER_CHANNEL, USER_OPT_DENOISE, USER_OPT_DROP_SILENCE, USER_OPT_DTMF_PASS, USER_OPT_JITTERBUFFER, USER_OPT_MARKEDUSER, USER_OPT_QUIET, USER_OPT_TALKER_DETECT, USER_OPT_TEXT_MESSAGING, and user_timeout().

Referenced by load_module().

 {
  int res = 0, volume_adjustments[2];
  int quiet = 0;
  int async_delete_task_pushed = 0;
  char *parse;
  const char *b_profile_name = NULL;
  const char *u_profile_name = NULL;
  const char *menu_profile_name = NULL;
  struct confbridge_conference *conference = NULL;
  struct confbridge_user user = {
  .chan = chan,
  .tech_args.talking_threshold = DEFAULT_TALKING_THRESHOLD,
  .tech_args.silence_threshold = DEFAULT_SILENCE_THRESHOLD,
  .tech_args.drop_silence = 0,
  };
  struct confbridge_hook_data *join_hook_data;
  struct confbridge_hook_data *leave_hook_data;
 
  AST_DECLARE_APP_ARGS(args,
  AST_APP_ARG(conf_name);
  AST_APP_ARG(b_profile_name);
  AST_APP_ARG(u_profile_name);
  AST_APP_ARG(menu_profile_name);
  );
 
  if (ast_bridge_features_init(&user.features)) {
  pbx_builtin_setvar_helper(chan, "CONFBRIDGE_RESULT", "FAILED");
  res = -1;
  goto confbridge_cleanup;
  }
 
  /* We need to make a copy of the input string if we are going to modify it! */
  parse = ast_strdupa(data);
 
  AST_STANDARD_APP_ARGS(args, parse);
 
  if (ast_strlen_zero(args.conf_name)) {
  pbx_builtin_setvar_helper(chan, "CONFBRIDGE_RESULT", "FAILED");
  ast_log(LOG_WARNING, "%s requires an argument (conference name[,options])\n", app);
  res = -1;
  goto confbridge_cleanup;
  }
 
  if (strlen(args.conf_name) >= MAX_CONF_NAME) {
  pbx_builtin_setvar_helper(chan, "CONFBRIDGE_RESULT", "FAILED");
  ast_log(LOG_WARNING, "%s does not accept conference names longer than %d\n", app, MAX_CONF_NAME - 1);
  res = -1;
  goto confbridge_cleanup;
  }
 
  /* bridge profile name */
  if (args.argc > 1 && !ast_strlen_zero(args.b_profile_name)) {
  b_profile_name = args.b_profile_name;
  }
  if (!conf_find_bridge_profile(chan, b_profile_name, &user.b_profile)) {
  pbx_builtin_setvar_helper(chan, "CONFBRIDGE_RESULT", "FAILED");
  ast_log(LOG_WARNING, "Conference bridge profile %s does not exist\n", b_profile_name ?
  b_profile_name : DEFAULT_BRIDGE_PROFILE);
  res = -1;
  goto confbridge_cleanup;
  }
 
  /* user profile name */
  if (args.argc > 2 && !ast_strlen_zero(args.u_profile_name)) {
  u_profile_name = args.u_profile_name;
  }
  if (!conf_find_user_profile(chan, u_profile_name, &user.u_profile)) {
  pbx_builtin_setvar_helper(chan, "CONFBRIDGE_RESULT", "FAILED");
  ast_log(LOG_WARNING, "Conference user profile %s does not exist\n", u_profile_name ?
  u_profile_name : DEFAULT_USER_PROFILE);
  res = -1;
  goto confbridge_cleanup;
  }
 
  /* If channel hasn't been answered already, answer it, unless we're explicitly not supposed to */
  if ((ast_channel_state(chan) != AST_STATE_UP) && (ast_test_flag(&user.u_profile, USER_OPT_ANSWER_CHANNEL))) {
  ast_answer(chan);
  }
 
  quiet = ast_test_flag(&user.u_profile, USER_OPT_QUIET);
 
  /* ask for a PIN immediately after finding user profile. This has to be
  * prompted for requardless of quiet setting. */
  if (!ast_strlen_zero(user.u_profile.pin)) {
  if (conf_get_pin(chan, &user)) {
  pbx_builtin_setvar_helper(chan, "CONFBRIDGE_RESULT", "FAILED");
  res = -1; /* invalid PIN */
  goto confbridge_cleanup;
  }
  }
 
  /* See if we need them to record a intro name */
  if (!quiet &&
  (ast_test_flag(&user.u_profile, USER_OPT_ANNOUNCE_JOIN_LEAVE) ||
  (ast_test_flag(&user.u_profile, USER_OPT_ANNOUNCE_JOIN_LEAVE_REVIEW)))) {
  if (conf_rec_name(&user, args.conf_name)) {
  pbx_builtin_setvar_helper(chan, "CONFBRIDGE_RESULT", "FAILED");
  res = -1; /* Hangup during name recording */
  goto confbridge_cleanup;
  }
  }
 
  /* menu name */
  if (args.argc > 3 && !ast_strlen_zero(args.menu_profile_name)) {
  menu_profile_name = args.menu_profile_name;
  }
 
  if (conf_set_menu_to_user(chan, &user, menu_profile_name)) {
  pbx_builtin_setvar_helper(chan, "CONFBRIDGE_RESULT", "FAILED");
  ast_log(LOG_WARNING, "Conference menu profile %s does not exist\n", menu_profile_name ?
  menu_profile_name : DEFAULT_MENU_PROFILE);
  res = -1;
  goto confbridge_cleanup;
  }
 
  /* Set if DTMF should pass through for this user or not */
  if (ast_test_flag(&user.u_profile, USER_OPT_DTMF_PASS)) {
  user.features.dtmf_passthrough = 1;
  } else {
  user.features.dtmf_passthrough = 0;
  }
 
  /* Set if text messaging is enabled for this user or not */
  if (ast_test_flag(&user.u_profile, USER_OPT_TEXT_MESSAGING)) {
  user.features.text_messaging = 1;
  } else {
  user.features.text_messaging = 0;
  }
 
  /* Set dsp threshold values if present */
  if (user.u_profile.talking_threshold) {
  user.tech_args.talking_threshold = user.u_profile.talking_threshold;
  }
  if (user.u_profile.silence_threshold) {
  user.tech_args.silence_threshold = user.u_profile.silence_threshold;
  }
 
  /* Set a talker indicate call back if talking detection is requested */
  if (ast_test_flag(&user.u_profile, USER_OPT_TALKER_DETECT)) {
  if (ast_bridge_talk_detector_hook(&user.features, conf_handle_talker_cb,
  &user, NULL, AST_BRIDGE_HOOK_REMOVE_ON_PULL)) {
  pbx_builtin_setvar_helper(chan, "CONFBRIDGE_RESULT", "FAILED");
  res = -1;
  goto confbridge_cleanup;
  }
  }
 
  /* Look for a conference bridge matching the provided name */
  if (!(conference = join_conference_bridge(args.conf_name, &user))) {
  pbx_builtin_setvar_helper(chan, "CONFBRIDGE_RESULT", "FAILED");
  res = -1;
  goto confbridge_cleanup;
  }
 
  /* Keep a copy of volume adjustments so we can restore them later if need be */
  volume_adjustments[0] = ast_audiohook_volume_get(chan, AST_AUDIOHOOK_DIRECTION_READ);
  volume_adjustments[1] = ast_audiohook_volume_get(chan, AST_AUDIOHOOK_DIRECTION_WRITE);
 
  if (ast_test_flag(&user.u_profile, USER_OPT_DROP_SILENCE)) {
  user.tech_args.drop_silence = 1;
  }
 
  if (ast_test_flag(&user.u_profile, USER_OPT_JITTERBUFFER)) {
  ast_func_write(chan, "JITTERBUFFER(adaptive)", "default");
  }
 
  if (ast_test_flag(&user.u_profile, USER_OPT_DENOISE)) {
  ast_func_write(chan, "DENOISE(rx)", "on");
  }
 
  /* if this user has a intro, play it before entering */
  if (!ast_strlen_zero(user.name_rec_location)) {
  ast_autoservice_start(chan);
  play_sound_file(conference, user.name_rec_location);
  play_sound_file(conference,
  conf_get_sound(CONF_SOUND_HAS_JOINED, conference->b_profile.sounds));
  ast_autoservice_stop(chan);
  }
 
  /* Play the Join sound to both the conference and the user entering. */
  if (!quiet) {
  const char *join_sound = conf_get_sound(CONF_SOUND_JOIN, conference->b_profile.sounds);
 
  if (strcmp(conference->b_profile.language, ast_channel_language(chan))) {
  ast_stream_and_wait(chan, join_sound, "");
  ast_autoservice_start(chan);
  play_sound_file(conference, join_sound);
  ast_autoservice_stop(chan);
  } else {
  async_play_sound_file(conference, join_sound, chan);
  }
  }
 
  if (user.u_profile.timeout) {
  ast_bridge_interval_hook(&user.features,
  0,
  user.u_profile.timeout * 1000,
  user_timeout,
  NULL,
  NULL,
  AST_BRIDGE_HOOK_REMOVE_ON_PULL);
  }
 
  /* See if we need to automatically set this user as a video source or not */
  handle_video_on_join(conference, user.chan, ast_test_flag(&user.u_profile, USER_OPT_MARKEDUSER));
 
  conf_moh_unsuspend(&user);
 
  join_hook_data = ast_malloc(sizeof(*join_hook_data));
  if (!join_hook_data) {
  res = -1;
  goto confbridge_cleanup;
  }
  join_hook_data->user = &user;
  join_hook_data->conference = conference;
  join_hook_data->hook_type = AST_BRIDGE_HOOK_TYPE_JOIN;
  res = ast_bridge_join_hook(&user.features, send_event_hook_callback,
  join_hook_data, ast_free_ptr, 0);
  if (res) {
  ast_free(join_hook_data);
  ast_log(LOG_ERROR, "Couldn't add bridge join hook for channel '%s'\n", ast_channel_name(chan));
  goto confbridge_cleanup;
  }
 
  leave_hook_data = ast_malloc(sizeof(*leave_hook_data));
  if (!leave_hook_data) {
  /* join_hook_data is cleaned up by ast_bridge_features_cleanup via the goto */
  res = -1;
  goto confbridge_cleanup;
  }
  leave_hook_data->user = &user;
  leave_hook_data->conference = conference;
  leave_hook_data->hook_type = AST_BRIDGE_HOOK_TYPE_LEAVE;
  res = ast_bridge_leave_hook(&user.features, send_event_hook_callback,
  leave_hook_data, ast_free_ptr, 0);
  if (res) {
  /* join_hook_data is cleaned up by ast_bridge_features_cleanup via the goto */
  ast_free(leave_hook_data);
  ast_log(LOG_ERROR, "Couldn't add bridge leave hook for channel '%s'\n", ast_channel_name(chan));
  goto confbridge_cleanup;
  }
 
  if (ast_bridge_join_hook(&user.features, join_callback, NULL, NULL, 0)) {
  async_play_sound_ready(user.chan);
  }
 
  ast_bridge_join(conference->bridge,
  chan,
  NULL,
  &user.features,
  &user.tech_args,
  0);
 
  /* This is a catch-all in case joining the bridge failed or for some reason
  * an async announcement got queued up and hasn't been told to play yet
  */
  async_play_sound_ready(chan);
 
  if (!user.kicked && ast_check_hangup(chan)) {
  pbx_builtin_setvar_helper(chan, "CONFBRIDGE_RESULT", "HANGUP");
  }
 
  /* if we're shutting down, don't attempt to do further processing */
  if (ast_shutting_down()) {
  /*
  * Not taking any new calls at this time. We cannot create
  * the announcer channel if this is the first channel into
  * the conference and we certainly cannot create any
  * recording channel.
  */
  leave_conference(&user);
  conference = NULL;
  goto confbridge_cleanup;
  }
 
  /* If this user was a video source, we need to clean up and possibly pick a new source. */
  handle_video_on_exit(conference, user.chan);
 
  /* if this user has a intro, play it when leaving */
  if (!quiet && !ast_strlen_zero(user.name_rec_location)) {
  async_play_sound_file(conference, user.name_rec_location, NULL);
  async_play_sound_file(conference,
  conf_get_sound(CONF_SOUND_HAS_LEFT, conference->b_profile.sounds), NULL);
  async_delete_name_rec(conference, user.name_rec_location);
  async_delete_task_pushed = 1;
  }
 
  /* play the leave sound */
  if (!quiet) {
  const char *leave_sound = conf_get_sound(CONF_SOUND_LEAVE, conference->b_profile.sounds);
  async_play_sound_file(conference, leave_sound, NULL);
  }
 
  /* If the user was kicked from the conference play back the audio prompt for it */
  if (!quiet && user.kicked) {
  res = ast_stream_and_wait(chan,
  conf_get_sound(CONF_SOUND_KICKED, conference->b_profile.sounds),
  "");
  }
 
  /* Easy as pie, depart this channel from the conference bridge */
  leave_conference(&user);
  conference = NULL;
 
  /* Restore volume adjustments to previous values in case they were changed */
  if (volume_adjustments[0]) {
  ast_audiohook_volume_set(chan, AST_AUDIOHOOK_DIRECTION_READ, volume_adjustments[0]);
  }
  if (volume_adjustments[1]) {
  ast_audiohook_volume_set(chan, AST_AUDIOHOOK_DIRECTION_WRITE, volume_adjustments[1]);
  }
 
 confbridge_cleanup:
  if (!async_delete_task_pushed && !ast_strlen_zero(user.name_rec_location)) {
  ast_filedelete(user.name_rec_location, NULL);
  }
  ast_bridge_features_cleanup(&user.features);
  conf_bridge_profile_destroy(&user.b_profile);
  return res;
 }

◆ confbridge_handle_atxfer()

void confbridge_handle_atxfer ( struct ast_attended_transfer_message * msg )

Create join/leave events for attended transfers.

Since: 13.28; 16.5

Parameters

msg	The attended transfer stasis message

Definition at line 1562 of file app_confbridge.c.

References confbridge_conference::active_list, ao2_find, ao2_lock, ast_channel_snapshot_dialplan::appl, ast_channel_name(), ast_debug, ast_json_pack(), ast_json_unref(), AST_LIST_TRAVERSE, ast_log, ast_strdupa, ast_strlen_zero, ast_test_flag, ast_channel_snapshot::base, confbridge_user::chan, ast_bridge_channel_snapshot_pair::channel_snapshot, confbridge_join_type(), confbridge_leave_type(), confbridge_unlock_and_unref(), hangup_data::conference, ast_channel_snapshot_dialplan::data, ast_channel_snapshot::dialplan, LOG_ERROR, confbridge_user::muted, ast_channel_snapshot_base::name, NULL, OBJ_SEARCH_KEY, RAII_VAR, send_conf_stasis_snapshots(), ast_attended_transfer_message::target, ast_attended_transfer_message::to_transfer_target, ast_attended_transfer_message::to_transferee, ast_attended_transfer_message::transferee, confbridge_user::u_profile, USER_OPT_ADMIN, confbridge_conference::waiting_list, and confbridge_conference::waitingusers.

Referenced by confbridge_atxfer_cb().

 {
  struct ast_channel_snapshot *old_snapshot;
  struct ast_channel_snapshot *new_snapshot;
  char *confbr_name = NULL;
  char *comma;
  RAII_VAR(struct confbridge_conference *, conference, NULL, confbridge_unlock_and_unref);
  struct confbridge_user *user = NULL;
  int found_user = 0;
  struct ast_json *json_object;
 
  if (msg->to_transferee.channel_snapshot
  && strcmp(msg->to_transferee.channel_snapshot->dialplan->appl, "ConfBridge") == 0
  && msg->target) {
  /* We're transferring a bridge to an extension */
  old_snapshot = msg->to_transferee.channel_snapshot;
  new_snapshot = msg->target;
  } else if (msg->to_transfer_target.channel_snapshot
  && strcmp(msg->to_transfer_target.channel_snapshot->dialplan->appl, "ConfBridge") == 0
  && msg->transferee) {
  /* We're transferring a call to a bridge */
  old_snapshot = msg->to_transfer_target.channel_snapshot;
  new_snapshot = msg->transferee;
  } else {
  ast_log(LOG_ERROR, "Could not determine proper channels\n");
  return;
  }
 
  /*
  * old_snapshot->data should have the original parameters passed to
  * the ConfBridge app:
  * conference[,bridge_profile[,user_profile[,menu]]]
  * We'll use "conference" to look up the bridge.
  *
  * We _could_ use old_snapshot->bridgeid to get the bridge but
  * that would involve locking the conference_bridges container
  * and iterating over it looking for a matching bridge.
  */
  if (ast_strlen_zero(old_snapshot->dialplan->data)) {
  ast_log(LOG_ERROR, "Channel '%s' didn't have app data set\n", old_snapshot->base->name);
  return;
  }
  confbr_name = ast_strdupa(old_snapshot->dialplan->data);
  comma = strchr(confbr_name, ',');
  if (comma) {
  *comma = '\0';
  }
 
  ast_debug(1, "Confbr: %s Leaving: %s Joining: %s\n", confbr_name, old_snapshot->base->name, new_snapshot->base->name);
 
  conference = ao2_find(conference_bridges, confbr_name, OBJ_SEARCH_KEY);
  if (!conference) {
  ast_log(LOG_ERROR, "Conference bridge '%s' not found\n", confbr_name);
  return;
  }
  ao2_lock(conference);
 
  /*
  * We need to grab the user profile for the departing user in order to
  * properly format the join/leave messages.
  */
  AST_LIST_TRAVERSE(&conference->active_list, user, list) {
  if (strcasecmp(ast_channel_name(user->chan), old_snapshot->base->name) == 0) {
  found_user = 1;
  break;
  }
  }
 
  /*
  * If we didn't find the user in the active list, try the waiting list.
  */
  if (!found_user && conference->waitingusers) {
  AST_LIST_TRAVERSE(&conference->waiting_list, user, list) {
  if (strcasecmp(ast_channel_name(user->chan), old_snapshot->base->name) == 0) {
  found_user = 1;
  break;
  }
  }
  }
 
  if (!found_user) {
  ast_log(LOG_ERROR, "Unable to find user profile for channel '%s' in bridge '%s'\n",
  old_snapshot->base->name, confbr_name);
  return;
  }
 
  /*
  * We're going to use the existing user profile to create the messages.
  */
  json_object = ast_json_pack("{s: b}",
  "admin", ast_test_flag(&user->u_profile, USER_OPT_ADMIN)
  );
  if (!json_object) {
  return;
  }
 
  send_conf_stasis_snapshots(conference, old_snapshot, confbridge_leave_type(), json_object);
  ast_json_unref(json_object);
 
  json_object = ast_json_pack("{s: b, s: b}",
  "admin", ast_test_flag(&user->u_profile, USER_OPT_ADMIN),
  "muted", user->muted);
  if (!json_object) {
  return;
  }
  send_conf_stasis_snapshots(conference, new_snapshot, confbridge_join_type(), json_object);
  ast_json_unref(json_object);
 }

◆ confbridge_unlock_and_unref()

static void confbridge_unlock_and_unref ( void * obj )

static

Definition at line 1551 of file app_confbridge.c.

References ao2_ref, ao2_unlock, and hangup_data::conference.

Referenced by confbridge_handle_atxfer().

 {
  struct confbridge_conference *conference = obj;
 
  if (!obj) {
  return;
  }
  ao2_unlock(conference);
  ao2_ref(conference, -1);
 }

◆ conference_bridge_cmp_cb()

static int conference_bridge_cmp_cb	(	void *	obj,
		void *	arg,
		int	flags
	)

static

Comparison function used for conference bridges container.

Definition at line 504 of file app_confbridge.c.

References CMP_MATCH, confbridge_conference::name, OBJ_KEY, OBJ_PARTIAL_KEY, and OBJ_POINTER.

Referenced by load_module().

 {
  const struct confbridge_conference *left = obj;
  const struct confbridge_conference *right = arg;
  const char *right_name = arg;
  int cmp;
 
  switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
  default:
  case OBJ_POINTER:
  right_name = right->name;
  /* Fall through */
  case OBJ_KEY:
  cmp = strcasecmp(left->name, right_name);
  break;
  case OBJ_PARTIAL_KEY:
  cmp = strncasecmp(left->name, right_name, strlen(right_name));
  break;
  }
  return cmp ? 0 : CMP_MATCH;
 }

◆ conference_bridge_hash_cb()

static int conference_bridge_hash_cb	(	const void *	obj,
		const int	flags
	)

static

Hashing function used for conference bridges container.

Definition at line 480 of file app_confbridge.c.

References ast_assert, ast_str_case_hash(), name, confbridge_conference::name, OBJ_KEY, OBJ_PARTIAL_KEY, and OBJ_POINTER.

Referenced by load_module().

 {
  const struct confbridge_conference *conference = obj;
  const char *name = obj;
  int hash;
 
  switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
  default:
  case OBJ_POINTER:
  name = conference->name;
  /* Fall through */
  case OBJ_KEY:
  hash = ast_str_case_hash(name);
  break;
  case OBJ_PARTIAL_KEY:
  /* Should never happen in hash callback. */
  ast_assert(0);
  hash = 0;
  break;
  }
  return hash;
 }

◆ confkick_exec()

static int confkick_exec	(	struct ast_channel *	chan,
		const char *	data
	)

static

Definition at line 4256 of file app_confbridge.c.

References ao2_find, ao2_ref, args, AST_APP_ARG, ast_debug, AST_DECLARE_APP_ARGS, ast_log, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero, hangup_data::conference, kick_conference_participant(), LOG_WARNING, OBJ_KEY, parse(), and pbx_builtin_setvar_helper().

Referenced by load_module().

 {
  char *parse;
  struct confbridge_conference *conference;
  int not_found;
 
  AST_DECLARE_APP_ARGS(args,
  AST_APP_ARG(confbridge);
  AST_APP_ARG(channel);
  );
 
  if (ast_strlen_zero(data)) {
  ast_log(LOG_WARNING, "No conference bridge specified.\n");
  pbx_builtin_setvar_helper(chan, "CONFKICKSTATUS", "FAILURE");
  return 0;
  }
 
  parse = ast_strdupa(data);
  AST_STANDARD_APP_ARGS(args, parse);
 
  conference = ao2_find(conference_bridges, args.confbridge, OBJ_KEY);
  if (!conference) {
  ast_log(LOG_WARNING, "No conference bridge named '%s' found!\n", args.confbridge);
  pbx_builtin_setvar_helper(chan, "CONFKICKSTATUS", "FAILURE");
  return 0;
  }
  if (ast_strlen_zero(args.channel)) {
  not_found = kick_conference_participant(conference, "all");
  } else {
  not_found = kick_conference_participant(conference, args.channel);
  }
 
  ao2_ref(conference, -1);
  if (not_found) {
  if (ast_strlen_zero(args.channel) || !strcasecmp("all", args.channel) || !strcasecmp("participants", args.channel)) {
  ast_log(LOG_WARNING, "No participants found in conference bridge '%s'!\n", args.confbridge);
  } else {
  ast_log(LOG_WARNING, "No participant named '%s' found in conference bridge '%s'!\n", args.channel, args.confbridge);
  }
  pbx_builtin_setvar_helper(chan, "CONFKICKSTATUS", "FAILURE");
  return 0;
  }
  ast_debug(1, "Kicked '%s' out of conference '%s'\n", args.channel, args.confbridge);
  pbx_builtin_setvar_helper(chan, "CONFKICKSTATUS", "SUCCESS");
  return 0;
 }

◆ destroy_conference_bridge()

static void destroy_conference_bridge ( void * obj )

static

Destroy a conference bridge.

Parameters

obj	The conference bridge object

Returns: Returns nothing

Definition at line 1173 of file app_confbridge.c.

Referenced by join_conference_bridge().

 {
  struct confbridge_conference *conference = obj;
 
  ast_debug(1, "Destroying conference bridge '%s'\n", conference->name);
 
  if (conference->playback_chan) {
  if (conference->playback_queue) {
  struct hangup_data hangup;
  hangup_data_init(&hangup, conference);
 
  if (!ast_taskprocessor_push(conference->playback_queue, hangup_playback, &hangup)) {
  ast_mutex_lock(&hangup.lock);
  while (!hangup.hungup) {
  ast_cond_wait(&hangup.cond, &hangup.lock);
  }
  ast_mutex_unlock(&hangup.lock);
  }
 
  hangup_data_destroy(&hangup);
  } else {
  /* Playback queue is not yet allocated. Just hang up the channel straight */
  ast_hangup(conference->playback_chan);
  conference->playback_chan = NULL;
  }
  }
 
  /* Destroying a conference bridge is simple, all we have to do is destroy the bridging object */
  if (conference->bridge) {
  ast_bridge_destroy(conference->bridge, 0);
  conference->bridge = NULL;
  }
 
  ast_channel_cleanup(conference->record_chan);
  ast_free(conference->orig_rec_file);
  ast_free(conference->record_filename);
 
  conf_bridge_profile_destroy(&conference->b_profile);
  ast_taskprocessor_unreference(conference->playback_queue);
 }

◆ execute_menu_entry()

static int execute_menu_entry	(	struct confbridge_conference *	conference,
		struct confbridge_user *	user,
		struct ast_bridge_channel *	bridge_channel,
		struct conf_menu_entry *	menu_entry,
		struct conf_menu *	menu
	)

static

Definition at line 3103 of file app_confbridge.c.

References conf_menu_action::action, action_dialplan_exec(), action_kick_last(), action_playback(), action_playback_and_continue(), action_toggle_binaural(), action_toggle_mute(), action_toggle_mute_participants(), conf_menu_entry::actions, announce_user_count(), ao2_lock, ao2_unlock, AST_AUDIOHOOK_DIRECTION_READ, AST_AUDIOHOOK_DIRECTION_WRITE, ast_audiohook_volume_adjust(), ast_audiohook_volume_set(), ast_bridge_remove(), ast_bridge_set_single_src_video_mode(), ast_channel_name(), AST_LIST_TRAVERSE, ast_test_flag, ast_test_suite_event_notify, confbridge_conference::b_profile, confbridge_conference::bridge, BRIDGE_OPT_VIDEO_SRC_SFU, ast_bridge_channel::chan, confbridge_user::chan, conf_get_sound(), CONF_SOUND_LOCKED_NOW, CONF_SOUND_UNLOCKED_NOW, conf_menu_action::data, conf_menu_entry::dtmf, handle_video_on_exit(), conf_menu_action::id, confbridge_conference::locked, MENU_ACTION_ADMIN_KICK_LAST, MENU_ACTION_ADMIN_TOGGLE_LOCK, MENU_ACTION_ADMIN_TOGGLE_MUTE_PARTICIPANTS, MENU_ACTION_DECREASE_LISTENING, MENU_ACTION_DECREASE_TALKING, MENU_ACTION_DIALPLAN_EXEC, MENU_ACTION_INCREASE_LISTENING, MENU_ACTION_INCREASE_TALKING, MENU_ACTION_LEAVE, MENU_ACTION_NOOP, MENU_ACTION_PARTICIPANT_COUNT, MENU_ACTION_PLAYBACK, MENU_ACTION_PLAYBACK_AND_CONTINUE, MENU_ACTION_RELEASE_SINGLE_VIDEO_SRC, MENU_ACTION_RESET_LISTENING, MENU_ACTION_RESET_TALKING, MENU_ACTION_SET_SINGLE_VIDEO_SRC, MENU_ACTION_TOGGLE_BINAURAL, MENU_ACTION_TOGGLE_MUTE, NULL, pbx_builtin_setvar_helper(), play_file(), conf_menu_action::playback_file, bridge_profile::sounds, confbridge_user::u_profile, and USER_OPT_ADMIN.

Referenced by action_playback_and_continue(), and conf_handle_dtmf().

 {
  struct conf_menu_action *menu_action;
  int isadmin = ast_test_flag(&user->u_profile, USER_OPT_ADMIN);
  int stop_prompts = 0;
  int res = 0;
 
  AST_LIST_TRAVERSE(&menu_entry->actions, menu_action, action) {
  switch (menu_action->id) {
  case MENU_ACTION_TOGGLE_MUTE:
  res |= action_toggle_mute(conference, user, bridge_channel);
  break;
  case MENU_ACTION_TOGGLE_BINAURAL:
  action_toggle_binaural(conference, user, bridge_channel);
  break;
  case MENU_ACTION_ADMIN_TOGGLE_MUTE_PARTICIPANTS:
  if (!isadmin) {
  break;
  }
  action_toggle_mute_participants(conference, user);
  break;
  case MENU_ACTION_PARTICIPANT_COUNT:
  announce_user_count(conference, user, bridge_channel);
  break;
  case MENU_ACTION_PLAYBACK:
  if (!stop_prompts) {
  res |= action_playback(bridge_channel, menu_action->data.playback_file);
  ast_test_suite_event_notify("CONF_MENU_PLAYBACK",
  "Message: %s\r\nChannel: %s",
  menu_action->data.playback_file, ast_channel_name(bridge_channel->chan));
  }
  break;
  case MENU_ACTION_RESET_LISTENING:
  ast_audiohook_volume_set(user->chan, AST_AUDIOHOOK_DIRECTION_WRITE, 0);
  break;
  case MENU_ACTION_RESET_TALKING:
  ast_audiohook_volume_set(user->chan, AST_AUDIOHOOK_DIRECTION_READ, 0);
  break;
  case MENU_ACTION_INCREASE_LISTENING:
  ast_audiohook_volume_adjust(user->chan,
  AST_AUDIOHOOK_DIRECTION_WRITE, 1);
  break;
  case MENU_ACTION_DECREASE_LISTENING:
  ast_audiohook_volume_adjust(user->chan,
  AST_AUDIOHOOK_DIRECTION_WRITE, -1);
  break;
  case MENU_ACTION_INCREASE_TALKING:
  ast_audiohook_volume_adjust(user->chan,
  AST_AUDIOHOOK_DIRECTION_READ, 1);
  break;
  case MENU_ACTION_DECREASE_TALKING:
  ast_audiohook_volume_adjust(user->chan,
  AST_AUDIOHOOK_DIRECTION_READ, -1);
  break;
  case MENU_ACTION_PLAYBACK_AND_CONTINUE:
  if (!(stop_prompts)) {
  res |= action_playback_and_continue(conference,
  user,
  bridge_channel,
  menu,
  menu_action->data.playback_file,
  menu_entry->dtmf,
  &stop_prompts);
  }
  break;
  case MENU_ACTION_DIALPLAN_EXEC:
  res |= action_dialplan_exec(bridge_channel, menu_action);
  break;
  case MENU_ACTION_ADMIN_TOGGLE_LOCK:
  if (!isadmin) {
  break;
  }
  conference->locked = (!conference->locked ? 1 : 0);
  res |= play_file(bridge_channel, NULL,
  conf_get_sound(
  conference->locked ? CONF_SOUND_LOCKED_NOW : CONF_SOUND_UNLOCKED_NOW,
  conference->b_profile.sounds)) < 0;
  break;
  case MENU_ACTION_ADMIN_KICK_LAST:
  res |= action_kick_last(conference, bridge_channel, user);
  break;
  case MENU_ACTION_LEAVE:
  pbx_builtin_setvar_helper(bridge_channel->chan, "CONFBRIDGE_RESULT", "DTMF");
  ao2_lock(conference);
  ast_bridge_remove(conference->bridge, bridge_channel->chan);
  ast_test_suite_event_notify("CONF_MENU_LEAVE",
  "Channel: %s",
  ast_channel_name(bridge_channel->chan));
  ao2_unlock(conference);
  break;
  case MENU_ACTION_NOOP:
  break;
  case MENU_ACTION_SET_SINGLE_VIDEO_SRC:
  ao2_lock(conference);
  if (!ast_test_flag(&conference->b_profile, BRIDGE_OPT_VIDEO_SRC_SFU)) {
  ast_bridge_set_single_src_video_mode(conference->bridge, bridge_channel->chan);
  }
  ao2_unlock(conference);
  break;
  case MENU_ACTION_RELEASE_SINGLE_VIDEO_SRC:
  handle_video_on_exit(conference, bridge_channel->chan);
  break;
  }
  }
  return res;
 }

◆ func_confbridge_info()

static int func_confbridge_info	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	len
	)

static

Definition at line 4196 of file app_confbridge.c.

References confbridge_conference::active_list, ao2_find, ao2_lock, ao2_ref, ao2_unlock, args, AST_APP_ARG, AST_DECLARE_APP_ARGS, AST_LIST_TRAVERSE, ast_log, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero, ast_test_flag, hangup_data::conference, confbridge_user::list, confbridge_conference::locked, LOG_ERROR, confbridge_conference::muted, OBJ_KEY, parse(), type, confbridge_user::u_profile, user, USER_OPT_ADMIN, USER_OPT_MARKEDUSER, and confbridge_conference::waiting_list.

 {
  char *parse;
  struct confbridge_conference *conference;
  struct confbridge_user *user;
  int count = 0;
  AST_DECLARE_APP_ARGS(args,
  AST_APP_ARG(type);
  AST_APP_ARG(confno);
  );
 
  /* parse all the required arguments and make sure they exist. */
  if (ast_strlen_zero(data)) {
  return -1;
  }
  parse = ast_strdupa(data);
  AST_STANDARD_APP_ARGS(args, parse);
  if (ast_strlen_zero(args.confno) || ast_strlen_zero(args.type)) {
  return -1;
  }
  conference = ao2_find(conference_bridges, args.confno, OBJ_KEY);
  if (!conference) {
  snprintf(buf, len, "0");
  return 0;
  }
 
  /* get the correct count for the type requested */
  ao2_lock(conference);
  if (!strcasecmp(args.type, "parties")) {
  AST_LIST_TRAVERSE(&conference->active_list, user, list) {
  count++;
  }
  AST_LIST_TRAVERSE(&conference->waiting_list, user, list) {
  count++;
  }
  } else if (!strcasecmp(args.type, "admins")) {
  AST_LIST_TRAVERSE(&conference->active_list, user, list) {
  if (ast_test_flag(&user->u_profile, USER_OPT_ADMIN)) {
  count++;
  }
  }
  } else if (!strcasecmp(args.type, "marked")) {
  AST_LIST_TRAVERSE(&conference->active_list, user, list) {
  if (ast_test_flag(&user->u_profile, USER_OPT_MARKEDUSER)) {
  count++;
  }
  }
  } else if (!strcasecmp(args.type, "locked")) {
  count = conference->locked;
  } else if (!strcasecmp(args.type, "muted")) {
  count = conference->muted;
  } else {
  ast_log(LOG_ERROR, "Invalid keyword '%s' passed to CONFBRIDGE_INFO.\n", args.type);
  }
  snprintf(buf, len, "%d", count);
  ao2_unlock(conference);
  ao2_ref(conference, -1);
  return 0;
 }

◆ generic_lock_unlock_helper()

static int generic_lock_unlock_helper	(	int	lock,
		const char *	conference_name
	)

static

Definition at line 3503 of file app_confbridge.c.

References ao2_find, ao2_lock, ao2_ref, ao2_unlock, ast_test_suite_event_notify, confbridge_conference::b_profile, hangup_data::conference, hangup_data::lock, confbridge_conference::locked, bridge_profile::name, and OBJ_KEY.

Referenced by action_lock_unlock_helper(), handle_cli_confbridge_lock(), and handle_cli_confbridge_unlock().

 {
  struct confbridge_conference *conference;
  int res = 0;
 
  conference = ao2_find(conference_bridges, conference_name, OBJ_KEY);
  if (!conference) {
  return -1;
  }
  ao2_lock(conference);
  conference->locked = lock;
  ast_test_suite_event_notify("CONF_LOCK", "Message: conference %s\r\nConference: %s", conference->locked ? "locked" : "unlocked", conference->b_profile.name);
  ao2_unlock(conference);
  ao2_ref(conference, -1);
 
  return res;
 }

◆ generic_mute_unmute_helper()

static int generic_mute_unmute_helper	(	int	mute,
		const char *	conference_name,
		const char *	chan_name
	)

static

Definition at line 3528 of file app_confbridge.c.

References confbridge_conference::active_list, ao2_cleanup, ao2_find, ast_channel_name(), AST_LIST_TRAVERSE, ast_test_flag, confbridge_user::chan, hangup_data::conference, generic_mute_unmute_user(), confbridge_user::list, match(), NULL, OBJ_KEY, RAII_VAR, SCOPED_AO2LOCK, confbridge_user::u_profile, user, USER_OPT_ADMIN, and confbridge_conference::waiting_list.

Referenced by action_mute_unmute_helper(), and cli_mute_unmute_helper().

 {
  RAII_VAR(struct confbridge_conference *, conference, NULL, ao2_cleanup);
  struct confbridge_user *user;
  int all = !strcasecmp("all", chan_name);
  int participants = !strcasecmp("participants", chan_name);
  int res = -2;
 
  conference = ao2_find(conference_bridges, conference_name, OBJ_KEY);
  if (!conference) {
  return -1;
  }
 
  {
  SCOPED_AO2LOCK(bridge_lock, conference);
  AST_LIST_TRAVERSE(&conference->active_list, user, list) {
  int match = !strncasecmp(chan_name, ast_channel_name(user->chan),
  strlen(chan_name));
  if (match || all
  || (participants && !ast_test_flag(&user->u_profile, USER_OPT_ADMIN))) {
  generic_mute_unmute_user(conference, user, mute);
  res = 0;
  if (match) {
  return res;
  }
  }
  }
 
  AST_LIST_TRAVERSE(&conference->waiting_list, user, list) {
  int match = !strncasecmp(chan_name, ast_channel_name(user->chan),
  strlen(chan_name));
  if (match || all
  || (participants && !ast_test_flag(&user->u_profile, USER_OPT_ADMIN))) {
  generic_mute_unmute_user(conference, user, mute);
  res = 0;
  if (match) {
  return res;
  }
  }
  }
  }
 
  return res;
 }

◆ generic_mute_unmute_user()

static void generic_mute_unmute_user	(	struct confbridge_conference *	conference,
		struct confbridge_user *	user,
		int	mute
	)

static

Definition at line 1312 of file app_confbridge.c.

References ast_channel_name(), ast_test_suite_event_notify, confbridge_conference::b_profile, confbridge_user::chan, conf_update_user_mute(), confbridge_user::muted, bridge_profile::name, send_mute_event(), and send_unmute_event().

Referenced by action_toggle_mute(), and generic_mute_unmute_helper().

 {
  /* Set user level mute request. */
  user->muted = mute ? 1 : 0;
 
  conf_update_user_mute(user);
  ast_test_suite_event_notify("CONF_MUTE",
  "Message: participant %s %s\r\n"
  "Conference: %s\r\n"
  "Channel: %s",
  ast_channel_name(user->chan),
  mute ? "muted" : "unmuted",
  conference->b_profile.name,
  ast_channel_name(user->chan));
  if (mute) {
  send_mute_event(user, conference);
  } else {
  send_unmute_event(user, conference);
  }
 }

◆ handle_cli_confbridge_kick()

static char* handle_cli_confbridge_kick	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)

static

Definition at line 3342 of file app_confbridge.c.

References ao2_find, ao2_ref, ast_cli_args::argc, ast_cli_args::argv, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_confbridge_name(), complete_confbridge_participant(), hangup_data::conference, ast_cli_args::fd, kick_conference_participant(), ast_cli_args::line, ast_cli_args::n, NULL, OBJ_KEY, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

 {
  struct confbridge_conference *conference;
  int not_found;
 
  switch (cmd) {
  case CLI_INIT:
  e->command = "confbridge kick";
  e->usage =
  "Usage: confbridge kick <conference> <channel>\n"
  " Kicks a channel out of the conference bridge.\n"
  " (all to kick everyone, participants to kick non-admins).\n";
  return NULL;
  case CLI_GENERATE:
  if (a->pos == 2) {
  return complete_confbridge_name(a->line, a->word, a->pos, a->n);
  }
  if (a->pos == 3) {
  return complete_confbridge_participant(a->argv[2], a->line, a->word, a->pos, a->n);
  }
  return NULL;
  }
 
  if (a->argc != 4) {
  return CLI_SHOWUSAGE;
  }
 
  conference = ao2_find(conference_bridges, a->argv[2], OBJ_KEY);
  if (!conference) {
  ast_cli(a->fd, "No conference bridge named '%s' found!\n", a->argv[2]);
  return CLI_SUCCESS;
  }
  not_found = kick_conference_participant(conference, a->argv[3]);
  ao2_ref(conference, -1);
  if (not_found) {
  if (!strcasecmp("all", a->argv[3]) || !strcasecmp("participants", a->argv[3])) {
  ast_cli(a->fd, "No participants found!\n");
  } else {
  ast_cli(a->fd, "No participant named '%s' found!\n", a->argv[3]);
  }
  return CLI_SUCCESS;
  }
  ast_cli(a->fd, "Kicked '%s' out of conference '%s'\n", a->argv[3], a->argv[2]);
  return CLI_SUCCESS;
 }

◆ handle_cli_confbridge_list()

static char* handle_cli_confbridge_list	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)

static

Definition at line 3424 of file app_confbridge.c.

References confbridge_conference::active_list, confbridge_conference::activeusers, ao2_find, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_cli_args::argc, ast_cli_args::argv, ast_cli(), AST_CLI_YESNO, AST_LIST_TRAVERSE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_confbridge_name(), hangup_data::conference, ast_cli_args::fd, handle_cli_confbridge_list_item(), ast_cli_args::line, confbridge_user::list, confbridge_conference::locked, confbridge_conference::markedusers, confbridge_conference::muted, ast_cli_args::n, confbridge_conference::name, NULL, OBJ_KEY, ast_cli_args::pos, ast_cli_entry::usage, user, confbridge_conference::waiting_list, confbridge_conference::waitingusers, and ast_cli_args::word.

 {
  struct confbridge_conference *conference;
 
  switch (cmd) {
  case CLI_INIT:
  e->command = "confbridge list";
  e->usage =
  "Usage: confbridge list [<name>]\n"
  " Lists all currently active conference bridges or a specific conference bridge.\n"
  "\n"
  " When a conference bridge name is provided, flags may be shown for users. Below\n"
  " are the flags and what they represent.\n"
  "\n"
  " Flags:\n"
  " A - The user is an admin\n"
  " M - The user is a marked user\n"
  " W - The user must wait for a marked user to join\n"
  " E - The user will be kicked after the last marked user leaves the conference\n"
  " m - The user is muted\n"
  " w - The user is waiting for a marked user to join\n";
  return NULL;
  case CLI_GENERATE:
  if (a->pos == 2) {
  return complete_confbridge_name(a->line, a->word, a->pos, a->n);
  }
  return NULL;
  }
 
  if (a->argc == 2) {
  struct ao2_iterator iter;
 
  ast_cli(a->fd, "Conference Bridge Name Users Marked Locked Muted\n");
  ast_cli(a->fd, "================================ ====== ====== ====== =====\n");
  iter = ao2_iterator_init(conference_bridges, 0);
  while ((conference = ao2_iterator_next(&iter))) {
  ast_cli(a->fd, "%-32s %6u %6u %-6s %s\n",
  conference->name,
  conference->activeusers + conference->waitingusers,
  conference->markedusers,
  AST_CLI_YESNO(conference->locked),
  AST_CLI_YESNO(conference->muted));
  ao2_ref(conference, -1);
  }
  ao2_iterator_destroy(&iter);
  return CLI_SUCCESS;
  }
 
  if (a->argc == 3) {
  struct confbridge_user *user;
 
  conference = ao2_find(conference_bridges, a->argv[2], OBJ_KEY);
  if (!conference) {
  ast_cli(a->fd, "No conference bridge named '%s' found!\n", a->argv[2]);
  return CLI_SUCCESS;
  }
  ast_cli(a->fd, "Channel Flags User Profile Bridge Profile Menu CallerID\n");
  ast_cli(a->fd, "============================== ====== ================ ================ ================ ================\n");
  ao2_lock(conference);
  AST_LIST_TRAVERSE(&conference->active_list, user, list) {
  handle_cli_confbridge_list_item(a, user, 0);
  }
  AST_LIST_TRAVERSE(&conference->waiting_list, user, list) {
  handle_cli_confbridge_list_item(a, user, 1);
  }
  ao2_unlock(conference);
  ao2_ref(conference, -1);
  return CLI_SUCCESS;
  }
 
  return CLI_SHOWUSAGE;
 }

◆ handle_cli_confbridge_list_item()

static void handle_cli_confbridge_list_item	(	struct ast_cli_args *	a,
		struct confbridge_user *	user,
		int	waiting
	)

static

Definition at line 3388 of file app_confbridge.c.

References ast_channel_caller(), ast_channel_name(), ast_cli(), ast_test_flag, confbridge_conference::b_profile, confbridge_user::chan, confbridge_user::conference, ast_cli_args::fd, ast_party_caller::id, confbridge_user::menu_name, confbridge_user::muted, user_profile::name, bridge_profile::name, ast_party_id::number, S_COR, ast_party_number::str, confbridge_user::u_profile, USER_OPT_ADMIN, USER_OPT_ENDMARKED, USER_OPT_MARKEDUSER, USER_OPT_WAITMARKED, and ast_party_number::valid.

Referenced by handle_cli_confbridge_list().

 {
  char flag_str[6 + 1];/* Max flags + terminator */
  int pos = 0;
 
  /* Build flags column string. */
  if (ast_test_flag(&user->u_profile, USER_OPT_ADMIN)) {
  flag_str[pos++] = 'A';
  }
  if (ast_test_flag(&user->u_profile, USER_OPT_MARKEDUSER)) {
  flag_str[pos++] = 'M';
  }
  if (ast_test_flag(&user->u_profile, USER_OPT_WAITMARKED)) {
  flag_str[pos++] = 'W';
  }
  if (ast_test_flag(&user->u_profile, USER_OPT_ENDMARKED)) {
  flag_str[pos++] = 'E';
  }
  if (user->muted) {
  flag_str[pos++] = 'm';
  }
  if (waiting) {
  flag_str[pos++] = 'w';
  }
  flag_str[pos] = '\0';
 
  ast_cli(a->fd, "%-30s %-6s %-16s %-16s %-16s %s\n",
  ast_channel_name(user->chan),
  flag_str,
  user->u_profile.name,
  user->conference->b_profile.name,
  user->menu_name,
  S_COR(ast_channel_caller(user->chan)->id.number.valid,
  ast_channel_caller(user->chan)->id.number.str, "<unknown>"));
 }

◆ handle_cli_confbridge_lock()

static char* handle_cli_confbridge_lock	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)

static

Definition at line 3655 of file app_confbridge.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_confbridge_name(), ast_cli_args::fd, generic_lock_unlock_helper(), ast_cli_args::line, ast_cli_args::n, NULL, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

 {
  switch (cmd) {
  case CLI_INIT:
  e->command = "confbridge lock";
  e->usage =
  "Usage: confbridge lock <conference>\n"
  " Lock a conference. While locked, no new non-admins\n"
  " may join the conference.\n";
  return NULL;
  case CLI_GENERATE:
  if (a->pos == 2) {
  return complete_confbridge_name(a->line, a->word, a->pos, a->n);
  }
  return NULL;
  }
  if (a->argc != 3) {
  return CLI_SHOWUSAGE;
  }
  if (generic_lock_unlock_helper(1, a->argv[2])) {
  ast_cli(a->fd, "Conference %s is not found\n", a->argv[2]);
  } else {
  ast_cli(a->fd, "Conference %s is locked.\n", a->argv[2]);
  }
  return CLI_SUCCESS;
 }

◆ handle_cli_confbridge_mute()

static char* handle_cli_confbridge_mute	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)

static

Definition at line 3593 of file app_confbridge.c.

References ast_cli_args::argc, ast_cli_args::argv, CLI_GENERATE, CLI_INIT, cli_mute_unmute_helper(), CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_confbridge_name(), complete_confbridge_participant(), ast_cli_args::line, ast_cli_args::n, NULL, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

 {
  switch (cmd) {
  case CLI_INIT:
  e->command = "confbridge mute";
  e->usage =
  "Usage: confbridge mute <conference> <channel>\n"
  " Mute a channel in a conference.\n"
  " (all to mute everyone, participants to mute non-admins)\n"
  " If the specified channel is a prefix,\n"
  " the action will be taken on the first\n"
  " matching channel.\n";
  return NULL;
  case CLI_GENERATE:
  if (a->pos == 2) {
  return complete_confbridge_name(a->line, a->word, a->pos, a->n);
  }
  if (a->pos == 3) {
  return complete_confbridge_participant(a->argv[2], a->line, a->word, a->pos, a->n);
  }
  return NULL;
  }
  if (a->argc != 4) {
  return CLI_SHOWUSAGE;
  }
 
  cli_mute_unmute_helper(1, a);
 
  return CLI_SUCCESS;
 }

◆ handle_cli_confbridge_start_record()

static char* handle_cli_confbridge_start_record	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)

static

Definition at line 3708 of file app_confbridge.c.

References ao2_find, ao2_lock, ao2_ref, ao2_unlock, ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_copy_string(), ast_strlen_zero, confbridge_conference::b_profile, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_confbridge_name(), conf_is_recording(), conf_start_record(), hangup_data::conference, ast_cli_args::fd, ast_cli_args::line, ast_cli_args::n, NULL, OBJ_KEY, ast_cli_args::pos, bridge_profile::rec_file, ast_cli_entry::usage, and ast_cli_args::word.

 {
  const char *rec_file = NULL;
  struct confbridge_conference *conference;
 
  switch (cmd) {
  case CLI_INIT:
  e->command = "confbridge record start";
  e->usage =
  "Usage: confbridge record start <conference> <file>\n"
  " <file> is optional, Otherwise the bridge profile\n"
  " record file will be used. If the bridge profile\n"
  " has no record file specified, a file will automatically\n"
  " be generated in the monitor directory\n";
  return NULL;
  case CLI_GENERATE:
  if (a->pos == 3) {
  return complete_confbridge_name(a->line, a->word, a->pos, a->n);
  }
  return NULL;
  }
  if (a->argc < 4) {
  return CLI_SHOWUSAGE;
  }
  if (a->argc == 5) {
  rec_file = a->argv[4];
  }
 
  conference = ao2_find(conference_bridges, a->argv[3], OBJ_KEY);
  if (!conference) {
  ast_cli(a->fd, "Conference not found.\n");
  return CLI_FAILURE;
  }
  ao2_lock(conference);
  if (conf_is_recording(conference)) {
  ast_cli(a->fd, "Conference is already being recorded.\n");
  ao2_unlock(conference);
  ao2_ref(conference, -1);
  return CLI_SUCCESS;
  }
  if (!ast_strlen_zero(rec_file)) {
  ast_copy_string(conference->b_profile.rec_file, rec_file, sizeof(conference->b_profile.rec_file));
  }
 
  if (conf_start_record(conference)) {
  ast_cli(a->fd, "Could not start recording due to internal error.\n");
  ao2_unlock(conference);
  ao2_ref(conference, -1);
  return CLI_FAILURE;
  }
  ao2_unlock(conference);
 
  ast_cli(a->fd, "Recording started\n");
  ao2_ref(conference, -1);
  return CLI_SUCCESS;
 }

◆ handle_cli_confbridge_stop_record()

static char* handle_cli_confbridge_stop_record	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)

static

Definition at line 3765 of file app_confbridge.c.

References ao2_find, ao2_lock, ao2_ref, ao2_unlock, ast_cli_args::argc, ast_cli_args::argv, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_confbridge_name(), conf_stop_record(), hangup_data::conference, ast_cli_args::fd, ast_cli_args::line, ast_cli_args::n, NULL, OBJ_KEY, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

 {
  struct confbridge_conference *conference;
  int ret;
 
  switch (cmd) {
  case CLI_INIT:
  e->command = "confbridge record stop";
  e->usage =
  "Usage: confbridge record stop <conference>\n"
  " Stop a previously started recording.\n";
  return NULL;
  case CLI_GENERATE:
  if (a->pos == 3) {
  return complete_confbridge_name(a->line, a->word, a->pos, a->n);
  }
  return NULL;
  }
  if (a->argc != 4) {
  return CLI_SHOWUSAGE;
  }
 
  conference = ao2_find(conference_bridges, a->argv[3], OBJ_KEY);
  if (!conference) {
  ast_cli(a->fd, "Conference not found.\n");
  return CLI_SUCCESS;
  }
  ao2_lock(conference);
  ret = conf_stop_record(conference);
  ao2_unlock(conference);
  ast_cli(a->fd, "Recording %sstopped.\n", ret ? "could not be " : "");
  ao2_ref(conference, -1);
  return CLI_SUCCESS;
 }

◆ handle_cli_confbridge_unlock()

static char* handle_cli_confbridge_unlock	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)

static

Definition at line 3682 of file app_confbridge.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_confbridge_name(), ast_cli_args::fd, generic_lock_unlock_helper(), ast_cli_args::line, ast_cli_args::n, NULL, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

 {
  switch (cmd) {
  case CLI_INIT:
  e->command = "confbridge unlock";
  e->usage =
  "Usage: confbridge unlock <conference>\n"
  " Unlock a previously locked conference.\n";
  return NULL;
  case CLI_GENERATE:
  if (a->pos == 2) {
  return complete_confbridge_name(a->line, a->word, a->pos, a->n);
  }
  return NULL;
  }
  if (a->argc != 3) {
  return CLI_SHOWUSAGE;
  }
  if (generic_lock_unlock_helper(0, a->argv[2])) {
  ast_cli(a->fd, "Conference %s is not found\n", a->argv[2]);
  } else {
  ast_cli(a->fd, "Conference %s is unlocked.\n", a->argv[2]);
  }
  return CLI_SUCCESS;
 }

◆ handle_cli_confbridge_unmute()

static char* handle_cli_confbridge_unmute	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)

static

Definition at line 3624 of file app_confbridge.c.

References ast_cli_args::argc, ast_cli_args::argv, CLI_GENERATE, CLI_INIT, cli_mute_unmute_helper(), CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_confbridge_name(), complete_confbridge_participant(), ast_cli_args::line, ast_cli_args::n, NULL, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

 {
  switch (cmd) {
  case CLI_INIT:
  e->command = "confbridge unmute";
  e->usage =
  "Usage: confbridge unmute <conference> <channel>\n"
  " Unmute a channel in a conference.\n"
  " (all to unmute everyone, participants to unmute non-admins)\n"
  " If the specified channel is a prefix,\n"
  " the action will be taken on the first\n"
  " matching channel.\n";
  return NULL;
  case CLI_GENERATE:
  if (a->pos == 2) {
  return complete_confbridge_name(a->line, a->word, a->pos, a->n);
  }
  if (a->pos == 3) {
  return complete_confbridge_participant(a->argv[2], a->line, a->word, a->pos, a->n);
  }
  return NULL;
  }
  if (a->argc != 4) {
  return CLI_SHOWUSAGE;
  }
 
  cli_mute_unmute_helper(0, a);
 
  return CLI_SUCCESS;
 }

◆ handle_conf_user_join()

static int handle_conf_user_join ( struct confbridge_user * user )

static

Call the proper join event handler for the user for the conference bridge's current state.

Definition at line 1220 of file app_confbridge.c.

References ast_assert, ast_test_flag, conf_invalid_event_fn(), confbridge_user::conference, handler(), confbridge_state::join_marked, confbridge_state::join_unmarked, confbridge_state::join_waitmarked, NULL, confbridge_conference::state, confbridge_user::u_profile, USER_OPT_MARKEDUSER, and USER_OPT_WAITMARKED.

Referenced by join_conference_bridge().

 {
  conference_event_fn handler;
  if (ast_test_flag(&user->u_profile, USER_OPT_MARKEDUSER)) {
  handler = user->conference->state->join_marked;
  } else if (ast_test_flag(&user->u_profile, USER_OPT_WAITMARKED)) {
  handler = user->conference->state->join_waitmarked;
  } else {
  handler = user->conference->state->join_unmarked;
  }
 
  ast_assert(handler != NULL);
 
  if (!handler) {
  conf_invalid_event_fn(user);
  return -1;
  }
 
  handler(user);
 
  return 0;
 }

◆ handle_conf_user_leave()

static int handle_conf_user_leave ( struct confbridge_user * user )

static

Call the proper leave event handler for the user for the conference bridge's current state.

Definition at line 1249 of file app_confbridge.c.

References ast_assert, ast_test_flag, conf_invalid_event_fn(), confbridge_user::conference, handler(), confbridge_state::leave_marked, confbridge_state::leave_unmarked, confbridge_state::leave_waitmarked, NULL, confbridge_conference::state, confbridge_user::u_profile, USER_OPT_MARKEDUSER, and USER_OPT_WAITMARKED.

Referenced by leave_conference().

 {
  conference_event_fn handler;
  if (ast_test_flag(&user->u_profile, USER_OPT_MARKEDUSER)) {
  handler = user->conference->state->leave_marked;
  } else if (ast_test_flag(&user->u_profile, USER_OPT_WAITMARKED)) {
  handler = user->conference->state->leave_waitmarked;
  } else {
  handler = user->conference->state->leave_unmarked;
  }
 
  ast_assert(handler != NULL);
 
  if (!handler) {
  /* This should never happen. If it does, though, it is bad. The user will not have been removed
  * from the appropriate list, so counts will be off and stuff. The conference won't be torn down, etc.
  * Shouldn't happen, though. */
  conf_invalid_event_fn(user);
  return -1;
  }
 
  handler(user);
 
  return 0;
 }

◆ handle_video_on_exit()

static void handle_video_on_exit	(	struct confbridge_conference *	conference,
		struct ast_channel *	chan
	)

static

Definition at line 1075 of file app_confbridge.c.

References confbridge_conference::active_list, ao2_lock, ao2_unlock, ast_bridge_is_video_src(), ast_bridge_remove_video_src(), ast_bridge_set_single_src_video_mode(), ast_bridge_set_talker_src_video_mode(), AST_LIST_TRAVERSE, ast_test_flag, confbridge_conference::b_profile, confbridge_conference::bridge, BRIDGE_OPT_VIDEO_SRC_FIRST_MARKED, BRIDGE_OPT_VIDEO_SRC_FOLLOW_TALKER, BRIDGE_OPT_VIDEO_SRC_LAST_MARKED, confbridge_user::chan, confbridge_user::list, NULL, confbridge_user::u_profile, and USER_OPT_MARKEDUSER.

Referenced by confbridge_exec(), and execute_menu_entry().

 {
  struct confbridge_user *user = NULL;
 
  /* if this isn't a video source, nothing to update */
  if (!ast_bridge_is_video_src(conference->bridge, chan)) {
  return;
  }
 
  ast_bridge_remove_video_src(conference->bridge, chan);
 
  /* If in follow talker mode, make sure to restore this mode on the
  * bridge when a source is removed. It is possible this channel was
  * only set temporarily as a video source by an AMI or DTMF action. */
  if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_VIDEO_SRC_FOLLOW_TALKER)) {
  ast_bridge_set_talker_src_video_mode(conference->bridge);
  }
 
  /* if the video_mode isn't set to automatically pick the video source, do nothing on exit. */
  if (!ast_test_flag(&conference->b_profile, BRIDGE_OPT_VIDEO_SRC_FIRST_MARKED) &&
  !ast_test_flag(&conference->b_profile, BRIDGE_OPT_VIDEO_SRC_LAST_MARKED)) {
  return;
  }
 
  /* Make the next available marked user the video src. */
  ao2_lock(conference);
  AST_LIST_TRAVERSE(&conference->active_list, user, list) {
  if (user->chan == chan) {
  continue;
  }
  if (ast_test_flag(&user->u_profile, USER_OPT_MARKEDUSER)) {
  ast_bridge_set_single_src_video_mode(conference->bridge, user->chan);
  break;
  }
  }
  ao2_unlock(conference);
 }

◆ handle_video_on_join()

static void handle_video_on_join	(	struct confbridge_conference *	conference,
		struct ast_channel *	chan,
		int	marked
	)

static

Definition at line 1043 of file app_confbridge.c.

References confbridge_conference::active_list, ao2_lock, ao2_unlock, ast_bridge_is_video_src(), ast_bridge_set_single_src_video_mode(), AST_LIST_TRAVERSE, ast_test_flag, confbridge_conference::b_profile, confbridge_conference::bridge, BRIDGE_OPT_VIDEO_SRC_FIRST_MARKED, BRIDGE_OPT_VIDEO_SRC_LAST_MARKED, confbridge_user::chan, confbridge_user::list, and NULL.

Referenced by confbridge_exec().

 {
  /* Right now, only marked users are automatically set as the single src of video.*/
  if (!marked) {
  return;
  }
 
  if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_VIDEO_SRC_FIRST_MARKED)) {
  int set = 1;
  struct confbridge_user *user = NULL;
 
  ao2_lock(conference);
  /* see if anyone is already the video src */
  AST_LIST_TRAVERSE(&conference->active_list, user, list) {
  if (user->chan == chan) {
  continue;
  }
  if (ast_bridge_is_video_src(conference->bridge, user->chan)) {
  set = 0;
  break;
  }
  }
  ao2_unlock(conference);
  if (set) {
  ast_bridge_set_single_src_video_mode(conference->bridge, chan);
  }
  } else if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_VIDEO_SRC_LAST_MARKED)) {
  /* we joined and are video capable, we override anyone else that may have already been the video feed */
  ast_bridge_set_single_src_video_mode(conference->bridge, chan);
  }
 }

◆ hangup_data_destroy()

static void hangup_data_destroy ( struct hangup_data * hangup )

static

Definition at line 1160 of file app_confbridge.c.

References ast_cond_destroy, ast_mutex_destroy, hangup_data::cond, and hangup_data::lock.

Referenced by destroy_conference_bridge().

 {
  ast_mutex_destroy(&hangup->lock);
  ast_cond_destroy(&hangup->cond);
 }

◆ hangup_data_init()

static void hangup_data_init	(	struct hangup_data *	hangup,
		struct confbridge_conference *	conference
	)

static

Definition at line 1151 of file app_confbridge.c.

References ast_cond_init, ast_mutex_init, hangup_data::cond, hangup_data::conference, hangup_data::hungup, hangup_data::lock, and NULL.

Referenced by destroy_conference_bridge().

 {
  ast_mutex_init(&hangup->lock);
  ast_cond_init(&hangup->cond, NULL);
 
  hangup->conference = conference;
  hangup->hungup = 0;
 }

◆ hangup_playback()

static int hangup_playback ( void * data )

static

Hang up the announcer channel.

This hangs up the announcer channel in the conference. This runs in the playback queue taskprocessor since we do not want to hang up the channel while it's trying to play an announcement.

This task is performed synchronously, so there is no need to perform any cleanup on the passed-in data.

Parameters

data	A hangup_data structure

Returns: 0

Definition at line 1134 of file app_confbridge.c.

References ast_autoservice_stop(), ast_cond_signal, ast_hangup(), ast_mutex_lock, ast_mutex_unlock, hangup_data::cond, hangup_data::conference, hangup(), hangup_data::hungup, hangup_data::lock, NULL, and confbridge_conference::playback_chan.

Referenced by destroy_conference_bridge().

 {
  struct hangup_data *hangup = data;
 
  ast_autoservice_stop(hangup->conference->playback_chan);
 
  ast_hangup(hangup->conference->playback_chan);
  hangup->conference->playback_chan = NULL;
 
  ast_mutex_lock(&hangup->lock);
  hangup->hungup = 1;
  ast_cond_signal(&hangup->cond);
  ast_mutex_unlock(&hangup->lock);
 
  return 0;
 }

◆ is_new_rec_file()

static int is_new_rec_file	(	const char *	rec_file,
		struct ast_str **	orig_rec_file
	)

static

Definition at line 771 of file app_confbridge.c.

References ast_str_buffer(), ast_str_create, ast_str_set(), ast_strlen_zero, and RECORD_FILENAME_INITIAL_SPACE.

Referenced by conf_start_record().

 {
  if (!ast_strlen_zero(rec_file)) {
  if (!*orig_rec_file) {
  *orig_rec_file = ast_str_create(RECORD_FILENAME_INITIAL_SPACE);
  }
 
  if (*orig_rec_file
  && strcmp(ast_str_buffer(*orig_rec_file), rec_file)) {
  ast_str_set(orig_rec_file, 0, "%s", rec_file);
  return 1;
  }
  }
  return 0;
 }

◆ join_callback()

static int join_callback	(	struct ast_bridge_channel *	bridge_channel,
		void *	ignore
	)

static

Definition at line 2518 of file app_confbridge.c.

References async_play_sound_ready(), and ast_bridge_channel::chan.

Referenced by confbridge_exec().

 {
  async_play_sound_ready(bridge_channel->chan);
  return 0;
 }

◆ join_conference_bridge()

static struct confbridge_conference* join_conference_bridge	(	const char *	conference_name,
		struct confbridge_user *	user
	)

static

Join a conference bridge.

Parameters

conference_name	The conference name
user	Conference bridge user structure

Returns: A pointer to the conference bridge struct, or NULL if the conference room wasn't found.

Definition at line 1679 of file app_confbridge.c.

References confbridge_conference::activeusers, alloc_playback_chan(), announce_user_count(), user_profile::announce_user_count_all_after, user_profile::announcement, ao2_alloc, ao2_find, ao2_link, ao2_lock, ao2_ref, ao2_unlink, ao2_unlock, app, ast_add_extension(), ast_autoservice_start(), ast_autoservice_stop(), ast_bridge_base_new(), AST_BRIDGE_CAPABILITY_MULTIMIX, AST_BRIDGE_FLAG_MASQUERADE_ONLY, AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY, ast_bridge_set_binaural_active(), ast_bridge_set_internal_sample_rate(), ast_bridge_set_maximum_sample_rate(), ast_bridge_set_mixing_interval(), ast_bridge_set_remb_estimated_bitrate(), ast_bridge_set_remb_send_interval(), ast_bridge_set_send_sdp_label(), ast_bridge_set_sfu_video_mode(), ast_bridge_set_talker_src_video_mode(), ast_bridge_set_video_update_discard(), AST_BRIDGE_VIDEO_SFU_REMB_AVERAGE, AST_BRIDGE_VIDEO_SFU_REMB_AVERAGE_ALL, AST_BRIDGE_VIDEO_SFU_REMB_FORCE, AST_BRIDGE_VIDEO_SFU_REMB_HIGHEST, AST_BRIDGE_VIDEO_SFU_REMB_HIGHEST_ALL, AST_BRIDGE_VIDEO_SFU_REMB_LOWEST, AST_BRIDGE_VIDEO_SFU_REMB_LOWEST_ALL, ast_brige_set_remb_behavior(), ast_check_hangup(), ast_copy_string(), ast_debug, ast_exists_extension(), ast_free, AST_LIST_REMOVE_HEAD, ast_log, ast_str_create, ast_stream_and_wait(), ast_strlen_zero, ast_test_flag, confbridge_conference::b_profile, confbridge_user::b_profile, confbridge_conference::bridge, BRIDGE_OPT_BINAURAL_ACTIVE, BRIDGE_OPT_ENABLE_EVENTS, BRIDGE_OPT_RECORD_CONFERENCE, BRIDGE_OPT_REMB_BEHAVIOR_AVERAGE, BRIDGE_OPT_REMB_BEHAVIOR_AVERAGE_ALL, BRIDGE_OPT_REMB_BEHAVIOR_FORCE, BRIDGE_OPT_REMB_BEHAVIOR_HIGHEST, BRIDGE_OPT_REMB_BEHAVIOR_HIGHEST_ALL, BRIDGE_OPT_REMB_BEHAVIOR_LOWEST, BRIDGE_OPT_REMB_BEHAVIOR_LOWEST_ALL, BRIDGE_OPT_VIDEO_SRC_FOLLOW_TALKER, BRIDGE_OPT_VIDEO_SRC_SFU, confbridge_user::chan, conf_bridge_profile_copy(), conf_get_sound(), CONF_SOUND_LOCKED, conf_start_record(), CONF_STATE_EMPTY, confbridge_user::conference, hangup_data::conference, destroy_conference_bridge(), post_join_action::func, handle_conf_user_join(), bridge_profile::internal_sample_rate, leave_conference(), post_join_action::list, confbridge_conference::locked, LOG_ERROR, bridge_profile::max_members, bridge_profile::maximum_sample_rate, bridge_profile::mix_interval, confbridge_conference::muted, confbridge_user::muted, confbridge_conference::name, NULL, OBJ_KEY, play_prompt_to_user(), confbridge_user::post_join_list, push_announcer(), confbridge_conference::record_filename, RECORD_FILENAME_INITIAL_SPACE, bridge_profile::regcontext, bridge_profile::remb_estimated_bitrate, bridge_profile::remb_send_interval, send_conf_start_event(), bridge_profile::sounds, confbridge_conference::state, confbridge_user::suspended_moh, confbridge_user::u_profile, USER_OPT_ADMIN, USER_OPT_ANNOUNCEUSERCOUNT, USER_OPT_ANNOUNCEUSERCOUNTALL, USER_OPT_STARTMUTED, and bridge_profile::video_update_discard.

Referenced by confbridge_exec().

 {
  struct confbridge_conference *conference;
  struct post_join_action *action;
  int max_members_reached = 0;
 
  /* We explictly lock the conference bridges container ourselves so that other callers can not create duplicate conferences at the same */
  ao2_lock(conference_bridges);
 
  ast_debug(1, "Trying to find conference bridge '%s'\n", conference_name);
 
  /* Attempt to find an existing conference bridge */
  conference = ao2_find(conference_bridges, conference_name, OBJ_KEY);
  if (conference && conference->b_profile.max_members) {
  max_members_reached = conference->b_profile.max_members > conference->activeusers ? 0 : 1;
  }
 
  /* When finding a conference bridge that already exists make sure that it is not locked, and if so that we are not an admin */
  if (conference && (max_members_reached || conference->locked) && !ast_test_flag(&user->u_profile, USER_OPT_ADMIN)) {
  ao2_unlock(conference_bridges);
  ast_debug(1, "Conference '%s' is locked and caller is not an admin\n", conference_name);
  ast_stream_and_wait(user->chan,
  conf_get_sound(CONF_SOUND_LOCKED, conference->b_profile.sounds),
  "");
  ao2_ref(conference, -1);
  return NULL;
  }
 
  /* If no conference bridge was found see if we can create one */
  if (!conference) {
  /* Try to allocate memory for a new conference bridge, if we fail... this won't end well. */
  if (!(conference = ao2_alloc(sizeof(*conference), destroy_conference_bridge))) {
  ao2_unlock(conference_bridges);
  ast_log(LOG_ERROR, "Conference '%s' could not be created.\n", conference_name);
  return NULL;
  }
 
  /* Setup for the record channel */
  conference->record_filename = ast_str_create(RECORD_FILENAME_INITIAL_SPACE);
  if (!conference->record_filename) {
  ao2_ref(conference, -1);
  ao2_unlock(conference_bridges);
  return NULL;
  }
 
  /* Setup conference bridge parameters */
  ast_copy_string(conference->name, conference_name, sizeof(conference->name));
  conf_bridge_profile_copy(&conference->b_profile, &user->b_profile);
 
  /* Create an actual bridge that will do the audio mixing */
  conference->bridge = ast_bridge_base_new(AST_BRIDGE_CAPABILITY_MULTIMIX,
  AST_BRIDGE_FLAG_MASQUERADE_ONLY | AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY,
  app, conference_name, NULL);
  if (!conference->bridge) {
  ao2_ref(conference, -1);
  ao2_unlock(conference_bridges);
  ast_log(LOG_ERROR, "Conference '%s' mixing bridge could not be created.\n", conference_name);
  return NULL;
  }
 
  /* Set the internal sample rate on the bridge from the bridge profile */
  ast_bridge_set_internal_sample_rate(conference->bridge, conference->b_profile.internal_sample_rate);
  /* Set the maximum sample rate on the bridge from the bridge profile */
  ast_bridge_set_maximum_sample_rate(conference->bridge, conference->b_profile.maximum_sample_rate);
  /* Set the internal mixing interval on the bridge from the bridge profile */
  ast_bridge_set_mixing_interval(conference->bridge, conference->b_profile.mix_interval);
  ast_bridge_set_binaural_active(conference->bridge, ast_test_flag(&conference->b_profile, BRIDGE_OPT_BINAURAL_ACTIVE));
 
  if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_VIDEO_SRC_FOLLOW_TALKER)) {
  ast_bridge_set_talker_src_video_mode(conference->bridge);
  } else if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_VIDEO_SRC_SFU)) {
  ast_bridge_set_sfu_video_mode(conference->bridge);
  ast_bridge_set_video_update_discard(conference->bridge, conference->b_profile.video_update_discard);
  ast_bridge_set_remb_send_interval(conference->bridge, conference->b_profile.remb_send_interval);
  if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_REMB_BEHAVIOR_AVERAGE)) {
  ast_brige_set_remb_behavior(conference->bridge, AST_BRIDGE_VIDEO_SFU_REMB_AVERAGE);
  } else if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_REMB_BEHAVIOR_LOWEST)) {
  ast_brige_set_remb_behavior(conference->bridge, AST_BRIDGE_VIDEO_SFU_REMB_LOWEST);
  } else if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_REMB_BEHAVIOR_HIGHEST)) {
  ast_brige_set_remb_behavior(conference->bridge, AST_BRIDGE_VIDEO_SFU_REMB_HIGHEST);
  } else if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_REMB_BEHAVIOR_AVERAGE_ALL)) {
  ast_brige_set_remb_behavior(conference->bridge, AST_BRIDGE_VIDEO_SFU_REMB_AVERAGE_ALL);
  } else if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_REMB_BEHAVIOR_LOWEST_ALL)) {
  ast_brige_set_remb_behavior(conference->bridge, AST_BRIDGE_VIDEO_SFU_REMB_LOWEST_ALL);
  } else if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_REMB_BEHAVIOR_HIGHEST_ALL)) {
  ast_brige_set_remb_behavior(conference->bridge, AST_BRIDGE_VIDEO_SFU_REMB_HIGHEST_ALL);
  } else if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_REMB_BEHAVIOR_FORCE)) {
  ast_brige_set_remb_behavior(conference->bridge, AST_BRIDGE_VIDEO_SFU_REMB_FORCE);
  ast_bridge_set_remb_estimated_bitrate(conference->bridge, conference->b_profile.remb_estimated_bitrate);
  }
  }
 
  if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_ENABLE_EVENTS)) {
  ast_bridge_set_send_sdp_label(conference->bridge, 1);
  }
 
  /* Link it into the conference bridges container */
  if (!ao2_link(conference_bridges, conference)) {
  ao2_ref(conference, -1);
  ao2_unlock(conference_bridges);
  ast_log(LOG_ERROR,
  "Conference '%s' could not be added to the conferences list.\n", conference_name);
  return NULL;
  }
 
  /* Set the initial state to EMPTY */
  conference->state = CONF_STATE_EMPTY;
 
  if (alloc_playback_chan(conference)) {
  ao2_unlink(conference_bridges, conference);
  ao2_ref(conference, -1);
  ao2_unlock(conference_bridges);
  ast_log(LOG_ERROR, "Could not allocate announcer channel for conference '%s'\n", conference_name);
  return NULL;
  }
 
  if (push_announcer(conference)) {
  ao2_unlink(conference_bridges, conference);
  ao2_ref(conference, -1);
  ao2_unlock(conference_bridges);
  ast_log(LOG_ERROR, "Could not add announcer channel for conference '%s' bridge\n", conference_name);
  return NULL;
  }
 
  if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_RECORD_CONFERENCE)) {
  ao2_lock(conference);
  conf_start_record(conference);
  ao2_unlock(conference);
  }
 
  send_conf_start_event(conference);
 
  if (!ast_strlen_zero(conference->b_profile.regcontext)) {
  if (!ast_exists_extension(NULL, conference->b_profile.regcontext, conference->name, 1, NULL)) {
  ast_add_extension(conference->b_profile.regcontext, 1, conference->name, 1, NULL, NULL, "Noop", NULL, NULL, "ConfBridge");
  }
  }
 
  ast_debug(1, "Created conference '%s' and linked to container.\n", conference_name);
  }
 
  ao2_unlock(conference_bridges);
 
  /* Setup conference bridge user parameters */
  user->conference = conference;
 
  ao2_lock(conference);
 
  /* Determine if the new user should join the conference muted. */
  if (ast_test_flag(&user->u_profile, USER_OPT_STARTMUTED)
  || (!ast_test_flag(&user->u_profile, USER_OPT_ADMIN) && conference->muted)) {
  /* Set user level mute request. */
  user->muted = 1;
  }
 
  /*
  * Suspend any MOH until the user actually joins the bridge of
  * the conference. This way any pre-join file playback does not
  * need to worry about MOH.
  */
  user->suspended_moh = 1;
 
  if (handle_conf_user_join(user)) {
  /* Invalid event, nothing was done, so we don't want to process a leave. */
  ao2_unlock(conference);
  ao2_ref(conference, -1);
  user->conference = NULL;
  return NULL;
  }
 
  if (ast_check_hangup(user->chan)) {
  ao2_unlock(conference);
  leave_conference(user);
  return NULL;
  }
 
  ao2_unlock(conference);
 
  /* If an announcement is to be played play it */
  if (!ast_strlen_zero(user->u_profile.announcement)) {
  if (play_prompt_to_user(user,
  user->u_profile.announcement)) {
  leave_conference(user);
  return NULL;
  }
  }
 
  /* Announce number of users if need be */
  if (ast_test_flag(&user->u_profile, USER_OPT_ANNOUNCEUSERCOUNT)) {
  if (announce_user_count(conference, user, NULL)) {
  leave_conference(user);
  return NULL;
  }
  }
 
  if (ast_test_flag(&user->u_profile, USER_OPT_ANNOUNCEUSERCOUNTALL) &&
  (conference->activeusers > user->u_profile.announce_user_count_all_after)) {
  int user_count_res;
 
  /*
  * We have to autoservice the new user because he has not quite
  * joined the conference yet.
  */
  ast_autoservice_start(user->chan);
  user_count_res = announce_user_count(conference, NULL, NULL);
  ast_autoservice_stop(user->chan);
  if (user_count_res) {
  leave_conference(user);
  return NULL;
  }
  }
 
  /* Handle post-join actions */
  while ((action = AST_LIST_REMOVE_HEAD(&user->post_join_list, list))) {
  action->func(user);
  ast_free(action);
  }
 
  return conference;
 }

◆ kick_conference_participant()

static int kick_conference_participant	(	struct confbridge_conference *	conference,
		const char *	channel
	)

static

Definition at line 3233 of file app_confbridge.c.

References confbridge_conference::active_list, ast_bridge_remove(), ast_channel_name(), AST_LIST_TRAVERSE, ast_test_flag, confbridge_conference::bridge, confbridge_user::chan, confbridge_user::kicked, confbridge_user::list, match(), NULL, pbx_builtin_setvar_helper(), SCOPED_AO2LOCK, confbridge_user::u_profile, USER_OPT_ADMIN, and confbridge_conference::waiting_list.

Referenced by action_confbridgekick(), confkick_exec(), and handle_cli_confbridge_kick().

 {
  int res = -1;
  int match;
  struct confbridge_user *user = NULL;
  int all = !strcasecmp("all", channel);
  int participants = !strcasecmp("participants", channel);
 
  SCOPED_AO2LOCK(bridge_lock, conference);
 
  AST_LIST_TRAVERSE(&conference->active_list, user, list) {
  if (user->kicked) {
  continue;
  }
  match = !strcasecmp(channel, ast_channel_name(user->chan));
  if (match || all
  || (participants && !ast_test_flag(&user->u_profile, USER_OPT_ADMIN))) {
  user->kicked = 1;
  pbx_builtin_setvar_helper(user->chan, "CONFBRIDGE_RESULT", "KICKED");
  ast_bridge_remove(conference->bridge, user->chan);
  res = 0;
  if (match) {
  return res;
  }
  }
  }
  AST_LIST_TRAVERSE(&conference->waiting_list, user, list) {
  if (user->kicked) {
  continue;
  }
  match = !strcasecmp(channel, ast_channel_name(user->chan));
  if (match || all
  || (participants && !ast_test_flag(&user->u_profile, USER_OPT_ADMIN))) {
  user->kicked = 1;
  pbx_builtin_setvar_helper(user->chan, "CONFBRIDGE_RESULT", "KICKED");
  ast_bridge_remove(conference->bridge, user->chan);
  res = 0;
  if (match) {
  return res;
  }
  }
  }
 
  return res;
 }

◆ leave_conference()

static void leave_conference ( struct confbridge_user * user )

static

Leave a conference.

Parameters

user	The conference user

Definition at line 1905 of file app_confbridge.c.

References ao2_lock, ao2_ref, ao2_unlock, ast_free, AST_LIST_REMOVE_HEAD, confbridge_user::conference, handle_conf_user_leave(), post_join_action::list, NULL, and confbridge_user::post_join_list.

Referenced by confbridge_exec(), and join_conference_bridge().

 {
  struct post_join_action *action;
 
  ao2_lock(user->conference);
  handle_conf_user_leave(user);
  ao2_unlock(user->conference);
 
  /* Discard any post-join actions */
  while ((action = AST_LIST_REMOVE_HEAD(&user->post_join_list, list))) {
  ast_free(action);
  }
 
  /* Done mucking with the conference, huzzah */
  ao2_ref(user->conference, -1);
  user->conference = NULL;
 }

◆ load_module()

static int load_module ( void )

static

Load the module.

Module loading including tests for configuration or dependencies. This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE, or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails tests return AST_MODULE_LOAD_FAILURE. If the module can not load the configuration file or other non-critical problem return AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.

Definition at line 4439 of file app_confbridge.c.

References action_confbridgekick(), action_confbridgelist(), action_confbridgelistrooms(), action_confbridgelock(), action_confbridgemute(), action_confbridgesetsinglevideosrc(), action_confbridgestartrecord(), action_confbridgestoprecord(), action_confbridgeunlock(), action_confbridgeunmute(), AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, app, app2, ARRAY_LEN, AST_CFE_WRITE, ast_cli_register_multiple, ast_custom_function_register, ast_custom_function_register_escalating, ast_log, ast_manager_register_xml, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_register_application_xml, conf_announce_get_tech(), conf_load_config(), conf_record_get_tech(), confbridge_exec(), CONFERENCE_BRIDGE_BUCKETS, conference_bridge_cmp_cb(), conference_bridge_hash_cb(), confkick_exec(), EVENT_FLAG_CALL, EVENT_FLAG_REPORTING, EVENT_FLAG_SYSTEM, LOG_ERROR, manager_confbridge_init(), NULL, register_channel_tech(), and unload_module().

Referenced by reload().

 {
  int res = 0;
 
  if (conf_load_config()) {
  ast_log(LOG_ERROR, "Unable to load config. Not loading module.\n");
  return AST_MODULE_LOAD_DECLINE;
  }
 
  if (register_channel_tech(conf_record_get_tech())
  || register_channel_tech(conf_announce_get_tech())) {
  unload_module();
  return AST_MODULE_LOAD_DECLINE;
  }
 
  /* Create a container to hold the conference bridges */
  conference_bridges = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
  CONFERENCE_BRIDGE_BUCKETS,
  conference_bridge_hash_cb, NULL, conference_bridge_cmp_cb);
  if (!conference_bridges) {
  unload_module();
  return AST_MODULE_LOAD_DECLINE;
  }
 
  /* Setup manager stasis subscriptions */
  res |= manager_confbridge_init();
 
  res |= ast_register_application_xml(app, confbridge_exec);
  res |= ast_register_application_xml(app2, confkick_exec);
 
  res |= ast_custom_function_register_escalating(&confbridge_function, AST_CFE_WRITE);
  res |= ast_custom_function_register(&confbridge_info_function);
 
  res |= ast_cli_register_multiple(cli_confbridge, ARRAY_LEN(cli_confbridge));
 
  res |= ast_manager_register_xml("ConfbridgeList", EVENT_FLAG_REPORTING, action_confbridgelist);
  res |= ast_manager_register_xml("ConfbridgeListRooms", EVENT_FLAG_REPORTING, action_confbridgelistrooms);
  res |= ast_manager_register_xml("ConfbridgeMute", EVENT_FLAG_CALL, action_confbridgemute);
  res |= ast_manager_register_xml("ConfbridgeUnmute", EVENT_FLAG_CALL, action_confbridgeunmute);
  res |= ast_manager_register_xml("ConfbridgeKick", EVENT_FLAG_CALL, action_confbridgekick);
  res |= ast_manager_register_xml("ConfbridgeUnlock", EVENT_FLAG_CALL, action_confbridgeunlock);
  res |= ast_manager_register_xml("ConfbridgeLock", EVENT_FLAG_CALL, action_confbridgelock);
  res |= ast_manager_register_xml("ConfbridgeStartRecord", EVENT_FLAG_SYSTEM, action_confbridgestartrecord);
  res |= ast_manager_register_xml("ConfbridgeStopRecord", EVENT_FLAG_SYSTEM, action_confbridgestoprecord);
  res |= ast_manager_register_xml("ConfbridgeSetSingleVideoSrc", EVENT_FLAG_CALL, action_confbridgesetsinglevideosrc);
  if (res) {
  unload_module();
  return AST_MODULE_LOAD_DECLINE;
  }
 
  return AST_MODULE_LOAD_SUCCESS;
 }

◆ play_file()

static int play_file	(	struct ast_bridge_channel *	bridge_channel,
		struct ast_channel *	channel,
		const char *	filename
	)

static

Definition at line 928 of file app_confbridge.c.

References ast_bridge_channel_feature_digit_add(), AST_DIGIT_ANY, AST_DIGIT_NONE, ast_log, ast_stopstream(), ast_stream_and_wait(), ast_bridge_channel::chan, digit, and LOG_WARNING.

Referenced by action_kick_last(), action_toggle_binaural(), action_toggle_mute(), announce_user_count(), check_bridge_play_sound(), and execute_menu_entry().

 {
  struct ast_channel *chan;
  const char *stop_digits;
  int digit;
 
  if (bridge_channel) {
  chan = bridge_channel->chan;
  stop_digits = AST_DIGIT_ANY;
  } else {
  chan = channel;
  stop_digits = AST_DIGIT_NONE;
  }
 
  digit = ast_stream_and_wait(chan, filename, stop_digits);
  if (digit < 0) {
  ast_log(LOG_WARNING, "Failed to playback file '%s' to channel\n", filename);
  return -1;
  }
 
  if (digit > 0) {
  ast_stopstream(bridge_channel->chan);
  ast_bridge_channel_feature_digit_add(bridge_channel, digit);
  return 1;
  }
 
  return 0;
 }

◆ play_prompt_to_user()

static int play_prompt_to_user	(	struct confbridge_user *	user,
		const char *	filename
	)

static

Play back an audio file to a channel.

Parameters

user	User to play audio prompt to
filename	Prompt to play

Returns: Returns 0 on success, -1 if the user hung up

Note: Generally this should be called when the conference is unlocked to avoid blocking the entire conference while the sound is played. But don't unlock the conference bridge in the middle of a state transition.

Definition at line 1038 of file app_confbridge.c.

References ast_stream_and_wait(), and confbridge_user::chan.

Referenced by conf_handle_inactive_waitmarked(), conf_handle_only_person(), and join_conference_bridge().

 {
  return ast_stream_and_wait(user->chan, filename, "");
 }

◆ play_sound_file()

int play_sound_file	(	struct confbridge_conference *	conference,
		const char *	filename
	)

Play sound file into conference bridge.

Parameters

conference	The conference bridge to play sound file into
filename	Sound file to play

Return values

0	success
-1	failure

Definition at line 2035 of file app_confbridge.c.

References play_sound_helper().

Referenced by action_toggle_mute_participants(), announce_user_count(), confbridge_exec(), and post_join_play_begin().

 {
  return play_sound_helper(conference, filename, -1);
 }

◆ play_sound_helper()

static int play_sound_helper	(	struct confbridge_conference *	conference,
		const char *	filename,
		int	say_number
	)

static

Definition at line 1997 of file app_confbridge.c.

References ast_cond_wait, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_strlen_zero, ast_taskprocessor_push(), playback_task_data::cond, playback_task_data::lock, LOG_WARNING, confbridge_conference::name, playback_task_data::playback_finished, confbridge_conference::playback_queue, playback_task(), playback_task_data_destroy(), playback_task_data_init(), and sound_file_exists().

Referenced by play_sound_file(), and play_sound_number().

 {
  struct playback_task_data ptd;
 
  /* Do not waste resources trying to play files that do not exist */
  if (ast_strlen_zero(filename)) {
  if (say_number < 0) {
  return 0;
  }
  } else if (!sound_file_exists(filename)) {
  return 0;
  }
 
  playback_task_data_init(&ptd, conference, filename, say_number);
  if (ast_taskprocessor_push(conference->playback_queue, playback_task, &ptd)) {
  if (!ast_strlen_zero(filename)) {
  ast_log(LOG_WARNING, "Unable to play file '%s' to conference %s\n",
  filename, conference->name);
  } else {
  ast_log(LOG_WARNING, "Unable to say number '%d' to conference %s\n",
  say_number, conference->name);
  }
  playback_task_data_destroy(&ptd);
  return -1;
  }
 
  /* Wait for the playback to complete */
  ast_mutex_lock(&ptd.lock);
  while (!ptd.playback_finished) {
  ast_cond_wait(&ptd.cond, &ptd.lock);
  }
  ast_mutex_unlock(&ptd.lock);
 
  playback_task_data_destroy(&ptd);
 
  return 0;
 }

◆ play_sound_number()

static int play_sound_number	(	struct confbridge_conference *	conference,
		int	say_number
	)

static

Play number into the conference bridge.

Parameters

conference	The conference bridge to say the number into
say_number	number to say

Return values

0	success
-1	failure

Definition at line 2317 of file app_confbridge.c.

References NULL, and play_sound_helper().

Referenced by announce_user_count().

 {
  return play_sound_helper(conference, NULL, say_number);
 }

◆ playback_common()

static void playback_common	(	struct confbridge_conference *	conference,
		const char *	filename,
		int	say_number
	)

static

Definition at line 1923 of file app_confbridge.c.

References ast_autoservice_start(), ast_autoservice_stop(), ast_channel_language(), ast_say_number(), ast_stream_and_wait(), ast_strlen_zero, NULL, and confbridge_conference::playback_chan.

Referenced by async_playback_task(), and playback_task().

 {
  /* Don't try to play if the playback channel has been hung up */
  if (!conference->playback_chan) {
  return;
  }
 
  ast_autoservice_stop(conference->playback_chan);
 
  /* The channel is all under our control, in goes the prompt */
  if (!ast_strlen_zero(filename)) {
  ast_stream_and_wait(conference->playback_chan, filename, "");
  } else if (say_number >= 0) {
  ast_say_number(conference->playback_chan, say_number, "",
  ast_channel_language(conference->playback_chan), NULL);
  }
 
  ast_autoservice_start(conference->playback_chan);
 }

◆ playback_task()

static int playback_task ( void * data )

static

Play an announcement into a confbridge.

This runs in the playback queue taskprocessor. This ensures that all playbacks are handled in sequence and do not play over top one another.

This task runs synchronously so there is no need for performing any sort of cleanup on the input parameter.

Parameters

data	A playback_task_data

Returns: 0

Definition at line 1965 of file app_confbridge.c.

References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, playback_task_data::cond, playback_task_data::conference, playback_task_data::filename, playback_task_data::lock, playback_common(), playback_task_data::playback_finished, and playback_task_data::say_number.

Referenced by play_sound_helper().

 {
  struct playback_task_data *ptd = data;
 
  playback_common(ptd->conference, ptd->filename, ptd->say_number);
 
  ast_mutex_lock(&ptd->lock);
  ptd->playback_finished = 1;
  ast_cond_signal(&ptd->cond);
  ast_mutex_unlock(&ptd->lock);
 
  return 0;
 }

◆ playback_task_data_destroy()

static void playback_task_data_destroy ( struct playback_task_data * ptd )

static

Definition at line 1991 of file app_confbridge.c.

References ast_cond_destroy, ast_mutex_destroy, playback_task_data::cond, and playback_task_data::lock.

Referenced by play_sound_helper().

 {
  ast_mutex_destroy(&ptd->lock);
  ast_cond_destroy(&ptd->cond);
 }

◆ playback_task_data_init()

static void playback_task_data_init	(	struct playback_task_data *	ptd,
		struct confbridge_conference *	conference,
		const char *	filename,
		int	say_number
	)

static

Definition at line 1979 of file app_confbridge.c.

References ast_cond_init, ast_mutex_init, playback_task_data::cond, hangup_data::conference, playback_task_data::conference, playback_task_data::filename, playback_task_data::lock, NULL, playback_task_data::playback_finished, and playback_task_data::say_number.

Referenced by play_sound_helper().

 {
  ast_mutex_init(&ptd->lock);
  ast_cond_init(&ptd->cond, NULL);
 
  ptd->filename = filename;
  ptd->say_number = say_number;
  ptd->conference = conference;
  ptd->playback_finished = 0;
 }

◆ push_announcer()

static int push_announcer ( struct confbridge_conference * conference )

static

Push the announcer channel into the bridge.

Parameters

conference Conference bridge to push the announcer to

Return values

0	Success
-1	Failed to push the channel to the bridge

Definition at line 1539 of file app_confbridge.c.

References ast_autoservice_start(), ast_hangup(), conf_announce_channel_push(), NULL, and confbridge_conference::playback_chan.

Referenced by join_conference_bridge().

 {
  if (conf_announce_channel_push(conference->playback_chan)) {
  ast_hangup(conference->playback_chan);
  conference->playback_chan = NULL;
  return -1;
  }
 
  ast_autoservice_start(conference->playback_chan);
  return 0;
 }

◆ register_channel_tech()

static int register_channel_tech ( struct ast_channel_tech * tech )

static

Definition at line 4377 of file app_confbridge.c.

References ast_channel_register(), ast_format_cap_alloc, ast_format_cap_append_by_type(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_log, AST_MEDIA_TYPE_UNKNOWN, ast_channel_tech::capabilities, ast_channel_tech::description, LOG_ERROR, and ast_channel_tech::type.

Referenced by load_module().

 {
  tech->capabilities = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
  if (!tech->capabilities) {
  return -1;
  }
  ast_format_cap_append_by_type(tech->capabilities, AST_MEDIA_TYPE_UNKNOWN);
  if (ast_channel_register(tech)) {
  ast_log(LOG_ERROR, "Unable to register channel technology %s(%s).\n",
  tech->type, tech->description);
  return -1;
  }
  return 0;
 }

◆ reload()

static int reload ( void )

static

Definition at line 4492 of file app_confbridge.c.

References AST_MODFLAG_LOAD_ORDER, AST_MODPRI_DEVSTATE_PROVIDER, AST_MODULE_INFO(), AST_MODULE_SUPPORT_CORE, ASTERISK_GPL_KEY, conf_reload_config(), load_module(), and unload_module().

 {
  return conf_reload_config();
 }

◆ send_conf_end_event()

static void send_conf_end_event ( struct confbridge_conference * conference )

static

Definition at line 664 of file app_confbridge.c.

References confbridge_end_type(), NULL, and send_conf_stasis().

Referenced by conf_ended().

 {
  send_conf_stasis(conference, NULL, confbridge_end_type(), NULL, 0);
 }

◆ send_conf_start_event()

static void send_conf_start_event ( struct confbridge_conference * conference )

static

Definition at line 659 of file app_confbridge.c.

References confbridge_start_type(), NULL, and send_conf_stasis().

Referenced by join_conference_bridge().

 {
  send_conf_stasis(conference, NULL, confbridge_start_type(), NULL, 0);
 }

◆ send_conf_stasis()

static void send_conf_stasis	(	struct confbridge_conference *	conference,
		struct ast_channel *	chan,
		struct stasis_message_type *	type,
		struct ast_json *	extras,
		int	channel_topic
	)

static

Definition at line 585 of file app_confbridge.c.

References ao2_cleanup, ast_bridge_blob_create(), ast_bridge_lock, ast_bridge_topic(), ast_bridge_unlock, ast_channel_topic(), ast_json_object_update(), ast_json_pack(), ast_json_unref(), ast_test_flag, confbridge_conference::b_profile, confbridge_conference::bridge, BRIDGE_OPT_ENABLE_EVENTS, conf_send_event_to_participants(), confbridge_conference::name, NULL, RAII_VAR, and stasis_publish().

Referenced by conf_handle_talker_cb(), send_conf_end_event(), send_conf_start_event(), send_join_event(), send_leave_event(), send_mute_event(), send_start_record_event(), send_stop_record_event(), and send_unmute_event().

 {
  RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
  RAII_VAR(struct ast_json *, json_object, NULL, ast_json_unref);
 
  json_object = ast_json_pack("{s: s}",
  "conference", conference->name);
  if (!json_object) {
  return;
  }
 
  if (extras) {
  ast_json_object_update(json_object, extras);
  }
 
  ast_bridge_lock(conference->bridge);
  msg = ast_bridge_blob_create(type,
  conference->bridge,
  chan,
  json_object);
  ast_bridge_unlock(conference->bridge);
  if (!msg) {
  return;
  }
 
  if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_ENABLE_EVENTS)) {
  conf_send_event_to_participants(conference, chan, msg);
  }
 
  if (channel_topic) {
  stasis_publish(ast_channel_topic(chan), msg);
  } else {
  stasis_publish(ast_bridge_topic(conference->bridge), msg);
  }
 }

◆ send_conf_stasis_snapshots()

static void send_conf_stasis_snapshots	(	struct confbridge_conference *	conference,
		struct ast_channel_snapshot *	chan_snapshot,
		struct stasis_message_type *	type,
		struct ast_json *	extras
	)

static

Definition at line 622 of file app_confbridge.c.

References ao2_cleanup, ast_bridge_blob_create_from_snapshots(), ast_bridge_lock, ast_bridge_snapshot_create(), ast_bridge_topic(), ast_bridge_unlock, ast_json_object_update(), ast_json_pack(), ast_json_unref(), confbridge_conference::bridge, confbridge_conference::name, NULL, RAII_VAR, and stasis_publish().

Referenced by confbridge_handle_atxfer().

 {
  RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
  RAII_VAR(struct ast_json *, json_object, NULL, ast_json_unref);
  RAII_VAR(struct ast_bridge_snapshot *, bridge_snapshot, NULL, ao2_cleanup);
 
  json_object = ast_json_pack("{s: s}",
  "conference", conference->name);
  if (!json_object) {
  return;
  }
 
  if (extras) {
  ast_json_object_update(json_object, extras);
  }
 
  ast_bridge_lock(conference->bridge);
  bridge_snapshot = ast_bridge_snapshot_create(conference->bridge);
  ast_bridge_unlock(conference->bridge);
  if (!bridge_snapshot) {
  return;
  }
 
  msg = ast_bridge_blob_create_from_snapshots(type,
  bridge_snapshot,
  chan_snapshot,
  json_object);
  if (!msg) {
  return;
  }
 
  stasis_publish(ast_bridge_topic(conference->bridge), msg);
 }

◆ send_event_hook_callback()

static int send_event_hook_callback	(	struct ast_bridge_channel *	bridge_channel,
		void *	data
	)

static

Definition at line 2530 of file app_confbridge.c.

References AST_BRIDGE_HOOK_TYPE_JOIN, confbridge_hook_data::conference, confbridge_hook_data::hook_type, send_join_event(), send_leave_event(), and confbridge_hook_data::user.

Referenced by confbridge_exec().

 {
  struct confbridge_hook_data *hook_data = data;
 
  if (hook_data->hook_type == AST_BRIDGE_HOOK_TYPE_JOIN) {
  send_join_event(hook_data->user, hook_data->conference);
  } else {
  send_leave_event(hook_data->user, hook_data->conference);
  }
 
  return 0;
 }

◆ send_join_event()

static void send_join_event	(	struct confbridge_user *	user,
		struct confbridge_conference *	conference
	)

static

Definition at line 669 of file app_confbridge.c.

References ast_json_pack(), ast_json_unref(), ast_test_flag, confbridge_user::chan, confbridge_join_type(), confbridge_user::muted, send_conf_stasis(), confbridge_user::u_profile, and USER_OPT_ADMIN.

Referenced by send_event_hook_callback().

 {
  struct ast_json *json_object;
 
  json_object = ast_json_pack("{s: b, s: b}",
  "admin", ast_test_flag(&user->u_profile, USER_OPT_ADMIN),
  "muted", user->muted);
  if (!json_object) {
  return;
  }
  send_conf_stasis(conference, user->chan, confbridge_join_type(), json_object, 0);
  ast_json_unref(json_object);
 }

◆ send_leave_event()

static void send_leave_event	(	struct confbridge_user *	user,
		struct confbridge_conference *	conference
	)

static

Definition at line 683 of file app_confbridge.c.

References ast_json_pack(), ast_json_unref(), ast_test_flag, confbridge_user::chan, confbridge_leave_type(), send_conf_stasis(), confbridge_user::u_profile, and USER_OPT_ADMIN.

Referenced by send_event_hook_callback().

 {
  struct ast_json *json_object;
 
  json_object = ast_json_pack("{s: b}",
  "admin", ast_test_flag(&user->u_profile, USER_OPT_ADMIN)
  );
  if (!json_object) {
  return;
  }
  send_conf_stasis(conference, user->chan, confbridge_leave_type(), json_object, 0);
  ast_json_unref(json_object);
 }

◆ send_mute_event()

static void send_mute_event	(	struct confbridge_user *	user,
		struct confbridge_conference *	conference
	)

static

Definition at line 707 of file app_confbridge.c.

References ast_json_pack(), ast_json_unref(), ast_test_flag, confbridge_user::chan, confbridge_mute_type(), send_conf_stasis(), confbridge_user::u_profile, and USER_OPT_ADMIN.

Referenced by generic_mute_unmute_user().

 {
  struct ast_json *json_object;
 
  json_object = ast_json_pack("{s: b}",
  "admin", ast_test_flag(&user->u_profile, USER_OPT_ADMIN)
  );
  if (!json_object) {
  return;
  }
  send_conf_stasis(conference, user->chan, confbridge_mute_type(), json_object, 1);
  ast_json_unref(json_object);
 }

◆ send_start_record_event()

static void send_start_record_event ( struct confbridge_conference * conference )

static

Definition at line 697 of file app_confbridge.c.

References confbridge_start_record_type(), NULL, and send_conf_stasis().

Referenced by conf_start_record().

 {
  send_conf_stasis(conference, NULL, confbridge_start_record_type(), NULL, 0);
 }

◆ send_stop_record_event()

static void send_stop_record_event ( struct confbridge_conference * conference )

static

Definition at line 702 of file app_confbridge.c.

References confbridge_stop_record_type(), NULL, and send_conf_stasis().

Referenced by conf_stop_record().

 {
  send_conf_stasis(conference, NULL, confbridge_stop_record_type(), NULL, 0);
 }

◆ send_unmute_event()

static void send_unmute_event	(	struct confbridge_user *	user,
		struct confbridge_conference *	conference
	)

static

Definition at line 721 of file app_confbridge.c.

References ast_json_pack(), ast_json_unref(), ast_test_flag, confbridge_user::chan, confbridge_unmute_type(), send_conf_stasis(), confbridge_user::u_profile, and USER_OPT_ADMIN.

Referenced by generic_mute_unmute_user().

 {
  struct ast_json *json_object;
 
  json_object = ast_json_pack("{s: b}",
  "admin", ast_test_flag(&user->u_profile, USER_OPT_ADMIN)
  );
  if (!json_object) {
  return;
  }
  send_conf_stasis(conference, user->chan, confbridge_unmute_type(), json_object, 1);
  ast_json_unref(json_object);
 }

◆ set_rec_filename()

static void set_rec_filename	(	struct confbridge_conference *	conference,
		struct ast_str **	filename,
		int	is_new
	)

static

Definition at line 735 of file app_confbridge.c.

References ast_str_append(), ast_str_reset(), ast_str_set(), ast_str_set_substr(), ast_str_strlen(), ast_strlen_zero, ast_test_flag, confbridge_conference::b_profile, BRIDGE_OPT_RECORD_FILE_APPEND, BRIDGE_OPT_RECORD_FILE_TIMESTAMP, ext, confbridge_conference::name, bridge_profile::rec_command, bridge_profile::rec_file, and bridge_profile::rec_options.

Referenced by conf_start_record().

 {
  char *rec_file = conference->b_profile.rec_file;
  char *ext;
  time_t now;
 
  if (ast_str_strlen(*filename)
  && ast_test_flag(&conference->b_profile, BRIDGE_OPT_RECORD_FILE_APPEND)
  && !is_new) {
  return;
  }
 
  time(&now);
 
  ast_str_reset(*filename);
  if (ast_strlen_zero(rec_file)) {
  ast_str_set(filename, 0, "confbridge-%s-%u.wav", conference->name,
  (unsigned int) now);
  } else if (ast_test_flag(&conference->b_profile, BRIDGE_OPT_RECORD_FILE_TIMESTAMP)) {
  /* insert time before file extension */
  ext = strrchr(rec_file, '.');
  if (ext) {
  ast_str_set_substr(filename, 0, rec_file, ext - rec_file);
  ast_str_append(filename, 0, "-%u%s", (unsigned int) now, ext);
  } else {
  ast_str_set(filename, 0, "%s-%u", rec_file, (unsigned int) now);
  }
  } else {
  ast_str_set(filename, 0, "%s", rec_file);
  }
  ast_str_append(filename, 0, ",%s%s,%s",
  ast_test_flag(&conference->b_profile, BRIDGE_OPT_RECORD_FILE_APPEND) ? "a" : "",
  conference->b_profile.rec_options,
  conference->b_profile.rec_command);
 }

◆ setup_async_playback_datastore()

static int setup_async_playback_datastore ( struct ast_channel * initiator )

static

Prepare the async playback datastore.

This is done prior to queuing an async announcement. If the datastore has not yet been created, it is allocated and initialized. If it already exists, we set it to be in "waiting" mode.

Parameters

initiator The channel that is queuing the async playback

Return values

0	Success
-1	Failure :(

Definition at line 2112 of file app_confbridge.c.

References ast_channel_datastore_add(), ast_channel_datastore_find(), ast_datastore_alloc, ast_datastore_free(), async_datastore_data_alloc(), ast_datastore::data, NULL, and async_datastore_data::wait.

Referenced by async_playback_task_data_alloc().

 {
  struct ast_datastore *async_datastore;
 
  async_datastore = ast_channel_datastore_find(initiator, &async_datastore_info, NULL);
  if (async_datastore) {
  struct async_datastore_data *add;
 
  add = async_datastore->data;
  add->wait = 1;
 
  return 0;
  }
 
  async_datastore = ast_datastore_alloc(&async_datastore_info, NULL);
  if (!async_datastore) {
  return -1;
  }
 
  async_datastore->data = async_datastore_data_alloc();
  if (!async_datastore->data) {
  ast_datastore_free(async_datastore);
  return -1;
  }
 
  ast_channel_datastore_add(initiator, async_datastore);
  return 0;
 }

◆ sound_file_exists()

static int sound_file_exists ( const char * filename )

static

Definition at line 966 of file app_confbridge.c.

References ast_fileexists(), ast_log, LOG_WARNING, and NULL.

Referenced by announce_user_count(), async_delete_name_rec(), async_play_sound_helper(), and play_sound_helper().

 {
  if (ast_fileexists(filename, NULL, NULL)) {
  return -1;
  }
  ast_log(LOG_WARNING, "File %s does not exist in any format\n", filename);
  return 0;
 }

◆ unload_module()

static int unload_module ( void )

static

Called when module is being unloaded.

Definition at line 4393 of file app_confbridge.c.

References ao2_cleanup, app, app2, ARRAY_LEN, ast_cli_unregister_multiple(), ast_custom_function_unregister(), ast_manager_unregister(), ast_unregister_application(), conf_announce_get_tech(), conf_destroy_config(), conf_record_get_tech(), manager_confbridge_shutdown(), NULL, and unregister_channel_tech().

Referenced by load_module(), and reload().

 {
  ast_unregister_application(app);
  ast_unregister_application(app2);
 
  ast_custom_function_unregister(&confbridge_function);
  ast_custom_function_unregister(&confbridge_info_function);
 
  ast_cli_unregister_multiple(cli_confbridge, ARRAY_LEN(cli_confbridge));
 
  ast_manager_unregister("ConfbridgeList");
  ast_manager_unregister("ConfbridgeListRooms");
  ast_manager_unregister("ConfbridgeMute");
  ast_manager_unregister("ConfbridgeUnmute");
  ast_manager_unregister("ConfbridgeKick");
  ast_manager_unregister("ConfbridgeUnlock");
  ast_manager_unregister("ConfbridgeLock");
  ast_manager_unregister("ConfbridgeStartRecord");
  ast_manager_unregister("ConfbridgeStopRecord");
  ast_manager_unregister("ConfbridgeSetSingleVideoSrc");
 
  /* Unsubscribe from stasis confbridge message type and clean it up. */
  manager_confbridge_shutdown();
 
  /* Get rid of the conference bridges container. Since we only allow dynamic ones none will be active. */
  ao2_cleanup(conference_bridges);
  conference_bridges = NULL;
 
  conf_destroy_config();
 
  unregister_channel_tech(conf_announce_get_tech());
  unregister_channel_tech(conf_record_get_tech());
 
  return 0;
 }

◆ unregister_channel_tech()

static void unregister_channel_tech ( struct ast_channel_tech * tech )

static

Definition at line 4361 of file app_confbridge.c.

References ao2_cleanup, ast_channel_unregister(), and ast_channel_tech::capabilities.

Referenced by unload_module().

 {
  ast_channel_unregister(tech);
  ao2_cleanup(tech->capabilities);
 }

◆ user_timeout()

static int user_timeout	(	struct ast_bridge_channel *	bridge_channel,
		void *	ignore
	)

static

Definition at line 2392 of file app_confbridge.c.

References ast_bridge_channel_leave_bridge(), BRIDGE_CHANNEL_STATE_END, ast_bridge_channel::chan, and pbx_builtin_setvar_helper().

Referenced by confbridge_exec().

 {
  ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END, 0);
  pbx_builtin_setvar_helper(bridge_channel->chan, "CONFBRIDGE_RESULT", "TIMEOUT");
  return -1;
 }

◆ wait_for_initiator()

static void wait_for_initiator ( struct ast_channel * initiator )

static

Wait for the initiator of an async playback to be ready.

See the description on the async_datastore_info structure for more information about what this is about.

Parameters

initiator The channel that queued the async announcement

Definition at line 2201 of file app_confbridge.c.

References ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, ast_cond_wait, ast_mutex_lock, ast_mutex_unlock, async_datastore_data::cond, ast_datastore::data, async_datastore_data::lock, NULL, and async_datastore_data::wait.

Referenced by async_playback_task().

 {
  struct ast_datastore *async_datastore;
  struct async_datastore_data *add;
 
  ast_channel_lock(initiator);
  async_datastore = ast_channel_datastore_find(initiator, &async_datastore_info, NULL);
  ast_channel_unlock(initiator);
 
  if (!async_datastore) {
  return;
  }
 
  add = async_datastore->data;
 
  ast_mutex_lock(&add->lock);
  while (add->wait) {
  ast_cond_wait(&add->cond, &add->lock);
  }
  ast_mutex_unlock(&add->lock);
 }

Variable Documentation

◆ __mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Conference Bridge Application" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_DEVSTATE_PROVIDER, .optional_modules = "codec_speex,func_jitterbuffer", }

static

Definition at line 4504 of file app_confbridge.c.

◆ app

const char app[] = "ConfBridge"

static

Playing back a file to a channel in a conference: You might notice in this application that while playing a sound file to a channel the actual conference bridge lock is not held. This is done so that other channels are not blocked from interacting with the conference bridge. Unfortunately because of this it is possible for things to change after the sound file is done being played. Data must therefore be checked after reacquiring the conference bridge lock if it is important.

Definition at line 459 of file app_confbridge.c.

Referenced by confbridge_exec(), join_conference_bridge(), load_module(), and unload_module().

◆ app2

const char app2[] = "ConfKick"

static

Definition at line 460 of file app_confbridge.c.

Referenced by _macro_exec(), load_module(), and unload_module().

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 4504 of file app_confbridge.c.

◆ async_datastore_info

struct ast_datastore_info async_datastore_info

static

Initial value:

= {
 .type = "Confbridge async playback",
 .destroy = async_datastore_data_destroy,
}

Datastore used for timing of async announcement playback.

Announcements that are played to the entire conference can be played asynchronously (i.e. The channel that queues the playback does not wait for the playback to complete before continuing)

The thing about async announcements is that the channel that queues the announcement is either not in the bridge or is in some other way "occupied" at the time the announcement is queued. Because of that, the initiator of the announcement may enter after the announcement has already started, resulting in the sound being "clipped".

This datastore makes it so that the channel that queues the async announcement can say "I'm ready now". This way the announcement does not start until the initiator of the announcement is ready to hear the sound.

Definition at line 2080 of file app_confbridge.c.

◆ cli_confbridge

struct ast_cli_entry cli_confbridge[]

static

Definition at line 3800 of file app_confbridge.c.

◆ confbridge_function

struct ast_custom_function confbridge_function

static

Initial value:

= {
 .name = "CONFBRIDGE",
 .write = func_confbridge_helper,
}

Definition at line 3810 of file app_confbridge.c.

◆ confbridge_info_function

struct ast_custom_function confbridge_info_function

static

Initial value:

= {
 .name = "CONFBRIDGE_INFO",
 .read = func_confbridge_info,
}

Definition at line 3816 of file app_confbridge.c.

◆ conference_bridges

struct ao2_container* conference_bridges

Container to hold all conference bridges in progress.

Definition at line 469 of file app_confbridge.c.

Referenced by announce_request().

Data Structures

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ CONFERENCE_BRIDGE_BUCKETS

◆ RECORD_FILENAME_INITIAL_SPACE

Function Documentation

◆ __reg_module()

◆ __unreg_module()

◆ action_confbridgekick()

◆ action_confbridgelist()

◆ action_confbridgelist_item()

◆ action_confbridgelistrooms()

◆ action_confbridgelock()

◆ action_confbridgemute()

◆ action_confbridgesetsinglevideosrc()

◆ action_confbridgestartrecord()

◆ action_confbridgestoprecord()

◆ action_confbridgeunlock()

◆ action_confbridgeunmute()

◆ action_dialplan_exec()

◆ action_kick_last()

◆ action_lock_unlock_helper()

◆ action_mute_unmute_helper()

◆ action_playback()

◆ action_playback_and_continue()

◆ action_toggle_binaural()

◆ action_toggle_mute()

◆ action_toggle_mute_participants()

◆ alloc_playback_chan()

◆ announce_user_count()

◆ AST_MODULE_SELF_SYM()

◆ async_datastore_data_alloc()

◆ async_datastore_data_destroy()

◆ async_delete_name_rec()

◆ async_delete_name_rec_task()

◆ async_delete_name_rec_task_data_alloc()

◆ async_delete_name_rec_task_data_destroy()

◆ async_play_sound_file()

◆ async_play_sound_helper()

◆ async_play_sound_ready()

◆ async_playback_task()

◆ async_playback_task_data_alloc()

◆ async_playback_task_data_destroy()

◆ cli_mute_unmute_helper()

◆ complete_confbridge_name()

◆ complete_confbridge_participant()

◆ conf_add_post_join_action()

◆ conf_add_user_active()

◆ conf_add_user_marked()

◆ conf_add_user_waiting()

◆ conf_ended()

◆ conf_find_bridge()

◆ conf_get_pin()

◆ conf_get_sound()

◆ conf_handle_dtmf()

◆ conf_handle_first_join()

◆ conf_handle_inactive_waitmarked()

◆ conf_handle_only_person()

◆ conf_handle_second_active()

◆ conf_handle_talker_cb()

◆ conf_is_recording()

◆ conf_moh_start()

◆ conf_moh_stop()

◆ conf_moh_suspend()

◆ conf_moh_unsuspend()

◆ conf_mute_only_active()

◆ conf_rec_name()

◆ conf_remove_user_active()

◆ conf_remove_user_marked()

◆ conf_remove_user_waiting()

◆ conf_start_record()

◆ conf_stop_record()

◆ conf_update_user_mute()

◆ confbridge_exec()

◆ confbridge_handle_atxfer()

◆ confbridge_unlock_and_unref()

◆ conference_bridge_cmp_cb()