AMI functions

Data Structures
struct	actions
	list of actions registered More...
struct	all_events
struct	ast_manager_user
	user descriptor, as read from the config file. More...
struct	event_filter_entry
struct	eventqent
struct	fast_originate_helper
	helper function for originate More...
struct	manager_hooks
	list of hooks registered More...
struct	mansession
	In case you didn't read that giant block of text above the mansession_session struct, the mansession is named this solely to keep the API the same in Asterisk. This structure really represents data that is different from Manager action to Manager action. The mansession_session pointer contained within points to session-specific data. More...
struct	mansession_session
struct	originate_permissions_entry
struct	permalias
struct	users
	list of users found in the config file More...

Macros
#define	any_manager_listeners(sessions)    ((sessions && ao2_container_count(sessions)) || !AST_RWLIST_EMPTY(&manager_hooks))
#define	ASTMAN_APPEND_BUF_INITSIZE   256
	initial allocated size for the astman_append_buf and astman_send_*_va More...
#define	DEFAULT_REALM   "asterisk"
#define	EVENT_FLAG_SHUTDOWN   -1
	Fake event class used to end sessions at shutdown. More...
#define	GET_HEADER_FIRST_MATCH   0
#define	GET_HEADER_LAST_MATCH   1
#define	GET_HEADER_SKIP_EMPTY   2
#define	MANAGER_EVENT_BUF_INITSIZE   256
#define	manager_event_sessions(sessions, category, event, contents, ...)    __manager_event_sessions(sessions, category, event, 0, NULL, __FILE__, __LINE__, __PRETTY_FUNCTION__, contents , ## __VA_ARGS__)
#define	MAX_AUTH_PERM_STRING   150
#define	MAX_BLACKLIST_CMD_LEN   2
	Descriptor for a manager session, either on the AMI socket or over HTTP. More...
#define	MAX_VARS   128
#define	MGR_SHOW_TERMINAL_WIDTH   80
#define	MSG_MOREDATA   ((char *)astman_send_response)

Enumerations
enum	add_filter_result { FILTER_SUCCESS = 0 , FILTER_ALLOC_FAILED , FILTER_COMPILE_FAIL , FILTER_FORMAT_ERROR }
enum	error_type {   UNKNOWN_ACTION = 1 , UNKNOWN_CATEGORY , UNSPECIFIED_CATEGORY , UNSPECIFIED_ARGUMENT ,   FAILURE_ALLOCATION , FAILURE_NEWCAT , FAILURE_DELCAT , FAILURE_EMPTYCAT ,   FAILURE_UPDATE , FAILURE_DELETE , FAILURE_APPEND , FAILURE_TEMPLATE }
enum	event_filter_match_type {   FILTER_MATCH_REGEX = 0 , FILTER_MATCH_EXACT , FILTER_MATCH_STARTS_WITH , FILTER_MATCH_ENDS_WITH ,   FILTER_MATCH_CONTAINS , FILTER_MATCH_NONE }
enum	mansession_message_parsing { MESSAGE_OKAY , MESSAGE_LINE_TOO_LONG }

Functions
int	__ast_manager_event_multichan (int category, const char *event, int chancount, struct ast_channel **chans, const char *file, int line, const char *func, const char *fmt,...)
static const char *	__astman_get_header (const struct message *m, char *var, int mode)
	Return a matching header value. More...
static void	__init_astman_append_buf (void)
	thread local buffer for astman_append More...
static void	__init_manager_event_buf (void)
static void	__init_userevent_buf (void)
static int	__manager_event_sessions (struct ao2_container *sessions, int category, const char *event, int chancount, struct ast_channel **chans, const char *file, int line, const char *func, const char *fmt,...)
static int	__manager_event_sessions_va (struct ao2_container *sessions, int category, const char *event, int chancount, struct ast_channel **chans, const char *file, int line, const char *func, const char *fmt, va_list ap)
static void	acl_change_stasis_cb (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void	acl_change_stasis_subscribe (void)
static void	acl_change_stasis_unsubscribe (void)
static struct ast_aoc_decoded *	action_aoc_de_message (struct mansession *s, const struct message *m)
static struct ast_aoc_decoded *	action_aoc_s_message (struct mansession *s, const struct message *m)
static int	action_aoc_s_submessage (struct mansession *s, const struct message *m, struct ast_aoc_decoded *decoded)
static int	action_aocmessage (struct mansession *s, const struct message *m)
static int	action_atxfer (struct mansession *s, const struct message *m)
static int	action_blind_transfer (struct mansession *s, const struct message *m)
static int	action_cancel_atxfer (struct mansession *s, const struct message *m)
static int	action_challenge (struct mansession *s, const struct message *m)
static int	action_command (struct mansession *s, const struct message *m)
	Manager command "command" - execute CLI command. More...
static int	action_coresettings (struct mansession *s, const struct message *m)
	Show PBX core settings information. More...
static int	action_coreshowchannelmap (struct mansession *s, const struct message *m)
	Manager command "CoreShowChannelMap" - Lists all channels connected to the specified channel. More...
static int	action_coreshowchannels (struct mansession *s, const struct message *m)
	Manager command "CoreShowChannels" - List currently defined channels and some information about them. More...
static int	action_corestatus (struct mansession *s, const struct message *m)
	Show PBX core status information. More...
static int	action_createconfig (struct mansession *s, const struct message *m)
static void	action_destroy (void *obj)
static int	action_events (struct mansession *s, const struct message *m)
static int	action_extensionstate (struct mansession *s, const struct message *m)
static int	action_filter (struct mansession *s, const struct message *m)
	Manager command to add an event filter to a manager session. More...
static struct manager_action *	action_find (const char *name)
static int	action_getconfig (struct mansession *s, const struct message *m)
static int	action_getconfigjson (struct mansession *s, const struct message *m)
static int	action_getvar (struct mansession *s, const struct message *m)
static int	action_hangup (struct mansession *s, const struct message *m)
static int	action_listcategories (struct mansession *s, const struct message *m)
static int	action_listcommands (struct mansession *s, const struct message *m)
static int	action_loggerrotate (struct mansession *s, const struct message *m)
	Manager command "LoggerRotate" - reloads and rotates the logger in the same manner as the CLI command 'logger rotate'. More...
static int	action_login (struct mansession *s, const struct message *m)
static int	action_logoff (struct mansession *s, const struct message *m)
static int	action_mailboxcount (struct mansession *s, const struct message *m)
static int	action_mailboxstatus (struct mansession *s, const struct message *m)
static int	action_originate (struct mansession *s, const struct message *m)
static int	action_ping (struct mansession *s, const struct message *m)
static int	action_presencestate (struct mansession *s, const struct message *m)
static int	action_redirect (struct mansession *s, const struct message *m)
	action_redirect: The redirect manager command More...
static int	action_reload (struct mansession *s, const struct message *m)
	Send a reload event. More...
static int	action_sendtext (struct mansession *s, const struct message *m)
static int	action_setvar (struct mansession *s, const struct message *m)
static int	action_status (struct mansession *s, const struct message *m)
	Manager "status" command to show channels. More...
static int	action_timeout (struct mansession *s, const struct message *m)
static int	action_updateconfig (struct mansession *s, const struct message *m)
static int	action_userevent (struct mansession *s, const struct message *m)
static int	action_waitevent (struct mansession *s, const struct message *m)
static struct eventqent *	advance_event (struct eventqent *e)
static	AO2_GLOBAL_OBJ_STATIC (event_docs)
	A container of event documentation nodes. More...
static	AO2_GLOBAL_OBJ_STATIC (mgr_sessions)
static int	aocmessage_get_unit_entry (const struct message *m, struct ast_aoc_unit_entry *entry, unsigned int entry_num)
static int	app_match (const char *app, const char *data, const char *search)
static int	appdata_match (const char *app, const char *data, const char *search)
static void	append_channel_vars (struct ast_str **pbuf, struct ast_channel *chan)
static int	append_event (const char *str, int event_name_hash, int category)
	events are appended to a queue from where they can be dispatched to clients. More...
int	ast_hook_send_action (struct manager_custom_hook *hook, const char *msg)
	access for hooks to send action messages to ami More...
static int	ast_instring (const char *bigstr, const char *smallstr, const char delim)
int	ast_manager_check_enabled (void)
	Check if AMI is enabled. More...
struct stasis_message_router *	ast_manager_get_message_router (void)
	Get the stasis_message_router for AMI. More...
struct stasis_topic *	ast_manager_get_topic (void)
	Get the Stasis Message Bus API topic for AMI. More...
int	ast_manager_hangup_helper (struct mansession *s, const struct message *m, manager_hangup_handler_t hangup_handler, manager_hangup_cause_validator_t cause_validator)
	A manager helper function that hangs up a channel using a supplied channel type specific hangup function and cause code validator. More...
void	ast_manager_publish_event (const char *type, int class_type, struct ast_json *obj)
	Publish an event to AMI. More...
int	ast_manager_register2 (const char *action, int auth, int(*func)(struct mansession *s, const struct message *m), struct ast_module *module, const char *synopsis, const char *description)
	register a new command with manager, including online help. This is the preferred way to register a manager command More...
void	ast_manager_register_hook (struct manager_custom_hook *hook)
	Add a custom hook to be called when an event is fired. More...
static int	ast_manager_register_struct (struct manager_action *act)
struct ast_str *	ast_manager_str_from_json_object (struct ast_json *blob, key_exclusion_cb exclusion_cb)
	Convert a JSON object into an AMI compatible string. More...
int	ast_manager_unregister (const char *action)
	support functions to register/unregister AMI action handlers, More...
void	ast_manager_unregister_hook (struct manager_custom_hook *hook)
	Delete a custom hook to be called when an event is fired. More...
int	ast_webmanager_check_enabled (void)
	Check if AMI/HTTP is enabled. More...
void	astman_append (struct mansession *s, const char *fmt,...)
static void	astman_append_headers (struct message *m, const struct ast_variable *params)
	Append additional headers into the message structure from params. More...
static void	astman_append_json (struct mansession *s, const char *str)
static void	astman_flush (struct mansession *s, struct ast_str *buf)
static void	astman_free_headers (struct message *m)
	Free headers inside message structure, but not the message structure itself. More...
const char *	astman_get_header (const struct message *m, char *var)
	Return the first matching variable from an array. More...
struct ast_variable *	astman_get_variables (const struct message *m)
	Get a linked list of the Variable: headers. More...
struct ast_variable *	astman_get_variables_order (const struct message *m, enum variable_orders order)
	Get a linked list of the Variable: headers with order specified. More...
void	astman_live_dangerously (int new_live_dangerously)
	Enable/disable the inclusion of 'dangerous' configurations outside of the ast_config_AST_CONFIG_DIR. More...
void	astman_send_ack (struct mansession *s, const struct message *m, char *msg)
	Send ack in manager transaction. More...
void	astman_send_error (struct mansession *s, const struct message *m, char *error)
	Send error in manager transaction. More...
void	astman_send_error_va (struct mansession *s, const struct message *m, const char *fmt,...)
	Send error in manager transaction (with va_args support) More...
static void	astman_send_list_complete (struct mansession *s, const struct message *m, const char *event_name, int count)
void	astman_send_list_complete_end (struct mansession *s)
	End the list complete event. More...
void	astman_send_list_complete_start (struct mansession *s, const struct message *m, const char *event_name, int count)
	Start the list complete event. More...
static struct ast_str *	astman_send_list_complete_start_common (struct mansession *s, const struct message *m, const char *event_name, int count)
void	astman_send_listack (struct mansession *s, const struct message *m, char *msg, char *listflag)
	Send ack in manager transaction to begin a list. More...
void	astman_send_response (struct mansession *s, const struct message *m, char *resp, char *msg)
	Send response in manager transaction. More...
static void	astman_send_response_full (struct mansession *s, const struct message *m, char *resp, char *msg, char *listflag)
	send a response with an optional message, and terminate it with an empty line. m is used only to grab the 'ActionID' field. More...
static void	astman_start_ack (struct mansession *s, const struct message *m)
static int	async_goto_with_discard_bridge_after (struct ast_channel *chan, const char *context, const char *exten, int priority)
static int	authenticate (struct mansession *s, const struct message *m)
static const char *	authority_to_str (int authority, struct ast_str **res)
	Convert authority code to a list of options. Note that the EVENT_FLAG_ALL authority will always be returned. More...
static struct mansession_session *	build_mansession (const struct ast_sockaddr *addr)
	Allocate manager session structure and add it to the list of sessions. More...
static int	check_blacklist (const char *cmd)
static int	check_manager_session_inuse (const char *name)
static int	coreshowchannelmap_add_connected_channels (struct ao2_container *channel_map, struct ast_channel_snapshot *channel_snapshot, struct ast_bridge_snapshot *bridge_snapshot)
	Recursive function to get all channels in a bridge. Follow local channels as well. More...
static int	coreshowchannelmap_add_to_map (struct ao2_container *c, const char *s)
	Helper function to add a channel name to the vector. More...
static void	destroy_fast_originate_helper (struct fast_originate_helper *doomed)
static int	do_message (struct mansession *s)
static void	event_filter_destructor (void *obj)
static void *	fast_originate (void *data)
static int	file_in_modules_dir (const char *filename)
	Check if the given file path is in the modules dir or not. More...
static int	filter_cmp_fn (void *obj, void *arg, void *data, int flags)
static int	function_capable_string_allowed_with_auths (const char *evaluating, int writepermlist)
	Checks to see if a string which can be used to evaluate functions should be rejected. More...
static void	generate_status (struct mansession *s, struct ast_channel *chan, char **vars, int varc, int all_variables, char *id_text, int *count)
static int	get_input (struct mansession *s, char *output)
static struct ast_manager_user *	get_manager_by_name_locked (const char *name)
static int	get_perm (const char *instr)
static struct eventqent *	grab_last (void)
static char *	handle_kickmanconn (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command manager kick session. More...
static char *	handle_manager_reload (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command manager reload. More...
static char *	handle_mandebug (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void	handle_parse_error (struct mansession *s, struct message *m, char *error)
static char *	handle_showmanager (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_showmanagers (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_showmancmd (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_showmancmds (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command manager list commands. More...
static char *	handle_showmanconn (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command manager list connected. More...
static char *	handle_showmaneventq (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command manager list eventq. More...
static enum error_type	handle_updates (struct mansession *s, const struct message *m, struct ast_config *cfg, const char *dfn)
	helper function for action_updateconfig More...
static int	is_originate_app_permitted (const char *app, const char *data, int permission)
static int	is_restricted_file (const char *filename)
	Check if a file is restricted or not. More...
static void	json_escape (char *out, const char *in)
static void	log_action (const struct message *m, const char *action)
static struct ast_variable *	man_do_variable_value (struct ast_variable *head, const char *hdr_val)
static enum add_filter_result	manager_add_filter (const char *criteria, const char *filter_pattern, struct ao2_container *includefilters, struct ao2_container *excludefilters)
	Add an event filter to a manager session. More...
static void	manager_default_msg_cb (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static int	manager_displayconnects (struct mansession_session *session)
	Get displayconnects config option. More...
static void	manager_generic_msg_cb (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void	manager_json_array_with_key (struct ast_json *obj, const char *key, size_t index, struct ast_str **res, key_exclusion_cb exclusion_cb)
static void	manager_json_obj_with_key (struct ast_json *obj, const char *key, const char *parent_key, struct ast_str **res, key_exclusion_cb exclusion_cb)
static void	manager_json_to_ast_str (struct ast_json *obj, const char *key, struct ast_str **res, key_exclusion_cb exclusion_cb)
static void	manager_json_value_str_append (struct ast_json *value, const char *key, struct ast_str **res)
static int	manager_modulecheck (struct mansession *s, const struct message *m)
	Manager function to check if module is loaded. More...
static int	manager_moduleload (struct mansession *s, const struct message *m)
static int	manager_state_cb (const char *context, const char *exten, struct ast_state_cb_info *info, void *data)
static int	mansession_cmp_fn (void *obj, void *arg, int flags)
static enum ast_transport	mansession_get_transport (const struct mansession *s)
static void	mansession_lock (struct mansession *s)
	Lock the 'mansession' structure. More...
static void	mansession_unlock (struct mansession *s)
	Unlock the 'mansession' structure. More...
static int	match_eventdata (struct event_filter_entry *entry, const char *eventdata)
	Test eventdata against a filter entry. More...
static void	print_event_instance (struct ast_cli_args *a, struct ast_xml_doc_item *instance)
static int	process_events (struct mansession *s)
static int	process_message (struct mansession *s, const struct message *m)
	Process an AMI message, performing desired action. Return 0 on success, -1 on error that require the session to be destroyed. More...
static void	purge_events (void)
static int	purge_sessions (int n_max)
	remove at most n_max stale session from the list. More...
static int	queue_match (const char *app, const char *data, const char *search)
static int	queue_read_action_payload (struct ast_channel *chan, const unsigned char *payload, size_t payload_size, enum ast_frame_read_action action)
	Queue a given read action containing a payload onto a channel. More...
static int	queue_sendtext (struct ast_channel *chan, const char *body)
	Queue a read action to send a text message. More...
static int	queue_sendtext_data (struct ast_channel *chan, const char *body, const char *content_type)
	Queue a read action to send a text data message. More...
static int	reload_module (void)
static void	report_auth_success (const struct mansession *s)
static void	report_failed_acl (const struct mansession *s, const char *username)
static void	report_failed_challenge_response (const struct mansession *s, const char *response, const char *expected_response)
static void	report_inval_password (const struct mansession *s, const char *username)
static void	report_invalid_user (const struct mansession *s, const char *username)
static void	report_req_bad_format (const struct mansession *s, const char *action)
static void	report_req_not_allowed (const struct mansession *s, const char *action)
static void	report_session_limit (const struct mansession *s)
static int	send_string (struct mansession *s, char *string)
static void	session_destroy (struct mansession_session *s)
static void	session_destructor (void *obj)
static void *	session_do (void *data)
	The body of the individual manager session. Call get_input() to read one line at a time (or be woken up on new events), collect the lines in a message until found an empty line, and execute the request. In any case, deliver events asynchronously through process_events() (called from here if no line is available, or at the end of process_message(). ) More...
static int	set_eventmask (struct mansession *s, const char *eventmask)
	Rather than braindead on,off this now can also accept a specific int mask value or a ',' delim list of mask strings (the same as manager.conf) -anthm. More...
static int	should_send_event (struct ao2_container *includefilters, struct ao2_container *excludefilters, struct eventqent *eqe)
static int	strings_to_mask (const char *string)
static struct mansession_session *	unref_mansession (struct mansession_session *s)
	Unreference manager session object. If no more references, then go ahead and delete it. More...
static const char *	user_authority_to_str (int authority, struct ast_str **res)
	Convert authority code to a list of options for a user. This will only display those authority codes that have an explicit match on authority. More...

Variables
static struct stasis_subscription *	acl_change_sub
static struct actions	actions = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
static struct all_events	all_events = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
static int	allowmultiplelogin = 1
static struct ast_threadstorage	astman_append_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_astman_append_buf , .custom_init = NULL , }
static int	authlimit
static int	authtimeout
static int	broken_events_action = 0
struct {
const char *   words [AST_MAX_CMD_LEN]
}	command_blacklist []
static int	displayconnects = 1
static char	global_realm [MAXHOSTNAMELEN]
static int	httptimeout = 60
static int	live_dangerously
	Set to true (non-zero) to globally allow all dangerous AMI actions to run. More...
static char *	manager_channelvars
static int	manager_debug = 0
static char *	manager_disabledevents
static int	manager_enabled = 0
static struct ast_threadstorage	manager_event_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_manager_event_buf , .custom_init = NULL , }
static struct manager_hooks	manager_hooks = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
static struct stasis_topic *	manager_topic
	A stasis_topic that all topics AMI cares about will be forwarded to. More...
static char *	match_type_names []
static struct originate_permissions_entry	originate_app_permissions []
static const struct permalias	perms []
static struct stasis_forward *	rtp_topic_forwarder
	The stasis_subscription for forwarding the RTP topic to the AMI topic. More...
static struct stasis_forward *	security_topic_forwarder
	The stasis_subscription for forwarding the Security topic to the AMI topic. More...
static struct stasis_message_router *	stasis_router
	The stasis_message_router for all Stasis Message Bus API messages. More...
static int	subscribed = 0
static int	timestampevents
static int	unauth_sessions = 0
static struct ast_threadstorage	userevent_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_userevent_buf , .custom_init = NULL , }
static struct users	users = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
static int	webmanager_enabled = 0
	STASIS_MESSAGE_TYPE_DEFN (ast_manager_get_generic_type)
	Define AMI message types. More...

Detailed Description

Macro Definition Documentation

any_manager_listeners

#define any_manager_listeners

(

sessions

)

((sessions && ao2_container_count(sessions)) || !AST_RWLIST_EMPTY(&manager_hooks))

Definition at line 569 of file manager.c.

ASTMAN_APPEND_BUF_INITSIZE

#define ASTMAN_APPEND_BUF_INITSIZE   256

initial allocated size for the astman_append_buf and astman_send_*_va

Definition at line 1893 of file manager.c.

DEFAULT_REALM

#define DEFAULT_REALM   "asterisk"

Definition at line 179 of file manager.c.

EVENT_FLAG_SHUTDOWN

#define EVENT_FLAG_SHUTDOWN   -1

Fake event class used to end sessions at shutdown.

Definition at line 212 of file manager.c.

GET_HEADER_FIRST_MATCH

#define GET_HEADER_FIRST_MATCH   0

Definition at line 1593 of file manager.c.

GET_HEADER_LAST_MATCH

#define GET_HEADER_LAST_MATCH   1

Definition at line 1594 of file manager.c.

GET_HEADER_SKIP_EMPTY

#define GET_HEADER_SKIP_EMPTY   2

Definition at line 1595 of file manager.c.

MANAGER_EVENT_BUF_INITSIZE

#define MANAGER_EVENT_BUF_INITSIZE   256

Definition at line 7538 of file manager.c.

manager_event_sessions

#define manager_event_sessions	(		sessions,
			category,
			event,
			contents,
			...
	)		__manager_event_sessions(sessions, category, event, 0, NULL, __FILE__, __LINE__, __PRETTY_FUNCTION__, contents , ## __VA_ARGS__)

Definition at line 566 of file manager.c.

MAX_AUTH_PERM_STRING

#define MAX_AUTH_PERM_STRING   150

Maximum string length of the AMI authority permission string buildable from perms[].

Definition at line 778 of file manager.c.

MAX_BLACKLIST_CMD_LEN

#define MAX_BLACKLIST_CMD_LEN   2

Descriptor for a manager session, either on the AMI socket or over HTTP.

Note

AMI session have managerid == 0; the entry is created upon a connect, and destroyed with the socket. HTTP sessions have managerid != 0, the value is used as a search key to lookup sessions (using the mansession_id cookie, or nonce key from Digest Authentication http header).

Definition at line 224 of file manager.c.

MAX_VARS

#define MAX_VARS   128

Definition at line 209 of file manager.c.

MGR_SHOW_TERMINAL_WIDTH

#define MGR_SHOW_TERMINAL_WIDTH   80

Definition at line 207 of file manager.c.

MSG_MOREDATA

#define MSG_MOREDATA   ((char *)astman_send_response)

Note

NOTE: XXX this comment is unclear and possibly wrong. Callers of astman_send_error(), astman_send_response() or astman_send_ack() must EITHER hold the session lock or be running in an action callback (in which case s->session->busy will be non-zero). In either of these cases, there is no need to lock-protect the session's fd, since no other output will be sent (events will be queued), and no input will be read until either the current action finishes or get_input() obtains the session lock.

Todo:

XXX MSG_MOREDATA should go to a header file.

Definition at line 1941 of file manager.c.

Enumeration Type Documentation

add_filter_result

enum add_filter_result

Enumerator
FILTER_SUCCESS
FILTER_ALLOC_FAILED
FILTER_COMPILE_FAIL
FILTER_FORMAT_ERROR

Definition at line 127 of file manager.c.

                       {
    FILTER_SUCCESS = 0,
    FILTER_ALLOC_FAILED,
    FILTER_COMPILE_FAIL,
    FILTER_FORMAT_ERROR,
};

error_type

enum error_type

Doxygen group

Enumerator
UNKNOWN_ACTION
UNKNOWN_CATEGORY
UNSPECIFIED_CATEGORY
UNSPECIFIED_ARGUMENT
FAILURE_ALLOCATION
FAILURE_NEWCAT
FAILURE_DELCAT
FAILURE_EMPTYCAT
FAILURE_UPDATE
FAILURE_DELETE
FAILURE_APPEND
FAILURE_TEMPLATE

Definition at line 112 of file manager.c.

                {
    UNKNOWN_ACTION = 1,
    UNKNOWN_CATEGORY,
    UNSPECIFIED_CATEGORY,
    UNSPECIFIED_ARGUMENT,
    FAILURE_ALLOCATION,
    FAILURE_NEWCAT,
    FAILURE_DELCAT,
    FAILURE_EMPTYCAT,
    FAILURE_UPDATE,
    FAILURE_DELETE,
    FAILURE_APPEND,
    FAILURE_TEMPLATE
};

event_filter_match_type

enum event_filter_match_type

Enumerator
FILTER_MATCH_REGEX
FILTER_MATCH_EXACT
FILTER_MATCH_STARTS_WITH
FILTER_MATCH_ENDS_WITH
FILTER_MATCH_CONTAINS
FILTER_MATCH_NONE

Definition at line 389 of file manager.c.

                             {
    FILTER_MATCH_REGEX = 0,
    FILTER_MATCH_EXACT,
    FILTER_MATCH_STARTS_WITH,
    FILTER_MATCH_ENDS_WITH,
    FILTER_MATCH_CONTAINS,
    FILTER_MATCH_NONE,
};

mansession_message_parsing

enum mansession_message_parsing

Enumerator
MESSAGE_OKAY
MESSAGE_LINE_TOO_LONG

Definition at line 317 of file manager.c.

                                {
    MESSAGE_OKAY,
    MESSAGE_LINE_TOO_LONG
};

Function Documentation

__ast_manager_event_multichan()

int __ast_manager_event_multichan	(	int	category,
		const char *	event,
		int	chancount,
		struct ast_channel **	chans,
		const char *	file,
		int	line,
		const char *	func,
		const char *	contents,
			...
	)

External routines may send asterisk manager events this way

Parameters

category	Event category, matches manager authorization
event	Event name
chancount	Number of channels in chans parameter
chans	A pointer to an array of channels involved in the event
file,line,func
contents	Format string describing event
...

Since

1.8

Definition at line 7672 of file manager.c.

{
    struct ao2_container *sessions = ao2_global_obj_ref(mgr_sessions);
    va_list ap;
    int res;
 
    if (!any_manager_listeners(sessions)) {
        /* Nobody is listening */
        ao2_cleanup(sessions);
        return 0;
    }
 
    va_start(ap, fmt);
    res = __manager_event_sessions_va(sessions, category, event, chancount, chans,
        file, line, func, fmt, ap);
    va_end(ap);
    ao2_cleanup(sessions);
    return res;
}

References __manager_event_sessions_va(), any_manager_listeners, ao2_cleanup, ao2_global_obj_ref, chancount, make_ari_stubs::file, and sessions.

__astman_get_header()

static const char * __astman_get_header ( const struct message *  m, char *  var, int  mode  )

static

Return a matching header value.

Generic function to return either the first or the last matching header from a list of variables, possibly skipping empty strings.

Note

At the moment there is only one use of this function in this file, so we make it static.

Never returns NULL.

Definition at line 1610 of file manager.c.

{
    int x, l = strlen(var);
    const char *result = "";
 
    if (!m) {
        return result;
    }
 
    for (x = 0; x < m->hdrcount; x++) {
        const char *h = m->headers[x];
        if (!strncasecmp(var, h, l) && h[l] == ':') {
            const char *value = h + l + 1;
            value = ast_skip_blanks(value); /* ignore leading spaces in the value */
            /* found a potential candidate */
            if ((mode & GET_HEADER_SKIP_EMPTY) && ast_strlen_zero(value)) {
                continue;   /* not interesting */
            }
            if (mode & GET_HEADER_LAST_MATCH) {
                result = value; /* record the last match so far */
            } else {
                return value;
            }
        }
    }
 
    return result;
}

References ast_skip_blanks(), ast_strlen_zero(), GET_HEADER_LAST_MATCH, GET_HEADER_SKIP_EMPTY, message::hdrcount, message::headers, result, value, and var.

Referenced by action_aoc_s_submessage(), astman_get_header(), and process_message().

__init_astman_append_buf()

static void __init_astman_append_buf ( void  )

static

thread local buffer for astman_append

Note

This can not be defined within the astman_append() function because it declares a couple of functions that get used to initialize the thread local storage key.

Definition at line 1888 of file manager.c.

{

__init_manager_event_buf()

static void __init_manager_event_buf ( void  )

static

Definition at line 7537 of file manager.c.

{

__init_userevent_buf()

static void __init_userevent_buf ( void  )

static

Definition at line 1890 of file manager.c.

{

__manager_event_sessions()

static int __manager_event_sessions ( struct ao2_container *  sessions, int  category, const char *  event, int  chancount, struct ast_channel **  chans, const char *  file, int  line, const char *  func, const char *  fmt,   ...  )

static

Definition at line 7650 of file manager.c.

{
    va_list ap;
    int res;
 
    va_start(ap, fmt);
    res = __manager_event_sessions_va(sessions, category, event,
        chancount, chans, file, line, func, fmt, ap);
    va_end(ap);
    return res;
}

References __manager_event_sessions_va(), chancount, make_ari_stubs::file, and sessions.

__manager_event_sessions_va()

static int __manager_event_sessions_va ( struct ao2_container *  sessions, int  category, const char *  event, int  chancount, struct ast_channel **  chans, const char *  file, int  line, const char *  func, const char *  fmt, va_list  ap  )

static

Definition at line 7540 of file manager.c.

{
    struct ast_str *auth = ast_str_alloca(MAX_AUTH_PERM_STRING);
    const char *cat_str;
    struct timeval now;
    struct ast_str *buf;
    int i;
    int event_name_hash;
 
    if (!ast_strlen_zero(manager_disabledevents)) {
        if (ast_in_delimited_string(event, manager_disabledevents, ',')) {
            ast_debug(3, "AMI Event '%s' is globally disabled, skipping\n", event);
            /* Event is globally disabled */
            return -1;
        }
    }
 
    buf = ast_str_thread_get(&manager_event_buf, MANAGER_EVENT_BUF_INITSIZE);
    if (!buf) {
        return -1;
    }
 
    cat_str = authority_to_str(category, &auth);
    ast_str_set(&buf, 0,
        "Event: %s\r\n"
        "Privilege: %s\r\n",
        event, cat_str);
 
    if (timestampevents) {
        now = ast_tvnow();
        ast_str_append(&buf, 0,
            "Timestamp: %ld.%06lu\r\n",
            (long)now.tv_sec, (unsigned long) now.tv_usec);
    }
    if (manager_debug) {
        static int seq;
 
        ast_str_append(&buf, 0,
            "SequenceNumber: %d\r\n",
            ast_atomic_fetchadd_int(&seq, 1));
        ast_str_append(&buf, 0,
            "File: %s\r\n"
            "Line: %d\r\n"
            "Func: %s\r\n",
            file, line, func);
    }
    if (!ast_strlen_zero(ast_config_AST_SYSTEM_NAME)) {
        ast_str_append(&buf, 0,
            "SystemName: %s\r\n",
            ast_config_AST_SYSTEM_NAME);
    }
 
    ast_str_append_va(&buf, 0, fmt, ap);
    for (i = 0; i < chancount; i++) {
        append_channel_vars(&buf, chans[i]);
    }
 
    ast_str_append(&buf, 0, "\r\n");
 
    event_name_hash = ast_str_hash(event);
 
    append_event(ast_str_buffer(buf), event_name_hash, category);
 
    /* Wake up any sleeping sessions */
    if (sessions) {
        struct ao2_iterator iter;
        struct mansession_session *session;
 
        iter = ao2_iterator_init(sessions, 0);
        while ((session = ao2_iterator_next(&iter))) {
            ast_mutex_lock(&session->notify_lock);
            if (session->waiting_thread != AST_PTHREADT_NULL) {
                pthread_kill(session->waiting_thread, SIGURG);
            } else {
                /* We have an event to process, but the mansession is
                 * not waiting for it. We still need to indicate that there
                 * is an event waiting so that get_input processes the pending
                 * event instead of polling.
                 */
                session->pending_event = 1;
            }
            ast_mutex_unlock(&session->notify_lock);
            unref_mansession(session);
        }
        ao2_iterator_destroy(&iter);
    }
 
    if (category != EVENT_FLAG_SHUTDOWN && !AST_RWLIST_EMPTY(&manager_hooks)) {
        struct manager_custom_hook *hook;
 
        AST_RWLIST_RDLOCK(&manager_hooks);
        AST_RWLIST_TRAVERSE(&manager_hooks, hook, list) {
            hook->helper(category, event, ast_str_buffer(buf));
        }
        AST_RWLIST_UNLOCK(&manager_hooks);
    }
 
    return 0;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, append_channel_vars(), append_event(), ast_atomic_fetchadd_int(), ast_config_AST_SYSTEM_NAME, ast_debug, ast_in_delimited_string(), ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, AST_RWLIST_EMPTY, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_str_alloca, ast_str_append(), ast_str_append_va(), ast_str_buffer(), ast_str_hash(), ast_str_set(), ast_str_thread_get(), ast_strlen_zero(), ast_tvnow(), authority_to_str(), buf, chancount, EVENT_FLAG_SHUTDOWN, make_ari_stubs::file, manager_custom_hook::helper, manager_debug, manager_disabledevents, manager_event_buf, MANAGER_EVENT_BUF_INITSIZE, MAX_AUTH_PERM_STRING, seq, session, sessions, timestampevents, and unref_mansession().

Referenced by __ast_manager_event_multichan(), and __manager_event_sessions().

acl_change_stasis_cb()

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

static

Definition at line 10141 of file manager.c.

{
    if (stasis_message_type(message) != ast_named_acl_change_type()) {
        return;
    }
 
    /* For now, this is going to be performed simply and just execute a forced reload. */
    ast_log(LOG_NOTICE, "Reloading manager in response to ACL change event.\n");
    __init_manager(1, 1);
}

References __init_manager(), ast_log, ast_named_acl_change_type(), LOG_NOTICE, and stasis_message_type().

Referenced by acl_change_stasis_subscribe().

acl_change_stasis_subscribe()

static void acl_change_stasis_subscribe ( void  )

static

Definition at line 235 of file manager.c.

{
    if (!acl_change_sub) {
        acl_change_sub = stasis_subscribe(ast_security_topic(),
            acl_change_stasis_cb, NULL);
        stasis_subscription_accept_message_type(acl_change_sub, ast_named_acl_change_type());
        stasis_subscription_set_filter(acl_change_sub, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
    }
}

References acl_change_stasis_cb(), acl_change_sub, ast_named_acl_change_type(), ast_security_topic(), NULL, stasis_subscribe, stasis_subscription_accept_message_type(), STASIS_SUBSCRIPTION_FILTER_SELECTIVE, and stasis_subscription_set_filter().

Referenced by __init_manager().

acl_change_stasis_unsubscribe()

static void acl_change_stasis_unsubscribe ( void  )

static

Definition at line 245 of file manager.c.

{
    acl_change_sub = stasis_unsubscribe_and_join(acl_change_sub);
}

References acl_change_sub, and stasis_unsubscribe_and_join().

Referenced by __init_manager(), and manager_shutdown().

action_aoc_de_message()

static struct ast_aoc_decoded * action_aoc_de_message ( struct mansession *  s, const struct message *  m  )

static

Definition at line 4500 of file manager.c.

{
    const char *msgtype = astman_get_header(m, "MsgType");
    const char *chargetype = astman_get_header(m, "ChargeType");
    const char *currencyname = astman_get_header(m, "CurrencyName");
    const char *currencyamount = astman_get_header(m, "CurrencyAmount");
    const char *mult = astman_get_header(m, "CurrencyMultiplier");
    const char *totaltype = astman_get_header(m, "TotalType");
    const char *aocbillingid = astman_get_header(m, "AOCBillingId");
    const char *association_id= astman_get_header(m, "ChargingAssociationId");
    const char *association_num = astman_get_header(m, "ChargingAssociationNumber");
    const char *association_plan = astman_get_header(m, "ChargingAssociationPlan");
 
    enum ast_aoc_type _msgtype;
    enum ast_aoc_charge_type _chargetype;
    enum ast_aoc_currency_multiplier _mult = AST_AOC_MULT_ONE;
    enum ast_aoc_total_type _totaltype = AST_AOC_TOTAL;
    enum ast_aoc_billing_id _billingid = AST_AOC_BILLING_NA;
    unsigned int _currencyamount = 0;
    int _association_id = 0;
    unsigned int _association_plan = 0;
 
    struct ast_aoc_decoded *decoded = NULL;
 
    if (ast_strlen_zero(chargetype)) {
        astman_send_error(s, m, "ChargeType not specified");
        goto aocmessage_cleanup;
    }
 
    _msgtype = strcasecmp(msgtype, "d") ? AST_AOC_E : AST_AOC_D;
 
    if (!strcasecmp(chargetype, "NA")) {
        _chargetype = AST_AOC_CHARGE_NA;
    } else if (!strcasecmp(chargetype, "Free")) {
        _chargetype = AST_AOC_CHARGE_FREE;
    } else if (!strcasecmp(chargetype, "Currency")) {
        _chargetype = AST_AOC_CHARGE_CURRENCY;
    } else if (!strcasecmp(chargetype, "Unit")) {
        _chargetype = AST_AOC_CHARGE_UNIT;
    } else {
        astman_send_error(s, m, "Invalid ChargeType");
        goto aocmessage_cleanup;
    }
 
    if (_chargetype == AST_AOC_CHARGE_CURRENCY) {
 
        if (ast_strlen_zero(currencyamount) || (sscanf(currencyamount, "%30u", &_currencyamount) != 1)) {
            astman_send_error(s, m, "Invalid CurrencyAmount, CurrencyAmount is a required when ChargeType is Currency");
            goto aocmessage_cleanup;
        }
 
        if (ast_strlen_zero(mult)) {
            astman_send_error(s, m, "ChargeMultiplier unspecified, ChargeMultiplier is required when ChargeType is Currency.");
            goto aocmessage_cleanup;
        } else if (!strcasecmp(mult, "onethousandth")) {
            _mult = AST_AOC_MULT_ONETHOUSANDTH;
        } else if (!strcasecmp(mult, "onehundredth")) {
            _mult = AST_AOC_MULT_ONEHUNDREDTH;
        } else if (!strcasecmp(mult, "onetenth")) {
            _mult = AST_AOC_MULT_ONETENTH;
        } else if (!strcasecmp(mult, "one")) {
            _mult = AST_AOC_MULT_ONE;
        } else if (!strcasecmp(mult, "ten")) {
            _mult = AST_AOC_MULT_TEN;
        } else if (!strcasecmp(mult, "hundred")) {
            _mult = AST_AOC_MULT_HUNDRED;
        } else if (!strcasecmp(mult, "thousand")) {
            _mult = AST_AOC_MULT_THOUSAND;
        } else {
            astman_send_error(s, m, "Invalid ChargeMultiplier");
            goto aocmessage_cleanup;
        }
    }
 
    /* create decoded object and start setting values */
    if (!(decoded = ast_aoc_create(_msgtype, _chargetype, 0))) {
            astman_send_error(s, m, "Message Creation Failed");
            goto aocmessage_cleanup;
    }
 
    if (_msgtype == AST_AOC_D) {
        if (!ast_strlen_zero(totaltype) && !strcasecmp(totaltype, "subtotal")) {
            _totaltype = AST_AOC_SUBTOTAL;
        }
 
        if (ast_strlen_zero(aocbillingid)) {
            /* ignore this is optional */
        } else if (!strcasecmp(aocbillingid, "Normal")) {
            _billingid = AST_AOC_BILLING_NORMAL;
        } else if (!strcasecmp(aocbillingid, "ReverseCharge")) {
            _billingid = AST_AOC_BILLING_REVERSE_CHARGE;
        } else if (!strcasecmp(aocbillingid, "CreditCard")) {
            _billingid = AST_AOC_BILLING_CREDIT_CARD;
        } else {
            astman_send_error(s, m, "Invalid AOC-D AOCBillingId");
            goto aocmessage_cleanup;
        }
    } else {
        if (ast_strlen_zero(aocbillingid)) {
            /* ignore this is optional */
        } else if (!strcasecmp(aocbillingid, "Normal")) {
            _billingid = AST_AOC_BILLING_NORMAL;
        } else if (!strcasecmp(aocbillingid, "ReverseCharge")) {
            _billingid = AST_AOC_BILLING_REVERSE_CHARGE;
        } else if (!strcasecmp(aocbillingid, "CreditCard")) {
            _billingid = AST_AOC_BILLING_CREDIT_CARD;
        } else if (!strcasecmp(aocbillingid, "CallFwdUnconditional")) {
            _billingid = AST_AOC_BILLING_CALL_FWD_UNCONDITIONAL;
        } else if (!strcasecmp(aocbillingid, "CallFwdBusy")) {
            _billingid = AST_AOC_BILLING_CALL_FWD_BUSY;
        } else if (!strcasecmp(aocbillingid, "CallFwdNoReply")) {
            _billingid = AST_AOC_BILLING_CALL_FWD_NO_REPLY;
        } else if (!strcasecmp(aocbillingid, "CallDeflection")) {
            _billingid = AST_AOC_BILLING_CALL_DEFLECTION;
        } else if (!strcasecmp(aocbillingid, "CallTransfer")) {
            _billingid = AST_AOC_BILLING_CALL_TRANSFER;
        } else {
            astman_send_error(s, m, "Invalid AOC-E AOCBillingId");
            goto aocmessage_cleanup;
        }
 
        if (!ast_strlen_zero(association_id) && (sscanf(association_id, "%30d", &_association_id) != 1)) {
            astman_send_error(s, m, "Invalid ChargingAssociationId");
            goto aocmessage_cleanup;
        }
        if (!ast_strlen_zero(association_plan) && (sscanf(association_plan, "%30u", &_association_plan) != 1)) {
            astman_send_error(s, m, "Invalid ChargingAssociationPlan");
            goto aocmessage_cleanup;
        }
 
        if (_association_id) {
            ast_aoc_set_association_id(decoded, _association_id);
        } else if (!ast_strlen_zero(association_num)) {
            ast_aoc_set_association_number(decoded, association_num, _association_plan);
        }
    }
 
    if (_chargetype == AST_AOC_CHARGE_CURRENCY) {
        ast_aoc_set_currency_info(decoded, _currencyamount, _mult, ast_strlen_zero(currencyname) ? NULL : currencyname);
    } else if (_chargetype == AST_AOC_CHARGE_UNIT) {
        struct ast_aoc_unit_entry entry;
        int i;
 
        /* multiple unit entries are possible, lets get them all */
        for (i = 0; i < 32; i++) {
            if (aocmessage_get_unit_entry(m, &entry, i)) {
                break; /* that's the end then */
            }
 
            ast_aoc_add_unit_entry(decoded, entry.valid_amount, entry.amount, entry.valid_type, entry.type);
        }
 
        /* at least one unit entry is required */
        if (!i) {
            astman_send_error(s, m, "Invalid UnitAmount(0), At least one valid unit entry is required when ChargeType is set to Unit");
            goto aocmessage_cleanup;
        }
 
    }
 
    ast_aoc_set_billing_id(decoded, _billingid);
    ast_aoc_set_total_type(decoded, _totaltype);
 
    return decoded;
 
aocmessage_cleanup:
 
    ast_aoc_destroy_decoded(decoded);
    return NULL;
}

References ast_aoc_unit_entry::amount, aocmessage_get_unit_entry(), ast_aoc_add_unit_entry(), AST_AOC_BILLING_CALL_DEFLECTION, AST_AOC_BILLING_CALL_FWD_BUSY, AST_AOC_BILLING_CALL_FWD_NO_REPLY, AST_AOC_BILLING_CALL_FWD_UNCONDITIONAL, AST_AOC_BILLING_CALL_TRANSFER, AST_AOC_BILLING_CREDIT_CARD, AST_AOC_BILLING_NA, AST_AOC_BILLING_NORMAL, AST_AOC_BILLING_REVERSE_CHARGE, AST_AOC_CHARGE_CURRENCY, AST_AOC_CHARGE_FREE, AST_AOC_CHARGE_NA, AST_AOC_CHARGE_UNIT, ast_aoc_create(), AST_AOC_D, ast_aoc_destroy_decoded(), AST_AOC_E, AST_AOC_MULT_HUNDRED, AST_AOC_MULT_ONE, AST_AOC_MULT_ONEHUNDREDTH, AST_AOC_MULT_ONETENTH, AST_AOC_MULT_ONETHOUSANDTH, AST_AOC_MULT_TEN, AST_AOC_MULT_THOUSAND, ast_aoc_set_association_id(), ast_aoc_set_association_number(), ast_aoc_set_billing_id(), ast_aoc_set_currency_info(), ast_aoc_set_total_type(), AST_AOC_SUBTOTAL, AST_AOC_TOTAL, ast_strlen_zero(), astman_get_header(), astman_send_error(), NULL, ast_aoc_unit_entry::type, ast_aoc_unit_entry::valid_amount, and ast_aoc_unit_entry::valid_type.

Referenced by action_aocmessage().

action_aoc_s_message()

static struct ast_aoc_decoded * action_aoc_s_message ( struct mansession *  s, const struct message *  m  )

static

Definition at line 4895 of file manager.c.

{
    struct ast_aoc_decoded *decoded = NULL;
    int hdrlen;
    int x;
    static const char hdr[] = "ChargedItem:";
    struct message sm = { 0 };
    int rates = 0;
 
    if (!(decoded = ast_aoc_create(AST_AOC_S, 0, 0))) {
        astman_send_error(s, m, "Message Creation Failed");
        goto aocmessage_cleanup;
    }
 
    hdrlen = strlen(hdr);
    for (x = 0; x < m->hdrcount; x++) {
        if (strncasecmp(hdr, m->headers[x], hdrlen) == 0) {
            if (rates > ast_aoc_s_get_count(decoded)) {
                if (action_aoc_s_submessage(s, &sm, decoded) == -1) {
                    goto aocmessage_cleanup;
                }
            }
            ++rates;
        }
 
        sm.headers[sm.hdrcount] = m->headers[x];
        ++sm.hdrcount;
    }
    if (rates > ast_aoc_s_get_count(decoded)) {
        if (action_aoc_s_submessage(s, &sm, decoded) == -1) {
            goto aocmessage_cleanup;
        }
    }
 
    return decoded;
 
aocmessage_cleanup:
 
    ast_aoc_destroy_decoded(decoded);
    return NULL;
}

References action_aoc_s_submessage(), ast_aoc_create(), ast_aoc_destroy_decoded(), AST_AOC_S, ast_aoc_s_get_count(), astman_send_error(), message::hdrcount, message::headers, and NULL.

Referenced by action_aocmessage().

action_aoc_s_submessage()

static int action_aoc_s_submessage ( struct mansession *  s, const struct message *  m, struct ast_aoc_decoded *  decoded  )

static

Definition at line 4671 of file manager.c.

{
    const char *chargeditem = __astman_get_header(m, "ChargedItem", GET_HEADER_LAST_MATCH);
    const char *ratetype = __astman_get_header(m, "RateType", GET_HEADER_LAST_MATCH);
    const char *currencyname = __astman_get_header(m, "CurrencyName", GET_HEADER_LAST_MATCH);
    const char *currencyamount = __astman_get_header(m, "CurrencyAmount", GET_HEADER_LAST_MATCH);
    const char *mult = __astman_get_header(m, "CurrencyMultiplier", GET_HEADER_LAST_MATCH);
    const char *time = __astman_get_header(m, "Time", GET_HEADER_LAST_MATCH);
    const char *timescale = __astman_get_header(m, "TimeScale", GET_HEADER_LAST_MATCH);
    const char *granularity = __astman_get_header(m, "Granularity", GET_HEADER_LAST_MATCH);
    const char *granularitytimescale = __astman_get_header(m, "GranularityTimeScale", GET_HEADER_LAST_MATCH);
    const char *chargingtype = __astman_get_header(m, "ChargingType", GET_HEADER_LAST_MATCH);
    const char *volumeunit = __astman_get_header(m, "VolumeUnit", GET_HEADER_LAST_MATCH);
    const char *code = __astman_get_header(m, "Code", GET_HEADER_LAST_MATCH);
 
    enum ast_aoc_s_charged_item _chargeditem;
    enum ast_aoc_s_rate_type _ratetype;
    enum ast_aoc_currency_multiplier _mult = AST_AOC_MULT_ONE;
    unsigned int _currencyamount = 0;
    unsigned int _code;
    unsigned int _time = 0;
    enum ast_aoc_time_scale _scale = 0;
    unsigned int _granularity = 0;
    enum ast_aoc_time_scale _granularity_time_scale = AST_AOC_TIME_SCALE_MINUTE;
    int _step = 0;
    enum ast_aoc_volume_unit _volumeunit = 0;
 
    if (ast_strlen_zero(chargeditem)) {
        astman_send_error(s, m, "ChargedItem not specified");
        goto aocmessage_cleanup;
    }
 
    if (ast_strlen_zero(ratetype)) {
        astman_send_error(s, m, "RateType not specified");
        goto aocmessage_cleanup;
    }
 
    if (!strcasecmp(chargeditem, "NA")) {
        _chargeditem = AST_AOC_CHARGED_ITEM_NA;
    } else if (!strcasecmp(chargeditem, "SpecialArrangement")) {
        _chargeditem = AST_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT;
    } else if (!strcasecmp(chargeditem, "BasicCommunication")) {
        _chargeditem = AST_AOC_CHARGED_ITEM_BASIC_COMMUNICATION;
    } else if (!strcasecmp(chargeditem, "CallAttempt")) {
        _chargeditem = AST_AOC_CHARGED_ITEM_CALL_ATTEMPT;
    } else if (!strcasecmp(chargeditem, "CallSetup")) {
        _chargeditem = AST_AOC_CHARGED_ITEM_CALL_SETUP;
    } else if (!strcasecmp(chargeditem, "UserUserInfo")) {
        _chargeditem = AST_AOC_CHARGED_ITEM_USER_USER_INFO;
    } else if (!strcasecmp(chargeditem, "SupplementaryService")) {
        _chargeditem = AST_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE;
    } else {
        astman_send_error(s, m, "Invalid ChargedItem");
        goto aocmessage_cleanup;
    }
 
    if (!strcasecmp(ratetype, "NA")) {
        _ratetype = AST_AOC_RATE_TYPE_NA;
    } else if (!strcasecmp(ratetype, "Free")) {
        _ratetype = AST_AOC_RATE_TYPE_FREE;
    } else if (!strcasecmp(ratetype, "FreeFromBeginning")) {
        _ratetype = AST_AOC_RATE_TYPE_FREE_FROM_BEGINNING;
    } else if (!strcasecmp(ratetype, "Duration")) {
        _ratetype = AST_AOC_RATE_TYPE_DURATION;
    } else if (!strcasecmp(ratetype, "Flat")) {
        _ratetype = AST_AOC_RATE_TYPE_FLAT;
    } else if (!strcasecmp(ratetype, "Volume")) {
        _ratetype = AST_AOC_RATE_TYPE_VOLUME;
    } else if (!strcasecmp(ratetype, "SpecialCode")) {
        _ratetype = AST_AOC_RATE_TYPE_SPECIAL_CODE;
    } else {
        astman_send_error(s, m, "Invalid RateType");
        goto aocmessage_cleanup;
    }
 
    if (_ratetype > AST_AOC_RATE_TYPE_FREE_FROM_BEGINNING) {
        if (ast_strlen_zero(currencyamount) || (sscanf(currencyamount, "%30u",
                &_currencyamount) != 1)) {
            astman_send_error(s, m, "Invalid CurrencyAmount, CurrencyAmount is a required when RateType is non-free");
            goto aocmessage_cleanup;
        }
 
        if (ast_strlen_zero(mult)) {
            astman_send_error(s, m, "ChargeMultiplier unspecified, ChargeMultiplier is required when ChargeType is Currency.");
            goto aocmessage_cleanup;
        } else if (!strcasecmp(mult, "onethousandth")) {
            _mult = AST_AOC_MULT_ONETHOUSANDTH;
        } else if (!strcasecmp(mult, "onehundredth")) {
            _mult = AST_AOC_MULT_ONEHUNDREDTH;
        } else if (!strcasecmp(mult, "onetenth")) {
            _mult = AST_AOC_MULT_ONETENTH;
        } else if (!strcasecmp(mult, "one")) {
            _mult = AST_AOC_MULT_ONE;
        } else if (!strcasecmp(mult, "ten")) {
            _mult = AST_AOC_MULT_TEN;
        } else if (!strcasecmp(mult, "hundred")) {
            _mult = AST_AOC_MULT_HUNDRED;
        } else if (!strcasecmp(mult, "thousand")) {
            _mult = AST_AOC_MULT_THOUSAND;
        } else {
            astman_send_error(s, m, "Invalid ChargeMultiplier");
            goto aocmessage_cleanup;
        }
    }
 
    if (_ratetype == AST_AOC_RATE_TYPE_DURATION) {
        if (ast_strlen_zero(timescale)) {
            astman_send_error(s, m, "TimeScale unspecified, TimeScale is required when RateType is Duration.");
            goto aocmessage_cleanup;
        } else if (!strcasecmp(timescale, "onehundredthsecond")) {
            _scale = AST_AOC_TIME_SCALE_HUNDREDTH_SECOND;
        } else if (!strcasecmp(timescale, "onetenthsecond")) {
            _scale = AST_AOC_TIME_SCALE_TENTH_SECOND;
        } else if (!strcasecmp(timescale, "second")) {
            _scale = AST_AOC_TIME_SCALE_SECOND;
        } else if (!strcasecmp(timescale, "tenseconds")) {
            _scale = AST_AOC_TIME_SCALE_TEN_SECOND;
        } else if (!strcasecmp(timescale, "minute")) {
            _scale = AST_AOC_TIME_SCALE_MINUTE;
        } else if (!strcasecmp(timescale, "hour")) {
            _scale = AST_AOC_TIME_SCALE_HOUR;
        } else if (!strcasecmp(timescale, "day")) {
            _scale = AST_AOC_TIME_SCALE_DAY;
        } else {
            astman_send_error(s, m, "Invalid TimeScale");
            goto aocmessage_cleanup;
        }
 
        if (ast_strlen_zero(time) || (sscanf(time, "%30u", &_time) != 1)) {
            astman_send_error(s, m, "Invalid Time, Time is a required when RateType is Duration");
            goto aocmessage_cleanup;
        }
 
        if (!ast_strlen_zero(granularity)) {
            if ((sscanf(time, "%30u", &_granularity) != 1)) {
                astman_send_error(s, m, "Invalid Granularity");
                goto aocmessage_cleanup;
            }
 
            if (ast_strlen_zero(granularitytimescale)) {
                astman_send_error(s, m, "Invalid GranularityTimeScale, GranularityTimeScale is a required when Granularity is specified");
            } else if (!strcasecmp(granularitytimescale, "onehundredthsecond")) {
                _granularity_time_scale = AST_AOC_TIME_SCALE_HUNDREDTH_SECOND;
            } else if (!strcasecmp(granularitytimescale, "onetenthsecond")) {
                _granularity_time_scale = AST_AOC_TIME_SCALE_TENTH_SECOND;
            } else if (!strcasecmp(granularitytimescale, "second")) {
                _granularity_time_scale = AST_AOC_TIME_SCALE_SECOND;
            } else if (!strcasecmp(granularitytimescale, "tenseconds")) {
                _granularity_time_scale = AST_AOC_TIME_SCALE_TEN_SECOND;
            } else if (!strcasecmp(granularitytimescale, "minute")) {
                _granularity_time_scale = AST_AOC_TIME_SCALE_MINUTE;
            } else if (!strcasecmp(granularitytimescale, "hour")) {
                _granularity_time_scale = AST_AOC_TIME_SCALE_HOUR;
            } else if (!strcasecmp(granularitytimescale, "day")) {
                _granularity_time_scale = AST_AOC_TIME_SCALE_DAY;
            } else {
                astman_send_error(s, m, "Invalid GranularityTimeScale");
                goto aocmessage_cleanup;
            }
        }
 
        if (ast_strlen_zero(chargingtype) || strcasecmp(chargingtype, "continuouscharging") == 0) {
            _step = 0;
        } else if (strcasecmp(chargingtype, "stepfunction") == 0 ) {
            _step = 1;
        } else {
            astman_send_error(s, m, "Invalid ChargingType");
            goto aocmessage_cleanup;
        }
    }
 
    if (_ratetype == AST_AOC_RATE_TYPE_VOLUME) {
        if (ast_strlen_zero(volumeunit)) {
            astman_send_error(s, m, "VolumeUnit unspecified, VolumeUnit is required when RateType is Volume.");
            goto aocmessage_cleanup;
        } else if (!strcasecmp(timescale, "octet")) {
            _volumeunit = AST_AOC_VOLUME_UNIT_OCTET;
        } else if (!strcasecmp(timescale, "segment")) {
            _volumeunit = AST_AOC_VOLUME_UNIT_SEGMENT;
        } else if (!strcasecmp(timescale, "message")) {
            _volumeunit = AST_AOC_VOLUME_UNIT_MESSAGE;
        }else {
            astman_send_error(s, m, "Invalid VolumeUnit");
            goto aocmessage_cleanup;
        }
    }
 
    if (_chargeditem == AST_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT
            || _ratetype == AST_AOC_RATE_TYPE_SPECIAL_CODE) {
        if (ast_strlen_zero(code) || (sscanf(code, "%30u", &_code) != 1)) {
            astman_send_error(s, m, "Invalid Code, Code is a required when ChargedItem is SpecialArrangement and when RateType is SpecialCode");
            goto aocmessage_cleanup;
        }
    }
 
    if (_chargeditem == AST_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT) {
        ast_aoc_s_add_special_arrangement(decoded, _code);
    } else if (_ratetype == AST_AOC_RATE_TYPE_DURATION) {
        ast_aoc_s_add_rate_duration(decoded, _chargeditem, _currencyamount, _mult,
            currencyname, _time, _scale, _granularity, _granularity_time_scale, _step);
    } else if (_ratetype == AST_AOC_RATE_TYPE_FLAT) {
        ast_aoc_s_add_rate_flat(decoded, _chargeditem, _currencyamount, _mult,
                currencyname);
    } else if (_ratetype == AST_AOC_RATE_TYPE_VOLUME) {
        ast_aoc_s_add_rate_volume(decoded, _chargeditem, _volumeunit, _currencyamount,
            _mult, currencyname);
    } else if (_ratetype == AST_AOC_RATE_TYPE_SPECIAL_CODE) {
        ast_aoc_s_add_rate_special_charge_code(decoded, _chargeditem, _code);
    } else if (_ratetype == AST_AOC_RATE_TYPE_FREE) {
        ast_aoc_s_add_rate_free(decoded, _chargeditem, 0);
    } else if (_ratetype == AST_AOC_RATE_TYPE_FREE_FROM_BEGINNING) {
        ast_aoc_s_add_rate_free(decoded, _chargeditem, 1);
    } else if (_ratetype == AST_AOC_RATE_TYPE_NA) {
        ast_aoc_s_add_rate_na(decoded, _chargeditem);
    }
 
    return 0;
 
aocmessage_cleanup:
 
    return -1;
}

References __astman_get_header(), AST_AOC_CHARGED_ITEM_BASIC_COMMUNICATION, AST_AOC_CHARGED_ITEM_CALL_ATTEMPT, AST_AOC_CHARGED_ITEM_CALL_SETUP, AST_AOC_CHARGED_ITEM_NA, AST_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT, AST_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE, AST_AOC_CHARGED_ITEM_USER_USER_INFO, AST_AOC_MULT_HUNDRED, AST_AOC_MULT_ONE, AST_AOC_MULT_ONEHUNDREDTH, AST_AOC_MULT_ONETENTH, AST_AOC_MULT_ONETHOUSANDTH, AST_AOC_MULT_TEN, AST_AOC_MULT_THOUSAND, AST_AOC_RATE_TYPE_DURATION, AST_AOC_RATE_TYPE_FLAT, AST_AOC_RATE_TYPE_FREE, AST_AOC_RATE_TYPE_FREE_FROM_BEGINNING, AST_AOC_RATE_TYPE_NA, AST_AOC_RATE_TYPE_SPECIAL_CODE, AST_AOC_RATE_TYPE_VOLUME, ast_aoc_s_add_rate_duration(), ast_aoc_s_add_rate_flat(), ast_aoc_s_add_rate_free(), ast_aoc_s_add_rate_na(), ast_aoc_s_add_rate_special_charge_code(), ast_aoc_s_add_rate_volume(), ast_aoc_s_add_special_arrangement(), AST_AOC_TIME_SCALE_DAY, AST_AOC_TIME_SCALE_HOUR, AST_AOC_TIME_SCALE_HUNDREDTH_SECOND, AST_AOC_TIME_SCALE_MINUTE, AST_AOC_TIME_SCALE_SECOND, AST_AOC_TIME_SCALE_TEN_SECOND, AST_AOC_TIME_SCALE_TENTH_SECOND, AST_AOC_VOLUME_UNIT_MESSAGE, AST_AOC_VOLUME_UNIT_OCTET, AST_AOC_VOLUME_UNIT_SEGMENT, ast_strlen_zero(), astman_send_error(), and GET_HEADER_LAST_MATCH.

Referenced by action_aoc_s_message().

action_aocmessage()

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

static

Definition at line 4938 of file manager.c.

{
    const char *msgtype = astman_get_header(m, "MsgType");
    const char *channel = astman_get_header(m, "Channel");
    const char *pchannel = astman_get_header(m, "ChannelPrefix");
 
    struct ast_channel *chan = NULL;
 
    struct ast_aoc_decoded *decoded = NULL;
    struct ast_aoc_encoded *encoded = NULL;
    size_t encoded_size = 0;
 
    if (ast_strlen_zero(channel) && ast_strlen_zero(pchannel)) {
        astman_send_error(s, m, "Channel and PartialChannel are not specified. Specify at least one of these.");
        goto aocmessage_cleanup;
    }
 
    if (!(chan = ast_channel_get_by_name(channel)) && !ast_strlen_zero(pchannel)) {
        chan = ast_channel_get_by_name_prefix(pchannel, strlen(pchannel));
    }
 
    if (!chan) {
        astman_send_error(s, m, "No such channel");
        goto aocmessage_cleanup;
    }
 
    if (strcasecmp(msgtype, "d") == 0 || strcasecmp(msgtype, "e") == 0) {
        decoded = action_aoc_de_message(s, m);
    }
    else if (strcasecmp(msgtype, "s") == 0) {
        decoded = action_aoc_s_message(s, m);
    }
    else {
        astman_send_error(s, m, "Invalid MsgType");
        goto aocmessage_cleanup;
    }
 
    if (!decoded) {
        goto aocmessage_cleanup;
    }
 
    if ((encoded = ast_aoc_encode(decoded, &encoded_size, chan))
            && !ast_indicate_data(chan, AST_CONTROL_AOC, encoded, encoded_size)) {
        astman_send_ack(s, m, "AOC Message successfully queued on channel");
    } else {
        astman_send_error(s, m, "Error encoding AOC message, could not queue onto channel");
    }
 
aocmessage_cleanup:
 
    ast_aoc_destroy_decoded(decoded);
    ast_aoc_destroy_encoded(encoded);
 
    if (chan) {
        chan = ast_channel_unref(chan);
    }
    return 0;
}

References action_aoc_de_message(), action_aoc_s_message(), ast_aoc_destroy_decoded(), ast_aoc_destroy_encoded(), ast_aoc_encode(), ast_channel_get_by_name(), ast_channel_get_by_name_prefix(), ast_channel_unref, AST_CONTROL_AOC, ast_indicate_data(), ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), and NULL.

Referenced by __init_manager().

action_atxfer()

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

static

Definition at line 4148 of file manager.c.

{
    const char *name = astman_get_header(m, "Channel");
    const char *exten = astman_get_header(m, "Exten");
    const char *context = astman_get_header(m, "Context");
    struct ast_channel *chan = NULL;
    char feature_code[AST_FEATURE_MAX_LEN];
    const char *digit;
 
    if (ast_strlen_zero(name)) {
        astman_send_error(s, m, "No channel specified");
        return 0;
    }
    if (ast_strlen_zero(exten)) {
        astman_send_error(s, m, "No extension specified");
        return 0;
    }
 
    if (!(chan = ast_channel_get_by_name(name))) {
        astman_send_error(s, m, "Channel specified does not exist");
        return 0;
    }
 
    ast_channel_lock(chan);
    if (ast_get_builtin_feature(chan, "atxfer", feature_code, sizeof(feature_code)) ||
            ast_strlen_zero(feature_code)) {
        ast_channel_unlock(chan);
        astman_send_error(s, m, "No attended transfer feature code found");
        ast_channel_unref(chan);
        return 0;
    }
    ast_channel_unlock(chan);
 
    if (!ast_strlen_zero(context)) {
        pbx_builtin_setvar_helper(chan, "TRANSFER_CONTEXT", context);
    }
 
    for (digit = feature_code; *digit; ++digit) {
        struct ast_frame f = { AST_FRAME_DTMF, .subclass.integer = *digit };
        ast_queue_frame(chan, &f);
    }
 
    for (digit = exten; *digit; ++digit) {
        struct ast_frame f = { AST_FRAME_DTMF, .subclass.integer = *digit };
        ast_queue_frame(chan, &f);
    }
 
    chan = ast_channel_unref(chan);
 
    astman_send_ack(s, m, "Atxfer successfully queued");
 
    return 0;
}

References ast_channel_get_by_name(), ast_channel_lock, ast_channel_unlock, ast_channel_unref, AST_FEATURE_MAX_LEN, AST_FRAME_DTMF, ast_get_builtin_feature(), ast_queue_frame(), ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), voicemailpwcheck::context, digit, name, NULL, and pbx_builtin_setvar_helper().

Referenced by __init_manager().

action_blind_transfer()

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

static

Definition at line 4102 of file manager.c.

{
    const char *name = astman_get_header(m, "Channel");
    const char *exten = astman_get_header(m, "Exten");
    const char *context = astman_get_header(m, "Context");
    struct ast_channel *chan;
 
    if (ast_strlen_zero(name)) {
        astman_send_error(s, m, "No channel specified");
        return 0;
    }
 
    if (ast_strlen_zero(exten)) {
        astman_send_error(s, m, "No extension specified");
        return 0;
    }
 
    chan = ast_channel_get_by_name(name);
    if (!chan) {
        astman_send_error(s, m, "Channel specified does not exist");
        return 0;
    }
 
    if (ast_strlen_zero(context)) {
        context = ast_channel_context(chan);
    }
 
    switch (ast_bridge_transfer_blind(1, chan, exten, context, NULL, NULL)) {
    case AST_BRIDGE_TRANSFER_NOT_PERMITTED:
        astman_send_error(s, m, "Transfer not permitted");
        break;
    case AST_BRIDGE_TRANSFER_INVALID:
        astman_send_error(s, m, "Transfer invalid");
        break;
    case AST_BRIDGE_TRANSFER_FAIL:
        astman_send_error(s, m, "Transfer failed");
        break;
    case AST_BRIDGE_TRANSFER_SUCCESS:
        astman_send_ack(s, m, "Transfer succeeded");
        break;
    }
 
    ast_channel_unref(chan);
    return 0;
}

References ast_bridge_transfer_blind(), AST_BRIDGE_TRANSFER_FAIL, AST_BRIDGE_TRANSFER_INVALID, AST_BRIDGE_TRANSFER_NOT_PERMITTED, AST_BRIDGE_TRANSFER_SUCCESS, ast_channel_context(), ast_channel_get_by_name(), ast_channel_unref, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), voicemailpwcheck::context, name, and NULL.

Referenced by __init_manager().

action_cancel_atxfer()

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

static

Definition at line 4202 of file manager.c.

{
    const char *name = astman_get_header(m, "Channel");
    struct ast_channel *chan = NULL;
    char *feature_code;
    const char *digit;
 
    if (ast_strlen_zero(name)) {
        astman_send_error(s, m, "No channel specified");
        return 0;
    }
 
    if (!(chan = ast_channel_get_by_name(name))) {
        astman_send_error(s, m, "Channel specified does not exist");
        return 0;
    }
 
    ast_channel_lock(chan);
    feature_code = ast_get_chan_features_atxferabort(chan);
    ast_channel_unlock(chan);
 
    if (!feature_code) {
        astman_send_error(s, m, "No disconnect feature code found");
        ast_channel_unref(chan);
        return 0;
    }
 
    for (digit = feature_code; *digit; ++digit) {
        struct ast_frame f = { AST_FRAME_DTMF, .subclass.integer = *digit };
        ast_queue_frame(chan, &f);
    }
    ast_free(feature_code);
 
    chan = ast_channel_unref(chan);
 
    astman_send_ack(s, m, "CancelAtxfer successfully queued");
 
    return 0;
}

References ast_channel_get_by_name(), ast_channel_lock, ast_channel_unlock, ast_channel_unref, AST_FRAME_DTMF, ast_free, ast_get_chan_features_atxferabort(), ast_queue_frame(), ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), digit, name, and NULL.

Referenced by __init_manager().

action_challenge()

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

static

Definition at line 3407 of file manager.c.

{
    const char *authtype = astman_get_header(m, "AuthType");
 
    if (!strcasecmp(authtype, "MD5")) {
        if (ast_strlen_zero(s->session->challenge)) {
            snprintf(s->session->challenge, sizeof(s->session->challenge), "%ld", ast_random());
        }
        mansession_lock(s);
        astman_start_ack(s, m);
        astman_append(s, "Challenge: %s\r\n\r\n", s->session->challenge);
        mansession_unlock(s);
    } else {
        astman_send_error(s, m, "Must specify AuthType");
    }
    return 0;
}

References ast_random(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), astman_start_ack(), mansession_session::challenge, mansession_lock(), mansession_unlock(), and mansession::session.

Referenced by __init_manager().

action_command()

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

static

Manager command "command" - execute CLI command.

Definition at line 4279 of file manager.c.

{
    const char *cmd = astman_get_header(m, "Command");
    char *buf = NULL, *final_buf = NULL, *delim, *output;
    char template[] = "/tmp/ast-ami-XXXXXX";    /* template for temporary file */
    int fd, ret;
    off_t len;
 
    if (ast_strlen_zero(cmd)) {
        astman_send_error(s, m, "No command provided");
        return 0;
    }
 
    if (check_blacklist(cmd)) {
        astman_send_error(s, m, "Command blacklisted");
        return 0;
    }
 
    if ((fd = mkstemp(template)) < 0) {
        astman_send_error_va(s, m, "Failed to create temporary file: %s", strerror(errno));
        return 0;
    }
 
    ret = ast_cli_command(fd, cmd);
    astman_send_response_full(s, m, ret == RESULT_SUCCESS ? "Success" : "Error", MSG_MOREDATA, NULL);
 
    /* Determine number of characters available */
    if ((len = lseek(fd, 0, SEEK_END)) < 0) {
        astman_append(s, "Message: Failed to determine number of characters: %s\r\n", strerror(errno));
        goto action_command_cleanup;
    }
 
    /* This has a potential to overflow the stack.  Hence, use the heap. */
    buf = ast_malloc(len + 1);
    final_buf = ast_malloc(len + 1);
 
    if (!buf || !final_buf) {
        astman_append(s, "Message: Memory allocation failure\r\n");
        goto action_command_cleanup;
    }
 
    if (lseek(fd, 0, SEEK_SET) < 0) {
        astman_append(s, "Message: Failed to set position on temporary file: %s\r\n", strerror(errno));
        goto action_command_cleanup;
    }
 
    if (read(fd, buf, len) < 0) {
        astman_append(s, "Message: Failed to read from temporary file: %s\r\n", strerror(errno));
        goto action_command_cleanup;
    }
 
    buf[len] = '\0';
    term_strip(final_buf, buf, len);
    final_buf[len] = '\0';
 
    /* Trim trailing newline */
    if (len && final_buf[len - 1] == '\n') {
        final_buf[len - 1] = '\0';
    }
 
    astman_append(s, "Message: Command output follows\r\n");
 
    delim = final_buf;
    while ((output = strsep(&delim, "\n"))) {
        astman_append(s, "Output: %s\r\n", output);
    }
 
action_command_cleanup:
    astman_append(s, "\r\n");
 
    close(fd);
    unlink(template);
 
    ast_free(buf);
    ast_free(final_buf);
 
    return 0;
}

References ast_free, ast_malloc, ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), astman_send_error_va(), astman_send_response_full(), buf, check_blacklist(), errno, len(), MSG_MOREDATA, NULL, RESULT_SUCCESS, strsep(), and term_strip().

Referenced by __init_manager().

action_coresettings()

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

static

Show PBX core settings information.

Definition at line 6463 of file manager.c.

{
    const char *actionid = astman_get_header(m, "ActionID");
    char idText[150];
 
    if (!ast_strlen_zero(actionid)) {
        snprintf(idText, sizeof(idText), "ActionID: %s\r\n", actionid);
    } else {
        idText[0] = '\0';
    }
 
    astman_append(s, "Response: Success\r\n"
            "%s"
            "AMIversion: %s\r\n"
            "AsteriskVersion: %s\r\n"
            "SystemName: %s\r\n"
            "CoreMaxCalls: %d\r\n"
            "CoreMaxLoadAvg: %f\r\n"
            "CoreRunUser: %s\r\n"
            "CoreRunGroup: %s\r\n"
            "CoreMaxFilehandles: %d\r\n"
            "CoreRealTimeEnabled: %s\r\n"
            "CoreCDRenabled: %s\r\n"
            "CoreHTTPenabled: %s\r\n"
            "SoundsSearchCustomDir: %s\r\n"
            "\r\n",
            idText,
            AMI_VERSION,
            ast_get_version(),
            ast_config_AST_SYSTEM_NAME,
            ast_option_maxcalls,
            ast_option_maxload,
            ast_config_AST_RUN_USER,
            ast_config_AST_RUN_GROUP,
            ast_option_maxfiles,
            AST_CLI_YESNO(ast_realtime_enabled()),
            AST_CLI_YESNO(ast_cdr_is_enabled()),
            AST_CLI_YESNO(ast_webmanager_check_enabled()),
            AST_CLI_YESNO(ast_opt_sounds_search_custom)
            );
    return 0;
}

References AMI_VERSION, ast_cdr_is_enabled(), AST_CLI_YESNO, ast_config_AST_RUN_GROUP, ast_config_AST_RUN_USER, ast_config_AST_SYSTEM_NAME, ast_get_version(), ast_opt_sounds_search_custom, ast_option_maxcalls, ast_option_maxfiles, ast_option_maxload, ast_realtime_enabled(), ast_strlen_zero(), ast_webmanager_check_enabled(), astman_append(), and astman_get_header().

Referenced by __init_manager().

action_coreshowchannelmap()

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

static

Manager command "CoreShowChannelMap" - Lists all channels connected to the specified channel.

Definition at line 6749 of file manager.c.

{
    const char *actionid = astman_get_header(m, "ActionID");
    const char *channel_name = astman_get_header(m, "Channel");
    char *current_channel_name;
    char id_text[256];
    int total = 0;
    struct ao2_container *channel_map;
    struct ao2_iterator i;
    RAII_VAR(struct ast_bridge_snapshot *, bridge_snapshot, NULL, ao2_cleanup);
    RAII_VAR(struct ast_channel_snapshot *, channel_snapshot, NULL, ao2_cleanup);
 
    if (!ast_strlen_zero(actionid)) {
        snprintf(id_text, sizeof(id_text), "ActionID: %s\r\n", actionid);
    } else {
        id_text[0] = '\0';
    }
 
    if (ast_strlen_zero(channel_name)) {
        astman_send_error(s, m, "CoreShowChannelMap requires a channel.\n");
        return 0;
    }
 
    channel_snapshot = ast_channel_snapshot_get_latest_by_name(channel_name);
    if (!channel_snapshot) {
        astman_send_error(s, m, "Could not get channel snapshot\n");
        return 0;
    }
 
    if (ast_strlen_zero(channel_snapshot->bridge->id)) {
        astman_send_listack(s, m, "Channel map will follow", "start");
        astman_send_list_complete_start(s, m, "CoreShowChannelMapComplete", 0);
        astman_send_list_complete_end(s);
        return 0;
    }
 
    bridge_snapshot = ast_bridge_get_snapshot_by_uniqueid(channel_snapshot->bridge->id);
    if (!bridge_snapshot) {
        astman_send_listack(s, m, "Channel map will follow", "start");
        astman_send_list_complete_start(s, m, "CoreShowChannelMapComplete", 0);
        astman_send_list_complete_end(s);
        return 0;
    }
 
    channel_map = ast_str_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK | AO2_CONTAINER_ALLOC_OPT_DUPS_OBJ_REJECT, 1);
    if (!channel_map) {
        astman_send_error(s, m, "Could not create channel map\n");
        return 0;
    }
 
    astman_send_listack(s, m, "Channel map will follow", "start");
 
    if (coreshowchannelmap_add_connected_channels(channel_map, channel_snapshot, bridge_snapshot)) {
        astman_send_error(s, m, "Could not complete channel map\n");
        ao2_ref(channel_map, -1);
        return 0;
    }
 
    i = ao2_iterator_init(channel_map, 0);
    while ((current_channel_name = ao2_iterator_next(&i))) {
        astman_append(s,
            "Event: CoreShowChannelMap\r\n"
            "%s"
            "Channel: %s\r\n"
            "ConnectedChannel: %s\r\n\r\n",
            id_text,
            channel_name,
            current_channel_name);
        total++;
    }
    ao2_iterator_destroy(&i);
 
    ao2_ref(channel_map, -1);
    astman_send_list_complete_start(s, m, "CoreShowChannelMapComplete", total);
    astman_send_list_complete_end(s);
 
    return 0;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_cleanup, AO2_CONTAINER_ALLOC_OPT_DUPS_OBJ_REJECT, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_bridge_get_snapshot_by_uniqueid(), ast_channel_snapshot_get_latest_by_name(), ast_str_container_alloc_options(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), coreshowchannelmap_add_connected_channels(), NULL, RAII_VAR, and total.

Referenced by __init_manager().

action_coreshowchannels()

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

static

Manager command "CoreShowChannels" - List currently defined channels and some information about them.

Definition at line 6581 of file manager.c.

{
    const char *actionid = astman_get_header(m, "ActionID");
    char idText[256];
    int numchans = 0;
    struct ao2_container *channels;
    struct ao2_iterator it_chans;
    struct ast_channel_snapshot *cs;
 
    if (!ast_strlen_zero(actionid)) {
        snprintf(idText, sizeof(idText), "ActionID: %s\r\n", actionid);
    } else {
        idText[0] = '\0';
    }
 
    channels = ast_channel_cache_by_name();
 
    astman_send_listack(s, m, "Channels will follow", "start");
 
    it_chans = ao2_iterator_init(channels, 0);
    for (; (cs = ao2_iterator_next(&it_chans)); ao2_ref(cs, -1)) {
        struct ast_str *built = ast_manager_build_channel_state_string_prefix(cs, "");
        char durbuf[16] = "";
 
        if (!built) {
            continue;
        }
 
        if (!ast_tvzero(cs->base->creationtime)) {
            int duration, durh, durm, durs;
 
            duration = (int)(ast_tvdiff_ms(ast_tvnow(), cs->base->creationtime) / 1000);
            durh = duration / 3600;
            durm = (duration % 3600) / 60;
            durs = duration % 60;
            snprintf(durbuf, sizeof(durbuf), "%02d:%02d:%02d", durh, durm, durs);
        }
 
        astman_append(s,
            "Event: CoreShowChannel\r\n"
            "%s"
            "%s"
            "Application: %s\r\n"
            "ApplicationData: %s\r\n"
            "Duration: %s\r\n"
            "BridgeId: %s\r\n"
            "\r\n",
            idText,
            ast_str_buffer(built),
            cs->dialplan->appl,
            cs->dialplan->data,
            durbuf,
            cs->bridge->id);
 
        numchans++;
 
        ast_free(built);
    }
    ao2_iterator_destroy(&it_chans);
 
    astman_send_list_complete(s, m, "CoreShowChannelsComplete", numchans);
 
    ao2_ref(channels, -1);
    return 0;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_channel_snapshot_dialplan::appl, ast_channel_cache_by_name(), ast_free, ast_manager_build_channel_state_string_prefix(), ast_str_buffer(), ast_strlen_zero(), ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), astman_append(), astman_get_header(), astman_send_list_complete(), astman_send_listack(), ast_channel_snapshot::base, ast_channel_snapshot::bridge, channels, ast_channel_snapshot_base::creationtime, ast_channel_snapshot_dialplan::data, ast_channel_snapshot::dialplan, and ast_channel_snapshot_bridge::id.

Referenced by __init_manager().

action_corestatus()

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

static

Show PBX core status information.

Definition at line 6507 of file manager.c.

{
    const char *actionid = astman_get_header(m, "ActionID");
    char idText[150];
    char startuptime[150], startupdate[150];
    char reloadtime[150], reloaddate[150];
    struct ast_tm tm;
 
    if (!ast_strlen_zero(actionid)) {
        snprintf(idText, sizeof(idText), "ActionID: %s\r\n", actionid);
    } else {
        idText[0] = '\0';
    }
 
    ast_localtime(&ast_startuptime, &tm, NULL);
    ast_strftime(startuptime, sizeof(startuptime), "%H:%M:%S", &tm);
    ast_strftime(startupdate, sizeof(startupdate), "%Y-%m-%d", &tm);
    ast_localtime(&ast_lastreloadtime, &tm, NULL);
    ast_strftime(reloadtime, sizeof(reloadtime), "%H:%M:%S", &tm);
    ast_strftime(reloaddate, sizeof(reloaddate), "%Y-%m-%d", &tm);
 
    astman_append(s, "Response: Success\r\n"
            "%s"
            "CoreStartupDate: %s\r\n"
            "CoreStartupTime: %s\r\n"
            "CoreReloadDate: %s\r\n"
            "CoreReloadTime: %s\r\n"
            "CoreCurrentCalls: %d\r\n"
            "CoreProcessedCalls: %d\r\n"
            "\r\n",
            idText,
            startupdate,
            startuptime,
            reloaddate,
            reloadtime,
            ast_active_channels(),
            ast_processed_calls()
            );
    return 0;
}

References ast_active_channels(), ast_lastreloadtime, ast_localtime(), ast_processed_calls(), ast_startuptime, ast_strftime(), ast_strlen_zero(), astman_append(), astman_get_header(), and NULL.

Referenced by __init_manager().

action_createconfig()

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

static

Definition at line 3097 of file manager.c.

{
    int fd;
    const char *fn = astman_get_header(m, "Filename");
    char *stripped_filename;
    RAII_VAR(char *, filepath, NULL, ast_free);
    RAII_VAR(char *, real_dir, NULL, ast_std_free);
    RAII_VAR(char *, real_path, NULL, ast_free);
    char *filename;
 
    if (ast_strlen_zero(fn)) {
        astman_send_error(s, m, "Filename not specified");
        return 0;
    }
 
    stripped_filename = ast_strip(ast_strdupa(fn));
 
    /* If the file name is relative, prepend ast_config_AST_CONFIG_DIR */
    if (stripped_filename[0] != '/') {
        if (ast_asprintf(&filepath, "%s/%s", ast_config_AST_CONFIG_DIR, stripped_filename) == -1) {
            return -1;
        }
    } else {
        filepath = ast_strdup(stripped_filename);
    }
 
    /*
     * We can't call is_restricted_file() here because it uses realpath() and...
     *
     * realpath() and other functions that canonicalize paths won't work with
     * a filename that doesn't exist, so we need to separate the directory
     * from the filename and canonicalize the directory first.  We have to do
     * the separation manually because dirname() and basename() aren't all
     * that friendly to multi-threaded programs and there are different
     * versions of basename for glibc and POSIX.
     */
 
    filename = strrchr(filepath, '/');
    if (!filename) {
        astman_send_error(s, m, "Filename is invalid");
        return 0;
    }
    *filename = '\0';
    filename++;
 
    /* filepath just has the directory now so canonicalize it. */
    real_dir = realpath(filepath, NULL);
    if (ast_strlen_zero(real_dir)) {
        astman_send_error(s, m, strerror(errno));
        return 0;
    }
 
    /* Check if the directory is restricted. */
    if (!live_dangerously && !ast_begins_with(real_dir, ast_config_AST_CONFIG_DIR)) {
        astman_send_error(s, m, "File requires escalated privileges");
        return 0;
    }
 
    /* Create the final file path. */
    if (ast_asprintf(&real_path, "%s/%s", real_dir, filename) == -1) {
        astman_send_error(s, m, strerror(errno));
        return -1;
    }
 
    if ((fd = open(real_path, O_CREAT | O_EXCL, AST_FILE_MODE)) != -1) {
        close(fd);
        astman_send_ack(s, m, "New configuration file created successfully");
    } else {
        astman_send_error(s, m, strerror(errno));
    }
 
    return 0;
}

References ast_asprintf, ast_begins_with(), ast_config_AST_CONFIG_DIR, AST_FILE_MODE, ast_free, ast_std_free(), ast_strdup, ast_strdupa, ast_strip(), ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), errno, live_dangerously, NULL, and RAII_VAR.

Referenced by __init_manager().

action_destroy()

static void action_destroy ( void *  obj )

static

Definition at line 7809 of file manager.c.

{
    struct manager_action *doomed = obj;
 
    if (doomed->synopsis) {
        /* The string fields were initialized. */
        ast_string_field_free_memory(doomed);
    }
    ao2_cleanup(doomed->final_response);
    ao2_cleanup(doomed->list_responses);
}

References ao2_cleanup, ast_string_field_free_memory, manager_action::final_response, manager_action::list_responses, and manager_action::synopsis.

Referenced by ast_manager_register2().

action_events()

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

static

Definition at line 3308 of file manager.c.

{
    const char *mask = astman_get_header(m, "EventMask");
    int res, x;
    const char *id = astman_get_header(m, "ActionID");
    char id_text[256];
 
    if (!ast_strlen_zero(id)) {
        snprintf(id_text, sizeof(id_text), "ActionID: %s\r\n", id);
    } else {
        id_text[0] = '\0';
    }
 
    res = set_eventmask(s, mask);
    if (broken_events_action) {
        /* if this option is set we should not return a response on
         * error, or when all events are set */
 
        if (res > 0) {
            for (x = 0; x < ARRAY_LEN(perms); x++) {
                if (!strcasecmp(perms[x].label, "all") && res == perms[x].num) {
                    return 0;
                }
            }
            astman_append(s, "Response: Success\r\n%s"
                     "Events: On\r\n\r\n", id_text);
        } else if (res == 0)
            astman_append(s, "Response: Success\r\n%s"
                     "Events: Off\r\n\r\n", id_text);
        return 0;
    }
 
    if (res > 0)
        astman_append(s, "Response: Success\r\n%s"
                 "Events: On\r\n\r\n", id_text);
    else if (res == 0)
        astman_append(s, "Response: Success\r\n%s"
                 "Events: Off\r\n\r\n", id_text);
    else
        astman_send_error(s, m, "Invalid event mask");
 
    return 0;
}

References ARRAY_LEN, ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), broken_events_action, permalias::num, perms, and set_eventmask().

Referenced by __init_manager().

action_extensionstate()

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

static

Definition at line 5464 of file manager.c.

{
    const char *exten = astman_get_header(m, "Exten");
    const char *context = astman_get_header(m, "Context");
    char hint[256];
    int status;
 
    if (ast_strlen_zero(exten)) {
        astman_send_error(s, m, "Extension not specified");
        return 0;
    }
    if (ast_strlen_zero(context)) {
        context = "default";
    }
    status = ast_extension_state(NULL, context, exten);
    hint[0] = '\0';
    ast_get_hint(hint, sizeof(hint), NULL, 0, NULL, context, exten);
    astman_start_ack(s, m);
    astman_append(s, "Message: Extension Status\r\n"
        "Exten: %s\r\n"
        "Context: %s\r\n"
        "Hint: %s\r\n"
        "Status: %d\r\n"
        "StatusText: %s\r\n"
        "\r\n",
        exten, context, hint, status,
        ast_extension_state2str(status));
    return 0;
}

References ast_extension_state(), ast_extension_state2str(), ast_get_hint(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), astman_start_ack(), voicemailpwcheck::context, NULL, and status.

Referenced by __init_manager().

action_filter()

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

static

Manager command to add an event filter to a manager session.

See also

For more details look at manager_add_filter

Definition at line 5686 of file manager.c.

{
    const char *match_criteria = astman_get_header(m, "MatchCriteria");
    const char *filter = astman_get_header(m, "Filter");
    const char *operation = astman_get_header(m, "Operation");
    int res;
 
    if (!strcasecmp(operation, "Add")) {
        char *criteria;
        int have_match = !ast_strlen_zero(match_criteria);
 
        /* Create an eventfilter expression.
         * eventfilter[(match_criteria)]
         */
        res = ast_asprintf(&criteria, "eventfilter%s%s%s",
            S_COR(have_match, "(", ""), S_OR(match_criteria, ""),
            S_COR(have_match, ")", ""));
        if (res <= 0) {
            astman_send_error(s, m, "Internal Error. Failed to allocate storage for filter type");
            return 0;
        }
 
        res = manager_add_filter(criteria, filter, s->session->includefilters, s->session->excludefilters);
        ast_std_free(criteria);
        if (res != FILTER_SUCCESS) {
            if (res == FILTER_ALLOC_FAILED) {
                astman_send_error(s, m, "Internal Error. Failed to allocate regex for filter");
                return 0;
            } else if (res == FILTER_COMPILE_FAIL) {
                astman_send_error(s, m,
                    "Filter did not compile.  Check the syntax of the filter given.");
                return 0;
            } else if (res == FILTER_FORMAT_ERROR) {
                astman_send_error(s, m,
                    "Filter was formatted incorrectly.  Check the syntax of the filter given.");
                return 0;
            } else {
                astman_send_error(s, m, "Internal Error. Failed adding filter.");
                return 0;
            }
        }
 
        astman_send_ack(s, m, "Success");
        return 0;
    }
 
    astman_send_error(s, m, "Unknown operation");
    return 0;
}

References ast_asprintf, ast_std_free(), ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), mansession_session::excludefilters, filter(), FILTER_ALLOC_FAILED, FILTER_COMPILE_FAIL, FILTER_FORMAT_ERROR, FILTER_SUCCESS, mansession_session::includefilters, manager_add_filter(), S_COR, S_OR, and mansession::session.

Referenced by __init_manager().

action_find()

static struct manager_action * action_find ( const char *  name )

static

Definition at line 438 of file manager.c.

{
    struct manager_action *act;
 
    AST_RWLIST_RDLOCK(&actions);
    AST_RWLIST_TRAVERSE(&actions, act, list) {
        if (!strcasecmp(name, act->action)) {
            ao2_t_ref(act, +1, "found action object");
            break;
        }
    }
    AST_RWLIST_UNLOCK(&actions);
 
    return act;
}

References manager_action::action, ao2_t_ref, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, and name.

Referenced by ast_hook_send_action(), and process_message().

action_getconfig()

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

static

Definition at line 2501 of file manager.c.

{
    struct ast_config *cfg;
    const char *fn = astman_get_header(m, "Filename");
    const char *category = astman_get_header(m, "Category");
    const char *filter = astman_get_header(m, "Filter");
    const char *category_name;
    int catcount = 0;
    int lineno = 0;
    int ret = 0;
    struct ast_category *cur_category = NULL;
    struct ast_variable *v;
    struct ast_flags config_flags = { CONFIG_FLAG_WITHCOMMENTS | CONFIG_FLAG_NOCACHE };
 
    if (ast_strlen_zero(fn)) {
        astman_send_error(s, m, "Filename not specified");
        return 0;
    }
 
    ret = is_restricted_file(fn);
    if (ret == 1) {
        astman_send_error(s, m, "File requires escalated privileges");
        return 0;
    } else if (ret == -1) {
        astman_send_error(s, m, "Config file not found");
        return 0;
    }
 
    cfg = ast_config_load2(fn, "manager", config_flags);
    if (cfg == CONFIG_STATUS_FILEMISSING) {
        astman_send_error(s, m, "Config file not found");
        return 0;
    } else if (cfg == CONFIG_STATUS_FILEINVALID) {
        astman_send_error(s, m, "Config file has invalid format");
        return 0;
    }
 
    astman_start_ack(s, m);
    while ((cur_category = ast_category_browse_filtered(cfg, category, cur_category, filter))) {
        struct ast_str *templates;
 
        category_name = ast_category_get_name(cur_category);
        lineno = 0;
        astman_append(s, "Category-%06d: %s\r\n", catcount, category_name);
 
        if (ast_category_is_template(cur_category)) {
            astman_append(s, "IsTemplate-%06d: %d\r\n", catcount, 1);
        }
 
        if ((templates = ast_category_get_templates(cur_category))
            && ast_str_strlen(templates) > 0) {
            astman_append(s, "Templates-%06d: %s\r\n", catcount, ast_str_buffer(templates));
            ast_free(templates);
        }
 
        for (v = ast_category_first(cur_category); v; v = v->next) {
            astman_append(s, "Line-%06d-%06d: %s=%s\r\n", catcount, lineno++, v->name, v->value);
        }
 
        catcount++;
    }
 
    if (!ast_strlen_zero(category) && catcount == 0) { /* TODO: actually, a config with no categories doesn't even get loaded */
        astman_append(s, "No categories found\r\n");
    }
 
    ast_config_destroy(cfg);
    astman_append(s, "\r\n");
 
    return 0;
}

References ast_category_browse_filtered(), ast_category_first(), ast_category_get_name(), ast_category_get_templates(), ast_category_is_template(), ast_config_destroy(), ast_config_load2(), ast_free, ast_str_buffer(), ast_str_strlen(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), astman_start_ack(), CONFIG_FLAG_NOCACHE, CONFIG_FLAG_WITHCOMMENTS, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEMISSING, filter(), is_restricted_file(), ast_variable::name, ast_variable::next, NULL, templates, and ast_variable::value.

Referenced by __init_manager().

action_getconfigjson()

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

static

Definition at line 2649 of file manager.c.

{
    struct ast_config *cfg;
    const char *fn = astman_get_header(m, "Filename");
    const char *filter = astman_get_header(m, "Filter");
    const char *category = astman_get_header(m, "Category");
    struct ast_category *cur_category = NULL;
    const char *category_name;
    struct ast_variable *v;
    int comma1 = 0;
    struct ast_flags config_flags = { CONFIG_FLAG_WITHCOMMENTS | CONFIG_FLAG_NOCACHE };
 
    if (ast_strlen_zero(fn)) {
        astman_send_error(s, m, "Filename not specified");
        return 0;
    }
 
    if (is_restricted_file(fn)) {
        astman_send_error(s, m, "File requires escalated privileges");
        return 0;
    }
 
    if (!(cfg = ast_config_load2(fn, "manager", config_flags))) {
        astman_send_error(s, m, "Config file not found");
        return 0;
    } else if (cfg == CONFIG_STATUS_FILEINVALID) {
        astman_send_error(s, m, "Config file has invalid format");
        return 0;
    }
 
    astman_start_ack(s, m);
    astman_append(s, "JSON: {");
    while ((cur_category = ast_category_browse_filtered(cfg, category, cur_category, filter))) {
        int comma2 = 0;
        struct ast_str *templates;
 
        category_name = ast_category_get_name(cur_category);
        astman_append(s, "%s\"", comma1 ? "," : "");
        astman_append_json(s, category_name);
        astman_append(s, "\":{");
        comma1 = 1;
 
        if (ast_category_is_template(cur_category)) {
            astman_append(s, "\"istemplate\":1");
            comma2 = 1;
        }
 
        if ((templates = ast_category_get_templates(cur_category))
            && ast_str_strlen(templates) > 0) {
            astman_append(s, "%s", comma2 ? "," : "");
            astman_append(s, "\"templates\":\"%s\"", ast_str_buffer(templates));
            ast_free(templates);
            comma2 = 1;
        }
 
        for (v = ast_category_first(cur_category); v; v = v->next) {
            astman_append(s, "%s\"", comma2 ? "," : "");
            astman_append_json(s, v->name);
            astman_append(s, "\":\"");
            astman_append_json(s, v->value);
            astman_append(s, "\"");
            comma2 = 1;
        }
 
        astman_append(s, "}");
    }
    astman_append(s, "}\r\n\r\n");
 
    ast_config_destroy(cfg);
 
    return 0;
}

References ast_category_browse_filtered(), ast_category_first(), ast_category_get_name(), ast_category_get_templates(), ast_category_is_template(), ast_config_destroy(), ast_config_load2(), ast_free, ast_str_buffer(), ast_str_strlen(), ast_strlen_zero(), astman_append(), astman_append_json(), astman_get_header(), astman_send_error(), astman_start_ack(), CONFIG_FLAG_NOCACHE, CONFIG_FLAG_WITHCOMMENTS, CONFIG_STATUS_FILEINVALID, filter(), is_restricted_file(), ast_variable::name, ast_variable::next, NULL, templates, and ast_variable::value.

Referenced by __init_manager().

action_getvar()

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

static

Definition at line 3585 of file manager.c.

{
    struct ast_channel *c = NULL;
    const char *name = astman_get_header(m, "Channel");
    const char *varname = astman_get_header(m, "Variable");
    char *varval;
    char workspace[1024];
 
    if (ast_strlen_zero(varname)) {
        astman_send_error(s, m, "No variable specified");
        return 0;
    }
 
    /* We don't want users with insufficient permissions using certain functions. */
    if (!(function_capable_string_allowed_with_auths(varname, s->session->writeperm))) {
        astman_send_error(s, m, "GetVar Access Forbidden: Variable");
        return 0;
    }
 
    if (!ast_strlen_zero(name)) {
        if (!(c = ast_channel_get_by_name(name))) {
            astman_send_error(s, m, "No such channel");
            return 0;
        }
    }
 
    workspace[0] = '\0';
    if (varname[strlen(varname) - 1] == ')') {
        if (!c) {
            c = ast_dummy_channel_alloc();
            if (c) {
                ast_func_read(c, (char *) varname, workspace, sizeof(workspace));
            } else
                ast_log(LOG_ERROR, "Unable to allocate bogus channel for variable substitution.  Function results may be blank.\n");
        } else {
            ast_func_read(c, (char *) varname, workspace, sizeof(workspace));
        }
        varval = workspace;
    } else {
        pbx_retrieve_variable(c, varname, &varval, workspace, sizeof(workspace), NULL);
    }
 
    if (c) {
        c = ast_channel_unref(c);
    }
 
    astman_start_ack(s, m);
    astman_append(s, "Variable: %s\r\nValue: %s\r\n\r\n", varname, S_OR(varval, ""));
 
    return 0;
}

References ast_channel_get_by_name(), ast_channel_unref, ast_dummy_channel_alloc, ast_func_read(), ast_log, ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), astman_start_ack(), c, function_capable_string_allowed_with_auths(), LOG_ERROR, name, NULL, pbx_retrieve_variable(), S_OR, mansession::session, and mansession_session::writeperm.

Referenced by __init_manager().

action_hangup()

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

static

Definition at line 3546 of file manager.c.

{
    return ast_manager_hangup_helper(s, m,
        ast_channel_softhangup_withcause_locked, NULL);
}

References ast_channel_softhangup_withcause_locked(), ast_manager_hangup_helper(), and NULL.

Referenced by __init_manager().

action_listcategories()

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

static

Definition at line 2573 of file manager.c.

{
    struct ast_config *cfg;
    const char *fn = astman_get_header(m, "Filename");
    const char *match = astman_get_header(m, "Match");
    struct ast_category *category = NULL;
    struct ast_flags config_flags = { CONFIG_FLAG_WITHCOMMENTS | CONFIG_FLAG_NOCACHE };
    int catcount = 0;
    int ret = 0;
 
    if (ast_strlen_zero(fn)) {
        astman_send_error(s, m, "Filename not specified");
        return 0;
    }
 
    ret = is_restricted_file(fn);
    if (ret == 1) {
        astman_send_error(s, m, "File requires escalated privileges");
        return 0;
    } else if (ret == -1) {
        astman_send_error(s, m, "Config file not found");
        return 0;
    }
 
    if (!(cfg = ast_config_load2(fn, "manager", config_flags))) {
        astman_send_error(s, m, "Config file not found");
        return 0;
    } else if (cfg == CONFIG_STATUS_FILEINVALID) {
        astman_send_error(s, m, "Config file has invalid format");
        return 0;
    }
 
    astman_start_ack(s, m);
    while ((category = ast_category_browse_filtered(cfg, NULL, category, match))) {
        astman_append(s, "Category-%06d: %s\r\n", catcount, ast_category_get_name(category));
        catcount++;
    }
 
    if (catcount == 0) { /* TODO: actually, a config with no categories doesn't even get loaded */
        astman_append(s, "Error: no categories found\r\n");
    }
 
    ast_config_destroy(cfg);
    astman_append(s, "\r\n");
 
    return 0;
}

References ast_category_browse_filtered(), ast_category_get_name(), ast_config_destroy(), ast_config_load2(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), astman_start_ack(), CONFIG_FLAG_NOCACHE, CONFIG_FLAG_WITHCOMMENTS, CONFIG_STATUS_FILEINVALID, is_restricted_file(), match(), and NULL.

Referenced by __init_manager().

action_listcommands()

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

static

Definition at line 3289 of file manager.c.

{
    struct manager_action *cur;
    struct ast_str *temp = ast_str_alloca(MAX_AUTH_PERM_STRING);
 
    astman_start_ack(s, m);
    AST_RWLIST_RDLOCK(&actions);
    AST_RWLIST_TRAVERSE(&actions, cur, list) {
        if ((s->session->writeperm & cur->authority) || cur->authority == 0) {
            astman_append(s, "%s: %s (Priv: %s)\r\n",
                cur->action, cur->synopsis, authority_to_str(cur->authority, &temp));
        }
    }
    AST_RWLIST_UNLOCK(&actions);
    astman_append(s, "\r\n");
 
    return 0;
}

References manager_action::action, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_str_alloca, astman_append(), astman_start_ack(), manager_action::authority, authority_to_str(), MAX_AUTH_PERM_STRING, mansession::session, manager_action::synopsis, and mansession_session::writeperm.

Referenced by __init_manager().

action_loggerrotate()

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

static

Manager command "LoggerRotate" - reloads and rotates the logger in the same manner as the CLI command 'logger rotate'.

Definition at line 6830 of file manager.c.

{
    if (ast_logger_rotate()) {
        astman_send_error(s, m, "Failed to reload the logger and rotate log files");
        return 0;
    }
 
    astman_send_ack(s, m, "Reloaded the logger and rotated log files");
    return 0;
}

References ast_logger_rotate(), astman_send_ack(), and astman_send_error().

Referenced by __init_manager().

action_login()

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

static

Definition at line 3358 of file manager.c.

{
 
    /* still authenticated - don't process again */
    if (s->session->authenticated) {
        astman_send_ack(s, m, "Already authenticated");
        return 0;
    }
 
    if (authenticate(s, m)) {
        sleep(1);
        astman_send_error(s, m, "Authentication failed");
        return -1;
    }
    s->session->authenticated = 1;
    ast_atomic_fetchadd_int(&unauth_sessions, -1);
    if (manager_displayconnects(s->session)) {
        ast_verb(2, "%sManager '%s' logged on from %s\n", (s->session->managerid ? "HTTP " : ""), s->session->username, ast_sockaddr_stringify_addr(&s->session->addr));
    }
    astman_send_ack(s, m, "Authentication accepted");
    if ((s->session->send_events & EVENT_FLAG_SYSTEM)
        && (s->session->readperm & EVENT_FLAG_SYSTEM)
        && ast_test_flag(&ast_options, AST_OPT_FLAG_FULLY_BOOTED)) {
        struct ast_str *auth = ast_str_alloca(MAX_AUTH_PERM_STRING);
        const char *cat_str = authority_to_str(EVENT_FLAG_SYSTEM, &auth);
        long uptime = 0;
        long lastreloaded = 0;
        struct timeval tmp;
        struct timeval curtime = ast_tvnow();
 
        if (ast_startuptime.tv_sec) {
            tmp = ast_tvsub(curtime, ast_startuptime);
            uptime = tmp.tv_sec;
        }
 
        if (ast_lastreloadtime.tv_sec) {
            tmp = ast_tvsub(curtime, ast_lastreloadtime);
            lastreloaded = tmp.tv_sec;
        }
 
        astman_append(s, "Event: FullyBooted\r\n"
            "Privilege: %s\r\n"
            "Uptime: %ld\r\n"
            "LastReload: %ld\r\n"
            "Status: Fully Booted\r\n\r\n", cat_str, uptime, lastreloaded);
    }
    return 0;
}

References mansession_session::addr, ast_atomic_fetchadd_int(), ast_lastreloadtime, AST_OPT_FLAG_FULLY_BOOTED, ast_options, ast_sockaddr_stringify_addr(), ast_startuptime, ast_str_alloca, ast_test_flag, ast_tvnow(), ast_tvsub(), ast_verb, astman_append(), astman_send_ack(), astman_send_error(), authenticate(), mansession_session::authenticated, authority_to_str(), EVENT_FLAG_SYSTEM, manager_displayconnects(), mansession_session::managerid, MAX_AUTH_PERM_STRING, mansession_session::readperm, mansession_session::send_events, mansession::session, unauth_sessions, and mansession_session::username.

Referenced by __init_manager().

action_logoff()

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

static

Definition at line 3352 of file manager.c.

{
    astman_send_response(s, m, "Goodbye", "Thanks for all the fish.");
    return -1;
}

References astman_send_response().

Referenced by __init_manager().

action_mailboxcount()

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

static

Definition at line 5443 of file manager.c.

{
    const char *mailbox = astman_get_header(m, "Mailbox");
    int newmsgs = 0, oldmsgs = 0, urgentmsgs = 0;;
 
    if (ast_strlen_zero(mailbox)) {
        astman_send_error(s, m, "Mailbox not specified");
        return 0;
    }
    ast_app_inboxcount2(mailbox, &urgentmsgs, &newmsgs, &oldmsgs);
    astman_start_ack(s, m);
    astman_append(s,   "Message: Mailbox Message Count\r\n"
               "Mailbox: %s\r\n"
               "UrgMessages: %d\r\n"
               "NewMessages: %d\r\n"
               "OldMessages: %d\r\n"
               "\r\n",
               mailbox, urgentmsgs, newmsgs, oldmsgs);
    return 0;
}

References ast_app_inboxcount2(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), astman_start_ack(), and voicemailpwcheck::mailbox.

Referenced by __init_manager().

action_mailboxstatus()

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

static

Definition at line 5426 of file manager.c.

{
    const char *mailbox = astman_get_header(m, "Mailbox");
    int ret;
 
    if (ast_strlen_zero(mailbox)) {
        astman_send_error(s, m, "Mailbox not specified");
        return 0;
    }
    ret = ast_app_has_voicemail(mailbox, NULL);
    astman_start_ack(s, m);
    astman_append(s, "Message: Mailbox Status\r\n"
             "Mailbox: %s\r\n"
             "Waiting: %d\r\n\r\n", mailbox, ret);
    return 0;
}

References ast_app_has_voicemail(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), astman_start_ack(), voicemailpwcheck::mailbox, and NULL.

Referenced by __init_manager().

action_originate()

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

static

Definition at line 5231 of file manager.c.

{
    const char *name = astman_get_header(m, "Channel");
    const char *exten = astman_get_header(m, "Exten");
    const char *context = astman_get_header(m, "Context");
    const char *priority = astman_get_header(m, "Priority");
    const char *timeout = astman_get_header(m, "Timeout");
    const char *callerid = astman_get_header(m, "CallerID");
    const char *account = astman_get_header(m, "Account");
    const char *app = astman_get_header(m, "Application");
    const char *appdata = astman_get_header(m, "Data");
    const char *async = astman_get_header(m, "Async");
    const char *id = astman_get_header(m, "ActionID");
    const char *codecs = astman_get_header(m, "Codecs");
    const char *early_media = astman_get_header(m, "Earlymedia");
    struct ast_assigned_ids assignedids = {
        .uniqueid = astman_get_header(m, "ChannelId"),
        .uniqueid2 = astman_get_header(m, "OtherChannelId"),
    };
    const char *gosub = astman_get_header(m, "PreDialGoSub");
 
    struct ast_variable *vars = NULL;
    char *tech, *data;
    char *l = NULL, *n = NULL;
    int pi = 0;
    int res;
    int to = 30000;
    int reason = 0;
    char tmp[256];
    char tmp2[256];
    struct ast_format_cap *cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    pthread_t th;
    int bridge_early = 0;
 
    if (!cap) {
        astman_send_error(s, m, "Internal Error. Memory allocation failure.");
        return 0;
    }
    ast_format_cap_append(cap, ast_format_slin, 0);
 
    if ((assignedids.uniqueid && AST_MAX_PUBLIC_UNIQUEID < strlen(assignedids.uniqueid))
        || (assignedids.uniqueid2 && AST_MAX_PUBLIC_UNIQUEID < strlen(assignedids.uniqueid2))) {
        astman_send_error_va(s, m, "Uniqueid length exceeds maximum of %d\n",
            AST_MAX_PUBLIC_UNIQUEID);
        res = 0;
        goto fast_orig_cleanup;
    }
 
    if (ast_strlen_zero(name)) {
        astman_send_error(s, m, "Channel not specified");
        res = 0;
        goto fast_orig_cleanup;
    }
    if (!ast_strlen_zero(priority) && (sscanf(priority, "%30d", &pi) != 1)) {
        if ((pi = ast_findlabel_extension(NULL, context, exten, priority, NULL)) < 1) {
            astman_send_error(s, m, "Invalid priority");
            res = 0;
            goto fast_orig_cleanup;
        }
    }
    if (!ast_strlen_zero(timeout) && (sscanf(timeout, "%30d", &to) != 1)) {
        astman_send_error(s, m, "Invalid timeout");
        res = 0;
        goto fast_orig_cleanup;
    }
    ast_copy_string(tmp, name, sizeof(tmp));
    tech = tmp;
    data = strchr(tmp, '/');
    if (!data) {
        astman_send_error(s, m, "Invalid channel");
        res = 0;
        goto fast_orig_cleanup;
    }
    *data++ = '\0';
    ast_copy_string(tmp2, callerid, sizeof(tmp2));
    ast_callerid_parse(tmp2, &n, &l);
    if (n) {
        if (ast_strlen_zero(n)) {
            n = NULL;
        }
    }
    if (l) {
        ast_shrink_phone_number(l);
        if (ast_strlen_zero(l)) {
            l = NULL;
        }
    }
    if (!ast_strlen_zero(codecs)) {
        ast_format_cap_remove_by_type(cap, AST_MEDIA_TYPE_UNKNOWN);
        ast_format_cap_update_by_allow_disallow(cap, codecs, 1);
    }
 
    if (!ast_strlen_zero(app) && s->session) {
        if (!is_originate_app_permitted(app, appdata, s->session->writeperm)) {
            astman_send_error(s, m, "Originate Access Forbidden: app or data blacklisted");
            res = 0;
            goto fast_orig_cleanup;
        }
    }
 
    /* Check early if the extension exists. If not, we need to bail out here. */
    if (exten && context && pi) {
        if (! ast_exists_extension(NULL, context, exten, pi, l)) {
            /* The extension does not exist. */
            astman_send_error(s, m, "Extension does not exist.");
            res = 0;
            goto fast_orig_cleanup;
        }
    }
 
    /* Allocate requested channel variables */
    vars = astman_get_variables(m);
    if (s->session && s->session->chanvars) {
        struct ast_variable *v, *old;
        old = vars;
        vars = NULL;
 
        /* The variables in the AMI originate action are appended at the end of the list, to override any user variables that apply */
 
        vars = ast_variables_dup(s->session->chanvars);
        if (old) {
            for (v = vars; v->next; v = v->next );
            v->next = old;  /* Append originate variables at end of list */
        }
    }
 
    /* For originate async - we can bridge in early media stage */
    bridge_early = ast_true(early_media);
 
    if (ast_true(async)) {
        struct fast_originate_helper *fast;
 
        fast = ast_calloc(1, sizeof(*fast));
        if (!fast || ast_string_field_init(fast, 252)) {
            ast_free(fast);
            ast_variables_destroy(vars);
            res = -1;
        } else {
            if (!ast_strlen_zero(id)) {
                ast_string_field_build(fast, idtext, "ActionID: %s\r\n", id);
            }
            ast_string_field_set(fast, tech, tech);
            ast_string_field_set(fast, data, data);
            ast_string_field_set(fast, app, app);
            ast_string_field_set(fast, appdata, appdata);
            ast_string_field_set(fast, cid_num, l);
            ast_string_field_set(fast, cid_name, n);
            ast_string_field_set(fast, context, context);
            ast_string_field_set(fast, exten, exten);
            ast_string_field_set(fast, account, account);
            ast_string_field_set(fast, channelid, assignedids.uniqueid);
            ast_string_field_set(fast, otherchannelid, assignedids.uniqueid2);
            fast->vars = vars;
            fast->cap = cap;
            cap = NULL; /* transferred originate helper the capabilities structure.  It is now responsible for freeing it. */
            fast->timeout = to;
            fast->early_media = bridge_early;
            fast->priority = pi;
            if (ast_pthread_create_detached(&th, NULL, fast_originate, fast)) {
                destroy_fast_originate_helper(fast);
                res = -1;
            } else {
                res = 0;
            }
        }
    } else if (!ast_strlen_zero(app)) {
        res = ast_pbx_outgoing_app(tech, cap, data, to, app, appdata, &reason,
                AST_OUTGOING_WAIT, l, n, vars, account, NULL,
                assignedids.uniqueid ? &assignedids : NULL);
        ast_variables_destroy(vars);
    } else {
        if (exten && context && pi) {
            res = ast_pbx_outgoing_exten_predial(tech, cap, data, to,
                    context, exten, pi, &reason, AST_OUTGOING_WAIT,
                    l, n, vars, account, NULL, bridge_early,
                    assignedids.uniqueid ? &assignedids : NULL , gosub);
            ast_variables_destroy(vars);
        } else {
            astman_send_error(s, m, "Originate with 'Exten' requires 'Context' and 'Priority'");
            ast_variables_destroy(vars);
            res = 0;
            goto fast_orig_cleanup;
        }
    }
    if (!res) {
        astman_send_ack(s, m, "Originate successfully queued");
    } else {
        astman_send_error(s, m, "Originate failed");
    }
 
fast_orig_cleanup:
    ao2_cleanup(cap);
    return 0;
}

References ao2_cleanup, app, ast_callerid_parse(), ast_calloc, ast_copy_string(), ast_exists_extension(), ast_findlabel_extension(), ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_remove_by_type(), ast_format_cap_update_by_allow_disallow(), ast_format_slin, ast_free, AST_MAX_PUBLIC_UNIQUEID, AST_MEDIA_TYPE_UNKNOWN, AST_OUTGOING_WAIT, ast_pbx_outgoing_app(), ast_pbx_outgoing_exten_predial(), ast_pthread_create_detached, ast_shrink_phone_number(), ast_string_field_build, ast_string_field_init, ast_string_field_set, ast_strlen_zero(), ast_true(), ast_variables_destroy(), ast_variables_dup(), astman_get_header(), astman_get_variables(), astman_send_ack(), astman_send_error(), astman_send_error_va(), fast_originate_helper::cap, mansession_session::chanvars, codecs, voicemailpwcheck::context, destroy_fast_originate_helper(), fast_originate_helper::early_media, fast_originate(), is_originate_app_permitted(), name, ast_variable::next, NULL, priority, fast_originate_helper::priority, mansession::session, fast_originate_helper::timeout, ast_assigned_ids::uniqueid, ast_assigned_ids::uniqueid2, fast_originate_helper::vars, and mansession_session::writeperm.

Referenced by __init_manager().

action_ping()

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

static

Definition at line 2429 of file manager.c.

{
    const char *actionid = astman_get_header(m, "ActionID");
    struct timeval now = ast_tvnow();
 
    astman_append(s, "Response: Success\r\n");
    if (!ast_strlen_zero(actionid)){
        astman_append(s, "ActionID: %s\r\n", actionid);
    }
    astman_append(
        s,
        "Ping: Pong\r\n"
        "Timestamp: %ld.%06lu\r\n"
        "\r\n",
        (long) now.tv_sec, (unsigned long) now.tv_usec);
    return 0;
}

References ast_strlen_zero(), ast_tvnow(), astman_append(), and astman_get_header().

Referenced by __init_manager().

action_presencestate()

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

static

Definition at line 5494 of file manager.c.

{
    const char *provider = astman_get_header(m, "Provider");
    enum ast_presence_state state;
    char *subtype;
    char *message;
 
    if (ast_strlen_zero(provider)) {
        astman_send_error(s, m, "No provider specified");
        return 0;
    }
 
    state = ast_presence_state(provider, &subtype, &message);
    if (state == AST_PRESENCE_INVALID) {
        astman_send_error_va(s, m, "Invalid provider %s or provider in invalid state", provider);
        return 0;
    }
 
    astman_start_ack(s, m);
    astman_append(s, "Message: Presence State\r\n"
                     "State: %s\r\n", ast_presence_state2str(state));
 
    if (!ast_strlen_zero(subtype)) {
        astman_append(s, "Subtype: %s\r\n", subtype);
    }
 
    if (!ast_strlen_zero(message)) {
        /* XXX The Message header here is deprecated as it
         * duplicates the action response header 'Message'.
         * Remove it in the next major revision of AMI.
         */
        astman_append(s, "Message: %s\r\n"
                         "PresenceMessage: %s\r\n",
                         message, message);
    }
    astman_append(s, "\r\n");
 
    return 0;
}

References AST_PRESENCE_INVALID, ast_presence_state2str(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), astman_send_error_va(), astman_start_ack(), provider, and state.

Referenced by __init_manager().

action_redirect()

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

static

action_redirect: The redirect manager command

Definition at line 3957 of file manager.c.

{
    char buf[256];
    const char *name = astman_get_header(m, "Channel");
    const char *name2 = astman_get_header(m, "ExtraChannel");
    const char *exten = astman_get_header(m, "Exten");
    const char *exten2 = astman_get_header(m, "ExtraExten");
    const char *context = astman_get_header(m, "Context");
    const char *context2 = astman_get_header(m, "ExtraContext");
    const char *priority = astman_get_header(m, "Priority");
    const char *priority2 = astman_get_header(m, "ExtraPriority");
    struct ast_channel *chan;
    struct ast_channel *chan2;
    int pi = 0;
    int pi2 = 0;
    int res;
    int chan1_wait = 0;
    int chan2_wait = 0;
 
    if (ast_strlen_zero(name)) {
        astman_send_error(s, m, "Channel not specified");
        return 0;
    }
 
    if (ast_strlen_zero(context)) {
        astman_send_error(s, m, "Context not specified");
        return 0;
    }
    if (ast_strlen_zero(exten)) {
        astman_send_error(s, m, "Exten not specified");
        return 0;
    }
    if (ast_strlen_zero(priority)) {
        astman_send_error(s, m, "Priority not specified");
        return 0;
    }
    if (sscanf(priority, "%30d", &pi) != 1) {
        pi = ast_findlabel_extension(NULL, context, exten, priority, NULL);
    }
    if (pi < 1) {
        astman_send_error(s, m, "Priority is invalid");
        return 0;
    }
 
    if (!ast_strlen_zero(name2) && !ast_strlen_zero(context2)) {
        /* We have an ExtraChannel and an ExtraContext */
        if (ast_strlen_zero(exten2)) {
            astman_send_error(s, m, "ExtraExten not specified");
            return 0;
        }
        if (ast_strlen_zero(priority2)) {
            astman_send_error(s, m, "ExtraPriority not specified");
            return 0;
        }
        if (sscanf(priority2, "%30d", &pi2) != 1) {
            pi2 = ast_findlabel_extension(NULL, context2, exten2, priority2, NULL);
        }
        if (pi2 < 1) {
            astman_send_error(s, m, "ExtraPriority is invalid");
            return 0;
        }
    }
 
    chan = ast_channel_get_by_name(name);
    if (!chan) {
        snprintf(buf, sizeof(buf), "Channel does not exist: %s", name);
        astman_send_error(s, m, buf);
        return 0;
    }
    if (ast_check_hangup_locked(chan)) {
        astman_send_error(s, m, "Redirect failed, channel not up.");
        chan = ast_channel_unref(chan);
        return 0;
    }
 
    if (ast_strlen_zero(name2)) {
        /* Single channel redirect in progress. */
        res = async_goto_with_discard_bridge_after(chan, context, exten, pi);
        if (!res) {
            astman_send_ack(s, m, "Redirect successful");
        } else {
            astman_send_error(s, m, "Redirect failed");
        }
        chan = ast_channel_unref(chan);
        return 0;
    }
 
    chan2 = ast_channel_get_by_name(name2);
    if (!chan2) {
        snprintf(buf, sizeof(buf), "ExtraChannel does not exist: %s", name2);
        astman_send_error(s, m, buf);
        chan = ast_channel_unref(chan);
        return 0;
    }
    if (ast_check_hangup_locked(chan2)) {
        astman_send_error(s, m, "Redirect failed, extra channel not up.");
        chan2 = ast_channel_unref(chan2);
        chan = ast_channel_unref(chan);
        return 0;
    }
 
    /* Dual channel redirect in progress. */
    ast_channel_lock(chan);
    if (ast_channel_is_bridged(chan)) {
        ast_set_flag(ast_channel_flags(chan), AST_FLAG_BRIDGE_DUAL_REDIRECT_WAIT);
        chan1_wait = 1;
    }
    ast_channel_unlock(chan);
 
    ast_channel_lock(chan2);
    if (ast_channel_is_bridged(chan2)) {
        ast_set_flag(ast_channel_flags(chan2), AST_FLAG_BRIDGE_DUAL_REDIRECT_WAIT);
        chan2_wait = 1;
    }
    ast_channel_unlock(chan2);
 
    res = async_goto_with_discard_bridge_after(chan, context, exten, pi);
    if (!res) {
        if (!ast_strlen_zero(context2)) {
            res = async_goto_with_discard_bridge_after(chan2, context2, exten2, pi2);
        } else {
            res = async_goto_with_discard_bridge_after(chan2, context, exten, pi);
        }
        if (!res) {
            astman_send_ack(s, m, "Dual Redirect successful");
        } else {
            astman_send_error(s, m, "Secondary redirect failed");
        }
    } else {
        astman_send_error(s, m, "Redirect failed");
    }
 
    /* Release the bridge wait. */
    if (chan1_wait) {
        ast_channel_clear_flag(chan, AST_FLAG_BRIDGE_DUAL_REDIRECT_WAIT);
    }
    if (chan2_wait) {
        ast_channel_clear_flag(chan2, AST_FLAG_BRIDGE_DUAL_REDIRECT_WAIT);
    }
 
    chan2 = ast_channel_unref(chan2);
    chan = ast_channel_unref(chan);
    return 0;
}

References ast_channel_clear_flag(), ast_channel_flags(), ast_channel_get_by_name(), ast_channel_is_bridged(), ast_channel_lock, ast_channel_unlock, ast_channel_unref, ast_check_hangup_locked(), ast_findlabel_extension(), AST_FLAG_BRIDGE_DUAL_REDIRECT_WAIT, ast_set_flag, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), async_goto_with_discard_bridge_after(), buf, voicemailpwcheck::context, name, NULL, and priority.

Referenced by __init_manager().

action_reload()

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

static

Send a reload event.

Definition at line 6549 of file manager.c.

{
    const char *module = astman_get_header(m, "Module");
    enum ast_module_reload_result res = ast_module_reload(S_OR(module, NULL));
 
    switch (res) {
    case AST_MODULE_RELOAD_NOT_FOUND:
        astman_send_error(s, m, "No such module");
        break;
    case AST_MODULE_RELOAD_NOT_IMPLEMENTED:
        astman_send_error(s, m, "Module does not support reload");
        break;
    case AST_MODULE_RELOAD_ERROR:
        astman_send_error(s, m, "An unknown error occurred");
        break;
    case AST_MODULE_RELOAD_IN_PROGRESS:
        astman_send_error(s, m, "A reload is in progress");
        break;
    case AST_MODULE_RELOAD_UNINITIALIZED:
        astman_send_error(s, m, "Module not initialized");
        break;
    case AST_MODULE_RELOAD_QUEUED:
    case AST_MODULE_RELOAD_SUCCESS:
        /* Treat a queued request as success */
        astman_send_ack(s, m, "Module Reloaded");
        break;
    }
    return 0;
}

References ast_module_reload(), AST_MODULE_RELOAD_ERROR, AST_MODULE_RELOAD_IN_PROGRESS, AST_MODULE_RELOAD_NOT_FOUND, AST_MODULE_RELOAD_NOT_IMPLEMENTED, AST_MODULE_RELOAD_QUEUED, AST_MODULE_RELOAD_SUCCESS, AST_MODULE_RELOAD_UNINITIALIZED, astman_get_header(), astman_send_ack(), astman_send_error(), NULL, and S_OR.

Referenced by __init_manager().

action_sendtext()

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

static

Definition at line 3908 of file manager.c.

{
    struct ast_channel *c;
    const char *name = astman_get_header(m, "Channel");
    const char *textmsg = astman_get_header(m, "Message");
    const char *content_type = astman_get_header(m, "Content-Type");
    int res;
 
    if (ast_strlen_zero(name)) {
        astman_send_error(s, m, "No channel specified");
        return 0;
    }
 
    if (ast_strlen_zero(textmsg)) {
        astman_send_error(s, m, "No Message specified");
        return 0;
    }
 
    c = ast_channel_get_by_name(name);
    if (!c) {
        astman_send_error(s, m, "No such channel");
        return 0;
    }
 
    /*
     * If the "extra" data is not available, then send using "string" only.
     * Doing such maintains backward compatibilities.
     */
    res = ast_strlen_zero(content_type) ? queue_sendtext(c, textmsg) :
        queue_sendtext_data(c, textmsg, content_type);
 
    ast_channel_unref(c);
 
    if (res >= 0) {
        astman_send_ack(s, m, "Success");
    } else {
        astman_send_error(s, m, "Failure");
    }
 
    return 0;
}

References ast_channel_get_by_name(), ast_channel_unref, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), c, name, queue_sendtext(), and queue_sendtext_data().

Referenced by __init_manager().

action_setvar()

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

static

Definition at line 3552 of file manager.c.

{
    struct ast_channel *c = NULL;
    const char *name = astman_get_header(m, "Channel");
    const char *varname = astman_get_header(m, "Variable");
    const char *varval = astman_get_header(m, "Value");
    int res = 0;
 
    if (ast_strlen_zero(varname)) {
        astman_send_error(s, m, "No variable specified");
        return 0;
    }
 
    if (!ast_strlen_zero(name)) {
        if (!(c = ast_channel_get_by_name(name))) {
            astman_send_error(s, m, "No such channel");
            return 0;
        }
    }
 
    res = pbx_builtin_setvar_helper(c, varname, S_OR(varval, ""));
 
    if (c) {
        c = ast_channel_unref(c);
    }
    if (res == 0) {
        astman_send_ack(s, m, "Variable Set");
    } else {
        astman_send_error(s, m, "Variable not set");
    }
    return 0;
}

References ast_channel_get_by_name(), ast_channel_unref, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), c, name, NULL, pbx_builtin_setvar_helper(), and S_OR.

Referenced by __init_manager().

action_status()

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

static

Manager "status" command to show channels.

Definition at line 3752 of file manager.c.

{
    const char *name = astman_get_header(m, "Channel");
    const char *chan_variables = astman_get_header(m, "Variables");
    const char *all_chan_variables = astman_get_header(m, "AllVariables");
    int all_variables = 0;
    const char *id = astman_get_header(m, "ActionID");
    char *variables = ast_strdupa(S_OR(chan_variables, ""));
    struct ast_channel *chan;
    int channels = 0;
    int all = ast_strlen_zero(name); /* set if we want all channels */
    char id_text[256];
    struct ast_channel_iterator *it_chans = NULL;
    AST_DECLARE_APP_ARGS(vars,
        AST_APP_ARG(name)[100];
    );
 
    if (!ast_strlen_zero(all_chan_variables)) {
        all_variables = ast_true(all_chan_variables);
    }
 
    if (!(function_capable_string_allowed_with_auths(variables, s->session->writeperm))) {
        astman_send_error(s, m, "Status Access Forbidden: Variables");
        return 0;
    }
 
    if (all) {
        if (!(it_chans = ast_channel_iterator_all_new())) {
            astman_send_error(s, m, "Memory Allocation Failure");
            return 1;
        }
        chan = ast_channel_iterator_next(it_chans);
    } else {
        chan = ast_channel_get_by_name(name);
        if (!chan) {
            astman_send_error(s, m, "No such channel");
            return 0;
        }
    }
 
    astman_send_listack(s, m, "Channel status will follow", "start");
 
    if (!ast_strlen_zero(id)) {
        snprintf(id_text, sizeof(id_text), "ActionID: %s\r\n", id);
    } else {
        id_text[0] = '\0';
    }
 
    if (!ast_strlen_zero(chan_variables)) {
        AST_STANDARD_APP_ARGS(vars, variables);
    }
 
    /* if we look by name, we break after the first iteration */
    for (; chan; all ? chan = ast_channel_iterator_next(it_chans) : 0) {
        ast_channel_lock(chan);
 
        generate_status(s, chan, vars.name, vars.argc, all_variables, id_text, &channels);
 
        ast_channel_unlock(chan);
        chan = ast_channel_unref(chan);
    }
 
    if (it_chans) {
        ast_channel_iterator_destroy(it_chans);
    }
 
    astman_send_list_complete_start(s, m, "StatusComplete", channels);
    astman_append(s, "Items: %d\r\n", channels);
    astman_send_list_complete_end(s);
 
    return 0;
}

References AST_APP_ARG, ast_channel_get_by_name(), ast_channel_iterator_all_new(), ast_channel_iterator_destroy(), ast_channel_iterator_next(), ast_channel_lock, ast_channel_unlock, ast_channel_unref, AST_DECLARE_APP_ARGS, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_true(), astman_append(), astman_get_header(), astman_send_error(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), channels, function_capable_string_allowed_with_auths(), generate_status(), name, ast_channel::name, NULL, S_OR, mansession::session, and mansession_session::writeperm.

Referenced by __init_manager().

action_timeout()

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

static

Definition at line 5534 of file manager.c.

{
    struct ast_channel *c;
    const char *name = astman_get_header(m, "Channel");
    double timeout = atof(astman_get_header(m, "Timeout"));
    struct timeval when = { timeout, 0 };
 
    if (ast_strlen_zero(name)) {
        astman_send_error(s, m, "No channel specified");
        return 0;
    }
 
    if (!timeout || timeout < 0) {
        astman_send_error(s, m, "No timeout specified");
        return 0;
    }
 
    if (!(c = ast_channel_get_by_name(name))) {
        astman_send_error(s, m, "No such channel");
        return 0;
    }
 
    when.tv_usec = (timeout - when.tv_sec) * 1000000.0;
 
    ast_channel_lock(c);
    ast_channel_setwhentohangup_tv(c, when);
    ast_channel_unlock(c);
    c = ast_channel_unref(c);
 
    astman_send_ack(s, m, "Timeout Set");
 
    return 0;
}

References ast_channel_get_by_name(), ast_channel_lock, ast_channel_setwhentohangup_tv(), ast_channel_unlock, ast_channel_unref, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), c, and name.

Referenced by __init_manager().

action_updateconfig()

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

static

Definition at line 3006 of file manager.c.

{
    struct ast_config *cfg;
    const char *sfn = astman_get_header(m, "SrcFilename");
    const char *dfn = astman_get_header(m, "DstFilename");
    int res;
    const char *rld = astman_get_header(m, "Reload");
    int preserve_effective_context = CONFIG_SAVE_FLAG_PRESERVE_EFFECTIVE_CONTEXT;
    const char *preserve_effective_context_string = astman_get_header(m, "PreserveEffectiveContext");
    struct ast_flags config_flags = { CONFIG_FLAG_WITHCOMMENTS | CONFIG_FLAG_NOCACHE };
    enum error_type result;
 
    if (ast_strlen_zero(sfn) || ast_strlen_zero(dfn)) {
        astman_send_error(s, m, "Filename not specified");
        return 0;
    }
    if (is_restricted_file(sfn) || is_restricted_file(dfn)) {
        astman_send_error(s, m, "File requires escalated privileges");
        return 0;
    }
    if (!(cfg = ast_config_load2(sfn, "manager", config_flags))) {
        astman_send_error(s, m, "Config file not found");
        return 0;
    } else if (cfg == CONFIG_STATUS_FILEINVALID) {
        astman_send_error(s, m, "Config file has invalid format");
        return 0;
    }
    result = handle_updates(s, m, cfg, dfn);
    if (!result) {
        ast_include_rename(cfg, sfn, dfn); /* change the include references from dfn to sfn, so things match up */
        if (!ast_strlen_zero(preserve_effective_context_string) && !ast_true(preserve_effective_context_string)) {
            preserve_effective_context = CONFIG_SAVE_FLAG_NONE;
        }
        res = ast_config_text_file_save2(dfn, cfg, "Manager", preserve_effective_context);
        ast_config_destroy(cfg);
        if (res) {
            astman_send_error(s, m, "Save of config failed");
            return 0;
        }
        astman_send_ack(s, m, NULL);
        if (!ast_strlen_zero(rld)) {
            if (ast_true(rld)) {
                ast_module_reload(NULL); /* Reload everything */
            } else if (!ast_false(rld)) {
                ast_module_reload(rld); /* Reload the specific module */
            }
        }
    } else {
        ast_config_destroy(cfg);
        switch(result) {
        case UNKNOWN_ACTION:
            astman_send_error(s, m, "Unknown action command");
            break;
        case UNKNOWN_CATEGORY:
            astman_send_error(s, m, "Given category does not exist");
            break;
        case UNSPECIFIED_CATEGORY:
            astman_send_error(s, m, "Category not specified");
            break;
        case UNSPECIFIED_ARGUMENT:
            astman_send_error(s, m, "Problem with category, value, or line (if required)");
            break;
        case FAILURE_ALLOCATION:
            astman_send_error(s, m, "Memory allocation failure, this should not happen");
            break;
        case FAILURE_NEWCAT:
            astman_send_error(s, m, "Create category did not complete successfully");
            break;
        case FAILURE_DELCAT:
            astman_send_error(s, m, "Delete category did not complete successfully");
            break;
        case FAILURE_EMPTYCAT:
            astman_send_error(s, m, "Empty category did not complete successfully");
            break;
        case FAILURE_UPDATE:
            astman_send_error(s, m, "Update did not complete successfully");
            break;
        case FAILURE_DELETE:
            astman_send_error(s, m, "Delete did not complete successfully");
            break;
        case FAILURE_APPEND:
            astman_send_error(s, m, "Append did not complete successfully");
            break;
        case FAILURE_TEMPLATE:
            astman_send_error(s, m, "Template category not found");
            break;
        }
    }
    return 0;
}

References ast_config_destroy(), ast_config_load2(), ast_config_text_file_save2(), ast_false(), ast_include_rename(), ast_module_reload(), ast_strlen_zero(), ast_true(), astman_get_header(), astman_send_ack(), astman_send_error(), CONFIG_FLAG_NOCACHE, CONFIG_FLAG_WITHCOMMENTS, CONFIG_SAVE_FLAG_NONE, CONFIG_SAVE_FLAG_PRESERVE_EFFECTIVE_CONTEXT, CONFIG_STATUS_FILEINVALID, FAILURE_ALLOCATION, FAILURE_APPEND, FAILURE_DELCAT, FAILURE_DELETE, FAILURE_EMPTYCAT, FAILURE_NEWCAT, FAILURE_TEMPLATE, FAILURE_UPDATE, handle_updates(), is_restricted_file(), NULL, result, UNKNOWN_ACTION, UNKNOWN_CATEGORY, UNSPECIFIED_ARGUMENT, and UNSPECIFIED_CATEGORY.

Referenced by __init_manager().

action_userevent()

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

static

Definition at line 6442 of file manager.c.

{
    const char *event = astman_get_header(m, "UserEvent");
    struct ast_str *body = ast_str_thread_get(&userevent_buf, 16);
    int x;
 
    ast_str_reset(body);
 
    for (x = 0; x < m->hdrcount; x++) {
        if (strncasecmp("UserEvent:", m->headers[x], strlen("UserEvent:")) &&
                strncasecmp("Action:", m->headers[x], strlen("Action:"))) {
            ast_str_append(&body, 0, "%s\r\n", m->headers[x]);
        }
    }
 
    astman_send_ack(s, m, "Event Sent");
    manager_event(EVENT_FLAG_USER, "UserEvent", "UserEvent: %s\r\n%s", event, ast_str_buffer(body));
    return 0;
}

References ast_str_append(), ast_str_buffer(), ast_str_reset(), ast_str_thread_get(), astman_get_header(), astman_send_ack(), EVENT_FLAG_USER, message::hdrcount, message::headers, manager_event, and userevent_buf.

Referenced by __init_manager().

action_waitevent()

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

static

Definition at line 3171 of file manager.c.

{
    const char *timeouts = astman_get_header(m, "Timeout");
    int timeout = -1;
    int x;
    int needexit = 0;
    const char *id = astman_get_header(m, "ActionID");
    char idText[256];
 
    if (!ast_strlen_zero(id)) {
        snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
    } else {
        idText[0] = '\0';
    }
 
    if (!ast_strlen_zero(timeouts)) {
        sscanf(timeouts, "%30i", &timeout);
        if (timeout < -1) {
            timeout = -1;
        }
        /* XXX maybe put an upper bound, or prevent the use of 0 ? */
    }
 
    ast_mutex_lock(&s->session->notify_lock);
    if (s->session->waiting_thread != AST_PTHREADT_NULL) {
        pthread_kill(s->session->waiting_thread, SIGURG);
    }
    ast_mutex_unlock(&s->session->notify_lock);
 
    ao2_lock(s->session);
 
    if (s->session->managerid) { /* AMI-over-HTTP session */
        /*
         * Make sure the timeout is within the expire time of the session,
         * as the client will likely abort the request if it does not see
         * data coming after some amount of time.
         */
        time_t now = time(NULL);
        int max = s->session->sessiontimeout - now - 10;
 
        if (max < 0) {  /* We are already late. Strange but possible. */
            max = 0;
        }
        if (timeout < 0 || timeout > max) {
            timeout = max;
        }
        if (!s->session->send_events) { /* make sure we record events */
            s->session->send_events = -1;
        }
    }
    ao2_unlock(s->session);
 
    ast_mutex_lock(&s->session->notify_lock);
    s->session->waiting_thread = pthread_self();    /* let new events wake up this thread */
    ast_mutex_unlock(&s->session->notify_lock);
    ast_debug(1, "Starting waiting for an event!\n");
 
    for (x = 0; x < timeout || timeout < 0; x++) {
        ao2_lock(s->session);
        if (AST_RWLIST_NEXT(s->session->last_ev, eq_next)) {
            needexit = 1;
        }
        if (s->session->needdestroy) {
            needexit = 1;
        }
        ao2_unlock(s->session);
        /* We can have multiple HTTP session point to the same mansession entry.
         * The way we deal with it is not very nice: newcomers kick out the previous
         * HTTP session. XXX this needs to be improved.
         */
        ast_mutex_lock(&s->session->notify_lock);
        if (s->session->waiting_thread != pthread_self()) {
            needexit = 1;
        }
        ast_mutex_unlock(&s->session->notify_lock);
        if (needexit) {
            break;
        }
        if (s->session->managerid == 0) {   /* AMI session */
            if (ast_wait_for_input(ast_iostream_get_fd(s->session->stream), 1000)) {
                break;
            }
        } else {    /* HTTP session */
            sleep(1);
        }
    }
    ast_debug(1, "Finished waiting for an event!\n");
 
    ast_mutex_lock(&s->session->notify_lock);
    if (s->session->waiting_thread == pthread_self()) {
        struct eventqent *eqe = s->session->last_ev;
 
        s->session->waiting_thread = AST_PTHREADT_NULL;
        ast_mutex_unlock(&s->session->notify_lock);
 
        ao2_lock(s->session);
        astman_send_response(s, m, "Success", "Waiting for Event completed.");
        while ((eqe = advance_event(eqe))) {
            if (((s->session->readperm & eqe->category) == eqe->category)
                && ((s->session->send_events & eqe->category) == eqe->category)
                && should_send_event(s->session->includefilters, s->session->excludefilters, eqe)) {
                astman_append(s, "%s", eqe->eventdata);
            }
            s->session->last_ev = eqe;
        }
        astman_append(s,
            "Event: WaitEventComplete\r\n"
            "%s"
            "\r\n", idText);
        ao2_unlock(s->session);
    } else {
        ast_mutex_unlock(&s->session->notify_lock);
        ast_debug(1, "Abandoning event request!\n");
    }
 
    return 0;
}

References advance_event(), ao2_lock, ao2_unlock, ast_debug, ast_iostream_get_fd(), ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, AST_RWLIST_NEXT, ast_strlen_zero(), ast_wait_for_input(), astman_append(), astman_get_header(), astman_send_response(), eventqent::category, mansession_session::excludefilters, mansession_session::includefilters, mansession_session::last_ev, mansession_session::managerid, max, mansession_session::needdestroy, mansession_session::notify_lock, NULL, mansession_session::readperm, mansession_session::send_events, mansession::session, mansession_session::sessiontimeout, should_send_event(), mansession_session::stream, and mansession_session::waiting_thread.

Referenced by __init_manager().

advance_event()

static struct eventqent * advance_event ( struct eventqent *  e )

static

Definition at line 1580 of file manager.c.

{
    struct eventqent *next;
 
    AST_RWLIST_RDLOCK(&all_events);
    if ((next = AST_RWLIST_NEXT(e, eq_next))) {
        ast_atomic_fetchadd_int(&next->usecount, 1);
        ast_atomic_fetchadd_int(&e->usecount, -1);
    }
    AST_RWLIST_UNLOCK(&all_events);
    return next;
}

References ast_atomic_fetchadd_int(), AST_RWLIST_NEXT, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, and eventqent::usecount.

Referenced by action_waitevent(), and process_events().

AO2_GLOBAL_OBJ_STATIC() [1/2]

static AO2_GLOBAL_OBJ_STATIC ( event_docs  )

static

A container of event documentation nodes.

AO2_GLOBAL_OBJ_STATIC() [2/2]

static AO2_GLOBAL_OBJ_STATIC ( mgr_sessions  )

static

Active manager connection sessions container.

aocmessage_get_unit_entry()

static int aocmessage_get_unit_entry ( const struct message *  m, struct ast_aoc_unit_entry *  entry, unsigned int  entry_num  )

static

Definition at line 4475 of file manager.c.

{
    const char *unitamount;
    const char *unittype;
    struct ast_str *str = ast_str_alloca(32);
 
    memset(entry, 0, sizeof(*entry));
 
    ast_str_set(&str, 0, "UnitAmount(%u)", entry_num);
    unitamount = astman_get_header(m, ast_str_buffer(str));
 
    ast_str_set(&str, 0, "UnitType(%u)", entry_num);
    unittype = astman_get_header(m, ast_str_buffer(str));
 
    if (!ast_strlen_zero(unitamount) && (sscanf(unitamount, "%30u", &entry->amount) == 1)) {
        entry->valid_amount = 1;
    }
 
    if (!ast_strlen_zero(unittype) && sscanf(unittype, "%30u", &entry->type) == 1) {
        entry->valid_type = 1;
    }
 
    return 0;
}

References ast_aoc_unit_entry::amount, ast_str_alloca, ast_str_buffer(), ast_str_set(), ast_strlen_zero(), astman_get_header(), str, ast_aoc_unit_entry::type, ast_aoc_unit_entry::valid_amount, and ast_aoc_unit_entry::valid_type.

Referenced by action_aoc_de_message().

app_match()

static int app_match ( const char *  app, const char *  data, const char *  search  )

static

Definition at line 5013 of file manager.c.

{
    /*
     * We use strcasestr so we don't have to trim any blanks
     * from the front or back of the string.
     */
    return !!(strcasestr(app, search));
}

References app, and strcasestr().

appdata_match()

static int appdata_match ( const char *  app, const char *  data, const char *  search  )

static

Definition at line 5032 of file manager.c.

{
    if (ast_strlen_zero(data)) {
        return 0;
    }
    return !!(strstr(data, search));
}

References ast_strlen_zero().

append_channel_vars()

static void append_channel_vars ( struct ast_str **  pbuf, struct ast_channel *  chan  )

static

Definition at line 7520 of file manager.c.

{
    struct varshead *vars;
    struct ast_var_t *var;
 
    vars = ast_channel_get_manager_vars(chan);
    if (!vars) {
        return;
    }
 
    AST_LIST_TRAVERSE(vars, var, entries) {
        ast_str_append(pbuf, 0, "ChanVariable(%s): %s=%s\r\n", ast_channel_name(chan), var->name, var->value);
    }
    ao2_ref(vars, -1);
}

References ao2_ref, ast_channel_get_manager_vars(), ast_channel_name(), AST_LIST_TRAVERSE, ast_str_append(), and var.

Referenced by __manager_event_sessions_va().

append_event()

static int append_event ( const char *  str, int  event_name_hash, int  category  )

static

events are appended to a queue from where they can be dispatched to clients.

Definition at line 7495 of file manager.c.

{
    struct eventqent *tmp = ast_malloc(sizeof(*tmp) + strlen(str));
    static int seq; /* sequence number */
 
    if (!tmp) {
        return -1;
    }
 
    /* need to init all fields, because ast_malloc() does not */
    tmp->usecount = 0;
    tmp->category = category;
    tmp->seq = ast_atomic_fetchadd_int(&seq, 1);
    tmp->tv = ast_tvnow();
    tmp->event_name_hash = event_name_hash;
    AST_RWLIST_NEXT(tmp, eq_next) = NULL;
    strcpy(tmp->eventdata, str);
 
    AST_RWLIST_WRLOCK(&all_events);
    AST_RWLIST_INSERT_TAIL(&all_events, tmp, eq_next);
    AST_RWLIST_UNLOCK(&all_events);
 
    return 0;
}

References ast_atomic_fetchadd_int(), ast_malloc, AST_RWLIST_INSERT_TAIL, AST_RWLIST_NEXT, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_tvnow(), eventqent::category, eventqent::event_name_hash, NULL, seq, eventqent::seq, str, eventqent::tv, and eventqent::usecount.

Referenced by __init_manager(), and __manager_event_sessions_va().

ast_hook_send_action()

int ast_hook_send_action	(	struct manager_custom_hook *	hook,
		const char *	msg
	)

access for hooks to send action messages to ami

Registered hooks can call this function to invoke actions and they will receive responses through registered callback.

Definition at line 1764 of file manager.c.

{
    const char *action;
    int ret = 0;
    struct manager_action *act_found;
    struct mansession s = {.session = NULL, };
    struct message m = { 0 };
    char *dup_str;
    char *src;
    int x = 0;
    int curlen;
 
    if (hook == NULL) {
        return -1;
    }
 
    /* Create our own copy of the AMI action msg string. */
    src = dup_str = ast_strdup(msg);
    if (!dup_str) {
        return -1;
    }
 
    /* convert msg string to message struct */
    curlen = strlen(src);
    for (x = 0; x < curlen; x++) {
        int cr; /* set if we have \r */
        if (src[x] == '\r' && x+1 < curlen && src[x+1] == '\n')
            cr = 2; /* Found. Update length to include \r\n */
        else if (src[x] == '\n')
            cr = 1; /* also accept \n only */
        else
            continue;
        /* don't keep empty lines */
        if (x && m.hdrcount < ARRAY_LEN(m.headers)) {
            /* ... but trim \r\n and terminate the header string */
            src[x] = '\0';
            m.headers[m.hdrcount++] = src;
        }
        x += cr;
        curlen -= x;        /* remaining size */
        src += x;       /* update pointer */
        x = -1;         /* reset loop */
    }
 
    action = astman_get_header(&m, "Action");
 
    do {
        if (!strcasecmp(action, "login")) {
            break;
        }
 
        act_found = action_find(action);
        if (!act_found) {
            break;
        }
 
        /*
         * we have to simulate a session for this action request
         * to be able to pass it down for processing
         * This is necessary to meet the previous design of manager.c
         */
        s.hook = hook;
 
        ret = -1;
        ao2_lock(act_found);
        if (act_found->registered && act_found->func) {
            struct ast_module *mod_ref = ast_module_running_ref(act_found->module);
 
            ao2_unlock(act_found);
            /* If the action is in a module it must be running. */
            if (!act_found->module || mod_ref) {
                ret = act_found->func(&s, &m);
                ast_module_unref(mod_ref);
            }
        } else {
            ao2_unlock(act_found);
        }
        ao2_t_ref(act_found, -1, "done with found action object");
    } while (0);
 
    ast_free(dup_str);
    return ret;
}

References action_find(), ao2_lock, ao2_t_ref, ao2_unlock, ARRAY_LEN, ast_free, ast_module_running_ref, ast_module_unref, ast_strdup, astman_get_header(), manager_action::func, message::hdrcount, message::headers, mansession::hook, manager_action::module, NULL, manager_action::registered, and mansession::session.

Referenced by hook_send().

ast_instring()

static int ast_instring ( const char *  bigstr, const char *  smallstr, const char  delim  )

static

Tells you if smallstr exists inside bigstr which is delim by delim and uses no buf or stringsep ast_instring("this|that|more","this",'|') == 1;

feel free to move this to app.c -anthm

Definition at line 847 of file manager.c.

{
    const char *val = bigstr, *next;
 
    do {
        if ((next = strchr(val, delim))) {
            if (!strncmp(val, smallstr, (next - val))) {
                return 1;
            } else {
                continue;
            }
        } else {
            return !strcmp(smallstr, val);
        }
    } while (*(val = (next + 1)));
 
    return 0;
}

Referenced by get_perm().

ast_manager_check_enabled()

int ast_manager_check_enabled

(

void

)

Check if AMI is enabled.

Definition at line 684 of file manager.c.

{
    return manager_enabled;
}

References manager_enabled.

Referenced by handle_show_settings().

ast_manager_get_message_router()

struct stasis_message_router * ast_manager_get_message_router

(

void

)

Get the stasis_message_router for AMI.

Since

12

Returns

The stasis_message_router for AMI

Return values

NULL

on error

Definition at line 459 of file manager.c.

{
    return stasis_router;
}

References stasis_router.

Referenced by manager_bridging_init(), manager_channels_init(), manager_mwi_init(), and manager_system_init().

ast_manager_get_topic()

struct stasis_topic * ast_manager_get_topic

(

void

)

Get the Stasis Message Bus API topic for AMI.

Since

12

Returns

The Stasis Message Bus API topic for AMI

Return values

NULL

on error

Definition at line 454 of file manager.c.

{
    return manager_topic;
}

References manager_topic.

Referenced by aoc_publish_blob(), ast_manager_publish_event(), endpoint_state_cb(), load_module(), manager_bridging_init(), manager_channels_init(), manager_mwi_init(), manager_system_init(), pbx_load_users(), publish_load_message_type(), queue_publish_member_blob(), and stasis_app_user_event().

ast_manager_hangup_helper()

int ast_manager_hangup_helper	(	struct mansession *	s,
		const struct message *	m,
		manager_hangup_handler_t	handler,
		manager_hangup_cause_validator_t	cause_validator
	)

A manager helper function that hangs up a channel using a supplied channel type specific hangup function and cause code validator.

This function handles the lookup of channel(s) and the AMI interaction but uses the supplied callbacks to actually perform the hangup. It can be used to implement a custom AMI 'Hangup' action without having to duplicate all the code in the standard Hangup action.

Parameters

s	Session
m	Message
handler	Function that actually performs the hangup
cause_validator	Function that validates the cause code

Return values

0	on success.
non-zero	on error.

Definition at line 3425 of file manager.c.

{
    struct ast_channel *c = NULL;
    int causecode = 0; /* all values <= 0 mean 'do not set hangupcause in channel' */
    const char *id = astman_get_header(m, "ActionID");
    const char *name_or_regex = astman_get_header(m, "Channel");
    const char *cause = astman_get_header(m, "Cause");
    char idText[256];
    regex_t regexbuf;
    struct ast_channel_iterator *iter = NULL;
    struct ast_str *regex_string;
    int channels_matched = 0;
 
    if (ast_strlen_zero(name_or_regex)) {
        astman_send_error(s, m, "No channel specified");
        return 0;
    }
 
    if (!ast_strlen_zero(id)) {
        snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
    } else {
        idText[0] = '\0';
    }
 
    if (cause_validator) {
        causecode = cause_validator(name_or_regex, cause);
    } else if (!ast_strlen_zero(cause)) {
        char *endptr;
        causecode = strtol(cause, &endptr, 10);
        if (causecode < 0 || causecode > 127 || *endptr != '\0') {
            ast_log(LOG_NOTICE, "Invalid 'Cause: %s' in manager action Hangup\n", cause);
            /* keep going, better to hangup without cause than to not hang up at all */
            causecode = 0; /* do not set channel's hangupcause */
        }
    }
 
    /************************************************/
    /* Regular explicit match channel byname hangup */
 
    if (name_or_regex[0] != '/') {
        if (!(c = ast_channel_get_by_name(name_or_regex))) {
            ast_log(LOG_NOTICE, "Request to hangup non-existent channel: %s\n",
                name_or_regex);
            astman_send_error(s, m, "No such channel");
            return 0;
        }
 
        ast_verb(3, "%sManager '%s' from %s, hanging up channel: %s\n",
            (s->session->managerid ? "HTTP " : ""),
            s->session->username,
            ast_sockaddr_stringify_addr(&s->session->addr),
            ast_channel_name(c));
 
        hangup_handler(c, causecode);
        c = ast_channel_unref(c);
 
        astman_send_ack(s, m, "Channel Hungup");
 
        return 0;
    }
 
    /***********************************************/
    /* find and hangup any channels matching regex */
 
    regex_string = ast_str_create(strlen(name_or_regex));
    if (!regex_string) {
        astman_send_error(s, m, "Memory Allocation Failure");
        return 0;
    }
 
    /* Make "/regex/" into "regex" */
    if (ast_regex_string_to_regex_pattern(name_or_regex, &regex_string) != 0) {
        astman_send_error(s, m, "Regex format invalid, Channel param should be /regex/");
        ast_free(regex_string);
        return 0;
    }
 
    /* if regex compilation fails, hangup fails */
    if (regcomp(&regexbuf, ast_str_buffer(regex_string), REG_EXTENDED | REG_NOSUB)) {
        astman_send_error_va(s, m, "Regex compile failed on: %s", name_or_regex);
        ast_free(regex_string);
        return 0;
    }
 
    astman_send_listack(s, m, "Channels hung up will follow", "start");
 
    iter = ast_channel_iterator_all_new();
    if (iter) {
        for (; (c = ast_channel_iterator_next(iter)); ast_channel_unref(c)) {
            if (regexec(&regexbuf, ast_channel_name(c), 0, NULL, 0)) {
                continue;
            }
 
            ast_verb(3, "%sManager '%s' from %s, hanging up channel: %s\n",
                (s->session->managerid ? "HTTP " : ""),
                s->session->username,
                ast_sockaddr_stringify_addr(&s->session->addr),
                ast_channel_name(c));
 
            hangup_handler(c, causecode);
            channels_matched++;
 
            astman_append(s,
                "Event: ChannelHungup\r\n"
                "Channel: %s\r\n"
                "%s"
                "\r\n", ast_channel_name(c), idText);
        }
        ast_channel_iterator_destroy(iter);
    }
 
    regfree(&regexbuf);
    ast_free(regex_string);
 
    astman_send_list_complete(s, m, "ChannelsHungupListComplete", channels_matched);
 
    return 0;
}

References mansession_session::addr, ast_channel_get_by_name(), ast_channel_iterator_all_new(), ast_channel_iterator_destroy(), ast_channel_iterator_next(), ast_channel_name(), ast_channel_unref, ast_free, ast_log, ast_regex_string_to_regex_pattern(), ast_sockaddr_stringify_addr(), ast_str_buffer(), ast_str_create, ast_strlen_zero(), ast_verb, astman_append(), astman_get_header(), astman_send_ack(), astman_send_error(), astman_send_error_va(), astman_send_list_complete(), astman_send_listack(), c, LOG_NOTICE, mansession_session::managerid, NULL, mansession::session, and mansession_session::username.

Referenced by action_hangup(), and pjsip_action_hangup().

ast_manager_publish_event()

void ast_manager_publish_event	(	const char *	type,
		int	class_type,
		struct ast_json *	obj
	)

Publish an event to AMI.

Since

12

Parameters

type	The type of AMI event to publish
class_type	The class on which to publish the event
obj	The event data to be published.

Publishes a message to the Stasis Message Bus API message bus solely for the consumption of AMI. The message will be of the type provided by ast_manager_get_generic_type, and will be published to the topic provided by ast_manager_get_topic. As such, the JSON must be constructed as defined by the ast_manager_get_generic_type message.

Definition at line 638 of file manager.c.

{
    RAII_VAR(struct ast_json *, event_info, NULL, ast_json_unref);
    RAII_VAR(struct ast_json_payload *, payload, NULL, ao2_cleanup);
    RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
 
    if (!obj || !ast_manager_get_generic_type()) {
        return;
    }
 
    ast_json_ref(obj);
    event_info = ast_json_pack("{s: s, s: i, s: o}",
            "type", type,
            "class_type", class_type,
            "event", obj);
    if (!event_info) {
        return;
    }
 
    payload = ast_json_payload_create(event_info);
    if (!payload) {
        return;
    }
    message = stasis_message_create(ast_manager_get_generic_type(), payload);
    if (!message) {
        return;
    }
    stasis_publish(ast_manager_get_topic(), message);
}

References ao2_cleanup, ast_json_pack(), ast_json_payload_create(), ast_json_ref(), ast_json_unref(), ast_manager_get_generic_type(), ast_manager_get_topic(), NULL, RAII_VAR, stasis_message_create(), stasis_publish(), and type.

Referenced by analog_publish_channel_alarm_clear(), analog_publish_dnd_state(), publish_channel_alarm(), publish_channel_alarm_clear(), publish_dnd_state(), publish_fully_booted(), publish_span_alarm(), publish_span_alarm_clear(), really_quit(), and reset_user_pw().

ast_manager_register2()

int ast_manager_register2	(	const char *	action,
		int	auth,
		int(*)(struct mansession *s, const struct message *m)	func,
		struct ast_module *	module,
		const char *	synopsis,
		const char *	description
	)

register a new command with manager, including online help. This is the preferred way to register a manager command

Register a manager command with the manager interface.

Definition at line 7823 of file manager.c.

{
    struct manager_action *cur;
 
    cur = ao2_t_alloc(sizeof(*cur), action_destroy, action);
    if (!cur) {
        return -1;
    }
    if (ast_string_field_init(cur, 128)) {
        ao2_t_ref(cur, -1, "action object creation failed");
        return -1;
    }
 
    if (ast_string_field_init_extended(cur, since)) {
        ao2_t_ref(cur, -1, "action object creation failed");
        return -1;
    }
 
    cur->action = action;
    cur->authority = auth;
    cur->func = func;
    cur->module = module;
#ifdef AST_XML_DOCS
    if (ast_strlen_zero(synopsis) && ast_strlen_zero(description)) {
        char *tmpxml;
 
        tmpxml = ast_xmldoc_build_since("manager", action, NULL);
        ast_string_field_set(cur, since, tmpxml);
        ast_free(tmpxml);
 
        tmpxml = ast_xmldoc_build_synopsis("manager", action, NULL);
        ast_string_field_set(cur, synopsis, tmpxml);
        ast_free(tmpxml);
 
        tmpxml = ast_xmldoc_build_syntax("manager", action, NULL);
        ast_string_field_set(cur, syntax, tmpxml);
        ast_free(tmpxml);
 
        tmpxml = ast_xmldoc_build_description("manager", action, NULL);
        ast_string_field_set(cur, description, tmpxml);
        ast_free(tmpxml);
 
        tmpxml = ast_xmldoc_build_seealso("manager", action, NULL);
        ast_string_field_set(cur, seealso, tmpxml);
        ast_free(tmpxml);
 
        tmpxml = ast_xmldoc_build_arguments("manager", action, NULL);
        ast_string_field_set(cur, arguments, tmpxml);
        ast_free(tmpxml);
 
        cur->final_response = ast_xmldoc_build_final_response("manager", action, NULL);
        cur->list_responses = ast_xmldoc_build_list_responses("manager", action, NULL);
 
        cur->docsrc = AST_XML_DOC;
    } else
#endif
    {
        ast_string_field_set(cur, synopsis, synopsis);
        ast_string_field_set(cur, description, description);
#ifdef AST_XML_DOCS
        cur->docsrc = AST_STATIC_DOC;
#endif
    }
    if (ast_manager_register_struct(cur)) {
        ao2_t_ref(cur, -1, "action object registration failed");
        return -1;
    }
 
    ao2_t_ref(cur, -1, "action object registration successful");
    return 0;
}

References manager_action::action, action_destroy(), ao2_t_alloc, ao2_t_ref, ast_free, ast_manager_register_struct(), AST_STATIC_DOC, ast_string_field_init, ast_string_field_init_extended, ast_string_field_set, ast_strlen_zero(), AST_XML_DOC, ast_xmldoc_build_arguments(), ast_xmldoc_build_description(), ast_xmldoc_build_final_response(), ast_xmldoc_build_list_responses(), ast_xmldoc_build_seealso(), ast_xmldoc_build_since(), ast_xmldoc_build_synopsis(), ast_xmldoc_build_syntax(), manager_action::authority, manager_action::docsrc, manager_action::final_response, manager_action::func, manager_action::list_responses, manager_action::module, NULL, and synopsis.

ast_manager_register_hook()

void ast_manager_register_hook

(

struct manager_custom_hook *

hook

)

Add a custom hook to be called when an event is fired.

Add a custom hook to be called when an event is fired

Parameters

hook	struct manager_custom_hook object to add

Definition at line 669 of file manager.c.

{
    AST_RWLIST_WRLOCK(&manager_hooks);
    AST_RWLIST_INSERT_TAIL(&manager_hooks, hook, list);
    AST_RWLIST_UNLOCK(&manager_hooks);
}

References AST_RWLIST_INSERT_TAIL, AST_RWLIST_UNLOCK, and AST_RWLIST_WRLOCK.

Referenced by create_test_dialplan(), and register_hook().

ast_manager_register_struct()

static int ast_manager_register_struct ( struct manager_action *  act )

static

Definition at line 7768 of file manager.c.

{
    struct manager_action *cur, *prev = NULL;
 
    AST_RWLIST_WRLOCK(&actions);
    AST_RWLIST_TRAVERSE(&actions, cur, list) {
        int ret;
 
        ret = strcasecmp(cur->action, act->action);
        if (ret == 0) {
            ast_log(LOG_WARNING, "Manager: Action '%s' already registered\n", act->action);
            AST_RWLIST_UNLOCK(&actions);
            return -1;
        }
        if (ret > 0) { /* Insert these alphabetically */
            break;
        }
        prev = cur;
    }
 
    ao2_t_ref(act, +1, "action object added to list");
    act->registered = 1;
    if (prev) {
        AST_RWLIST_INSERT_AFTER(&actions, prev, act, list);
    } else {
        AST_RWLIST_INSERT_HEAD(&actions, act, list);
    }
 
    ast_verb(5, "Manager registered action %s\n", act->action);
 
    AST_RWLIST_UNLOCK(&actions);
 
    return 0;
}

References manager_action::action, ao2_t_ref, ast_log, AST_RWLIST_INSERT_AFTER, AST_RWLIST_INSERT_HEAD, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb, LOG_WARNING, NULL, ast_category::prev, and manager_action::registered.

Referenced by ast_manager_register2().

ast_manager_str_from_json_object()

struct ast_str * ast_manager_str_from_json_object	(	struct ast_json *	blob,
		key_exclusion_cb	exclusion_cb
	)

Convert a JSON object into an AMI compatible string.

Since

12

Parameters

blob	The JSON blob containing key/value pairs to convert
exclusion_cb	A key_exclusion_cb pointer to a function that will exclude keys from the final AMI string

Returns

A malloc'd ast_str object. Callers of this function should free the returned ast_str object

Return values

NULL

on error

Definition at line 555 of file manager.c.

{
    struct ast_str *res = ast_str_create(1024);
 
    if (!ast_json_is_null(blob)) {
       manager_json_to_ast_str(blob, NULL, &res, exclusion_cb);
    }
 
    return res;
}

References ast_json_is_null(), ast_str_create, manager_json_to_ast_str(), and NULL.

Referenced by agi_channel_to_ami(), aoc_to_ami(), manager_generic_msg_cb(), multi_user_event_to_ami(), mwi_app_event_cb(), queue_channel_to_ami(), queue_member_to_ami(), and queue_multi_channel_to_ami().

ast_manager_unregister()

int ast_manager_unregister

(

const char *

action

)

support functions to register/unregister AMI action handlers,

Unregister a registered manager command.

Definition at line 7697 of file manager.c.

{
    struct manager_action *cur;
 
    AST_RWLIST_WRLOCK(&actions);
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&actions, cur, list) {
        if (!strcasecmp(action, cur->action)) {
            AST_RWLIST_REMOVE_CURRENT(list);
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
    AST_RWLIST_UNLOCK(&actions);
 
    if (cur) {
        /*
         * We have removed the action object from the container so we
         * are no longer in a hurry.
         */
        ao2_lock(cur);
        cur->registered = 0;
        ao2_unlock(cur);
 
        ao2_t_ref(cur, -1, "action object removed from list");
        ast_verb(5, "Manager unregistered action %s\n", action);
    }
 
    return 0;
}

References manager_action::action, ao2_lock, ao2_t_ref, ao2_unlock, AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb, and manager_action::registered.

Referenced by __unload_module(), ast_res_pjsip_cleanup_options_handling(), ast_res_pjsip_destroy_configuration(), ast_sip_destroy_sorcery_auth(), ast_sip_destroy_sorcery_location(), astdb_atexit(), bridge_cleanup(), load_module(), local_shutdown(), manager_bridging_cleanup(), manager_shutdown(), message_shutdown(), unload_module(), unload_parking_manager(), and unload_pbx().

ast_manager_unregister_hook()

void ast_manager_unregister_hook

(

struct manager_custom_hook *

hook

)

Delete a custom hook to be called when an event is fired.

Delete a custom hook to be called when an event is fired

Parameters

hook	struct manager_custom_hook object to delete

Definition at line 677 of file manager.c.

{
    AST_RWLIST_WRLOCK(&manager_hooks);
    AST_RWLIST_REMOVE(&manager_hooks, hook, list);
    AST_RWLIST_UNLOCK(&manager_hooks);
}

References AST_RWLIST_REMOVE, AST_RWLIST_UNLOCK, and AST_RWLIST_WRLOCK.

Referenced by register_hook(), unload_module(), and unregister_hook().

ast_webmanager_check_enabled()

int ast_webmanager_check_enabled

(

void

)

Check if AMI/HTTP is enabled.

Definition at line 689 of file manager.c.

{
    return (webmanager_enabled && manager_enabled);
}

References manager_enabled, and webmanager_enabled.

Referenced by action_coresettings(), and handle_show_settings().

astman_append()

void astman_append	(	struct mansession *	s,
		const char *	fmt,
			...
	)

utility functions for creating AMI replies

Definition at line 1907 of file manager.c.

{
    int res;
    va_list ap;
    struct ast_str *buf;
 
    if (!(buf = ast_str_thread_get(&astman_append_buf, ASTMAN_APPEND_BUF_INITSIZE))) {
        return;
    }
 
    va_start(ap, fmt);
    res = ast_str_set_va(&buf, 0, fmt, ap);
    va_end(ap);
    if (res == AST_DYNSTR_BUILD_FAILED) {
        return;
    }
 
    if (s->hook || (s->tcptls_session != NULL && s->tcptls_session->stream != NULL)) {
        send_string(s, ast_str_buffer(buf));
    } else {
        ast_verbose("No connection stream in astman_append, should not happen\n");
    }
}

References AST_DYNSTR_BUILD_FAILED, ast_str_buffer(), ast_str_set_va(), ast_str_thread_get(), ast_verbose(), astman_append_buf, ASTMAN_APPEND_BUF_INITSIZE, buf, mansession::hook, NULL, send_string(), ast_tcptls_session_instance::stream, and mansession::tcptls_session.

Referenced by _iax2_show_peers_one(), action_agents(), action_challenge(), action_command(), action_confbridgelist_item(), action_confbridgelistrooms(), action_coresettings(), action_coreshowchannelmap(), action_coreshowchannels(), action_corestatus(), action_dahdishowchannels(), action_dahdishowstatus(), action_devicestatelist(), action_events(), action_extensionstate(), action_extensionstatelist(), action_getconfig(), action_getconfigjson(), action_getvar(), action_listcategories(), action_listcommands(), action_login(), action_mailboxcount(), action_mailboxstatus(), action_meetmelist(), action_meetmelistrooms(), action_ping(), action_presencestate(), action_presencestatelist(), action_status(), action_waitevent(), ami_outbound_registration_task(), ami_registrations_aor(), ami_show_outbound_registrations(), ami_subscription_detail(), append_vmbox_info_astman(), append_vmu_info_astman(), ast_cli_netstats(), ast_manager_hangup_helper(), ast_sip_format_contact_ami(), astman_append_json(), astman_send_list_complete_end(), do_print(), format_ami_aor_handler(), format_ami_aorlist_handler(), format_ami_auth_handler(), format_ami_authlist_handler(), format_ami_contactlist_handler(), format_ami_endpoint(), format_ami_endpoint_transport(), format_ami_endpoints(), format_ami_resource_lists(), generate_status(), manager_append_event_parking_lot_data_cb(), manager_bridge_info(), manager_bridge_tech_list(), manager_db_tree_get(), manager_dbget(), manager_fax_sessions(), manager_fax_sessions_entry(), manager_fax_stats(), manager_iax2_show_netstats(), manager_iax2_show_registry(), manager_jabber_send(), manager_mixmonitor(), manager_modulecheck(), manager_mute_mixmonitor(), manager_mutestream(), manager_parking_status_all_lots(), manager_parking_status_single_lot(), manager_queue_rule_show(), manager_queues_status(), manager_queues_summary(), manager_show_dialplan(), manager_show_dialplan_helper(), manager_stop_mixmonitor(), mwi_mailbox_get(), send_bridge_info_item_cb(), send_bridge_list_item_cb(), send_identify_ami_event(), session_do(), and spandsp_manager_fax_session().

astman_append_headers()

static void astman_append_headers ( struct message *  m, const struct ast_variable *  params  )

static

Append additional headers into the message structure from params.

Note

You likely want to initialize m->hdrcount to 0 before calling this.

Definition at line 1657 of file manager.c.

{
    const struct ast_variable *v;
 
    for (v = params; v && m->hdrcount < ARRAY_LEN(m->headers); v = v->next) {
        if (ast_asprintf((char**)&m->headers[m->hdrcount], "%s: %s", v->name, v->value) > -1) {
            ++m->hdrcount;
        }
    }
}

References ARRAY_LEN, ast_asprintf, message::hdrcount, message::headers, ast_variable::name, ast_variable::next, and ast_variable::value.

Referenced by auth_http_callback(), and generic_http_callback().

astman_append_json()

static void astman_append_json ( struct mansession *  s, const char *  str  )

static

Definition at line 2640 of file manager.c.

{
    char *buf;
 
    buf = ast_alloca(2 * strlen(str) + 1);
    json_escape(buf, str);
    astman_append(s, "%s", buf);
}

References ast_alloca, astman_append(), buf, json_escape(), and str.

Referenced by action_getconfigjson().

astman_flush()

static void astman_flush ( struct mansession *  s, struct ast_str *  buf  )

static

Definition at line 1895 of file manager.c.

{
    if (s->hook || (s->tcptls_session && s->tcptls_session->stream)) {
        send_string(s, ast_str_buffer(buf));
    } else {
        ast_verbose("No connection stream in astman_append, should not happen\n");
    }
}

References ast_str_buffer(), ast_verbose(), buf, mansession::hook, send_string(), ast_tcptls_session_instance::stream, and mansession::tcptls_session.

Referenced by astman_send_list_complete(), astman_send_list_complete_start(), and astman_send_response_full().

astman_free_headers()

static void astman_free_headers ( struct message *  m )

static

Free headers inside message structure, but not the message structure itself.

Definition at line 1671 of file manager.c.

{
    while (m->hdrcount) {
        --m->hdrcount;
        ast_free((void *) m->headers[m->hdrcount]);
        m->headers[m->hdrcount] = NULL;
    }
}

References ast_free, message::hdrcount, message::headers, and NULL.

Referenced by auth_http_callback(), do_message(), and generic_http_callback().

astman_get_header()

const char * astman_get_header	(	const struct message *	m,
		char *	var
	)

Return the first matching variable from an array.

Get header from manager transaction.

Note

This is the legacy function and is implemented in therms of __astman_get_header().

Never returns NULL.

Definition at line 1647 of file manager.c.

{
    return __astman_get_header(m, var, GET_HEADER_FIRST_MATCH);
}

References __astman_get_header(), GET_HEADER_FIRST_MATCH, and var.

Referenced by action_add_agi_cmd(), action_agent_logoff(), action_agents(), action_aoc_de_message(), action_aocmessage(), action_atxfer(), action_blind_transfer(), action_bridge(), action_cancel_atxfer(), action_challenge(), action_command(), action_confbridgekick(), action_confbridgelist(), action_confbridgelistrooms(), action_confbridgesetsinglevideosrc(), action_confbridgestartrecord(), action_confbridgestoprecord(), action_coresettings(), action_coreshowchannelmap(), action_coreshowchannels(), action_corestatus(), action_createconfig(), action_dahdidialoffhook(), action_dahdidndoff(), action_dahdidndon(), action_dahdishowchannels(), action_dahdishowstatus(), action_devicestatelist(), action_events(), action_extensionstate(), action_extensionstatelist(), action_filter(), action_getconfig(), action_getconfigjson(), action_getvar(), action_listcategories(), action_lock_unlock_helper(), action_mailboxcount(), action_mailboxstatus(), action_meetmelist(), action_meetmelistrooms(), action_messagesend(), action_mute_unmute_helper(), action_originate(), action_ping(), action_presencestate(), action_presencestatelist(), action_redirect(), action_reload(), action_sendtext(), action_setvar(), action_status(), action_timeout(), action_transfer(), action_transferhangup(), action_updateconfig(), action_userevent(), action_waitevent(), ami_register(), ami_show_aors(), ami_show_auths(), ami_show_contacts(), ami_show_endpoint(), ami_show_endpoints(), ami_show_outbound_registrations(), ami_show_registration_contact_statuses(), ami_show_registrations(), ami_show_resource_lists(), ami_show_subscriptions_inbound(), ami_show_subscriptions_outbound(), ami_sip_qualify(), ami_unregister(), aocmessage_get_unit_entry(), ast_hook_send_action(), ast_manager_hangup_helper(), astman_send_list_complete_start_common(), astman_send_response_full(), authenticate(), controlplayback_manager(), handle_manager_bridge_tech_suspend(), handle_updates(), manager_add_queue_member(), manager_bridge_destroy(), manager_bridge_info(), manager_bridge_kick(), manager_bridge_tech_list(), manager_bridges_list(), manager_change_priority_caller_on_queue(), manager_db_tree_get(), manager_dbdel(), manager_dbdeltree(), manager_dbget(), manager_dbput(), manager_dialplan_extension_add(), manager_dialplan_extension_remove(), manager_fax_session(), manager_fax_sessions(), manager_fax_stats(), manager_get_mailbox_summary(), manager_iax2_show_peer_list(), manager_iax2_show_peers(), manager_iax2_show_registry(), manager_jabber_send(), manager_list_voicemail_users(), manager_match_mailbox(), manager_mixmonitor(), manager_modulecheck(), manager_moduleload(), manager_mute_mixmonitor(), manager_mutestream(), manager_notify(), manager_notify_endpoint(), manager_notify_uri(), manager_optimize_away(), manager_park(), manager_parking_lot_list(), manager_parking_status(), manager_pause_queue_member(), manager_play_dtmf(), manager_play_mf(), manager_queue_log_custom(), manager_queue_member_penalty(), manager_queue_member_ringinuse(), manager_queue_reload(), manager_queue_reset(), manager_queue_rule_show(), manager_queues_status(), manager_queues_summary(), manager_remove_queue_member(), manager_request_withdraw_caller_from_queue(), manager_send_flash(), manager_show_dialplan(), manager_status_voicemail_user(), manager_stop_mixmonitor(), manager_voicemail_forward(), manager_voicemail_move(), manager_voicemail_remove(), meetmemute(), mwi_mailbox_delete(), mwi_mailbox_get(), mwi_mailbox_update(), process_message(), sorcery_memory_cache_ami_expire(), sorcery_memory_cache_ami_expire_object(), sorcery_memory_cache_ami_populate(), sorcery_memory_cache_ami_stale(), and sorcery_memory_cache_ami_stale_object().

astman_get_variables()

struct ast_variable * astman_get_variables

(

const struct message *

m

)

Get a linked list of the Variable: headers.

Note

Order of variables is reversed from the order they are specified in the manager message

Definition at line 1733 of file manager.c.

{
    return astman_get_variables_order(m, ORDER_REVERSE);
}

References astman_get_variables_order(), and ORDER_REVERSE.

Referenced by action_originate().

astman_get_variables_order()

struct ast_variable * astman_get_variables_order	(	const struct message *	m,
		enum variable_orders	order
	)

Get a linked list of the Variable: headers with order specified.

Definition at line 1738 of file manager.c.

{
    int varlen;
    int x;
    struct ast_variable *head = NULL;
 
    static const char var_hdr[] = "Variable:";
 
    /* Process all "Variable:" headers. */
    varlen = strlen(var_hdr);
    for (x = 0; x < m->hdrcount; x++) {
        if (strncasecmp(var_hdr, m->headers[x], varlen)) {
            continue;
        }
        head = man_do_variable_value(head, m->headers[x] + varlen);
    }
 
    if (order == ORDER_NATURAL) {
        head = ast_variables_reverse(head);
    }
 
    return head;
}

References ast_variables_reverse(), message::hdrcount, message::headers, man_do_variable_value(), NULL, order, and ORDER_NATURAL.

Referenced by action_messagesend(), astman_get_variables(), manager_notify_channel(), manager_notify_endpoint(), and manager_notify_uri().

astman_live_dangerously()

void astman_live_dangerously

(

int

new_live_dangerously

)

Enable/disable the inclusion of 'dangerous' configurations outside of the ast_config_AST_CONFIG_DIR.

This function can globally enable/disable the loading of configuration files outside of ast_config_AST_CONFIG_DIR.

Parameters

new_live_dangerously

If true, enable the access of files outside ast_config_AST_CONFIG_DIR from astman.

Definition at line 2447 of file manager.c.

{
    if (new_live_dangerously && !live_dangerously)
    {
        ast_log(LOG_WARNING, "Manager Configuration load protection disabled.\n");
    }
 
    if (!new_live_dangerously && live_dangerously)
    {
        ast_log(LOG_NOTICE, "Manager Configuration load protection enabled.\n");
    }
    live_dangerously = new_live_dangerously;
}

References ast_log, live_dangerously, LOG_NOTICE, and LOG_WARNING.

Referenced by load_asterisk_conf().

astman_send_ack()

void astman_send_ack	(	struct mansession *	s,
		const struct message *	m,
		char *	msg
	)

Send ack in manager transaction.

Definition at line 2018 of file manager.c.

{
    astman_send_response_full(s, m, "Success", msg, NULL);
}

References astman_send_response_full(), and NULL.

Referenced by action_add_agi_cmd(), action_agent_logoff(), action_aocmessage(), action_atxfer(), action_blind_transfer(), action_bridge(), action_cancel_atxfer(), action_confbridgekick(), action_confbridgesetsinglevideosrc(), action_confbridgestartrecord(), action_confbridgestoprecord(), action_createconfig(), action_dahdidialoffhook(), action_dahdidndoff(), action_dahdidndon(), action_dahdirestart(), action_filter(), action_lock_unlock_helper(), action_loggerrotate(), action_login(), action_messagesend(), action_mute_unmute_helper(), action_originate(), action_redirect(), action_reload(), action_sendtext(), action_setvar(), action_timeout(), action_transfer(), action_transferhangup(), action_updateconfig(), action_userevent(), ami_register(), ami_sip_qualify(), ami_unregister(), ast_manager_hangup_helper(), controlplayback_manager(), handle_manager_bridge_tech_suspend(), manager_add_queue_member(), manager_bridge_destroy(), manager_bridge_kick(), manager_change_priority_caller_on_queue(), manager_dbdel(), manager_dbdeltree(), manager_dbput(), manager_dialplan_extension_add(), manager_dialplan_extension_remove(), manager_fax_session(), manager_fax_stats(), manager_get_mailbox_summary(), manager_jabber_send(), manager_list_voicemail_users(), manager_moduleload(), manager_optimize_away(), manager_park_bridged(), manager_park_unbridged(), manager_pause_queue_member(), manager_play_dtmf(), manager_play_mf(), manager_queue_log_custom(), manager_queue_member_penalty(), manager_queue_member_ringinuse(), manager_queue_reload(), manager_queue_reset(), manager_remove_queue_member(), manager_request_withdraw_caller_from_queue(), manager_send_flash(), manager_send_response(), manager_status_voicemail_user(), manager_voicemail_forward(), manager_voicemail_move(), manager_voicemail_refresh(), manager_voicemail_remove(), meetmemute(), mwi_mailbox_delete(), mwi_mailbox_update(), sorcery_memory_cache_ami_expire(), sorcery_memory_cache_ami_expire_object(), sorcery_memory_cache_ami_populate(), sorcery_memory_cache_ami_stale(), and sorcery_memory_cache_ami_stale_object().

astman_send_error()

void astman_send_error	(	struct mansession *	s,
		const struct message *	m,
		char *	error
	)

Send error in manager transaction.

Definition at line 1986 of file manager.c.

{
    astman_send_response_full(s, m, "Error", error, NULL);
}

References astman_send_response_full(), error(), and NULL.

Referenced by action_add_agi_cmd(), action_agent_logoff(), action_aoc_de_message(), action_aoc_s_message(), action_aoc_s_submessage(), action_aocmessage(), action_atxfer(), action_blind_transfer(), action_bridge(), action_cancel_atxfer(), action_challenge(), action_command(), action_confbridgekick(), action_confbridgelist(), action_confbridgelistrooms(), action_confbridgesetsinglevideosrc(), action_confbridgestartrecord(), action_confbridgestoprecord(), action_coreshowchannelmap(), action_createconfig(), action_dahdidialoffhook(), action_dahdidndoff(), action_dahdidndon(), action_dahdirestart(), action_dahdishowstatus(), action_devicestatelist(), action_events(), action_extensionstate(), action_extensionstatelist(), action_filter(), action_getconfig(), action_getconfigjson(), action_getvar(), action_listcategories(), action_lock_unlock_helper(), action_loggerrotate(), action_login(), action_mailboxcount(), action_mailboxstatus(), action_meetmelist(), action_meetmelistrooms(), action_messagesend(), action_mute_unmute_helper(), action_originate(), action_presencestate(), action_presencestatelist(), action_redirect(), action_reload(), action_sendtext(), action_setvar(), action_status(), action_timeout(), action_transfer(), action_transferhangup(), action_updateconfig(), ami_register(), ami_show_aors(), ami_show_auths(), ami_show_contacts(), ami_show_endpoints(), ami_show_outbound_registrations(), ami_show_resource_lists(), ami_sip_qualify(), ami_unregister(), ast_manager_hangup_helper(), controlplayback_manager(), do_message(), handle_manager_bridge_tech_suspend(), handle_parse_error(), manager_add_queue_member(), manager_bridge_destroy(), manager_bridge_info(), manager_bridge_kick(), manager_bridge_tech_list(), manager_bridges_list(), manager_change_priority_caller_on_queue(), manager_db_tree_get(), manager_dbdel(), manager_dbdeltree(), manager_dbget(), manager_dbput(), manager_dialplan_extension_add(), manager_dialplan_extension_remove(), manager_fax_session(), manager_get_mailbox_summary(), manager_jabber_send(), manager_mixmonitor(), manager_modulecheck(), manager_moduleload(), manager_mute_mixmonitor(), manager_mutestream(), manager_notify(), manager_optimize_away(), manager_park(), manager_park_bridged(), manager_park_unbridged(), manager_parking_lot_list(), manager_parking_status_all_lots(), manager_parking_status_single_lot(), manager_pause_queue_member(), manager_play_dtmf(), manager_play_mf(), manager_queue_log_custom(), manager_queue_member_penalty(), manager_queue_member_ringinuse(), manager_queue_reload(), manager_queue_reset(), manager_remove_queue_member(), manager_request_withdraw_caller_from_queue(), manager_send_flash(), manager_send_response(), manager_show_dialplan(), manager_show_dialplan_helper(), manager_status_voicemail_user(), manager_stop_mixmonitor(), manager_voicemail_forward(), manager_voicemail_move(), manager_voicemail_remove(), meetmemute(), mwi_mailbox_delete(), mwi_mailbox_get(), mwi_mailbox_update(), process_message(), sorcery_memory_cache_ami_expire(), sorcery_memory_cache_ami_expire_object(), sorcery_memory_cache_ami_populate(), sorcery_memory_cache_ami_stale(), and sorcery_memory_cache_ami_stale_object().

astman_send_error_va()

void astman_send_error_va	(	struct mansession *	s,
		const struct message *	m,
		const char *	fmt,
			...
	)

Send error in manager transaction (with va_args support)

Definition at line 1991 of file manager.c.

{
    int res;
    va_list ap;
    struct ast_str *buf;
    char *msg;
 
    if (!(buf = ast_str_thread_get(&astman_append_buf, ASTMAN_APPEND_BUF_INITSIZE))) {
        return;
    }
 
    va_start(ap, fmt);
    res = ast_str_set_va(&buf, 0, fmt, ap);
    va_end(ap);
    if (res == AST_DYNSTR_BUILD_FAILED) {
        return;
    }
 
    /* astman_append will use the same underlying buffer, so copy the message out
     * before sending the response */
    msg = ast_str_buffer(buf);
    if (msg) {
        msg = ast_strdupa(msg);
    }
    astman_send_response_full(s, m, "Error", msg, NULL);
}

References AST_DYNSTR_BUILD_FAILED, ast_str_buffer(), ast_str_set_va(), ast_str_thread_get(), ast_strdupa, astman_append_buf, ASTMAN_APPEND_BUF_INITSIZE, astman_send_response_full(), buf, and NULL.

Referenced by action_command(), action_originate(), action_presencestate(), ami_show_endpoint(), ast_manager_hangup_helper(), ast_sip_create_ami_event(), format_ami_endpoint_transport(), manager_notify_endpoint(), manager_notify_uri(), manager_send_response(), mwi_mailbox_delete(), mwi_mailbox_get(), and mwi_mailbox_update().

astman_send_list_complete()

static void astman_send_list_complete ( struct mansession *  s, const struct message *  m, const char *  event_name, int  count  )

static

Definition at line 2055 of file manager.c.

{
    struct ast_str *buf = astman_send_list_complete_start_common(s, m, event_name, count);
    if (buf) {
        ast_str_append(&buf, 0, "\r\n");
        astman_flush(s, buf);
    }
}

References ast_str_append(), astman_flush(), astman_send_list_complete_start_common(), and buf.

Referenced by action_coreshowchannels(), and ast_manager_hangup_helper().

astman_send_list_complete_end()

void astman_send_list_complete_end

(

struct mansession *

s

)

End the list complete event.

Since

13.2.0

Parameters

s	- AMI session control struct.

Note

You need to call astman_send_list_complete_start() to start the AMI list completion event.

Between calling astman_send_list_complete_start() and astman_send_list_complete_end() you can add additonal headers using astman_append().

Definition at line 2072 of file manager.c.

{
    astman_append(s, "\r\n");
}

References astman_append().

Referenced by action_agents(), action_confbridgelist(), action_confbridgelistrooms(), action_coreshowchannelmap(), action_dahdishowchannels(), action_dahdishowstatus(), action_devicestatelist(), action_extensionstatelist(), action_meetmelist(), action_meetmelistrooms(), action_presencestatelist(), action_status(), ami_show_aors(), ami_show_auths(), ami_show_contacts(), ami_show_endpoint(), ami_show_endpoints(), ami_show_outbound_registrations(), ami_show_registration_contact_statuses(), ami_show_registrations(), ami_show_resource_lists(), ami_show_subscriptions_inbound(), ami_show_subscriptions_outbound(), append_vmbox_info_astman(), manager_bridge_info(), manager_bridge_tech_list(), manager_bridges_list(), manager_db_tree_get(), manager_dbget(), manager_fax_sessions(), manager_iax2_show_peer_list(), manager_iax2_show_peers(), manager_iax2_show_registry(), manager_list_voicemail_users(), manager_parking_lot_list(), manager_parking_status_all_lots(), manager_parking_status_single_lot(), manager_queues_status(), manager_queues_summary(), manager_show_dialplan(), manager_status_voicemail_user(), and mwi_mailbox_get().

astman_send_list_complete_start()

void astman_send_list_complete_start	(	struct mansession *	s,
		const struct message *	m,
		const char *	event_name,
		int	count
	)

Start the list complete event.

Since

13.2.0

Parameters

s	- AMI session control struct.
m	- AMI action request that started the list.
event_name	- AMI list complete event name.
count	- Number of items in the list.

Note

You need to call astman_send_list_complete_end() to end the AMI list completion event.

Between calling astman_send_list_complete_start() and astman_send_list_complete_end() you can add additonal headers using astman_append().

Definition at line 2064 of file manager.c.

{
    struct ast_str *buf = astman_send_list_complete_start_common(s, m, event_name, count);
    if (buf) {
        astman_flush(s, buf);
    }
}

References astman_flush(), astman_send_list_complete_start_common(), and buf.

Referenced by action_agents(), action_confbridgelist(), action_confbridgelistrooms(), action_coreshowchannelmap(), action_dahdishowchannels(), action_dahdishowstatus(), action_devicestatelist(), action_extensionstatelist(), action_meetmelist(), action_meetmelistrooms(), action_presencestatelist(), action_status(), ami_show_aors(), ami_show_auths(), ami_show_contacts(), ami_show_endpoint(), ami_show_endpoints(), ami_show_outbound_registrations(), ami_show_registration_contact_statuses(), ami_show_registrations(), ami_show_resource_lists(), ami_show_subscriptions_inbound(), ami_show_subscriptions_outbound(), append_vmbox_info_astman(), manager_bridge_info(), manager_bridge_tech_list(), manager_bridges_list(), manager_db_tree_get(), manager_dbget(), manager_fax_sessions(), manager_iax2_show_peer_list(), manager_iax2_show_peers(), manager_iax2_show_registry(), manager_list_voicemail_users(), manager_parking_lot_list(), manager_parking_status_all_lots(), manager_parking_status_single_lot(), manager_queues_status(), manager_queues_summary(), manager_show_dialplan(), manager_status_voicemail_user(), and mwi_mailbox_get().

astman_send_list_complete_start_common()

static struct ast_str * astman_send_list_complete_start_common ( struct mansession *  s, const struct message *  m, const char *  event_name, int  count  )

static

Definition at line 2033 of file manager.c.

{
    const char *id = astman_get_header(m, "ActionID");
    struct ast_str *buf;
 
    buf = ast_str_thread_get(&astman_append_buf, ASTMAN_APPEND_BUF_INITSIZE);
    if (!buf) {
        return NULL;
    }
 
    ast_str_set(&buf, 0, "Event: %s\r\n", event_name);
    if (!ast_strlen_zero(id)) {
        ast_str_append(&buf, 0, "ActionID: %s\r\n", id);
    }
    ast_str_append(&buf, 0,
        "EventList: Complete\r\n"
        "ListItems: %d\r\n",
        count);
 
    return buf;
}

References ast_str_append(), ast_str_set(), ast_str_thread_get(), ast_strlen_zero(), astman_append_buf, ASTMAN_APPEND_BUF_INITSIZE, astman_get_header(), buf, and NULL.

Referenced by astman_send_list_complete(), and astman_send_list_complete_start().

astman_send_listack()

void astman_send_listack	(	struct mansession *	s,
		const struct message *	m,
		char *	msg,
		char *	listflag
	)

Send ack in manager transaction to begin a list.

Parameters

s	- AMI session control struct.
m	- AMI action request that started the list.
msg	- Message contents describing the list to follow.
listflag	- Should always be set to "start".

Note

You need to call astman_send_list_complete_start() and astman_send_list_complete_end() to send the AMI list completion event.

Definition at line 2028 of file manager.c.

{
    astman_send_response_full(s, m, "Success", msg, listflag);
}

References astman_send_response_full().

Referenced by action_agents(), action_confbridgelist(), action_confbridgelistrooms(), action_coreshowchannelmap(), action_coreshowchannels(), action_dahdishowchannels(), action_dahdishowstatus(), action_devicestatelist(), action_extensionstatelist(), action_meetmelist(), action_meetmelistrooms(), action_presencestatelist(), action_status(), ami_show_aors(), ami_show_auths(), ami_show_contacts(), ami_show_endpoint(), ami_show_endpoints(), ami_show_outbound_registrations(), ami_show_registration_contact_statuses(), ami_show_registrations(), ami_show_resource_lists(), ami_show_subscriptions_inbound(), ami_show_subscriptions_outbound(), append_vmbox_info_astman(), ast_manager_hangup_helper(), manager_bridge_info(), manager_bridge_tech_list(), manager_bridges_list(), manager_db_tree_get(), manager_dbget(), manager_dpsendack(), manager_fax_sessions(), manager_iax2_show_peer_list(), manager_iax2_show_peers(), manager_iax2_show_registry(), manager_list_voicemail_users(), manager_parking_lot_list(), manager_parking_status_all_lots(), manager_parking_status_single_lot(), manager_queues_status(), manager_queues_summary(), manager_status_voicemail_user(), and mwi_mailbox_get().

astman_send_response()

void astman_send_response	(	struct mansession *	s,
		const struct message *	m,
		char *	resp,
		char *	msg
	)

Send response in manager transaction.

Definition at line 1981 of file manager.c.

{
    astman_send_response_full(s, m, resp, msg, NULL);
}

References astman_send_response_full(), and NULL.

Referenced by action_logoff(), and action_waitevent().

astman_send_response_full()

static void astman_send_response_full ( struct mansession *  s, const struct message *  m, char *  resp, char *  msg, char *  listflag  )

static

send a response with an optional message, and terminate it with an empty line. m is used only to grab the 'ActionID' field.

Use the explicit constant MSG_MOREDATA to remove the empty line. XXX MSG_MOREDATA should go to a header file.

Definition at line 1950 of file manager.c.

{
    const char *id = astman_get_header(m, "ActionID");
    struct ast_str *buf;
 
    buf = ast_str_thread_get(&astman_append_buf, ASTMAN_APPEND_BUF_INITSIZE);
    if (!buf) {
        return;
    }
 
    ast_str_set(&buf, 0, "Response: %s\r\n", resp);
 
    if (!ast_strlen_zero(id)) {
        ast_str_append(&buf, 0, "ActionID: %s\r\n", id);
    }
 
    if (listflag) {
        /* Start, complete, cancelled */
        ast_str_append(&buf, 0, "EventList: %s\r\n", listflag);
    }
 
    if (msg != MSG_MOREDATA) {
        if (msg) {
            ast_str_append(&buf, 0, "Message: %s\r\n", msg);
        }
        ast_str_append(&buf, 0, "\r\n");
    }
 
    astman_flush(s, buf);
}

References ast_str_append(), ast_str_set(), ast_str_thread_get(), ast_strlen_zero(), astman_append_buf, ASTMAN_APPEND_BUF_INITSIZE, astman_flush(), astman_get_header(), buf, and MSG_MOREDATA.

Referenced by action_command(), astman_send_ack(), astman_send_error(), astman_send_error_va(), astman_send_listack(), astman_send_response(), and astman_start_ack().

astman_start_ack()

static void astman_start_ack ( struct mansession *  s, const struct message *  m  )

static

Definition at line 2023 of file manager.c.

{
    astman_send_response_full(s, m, "Success", MSG_MOREDATA, NULL);
}

References astman_send_response_full(), MSG_MOREDATA, and NULL.

Referenced by action_challenge(), action_extensionstate(), action_getconfig(), action_getconfigjson(), action_getvar(), action_listcategories(), action_listcommands(), action_mailboxcount(), action_mailboxstatus(), and action_presencestate().

async_goto_with_discard_bridge_after()

static int async_goto_with_discard_bridge_after ( struct ast_channel *  chan, const char *  context, const char *  exten, int  priority  )

static

Definition at line 3950 of file manager.c.

{
    ast_bridge_discard_after_goto(chan);
    return ast_async_goto(chan, context, exten, priority);
}

References ast_async_goto(), ast_bridge_discard_after_goto(), voicemailpwcheck::context, and priority.

Referenced by action_redirect().

authenticate()

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

static

Definition at line 2332 of file manager.c.

{
    const char *username = astman_get_header(m, "Username");
    const char *password = astman_get_header(m, "Secret");
    int error = -1;
    struct ast_manager_user *user = NULL;
    regex_t *regex_filter;
    struct ao2_iterator filter_iter;
 
    if (ast_strlen_zero(username)) {    /* missing username */
        return -1;
    }
 
    /* locate user in locked state */
    AST_RWLIST_WRLOCK(&users);
 
    if (!(user = get_manager_by_name_locked(username))) {
        report_invalid_user(s, username);
        ast_log(LOG_NOTICE, "%s tried to authenticate with nonexistent user '%s'\n", ast_sockaddr_stringify_addr(&s->session->addr), username);
    } else if (user->acl && (ast_apply_acl(user->acl, &s->session->addr, "Manager User ACL: ") == AST_SENSE_DENY)) {
        report_failed_acl(s, username);
        ast_log(LOG_NOTICE, "%s failed to pass IP ACL as '%s'\n", ast_sockaddr_stringify_addr(&s->session->addr), username);
    } else if (!strcasecmp(astman_get_header(m, "AuthType"), "MD5")) {
        const char *key = astman_get_header(m, "Key");
        if (!ast_strlen_zero(key) && !ast_strlen_zero(s->session->challenge) && user->secret) {
            int x;
            int len = 0;
            char md5key[256] = "";
            struct MD5Context md5;
            unsigned char digest[16];
 
            MD5Init(&md5);
            MD5Update(&md5, (unsigned char *) s->session->challenge, strlen(s->session->challenge));
            MD5Update(&md5, (unsigned char *) user->secret, strlen(user->secret));
            MD5Final(digest, &md5);
            for (x = 0; x < 16; x++)
                len += sprintf(md5key + len, "%02hhx", digest[x]);
            if (!strcmp(md5key, key)) {
                error = 0;
            } else {
                report_failed_challenge_response(s, key, md5key);
            }
        } else {
            ast_debug(1, "MD5 authentication is not possible.  challenge: '%s'\n",
                S_OR(s->session->challenge, ""));
        }
    } else if (user->secret) {
        if (!strcmp(password, user->secret)) {
            error = 0;
        } else {
            report_inval_password(s, username);
        }
    }
 
    if (error) {
        ast_log(LOG_NOTICE, "%s failed to authenticate as '%s'\n", ast_sockaddr_stringify_addr(&s->session->addr), username);
        AST_RWLIST_UNLOCK(&users);
        return -1;
    }
 
    /* auth complete */
 
    /* All of the user parameters are copied to the session so that in the event
    * of a reload and a configuration change, the session parameters are not
    * changed. */
    ast_copy_string(s->session->username, username, sizeof(s->session->username));
    s->session->readperm = user->readperm;
    s->session->writeperm = user->writeperm;
    s->session->writetimeout = user->writetimeout;
    if (user->chanvars) {
        s->session->chanvars = ast_variables_dup(user->chanvars);
    }
 
    filter_iter = ao2_iterator_init(user->includefilters, 0);
    while ((regex_filter = ao2_iterator_next(&filter_iter))) {
        ao2_t_link(s->session->includefilters, regex_filter, "add include user filter to session");
        ao2_t_ref(regex_filter, -1, "remove iterator ref");
    }
    ao2_iterator_destroy(&filter_iter);
 
    filter_iter = ao2_iterator_init(user->excludefilters, 0);
    while ((regex_filter = ao2_iterator_next(&filter_iter))) {
        ao2_t_link(s->session->excludefilters, regex_filter, "add exclude user filter to session");
        ao2_t_ref(regex_filter, -1, "remove iterator ref");
    }
    ao2_iterator_destroy(&filter_iter);
 
    s->session->sessionstart = time(NULL);
    s->session->sessionstart_tv = ast_tvnow();
    set_eventmask(s, astman_get_header(m, "Events"));
 
    report_auth_success(s);
 
    AST_RWLIST_UNLOCK(&users);
    return 0;
}

References mansession_session::addr, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_t_link, ao2_t_ref, ast_apply_acl(), ast_copy_string(), ast_debug, ast_log, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, AST_SENSE_DENY, ast_sockaddr_stringify_addr(), ast_strlen_zero(), ast_tvnow(), ast_variables_dup(), astman_get_header(), mansession_session::challenge, mansession_session::chanvars, error(), mansession_session::excludefilters, get_manager_by_name_locked(), mansession_session::includefilters, len(), LOG_NOTICE, md5(), MD5Final(), MD5Init(), MD5Update(), NULL, mansession_session::readperm, report_auth_success(), report_failed_acl(), report_failed_challenge_response(), report_inval_password(), report_invalid_user(), S_OR, mansession::session, mansession_session::sessionstart, mansession_session::sessionstart_tv, set_eventmask(), mansession_session::username, mansession_session::writeperm, and mansession_session::writetimeout.

Referenced by action_login().

authority_to_str()

static const char * authority_to_str ( int  authority, struct ast_str **  res  )

static

Convert authority code to a list of options. Note that the EVENT_FLAG_ALL authority will always be returned.

Definition at line 819 of file manager.c.

{
    int i;
    char *sep = "";
 
    ast_str_reset(*res);
    if (authority != EVENT_FLAG_SHUTDOWN) {
        for (i = 0; i < ARRAY_LEN(perms) - 1; i++) {
            if (authority & perms[i].num) {
                ast_str_append(res, 0, "%s%s", sep, perms[i].label);
                sep = ",";
            }
        }
    }
 
    if (ast_str_strlen(*res) == 0) {
        /* replace empty string with something sensible */
        ast_str_append(res, 0, "<none>");
    }
 
    return ast_str_buffer(*res);
}

References ARRAY_LEN, ast_str_append(), ast_str_buffer(), ast_str_reset(), ast_str_strlen(), EVENT_FLAG_SHUTDOWN, and perms.

Referenced by __manager_event_sessions_va(), action_listcommands(), action_login(), and handle_showmancmd().

build_mansession()

static struct mansession_session * build_mansession ( const struct ast_sockaddr *  addr )

static

Allocate manager session structure and add it to the list of sessions.

Definition at line 970 of file manager.c.

{
    struct ao2_container *sessions;
    struct mansession_session *newsession;
 
    newsession = ao2_alloc(sizeof(*newsession), session_destructor);
    if (!newsession) {
        return NULL;
    }
 
    newsession->includefilters = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
    newsession->excludefilters = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
    if (!newsession->includefilters || !newsession->excludefilters) {
        ao2_ref(newsession, -1);
        return NULL;
    }
 
    newsession->waiting_thread = AST_PTHREADT_NULL;
    newsession->writetimeout = 100;
    newsession->send_events = -1;
    ast_sockaddr_copy(&newsession->addr, addr);
 
    ast_mutex_init(&newsession->notify_lock);
 
    sessions = ao2_global_obj_ref(mgr_sessions);
    if (sessions) {
        ao2_link(sessions, newsession);
        ao2_ref(sessions, -1);
    }
 
    return newsession;
}

References mansession_session::addr, ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_list, ao2_global_obj_ref, ao2_link, ao2_ref, ast_mutex_init, AST_PTHREADT_NULL, ast_sockaddr_copy(), mansession_session::excludefilters, mansession_session::includefilters, mansession_session::notify_lock, NULL, mansession_session::send_events, session_destructor(), sessions, mansession_session::waiting_thread, and mansession_session::writetimeout.

Referenced by auth_http_callback(), generic_http_callback(), and session_do().

check_blacklist()

static int check_blacklist ( const char *  cmd )

static

Definition at line 4243 of file manager.c.

{
    char *cmd_copy, *cur_cmd;
    char *cmd_words[AST_MAX_CMD_LEN] = { NULL, };
    int i;
 
    cmd_copy = ast_strdupa(cmd);
    for (i = 0; i < MAX_BLACKLIST_CMD_LEN && (cur_cmd = strsep(&cmd_copy, " ")); i++) {
        cur_cmd = ast_strip(cur_cmd);
        if (ast_strlen_zero(cur_cmd)) {
            i--;
            continue;
        }
 
        cmd_words[i] = cur_cmd;
    }
 
    for (i = 0; i < ARRAY_LEN(command_blacklist); i++) {
        int j, match = 1;
 
        for (j = 0; command_blacklist[i].words[j]; j++) {
            if (ast_strlen_zero(cmd_words[j]) || strcasecmp(cmd_words[j], command_blacklist[i].words[j])) {
                match = 0;
                break;
            }
        }
 
        if (match) {
            return 1;
        }
    }
 
    return 0;
}

References ARRAY_LEN, AST_MAX_CMD_LEN, ast_strdupa, ast_strip(), ast_strlen_zero(), command_blacklist, match(), MAX_BLACKLIST_CMD_LEN, NULL, strsep(), and words.

Referenced by action_command().

check_manager_session_inuse()

static int check_manager_session_inuse ( const char *  name )

static

Definition at line 1023 of file manager.c.

{
    struct ao2_container *sessions;
    struct mansession_session *session;
    int inuse = 0;
 
    sessions = ao2_global_obj_ref(mgr_sessions);
    if (sessions) {
        session = ao2_find(sessions, (char *) name, 0);
        ao2_ref(sessions, -1);
        if (session) {
            unref_mansession(session);
            inuse = 1;
        }
    }
    return inuse;
}

References ao2_find, ao2_global_obj_ref, ao2_ref, mansession_session::inuse, name, session, sessions, and unref_mansession().

Referenced by process_message().

coreshowchannelmap_add_connected_channels()

static int coreshowchannelmap_add_connected_channels ( struct ao2_container *  channel_map, struct ast_channel_snapshot *  channel_snapshot, struct ast_bridge_snapshot *  bridge_snapshot  )

static

Recursive function to get all channels in a bridge. Follow local channels as well.

Definition at line 6665 of file manager.c.

{
    int res = 0;
    struct ao2_iterator iter;
    char *current_channel_uid;
 
    iter = ao2_iterator_init(bridge_snapshot->channels, 0);
    while ((current_channel_uid = ao2_iterator_next(&iter))) {
        struct ast_channel_snapshot *current_channel_snapshot;
        int add_channel_res;
 
        /* Don't add the original channel to the list - it's either already in there,
         * or it's the channel we want the map for */
        if (!strcmp(current_channel_uid, channel_snapshot->base->uniqueid)) {
            ao2_ref(current_channel_uid, -1);
            continue;
        }
 
        current_channel_snapshot = ast_channel_snapshot_get_latest(current_channel_uid);
        if (!current_channel_snapshot) {
            ast_debug(5, "Unable to get channel snapshot\n");
            ao2_ref(current_channel_uid, -1);
            continue;
        }
 
        add_channel_res = coreshowchannelmap_add_to_map(channel_map, current_channel_snapshot->base->name);
        if (add_channel_res) {
            res = 1;
            ao2_ref(current_channel_snapshot, -1);
            ao2_ref(current_channel_uid, -1);
            break;
        }
 
        /* If this is a local channel that we haven't seen yet, let's go ahead and find out what else is connected to it */
        if (ast_begins_with(current_channel_snapshot->base->name, "Local")) {
            struct ast_channel_snapshot *other_local_snapshot;
            struct ast_bridge_snapshot *other_bridge_snapshot;
            int size = strlen(current_channel_snapshot->base->name);
            char other_local[size + 1];
 
            /* Don't copy the trailing number - set it to 1 or 2, whichever one it currently is not */
            ast_copy_string(other_local, current_channel_snapshot->base->name, size);
            other_local[size - 1] = ast_ends_with(current_channel_snapshot->base->name, "1") ? '2' : '1';
            other_local[size] = '\0';
 
            other_local_snapshot = ast_channel_snapshot_get_latest_by_name(other_local);
            if (!other_local_snapshot) {
                ast_debug(5, "Unable to get other local channel snapshot\n");
                ao2_ref(current_channel_snapshot, -1);
                ao2_ref(current_channel_uid, -1);
                continue;
            }
 
            if (coreshowchannelmap_add_to_map(channel_map, other_local_snapshot->base->name)) {
                res = 1;
                ao2_ref(current_channel_snapshot, -1);
                ao2_ref(current_channel_uid, -1);
                ao2_ref(other_local_snapshot, -1);
                break;
            }
 
            other_bridge_snapshot = ast_bridge_get_snapshot_by_uniqueid(other_local_snapshot->bridge->id);
            if (other_bridge_snapshot) {
                res = coreshowchannelmap_add_connected_channels(channel_map, other_local_snapshot, other_bridge_snapshot);
            }
 
            ao2_ref(current_channel_snapshot, -1);
            ao2_ref(current_channel_uid, -1);
            ao2_ref(other_local_snapshot, -1);
            ao2_ref(other_bridge_snapshot, -1);
 
            if (res) {
                break;
            }
        }
    }
    ao2_iterator_destroy(&iter);
 
    return res;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_begins_with(), ast_bridge_get_snapshot_by_uniqueid(), ast_channel_snapshot_get_latest(), ast_channel_snapshot_get_latest_by_name(), ast_copy_string(), ast_debug, ast_ends_with(), ast_channel_snapshot::base, ast_channel_snapshot::bridge, ast_bridge_snapshot::channels, coreshowchannelmap_add_connected_channels(), coreshowchannelmap_add_to_map(), ast_channel_snapshot_bridge::id, ast_channel_snapshot_base::name, and ast_channel_snapshot_base::uniqueid.

Referenced by action_coreshowchannelmap(), and coreshowchannelmap_add_connected_channels().

coreshowchannelmap_add_to_map()

static int coreshowchannelmap_add_to_map ( struct ao2_container *  c, const char *  s  )

static

Helper function to add a channel name to the vector.

Definition at line 6648 of file manager.c.

{
    char *str;
 
    str = ast_strdup(s);
    if (!str) {
        ast_log(LOG_ERROR, "Unable to append channel to channel map\n");
        return 1;
    }
 
    /* If this is a duplicate, it will be ignored */
    ast_str_container_add(c, str);
 
    return 0;
}

References ast_log, ast_str_container_add(), ast_strdup, c, LOG_ERROR, and str.

Referenced by coreshowchannelmap_add_connected_channels().

destroy_fast_originate_helper()

static void destroy_fast_originate_helper ( struct fast_originate_helper *  doomed )

static

Definition at line 4387 of file manager.c.

{
    ao2_cleanup(doomed->cap);
    ast_variables_destroy(doomed->vars);
    ast_string_field_free_memory(doomed);
    ast_free(doomed);
}

References ao2_cleanup, ast_free, ast_string_field_free_memory, ast_variables_destroy(), fast_originate_helper::cap, and fast_originate_helper::vars.

Referenced by action_originate(), and fast_originate().

do_message()

static int do_message ( struct mansession *  s )

static

Definition at line 7276 of file manager.c.

{
    struct message m = { 0 };
    char header_buf[sizeof(s->session->inbuf)] = { '\0' };
    int res;
    int hdr_loss;
    time_t now;
 
    hdr_loss = 0;
    for (;;) {
        /* Check if any events are pending and do them if needed */
        if (process_events(s)) {
            res = -1;
            break;
        }
        res = get_input(s, header_buf);
        if (res == 0) {
            /* No input line received. */
            if (!s->session->authenticated) {
                if (time(&now) == -1) {
                    ast_log(LOG_ERROR, "error executing time(): %s\n", strerror(errno));
                    res = -1;
                    break;
                }
 
                if (now - s->session->authstart > authtimeout) {
                    if (displayconnects) {
                        ast_verb(2, "Client from %s, failed to authenticate in %d seconds\n", ast_sockaddr_stringify_addr(&s->session->addr), authtimeout);
                    }
                    res = -1;
                    break;
                }
            }
            continue;
        } else if (res > 0) {
            /* Input line received. */
            if (ast_strlen_zero(header_buf)) {
                if (hdr_loss) {
                    mansession_lock(s);
                    astman_send_error(s, &m, "Too many lines in message or allocation failure");
                    mansession_unlock(s);
                    res = 0;
                } else {
                    switch (s->parsing) {
                    case MESSAGE_OKAY:
                        res = process_message(s, &m) ? -1 : 0;
                        break;
                    case MESSAGE_LINE_TOO_LONG:
                        handle_parse_error(s, &m, "Failed to parse message: line too long");
                        res = 0;
                        break;
                    }
                }
                break;
            } else if (m.hdrcount < ARRAY_LEN(m.headers)) {
                m.headers[m.hdrcount] = ast_strdup(header_buf);
                if (!m.headers[m.hdrcount]) {
                    /* Allocation failure. */
                    hdr_loss = 1;
                } else {
                    ++m.hdrcount;
                }
            } else {
                /* Too many lines in message. */
                hdr_loss = 1;
            }
        } else {
            /* Input error. */
            break;
        }
    }
 
    astman_free_headers(&m);
 
    return res;
}

References mansession_session::addr, ARRAY_LEN, ast_log, ast_sockaddr_stringify_addr(), ast_strdup, ast_strlen_zero(), ast_verb, astman_free_headers(), astman_send_error(), mansession_session::authenticated, mansession_session::authstart, authtimeout, displayconnects, errno, get_input(), handle_parse_error(), message::hdrcount, message::headers, mansession_session::inbuf, LOG_ERROR, mansession_lock(), mansession_unlock(), MESSAGE_LINE_TOO_LONG, MESSAGE_OKAY, mansession::parsing, process_events(), process_message(), and mansession::session.

Referenced by session_do().

event_filter_destructor()

static void event_filter_destructor ( void *  obj )

static

Definition at line 927 of file manager.c.

{
    struct event_filter_entry *entry = obj;
    if (entry->regex_filter) {
        regfree(entry->regex_filter);
        ast_free(entry->regex_filter);
    }
    ast_free(entry->event_name);
    ast_free(entry->header_name);
    ast_free(entry->string_filter);
}

References ast_free, event_filter_entry::event_name, event_filter_entry::header_name, event_filter_entry::regex_filter, and event_filter_entry::string_filter.

Referenced by manager_add_filter().

fast_originate()

static void * fast_originate ( void *  data )

static

Definition at line 4395 of file manager.c.

{
    struct fast_originate_helper *in = data;
    int res;
    int reason = 0;
    struct ast_channel *chan = NULL, *chans[1];
    char requested_channel[AST_CHANNEL_NAME];
    struct ast_assigned_ids assignedids = {
        .uniqueid = in->channelid,
        .uniqueid2 = in->otherchannelid
    };
 
    if (!ast_strlen_zero(in->app)) {
        res = ast_pbx_outgoing_app(in->tech, in->cap, in->data,
            in->timeout, in->app, in->appdata, &reason,
            AST_OUTGOING_WAIT,
            S_OR(in->cid_num, NULL),
            S_OR(in->cid_name, NULL),
            in->vars, in->account, &chan, &assignedids);
    } else {
        res = ast_pbx_outgoing_exten(in->tech, in->cap, in->data,
            in->timeout, in->context, in->exten, in->priority, &reason,
            AST_OUTGOING_WAIT,
            S_OR(in->cid_num, NULL),
            S_OR(in->cid_name, NULL),
            in->vars, in->account, &chan, in->early_media, &assignedids);
    }
 
    if (!chan) {
        snprintf(requested_channel, AST_CHANNEL_NAME, "%s/%s", in->tech, in->data);
    }
    /* Tell the manager what happened with the channel */
    chans[0] = chan;
    if (!ast_strlen_zero(in->app)) {
        ast_manager_event_multichan(EVENT_FLAG_CALL, "OriginateResponse", chan ? 1 : 0, chans,
            "%s"
            "Response: %s\r\n"
            "Channel: %s\r\n"
            "Application: %s\r\n"
            "Data: %s\r\n"
            "Reason: %d\r\n"
            "Uniqueid: %s\r\n"
            "CallerIDNum: %s\r\n"
            "CallerIDName: %s\r\n",
            in->idtext, res ? "Failure" : "Success",
            chan ? ast_channel_name(chan) : requested_channel,
            in->app, in->appdata, reason,
            chan ? ast_channel_uniqueid(chan) : S_OR(in->channelid, "<unknown>"),
            S_OR(in->cid_num, "<unknown>"),
            S_OR(in->cid_name, "<unknown>")
            );
    } else {
        ast_manager_event_multichan(EVENT_FLAG_CALL, "OriginateResponse", chan ? 1 : 0, chans,
            "%s"
            "Response: %s\r\n"
            "Channel: %s\r\n"
            "Context: %s\r\n"
            "Exten: %s\r\n"
            "Reason: %d\r\n"
            "Uniqueid: %s\r\n"
            "CallerIDNum: %s\r\n"
            "CallerIDName: %s\r\n",
            in->idtext, res ? "Failure" : "Success",
            chan ? ast_channel_name(chan) : requested_channel,
            in->context, in->exten, reason,
            chan ? ast_channel_uniqueid(chan) : S_OR(in->channelid, "<unknown>"),
            S_OR(in->cid_num, "<unknown>"),
            S_OR(in->cid_name, "<unknown>")
            );
    }
 
    /* Locked and ref'd by ast_pbx_outgoing_exten or ast_pbx_outgoing_app */
    if (chan) {
        ast_channel_unlock(chan);
        ast_channel_unref(chan);
    }
    destroy_fast_originate_helper(in);
    return NULL;
}

References AST_CHANNEL_NAME, ast_channel_name(), ast_channel_uniqueid(), ast_channel_unlock, ast_channel_unref, ast_manager_event_multichan, AST_OUTGOING_WAIT, ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), ast_strlen_zero(), destroy_fast_originate_helper(), EVENT_FLAG_CALL, in, NULL, S_OR, and ast_assigned_ids::uniqueid.

Referenced by action_originate().

file_in_modules_dir()

static int file_in_modules_dir ( const char *  filename )

static

Check if the given file path is in the modules dir or not.

Note

When the module is being loaded / reloaded / unloaded, the modules dir is automatically prepended

Returns

1 if inside modules dir

0 if outside modules dir

-1 on failure

Definition at line 6881 of file manager.c.

{
    char *stripped_filename;
    RAII_VAR(char *, path, NULL, ast_free);
    RAII_VAR(char *, real_path, NULL, ast_free);
 
    /* Don't bother checking */
    if (live_dangerously) {
        return 1;
    }
 
    stripped_filename = ast_strip(ast_strdupa(filename));
 
    /* Always prepend the modules dir since that is what the code does for ModuleLoad */
    if (ast_asprintf(&path, "%s/%s", ast_config_AST_MODULE_DIR, stripped_filename) == -1) {
        return -1;
    }
 
    real_path = realpath(path, NULL);
    if (!real_path) {
        return -1;
    }
 
    return ast_begins_with(real_path, ast_config_AST_MODULE_DIR);
}

References ast_asprintf, ast_begins_with(), ast_config_AST_MODULE_DIR, ast_free, ast_strdupa, ast_strip(), live_dangerously, NULL, and RAII_VAR.

Referenced by manager_moduleload().

filter_cmp_fn()

static int filter_cmp_fn ( void *  obj, void *  arg, void *  data, int  flags  )

static

Definition at line 5596 of file manager.c.

{
    struct eventqent *eqe = arg;
    struct event_filter_entry *filter_entry = obj;
    char *line_buffer_start = NULL;
    char *line_buffer = NULL;
    char *line = NULL;
    int match = 0;
    int *result = data;
 
    if (filter_entry->event_name_hash) {
        if (eqe->event_name_hash != filter_entry->event_name_hash) {
            goto done;
        }
    }
 
    /* We're looking at the entire event data */
    if (!filter_entry->header_name) {
        match = match_eventdata(filter_entry, eqe->eventdata);
        goto done;
    }
 
    /* We're looking at a specific header */
    line_buffer_start = ast_strdup(eqe->eventdata);
    line_buffer = line_buffer_start;
    if (!line_buffer_start) {
        goto done;
    }
 
    while ((line = ast_read_line_from_buffer(&line_buffer))) {
        if (ast_begins_with(line, filter_entry->header_name)) {
            line += strlen(filter_entry->header_name);
            line = ast_skip_blanks(line);
            if (ast_strlen_zero(line)) {
                continue;
            }
            match = match_eventdata(filter_entry, line);
            if (match) {
                ast_free(line_buffer_start);
                line_buffer_start = NULL;
                break;
            }
        }
    }
 
    ast_free(line_buffer_start);
 
done:
 
    *result = match;
    return match ? CMP_MATCH | CMP_STOP : 0;
}

References ast_begins_with(), ast_free, ast_read_line_from_buffer(), ast_skip_blanks(), ast_strdup, ast_strlen_zero(), CMP_MATCH, CMP_STOP, done, eventqent::event_name_hash, event_filter_entry::event_name_hash, event_filter_entry::header_name, match(), match_eventdata(), NULL, and result.

Referenced by should_send_event().

function_capable_string_allowed_with_auths()

static int function_capable_string_allowed_with_auths ( const char *  evaluating, int  writepermlist  )

static

Checks to see if a string which can be used to evaluate functions should be rejected.

Definition at line 781 of file manager.c.

{
    if (!(writepermlist & EVENT_FLAG_SYSTEM)
        && (
            strstr(evaluating, "SHELL") ||       /* NoOp(${SHELL(rm -rf /)})  */
            strstr(evaluating, "EVAL")           /* NoOp(${EVAL(${some_var_containing_SHELL})}) */
        )) {
        return 0;
    }
    return 1;
}

References EVENT_FLAG_SYSTEM.

Referenced by action_getvar(), and action_status().

generate_status()

static void generate_status ( struct mansession *  s, struct ast_channel *  chan, char **  vars, int  varc, int  all_variables, char *  id_text, int *  count  )

static

Definition at line 3637 of file manager.c.

{
    struct timeval now;
    long elapsed_seconds;
    struct ast_bridge *bridge;
    RAII_VAR(struct ast_str *, variable_str, NULL, ast_free);
    struct ast_str *write_transpath = ast_str_alloca(256);
    struct ast_str *read_transpath = ast_str_alloca(256);
    struct ast_str *codec_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
    struct ast_party_id effective_id;
    int i;
    RAII_VAR(struct ast_channel_snapshot *, snapshot,
        ast_channel_snapshot_get_latest(ast_channel_uniqueid(chan)),
        ao2_cleanup);
    RAII_VAR(struct ast_str *, snapshot_str, NULL, ast_free);
 
    if (!snapshot) {
        return;
    }
 
    snapshot_str = ast_manager_build_channel_state_string(snapshot);
    if (!snapshot_str) {
        return;
    }
 
    if (all_variables) {
        variable_str = ast_str_create(2048);
    } else {
        variable_str = ast_str_create(1024);
    }
    if (!variable_str) {
        return;
    }
 
    now = ast_tvnow();
    elapsed_seconds = ast_tvdiff_sec(now, ast_channel_creationtime(chan));
 
    /* Even if all_variables has been specified, explicitly requested variables
     * may be global variables or dialplan functions */
    for (i = 0; i < varc; i++) {
        char valbuf[512], *ret = NULL;
 
        if (vars[i][strlen(vars[i]) - 1] == ')') {
            if (ast_func_read(chan, vars[i], valbuf, sizeof(valbuf)) < 0) {
                valbuf[0] = '\0';
            }
            ret = valbuf;
        } else {
            pbx_retrieve_variable(chan, vars[i], &ret, valbuf, sizeof(valbuf), NULL);
        }
 
        ast_str_append(&variable_str, 0, "Variable: %s=%s\r\n", vars[i], ret);
    }
 
    /* Walk all channel variables and add them */
    if (all_variables) {
        struct ast_var_t *variables;
 
        AST_LIST_TRAVERSE(ast_channel_varshead(chan), variables, entries) {
            ast_str_append(&variable_str, 0, "Variable: %s=%s\r\n",
                ast_var_name(variables), ast_var_value(variables));
        }
    }
 
    bridge = ast_channel_get_bridge(chan);
    effective_id = ast_channel_connected_effective_id(chan);
 
    astman_append(s,
        "Event: Status\r\n"
        "Privilege: Call\r\n"
        "%s"
        "Type: %s\r\n"
        "DNID: %s\r\n"
        "EffectiveConnectedLineNum: %s\r\n"
        "EffectiveConnectedLineName: %s\r\n"
        "TimeToHangup: %ld\r\n"
        "BridgeID: %s\r\n"
        "Application: %s\r\n"
        "Data: %s\r\n"
        "Nativeformats: %s\r\n"
        "Readformat: %s\r\n"
        "Readtrans: %s\r\n"
        "Writeformat: %s\r\n"
        "Writetrans: %s\r\n"
        "Callgroup: %llu\r\n"
        "Pickupgroup: %llu\r\n"
        "Seconds: %ld\r\n"
        "%s"
        "%s"
        "\r\n",
        ast_str_buffer(snapshot_str),
        ast_channel_tech(chan)->type,
        S_OR(ast_channel_dialed(chan)->number.str, ""),
        S_COR(effective_id.number.valid, effective_id.number.str, "<unknown>"),
        S_COR(effective_id.name.valid, effective_id.name.str, "<unknown>"),
        (long)ast_channel_whentohangup(chan)->tv_sec,
        bridge ? bridge->uniqueid : "",
        ast_channel_appl(chan),
        ast_channel_data(chan),
        ast_format_cap_get_names(ast_channel_nativeformats(chan), &codec_buf),
        ast_format_get_name(ast_channel_readformat(chan)),
        ast_translate_path_to_str(ast_channel_readtrans(chan), &read_transpath),
        ast_format_get_name(ast_channel_writeformat(chan)),
        ast_translate_path_to_str(ast_channel_writetrans(chan), &write_transpath),
        ast_channel_callgroup(chan),
        ast_channel_pickupgroup(chan),
        (long)elapsed_seconds,
        ast_str_buffer(variable_str),
        id_text);
    ++*count;
 
    ao2_cleanup(bridge);
}

References ao2_cleanup, ast_channel_appl(), ast_channel_callgroup(), ast_channel_connected_effective_id(), ast_channel_creationtime(), ast_channel_data(), ast_channel_dialed(), ast_channel_get_bridge(), ast_channel_nativeformats(), ast_channel_pickupgroup(), ast_channel_readformat(), ast_channel_readtrans(), ast_channel_snapshot_get_latest(), ast_channel_tech(), ast_channel_uniqueid(), ast_channel_varshead(), ast_channel_whentohangup(), ast_channel_writeformat(), ast_channel_writetrans(), ast_format_cap_get_names(), AST_FORMAT_CAP_NAMES_LEN, ast_format_get_name(), ast_free, ast_func_read(), AST_LIST_TRAVERSE, ast_manager_build_channel_state_string(), ast_str_alloca, ast_str_append(), ast_str_buffer(), ast_str_create, ast_translate_path_to_str(), ast_tvdiff_sec(), ast_tvnow(), ast_var_name(), ast_var_value(), astman_append(), ast_party_id::name, NULL, ast_party_id::number, pbx_retrieve_variable(), RAII_VAR, S_COR, S_OR, ast_party_name::str, ast_party_number::str, type, ast_bridge::uniqueid, ast_party_name::valid, and ast_party_number::valid.

Referenced by action_status().

get_input()

static int get_input ( struct mansession *  s, char *  output  )

static

Read one full line (including crlf) from the manager socket.

Note

* \r\n is the only valid terminator for the line.
* (Note that, later, '\0' will be considered as the end-of-line marker,
* so everything between the '\0' and the '\r\n' will not be used).
* Also note that we assume output to have at least "maxlen" space.
* 

Definition at line 7155 of file manager.c.

{
    int res, x;
    int maxlen = sizeof(s->session->inbuf) - 1;
    char *src = s->session->inbuf;
    int timeout = -1;
    time_t now;
 
    /*
     * Look for \r\n within the buffer. If found, copy to the output
     * buffer and return, trimming the \r\n (not used afterwards).
     */
    for (x = 0; x < s->session->inlen; x++) {
        int cr; /* set if we have \r */
        if (src[x] == '\r' && x+1 < s->session->inlen && src[x + 1] == '\n') {
            cr = 2; /* Found. Update length to include \r\n */
        } else if (src[x] == '\n') {
            cr = 1; /* also accept \n only */
        } else {
            continue;
        }
        memmove(output, src, x);    /*... but trim \r\n */
        output[x] = '\0';       /* terminate the string */
        x += cr;            /* number of bytes used */
        s->session->inlen -= x;         /* remaining size */
        memmove(src, src + x, s->session->inlen); /* remove used bytes */
        return 1;
    }
    if (s->session->inlen >= maxlen) {
        /* no crlf found, and buffer full - sorry, too long for us
         * keep the last character in case we are in the middle of a CRLF. */
        ast_log(LOG_WARNING, "Discarding message from %s. Line too long: %.25s...\n", ast_sockaddr_stringify_addr(&s->session->addr), src);
        src[0] = src[s->session->inlen - 1];
        s->session->inlen = 1;
        s->parsing = MESSAGE_LINE_TOO_LONG;
    }
    res = 0;
    while (res == 0) {
        /* calculate a timeout if we are not authenticated */
        if (!s->session->authenticated) {
            if(time(&now) == -1) {
                ast_log(LOG_ERROR, "error executing time(): %s\n", strerror(errno));
                return -1;
            }
 
            timeout = (authtimeout - (now - s->session->authstart)) * 1000;
            if (timeout < 0) {
                /* we have timed out */
                return 0;
            }
        }
 
        ast_mutex_lock(&s->session->notify_lock);
        if (s->session->pending_event) {
            s->session->pending_event = 0;
            ast_mutex_unlock(&s->session->notify_lock);
            return 0;
        }
        s->session->waiting_thread = pthread_self();
        ast_mutex_unlock(&s->session->notify_lock);
 
        res = ast_wait_for_input(ast_iostream_get_fd(s->session->stream), timeout);
 
        ast_mutex_lock(&s->session->notify_lock);
        s->session->waiting_thread = AST_PTHREADT_NULL;
        ast_mutex_unlock(&s->session->notify_lock);
    }
    if (res < 0) {
        if (s->session->kicked) {
            ast_debug(1, "Manager session has been kicked\n");
            return -1;
        }
        /* If we get a signal from some other thread (typically because
         * there are new events queued), return 0 to notify the caller.
         */
        if (errno == EINTR || errno == EAGAIN) {
            return 0;
        }
        ast_log(LOG_WARNING, "poll() returned error: %s\n", strerror(errno));
        return -1;
    }
 
    ao2_lock(s->session);
    res = ast_iostream_read(s->session->stream, src + s->session->inlen, maxlen - s->session->inlen);
    if (res < 1) {
        res = -1;   /* error return */
    } else {
        s->session->inlen += res;
        src[s->session->inlen] = '\0';
        res = 0;
    }
    ao2_unlock(s->session);
    return res;
}

References mansession_session::addr, ao2_lock, ao2_unlock, ast_debug, ast_iostream_get_fd(), ast_iostream_read(), ast_log, ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, ast_sockaddr_stringify_addr(), ast_wait_for_input(), mansession_session::authenticated, mansession_session::authstart, authtimeout, errno, mansession_session::inbuf, mansession_session::inlen, mansession_session::kicked, LOG_ERROR, LOG_WARNING, MESSAGE_LINE_TOO_LONG, mansession_session::notify_lock, mansession::parsing, mansession_session::pending_event, mansession::session, mansession_session::stream, and mansession_session::waiting_thread.

Referenced by do_message().

get_manager_by_name_locked()

static struct ast_manager_user * get_manager_by_name_locked ( const char *  name )

static

lookup an entry in the list of registered users. must be called with the list lock held.

Definition at line 1046 of file manager.c.

{
    struct ast_manager_user *user = NULL;
 
    AST_RWLIST_TRAVERSE(&users, user, list) {
        if (!strcasecmp(user->username, name)) {
            break;
        }
    }
 
    return user;
}

References AST_RWLIST_TRAVERSE, name, NULL, and user.

Referenced by __init_manager(), auth_http_callback(), authenticate(), function_amiclient(), handle_showmanager(), manager_displayconnects(), and process_message().

get_perm()

static int get_perm ( const char *  instr )

static

Definition at line 866 of file manager.c.

{
    int x = 0, ret = 0;
 
    if (!instr) {
        return 0;
    }
 
    for (x = 0; x < ARRAY_LEN(perms); x++) {
        if (ast_instring(instr, perms[x].label, ',')) {
            ret |= perms[x].num;
        }
    }
 
    return ret;
}

References ARRAY_LEN, ast_instring(), permalias::num, and perms.

Referenced by __init_manager(), and strings_to_mask().

grab_last()

static struct eventqent * grab_last ( void  )

static

Grab a reference to the last event, update usecount as needed. Can handle a NULL pointer.

Definition at line 698 of file manager.c.

{
    struct eventqent *ret;
 
    AST_RWLIST_WRLOCK(&all_events);
    ret = AST_RWLIST_LAST(&all_events);
    /* the list is never empty now, but may become so when
     * we optimize it in the future, so be prepared.
     */
    if (ret) {
        ast_atomic_fetchadd_int(&ret->usecount, 1);
    }
    AST_RWLIST_UNLOCK(&all_events);
    return ret;
}

References ast_atomic_fetchadd_int(), AST_RWLIST_LAST, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, and eventqent::usecount.

Referenced by auth_http_callback(), generic_http_callback(), and session_do().

handle_kickmanconn()

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

static

CLI command manager kick session.

Definition at line 1412 of file manager.c.

{
    struct ao2_container *sessions;
    struct mansession_session *session;
    struct ao2_iterator i;
    int fd = -1;
    int found = 0;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "manager kick session";
        e->usage =
            "Usage: manager kick session <file descriptor>\n"
            "   Kick an active Asterisk Manager Interface session\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 4) {
        return CLI_SHOWUSAGE;
    }
 
    fd = atoi(a->argv[3]);
    if (fd <= 0) { /* STDOUT won't be a valid AMI fd either */
        ast_cli(a->fd, "Invalid AMI file descriptor: %s\n", a->argv[3]);
        return CLI_FAILURE;
    }
 
    sessions = ao2_global_obj_ref(mgr_sessions);
    if (sessions) {
        i = ao2_iterator_init(sessions, 0);
        ao2_ref(sessions, -1);
        while ((session = ao2_iterator_next(&i))) {
            ao2_lock(session);
            if (session->stream) {
                if (ast_iostream_get_fd(session->stream) == fd) {
                    if (session->kicked) {
                        ast_cli(a->fd, "Manager session using file descriptor %d has already been kicked\n", fd);
                        ao2_unlock(session);
                        unref_mansession(session);
                        break;
                    }
                    fd = ast_iostream_get_fd(session->stream);
                    found = fd;
                    ast_cli(a->fd, "Kicking manager session connected using file descriptor %d\n", fd);
                    ast_mutex_lock(&session->notify_lock);
                    session->kicked = 1;
                    if (session->waiting_thread != AST_PTHREADT_NULL) {
                        pthread_kill(session->waiting_thread, SIGURG);
                    }
                    ast_mutex_unlock(&session->notify_lock);
                    ao2_unlock(session);
                    unref_mansession(session);
                    break;
                }
            }
            ao2_unlock(session);
            unref_mansession(session);
        }
        ao2_iterator_destroy(&i);
    }
 
    if (!found) {
        ast_cli(a->fd, "No manager session found using file descriptor %d\n", fd);
    }
    return CLI_SUCCESS;
}

References a, ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_cli(), ast_iostream_get_fd(), ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, session, sessions, unref_mansession(), and ast_cli_entry::usage.

handle_manager_reload()

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

static

CLI command manager reload.

Definition at line 1561 of file manager.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "manager reload";
        e->usage =
            "Usage: manager reload\n"
            "       Reloads the manager configuration.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
    if (a->argc > 2) {
        return CLI_SHOWUSAGE;
    }
    reload_module();
    return CLI_SUCCESS;
}

References a, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, reload_module(), and ast_cli_entry::usage.

handle_mandebug()

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

static

Definition at line 1229 of file manager.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "manager set debug [on|off]";
        e->usage = "Usage: manager set debug [on|off]\n Show, enable, disable debugging of the manager code.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc == 3) {
        ast_cli(a->fd, "manager debug is %s\n", manager_debug? "on" : "off");
    } else if (a->argc == 4) {
        if (!strcasecmp(a->argv[3], "on")) {
            manager_debug = 1;
        } else if (!strcasecmp(a->argv[3], "off")) {
            manager_debug = 0;
        } else {
            return CLI_SHOWUSAGE;
        }
    }
    return CLI_SUCCESS;
}

References a, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, manager_debug, NULL, and ast_cli_entry::usage.

handle_parse_error()

static void handle_parse_error ( struct mansession *  s, struct message *  m, char *  error  )

static

Definition at line 7259 of file manager.c.

{
    mansession_lock(s);
    astman_send_error(s, m, error);
    s->parsing = MESSAGE_OKAY;
    mansession_unlock(s);
}

References astman_send_error(), error(), mansession_lock(), mansession_unlock(), MESSAGE_OKAY, and mansession::parsing.

Referenced by do_message().

handle_showmanager()

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

static

Definition at line 1254 of file manager.c.

{
    struct ast_manager_user *user = NULL;
    int l;
    struct ast_str *rauthority = ast_str_alloca(MAX_AUTH_PERM_STRING);
    struct ast_str *wauthority = ast_str_alloca(MAX_AUTH_PERM_STRING);
    struct ast_variable *v;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "manager show user";
        e->usage =
            " Usage: manager show user <user>\n"
            "        Display all information related to the manager user specified.\n";
        return NULL;
    case CLI_GENERATE:
        l = strlen(a->word);
        if (a->pos != 3) {
            return NULL;
        }
        AST_RWLIST_RDLOCK(&users);
        AST_RWLIST_TRAVERSE(&users, user, list) {
            if (!strncasecmp(a->word, user->username, l)) {
                if (ast_cli_completion_add(ast_strdup(user->username))) {
                    break;
                }
            }
        }
        AST_RWLIST_UNLOCK(&users);
        return NULL;
    }
 
    if (a->argc != 4) {
        return CLI_SHOWUSAGE;
    }
 
    AST_RWLIST_RDLOCK(&users);
 
    if (!(user = get_manager_by_name_locked(a->argv[3]))) {
        ast_cli(a->fd, "There is no manager called %s\n", a->argv[3]);
        AST_RWLIST_UNLOCK(&users);
        return CLI_SUCCESS;
    }
 
    ast_cli(a->fd, "\n");
    ast_cli(a->fd,
        "          username: %s\n"
        "            secret: %s\n"
        "               ACL: %s\n"
        "         read perm: %s\n"
        "        write perm: %s\n"
        "   displayconnects: %s\n"
        "allowmultiplelogin: %s\n",
        S_OR(user->username, "(N/A)"),
        (user->secret ? "<Set>" : "(N/A)"),
        ((user->acl && !ast_acl_list_is_empty(user->acl)) ? "yes" : "no"),
        user_authority_to_str(user->readperm, &rauthority),
        user_authority_to_str(user->writeperm, &wauthority),
        (user->displayconnects ? "yes" : "no"),
        (user->allowmultiplelogin ? "yes" : "no"));
    ast_cli(a->fd, "         Variables: \n");
        for (v = user->chanvars ; v ; v = v->next) {
            ast_cli(a->fd, "                 %s = %s\n", v->name, v->value);
        }
    if (!ast_acl_list_is_empty(user->acl)) {
        ast_acl_output(a->fd, user->acl, NULL);
    }
 
    AST_RWLIST_UNLOCK(&users);
 
    return CLI_SUCCESS;
}

References a, ast_acl_list_is_empty(), ast_acl_output(), ast_cli(), ast_cli_completion_add(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_str_alloca, ast_strdup, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, get_manager_by_name_locked(), MAX_AUTH_PERM_STRING, ast_variable::name, ast_variable::next, NULL, S_OR, ast_cli_entry::usage, user_authority_to_str(), and ast_variable::value.

handle_showmanagers()

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

static

Definition at line 1327 of file manager.c.

{
    struct ast_manager_user *user = NULL;
    int count_amu = 0;
    switch (cmd) {
    case CLI_INIT:
        e->command = "manager show users";
        e->usage =
            "Usage: manager show users\n"
            "       Prints a listing of all managers that are currently configured on that\n"
            " system.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
    if (a->argc != 3) {
        return CLI_SHOWUSAGE;
    }
 
    AST_RWLIST_RDLOCK(&users);
 
    /* If there are no users, print out something along those lines */
    if (AST_RWLIST_EMPTY(&users)) {
        ast_cli(a->fd, "There are no manager users.\n");
        AST_RWLIST_UNLOCK(&users);
        return CLI_SUCCESS;
    }
 
    ast_cli(a->fd, "\nusername\n--------\n");
 
    AST_RWLIST_TRAVERSE(&users, user, list) {
        ast_cli(a->fd, "%s\n", user->username);
        count_amu++;
    }
 
    AST_RWLIST_UNLOCK(&users);
 
    ast_cli(a->fd,"-------------------\n"
              "%d manager users configured.\n", count_amu);
    return CLI_SUCCESS;
}

References a, ast_cli(), AST_RWLIST_EMPTY, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, and ast_cli_entry::usage.

handle_showmancmd()

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

static

Definition at line 1081 of file manager.c.

{
    struct manager_action *cur;
    struct ast_str *authority;
    int num;
    int l;
    const char *auth_str;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "manager show command";
        e->usage =
            "Usage: manager show command <actionname> [<actionname> [<actionname> [...]]]\n"
            "   Shows the detailed description for a specific Asterisk manager interface command.\n";
        return NULL;
    case CLI_GENERATE:
        l = strlen(a->word);
        AST_RWLIST_RDLOCK(&actions);
        AST_RWLIST_TRAVERSE(&actions, cur, list) {
            if (!strncasecmp(a->word, cur->action, l)) {
                if (ast_cli_completion_add(ast_strdup(cur->action))) {
                    break;
                }
            }
        }
        AST_RWLIST_UNLOCK(&actions);
        return NULL;
    }
    if (a->argc < 4) {
        return CLI_SHOWUSAGE;
    }
 
    authority = ast_str_alloca(MAX_AUTH_PERM_STRING);
 
    AST_RWLIST_RDLOCK(&actions);
    AST_RWLIST_TRAVERSE(&actions, cur, list) {
        for (num = 3; num < a->argc; num++) {
            if (!strcasecmp(cur->action, a->argv[num])) {
                auth_str = authority_to_str(cur->authority, &authority);
 
#ifdef AST_XML_DOCS
                if (cur->docsrc == AST_XML_DOC) {
                    char *synopsis = ast_xmldoc_printable(S_OR(cur->synopsis, "Not available"), 1);
                    char *since = ast_xmldoc_printable(S_OR(cur->since, "Not available"), 1);
                    char *description = ast_xmldoc_printable(S_OR(cur->description, "Not available"), 1);
                    char *syntax = ast_xmldoc_printable(S_OR(cur->syntax, "Not available"), 1);
                    char *arguments = ast_xmldoc_printable(S_OR(cur->arguments, "Not available"), 1);
                    char *privilege = ast_xmldoc_printable(S_OR(auth_str, "Not available"), 1);
                    char *seealso = ast_xmldoc_printable(S_OR(cur->seealso, "Not available"), 1);
                    char *responses = ast_xmldoc_printable("None", 1);
 
                    if (!synopsis || !since || !description || !syntax || !arguments
                            || !privilege || !seealso || !responses) {
                        ast_free(synopsis);
                        ast_free(since);
                        ast_free(description);
                        ast_free(syntax);
                        ast_free(arguments);
                        ast_free(privilege);
                        ast_free(seealso);
                        ast_free(responses);
                        ast_cli(a->fd, "Allocation failure.\n");
                        AST_RWLIST_UNLOCK(&actions);
 
                        return CLI_FAILURE;
                    }
 
                    ast_cli(a->fd, "\n"
                        "%s  -= Info about Manager Command '%s' =- %s\n\n"
                        COLORIZE_FMT "\n"
                        "%s\n\n"
                        COLORIZE_FMT "\n"
                        "%s\n\n"
                        COLORIZE_FMT "\n"
                        "%s\n\n"
                        COLORIZE_FMT "\n"
                        "%s\n\n"
                        COLORIZE_FMT "\n"
                        "%s\n\n"
                        COLORIZE_FMT "\n"
                        "%s\n\n"
                        COLORIZE_FMT "\n"
                        "%s\n\n"
                        COLORIZE_FMT "\n",
                        ast_term_color(COLOR_MAGENTA, 0), cur->action, ast_term_reset(),
                        COLORIZE(COLOR_MAGENTA, 0, "[Synopsis]"), synopsis,
                        COLORIZE(COLOR_MAGENTA, 0, "[Since]"), since,
                        COLORIZE(COLOR_MAGENTA, 0, "[Description]"), description,
                        COLORIZE(COLOR_MAGENTA, 0, "[Syntax]"), syntax,
                        COLORIZE(COLOR_MAGENTA, 0, "[Arguments]"), arguments,
                        COLORIZE(COLOR_MAGENTA, 0, "[Privilege]"), privilege,
                        COLORIZE(COLOR_MAGENTA, 0, "[See Also]"), seealso,
                        COLORIZE(COLOR_MAGENTA, 0, "[List Responses]")
                        );
 
                    if (!cur->list_responses) {
                        ast_cli(a->fd, "%s\n\n", responses);
                    } else {
                        struct ast_xml_doc_item *temp;
                        for (temp = cur->list_responses; temp; temp = AST_LIST_NEXT(temp, next)) {
                            ast_cli(a->fd, "Event: %s\n", temp->name);
                            print_event_instance(a, temp);
                        }
                    }
                    ast_cli(a->fd,
                        COLORIZE_FMT "\n",
                        COLORIZE(COLOR_MAGENTA, 0, "[End List Responses]")
                        );
 
                    ast_cli(a->fd, "\n"
                        COLORIZE_FMT "\n",
                        COLORIZE(COLOR_MAGENTA, 0, "[Final Response]")
                        );
                    if (!cur->final_response) {
                        ast_cli(a->fd, "%s\n\n", responses);
                    } else {
                        ast_cli(a->fd, "Event: %s\n", cur->final_response->name);
                        print_event_instance(a, cur->final_response);
                    }
                    ast_cli(a->fd,
                        COLORIZE_FMT "\n",
                        COLORIZE(COLOR_MAGENTA, 0, "[End Final Response]")
                        );
 
                    ast_free(synopsis);
                    ast_free(since);
                    ast_free(description);
                    ast_free(syntax);
                    ast_free(arguments);
                    ast_free(privilege);
                    ast_free(seealso);
                    ast_free(responses);
                } else
#endif
                {
                    ast_cli(a->fd, "Action: %s\nSynopsis: %s\nPrivilege: %s\n%s\n",
                        cur->action, cur->synopsis,
                        auth_str,
                        S_OR(cur->description, ""));
                }
            }
        }
    }
    AST_RWLIST_UNLOCK(&actions);
 
    return CLI_SUCCESS;
}

References a, manager_action::action, manager_action::arguments, ast_xml_doc_item::arguments, ast_cli(), ast_cli_completion_add(), ast_free, AST_LIST_NEXT, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_str_alloca, ast_strdup, ast_term_color(), ast_term_reset(), AST_XML_DOC, ast_xmldoc_printable(), manager_action::authority, authority_to_str(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, COLOR_MAGENTA, COLORIZE, COLORIZE_FMT, ast_cli_entry::command, manager_action::description, ast_xml_doc_item::description, manager_action::docsrc, manager_action::final_response, manager_action::list_responses, MAX_AUTH_PERM_STRING, ast_xml_doc_item::name, ast_xml_doc_item::next, NULL, print_event_instance(), S_OR, manager_action::seealso, ast_xml_doc_item::seealso, ast_xml_doc_item::since, synopsis, manager_action::synopsis, manager_action::syntax, ast_xml_doc_item::syntax, and ast_cli_entry::usage.

handle_showmancmds()

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

static

CLI command manager list commands.

Definition at line 1370 of file manager.c.

{
    struct manager_action *cur;
    int name_len = 1;
    int space_remaining;
#define HSMC_FORMAT "  %-*.*s  %-.*s\n"
    switch (cmd) {
    case CLI_INIT:
        e->command = "manager show commands";
        e->usage =
            "Usage: manager show commands\n"
            "   Prints a listing of all the available Asterisk manager interface commands.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    AST_RWLIST_RDLOCK(&actions);
    AST_RWLIST_TRAVERSE(&actions, cur, list) {
        int incoming_len = strlen(cur->action);
        if (incoming_len > name_len) {
            name_len = incoming_len;
        }
    }
 
    space_remaining = MGR_SHOW_TERMINAL_WIDTH - name_len - 4;
    if (space_remaining < 0) {
        space_remaining = 0;
    }
 
    ast_cli(a->fd, HSMC_FORMAT, name_len, name_len, "Action", space_remaining, "Synopsis");
    ast_cli(a->fd, HSMC_FORMAT, name_len, name_len, "------", space_remaining, "--------");
 
    AST_RWLIST_TRAVERSE(&actions, cur, list) {
        ast_cli(a->fd, HSMC_FORMAT, name_len, name_len, cur->action, space_remaining, cur->synopsis);
    }
    AST_RWLIST_UNLOCK(&actions);
 
    return CLI_SUCCESS;
}

References a, manager_action::action, ast_cli(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, HSMC_FORMAT, MGR_SHOW_TERMINAL_WIDTH, NULL, manager_action::synopsis, and ast_cli_entry::usage.

handle_showmanconn()

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

static

CLI command manager list connected.

Definition at line 1482 of file manager.c.

{
    struct ao2_container *sessions;
    struct mansession_session *session;
    time_t now = time(NULL);
#define HSMCONN_FORMAT1 "  %-15.15s  %-55.55s  %-10.10s  %-10.10s  %-8.8s  %-8.8s  %-10.10s  %-10.10s\n"
#define HSMCONN_FORMAT2 "  %-15.15s  %-55.55s  %-10d  %-10d  %-8d  %-8d  %-10.10d  %-10.10d\n"
    int count = 0;
    struct ao2_iterator i;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "manager show connected";
        e->usage =
            "Usage: manager show connected\n"
            "   Prints a listing of the users that are currently connected to the\n"
            "Asterisk manager interface.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    ast_cli(a->fd, HSMCONN_FORMAT1, "Username", "IP Address", "Start", "Elapsed", "FileDes", "HttpCnt", "ReadPerms", "WritePerms");
 
    sessions = ao2_global_obj_ref(mgr_sessions);
    if (sessions) {
        i = ao2_iterator_init(sessions, 0);
        ao2_ref(sessions, -1);
        while ((session = ao2_iterator_next(&i))) {
            ao2_lock(session);
            ast_cli(a->fd, HSMCONN_FORMAT2, session->username,
                ast_sockaddr_stringify_addr(&session->addr),
                (int) (session->sessionstart),
                (int) (now - session->sessionstart),
                session->stream ? ast_iostream_get_fd(session->stream) : -1,
                session->inuse,
                session->readperm,
                session->writeperm);
            count++;
            ao2_unlock(session);
            unref_mansession(session);
        }
        ao2_iterator_destroy(&i);
    }
    ast_cli(a->fd, "%d users connected.\n", count);
 
    return CLI_SUCCESS;
}

References a, ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_cli(), ast_iostream_get_fd(), ast_sockaddr_stringify_addr(), CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, HSMCONN_FORMAT1, HSMCONN_FORMAT2, NULL, session, sessions, unref_mansession(), and ast_cli_entry::usage.

handle_showmaneventq()

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

static

CLI command manager list eventq.

Definition at line 1533 of file manager.c.

{
    struct eventqent *s;
    switch (cmd) {
    case CLI_INIT:
        e->command = "manager show eventq";
        e->usage =
            "Usage: manager show eventq\n"
            "   Prints a listing of all events pending in the Asterisk manger\n"
            "event queue.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
    AST_RWLIST_RDLOCK(&all_events);
    AST_RWLIST_TRAVERSE(&all_events, s, eq_next) {
        ast_cli(a->fd, "Usecount: %d\n", s->usecount);
        ast_cli(a->fd, "Category: %d\n", s->category);
        ast_cli(a->fd, "Event:\n%s", s->eventdata);
    }
    AST_RWLIST_UNLOCK(&all_events);
 
    return CLI_SUCCESS;
}

References a, ast_cli(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, eventqent::category, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, NULL, ast_cli_entry::usage, and eventqent::usecount.

handle_updates()

static enum error_type handle_updates ( struct mansession *  s, const struct message *  m, struct ast_config *  cfg, const char *  dfn  )

static

helper function for action_updateconfig

Definition at line 2723 of file manager.c.

{
    int x;
    char hdr[40];
    const char *action, *cat, *var, *value, *match, *line, *options;
    struct ast_variable *v;
    struct ast_str *str1 = ast_str_create(16), *str2 = ast_str_create(16);
    enum error_type result = 0;
 
    for (x = 0; x < 100000; x++) {  /* 100000 = the max number of allowed updates + 1 */
        unsigned int object = 0;
        char *dupoptions;
        int allowdups = 0;
        int istemplate = 0;
        int ignoreerror = 0;
        RAII_VAR(char *, inherit, NULL, ast_free);
        RAII_VAR(char *, catfilter, NULL, ast_free);
        char *token;
        int foundvar = 0;
        int foundcat = 0;
        struct ast_category *category = NULL;
 
        snprintf(hdr, sizeof(hdr), "Action-%06d", x);
        action = astman_get_header(m, hdr);
        if (ast_strlen_zero(action))        /* breaks the for loop if no action header */
            break;                          /* this could cause problems if actions come in misnumbered */
 
        snprintf(hdr, sizeof(hdr), "Cat-%06d", x);
        cat = astman_get_header(m, hdr);
        if (ast_strlen_zero(cat)) {     /* every action needs a category */
            result =  UNSPECIFIED_CATEGORY;
            break;
        }
 
        snprintf(hdr, sizeof(hdr), "Var-%06d", x);
        var = astman_get_header(m, hdr);
 
        snprintf(hdr, sizeof(hdr), "Value-%06d", x);
        value = astman_get_header(m, hdr);
 
        if (!ast_strlen_zero(value) && *value == '>') {
            object = 1;
            value++;
        }
 
        snprintf(hdr, sizeof(hdr), "Match-%06d", x);
        match = astman_get_header(m, hdr);
 
        snprintf(hdr, sizeof(hdr), "Line-%06d", x);
        line = astman_get_header(m, hdr);
 
        snprintf(hdr, sizeof(hdr), "Options-%06d", x);
        options = astman_get_header(m, hdr);
        if (!ast_strlen_zero(options)) {
            char copy[strlen(options) + 1];
            strcpy(copy, options); /* safe */
            dupoptions = copy;
            while ((token = ast_strsep(&dupoptions, ',', AST_STRSEP_STRIP))) {
                if (!strcasecmp("allowdups", token)) {
                    allowdups = 1;
                    continue;
                }
                if (!strcasecmp("template", token)) {
                    istemplate = 1;
                    continue;
                }
                if (!strcasecmp("ignoreerror", token)) {
                    ignoreerror = 1;
                    continue;
                }
                if (ast_begins_with(token, "inherit")) {
                    char *c = ast_strsep(&token, '=', AST_STRSEP_STRIP);
                    c = ast_strsep(&token, '=', AST_STRSEP_STRIP);
                    if (c) {
                        inherit = ast_strdup(c);
                    }
                    continue;
                }
                if (ast_begins_with(token, "catfilter")) {
                    char *c = ast_strsep(&token, '=', AST_STRSEP_STRIP);
                    c = ast_strsep(&token, '=', AST_STRSEP_STRIP);
                    if (c) {
                        catfilter = ast_strdup(c);
                    }
                    continue;
                }
            }
        }
 
        if (!strcasecmp(action, "newcat")) {
            struct ast_category *template;
            char *tmpl_name = NULL;
 
            if (!allowdups) {
                if (ast_category_get(cfg, cat, "TEMPLATES=include")) {
                    if (ignoreerror) {
                        continue;
                    } else {
                        result = FAILURE_NEWCAT;    /* already exist */
                        break;
                    }
                }
            }
 
            if (istemplate) {
                category = ast_category_new_template(cat, dfn, -1);
            } else {
                category = ast_category_new(cat, dfn, -1);
            }
 
            if (!category) {
                result = FAILURE_ALLOCATION;
                break;
            }
 
            if (inherit) {
                while ((tmpl_name = ast_strsep(&inherit, ',', AST_STRSEP_STRIP))) {
                    if ((template = ast_category_get(cfg, tmpl_name, "TEMPLATES=restrict"))) {
                        if (ast_category_inherit(category, template)) {
                            result = FAILURE_ALLOCATION;
                            break;
                        }
                    } else {
                        ast_category_destroy(category);
                        category = NULL;
                        result = FAILURE_TEMPLATE;  /* template not found */
                        break;
                    }
                }
            }
 
            if (category != NULL) {
                if (ast_strlen_zero(match)) {
                    ast_category_append(cfg, category);
                } else {
                    if (ast_category_insert(cfg, category, match)) {
                        ast_category_destroy(category);
                        result = FAILURE_NEWCAT;
                        break;
                    }
                }
            }
        } else if (!strcasecmp(action, "renamecat")) {
            if (ast_strlen_zero(value)) {
                result = UNSPECIFIED_ARGUMENT;
                break;
            }
 
            foundcat = 0;
            while ((category = ast_category_browse_filtered(cfg, cat, category, catfilter))) {
                ast_category_rename(category, value);
                foundcat = 1;
            }
 
            if (!foundcat) {
                result = UNKNOWN_CATEGORY;
                break;
            }
        } else if (!strcasecmp(action, "delcat")) {
            foundcat = 0;
            while ((category = ast_category_browse_filtered(cfg, cat, category, catfilter))) {
                category = ast_category_delete(cfg, category);
                foundcat = 1;
            }
 
            if (!foundcat && !ignoreerror) {
                result = UNKNOWN_CATEGORY;
                break;
            }
        } else if (!strcasecmp(action, "emptycat")) {
            foundcat = 0;
            while ((category = ast_category_browse_filtered(cfg, cat, category, catfilter))) {
                ast_category_empty(category);
                foundcat = 1;
            }
 
            if (!foundcat) {
                result = UNKNOWN_CATEGORY;
                break;
            }
        } else if (!strcasecmp(action, "update")) {
            if (ast_strlen_zero(var)) {
                result = UNSPECIFIED_ARGUMENT;
                break;
            }
 
            foundcat = 0;
            foundvar = 0;
            while ((category = ast_category_browse_filtered(cfg, cat, category, catfilter))) {
                if (!ast_variable_update(category, var, value, match, object)) {
                    foundvar = 1;
                }
                foundcat = 1;
            }
 
            if (!foundcat) {
                result = UNKNOWN_CATEGORY;
                break;
            }
 
            if (!foundvar) {
                result = FAILURE_UPDATE;
                break;
            }
        } else if (!strcasecmp(action, "delete")) {
            if ((ast_strlen_zero(var) && ast_strlen_zero(line))) {
                result = UNSPECIFIED_ARGUMENT;
                break;
            }
 
            foundcat = 0;
            foundvar = 0;
            while ((category = ast_category_browse_filtered(cfg, cat, category, catfilter))) {
                if (!ast_variable_delete(category, var, match, line)) {
                    foundvar = 1;
                }
                foundcat = 1;
            }
 
            if (!foundcat) {
                result = UNKNOWN_CATEGORY;
                break;
            }
 
            if (!foundvar && !ignoreerror) {
                result = FAILURE_UPDATE;
                break;
            }
        } else if (!strcasecmp(action, "append")) {
            if (ast_strlen_zero(var)) {
                result = UNSPECIFIED_ARGUMENT;
                break;
            }
 
            foundcat = 0;
            while ((category = ast_category_browse_filtered(cfg, cat, category, catfilter))) {
                if (!(v = ast_variable_new(var, value, dfn))) {
                    result = FAILURE_ALLOCATION;
                    break;
                }
                if (object || (match && !strcasecmp(match, "object"))) {
                    v->object = 1;
                }
                ast_variable_append(category, v);
                foundcat = 1;
            }
 
            if (!foundcat) {
                result = UNKNOWN_CATEGORY;
                break;
            }
        } else if (!strcasecmp(action, "insert")) {
            if (ast_strlen_zero(var) || ast_strlen_zero(line)) {
                result = UNSPECIFIED_ARGUMENT;
                break;
            }
 
            foundcat = 0;
            while ((category = ast_category_browse_filtered(cfg, cat, category, catfilter))) {
                if (!(v = ast_variable_new(var, value, dfn))) {
                    result = FAILURE_ALLOCATION;
                    break;
                }
                ast_variable_insert(category, v, line);
                foundcat = 1;
            }
 
            if (!foundcat) {
                result = UNKNOWN_CATEGORY;
                break;
            }
        }
        else {
            ast_log(LOG_WARNING, "Action-%06d: %s not handled\n", x, action);
            result = UNKNOWN_ACTION;
            break;
        }
    }
    ast_free(str1);
    ast_free(str2);
    return result;
}

References ast_begins_with(), ast_category_append(), ast_category_browse_filtered(), ast_category_delete(), ast_category_destroy(), ast_category_empty(), ast_category_get(), ast_category_inherit(), ast_category_insert(), ast_category_new(), ast_category_new_template(), ast_category_rename(), ast_free, ast_log, ast_str_create, ast_strdup, ast_strlen_zero(), ast_strsep(), AST_STRSEP_STRIP, ast_variable_append(), ast_variable_delete(), ast_variable_insert(), ast_variable_new, ast_variable_update(), astman_get_header(), c, copy(), FAILURE_ALLOCATION, FAILURE_NEWCAT, FAILURE_TEMPLATE, FAILURE_UPDATE, LOG_WARNING, match(), NULL, ast_variable::object, options, RAII_VAR, result, UNKNOWN_ACTION, UNKNOWN_CATEGORY, UNSPECIFIED_ARGUMENT, UNSPECIFIED_CATEGORY, value, and var.

Referenced by action_updateconfig().

is_originate_app_permitted()

static int is_originate_app_permitted ( const char *  app, const char *  data, int  permission  )

static

Definition at line 5125 of file manager.c.

{
    int i;
 
    for (i = 0; originate_app_permissions[i].search; i++) {
        if (originate_app_permissions[i].searchfn(app, data, originate_app_permissions[i].search)) {
            return !!(permission & originate_app_permissions[i].permission);
        }
    }
 
    return 1;
}

References app, originate_app_permissions, originate_permissions_entry::permission, and originate_permissions_entry::search.

Referenced by action_originate().

is_restricted_file()

static int is_restricted_file ( const char *  filename )

static

Check if a file is restricted or not.

Returns

0 on success

1 on restricted file

-1 on failure

Definition at line 2468 of file manager.c.

{
    char *stripped_filename;
    RAII_VAR(char *, path, NULL, ast_free);
    RAII_VAR(char *, real_path, NULL, ast_std_free);
 
    if (live_dangerously) {
        return 0;
    }
 
    stripped_filename = ast_strip(ast_strdupa(filename));
 
    /* If the file path starts with '/', don't prepend ast_config_AST_CONFIG_DIR */
    if (stripped_filename[0] == '/') {
        real_path = realpath(stripped_filename, NULL);
    } else {
        if (ast_asprintf(&path, "%s/%s", ast_config_AST_CONFIG_DIR, stripped_filename) == -1) {
            return -1;
        }
        real_path = realpath(path, NULL);
    }
 
    if (!real_path) {
        return -1;
    }
 
    if (!ast_begins_with(real_path, ast_config_AST_CONFIG_DIR)) {
        return 1;
    }
 
    return 0;
}

References ast_asprintf, ast_begins_with(), ast_config_AST_CONFIG_DIR, ast_free, ast_std_free(), ast_strdupa, ast_strip(), live_dangerously, NULL, and RAII_VAR.

Referenced by action_getconfig(), action_getconfigjson(), action_listcategories(), and action_updateconfig().

json_escape()

static void json_escape ( char *  out, const char *  in  )

static

The amount of space in out must be at least ( 2 * strlen(in) + 1 )

Definition at line 2622 of file manager.c.

{
    for (; *in; in++) {
        if (*in == '\\' || *in == '\"') {
            *out++ = '\\';
        }
        *out++ = *in;
    }
    *out = '\0';
}

References in, and out.

Referenced by astman_append_json().

log_action()

static void log_action ( const struct message *  m, const char *  action  )

static

Definition at line 6988 of file manager.c.

{
    struct ast_str *buf;
    int x;
 
    if (!manager_debug) {
        return;
    }
 
    buf = ast_str_create(256);
    if (!buf) {
        return;
    }
 
    for (x = 0; x < m->hdrcount; ++x) {
        if (!strncasecmp(m->headers[x], "Secret", 6)) {
            ast_str_append(&buf, 0, "Secret: <redacted from logging>\n");
        } else {
            ast_str_append(&buf, 0, "%s\n", m->headers[x]);
        }
    }
 
    ast_verbose("<--- Examining AMI action: -->\n%s\n", ast_str_buffer(buf));
    ast_free(buf);
}

References ast_free, ast_str_append(), ast_str_buffer(), ast_str_create, ast_verbose(), buf, message::hdrcount, message::headers, and manager_debug.

Referenced by process_message().

man_do_variable_value()

static struct ast_variable * man_do_variable_value ( struct ast_variable *  head, const char *  hdr_val  )

static

Definition at line 1689 of file manager.c.

{
    char *parse;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(vars)[64];
    );
 
    hdr_val = ast_skip_blanks(hdr_val); /* ignore leading spaces in the value */
    parse = ast_strdupa(hdr_val);
 
    /* Break the header value string into name=val pair items. */
    AST_STANDARD_APP_ARGS(args, parse);
    if (args.argc) {
        int y;
 
        /* Process each name=val pair item. */
        for (y = 0; y < args.argc; y++) {
            struct ast_variable *cur;
            char *var;
            char *val;
 
            if (!args.vars[y]) {
                continue;
            }
            var = val = args.vars[y];
            strsep(&val, "=");
 
            /* XXX We may wish to trim whitespace from the strings. */
            if (!val || ast_strlen_zero(var)) {
                continue;
            }
 
            /* Create new variable list node and prepend it to the list. */
            cur = ast_variable_new(var, val, "");
            if (cur) {
                cur->next = head;
                head = cur;
            }
        }
    }
 
    return head;
}

References args, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_skip_blanks(), AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_variable_new, ast_variable::next, strsep(), and var.

Referenced by astman_get_variables_order().

manager_add_filter()

static enum add_filter_result manager_add_filter ( const char *  criteria, const char *  filter_pattern, struct ao2_container *  includefilters, struct ao2_container *  excludefilters  )

static

Add an event filter to a manager session.

Parameters

criteria	See examples in manager.conf.sample
filter_pattern	Filter pattern
includefilters,excludefilters

Returns

FILTER_ALLOC_FAILED Memory allocation failure

FILTER_COMPILE_FAIL If the filter did not compile

FILTER_FORMAT_ERROR If the criteria weren't formatted correctly

FILTER_SUCCESS Success

Examples: See examples in manager.conf.sample

Definition at line 5753 of file manager.c.

{
    RAII_VAR(struct event_filter_entry *, filter_entry,
        ao2_t_alloc(sizeof(*filter_entry), event_filter_destructor, "event_filter allocation"),
        ao2_cleanup);
    char *options_start = NULL;
    SCOPE_ENTER(3, "manager_add_filter(%s, %s, %p, %p)", criteria, filter_pattern, includefilters, excludefilters);
 
    if (!filter_entry) {
        SCOPE_EXIT_LOG_RTN_VALUE(FILTER_ALLOC_FAILED, LOG_WARNING, "Unable to allocate filter_entry");
    }
 
    /*
     * At a minimum, criteria must be "eventfilter" but may contain additional
     * constraints.
     */
    if (ast_strlen_zero(criteria)) {
        SCOPE_EXIT_LOG_RTN_VALUE(FILTER_FORMAT_ERROR, LOG_WARNING, "Missing criteria");
    }
 
    /*
     * filter_pattern could be empty but it should never be NULL.
     */
    if (!filter_pattern) {
        SCOPE_EXIT_LOG_RTN_VALUE(FILTER_FORMAT_ERROR, LOG_WARNING, "Filter pattern was NULL");
    }
 
    /*
     * For a legacy filter, if the first character of filter_pattern is
     * '!' then it's an exclude filter.  It's also accepted as an alternative
     * to specifying "action(exclude)" for an advanced filter.  If
     * "action" is specified however, it will take precedence.
     */
    if (filter_pattern[0] == '!') {
        filter_entry->is_excludefilter = 1;
        filter_pattern++;
    }
 
    /*
     * This is the default
     */
    filter_entry->match_type = FILTER_MATCH_REGEX;
 
    /*
     * If the criteria has a '(' in it, then it's an advanced filter.
     */
    options_start = strstr(criteria, "(");
 
    /*
     * If it's a legacy filter, there MUST be a filter pattern.
     */
    if (!options_start && ast_strlen_zero(filter_pattern)) {
        SCOPE_EXIT_LOG_RTN_VALUE(FILTER_FORMAT_ERROR, LOG_WARNING,
            "'%s = %s': Legacy filter with no filter pattern specified\n",
            criteria, filter_pattern);
    }
 
    if (options_start) {
        /*
         * This is an advanced filter
         */
        char *temp = ast_strdupa(options_start + 1); /* skip over the leading '(' */
        char *saveptr = NULL;
        char *option = NULL;
        enum found_options {
            action_found = (1 << 0),
            name_found = (1 << 1),
            header_found = (1 << 2),
            method_found = (1 << 3),
        };
        enum found_options options_found = 0;
 
        filter_entry->match_type = FILTER_MATCH_NONE;
 
        ast_strip(temp);
        if (ast_strlen_zero(temp) || !ast_ends_with(temp, ")")) {
            SCOPE_EXIT_LOG_RTN_VALUE(FILTER_FORMAT_ERROR, LOG_WARNING,
                "'%s = %s': Filter options not formatted correctly\n",
                criteria, filter_pattern);
        }
 
        /*
         * These can actually be in any order...
         * action(include|exclude),name(<event_name>),header(<header_name>),method(<match_method>)
         * At least one of action, name, or header is required.
         */
        while ((option = strtok_r(temp, " ,)", &saveptr))) {
            if (!strncmp(option, "action", 6)) {
                char *method = strstr(option, "(");
                if (ast_strlen_zero(method)) {
                    SCOPE_EXIT_LOG_RTN_VALUE(FILTER_FORMAT_ERROR, LOG_WARNING, "'%s = %s': 'action' parameter not formatted correctly\n",
                        criteria, filter_pattern);
                }
                method++;
                ast_strip(method);
                if (!strcmp(method, "include")) {
                    filter_entry->is_excludefilter = 0;
                } else if (!strcmp(method, "exclude")) {
                    filter_entry->is_excludefilter = 1;
                } else {
                    SCOPE_EXIT_LOG_RTN_VALUE(FILTER_FORMAT_ERROR, LOG_WARNING, "'%s = %s': 'action' option '%s' is unknown\n",
                        criteria, filter_pattern, method);
                }
                options_found |= action_found;
            } else if (!strncmp(option, "name", 4)) {
                char *event_name = strstr(option, "(");
                event_name++;
                ast_strip(event_name);
                if (ast_strlen_zero(event_name)) {
                    SCOPE_EXIT_LOG_RTN_VALUE(FILTER_FORMAT_ERROR, LOG_WARNING, "'%s = %s': 'name' parameter not formatted correctly\n",
                        criteria, filter_pattern);
                }
                filter_entry->event_name = ast_strdup(event_name);
                filter_entry->event_name_hash = ast_str_hash(event_name);
                options_found |= name_found;
            } else if (!strncmp(option, "header", 6)) {
                char *header_name = strstr(option, "(");
                header_name++;
                ast_strip(header_name);
                if (ast_strlen_zero(header_name)) {
                    SCOPE_EXIT_LOG_RTN_VALUE(FILTER_FORMAT_ERROR, LOG_WARNING, "'%s = %s': 'header' parameter not formatted correctly\n",
                        criteria, filter_pattern);
                }
                if (!ast_ends_with(header_name, ":")) {
                    filter_entry->header_name = ast_malloc(strlen(header_name) + 2);
                    if (!filter_entry->header_name) {
                        SCOPE_EXIT_LOG_RTN_VALUE(FILTER_ALLOC_FAILED, LOG_ERROR, "Unable to allocate memory for header_name");
                    }
                    sprintf(filter_entry->header_name, "%s:", header_name); /* Safe */
                } else {
                    filter_entry->header_name = ast_strdup(header_name);
                }
                options_found |= header_found;
            } else if (!strncmp(option, "method", 6)) {
                char *method = strstr(option, "(");
                method++;
                ast_strip(method);
                if (ast_strlen_zero(method)) {
                    SCOPE_EXIT_LOG_RTN_VALUE(FILTER_FORMAT_ERROR, LOG_WARNING, "'%s = %s': 'method' parameter not formatted correctly\n",
                        criteria, filter_pattern);
                }
                if (!strcmp(method, "regex")) {
                    filter_entry->match_type = FILTER_MATCH_REGEX;
                } else if (!strcmp(method, "exact")) {
                    filter_entry->match_type = FILTER_MATCH_EXACT;
                } else if (!strcmp(method, "starts_with")) {
                    filter_entry->match_type = FILTER_MATCH_STARTS_WITH;
                } else if (!strcmp(method, "ends_with")) {
                    filter_entry->match_type = FILTER_MATCH_ENDS_WITH;
                } else if (!strcmp(method, "contains")) {
                    filter_entry->match_type = FILTER_MATCH_CONTAINS;
                } else if (!strcmp(method, "none")) {
                    filter_entry->match_type = FILTER_MATCH_NONE;
                } else {
                    SCOPE_EXIT_LOG_RTN_VALUE(FILTER_FORMAT_ERROR, LOG_WARNING, "'%s = %s': 'method' option '%s' is unknown\n",
                        criteria, filter_pattern, method);
                }
                options_found |= method_found;
            } else {
                SCOPE_EXIT_LOG_RTN_VALUE(FILTER_FORMAT_ERROR, LOG_WARNING, "'%s = %s': Filter option '%s' is unknown\n",
                    criteria, filter_pattern, option);
            }
            temp = NULL;
        }
        if (!options_found) {
            SCOPE_EXIT_LOG_RTN_VALUE(FILTER_FORMAT_ERROR, LOG_WARNING,
                "'%s = %s': No action, name, header, or method option found\n",
                criteria, filter_pattern);
        }
        if (ast_strlen_zero(filter_pattern) && filter_entry->match_type != FILTER_MATCH_NONE) {
            SCOPE_EXIT_LOG_RTN_VALUE(FILTER_FORMAT_ERROR, LOG_WARNING,
                "'%s = %s': method can't be '%s' with no filter pattern\n",
                criteria, filter_pattern, match_type_names[filter_entry->match_type]);
        }
        if (!ast_strlen_zero(filter_pattern) && filter_entry->match_type == FILTER_MATCH_NONE) {
            SCOPE_EXIT_LOG_RTN_VALUE(FILTER_FORMAT_ERROR, LOG_WARNING,
                "'%s = %s': method can't be 'none' with a filter pattern\n",
                criteria, filter_pattern);
        }
        if (!(options_found & name_found) && !(options_found & header_found) &&
            filter_entry->match_type == FILTER_MATCH_NONE) {
            SCOPE_EXIT_LOG_RTN_VALUE(FILTER_FORMAT_ERROR, LOG_WARNING,
                "'%s = %s': No name or header option found and no filter pattern\n",
                criteria, filter_pattern);
        }
    }
 
    if (!ast_strlen_zero(filter_pattern)) {
        if (filter_entry->match_type == FILTER_MATCH_REGEX) {
            filter_entry->regex_filter = ast_calloc(1, sizeof(regex_t));
            if (!filter_entry->regex_filter) {
                SCOPE_EXIT_LOG_RTN_VALUE(FILTER_ALLOC_FAILED, LOG_ERROR, "Unable to allocate memory for regex_filter");
            }
            if (regcomp(filter_entry->regex_filter, filter_pattern, REG_EXTENDED | REG_NOSUB)) {
                SCOPE_EXIT_LOG_RTN_VALUE(FILTER_COMPILE_FAIL, LOG_WARNING, "Unable to compile regex filter for '%s'", filter_pattern);
            }
        } else {
            filter_entry->string_filter = ast_strdup(filter_pattern);
        }
    }
 
    ast_debug(2, "Event filter:\n"
        "conf entry: %s = %s\n"
        "event_name: %s (hash: %d)\n"
        "test_header:  %s\n"
        "match_type: %s\n"
        "regex_filter: %p\n"
        "string filter: %s\n"
        "is excludefilter: %d\n",
        criteria, filter_pattern,
        S_OR(filter_entry->event_name, "<not used>"),
        filter_entry->event_name_hash,
        S_OR(filter_entry->header_name, "<not used>"),
        match_type_names[filter_entry->match_type],
        filter_entry->regex_filter,
        filter_entry->string_filter,
        filter_entry->is_excludefilter);
 
    if (filter_entry->is_excludefilter) {
        ao2_t_link(excludefilters, filter_entry, "link new filter into exclude user container");
    } else {
        ao2_t_link(includefilters, filter_entry, "link new filter into include user container");
    }
 
    SCOPE_EXIT_RTN_VALUE(FILTER_SUCCESS, "Filter added successfully");
}

References ao2_cleanup, ao2_t_alloc, ao2_t_link, ast_calloc, ast_debug, ast_ends_with(), ast_malloc, ast_str_hash(), ast_strdup, ast_strdupa, ast_strip(), ast_strlen_zero(), event_filter_destructor(), FILTER_ALLOC_FAILED, FILTER_COMPILE_FAIL, FILTER_FORMAT_ERROR, FILTER_MATCH_CONTAINS, FILTER_MATCH_ENDS_WITH, FILTER_MATCH_EXACT, FILTER_MATCH_NONE, FILTER_MATCH_REGEX, FILTER_MATCH_STARTS_WITH, FILTER_SUCCESS, LOG_ERROR, LOG_WARNING, match_type_names, method, NULL, RAII_VAR, S_OR, SCOPE_ENTER, SCOPE_EXIT_LOG_RTN_VALUE, and SCOPE_EXIT_RTN_VALUE.

Referenced by __init_manager(), and action_filter().

manager_default_msg_cb()

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

static

Definition at line 572 of file manager.c.

{
    struct ao2_container *sessions;
    struct ast_manager_event_blob *ev;
 
    if (!stasis_message_can_be_ami(message)) {
        /* Not an AMI message; disregard */
        return;
    }
 
    sessions = ao2_global_obj_ref(mgr_sessions);
    if (!any_manager_listeners(sessions)) {
        /* Nobody is listening */
        ao2_cleanup(sessions);
        return;
    }
 
    ev = stasis_message_to_ami(message);
    if (!ev) {
        /* Conversion failure */
        ao2_cleanup(sessions);
        return;
    }
 
    manager_event_sessions(sessions, ev->event_flags, ev->manager_event,
        "%s", ev->extra_fields);
    ao2_ref(ev, -1);
    ao2_cleanup(sessions);
}

References any_manager_listeners, ao2_cleanup, ao2_global_obj_ref, ao2_ref, ast_manager_event_blob::event_flags, ast_manager_event_blob::extra_fields, ast_manager_event_blob::manager_event, manager_event_sessions, sessions, stasis_message_can_be_ami(), and stasis_message_to_ami().

Referenced by manager_subscriptions_init().

manager_displayconnects()

static int manager_displayconnects ( struct mansession_session *  session )

static

Get displayconnects config option.

Parameters

session

manager session to get parameter from.

Returns

displayconnects config option value.

Definition at line 1063 of file manager.c.

{
    struct ast_manager_user *user = NULL;
    int ret = 0;
 
    AST_RWLIST_RDLOCK(&users);
    if ((user = get_manager_by_name_locked(session->username))) {
        ret = user->displayconnects;
    }
    AST_RWLIST_UNLOCK(&users);
 
    return ret;
}

References AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, get_manager_by_name_locked(), NULL, and session.

Referenced by action_login(), generic_http_callback(), purge_sessions(), and session_do().

manager_generic_msg_cb()

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

static

Definition at line 603 of file manager.c.

{
    struct ast_json_payload *payload;
    int class_type;
    const char *type;
    struct ast_json *event;
    struct ast_str *event_buffer;
    struct ao2_container *sessions;
 
    sessions = ao2_global_obj_ref(mgr_sessions);
    if (!any_manager_listeners(sessions)) {
        /* Nobody is listening */
        ao2_cleanup(sessions);
        return;
    }
 
    payload = stasis_message_data(message);
    class_type = ast_json_integer_get(ast_json_object_get(payload->json, "class_type"));
    type = ast_json_string_get(ast_json_object_get(payload->json, "type"));
    event = ast_json_object_get(payload->json, "event");
 
    event_buffer = ast_manager_str_from_json_object(event, NULL);
    if (!event_buffer) {
        ast_log(AST_LOG_WARNING, "Error while creating payload for event %s\n", type);
        ao2_cleanup(sessions);
        return;
    }
 
    manager_event_sessions(sessions, class_type, type,
        "%s", ast_str_buffer(event_buffer));
    ast_free(event_buffer);
    ao2_cleanup(sessions);
}

References any_manager_listeners, ao2_cleanup, ao2_global_obj_ref, ast_free, ast_json_integer_get(), ast_json_object_get(), ast_json_string_get(), ast_log, AST_LOG_WARNING, ast_manager_str_from_json_object(), ast_str_buffer(), ast_json_payload::json, manager_event_sessions, NULL, sessions, stasis_message_data(), and type.

Referenced by manager_subscriptions_init().

manager_json_array_with_key()

static void manager_json_array_with_key ( struct ast_json *  obj, const char *  key, size_t  index, struct ast_str **  res, key_exclusion_cb  exclusion_cb  )

static

Definition at line 489 of file manager.c.

{
    struct ast_str *key_str = ast_str_alloca(64);
    ast_str_set(&key_str, 0, "%s(%zu)", key, index);
    manager_json_to_ast_str(obj, ast_str_buffer(key_str),
                res, exclusion_cb);
}

References ast_str_alloca, ast_str_buffer(), ast_str_set(), and manager_json_to_ast_str().

Referenced by manager_json_to_ast_str().

manager_json_obj_with_key()

static void manager_json_obj_with_key ( struct ast_json *  obj, const char *  key, const char *  parent_key, struct ast_str **  res, key_exclusion_cb  exclusion_cb  )

static

Definition at line 499 of file manager.c.

{
    if (parent_key) {
        struct ast_str *key_str = ast_str_alloca(64);
        ast_str_set(&key_str, 0, "%s/%s", parent_key, key);
        manager_json_to_ast_str(obj, ast_str_buffer(key_str),
                    res, exclusion_cb);
        return;
    }
 
    manager_json_to_ast_str(obj, key, res, exclusion_cb);
}

References ast_str_alloca, ast_str_buffer(), ast_str_set(), and manager_json_to_ast_str().

Referenced by manager_json_to_ast_str().

manager_json_to_ast_str()

void manager_json_to_ast_str ( struct ast_json *  obj, const char *  key, struct ast_str **  res, key_exclusion_cb  exclusion_cb  )

static

Definition at line 514 of file manager.c.

{
    struct ast_json_iter *i;
 
    /* If obj or res is not given, just return */
    if (!obj || !res) {
        return;
    }
 
    if (!*res && !(*res = ast_str_create(1024))) {
        return;
    }
 
    if (exclusion_cb && key && exclusion_cb(key)) {
        return;
    }
 
    if (ast_json_typeof(obj) != AST_JSON_OBJECT &&
        ast_json_typeof(obj) != AST_JSON_ARRAY) {
        manager_json_value_str_append(obj, key, res);
        return;
    }
 
    if (ast_json_typeof(obj) == AST_JSON_ARRAY) {
        size_t j;
        for (j = 0; j < ast_json_array_size(obj); ++j) {
            manager_json_array_with_key(ast_json_array_get(obj, j),
                            key, j, res, exclusion_cb);
        }
        return;
    }
 
    for (i = ast_json_object_iter(obj); i;
         i = ast_json_object_iter_next(obj, i)) {
        manager_json_obj_with_key(ast_json_object_iter_value(i),
                      ast_json_object_iter_key(i),
                      key, res, exclusion_cb);
    }
}

References AST_JSON_ARRAY, ast_json_array_get(), ast_json_array_size(), AST_JSON_OBJECT, ast_json_object_iter(), ast_json_object_iter_key(), ast_json_object_iter_next(), ast_json_object_iter_value(), ast_json_typeof(), ast_str_create, manager_json_array_with_key(), manager_json_obj_with_key(), and manager_json_value_str_append().

Referenced by ast_manager_str_from_json_object(), manager_json_array_with_key(), and manager_json_obj_with_key().

manager_json_value_str_append()

static void manager_json_value_str_append ( struct ast_json *  value, const char *  key, struct ast_str **  res  )

static

Definition at line 464 of file manager.c.

{
    switch (ast_json_typeof(value)) {
    case AST_JSON_STRING:
        ast_str_append(res, 0, "%s: %s\r\n", key, ast_json_string_get(value));
        break;
    case AST_JSON_INTEGER:
        ast_str_append(res, 0, "%s: %jd\r\n", key, ast_json_integer_get(value));
        break;
    case AST_JSON_TRUE:
        ast_str_append(res, 0, "%s: True\r\n", key);
        break;
    case AST_JSON_FALSE:
        ast_str_append(res, 0, "%s: False\r\n", key);
        break;
    default:
        ast_str_append(res, 0, "%s: \r\n", key);
        break;
    }
}

References AST_JSON_FALSE, AST_JSON_INTEGER, ast_json_integer_get(), AST_JSON_STRING, ast_json_string_get(), AST_JSON_TRUE, ast_json_typeof(), ast_str_append(), and value.

Referenced by manager_json_to_ast_str().

manager_modulecheck()

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

static

Manager function to check if module is loaded.

Definition at line 6842 of file manager.c.

{
    const char *module = astman_get_header(m, "Module");
    const char *id = astman_get_header(m, "ActionID");
 
    ast_debug(1, "**** ModuleCheck .so file %s\n", module);
    if (!ast_module_check(module)) {
        astman_send_error(s, m, "Module not loaded");
        return 0;
    }
 
    astman_append(s, "Response: Success\r\n");
 
    if (!ast_strlen_zero(id)) {
        astman_append(s, "ActionID: %s\r\n", id);
    }
 
#if !defined(LOW_MEMORY)
    /* When we switched from subversion to git we lost the ability to
     * retrieve the 'ASTERISK_FILE_VERSION' from that file, but we retain
     * the response header here for backwards compatibility. */
    astman_append(s, "Version: \r\n");
#endif
 
    astman_append(s, "\r\n");
 
    return 0;
}

References ast_debug, ast_module_check(), ast_strlen_zero(), astman_append(), astman_get_header(), and astman_send_error().

Referenced by __init_manager().

manager_moduleload()

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

static

Definition at line 6907 of file manager.c.

{
    int res;
    const char *module = astman_get_header(m, "Module");
    const char *loadtype = astman_get_header(m, "LoadType");
    const char *recursive = astman_get_header(m, "Recursive");
 
    if (!loadtype || strlen(loadtype) == 0) {
        astman_send_error(s, m, "Incomplete ModuleLoad action.");
    }
    if ((!module || strlen(module) == 0) && strcasecmp(loadtype, "reload") != 0) {
        astman_send_error(s, m, "Need module name");
    }
 
    res = file_in_modules_dir(module);
    if (res == 0) {
        astman_send_error(s, m, "Module must be in the configured modules directory.");
        return 0;
    } else if (res == -1) {
        astman_send_error(s, m, "Module not found.");
        return 0;
    }
 
    if (!strcasecmp(loadtype, "load")) {
        res = ast_load_resource(module);
        if (res) {
            astman_send_error(s, m, "Could not load module.");
        } else {
            astman_send_ack(s, m, "Module loaded.");
        }
    } else if (!strcasecmp(loadtype, "unload")) {
        res = ast_unload_resource(module, AST_FORCE_SOFT);
        if (res) {
            astman_send_error(s, m, "Could not unload module.");
        } else {
            astman_send_ack(s, m, "Module unloaded.");
        }
    } else if (!strcasecmp(loadtype, "refresh")) {
        res = ast_refresh_resource(module, AST_FORCE_SOFT, !ast_strlen_zero(recursive) && ast_true(recursive));
        if (res) {
            astman_send_error(s, m, "Could not refresh module.");
        } else {
            astman_send_ack(s, m, "Module unloaded and loaded.");
        }
    } else if (!strcasecmp(loadtype, "reload")) {
        /* TODO: Unify the ack/error messages here with action_reload */
        if (!ast_strlen_zero(module)) {
            enum ast_module_reload_result reload_res = ast_module_reload(module);
 
            switch (reload_res) {
            case AST_MODULE_RELOAD_NOT_FOUND:
                astman_send_error(s, m, "No such module.");
                break;
            case AST_MODULE_RELOAD_NOT_IMPLEMENTED:
                astman_send_error(s, m, "Module does not support reload action.");
                break;
            case AST_MODULE_RELOAD_ERROR:
                astman_send_error(s, m, "An unknown error occurred");
                break;
            case AST_MODULE_RELOAD_IN_PROGRESS:
                astman_send_error(s, m, "A reload is in progress");
                break;
            case AST_MODULE_RELOAD_UNINITIALIZED:
                astman_send_error(s, m, "Module not initialized");
                break;
            case AST_MODULE_RELOAD_QUEUED:
            case AST_MODULE_RELOAD_SUCCESS:
                /* Treat a queued request as success */
                astman_send_ack(s, m, "Module reloaded.");
                break;
            }
        } else {
            ast_module_reload(NULL);    /* Reload all modules */
            astman_send_ack(s, m, "All modules reloaded");
        }
    } else {
        astman_send_error(s, m, "Incomplete ModuleLoad action.");
    }
    return 0;
}

References AST_FORCE_SOFT, ast_load_resource(), ast_module_reload(), AST_MODULE_RELOAD_ERROR, AST_MODULE_RELOAD_IN_PROGRESS, AST_MODULE_RELOAD_NOT_FOUND, AST_MODULE_RELOAD_NOT_IMPLEMENTED, AST_MODULE_RELOAD_QUEUED, AST_MODULE_RELOAD_SUCCESS, AST_MODULE_RELOAD_UNINITIALIZED, ast_refresh_resource(), ast_strlen_zero(), ast_true(), ast_unload_resource(), astman_get_header(), astman_send_ack(), astman_send_error(), file_in_modules_dir(), and NULL.

Referenced by __init_manager().

manager_state_cb()

static int manager_state_cb ( const char *  context, const char *  exten, struct ast_state_cb_info *  info, void *  data  )

static

Definition at line 7727 of file manager.c.

{
    /* Notify managers of change */
    char hint[512];
 
    hint[0] = '\0';
    ast_get_hint(hint, sizeof(hint), NULL, 0, NULL, context, exten);
 
    switch(info->reason) {
    case AST_HINT_UPDATE_DEVICE:
        manager_event(EVENT_FLAG_CALL, "ExtensionStatus",
            "Exten: %s\r\n"
            "Context: %s\r\n"
            "Hint: %s\r\n"
            "Status: %d\r\n"
            "StatusText: %s\r\n",
            exten,
            context,
            hint,
            info->exten_state,
            ast_extension_state2str(info->exten_state));
        break;
    case AST_HINT_UPDATE_PRESENCE:
        manager_event(EVENT_FLAG_CALL, "PresenceStatus",
            "Exten: %s\r\n"
            "Context: %s\r\n"
            "Hint: %s\r\n"
            "Status: %s\r\n"
            "Subtype: %s\r\n"
            "Message: %s\r\n",
            exten,
            context,
            hint,
            ast_presence_state2str(info->presence_state),
            info->presence_subtype,
            info->presence_message);
        break;
    }
    return 0;
}

References ast_extension_state2str(), ast_get_hint(), AST_HINT_UPDATE_DEVICE, AST_HINT_UPDATE_PRESENCE, ast_presence_state2str(), voicemailpwcheck::context, EVENT_FLAG_CALL, sip_to_pjsip::info(), manager_event, and NULL.

Referenced by __init_manager().

mansession_cmp_fn()

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

static

Definition at line 1003 of file manager.c.

{
    struct mansession_session *s = obj;
    char *str = arg;
    return !strcasecmp(s->username, str) ? CMP_MATCH : 0;
}

References CMP_MATCH, str, and mansession_session::username.

Referenced by __init_manager().

mansession_get_transport()

static enum ast_transport mansession_get_transport ( const struct mansession *  s )

static

Definition at line 2106 of file manager.c.

{
    return s->tcptls_session->parent->tls_cfg ? AST_TRANSPORT_TLS :
            AST_TRANSPORT_TCP;
}

References AST_TRANSPORT_TCP, AST_TRANSPORT_TLS, ast_tcptls_session_instance::parent, mansession::tcptls_session, and ast_tcptls_session_args::tls_cfg.

Referenced by report_auth_success(), report_failed_acl(), report_failed_challenge_response(), report_inval_password(), report_invalid_user(), report_req_bad_format(), report_req_not_allowed(), and report_session_limit().

mansession_lock()

static void mansession_lock ( struct mansession *  s )

static

Lock the 'mansession' structure.

Definition at line 2078 of file manager.c.

{
    ast_mutex_lock(&s->lock);
}

References ast_mutex_lock, and mansession::lock.

Referenced by action_challenge(), do_message(), handle_parse_error(), and process_message().

mansession_unlock()

static void mansession_unlock ( struct mansession *  s )

static

Unlock the 'mansession' structure.

Definition at line 2084 of file manager.c.

{
    ast_mutex_unlock(&s->lock);
}

References ast_mutex_unlock, and mansession::lock.

Referenced by action_challenge(), do_message(), handle_parse_error(), and process_message().

match_eventdata()

static int match_eventdata ( struct event_filter_entry *  entry, const char *  eventdata  )

static

Test eventdata against a filter entry.

Parameters

entry	The event_filter entry to match with
eventdata	The data to match against

Return values

0	if no match
1	if match

Definition at line 5576 of file manager.c.

{
    switch(entry->match_type) {
    case FILTER_MATCH_REGEX:
        return regexec(entry->regex_filter, eventdata, 0, NULL, 0) == 0;
    case FILTER_MATCH_STARTS_WITH:
        return ast_begins_with(eventdata, entry->string_filter);
    case FILTER_MATCH_ENDS_WITH:
        return ast_ends_with(eventdata, entry->string_filter);
    case FILTER_MATCH_CONTAINS:
        return strstr(eventdata, entry->string_filter) != NULL;
    case FILTER_MATCH_EXACT:
        return strcmp(eventdata, entry->string_filter) == 0;
    case FILTER_MATCH_NONE:
        return 1;
    }
 
    return 0;
}

References ast_begins_with(), ast_ends_with(), FILTER_MATCH_CONTAINS, FILTER_MATCH_ENDS_WITH, FILTER_MATCH_EXACT, FILTER_MATCH_NONE, FILTER_MATCH_REGEX, FILTER_MATCH_STARTS_WITH, event_filter_entry::match_type, NULL, event_filter_entry::regex_filter, and event_filter_entry::string_filter.

Referenced by filter_cmp_fn().

print_event_instance()

static void print_event_instance ( struct ast_cli_args *  a, struct ast_xml_doc_item *  instance  )

static

Definition at line 9263 of file manager.c.

{
    char *since, *syntax, *description, *synopsis, *seealso, *arguments;
 
    synopsis = ast_xmldoc_printable(AS_OR(instance->synopsis, "Not available"), 1);
    since = ast_xmldoc_printable(AS_OR(instance->since, "Not available"), 1);
    description = ast_xmldoc_printable(AS_OR(instance->description, "Not available"), 1);
    syntax = ast_xmldoc_printable(AS_OR(instance->syntax, "Not available"), 1);
    arguments = ast_xmldoc_printable(AS_OR(instance->arguments, "Not available"), 1);
    seealso = ast_xmldoc_printable(AS_OR(instance->seealso, "Not available"), 1);
 
    if (!synopsis || !since || !description || !syntax || !arguments || !seealso) {
        ast_cli(a->fd, "Error: Memory allocation failed\n");
        goto free_docs;
    }
 
    ast_cli(a->fd, "\n"
        "%s  -= Info about Manager Event '%s' =- %s\n\n"
        COLORIZE_FMT "\n"
        "%s\n\n"
        COLORIZE_FMT "\n"
        "%s\n\n"
        COLORIZE_FMT "\n"
        "%s\n\n"
        COLORIZE_FMT "\n"
        "%s\n\n"
        COLORIZE_FMT "\n"
        "%s\n\n"
        COLORIZE_FMT "\n"
        "%s\n\n",
        ast_term_color(COLOR_MAGENTA, 0), instance->name, ast_term_reset(),
        COLORIZE(COLOR_MAGENTA, 0, "[Synopsis]"), synopsis,
        COLORIZE(COLOR_MAGENTA, 0, "[Since]"), since,
        COLORIZE(COLOR_MAGENTA, 0, "[Description]"), description,
        COLORIZE(COLOR_MAGENTA, 0, "[Syntax]"), syntax,
        COLORIZE(COLOR_MAGENTA, 0, "[Arguments]"), arguments,
        COLORIZE(COLOR_MAGENTA, 0, "[See Also]"), seealso
        );
 
free_docs:
    ast_free(synopsis);
    ast_free(since);
    ast_free(description);
    ast_free(syntax);
    ast_free(arguments);
    ast_free(seealso);
}

References a, ast_xml_doc_item::arguments, AS_OR, ast_cli(), ast_free, ast_term_color(), ast_term_reset(), ast_xmldoc_printable(), COLOR_MAGENTA, COLORIZE, COLORIZE_FMT, ast_xml_doc_item::description, ast_xml_doc_item::name, ast_xml_doc_item::seealso, ast_xml_doc_item::since, synopsis, ast_xml_doc_item::synopsis, and ast_xml_doc_item::syntax.

Referenced by handle_manager_show_event(), and handle_showmancmd().

process_events()

static int process_events ( struct mansession *  s )

static

Send any applicable events to the client listening on this socket. Wait only for a finite time on each event, and drop all events whether they are successfully sent or not.

Definition at line 6414 of file manager.c.

{
    int ret = 0;
 
    ao2_lock(s->session);
    if (s->session->stream != NULL) {
        struct eventqent *eqe = s->session->last_ev;
 
        while ((eqe = advance_event(eqe))) {
            if (eqe->category == EVENT_FLAG_SHUTDOWN) {
                ast_debug(3, "Received CloseSession event\n");
                ret = -1;
            }
            if (!ret && s->session->authenticated &&
                (s->session->readperm & eqe->category) == eqe->category &&
                (s->session->send_events & eqe->category) == eqe->category) {
                    if (should_send_event(s->session->includefilters, s->session->excludefilters, eqe)) {
                        if (send_string(s, eqe->eventdata) < 0 || s->write_error)
                            ret = -1;   /* don't send more */
                    }
            }
            s->session->last_ev = eqe;
        }
    }
    ao2_unlock(s->session);
    return ret;
}

References advance_event(), ao2_lock, ao2_unlock, ast_debug, mansession_session::authenticated, eventqent::category, EVENT_FLAG_SHUTDOWN, mansession_session::excludefilters, mansession_session::includefilters, mansession_session::last_ev, NULL, mansession_session::readperm, mansession_session::send_events, send_string(), mansession::session, should_send_event(), mansession_session::stream, and mansession::write_error.

Referenced by do_message(), and process_message().

process_message()

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

static

Process an AMI message, performing desired action. Return 0 on success, -1 on error that require the session to be destroyed.

Definition at line 7027 of file manager.c.

{
    int ret = 0;
    struct manager_action *act_found;
    struct ast_manager_user *user = NULL;
    const char *username;
    const char *action;
 
    action = __astman_get_header(m, "Action", GET_HEADER_SKIP_EMPTY);
    if (ast_strlen_zero(action)) {
        report_req_bad_format(s, "NONE");
        mansession_lock(s);
        astman_send_error(s, m, "Missing action in request");
        mansession_unlock(s);
        return 0;
    }
 
    log_action(m, action);
 
    if (ast_shutting_down()) {
        ast_log(LOG_ERROR, "Unable to process manager action '%s'. Asterisk is shutting down.\n", action);
        mansession_lock(s);
        astman_send_error(s, m, "Asterisk is shutting down");
        mansession_unlock(s);
        return 0;
    }
 
    if (!s->session->authenticated
        && strcasecmp(action, "Login")
        && strcasecmp(action, "Logoff")
        && strcasecmp(action, "Challenge")) {
        if (!s->session->authenticated) {
            report_req_not_allowed(s, action);
        }
        mansession_lock(s);
        astman_send_error(s, m, "Permission denied");
        mansession_unlock(s);
        return 0;
    }
 
    if (!s->session->authenticated
        && (!strcasecmp(action, "Login")
            || !strcasecmp(action, "Challenge"))) {
        username = astman_get_header(m, "Username");
 
        if (!ast_strlen_zero(username) && check_manager_session_inuse(username)) {
            AST_RWLIST_WRLOCK(&users);
            user = get_manager_by_name_locked(username);
            if (user && !user->allowmultiplelogin) {
                AST_RWLIST_UNLOCK(&users);
                report_session_limit(s);
                sleep(1);
                mansession_lock(s);
                astman_send_error(s, m, "Login Already In Use");
                mansession_unlock(s);
                return -1;
            }
            AST_RWLIST_UNLOCK(&users);
        }
    }
 
    act_found = action_find(action);
    if (act_found) {
        /* Found the requested AMI action. */
        int acted = 0;
 
        if ((s->session->writeperm & act_found->authority)
            || act_found->authority == 0) {
            /* We have the authority to execute the action. */
            ret = -1;
            ao2_lock(act_found);
            if (act_found->registered && act_found->func) {
                struct ast_module *mod_ref = ast_module_running_ref(act_found->module);
 
                ao2_unlock(act_found);
                if (mod_ref || !act_found->module) {
                    ast_debug(1, "Running action '%s'\n", act_found->action);
                    ret = act_found->func(s, m);
                    acted = 1;
                    ast_module_unref(mod_ref);
                }
            } else {
                ao2_unlock(act_found);
            }
        }
        if (!acted) {
            /*
             * We did not execute the action because access was denied, it
             * was no longer registered, or no action was really registered.
             * Complain about it and leave.
             */
            report_req_not_allowed(s, action);
            mansession_lock(s);
            astman_send_error(s, m, "Permission denied");
            mansession_unlock(s);
        }
        ao2_t_ref(act_found, -1, "done with found action object");
    } else {
        char buf[512];
 
        report_req_bad_format(s, action);
        snprintf(buf, sizeof(buf), "Invalid/unknown command: %s. Use Action: ListCommands to show available commands.", action);
        mansession_lock(s);
        astman_send_error(s, m, buf);
        mansession_unlock(s);
    }
    if (ret) {
        return ret;
    }
    /* Once done with our message, deliver any pending events unless the
       requester doesn't want them as part of this response.
    */
    if (ast_strlen_zero(astman_get_header(m, "SuppressEvents"))) {
        return process_events(s);
    } else {
        return ret;
    }
}

References __astman_get_header(), manager_action::action, action_find(), ao2_lock, ao2_t_ref, ao2_unlock, ast_debug, ast_log, ast_module_running_ref, ast_module_unref, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_shutting_down(), ast_strlen_zero(), astman_get_header(), astman_send_error(), mansession_session::authenticated, manager_action::authority, buf, check_manager_session_inuse(), manager_action::func, GET_HEADER_SKIP_EMPTY, get_manager_by_name_locked(), log_action(), LOG_ERROR, mansession_lock(), mansession_unlock(), manager_action::module, NULL, process_events(), manager_action::registered, report_req_bad_format(), report_req_not_allowed(), report_session_limit(), mansession::session, and mansession_session::writeperm.

Referenced by auth_http_callback(), do_message(), and generic_http_callback().

purge_events()

static void purge_events ( void  )

static

Purge unused events. Remove elements from the head as long as their usecount is 0 and there is a next element.

Definition at line 718 of file manager.c.

{
    struct eventqent *ev;
    struct timeval now = ast_tvnow();
 
    AST_RWLIST_WRLOCK(&all_events);
    while ( (ev = AST_RWLIST_FIRST(&all_events)) &&
        ev->usecount == 0 && AST_RWLIST_NEXT(ev, eq_next)) {
        AST_RWLIST_REMOVE_HEAD(&all_events, eq_next);
        ast_free(ev);
    }
 
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&all_events, ev, eq_next) {
        /* Never release the last event */
        if (!AST_RWLIST_NEXT(ev, eq_next)) {
            break;
        }
 
        /* 2.5 times whatever the HTTP timeout is (maximum 2.5 hours) is the maximum time that we will definitely cache an event */
        if (ev->usecount == 0 && ast_tvdiff_sec(now, ev->tv) > (httptimeout > 3600 ? 3600 : httptimeout) * 2.5) {
            AST_RWLIST_REMOVE_CURRENT(eq_next);
            ast_free(ev);
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
    AST_RWLIST_UNLOCK(&all_events);
}

References ast_free, AST_RWLIST_FIRST, AST_RWLIST_NEXT, AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_REMOVE_HEAD, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_tvdiff_sec(), ast_tvnow(), httptimeout, eventqent::tv, and eventqent::usecount.

Referenced by purge_old_stuff().

purge_sessions()

static int purge_sessions ( int  n_max )

static

remove at most n_max stale session from the list.

Definition at line 7455 of file manager.c.

{
    struct ao2_container *sessions;
    struct mansession_session *session;
    time_t now = time(NULL);
    struct ao2_iterator i;
    int purged = 0;
 
    sessions = ao2_global_obj_ref(mgr_sessions);
    if (!sessions) {
        return 0;
    }
    i = ao2_iterator_init(sessions, 0);
    ao2_ref(sessions, -1);
    while ((session = ao2_iterator_next(&i)) && n_max > 0) {
        ao2_lock(session);
        if (session->sessiontimeout && (now > session->sessiontimeout) && !session->inuse) {
            if (session->authenticated
                && VERBOSITY_ATLEAST(2)
                && manager_displayconnects(session)) {
                ast_verb(2, "HTTP Manager '%s' timed out from %s\n",
                    session->username, ast_sockaddr_stringify_addr(&session->addr));
            }
            ao2_unlock(session);
            session_destroy(session);
            n_max--;
            purged++;
        } else {
            ao2_unlock(session);
            unref_mansession(session);
        }
    }
    ao2_iterator_destroy(&i);
    return purged;
}

References ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_sockaddr_stringify_addr(), ast_verb, manager_displayconnects(), NULL, session, session_destroy(), sessions, unref_mansession(), and VERBOSITY_ATLEAST.

Referenced by purge_old_stuff().

queue_match()

static int queue_match ( const char *  app, const char *  data, const char *  search  )

static

Definition at line 5052 of file manager.c.

{
    char *parse;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(queuename);
        AST_APP_ARG(options);
        AST_APP_ARG(url);
        AST_APP_ARG(announceoverride);
        AST_APP_ARG(queuetimeoutstr);
        AST_APP_ARG(agi);
        AST_APP_ARG(gosub);
        AST_APP_ARG(rule);
        AST_APP_ARG(position);
    );
 
    if (!strcasestr(app, "queue") || ast_strlen_zero(data)) {
        return 0;
    }
 
    parse = ast_strdupa(data);
    AST_STANDARD_APP_ARGS(args, parse);
 
    /*
     * The Queue application is fine unless the AGI parameter is set.
     * If it is, we need to check the user's permissions.
     */
    return !ast_strlen_zero(args.agi);
}

References app, args, AST_APP_ARG, AST_DECLARE_APP_ARGS, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), options, strcasestr(), and url.

queue_read_action_payload()

static int queue_read_action_payload ( struct ast_channel *  chan, const unsigned char *  payload, size_t  payload_size, enum ast_frame_read_action  action  )

static

Queue a given read action containing a payload onto a channel.

This queues a READ_ACTION control frame that contains a given "payload", or data to be triggered and handled on the channel's read side. This ensures the "action" is handled by the channel's media reading thread.

Parameters

chan	The channel to queue the action on
payload	The read action's payload
payload_size	The size of the given payload
action	The type of read action to queue

Return values

-1	on error
0	on success

Definition at line 3840 of file manager.c.

{
    struct ast_control_read_action_payload *obj;
    size_t obj_size;
    int res;
 
    obj_size = payload_size + sizeof(*obj);
 
    obj = ast_malloc(obj_size);
    if (!obj) {
        return -1;
    }
 
    obj->action = action;
    obj->payload_size = payload_size;
    memcpy(obj->payload, payload, payload_size);
 
    res = ast_queue_control_data(chan, AST_CONTROL_READ_ACTION, obj, obj_size);
 
    ast_free(obj);
    return res;
}

References ast_control_read_action_payload::action, AST_CONTROL_READ_ACTION, ast_free, ast_malloc, ast_queue_control_data(), ast_control_read_action_payload::payload, and ast_control_read_action_payload::payload_size.

Referenced by queue_sendtext(), and queue_sendtext_data().

queue_sendtext()

static int queue_sendtext ( struct ast_channel *  chan, const char *  body  )

static

Queue a read action to send a text message.

Parameters

chan	The channel to queue the action on
body	The body of the message

Return values

-1	on error
0	on success

Definition at line 3873 of file manager.c.

{
    return queue_read_action_payload(chan, (const unsigned char *)body,
        strlen(body) + 1, AST_FRAME_READ_ACTION_SEND_TEXT);
}

References AST_FRAME_READ_ACTION_SEND_TEXT, and queue_read_action_payload().

Referenced by action_sendtext().

queue_sendtext_data()

static int queue_sendtext_data ( struct ast_channel *  chan, const char *  body, const char *  content_type  )

static

Queue a read action to send a text data message.

Parameters

chan	The channel to queue the action on
body	The body of the message
content_type	The message's content type

Return values

-1	on error
0	on success

Definition at line 3889 of file manager.c.

{
    int res;
    struct ast_msg_data *obj;
 
    obj = ast_msg_data_alloc2(AST_MSG_DATA_SOURCE_TYPE_UNKNOWN,
                            NULL, NULL, content_type, body);
    if (!obj) {
        return -1;
    }
 
    res = queue_read_action_payload(chan, (const unsigned char *)obj,
        ast_msg_data_get_length(obj), AST_FRAME_READ_ACTION_SEND_TEXT_DATA);
 
    ast_free(obj);
    return res;
}

References AST_FRAME_READ_ACTION_SEND_TEXT_DATA, ast_free, ast_msg_data_alloc2(), ast_msg_data_get_length(), AST_MSG_DATA_SOURCE_TYPE_UNKNOWN, NULL, and queue_read_action_payload().

Referenced by action_sendtext().

reload_module()

static int reload_module ( void  )

static

Definition at line 10171 of file manager.c.

{
    return __init_manager(1, 0) ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_SUCCESS;
}

References __init_manager(), AST_MODULE_LOAD_FAILURE, and AST_MODULE_LOAD_SUCCESS.

Referenced by handle_manager_reload().

report_auth_success()

static void report_auth_success ( const struct mansession *  s )

static

Definition at line 2187 of file manager.c.

{
    char session_id[32];
    struct ast_security_event_successful_auth successful_auth = {
        .common.event_type = AST_SECURITY_EVENT_SUCCESSFUL_AUTH,
        .common.version    = AST_SECURITY_EVENT_SUCCESSFUL_AUTH_VERSION,
        .common.service    = "AMI",
        .common.account_id = s->session->username,
        .common.session_tv = &s->session->sessionstart_tv,
        .common.local_addr = {
            .addr      = &s->tcptls_session->parent->local_address,
            .transport = mansession_get_transport(s),
        },
        .common.remote_addr = {
            .addr      = &s->session->addr,
            .transport = mansession_get_transport(s),
        },
        .common.session_id = session_id,
    };
 
    snprintf(session_id, sizeof(session_id), "%p", s->session);
 
    ast_security_event_report(AST_SEC_EVT(&successful_auth));
}

References mansession_session::addr, AST_SEC_EVT, ast_security_event_report(), AST_SECURITY_EVENT_SUCCESSFUL_AUTH, AST_SECURITY_EVENT_SUCCESSFUL_AUTH_VERSION, ast_security_event_successful_auth::common, ast_security_event_common::event_type, ast_tcptls_session_args::local_address, mansession_get_transport(), ast_tcptls_session_instance::parent, mansession::session, mansession_session::sessionstart_tv, mansession::tcptls_session, and mansession_session::username.

Referenced by authenticate().

report_failed_acl()

static void report_failed_acl ( const struct mansession *  s, const char *  username  )

static

Definition at line 2137 of file manager.c.

{
    char session_id[32];
    struct ast_security_event_failed_acl failed_acl_event = {
        .common.event_type = AST_SECURITY_EVENT_FAILED_ACL,
        .common.version    = AST_SECURITY_EVENT_FAILED_ACL_VERSION,
        .common.service    = "AMI",
        .common.account_id = username,
        .common.session_tv = &s->session->sessionstart_tv,
        .common.local_addr = {
            .addr      = &s->tcptls_session->parent->local_address,
            .transport = mansession_get_transport(s),
        },
        .common.remote_addr = {
            .addr      = &s->session->addr,
            .transport = mansession_get_transport(s),
        },
        .common.session_id = session_id,
    };
 
    snprintf(session_id, sizeof(session_id), "%p", s->session);
 
    ast_security_event_report(AST_SEC_EVT(&failed_acl_event));
}

References mansession_session::addr, AST_SEC_EVT, AST_SECURITY_EVENT_FAILED_ACL, AST_SECURITY_EVENT_FAILED_ACL_VERSION, ast_security_event_report(), ast_security_event_failed_acl::common, ast_security_event_common::event_type, ast_tcptls_session_args::local_address, mansession_get_transport(), ast_tcptls_session_instance::parent, mansession::session, mansession_session::sessionstart_tv, and mansession::tcptls_session.

Referenced by authenticate().

report_failed_challenge_response()

static void report_failed_challenge_response ( const struct mansession *  s, const char *  response, const char *  expected_response  )

static

Definition at line 2270 of file manager.c.

{
    char session_id[32];
    struct ast_security_event_chal_resp_failed chal_resp_failed = {
        .common.event_type = AST_SECURITY_EVENT_CHAL_RESP_FAILED,
        .common.version    = AST_SECURITY_EVENT_CHAL_RESP_FAILED_VERSION,
        .common.service    = "AMI",
        .common.account_id = s->session->username,
        .common.session_tv = &s->session->sessionstart_tv,
        .common.local_addr = {
            .addr      = &s->tcptls_session->parent->local_address,
            .transport = mansession_get_transport(s),
        },
        .common.remote_addr = {
            .addr      = &s->session->addr,
            .transport = mansession_get_transport(s),
        },
        .common.session_id = session_id,
 
        .challenge         = s->session->challenge,
        .response          = response,
        .expected_response = expected_response,
    };
 
    snprintf(session_id, sizeof(session_id), "%p", s->session);
 
    ast_security_event_report(AST_SEC_EVT(&chal_resp_failed));
}

References mansession_session::addr, AST_SEC_EVT, AST_SECURITY_EVENT_CHAL_RESP_FAILED, AST_SECURITY_EVENT_CHAL_RESP_FAILED_VERSION, ast_security_event_report(), mansession_session::challenge, ast_security_event_chal_resp_failed::common, ast_security_event_common::event_type, ast_security_event_chal_resp_failed::expected_response, ast_tcptls_session_args::local_address, mansession_get_transport(), ast_tcptls_session_instance::parent, ast_security_event_chal_resp_failed::response, mansession::session, mansession_session::sessionstart_tv, mansession::tcptls_session, and mansession_session::username.

Referenced by authenticate().

report_inval_password()

static void report_inval_password ( const struct mansession *  s, const char *  username  )

static

Definition at line 2162 of file manager.c.

{
    char session_id[32];
    struct ast_security_event_inval_password inval_password = {
        .common.event_type = AST_SECURITY_EVENT_INVAL_PASSWORD,
        .common.version    = AST_SECURITY_EVENT_INVAL_PASSWORD_VERSION,
        .common.service    = "AMI",
        .common.account_id = username,
        .common.session_tv = &s->session->sessionstart_tv,
        .common.local_addr = {
            .addr      = &s->tcptls_session->parent->local_address,
            .transport = mansession_get_transport(s),
        },
        .common.remote_addr = {
            .addr      = &s->session->addr,
            .transport = mansession_get_transport(s),
        },
        .common.session_id = session_id,
    };
 
    snprintf(session_id, sizeof(session_id), "%p", s->session);
 
    ast_security_event_report(AST_SEC_EVT(&inval_password));
}

References mansession_session::addr, AST_SEC_EVT, AST_SECURITY_EVENT_INVAL_PASSWORD, AST_SECURITY_EVENT_INVAL_PASSWORD_VERSION, ast_security_event_report(), ast_security_event_inval_password::common, ast_security_event_common::event_type, ast_tcptls_session_args::local_address, mansession_get_transport(), ast_tcptls_session_instance::parent, mansession::session, mansession_session::sessionstart_tv, and mansession::tcptls_session.

Referenced by authenticate().

report_invalid_user()

static void report_invalid_user ( const struct mansession *  s, const char *  username  )

static

Definition at line 2112 of file manager.c.

{
    char session_id[32];
    struct ast_security_event_inval_acct_id inval_acct_id = {
        .common.event_type = AST_SECURITY_EVENT_INVAL_ACCT_ID,
        .common.version    = AST_SECURITY_EVENT_INVAL_ACCT_ID_VERSION,
        .common.service    = "AMI",
        .common.account_id = username,
        .common.session_tv = &s->session->sessionstart_tv,
        .common.local_addr = {
            .addr      = &s->tcptls_session->parent->local_address,
            .transport = mansession_get_transport(s),
        },
        .common.remote_addr = {
            .addr      = &s->session->addr,
            .transport = mansession_get_transport(s),
        },
        .common.session_id = session_id,
    };
 
    snprintf(session_id, sizeof(session_id), "%p", s);
 
    ast_security_event_report(AST_SEC_EVT(&inval_acct_id));
}

References mansession_session::addr, AST_SEC_EVT, AST_SECURITY_EVENT_INVAL_ACCT_ID, AST_SECURITY_EVENT_INVAL_ACCT_ID_VERSION, ast_security_event_report(), ast_security_event_inval_acct_id::common, ast_security_event_common::event_type, ast_tcptls_session_args::local_address, mansession_get_transport(), ast_tcptls_session_instance::parent, mansession::session, mansession_session::sessionstart_tv, and mansession::tcptls_session.

Referenced by authenticate().

report_req_bad_format()

static void report_req_bad_format ( const struct mansession *  s, const char *  action  )

static

Definition at line 2241 of file manager.c.

{
    char session_id[32];
    char request_type[64];
    struct ast_security_event_req_bad_format req_bad_format = {
        .common.event_type = AST_SECURITY_EVENT_REQ_BAD_FORMAT,
        .common.version    = AST_SECURITY_EVENT_REQ_BAD_FORMAT_VERSION,
        .common.service    = "AMI",
        .common.account_id = s->session->username,
        .common.session_tv = &s->session->sessionstart_tv,
        .common.local_addr = {
            .addr      = &s->tcptls_session->parent->local_address,
            .transport = mansession_get_transport(s),
        },
        .common.remote_addr = {
            .addr      = &s->session->addr,
            .transport = mansession_get_transport(s),
        },
        .common.session_id = session_id,
 
        .request_type      = request_type,
    };
 
    snprintf(session_id, sizeof(session_id), "%p", s->session);
    snprintf(request_type, sizeof(request_type), "Action: %s", action);
 
    ast_security_event_report(AST_SEC_EVT(&req_bad_format));
}

References mansession_session::addr, AST_SEC_EVT, ast_security_event_report(), AST_SECURITY_EVENT_REQ_BAD_FORMAT, AST_SECURITY_EVENT_REQ_BAD_FORMAT_VERSION, ast_security_event_req_bad_format::common, ast_security_event_common::event_type, ast_tcptls_session_args::local_address, mansession_get_transport(), ast_tcptls_session_instance::parent, ast_security_event_req_not_allowed::request_type, ast_security_event_req_bad_format::request_type, mansession::session, mansession_session::sessionstart_tv, mansession::tcptls_session, and mansession_session::username.

Referenced by process_message().

report_req_not_allowed()

static void report_req_not_allowed ( const struct mansession *  s, const char *  action  )

static

Definition at line 2212 of file manager.c.

{
    char session_id[32];
    char request_type[64];
    struct ast_security_event_req_not_allowed req_not_allowed = {
        .common.event_type = AST_SECURITY_EVENT_REQ_NOT_ALLOWED,
        .common.version    = AST_SECURITY_EVENT_REQ_NOT_ALLOWED_VERSION,
        .common.service    = "AMI",
        .common.account_id = s->session->username,
        .common.session_tv = &s->session->sessionstart_tv,
        .common.local_addr = {
            .addr      = &s->tcptls_session->parent->local_address,
            .transport = mansession_get_transport(s),
        },
        .common.remote_addr = {
            .addr      = &s->session->addr,
            .transport = mansession_get_transport(s),
        },
        .common.session_id = session_id,
 
        .request_type      = request_type,
    };
 
    snprintf(session_id, sizeof(session_id), "%p", s->session);
    snprintf(request_type, sizeof(request_type), "Action: %s", action);
 
    ast_security_event_report(AST_SEC_EVT(&req_not_allowed));
}

References mansession_session::addr, AST_SEC_EVT, ast_security_event_report(), AST_SECURITY_EVENT_REQ_NOT_ALLOWED, AST_SECURITY_EVENT_REQ_NOT_ALLOWED_VERSION, ast_security_event_req_not_allowed::common, ast_security_event_common::event_type, ast_tcptls_session_args::local_address, mansession_get_transport(), ast_tcptls_session_instance::parent, ast_security_event_req_not_allowed::request_type, mansession::session, mansession_session::sessionstart_tv, mansession::tcptls_session, and mansession_session::username.

Referenced by process_message().

report_session_limit()

static void report_session_limit ( const struct mansession *  s )

static

Definition at line 2300 of file manager.c.

{
    char session_id[32];
    struct ast_security_event_session_limit session_limit = {
        .common.event_type = AST_SECURITY_EVENT_SESSION_LIMIT,
        .common.version    = AST_SECURITY_EVENT_SESSION_LIMIT_VERSION,
        .common.service    = "AMI",
        .common.account_id = s->session->username,
        .common.session_tv = &s->session->sessionstart_tv,
        .common.local_addr = {
            .addr      = &s->tcptls_session->parent->local_address,
            .transport = mansession_get_transport(s),
        },
        .common.remote_addr = {
            .addr      = &s->session->addr,
            .transport = mansession_get_transport(s),
        },
        .common.session_id = session_id,
    };
 
    snprintf(session_id, sizeof(session_id), "%p", s->session);
 
    ast_security_event_report(AST_SEC_EVT(&session_limit));
}

References mansession_session::addr, AST_SEC_EVT, ast_security_event_report(), AST_SECURITY_EVENT_SESSION_LIMIT, AST_SECURITY_EVENT_SESSION_LIMIT_VERSION, ast_tcptls_session_args::local_address, mansession_get_transport(), ast_tcptls_session_instance::parent, mansession::session, session_limit, mansession_session::sessionstart_tv, mansession::tcptls_session, and mansession_session::username.

Referenced by process_message().

send_string()

static int send_string ( struct mansession *  s, char *  string  )

static

helper function to send a string to the socket. Return -1 on error (e.g. buffer full).

Definition at line 1852 of file manager.c.

{
    struct ast_iostream *stream;
    int len, res;
 
    /* It's a result from one of the hook's action invocation */
    if (s->hook) {
        /*
         * to send responses, we're using the same function
         * as for receiving events. We call the event "HookResponse"
         */
        s->hook->helper(EVENT_FLAG_HOOKRESPONSE, "HookResponse", string);
        return 0;
    }
 
    stream = s->stream ? s->stream : s->session->stream;
 
    len = strlen(string);
    ast_iostream_set_timeout_inactivity(stream, s->session->writetimeout);
    res = ast_iostream_write(stream, string, len);
    ast_iostream_set_timeout_disable(stream);
 
    if (res < len) {
        s->write_error = 1;
    }
 
    return res;
}

References ast_iostream_set_timeout_disable(), ast_iostream_set_timeout_inactivity(), ast_iostream_write(), EVENT_FLAG_HOOKRESPONSE, manager_custom_hook::helper, mansession::hook, len(), mansession::session, mansession_session::stream, mansession::stream, mansession::write_error, and mansession_session::writetimeout.

Referenced by astman_append(), astman_flush(), and process_events().

session_destroy()

static void session_destroy ( struct mansession_session *  s )

static

Definition at line 1010 of file manager.c.

{
    struct ao2_container *sessions;
 
    sessions = ao2_global_obj_ref(mgr_sessions);
    if (sessions) {
        ao2_unlink(sessions, s);
        ao2_ref(sessions, -1);
    }
    unref_mansession(s);
}

References ao2_global_obj_ref, ao2_ref, ao2_unlink, sessions, and unref_mansession().

Referenced by auth_http_callback(), generic_http_callback(), purge_sessions(), and session_do().

session_destructor()

static void session_destructor ( void *  obj )

static

Definition at line 939 of file manager.c.

{
    struct mansession_session *session = obj;
    struct eventqent *eqe = session->last_ev;
    struct ast_datastore *datastore;
 
    /* Get rid of each of the data stores on the session */
    while ((datastore = AST_LIST_REMOVE_HEAD(&session->datastores, entry))) {
        /* Free the data store */
        ast_datastore_free(datastore);
    }
 
    if (eqe) {
        ast_atomic_fetchadd_int(&eqe->usecount, -1);
    }
    if (session->chanvars) {
        ast_variables_destroy(session->chanvars);
    }
 
    if (session->includefilters) {
        ao2_t_ref(session->includefilters, -1, "decrement ref for include container, should be last one");
    }
 
    if (session->excludefilters) {
        ao2_t_ref(session->excludefilters, -1, "decrement ref for exclude container, should be last one");
    }
 
    ast_mutex_destroy(&session->notify_lock);
}

References ao2_t_ref, ast_atomic_fetchadd_int(), ast_datastore_free(), AST_LIST_REMOVE_HEAD, ast_mutex_destroy, ast_variables_destroy(), ast_datastore::entry, session, and eventqent::usecount.

Referenced by build_mansession().

session_do()

static void * session_do ( void *  data )

static

The body of the individual manager session. Call get_input() to read one line at a time (or be woken up on new events), collect the lines in a message until found an empty line, and execute the request. In any case, deliver events asynchronously through process_events() (called from here if no line is available, or at the end of process_message(). )

Definition at line 7361 of file manager.c.

{
    struct ast_tcptls_session_instance *ser = data;
    struct mansession_session *session;
    struct mansession s = {
        .tcptls_session = data,
    };
    int res;
    int arg = 1;
    struct ast_sockaddr ser_remote_address_tmp;
 
    if (ast_atomic_fetchadd_int(&unauth_sessions, +1) >= authlimit) {
        ast_atomic_fetchadd_int(&unauth_sessions, -1);
        goto done;
    }
 
    ast_sockaddr_copy(&ser_remote_address_tmp, &ser->remote_address);
    session = build_mansession(&ser_remote_address_tmp);
 
    if (session == NULL) {
        ast_atomic_fetchadd_int(&unauth_sessions, -1);
        goto done;
    }
 
    /* here we set TCP_NODELAY on the socket to disable Nagle's algorithm.
     * This is necessary to prevent delays (caused by buffering) as we
     * write to the socket in bits and pieces. */
    if (setsockopt(ast_iostream_get_fd(ser->stream), IPPROTO_TCP, TCP_NODELAY, (char *) &arg, sizeof(arg)) < 0) {
        ast_log(LOG_WARNING, "Failed to set TCP_NODELAY on manager connection: %s\n", strerror(errno));
    }
    ast_iostream_nonblock(ser->stream);
 
    ao2_lock(session);
    /* Hook to the tail of the event queue */
    session->last_ev = grab_last();
 
    ast_mutex_init(&s.lock);
 
    /* these fields duplicate those in the 'ser' structure */
    session->stream = s.stream = ser->stream;
    ast_sockaddr_copy(&session->addr, &ser_remote_address_tmp);
    s.session = session;
 
    AST_LIST_HEAD_INIT_NOLOCK(&session->datastores);
 
    if(time(&session->authstart) == -1) {
        ast_log(LOG_ERROR, "error executing time(): %s; disconnecting client\n", strerror(errno));
        ast_atomic_fetchadd_int(&unauth_sessions, -1);
        ao2_unlock(session);
        session_destroy(session);
        goto done;
    }
    ao2_unlock(session);
 
    /*
     * We cannot let the stream exclusively wait for data to arrive.
     * We have to wake up the task to send async events.
     */
    ast_iostream_set_exclusive_input(ser->stream, 0);
 
    ast_iostream_set_timeout_sequence(ser->stream,
        ast_tvnow(), authtimeout * 1000);
 
    astman_append(&s, "Asterisk Call Manager/%s\r\n", AMI_VERSION); /* welcome prompt */
    for (;;) {
        if ((res = do_message(&s)) < 0 || s.write_error || session->kicked) {
            break;
        }
        if (session->authenticated) {
            ast_iostream_set_timeout_disable(ser->stream);
        }
    }
    /* session is over, explain why and terminate */
    if (session->authenticated) {
        if (manager_displayconnects(session)) {
            ast_verb(2, "Manager '%s' %s from %s\n", session->username, session->kicked ? "kicked" : "logged off", ast_sockaddr_stringify_addr(&session->addr));
        }
    } else {
        ast_atomic_fetchadd_int(&unauth_sessions, -1);
        if (displayconnects) {
            ast_verb(2, "Connect attempt from '%s' unable to authenticate\n", ast_sockaddr_stringify_addr(&session->addr));
        }
    }
 
    session_destroy(session);
 
    ast_mutex_destroy(&s.lock);
done:
    ao2_ref(ser, -1);
    ser = NULL;
    return NULL;
}

References AMI_VERSION, ao2_lock, ao2_ref, ao2_unlock, ast_atomic_fetchadd_int(), ast_iostream_get_fd(), ast_iostream_nonblock(), ast_iostream_set_exclusive_input(), ast_iostream_set_timeout_disable(), ast_iostream_set_timeout_sequence(), AST_LIST_HEAD_INIT_NOLOCK, ast_log, ast_mutex_destroy, ast_mutex_init, ast_sockaddr_copy(), ast_sockaddr_stringify_addr(), ast_tvnow(), ast_verb, astman_append(), authlimit, authtimeout, build_mansession(), displayconnects, do_message(), done, errno, grab_last(), mansession::lock, LOG_ERROR, LOG_WARNING, manager_displayconnects(), NULL, ast_tcptls_session_instance::remote_address, mansession::session, session, session_destroy(), ast_tcptls_session_instance::stream, mansession::stream, mansession::tcptls_session, unauth_sessions, and mansession::write_error.

set_eventmask()

static int set_eventmask ( struct mansession *  s, const char *  eventmask  )

static

Rather than braindead on,off this now can also accept a specific int mask value or a ',' delim list of mask strings (the same as manager.conf) -anthm.

Definition at line 2093 of file manager.c.

{
    int maskint = strings_to_mask(eventmask);
 
    ao2_lock(s->session);
    if (maskint >= 0) {
        s->session->send_events = maskint;
    }
    ao2_unlock(s->session);
 
    return maskint;
}

References ao2_lock, ao2_unlock, mansession_session::send_events, mansession::session, and strings_to_mask().

Referenced by action_events(), and authenticate().

should_send_event()

static int should_send_event ( struct ao2_container *  includefilters, struct ao2_container *  excludefilters, struct eventqent *  eqe  )

static

Definition at line 5649 of file manager.c.

{
    int result = 0;
 
    if (manager_debug) {
        ast_verbose("<-- Examining AMI event (%u): -->\n%s\n", eqe->event_name_hash, eqe->eventdata);
    } else {
        ast_debug(4, "Examining AMI event (%u):\n%s\n", eqe->event_name_hash, eqe->eventdata);
    }
    if (!ao2_container_count(includefilters) && !ao2_container_count(excludefilters)) {
        return 1; /* no filtering means match all */
    } else if (ao2_container_count(includefilters) && !ao2_container_count(excludefilters)) {
        /* include filters only: implied exclude all filter processed first, then include filters */
        ao2_t_callback_data(includefilters, OBJ_NODATA, filter_cmp_fn, eqe, &result, "find filter in includefilters container");
        return result;
    } else if (!ao2_container_count(includefilters) && ao2_container_count(excludefilters)) {
        /* exclude filters only: implied include all filter processed first, then exclude filters */
        ao2_t_callback_data(excludefilters, OBJ_NODATA, filter_cmp_fn, eqe, &result, "find filter in excludefilters container");
        return !result;
    } else {
        /* include and exclude filters: implied exclude all filter processed first, then include filters, and lastly exclude filters */
        ao2_t_callback_data(includefilters, OBJ_NODATA, filter_cmp_fn, eqe, &result, "find filter in session filter container");
        if (result) {
            result = 0;
            ao2_t_callback_data(excludefilters, OBJ_NODATA, filter_cmp_fn, eqe, &result, "find filter in session filter container");
            return !result;
        }
    }
 
    return result;
}

References ao2_container_count(), ao2_t_callback_data, ast_debug, ast_verbose(), eventqent::event_name_hash, filter_cmp_fn(), manager_debug, OBJ_NODATA, and result.

Referenced by action_waitevent(), and process_events().

STASIS_MESSAGE_TYPE_DEFN()

STASIS_MESSAGE_TYPE_DEFN

(

ast_manager_get_generic_type

)

Define AMI message types.

strings_to_mask()

static int strings_to_mask ( const char *  string )

static

A number returns itself, false returns 0, true returns all flags, other strings return the flags that are set.

Definition at line 887 of file manager.c.

{
    const char *p;
 
    if (ast_strlen_zero(string)) {
        return -1;
    }
 
    for (p = string; *p; p++) {
        if (*p < '0' || *p > '9') {
            break;
        }
    }
    if (!*p) { /* all digits */
        return atoi(string);
    }
    if (ast_false(string)) {
        return 0;
    }
    if (ast_true(string)) { /* all permissions */
        int x, ret = 0;
        for (x = 0; x < ARRAY_LEN(perms); x++) {
            ret |= perms[x].num;
        }
        return ret;
    }
    return get_perm(string);
}

References ARRAY_LEN, ast_false(), ast_strlen_zero(), ast_true(), get_perm(), permalias::num, and perms.

Referenced by set_eventmask().

unref_mansession()

static struct mansession_session * unref_mansession ( struct mansession_session *  s )

static

Unreference manager session object. If no more references, then go ahead and delete it.

Definition at line 918 of file manager.c.

{
    int refcount = ao2_ref(s, -1);
    if (manager_debug) {
        ast_debug(1, "Mansession: %p refcount now %d\n", s, refcount - 1);
    }
    return NULL;
}

References ao2_ref, ast_debug, manager_debug, and NULL.

Referenced by __manager_event_sessions_va(), astman_is_authed(), astman_verify_session_readpermissions(), astman_verify_session_writepermissions(), check_manager_session_inuse(), find_session(), find_session_by_nonce(), generic_http_callback(), handle_kickmanconn(), handle_showmanconn(), purge_sessions(), and session_destroy().

user_authority_to_str()

static const char * user_authority_to_str ( int  authority, struct ast_str **  res  )

static

Convert authority code to a list of options for a user. This will only display those authority codes that have an explicit match on authority.

Definition at line 795 of file manager.c.

{
    int i;
    char *sep = "";
 
    ast_str_reset(*res);
    for (i = 0; i < ARRAY_LEN(perms) - 1; i++) {
        if ((authority & perms[i].num) == perms[i].num) {
            ast_str_append(res, 0, "%s%s", sep, perms[i].label);
            sep = ",";
        }
    }
 
    if (ast_str_strlen(*res) == 0) {
        /* replace empty string with something sensible */
        ast_str_append(res, 0, "<none>");
    }
 
    return ast_str_buffer(*res);
}

References ARRAY_LEN, ast_str_append(), ast_str_buffer(), ast_str_reset(), ast_str_strlen(), permalias::num, and perms.

Referenced by handle_showmanager().

Variable Documentation

acl_change_sub

struct stasis_subscription* acl_change_sub

static

Definition at line 183 of file manager.c.

Referenced by acl_change_stasis_subscribe(), and acl_change_stasis_unsubscribe().

actions

struct actions actions = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

static

all_events

struct all_events all_events = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

static

allowmultiplelogin

int allowmultiplelogin = 1

static

Definition at line 166 of file manager.c.

Referenced by __init_manager(), and handle_manager_show_settings().

astman_append_buf

struct ast_threadstorage astman_append_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_astman_append_buf , .custom_init = NULL , }

static

Definition at line 1888 of file manager.c.

Referenced by astman_append(), astman_send_error_va(), astman_send_list_complete_start_common(), and astman_send_response_full().

authlimit

int authlimit

static

Definition at line 175 of file manager.c.

Referenced by __init_manager(), manager_set_defaults(), and session_do().

authtimeout

int authtimeout

static

Definition at line 174 of file manager.c.

Referenced by __init_manager(), do_message(), get_input(), manager_set_defaults(), and session_do().

broken_events_action

int broken_events_action = 0

static

Definition at line 169 of file manager.c.

Referenced by __init_manager(), action_events(), and manager_set_defaults().

const struct { ... } command_blacklist[]

Initial value:

= {
    {{ "module", "load", NULL }},
    {{ "module", "unload", NULL }},
    {{ "restart", "gracefully", NULL }},
}

Referenced by check_blacklist().

displayconnects

int displayconnects = 1

static

Definition at line 165 of file manager.c.

Referenced by __init_manager(), do_message(), generic_http_callback(), handle_manager_show_settings(), manager_set_defaults(), and session_do().

global_realm

char global_realm[MAXHOSTNAMELEN]

static

Default realm

Definition at line 180 of file manager.c.

Referenced by __init_manager(), auth_http_callback(), and manager_set_defaults().

httptimeout

int httptimeout = 60

static

Definition at line 168 of file manager.c.

Referenced by __init_manager(), auth_http_callback(), generic_http_callback(), handle_manager_show_settings(), and purge_events().

live_dangerously

int live_dangerously

static

Set to true (non-zero) to globally allow all dangerous AMI actions to run.

Definition at line 200 of file manager.c.

Referenced by action_createconfig(), astman_live_dangerously(), file_in_modules_dir(), is_restricted_file(), and load_asterisk_conf().

manager_channelvars

char* manager_channelvars

static

Definition at line 176 of file manager.c.

Referenced by handle_manager_show_settings(), load_channelvars(), and manager_shutdown().

manager_debug

int manager_debug = 0

static

enable some debugging code in the manager

Definition at line 173 of file manager.c.

Referenced by __init_manager(), __manager_event_sessions_va(), handle_manager_show_settings(), handle_mandebug(), log_action(), manager_set_defaults(), should_send_event(), and unref_mansession().

manager_disabledevents

char* manager_disabledevents

static

Definition at line 177 of file manager.c.

Referenced by __manager_event_sessions_va(), handle_manager_show_settings(), load_disabledevents(), and manager_shutdown().

manager_enabled

int manager_enabled = 0

static

Definition at line 170 of file manager.c.

Referenced by __init_manager(), ast_manager_check_enabled(), ast_webmanager_check_enabled(), handle_manager_show_settings(), and manager_set_defaults().

manager_event_buf

struct ast_threadstorage manager_event_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_manager_event_buf , .custom_init = NULL , }

static

Definition at line 7537 of file manager.c.

Referenced by __manager_event_sessions_va().

manager_hooks

struct manager_hooks manager_hooks = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

static

manager_topic

struct stasis_topic* manager_topic

static

A stasis_topic that all topics AMI cares about will be forwarded to.

Definition at line 186 of file manager.c.

Referenced by __init_manager(), ast_manager_get_topic(), load_module(), manager_bridging_init(), manager_channels_init(), manager_mwi_init(), manager_shutdown(), manager_subscriptions_init(), manager_system_init(), and state_id_by_topic().

match_type_names

char* match_type_names[]

static

Definition at line 398 of file manager.c.

Referenced by manager_add_filter().

originate_app_permissions

struct originate_permissions_entry originate_app_permissions[]

static

Definition at line 5089 of file manager.c.

Referenced by is_originate_app_permitted().

perms

const struct permalias perms[]

static

Referenced by action_events(), authority_to_str(), get_perm(), strings_to_mask(), and user_authority_to_str().

rtp_topic_forwarder

struct stasis_forward* rtp_topic_forwarder

static

The stasis_subscription for forwarding the RTP topic to the AMI topic.

Definition at line 192 of file manager.c.

Referenced by manager_shutdown(), and manager_subscriptions_init().

security_topic_forwarder

struct stasis_forward* security_topic_forwarder

static

The stasis_subscription for forwarding the Security topic to the AMI topic.

Definition at line 195 of file manager.c.

Referenced by manager_shutdown(), and manager_subscriptions_init().

stasis_router

struct stasis_message_router* stasis_router

static

The stasis_message_router for all Stasis Message Bus API messages.

Definition at line 189 of file manager.c.

Referenced by ast_manager_get_message_router(), manager_shutdown(), and manager_subscriptions_init().

subscribed

int subscribed = 0

static

Definition at line 171 of file manager.c.

Referenced by __init_manager(), bridge_app_subscribed_involved(), bridge_attended_transfer_handler(), and subscribe_all().

timestampevents

int timestampevents

static

Definition at line 167 of file manager.c.

Referenced by __init_manager(), __manager_event_sessions_va(), and handle_manager_show_settings().

unauth_sessions

int unauth_sessions = 0

static

Definition at line 182 of file manager.c.

Referenced by action_login(), and session_do().

userevent_buf

struct ast_threadstorage userevent_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_userevent_buf , .custom_init = NULL , }

static

Definition at line 1890 of file manager.c.

Referenced by action_userevent().

users

struct users users = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

static

webmanager_enabled

int webmanager_enabled = 0

static

Definition at line 172 of file manager.c.

Referenced by __init_manager(), ast_webmanager_check_enabled(), and handle_manager_show_settings().

words

const char* words[AST_MAX_CMD_LEN]

Definition at line 226 of file manager.c.