manager.c File Reference

The Asterisk Management Interface - AMI. More...

#include "asterisk.h"
#include "asterisk/paths.h"
#include <ctype.h>
#include <sys/time.h>
#include <signal.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <regex.h>
#include "asterisk/channel.h"
#include "asterisk/file.h"
#include "asterisk/manager.h"
#include "asterisk/module.h"
#include "asterisk/config.h"
#include "asterisk/callerid.h"
#include "asterisk/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"

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=\"\">-----&gt;</option>\n\ <option value=\"login\">login</option>\n\ <option value=\"command\">Command</option>\n\ <option value=\"waitevent\">waitevent</option>\n\ <option value=\"listcommands\">listcommands</option>\n\ </select>\n\ or <input name=\"action\"><br/>\n\ CLI Command <input name=\"command\"><br>\n\ user <input name=\"username\"> pass <input type=\"password\" name=\"secret\"><br>\n\ <input type=\"submit\">\n</form>\n"

Enumerations
enum	add_filter_result { FILTER_SUCCESS, 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)
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...
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)
int	check_manager_enabled (void)
	Check if AMI is enabled. More...
static int	check_manager_session_inuse (const char *name)
int	check_webmanager_enabled (void)
	Check if AMI/HTTP is enabled. More...
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 = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = AST_MODPRI_CORE, .requires = "extconfig,acl,http", }
static struct stasis_subscription *	acl_change_sub
static struct actions	actions = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
static struct all_events	all_events = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
static int	allowmultiplelogin = 1
static struct ast_http_uri	amanageruri
static struct ast_http_uri	amanagerxmluri
static struct ast_tcptls_session_args	ami_desc
static struct ast_tls_config	ami_tls_cfg
static struct ast_tcptls_session_args	amis_desc
static struct ast_http_uri	arawmanuri
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_threadstorage	astman_append_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_astman_append_buf , .custom_init = NULL , }
static int	authlimit
static int	authtimeout
static int	broken_events_action = 0
static struct ast_cli_entry	cli_manager []
struct {
const char *   words [AST_MAX_CMD_LEN]
}	command_blacklist []
static const char *const	contenttype []
static int	displayconnects = 1
static char	global_realm [MAXHOSTNAMELEN]
static int	httptimeout = 60
static 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 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=\"\">-----&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"

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.

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

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

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

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.

References ast_manager_user::a1_hash, ast_manager_user::acl, mansession_session::addr, ao2_lock, ao2_unlock, ast_apply_acl(), ast_asprintf, ast_copy_string(), ast_debug, ast_free, ast_get_http_method(), ast_http_auth(), ast_http_error(), AST_HTTP_GET, ast_http_get_post_vars(), AST_HTTP_HEAD, AST_HTTP_POST, ast_http_request_close_on_completion(), ast_http_send(), ast_iostream_close(), ast_iostream_from_fd(), ast_iostream_get_fd(), AST_LIST_HEAD_INIT_NOLOCK, ast_log, ast_md5_hash(), ast_mutex_destroy, ast_mutex_init, ast_parse_digest(), ast_random(), AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_sockaddr_stringify_addr(), ast_str_append(), ast_str_create, ast_string_field_free_memory, ast_string_field_init, ast_strlen_zero, ast_variables_destroy(), ast_verb, astman_append_headers(), astman_free_headers(), mansession_session::authenticated, build_mansession(), close_mansession_file(), ast_http_digest::cnonce, d, mansession_session::datastores, ast_manager_user::displayconnects, errno, find_session_by_nonce(), FORMAT_HTML, FORMAT_XML, get_manager_by_name_locked(), global_realm, grab_last(), httptimeout, mansession_session::last_ev, mansession::lock, LOG_NOTICE, LOG_WARNING, mansession_session::managerid, ast_variable::name, ast_http_digest::nc, mansession_session::nc, mansession_session::needdestroy, ast_variable::next, ast_http_digest::nonce, mansession_session::noncetime, NULL, mansession_session::oldnonce, out, process_message(), process_output(), ast_http_digest::qop, mansession_session::readperm, ast_manager_user::readperm, ast_http_digest::response, session, mansession::session, session_destroy(), mansession_session::sessionstart, mansession_session::sessiontimeout, mansession_session::stream, mansession::stream, ast_http_digest::uri, ast_http_digest::username, mansession_session::username, ast_manager_user::username, ast_variable::value, mansession_session::writeperm, ast_manager_user::writeperm, mansession_session::writetimeout, and ast_manager_user::writetimeout.

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.

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

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