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/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	eventqent

struct	fast_originate_helper
	helper function for originate More...

struct	manager_hooks
	list of hooks registered More...

struct	mansession
	In case you didn't read that giant block of text above the mansession_session struct, the struct mansession is named this solely to keep the API the same in Asterisk. This structure really represents data that is different from Manager action to Manager action. The mansession_session pointer contained within points to session-specific data. More...

struct	mansession_session::mansession_datastores

struct	mansession_session

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	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 %-5.5s %-5.5s\n"

#define	HSMCONN_FORMAT2 " %-15.15s %-55.55s %-10d %-10d %-8d %-8d %-5.5d %-5.5d\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=\"\">-----></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, FILTER_ALLOC_FAILED, FILTER_COMPILE_FAIL }

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

enum	mansession_message_parsing { MESSAGE_OKAY, MESSAGE_LINE_TOO_LONG }

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 int	action_aocmessage (struct mansession s, const struct message m)

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

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

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

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

static int	action_command (struct mansession s, const struct message m)
	Manager command "command" - execute CLI command. More...

static int	action_coresettings (struct mansession s, const struct message m)
	Show PBX core settings information. More...

static int	action_coreshowchannels (struct mansession s, const struct message m)
	Manager command "CoreShowChannels" - List currently defined channels and some information about them. More...

static int	action_corestatus (struct mansession s, const struct message m)
	Show PBX core status information. More...

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

static void	action_destroy (void *obj)

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

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

static int	action_filter (struct mansession s, const struct message m)
	Manager command to add an event filter to a manager session. More...

static struct manager_action *	action_find (const char *name)

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

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

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

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

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

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

static int	action_loggerrotate (struct mansession s, const struct message m)
	Manager command "LoggerRotate" - reloads and rotates the logger in the same manner as the CLI command 'logger rotate'. More...

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

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

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

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

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

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

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

static int	action_redirect (struct mansession s, const struct message m)
	action_redirect: The redirect manager command More...

static int	action_reload (struct mansession s, const struct message m)
	Send a reload event. More...

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

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

static int	action_status (struct mansession s, const struct message m)
	Manager "status" command to show channels. More...

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

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

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

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

static struct eventqent *	advance_event (struct eventqent *e)

static	AO2_GLOBAL_OBJ_STATIC (mgr_sessions)

static	AO2_GLOBAL_OBJ_STATIC (event_docs)
	A container of event documentation nodes. More...

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

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

static int	append_event (const char *str, int category)
	events are appended to a queue from where they can be dispatched to clients. More...

int	ast_hook_send_action (struct manager_custom_hook hook, const char msg)
	access for hooks to send action messages to ami More...

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

int	ast_manager_check_enabled (void)
	Check if AMI is enabled. More...

struct 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...

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)
	Determinie if a manager session ident is authenticated. 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 int	blackfilter_cmp_fn (void obj, void arg, void *data, int flags)

static struct mansession_session *	build_mansession (const struct ast_sockaddr *addr)
	Allocate manager session structure and add it to the list of sessions. More...

static int	check_blacklist (const char *cmd)

static int	check_manager_session_inuse (const char *name)

static void	close_mansession_file (struct mansession *s)

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 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_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 void	json_escape (char out, const char in)

static void	load_channelvars (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 filter_pattern, struct ao2_container whitefilters, struct ao2_container *blackfilters)
	Add an event filter to a manager session. More...

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

static int	manager_displayconnects (struct mansession_session *session)
	Get displayconnects config option. More...

static void	manager_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_filter (struct mansession s, char eventdata)

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 void	purge_sessions (int n_max)
	remove at most n_max stale session from the list. More...

static int	queue_read_action_payload (struct ast_channel chan, const unsigned char payload, size_t payload_size, enum ast_frame_read_action action)
	Queue a given read action containing a payload onto a channel. More...

static int	queue_sendtext (struct ast_channel chan, const char body)
	Queue a read action to send a text message. More...

static int	queue_sendtext_data (struct ast_channel chan, const char body, const char *content_type)
	Queue a read action to send a text data message. More...

static int	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	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 int	whitefilter_cmp_fn (void obj, void arg, void *data, 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 = "30ef0c93b36035ec78c9cfd712d36d9b" , .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 char *	manager_channelvars

static int	manager_debug = 0

static int	manager_enabled = 0

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

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

static struct stasis_topic *	manager_topic
	A stasis_topic that all topics AMI cares about will be forwarded to. More...

static 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 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 struct stasis_forward *	test_suite_forwarder
	The stasis_subscription for forwarding the Test topic to the AMI topic. More...

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"

Referenced by handle_manager_show_settings().

◆ FORMAT2

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

Referenced by handle_manager_show_settings().

◆ HSMC_FORMAT

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

Referenced by handle_showmancmds().

◆ HSMCONN_FORMAT1

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

Referenced by handle_showmanconn().

◆ HSMCONN_FORMAT2

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

Referenced by handle_showmanconn().

◆ ROW_FMT

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

Referenced by generic_http_callback().

◆ TEST_STRING

#define TEST_STRING "<form action=\"manager\" method=\"post\">\n\ Action: <select name=\"action\">\n\ <option value=\"\">-----></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"

Referenced by generic_http_callback().

Enumeration Type Documentation

◆ output_format

enum output_format

Enumerator
FORMAT_RAW
FORMAT_HTML
FORMAT_XML

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

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

 {
    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[256];
    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("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", 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 {
          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->whitefilters = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
          user->blackfilters = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
          if (!user->whitefilters || !user->blackfilters) {
             manager_free_user(user);
             break;
          }
 
          /* Insert into list */
          AST_RWLIST_INSERT_TAIL(&users, user, list);
       } else {
          ao2_t_callback(user->whitefilters, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, NULL, NULL, "unlink all white filters");
          ao2_t_callback(user->blackfilters, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, NULL, NULL, "unlink all black 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 (!strcasecmp(var->name, "eventfilter")) {
             const char *value = var->value;
             manager_add_filter(value, user->whitefilters, user->blackfilters);
          } 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;

◆ __reg_module()

static void __reg_module ( void )

static

Definition at line 9766 of file manager.c.

◆ __unreg_module()

static void __unreg_module ( void )

static

Definition at line 9766 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_snapshot_event object.; NULL on error.

Definition at line 9727 of file manager.c.

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_assert, AST_MODFLAG_GLOBAL_SYMBOLS, AST_MODFLAG_LOAD_ORDER, AST_MODPRI_CORE, AST_MODULE_INFO(), AST_MODULE_SUPPORT_CORE, ast_string_field_init, ast_string_field_ptr_build_va, ASTERISK_GPL_KEY, ast_manager_event_blob::event_flags, ast_manager_event_blob::extra_fields, load_module(), manager_event, ast_manager_event_blob::manager_event, manager_event_blob_dtor(), NULL, reload(), and unload_module().

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(), session_timeout_to_ami(), system_registry_to_ami(), talking_start_to_ami(), talking_stop_to_ami(), test_suite_event_to_ami(), and varset_to_ami().

 {
    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;

◆ AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM ( void )

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

References ast_str_append(), and ast_str_create.

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

 {
    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;

◆ ast_xml_doc_item_cmp_fn()

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

static

Definition at line 8705 of file manager.c.

Referenced by handle_manager_show_events().

 {
    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);

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

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

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

◆ 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.

Return values

pointer	to the datastore if found
NULL	if not found

Since: 1.6.1

Definition at line 9678 of file manager.c.

References AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, mansession_session::datastores, ast_datastore::info, NULL, mansession::session, and ast_datastore::uid.

 {
    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;

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

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

9675 {

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

mansession_session::datastores

struct mansession_session::mansession_datastores datastores

AST_LIST_REMOVE

#define AST_LIST_REMOVE(head, elm, field)

Removes a specific entry from a list.

Definition: linkedlists.h:855

mansession::session

struct mansession_session * session

Definition: manager.c:1626

entry

Definition: search.h:40

◆ astman_is_authed()

int astman_is_authed ( uint32_t ident )

Determinie if a manager session ident is authenticated.

Definition at line 7551 of file manager.c.

References ao2_unlock, mansession_session::authenticated, find_session(), session, and unref_mansession().

Referenced by http_post_callback(), and static_callback().

 {
    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;

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

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

 {
    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;

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

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

Referenced by http_post_callback().

 {
    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;

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

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

 {
    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;

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

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

 {
    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;

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

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

 {
    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;

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

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

 {
    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;

◆ close_mansession_file()

static void close_mansession_file ( struct mansession * s )

static

Definition at line 7864 of file manager.c.

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

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

 {
    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");
    }

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

References ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_atomic_fetchadd_int(), mansession_session::inuse, mansession_session::managerid, mansession_session::needdestroy, NULL, session, sessions, and unref_mansession().

Referenced by astman_is_authed(), and generic_http_callback().

 {
    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;

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

References ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, mansession_session::managerid, NULL, mansession_session::oldnonce, session, sessions, unref_mansession(), and mansession_session::username.

Referenced by auth_http_callback().

 {
    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;

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

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, get_manager_by_name_locked(), get_manager_sessions_cb(), LOG_ERROR, LOG_WARNING, name, NULL, and sessions.

 {
    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;

◆ 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 constantcy of s), that won't happen twice in a row.

Definition at line 7907 of file manager.c.

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

 {
    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 constantcy 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;

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

References session, and mansession_session::username.

Referenced by function_amiclient().

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

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

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

 {
    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;

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

References ao2_callback, ao2_container_count(), ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_cli_args::argc, 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, ast_cli_args::fd, item, name, NULL, OBJ_MULTIPLE, OBJ_NOLOCK, and ast_cli_entry::usage.

 {
    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;

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

References allowmultiplelogin, ami_tls_cfg, ast_cli_args::argc, 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, ast_cli_args::fd, FORMAT, FORMAT2, httptimeout, ast_tcptls_session_args::local_address, manager_channelvars, manager_debug, manager_enabled, NULL, ast_tls_config::pvtfile, S_OR, timestampevents, ast_cli_entry::usage, and webmanager_enabled.

 {
    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"
    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, FORMAT, "Channel vars:", S_OR(manager_channelvars, ""));
    ast_cli(a->fd, FORMAT, "Debug:", AST_CLI_YESNO(manager_debug));
 #undef FORMAT
 #undef FORMAT2
 
    return CLI_SUCCESS;

◆ load_channelvars()

static void load_channelvars ( struct ast_variable * var )

static

Definition at line 8916 of file manager.c.

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, parse(), and ast_variable::value.

Referenced by __init_manager().

 {
         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);

◆ load_module()

static int load_module ( void )

static

Definition at line 9654 of file manager.c.

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

Referenced by ast_manager_event_blob_create().

 {
    ast_register_cleanup(manager_shutdown);
 
    return __init_manager(0, 0) ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_SUCCESS;

◆ manager_event_blob_dtor()

static void manager_event_blob_dtor ( void * obj )

static

Definition at line 9718 of file manager.c.

References ast_string_field_free_memory.

Referenced by ast_manager_event_blob_create().

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

◆ manager_free_user()

static void manager_free_user ( struct ast_manager_user * user )

static

Definition at line 8937 of file manager.c.

References ast_manager_user::a1_hash, ast_manager_user::acl, ao2_t_ref, ast_free, ast_free_acl_list(), ast_variables_destroy(), ast_manager_user::blackfilters, ast_manager_user::chanvars, ast_manager_user::secret, and ast_manager_user::whitefilters.

Referenced by __init_manager(), and manager_shutdown().

 {
    ast_free(user->a1_hash);
    ast_free(user->secret);
    if (user->whitefilters) {
       ao2_t_ref(user->whitefilters, -1, "decrement ref for white container, should be last one");
    }
    if (user->blackfilters) {
       ao2_t_ref(user->blackfilters, -1, "decrement ref for black container, should be last one");
    }
    user->acl = ast_free_acl_list(user->acl);
    ast_variables_destroy(user->chanvars);
    ast_free(user);

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

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

 {
    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;

◆ manager_set_defaults()

static void manager_set_defaults ( void )

static

Definition at line 9116 of file manager.c.

References ami_tls_cfg, 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_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("");

◆ manager_shutdown()

static void manager_shutdown ( void )

static

Definition at line 8956 of file manager.c.

References acl_change_stasis_unsubscribe(), ami_tls_cfg, 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_tls_config::cafile, ast_tls_config::capath, ast_tls_config::certfile, ast_tls_config::cipher, EVENT_FLAG_SHUTDOWN, manager_channelvars, manager_event, manager_free_user(), NULL, ast_tls_config::pvtfile, stasis_forward_cancel(), stasis_message_router_unsubscribe_and_join(), STASIS_MESSAGE_TYPE_CLEANUP, and user.

Referenced by load_module().

 {
    struct ast_manager_user *user;
 
    /* 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("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);

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

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(), NULL, stasis_forward_all(), stasis_message_router_add(), stasis_message_router_create, stasis_message_router_set_congestion_limits(), stasis_message_router_set_formatters_default(), and STASIS_SUBSCRIPTION_FORMATTER_AMI.

Referenced by subscribe_all().

 {
    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;

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

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

 {
    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;

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

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

Referenced by auth_http_callback(), and generic_http_callback().

 {
    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);

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

References purge_events(), and purge_sessions().

 {
    purge_sessions(1);
    purge_events();

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

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

 {
    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;

◆ subscribe_all()

static int subscribe_all ( void )

static

Definition at line 9086 of file manager.c.

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

 {
    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;

◆ unload_module()

static int unload_module ( void )

static

Definition at line 9649 of file manager.c.

Referenced by ast_manager_event_blob_create().

9651 {

9652 return 0;

◆ variable_count_cmp_fn()

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

static

Definition at line 7707 of file manager.c.

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

Referenced by xml_translate().

 {
    /* 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;

◆ variable_count_hash_fn()

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

static

Definition at line 7700 of file manager.c.

References ast_str_hash(), and variable_count::varname.

Referenced by xml_translate().

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

◆ xml_copy_escape()

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

static

Definition at line 7638 of file manager.c.

References ast_str_append(), and buf.

Referenced by xml_translate().

 {
    /* store in a local buffer to avoid calling ast_str_append too often */
    char buf[256];
    char *dst = buf;
    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) && !isalnum(*src)) {
          *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--;
       }
    }

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

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, ast_variable::name, ast_variable::next, NULL, strsep(), ast_variable::value, var, variable_count_cmp_fn(), variable_count_hash_fn(), variable_count::varname, and xml_copy_escape().

Referenced by process_output().

 {
    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);
    }

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 = "30ef0c93b36035ec78c9cfd712d36d9b" , .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 9766 of file manager.c.

◆ amanageruri

struct ast_http_uri amanageruri

static

Definition at line 8543 of file manager.c.

◆ amanagerxmluri

struct ast_http_uri amanagerxmluri

static

Definition at line 8552 of file manager.c.

◆ ami_desc

struct ast_tcptls_session_args ami_desc

static

Definition at line 8642 of file manager.c.

◆ ami_tls_cfg

struct ast_tls_config ami_tls_cfg

static

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

◆ arawmanuri

struct ast_http_uri arawmanuri

static

Definition at line 8534 of file manager.c.

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 9766 of file manager.c.

◆ cli_manager

struct ast_cli_entry cli_manager[]

static

Definition at line 8892 of file manager.c.

◆ contenttype

const char* const contenttype[]

static

Initial value:

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

Definition at line 7468 of file manager.c.

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

◆ manageruri

struct ast_http_uri manageruri

static

Definition at line 8483 of file manager.c.

◆ managerxmluri

struct ast_http_uri managerxmluri

static

Definition at line 8491 of file manager.c.

◆ rawmanuri

struct ast_http_uri rawmanuri

static

Definition at line 8475 of file manager.c.

◆ webregged

int webregged = 0

static

Definition at line 8630 of file manager.c.

◆ words

const char* words[AST_MAX_CMD_LEN]

Definition at line 1525 of file manager.c.

Referenced by check_blacklist().

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ FORMAT

◆ FORMAT2

◆ HSMC_FORMAT

◆ HSMCONN_FORMAT1

◆ HSMCONN_FORMAT2

◆ ROW_FMT

◆ TEST_STRING

Enumeration Type Documentation

◆ output_format

Function Documentation

◆ __init_manager()

◆ __reg_module()

◆ __unreg_module()

◆ ast_manager_event_blob_create()

◆ AST_MODULE_SELF_SYM()

◆ ast_str_append_event_header()

◆ ast_xml_doc_item_cmp_fn()

◆ astman_datastore_add()

◆ astman_datastore_find()

◆ astman_datastore_remove()

◆ astman_is_authed()

◆ astman_verify_session_readpermissions()

◆ astman_verify_session_writepermissions()

◆ auth_http_callback()

◆ auth_manager_http_callback()

◆ auth_mxml_http_callback()

◆ auth_rawman_http_callback()

◆ close_mansession_file()

◆ find_session()

◆ find_session_by_nonce()

◆ function_amiclient()

◆ generic_http_callback()

◆ get_manager_sessions_cb()

◆ handle_manager_show_event()

◆ handle_manager_show_events()

◆ handle_manager_show_settings()

◆ load_channelvars()

◆ load_module()

◆ manager_event_blob_dtor()

◆ manager_free_user()

◆ manager_http_callback()

◆ manager_set_defaults()

◆ manager_shutdown()

◆ manager_subscriptions_init()

◆ mxml_http_callback()

◆ process_output()

◆ purge_old_stuff()

◆ rawman_http_callback()

◆ subscribe_all()

◆ unload_module()

◆ variable_count_cmp_fn()

◆ variable_count_hash_fn()

◆ xml_copy_escape()

◆ xml_translate()

Variable Documentation

◆ __mod_info

◆ amanageruri

◆ amanagerxmluri

◆ ami_desc

◆ ami_tls_cfg

◆ amis_desc

◆ arawmanuri

◆ ast_module_info

◆ cli_manager

◆ contenttype

◆ managerclient_function

◆ manageruri

◆ managerxmluri

◆ rawmanuri

◆ webregged

◆ words