app_meetme.c File Reference

Meet me conference bridge. 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	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	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_KICK_CONTINUE = (1 << 26) , CONFFLAG_DURATION_STOP = (1 << 27) ,   CONFFLAG_DURATION_LIMIT = (1 << 28) }
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	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	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.
static void *	announce_thread (void *data)
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.
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)
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.
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.
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.
static int	dispose_conf (struct ast_conference *conf)
	Decrement reference counts, as incremented by find_conf()
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.
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.
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	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)
	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 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 = ASTERISK_GPL_KEY , .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.
static struct ast_cli_entry	cli_meetme []
static unsigned int	conf_map [1024] = {0, }
static struct confs	confs = AST_LIST_HEAD_INIT_VALUE
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.
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 = CONFFLAG_INTROMSG , .arg_index = OPT_ARG_INTROMSG + 1 }, [ 'v' ] = { .flag = CONFFLAG_INTROUSER_VMREC , .arg_index = OPT_ARG_INTROUSER_VMREC + 1 }, [ 'i' ] = { .flag = CONFFLAG_INTROUSER }, [ 'I' ] = { .flag = CONFFLAG_INTROUSERNOREVIEW }, [ 'k' ] = { .flag = CONFFLAG_KILL_LAST_MAN_STANDING }, [ 'M' ] = { .flag = CONFFLAG_MOH , .arg_index = OPT_ARG_MOH_CLASS + 1 }, [ 'm' ] = { .flag = CONFFLAG_STARTMUTED }, [ 'n' ] = { .flag = CONFFLAG_DONT_DENOISE }, [ '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

Detailed Description

Meet me conference bridge.

Author

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

Definition in file app_meetme.c.

Macro Definition Documentation

AST_FRAME_BITS

#define AST_FRAME_BITS   32

Definition at line 730 of file app_meetme.c.

CONF_SIZE

#define CONF_SIZE   320

Definition at line 749 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 817 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 812 of file app_meetme.c.

CONFFLAG_INTROUSER_VMREC

#define CONFFLAG_INTROUSER_VMREC   (1ULL << 33)

Definition at line 813 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 815 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 811 of file app_meetme.c.

CONFIG_FILE_NAME

#define CONFIG_FILE_NAME   "meetme.conf"

Definition at line 709 of file app_meetme.c.

DATE_FORMAT

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

String format for scheduled conferences

Definition at line 716 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 713 of file app_meetme.c.

MAX_CONFNUM

#define MAX_CONFNUM   80

Definition at line 881 of file app_meetme.c.

MAX_PIN

#define MAX_PIN   80

Definition at line 882 of file app_meetme.c.

MAX_SETTINGS

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

Definition at line 886 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 728 of file app_meetme.c.

MEETME_DELAYDETECTTALK

#define MEETME_DELAYDETECTTALK   300

Definition at line 727 of file app_meetme.c.

OPTIONS_LEN

#define OPTIONS_LEN   100

Definition at line 883 of file app_meetme.c.

STR_CONCISE

#define STR_CONCISE   "concise"

Definition at line 710 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 718 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_KICK_CONTINUE	If set, the user should continue in the dialplan if kicked out
CONFFLAG_DURATION_STOP
CONFFLAG_DURATION_LIMIT

Definition at line 751 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),
    /*! If set, the user should continue in the dialplan if kicked out */
    CONFFLAG_KICK_CONTINUE = (1 << 26),
    CONFFLAG_DURATION_STOP = (1 << 27),
    CONFFLAG_DURATION_LIMIT = (1 << 28),
};

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 819 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,
};

announcetypes

enum announcetypes

Enumerator
CONF_HASJOIN
CONF_HASLEFT

Definition at line 888 of file app_meetme.c.

                   {
    CONF_HASJOIN,
    CONF_HASLEFT
};

entrance_sound

enum entrance_sound

Enumerator
ENTER
LEAVE

Definition at line 737 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 2364 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 742 of file app_meetme.c.

                     {
    MEETME_RECORD_OFF,
    MEETME_RECORD_STARTED,
    MEETME_RECORD_ACTIVE,
    MEETME_RECORD_TERMINATE
};

volume_action

enum volume_action

Enumerator
VOL_UP
VOL_DOWN

Definition at line 732 of file app_meetme.c.

                   {
    VOL_UP,
    VOL_DOWN
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 5620 of file app_meetme.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 5620 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 5486 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, and result.

acf_meetme_info_eval()

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

static

Definition at line 5468 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 5135 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, 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 5207 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 5125 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 5130 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 4831 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(), and meetme_cmd_helper().

announce_thread()

static void * announce_thread ( void *  data )

static

Definition at line 2230 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().

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 5620 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 1482 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 find_conf(), and find_conf_realtime().

can_write()

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

static

Definition at line 2287 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 1284 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 5004 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 1601 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 1690 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, 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 1682 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 1642 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, and NULL.

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 1620 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 4443 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(), ast_conference::isdynamic, LOG_ERROR, LOG_WARNING, MAX_CONFNUM, MAX_PIN, MAX_SETTINGS, meetme_opts, NULL, OPT_ARG_ARRAY_SIZE, options, 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 1998 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 2030 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(), announce_listitem::entry, 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 1402 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 2099 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(), and LOG_WARNING.

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 2794 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 {
            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)) ? 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))) {
                    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) ? 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 (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;
}

References ADMINFLAG_HANGUP, ADMINFLAG_KICKME, ADMINFLAG_MUTED, ADMINFLAG_SELFMUTED, ADMINFLAG_T_REQUEST, announce_thread(), ao2_alloc, ao2_callback, ao2_cleanup, ao2_link, ao2_lock, ao2_ref, ao2_unlink, ao2_unlock, ast_channel_audiohooks(), ast_channel_context(), ast_channel_fd(), ast_channel_language(), ast_channel_lock, ast_channel_name(), ast_channel_rawwriteformat(), ast_channel_setoption(), ast_channel_uniqueid(), ast_channel_unlock, ast_check_hangup(), ast_clear_flag64, ast_cond_signal, ast_config_AST_SPOOL_DIR, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, ast_copy_string(), ast_debug, AST_DEVICE_INUSE, AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), AST_DEVSTATE_NOT_CACHABLE, AST_DIGIT_ANY, ast_dsp_free(), ast_dsp_get_threshold_from_settings(), ast_dsp_new(), ast_dsp_silence(), ast_exists_extension(), ast_filedelete(), ast_fileexists(), ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cmp(), AST_FORMAT_CMP_EQUAL, ast_format_compatibility_format2bitfield(), ast_format_slin, ast_frame_adjust_volume(), AST_FRAME_BITS, AST_FRAME_CONTROL, AST_FRAME_DTMF, AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, AST_FRAME_NULL, AST_FRAME_VOICE, ast_frfree, AST_FRIENDLY_OFFSET, ast_func_write(), ast_goto_if_exists(), ast_hangup(), ast_indicate(), ast_json_unref(), AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_NEXT, AST_LIST_UNLOCK, ast_load_realtime(), ast_localtime(), ast_log, AST_MAX_CONTEXT, AST_MAX_EXTENSION, ast_mkdir(), ast_mktime(), ast_moh_stop(), ast_mutex_init, ast_mutex_lock, ast_mutex_unlock, ast_null_frame, AST_OPTION_TONE_VERIFY, ast_play_and_record(), ast_pthread_create_background, ast_pthread_create_detached_background, AST_PTHREADT_NULL, ast_read(), ast_read_noaudio(), ast_realtime_require_field(), ast_record_review(), ast_request(), ast_safe_sleep(), ast_samp2tv(), ast_say_digits(), ast_say_number(), ast_set_read_format(), ast_set_write_format(), ast_stopstream(), ast_strdup, ast_strdupa, ast_streamfile(), ast_strftime(), ast_strlen_zero(), ast_strptime(), ast_test_flag64, ast_test_suite_event_notify, ast_translate(), ast_translator_build_path(), ast_tvadd(), ast_tvdiff_ms(), ast_tvnow(), ast_tvsub(), ast_tvzero(), ast_update_realtime(), ast_variables_destroy(), ast_verb, ast_verbose, ast_waitfor_nandfds(), ast_waitstream(), ast_write(), audio_buffers, buf, c, can_write(), careful_write(), conf_flush(), CONF_HASJOIN, CONF_HASLEFT, conf_play(), conf_queue_dtmf(), CONF_SIZE, conf_start_moh(), CONFFLAG_ADMIN, CONFFLAG_AGI, CONFFLAG_ANNOUNCEUSERCOUNT, CONFFLAG_DONT_DENOISE, CONFFLAG_DURATION_LIMIT, CONFFLAG_DURATION_STOP, CONFFLAG_EXIT_CONTEXT, CONFFLAG_INTROMSG, CONFFLAG_INTROUSER, CONFFLAG_INTROUSER_VMREC, CONFFLAG_INTROUSERNOREVIEW, CONFFLAG_KEYEXIT, CONFFLAG_KICK_CONTINUE, CONFFLAG_KILL_LAST_MAN_STANDING, CONFFLAG_MARKEDEXIT, CONFFLAG_MARKEDUSER, CONFFLAG_MOH, CONFFLAG_MONITOR, CONFFLAG_MONITORTALKER, CONFFLAG_NO_AUDIO_UNTIL_UP, CONFFLAG_NOONLYPERSON, CONFFLAG_OPTIMIZETALKER, CONFFLAG_PASS_DTMF, CONFFLAG_QUIET, CONFFLAG_RECORDCONF, CONFFLAG_STARMENU, CONFFLAG_STARTMUTED, CONFFLAG_TALKER, CONFFLAG_WAITMARKED, ast_frame::data, ast_frame::datalen, DATE_FORMAT, ENTER, announce_listitem::entry, errno, exitcontext, ast_frame_subclass::format, ast_frame::frametype, ast_frame_subclass::integer, item, LEAVE, LOG_WARNING, MEETME_DELAYDETECTENDTALK, MEETME_DELAYDETECTTALK, meetme_menu(), meetme_stasis_generate_msg(), MENU_ADMIN, MENU_DISABLED, MENU_NORMAL, NULL, OBJ_NODATA, ast_frame::offset, OPT_ARG_DURATION_LIMIT, OPT_ARG_DURATION_STOP, OPT_ARG_EXITKEYS, OPT_ARG_INTROMSG, OPT_ARG_INTROUSER_VMREC, OPT_ARG_MOH_CLASS, OPT_ARG_WAITMARKED, PATH_MAX, pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), pbx_exec(), pbx_findapp(), ast_frame::ptr, RAII_VAR, recordthread(), reset_volumes(), RQ_UINTEGER1, RQ_UINTEGER2, RQ_UINTEGER3, RQ_UINTEGER4, rt_log_members, rt_schedule, ast_frame::samples, set_talk_volume(), set_user_talking(), status_to_json(), strsep(), ast_frame::subclass, THRESHOLD_SILENCE, type, user_max_cmp(), user_set_hangup_cb(), and var.

Referenced by conf_exec().

conf_start_moh()

static void conf_start_moh ( struct ast_channel *  chan, const char *  musicclass  )

static

Definition at line 2200 of file app_meetme.c.

{
    char *original_moh;
 
    ast_channel_lock(chan);
    original_moh = ast_strdupa(ast_channel_musicclass(chan));
    ast_channel_musicclass_set(chan, musicclass);
    ast_channel_unlock(chan);
 
    ast_moh_start(chan, original_moh, NULL);
 
    ast_channel_lock(chan);
    ast_channel_musicclass_set(chan, original_moh);
    ast_channel_unlock(chan);
}

References ast_channel_lock, ast_channel_musicclass(), ast_channel_unlock, ast_moh_start(), ast_strdupa, and NULL.

Referenced by conf_run().

count_exec()

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

static

The MeetmeCount application.

Definition at line 4398 of file app_meetme.c.

{
    int res = 0;
    struct ast_conference *conf;
    int count;
    char *localdata;
    char val[80] = "0";
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(confno);
        AST_APP_ARG(varname);
    );
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "MeetMeCount requires an argument (conference number)\n");
        return -1;
    }
 
    localdata = ast_strdupa(data);
 
    AST_STANDARD_APP_ARGS(args, localdata);
 
    conf = find_conf(chan, args.confno, 0, 0, NULL, 0, 1, NULL);
 
    if (conf) {
        count = conf->users;
        dispose_conf(conf);
        conf = NULL;
    } else
        count = 0;
 
    if (!ast_strlen_zero(args.varname)) {
        /* have var so load it and exit */
        snprintf(val, sizeof(val), "%d", count);
        pbx_builtin_setvar_helper(chan, args.varname, val);
    } else {
        if (ast_channel_state(chan) != AST_STATE_UP) {
            ast_answer(chan);
        }
        res = ast_say_number(chan, count, "", ast_channel_language(chan), (char *) NULL); /* Needs gender */
    }
 
    return res;
}

References args, ast_answer(), AST_APP_ARG, ast_channel_language(), AST_DECLARE_APP_ARGS, ast_log, ast_say_number(), AST_STANDARD_APP_ARGS, AST_STATE_UP, ast_strdupa, ast_strlen_zero(), ast_conference::chan, ast_conference::confno, dispose_conf(), find_conf(), LOG_WARNING, NULL, and pbx_builtin_setvar_helper().

Referenced by load_module().

dispose_conf()

static int dispose_conf ( struct ast_conference *  conf )

static

Decrement reference counts, as incremented by find_conf()

Definition at line 2119 of file app_meetme.c.

{
    int res = 0;
    int confno_int = 0;
 
    AST_LIST_LOCK(&confs);
    if (ast_atomic_dec_and_test(&conf->refcount)) {
        /* Take the conference room number out of an inuse state */
        if ((sscanf(conf->confno, "%4d", &confno_int) == 1) && (confno_int >= 0 && confno_int < 1024)) {
            conf_map[confno_int] = 0;
        }
        conf_free(conf);
        res = 1;
    }
    AST_LIST_UNLOCK(&confs);
 
    return res;
}

References ast_atomic_dec_and_test(), AST_LIST_LOCK, AST_LIST_UNLOCK, conf_free(), and conf_map.

Referenced by admin_exec(), conf_exec(), and count_exec().

filename_parse()

static void filename_parse ( char *  filename, char *  buffer  )

static

Definition at line 5276 of file app_meetme.c.

{
    char *slash;
    if (ast_strlen_zero(filename)) {
        ast_log(LOG_WARNING, "No file name was provided for a file save option.\n");
    } else if (filename[0] != '/') {
        snprintf(buffer, PATH_MAX, "%s/meetme/%s", ast_config_AST_SPOOL_DIR, filename);
    } else {
        ast_copy_string(buffer, filename, PATH_MAX);
    }
 
    slash = buffer;
    if ((slash = strrchr(slash, '/'))) {
        *slash = '\0';
        ast_mkdir(buffer, 0777);
        *slash = '/';
    }
}

References ast_config_AST_SPOOL_DIR, ast_copy_string(), ast_log, ast_mkdir(), ast_strlen_zero(), LOG_WARNING, and PATH_MAX.

Referenced by recordthread().

find_conf()

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

Definition at line 4294 of file app_meetme.c.

{
    struct ast_config *cfg;
    struct ast_variable *var;
    struct ast_flags config_flags = { 0 };
    struct ast_conference *cnf;
 
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(confno);
        AST_APP_ARG(pin);
        AST_APP_ARG(pinadmin);
    );
 
    /* Check first in the conference list */
    ast_debug(1, "The requested confno is '%s'?\n", confno);
    AST_LIST_LOCK(&confs);
    AST_LIST_TRAVERSE(&confs, cnf, list) {
        ast_debug(3, "Does conf %s match %s?\n", confno, cnf->confno);
        if (!strcmp(confno, cnf->confno))
            break;
    }
    if (cnf) {
        cnf->refcount += refcount;
    }
    AST_LIST_UNLOCK(&confs);
 
    if (!cnf) {
        if (dynamic) {
            /* No need to parse meetme.conf */
            ast_debug(1, "Building dynamic conference '%s'\n", confno);
            if (dynamic_pin) {
                if (dynamic_pin[0] == 'q') {
                    /* Query the user to enter a PIN */
                    if (ast_app_getdata(chan, "conf-getpin", dynamic_pin, pin_buf_len - 1, 0) < 0)
                        return NULL;
                }
                cnf = build_conf(confno, dynamic_pin, "", make, dynamic, refcount, chan, NULL);
            } else {
                cnf = build_conf(confno, "", "", make, dynamic, refcount, chan, NULL);
            }
        } else {
            /* Check the config */
            cfg = ast_config_load(CONFIG_FILE_NAME, config_flags);
            if (!cfg) {
                ast_log(LOG_WARNING, "No %s file :(\n", CONFIG_FILE_NAME);
                return NULL;
            } else if (cfg == CONFIG_STATUS_FILEINVALID) {
                ast_log(LOG_ERROR, "Config file " CONFIG_FILE_NAME " is in an invalid format.  Aborting.\n");
                return NULL;
            }
 
            for (var = ast_variable_browse(cfg, "rooms"); var; var = var->next) {
                char parse[MAX_SETTINGS];
 
                if (strcasecmp(var->name, "conf"))
                    continue;
 
                ast_copy_string(parse, var->value, sizeof(parse));
 
                AST_STANDARD_APP_ARGS(args, parse);
                ast_debug(3, "Will conf %s match %s?\n", confno, args.confno);
                if (!strcasecmp(args.confno, confno)) {
                    /* Bingo it's a valid conference */
                    cnf = build_conf(args.confno,
                            S_OR(args.pin, ""),
                            S_OR(args.pinadmin, ""),
                            make, dynamic, refcount, chan, NULL);
                    break;
                }
            }
            if (!var) {
                ast_log(LOG_WARNING, "%s isn't a valid conference\n", confno);
            }
            ast_config_destroy(cfg);
        }
    } else if (dynamic_pin) {
        /* Correct for the user selecting 'D' instead of 'd' to have
           someone join into a conference that has already been created
           with a pin. */
        if (dynamic_pin[0] == 'q') {
            dynamic_pin[0] = '\0';
        }
    }
 
    if (cnf) {
        if (confflags && !cnf->chan &&
            !ast_test_flag64(confflags, CONFFLAG_QUIET) &&
            ast_test_flag64(confflags, CONFFLAG_INTROUSER | CONFFLAG_INTROUSERNOREVIEW  | CONFFLAG_INTROUSER_VMREC)) {
            ast_log(LOG_WARNING, "No DAHDI channel available for conference, user introduction disabled (is chan_dahdi loaded?)\n");
            ast_clear_flag64(confflags, CONFFLAG_INTROUSER | CONFFLAG_INTROUSERNOREVIEW | CONFFLAG_INTROUSER_VMREC);
        }
 
        if (confflags && !cnf->chan &&
            ast_test_flag64(confflags, CONFFLAG_RECORDCONF)) {
            ast_log(LOG_WARNING, "No DAHDI channel available for conference, conference recording disabled (is chan_dahdi loaded?)\n");
            ast_clear_flag64(confflags, CONFFLAG_RECORDCONF);
        }
    }
 
    return cnf;
}

References args, AST_APP_ARG, ast_app_getdata(), ast_clear_flag64, ast_config_destroy(), ast_config_load, ast_copy_string(), ast_debug, AST_DECLARE_APP_ARGS, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, AST_STANDARD_APP_ARGS, ast_test_flag64, ast_variable_browse(), build_conf(), ast_conference::chan, CONFFLAG_INTROUSER, CONFFLAG_INTROUSER_VMREC, CONFFLAG_INTROUSERNOREVIEW, CONFFLAG_QUIET, CONFFLAG_RECORDCONF, CONFIG_FILE_NAME, CONFIG_STATUS_FILEINVALID, ast_conference::confno, ast_conference::list, LOG_ERROR, LOG_WARNING, MAX_SETTINGS, ast_variable::next, NULL, ast_conference::pin, ast_conference::pinadmin, ast_conference::refcount, S_OR, and var.

Referenced by conf_exec(), and count_exec().

find_conf_realtime()

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

Definition at line 4107 of file app_meetme.c.

{
    struct ast_variable *var, *origvar;
    struct ast_conference *cnf;
 
    *too_early = 0;
 
    /* Check first in the conference list */
    AST_LIST_LOCK(&confs);
    AST_LIST_TRAVERSE(&confs, cnf, list) {
        if (!strcmp(confno, cnf->confno)) {
            break;
        }
    }
    if (cnf) {
        cnf->refcount += refcount;
    }
    AST_LIST_UNLOCK(&confs);
 
    if (!cnf) {
        char *pin = NULL, *pinadmin = NULL; /* For temp use */
        int maxusers = 0;
        struct timeval now;
        char recordingfilename[256] = "";
        char recordingformat[11] = "";
        char currenttime[32] = "";
        char eatime[32] = "";
        char bookid[51] = "";
        char recordingtmp[AST_MAX_EXTENSION * 2] = "";
        char useropts[OPTIONS_LEN + 1] = ""; /* Used for RealTime conferences */
        char adminopts[OPTIONS_LEN + 1] = "";
        struct ast_tm tm, etm;
        struct timeval endtime = { .tv_sec = 0 };
        const char *var2;
 
        if (rt_schedule) {
            now = ast_tvnow();
 
            ast_localtime(&now, &tm, NULL);
            ast_strftime(currenttime, sizeof(currenttime), DATE_FORMAT, &tm);
 
            ast_debug(1, "Looking for conference %s that starts after %s\n", confno, currenttime);
 
            var = ast_load_realtime("meetme", "confno",
                confno, "starttime <= ", currenttime, "endtime >= ",
                currenttime, NULL);
 
            if (!var && fuzzystart) {
                now = ast_tvnow();
                now.tv_sec += fuzzystart;
 
                ast_localtime(&now, &tm, NULL);
                ast_strftime(currenttime, sizeof(currenttime), DATE_FORMAT, &tm);
                var = ast_load_realtime("meetme", "confno",
                    confno, "starttime <= ", currenttime, "endtime >= ",
                    currenttime, NULL);
            }
 
            if (!var && earlyalert) {
                now = ast_tvnow();
                now.tv_sec += earlyalert;
                ast_localtime(&now, &etm, NULL);
                ast_strftime(eatime, sizeof(eatime), DATE_FORMAT, &etm);
                var = ast_load_realtime("meetme", "confno",
                    confno, "starttime <= ", eatime, "endtime >= ",
                    currenttime, NULL);
                if (var) {
                    *too_early = 1;
                }
            }
 
        } else {
             var = ast_load_realtime("meetme", "confno", confno, NULL);
        }
 
        if (!var) {
            return NULL;
        }
 
        if (rt_schedule && *too_early) {
            /* Announce that the caller is early and exit */
            if (!ast_streamfile(chan, "conf-has-not-started", ast_channel_language(chan))) {
                ast_waitstream(chan, "");
            }
            ast_variables_destroy(var);
            return NULL;
        }
 
        for (origvar = var; var; var = var->next) {
            if (!strcasecmp(var->name, "pin")) {
                pin = ast_strdupa(var->value);
            } else if (!strcasecmp(var->name, "adminpin")) {
                pinadmin = ast_strdupa(var->value);
            } else if (!strcasecmp(var->name, "bookId")) {
                ast_copy_string(bookid, var->value, sizeof(bookid));
            } else if (!strcasecmp(var->name, "opts")) {
                ast_copy_string(useropts, var->value, sizeof(char[OPTIONS_LEN + 1]));
            } else if (!strcasecmp(var->name, "maxusers")) {
                maxusers = atoi(var->value);
            } else if (!strcasecmp(var->name, "adminopts")) {
                ast_copy_string(adminopts, var->value, sizeof(char[OPTIONS_LEN + 1]));
            } else if (!strcasecmp(var->name, "recordingfilename")) {
                ast_copy_string(recordingfilename, var->value, sizeof(recordingfilename));
            } else if (!strcasecmp(var->name, "recordingformat")) {
                ast_copy_string(recordingformat, var->value, sizeof(recordingformat));
            } else if (!strcasecmp(var->name, "endtime")) {
                struct ast_tm endtime_tm;
                ast_strptime(var->value, "%Y-%m-%d %H:%M:%S", &endtime_tm);
                endtime = ast_mktime(&endtime_tm, NULL);
            }
        }
 
        ast_variables_destroy(origvar);
 
        cnf = build_conf(confno, pin ? pin : "", pinadmin ? pinadmin : "", make, dynamic, refcount, chan, NULL);
 
        if (cnf) {
            struct ast_flags64 tmp_flags;
 
            cnf->maxusers = maxusers;
            cnf->endalert = endalert;
            cnf->endtime = endtime.tv_sec;
            cnf->useropts = ast_strdup(useropts);
            cnf->adminopts = ast_strdup(adminopts);
            cnf->bookid = ast_strdup(bookid);
            if (!ast_strlen_zero(recordingfilename)) {
                cnf->recordingfilename = ast_strdup(recordingfilename);
            }
            if (!ast_strlen_zero(recordingformat)) {
                cnf->recordingformat = ast_strdup(recordingformat);
            }
 
            /* Parse the other options into confflags -- need to do this in two
             * steps, because the parse_options routine zeroes the buffer. */
            ast_app_parse_options64(meetme_opts, &tmp_flags, optargs, useropts);
            ast_copy_flags64(confflags, &tmp_flags, tmp_flags.flags);
 
            if (strchr(cnf->useropts, 'r')) {
                if (ast_strlen_zero(recordingfilename)) { /* If the recordingfilename in the database is empty, use the channel definition or use the default. */
                    ast_channel_lock(chan);
                    if ((var2 = pbx_builtin_getvar_helper(chan, "MEETME_RECORDINGFILE"))) {
                        ast_free(cnf->recordingfilename);
                        cnf->recordingfilename = ast_strdup(var2);
                    }
                    ast_channel_unlock(chan);
                    if (ast_strlen_zero(cnf->recordingfilename)) {
                        snprintf(recordingtmp, sizeof(recordingtmp), "meetme-conf-rec-%s-%s", cnf->confno, ast_channel_uniqueid(chan));
                        ast_free(cnf->recordingfilename);
                        cnf->recordingfilename = ast_strdup(recordingtmp);
                    }
                }
                if (ast_strlen_zero(cnf->recordingformat)) {/* If the recording format is empty, use the wav as default */
                    ast_channel_lock(chan);
                    if ((var2 = pbx_builtin_getvar_helper(chan, "MEETME_RECORDINGFORMAT"))) {
                        ast_free(cnf->recordingformat);
                        cnf->recordingformat = ast_strdup(var2);
                    }
                    ast_channel_unlock(chan);
                    if (ast_strlen_zero(cnf->recordingformat)) {
                        ast_free(cnf->recordingformat);
                        cnf->recordingformat = ast_strdup("wav");
                    }
                }
                ast_verb(4, "Starting recording of MeetMe Conference %s into file %s.%s.\n", cnf->confno, cnf->recordingfilename, cnf->recordingformat);
            }
        }
    }
 
    if (cnf) {
        if (confflags->flags && !cnf->chan &&
            !ast_test_flag64(confflags, CONFFLAG_QUIET) &&
            ast_test_flag64(confflags, CONFFLAG_INTROUSER | CONFFLAG_INTROUSERNOREVIEW | CONFFLAG_INTROUSER_VMREC)) {
            ast_log(LOG_WARNING, "No DAHDI channel available for conference, user introduction disabled (is chan_dahdi loaded?)\n");
            ast_clear_flag64(confflags, CONFFLAG_INTROUSER | CONFFLAG_INTROUSERNOREVIEW | CONFFLAG_INTROUSER_VMREC);
        }
 
        if (confflags && !cnf->chan &&
            ast_test_flag64(confflags, CONFFLAG_RECORDCONF)) {
            ast_log(LOG_WARNING, "No DAHDI channel available for conference, conference recording disabled (is chan_dahdi loaded?)\n");
            ast_clear_flag64(confflags, CONFFLAG_RECORDCONF);
        }
    }
 
    return cnf;
}

References ast_conference::adminopts, ast_app_parse_options64(), ast_channel_language(), ast_channel_lock, ast_channel_uniqueid(), ast_channel_unlock, ast_clear_flag64, ast_copy_flags64, ast_copy_string(), ast_debug, ast_free, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_load_realtime(), ast_localtime(), ast_log, AST_MAX_EXTENSION, ast_mktime(), ast_strdup, ast_strdupa, ast_streamfile(), ast_strftime(), ast_strlen_zero(), ast_strptime(), ast_test_flag64, ast_tvnow(), ast_variables_destroy(), ast_verb, ast_waitstream(), ast_conference::bookid, build_conf(), ast_conference::chan, CONFFLAG_INTROUSER, CONFFLAG_INTROUSER_VMREC, CONFFLAG_INTROUSERNOREVIEW, CONFFLAG_QUIET, CONFFLAG_RECORDCONF, ast_conference::confno, DATE_FORMAT, earlyalert, endalert, ast_conference::endalert, ast_conference::endtime, ast_flags64::flags, fuzzystart, ast_conference::list, LOG_WARNING, ast_conference::maxusers, meetme_opts, ast_variable::next, NULL, OPTIONS_LEN, pbx_builtin_getvar_helper(), ast_conference::pin, ast_conference::pinadmin, ast_conference::recordingfilename, ast_conference::recordingformat, ast_conference::refcount, rt_schedule, ast_conference::useropts, and var.

Referenced by conf_exec().

find_user()

static struct ast_conf_user * find_user ( struct ast_conference *  conf, const char *  callerident  )

static

Definition at line 4768 of file app_meetme.c.

{
    struct ast_conf_user *user = NULL;
    int cid;
 
    if (conf && callerident && sscanf(callerident, "%30d", &cid) == 1) {
        user = ao2_find(conf->usercontainer, &cid, 0);
        /* reference decremented later in admin_exec */
        return user;
    }
    return NULL;
}

References ao2_find, and NULL.

Referenced by admin_exec().

get_announce_filename()

static const char * get_announce_filename ( enum announcetypes  type )

static

Definition at line 2216 of file app_meetme.c.

{
    switch (type) {
    case CONF_HASLEFT:
        return "conf-hasleft";
        break;
    case CONF_HASJOIN:
        return "conf-hasjoin";
        break;
    default:
        return "";
    }
}

References CONF_HASJOIN, CONF_HASLEFT, and type.

Referenced by announce_thread().

istalking()

static const char * istalking ( int  x )

static

Definition at line 1274 of file app_meetme.c.

{
    if (x > 0)
        return "(talking)";
    else if (x < 0)
        return "(unmonitored)";
    else
        return "(not talking)";
}

Referenced by meetme_show_cmd().

load_config()

static int load_config ( int  reload )

static

Definition at line 5541 of file app_meetme.c.

{
    load_config_meetme(reload);
    return 0;
}

References load_config_meetme(), and reload().

load_config_meetme()

static void load_config_meetme ( int  reload )

static

Definition at line 5402 of file app_meetme.c.

{
    struct ast_config *cfg;
    struct ast_flags config_flags = { 0 };
    const char *val;
 
    if (!reload) {
        meetme_set_defaults();
    }
 
    if (!(cfg = ast_config_load(CONFIG_FILE_NAME, config_flags))) {
        return;
    } else if (cfg == CONFIG_STATUS_FILEINVALID) {
        ast_log(LOG_ERROR, "Config file " CONFIG_FILE_NAME " is in an invalid format.  Aborting.\n");
        return;
    }
 
    if (reload) {
        meetme_set_defaults();
    }
 
    if ((val = ast_variable_retrieve(cfg, "general", "audiobuffers"))) {
        if ((sscanf(val, "%30d", &audio_buffers) != 1)) {
            ast_log(LOG_WARNING, "audiobuffers setting must be a number, not '%s'\n", val);
            audio_buffers = DEFAULT_AUDIO_BUFFERS;
        } else if ((audio_buffers < DAHDI_DEFAULT_NUM_BUFS) || (audio_buffers > DAHDI_MAX_NUM_BUFS)) {
            ast_log(LOG_WARNING, "audiobuffers setting must be between %d and %d\n",
                DAHDI_DEFAULT_NUM_BUFS, DAHDI_MAX_NUM_BUFS);
            audio_buffers = DEFAULT_AUDIO_BUFFERS;
        }
        if (audio_buffers != DEFAULT_AUDIO_BUFFERS)
            ast_log(LOG_NOTICE, "Audio buffers per channel set to %d\n", audio_buffers);
    }
 
    if ((val = ast_variable_retrieve(cfg, "general", "schedule")))
        rt_schedule = ast_true(val);
    if ((val = ast_variable_retrieve(cfg, "general", "logmembercount")))
        rt_log_members = ast_true(val);
    if ((val = ast_variable_retrieve(cfg, "general", "fuzzystart"))) {
        if ((sscanf(val, "%30d", &fuzzystart) != 1)) {
            ast_log(LOG_WARNING, "fuzzystart must be a number, not '%s'\n", val);
            fuzzystart = 0;
        }
    }
    if ((val = ast_variable_retrieve(cfg, "general", "earlyalert"))) {
        if ((sscanf(val, "%30d", &earlyalert) != 1)) {
            ast_log(LOG_WARNING, "earlyalert must be a number, not '%s'\n", val);
            earlyalert = 0;
        }
    }
    if ((val = ast_variable_retrieve(cfg, "general", "endalert"))) {
        if ((sscanf(val, "%30d", &endalert) != 1)) {
            ast_log(LOG_WARNING, "endalert must be a number, not '%s'\n", val);
            endalert = 0;
        }
    }
    if ((val = ast_variable_retrieve(cfg, "general", "extendby"))) {
        if ((sscanf(val, "%30d", &extendby) != 1)) {
            ast_log(LOG_WARNING, "extendby must be a number, not '%s'\n", val);
            extendby = 0;
        }
    }
 
    ast_config_destroy(cfg);
}

References ast_config_destroy(), ast_config_load, ast_log, ast_true(), ast_variable_retrieve(), audio_buffers, CONFIG_FILE_NAME, CONFIG_STATUS_FILEINVALID, DEFAULT_AUDIO_BUFFERS, earlyalert, endalert, extendby, fuzzystart, LOG_ERROR, LOG_NOTICE, LOG_WARNING, meetme_set_defaults(), reload(), rt_log_members, and rt_schedule.

Referenced by load_config().

load_module()

static int load_module ( void  )

static

Load the module.

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

Definition at line 5581 of file app_meetme.c.

{
    int res = 0;
 
    res |= load_config(0);
 
    res |= meetme_stasis_init();
 
    ast_cli_register_multiple(cli_meetme, ARRAY_LEN(cli_meetme));
    res |= ast_manager_register_xml("MeetmeMute", EVENT_FLAG_CALL, action_meetmemute);
    res |= ast_manager_register_xml("MeetmeUnmute", EVENT_FLAG_CALL, action_meetmeunmute);
    res |= ast_manager_register_xml("MeetmeList", EVENT_FLAG_REPORTING, action_meetmelist);
    res |= ast_manager_register_xml("MeetmeListRooms", EVENT_FLAG_REPORTING, action_meetmelistrooms);
    res |= ast_register_application_xml(app4, channel_admin_exec);
    res |= ast_register_application_xml(app3, admin_exec);
    res |= ast_register_application_xml(app2, count_exec);
    res |= ast_register_application_xml(app, conf_exec);
 
    res |= ast_devstate_prov_add("Meetme", meetmestate);
 
    res |= ast_custom_function_register(&meetme_info_acf);
    ast_realtime_require_field("meetme", "confno", RQ_UINTEGER2, 3, "members", RQ_UINTEGER1, 3, NULL);
 
    return res;
}

References action_meetmelist(), action_meetmelistrooms(), action_meetmemute(), action_meetmeunmute(), admin_exec(), app, app2, app3, app4, ARRAY_LEN, ast_cli_register_multiple, ast_custom_function_register, ast_devstate_prov_add(), ast_manager_register_xml, ast_realtime_require_field(), ast_register_application_xml, channel_admin_exec(), cli_meetme, conf_exec(), count_exec(), EVENT_FLAG_CALL, EVENT_FLAG_REPORTING, load_config(), meetme_info_acf, meetme_stasis_init(), meetmestate(), NULL, RQ_UINTEGER1, and RQ_UINTEGER2.

meetme_cmd_helper()

static char * meetme_cmd_helper ( struct ast_cli_args *  a )

static

Definition at line 1871 of file app_meetme.c.

{
    /* Process the command */
    struct ast_str *cmdline;
 
    /* Max confno length */
    if (!(cmdline = ast_str_create(MAX_CONFNUM))) {
        return CLI_FAILURE;
    }
 
    ast_str_set(&cmdline, 0, "%s", a->argv[2]); /* Argv 2: conference number */
    if (strcasestr(a->argv[1], "lock")) {
        if (strcasecmp(a->argv[1], "lock") == 0) {
            /* Lock */
            ast_str_append(&cmdline, 0, ",L");
        } else {
            /* Unlock */
            ast_str_append(&cmdline, 0, ",l");
        }
    } else if (strcasestr(a->argv[1], "mute")) {
        if (strcasecmp(a->argv[1], "mute") == 0) {
            /* Mute */
            if (strcasecmp(a->argv[3], "all") == 0) {
                ast_str_append(&cmdline, 0, ",N");
            } else {
                ast_str_append(&cmdline, 0, ",M,%s", a->argv[3]);
            }
        } else {
            /* Unmute */
            if (strcasecmp(a->argv[3], "all") == 0) {
                ast_str_append(&cmdline, 0, ",n");
            } else {
                ast_str_append(&cmdline, 0, ",m,%s", a->argv[3]);
            }
        }
    } else if (strcasecmp(a->argv[1], "kick") == 0) {
        if (strcasecmp(a->argv[3], "all") == 0) {
            /* Kick all */
            ast_str_append(&cmdline, 0, ",K");
        } else {
            /* Kick a single user */
            ast_str_append(&cmdline, 0, ",k,%s", a->argv[3]);
        }
    } else {
        /*
         * Should never get here because it is already filtered by the
         * callers.
         */
        ast_free(cmdline);
        return CLI_SHOWUSAGE;
    }
 
    ast_debug(1, "Cmdline: %s\n", ast_str_buffer(cmdline));
 
    admin_exec(NULL, ast_str_buffer(cmdline));
    ast_free(cmdline);
 
    return CLI_SUCCESS;
}

References a, admin_exec(), ast_debug, ast_free, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_set(), CLI_FAILURE, CLI_SHOWUSAGE, CLI_SUCCESS, MAX_CONFNUM, NULL, and strcasestr().

Referenced by meetme_kick_cmd(), meetme_lock_cmd(), and meetme_mute_cmd().

meetme_kick_cmd()

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

static

Definition at line 1951 of file app_meetme.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "meetme kick";
        e->usage =
            "Usage: meetme kick <confno> all|<userno>\n"
            "       Kick a conference or a user in a conference.\n";
        return NULL;
    case CLI_GENERATE:
        return complete_meetmecmd_mute_kick(a->line, a->word, a->pos, a->n);
    }
 
    if (a->argc != 4) {
        return CLI_SHOWUSAGE;
    }
 
    return meetme_cmd_helper(a);
}

References a, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, ast_cli_entry::command, complete_meetmecmd_mute_kick(), meetme_cmd_helper(), NULL, and ast_cli_entry::usage.

meetme_lock_cmd()

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

static

Definition at line 1931 of file app_meetme.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "meetme {lock|unlock}";
        e->usage =
            "Usage: meetme lock|unlock <confno>\n"
            "       Lock or unlock a conference to new users.\n";
        return NULL;
    case CLI_GENERATE:
        return complete_meetmecmd_lock(a->word, a->pos, a->n);
    }
 
    if (a->argc != 3) {
        return CLI_SHOWUSAGE;
    }
 
    return meetme_cmd_helper(a);
}

References a, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, ast_cli_entry::command, complete_meetmecmd_lock(), meetme_cmd_helper(), NULL, and ast_cli_entry::usage.

meetme_menu()

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

Definition at line 2770 of file app_meetme.c.

{
    switch (*menu_mode) {
    case MENU_DISABLED:
        break;
    case MENU_NORMAL:
        meetme_menu_normal(menu_mode, dtmf, conf, confflags, chan, user);
        break;
    case MENU_ADMIN:
        meetme_menu_admin(menu_mode, dtmf, conf, confflags, chan, user);
        /* Admin Menu is capable of branching into another menu, in which case it will reset dtmf and change the menu mode. */
        if (*menu_mode != MENU_ADMIN_EXTENDED || (*dtmf <= 0)) {
            break;
        }
    case MENU_ADMIN_EXTENDED:
        meetme_menu_admin_extended(menu_mode, dtmf, conf, confflags, chan, user,
            recordingtmp, recordingtmp_size, cap_slin);
        break;
    }
}

References meetme_menu_admin(), meetme_menu_admin_extended(), meetme_menu_normal(), MENU_ADMIN, MENU_ADMIN_EXTENDED, MENU_DISABLED, and MENU_NORMAL.

Referenced by conf_run().

meetme_menu_admin()

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

Definition at line 2461 of file app_meetme.c.

{
    switch(*dtmf) {
    case '1': /* Un/Mute */
        *menu_mode = MENU_DISABLED;
        /* for admin, change both admin and use flags */
        if (user->adminflags & (ADMINFLAG_MUTED | ADMINFLAG_SELFMUTED)) {
            user->adminflags &= ~(ADMINFLAG_MUTED | ADMINFLAG_SELFMUTED);
        } else {
            user->adminflags |= (ADMINFLAG_MUTED | ADMINFLAG_SELFMUTED);
        }
 
        if (ast_test_flag64(confflags, CONFFLAG_MONITOR) || (user->adminflags & (ADMINFLAG_MUTED | ADMINFLAG_SELFMUTED))) {
            if (!ast_streamfile(chan, "conf-muted", ast_channel_language(chan))) {
                ast_waitstream(chan, "");
            }
        } else {
            if (!ast_streamfile(chan, "conf-unmuted", ast_channel_language(chan))) {
                ast_waitstream(chan, "");
            }
        }
        break;
 
    case '2': /* Un/Lock the Conference */
        *menu_mode = MENU_DISABLED;
        if (conf->locked) {
            conf->locked = 0;
            if (!ast_streamfile(chan, "conf-unlockednow", ast_channel_language(chan))) {
                ast_waitstream(chan, "");
            }
        } else {
            conf->locked = 1;
            if (!ast_streamfile(chan, "conf-lockednow", ast_channel_language(chan))) {
                ast_waitstream(chan, "");
            }
        }
        break;
 
    case '3': /* Eject last user */
    {
        struct ast_conf_user *usr = NULL;
        int max_no = 0;
        ao2_callback(conf->usercontainer, OBJ_NODATA, user_max_cmp, &max_no);
        *menu_mode = MENU_DISABLED;
        usr = ao2_find(conf->usercontainer, &max_no, 0);
        if ((ast_channel_name(usr->chan) == ast_channel_name(chan)) || ast_test_flag64(&usr->userflags, CONFFLAG_ADMIN)) {
            if (!ast_streamfile(chan, "conf-errormenu", ast_channel_language(chan))) {
                ast_waitstream(chan, "");
            }
        } else {
            usr->adminflags |= ADMINFLAG_KICKME;
        }
        ao2_ref(usr, -1);
        ast_stopstream(chan);
        break;
    }
 
    case '4':
        tweak_listen_volume(user, VOL_DOWN);
        break;
 
    case '5':
        /* Extend RT conference */
        if (rt_schedule) {
            if (!rt_extend_conf(conf->confno)) {
                if (!ast_streamfile(chan, "conf-extended", ast_channel_language(chan))) {
                    ast_waitstream(chan, "");
                }
            } else {
                if (!ast_streamfile(chan, "conf-nonextended", ast_channel_language(chan))) {
                    ast_waitstream(chan, "");
                }
            }
            ast_stopstream(chan);
        }
        *menu_mode = MENU_DISABLED;
        break;
 
    case '6':
        tweak_listen_volume(user, VOL_UP);
        break;
 
    case '7':
        tweak_talk_volume(user, VOL_DOWN);
        break;
 
    case '8':
        if (!ast_streamfile(chan, "conf-adminmenu-menu8", ast_channel_language(chan))) {
            /* If the user provides DTMF while playing the sound, we want to drop right into the extended menu function with new DTMF once we get out of here. */
            *dtmf = ast_waitstream(chan, AST_DIGIT_ANY);
            ast_stopstream(chan);
        }
        *menu_mode = MENU_ADMIN_EXTENDED;
        break;
 
    case '9':
        tweak_talk_volume(user, VOL_UP);
        break;
    default:
        *menu_mode = MENU_DISABLED;
        /* Play an error message! */
        if (!ast_streamfile(chan, "conf-errormenu", ast_channel_language(chan))) {
            ast_waitstream(chan, "");
        }
        break;
    }
 
}

References ADMINFLAG_KICKME, ADMINFLAG_MUTED, ADMINFLAG_SELFMUTED, ast_conf_user::adminflags, ao2_callback, ao2_find, ao2_ref, ast_channel_language(), ast_channel_name(), AST_DIGIT_ANY, ast_stopstream(), ast_streamfile(), ast_test_flag64, ast_waitstream(), ast_conf_user::chan, CONFFLAG_ADMIN, CONFFLAG_MONITOR, MENU_ADMIN_EXTENDED, MENU_DISABLED, NULL, OBJ_NODATA, rt_extend_conf(), rt_schedule, tweak_listen_volume(), tweak_talk_volume(), user_max_cmp(), ast_conf_user::userflags, VOL_DOWN, and VOL_UP.

Referenced by meetme_menu().

meetme_menu_admin_extended()

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

Definition at line 2582 of file app_meetme.c.

{
    int keepplaying;
    int playednamerec;
    int res;
    struct ao2_iterator user_iter;
    struct ast_conf_user *usr = NULL;
 
    switch(*dtmf) {
    case '1': /* *81 Roll call */
        keepplaying = 1;
        playednamerec = 0;
        if (conf->users == 1) {
            if (keepplaying && !ast_streamfile(chan, "conf-onlyperson", ast_channel_language(chan))) {
                res = ast_waitstream(chan, AST_DIGIT_ANY);
                ast_stopstream(chan);
                if (res > 0) {
                    keepplaying = 0;
                }
            }
        } else if (conf->users == 2) {
            if (keepplaying && !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 (keepplaying && !ast_streamfile(chan, "conf-thereare", ast_channel_language(chan))) {
                res = ast_waitstream(chan, AST_DIGIT_ANY);
                ast_stopstream(chan);
                if (res > 0) {
                    keepplaying = 0;
                }
            }
            if (keepplaying) {
                res = ast_say_number(chan, conf->users - 1, AST_DIGIT_ANY, ast_channel_language(chan), (char *) NULL);
                ast_stopstream(chan);
                if (res > 0) {
                    keepplaying = 0;
                }
            }
            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;
                }
            }
        }
        user_iter = ao2_iterator_init(conf->usercontainer, 0);
        while((usr = ao2_iterator_next(&user_iter))) {
            if (ast_fileexists(usr->namerecloc, NULL, NULL)) {
                if (keepplaying && !ast_streamfile(chan, usr->namerecloc, ast_channel_language(chan))) {
                    res = ast_waitstream(chan, AST_DIGIT_ANY);
                    ast_stopstream(chan);
                    if (res > 0) {
                        keepplaying = 0;
                    }
                }
                playednamerec = 1;
            }
            ao2_ref(usr, -1);
        }
        ao2_iterator_destroy(&user_iter);
        if (keepplaying && playednamerec && !ast_streamfile(chan, "conf-roll-callcomplete", ast_channel_language(chan))) {
            res = ast_waitstream(chan, AST_DIGIT_ANY);
            ast_stopstream(chan);
            if (res > 0) {
                keepplaying = 0;
            }
        }
 
        *menu_mode = MENU_DISABLED;
        break;
 
    case '2': /* *82 Eject all non-admins */
        if (conf->users == 1) {
            if(!ast_streamfile(chan, "conf-errormenu", ast_channel_language(chan))) {
                ast_waitstream(chan, "");
            }
        } else {
            ao2_callback(conf->usercontainer, OBJ_NODATA, user_set_kickme_cb, &conf);
        }
        ast_stopstream(chan);
        *menu_mode = MENU_DISABLED;
        break;
 
    case '3': /* *83 (Admin) mute/unmute all non-admins */
        if(conf->gmuted) {
            conf->gmuted = 0;
            ao2_callback(conf->usercontainer, OBJ_NODATA, user_set_unmuted_cb, &conf);
            if (!ast_streamfile(chan, "conf-now-unmuted", ast_channel_language(chan))) {
                ast_waitstream(chan, "");
            }
        } else {
            conf->gmuted = 1;
            ao2_callback(conf->usercontainer, OBJ_NODATA, user_set_muted_cb, &conf);
            if (!ast_streamfile(chan, "conf-now-muted", ast_channel_language(chan))) {
                ast_waitstream(chan, "");
            }
        }
        ast_stopstream(chan);
        *menu_mode = MENU_DISABLED;
        break;
 
    case '4': /* *84 Record conference */
        if (conf->recording != MEETME_RECORD_ACTIVE) {
            ast_set_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, recordingtmp_size, "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)))) {
                struct dahdi_confinfo dahdic;
 
                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);
            if (!ast_streamfile(chan, "conf-now-recording", ast_channel_language(chan))) {
                ast_waitstream(chan, "");
            }
        }
 
        ast_stopstream(chan);
        *menu_mode = MENU_DISABLED;
        break;
 
    case '8': /* *88 Exit the menu and return to the conference... without an error message */
        ast_stopstream(chan);
        *menu_mode = MENU_DISABLED;
        break;
 
    default:
        if (!ast_streamfile(chan, "conf-errormenu", ast_channel_language(chan))) {
            ast_waitstream(chan, "");
        }
        ast_stopstream(chan);
        *menu_mode = MENU_DISABLED;
        break;
    }
}

References ao2_callback, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_channel_fd(), ast_channel_language(), ast_channel_lock, ast_channel_uniqueid(), ast_channel_unlock, AST_DIGIT_ANY, ast_fileexists(), ast_format_slin, ast_hangup(), ast_log, ast_mutex_lock, ast_mutex_unlock, ast_pthread_create_detached_background, AST_PTHREADT_NULL, ast_request(), ast_say_number(), ast_set_flag64, ast_set_read_format(), ast_set_write_format(), ast_stopstream(), ast_strdup, ast_streamfile(), ast_test_flag64, ast_verb, ast_waitstream(), ast_conf_user::chan, CONFFLAG_RECORDCONF, LOG_WARNING, MEETME_RECORD_ACTIVE, MENU_DISABLED, ast_conf_user::namerecloc, NULL, OBJ_NODATA, pbx_builtin_getvar_helper(), recordthread(), user_set_kickme_cb(), user_set_muted_cb(), user_set_unmuted_cb(), and var.

Referenced by meetme_menu().

meetme_menu_normal()

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

Definition at line 2381 of file app_meetme.c.

{
    switch (*dtmf) {
    case '1': /* Un/Mute */
        *menu_mode = MENU_DISABLED;
 
        /* user can only toggle the self-muted state */
        user->adminflags ^= ADMINFLAG_SELFMUTED;
 
        /* they can't override the admin mute state */
        if (ast_test_flag64(confflags, CONFFLAG_MONITOR) || (user->adminflags & (ADMINFLAG_MUTED | ADMINFLAG_SELFMUTED))) {
            if (!ast_streamfile(chan, "conf-muted", ast_channel_language(chan))) {
                ast_waitstream(chan, "");
            }
        } else {
            if (!ast_streamfile(chan, "conf-unmuted", ast_channel_language(chan))) {
                ast_waitstream(chan, "");
            }
        }
        break;
 
    case '2':
        *menu_mode = MENU_DISABLED;
        if (user->adminflags & (ADMINFLAG_MUTED | ADMINFLAG_SELFMUTED)) {
            user->adminflags |= ADMINFLAG_T_REQUEST;
        }
 
        if (user->adminflags & ADMINFLAG_T_REQUEST) {
            if (!ast_streamfile(chan, "beep", ast_channel_language(chan))) {
                ast_waitstream(chan, "");
            }
        }
        break;
 
    case '4':
        tweak_listen_volume(user, VOL_DOWN);
        break;
    case '5':
        /* Extend RT conference */
        if (rt_schedule) {
            rt_extend_conf(conf->confno);
        }
        *menu_mode = MENU_DISABLED;
        break;
 
    case '6':
        tweak_listen_volume(user, VOL_UP);
        break;
 
    case '7':
        tweak_talk_volume(user, VOL_DOWN);
        break;
 
    case '8':
        *menu_mode = MENU_DISABLED;
        break;
 
    case '9':
        tweak_talk_volume(user, VOL_UP);
        break;
 
    default:
        *menu_mode = MENU_DISABLED;
        if (!ast_streamfile(chan, "conf-errormenu", ast_channel_language(chan))) {
            ast_waitstream(chan, "");
        }
        break;
    }
}

References ADMINFLAG_MUTED, ADMINFLAG_SELFMUTED, ADMINFLAG_T_REQUEST, ast_channel_language(), ast_streamfile(), ast_test_flag64, ast_waitstream(), ast_conf_user::chan, CONFFLAG_MONITOR, MENU_DISABLED, rt_extend_conf(), rt_schedule, tweak_listen_volume(), tweak_talk_volume(), VOL_DOWN, and VOL_UP.

Referenced by meetme_menu().

meetme_mute_cmd()

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

static

Definition at line 1971 of file app_meetme.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "meetme {mute|unmute}";
        e->usage =
            "Usage: meetme mute|unmute <confno> all|<userno>\n"
            "       Mute or unmute a conference or a user in a conference.\n";
        return NULL;
    case CLI_GENERATE:
        return complete_meetmecmd_mute_kick(a->line, a->word, a->pos, a->n);
    }
 
    if (a->argc != 4) {
        return CLI_SHOWUSAGE;
    }
 
    return meetme_cmd_helper(a);
}

References a, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, ast_cli_entry::command, complete_meetmecmd_mute_kick(), meetme_cmd_helper(), NULL, and ast_cli_entry::usage.

meetme_set_defaults()

static void meetme_set_defaults ( void  )

static

Definition at line 5386 of file app_meetme.c.

{
    /*  Scheduling support is off by default */
    rt_schedule = 0;
    fuzzystart = 0;
    earlyalert = 0;
    endalert = 0;
    extendby = 0;
 
    /*  Logging of participants defaults to ON for compatibility reasons */
    rt_log_members = 1;
 
    /* Set default number of buffers to be allocated. */
    audio_buffers = DEFAULT_AUDIO_BUFFERS;
}

References audio_buffers, DEFAULT_AUDIO_BUFFERS, earlyalert, endalert, extendby, fuzzystart, rt_log_members, and rt_schedule.

Referenced by load_config_meetme().

meetme_show_cmd()

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

static

Definition at line 1729 of file app_meetme.c.

{
    /* Process the command */
    struct ast_conf_user *user;
    struct ast_conference *cnf;
    int hr, min, sec;
    int total = 0;
    time_t now;
#define MC_HEADER_FORMAT "%-14s %-14s %-10s %-8s  %-8s  %-6s\n"
#define MC_DATA_FORMAT "%-12.12s   %4.4d          %4.4s       %02d:%02d:%02d  %-8s  %-6s\n"
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "meetme list";
        e->usage =
            "Usage: meetme list [<confno>] [" STR_CONCISE "]\n"
            "       List all conferences or a specific conference.\n";
        return NULL;
    case CLI_GENERATE:
        return complete_meetmecmd_list(a->line, a->word, a->pos, a->n);
    }
 
    if (a->argc == 2 || (a->argc == 3 && !strcasecmp(a->argv[2], STR_CONCISE))) {
        /* List all the conferences */
        int concise = (a->argc == 3);
        struct ast_str *marked_users;
 
        if (!(marked_users = ast_str_create(30))) {
            return CLI_FAILURE;
        }
 
        now = time(NULL);
        AST_LIST_LOCK(&confs);
        if (AST_LIST_EMPTY(&confs)) {
            if (!concise) {
                ast_cli(a->fd, "No active MeetMe conferences.\n");
            }
            AST_LIST_UNLOCK(&confs);
            ast_free(marked_users);
            return CLI_SUCCESS;
        }
        if (!concise) {
            ast_cli(a->fd, MC_HEADER_FORMAT, "Conf Num", "Parties", "Marked", "Activity", "Creation", "Locked");
        }
        AST_LIST_TRAVERSE(&confs, cnf, list) {
            hr = (now - cnf->start) / 3600;
            min = ((now - cnf->start) % 3600) / 60;
            sec = (now - cnf->start) % 60;
            if (!concise) {
                if (cnf->markedusers == 0) {
                    ast_str_set(&marked_users, 0, "N/A ");
                } else {
                    ast_str_set(&marked_users, 0, "%4.4d", cnf->markedusers);
                }
                ast_cli(a->fd, MC_DATA_FORMAT, cnf->confno, cnf->users,
                    ast_str_buffer(marked_users), hr, min, sec,
                    cnf->isdynamic ? "Dynamic" : "Static", cnf->locked ? "Yes" : "No");
            } else {
                ast_cli(a->fd, "%s!%d!%d!%02d:%02d:%02d!%d!%d\n",
                    cnf->confno,
                    cnf->users,
                    cnf->markedusers,
                    hr, min, sec,
                    cnf->isdynamic,
                    cnf->locked);
            }
 
            total += cnf->users;
        }
        AST_LIST_UNLOCK(&confs);
        if (!concise) {
            ast_cli(a->fd, "* Total number of MeetMe users: %d\n", total);
        }
        ast_free(marked_users);
        return CLI_SUCCESS;
    }
    if (a->argc == 3 || (a->argc == 4 && !strcasecmp(a->argv[3], STR_CONCISE))) {
        struct ao2_iterator user_iter;
        int concise = (a->argc == 4);
 
        /* List all the users in a conference */
        if (AST_LIST_EMPTY(&confs)) {
            if (!concise) {
                ast_cli(a->fd, "No active MeetMe conferences.\n");
            }
            return CLI_SUCCESS;
        }
        /* Find the right conference */
        AST_LIST_LOCK(&confs);
        AST_LIST_TRAVERSE(&confs, cnf, list) {
            if (strcmp(cnf->confno, a->argv[2]) == 0) {
                break;
            }
        }
        if (!cnf) {
            if (!concise)
                ast_cli(a->fd, "No such conference: %s.\n", a->argv[2]);
            AST_LIST_UNLOCK(&confs);
            return CLI_SUCCESS;
        }
        /* Show all the users */
        time(&now);
        user_iter = ao2_iterator_init(cnf->usercontainer, 0);
        while((user = ao2_iterator_next(&user_iter))) {
            hr = (now - user->jointime) / 3600;
            min = ((now - user->jointime) % 3600) / 60;
            sec = (now - user->jointime) % 60;
            if (!concise) {
                ast_cli(a->fd, "User #: %-2.2d %12.12s %-20.20s Channel: %s %s %s %s %s %s %02d:%02d:%02d\n",
                    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>"),
                    ast_channel_name(user->chan),
                    ast_test_flag64(&user->userflags, CONFFLAG_ADMIN) ? "(Admin)" : "",
                    ast_test_flag64(&user->userflags, CONFFLAG_MONITOR) ? "(Listen only)" : "",
                    user->adminflags & ADMINFLAG_MUTED ? "(Admin Muted)" : user->adminflags & ADMINFLAG_SELFMUTED ? "(Muted)" : "",
                    user->adminflags & ADMINFLAG_T_REQUEST ? "(Request to Talk)" : "",
                    istalking(user->talking), hr, min, sec);
            } else {
                ast_cli(a->fd, "%d!%s!%s!%s!%s!%s!%s!%s!%d!%02d:%02d:%02d\n",
                    user->user_no,
                    S_COR(ast_channel_caller(user->chan)->id.number.valid, ast_channel_caller(user->chan)->id.number.str, ""),
                    S_COR(ast_channel_caller(user->chan)->id.name.valid, ast_channel_caller(user->chan)->id.name.str, ""),
                    ast_channel_name(user->chan),
                    ast_test_flag64(&user->userflags, CONFFLAG_ADMIN) ? "1" : "",
                    ast_test_flag64(&user->userflags, CONFFLAG_MONITOR) ? "1" : "",
                    user->adminflags & (ADMINFLAG_MUTED | ADMINFLAG_SELFMUTED) ? "1" : "",
                    user->adminflags & ADMINFLAG_T_REQUEST ? "1" : "",
                    user->talking, hr, min, sec);
            }
            ao2_ref(user, -1);
        }
        ao2_iterator_destroy(&user_iter);
        if (!concise) {
            ast_cli(a->fd, "%d users in that conference.\n", cnf->users);
        }
        AST_LIST_UNLOCK(&confs);
        return CLI_SUCCESS;
    }
    return CLI_SHOWUSAGE;
}

References a, ADMINFLAG_MUTED, ADMINFLAG_SELFMUTED, ADMINFLAG_T_REQUEST, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_channel_caller(), ast_channel_name(), ast_cli(), ast_free, AST_LIST_EMPTY, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_str_buffer(), ast_str_create, ast_str_set(), ast_test_flag64, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_meetmecmd_list(), CONFFLAG_ADMIN, CONFFLAG_MONITOR, ast_conference::confno, ast_party_caller::id, ast_conference::isdynamic, istalking(), ast_conference::locked, ast_conference::markedusers, MC_DATA_FORMAT, MC_HEADER_FORMAT, min, ast_party_id::name, NULL, ast_party_id::number, S_COR, ast_conference::start, ast_party_name::str, ast_party_number::str, STR_CONCISE, total, ast_cli_entry::usage, ast_conference::usercontainer, ast_conference::users, ast_party_name::valid, and ast_party_number::valid.

meetme_stasis_cb()

static void meetme_stasis_cb ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

Definition at line 1102 of file app_meetme.c.

{
    struct ast_channel_blob *channel_blob = stasis_message_data(message);
    struct stasis_message_type *message_type;
    const char *event;
    const char *conference_num;
    const char *status;
    struct ast_json *json_cur;
    RAII_VAR(struct ast_str *, channel_text, NULL, ast_free);
    RAII_VAR(struct ast_str *, extra_text, NULL, ast_free);
 
    if (!channel_blob) {
        ast_assert(0);
        return;
    }
 
    message_type = stasis_message_type(message);
 
    if (!message_type) {
        ast_assert(0);
        return;
    }
 
    if (message_type == meetme_join_type()) {
        event = "MeetmeJoin";
    } else if (message_type == meetme_leave_type()) {
        event = "MeetmeLeave";
    } else if (message_type == meetme_end_type()) {
        event = "MeetmeEnd";
    } else if (message_type == meetme_mute_type()) {
        event = "MeetmeMute";
    } else if (message_type == meetme_talking_type()) {
        event = "MeetmeTalking";
    } else if (message_type == meetme_talk_request_type()) {
        event = "MeetmeTalkRequest";
    } else {
        ast_assert(0);
        return;
    }
 
    if (!event) {
        ast_assert(0);
        return;
    }
 
    conference_num = ast_json_string_get(ast_json_object_get(channel_blob->blob, "Meetme"));
    if (!conference_num) {
        ast_assert(0);
        return;
    }
 
    status = ast_json_string_get(ast_json_object_get(channel_blob->blob, "status"));
    if (status) {
        ast_str_append_event_header(&extra_text, "Status", status);
    }
 
    if (channel_blob->snapshot) {
        channel_text = ast_manager_build_channel_state_string(channel_blob->snapshot);
    }
 
    if ((json_cur = ast_json_object_get(channel_blob->blob, "user"))) {
        int user_number = ast_json_integer_get(json_cur);
        RAII_VAR(struct ast_str *, user_prop_str, ast_str_create(32), ast_free);
        if (!user_prop_str) {
            return;
        }
 
        ast_str_set(&user_prop_str, 0, "%d", user_number);
        ast_str_append_event_header(&extra_text, "User", ast_str_buffer(user_prop_str));
 
        if ((json_cur = ast_json_object_get(channel_blob->blob, "duration"))) {
            int duration = ast_json_integer_get(json_cur);
            ast_str_set(&user_prop_str, 0, "%d", duration);
            ast_str_append_event_header(&extra_text, "Duration", ast_str_buffer(user_prop_str));
        }
 
        json_cur = NULL;
    }
 
    manager_event(EVENT_FLAG_CALL, event,
        "Meetme: %s\r\n"
        "%s"
        "%s",
        conference_num,
        channel_text ? ast_str_buffer(channel_text) : "",
        extra_text ? ast_str_buffer(extra_text) : "");
}

References ast_assert, ast_free, ast_json_integer_get(), ast_json_object_get(), ast_json_string_get(), ast_manager_build_channel_state_string(), ast_str_append_event_header(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_channel_blob::blob, EVENT_FLAG_CALL, manager_event, NULL, RAII_VAR, ast_channel_blob::snapshot, stasis_message_data(), and status.

Referenced by meetme_stasis_init().

meetme_stasis_cleanup()

static void meetme_stasis_cleanup ( void  )

static

Definition at line 1018 of file app_meetme.c.

{
    if (meetme_event_message_router) {
        stasis_message_router_unsubscribe(meetme_event_message_router);
        meetme_event_message_router = NULL;
    }
 
    STASIS_MESSAGE_TYPE_CLEANUP(meetme_join_type);
    STASIS_MESSAGE_TYPE_CLEANUP(meetme_leave_type);
    STASIS_MESSAGE_TYPE_CLEANUP(meetme_end_type);
    STASIS_MESSAGE_TYPE_CLEANUP(meetme_mute_type);
    STASIS_MESSAGE_TYPE_CLEANUP(meetme_talking_type);
    STASIS_MESSAGE_TYPE_CLEANUP(meetme_talk_request_type);
}

References meetme_event_message_router, NULL, stasis_message_router_unsubscribe(), and STASIS_MESSAGE_TYPE_CLEANUP.

Referenced by meetme_stasis_init(), and unload_module().

meetme_stasis_generate_msg()

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

Definition at line 1219 of file app_meetme.c.

{
    RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
    RAII_VAR(struct ast_json *, json_object, NULL, ast_json_unref);
 
    json_object = ast_json_pack("{s: s}",
        "Meetme", meetme_conference->confno);
 
    if (!json_object) {
        return;
    }
 
    if (extras) {
        ast_json_object_update(json_object, extras);
    }
 
    if (user) {
        struct timeval now = ast_tvnow();
        long duration = (long)(now.tv_sec - user->jointime);
        struct ast_json *json_user;
        struct ast_json *json_user_duration;
 
        json_user = ast_json_integer_create(user->user_no);
        if (!json_user || ast_json_object_set(json_object, "user", json_user)) {
            return;
        }
 
        if (duration > 0) {
            json_user_duration = ast_json_integer_create(duration);
            if (!json_user_duration
                || ast_json_object_set(json_object, "duration", json_user_duration)) {
                return;
            }
        }
    }
 
    if (chan) {
        ast_channel_lock(chan);
    }
    msg = ast_channel_blob_create(chan, message_type, json_object);
    if (chan) {
        ast_channel_unlock(chan);
    }
 
    if (!msg) {
        return;
    }
 
    stasis_publish(ast_channel_topic(chan), msg);
}

References ao2_cleanup, ast_channel_blob_create(), ast_channel_lock, ast_channel_topic(), ast_channel_unlock, ast_json_integer_create(), ast_json_object_set(), ast_json_object_update(), ast_json_pack(), ast_json_unref(), ast_tvnow(), ast_conference::confno, NULL, RAII_VAR, and stasis_publish().

Referenced by conf_free(), conf_run(), and send_talking_event().

meetme_stasis_init()

static int meetme_stasis_init ( void  )

static

Definition at line 1033 of file app_meetme.c.

{
 
    STASIS_MESSAGE_TYPE_INIT(meetme_join_type);
    STASIS_MESSAGE_TYPE_INIT(meetme_leave_type);
    STASIS_MESSAGE_TYPE_INIT(meetme_end_type);
    STASIS_MESSAGE_TYPE_INIT(meetme_mute_type);
    STASIS_MESSAGE_TYPE_INIT(meetme_talking_type);
    STASIS_MESSAGE_TYPE_INIT(meetme_talk_request_type);
 
    meetme_event_message_router = stasis_message_router_create(
        ast_channel_topic_all());
 
    if (!meetme_event_message_router) {
        meetme_stasis_cleanup();
        return -1;
    }
 
    if (stasis_message_router_add(meetme_event_message_router,
            meetme_join_type(),
            meetme_stasis_cb,
            NULL)) {
        meetme_stasis_cleanup();
        return -1;
    }
 
    if (stasis_message_router_add(meetme_event_message_router,
            meetme_leave_type(),
            meetme_stasis_cb,
            NULL)) {
        meetme_stasis_cleanup();
        return -1;
    }
 
    if (stasis_message_router_add(meetme_event_message_router,
            meetme_end_type(),
            meetme_stasis_cb,
            NULL)) {
        meetme_stasis_cleanup();
        return -1;
    }
 
    if (stasis_message_router_add(meetme_event_message_router,
            meetme_mute_type(),
            meetme_stasis_cb,
            NULL)) {
        meetme_stasis_cleanup();
        return -1;
    }
 
    if (stasis_message_router_add(meetme_event_message_router,
            meetme_talking_type(),
            meetme_stasis_cb,
            NULL)) {
        meetme_stasis_cleanup();
        return -1;
    }
 
    if (stasis_message_router_add(meetme_event_message_router,
            meetme_talk_request_type(),
            meetme_stasis_cb,
            NULL)) {
        meetme_stasis_cleanup();
        return -1;
    }
 
    return 0;
}

References ast_channel_topic_all(), meetme_event_message_router, meetme_stasis_cb(), meetme_stasis_cleanup(), NULL, stasis_message_router_add(), stasis_message_router_create, and STASIS_MESSAGE_TYPE_INIT.

Referenced by load_module().

meetmemute()

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

static

Definition at line 5065 of file app_meetme.c.

{
    struct ast_conference *conf;
    struct ast_conf_user *user;
    const char *confid = astman_get_header(m, "Meetme");
    char *userid = ast_strdupa(astman_get_header(m, "Usernum"));
    int userno;
 
    if (ast_strlen_zero(confid)) {
        astman_send_error(s, m, "Meetme conference not specified");
        return 0;
    }
 
    if (ast_strlen_zero(userid)) {
        astman_send_error(s, m, "Meetme user number not specified");
        return 0;
    }
 
    userno = strtoul(userid, &userid, 10);
 
    if (*userid) {
        astman_send_error(s, m, "Invalid user number");
        return 0;
    }
 
    /* Look in the conference list */
    AST_LIST_LOCK(&confs);
    AST_LIST_TRAVERSE(&confs, conf, list) {
        if (!strcmp(confid, conf->confno))
            break;
    }
 
    if (!conf) {
        AST_LIST_UNLOCK(&confs);
        astman_send_error(s, m, "Meetme conference does not exist");
        return 0;
    }
 
    user = ao2_find(conf->usercontainer, &userno, 0);
 
    if (!user) {
        AST_LIST_UNLOCK(&confs);
        astman_send_error(s, m, "User number not found");
        return 0;
    }
 
    if (mute)
        user->adminflags |= ADMINFLAG_MUTED;    /* request user muting */
    else
        user->adminflags &= ~(ADMINFLAG_MUTED | ADMINFLAG_SELFMUTED | ADMINFLAG_T_REQUEST); /* request user unmuting */
 
    AST_LIST_UNLOCK(&confs);
 
    ast_log(LOG_NOTICE, "Requested to %smute conf %s user %d userchan %s uniqueid %s\n", mute ? "" : "un", conf->confno, user->user_no, ast_channel_name(user->chan), ast_channel_uniqueid(user->chan));
 
    ao2_ref(user, -1);
    astman_send_ack(s, m, mute ? "User muted" : "User unmuted");
    return 0;
}

References ADMINFLAG_MUTED, ADMINFLAG_SELFMUTED, ADMINFLAG_T_REQUEST, ao2_find, ao2_ref, ast_channel_name(), ast_channel_uniqueid(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, ast_strdupa, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), ast_conf_user::list, and LOG_NOTICE.

Referenced by action_meetmemute(), and action_meetmeunmute().

meetmestate()

static enum ast_device_state meetmestate ( const char *  data )

static

Callback for devicestate providers.

Definition at line 5364 of file app_meetme.c.

{
    struct ast_conference *conf;
 
    /* Find conference */
    AST_LIST_LOCK(&confs);
    AST_LIST_TRAVERSE(&confs, conf, list) {
        if (!strcmp(data, conf->confno))
            break;
    }
    AST_LIST_UNLOCK(&confs);
    if (!conf)
        return AST_DEVICE_INVALID;
 
 
    /* SKREP to fill */
    if (!conf->users)
        return AST_DEVICE_NOT_INUSE;
 
    return AST_DEVICE_INUSE;
}

References AST_DEVICE_INUSE, AST_DEVICE_INVALID, AST_DEVICE_NOT_INUSE, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, and ast_conference::list.

Referenced by load_module().

recordthread()

static void * recordthread ( void *  args )

static

Definition at line 5295 of file app_meetme.c.

{
    struct ast_conference *cnf = args;
    struct ast_frame *f = NULL;
    int flags;
    struct ast_filestream *s = NULL;
    int res = 0;
    int x;
    const char *oldrecordingfilename = NULL;
    char filename_buffer[PATH_MAX];
 
    if (!cnf || !cnf->lchan) {
        pthread_exit(0);
    }
 
    filename_buffer[0] = '\0';
    filename_parse(cnf->recordingfilename, filename_buffer);
 
    ast_stopstream(cnf->lchan);
    flags = O_CREAT | O_TRUNC | O_WRONLY;
 
 
    cnf->recording = MEETME_RECORD_ACTIVE;
    while (ast_waitfor(cnf->lchan, -1) > -1) {
        if (cnf->recording == MEETME_RECORD_TERMINATE) {
            AST_LIST_LOCK(&confs);
            AST_LIST_UNLOCK(&confs);
            break;
        }
        if (!s && !(ast_strlen_zero(filename_buffer)) && (filename_buffer != oldrecordingfilename)) {
            s = ast_writefile(filename_buffer, cnf->recordingformat, NULL, flags, 0, AST_FILE_MODE);
            oldrecordingfilename = filename_buffer;
        }
 
        f = ast_read(cnf->lchan);
        if (!f) {
            res = -1;
            break;
        }
        if (f->frametype == AST_FRAME_VOICE) {
            ast_mutex_lock(&cnf->listenlock);
            for (x = 0; x < AST_FRAME_BITS; x++) {
                /* Free any translations that have occured */
                if (cnf->transframe[x]) {
                    ast_frfree(cnf->transframe[x]);
                    cnf->transframe[x] = NULL;
                }
            }
            if (cnf->origframe)
                ast_frfree(cnf->origframe);
            cnf->origframe = ast_frdup(f);
            ast_mutex_unlock(&cnf->listenlock);
            if (s)
                res = ast_writestream(s, f);
            if (res) {
                ast_frfree(f);
                break;
            }
        }
        ast_frfree(f);
    }
    cnf->recording = MEETME_RECORD_OFF;
    if (s)
        ast_closestream(s);
 
    pthread_exit(0);
}

References args, ast_closestream(), AST_FILE_MODE, AST_FRAME_BITS, AST_FRAME_VOICE, ast_frdup, ast_frfree, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_mutex_lock, ast_mutex_unlock, ast_read(), ast_stopstream(), ast_strlen_zero(), ast_waitfor(), ast_writefile(), ast_writestream(), ast_filestream::f, filename_parse(), ast_frame::flags, ast_filestream::flags, ast_conference::lchan, ast_conference::listenlock, MEETME_RECORD_ACTIVE, MEETME_RECORD_OFF, MEETME_RECORD_TERMINATE, NULL, ast_conference::origframe, PATH_MAX, ast_conference::recording, ast_conference::recordingfilename, ast_conference::recordingformat, and ast_conference::transframe.

Referenced by conf_run(), and meetme_menu_admin_extended().

reload()

static int reload ( void  )

static

Definition at line 5607 of file app_meetme.c.

{
    ast_unload_realtime("meetme");
    return load_config(1);
}

References ast_unload_realtime(), and load_config().

Referenced by load_config(), and load_config_meetme().

reset_volumes()

static void reset_volumes ( struct ast_conf_user *  user )

static

Definition at line 1394 of file app_meetme.c.

{
    signed char zero_volume = 0;
 
    ast_channel_setoption(user->chan, AST_OPTION_TXGAIN, &zero_volume, sizeof(zero_volume), 0);
    ast_channel_setoption(user->chan, AST_OPTION_RXGAIN, &zero_volume, sizeof(zero_volume), 0);
}

References ast_channel_setoption(), AST_OPTION_RXGAIN, and AST_OPTION_TXGAIN.

Referenced by admin_exec(), conf_run(), and user_reset_vol_cb().

rt_extend_conf()

static int rt_extend_conf ( const char *  confno )

static

Definition at line 2138 of file app_meetme.c.

{
    char currenttime[32];
    char endtime[32];
    struct timeval now;
    struct ast_tm tm;
    struct ast_variable *var, *orig_var;
    char bookid[51];
 
    if (!extendby) {
        return 0;
    }
 
    now = ast_tvnow();
 
    ast_localtime(&now, &tm, NULL);
    ast_strftime(currenttime, sizeof(currenttime), DATE_FORMAT, &tm);
 
    var = ast_load_realtime("meetme", "confno",
        confno, "startTime<= ", currenttime,
        "endtime>= ", currenttime, NULL);
 
    orig_var = var;
 
    /* Identify the specific RealTime conference */
    while (var) {
        if (!strcasecmp(var->name, "bookid")) {
            ast_copy_string(bookid, var->value, sizeof(bookid));
        }
        if (!strcasecmp(var->name, "endtime")) {
            ast_copy_string(endtime, var->value, sizeof(endtime));
        }
 
        var = var->next;
    }
    ast_variables_destroy(orig_var);
 
    ast_strptime(endtime, DATE_FORMAT, &tm);
    now = ast_mktime(&tm, NULL);
 
    now.tv_sec += extendby;
 
    ast_localtime(&now, &tm, NULL);
    ast_strftime(currenttime, sizeof(currenttime), DATE_FORMAT, &tm);
    strcat(currenttime, "0"); /* Seconds needs to be 00 */
 
    var = ast_load_realtime("meetme", "confno",
        confno, "startTime<= ", currenttime,
        "endtime>= ", currenttime, NULL);
 
    /* If there is no conflict with extending the conference, update the DB */
    if (!var) {
        ast_debug(3, "Trying to update the endtime of Conference %s to %s\n", confno, currenttime);
        ast_update_realtime("meetme", "bookid", bookid, "endtime", currenttime, NULL);
        return 0;
 
    }
 
    ast_variables_destroy(var);
    return -1;
}

References ast_copy_string(), ast_debug, ast_load_realtime(), ast_localtime(), ast_mktime(), ast_strftime(), ast_strptime(), ast_tvnow(), ast_update_realtime(), ast_variables_destroy(), DATE_FORMAT, extendby, NULL, and var.

Referenced by admin_exec(), meetme_menu_admin(), and meetme_menu_normal().

send_talking_event()

static void send_talking_event ( struct ast_channel *  chan, struct ast_conference *  conf, struct ast_conf_user *  user, int  talking  )

static

Definition at line 2296 of file app_meetme.c.

{
    RAII_VAR(struct ast_json *, status_blob, status_to_json(talking), ast_json_unref);
    meetme_stasis_generate_msg(conf, chan, user, meetme_talking_type(), status_blob);
}

References ast_json_unref(), ast_conference::chan, meetme_stasis_generate_msg(), RAII_VAR, and status_to_json().

Referenced by set_user_talking().

set_listen_volume()

static int set_listen_volume ( struct ast_conf_user *  user, int  volume  )

static

Definition at line 1323 of file app_meetme.c.

{
    char gain_adjust;
 
    /* attempt to make the adjustment in the channel driver;
       if successful, don't adjust in the frame reading routine
    */
    gain_adjust = gain_map[volume + 5];
 
    return ast_channel_setoption(user->chan, AST_OPTION_TXGAIN, &gain_adjust, sizeof(gain_adjust), 0);
}

References ast_channel_setoption(), AST_OPTION_TXGAIN, and gain_map.

Referenced by tweak_listen_volume().

set_talk_volume()

static int set_talk_volume ( struct ast_conf_user *  user, int  volume  )

static

Definition at line 1311 of file app_meetme.c.

{
    char gain_adjust;
 
    /* attempt to make the adjustment in the channel driver;
       if successful, don't adjust in the frame reading routine
    */
    gain_adjust = gain_map[volume + 5];
 
    return ast_channel_setoption(user->chan, AST_OPTION_RXGAIN, &gain_adjust, sizeof(gain_adjust), 0);
}

References ast_channel_setoption(), AST_OPTION_RXGAIN, and gain_map.

Referenced by conf_run(), and tweak_talk_volume().

set_user_talking()

static void set_user_talking ( struct ast_channel *  chan, struct ast_conference *  conf, struct ast_conf_user *  user, int  talking, int  monitor  )

static

Definition at line 2302 of file app_meetme.c.

{
    int last_talking = user->talking;
    if (last_talking == talking)
        return;
 
    user->talking = talking;
 
    if (monitor) {
        /* Check if talking state changed. Take care of -1 which means unmonitored */
        int was_talking = (last_talking > 0);
        int now_talking = (talking > 0);
        if (was_talking != now_talking) {
            send_talking_event(chan, conf, user, now_talking);
        }
    }
}

References ast_conference::chan, and send_talking_event().

Referenced by conf_run().

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [1/6]

STASIS_MESSAGE_TYPE_DEFN_LOCAL

(

meetme_end_type

)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [2/6]

STASIS_MESSAGE_TYPE_DEFN_LOCAL

(

meetme_join_type

)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [3/6]

STASIS_MESSAGE_TYPE_DEFN_LOCAL

(

meetme_leave_type

)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [4/6]

STASIS_MESSAGE_TYPE_DEFN_LOCAL

(

meetme_mute_type

)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [5/6]

STASIS_MESSAGE_TYPE_DEFN_LOCAL

(

meetme_talk_request_type

)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [6/6]

STASIS_MESSAGE_TYPE_DEFN_LOCAL

(

meetme_talking_type

)

status_to_json()

static struct ast_json * status_to_json ( int  on )

static

Definition at line 1200 of file app_meetme.c.

{
    struct ast_json *json_object = ast_json_pack("{s: s}",
        "status", on ? "on" : "off");
 
    return json_object;
}

References ast_json_pack().

Referenced by conf_run(), and send_talking_event().

tweak_listen_volume()

static void tweak_listen_volume ( struct ast_conf_user *  user, enum volume_action  action  )

static

Definition at line 1382 of file app_meetme.c.

{
    tweak_volume(&user->listen, action);
    /* attempt to make the adjustment in the channel driver;
       if successful, don't adjust in the frame reading routine
    */
    if (!set_listen_volume(user, user->listen.desired))
        user->listen.actual = 0;
    else
        user->listen.actual = user->listen.desired;
}

References set_listen_volume(), and tweak_volume().

Referenced by admin_exec(), meetme_menu_admin(), meetme_menu_normal(), user_listen_voldown_cb(), and user_listen_volup_cb().

tweak_talk_volume()

static void tweak_talk_volume ( struct ast_conf_user *  user, enum volume_action  action  )

static

Definition at line 1370 of file app_meetme.c.

{
    tweak_volume(&user->talk, action);
    /* attempt to make the adjustment in the channel driver;
       if successful, don't adjust in the frame reading routine
    */
    if (!set_talk_volume(user, user->talk.desired))
        user->talk.actual = 0;
    else
        user->talk.actual = user->talk.desired;
}

References set_talk_volume(), and tweak_volume().

Referenced by admin_exec(), meetme_menu_admin(), meetme_menu_normal(), user_talk_voldown_cb(), and user_talk_volup_cb().

tweak_volume()

static void tweak_volume ( struct volume *  vol, enum volume_action  action  )

static

Definition at line 1335 of file app_meetme.c.

{
    switch (action) {
    case VOL_UP:
        switch (vol->desired) {
        case 5:
            break;
        case 0:
            vol->desired = 2;
            break;
        case -2:
            vol->desired = 0;
            break;
        default:
            vol->desired++;
            break;
        }
        break;
    case VOL_DOWN:
        switch (vol->desired) {
        case -5:
            break;
        case 2:
            vol->desired = 0;
            break;
        case 0:
            vol->desired = -2;
            break;
        default:
            vol->desired--;
            break;
        }
    }
}

References volume::desired, VOL_DOWN, and VOL_UP.

Referenced by tweak_listen_volume(), and tweak_talk_volume().

unload_module()

static int unload_module ( void  )

static

Definition at line 5547 of file app_meetme.c.

{
    int res = 0;
 
    ast_cli_unregister_multiple(cli_meetme, ARRAY_LEN(cli_meetme));
    res = ast_manager_unregister("MeetmeMute");
    res |= ast_manager_unregister("MeetmeUnmute");
    res |= ast_manager_unregister("MeetmeList");
    res |= ast_manager_unregister("MeetmeListRooms");
    res |= ast_unregister_application(app4);
    res |= ast_unregister_application(app3);
    res |= ast_unregister_application(app2);
    res |= ast_unregister_application(app);
 
    ast_devstate_prov_del("Meetme");
 
    res |= ast_custom_function_unregister(&meetme_info_acf);
    ast_unload_realtime("meetme");
 
    meetme_stasis_cleanup();
 
    return res;
}

References app, app2, app3, app4, ARRAY_LEN, ast_cli_unregister_multiple(), ast_custom_function_unregister(), ast_devstate_prov_del(), ast_manager_unregister(), ast_unload_realtime(), ast_unregister_application(), cli_meetme, meetme_info_acf, and meetme_stasis_cleanup().

user_chan_cb()

static int user_chan_cb ( void *  obj, void *  args, int  flags  )

static

Definition at line 4816 of file app_meetme.c.

{
    struct ast_conf_user *user = obj;
    const char *channel = args;
 
    if (!strcmp(ast_channel_name(user->chan), channel)) {
        return (CMP_MATCH | CMP_STOP);
    }
 
    return 0;
}

References args, ast_channel_name(), CMP_MATCH, and CMP_STOP.

Referenced by channel_admin_exec().

user_listen_voldown_cb()

static int user_listen_voldown_cb ( void *  obj, void *  unused, int  flags  )

static

Definition at line 4788 of file app_meetme.c.

{
    struct ast_conf_user *user = obj;
    tweak_listen_volume(user, VOL_DOWN);
    return 0;
}

References tweak_listen_volume(), and VOL_DOWN.

Referenced by admin_exec().

user_listen_volup_cb()

static int user_listen_volup_cb ( void *  obj, void *  unused, int  flags  )

static

Definition at line 4781 of file app_meetme.c.

{
    struct ast_conf_user *user = obj;
    tweak_listen_volume(user, VOL_UP);
    return 0;
}

References tweak_listen_volume(), and VOL_UP.

Referenced by admin_exec().

user_max_cmp()

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

static

Definition at line 1455 of file app_meetme.c.

{
    struct ast_conf_user *user = obj;
    int *max_no = arg;
 
    if (user->user_no > *max_no) {
        *max_no = user->user_no;
    }
 
    return 0;
}

Referenced by admin_exec(), conf_run(), and meetme_menu_admin().

user_no_cmp()

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

static

Definition at line 1443 of file app_meetme.c.

{
    struct ast_conf_user *user = obj;
    int *user_no = arg;
 
    if (user->user_no == *user_no) {
        return (CMP_MATCH | CMP_STOP);
    }
 
    return 0;
}

References CMP_MATCH, CMP_STOP, and ast_conf_user::user_no.

Referenced by build_conf().

user_reset_vol_cb()

static int user_reset_vol_cb ( void *  obj, void *  unused, int  flags  )

static

Definition at line 4809 of file app_meetme.c.

{
    struct ast_conf_user *user = obj;
    reset_volumes(user);
    return 0;
}

References reset_volumes().

Referenced by admin_exec().

user_set_hangup_cb()

static int user_set_hangup_cb ( void *  obj, void *  check_admin_arg, int  flags  )

static

Definition at line 2320 of file app_meetme.c.

{
    struct ast_conf_user *user = obj;
    /* actual pointer contents of check_admin_arg is irrelevant */
 
    if (!check_admin_arg || (check_admin_arg && !ast_test_flag64(&user->userflags, CONFFLAG_ADMIN))) {
        user->adminflags |= ADMINFLAG_HANGUP;
    }
    return 0;
}

References ADMINFLAG_HANGUP, ast_test_flag64, and CONFFLAG_ADMIN.

Referenced by conf_run().

user_set_kickme_cb()

static int user_set_kickme_cb ( void *  obj, void *  check_admin_arg, int  flags  )

static

Definition at line 2331 of file app_meetme.c.

{
    struct ast_conf_user *user = obj;
    /* actual pointer contents of check_admin_arg is irrelevant */
 
    if (!check_admin_arg || (check_admin_arg && !ast_test_flag64(&user->userflags, CONFFLAG_ADMIN))) {
        user->adminflags |= ADMINFLAG_KICKME;
    }
    return 0;
}

References ADMINFLAG_KICKME, ast_test_flag64, and CONFFLAG_ADMIN.

Referenced by admin_exec(), and meetme_menu_admin_extended().

user_set_muted_cb()

static int user_set_muted_cb ( void *  obj, void *  check_admin_arg, int  flags  )

static

Definition at line 2353 of file app_meetme.c.

{
    struct ast_conf_user *user = obj;
    /* actual pointer contents of check_admin_arg is irrelevant */
 
    if (!check_admin_arg || !ast_test_flag64(&user->userflags, CONFFLAG_ADMIN)) {
        user->adminflags |= ADMINFLAG_MUTED;
    }
    return 0;
}

References ADMINFLAG_MUTED, ast_test_flag64, and CONFFLAG_ADMIN.

Referenced by admin_exec(), and meetme_menu_admin_extended().

user_set_unmuted_cb()

static int user_set_unmuted_cb ( void *  obj, void *  check_admin_arg, int  flags  )

static

Definition at line 2342 of file app_meetme.c.

{
    struct ast_conf_user *user = obj;
    /* actual pointer contents of check_admin_arg is irrelevant */
 
    if (!check_admin_arg || !ast_test_flag64(&user->userflags, CONFFLAG_ADMIN)) {
        user->adminflags &= ~(ADMINFLAG_MUTED | ADMINFLAG_SELFMUTED | ADMINFLAG_T_REQUEST);
    }
    return 0;
}

References ADMINFLAG_MUTED, ADMINFLAG_SELFMUTED, ADMINFLAG_T_REQUEST, ast_test_flag64, and CONFFLAG_ADMIN.

Referenced by admin_exec(), and meetme_menu_admin_extended().

user_talk_voldown_cb()

static int user_talk_voldown_cb ( void *  obj, void *  unused, int  flags  )

static

Definition at line 4802 of file app_meetme.c.

{
    struct ast_conf_user *user = obj;
    tweak_talk_volume(user, VOL_DOWN);
    return 0;
}

References tweak_talk_volume(), and VOL_DOWN.

Referenced by admin_exec().

user_talk_volup_cb()

static int user_talk_volup_cb ( void *  obj, void *  unused, int  flags  )

static

Definition at line 4795 of file app_meetme.c.

{
    struct ast_conf_user *user = obj;
    tweak_talk_volume(user, VOL_UP);
    return 0;
}

References tweak_talk_volume(), and VOL_UP.

Referenced by admin_exec().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "MeetMe conference bridge" , .key = ASTERISK_GPL_KEY , .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

Definition at line 5620 of file app_meetme.c.

app

const char* const app = "MeetMe"

static

Definition at line 866 of file app_meetme.c.

Referenced by load_module(), and unload_module().

app2

const char* const app2 = "MeetMeCount"

static

Definition at line 867 of file app_meetme.c.

Referenced by load_module(), and unload_module().

app3

const char* const app3 = "MeetMeAdmin"

static

Definition at line 868 of file app_meetme.c.

Referenced by load_module(), and unload_module().

app4

const char* const app4 = "MeetMeChannelAdmin"

static

Definition at line 869 of file app_meetme.c.

Referenced by load_module(), and unload_module().

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 5620 of file app_meetme.c.

audio_buffers

int audio_buffers

static

The number of audio buffers to be allocated on pseudo channels when in a conference.

Definition at line 982 of file app_meetme.c.

Referenced by conf_run(), load_config_meetme(), and meetme_set_defaults().

cli_meetme

struct ast_cli_entry cli_meetme[]

static

Definition at line 1991 of file app_meetme.c.

                                           {
    AST_CLI_DEFINE(meetme_kick_cmd, "Kick a conference or a user in a conference."),
    AST_CLI_DEFINE(meetme_show_cmd, "List all conferences or a specific conference."),
    AST_CLI_DEFINE(meetme_lock_cmd, "Lock or unlock a conference to new users."),
    AST_CLI_DEFINE(meetme_mute_cmd, "Mute or unmute a conference or a user in a conference."),
};

Referenced by load_module(), and unload_module().

conf_map

unsigned int conf_map[1024] = {0, }

static

Definition at line 950 of file app_meetme.c.

{0, };

Referenced by build_conf(), conf_exec(), and dispose_conf().

confs

struct confs confs = AST_LIST_HEAD_INIT_VALUE

static

earlyalert

int earlyalert

static

Definition at line 874 of file app_meetme.c.

Referenced by find_conf_realtime(), load_config_meetme(), and meetme_set_defaults().

endalert

int endalert

static

Definition at line 875 of file app_meetme.c.

Referenced by find_conf_realtime(), load_config_meetme(), and meetme_set_defaults().

extendby

int extendby

static

Definition at line 876 of file app_meetme.c.

Referenced by load_config_meetme(), meetme_set_defaults(), and rt_extend_conf().

fuzzystart

int fuzzystart

static

Definition at line 873 of file app_meetme.c.

Referenced by find_conf_realtime(), load_config_meetme(), and meetme_set_defaults().

gain_map

const char gain_map[]

static

Map 'volume' levels from -5 through +5 into decibel (dB) settings for channel drivers.

Note

these are not a straight linear-to-dB conversion... the numbers have been modified to give the user a better level of adjustability.

Definition at line 991 of file app_meetme.c.

                               {
    -15,
    -13,
    -10,
    -6,
    0,
    0,
    0,
    6,
    10,
    13,
    15,
};

Referenced by set_listen_volume(), and set_talk_volume().

meetme_event_message_router

struct stasis_message_router* meetme_event_message_router

static

Definition at line 1006 of file app_meetme.c.

Referenced by meetme_stasis_cleanup(), and meetme_stasis_init().

meetme_info_acf

struct ast_custom_function meetme_info_acf

static

Initial value:

= {
    .name = "MEETME_INFO",
    .read = acf_meetme_info,
}

Definition at line 5536 of file app_meetme.c.

                                                    {
    .name = "MEETME_INFO",
    .read = acf_meetme_info,
};

Referenced by load_module(), and unload_module().

meetme_opts

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 = CONFFLAG_INTROMSG , .arg_index = OPT_ARG_INTROMSG + 1 }, [ 'v' ] = { .flag = CONFFLAG_INTROUSER_VMREC , .arg_index = OPT_ARG_INTROUSER_VMREC + 1 }, [ 'i' ] = { .flag = CONFFLAG_INTROUSER }, [ 'I' ] = { .flag = CONFFLAG_INTROUSERNOREVIEW }, [ 'k' ] = { .flag = CONFFLAG_KILL_LAST_MAN_STANDING }, [ 'M' ] = { .flag = CONFFLAG_MOH , .arg_index = OPT_ARG_MOH_CLASS + 1 }, [ 'm' ] = { .flag = CONFFLAG_STARTMUTED }, [ 'n' ] = { .flag = CONFFLAG_DONT_DENOISE }, [ '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

Definition at line 864 of file app_meetme.c.

Referenced by conf_exec(), and find_conf_realtime().

rt_log_members

int rt_log_members

static

Log participant count to the RealTime backend

Definition at line 879 of file app_meetme.c.

Referenced by conf_run(), load_config_meetme(), and meetme_set_defaults().

rt_schedule

int rt_schedule

static

Definition at line 872 of file app_meetme.c.

Referenced by conf_exec(), conf_run(), find_conf_realtime(), load_config_meetme(), meetme_menu_admin(), meetme_menu_normal(), and meetme_set_defaults().