Sat Nov 1 06:28:34 2008

Asterisk developer's documentation

---

manager.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2006, Digium, Inc.
 *
 * Mark Spencer <markster@digium.com>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! \file
 *
 * \brief The Asterisk Management Interface - AMI
 *
 * \author Mark Spencer <markster@digium.com>
 *
 * Channel Management and more
 * 
 * \ref amiconf
 */

/*! \addtogroup Group_AMI AMI functions 
*/
/*! @{ 
 Doxygen group */

#include "asterisk.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision: 150816 $")

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.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 "asterisk/channel.h"
#include "asterisk/file.h"
#include "asterisk/manager.h"
#include "asterisk/config.h"
#include "asterisk/callerid.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 "asterisk/http.h"
#include "asterisk/threadstorage.h"
#include "asterisk/linkedlists.h"
#include "asterisk/term.h"
#include "asterisk/astobj2.h"

struct fast_originate_helper {
   char tech[AST_MAX_EXTENSION];
   char data[AST_MAX_EXTENSION];
   int timeout;
   int format;
   char app[AST_MAX_APP];
   char appdata[AST_MAX_EXTENSION];
   char cid_name[AST_MAX_EXTENSION];
   char cid_num[AST_MAX_EXTENSION];
   char context[AST_MAX_CONTEXT];
   char exten[AST_MAX_EXTENSION];
   char idtext[AST_MAX_EXTENSION];
   char account[AST_MAX_ACCOUNT_CODE];
   int priority;
   struct ast_variable *vars;
};

struct eventqent {
   int usecount;
   int category;
   struct eventqent *next;
   char eventdata[1];
};

static int enabled;
static int portno = DEFAULT_MANAGER_PORT;
static int asock = -1;
static int displayconnects = 1;
static int timestampevents;
static int httptimeout = 60;

static pthread_t t;
static int block_sockets;
static int num_sessions;

/* Protected by the sessions list lock */
struct eventqent *master_eventq = NULL;

AST_THREADSTORAGE(manager_event_buf, manager_event_buf_init);
#define MANAGER_EVENT_BUF_INITSIZE   256

AST_THREADSTORAGE(astman_append_buf, astman_append_buf_init);
#define ASTMAN_APPEND_BUF_INITSIZE   256

static struct permalias {
   int num;
   char *label;
} perms[] = {
   { EVENT_FLAG_SYSTEM, "system" },
   { EVENT_FLAG_CALL, "call" },
   { EVENT_FLAG_LOG, "log" },
   { EVENT_FLAG_VERBOSE, "verbose" },
   { EVENT_FLAG_COMMAND, "command" },
   { EVENT_FLAG_AGENT, "agent" },
   { EVENT_FLAG_USER, "user" },
   { EVENT_FLAG_CONFIG, "config" },
   { -1, "all" },
   { 0, "none" },
};

#define MAX_BLACKLIST_CMD_LEN 2
static struct {
   char *words[AST_MAX_CMD_LEN];
} command_blacklist[] = {
   {{ "module", "load", NULL }},
   {{ "module", "unload", NULL }},
};

struct mansession {
   /*! Execution thread */
   pthread_t t;
   /*! Thread lock -- don't use in action callbacks, it's already taken care of  */
   ast_mutex_t __lock;
   /*! socket address */
   struct sockaddr_in sin;
   /*! TCP socket */
   int fd;
   /*! Whether an HTTP manager is in use */
   int inuse;
   /*! Whether an HTTP session should be destroyed */
   int needdestroy;
   /*! Whether an HTTP session has someone waiting on events */
   pthread_t waiting_thread;
   /*! Unique manager identifer */
   uint32_t managerid;
   /*! Session timeout if HTTP */
   time_t sessiontimeout;
   /*! Output from manager interface */
   struct ast_dynamic_str *outputstr;
   /*! Logged in username */
   char username[80];
   /*! Authentication challenge */
   char challenge[10];
   /*! Authentication status */
   int authenticated;
   /*! Authorization for reading */
   int readperm;
   /*! Authorization for writing */
   int writeperm;
   /*! Buffer */
   char inbuf[1024];
   int inlen;
   int send_events;
   int displaysystemname;     /*!< Add system name to manager responses and events */
   /* Queued events that we've not had the ability to send yet */
   struct eventqent *eventq;
   /* Timeout for ast_carefulwrite() */
   int writetimeout;
   int pending_event;         /*!< Pending events indicator in case when waiting_thread is NULL */
   AST_LIST_ENTRY(mansession) list;
};

static AST_LIST_HEAD_STATIC(sessions, mansession);

struct ast_manager_user {
   char username[80];
   char *secret;
   char *deny;
   char *permit;
   char *read;
   char *write;
   unsigned int displayconnects:1;
   int keep;
   AST_LIST_ENTRY(ast_manager_user) list;
};

static AST_LIST_HEAD_STATIC(users, ast_manager_user);

static struct manager_action *first_action;
AST_RWLOCK_DEFINE_STATIC(actionlock);

/*! \brief Convert authority code to string with serveral options */
static char *authority_to_str(int authority, char *res, int reslen)
{
   int running_total = 0, i;

   memset(res, 0, reslen);
   for (i = 0; i < (sizeof(perms) / sizeof(perms[0])) - 1; i++) {
      if (authority & perms[i].num) {
         if (*res) {
            strncat(res, ",", (reslen > running_total) ? reslen - running_total - 1 : 0);
            running_total++;
         }
         strncat(res, perms[i].label, (reslen > running_total) ? reslen - running_total - 1 : 0);
         running_total += strlen(perms[i].label);
      }
   }

   if (ast_strlen_zero(res))
      ast_copy_string(res, "<none>", reslen);
   
   return res;
}

static char *complete_show_mancmd(const char *line, const char *word, int pos, int state)
{
   struct manager_action *cur;
   int which = 0;
   char *ret = NULL;

   ast_rwlock_rdlock(&actionlock);
   for (cur = first_action; cur; cur = cur->next) { /* Walk the list of actions */
      if (!strncasecmp(word, cur->action, strlen(word)) && ++which > state) {
         ret = ast_strdup(cur->action);
         break;   /* make sure we exit even if ast_strdup() returns NULL */
      }
   }
   ast_rwlock_unlock(&actionlock);

   return ret;
}

static void xml_copy_escape(char **dst, size_t *maxlen, const char *src, int lower)
{
   while (*src && (*maxlen > 6)) {
      switch (*src) {
      case '<':
         strcpy(*dst, "&lt;");
         (*dst) += 4;
         *maxlen -= 4;
         break;
      case '>':
         strcpy(*dst, "&gt;");
         (*dst) += 4;
         *maxlen -= 4;
         break;
      case '\"':
         strcpy(*dst, "&quot;");
         (*dst) += 6;
         *maxlen -= 6;
         break;
      case '\'':
         strcpy(*dst, "&apos;");
         (*dst) += 6;
         *maxlen -= 6;
         break;
      case '&':
         strcpy(*dst, "&amp;");
         (*dst) += 5;
         *maxlen -= 5;
         break;      
      default:
         *(*dst)++ = lower ? tolower(*src) : *src;
         (*maxlen)--;
      }
      src++;
   }
}

struct variable_count {
   char *varname;
   int count;
};

static int compress_char(char c)
{
   c &= 0x7f;
   if (c < 32)
      return 0;
   else if (c >= 'a' && c <= 'z')
      return c - 64;
   else if (c > 'z')
      return '_';
   else
      return c - 32;
}

static int variable_count_hash_fn(const void *vvc, const int flags)
{
   const struct variable_count *vc = vvc;
   int res = 0, i;
   for (i = 0; i < 5; i++) {
      if (vc->varname[i] == '\0')
         break;
      res += compress_char(vc->varname[i]) << (i * 6);
   }
   return res;
}

static int variable_count_cmp_fn(void *obj, void *vstr, int flags)
{
   /* Due to the simplicity of struct variable_count, it makes no difference
    * if you pass in objects or strings, the same operation applies. This is
    * due to the fact that the hash occurs on the first element, which means
    * the address of both the struct and the string are exactly the same. */
   struct variable_count *vc = obj;
   char *str = vstr;
   return !strcmp(vc->varname, str) ? CMP_MATCH | CMP_STOP : 0;
}

static char *xml_translate(char *in, struct ast_variable *vars)
{
   struct ast_variable *v;
   char *dest = NULL;
   char *out, *tmp, *var, *val;
   char *objtype = NULL;
   int colons = 0;
   int breaks = 0;
   size_t len;
   int count = 1;
   int escaped = 0;
   int inobj = 0;
   int x;
   struct variable_count *vc = NULL;
   struct ao2_container *vco = NULL;

   for (v = vars; v; v = v->next) {
      if (!dest && !strcasecmp(v->name, "ajaxdest"))
         dest = v->value;
      else if (!objtype && !strcasecmp(v->name, "ajaxobjtype")) 
         objtype = v->value;
   }
   if (!dest)
      dest = "unknown";
   if (!objtype)
      objtype = "generic";
   for (x = 0; in[x]; x++) {
      if (in[x] == ':')
         colons++;
      else if (in[x] == '\n')
         breaks++;
      else if (strchr("&\"<>\'", in[x]))
         escaped++;
   }
   len = (size_t) (strlen(in) + colons * 5 + breaks * (40 + strlen(dest) + strlen(objtype)) + escaped * 10); /* foo="bar", "<response type=\"object\" id=\"dest\"", "&amp;" */
   out = ast_malloc(len);
   if (!out)
      return 0;
   tmp = out;
   while (*in) {
      var = in;
      while (*in && (*in >= 32))
         in++;
      if (*in) {
         if ((count > 3) && inobj) {
            ast_build_string(&tmp, &len, " /></response>\n");
            inobj = 0;

            /* Entity is closed, so close out the name cache */
            ao2_ref(vco, -1);
            vco = NULL;
         }
         count = 0;
         while (*in && (*in < 32)) {
            *in = '\0';
            in++;
            count++;
         }
         val = strchr(var, ':');
         if (val) {
            *val = '\0';
            val++;
            if (*val == ' ')
               val++;
            if (!inobj) {
               vco = ao2_container_alloc(37, variable_count_hash_fn, variable_count_cmp_fn);
               ast_build_string(&tmp, &len, "<response type='object' id='%s'><%s", dest, objtype);
               inobj = 1;
            }

            /* Check if the var has been used already */
            if ((vc = ao2_find(vco, var, 0)))
               vc->count++;
            else {
               /* Create a new entry for this one */
               vc = ao2_alloc(sizeof(*vc), NULL);
               vc->varname = var;
               vc->count = 1;
               ao2_link(vco, vc);
            }

            ast_build_string(&tmp, &len, " ");
            xml_copy_escape(&tmp, &len, var, 1);
            if (vc->count > 1)
               ast_build_string(&tmp, &len, "-%d", vc->count);
            ast_build_string(&tmp, &len, "='");
            xml_copy_escape(&tmp, &len, val, 0);
            ast_build_string(&tmp, &len, "'");
            ao2_ref(vc, -1);
         }
      }
   }
   if (inobj)
      ast_build_string(&tmp, &len, " /></response>\n");
   if (vco)
      ao2_ref(vco, -1);
   return out;
}

static char *html_translate(char *in)
{
   int x;
   int colons = 0;
   int breaks = 0;
   size_t len;
   int count = 1;
   char *tmp, *var, *val, *out;

   for (x=0; in[x]; x++) {
      if (in[x] == ':')
         colons++;
      if (in[x] == '\n')
         breaks++;
   }
   len = strlen(in) + colons * 40 + breaks * 40; /* <tr><td></td><td></td></tr>, "<tr><td colspan=\"2\"><hr></td></tr> */
   out = ast_malloc(len);
   if (!out)
      return 0;
   tmp = out;
   while (*in) {
      var = in;
      while (*in && (*in >= 32))
         in++;
      if (*in) {
         if ((count % 4) == 0){
            ast_build_string(&tmp, &len, "<tr><td colspan=\"2\"><hr></td></tr>\r\n");
         }
         count = 0;
         while (*in && (*in < 32)) {
            *in = '\0';
            in++;
            count++;
         }
         val = strchr(var, ':');
         if (val) {
            *val = '\0';
            val++;
            if (*val == ' ')
               val++;
            ast_build_string(&tmp, &len, "<tr><td>%s</td><td>%s</td></tr>\r\n", var, val);
         }
      }
   }
   return out;
}



static struct ast_manager_user *ast_get_manager_by_name_locked(const char *name)
{
   struct ast_manager_user *user = NULL;

   AST_LIST_TRAVERSE(&users, user, list)
      if (!strcasecmp(user->username, name))
         break;
   return user;
}

void astman_append(struct mansession *s, const char *fmt, ...)
{
   va_list ap;
   struct ast_dynamic_str *buf;

   ast_mutex_lock(&s->__lock);

   if (!(buf = ast_dynamic_str_thread_get(&astman_append_buf, ASTMAN_APPEND_BUF_INITSIZE))) {
      ast_mutex_unlock(&s->__lock);
      return;
   }

   va_start(ap, fmt);
   ast_dynamic_str_thread_set_va(&buf, 0, &astman_append_buf, fmt, ap);
   va_end(ap);
   
   if (s->fd > -1)
      ast_carefulwrite(s->fd, buf->str, strlen(buf->str), s->writetimeout);
   else {
      if (!s->outputstr && !(s->outputstr = ast_calloc(1, sizeof(*s->outputstr)))) {
         ast_mutex_unlock(&s->__lock);
         return;
      }

      ast_dynamic_str_append(&s->outputstr, 0, "%s", buf->str);   
   }

   ast_mutex_unlock(&s->__lock);
}

static int handle_showmancmd(int fd, int argc, char *argv[])
{
   struct manager_action *cur;
   char authority[80];
   int num;

   if (argc != 4)
      return RESULT_SHOWUSAGE;

   ast_rwlock_rdlock(&actionlock);
   for (cur = first_action; cur; cur = cur->next) { /* Walk the list of actions */
      for (num = 3; num < argc; num++) {
         if (!strcasecmp(cur->action, argv[num])) {
            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 : "");
         }
      }
   }
   ast_rwlock_unlock(&actionlock);

   return RESULT_SUCCESS;
}

static int handle_showmanager(int fd, int argc, char *argv[])
{
   struct ast_manager_user *user = NULL;

   if (argc != 4)
      return RESULT_SHOWUSAGE;

   AST_LIST_LOCK(&users);

   if (!(user = ast_get_manager_by_name_locked(argv[3]))) {
      ast_cli(fd, "There is no manager called %s\n", argv[3]);
      AST_LIST_UNLOCK(&users);
      return -1;
   }

   ast_cli(fd,"\n");
   ast_cli(fd,
      "       username: %s\n"
      "         secret: %s\n"
      "           deny: %s\n"
      "         permit: %s\n"
      "           read: %s\n"
      "          write: %s\n"
      "displayconnects: %s\n",
      (user->username ? user->username : "(N/A)"),
      (user->secret ? "<Set>" : "(N/A)"),
      (user->deny ? user->deny : "(N/A)"),
      (user->permit ? user->permit : "(N/A)"),
      (user->read ? user->read : "(N/A)"),
      (user->write ? user->write : "(N/A)"),
      (user->displayconnects ? "yes" : "no"));

   AST_LIST_UNLOCK(&users);

   return RESULT_SUCCESS;
}


static int handle_showmanagers(int fd, int argc, char *argv[])
{
   struct ast_manager_user *user = NULL;
   int count_amu = 0;

   if (argc != 3)
      return RESULT_SHOWUSAGE;

   AST_LIST_LOCK(&users);

   /* If there are no users, print out something along those lines */
   if (AST_LIST_EMPTY(&users)) {
      ast_cli(fd, "There are no manager users.\n");
      AST_LIST_UNLOCK(&users);
      return RESULT_SUCCESS;
   }

   ast_cli(fd, "\nusername\n--------\n");

   AST_LIST_TRAVERSE(&users, user, list) {
      ast_cli(fd, "%s\n", user->username);
      count_amu++;
   }

   AST_LIST_UNLOCK(&users);

   ast_cli(fd,"-------------------\n");
   ast_cli(fd,"%d manager users configured.\n", count_amu);

   return RESULT_SUCCESS;
}


/*! \brief  CLI command 
   Should change to "manager show commands" */
static int handle_showmancmds(int fd, int argc, char *argv[])
{
   struct manager_action *cur;
   char authority[80];
   char *format = "  %-15.15s  %-15.15s  %-55.55s\n";

   ast_cli(fd, format, "Action", "Privilege", "Synopsis");
   ast_cli(fd, format, "------", "---------", "--------");
   
   ast_rwlock_rdlock(&actionlock);
   for (cur = first_action; cur; cur = cur->next) /* Walk the list of actions */
      ast_cli(fd, format, cur->action, authority_to_str(cur->authority, authority, sizeof(authority) -1), cur->synopsis);
   ast_rwlock_unlock(&actionlock);
   
   return RESULT_SUCCESS;
}

/*! \brief CLI command show manager connected */
/* Should change to "manager show connected" */
static int handle_showmanconn(int fd, int argc, char *argv[])
{
   struct mansession *s;
   char *format = "  %-15.15s  %-15.15s\n";

   ast_cli(fd, format, "Username", "IP Address");
   
   AST_LIST_LOCK(&sessions);
   AST_LIST_TRAVERSE(&sessions, s, list)
      ast_cli(fd, format,s->username, ast_inet_ntoa(s->sin.sin_addr));
   AST_LIST_UNLOCK(&sessions);

   return RESULT_SUCCESS;
}

/*! \brief CLI command show manager connected */
/* Should change to "manager show connected" */
static int handle_showmaneventq(int fd, int argc, char *argv[])
{
   struct eventqent *s;

   AST_LIST_LOCK(&sessions);
   for (s = master_eventq; s; s = s->next) {
      ast_cli(fd, "Usecount: %d\n",s->usecount);
      ast_cli(fd, "Category: %d\n", s->category);
      ast_cli(fd, "Event:\n%s", s->eventdata);
   }
   AST_LIST_UNLOCK(&sessions);

   return RESULT_SUCCESS;
}

static char showmancmd_help[] = 
"Usage: manager show command <actionname>\n"
"  Shows the detailed description for a specific Asterisk manager interface command.\n";

static char showmancmds_help[] = 
"Usage: manager show commands\n"
"  Prints a listing of all the available Asterisk manager interface commands.\n";

static char showmanconn_help[] = 
"Usage: manager show connected\n"
"  Prints a listing of the users that are currently connected to the\n"
"Asterisk manager interface.\n";

static char showmaneventq_help[] = 
"Usage: manager show eventq\n"
"  Prints a listing of all events pending in the Asterisk manger\n"
"event queue.\n";

static char showmanagers_help[] =
"Usage: manager show users\n"
"       Prints a listing of all managers that are currently configured on that\n"
" system.\n";

static char showmanager_help[] =
" Usage: manager show user <user>\n"
"        Display all information related to the manager user specified.\n";

static struct ast_cli_entry cli_show_manager_command_deprecated = {
   { "show", "manager", "command", NULL },
   handle_showmancmd, NULL,
   NULL, complete_show_mancmd };

static struct ast_cli_entry cli_show_manager_commands_deprecated = {
   { "show", "manager", "commands", NULL },
   handle_showmancmds, NULL,
   NULL };

static struct ast_cli_entry cli_show_manager_connected_deprecated = {
   { "show", "manager", "connected", NULL },
   handle_showmanconn, NULL,
   NULL };

static struct ast_cli_entry cli_show_manager_eventq_deprecated = {
   { "show", "manager", "eventq", NULL },
   handle_showmaneventq, NULL,
   NULL };

static struct ast_cli_entry cli_manager[] = {
   { { "manager", "show", "command", NULL },
   handle_showmancmd, "Show a manager interface command",
   showmancmd_help, complete_show_mancmd, &cli_show_manager_command_deprecated },

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

   { { "manager", "show", "connected", NULL },
   handle_showmanconn, "List connected manager interface users",
   showmanconn_help, NULL, &cli_show_manager_connected_deprecated },

   { { "manager", "show", "eventq", NULL },
   handle_showmaneventq, "List manager interface queued events",
   showmaneventq_help, NULL, &cli_show_manager_eventq_deprecated },

   { { "manager", "show", "users", NULL },
   handle_showmanagers, "List configured manager users",
   showmanagers_help, NULL, NULL },

   { { "manager", "show", "user", NULL },
   handle_showmanager, "Display information on a specific manager user",
   showmanager_help, NULL, NULL },
};

static void unuse_eventqent(struct eventqent *e)
{
   if (ast_atomic_dec_and_test(&e->usecount) && e->next)
      pthread_kill(t, SIGURG);
}

static void free_session(struct mansession *s)
{
   struct eventqent *eqe;
   if (s->fd > -1)
      close(s->fd);
   if (s->outputstr)
      free(s->outputstr);
   ast_mutex_destroy(&s->__lock);
   while (s->eventq) {
      eqe = s->eventq;
      s->eventq = s->eventq->next;
      unuse_eventqent(eqe);
   }
   free(s);
}

static void destroy_session(struct mansession *s)
{
   AST_LIST_LOCK(&sessions);
   AST_LIST_REMOVE(&sessions, s, list);
   num_sessions--;
   free_session(s);
   AST_LIST_UNLOCK(&sessions);
}

const char *astman_get_header(const struct message *m, char *var)
{
   char cmp[80];
   int x;

   snprintf(cmp, sizeof(cmp), "%s: ", var);

   for (x = 0; x < m->hdrcount; x++) {
      if (!strncasecmp(cmp, m->headers[x], strlen(cmp)))
         return m->headers[x] + strlen(cmp);
   }

   return "";
}

struct ast_variable *astman_get_variables(const struct message *m)
{
   int varlen, x, y;
   struct ast_variable *head = NULL, *cur;
   char *var, *val;

   char *parse;    
   AST_DECLARE_APP_ARGS(args,
      AST_APP_ARG(vars)[32];
   );

   varlen = strlen("Variable: ");   

   for (x = 0; x < m->hdrcount; x++) {
      if (strncasecmp("Variable: ", m->headers[x], varlen))
         continue;

      parse = ast_strdupa(m->headers[x] + varlen);

      AST_STANDARD_APP_ARGS(args, parse);
      if (args.argc) {
         for (y = 0; y < args.argc; y++) {
            if (!args.vars[y])
               continue;
            var = val = ast_strdupa(args.vars[y]);
            strsep(&val, "=");
            if (!val || ast_strlen_zero(var))
               continue;
            cur = ast_variable_new(var, val);
            if (head) {
               cur->next = head;
               head = cur;
            } else
               head = cur;
         }
      }
   }

   return head;
}

/*! \note NOTE:
   Callers of astman_send_error(), astman_send_response() or astman_send_ack() must EITHER
   hold the session lock _or_ be running in an action callback (in which case s->busy will
   be non-zero). In either of these cases, there is no need to lock-protect the session's
   fd, since no other output will be sent (events will be queued), and no input will
   be read until either the current action finishes or get_input() obtains the session
   lock.
 */
void astman_send_error(struct mansession *s, const struct message *m, char *error)
{
   const char *id = astman_get_header(m,"ActionID");

   astman_append(s, "Response: Error\r\n");
   if (!ast_strlen_zero(id))
      astman_append(s, "ActionID: %s\r\n", id);
   astman_append(s, "Message: %s\r\n\r\n", error);
}

void astman_send_response(struct mansession *s, const struct message *m, char *resp, char *msg)
{
   const char *id = astman_get_header(m,"ActionID");

   astman_append(s, "Response: %s\r\n", resp);
   if (!ast_strlen_zero(id))
      astman_append(s, "ActionID: %s\r\n", id);
   if (msg)
      astman_append(s, "Message: %s\r\n\r\n", msg);
   else
      astman_append(s, "\r\n");
}

void astman_send_ack(struct mansession *s, const struct message *m, char *msg)
{
   astman_send_response(s, m, "Success", msg);
}

/*! 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 */
static int ast_instring(const char *bigstr, const char *smallstr, char delim) 
{
   const char *val = bigstr, *next;

   do {
      if ((next = strchr(val, delim))) {
         if (!strncmp(val, smallstr, (next - val)))
            return 1;
         else
            continue;
      } else
         return !strcmp(smallstr, val);

   } while (*(val = (next + 1)));

   return 0;
}

static int get_perm(const char *instr)
{
   int x = 0, ret = 0;

   if (!instr)
      return 0;

   for (x = 0; x < (sizeof(perms) / sizeof(perms[0])); x++) {
      if (ast_instring(instr, perms[x].label, ','))
         ret |= perms[x].num;
   }
   
   return ret;
}

static int ast_is_number(const char *string) 
{
   int ret = 1, x = 0;

   if (!string)
      return 0;

   for (x = 0; x < strlen(string); x++) {
      if (!(string[x] >= 48 && string[x] <= 57)) {
         ret = 0;
         break;
      }
   }
   
   return ret ? atoi(string) : 0;
}

static int strings_to_mask(const char *string) 
{
   int x, ret = -1;
   
   x = ast_is_number(string);

   if (x)
      ret = x;
   else if (ast_strlen_zero(string))
      ret = -1;
   else if (ast_false(string))
      ret = 0;
   else if (ast_true(string)) {
      ret = 0;
      for (x=0; x<sizeof(perms) / sizeof(perms[0]); x++)
         ret |= perms[x].num;    
   } else {
      ret = 0;
      for (x=0; x<sizeof(perms) / sizeof(perms[0]); x++) {
         if (ast_instring(string, perms[x].label, ',')) 
            ret |= perms[x].num;    
      }
   }

   return ret;
}

/*! \brief
   Rather than braindead on,off this now can also accept a specific int mask value 
   or a ',' delim list of mask strings (the same as manager.conf) -anthm
*/
static int set_eventmask(struct mansession *s, const char *eventmask)
{
   int maskint = strings_to_mask(eventmask);

   ast_mutex_lock(&s->__lock);
   if (maskint >= 0) 
      s->send_events = maskint;
   ast_mutex_unlock(&s->__lock);
   
   return maskint;
}

static int authenticate(struct mansession *s, const struct message *m)
{
   struct ast_config *cfg;
   char *cat;
   const char *user = astman_get_header(m, "Username");
   const char *pass = astman_get_header(m, "Secret");
   const char *authtype = astman_get_header(m, "AuthType");
   const char *key = astman_get_header(m, "Key");
   const char *events = astman_get_header(m, "Events");
   
   cfg = ast_config_load("manager.conf");
   if (!cfg)
      return -1;
   cat = ast_category_browse(cfg, NULL);
   while (cat) {
      if (strcasecmp(cat, "general")) {
         /* This is a user */
         if (!strcasecmp(cat, user)) {
            struct ast_variable *v;
            struct ast_ha *ha = NULL;
            char *password = NULL;

            for (v = ast_variable_browse(cfg, cat); v; v = v->next) {
               if (!strcasecmp(v->name, "secret")) {
                  password = v->value;
               } else if (!strcasecmp(v->name, "displaysystemname")) {
                  if (ast_true(v->value)) {
                     if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME)) {
                        s->displaysystemname = 1;
                     } else {
                        ast_log(LOG_ERROR, "Can't enable displaysystemname in manager.conf - no system name configured in asterisk.conf\n");
                     }