Sat Nov 1 06:28:23 2008

Asterisk developer's documentation

---

asterisk.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2008, 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 Licensing
 * \arg \ref DevDoc 
 * \arg \ref ConfigFiles
 *
 * \section copyright Copyright and author
 *
 * Copyright (C) 1999 - 2008, Digium, Inc.
 * Asterisk is a trademark registered by Digium, Inc.
 *
 * \author Mark Spencer <markster@digium.com>
 * Also see \ref AstCREDITS
 *
 * 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.
 */

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

#include "asterisk.h"

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

#undef sched_setscheduler
#undef setpriority
#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>

#if defined(HAVE_ZAPTEL) || defined (HAVE_DAHDI)
#include <sys/ioctl.h>
#include "asterisk/dahdi_compat.h"
#endif

#ifdef linux
#include <sys/prctl.h>
#ifdef HAVE_CAP
#include <sys/capability.h>
#endif /* HAVE_CAP */
#endif /* linux */
#include <regex.h>

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

#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/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/http.h"
#include "asterisk/udptl.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/module.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 - 2008 Digium, Inc. and others.\n"); \
   ast_verbose("Created by Mark Spencer <markster@digium.com>\n"); \
   ast_verbose("Asterisk comes with ABSOLUTELY NO WARRANTY; type 'core 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 'core show license' for details.\n"); \
   ast_verbose("=========================================================================\n")

/*! \defgroup main_options Main Configuration 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 
 */
/*! @{ */

struct ast_flags ast_options = { AST_DEFAULT_OPTIONS };

int option_verbose;           /*!< Verbosity level */
int option_debug;          /*!< Debug level */

double option_maxload;           /*!< Max load avg on system */
int option_maxcalls;          /*!< Max number of active calls */

/*! @} */

char record_cache_dir[AST_CACHE_DIR_LEN] = AST_TMP_DIR;
char debug_filename[AST_FILENAME_MAX] = "";
#ifdef HAVE_ZAPTEL
static char _dahdi_chan_name[AST_CHANNEL_NAME] = "Zap";
static size_t _dahdi_chan_name_len = 3;
static enum dahdi_chan_modes _dahdi_chan_mode = CHAN_ZAP_MODE;
#else
static char _dahdi_chan_name[AST_CHANNEL_NAME] = "DAHDI";
static size_t _dahdi_chan_name_len = 5;
static enum dahdi_chan_modes _dahdi_chan_mode = CHAN_DAHDI_PLUS_ZAP_MODE;
#endif
const char *dahdi_chan_name;
const size_t *dahdi_chan_name_len;
const enum dahdi_chan_modes *dahdi_chan_mode;

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

struct ast_atexit {
   void (*func)(void);
   AST_LIST_ENTRY(ast_atexit) list;
};

static AST_LIST_HEAD_STATIC(atexits, ast_atexit);

time_t ast_startuptime;
time_t ast_lastreloadtime;

static History *el_hist;
static EditLine *el;
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[PATH_MAX];
char ast_config_AST_CONFIG_FILE[PATH_MAX];
char ast_config_AST_MODULE_DIR[PATH_MAX];
char ast_config_AST_SPOOL_DIR[PATH_MAX];
char ast_config_AST_MONITOR_DIR[PATH_MAX];
char ast_config_AST_VAR_DIR[PATH_MAX];
char ast_config_AST_DATA_DIR[PATH_MAX];
char ast_config_AST_LOG_DIR[PATH_MAX];
char ast_config_AST_AGI_DIR[PATH_MAX];
char ast_config_AST_DB[PATH_MAX];
char ast_config_AST_KEY_DIR[PATH_MAX];
char ast_config_AST_PID[PATH_MAX];
char ast_config_AST_SOCKET[PATH_MAX];
char ast_config_AST_RUN_DIR[PATH_MAX];
char ast_config_AST_RUN_USER[PATH_MAX];
char ast_config_AST_RUN_GROUP[PATH_MAX];
char ast_config_AST_CTL_PERMISSIONS[PATH_MAX];
char ast_config_AST_CTL_OWNER[PATH_MAX] = "\0";
char ast_config_AST_CTL_GROUP[PATH_MAX] = "\0";
char ast_config_AST_CTL[PATH_MAX] = "asterisk.ctl";
char ast_config_AST_SYSTEM_NAME[20] = "";

extern const char *ast_build_hostname;
extern const char *ast_build_kernel;
extern const char *ast_build_machine;
extern const char *ast_build_os;
extern const char *ast_build_date;
extern const char *ast_build_user;

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

static char randompool[256];

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;
   
   if (!(new = ast_calloc(1, sizeof(*new) + version_length)))
      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);
}

struct thread_list_t {
   AST_LIST_ENTRY(thread_list_t) list;
   char *name;
   pthread_t id;
};

static AST_LIST_HEAD_STATIC(thread_list, thread_list_t);

static char show_threads_help[] =
"Usage: core show threads\n"
"       List threads currently active in the system.\n";

void ast_register_thread(char *name)
{ 
   struct thread_list_t *new = ast_calloc(1, sizeof(*new));

   if (!new)
      return;
   new->id = pthread_self();
   new->name = name; /* steal the allocated memory for the thread name */
   AST_LIST_LOCK(&thread_list);
   AST_LIST_INSERT_HEAD(&thread_list, new, list);
   AST_LIST_UNLOCK(&thread_list);
}

void ast_unregister_thread(void *id)
{
   struct thread_list_t *x;

   AST_LIST_LOCK(&thread_list);
   AST_LIST_TRAVERSE_SAFE_BEGIN(&thread_list, x, list) {
      if ((void *) x->id == id) {
         AST_LIST_REMOVE_CURRENT(&thread_list, list);
         break;
      }
   }
   AST_LIST_TRAVERSE_SAFE_END;
   AST_LIST_UNLOCK(&thread_list);
   if (x) {
      free(x->name);
      free(x);
   }
}

static int handle_show_threads(int fd, int argc, char *argv[])
{
   int count = 0;
   struct thread_list_t *cur;

   AST_LIST_LOCK(&thread_list);
   AST_LIST_TRAVERSE(&thread_list, cur, list) {
      ast_cli(fd, "%p %s\n", (void *)cur->id, cur->name);
      count++;
   }
        AST_LIST_UNLOCK(&thread_list);
   ast_cli(fd, "%d threads listed.\n", count);
   return 0;
}

struct profile_entry {
   const char *name;
   uint64_t scale;   /* if non-zero, values are scaled by this */
   int64_t  mark;
   int64_t  value;
   int64_t  events;
};

struct profile_data {
   int entries;
   int max_size;
   struct profile_entry e[0];
};

static struct profile_data *prof_data;

/*! \brief allocates a counter with a given name and scale.
 * \return Returns the identifier of the counter.
 */
int ast_add_profile(const char *name, uint64_t scale)
{
   int l = sizeof(struct profile_data);
   int n = 10; /* default entries */

   if (prof_data == NULL) {
      prof_data = ast_calloc(1, l + n*sizeof(struct profile_entry));
      if (prof_data == NULL)
         return -1;
      prof_data->entries = 0;
      prof_data->max_size = n;
   }
   if (prof_data->entries >= prof_data->max_size) {
      void *p;
      n = prof_data->max_size + 20;
      p = ast_realloc(prof_data, l + n*sizeof(struct profile_entry));
      if (p == NULL)
         return -1;
      prof_data = p;
      prof_data->max_size = n;
   }
   n = prof_data->entries++;
   prof_data->e[n].name = ast_strdup(name);
   prof_data->e[n].value = 0;
   prof_data->e[n].events = 0;
   prof_data->e[n].mark = 0;
   prof_data->e[n].scale = scale;
   return n;
}

int64_t ast_profile(int i, int64_t delta)
{
   if (!prof_data || i < 0 || i > prof_data->entries) /* invalid index */
      return 0;
   if (prof_data->e[i].scale > 1)
      delta /= prof_data->e[i].scale;
   prof_data->e[i].value += delta;
   prof_data->e[i].events++;
   return prof_data->e[i].value;
}

/* The RDTSC instruction was introduced on the Pentium processor and is not
 * implemented on certain clones, like the Cyrix 586. Hence, the previous
 * expectation of __i386__ was in error. */
#if defined ( __i686__) && (defined(__FreeBSD__) || defined(linux))
#if defined(__FreeBSD__)
#include <machine/cpufunc.h>
#elif defined(linux)
static __inline uint64_t
rdtsc(void)
{ 
   uint64_t rv;

   __asm __volatile(".byte 0x0f, 0x31" : "=A" (rv));
   return (rv);
}
#endif
#else /* supply a dummy function on other platforms */
static __inline uint64_t
rdtsc(void)
{
   return 0;
}
#endif

int64_t ast_mark(int i, int startstop)
{
   if (!prof_data || i < 0 || i > prof_data->entries) /* invalid index */
      return 0;
   if (startstop == 1)
      prof_data->e[i].mark = rdtsc();
   else {
      prof_data->e[i].mark = (rdtsc() - prof_data->e[i].mark);
      if (prof_data->e[i].scale > 1)
         prof_data->e[i].mark /= prof_data->e[i].scale;
      prof_data->e[i].value += prof_data->e[i].mark;
      prof_data->e[i].events++;
   }
   return prof_data->e[i].mark;
}

static int handle_show_profile_deprecated(int fd, int argc, char *argv[])
{
   int i, min, max;
   char *search = NULL;

   if (prof_data == NULL)
      return 0;

   min = 0;
   max = prof_data->entries;
   if  (argc >= 3) { /* specific entries */
      if (isdigit(argv[2][0])) {
         min = atoi(argv[2]);
         if (argc == 4 && strcmp(argv[3], "-"))
            max = atoi(argv[3]);
      } else
         search = argv[2];
   }
   if (max > prof_data->entries)
      max = prof_data->entries;
   if (!strcmp(argv[0], "clear")) {
      for (i= min; i < max; i++) {
         if (!search || strstr(prof_data->e[i].name, search)) {
            prof_data->e[i].value = 0;
            prof_data->e[i].events = 0;
         }
      }
      return 0;
   }
   ast_cli(fd, "profile values (%d, allocated %d)\n-------------------\n",
      prof_data->entries, prof_data->max_size);
   ast_cli(fd, "%6s   %8s  %10s %12s %12s  %s\n", "ID", "Scale", "Events",
         "Value", "Average", "Name");
   for (i = min; i < max; i++) {
      struct profile_entry *e = &prof_data->e[i];
      if (!search || strstr(prof_data->e[i].name, search))
          ast_cli(fd, "%6d: [%8ld] %10ld %12lld %12lld  %s\n",
         i,
         (long)e->scale,
         (long)e->events, (long long)e->value,
         (long long)(e->events ? e->value / e->events : e->value),
         e->name);
   }
   return 0;
}

static int handle_show_profile(int fd, int argc, char *argv[])
{
   int i, min, max;
   char *search = NULL;

   if (prof_data == NULL)
      return 0;

   min = 0;
   max = prof_data->entries;
   if  (argc > 3) { /* specific entries */
      if (isdigit(argv[3][0])) {
         min = atoi(argv[3]);
         if (argc == 5 && strcmp(argv[4], "-"))
            max = atoi(argv[4]);
      } else
         search = argv[3];
   }
   if (max > prof_data->entries)
      max = prof_data->entries;
   if (!strcmp(argv[1], "clear")) {
      for (i= min; i < max; i++) {
         if (!search || strstr(prof_data->e[i].name, search)) {
            prof_data->e[i].value = 0;
            prof_data->e[i].events = 0;
         }
      }
      return 0;
   }
   ast_cli(fd, "profile values (%d, allocated %d)\n-------------------\n",
      prof_data->entries, prof_data->max_size);
   ast_cli(fd, "%6s   %8s  %10s %12s %12s  %s\n", "ID", "Scale", "Events",
         "Value", "Average", "Name");
   for (i = min; i < max; i++) {
      struct profile_entry *e = &prof_data->e[i];
      if (!search || strstr(prof_data->e[i].name, search))
          ast_cli(fd, "%6d: [%8ld] %10ld %12lld %12lld  %s\n",
         i,
         (long)e->scale,
         (long)e->events, (long long)e->value,
         (long long)(e->events ? e->value / e->events : e->value),
         e->name);
   }
   return 0;
}

static char show_version_files_help[] = 
"Usage: core show file version [like <pattern>]\n"
"       Lists 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";

/*! \brief CLI command to list module versions */
static int handle_show_version_files_deprecated(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 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 6:
      if (!strcasecmp(argv[4], "like")) {
         if (regcomp(&regexbuf, argv[5], REG_EXTENDED | REG_NOSUB))
            return RESULT_SHOWUSAGE;
         havepattern = 1;
      } else
         return RESULT_SHOWUSAGE;
      break;
   case 5:
      havename = 1;
      break;
   case 4:
      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[4]))
         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_deprecated(const char *line, const 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) && ++which > state) {
         ret = ast_strdup(find->file);
         break;
      }
   }
   AST_LIST_UNLOCK(&file_versions);

   return ret;
}

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

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

   return ret;
}

#endif /* ! LOW_MEMORY */

int ast_register_atexit(void (*func)(void))
{
   struct ast_atexit *ae;

   if (!(ae = ast_calloc(1, sizeof(*ae))))
      return -1;

   ae->func = func;

   ast_unregister_atexit(func);  

   AST_LIST_LOCK(&atexits);
   AST_LIST_INSERT_HEAD(&atexits, ae, list);
   AST_LIST_UNLOCK(&atexits);

   return 0;
}

void ast_unregister_atexit(void (*func)(void))
{
   struct ast_atexit *ae = NULL;

   AST_LIST_LOCK(&atexits);
   AST_LIST_TRAVERSE_SAFE_BEGIN(&atexits, ae, list) {
      if (ae->func == func) {
         AST_LIST_REMOVE_CURRENT(&atexits, list);
         break;
      }
   }
   AST_LIST_TRAVERSE_SAFE_END
   AST_LIST_UNLOCK(&atexits);

   if (ae)
      free(ae);
}

/* Sending commands from consoles back to the daemon requires a terminating NULL */
static int fdsend(int fd, const char *s)
{
   return write(fd, s, strlen(s) + 1);
}

/* Sending messages from the daemon back to the display requires _excluding_ the terminating NULL */
static int fdprint(int fd, const char *s)
{
   return write(fd, s, strlen(s));
}

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

}

AST_MUTEX_DEFINE_STATIC(safe_system_lock);
/*! \brief Keep track of how many threads are currently trying to wait*() on
 *  a child process */
static unsigned int safe_system_level = 0;
static void *safe_system_prev_handler;

void ast_replace_sigchld(void)
{
   unsigned int level;

   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);
}

void ast_unreplace_sigchld(void)
{
   unsigned int level;

   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);
}

int ast_safe_system(const char *s)
{
   pid_t pid;
#ifdef HAVE_WORKING_FORK
   int x;
#endif
   int res;
   struct rusage rusage;
   int status;

#if defined(HAVE_WORKING_FORK) || defined(HAVE_WORKING_VFORK)
   ast_replace_sigchld();

#ifdef HAVE_WORKING_FORK
   pid = fork();
#else
   pid = vfork();
#endif   

   if (pid == 0) {
#ifdef HAVE_WORKING_FORK
      if (ast_opt_high_priority)
         ast_set_priority(0);
      /* Close file descriptors and launch system command */
      for (x = STDERR_FILENO + 1; x < 4096; x++)
         close(x);
#endif
      execl("/bin/sh", "/bin/sh", "-c", s, (char *) 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_unreplace_sigchld();
#else
   res = -1;
#endif

   return res;
}

/*!
 * \brief mute or unmute a console from logging
 */
void ast_console_toggle_mute(int fd, int silent) {
   int x;
   for (x = 0;x < AST_MAX_CONNECTS; x++) {
      if (fd == consoles[x].fd) {
         if (consoles[x].mute) {
            consoles[x].mute = 0;
            if (!silent)
               ast_cli(fd, "Console is not muted anymore.\n");
         } else {
            consoles[x].mute = 1;
            if (!silent)
               ast_cli(fd, "Console is muted.\n");
         }
         return;
      }
   }
   ast_cli(fd, "Couldn't find remote console.\n");
}

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

/*!
 * \brief log the string to the console, and all attached
 * console clients
 */
void ast_console_puts_mutable(const char *string)
{
   fputs(string, stdout);
   fflush(stdout);
   ast_network_puts_mutable(string);
}

/*!
 * \brief 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)
{
   ast_network_puts_mutable(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/%ld/%s\n", hostname, (long)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_multiple(con->fd, res, 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];