Asterisk - The Open Source Telephony Project GIT-master-a63eec2
Loading...
Searching...
No Matches
Data Structures | Macros | Enumerations | Functions | Variables
manager.c File Reference

The Asterisk Management Interface - AMI. More...

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

Go to the source code of this file.

Data Structures

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

Macros

#define any_manager_listeners(sessions)    ((sessions && ao2_container_count(sessions)) || !AST_RWLIST_EMPTY(&manager_hooks))
 
#define ASTMAN_APPEND_BUF_INITSIZE   256
 initial allocated size for the astman_append_buf and astman_send_*_va
 
#define DEFAULT_REALM   "asterisk"
 
#define EVENT_FLAG_SHUTDOWN   -1
 Fake event class used to end sessions at shutdown.
 
#define FORMAT   " %-25.25s %-15.55s\n"
 
#define FORMAT2   " %-25.25s %-15d\n"
 
#define FORMAT3   " %-25.25s %s\n"
 
#define GET_HEADER_FIRST_MATCH   0
 
#define GET_HEADER_LAST_MATCH   1
 
#define GET_HEADER_SKIP_EMPTY   2
 
#define HSMC_FORMAT   " %-*.*s %-.*s\n"
 
#define HSMCONN_FORMAT1   " %-15.15s %-55.55s %-10.10s %-10.10s %-8.8s %-8.8s %-10.10s %-10.10s\n"
 
#define HSMCONN_FORMAT2   " %-15.15s %-55.55s %-10d %-10d %-8d %-8d %-10.10d %-10.10d\n"
 
#define MANAGER_EVENT_BUF_INITSIZE   256
 
#define manager_event_sessions(sessions, category, event, contents, ...)    __manager_event_sessions(sessions, category, event, 0, NULL, __FILE__, __LINE__, __PRETTY_FUNCTION__, contents , ## __VA_ARGS__)
 
#define MAX_AUTH_PERM_STRING   150
 
#define MAX_BLACKLIST_CMD_LEN   2
 Descriptor for a manager session, either on the AMI socket or over HTTP.
 
#define MAX_VARS   128
 
#define MGR_SHOW_TERMINAL_WIDTH   80
 
#define MSG_MOREDATA   ((char *)astman_send_response)
 
#define ROW_FMT   "<tr><td colspan=\"2\" bgcolor=\"#f1f1ff\">%s</td></tr>\r\n"
 
#define TEST_STRING    "<form action=\"manager\" method=\"post\">\n\ Action: <select name=\"action\">\n\ <option value=\"\">-----&gt;</option>\n\ <option value=\"login\">login</option>\n\ <option value=\"command\">Command</option>\n\ <option value=\"waitevent\">waitevent</option>\n\ <option value=\"listcommands\">listcommands</option>\n\ </select>\n\ or <input name=\"action\"><br/>\n\ CLI Command <input name=\"command\"><br>\n\ user <input name=\"username\"> pass <input type=\"password\" name=\"secret\"><br>\n\ <input type=\"submit\">\n</form>\n"
 

Enumerations

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

Functions

int __ast_manager_event_multichan (int category, const char *event, int chancount, struct ast_channel **chans, const char *file, int line, const char *func, const char *fmt,...)
 
static const char * __astman_get_header (const struct message *m, char *var, int mode)
 Return a matching header value.
 
static int __init_manager (int reload, int by_external_config)
 
static int __manager_event_sessions (struct ao2_container *sessions, int category, const char *event, int chancount, struct ast_channel **chans, const char *file, int line, const char *func, const char *fmt,...)
 
static int __manager_event_sessions_va (struct ao2_container *sessions, int category, const char *event, int chancount, struct ast_channel **chans, const char *file, int line, const char *func, const char *fmt, va_list ap)
 
static void __reg_module (void)
 
static void __unreg_module (void)
 
static void acl_change_stasis_cb (void *data, struct stasis_subscription *sub, struct stasis_message *message)
 
static void acl_change_stasis_subscribe (void)
 
static void acl_change_stasis_unsubscribe (void)
 
static struct ast_aoc_decodedaction_aoc_de_message (struct mansession *s, const struct message *m)
 
static struct ast_aoc_decodedaction_aoc_s_message (struct mansession *s, const struct message *m)
 
static int action_aoc_s_submessage (struct mansession *s, const struct message *m, struct ast_aoc_decoded *decoded)
 
static int action_aocmessage (struct mansession *s, const struct message *m)
 
static int action_atxfer (struct mansession *s, const struct message *m)
 
static int action_blind_transfer (struct mansession *s, const struct message *m)
 
static int action_cancel_atxfer (struct mansession *s, const struct message *m)
 
static int action_challenge (struct mansession *s, const struct message *m)
 
static int action_command (struct mansession *s, const struct message *m)
 Manager command "command" - execute CLI command.
 
static int action_coresettings (struct mansession *s, const struct message *m)
 Show PBX core settings information.
 
static int action_coreshowchannelmap (struct mansession *s, const struct message *m)
 Manager command "CoreShowChannelMap" - Lists all channels connected to the specified channel.
 
static int action_coreshowchannels (struct mansession *s, const struct message *m)
 Manager command "CoreShowChannels" - List currently defined channels and some information about them.
 
static int action_corestatus (struct mansession *s, const struct message *m)
 Show PBX core status information.
 
static int action_createconfig (struct mansession *s, const struct message *m)
 
static void action_destroy (void *obj)
 
static int action_events (struct mansession *s, const struct message *m)
 
static int action_extensionstate (struct mansession *s, const struct message *m)
 
static int action_filter (struct mansession *s, const struct message *m)
 Manager command to add an event filter to a manager session.
 
static struct manager_actionaction_find (const char *name)
 
static int action_getconfig (struct mansession *s, const struct message *m)
 
static int action_getconfigjson (struct mansession *s, const struct message *m)
 
static int action_getvar (struct mansession *s, const struct message *m)
 
static int action_hangup (struct mansession *s, const struct message *m)
 
static int action_listcategories (struct mansession *s, const struct message *m)
 
static int action_listcommands (struct mansession *s, const struct message *m)
 
static int action_loggerrotate (struct mansession *s, const struct message *m)
 Manager command "LoggerRotate" - reloads and rotates the logger in the same manner as the CLI command 'logger rotate'.
 
static int action_login (struct mansession *s, const struct message *m)
 
static int action_logoff (struct mansession *s, const struct message *m)
 
static int action_mailboxcount (struct mansession *s, const struct message *m)
 
static int action_mailboxstatus (struct mansession *s, const struct message *m)
 
static int action_originate (struct mansession *s, const struct message *m)
 
static int action_ping (struct mansession *s, const struct message *m)
 
static int action_presencestate (struct mansession *s, const struct message *m)
 
static int action_redirect (struct mansession *s, const struct message *m)
 action_redirect: The redirect manager command
 
static int action_reload (struct mansession *s, const struct message *m)
 Send a reload event.
 
static int action_sendtext (struct mansession *s, const struct message *m)
 
static int action_setvar (struct mansession *s, const struct message *m)
 
static int action_status (struct mansession *s, const struct message *m)
 Manager "status" command to show channels.
 
static int action_timeout (struct mansession *s, const struct message *m)
 
static int action_updateconfig (struct mansession *s, const struct message *m)
 
static int action_userevent (struct mansession *s, const struct message *m)
 
static int action_waitevent (struct mansession *s, const struct message *m)
 
static struct eventqentadvance_event (struct eventqent *e)
 
static AO2_GLOBAL_OBJ_STATIC (event_docs)
 A container of event documentation nodes.
 
static AO2_GLOBAL_OBJ_STATIC (mgr_sessions)
 
static int aocmessage_get_unit_entry (const struct message *m, struct ast_aoc_unit_entry *entry, unsigned int entry_num)
 
static int app_match (const char *app, const char *data, const char *search)
 
static int appdata_match (const char *app, const char *data, const char *search)
 
static void append_channel_vars (struct ast_str **pbuf, struct ast_channel *chan)
 
static int append_event (const char *str, int event_name_hash, int category)
 events are appended to a queue from where they can be dispatched to clients.
 
int ast_hook_send_action (struct manager_custom_hook *hook, const char *msg)
 access for hooks to send action messages to ami
 
static int ast_instring (const char *bigstr, const char *smallstr, const char delim)
 
int ast_manager_check_enabled (void)
 Check if AMI is enabled.
 
struct ast_manager_event_blobast_manager_event_blob_create (int event_flags, const char *manager_event, const char *extra_fields_fmt,...)
 Construct a ast_manager_event_blob.
 
struct stasis_message_routerast_manager_get_message_router (void)
 Get the stasis_message_router for AMI.
 
struct stasis_topicast_manager_get_topic (void)
 Get the Stasis Message Bus API topic for AMI.
 
int ast_manager_hangup_helper (struct mansession *s, const struct message *m, manager_hangup_handler_t hangup_handler, manager_hangup_cause_validator_t cause_validator)
 A manager helper function that hangs up a channel using a supplied channel type specific hangup function and cause code validator.
 
void ast_manager_publish_event (const char *type, int class_type, struct ast_json *obj)
 Publish an event to AMI.
 
int ast_manager_register2 (const char *action, int auth, int(*func)(struct mansession *s, const struct message *m), struct ast_module *module, const char *synopsis, const char *description)
 register a new command with manager, including online help. This is the preferred way to register a manager command
 
void ast_manager_register_hook (struct manager_custom_hook *hook)
 Add a custom hook to be called when an event is fired.
 
static int ast_manager_register_struct (struct manager_action *act)
 
struct ast_strast_manager_str_from_json_object (struct ast_json *blob, key_exclusion_cb exclusion_cb)
 Convert a JSON object into an AMI compatible string.
 
int ast_manager_unregister (const char *action)
 support functions to register/unregister AMI action handlers,
 
void ast_manager_unregister_hook (struct manager_custom_hook *hook)
 Delete a custom hook to be called when an event is fired.
 
struct ast_moduleAST_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
 
 AST_THREADSTORAGE_CUSTOM_SCOPE (astman_append_buf, NULL, ast_free_ptr, static)
 thread local buffer for astman_append
 
 AST_THREADSTORAGE_CUSTOM_SCOPE (manager_event_buf, NULL, ast_free_ptr, static)
 
 AST_THREADSTORAGE_CUSTOM_SCOPE (userevent_buf, NULL, ast_free_ptr, static)
 
int ast_webmanager_check_enabled (void)
 Check if AMI/HTTP is enabled.
 
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.
 
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.
 
struct ast_datastoreastman_datastore_find (struct mansession *s, const struct ast_datastore_info *info, const char *uid)
 Find a datastore on a session.
 
int astman_datastore_remove (struct mansession *s, struct ast_datastore *datastore)
 Remove a datastore from a session.
 
static void astman_flush (struct mansession *s, struct ast_str *buf)
 
static void astman_free_headers (struct message *m)
 Free headers inside message structure, but not the message structure itself.
 
const char * astman_get_header (const struct message *m, char *var)
 Return the first matching variable from an array.
 
struct ast_variableastman_get_variables (const struct message *m)
 Get a linked list of the Variable: headers.
 
struct ast_variableastman_get_variables_order (const struct message *m, enum variable_orders order)
 Get a linked list of the Variable: headers with order specified.
 
int astman_is_authed (uint32_t ident)
 Determine if a manager session ident is authenticated.
 
void astman_live_dangerously (int new_live_dangerously)
 Enable/disable the inclusion of 'dangerous' configurations outside of the ast_config_AST_CONFIG_DIR.
 
void astman_send_ack (struct mansession *s, const struct message *m, char *msg)
 Send ack in manager transaction.
 
void astman_send_error (struct mansession *s, const struct message *m, char *error)
 Send error in manager transaction.
 
void astman_send_error_va (struct mansession *s, const struct message *m, const char *fmt,...)
 Send error in manager transaction (with va_args support)
 
static void astman_send_list_complete (struct mansession *s, const struct message *m, const char *event_name, int count)
 
void astman_send_list_complete_end (struct mansession *s)
 End the list complete event.
 
void astman_send_list_complete_start (struct mansession *s, const struct message *m, const char *event_name, int count)
 Start the list complete event.
 
static struct ast_strastman_send_list_complete_start_common (struct mansession *s, const struct message *m, const char *event_name, int count)
 
void astman_send_listack (struct mansession *s, const struct message *m, char *msg, char *listflag)
 Send ack in manager transaction to begin a list.
 
void astman_send_response (struct mansession *s, const struct message *m, char *resp, char *msg)
 Send response in manager transaction.
 
static void astman_send_response_full (struct mansession *s, const struct message *m, char *resp, char *msg, char *listflag)
 send a response with an optional message, and terminate it with an empty line. m is used only to grab the 'ActionID' field.
 
static void astman_start_ack (struct mansession *s, const struct message *m)
 
int astman_verify_session_readpermissions (uint32_t ident, int perm)
 Verify a session's read permissions against a permission mask.
 
int astman_verify_session_writepermissions (uint32_t ident, int perm)
 Verify a session's write permissions against a permission mask.
 
static int async_goto_with_discard_bridge_after (struct ast_channel *chan, const char *context, const char *exten, int priority)
 
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.
 
static struct mansession_sessionbuild_mansession (const struct ast_sockaddr *addr)
 Allocate manager session structure and add it to the list of sessions.
 
static int check_blacklist (const char *cmd)
 
static int check_manager_session_inuse (const char *name)
 
static void close_mansession_file (struct mansession *s)
 
static int coreshowchannelmap_add_connected_channels (struct ao2_container *channel_map, struct ast_channel_snapshot *channel_snapshot, struct ast_bridge_snapshot *bridge_snapshot)
 Recursive function to get all channels in a bridge. Follow local channels as well.
 
static int coreshowchannelmap_add_to_map (struct ao2_container *c, const char *s)
 Helper function to add a channel name to the vector.
 
static void destroy_fast_originate_helper (struct fast_originate_helper *doomed)
 
static int do_message (struct mansession *s)
 
static void event_filter_destructor (void *obj)
 
static void * fast_originate (void *data)
 
static int file_in_modules_dir (const char *filename)
 Check if the given file path is in the modules dir or not.
 
static int filter_cmp_fn (void *obj, void *arg, void *data, int flags)
 
static struct mansession_sessionfind_session (uint32_t ident, int incinuse)
 
static struct mansession_sessionfind_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
 
static int function_capable_string_allowed_with_auths (const char *evaluating, int writepermlist)
 Checks to see if a string which can be used to evaluate functions should be rejected.
 
static void generate_status (struct mansession *s, struct ast_channel *chan, char **vars, int varc, int all_variables, char *id_text, int *count)
 
static int 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_userget_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.
 
static int get_perm (const char *instr)
 
static struct eventqentgrab_last (void)
 
static char * handle_kickmanconn (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 CLI command manager kick session.
 
static char * handle_manager_reload (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 CLI command manager reload.
 
static char * handle_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.
 
static char * handle_mandebug (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 
static void handle_parse_error (struct mansession *s, struct message *m, char *error)
 
static char * handle_showmanager (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 
static char * handle_showmanagers (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 
static char * handle_showmancmd (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 
static char * handle_showmancmds (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 CLI command manager list commands.
 
static char * handle_showmanconn (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 CLI command manager list connected.
 
static char * handle_showmaneventq (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 CLI command manager list eventq.
 
static enum error_type handle_updates (struct mansession *s, const struct message *m, struct ast_config *cfg, const char *dfn)
 helper function for action_updateconfig
 
static int is_originate_app_permitted (const char *app, const char *data, int permission)
 
static int is_restricted_file (const char *filename)
 Check if a file is restricted or not.
 
static void json_escape (char *out, const char *in)
 
static void load_channelvars (struct ast_variable *var)
 
static void load_disabledevents (struct ast_variable *var)
 
static int load_module (void)
 
static void log_action (const struct message *m, const char *action)
 
static struct ast_variableman_do_variable_value (struct ast_variable *head, const char *hdr_val)
 
static enum add_filter_result manager_add_filter (const char *criteria, const char *filter_pattern, struct ao2_container *includefilters, struct ao2_container *excludefilters)
 Add an event filter to a manager session.
 
static void manager_default_msg_cb (void *data, struct stasis_subscription *sub, struct stasis_message *message)
 
static int manager_displayconnects (struct mansession_session *session)
 Get displayconnects config option.
 
static void manager_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.
 
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.
 
static int mansession_cmp_fn (void *obj, void *arg, int flags)
 
static enum ast_transport mansession_get_transport (const struct mansession *s)
 
static void mansession_lock (struct mansession *s)
 Lock the 'mansession' structure.
 
static void mansession_unlock (struct mansession *s)
 Unlock the 'mansession' structure.
 
static int match_eventdata (struct event_filter_entry *entry, const char *eventdata)
 Test eventdata against a filter entry.
 
static 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.
 
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
 
static int purge_sessions (int n_max)
 remove at most n_max stale session from the list.
 
static int queue_match (const char *app, const char *data, const char *search)
 
static int queue_read_action_payload (struct ast_channel *chan, const unsigned char *payload, size_t payload_size, enum ast_frame_read_action action)
 Queue a given read action containing a payload onto a channel.
 
static int queue_sendtext (struct ast_channel *chan, const char *body)
 Queue a read action to send a text message.
 
static int queue_sendtext_data (struct ast_channel *chan, const char *body, const char *content_type)
 Queue a read action to send a text data message.
 
static int 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(). )
 
static int set_eventmask (struct mansession *s, const char *eventmask)
 Rather than braindead on,off this now can also accept a specific int mask value or a ',' delim list of mask strings (the same as manager.conf) -anthm.
 
static int should_send_event (struct ao2_container *includefilters, struct ao2_container *excludefilters, struct eventqent *eqe)
 
static int strings_to_mask (const char *string)
 
static int subscribe_all (void)
 
static int unload_module (void)
 
static struct mansession_sessionunref_mansession (struct mansession_session *s)
 Unreference manager session object. If no more references, then go ahead and delete it.
 
static const char * user_authority_to_str (int authority, struct ast_str **res)
 Convert authority code to a list of options for a user. This will only display those authority codes that have an explicit match on authority.
 
static int variable_count_cmp_fn (void *obj, void *vstr, int flags)
 
static int variable_count_hash_fn (const void *vvc, const int flags)
 
static void xml_copy_escape (struct ast_str **out, const char *src, int mode)
 
static void xml_translate (struct ast_str **out, char *in, struct ast_variable *get_vars, enum output_format format)
 Convert the input into XML or HTML. The input is supposed to be a sequence of lines of the form Name: value optionally followed by a blob of unformatted text. A blank line is a section separator. Basically, this is a mixture of the format of Manager Interface and CLI commands. The unformatted text is considered as a single value of a field named 'Opaque-data'.
 
 STASIS_MESSAGE_TYPE_DEFN (ast_manager_get_generic_type)
 Define AMI message types.
 

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 = ASTERISK_GPL_KEY , .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_subscriptionacl_change_sub
 
static struct actions actions = AST_RWLIST_HEAD_INIT_VALUE
 
static struct all_events all_events = AST_RWLIST_HEAD_INIT_VALUE
 
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_infoast_module_info = &__mod_info
 
static int authlimit
 
static int authtimeout
 
static int broken_events_action = 0
 
static struct ast_cli_entry cli_manager []
 
struct { 
 
   const char *   words [AST_MAX_CMD_LEN
 
command_blacklist [] 
 
static const char *const contenttype []
 
static int displayconnects = 1
 
static char global_realm [MAXHOSTNAMELEN]
 
static int httptimeout = 60
 
static int live_dangerously
 Set to true (non-zero) to globally allow all dangerous AMI actions to run.
 
static char * manager_channelvars
 
static int manager_debug = 0
 
static char * manager_disabledevents
 
static int manager_enabled = 0
 
static struct manager_hooks manager_hooks = AST_RWLIST_HEAD_INIT_VALUE
 
static struct stasis_topicmanager_topic
 A stasis_topic that all topics AMI cares about will be forwarded to.
 
static struct ast_custom_function managerclient_function
 description of AMI_CLIENT dialplan function
 
static struct ast_http_uri manageruri
 
static struct ast_http_uri managerxmluri
 
static char * match_type_names []
 
static struct originate_permissions_entry originate_app_permissions []
 
static const struct permalias perms []
 
static struct ast_http_uri rawmanuri
 
static struct stasis_forwardrtp_topic_forwarder
 The stasis_subscription for forwarding the RTP topic to the AMI topic.
 
static struct stasis_forwardsecurity_topic_forwarder
 The stasis_subscription for forwarding the Security topic to the AMI topic.
 
static struct stasis_message_routerstasis_router
 The stasis_message_router for all Stasis Message Bus API messages.
 
static int subscribed = 0
 
static int timestampevents
 
static int unauth_sessions = 0
 
static struct users users = AST_RWLIST_HEAD_INIT_VALUE
 
static int webmanager_enabled = 0
 
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:

manager.conf

Definition in file manager.c.

Macro Definition Documentation

◆ FORMAT

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

◆ FORMAT2

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

◆ FORMAT3

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

◆ HSMC_FORMAT

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

◆ HSMCONN_FORMAT1

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

◆ HSMCONN_FORMAT2

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

◆ ROW_FMT

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

◆ TEST_STRING

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

Enumeration Type Documentation

◆ output_format

Enumerator
FORMAT_RAW 
FORMAT_HTML 
FORMAT_XML 

Definition at line 7910 of file manager.c.

7910 {
7911 FORMAT_RAW,
7913 FORMAT_XML,
7914};
@ FORMAT_RAW
Definition manager.c:7911
@ FORMAT_HTML
Definition manager.c:7912
@ FORMAT_XML
Definition manager.c:7913

Function Documentation

◆ __init_manager()

static int __init_manager ( int  reload,
int  by_external_config 
)
static

Definition at line 9645 of file manager.c.

9646{
9647 struct ast_config *cfg = NULL;
9648 const char *val;
9649 char *cat = NULL;
9650 int newhttptimeout = 60;
9651 struct ast_manager_user *user = NULL;
9652 struct ast_variable *var;
9653 struct ast_flags config_flags = { (reload && !by_external_config) ? CONFIG_FLAG_FILEUNCHANGED : 0 };
9654 char a1[337];
9655 char a1_hash[256];
9656 struct ast_sockaddr ami_desc_local_address_tmp;
9657 struct ast_sockaddr amis_desc_local_address_tmp;
9658 int tls_was_enabled = 0;
9659 int acl_subscription_flag = 0;
9660
9661 if (!reload) {
9662 struct ao2_container *sessions;
9663#ifdef AST_XML_DOCS
9664 struct ao2_container *temp_event_docs;
9665#endif
9666 int res;
9667
9669 if (res != 0) {
9670 return -1;
9671 }
9672 manager_topic = stasis_topic_create("manager:core");
9673 if (!manager_topic) {
9674 return -1;
9675 }
9676
9677 /* Register default actions */
9717
9718#ifdef TEST_FRAMEWORK
9719 test_suite_forwarder = stasis_forward_all(ast_test_suite_topic(), manager_topic);
9720#endif
9721
9725
9726 /* Append placeholder event so master_eventq never runs dry */
9727 if (append_event("Event: Placeholder\r\n\r\n",
9728 ast_str_hash("Placeholder"), 0)) {
9729 return -1;
9730 }
9731
9732#ifdef AST_XML_DOCS
9733 temp_event_docs = ast_xmldoc_build_documentation("managerEvent");
9734 if (temp_event_docs) {
9735 ao2_t_global_obj_replace_unref(event_docs, temp_event_docs, "Toss old event docs");
9736 ao2_t_ref(temp_event_docs, -1, "Remove creation ref - container holds only ref now");
9737 }
9738#endif
9739
9740 /* If you have a NULL hash fn, you only need a single bucket */
9742 if (!sessions) {
9743 return -1;
9744 }
9746 ao2_ref(sessions, -1);
9747
9748 /* Initialize all settings before first configuration load. */
9750 }
9751
9752 cfg = ast_config_load2("manager.conf", "manager", config_flags);
9753 if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
9754 return 0;
9755 } else if (!cfg || cfg == CONFIG_STATUS_FILEINVALID) {
9756 ast_log(LOG_NOTICE, "Unable to open AMI configuration manager.conf, or configuration is invalid.\n");
9757 return 0;
9758 }
9759
9760 /* 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. */
9761 if (!by_external_config) {
9763 }
9764
9765 if (reload) {
9766 /* Reset all settings before reloading configuration */
9767 tls_was_enabled = ami_tls_cfg.enabled;
9769 }
9770
9771 ast_sockaddr_parse(&ami_desc_local_address_tmp, "[::]", 0);
9772 ast_sockaddr_set_port(&ami_desc_local_address_tmp, DEFAULT_MANAGER_PORT);
9773
9774 for (var = ast_variable_browse(cfg, "general"); var; var = var->next) {
9775 val = var->value;
9776
9777 /* read tls config options while preventing unsupported options from being set */
9778 if (strcasecmp(var->name, "tlscafile")
9779 && strcasecmp(var->name, "tlscapath")
9780 && strcasecmp(var->name, "tlscadir")
9781 && strcasecmp(var->name, "tlsverifyclient")
9782 && strcasecmp(var->name, "tlsdontverifyserver")
9783 && strcasecmp(var->name, "tlsclientmethod")
9784 && strcasecmp(var->name, "sslclientmethod")
9786 continue;
9787 }
9788
9789 if (!strcasecmp(var->name, "enabled")) {
9791 } else if (!strcasecmp(var->name, "webenabled")) {
9793 } else if (!strcasecmp(var->name, "port")) {
9794 int bindport;
9795 if (ast_parse_arg(val, PARSE_UINT32|PARSE_IN_RANGE, &bindport, 1024, 65535)) {
9796 ast_log(LOG_WARNING, "Invalid port number '%s'\n", val);
9797 }
9798 ast_sockaddr_set_port(&ami_desc_local_address_tmp, bindport);
9799 } else if (!strcasecmp(var->name, "bindaddr")) {
9800 /* remember port if it has already been set */
9801 int setport = ast_sockaddr_port(&ami_desc_local_address_tmp);
9802
9804 ast_log(LOG_WARNING, "Invalid address '%s' specified, default '%s' will be used\n", val,
9805 ast_sockaddr_stringify_addr(&ami_desc_local_address_tmp));
9806 } else {
9807 ast_sockaddr_parse(&ami_desc_local_address_tmp, val, PARSE_PORT_IGNORE);
9808 }
9809
9810 if (setport) {
9811 ast_sockaddr_set_port(&ami_desc_local_address_tmp, setport);
9812 }
9813
9814 } else if (!strcasecmp(var->name, "brokeneventsaction")) {
9816 } else if (!strcasecmp(var->name, "allowmultiplelogin")) {
9818 } else if (!strcasecmp(var->name, "displayconnects")) {
9820 } else if (!strcasecmp(var->name, "timestampevents")) {
9822 } else if (!strcasecmp(var->name, "debug")) {
9824 } else if (!strcasecmp(var->name, "httptimeout")) {
9825 newhttptimeout = atoi(val);
9826 } else if (!strcasecmp(var->name, "authtimeout")) {
9827 int timeout = atoi(var->value);
9828
9829 if (timeout < 1) {
9830 ast_log(LOG_WARNING, "Invalid authtimeout value '%s', using default value\n", var->value);
9831 } else {
9832 authtimeout = timeout;
9833 }
9834 } else if (!strcasecmp(var->name, "authlimit")) {
9835 int limit = atoi(var->value);
9836
9837 if (limit < 1) {
9838 ast_log(LOG_WARNING, "Invalid authlimit value '%s', using default value\n", var->value);
9839 } else {
9840 authlimit = limit;
9841 }
9842 } else if (!strcasecmp(var->name, "channelvars")) {
9844 } else if (!strcasecmp(var->name, "disabledevents")) {
9846 } else {
9847 ast_log(LOG_NOTICE, "Invalid keyword <%s> = <%s> in manager.conf [general]\n",
9848 var->name, val);
9849 }
9850 }
9851
9852 if (manager_enabled && !subscribed) {
9853 if (subscribe_all() != 0) {
9854 ast_log(LOG_ERROR, "Manager subscription error\n");
9855 return -1;
9856 }
9857 }
9858
9859 ast_sockaddr_copy(&amis_desc_local_address_tmp, &amis_desc.local_address);
9860
9861 /* if the amis address has not been set, default is the same as non secure ami */
9862 if (ast_sockaddr_isnull(&amis_desc_local_address_tmp)) {
9863 ast_sockaddr_copy(&amis_desc_local_address_tmp, &ami_desc_local_address_tmp);
9864 }
9865
9866 /* if the amis address was not set, it will have non-secure ami port set; if
9867 amis address was set, we need to check that a port was set or not, if not
9868 use the default tls port */
9869 if (ast_sockaddr_port(&amis_desc_local_address_tmp) == 0 ||
9870 (ast_sockaddr_port(&ami_desc_local_address_tmp) == ast_sockaddr_port(&amis_desc_local_address_tmp))) {
9871
9872 ast_sockaddr_set_port(&amis_desc_local_address_tmp, DEFAULT_MANAGER_TLS_PORT);
9873 }
9874
9875 if (manager_enabled) {
9876 ast_sockaddr_copy(&ami_desc.local_address, &ami_desc_local_address_tmp);
9877 ast_sockaddr_copy(&amis_desc.local_address, &amis_desc_local_address_tmp);
9878 }
9879
9881
9882 while ((cat = ast_category_browse(cfg, cat))) {
9883 struct ast_acl_list *oldacl;
9884
9885 if (!strcasecmp(cat, "general")) {
9886 continue;
9887 }
9888
9889 /* Look for an existing entry, if none found - create one and add it to the list */
9890 if (!(user = get_manager_by_name_locked(cat))) {
9891 if (!(user = ast_calloc(1, sizeof(*user)))) {
9892 break;
9893 }
9894 /* Copy name over */
9895 ast_copy_string(user->username, cat, sizeof(user->username));
9896
9897 user->acl = NULL;
9898 user->readperm = 0;
9899 user->writeperm = 0;
9900 /* Default displayconnect from [general] */
9901 user->displayconnects = displayconnects;
9902 /* Default allowmultiplelogin from [general] */
9903 user->allowmultiplelogin = allowmultiplelogin;
9904 user->writetimeout = 100;
9907 if (!user->includefilters || !user->excludefilters) {
9909 break;
9910 }
9911
9912 /* Insert into list */
9914 } else {
9915 ao2_t_callback(user->includefilters, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, NULL, NULL, "unlink all include filters");
9916 ao2_t_callback(user->excludefilters, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, NULL, NULL, "unlink all exclude filters");
9917 }
9918
9919 /* Make sure we keep this user and don't destroy it during cleanup */
9920 user->keep = 1;
9921 oldacl = user->acl;
9922 user->acl = NULL;
9923 ast_variables_destroy(user->chanvars);
9924
9925 var = ast_variable_browse(cfg, cat);
9926 for (; var; var = var->next) {
9927 if (!strcasecmp(var->name, "secret")) {
9928 ast_free(user->secret);
9929 user->secret = ast_strdup(var->value);
9930 } else if (!strcasecmp(var->name, "deny") ||
9931 !strcasecmp(var->name, "permit") ||
9932 !strcasecmp(var->name, "acl")) {
9933 int acl_error = 0;
9934
9935 ast_append_acl(var->name, var->value, &user->acl, &acl_error, &acl_subscription_flag);
9936 if (acl_error) {
9937 ast_log(LOG_ERROR, "Invalid ACL '%s' for manager user '%s' on line %d. Deleting user\n",
9938 var->value, user->username, var->lineno);
9939 user->keep = 0;
9940 }
9941 } else if (!strcasecmp(var->name, "read") ) {
9942 user->readperm = get_perm(var->value);
9943 } else if (!strcasecmp(var->name, "write") ) {
9944 user->writeperm = get_perm(var->value);
9945 } else if (!strcasecmp(var->name, "displayconnects") ) {
9946 user->displayconnects = ast_true(var->value);
9947 } else if (!strcasecmp(var->name, "allowmultiplelogin") ) {
9948 user->allowmultiplelogin = ast_true(var->value);
9949 } else if (!strcasecmp(var->name, "writetimeout")) {
9950 int value = atoi(var->value);
9951 if (value < 100) {
9952 ast_log(LOG_WARNING, "Invalid writetimeout value '%s' at line %d\n", var->value, var->lineno);
9953 } else {
9954 user->writetimeout = value;
9955 }
9956 } else if (!strcasecmp(var->name, "setvar")) {
9957 struct ast_variable *tmpvar;
9958 char varbuf[256];
9959 char *varval;
9960 char *varname;
9961
9962 ast_copy_string(varbuf, var->value, sizeof(varbuf));
9963 varname = varbuf;
9964
9965 if ((varval = strchr(varname,'='))) {
9966 *varval++ = '\0';
9967 if ((tmpvar = ast_variable_new(varname, varval, ""))) {
9968 tmpvar->next = user->chanvars;
9969 user->chanvars = tmpvar;
9970 }
9971 }
9972 } else if (ast_begins_with(var->name, "eventfilter")) {
9973 const char *value = var->value;
9974 manager_add_filter(var->name, value, user->includefilters, user->excludefilters);
9975 } else {
9976 ast_debug(1, "%s is an unknown option.\n", var->name);
9977 }
9978 }
9979
9980 oldacl = ast_free_acl_list(oldacl);
9981 }
9982 ast_config_destroy(cfg);
9983
9984 /* Check the flag for named ACL event subscription and if we need to, register a subscription. */
9985 if (acl_subscription_flag && !by_external_config) {
9987 }
9988
9989 /* Perform cleanup - essentially prune out old users that no longer exist */
9991 if (user->keep) { /* valid record. clear flag for the next round */
9992 user->keep = 0;
9993
9994 /* Calculate A1 for Digest auth */
9995 snprintf(a1, sizeof(a1), "%s:%s:%s", user->username, global_realm, user->secret);
9996 ast_md5_hash(a1_hash,a1);
9997 ast_free(user->a1_hash);
9998 user->a1_hash = ast_strdup(a1_hash);
9999 continue;
10000 }
10001 /* We do not need to keep this user so take them out of the list */
10003 ast_debug(4, "Pruning user '%s'\n", user->username);
10005 }
10007
10009
10011 if (!webregged) {
10015
10019 webregged = 1;
10020 }
10021 } else {
10022 if (webregged) {
10026
10030 webregged = 0;
10031 }
10032 }
10033
10034 if (newhttptimeout > 0) {
10035 httptimeout = newhttptimeout;
10036 }
10037
10039 if (tls_was_enabled && !ami_tls_cfg.enabled) {
10041 } else if (ast_ssl_setup(amis_desc.tls_cfg)) {
10043 }
10044
10045 return 0;
10046}
void ast_append_acl(const char *sense, const char *stuff, struct ast_acl_list **path, int *error, int *named_acl_flag)
Add a rule to an ACL struct.
Definition acl.c:429
struct ast_acl_list * ast_free_acl_list(struct ast_acl_list *acl)
Free a list of ACLs.
Definition acl.c:233
#define var
Definition ast_expr2f.c:605
#define ast_free(a)
Definition astmm.h:180
#define ast_strdup(str)
A wrapper for strdup()
Definition astmm.h:241
#define ast_calloc(num, len)
A wrapper for calloc()
Definition astmm.h:202
#define ast_log
Definition astobj2.c:42
#define ao2_t_ref(o, delta, tag)
Definition astobj2.h:460
@ AO2_ALLOC_OPT_LOCK_MUTEX
Definition astobj2.h:363
#define ao2_global_obj_replace_unref(holder, obj)
Replace an ao2 object in the global holder, throwing away any old object.
Definition astobj2.h:901
#define ao2_t_global_obj_replace_unref(holder, obj, tag)
Definition astobj2.h:904
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition astobj2.h:459
@ OBJ_NODATA
Definition astobj2.h:1044
@ OBJ_MULTIPLE
Definition astobj2.h:1049
@ OBJ_UNLINK
Definition astobj2.h:1039
#define ao2_container_alloc_list(ao2_options, container_options, sort_fn, cmp_fn)
Allocate and initialize a list container.
Definition astobj2.h:1327
#define ao2_t_callback(c, flags, cb_fn, arg, tag)
Definition astobj2.h:1696
static struct unistimsession * sessions
#define ast_cli_register_multiple(e, len)
Register multiple commands.
Definition cli.h:265
static int action_setvar(struct mansession *s, const struct message *m)
Definition manager.c:3548
static int action_createconfig(struct mansession *s, const struct message *m)
Definition manager.c:3093
static int manager_state_cb(const char *context, const char *exten, struct ast_state_cb_info *info, void *data)
Definition manager.c:7728
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...
Definition manager.c:6829
static struct ast_manager_user * get_manager_by_name_locked(const char *name)
Definition manager.c:1042
static void acl_change_stasis_subscribe(void)
Definition manager.c:231
static int append_event(const char *str, int event_name_hash, int category)
events are appended to a queue from where they can be dispatched to clients.
Definition manager.c:7496
static int manager_enabled
Definition manager.c:166
static int action_sendtext(struct mansession *s, const struct message *m)
Definition manager.c:3904
static int action_mailboxcount(struct mansession *s, const struct message *m)
Definition manager.c:5439
static int action_getconfigjson(struct mansession *s, const struct message *m)
Definition manager.c:2645
static int action_listcategories(struct mansession *s, const struct message *m)
Definition manager.c:2569
static int action_hangup(struct mansession *s, const struct message *m)
Definition manager.c:3542
static int action_listcommands(struct mansession *s, const struct message *m)
Definition manager.c:3285
static int action_atxfer(struct mansession *s, const struct message *m)
Definition manager.c:4144
static int action_timeout(struct mansession *s, const struct message *m)
Definition manager.c:5533
static int action_coresettings(struct mansession *s, const struct message *m)
Show PBX core settings information.
Definition manager.c:6462
static int mansession_cmp_fn(void *obj, void *arg, int flags)
Definition manager.c:999
static int displayconnects
Definition manager.c:161
static int action_filter(struct mansession *s, const struct message *m)
Manager command to add an event filter to a manager session.
Definition manager.c:5685
static int manager_debug
Definition manager.c:169
static int action_mailboxstatus(struct mansession *s, const struct message *m)
Definition manager.c:5422
static int action_login(struct mansession *s, const struct message *m)
Definition manager.c:3354
static int action_getvar(struct mansession *s, const struct message *m)
Definition manager.c:3581
static int action_blind_transfer(struct mansession *s, const struct message *m)
Definition manager.c:4098
static int action_extensionstate(struct mansession *s, const struct message *m)
Definition manager.c:5460
static int action_getconfig(struct mansession *s, const struct message *m)
Definition manager.c:2497
static enum add_filter_result manager_add_filter(const char *criteria, const char *filter_pattern, struct ao2_container *includefilters, struct ao2_container *excludefilters)
Add an event filter to a manager session.
Definition manager.c:5752
static int action_logoff(struct mansession *s, const struct message *m)
Definition manager.c:3348
static int action_updateconfig(struct mansession *s, const struct message *m)
Definition manager.c:3002
static int manager_moduleload(struct mansession *s, const struct message *m)
Definition manager.c:6906
static void acl_change_stasis_unsubscribe(void)
Definition manager.c:241
static int action_reload(struct mansession *s, const struct message *m)
Send a reload event.
Definition manager.c:6548
static int authlimit
Definition manager.c:171
static int action_aocmessage(struct mansession *s, const struct message *m)
Definition manager.c:4934
static int action_events(struct mansession *s, const struct message *m)
Definition manager.c:3304
static int action_redirect(struct mansession *s, const struct message *m)
action_redirect: The redirect manager command
Definition manager.c:3953
static int action_presencestate(struct mansession *s, const struct message *m)
Definition manager.c:5490
static int allowmultiplelogin
Definition manager.c:162
static int action_cancel_atxfer(struct mansession *s, const struct message *m)
Definition manager.c:4198
static char global_realm[MAXHOSTNAMELEN]
Definition manager.c:176
static int action_originate(struct mansession *s, const struct message *m)
Definition manager.c:5227
static int action_userevent(struct mansession *s, const struct message *m)
Definition manager.c:6441
static int action_command(struct mansession *s, const struct message *m)
Manager command "command" - execute CLI command.
Definition manager.c:4275
static int broken_events_action
Definition manager.c:165
static int timestampevents
Definition manager.c:163
static int subscribed
Definition manager.c:167
static int authtimeout
Definition manager.c:170
static int manager_modulecheck(struct mansession *s, const struct message *m)
Manager function to check if module is loaded.
Definition manager.c:6841
static int webmanager_enabled
Definition manager.c:168
static int action_status(struct mansession *s, const struct message *m)
Manager "status" command to show channels.
Definition manager.c:3748
static int get_perm(const char *instr)
Definition manager.c:862
static int action_coreshowchannels(struct mansession *s, const struct message *m)
Manager command "CoreShowChannels" - List currently defined channels and some information about them.
Definition manager.c:6580
static int action_corestatus(struct mansession *s, const struct message *m)
Show PBX core status information.
Definition manager.c:6506
static int action_challenge(struct mansession *s, const struct message *m)
Definition manager.c:3403
static struct stasis_topic * manager_topic
A stasis_topic that all topics AMI cares about will be forwarded to.
Definition manager.c:182
static int action_waitevent(struct mansession *s, const struct message *m)
Definition manager.c:3167
static int action_coreshowchannelmap(struct mansession *s, const struct message *m)
Manager command "CoreShowChannelMap" - Lists all channels connected to the specified channel.
Definition manager.c:6748
static int action_ping(struct mansession *s, const struct message *m)
Definition manager.c:2425
static int httptimeout
Definition manager.c:164
void ast_http_uri_unlink(struct ast_http_uri *urihandler)
Unregister a URI handler.
Definition http.c:721
int ast_http_uri_link(struct ast_http_uri *urihandler)
Register a URI handler.
Definition http.c:689
struct ast_config * ast_config_load2(const char *filename, const char *who_asked, struct ast_flags flags)
Load a config file.
char * ast_category_browse(struct ast_config *config, const char *prev_name)
Browse categories.
Definition extconf.c:3324
#define ast_variable_new(name, value, filename)
#define CONFIG_STATUS_FILEUNCHANGED
#define CONFIG_STATUS_FILEINVALID
int ast_parse_arg(const char *arg, enum ast_parse_flags flags, void *p_result,...)
The argument parsing routine.
void ast_config_destroy(struct ast_config *cfg)
Destroys a config.
Definition extconf.c:1287
@ CONFIG_FLAG_FILEUNCHANGED
void ast_variables_destroy(struct ast_variable *var)
Free variable list.
Definition extconf.c:1260
struct ast_variable * ast_variable_browse(const struct ast_config *config, const char *category_name)
Definition extconf.c:1213
#define ast_debug(level,...)
Log a DEBUG message.
#define LOG_ERROR
#define LOG_NOTICE
#define LOG_WARNING
#define AST_RWLIST_REMOVE_CURRENT
#define AST_RWLIST_TRAVERSE_SAFE_BEGIN
#define AST_RWLIST_WRLOCK(head)
Write locks a list.
Definition linkedlists.h:52
#define AST_RWLIST_UNLOCK(head)
Attempts to unlock a read/write based list.
#define AST_RWLIST_TRAVERSE_SAFE_END
#define AST_RWLIST_INSERT_TAIL
static struct ast_tls_config ami_tls_cfg
Definition manager.c:9109
static struct ast_tcptls_session_args ami_desc
Definition manager.c:9110
static struct ast_http_uri managerxmluri
Definition manager.c:8949
static struct ast_tcptls_session_args amis_desc
Definition manager.c:9121
static struct ast_custom_function managerclient_function
description of AMI_CLIENT dialplan function
Definition manager.c:9082
static void load_channelvars(struct ast_variable *var)
Definition manager.c:9397
static struct ast_http_uri manageruri
Definition manager.c:8941
static void manager_set_defaults(void)
Definition manager.c:9617
static struct ast_http_uri arawmanuri
Definition manager.c:8992
static struct ast_http_uri rawmanuri
Definition manager.c:8933
static struct ast_cli_entry cli_manager[]
Definition manager.c:9374
static void manager_free_user(struct ast_manager_user *user)
Definition manager.c:9430
static struct ast_http_uri amanageruri
Definition manager.c:9001
static int webregged
Definition manager.c:9088
static int subscribe_all(void)
Definition manager.c:9587
static struct ast_http_uri amanagerxmluri
Definition manager.c:9010
static void load_disabledevents(struct ast_variable *var)
Definition manager.c:9420
#define EVENT_FLAG_REPORTING
Definition manager.h:84
#define ast_manager_register_xml_core(action, authority, func)
Register a manager callback using XML documentation to describe the manager.
Definition manager.h:203
#define EVENT_FLAG_CONFIG
Definition manager.h:82
#define EVENT_FLAG_SYSTEM
Definition manager.h:75
struct stasis_message_type * ast_manager_get_generic_type(void)
Get the stasis_message_type for generic messages.
#define DEFAULT_MANAGER_PORT
Definition manager.h:58
#define DEFAULT_MANAGER_TLS_PORT
Definition manager.h:59
#define EVENT_FLAG_CALL
Definition manager.h:76
#define EVENT_FLAG_COMMAND
Definition manager.h:79
#define EVENT_FLAG_USER
Definition manager.h:81
#define EVENT_FLAG_AOC
Definition manager.h:91
#define EVENT_FLAG_ORIGINATE
Definition manager.h:87
#define ast_sockaddr_port(addr)
Get the port number of a socket address.
Definition netsock2.h:517
static void ast_sockaddr_copy(struct ast_sockaddr *dst, const struct ast_sockaddr *src)
Copies the data from one ast_sockaddr to another.
Definition netsock2.h:167
int ast_sockaddr_parse(struct ast_sockaddr *addr, const char *str, int flags)
Parse an IPv4 or IPv6 address string.
Definition netsock2.c:230
static int ast_sockaddr_isnull(const struct ast_sockaddr *addr)
Checks if the ast_sockaddr is null. "null" in this sense essentially means uninitialized,...
Definition netsock2.h:127
#define ast_sockaddr_set_port(addr, port)
Sets the port number of a socket address.
Definition netsock2.h:532
static char * ast_sockaddr_stringify_addr(const struct ast_sockaddr *addr)
Wrapper around ast_sockaddr_stringify_fmt() to return an address only.
Definition netsock2.h:286
int __ast_custom_function_register(struct ast_custom_function *acf, struct ast_module *mod)
Register a custom function.
int ast_extension_state_add(const char *context, const char *exten, ast_state_cb_type change_cb, void *data)
Add watcher for extension states.
Definition pbx.c:3844
static int reload(void)
#define NULL
Definition resample.c:96
struct stasis_topic * stasis_topic_create(const char *name)
Create a new topic.
Definition stasis.c:684
#define STASIS_MESSAGE_TYPE_INIT(name)
Boiler-plate messaging macro for initializing message types.
Definition stasis.h:1493
struct stasis_forward * stasis_forward_all(struct stasis_topic *from_topic, struct stasis_topic *to_topic)
Create a subscription which forwards all messages from one topic to another.
Definition stasis.c:1645
static force_inline int attribute_pure ast_str_hash(const char *str)
Compute a hash value on a string.
Definition strings.h:1259
int attribute_pure ast_true(const char *val)
Make sure something is true. Determine if a string containing a boolean value is "true"....
Definition utils.c:2235
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition strings.h:425
static int force_inline attribute_pure ast_begins_with(const char *str, const char *prefix)
Checks whether a string begins with another.
Definition strings.h:97
Generic container type.
Wrapper for an ast_acl linked list.
Definition acl.h:76
Structure used to handle boolean flags.
Definition utils.h:217
user descriptor, as read from the config file.
Definition manager.c:342
Socket address structure.
Definition netsock2.h:97
struct ast_sockaddr local_address
Definition tcptls.h:131
const char * name
Definition tcptls.h:143
struct ast_tls_config * tls_cfg
Definition tcptls.h:135
Structure for variables, used for configurations and for channel variables.
struct ast_variable * next
structure to hold users read from phoneprov_users.conf
list of users found in the config file
int value
Definition syslog.c:37
void ast_tcptls_server_stop(struct ast_tcptls_session_args *desc)
Shutdown a running server if there is one.
Definition tcptls.c:933
int ast_ssl_setup(struct ast_tls_config *cfg)
Set up an SSL server.
Definition tcptls.c:577
void ast_tcptls_server_start(struct ast_tcptls_session_args *desc)
This is a generic (re)start routine for a TCP server, which does the socket/bind/listen and starts a ...
Definition tcptls.c:768
int ast_tls_read_conf(struct ast_tls_config *tls_cfg, struct ast_tcptls_session_args *tls_desc, const char *varname, const char *value)
Used to parse conf files containing tls/ssl options.
Definition tcptls.c:959
#define ARRAY_LEN(a)
Definition utils.h:703
void ast_md5_hash(char *output, const char *input)
Produces MD5 hash based on input string.
Definition utils.c:250
struct ao2_container * ast_xmldoc_build_documentation(const char *type)
Build the documentation for a particular source type.
Definition xmldoc.c:2783

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

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

◆ __reg_module()

static void __reg_module ( void  )
static

Definition at line 10183 of file manager.c.

◆ __unreg_module()

static void __unreg_module ( void  )
static

Definition at line 10183 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_flagsFlags the event should be raised with.
manager_eventThe event to be raised, should be a string literal.
extra_fields_fmtFormat string for extra fields to include. Or NO_EXTRA_FIELDS for no extra fields.
Returns
New ast_manager_event_blob object.
Return values
NULLon error.

Definition at line 10144 of file manager.c.

10149{
10150 struct ast_manager_event_blob *ev;
10151 va_list argp;
10152
10153 ast_assert(extra_fields_fmt != NULL);
10155
10157 if (!ev) {
10158 return NULL;
10159 }
10160
10161 if (ast_string_field_init(ev, 20)) {
10162 ao2_ref(ev, -1);
10163 return NULL;
10164 }
10165
10168
10169 va_start(argp, extra_fields_fmt);
10170 ast_string_field_ptr_build_va(ev, &ev->extra_fields, extra_fields_fmt, argp);
10171 va_end(argp);
10172
10173 return ev;
10174}
@ AO2_ALLOC_OPT_LOCK_NOLOCK
Definition astobj2.h:367
#define ao2_alloc_options(data_size, destructor_fn, options)
Definition astobj2.h:404
static void manager_event_blob_dtor(void *obj)
Definition manager.c:10135
#define manager_event(category, event, contents,...)
External routines may send asterisk manager events this way.
Definition manager.h:254
#define ast_string_field_ptr_build_va(x, ptr, fmt, args)
Set a field to a complex (built) value with prebuilt va_lists.
#define ast_string_field_init(x, size)
Initialize a field pool and fields.
Struct containing info for an AMI event to send out.
Definition manager.h:503
const ast_string_field extra_fields
Definition manager.h:508
const char * manager_event
Definition manager.h:505
#define ast_assert(a)
Definition utils.h:776

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

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

◆ AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM ( void  )

Definition at line 10183 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_stringpointer 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.
headerThe header being applied
valuethe value of the header
Return values
0if successful
non-zeroon failure

Definition at line 10122 of file manager.c.

10124{
10125 if (!*fields_string) {
10126 *fields_string = ast_str_create(128);
10127 if (!*fields_string) {
10128 return -1;
10129 }
10130 }
10131
10132 return (ast_str_append(fields_string, 0, "%s: %s\r\n", header, value) < 0) ? -1 : 0;
10133}
int ast_str_append(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Append to a thread local dynamic string.
Definition strings.h:1139
#define ast_str_create(init_len)
Create a malloc'ed dynamic length string.
Definition strings.h:659

References ast_str_append(), ast_str_create, and value.

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

◆ ast_xml_doc_item_cmp_fn()

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

Definition at line 9176 of file manager.c.

9177{
9178 struct ast_xml_doc_item **item_a = (struct ast_xml_doc_item **)a;
9179 struct ast_xml_doc_item **item_b = (struct ast_xml_doc_item **)b;
9180 return strcmp((*item_a)->name, (*item_b)->name);
9181}
Struct that contains the XML documentation for a particular item. Note that this is an ao2 ref counte...
Definition xmldoc.h:56
static struct test_val b
static struct test_val a

References a, and b.

Referenced by handle_manager_show_events().

◆ astman_datastore_add()

int astman_datastore_add ( struct mansession s,
struct ast_datastore datastore 
)

Add a datastore to a session.

Return values
0success
non-zerofailure
Since
1.6.1

Definition at line 10083 of file manager.c.

10084{
10085 AST_LIST_INSERT_HEAD(&s->session->datastores, datastore, entry);
10086
10087 return 0;
10088}
#define AST_LIST_INSERT_HEAD(head, elm, field)
Inserts a list entry at the head of a list.
struct mansession_session::mansession_datastores datastores
struct mansession_session * session
Definition manager.c:324

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

◆ astman_datastore_find()

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

Find a datastore on a session.

Returns
pointer to the datastore if found
Return values
NULLif not found
Since
1.6.1

Definition at line 10095 of file manager.c.

10096{
10097 struct ast_datastore *datastore = NULL;
10098
10099 if (info == NULL)
10100 return NULL;
10101
10103 if (datastore->info != info) {
10104 continue;
10105 }
10106
10107 if (uid == NULL) {
10108 /* matched by type only */
10109 break;
10110 }
10111
10112 if ((datastore->uid != NULL) && !strcasecmp(uid, datastore->uid)) {
10113 /* Matched by type AND uid */
10114 break;
10115 }
10116 }
10118
10119 return datastore;
10120}
#define AST_LIST_TRAVERSE_SAFE_END
Closes a safe loop traversal block.
#define AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field)
Loops safely over (traverses) the entries in a list.
Structure for a data store object.
Definition datastore.h:64
const struct ast_datastore_info * info
Definition datastore.h:67
const char * uid
Definition datastore.h:65
struct ast_datastore::@227 entry

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

◆ astman_datastore_remove()

int astman_datastore_remove ( struct mansession s,
struct ast_datastore datastore 
)

Remove a datastore from a session.

Return values
0success
non-zerofailure
Since
1.6.1

Definition at line 10090 of file manager.c.

10091{
10092 return AST_LIST_REMOVE(&s->session->datastores, datastore, entry) ? 0 : -1;
10093}
#define AST_LIST_REMOVE(head, elm, field)
Removes a specific entry from a list.

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

◆ astman_is_authed()

int astman_is_authed ( uint32_t  ident)

Determine if a manager session ident is authenticated.

Definition at line 7999 of file manager.c.

8000{
8001 int authed;
8003
8004 if (!(session = find_session(ident, 0)))
8005 return 0;
8006
8007 authed = (session->authenticated != 0);
8008
8011
8012 return authed;
8013}
static struct ast_mansession session
#define ao2_unlock(a)
Definition astobj2.h:729
static struct mansession_session * unref_mansession(struct mansession_session *s)
Unreference manager session object. If no more references, then go ahead and delete it.
Definition manager.c:914
static struct mansession_session * find_session(uint32_t ident, int incinuse)
Definition manager.c:7927

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

Referenced by http_post_callback(), and static_callback().

◆ astman_verify_session_readpermissions()

int astman_verify_session_readpermissions ( uint32_t  ident,
int  perm 
)

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

Parameters
identsession identity
permpermission mask to verify
Return values
1if the session has the permission mask capabilities
0otherwise

Definition at line 8015 of file manager.c.

8016{
8017 int result = 0;
8019 struct ao2_container *sessions;
8020 struct ao2_iterator i;
8021
8022 if (ident == 0) {
8023 return 0;
8024 }
8025
8026 sessions = ao2_global_obj_ref(mgr_sessions);
8027 if (!sessions) {
8028 return 0;
8029 }
8031 ao2_ref(sessions, -1);
8032 while ((session = ao2_iterator_next(&i))) {
8034 if ((session->managerid == ident) && (session->readperm & perm)) {
8035 result = 1;
8038 break;
8039 }
8042 }
8044
8045 return result;
8046}
#define ao2_iterator_next(iter)
Definition astobj2.h:1911
#define ao2_global_obj_ref(holder)
Get a reference to the object stored in the global holder.
Definition astobj2.h:918
struct ao2_iterator ao2_iterator_init(struct ao2_container *c, int flags) attribute_warn_unused_result
Create an iterator for a container.
#define ao2_lock(a)
Definition astobj2.h:717
void ao2_iterator_destroy(struct ao2_iterator *iter)
Destroy a container iterator.
static PGresult * result
Definition cel_pgsql.c:84
When we need to walk through a container, we use an ao2_iterator to keep track of the current positio...
Definition astobj2.h:1821

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

◆ astman_verify_session_writepermissions()

int astman_verify_session_writepermissions ( uint32_t  ident,
int  perm 
)

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

Parameters
identsession identity
permpermission mask to verify
Return values
1if the session has the permission mask capabilities, otherwise 0
0otherwise

Definition at line 8048 of file manager.c.

8049{
8050 int result = 0;
8052 struct ao2_container *sessions;
8053 struct ao2_iterator i;
8054
8055 if (ident == 0) {
8056 return 0;
8057 }
8058
8059 sessions = ao2_global_obj_ref(mgr_sessions);
8060 if (!sessions) {
8061 return 0;
8062 }
8064 ao2_ref(sessions, -1);
8065 while ((session = ao2_iterator_next(&i))) {
8067 if ((session->managerid == ident) && (session->writeperm & perm)) {
8068 result = 1;
8071 break;
8072 }
8075 }
8077
8078 return result;
8079}

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

Referenced by http_post_callback().

◆ auth_http_callback()

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

Definition at line 8577 of file manager.c.

8583{
8585 struct mansession s = { .session = NULL, .tcptls_session = ser };
8586 struct ast_variable *v, *params = get_params;
8587 char template[] = "/tmp/ast-http-XXXXXX"; /* template for temporary file */
8588 struct ast_str *http_header = NULL, *out = NULL;
8589 size_t result_size;
8590 struct message m = { 0 };
8591 int fd;
8592
8593 time_t time_now = time(NULL);
8594 unsigned long nonce = 0, nc;
8595 struct ast_http_digest d = { NULL, };
8596 struct ast_manager_user *user = NULL;
8597 int stale = 0;
8598 char resp_hash[256]="";
8599 /* Cache for user data */
8600 char u_username[80];
8601 int u_readperm;
8602 int u_writeperm;
8603 int u_writetimeout;
8604 int u_displayconnects;
8605
8607 ast_http_error(ser, 501, "Not Implemented", "Attempt to use unimplemented / unsupported method");
8608 return 0;
8609 }
8610
8611 /* Find "Authorization: " header */
8612 for (v = headers; v; v = v->next) {
8613 if (!strcasecmp(v->name, "Authorization")) {
8614 break;
8615 }
8616 }
8617
8618 if (!v || ast_strlen_zero(v->value)) {
8619 goto out_401; /* Authorization Header not present - send auth request */
8620 }
8621
8622 /* Digest found - parse */
8623 if (ast_string_field_init(&d, 128)) {
8625 ast_http_error(ser, 500, "Server Error", "Internal Server Error (out of memory)");
8626 return 0;
8627 }
8628
8629 if (ast_parse_digest(v->value, &d, 0, 1)) {
8630 /* Error in Digest - send new one */
8631 nonce = 0;
8632 goto out_401;
8633 }
8634 if (sscanf(d.nonce, "%30lx", &nonce) != 1) {
8635 ast_log(LOG_WARNING, "Received incorrect nonce in Digest <%s>\n", d.nonce);
8636 nonce = 0;
8637 goto out_401;
8638 }
8639
8641 user = get_manager_by_name_locked(d.username);
8642 if(!user) {
8644 ast_log(LOG_NOTICE, "%s tried to authenticate with nonexistent user '%s'\n", ast_sockaddr_stringify_addr(&session->addr), d.username);
8645 nonce = 0;
8646 goto out_401;
8647 }
8648
8649 /* --- We have User for this auth, now check ACL */
8650 if (user->acl && !ast_apply_acl(user->acl, remote_address, "Manager User ACL:")) {
8652 ast_log(LOG_NOTICE, "%s failed to pass IP ACL as '%s'\n", ast_sockaddr_stringify_addr(&session->addr), d.username);
8654 ast_http_error(ser, 403, "Permission denied", "Permission denied");
8655 return 0;
8656 }
8657
8658 /* --- We have auth, so check it */
8659
8660 /* compute the expected response to compare with what we received */
8661 {
8662 char *a2;
8663 /* ast_md5_hash outputs 32 characters plus NULL terminator. */
8664 char a2_hash[33];
8665 char resp[256];
8666
8667 /* XXX Now request method are hardcoded in A2 */
8668 if (ast_asprintf(&a2, "%s:%s", ast_get_http_method(method), d.uri) < 0) {
8671 ast_http_error(ser, 500, "Server Error", "Internal Server Error (out of memory)");
8672 return 0;
8673 }
8674
8675 ast_md5_hash(a2_hash, a2);
8676 ast_free(a2);
8677
8678 if (d.qop) {
8679 /* RFC 2617 */
8680 snprintf(resp, sizeof(resp), "%s:%08lx:%s:%s:auth:%s", user->a1_hash, nonce, d.nc, d.cnonce, a2_hash);
8681 } else {
8682 /* RFC 2069 */
8683 snprintf(resp, sizeof(resp), "%s:%08lx:%s", user->a1_hash, nonce, a2_hash);
8684 }
8685 ast_md5_hash(resp_hash, resp);
8686 }
8687
8688 if (strncasecmp(d.response, resp_hash, strlen(resp_hash))) {
8689 /* Something was wrong, so give the client to try with a new challenge */
8691 nonce = 0;
8692 goto out_401;
8693 }
8694
8695 /*
8696 * User are pass Digest authentication.
8697 * Now, cache the user data and unlock user list.
8698 */
8699 ast_copy_string(u_username, user->username, sizeof(u_username));
8700 u_readperm = user->readperm;
8701 u_writeperm = user->writeperm;
8702 u_displayconnects = user->displayconnects;
8703 u_writetimeout = user->writetimeout;
8705
8706 if (!(session = find_session_by_nonce(d.username, nonce, &stale))) {
8707 /*
8708 * Create new session.
8709 * While it is not in the list we don't need any locking
8710 */
8711 if (!(session = build_mansession(remote_address))) {
8713 ast_http_error(ser, 500, "Server Error", "Internal Server Error (out of memory)");
8714 return 0;
8715 }
8717
8718 ast_copy_string(session->username, u_username, sizeof(session->username));
8719 session->managerid = nonce;
8720 session->last_ev = grab_last();
8721 AST_LIST_HEAD_INIT_NOLOCK(&session->datastores);
8722
8723 session->readperm = u_readperm;
8724 session->writeperm = u_writeperm;
8725 session->writetimeout = u_writetimeout;
8726
8727 if (u_displayconnects) {
8728 ast_verb(2, "HTTP Manager '%s' logged in from %s\n", session->username, ast_sockaddr_stringify_addr(&session->addr));
8729 }
8730 session->noncetime = session->sessionstart = time_now;
8731 session->authenticated = 1;
8732 } else if (stale) {
8733 /*
8734 * Session found, but nonce is stale.
8735 *
8736 * This could be because an old request (w/old nonce) arrived.
8737 *
8738 * This may be as the result of http proxy usage (separate delay or
8739 * multipath) or in a situation where a page was refreshed too quickly
8740 * (seen in Firefox).
8741 *
8742 * In this situation, we repeat the 401 auth with the current nonce
8743 * value.
8744 */
8745 nonce = session->managerid;
8747 stale = 1;
8748 goto out_401;
8749 } else {
8750 sscanf(d.nc, "%30lx", &nc);
8751 if (session->nc >= nc || ((time_now - session->noncetime) > 62) ) {
8752 /*
8753 * Nonce time expired (> 2 minutes) or something wrong with nonce
8754 * counter.
8755 *
8756 * Create new nonce key and resend Digest auth request. Old nonce
8757 * is saved for stale checking...
8758 */
8759 session->nc = 0; /* Reset nonce counter */
8760 session->oldnonce = session->managerid;
8761 nonce = session->managerid = ast_random();
8762 session->noncetime = time_now;
8764 stale = 1;
8765 goto out_401;
8766 } else {
8767 session->nc = nc; /* All OK, save nonce counter */
8768 }
8769 }
8770
8771
8772 /* Reset session timeout. */
8773 session->sessiontimeout = time(NULL) + (httptimeout > 5 ? httptimeout : 5);
8775
8776 ast_mutex_init(&s.lock);
8777 s.session = session;
8778 fd = mkstemp(template); /* create a temporary file for command output */
8779 unlink(template);
8780 if (fd <= -1) {
8781 ast_http_error(ser, 500, "Server Error", "Internal Server Error (mkstemp failed)");
8782 goto auth_callback_out;
8783 }
8785 if (!s.stream) {
8786 ast_log(LOG_WARNING, "HTTP Manager, fdopen failed: %s!\n", strerror(errno));
8787 ast_http_error(ser, 500, "Server Error", "Internal Server Error (fdopen failed)");
8788 close(fd);
8789 goto auth_callback_out;
8790 }
8791
8792 if (method == AST_HTTP_POST) {
8793 params = ast_http_get_post_vars(ser, headers);
8794 if (!params) {
8795 switch (errno) {
8796 case EFBIG:
8797 ast_http_error(ser, 413, "Request Entity Too Large", "Body too large");
8799 goto auth_callback_out;
8800 case ENOMEM:
8802 ast_http_error(ser, 500, "Server Error", "Out of memory");
8804 goto auth_callback_out;
8805 case EIO:
8806 ast_http_error(ser, 400, "Bad Request", "Error parsing request body");
8808 goto auth_callback_out;
8809 }
8810 }
8811 }
8812
8813 astman_append_headers(&m, params);
8814
8815 if (process_message(&s, &m)) {
8816 if (u_displayconnects) {
8817 ast_verb(2, "HTTP Manager '%s' logged off from %s\n", session->username, ast_sockaddr_stringify_addr(&session->addr));
8818 }
8819
8820 session->needdestroy = 1;
8821 }
8822
8824
8825 result_size = lseek(ast_iostream_get_fd(s.stream), 0, SEEK_CUR); /* Calculate approx. size of result */
8826
8827 http_header = ast_str_create(80);
8828 out = ast_str_create(result_size * 2 + 512);
8829 if (http_header == NULL || out == NULL) {
8831 ast_http_error(ser, 500, "Server Error", "Internal Server Error (ast_str_create() out of memory)");
8833 goto auth_callback_out;
8834 }
8835
8836 ast_str_append(&http_header, 0, "Content-type: text/%s\r\n", contenttype[format]);
8837
8838 if (format == FORMAT_XML) {
8839 ast_str_append(&out, 0, "<ajax-response>\n");
8840 } else if (format == FORMAT_HTML) {
8841 ast_str_append(&out, 0,
8842 "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\r\n"
8843 "<html><head>\r\n"
8844 "<title>Asterisk&trade; Manager Interface</title>\r\n"
8845 "</head><body style=\"background-color: #ffffff;\">\r\n"
8846 "<form method=\"POST\">\r\n"
8847 "<table align=\"center\" style=\"background-color: #f1f1f1;\" width=\"500\">\r\n"
8848 "<tr><th colspan=\"2\" style=\"background-color: #f1f1ff;\"><h1>Manager Tester</h1></th></tr>\r\n"
8849 "<tr><th colspan=\"2\" style=\"background-color: #f1f1ff;\">Action: <input name=\"action\" /> Cmd: <input name=\"command\" /><br>"
8850 "<input type=\"submit\" value=\"Send request\" /></th></tr>\r\n");
8851 }
8852
8853 process_output(&s, &out, params, format);
8854
8855 if (format == FORMAT_XML) {
8856 ast_str_append(&out, 0, "</ajax-response>\n");
8857 } else if (format == FORMAT_HTML) {
8858 ast_str_append(&out, 0, "</table></form></body></html>\r\n");
8859 }
8860
8861 ast_http_send(ser, method, 200, NULL, http_header, out, 0, 0);
8862 http_header = NULL;
8863 out = NULL;
8864
8865auth_callback_out:
8867
8868 /* Clear resources and unlock manager session */
8869 if (method == AST_HTTP_POST && params) {
8870 ast_variables_destroy(params);
8871 }
8872
8873 ast_free(http_header);
8874 ast_free(out);
8875
8877 if (session->stream) {
8878 ast_iostream_close(session->stream);
8879 session->stream = NULL;
8880 }
8882
8883 if (session->needdestroy) {
8884 ast_debug(1, "Need destroy, doing it now!\n");
8886 }
8888 return 0;
8889
8890out_401:
8891 if (!nonce) {
8892 nonce = ast_random();
8893 }
8894
8895 ast_http_auth(ser, global_realm, nonce, nonce, stale, NULL);
8897 return 0;
8898}
enum ast_acl_sense ast_apply_acl(struct ast_acl_list *acl_list, const struct ast_sockaddr *addr, const char *purpose)
Apply a set of rules to a given IP address.
Definition acl.c:799
#define ast_asprintf(ret, fmt,...)
A wrapper for asprintf()
Definition astmm.h:267
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 ...
Definition manager.c:7026
static struct mansession_session * build_mansession(const struct ast_sockaddr *addr)
Allocate manager session structure and add it to the list of sessions.
Definition manager.c:966
static void astman_free_headers(struct message *m)
Free headers inside message structure, but not the message structure itself.
Definition manager.c:1667
static void session_destroy(struct mansession_session *s)
Definition manager.c:1006
static void astman_append_headers(struct message *m, const struct ast_variable *params)
Append additional headers into the message structure from params.
Definition manager.c:1653
static struct eventqent * grab_last(void)
Definition manager.c:694
void ast_http_send(struct ast_tcptls_session_instance *ser, enum ast_http_method method, int status_code, const char *status_title, struct ast_str *http_header, struct ast_str *out, int fd, unsigned int static_content)
Generic function for sending HTTP/1.1 response.
Definition http.c:472
struct ast_variable * ast_http_get_post_vars(struct ast_tcptls_session_instance *ser, struct ast_variable *headers)
Get post variables from client Request Entity-Body, if content type is application/x-www-form-urlenco...
Definition http.c:1405
@ AST_HTTP_POST
Definition http.h:61
@ AST_HTTP_GET
Definition http.h:60
@ AST_HTTP_HEAD
Definition http.h:62
const char * ast_get_http_method(enum ast_http_method method) attribute_pure
Return http method name string.
Definition http.c:193
void ast_http_request_close_on_completion(struct ast_tcptls_session_instance *ser)
Request the HTTP connection be closed after this HTTP request.
Definition http.c:853
void ast_http_error(struct ast_tcptls_session_instance *ser, int status, const char *title, const char *text)
Send HTTP error message and close socket.
Definition http.c:664
#define ast_verb(level,...)
struct ast_iostream * ast_iostream_from_fd(int *fd)
Create an iostream from a file descriptor.
Definition iostream.c:611
int ast_iostream_get_fd(struct ast_iostream *stream)
Get an iostream's file descriptor.
Definition iostream.c:85
int ast_iostream_close(struct ast_iostream *stream)
Close an iostream.
Definition iostream.c:539
#define AST_LIST_HEAD_INIT_NOLOCK(head)
Initializes a list head structure.
#define ast_mutex_init(pmutex)
Definition lock.h:193
#define ast_mutex_destroy(a)
Definition lock.h:195
int errno
static void close_mansession_file(struct mansession *s)
Definition manager.c:8322
static struct mansession_session * find_session_by_nonce(const char *username, unsigned long nonce, int *stale)
Definition manager.c:7966
static void process_output(struct mansession *s, struct ast_str **out, struct ast_variable *params, enum output_format format)
Definition manager.c:8332
static const char *const contenttype[]
Definition manager.c:7916
const char * method
Definition res_pjsip.c:1279
#define ast_string_field_free_memory(x)
free all memory - to be called before destroying the object
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition strings.h:65
HTTP authentication information.
Definition http.h:125
Support for dynamic strings.
Definition strings.h:623
In case you didn't read that giant block of text above the mansession_session struct,...
Definition manager.c:323
struct ast_iostream * stream
Definition manager.c:325
ast_mutex_t lock
Definition manager.c:330
static struct test_val d
FILE * out
Definition utils/frame.c:33
int ast_parse_digest(const char *digest, struct ast_http_digest *d, int request, int pedantic)
Parse digest authorization header.
Definition utils.c:2674
long int ast_random(void)
Definition utils.c:2348

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

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

◆ auth_manager_http_callback()

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

Definition at line 8959 of file manager.c.

8960{
8961 int retval;
8962 struct ast_sockaddr ser_remote_address_tmp;
8963
8964 ast_sockaddr_copy(&ser_remote_address_tmp, &ser->remote_address);
8965 retval = auth_http_callback(ser, method, FORMAT_HTML, &ser_remote_address_tmp, uri, get_params, headers);
8966 ast_sockaddr_copy(&ser->remote_address, &ser_remote_address_tmp);
8967 return retval;
8968}
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)
Definition manager.c:8577
struct ast_sockaddr remote_address
Definition tcptls.h:153

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

◆ auth_mxml_http_callback()

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

Definition at line 8970 of file manager.c.

8971{
8972 int retval;
8973 struct ast_sockaddr ser_remote_address_tmp;
8974
8975 ast_sockaddr_copy(&ser_remote_address_tmp, &ser->remote_address);
8976 retval = auth_http_callback(ser, method, FORMAT_XML, &ser_remote_address_tmp, uri, get_params, headers);
8977 ast_sockaddr_copy(&ser->remote_address, &ser_remote_address_tmp);
8978 return retval;
8979}

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

◆ auth_rawman_http_callback()

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

Definition at line 8981 of file manager.c.

8982{
8983 int retval;
8984 struct ast_sockaddr ser_remote_address_tmp;
8985
8986 ast_sockaddr_copy(&ser_remote_address_tmp, &ser->remote_address);
8987 retval = auth_http_callback(ser, method, FORMAT_RAW, &ser_remote_address_tmp, uri, get_params, headers);
8988 ast_sockaddr_copy(&ser->remote_address, &ser_remote_address_tmp);
8989 return retval;
8990}

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

◆ close_mansession_file()

static void close_mansession_file ( struct mansession s)
static

Definition at line 8322 of file manager.c.

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

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

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

◆ find_session()

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

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

Definition at line 7927 of file manager.c.

7928{
7929 struct ao2_container *sessions;
7931 struct ao2_iterator i;
7932
7933 if (ident == 0) {
7934 return NULL;
7935 }
7936
7937 sessions = ao2_global_obj_ref(mgr_sessions);
7938 if (!sessions) {
7939 return NULL;
7940 }
7942 ao2_ref(sessions, -1);
7943 while ((session = ao2_iterator_next(&i))) {
7945 if (session->managerid == ident && !session->needdestroy) {
7946 ast_atomic_fetchadd_int(&session->inuse, incinuse ? 1 : 0);
7947 break;
7948 }
7951 }
7953
7954 return session;
7955}
int ast_atomic_fetchadd_int(volatile int *p, int v)
Atomically add v to *p and return the previous value of *p.
Definition lock.h:764

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

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

◆ find_session_by_nonce()

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

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

Definition at line 7966 of file manager.c.

7967{
7969 struct ao2_container *sessions;
7970 struct ao2_iterator i;
7971
7972 if (nonce == 0 || username == NULL || stale == NULL) {
7973 return NULL;
7974 }
7975
7976 sessions = ao2_global_obj_ref(mgr_sessions);
7977 if (!sessions) {
7978 return NULL;
7979 }
7981 ao2_ref(sessions, -1);
7982 while ((session = ao2_iterator_next(&i))) {
7984 if (!strcasecmp(session->username, username) && session->managerid == nonce) {
7985 *stale = 0;
7986 break;
7987 } else if (!strcasecmp(session->username, username) && session->oldnonce == nonce) {
7988 *stale = 1;
7989 break;
7990 }
7993 }
7995
7996 return session;
7997}

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

Referenced by auth_http_callback().

◆ function_amiclient()

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

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

Definition at line 9035 of file manager.c.

9036{
9037 struct ast_manager_user *user = NULL;
9038
9041 AST_APP_ARG(param);
9042 );
9043
9044
9045 if (ast_strlen_zero(data) ) {
9046 ast_log(LOG_WARNING, "AMI_CLIENT() requires two arguments: AMI_CLIENT(<name>[,<arg>])\n");
9047 return -1;
9048 }
9050 args.name = ast_strip(args.name);
9051 args.param = ast_strip(args.param);
9052
9054 if (!(user = get_manager_by_name_locked(args.name))) {
9056 ast_log(LOG_ERROR, "There's no manager user called : \"%s\"\n", args.name);
9057 return -1;
9058 }
9060
9061 if (!strcasecmp(args.param, "sessions")) {
9062 int no_sessions = 0;
9063 struct ao2_container *sessions;
9064
9065 sessions = ao2_global_obj_ref(mgr_sessions);
9066 if (sessions) {
9067 ao2_callback_data(sessions, 0, get_manager_sessions_cb, /*login name*/ data, &no_sessions);
9068 ao2_ref(sessions, -1);
9069 }
9070 snprintf(buf, len, "%d", no_sessions);
9071 } else {
9072 ast_log(LOG_ERROR, "Invalid arguments provided to function AMI_CLIENT: %s\n", args.param);
9073 return -1;
9074
9075 }
9076
9077 return 0;
9078}
#define ao2_callback_data(container, flags, cb_fn, arg, data)
Definition astobj2.h:1723
char buf[BUFSIZE]
Definition eagi_proxy.c:66
static const char name[]
Definition format_mp3.c:68
static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
#define AST_APP_ARG(name)
Define an application argument.
#define AST_DECLARE_APP_ARGS(name, arglist)
Declare a structure to hold an application's arguments.
#define AST_STANDARD_APP_ARGS(args, parse)
Performs the 'standard' argument separation process for an application.
#define AST_RWLIST_RDLOCK(head)
Read locks a list.
Definition linkedlists.h:78
static int get_manager_sessions_cb(void *obj, void *arg, void *data, int flags)
Get number of logged in sessions for a login name.
Definition manager.c:9020
static struct @519 args
char * ast_strip(char *s)
Strip leading/trailing whitespace from a string.
Definition strings.h:223

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

◆ generic_http_callback()

static int generic_http_callback ( struct ast_tcptls_session_instance ser,
enum ast_http_method  method,
enum output_format  format,
const struct ast_sockaddr remote_address,
const char *  uri,
struct ast_variable get_params,
struct ast_variable headers 
)
static
Note
There is approximately a 1 in 1.8E19 chance that the following calculation will produce 0, which is an invalid ID, but due to the properties of the rand() function (and the constancy of s), that won't happen twice in a row.

Definition at line 8365 of file manager.c.

8371{
8372 struct mansession s = { .session = NULL, .tcptls_session = ser };
8374 uint32_t ident;
8375 int fd;
8376 int blastaway = 0;
8377 struct ast_variable *params = get_params;
8378 char template[] = "/tmp/ast-http-XXXXXX"; /* template for temporary file */
8379 struct ast_str *http_header = NULL, *out = NULL;
8380 struct message m = { 0 };
8381
8383 ast_http_error(ser, 501, "Not Implemented", "Attempt to use unimplemented / unsupported method");
8384 return 0;
8385 }
8386
8387 ident = ast_http_manid_from_vars(headers);
8388
8389 if (!(session = find_session(ident, 1))) {
8390
8391 /**/
8392 /* Create new session.
8393 * While it is not in the list we don't need any locking
8394 */
8395 if (!(session = build_mansession(remote_address))) {
8397 ast_http_error(ser, 500, "Server Error", "Internal Server Error (out of memory)");
8398 return 0;
8399 }
8401 session->send_events = 0;
8402 session->inuse = 1;
8403 /*!
8404 * \note There is approximately a 1 in 1.8E19 chance that the following
8405 * calculation will produce 0, which is an invalid ID, but due to the
8406 * properties of the rand() function (and the constancy of s), that
8407 * won't happen twice in a row.
8408 */
8409 while ((session->managerid = ast_random() ^ (unsigned long) session) == 0) {
8410 }
8411 session->last_ev = grab_last();
8412 AST_LIST_HEAD_INIT_NOLOCK(&session->datastores);
8413 }
8415
8416 http_header = ast_str_create(128);
8417 out = ast_str_create(2048);
8418
8419 ast_mutex_init(&s.lock);
8420
8421 if (http_header == NULL || out == NULL) {
8423 ast_http_error(ser, 500, "Server Error", "Internal Server Error (ast_str_create() out of memory)");
8424 goto generic_callback_out;
8425 }
8426
8427 s.session = session;
8428 fd = mkstemp(template); /* create a temporary file for command output */
8429 unlink(template);
8430 if (fd <= -1) {
8431 ast_http_error(ser, 500, "Server Error", "Internal Server Error (mkstemp failed)");
8432 goto generic_callback_out;
8433 }
8435 if (!s.stream) {
8436 ast_log(LOG_WARNING, "HTTP Manager, fdopen failed: %s!\n", strerror(errno));
8437 ast_http_error(ser, 500, "Server Error", "Internal Server Error (fdopen failed)");
8438 close(fd);
8439 goto generic_callback_out;
8440 }
8441
8442 if (method == AST_HTTP_POST) {
8443 params = ast_http_get_post_vars(ser, headers);
8444 if (!params) {
8445 switch (errno) {
8446 case EFBIG:
8447 ast_http_error(ser, 413, "Request Entity Too Large", "Body too large");
8449 goto generic_callback_out;
8450 case ENOMEM:
8452 ast_http_error(ser, 500, "Server Error", "Out of memory");
8454 goto generic_callback_out;
8455 case EIO:
8456 ast_http_error(ser, 400, "Bad Request", "Error parsing request body");
8458 goto generic_callback_out;
8459 }
8460 }
8461 }
8462
8463 astman_append_headers(&m, params);
8464
8465 if (process_message(&s, &m)) {
8466 if (session->authenticated) {
8468 ast_verb(2, "HTTP Manager '%s' logged off from %s\n", session->username, ast_sockaddr_stringify_addr(&session->addr));
8469 }
8470 } else {
8471 if (displayconnects) {
8472 ast_verb(2, "HTTP Connect attempt from '%s' unable to authenticate\n", ast_sockaddr_stringify_addr(&session->addr));
8473 }
8474 }
8475 session->needdestroy = 1;
8476 }
8477
8479
8480 ast_str_append(&http_header, 0,
8481 "Content-type: text/%s\r\n"
8482 "Set-Cookie: mansession_id=\"%08x\"; Version=1; Max-Age=%d\r\n"
8483 "Pragma: SuppressEvents\r\n",
8484 contenttype[format],
8485 session->managerid, httptimeout);
8486
8487 if (format == FORMAT_XML) {
8488 ast_str_append(&out, 0, "<ajax-response>\n");
8489 } else if (format == FORMAT_HTML) {
8490 /*
8491 * When handling AMI-over-HTTP in HTML format, we provide a simple form for
8492 * debugging purposes. This HTML code should not be here, we
8493 * should read from some config file...
8494 */
8495
8496#define ROW_FMT "<tr><td colspan=\"2\" bgcolor=\"#f1f1ff\">%s</td></tr>\r\n"
8497#define TEST_STRING \
8498 "<form action=\"manager\" method=\"post\">\n\
8499 Action: <select name=\"action\">\n\
8500 <option value=\"\">-----&gt;</option>\n\
8501 <option value=\"login\">login</option>\n\
8502 <option value=\"command\">Command</option>\n\
8503 <option value=\"waitevent\">waitevent</option>\n\
8504 <option value=\"listcommands\">listcommands</option>\n\
8505 </select>\n\
8506 or <input name=\"action\"><br/>\n\
8507 CLI Command <input name=\"command\"><br>\n\
8508 user <input name=\"username\"> pass <input type=\"password\" name=\"secret\"><br>\n\
8509 <input type=\"submit\">\n</form>\n"
8510
8511 ast_str_append(&out, 0, "<title>Asterisk&trade; Manager Interface</title>");
8512 ast_str_append(&out, 0, "<body bgcolor=\"#ffffff\"><table align=center bgcolor=\"#f1f1f1\" width=\"500\">\r\n");
8513 ast_str_append(&out, 0, ROW_FMT, "<h1>Manager Tester</h1>");
8515 }
8516
8517 process_output(&s, &out, params, format);
8518
8519 if (format == FORMAT_XML) {
8520 ast_str_append(&out, 0, "</ajax-response>\n");
8521 } else if (format == FORMAT_HTML) {
8522 ast_str_append(&out, 0, "</table></body>\r\n");
8523 }
8524
8526 /* Reset HTTP timeout. If we're not authenticated, keep it extremely short */
8527 session->sessiontimeout = time(NULL) + ((session->authenticated || httptimeout < 5) ? httptimeout : 5);
8528
8529 if (session->needdestroy) {
8530 if (session->inuse == 1) {
8531 ast_debug(1, "Need destroy, doing it now!\n");
8532 blastaway = 1;
8533 } else {
8534 ast_debug(1, "Need destroy, but can't do it yet!\n");
8535 ast_mutex_lock(&session->notify_lock);
8536 if (session->waiting_thread != AST_PTHREADT_NULL) {
8537 pthread_kill(session->waiting_thread, SIGURG);
8538 }
8539 ast_mutex_unlock(&session->notify_lock);
8540 session->inuse--;
8541 }
8542 } else {
8543 session->inuse--;
8544 }
8546
8547 ast_http_send(ser, method, 200, NULL, http_header, out, 0, 0);
8548 http_header = NULL;
8549 out = NULL;
8550
8551generic_callback_out:
8553
8554 /* Clear resource */
8555
8556 if (method == AST_HTTP_POST && params) {
8557 ast_variables_destroy(params);
8558 }
8559 ast_free(http_header);
8560 ast_free(out);
8561
8562 if (session) {
8563 if (blastaway) {
8565 } else {
8566 if (session->stream) {
8567 ast_iostream_close(session->stream);
8568 session->stream = NULL;
8569 }
8571 }
8572 }
8573
8574 return 0;
8575}
static int manager_displayconnects(struct mansession_session *session)
Get displayconnects config option.
Definition manager.c:1059
uint32_t ast_http_manid_from_vars(struct ast_variable *headers) attribute_pure
Return manager id, if exist, from request headers.
Definition http.c:233
#define AST_PTHREADT_NULL
Definition lock.h:73
#define ast_mutex_unlock(a)
Definition lock.h:197
#define ast_mutex_lock(a)
Definition lock.h:196
#define ROW_FMT
#define TEST_STRING

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

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

◆ get_manager_sessions_cb()

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

Get number of logged in sessions for a login name.

Definition at line 9020 of file manager.c.

9021{
9022 struct mansession_session *session = obj;
9023 const char *login = (char *)arg;
9024 int *no_sessions = data;
9025
9026 if (strcasecmp(session->username, login) == 0) {
9027 (*no_sessions)++;
9028 }
9029
9030 return 0;
9031}

References session.

Referenced by function_amiclient().

◆ handle_manager_show_event()

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

Definition at line 9312 of file manager.c.

9313{
9315 struct ao2_iterator it_events;
9316 struct ast_xml_doc_item *item, *temp;
9317 int length;
9318
9319 if (cmd == CLI_INIT) {
9320 e->command = "manager show event";
9321 e->usage =
9322 "Usage: manager show event <eventname>\n"
9323 " Provides a detailed description a Manager interface event.\n";
9324 return NULL;
9325 }
9326
9327 events = ao2_global_obj_ref(event_docs);
9328 if (!events) {
9329 ast_cli(a->fd, "No manager event documentation loaded\n");
9330 return CLI_SUCCESS;
9331 }
9332
9333 if (cmd == CLI_GENERATE) {
9334 if (a->pos != 3) {
9335 return NULL;
9336 }
9337
9338 length = strlen(a->word);
9339 it_events = ao2_iterator_init(events, 0);
9340 while ((item = ao2_iterator_next(&it_events))) {
9341 if (!strncasecmp(a->word, item->name, length)) {
9343 ao2_ref(item, -1);
9344 break;
9345 }
9346 }
9347 ao2_ref(item, -1);
9348 }
9349 ao2_iterator_destroy(&it_events);
9350
9351 return NULL;
9352 }
9353
9354 if (a->argc != 4) {
9355 return CLI_SHOWUSAGE;
9356 }
9357
9358 if (!(item = ao2_find(events, a->argv[3], OBJ_KEY))) {
9359 ast_cli(a->fd, "Could not find event '%s'\n", a->argv[3]);
9360 return CLI_SUCCESS;
9361 }
9362
9363 ast_cli(a->fd, "Event: %s\n", a->argv[3]);
9364 for (temp = item; temp; temp = AST_LIST_NEXT(temp, next)) {
9365 print_event_instance(a, temp);
9366 }
9367
9368 ao2_ref(item, -1);
9369 return CLI_SUCCESS;
9370}
static const struct adsi_event events[]
#define OBJ_KEY
Definition astobj2.h:1151
#define ao2_cleanup(obj)
Definition astobj2.h:1934
#define ao2_find(container, arg, flags)
Definition astobj2.h:1736
#define CLI_SHOWUSAGE
Definition cli.h:45
#define CLI_SUCCESS
Definition cli.h:44
int ast_cli_completion_add(char *value)
Add a result to a request for completion options.
Definition main/cli.c:2737
void ast_cli(int fd, const char *fmt,...)
Definition clicompat.c:6
@ CLI_INIT
Definition cli.h:152
@ CLI_GENERATE
Definition cli.h:153
static void print_event_instance(struct ast_cli_args *a, struct ast_xml_doc_item *instance)
Definition manager.c:9264
#define AST_LIST_NEXT(elm, field)
Returns the next entry in the list after the given entry.
const char * name
char * command
Definition cli.h:186
const char * usage
Definition cli.h:177
struct ast_xml_doc_item * next
Definition xmldoc.h:80
static struct aco_type item
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition utils.h:978

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

◆ handle_manager_show_events()

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

Definition at line 9183 of file manager.c.

9184{
9185 struct ao2_container *events;
9186 struct ao2_iterator *it_events;
9187 struct ast_xml_doc_item *item;
9188 struct ast_xml_doc_item **items;
9189 struct ast_str *buffer;
9190 int i = 0, totalitems = 0;
9191
9192 switch (cmd) {
9193 case CLI_INIT:
9194 e->command = "manager show events";
9195 e->usage =
9196 "Usage: manager show events\n"
9197 " Prints a listing of the available Asterisk manager interface events.\n";
9198 return NULL;
9199 case CLI_GENERATE:
9200 return NULL;
9201 }
9202 if (a->argc != 3) {
9203 return CLI_SHOWUSAGE;
9204 }
9205
9206 buffer = ast_str_create(128);
9207 if (!buffer) {
9208 return CLI_SUCCESS;
9209 }
9210
9211 events = ao2_global_obj_ref(event_docs);
9212 if (!events) {
9213 ast_cli(a->fd, "No manager event documentation loaded\n");
9214 ast_free(buffer);
9215 return CLI_SUCCESS;
9216 }
9217
9219 if (!(it_events = ao2_callback(events, OBJ_MULTIPLE | OBJ_NOLOCK, NULL, NULL))) {
9221 ast_log(AST_LOG_ERROR, "Unable to create iterator for events container\n");
9222 ast_free(buffer);
9223 ao2_ref(events, -1);
9224 return CLI_SUCCESS;
9225 }
9226 if (!(items = ast_calloc(sizeof(struct ast_xml_doc_item *), ao2_container_count(events)))) {
9228 ast_log(AST_LOG_ERROR, "Unable to create temporary sorting array for events\n");
9229 ao2_iterator_destroy(it_events);
9230 ast_free(buffer);
9231 ao2_ref(events, -1);
9232 return CLI_SUCCESS;
9233 }
9235
9236 while ((item = ao2_iterator_next(it_events))) {
9237 items[totalitems++] = item;
9238 ao2_ref(item, -1);
9239 }
9240
9241 qsort(items, totalitems, sizeof(struct ast_xml_doc_item *), ast_xml_doc_item_cmp_fn);
9242
9243 ast_cli(a->fd, "Events:\n");
9244 ast_cli(a->fd, " -------------------- -------------------- -------------------- \n");
9245 for (i = 0; i < totalitems; i++) {
9246 ast_str_append(&buffer, 0, " %-20.20s", items[i]->name);
9247 if ((i + 1) % 3 == 0) {
9248 ast_cli(a->fd, "%s\n", ast_str_buffer(buffer));
9249 ast_str_set(&buffer, 0, "%s", "");
9250 }
9251 }
9252 if ((i + 1) % 3 != 0) {
9253 ast_cli(a->fd, "%s\n", ast_str_buffer(buffer));
9254 }
9255
9256 ao2_iterator_destroy(it_events);
9257 ast_free(items);
9258 ao2_ref(events, -1);
9259 ast_free(buffer);
9260
9261 return CLI_SUCCESS;
9262}
#define ao2_callback(c, flags, cb_fn, arg)
ao2_callback() is a generic function that applies cb_fn() to all objects in a container,...
Definition astobj2.h:1693
int ao2_container_count(struct ao2_container *c)
Returns the number of elements in a container.
@ OBJ_NOLOCK
Assume that the ao2_container is already locked.
Definition astobj2.h:1063
#define AST_LOG_ERROR
static int ast_xml_doc_item_cmp_fn(const void *a, const void *b)
Definition manager.c:9176
int ast_str_set(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Set a dynamic string using variable arguments.
Definition strings.h:1113
char *attribute_pure ast_str_buffer(const struct ast_str *buf)
Returns the string buffer within the ast_str buf.
Definition strings.h:761

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

◆ handle_manager_show_settings()

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

CLI command manager show settings.

Definition at line 9132 of file manager.c.

9133{
9134 switch (cmd) {
9135 case CLI_INIT:
9136 e->command = "manager show settings";
9137 e->usage =
9138 "Usage: manager show settings\n"
9139 " Provides detailed list of the configuration of the Manager.\n";
9140 return NULL;
9141 case CLI_GENERATE:
9142 return NULL;
9143 }
9144#define FORMAT " %-25.25s %-15.55s\n"
9145#define FORMAT2 " %-25.25s %-15d\n"
9146#define FORMAT3 " %-25.25s %s\n"
9147 if (a->argc != 3) {
9148 return CLI_SHOWUSAGE;
9149 }
9150 ast_cli(a->fd, "\nGlobal Settings:\n");
9151 ast_cli(a->fd, "----------------\n");
9152 ast_cli(a->fd, FORMAT, "Manager (AMI):", AST_CLI_YESNO(manager_enabled));
9153 ast_cli(a->fd, FORMAT, "Web Manager (AMI/HTTP):", AST_CLI_YESNO(webmanager_enabled));
9154 ast_cli(a->fd, FORMAT, "TCP Bindaddress:", manager_enabled != 0 ? ast_sockaddr_stringify(&ami_desc.local_address) : "Disabled");
9155 ast_cli(a->fd, FORMAT2, "HTTP Timeout (seconds):", httptimeout);
9156 ast_cli(a->fd, FORMAT, "TLS Enable:", AST_CLI_YESNO(ami_tls_cfg.enabled));
9157 ast_cli(a->fd, FORMAT, "TLS Bindaddress:", ami_tls_cfg.enabled != 0 ? ast_sockaddr_stringify(&amis_desc.local_address) : "Disabled");
9158 ast_cli(a->fd, FORMAT, "TLS Certfile:", ami_tls_cfg.certfile);
9159 ast_cli(a->fd, FORMAT, "TLS Privatekey:", ami_tls_cfg.pvtfile);
9160 ast_cli(a->fd, FORMAT, "TLS Cipher:", ami_tls_cfg.cipher);
9161 ast_cli(a->fd, FORMAT, "Allow multiple login:", AST_CLI_YESNO(allowmultiplelogin));
9162 ast_cli(a->fd, FORMAT, "Display connects:", AST_CLI_YESNO(displayconnects));
9163 ast_cli(a->fd, FORMAT, "Timestamp events:", AST_CLI_YESNO(timestampevents));
9164 ast_cli(a->fd, FORMAT3, "Channel vars:", S_OR(manager_channelvars, ""));
9165 ast_cli(a->fd, FORMAT3, "Disabled events:", S_OR(manager_disabledevents, ""));
9166 ast_cli(a->fd, FORMAT, "Debug:", AST_CLI_YESNO(manager_debug));
9167#undef FORMAT
9168#undef FORMAT2
9169#undef FORMAT3
9170
9171 return CLI_SUCCESS;
9172}
#define AST_CLI_YESNO(x)
Return Yes or No depending on the argument.
Definition cli.h:71
static char * manager_channelvars
Definition manager.c:172
static char * manager_disabledevents
Definition manager.c:173
#define FORMAT3
#define FORMAT
#define FORMAT2
static char * ast_sockaddr_stringify(const struct ast_sockaddr *addr)
Wrapper around ast_sockaddr_stringify_fmt() with default format.
Definition netsock2.h:256
#define S_OR(a, b)
returns the equivalent of logic or for strings: first one if not empty, otherwise second one.
Definition strings.h:80
char * certfile
Definition tcptls.h:90
char * cipher
Definition tcptls.h:92
char * pvtfile
Definition tcptls.h:91

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

◆ load_channelvars()

static void load_channelvars ( struct ast_variable var)
static

Definition at line 9397 of file manager.c.

9398{
9399 char *parse = NULL;
9401 AST_APP_ARG(vars)[MAX_VARS];
9402 );
9403
9406
9407 /* parse the setting */
9410
9412}
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition astmm.h:298
void ast_channel_set_manager_vars(size_t varc, char **vars)
Sets the variables to be stored in the manager_vars field of all snapshots.
Definition channel.c:7842
#define MAX_VARS
Definition manager.c:205

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

Referenced by __init_manager().

◆ load_disabledevents()

static void load_disabledevents ( struct ast_variable var)
static

Definition at line 9420 of file manager.c.

References ast_free, ast_strdup, manager_disabledevents, and var.

Referenced by __init_manager().

◆ load_module()

static int load_module ( void  )
static

Definition at line 10065 of file manager.c.

10066{
10067 int rc = 0;
10070#ifdef TEST_FRAMEWORK
10071 AST_TEST_REGISTER(eventfilter_test_creation);
10072 AST_TEST_REGISTER(eventfilter_test_matching);
10073 AST_TEST_REGISTER(originate_permissions_test);
10074#endif
10075 return rc;
10076}
int ast_register_cleanup(void(*func)(void))
Register a function to be executed before Asterisk gracefully exits.
Definition clicompat.c:19
static int __init_manager(int reload, int by_external_config)
Definition manager.c:9645
static void manager_shutdown(void)
Definition manager.c:9449
@ AST_MODULE_LOAD_FAILURE
Module could not be loaded properly.
Definition module.h:102
@ AST_MODULE_LOAD_SUCCESS
Definition module.h:70
#define AST_TEST_REGISTER(cb)
Definition test.h:127

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

◆ manager_event_blob_dtor()

static void manager_event_blob_dtor ( void *  obj)
static

Definition at line 10135 of file manager.c.

10136{
10137 struct ast_manager_event_blob *ev = obj;
10138
10140}

References ast_string_field_free_memory.

Referenced by ast_manager_event_blob_create().

◆ manager_free_user()

static void manager_free_user ( struct ast_manager_user user)
static

Definition at line 9430 of file manager.c.

9431{
9432 ast_free(user->a1_hash);
9433 ast_free(user->secret);
9434 if (user->includefilters) {
9435 ao2_t_ref(user->includefilters, -1, "decrement ref for include container, should be last one");
9436 }
9437 if (user->excludefilters) {
9438 ao2_t_ref(user->excludefilters, -1, "decrement ref for exclude container, should be last one");
9439 }
9440 user->acl = ast_free_acl_list(user->acl);
9441 ast_variables_destroy(user->chanvars);
9442 ast_free(user);
9443}

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

Referenced by __init_manager(), and manager_shutdown().

◆ manager_http_callback()

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

Definition at line 8900 of file manager.c.

8901{
8902 int retval;
8903 struct ast_sockaddr ser_remote_address_tmp;
8904
8905 ast_sockaddr_copy(&ser_remote_address_tmp, &ser->remote_address);
8906 retval = generic_http_callback(ser, method, FORMAT_HTML, &ser_remote_address_tmp, uri, get_params, headers);
8907 ast_sockaddr_copy(&ser->remote_address, &ser_remote_address_tmp);
8908 return retval;
8909}
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)
Definition manager.c:8365

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

◆ manager_set_defaults()

static void manager_set_defaults ( void  )
static

Definition at line 9617 of file manager.c.

9618{
9619 manager_enabled = 0;
9620 displayconnects = 1;
9622 authtimeout = 30;
9623 authlimit = 50;
9624 manager_debug = 0; /* Debug disabled by default */
9625
9626 /* default values */
9628 sizeof(global_realm));
9631
9632 ami_tls_cfg.enabled = 0;
9643}
#define DEFAULT_REALM
Definition manager.c:175
static void ast_sockaddr_setnull(struct ast_sockaddr *addr)
Sets address addr to null.
Definition netsock2.h:138
const char * ast_config_AST_SYSTEM_NAME
Definition options.c:171
char * capath
Definition tcptls.h:94
char * cafile
Definition tcptls.h:93
#define AST_CERTFILE
Definition tcptls.h:63

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

Referenced by __init_manager().

◆ manager_shutdown()

static void manager_shutdown ( void  )
static

Definition at line 9449 of file manager.c.

9450{
9451 struct ast_manager_user *user;
9452
9453#ifdef TEST_FRAMEWORK
9454 AST_TEST_UNREGISTER(eventfilter_test_creation);
9455 AST_TEST_UNREGISTER(eventfilter_test_matching);
9456 AST_TEST_UNREGISTER(originate_permissions_test);
9457#endif
9458
9459 /* This event is not actually transmitted, but causes all TCP sessions to be closed */
9460 manager_event(EVENT_FLAG_SHUTDOWN, "CloseSession", "CloseSession: true\r\n");
9461
9462 ast_manager_unregister("Ping");
9463 ast_manager_unregister("Events");
9464 ast_manager_unregister("Logoff");
9465 ast_manager_unregister("Login");
9466 ast_manager_unregister("Challenge");
9467 ast_manager_unregister("Hangup");
9468 ast_manager_unregister("Status");
9469 ast_manager_unregister("Setvar");
9470 ast_manager_unregister("Getvar");
9471 ast_manager_unregister("GetConfig");
9472 ast_manager_unregister("GetConfigJSON");
9473 ast_manager_unregister("UpdateConfig");
9474 ast_manager_unregister("CreateConfig");
9475 ast_manager_unregister("ListCategories");
9476 ast_manager_unregister("Redirect");
9477 ast_manager_unregister("Atxfer");
9478 ast_manager_unregister("CancelAtxfer");
9479 ast_manager_unregister("Originate");
9480 ast_manager_unregister("Command");
9481 ast_manager_unregister("ExtensionState");
9482 ast_manager_unregister("PresenceState");
9483 ast_manager_unregister("AbsoluteTimeout");
9484 ast_manager_unregister("MailboxStatus");
9485 ast_manager_unregister("MailboxCount");
9486 ast_manager_unregister("ListCommands");
9487 ast_manager_unregister("SendText");
9488 ast_manager_unregister("UserEvent");
9489 ast_manager_unregister("WaitEvent");
9490 ast_manager_unregister("CoreSettings");
9491 ast_manager_unregister("CoreStatus");
9492 ast_manager_unregister("Reload");
9493 ast_manager_unregister("LoggerRotate");
9494 ast_manager_unregister("CoreShowChannels");
9495 ast_manager_unregister("CoreShowChannelMap");
9496 ast_manager_unregister("ModuleLoad");
9497 ast_manager_unregister("ModuleCheck");
9498 ast_manager_unregister("AOCMessage");
9499 ast_manager_unregister("Filter");
9500 ast_manager_unregister("BlindTransfer");
9503
9504#ifdef AST_XML_DOCS
9505 ao2_t_global_obj_release(event_docs, "Dispose of event_docs");
9506#endif
9507
9508#ifdef TEST_FRAMEWORK
9509 stasis_forward_cancel(test_suite_forwarder);
9510 test_suite_forwarder = NULL;
9511#endif
9512
9513 if (stasis_router) {
9516 }
9524
9527
9538
9539 ao2_global_obj_release(mgr_sessions);
9540
9541 while ((user = AST_LIST_REMOVE_HEAD(&users, list))) {
9543 }
9545
9548}
void ast_cli_unregister_multiple(void)
Definition ael_main.c:408
#define ao2_global_obj_release(holder)
Release the ao2 object held in the global holder.
Definition astobj2.h:859
#define ao2_t_global_obj_release(holder, tag)
Definition astobj2.h:861
static struct stasis_message_router * stasis_router
The stasis_message_router for all Stasis Message Bus API messages.
Definition manager.c:185
static struct stasis_forward * rtp_topic_forwarder
The stasis_subscription for forwarding the RTP topic to the AMI topic.
Definition manager.c:188
static struct stasis_forward * security_topic_forwarder
The stasis_subscription for forwarding the Security topic to the AMI topic.
Definition manager.c:191
#define EVENT_FLAG_SHUTDOWN
Fake event class used to end sessions at shutdown.
Definition manager.c:208
int ast_manager_unregister(const char *action)
support functions to register/unregister AMI action handlers,
Definition manager.c:7698
#define AST_LIST_REMOVE_HEAD(head, field)
Removes and returns the head entry from a list.
int ast_custom_function_unregister(struct ast_custom_function *acf)
Unregister a custom function.
#define STASIS_MESSAGE_TYPE_CLEANUP(name)
Boiler-plate messaging macro for cleaning up message types.
Definition stasis.h:1515
struct stasis_forward * stasis_forward_cancel(struct stasis_forward *forward)
Definition stasis.c:1615
void stasis_message_router_unsubscribe_and_join(struct stasis_message_router *router)
Unsubscribe the router from the upstream topic, blocking until the final message has been processed.
struct ast_manager_user::@402 list
#define AST_TEST_UNREGISTER(cb)
Definition test.h:128

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

Referenced by load_module().

◆ manager_subscriptions_init()

static int manager_subscriptions_init ( void  )
static

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

Definition at line 9554 of file manager.c.

9555{
9556 int res = 0;
9557
9559 if (!rtp_topic_forwarder) {
9560 return -1;
9561 }
9562
9565 return -1;
9566 }
9567
9569 if (!stasis_router) {
9570 return -1;
9571 }
9574
9577
9580
9581 if (res != 0) {
9582 return -1;
9583 }
9584 return 0;
9585}
static void manager_default_msg_cb(void *data, struct stasis_subscription *sub, struct stasis_message *message)
Definition manager.c:568
static void manager_generic_msg_cb(void *data, struct stasis_subscription *sub, struct stasis_message *message)
Definition manager.c:599
struct stasis_topic * ast_rtp_topic(void)
Stasis Message Bus API topic for RTP and RTCP related messages
struct stasis_topic * ast_security_topic(void)
A stasis_topic which publishes messages for security related issues.
@ STASIS_SUBSCRIPTION_FORMATTER_AMI
Definition stasis.h:311
int stasis_message_router_set_congestion_limits(struct stasis_message_router *router, long low_water, long high_water)
Set the high and low alert water marks of the stasis message router.
#define stasis_message_router_create(topic)
Create a new message router object.
int stasis_message_router_add(struct stasis_message_router *router, struct stasis_message_type *message_type, stasis_subscription_cb callback, void *data)
Add a route to a message router.
void stasis_message_router_set_formatters_default(struct stasis_message_router *router, stasis_subscription_cb callback, void *data, enum stasis_subscription_message_formatters formatters)
Sets the default route of a router with formatters.
#define AST_TASKPROCESSOR_HIGH_WATER_LEVEL

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

Referenced by subscribe_all().

◆ mxml_http_callback()

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

Definition at line 8911 of file manager.c.

8912{
8913 int retval;
8914 struct ast_sockaddr ser_remote_address_tmp;
8915
8916 ast_sockaddr_copy(&ser_remote_address_tmp, &ser->remote_address);
8917 retval = generic_http_callback(ser, method, FORMAT_XML, &ser_remote_address_tmp, uri, get_params, headers);
8918 ast_sockaddr_copy(&ser->remote_address, &ser_remote_address_tmp);
8919 return retval;
8920}

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

◆ process_output()

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

Definition at line 8332 of file manager.c.

8333{
8334 char *buf;
8335 off_t l;
8336 int fd;
8337
8338 if (!s->stream)
8339 return;
8340
8341 /* Ensure buffer is NULL-terminated */
8342 ast_iostream_write(s->stream, "", 1);
8343
8344 fd = ast_iostream_get_fd(s->stream);
8345
8346 l = lseek(fd, 0, SEEK_CUR);
8347 if (l > 0) {
8348 if (MAP_FAILED == (buf = mmap(NULL, l, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0))) {
8349 ast_log(LOG_WARNING, "mmap failed. Manager output was not processed\n");
8350 } else {
8351 if (format == FORMAT_XML || format == FORMAT_HTML) {
8352 xml_translate(out, buf, params, format);
8353 } else {
8354 ast_str_append(out, 0, "%s", buf);
8355 }
8356 munmap(buf, l);
8357 }
8358 } else if (format == FORMAT_XML || format == FORMAT_HTML) {
8359 xml_translate(out, "", params, format);
8360 }
8361
8363}
ssize_t ast_iostream_write(struct ast_iostream *stream, const void *buffer, size_t count)
Write data to an iostream.
Definition iostream.c:385
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:...
Definition manager.c:8204

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

Referenced by auth_http_callback(), and generic_http_callback().

◆ purge_old_stuff()

static void purge_old_stuff ( void *  data)
static

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

Definition at line 9093 of file manager.c.

9094{
9095 struct ast_tcptls_session_args *ser = data;
9096 /* purge_sessions will return the number of sessions actually purged,
9097 * up to a maximum of it's arguments, purge one at a time, keeping a
9098 * purge interval of 1ms as long as we purged a session, otherwise
9099 * revert to a purge check every 5s
9100 */
9101 if (purge_sessions(1) == 1) {
9102 ser->poll_timeout = 1;
9103 } else {
9104 ser->poll_timeout = 5000;
9105 }
9106 purge_events();
9107}
static void purge_events(void)
Definition manager.c:714
static int purge_sessions(int n_max)
remove at most n_max stale session from the list.
Definition manager.c:7454
arguments for the accepting thread
Definition tcptls.h:130

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

◆ rawman_http_callback()

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

Definition at line 8922 of file manager.c.

8923{
8924 int retval;
8925 struct ast_sockaddr ser_remote_address_tmp;
8926
8927 ast_sockaddr_copy(&ser_remote_address_tmp, &ser->remote_address);
8928 retval = generic_http_callback(ser, method, FORMAT_RAW, &ser_remote_address_tmp, uri, get_params, headers);
8929 ast_sockaddr_copy(&ser->remote_address, &ser_remote_address_tmp);
8930 return retval;
8931}

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

◆ subscribe_all()

static int subscribe_all ( void  )
static

Definition at line 9587 of file manager.c.

9588{
9590 ast_log(AST_LOG_ERROR, "Failed to initialize manager subscriptions\n");
9591 return -1;
9592 }
9593 if (manager_system_init()) {
9594 ast_log(AST_LOG_ERROR, "Failed to initialize manager system handling\n");
9595 return -1;
9596 }
9597 if (manager_channels_init()) {
9598 ast_log(AST_LOG_ERROR, "Failed to initialize manager channel handling\n");
9599 return -1;
9600 }
9601 if (manager_mwi_init()) {
9602 ast_log(AST_LOG_ERROR, "Failed to initialize manager MWI handling\n");
9603 return -1;
9604 }
9605 if (manager_bridging_init()) {
9606 return -1;
9607 }
9608 if (manager_endpoints_init()) {
9609 ast_log(AST_LOG_ERROR, "Failed to initialize manager endpoints handling\n");
9610 return -1;
9611 }
9612
9613 subscribed = 1;
9614 return 0;
9615}
static int manager_subscriptions_init(void)
Initialize all Stasis Message Bus API topics and routers used by the various sub-components of AMI.
Definition manager.c:9554
int manager_mwi_init(void)
Initialize support for AMI MWI events.
int manager_bridging_init(void)
Initialize support for AMI channel events.
int manager_endpoints_init(void)
Initialize support for AMI endpoint events.
int manager_system_init(void)
Initialize support for AMI system events.
int manager_channels_init(void)
Initialize support for AMI channel events.

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(), ari_conf_init(), session_create(), session_register_apps(), and websocket_attempted_cb().

◆ unload_module()

static int unload_module ( void  )
static

Definition at line 10060 of file manager.c.

10061{
10062 return 0;
10063}

◆ variable_count_cmp_fn()

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

Definition at line 8165 of file manager.c.

8166{
8167 /* Due to the simplicity of struct variable_count, it makes no difference
8168 * if you pass in objects or strings, the same operation applies. This is
8169 * due to the fact that the hash occurs on the first element, which means
8170 * the address of both the struct and the string are exactly the same. */
8171 struct variable_count *vc = obj;
8172 char *str = vstr;
8173 return !strcmp(vc->varname, str) ? CMP_MATCH | CMP_STOP : 0;
8174}
const char * str
Definition app_jack.c:150
@ CMP_MATCH
Definition astobj2.h:1027
@ CMP_STOP
Definition astobj2.h:1028
char * varname
Definition manager.c:8154

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

Referenced by xml_translate().

◆ variable_count_hash_fn()

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

Definition at line 8158 of file manager.c.

8159{
8160 const struct variable_count *vc = vvc;
8161
8162 return ast_str_hash(vc->varname);
8163}

References ast_str_hash(), and variable_count::varname.

Referenced by xml_translate().

◆ xml_copy_escape()

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

Definition at line 8086 of file manager.c.

8087{
8088 /* store in a local buffer to avoid calling ast_str_append too often */
8089 char buf[256];
8090 char *dst = buf;
8091 const char *save = src;
8092 int space = sizeof(buf);
8093 /* repeat until done and nothing to flush */
8094 for ( ; *src || dst != buf ; src++) {
8095 if (*src == '\0' || space < 10) { /* flush */
8096 *dst++ = '\0';
8097 ast_str_append(out, 0, "%s", buf);
8098 dst = buf;
8099 space = sizeof(buf);
8100 if (*src == '\0') {
8101 break;
8102 }
8103 }
8104
8105 if (mode & 2) {
8106 if (save == src && isdigit(*src)) {
8107 /* The first character of an XML attribute cannot be a digit */
8108 *dst++ = '_';
8109 *dst++ = *src;
8110 space -= 2;
8111 continue;
8112 } else if (!isalnum(*src)) {
8113 /* Replace non-alphanumeric with an underscore */
8114 *dst++ = '_';
8115 space--;
8116 continue;
8117 }
8118 }
8119 switch (*src) {
8120 case '<':
8121 strcpy(dst, "&lt;");
8122 dst += 4;
8123 space -= 4;
8124 break;
8125 case '>':
8126 strcpy(dst, "&gt;");
8127 dst += 4;
8128 space -= 4;
8129 break;
8130 case '\"':
8131 strcpy(dst, "&quot;");
8132 dst += 6;
8133 space -= 6;
8134 break;
8135 case '\'':
8136 strcpy(dst, "&apos;");
8137 dst += 6;
8138 space -= 6;
8139 break;
8140 case '&':
8141 strcpy(dst, "&amp;");
8142 dst += 5;
8143 space -= 5;
8144 break;
8145
8146 default:
8147 *dst++ = mode ? tolower(*src) : *src;
8148 space--;
8149 }
8150 }
8151}

References ast_str_append(), buf, and out.

Referenced by xml_translate().

◆ xml_translate()

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

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

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

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

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

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


Definition at line 8204 of file manager.c.

8205{
8206 struct ast_variable *v;
8207 const char *dest = NULL;
8208 char *var, *val;
8209 const char *objtype = NULL;
8210 int in_data = 0; /* parsing data */
8211 int inobj = 0;
8212 int xml = (format == FORMAT_XML);
8213 struct variable_count *vc = NULL;
8214 struct ao2_container *vco = NULL;
8215
8216 if (xml) {
8217 /* dest and objtype need only for XML format */
8218 for (v = get_vars; v; v = v->next) {
8219 if (!strcasecmp(v->name, "ajaxdest")) {
8220 dest = v->value;
8221 } else if (!strcasecmp(v->name, "ajaxobjtype")) {
8222 objtype = v->value;
8223 }
8224 }
8225 if (ast_strlen_zero(dest)) {
8226 dest = "unknown";
8227 }
8228 if (ast_strlen_zero(objtype)) {
8229 objtype = "generic";
8230 }
8231 }
8232
8233 /* we want to stop when we find an empty line */
8234 while (in && *in) {
8235 val = strsep(&in, "\r\n"); /* mark start and end of line */
8236 if (in && *in == '\n') { /* remove trailing \n if any */
8237 in++;
8238 }
8240 ast_debug(5, "inobj %d in_data %d line <%s>\n", inobj, in_data, val);
8241 if (ast_strlen_zero(val)) {
8242 /* empty line */
8243 if (in_data) {
8244 /* close data in Opaque mode */
8245 ast_str_append(out, 0, xml ? "'" : "</td></tr>\n");
8246 in_data = 0;
8247 }
8248
8249 if (inobj) {
8250 /* close block */
8251 ast_str_append(out, 0, xml ? " /></response>\n" :
8252 "<tr><td colspan=\"2\"><hr></td></tr>\r\n");
8253 inobj = 0;
8254 ao2_ref(vco, -1);
8255 vco = NULL;
8256 }
8257 continue;
8258 }
8259
8260 if (!inobj) {
8261 /* start new block */
8262 if (xml) {
8263 ast_str_append(out, 0, "<response type='object' id='%s'><%s", dest, objtype);
8264 }
8267 inobj = 1;
8268 }
8269
8270 if (in_data) {
8271 /* Process data field in Opaque mode. This is a
8272 * followup, so we re-add line feeds. */
8273 ast_str_append(out, 0, xml ? "\n" : "<br>\n");
8274 xml_copy_escape(out, val, 0); /* data field */
8275 continue;
8276 }
8277
8278 /* We expect "Name: value" line here */
8279 var = strsep(&val, ":");
8280 if (val) {
8281 /* found the field name */
8284 } else {
8285 /* field name not found, switch to opaque mode */
8286 val = var;
8287 var = "Opaque-data";
8288 in_data = 1;
8289 }
8290
8291
8292 ast_str_append(out, 0, xml ? " " : "<tr><td>");
8293 if ((vc = ao2_find(vco, var, 0))) {
8294 vc->count++;
8295 } else {
8296 /* Create a new entry for this one */
8297 vc = ao2_alloc(sizeof(*vc), NULL);
8298 vc->varname = var;
8299 vc->count = 1;
8300 ao2_link(vco, vc);
8301 }
8302
8303 xml_copy_escape(out, var, xml ? 1 | 2 : 0); /* data name */
8304 if (vc->count > 1) {
8305 ast_str_append(out, 0, "-%d", vc->count);
8306 }
8307 ao2_ref(vc, -1);
8308 ast_str_append(out, 0, xml ? "='" : "</td><td>");
8309 xml_copy_escape(out, val, 0); /* data field */
8310 if (!in_data || !*in) {
8311 ast_str_append(out, 0, xml ? "'" : "</td></tr>\n");
8312 }
8313 }
8314
8315 if (inobj) {
8316 ast_str_append(out, 0, xml ? " /></response>\n" :
8317 "<tr><td colspan=\"2\"><hr></td></tr>\r\n");
8318 ao2_ref(vco, -1);
8319 }
8320}
char * strsep(char **str, const char *delims)
#define ao2_link(container, obj)
Add an object to a container.
Definition astobj2.h:1532
#define ao2_alloc(data_size, destructor_fn)
Definition astobj2.h:409
#define ao2_container_alloc_hash(ao2_options, container_options, n_buckets, hash_fn, sort_fn, cmp_fn)
Allocate and initialize a hash container with the desired number of buckets.
Definition astobj2.h:1303
static void xml_copy_escape(struct ast_str **out, const char *src, int mode)
Definition manager.c:8086
static int variable_count_cmp_fn(void *obj, void *vstr, int flags)
Definition manager.c:8165
static int variable_count_hash_fn(const void *vvc, const int flags)
Definition manager.c:8158
char * ast_trim_blanks(char *str)
Trims trailing whitespace characters from a string.
Definition strings.h:186
char *attribute_pure ast_skip_blanks(const char *str)
Gets a pointer to the first non-whitespace character in a string.
Definition strings.h:161
FILE * in
Definition utils/frame.c:33

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

Referenced by process_output().

Variable Documentation

◆ __mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Asterisk Manager Interface" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = AST_MODPRI_CORE, .requires = "extconfig,acl,http", }
static

Definition at line 10183 of file manager.c.

◆ amanageruri

struct ast_http_uri amanageruri
static

Definition at line 9001 of file manager.c.

9001 {
9002 .description = "HTML Manager Event Interface w/Digest authentication",
9003 .uri = "amanager",
9004 .has_subtree = 0,
9005 .callback = auth_manager_http_callback,
9006 .data = NULL,
9007 .key = __FILE__,
9008};
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)
Definition manager.c:8959

Referenced by __init_manager().

◆ amanagerxmluri

struct ast_http_uri amanagerxmluri
static

Definition at line 9010 of file manager.c.

9010 {
9011 .description = "XML Manager Event Interface w/Digest authentication",
9012 .uri = "amxml",
9013 .has_subtree = 0,
9014 .callback = auth_mxml_http_callback,
9015 .data = NULL,
9016 .key = __FILE__,
9017};
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)
Definition manager.c:8970

Referenced by __init_manager().

◆ ami_desc

struct ast_tcptls_session_args ami_desc
static

Definition at line 9110 of file manager.c.

9110 {
9111 .accept_fd = -1,
9112 .master = AST_PTHREADT_NULL,
9113 .tls_cfg = NULL,
9114 .poll_timeout = 5000, /* wake up every 5 seconds */
9115 .periodic_fn = purge_old_stuff,
9116 .name = "AMI server",
9117 .accept_fn = ast_tcptls_server_root, /* thread doing the accept() */
9118 .worker_fn = session_do, /* thread handling the session */
9119};
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 ...
Definition manager.c:7360
static void purge_old_stuff(void *data)
cleanup code called at each iteration of server_root, guaranteed to happen every 5 seconds at most
Definition manager.c:9093
void * ast_tcptls_server_root(void *)
Definition tcptls.c:280

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

◆ ami_tls_cfg

struct ast_tls_config ami_tls_cfg
static

◆ amis_desc

struct ast_tcptls_session_args amis_desc
static

Definition at line 9121 of file manager.c.

9121 {
9122 .accept_fd = -1,
9123 .master = AST_PTHREADT_NULL,
9124 .tls_cfg = &ami_tls_cfg,
9125 .poll_timeout = -1, /* the other does the periodic cleanup */
9126 .name = "AMI TLS server",
9127 .accept_fn = ast_tcptls_server_root, /* thread doing the accept() */
9128 .worker_fn = session_do, /* thread handling the session */
9129};

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

◆ arawmanuri

struct ast_http_uri arawmanuri
static

Definition at line 8992 of file manager.c.

8992 {
8993 .description = "Raw HTTP Manager Event Interface w/Digest authentication",
8994 .uri = "arawman",
8995 .has_subtree = 0,
8996 .callback = auth_rawman_http_callback,
8997 .data = NULL,
8998 .key = __FILE__,
8999};
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)
Definition manager.c:8981

Referenced by __init_manager().

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info
static

Definition at line 10183 of file manager.c.

◆ cli_manager

struct ast_cli_entry cli_manager[]
static

Definition at line 9374 of file manager.c.

9374 {
9375 AST_CLI_DEFINE(handle_showmancmd, "Show a manager interface command"),
9376 AST_CLI_DEFINE(handle_showmancmds, "List manager interface commands"),
9377 AST_CLI_DEFINE(handle_showmanconn, "List connected manager interface users"),
9378 AST_CLI_DEFINE(handle_kickmanconn, "Kick a connected manager interface connection"),
9379 AST_CLI_DEFINE(handle_showmaneventq, "List manager interface queued events"),
9380 AST_CLI_DEFINE(handle_showmanagers, "List configured manager users"),
9381 AST_CLI_DEFINE(handle_showmanager, "Display information on a specific manager user"),
9382 AST_CLI_DEFINE(handle_mandebug, "Show, enable, disable debugging of the manager code"),
9383 AST_CLI_DEFINE(handle_manager_reload, "Reload manager configurations"),
9384 AST_CLI_DEFINE(handle_manager_show_settings, "Show manager global settings"),
9385#ifdef AST_XML_DOCS
9386 AST_CLI_DEFINE(handle_manager_show_events, "List manager interface events"),
9387 AST_CLI_DEFINE(handle_manager_show_event, "Show a manager interface event"),
9388#endif
9389};
#define AST_CLI_DEFINE(fn, txt,...)
Definition cli.h:197
static char * handle_showmancmd(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition manager.c:1077
static char * handle_showmaneventq(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
CLI command manager list eventq.
Definition manager.c:1529
static char * handle_showmanconn(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
CLI command manager list connected.
Definition manager.c:1478
static char * handle_kickmanconn(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
CLI command manager kick session.
Definition manager.c:1408
static char * handle_showmanagers(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition manager.c:1323
static char * handle_showmanager(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition manager.c:1250
static char * handle_manager_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
CLI command manager reload.
Definition manager.c:1557
static char * handle_showmancmds(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
CLI command manager list commands.
Definition manager.c:1366
static char * handle_mandebug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition manager.c:1225
static char * handle_manager_show_events(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition manager.c:9183
static char * handle_manager_show_settings(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
CLI command manager show settings.
Definition manager.c:9132
static char * handle_manager_show_event(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition manager.c:9312

Referenced by __init_manager(), and manager_shutdown().

◆ contenttype

const char* const contenttype[]
static
Initial value:
= {
[FORMAT_RAW] = "plain",
[FORMAT_HTML] = "html",
[FORMAT_XML] = "xml",
}

Definition at line 7916 of file manager.c.

7916 {
7917 [FORMAT_RAW] = "plain",
7918 [FORMAT_HTML] = "html",
7919 [FORMAT_XML] = "xml",
7920};

Referenced by auth_http_callback(), and generic_http_callback().

◆ managerclient_function

struct ast_custom_function managerclient_function
static
Initial value:
= {
.name = "AMI_CLIENT",
.read_max = 12,
}
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
Definition manager.c:9035

description of AMI_CLIENT dialplan function

Definition at line 9082 of file manager.c.

9082 {
9083 .name = "AMI_CLIENT",
9084 .read = function_amiclient,
9085 .read_max = 12,
9086};

Referenced by __init_manager(), and manager_shutdown().

◆ manageruri

struct ast_http_uri manageruri
static

Definition at line 8941 of file manager.c.

8941 {
8942 .description = "HTML Manager Event Interface",
8943 .uri = "manager",
8944 .callback = manager_http_callback,
8945 .data = NULL,
8946 .key = __FILE__,
8947};
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)
Definition manager.c:8900

Referenced by __init_manager().

◆ managerxmluri

struct ast_http_uri managerxmluri
static

Definition at line 8949 of file manager.c.

8949 {
8950 .description = "XML Manager Event Interface",
8951 .uri = "mxml",
8952 .callback = mxml_http_callback,
8953 .data = NULL,
8954 .key = __FILE__,
8955};
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)
Definition manager.c:8911

Referenced by __init_manager().

◆ rawmanuri

struct ast_http_uri rawmanuri
static

Definition at line 8933 of file manager.c.

8933 {
8934 .description = "Raw HTTP Manager Event Interface",
8935 .uri = "rawman",
8936 .callback = rawman_http_callback,
8937 .data = NULL,
8938 .key = __FILE__,
8939};
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)
Definition manager.c:8922

Referenced by __init_manager().

◆ webregged

int webregged = 0
static

Definition at line 9088 of file manager.c.

Referenced by __init_manager().

◆ words

const char* words[AST_MAX_CMD_LEN]

Definition at line 222 of file manager.c.

Referenced by check_blacklist().