manager.c File Reference

00084 {
00085    /* Try to write string, but wait no more than ms milliseconds
00086       before timing out */
00087    int res=0;
00088    struct pollfd fds[1];
00089    while(len) {
00090       res = write(fd, s, len);
00091       if ((res < 0) && (errno != EAGAIN)) {
00092          return -1;
00093       }
00094       if (res < 0) res = 0;
00095       len -= res;
00096       s += res;
00097       fds[0].fd = fd;
00098       fds[0].events = POLLOUT;
00099       /* Wait until writable again */
00100       res = poll(fds, 1, timeoutms);
00101       if (res < 1)
00102          return -1;
00103    }
00104    return res;
00105 }

01358 {
01359    struct manager_action *cur;
01360 
01361    cur = malloc(sizeof(struct manager_action));
01362    if (!cur) {
01363       ast_log(LOG_WARNING, "Manager: out of memory trying to register action\n");
01364       ast_mutex_unlock(&actionlock);
01365       return -1;
01366    }
01367    cur->action = action;
01368    cur->authority = auth;
01369    cur->func = func;
01370    cur->synopsis = synopsis;
01371    cur->description = description;
01372    cur->next = NULL;
01373 
01374    ast_manager_register_struct(cur);
01375 
01376    return 0;
01377 }

01289                                            {
01290    struct manager_action *cur = first_action, *prev = first_action;
01291 
01292    ast_mutex_lock(&actionlock);
01293    while( cur ) {       
01294       if (!strcasecmp(action, cur->action)) {
01295          prev->next = cur->next;
01296          free(cur);
01297          if (option_verbose > 1) 
01298             ast_verbose(VERBOSE_PREFIX_2 "Manager unregistered action %s\n", action);
01299          ast_mutex_unlock(&actionlock);
01300          return 0;
01301       }
01302       prev = cur;
01303       cur = cur->next;
01304    }
01305    ast_mutex_unlock(&actionlock);
01306    return 0;
01307 }

00252 {
00253    char cmp[80];
00254    int x;
00255    snprintf(cmp, sizeof(cmp), "%s: ", var);
00256    for (x=0;x<m->hdrcount;x++)
00257       if (!strncasecmp(cmp, m->headers[x], strlen(cmp)))
00258          return m->headers[x] + strlen(cmp);
00259    return "";
00260 }

00288 {
00289    astman_send_response(s, m, "Success", msg);
00290 }

00263 {
00264    char *id = astman_get_header(m,"ActionID");
00265    ast_mutex_lock(&s->lock);
00266    ast_cli(s->fd, "Response: Error\r\n");
00267    if (id && !ast_strlen_zero(id))
00268       ast_cli(s->fd, "ActionID: %s\r\n",id);
00269    ast_cli(s->fd, "Message: %s\r\n\r\n", error);
00270    ast_mutex_unlock(&s->lock);
00271 }

00274 {
00275    char *id = astman_get_header(m,"ActionID");
00276    ast_mutex_lock(&s->lock);
00277    ast_cli(s->fd, "Response: %s\r\n", resp);
00278    if (id && !ast_strlen_zero(id))
00279       ast_cli(s->fd, "ActionID: %s\r\n",id);
00280    if (msg)
00281       ast_cli(s->fd, "Message: %s\r\n\r\n", msg);
00282    else
00283       ast_cli(s->fd, "\r\n");
00284    ast_mutex_unlock(&s->lock);
00285 }

01382 {
01383    struct ast_config *cfg;
01384    char *val;
01385    int oldportno = portno;
01386    static struct sockaddr_in ba;
01387    int x = 1;
01388    if (!registered) {
01389       /* Register default actions */
01390       ast_manager_register2("Ping", 0, action_ping, "Ping", mandescr_ping);
01391       ast_manager_register2("Events", 0, action_events, "Contol Event Flow", mandescr_events);
01392       ast_manager_register2("Logoff", 0, action_logoff, "Logoff Manager", mandescr_logoff);
01393       ast_manager_register2("Hangup", EVENT_FLAG_CALL, action_hangup, "Hangup Channel", mandescr_hangup);
01394       ast_manager_register( "Status", EVENT_FLAG_CALL, action_status, "Status" );
01395       ast_manager_register( "Setvar", EVENT_FLAG_CALL, action_setvar, "Set Channel Variable" );
01396       ast_manager_register( "Getvar", EVENT_FLAG_CALL, action_getvar, "Gets a Channel Variable" );
01397       ast_manager_register( "Redirect", EVENT_FLAG_CALL, action_redirect, "Redirect" );
01398       ast_manager_register2("Originate", EVENT_FLAG_CALL, action_originate, "Originate Call", mandescr_originate);
01399       ast_manager_register( "MailboxStatus", EVENT_FLAG_CALL, action_mailboxstatus, "Check Mailbox" );
01400       ast_manager_register( "Command", EVENT_FLAG_COMMAND, action_command, "Execute Command" );
01401       ast_manager_register( "ExtensionState", EVENT_FLAG_CALL, action_extensionstate, "Check Extension Status" );
01402       ast_manager_register( "AbsoluteTimeout", EVENT_FLAG_CALL, action_timeout, "Set Absolute Timeout" );
01403       ast_manager_register( "MailboxCount", EVENT_FLAG_CALL, action_mailboxcount, "Check Mailbox Message Count" );
01404       ast_manager_register2("ListCommands", 0, action_listcommands, "List available manager commands", mandescr_listcommands);
01405 
01406       ast_cli_register(&show_mancmd_cli);
01407       ast_cli_register(&show_mancmds_cli);
01408       ast_cli_register(&show_manconn_cli);
01409       ast_extension_state_add(NULL, NULL, manager_state_cb, NULL);
01410       registered = 1;
01411    }
01412    portno = DEFAULT_MANAGER_PORT;
01413    cfg = ast_load("manager.conf");
01414    if (!cfg) {
01415       ast_log(LOG_NOTICE, "Unable to open management configuration manager.conf.  Call management disabled.\n");
01416       return 0;
01417    }
01418    memset(&ba, 0, sizeof(ba));
01419    val = ast_variable_retrieve(cfg, "general", "enabled");
01420    if (val)
01421       enabled = ast_true(val);
01422 
01423    val = ast_variable_retrieve(cfg, "general", "block-sockets");
01424    if(val)
01425       block_sockets = ast_true(val);
01426 
01427    if ((val = ast_variable_retrieve(cfg, "general", "port"))) {
01428       if (sscanf(val, "%d", &portno) != 1) {
01429          ast_log(LOG_WARNING, "Invalid port number '%s'\n", val);
01430          portno = DEFAULT_MANAGER_PORT;
01431       }
01432    } else if ((val = ast_variable_retrieve(cfg, "general", "portno"))) {
01433       if (sscanf(val, "%d", &portno) != 1) {
01434          ast_log(LOG_WARNING, "Invalid port number '%s'\n", val);
01435          portno = DEFAULT_MANAGER_PORT;
01436       }
01437       ast_log(LOG_NOTICE, "Use of portno in manager.conf deprecated.  Please use 'port=%s' instead.\n", val);
01438    }
01439    
01440    ba.sin_family = AF_INET;
01441    ba.sin_port = htons(portno);
01442    memset(&ba.sin_addr, 0, sizeof(ba.sin_addr));
01443    
01444    if ((val = ast_variable_retrieve(cfg, "general", "bindaddr"))) {
01445       if (!inet_aton(val, &ba.sin_addr)) { 
01446          ast_log(LOG_WARNING, "Invalid address '%s' specified, using 0.0.0.0\n", val);
01447          memset(&ba.sin_addr, 0, sizeof(ba.sin_addr));
01448       }
01449    }
01450    
01451    if ((asock > -1) && ((portno != oldportno) || !enabled)) {
01452 #if 0
01453       /* Can't be done yet */
01454       close(asock);
01455       asock = -1;
01456 #else
01457       ast_log(LOG_WARNING, "Unable to change management port / enabled\n");
01458 #endif
01459    }
01460    ast_destroy(cfg);
01461    
01462    /* If not enabled, do nothing */
01463    if (!enabled) {
01464       return 0;
01465    }
01466    if (asock < 0) {
01467       asock = socket(AF_INET, SOCK_STREAM, 0);
01468       if (asock < 0) {
01469          ast_log(LOG_WARNING, "Unable to create socket: %s\n", strerror(errno));
01470          return -1;
01471       }
01472       setsockopt(asock, SOL_SOCKET, SO_REUSEADDR, &x, sizeof(x));
01473       if (bind(asock, (struct sockaddr *)&ba, sizeof(ba))) {
01474          ast_log(LOG_WARNING, "Unable to bind socket: %s\n", strerror(errno));
01475          close(asock);
01476          asock = -1;
01477          return -1;
01478       }
01479       if (listen(asock, 2)) {
01480          ast_log(LOG_WARNING, "Unable to listen on socket: %s\n", strerror(errno));
01481          close(asock);
01482          asock = -1;
01483          return -1;
01484       }
01485       if (option_verbose)
01486          ast_verbose("Asterisk Management interface listening on port %d\n", portno);
01487       ast_pthread_create(&t, NULL, accept_thread, NULL);
01488    }
01489    return 0;
01490 }

01263 {
01264    struct mansession *s;
01265    char tmp[4096];
01266    va_list ap;
01267 
01268    ast_mutex_lock(&sessionlock);
01269    s = sessions;
01270    while(s) {
01271       if (((s->readperm & category) == category) && ((s->send_events & category) == category) ) {
01272          ast_mutex_lock(&s->lock);
01273          if (!s->blocking) {
01274             ast_cli(s->fd, "Event: %s\r\n", event);
01275             va_start(ap, fmt);
01276             vsnprintf(tmp, sizeof(tmp), fmt, ap);
01277             va_end(ap);
01278             ast_carefulwrite(s->fd,tmp,strlen(tmp),100);
01279             ast_cli(s->fd, "\r\n");
01280          }
01281          ast_mutex_unlock(&s->lock);
01282       }
01283       s = s->next;
01284    }
01285    ast_mutex_unlock(&sessionlock);
01286    return 0;
01287 }

01493 {
01494    manager_event(EVENT_FLAG_SYSTEM, "Reload", "Message: Reload Requested\r\n");
01495    return init_manager();
01496 }

Data Structures
struct	fast_originate_helper
struct	permalias
Functions
	AST_MUTEX_DEFINE_STATIC (sessionlock)
	AST_MUTEX_DEFINE_STATIC (actionlock)
int	ast_carefulwrite (int fd, char *s, int len, int timeoutms)
char *	astman_get_header (struct message m, char var)
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)
void	astman_send_ack (struct mansession s, struct message m, char *msg)
int	manager_event (int category, char event, char fmt,...)
int	ast_manager_unregister (char *action)
int	ast_manager_register2 (char action, int auth, int(func)(struct mansession s, struct message m), char synopsis, char description)
int	init_manager (void)
int	reload_manager (void)

manager.c File Reference

Data Structures

Functions

Function Documentation