Thu May 14 14:50:22 2009

Asterisk developer's documentation


AMI functions

callback to display queues status in manager More...

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_userast_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_variableastman_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_actionfirst_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.
eventqentmaster_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

Detailed Description

callback to display queues status in manager


Define Documentation

#define ASTMAN_APPEND_BUF_INITSIZE   256

Definition at line 120 of file manager.c.

Referenced by astman_append().

#define MANAGER_EVENT_BUF_INITSIZE   256

Definition at line 117 of file manager.c.

Referenced by manager_event().

#define MAX_BLACKLIST_CMD_LEN   2

Definition at line 138 of file manager.c.

Referenced by check_blacklist().


Function Documentation

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]

Note:
The actionlock is read-locked by the caller of this function

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

Parameters:
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  ) 

Parameters:
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]

Definition at line 119 of file manager.c.

00122 {

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 
)

Note:
NOTE: Callers of astman_send_error(), astman_send_response() or astman_send_ack() must EITHER hold the session lock _or_ be running in an action callback (in which case s->busy will be non-zero). In either of these cases, there is no need to lock-protect the session's fd, since no other output will be sent (events will be queued), and no input will be read until either the current action finishes or get_input() obtains the session lock.

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

Parameters:
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]

Definition at line 116 of file manager.c.

00122 {

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, "&lt;");
00267          (*dst) += 4;
00268          *maxlen -= 4;
00269          break;
00270       case '>':
00271          strcpy(*dst, "&gt;");
00272          (*dst) += 4;
00273          *maxlen -= 4;
00274          break;
00275       case '\"':
00276          strcpy(*dst, "&quot;");
00277          (*dst) += 6;
00278          *maxlen -= 6;
00279          break;
00280       case '\'':
00281          strcpy(*dst, "&apos;");
00282          (*dst) += 6;
00283          *maxlen -= 6;
00284          break;
00285       case '&':
00286          strcpy(*dst, "&amp;");
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\"", "&amp;" */
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 }


Variable Documentation

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]

Definition at line 104 of file manager.c.

Referenced by accept_thread(), and init_manager().

struct ast_threadstorage astman_append_buf = { .once = PTHREAD_ONCE_INIT, .key_init = astman_append_buf_init , } [static]

Definition at line 119 of file manager.c.

Referenced by astman_append().

int block_sockets [static]

Definition at line 110 of file manager.c.

Referenced by accept_thread(), and init_manager().

struct ast_cli_entry cli_manager[] [static]

Definition at line 724 of file manager.c.

Referenced by init_manager().

struct ast_cli_entry cli_show_manager_command_deprecated [static]

Initial value:

 {
   { "show", "manager", "command", NULL },
   handle_showmancmd, NULL,
   NULL, complete_show_mancmd }

Definition at line 704 of file manager.c.

struct ast_cli_entry cli_show_manager_commands_deprecated [static]

Initial value:

 {
   { "show", "manager", "commands", NULL },
   handle_showmancmds, NULL,
   NULL }

Definition at line 709 of file manager.c.

struct ast_cli_entry cli_show_manager_connected_deprecated [static]

Initial value:

 {
   { "show", "manager", "connected", NULL },
   handle_showmanconn, NULL,
   NULL }

Definition at line 714 of file manager.c.

struct ast_cli_entry cli_show_manager_eventq_deprecated [static]

Initial value:

 {
   { "show", "manager", "eventq", NULL },
   handle_showmaneventq, NULL,
   NULL }

Definition at line 719 of file manager.c.

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]

Definition at line 107 of file manager.c.

int manager_enabled = 0 [static]

Definition at line 100 of file manager.c.

Referenced by init_manager().

struct ast_threadstorage manager_event_buf = { .once = PTHREAD_ONCE_INIT, .key_init = manager_event_buf_init , } [static]

Definition at line 116 of file manager.c.

Referenced by manager_event().

char mandescr_atxfer[] [static]

Definition at line 1760 of file manager.c.

Referenced by init_manager().

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]

Initial value:

"Description: Query for Core PBX settings.\n"
"Variables: (Names marked with * are optional)\n"
"       *ActionID: ActionID of this transaction\n"

Definition at line 2234 of file manager.c.

char mandescr_corestatus[] [static]

Initial value:

"Description: Query for Core PBX status.\n"
"Variables: (Names marked with * are optional)\n"
"       *ActionID: ActionID of this transaction\n"

Definition at line 2278 of file manager.c.

char mandescr_events[] [static]

Definition at line 1397 of file manager.c.

Referenced by init_manager().

char mandescr_extensionstate[] [static]

Definition at line 2107 of file manager.c.

Referenced by init_manager().

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]

Definition at line 1490 of file manager.c.

Referenced by init_manager().

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]

Definition at line 2071 of file manager.c.

Referenced by init_manager().

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]

Definition at line 1908 of file manager.c.

Referenced by init_manager().

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"
Manager PING.

Definition at line 1117 of file manager.c.

Referenced by init_manager().

char mandescr_redirect[] [static]

Definition at line 1639 of file manager.c.

Referenced by init_manager().

char mandescr_setvar[] [static]

Definition at line 1453 of file manager.c.

Referenced by init_manager().

char mandescr_timeout[] [static]

Definition at line 2148 of file manager.c.

Referenced by init_manager().

char mandescr_updateconfig[] [static]

Definition at line 1232 of file manager.c.

Referenced by init_manager().

char mandescr_userevent[] [static]

Definition at line 2205 of file manager.c.

Referenced by init_manager().

char mandescr_waitevent[] [static]

Manager WAITEVENT.

Definition at line 1283 of file manager.c.

Referenced by init_manager().

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

struct permalias perms[] [static]

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]

Initial value:

" Usage: manager show user <user>\n"
"        Display all information related to the manager user specified.\n"

Definition at line 700 of file manager.c.

char showmanagers_help[] [static]

Initial value:

"Usage: manager show users\n"
"       Prints a listing of all managers that are currently configured on that\n"
" system.\n"

Definition at line 695 of file manager.c.

char showmancmd_help[] [static]

Initial value:

 
"Usage: manager show command <actionname>\n"
"  Shows the detailed description for a specific Asterisk manager interface command.\n"

Definition at line 677 of file manager.c.

char showmancmds_help[] [static]

Initial value:

 
"Usage: manager show commands\n"
"  Prints a listing of all the available Asterisk manager interface commands.\n"

Definition at line 681 of file manager.c.

char showmanconn_help[] [static]

Initial value:

 
"Usage: manager show connected\n"
"  Prints a listing of the users that are currently connected to the\n"
"Asterisk manager interface.\n"

Definition at line 685 of file manager.c.

char showmaneventq_help[] [static]

Initial value:

 
"Usage: manager show eventq\n"
"  Prints a listing of all events pending in the Asterisk manger\n"
"event queue.\n"

Definition at line 690 of file manager.c.

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]

Definition at line 106 of file manager.c.

Referenced by init_manager(), and manager_event().

int webmanager_enabled = 0 [static]

Definition at line 101 of file manager.c.

Referenced by init_manager().

char* words[AST_MAX_CMD_LEN] [inherited]

Definition at line 140 of file manager.c.


Generated on Thu May 14 14:50:22 2009 for Asterisk - the Open Source PBX by  doxygen 1.4.7