Thu Feb 5 16:26:28 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 2511 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().

02512 {
02513    int as;
02514    struct sockaddr_in sin;
02515    socklen_t sinlen;
02516    struct eventqent *eqe;
02517    struct mansession *s;
02518    struct protoent *p;
02519    int arg = 1;
02520    int flags;
02521    pthread_attr_t attr;
02522    time_t now;
02523    struct pollfd pfds[1];
02524 
02525    pthread_attr_init(&attr);
02526    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
02527 
02528    for (;;) {
02529       time(&now);
02530       AST_LIST_LOCK(&sessions);
02531       AST_LIST_TRAVERSE_SAFE_BEGIN(&sessions, s, list) {
02532          if (s->sessiontimeout && (now > s->sessiontimeout) && !s->inuse) {
02533             AST_LIST_REMOVE_CURRENT(&sessions, list);
02534             num_sessions--;
02535             if (s->authenticated && (option_verbose > 1) && displayconnects) {
02536                ast_verbose(VERBOSE_PREFIX_2 "HTTP Manager '%s' timed out from %s\n",
02537                   s->username, ast_inet_ntoa(s->sin.sin_addr));
02538             }
02539             free_session(s);
02540             break;   
02541          }
02542       }
02543       AST_LIST_TRAVERSE_SAFE_END
02544       /* Purge master event queue of old, unused events, but make sure we
02545          always keep at least one in the queue */
02546       eqe = master_eventq;
02547       while (master_eventq->next && !master_eventq->usecount) {
02548          eqe = master_eventq;
02549          master_eventq = master_eventq->next;
02550          free(eqe);
02551       }
02552       AST_LIST_UNLOCK(&sessions);
02553 
02554       sinlen = sizeof(sin);
02555       pfds[0].fd = asock;
02556       pfds[0].events = POLLIN;
02557       /* Wait for something to happen, but timeout every few seconds so
02558          we can ditch any old manager sessions */
02559       if (poll(pfds, 1, 5000) < 1)
02560          continue;
02561       as = accept(asock, (struct sockaddr *)&sin, &sinlen);
02562       if (as < 0) {
02563          ast_log(LOG_NOTICE, "Accept returned -1: %s\n", strerror(errno));
02564          continue;
02565       }
02566       p = getprotobyname("tcp");
02567       if (p) {
02568          if( setsockopt(as, p->p_proto, TCP_NODELAY, (char *)&arg, sizeof(arg) ) < 0 ) {
02569             ast_log(LOG_WARNING, "Failed to set manager tcp connection to TCP_NODELAY mode: %s\n", strerror(errno));
02570          }
02571       }
02572       if (!(s = ast_calloc(1, sizeof(*s))))
02573          continue;
02574 
02575       memcpy(&s->sin, &sin, sizeof(sin));
02576       s->writetimeout = 100;
02577       s->waiting_thread = AST_PTHREADT_NULL;
02578 
02579       if (!block_sockets) {
02580          /* For safety, make sure socket is non-blocking */
02581          flags = fcntl(as, F_GETFL);
02582          fcntl(as, F_SETFL, flags | O_NONBLOCK);
02583       } else {
02584          flags = fcntl(as, F_GETFL);
02585          fcntl(as, F_SETFL, flags & ~O_NONBLOCK);
02586       }
02587       ast_mutex_init(&s->__lock);
02588       s->fd = as;
02589       s->send_events = -1;
02590       AST_LIST_LOCK(&sessions);
02591       AST_LIST_INSERT_HEAD(&sessions, s, list);
02592       num_sessions++;
02593       /* Find the last place in the master event queue and hook ourselves
02594          in there */
02595       s->eventq = master_eventq;
02596       while(s->eventq->next)
02597          s->eventq = s->eventq->next;
02598       ast_atomic_fetchadd_int(&s->eventq->usecount, 1);
02599       AST_LIST_UNLOCK(&sessions);
02600       if (ast_pthread_create_background(&s->t, &attr, session_do, s))
02601          destroy_session(s);
02602    }
02603    pthread_attr_destroy(&attr);
02604    return NULL;
02605 }

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

Definition at line 1757 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().

01758 {
01759    struct ast_channel *c;
01760    const char *name = astman_get_header(m, "Channel");
01761    const char *exten = astman_get_header(m, "Exten");
01762    const char *context = astman_get_header(m, "Context");
01763    char *xferto;
01764    int len;
01765 
01766    if (ast_strlen_zero(name)) {
01767       astman_send_error(s, m, "No channel specified");
01768       return 0;
01769    }
01770    if (ast_strlen_zero(exten)) {
01771       astman_send_error(s, m, "No exten specified");
01772       return 0;
01773    }
01774    c = ast_get_channel_by_name_locked(name);
01775    if (!c) {
01776       astman_send_error(s, m, "No such channel");
01777       return 0;
01778    }
01779    len = asprintf(&xferto, "%s@%s", exten, context);
01780    if (len < 0) {
01781       astman_send_error(s, m, "Out of memory!");
01782       goto cleanup;
01783    }
01784    ast_queue_control_data(c, AST_CONTROL_ATXFERCMD, xferto, len+1);
01785    free(xferto);
01786    astman_send_ack(s, m, "Attended transfer started");
01787 cleanup:
01788    ast_channel_unlock(c);
01789    return 0;
01790 }

static int action_command ( struct mansession s,
const struct message m 
) [static]

action_command: Manager command "command" - execute CLI command

Definition at line 1799 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().

01800 {
01801    const char *cmd = astman_get_header(m, "Command");
01802    const char *id = astman_get_header(m, "ActionID");
01803    char *buf, *final_buf;
01804    char template[] = "/tmp/ast-ami-XXXXXX";  /* template for temporary file */
01805    int fd = mkstemp(template);
01806    off_t l;
01807 
01808    if (ast_strlen_zero(cmd)) {
01809       astman_send_error(s, m, "No command provided");
01810       return 0;
01811    }
01812 
01813    if (check_blacklist(cmd)) {
01814       astman_send_error(s, m, "Command blacklisted");
01815       return 0;
01816    }
01817 
01818    astman_append(s, "Response: Follows\r\nPrivilege: Command\r\n");
01819    if (!ast_strlen_zero(id))
01820       astman_append(s, "ActionID: %s\r\n", id);
01821    /* FIXME: Wedge a ActionID response in here, waiting for later changes */
01822    ast_cli_command(fd, cmd);  /* XXX need to change this to use a FILE * */
01823    l = lseek(fd, 0, SEEK_END);   /* how many chars available */
01824 
01825    /* This has a potential to overflow the stack.  Hence, use the heap. */
01826    buf = ast_calloc(1, l + 1);
01827    final_buf = ast_calloc(1, l + 1);
01828    if (buf) {
01829       lseek(fd, 0, SEEK_SET);
01830       if (read(fd, buf, l) < 0) {
01831          ast_log(LOG_WARNING, "read() failed: %s\n", strerror(errno));
01832       }
01833       buf[l] = '\0';
01834       if (final_buf) {
01835          term_strip(final_buf, buf, l);
01836          final_buf[l] = '\0';
01837       }
01838       astman_append(s, "%s", S_OR(final_buf, buf));
01839       ast_free(buf);
01840    }
01841    close(fd);
01842    unlink(template);
01843    astman_append(s, "--END COMMAND--\r\n\r\n");
01844    if (final_buf)
01845       ast_free(final_buf);
01846    return 0;
01847 }

static int action_coresettings ( struct mansession s,
const struct message m 
) [static]

Show PBX core settings information.

Definition at line 2225 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().

02226 {
02227    const char *actionid = astman_get_header(m, "ActionID");
02228    char idText[150] = "";
02229 
02230    if (!ast_strlen_zero(actionid))
02231       snprintf(idText, sizeof(idText), "ActionID: %s\r\n", actionid);
02232 
02233    astman_append(s, "Response: Success\r\n"
02234          "%s"
02235          "AMIversion: %s\r\n"
02236          "AsteriskVersion: %s\r\n"
02237          "SystemName: %s\r\n"
02238          "CoreMaxCalls: %d\r\n"
02239          "CoreMaxLoadAvg: %f\r\n"
02240          "CoreRunUser: %s\r\n"
02241          "CoreRunGroup: %s\r\n"
02242          "CoreMaxFilehandles: %d\r\n" 
02243          "CoreRealTimeEnabled: %s\r\n"
02244          "CoreCDRenabled: %s\r\n"
02245          "CoreHTTPenabled: %s\r\n"
02246          "\r\n",
02247          idText,
02248          AMI_VERSION,
02249          ASTERISK_VERSION, 
02250          ast_config_AST_SYSTEM_NAME,
02251          option_maxcalls,
02252          option_maxload,
02253          ast_config_AST_RUN_USER,
02254          ast_config_AST_RUN_GROUP,
02255          option_maxfiles,
02256          ast_realtime_enabled() ? "Yes" : "No",
02257          check_cdr_enabled() ? "Yes" : "No",
02258          check_webmanager_enabled() ? "Yes" : "No"
02259          );
02260    return 0;
02261 }

static int action_corestatus ( struct mansession s,
const struct message m 
) [static]

Show PBX core status information.

Definition at line 2269 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().

02270 {
02271    const char *actionid = astman_get_header(m, "ActionID");
02272    char idText[150];
02273    char startuptime[150];
02274    char reloadtime[150];
02275    struct tm tm;
02276 
02277    if (!ast_strlen_zero(actionid))
02278       snprintf(idText, sizeof(idText), "ActionID: %s\r\n", actionid);
02279 
02280    ast_localtime(&ast_startuptime, &tm, NULL);
02281    strftime(startuptime, sizeof(startuptime), "%H:%M:%S", &tm);
02282    ast_localtime(&ast_lastreloadtime, &tm, NULL);
02283    strftime(reloadtime, sizeof(reloadtime), "%H:%M:%S", &tm);
02284 
02285    astman_append(s, "Response: Success\r\n"
02286          "%s"
02287          "CoreStartupTime: %s\r\n"
02288          "CoreReloadTime: %s\r\n"
02289          "CoreCurrentCalls: %d\r\n"
02290          "\r\n",
02291          idText,
02292          startuptime,
02293          reloadtime,
02294          ast_active_channels()
02295          );
02296    return 0;
02297 }

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

02108 {
02109    const char *exten = astman_get_header(m, "Exten");
02110    const char *context = astman_get_header(m, "Context");
02111    const char *id = astman_get_header(m,"ActionID");
02112    char idText[256] = "";
02113    char hint[256] = "";
02114    int status;
02115    if (ast_strlen_zero(exten)) {
02116       astman_send_error(s, m, "Extension not specified");
02117       return 0;
02118    }
02119    if (ast_strlen_zero(context))
02120       context = "default";
02121    status = ast_extension_state(NULL, context, exten);
02122    ast_get_hint(hint, sizeof(hint) - 1, NULL, 0, NULL, context, exten);
02123         if (!ast_strlen_zero(id)) {
02124                 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
02125         }
02126    astman_append(s, "Response: Success\r\n"
02127                     "%s"
02128                "Message: Extension Status\r\n"
02129                "Exten: %s\r\n"
02130                "Context: %s\r\n"
02131                "Hint: %s\r\n"
02132                "Status: %d\r\n\r\n",
02133                idText,exten, context, hint, status);
02134    return 0;
02135 }

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

02072 {
02073    const char *mailbox = astman_get_header(m, "Mailbox");
02074    const char *id = astman_get_header(m,"ActionID");
02075    char idText[256] = "";
02076    int newmsgs = 0, oldmsgs = 0;
02077    if (ast_strlen_zero(mailbox)) {
02078       astman_send_error(s, m, "Mailbox not specified");
02079       return 0;
02080    }
02081    ast_app_inboxcount(mailbox, &newmsgs, &oldmsgs);
02082    if (!ast_strlen_zero(id)) {
02083       snprintf(idText, sizeof(idText), "ActionID: %s\r\n",id);
02084    }
02085    astman_append(s, "Response: Success\r\n"
02086                "%s"
02087                "Message: Mailbox Message Count\r\n"
02088                "Mailbox: %s\r\n"
02089                "NewMessages: %d\r\n"
02090                "OldMessages: %d\r\n" 
02091                "\r\n",
02092                 idText,mailbox, newmsgs, oldmsgs);
02093    return 0;
02094 }

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

Definition at line 2039 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().

02040 {
02041    const char *mailbox = astman_get_header(m, "Mailbox");
02042    const char *id = astman_get_header(m,"ActionID");
02043    char idText[256] = "";
02044    int ret;
02045    if (ast_strlen_zero(mailbox)) {
02046       astman_send_error(s, m, "Mailbox not specified");
02047       return 0;
02048    }
02049         if (!ast_strlen_zero(id))
02050                 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
02051    ret = ast_app_has_voicemail(mailbox, NULL);
02052    astman_append(s, "Response: Success\r\n"
02053                "%s"
02054                "Message: Mailbox Status\r\n"
02055                "Mailbox: %s\r\n"
02056                "Waiting: %d\r\n\r\n", idText, mailbox, ret);
02057    return 0;
02058 }

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

Definition at line 1913 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().

01914 {
01915    const char *name = astman_get_header(m, "Channel");
01916    const char *exten = astman_get_header(m, "Exten");
01917    const char *context = astman_get_header(m, "Context");
01918    const char *priority = astman_get_header(m, "Priority");
01919    const char *timeout = astman_get_header(m, "Timeout");
01920    const char *callerid = astman_get_header(m, "CallerID");
01921    const char *account = astman_get_header(m, "Account");
01922    const char *app = astman_get_header(m, "Application");
01923    const char *appdata = astman_get_header(m, "Data");
01924    const char *async = astman_get_header(m, "Async");
01925    const char *id = astman_get_header(m, "ActionID");
01926    const char *codecs = astman_get_header(m, "Codecs");
01927    struct ast_variable *vars = astman_get_variables(m);
01928    char *tech, *data;
01929    char *l = NULL, *n = NULL;
01930    int pi = 0;
01931    int res;
01932    int to = 30000;
01933    int reason = 0;
01934    char tmp[256];
01935    char tmp2[256];
01936    int format = AST_FORMAT_SLINEAR;
01937    
01938    pthread_t th;
01939    pthread_attr_t attr;
01940    if (ast_strlen_zero(name)) {
01941       astman_send_error(s, m, "Channel not specified");
01942       return 0;
01943    }
01944    if (!ast_strlen_zero(priority) && (sscanf(priority, "%d", &pi) != 1)) {
01945       if ((pi = ast_findlabel_extension(NULL, context, exten, priority, NULL)) < 1) {
01946          astman_send_error(s, m, "Invalid priority");
01947          return 0;
01948       }
01949    }
01950    if (!ast_strlen_zero(timeout) && (sscanf(timeout, "%d", &to) != 1)) {
01951       astman_send_error(s, m, "Invalid timeout");
01952       return 0;
01953    }
01954    ast_copy_string(tmp, name, sizeof(tmp));
01955    tech = tmp;
01956    data = strchr(tmp, '/');
01957    if (!data) {
01958       astman_send_error(s, m, "Invalid channel");
01959       return 0;
01960    }
01961    *data++ = '\0';
01962    ast_copy_string(tmp2, callerid, sizeof(tmp2));
01963    ast_callerid_parse(tmp2, &n, &l);
01964    if (n) {
01965       if (ast_strlen_zero(n))
01966          n = NULL;
01967    }
01968    if (l) {
01969       ast_shrink_phone_number(l);
01970       if (ast_strlen_zero(l))
01971          l = NULL;
01972    }
01973    if (!ast_strlen_zero(codecs)) {
01974       format = 0;
01975       ast_parse_allow_disallow(NULL, &format, codecs, 1);
01976    }
01977    if (ast_true(async)) {
01978       struct fast_originate_helper *fast = ast_calloc(1, sizeof(*fast));
01979       if (!fast) {
01980          res = -1;
01981       } else {
01982          if (!ast_strlen_zero(id))
01983             snprintf(fast->idtext, sizeof(fast->idtext), "ActionID: %s\r\n", id);
01984          ast_copy_string(fast->tech, tech, sizeof(fast->tech));
01985             ast_copy_string(fast->data, data, sizeof(fast->data));
01986          ast_copy_string(fast->app, app, sizeof(fast->app));
01987          ast_copy_string(fast->appdata, appdata, sizeof(fast->appdata));
01988          if (l)
01989             ast_copy_string(fast->cid_num, l, sizeof(fast->cid_num));
01990          if (n)
01991             ast_copy_string(fast->cid_name, n, sizeof(fast->cid_name));
01992          fast->vars = vars;   
01993          ast_copy_string(fast->context, context, sizeof(fast->context));
01994          ast_copy_string(fast->exten, exten, sizeof(fast->exten));
01995          ast_copy_string(fast->account, account, sizeof(fast->account));
01996          fast->format = format;
01997          fast->timeout = to;
01998          fast->priority = pi;
01999          pthread_attr_init(&attr);
02000          pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
02001          if (ast_pthread_create(&th, &attr, fast_originate, fast)) {
02002             ast_free(fast);
02003             res = -1;
02004          } else {
02005             res = 0;
02006          }
02007          pthread_attr_destroy(&attr);
02008       }
02009    } else if (!ast_strlen_zero(app)) {
02010          res = ast_pbx_outgoing_app(tech, format, data, to, app, appdata, &reason, 1, l, n, vars, account, NULL);
02011       } else {
02012       if (exten && context && pi)
02013             res = ast_pbx_outgoing_exten(tech, format, data, to, context, exten, pi, &reason, 1, l, n, vars, account, NULL);
02014       else {
02015          astman_send_error(s, m, "Originate with 'Exten' requires 'Context' and 'Priority'");
02016          return 0;
02017       }
02018    }   
02019    if (!res)
02020       astman_send_ack(s, m, "Originate successfully queued");
02021    else
02022       astman_send_error(s, m, "Originate failed");
02023    return 0;
02024 }

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_unlock, ast_check_hangup(), ast_findlabel_extension(), ast_get_channel_by_name_locked(), ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), context, exten, name, 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    res = ast_async_goto(chan, context, exten, pi);
01693    if (!res) {
01694       if (!ast_strlen_zero(name2)) {
01695          if (chan2)
01696             res = ast_async_goto(chan2, context, exten, pi);
01697          else
01698             res = -1;
01699          if (!res)
01700             astman_send_ack(s, m, "Dual Redirect successful");
01701          else
01702             astman_send_error(s, m, "Secondary redirect failed");
01703       } else
01704          astman_send_ack(s, m, "Redirect successful");
01705    } else
01706       astman_send_error(s, m, "Redirect failed");
01707    if (chan)
01708       ast_channel_unlock(chan);
01709    if (chan2)
01710       ast_channel_unlock(chan2);
01711    return 0;
01712 }

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

02145 {
02146    struct ast_channel *c = NULL;
02147    const char *name = astman_get_header(m, "Channel");
02148    int timeout = atoi(astman_get_header(m, "Timeout"));
02149    if (ast_strlen_zero(name)) {
02150       astman_send_error(s, m, "No channel specified");
02151       return 0;
02152    }
02153    if (!timeout) {
02154       astman_send_error(s, m, "No timeout specified");
02155       return 0;
02156    }
02157    c = ast_get_channel_by_name_locked(name);
02158    if (!c) {
02159       astman_send_error(s, m, "No such channel");
02160       return 0;
02161    }
02162    ast_channel_setwhentohangup(c, timeout);
02163    ast_channel_unlock(c);
02164    astman_send_ack(s, m, "Timeout Set");
02165    return 0;
02166 }

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

References ast_copy_string(), astman_get_header(), EVENT_FLAG_USER, message::hdrcount, message::headers, and manager_event().

Referenced by init_manager().

02202 {
02203    const char *event = astman_get_header(m, "UserEvent");
02204    char body[2048] = "";
02205    int x, bodylen = 0;
02206    for (x = 0; x < m->hdrcount; x++) {
02207       if (strncasecmp("UserEvent:", m->headers[x], strlen("UserEvent:"))) {
02208          ast_copy_string(body + bodylen, m->headers[x], sizeof(body) - bodylen - 3);
02209          bodylen += strlen(m->headers[x]);
02210          ast_copy_string(body + bodylen, "\r\n", 3);
02211          bodylen += 2;
02212       }
02213    }
02214 
02215    manager_event(EVENT_FLAG_USER, "UserEvent", "UserEvent: %s\r\n%s", event, body);
02216    return 0;
02217 }

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

References ast_malloc, master_eventq, eventqent::next, num_sessions, and eventqent::usecount.

Referenced by init_manager(), and manager_event().

02608 {
02609    struct eventqent *tmp, *prev = NULL;
02610    tmp = ast_malloc(sizeof(*tmp) + strlen(str));
02611 
02612    if (!tmp)
02613       return -1;
02614 
02615    tmp->next = NULL;
02616    tmp->category = category;
02617    strcpy(tmp->eventdata, str);
02618    
02619    if (master_eventq) {
02620       prev = master_eventq;
02621       while (prev->next) 
02622          prev = prev->next;
02623       prev->next = tmp;
02624    } else {
02625       master_eventq = tmp;
02626    }
02627    
02628    tmp->usecount = num_sessions;
02629    
02630    return 0;
02631 }

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

References ast_malloc, and ast_manager_register_struct().

Referenced by init_manager(), and load_module().

02761 {
02762    struct manager_action *cur;
02763 
02764    cur = ast_malloc(sizeof(*cur));
02765    if (!cur)
02766       return -1;
02767    
02768    cur->action = action;
02769    cur->authority = auth;
02770    cur->func = func;
02771    cur->synopsis = synopsis;
02772    cur->description = description;
02773    cur->next = NULL;
02774 
02775    ast_manager_register_struct(cur);
02776 
02777    return 0;
02778 }

static int ast_manager_register_struct ( struct manager_action act  )  [static]

Definition at line 2716 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().

02717 {
02718    struct manager_action *cur, *prev = NULL;
02719    int ret;
02720 
02721    ast_rwlock_wrlock(&actionlock);
02722    cur = first_action;
02723    while (cur) { /* Walk the list of actions */
02724       ret = strcasecmp(cur->action, act->action);
02725       if (ret == 0) {
02726          ast_log(LOG_WARNING, "Manager: Action '%s' already registered\n", act->action);
02727          ast_rwlock_unlock(&actionlock);
02728          return -1;
02729       } else if (ret > 0) {
02730          /* Insert these alphabetically */
02731          if (prev) {
02732             act->next = prev->next;
02733             prev->next = act;
02734          } else {
02735             act->next = first_action;
02736             first_action = act;
02737          }
02738          break;
02739       }
02740       prev = cur; 
02741       cur = cur->next;
02742    }
02743    
02744    if (!cur) {
02745       if (prev)
02746          prev->next = act;
02747       else
02748          first_action = act;
02749       act->next = NULL;
02750    }
02751 
02752    if (option_verbose > 1) 
02753       ast_verbose(VERBOSE_PREFIX_2 "Manager registered action %s\n", act->action);
02754    ast_rwlock_unlock(&actionlock);
02755    return 0;
02756 }

int ast_manager_unregister ( char *  action  ) 

Parameters:
action Name of registred Action:

Definition at line 2687 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().

02688 {
02689    struct manager_action *cur, *prev;
02690 
02691    ast_rwlock_wrlock(&actionlock);
02692    cur = prev = first_action;
02693    while (cur) {
02694       if (!strcasecmp(action, cur->action)) {
02695          prev->next = cur->next;
02696          free(cur);
02697          if (option_verbose > 1) 
02698             ast_verbose(VERBOSE_PREFIX_2 "Manager unregistered action %s\n", action);
02699          ast_rwlock_unlock(&actionlock);
02700          return 0;
02701       }
02702       prev = cur;
02703       cur = cur->next;
02704    }
02705    ast_rwlock_unlock(&actionlock);
02706    return 0;
02707 }

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

01715 {
01716    char *cmd_copy, *cur_cmd;
01717    char *cmd_words[MAX_BLACKLIST_CMD_LEN] = { NULL, };
01718    int i;
01719 
01720    cmd_copy = ast_strdupa(cmd);
01721    for (i = 0; i < MAX_BLACKLIST_CMD_LEN && (cur_cmd = strsep(&cmd_copy, " ")); i++) {
01722       cur_cmd = ast_strip(cur_cmd);
01723       if (ast_strlen_zero(cur_cmd)) {
01724          i--;
01725          continue;
01726       }
01727 
01728       cmd_words[i] = cur_cmd;
01729    }
01730 
01731    for (i = 0; i < ARRAY_LEN(command_blacklist); i++) {
01732       int j, match = 1;
01733 
01734       for (j = 0; command_blacklist[i].words[j]; j++) {
01735          if (ast_strlen_zero(cmd_words[j]) || strcasecmp(cmd_words[j], command_blacklist[i].words[j])) {
01736             match = 0;
01737             break;
01738          }
01739       }
01740 
01741       if (match) {
01742          return 1;
01743       }
01744    }
01745 
01746    return 0;
01747 }

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

02441 {
02442    struct message m = { 0 };
02443    char header_buf[sizeof(s->inbuf)] = { '\0' };
02444    int res;
02445 
02446    for (;;) {
02447       /* Check if any events are pending and do them if needed */
02448       if (s->eventq->next) {
02449          if (process_events(s))
02450             return -1;
02451       }
02452       res = get_input(s, header_buf);
02453       if (res == 0) {
02454          continue;
02455       } else if (res > 0) {
02456          /* Strip trailing \r\n */
02457          if (strlen(header_buf) < 2)
02458             continue;
02459          header_buf[strlen(header_buf) - 2] = '\0';
02460          if (ast_strlen_zero(header_buf))
02461             return process_message(s, &m) ? -1 : 0;
02462          else if (m.hdrcount < (AST_MAX_MANHEADERS - 1))
02463             m.headers[m.hdrcount++] = ast_strdupa(header_buf);
02464       } else {
02465          return res;
02466       }
02467    }
02468 }

static void* fast_originate ( void *  data  )  [static]

Definition at line 1849 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().

01850 {
01851    struct fast_originate_helper *in = data;
01852    int res;
01853    int reason = 0;
01854    struct ast_channel *chan = NULL;
01855    char requested_channel[AST_CHANNEL_NAME];
01856 
01857    if (!ast_strlen_zero(in->app)) {
01858       res = ast_pbx_outgoing_app(in->tech, in->format, in->data, in->timeout, in->app, in->appdata, &reason, 1, 
01859          S_OR(in->cid_num, NULL), 
01860          S_OR(in->cid_name, NULL),
01861          in->vars, in->account, &chan);
01862    } else {
01863       res = ast_pbx_outgoing_exten(in->tech, in->format, in->data, in->timeout, in->context, in->exten, in->priority, &reason, 1, 
01864          S_OR(in->cid_num, NULL), 
01865          S_OR(in->cid_name, NULL),
01866          in->vars, in->account, &chan);
01867    }
01868 
01869    if (!chan)
01870       snprintf(requested_channel, AST_CHANNEL_NAME, "%s/%s", in->tech, in->data);   
01871    /* Tell the manager what happened with the channel */
01872    manager_event(EVENT_FLAG_CALL, "OriginateResponse",
01873       "%s"
01874       "Response: %s\r\n"
01875       "Channel: %s\r\n"
01876       "Context: %s\r\n"
01877       "Exten: %s\r\n"
01878       "Reason: %d\r\n"
01879       "Uniqueid: %s\r\n"
01880       "CallerID: %s\r\n"      /* This parameter is deprecated and will be removed post-1.4 */
01881       "CallerIDNum: %s\r\n"
01882       "CallerIDName: %s\r\n",
01883       in->idtext, res ? "Failure" : "Success", chan ? chan->name : requested_channel, in->context, in->exten, reason, 
01884       chan ? chan->uniqueid : "<null>",
01885       S_OR(in->cid_num, "<unknown>"),
01886       S_OR(in->cid_num, "<unknown>"),
01887       S_OR(in->cid_name, "<unknown>")
01888       );
01889 
01890    /* Locked by ast_pbx_outgoing_exten or ast_pbx_outgoing_app */
01891    if (chan)
01892       ast_channel_unlock(chan);
01893    free(in);
01894    return NULL;
01895 }

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

References ast_channel::fds, and s.

Referenced by do_message(), and skinny_session().

02382 {
02383    /* output must have at least sizeof(s->inbuf) space */
02384    int res;
02385    int x;
02386    struct pollfd fds[1];
02387    for (x = 1; x < s->inlen; x++) {
02388       if ((s->inbuf[x] == '\n') && (s->inbuf[x-1] == '\r')) {
02389          /* Copy output data up to and including \r\n */
02390          memcpy(output, s->inbuf, x + 1);
02391          /* Add trailing \0 */
02392          output[x+1] = '\0';
02393          /* Move remaining data back to the front */
02394          memmove(s->inbuf, s->inbuf + x + 1, s->inlen - x);
02395          s->inlen -= (x + 1);
02396          return 1;
02397       }
02398    } 
02399    if (s->inlen >= sizeof(s->inbuf) - 1) {
02400       ast_log(LOG_WARNING, "Dumping long line with no return from %s: %s\n", ast_inet_ntoa(s->sin.sin_addr), s->inbuf);
02401       s->inlen = 0;
02402    }
02403    fds[0].fd = s->fd;
02404    fds[0].events = POLLIN;
02405    do {
02406       ast_mutex_lock(&s->__lock);
02407       if (s->pending_event) {
02408          s->pending_event = 0;
02409          ast_mutex_unlock(&s->__lock);
02410          return 0;
02411       }
02412       s->waiting_thread = pthread_self();
02413       ast_mutex_unlock(&s->__lock);
02414 
02415       res = poll(fds, 1, -1);
02416 
02417       ast_mutex_lock(&s->__lock);
02418       s->waiting_thread = AST_PTHREADT_NULL;
02419       ast_mutex_unlock(&s->__lock);
02420       if (res < 0) {
02421          if (errno == EINTR || errno == EAGAIN) {
02422             return 0;
02423          }
02424          ast_log(LOG_WARNING, "Select returned error: %s\n", strerror(errno));
02425          return -1;
02426       } else if (res > 0) {
02427          ast_mutex_lock(&s->__lock);
02428          res = read(s->fd, s->inbuf + s->inlen, sizeof(s->inbuf) - 1 - s->inlen);
02429          ast_mutex_unlock(&s->__lock);
02430          if (res < 1)
02431             return -1;
02432          break;
02433       }
02434    } while(1);
02435    s->inlen += res;
02436    s->inbuf[s->inlen] = '\0';
02437    return 0;
02438 }

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 2634 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(), action_userevent(), 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(), userevent_exec(), and vm_execmain().

02635 {
02636    struct mansession *s;
02637    char auth[80];
02638    va_list ap;
02639    struct timeval now;
02640    struct ast_dynamic_str *buf;
02641 
02642    /* Abort if there aren't any manager sessions */
02643    if (!num_sessions)
02644       return 0;
02645 
02646    if (!(buf = ast_dynamic_str_thread_get(&manager_event_buf, MANAGER_EVENT_BUF_INITSIZE)))
02647       return -1;
02648 
02649    ast_dynamic_str_thread_set(&buf, 0, &manager_event_buf,
02650          "Event: %s\r\nPrivilege: %s\r\n",
02651           event, authority_to_str(category, auth, sizeof(auth)));
02652 
02653    if (timestampevents) {
02654       now = ast_tvnow();
02655       ast_dynamic_str_thread_append(&buf, 0, &manager_event_buf,
02656             "Timestamp: %ld.%06lu\r\n",
02657              now.tv_sec, (unsigned long) now.tv_usec);
02658    }
02659 
02660    va_start(ap, fmt);
02661    ast_dynamic_str_thread_append_va(&buf, 0, &manager_event_buf, fmt, ap);
02662    va_end(ap);
02663    
02664    ast_dynamic_str_thread_append(&buf, 0, &manager_event_buf, "\r\n");  
02665    
02666    /* Append event to master list and wake up any sleeping sessions */
02667    AST_LIST_LOCK(&sessions);
02668    append_event(buf->str, category);
02669    AST_LIST_TRAVERSE(&sessions, s, list) {
02670       ast_mutex_lock(&s->__lock);
02671       if (s->waiting_thread != AST_PTHREADT_NULL)
02672          pthread_kill(s->waiting_thread, SIGURG);
02673       else
02674          /* We have an event to process, but the mansession is
02675           * not waiting for it. We still need to indicate that there
02676           * is an event waiting so that get_input processes the pending
02677           * event instead of polling.
02678           */
02679          s->pending_event = 1;
02680       ast_mutex_unlock(&s->__lock);
02681    }
02682    AST_LIST_UNLOCK(&sessions);
02683 
02684    return 0;
02685 }

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

References EVENT_FLAG_CALL, and manager_event().

Referenced by init_manager().

02710 {
02711    /* Notify managers of change */
02712    manager_event(EVENT_FLAG_CALL, "ExtensionStatus", "Exten: %s\r\nContext: %s\r\nStatus: %d\r\n", exten, context, state);
02713    return 0;
02714 }

static int process_events ( struct mansession s  )  [static]

Definition at line 2168 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().

02169 {
02170    struct eventqent *eqe;
02171    int ret = 0;
02172    ast_mutex_lock(&s->__lock);
02173    if (!s->eventq)
02174       s->eventq = master_eventq;
02175    while(s->eventq->next) {
02176       eqe = s->eventq->next;
02177       if ((s->authenticated && (s->readperm & eqe->category) == eqe->category) &&
02178                ((s->send_events & eqe->category) == eqe->category)) {
02179          if (s->fd > -1) {
02180             if (!ret && ast_carefulwrite(s->fd, eqe->eventdata, strlen(eqe->eventdata), s->writetimeout) < 0)
02181                ret = -1;
02182          } else if (!s->outputstr && !(s->outputstr = ast_calloc(1, sizeof(*s->outputstr)))) 
02183             ret = -1;
02184          else 
02185             ast_dynamic_str_append(&s->outputstr, 0, "%s", eqe->eventdata);
02186       }
02187       unuse_eventqent(s->eventq);
02188       s->eventq = eqe;
02189    }
02190    ast_mutex_unlock(&s->__lock);
02191    return ret;
02192 }

static int process_message ( struct mansession s,
const struct message m 
) [static]

Definition at line 2299 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().

02300 {
02301    char action[80] = "";
02302    struct manager_action *tmp;
02303    const char *id = astman_get_header(m,"ActionID");
02304    char idText[256] = "";
02305    int ret = 0;
02306 
02307    ast_copy_string(action, astman_get_header(m, "Action"), sizeof(action));
02308    if (option_debug)
02309       ast_log( LOG_DEBUG, "Manager received command '%s'\n", action );
02310 
02311    if (ast_strlen_zero(action)) {
02312       astman_send_error(s, m, "Missing action in request");
02313       return 0;
02314    }
02315    if (!ast_strlen_zero(id)) {
02316       snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
02317    }
02318    if (!s->authenticated) {
02319       if (!strcasecmp(action, "Challenge")) {
02320          const char *authtype = astman_get_header(m, "AuthType");
02321 
02322          if (!strcasecmp(authtype, "MD5")) {
02323             if (ast_strlen_zero(s->challenge))
02324                snprintf(s->challenge, sizeof(s->challenge), "%ld", ast_random());
02325             astman_append(s, "Response: Success\r\n"
02326                   "%s"
02327                   "Challenge: %s\r\n\r\n",
02328                   idText, s->challenge);
02329             return 0;
02330          } else {
02331             astman_send_error(s, m, "Must specify AuthType");
02332             return 0;
02333          }
02334       } else if (!strcasecmp(action, "Login")) {
02335          if (authenticate(s, m)) {
02336             sleep(1);
02337             astman_send_error(s, m, "Authentication failed");
02338             return -1;
02339          } else {
02340             s->authenticated = 1;
02341             if (option_verbose > 1) {
02342                if (displayconnects) {
02343                   ast_verbose(VERBOSE_PREFIX_2 "%sManager '%s' logged on from %s\n", 
02344                      (s->sessiontimeout ? "HTTP " : ""), s->username, ast_inet_ntoa(s->sin.sin_addr));
02345                }
02346             }
02347             ast_log(LOG_EVENT, "%sManager '%s' logged on from %s\n", 
02348                (s->sessiontimeout ? "HTTP " : ""), s->username, ast_inet_ntoa(s->sin.sin_addr));
02349             astman_send_ack(s, m, "Authentication accepted");
02350          }
02351       } else if (!strcasecmp(action, "Logoff")) {
02352          astman_send_ack(s, m, "See ya");
02353          return -1;
02354       } else
02355          astman_send_error(s, m, "Authentication Required");
02356    } else {
02357       if (!strcasecmp(action, "Login"))
02358          astman_send_ack(s, m, "Already logged in");
02359       else {
02360          ast_rwlock_rdlock(&actionlock);
02361          for (tmp = first_action; tmp; tmp = tmp->next) {      
02362             if (strcasecmp(action, tmp->action))
02363                continue;
02364             if ((s->writeperm & tmp->authority) == tmp->authority) {
02365                if (tmp->func(s, m))
02366                   ret = -1;
02367             } else
02368                astman_send_error(s, m, "Permission denied");
02369             break;
02370          }
02371          ast_rwlock_unlock(&actionlock);
02372          if (!tmp)
02373             astman_send_error(s, m, "Invalid/unknown command");
02374       }
02375    }
02376    if (ret)
02377       return ret;
02378    return process_events(s);
02379 }

static void* session_do ( void *  data  )  [static]

Definition at line 2470 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().

02471 {
02472    struct mansession *s = data;
02473    int res;
02474    
02475    astman_append(s, "Asterisk Call Manager/1.0\r\n");
02476    for (;;) {
02477       if ((res = do_message(s)) < 0)
02478          break;
02479    }
02480    if (s->authenticated) {
02481       if (option_verbose > 1) {
02482          if (displayconnects) 
02483             ast_verbose(VERBOSE_PREFIX_2 "Manager '%s' logged off from %s\n", s->username, ast_inet_ntoa(s->sin.sin_addr));
02484       }
02485       ast_log(LOG_EVENT, "Manager '%s' logged off from %s\n", s->username, ast_inet_ntoa(s->sin.sin_addr));
02486    } else {
02487       if (option_verbose > 1) {
02488          if (displayconnects)
02489             ast_verbose(VERBOSE_PREFIX_2 "Connect attempt from '%s' unable to authenticate\n", ast_inet_ntoa(s->sin.sin_addr));
02490       }
02491       ast_log(LOG_EVENT, "Failed attempt from %s\n", ast_inet_ntoa(s->sin.sin_addr));
02492    }
02493 
02494    /* It is possible under certain circumstances for this session thread
02495       to complete its work and exit *before* the thread that created it
02496       has finished executing the ast_pthread_create_background() function.
02497       If this occurs, some versions of glibc appear to act in a buggy
02498       fashion and attempt to write data into memory that it thinks belongs
02499       to the thread but is in fact not owned by the thread (or may have
02500       been freed completely).
02501 
02502       Causing this thread to yield to other threads at least one time
02503       appears to work around this bug.
02504    */
02505    usleep(1);
02506 
02507    destroy_session(s);
02508    return NULL;
02509 }

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

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

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 2219 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 2263 of file manager.c.

char mandescr_events[] [static]

Definition at line 1397 of file manager.c.

char mandescr_extensionstate[] [static]

Definition at line 2096 of file manager.c.

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.

char mandescr_getvar[] [static]

Definition at line 1490 of file manager.c.

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.

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.

char mandescr_logoff[] [static]

Initial value:

 
"Description: Logoff this manager session\n"
"Variables: NONE\n"

Definition at line 1419 of file manager.c.

char mandescr_mailboxcount[] [static]

Definition at line 2060 of file manager.c.

char mandescr_mailboxstatus[] [static]

Help text for manager command mailboxstatus.

Definition at line 2028 of file manager.c.

char mandescr_originate[] [static]

Definition at line 1897 of file manager.c.

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.

char mandescr_redirect[] [static]

Definition at line 1639 of file manager.c.

char mandescr_setvar[] [static]

Definition at line 1453 of file manager.c.

char mandescr_timeout[] [static]

Definition at line 2137 of file manager.c.

char mandescr_updateconfig[] [static]

Definition at line 1232 of file manager.c.

char mandescr_userevent[] [static]

Definition at line 2194 of file manager.c.

char mandescr_waitevent[] [static]

Manager WAITEVENT.

Definition at line 1283 of file manager.c.

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(), 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 Feb 5 16:26:28 2009 for Asterisk - the Open Source PBX by  doxygen 1.4.7