AMI functions

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

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

Enumerations
enum	add_filter_result { FILTER_SUCCESS , FILTER_ALLOC_FAILED , FILTER_COMPILE_FAIL }
enum	error_type {   UNKNOWN_ACTION = 1 , UNKNOWN_CATEGORY , UNSPECIFIED_CATEGORY , UNSPECIFIED_ARGUMENT ,   FAILURE_ALLOCATION , FAILURE_NEWCAT , FAILURE_DELCAT , FAILURE_EMPTYCAT ,   FAILURE_UPDATE , FAILURE_DELETE , FAILURE_APPEND , FAILURE_TEMPLATE }
enum	mansession_message_parsing { MESSAGE_OKAY , MESSAGE_LINE_TOO_LONG }

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

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

Detailed Description

Macro Definition Documentation

any_manager_listeners

#define any_manager_listeners

(

sessions

)

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

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

DEFAULT_REALM

#define DEFAULT_REALM   "asterisk"

Definition at line 1483 of file manager.c.

EVENT_FLAG_SHUTDOWN

#define EVENT_FLAG_SHUTDOWN   -1

Fake event class used to end sessions at shutdown.

Definition at line 1511 of file manager.c.

GET_HEADER_FIRST_MATCH

#define GET_HEADER_FIRST_MATCH   0

Definition at line 2766 of file manager.c.

GET_HEADER_LAST_MATCH

#define GET_HEADER_LAST_MATCH   1

Definition at line 2767 of file manager.c.

GET_HEADER_SKIP_EMPTY

#define GET_HEADER_SKIP_EMPTY   2

Definition at line 2768 of file manager.c.

MANAGER_EVENT_BUF_INITSIZE

#define MANAGER_EVENT_BUF_INITSIZE   256

Definition at line 7110 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 1832 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 2043 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 1523 of file manager.c.

MAX_VARS

#define MAX_VARS   128

Definition at line 1508 of file manager.c.

MGR_SHOW_TERMINAL_WIDTH

#define MGR_SHOW_TERMINAL_WIDTH   80

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

Enumeration Type Documentation

add_filter_result

enum add_filter_result

Enumerator
FILTER_SUCCESS
FILTER_ALLOC_FAILED
FILTER_COMPILE_FAIL

Definition at line 1434 of file manager.c.

                       {
   FILTER_SUCCESS,
   FILTER_ALLOC_FAILED,
   FILTER_COMPILE_FAIL,
};

error_type

enum error_type

Doxygen group

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

Definition at line 1419 of file manager.c.

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

mansession_message_parsing

enum mansession_message_parsing

Enumerator
MESSAGE_OKAY
MESSAGE_LINE_TOO_LONG

Definition at line 1615 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 7233 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, and make_ari_stubs::file.

__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 2783 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 astman_get_header(), and process_message().

__init_astman_append_buf()

static void __init_astman_append_buf ( void  )

static

thread local buffer for astman_append

Note

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

Definition at line 3061 of file manager.c.

{

__init_manager_event_buf()

static void __init_manager_event_buf ( void  )

static

Definition at line 7109 of file manager.c.

{

__init_userevent_buf()

static void __init_userevent_buf ( void  )

static

Definition at line 3063 of file manager.c.

{

__manager_event_sessions()

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

static

Definition at line 7211 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, and make_ari_stubs::file.

__manager_event_sessions_va()

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

static

Definition at line 7112 of file manager.c.

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

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, append_channel_vars(), append_event(), ast_atomic_fetchadd_int(), ast_config_AST_SYSTEM_NAME, ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, AST_RWLIST_EMPTY, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_str_alloca, ast_str_append(), ast_str_append_va(), ast_str_buffer(), ast_str_set(), ast_str_thread_get(), ast_strlen_zero(), ast_tvnow(), authority_to_str(), buf, chancount, EVENT_FLAG_SHUTDOWN, make_ari_stubs::file, manager_custom_hook::helper, manager_debug, manager_event_buf, MANAGER_EVENT_BUF_INITSIZE, MAX_AUTH_PERM_STRING, seq, session, 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 9638 of file manager.c.

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

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

Referenced by acl_change_stasis_subscribe().

acl_change_stasis_subscribe()

static void acl_change_stasis_subscribe ( void  )

static

Definition at line 1534 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 1544 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_aocmessage()

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

static

Definition at line 5518 of file manager.c.

{
   const char *channel = astman_get_header(m, "Channel");
   const char *pchannel = astman_get_header(m, "ChannelPrefix");
   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_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 (ast_strlen_zero(msgtype) || (strcasecmp(msgtype, "d") && strcasecmp(msgtype, "e"))) {
      astman_send_error(s, m, "Invalid MsgType");
      goto aocmessage_cleanup;
   }
 
   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);
 
 
   if ((encoded = ast_aoc_encode(decoded, &encoded_size, NULL)) && !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 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_destroy_encoded(), AST_AOC_E, ast_aoc_encode(), 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_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 5164 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(), context, digit, exten, name, NULL, and pbx_builtin_setvar_helper().

Referenced by __init_manager().

action_blind_transfer()

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

static

Definition at line 5118 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(), context, exten, 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 5218 of file manager.c.

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

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

Referenced by __init_manager().

action_challenge()

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

static

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

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

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

Referenced by __init_manager().

action_coresettings()

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

static

Show PBX core settings information.

Definition at line 6276 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"
         "\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())
         );
   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_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_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 6390 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 6318 of file manager.c.

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

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

Referenced by __init_manager().

action_createconfig()

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

static

Definition at line 4188 of file manager.c.

{
   int fd;
   const char *fn = astman_get_header(m, "Filename");
   struct ast_str *filepath = ast_str_alloca(PATH_MAX);
   ast_str_set(&filepath, 0, "%s/", ast_config_AST_CONFIG_DIR);
   ast_str_append(&filepath, 0, "%s", fn);
 
   if ((fd = open(ast_str_buffer(filepath), O_CREAT | O_EXCL, AST_FILE_MODE)) != -1) {
      close(fd);
      astman_send_ack(s, m, "New configuration file created successfully");
   } else {
      astman_send_error(s, m, strerror(errno));
   }
 
   return 0;
}

References ast_config_AST_CONFIG_DIR, AST_FILE_MODE, ast_str_alloca, ast_str_append(), ast_str_buffer(), ast_str_set(), astman_get_header(), astman_send_ack(), astman_send_error(), errno, and PATH_MAX.

Referenced by __init_manager().

action_destroy()

static void action_destroy ( void *  obj )

static

Definition at line 7372 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 4343 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 5974 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(), context, exten, 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 6111 of file manager.c.

{
   const char *filter = astman_get_header(m, "Filter");
   const char *operation = astman_get_header(m, "Operation");
   int res;
 
   if (!strcasecmp(operation, "Add")) {
      res = manager_add_filter(filter, s->session->whitefilters, s->session->blackfilters);
 
           if (res != FILTER_SUCCESS) {
              if (res == FILTER_ALLOC_FAILED) {
            astman_send_error(s, m, "Internal Error. Failed to allocate regex for filter");
                      return 0;
              } else if (res == FILTER_COMPILE_FAIL) {
            astman_send_error(s, m, "Filter did not compile.  Check the syntax of the filter given.");
                      return 0;
              } else {
            astman_send_error(s, m, "Internal Error. Failed adding filter.");
                      return 0;
                   }
      }
 
      astman_send_ack(s, m, "Success");
      return 0;
   }
 
   astman_send_error(s, m, "Unknown operation");
   return 0;
}

References astman_get_header(), astman_send_ack(), astman_send_error(), mansession_session::blackfilters, filter(), FILTER_ALLOC_FAILED, FILTER_COMPILE_FAIL, FILTER_SUCCESS, manager_add_filter(), mansession::session, and mansession_session::whitefilters.

Referenced by __init_manager().

action_find()

static struct manager_action* action_find ( const char *  name )

static

Definition at line 1704 of file manager.c.

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

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

Referenced by ast_hook_send_action(), and process_message().

action_getconfig()

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

static

Definition at line 3620 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;
   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;
   }
 
   cfg = ast_config_load2(fn, "manager", config_flags);
   if (cfg == CONFIG_STATUS_FILEMISSING) {
      astman_send_error(s, m, "Config file not found");
      return 0;
   } else if (cfg == CONFIG_STATUS_FILEINVALID) {
      astman_send_error(s, m, "Config file has invalid format");
      return 0;
   }
 
   astman_start_ack(s, m);
   while ((cur_category = ast_category_browse_filtered(cfg, category, cur_category, filter))) {
      struct ast_str *templates;
 
      category_name = ast_category_get_name(cur_category);
      lineno = 0;
      astman_append(s, "Category-%06d: %s\r\n", catcount, category_name);
 
      if (ast_category_is_template(cur_category)) {
         astman_append(s, "IsTemplate-%06d: %d\r\n", catcount, 1);
      }
 
      if ((templates = ast_category_get_templates(cur_category))
         && ast_str_strlen(templates) > 0) {
         astman_append(s, "Templates-%06d: %s\r\n", catcount, ast_str_buffer(templates));
         ast_free(templates);
      }
 
      for (v = ast_category_first(cur_category); v; v = v->next) {
         astman_append(s, "Line-%06d-%06d: %s=%s\r\n", catcount, lineno++, v->name, v->value);
      }
 
      catcount++;
   }
 
   if (!ast_strlen_zero(category) && catcount == 0) { /* TODO: actually, a config with no categories doesn't even get loaded */
      astman_append(s, "No categories found\r\n");
   }
 
   ast_config_destroy(cfg);
   astman_append(s, "\r\n");
 
   return 0;
}

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

Referenced by __init_manager().

action_getconfigjson()

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

static

Definition at line 3750 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 (!(cfg = ast_config_load2(fn, "manager", config_flags))) {
      astman_send_error(s, m, "Config file not found");
      return 0;
   } else if (cfg == CONFIG_STATUS_FILEINVALID) {
      astman_send_error(s, m, "Config file has invalid format");
      return 0;
   }
 
   astman_start_ack(s, m);
   astman_append(s, "JSON: {");
   while ((cur_category = ast_category_browse_filtered(cfg, category, cur_category, filter))) {
      int comma2 = 0;
      struct ast_str *templates;
 
      category_name = ast_category_get_name(cur_category);
      astman_append(s, "%s\"", comma1 ? "," : "");
      astman_append_json(s, category_name);
      astman_append(s, "\":{");
      comma1 = 1;
 
      if (ast_category_is_template(cur_category)) {
         astman_append(s, "\"istemplate\":1");
         comma2 = 1;
      }
 
      if ((templates = ast_category_get_templates(cur_category))
         && ast_str_strlen(templates) > 0) {
         astman_append(s, "%s", comma2 ? "," : "");
         astman_append(s, "\"templates\":\"%s\"", ast_str_buffer(templates));
         ast_free(templates);
         comma2 = 1;
      }
 
      for (v = ast_category_first(cur_category); v; v = v->next) {
         astman_append(s, "%s\"", comma2 ? "," : "");
         astman_append_json(s, v->name);
         astman_append(s, "\":\"");
         astman_append_json(s, v->value);
         astman_append(s, "\"");
         comma2 = 1;
      }
 
      astman_append(s, "}");
   }
   astman_append(s, "}\r\n\r\n");
 
   ast_config_destroy(cfg);
 
   return 0;
}

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

Referenced by __init_manager().

action_getvar()

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

static

Definition at line 4610 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 4460 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 (!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));
 
      ast_channel_softhangup_withcause_locked(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));
 
         ast_channel_softhangup_withcause_locked(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_softhangup_withcause_locked(), 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 __init_manager().

action_listcategories()

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

static

Definition at line 3682 of file manager.c.

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

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

Referenced by __init_manager().

action_listcommands()

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

static

Definition at line 4324 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 6458 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 4393 of file manager.c.

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

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

Referenced by __init_manager().

action_logoff()

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

static

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

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

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

Referenced by __init_manager().

action_mailboxstatus()

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

static

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

Referenced by __init_manager().

action_originate()

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

static

Definition at line 5723 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"),
   };
   struct ast_variable *vars = NULL;
   char *tech, *data;
   char *l = NULL, *n = NULL;
   int pi = 0;
   int res;
   int to = 30000;
   int reason = 0;
   char tmp[256];
   char tmp2[256];
   struct ast_format_cap *cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
   pthread_t th;
   int bridge_early = 0;
 
   if (!cap) {
      astman_send_error(s, m, "Internal Error. Memory allocation failure.");
      return 0;
   }
   ast_format_cap_append(cap, ast_format_slin, 0);
 
   if ((assignedids.uniqueid && AST_MAX_PUBLIC_UNIQUEID < strlen(assignedids.uniqueid))
      || (assignedids.uniqueid2 && AST_MAX_PUBLIC_UNIQUEID < strlen(assignedids.uniqueid2))) {
      astman_send_error_va(s, m, "Uniqueid length exceeds maximum of %d\n",
         AST_MAX_PUBLIC_UNIQUEID);
      res = 0;
      goto fast_orig_cleanup;
   }
 
   if (ast_strlen_zero(name)) {
      astman_send_error(s, m, "Channel not specified");
      res = 0;
      goto fast_orig_cleanup;
   }
   if (!ast_strlen_zero(priority) && (sscanf(priority, "%30d", &pi) != 1)) {
      if ((pi = ast_findlabel_extension(NULL, context, exten, priority, NULL)) < 1) {
         astman_send_error(s, m, "Invalid priority");
         res = 0;
         goto fast_orig_cleanup;
      }
   }
   if (!ast_strlen_zero(timeout) && (sscanf(timeout, "%30d", &to) != 1)) {
      astman_send_error(s, m, "Invalid timeout");
      res = 0;
      goto fast_orig_cleanup;
   }
   ast_copy_string(tmp, name, sizeof(tmp));
   tech = tmp;
   data = strchr(tmp, '/');
   if (!data) {
      astman_send_error(s, m, "Invalid channel");
      res = 0;
      goto fast_orig_cleanup;
   }
   *data++ = '\0';
   ast_copy_string(tmp2, callerid, sizeof(tmp2));
   ast_callerid_parse(tmp2, &n, &l);
   if (n) {
      if (ast_strlen_zero(n)) {
         n = NULL;
      }
   }
   if (l) {
      ast_shrink_phone_number(l);
      if (ast_strlen_zero(l)) {
         l = NULL;
      }
   }
   if (!ast_strlen_zero(codecs)) {
      ast_format_cap_remove_by_type(cap, AST_MEDIA_TYPE_UNKNOWN);
      ast_format_cap_update_by_allow_disallow(cap, codecs, 1);
   }
 
   if (!ast_strlen_zero(app) && s->session) {
      int bad_appdata = 0;
      /* To run the System application (or anything else that goes to
       * shell), you must have the additional System privilege */
      if (!(s->session->writeperm & EVENT_FLAG_SYSTEM)
         && (
            strcasestr(app, "system") ||      /* System(rm -rf /)
                                                 TrySystem(rm -rf /)       */
            strcasestr(app, "exec") ||        /* Exec(System(rm -rf /))
                                                 TryExec(System(rm -rf /)) */
            strcasestr(app, "agi") ||         /* AGI(/bin/rm,-rf /)
                                                 EAGI(/bin/rm,-rf /)       */
            strcasestr(app, "mixmonitor") ||  /* MixMonitor(blah,,rm -rf)  */
            strcasestr(app, "externalivr") || /* ExternalIVR(rm -rf)       */
            strcasestr(app, "originate") ||   /* Originate(Local/1234,app,System,rm -rf) */
            (strstr(appdata, "SHELL") && (bad_appdata = 1)) ||       /* NoOp(${SHELL(rm -rf /)})  */
            (strstr(appdata, "EVAL") && (bad_appdata = 1))           /* NoOp(${EVAL(${some_var_containing_SHELL})}) */
            )) {
         char error_buf[64];
         snprintf(error_buf, sizeof(error_buf), "Originate Access Forbidden: %s", bad_appdata ? "Data" : "Application");
         astman_send_error(s, m, error_buf);
         res = 0;
         goto fast_orig_cleanup;
      }
   }
 
   /* Check early if the extension exists. If not, we need to bail out here. */
   if (exten && context && pi) {
      if (! ast_exists_extension(NULL, context, exten, pi, l)) {
         /* The extension does not exist. */
         astman_send_error(s, m, "Extension does not exist.");
         res = 0;
         goto fast_orig_cleanup;
      }
   }
 
   /* Allocate requested channel variables */
   vars = astman_get_variables(m);
   if (s->session && s->session->chanvars) {
      struct ast_variable *v, *old;
      old = vars;
      vars = NULL;
 
      /* The variables in the AMI originate action are appended at the end of the list, to override any user variables that apply*/
 
      vars = ast_variables_dup(s->session->chanvars);
      if (old) {
         for (v = vars; v->next; v = v->next );
         if (v->next) {
            v->next = old; /* Append originate variables at end of list */
         }
      }
   }
 
   /* For originate async - we can bridge in early media stage */
   bridge_early = ast_true(early_media);
 
   if (ast_true(async)) {
      struct fast_originate_helper *fast;
 
      fast = ast_calloc(1, sizeof(*fast));
      if (!fast || ast_string_field_init(fast, 252)) {
         ast_free(fast);
         ast_variables_destroy(vars);
         res = -1;
      } else {
         if (!ast_strlen_zero(id)) {
            ast_string_field_build(fast, idtext, "ActionID: %s\r\n", id);
         }
         ast_string_field_set(fast, tech, tech);
         ast_string_field_set(fast, data, data);
         ast_string_field_set(fast, app, app);
         ast_string_field_set(fast, appdata, appdata);
         ast_string_field_set(fast, cid_num, l);
         ast_string_field_set(fast, cid_name, n);
         ast_string_field_set(fast, context, context);
         ast_string_field_set(fast, exten, exten);
         ast_string_field_set(fast, account, account);
         ast_string_field_set(fast, channelid, assignedids.uniqueid);
         ast_string_field_set(fast, otherchannelid, assignedids.uniqueid2);
         fast->vars = vars;
         fast->cap = cap;
         cap = NULL; /* transfered originate helper the capabilities structure.  It is now responsible for freeing it. */
         fast->timeout = to;
         fast->early_media = bridge_early;
         fast->priority = pi;
         if (ast_pthread_create_detached(&th, NULL, fast_originate, fast)) {
            destroy_fast_originate_helper(fast);
            res = -1;
         } else {
            res = 0;
         }
      }
   } else if (!ast_strlen_zero(app)) {
      res = ast_pbx_outgoing_app(tech, cap, data, to, app, appdata, &reason,
            AST_OUTGOING_WAIT, l, n, vars, account, NULL,
            assignedids.uniqueid ? &assignedids : NULL);
      ast_variables_destroy(vars);
   } else {
      if (exten && context && pi) {
         res = ast_pbx_outgoing_exten(tech, cap, data, to,
               context, exten, pi, &reason, AST_OUTGOING_WAIT,
               l, n, vars, account, NULL, bridge_early,
               assignedids.uniqueid ? &assignedids : NULL);
         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(), 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, cid_name, cid_num, codecs, context, destroy_fast_originate_helper(), fast_originate_helper::early_media, EVENT_FLAG_SYSTEM, exten, fast_originate(), name, ast_variable::next, NULL, priority, fast_originate_helper::priority, mansession::session, strcasestr(), fast_originate_helper::timeout, tmp(), ast_assigned_ids::uniqueid, ast_assigned_ids::uniqueid2, fast_originate_helper::vars, and mansession_session::writeperm.

Referenced by __init_manager().

action_ping()

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

static

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

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

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

Referenced by __init_manager().

action_redirect()

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

static

action_redirect: The redirect manager command

Definition at line 4973 of file manager.c.

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

References ast_async_goto(), ast_channel_clear_flag(), ast_channel_flags(), ast_channel_get_by_name(), ast_channel_is_bridged(), ast_channel_lock, ast_channel_unlock, ast_channel_unref, ast_check_hangup_locked(), ast_findlabel_extension(), AST_FLAG_BRIDGE_DUAL_REDIRECT_WAIT, ast_set_flag, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), buf, context, exten, 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 6358 of file manager.c.

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

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

Referenced by __init_manager().

action_sendtext()

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

static

Definition at line 4930 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 4577 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 4777 of file manager.c.

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

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

Referenced by __init_manager().

action_timeout()

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

static

Definition at line 6044 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 4102 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 (!(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)) {
            rld = NULL;
         }
         ast_module_reload(rld);
      }
   } 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_include_rename(), ast_module_reload(), ast_strlen_zero(), ast_true(), astman_get_header(), astman_send_ack(), astman_send_error(), CONFIG_FLAG_NOCACHE, CONFIG_FLAG_WITHCOMMENTS, CONFIG_SAVE_FLAG_NONE, CONFIG_SAVE_FLAG_PRESERVE_EFFECTIVE_CONTEXT, CONFIG_STATUS_FILEINVALID, FAILURE_ALLOCATION, FAILURE_APPEND, FAILURE_DELCAT, FAILURE_DELETE, FAILURE_EMPTYCAT, FAILURE_NEWCAT, FAILURE_TEMPLATE, FAILURE_UPDATE, handle_updates(), NULL, 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 6255 of file manager.c.

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

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

Referenced by __init_manager().

action_waitevent()

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

static

Definition at line 4206 of file manager.c.

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

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

Referenced by __init_manager().

advance_event()

static struct eventqent* advance_event ( struct eventqent *  e )

static

Definition at line 2753 of file manager.c.

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

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

Referenced by action_waitevent(), and process_events().

AO2_GLOBAL_OBJ_STATIC() [1/2]

static AO2_GLOBAL_OBJ_STATIC ( event_docs  )

static

A container of event documentation nodes.

AO2_GLOBAL_OBJ_STATIC() [2/2]

static AO2_GLOBAL_OBJ_STATIC ( mgr_sessions  )

static

Active manager connection sessions container.

aocmessage_get_unit_entry()

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

static

Definition at line 5493 of file manager.c.

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

References ast_str_alloca, ast_str_buffer(), ast_str_set(), ast_strlen_zero(), astman_get_header(), and str.

Referenced by action_aocmessage().

append_channel_vars()

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

static

Definition at line 7092 of file manager.c.

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

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

Referenced by __manager_event_sessions_va().

append_event()

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

static

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

Definition at line 7068 of file manager.c.

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

References ast_atomic_fetchadd_int(), ast_malloc, AST_RWLIST_INSERT_TAIL, AST_RWLIST_NEXT, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_tvnow(), NULL, seq, str, and tmp().

Referenced by __init_manager(), and __manager_event_sessions_va().

ast_hook_send_action()

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

access for hooks to send action messages to ami

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

Definition at line 2937 of file manager.c.

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

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

Referenced by hook_send().

ast_instring()

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

static

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

feel free to move this to app.c -anthm

Definition at line 2112 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 1949 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

Return values

The	stasis_message_router for AMI
NULL	on error

Definition at line 1725 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

Return values

The	Stasis Message Bus API topic for AMI
NULL	on error

Definition at line 1720 of file manager.c.

{
   return manager_topic;
}

References manager_topic.

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

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_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_type message.

Definition at line 1903 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_qualify_peer_done(), publish_span_alarm(), publish_span_alarm_clear(), and really_quit().

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

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

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

ast_manager_register_hook()

void ast_manager_register_hook

(

struct manager_custom_hook *

hook

)

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

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

Parameters

hook	struct manager_custom_hook object to add

Definition at line 1934 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 7329 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(&