Wed Oct 28 15:49:24 2009

Asterisk developer's documentation


AMI functions

callback to display queues status in manager More...

Data Structures

struct  fast_originate_helper
struct  permalias

Functions

static void * accept_thread (void *ignore)
static int action_command (struct mansession *s, struct message *m)
 action_command: Manager command "command" - execute CLI command
static int action_events (struct mansession *s, struct message *m)
static int action_extensionstate (struct mansession *s, struct message *m)
static int action_getvar (struct mansession *s, struct message *m)
static int action_hangup (struct mansession *s, struct message *m)
static int action_listcommands (struct mansession *s, struct message *m)
static int action_logoff (struct mansession *s, struct message *m)
static int action_mailboxcount (struct mansession *s, struct message *m)
static int action_mailboxstatus (struct mansession *s, struct message *m)
static int action_originate (struct mansession *s, struct message *m)
static int action_ping (struct mansession *s, struct message *m)
static int action_redirect (struct mansession *s, struct message *m)
 action_redirect: The redirect manager command
static int action_setvar (struct mansession *s, struct message *m)
static int action_status (struct mansession *s, struct message *m)
 action_status: Manager "status" command to show channels
static int action_timeout (struct mansession *s, struct message *m)
static int append_event (struct mansession *s, const char *str)
int ast_carefulwrite (int fd, char *s, int len, int timeoutms)
static int ast_instring (char *bigstr, char *smallstr, char delim)
static int ast_is_number (char *string)
int ast_manager_register2 (const char *action, int auth, int(*func)(struct mansession *s, 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)
 AST_MUTEX_DEFINE_STATIC (actionlock)
 AST_MUTEX_DEFINE_STATIC (sessionlock)
static int ast_strings_to_mask (char *string)
char * astman_get_header (struct message *m, char *var)
struct ast_variableastman_get_variables (struct message *m)
void astman_send_ack (struct mansession *s, struct message *m, char *msg)
void astman_send_error (struct mansession *s, struct message *m, char *error)
void astman_send_response (struct mansession *s, struct message *m, char *resp, char *msg)
static int authenticate (struct mansession *s, struct message *m)
static char * authority_to_str (int authority, char *res, int reslen)
static char * complete_show_mancmd (char *line, char *word, int pos, int state)
static void destroy_session (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 (char *instr)
static int handle_showmancmd (int fd, int argc, char *argv[])
static int handle_showmancmds (int fd, int argc, char *argv[])
 handle_showmancmds: CLI command
static int handle_showmanconn (int fd, int argc, char *argv[])
 handle_showmanconn: CLI command show manager connected
int manager_event (int category, char *event, char *fmt,...)
 manager_event: Send AMI event to client
static int manager_state_cb (char *context, char *exten, int state, void *data)
static int process_message (struct mansession *s, struct message *m)
static void * session_do (void *data)
static int set_eventmask (struct mansession *s, char *eventmask)

Variables

static int asock = -1
static int block_sockets = 0
static int displayconnects = 1
static int enabled = 0
static struct manager_actionfirst_action = NULL
static char mandescr_command []
static char mandescr_events []
static char mandescr_extensionstate []
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 []
 PING: Manager PING.
static char mandescr_redirect []
static char mandescr_setvar []
static char mandescr_timeout []
static struct permalias perms []
static int portno = DEFAULT_MANAGER_PORT
static struct mansessionsessions = NULL
static struct ast_cli_entry show_mancmd_cli
static struct ast_cli_entry show_mancmds_cli
static struct ast_cli_entry show_manconn_cli
static char showmancmd_help []
static char showmancmds_help []
static char showmanconn_help []
static pthread_t t

Detailed Description

callback to display queues status in manager


Function Documentation

static void* accept_thread ( void *  ignore  )  [static]

Definition at line 1434 of file manager.c.

References mansession::__lock, ast_log(), ast_mutex_init(), ast_mutex_lock(), ast_mutex_unlock(), ast_pthread_create, destroy_session(), mansession::fd, LOG_NOTICE, LOG_WARNING, malloc, mansession::next, s, mansession::send_events, session_do(), mansession::sin, mansession::t, and mansession::writetimeout.

Referenced by init_manager(), and reload_config().

01435 {
01436    int as;
01437    struct sockaddr_in sin;
01438    socklen_t sinlen;
01439    struct mansession *s;
01440    struct protoent *p;
01441    int arg = 1;
01442    int flags;
01443    pthread_attr_t attr;
01444 
01445    pthread_attr_init(&attr);
01446    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
01447 
01448    for (;;) {
01449       sinlen = sizeof(sin);
01450       as = accept(asock, (struct sockaddr *)&sin, &sinlen);
01451       if (as < 0) {
01452          ast_log(LOG_NOTICE, "Accept returned -1: %s\n", strerror(errno));
01453          continue;
01454       }
01455       p = getprotobyname("tcp");
01456       if (p) {
01457          if( setsockopt(as, p->p_proto, TCP_NODELAY, (char *)&arg, sizeof(arg) ) < 0 ) {
01458             ast_log(LOG_WARNING, "Failed to set manager tcp connection to TCP_NODELAY mode: %s\n", strerror(errno));
01459          }
01460       }
01461       s = malloc(sizeof(struct mansession));
01462       if (!s) {
01463          ast_log(LOG_WARNING, "Failed to allocate management session: %s\n", strerror(errno));
01464          continue;
01465       } 
01466       memset(s, 0, sizeof(struct mansession));
01467       memcpy(&s->sin, &sin, sizeof(sin));
01468       s->writetimeout = 100;
01469 
01470       if(! block_sockets) {
01471          /* For safety, make sure socket is non-blocking */
01472          flags = fcntl(as, F_GETFL);
01473          fcntl(as, F_SETFL, flags | O_NONBLOCK);
01474       }
01475       ast_mutex_init(&s->__lock);
01476       s->fd = as;
01477       s->send_events = -1;
01478       ast_mutex_lock(&sessionlock);
01479       s->next = sessions;
01480       sessions = s;
01481       ast_mutex_unlock(&sessionlock);
01482       if (ast_pthread_create(&s->t, &attr, session_do, s))
01483          destroy_session(s);
01484    }
01485    pthread_attr_destroy(&attr);
01486    return NULL;
01487 }

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

action_command: Manager command "command" - execute CLI command

Definition at line 926 of file manager.c.

References ast_cli(), ast_cli_command(), ast_strlen_zero(), astman_get_header(), and mansession::fd.

Referenced by init_manager().

00927 {
00928    char *cmd = astman_get_header(m, "Command");
00929    char *id = astman_get_header(m, "ActionID");
00930    ast_cli(s->fd, "Response: Follows\r\nPrivilege: Command\r\n");
00931    if (!ast_strlen_zero(id))
00932       ast_cli(s->fd, "ActionID: %s\r\n", id);
00933    /* FIXME: Wedge a ActionID response in here, waiting for later changes */
00934    ast_cli_command(s->fd, cmd);
00935    ast_cli(s->fd, "--END COMMAND--\r\n\r\n");
00936    return 0;
00937 }

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

Definition at line 628 of file manager.c.

References astman_get_header(), astman_send_response(), and set_eventmask().

Referenced by init_manager().

00629 {
00630    char *mask = astman_get_header(m, "EventMask");
00631    int res;
00632 
00633    res = set_eventmask(s, mask);
00634    if (res > 0)
00635       astman_send_response(s, m, "Events On", NULL);
00636    else if (res == 0)
00637       astman_send_response(s, m, "Events Off", NULL);
00638 
00639    return 0;
00640 }

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

Definition at line 1187 of file manager.c.

References ast_cli(), ast_extension_state(), ast_get_hint(), ast_strlen_zero(), astman_get_header(), astman_send_error(), context, exten, and mansession::fd.

Referenced by init_manager().

01188 {
01189    char *exten = astman_get_header(m, "Exten");
01190    char *context = astman_get_header(m, "Context");
01191    char *id = astman_get_header(m,"ActionID");
01192    char idText[256] = "";
01193    char hint[256] = "";
01194    int status;
01195    if (ast_strlen_zero(exten)) {
01196       astman_send_error(s, m, "Extension not specified");
01197       return 0;
01198    }
01199    if (ast_strlen_zero(context))
01200       context = "default";
01201    status = ast_extension_state(NULL, context, exten);
01202    ast_get_hint(hint, sizeof(hint) - 1, NULL, 0, NULL, context, exten);
01203         if (!ast_strlen_zero(id)) {
01204                 snprintf(idText,256,"ActionID: %s\r\n",id);
01205         }
01206    ast_cli(s->fd, "Response: Success\r\n"
01207                     "%s"
01208                "Message: Extension Status\r\n"
01209                "Exten: %s\r\n"
01210                "Context: %s\r\n"
01211                "Hint: %s\r\n"
01212                "Status: %d\r\n\r\n",
01213                idText,exten, context, hint, status);
01214    return 0;
01215 }

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

Definition at line 720 of file manager.c.

References ast_cli(), ast_get_channel_by_name_locked(), ast_mutex_unlock(), ast_strdupa, ast_strlen_zero(), astman_get_header(), astman_send_error(), mansession::fd, ast_channel::lock, name, and pbx_builtin_getvar_helper().

Referenced by init_manager().

00721 {
00722         struct ast_channel *c = NULL;
00723         char *name = astman_get_header(m, "Channel");
00724         char *varname = astman_get_header(m, "Variable");
00725    char *id = astman_get_header(m,"ActionID");
00726    char *varval;
00727    char *varval2=NULL;
00728 
00729    if (!strlen(varname)) {
00730       astman_send_error(s, m, "No variable specified");
00731       return 0;
00732    }
00733 
00734    if (strlen(name)) {
00735       c = ast_get_channel_by_name_locked(name);
00736       if (!c) {
00737          astman_send_error(s, m, "No such channel");
00738          return 0;
00739       }
00740    }
00741    
00742    varval=pbx_builtin_getvar_helper(c,varname);
00743    if (varval)
00744       varval2 = ast_strdupa(varval);
00745    if (!varval2)
00746       varval2 = "";
00747    if (c)
00748       ast_mutex_unlock(&c->lock);
00749    ast_cli(s->fd, "Response: Success\r\n"
00750       "Variable: %s\r\nValue: %s\r\n" ,varname,varval2);
00751    if (!ast_strlen_zero(id))
00752       ast_cli(s->fd, "ActionID: %s\r\n",id);
00753    ast_cli(s->fd, "\r\n");
00754 
00755    return 0;
00756 }

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

Definition at line 657 of file manager.c.

References ast_get_channel_by_name_locked(), ast_mutex_unlock(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), ast_channel::lock, and name.

Referenced by init_manager().

00658 {
00659    struct ast_channel *c = NULL;
00660    char *name = astman_get_header(m, "Channel");
00661    if (ast_strlen_zero(name)) {
00662       astman_send_error(s, m, "No channel specified");
00663       return 0;
00664    }
00665    c = ast_get_channel_by_name_locked(name);
00666    if (!c) {
00667       astman_send_error(s, m, "No such channel");
00668       return 0;
00669    }
00670    ast_softhangup(c, AST_SOFTHANGUP_EXPLICIT);
00671    ast_mutex_unlock(&c->lock);
00672    astman_send_ack(s, m, "Channel Hungup");
00673    return 0;
00674 }

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

Definition at line 598 of file manager.c.

References manager_action::action, ast_cli(), ast_mutex_lock(), ast_mutex_unlock(), ast_strlen_zero(), astman_get_header(), manager_action::authority, authority_to_str(), mansession::fd, manager_action::next, manager_action::synopsis, and mansession::writeperm.

Referenced by init_manager().

00599 {
00600    struct manager_action *cur = first_action;
00601    char idText[256] = "";
00602    char temp[BUFSIZ];
00603    char *id = astman_get_header(m,"ActionID");
00604 
00605    if (!ast_strlen_zero(id))
00606       snprintf(idText,256,"ActionID: %s\r\n",id);
00607    ast_cli(s->fd, "Response: Success\r\n%s", idText);
00608    ast_mutex_lock(&actionlock);
00609    while (cur) { /* Walk the list of actions */
00610       if ((s->writeperm & cur->authority) == cur->authority)
00611          ast_cli(s->fd, "%s: %s (Priv: %s)\r\n", cur->action, cur->synopsis, authority_to_str(cur->authority, temp, sizeof(temp)) );
00612       cur = cur->next;
00613    }
00614    ast_mutex_unlock(&actionlock);
00615    ast_cli(s->fd, "\r\n");
00616 
00617    return 0;
00618 }

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

Definition at line 646 of file manager.c.

References astman_send_response().

Referenced by init_manager().

00647 {
00648    astman_send_response(s, m, "Goodbye", "Thanks for all the fish.");
00649    return -1;
00650 }

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

Definition at line 1151 of file manager.c.

References ast_app_messagecount(), ast_cli(), ast_strlen_zero(), astman_get_header(), astman_send_error(), mansession::fd, and mailbox.

Referenced by init_manager().

01152 {
01153    char *mailbox = astman_get_header(m, "Mailbox");
01154    char *id = astman_get_header(m,"ActionID");
01155    char idText[256] = "";
01156    int newmsgs = 0, oldmsgs = 0;
01157    if (ast_strlen_zero(mailbox)) {
01158       astman_send_error(s, m, "Mailbox not specified");
01159       return 0;
01160    }
01161    ast_app_messagecount(mailbox, &newmsgs, &oldmsgs);
01162    if (!ast_strlen_zero(id)) {
01163       snprintf(idText,256,"ActionID: %s\r\n",id);
01164    }
01165    ast_cli(s->fd, "Response: Success\r\n"
01166                "%s"
01167                "Message: Mailbox Message Count\r\n"
01168                "Mailbox: %s\r\n"
01169                "NewMessages: %d\r\n"
01170                "OldMessages: %d\r\n" 
01171                "\r\n",
01172                 idText,mailbox, newmsgs, oldmsgs);
01173    return 0;
01174 }

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

Definition at line 1119 of file manager.c.

References ast_app_has_voicemail(), ast_cli(), ast_strlen_zero(), astman_get_header(), astman_send_error(), mansession::fd, and mailbox.

Referenced by init_manager().

01120 {
01121    char *mailbox = astman_get_header(m, "Mailbox");
01122    char *id = astman_get_header(m,"ActionID");
01123    char idText[256] = "";
01124    int ret;
01125    if (ast_strlen_zero(mailbox)) {
01126       astman_send_error(s, m, "Mailbox not specified");
01127       return 0;
01128    }
01129         if (!ast_strlen_zero(id))
01130                 snprintf(idText,256,"ActionID: %s\r\n",id);
01131    ret = ast_app_has_voicemail(mailbox, NULL);
01132    ast_cli(s->fd, "Response: Success\r\n"
01133                "%s"
01134                "Message: Mailbox Status\r\n"
01135                "Mailbox: %s\r\n"
01136                "Waiting: %d\r\n\r\n", idText, mailbox, ret);
01137    return 0;
01138 }

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

Definition at line 1001 of file manager.c.

References fast_originate_helper::account, fast_originate_helper::app, app, fast_originate_helper::appdata, ast_callerid_parse(), AST_FORMAT_SLINEAR, 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(), fast_originate_helper::cid_name, fast_originate_helper::cid_num, fast_originate_helper::context, context, fast_originate_helper::data, fast_originate_helper::exten, exten, fast_originate(), fast_originate_helper::idtext, malloc, n, name, fast_originate_helper::priority, ast_channel::priority, fast_originate_helper::tech, fast_originate_helper::timeout, and fast_originate_helper::vars.

Referenced by init_manager().

01002 {
01003    char *name = astman_get_header(m, "Channel");
01004    char *exten = astman_get_header(m, "Exten");
01005    char *context = astman_get_header(m, "Context");
01006    char *priority = astman_get_header(m, "Priority");
01007    char *timeout = astman_get_header(m, "Timeout");
01008    char *callerid = astman_get_header(m, "CallerID");
01009    char *account = astman_get_header(m, "Account");
01010    char *app = astman_get_header(m, "Application");
01011    char *appdata = astman_get_header(m, "Data");
01012    char *async = astman_get_header(m, "Async");
01013    char *id = astman_get_header(m, "ActionID");
01014    struct ast_variable *vars = astman_get_variables(m);
01015    char *tech, *data;
01016    char *l=NULL, *n=NULL;
01017    int pi = 0;
01018    int res;
01019    int to = 30000;
01020    int reason = 0;
01021    char tmp[256];
01022    char tmp2[256];
01023    
01024    pthread_t th;
01025    pthread_attr_t attr;
01026    if (!name) {
01027       astman_send_error(s, m, "Channel not specified");
01028       return 0;
01029    }
01030    if (!ast_strlen_zero(priority) && (sscanf(priority, "%30d", &pi) != 1)) {
01031       astman_send_error(s, m, "Invalid priority\n");
01032       return 0;
01033    }
01034    if (!ast_strlen_zero(timeout) && (sscanf(timeout, "%30d", &to) != 1)) {
01035       astman_send_error(s, m, "Invalid timeout\n");
01036       return 0;
01037    }
01038    ast_copy_string(tmp, name, sizeof(tmp));
01039    tech = tmp;
01040    data = strchr(tmp, '/');
01041    if (!data) {
01042       astman_send_error(s, m, "Invalid channel\n");
01043       return 0;
01044    }
01045    *data = '\0';
01046    data++;
01047    ast_copy_string(tmp2, callerid, sizeof(tmp2));
01048    ast_callerid_parse(tmp2, &n, &l);
01049    if (n) {
01050       if (ast_strlen_zero(n))
01051          n = NULL;
01052    }
01053    if (l) {
01054       ast_shrink_phone_number(l);
01055       if (ast_strlen_zero(l))
01056          l = NULL;
01057    }
01058    if (ast_true(async)) {
01059       struct fast_originate_helper *fast = malloc(sizeof(struct fast_originate_helper));
01060       if (!fast) {
01061          res = -1;
01062       } else {
01063          memset(fast, 0, sizeof(struct fast_originate_helper));
01064          if (!ast_strlen_zero(id))
01065             snprintf(fast->idtext, sizeof(fast->idtext), "ActionID: %s\r\n", id);
01066          ast_copy_string(fast->tech, tech, sizeof(fast->tech));
01067             ast_copy_string(fast->data, data, sizeof(fast->data));
01068          ast_copy_string(fast->app, app, sizeof(fast->app));
01069          ast_copy_string(fast->appdata, appdata, sizeof(fast->appdata));
01070          if (l)
01071             ast_copy_string(fast->cid_num, l, sizeof(fast->cid_num));
01072          if (n)
01073             ast_copy_string(fast->cid_name, n, sizeof(fast->cid_name));
01074          fast->vars = vars;   
01075          ast_copy_string(fast->context, context, sizeof(fast->context));
01076          ast_copy_string(fast->exten, exten, sizeof(fast->exten));
01077          ast_copy_string(fast->account, account, sizeof(fast->account));
01078          fast->timeout = to;
01079          fast->priority = pi;
01080          pthread_attr_init(&attr);
01081          pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
01082          if (ast_pthread_create(&th, &attr, fast_originate, fast)) {
01083             res = -1;
01084          } else {
01085             res = 0;
01086          }
01087          pthread_attr_destroy(&attr);
01088       }
01089    } else if (!ast_strlen_zero(app)) {
01090          res = ast_pbx_outgoing_app(tech, AST_FORMAT_SLINEAR, data, to, app, appdata, &reason, 1, l, n, vars, account, NULL);
01091       } else {
01092       if (exten && context && pi)
01093             res = ast_pbx_outgoing_exten(tech, AST_FORMAT_SLINEAR, data, to, context, exten, pi, &reason, 1, l, n, vars, account, NULL);
01094       else {
01095          astman_send_error(s, m, "Originate with 'Exten' requires 'Context' and 'Priority'");
01096          return 0;
01097       }
01098    }   
01099    if (!res)
01100       astman_send_ack(s, m, "Originate successfully queued");
01101    else
01102       astman_send_error(s, m, "Originate failed");
01103    return 0;
01104 }

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

Definition at line 587 of file manager.c.

References astman_send_response().

Referenced by init_manager().

00588 {
00589    astman_send_response(s, m, "Pong", NULL);
00590    return 0;
00591 }

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

action_redirect: The redirect manager command

Definition at line 858 of file manager.c.

References ast_async_goto(), ast_check_hangup(), ast_get_channel_by_name_locked(), ast_mutex_unlock(), ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), context, exten, ast_channel::lock, and name.

Referenced by init_manager().

00859 {
00860    char *name = astman_get_header(m, "Channel");
00861    char *name2 = astman_get_header(m, "ExtraChannel");
00862    char *exten = astman_get_header(m, "Exten");
00863    char *context = astman_get_header(m, "Context");
00864    char *priority = astman_get_header(m, "Priority");
00865    struct ast_channel *chan, *chan2 = NULL;
00866    int pi = 0;
00867    int res;
00868 
00869    if (ast_strlen_zero(name)) {
00870       astman_send_error(s, m, "Channel not specified");
00871       return 0;
00872    }
00873    if (!ast_strlen_zero(priority) && (sscanf(priority, "%30d", &pi) != 1)) {
00874       astman_send_error(s, m, "Invalid priority\n");
00875       return 0;
00876    }
00877    chan = ast_get_channel_by_name_locked(name);
00878    if (!chan) {
00879       char buf[BUFSIZ];
00880       snprintf(buf, sizeof(buf), "Channel does not exist: %s", name);
00881       astman_send_error(s, m, buf);
00882       return 0;
00883    }
00884    if (ast_check_hangup(chan)) {
00885       astman_send_error(s, m, "Redirect failed, channel hung up.\n");
00886       ast_mutex_unlock(&chan->lock);
00887       return 0;
00888    }
00889    if (!ast_strlen_zero(name2))
00890       chan2 = ast_get_channel_by_name_locked(name2);
00891    if (chan2 && ast_check_hangup(chan2)) {
00892       astman_send_error(s, m, "Redirect failed, extra channel hung up.\n");
00893       ast_mutex_unlock(&chan->lock);
00894       ast_mutex_unlock(&chan2->lock);
00895       return 0;
00896    }
00897    res = ast_async_goto(chan, context, exten, pi);
00898    if (!res) {
00899       if (!ast_strlen_zero(name2)) {
00900          if (chan2)
00901             res = ast_async_goto(chan2, context, exten, pi);
00902          else
00903             res = -1;
00904          if (!res)
00905             astman_send_ack(s, m, "Dual Redirect successful");
00906          else
00907             astman_send_error(s, m, "Secondary redirect failed");
00908       } else
00909          astman_send_ack(s, m, "Redirect successful");
00910    } else
00911       astman_send_error(s, m, "Redirect failed");
00912    if (chan)
00913       ast_mutex_unlock(&chan->lock);
00914    if (chan2)
00915       ast_mutex_unlock(&chan2->lock);
00916    return 0;
00917 }

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

Definition at line 683 of file manager.c.

References ast_get_channel_by_name_locked(), ast_mutex_unlock(), ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), ast_channel::lock, name, and pbx_builtin_setvar_helper().

Referenced by init_manager().

00684 {
00685         struct ast_channel *c = NULL;
00686         char *name = astman_get_header(m, "Channel");
00687         char *varname = astman_get_header(m, "Variable");
00688         char *varval = astman_get_header(m, "Value");
00689    
00690    if (ast_strlen_zero(varname)) {
00691       astman_send_error(s, m, "No variable specified");
00692       return 0;
00693    }
00694    
00695    if (!ast_strlen_zero(name)) {
00696       c = ast_get_channel_by_name_locked(name);
00697       if (!c) {
00698          astman_send_error(s, m, "No such channel");
00699          return 0;
00700       }
00701    }
00702    
00703    pbx_builtin_setvar_helper(c, varname, varval ? varval : "");
00704      
00705    if (c)
00706       ast_mutex_unlock(&c->lock);
00707 
00708    astman_send_ack(s, m, "Variable Set"); 
00709 
00710    return 0;
00711 }

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

action_status: Manager "status" command to show channels

Definition at line 761 of file manager.c.

References ast_channel::_bridge, ast_channel::_state, ast_channel::accountcode, ast_channel_walk_locked(), ast_cli(), ast_get_channel_by_name_locked(), ast_mutex_unlock(), ast_state2str(), ast_strlen_zero(), 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, mansession::fd, ast_channel::lock, ast_channel::name, name, ast_channel::pbx, ast_channel::priority, ast_cdr::start, and ast_channel::uniqueid.

Referenced by init_manager().

00762 {
00763    char *id = astman_get_header(m,"ActionID");
00764       char *name = astman_get_header(m,"Channel");
00765    char idText[256] = "";
00766    struct ast_channel *c;
00767    char bridge[256];
00768    struct timeval now = ast_tvnow();
00769    long elapsed_seconds=0;
00770    int all = ast_strlen_zero(name); /* set if we want all channels */
00771 
00772         if (!ast_strlen_zero(id))
00773                 snprintf(idText,256,"ActionID: %s\r\n",id);
00774    if (all)
00775       c = ast_channel_walk_locked(NULL);
00776    else {
00777       c = ast_get_channel_by_name_locked(name);
00778       if (!c) {
00779          astman_send_error(s, m, "No such channel");
00780          return 0;
00781       }
00782    }
00783    astman_send_ack(s, m, "Channel status will follow");
00784    /* if we look by name, we break after the first iteration */
00785    while(c) {
00786       if (c->_bridge)
00787          snprintf(bridge, sizeof(bridge), "Link: %s\r\n", c->_bridge->name);
00788       else
00789          bridge[0] = '\0';
00790       if (c->pbx) {
00791          if (c->cdr) {
00792             elapsed_seconds = now.tv_sec - c->cdr->start.tv_sec;
00793          }
00794          ast_cli(s->fd,
00795          "Event: Status\r\n"
00796          "Privilege: Call\r\n"
00797          "Channel: %s\r\n"
00798          "CallerID: %s\r\n"
00799          "CallerIDName: %s\r\n"
00800          "Account: %s\r\n"
00801          "State: %s\r\n"
00802          "Context: %s\r\n"
00803          "Extension: %s\r\n"
00804          "Priority: %d\r\n"
00805          "Seconds: %ld\r\n"
00806          "%s"
00807          "Uniqueid: %s\r\n"
00808          "%s"
00809          "\r\n",
00810          c->name, 
00811          c->cid.cid_num ? c->cid.cid_num : "<unknown>", 
00812          c->cid.cid_name ? c->cid.cid_name : "<unknown>", 
00813          c->accountcode,
00814          ast_state2str(c->_state), c->context,
00815          c->exten, c->priority, (long)elapsed_seconds, bridge, c->uniqueid, idText);
00816       } else {
00817          ast_cli(s->fd,
00818          "Event: Status\r\n"
00819          "Privilege: Call\r\n"
00820          "Channel: %s\r\n"
00821          "CallerID: %s\r\n"
00822          "CallerIDName: %s\r\n"
00823          "Account: %s\r\n"
00824          "State: %s\r\n"
00825          "%s"
00826          "Uniqueid: %s\r\n"
00827          "%s"
00828          "\r\n",
00829          c->name, 
00830          c->cid.cid_num ? c->cid.cid_num : "<unknown>", 
00831          c->cid.cid_name ? c->cid.cid_name : "<unknown>", 
00832          c->accountcode,
00833          ast_state2str(c->_state), bridge, c->uniqueid, idText);
00834       }
00835       ast_mutex_unlock(&c->lock);
00836       if (!all)
00837          break;
00838       c = ast_channel_walk_locked(c);
00839    }
00840    ast_cli(s->fd,
00841    "Event: StatusComplete\r\n"
00842    "%s"
00843    "\r\n",idText);
00844    return 0;
00845 }

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

Definition at line 1224 of file manager.c.

References ast_channel_setwhentohangup(), ast_get_channel_by_name_locked(), ast_mutex_unlock(), ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), ast_channel::lock, and name.

Referenced by init_manager().

01225 {
01226    struct ast_channel *c = NULL;
01227    char *name = astman_get_header(m, "Channel");
01228    int timeout = atoi(astman_get_header(m, "Timeout"));
01229    if (ast_strlen_zero(name)) {
01230       astman_send_error(s, m, "No channel specified");
01231       return 0;
01232    }
01233    if (!timeout) {
01234       astman_send_error(s, m, "No timeout specified");
01235       return 0;
01236    }
01237    c = ast_get_channel_by_name_locked(name);
01238    if (!c) {
01239       astman_send_error(s, m, "No such channel");
01240       return 0;
01241    }
01242    ast_channel_setwhentohangup(c, timeout);
01243    ast_mutex_unlock(&c->lock);
01244    astman_send_ack(s, m, "Timeout Set");
01245    return 0;
01246 }

static int append_event ( struct mansession s,
const char *  str 
) [static]

Definition at line 1489 of file manager.c.

References eventqent::eventdata, mansession::eventq, malloc, and eventqent::next.

Referenced by manager_event().

01490 {
01491    struct eventqent *tmp, *prev=NULL;
01492    tmp = malloc(sizeof(struct eventqent) + strlen(str));
01493    if (tmp) {
01494       tmp->next = NULL;
01495       strcpy(tmp->eventdata, str);
01496       if (s->eventq) {
01497          prev = s->eventq;
01498          while(prev->next) 
01499             prev = prev->next;
01500          prev->next = tmp;
01501       } else {
01502          s->eventq = tmp;
01503       }
01504       return 0;
01505    }
01506    return -1;
01507 }

int ast_carefulwrite ( int  fd,
char *  s,
int  len,
int  timeoutms 
)

If you are calling ast_carefulwrite, it is assumed that you are calling it on a file descriptor that _DOES_ have NONBLOCK set. This way, there is only one system call made to do a write, unless we actually have a need to wait. This way, we get better performance.

Definition at line 114 of file manager.c.

References pollfd::events, pollfd::fd, poll(), and POLLOUT.

Referenced by agi_debug_cli(), ast_cli(), manager_event(), and process_message().

00115 {
00116    /* Try to write string, but wait no more than ms milliseconds
00117       before timing out */
00118    int res=0;
00119    struct pollfd fds[1];
00120    while(len) {
00121       res = write(fd, s, len);
00122       if ((res < 0) && (errno != EAGAIN)) {
00123          return -1;
00124       }
00125       if (res < 0) res = 0;
00126       len -= res;
00127       s += res;
00128       res = 0;
00129       if (len) {
00130          fds[0].fd = fd;
00131          fds[0].events = POLLOUT;
00132          /* Wait until writable again */
00133          res = poll(fds, 1, timeoutms);
00134          if (res < 1)
00135             return -1;
00136       }
00137    }
00138    return res;
00139 }

static int ast_instring ( char *  bigstr,
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 395 of file manager.c.

References ast_variable::next.

Referenced by ast_strings_to_mask(), and get_perm().

00396 {
00397    char *val = bigstr, *next;
00398 
00399    do {
00400       if ((next = strchr(val, delim))) {
00401          if (!strncmp(val, smallstr, (next - val)))
00402             return 1;
00403          else
00404             continue;
00405       } else
00406          return !strcmp(smallstr, val);
00407 
00408    } while (*(val = (next + 1)));
00409 
00410    return 0;
00411 }

static int ast_is_number ( char *  string  )  [static]

Definition at line 427 of file manager.c.

Referenced by ast_strings_to_mask().

00428 {
00429    int ret = 1, x = 0;
00430 
00431    if (!string)
00432       return 0;
00433 
00434    for (x=0; x < strlen(string); x++) {
00435       if (!(string[x] >= 48 && string[x] <= 57)) {
00436          ret = 0;
00437          break;
00438       }
00439    }
00440    
00441    return ret ? atoi(string) : 0;
00442 }

int ast_manager_register2 ( const char *  action,
int  authority,
int(*)(struct mansession *s, 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

Register a manager command with the manager interface

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

References manager_action::action, ast_log(), ast_manager_register_struct(), manager_action::authority, manager_action::description, manager_action::func, LOG_WARNING, malloc, manager_action::next, and manager_action::synopsis.

Referenced by init_manager(), and load_module().

01627 {
01628    struct manager_action *cur;
01629 
01630    cur = malloc(sizeof(struct manager_action));
01631    if (!cur) {
01632       ast_log(LOG_WARNING, "Manager: out of memory trying to register action\n");
01633       return -1;
01634    }
01635    cur->action = action;
01636    cur->authority = auth;
01637    cur->func = func;
01638    cur->synopsis = synopsis;
01639    cur->description = description;
01640    cur->next = NULL;
01641 
01642    ast_manager_register_struct(cur);
01643 
01644    return 0;
01645 }

static int ast_manager_register_struct ( struct manager_action act  )  [static]

Definition at line 1583 of file manager.c.

References manager_action::action, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_verbose(), LOG_WARNING, manager_action::next, option_verbose, and VERBOSE_PREFIX_2.

Referenced by ast_manager_register2().

01584 {
01585    struct manager_action *cur = first_action, *prev = NULL;
01586    int ret;
01587 
01588    ast_mutex_lock(&actionlock);
01589    while(cur) { /* Walk the list of actions */
01590       ret = strcasecmp(cur->action, act->action);
01591       if (ret == 0) {
01592          ast_log(LOG_WARNING, "Manager: Action '%s' already registered\n", act->action);
01593          ast_mutex_unlock(&actionlock);
01594          return -1;
01595       } else if (ret > 0) {
01596          /* Insert these alphabetically */
01597          if (prev) {
01598             act->next = prev->next;
01599             prev->next = act;
01600          } else {
01601             act->next = first_action;
01602             first_action = act;
01603          }
01604          break;
01605       }
01606       prev = cur; 
01607       cur = cur->next;
01608    }
01609    
01610    if (!cur) {
01611       if (prev)
01612          prev->next = act;
01613       else
01614          first_action = act;
01615       act->next = NULL;
01616    }
01617 
01618    if (option_verbose > 1) 
01619       ast_verbose(VERBOSE_PREFIX_2 "Manager registered action %s\n", act->action);
01620    ast_mutex_unlock(&actionlock);
01621    return 0;
01622 }

int ast_manager_unregister ( char *  action  ) 

Unregister a registred manager command

Parameters:
action Name of registred Action:

Definition at line 1555 of file manager.c.

References manager_action::action, ast_mutex_lock(), ast_mutex_unlock(), ast_verbose(), free, manager_action::next, option_verbose, and VERBOSE_PREFIX_2.

Referenced by __unload_module(), and unload_module().

01556 {
01557    struct manager_action *cur = first_action, *prev = first_action;
01558 
01559    ast_mutex_lock(&actionlock);
01560    while( cur ) {       
01561       if (!strcasecmp(action, cur->action)) {
01562          prev->next = cur->next;
01563          free(cur);
01564          if (option_verbose > 1) 
01565             ast_verbose(VERBOSE_PREFIX_2 "Manager unregistered action %s\n", action);
01566          ast_mutex_unlock(&actionlock);
01567          return 0;
01568       }
01569       prev = cur;
01570       cur = cur->next;
01571    }
01572    ast_mutex_unlock(&actionlock);
01573    return 0;
01574 }

AST_MUTEX_DEFINE_STATIC ( actionlock   ) 

AST_MUTEX_DEFINE_STATIC ( sessionlock   ) 

static int ast_strings_to_mask ( char *  string  )  [static]

Definition at line 444 of file manager.c.

References ast_false(), ast_instring(), ast_is_number(), ast_strlen_zero(), ast_true(), and perms.

Referenced by set_eventmask().

00445 {
00446    int x, ret = -1;
00447    
00448    x = ast_is_number(string);
00449 
00450    if (x) {
00451       ret = x;
00452    } else if (ast_strlen_zero(string)) {
00453       ret = -1;
00454    } else if (ast_false(string)) {
00455       ret = 0;
00456    } else if (ast_true(string)) {
00457       ret = 0;
00458       for (x=0; x<sizeof(perms) / sizeof(perms[0]); x++)
00459          ret |= perms[x].num;    
00460    } else {
00461       ret = 0;
00462       for (x=0; x<sizeof(perms) / sizeof(perms[0]); x++) {
00463          if (ast_instring(string, perms[x].label, ',')) 
00464             ret |= perms[x].num;    
00465       }
00466    }
00467 
00468    return ret;
00469 }

char* astman_get_header ( struct message m,
char *  var 
)

struct ast_variable* astman_get_variables ( struct message m  )  [read]

Get a linked list of the Variable: headers

Definition at line 316 of file manager.c.

References ast_app_separate_args(), ast_strdupa, ast_strlen_zero(), ast_variable_new(), message::hdrcount, message::headers, strsep(), and var.

Referenced by action_originate().

00317 {
00318    int varlen, x, y;
00319    struct ast_variable *head = NULL, *cur;
00320    char *var, *val;
00321    unsigned int var_count;
00322         char *vars[32];
00323    
00324    varlen = strlen("Variable: ");   
00325 
00326    for (x = 0; x < m->hdrcount; x++) {
00327       if (strncasecmp("Variable: ", m->headers[x], varlen))
00328          continue;
00329 
00330       if (!(var = ast_strdupa(m->headers[x] + varlen)))
00331          return head;
00332 
00333       if ((var_count = ast_app_separate_args(var, '|', vars, sizeof(vars) / sizeof(vars[0])))) {
00334          for (y = 0; y < var_count; y++) {
00335             if (!vars[y])
00336                continue;
00337             var = val = ast_strdupa(vars[y]);
00338             strsep(&val, "=");
00339             if (!val || ast_strlen_zero(var))
00340                continue;
00341             cur = ast_variable_new(var, val);
00342             if (head) {
00343                cur->next = head;
00344                head = cur;
00345             } else
00346                head = cur;
00347          }
00348       }
00349    }
00350 
00351    return head;
00352 }

void astman_send_ack ( struct mansession s,
struct message m,
char *  msg 
)

void astman_send_error ( struct mansession s,
struct message m,
char *  error 
)

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

References ast_cli(), ast_strlen_zero(), astman_get_header(), and mansession::fd.

Referenced by _sip_show_peer(), action_agent_callback_login(), action_agent_logoff(), action_extensionstate(), action_getvar(), action_hangup(), action_mailboxcount(), action_mailboxstatus(), action_originate(), action_redirect(), action_setcdruserfield(), action_setvar(), action_status(), action_timeout(), action_transfer(), action_transferhangup(), action_zapdialoffhook(), action_zapdndoff(), action_zapdndon(), change_monitor_action(), manager_add_queue_member(), manager_dbget(), manager_dbput(), manager_pause_queue_member(), manager_remove_queue_member(), manager_sip_show_peer(), process_message(), start_monitor_action(), and stop_monitor_action().

00363 {
00364    char *id = astman_get_header(m,"ActionID");
00365 
00366    ast_cli(s->fd, "Response: Error\r\n");
00367    if (!ast_strlen_zero(id))
00368       ast_cli(s->fd, "ActionID: %s\r\n",id);
00369    ast_cli(s->fd, "Message: %s\r\n\r\n", error);
00370 }

void astman_send_response ( struct mansession s,
struct message m,
char *  resp,
char *  msg 
)

Definition at line 372 of file manager.c.

References ast_cli(), ast_strlen_zero(), astman_get_header(), and mansession::fd.

Referenced by action_events(), action_logoff(), action_ping(), and astman_send_ack().

00373 {
00374    char *id = astman_get_header(m,"ActionID");
00375 
00376    ast_cli(s->fd, "Response: %s\r\n", resp);
00377    if (!ast_strlen_zero(id))
00378       ast_cli(s->fd, "ActionID: %s\r\n",id);
00379    if (msg)
00380       ast_cli(s->fd, "Message: %s\r\n\r\n", msg);
00381    else
00382       ast_cli(s->fd, "\r\n");
00383 }

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

Definition at line 488 of file manager.c.

References ast_append_ha(), ast_apply_ha(), ast_category_browse(), ast_config_destroy(), ast_config_load(), ast_free_ha(), ast_inet_ntoa(), ast_log(), ast_strlen_zero(), ast_variable_browse(), ast_variable_retrieve(), astman_get_header(), cfg, mansession::challenge, events, get_perm(), key(), ast_variable::lineno, LOG_NOTICE, LOG_WARNING, MD5Final(), MD5Init(), MD5Update(), ast_variable::name, ast_variable::next, pass, password, mansession::readperm, set_eventmask(), mansession::sin, user, mansession::username, ast_variable::value, mansession::writeperm, and mansession::writetimeout.

Referenced by authenticate_reply(), handle_response_invite(), process_message(), and registry_rerequest().

00489 {
00490    struct ast_config *cfg;
00491    char iabuf[INET_ADDRSTRLEN];
00492    char *cat;
00493    char *user = astman_get_header(m, "Username");
00494    char *pass = astman_get_header(m, "Secret");
00495    char *authtype = astman_get_header(m, "AuthType");
00496    char *key = astman_get_header(m, "Key");
00497    char *events = astman_get_header(m, "Events");
00498    
00499    cfg = ast_config_load("manager.conf");
00500    if (!cfg)
00501       return -1;
00502    cat = ast_category_browse(cfg, NULL);
00503    while(cat) {
00504       if (strcasecmp(cat, "general")) {
00505          /* This is a user */
00506          if (!strcasecmp(cat, user)) {
00507             struct ast_variable *v;
00508             struct ast_ha *ha = NULL;
00509             char *password = NULL;
00510             v = ast_variable_browse(cfg, cat);
00511             while (v) {
00512                if (!strcasecmp(v->name, "secret")) {
00513                   password = v->value;
00514                } else if (!strcasecmp(v->name, "permit") ||
00515                      !strcasecmp(v->name, "deny")) {
00516                   ha = ast_append_ha(v->name, v->value, ha);
00517                } else if (!strcasecmp(v->name, "writetimeout")) {
00518                   int val = atoi(v->value);
00519 
00520                   if (val < 100)
00521                      ast_log(LOG_WARNING, "Invalid writetimeout value '%s' at line %d\n", v->value, v->lineno);
00522                   else
00523                      s->writetimeout = val;
00524                }
00525                      
00526                v = v->next;
00527             }
00528             if (ha && !ast_apply_ha(ha, &(s->sin))) {
00529                ast_log(LOG_NOTICE, "%s failed to pass IP ACL as '%s'\n", ast_inet_ntoa(iabuf, sizeof(iabuf), s->sin.sin_addr), user);
00530                ast_free_ha(ha);
00531                ast_config_destroy(cfg);
00532                return -1;
00533             } else if (ha)
00534                ast_free_ha(ha);
00535             if (!strcasecmp(authtype, "MD5")) {
00536                if (!ast_strlen_zero(key) && 
00537                    !ast_strlen_zero(s->challenge) && !ast_strlen_zero(password)) {
00538                   int x;
00539                   int len=0;
00540                   char md5key[256] = "";
00541                   struct MD5Context md5;
00542                   unsigned char digest[16];
00543                   MD5Init(&md5);
00544                   MD5Update(&md5, (unsigned char *) s->challenge, strlen(s->challenge));
00545                   MD5Update(&md5, (unsigned char *) password, strlen(password));
00546                   MD5Final(digest, &md5);
00547                   for (x=0;x<16;x++)
00548                      len += sprintf(md5key + len, "%2.2x", digest[x]);
00549                   if (!strcmp(md5key, key))
00550                      break;
00551                   else {
00552                      ast_config_destroy(cfg);
00553                      return -1;
00554                   }
00555                }
00556             } else if (password && !strcasecmp(password, pass)) {
00557                break;
00558             } else {
00559                ast_log(LOG_NOTICE, "%s failed to authenticate as '%s'\n", ast_inet_ntoa(iabuf, sizeof(iabuf), s->sin.sin_addr), user);
00560                ast_config_destroy(cfg);
00561                return -1;
00562             }  
00563          }
00564       }
00565       cat = ast_category_browse(cfg, cat);
00566    }
00567    if (cat) {
00568       ast_copy_string(s->username, cat, sizeof(s->username));
00569       s->readperm = get_perm(ast_variable_retrieve(cfg, cat, "read"));
00570       s->writeperm = get_perm(ast_variable_retrieve(cfg, cat, "write"));
00571       ast_config_destroy(cfg);
00572       if (events)
00573          set_eventmask(s, events);
00574       return 0;
00575    }
00576    ast_log(LOG_NOTICE, "%s tried to authenticate with nonexistent user '%s'\n", ast_inet_ntoa(iabuf, sizeof(iabuf), s->sin.sin_addr), user);
00577    ast_config_destroy(cfg);
00578    return -1;
00579 }

static char* authority_to_str ( int  authority,
char *  res,
int  reslen 
) [static]

authority_to_str: Convert authority code to string with serveral options

Definition at line 142 of file manager.c.

References ast_strlen_zero(), and perms.

Referenced by action_listcommands(), handle_showmancmd(), handle_showmancmds(), and manager_event().

00143 {
00144    int running_total = 0, i;
00145    memset(res, 0, reslen);
00146    for (i=0; i<sizeof(perms) / sizeof(perms[0]) - 1; i++) {
00147       if (authority & perms[i].num) {
00148          if (*res) {
00149             strncat(res, ",", (reslen > running_total) ? reslen - running_total : 0);
00150             running_total++;
00151          }
00152          strncat(res, perms[i].label, (reslen > running_total) ? reslen - running_total : 0);
00153          running_total += strlen(perms[i].label);
00154       }
00155    }
00156    if (ast_strlen_zero(res)) {
00157       ast_copy_string(res, "<none>", reslen);
00158    }
00159    return res;
00160 }

static char* complete_show_mancmd ( char *  line,
char *  word,
int  pos,
int  state 
) [static]

Definition at line 162 of file manager.c.

References manager_action::action, ast_mutex_lock(), ast_mutex_unlock(), manager_action::next, and strdup.

00163 {
00164    struct manager_action *cur = first_action;
00165    int which = 0;
00166 
00167    ast_mutex_lock(&actionlock);
00168    while (cur) { /* Walk the list of actions */
00169       if (!strncasecmp(word, cur->action, strlen(word))) {
00170          if (++which > state) {
00171             char *ret = strdup(cur->action);
00172             ast_mutex_unlock(&actionlock);
00173             return ret;
00174          }
00175       }
00176       cur = cur->next;
00177    }
00178    ast_mutex_unlock(&actionlock);
00179    return NULL;
00180 }

static void destroy_session ( struct mansession s  )  [static]

Definition at line 282 of file manager.c.

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), free_session(), LOG_WARNING, and mansession::next.

Referenced by accept_thread(), session_do(), and skinny_session().

00283 {
00284    struct mansession *cur, *prev = NULL;
00285    ast_mutex_lock(&sessionlock);
00286    cur = sessions;
00287    while(cur) {
00288       if (cur == s)
00289          break;
00290       prev = cur;
00291       cur = cur->next;
00292    }
00293    if (cur) {
00294       if (prev)
00295          prev->next = cur->next;
00296       else
00297          sessions = cur->next;
00298       free_session(s);
00299    } else
00300       ast_log(LOG_WARNING, "Trying to delete nonexistent session %p?\n", s);
00301    ast_mutex_unlock(&sessionlock);
00302    
00303 }

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

Definition at line 939 of file manager.c.

References fast_originate_helper::account, fast_originate_helper::app, fast_originate_helper::appdata, AST_FORMAT_SLINEAR, ast_mutex_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, free, fast_originate_helper::idtext, ast_channel::lock, manager_event(), fast_originate_helper::priority, fast_originate_helper::tech, fast_originate_helper::timeout, ast_channel::uniqueid, and fast_originate_helper::vars.

Referenced by action_originate().

00940 {
00941    struct fast_originate_helper *in = data;
00942    int res;
00943    int reason = 0;
00944    struct ast_channel *chan = NULL;
00945 
00946    if (!ast_strlen_zero(in->app)) {
00947       res = ast_pbx_outgoing_app(in->tech, AST_FORMAT_SLINEAR, in->data, in->timeout, in->app, in->appdata, &reason, 1, 
00948          !ast_strlen_zero(in->cid_num) ? in->cid_num : NULL, 
00949          !ast_strlen_zero(in->cid_name) ? in->cid_name : NULL,
00950          in->vars, in->account, &chan);
00951    } else {
00952       res = ast_pbx_outgoing_exten(in->tech, AST_FORMAT_SLINEAR, in->data, in->timeout, in->context, in->exten, in->priority, &reason, 1, 
00953          !ast_strlen_zero(in->cid_num) ? in->cid_num : NULL, 
00954          !ast_strlen_zero(in->cid_name) ? in->cid_name : NULL,
00955          in->vars, in->account, &chan);
00956    }   
00957    if (!res)
00958       manager_event(EVENT_FLAG_CALL,
00959          "OriginateSuccess",
00960          "%s"
00961          "Channel: %s/%s\r\n"
00962          "Context: %s\r\n"
00963          "Exten: %s\r\n"
00964          "Reason: %d\r\n"
00965          "Uniqueid: %s\r\n",
00966          in->idtext, in->tech, in->data, in->context, in->exten, reason, chan ? chan->uniqueid : "<null>");
00967    else
00968       manager_event(EVENT_FLAG_CALL,
00969          "OriginateFailure",
00970          "%s"
00971          "Channel: %s/%s\r\n"
00972          "Context: %s\r\n"
00973          "Exten: %s\r\n"
00974          "Reason: %d\r\n"
00975          "Uniqueid: %s\r\n",
00976          in->idtext, in->tech, in->data, in->context, in->exten, reason, chan ? chan->uniqueid : "<null>");
00977 
00978    /* Locked by ast_pbx_outgoing_exten or ast_pbx_outgoing_app */
00979    if (chan)
00980       ast_mutex_unlock(&chan->lock);
00981    free(in);
00982    return NULL;
00983 }

static void free_session ( struct mansession s  )  [static]

Definition at line 268 of file manager.c.

References mansession::__lock, ast_mutex_destroy(), mansession::eventq, mansession::fd, free, and eventqent::next.

Referenced by destroy_session().

00269 {
00270    struct eventqent *eqe;
00271    if (s->fd > -1)
00272       close(s->fd);
00273    ast_mutex_destroy(&s->__lock);
00274    while(s->eventq) {
00275       eqe = s->eventq;
00276       s->eventq = s->eventq->next;
00277       free(eqe);
00278    }
00279    free(s);
00280 }

static int get_input ( struct mansession s,
char *  output 
) [static]

Definition at line 1341 of file manager.c.

References mansession::__lock, ast_inet_ntoa(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), mansession::dead, pollfd::events, mansession::fd, pollfd::fd, mansession::inbuf, mansession::inlen, LOG_WARNING, poll(), POLLIN, and mansession::sin.

Referenced by session_do(), and skinny_session().

01342 {
01343    /* output must have at least sizeof(s->inbuf) space */
01344    int res;
01345    int x;
01346    struct pollfd fds[1];
01347    char iabuf[INET_ADDRSTRLEN];
01348    for (x=1;x<s->inlen;x++) {
01349       if ((s->inbuf[x] == '\n') && (s->inbuf[x-1] == '\r')) {
01350          /* Copy output data up to and including \r\n */
01351          memcpy(output, s->inbuf, x + 1);
01352          /* Add trailing \0 */
01353          output[x+1] = '\0';
01354          /* Move remaining data back to the front */
01355          memmove(s->inbuf, s->inbuf + x + 1, s->inlen - x);
01356          s->inlen -= (x + 1);
01357          return 1;
01358       }
01359    } 
01360    if (s->inlen >= sizeof(s->inbuf) - 1) {
01361       ast_log(LOG_WARNING, "Dumping long line with no return from %s: %s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), s->sin.sin_addr), s->inbuf);
01362       s->inlen = 0;
01363    }
01364    fds[0].fd = s->fd;
01365    fds[0].events = POLLIN;
01366    do {
01367       res = poll(fds, 1, -1);
01368       if (res < 0) {
01369          if (errno == EINTR) {
01370             if (s->dead)
01371                return -1;
01372             continue;
01373          }
01374          ast_log(LOG_WARNING, "Select returned error: %s\n", strerror(errno));
01375          return -1;
01376       } else if (res > 0) {
01377          ast_mutex_lock(&s->__lock);
01378          res = read(s->fd, s->inbuf + s->inlen, sizeof(s->inbuf) - 1 - s->inlen);
01379          ast_mutex_unlock(&s->__lock);
01380          if (res < 1)
01381             return -1;
01382          break;
01383       }
01384    } while(1);
01385    s->inlen += res;
01386    s->inbuf[s->inlen] = '\0';
01387    return 0;
01388 }

static int get_perm ( char *  instr  )  [static]

Definition at line 413 of file manager.c.

References ast_instring(), and perms.

Referenced by authenticate().

00414 {
00415    int x = 0, ret = 0;
00416 
00417    if (!instr)
00418       return 0;
00419 
00420    for (x=0; x<sizeof(perms) / sizeof(perms[0]); x++)
00421       if (ast_instring(instr, perms[x].label, ','))
00422          ret |= perms[x].num;
00423    
00424    return ret;
00425 }

static int handle_showmancmd ( int  fd,
int  argc,
char *  argv[] 
) [static]

Definition at line 182 of file manager.c.

References manager_action::action, ast_cli(), ast_mutex_lock(), ast_mutex_unlock(), manager_action::authority, authority_to_str(), manager_action::description, manager_action::next, RESULT_SHOWUSAGE, RESULT_SUCCESS, and manager_action::synopsis.

00183 {
00184    struct manager_action *cur = first_action;
00185    char authority[80];
00186    int num;
00187 
00188    if (argc != 4)
00189       return RESULT_SHOWUSAGE;
00190    ast_mutex_lock(&actionlock);
00191    while (cur) { /* Walk the list of actions */
00192       for (num = 3; num < argc; num++) {
00193          if (!strcasecmp(cur->action, argv[num])) {
00194             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 : "");
00195          }
00196       }
00197       cur = cur->next;
00198    }
00199 
00200    ast_mutex_unlock(&actionlock);
00201    return RESULT_SUCCESS;
00202 }

static int handle_showmancmds ( int  fd,
int  argc,
char *  argv[] 
) [static]

handle_showmancmds: CLI command

Definition at line 206 of file manager.c.

References manager_action::action, ast_cli(), ast_mutex_lock(), ast_mutex_unlock(), manager_action::authority, authority_to_str(), format, manager_action::next, RESULT_SUCCESS, and manager_action::synopsis.

00207 {
00208    struct manager_action *cur = first_action;
00209    char authority[80];
00210    char *format = "  %-15.15s  %-15.15s  %-55.55s\n";
00211 
00212    ast_mutex_lock(&actionlock);
00213    ast_cli(fd, format, "Action", "Privilege", "Synopsis");
00214    ast_cli(fd, format, "------", "---------", "--------");
00215    while (cur) { /* Walk the list of actions */
00216       ast_cli(fd, format, cur->action, authority_to_str(cur->authority, authority, sizeof(authority) -1), cur->synopsis);
00217       cur = cur->next;
00218    }
00219 
00220    ast_mutex_unlock(&actionlock);
00221    return RESULT_SUCCESS;
00222 }

static int handle_showmanconn ( int  fd,
int  argc,
char *  argv[] 
) [static]

handle_showmanconn: CLI command show manager connected

Definition at line 226 of file manager.c.

References ast_cli(), ast_inet_ntoa(), ast_mutex_lock(), ast_mutex_unlock(), format, mansession::next, RESULT_SUCCESS, s, mansession::sin, and mansession::username.

00227 {
00228    struct mansession *s;
00229    char iabuf[INET_ADDRSTRLEN];
00230    char *format = "  %-15.15s  %-15.15s\n";
00231    ast_mutex_lock(&sessionlock);
00232    s = sessions;
00233    ast_cli(fd, format, "Username", "IP Address");
00234    while (s) {
00235       ast_cli(fd, format,s->username, ast_inet_ntoa(iabuf, sizeof(iabuf), s->sin.sin_addr));
00236       s = s->next;
00237    }
00238 
00239    ast_mutex_unlock(&sessionlock);
00240    return RESULT_SUCCESS;
00241 }

int manager_event ( int  category,
char *  event,
char *  fmt,
  ... 
)

manager_event: Send AMI event to client

Definition at line 1510 of file manager.c.

References mansession::__lock, append_event(), ast_build_string(), ast_build_string_va(), ast_carefulwrite(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_strlen_zero(), authority_to_str(), mansession::busy, mansession::dead, mansession::fd, LOG_WARNING, mansession::next, mansession::readperm, s, mansession::send_events, mansession::t, and mansession::writetimeout.

Referenced by __login_exec(), action_agent_callback_login(), add_to_queue(), agent_hangup(), agent_logoff(), ast_change_name(), ast_channel_bridge(), ast_do_masquerade(), ast_hangup(), ast_log(), ast_park_call(), ast_request(), ast_set_callerid(), ast_setstate(), changethread(), conf_run(), do_parking_thread(), expire_register(), fast_originate(), handle_init_event(), handle_response_peerpoke(), handle_response_register(), iax2_ack_registry(), iax2_poke_noanswer(), join_queue(), leave_queue(), manager_log(), manager_state_cb(), notify_new_message(), park_exec(), parse_register_contact(), pbx_extension_helper(), process_sdp(), quit_handler(), realtime_exec(), register_verify(), reload_logger(), reload_manager(), remove_from_queue(), ring_entry(), senddialevent(), set_member_paused(), sip_poke_noanswer(), sip_reg_timeout(), socket_read(), ss_thread(), try_calling(), update_registry(), update_status(), userevent_exec(), vm_execmain(), and zt_handle_event().

01511 {
01512    struct mansession *s;
01513    char auth[80];
01514    char tmp[4096] = "";
01515    char *tmp_next = tmp;
01516    size_t tmp_left = sizeof(tmp) - 2;
01517    va_list ap;
01518 
01519    ast_mutex_lock(&sessionlock);
01520    for (s = sessions; s; s = s->next) {
01521       if ((s->readperm & category) != category)
01522          continue;
01523 
01524       if ((s->send_events & category) != category)
01525          continue;
01526 
01527       if (ast_strlen_zero(tmp)) {
01528          ast_build_string(&tmp_next, &tmp_left, "Event: %s\r\nPrivilege: %s\r\n",
01529                 event, authority_to_str(category, auth, sizeof(auth)));
01530          va_start(ap, fmt);
01531          ast_build_string_va(&tmp_next, &tmp_left, fmt, ap);
01532          va_end(ap);
01533          *tmp_next++ = '\r';
01534          *tmp_next++ = '\n';
01535          *tmp_next = '\0';
01536       }
01537 
01538       ast_mutex_lock(&s->__lock);
01539       if (s->busy) {
01540          append_event(s, tmp);
01541       } else if (!s->dead) {
01542          if (ast_carefulwrite(s->fd, tmp, tmp_next - tmp, s->writetimeout) < 0) {
01543             ast_log(LOG_WARNING, "Disconnecting slow (or gone) manager session!\n");
01544             s->dead = 1;
01545             pthread_kill(s->t, SIGURG);
01546          }
01547       }
01548       ast_mutex_unlock(&s->__lock);
01549    }
01550    ast_mutex_unlock(&sessionlock);
01551 
01552    return 0;
01553 }

static int manager_state_cb ( char *  context,
char *  exten,
int  state,
void *  data 
) [static]

Definition at line 1576 of file manager.c.

References EVENT_FLAG_CALL, and manager_event().

Referenced by init_manager().

01577 {
01578    /* Notify managers of change */
01579    manager_event(EVENT_FLAG_CALL, "ExtensionStatus", "Exten: %s\r\nContext: %s\r\nStatus: %d\r\n", exten, context, state);
01580    return 0;
01581 }

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

Definition at line 1248 of file manager.c.

References mansession::__lock, manager_action::action, ast_carefulwrite(), ast_cli(), ast_inet_ntoa(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_strlen_zero(), ast_verbose(), astman_get_header(), astman_send_ack(), astman_send_error(), authenticate(), mansession::authenticated, manager_action::authority, mansession::busy, mansession::challenge, eventqent::eventdata, mansession::eventq, mansession::fd, free, manager_action::func, LOG_DEBUG, LOG_EVENT, eventqent::next, manager_action::next, option_verbose, mansession::sin, mansession::username, VERBOSE_PREFIX_2, mansession::writeperm, and mansession::writetimeout.

Referenced by session_do().

01249 {
01250    char action[80] = "";
01251    struct manager_action *tmp = first_action;
01252    char *id = astman_get_header(m,"ActionID");
01253    char idText[256] = "";
01254    char iabuf[INET_ADDRSTRLEN];
01255 
01256    ast_copy_string(action, astman_get_header(m, "Action"), sizeof(action));
01257    ast_log( LOG_DEBUG, "Manager received command '%s'\n", action );
01258 
01259    if (ast_strlen_zero(action)) {
01260       astman_send_error(s, m, "Missing action in request");
01261       return 0;
01262    }
01263         if (!ast_strlen_zero(id)) {
01264                 snprintf(idText,256,"ActionID: %s\r\n",id);
01265         }
01266    if (!s->authenticated) {
01267       if (!strcasecmp(action, "Challenge")) {
01268          char *authtype;
01269          authtype = astman_get_header(m, "AuthType");
01270          if (!strcasecmp(authtype, "MD5")) {
01271             if (ast_strlen_zero(s->challenge))
01272                snprintf(s->challenge, sizeof(s->challenge), "%d", rand());
01273             ast_mutex_lock(&s->__lock);
01274             ast_cli(s->fd, "Response: Success\r\n"
01275                   "%s"
01276                   "Challenge: %s\r\n\r\n",
01277                   idText,s->challenge);
01278             ast_mutex_unlock(&s->__lock);
01279             return 0;
01280          } else {
01281             astman_send_error(s, m, "Must specify AuthType");
01282             return 0;
01283          }
01284       } else if (!strcasecmp(action, "Login")) {
01285          if (authenticate(s, m)) {
01286             sleep(1);
01287             astman_send_error(s, m, "Authentication failed");
01288             return -1;
01289          } else {
01290             s->authenticated = 1;
01291             if (option_verbose > 1) {
01292                if ( displayconnects ) {
01293                   ast_verbose(VERBOSE_PREFIX_2 "Manager '%s' logged on from %s\n", s->username, ast_inet_ntoa(iabuf, sizeof(iabuf), s->sin.sin_addr));
01294                }
01295             }
01296             ast_log(LOG_EVENT, "Manager '%s' logged on from %s\n", s->username, ast_inet_ntoa(iabuf, sizeof(iabuf), s->sin.sin_addr));
01297             astman_send_ack(s, m, "Authentication accepted");
01298          }
01299       } else if (!strcasecmp(action, "Logoff")) {
01300          astman_send_ack(s, m, "See ya");
01301          return -1;
01302       } else
01303          astman_send_error(s, m, "Authentication Required");
01304    } else {
01305       int ret=0;
01306       struct eventqent *eqe;
01307       ast_mutex_lock(&s->__lock);
01308       s->busy = 1;
01309       ast_mutex_unlock(&s->__lock);
01310       while( tmp ) {       
01311          if (!strcasecmp(action, tmp->action)) {
01312             if ((s->writeperm & tmp->authority) == tmp->authority) {
01313                if (tmp->func(s, m))
01314                   ret = -1;
01315             } else {
01316                astman_send_error(s, m, "Permission denied");
01317             }
01318             break;
01319          }
01320          tmp = tmp->next;
01321       }
01322       if (!tmp)
01323          astman_send_error(s, m, "Invalid/unknown command");
01324       ast_mutex_lock(&s->__lock);
01325       s->busy = 0;
01326       while(s->eventq) {
01327          if (ast_carefulwrite(s->fd, s->eventq->eventdata, strlen(s->eventq->eventdata), s->writetimeout) < 0) {
01328             ret = -1;
01329             break;
01330          }
01331          eqe = s->eventq;
01332          s->eventq = s->eventq->next;
01333          free(eqe);
01334       }
01335       ast_mutex_unlock(&s->__lock);
01336       return ret;
01337    }
01338    return 0;
01339 }

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

Definition at line 1390 of file manager.c.

References mansession::__lock, ast_cli(), ast_inet_ntoa(), ast_log(), AST_MAX_MANHEADERS, ast_mutex_lock(), ast_mutex_unlock(), ast_strlen_zero(), ast_verbose(), mansession::authenticated, destroy_session(), mansession::fd, get_input(), message::hdrcount, message::headers, LOG_EVENT, option_verbose, process_message(), s, mansession::sin, mansession::username, and VERBOSE_PREFIX_2.

Referenced by accept_thread().

01391 {
01392    struct mansession *s = data;
01393    struct message m;
01394    char iabuf[INET_ADDRSTRLEN];
01395    int res;
01396    
01397    ast_mutex_lock(&s->__lock);
01398    ast_cli(s->fd, "Asterisk Call Manager/1.0\r\n");
01399    ast_mutex_unlock(&s->__lock);
01400    memset(&m, 0, sizeof(m));
01401    for (;;) {
01402       res = get_input(s, m.headers[m.hdrcount]);
01403       if (res > 0) {
01404          /* Strip trailing \r\n */
01405          if (strlen(m.headers[m.hdrcount]) < 2)
01406             continue;
01407          m.headers[m.hdrcount][strlen(m.headers[m.hdrcount]) - 2] = '\0';
01408          if (ast_strlen_zero(m.headers[m.hdrcount])) {
01409             if (process_message(s, &m))
01410                break;
01411             memset(&m, 0, sizeof(m));
01412          } else if (m.hdrcount < AST_MAX_MANHEADERS - 1)
01413             m.hdrcount++;
01414       } else if (res < 0)
01415          break;
01416    }
01417    if (s->authenticated) {
01418       if (option_verbose > 1) {
01419          if (displayconnects) 
01420             ast_verbose(VERBOSE_PREFIX_2 "Manager '%s' logged off from %s\n", s->username, ast_inet_ntoa(iabuf, sizeof(iabuf), s->sin.sin_addr));    
01421       }
01422       ast_log(LOG_EVENT, "Manager '%s' logged off from %s\n", s->username, ast_inet_ntoa(iabuf, sizeof(iabuf), s->sin.sin_addr));
01423    } else {
01424       if (option_verbose > 1) {
01425          if ( displayconnects )
01426             ast_verbose(VERBOSE_PREFIX_2 "Connect attempt from '%s' unable to authenticate\n", ast_inet_ntoa(iabuf, sizeof(iabuf), s->sin.sin_addr));
01427       }
01428       ast_log(LOG_EVENT, "Failed attempt from %s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), s->sin.sin_addr));
01429    }
01430    destroy_session(s);
01431    return NULL;
01432 }

static int set_eventmask ( struct mansession s,
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 476 of file manager.c.

References mansession::__lock, ast_mutex_lock(), ast_mutex_unlock(), ast_strings_to_mask(), and mansession::send_events.

Referenced by action_events(), and authenticate().

00477 {
00478    int maskint = ast_strings_to_mask(eventmask);
00479 
00480    ast_mutex_lock(&s->__lock);
00481    if (maskint >= 0) 
00482       s->send_events = maskint;
00483    ast_mutex_unlock(&s->__lock);
00484    
00485    return maskint;
00486 }


Variable Documentation

int asock = -1 [static]

Definition at line 84 of file manager.c.

int block_sockets = 0 [static]

Definition at line 89 of file manager.c.

int displayconnects = 1 [static]

Definition at line 85 of file manager.c.

int enabled = 0 [static]

Definition at line 82 of file manager.c.

struct manager_action* first_action = NULL [static]

Definition at line 107 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 919 of file manager.c.

char mandescr_events[] [static]

Definition at line 620 of file manager.c.

char mandescr_extensionstate[] [static]

Definition at line 1176 of file manager.c.

char mandescr_getvar[] [static]

Definition at line 713 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 652 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 593 of file manager.c.

char mandescr_logoff[] [static]

Initial value:

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

Definition at line 642 of file manager.c.

char mandescr_mailboxcount[] [static]

Definition at line 1140 of file manager.c.

char mandescr_mailboxstatus[] [static]

Help text for manager command mailboxstatus.

Definition at line 1108 of file manager.c.

char mandescr_originate[] [static]

Definition at line 985 of file manager.c.

char mandescr_ping[] [static]

Initial value:

 
"Description: A 'Ping' action will ellicit a 'Pong' response.  Used to keep the "
"  manager connection open.\n"
"Variables: NONE\n"
PING: Manager PING.

Definition at line 582 of file manager.c.

char mandescr_redirect[] [static]

Definition at line 847 of file manager.c.

char mandescr_setvar[] [static]

Definition at line 676 of file manager.c.

char mandescr_timeout[] [static]

Definition at line 1217 of file manager.c.

struct permalias perms[] [static]

int portno = DEFAULT_MANAGER_PORT [static]

Definition at line 83 of file manager.c.

Referenced by ast_netsock_bind(), create_addr(), process_sdp(), and set_config().

struct mansession* sessions = NULL [static]

Definition at line 106 of file manager.c.

Referenced by accept_thread(), and destroy_session().

struct ast_cli_entry show_mancmd_cli [static]

Initial value:

   { { "show", "manager", "command", NULL },
   handle_showmancmd, "Show a manager interface command", showmancmd_help, complete_show_mancmd }

Definition at line 256 of file manager.c.

Initial value:

   { { "show", "manager", "commands", NULL },
   handle_showmancmds, "List manager interface commands", showmancmds_help }

Definition at line 260 of file manager.c.

Initial value:

   { { "show", "manager", "connected", NULL },
   handle_showmanconn, "Show connected manager interface users", showmanconn_help }

Definition at line 264 of file manager.c.

char showmancmd_help[] [static]

Initial value:

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

Definition at line 243 of file manager.c.

char showmancmds_help[] [static]

Initial value:

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

Definition at line 247 of file manager.c.

char showmanconn_help[] [static]

Initial value:

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

Definition at line 251 of file manager.c.

pthread_t t [static]


Generated on Wed Oct 28 15:49:24 2009 for Asterisk - the Open Source PBX by  doxygen 1.5.6