Data Structures | |
struct | ast_manager_user |
struct | eventqent |
struct | fast_originate_helper |
struct | mansession |
struct | permalias |
struct | sessions |
struct | users |
struct | variable_count |
Defines | |
#define | ASTMAN_APPEND_BUF_INITSIZE 256 |
#define | MANAGER_EVENT_BUF_INITSIZE 256 |
#define | MAX_BLACKLIST_CMD_LEN 2 |
Functions | |
static void * | accept_thread (void *ignore) |
static int | action_atxfer (struct mansession *s, const struct message *m) |
static int | action_command (struct mansession *s, const struct message *m) |
action_command: 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_corestatus (struct mansession *s, const struct message *m) |
Show PBX core status information. | |
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_getconfig (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_listcommands (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_redirect (struct mansession *s, const struct message *m) |
action_redirect: The redirect manager command | |
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 int | append_event (const char *str, int category) |
static struct ast_manager_user * | ast_get_manager_by_name_locked (const char *name) |
static int | ast_instring (const char *bigstr, const char *smallstr, char delim) |
static int | ast_is_number (const char *string) |
int | ast_manager_register2 (const char *action, int auth, int(*func)(struct mansession *s, const struct message *m), 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 | |
static int | ast_manager_register_struct (struct manager_action *act) |
int | ast_manager_unregister (char *action) |
void | astman_append (struct mansession *s, const char *fmt,...) |
static void | astman_append_buf_init (void) |
const char * | astman_get_header (const struct message *m, char *var) |
ast_variable * | astman_get_variables (const struct message *m) |
void | astman_send_ack (struct mansession *s, const struct message *m, char *msg) |
void | astman_send_error (struct mansession *s, const struct message *m, char *error) |
void | astman_send_response (struct mansession *s, const struct message *m, char *resp, char *msg) |
static int | authenticate (struct mansession *s, const struct message *m) |
static char * | authority_to_str (int authority, char *res, int reslen) |
Convert authority code to string with serveral options. | |
static int | check_blacklist (const char *cmd) |
int | check_manager_enabled () |
Check if AMI is enabled. | |
int | check_webmanager_enabled () |
Check if AMI/HTTP is enabled. | |
static char * | complete_show_mancmd (const char *line, const char *word, int pos, int state) |
static int | compress_char (char c) |
static void | destroy_session (struct mansession *s) |
static int | do_message (struct mansession *s) |
static void * | fast_originate (void *data) |
static void | free_session (struct mansession *s) |
static int | get_input (struct mansession *s, char *output) |
static int | get_perm (const char *instr) |
static int | handle_showmanager (int fd, int argc, char *argv[]) |
static int | handle_showmanagers (int fd, int argc, char *argv[]) |
static int | handle_showmancmd (int fd, int argc, char *argv[]) |
static int | handle_showmancmds (int fd, int argc, char *argv[]) |
CLI command Should change to "manager show commands". | |
static int | handle_showmanconn (int fd, int argc, char *argv[]) |
CLI command show manager connected. | |
static int | handle_showmaneventq (int fd, int argc, char *argv[]) |
CLI command show manager eventq. | |
static void | handle_updates (struct mansession *s, const struct message *m, struct ast_config *cfg) |
static char * | html_translate (char *in) |
int | manager_event (int category, const char *event, const char *fmt,...) |
manager_event: Send AMI event to client | |
static void | manager_event_buf_init (void) |
static int | manager_state_cb (char *context, char *exten, int state, void *data) |
static int | process_events (struct mansession *s) |
static int | process_message (struct mansession *s, const struct message *m) |
static void * | session_do (void *data) |
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 | strings_to_mask (const char *string) |
static void | unuse_eventqent (struct eventqent *e) |
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 (char **dst, size_t *maxlen, const char *src, int lower) |
static char * | xml_translate (char *in, struct ast_variable *vars) |
Variables | |
static ast_rwlock_t | actionlock = PTHREAD_RWLOCK_INITIALIZER |
static int | asock = -1 |
static struct ast_threadstorage | astman_append_buf = { .once = PTHREAD_ONCE_INIT, .key_init = astman_append_buf_init , } |
static int | block_sockets |
static struct ast_cli_entry | cli_manager [] |
static struct ast_cli_entry | cli_show_manager_command_deprecated |
static struct ast_cli_entry | cli_show_manager_commands_deprecated |
static struct ast_cli_entry | cli_show_manager_connected_deprecated |
static struct ast_cli_entry | cli_show_manager_eventq_deprecated |
struct { | |
char * words [AST_MAX_CMD_LEN] | |
} | command_blacklist [] |
static int | displayconnects = 1 |
static struct manager_action * | first_action |
static int | httptimeout = 60 |
static int | manager_enabled = 0 |
static struct ast_threadstorage | manager_event_buf = { .once = PTHREAD_ONCE_INIT, .key_init = manager_event_buf_init , } |
static char | mandescr_atxfer [] |
static char | mandescr_command [] |
static char | mandescr_coresettings [] |
static char | mandescr_corestatus [] |
static char | mandescr_events [] |
static char | mandescr_extensionstate [] |
static char | mandescr_getconfig [] |
static char | mandescr_getvar [] |
static char | mandescr_hangup [] |
static char | mandescr_listcommands [] |
static char | mandescr_logoff [] |
static char | mandescr_mailboxcount [] |
static char | mandescr_mailboxstatus [] |
Help text for manager command mailboxstatus. | |
static char | mandescr_originate [] |
static char | mandescr_ping [] |
Manager PING. | |
static char | mandescr_redirect [] |
static char | mandescr_setvar [] |
static char | mandescr_timeout [] |
static char | mandescr_updateconfig [] |
static char | mandescr_userevent [] |
static char | mandescr_waitevent [] |
Manager WAITEVENT. | |
eventqent * | master_eventq = NULL |
static int | num_sessions |
static struct permalias | perms [] |
static int | portno = DEFAULT_MANAGER_PORT |
static char | showmanager_help [] |
static char | showmanagers_help [] |
static char | showmancmd_help [] |
static char | showmancmds_help [] |
static char | showmanconn_help [] |
static char | showmaneventq_help [] |
static pthread_t | t |
static int | timestampevents |
static int | webmanager_enabled = 0 |
#define ASTMAN_APPEND_BUF_INITSIZE 256 |
#define MANAGER_EVENT_BUF_INITSIZE 256 |
#define MAX_BLACKLIST_CMD_LEN 2 |
static void* accept_thread | ( | void * | ignore | ) | [static] |
Definition at line 2526 of file manager.c.
References asock, ast_atomic_fetchadd_int(), ast_calloc, ast_inet_ntoa(), AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_log(), ast_mutex_init(), ast_pthread_create_background, AST_PTHREADT_NULL, ast_verbose(), block_sockets, destroy_session(), displayconnects, errno, pollfd::events, pollfd::fd, ast_channel::flags, free, free_session(), LOG_WARNING, master_eventq, eventqent::next, num_sessions, option_verbose, poll(), POLLIN, s, session_do(), eventqent::usecount, and VERBOSE_PREFIX_2.
Referenced by reload_config().
02527 { 02528 int as; 02529 struct sockaddr_in sin; 02530 socklen_t sinlen; 02531 struct eventqent *eqe; 02532 struct mansession *s; 02533 struct protoent *p; 02534 int arg = 1; 02535 int flags; 02536 pthread_attr_t attr; 02537 time_t now; 02538 struct pollfd pfds[1]; 02539 02540 pthread_attr_init(&attr); 02541 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); 02542 02543 for (;;) { 02544 time(&now); 02545 AST_LIST_LOCK(&sessions); 02546 AST_LIST_TRAVERSE_SAFE_BEGIN(&sessions, s, list) { 02547 if (s->sessiontimeout && (now > s->sessiontimeout) && !s->inuse) { 02548 AST_LIST_REMOVE_CURRENT(&sessions, list); 02549 num_sessions--; 02550 if (s->authenticated && (option_verbose > 1) && displayconnects) { 02551 ast_verbose(VERBOSE_PREFIX_2 "HTTP Manager '%s' timed out from %s\n", 02552 s->username, ast_inet_ntoa(s->sin.sin_addr)); 02553 } 02554 free_session(s); 02555 break; 02556 } 02557 } 02558 AST_LIST_TRAVERSE_SAFE_END 02559 /* Purge master event queue of old, unused events, but make sure we 02560 always keep at least one in the queue */ 02561 eqe = master_eventq; 02562 while (master_eventq->next && !master_eventq->usecount) { 02563 eqe = master_eventq; 02564 master_eventq = master_eventq->next; 02565 free(eqe); 02566 } 02567 AST_LIST_UNLOCK(&sessions); 02568 02569 sinlen = sizeof(sin); 02570 pfds[0].fd = asock; 02571 pfds[0].events = POLLIN; 02572 /* Wait for something to happen, but timeout every few seconds so 02573 we can ditch any old manager sessions */ 02574 if (poll(pfds, 1, 5000) < 1) 02575 continue; 02576 as = accept(asock, (struct sockaddr *)&sin, &sinlen); 02577 if (as < 0) { 02578 ast_log(LOG_NOTICE, "Accept returned -1: %s\n", strerror(errno)); 02579 continue; 02580 } 02581 p = getprotobyname("tcp"); 02582 if (p) { 02583 if( setsockopt(as, p->p_proto, TCP_NODELAY, (char *)&arg, sizeof(arg) ) < 0 ) { 02584 ast_log(LOG_WARNING, "Failed to set manager tcp connection to TCP_NODELAY mode: %s\n", strerror(errno)); 02585 } 02586 } 02587 if (!(s = ast_calloc(1, sizeof(*s)))) 02588 continue; 02589 02590 memcpy(&s->sin, &sin, sizeof(sin)); 02591 s->writetimeout = 100; 02592 s->waiting_thread = AST_PTHREADT_NULL; 02593 02594 if (!block_sockets) { 02595 /* For safety, make sure socket is non-blocking */ 02596 flags = fcntl(as, F_GETFL); 02597 fcntl(as, F_SETFL, flags | O_NONBLOCK); 02598 } else { 02599 flags = fcntl(as, F_GETFL); 02600 fcntl(as, F_SETFL, flags & ~O_NONBLOCK); 02601 } 02602 ast_mutex_init(&s->__lock); 02603 s->fd = as; 02604 s->send_events = -1; 02605 AST_LIST_LOCK(&sessions); 02606 AST_LIST_INSERT_HEAD(&sessions, s, list); 02607 num_sessions++; 02608 /* Find the last place in the master event queue and hook ourselves 02609 in there */ 02610 s->eventq = master_eventq; 02611 while(s->eventq->next) 02612 s->eventq = s->eventq->next; 02613 ast_atomic_fetchadd_int(&s->eventq->usecount, 1); 02614 AST_LIST_UNLOCK(&sessions); 02615 if (ast_pthread_create_background(&s->t, &attr, session_do, s)) 02616 destroy_session(s); 02617 } 02618 pthread_attr_destroy(&attr); 02619 return NULL; 02620 }
static int action_atxfer | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 1768 of file manager.c.
References asprintf, ast_channel_unlock, AST_CONTROL_ATXFERCMD, ast_get_channel_by_name_locked(), ast_queue_control_data(), ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), cleanup(), context, exten, free, len(), name, and s.
Referenced by init_manager().
01769 { 01770 struct ast_channel *c; 01771 const char *name = astman_get_header(m, "Channel"); 01772 const char *exten = astman_get_header(m, "Exten"); 01773 const char *context = astman_get_header(m, "Context"); 01774 char *xferto; 01775 int len; 01776 01777 if (ast_strlen_zero(name)) { 01778 astman_send_error(s, m, "No channel specified"); 01779 return 0; 01780 } 01781 if (ast_strlen_zero(exten)) { 01782 astman_send_error(s, m, "No exten specified"); 01783 return 0; 01784 } 01785 c = ast_get_channel_by_name_locked(name); 01786 if (!c) { 01787 astman_send_error(s, m, "No such channel"); 01788 return 0; 01789 } 01790 len = asprintf(&xferto, "%s@%s", exten, context); 01791 if (len < 0) { 01792 astman_send_error(s, m, "Out of memory!"); 01793 goto cleanup; 01794 } 01795 ast_queue_control_data(c, AST_CONTROL_ATXFERCMD, xferto, len+1); 01796 free(xferto); 01797 astman_send_ack(s, m, "Attended transfer started"); 01798 cleanup: 01799 ast_channel_unlock(c); 01800 return 0; 01801 }
static int action_command | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
action_command: Manager command "command" - execute CLI command
Definition at line 1810 of file manager.c.
References ast_calloc, ast_cli_command(), ast_free, ast_log(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), check_blacklist(), errno, LOG_WARNING, s, S_OR, and term_strip().
Referenced by init_manager().
01811 { 01812 const char *cmd = astman_get_header(m, "Command"); 01813 const char *id = astman_get_header(m, "ActionID"); 01814 char *buf, *final_buf; 01815 char template[] = "/tmp/ast-ami-XXXXXX"; /* template for temporary file */ 01816 int fd = mkstemp(template); 01817 off_t l; 01818 01819 if (ast_strlen_zero(cmd)) { 01820 astman_send_error(s, m, "No command provided"); 01821 return 0; 01822 } 01823 01824 if (check_blacklist(cmd)) { 01825 astman_send_error(s, m, "Command blacklisted"); 01826 return 0; 01827 } 01828 01829 astman_append(s, "Response: Follows\r\nPrivilege: Command\r\n"); 01830 if (!ast_strlen_zero(id)) 01831 astman_append(s, "ActionID: %s\r\n", id); 01832 /* FIXME: Wedge a ActionID response in here, waiting for later changes */ 01833 ast_cli_command(fd, cmd); /* XXX need to change this to use a FILE * */ 01834 l = lseek(fd, 0, SEEK_END); /* how many chars available */ 01835 01836 /* This has a potential to overflow the stack. Hence, use the heap. */ 01837 buf = ast_calloc(1, l + 1); 01838 final_buf = ast_calloc(1, l + 1); 01839 if (buf) { 01840 lseek(fd, 0, SEEK_SET); 01841 if (read(fd, buf, l) < 0) { 01842 ast_log(LOG_WARNING, "read() failed: %s\n", strerror(errno)); 01843 } 01844 buf[l] = '\0'; 01845 if (final_buf) { 01846 term_strip(final_buf, buf, l); 01847 final_buf[l] = '\0'; 01848 } 01849 astman_append(s, "%s", S_OR(final_buf, buf)); 01850 ast_free(buf); 01851 } 01852 close(fd); 01853 unlink(template); 01854 astman_append(s, "--END COMMAND--\r\n\r\n"); 01855 if (final_buf) 01856 ast_free(final_buf); 01857 return 0; 01858 }
static int action_coresettings | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Show PBX core settings information.
Definition at line 2240 of file manager.c.
References AMI_VERSION, ast_config_AST_RUN_GROUP, ast_config_AST_RUN_USER, ast_config_AST_SYSTEM_NAME, ast_realtime_enabled(), ast_strlen_zero(), ASTERISK_VERSION, astman_append(), astman_get_header(), check_cdr_enabled(), check_webmanager_enabled(), option_maxcalls, option_maxfiles, option_maxload, and s.
Referenced by init_manager().
02241 { 02242 const char *actionid = astman_get_header(m, "ActionID"); 02243 char idText[150] = ""; 02244 02245 if (!ast_strlen_zero(actionid)) 02246 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", actionid); 02247 02248 astman_append(s, "Response: Success\r\n" 02249 "%s" 02250 "AMIversion: %s\r\n" 02251 "AsteriskVersion: %s\r\n" 02252 "SystemName: %s\r\n" 02253 "CoreMaxCalls: %d\r\n" 02254 "CoreMaxLoadAvg: %f\r\n" 02255 "CoreRunUser: %s\r\n" 02256 "CoreRunGroup: %s\r\n" 02257 "CoreMaxFilehandles: %d\r\n" 02258 "CoreRealTimeEnabled: %s\r\n" 02259 "CoreCDRenabled: %s\r\n" 02260 "CoreHTTPenabled: %s\r\n" 02261 "\r\n", 02262 idText, 02263 AMI_VERSION, 02264 ASTERISK_VERSION, 02265 ast_config_AST_SYSTEM_NAME, 02266 option_maxcalls, 02267 option_maxload, 02268 ast_config_AST_RUN_USER, 02269 ast_config_AST_RUN_GROUP, 02270 option_maxfiles, 02271 ast_realtime_enabled() ? "Yes" : "No", 02272 check_cdr_enabled() ? "Yes" : "No", 02273 check_webmanager_enabled() ? "Yes" : "No" 02274 ); 02275 return 0; 02276 }
static int action_corestatus | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Show PBX core status information.
Definition at line 2284 of file manager.c.
References ast_active_channels(), ast_lastreloadtime, ast_localtime(), ast_startuptime, ast_strlen_zero(), astman_append(), astman_get_header(), and s.
Referenced by init_manager().
02285 { 02286 const char *actionid = astman_get_header(m, "ActionID"); 02287 char idText[150]; 02288 char startuptime[150]; 02289 char reloadtime[150]; 02290 struct tm tm; 02291 02292 if (!ast_strlen_zero(actionid)) 02293 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", actionid); 02294 02295 ast_localtime(&ast_startuptime, &tm, NULL); 02296 strftime(startuptime, sizeof(startuptime), "%H:%M:%S", &tm); 02297 ast_localtime(&ast_lastreloadtime, &tm, NULL); 02298 strftime(reloadtime, sizeof(reloadtime), "%H:%M:%S", &tm); 02299 02300 astman_append(s, "Response: Success\r\n" 02301 "%s" 02302 "CoreStartupTime: %s\r\n" 02303 "CoreReloadTime: %s\r\n" 02304 "CoreCurrentCalls: %d\r\n" 02305 "\r\n", 02306 idText, 02307 startuptime, 02308 reloadtime, 02309 ast_active_channels() 02310 ); 02311 return 0; 02312 }
static int action_events | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 1405 of file manager.c.
References astman_get_header(), astman_send_response(), s, and set_eventmask().
Referenced by init_manager().
01406 { 01407 const char *mask = astman_get_header(m, "EventMask"); 01408 int res; 01409 01410 res = set_eventmask(s, mask); 01411 if (res > 0) 01412 astman_send_response(s, m, "Events On", NULL); 01413 else if (res == 0) 01414 astman_send_response(s, m, "Events Off", NULL); 01415 01416 return 0; 01417 }
static int action_extensionstate | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 2118 of file manager.c.
References ast_extension_state(), ast_get_hint(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), context, exten, and s.
Referenced by init_manager().
02119 { 02120 const char *exten = astman_get_header(m, "Exten"); 02121 const char *context = astman_get_header(m, "Context"); 02122 const char *id = astman_get_header(m,"ActionID"); 02123 char idText[256] = ""; 02124 char hint[256] = ""; 02125 int status; 02126 if (ast_strlen_zero(exten)) { 02127 astman_send_error(s, m, "Extension not specified"); 02128 return 0; 02129 } 02130 if (ast_strlen_zero(context)) 02131 context = "default"; 02132 status = ast_extension_state(NULL, context, exten); 02133 ast_get_hint(hint, sizeof(hint) - 1, NULL, 0, NULL, context, exten); 02134 if (!ast_strlen_zero(id)) { 02135 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id); 02136 } 02137 astman_append(s, "Response: Success\r\n" 02138 "%s" 02139 "Message: Extension Status\r\n" 02140 "Exten: %s\r\n" 02141 "Context: %s\r\n" 02142 "Hint: %s\r\n" 02143 "Status: %d\r\n\r\n", 02144 idText,exten, context, hint, status); 02145 return 0; 02146 }
static int action_getconfig | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 1134 of file manager.c.
References ast_category_browse(), ast_config_destroy(), ast_config_load_with_comments(), ast_strlen_zero(), ast_variable_browse(), astman_append(), astman_get_header(), astman_send_error(), ast_variable::name, ast_variable::next, s, and ast_variable::value.
Referenced by init_manager().
01135 { 01136 struct ast_config *cfg; 01137 const char *fn = astman_get_header(m, "Filename"); 01138 int catcount = 0; 01139 int lineno = 0; 01140 char *category=NULL; 01141 struct ast_variable *v; 01142 char idText[256] = ""; 01143 const char *id = astman_get_header(m, "ActionID"); 01144 01145 if (!ast_strlen_zero(id)) 01146 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id); 01147 01148 if (ast_strlen_zero(fn)) { 01149 astman_send_error(s, m, "Filename not specified"); 01150 return 0; 01151 } 01152 if (!(cfg = ast_config_load_with_comments(fn))) { 01153 astman_send_error(s, m, "Config file not found"); 01154 return 0; 01155 } 01156 astman_append(s, "Response: Success\r\n%s", idText); 01157 while ((category = ast_category_browse(cfg, category))) { 01158 lineno = 0; 01159 astman_append(s, "Category-%06d: %s\r\n", catcount, category); 01160 for (v = ast_variable_browse(cfg, category); v; v = v->next) 01161 astman_append(s, "Line-%06d-%06d: %s=%s\r\n", catcount, lineno++, v->name, v->value); 01162 catcount++; 01163 } 01164 ast_config_destroy(cfg); 01165 astman_append(s, "\r\n"); 01166 01167 return 0; 01168 }
static int action_getvar | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 1497 of file manager.c.
References ast_channel_alloc(), ast_channel_free(), ast_channel_unlock, ast_func_read(), ast_get_channel_by_name_locked(), ast_log(), ast_strdupa, ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), copy(), LOG_ERROR, name, pbx_retrieve_variable(), and s.
Referenced by init_manager().
01498 { 01499 struct ast_channel *c = NULL; 01500 const char *name = astman_get_header(m, "Channel"); 01501 const char *varname = astman_get_header(m, "Variable"); 01502 const char *id = astman_get_header(m,"ActionID"); 01503 char *varval; 01504 char workspace[1024] = ""; 01505 01506 if (ast_strlen_zero(varname)) { 01507 astman_send_error(s, m, "No variable specified"); 01508 return 0; 01509 } 01510 01511 if (!ast_strlen_zero(name)) { 01512 c = ast_get_channel_by_name_locked(name); 01513 if (!c) { 01514 astman_send_error(s, m, "No such channel"); 01515 return 0; 01516 } 01517 } 01518 01519 if (varname[strlen(varname) - 1] == ')') { 01520 char *copy = ast_strdupa(varname); 01521 if (!c) { 01522 c = ast_channel_alloc(0, 0, "", "", "", "", "", 0, "Bogus/manager"); 01523 if (c) { 01524 ast_func_read(c, copy, workspace, sizeof(workspace)); 01525 ast_channel_free(c); 01526 } else 01527 ast_log(LOG_ERROR, "Unable to allocate bogus channel for variable substitution. Function results may be blank.\n"); 01528 } else 01529 ast_func_read(c, copy, workspace, sizeof(workspace)); 01530 varval = workspace; 01531 } else { 01532 pbx_retrieve_variable(c, varname, &varval, workspace, sizeof(workspace), NULL); 01533 } 01534 01535 if (c) 01536 ast_channel_unlock(c); 01537 astman_append(s, "Response: Success\r\n" 01538 "Variable: %s\r\nValue: %s\r\n", varname, varval); 01539 if (!ast_strlen_zero(id)) 01540 astman_append(s, "ActionID: %s\r\n",id); 01541 astman_append(s, "\r\n"); 01542 01543 return 0; 01544 }
static int action_hangup | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 1434 of file manager.c.
References ast_channel_unlock, ast_get_channel_by_name_locked(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), name, and s.
Referenced by init_manager().
01435 { 01436 struct ast_channel *c = NULL; 01437 const char *name = astman_get_header(m, "Channel"); 01438 if (ast_strlen_zero(name)) { 01439 astman_send_error(s, m, "No channel specified"); 01440 return 0; 01441 } 01442 c = ast_get_channel_by_name_locked(name); 01443 if (!c) { 01444 astman_send_error(s, m, "No such channel"); 01445 return 0; 01446 } 01447 ast_softhangup(c, AST_SOFTHANGUP_EXPLICIT); 01448 ast_channel_unlock(c); 01449 astman_send_ack(s, m, "Channel Hungup"); 01450 return 0; 01451 }
static int action_listcommands | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 1378 of file manager.c.
References manager_action::action, ast_strlen_zero(), astman_append(), astman_get_header(), manager_action::authority, authority_to_str(), first_action, manager_action::next, s, and manager_action::synopsis.
Referenced by init_manager().
01379 { 01380 struct manager_action *cur; 01381 char idText[256] = ""; 01382 char temp[BUFSIZ]; 01383 const char *id = astman_get_header(m,"ActionID"); 01384 01385 if (!ast_strlen_zero(id)) 01386 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id); 01387 astman_append(s, "Response: Success\r\n%s", idText); 01388 for (cur = first_action; cur; cur = cur->next) { 01389 if ((s->writeperm & cur->authority) == cur->authority) 01390 astman_append(s, "%s: %s (Priv: %s)\r\n", cur->action, cur->synopsis, authority_to_str(cur->authority, temp, sizeof(temp))); 01391 } 01392 astman_append(s, "\r\n"); 01393 01394 return 0; 01395 }
static int action_logoff | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 1423 of file manager.c.
References astman_send_response(), and s.
Referenced by init_manager().
01424 { 01425 astman_send_response(s, m, "Goodbye", "Thanks for all the fish."); 01426 return -1; 01427 }
static int action_mailboxcount | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 2082 of file manager.c.
References ast_app_inboxcount(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), mailbox, and s.
Referenced by init_manager().
02083 { 02084 const char *mailbox = astman_get_header(m, "Mailbox"); 02085 const char *id = astman_get_header(m,"ActionID"); 02086 char idText[256] = ""; 02087 int newmsgs = 0, oldmsgs = 0; 02088 if (ast_strlen_zero(mailbox)) { 02089 astman_send_error(s, m, "Mailbox not specified"); 02090 return 0; 02091 } 02092 ast_app_inboxcount(mailbox, &newmsgs, &oldmsgs); 02093 if (!ast_strlen_zero(id)) { 02094 snprintf(idText, sizeof(idText), "ActionID: %s\r\n",id); 02095 } 02096 astman_append(s, "Response: Success\r\n" 02097 "%s" 02098 "Message: Mailbox Message Count\r\n" 02099 "Mailbox: %s\r\n" 02100 "NewMessages: %d\r\n" 02101 "OldMessages: %d\r\n" 02102 "\r\n", 02103 idText,mailbox, newmsgs, oldmsgs); 02104 return 0; 02105 }
static int action_mailboxstatus | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 2050 of file manager.c.
References ast_app_has_voicemail(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), mailbox, and s.
Referenced by init_manager().
02051 { 02052 const char *mailbox = astman_get_header(m, "Mailbox"); 02053 const char *id = astman_get_header(m,"ActionID"); 02054 char idText[256] = ""; 02055 int ret; 02056 if (ast_strlen_zero(mailbox)) { 02057 astman_send_error(s, m, "Mailbox not specified"); 02058 return 0; 02059 } 02060 if (!ast_strlen_zero(id)) 02061 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id); 02062 ret = ast_app_has_voicemail(mailbox, NULL); 02063 astman_append(s, "Response: Success\r\n" 02064 "%s" 02065 "Message: Mailbox Status\r\n" 02066 "Mailbox: %s\r\n" 02067 "Waiting: %d\r\n\r\n", idText, mailbox, ret); 02068 return 0; 02069 }
static int action_originate | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 1924 of file manager.c.
References app, ast_callerid_parse(), ast_calloc, ast_copy_string(), ast_findlabel_extension(), AST_FORMAT_SLINEAR, ast_free, ast_parse_allow_disallow(), ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), ast_pthread_create, ast_shrink_phone_number(), ast_strlen_zero(), ast_true(), astman_get_header(), astman_get_variables(), astman_send_ack(), astman_send_error(), context, ast_channel::data, exten, fast_originate(), format, name, ast_channel::priority, s, and ast_channel::tech.
Referenced by init_manager().
01925 { 01926 const char *name = astman_get_header(m, "Channel"); 01927 const char *exten = astman_get_header(m, "Exten"); 01928 const char *context = astman_get_header(m, "Context"); 01929 const char *priority = astman_get_header(m, "Priority"); 01930 const char *timeout = astman_get_header(m, "Timeout"); 01931 const char *callerid = astman_get_header(m, "CallerID"); 01932 const char *account = astman_get_header(m, "Account"); 01933 const char *app = astman_get_header(m, "Application"); 01934 const char *appdata = astman_get_header(m, "Data"); 01935 const char *async = astman_get_header(m, "Async"); 01936 const char *id = astman_get_header(m, "ActionID"); 01937 const char *codecs = astman_get_header(m, "Codecs"); 01938 struct ast_variable *vars = astman_get_variables(m); 01939 char *tech, *data; 01940 char *l = NULL, *n = NULL; 01941 int pi = 0; 01942 int res; 01943 int to = 30000; 01944 int reason = 0; 01945 char tmp[256]; 01946 char tmp2[256]; 01947 int format = AST_FORMAT_SLINEAR; 01948 01949 pthread_t th; 01950 pthread_attr_t attr; 01951 if (ast_strlen_zero(name)) { 01952 astman_send_error(s, m, "Channel not specified"); 01953 return 0; 01954 } 01955 if (!ast_strlen_zero(priority) && (sscanf(priority, "%d", &pi) != 1)) { 01956 if ((pi = ast_findlabel_extension(NULL, context, exten, priority, NULL)) < 1) { 01957 astman_send_error(s, m, "Invalid priority"); 01958 return 0; 01959 } 01960 } 01961 if (!ast_strlen_zero(timeout) && (sscanf(timeout, "%d", &to) != 1)) { 01962 astman_send_error(s, m, "Invalid timeout"); 01963 return 0; 01964 } 01965 ast_copy_string(tmp, name, sizeof(tmp)); 01966 tech = tmp; 01967 data = strchr(tmp, '/'); 01968 if (!data) { 01969 astman_send_error(s, m, "Invalid channel"); 01970 return 0; 01971 } 01972 *data++ = '\0'; 01973 ast_copy_string(tmp2, callerid, sizeof(tmp2)); 01974 ast_callerid_parse(tmp2, &n, &l); 01975 if (n) { 01976 if (ast_strlen_zero(n)) 01977 n = NULL; 01978 } 01979 if (l) { 01980 ast_shrink_phone_number(l); 01981 if (ast_strlen_zero(l)) 01982 l = NULL; 01983 } 01984 if (!ast_strlen_zero(codecs)) { 01985 format = 0; 01986 ast_parse_allow_disallow(NULL, &format, codecs, 1); 01987 } 01988 if (ast_true(async)) { 01989 struct fast_originate_helper *fast = ast_calloc(1, sizeof(*fast)); 01990 if (!fast) { 01991 res = -1; 01992 } else { 01993 if (!ast_strlen_zero(id)) 01994 snprintf(fast->idtext, sizeof(fast->idtext), "ActionID: %s\r\n", id); 01995 ast_copy_string(fast->tech, tech, sizeof(fast->tech)); 01996 ast_copy_string(fast->data, data, sizeof(fast->data)); 01997 ast_copy_string(fast->app, app, sizeof(fast->app)); 01998 ast_copy_string(fast->appdata, appdata, sizeof(fast->appdata)); 01999 if (l) 02000 ast_copy_string(fast->cid_num, l, sizeof(fast->cid_num)); 02001 if (n) 02002 ast_copy_string(fast->cid_name, n, sizeof(fast->cid_name)); 02003 fast->vars = vars; 02004 ast_copy_string(fast->context, context, sizeof(fast->context)); 02005 ast_copy_string(fast->exten, exten, sizeof(fast->exten)); 02006 ast_copy_string(fast->account, account, sizeof(fast->account)); 02007 fast->format = format; 02008 fast->timeout = to; 02009 fast->priority = pi; 02010 pthread_attr_init(&attr); 02011 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); 02012 if (ast_pthread_create(&th, &attr, fast_originate, fast)) { 02013 ast_free(fast); 02014 res = -1; 02015 } else { 02016 res = 0; 02017 } 02018 pthread_attr_destroy(&attr); 02019 } 02020 } else if (!ast_strlen_zero(app)) { 02021 res = ast_pbx_outgoing_app(tech, format, data, to, app, appdata, &reason, 1, l, n, vars, account, NULL); 02022 } else { 02023 if (exten && context && pi) 02024 res = ast_pbx_outgoing_exten(tech, format, data, to, context, exten, pi, &reason, 1, l, n, vars, account, NULL); 02025 else { 02026 astman_send_error(s, m, "Originate with 'Exten' requires 'Context' and 'Priority'"); 02027 return 0; 02028 } 02029 } 02030 if (!res) 02031 astman_send_ack(s, m, "Originate successfully queued"); 02032 else 02033 astman_send_error(s, m, "Originate failed"); 02034 return 0; 02035 }
static int action_ping | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 1122 of file manager.c.
References astman_send_response(), and s.
Referenced by init_manager().
01123 { 01124 astman_send_response(s, m, "Pong", NULL); 01125 return 0; 01126 }
static int action_redirect | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
action_redirect: The redirect manager command
Definition at line 1650 of file manager.c.
References ast_async_goto(), ast_channel_lock, ast_channel_unlock, ast_check_hangup(), ast_findlabel_extension(), AST_FLAG_BRIDGE_HANGUP_DONT, ast_get_channel_by_name_locked(), ast_set_flag, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), context, exten, name, ast_channel::pbx, and s.
Referenced by init_manager().
01651 { 01652 const char *name = astman_get_header(m, "Channel"); 01653 const char *name2 = astman_get_header(m, "ExtraChannel"); 01654 const char *exten = astman_get_header(m, "Exten"); 01655 const char *context = astman_get_header(m, "Context"); 01656 const char *priority = astman_get_header(m, "Priority"); 01657 struct ast_channel *chan, *chan2 = NULL; 01658 int pi = 0; 01659 int res; 01660 01661 if (ast_strlen_zero(name)) { 01662 astman_send_error(s, m, "Channel not specified"); 01663 return 0; 01664 } 01665 if (!ast_strlen_zero(priority) && (sscanf(priority, "%d", &pi) != 1)) { 01666 if ((pi = ast_findlabel_extension(NULL, context, exten, priority, NULL)) < 1) { 01667 astman_send_error(s, m, "Invalid priority"); 01668 return 0; 01669 } 01670 } 01671 /* XXX watch out, possible deadlock!!! */ 01672 chan = ast_get_channel_by_name_locked(name); 01673 if (!chan) { 01674 char buf[BUFSIZ]; 01675 snprintf(buf, sizeof(buf), "Channel does not exist: %s", name); 01676 astman_send_error(s, m, buf); 01677 return 0; 01678 } 01679 if (ast_check_hangup(chan)) { 01680 astman_send_error(s, m, "Redirect failed, channel not up."); 01681 ast_channel_unlock(chan); 01682 return 0; 01683 } 01684 if (!ast_strlen_zero(name2)) 01685 chan2 = ast_get_channel_by_name_locked(name2); 01686 if (chan2 && ast_check_hangup(chan2)) { 01687 astman_send_error(s, m, "Redirect failed, extra channel not up."); 01688 ast_channel_unlock(chan); 01689 ast_channel_unlock(chan2); 01690 return 0; 01691 } 01692 if (chan->pbx) { 01693 ast_channel_lock(chan); 01694 ast_set_flag(chan, AST_FLAG_BRIDGE_HANGUP_DONT); /* don't let the after-bridge code run the h-exten */ 01695 ast_channel_unlock(chan); 01696 } 01697 res = ast_async_goto(chan, context, exten, pi); 01698 if (!res) { 01699 if (!ast_strlen_zero(name2)) { 01700 if (chan2) { 01701 if (chan2->pbx) { 01702 ast_channel_lock(chan2); 01703 ast_set_flag(chan2, AST_FLAG_BRIDGE_HANGUP_DONT); /* don't let the after-bridge code run the h-exten */ 01704 ast_channel_unlock(chan2); 01705 } 01706 res = ast_async_goto(chan2, context, exten, pi); 01707 } else { 01708 res = -1; 01709 } 01710 if (!res) 01711 astman_send_ack(s, m, "Dual Redirect successful"); 01712 else 01713 astman_send_error(s, m, "Secondary redirect failed"); 01714 } else 01715 astman_send_ack(s, m, "Redirect successful"); 01716 } else 01717 astman_send_error(s, m, "Redirect failed"); 01718 if (chan) 01719 ast_channel_unlock(chan); 01720 if (chan2) 01721 ast_channel_unlock(chan2); 01722 return 0; 01723 }
static int action_setvar | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 1460 of file manager.c.
References ast_channel_unlock, ast_get_channel_by_name_locked(), ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), name, pbx_builtin_setvar_helper(), s, and S_OR.
Referenced by init_manager().
01461 { 01462 struct ast_channel *c = NULL; 01463 const char *name = astman_get_header(m, "Channel"); 01464 const char *varname = astman_get_header(m, "Variable"); 01465 const char *varval = astman_get_header(m, "Value"); 01466 01467 if (ast_strlen_zero(varname)) { 01468 astman_send_error(s, m, "No variable specified"); 01469 return 0; 01470 } 01471 01472 if (!ast_strlen_zero(name)) { 01473 c = ast_get_channel_by_name_locked(name); 01474 if (!c) { 01475 astman_send_error(s, m, "No such channel"); 01476 return 0; 01477 } 01478 } 01479 01480 pbx_builtin_setvar_helper(c, varname, S_OR(varval, "")); 01481 01482 if (c) 01483 ast_channel_unlock(c); 01484 01485 astman_send_ack(s, m, "Variable Set"); 01486 01487 return 0; 01488 }
static int action_status | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Manager "status" command to show channels.
Definition at line 1549 of file manager.c.
References ast_channel::_bridge, ast_channel::_state, ast_channel::accountcode, ast_channel_unlock, ast_channel_walk_locked(), ast_get_channel_by_name_locked(), ast_state2str(), ast_strlen_zero(), ast_tvnow(), astman_append(), astman_get_header(), astman_send_ack(), astman_send_error(), ast_channel::cdr, ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, ast_channel::context, ast_channel::exten, ast_channel::name, name, ast_channel::pbx, ast_channel::priority, s, S_OR, ast_cdr::start, and ast_channel::uniqueid.
Referenced by init_manager().
01550 { 01551 const char *id = astman_get_header(m,"ActionID"); 01552 const char *name = astman_get_header(m,"Channel"); 01553 char idText[256] = ""; 01554 struct ast_channel *c; 01555 char bridge[256]; 01556 struct timeval now = ast_tvnow(); 01557 long elapsed_seconds = 0; 01558 int all = ast_strlen_zero(name); /* set if we want all channels */ 01559 01560 if (!ast_strlen_zero(id)) 01561 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id); 01562 if (all) 01563 c = ast_channel_walk_locked(NULL); 01564 else { 01565 c = ast_get_channel_by_name_locked(name); 01566 if (!c) { 01567 astman_send_error(s, m, "No such channel"); 01568 return 0; 01569 } 01570 } 01571 astman_send_ack(s, m, "Channel status will follow"); 01572 /* if we look by name, we break after the first iteration */ 01573 while (c) { 01574 if (c->_bridge) 01575 snprintf(bridge, sizeof(bridge), "Link: %s\r\n", c->_bridge->name); 01576 else 01577 bridge[0] = '\0'; 01578 if (c->pbx) { 01579 if (c->cdr) { 01580 elapsed_seconds = now.tv_sec - c->cdr->start.tv_sec; 01581 } 01582 astman_append(s, 01583 "Event: Status\r\n" 01584 "Privilege: Call\r\n" 01585 "Channel: %s\r\n" 01586 "CallerID: %s\r\n" /* This parameter is deprecated and will be removed post-1.4 */ 01587 "CallerIDNum: %s\r\n" 01588 "CallerIDName: %s\r\n" 01589 "Account: %s\r\n" 01590 "State: %s\r\n" 01591 "Context: %s\r\n" 01592 "Extension: %s\r\n" 01593 "Priority: %d\r\n" 01594 "Seconds: %ld\r\n" 01595 "%s" 01596 "Uniqueid: %s\r\n" 01597 "%s" 01598 "\r\n", 01599 c->name, 01600 S_OR(c->cid.cid_num, "<unknown>"), 01601 S_OR(c->cid.cid_num, "<unknown>"), 01602 S_OR(c->cid.cid_name, "<unknown>"), 01603 c->accountcode, 01604 ast_state2str(c->_state), c->context, 01605 c->exten, c->priority, (long)elapsed_seconds, bridge, c->uniqueid, idText); 01606 } else { 01607 astman_append(s, 01608 "Event: Status\r\n" 01609 "Privilege: Call\r\n" 01610 "Channel: %s\r\n" 01611 "CallerID: %s\r\n" /* This parameter is deprecated and will be removed post-1.4 */ 01612 "CallerIDNum: %s\r\n" 01613 "CallerIDName: %s\r\n" 01614 "Account: %s\r\n" 01615 "State: %s\r\n" 01616 "%s" 01617 "Uniqueid: %s\r\n" 01618 "%s" 01619 "\r\n", 01620 c->name, 01621 S_OR(c->cid.cid_num, "<unknown>"), 01622 S_OR(c->cid.cid_num, "<unknown>"), 01623 S_OR(c->cid.cid_name, "<unknown>"), 01624 c->accountcode, 01625 ast_state2str(c->_state), bridge, c->uniqueid, idText); 01626 } 01627 ast_channel_unlock(c); 01628 if (!all) 01629 break; 01630 c = ast_channel_walk_locked(c); 01631 } 01632 astman_append(s, 01633 "Event: StatusComplete\r\n" 01634 "%s" 01635 "\r\n",idText); 01636 return 0; 01637 }
static int action_timeout | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 2155 of file manager.c.
References ast_channel_setwhentohangup(), ast_channel_unlock, ast_get_channel_by_name_locked(), ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), name, and s.
Referenced by init_manager().
02156 { 02157 struct ast_channel *c = NULL; 02158 const char *name = astman_get_header(m, "Channel"); 02159 int timeout = atoi(astman_get_header(m, "Timeout")); 02160 if (ast_strlen_zero(name)) { 02161 astman_send_error(s, m, "No channel specified"); 02162 return 0; 02163 } 02164 if (!timeout) { 02165 astman_send_error(s, m, "No timeout specified"); 02166 return 0; 02167 } 02168 c = ast_get_channel_by_name_locked(name); 02169 if (!c) { 02170 astman_send_error(s, m, "No such channel"); 02171 return 0; 02172 } 02173 ast_channel_setwhentohangup(c, timeout); 02174 ast_channel_unlock(c); 02175 astman_send_ack(s, m, "Timeout Set"); 02176 return 0; 02177 }
static int action_updateconfig | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 1245 of file manager.c.
References ast_config_destroy(), ast_config_load_with_comments(), ast_module_reload(), ast_strlen_zero(), ast_true(), astman_append(), astman_get_header(), astman_send_error(), config_text_file_save(), handle_updates(), and s.
Referenced by init_manager().
01246 { 01247 struct ast_config *cfg; 01248 const char *sfn = astman_get_header(m, "SrcFilename"); 01249 const char *dfn = astman_get_header(m, "DstFilename"); 01250 int res; 01251 char idText[256] = ""; 01252 const char *id = astman_get_header(m, "ActionID"); 01253 const char *rld = astman_get_header(m, "Reload"); 01254 01255 if (!ast_strlen_zero(id)) 01256 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id); 01257 01258 if (ast_strlen_zero(sfn) || ast_strlen_zero(dfn)) { 01259 astman_send_error(s, m, "Filename not specified"); 01260 return 0; 01261 } 01262 if (!(cfg = ast_config_load_with_comments(sfn))) { 01263 astman_send_error(s, m, "Config file not found"); 01264 return 0; 01265 } 01266 handle_updates(s, m, cfg); 01267 res = config_text_file_save(dfn, cfg, "Manager"); 01268 ast_config_destroy(cfg); 01269 if (res) { 01270 astman_send_error(s, m, "Save of config failed"); 01271 return 0; 01272 } 01273 astman_append(s, "Response: Success\r\n%s\r\n", idText); 01274 if (!ast_strlen_zero(rld)) { 01275 if (ast_true(rld)) 01276 rld = NULL; 01277 ast_module_reload(rld); 01278 } 01279 return 0; 01280 }
static int action_userevent | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 2212 of file manager.c.
References ast_copy_string(), ast_log(), astman_get_header(), message::hdrcount, message::headers, and LOG_WARNING.
Referenced by init_manager().
02213 { 02214 const char *event = astman_get_header(m, "UserEvent"); 02215 char body[2048] = ""; 02216 int x, bodylen = 0, xlen; 02217 for (x = 0; x < m->hdrcount; x++) { 02218 if (strncasecmp("UserEvent:", m->headers[x], strlen("UserEvent:"))) { 02219 if (sizeof(body) < bodylen + (xlen = strlen(m->headers[x])) + 3) { 02220 ast_log(LOG_WARNING, "UserEvent exceeds our buffer length. Truncating.\n"); 02221 break; 02222 } 02223 ast_copy_string(body + bodylen, m->headers[x], sizeof(body) - bodylen - 3); 02224 bodylen += xlen; 02225 ast_copy_string(body + bodylen, "\r\n", 3); 02226 bodylen += 2; 02227 } 02228 } 02229 02230 manager_event(EVENT_FLAG_USER, "UserEvent", "UserEvent: %s\r\n%s", event, body); 02231 return 0; 02232 }
static int action_waitevent | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 1290 of file manager.c.
References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), AST_PTHREADT_NULL, ast_strlen_zero(), ast_wait_for_input(), astman_append(), astman_get_header(), astman_send_response(), eventqent::category, eventqent::eventdata, LOG_DEBUG, option_debug, s, and unuse_eventqent().
Referenced by init_manager().
01291 { 01292 const char *timeouts = astman_get_header(m, "Timeout"); 01293 int timeout = -1, max; 01294 int x; 01295 int needexit = 0; 01296 time_t now; 01297 struct eventqent *eqe; 01298 const char *id = astman_get_header(m,"ActionID"); 01299 char idText[256] = ""; 01300 01301 if (!ast_strlen_zero(id)) 01302 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id); 01303 01304 if (!ast_strlen_zero(timeouts)) { 01305 sscanf(timeouts, "%i", &timeout); 01306 } 01307 01308 ast_mutex_lock(&s->__lock); 01309 if (s->waiting_thread != AST_PTHREADT_NULL) { 01310 pthread_kill(s->waiting_thread, SIGURG); 01311 } 01312 if (s->sessiontimeout) { 01313 time(&now); 01314 max = s->sessiontimeout - now - 10; 01315 if (max < 0) 01316 max = 0; 01317 if ((timeout < 0) || (timeout > max)) 01318 timeout = max; 01319 if (!s->send_events) 01320 s->send_events = -1; 01321 /* Once waitevent is called, always queue events from now on */ 01322 } 01323 ast_mutex_unlock(&s->__lock); 01324 s->waiting_thread = pthread_self(); 01325 if (option_debug) 01326 ast_log(LOG_DEBUG, "Starting waiting for an event!\n"); 01327 for (x=0; ((x < timeout) || (timeout < 0)); x++) { 01328 ast_mutex_lock(&s->__lock); 01329 if (s->eventq && s->eventq->next) 01330 needexit = 1; 01331 if (s->waiting_thread != pthread_self()) 01332 needexit = 1; 01333 if (s->needdestroy) 01334 needexit = 1; 01335 ast_mutex_unlock(&s->__lock); 01336 if (needexit) 01337 break; 01338 if (s->fd > 0) { 01339 if (ast_wait_for_input(s->fd, 1000)) 01340 break; 01341 } else { 01342 sleep(1); 01343 } 01344 } 01345 if (option_debug) 01346 ast_log(LOG_DEBUG, "Finished waiting for an event!\n"); 01347 ast_mutex_lock(&s->__lock); 01348 if (s->waiting_thread == pthread_self()) { 01349 astman_send_response(s, m, "Success", "Waiting for Event..."); 01350 /* Only show events if we're the most recent waiter */ 01351 while(s->eventq->next) { 01352 eqe = s->eventq->next; 01353 if (((s->readperm & eqe->category) == eqe->category) && 01354 ((s->send_events & eqe->category) == eqe->category)) { 01355 astman_append(s, "%s", eqe->eventdata); 01356 } 01357 unuse_eventqent(s->eventq); 01358 s->eventq = eqe; 01359 } 01360 astman_append(s, 01361 "Event: WaitEventComplete\r\n" 01362 "%s" 01363 "\r\n", idText); 01364 s->waiting_thread = AST_PTHREADT_NULL; 01365 } else { 01366 ast_log(LOG_DEBUG, "Abandoning event request!\n"); 01367 } 01368 ast_mutex_unlock(&s->__lock); 01369 return 0; 01370 }
static int append_event | ( | const char * | str, | |
int | category | |||
) | [static] |
Definition at line 2622 of file manager.c.
References ast_malloc, master_eventq, eventqent::next, num_sessions, and eventqent::usecount.
Referenced by init_manager(), and manager_event().
02623 { 02624 struct eventqent *tmp, *prev = NULL; 02625 tmp = ast_malloc(sizeof(*tmp) + strlen(str)); 02626 02627 if (!tmp) 02628 return -1; 02629 02630 tmp->next = NULL; 02631 tmp->category = category; 02632 strcpy(tmp->eventdata, str); 02633 02634 if (master_eventq) { 02635 prev = master_eventq; 02636 while (prev->next) 02637 prev = prev->next; 02638 prev->next = tmp; 02639 } else { 02640 master_eventq = tmp; 02641 } 02642 02643 tmp->usecount = num_sessions; 02644 02645 return 0; 02646 }
static struct ast_manager_user* ast_get_manager_by_name_locked | ( | const char * | name | ) | [static] |
Definition at line 487 of file manager.c.
References AST_LIST_TRAVERSE, mansession::list, and ast_manager_user::username.
Referenced by handle_showmanager(), and init_manager().
00488 { 00489 struct ast_manager_user *user = NULL; 00490 00491 AST_LIST_TRAVERSE(&users, user, list) 00492 if (!strcasecmp(user->username, name)) 00493 break; 00494 return user; 00495 }
static int ast_instring | ( | const char * | bigstr, | |
const char * | smallstr, | |||
char | delim | |||
) | [static] |
Tells you if smallstr exists inside bigstr which is delim by delim and uses no buf or stringsep ast_instring("this|that|more","this",',') == 1;
feel free to move this to app.c -anthm
Definition at line 878 of file manager.c.
References ast_variable::next.
Referenced by get_perm(), and strings_to_mask().
00879 { 00880 const char *val = bigstr, *next; 00881 00882 do { 00883 if ((next = strchr(val, delim))) { 00884 if (!strncmp(val, smallstr, (next - val))) 00885 return 1; 00886 else 00887 continue; 00888 } else 00889 return !strcmp(smallstr, val); 00890 00891 } while (*(val = (next + 1))); 00892 00893 return 0; 00894 }
static int ast_is_number | ( | const char * | string | ) | [static] |
Definition at line 911 of file manager.c.
Referenced by strings_to_mask().
00912 { 00913 int ret = 1, x = 0; 00914 00915 if (!string) 00916 return 0; 00917 00918 for (x = 0; x < strlen(string); x++) { 00919 if (!(string[x] >= 48 && string[x] <= 57)) { 00920 ret = 0; 00921 break; 00922 } 00923 } 00924 00925 return ret ? atoi(string) : 0; 00926 }
int ast_manager_register2 | ( | const char * | action, | |
int | authority, | |||
int(*)(struct mansession *s, const struct message *m) | func, | |||
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
action | Name of the requested Action: | |
authority | Required authority for this command | |
func | Function to call for this command | |
synopsis | Help text (one line, up to 30 chars) for CLI manager show commands | |
description | Help text, several lines |
Definition at line 2775 of file manager.c.
References ast_malloc, and ast_manager_register_struct().
Referenced by init_manager(), and load_module().
02776 { 02777 struct manager_action *cur; 02778 02779 cur = ast_malloc(sizeof(*cur)); 02780 if (!cur) 02781 return -1; 02782 02783 cur->action = action; 02784 cur->authority = auth; 02785 cur->func = func; 02786 cur->synopsis = synopsis; 02787 cur->description = description; 02788 cur->next = NULL; 02789 02790 ast_manager_register_struct(cur); 02791 02792 return 0; 02793 }
static int ast_manager_register_struct | ( | struct manager_action * | act | ) | [static] |
Definition at line 2731 of file manager.c.
References manager_action::action, actionlock, ast_log(), ast_rwlock_unlock(), ast_rwlock_wrlock(), ast_verbose(), first_action, LOG_WARNING, manager_action::next, option_verbose, and VERBOSE_PREFIX_2.
Referenced by ast_manager_register2().
02732 { 02733 struct manager_action *cur, *prev = NULL; 02734 int ret; 02735 02736 ast_rwlock_wrlock(&actionlock); 02737 cur = first_action; 02738 while (cur) { /* Walk the list of actions */ 02739 ret = strcasecmp(cur->action, act->action); 02740 if (ret == 0) { 02741 ast_log(LOG_WARNING, "Manager: Action '%s' already registered\n", act->action); 02742 ast_rwlock_unlock(&actionlock); 02743 return -1; 02744 } else if (ret > 0) { 02745 /* Insert these alphabetically */ 02746 if (prev) { 02747 act->next = prev->next; 02748 prev->next = act; 02749 } else { 02750 act->next = first_action; 02751 first_action = act; 02752 } 02753 break; 02754 } 02755 prev = cur; 02756 cur = cur->next; 02757 } 02758 02759 if (!cur) { 02760 if (prev) 02761 prev->next = act; 02762 else 02763 first_action = act; 02764 act->next = NULL; 02765 } 02766 02767 if (option_verbose > 1) 02768 ast_verbose(VERBOSE_PREFIX_2 "Manager registered action %s\n", act->action); 02769 ast_rwlock_unlock(&actionlock); 02770 return 0; 02771 }
int ast_manager_unregister | ( | char * | action | ) |
action | Name of registered Action: |
Definition at line 2702 of file manager.c.
References manager_action::action, actionlock, ast_rwlock_unlock(), ast_rwlock_wrlock(), ast_verbose(), first_action, free, manager_action::next, option_verbose, and VERBOSE_PREFIX_2.
Referenced by __unload_module(), and unload_module().
02703 { 02704 struct manager_action *cur, *prev; 02705 02706 ast_rwlock_wrlock(&actionlock); 02707 cur = prev = first_action; 02708 while (cur) { 02709 if (!strcasecmp(action, cur->action)) { 02710 prev->next = cur->next; 02711 free(cur); 02712 if (option_verbose > 1) 02713 ast_verbose(VERBOSE_PREFIX_2 "Manager unregistered action %s\n", action); 02714 ast_rwlock_unlock(&actionlock); 02715 return 0; 02716 } 02717 prev = cur; 02718 cur = cur->next; 02719 } 02720 ast_rwlock_unlock(&actionlock); 02721 return 0; 02722 }
void astman_append | ( | struct mansession * | s, | |
const char * | fmt, | |||
... | ||||
) |
Definition at line 497 of file manager.c.
References ast_calloc, ast_carefulwrite(), ast_dynamic_str_append(), ast_dynamic_str_thread_get(), ast_dynamic_str_thread_set_va, ast_mutex_lock(), ast_mutex_unlock(), astman_append_buf, ASTMAN_APPEND_BUF_INITSIZE, s, and ast_dynamic_str::str.
Referenced by __action_showchannels(), __iax2_show_peers(), __queues_show(), _sip_show_peer(), _sip_show_peers(), action_agents(), action_command(), action_coresettings(), action_corestatus(), action_extensionstate(), action_getconfig(), action_getvar(), action_listcommands(), action_mailboxcount(), action_mailboxstatus(), action_status(), action_updateconfig(), action_waitevent(), ast_cli_netstats(), astman_send_error(), astman_send_response(), manager_dbget(), manager_iax2_show_netstats(), manager_iax2_show_peers(), manager_jabber_send(), manager_parking_status(), manager_queues_show(), manager_queues_status(), manager_sip_show_peer(), manager_sip_show_peers(), process_message(), and session_do().
00498 { 00499 va_list ap; 00500 struct ast_dynamic_str *buf; 00501 00502 ast_mutex_lock(&s->__lock); 00503 00504 if (!(buf = ast_dynamic_str_thread_get(&astman_append_buf, ASTMAN_APPEND_BUF_INITSIZE))) { 00505 ast_mutex_unlock(&s->__lock); 00506 return; 00507 } 00508 00509 va_start(ap, fmt); 00510 ast_dynamic_str_thread_set_va(&buf, 0, &astman_append_buf, fmt, ap); 00511 va_end(ap); 00512 00513 if (s->fd > -1) 00514 ast_carefulwrite(s->fd, buf->str, strlen(buf->str), s->writetimeout); 00515 else { 00516 if (!s->outputstr && !(s->outputstr = ast_calloc(1, sizeof(*s->outputstr)))) { 00517 ast_mutex_unlock(&s->__lock); 00518 return; 00519 } 00520 00521 ast_dynamic_str_append(&s->outputstr, 0, "%s", buf->str); 00522 } 00523 00524 ast_mutex_unlock(&s->__lock); 00525 }
static void astman_append_buf_init | ( | void | ) | [static] |
const char* astman_get_header | ( | const struct message * | m, | |
char * | var | |||
) |
Get header from mananger transaction
Definition at line 781 of file manager.c.
References message::hdrcount, and message::headers.
Referenced by __action_dialoffhook(), __action_showchannels(), _sip_show_peer(), _sip_show_peers(), action_agent_callback_login(), action_agent_logoff(), action_agents(), action_atxfer(), action_command(), action_coresettings(), action_corestatus(), action_events(), action_extensionstate(), action_getconfig(), action_getvar(), action_hangup(), action_listcommands(), action_mailboxcount(), action_mailboxstatus(), action_originate(), action_redirect(), action_setcdruserfield(), action_setvar(), action_status(), action_timeout(), action_updateconfig(), action_userevent(), action_waitevent(), astman_send_error(), astman_send_response(), authenticate(), change_monitor_action(), do_pause_or_unpause(), handle_updates(), manager_add_queue_member(), manager_dbget(), manager_dbput(), manager_iax2_show_peers(), manager_jabber_send(), manager_park(), manager_parking_status(), manager_pause_queue_member(), manager_play_dtmf(), manager_queues_status(), manager_remove_queue_member(), manager_sip_show_peer(), manager_sip_show_peers(), meetmemute(), process_message(), start_monitor_action(), and stop_monitor_action().
00782 { 00783 char cmp[80]; 00784 int x; 00785 00786 snprintf(cmp, sizeof(cmp), "%s: ", var); 00787 00788 for (x = 0; x < m->hdrcount; x++) { 00789 if (!strncasecmp(cmp, m->headers[x], strlen(cmp))) 00790 return m->headers[x] + strlen(cmp); 00791 } 00792 00793 return ""; 00794 }
struct ast_variable* astman_get_variables | ( | const struct message * | m | ) |
Get a linked list of the Variable: headers
Definition at line 796 of file manager.c.
References AST_APP_ARG, AST_DECLARE_APP_ARGS, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_variable_new(), message::hdrcount, message::headers, parse(), and var.
Referenced by action_originate().
00797 { 00798 int varlen, x, y; 00799 struct ast_variable *head = NULL, *cur; 00800 char *var, *val; 00801 00802 char *parse; 00803 AST_DECLARE_APP_ARGS(args, 00804 AST_APP_ARG(vars)[32]; 00805 ); 00806 00807 varlen = strlen("Variable: "); 00808 00809 for (x = 0; x < m->hdrcount; x++) { 00810 if (strncasecmp("Variable: ", m->headers[x], varlen)) 00811 continue; 00812 00813 parse = ast_strdupa(m->headers[x] + varlen); 00814 00815 AST_STANDARD_APP_ARGS(args, parse); 00816 if (args.argc) { 00817 for (y = 0; y < args.argc; y++) { 00818 if (!args.vars[y]) 00819 continue; 00820 var = val = ast_strdupa(args.vars[y]); 00821 strsep(&val, "="); 00822 if (!val || ast_strlen_zero(var)) 00823 continue; 00824 cur = ast_variable_new(var, val); 00825 if (head) { 00826 cur->next = head; 00827 head = cur; 00828 } else 00829 head = cur; 00830 } 00831 } 00832 } 00833 00834 return head; 00835 }
void astman_send_ack | ( | struct mansession * | s, | |
const struct message * | m, | |||
char * | msg | |||
) |
Definition at line 868 of file manager.c.
References astman_send_response(), and s.
Referenced by action_agent_callback_login(), action_agent_logoff(), action_agents(), action_atxfer(), action_hangup(), action_originate(), action_redirect(), action_setcdruserfield(), action_setvar(), action_status(), action_timeout(), change_monitor_action(), do_pause_or_unpause(), manager_add_queue_member(), manager_dbget(), manager_dbput(), manager_jabber_send(), manager_park(), manager_parking_status(), manager_pause_queue_member(), manager_play_dtmf(), manager_queues_status(), manager_remove_queue_member(), manager_sip_show_peers(), meetmemute(), process_message(), start_monitor_action(), and stop_monitor_action().
00869 { 00870 astman_send_response(s, m, "Success", msg); 00871 }
void astman_send_error | ( | struct mansession * | s, | |
const struct message * | m, | |||
char * | error | |||
) |
Definition at line 845 of file manager.c.
References ast_strlen_zero(), astman_append(), astman_get_header(), and s.
Referenced by __action_dialoffhook(), __action_dnd(), __action_restart(), __action_transfer(), __action_transferhangup(), _sip_show_peer(), action_agent_callback_login(), action_agent_logoff(), action_atxfer(), action_command(), action_extensionstate(), action_getconfig(), action_getvar(), action_hangup(), action_mailboxcount(), action_mailboxstatus(), action_originate(), action_redirect(), action_setcdruserfield(), action_setvar(), action_status(), action_timeout(), action_updateconfig(), change_monitor_action(), do_pause_or_unpause(), manager_add_queue_member(), manager_dbget(), manager_dbput(), manager_jabber_send(), manager_park(), manager_pause_queue_member(), manager_play_dtmf(), manager_remove_queue_member(), manager_sip_show_peer(), meetmemute(), process_message(), start_monitor_action(), and stop_monitor_action().
00846 { 00847 const char *id = astman_get_header(m,"ActionID"); 00848 00849 astman_append(s, "Response: Error\r\n"); 00850 if (!ast_strlen_zero(id)) 00851 astman_append(s, "ActionID: %s\r\n", id); 00852 astman_append(s, "Message: %s\r\n\r\n", error); 00853 }
void astman_send_response | ( | struct mansession * | s, | |
const struct message * | m, | |||
char * | resp, | |||
char * | msg | |||
) |
Definition at line 855 of file manager.c.
References ast_strlen_zero(), astman_append(), astman_get_header(), and s.
Referenced by action_events(), action_logoff(), action_ping(), action_waitevent(), and astman_send_ack().
00856 { 00857 const char *id = astman_get_header(m,"ActionID"); 00858 00859 astman_append(s, "Response: %s\r\n", resp); 00860 if (!ast_strlen_zero(id)) 00861 astman_append(s, "ActionID: %s\r\n", id); 00862 if (msg) 00863 astman_append(s, "Message: %s\r\n\r\n", msg); 00864 else 00865 astman_append(s, "\r\n"); 00866 }
static int authenticate | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 971 of file manager.c.
References ast_append_ha(), ast_apply_ha(), ast_category_browse(), ast_config_AST_SYSTEM_NAME, ast_config_destroy(), ast_config_load(), ast_free_ha(), ast_inet_ntoa(), ast_log(), ast_strlen_zero(), ast_true(), ast_variable_browse(), astman_get_header(), events, len(), LOG_DEBUG, LOG_ERROR, LOG_NOTICE, LOG_WARNING, md5(), MD5Final(), MD5Init(), MD5Update(), ast_variable::name, ast_variable::next, password, s, S_OR, and ast_variable::value.
Referenced by authenticate_reply(), handle_response_invite(), process_message(), and registry_rerequest().
00972 { 00973 struct ast_config *cfg; 00974 char *cat; 00975 const char *user = astman_get_header(m, "Username"); 00976 const char *pass = astman_get_header(m, "Secret"); 00977 const char *authtype = astman_get_header(m, "AuthType"); 00978 const char *key = astman_get_header(m, "Key"); 00979 const char *events = astman_get_header(m, "Events"); 00980 00981 cfg = ast_config_load("manager.conf"); 00982 if (!cfg) 00983 return -1; 00984 cat = ast_category_browse(cfg, NULL); 00985 while (cat) { 00986 if (strcasecmp(cat, "general")) { 00987 /* This is a user */ 00988 if (!strcasecmp(cat, user)) { 00989 struct ast_variable *v; 00990 struct ast_ha *ha = NULL; 00991 char *password = NULL; 00992 00993 for (v = ast_variable_browse(cfg, cat); v; v = v->next) { 00994 if (!strcasecmp(v->name, "secret")) { 00995 password = v->value; 00996 } else if (!strcasecmp(v->name, "displaysystemname")) { 00997 if (ast_true(v->value)) { 00998 if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME)) { 00999 s->displaysystemname = 1; 01000 } else { 01001 ast_log(LOG_ERROR, "Can't enable displaysystemname in manager.conf - no system name configured in asterisk.conf\n"); 01002 } 01003 } 01004 } else if (!strcasecmp(v->name, "permit") || 01005 !strcasecmp(v->name, "deny")) { 01006 ha = ast_append_ha(v->name, v->value, ha); 01007 } else if (!strcasecmp(v->name, "writetimeout")) { 01008 int val = atoi(v->value); 01009 01010 if (val < 100) 01011 ast_log(LOG_WARNING, "Invalid writetimeout value '%s' at line %d\n", v->value, v->lineno); 01012 else 01013 s->writetimeout = val; 01014 } 01015 01016 } 01017 if (ha && !ast_apply_ha(ha, &(s->sin))) { 01018 ast_log(LOG_NOTICE, "%s failed to pass IP ACL as '%s'\n", ast_inet_ntoa(s->sin.sin_addr), user); 01019 ast_free_ha(ha); 01020 ast_config_destroy(cfg); 01021 return -1; 01022 } else if (ha) 01023 ast_free_ha(ha); 01024 if (!strcasecmp(authtype, "MD5")) { 01025 if (!ast_strlen_zero(key) && 01026 !ast_strlen_zero(s->challenge) && !ast_strlen_zero(password)) { 01027 int x; 01028 int len = 0; 01029 char md5key[256] = ""; 01030 struct MD5Context md5; 01031 unsigned char digest[16]; 01032 MD5Init(&md5); 01033 MD5Update(&md5, (unsigned char *) s->challenge, strlen(s->challenge)); 01034 MD5Update(&md5, (unsigned char *) password, strlen(password)); 01035 MD5Final(digest, &md5); 01036 for (x=0; x<16; x++) 01037 len += sprintf(md5key + len, "%2.2x", digest[x]); 01038 if (!strcmp(md5key, key)) 01039 break; 01040 else { 01041 ast_config_destroy(cfg); 01042 return -1; 01043 } 01044 } else { 01045 ast_log(LOG_DEBUG, "MD5 authentication is not possible. challenge: '%s'\n", 01046 S_OR(s->challenge, "")); 01047 ast_config_destroy(cfg); 01048 return -1; 01049 } 01050 } else if (password && !strcmp(password, pass)) { 01051 break; 01052 } else { 01053 ast_log(LOG_NOTICE, "%s failed to authenticate as '%s'\n", ast_inet_ntoa(s->sin.sin_addr), user); 01054 ast_config_destroy(cfg); 01055 return -1; 01056 } 01057 } 01058 } 01059 cat = ast_category_browse(cfg, cat); 01060 } 01061 if (cat) { 01062 ast_copy_string(s->username, cat, sizeof(s->username)); 01063 s->readperm = get_perm(ast_variable_retrieve(cfg, cat, "read")); 01064 s->writeperm = get_perm(ast_variable_retrieve(cfg, cat, "write")); 01065 ast_config_destroy(cfg); 01066 if (events) 01067 set_eventmask(s, events); 01068 return 0; 01069 } 01070 ast_config_destroy(cfg); 01071 cfg = ast_config_load("users.conf"); 01072 if (!cfg) 01073 return -1; 01074 cat = ast_category_browse(cfg, NULL); 01075 while (cat) { 01076 struct ast_variable *v; 01077 const char *password = NULL; 01078 int hasmanager = 0; 01079 const char *readperms = NULL; 01080 const char *writeperms = NULL; 01081 01082 if (strcasecmp(cat, user) || !strcasecmp(cat, "general")) { 01083 cat = ast_category_browse(cfg, cat); 01084 continue; 01085 } 01086 for (v = ast_variable_browse(cfg, cat); v; v = v->next) { 01087 if (!strcasecmp(v->name, "secret")) 01088 password = v->value; 01089 else if (!strcasecmp(v->name, "hasmanager")) 01090 hasmanager = ast_true(v->value); 01091 else if (!strcasecmp(v->name, "managerread")) 01092 readperms = v->value; 01093 else if (!strcasecmp(v->name, "managerwrite")) 01094 writeperms = v->value; 01095 } 01096 if (!hasmanager) 01097 break; 01098 if (!password || strcmp(password, pass)) { 01099 ast_log(LOG_NOTICE, "%s failed to authenticate as '%s'\n", ast_inet_ntoa(s->sin.sin_addr), user); 01100 ast_config_destroy(cfg); 01101 return -1; 01102 } 01103 ast_copy_string(s->username, cat, sizeof(s->username)); 01104 s->readperm = readperms ? get_perm(readperms) : -1; 01105 s->writeperm = writeperms ? get_perm(writeperms) : -1; 01106 ast_config_destroy(cfg); 01107 if (events) 01108 set_eventmask(s, events); 01109 return 0; 01110 } 01111 ast_log(LOG_NOTICE, "%s tried to authenticate with nonexistent user '%s'\n", ast_inet_ntoa(s->sin.sin_addr), user); 01112 ast_config_destroy(cfg); 01113 return -1; 01114 }
static char* authority_to_str | ( | int | authority, | |
char * | res, | |||
int | reslen | |||
) | [static] |
Convert authority code to string with serveral options.
Definition at line 221 of file manager.c.
References ast_copy_string(), ast_strlen_zero(), and perms.
Referenced by action_listcommands(), handle_showmancmd(), handle_showmancmds(), and manager_event().
00222 { 00223 int running_total = 0, i; 00224 00225 memset(res, 0, reslen); 00226 for (i = 0; i < (sizeof(perms) / sizeof(perms[0])) - 1; i++) { 00227 if (authority & perms[i].num) { 00228 if (*res) { 00229 strncat(res, ",", (reslen > running_total) ? reslen - running_total - 1 : 0); 00230 running_total++; 00231 } 00232 strncat(res, perms[i].label, (reslen > running_total) ? reslen - running_total - 1 : 0); 00233 running_total += strlen(perms[i].label); 00234 } 00235 } 00236 00237 if (ast_strlen_zero(res)) 00238 ast_copy_string(res, "<none>", reslen); 00239 00240 return res; 00241 }
static int check_blacklist | ( | const char * | cmd | ) | [static] |
Definition at line 1725 of file manager.c.
References ARRAY_LEN, ast_strdupa, ast_strip(), ast_strlen_zero(), command_blacklist, match(), MAX_BLACKLIST_CMD_LEN, and words.
Referenced by action_command().
01726 { 01727 char *cmd_copy, *cur_cmd; 01728 char *cmd_words[MAX_BLACKLIST_CMD_LEN] = { NULL, }; 01729 int i; 01730 01731 cmd_copy = ast_strdupa(cmd); 01732 for (i = 0; i < MAX_BLACKLIST_CMD_LEN && (cur_cmd = strsep(&cmd_copy, " ")); i++) { 01733 cur_cmd = ast_strip(cur_cmd); 01734 if (ast_strlen_zero(cur_cmd)) { 01735 i--; 01736 continue; 01737 } 01738 01739 cmd_words[i] = cur_cmd; 01740 } 01741 01742 for (i = 0; i < ARRAY_LEN(command_blacklist); i++) { 01743 int j, match = 1; 01744 01745 for (j = 0; command_blacklist[i].words[j]; j++) { 01746 if (ast_strlen_zero(cmd_words[j]) || strcasecmp(cmd_words[j], command_blacklist[i].words[j])) { 01747 match = 0; 01748 break; 01749 } 01750 } 01751 01752 if (match) { 01753 return 1; 01754 } 01755 } 01756 01757 return 0; 01758 }
int check_manager_enabled | ( | void | ) |
Check if AMI is enabled.
Definition at line 210 of file manager.c.
Referenced by handle_show_settings().
00211 { 00212 return manager_enabled; 00213 }
int check_webmanager_enabled | ( | void | ) |
Check if AMI/HTTP is enabled.
Definition at line 215 of file manager.c.
Referenced by action_coresettings(), and handle_show_settings().
00216 { 00217 return (webmanager_enabled && manager_enabled); 00218 }
static char* complete_show_mancmd | ( | const char * | line, | |
const char * | word, | |||
int | pos, | |||
int | state | |||
) | [static] |
Definition at line 243 of file manager.c.
References manager_action::action, actionlock, ast_rwlock_rdlock(), ast_rwlock_unlock(), ast_strdup, first_action, and manager_action::next.
00244 { 00245 struct manager_action *cur; 00246 int which = 0; 00247 char *ret = NULL; 00248 00249 ast_rwlock_rdlock(&actionlock); 00250 for (cur = first_action; cur; cur = cur->next) { /* Walk the list of actions */ 00251 if (!strncasecmp(word, cur->action, strlen(word)) && ++which > state) { 00252 ret = ast_strdup(cur->action); 00253 break; /* make sure we exit even if ast_strdup() returns NULL */ 00254 } 00255 } 00256 ast_rwlock_unlock(&actionlock); 00257 00258 return ret; 00259 }
static int compress_char | ( | char | c | ) | [static] |
Definition at line 303 of file manager.c.
Referenced by member_hash_fn(), and variable_count_hash_fn().
00304 { 00305 c &= 0x7f; 00306 if (c < 32) 00307 return 0; 00308 else if (c >= 'a' && c <= 'z') 00309 return c - 64; 00310 else if (c > 'z') 00311 return '_'; 00312 else 00313 return c - 32; 00314 }
static void destroy_session | ( | struct mansession * | s | ) | [static] |
Definition at line 772 of file manager.c.
References AST_LIST_LOCK, AST_LIST_REMOVE, AST_LIST_UNLOCK, free_session(), mansession::list, and s.
Referenced by accept_thread(), and skinny_session().
00773 { 00774 AST_LIST_LOCK(&sessions); 00775 AST_LIST_REMOVE(&sessions, s, list); 00776 num_sessions--; 00777 free_session(s); 00778 AST_LIST_UNLOCK(&sessions); 00779 }
static int do_message | ( | struct mansession * | s | ) | [static] |
Definition at line 2455 of file manager.c.
References AST_MAX_MANHEADERS, ast_strdupa, ast_strlen_zero(), get_input(), message::hdrcount, message::headers, process_events(), process_message(), and s.
Referenced by session_do().
02456 { 02457 struct message m = { 0 }; 02458 char header_buf[sizeof(s->inbuf)] = { '\0' }; 02459 int res; 02460 02461 for (;;) { 02462 /* Check if any events are pending and do them if needed */ 02463 if (s->eventq->next) { 02464 if (process_events(s)) 02465 return -1; 02466 } 02467 res = get_input(s, header_buf); 02468 if (res == 0) { 02469 continue; 02470 } else if (res > 0) { 02471 /* Strip trailing \r\n */ 02472 if (strlen(header_buf) < 2) 02473 continue; 02474 header_buf[strlen(header_buf) - 2] = '\0'; 02475 if (ast_strlen_zero(header_buf)) 02476 return process_message(s, &m) ? -1 : 0; 02477 else if (m.hdrcount < (AST_MAX_MANHEADERS - 1)) 02478 m.headers[m.hdrcount++] = ast_strdupa(header_buf); 02479 } else { 02480 return res; 02481 } 02482 } 02483 }
static void* fast_originate | ( | void * | data | ) | [static] |
Definition at line 1860 of file manager.c.
References fast_originate_helper::account, fast_originate_helper::app, fast_originate_helper::appdata, AST_CHANNEL_NAME, ast_channel_unlock, ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), ast_strlen_zero(), fast_originate_helper::cid_name, fast_originate_helper::cid_num, fast_originate_helper::context, fast_originate_helper::data, EVENT_FLAG_CALL, fast_originate_helper::exten, fast_originate_helper::format, free, fast_originate_helper::idtext, manager_event(), ast_channel::name, fast_originate_helper::priority, S_OR, fast_originate_helper::tech, fast_originate_helper::timeout, ast_channel::uniqueid, and fast_originate_helper::vars.
Referenced by action_originate().
01861 { 01862 struct fast_originate_helper *in = data; 01863 int res; 01864 int reason = 0; 01865 struct ast_channel *chan = NULL; 01866 char requested_channel[AST_CHANNEL_NAME]; 01867 01868 if (!ast_strlen_zero(in->app)) { 01869 res = ast_pbx_outgoing_app(in->tech, in->format, in->data, in->timeout, in->app, in->appdata, &reason, 1, 01870 S_OR(in->cid_num, NULL), 01871 S_OR(in->cid_name, NULL), 01872 in->vars, in->account, &chan); 01873 } else { 01874 res = ast_pbx_outgoing_exten(in->tech, in->format, in->data, in->timeout, in->context, in->exten, in->priority, &reason, 1, 01875 S_OR(in->cid_num, NULL), 01876 S_OR(in->cid_name, NULL), 01877 in->vars, in->account, &chan); 01878 } 01879 01880 if (!chan) 01881 snprintf(requested_channel, AST_CHANNEL_NAME, "%s/%s", in->tech, in->data); 01882 /* Tell the manager what happened with the channel */ 01883 manager_event(EVENT_FLAG_CALL, "OriginateResponse", 01884 "%s" 01885 "Response: %s\r\n" 01886 "Channel: %s\r\n" 01887 "Context: %s\r\n" 01888 "Exten: %s\r\n" 01889 "Reason: %d\r\n" 01890 "Uniqueid: %s\r\n" 01891 "CallerID: %s\r\n" /* This parameter is deprecated and will be removed post-1.4 */ 01892 "CallerIDNum: %s\r\n" 01893 "CallerIDName: %s\r\n", 01894 in->idtext, res ? "Failure" : "Success", chan ? chan->name : requested_channel, in->context, in->exten, reason, 01895 chan ? chan->uniqueid : "<null>", 01896 S_OR(in->cid_num, "<unknown>"), 01897 S_OR(in->cid_num, "<unknown>"), 01898 S_OR(in->cid_name, "<unknown>") 01899 ); 01900 01901 /* Locked by ast_pbx_outgoing_exten or ast_pbx_outgoing_app */ 01902 if (chan) 01903 ast_channel_unlock(chan); 01904 free(in); 01905 return NULL; 01906 }
static void free_session | ( | struct mansession * | s | ) | [static] |
Definition at line 756 of file manager.c.
References ast_mutex_destroy(), free, s, and unuse_eventqent().
Referenced by accept_thread(), and destroy_session().
00757 { 00758 struct eventqent *eqe; 00759 if (s->fd > -1) 00760 close(s->fd); 00761 if (s->outputstr) 00762 free(s->outputstr); 00763 ast_mutex_destroy(&s->__lock); 00764 while (s->eventq) { 00765 eqe = s->eventq; 00766 s->eventq = s->eventq->next; 00767 unuse_eventqent(eqe); 00768 } 00769 free(s); 00770 }
static int get_input | ( | struct mansession * | s, | |
char * | output | |||
) | [static] |
Definition at line 2396 of file manager.c.
References ast_channel::fds, and s.
Referenced by do_message(), and skinny_session().
02397 { 02398 /* output must have at least sizeof(s->inbuf) space */ 02399 int res; 02400 int x; 02401 struct pollfd fds[1]; 02402 for (x = 1; x < s->inlen; x++) { 02403 if ((s->inbuf[x] == '\n') && (s->inbuf[x-1] == '\r')) { 02404 /* Copy output data up to and including \r\n */ 02405 memcpy(output, s->inbuf, x + 1); 02406 /* Add trailing \0 */ 02407 output[x+1] = '\0'; 02408 /* Move remaining data back to the front */ 02409 memmove(s->inbuf, s->inbuf + x + 1, s->inlen - x); 02410 s->inlen -= (x + 1); 02411 return 1; 02412 } 02413 } 02414 if (s->inlen >= sizeof(s->inbuf) - 1) { 02415 ast_log(LOG_WARNING, "Dumping long line with no return from %s: %s\n", ast_inet_ntoa(s->sin.sin_addr), s->inbuf); 02416 s->inlen = 0; 02417 } 02418 fds[0].fd = s->fd; 02419 fds[0].events = POLLIN; 02420 do { 02421 ast_mutex_lock(&s->__lock); 02422 if (s->pending_event) { 02423 s->pending_event = 0; 02424 ast_mutex_unlock(&s->__lock); 02425 return 0; 02426 } 02427 s->waiting_thread = pthread_self(); 02428 ast_mutex_unlock(&s->__lock); 02429 02430 res = poll(fds, 1, -1); 02431 02432 ast_mutex_lock(&s->__lock); 02433 s->waiting_thread = AST_PTHREADT_NULL; 02434 ast_mutex_unlock(&s->__lock); 02435 if (res < 0) { 02436 if (errno == EINTR || errno == EAGAIN) { 02437 return 0; 02438 } 02439 ast_log(LOG_WARNING, "Select returned error: %s\n", strerror(errno)); 02440 return -1; 02441 } else if (res > 0) { 02442 ast_mutex_lock(&s->__lock); 02443 res = read(s->fd, s->inbuf + s->inlen, sizeof(s->inbuf) - 1 - s->inlen); 02444 ast_mutex_unlock(&s->__lock); 02445 if (res < 1) 02446 return -1; 02447 break; 02448 } 02449 } while(1); 02450 s->inlen += res; 02451 s->inbuf[s->inlen] = '\0'; 02452 return 0; 02453 }
static int get_perm | ( | const char * | instr | ) | [static] |
Definition at line 896 of file manager.c.
References ast_instring(), and perms.
00897 { 00898 int x = 0, ret = 0; 00899 00900 if (!instr) 00901 return 0; 00902 00903 for (x = 0; x < (sizeof(perms) / sizeof(perms[0])); x++) { 00904 if (ast_instring(instr, perms[x].label, ',')) 00905 ret |= perms[x].num; 00906 } 00907 00908 return ret; 00909 }
static int handle_showmanager | ( | int | fd, | |
int | argc, | |||
char * | argv[] | |||
) | [static] |
Definition at line 549 of file manager.c.
References ast_cli(), ast_get_manager_by_name_locked(), AST_LIST_LOCK, AST_LIST_UNLOCK, ast_manager_user::deny, ast_manager_user::displayconnects, ast_manager_user::permit, ast_manager_user::read, RESULT_SHOWUSAGE, RESULT_SUCCESS, ast_manager_user::secret, ast_manager_user::username, and ast_manager_user::write.
00550 { 00551 struct ast_manager_user *user = NULL; 00552 00553 if (argc != 4) 00554 return RESULT_SHOWUSAGE; 00555 00556 AST_LIST_LOCK(&users); 00557 00558 if (!(user = ast_get_manager_by_name_locked(argv[3]))) { 00559 ast_cli(fd, "There is no manager called %s\n", argv[3]); 00560 AST_LIST_UNLOCK(&users); 00561 return -1; 00562 } 00563 00564 ast_cli(fd,"\n"); 00565 ast_cli(fd, 00566 " username: %s\n" 00567 " secret: %s\n" 00568 " deny: %s\n" 00569 " permit: %s\n" 00570 " read: %s\n" 00571 " write: %s\n" 00572 "displayconnects: %s\n", 00573 (user->username ? user->username : "(N/A)"), 00574 (user->secret ? "<Set>" : "(N/A)"), 00575 (user->deny ? user->deny : "(N/A)"), 00576 (user->permit ? user->permit : "(N/A)"), 00577 (user->read ? user->read : "(N/A)"), 00578 (user->write ? user->write : "(N/A)"), 00579 (user->displayconnects ? "yes" : "no")); 00580 00581 AST_LIST_UNLOCK(&users); 00582 00583 return RESULT_SUCCESS; 00584 }
static int handle_showmanagers | ( | int | fd, | |
int | argc, | |||
char * | argv[] | |||
) | [static] |
Definition at line 587 of file manager.c.
References ast_cli(), AST_LIST_EMPTY, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, mansession::list, RESULT_SHOWUSAGE, RESULT_SUCCESS, and ast_manager_user::username.
00588 { 00589 struct ast_manager_user *user = NULL; 00590 int count_amu = 0; 00591 00592 if (argc != 3) 00593 return RESULT_SHOWUSAGE; 00594 00595 AST_LIST_LOCK(&users); 00596 00597 /* If there are no users, print out something along those lines */ 00598 if (AST_LIST_EMPTY(&users)) { 00599 ast_cli(fd, "There are no manager users.\n"); 00600 AST_LIST_UNLOCK(&users); 00601 return RESULT_SUCCESS; 00602 } 00603 00604 ast_cli(fd, "\nusername\n--------\n"); 00605 00606 AST_LIST_TRAVERSE(&users, user, list) { 00607 ast_cli(fd, "%s\n", user->username); 00608 count_amu++; 00609 } 00610 00611 AST_LIST_UNLOCK(&users); 00612 00613 ast_cli(fd,"-------------------\n"); 00614 ast_cli(fd,"%d manager users configured.\n", count_amu); 00615 00616 return RESULT_SUCCESS; 00617 }
static int handle_showmancmd | ( | int | fd, | |
int | argc, | |||
char * | argv[] | |||
) | [static] |
Definition at line 527 of file manager.c.
References manager_action::action, actionlock, ast_cli(), ast_rwlock_rdlock(), manager_action::authority, authority_to_str(), manager_action::description, first_action, manager_action::next, RESULT_SHOWUSAGE, and manager_action::synopsis.
00528 { 00529 struct manager_action *cur; 00530 char authority[80]; 00531 int num; 00532 00533 if (argc != 4) 00534 return RESULT_SHOWUSAGE; 00535 00536 ast_rwlock_rdlock(&actionlock); 00537 for (cur = first_action; cur; cur = cur->next) { /* Walk the list of actions */ 00538 for (num = 3; num < argc; num++) { 00539 if (!strcasecmp(cur->action, argv[num])) { 00540 ast_cli(fd, "Action: %s\nSynopsis: %s\nPrivilege: %s\n%s\n", cur->action, cur->synopsis, authority_to_str(cur->authority, authority, sizeof(authority) -1), cur->description ? cur->description : ""); 00541 } 00542 } 00543 } 00544 ast_rwlock_unlock(&actionlock); 00545 00546 return RESULT_SUCCESS; 00547 }
static int handle_showmancmds | ( | int | fd, | |
int | argc, | |||
char * | argv[] | |||
) | [static] |
CLI command Should change to "manager show commands".
Definition at line 622 of file manager.c.
References manager_action::action, actionlock, ast_cli(), ast_rwlock_rdlock(), ast_rwlock_unlock(), manager_action::authority, authority_to_str(), first_action, format, manager_action::next, RESULT_SUCCESS, and manager_action::synopsis.
00623 { 00624 struct manager_action *cur; 00625 char authority[80]; 00626 char *format = " %-15.15s %-15.15s %-55.55s\n"; 00627 00628 ast_cli(fd, format, "Action", "Privilege", "Synopsis"); 00629 ast_cli(fd, format, "------", "---------", "--------"); 00630 00631 ast_rwlock_rdlock(&actionlock); 00632 for (cur = first_action; cur; cur = cur->next) /* Walk the list of actions */ 00633 ast_cli(fd, format, cur->action, authority_to_str(cur->authority, authority, sizeof(authority) -1), cur->synopsis); 00634 ast_rwlock_unlock(&actionlock); 00635 00636 return RESULT_SUCCESS; 00637 }
static int handle_showmanconn | ( | int | fd, | |
int | argc, | |||
char * | argv[] | |||
) | [static] |
CLI command show manager connected.
Definition at line 641 of file manager.c.
References ast_cli(), ast_inet_ntoa(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, format, mansession::list, RESULT_SUCCESS, and s.
00642 { 00643 struct mansession *s; 00644 char wtout[32]; 00645 char *format = " %-15.15s %-15.15s %-15.15s\n"; 00646 00647 ast_cli(fd, format, "Username", "IP Address", "Timeout"); 00648 00649 AST_LIST_LOCK(&sessions); 00650 AST_LIST_TRAVERSE(&sessions, s, list) { 00651 memset(wtout, 0, sizeof(wtout)); 00652 snprintf(wtout, sizeof(wtout)-1, "%d", s->writetimeout); 00653 ast_cli(fd, format,s->username, ast_inet_ntoa(s->sin.sin_addr), wtout); 00654 } 00655 AST_LIST_UNLOCK(&sessions); 00656 00657 return RESULT_SUCCESS; 00658 }
static int handle_showmaneventq | ( | int | fd, | |
int | argc, | |||
char * | argv[] | |||
) | [static] |
CLI command show manager eventq.
Definition at line 662 of file manager.c.
References ast_cli(), AST_LIST_LOCK, AST_LIST_UNLOCK, master_eventq, RESULT_SUCCESS, and s.
00663 { 00664 struct eventqent *s; 00665 00666 AST_LIST_LOCK(&sessions); 00667 for (s = master_eventq; s; s = s->next) { 00668 ast_cli(fd, "Usecount: %d\n",s->usecount); 00669 ast_cli(fd, "Category: %d\n", s->category); 00670 ast_cli(fd, "Event:\n%s", s->eventdata); 00671 } 00672 AST_LIST_UNLOCK(&sessions); 00673 00674 return RESULT_SUCCESS; 00675 }
static void handle_updates | ( | struct mansession * | s, | |
const struct message * | m, | |||
struct ast_config * | cfg | |||
) | [static] |
Definition at line 1171 of file manager.c.
References ast_category_append(), ast_category_delete(), ast_category_get(), ast_category_new(), ast_category_rename(), ast_strlen_zero(), ast_variable_append(), ast_variable_delete(), ast_variable_new(), ast_variable_update(), astman_get_header(), match(), ast_variable::object, ast_variable::value, and var.
Referenced by action_updateconfig().
01172 { 01173 int x; 01174 char hdr[40]; 01175 const char *action, *cat, *var, *value, *match; 01176 struct ast_category *category; 01177 struct ast_variable *v; 01178 01179 for (x=0;x<100000;x++) { 01180 unsigned int object = 0; 01181 01182 snprintf(hdr, sizeof(hdr), "Action-%06d", x); 01183 action = astman_get_header(m, hdr); 01184 if (ast_strlen_zero(action)) 01185 break; 01186 snprintf(hdr, sizeof(hdr), "Cat-%06d", x); 01187 cat = astman_get_header(m, hdr); 01188 snprintf(hdr, sizeof(hdr), "Var-%06d", x); 01189 var = astman_get_header(m, hdr); 01190 snprintf(hdr, sizeof(hdr), "Value-%06d", x); 01191 value = astman_get_header(m, hdr); 01192 if (!ast_strlen_zero(value) && *value == '>') { 01193 object = 1; 01194 value++; 01195 } 01196 snprintf(hdr, sizeof(hdr), "Match-%06d", x); 01197 match = astman_get_header(m, hdr); 01198 if (!strcasecmp(action, "newcat")) { 01199 if (!ast_strlen_zero(cat)) { 01200 category = ast_category_new(cat); 01201 if (category) { 01202 ast_category_append(cfg, category); 01203 } 01204 } 01205 } else if (!strcasecmp(action, "renamecat")) { 01206 if (!ast_strlen_zero(cat) && !ast_strlen_zero(value)) { 01207 category = ast_category_get(cfg, cat); 01208 if (category) 01209 ast_category_rename(category, value); 01210 } 01211 } else if (!strcasecmp(action, "delcat")) { 01212 if (!ast_strlen_zero(cat)) 01213 ast_category_delete(cfg, (char *) cat); 01214 } else if (!strcasecmp(action, "update")) { 01215 if (!ast_strlen_zero(cat) && !ast_strlen_zero(var) && (category = ast_category_get(cfg, cat))) 01216 ast_variable_update(category, var, value, match, object); 01217 } else if (!strcasecmp(action, "delete")) { 01218 if (!ast_strlen_zero(cat) && !ast_strlen_zero(var) && (category = ast_category_get(cfg, cat))) 01219 ast_variable_delete(category, (char *) var, (char *) match); 01220 } else if (!strcasecmp(action, "append")) { 01221 if (!ast_strlen_zero(cat) && !ast_strlen_zero(var) && 01222 (category = ast_category_get(cfg, cat)) && 01223 (v = ast_variable_new(var, value))){ 01224 if (object || (match && !strcasecmp(match, "object"))) 01225 v->object = 1; 01226 ast_variable_append(category, v); 01227 } 01228 } 01229 } 01230 }
static char* html_translate | ( | char * | in | ) | [static] |
Definition at line 438 of file manager.c.
References ast_build_string(), ast_malloc, len(), and var.
00439 { 00440 int x; 00441 int colons = 0; 00442 int breaks = 0; 00443 size_t len; 00444 int count = 1; 00445 char *tmp, *var, *val, *out; 00446 00447 for (x=0; in[x]; x++) { 00448 if (in[x] == ':') 00449 colons++; 00450 if (in[x] == '\n') 00451 breaks++; 00452 } 00453 len = strlen(in) + colons * 40 + breaks * 40; /* <tr><td></td><td></td></tr>, "<tr><td colspan=\"2\"><hr></td></tr> */ 00454 out = ast_malloc(len); 00455 if (!out) 00456 return 0; 00457 tmp = out; 00458 while (*in) { 00459 var = in; 00460 while (*in && (*in >= 32)) 00461 in++; 00462 if (*in) { 00463 if ((count % 4) == 0){ 00464 ast_build_string(&tmp, &len, "<tr><td colspan=\"2\"><hr></td></tr>\r\n"); 00465 } 00466 count = 0; 00467 while (*in && (*in < 32)) { 00468 *in = '\0'; 00469 in++; 00470 count++; 00471 } 00472 val = strchr(var, ':'); 00473 if (val) { 00474 *val = '\0'; 00475 val++; 00476 if (*val == ' ') 00477 val++; 00478 ast_build_string(&tmp, &len, "<tr><td>%s</td><td>%s</td></tr>\r\n", var, val); 00479 } 00480 } 00481 } 00482 return out; 00483 }
int manager_event | ( | int | category, | |
const char * | event, | |||
const char * | contents, | |||
... | ||||
) |
manager_event: Send AMI event to client
category | Event category, matches manager authorization | |
event | Event name | |
contents | Contents of event |
Definition at line 2649 of file manager.c.
References append_event(), ast_dynamic_str_thread_append(), ast_dynamic_str_thread_append_va, ast_dynamic_str_thread_get(), ast_dynamic_str_thread_set(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock(), ast_mutex_unlock(), AST_PTHREADT_NULL, ast_tvnow(), authority_to_str(), manager_event_buf, MANAGER_EVENT_BUF_INITSIZE, num_sessions, s, ast_dynamic_str::str, and timestampevents.
Referenced by __expire_registry(), __iax2_poke_noanswer(), __login_exec(), action_agent_callback_login(), add_to_queue(), agent_logoff_maintenance(), aji_log_hook(), ast_change_name(), ast_channel_bridge(), ast_do_masquerade(), ast_hangup(), ast_log(), ast_set_callerid(), ast_setstate(), change_hold_state(), conf_run(), dahdi_handle_event(), expire_register(), fast_originate(), handle_alarms(), handle_init_event(), handle_response_peerpoke(), handle_response_register(), iax2_ack_registry(), join_queue(), leave_queue(), manager_log(), manager_state_cb(), notify_new_message(), park_call_full(), park_exec(), parse_register_contact(), pbx_extension_helper(), post_manager_event(), quit_handler(), realtime_exec(), record_abandoned(), register_verify(), reload_logger(), reload_manager(), remove_from_queue(), ring_entry(), senddialevent(), set_member_paused(), sip_poke_noanswer(), sip_reg_timeout(), socket_process(), ss_thread(), try_calling(), update_registry(), update_status(), and vm_execmain().
02650 { 02651 struct mansession *s; 02652 char auth[80]; 02653 va_list ap; 02654 struct timeval now; 02655 struct ast_dynamic_str *buf; 02656 02657 /* Abort if there aren't any manager sessions */ 02658 if (!num_sessions) 02659 return 0; 02660 02661 if (!(buf = ast_dynamic_str_thread_get(&manager_event_buf, MANAGER_EVENT_BUF_INITSIZE))) 02662 return -1; 02663 02664 ast_dynamic_str_thread_set(&buf, 0, &manager_event_buf, 02665 "Event: %s\r\nPrivilege: %s\r\n", 02666 event, authority_to_str(category, auth, sizeof(auth))); 02667 02668 if (timestampevents) { 02669 now = ast_tvnow(); 02670 ast_dynamic_str_thread_append(&buf, 0, &manager_event_buf, 02671 "Timestamp: %ld.%06lu\r\n", 02672 now.tv_sec, (unsigned long) now.tv_usec); 02673 } 02674 02675 va_start(ap, fmt); 02676 ast_dynamic_str_thread_append_va(&buf, 0, &manager_event_buf, fmt, ap); 02677 va_end(ap); 02678 02679 ast_dynamic_str_thread_append(&buf, 0, &manager_event_buf, "\r\n"); 02680 02681 /* Append event to master list and wake up any sleeping sessions */ 02682 AST_LIST_LOCK(&sessions); 02683 append_event(buf->str, category); 02684 AST_LIST_TRAVERSE(&sessions, s, list) { 02685 ast_mutex_lock(&s->__lock); 02686 if (s->waiting_thread != AST_PTHREADT_NULL) 02687 pthread_kill(s->waiting_thread, SIGURG); 02688 else 02689 /* We have an event to process, but the mansession is 02690 * not waiting for it. We still need to indicate that there 02691 * is an event waiting so that get_input processes the pending 02692 * event instead of polling. 02693 */ 02694 s->pending_event = 1; 02695 ast_mutex_unlock(&s->__lock); 02696 } 02697 AST_LIST_UNLOCK(&sessions); 02698 02699 return 0; 02700 }
static void manager_event_buf_init | ( | void | ) | [static] |
static int manager_state_cb | ( | char * | context, | |
char * | exten, | |||
int | state, | |||
void * | data | |||
) | [static] |
Definition at line 2724 of file manager.c.
References EVENT_FLAG_CALL, and manager_event().
Referenced by init_manager().
02725 { 02726 /* Notify managers of change */ 02727 manager_event(EVENT_FLAG_CALL, "ExtensionStatus", "Exten: %s\r\nContext: %s\r\nStatus: %d\r\n", exten, context, state); 02728 return 0; 02729 }
static int process_events | ( | struct mansession * | s | ) | [static] |
Definition at line 2179 of file manager.c.
References ast_calloc, ast_carefulwrite(), ast_dynamic_str_append(), ast_mutex_lock(), ast_mutex_unlock(), eventqent::category, eventqent::eventdata, master_eventq, s, and unuse_eventqent().
Referenced by do_message().
02180 { 02181 struct eventqent *eqe; 02182 int ret = 0; 02183 ast_mutex_lock(&s->__lock); 02184 if (!s->eventq) 02185 s->eventq = master_eventq; 02186 while(s->eventq->next) { 02187 eqe = s->eventq->next; 02188 if ((s->authenticated && (s->readperm & eqe->category) == eqe->category) && 02189 ((s->send_events & eqe->category) == eqe->category)) { 02190 if (s->fd > -1) { 02191 if (!ret && ast_carefulwrite(s->fd, eqe->eventdata, strlen(eqe->eventdata), s->writetimeout) < 0) 02192 ret = -1; 02193 } else if (!s->outputstr && !(s->outputstr = ast_calloc(1, sizeof(*s->outputstr)))) 02194 ret = -1; 02195 else 02196 ast_dynamic_str_append(&s->outputstr, 0, "%s", eqe->eventdata); 02197 } 02198 unuse_eventqent(s->eventq); 02199 s->eventq = eqe; 02200 } 02201 ast_mutex_unlock(&s->__lock); 02202 return ret; 02203 }
static int process_message | ( | struct mansession * | s, | |
const struct message * | m | |||
) | [static] |
Definition at line 2314 of file manager.c.
References manager_action::action, actionlock, ast_copy_string(), ast_inet_ntoa(), ast_log(), ast_random(), ast_rwlock_rdlock(), ast_rwlock_unlock(), ast_strlen_zero(), ast_verbose(), astman_append(), astman_get_header(), astman_send_ack(), astman_send_error(), authenticate(), manager_action::authority, displayconnects, first_action, manager_action::func, LOG_DEBUG, LOG_EVENT, manager_action::next, option_debug, option_verbose, s, and VERBOSE_PREFIX_2.
Referenced by do_message().
02315 { 02316 char action[80] = ""; 02317 struct manager_action *tmp; 02318 const char *id = astman_get_header(m,"ActionID"); 02319 char idText[256] = ""; 02320 int ret = 0; 02321 02322 ast_copy_string(action, astman_get_header(m, "Action"), sizeof(action)); 02323 if (option_debug) 02324 ast_log( LOG_DEBUG, "Manager received command '%s'\n", action ); 02325 02326 if (ast_strlen_zero(action)) { 02327 astman_send_error(s, m, "Missing action in request"); 02328 return 0; 02329 } 02330 if (!ast_strlen_zero(id)) { 02331 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id); 02332 } 02333 if (!s->authenticated) { 02334 if (!strcasecmp(action, "Challenge")) { 02335 const char *authtype = astman_get_header(m, "AuthType"); 02336 02337 if (!strcasecmp(authtype, "MD5")) { 02338 if (ast_strlen_zero(s->challenge)) 02339 snprintf(s->challenge, sizeof(s->challenge), "%ld", ast_random()); 02340 astman_append(s, "Response: Success\r\n" 02341 "%s" 02342 "Challenge: %s\r\n\r\n", 02343 idText, s->challenge); 02344 return 0; 02345 } else { 02346 astman_send_error(s, m, "Must specify AuthType"); 02347 return 0; 02348 } 02349 } else if (!strcasecmp(action, "Login")) { 02350 if (authenticate(s, m)) { 02351 sleep(1); 02352 astman_send_error(s, m, "Authentication failed"); 02353 return -1; 02354 } else { 02355 s->authenticated = 1; 02356 if (option_verbose > 1) { 02357 if (displayconnects) { 02358 ast_verbose(VERBOSE_PREFIX_2 "%sManager '%s' logged on from %s\n", 02359 (s->sessiontimeout ? "HTTP " : ""), s->username, ast_inet_ntoa(s->sin.sin_addr)); 02360 } 02361 } 02362 ast_log(LOG_EVENT, "%sManager '%s' logged on from %s\n", 02363 (s->sessiontimeout ? "HTTP " : ""), s->username, ast_inet_ntoa(s->sin.sin_addr)); 02364 astman_send_ack(s, m, "Authentication accepted"); 02365 } 02366 } else if (!strcasecmp(action, "Logoff")) { 02367 astman_send_ack(s, m, "See ya"); 02368 return -1; 02369 } else 02370 astman_send_error(s, m, "Authentication Required"); 02371 } else { 02372 if (!strcasecmp(action, "Login")) 02373 astman_send_ack(s, m, "Already logged in"); 02374 else { 02375 ast_rwlock_rdlock(&actionlock); 02376 for (tmp = first_action; tmp; tmp = tmp->next) { 02377 if (strcasecmp(action, tmp->action)) 02378 continue; 02379 if ((s->writeperm & tmp->authority) == tmp->authority) { 02380 if (tmp->func(s, m)) 02381 ret = -1; 02382 } else 02383 astman_send_error(s, m, "Permission denied"); 02384 break; 02385 } 02386 ast_rwlock_unlock(&actionlock); 02387 if (!tmp) 02388 astman_send_error(s, m, "Invalid/unknown command"); 02389 } 02390 } 02391 if (ret) 02392 return ret; 02393 return process_events(s); 02394 }
static void* session_do | ( | void * | data | ) | [static] |
Definition at line 2485 of file manager.c.
References ast_inet_ntoa(), ast_log(), ast_verbose(), astman_append(), displayconnects, do_message(), LOG_EVENT, option_verbose, s, and VERBOSE_PREFIX_2.
Referenced by accept_thread().
02486 { 02487 struct mansession *s = data; 02488 int res; 02489 02490 astman_append(s, "Asterisk Call Manager/1.0\r\n"); 02491 for (;;) { 02492 if ((res = do_message(s)) < 0) 02493 break; 02494 } 02495 if (s->authenticated) { 02496 if (option_verbose > 1) { 02497 if (displayconnects) 02498 ast_verbose(VERBOSE_PREFIX_2 "Manager '%s' logged off from %s\n", s->username, ast_inet_ntoa(s->sin.sin_addr)); 02499 } 02500 ast_log(LOG_EVENT, "Manager '%s' logged off from %s\n", s->username, ast_inet_ntoa(s->sin.sin_addr)); 02501 } else { 02502 if (option_verbose > 1) { 02503 if (displayconnects) 02504 ast_verbose(VERBOSE_PREFIX_2 "Connect attempt from '%s' unable to authenticate\n", ast_inet_ntoa(s->sin.sin_addr)); 02505 } 02506 ast_log(LOG_EVENT, "Failed attempt from %s\n", ast_inet_ntoa(s->sin.sin_addr)); 02507 } 02508 02509 /* It is possible under certain circumstances for this session thread 02510 to complete its work and exit *before* the thread that created it 02511 has finished executing the ast_pthread_create_background() function. 02512 If this occurs, some versions of glibc appear to act in a buggy 02513 fashion and attempt to write data into memory that it thinks belongs 02514 to the thread but is in fact not owned by the thread (or may have 02515 been freed completely). 02516 02517 Causing this thread to yield to other threads at least one time 02518 appears to work around this bug. 02519 */ 02520 usleep(1); 02521 02522 destroy_session(s); 02523 return NULL; 02524 }
static int set_eventmask | ( | struct mansession * | s, | |
const char * | eventmask | |||
) | [static] |
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.
Definition at line 959 of file manager.c.
References ast_mutex_lock(), ast_mutex_unlock(), s, and strings_to_mask().
Referenced by action_events().
00960 { 00961 int maskint = strings_to_mask(eventmask); 00962 00963 ast_mutex_lock(&s->__lock); 00964 if (maskint >= 0) 00965 s->send_events = maskint; 00966 ast_mutex_unlock(&s->__lock); 00967 00968 return maskint; 00969 }
static int strings_to_mask | ( | const char * | string | ) | [static] |
Definition at line 928 of file manager.c.
References ast_false(), ast_instring(), ast_is_number(), ast_strlen_zero(), ast_true(), and perms.
Referenced by set_eventmask().
00929 { 00930 int x, ret = -1; 00931 00932 x = ast_is_number(string); 00933 00934 if (x) 00935 ret = x; 00936 else if (ast_strlen_zero(string)) 00937 ret = -1; 00938 else if (ast_false(string)) 00939 ret = 0; 00940 else if (ast_true(string)) { 00941 ret = 0; 00942 for (x=0; x<sizeof(perms) / sizeof(perms[0]); x++) 00943 ret |= perms[x].num; 00944 } else { 00945 ret = 0; 00946 for (x=0; x<sizeof(perms) / sizeof(perms[0]); x++) { 00947 if (ast_instring(string, perms[x].label, ',')) 00948 ret |= perms[x].num; 00949 } 00950 } 00951 00952 return ret; 00953 }
static void unuse_eventqent | ( | struct eventqent * | e | ) | [static] |
Definition at line 750 of file manager.c.
References ast_atomic_dec_and_test(), eventqent::next, and eventqent::usecount.
Referenced by action_waitevent(), free_session(), and process_events().
00751 { 00752 if (ast_atomic_dec_and_test(&e->usecount) && e->next) 00753 pthread_kill(t, SIGURG); 00754 }
static int variable_count_cmp_fn | ( | void * | obj, | |
void * | vstr, | |||
int | flags | |||
) | [static] |
Definition at line 328 of file manager.c.
References variable_count::varname.
Referenced by xml_translate().
00329 { 00330 /* Due to the simplicity of struct variable_count, it makes no difference 00331 * if you pass in objects or strings, the same operation applies. This is 00332 * due to the fact that the hash occurs on the first element, which means 00333 * the address of both the struct and the string are exactly the same. */ 00334 struct variable_count *vc = obj; 00335 char *str = vstr; 00336 return !strcmp(vc->varname, str) ? CMP_MATCH | CMP_STOP : 0; 00337 }
static int variable_count_hash_fn | ( | const void * | vvc, | |
const int | flags | |||
) | [static] |
Definition at line 316 of file manager.c.
References compress_char(), and variable_count::varname.
Referenced by xml_translate().
00317 { 00318 const struct variable_count *vc = vvc; 00319 int res = 0, i; 00320 for (i = 0; i < 5; i++) { 00321 if (vc->varname[i] == '\0') 00322 break; 00323 res += compress_char(vc->varname[i]) << (i * 6); 00324 } 00325 return res; 00326 }
static void xml_copy_escape | ( | char ** | dst, | |
size_t * | maxlen, | |||
const char * | src, | |||
int | lower | |||
) | [static] |
Definition at line 261 of file manager.c.
Referenced by xml_translate().
00262 { 00263 while (*src && (*maxlen > 6)) { 00264 switch (*src) { 00265 case '<': 00266 strcpy(*dst, "<"); 00267 (*dst) += 4; 00268 *maxlen -= 4; 00269 break; 00270 case '>': 00271 strcpy(*dst, ">"); 00272 (*dst) += 4; 00273 *maxlen -= 4; 00274 break; 00275 case '\"': 00276 strcpy(*dst, """); 00277 (*dst) += 6; 00278 *maxlen -= 6; 00279 break; 00280 case '\'': 00281 strcpy(*dst, "'"); 00282 (*dst) += 6; 00283 *maxlen -= 6; 00284 break; 00285 case '&': 00286 strcpy(*dst, "&"); 00287 (*dst) += 5; 00288 *maxlen -= 5; 00289 break; 00290 default: 00291 *(*dst)++ = lower ? tolower(*src) : *src; 00292 (*maxlen)--; 00293 } 00294 src++; 00295 } 00296 }
static char* xml_translate | ( | char * | in, | |
struct ast_variable * | vars | |||
) | [static] |
Definition at line 339 of file manager.c.
References ao2_alloc(), ao2_container_alloc(), ao2_find(), ao2_ref(), ast_build_string(), ast_malloc, variable_count::count, len(), ast_variable::name, ast_variable::next, ast_variable::value, var, variable_count_cmp_fn(), variable_count_hash_fn(), and xml_copy_escape().
00340 { 00341 struct ast_variable *v; 00342 char *dest = NULL; 00343 char *out, *tmp, *var, *val; 00344 char *objtype = NULL; 00345 int colons = 0; 00346 int breaks = 0; 00347 size_t len; 00348 int count = 1; 00349 int escaped = 0; 00350 int inobj = 0; 00351 int x; 00352 struct variable_count *vc = NULL; 00353 struct ao2_container *vco = NULL; 00354 00355 for (v = vars; v; v = v->next) { 00356 if (!dest && !strcasecmp(v->name, "ajaxdest")) 00357 dest = v->value; 00358 else if (!objtype && !strcasecmp(v->name, "ajaxobjtype")) 00359 objtype = v->value; 00360 } 00361 if (!dest) 00362 dest = "unknown"; 00363 if (!objtype) 00364 objtype = "generic"; 00365 for (x = 0; in[x]; x++) { 00366 if (in[x] == ':') 00367 colons++; 00368 else if (in[x] == '\n') 00369 breaks++; 00370 else if (strchr("&\"<>\'", in[x])) 00371 escaped++; 00372 } 00373 len = (size_t) (strlen(in) + colons * 5 + breaks * (40 + strlen(dest) + strlen(objtype)) + escaped * 10); /* foo="bar", "<response type=\"object\" id=\"dest\"", "&" */ 00374 out = ast_malloc(len); 00375 if (!out) 00376 return 0; 00377 tmp = out; 00378 while (*in) { 00379 var = in; 00380 while (*in && (*in >= 32)) 00381 in++; 00382 if (*in) { 00383 if ((count > 3) && inobj) { 00384 ast_build_string(&tmp, &len, " /></response>\n"); 00385 inobj = 0; 00386 00387 /* Entity is closed, so close out the name cache */ 00388 ao2_ref(vco, -1); 00389 vco = NULL; 00390 } 00391 count = 0; 00392 while (*in && (*in < 32)) { 00393 *in = '\0'; 00394 in++; 00395 count++; 00396 } 00397 val = strchr(var, ':'); 00398 if (val) { 00399 *val = '\0'; 00400 val++; 00401 if (*val == ' ') 00402 val++; 00403 if (!inobj) { 00404 vco = ao2_container_alloc(37, variable_count_hash_fn, variable_count_cmp_fn); 00405 ast_build_string(&tmp, &len, "<response type='object' id='%s'><%s", dest, objtype); 00406 inobj = 1; 00407 } 00408 00409 /* Check if the var has been used already */ 00410 if ((vc = ao2_find(vco, var, 0))) 00411 vc->count++; 00412 else { 00413 /* Create a new entry for this one */ 00414 vc = ao2_alloc(sizeof(*vc), NULL); 00415 vc->varname = var; 00416 vc->count = 1; 00417 ao2_link(vco, vc); 00418 } 00419 00420 ast_build_string(&tmp, &len, " "); 00421 xml_copy_escape(&tmp, &len, var, 1); 00422 if (vc->count > 1) 00423 ast_build_string(&tmp, &len, "-%d", vc->count); 00424 ast_build_string(&tmp, &len, "='"); 00425 xml_copy_escape(&tmp, &len, val, 0); 00426 ast_build_string(&tmp, &len, "'"); 00427 ao2_ref(vc, -1); 00428 } 00429 } 00430 } 00431 if (inobj) 00432 ast_build_string(&tmp, &len, " /></response>\n"); 00433 if (vco) 00434 ao2_ref(vco, -1); 00435 return out; 00436 }
ast_rwlock_t actionlock = PTHREAD_RWLOCK_INITIALIZER [static] |
Definition at line 208 of file manager.c.
Referenced by ast_manager_register_struct(), ast_manager_unregister(), complete_show_mancmd(), handle_showmancmd(), handle_showmancmds(), and process_message().
int asock = -1 [static] |
struct ast_threadstorage astman_append_buf = { .once = PTHREAD_ONCE_INIT, .key_init = astman_append_buf_init , } [static] |
int block_sockets [static] |
struct ast_cli_entry cli_manager[] [static] |
struct ast_cli_entry cli_show_manager_command_deprecated [static] |
Initial value:
{ { "show", "manager", "command", NULL }, handle_showmancmd, NULL, NULL, complete_show_mancmd }
struct ast_cli_entry cli_show_manager_commands_deprecated [static] |
Initial value:
{ { "show", "manager", "commands", NULL }, handle_showmancmds, NULL, NULL }
struct ast_cli_entry cli_show_manager_connected_deprecated [static] |
Initial value:
{ { "show", "manager", "connected", NULL }, handle_showmanconn, NULL, NULL }
struct ast_cli_entry cli_show_manager_eventq_deprecated [static] |
Initial value:
{ { "show", "manager", "eventq", NULL }, handle_showmaneventq, NULL, NULL }
struct { ... } command_blacklist[] [static] |
Referenced by check_blacklist().
int displayconnects = 1 [static] |
Definition at line 105 of file manager.c.
Referenced by accept_thread(), init_manager(), process_message(), and session_do().
struct manager_action* first_action [static] |
Definition at line 207 of file manager.c.
Referenced by action_listcommands(), ast_manager_register_struct(), ast_manager_unregister(), complete_show_mancmd(), handle_showmancmd(), handle_showmancmds(), and process_message().
int httptimeout = 60 [static] |
int manager_enabled = 0 [static] |
struct ast_threadstorage manager_event_buf = { .once = PTHREAD_ONCE_INIT, .key_init = manager_event_buf_init , } [static] |
char mandescr_atxfer[] [static] |
char mandescr_command[] [static] |
Initial value:
"Description: Run a CLI command.\n" "Variables: (Names marked with * are required)\n" " *Command: Asterisk CLI command to run\n" " ActionID: Optional Action id for message matching.\n"
Definition at line 1803 of file manager.c.
Referenced by init_manager().
char mandescr_coresettings[] [static] |
char mandescr_corestatus[] [static] |
char mandescr_events[] [static] |
char mandescr_extensionstate[] [static] |
char mandescr_getconfig[] [static] |
Initial value:
"Description: A 'GetConfig' action will dump the contents of a configuration\n" "file by category and contents.\n" "Variables:\n" " Filename: Configuration filename (e.g. foo.conf)\n"
Definition at line 1128 of file manager.c.
Referenced by init_manager().
char mandescr_getvar[] [static] |
char mandescr_hangup[] [static] |
Initial value:
"Description: Hangup a channel\n" "Variables: \n" " Channel: The channel name to be hungup\n"
Definition at line 1429 of file manager.c.
Referenced by init_manager().
char mandescr_listcommands[] [static] |
Initial value:
"Description: Returns the action name and synopsis for every\n" " action that is available to the user\n" "Variables: NONE\n"
Definition at line 1372 of file manager.c.
Referenced by init_manager().
char mandescr_logoff[] [static] |
Initial value:
"Description: Logoff this manager session\n" "Variables: NONE\n"
Definition at line 1419 of file manager.c.
Referenced by init_manager().
char mandescr_mailboxcount[] [static] |
char mandescr_mailboxstatus[] [static] |
Help text for manager command mailboxstatus.
Definition at line 2039 of file manager.c.
Referenced by init_manager().
char mandescr_originate[] [static] |
char mandescr_ping[] [static] |
Initial value:
"Description: A 'Ping' action will ellicit a 'Pong' response. Used to keep the\n" " manager connection open.\n" "Variables: NONE\n"
Definition at line 1117 of file manager.c.
Referenced by init_manager().
char mandescr_redirect[] [static] |
char mandescr_setvar[] [static] |
char mandescr_timeout[] [static] |
char mandescr_updateconfig[] [static] |
char mandescr_userevent[] [static] |
char mandescr_waitevent[] [static] |
struct eventqent* master_eventq = NULL |
Definition at line 114 of file manager.c.
Referenced by accept_thread(), append_event(), handle_showmaneventq(), and process_events().
int num_sessions [static] |
Definition at line 111 of file manager.c.
Referenced by accept_thread(), append_event(), and manager_event().
Referenced by authority_to_str(), get_perm(), and strings_to_mask().
int portno = DEFAULT_MANAGER_PORT [static] |
Definition at line 103 of file manager.c.
Referenced by ast_netsock_bind(), create_addr(), init_manager(), process_sdp(), and set_config().
char showmanager_help[] [static] |
char showmanagers_help[] [static] |
char showmancmd_help[] [static] |
char showmancmds_help[] [static] |
char showmanconn_help[] [static] |
char showmaneventq_help[] [static] |
pthread_t t [static] |
Definition at line 109 of file manager.c.
Referenced by __ast_register_translator(), __schedule_action(), acf_odbc_write(), add_sdp(), add_t38_sdp(), append_date(), ast_channel_bridge(), ast_check_timing(), ast_do_masquerade(), ast_get_time_t(), ast_httpd_helper_thread(), ast_log(), ast_pbx_start(), ast_say_enumeration_full_da(), ast_say_enumeration_full_de(), ast_say_enumeration_full_en(), ast_say_number_full_de(), ast_translator_activate(), ast_translator_build_path(), ast_translator_deactivate(), ast_tvdiff_ms(), ast_tveq(), ast_unregister_translator(), ast_verbose(), background_detect_exec(), build_mapping(), byteReverse(), calc_cost(), calc_txstamp(), callerid_genmsg(), callerid_getcarrier(), cb_events(), cdr_get_tv(), check_switch_expr(), check_user_full(), cli_prompt(), config_text_file_save(), destroy(), do_monitor(), does_peer_need_mwi(), dump_cmd_queues(), expr2_token_subst(), gen_match_to_pattern(), gen_tone(), gen_tones(), get_date(), get_trans_id(), gtalk_action(), gtalk_create_candidates(), gtalk_digit(), gtalk_invite(), gtalk_invite_response(), handle_bchan(), handle_enbloc_call_message(), handle_hd_hf(), handle_offhook_message(), handle_save_dialplan(), handle_soft_key_event_message(), handle_stimulus_message(), iax2_datetime(), iax2_process_thread(), iax2_show_threads(), iax_template_parse(), launch_service(), listener(), local_new(), localsub(), lws2sws(), manager_log(), MD5Update(), misdn_read(), newpvt(), osp_create_provider(), osp_load(), packdate(), parse_moved_contact(), pgsql_log(), pri_dchannel(), prune_gateways(), rebuild_matrix(), register_verify(), rpt(), rpt_do_lstats(), rpt_exec(), rpt_tele_thread(), send_request(), SHA1ProcessMessageBlock(), sms_readfile(), socket_read(), sqlite_log(), strip_quotes(), tdd_getcarrier(), time2sub(), transmit_notify_request_with_callerid(), transmit_notify_with_mwi(), transmit_state_notify(), and write_metadata().
int timestampevents [static] |
int webmanager_enabled = 0 [static] |