Main Page | Alphabetical List | Data Structures | File List | Data Fields | Globals

manager.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <sys/time.h>
#include <sys/types.h>
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
#include <sys/poll.h>
#include <asterisk/channel.h>
#include <asterisk/file.h>
#include <asterisk/manager.h>
#include <asterisk/config.h>
#include <asterisk/lock.h>
#include <asterisk/logger.h>
#include <asterisk/options.h>
#include <asterisk/cli.h>
#include <asterisk/app.h>
#include <asterisk/pbx.h>
#include <asterisk/md5.h>
#include <asterisk/acl.h>
#include <asterisk/utils.h>

Include dependency graph for manager.c:

Include dependency graph

Go to the source code of this file.

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)

Function Documentation

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

Definition at line 83 of file manager.c.

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

Referenced by manager_event(). 

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 }

int ast_manager_register2 (  char *  action,
int  auth,
int(*  func)(struct mansession *s, struct message *m),
char *  synopsis,
char *  description
) 
 

Definition at line 1197 of file manager.c.

References ast_log(), ast_mutex_unlock, description(), LOG_WARNING, and malloc.

Referenced by init_manager(). 

01198 {
01199    struct manager_action *cur;
01200 
01201    cur = malloc(sizeof(struct manager_action));
01202    if (!cur) {
01203       ast_log(LOG_WARNING, "Manager: out of memory trying to register action\n");
01204       ast_mutex_unlock(&actionlock);
01205       return -1;
01206    }
01207    cur->action = action;
01208    cur->authority = auth;
01209    cur->func = func;
01210    cur->synopsis = synopsis;
01211    cur->description = description;
01212    cur->next = NULL;
01213 
01214    ast_manager_register_struct(cur);
01215 
01216    return 0;
01217 }

int ast_manager_unregister (  char *  action  ) 
 

Definition at line 1129 of file manager.c.

References ast_mutex_lock, ast_mutex_unlock, ast_verbose(), free, option_verbose, and VERBOSE_PREFIX_2. 

01129                                            {
01130    struct manager_action *cur = first_action, *prev = first_action;
01131 
01132    ast_mutex_lock(&actionlock);
01133    while( cur ) {       
01134       if (!strcasecmp(action, cur->action)) {
01135          prev->next = cur->next;
01136          free(cur);
01137          if (option_verbose > 1) 
01138             ast_verbose(VERBOSE_PREFIX_2 "Manager unregistered action %s\n", action);
01139          ast_mutex_unlock(&actionlock);
01140          return 0;
01141       }
01142       prev = cur;
01143       cur = cur->next;
01144    }
01145    ast_mutex_unlock(&actionlock);
01146    return 0;
01147 }

AST_MUTEX_DEFINE_STATIC (  actionlock   ) 
 

AST_MUTEX_DEFINE_STATIC (  sessionlock   ) 
 

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

Definition at line 230 of file manager.c.

References message::hdrcount, and message::headers.

Referenced by astman_send_error(), and astman_send_response(). 

00231 {
00232    char cmp[80];
00233    int x;
00234    snprintf(cmp, sizeof(cmp), "%s: ", var);
00235    for (x=0;x<m->hdrcount;x++)
00236       if (!strncasecmp(cmp, m->headers[x], strlen(cmp)))
00237          return m->headers[x] + strlen(cmp);
00238    return "";
00239 }

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

Definition at line 266 of file manager.c.

References astman_send_response(), and s. 

00267 {
00268    astman_send_response(s, m, "Success", msg);
00269 }

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

Definition at line 241 of file manager.c.

References ast_cli(), ast_mutex_lock, ast_mutex_unlock, astman_get_header(), and s. 

00242 {
00243    char *id = astman_get_header(m,"ActionID");
00244    ast_mutex_lock(&s->lock);
00245    ast_cli(s->fd, "Response: Error\r\n");
00246    if (id && !ast_strlen_zero(id))
00247       ast_cli(s->fd, "ActionID: %s\r\n",id);
00248    ast_cli(s->fd, "Message: %s\r\n\r\n", error);
00249    ast_mutex_unlock(&s->lock);
00250 }

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

Definition at line 252 of file manager.c.

References ast_cli(), ast_mutex_lock, ast_mutex_unlock, astman_get_header(), and s.

Referenced by astman_send_ack(). 

00253 {
00254    char *id = astman_get_header(m,"ActionID");
00255    ast_mutex_lock(&s->lock);
00256    ast_cli(s->fd, "Response: %s\r\n", resp);
00257    if (id && !ast_strlen_zero(id))
00258       ast_cli(s->fd, "ActionID: %s\r\n",id);
00259    if (msg)
00260       ast_cli(s->fd, "Message: %s\r\n\r\n", msg);
00261    else
00262       ast_cli(s->fd, "\r\n");
00263    ast_mutex_unlock(&s->lock);
00264 }

int init_manager (  void   ) 
 

Definition at line 1221 of file manager.c.

References ast_cli_register(), ast_destroy(), ast_extension_state_add(), ast_load(), ast_log(), ast_manager_register, ast_manager_register2(), ast_true(), ast_variable_retrieve(), ast_verbose(), DEFAULT_MANAGER_PORT, EVENT_FLAG_CALL, EVENT_FLAG_COMMAND, LOG_NOTICE, LOG_WARNING, and option_verbose.

Referenced by main(), and reload_manager(). 

01222 {
01223    struct ast_config *cfg;
01224    char *val;
01225    int oldportno = portno;
01226    static struct sockaddr_in ba;
01227    int x = 1;
01228    if (!registered) {
01229       /* Register default actions */
01230       ast_manager_register2("Ping", 0, action_ping, "Ping", mandescr_ping);
01231       ast_manager_register( "Events", 0, action_events, "Contol Event Flow" );
01232       ast_manager_register( "Logoff", 0, action_logoff, "Logoff Manager" );
01233       ast_manager_register( "Hangup", EVENT_FLAG_CALL, action_hangup, "Hangup Channel" );
01234       ast_manager_register( "Status", EVENT_FLAG_CALL, action_status, "Status" );
01235       ast_manager_register( "Setvar", EVENT_FLAG_CALL, action_setvar, "Set Channel Variable" );
01236       ast_manager_register( "Getvar", EVENT_FLAG_CALL, action_getvar, "Gets a Channel Variable" );
01237       ast_manager_register( "Redirect", EVENT_FLAG_CALL, action_redirect, "Redirect" );
01238       ast_manager_register2("Originate", EVENT_FLAG_CALL, action_originate, "Originate Call", mandescr_originate);
01239       ast_manager_register( "MailboxStatus", EVENT_FLAG_CALL, action_mailboxstatus, "Check Mailbox" );
01240       ast_manager_register( "Command", EVENT_FLAG_COMMAND, action_command, "Execute Command" );
01241       ast_manager_register( "ExtensionState", EVENT_FLAG_CALL, action_extensionstate, "Check Extension Status" );
01242       ast_manager_register( "AbsoluteTimeout", EVENT_FLAG_CALL, action_timeout, "Set Absolute Timeout" );
01243       ast_manager_register( "MailboxCount", EVENT_FLAG_CALL, action_mailboxcount, "Check Mailbox Message Count" );
01244       ast_manager_register2("ListCommands", 0, action_listcommands, "List available manager commands", mandescr_listcommands);
01245 
01246       ast_cli_register(&show_mancmd_cli);
01247       ast_cli_register(&show_mancmds_cli);
01248       ast_cli_register(&show_manconn_cli);
01249       ast_extension_state_add(NULL, NULL, manager_state_cb, NULL);
01250       registered = 1;
01251    }
01252    portno = DEFAULT_MANAGER_PORT;
01253    cfg = ast_load("manager.conf");
01254    if (!cfg) {
01255       ast_log(LOG_NOTICE, "Unable to open management configuration manager.conf.  Call management disabled.\n");
01256       return 0;
01257    }
01258    memset(&ba, 0, sizeof(ba));
01259    val = ast_variable_retrieve(cfg, "general", "enabled");
01260    if (val)
01261       enabled = ast_true(val);
01262 
01263    val = ast_variable_retrieve(cfg, "general", "block-sockets");
01264    if(val)
01265       block_sockets = ast_true(val);
01266 
01267    if ((val = ast_variable_retrieve(cfg, "general", "port"))) {
01268       if (sscanf(val, "%d", &portno) != 1) {
01269          ast_log(LOG_WARNING, "Invalid port number '%s'\n", val);
01270          portno = DEFAULT_MANAGER_PORT;
01271       }
01272    } else if ((val = ast_variable_retrieve(cfg, "general", "portno"))) {
01273       if (sscanf(val, "%d", &portno) != 1) {
01274          ast_log(LOG_WARNING, "Invalid port number '%s'\n", val);
01275          portno = DEFAULT_MANAGER_PORT;
01276       }
01277       ast_log(LOG_NOTICE, "Use of portno in manager.conf deprecated.  Please use 'port=%s' instead.\n", val);
01278    }
01279    
01280    ba.sin_family = AF_INET;
01281    ba.sin_port = htons(portno);
01282    memset(&ba.sin_addr, 0, sizeof(ba.sin_addr));
01283    
01284    if ((val = ast_variable_retrieve(cfg, "general", "bindaddr"))) {
01285       if (!inet_aton(val, &ba.sin_addr)) { 
01286          ast_log(LOG_WARNING, "Invalid address '%s' specified, using 0.0.0.0\n", val);
01287          memset(&ba.sin_addr, 0, sizeof(ba.sin_addr));
01288       }
01289    }
01290    
01291    if ((asock > -1) && ((portno != oldportno) || !enabled)) {
01292 #if 0
01293       /* Can't be done yet */
01294       close(asock);
01295       asock = -1;
01296 #else
01297       ast_log(LOG_WARNING, "Unable to change management port / enabled\n");
01298 #endif
01299    }
01300    ast_destroy(cfg);
01301    
01302    /* If not enabled, do nothing */
01303    if (!enabled) {
01304       return 0;
01305    }
01306    if (asock < 0) {
01307       asock = socket(AF_INET, SOCK_STREAM, 0);
01308       if (asock < 0) {
01309          ast_log(LOG_WARNING, "Unable to create socket: %s\n", strerror(errno));
01310          return -1;
01311       }
01312       setsockopt(asock, SOL_SOCKET, SO_REUSEADDR, &x, sizeof(x));
01313       if (bind(asock, (struct sockaddr *)&ba, sizeof(ba))) {
01314          ast_log(LOG_WARNING, "Unable to bind socket: %s\n", strerror(errno));
01315          close(asock);
01316          asock = -1;
01317          return -1;
01318       }
01319       if (listen(asock, 2)) {
01320          ast_log(LOG_WARNING, "Unable to listen on socket: %s\n", strerror(errno));
01321          close(asock);
01322          asock = -1;
01323          return -1;
01324       }
01325       if (option_verbose)
01326          ast_verbose("Asterisk Management interface listening on port %d\n", portno);
01327       pthread_create(&t, NULL, accept_thread, NULL);
01328    }
01329    return 0;
01330 }

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

Definition at line 1102 of file manager.c.

References ast_carefulwrite(), ast_cli(), ast_mutex_lock, ast_mutex_unlock, and s. 

01103 {
01104    struct mansession *s;
01105    char tmp[4096];
01106    va_list ap;
01107 
01108    ast_mutex_lock(&sessionlock);
01109    s = sessions;
01110    while(s) {
01111       if (((s->readperm & category) == category) && s->send_events) {
01112          ast_mutex_lock(&s->lock);
01113          if (!s->blocking) {
01114             ast_cli(s->fd, "Event: %s\r\n", event);
01115             va_start(ap, fmt);
01116             vsnprintf(tmp, sizeof(tmp), fmt, ap);
01117             va_end(ap);
01118             ast_carefulwrite(s->fd,tmp,strlen(tmp),100);
01119             ast_cli(s->fd, "\r\n");
01120          }
01121          ast_mutex_unlock(&s->lock);
01122       }
01123       s = s->next;
01124    }
01125    ast_mutex_unlock(&sessionlock);
01126    return 0;
01127 }

int reload_manager (  void   ) 
 

Definition at line 1332 of file manager.c.

References EVENT_FLAG_SYSTEM, init_manager(), and manager_event().

Referenced by ast_module_reload(). 

01333 {
01334    manager_event(EVENT_FLAG_SYSTEM, "Reload", "Message: Reload Requested\r\n");
01335    return init_manager();
01336 }

Generated on Sat Jun 12 16:41:40 2004 for Asterisk by doxygen 1.3.7