app_meetme.c File Reference

Meet me conference bridge and Shared Line Appearances. More...

#include "asterisk.h"
#include <dahdi/user.h>
#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/config.h"
#include "asterisk/app.h"
#include "asterisk/dsp.h"
#include "asterisk/musiconhold.h"
#include "asterisk/manager.h"
#include "asterisk/cli.h"
#include "asterisk/say.h"
#include "asterisk/utils.h"
#include "asterisk/translate.h"
#include "asterisk/ulaw.h"
#include "asterisk/astobj2.h"
#include "asterisk/devicestate.h"
#include "asterisk/dial.h"
#include "asterisk/causes.h"
#include "asterisk/paths.h"
#include "asterisk/test.h"
#include "asterisk/stasis.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_message_router.h"
#include "asterisk/json.h"
#include "asterisk/format_compatibility.h"
#include "enter.h"
#include "leave.h"

Include dependency graph for app_meetme.c:

Go to the source code of this file.

Data Structures
struct	announce_listitem
struct	ast_conf_user
	The MeetMe User object. More...
struct	ast_conference
	The MeetMe Conference object. More...
struct	confs
struct	dial_trunk_args
struct	run_station_args
struct	sla_event
struct	sla_failed_station
	A station that failed to be dialed. More...
struct	sla_ringing_station
	A station that is ringing. More...
struct	sla_ringing_trunk
	A trunk that is ringing. More...
struct	sla_station
struct	sla_station_ref
	A reference to a station. More...
struct	sla_trunk
struct	sla_trunk_ref
	A station's reference to a trunk. More...
struct	volume

Macros
#define	AST_FRAME_BITS   32
#define	CONF_SIZE   320
#define	CONFFLAG_DONT_DENOISE   (1ULL << 35)
#define	CONFFLAG_INTROMSG   (1ULL << 32)
#define	CONFFLAG_INTROUSER_VMREC   (1ULL << 33)
#define	CONFFLAG_KILL_LAST_MAN_STANDING   (1ULL << 34)
#define	CONFFLAG_NO_AUDIO_UNTIL_UP   (1ULL << 31)
#define	CONFIG_FILE_NAME   "meetme.conf"
#define	DATE_FORMAT   "%Y-%m-%d %H:%M:%S"
#define	DEFAULT_AUDIO_BUFFERS   32
#define	MAX_CONFNUM   80
#define	MAX_PIN   80
#define	MAX_SETTINGS   (MAX_CONFNUM + MAX_PIN + MAX_PIN + 3)
#define	MC_DATA_FORMAT   "%-12.12s %4.4d %4.4s %02d:%02d:%02d %-8s %-6s\n"
#define	MC_HEADER_FORMAT   "%-14s %-14s %-10s %-8s %-8s %-6s\n"
#define	MEETME_DELAYDETECTENDTALK   1000
#define	MEETME_DELAYDETECTTALK   300
#define	OPTIONS_LEN   100
#define	S(e)   case e: return # e;
#define	SLA_CONFIG_FILE   "sla.conf"
#define	STR_CONCISE   "concise"

Enumerations
enum	{   ADMINFLAG_MUTED = (1 << 1) , ADMINFLAG_SELFMUTED = (1 << 2) , ADMINFLAG_KICKME = (1 << 3) , ADMINFLAG_T_REQUEST = (1 << 4) ,   ADMINFLAG_HANGUP = (1 << 5) }
enum	{   CONFFLAG_ADMIN = (1 << 0) , CONFFLAG_MONITOR = (1 << 1) , CONFFLAG_KEYEXIT = (1 << 2) , CONFFLAG_STARMENU = (1 << 3) ,   CONFFLAG_TALKER = (1 << 4) , CONFFLAG_QUIET = (1 << 5) , CONFFLAG_ANNOUNCEUSERCOUNT = (1 << 6) , CONFFLAG_AGI = (1 << 7) ,   CONFFLAG_MOH = (1 << 8) , CONFFLAG_MARKEDEXIT = (1 << 9) , CONFFLAG_WAITMARKED = (1 << 10) , CONFFLAG_EXIT_CONTEXT = (1 << 11) ,   CONFFLAG_MARKEDUSER = (1 << 12) , CONFFLAG_INTROUSER = (1 << 13) , CONFFLAG_RECORDCONF = (1<< 14) , CONFFLAG_MONITORTALKER = (1 << 15) ,   CONFFLAG_DYNAMIC = (1 << 16) , CONFFLAG_DYNAMICPIN = (1 << 17) , CONFFLAG_EMPTY = (1 << 18) , CONFFLAG_EMPTYNOPIN = (1 << 19) ,   CONFFLAG_ALWAYSPROMPT = (1 << 20) , CONFFLAG_OPTIMIZETALKER = (1 << 21) , CONFFLAG_NOONLYPERSON = (1 << 22) , CONFFLAG_INTROUSERNOREVIEW = (1 << 23) ,   CONFFLAG_STARTMUTED = (1 << 24) , CONFFLAG_PASS_DTMF = (1 << 25) , CONFFLAG_SLA_STATION = (1 << 26) , CONFFLAG_SLA_TRUNK = (1 << 27) ,   CONFFLAG_KICK_CONTINUE = (1 << 28) , CONFFLAG_DURATION_STOP = (1 << 29) , CONFFLAG_DURATION_LIMIT = (1 << 30) }
enum	{   OPT_ARG_WAITMARKED = 0 , OPT_ARG_EXITKEYS = 1 , OPT_ARG_DURATION_STOP = 2 , OPT_ARG_DURATION_LIMIT = 3 ,   OPT_ARG_MOH_CLASS = 4 , OPT_ARG_INTROMSG = 5 , OPT_ARG_INTROUSER_VMREC = 6 , OPT_ARG_ARRAY_SIZE = 7 }
enum	{ SLA_TRUNK_OPT_MOH = (1 << 0) }
enum	{ SLA_TRUNK_OPT_ARG_MOH_CLASS = 0 , SLA_TRUNK_OPT_ARG_ARRAY_SIZE = 1 }
enum	announcetypes { CONF_HASJOIN , CONF_HASLEFT }
enum	entrance_sound { ENTER , LEAVE }
enum	menu_modes { MENU_DISABLED = 0 , MENU_NORMAL , MENU_ADMIN , MENU_ADMIN_EXTENDED }
enum	recording_state { MEETME_RECORD_OFF , MEETME_RECORD_STARTED , MEETME_RECORD_ACTIVE , MEETME_RECORD_TERMINATE }
enum	sla_event_type { SLA_EVENT_HOLD , SLA_EVENT_DIAL_STATE , SLA_EVENT_RINGING_TRUNK }
	Event types that can be queued up for the SLA thread. More...
enum	sla_hold_access { SLA_HOLD_OPEN , SLA_HOLD_PRIVATE }
enum	sla_station_hangup { SLA_STATION_HANGUP_NORMAL , SLA_STATION_HANGUP_TIMEOUT }
enum	sla_trunk_state {   SLA_TRUNK_STATE_IDLE , SLA_TRUNK_STATE_RINGING , SLA_TRUNK_STATE_UP , SLA_TRUNK_STATE_ONHOLD ,   SLA_TRUNK_STATE_ONHOLD_BYME }
enum	sla_which_trunk_refs { ALL_TRUNK_REFS , INACTIVE_TRUNK_REFS }
enum	volume_action { VOL_UP , VOL_DOWN }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static int	acf_meetme_info (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int	acf_meetme_info_eval (const char *keyword, const struct ast_conference *conf)
static int	action_meetmelist (struct mansession *s, const struct message *m)
static int	action_meetmelistrooms (struct mansession *s, const struct message *m)
static int	action_meetmemute (struct mansession *s, const struct message *m)
static int	action_meetmeunmute (struct mansession *s, const struct message *m)
static int	admin_exec (struct ast_channel *chan, const char *data)
	The MeetMeAdmin application. More...
static void *	announce_thread (void *data)
static void	answer_trunk_chan (struct ast_channel *chan)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static struct ast_conference *	build_conf (const char *confno, const char *pin, const char *pinadmin, int make, int dynamic, int refcount, const struct ast_channel *chan, struct ast_test *test)
	Find or create a conference. More...
static int	can_write (struct ast_channel *chan, struct ast_flags64 *confflags)
static int	careful_write (int fd, unsigned char *data, int len, int block)
static int	channel_admin_exec (struct ast_channel *chan, const char *data)
	The MeetMeChannelAdmin application MeetMeChannelAdmin(channel, command) More...
static char *	complete_confno (const char *word, int state)
static char *	complete_meetmecmd_list (const char *line, const char *word, int pos, int state)
static char *	complete_meetmecmd_lock (const char *word, int pos, int state)
static char *	complete_meetmecmd_mute_kick (const char *line, const char *word, int pos, int state)
static char *	complete_userno (struct ast_conference *cnf, const char *word, int state)
static int	conf_exec (struct ast_channel *chan, const char *data)
	The meetme() application. More...
static void	conf_flush (int fd, struct ast_channel *chan)
static int	conf_free (struct ast_conference *conf)
	Remove the conference from the list and free it. More...
static void	conf_play (struct ast_channel *chan, struct ast_conference *conf, enum entrance_sound sound)
static void	conf_queue_dtmf (const struct ast_conference *conf, const struct ast_conf_user *sender, struct ast_frame *f)
static int	conf_run (struct ast_channel *chan, struct ast_conference *conf, struct ast_flags64 *confflags, char *optargs[])
static void	conf_start_moh (struct ast_channel *chan, const char *musicclass)
static int	count_exec (struct ast_channel *chan, const char *data)
	The MeetmeCount application. More...
static struct sla_trunk_ref *	create_trunk_ref (struct sla_trunk *trunk)
static void *	dial_trunk (void *data)
static int	dispose_conf (struct ast_conference *conf)
	Decrement reference counts, as incremented by find_conf() More...
static void	filename_parse (char *filename, char *buffer)
static struct ast_conference *	find_conf (struct ast_channel *chan, char *confno, int make, int dynamic, char *dynamic_pin, size_t pin_buf_len, int refcount, struct ast_flags64 *confflags)
static struct ast_conference *	find_conf_realtime (struct ast_channel *chan, char *confno, int make, int dynamic, char *dynamic_pin, size_t pin_buf_len, int refcount, struct ast_flags64 *confflags, int *too_early, char **optargs)
static struct ast_conf_user *	find_user (struct ast_conference *conf, const char *callerident)
static const char *	get_announce_filename (enum announcetypes type)
static const char *	istalking (int x)
static int	load_config (int reload)
static void	load_config_meetme (int reload)
static int	load_module (void)
	Load the module. More...
static char *	meetme_cmd_helper (struct ast_cli_args *a)
static char *	meetme_kick_cmd (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	meetme_lock_cmd (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void	meetme_menu (enum menu_modes *menu_mode, int *dtmf, struct ast_conference *conf, struct ast_flags64 *confflags, struct ast_channel *chan, struct ast_conf_user *user, char *recordingtmp, int recordingtmp_size, struct ast_format_cap *cap_slin)
static void	meetme_menu_admin (enum menu_modes *menu_mode, int *dtmf, struct ast_conference *conf, struct ast_flags64 *confflags, struct ast_channel *chan, struct ast_conf_user *user)
static void	meetme_menu_admin_extended (enum menu_modes *menu_mode, int *dtmf, struct ast_conference *conf, struct ast_flags64 *confflags, struct ast_channel *chan, struct ast_conf_user *user, char *recordingtmp, int recordingtmp_size, struct ast_format_cap *cap_slin)
static void	meetme_menu_normal (enum menu_modes *menu_mode, int *dtmf, struct ast_conference *conf, struct ast_flags64 *confflags, struct ast_channel *chan, struct ast_conf_user *user)
static char *	meetme_mute_cmd (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void	meetme_set_defaults (void)
static char *	meetme_show_cmd (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void	meetme_stasis_cb (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void	meetme_stasis_cleanup (void)
static void	meetme_stasis_generate_msg (struct ast_conference *meetme_conference, struct ast_channel *chan, struct ast_conf_user *user, struct stasis_message_type *message_type, struct ast_json *extras)
static int	meetme_stasis_init (void)
static int	meetmemute (struct mansession *s, const struct message *m, int mute)
static enum ast_device_state	meetmestate (const char *data)
	Callback for devicestate providers. More...
static struct sla_ringing_trunk *	queue_ringing_trunk (struct sla_trunk *trunk)
static void *	recordthread (void *args)
static int	reload (void)
static void	reset_volumes (struct ast_conf_user *user)
static int	rt_extend_conf (const char *confno)
static void *	run_station (void *data)
static void	send_talking_event (struct ast_channel *chan, struct ast_conference *conf, struct ast_conf_user *user, int talking)
static int	set_listen_volume (struct ast_conf_user *user, int volume)
static int	set_talk_volume (struct ast_conf_user *user, int volume)
static void	set_user_talking (struct ast_channel *chan, struct ast_conference *conf, struct ast_conf_user *user, int talking, int monitor)
static void	sla_add_trunk_to_station (struct sla_station *station, struct ast_variable *var)
static int	sla_build_station (struct ast_config *cfg, const char *cat)
static int	sla_build_trunk (struct ast_config *cfg, const char *cat)
static int	sla_calc_station_delays (unsigned int *timeout)
	Calculate the ring delay for a station. More...
static int	sla_calc_station_timeouts (unsigned int *timeout)
	Process station ring timeouts. More...
static int	sla_calc_trunk_timeouts (unsigned int *timeout)
	Process trunk ring timeouts. More...
static void	sla_change_trunk_state (const struct sla_trunk *trunk, enum sla_trunk_state state, enum sla_which_trunk_refs inactive_only, const struct sla_trunk_ref *exclude)
static int	sla_check_device (const char *device)
static int	sla_check_failed_station (const struct sla_station *station)
	Check to see if this station has failed to be dialed in the past minute. More...
static int	sla_check_inuse_station (const struct sla_station *station)
	Check to see if a station is in use. More...
static int	sla_check_ringing_station (const struct sla_station *station)
	Check to see if this station is already ringing. More...
static int	sla_check_station_delay (struct sla_station *station, struct sla_ringing_trunk *ringing_trunk)
	Calculate the ring delay for a given ringing trunk on a station. More...
static int	sla_check_station_hold_access (const struct sla_trunk *trunk, const struct sla_station *station)
static int	sla_check_timed_out_station (const struct sla_ringing_trunk *ringing_trunk, const struct sla_station *station)
	Check to see if dialing this station already timed out for this ringing trunk. More...
static struct sla_trunk_ref *	sla_choose_idle_trunk (const struct sla_station *station)
	For a given station, choose the highest priority idle trunk. More...
static struct sla_ringing_trunk *	sla_choose_ringing_trunk (struct sla_station *station, struct sla_trunk_ref **trunk_ref, int rm)
	Choose the highest priority ringing trunk for a station. More...
static struct sla_failed_station *	sla_create_failed_station (struct sla_station *station)
static struct sla_ringing_station *	sla_create_ringing_station (struct sla_station *station)
static struct sla_station_ref *	sla_create_station_ref (struct sla_station *station)
static void	sla_destroy (void)
static void	sla_dial_state_callback (struct ast_dial *dial)
static void	sla_event_destroy (struct sla_event *event)
static void	sla_failed_station_destroy (struct sla_failed_station *failed_station)
static struct sla_station *	sla_find_station (const char *name)
static struct sla_trunk *	sla_find_trunk (const char *name)
static struct sla_trunk_ref *	sla_find_trunk_ref (const struct sla_station *station, const struct sla_trunk *trunk)
static struct sla_trunk_ref *	sla_find_trunk_ref_byname (const struct sla_station *station, const char *name)
	Find a trunk reference on a station by name. More...
static void	sla_handle_dial_state_event (void)
static void	sla_handle_hold_event (struct sla_event *event)
static void	sla_handle_ringing_trunk_event (void)
static void	sla_hangup_stations (void)
static const char *	sla_hold_str (unsigned int hold_access)
static int	sla_in_use (void)
static int	sla_load_config (int reload)
static int	sla_process_timers (struct timespec *ts)
	Calculate the time until the next known event. More...
static void	sla_queue_event (enum sla_event_type type)
static void	sla_queue_event_conf (enum sla_event_type type, struct ast_channel *chan, struct ast_conference *conf)
	Queue a SLA event from the conference. More...
static void	sla_queue_event_full (enum sla_event_type type, struct sla_trunk_ref *trunk_ref, struct sla_station *station, int lock)
static void	sla_queue_event_nolock (enum sla_event_type type)
static int	sla_ring_station (struct sla_ringing_trunk *ringing_trunk, struct sla_station *station)
	Ring a station. More...
static void	sla_ring_stations (void)
	Ring stations based on current set of ringing trunks. More...
static void	sla_ringing_station_destroy (struct sla_ringing_station *ringing_station)
static void	sla_ringing_trunk_destroy (struct sla_ringing_trunk *ringing_trunk)
static char *	sla_show_stations (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	sla_show_trunks (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static enum ast_device_state	sla_state (const char *data)
static enum ast_device_state	sla_state_to_devstate (enum sla_trunk_state state)
static int	sla_station_cmp (void *obj, void *arg, int flags)
static void	sla_station_destructor (void *obj)
static int	sla_station_exec (struct ast_channel *chan, const char *data)
static int	sla_station_is_marked (void *obj, void *arg, int flags)
static int	sla_station_mark (void *obj, void *arg, int flags)
static void	sla_station_ref_destructor (void *obj)
static int	sla_station_release_refs (void *obj, void *arg, int flags)
static void	sla_stop_ringing_station (struct sla_ringing_station *ringing_station, enum sla_station_hangup hangup)
static void	sla_stop_ringing_trunk (struct sla_ringing_trunk *ringing_trunk)
static void *	sla_thread (void *data)
static int	sla_trunk_cmp (void *obj, void *arg, int flags)
static void	sla_trunk_destructor (void *obj)
static int	sla_trunk_exec (struct ast_channel *chan, const char *data)
static int	sla_trunk_is_marked (void *obj, void *arg, int flags)
static int	sla_trunk_mark (void *obj, void *arg, int flags)
static void	sla_trunk_ref_destructor (void *obj)
static int	sla_trunk_release_refs (void *obj, void *arg, int flags)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (meetme_end_type)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (meetme_join_type)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (meetme_leave_type)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (meetme_mute_type)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (meetme_talk_request_type)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (meetme_talking_type)
static struct ast_json *	status_to_json (int on)
static const char *	trunkstate2str (enum sla_trunk_state state)
static void	tweak_listen_volume (struct ast_conf_user *user, enum volume_action action)
static void	tweak_talk_volume (struct ast_conf_user *user, enum volume_action action)
static void	tweak_volume (struct volume *vol, enum volume_action action)
static int	unload_module (void)
static int	user_chan_cb (void *obj, void *args, int flags)
static int	user_listen_voldown_cb (void *obj, void *unused, int flags)
static int	user_listen_volup_cb (void *obj, void *unused, int flags)
static int	user_max_cmp (void *obj, void *arg, int flags)
static int	user_no_cmp (void *obj, void *arg, int flags)
static int	user_reset_vol_cb (void *obj, void *unused, int flags)
static int	user_set_hangup_cb (void *obj, void *check_admin_arg, int flags)
static int	user_set_kickme_cb (void *obj, void *check_admin_arg, int flags)
static int	user_set_muted_cb (void *obj, void *check_admin_arg, int flags)
static int	user_set_unmuted_cb (void *obj, void *check_admin_arg, int flags)
static int	user_talk_voldown_cb (void *obj, void *unused, int flags)
static int	user_talk_volup_cb (void *obj, void *unused, int flags)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "MeetMe conference bridge" , .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 = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_DEPRECATED, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_DEVSTATE_PROVIDER, .optional_modules = "func_speex", }
static const char *const	app = "MeetMe"
static const char *const	app2 = "MeetMeCount"
static const char *const	app3 = "MeetMeAdmin"
static const char *const	app4 = "MeetMeChannelAdmin"
static const struct ast_module_info *	ast_module_info = &__mod_info
static int	audio_buffers
	The number of audio buffers to be allocated on pseudo channels when in a conference. More...
static struct ast_cli_entry	cli_meetme []
static unsigned int	conf_map [1024] = {0, }
static struct confs	confs = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }
static int	earlyalert
static int	endalert
static int	extendby
static int	fuzzystart
static const char	gain_map []
	Map 'volume' levels from -5 through +5 into decibel (dB) settings for channel drivers. More...
static struct stasis_message_router *	meetme_event_message_router
static struct ast_custom_function	meetme_info_acf
static const struct ast_app_option	meetme_opts [128] = { [ 'A' ] = { .flag = CONFFLAG_MARKEDUSER }, [ 'a' ] = { .flag = CONFFLAG_ADMIN }, [ 'b' ] = { .flag = CONFFLAG_AGI }, [ 'c' ] = { .flag = CONFFLAG_ANNOUNCEUSERCOUNT }, [ 'C' ] = { .flag = CONFFLAG_KICK_CONTINUE }, [ 'D' ] = { .flag = CONFFLAG_DYNAMICPIN }, [ 'd' ] = { .flag = CONFFLAG_DYNAMIC }, [ 'E' ] = { .flag = CONFFLAG_EMPTYNOPIN }, [ 'e' ] = { .flag = CONFFLAG_EMPTY }, [ 'F' ] = { .flag = CONFFLAG_PASS_DTMF }, [ 'G' ] = { .flag = (1ULL << 32) , .arg_index = OPT_ARG_INTROMSG + 1 }, [ 'v' ] = { .flag = (1ULL << 33) , .arg_index = OPT_ARG_INTROUSER_VMREC + 1 }, [ 'i' ] = { .flag = CONFFLAG_INTROUSER }, [ 'I' ] = { .flag = CONFFLAG_INTROUSERNOREVIEW }, [ 'k' ] = { .flag = (1ULL << 34) }, [ 'M' ] = { .flag = CONFFLAG_MOH , .arg_index = OPT_ARG_MOH_CLASS + 1 }, [ 'm' ] = { .flag = CONFFLAG_STARTMUTED }, [ 'n' ] = { .flag = (1ULL << 35) }, [ 'o' ] = { .flag = CONFFLAG_OPTIMIZETALKER }, [ 'P' ] = { .flag = CONFFLAG_ALWAYSPROMPT }, [ 'p' ] = { .flag = CONFFLAG_KEYEXIT , .arg_index = OPT_ARG_EXITKEYS + 1 }, [ 'q' ] = { .flag = CONFFLAG_QUIET }, [ 'r' ] = { .flag = CONFFLAG_RECORDCONF }, [ 's' ] = { .flag = CONFFLAG_STARMENU }, [ 'T' ] = { .flag = CONFFLAG_MONITORTALKER }, [ 'l' ] = { .flag = CONFFLAG_MONITOR }, [ 't' ] = { .flag = CONFFLAG_TALKER }, [ 'w' ] = { .flag = CONFFLAG_WAITMARKED , .arg_index = OPT_ARG_WAITMARKED + 1 }, [ 'X' ] = { .flag = CONFFLAG_EXIT_CONTEXT }, [ 'x' ] = { .flag = CONFFLAG_MARKEDEXIT }, [ '1' ] = { .flag = CONFFLAG_NOONLYPERSON }, [ 'S' ] = { .flag = CONFFLAG_DURATION_STOP , .arg_index = OPT_ARG_DURATION_STOP + 1 }, [ 'L' ] = { .flag = CONFFLAG_DURATION_LIMIT , .arg_index = OPT_ARG_DURATION_LIMIT + 1 }, }
static int	rt_log_members
static int	rt_schedule
struct {
unsigned int   attempt_callerid:1
ast_cond_t   cond
struct {
struct sla_event *   first
struct sla_event *   last
}   event_q
struct {
struct sla_failed_station *   first
struct sla_failed_station *   last
}   failed_stations
ast_mutex_t   lock
struct {
struct sla_ringing_station *   first
struct sla_ringing_station *   last
}   ringing_stations
struct {
struct sla_ringing_trunk *   first
struct sla_ringing_trunk *   last
}   ringing_trunks
unsigned int   stop:1
pthread_t   thread
}	sla
	A structure for data used by the sla thread. More...
static const char	sla_registrar [] = "SLA"
static struct ao2_container *	sla_stations
static const struct ast_app_option	sla_trunk_opts [128] = { [ 'M' ] = { .flag = SLA_TRUNK_OPT_MOH , .arg_index = SLA_TRUNK_OPT_ARG_MOH_CLASS + 1 }, }
static struct ao2_container *	sla_trunks
static const char *const	slastation_app = "SLAStation"
static const char *const	slatrunk_app = "SLATrunk"

Detailed Description

Meet me conference bridge and Shared Line Appearances.

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

(SLA) Russell Bryant russe.nosp@m.ll@d.nosp@m.igium.nosp@m..com

Definition in file app_meetme.c.

Macro Definition Documentation

AST_FRAME_BITS

#define AST_FRAME_BITS   32

Definition at line 666 of file app_meetme.c.

CONF_SIZE

#define CONF_SIZE   320

Definition at line 685 of file app_meetme.c.

CONFFLAG_DONT_DENOISE

#define CONFFLAG_DONT_DENOISE   (1ULL << 35)

If set, don't enable a denoiser for the channel

Definition at line 755 of file app_meetme.c.

CONFFLAG_INTROMSG

#define CONFFLAG_INTROMSG   (1ULL << 32)

If set play an intro announcement at start of conference

Definition at line 750 of file app_meetme.c.

CONFFLAG_INTROUSER_VMREC

#define CONFFLAG_INTROUSER_VMREC   (1ULL << 33)

Definition at line 751 of file app_meetme.c.

CONFFLAG_KILL_LAST_MAN_STANDING

#define CONFFLAG_KILL_LAST_MAN_STANDING   (1ULL << 34)

If there's only one person left in a conference when someone leaves, kill the conference

Definition at line 753 of file app_meetme.c.

CONFFLAG_NO_AUDIO_UNTIL_UP

#define CONFFLAG_NO_AUDIO_UNTIL_UP   (1ULL << 31)

Do not write any audio to this channel until the state is up.

Definition at line 749 of file app_meetme.c.

CONFIG_FILE_NAME

#define CONFIG_FILE_NAME   "meetme.conf"

Definition at line 644 of file app_meetme.c.

DATE_FORMAT

#define DATE_FORMAT   "%Y-%m-%d %H:%M:%S"

String format for scheduled conferences

Definition at line 652 of file app_meetme.c.

DEFAULT_AUDIO_BUFFERS

#define DEFAULT_AUDIO_BUFFERS   32

each buffer is 20ms, so this is 640ms total

Definition at line 649 of file app_meetme.c.

MAX_CONFNUM

#define MAX_CONFNUM   80

Definition at line 821 of file app_meetme.c.

MAX_PIN

#define MAX_PIN   80

Definition at line 822 of file app_meetme.c.

MAX_SETTINGS

#define MAX_SETTINGS   (MAX_CONFNUM + MAX_PIN + MAX_PIN + 3)

Definition at line 826 of file app_meetme.c.

MC_DATA_FORMAT

#define MC_DATA_FORMAT   "%-12.12s %4.4d %4.4s %02d:%02d:%02d %-8s %-6s\n"

MC_HEADER_FORMAT

#define MC_HEADER_FORMAT   "%-14s %-14s %-10s %-8s %-8s %-6s\n"

MEETME_DELAYDETECTENDTALK

#define MEETME_DELAYDETECTENDTALK   1000

Definition at line 664 of file app_meetme.c.

MEETME_DELAYDETECTTALK

#define MEETME_DELAYDETECTTALK   300

Definition at line 663 of file app_meetme.c.

OPTIONS_LEN

#define OPTIONS_LEN   100

Definition at line 823 of file app_meetme.c.

S

#define S

(

e

)

case e: return # e;

SLA_CONFIG_FILE

#define SLA_CONFIG_FILE   "sla.conf"

Definition at line 645 of file app_meetme.c.

STR_CONCISE

#define STR_CONCISE   "concise"

Definition at line 646 of file app_meetme.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
ADMINFLAG_MUTED	User is muted
ADMINFLAG_SELFMUTED	User muted self
ADMINFLAG_KICKME	User has been kicked
ADMINFLAG_T_REQUEST	User has requested to speak
ADMINFLAG_HANGUP	User will be leaving the conference

Definition at line 654 of file app_meetme.c.

     {
    ADMINFLAG_MUTED =     (1 << 1), /*!< User is muted */
    ADMINFLAG_SELFMUTED = (1 << 2), /*!< User muted self */
    ADMINFLAG_KICKME =    (1 << 3),  /*!< User has been kicked */
    /*! User has requested to speak */
    ADMINFLAG_T_REQUEST = (1 << 4),
    ADMINFLAG_HANGUP = (1 << 5),    /*!< User will be leaving the conference */
};

anonymous enum

anonymous enum

Enumerator
CONFFLAG_ADMIN	user has admin access on the conference
CONFFLAG_MONITOR	If set the user can only receive audio from the conference
CONFFLAG_KEYEXIT	If set asterisk will exit conference when key defined in p() option is pressed
CONFFLAG_STARMENU	If set asterisk will provide a menu to the user when '*' is pressed
CONFFLAG_TALKER	If set the use can only send audio to the conference
CONFFLAG_QUIET	If set there will be no enter or leave sounds
CONFFLAG_ANNOUNCEUSERCOUNT	If set, when user joins the conference, they will be told the number of users that are already in
CONFFLAG_AGI	Set to run AGI Script in Background
CONFFLAG_MOH	Set to have music on hold when user is alone in conference
CONFFLAG_MARKEDEXIT	If set, the channel will leave the conference if all marked users leave
CONFFLAG_WAITMARKED	If set, the MeetMe will wait until a marked user enters
CONFFLAG_EXIT_CONTEXT	If set, the MeetMe will exit to the specified context
CONFFLAG_MARKEDUSER	If set, the user will be marked
CONFFLAG_INTROUSER	If set, user will be ask record name on entry of conference
CONFFLAG_RECORDCONF	If set, the MeetMe will be recorded
CONFFLAG_MONITORTALKER	If set, the user will be monitored if the user is talking or not
CONFFLAG_DYNAMIC
CONFFLAG_DYNAMICPIN
CONFFLAG_EMPTY
CONFFLAG_EMPTYNOPIN
CONFFLAG_ALWAYSPROMPT
CONFFLAG_OPTIMIZETALKER	If set, treat talking users as muted users
CONFFLAG_NOONLYPERSON	If set, won't speak the extra prompt when the first person enters the conference
CONFFLAG_INTROUSERNOREVIEW	If set, user will be asked to record name on entry of conference without review
CONFFLAG_STARTMUTED	If set, the user will be initially self-muted
CONFFLAG_PASS_DTMF	Pass DTMF through the conference
CONFFLAG_SLA_STATION
CONFFLAG_SLA_TRUNK
CONFFLAG_KICK_CONTINUE	If set, the user should continue in the dialplan if kicked out
CONFFLAG_DURATION_STOP
CONFFLAG_DURATION_LIMIT

Definition at line 687 of file app_meetme.c.

     {
    /*! user has admin access on the conference */
    CONFFLAG_ADMIN = (1 << 0),
    /*! If set the user can only receive audio from the conference */
    CONFFLAG_MONITOR = (1 << 1),
    /*! If set asterisk will exit conference when key defined in p() option is pressed */
    CONFFLAG_KEYEXIT = (1 << 2),
    /*! If set asterisk will provide a menu to the user when '*' is pressed */
    CONFFLAG_STARMENU = (1 << 3),
    /*! If set the use can only send audio to the conference */
    CONFFLAG_TALKER = (1 << 4),
    /*! If set there will be no enter or leave sounds */
    CONFFLAG_QUIET = (1 << 5),
    /*! If set, when user joins the conference, they will be told the number
     *  of users that are already in */
    CONFFLAG_ANNOUNCEUSERCOUNT = (1 << 6),
    /*! Set to run AGI Script in Background */
    CONFFLAG_AGI = (1 << 7),
    /*! Set to have music on hold when user is alone in conference */
    CONFFLAG_MOH = (1 << 8),
    /*! If set, the channel will leave the conference if all marked users leave */
    CONFFLAG_MARKEDEXIT = (1 << 9),
    /*! If set, the MeetMe will wait until a marked user enters */
    CONFFLAG_WAITMARKED = (1 << 10),
    /*! If set, the MeetMe will exit to the specified context */
    CONFFLAG_EXIT_CONTEXT = (1 << 11),
    /*! If set, the user will be marked */
    CONFFLAG_MARKEDUSER = (1 << 12),
    /*! If set, user will be ask record name on entry of conference */
    CONFFLAG_INTROUSER = (1 << 13),
    /*! If set, the MeetMe will be recorded */
    CONFFLAG_RECORDCONF = (1<< 14),
    /*! If set, the user will be monitored if the user is talking or not */
    CONFFLAG_MONITORTALKER = (1 << 15),
    CONFFLAG_DYNAMIC = (1 << 16),
    CONFFLAG_DYNAMICPIN = (1 << 17),
    CONFFLAG_EMPTY = (1 << 18),
    CONFFLAG_EMPTYNOPIN = (1 << 19),
    CONFFLAG_ALWAYSPROMPT = (1 << 20),
    /*! If set, treat talking users as muted users */
    CONFFLAG_OPTIMIZETALKER = (1 << 21),
    /*! If set, won't speak the extra prompt when the first person
     *  enters the conference */
    CONFFLAG_NOONLYPERSON = (1 << 22),
    /*! If set, user will be asked to record name on entry of conference
     *  without review */
    CONFFLAG_INTROUSERNOREVIEW = (1 << 23),
    /*! If set, the user will be initially self-muted */
    CONFFLAG_STARTMUTED = (1 << 24),
    /*! Pass DTMF through the conference */
    CONFFLAG_PASS_DTMF = (1 << 25),
    CONFFLAG_SLA_STATION = (1 << 26),
    CONFFLAG_SLA_TRUNK = (1 << 27),
    /*! If set, the user should continue in the dialplan if kicked out */
    CONFFLAG_KICK_CONTINUE = (1 << 28),
    CONFFLAG_DURATION_STOP = (1 << 29),
    CONFFLAG_DURATION_LIMIT = (1 << 30),
};

anonymous enum

anonymous enum

Enumerator
OPT_ARG_WAITMARKED
OPT_ARG_EXITKEYS
OPT_ARG_DURATION_STOP
OPT_ARG_DURATION_LIMIT
OPT_ARG_MOH_CLASS
OPT_ARG_INTROMSG
OPT_ARG_INTROUSER_VMREC
OPT_ARG_ARRAY_SIZE

Definition at line 757 of file app_meetme.c.

     {
    OPT_ARG_WAITMARKED = 0,
    OPT_ARG_EXITKEYS   = 1,
    OPT_ARG_DURATION_STOP = 2,
    OPT_ARG_DURATION_LIMIT = 3,
    OPT_ARG_MOH_CLASS = 4,
    OPT_ARG_INTROMSG = 5,
    OPT_ARG_INTROUSER_VMREC = 6,
    OPT_ARG_ARRAY_SIZE = 7,
};

anonymous enum

anonymous enum

Enumerator
SLA_TRUNK_OPT_MOH

Definition at line 7227 of file app_meetme.c.

     {
    SLA_TRUNK_OPT_MOH = (1 << 0),
};

anonymous enum

anonymous enum

Enumerator
SLA_TRUNK_OPT_ARG_MOH_CLASS
SLA_TRUNK_OPT_ARG_ARRAY_SIZE

Definition at line 7231 of file app_meetme.c.

     {
    SLA_TRUNK_OPT_ARG_MOH_CLASS = 0,
    SLA_TRUNK_OPT_ARG_ARRAY_SIZE = 1,
};

announcetypes

enum announcetypes

Enumerator
CONF_HASJOIN
CONF_HASLEFT

Definition at line 828 of file app_meetme.c.

                   {
    CONF_HASJOIN,
    CONF_HASLEFT
};

entrance_sound

enum entrance_sound

Enumerator
ENTER
LEAVE

Definition at line 673 of file app_meetme.c.

                    {
    ENTER,
    LEAVE
};

menu_modes

enum menu_modes

Enumerator
MENU_DISABLED
MENU_NORMAL
MENU_ADMIN
MENU_ADMIN_EXTENDED

Definition at line 2751 of file app_meetme.c.

                {
    MENU_DISABLED = 0,
    MENU_NORMAL,
    MENU_ADMIN,
    MENU_ADMIN_EXTENDED,
};

recording_state

enum recording_state

Enumerator
MEETME_RECORD_OFF
MEETME_RECORD_STARTED
MEETME_RECORD_ACTIVE
MEETME_RECORD_TERMINATE

Definition at line 678 of file app_meetme.c.

                     {
    MEETME_RECORD_OFF,
    MEETME_RECORD_STARTED,
    MEETME_RECORD_ACTIVE,
    MEETME_RECORD_TERMINATE
};

sla_event_type

enum sla_event_type

Event types that can be queued up for the SLA thread.

Enumerator
SLA_EVENT_HOLD	A station has put the call on hold
SLA_EVENT_DIAL_STATE	The state of a dial has changed
SLA_EVENT_RINGING_TRUNK	The state of a ringing trunk has changed

Definition at line 1040 of file app_meetme.c.

                    {
    /*! A station has put the call on hold */
    SLA_EVENT_HOLD,
    /*! The state of a dial has changed */
    SLA_EVENT_DIAL_STATE,
    /*! The state of a ringing trunk has changed */
    SLA_EVENT_RINGING_TRUNK,
};

sla_hold_access

enum sla_hold_access

Enumerator
SLA_HOLD_OPEN	This means that any station can put it on hold, and any station can retrieve the call from hold.
SLA_HOLD_PRIVATE	This means that only the station that put the call on hold may retrieve it from hold.

Definition at line 933 of file app_meetme.c.

                     {
    /*! This means that any station can put it on hold, and any station
     * can retrieve the call from hold. */
    SLA_HOLD_OPEN,
    /*! This means that only the station that put the call on hold may
     * retrieve it from hold. */
    SLA_HOLD_PRIVATE,
};

sla_station_hangup

enum sla_station_hangup

Enumerator
SLA_STATION_HANGUP_NORMAL
SLA_STATION_HANGUP_TIMEOUT

Definition at line 1073 of file app_meetme.c.

                        {
    SLA_STATION_HANGUP_NORMAL,
    SLA_STATION_HANGUP_TIMEOUT,
};

sla_trunk_state

enum sla_trunk_state

Enumerator
SLA_TRUNK_STATE_IDLE
SLA_TRUNK_STATE_RINGING
SLA_TRUNK_STATE_UP
SLA_TRUNK_STATE_ONHOLD
SLA_TRUNK_STATE_ONHOLD_BYME

Definition at line 925 of file app_meetme.c.

                     {
    SLA_TRUNK_STATE_IDLE,
    SLA_TRUNK_STATE_RINGING,
    SLA_TRUNK_STATE_UP,
    SLA_TRUNK_STATE_ONHOLD,
    SLA_TRUNK_STATE_ONHOLD_BYME,
};

sla_which_trunk_refs

enum sla_which_trunk_refs

Enumerator
ALL_TRUNK_REFS
INACTIVE_TRUNK_REFS

Definition at line 920 of file app_meetme.c.

                          {
    ALL_TRUNK_REFS,
    INACTIVE_TRUNK_REFS,
};

volume_action

enum volume_action

Enumerator
VOL_UP
VOL_DOWN

Definition at line 668 of file app_meetme.c.

                   {
    VOL_UP,
    VOL_DOWN
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 8097 of file app_meetme.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 8097 of file app_meetme.c.

acf_meetme_info()

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

static

Definition at line 7953 of file app_meetme.c.

{
    struct ast_conference *conf;
    char *parse;
    int result = -2; /* only non-negative numbers valid, -1 is used elsewhere */
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(keyword);
        AST_APP_ARG(confno);
    );
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_ERROR, "Syntax: MEETME_INFO() requires two arguments\n");
        return -1;
    }
 
    parse = ast_strdupa(data);
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.keyword)) {
        ast_log(LOG_ERROR, "Syntax: MEETME_INFO() requires a keyword\n");
        return -1;
    }
 
    if (ast_strlen_zero(args.confno)) {
        ast_log(LOG_ERROR, "Syntax: MEETME_INFO() requires a conference number\n");
        return -1;
    }
 
    AST_LIST_LOCK(&confs);
    AST_LIST_TRAVERSE(&confs, conf, list) {
        if (!strcmp(args.confno, conf->confno)) {
            result = acf_meetme_info_eval(args.keyword, conf);
            break;
        }
    }
    AST_LIST_UNLOCK(&confs);
 
    if (result > -1) {
        snprintf(buf, len, "%d", result);
    } else if (result == -1) {
        ast_log(LOG_NOTICE, "Error: invalid keyword: '%s'\n", args.keyword);
        snprintf(buf, len, "0");
    } else if (result == -2) {
        ast_log(LOG_NOTICE, "Error: conference (%s) not found\n", args.confno);
        snprintf(buf, len, "0");
    }
 
    return 0;
}

References acf_meetme_info_eval(), args, AST_APP_ARG, AST_DECLARE_APP_ARGS, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), buf, ast_conference::confno, len(), ast_conference::list, LOG_ERROR, LOG_NOTICE, parse(), and result.

acf_meetme_info_eval()

static int acf_meetme_info_eval ( const char *  keyword, const struct ast_conference *  conf  )

static

Definition at line 7935 of file app_meetme.c.

{
    if (!strcasecmp("lock", keyword)) {
        return conf->locked;
    } else if (!strcasecmp("parties", keyword)) {
        return conf->users;
    } else if (!strcasecmp("activity", keyword)) {
        time_t now;
        now = time(NULL);
        return (now - conf->start);
    } else if (!strcasecmp("dynamic", keyword)) {
        return conf->isdynamic;
    } else {
        return -1;
    }
 
}

References NULL.

Referenced by acf_meetme_info().

action_meetmelist()

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

static

Definition at line 5533 of file app_meetme.c.

{
    const char *actionid = astman_get_header(m, "ActionID");
    const char *conference = astman_get_header(m, "Conference");
    char idText[80] = "";
    struct ast_conference *cnf;
    struct ast_conf_user *user;
    struct ao2_iterator user_iter;
    int total = 0;
 
    if (!ast_strlen_zero(actionid))
        snprintf(idText, sizeof(idText), "ActionID: %s\r\n", actionid);
 
    if (AST_LIST_EMPTY(&confs)) {
        astman_send_error(s, m, "No active conferences.");
        return 0;
    }
 
    astman_send_listack(s, m, "Meetme user list will follow", "start");
 
    /* Find the right conference */
    AST_LIST_LOCK(&confs);
    AST_LIST_TRAVERSE(&confs, cnf, list) {
        /* If we ask for one particular, and this isn't it, skip it */
        if (!ast_strlen_zero(conference) && strcmp(cnf->confno, conference))
            continue;
 
        /* Show all the users */
        user_iter = ao2_iterator_init(cnf->usercontainer, 0);
        while ((user = ao2_iterator_next(&user_iter))) {
            total++;
            astman_append(s,
                "Event: MeetmeList\r\n"
                "%s"
                "Conference: %s\r\n"
                "UserNumber: %d\r\n"
                "CallerIDNum: %s\r\n"
                "CallerIDName: %s\r\n"
                "ConnectedLineNum: %s\r\n"
                "ConnectedLineName: %s\r\n"
                "Channel: %s\r\n"
                "Admin: %s\r\n"
                "Role: %s\r\n"
                "MarkedUser: %s\r\n"
                "Muted: %s\r\n"
                "Talking: %s\r\n"
                "\r\n",
                idText,
                cnf->confno,
                user->user_no,
                S_COR(ast_channel_caller(user->chan)->id.number.valid, ast_channel_caller(user->chan)->id.number.str, "<unknown>"),
                S_COR(ast_channel_caller(user->chan)->id.name.valid, ast_channel_caller(user->chan)->id.name.str, "<no name>"),
                S_COR(ast_channel_connected(user->chan)->id.number.valid, ast_channel_connected(user->chan)->id.number.str, "<unknown>"),
                S_COR(ast_channel_connected(user->chan)->id.name.valid, ast_channel_connected(user->chan)->id.name.str, "<no name>"),
                ast_channel_name(user->chan),
                ast_test_flag64(&user->userflags, CONFFLAG_ADMIN) ? "Yes" : "No",
                ast_test_flag64(&user->userflags, CONFFLAG_MONITOR) ? "Listen only" : ast_test_flag64(&user->userflags, CONFFLAG_TALKER) ? "Talk only" : "Talk and listen",
                ast_test_flag64(&user->userflags, CONFFLAG_MARKEDUSER) ? "Yes" : "No",
                user->adminflags & ADMINFLAG_MUTED ? "By admin" : user->adminflags & ADMINFLAG_SELFMUTED ? "By self" : "No",
                user->talking > 0 ? "Yes" : user->talking == 0 ? "No" : "Not monitored");
            ao2_ref(user, -1);
        }
        ao2_iterator_destroy(&user_iter);
    }
    AST_LIST_UNLOCK(&confs);
 
    /* Send final confirmation */
    astman_send_list_complete_start(s, m, "MeetmeListComplete", total);
    astman_send_list_complete_end(s);
    return 0;
}

References ADMINFLAG_MUTED, ADMINFLAG_SELFMUTED, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_channel_caller(), ast_channel_connected(), ast_channel_name(), AST_LIST_EMPTY, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strlen_zero(), ast_test_flag64, astman_append(), astman_get_header(), astman_send_error(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), CONFFLAG_ADMIN, CONFFLAG_MARKEDUSER, CONFFLAG_MONITOR, CONFFLAG_TALKER, ast_conference::confno, ast_party_caller::id, ast_party_connected_line::id, ast_party_id::name, ast_party_id::number, S_COR, ast_party_name::str, ast_party_number::str, total, user, ast_conference::usercontainer, ast_party_name::valid, and ast_party_number::valid.

Referenced by load_module().

action_meetmelistrooms()

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

static

Definition at line 5605 of file app_meetme.c.

{
    const char *actionid = astman_get_header(m, "ActionID");
    char idText[80] = "";
    struct ast_conference *cnf;
    int totalitems = 0;
    int hr, min, sec;
    time_t now;
    char markedusers[5];
 
    if (!ast_strlen_zero(actionid)) {
        snprintf(idText, sizeof(idText), "ActionID: %s\r\n", actionid);
    }
 
    if (AST_LIST_EMPTY(&confs)) {
        astman_send_error(s, m, "No active conferences.");
        return 0;
    }
 
    astman_send_listack(s, m, "Meetme conferences will follow", "start");
 
    now = time(NULL);
 
    /* Traverse the conference list */
    AST_LIST_LOCK(&confs);
    AST_LIST_TRAVERSE(&confs, cnf, list) {
        totalitems++;
 
        if (cnf->markedusers == 0) {
            strcpy(markedusers, "N/A");
        } else {
            sprintf(markedusers, "%.4d", cnf->markedusers);
        }
        hr = (now - cnf->start) / 3600;
        min = ((now - cnf->start) % 3600) / 60;
        sec = (now - cnf->start) % 60;
 
        astman_append(s,
        "Event: MeetmeListRooms\r\n"
        "%s"
        "Conference: %s\r\n"
        "Parties: %d\r\n"
        "Marked: %s\r\n"
        "Activity: %2.2d:%2.2d:%2.2d\r\n"
        "Creation: %s\r\n"
        "Locked: %s\r\n"
        "\r\n",
        idText,
        cnf->confno,
        cnf->users,
        markedusers,
        hr,  min, sec,
        cnf->isdynamic ? "Dynamic" : "Static",
        cnf->locked ? "Yes" : "No");
    }
    AST_LIST_UNLOCK(&confs);
 
    /* Send final confirmation */
    astman_send_list_complete_start(s, m, "MeetmeListRoomsComplete", totalitems);
    astman_send_list_complete_end(s);
    return 0;
}

References AST_LIST_EMPTY, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), ast_conference::confno, ast_conference::isdynamic, ast_conference::list, ast_conference::locked, ast_conference::markedusers, min, NULL, ast_conference::start, and ast_conference::users.

Referenced by load_module().

action_meetmemute()

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

static

Definition at line 5523 of file app_meetme.c.

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

References meetmemute().

Referenced by load_module().

action_meetmeunmute()

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

static

Definition at line 5528 of file app_meetme.c.

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

References meetmemute().

Referenced by load_module().

admin_exec()

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

static

The MeetMeAdmin application.

MeetMeAdmin(confno, command, caller)

Definition at line 5229 of file app_meetme.c.

                                                                  {
    char *params;
    struct ast_conference *cnf;
    struct ast_conf_user *user = NULL;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(confno);
        AST_APP_ARG(command);
        AST_APP_ARG(user);
    );
    int res = 0;
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "MeetMeAdmin requires an argument!\n");
        if (chan) {
            pbx_builtin_setvar_helper(chan, "MEETMEADMINSTATUS", "NOPARSE");
        }
        return -1;
    }
 
    params = ast_strdupa(data);
    AST_STANDARD_APP_ARGS(args, params);
 
    if (!args.command) {
        ast_log(LOG_WARNING, "MeetmeAdmin requires a command!\n");
        if (chan) {
            pbx_builtin_setvar_helper(chan, "MEETMEADMINSTATUS", "NOPARSE");
        }
        return -1;
    }
 
    AST_LIST_LOCK(&confs);
    AST_LIST_TRAVERSE(&confs, cnf, list) {
        if (!strcmp(cnf->confno, args.confno))
            break;
    }
 
    if (!cnf) {
        ast_log(LOG_WARNING, "Conference number '%s' not found!\n", args.confno);
        AST_LIST_UNLOCK(&confs);
        if (chan) {
            pbx_builtin_setvar_helper(chan, "MEETMEADMINSTATUS", "NOTFOUND");
        }
        return 0;
    }
 
    ast_atomic_fetchadd_int(&cnf->refcount, 1);
 
    if (args.user) {
        user = find_user(cnf, args.user);
        if (!user) {
            ast_log(LOG_NOTICE, "Specified User not found!\n");
            res = -2;
            goto usernotfound;
        }
    } else {
        /* fail for commands that require a user */
        switch (*args.command) {
        case 'm': /* Unmute */
        case 'M': /* Mute */
        case 't': /* Lower user's talk volume */
        case 'T': /* Raise user's talk volume */
        case 'u': /* Lower user's listen volume */
        case 'U': /* Raise user's listen volume */
        case 'r': /* Reset user's volume level */
        case 'k': /* Kick user */
            res = -2;
            ast_log(LOG_NOTICE, "No user specified!\n");
            goto usernotfound;
        default:
            break;
        }
    }
 
    switch (*args.command) {
    case 76: /* L: Lock */
        cnf->locked = 1;
        break;
    case 108: /* l: Unlock */
        cnf->locked = 0;
        break;
    case 75: /* K: kick all users */
        ao2_callback(cnf->usercontainer, OBJ_NODATA, user_set_kickme_cb, NULL);
        break;
    case 101: /* e: Eject last user*/
    {
        int max_no = 0;
        RAII_VAR(struct ast_conf_user *, eject_user, NULL, ao2_cleanup);
 
        ao2_callback(cnf->usercontainer, OBJ_NODATA, user_max_cmp, &max_no);
        eject_user = ao2_find(cnf->usercontainer, &max_no, 0);
        if (!eject_user) {
            res = -1;
            ast_log(LOG_NOTICE, "No last user to kick!\n");
            break;
        }
 
        if (!ast_test_flag64(&eject_user->userflags, CONFFLAG_ADMIN)) {
            eject_user->adminflags |= ADMINFLAG_KICKME;
        } else {
            res = -1;
            ast_log(LOG_NOTICE, "Not kicking last user, is an Admin!\n");
        }
        break;
    }
    case 77: /* M: Mute */
        user->adminflags |= ADMINFLAG_MUTED;
        break;
    case 78: /* N: Mute all (non-admin) users */
        ao2_callback(cnf->usercontainer, OBJ_NODATA, user_set_muted_cb, &cnf);
        break;
    case 109: /* m: Unmute */
        user->adminflags &= ~(ADMINFLAG_MUTED | ADMINFLAG_SELFMUTED | ADMINFLAG_T_REQUEST);
        break;
    case 110: /* n: Unmute all users */
        ao2_callback(cnf->usercontainer, OBJ_NODATA, user_set_unmuted_cb, NULL);
        break;
    case 107: /* k: Kick user */
        user->adminflags |= ADMINFLAG_KICKME;
        break;
    case 118: /* v: Lower all users listen volume */
        ao2_callback(cnf->usercontainer, OBJ_NODATA, user_listen_voldown_cb, NULL);
        break;
    case 86: /* V: Raise all users listen volume */
        ao2_callback(cnf->usercontainer, OBJ_NODATA, user_listen_volup_cb, NULL);
        break;
    case 115: /* s: Lower all users speaking volume */
        ao2_callback(cnf->usercontainer, OBJ_NODATA, user_talk_voldown_cb, NULL);
        break;
    case 83: /* S: Raise all users speaking volume */
        ao2_callback(cnf->usercontainer, OBJ_NODATA, user_talk_volup_cb, NULL);
        break;
    case 82: /* R: Reset all volume levels */
        ao2_callback(cnf->usercontainer, OBJ_NODATA, user_reset_vol_cb, NULL);
        break;
    case 114: /* r: Reset user's volume level */
        reset_volumes(user);
        break;
    case 85: /* U: Raise user's listen volume */
        tweak_listen_volume(user, VOL_UP);
        break;
    case 117: /* u: Lower user's listen volume */
        tweak_listen_volume(user, VOL_DOWN);
        break;
    case 84: /* T: Raise user's talk volume */
        tweak_talk_volume(user, VOL_UP);
        break;
    case 116: /* t: Lower user's talk volume */
        tweak_talk_volume(user, VOL_DOWN);
        break;
    case 'E': /* E: Extend conference */
        if (rt_extend_conf(args.confno)) {
            res = -1;
        }
        break;
    }
 
    if (args.user) {
        /* decrement reference from find_user */
        ao2_ref(user, -1);
    }
usernotfound:
    AST_LIST_UNLOCK(&confs);
 
    dispose_conf(cnf);
    if (chan) {
        pbx_builtin_setvar_helper(chan, "MEETMEADMINSTATUS", res == -2 ? "NOTFOUND" : res ? "FAILED" : "OK");
    }
 
    return 0;
}

References ADMINFLAG_KICKME, ADMINFLAG_MUTED, ADMINFLAG_SELFMUTED, ADMINFLAG_T_REQUEST, ao2_callback, ao2_cleanup, ao2_find, ao2_ref, args, AST_APP_ARG, ast_atomic_fetchadd_int(), AST_DECLARE_APP_ARGS, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_test_flag64, ast_conf_user::chan, CONFFLAG_ADMIN, ast_conference::confno, dispose_conf(), find_user(), ast_conf_user::list, ast_conference::locked, LOG_NOTICE, LOG_WARNING, NULL, OBJ_NODATA, pbx_builtin_setvar_helper(), RAII_VAR, ast_conference::refcount, reset_volumes(), rt_extend_conf(), tweak_listen_volume(), tweak_talk_volume(), user_listen_voldown_cb(), user_listen_volup_cb(), user_max_cmp(), user_reset_vol_cb(), user_set_kickme_cb(), user_set_muted_cb(), user_set_unmuted_cb(), user_talk_voldown_cb(), user_talk_volup_cb(), ast_conference::usercontainer, VOL_DOWN, and VOL_UP.

Referenced by load_module(), meetme_cmd_helper(), run_station(), sla_station_exec(), and sla_stop_ringing_trunk().

announce_thread()

static void* announce_thread ( void *  data )

static

Definition at line 2617 of file app_meetme.c.

{
    struct announce_listitem *current;
    struct ast_conference *conf = data;
    int res;
    char filename[PATH_MAX] = "";
    AST_LIST_HEAD_NOLOCK(, announce_listitem) local_list;
    AST_LIST_HEAD_INIT_NOLOCK(&local_list);
 
    while (!conf->announcethread_stop) {
        ast_mutex_lock(&conf->announcelistlock);
        if (conf->announcethread_stop) {
            ast_mutex_unlock(&conf->announcelistlock);
            break;
        }
        if (AST_LIST_EMPTY(&conf->announcelist))
            ast_cond_wait(&conf->announcelist_addition, &conf->announcelistlock);
 
        AST_LIST_APPEND_LIST(&local_list, &conf->announcelist, entry);
        AST_LIST_HEAD_INIT_NOLOCK(&conf->announcelist);
 
        ast_mutex_unlock(&conf->announcelistlock);
        if (conf->announcethread_stop) {
            break;
        }
 
        for (res = 1; !conf->announcethread_stop && (current = AST_LIST_REMOVE_HEAD(&local_list, entry)); ao2_ref(current, -1)) {
            ast_debug(1, "About to play %s\n", current->namerecloc);
            if (!ast_fileexists(current->namerecloc, NULL, NULL))
                continue;
            if ((current->confchan) && (current->confusers > 1) && !ast_check_hangup(current->confchan)) {
                if (!ast_streamfile(current->confchan, current->namerecloc, current->language))
                    res = ast_waitstream(current->confchan, "");
                if (!res) {
                    ast_copy_string(filename, get_announce_filename(current->announcetype), sizeof(filename));
                    if (!ast_streamfile(current->confchan, filename, current->language))
                        ast_waitstream(current->confchan, "");
                }
            }
            if (current->announcetype == CONF_HASLEFT && current->announcetype && !current->vmrec) {
                /* only remove it if it isn't a VM recording file */
                ast_filedelete(current->namerecloc, NULL);
            }
        }
    }
 
    /* thread marked to stop, clean up */
    while ((current = AST_LIST_REMOVE_HEAD(&local_list, entry))) {
        /* only delete if it's a vm rec */
        if (!current->vmrec) {
            ast_filedelete(current->namerecloc, NULL);
        }
        ao2_ref(current, -1);
    }
    return NULL;
}

References ao2_ref, ast_check_hangup(), ast_cond_wait, ast_copy_string(), ast_debug, ast_filedelete(), ast_fileexists(), AST_LIST_APPEND_LIST, AST_LIST_EMPTY, AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_HEAD_NOLOCK(), AST_LIST_REMOVE_HEAD, ast_mutex_lock, ast_mutex_unlock, ast_streamfile(), ast_waitstream(), CONF_HASLEFT, current, get_announce_filename(), NULL, and PATH_MAX.

Referenced by conf_run().

answer_trunk_chan()

static void answer_trunk_chan ( struct ast_channel *  chan )

static

Definition at line 6074 of file app_meetme.c.

{
    ast_answer(chan);
    ast_indicate(chan, -1);
}

References ast_answer(), ast_indicate(), and sla_trunk_ref::chan.

Referenced by run_station(), sla_handle_dial_state_event(), and sla_station_exec().

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 8097 of file app_meetme.c.

build_conf()

static struct ast_conference* build_conf ( const char *  confno, const char *  pin, const char *  pinadmin, int  make, int  dynamic, int  refcount, const struct ast_channel *  chan, struct ast_test *  test  )

static

Find or create a conference.

Parameters

confno	The conference name/number
pin	The regular user pin
pinadmin	The admin pin
make	Make the conf if it doesn't exist
dynamic	Mark the newly created conference as dynamic
refcount	How many references to mark on the conference
chan	The asterisk channel
test

Returns

A pointer to the conference struct, or NULL if it wasn't found and make or dynamic were not set.

Definition at line 1608 of file app_meetme.c.

{
    struct ast_conference *cnf;
    struct dahdi_confinfo dahdic = { 0, };
    int confno_int = 0;
    struct ast_format_cap *cap_slin = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
 
    AST_LIST_LOCK(&confs);
 
    AST_LIST_TRAVERSE(&confs, cnf, list) {
        if (!strcmp(confno, cnf->confno))
            break;
    }
 
    if (cnf || (!make && !dynamic) || !cap_slin)
        goto cnfout;
 
    ast_format_cap_append(cap_slin, ast_format_slin, 0);
    /* Make a new one */
    cnf = ast_calloc(1, sizeof(*cnf));
    if (!cnf) {
        goto cnfout;
    }
 
    cnf->usercontainer = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        NULL, user_no_cmp);
    if (!cnf->usercontainer) {
        goto cnfout;
    }
 
    ast_mutex_init(&cnf->playlock);
    ast_mutex_init(&cnf->listenlock);
    cnf->recordthread = AST_PTHREADT_NULL;
    ast_mutex_init(&cnf->recordthreadlock);
    cnf->announcethread = AST_PTHREADT_NULL;
    ast_mutex_init(&cnf->announcethreadlock);
    ast_copy_string(cnf->confno, confno, sizeof(cnf->confno));
    ast_copy_string(cnf->pin, pin, sizeof(cnf->pin));
    ast_copy_string(cnf->pinadmin, pinadmin, sizeof(cnf->pinadmin));
    ast_copy_string(cnf->uniqueid, ast_channel_uniqueid(chan), sizeof(cnf->uniqueid));
 
    /* Setup a new dahdi conference */
    dahdic.confno = -1;
    dahdic.confmode = DAHDI_CONF_CONFANN | DAHDI_CONF_CONFANNMON;
    cnf->fd = open("/dev/dahdi/pseudo", O_RDWR);
    if (cnf->fd < 0 || ioctl(cnf->fd, DAHDI_SETCONF, &dahdic)) {
        if (test) {
            /* if we are creating a conference for a unit test, it is not neccesary
             * to open a pseudo channel, so, if we fail continue creating
             * the conference. */
            ast_test_status_update(test, "Unable to open DAHDI pseudo device\n");
        } else {
            ast_log(LOG_WARNING, "Unable to open DAHDI pseudo device\n");
            if (cnf->fd >= 0)
                close(cnf->fd);
            ao2_ref(cnf->usercontainer, -1);
            ast_mutex_destroy(&cnf->playlock);
            ast_mutex_destroy(&cnf->listenlock);
            ast_mutex_destroy(&cnf->recordthreadlock);
            ast_mutex_destroy(&cnf->announcethreadlock);
            ast_free(cnf);
            cnf = NULL;
            goto cnfout;
        }
    }
 
    cnf->dahdiconf = dahdic.confno;
 
    /* Setup a new channel for playback of audio files */
    cnf->chan = ast_request("DAHDI", cap_slin, NULL, chan, "pseudo", NULL);
    if (cnf->chan) {
        ast_set_read_format(cnf->chan, ast_format_slin);
        ast_set_write_format(cnf->chan, ast_format_slin);
        dahdic.chan = 0;
        dahdic.confno = cnf->dahdiconf;
        dahdic.confmode = DAHDI_CONF_CONFANN | DAHDI_CONF_CONFANNMON;
        if (ioctl(ast_channel_fd(cnf->chan, 0), DAHDI_SETCONF, &dahdic)) {
            if (test) {
                ast_test_status_update(test, "Error setting conference on pseudo channel\n");
            }
            ast_log(LOG_WARNING, "Error setting conference\n");
            if (cnf->chan)
                ast_hangup(cnf->chan);
            else
                close(cnf->fd);
            ao2_ref(cnf->usercontainer, -1);
            ast_mutex_destroy(&cnf->playlock);
            ast_mutex_destroy(&cnf->listenlock);
            ast_mutex_destroy(&cnf->recordthreadlock);
            ast_mutex_destroy(&cnf->announcethreadlock);
            ast_free(cnf);
            cnf = NULL;
            goto cnfout;
        }
    }
 
    /* Fill the conference struct */
    cnf->start = time(NULL);
    cnf->maxusers = 0x7fffffff;
    cnf->isdynamic = dynamic ? 1 : 0;
    ast_verb(3, "Created MeetMe conference %d for conference '%s'\n", cnf->dahdiconf, cnf->confno);
    AST_LIST_INSERT_HEAD(&confs, cnf, list);
 
    /* Reserve conference number in map */
    if ((sscanf(cnf->confno, "%30d", &confno_int) == 1) && (confno_int >= 0 && confno_int < 1024))
        conf_map[confno_int] = 1;
 
cnfout:
    ao2_cleanup(cap_slin);
    if (cnf)
        ast_atomic_fetchadd_int(&cnf->refcount, refcount);
 
    AST_LIST_UNLOCK(&confs);
 
    return cnf;
}

References ast_conference::announcethread, ast_conference::announcethreadlock, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_cleanup, ao2_container_alloc_list, ao2_ref, ast_atomic_fetchadd_int(), ast_calloc, ast_channel_fd(), ast_channel_uniqueid(), ast_copy_string(), ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_slin, ast_free, ast_hangup(), AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, ast_mutex_destroy, ast_mutex_init, AST_PTHREADT_NULL, ast_request(), ast_set_read_format(), ast_set_write_format(), ast_test_status_update, ast_verb, ast_conference::chan, conf_map, ast_conference::confno, ast_conference::dahdiconf, ast_conference::fd, ast_conference::isdynamic, ast_conference::listenlock, LOG_WARNING, ast_conference::maxusers, NULL, ast_conference::pin, ast_conference::pinadmin, ast_conference::playlock, ast_conference::recordthread, ast_conference::recordthreadlock, ast_conference::refcount, ast_conference::start, ast_conference::uniqueid, user_no_cmp(), and ast_conference::usercontainer.

Referenced by dial_trunk(), find_conf(), find_conf_realtime(), run_station(), sla_state(), and sla_station_exec().

can_write()

static int can_write ( struct ast_channel *  chan, struct ast_flags64 *  confflags  )

static

Definition at line 2674 of file app_meetme.c.

{
    if (!ast_test_flag64(confflags, CONFFLAG_NO_AUDIO_UNTIL_UP)) {
        return 1;
    }
 
    return (ast_channel_state(chan) == AST_STATE_UP);
}

References AST_STATE_UP, ast_test_flag64, ast_conference::chan, and CONFFLAG_NO_AUDIO_UNTIL_UP.

Referenced by conf_run().

careful_write()

static int careful_write ( int  fd, unsigned char *  data, int  len, int  block  )

static

Definition at line 1410 of file app_meetme.c.

{
    int res;
    int x;
 
    while (len) {
        if (block) {
            x = DAHDI_IOMUX_WRITE | DAHDI_IOMUX_SIGEVENT;
            res = ioctl(fd, DAHDI_IOMUX, &x);
        } else
            res = 0;
        if (res >= 0)
            res = write(fd, data, len);
        if (res < 1) {
            if (errno != EAGAIN) {
                ast_log(LOG_WARNING, "Failed to write audio data to conference: %s\n", strerror(errno));
                return -1;
            } else
                return 0;
        }
        len -= res;
        data += res;
    }
 
    return 0;
}

References ast_log, errno, len(), and LOG_WARNING.

Referenced by conf_play(), and conf_run().

channel_admin_exec()

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

static

The MeetMeChannelAdmin application MeetMeChannelAdmin(channel, command)

Definition at line 5402 of file app_meetme.c.

                                                                          {
    char *params;
    struct ast_conference *conf = NULL;
    struct ast_conf_user *user = NULL;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(channel);
        AST_APP_ARG(command);
    );
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "MeetMeChannelAdmin requires two arguments!\n");
        return -1;
    }
 
    params = ast_strdupa(data);
    AST_STANDARD_APP_ARGS(args, params);
 
    if (!args.channel) {
        ast_log(LOG_WARNING, "MeetMeChannelAdmin requires a channel name!\n");
        return -1;
    }
 
    if (!args.command) {
        ast_log(LOG_WARNING, "MeetMeChannelAdmin requires a command!\n");
        return -1;
    }
 
    AST_LIST_LOCK(&confs);
    AST_LIST_TRAVERSE(&confs, conf, list) {
        if ((user = ao2_callback(conf->usercontainer, 0, user_chan_cb, args.channel))) {
            break;
        }
    }
 
    if (!user) {
        ast_log(LOG_NOTICE, "Specified user (%s) not found\n", args.channel);
        AST_LIST_UNLOCK(&confs);
        return 0;
    }
 
    /* perform the specified action */
    switch (*args.command) {
        case 77: /* M: Mute */
            user->adminflags |= ADMINFLAG_MUTED;
            break;
        case 109: /* m: Unmute */
            user->adminflags &= ~ADMINFLAG_MUTED;
            break;
        case 107: /* k: Kick user */
            user->adminflags |= ADMINFLAG_KICKME;
            break;
        default: /* unknown command */
            ast_log(LOG_WARNING, "Unknown MeetMeChannelAdmin command '%s'\n", args.command);
            break;
    }
    ao2_ref(user, -1);
    AST_LIST_UNLOCK(&confs);
 
    return 0;
}

References ADMINFLAG_KICKME, ADMINFLAG_MUTED, ao2_callback, ao2_ref, args, AST_APP_ARG, AST_DECLARE_APP_ARGS, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_conf_user::list, LOG_NOTICE, LOG_WARNING, NULL, and user_chan_cb().

Referenced by load_module().

complete_confno()

static char* complete_confno ( const char *  word, int  state  )

static

Definition at line 1727 of file app_meetme.c.

{
    struct ast_conference *cnf;
    char *ret = NULL;
    int which = 0;
    int len = strlen(word);
 
    AST_LIST_LOCK(&confs);
    AST_LIST_TRAVERSE(&confs, cnf, list) {
        if (!strncmp(word, cnf->confno, len) && ++which > state) {
            /* dup before releasing the lock */
            ret = ast_strdup(cnf->confno);
            break;
        }
    }
    AST_LIST_UNLOCK(&confs);
    return ret;
}

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strdup, ast_conference::confno, len(), ast_conference::list, and NULL.

Referenced by complete_meetmecmd_list(), complete_meetmecmd_lock(), and complete_meetmecmd_mute_kick().

complete_meetmecmd_list()

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

static

Definition at line 1816 of file app_meetme.c.

{
    int len;
 
    if (pos == 2) {
        len = strlen(word);
        if (!strncasecmp(word, STR_CONCISE, len)) {
            if (state == 0) {
                return ast_strdup(STR_CONCISE);
            }
            --state;
        }
 
        return complete_confno(word, state);
    }
    if (pos == 3 && state == 0) {
        char *saved = NULL;
        char *myline;
        char *confno;
 
        /* Extract the confno from the command line. */
        myline = ast_strdupa(line);
        strtok_r(myline, " ", &saved);
        strtok_r(NULL, " ", &saved);
        confno = strtok_r(NULL, " ", &saved);
 
        if (!strcasecmp(confno, STR_CONCISE)) {
            /* There is nothing valid in this position now. */
            return NULL;
        }
 
        len = strlen(word);
        if (!strncasecmp(word, STR_CONCISE, len)) {
            return ast_strdup(STR_CONCISE);
        }
    }
    return NULL;
}

References ast_strdup, ast_strdupa, complete_confno(), ast_conference::confno, len(), NULL, state, and STR_CONCISE.

Referenced by meetme_show_cmd().

complete_meetmecmd_lock()

static char* complete_meetmecmd_lock ( const char *  word, int  pos, int  state  )

static

Definition at line 1808 of file app_meetme.c.

{
    if (pos == 2) {
        return complete_confno(word, state);
    }
    return NULL;
}

References complete_confno(), and NULL.

Referenced by meetme_lock_cmd().

complete_meetmecmd_mute_kick()

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

static

Definition at line 1768 of file app_meetme.c.

{
    if (pos == 2) {
        return complete_confno(word, state);
    }
    if (pos == 3) {
        int len = strlen(word);
        char *ret = NULL;
        char *saved = NULL;
        char *myline;
        char *confno;
        struct ast_conference *cnf;
 
        if (!strncasecmp(word, "all", len)) {
            if (state == 0) {
                return ast_strdup("all");
            }
            --state;
        }
 
        /* Extract the confno from the command line. */
        myline = ast_strdupa(line);
        strtok_r(myline, " ", &saved);
        strtok_r(NULL, " ", &saved);
        confno = strtok_r(NULL, " ", &saved);
 
        AST_LIST_LOCK(&confs);
        AST_LIST_TRAVERSE(&confs, cnf, list) {
            if (!strcmp(confno, cnf->confno)) {
                ret = complete_userno(cnf, word, state);
                break;
            }
        }
        AST_LIST_UNLOCK(&confs);
 
        return ret;
    }
    return NULL;
}

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strdup, ast_strdupa, complete_confno(), complete_userno(), ast_conference::confno, len(), ast_conference::list, NULL, and state.

Referenced by meetme_kick_cmd(), and meetme_mute_cmd().

complete_userno()

static char* complete_userno ( struct ast_conference *  cnf, const char *  word, int  state  )

static

Definition at line 1746 of file app_meetme.c.

{
    char usrno[50];
    struct ao2_iterator iter;
    struct ast_conf_user *usr;
    char *ret = NULL;
    int which = 0;
    int len = strlen(word);
 
    iter = ao2_iterator_init(cnf->usercontainer, 0);
    for (; (usr = ao2_iterator_next(&iter)); ao2_ref(usr, -1)) {
        snprintf(usrno, sizeof(usrno), "%d", usr->user_no);
        if (!strncmp(word, usrno, len) && ++which > state) {
            ao2_ref(usr, -1);
            ret = ast_strdup(usrno);
            break;
        }
    }
    ao2_iterator_destroy(&iter);
    return ret;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_strdup, len(), NULL, ast_conf_user::user_no, and ast_conference::usercontainer.

Referenced by complete_meetmecmd_mute_kick().

conf_exec()

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

static

The meetme() application.

Definition at line 4841 of file app_meetme.c.

{
    int res = -1;
    char confno[MAX_CONFNUM] = "";
    int allowretry = 0;
    int retrycnt = 0;
    struct ast_conference *cnf = NULL;
    struct ast_flags64 confflags = {0};
    struct ast_flags config_flags = { 0 };
    int dynamic = 0;
    int empty = 0, empty_no_pin = 0;
    int always_prompt = 0;
    const char *notdata;
    char *info, the_pin[MAX_PIN] = "";
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(confno);
        AST_APP_ARG(options);
        AST_APP_ARG(pin);
    );
    char *optargs[OPT_ARG_ARRAY_SIZE] = { NULL, };
 
    if (ast_strlen_zero(data)) {
        allowretry = 1;
        notdata = "";
    } else {
        notdata = data;
    }
 
    if (ast_channel_state(chan) != AST_STATE_UP)
        ast_answer(chan);
 
    info = ast_strdupa(notdata);
 
    AST_STANDARD_APP_ARGS(args, info);
 
    if (args.confno) {
        ast_copy_string(confno, args.confno, sizeof(confno));
        if (ast_strlen_zero(confno)) {
            allowretry = 1;
        }
    }
 
    if (args.pin)
        ast_copy_string(the_pin, args.pin, sizeof(the_pin));
 
    if (args.options) {
        ast_app_parse_options64(meetme_opts, &confflags, optargs, args.options);
        dynamic = ast_test_flag64(&confflags, CONFFLAG_DYNAMIC | CONFFLAG_DYNAMICPIN);
        if (ast_test_flag64(&confflags, CONFFLAG_DYNAMICPIN) && ast_strlen_zero(args.pin))
            strcpy(the_pin, "q");
 
        empty = ast_test_flag64(&confflags, CONFFLAG_EMPTY | CONFFLAG_EMPTYNOPIN);
        empty_no_pin = ast_test_flag64(&confflags, CONFFLAG_EMPTYNOPIN);
        always_prompt = ast_test_flag64(&confflags, CONFFLAG_ALWAYSPROMPT | CONFFLAG_DYNAMICPIN);
    }
 
    do {
        if (retrycnt > 3)
            allowretry = 0;
        if (empty) {
            int i;
            struct ast_config *cfg;
            struct ast_variable *var;
            int confno_int;
 
            /* We only need to load the config file for static and empty_no_pin (otherwise we don't care) */
            if ((empty_no_pin) || (!dynamic)) {
                cfg = ast_config_load(CONFIG_FILE_NAME, config_flags);
                if (cfg && cfg != CONFIG_STATUS_FILEINVALID) {
                    var = ast_variable_browse(cfg, "rooms");
                    while (var) {
                        char parse[MAX_SETTINGS], *stringp = parse, *confno_tmp;
                        if (!strcasecmp(var->name, "conf")) {
                            int found = 0;
                            ast_copy_string(parse, var->value, sizeof(parse));
                            confno_tmp = strsep(&stringp, "|,");
                            if (!dynamic) {
                                /* For static:  run through the list and see if this conference is empty */
                                AST_LIST_LOCK(&confs);
                                AST_LIST_TRAVERSE(&confs, cnf, list) {
                                    if (!strcmp(confno_tmp, cnf->confno)) {
                                        /* The conference exists, therefore it's not empty */
                                        found = 1;
                                        break;
                                    }
                                }
                                AST_LIST_UNLOCK(&confs);
                                cnf = NULL;
                                if (!found) {
                                    /* At this point, we have a confno_tmp (static conference) that is empty */
                                    if ((empty_no_pin && ast_strlen_zero(stringp)) || (!empty_no_pin)) {
                                        /* Case 1:  empty_no_pin and pin is nonexistent (NULL)
                                         * Case 2:  empty_no_pin and pin is blank (but not NULL)
                                         * Case 3:  not empty_no_pin
                                         */
                                        ast_copy_string(confno, confno_tmp, sizeof(confno));
                                        break;
                                    }
                                }
                            }
                        }
                        var = var->next;
                    }
                    ast_config_destroy(cfg);
                }
 
                if (ast_strlen_zero(confno) && (cfg = ast_load_realtime_multientry("meetme", "confno LIKE", "%", SENTINEL))) {
                    const char *catg;
                    for (catg = ast_category_browse(cfg, NULL); catg; catg = ast_category_browse(cfg, catg)) {
                        const char *confno_tmp = ast_variable_retrieve(cfg, catg, "confno");
                        const char *pin_tmp = ast_variable_retrieve(cfg, catg, "pin");
                        if (ast_strlen_zero(confno_tmp)) {
                            continue;
                        }
                        if (!dynamic) {
                            int found = 0;
                            /* For static:  run through the list and see if this conference is empty */
                            AST_LIST_LOCK(&confs);
                            AST_LIST_TRAVERSE(&confs, cnf, list) {
                                if (!strcmp(confno_tmp, cnf->confno)) {
                                    /* The conference exists, therefore it's not empty */
                                    found = 1;
                                    break;
                                }
                            }
                            AST_LIST_UNLOCK(&confs);
                            if (!found) {
                                /* At this point, we have a confno_tmp (realtime conference) that is empty */
                                if ((empty_no_pin && ast_strlen_zero(pin_tmp)) || (!empty_no_pin)) {
                                    /* Case 1:  empty_no_pin and pin is nonexistent (NULL)
                                     * Case 2:  empty_no_pin and pin is blank (but not NULL)
                                     * Case 3:  not empty_no_pin
                                     */
                                    ast_copy_string(confno, confno_tmp, sizeof(confno));
                                    break;
                                }
                            }
                        }
                    }
                    ast_config_destroy(cfg);
                }
            }
 
            /* Select first conference number not in use */
            if (ast_strlen_zero(confno) && dynamic) {
                AST_LIST_LOCK(&confs);
                for (i = 0; i < ARRAY_LEN(conf_map); i++) {
                    if (!conf_map[i]) {
                        snprintf(confno, sizeof(confno), "%d", i);
                        conf_map[i] = 1;
                        break;
                    }
                }
                AST_LIST_UNLOCK(&confs);
            }
 
            /* Not found? */
            if (ast_strlen_zero(confno)) {
                res = ast_streamfile(chan, "conf-noempty", ast_channel_language(chan));
                ast_test_suite_event_notify("PLAYBACK", "Message: conf-noempty");
                if (!res)
                    ast_waitstream(chan, "");
            } else {
                if (sscanf(confno, "%30d", &confno_int) == 1) {
                    if (!ast_test_flag64(&confflags, CONFFLAG_QUIET)) {
                        res = ast_streamfile(chan, "conf-enteringno", ast_channel_language(chan));
                        if (!res) {
                            ast_waitstream(chan, "");
                            res = ast_say_digits(chan, confno_int, "", ast_channel_language(chan));
                        }
                    }
                } else {
                    ast_log(LOG_ERROR, "Could not scan confno '%s'\n", confno);
                }
            }
        }
 
        while (allowretry && (ast_strlen_zero(confno)) && (++retrycnt < 4)) {
            /* Prompt user for conference number */
            res = ast_app_getdata(chan, "conf-getconfno", confno, sizeof(confno) - 1, 0);
            if (res < 0) {
                /* Don't try to validate when we catch an error */
                confno[0] = '\0';
                allowretry = 0;
                break;
            }
        }
        if (!ast_strlen_zero(confno)) {
            /* Check the validity of the conference */
            cnf = find_conf(chan, confno, 1, dynamic, the_pin,
                sizeof(the_pin), 1, &confflags);
            if (!cnf) {
                int too_early = 0;
 
                cnf = find_conf_realtime(chan, confno, 1, dynamic,
                    the_pin, sizeof(the_pin), 1, &confflags, &too_early, optargs);
                if (rt_schedule && too_early)
                    allowretry = 0;
            }
 
            if (!cnf) {
                if (allowretry) {
                    confno[0] = '\0';
                    res = ast_streamfile(chan, "conf-invalid", ast_channel_language(chan));
                    if (!res)
                        ast_waitstream(chan, "");
                    res = -1;
                }
            } else {
                /* Conference requires a pin for specified access level */
                int req_pin = !ast_strlen_zero(cnf->pin) ||
                    (!ast_strlen_zero(cnf->pinadmin) &&
                        ast_test_flag64(&confflags, CONFFLAG_ADMIN));
                /* The following logic was derived from a
                 * 4 variable truth table and defines which
                 * circumstances are not exempt from pin
                 * checking.
                 * If this needs to be modified, write the
                 * truth table back out from the boolean
                 * expression AB+A'D+C', change the erroneous
                 * result, and rederive the expression.
                 * Variables:
                 *  A: pin provided?
                 *  B: always prompt?
                 *  C: dynamic?
                 *  D: has users? */
                int not_exempt = !cnf->isdynamic;
                not_exempt = not_exempt || (!ast_strlen_zero(args.pin) && ast_test_flag64(&confflags, CONFFLAG_ALWAYSPROMPT));
                not_exempt = not_exempt || (ast_strlen_zero(args.pin) && cnf->users);
                if (req_pin && not_exempt) {
                    char pin[MAX_PIN] = "";
                    int j;
 
                    /* Allow the pin to be retried up to 3 times */
                    for (j = 0; j < 3; j++) {
                        if (*the_pin && (always_prompt == 0)) {
                            ast_copy_string(pin, the_pin, sizeof(pin));
                            res = 0;
                        } else {
                            /* Prompt user for pin if pin is required */
                            ast_test_suite_event_notify("PLAYBACK", "Message: conf-getpin\r\n"
                                "Channel: %s",
                                ast_channel_name(chan));
                            res = ast_app_getdata(chan, "conf-getpin", pin + strlen(pin), sizeof(pin) - 1 - strlen(pin), 0);
                        }
                        if (res >= 0) {
                            if ((!strcasecmp(pin, cnf->pin) &&
                                 (ast_strlen_zero(cnf->pinadmin) ||
                                  !ast_test_flag64(&confflags, CONFFLAG_ADMIN))) ||
                                 (!ast_strlen_zero(cnf->pinadmin) &&
                                  !strcasecmp(pin, cnf->pinadmin))) {
                                /* Pin correct */
                                allowretry = 0;
                                if (!ast_strlen_zero(cnf->pinadmin) && !strcasecmp(pin, cnf->pinadmin)) {
                                    if (!ast_strlen_zero(cnf->adminopts)) {
                                        char *opts = ast_strdupa(cnf->adminopts);
                                        ast_app_parse_options64(meetme_opts, &confflags, optargs, opts);
                                    }
                                } else {
                                    if (!ast_strlen_zero(cnf->useropts)) {
                                        char *opts = ast_strdupa(cnf->useropts);
                                        ast_app_parse_options64(meetme_opts, &confflags, optargs, opts);
                                    }
                                }
                                /* Run the conference */
                                ast_verb(4, "Starting recording of MeetMe Conference %s into file %s.%s.\n", cnf->confno, cnf->recordingfilename, cnf->recordingformat);
                                res = conf_run(chan, cnf, &confflags, optargs);
                                break;
                            } else {
                                /* Pin invalid */
                                if (!ast_streamfile(chan, "conf-invalidpin", ast_channel_language(chan))) {
                                    res = ast_waitstream(chan, AST_DIGIT_ANY);
                                    ast_stopstream(chan);
                                } else {
                                    ast_log(LOG_WARNING, "Couldn't play invalid pin msg!\n");
                                    break;
                                }
                                if (res < 0)
                                    break;
                                pin[0] = res;
                                pin[1] = '\0';
                                res = -1;
                                if (allowretry)
                                    confno[0] = '\0';
                            }
                        } else {
                            /* failed when getting the pin */
                            res = -1;
                            allowretry = 0;
                            /* see if we need to get rid of the conference */
                            break;
                        }
 
                        /* Don't retry pin with a static pin */
                        if (*the_pin && (always_prompt == 0)) {
                            break;
                        }
                    }
                } else {
                    /* No pin required */
                    allowretry = 0;
 
                    /* For RealTime conferences without a pin
                     * should still support loading options
                     */
                    if (!ast_strlen_zero(cnf->useropts)) {
                        char *opts = ast_strdupa(cnf->useropts);
                        ast_app_parse_options64(meetme_opts, &confflags, optargs, opts);
                    }
 
                    /* Run the conference */
                    res = conf_run(chan, cnf, &confflags, optargs);
                }
                dispose_conf(cnf);
                cnf = NULL;
            }
        }
    } while (allowretry);
 
    if (cnf)
        dispose_conf(cnf);
 
    return res;
}

References ast_conference::adminopts, args, ARRAY_LEN, ast_answer(), AST_APP_ARG, ast_app_getdata(), ast_app_parse_options64(), ast_category_browse(), ast_channel_language(), ast_channel_name(), ast_config_destroy(), ast_config_load, ast_copy_string(), AST_DECLARE_APP_ARGS, AST_DIGIT_ANY, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_load_realtime_multientry(), ast_log, ast_say_digits(), AST_STANDARD_APP_ARGS, AST_STATE_UP, ast_stopstream(), ast_strdupa, ast_streamfile(), ast_strlen_zero(), ast_test_flag64, ast_test_suite_event_notify, ast_variable_browse(), ast_variable_retrieve(), ast_verb, ast_waitstream(), conf_map, conf_run(), CONFFLAG_ADMIN, CONFFLAG_ALWAYSPROMPT, CONFFLAG_DYNAMIC, CONFFLAG_DYNAMICPIN, CONFFLAG_EMPTY, CONFFLAG_EMPTYNOPIN, CONFFLAG_QUIET, CONFIG_FILE_NAME, CONFIG_STATUS_FILEINVALID, ast_conference::confno, dispose_conf(), find_conf(), find_conf_realtime(), sip_to_pjsip::info(), ast_conference::isdynamic, LOG_ERROR, LOG_WARNING, MAX_CONFNUM, MAX_PIN, MAX_SETTINGS, meetme_opts, NULL, OPT_ARG_ARRAY_SIZE, options, parse(), ast_conference::pin, ast_conference::pinadmin, ast_conference::recordingfilename, ast_conference::recordingformat, rt_schedule, SENTINEL, strsep(), ast_conference::useropts, ast_conference::users, and var.

Referenced by load_module().

conf_flush()

static void conf_flush ( int  fd, struct ast_channel *  chan  )

static

Definition at line 2301 of file app_meetme.c.

{
    int x;
 
    /* read any frames that may be waiting on the channel
       and throw them away
    */
    if (chan) {
        struct ast_frame *f;
 
        /* when no frames are available, this will wait
           for 1 millisecond maximum
        */
        while (ast_waitfor(chan, 1) > 0) {
            f = ast_read(chan);
            if (f)
                ast_frfree(f);
            else /* channel was hung up or something else happened */
                break;
        }
    }
 
    /* flush any data sitting in the pseudo channel */
    x = DAHDI_FLUSH_ALL;
    if (ioctl(fd, DAHDI_FLUSH, &x))
        ast_log(LOG_WARNING, "Error flushing channel\n");
 
}

References ast_frfree, ast_log, ast_read(), ast_waitfor(), and LOG_WARNING.

Referenced by conf_run().

conf_free()

static int conf_free ( struct ast_conference *  conf )

static

Remove the conference from the list and free it.

We assume that this was called while holding conflock.

Definition at line 2333 of file app_meetme.c.

{
    int x;
    struct announce_listitem *item;
 
    AST_LIST_REMOVE(&confs, conf, list);
 
    meetme_stasis_generate_msg(conf, NULL, NULL, meetme_end_type(), NULL);
 
    if (conf->recording == MEETME_RECORD_ACTIVE) {
        conf->recording = MEETME_RECORD_TERMINATE;
        AST_LIST_UNLOCK(&confs);
        while (1) {
            usleep(1);
            AST_LIST_LOCK(&confs);
            if (conf->recording == MEETME_RECORD_OFF)
                break;
            AST_LIST_UNLOCK(&confs);
        }
    }
 
    for (x = 0; x < AST_FRAME_BITS; x++) {
        if (conf->transframe[x])
            ast_frfree(conf->transframe[x]);
        if (conf->transpath[x])
            ast_translator_free_path(conf->transpath[x]);
    }
    if (conf->announcethread != AST_PTHREADT_NULL) {
        ast_mutex_lock(&conf->announcelistlock);
        conf->announcethread_stop = 1;
        ast_softhangup(conf->chan, AST_SOFTHANGUP_EXPLICIT);
        ast_cond_signal(&conf->announcelist_addition);
        ast_mutex_unlock(&conf->announcelistlock);
        pthread_join(conf->announcethread, NULL);
 
        while ((item = AST_LIST_REMOVE_HEAD(&conf->announcelist, entry))) {
            /* If it's a voicemail greeting file we don't want to remove it */
            if (!item->vmrec){
                ast_filedelete(item->namerecloc, NULL);
            }
            ao2_ref(item, -1);
        }
        ast_mutex_destroy(&conf->announcelistlock);
    }
 
    if (conf->origframe)
        ast_frfree(conf->origframe);
    ast_hangup(conf->lchan);
    ast_hangup(conf->chan);
    if (conf->fd >= 0)
        close(conf->fd);
    if (conf->recordingfilename) {
        ast_free(conf->recordingfilename);
    }
    if (conf->usercontainer) {
        ao2_ref(conf->usercontainer, -1);
    }
    if (conf->recordingformat) {
        ast_free(conf->recordingformat);
    }
    ast_mutex_destroy(&conf->playlock);
    ast_mutex_destroy(&conf->listenlock);
    ast_mutex_destroy(&conf->recordthreadlock);
    ast_mutex_destroy(&conf->announcethreadlock);
    ast_free(conf);
 
    return 0;
}

References ao2_ref, ast_cond_signal, ast_filedelete(), AST_FRAME_BITS, ast_free, ast_frfree, ast_hangup(), AST_LIST_LOCK, AST_LIST_REMOVE, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, ast_translator_free_path(), item, MEETME_RECORD_ACTIVE, MEETME_RECORD_OFF, MEETME_RECORD_TERMINATE, meetme_stasis_generate_msg(), and NULL.

Referenced by dispose_conf().

conf_play()

static void conf_play ( struct ast_channel *  chan, struct ast_conference *  conf, enum entrance_sound  sound  )

static

Definition at line 1528 of file app_meetme.c.

{
    unsigned char *data;
    int len;
    int res = -1;
 
    ast_test_suite_event_notify("CONFPLAY", "Channel: %s\r\n"
        "Conference: %s\r\n"
        "Marked: %d",
        ast_channel_name(chan),
        conf->confno,
        conf->markedusers);
 
    if (!ast_check_hangup(chan))
        res = ast_autoservice_start(chan);
 
    AST_LIST_LOCK(&confs);
 
    switch(sound) {
    case ENTER:
        data = enter;
        len = sizeof(enter);
        break;
    case LEAVE:
        data = leave;
        len = sizeof(leave);
        break;
    default:
        data = NULL;
        len = 0;
    }
    if (data) {
        careful_write(conf->fd, data, len, 1);
    }
 
    AST_LIST_UNLOCK(&confs);
 
    if (!res)
        ast_autoservice_stop(chan);
}

References ast_autoservice_start(), ast_autoservice_stop(), ast_channel_name(), ast_check_hangup(), AST_LIST_LOCK, AST_LIST_UNLOCK, ast_test_suite_event_notify, careful_write(), ENTER, enter, LEAVE, leave, len(), and NULL.

Referenced by conf_run().

conf_queue_dtmf()

static void conf_queue_dtmf ( const struct ast_conference *  conf, const struct ast_conf_user *  sender, struct ast_frame *  f  )

static

Definition at line 2402 of file app_meetme.c.

{
    struct ast_conf_user *user;
    struct ao2_iterator user_iter;
 
    user_iter = ao2_iterator_init(conf->usercontainer, 0);
    while ((user = ao2_iterator_next(&user_iter))) {
        if (user == sender) {
            ao2_ref(user, -1);
            continue;
        }
        if (ast_write(user->chan, f) < 0)
            ast_log(LOG_WARNING, "Error writing frame to channel %s\n", ast_channel_name(user->chan));
        ao2_ref(user, -1);
    }
    ao2_iterator_destroy(&user_iter);
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_channel_name(), ast_log, ast_write(), LOG_WARNING, and user.

Referenced by conf_run().

conf_run()

static int conf_run ( struct ast_channel *  chan, struct ast_conference *  conf, struct ast_flags64 *  confflags, char *  optargs[]  )

static

Definition at line 3181 of file app_meetme.c.

{
    struct ast_conf_user *user = NULL;
    int fd;
    struct dahdi_confinfo dahdic, dahdic_empty;
    struct ast_frame *f;
    struct ast_channel *c;
    struct ast_frame fr;
    int outfd;
    int ms;
    int nfds;
    int res;
    int retrydahdi;
    int origfd;
    int musiconhold = 0, mohtempstopped = 0;
    int firstpass = 0;
    int lastmarked = 0;
    int currentmarked = 0;
    int ret = -1;
    int x;
    enum menu_modes menu_mode = MENU_DISABLED;
    int talkreq_manager = 0;
    int using_pseudo = 0;
    int duration = 20;
    int sent_event = 0;
    int checked = 0;
    int announcement_played = 0;
    struct timeval now;
    struct ast_dsp *dsp = NULL;
    struct ast_app *agi_app;
    char *agifile;
    const char *agifiledefault = "conf-background.agi", *tmpvar;
    char meetmesecs[30] = "";
    char exitcontext[AST_MAX_CONTEXT] = "";
    char recordingtmp[AST_MAX_EXTENSION * 2] = "";
    char members[10] = "";
    int dtmf = 0, opt_waitmarked_timeout = 0;
    time_t timeout = 0;
    struct dahdi_bufferinfo bi;
    char __buf[CONF_SIZE + AST_FRIENDLY_OFFSET];
    char *buf = __buf + AST_FRIENDLY_OFFSET;
    char *exitkeys = NULL;
    unsigned int calldurationlimit = 0;
    long timelimit = 0;
    long play_warning = 0;
    long warning_freq = 0;
    const char *warning_sound = NULL;
    const char *end_sound = NULL;
    char *parse;
    long time_left_ms = 0;
    struct timeval nexteventts = { 0, };
    int to;
    int setusercount = 0;
    int confsilence = 0, totalsilence = 0;
    char *mailbox, *context;
    struct ast_format_cap *cap_slin = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
 
    if (!cap_slin) {
        goto conf_run_cleanup;
    }
    ast_format_cap_append(cap_slin, ast_format_slin, 0);
 
    if (!(user = ao2_alloc(sizeof(*user), NULL))) {
        goto conf_run_cleanup;
    }
 
    /* Possible timeout waiting for marked user */
    if (ast_test_flag64(confflags, CONFFLAG_WAITMARKED) &&
        !ast_strlen_zero(optargs[OPT_ARG_WAITMARKED]) &&
        (sscanf(optargs[OPT_ARG_WAITMARKED], "%30d", &opt_waitmarked_timeout) == 1) &&
        (opt_waitmarked_timeout > 0)) {
        timeout = time(NULL) + opt_waitmarked_timeout;
    }
 
    if (ast_test_flag64(confflags, CONFFLAG_DURATION_STOP) && !ast_strlen_zero(optargs[OPT_ARG_DURATION_STOP])) {
        calldurationlimit = atoi(optargs[OPT_ARG_DURATION_STOP]);
        ast_verb(3, "Setting call duration limit to %u seconds.\n", calldurationlimit);
    }
 
    if (ast_test_flag64(confflags, CONFFLAG_DURATION_LIMIT) && !ast_strlen_zero(optargs[OPT_ARG_DURATION_LIMIT])) {
        char *limit_str, *warning_str, *warnfreq_str;
        const char *var;
 
        parse = optargs[OPT_ARG_DURATION_LIMIT];
        limit_str = strsep(&parse, ":");
        warning_str = strsep(&parse, ":");
        warnfreq_str = parse;
 
        timelimit = atol(limit_str);
        if (warning_str)
            play_warning = atol(warning_str);
        if (warnfreq_str)
            warning_freq = atol(warnfreq_str);
 
        if (!timelimit) {
            timelimit = play_warning = warning_freq = 0;
            warning_sound = NULL;
        } else if (play_warning > timelimit) {
            if (!warning_freq) {
                play_warning = 0;
            } else {
                while (play_warning > timelimit)
                    play_warning -= warning_freq;
                if (play_warning < 1)
                    play_warning = warning_freq = 0;
            }
        }
 
        ast_verb(3, "Setting conference duration limit to: %ldms.\n", timelimit);
        if (play_warning) {
            ast_verb(3, "Setting warning time to %ldms from the conference duration limit.\n", play_warning);
        }
        if (warning_freq) {
            ast_verb(3, "Setting warning frequency to %ldms.\n", warning_freq);
        }
 
        ast_channel_lock(chan);
        if ((var = pbx_builtin_getvar_helper(chan, "CONF_LIMIT_WARNING_FILE"))) {
            var = ast_strdupa(var);
        }
        ast_channel_unlock(chan);
 
        warning_sound = var ? var : "timeleft";
 
        ast_channel_lock(chan);
        if ((var = pbx_builtin_getvar_helper(chan, "CONF_LIMIT_TIMEOUT_FILE"))) {
            var = ast_strdupa(var);
        }
        ast_channel_unlock(chan);
 
        end_sound = var ? var : NULL;
 
        /* undo effect of S(x) in case they are both used */
        calldurationlimit = 0;
        /* more efficient do it like S(x) does since no advanced opts */
        if (!play_warning && !end_sound && timelimit) {
            calldurationlimit = timelimit / 1000;
            timelimit = play_warning = warning_freq = 0;
        } else {
            ast_debug(2, "Limit Data for this call:\n");
            ast_debug(2, "- timelimit     = %ld\n", timelimit);
            ast_debug(2, "- play_warning  = %ld\n", play_warning);
            ast_debug(2, "- warning_freq  = %ld\n", warning_freq);
            ast_debug(2, "- warning_sound = %s\n", warning_sound ? warning_sound : "UNDEF");
            ast_debug(2, "- end_sound     = %s\n", end_sound ? end_sound : "UNDEF");
        }
    }
 
    /* Get exit keys */
    if (ast_test_flag64(confflags, CONFFLAG_KEYEXIT)) {
        if (!ast_strlen_zero(optargs[OPT_ARG_EXITKEYS]))
            exitkeys = ast_strdupa(optargs[OPT_ARG_EXITKEYS]);
        else
            exitkeys = ast_strdupa("#"); /* Default */
    }
 
    if (ast_test_flag64(confflags, CONFFLAG_RECORDCONF)) {
        if (!conf->recordingfilename) {
            const char *var;
            ast_channel_lock(chan);
            if ((var = pbx_builtin_getvar_helper(chan, "MEETME_RECORDINGFILE"))) {
                conf->recordingfilename = ast_strdup(var);
            }
            if ((var = pbx_builtin_getvar_helper(chan, "MEETME_RECORDINGFORMAT"))) {
                conf->recordingformat = ast_strdup(var);
            }
            ast_channel_unlock(chan);
            if (!conf->recordingfilename) {
                snprintf(recordingtmp, sizeof(recordingtmp), "meetme-conf-rec-%s-%s", conf->confno, ast_channel_uniqueid(chan));
                conf->recordingfilename = ast_strdup(recordingtmp);
            }
            if (!conf->recordingformat) {
                conf->recordingformat = ast_strdup("wav");
            }
            ast_verb(4, "Starting recording of MeetMe Conference %s into file %s.%s.\n",
                    conf->confno, conf->recordingfilename, conf->recordingformat);
        }
    }
 
    ast_mutex_lock(&conf->recordthreadlock);
    if ((conf->recordthread == AST_PTHREADT_NULL) && ast_test_flag64(confflags, CONFFLAG_RECORDCONF) &&
        ((conf->lchan = ast_request("DAHDI", cap_slin, NULL, chan, "pseudo", NULL)))) {
        ast_set_read_format(conf->lchan, ast_format_slin);
        ast_set_write_format(conf->lchan, ast_format_slin);
        dahdic.chan = 0;
        dahdic.confno = conf->dahdiconf;
        dahdic.confmode = DAHDI_CONF_CONFANN | DAHDI_CONF_CONFANNMON;
        if (ioctl(ast_channel_fd(conf->lchan, 0), DAHDI_SETCONF, &dahdic)) {
            ast_log(LOG_WARNING, "Error starting listen channel\n");
            ast_hangup(conf->lchan);
            conf->lchan = NULL;
        } else {
            ast_pthread_create_detached_background(&conf->recordthread, NULL, recordthread, conf);
        }
    }
    ast_mutex_unlock(&conf->recordthreadlock);
 
    ast_mutex_lock(&conf->announcethreadlock);
    if ((conf->announcethread == AST_PTHREADT_NULL) && !ast_test_flag64(confflags, CONFFLAG_QUIET) &&
        ast_test_flag64(confflags, CONFFLAG_INTROUSER | CONFFLAG_INTROUSERNOREVIEW | CONFFLAG_INTROUSER_VMREC)) {
        ast_mutex_init(&conf->announcelistlock);
        AST_LIST_HEAD_INIT_NOLOCK(&conf->announcelist);
        ast_pthread_create_background(&conf->announcethread, NULL, announce_thread, conf);
    }
    ast_mutex_unlock(&conf->announcethreadlock);
 
    time(&user->jointime);
 
    user->timelimit = timelimit;
    user->play_warning = play_warning;
    user->warning_freq = warning_freq;
    user->warning_sound = warning_sound;
    user->end_sound = end_sound;
 
    if (calldurationlimit > 0) {
        time(&user->kicktime);
        user->kicktime = user->kicktime + calldurationlimit;
    }
 
    if (ast_tvzero(user->start_time))
        user->start_time = ast_tvnow();
    time_left_ms = user->timelimit;
 
    if (user->timelimit) {
        nexteventts = ast_tvadd(user->start_time, ast_samp2tv(user->timelimit, 1000));
        nexteventts = ast_tvsub(nexteventts, ast_samp2tv(user->play_warning, 1000));
    }
 
    if (conf->locked && (!ast_test_flag64(confflags, CONFFLAG_ADMIN))) {
        /* Sorry, but this conference is locked! */
        if (!ast_streamfile(chan, "conf-locked", ast_channel_language(chan)))
            ast_waitstream(chan, "");
        goto outrun;
    }
 
    ast_mutex_lock(&conf->playlock);
 
    if (rt_schedule && conf->maxusers) {
        if (conf->users >= conf->maxusers) {
            /* Sorry, but this confernce has reached the participant limit! */
            ast_mutex_unlock(&conf->playlock);
            if (!ast_streamfile(chan, "conf-full", ast_channel_language(chan)))
                ast_waitstream(chan, "");
            goto outrun;
        }
    }
 
    ao2_lock(conf->usercontainer);
    ao2_callback(conf->usercontainer, OBJ_NODATA, user_max_cmp, &user->user_no);
    user->user_no++;
    ao2_link(conf->usercontainer, user);
    ao2_unlock(conf->usercontainer);
 
    user->chan = chan;
    user->userflags = *confflags;
    user->adminflags = ast_test_flag64(confflags, CONFFLAG_STARTMUTED) ? ADMINFLAG_SELFMUTED : 0;
    if (!ast_test_flag64(confflags, CONFFLAG_ADMIN)) {
        user->adminflags |= (conf->gmuted) ? ADMINFLAG_MUTED : 0;
    }
    user->talking = -1;
 
    ast_mutex_unlock(&conf->playlock);
 
    if (!ast_test_flag64(confflags, CONFFLAG_QUIET) && (ast_test_flag64(confflags, CONFFLAG_INTROUSER | CONFFLAG_INTROUSERNOREVIEW | CONFFLAG_INTROUSER_VMREC))) {
        char destdir[PATH_MAX];
 
        snprintf(destdir, sizeof(destdir), "%s/meetme", ast_config_AST_SPOOL_DIR);
 
        if (ast_mkdir(destdir, 0777) != 0) {
            ast_log(LOG_WARNING, "mkdir '%s' failed: %s\n", destdir, strerror(errno));
            goto outrun;
        }
 
        if (ast_test_flag64(confflags, CONFFLAG_INTROUSER_VMREC)){
            context = ast_strdupa(optargs[OPT_ARG_INTROUSER_VMREC]);
            mailbox = strsep(&context, "@");
 
            if (ast_strlen_zero(mailbox)) {
                /* invalid input, clear the v flag*/
                ast_clear_flag64(confflags,CONFFLAG_INTROUSER_VMREC);
                ast_log(LOG_WARNING,"You must specify a mailbox in the v() option\n");
            } else {
                if (ast_strlen_zero(context)) {
                    context = "default";
                }
                /* if there is no mailbox we don't need to do this logic  */
                snprintf(user->namerecloc, sizeof(user->namerecloc),
                     "%s/voicemail/%s/%s/greet",ast_config_AST_SPOOL_DIR,context,mailbox);
 
                /* if the greeting doesn't exist then use the temp file method instead, clear flag v */
                if (!ast_fileexists(user->namerecloc, NULL, NULL)){
                    snprintf(user->namerecloc, sizeof(user->namerecloc),
                         "%s/meetme-username-%s-%d", destdir,
                         conf->confno, user->user_no);
                    ast_clear_flag64(confflags, CONFFLAG_INTROUSER_VMREC);
                }
            }
        } else {
            snprintf(user->namerecloc, sizeof(user->namerecloc),
                 "%s/meetme-username-%s-%d", destdir,
                 conf->confno, user->user_no);
        }
 
        res = 0;
        if (ast_test_flag64(confflags, CONFFLAG_INTROUSERNOREVIEW) && !ast_fileexists(user->namerecloc, NULL, NULL))
            res = ast_play_and_record(chan, "vm-rec-name", user->namerecloc, 10, "sln", &duration, NULL, ast_dsp_get_threshold_from_settings(THRESHOLD_SILENCE), 0, NULL);
        else if (ast_test_flag64(confflags, CONFFLAG_INTROUSER) && !ast_fileexists(user->namerecloc, NULL, NULL))
            res = ast_record_review(chan, "vm-rec-name", user->namerecloc, 10, "sln", &duration, NULL);
        if (res == -1)
            goto outrun;
 
    }
 
    ast_mutex_lock(&conf->playlock);
 
    if (ast_test_flag64(confflags, CONFFLAG_MARKEDUSER))
        conf->markedusers++;
    conf->users++;
    if (rt_log_members) {
        /* Update table */
        snprintf(members, sizeof(members), "%d", conf->users);
        ast_realtime_require_field("meetme",
            "confno", strlen(conf->confno) > 7 ? RQ_UINTEGER4 : strlen(conf->confno) > 4 ? RQ_UINTEGER3 : RQ_UINTEGER2, strlen(conf->confno),
            "members", RQ_UINTEGER1, strlen(members),
            NULL);
        ast_update_realtime("meetme", "confno", conf->confno, "members", members, NULL);
    }
    setusercount = 1;
 
    /* This device changed state now - if this is the first user */
    if (conf->users == 1)
        ast_devstate_changed(AST_DEVICE_INUSE, (conf->isdynamic ? AST_DEVSTATE_NOT_CACHABLE : AST_DEVSTATE_CACHABLE), "meetme:%s", conf->confno);
 
    ast_mutex_unlock(&conf->playlock);
 
    /* return the unique ID of the conference */
    pbx_builtin_setvar_helper(chan, "MEETMEUNIQUEID", conf->uniqueid);
 
    if (ast_test_flag64(confflags, CONFFLAG_EXIT_CONTEXT)) {
        ast_channel_lock(chan);
        if ((tmpvar = pbx_builtin_getvar_helper(chan, "MEETME_EXIT_CONTEXT"))) {
            ast_copy_string(exitcontext, tmpvar, sizeof(exitcontext));
        } else if (!ast_strlen_zero(ast_channel_macrocontext(chan))) {
            ast_copy_string(exitcontext, ast_channel_macrocontext(chan), sizeof(exitcontext));
        } else {
            ast_copy_string(exitcontext, ast_channel_context(chan), sizeof(exitcontext));
        }
        ast_channel_unlock(chan);
    }
 
    /* Play an arbitrary intro message */
    if (ast_test_flag64(confflags, CONFFLAG_INTROMSG) &&
            !ast_strlen_zero(optargs[OPT_ARG_INTROMSG])) {
        if (!ast_streamfile(chan, optargs[OPT_ARG_INTROMSG], ast_channel_language(chan))) {
            ast_waitstream(chan, "");
        }
    }
 
    if (!ast_test_flag64(confflags, (CONFFLAG_QUIET | CONFFLAG_NOONLYPERSON))) {
        if (conf->users == 1 && !ast_test_flag64(confflags, CONFFLAG_WAITMARKED))
            if (!ast_streamfile(chan, "conf-onlyperson", ast_channel_language(chan)))
                ast_waitstream(chan, "");
        if (ast_test_flag64(confflags, CONFFLAG_WAITMARKED) && conf->markedusers == 0)
            if (!ast_streamfile(chan, "conf-waitforleader", ast_channel_language(chan)))
                ast_waitstream(chan, "");
    }
 
    if (ast_test_flag64(confflags, CONFFLAG_ANNOUNCEUSERCOUNT) && conf->users > 1) {
        int keepplaying = 1;
 
        if (conf->users == 2) {
            if (!ast_streamfile(chan, "conf-onlyone", ast_channel_language(chan))) {
                res = ast_waitstream(chan, AST_DIGIT_ANY);
                ast_stopstream(chan);
                if (res > 0)
                    keepplaying = 0;
                else if (res == -1)
                    goto outrun;
            }
        } else {
            if (!ast_streamfile(chan, "conf-thereare", ast_channel_language(chan))) {
                res = ast_waitstream(chan, AST_DIGIT_ANY);
                ast_stopstream(chan);
                if (res > 0)
                    keepplaying = 0;
                else if (res == -1)
                    goto outrun;
            }
            if (keepplaying) {
                res = ast_say_number(chan, conf->users - 1, AST_DIGIT_ANY, ast_channel_language(chan), (char *) NULL);
                if (res > 0)
                    keepplaying = 0;
                else if (res == -1)
                    goto outrun;
            }
            if (keepplaying && !ast_streamfile(chan, "conf-otherinparty", ast_channel_language(chan))) {
                res = ast_waitstream(chan, AST_DIGIT_ANY);
                ast_stopstream(chan);
                if (res > 0)
                    keepplaying = 0;
                else if (res == -1)
                    goto outrun;
            }
        }
    }
 
    if (!ast_test_flag64(confflags, CONFFLAG_NO_AUDIO_UNTIL_UP)) {
        /* We're leaving this alone until the state gets changed to up */
        ast_indicate(chan, -1);
    }
 
    if (ast_set_write_format(chan, ast_format_slin) < 0) {
        ast_log(LOG_WARNING, "Unable to set '%s' to write linear mode\n", ast_channel_name(chan));
        goto outrun;
    }
 
    if (ast_set_read_format(chan, ast_format_slin) < 0) {
        ast_log(LOG_WARNING, "Unable to set '%s' to read linear mode\n", ast_channel_name(chan));
        goto outrun;
    }
 
    /* Reduce background noise from each participant */
    if (!ast_test_flag64(confflags, CONFFLAG_DONT_DENOISE)) {
        ast_func_write(chan, "DENOISE(rx)", "on");
    }
 
    retrydahdi = (strcasecmp(ast_channel_tech(chan)->type, "DAHDI") || (ast_channel_audiohooks(chan) || ast_channel_monitor(chan)) ? 1 : 0);
    user->dahdichannel = !retrydahdi;
 
 dahdiretry:
    origfd = ast_channel_fd(chan, 0);
    if (retrydahdi) {
        /* open pseudo in non-blocking mode */
        fd = open("/dev/dahdi/pseudo", O_RDWR | O_NONBLOCK);
        if (fd < 0) {
            ast_log(LOG_WARNING, "Unable to open DAHDI pseudo channel: %s\n", strerror(errno));
            goto outrun;
        }
        using_pseudo = 1;
        /* Setup buffering information */
        memset(&bi, 0, sizeof(bi));
        bi.bufsize = CONF_SIZE / 2;
        bi.txbufpolicy = DAHDI_POLICY_IMMEDIATE;
        bi.rxbufpolicy = DAHDI_POLICY_IMMEDIATE;
        bi.numbufs = audio_buffers;
        if (ioctl(fd, DAHDI_SET_BUFINFO, &bi)) {
            ast_log(LOG_WARNING, "Unable to set buffering information: %s\n", strerror(errno));
            close(fd);
            goto outrun;
        }
        x = 1;
        if (ioctl(fd, DAHDI_SETLINEAR, &x)) {
            ast_log(LOG_WARNING, "Unable to set linear mode: %s\n", strerror(errno));
            close(fd);
            goto outrun;
        }
        nfds = 1;
    } else {
        /* XXX Make sure we're not running on a pseudo channel XXX */
        fd = ast_channel_fd(chan, 0);
        nfds = 0;
    }
    memset(&dahdic, 0, sizeof(dahdic));
    memset(&dahdic_empty, 0, sizeof(dahdic_empty));
    /* Check to see if we're in a conference... */
    dahdic.chan = 0;
    if (ioctl(fd, DAHDI_GETCONF, &dahdic)) {
        ast_log(LOG_WARNING, "Error getting conference\n");
        close(fd);
        goto outrun;
    }
    if (dahdic.confmode) {
        /* Whoa, already in a conference...  Retry... */
        if (!retrydahdi) {
            ast_debug(1, "DAHDI channel is in a conference already, retrying with pseudo\n");
            retrydahdi = 1;
            goto dahdiretry;
        }
    }
    memset(&dahdic, 0, sizeof(dahdic));
    /* Add us to the conference */
    dahdic.chan = 0;
    dahdic.confno = conf->dahdiconf;
 
    if (!ast_test_flag64(confflags, CONFFLAG_QUIET) && (ast_test_flag64(confflags, CONFFLAG_INTROUSER) ||
            ast_test_flag64(confflags, CONFFLAG_INTROUSERNOREVIEW) || ast_test_flag64(confflags, CONFFLAG_INTROUSER_VMREC)) && conf->users > 1) {
        struct announce_listitem *item;
        if (!(item = ao2_alloc(sizeof(*item), NULL)))
            goto outrun;
        ast_copy_string(item->namerecloc, user->namerecloc, sizeof(item->namerecloc));
        ast_copy_string(item->language, ast_channel_language(chan), sizeof(item->language));
        item->confchan = conf->chan;
        item->confusers = conf->users;
        if (ast_test_flag64(confflags, CONFFLAG_INTROUSER_VMREC)){
            item->vmrec = 1;
        }
        item->announcetype = CONF_HASJOIN;
        ast_mutex_lock(&conf->announcelistlock);
        ao2_ref(item, +1); /* add one more so we can determine when announce_thread is done playing it */
        AST_LIST_INSERT_TAIL(&conf->announcelist, item, entry);
        ast_cond_signal(&conf->announcelist_addition);
        ast_mutex_unlock(&conf->announcelistlock);
 
        while (!ast_check_hangup(conf->chan) && ao2_ref(item, 0) == 2 && !ast_safe_sleep(chan, 1000)) {
            ;
        }
        ao2_ref(item, -1);
    }
 
    if (ast_test_flag64(confflags, CONFFLAG_WAITMARKED) && !conf->markedusers)
        dahdic.confmode = DAHDI_CONF_CONF;
    else if (ast_test_flag64(confflags, CONFFLAG_MONITOR))
        dahdic.confmode = DAHDI_CONF_CONFMON | DAHDI_CONF_LISTENER;
    else if (ast_test_flag64(confflags, CONFFLAG_TALKER))
        dahdic.confmode = DAHDI_CONF_CONF | DAHDI_CONF_TALKER;
    else
        dahdic.confmode = DAHDI_CONF_CONF | DAHDI_CONF_TALKER | DAHDI_CONF_LISTENER;
 
    if (ioctl(fd, DAHDI_SETCONF, &dahdic)) {
        ast_log(LOG_WARNING, "Error setting conference\n");
        close(fd);
        goto outrun;
    }
    ast_debug(1, "Placed channel %s in DAHDI conf %d\n", ast_channel_name(chan), conf->dahdiconf);
 
    if (!sent_event) {
        meetme_stasis_generate_msg(conf, chan, user, meetme_join_type(), NULL);
        sent_event = 1;
    }
 
    if (!firstpass && !ast_test_flag64(confflags, CONFFLAG_MONITOR) &&
        !ast_test_flag64(confflags, CONFFLAG_ADMIN)) {
        firstpass = 1;
        if (!ast_test_flag64(confflags, CONFFLAG_QUIET))
            if (!ast_test_flag64(confflags, CONFFLAG_WAITMARKED) || (ast_test_flag64(confflags, CONFFLAG_MARKEDUSER) &&
                (conf->markedusers >= 1))) {
                conf_play(chan, conf, ENTER);
            }
    }
 
    conf_flush(fd, chan);
 
    if (dsp)
        ast_dsp_free(dsp);
 
    if (!(dsp = ast_dsp_new())) {
        ast_log(LOG_WARNING, "Unable to allocate DSP!\n");
        res = -1;
    }
 
    if (ast_test_flag64(confflags, CONFFLAG_AGI)) {
        /* Get name of AGI file to run from $(MEETME_AGI_BACKGROUND)
           or use default filename of conf-background.agi */
 
        ast_channel_lock(chan);
        if ((tmpvar = pbx_builtin_getvar_helper(chan, "MEETME_AGI_BACKGROUND"))) {
            agifile = ast_strdupa(tmpvar);
        } else {
            agifile = ast_strdupa(agifiledefault);
        }
        ast_channel_unlock(chan);
 
        if (user->dahdichannel) {
            /*  Set CONFMUTE mode on DAHDI channel to mute DTMF tones */
            x = 1;
            ast_channel_setoption(chan, AST_OPTION_TONE_VERIFY, &x, sizeof(char), 0);
        }
        /* Find a pointer to the agi app and execute the script */
        agi_app = pbx_findapp("agi");
        if (agi_app) {
            ret = pbx_exec(chan, agi_app, agifile);
        } else {
            ast_log(LOG_WARNING, "Could not find application (agi)\n");
            ret = -2;
        }
        if (user->dahdichannel) {
            /*  Remove CONFMUTE mode on DAHDI channel */
            x = 0;
            ast_channel_setoption(chan, AST_OPTION_TONE_VERIFY, &x, sizeof(char), 0);
        }
    } else {
        int lastusers = conf->users;
        if (user->dahdichannel && ast_test_flag64(confflags, CONFFLAG_STARMENU)) {
            /*  Set CONFMUTE mode on DAHDI channel to mute DTMF tones when the menu is enabled */
            x = 1;
            ast_channel_setoption(chan, AST_OPTION_TONE_VERIFY, &x, sizeof(char), 0);
        }
 
        for (;;) {
            int menu_was_active = 0;
 
            outfd = -1;
            ms = -1;
            now = ast_tvnow();
 
            if (rt_schedule && conf->endtime) {
                char currenttime[32];
                long localendtime = 0;
                int extended = 0;
                struct ast_tm tm;
                struct ast_variable *var, *origvar;
                struct timeval tmp;
 
                if (now.tv_sec % 60 == 0) {
                    if (!checked) {
                        ast_localtime(&now, &tm, NULL);
                        ast_strftime(currenttime, sizeof(currenttime), DATE_FORMAT, &tm);
                        var = origvar = ast_load_realtime("meetme", "confno",
                            conf->confno, "starttime <=", currenttime,
                             "endtime >=", currenttime, NULL);
 
                        for ( ; var; var = var->next) {
                            if (!strcasecmp(var->name, "endtime")) {
                                struct ast_tm endtime_tm;
                                ast_strptime(var->value, "%Y-%m-%d %H:%M:%S", &endtime_tm);
                                tmp = ast_mktime(&endtime_tm, NULL);
                                localendtime = tmp.tv_sec;
                            }
                        }
                        ast_variables_destroy(origvar);
 
                        /* A conference can be extended from the
                           Admin/User menu or by an external source */
                        if (localendtime > conf->endtime){
                            conf->endtime = localendtime;
                            extended = 1;
                        }
 
                        if (conf->endtime && (now.tv_sec >= conf->endtime)) {
                            ast_verbose("Quitting time...\n");
                            goto outrun;
                        }
 
                        if (!announcement_played && conf->endalert) {
                            if (now.tv_sec + conf->endalert >= conf->endtime) {
                                if (!ast_streamfile(chan, "conf-will-end-in", ast_channel_language(chan)))
                                    ast_waitstream(chan, "");
                                ast_say_digits(chan, (conf->endtime - now.tv_sec) / 60, "", ast_channel_language(chan));
                                if (!ast_streamfile(chan, "minutes", ast_channel_language(chan)))
                                    ast_waitstream(chan, "");
                                if (musiconhold) {
                                    conf_start_moh(chan, optargs[OPT_ARG_MOH_CLASS]);
                                }
                                announcement_played = 1;
                            }
                        }
 
                        if (extended) {
                            announcement_played = 0;
                        }
 
                        checked = 1;
                    }
                } else {
                    checked = 0;
                }
            }
 
            if (user->kicktime && (user->kicktime <= now.tv_sec)) {
                if (ast_test_flag64(confflags, CONFFLAG_KICK_CONTINUE)) {
                    ret = 0;
                } else {
                    ret = -1;
                }
                break;
            }
 
            to = -1;
            if (user->timelimit) {
                int minutes = 0, seconds = 0, remain = 0;
 
                to = ast_tvdiff_ms(nexteventts, now);
                if (to < 0) {
                    to = 0;
                }
                time_left_ms = user->timelimit - ast_tvdiff_ms(now, user->start_time);
                if (time_left_ms < to) {
                    to = time_left_ms;
                }
 
                if (time_left_ms <= 0) {
                    if (user->end_sound) {
                        res = ast_streamfile(chan, user->end_sound, ast_channel_language(chan));
                        res = ast_waitstream(chan, "");
                    }
                    if (ast_test_flag64(confflags, CONFFLAG_KICK_CONTINUE)) {
                        ret = 0;
                    } else {
                        ret = -1;
                    }
                    break;
                }
 
                if (!to) {
                    if (time_left_ms >= 5000) {
 
                        remain = (time_left_ms + 500) / 1000;
                        if (remain / 60 >= 1) {
                            minutes = remain / 60;
                            seconds = remain % 60;
                        } else {
                            seconds = remain;
                        }
 
                        /* force the time left to round up if appropriate */
                        if (user->warning_sound && user->play_warning) {
                            if (!strcmp(user->warning_sound, "timeleft")) {
 
                                res = ast_streamfile(chan, "vm-youhave", ast_channel_language(chan));
                                res = ast_waitstream(chan, "");
                                if (minutes) {
                                    res = ast_say_number(chan, minutes, AST_DIGIT_ANY, ast_channel_language(chan), (char *) NULL);
                                    res = ast_streamfile(chan, "queue-minutes", ast_channel_language(chan));
                                    res = ast_waitstream(chan, "");
                                }
                                if (seconds) {
                                    res = ast_say_number(chan, seconds, AST_DIGIT_ANY, ast_channel_language(chan), (char *) NULL);
                                    res = ast_streamfile(chan, "queue-seconds", ast_channel_language(chan));
                                    res = ast_waitstream(chan, "");
                                }
                            } else {
                                res = ast_streamfile(chan, user->warning_sound, ast_channel_language(chan));
                                res = ast_waitstream(chan, "");
                            }
                            if (musiconhold) {
                                conf_start_moh(chan, optargs[OPT_ARG_MOH_CLASS]);
                            }
                        }
                    }
                    if (user->warning_freq) {
                        nexteventts = ast_tvadd(nexteventts, ast_samp2tv(user->warning_freq, 1000));
                    } else {
                        nexteventts = ast_tvadd(user->start_time, ast_samp2tv(user->timelimit, 1000));
                    }
                }
            }
 
            now = ast_tvnow();
            if (timeout && now.tv_sec >= timeout) {
                if (ast_test_flag64(confflags, CONFFLAG_KICK_CONTINUE)) {
                    ret = 0;
                } else {
                    ret = -1;
                }
                break;
            }
 
            /* if we have just exited from the menu, and the user had a channel-driver
               volume adjustment, restore it
            */
            if (!menu_mode && menu_was_active && user->listen.desired && !user->listen.actual) {
                set_talk_volume(user, user->listen.desired);
            }
 
            menu_was_active = menu_mode;
 
            currentmarked = conf->markedusers;
            if (!ast_test_flag64(confflags, CONFFLAG_QUIET) &&
                ast_test_flag64(confflags, CONFFLAG_MARKEDUSER) &&
                ast_test_flag64(confflags, CONFFLAG_WAITMARKED) &&
                lastmarked == 0) {
                if (currentmarked == 1 && conf->users > 1) {
                    ast_say_number(chan, conf->users - 1, AST_DIGIT_ANY, ast_channel_language(chan), (char *) NULL);
                    if (conf->users - 1 == 1) {
                        if (!ast_streamfile(chan, "conf-userwilljoin", ast_channel_language(chan))) {
                            ast_waitstream(chan, "");
                        }
                    } else {
                        if (!ast_streamfile(chan, "conf-userswilljoin", ast_channel_language(chan))) {
                            ast_waitstream(chan, "");
                        }
                    }
                }
                if (conf->users == 1 && !ast_test_flag64(confflags, CONFFLAG_MARKEDUSER)) {
                    if (!ast_streamfile(chan, "conf-onlyperson", ast_channel_language(chan))) {
                        ast_waitstream(chan, "");
                    }
                }
            }
 
            /* Update the struct with the actual confflags */
            user->userflags = *confflags;
 
            if (ast_test_flag64(confflags, CONFFLAG_WAITMARKED)) {
                if (currentmarked == 0) {
                    if (lastmarked != 0) {
                        if (!ast_test_flag64(confflags, CONFFLAG_QUIET)) {
                            if (!ast_streamfile(chan, "conf-leaderhasleft", ast_channel_language(chan))) {
                                ast_waitstream(chan, "");
                            }
                        }
                        if (ast_test_flag64(confflags, CONFFLAG_MARKEDEXIT)) {
                            if (ast_test_flag64(confflags, CONFFLAG_KICK_CONTINUE)) {
                                ret = 0;
                            }
                            break;
                        } else {
                            dahdic.confmode = DAHDI_CONF_CONF;
                            if (ioctl(fd, DAHDI_SETCONF, &dahdic)) {
                                ast_log(LOG_WARNING, "Error setting conference\n");
                                close(fd);
                                goto outrun;
                            }
                        }
                    }
                    if (!musiconhold && (ast_test_flag64(confflags, CONFFLAG_MOH))) {
                        conf_start_moh(chan, optargs[OPT_ARG_MOH_CLASS]);
                        musiconhold = 1;
                    }
                } else if (currentmarked >= 1 && lastmarked == 0) {
                    /* Marked user entered, so cancel timeout */
                    timeout = 0;
                    if (ast_test_flag64(confflags, CONFFLAG_MONITOR)) {
                        dahdic.confmode = DAHDI_CONF_CONFMON | DAHDI_CONF_LISTENER;
                    } else if (ast_test_flag64(confflags, CONFFLAG_TALKER)) {
                        dahdic.confmode = DAHDI_CONF_CONF | DAHDI_CONF_TALKER;
                    } else {
                        dahdic.confmode = DAHDI_CONF_CONF | DAHDI_CONF_TALKER | DAHDI_CONF_LISTENER;
                    }
                    if (ioctl(fd, DAHDI_SETCONF, &dahdic)) {
                        ast_log(LOG_WARNING, "Error setting conference\n");
                        close(fd);
                        goto outrun;
                    }
                    if (musiconhold && (ast_test_flag64(confflags, CONFFLAG_MOH))) {
                        ast_moh_stop(chan);
                        musiconhold = 0;
                    }
                    if (!ast_test_flag64(confflags, CONFFLAG_QUIET) &&
                        !ast_test_flag64(confflags, CONFFLAG_MARKEDUSER)) {
                        if (!ast_streamfile(chan, "conf-placeintoconf", ast_channel_language(chan))) {
                            ast_waitstream(chan, "");
                        }
                        conf_play(chan, conf, ENTER);
                    }
                }
            }
 
            /* trying to add moh for single person conf */
            if (ast_test_flag64(confflags, CONFFLAG_MOH) && !ast_test_flag64(confflags, CONFFLAG_WAITMARKED)) {
                if (conf->users == 1) {
                    if (!musiconhold) {
                        conf_start_moh(chan, optargs[OPT_ARG_MOH_CLASS]);
                        musiconhold = 1;
                    }
                } else {
                    if (musiconhold) {
                        ast_moh_stop(chan);
                        musiconhold = 0;
                    }
                }
            }
 
            /* Leave if the last marked user left */
            if (currentmarked == 0 && lastmarked != 0 && ast_test_flag64(confflags, CONFFLAG_MARKEDEXIT)) {
                if (ast_test_flag64(confflags, CONFFLAG_KICK_CONTINUE)) {
                    ret = 0;
                } else {
                    ret = -1;
                }
                break;
            }
 
            /* Throw a TestEvent if a user exit did not cause this user to leave the conference */
            if (conf->users != lastusers) {
                if (conf->users < lastusers) {
                    ast_test_suite_event_notify("NOEXIT", "Message: CONFFLAG_MARKEDEXIT\r\nLastUsers: %d\r\nUsers: %d", lastusers, conf->users);
                }
                lastusers = conf->users;
            }
 
            /* Check if my modes have changed */
 
            /* If I should be muted but am still talker, mute me */
            if ((user->adminflags & (ADMINFLAG_MUTED | ADMINFLAG_SELFMUTED)) && (dahdic.confmode & DAHDI_CONF_TALKER)) {
                RAII_VAR(struct ast_json *, status_blob, status_to_json(1), ast_json_unref);
                dahdic.confmode ^= DAHDI_CONF_TALKER;
                if (ioctl(fd, DAHDI_SETCONF, &dahdic)) {
                    ast_log(LOG_WARNING, "Error setting conference - Un/Mute \n");
                    ret = -1;
                    break;
                }
 
                /* Indicate user is not talking anymore - change him to unmonitored state */
                if (ast_test_flag64(confflags,  (CONFFLAG_MONITORTALKER | CONFFLAG_OPTIMIZETALKER))) {
                    set_user_talking(chan, conf, user, -1, ast_test_flag64(confflags, CONFFLAG_MONITORTALKER));
                }
                meetme_stasis_generate_msg(conf, chan, user, meetme_mute_type(), status_blob);
            }
 
            /* If I should be un-muted but am not talker, un-mute me */
            if (!(user->adminflags & (ADMINFLAG_MUTED | ADMINFLAG_SELFMUTED)) && !ast_test_flag64(confflags, CONFFLAG_MONITOR) && !(dahdic.confmode & DAHDI_CONF_TALKER)) {
                RAII_VAR(struct ast_json *, status_blob, status_to_json(0), ast_json_unref);
                dahdic.confmode |= DAHDI_CONF_TALKER;
                if (ioctl(fd, DAHDI_SETCONF, &dahdic)) {
                    ast_log(LOG_WARNING, "Error setting conference - Un/Mute \n");
                    ret = -1;
                    break;
                }
                meetme_stasis_generate_msg(conf, chan, user, meetme_mute_type(), status_blob);
            }
 
            if ((user->adminflags & (ADMINFLAG_MUTED | ADMINFLAG_SELFMUTED)) &&
                (user->adminflags & ADMINFLAG_T_REQUEST) && !(talkreq_manager)) {
 
                RAII_VAR(struct ast_json *, status_blob, status_to_json(1), ast_json_unref);
                talkreq_manager = 1;
                meetme_stasis_generate_msg(conf, chan, user, meetme_talk_request_type(), status_blob);
            }
 
            if (!(user->adminflags & (ADMINFLAG_MUTED | ADMINFLAG_SELFMUTED)) &&
                !(user->adminflags & ADMINFLAG_T_REQUEST) && (talkreq_manager)) {
                RAII_VAR(struct ast_json *, status_blob, status_to_json(0), ast_json_unref);
                talkreq_manager = 0;
                meetme_stasis_generate_msg(conf, chan, user, meetme_talk_request_type(), status_blob);
            }
 
            /* If user have been hung up, exit the conference */
            if (user->adminflags & ADMINFLAG_HANGUP) {
                ret = 0;
                break;
            }
 
            /* If I have been kicked, exit the conference */
            if (user->adminflags & ADMINFLAG_KICKME) {
                /* You have been kicked. */
                if (!ast_test_flag64(confflags, CONFFLAG_QUIET) &&
                    !ast_streamfile(chan, "conf-kicked", ast_channel_language(chan))) {
                    ast_waitstream(chan, "");
                }
                ret = 0;
                break;
            }
 
            /* Perform a hangup check here since ast_waitfor_nandfds will not always be able to get a channel after a hangup has occurred */
            if (ast_check_hangup(chan)) {
                break;
            }
 
            c = ast_waitfor_nandfds(&chan, 1, &fd, nfds, NULL, &outfd, &ms);
 
            if (c) {
                char dtmfstr[2] = "";
 
                if (ast_channel_fd(c, 0) != origfd || (user->dahdichannel && (ast_channel_audiohooks(c) || ast_channel_monitor(c)))) {
                    if (using_pseudo) {
                        /* Kill old pseudo */
                        close(fd);
                        using_pseudo = 0;
                    }
                    ast_debug(1, "Ooh, something swapped out under us, starting over\n");
                    retrydahdi = (strcasecmp(ast_channel_tech(c)->type, "DAHDI") || (ast_channel_audiohooks(c) || ast_channel_monitor(c)) ? 1 : 0);
                    user->dahdichannel = !retrydahdi;
                    goto dahdiretry;
                }
                if (ast_test_flag64(confflags, CONFFLAG_MONITOR) || (user->adminflags & (ADMINFLAG_MUTED | ADMINFLAG_SELFMUTED))) {
                    f = ast_read_noaudio(c);
                } else {
                    f = ast_read(c);
                }
                if (!f) {
                    break;
                }
                if (f->frametype == AST_FRAME_DTMF) {
                    dtmfstr[0] = f->subclass.integer;
                    dtmfstr[1] = '\0';
                }
 
                if ((f->frametype == AST_FRAME_VOICE) && (ast_format_cmp(f->subclass.format, ast_format_slin) == AST_FORMAT_CMP_EQUAL)) {
                    if (user->talk.actual) {
                        ast_frame_adjust_volume(f, user->talk.actual);
                    }
 
                    if (ast_test_flag64(confflags, (CONFFLAG_OPTIMIZETALKER | CONFFLAG_MONITORTALKER))) {
                        if (user->talking == -1) {
                            user->talking = 0;
                        }
 
                        res = ast_dsp_silence(dsp, f, &totalsilence);
                        if (!user->talking && totalsilence < MEETME_DELAYDETECTTALK) {
                            set_user_talking(chan, conf, user, 1, ast_test_flag64(confflags, CONFFLAG_MONITORTALKER));
                        }
 
                        if (user->talking && totalsilence > MEETME_DELAYDETECTENDTALK) {
                            set_user_talking(chan, conf, user, 0, ast_test_flag64(confflags, CONFFLAG_MONITORTALKER));
                        }
                    }
                    if (using_pseudo) {
                        /* Absolutely do _not_ use careful_write here...
                           it is important that we read data from the channel
                           as fast as it arrives, and feed it into the conference.
                           The buffering in the pseudo channel will take care of any
                           timing differences, unless they are so drastic as to lose
                           audio frames (in which case carefully writing would only
                           have delayed the audio even further).
                        */
                        /* As it turns out, we do want to use careful write.  We just
                           don't want to block, but we do want to at least *try*
                           to write out all the samples.
                         */
                        if (user->talking || !ast_test_flag64(confflags, CONFFLAG_OPTIMIZETALKER)) {
                            careful_write(fd, f->data.ptr, f->datalen, 0);
                        }
                    }
                } else if (((f->frametype == AST_FRAME_DTMF) && (f->subclass.integer == '*') && ast_test_flag64(confflags, CONFFLAG_STARMENU)) || ((f->frametype == AST_FRAME_DTMF) && menu_mode)) {
                    if (ast_test_flag64(confflags, CONFFLAG_PASS_DTMF)) {
                        conf_queue_dtmf(conf, user, f);
                    }
                    /* Take out of conference */
                    if (ioctl(fd, DAHDI_SETCONF, &dahdic_empty)) {
                        ast_log(LOG_WARNING, "Error setting conference\n");
                        close(fd);
                        ast_frfree(f);
                        goto outrun;
                    }
 
                    /* if we are entering the menu, and the user has a channel-driver
                       volume adjustment, clear it
                    */
                    if (!menu_mode && user->talk.desired && !user->talk.actual) {
                        set_talk_volume(user, 0);
                    }
 
                    if (musiconhold) {
                        ast_moh_stop(chan);
                    } else if (!menu_mode) {
                        char *menu_to_play;
                        if (ast_test_flag64(confflags, CONFFLAG_ADMIN)) {
                            menu_mode = MENU_ADMIN;
                            menu_to_play = "conf-adminmenu-18";
                        } else {
                            menu_mode = MENU_NORMAL;
                            menu_to_play = "conf-usermenu-162";
                        }
 
                        if (!ast_streamfile(chan, menu_to_play, ast_channel_language(chan))) {
                            dtmf = ast_waitstream(chan, AST_DIGIT_ANY);
                            ast_stopstream(chan);
                        } else {
                            dtmf = 0;
                        }
                    } else {
                        dtmf = f->subclass.integer;
                    }
 
                    if (dtmf > 0) {
                        meetme_menu(&menu_mode, &dtmf, conf, confflags,
                            chan, user, recordingtmp, sizeof(recordingtmp), cap_slin);
                    }
 
                    if (musiconhold && !menu_mode) {
                        conf_start_moh(chan, optargs[OPT_ARG_MOH_CLASS]);
                    }
 
                    /* Put back into conference */
                    if (ioctl(fd, DAHDI_SETCONF, &dahdic)) {
                        ast_log(LOG_WARNING, "Error setting conference\n");
                        close(fd);
                        ast_frfree(f);
                        goto outrun;
                    }
 
                    conf_flush(fd, chan);
                /*
                 * Since options using DTMF could absorb DTMF meant for the
                 * conference menu, we have to check them after the menu.
                 */
                } else if ((f->frametype == AST_FRAME_DTMF) && ast_test_flag64(confflags, CONFFLAG_EXIT_CONTEXT) && ast_exists_extension(chan, exitcontext, dtmfstr, 1, "")) {
                    if (ast_test_flag64(confflags, CONFFLAG_PASS_DTMF)) {
                        conf_queue_dtmf(conf, user, f);
                    }
 
                    if (!ast_goto_if_exists(chan, exitcontext, dtmfstr, 1)) {
                        ast_debug(1, "Got DTMF %c, goto context %s\n", dtmfstr[0], exitcontext);
                        ret = 0;
                        ast_frfree(f);
                        break;
                    } else {
                        ast_debug(2, "Exit by single digit did not work in meetme. Extension %s does not exist in context %s\n", dtmfstr, exitcontext);
                    }
                } else if ((f->frametype == AST_FRAME_DTMF) && ast_test_flag64(confflags, CONFFLAG_KEYEXIT) &&
                    (strchr(exitkeys, f->subclass.integer))) {
                    pbx_builtin_setvar_helper(chan, "MEETME_EXIT_KEY", dtmfstr);
 
                    if (ast_test_flag64(confflags, CONFFLAG_PASS_DTMF)) {
                        conf_queue_dtmf(conf, user, f);
                    }
                    ret = 0;
                    ast_frfree(f);
                    break;
                } else if ((f->frametype == AST_FRAME_DTMF_BEGIN || f->frametype == AST_FRAME_DTMF_END)
                    && ast_test_flag64(confflags, CONFFLAG_PASS_DTMF)) {
                    conf_queue_dtmf(conf, user, f);
                } else if (ast_test_flag64(confflags, CONFFLAG_SLA_STATION) && f->frametype == AST_FRAME_CONTROL) {
                    switch (f->subclass.integer) {
                    case AST_CONTROL_HOLD:
                        sla_queue_event_conf(SLA_EVENT_HOLD, chan, conf);
                        break;
                    default:
                        break;
                    }
                } else if (f->frametype == AST_FRAME_NULL) {
                    /* Ignore NULL frames. It is perfectly normal to get these if the person is muted. */
                } else if (f->frametype == AST_FRAME_CONTROL) {
                    switch (f->subclass.integer) {
                    case AST_CONTROL_BUSY:
                    case AST_CONTROL_CONGESTION:
                        ast_frfree(f);
                        goto outrun;
                        break;
                    default:
                        ast_debug(1,
                            "Got ignored control frame on channel %s, f->frametype=%u,f->subclass=%d\n",
                            ast_channel_name(chan), f->frametype, f->subclass.integer);
                    }
                } else {
                    ast_debug(1,
                        "Got unrecognized frame on channel %s, f->frametype=%u,f->subclass=%d\n",
                        ast_channel_name(chan), f->frametype, f->subclass.integer);
                }
                ast_frfree(f);
            } else if (outfd > -1) {
                res = read(outfd, buf, CONF_SIZE);
                if (res > 0) {
                    memset(&fr, 0, sizeof(fr));
                    fr.frametype = AST_FRAME_VOICE;
                    fr.subclass.format = ast_format_slin;
                    fr.datalen = res;
                    fr.samples = res / 2;
                    fr.data.ptr = buf;
                    fr.offset = AST_FRIENDLY_OFFSET;
                    if (!user->listen.actual &&
                        (ast_test_flag64(confflags, CONFFLAG_MONITOR) ||
                         (user->adminflags & (ADMINFLAG_MUTED | ADMINFLAG_SELFMUTED)) ||
                         (!user->talking && ast_test_flag64(confflags, CONFFLAG_OPTIMIZETALKER))
                         )) {
                        int idx;
                        for (idx = 0; idx < AST_FRAME_BITS; idx++) {
                            if (ast_format_compatibility_format2bitfield(ast_channel_rawwriteformat(chan)) & (1 << idx)) {
                                break;
                            }
                        }
                        if (idx >= AST_FRAME_BITS) {
                            goto bailoutandtrynormal;
                        }
                        ast_mutex_lock(&conf->listenlock);
                        if (!conf->transframe[idx]) {
                            if (conf->origframe) {
                                if (musiconhold
                                    && !ast_test_flag64(confflags, CONFFLAG_WAITMARKED)
                                    && !ast_dsp_silence(dsp, conf->origframe, &confsilence)
                                    && confsilence < MEETME_DELAYDETECTTALK) {
                                    ast_moh_stop(chan);
                                    mohtempstopped = 1;
                                }
                                if (!conf->transpath[idx]) {
                                    conf->transpath[idx] = ast_translator_build_path(ast_channel_rawwriteformat(chan), ast_format_slin);
                                }
                                if (conf->transpath[idx]) {
                                    conf->transframe[idx] = ast_translate(conf->transpath[idx], conf->origframe, 0);
                                    if (!conf->transframe[idx]) {
                                        conf->transframe[idx] = &ast_null_frame;
                                    }
                                }
                            }
                        }
                        if (conf->transframe[idx]) {
                            if ((conf->transframe[idx]->frametype != AST_FRAME_NULL) &&
                                can_write(chan, confflags)) {
                                struct ast_frame *cur;
                                /* the translator may have returned a list of frames, so
                                   write each one onto the channel
                                */
                                for (cur = conf->transframe[idx]; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
                                    if (ast_write(chan, cur)) {
                                        ast_log(LOG_WARNING, "Unable to write frame to channel %s\n", ast_channel_name(chan));
                                        break;
                                    }
                                }
                                if (musiconhold && mohtempstopped && confsilence > MEETME_DELAYDETECTENDTALK) {
                                    mohtempstopped = 0;
                                    conf_start_moh(chan, optargs[OPT_ARG_MOH_CLASS]);
                                }
                            }
                        } else {
                            ast_mutex_unlock(&conf->listenlock);
                            goto bailoutandtrynormal;
                        }
                        ast_mutex_unlock(&conf->listenlock);
                    } else {
bailoutandtrynormal:
                        if (musiconhold
                            && !ast_test_flag64(confflags, CONFFLAG_WAITMARKED)
                            && !ast_dsp_silence(dsp, &fr, &confsilence)
                            && confsilence < MEETME_DELAYDETECTTALK) {
                            ast_moh_stop(chan);
                            mohtempstopped = 1;
                        }
                        if (user->listen.actual) {
                            ast_frame_adjust_volume(&fr, user->listen.actual);
                        }
                        if (can_write(chan, confflags) && ast_write(chan, &fr) < 0) {
                            ast_log(LOG_WARNING, "Unable to write frame to channel %s\n", ast_channel_name(chan));
                        }
                        if (musiconhold && mohtempstopped && confsilence > MEETME_DELAYDETECTENDTALK) {
                            mohtempstopped = 0;
                            conf_start_moh(chan, optargs[OPT_ARG_MOH_CLASS]);
                        }
                    }
                } else {
                    ast_log(LOG_WARNING, "Failed to read frame: %s\n", strerror(errno));
                }
            }
            lastmarked = currentmarked;
        }
    }
 
    if (musiconhold) {
        ast_moh_stop(chan);
    }
 
    if (using_pseudo) {
        close(fd);
    } else {
        /* Take out of conference */
        dahdic.chan = 0;
        dahdic.confno = 0;
        dahdic.confmode = 0;
        if (ioctl(fd, DAHDI_SETCONF, &dahdic)) {
            ast_log(LOG_WARNING, "Error setting conference\n");
        }
    }
 
    reset_volumes(user);
 
    if (!ast_test_flag64(confflags, CONFFLAG_QUIET) && !ast_test_flag64(confflags, CONFFLAG_MONITOR) &&
        !ast_test_flag64(confflags, CONFFLAG_ADMIN)) {
        conf_play(chan, conf, LEAVE);
    }
 
    if (!ast_test_flag64(confflags, CONFFLAG_QUIET) && ast_test_flag64(confflags, CONFFLAG_INTROUSER |CONFFLAG_INTROUSERNOREVIEW | CONFFLAG_INTROUSER_VMREC) && conf->users > 1) {
        struct announce_listitem *item;
        if (!(item = ao2_alloc(sizeof(*item), NULL)))
            goto outrun;
        ast_copy_string(item->namerecloc, user->namerecloc, sizeof(item->namerecloc));
        ast_copy_string(item->language, ast_channel_language(chan), sizeof(item->language));
        item->confchan = conf->chan;
        item->confusers = conf->users;
        item->announcetype = CONF_HASLEFT;
        if (ast_test_flag64(confflags, CONFFLAG_INTROUSER_VMREC)){
            item->vmrec = 1;
        }
        ast_mutex_lock(&conf->announcelistlock);
        AST_LIST_INSERT_TAIL(&conf->announcelist, item, entry);
        ast_cond_signal(&conf->announcelist_addition);
        ast_mutex_unlock(&conf->announcelistlock);
    } else if (!ast_test_flag64(confflags, CONFFLAG_QUIET) && ast_test_flag64(confflags, CONFFLAG_INTROUSER | CONFFLAG_INTROUSERNOREVIEW) && !ast_test_flag64(confflags, CONFFLAG_INTROUSER_VMREC) && conf->users == 1) {
        /* Last person is leaving, so no reason to try and announce, but should delete the name recording */
        ast_filedelete(user->namerecloc, NULL);
    }
 
 outrun:
    AST_LIST_LOCK(&confs);
 
    if (dsp) {
        ast_dsp_free(dsp);
    }
 
    if (user->user_no) {
        /* Only cleanup users who really joined! */
        now = ast_tvnow();
 
        if (sent_event) {
            meetme_stasis_generate_msg(conf, chan, user, meetme_leave_type(), NULL);
        }
 
        if (setusercount) {
            conf->users--;
            if (rt_log_members) {
                /* Update table */
                snprintf(members, sizeof(members), "%d", conf->users);
                ast_realtime_require_field("meetme",
                    "confno", strlen(conf->confno) > 7 ? RQ_UINTEGER4 : strlen(conf->confno) > 4 ? RQ_UINTEGER3 : RQ_UINTEGER2, strlen(conf->confno),
                    "members", RQ_UINTEGER1, strlen(members),
                    NULL);
                ast_update_realtime("meetme", "confno", conf->confno, "members", members, NULL);
            }
            if (ast_test_flag64(confflags, CONFFLAG_MARKEDUSER)) {
                conf->markedusers--;
            }
        }
        /* Remove ourselves from the container */
        ao2_unlink(conf->usercontainer, user);
 
        /* Change any states */
        if (!conf->users) {
            ast_devstate_changed(AST_DEVICE_NOT_INUSE, (conf->isdynamic ? AST_DEVSTATE_NOT_CACHABLE : AST_DEVSTATE_CACHABLE), "meetme:%s", conf->confno);
        }
 
        /* This flag is meant to kill a conference with only one participant remaining.  */
        if (conf->users == 1 && ast_test_flag64(confflags, CONFFLAG_KILL_LAST_MAN_STANDING)) {
            ao2_callback(conf->usercontainer, 0, user_set_hangup_cb, NULL);
        }
 
        /* Return the number of seconds the user was in the conf */
        snprintf(meetmesecs, sizeof(meetmesecs), "%d", (int) (time(NULL) - user->jointime));
        pbx_builtin_setvar_helper(chan, "MEETMESECS", meetmesecs);
 
        /* Return the RealTime bookid for CDR linking */
        if (rt_schedule) {
            pbx_builtin_setvar_helper(chan, "MEETMEBOOKID", conf->bookid);
        }
    }
    ao2_ref(user, -1);
    AST_LIST_UNLOCK(&confs);
 
 
conf_run_cleanup:
    ao2_cleanup(cap_slin);
 
    return ret;
}