manager.c File Reference

The Asterisk Management Interface - AMI. More...

#include "asterisk.h"
#include "asterisk/paths.h"
#include <ctype.h>
#include <sys/time.h>
#include <signal.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <regex.h>
#include "asterisk/channel.h"
#include "asterisk/file.h"
#include "asterisk/manager.h"
#include "asterisk/module.h"
#include "asterisk/config.h"
#include "asterisk/callerid.h"
#include "asterisk/core_local.h"
#include "asterisk/lock.h"
#include "asterisk/cli.h"
#include "asterisk/app.h"
#include "asterisk/mwi.h"
#include "asterisk/pbx.h"
#include "asterisk/md5.h"
#include "asterisk/acl.h"
#include "asterisk/utils.h"
#include "asterisk/tcptls.h"
#include "asterisk/http.h"
#include "asterisk/ast_version.h"
#include "asterisk/threadstorage.h"
#include "asterisk/linkedlists.h"
#include "asterisk/term.h"
#include "asterisk/astobj2.h"
#include "asterisk/features.h"
#include "asterisk/security_events.h"
#include "asterisk/aoc.h"
#include "asterisk/strings.h"
#include "asterisk/stringfields.h"
#include "asterisk/presencestate.h"
#include "asterisk/stasis_message_router.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_bridges.h"
#include "asterisk/test.h"
#include "asterisk/json.h"
#include "asterisk/bridge.h"
#include "asterisk/features_config.h"
#include "asterisk/rtp_engine.h"
#include "asterisk/format_cache.h"
#include "asterisk/translate.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/message.h"

Include dependency graph for manager.c:

Go to the source code of this file.

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

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	FORMAT   " %-25.25s %-15.55s\n"
#define	FORMAT2   " %-25.25s %-15d\n"
#define	FORMAT3   " %-25.25s %s\n"
#define	GET_HEADER_FIRST_MATCH   0
#define	GET_HEADER_LAST_MATCH   1
#define	GET_HEADER_SKIP_EMPTY   2
#define	HSMC_FORMAT   " %-*.*s %-.*s\n"
#define	HSMCONN_FORMAT1   " %-15.15s %-55.55s %-10.10s %-10.10s %-8.8s %-8.8s %-10.10s %-10.10s\n"
#define	HSMCONN_FORMAT2   " %-15.15s %-55.55s %-10d %-10d %-8d %-8d %-10.10d %-10.10d\n"
#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)
#define	ROW_FMT   "<tr><td colspan=\"2\" bgcolor=\"#f1f1ff\">%s</td></tr>\r\n"
#define	TEST_STRING    "<form action=\"manager\" method=\"post\">\n\ Action: <select name=\"action\">\n\ <option value=\"\">-----&gt;</option>\n\ <option value=\"login\">login</option>\n\ <option value=\"command\">Command</option>\n\ <option value=\"waitevent\">waitevent</option>\n\ <option value=\"listcommands\">listcommands</option>\n\ </select>\n\ or <input name=\"action\"><br/>\n\ CLI Command <input name=\"command\"><br>\n\ user <input name=\"username\"> pass <input type=\"password\" name=\"secret\"><br>\n\ <input type=\"submit\">\n</form>\n"

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

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 int	__init_manager (int reload, int by_external_config)
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	__reg_module (void)
static void	__unreg_module (void)
static void	acl_change_stasis_cb (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void	acl_change_stasis_subscribe (void)
static void	acl_change_stasis_unsubscribe (void)
static struct ast_aoc_decoded *	action_aoc_de_message (struct mansession *s, const struct message *m)
static struct ast_aoc_decoded *	action_aoc_s_message (struct mansession *s, const struct message *m)
static int	action_aoc_s_submessage (struct mansession *s, const struct message *m, struct ast_aoc_decoded *decoded)
static int	action_aocmessage (struct mansession *s, const struct message *m)
static int	action_atxfer (struct mansession *s, const struct message *m)
static int	action_blind_transfer (struct mansession *s, const struct message *m)
static int	action_cancel_atxfer (struct mansession *s, const struct message *m)
static int	action_challenge (struct mansession *s, const struct message *m)
static int	action_command (struct mansession *s, const struct message *m)
	Manager command "command" - execute CLI command. More...
static int	action_coresettings (struct mansession *s, const struct message *m)
	Show PBX core settings information. More...
static int	action_coreshowchannelmap (struct mansession *s, const struct message *m)
	Manager command "CoreShowChannelMap" - Lists all channels connected to the specified channel. More...
static int	action_coreshowchannels (struct mansession *s, const struct message *m)
	Manager command "CoreShowChannels" - List currently defined channels and some information about them. More...
static int	action_corestatus (struct mansession *s, const struct message *m)
	Show PBX core status information. More...
static int	action_createconfig (struct mansession *s, const struct message *m)
static void	action_destroy (void *obj)
static int	action_events (struct mansession *s, const struct message *m)
static int	action_extensionstate (struct mansession *s, const struct message *m)
static int	action_filter (struct mansession *s, const struct message *m)
	Manager command to add an event filter to a manager session. More...
static struct manager_action *	action_find (const char *name)
static int	action_getconfig (struct mansession *s, const struct message *m)
static int	action_getconfigjson (struct mansession *s, const struct message *m)
static int	action_getvar (struct mansession *s, const struct message *m)
static int	action_hangup (struct mansession *s, const struct message *m)
static int	action_listcategories (struct mansession *s, const struct message *m)
static int	action_listcommands (struct mansession *s, const struct message *m)
static int	action_loggerrotate (struct mansession *s, const struct message *m)
	Manager command "LoggerRotate" - reloads and rotates the logger in the same manner as the CLI command 'logger rotate'. More...
static int	action_login (struct mansession *s, const struct message *m)
static int	action_logoff (struct mansession *s, const struct message *m)
static int	action_mailboxcount (struct mansession *s, const struct message *m)
static int	action_mailboxstatus (struct mansession *s, const struct message *m)
static int	action_originate (struct mansession *s, const struct message *m)
static int	action_ping (struct mansession *s, const struct message *m)
static int	action_presencestate (struct mansession *s, const struct message *m)
static int	action_redirect (struct mansession *s, const struct message *m)
	action_redirect: The redirect manager command More...
static int	action_reload (struct mansession *s, const struct message *m)
	Send a reload event. More...
static int	action_sendtext (struct mansession *s, const struct message *m)
static int	action_setvar (struct mansession *s, const struct message *m)
static int	action_status (struct mansession *s, const struct message *m)
	Manager "status" command to show channels. More...
static int	action_timeout (struct mansession *s, const struct message *m)
static int	action_updateconfig (struct mansession *s, const struct message *m)
static int	action_userevent (struct mansession *s, const struct message *m)
static int	action_waitevent (struct mansession *s, const struct message *m)
static struct eventqent *	advance_event (struct eventqent *e)
static	AO2_GLOBAL_OBJ_STATIC (event_docs)
	A container of event documentation nodes. More...
static	AO2_GLOBAL_OBJ_STATIC (mgr_sessions)
static int	aocmessage_get_unit_entry (const struct message *m, struct ast_aoc_unit_entry *entry, unsigned int entry_num)
static int	app_match (const char *app, const char *data, const char *search)
static int	appdata_match (const char *app, const char *data, const char *search)
static void	append_channel_vars (struct ast_str **pbuf, struct ast_channel *chan)
static int	append_event (const char *str, int event_name_hash, int category)
	events are appended to a queue from where they can be dispatched to clients. More...
int	ast_hook_send_action (struct manager_custom_hook *hook, const char *msg)
	access for hooks to send action messages to ami More...
static int	ast_instring (const char *bigstr, const char *smallstr, const char delim)
int	ast_manager_check_enabled (void)
	Check if AMI is enabled. More...
struct ast_manager_event_blob *	ast_manager_event_blob_create (int event_flags, const char *manager_event, const char *extra_fields_fmt,...)
	Construct a ast_manager_event_blob. More...
struct stasis_message_router *	ast_manager_get_message_router (void)
	Get the stasis_message_router for AMI. More...
struct stasis_topic *	ast_manager_get_topic (void)
	Get the Stasis Message Bus API topic for AMI. More...
int	ast_manager_hangup_helper (struct mansession *s, const struct message *m, manager_hangup_handler_t hangup_handler, manager_hangup_cause_validator_t cause_validator)
	A manager helper function that hangs up a channel using a supplied channel type specific hangup function and cause code validator. More...
void	ast_manager_publish_event (const char *type, int class_type, struct ast_json *obj)
	Publish an event to AMI. More...
int	ast_manager_register2 (const char *action, int auth, int(*func)(struct mansession *s, const struct message *m), struct ast_module *module, const char *synopsis, const char *description)
	register a new command with manager, including online help. This is the preferred way to register a manager command More...
void	ast_manager_register_hook (struct manager_custom_hook *hook)
	Add a custom hook to be called when an event is fired. More...
static int	ast_manager_register_struct (struct manager_action *act)
struct ast_str *	ast_manager_str_from_json_object (struct ast_json *blob, key_exclusion_cb exclusion_cb)
	Convert a JSON object into an AMI compatible string. More...
int	ast_manager_unregister (const char *action)
	support functions to register/unregister AMI action handlers, More...
void	ast_manager_unregister_hook (struct manager_custom_hook *hook)
	Delete a custom hook to be called when an event is fired. More...
struct ast_module *	AST_MODULE_SELF_SYM (void)
int	ast_str_append_event_header (struct ast_str **fields_string, const char *header, const char *value)
	append an event header to an ast string More...
int	ast_webmanager_check_enabled (void)
	Check if AMI/HTTP is enabled. More...
static int	ast_xml_doc_item_cmp_fn (const void *a, const void *b)
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)
int	astman_datastore_add (struct mansession *s, struct ast_datastore *datastore)
	Add a datastore to a session. More...
struct ast_datastore *	astman_datastore_find (struct mansession *s, const struct ast_datastore_info *info, const char *uid)
	Find a datastore on a session. More...
int	astman_datastore_remove (struct mansession *s, struct ast_datastore *datastore)
	Remove a datastore from a session. More...
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...
int	astman_is_authed (uint32_t ident)
	Determine if a manager session ident is authenticated. More...
void	astman_live_dangerously (int new_live_dangerously)
	Enable/disable the inclusion of 'dangerous' configurations outside of the ast_config_AST_CONFIG_DIR. More...
void	astman_send_ack (struct mansession *s, const struct message *m, char *msg)
	Send ack in manager transaction. More...
void	astman_send_error (struct mansession *s, const struct message *m, char *error)
	Send error in manager transaction. More...
void	astman_send_error_va (struct mansession *s, const struct message *m, const char *fmt,...)
	Send error in manager transaction (with va_args support) More...
static void	astman_send_list_complete (struct mansession *s, const struct message *m, const char *event_name, int count)
void	astman_send_list_complete_end (struct mansession *s)
	End the list complete event. More...
void	astman_send_list_complete_start (struct mansession *s, const struct message *m, const char *event_name, int count)
	Start the list complete event. More...
static struct ast_str *	astman_send_list_complete_start_common (struct mansession *s, const struct message *m, const char *event_name, int count)
void	astman_send_listack (struct mansession *s, const struct message *m, char *msg, char *listflag)
	Send ack in manager transaction to begin a list. More...
void	astman_send_response (struct mansession *s, const struct message *m, char *resp, char *msg)
	Send response in manager transaction. More...
static void	astman_send_response_full (struct mansession *s, const struct message *m, char *resp, char *msg, char *listflag)
	send a response with an optional message, and terminate it with an empty line. m is used only to grab the 'ActionID' field. More...
static void	astman_start_ack (struct mansession *s, const struct message *m)
int	astman_verify_session_readpermissions (uint32_t ident, int perm)
	Verify a session's read permissions against a permission mask. More...
int	astman_verify_session_writepermissions (uint32_t ident, int perm)
	Verify a session's write permissions against a permission mask. More...
static int	auth_http_callback (struct ast_tcptls_session_instance *ser, enum ast_http_method method, enum output_format format, const struct ast_sockaddr *remote_address, const char *uri, struct ast_variable *get_params, struct ast_variable *headers)
static int	auth_manager_http_callback (struct ast_tcptls_session_instance *ser, const struct ast_http_uri *urih, const char *uri, enum ast_http_method method, struct ast_variable *get_params, struct ast_variable *headers)
static int	auth_mxml_http_callback (struct ast_tcptls_session_instance *ser, const struct ast_http_uri *urih, const char *uri, enum ast_http_method method, struct ast_variable *get_params, struct ast_variable *headers)
static int	auth_rawman_http_callback (struct ast_tcptls_session_instance *ser, const struct ast_http_uri *urih, const char *uri, enum ast_http_method method, struct ast_variable *get_params, struct ast_variable *headers)
static int	authenticate (struct mansession *s, const struct message *m)
static const char *	authority_to_str (int authority, struct ast_str **res)
	Convert authority code to a list of options. Note that the EVENT_FLAG_ALL authority will always be returned. More...
static struct mansession_session *	build_mansession (const struct ast_sockaddr *addr)
	Allocate manager session structure and add it to the list of sessions. More...
static int	check_blacklist (const char *cmd)
static int	check_manager_session_inuse (const char *name)
static void	close_mansession_file (struct mansession *s)
static int	coreshowchannelmap_add_connected_channels (struct ao2_container *channel_map, struct ast_channel_snapshot *channel_snapshot, struct ast_bridge_snapshot *bridge_snapshot)
	Recursive function to get all channels in a bridge. Follow local channels as well. More...
static int	coreshowchannelmap_add_to_map (struct ao2_container *c, const char *s)
	Helper function to add a channel name to the vector. More...
static void	destroy_fast_originate_helper (struct fast_originate_helper *doomed)
static int	do_message (struct mansession *s)
static void	event_filter_destructor (void *obj)
static void *	fast_originate (void *data)
static int	file_in_modules_dir (const char *filename)
	Check if the given file path is in the modules dir or not. More...
static int	filter_cmp_fn (void *obj, void *arg, void *data, int flags)
static struct mansession_session *	find_session (uint32_t ident, int incinuse)
static struct mansession_session *	find_session_by_nonce (const char *username, unsigned long nonce, int *stale)
static int	function_amiclient (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
	${AMI_CLIENT()} Dialplan function - reads manager client data More...
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	generic_http_callback (struct ast_tcptls_session_instance *ser, enum ast_http_method method, enum output_format format, const struct ast_sockaddr *remote_address, const char *uri, struct ast_variable *get_params, struct ast_variable *headers)
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_manager_sessions_cb (void *obj, void *arg, void *data, int flags)
	Get number of logged in sessions for a login name. More...
static int	get_perm (const char *instr)
static struct eventqent *	grab_last (void)
static char *	handle_kickmanconn (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command manager kick session. More...
static char *	handle_manager_reload (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command manager reload. More...
static char *	handle_manager_show_event (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_manager_show_events (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_manager_show_settings (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command manager show settings. More...
static char *	handle_mandebug (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void	handle_parse_error (struct mansession *s, struct message *m, char *error)
static char *	handle_showmanager (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_showmanagers (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_showmancmd (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_showmancmds (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command manager list commands. More...
static char *	handle_showmanconn (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command manager list connected. More...
static char *	handle_showmaneventq (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command manager list eventq. More...
static enum error_type	handle_updates (struct mansession *s, const struct message *m, struct ast_config *cfg, const char *dfn)
	helper function for action_updateconfig More...
static int	is_originate_app_permitted (const char *app, const char *data, int permission)
static int	is_restricted_file (const char *filename)
	Check if a file is restricted or not. More...
static void	json_escape (char *out, const char *in)
static void	load_channelvars (struct ast_variable *var)
static void	load_disabledevents (struct ast_variable *var)
static int	load_module (void)
static void	log_action (const struct message *m, const char *action)
static struct ast_variable *	man_do_variable_value (struct ast_variable *head, const char *hdr_val)
static enum add_filter_result	manager_add_filter (const char *criteria, const char *filter_pattern, struct ao2_container *includefilters, struct ao2_container *excludefilters)
	Add an event filter to a manager session. More...
static void	manager_default_msg_cb (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static int	manager_displayconnects (struct mansession_session *session)
	Get displayconnects config option. More...
static void	manager_event_blob_dtor (void *obj)
static void	manager_free_user (struct ast_manager_user *user)
static void	manager_generic_msg_cb (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static int	manager_http_callback (struct ast_tcptls_session_instance *ser, const struct ast_http_uri *urih, const char *uri, enum ast_http_method method, struct ast_variable *get_params, struct ast_variable *headers)
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 void	manager_set_defaults (void)
static void	manager_shutdown (void)
static int	manager_state_cb (const char *context, const char *exten, struct ast_state_cb_info *info, void *data)
static int	manager_subscriptions_init (void)
	Initialize all Stasis Message Bus API topics and routers used by the various sub-components of AMI. More...
static int	mansession_cmp_fn (void *obj, void *arg, int flags)
static enum ast_transport	mansession_get_transport (const struct mansession *s)
static void	mansession_lock (struct mansession *s)
	Lock the 'mansession' structure. More...
static void	mansession_unlock (struct mansession *s)
	Unlock the 'mansession' structure. More...
static int	match_eventdata (struct event_filter_entry *entry, const char *eventdata)
	Test eventdata against a filter entry. More...
static int	mxml_http_callback (struct ast_tcptls_session_instance *ser, const struct ast_http_uri *urih, const char *uri, enum ast_http_method method, struct ast_variable *get_params, struct ast_variable *headers)
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	process_output (struct mansession *s, struct ast_str **out, struct ast_variable *params, enum output_format format)
static void	purge_events (void)
static void	purge_old_stuff (void *data)
	cleanup code called at each iteration of server_root, guaranteed to happen every 5 seconds at most More...
static int	purge_sessions (int n_max)
	remove at most n_max stale session from the list. More...
static int	queue_match (const char *app, const char *data, const char *search)
static int	queue_read_action_payload (struct ast_channel *chan, const unsigned char *payload, size_t payload_size, enum ast_frame_read_action action)
	Queue a given read action containing a payload onto a channel. More...
static int	queue_sendtext (struct ast_channel *chan, const char *body)
	Queue a read action to send a text message. More...
static int	queue_sendtext_data (struct ast_channel *chan, const char *body, const char *content_type)
	Queue a read action to send a text data message. More...
static int	rawman_http_callback (struct ast_tcptls_session_instance *ser, const struct ast_http_uri *urih, const char *uri, enum ast_http_method method, struct ast_variable *get_params, struct ast_variable *headers)
static int	reload_module (void)
static void	report_auth_success (const struct mansession *s)
static void	report_failed_acl (const struct mansession *s, const char *username)
static void	report_failed_challenge_response (const struct mansession *s, const char *response, const char *expected_response)
static void	report_inval_password (const struct mansession *s, const char *username)
static void	report_invalid_user (const struct mansession *s, const char *username)
static void	report_req_bad_format (const struct mansession *s, const char *action)
static void	report_req_not_allowed (const struct mansession *s, const char *action)
static void	report_session_limit (const struct mansession *s)
static int	send_string (struct mansession *s, char *string)
static void	session_destroy (struct mansession_session *s)
static void	session_destructor (void *obj)
static void *	session_do (void *data)
	The body of the individual manager session. Call get_input() to read one line at a time (or be woken up on new events), collect the lines in a message until found an empty line, and execute the request. In any case, deliver events asynchronously through process_events() (called from here if no line is available, or at the end of process_message(). ) More...
static int	set_eventmask (struct mansession *s, const char *eventmask)
	Rather than braindead on,off this now can also accept a specific int mask value or a ',' delim list of mask strings (the same as manager.conf) -anthm. More...
static int	should_send_event (struct ao2_container *includefilters, struct ao2_container *excludefilters, struct eventqent *eqe)
static int	strings_to_mask (const char *string)
static int	subscribe_all (void)
static int	unload_module (void)
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	variable_count_cmp_fn (void *obj, void *vstr, int flags)
static int	variable_count_hash_fn (const void *vvc, const int flags)
static void	xml_copy_escape (struct ast_str **out, const char *src, int mode)
static void	xml_translate (struct ast_str **out, char *in, struct ast_variable *get_vars, enum output_format format)
	Convert the input into XML or HTML. The input is supposed to be a sequence of lines of the form Name: value optionally followed by a blob of unformatted text. A blank line is a section separator. Basically, this is a mixture of the format of Manager Interface and CLI commands. The unformatted text is considered as a single value of a field named 'Opaque-data'. More...
	STASIS_MESSAGE_TYPE_DEFN (ast_manager_get_generic_type)
	Define AMI message types. More...

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Asterisk Manager Interface" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = AST_MODPRI_CORE, .requires = "extconfig,acl,http", }
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_http_uri	amanageruri
static struct ast_http_uri	amanagerxmluri
static struct ast_tcptls_session_args	ami_desc
static struct ast_tls_config	ami_tls_cfg
static struct ast_tcptls_session_args	amis_desc
static struct ast_http_uri	arawmanuri
static const struct ast_module_info *	ast_module_info = &__mod_info
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
static struct ast_cli_entry	cli_manager []
struct {
const char *   words [AST_MAX_CMD_LEN]
}	command_blacklist []
static const char *const	contenttype []
static int	displayconnects = 1
static char	global_realm [MAXHOSTNAMELEN]
static int	httptimeout = 60
static int	live_dangerously
	Set to true (non-zero) to globally allow all dangerous AMI actions to run. More...
static char *	manager_channelvars
static int	manager_debug = 0
static char *	manager_disabledevents
static int	manager_enabled = 0
static struct ast_threadstorage	manager_event_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_manager_event_buf , .custom_init = NULL , }
static struct manager_hooks	manager_hooks = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
static struct stasis_topic *	manager_topic
	A stasis_topic that all topics AMI cares about will be forwarded to. More...
static struct ast_custom_function	managerclient_function
	description of AMI_CLIENT dialplan function More...
static struct ast_http_uri	manageruri
static struct ast_http_uri	managerxmluri
static char *	match_type_names []
static struct originate_permissions_entry	originate_app_permissions []
static const struct permalias	perms []
static struct ast_http_uri	rawmanuri
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
static int	webregged = 0

Detailed Description

The Asterisk Management Interface - AMI.

Author

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

OpenSSL http://www.openssl.org - for AMI/SSL

At the moment this file contains a number of functions, namely:

• data structures storing AMI state
• AMI-related API functions, used by internal asterisk components
• handlers for AMI-related CLI functions
• handlers for AMI functions (available through the AMI socket)
• the code for the main AMI listener thread and individual session threads
• the http handlers invoked for AMI-over-HTTP by the threads in main/http.c

manager.conf

Definition in file manager.c.

Macro Definition Documentation

FORMAT

#define FORMAT   " %-25.25s %-15.55s\n"

FORMAT2

#define FORMAT2   " %-25.25s %-15d\n"

FORMAT3

#define FORMAT3   " %-25.25s %s\n"

HSMC_FORMAT

#define HSMC_FORMAT   " %-*.*s %-.*s\n"

HSMCONN_FORMAT1

#define HSMCONN_FORMAT1   " %-15.15s %-55.55s %-10.10s %-10.10s %-8.8s %-8.8s %-10.10s %-10.10s\n"

HSMCONN_FORMAT2

#define HSMCONN_FORMAT2   " %-15.15s %-55.55s %-10d %-10d %-8d %-8d %-10.10d %-10.10d\n"

ROW_FMT

#define ROW_FMT   "<tr><td colspan=\"2\" bgcolor=\"#f1f1ff\">%s</td></tr>\r\n"

TEST_STRING

#define TEST_STRING    "<form action=\"manager\" method=\"post\">\n\ Action: <select name=\"action\">\n\ <option value=\"\">-----&gt;</option>\n\ <option value=\"login\">login</option>\n\ <option value=\"command\">Command</option>\n\ <option value=\"waitevent\">waitevent</option>\n\ <option value=\"listcommands\">listcommands</option>\n\ </select>\n\ or <input name=\"action\"><br/>\n\ CLI Command <input name=\"command\"><br>\n\ user <input name=\"username\"> pass <input type=\"password\" name=\"secret\"><br>\n\ <input type=\"submit\">\n</form>\n"

Enumeration Type Documentation

output_format

enum output_format

Enumerator
FORMAT_RAW
FORMAT_HTML
FORMAT_XML

Definition at line 7902 of file manager.c.

                   {
    FORMAT_RAW,
    FORMAT_HTML,
    FORMAT_XML,
};

Function Documentation

__init_manager()

static int __init_manager ( int  reload, int  by_external_config  )

static

Definition at line 9637 of file manager.c.

{
    struct ast_config *ucfg = NULL, *cfg = NULL;
    const char *val;
    char *cat = NULL;
    int newhttptimeout = 60;
    struct ast_manager_user *user = NULL;
    struct ast_variable *var;
    struct ast_flags config_flags = { (reload && !by_external_config) ? CONFIG_FLAG_FILEUNCHANGED : 0 };
    char a1[337];
    char a1_hash[256];
    struct ast_sockaddr ami_desc_local_address_tmp;
    struct ast_sockaddr amis_desc_local_address_tmp;
    int tls_was_enabled = 0;
    int acl_subscription_flag = 0;
 
    if (!reload) {
        struct ao2_container *sessions;
#ifdef AST_XML_DOCS
        struct ao2_container *temp_event_docs;
#endif
        int res;
 
        res = STASIS_MESSAGE_TYPE_INIT(ast_manager_get_generic_type);
        if (res != 0) {
            return -1;
        }
        manager_topic = stasis_topic_create("manager:core");
        if (!manager_topic) {
            return -1;
        }
 
        /* Register default actions */
        ast_manager_register_xml_core("Ping", 0, action_ping);
        ast_manager_register_xml_core("Events", 0, action_events);
        ast_manager_register_xml_core("Logoff", 0, action_logoff);
        ast_manager_register_xml_core("Login", 0, action_login);
        ast_manager_register_xml_core("Challenge", 0, action_challenge);
        ast_manager_register_xml_core("Hangup", EVENT_FLAG_SYSTEM | EVENT_FLAG_CALL, action_hangup);
        ast_manager_register_xml_core("Status", EVENT_FLAG_SYSTEM | EVENT_FLAG_CALL | EVENT_FLAG_REPORTING, action_status);
        ast_manager_register_xml_core("Setvar", EVENT_FLAG_CALL, action_setvar);
        ast_manager_register_xml_core("Getvar", EVENT_FLAG_CALL | EVENT_FLAG_REPORTING, action_getvar);
        ast_manager_register_xml_core("GetConfig", EVENT_FLAG_SYSTEM | EVENT_FLAG_CONFIG, action_getconfig);
        ast_manager_register_xml_core("GetConfigJSON", EVENT_FLAG_SYSTEM | EVENT_FLAG_CONFIG, action_getconfigjson);
        ast_manager_register_xml_core("UpdateConfig", EVENT_FLAG_CONFIG, action_updateconfig);
        ast_manager_register_xml_core("CreateConfig", EVENT_FLAG_CONFIG, action_createconfig);
        ast_manager_register_xml_core("ListCategories", EVENT_FLAG_CONFIG, action_listcategories);
        ast_manager_register_xml_core("Redirect", EVENT_FLAG_CALL, action_redirect);
        ast_manager_register_xml_core("Atxfer", EVENT_FLAG_CALL, action_atxfer);
        ast_manager_register_xml_core("CancelAtxfer", EVENT_FLAG_CALL, action_cancel_atxfer);
        ast_manager_register_xml_core("Originate", EVENT_FLAG_ORIGINATE, action_originate);
        ast_manager_register_xml_core("Command", EVENT_FLAG_COMMAND, action_command);
        ast_manager_register_xml_core("ExtensionState", EVENT_FLAG_CALL | EVENT_FLAG_REPORTING, action_extensionstate);
        ast_manager_register_xml_core("PresenceState", EVENT_FLAG_CALL | EVENT_FLAG_REPORTING, action_presencestate);
        ast_manager_register_xml_core("AbsoluteTimeout", EVENT_FLAG_SYSTEM | EVENT_FLAG_CALL, action_timeout);
        ast_manager_register_xml_core("MailboxStatus", EVENT_FLAG_CALL | EVENT_FLAG_REPORTING, action_mailboxstatus);
        ast_manager_register_xml_core("MailboxCount", EVENT_FLAG_CALL | EVENT_FLAG_REPORTING, action_mailboxcount);
        ast_manager_register_xml_core("ListCommands", 0, action_listcommands);
        ast_manager_register_xml_core("SendText", EVENT_FLAG_CALL, action_sendtext);
        ast_manager_register_xml_core("UserEvent", EVENT_FLAG_USER, action_userevent);
        ast_manager_register_xml_core("WaitEvent", 0, action_waitevent);
        ast_manager_register_xml_core("CoreSettings", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, action_coresettings);
        ast_manager_register_xml_core("CoreStatus", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, action_corestatus);
        ast_manager_register_xml_core("Reload", EVENT_FLAG_CONFIG | EVENT_FLAG_SYSTEM, action_reload);
        ast_manager_register_xml_core("LoggerRotate", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, action_loggerrotate);
        ast_manager_register_xml_core("CoreShowChannels", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, action_coreshowchannels);
        ast_manager_register_xml_core("CoreShowChannelMap", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, action_coreshowchannelmap);
        ast_manager_register_xml_core("ModuleLoad", EVENT_FLAG_SYSTEM, manager_moduleload);
        ast_manager_register_xml_core("ModuleCheck", EVENT_FLAG_SYSTEM, manager_modulecheck);
        ast_manager_register_xml_core("AOCMessage", EVENT_FLAG_AOC, action_aocmessage);
        ast_manager_register_xml_core("Filter", EVENT_FLAG_SYSTEM, action_filter);
        ast_manager_register_xml_core("BlindTransfer", EVENT_FLAG_CALL, action_blind_transfer);
 
#ifdef TEST_FRAMEWORK
        test_suite_forwarder = stasis_forward_all(ast_test_suite_topic(), manager_topic);
#endif
 
        ast_cli_register_multiple(cli_manager, ARRAY_LEN(cli_manager));
        __ast_custom_function_register(&managerclient_function, NULL);
        ast_extension_state_add(NULL, NULL, manager_state_cb, NULL);
 
        /* Append placeholder event so master_eventq never runs dry */
        if (append_event("Event: Placeholder\r\n\r\n",
            ast_str_hash("Placeholder"), 0)) {
            return -1;
        }
 
#ifdef AST_XML_DOCS
        temp_event_docs = ast_xmldoc_build_documentation("managerEvent");
        if (temp_event_docs) {
            ao2_t_global_obj_replace_unref(event_docs, temp_event_docs, "Toss old event docs");
            ao2_t_ref(temp_event_docs, -1, "Remove creation ref - container holds only ref now");
        }
#endif
 
        /* If you have a NULL hash fn, you only need a single bucket */
        sessions = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, mansession_cmp_fn);
        if (!sessions) {
            return -1;
        }
        ao2_global_obj_replace_unref(mgr_sessions, sessions);
        ao2_ref(sessions, -1);
 
        /* Initialize all settings before first configuration load. */
        manager_set_defaults();
    }
 
    cfg = ast_config_load2("manager.conf", "manager", config_flags);
    if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
        return 0;
    } else if (!cfg || cfg == CONFIG_STATUS_FILEINVALID) {
        ast_log(LOG_NOTICE, "Unable to open AMI configuration manager.conf, or configuration is invalid.\n");
        return 0;
    }
 
    /* If this wasn't performed due to a forced reload (because those can be created by ACL change events, we need to unsubscribe to ACL change events. */
    if (!by_external_config) {
        acl_change_stasis_unsubscribe();
    }
 
    if (reload) {
        /* Reset all settings before reloading configuration */
        tls_was_enabled = ami_tls_cfg.enabled;
        manager_set_defaults();
    }
 
    ast_sockaddr_parse(&ami_desc_local_address_tmp, "[::]", 0);
    ast_sockaddr_set_port(&ami_desc_local_address_tmp, DEFAULT_MANAGER_PORT);
 
    for (var = ast_variable_browse(cfg, "general"); var; var = var->next) {
        val = var->value;
 
        /* read tls config options while preventing unsupported options from being set */
        if (strcasecmp(var->name, "tlscafile")
            && strcasecmp(var->name, "tlscapath")
            && strcasecmp(var->name, "tlscadir")
            && strcasecmp(var->name, "tlsverifyclient")
            && strcasecmp(var->name, "tlsdontverifyserver")
            && strcasecmp(var->name, "tlsclientmethod")
            && strcasecmp(var->name, "sslclientmethod")
            && !ast_tls_read_conf(&ami_tls_cfg, &amis_desc, var->name, val)) {
            continue;
        }
 
        if (!strcasecmp(var->name, "enabled")) {
            manager_enabled = ast_true(val);
        } else if (!strcasecmp(var->name, "webenabled")) {
            webmanager_enabled = ast_true(val);
        } else if (!strcasecmp(var->name, "port")) {
            int bindport;
            if (ast_parse_arg(val, PARSE_UINT32|PARSE_IN_RANGE, &bindport, 1024, 65535)) {
                ast_log(LOG_WARNING, "Invalid port number '%s'\n", val);
            }
            ast_sockaddr_set_port(&ami_desc_local_address_tmp, bindport);
        } else if (!strcasecmp(var->name, "bindaddr")) {
            /* remember port if it has already been set */
            int setport = ast_sockaddr_port(&ami_desc_local_address_tmp);
 
            if (ast_parse_arg(val, PARSE_ADDR|PARSE_PORT_IGNORE, NULL)) {
                ast_log(LOG_WARNING, "Invalid address '%s' specified, default '%s' will be used\n", val,
                        ast_sockaddr_stringify_addr(&ami_desc_local_address_tmp));
            } else {
                ast_sockaddr_parse(&ami_desc_local_address_tmp, val, PARSE_PORT_IGNORE);
            }
 
            if (setport) {
                ast_sockaddr_set_port(&ami_desc_local_address_tmp, setport);
            }
 
        } else if (!strcasecmp(var->name, "brokeneventsaction")) {
            broken_events_action = ast_true(val);
        } else if (!strcasecmp(var->name, "allowmultiplelogin")) {
            allowmultiplelogin = ast_true(val);
        } else if (!strcasecmp(var->name, "displayconnects")) {
            displayconnects = ast_true(val);
        } else if (!strcasecmp(var->name, "timestampevents")) {
            timestampevents = ast_true(val);
        } else if (!strcasecmp(var->name, "debug")) {
            manager_debug = ast_true(val);
        } else if (!strcasecmp(var->name, "httptimeout")) {
            newhttptimeout = atoi(val);
        } else if (!strcasecmp(var->name, "authtimeout")) {
            int timeout = atoi(var->value);
 
            if (timeout < 1) {
                ast_log(LOG_WARNING, "Invalid authtimeout value '%s', using default value\n", var->value);
            } else {
                authtimeout = timeout;
            }
        } else if (!strcasecmp(var->name, "authlimit")) {
            int limit = atoi(var->value);
 
            if (limit < 1) {
                ast_log(LOG_WARNING, "Invalid authlimit value '%s', using default value\n", var->value);
            } else {
                authlimit = limit;
            }
        } else if (!strcasecmp(var->name, "channelvars")) {
            load_channelvars(var);
        } else if (!strcasecmp(var->name, "disabledevents")) {
            load_disabledevents(var);
        } else {
            ast_log(LOG_NOTICE, "Invalid keyword <%s> = <%s> in manager.conf [general]\n",
                var->name, val);
        }
    }
 
    if (manager_enabled && !subscribed) {
        if (subscribe_all() != 0) {
            ast_log(LOG_ERROR, "Manager subscription error\n");
            return -1;
        }
    }
 
    ast_sockaddr_copy(&amis_desc_local_address_tmp, &amis_desc.local_address);
 
    /* if the amis address has not been set, default is the same as non secure ami */
    if (ast_sockaddr_isnull(&amis_desc_local_address_tmp)) {
        ast_sockaddr_copy(&amis_desc_local_address_tmp, &ami_desc_local_address_tmp);
    }
 
    /* if the amis address was not set, it will have non-secure ami port set; if
       amis address was set, we need to check that a port was set or not, if not
       use the default tls port */
    if (ast_sockaddr_port(&amis_desc_local_address_tmp) == 0 ||
            (ast_sockaddr_port(&ami_desc_local_address_tmp) == ast_sockaddr_port(&amis_desc_local_address_tmp))) {
 
        ast_sockaddr_set_port(&amis_desc_local_address_tmp, DEFAULT_MANAGER_TLS_PORT);
    }
 
    if (manager_enabled) {
        ast_sockaddr_copy(&ami_desc.local_address, &ami_desc_local_address_tmp);
        ast_sockaddr_copy(&amis_desc.local_address, &amis_desc_local_address_tmp);
    }
 
    AST_RWLIST_WRLOCK(&users);
 
    /* First, get users from users.conf */
    ucfg = ast_config_load2("users.conf", "manager", config_flags);
    if (ucfg && (ucfg != CONFIG_STATUS_FILEUNCHANGED) && ucfg != CONFIG_STATUS_FILEINVALID) {
        const char *hasmanager;
        int genhasmanager = ast_true(ast_variable_retrieve(ucfg, "general", "hasmanager"));
 
        while ((cat = ast_category_browse(ucfg, cat))) {
            if (!strcasecmp(cat, "general")) {
                continue;
            }
 
            hasmanager = ast_variable_retrieve(ucfg, cat, "hasmanager");
            if ((!hasmanager && genhasmanager) || ast_true(hasmanager)) {
                const char *user_secret = ast_variable_retrieve(ucfg, cat, "secret");
                const char *user_read = ast_variable_retrieve(ucfg, cat, "read");
                const char *user_write = ast_variable_retrieve(ucfg, cat, "write");
                const char *user_displayconnects = ast_variable_retrieve(ucfg, cat, "displayconnects");
                const char *user_allowmultiplelogin = ast_variable_retrieve(ucfg, cat, "allowmultiplelogin");
                const char *user_writetimeout = ast_variable_retrieve(ucfg, cat, "writetimeout");
 
                /* Look for an existing entry,
                 * if none found - create one and add it to the list
                 */
                if (!(user = get_manager_by_name_locked(cat))) {
                    if (!(user = ast_calloc(1, sizeof(*user)))) {
                        break;
                    }
 
                    /* Copy name over */
                    ast_copy_string(user->username, cat, sizeof(user->username));
                    /* Insert into list */
                    AST_LIST_INSERT_TAIL(&users, user, list);
                    user->acl = NULL;
                    user->keep = 1;
                    user->readperm = -1;
                    user->writeperm = -1;
                    /* Default displayconnect from [general] */
                    user->displayconnects = displayconnects;
                    /* Default allowmultiplelogin from [general] */
                    user->allowmultiplelogin = allowmultiplelogin;
                    user->writetimeout = 100;
                }
 
                if (!user_secret) {
                    user_secret = ast_variable_retrieve(ucfg, "general", "secret");
                }
                if (!user_read) {
                    user_read = ast_variable_retrieve(ucfg, "general", "read");
                }
                if (!user_write) {
                    user_write = ast_variable_retrieve(ucfg, "general", "write");
                }
                if (!user_displayconnects) {
                    user_displayconnects = ast_variable_retrieve(ucfg, "general", "displayconnects");
                }
                if (!user_allowmultiplelogin) {
                    user_allowmultiplelogin = ast_variable_retrieve(ucfg, "general", "allowmultiplelogin");
                }
                if (!user_writetimeout) {
                    user_writetimeout = ast_variable_retrieve(ucfg, "general", "writetimeout");
                }
 
                if (!ast_strlen_zero(user_secret)) {
                    ast_free(user->secret);
                    user->secret = ast_strdup(user_secret);
                }
 
                if (user_read) {
                    user->readperm = get_perm(user_read);
                }
                if (user_write) {
                    user->writeperm = get_perm(user_write);
                }
                if (user_displayconnects) {
                    user->displayconnects = ast_true(user_displayconnects);
                }
                if (user_allowmultiplelogin) {
                    user->allowmultiplelogin = ast_true(user_allowmultiplelogin);
                }
                if (user_writetimeout) {
                    int value = atoi(user_writetimeout);
                    if (value < 100) {
                        ast_log(LOG_WARNING, "Invalid writetimeout value '%d' in users.conf\n", value);
                    } else {
                        user->writetimeout = value;
                    }
                }
            }
        }
        ast_config_destroy(ucfg);
    }
 
    /* cat is NULL here in any case */
 
    while ((cat = ast_category_browse(cfg, cat))) {
        struct ast_acl_list *oldacl;
 
        if (!strcasecmp(cat, "general")) {
            continue;
        }
 
        /* Look for an existing entry, if none found - create one and add it to the list */
        if (!(user = get_manager_by_name_locked(cat))) {
            if (!(user = ast_calloc(1, sizeof(*user)))) {
                break;
            }
            /* Copy name over */
            ast_copy_string(user->username, cat, sizeof(user->username));
 
            user->acl = NULL;
            user->readperm = 0;
            user->writeperm = 0;
            /* Default displayconnect from [general] */
            user->displayconnects = displayconnects;
            /* Default allowmultiplelogin from [general] */
            user->allowmultiplelogin = allowmultiplelogin;
            user->writetimeout = 100;
            user->includefilters = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
            user->excludefilters = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
            if (!user->includefilters || !user->excludefilters) {
                manager_free_user(user);
                break;
            }
 
            /* Insert into list */
            AST_RWLIST_INSERT_TAIL(&users, user, list);
        } else {
            ao2_t_callback(user->includefilters, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, NULL, NULL, "unlink all include filters");
            ao2_t_callback(user->excludefilters, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, NULL, NULL, "unlink all exclude filters");
        }
 
        /* Make sure we keep this user and don't destroy it during cleanup */
        user->keep = 1;
        oldacl = user->acl;
        user->acl = NULL;
        ast_variables_destroy(user->chanvars);
 
        var = ast_variable_browse(cfg, cat);
        for (; var; var = var->next) {
            if (!strcasecmp(var->name, "secret")) {
                ast_free(user->secret);
                user->secret = ast_strdup(var->value);
            } else if (!strcasecmp(var->name, "deny") ||
                       !strcasecmp(var->name, "permit") ||
                       !strcasecmp(var->name, "acl")) {
                int acl_error = 0;
 
                ast_append_acl(var->name, var->value, &user->acl, &acl_error, &acl_subscription_flag);
                if (acl_error) {
                    ast_log(LOG_ERROR, "Invalid ACL '%s' for manager user '%s' on line %d. Deleting user\n",
                        var->value, user->username, var->lineno);
                    user->keep = 0;
                }
            }  else if (!strcasecmp(var->name, "read") ) {
                user->readperm = get_perm(var->value);
            }  else if (!strcasecmp(var->name, "write") ) {
                user->writeperm = get_perm(var->value);
            }  else if (!strcasecmp(var->name, "displayconnects") ) {
                user->displayconnects = ast_true(var->value);
            }  else if (!strcasecmp(var->name, "allowmultiplelogin") ) {
                user->allowmultiplelogin = ast_true(var->value);
            } else if (!strcasecmp(var->name, "writetimeout")) {
                int value = atoi(var->value);
                if (value < 100) {
                    ast_log(LOG_WARNING, "Invalid writetimeout value '%s' at line %d\n", var->value, var->lineno);
                } else {
                    user->writetimeout = value;
                }
            } else if (!strcasecmp(var->name, "setvar")) {
                struct ast_variable *tmpvar;
                char varbuf[256];
                char *varval;
                char *varname;
 
                ast_copy_string(varbuf, var->value, sizeof(varbuf));
                varname = varbuf;
 
                if ((varval = strchr(varname,'='))) {
                    *varval++ = '\0';
                    if ((tmpvar = ast_variable_new(varname, varval, ""))) {
                        tmpvar->next = user->chanvars;
                        user->chanvars = tmpvar;
                    }
                }
            } else if (ast_begins_with(var->name, "eventfilter")) {
                const char *value = var->value;
                manager_add_filter(var->name, value, user->includefilters, user->excludefilters);
            } else {
                ast_debug(1, "%s is an unknown option.\n", var->name);
            }
        }
 
        oldacl = ast_free_acl_list(oldacl);
    }
    ast_config_destroy(cfg);
 
    /* Check the flag for named ACL event subscription and if we need to, register a subscription. */
    if (acl_subscription_flag && !by_external_config) {
        acl_change_stasis_subscribe();
    }
 
    /* Perform cleanup - essentially prune out old users that no longer exist */
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&users, user, list) {
        if (user->keep) {   /* valid record. clear flag for the next round */
            user->keep = 0;
 
            /* Calculate A1 for Digest auth */
            snprintf(a1, sizeof(a1), "%s:%s:%s", user->username, global_realm, user->secret);
            ast_md5_hash(a1_hash,a1);
            ast_free(user->a1_hash);
            user->a1_hash = ast_strdup(a1_hash);
            continue;
        }
        /* We do not need to keep this user so take them out of the list */
        AST_RWLIST_REMOVE_CURRENT(list);
        ast_debug(4, "Pruning user '%s'\n", user->username);
        manager_free_user(user);
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
 
    AST_RWLIST_UNLOCK(&users);
 
    if (webmanager_enabled && manager_enabled) {
        if (!webregged) {
            ast_http_uri_link(&rawmanuri);
            ast_http_uri_link(&manageruri);
            ast_http_uri_link(&managerxmluri);
 
            ast_http_uri_link(&arawmanuri);
            ast_http_uri_link(&amanageruri);
            ast_http_uri_link(&amanagerxmluri);
            webregged = 1;
        }
    } else {
        if (webregged) {
            ast_http_uri_unlink(&rawmanuri);
            ast_http_uri_unlink(&manageruri);
            ast_http_uri_unlink(&managerxmluri);
 
            ast_http_uri_unlink(&arawmanuri);
            ast_http_uri_unlink(&amanageruri);
            ast_http_uri_unlink(&amanagerxmluri);
            webregged = 0;
        }
    }
 
    if (newhttptimeout > 0) {
        httptimeout = newhttptimeout;
    }
 
    ast_tcptls_server_start(&ami_desc);
    if (tls_was_enabled && !ami_tls_cfg.enabled) {
        ast_tcptls_server_stop(&amis_desc);
    } else if (ast_ssl_setup(amis_desc.tls_cfg)) {
        ast_tcptls_server_start(&amis_desc);
    }
 
    return 0;
}

References __ast_custom_function_register(), acl_change_stasis_subscribe(), acl_change_stasis_unsubscribe(), action_aocmessage(), action_atxfer(), action_blind_transfer(), action_cancel_atxfer(), action_challenge(), action_command(), action_coresettings(), action_coreshowchannelmap(), action_coreshowchannels(), action_corestatus(), action_createconfig(), action_events(), action_extensionstate(), action_filter(), action_getconfig(), action_getconfigjson(), action_getvar(), action_hangup(), action_listcategories(), action_listcommands(), action_loggerrotate(), action_login(), action_logoff(), action_mailboxcount(), action_mailboxstatus(), action_originate(), action_ping(), action_presencestate(), action_redirect(), action_reload(), action_sendtext(), action_setvar(), action_status(), action_timeout(), action_updateconfig(), action_userevent(), action_waitevent(), allowmultiplelogin, amanageruri, amanagerxmluri, ami_desc, ami_tls_cfg, amis_desc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_list, ao2_global_obj_replace_unref, ao2_ref, ao2_t_callback, ao2_t_global_obj_replace_unref, ao2_t_ref, append_event(), arawmanuri, ARRAY_LEN, ast_append_acl(), ast_begins_with(), ast_calloc, ast_category_browse(), ast_cli_register_multiple, ast_config_destroy(), ast_config_load2(), ast_copy_string(), ast_debug, ast_extension_state_add(), ast_free, ast_free_acl_list(), ast_http_uri_link(), ast_http_uri_unlink(), AST_LIST_INSERT_TAIL, ast_log, ast_manager_get_generic_type(), ast_manager_register_xml_core, ast_md5_hash(), ast_parse_arg(), AST_RWLIST_INSERT_TAIL, AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_sockaddr_copy(), ast_sockaddr_isnull(), ast_sockaddr_parse(), ast_sockaddr_port, ast_sockaddr_set_port, ast_sockaddr_stringify_addr(), ast_ssl_setup(), ast_str_hash(), ast_strdup, ast_strlen_zero(), ast_tcptls_server_start(), ast_tcptls_server_stop(), ast_tls_read_conf(), ast_true(), ast_variable_browse(), ast_variable_new, ast_variable_retrieve(), ast_variables_destroy(), ast_xmldoc_build_documentation(), authlimit, authtimeout, broken_events_action, cli_manager, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, DEFAULT_MANAGER_PORT, DEFAULT_MANAGER_TLS_PORT, displayconnects, ast_tls_config::enabled, EVENT_FLAG_AOC, EVENT_FLAG_CALL, EVENT_FLAG_COMMAND, EVENT_FLAG_CONFIG, EVENT_FLAG_ORIGINATE, EVENT_FLAG_REPORTING, EVENT_FLAG_SYSTEM, EVENT_FLAG_USER, get_manager_by_name_locked(), get_perm(), global_realm, httptimeout, load_channelvars(), load_disabledevents(), ast_tcptls_session_args::local_address, LOG_ERROR, LOG_NOTICE, LOG_WARNING, manager_add_filter(), manager_debug, manager_enabled, manager_free_user(), manager_modulecheck(), manager_moduleload(), manager_set_defaults(), manager_state_cb(), manager_topic, managerclient_function, manageruri, managerxmluri, mansession_cmp_fn(), ast_variable::next, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_UNLINK, PARSE_ADDR, PARSE_IN_RANGE, PARSE_PORT_IGNORE, PARSE_UINT32, rawmanuri, reload(), sessions, stasis_forward_all(), STASIS_MESSAGE_TYPE_INIT, stasis_topic_create(), subscribe_all(), subscribed, timestampevents, ast_tcptls_session_args::tls_cfg, value, var, webmanager_enabled, and webregged.

Referenced by acl_change_stasis_cb(), load_module(), and reload_module().

__reg_module()

static void __reg_module ( void  )

static

Definition at line 10269 of file manager.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 10269 of file manager.c.

ast_manager_event_blob_create()

struct ast_manager_event_blob * ast_manager_event_blob_create	(	int	event_flags,
		const char *	manager_event,
		const char *	extra_fields_fmt,
			...
	)

Construct a ast_manager_event_blob.

Since

12

The returned object is AO2 managed, so clean up with ao2_cleanup().

Parameters

event_flags	Flags the event should be raised with.
manager_event	The event to be raised, should be a string literal.
extra_fields_fmt	Format string for extra fields to include. Or NO_EXTRA_FIELDS for no extra fields.

Returns

New ast_manager_event_blob object.

Return values

NULL

on error.

Definition at line 10230 of file manager.c.

{
    struct ast_manager_event_blob *ev;
    va_list argp;
 
    ast_assert(extra_fields_fmt != NULL);
    ast_assert(manager_event != NULL);
 
    ev = ao2_alloc_options(sizeof(*ev), manager_event_blob_dtor, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!ev) {
        return NULL;
    }
 
    if (ast_string_field_init(ev, 20)) {
        ao2_ref(ev, -1);
        return NULL;
    }
 
    ev->manager_event = manager_event;
    ev->event_flags = event_flags;
 
    va_start(argp, extra_fields_fmt);
    ast_string_field_ptr_build_va(ev, &ev->extra_fields, extra_fields_fmt, argp);
    va_end(argp);
 
    return ev;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_assert, ast_string_field_init, ast_string_field_ptr_build_va, ast_manager_event_blob::event_flags, ast_manager_event_blob::extra_fields, manager_event, ast_manager_event_blob::manager_event, manager_event_blob_dtor(), and NULL.

Referenced by agent_login_to_ami(), agent_logoff_to_ami(), agi_channel_to_ami(), aoc_to_ami(), attended_transfer_to_ami(), blind_transfer_to_ami(), bridge_create(), bridge_destroy(), bridge_video_update(), call_pickup_to_ami(), cc_available_to_ami(), cc_callerrecalling_to_ami(), cc_callerstartmonitoring_to_ami(), cc_callerstopmonitoring_to_ami(), cc_failure_to_ami(), cc_monitorfailed_to_ami(), cc_offertimerstart_to_ami(), cc_recallcomplete_to_ami(), cc_requestacknowledged_to_ami(), cc_requested_to_ami(), channel_new_accountcode(), channel_new_callerid(), channel_new_connected_line(), channel_newexten(), channel_state_change(), contactstatus_to_ami(), dahdichannel_to_ami(), devstate_to_ami(), fake_ami(), local_message_to_ami(), multi_user_event_to_ami(), peerstatus_to_ami(), presence_state_to_ami(), queue_channel_to_ami(), queue_member_to_ami(), queue_multi_channel_to_ami(), rtcp_report_to_ami(), security_event_to_ami_blob(), system_registry_to_ami(), talking_start_to_ami(), talking_stop_to_ami(), and varset_to_ami().

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 10269 of file manager.c.

ast_str_append_event_header()

int ast_str_append_event_header	(	struct ast_str **	fields_string,
		const char *	header,
		const char *	value
	)

append an event header to an ast string

Since

12

Parameters

fields_string	pointer to an ast_string pointer. It may be a pointer to a NULL ast_str pointer, in which case the ast_str will be initialized.
header	The header being applied
value	the value of the header

Return values

0	if successful
non-zero	on failure

Definition at line 10208 of file manager.c.

{
    if (!*fields_string) {
        *fields_string = ast_str_create(128);
        if (!*fields_string) {
            return -1;
        }
    }
 
    return (ast_str_append(fields_string, 0, "%s: %s\r\n", header, value) < 0) ? -1 : 0;
}

References ast_str_append(), ast_str_create, and value.

Referenced by confbridge_talking_cb(), get_bool_header(), and meetme_stasis_cb().

ast_xml_doc_item_cmp_fn()

static int ast_xml_doc_item_cmp_fn ( const void *  a, const void *  b  )

static

Definition at line 9168 of file manager.c.

{
    struct ast_xml_doc_item **item_a = (struct ast_xml_doc_item **)a;
    struct ast_xml_doc_item **item_b = (struct ast_xml_doc_item **)b;
    return strcmp((*item_a)->name, (*item_b)->name);
}

References a, and b.

Referenced by handle_manager_show_events().

astman_datastore_add()

int astman_datastore_add	(	struct mansession *	s,
		struct ast_datastore *	datastore
	)

Add a datastore to a session.

Return values

0	success
non-zero	failure

Since

1.6.1

Definition at line 10169 of file manager.c.

{
    AST_LIST_INSERT_HEAD(&s->session->datastores, datastore, entry);
 
    return 0;
}

References AST_LIST_INSERT_HEAD, mansession_session::datastores, and mansession::session.

astman_datastore_find()

struct ast_datastore * astman_datastore_find	(	struct mansession *	s,
		const struct ast_datastore_info *	info,
		const char *	uid
	)

Find a datastore on a session.

Returns

pointer to the datastore if found

Return values

NULL	if not found

Since

1.6.1

Definition at line 10181 of file manager.c.

{
    struct ast_datastore *datastore = NULL;
 
    if (info == NULL)
        return NULL;
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(&s->session->datastores, datastore, entry) {
        if (datastore->info != info) {
            continue;
        }
 
        if (uid == NULL) {
            /* matched by type only */
            break;
        }
 
        if ((datastore->uid != NULL) && !strcasecmp(uid, datastore->uid)) {
            /* Matched by type AND uid */
            break;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    return datastore;
}

References AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, mansession_session::datastores, ast_datastore::entry, sip_to_pjsip::info(), ast_datastore::info, NULL, mansession::session, and ast_datastore::uid.

astman_datastore_remove()

int astman_datastore_remove	(	struct mansession *	s,
		struct ast_datastore *	datastore
	)

Remove a datastore from a session.

Return values

0	success
non-zero	failure

Since

1.6.1

Definition at line 10176 of file manager.c.

{
    return AST_LIST_REMOVE(&s->session->datastores, datastore, entry) ? 0 : -1;
}

References AST_LIST_REMOVE, mansession_session::datastores, and mansession::session.

astman_is_authed()

int astman_is_authed

(

uint32_t

ident

)

Determine if a manager session ident is authenticated.

Definition at line 7991 of file manager.c.

{
    int authed;
    struct mansession_session *session;
 
    if (!(session = find_session(ident, 0)))
        return 0;
 
    authed = (session->authenticated != 0);
 
    ao2_unlock(session);
    unref_mansession(session);
 
    return authed;
}

References ao2_unlock, find_session(), session, and unref_mansession().

Referenced by http_post_callback(), and static_callback().

astman_verify_session_readpermissions()

int astman_verify_session_readpermissions	(	uint32_t	ident,
		int	perm
	)

Verify a session's read permissions against a permission mask.

Parameters

ident	session identity
perm	permission mask to verify

Return values

1	if the session has the permission mask capabilities
0	otherwise

Definition at line 8007 of file manager.c.

{
    int result = 0;
    struct mansession_session *session;
    struct ao2_container *sessions;
    struct ao2_iterator i;
 
    if (ident == 0) {
        return 0;
    }
 
    sessions = ao2_global_obj_ref(mgr_sessions);
    if (!sessions) {
        return 0;
    }
    i = ao2_iterator_init(sessions, 0);
    ao2_ref(sessions, -1);
    while ((session = ao2_iterator_next(&i))) {
        ao2_lock(session);
        if ((session->managerid == ident) && (session->readperm & perm)) {
            result = 1;
            ao2_unlock(session);
            unref_mansession(session);
            break;
        }
        ao2_unlock(session);
        unref_mansession(session);
    }
    ao2_iterator_destroy(&i);
 
    return result;
}

References ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, result, session, sessions, and unref_mansession().

astman_verify_session_writepermissions()

int astman_verify_session_writepermissions	(	uint32_t	ident,
		int	perm
	)

Verify a session's write permissions against a permission mask.

Parameters

ident	session identity
perm	permission mask to verify

Return values

1	if the session has the permission mask capabilities, otherwise 0
0	otherwise

Definition at line 8040 of file manager.c.

{
    int result = 0;
    struct mansession_session *session;
    struct ao2_container *sessions;
    struct ao2_iterator i;
 
    if (ident == 0) {
        return 0;
    }
 
    sessions = ao2_global_obj_ref(mgr_sessions);
    if (!sessions) {
        return 0;
    }
    i = ao2_iterator_init(sessions, 0);
    ao2_ref(sessions, -1);
    while ((session = ao2_iterator_next(&i))) {
        ao2_lock(session);
        if ((session->managerid == ident) && (session->writeperm & perm)) {
            result = 1;
            ao2_unlock(session);
            unref_mansession(session);
            break;
        }
        ao2_unlock(session);
        unref_mansession(session);
    }
    ao2_iterator_destroy(&i);
 
    return result;
}

References ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, result, session, sessions, and unref_mansession().

Referenced by http_post_callback().

auth_http_callback()

static int auth_http_callback ( struct ast_tcptls_session_instance *  ser, enum ast_http_method  method, enum output_format  format, const struct ast_sockaddr *  remote_address, const char *  uri, struct ast_variable *  get_params, struct ast_variable *  headers  )

static

Definition at line 8569 of file manager.c.

{
    struct mansession_session *session = NULL;
    struct mansession s = { .session = NULL, .tcptls_session = ser };
    struct ast_variable *v, *params = get_params;
    char template[] = "/tmp/ast-http-XXXXXX";   /* template for temporary file */
    struct ast_str *http_header = NULL, *out = NULL;
    size_t result_size;
    struct message m = { 0 };
    int fd;
 
    time_t time_now = time(NULL);
    unsigned long nonce = 0, nc;
    struct ast_http_digest d = { NULL, };
    struct ast_manager_user *user = NULL;
    int stale = 0;
    char resp_hash[256]="";
    /* Cache for user data */
    char u_username[80];
    int u_readperm;
    int u_writeperm;
    int u_writetimeout;
    int u_displayconnects;
 
    if (method != AST_HTTP_GET && method != AST_HTTP_HEAD && method != AST_HTTP_POST) {
        ast_http_error(ser, 501, "Not Implemented", "Attempt to use unimplemented / unsupported method");
        return 0;
    }
 
    /* Find "Authorization: " header */
    for (v = headers; v; v = v->next) {
        if (!strcasecmp(v->name, "Authorization")) {
            break;
        }
    }
 
    if (!v || ast_strlen_zero(v->value)) {
        goto out_401; /* Authorization Header not present - send auth request */
    }
 
    /* Digest found - parse */
    if (ast_string_field_init(&d, 128)) {
        ast_http_request_close_on_completion(ser);
        ast_http_error(ser, 500, "Server Error", "Internal Server Error (out of memory)");
        return 0;
    }
 
    if (ast_parse_digest(v->value, &d, 0, 1)) {
        /* Error in Digest - send new one */
        nonce = 0;
        goto out_401;
    }
    if (sscanf(d.nonce, "%30lx", &nonce) != 1) {
        ast_log(LOG_WARNING, "Received incorrect nonce in Digest <%s>\n", d.nonce);
        nonce = 0;
        goto out_401;
    }
 
    AST_RWLIST_WRLOCK(&users);
    user = get_manager_by_name_locked(d.username);
    if(!user) {
        AST_RWLIST_UNLOCK(&users);
        ast_log(LOG_NOTICE, "%s tried to authenticate with nonexistent user '%s'\n", ast_sockaddr_stringify_addr(&session->addr), d.username);
        nonce = 0;
        goto out_401;
    }
 
    /* --- We have User for this auth, now check ACL */
    if (user->acl && !ast_apply_acl(user->acl, remote_address, "Manager User ACL:")) {
        AST_RWLIST_UNLOCK(&users);
        ast_log(LOG_NOTICE, "%s failed to pass IP ACL as '%s'\n", ast_sockaddr_stringify_addr(&session->addr), d.username);
        ast_http_request_close_on_completion(ser);
        ast_http_error(ser, 403, "Permission denied", "Permission denied");
        return 0;
    }
 
    /* --- We have auth, so check it */
 
    /* compute the expected response to compare with what we received */
    {
        char *a2;
        /* ast_md5_hash outputs 32 characters plus NULL terminator. */
        char a2_hash[33];
        char resp[256];
 
        /* XXX Now request method are hardcoded in A2 */
        if (ast_asprintf(&a2, "%s:%s", ast_get_http_method(method), d.uri) < 0) {
            AST_RWLIST_UNLOCK(&users);
            ast_http_request_close_on_completion(ser);
            ast_http_error(ser, 500, "Server Error", "Internal Server Error (out of memory)");
            return 0;
        }
 
        ast_md5_hash(a2_hash, a2);
        ast_free(a2);
 
        if (d.qop) {
            /* RFC 2617 */
            snprintf(resp, sizeof(resp), "%s:%08lx:%s:%s:auth:%s", user->a1_hash, nonce, d.nc, d.cnonce, a2_hash);
        }  else {
            /* RFC 2069 */
            snprintf(resp, sizeof(resp), "%s:%08lx:%s", user->a1_hash, nonce, a2_hash);
        }
        ast_md5_hash(resp_hash, resp);
    }
 
    if (strncasecmp(d.response, resp_hash, strlen(resp_hash))) {
        /* Something was wrong, so give the client to try with a new challenge */
        AST_RWLIST_UNLOCK(&users);
        nonce = 0;
        goto out_401;
    }
 
    /*
     * User are pass Digest authentication.
     * Now, cache the user data and unlock user list.
     */
    ast_copy_string(u_username, user->username, sizeof(u_username));
    u_readperm = user->readperm;
    u_writeperm = user->writeperm;
    u_displayconnects = user->displayconnects;
    u_writetimeout = user->writetimeout;
    AST_RWLIST_UNLOCK(&users);
 
    if (!(session = find_session_by_nonce(d.username, nonce, &stale))) {
        /*
         * Create new session.
         * While it is not in the list we don't need any locking
         */
        if (!(session = build_mansession(remote_address))) {
            ast_http_request_close_on_completion(ser);
            ast_http_error(ser, 500, "Server Error", "Internal Server Error (out of memory)");
            return 0;
        }
        ao2_lock(session);
 
        ast_copy_string(session->username, u_username, sizeof(session->username));
        session->managerid = nonce;
        session->last_ev = grab_last();
        AST_LIST_HEAD_INIT_NOLOCK(&session->datastores);
 
        session->readperm = u_readperm;
        session->writeperm = u_writeperm;
        session->writetimeout = u_writetimeout;
 
        if (u_displayconnects) {
            ast_verb(2, "HTTP Manager '%s' logged in from %s\n", session->username, ast_sockaddr_stringify_addr(&session->addr));
        }
        session->noncetime = session->sessionstart = time_now;
        session->authenticated = 1;
    } else if (stale) {
        /*
         * Session found, but nonce is stale.
         *
         * This could be because an old request (w/old nonce) arrived.
         *
         * This may be as the result of http proxy usage (separate delay or
         * multipath) or in a situation where a page was refreshed too quickly
         * (seen in Firefox).
         *
         * In this situation, we repeat the 401 auth with the current nonce
         * value.
         */
        nonce = session->managerid;
        ao2_unlock(session);
        stale = 1;
        goto out_401;
    } else {
        sscanf(d.nc, "%30lx", &nc);
        if (session->nc >= nc || ((time_now - session->noncetime) > 62) ) {
            /*
             * Nonce time expired (> 2 minutes) or something wrong with nonce
             * counter.
             *
             * Create new nonce key and resend Digest auth request. Old nonce
             * is saved for stale checking...
             */
            session->nc = 0; /* Reset nonce counter */
            session->oldnonce = session->managerid;
            nonce = session->managerid = ast_random();
            session->noncetime = time_now;
            ao2_unlock(session);
            stale = 1;
            goto out_401;
        } else {
            session->nc = nc; /* All OK, save nonce counter */
        }
    }
 
 
    /* Reset session timeout. */
    session->sessiontimeout = time(NULL) + (httptimeout > 5 ? httptimeout : 5);
    ao2_unlock(session);
 
    ast_mutex_init(&s.lock);
    s.session = session;
    fd = mkstemp(template); /* create a temporary file for command output */
    unlink(template);
    if (fd <= -1) {
        ast_http_error(ser, 500, "Server Error", "Internal Server Error (mkstemp failed)");
        goto auth_callback_out;
    }
    s.stream = ast_iostream_from_fd(&fd);
    if (!s.stream) {
        ast_log(LOG_WARNING, "HTTP Manager, fdopen failed: %s!\n", strerror(errno));
        ast_http_error(ser, 500, "Server Error", "Internal Server Error (fdopen failed)");
        close(fd);
        goto auth_callback_out;
    }
 
    if (method == AST_HTTP_POST) {
        params = ast_http_get_post_vars(ser, headers);
        if (!params) {
            switch (errno) {
            case EFBIG:
                ast_http_error(ser, 413, "Request Entity Too Large", "Body too large");
                close_mansession_file(&s);
                goto auth_callback_out;
            case ENOMEM:
                ast_http_request_close_on_completion(ser);
                ast_http_error(ser, 500, "Server Error", "Out of memory");
                close_mansession_file(&s);
                goto auth_callback_out;
            case EIO:
                ast_http_error(ser, 400, "Bad Request", "Error parsing request body");
                close_mansession_file(&s);
                goto auth_callback_out;
            }
        }
    }
 
    astman_append_headers(&m, params);
 
    if (process_message(&s, &m)) {
        if (u_displayconnects) {
            ast_verb(2, "HTTP Manager '%s' logged off from %s\n", session->username, ast_sockaddr_stringify_addr(&session->addr));
        }
 
        session->needdestroy = 1;
    }
 
    astman_free_headers(&m);
 
    result_size = lseek(ast_iostream_get_fd(s.stream), 0, SEEK_CUR); /* Calculate approx. size of result */
 
    http_header = ast_str_create(80);
    out = ast_str_create(result_size * 2 + 512);
    if (http_header == NULL || out == NULL) {
        ast_http_request_close_on_completion(ser);
        ast_http_error(ser, 500, "Server Error", "Internal Server Error (ast_str_create() out of memory)");
        close_mansession_file(&s);
        goto auth_callback_out;
    }
 
    ast_str_append(&http_header, 0, "Content-type: text/%s\r\n", contenttype[format]);
 
    if (format == FORMAT_XML) {
        ast_str_append(&out, 0, "<ajax-response>\n");
    } else if (format == FORMAT_HTML) {
        ast_str_append(&out, 0,
        "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\r\n"
        "<html><head>\r\n"
        "<title>Asterisk&trade; Manager Interface</title>\r\n"
        "</head><body style=\"background-color: #ffffff;\">\r\n"
        "<form method=\"POST\">\r\n"
        "<table align=\"center\" style=\"background-color: #f1f1f1;\" width=\"500\">\r\n"
        "<tr><th colspan=\"2\" style=\"background-color: #f1f1ff;\"><h1>Manager Tester</h1></th></tr>\r\n"
        "<tr><th colspan=\"2\" style=\"background-color: #f1f1ff;\">Action: <input name=\"action\" /> Cmd: <input name=\"command\" /><br>"
        "<input type=\"submit\" value=\"Send request\" /></th></tr>\r\n");
    }
 
    process_output(&s, &out, params, format);
 
    if (format == FORMAT_XML) {
        ast_str_append(&out, 0, "</ajax-response>\n");
    } else if (format == FORMAT_HTML) {
        ast_str_append(&out, 0, "</table></form></body></html>\r\n");
    }
 
    ast_http_send(ser, method, 200, NULL, http_header, out, 0, 0);
    http_header = NULL;
    out = NULL;
 
auth_callback_out:
    ast_mutex_destroy(&s.lock);
 
    /* Clear resources and unlock manager session */
    if (method == AST_HTTP_POST && params) {
        ast_variables_destroy(params);
    }
 
    ast_free(http_header);
    ast_free(out);
 
    ao2_lock(session);
    if (session->stream) {
        ast_iostream_close(session->stream);
        session->stream = NULL;
    }
    ao2_unlock(session);
 
    if (session->needdestroy) {
        ast_debug(1, "Need destroy, doing it now!\n");
        session_destroy(session);
    }
    ast_string_field_free_memory(&d);
    return 0;
 
out_401:
    if (!nonce) {
        nonce = ast_random();
    }
 
    ast_http_auth(ser, global_realm, nonce, nonce, stale, NULL);
    ast_string_field_free_memory(&d);
    return 0;
}

References ao2_lock, ao2_unlock, ast_apply_acl(), ast_asprintf, ast_copy_string(), ast_debug, ast_free, ast_get_http_method(), ast_http_auth(), ast_http_error(), AST_HTTP_GET, ast_http_get_post_vars(), AST_HTTP_HEAD, AST_HTTP_POST, ast_http_request_close_on_completion(), ast_http_send(), ast_iostream_close(), ast_iostream_from_fd(), ast_iostream_get_fd(), AST_LIST_HEAD_INIT_NOLOCK, ast_log, ast_md5_hash(), ast_mutex_destroy, ast_mutex_init, ast_parse_digest(), ast_random(), AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_sockaddr_stringify_addr(), ast_str_append(), ast_str_create, ast_string_field_free_memory, ast_string_field_init, ast_strlen_zero(), ast_variables_destroy(), ast_verb, astman_append_headers(), astman_free_headers(), build_mansession(), close_mansession_file(), contenttype, d, errno, find_session_by_nonce(), FORMAT_HTML, FORMAT_XML, get_manager_by_name_locked(), global_realm, grab_last(), httptimeout, mansession::lock, LOG_NOTICE, LOG_WARNING, method, ast_variable::name, ast_variable::next, NULL, out, process_message(), process_output(), mansession::session, session, session_destroy(), mansession::stream, and ast_variable::value.

Referenced by auth_manager_http_callback(), auth_mxml_http_callback(), and auth_rawman_http_callback().

auth_manager_http_callback()

static int auth_manager_http_callback ( struct ast_tcptls_session_instance *  ser, const struct ast_http_uri *  urih, const char *  uri, enum ast_http_method  method, struct ast_variable *  get_params, struct ast_variable *  headers  )

static

Definition at line 8951 of file manager.c.

{
    int retval;
    struct ast_sockaddr ser_remote_address_tmp;
 
    ast_sockaddr_copy(&ser_remote_address_tmp, &ser->remote_address);
    retval = auth_http_callback(ser, method, FORMAT_HTML, &ser_remote_address_tmp, uri, get_params, headers);
    ast_sockaddr_copy(&ser->remote_address, &ser_remote_address_tmp);
    return retval;
}

References ast_sockaddr_copy(), auth_http_callback(), FORMAT_HTML, method, and ast_tcptls_session_instance::remote_address.

auth_mxml_http_callback()

static int auth_mxml_http_callback ( struct ast_tcptls_session_instance *  ser, const struct ast_http_uri *  urih, const char *  uri, enum ast_http_method  method, struct ast_variable *  get_params, struct ast_variable *  headers  )

static

Definition at line 8962 of file manager.c.

{
    int retval;
    struct ast_sockaddr ser_remote_address_tmp;
 
    ast_sockaddr_copy(&ser_remote_address_tmp, &ser->remote_address);
    retval = auth_http_callback(ser, method, FORMAT_XML, &ser_remote_address_tmp, uri, get_params, headers);
    ast_sockaddr_copy(&ser->remote_address, &ser_remote_address_tmp);
    return retval;
}

References ast_sockaddr_copy(), auth_http_callback(), FORMAT_XML, method, and ast_tcptls_session_instance::remote_address.

auth_rawman_http_callback()

static int auth_rawman_http_callback ( struct ast_tcptls_session_instance *  ser, const struct ast_http_uri *  urih, const char *  uri, enum ast_http_method  method, struct ast_variable *  get_params, struct ast_variable *  headers  )

static

Definition at line 8973 of file manager.c.

{
    int retval;
    struct ast_sockaddr ser_remote_address_tmp;
 
    ast_sockaddr_copy(&ser_remote_address_tmp, &ser->remote_address);
    retval = auth_http_callback(ser, method, FORMAT_RAW, &ser_remote_address_tmp, uri, get_params, headers);
    ast_sockaddr_copy(&ser->remote_address, &ser_remote_address_tmp);
    return retval;
}

References ast_sockaddr_copy(), auth_http_callback(), FORMAT_RAW, method, and ast_tcptls_session_instance::remote_address.

close_mansession_file()

static void close_mansession_file ( struct mansession *  s )

static

Definition at line 8314 of file manager.c.

{
    if (s->stream) {
        ast_iostream_close(s->stream);
        s->stream = NULL;
    } else {
        ast_log(LOG_ERROR, "Attempted to close file/file descriptor on mansession without a valid file or file descriptor.\n");
    }
}

References ast_iostream_close(), ast_log, LOG_ERROR, NULL, and mansession::stream.

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

find_session()

static struct mansession_session * find_session ( uint32_t  ident, int  incinuse  )

static

locate an http session in the list. The search key (ident) is the value of the mansession_id cookie (0 is not valid and means a session on the AMI socket).

Definition at line 7919 of file manager.c.

{
    struct ao2_container *sessions;
    struct mansession_session *session;
    struct ao2_iterator i;
 
    if (ident == 0) {
        return NULL;
    }
 
    sessions = ao2_global_obj_ref(mgr_sessions);
    if (!sessions) {
        return NULL;
    }
    i = ao2_iterator_init(sessions, 0);
    ao2_ref(sessions, -1);
    while ((session = ao2_iterator_next(&i))) {
        ao2_lock(session);
        if (session->managerid == ident && !session->needdestroy) {
            ast_atomic_fetchadd_int(&session->inuse, incinuse ? 1 : 0);
            break;
        }
        ao2_unlock(session);
        unref_mansession(session);
    }
    ao2_iterator_destroy(&i);
 
    return session;
}

References ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_atomic_fetchadd_int(), NULL, session, sessions, and unref_mansession().

Referenced by astman_is_authed(), generic_http_callback(), and manager_fax_session().

find_session_by_nonce()

static struct mansession_session * find_session_by_nonce ( const char *  username, unsigned long  nonce, int *  stale  )

static

locate an http session in the list. The search keys (nonce) and (username) is value from received "Authorization" http header. As well as in find_session() function, the value of the nonce can't be zero. (0 meansi, that the session used for AMI socket connection). Flag (stale) is set, if client used valid, but old, nonce value.

Definition at line 7958 of file manager.c.

{
    struct mansession_session *session;
    struct ao2_container *sessions;
    struct ao2_iterator i;
 
    if (nonce == 0 || username == NULL || stale == NULL) {
        return NULL;
    }
 
    sessions = ao2_global_obj_ref(mgr_sessions);
    if (!sessions) {
        return NULL;
    }
    i = ao2_iterator_init(sessions, 0);
    ao2_ref(sessions, -1);
    while ((session = ao2_iterator_next(&i))) {
        ao2_lock(session);
        if (!strcasecmp(session->username, username) && session->managerid == nonce) {
            *stale = 0;
            break;
        } else if (!strcasecmp(session->username, username) && session->oldnonce == nonce) {
            *stale = 1;
            break;
        }
        ao2_unlock(session);
        unref_mansession(session);
    }
    ao2_iterator_destroy(&i);
 
    return session;
}

References ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, NULL, session, sessions, and unref_mansession().

Referenced by auth_http_callback().

function_amiclient()

static int function_amiclient ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len  )

static

${AMI_CLIENT()} Dialplan function - reads manager client data

Definition at line 9027 of file manager.c.

{
    struct ast_manager_user *user = NULL;
 
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(name);
        AST_APP_ARG(param);
    );
 
 
    if (ast_strlen_zero(data) ) {
        ast_log(LOG_WARNING, "AMI_CLIENT() requires two arguments: AMI_CLIENT(<name>[,<arg>])\n");
        return -1;
    }
    AST_STANDARD_APP_ARGS(args, data);
    args.name = ast_strip(args.name);
    args.param = ast_strip(args.param);
 
    AST_RWLIST_RDLOCK(&users);
    if (!(user = get_manager_by_name_locked(args.name))) {
        AST_RWLIST_UNLOCK(&users);
        ast_log(LOG_ERROR, "There's no manager user called : \"%s\"\n", args.name);
        return -1;
    }
    AST_RWLIST_UNLOCK(&users);
 
    if (!strcasecmp(args.param, "sessions")) {
        int no_sessions = 0;
        struct ao2_container *sessions;
 
        sessions = ao2_global_obj_ref(mgr_sessions);
        if (sessions) {
            ao2_callback_data(sessions, 0, get_manager_sessions_cb, /*login name*/ data, &no_sessions);
            ao2_ref(sessions, -1);
        }
        snprintf(buf, len, "%d", no_sessions);
    } else {
        ast_log(LOG_ERROR, "Invalid arguments provided to function AMI_CLIENT: %s\n", args.param);
        return -1;
 
    }
 
    return 0;
}

References ao2_callback_data, ao2_global_obj_ref, ao2_ref, args, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_log, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, AST_STANDARD_APP_ARGS, ast_strip(), ast_strlen_zero(), buf, get_manager_by_name_locked(), get_manager_sessions_cb(), len(), LOG_ERROR, LOG_WARNING, name, NULL, and sessions.

generic_http_callback()

static int generic_http_callback ( struct ast_tcptls_session_instance *  ser, enum ast_http_method  method, enum output_format  format, const struct ast_sockaddr *  remote_address, const char *  uri, struct ast_variable *  get_params, struct ast_variable *  headers  )

static

Note

There is approximately a 1 in 1.8E19 chance that the following calculation will produce 0, which is an invalid ID, but due to the properties of the rand() function (and the constancy of s), that won't happen twice in a row.

Definition at line 8357 of file manager.c.

{
    struct mansession s = { .session = NULL, .tcptls_session = ser };
    struct mansession_session *session = NULL;
    uint32_t ident;
    int fd;
    int blastaway = 0;
    struct ast_variable *params = get_params;
    char template[] = "/tmp/ast-http-XXXXXX";   /* template for temporary file */
    struct ast_str *http_header = NULL, *out = NULL;
    struct message m = { 0 };
 
    if (method != AST_HTTP_GET && method != AST_HTTP_HEAD && method != AST_HTTP_POST) {
        ast_http_error(ser, 501, "Not Implemented", "Attempt to use unimplemented / unsupported method");
        return 0;
    }
 
    ident = ast_http_manid_from_vars(headers);
 
    if (!(session = find_session(ident, 1))) {
 
        /**/
        /* Create new session.
         * While it is not in the list we don't need any locking
         */
        if (!(session = build_mansession(remote_address))) {
            ast_http_request_close_on_completion(ser);
            ast_http_error(ser, 500, "Server Error", "Internal Server Error (out of memory)");
            return 0;
        }
        ao2_lock(session);
        session->send_events = 0;
        session->inuse = 1;
        /*!
         * \note There is approximately a 1 in 1.8E19 chance that the following
         * calculation will produce 0, which is an invalid ID, but due to the
         * properties of the rand() function (and the constancy of s), that
         * won't happen twice in a row.
         */
        while ((session->managerid = ast_random() ^ (unsigned long) session) == 0) {
        }
        session->last_ev = grab_last();
        AST_LIST_HEAD_INIT_NOLOCK(&session->datastores);
    }
    ao2_unlock(session);
 
    http_header = ast_str_create(128);
    out = ast_str_create(2048);
 
    ast_mutex_init(&s.lock);
 
    if (http_header == NULL || out == NULL) {
        ast_http_request_close_on_completion(ser);
        ast_http_error(ser, 500, "Server Error", "Internal Server Error (ast_str_create() out of memory)");
        goto generic_callback_out;
    }
 
    s.session = session;
    fd = mkstemp(template); /* create a temporary file for command output */
    unlink(template);
    if (fd <= -1) {
        ast_http_error(ser, 500, "Server Error", "Internal Server Error (mkstemp failed)");
        goto generic_callback_out;
    }
    s.stream = ast_iostream_from_fd(&fd);
    if (!s.stream) {
        ast_log(LOG_WARNING, "HTTP Manager, fdopen failed: %s!\n", strerror(errno));
        ast_http_error(ser, 500, "Server Error", "Internal Server Error (fdopen failed)");
        close(fd);
        goto generic_callback_out;
    }
 
    if (method == AST_HTTP_POST) {
        params = ast_http_get_post_vars(ser, headers);
        if (!params) {
            switch (errno) {
            case EFBIG:
                ast_http_error(ser, 413, "Request Entity Too Large", "Body too large");
                close_mansession_file(&s);
                goto generic_callback_out;
            case ENOMEM:
                ast_http_request_close_on_completion(ser);
                ast_http_error(ser, 500, "Server Error", "Out of memory");
                close_mansession_file(&s);
                goto generic_callback_out;
            case EIO:
                ast_http_error(ser, 400, "Bad Request", "Error parsing request body");
                close_mansession_file(&s);
                goto generic_callback_out;
            }
        }
    }
 
    astman_append_headers(&m, params);
 
    if (process_message(&s, &m)) {
        if (session->authenticated) {
            if (manager_displayconnects(session)) {
                ast_verb(2, "HTTP Manager '%s' logged off from %s\n", session->username, ast_sockaddr_stringify_addr(&session->addr));
            }
        } else {
            if (displayconnects) {
                ast_verb(2, "HTTP Connect attempt from '%s' unable to authenticate\n", ast_sockaddr_stringify_addr(&session->addr));
            }
        }
        session->needdestroy = 1;
    }
 
    astman_free_headers(&m);
 
    ast_str_append(&http_header, 0,
        "Content-type: text/%s\r\n"
        "Set-Cookie: mansession_id=\"%08x\"; Version=1; Max-Age=%d\r\n"
        "Pragma: SuppressEvents\r\n",
        contenttype[format],
        session->managerid, httptimeout);
 
    if (format == FORMAT_XML) {
        ast_str_append(&out, 0, "<ajax-response>\n");
    } else if (format == FORMAT_HTML) {
        /*
         * When handling AMI-over-HTTP in HTML format, we provide a simple form for
         * debugging purposes. This HTML code should not be here, we
         * should read from some config file...
         */
 
#define ROW_FMT "<tr><td colspan=\"2\" bgcolor=\"#f1f1ff\">%s</td></tr>\r\n"
#define TEST_STRING \
    "<form action=\"manager\" method=\"post\">\n\
    Action: <select name=\"action\">\n\
        <option value=\"\">-----&gt;</option>\n\
        <option value=\"login\">login</option>\n\
        <option value=\"command\">Command</option>\n\
        <option value=\"waitevent\">waitevent</option>\n\
        <option value=\"listcommands\">listcommands</option>\n\
    </select>\n\
    or <input name=\"action\"><br/>\n\
    CLI Command <input name=\"command\"><br>\n\
    user <input name=\"username\"> pass <input type=\"password\" name=\"secret\"><br>\n\
    <input type=\"submit\">\n</form>\n"
 
        ast_str_append(&out, 0, "<title>Asterisk&trade; Manager Interface</title>");
        ast_str_append(&out, 0, "<body bgcolor=\"#ffffff\"><table align=center bgcolor=\"#f1f1f1\" width=\"500\">\r\n");
        ast_str_append(&out, 0, ROW_FMT, "<h1>Manager Tester</h1>");
        ast_str_append(&out, 0, ROW_FMT, TEST_STRING);
    }
 
    process_output(&s, &out, params, format);
 
    if (format == FORMAT_XML) {
        ast_str_append(&out, 0, "</ajax-response>\n");
    } else if (format == FORMAT_HTML) {
        ast_str_append(&out, 0, "</table></body>\r\n");
    }
 
    ao2_lock(session);
    /* Reset HTTP timeout.  If we're not authenticated, keep it extremely short */
    session->sessiontimeout = time(NULL) + ((session->authenticated || httptimeout < 5) ? httptimeout : 5);
 
    if (session->needdestroy) {
        if (session->inuse == 1) {
            ast_debug(1, "Need destroy, doing it now!\n");
            blastaway = 1;
        } else {
            ast_debug(1, "Need destroy, but can't do it yet!\n");
            ast_mutex_lock(&session->notify_lock);
            if (session->waiting_thread != AST_PTHREADT_NULL) {
                pthread_kill(session->waiting_thread, SIGURG);
            }
            ast_mutex_unlock(&session->notify_lock);
            session->inuse--;
        }
    } else {
        session->inuse--;
    }
    ao2_unlock(session);
 
    ast_http_send(ser, method, 200, NULL, http_header, out, 0, 0);
    http_header = NULL;
    out = NULL;
 
generic_callback_out:
    ast_mutex_destroy(&s.lock);
 
    /* Clear resource */
 
    if (method == AST_HTTP_POST && params) {
        ast_variables_destroy(params);
    }
    ast_free(http_header);
    ast_free(out);
 
    if (session) {
        if (blastaway) {
            session_destroy(session);
        } else {
            if (session->stream) {
                ast_iostream_close(session->stream);
                session->stream = NULL;
            }
            unref_mansession(session);
        }
    }
 
    return 0;
}

References ao2_lock, ao2_unlock, ast_debug, ast_free, ast_http_error(), AST_HTTP_GET, ast_http_get_post_vars(), AST_HTTP_HEAD, ast_http_manid_from_vars(), AST_HTTP_POST, ast_http_request_close_on_completion(), ast_http_send(), ast_iostream_close(), ast_iostream_from_fd(), AST_LIST_HEAD_INIT_NOLOCK, ast_log, ast_mutex_destroy, ast_mutex_init, ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, ast_random(), ast_sockaddr_stringify_addr(), ast_str_append(), ast_str_create, ast_variables_destroy(), ast_verb, astman_append_headers(), astman_free_headers(), build_mansession(), close_mansession_file(), contenttype, displayconnects, errno, find_session(), FORMAT_HTML, FORMAT_XML, grab_last(), httptimeout, mansession::lock, LOG_WARNING, manager_displayconnects(), method, NULL, out, process_message(), process_output(), ROW_FMT, mansession::session, session, session_destroy(), mansession::stream, TEST_STRING, and unref_mansession().

Referenced by manager_http_callback(), mxml_http_callback(), and rawman_http_callback().

get_manager_sessions_cb()

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

static

Get number of logged in sessions for a login name.

Definition at line 9012 of file manager.c.

{
    struct mansession_session *session = obj;
    const char *login = (char *)arg;
    int *no_sessions = data;
 
    if (strcasecmp(session->username, login) == 0) {
        (*no_sessions)++;
    }
 
    return 0;
}

References session.

Referenced by function_amiclient().

handle_manager_show_event()

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

static

Definition at line 9304 of file manager.c.

{
    RAII_VAR(struct ao2_container *, events, NULL, ao2_cleanup);
    struct ao2_iterator it_events;
    struct ast_xml_doc_item *item, *temp;
    int length;
 
    if (cmd == CLI_INIT) {
        e->command = "manager show event";
        e->usage =
            "Usage: manager show event <eventname>\n"
            "       Provides a detailed description a Manager interface event.\n";
        return NULL;
    }
 
    events = ao2_global_obj_ref(event_docs);
    if (!events) {
        ast_cli(a->fd, "No manager event documentation loaded\n");
        return CLI_SUCCESS;
    }
 
    if (cmd == CLI_GENERATE) {
        if (a->pos != 3) {
            return NULL;
        }
 
        length = strlen(a->word);
        it_events = ao2_iterator_init(events, 0);
        while ((item = ao2_iterator_next(&it_events))) {
            if (!strncasecmp(a->word, item->name, length)) {
                if (ast_cli_completion_add(ast_strdup(item->name))) {
                    ao2_ref(item, -1);
                    break;
                }
            }
            ao2_ref(item, -1);
        }
        ao2_iterator_destroy(&it_events);
 
        return NULL;
    }
 
    if (a->argc != 4) {
        return CLI_SHOWUSAGE;
    }
 
    if (!(item = ao2_find(events, a->argv[3], OBJ_KEY))) {
        ast_cli(a->fd, "Could not find event '%s'\n", a->argv[3]);
        return CLI_SUCCESS;
    }
 
    ast_cli(a->fd, "Event: %s\n", a->argv[3]);
    for (temp = item; temp; temp = AST_LIST_NEXT(temp, next)) {
        print_event_instance(a, temp);
    }
 
    ao2_ref(item, -1);
    return CLI_SUCCESS;
}

References a, ao2_cleanup, ao2_find, ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_cli(), ast_cli_completion_add(), AST_LIST_NEXT, ast_strdup, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, events, item, aco_type::name, ast_xml_doc_item::next, NULL, OBJ_KEY, print_event_instance(), RAII_VAR, and ast_cli_entry::usage.

handle_manager_show_events()

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

static

Definition at line 9175 of file manager.c.

{
    struct ao2_container *events;
    struct ao2_iterator *it_events;
    struct ast_xml_doc_item *item;
    struct ast_xml_doc_item **items;
    struct ast_str *buffer;
    int i = 0, totalitems = 0;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "manager show events";
        e->usage =
            "Usage: manager show events\n"
                "   Prints a listing of the available Asterisk manager interface events.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
    if (a->argc != 3) {
        return CLI_SHOWUSAGE;
    }
 
    buffer = ast_str_create(128);
    if (!buffer) {
        return CLI_SUCCESS;
    }
 
    events = ao2_global_obj_ref(event_docs);
    if (!events) {
        ast_cli(a->fd, "No manager event documentation loaded\n");
        ast_free(buffer);
        return CLI_SUCCESS;
    }
 
    ao2_lock(events);
    if (!(it_events = ao2_callback(events, OBJ_MULTIPLE | OBJ_NOLOCK, NULL, NULL))) {
        ao2_unlock(events);
        ast_log(AST_LOG_ERROR, "Unable to create iterator for events container\n");
        ast_free(buffer);
        ao2_ref(events, -1);
        return CLI_SUCCESS;
    }
    if (!(items = ast_calloc(sizeof(struct ast_xml_doc_item *), ao2_container_count(events)))) {
        ao2_unlock(events);
        ast_log(AST_LOG_ERROR, "Unable to create temporary sorting array for events\n");
        ao2_iterator_destroy(it_events);
        ast_free(buffer);
        ao2_ref(events, -1);
        return CLI_SUCCESS;
    }
    ao2_unlock(events);
 
    while ((item = ao2_iterator_next(it_events))) {
        items[totalitems++] = item;
        ao2_ref(item, -1);
    }
 
    qsort(items, totalitems, sizeof(struct ast_xml_doc_item *), ast_xml_doc_item_cmp_fn);
 
    ast_cli(a->fd, "Events:\n");
    ast_cli(a->fd, "  --------------------  --------------------  --------------------  \n");
    for (i = 0; i < totalitems; i++) {
        ast_str_append(&buffer, 0, "  %-20.20s", items[i]->name);
        if ((i + 1) % 3 == 0) {
            ast_cli(a->fd, "%s\n", ast_str_buffer(buffer));
            ast_str_set(&buffer, 0, "%s", "");
        }
    }
    if ((i + 1) % 3 != 0) {
        ast_cli(a->fd, "%s\n", ast_str_buffer(buffer));
    }
 
    ao2_iterator_destroy(it_events);
    ast_free(items);
    ao2_ref(events, -1);
    ast_free(buffer);
 
    return CLI_SUCCESS;
}

References a, ao2_callback, ao2_container_count(), ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_calloc, ast_cli(), ast_free, ast_log, AST_LOG_ERROR, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_xml_doc_item_cmp_fn(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, events, item, name, NULL, OBJ_MULTIPLE, OBJ_NOLOCK, and ast_cli_entry::usage.

handle_manager_show_settings()

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

static

CLI command manager show settings.

Definition at line 9124 of file manager.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "manager show settings";
        e->usage =
            "Usage: manager show settings\n"
            "       Provides detailed list of the configuration of the Manager.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
#define FORMAT "  %-25.25s  %-15.55s\n"
#define FORMAT2 "  %-25.25s  %-15d\n"
#define FORMAT3 "  %-25.25s  %s\n"
    if (a->argc != 3) {
        return CLI_SHOWUSAGE;
    }
    ast_cli(a->fd, "\nGlobal Settings:\n");
    ast_cli(a->fd, "----------------\n");
    ast_cli(a->fd, FORMAT, "Manager (AMI):", AST_CLI_YESNO(manager_enabled));
    ast_cli(a->fd, FORMAT, "Web Manager (AMI/HTTP):", AST_CLI_YESNO(webmanager_enabled));
    ast_cli(a->fd, FORMAT, "TCP Bindaddress:", manager_enabled != 0 ? ast_sockaddr_stringify(&ami_desc.local_address) : "Disabled");
    ast_cli(a->fd, FORMAT2, "HTTP Timeout (seconds):", httptimeout);
    ast_cli(a->fd, FORMAT, "TLS Enable:", AST_CLI_YESNO(ami_tls_cfg.enabled));
    ast_cli(a->fd, FORMAT, "TLS Bindaddress:", ami_tls_cfg.enabled != 0 ? ast_sockaddr_stringify(&amis_desc.local_address) : "Disabled");
    ast_cli(a->fd, FORMAT, "TLS Certfile:", ami_tls_cfg.certfile);
    ast_cli(a->fd, FORMAT, "TLS Privatekey:", ami_tls_cfg.pvtfile);
    ast_cli(a->fd, FORMAT, "TLS Cipher:", ami_tls_cfg.cipher);
    ast_cli(a->fd, FORMAT, "Allow multiple login:", AST_CLI_YESNO(allowmultiplelogin));
    ast_cli(a->fd, FORMAT, "Display connects:", AST_CLI_YESNO(displayconnects));
    ast_cli(a->fd, FORMAT, "Timestamp events:", AST_CLI_YESNO(timestampevents));
    ast_cli(a->fd, FORMAT3, "Channel vars:", S_OR(manager_channelvars, ""));
    ast_cli(a->fd, FORMAT3, "Disabled events:", S_OR(manager_disabledevents, ""));
    ast_cli(a->fd, FORMAT, "Debug:", AST_CLI_YESNO(manager_debug));
#undef FORMAT
#undef FORMAT2
#undef FORMAT3
 
    return CLI_SUCCESS;
}

References a, allowmultiplelogin, ami_desc, ami_tls_cfg, amis_desc, ast_cli(), AST_CLI_YESNO, ast_sockaddr_stringify(), ast_tls_config::certfile, ast_tls_config::cipher, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, displayconnects, ast_tls_config::enabled, FORMAT, FORMAT2, FORMAT3, httptimeout, ast_tcptls_session_args::local_address, manager_channelvars, manager_debug, manager_disabledevents, manager_enabled, NULL, ast_tls_config::pvtfile, S_OR, timestampevents, ast_cli_entry::usage, and webmanager_enabled.

load_channelvars()

static void load_channelvars ( struct ast_variable *  var )

static

Definition at line 9389 of file manager.c.

{
    char *parse = NULL;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(vars)[MAX_VARS];
    );
 
    ast_free(manager_channelvars);
    manager_channelvars = ast_strdup(var->value);
 
    /* parse the setting */
    parse = ast_strdupa(manager_channelvars);
    AST_STANDARD_APP_ARGS(args, parse);
 
    ast_channel_set_manager_vars(args.argc, args.vars);
}

References args, AST_APP_ARG, ast_channel_set_manager_vars(), AST_DECLARE_APP_ARGS, ast_free, AST_STANDARD_APP_ARGS, ast_strdup, ast_strdupa, manager_channelvars, MAX_VARS, NULL, and var.

Referenced by __init_manager().

load_disabledevents()

static void load_disabledevents ( struct ast_variable *  var )

static

Definition at line 9412 of file manager.c.

{
    ast_free(manager_disabledevents);
    manager_disabledevents = ast_strdup(var->value);
}

References ast_free, ast_strdup, manager_disabledevents, and var.

Referenced by __init_manager().

load_module()

static int load_module ( void  )

static

Definition at line 10151 of file manager.c.

{
    int rc = 0;
    ast_register_cleanup(manager_shutdown);
    rc = __init_manager(0, 0) ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_SUCCESS;
#ifdef TEST_FRAMEWORK
    AST_TEST_REGISTER(eventfilter_test_creation);
    AST_TEST_REGISTER(eventfilter_test_matching);
    AST_TEST_REGISTER(originate_permissions_test);
#endif
    return rc;
}

References __init_manager(), AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_SUCCESS, ast_register_cleanup(), AST_TEST_REGISTER, and manager_shutdown().

manager_event_blob_dtor()

static void manager_event_blob_dtor ( void *  obj )

static

Definition at line 10221 of file manager.c.

{
    struct ast_manager_event_blob *ev = obj;
 
    ast_string_field_free_memory(ev);
}

References ast_string_field_free_memory.

Referenced by ast_manager_event_blob_create().

manager_free_user()

static void manager_free_user ( struct ast_manager_user *  user )

static

Definition at line 9422 of file manager.c.

{
    ast_free(user->a1_hash);
    ast_free(user->secret);
    if (user->includefilters) {
        ao2_t_ref(user->includefilters, -1, "decrement ref for include container, should be last one");
    }
    if (user->excludefilters) {
        ao2_t_ref(user->excludefilters, -1, "decrement ref for exclude container, should be last one");
    }
    user->acl = ast_free_acl_list(user->acl);
    ast_variables_destroy(user->chanvars);
    ast_free(user);
}

References ao2_t_ref, ast_free, ast_free_acl_list(), and ast_variables_destroy().

Referenced by __init_manager(), and manager_shutdown().

manager_http_callback()

static int manager_http_callback ( struct ast_tcptls_session_instance *  ser, const struct ast_http_uri *  urih, const char *  uri, enum ast_http_method  method, struct ast_variable *  get_params, struct ast_variable *  headers  )

static

Definition at line 8892 of file manager.c.

{
    int retval;
    struct ast_sockaddr ser_remote_address_tmp;
 
    ast_sockaddr_copy(&ser_remote_address_tmp, &ser->remote_address);
    retval = generic_http_callback(ser, method, FORMAT_HTML, &ser_remote_address_tmp, uri, get_params, headers);
    ast_sockaddr_copy(&ser->remote_address, &ser_remote_address_tmp);
    return retval;
}

References ast_sockaddr_copy(), FORMAT_HTML, generic_http_callback(), method, and ast_tcptls_session_instance::remote_address.

manager_set_defaults()

static void manager_set_defaults ( void  )

static

Definition at line 9609 of file manager.c.

{
    manager_enabled = 0;
    displayconnects = 1;
    broken_events_action = 0;
    authtimeout = 30;
    authlimit = 50;
    manager_debug = 0;      /* Debug disabled by default */
 
    /* default values */
    ast_copy_string(global_realm, S_OR(ast_config_AST_SYSTEM_NAME, DEFAULT_REALM),
        sizeof(global_realm));
    ast_sockaddr_setnull(&ami_desc.local_address);
    ast_sockaddr_setnull(&amis_desc.local_address);
 
    ami_tls_cfg.enabled = 0;
    ast_free(ami_tls_cfg.certfile);
    ami_tls_cfg.certfile = ast_strdup(AST_CERTFILE);
    ast_free(ami_tls_cfg.pvtfile);
    ami_tls_cfg.pvtfile = ast_strdup("");
    ast_free(ami_tls_cfg.cipher);
    ami_tls_cfg.cipher = ast_strdup("");
    ast_free(ami_tls_cfg.cafile);
    ami_tls_cfg.cafile = ast_strdup("");
    ast_free(ami_tls_cfg.capath);
    ami_tls_cfg.capath = ast_strdup("");
}

References ami_desc, ami_tls_cfg, amis_desc, AST_CERTFILE, ast_config_AST_SYSTEM_NAME, ast_copy_string(), ast_free, ast_sockaddr_setnull(), ast_strdup, authlimit, authtimeout, broken_events_action, ast_tls_config::cafile, ast_tls_config::capath, ast_tls_config::certfile, ast_tls_config::cipher, DEFAULT_REALM, displayconnects, ast_tls_config::enabled, global_realm, ast_tcptls_session_args::local_address, manager_debug, manager_enabled, ast_tls_config::pvtfile, and S_OR.

Referenced by __init_manager().

manager_shutdown()

static void manager_shutdown ( void  )

static

Definition at line 9441 of file manager.c.

{
    struct ast_manager_user *user;
 
#ifdef TEST_FRAMEWORK
    AST_TEST_UNREGISTER(eventfilter_test_creation);
    AST_TEST_UNREGISTER(eventfilter_test_matching);
    AST_TEST_UNREGISTER(originate_permissions_test);
#endif
 
    /* This event is not actually transmitted, but causes all TCP sessions to be closed */
    manager_event(EVENT_FLAG_SHUTDOWN, "CloseSession", "CloseSession: true\r\n");
 
    ast_manager_unregister("Ping");
    ast_manager_unregister("Events");
    ast_manager_unregister("Logoff");
    ast_manager_unregister("Login");
    ast_manager_unregister("Challenge");
    ast_manager_unregister("Hangup");
    ast_manager_unregister("Status");
    ast_manager_unregister("Setvar");
    ast_manager_unregister("Getvar");
    ast_manager_unregister("GetConfig");
    ast_manager_unregister("GetConfigJSON");
    ast_manager_unregister("UpdateConfig");
    ast_manager_unregister("CreateConfig");
    ast_manager_unregister("ListCategories");
    ast_manager_unregister("Redirect");
    ast_manager_unregister("Atxfer");
    ast_manager_unregister("CancelAtxfer");
    ast_manager_unregister("Originate");
    ast_manager_unregister("Command");
    ast_manager_unregister("ExtensionState");
    ast_manager_unregister("PresenceState");
    ast_manager_unregister("AbsoluteTimeout");
    ast_manager_unregister("MailboxStatus");
    ast_manager_unregister("MailboxCount");
    ast_manager_unregister("ListCommands");
    ast_manager_unregister("SendText");
    ast_manager_unregister("UserEvent");
    ast_manager_unregister("WaitEvent");
    ast_manager_unregister("CoreSettings");
    ast_manager_unregister("CoreStatus");
    ast_manager_unregister("Reload");
    ast_manager_unregister("LoggerRotate");
    ast_manager_unregister("CoreShowChannels");
    ast_manager_unregister("CoreShowChannelMap");
    ast_manager_unregister("ModuleLoad");
    ast_manager_unregister("ModuleCheck");
    ast_manager_unregister("AOCMessage");
    ast_manager_unregister("Filter");
    ast_manager_unregister("BlindTransfer");
    ast_custom_function_unregister(&managerclient_function);
    ast_cli_unregister_multiple(cli_manager, ARRAY_LEN(cli_manager));
 
#ifdef AST_XML_DOCS
    ao2_t_global_obj_release(event_docs, "Dispose of event_docs");
#endif
 
#ifdef TEST_FRAMEWORK
    stasis_forward_cancel(test_suite_forwarder);
    test_suite_forwarder = NULL;
#endif
 
    if (stasis_router) {
        stasis_message_router_unsubscribe_and_join(stasis_router);
        stasis_router = NULL;
    }
    stasis_forward_cancel(rtp_topic_forwarder);
    rtp_topic_forwarder = NULL;
    stasis_forward_cancel(security_topic_forwarder);
    security_topic_forwarder = NULL;
    ao2_cleanup(manager_topic);
    manager_topic = NULL;
    STASIS_MESSAGE_TYPE_CLEANUP(ast_manager_get_generic_type);
 
    ast_tcptls_server_stop(&ami_desc);
    ast_tcptls_server_stop(&amis_desc);
 
    ast_free(ami_tls_cfg.certfile);
    ami_tls_cfg.certfile = NULL;
    ast_free(ami_tls_cfg.pvtfile);
    ami_tls_cfg.pvtfile = NULL;
    ast_free(ami_tls_cfg.cipher);
    ami_tls_cfg.cipher = NULL;
    ast_free(ami_tls_cfg.cafile);
    ami_tls_cfg.cafile = NULL;
    ast_free(ami_tls_cfg.capath);
    ami_tls_cfg.capath = NULL;
 
    ao2_global_obj_release(mgr_sessions);
 
    while ((user = AST_LIST_REMOVE_HEAD(&users, list))) {
        manager_free_user(user);
    }
    acl_change_stasis_unsubscribe();
 
    ast_free(manager_channelvars);
    ast_free(manager_disabledevents);
}

References acl_change_stasis_unsubscribe(), ami_desc, ami_tls_cfg, amis_desc, ao2_cleanup, ao2_global_obj_release, ao2_t_global_obj_release, ARRAY_LEN, ast_cli_unregister_multiple(), ast_custom_function_unregister(), ast_free, AST_LIST_REMOVE_HEAD, ast_manager_get_generic_type(), ast_manager_unregister(), ast_tcptls_server_stop(), AST_TEST_UNREGISTER, ast_tls_config::cafile, ast_tls_config::capath, ast_tls_config::certfile, ast_tls_config::cipher, cli_manager, EVENT_FLAG_SHUTDOWN, manager_channelvars, manager_disabledevents, manager_event, manager_free_user(), manager_topic, managerclient_function, NULL, ast_tls_config::pvtfile, rtp_topic_forwarder, security_topic_forwarder, stasis_forward_cancel(), stasis_message_router_unsubscribe_and_join(), STASIS_MESSAGE_TYPE_CLEANUP, stasis_router, and user.

Referenced by load_module().

manager_subscriptions_init()

static int manager_subscriptions_init ( void  )

static

Initialize all Stasis Message Bus API topics and routers used by the various sub-components of AMI.

Definition at line 9546 of file manager.c.

{
    int res = 0;
 
    rtp_topic_forwarder = stasis_forward_all(ast_rtp_topic(), manager_topic);
    if (!rtp_topic_forwarder) {
        return -1;
    }
 
    security_topic_forwarder = stasis_forward_all(ast_security_topic(), manager_topic);
    if (!security_topic_forwarder) {
        return -1;
    }
 
    stasis_router = stasis_message_router_create(manager_topic);
    if (!stasis_router) {
        return -1;
    }
    stasis_message_router_set_congestion_limits(stasis_router, -1,
        6 * AST_TASKPROCESSOR_HIGH_WATER_LEVEL);
 
    stasis_message_router_set_formatters_default(stasis_router,
        manager_default_msg_cb, NULL, STASIS_SUBSCRIPTION_FORMATTER_AMI);
 
    res |= stasis_message_router_add(stasis_router,
        ast_manager_get_generic_type(), manager_generic_msg_cb, NULL);
 
    if (res != 0) {
        return -1;
    }
    return 0;
}

References ast_manager_get_generic_type(), ast_rtp_topic(), ast_security_topic(), AST_TASKPROCESSOR_HIGH_WATER_LEVEL, manager_default_msg_cb(), manager_generic_msg_cb(), manager_topic, NULL, rtp_topic_forwarder, security_topic_forwarder, stasis_forward_all(), stasis_message_router_add(), stasis_message_router_create, stasis_message_router_set_congestion_limits(), stasis_message_router_set_formatters_default(), stasis_router, and STASIS_SUBSCRIPTION_FORMATTER_AMI.

Referenced by subscribe_all().

mxml_http_callback()

static int mxml_http_callback ( struct ast_tcptls_session_instance *  ser, const struct ast_http_uri *  urih, const char *  uri, enum ast_http_method  method, struct ast_variable *  get_params, struct ast_variable *  headers  )

static

Definition at line 8903 of file manager.c.

{
    int retval;
    struct ast_sockaddr ser_remote_address_tmp;
 
    ast_sockaddr_copy(&ser_remote_address_tmp, &ser->remote_address);
    retval = generic_http_callback(ser, method, FORMAT_XML, &ser_remote_address_tmp, uri, get_params, headers);
    ast_sockaddr_copy(&ser->remote_address, &ser_remote_address_tmp);
    return retval;
}

References ast_sockaddr_copy(), FORMAT_XML, generic_http_callback(), method, and ast_tcptls_session_instance::remote_address.

process_output()

static void process_output ( struct mansession *  s, struct ast_str **  out, struct ast_variable *  params, enum output_format  format  )

static

Definition at line 8324 of file manager.c.

{
    char *buf;
    off_t l;
    int fd;
 
    if (!s->stream)
        return;
 
    /* Ensure buffer is NULL-terminated */
    ast_iostream_write(s->stream, "", 1);
 
    fd = ast_iostream_get_fd(s->stream);
 
    l = lseek(fd, 0, SEEK_CUR);
    if (l > 0) {
        if (MAP_FAILED == (buf = mmap(NULL, l, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0))) {
            ast_log(LOG_WARNING, "mmap failed.  Manager output was not processed\n");
        } else {
            if (format == FORMAT_XML || format == FORMAT_HTML) {
                xml_translate(out, buf, params, format);
            } else {
                ast_str_append(out, 0, "%s", buf);
            }
            munmap(buf, l);
        }
    } else if (format == FORMAT_XML || format == FORMAT_HTML) {
        xml_translate(out, "", params, format);
    }
 
    close_mansession_file(s);
}

References ast_iostream_get_fd(), ast_iostream_write(), ast_log, ast_str_append(), buf, close_mansession_file(), FORMAT_HTML, FORMAT_XML, LOG_WARNING, NULL, out, mansession::stream, and xml_translate().

Referenced by auth_http_callback(), and generic_http_callback().

purge_old_stuff()

static void purge_old_stuff ( void *  data )

static

cleanup code called at each iteration of server_root, guaranteed to happen every 5 seconds at most

Definition at line 9085 of file manager.c.

{
    struct ast_tcptls_session_args *ser = data;
    /* purge_sessions will return the number of sessions actually purged,
     * up to a maximum of it's arguments, purge one at a time, keeping a
     * purge interval of 1ms as long as we purged a session, otherwise
     * revert to a purge check every 5s
     */
    if (purge_sessions(1) == 1) {
        ser->poll_timeout = 1;
    } else {
        ser->poll_timeout = 5000;
    }
    purge_events();
}

References ast_tcptls_session_args::poll_timeout, purge_events(), and purge_sessions().

rawman_http_callback()

static int rawman_http_callback ( struct ast_tcptls_session_instance *  ser, const struct ast_http_uri *  urih, const char *  uri, enum ast_http_method  method, struct ast_variable *  get_params, struct ast_variable *  headers  )

static

Definition at line 8914 of file manager.c.

{
    int retval;
    struct ast_sockaddr ser_remote_address_tmp;
 
    ast_sockaddr_copy(&ser_remote_address_tmp, &ser->remote_address);
    retval = generic_http_callback(ser, method, FORMAT_RAW, &ser_remote_address_tmp, uri, get_params, headers);
    ast_sockaddr_copy(&ser->remote_address, &ser_remote_address_tmp);
    return retval;
}

References ast_sockaddr_copy(), FORMAT_RAW, generic_http_callback(), method, and ast_tcptls_session_instance::remote_address.

subscribe_all()

static int subscribe_all ( void  )

static

Definition at line 9579 of file manager.c.

{
    if (manager_subscriptions_init()) {
        ast_log(AST_LOG_ERROR, "Failed to initialize manager subscriptions\n");
        return -1;
    }
    if (manager_system_init()) {
        ast_log(AST_LOG_ERROR, "Failed to initialize manager system handling\n");
        return -1;
    }
    if (manager_channels_init()) {
        ast_log(AST_LOG_ERROR, "Failed to initialize manager channel handling\n");
        return -1;
    }
    if (manager_mwi_init()) {
        ast_log(AST_LOG_ERROR, "Failed to initialize manager MWI handling\n");
        return -1;
    }
    if (manager_bridging_init()) {
        return -1;
    }
    if (manager_endpoints_init()) {
        ast_log(AST_LOG_ERROR, "Failed to initialize manager endpoints handling\n");
        return -1;
    }
 
    subscribed = 1;
    return 0;
}

References ast_log, AST_LOG_ERROR, manager_bridging_init(), manager_channels_init(), manager_endpoints_init(), manager_mwi_init(), manager_subscriptions_init(), manager_system_init(), and subscribed.

Referenced by __init_manager().

unload_module()

static int unload_module ( void  )

static

Definition at line 10146 of file manager.c.

{
    return 0;
}

variable_count_cmp_fn()

static int variable_count_cmp_fn ( void *  obj, void *  vstr, int  flags  )

static

Definition at line 8157 of file manager.c.

{
    /* Due to the simplicity of struct variable_count, it makes no difference
     * if you pass in objects or strings, the same operation applies. This is
     * due to the fact that the hash occurs on the first element, which means
     * the address of both the struct and the string are exactly the same. */
    struct variable_count *vc = obj;
    char *str = vstr;
    return !strcmp(vc->varname, str) ? CMP_MATCH | CMP_STOP : 0;
}

References CMP_MATCH, CMP_STOP, str, and variable_count::varname.

Referenced by xml_translate().

variable_count_hash_fn()

static int variable_count_hash_fn ( const void *  vvc, const int  flags  )

static

Definition at line 8150 of file manager.c.

{
    const struct variable_count *vc = vvc;
 
    return ast_str_hash(vc->varname);
}

References ast_str_hash(), and variable_count::varname.

Referenced by xml_translate().

xml_copy_escape()

static void xml_copy_escape ( struct ast_str **  out, const char *  src, int  mode  )

static

Definition at line 8078 of file manager.c.

{
    /* store in a local buffer to avoid calling ast_str_append too often */
    char buf[256];
    char *dst = buf;
    const char *save = src;
    int space = sizeof(buf);
    /* repeat until done and nothing to flush */
    for ( ; *src || dst != buf ; src++) {
        if (*src == '\0' || space < 10) {   /* flush */
            *dst++ = '\0';
            ast_str_append(out, 0, "%s", buf);
            dst = buf;
            space = sizeof(buf);
            if (*src == '\0') {
                break;
            }
        }
 
        if (mode & 2) {
            if (save == src && isdigit(*src)) {
                /* The first character of an XML attribute cannot be a digit */
                *dst++ = '_';
                *dst++ = *src;
                space -= 2;
                continue;
            } else if (!isalnum(*src)) {
                /* Replace non-alphanumeric with an underscore */
                *dst++ = '_';
                space--;
                continue;
            }
        }
        switch (*src) {
        case '<':
            strcpy(dst, "&lt;");
            dst += 4;
            space -= 4;
            break;
        case '>':
            strcpy(dst, "&gt;");
            dst += 4;
            space -= 4;
            break;
        case '\"':
            strcpy(dst, "&quot;");
            dst += 6;
            space -= 6;
            break;
        case '\'':
            strcpy(dst, "&apos;");
            dst += 6;
            space -= 6;
            break;
        case '&':
            strcpy(dst, "&amp;");
            dst += 5;
            space -= 5;
            break;
 
        default:
            *dst++ = mode ? tolower(*src) : *src;
            space--;
        }
    }
}

References ast_str_append(), buf, and out.

Referenced by xml_translate().

xml_translate()

static void xml_translate ( struct ast_str **  out, char *  in, struct ast_variable *  get_vars, enum output_format  format  )

static

Convert the input into XML or HTML. The input is supposed to be a sequence of lines of the form Name: value optionally followed by a blob of unformatted text. A blank line is a section separator. Basically, this is a mixture of the format of Manager Interface and CLI commands. The unformatted text is considered as a single value of a field named 'Opaque-data'.

At the moment the output format is the following (but it may change depending on future requirements so don't count too much on it when writing applications):

General: the unformatted text is used as a value of XML output: to be completed

*   Each section is within <response type="object" id="xxx">
*   where xxx is taken from ajaxdest variable or defaults to unknown
*   Each row is reported as an attribute Name="value" of an XML
*   entity named from the variable ajaxobjtype, default to "generic"
* 

HTML output: each Name-value pair is output as a single row of a two-column table. Sections (blank lines in the input) are separated by a

---

Definition at line 8196 of file manager.c.

{
    struct ast_variable *v;
    const char *dest = NULL;
    char *var, *val;
    const char *objtype = NULL;
    int in_data = 0;    /* parsing data */
    int inobj = 0;
    int xml = (format == FORMAT_XML);
    struct variable_count *vc = NULL;
    struct ao2_container *vco = NULL;
 
    if (xml) {
        /* dest and objtype need only for XML format */
        for (v = get_vars; v; v = v->next) {
            if (!strcasecmp(v->name, "ajaxdest")) {
                dest = v->value;
            } else if (!strcasecmp(v->name, "ajaxobjtype")) {
                objtype = v->value;
            }
        }
        if (ast_strlen_zero(dest)) {
            dest = "unknown";
        }
        if (ast_strlen_zero(objtype)) {
            objtype = "generic";
        }
    }
 
    /* we want to stop when we find an empty line */
    while (in && *in) {
        val = strsep(&in, "\r\n");  /* mark start and end of line */
        if (in && *in == '\n') {    /* remove trailing \n if any */
            in++;
        }
        ast_trim_blanks(val);
        ast_debug(5, "inobj %d in_data %d line <%s>\n", inobj, in_data, val);
        if (ast_strlen_zero(val)) {
            /* empty line */
            if (in_data) {
                /* close data in Opaque mode */
                ast_str_append(out, 0, xml ? "'" : "</td></tr>\n");
                in_data = 0;
            }
 
            if (inobj) {
                /* close block */
                ast_str_append(out, 0, xml ? " /></response>\n" :
                    "<tr><td colspan=\"2\"><hr></td></tr>\r\n");
                inobj = 0;
                ao2_ref(vco, -1);
                vco = NULL;
            }
            continue;
        }
 
        if (!inobj) {
            /* start new block */
            if (xml) {
                ast_str_append(out, 0, "<response type='object' id='%s'><%s", dest, objtype);
            }
            vco = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 37,
                variable_count_hash_fn, NULL, variable_count_cmp_fn);
            inobj = 1;
        }
 
        if (in_data) {
            /* Process data field in Opaque mode. This is a
             * followup, so we re-add line feeds. */
            ast_str_append(out, 0, xml ? "\n" : "<br>\n");
            xml_copy_escape(out, val, 0);   /* data field */
            continue;
        }
 
        /* We expect "Name: value" line here */
        var = strsep(&val, ":");
        if (val) {
            /* found the field name */
            val = ast_skip_blanks(val);
            ast_trim_blanks(var);
        } else {
            /* field name not found, switch to opaque mode */
            val = var;
            var = "Opaque-data";
            in_data = 1;
        }
 
 
        ast_str_append(out, 0, xml ? " " : "<tr><td>");
        if ((vc = ao2_find(vco, var, 0))) {
            vc->count++;
        } else {
            /* Create a new entry for this one */
            vc = ao2_alloc(sizeof(*vc), NULL);
            vc->varname = var;
            vc->count = 1;
            ao2_link(vco, vc);
        }
 
        xml_copy_escape(out, var, xml ? 1 | 2 : 0); /* data name */
        if (vc->count > 1) {
            ast_str_append(out, 0, "-%d", vc->count);
        }
        ao2_ref(vc, -1);
        ast_str_append(out, 0, xml ? "='" : "</td><td>");
        xml_copy_escape(out, val, 0);   /* data field */
        if (!in_data || !*in) {
            ast_str_append(out, 0, xml ? "'" : "</td></tr>\n");
        }
    }
 
    if (inobj) {
        ast_str_append(out, 0, xml ? " /></response>\n" :
            "<tr><td colspan=\"2\"><hr></td></tr>\r\n");
        ao2_ref(vco, -1);
    }
}

References ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_find, ao2_link, ao2_ref, ast_debug, ast_skip_blanks(), ast_str_append(), ast_strlen_zero(), ast_trim_blanks(), variable_count::count, FORMAT_XML, in, ast_variable::name, ast_variable::next, NULL, out, strsep(), ast_variable::value, var, variable_count_cmp_fn(), variable_count_hash_fn(), variable_count::varname, and xml_copy_escape().

Referenced by process_output().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Asterisk Manager Interface" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = AST_MODPRI_CORE, .requires = "extconfig,acl,http", }

static

Definition at line 10269 of file manager.c.

amanageruri

struct ast_http_uri amanageruri

static

Definition at line 8993 of file manager.c.

Referenced by __init_manager().

amanagerxmluri

struct ast_http_uri amanagerxmluri

static

Definition at line 9002 of file manager.c.

Referenced by __init_manager().

ami_desc

struct ast_tcptls_session_args ami_desc

static

Definition at line 9102 of file manager.c.

Referenced by __init_manager(), handle_manager_show_settings(), manager_set_defaults(), and manager_shutdown().

ami_tls_cfg

struct ast_tls_config ami_tls_cfg

static

Definition at line 9101 of file manager.c.

Referenced by __init_manager(), handle_manager_show_settings(), manager_set_defaults(), and manager_shutdown().

amis_desc

struct ast_tcptls_session_args amis_desc

static

Definition at line 9113 of file manager.c.

Referenced by __init_manager(), handle_manager_show_settings(), manager_set_defaults(), and manager_shutdown().

arawmanuri

struct ast_http_uri arawmanuri

static

Definition at line 8984 of file manager.c.

Referenced by __init_manager().

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 10269 of file manager.c.

cli_manager

struct ast_cli_entry cli_manager[]

static

Definition at line 9366 of file manager.c.

Referenced by __init_manager(), and manager_shutdown().

contenttype

const char* const contenttype[]

static

Initial value:

= {
    [FORMAT_RAW] = "plain",
    [FORMAT_HTML] = "html",
    [FORMAT_XML] =  "xml",
}

Definition at line 7908 of file manager.c.

Referenced by auth_http_callback(), and generic_http_callback().

managerclient_function

struct ast_custom_function managerclient_function

static

Initial value:

= {
    .name = "AMI_CLIENT",
    .read = function_amiclient,
    .read_max = 12,
}

description of AMI_CLIENT dialplan function

Definition at line 9074 of file manager.c.

Referenced by __init_manager(), and manager_shutdown().

manageruri

struct ast_http_uri manageruri

static

Definition at line 8933 of file manager.c.

Referenced by __init_manager().

managerxmluri

struct ast_http_uri managerxmluri

static

Definition at line 8941 of file manager.c.

Referenced by __init_manager().

rawmanuri

struct ast_http_uri rawmanuri

static

Definition at line 8925 of file manager.c.

Referenced by __init_manager().

webregged

int webregged = 0

static

Definition at line 9080 of file manager.c.

Referenced by __init_manager().

words

const char* words[AST_MAX_CMD_LEN]

Definition at line 225 of file manager.c.

Referenced by check_blacklist().