manager.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * Channel Management and more
   5  *
   6  * Copyright (C) 1999, Mark Spencer
   7  *
   8  * Mark Spencer <markster@linux-support.net>
   9  *
  10  * This program is free software, distributed under the terms of
  11  * the GNU General Public License
  12  */
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <pthread.h>
  17 #include <string.h>
  18 #include <sys/time.h>
  19 #include <sys/types.h>
  20 #include <netdb.h>
  21 #include <sys/socket.h>
  22 #include <netinet/in.h>
  23 #include <netinet/tcp.h>
  24 #include <arpa/inet.h>
  25 #include <signal.h>
  26 #include <errno.h>
  27 #include <unistd.h>
  28 #include <asterisk/channel.h>
  29 #include <asterisk/file.h>
  30 #include <asterisk/manager.h>
  31 #include <asterisk/config.h>
  32 #include <asterisk/lock.h>
  33 #include <asterisk/logger.h>
  34 #include <asterisk/options.h>
  35 #include <asterisk/cli.h>
  36 #include <asterisk/app.h>
  37 #include <asterisk/pbx.h>
  38 #include <asterisk/md5.h>
  39 #include <asterisk/acl.h>
  40
  41 static int enabled = 0;
  42 static int portno = DEFAULT_MANAGER_PORT;
  43 static int asock = -1;
  44 static pthread_t t;
  45 static pthread_mutex_t sessionlock = AST_MUTEX_INITIALIZER;
  46
  47 static struct permalias {
  48         int num;
  49         char *label;
  50 } perms[] = {
  51         { EVENT_FLAG_SYSTEM, "system" },
  52         { EVENT_FLAG_CALL, "call" },
  53         { EVENT_FLAG_LOG, "log" },
  54         { EVENT_FLAG_VERBOSE, "verbose" },
  55         { EVENT_FLAG_COMMAND, "command" },
  56         { EVENT_FLAG_AGENT, "agent" },
  57         { EVENT_FLAG_USER, "user" },
  58         { -1, "all" },
  59 };
  60
  61 static struct mansession *sessions = NULL;
  62 static struct manager_action *first_action = NULL;
  63 static pthread_mutex_t actionlock = AST_MUTEX_INITIALIZER;
  64
  65 static int handle_showmancmds(int fd, int argc, char *argv[])
  66 {
  67         struct manager_action *cur = first_action;
  68
  69         ast_pthread_mutex_lock(&actionlock);
  70         while(cur) { /* Walk the list of actions */
  71                 ast_cli(fd, "\t%s  %s\r\n",cur->action, cur->synopsis);
  72                 cur = cur->next;
  73         }
  74
  75         ast_pthread_mutex_unlock(&actionlock);
  76         return RESULT_SUCCESS;
  77 }
  78
  79 static int handle_showmanconn(int fd, int argc, char *argv[])
  80 {
  81         struct mansession *s;
  82
  83         ast_pthread_mutex_lock(&sessionlock);
  84         s = sessions;
  85         ast_cli(fd, "  Username\tIP Address\n");
  86         while(s) {
  87                 ast_cli(fd, "  %s\t\t%s\r\n",s->username, inet_ntoa(s->sin.sin_addr));
  88                 s = s->next;
  89         }
  90
  91         ast_pthread_mutex_unlock(&sessionlock);
  92         return RESULT_SUCCESS;
  93 }
  94
  95 static char showmancmds_help[] =
  96 "Usage: show manager commands\n"
  97 "       Prints a listing of all the available manager commands.\n";
  98
  99 static char showmanconn_help[] =
 100 "Usage: show manager connected\n"
 101 "       Prints a listing of the users that are connected to the\n"
 102 "manager interface.\n";
 103
 104 static struct ast_cli_entry show_mancmds_cli =
 105         { { "show", "manager", "commands", NULL },
 106         handle_showmancmds, "Show manager commands", showmancmds_help };
 107
 108 static struct ast_cli_entry show_manconn_cli =
 109         { { "show", "manager", "connected", NULL },
 110         handle_showmanconn, "Show connected manager users", showmanconn_help };
 111
 112 static void destroy_session(struct mansession *s)
 113 {
 114         struct mansession *cur, *prev = NULL;
 115         ast_pthread_mutex_lock(&sessionlock);
 116         cur = sessions;
 117         while(cur) {
 118                 if (cur == s)
 119                         break;
 120                 prev = cur;
 121                 cur = cur->next;
 122         }
 123         if (cur) {
 124                 if (prev)
 125                         prev->next = cur->next;
 126                 else
 127                         sessions = cur->next;
 128                 if (s->fd > -1)
 129                         close(s->fd);
 130                 free(s);
 131         } else
 132                 ast_log(LOG_WARNING, "Trying to delete non-existant session %p?\n", s);
 133         ast_pthread_mutex_unlock(&sessionlock);
 134
 135 }
 136
 137 char *astman_get_header(struct message *m, char *var)
 138 {
 139         char cmp[80];
 140         int x;
 141         snprintf(cmp, sizeof(cmp), "%s: ", var);
 142         for (x=0;x<m->hdrcount;x++)
 143                 if (!strncasecmp(cmp, m->headers[x], strlen(cmp)))
 144                         return m->headers[x] + strlen(cmp);
 145         return "";
 146 }
 147
 148 void astman_send_error(struct mansession *s, char *error)
 149 {
 150         ast_pthread_mutex_lock(&s->lock);
 151         ast_cli(s->fd, "Response: Error\r\n");
 152         ast_cli(s->fd, "Message: %s\r\n\r\n", error);
 153         ast_pthread_mutex_unlock(&s->lock);
 154 }
 155
 156 void astman_send_response(struct mansession *s, char *resp, char *msg)
 157 {
 158         ast_pthread_mutex_lock(&s->lock);
 159         ast_cli(s->fd, "Response: %s\r\n", resp);
 160         if (msg)
 161                 ast_cli(s->fd, "Message: %s\r\n\r\n", msg);
 162         else
 163                 ast_cli(s->fd, "\r\n");
 164         ast_pthread_mutex_unlock(&s->lock);
 165 }
 166
 167 void astman_send_ack(struct mansession *s, char *msg)
 168 {
 169         astman_send_response(s, "Success", msg);
 170 }
 171
 172 static int get_perm(char *instr)
 173 {
 174         char tmp[256];
 175         char *c;
 176         int x;
 177         int ret = 0;
 178         char *stringp=NULL;
 179         if (!instr)
 180                 return 0;
 181         strncpy(tmp, instr, sizeof(tmp) - 1);
 182         stringp=tmp;
 183         c = strsep(&stringp, ",");
 184         while(c) {
 185                 for (x=0;x<sizeof(perms) / sizeof(perms[0]);x++) {
 186                         if (!strcasecmp(perms[x].label, c))
 187                                 ret |= perms[x].num;
 188                 }
 189                 c = strsep(&stringp, ",");
 190         }
 191         return ret;
 192 }
 193
 194 static int authenticate(struct mansession *s, struct message *m)
 195 {
 196         struct ast_config *cfg;
 197         char *cat;
 198         char *user = astman_get_header(m, "Username");
 199         char *pass = astman_get_header(m, "Secret");
 200         char *authtype = astman_get_header(m, "AuthType");
 201         char *key = astman_get_header(m, "Key");
 202
 203         cfg = ast_load("manager.conf");
 204         if (!cfg)
 205                 return -1;
 206         cat = ast_category_browse(cfg, NULL);
 207         while(cat) {
 208                 if (strcasecmp(cat, "general")) {
 209                         /* This is a user */
 210                         if (!strcasecmp(cat, user)) {
 211                                 struct ast_variable *v;
 212                                 struct ast_ha *ha = NULL;
 213                                 char *password = NULL;
 214                                 v = ast_variable_browse(cfg, cat);
 215                                 while (v) {
 216                                         if (!strcasecmp(v->name, "secret")) {
 217                                                 password = v->value;
 218                                         } else if (!strcasecmp(v->name, "permit") ||
 219                                                    !strcasecmp(v->name, "deny")) {
 220                                                         ha = ast_append_ha(v->name, v->value, ha);
 221                                         }
 222                                         v = v->next;
 223                                 }
 224                                 if (ha && !ast_apply_ha(ha, &(s->sin))) {
 225                                         ast_log(LOG_NOTICE, "%s failed to pass IP ACL as '%s'\n", inet_ntoa(s->sin.sin_addr), user);
 226                                         ast_free_ha(ha);
 227                                         ast_destroy(cfg);
 228                                         return -1;
 229                                 } else if (ha)
 230                                         ast_free_ha(ha);
 231                                 if (!strcasecmp(authtype, "MD5")) {
 232                                         if (key && strlen(key) && s->challenge) {
 233                                                 int x;
 234                                                 int len=0;
 235                                                 char md5key[256] = "";
 236                                                 struct MD5Context md5;
 237                                                 unsigned char digest[16];
 238                                                 MD5Init(&md5);
 239                                                 MD5Update(&md5, s->challenge, strlen(s->challenge));
 240                                                 MD5Update(&md5, password, strlen(password));
 241                                                 MD5Final(digest, &md5);
 242                                                 for (x=0;x<16;x++)
 243                                                         len += sprintf(md5key + len, "%2.2x", digest[x]);
 244                                                 if (!strcmp(md5key, key))
 245                                                         break;
 246                                                 else {
 247                                                         ast_destroy(cfg);
 248                                                         return -1;
 249                                                 }
 250                                         }
 251                                 } else if (password && !strcasecmp(password, pass)) {
 252                                         break;
 253                                 } else {
 254                                         ast_log(LOG_NOTICE, "%s failed to authenticate as '%s'\n", inet_ntoa(s->sin.sin_addr), user);
 255                                         ast_destroy(cfg);
 256                                         return -1;
 257                                 }
 258                         }
 259                 }
 260                 cat = ast_category_browse(cfg, cat);
 261         }
 262         if (cat) {
 263                 strncpy(s->username, cat, sizeof(s->username) - 1);
 264                 s->readperm = get_perm(ast_variable_retrieve(cfg, cat, "read"));
 265                 s->writeperm = get_perm(ast_variable_retrieve(cfg, cat, "write"));
 266                 ast_destroy(cfg);
 267                 return 0;
 268         }
 269         ast_log(LOG_NOTICE, "%s tried to authenticate with non-existant user '%s'\n", inet_ntoa(s->sin.sin_addr), user);
 270         ast_destroy(cfg);
 271         return -1;
 272 }
 273
 274 static int action_ping(struct mansession *s, struct message *m)
 275 {
 276         astman_send_response(s, "Pong", NULL);
 277         return 0;
 278 }
 279
 280 static int action_logoff(struct mansession *s, struct message *m)
 281 {
 282         astman_send_response(s, "Goodbye", "Thanks for all the fish.");
 283         return -1;
 284 }
 285
 286 static int action_hangup(struct mansession *s, struct message *m)
 287 {
 288         struct ast_channel *c = NULL;
 289         char *name = astman_get_header(m, "Channel");
 290         if (!strlen(name)) {
 291                 astman_send_error(s, "No channel specified");
 292                 return 0;
 293         }
 294         c = ast_channel_walk(NULL);
 295         while(c) {
 296                 if (!strcasecmp(c->name, name)) {
 297                         break;
 298                 }
 299                 c = ast_channel_walk(c);
 300         }
 301         if (!c) {
 302                 astman_send_error(s, "No such channel");
 303                 return 0;
 304         }
 305         ast_softhangup(c, AST_SOFTHANGUP_EXPLICIT);
 306         astman_send_ack(s, "Channel Hungup");
 307         return 0;
 308 }
 309
 310 static int action_status(struct mansession *s, struct message *m)
 311 {
 312         struct ast_channel *c;
 313         char bridge[256];
 314         astman_send_ack(s, "Channel status will follow");
 315         c = ast_channel_walk(NULL);
 316         while(c) {
 317                 if (c->bridge)
 318                         snprintf(bridge, sizeof(bridge), "Link: %s\r\n", c->bridge->name);
 319                 else
 320                         strcpy(bridge, "");
 321                 if (c->pbx) {
 322                         ast_cli(s->fd,
 323                         "Event: Status\r\n"
 324                         "Channel: %s\r\n"
 325                         "CallerID: %s\r\n"
 326                         "State: %s\r\n"
 327                         "Context: %s\r\n"
 328                         "Extension: %s\r\n"
 329                         "Priority: %d\r\n"
 330                         "%s"
 331                         "\r\n"
 332                         "Uniqueid: %s\r\n",
 333                         c->name, c->callerid ? c->callerid : "<unknown>",
 334                         ast_state2str(c->_state), c->context,
 335                         c->exten, c->priority, bridge, c->uniqueid);
 336                 } else {
 337                         ast_cli(s->fd,
 338                         "Event: Status\r\n"
 339                         "Channel: %s\r\n"
 340                         "CallerID: %s\r\n"
 341                         "State: %s\r\n"
 342                         "%s"
 343                         "\r\n"
 344                         "Uniqueid: %s\r\n",
 345                         c->name, c->callerid ? c->callerid : "<unknown>",
 346                         ast_state2str(c->_state), bridge, c->uniqueid);
 347                 }
 348                 c = ast_channel_walk(c);
 349         }
 350         return 0;
 351 }
 352
 353 static int action_redirect(struct mansession *s, struct message *m)
 354 {
 355         char *name = astman_get_header(m, "Channel");
 356         char *name2 = astman_get_header(m, "ExtraChannel");
 357         char *exten = astman_get_header(m, "Exten");
 358         char *context = astman_get_header(m, "Context");
 359         char *priority = astman_get_header(m, "Priority");
 360         int pi = 0;
 361         int res;
 362         if (!name || !strlen(name)) {
 363                 astman_send_error(s, "Channel not specified");
 364                 return 0;
 365         }
 366         if (strlen(priority) && (sscanf(priority, "%d", &pi) != 1)) {
 367                 astman_send_error(s, "Invalid priority\n");
 368                 return 0;
 369         }
 370         res = ast_async_goto_by_name(name, context, exten, pi);
 371         if (!res) {
 372                 if (strlen(name2)) {
 373                         res = ast_async_goto_by_name(name2, context, exten, pi);
 374                         if (!res)
 375                                 astman_send_ack(s, "Dual Redirect successful");
 376                         else
 377                                 astman_send_error(s, "Secondary redirect failed");
 378                 } else
 379                         astman_send_ack(s, "Redirect successful");
 380         } else
 381                 astman_send_error(s, "Redirect failed");
 382         return 0;
 383 }
 384
 385 static int action_command(struct mansession *s, struct message *m)
 386 {
 387         char *cmd = astman_get_header(m, "Command");
 388         ast_pthread_mutex_lock(&s->lock);
 389         s->blocking = 1;
 390         ast_pthread_mutex_unlock(&s->lock);
 391         ast_cli(s->fd, "Response: Follows\r\n");
 392         ast_cli_command(s->fd, cmd);
 393         ast_cli(s->fd, "--END COMMAND--\r\n\r\n");
 394         ast_pthread_mutex_lock(&s->lock);
 395         s->blocking = 0;
 396         ast_pthread_mutex_unlock(&s->lock);
 397         return 0;
 398 }
 399
 400 static int action_originate(struct mansession *s, struct message *m)
 401 {
 402         char *name = astman_get_header(m, "Channel");
 403         char *exten = astman_get_header(m, "Exten");
 404         char *context = astman_get_header(m, "Context");
 405         char *priority = astman_get_header(m, "Priority");
 406         char *timeout = astman_get_header(m, "Timeout");
 407         char *callerid = astman_get_header(m, "CallerID");
 408         char *tech, *data;
 409         int pi = 0;
 410         int res;
 411         int to = 30000;
 412         int reason = 0;
 413         char tmp[256];
 414         if (!name) {
 415                 astman_send_error(s, "Channel not specified");
 416                 return 0;
 417         }
 418         if (strlen(priority) && (sscanf(priority, "%d", &pi) != 1)) {
 419                 astman_send_error(s, "Invalid priority\n");
 420                 return 0;
 421         }
 422         if (strlen(timeout) && (sscanf(timeout, "%d", &to) != 1)) {
 423                 astman_send_error(s, "Invalid timeout\n");
 424                 return 0;
 425         }
 426         strncpy(tmp, name, sizeof(tmp) - 1);
 427         tech = tmp;
 428         data = strchr(tmp, '/');
 429         if (!data) {
 430                 astman_send_error(s, "Invalid channel\n");
 431                 return 0;
 432         }
 433         *data = '\0';
 434         data++;
 435         res = ast_pbx_outgoing_exten(tech, AST_FORMAT_SLINEAR, data, to, context, exten, pi, &reason, 0, strlen(callerid) ? callerid : NULL, NULL );
 436         if (!res)
 437                 astman_send_ack(s, "Originate successfully queued");
 438         else
 439                 astman_send_error(s, "Originate failed");
 440         return 0;
 441 }
 442
 443 static int action_mailboxstatus(struct mansession *s, struct message *m)
 444 {
 445         char *mailbox = astman_get_header(m, "Mailbox");
 446         if (!mailbox || !strlen(mailbox)) {
 447                 astman_send_error(s, "Mailbox not specified");
 448                 return 0;
 449         }
 450         ast_cli(s->fd, "Response: Success\r\n"
 451                                    "Message: Mailbox Status\r\n"
 452                                    "Mailbox: %s\r\n"
 453                                    "Waiting: %d\r\n\r\n", mailbox, ast_app_has_voicemail(mailbox));
 454         return 0;
 455 }
 456
 457 static int action_extensionstate(struct mansession *s, struct message *m)
 458 {
 459         char *exten = astman_get_header(m, "Exten");
 460         char *context = astman_get_header(m, "Context");
 461         char hint[256] = "";
 462         int status;
 463         if (!exten || !strlen(exten)) {
 464                 astman_send_error(s, "Extension not specified");
 465                 return 0;
 466         }
 467         if (!context || !strlen(context))
 468                 context = "default";
 469         status = ast_extension_state(NULL, context, exten);
 470         ast_get_hint(hint, sizeof(hint) - 1, NULL, context, exten);
 471         ast_cli(s->fd, "Response: Success\r\n"
 472                                    "Message: Extension Status\r\n"
 473                                    "Exten: %s\r\n"
 474                                    "Context: %s\r\n"
 475                                    "Hint: %s\r\n"
 476                                    "Status: %d\r\n\r\n", exten, context, hint, status);
 477         return 0;
 478 }
 479
 480 static int action_timeout(struct mansession *s, struct message *m)
 481 {
 482         struct ast_channel *c = NULL;
 483         char *name = astman_get_header(m, "Channel");
 484         int timeout = atoi(astman_get_header(m, "Timeout"));
 485         if (!strlen(name)) {
 486                 astman_send_error(s, "No channel specified");
 487                 return 0;
 488         }
 489         if (!timeout) {
 490                 astman_send_error(s, "No timeout specified");
 491                 return 0;
 492         }
 493         c = ast_channel_walk(NULL);
 494         while(c) {
 495                 if (!strcasecmp(c->name, name)) {
 496                         break;
 497                 }
 498                 c = ast_channel_walk(c);
 499         }
 500         if (!c) {
 501                 astman_send_error(s, "No such channel");
 502                 return 0;
 503         }
 504         ast_channel_setwhentohangup(c, timeout);
 505         astman_send_ack(s, "Timeout Set");
 506         return 0;
 507 }
 508
 509 static int process_message(struct mansession *s, struct message *m)
 510 {
 511         char action[80];
 512         struct manager_action *tmp = first_action;
 513
 514         strncpy(action, astman_get_header(m, "Action"), sizeof(action));
 515         ast_log( LOG_DEBUG, "Manager received command '%s'\n", action );
 516
 517         if (!strlen(action)) {
 518                 astman_send_error(s, "Missing action in request");
 519                 return 0;
 520         }
 521         if (!s->authenticated) {
 522                 if (!strcasecmp(action, "Challenge")) {
 523                         char *authtype;
 524                         authtype = astman_get_header(m, "AuthType");
 525                         if (!strcasecmp(authtype, "MD5")) {
 526                                 if (!s->challenge || !strlen(s->challenge)) {
 527                                         ast_pthread_mutex_lock(&s->lock);
 528                                         snprintf(s->challenge, sizeof(s->challenge), "%d", rand());
 529                                         ast_pthread_mutex_unlock(&s->lock);
 530                                 }
 531                                 ast_cli(s->fd, "Response: Success\r\nChallenge: %s\r\n\r\n", s->challenge);
 532                                 return 0;
 533                         } else {
 534                                 astman_send_error(s, "Must specify AuthType");
 535                                 return 0;
 536                         }
 537                 } else if (!strcasecmp(action, "Login")) {
 538                         if (authenticate(s, m)) {
 539                                 sleep(1);
 540                                 astman_send_error(s, "Authentication failed");
 541                                 return -1;
 542                         } else {
 543                                 s->authenticated = 1;
 544                                 if (option_verbose > 1)
 545                                         ast_verbose(VERBOSE_PREFIX_2 "Manager '%s' logged on from %s\n", s->username, inet_ntoa(s->sin.sin_addr));
 546                                 ast_log(LOG_EVENT, "Manager '%s' logged on from %s\n", s->username, inet_ntoa(s->sin.sin_addr));
 547                                 astman_send_ack(s, "Authentication accepted");
 548                         }
 549                 } else
 550                         astman_send_error(s, "Authentication Required");
 551         } else {
 552                 while( tmp ) {
 553                         if (!strcasecmp(action, tmp->action)) {
 554                                 if ((s->writeperm & tmp->authority) == tmp->authority) {
 555                                         if (tmp->func(s, m))
 556                                                 return -1;
 557                                 } else {
 558                                         astman_send_error(s, "Permission denied");
 559                                 }
 560                                 return 0;
 561                         }
 562                         tmp = tmp->next;
 563                 }
 564                 astman_send_error(s, "Invalid/unknown command");
 565         }
 566         return 0;
 567 }
 568
 569 static int get_input(struct mansession *s, char *output)
 570 {
 571         /* output must have at least sizeof(s->inbuf) space */
 572         int res;
 573         int x;
 574         fd_set fds;
 575         for (x=1;x<s->inlen;x++) {
 576                 if ((s->inbuf[x] == '\n') && (s->inbuf[x-1] == '\r')) {
 577                         /* Copy output data up to and including \r\n */
 578                         memcpy(output, s->inbuf, x + 1);
 579                         /* Add trailing \0 */
 580                         output[x+1] = '\0';
 581                         /* Move remaining data back to the front */
 582                         memmove(s->inbuf, s->inbuf + x + 1, s->inlen - x);
 583                         s->inlen -= (x + 1);
 584                         return 1;
 585                 }
 586         }
 587         if (s->inlen >= sizeof(s->inbuf) - 1) {
 588                 ast_log(LOG_WARNING, "Dumping long line with no return from %s: %s\n", inet_ntoa(s->sin.sin_addr), s->inbuf);
 589                 s->inlen = 0;
 590         }
 591         FD_ZERO(&fds);
 592         FD_SET(s->fd, &fds);
 593         res = ast_select(s->fd + 1, &fds, NULL, NULL, NULL);
 594         if (res < 0) {
 595                 ast_log(LOG_WARNING, "Select returned error: %s\n", strerror(errno));
 596         } else if (res > 0) {
 597                 ast_pthread_mutex_lock(&s->lock);
 598                 res = read(s->fd, s->inbuf + s->inlen, sizeof(s->inbuf) - 1 - s->inlen);
 599                 ast_pthread_mutex_unlock(&s->lock);
 600                 if (res < 1)
 601                         return -1;
 602         }
 603         s->inlen += res;
 604         s->inbuf[s->inlen] = '\0';
 605         return 0;
 606 }
 607
 608 static void *session_do(void *data)
 609 {
 610         struct mansession *s = data;
 611         struct message m;
 612         int res;
 613
 614         ast_pthread_mutex_lock(&s->lock);
 615         ast_cli(s->fd, "Asterisk Call Manager/1.0\r\n");
 616         ast_pthread_mutex_unlock(&s->lock);
 617         memset(&m, 0, sizeof(&m));
 618         for (;;) {
 619                 res = get_input(s, m.headers[m.hdrcount]);
 620                 if (res > 0) {
 621                         /* Strip trailing \r\n */
 622                         if (strlen(m.headers[m.hdrcount]) < 2)
 623                                 continue;
 624                         m.headers[m.hdrcount][strlen(m.headers[m.hdrcount]) - 2] = '\0';
 625                         if (!strlen(m.headers[m.hdrcount])) {
 626                                 if (process_message(s, &m))
 627                                         break;
 628                                 memset(&m, 0, sizeof(&m));
 629                         } else if (m.hdrcount < MAX_HEADERS - 1)
 630                                 m.hdrcount++;
 631                 } else if (res < 0)
 632                         break;
 633         }
 634         if (s->authenticated) {
 635                 if (option_verbose > 1)
 636                         ast_verbose(VERBOSE_PREFIX_2 "Manager '%s' logged off from %s\n", s->username, inet_ntoa(s->sin.sin_addr));
 637                 ast_log(LOG_EVENT, "Manager '%s' logged off from %s\n", s->username, inet_ntoa(s->sin.sin_addr));
 638         } else {
 639                 if (option_verbose > 1)
 640                         ast_verbose(VERBOSE_PREFIX_2 "Connect attempt from '%s' unable to authenticate\n", inet_ntoa(s->sin.sin_addr));
 641                 ast_log(LOG_EVENT, "Failed attempt from %s\n", inet_ntoa(s->sin.sin_addr));
 642         }
 643         destroy_session(s);
 644         return NULL;
 645 }
 646
 647 static void *accept_thread(void *ignore)
 648 {
 649         int as;
 650         struct sockaddr_in sin;
 651         int sinlen;
 652         struct mansession *s;
 653         struct protoent *p;
 654         int arg = 1;
 655         pthread_attr_t attr;
 656
 657         pthread_attr_init(&attr);
 658         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 659
 660         for (;;) {
 661                 sinlen = sizeof(sin);
 662                 as = accept(asock, &sin, &sinlen);
 663                 if (as < 0) {
 664                         ast_log(LOG_NOTICE, "Accept returned -1: %s\n", strerror(errno));
 665                         continue;
 666                 }
 667                 p = getprotobyname("tcp");
 668                 if( p ) {
 669                         if( setsockopt(as, p->p_proto, TCP_NODELAY, (char *)&arg, sizeof(arg) ) < 0 ) {
 670                                 ast_log(LOG_WARNING, "Failed to set manager tcp connection to TCP_NODELAY mode: %s\n", strerror(errno));
 671                         }
 672                 }
 673                 s = malloc(sizeof(struct mansession));
 674                 if (!s) {
 675                         ast_log(LOG_WARNING, "Failed to allocate management session: %s\n", strerror(errno));
 676                         continue;
 677                 }
 678                 memset(s, 0, sizeof(struct mansession));
 679                 memcpy(&s->sin, &sin, sizeof(sin));
 680                 ast_pthread_mutex_init(&s->lock);
 681                 s->fd = as;
 682                 ast_pthread_mutex_lock(&sessionlock);
 683                 s->next = sessions;
 684                 sessions = s;
 685                 ast_pthread_mutex_unlock(&sessionlock);
 686                 if (pthread_create(&t, &attr, session_do, s))
 687                         destroy_session(s);
 688         }
 689         pthread_attr_destroy(&attr);
 690         return NULL;
 691 }
 692
 693 int manager_event(int category, char *event, char *fmt, ...)
 694 {
 695         struct mansession *s;
 696         char tmp[4096];
 697         va_list ap;
 698
 699         ast_pthread_mutex_lock(&sessionlock);
 700         s = sessions;
 701         while(s) {
 702                 if ((s->readperm & category) == category) {
 703                         ast_pthread_mutex_lock(&s->lock);
 704                         if (!s->blocking) {
 705                                 ast_cli(s->fd, "Event: %s\r\n", event);
 706                                 va_start(ap, fmt);
 707                                 vsnprintf(tmp, sizeof(tmp), fmt, ap);
 708                                 va_end(ap);
 709                                 write(s->fd, tmp, strlen(tmp));
 710                                 ast_cli(s->fd, "\r\n");
 711                         }
 712                         ast_pthread_mutex_unlock(&s->lock);
 713                 }
 714                 s = s->next;
 715         }
 716         ast_pthread_mutex_unlock(&sessionlock);
 717         return 0;
 718 }
 719
 720 int ast_manager_unregister( char *action ) {
 721         struct manager_action *cur = first_action, *prev = first_action;
 722
 723         ast_pthread_mutex_lock(&actionlock);
 724         while( cur ) {
 725                 if (!strcasecmp(action, cur->action)) {
 726                         prev->next = cur->next;
 727                         free(cur);
 728                         if (option_verbose > 1)
 729                                 ast_verbose(VERBOSE_PREFIX_2 "Manager unregistered action %s\n", action);
 730                         ast_pthread_mutex_unlock(&actionlock);
 731                         return 0;
 732                 }
 733                 prev = cur;
 734                 cur = cur->next;
 735         }
 736         ast_pthread_mutex_unlock(&actionlock);
 737         return 0;
 738 }
 739
 740 static int manager_state_cb(char *context, char *exten, int state, void *data)
 741 {
 742         /* Notify managers of change */
 743         manager_event(EVENT_FLAG_CALL, "ExtensionStatus", "Exten: %s\r\nContext: %s\r\nStatus: %d\r\n", exten, context, state);
 744         return 0;
 745 }
 746
 747 int ast_manager_register( char *action, int auth,
 748         int (*func)(struct mansession *s, struct message *m), char *synopsis)
 749 {
 750         struct manager_action *cur = first_action, *prev = NULL;
 751
 752         ast_pthread_mutex_lock(&actionlock);
 753         while(cur) { /* Walk the list of actions */
 754                 prev = cur;
 755                 cur = cur->next;
 756         }
 757         cur = malloc( sizeof(struct manager_action) );
 758         if( !cur ) {
 759                 ast_log(LOG_WARNING, "Manager: out of memory trying to register action\n");
 760                 ast_pthread_mutex_unlock(&actionlock);
 761                 return -1;
 762         }
 763         strncpy( cur->action, action, 255 );
 764         cur->authority = auth;
 765         cur->func = func;
 766         cur->synopsis = synopsis;
 767         cur->next = NULL;
 768
 769         if( prev ) prev->next = cur;
 770         else first_action = cur;
 771
 772         if (option_verbose > 1)
 773                 ast_verbose(VERBOSE_PREFIX_2 "Manager registered action %s\n", action);
 774         ast_pthread_mutex_unlock(&actionlock);
 775         return 0;
 776 }
 777
 778 static int registered = 0;
 779
 780 int init_manager(void)
 781 {
 782         struct ast_config *cfg;
 783         char *val;
 784         int oldportno = portno;
 785         static struct sockaddr_in ba;
 786         int x = 1;
 787         if (!registered) {
 788                 /* Register default actions */
 789                 ast_manager_register( "Ping", 0, action_ping, "Ping" );
 790                 ast_manager_register( "Logoff", 0, action_logoff, "Logoff Manager" );
 791                 ast_manager_register( "Hangup", EVENT_FLAG_CALL, action_hangup, "Hangup Channel" );
 792                 ast_manager_register( "Status", EVENT_FLAG_CALL, action_status, "Status" );
 793                 ast_manager_register( "Redirect", EVENT_FLAG_CALL, action_redirect, "Redirect" );
 794                 ast_manager_register( "Originate", EVENT_FLAG_CALL, action_originate, "Originate Call" );
 795                 ast_manager_register( "MailboxStatus", EVENT_FLAG_CALL, action_mailboxstatus, "Check Mailbox" );
 796                 ast_manager_register( "Command", EVENT_FLAG_COMMAND, action_command, "Execute Command" );
 797                 ast_manager_register( "ExtensionState", EVENT_FLAG_CALL, action_extensionstate, "Check Extension Status" );
 798                 ast_manager_register( "AbsoluteTimeout", EVENT_FLAG_CALL, action_timeout, "Set Absolute Timeout" );
 799
 800                 ast_cli_register(&show_mancmds_cli);
 801                 ast_cli_register(&show_manconn_cli);
 802                 ast_extension_state_add(NULL, NULL, manager_state_cb, NULL);
 803                 registered = 1;
 804         }
 805         portno = DEFAULT_MANAGER_PORT;
 806         cfg = ast_load("manager.conf");
 807         if (!cfg) {
 808                 ast_log(LOG_NOTICE, "Unable to open management configuration manager.conf.  Call management disabled.\n");
 809                 return 0;
 810         }
 811         memset(&ba, 0, sizeof(ba));
 812         val = ast_variable_retrieve(cfg, "general", "enabled");
 813         if (val)
 814                 enabled = ast_true(val);
 815
 816         if ((val = ast_variable_retrieve(cfg, "general", "portno"))) {
 817                 if (sscanf(val, "%d", &portno) != 1) {
 818                         ast_log(LOG_WARNING, "Invalid port number '%s'\n", val);
 819                         portno = DEFAULT_MANAGER_PORT;
 820                 }
 821         }
 822
 823         ba.sin_family = AF_INET;
 824         ba.sin_port = htons(portno);
 825         memset(&ba.sin_addr, 0, sizeof(ba.sin_addr));
 826
 827         if ((val = ast_variable_retrieve(cfg, "general", "bindaddr"))) {
 828                 if (!inet_aton(val, &ba.sin_addr)) {
 829                         ast_log(LOG_WARNING, "Invalid address '%s' specified, using 0.0.0.0\n", val);
 830                         memset(&ba.sin_addr, 0, sizeof(ba.sin_addr));
 831                 }
 832         }
 833
 834         if ((asock > -1) && ((portno != oldportno) || !enabled)) {
 835 #if 0
 836                 /* Can't be done yet */
 837                 close(asock);
 838                 asock = -1;
 839 #else
 840                 ast_log(LOG_WARNING, "Unable to change management port / enabled\n");
 841 #endif
 842         }
 843         /* If not enabled, do nothing */
 844         if (!enabled)
 845                 return 0;
 846         if (asock < 0) {
 847                 asock = socket(AF_INET, SOCK_STREAM, 0);
 848                 if (asock < 0) {
 849                         ast_log(LOG_WARNING, "Unable to create socket: %s\n", strerror(errno));
 850                         return -1;
 851                 }
 852                 setsockopt(asock, SOL_SOCKET, SO_REUSEADDR, &x, sizeof(x));
 853                 if (bind(asock, &ba, sizeof(ba))) {
 854                         ast_log(LOG_WARNING, "Unable to bind socket: %s\n", strerror(errno));
 855                         close(asock);
 856                         asock = -1;
 857                         return -1;
 858                 }
 859                 if (listen(asock, 2)) {
 860                         ast_log(LOG_WARNING, "Unable to listen on socket: %s\n", strerror(errno));
 861                         close(asock);
 862                         asock = -1;
 863                         return -1;
 864                 }
 865                 if (option_verbose)
 866                         ast_verbose("Asterisk Management interface listening on port %d\n", portno);
 867                 pthread_create(&t, NULL, accept_thread, NULL);
 868         }
 869         ast_destroy(cfg);
 870         return 0;
 871 }
 872
 873 int reload_manager(void)
 874 {
 875         manager_event(EVENT_FLAG_SYSTEM, "Reload", "Message: Reload Requested\r\n");
 876         return init_manager();
 877 }