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	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	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 , FILTER_ALLOC_FAILED , FILTER_COMPILE_FAIL }
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	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 void	append_channel_vars (struct ast_str **pbuf, struct ast_channel *chan)
static int	append_event (const char *str, 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	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 int	blackfilter_cmp_fn (void *obj, void *arg, void *data, int flags)
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	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 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 *filter_pattern, struct ao2_container *whitefilters, struct ao2_container *blackfilters)
	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_filter (struct mansession *s, char *eventdata)
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_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	restrictedFile (const char *filename)
	Check if a file is restricted or not. More...
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	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...
static int	whitefilter_cmp_fn (void *obj, void *arg, void *data, int flags)

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 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 1987 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 3288 of file manager.c.

DEFAULT_REALM

#define DEFAULT_REALM   "asterisk"

Definition at line 1629 of file manager.c.

EVENT_FLAG_SHUTDOWN

#define EVENT_FLAG_SHUTDOWN   -1

Fake event class used to end sessions at shutdown.

Definition at line 1662 of file manager.c.

GET_HEADER_FIRST_MATCH

#define GET_HEADER_FIRST_MATCH   0

Definition at line 2988 of file manager.c.

GET_HEADER_LAST_MATCH

#define GET_HEADER_LAST_MATCH   1

Definition at line 2989 of file manager.c.

GET_HEADER_SKIP_EMPTY

#define GET_HEADER_SKIP_EMPTY   2

Definition at line 2990 of file manager.c.

MANAGER_EVENT_BUF_INITSIZE

#define MANAGER_EVENT_BUF_INITSIZE   256

Definition at line 7885 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 1984 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 2195 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 1674 of file manager.c.

MAX_VARS

#define MAX_VARS   128

Definition at line 1659 of file manager.c.

MGR_SHOW_TERMINAL_WIDTH

#define MGR_SHOW_TERMINAL_WIDTH   80

Definition at line 1657 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 3336 of file manager.c.

Enumeration Type Documentation

add_filter_result

enum add_filter_result

Enumerator
FILTER_SUCCESS
FILTER_ALLOC_FAILED
FILTER_COMPILE_FAIL

Definition at line 1579 of file manager.c.

                       {
    FILTER_SUCCESS,
    FILTER_ALLOC_FAILED,
    FILTER_COMPILE_FAIL,
};

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 1564 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
};

mansession_message_parsing

enum mansession_message_parsing

Enumerator
MESSAGE_OKAY
MESSAGE_LINE_TOO_LONG

Definition at line 1767 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 8016 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 3005 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 3283 of file manager.c.

{

__init_manager_event_buf()

static void __init_manager_event_buf ( void  )

static

Definition at line 7884 of file manager.c.

{

__init_userevent_buf()

static void __init_userevent_buf ( void  )

static

Definition at line 3285 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 7994 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 7887 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;
 
    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");
 
    append_event(ast_str_buffer(buf), 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_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 10458 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 1685 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 1695 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 5823 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 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(), and NULL.

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 6218 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 5994 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 6261 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 5471 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 5425 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 5525 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 4736 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 5602 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 6874 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 7158 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;
    }
 
    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\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 6990 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 6918 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"
            "\r\n",
            idText,
            startupdate,
            startuptime,
            reloaddate,
            reloadtime,
            ast_active_channels()
            );
    return 0;
}

References ast_active_channels(), ast_lastreloadtime, ast_localtime(), 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 4482 of file manager.c.

{
    int fd;
    const char *fn = astman_get_header(m, "Filename");
    struct ast_str *filepath = ast_str_alloca(PATH_MAX);
    ast_str_set(&filepath, 0, "%s/", ast_config_AST_CONFIG_DIR);
    ast_str_append(&filepath, 0, "%s", fn);
 
    if ((fd = open(ast_str_buffer(filepath), 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_config_AST_CONFIG_DIR, AST_FILE_MODE, ast_str_alloca, ast_str_append(), ast_str_buffer(), ast_str_set(), astman_get_header(), astman_send_ack(), astman_send_error(), errno, and PATH_MAX.

Referenced by __init_manager().

action_destroy()

static void action_destroy ( void *  obj )

static

Definition at line 8153 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 4637 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 6571 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 6708 of file manager.c.

{
    const char *filter = astman_get_header(m, "Filter");
    const char *operation = astman_get_header(m, "Operation");
    int res;
 
    if (!strcasecmp(operation, "Add")) {
        res = manager_add_filter(filter, s->session->whitefilters, s->session->blackfilters);
 
            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 {
                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 astman_get_header(), astman_send_ack(), astman_send_error(), mansession_session::blackfilters, filter(), FILTER_ALLOC_FAILED, FILTER_COMPILE_FAIL, FILTER_SUCCESS, manager_add_filter(), mansession::session, and mansession_session::whitefilters.

Referenced by __init_manager().

action_find()

static struct manager_action * action_find ( const char *  name )

static

Definition at line 1856 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 3896 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 = restrictedFile(fn);
    if (ret == 1) {
        astman_send_error(s, m, "File requires escalated priveledges");
        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(), ast_variable::name, ast_variable::next, NULL, restrictedFile(), 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 4034 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 (restrictedFile(fn)) {
        astman_send_error(s, m, "File requires escalated priveledges");
        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(), ast_variable::name, ast_variable::next, NULL, restrictedFile(), 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 4914 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 4875 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 3968 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;
 
    if (ast_strlen_zero(fn)) {
        astman_send_error(s, m, "Filename not specified");
        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, match(), and NULL.

Referenced by __init_manager().

action_listcommands()

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

static

Definition at line 4618 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 7232 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 4687 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, tmp(), 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 4681 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 6550 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 6533 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 6320 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) {
        int bad_appdata = 0;
        /* To run the System application (or anything else that goes to
         * shell), you must have the additional System privilege */
        if (!(s->session->writeperm & EVENT_FLAG_SYSTEM)
            && (
                strcasestr(app, "system") ||      /* System(rm -rf /)
                                                     TrySystem(rm -rf /)       */
                strcasestr(app, "exec") ||        /* Exec(System(rm -rf /))
                                                     TryExec(System(rm -rf /)) */
                strcasestr(app, "agi") ||         /* AGI(/bin/rm,-rf /)
                                                     EAGI(/bin/rm,-rf /)       */
                strcasestr(app, "mixmonitor") ||  /* MixMonitor(blah,,rm -rf)  */
                strcasestr(app, "externalivr") || /* ExternalIVR(rm -rf)       */
                strcasestr(app, "originate") ||   /* Originate(Local/1234,app,System,rm -rf) */
                (strstr(appdata, "SHELL") && (bad_appdata = 1)) ||       /* NoOp(${SHELL(rm -rf /)})  */
                (strstr(appdata, "EVAL") && (bad_appdata = 1))           /* NoOp(${EVAL(${some_var_containing_SHELL})}) */
                )) {
            char error_buf[64];
            snprintf(error_buf, sizeof(error_buf), "Originate Access Forbidden: %s", bad_appdata ? "Data" : "Application");
            astman_send_error(s, m, error_buf);
            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; /* transfered 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, EVENT_FLAG_SYSTEM, fast_originate(), name, ast_variable::next, NULL, priority, fast_originate_helper::priority, mansession::session, strcasestr(), fast_originate_helper::timeout, tmp(), 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 3824 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 6601 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 5280 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 = ast_async_goto(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 = ast_async_goto(chan, context, exten, pi);
    if (!res) {
        if (!ast_strlen_zero(context2)) {
            res = ast_async_goto(chan2, context2, exten2, pi2);
        } else {
            res = ast_async_goto(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_async_goto(), 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(), 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 6958 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 5237 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 4881 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 5081 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 6641 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 4391 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 (restrictedFile(sfn) || restrictedFile(dfn)) {
        astman_send_error(s, m, "File requires escalated priveledges");
        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(), NULL, restrictedFile(), 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 6853 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 4500 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)
                && match_filter(s, eqe->eventdata)) {
                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::last_ev, mansession_session::managerid, match_filter(), max, mansession_session::needdestroy, mansession_session::notify_lock, NULL, mansession_session::readperm, mansession_session::send_events, mansession::session, mansession_session::sessiontimeout, 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 2975 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 5798 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_str_alloca, ast_str_buffer(), ast_str_set(), ast_strlen_zero(), astman_get_header(), and str.

Referenced by action_aoc_de_message().

append_channel_vars()

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

static

Definition at line 7867 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  category  )

static

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

Definition at line 7843 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();
    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(), NULL, seq, str, and tmp().

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 3159 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 2264 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 2101 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 1877 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 1872 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 4754 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 2055 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 8167 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;
    }
 
    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_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_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_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 2086 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 8112 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 1973 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 8041 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 2094 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 2106 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 3302 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 3052 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 4025 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 3290 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 3066 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 3042 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 3128 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 3133 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 3842 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 3413 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 3381 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 3386 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 3450 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 3467 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 3459 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 3428 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 3423 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 3376 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 3345 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 3418 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().

authenticate()

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

static

Definition at line 3727 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->whitefilters, 0);
    while ((regex_filter = ao2_iterator_next(&filter_iter))) {
        ao2_t_link(s->session->whitefilters, regex_filter, "add white user filter to session");
        ao2_t_ref(regex_filter, -1, "remove iterator ref");
    }
    ao2_iterator_destroy(&filter_iter);
 
    filter_iter = ao2_iterator_init(user->blackfilters, 0);
    while ((regex_filter = ao2_iterator_next(&filter_iter))) {
        ao2_t_link(s->session->blackfilters, regex_filter, "add black 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::blackfilters, mansession_session::challenge, mansession_session::chanvars, error(), get_manager_by_name_locked(), 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::whitefilters, 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 2236 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().

blackfilter_cmp_fn()

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

static

Definition at line 6689 of file manager.c.

{
    regex_t *regex_filter = obj;
    const char *eventdata = arg;
    int *result = data;
 
    if (!regexec(regex_filter, eventdata, 0, NULL, 0)) {
        *result = 0;
        return (CMP_MATCH | CMP_STOP);
    }
 
    *result = 1;
    return 0;
}

References CMP_MATCH, CMP_STOP, NULL, and result.

Referenced by match_filter().

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 2381 of file manager.c.

{
    struct ao2_container *sessions;
    struct mansession_session *newsession;
 
    newsession = ao2_alloc(sizeof(*newsession), session_destructor);
    if (!newsession) {
        return NULL;
    }
 
    newsession->whitefilters = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
    newsession->blackfilters = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
    if (!newsession->whitefilters || !newsession->blackfilters) {
        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::blackfilters, mansession_session::notify_lock, NULL, mansession_session::send_events, session_destructor(), sessions, mansession_session::waiting_thread, mansession_session::whitefilters, 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 5566 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 2434 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 7074 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 7057 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 5710 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 7624 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 2344 of file manager.c.

{
    regex_t *regex_filter = obj;
    regfree(regex_filter);
}

Referenced by manager_add_filter().

fast_originate()

static void * fast_originate ( void *  data )

static

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

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 2198 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 4966 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 7503 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 2457 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 2283 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 2115 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 2807 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 2956 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 2624 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 7607 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 2649 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 2722 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 2492 of file manager.c.

{
    struct manager_action *cur;
    struct ast_str *authority;
    int num;
    int l;
    const char *auth_str;
#ifdef AST_XML_DOCS
    char syntax_title[64], description_title[64], synopsis_title[64], seealso_title[64];
    char arguments_title[64], privilege_title[64], final_response_title[64], list_responses_title[64];
#endif
 
    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);
 
#ifdef AST_XML_DOCS
    /* setup the titles */
    term_color(synopsis_title, "[Synopsis]\n", COLOR_MAGENTA, 0, 40);
    term_color(description_title, "[Description]\n", COLOR_MAGENTA, 0, 40);
    term_color(syntax_title, "[Syntax]\n", COLOR_MAGENTA, 0, 40);
    term_color(seealso_title, "[See Also]\n", COLOR_MAGENTA, 0, 40);
    term_color(arguments_title, "[Arguments]\n", COLOR_MAGENTA, 0, 40);
    term_color(privilege_title, "[Privilege]\n", COLOR_MAGENTA, 0, 40);
    term_color(final_response_title, "[Final Response]\n", COLOR_MAGENTA, 0, 40);
    term_color(list_responses_title, "[List Responses]\n", COLOR_MAGENTA, 0, 40);
#endif
 
    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 *syntax = ast_xmldoc_printable(S_OR(cur->syntax, "Not available"), 1);
                    char *synopsis = ast_xmldoc_printable(S_OR(cur->synopsis, "Not available"), 1);
                    char *description = ast_xmldoc_printable(S_OR(cur->description, "Not available"), 1);
                    char *arguments = ast_xmldoc_printable(S_OR(cur->arguments, "Not available"), 1);
                    char *seealso = ast_xmldoc_printable(S_OR(cur->seealso, "Not available"), 1);
                    char *privilege = ast_xmldoc_printable(S_OR(auth_str, "Not available"), 1);
                    char *responses = ast_xmldoc_printable("None", 1);
 
                    if (!syntax || !synopsis || !description || !arguments
                            || !seealso || !privilege || !responses) {
                        ast_free(syntax);
                        ast_free(synopsis);
                        ast_free(description);
                        ast_free(arguments);
                        ast_free(seealso);
                        ast_free(privilege);
                        ast_free(responses);
                        ast_cli(a->fd, "Allocation failure.\n");
                        AST_RWLIST_UNLOCK(&actions);
 
                        return CLI_FAILURE;
                    }
 
                    ast_cli(a->fd, "%s%s\n\n%s%s\n\n%s%s\n\n%s%s\n\n%s%s\n\n%s%s\n\n%s",
                        syntax_title, syntax,
                        synopsis_title, synopsis,
                        description_title, description,
                        arguments_title, arguments,
                        seealso_title, seealso,
                        privilege_title, privilege,
                        list_responses_title);
 
                    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, "%s", final_response_title);
 
                    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_free(syntax);
                    ast_free(synopsis);
                    ast_free(description);
                    ast_free(arguments);
                    ast_free(seealso);
                    ast_free(privilege);
                    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_XML_DOC, ast_xmldoc_printable(), manager_action::authority, authority_to_str(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, COLOR_MAGENTA, 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, synopsis, manager_action::synopsis, manager_action::syntax, ast_xml_doc_item::syntax, term_color(), 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 2765 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 2877 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 2928 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 4108 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().

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 4007 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 7336 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 3084 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 *  filter_pattern, struct ao2_container *  whitefilters, struct ao2_container *  blackfilters  )

static

Add an event filter to a manager session.

Parameters

filter_pattern	Filter syntax to add, see below for syntax
whitefilters,blackfilters

Returns

FILTER_ALLOC_FAILED Memory allocation failure

FILTER_COMPILE_FAIL If the filter did not compile

FILTER_SUCCESS Success

Filter will be used to match against each line of a manager event Filter can be any valid regular expression Filter can be a valid regular expression prefixed with !, which will add the filter as a black filter

Examples:

filter_pattern = "Event: Newchannel"
filter_pattern = "Event: New.*"
filter_pattern = "!Channel: DAHDI.*"

Definition at line 6760 of file manager.c.

                                                                                                                                                     {
    regex_t *new_filter = ao2_t_alloc(sizeof(*new_filter), event_filter_destructor, "event_filter allocation");
    int is_blackfilter;
 
    if (!new_filter) {
        return FILTER_ALLOC_FAILED;
    }
 
    if (filter_pattern[0] == '!') {
        is_blackfilter = 1;
        filter_pattern++;
    } else {
        is_blackfilter = 0;
    }
 
    if (regcomp(new_filter, filter_pattern, REG_EXTENDED | REG_NOSUB)) {
        ao2_t_ref(new_filter, -1, "failed to make regex");
        return FILTER_COMPILE_FAIL;
    }
 
    if (is_blackfilter) {
        ao2_t_link(blackfilters, new_filter, "link new filter into black user container");
    } else {
        ao2_t_link(whitefilters, new_filter, "link new filter into white user container");
    }
 
    ao2_ref(new_filter, -1);
 
    return FILTER_SUCCESS;
}

References ao2_ref, ao2_t_alloc, ao2_t_link, ao2_t_ref, event_filter_destructor(), FILTER_ALLOC_FAILED, FILTER_COMPILE_FAIL, and FILTER_SUCCESS.

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 1990 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 2474 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 2021 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 1907 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 1917 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 1932 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 1882 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 7244 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 7273 of file manager.c.

{
    int res;
    const char *module = astman_get_header(m, "Module");
    const char *loadtype = astman_get_header(m, "LoadType");
 
    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");
    }
 
    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, "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_strlen_zero(), ast_unload_resource(), astman_get_header(), astman_send_ack(), astman_send_error(), 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 8071 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 2414 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 3501 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 3473 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 3479 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_filter()

static int match_filter ( struct mansession *  s, char *  eventdata  )

static

Definition at line 6791 of file manager.c.

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

References ao2_container_count(), ao2_t_callback_data, ast_debug, ast_verbose(), blackfilter_cmp_fn(), mansession_session::blackfilters, manager_debug, OBJ_NODATA, result, mansession::session, whitefilter_cmp_fn(), and mansession_session::whitefilters.

Referenced by action_waitevent(), and process_events().

print_event_instance()

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

static

Definition at line 9598 of file manager.c.

{
    char syntax_title[64], description_title[64], synopsis_title[64], seealso_title[64], arguments_title[64];
 
    term_color(synopsis_title, "[Synopsis]\n", COLOR_MAGENTA, 0, 40);
    term_color(description_title, "[Description]\n", COLOR_MAGENTA, 0, 40);
    term_color(syntax_title, "[Syntax]\n", COLOR_MAGENTA, 0, 40);
    term_color(seealso_title, "[See Also]\n", COLOR_MAGENTA, 0, 40);
    term_color(arguments_title, "[Arguments]\n", COLOR_MAGENTA, 0, 40);
 
    if (!ast_strlen_zero(ast_str_buffer(instance->synopsis))) {
        char *synopsis = ast_xmldoc_printable(ast_str_buffer(instance->synopsis), 1);
        ast_cli(a->fd, "%s%s\n\n", synopsis_title, synopsis);
        ast_free(synopsis);
    }
    if (!ast_strlen_zero(ast_str_buffer(instance->syntax))) {
        char *syntax = ast_xmldoc_printable(ast_str_buffer(instance->syntax), 1);
        ast_cli(a->fd, "%s%s\n\n", syntax_title, syntax);
        ast_free(syntax);
    }
    if (!ast_strlen_zero(ast_str_buffer(instance->description))) {
        char *description = ast_xmldoc_printable(ast_str_buffer(instance->description), 1);
        ast_cli(a->fd, "%s%s\n\n", description_title, description);
        ast_free(description);
    }
    if (!ast_strlen_zero(ast_str_buffer(instance->arguments))) {
        char *arguments = ast_xmldoc_printable(ast_str_buffer(instance->arguments), 1);
        ast_cli(a->fd, "%s%s\n\n", arguments_title, arguments);
        ast_free(arguments);
    }
    if (!ast_strlen_zero(ast_str_buffer(instance->seealso))) {
        char *seealso = ast_xmldoc_printable(ast_str_buffer(instance->seealso), 1);
        ast_cli(a->fd, "%s%s\n\n", seealso_title, seealso);
        ast_free(seealso);
    }
}

References a, ast_xml_doc_item::arguments, ast_cli(), ast_free, ast_str_buffer(), ast_strlen_zero(), ast_xmldoc_printable(), COLOR_MAGENTA, ast_xml_doc_item::description, ast_xml_doc_item::seealso, synopsis, ast_xml_doc_item::synopsis, ast_xml_doc_item::syntax, and term_color().

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 6825 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 (match_filter(s, eqe->eventdata)) {
                        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::last_ev, match_filter(), NULL, mansession_session::readperm, mansession_session::send_events, send_string(), mansession::session, 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 7375 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 2135 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 7803 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_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 5169 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 5202 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 5218 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 10482 of file manager.c.

{
    return __init_manager(1, 0);
}

References __init_manager().

Referenced by handle_manager_reload().

report_auth_success()

static void report_auth_success ( const struct mansession *  s )

static

Definition at line 3582 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 3532 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 3665 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 3557 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 3507 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 3636 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 3607 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 3695 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().

restrictedFile()

static int restrictedFile ( 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 3863 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(), and action_updateconfig().

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 3247 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 2421 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 2350 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->whitefilters) {
        ao2_t_ref(session->whitefilters, -1, "decrement ref for white container, should be last one");
    }
 
    if (session->blackfilters) {
        ao2_t_ref(session->blackfilters, -1, "decrement ref for black 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(), 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 7709 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 3488 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().

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 2304 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 2335 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 2212 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().

whitefilter_cmp_fn()

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

static

Definition at line 6675 of file manager.c.

{
    regex_t *regex_filter = obj;
    const char *eventdata = arg;
    int *result = data;
 
    if (!regexec(regex_filter, eventdata, 0, NULL, 0)) {
        *result = 1;
        return (CMP_MATCH | CMP_STOP);
    }
 
    return 0;
}

References CMP_MATCH, CMP_STOP, NULL, and result.

Referenced by match_filter().

Variable Documentation

acl_change_sub

struct stasis_subscription* acl_change_sub

static

Definition at line 1633 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 1616 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 3283 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 1625 of file manager.c.

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

authtimeout

int authtimeout

static

Definition at line 1624 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 1619 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 1615 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 1630 of file manager.c.

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

httptimeout

int httptimeout = 60

static

Definition at line 1618 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 1650 of file manager.c.

Referenced by astman_live_dangerously(), load_asterisk_conf(), and restrictedFile().

manager_channelvars

char* manager_channelvars

static

Definition at line 1626 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 1623 of file manager.c.

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

manager_disabledevents

char* manager_disabledevents

static

Definition at line 1627 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 1620 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 7884 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 1636 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().

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 1642 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 1645 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 1639 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 1621 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 1617 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 1632 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 3285 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 1622 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 1676 of file manager.c.