Thu Oct 9 06:44:48 2008

Asterisk developer's documentation

---

asterisk.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2005, 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.
 */


/* Doxygenified Copyright Header */

/*!
 * \mainpage Asterisk -- An Open Source Telephony Toolkit
 *
 * \par Developer Documentation for Asterisk
 * This is the main developer documentation for Asterisk. It is 
 * generated by running "make progdocs".
 * \par Additional documentation
 * \arg \ref DevDoc 
 * \arg \ref ConfigFiles
 *
 * \section copyright Copyright and author
 *
 * Copyright (C) 1999 - 2005, Digium, Inc.
 * Asterisk is a trade mark registered by Digium, Inc.
 *
 * \author Mark Spencer <markster@digium.com>
 * Also see \ref AstCREDITS
 *
 * \section license License
 * 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.
 *
 * \verbinclude LICENSE
 *
 */

/*! \file
  \brief Top level source file for Asterisk  - the Open Source PBX. Implementation
  of PBX core functions and CLI interface.
  
 */

#include <unistd.h>
#include <stdlib.h>
#include <sys/time.h>
#include <fcntl.h>
#include <stdio.h>
#include <signal.h>
#include <sched.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/wait.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <sys/resource.h>
#include <grp.h>
#include <pwd.h>
#include <sys/stat.h>
#include <regex.h>

#ifdef linux
#include <sys/prctl.h>
#endif 

#if  defined(__FreeBSD__) || defined( __NetBSD__ ) || defined(SOLARIS)
#include <netdb.h>
#if defined(SOLARIS)
extern int daemon(int, int);  /* defined in libresolv of all places */
#endif
#endif

#include "asterisk.h"

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

#include "asterisk/logger.h"
#include "asterisk/options.h"
#include "asterisk/cli.h"
#include "asterisk/channel.h"
#include "asterisk/ulaw.h"
#include "asterisk/alaw.h"
#include "asterisk/callerid.h"
#include "asterisk/module.h"
#include "asterisk/image.h"
#include "asterisk/tdd.h"
#include "asterisk/term.h"
#include "asterisk/manager.h"
#include "asterisk/cdr.h"
#include "asterisk/pbx.h"
#include "asterisk/enum.h"
#include "asterisk/rtp.h"
#include "asterisk/app.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "asterisk/file.h"
#include "asterisk/io.h"
#include "asterisk/lock.h"
#include "editline/histedit.h"
#include "asterisk/config.h"
#include "asterisk/version.h"
#include "asterisk/linkedlists.h"
#include "asterisk/devicestate.h"
#include "asterisk/compat.h"

#include "asterisk/doxyref.h"    /* Doxygen documentation */

#include "defaults.h"

#ifndef AF_LOCAL
#define AF_LOCAL AF_UNIX
#define PF_LOCAL PF_UNIX
#endif

#define AST_MAX_CONNECTS 128
#define NUM_MSGS 64

/*! \brief Welcome message when starting a CLI interface */
#define WELCOME_MESSAGE \
   ast_verbose("Asterisk " ASTERISK_VERSION ", Copyright (C) 1999 - 2007 Digium, Inc. and others.\n"); \
   ast_verbose("Created by Mark Spencer <markster@digium.com>\n"); \
   ast_verbose("Asterisk comes with ABSOLUTELY NO WARRANTY; type 'show warranty' for details.\n"); \
   ast_verbose("This is free software, with components licensed under the GNU General Public\n"); \
   ast_verbose("License version 2 and other licenses; you are welcome to redistribute it under\n"); \
   ast_verbose("certain conditions. Type 'show license' for details.\n"); \
   ast_verbose("=========================================================================\n")

/*! \defgroup main_options 
 \brief Main configuration options from \ref Config_ast "asterisk.conf" or 
  the operating system command line when starting Asterisk 
  Some of them can be changed in the CLI 
 */
/*! @{ */
int option_verbose=0;         /*!< Verbosity level */
int option_debug=0;        /*!< Debug level */
int option_exec_includes=0;      /*!< Allow \#exec in config files? */
int option_nofork=0;       /*!< Do not fork */
int option_quiet=0;        /*!< Keep quiet */
int option_console=0;         /*!< Console mode, no background */
int option_highpriority=0;    /*!< Run in realtime Linux priority */
int option_remote=0;       /*!< Remote CLI */
int option_exec=0;         /*!< */
int option_initcrypto=0;      /*!< Initialize crypto keys for RSA auth */
int option_nocolor;        /*!< Don't use termcap colors */
int option_dumpcore = 0;         /*!< Dump core when failing */
int option_cache_record_files = 0;     /*!< Cache sound files */
int option_timestamp = 0;        /*!< Timestamp in logging */
int option_overrideconfig = 0;         /*!< */
int option_reconnect = 0;        /*!< */
int option_transcode_slin = 1;         /*!< */
int option_maxcalls = 0;         /*!< */
double option_maxload = 0.0;        /*!< Max load avg on system */
int option_dontwarn = 0;         /*!< */
int option_priority_jumping = 1;    /*!< Enable priority jumping as result value for apps */
int option_transmit_silence_during_record = 0;  /*!< Transmit silence during record() app */

/*! @} */

int fully_booted = 0;
char record_cache_dir[AST_CACHE_DIR_LEN] = AST_TMP_DIR;
char debug_filename[AST_FILENAME_MAX] = "";

static int ast_socket = -1;      /*!< UNIX Socket for allowing remote control */
static int ast_consock = -1;     /*!< UNIX Socket for controlling another asterisk */
int ast_mainpid;
struct console {
   int fd;           /*!< File descriptor */
   int p[2];         /*!< Pipe */
   pthread_t t;         /*!< Thread of handler */
};

static struct ast_atexit {
   void (*func)(void);
   struct ast_atexit *next;
} *atexits = NULL;

AST_MUTEX_DEFINE_STATIC(atexitslock);

time_t ast_startuptime;
time_t ast_lastreloadtime;

static History *el_hist = NULL;
static EditLine *el = NULL;
static char *remotehostname;

struct console consoles[AST_MAX_CONNECTS];

char defaultlanguage[MAX_LANGUAGE] = DEFAULT_LANGUAGE;

static int ast_el_add_history(char *);
static int ast_el_read_history(char *);
static int ast_el_write_history(char *);

char ast_config_AST_CONFIG_DIR[AST_CONFIG_MAX_PATH];
char ast_config_AST_CONFIG_FILE[AST_CONFIG_MAX_PATH];
char ast_config_AST_MODULE_DIR[AST_CONFIG_MAX_PATH];
char ast_config_AST_SPOOL_DIR[AST_CONFIG_MAX_PATH];
char ast_config_AST_MONITOR_DIR[AST_CONFIG_MAX_PATH];
char ast_config_AST_VAR_DIR[AST_CONFIG_MAX_PATH];
char ast_config_AST_LOG_DIR[AST_CONFIG_MAX_PATH];
char ast_config_AST_AGI_DIR[AST_CONFIG_MAX_PATH];
char ast_config_AST_DB[AST_CONFIG_MAX_PATH];
char ast_config_AST_KEY_DIR[AST_CONFIG_MAX_PATH];
char ast_config_AST_PID[AST_CONFIG_MAX_PATH];
char ast_config_AST_SOCKET[AST_CONFIG_MAX_PATH];
char ast_config_AST_RUN_DIR[AST_CONFIG_MAX_PATH];
char ast_config_AST_RUN_USER[AST_CONFIG_MAX_PATH];
char ast_config_AST_RUN_GROUP[AST_CONFIG_MAX_PATH];
char ast_config_AST_CTL_PERMISSIONS[AST_CONFIG_MAX_PATH];
char ast_config_AST_CTL_OWNER[AST_CONFIG_MAX_PATH] = "\0";
char ast_config_AST_CTL_GROUP[AST_CONFIG_MAX_PATH] = "\0";
char ast_config_AST_CTL[AST_CONFIG_MAX_PATH] = "asterisk.ctl";

static char *_argv[256];
static int shuttingdown = 0;
static int restartnow = 0;
static pthread_t consolethread = AST_PTHREADT_NULL;

static int sig_alert_pipe[2] = { -1, -1 };
static struct {
    unsigned int need_reload:1;
    unsigned int need_quit:1;
} sig_flags;

#if !defined(LOW_MEMORY)
struct file_version {
   AST_LIST_ENTRY(file_version) list;
   const char *file;
   char *version;
};

static AST_LIST_HEAD_STATIC(file_versions, file_version);

void ast_register_file_version(const char *file, const char *version)
{
   struct file_version *new;
   char *work;
   size_t version_length;

   work = ast_strdupa(version);
   work = ast_strip(ast_strip_quoted(work, "$", "$"));
   version_length = strlen(work) + 1;

   new = calloc(1, sizeof(*new) + version_length);
   if (!new)
      return;

   new->file = file;
   new->version = (char *) new + sizeof(*new);
   memcpy(new->version, work, version_length);
   AST_LIST_LOCK(&file_versions);
   AST_LIST_INSERT_HEAD(&file_versions, new, list);
   AST_LIST_UNLOCK(&file_versions);
}

void ast_unregister_file_version(const char *file)
{
   struct file_version *find;

   AST_LIST_LOCK(&file_versions);
   AST_LIST_TRAVERSE_SAFE_BEGIN(&file_versions, find, list) {
      if (!strcasecmp(find->file, file)) {
         AST_LIST_REMOVE_CURRENT(&file_versions, list);
         break;
      }
   }
   AST_LIST_TRAVERSE_SAFE_END;
   AST_LIST_UNLOCK(&file_versions);
   if (find)
      free(find);
}

static char show_version_files_help[] = 
"Usage: show version files [like <pattern>]\n"
"       Shows the revision numbers of the files used to build this copy of Asterisk.\n"
"       Optional regular expression pattern is used to filter the file list.\n";

/*! CLI command to list module versions */
static int handle_show_version_files(int fd, int argc, char *argv[])
{
#define FORMAT "%-25.25s %-40.40s\n"
   struct file_version *iterator;
   regex_t regexbuf;
   int havepattern = 0;
   int havename = 0;
   int count_files = 0;

   switch (argc) {
   case 5:
      if (!strcasecmp(argv[3], "like")) {
         if (regcomp(&regexbuf, argv[4], REG_EXTENDED | REG_NOSUB))
            return RESULT_SHOWUSAGE;
         havepattern = 1;
      } else
         return RESULT_SHOWUSAGE;
      break;
   case 4:
      havename = 1;
      break;
   case 3:
      break;
   default:
      return RESULT_SHOWUSAGE;
   }

   ast_cli(fd, FORMAT, "File", "Revision");
   ast_cli(fd, FORMAT, "----", "--------");
   AST_LIST_LOCK(&file_versions);
   AST_LIST_TRAVERSE(&file_versions, iterator, list) {
      if (havename && strcasecmp(iterator->file, argv[3]))
         continue;

      if (havepattern && regexec(&regexbuf, iterator->file, 0, NULL, 0))
         continue;

      ast_cli(fd, FORMAT, iterator->file, iterator->version);
      count_files++;
      if (havename)
         break;
   }
   AST_LIST_UNLOCK(&file_versions);
   if (!havename) {
      ast_cli(fd, "%d files listed.\n", count_files);
   }

   if (havepattern)
      regfree(&regexbuf);

   return RESULT_SUCCESS;
#undef FORMAT
}

static char *complete_show_version_files(char *line, char *word, int pos, int state)
{
   struct file_version *find;
   int which = 0;
   char *ret = NULL;
   int matchlen = strlen(word);

   if (pos != 3)
      return NULL;

   AST_LIST_LOCK(&file_versions);
   AST_LIST_TRAVERSE(&file_versions, find, list) {
      if (!strncasecmp(word, find->file, matchlen)) {
         if (++which > state) {
            ret = strdup(find->file);
            break;
         }
      }
   }
   AST_LIST_UNLOCK(&file_versions);

   return ret;
}
#endif /* ! LOW_MEMORY */

int ast_register_atexit(void (*func)(void))
{
   int res = -1;
   struct ast_atexit *ae;
   ast_unregister_atexit(func);
   ae = malloc(sizeof(struct ast_atexit));
   ast_mutex_lock(&atexitslock);
   if (ae) {
      memset(ae, 0, sizeof(struct ast_atexit));
      ae->next = atexits;
      ae->func = func;
      atexits = ae;
      res = 0;
   }
   ast_mutex_unlock(&atexitslock);
   return res;
}

void ast_unregister_atexit(void (*func)(void))
{
   struct ast_atexit *ae, *prev = NULL;
   ast_mutex_lock(&atexitslock);
   ae = atexits;
   while(ae) {
      if (ae->func == func) {
         if (prev)
            prev->next = ae->next;
         else
            atexits = ae->next;
         break;
      }
      prev = ae;
      ae = ae->next;
   }
   ast_mutex_unlock(&atexitslock);
}

static int fdprint(int fd, const char *s)
{
   return write(fd, s, strlen(s) + 1);
}

/*! NULL handler so we can collect the child exit status */
static void null_sig_handler(int signal)
{

}

AST_MUTEX_DEFINE_STATIC(safe_system_lock);
static unsigned int safe_system_level = 0;
static void *safe_system_prev_handler;

int ast_safe_system(const char *s)
{
   pid_t pid;
   int x;
   int res;
   struct rusage rusage;
   int status;
   unsigned int level;

   /* keep track of how many ast_safe_system() functions
      are running at this moment
   */
   ast_mutex_lock(&safe_system_lock);
   level = safe_system_level++;

   /* only replace the handler if it has not already been done */
   if (level == 0)
      safe_system_prev_handler = signal(SIGCHLD, null_sig_handler);

   ast_mutex_unlock(&safe_system_lock);

   pid = fork();

   if (pid == 0) {
      if (option_highpriority)
         ast_set_priority(0);
      /* Close file descriptors and launch system command */
      for (x = STDERR_FILENO + 1; x < 4096; x++)
         close(x);
      execl("/bin/sh", "/bin/sh", "-c", s, NULL);
      _exit(1);
   } else if (pid > 0) {
      for(;;) {
         res = wait4(pid, &status, 0, &rusage);
         if (res > -1) {
            res = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
            break;
         } else if (errno != EINTR) 
            break;
      }
   } else {
      ast_log(LOG_WARNING, "Fork failed: %s\n", strerror(errno));
      res = -1;
   }

   ast_mutex_lock(&safe_system_lock);
   level = --safe_system_level;

   /* only restore the handler if we are the last one */
   if (level == 0)
      signal(SIGCHLD, safe_system_prev_handler);

   ast_mutex_unlock(&safe_system_lock);

   return res;
}

/*!
 * write the string to all attached console clients
 */
static void ast_network_puts(const char *string)
{
   int x;
   for (x=0;x<AST_MAX_CONNECTS; x++) {
      if (consoles[x].fd > -1) 
         fdprint(consoles[x].p[1], string);
   }
}

/*!
 * write the string to the console, and all attached
 * console clients
 */
void ast_console_puts(const char *string)
{
   fputs(string, stdout);
   fflush(stdout);
   ast_network_puts(string);
}

static void network_verboser(const char *s, int pos, int replace, int complete)
   /* ARGUSED */
{
   if (replace) {
      char *t = alloca(strlen(s) + 2);
      if (t) {
         sprintf(t, "\r%s", s);
         if (complete)
            ast_network_puts(t);
      } else {
         ast_log(LOG_ERROR, "Out of memory\n");
         ast_network_puts(s);
      }
   } else {
      if (complete)
         ast_network_puts(s);
   }
}

static pthread_t lthread;

static void *netconsole(void *vconsole)
{
   struct console *con = vconsole;
   char hostname[MAXHOSTNAMELEN]="";
   char tmp[512];
   int res;
   struct pollfd fds[2];
   
   if (gethostname(hostname, sizeof(hostname)-1))
      ast_copy_string(hostname, "<Unknown>", sizeof(hostname));
   snprintf(tmp, sizeof(tmp), "%s/%d/%s\n", hostname, ast_mainpid, ASTERISK_VERSION);
   fdprint(con->fd, tmp);
   for(;;) {
      fds[0].fd = con->fd;
      fds[0].events = POLLIN;
      fds[0].revents = 0;
      fds[1].fd = con->p[0];
      fds[1].events = POLLIN;
      fds[1].revents = 0;

      res = poll(fds, 2, -1);
      if (res < 0) {
         if (errno != EINTR)
            ast_log(LOG_WARNING, "poll returned < 0: %s\n", strerror(errno));
         continue;
      }
      if (fds[0].revents) {
         res = read(con->fd, tmp, sizeof(tmp));
         if (res < 1) {
            break;
         }
         tmp[res] = 0;
         ast_cli_command(con->fd, tmp);
      }
      if (fds[1].revents) {
         res = read(con->p[0], tmp, sizeof(tmp));
         if (res < 1) {
            ast_log(LOG_ERROR, "read returned %d\n", res);
            break;
         }
         res = write(con->fd, tmp, res);
         if (res < 1)
            break;
      }
   }
   if (option_verbose > 2) 
      ast_verbose(VERBOSE_PREFIX_3 "Remote UNIX connection disconnected\n");
   close(con->fd);
   close(con->p[0]);
   close(con->p[1]);
   con->fd = -1;
   
   return NULL;
}

static void *listener(void *unused)
{
   struct sockaddr_un sunaddr;
   int s;
   socklen_t len;
   int x;
   int flags;
   struct pollfd fds[1];
   pthread_attr_t attr;
   pthread_attr_init(&attr);
   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
   for(;;) {
      if (ast_socket < 0)
         return NULL;
      fds[0].fd = ast_socket;
      fds[0].events= POLLIN;
      s = poll(fds, 1, -1);
      pthread_testcancel();
      if (s < 0) {
         if (errno != EINTR)
            ast_log(LOG_WARNING, "poll returned error: %s\n", strerror(errno));
         continue;
      }
      len = sizeof(sunaddr);
      s = accept(ast_socket, (struct sockaddr *)&sunaddr, &len);
      if (s < 0) {
         if (errno != EINTR)
            ast_log(LOG_WARNING, "Accept returned %d: %s\n", s, strerror(errno));
      } else {
         for (x=0;x<AST_MAX_CONNECTS;x++) {
            if (consoles[x].fd < 0) {
               if (socketpair(AF_LOCAL, SOCK_STREAM, 0, consoles[x].p)) {
                  ast_log(LOG_ERROR, "Unable to create pipe: %s\n", strerror(errno));
                  consoles[x].fd = -1;
                  fdprint(s, "Server failed to create pipe\n");
                  close(s);
                  break;
               }
               flags = fcntl(consoles[x].p[1], F_GETFL);
               fcntl(consoles[x].p[1], F_SETFL, flags | O_NONBLOCK);
               consoles[x].fd = s;
               if (ast_pthread_create(&consoles[x].t, &attr, netconsole, &consoles[x])) {
                  ast_log(LOG_ERROR, "Unable to spawn thread to handle connection: %s\n", strerror(errno));
                  close(consoles[x].p[0]);
                  close(consoles[x].p[1]);
                  consoles[x].fd = -1;
                  fdprint(s, "Server failed to spawn thread\n");
                  close(s);
               }
               break;
            }
         }
         if (x >= AST_MAX_CONNECTS) {
            fdprint(s, "No more connections allowed\n");
            ast_log(LOG_WARNING, "No more connections allowed\n");
            close(s);
         } else if (consoles[x].fd > -1) {
            if (option_verbose > 2) 
               ast_verbose(VERBOSE_PREFIX_3 "Remote UNIX connection\n");
         }
      }
   }
   return NULL;
}

static int ast_makesocket(void)
{
   struct sockaddr_un sunaddr;
   int res;
   int x;
   uid_t uid = -1;
   gid_t gid = -1;

   for (x = 0; x < AST_MAX_CONNECTS; x++) 
      consoles[x].fd = -1;
   unlink(ast_config_AST_SOCKET);
   ast_socket = socket(PF_LOCAL, SOCK_STREAM, 0);
   if (ast_socket < 0) {
      ast_log(LOG_WARNING, "Unable to create control socket: %s\n", strerror(errno));
      return -1;
   }     
   memset(&sunaddr, 0, sizeof(sunaddr));
   sunaddr.sun_family = AF_LOCAL;
   ast_copy_string(sunaddr.sun_path, ast_config_AST_SOCKET, sizeof(sunaddr.sun_path));
   res = bind(ast_socket, (struct sockaddr *)&sunaddr, sizeof(sunaddr));
   if (res) {
      ast_log(LOG_WARNING, "Unable to bind socket to %s: %s\n", ast_config_AST_SOCKET, strerror(errno));
      close(ast_socket);
      ast_socket = -1;
      return -1;
   }
   res = listen(ast_socket, 2);
   if (res < 0) {
      ast_log(LOG_WARNING, "Unable to listen on socket %s: %s\n", ast_config_AST_SOCKET, strerror(errno));
      close(ast_socket);
      ast_socket = -1;
      return -1;
   }
   ast_register_verbose(network_verboser);
   ast_pthread_create(&lthread, NULL, listener, NULL);

   if (!ast_strlen_zero(ast_config_AST_CTL_OWNER)) {
      struct passwd *pw;
      if ((pw = getpwnam(ast_config_AST_CTL_OWNER)) == NULL) {
         ast_log(LOG_WARNING, "Unable to find uid of user %s\n", ast_config_AST_CTL_OWNER);
      } else {
         uid = pw->pw_uid;
      }
   }
      
   if (!ast_strlen_zero(ast_config_AST_CTL_GROUP)) {
      struct group *grp;
      if ((grp = getgrnam(ast_config_AST_CTL_GROUP)) == NULL) {
         ast_log(LOG_WARNING, "Unable to find gid of group %s\n", ast_config_AST_CTL_GROUP);
      } else {
         gid = grp->gr_gid;
      }
   }

   if (chown(ast_config_AST_SOCKET, uid, gid) < 0)
      ast_log(LOG_WARNING, "Unable to change ownership of %s: %s\n", ast_config_AST_SOCKET, strerror(errno));

   if (!ast_strlen_zero(ast_config_AST_CTL_PERMISSIONS)) {
      int p1;
      mode_t p;
      sscanf(ast_config_AST_CTL_PERMISSIONS, "%o", &p1);
      p = p1;
      if ((chmod(ast_config_AST_SOCKET, p)) < 0)
         ast_log(LOG_WARNING, "Unable to change file permissions of %s: %s\n", ast_config_AST_SOCKET, strerror(errno));
   }

   return 0;
}

static int ast_tryconnect(void)
{
   struct sockaddr_un sunaddr;
   int res;
   ast_consock = socket(PF_LOCAL, SOCK_STREAM, 0);
   if (ast_consock < 0) {
      ast_log(LOG_WARNING, "Unable to create socket: %s\n", strerror(errno));
      return 0;
   }
   memset(&sunaddr, 0, sizeof(sunaddr));
   sunaddr.sun_family = AF_LOCAL;
   ast_copy_string(sunaddr.sun_path, (char *)ast_config_AST_SOCKET, sizeof(sunaddr.sun_path));
   res = connect(ast_consock, (struct sockaddr *)&sunaddr, sizeof(sunaddr));
   if (res) {
      close(ast_consock);
      ast_consock = -1;
      return 0;
   } else
      return 1;
}

/*! Urgent handler
 Called by soft_hangup to interrupt the poll, read, or other
 system call.  We don't actually need to do anything though.  
 Remember: Cannot EVER ast_log from within a signal handler 
 */
static void urg_handler(int num)
{
   signal(num, urg_handler);
   return;
}

static void hup_handler(int num)
{
   int a = 0;
   if (option_verbose > 1) 
      printf("Received HUP signal -- Reloading configs\n");
   if (restartnow)
      execvp(_argv[0], _argv);
   sig_flags.need_reload = 1;
   if (sig_alert_pipe[1] != -1)
      write(sig_alert_pipe[1], &a, sizeof(a));
   signal(num, hup_handler);
}

static void child_handler(int sig)
{
   /* Must not ever ast_log or ast_verbose within signal handler */
   int n, status;

   /*
    * Reap all dead children -- not just one
    */
   for (n = 0; wait4(-1, &status, WNOHANG, NULL) > 0; n++)
      ;
   if (n == 0 && option_debug)   
      printf("Huh?  Child handler, but nobody there?\n");
   signal(sig, child_handler);
}

/*! Set an X-term or screen title */
static void set_title(char *text)
{
   if (getenv("TERM") && strstr(getenv("TERM"), "xterm"))
      fprintf(stdout, "\033]2;%s\007", text);
}

static void set_icon(char *text)
{
   if (getenv("TERM") && strstr(getenv("TERM"), "xterm"))
      fprintf(stdout, "\033]1;%s\007", text);
}

/*! We set ourselves to a high priority, that we might pre-empt everything
   else.  If your PBX has heavy activity on it, this is a good thing.  */
int ast_set_priority(int pri)
{
   struct sched_param sched;
   memset(&sched, 0, sizeof(sched));
#ifdef __linux__
#undef sched_setscheduler
   if (pri) {  
      sched.sched_priority = 10;
      if (sched_setscheduler(0, SCHED_RR, &sched)) {
         ast_log(LOG_WARNING, "Unable to set high priority\n");
         return -1;
      } else
         if (option_verbose)
            ast_verbose("Set to realtime thread\n");
   } else {
      sched.sched_priority = 0;
      /* According to the manpage, this can never fail, with these parameters. */
      sched_setscheduler(0, SCHED_OTHER, &sched);
   }
#else
#undef setpriority
   if (pri) {
      if (setpriority(PRIO_PROCESS, 0, -10) == -1) {
         ast_log(LOG_WARNING, "Unable to set high priority\n");
         return -1;
      } else
         if (option_verbose)
            ast_verbose("Set to high priority\n");
   } else {
      /* According to the manpage, this can never fail, with these parameters. */
      setpriority(PRIO_PROCESS, 0, 0);
   }
#endif
   return 0;
}

static void ast_run_atexits(void)
{
   struct ast_atexit *ae;
   ast_mutex_lock(&atexitslock);
   ae = atexits;
   while(ae) {
      if (ae->func) 
         ae->func();
      ae = ae->next;
   }
   ast_mutex_unlock(&atexitslock);
}

static void quit_handler(int num, int nice, int safeshutdown, int restart)
{
   char filename[80] = "";
   time_t s,e;
   int x;
   /* Try to get as many CDRs as possible submitted to the backend engines (if in batch mode) */
   ast_cdr_engine_term();
   if (safeshutdown) {
      shuttingdown = 1;
      if (!nice) {
         /* Begin shutdown routine, hanging up active channels */
         ast_begin_shutdown(1);
         if (option_verbose && option_console)
            ast_verbose("Beginning asterisk %s....\n", restart ? "restart" : "shutdown");
         time(&s);
         for(;;) {
            time(&e);
            /* Wait up to 15 seconds for all channels to go away */
            if ((e - s) > 15)
               break;
            if (!ast_active_channels())
               break;
            if (!shuttingdown)
               break;
            /* Sleep 1/10 of a second */
            usleep(100000);
         }
      } else {
         if (nice < 2)
            ast_begin_shutdown(0);
         if (option_verbose && option_console)
            ast_verbose("Waiting for inactivity to perform %s...\n", restart ? "restart" : "halt");
         for(;;) {
            if (!ast_active_channels())
               break;
            if (!shuttingdown)
               break;
            sleep(1);
         }
      }

      if (!shuttingdown) {
         if (option_verbose && option_console)
            ast_verbose("Asterisk %s cancelled.\n", restart ? "restart" : "shutdown");
         return;
      }
   }
   if (option_console || option_remote) {
      if (getenv("HOME")) 
         snprintf(filename, sizeof(filename), "%s/.asterisk_history", getenv("HOME"));
      if (!ast_strlen_zero(filename))
         ast_el_write_history(filename);
      if (el != NULL)
         el_end(el);
      if (el_hist != NULL)
         history_end(el_hist);
   }
   if (option_verbose)
      ast_verbose("Executing last minute cleanups\n");
   ast_run_atexits();
   /* Called on exit */
   if (option_verbose && option_console)
      ast_verbose("Asterisk %s ending (%d).\n", ast_active_channels() ? "uncleanly" : "cleanly", num);
   if (option_debug)
      ast_log(LOG_DEBUG, "Asterisk ending (%d).\n", num);
   manager_event(EVENT_FLAG_SYSTEM, "Shutdown", "Shutdown: %s\r\nRestart: %s\r\n", ast_active_channels() ? "Uncleanly" : "Cleanly", restart ? "True" : "False");
   if (ast_socket > -1) {
      pthread_cancel(lthread);
      close(ast_socket);
      ast_socket = -1;
      unlink(ast_config_AST_SOCKET);
   }
   if (ast_consock > -1)
      close(ast_consock);
   if (!option_remote) unlink((char *)ast_config_AST_PID);
   printf(term_quit());
   if (restart) {
      if (option_verbose || option_console)
         ast_verbose("Preparing for Asterisk restart...\n");
      /* Mark all FD's for closing on exec */
      for (x=3;x<32768;x++) {
         fcntl(x, F_SETFD, FD_CLOEXEC);
      }
      if (option_verbose || option_console)
         ast_verbose("Restarting Asterisk NOW...\n");
      restartnow = 1;

      /* close logger */
      close_logger();

      /* If there is a consolethread running send it a SIGHUP 
         so it can execvp, otherwise we can do it ourselves */
      if ((consolethread != AST_PTHREADT_NULL) && (consolethread != pthread_self())) {
         pthread_kill(consolethread, SIGHUP);
         /* Give the signal handler some time to complete */
         sleep(2);
      } else
         execvp(_argv[0], _argv);
   
   } else {
      /* close logger */
      close_logger();
   }
   exit(0);
}

static void __quit_handler(int num)
{
   int a = 0;
   sig_flags.need_quit = 1;
   if (sig_alert_pipe[1] != -1)
      write(sig_alert_pipe[1], &a, sizeof(a));
   /* There is no need to restore the signal handler here, since the app
    * is going to exit */
}

static const char *fix_header(char *outbuf, int maxout, const char *s, char *cmp)
{
   const char *c;
   if (!strncmp(s, cmp, strlen(cmp))) {
      c = s + strlen(cmp);
      term_color(outbuf, cmp, COLOR_GRAY, 0, maxout);
      return c;
   }
   return NULL;
}

static void console_verboser(const char *s, int pos, int replace, int complete)
{
   char tmp[80];
   const char *c=NULL;
   /* Return to the beginning of the line */
   if (!pos) {
      fprintf(stdout, "\r");
      if ((c = fix_header(tmp, sizeof(tmp), s, VERBOSE_PREFIX_4)) ||
         (c = fix_header(tmp, sizeof(tmp), s, VERBOSE_PREFIX_3)) ||
         (c = fix_header(tmp, sizeof(tmp), s, VERBOSE_PREFIX_2)) ||
         (c = fix_header(tmp, sizeof(tmp), s, VERBOSE_PREFIX_1)))
         fputs(tmp, stdout);
   }
   if (c)
      fputs(c + pos,stdout);
   else
      fputs(s + pos,stdout);
   fflush(stdout);
   if (complete) {
      /* Wake up a poll()ing console */
      if (option_console && consolethread != AST_PTHREADT_NULL)
         pthread_kill(consolethread, SIGURG);
   }
}

static int ast_all_zeros(char *s)
{
   while(*s) {
      if (*s > 32)
         return 0;
      s++;  
   }
   return 1;
}

static void consolehandler(char *s)
{
   printf(term_end());
   fflush(stdout);

   /* Called when readline data is available */
   if (!ast_all_zeros(s))
      ast_el_add_history(s);
   /* The real handler for bang */
   if (s[0] == '!') {
      if (s[1])
         ast_safe_system(s+1);
      else
         ast_safe_system(getenv("SHELL") ? getenv("SHELL") : "/bin/sh");
   } else 
      ast_cli_command(STDOUT_FILENO, s);
}

static int remoteconsolehandler(char *s)
{
   int ret = 0;

   /* Called when readline data is available */
   if (!ast_all_zeros(s))
      ast_el_add_history(s);
   /* The real handler for bang */
   if (s[0] == '!') {
      if (s[1])
         ast_safe_system(s+1);
      else
         ast_safe_system(getenv("SHELL") ? getenv("SHELL") : "/bin/sh");
      ret = 1;
   }
   if ((strncasecmp(s, "quit", 4) == 0 || strncasecmp(s, "exit", 4) == 0) &&
       (s[4] == '\0' || isspace(s[4]))) {
      quit_handler(0, 0, 0, 0);
      ret = 1;
   }

   return ret;
}

static char abort_halt_help[] = 
"Usage: abort shutdown\n"
"       Causes Asterisk to abort an executing shutdown or restart, and resume normal\n"
"       call operations.\n";

static char shutdown_now_help[] = 
"Usage: stop now\n"
"       Shuts down a running Asterisk immediately, hanging up all active calls .\n";

static char shutdown_gracefully_help[] = 
"Usage: stop gracefully\n"
"       Causes Asterisk to not accept new calls, and exit when all\n"
"       active calls have terminated normally.\n";

static char shutdown_when_convenient_help[] = 
"Usage: stop when convenient\n"
"       Causes Asterisk to perform