AMI functions

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

Macros
#define	any_manager_listeners(sessions)    ((sessions && ao2_container_count(sessions)) || !AST_RWLIST_EMPTY(&manager_hooks))
#define	ASTMAN_APPEND_BUF_INITSIZE   256
	initial allocated size for the astman_append_buf and astman_send_*_va
#define	DEFAULT_REALM   "asterisk"
#define	EVENT_FLAG_SHUTDOWN   -1
	Fake event class used to end sessions at shutdown.
#define	GET_HEADER_FIRST_MATCH   0
#define	GET_HEADER_LAST_MATCH   1
#define	GET_HEADER_SKIP_EMPTY   2
#define	MANAGER_EVENT_BUF_INITSIZE   256
	Initial size of the manager event message buffer.
#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.
#define	MAX_VARS   128
#define	MGR_SHOW_TERMINAL_WIDTH   80
#define	MSG_MOREDATA   ((char *)astman_send_response)

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

Functions
int	__ast_manager_event_multichan (int category, const char *event, int chancount, struct ast_channel **chans, const char *file, int line, const char *func, const char *fmt,...)
static const char *	__astman_get_header (const struct message *m, char *var, int mode)
	Return a matching header value.
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_name, 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.
static int	action_coresettings (struct mansession *s, const struct message *m)
	Show PBX core settings information.
static int	action_coreshowchannelmap (struct mansession *s, const struct message *m)
	Manager command "CoreShowChannelMap" - Lists all channels connected to the specified channel.
static int	action_coreshowchannels (struct mansession *s, const struct message *m)
	Manager command "CoreShowChannels" - List currently defined channels and some information about them.
static int	action_corestatus (struct mansession *s, const struct message *m)
	Show PBX core status information.
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.
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'.
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
static int	action_reload (struct mansession *s, const struct message *m)
	Send a reload event.
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.
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 int	action_waitevent_http (struct mansession *s, const struct message *m, const char *id, int timeout)
static int	action_waitevent_tcp (struct mansession *s, const struct message *m, const char *id, int timeout)
static	AO2_GLOBAL_OBJ_STATIC (event_docs)
	A container of event documentation nodes.
static	AO2_GLOBAL_OBJ_STATIC (mgr_sessions)
static int	aocmessage_get_unit_entry (const struct message *m, struct ast_aoc_unit_entry *entry, unsigned int entry_num)
static int	app_match (const char *app, const char *data, const char *search)
static int	appdata_match (const char *app, const char *data, const char *search)
static void	append_channel_vars (struct ast_str **pbuf, struct ast_channel *chan)
int	ast_hook_send_action (struct manager_custom_hook *hook, const char *msg)
	access for hooks to send action messages to ami
static int	ast_instring (const char *bigstr, const char *smallstr, const char delim)
int	ast_manager_check_enabled (void)
	Check if AMI is enabled.
struct stasis_message_router *	ast_manager_get_message_router (void)
	Get the stasis_message_router for AMI.
struct stasis_topic *	ast_manager_get_topic (void)
	Get the Stasis Message Bus API topic for AMI.
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.
void	ast_manager_publish_event (const char *type, int class_type, struct ast_json *obj)
	Publish an event to AMI.
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
void	ast_manager_register_hook (struct manager_custom_hook *hook)
	Add a custom hook to be called when an event is fired.
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.
int	ast_manager_unregister (const char *action)
	support functions to register/unregister AMI action handlers,
void	ast_manager_unregister_hook (struct manager_custom_hook *hook)
	Delete a custom hook to be called when an event is fired.
	AST_THREADSTORAGE_CUSTOM_SCOPE (astman_append_buf, NULL, ast_free_ptr, static)
	thread local buffer for astman_append
	AST_THREADSTORAGE_CUSTOM_SCOPE (userevent_buf, NULL, ast_free_ptr, static)
int	ast_webmanager_check_enabled (void)
	Check if AMI/HTTP is enabled.
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.
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.
const char *	astman_get_header (const struct message *m, char *var)
	Return the first matching variable from an array.
struct ast_variable *	astman_get_variables (const struct message *m)
	Get a linked list of the Variable: headers.
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.
void	astman_live_dangerously (int new_live_dangerously)
	Enable/disable the inclusion of 'dangerous' configurations outside of the ast_config_AST_CONFIG_DIR.
void	astman_send_ack (struct mansession *s, const struct message *m, char *msg)
	Send ack in manager transaction.
void	astman_send_error (struct mansession *s, const struct message *m, char *error)
	Send error in manager transaction.
void	astman_send_error_va (struct mansession *s, const struct message *m, const char *fmt,...)
	Send error in manager transaction (with va_args support)
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.
void	astman_send_list_complete_start (struct mansession *s, const struct message *m, const char *event_name, int count)
	Start the list complete event.
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.
void	astman_send_response (struct mansession *s, const struct message *m, char *resp, char *msg)
	Send response in manager transaction.
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.
static void	astman_start_ack (struct mansession *s, const struct message *m)
static int	async_goto_with_discard_bridge_after (struct ast_channel *chan, const char *context, const char *exten, int priority)
static int	authenticate (struct mansession *s, const struct message *m)
static const char *	authority_to_str (int authority, struct ast_str **res)
	Convert authority code to a list of options. Note that the EVENT_FLAG_ALL authority will always be returned.
static struct mansession_session *	build_mansession (const struct ast_sockaddr *addr, unsigned int needs_alert_pipe)
	Allocate manager session structure and add it to the list of sessions.
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.
static int	coreshowchannelmap_add_to_map (struct ao2_container *c, const char *s)
	Helper function to add a channel name to the vector.
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 struct eventqent *	eventqent_alloc (const char *event_name, int category)
	Allocate a manager event.
static void	eventqent_destructor (void *obj)
	Destructor for manager event message.
static void *	fast_originate (void *data)
static int	file_in_modules_dir (const char *filename)
	Check if the given file path is in the modules dir or not.
static int	filter_cmp_fn (void *obj, void *arg, void *data, int flags)
static int	function_capable_string_allowed_with_auths (const char *evaluating, int writepermlist)
	Checks to see if a string which can be used to evaluate functions should be rejected.
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, struct pollfd *pfds, char *output)
static struct ast_manager_user *	get_manager_by_name_locked (const char *name)
static int	get_perm (const char *instr)
static char *	handle_kickmanconn (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command manager kick session.
static char *	handle_manager_reload (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command manager reload.
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.
static char *	handle_showmanconn (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command manager list connected.
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
static int	is_originate_app_permitted (const char *app, const char *data, int permission)
static int	is_restricted_file (const char *filename)
	Check if a file is restricted or not.
static void	json_escape (char *out, const char *in)
static void	log_action (const struct message *m, const char *action)
static struct ast_variable *	man_do_variable_value (struct ast_variable *head, const char *hdr_val)
static enum add_filter_result	manager_add_filter (const char *criteria, const char *filter_pattern, struct ao2_container *includefilters, struct ao2_container *excludefilters)
	Add an event filter to a manager session.
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.
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.
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 void	manager_subscription_change_msg_cb (void *userdata, struct stasis_subscription *sub, struct stasis_message *message)
	Callback for subscription change messages.
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.
static void	mansession_unlock (struct mansession *s)
	Unlock the 'mansession' structure.
static int	match_eventdata (struct event_filter_entry *entry, const char *eventdata)
	Test eventdata against a filter entry.
static void	print_event_instance (struct ast_cli_args *a, struct ast_xml_doc_item *instance)
static int	process_events (struct mansession *s)
	Send any pending events to the client listening on this socket.
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.
static int	purge_sessions (int n_max)
	remove at most n_max stale session from the list.
static int	queue_match (const char *app, const char *data, const char *search)
static int	queue_read_action_payload (struct ast_channel *chan, const unsigned char *payload, size_t payload_size, enum ast_frame_read_action action)
	Queue a given read action containing a payload onto a channel.
static int	queue_sendtext (struct ast_channel *chan, const char *body)
	Queue a read action to send a text message.
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.
static int	reload_module (void)
static void	report_auth_success (const struct mansession *s)
static void	report_failed_acl (const struct mansession *s, const char *username)
static void	report_failed_challenge_response (const struct mansession *s, const char *response, const char *expected_response)
static void	report_inval_password (const struct mansession *s, const char *username)
static void	report_invalid_user (const struct mansession *s, const char *username)
static void	report_req_bad_format (const struct mansession *s, const char *action)
static void	report_req_not_allowed (const struct mansession *s, const char *action)
static void	report_session_limit (const struct mansession *s)
static int	send_string (struct mansession *s, char *string)
static void	session_destroy (struct mansession_session *s)
static void	session_destructor (void *obj)
static void *	session_do (void *data)
	The body of the individual manager session. Call get_input() to read one line at a time (or be woken up on new events), collect the lines in a message until found an empty line, and execute the request. In any case, deliver events asynchronously through process_events() (called from here if no line is available, or at the end of process_message(). )
static void	session_notify (struct mansession_session *session)
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.
static int	should_send_event (struct ao2_container *includefilters, struct ao2_container *excludefilters, struct eventqent *eqe)
static int	strings_to_mask (const char *string)
static struct mansession_session *	unref_mansession (struct mansession_session *s)
	Unreference manager session object. If no more references, then go ahead and delete it.
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.

Variables
static struct stasis_subscription *	acl_change_sub
static struct actions	actions = AST_RWLIST_HEAD_INIT_VALUE
static int	allowmultiplelogin = 1
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.
static char *	manager_channelvars
static int	manager_debug = 0
static char *	manager_disabledevents
static int	manager_enabled = 0
static struct manager_hooks	manager_hooks = AST_RWLIST_HEAD_INIT_VALUE
static struct stasis_topic *	manager_topic
	A stasis_topic that all topics AMI cares about will be forwarded to.
static char *	match_type_names []
static struct originate_permissions_entry	originate_app_permissions []
static const struct permalias	perms []
static struct stasis_forward *	rtp_topic_forwarder
	The stasis_subscription for forwarding the RTP topic to the AMI topic.
static struct stasis_forward *	security_topic_forwarder
	The stasis_subscription for forwarding the Security topic to the AMI topic.
static struct stasis_message_router *	stasis_router
	The stasis_message_router for all Stasis Message Bus API messages.
static int	subscribed = 0
static int	timestampevents
static int	unauth_sessions = 0
static struct users	users = AST_RWLIST_HEAD_INIT_VALUE
static int	webmanager_enabled = 0
	STASIS_MESSAGE_TYPE_DEFN (ast_manager_get_generic_type)
	Define AMI message types.

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

DEFAULT_REALM

#define DEFAULT_REALM   "asterisk"

Definition at line 163 of file manager.c.

EVENT_FLAG_SHUTDOWN

#define EVENT_FLAG_SHUTDOWN   -1

Fake event class used to end sessions at shutdown.

Definition at line 196 of file manager.c.

GET_HEADER_FIRST_MATCH

#define GET_HEADER_FIRST_MATCH   0

Definition at line 1528 of file manager.c.

GET_HEADER_LAST_MATCH

#define GET_HEADER_LAST_MATCH   1

Definition at line 1529 of file manager.c.

GET_HEADER_SKIP_EMPTY

#define GET_HEADER_SKIP_EMPTY   2

Definition at line 1530 of file manager.c.

MANAGER_EVENT_BUF_INITSIZE

#define MANAGER_EVENT_BUF_INITSIZE   256

Initial size of the manager event message buffer.

Definition at line 7569 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 553 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 725 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 208 of file manager.c.

MAX_VARS

#define MAX_VARS   128

Definition at line 193 of file manager.c.

MGR_SHOW_TERMINAL_WIDTH

#define MGR_SHOW_TERMINAL_WIDTH   80

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

Enumeration Type Documentation

add_filter_result

enum add_filter_result

Enumerator
FILTER_SUCCESS
FILTER_ALLOC_FAILED
FILTER_COMPILE_FAIL
FILTER_FORMAT_ERROR

Definition at line 123 of file manager.c.

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

error_type

enum error_type

Doxygen group

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

Definition at line 108 of file manager.c.

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

event_filter_match_type

enum event_filter_match_type

Enumerator
FILTER_MATCH_REGEX
FILTER_MATCH_EXACT
FILTER_MATCH_STARTS_WITH
FILTER_MATCH_ENDS_WITH
FILTER_MATCH_CONTAINS
FILTER_MATCH_NONE

Definition at line 376 of file manager.c.

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

mansession_message_parsing

enum mansession_message_parsing

Enumerator
MESSAGE_OKAY
MESSAGE_LINE_TOO_LONG

Definition at line 304 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 7757 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, ast_category::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 1545 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().

__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 7735 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, ast_category::file, and sessions.

__manager_event_sessions_va()

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

static

Definition at line 7620 of file manager.c.

{
    struct eventqent *event;
    struct ast_str *auth = ast_str_alloca(MAX_AUTH_PERM_STRING);
    const char *cat_str;
    int i;
 
    if (!ast_strlen_zero(manager_disabledevents)) {
        if (ast_in_delimited_string(event_name, manager_disabledevents, ',')) {
            ast_debug(3, "AMI Event '%s' is globally disabled, skipping\n", event_name);
            /* Event is globally disabled */
            return -1;
        }
    }
 
    event = eventqent_alloc(event_name, category);
    if (!event) {
        return -1;
    }
 
    cat_str = authority_to_str(category, &auth);
    ast_str_set(&event->message, 0,
        "Event: %s\r\n"
        "Privilege: %s\r\n",
        event_name, cat_str);
 
    if (timestampevents) {
        struct timeval now;
 
        now = ast_tvnow();
        ast_str_append(&event->message, 0,
            "Timestamp: %ld.%06lu\r\n",
            (long)now.tv_sec, (unsigned long) now.tv_usec);
    }
    if (manager_debug) {
        static int seq;
 
        ast_str_append(&event->message, 0,
            "SequenceNumber: %d\r\n",
            ast_atomic_fetchadd_int(&seq, 1));
        ast_str_append(&event->message, 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(&event->message, 0,
            "SystemName: %s\r\n",
            ast_config_AST_SYSTEM_NAME);
    }
 
    ast_str_append_va(&event->message, 0, fmt, ap);
    for (i = 0; i < chancount; i++) {
        append_channel_vars(&event->message, chans[i]);
    }
 
    ast_str_append(&event->message, 0, "\r\n");
 
    /* Wake up any sleeping sessions */
    if (sessions) {
        struct ao2_iterator iter;
        struct mansession_session *session;
 
        /*
         * This purposely does not hold the session lock while checking send_events, as it
         * could block for a long period of time. We also do a second check in the consumer
         * of the pending_events queue such that if an event is added to the queue which should no
         * longer be sent to the session it won't be.
         */
        iter = ao2_iterator_init(sessions, 0);
        while ((session = ao2_iterator_next(&iter))) {
            if (category == EVENT_FLAG_SHUTDOWN ||
                (session->send_events & category) == category) {
                ast_mutex_lock(&session->pending_events_lock);
                if (!AST_VECTOR_APPEND(&session->pending_events, ao2_bump(event))) {
                    if (AST_VECTOR_SIZE(&session->pending_events) == 1) {
                        /* If this is the first event, wake up the session */
                        session_notify(session);
                    }
                } else {
                    ao2_ref(event, -1);
                }
                ast_mutex_unlock(&session->pending_events_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_name, ast_str_buffer(event->message));
        }
        AST_RWLIST_UNLOCK(&manager_hooks);
    }
 
    ao2_ref(event, -1);
 
    return 0;
}

References ao2_bump, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, append_channel_vars(), ast_atomic_fetchadd_int(), ast_config_AST_SYSTEM_NAME, ast_debug, ast_in_delimited_string(), ast_mutex_lock, ast_mutex_unlock, 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_strlen_zero(), ast_tvnow(), AST_VECTOR_APPEND, AST_VECTOR_SIZE, authority_to_str(), chancount, EVENT_FLAG_SHUTDOWN, eventqent_alloc(), ast_category::file, manager_custom_hook::helper, manager_debug, manager_disabledevents, MAX_AUTH_PERM_STRING, seq, session, session_notify(), 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 10155 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(), and LOG_NOTICE.

Referenced by acl_change_stasis_subscribe().

acl_change_stasis_subscribe()

static void acl_change_stasis_subscribe ( void  )

static

Definition at line 221 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 231 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 4544 of file manager.c.

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

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

Referenced by action_aocmessage().

action_aoc_s_message()

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

static

Definition at line 4939 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 4715 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 4982 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 4192 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(), digit, ast_frame_subclass::integer, name, NULL, pbx_builtin_setvar_helper(), and ast_frame::subclass.

Referenced by __init_manager().

action_blind_transfer()

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

static

Definition at line 4146 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(), 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 4246 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, ast_frame_subclass::integer, name, NULL, and ast_frame::subclass.

Referenced by __init_manager().

action_challenge()

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

static

Definition at line 3451 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 4323 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_cli_command, 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 6525 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 6811 of file manager.c.

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

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

Referenced by __init_manager().

action_coreshowchannels()

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

static

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

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

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

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

Referenced by __init_manager().

action_createconfig()

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

static

Definition at line 3044 of file manager.c.

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

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

Referenced by __init_manager().

action_destroy()

static void action_destroy ( void *  obj )

static

Definition at line 7894 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 3353 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 5508 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(), 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 5733 of file manager.c.

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

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

Referenced by __init_manager().

action_find()

static struct manager_action * action_find ( const char *  name )

static

Definition at line 425 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, manager_action::list, 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 2448 of file manager.c.

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

References ast_category_browse_filtered(), ast_category_first(), ast_category_get_name(), ast_category_get_templates(), ast_category_is_template(), ast_config_destroy(), ast_config_load2(), ast_free, ast_str_buffer(), ast_str_strlen(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), astman_start_ack(), CONFIG_FLAG_NOCACHE, CONFIG_FLAG_WITHCOMMENTS, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEMISSING, filter(), is_restricted_file(), ast_variable::name, ast_variable::next, NULL, 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 2596 of file manager.c.

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

References ast_category_browse_filtered(), ast_category_first(), ast_category_get_name(), ast_category_get_templates(), ast_category_is_template(), ast_config_destroy(), ast_config_load2(), ast_free, ast_str_buffer(), ast_str_strlen(), ast_strlen_zero(), astman_append(), astman_append_json(), astman_get_header(), astman_send_error(), astman_start_ack(), CONFIG_FLAG_NOCACHE, CONFIG_FLAG_WITHCOMMENTS, CONFIG_STATUS_FILEINVALID, filter(), is_restricted_file(), ast_variable::name, ast_variable::next, NULL, 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 3629 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 3590 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 2520 of file manager.c.

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

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

Referenced by __init_manager().

action_listcommands()

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

static

Definition at line 3334 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 6892 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 3403 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)
        && ast_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_fully_booted, ast_lastreloadtime, ast_sockaddr_stringify_addr(), ast_startuptime, ast_str_alloca, 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::send_events, mansession::session, unauth_sessions, and mansession_session::username.

Referenced by __init_manager().

action_logoff()

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

static

Definition at line 3397 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 5487 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(), and astman_start_ack().

Referenced by __init_manager().

action_mailboxstatus()

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

static

Definition at line 5470 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(), and NULL.

Referenced by __init_manager().

action_originate()

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

static

Definition at line 5275 of file manager.c.

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

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

Referenced by __init_manager().

action_ping()

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

static

Definition at line 2376 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 5538 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");
 
    ast_free(subtype);
    ast_free(message);
 
    return 0;
}

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

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

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

References ast_channel_clear_flag(), ast_channel_flags(), ast_channel_get_by_name(), ast_channel_is_bridged(), ast_channel_lock, ast_channel_unlock, ast_channel_unref, ast_check_hangup_locked(), ast_findlabel_extension(), AST_FLAG_BRIDGE_DUAL_REDIRECT_WAIT, ast_set_flag, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), async_goto_with_discard_bridge_after(), buf, 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 6611 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_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 3952 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 3596 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 3796 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, 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 5581 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 2953 of file manager.c.

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

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

Referenced by __init_manager().

action_userevent()

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

static

Definition at line 6504 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, and manager_event.

Referenced by __init_manager().

action_waitevent()

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

static

Definition at line 3306 of file manager.c.

{
    const char *timeouts = astman_get_header(m, "Timeout");
    int timeout = -1;
    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 ? */
    }
 
    if (!s->session->managerid) {
        return action_waitevent_tcp(s, m, idText, timeout);
    } else {
        return action_waitevent_http(s, m, idText, timeout);
    }
}

References action_waitevent_http(), action_waitevent_tcp(), ast_strlen_zero(), astman_get_header(), mansession_session::managerid, and mansession::session.

Referenced by __init_manager().

action_waitevent_http()

static int action_waitevent_http ( struct mansession *  s, const struct message *  m, const char *  id, int  timeout  )

static

Definition at line 3200 of file manager.c.

{
    time_t now;
    int max, needexit = 0, x;
 
    ast_mutex_lock(&s->session->http_thread_lock);
    if (s->session->http_thread != AST_PTHREADT_NULL) {
        pthread_kill(s->session->http_thread, SIGURG);
    }
    ast_mutex_unlock(&s->session->http_thread_lock);
 
    ao2_lock(s->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.
     */
    now = time(NULL);
    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 = s->session->readperm;
    }
    ao2_unlock(s->session);
 
    ast_mutex_lock(&s->session->http_thread_lock);
    s->session->http_thread = pthread_self();   /* let new events wake up this thread */
    ast_mutex_unlock(&s->session->http_thread_lock);
    ast_debug(1, "Starting waiting for an event!\n");
 
    for (x = 0; x < timeout || timeout < 0; x++) {
        ast_mutex_lock(&s->session->pending_events_lock);
        if (AST_VECTOR_SIZE(&s->session->pending_events)) {
            needexit = 1;
        }
        ast_mutex_unlock(&s->session->pending_events_lock);
 
        ao2_lock(s->session);
        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->http_thread_lock);
        if (s->session->http_thread != pthread_self()) {
            needexit = 1;
        }
        ast_mutex_unlock(&s->session->http_thread_lock);
        if (needexit) {
            break;
        }
 
        sleep(1);
    }
    ast_debug(1, "Finished waiting for an event!\n");
 
    ast_mutex_lock(&s->session->http_thread_lock);
    if (s->session->http_thread == pthread_self()) {
        size_t events_count;
        struct eventqent **events;
 
        s->session->http_thread = AST_PTHREADT_NULL;
        ast_mutex_unlock(&s->session->http_thread_lock);
 
        /* To reduce contention we lock only long enough to steal the events */
        ast_mutex_lock(&s->session->pending_events_lock);
        events_count = AST_VECTOR_SIZE(&s->session->pending_events);
        events = AST_VECTOR_STEAL_ELEMENTS(&s->session->pending_events);
        ast_mutex_unlock(&s->session->pending_events_lock);
 
        ao2_lock(s->session);
        astman_send_response(s, m, "Success", "Waiting for Event completed.");
        for (x = 0; x < events_count; x++) {
            struct eventqent *eqe = events[x];
 
            if (((s->session->send_events & eqe->category) == eqe->category) &&
                should_send_event(s->session->includefilters, s->session->excludefilters, eqe)) {
                astman_append(s, "%s", ast_str_buffer(eqe->message));
            }
 
            ao2_ref(eqe, -1);
        }
        astman_append(s,
            "Event: WaitEventComplete\r\n"
            "%s"
            "\r\n", id);
        ao2_unlock(s->session);
        ast_free(events);
    } else {
        ast_mutex_unlock(&s->session->http_thread_lock);
        ast_debug(1, "Abandoning event request!\n");
    }
 
    return 0;
}

References ao2_lock, ao2_ref, ao2_unlock, ast_debug, ast_free, ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, ast_str_buffer(), AST_VECTOR_SIZE, AST_VECTOR_STEAL_ELEMENTS, astman_append(), astman_send_response(), eventqent::category, events, mansession_session::excludefilters, mansession_session::http_thread, mansession_session::http_thread_lock, mansession_session::includefilters, max, eventqent::message, mansession_session::needdestroy, NULL, mansession_session::pending_events, mansession_session::pending_events_lock, mansession_session::readperm, mansession_session::send_events, mansession::session, mansession_session::sessiontimeout, and should_send_event().

Referenced by action_waitevent().

action_waitevent_tcp()

static int action_waitevent_tcp ( struct mansession *  s, const struct message *  m, const char *  id, int  timeout  )

static

Definition at line 3118 of file manager.c.

{
    struct pollfd pfds[2];
    int x, res;
    size_t events_count;
    struct eventqent **events;
 
    /* Since we don't have access to the reusable pollfd, we set it up each time */
    memset(pfds, 0, sizeof(pfds));
    pfds[0].fd = ast_iostream_get_fd(s->session->stream);
    pfds[0].events = POLLIN | POLLPRI;
    pfds[1].fd = ast_alertpipe_readfd(s->session->alert_pipe);
    pfds[1].events = POLLIN | POLLPRI;
 
    ast_debug(1, "Starting waiting for an event!\n");
 
    for (x = 0; x < timeout || timeout < 0; x++) {
        /*
         * Poll on both the TCP connection as well as the alert pipe for events,
         * and when it comes to the timeout we get it passed in as seconds and the
         * poll will wake up every second. The for loop then enforces the timeout.
         */
        res = ast_poll(pfds, 2, 1000);
        if (res == -1) {
            if (errno == EINTR || errno == EAGAIN) {
                continue;
            }
            ast_log(LOG_WARNING, "poll() returned error: %s\n", strerror(errno));
            return -1;
        }
 
        /* If the alert pipe has data that means there are events waiting */
        if (pfds[1].revents) {
            /* If the session has been kicked go no further */
            if (s->session->kicked) {
                ast_debug(1, "Manager session has been kicked\n");
                return -1;
            }
 
            ast_alertpipe_read(s->session->alert_pipe);
            break;
        }
 
        /* If any data came from the TCP connection break now or else poll will return immediately */
        if (pfds[0].revents) {
            break;
        }
    }
 
    ast_debug(1, "Finished waiting for an event!\n");
 
    /* To reduce contention we lock only long enough to steal the events */
    ast_mutex_lock(&s->session->pending_events_lock);
    events_count = AST_VECTOR_SIZE(&s->session->pending_events);
    events = AST_VECTOR_STEAL_ELEMENTS(&s->session->pending_events);
    ast_mutex_unlock(&s->session->pending_events_lock);
 
    ao2_lock(s->session);
    astman_send_response(s, m, "Success", "Waiting for Event completed.");
 
    for (x = 0; x < events_count; x++) {
        struct eventqent *eqe = events[x];
 
        if (((s->session->send_events & eqe->category) == eqe->category) &&
            should_send_event(s->session->includefilters, s->session->excludefilters, eqe)) {
            astman_append(s, "%s", ast_str_buffer(eqe->message));
        }
 
        ao2_ref(eqe, -1);
    }
 
    astman_append(s,
        "Event: WaitEventComplete\r\n"
        "%s"
        "\r\n", id);
    ao2_unlock(s->session);
 
    ast_free(events);
 
    return 0;
}

References mansession_session::alert_pipe, ao2_lock, ao2_ref, ao2_unlock, ast_alertpipe_read(), ast_alertpipe_readfd(), ast_debug, ast_free, ast_iostream_get_fd(), ast_log, ast_mutex_lock, ast_mutex_unlock, ast_poll, ast_str_buffer(), AST_VECTOR_SIZE, AST_VECTOR_STEAL_ELEMENTS, astman_append(), astman_send_response(), eventqent::category, errno, events, mansession_session::excludefilters, mansession_session::includefilters, mansession_session::kicked, LOG_WARNING, eventqent::message, mansession_session::pending_events, mansession_session::pending_events_lock, mansession_session::send_events, mansession::session, should_send_event(), and mansession_session::stream.

Referenced by action_waitevent().

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

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

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

Referenced by action_aoc_de_message().

app_match()

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

static

Definition at line 5057 of file manager.c.

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

References app, and strcasestr().

appdata_match()

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

static

Definition at line 5076 of file manager.c.

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

References ast_strlen_zero().

append_channel_vars()

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

static

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

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 1699 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, 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 794 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 683 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 446 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 441 of file manager.c.

{
    return manager_topic;
}

References manager_topic.

Referenced by aoc_publish_blob(), ast_manager_publish_event(), endpoint_state_cb(), load_module(), load_module(), load_module(), load_module(), load_module(), manager_bridging_init(), manager_channels_init(), manager_mwi_init(), manager_system_init(), 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 3469 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 637 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 7908 of file manager.c.

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

References manager_action::action, action_destroy(), ao2_t_alloc, ao2_t_ref, ast_free, ast_manager_register_struct(), AST_STATIC_DOC, ast_string_field_init, ast_string_field_init_extended, ast_string_field_set, ast_strlen_zero(), AST_XML_DOC, ast_xmldoc_build_arguments(), ast_xmldoc_build_description(), ast_xmldoc_build_final_response(), ast_xmldoc_build_list_responses(), ast_xmldoc_build_provided_by(), ast_xmldoc_build_seealso(), ast_xmldoc_build_since(), ast_xmldoc_build_synopsis(), ast_xmldoc_build_syntax(), manager_action::authority, manager_action::docsrc, manager_action::final_response, manager_action::func, manager_action::list_responses, 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 668 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 7853 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 542 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 7782 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(), __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(), extension_state_cleanup(), load_module(), load_module(), local_shutdown(), manager_bridging_cleanup(), manager_shutdown(), message_shutdown(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), 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 676 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(), unload_module(), and unregister_hook().

AST_THREADSTORAGE_CUSTOM_SCOPE() [1/2]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	astman_append_buf	,
		NULL	,
		ast_free_ptr	,
		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.

AST_THREADSTORAGE_CUSTOM_SCOPE() [2/2]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	userevent_buf	,
		NULL	,
		ast_free_ptr	,
		static
	)

ast_webmanager_check_enabled()

int ast_webmanager_check_enabled

(

void

)

Check if AMI/HTTP is enabled.

Definition at line 688 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 1842 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_INITSIZE, buf, mansession::hook, NULL, send_string(), ast_iostream::start, 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_http(), action_waitevent_tcp(), ami_maint_entry_cb(), ami_outbound_registration_task(), ami_registrations_aor(), ami_show_maintenance(), 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 1592 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 2587 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 1830 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 1606 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 1582 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_sendtext(), action_setvar(), action_status(), action_timeout(), action_transfer(), action_transferhangup(), action_updateconfig(), action_userevent(), action_waitevent(), ami_register(), ami_set_maintenance(), ami_show_aors(), ami_show_auths(), ami_show_contacts(), ami_show_endpoint(), ami_show_endpoints(), ami_show_maintenance(), 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 1668 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 1673 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 2394 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 1953 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_set_maintenance(), 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 1921 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_set_maintenance(), 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 1926 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_INITSIZE, astman_send_response_full(), buf, and NULL.

Referenced by action_command(), action_originate(), action_presencestate(), ami_set_maintenance(), 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 1990 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 2007 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_maintenance(), 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 1999 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_maintenance(), 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 1968 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_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 1963 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_maintenance(), 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 1916 of file manager.c.

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

References astman_send_response_full(), and NULL.

Referenced by action_logoff(), action_waitevent_http(), and action_waitevent_tcp().

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 1885 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_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 1958 of file manager.c.

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

References astman_send_response_full(), MSG_MOREDATA, and NULL.

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

async_goto_with_discard_bridge_after()

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

static

Definition at line 3994 of file manager.c.

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

References ast_async_goto(), ast_bridge_discard_after_goto(), and priority.

Referenced by action_redirect().

authenticate()

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

static

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

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

Referenced by action_login().

authority_to_str()

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

static

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

Definition at line 766 of file manager.c.

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

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

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

build_mansession()

static struct mansession_session * build_mansession ( const struct ast_sockaddr *  addr, unsigned int  needs_alert_pipe  )

static

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

Definition at line 934 of file manager.c.

{
    struct ao2_container *sessions;
    struct mansession_session *newsession;
 
    newsession = ao2_alloc(sizeof(*newsession), session_destructor);
    if (!newsession) {
        return NULL;
    }
 
    AST_VECTOR_INIT(&newsession->pending_events, 0);
    ast_alertpipe_clear(newsession->alert_pipe);
    ast_mutex_init(&newsession->pending_events_lock);
    ast_mutex_init(&newsession->http_thread_lock);
    AST_LIST_HEAD_INIT_NOLOCK(&newsession->datastores);
 
    newsession->includefilters = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
    newsession->excludefilters = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
    if (!newsession->includefilters || !newsession->excludefilters) {
        ao2_ref(newsession, -1);
        return NULL;
    }
 
    newsession->http_thread = AST_PTHREADT_NULL;
    newsession->writetimeout = 100;
    newsession->send_events = 0; /* Until authenticated this session will not receive events */
    ast_sockaddr_copy(&newsession->addr, addr);
 
    if (needs_alert_pipe && ast_alertpipe_init(newsession->alert_pipe)) {
        ao2_ref(newsession, -1);
        return NULL;
    }
 
    sessions = ao2_global_obj_ref(mgr_sessions);
    if (sessions) {
        ao2_link(sessions, newsession);
        ao2_ref(sessions, -1);
    }
 
    return newsession;
}

References mansession_session::addr, mansession_session::alert_pipe, ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_list, ao2_global_obj_ref, ao2_link, ao2_ref, ast_alertpipe_clear(), ast_alertpipe_init(), AST_LIST_HEAD_INIT_NOLOCK, ast_mutex_init, AST_PTHREADT_NULL, ast_sockaddr_copy(), AST_VECTOR_INIT, mansession_session::datastores, mansession_session::excludefilters, mansession_session::http_thread, mansession_session::http_thread_lock, mansession_session::includefilters, NULL, mansession_session::pending_events, mansession_session::pending_events_lock, mansession_session::send_events, session_destructor(), sessions, 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 4287 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 996 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 6727 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 6710 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 4431 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 7342 of file manager.c.

{
    struct message m = { 0 };
    char header_buf[sizeof(s->session->inbuf)] = { '\0' };
    int res;
    int hdr_loss;
    time_t now;
    struct pollfd pfds[2];
 
    /* TCP based manager never has the underlying stream change, so we can setup the pollfd once */
    memset(pfds, 0, sizeof(pfds));
    pfds[0].fd = ast_iostream_get_fd(s->session->stream);
    pfds[0].events = POLLIN | POLLPRI;
    pfds[1].fd = ast_alertpipe_readfd(s->session->alert_pipe);
    pfds[1].events = POLLIN | POLLPRI;
 
    hdr_loss = 0;
    for (;;) {
        res = get_input(s, pfds, 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, mansession_session::alert_pipe, ARRAY_LEN, ast_alertpipe_readfd(), ast_iostream_get_fd(), 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_message(), mansession::session, and mansession_session::stream.

Referenced by session_do().

event_filter_destructor()

static void event_filter_destructor ( void *  obj )

static

Definition at line 874 of file manager.c.

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

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

Referenced by manager_add_filter().

eventqent_alloc()

static struct eventqent * eventqent_alloc ( const char *  event_name, int  category  )

static

Allocate a manager event.

Parameters

event_name	The name of the event
category	The category of the event

Returns

non-NULL on success, NULL on failure

Definition at line 7579 of file manager.c.

{
    struct eventqent *event;
 
    event = ao2_alloc_options(sizeof(*event), eventqent_destructor, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!event) {
        return NULL;
    }
 
    event->category = category;
    event->event_name_hash = ast_str_hash(event_name);
 
    /*
     * This event will most likely be queued to at least one session so we do message
     * creation directly inside the event to avoid having to duplicate the string.
     */
    event->message = ast_str_create(MANAGER_EVENT_BUF_INITSIZE);
    if (!event->message) {
        ao2_ref(event, -1);
        return NULL;
    }
 
    return event;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_str_create, ast_str_hash(), eventqent_destructor(), MANAGER_EVENT_BUF_INITSIZE, and NULL.

Referenced by __manager_event_sessions_va().

eventqent_destructor()

static void eventqent_destructor ( void *  obj )

static

Destructor for manager event message.

Parameters

obj	The event message to free

Definition at line 7561 of file manager.c.

{
    struct eventqent *event = obj;
 
    ast_free(event->message);
}

References ast_free.

Referenced by eventqent_alloc().

fast_originate()

static void * fast_originate ( void *  data )

static

Definition at line 4439 of file manager.c.

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

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

Referenced by action_originate().

file_in_modules_dir()

static int file_in_modules_dir ( const char *  filename )

static

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

Note

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

Returns

1 if inside modules dir

0 if outside modules dir

-1 on failure

Definition at line 6943 of file manager.c.

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

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

Referenced by manager_moduleload().

filter_cmp_fn()

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

static

Definition at line 5643 of file manager.c.

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

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

Referenced by should_send_event().

function_capable_string_allowed_with_auths()

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

static

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

Definition at line 728 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 3681 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_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, struct pollfd *  pfds, 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 7217 of file manager.c.

{
    int res = 0, 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;
            }
        }
 
        res = ast_poll(pfds, 2, timeout);
 
        /* If polling resulted in an error, break out of the loop */
        if (res < 0) {
            /* If in reality we were interrupted, iterate again */
            if (errno == EINTR || errno == EAGAIN) {
                continue;
            }
 
            ast_log(LOG_WARNING, "poll() returned error: %s\n", strerror(errno));
            return -1;
        } else if (!res) {
            /* If nothing happened we loop again */
            continue;
        }
 
        if (pfds[1].revents) {
            /* There are pending events to send, or this session has been kicked */
            if (s->session->kicked) {
                ast_debug(1, "Manager session has been kicked\n");
                return -1;
            }
            ast_alertpipe_read(s->session->alert_pipe);
 
            if (process_events(s)) {
                return -1;
            }
        }
 
        if (pfds[0].revents) {
            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;
        }
    }
 
    return 0;
}

References mansession_session::addr, mansession_session::alert_pipe, ao2_lock, ao2_unlock, ast_alertpipe_read(), ast_debug, ast_iostream_read(), ast_log, ast_poll, ast_sockaddr_stringify_addr(), 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::parsing, process_events(), mansession::session, and mansession_session::stream.

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 1019 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, ast_manager_user::list, name, and NULL.

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 813 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().

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 1391 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);
                    session->kicked = 1;
                    ao2_unlock(session);
                    session_notify(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(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, session, session_notify(), 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 1509 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 1208 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 7325 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 1233 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 1306 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, ast_manager_user::list, 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 1054 of file manager.c.

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

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

handle_showmancmds()

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

static

CLI command manager list commands.

Definition at line 1349 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, manager_action::list, 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 1457 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_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 2670 of file manager.c.

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

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

Referenced by action_updateconfig().

is_originate_app_permitted()

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

static

Definition at line 5169 of file manager.c.

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

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

Referenced by action_originate().

is_restricted_file()

static int is_restricted_file ( const char *  filename )

static

Check if a file is restricted or not.

Returns

0 on success

1 on restricted file

-1 on failure

Definition at line 2415 of file manager.c.

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

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

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

json_escape()

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

static

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

Definition at line 2569 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 7050 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 1624 of file manager.c.

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

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

Referenced by astman_get_variables_order().

manager_add_filter()

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

static

Add an event filter to a manager session.

Parameters

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

Returns

FILTER_ALLOC_FAILED Memory allocation failure

FILTER_COMPILE_FAIL If the filter did not compile

FILTER_FORMAT_ERROR If the criteria weren't formatted correctly

FILTER_SUCCESS Success

Examples: See examples in manager.conf.sample

Definition at line 5800 of file manager.c.

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

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

Referenced by __init_manager(), and action_filter().

manager_default_msg_cb()

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

static

Definition at line 559 of file manager.c.

{
    struct ao2_container *sessions = data;
    struct ast_manager_event_blob *ev;
 
    /*
     * This callback only receives messages that can be turned into AMI events, so
     * no need to check that the message can be turned into an event before checking for listeners.
     */
    if (!any_manager_listeners(sessions)) {
        /* Nobody is listening */
        return;
    }
 
    ev = stasis_message_to_ami(message);
    if (!ev) {
        /* Conversion failure */
        return;
    }
 
    manager_event_sessions(sessions, ev->event_flags, ev->manager_event,
        "%s", ev->extra_fields);
    ao2_ref(ev, -1);
}

References any_manager_listeners, ao2_ref, ast_manager_event_blob::event_flags, ast_manager_event_blob::extra_fields, ast_manager_event_blob::manager_event, manager_event_sessions, sessions, 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 1036 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 585 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 = data;
 
    if (!any_manager_listeners(sessions)) {
        /* Nobody is listening */
        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);
        return;
    }
 
    manager_event_sessions(sessions, class_type, type,
        "%s", ast_str_buffer(event_buffer));
    ast_free(event_buffer);
}

References any_manager_listeners, 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 476 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 486 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 501 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 451 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 6904 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 6969 of file manager.c.

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

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

Referenced by __init_manager().

manager_state_cb()

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

static

Definition at line 7812 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(), EVENT_FLAG_CALL, manager_event, and NULL.

Referenced by __init_manager().

manager_subscription_change_msg_cb()

static void manager_subscription_change_msg_cb ( void *  userdata, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

Callback for subscription change messages.

Parameters

userdata	The subscription user data (in our case a pointer to the sessions container)
sub	The subscription
message	The message

Definition at line 622 of file manager.c.

{
    /*
     * When the subscription unsubscribes a final message is sent to the subscription
     * to indicate it. We use this to manage the lifetime of the sessions container
     * pointer stored with the subscription. When the subscription is done we drop
     * the reference to the sessions container (userdata) so it can be cleaned up
     * if needed.
     */
    if (stasis_subscription_final_message(sub, message)) {
        ao2_cleanup(userdata);
    }
}

References ao2_cleanup, stasis_subscription_final_message(), and sub.

Referenced by manager_subscriptions_init().

mansession_cmp_fn()

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

static

Definition at line 976 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 2042 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 2013 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 2019 of file manager.c.

{
    ast_mutex_unlock(&s->lock);
}

References ast_mutex_unlock, and mansession::lock.

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

match_eventdata()

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

static

Test eventdata against a filter entry.

Parameters

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

Return values

0	if no match
1	if match

Definition at line 5623 of file manager.c.

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

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

Referenced by filter_cmp_fn().

print_event_instance()

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

static

Definition at line 9358 of file manager.c.

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

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

Referenced by handle_manager_show_event(), and handle_showmancmd().

process_events()

static int process_events ( struct mansession *  s )

static

Send any pending events to the client listening on this socket.

Parameters

s	The manager session to send events for.

Definition at line 6459 of file manager.c.

{
    int ret = 0;
    size_t events_count;
    struct eventqent **events;
    int i;
 
    ao2_lock(s->session);
 
    if (!s->session->stream) {
        ao2_unlock(s->session);
        return 0;
    }
 
    /* To reduce contention we lock only long enough to steal the events */
    ast_mutex_lock(&s->session->pending_events_lock);
    events_count = AST_VECTOR_SIZE(&s->session->pending_events);
    events = AST_VECTOR_STEAL_ELEMENTS(&s->session->pending_events);
    ast_mutex_unlock(&s->session->pending_events_lock);
 
    for (i = 0; i < events_count; i++) {
        struct eventqent *eqe = events[i];
 
        if (eqe->category == EVENT_FLAG_SHUTDOWN) {
            ast_debug(3, "Received CloseSession event\n");
            ret = -1;
            /* We purposely don't break here so that we drop the reference on remaining events */
        }
 
        if (!ret && ((s->session->send_events & eqe->category) == eqe->category) &&
            should_send_event(s->session->includefilters, s->session->excludefilters, eqe) &&
            (send_string(s, ast_str_buffer(eqe->message)) < 0 || s->write_error)) {
            ret = -1;   /* don't send more */
        }
 
        ao2_ref(eqe, -1);
    }
 
    ao2_unlock(s->session);
 
    ast_free(events);
 
    return ret;
}

References ao2_lock, ao2_ref, ao2_unlock, ast_debug, ast_free, ast_mutex_lock, ast_mutex_unlock, ast_str_buffer(), AST_VECTOR_SIZE, AST_VECTOR_STEAL_ELEMENTS, eventqent::category, EVENT_FLAG_SHUTDOWN, events, mansession_session::excludefilters, mansession_session::includefilters, eventqent::message, mansession_session::pending_events, mansession_session::pending_events_lock, mansession_session::send_events, send_string(), mansession::session, should_send_event(), mansession_session::stream, and mansession::write_error.

Referenced by get_input(), 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 7089 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(), 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_sessions()

static int purge_sessions ( int  n_max )

static

remove at most n_max stale session from the list.

Definition at line 7518 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);
 
    /* The order of operations is significant */
    while (n_max > 0 && (session = ao2_iterator_next(&i))) {
        ao2_lock(session);
        if (session->sessiontimeout && (now > session->sessiontimeout) && !session->inuse) {
            if (session->authenticated
                && VERBOSITY_ATLEAST(2)
                && manager_displayconnects(session)) {
                ast_verb(2, "HTTP Manager '%s' timed out from %s\n",
                    session->username, ast_sockaddr_stringify_addr(&session->addr));
            }
            ao2_unlock(session);
            session_destroy(session);
            n_max--;
            purged++;
        } else {
            ao2_unlock(session);
            unref_mansession(session);
        }
    }
    ao2_iterator_destroy(&i);
    return purged;
}

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

Referenced by purge_old_stuff().

queue_match()

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

static

Definition at line 5096 of file manager.c.

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

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

queue_read_action_payload()

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

static

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

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

Parameters

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

Return values

-1	on error
0	on success

Definition at line 3884 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 3917 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 3933 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 10185 of file manager.c.

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

References __init_manager(), AST_MODULE_LOAD_FAILURE, and AST_MODULE_LOAD_SUCCESS.

Referenced by handle_manager_reload().

report_auth_success()

static void report_auth_success ( const struct mansession *  s )

static

Definition at line 2123 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 2073 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 2206 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 2098 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 2048 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 2177 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 2148 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 2236 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_security_event_session_limit::common, ast_security_event_common::event_type, ast_tcptls_session_args::local_address, mansession_get_transport(), ast_tcptls_session_instance::parent, mansession::session, session_limit, mansession_session::sessionstart_tv, mansession::tcptls_session, and mansession_session::username.

Referenced by process_message().

send_string()

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

static

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

Definition at line 1787 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, ast_iostream::start, 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 983 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 901 of file manager.c.

{
    struct mansession_session *session = obj;
    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 (session->chanvars) {
        ast_variables_destroy(session->chanvars);
    }
 
    if (session->includefilters) {
        ao2_t_ref(session->includefilters, -1, "decrement ref for include container, should be last one");
    }
 
    if (session->excludefilters) {
        ao2_t_ref(session->excludefilters, -1, "decrement ref for exclude container, should be last one");
    }
 
    AST_VECTOR_CALLBACK_VOID(&session->pending_events, ao2_cleanup);
    AST_VECTOR_FREE(&session->pending_events);
    ast_mutex_destroy(&session->http_thread_lock);
    ast_mutex_destroy(&session->pending_events_lock);
 
    /* On initialization the alert pipe is set to -1, ensuring it is safe to call close */
    ast_alertpipe_close(session->alert_pipe);
}

References ao2_cleanup, ao2_t_ref, ast_alertpipe_close(), ast_datastore_free(), AST_LIST_REMOVE_HEAD, ast_mutex_destroy, ast_variables_destroy(), AST_VECTOR_CALLBACK_VOID, AST_VECTOR_FREE, ast_datastore::entry, and session.

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 7430 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;
 
    /* If this session would exceed the auth limit, reject it immediately */
    if (ast_atomic_fetchadd_int(&unauth_sessions, +1) >= authlimit) {
        ast_atomic_fetchadd_int(&unauth_sessions, -1);
        goto done;
    }
 
    session = build_mansession(&ser->remote_address, 1);
    if (!session) {
        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);
 
    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);
    s.session = session;
 
    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_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, 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.

session_notify()

static void session_notify ( struct mansession_session *  session )

static

Definition at line 886 of file manager.c.

{
    if (!session->managerid) {
        /* TCP based connections are easy and use an alert pipe, which requires no locking */
        ast_alertpipe_write(session->alert_pipe);
    } else {
        /* HTTP based connections require locking as multiple HTTP connections can end up using the same session */
        ast_mutex_lock(&session->http_thread_lock);
        if (session->http_thread != AST_PTHREADT_NULL) {
            pthread_kill(session->http_thread, SIGURG);
        }
        ast_mutex_unlock(&session->http_thread_lock);
    }
}

References ast_alertpipe_write(), ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, and session.

Referenced by __manager_event_sessions_va(), and handle_kickmanconn().

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

{
    int maskint = strings_to_mask(eventmask);
 
    ao2_lock(s->session);
    /* Limit what event categories are sent to the client based on read permissions */
    if (maskint >= 0) {
        s->session->send_events = s->session->readperm & maskint;
    }
    ao2_unlock(s->session);
 
    return maskint;
}

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

Referenced by action_events(), and authenticate().

should_send_event()

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

static

Definition at line 5696 of file manager.c.

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

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

Referenced by action_waitevent_http(), action_waitevent_tcp(), and process_events().

STASIS_MESSAGE_TYPE_DEFN()

STASIS_MESSAGE_TYPE_DEFN

(

ast_manager_get_generic_type

)

Define AMI message types.

strings_to_mask()

static int strings_to_mask ( const char *  string )

static

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

Definition at line 834 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 865 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 742 of file manager.c.

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

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

Referenced by handle_showmanager().

Variable Documentation

acl_change_sub

struct stasis_subscription* acl_change_sub

static

Definition at line 167 of file manager.c.

Referenced by acl_change_stasis_subscribe(), and acl_change_stasis_unsubscribe().

actions

struct actions actions = AST_RWLIST_HEAD_INIT_VALUE

static

allowmultiplelogin

int allowmultiplelogin = 1

static

Definition at line 150 of file manager.c.

Referenced by __init_manager(), and handle_manager_show_settings().

authlimit

int authlimit

static

Definition at line 159 of file manager.c.

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

authtimeout

int authtimeout

static

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

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

[struct]

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

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

httptimeout

int httptimeout = 60

static

Definition at line 152 of file manager.c.

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

live_dangerously

int live_dangerously

static

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

Definition at line 184 of file manager.c.

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

manager_channelvars

char* manager_channelvars

static

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

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

manager_disabledevents

char* manager_disabledevents

static

Definition at line 161 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 154 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_hooks

struct manager_hooks manager_hooks = AST_RWLIST_HEAD_INIT_VALUE

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

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

match_type_names

char* match_type_names[]

static

Definition at line 385 of file manager.c.

                                  {
    [FILTER_MATCH_REGEX] = "regex",
    [FILTER_MATCH_EXACT] = "exact",
    [FILTER_MATCH_STARTS_WITH] = "starts_with",
    [FILTER_MATCH_ENDS_WITH] = "ends_with",
    [FILTER_MATCH_CONTAINS] = "contains",
    [FILTER_MATCH_NONE] = "none",
};

Referenced by manager_add_filter().

originate_app_permissions

struct originate_permissions_entry originate_app_permissions[]

static

Definition at line 5133 of file manager.c.

                                                                        {
    /*
     * The app_match function checks if the search string is
     * anywhere in the app parameter.  The check is case-insensitive.
     */
    { "agi", EVENT_FLAG_SYSTEM, app_match },
    { "dbdeltree", EVENT_FLAG_SYSTEM, app_match },
    { "exec", EVENT_FLAG_SYSTEM, app_match },
    { "externalivr", EVENT_FLAG_SYSTEM, app_match },
    { "mixmonitor", EVENT_FLAG_SYSTEM, app_match },
    { "originate", EVENT_FLAG_SYSTEM, app_match },
    { "reload", EVENT_FLAG_SYSTEM, app_match },
    { "system", EVENT_FLAG_SYSTEM, app_match },
    /*
     * Since the queue_match function specifically checks
     * for the presence of the AGI parameter, we'll allow
     * the call if the user has either the AGI or SYSTEM
     * permission.
     */
    { "queue", EVENT_FLAG_AGI | EVENT_FLAG_SYSTEM, queue_match },
    /*
     * The appdata_match function checks if the search string is
     * anywhere in the appdata parameter.  Unlike app_match,
     * the check is case-sensitive.  These are generally
     * dialplan functions.
     */
    { "CURL", EVENT_FLAG_SYSTEM, appdata_match },
    { "DB", EVENT_FLAG_SYSTEM, appdata_match },
    { "EVAL", EVENT_FLAG_SYSTEM, appdata_match },
    { "FILE", EVENT_FLAG_SYSTEM, appdata_match },
    { "ODBC", EVENT_FLAG_SYSTEM, appdata_match },
    { "REALTIME", EVENT_FLAG_SYSTEM, appdata_match },
    { "SHELL", EVENT_FLAG_SYSTEM, appdata_match },
    { NULL, 0 },
};

Referenced by is_originate_app_permitted().

perms

const struct permalias perms[]

static

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

rtp_topic_forwarder

struct stasis_forward* rtp_topic_forwarder

static

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

Definition at line 176 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 179 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 173 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 155 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 151 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 166 of file manager.c.

Referenced by action_login(), and session_do().

users

struct users users = AST_RWLIST_HEAD_INIT_VALUE

static

webmanager_enabled

int webmanager_enabled = 0

static

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