Sat Nov 1 06:28:30 2008

Asterisk developer's documentation

---

cli.c

Go to the documentation of this file.

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

/*! \file
 *
 * \brief Standard Command Line Interface
 *
 * \author Mark Spencer <markster@digium.com> 
 */

#include "asterisk.h"

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

#include <unistd.h>
#include <stdlib.h>
#include <sys/signal.h>
#include <stdio.h>
#include <signal.h>
#include <string.h>
#include <ctype.h>
#include <regex.h>

#include "asterisk/logger.h"
#include "asterisk/options.h"
#include "asterisk/cli.h"
#include "asterisk/linkedlists.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/channel.h"
#include "asterisk/utils.h"
#include "asterisk/app.h"
#include "asterisk/lock.h"
#include "editline/readline/readline.h"
#include "asterisk/threadstorage.h"

extern unsigned long global_fin, global_fout;

AST_THREADSTORAGE(ast_cli_buf, ast_cli_buf_init);

/*! \brief Initial buffer size for resulting strings in ast_cli() */
#define AST_CLI_INITLEN   256

void ast_cli(int fd, char *fmt, ...)
{
   int res;
   struct ast_dynamic_str *buf;
   va_list ap;

   if (!(buf = ast_dynamic_str_thread_get(&ast_cli_buf, AST_CLI_INITLEN)))
      return;

   va_start(ap, fmt);
   res = ast_dynamic_str_thread_set_va(&buf, 0, &ast_cli_buf, fmt, ap);
   va_end(ap);

   if (res != AST_DYNSTR_BUILD_FAILED)
      ast_carefulwrite(fd, buf->str, strlen(buf->str), 100);
}

static AST_LIST_HEAD_STATIC(helpers, ast_cli_entry);

static char load_help[] = 
"Usage: module load <module name>\n"
"       Loads the specified module into Asterisk.\n";

static char unload_help[] = 
"Usage: module unload [-f|-h] <module name>\n"
"       Unloads the specified module from Asterisk. The -f\n"
"       option causes the module to be unloaded even if it is\n"
"       in use (may cause a crash) and the -h module causes the\n"
"       module to be unloaded even if the module says it cannot, \n"
"       which almost always will cause a crash.\n";

static char help_help[] =
"Usage: help [topic]\n"
"       When called with a topic as an argument, displays usage\n"
"       information on the given command. If called without a\n"
"       topic, it provides a list of commands.\n";

static char chanlist_help[] = 
"Usage: core show channels [concise|verbose]\n"
"       Lists currently defined channels and some information about them. If\n"
"       'concise' is specified, the format is abridged and in a more easily\n"
"       machine parsable format. If 'verbose' is specified, the output includes\n"
"       more and longer fields.\n";

static char reload_help[] = 
"Usage: module reload [module ...]\n"
"       Reloads configuration files for all listed modules which support\n"
"       reloading, or for all supported modules if none are listed.\n";

static char verbose_help[] = 
"Usage: core set verbose <level>\n"
"       Sets level of verbose messages to be displayed.  0 means\n"
"       no messages should be displayed. Equivalent to -v[v[v...]]\n"
"       on startup\n";

static char debug_help[] = 
"Usage: core set debug <level> [filename]\n"
"       Sets level of core debug messages to be displayed.  0 means\n"
"       no messages should be displayed.  Equivalent to -d[d[d...]]\n"
"       on startup.  If filename is specified, debugging will be\n"
"       limited to just that file.\n";

static char nodebug_help[] = 
"Usage: core set debug off\n"
"       Turns off core debug messages.\n";

static char logger_mute_help[] = 
"Usage: logger mute\n"
"       Disables logging output to the current console, making it possible to\n"
"       gather information without being disturbed by scrolling lines.\n";

static char softhangup_help[] =
"Usage: soft hangup <channel>\n"
"       Request that a channel be hung up. The hangup takes effect\n"
"       the next time the driver reads or writes from the channel\n";

static char group_show_channels_help[] = 
"Usage: group show channels [pattern]\n"
"       Lists all currently active channels with channel group(s) specified.\n"
"       Optional regular expression pattern is matched to group names for each\n"
"       channel.\n";

static int handle_load_deprecated(int fd, int argc, char *argv[])
{
   if (argc != 2)
      return RESULT_SHOWUSAGE;
   if (ast_load_resource(argv[1])) {
      ast_cli(fd, "Unable to load module %s\n", argv[1]);
      return RESULT_FAILURE;
   }
   return RESULT_SUCCESS;
}

static int handle_load(int fd, int argc, char *argv[])
{
   if (argc != 3)
      return RESULT_SHOWUSAGE;
   if (ast_load_resource(argv[2])) {
      ast_cli(fd, "Unable to load module %s\n", argv[2]);
      return RESULT_FAILURE;
   }
   return RESULT_SUCCESS;
}

static int handle_reload_deprecated(int fd, int argc, char *argv[])
{
   int x;
   int res;
   if (argc < 1)
      return RESULT_SHOWUSAGE;
   if (argc > 1) { 
      for (x = 1; x < argc; x++) {
         res = ast_module_reload(argv[x]);
         switch(res) {
         case 0:
            ast_cli(fd, "No such module '%s'\n", argv[x]);
            break;
         case 1:
            ast_cli(fd, "Module '%s' does not support reload\n", argv[x]);
            break;
         }
      }
   } else
      ast_module_reload(NULL);
   return RESULT_SUCCESS;
}

static int handle_reload(int fd, int argc, char *argv[])
{
   int x;
   int res;
   if (argc < 2)
      return RESULT_SHOWUSAGE;
   if (argc > 2) { 
      for (x = 2; x < argc; x++) {
         res = ast_module_reload(argv[x]);
         switch(res) {
         case 0:
            ast_cli(fd, "No such module '%s'\n", argv[x]);
            break;
         case 1:
            ast_cli(fd, "Module '%s' does not support reload\n", argv[x]);
            break;
         }
      }
   } else
      ast_module_reload(NULL);
   return RESULT_SUCCESS;
}

static int handle_set_verbose_deprecated(int fd, int argc, char *argv[])
{
   int val = 0;
   int oldval = option_verbose;

   /* "set verbose [atleast] N" */
   if (argc == 3)
      option_verbose = atoi(argv[2]);
   else if (argc == 4) {
      if (strcasecmp(argv[2], "atleast"))
         return RESULT_SHOWUSAGE;
      val = atoi(argv[3]);
      if (val > option_verbose)
         option_verbose = val;
   } else
      return RESULT_SHOWUSAGE;

   if (oldval != option_verbose && option_verbose > 0)
      ast_cli(fd, "Verbosity was %d and is now %d\n", oldval, option_verbose);
   else if (oldval > 0 && option_verbose > 0)
      ast_cli(fd, "Verbosity is at least %d\n", option_verbose);
   else if (oldval > 0 && option_verbose == 0)
      ast_cli(fd, "Verbosity is now OFF\n");

   return RESULT_SUCCESS;
}

static int handle_verbose(int fd, int argc, char *argv[])
{
   int oldval = option_verbose;
   int newlevel;
   int atleast = 0;

   if ((argc < 4) || (argc > 5))
      return RESULT_SHOWUSAGE;

   if (!strcasecmp(argv[3], "atleast"))
      atleast = 1;

   if (!atleast) {
      if (argc > 4)
         return RESULT_SHOWUSAGE;

      option_verbose = atoi(argv[3]);
   } else {
      if (argc < 5)
         return RESULT_SHOWUSAGE;

      newlevel = atoi(argv[4]);
      if (newlevel > option_verbose)
         option_verbose = newlevel;
        }
   if (oldval > 0 && option_verbose == 0)
      ast_cli(fd, "Verbosity is now OFF\n");
   else if (option_verbose > 0) {
      if (oldval == option_verbose)
         ast_cli(fd, "Verbosity is at least %d\n", option_verbose);
      else
         ast_cli(fd, "Verbosity was %d and is now %d\n", oldval, option_verbose);
   }

   return RESULT_SUCCESS;
}

static int handle_set_debug_deprecated(int fd, int argc, char *argv[])
{
   int val = 0;
   int oldval = option_debug;

   /* "set debug [atleast] N" */
   if (argc == 3)
      option_debug = atoi(argv[2]);
   else if (argc == 4) {
      if (strcasecmp(argv[2], "atleast"))
         return RESULT_SHOWUSAGE;
      val = atoi(argv[3]);
      if (val > option_debug)
         option_debug = val;
   } else
      return RESULT_SHOWUSAGE;

   if (oldval != option_debug && option_debug > 0)
      ast_cli(fd, "Core debug was %d and is now %d\n", oldval, option_debug);
   else if (oldval > 0 && option_debug > 0)
      ast_cli(fd, "Core debug is at least %d\n", option_debug);
   else if (oldval > 0 && option_debug == 0)
      ast_cli(fd, "Core debug is now OFF\n");

   return RESULT_SUCCESS;
}

static int handle_set_debug(int fd, int argc, char *argv[])
{
   int oldval = option_debug;
   int newlevel;
   int atleast = 0;
   char *filename = '\0';

   /* 'core set debug <level>'
    * 'core set debug <level> <fn>'
    * 'core set debug atleast <level>'
    * 'core set debug atleast <level> <fn>'
    */
   if ((argc < 4) || (argc > 6))
      return RESULT_SHOWUSAGE;

   if (!strcasecmp(argv[3], "atleast"))
      atleast = 1;

   if (!atleast) {
      if (argc > 5)
         return RESULT_SHOWUSAGE;

      if (sscanf(argv[3], "%d", &newlevel) != 1)
         return RESULT_SHOWUSAGE;

      if (argc == 4) {
         debug_filename[0] = '\0';
      } else {
         filename = argv[4];
         ast_copy_string(debug_filename, filename, sizeof(debug_filename));
      }

      option_debug = newlevel;
   } else {
      if (argc < 5 || argc > 6)
         return RESULT_SHOWUSAGE;

      if (sscanf(argv[4], "%d", &newlevel) != 1)
         return RESULT_SHOWUSAGE;

      if (argc == 5) {
         debug_filename[0] = '\0';
      } else {
         filename = argv[5];
         ast_copy_string(debug_filename, filename, sizeof(debug_filename));
      }

      if (newlevel > option_debug)
         option_debug = newlevel;
   }

   if (oldval > 0 && option_debug == 0)
      ast_cli(fd, "Core debug is now OFF\n");
   else if (option_debug > 0) {
      if (filename) {
         if (oldval == option_debug)
            ast_cli(fd, "Core debug is at least %d, file '%s'\n", option_debug, filename);
         else
            ast_cli(fd, "Core debug was %d and is now %d, file '%s'\n", oldval, option_debug, filename);
      } else {
         if (oldval == option_debug)
            ast_cli(fd, "Core debug is at least %d\n", option_debug);
         else
            ast_cli(fd, "Core debug was %d and is now %d\n", oldval, option_debug);
      }
   }

   return RESULT_SUCCESS;
}

static int handle_nodebug(int fd, int argc, char *argv[])
{
   int oldval = option_debug;
   if (argc != 4)
      return RESULT_SHOWUSAGE;

   option_debug = 0;
   debug_filename[0] = '\0';

   if (oldval > 0)
      ast_cli(fd, "Core debug is now OFF\n");
   return RESULT_SUCCESS;
}

static int handle_debuglevel_deprecated(int fd, int argc, char *argv[])
{
   int newlevel;
   char *filename = "<any>";
   if ((argc < 3) || (argc > 4))
      return RESULT_SHOWUSAGE;
   if (sscanf(argv[2], "%d", &newlevel) != 1)
      return RESULT_SHOWUSAGE;
   option_debug = newlevel;
   if (argc == 4) {
      filename = argv[3];
      ast_copy_string(debug_filename, filename, sizeof(debug_filename));
   } else {
      debug_filename[0] = '\0';
   }
   ast_cli(fd, "Debugging level set to %d, file '%s'\n", newlevel, filename);
   return RESULT_SUCCESS;
}

static int handle_logger_mute(int fd, int argc, char *argv[])
{
   if (argc < 2 || argc > 3)
      return RESULT_SHOWUSAGE;
   if (argc == 3 && !strcasecmp(argv[2], "silent"))
      ast_console_toggle_mute(fd, 1);
   else
      ast_console_toggle_mute(fd, 0);
   return RESULT_SUCCESS;
}

static int handle_unload_deprecated(int fd, int argc, char *argv[])
{
   int x;
   int force = AST_FORCE_SOFT;
   if (argc < 2)
      return RESULT_SHOWUSAGE;
   for (x = 1; x < argc; x++) {
      if (argv[x][0] == '-') {
         switch(argv[x][1]) {
         case 'f':
            force = AST_FORCE_FIRM;
            break;
         case 'h':
            force = AST_FORCE_HARD;
            break;
         default:
            return RESULT_SHOWUSAGE;
         }
      } else if (x != argc - 1) 
         return RESULT_SHOWUSAGE;
      else if (ast_unload_resource(argv[x], force)) {
         ast_cli(fd, "Unable to unload resource %s\n", argv[x]);
         return RESULT_FAILURE;
      }
   }
   return RESULT_SUCCESS;
}

static int handle_unload(int fd, int argc, char *argv[])
{
   int x;
   int force = AST_FORCE_SOFT;
   if (argc < 3)
      return RESULT_SHOWUSAGE;
   for (x = 2; x < argc; x++) {
      if (argv[x][0] == '-') {
         switch(argv[x][1]) {
         case 'f':
            force = AST_FORCE_FIRM;
            break;
         case 'h':
            force = AST_FORCE_HARD;
            break;
         default:
            return RESULT_SHOWUSAGE;
         }
      } else if (x != argc - 1) 
         return RESULT_SHOWUSAGE;
      else if (ast_unload_resource(argv[x], force)) {
         ast_cli(fd, "Unable to unload resource %s\n", argv[x]);
         return RESULT_FAILURE;
      }
   }
   return RESULT_SUCCESS;
}

#define MODLIST_FORMAT  "%-30s %-40.40s %-10d\n"
#define MODLIST_FORMAT2 "%-30s %-40.40s %-10s\n"

AST_MUTEX_DEFINE_STATIC(climodentrylock);
static int climodentryfd = -1;

static int modlist_modentry(const char *module, const char *description, int usecnt, const char *like)
{
   /* Comparing the like with the module */
   if (strcasestr(module, like) ) {
      ast_cli(climodentryfd, MODLIST_FORMAT, module, description, usecnt);
      return 1;
   } 
   return 0;
}

static char modlist_help[] =
"Usage: module show [like <keyword>]\n"
"       Shows Asterisk modules currently in use, and usage statistics.\n";

static char uptime_help[] =
"Usage: core show uptime [seconds]\n"
"       Shows Asterisk uptime information.\n"
"       The seconds word returns the uptime in seconds only.\n";

static void print_uptimestr(int fd, time_t timeval, const char *prefix, int printsec)
{
   int x; /* the main part - years, weeks, etc. */
   char timestr[256]="", *s = timestr;
   size_t maxbytes = sizeof(timestr);

#define SECOND (1)
#define MINUTE (SECOND*60)
#define HOUR (MINUTE*60)
#define DAY (HOUR*24)
#define WEEK (DAY*7)
#define YEAR (DAY*365)
#define ESS(x) ((x == 1) ? "" : "s")   /* plural suffix */
#define NEEDCOMMA(x) ((x)? ",": "") /* define if we need a comma */
   if (timeval < 0)  /* invalid, nothing to show */
      return;
   if (printsec)  {  /* plain seconds output */
      ast_build_string(&s, &maxbytes, "%lu", (u_long)timeval);
      timeval = 0; /* bypass the other cases */
   }
   if (timeval > YEAR) {
      x = (timeval / YEAR);
      timeval -= (x * YEAR);
      ast_build_string(&s, &maxbytes, "%d year%s%s ", x, ESS(x),NEEDCOMMA(timeval));
   }
   if (timeval > WEEK) {
      x = (timeval / WEEK);
      timeval -= (x * WEEK);
      ast_build_string(&s, &maxbytes, "%d week%s%s ", x, ESS(x),NEEDCOMMA(timeval));
   }
   if (timeval > DAY) {
      x = (timeval / DAY);
      timeval -= (x * DAY);
      ast_build_string(&s, &maxbytes, "%d day%s%s ", x, ESS(x),NEEDCOMMA(timeval));
   }
   if (timeval > HOUR) {
      x = (timeval / HOUR);
      timeval -= (x * HOUR);
      ast_build_string(&s, &maxbytes, "%d hour%s%s ", x, ESS(x),NEEDCOMMA(timeval));
   }
   if (timeval > MINUTE) {
      x = (timeval / MINUTE);
      timeval -= (x * MINUTE);
      ast_build_string(&s, &maxbytes, "%d minute%s%s ", x, ESS(x),NEEDCOMMA(timeval));
   }
   x = timeval;
   if (x > 0)
      ast_build_string(&s, &maxbytes, "%d second%s ", x, ESS(x));
   if (timestr[0] != '\0')
      ast_cli(fd, "%s: %s\n", prefix, timestr);
}

static int handle_showuptime_deprecated(int fd, int argc, char *argv[])
{
   /* 'show uptime [seconds]' */
   time_t curtime = time(NULL);
   int printsec = (argc == 3 && !strcasecmp(argv[2],"seconds"));

   if (argc != 2 && !printsec)
      return RESULT_SHOWUSAGE;
   if (ast_startuptime)
      print_uptimestr(fd, curtime - ast_startuptime, "System uptime", printsec);
   if (ast_lastreloadtime)
      print_uptimestr(fd, curtime - ast_lastreloadtime, "Last reload", printsec);
   return RESULT_SUCCESS;
}

static int handle_showuptime(int fd, int argc, char *argv[])
{
   /* 'core show uptime [seconds]' */
   time_t curtime = time(NULL);
   int printsec = (argc == 4 && !strcasecmp(argv[3],"seconds"));

   if (argc != 3 && !printsec)
      return RESULT_SHOWUSAGE;
   if (ast_startuptime)
      print_uptimestr(fd, curtime - ast_startuptime, "System uptime", printsec);
   if (ast_lastreloadtime)
      print_uptimestr(fd, curtime - ast_lastreloadtime, "Last reload", printsec);
   return RESULT_SUCCESS;
}

static int handle_modlist(int fd, int argc, char *argv[])
{
   char *like = "";
   if (argc == 3)
      return RESULT_SHOWUSAGE;
   else if (argc >= 4) {
      if (strcmp(argv[2],"like")) 
         return RESULT_SHOWUSAGE;
      like = argv[3];
   }
      
   ast_mutex_lock(&climodentrylock);
   climodentryfd = fd; /* global, protected by climodentrylock */
   ast_cli(fd, MODLIST_FORMAT2, "Module", "Description", "Use Count");
   ast_cli(fd,"%d modules loaded\n", ast_update_module_list(modlist_modentry, like));
   climodentryfd = -1;
   ast_mutex_unlock(&climodentrylock);
   return RESULT_SUCCESS;
}
#undef MODLIST_FORMAT
#undef MODLIST_FORMAT2

#define FORMAT_STRING  "%-20.20s %-20.20s %-7.7s %-30.30s\n"
#define FORMAT_STRING2 "%-20.20s %-20.20s %-7.7s %-30.30s\n"
#define CONCISE_FORMAT_STRING  "%s!%s!%s!%d!%s!%s!%s!%s!%s!%d!%s!%s\n"
#define VERBOSE_FORMAT_STRING  "%-20.20s %-20.20s %-16.16s %4d %-7.7s %-12.12s %-25.25s %-15.15s %8.8s %-11.11s %-20.20s\n"
#define VERBOSE_FORMAT_STRING2 "%-20.20s %-20.20s %-16.16s %-4.4s %-7.7s %-12.12s %-25.25s %-15.15s %8.8s %-11.11s %-20.20s\n"

static int handle_chanlist_deprecated(int fd, int argc, char *argv[])
{
   struct ast_channel *c = NULL;
   char durbuf[10] = "-";
   char locbuf[40];
   char appdata[40];
   int duration;
   int durh, durm, durs;
   int numchans = 0, concise = 0, verbose = 0;

   concise = (argc == 3 && (!strcasecmp(argv[2],"concise")));
   verbose = (argc == 3 && (!strcasecmp(argv[2],"verbose")));

   if (argc < 2 || argc > 3 || (argc == 3 && !concise && !verbose))
      return RESULT_SHOWUSAGE;

   if (!concise && !verbose)
      ast_cli(fd, FORMAT_STRING2, "Channel", "Location", "State", "Application(Data)");
   else if (verbose)
      ast_cli(fd, VERBOSE_FORMAT_STRING2, "Channel", "Context", "Extension", "Priority", "State", "Application", "Data", 
              "CallerID", "Duration", "Accountcode", "BridgedTo");

   while ((c = ast_channel_walk_locked(c)) != NULL) {
      struct ast_channel *bc = ast_bridged_channel(c);
      if ((concise || verbose)  && c->cdr && !ast_tvzero(c->cdr->start)) {
         duration = (int)(ast_tvdiff_ms(ast_tvnow(), c->cdr->start) / 1000);
         if (verbose) {
            durh = duration / 3600;
            durm = (duration % 3600) / 60;
            durs = duration % 60;
            snprintf(durbuf, sizeof(durbuf), "%02d:%02d:%02d", durh, durm, durs);
         } else {
            snprintf(durbuf, sizeof(durbuf), "%d", duration);
         }           
      } else {
         durbuf[0] = '\0';
      }
      if (concise) {
         ast_cli(fd, CONCISE_FORMAT_STRING, c->name, c->context, c->exten, c->priority, ast_state2str(c->_state),
                 c->appl ? c->appl : "(None)",
            S_OR(c->data, ""),   /* XXX different from verbose ? */
                 S_OR(c->cid.cid_num, ""),
                 S_OR(c->accountcode, ""),
            c->amaflags, 
                 durbuf,
            bc ? bc->name : "(None)");
      } else if (verbose) {
         ast_cli(fd, VERBOSE_FORMAT_STRING, c->name, c->context, c->exten, c->priority, ast_state2str(c->_state),
                 c->appl ? c->appl : "(None)",
            c->data ? S_OR(c->data, "(Empty)" ): "(None)",
                 S_OR(c->cid.cid_num, ""),
            durbuf,
                 S_OR(c->accountcode, ""),
            bc ? bc->name : "(None)");
      } else {
         if (!ast_strlen_zero(c->context) && !ast_strlen_zero(c->exten)) 
            snprintf(locbuf, sizeof(locbuf), "%s@%s:%d", c->exten, c->context, c->priority);
         else
            strcpy(locbuf, "(None)");
         if (c->appl)
            snprintf(appdata, sizeof(appdata), "%s(%s)", c->appl, c->data ? c->data : "");
         else
            strcpy(appdata, "(None)");
         ast_cli(fd, FORMAT_STRING, c->name, locbuf, ast_state2str(c->_state), appdata);
      }
      numchans++;
      ast_channel_unlock(c);
   }
   if (!concise) {
      ast_cli(fd, "%d active channel%s\n", numchans, ESS(numchans));
      if (option_maxcalls)
         ast_cli(fd, "%d of %d max active call%s (%5.2f%% of capacity)\n",
            ast_active_calls(), option_maxcalls, ESS(ast_active_calls()),
            ((double)ast_active_calls() / (double)option_maxcalls) * 100.0);
      else
         ast_cli(fd, "%d active call%s\n", ast_active_calls(), ESS(ast_active_calls()));
   }
   return RESULT_SUCCESS;
}
   
static int handle_chanlist(int fd, int argc, char *argv[])
{
   struct ast_channel *c = NULL;
   char durbuf[10] = "-";
   char locbuf[40];
   char appdata[40];
   int duration;
   int durh, durm, durs;
   int numchans = 0, concise = 0, verbose = 0;

   concise = (argc == 4 && (!strcasecmp(argv[3],"concise")));
   verbose = (argc == 4 && (!strcasecmp(argv[3],"verbose")));

   if (argc < 3 || argc > 4 || (argc == 4 && !concise && !verbose))
      return RESULT_SHOWUSAGE;

   if (!concise && !verbose)
      ast_cli(fd, FORMAT_STRING2, "Channel", "Location", "State", "Application(Data)");
   else if (verbose)
      ast_cli(fd, VERBOSE_FORMAT_STRING2, "Channel", "Context", "Extension", "Priority", "State", "Application", "Data", 
              "CallerID", "Duration", "Accountcode", "BridgedTo");

   while ((c = ast_channel_walk_locked(c)) != NULL) {
      struct ast_channel *bc = ast_bridged_channel(c);
      if ((concise || verbose)  && c->cdr && !ast_tvzero(c->cdr->start)) {
         duration = (int)(ast_tvdiff_ms(ast_tvnow(), c->cdr->start) / 1000);
         if (verbose) {
            durh = duration / 3600;
            durm = (duration % 3600) / 60;
            durs = duration % 60;
            snprintf(durbuf, sizeof(durbuf), "%02d:%02d:%02d", durh, durm, durs);
         } else {
            snprintf(durbuf, sizeof(durbuf), "%d", duration);
         }           
      } else {
         durbuf[0] = '\0';
      }
      if (concise) {
         ast_cli(fd, CONCISE_FORMAT_STRING, c->name, c->context, c->exten, c->priority, ast_state2str(c->_state),
                 c->appl ? c->appl : "(None)",
            S_OR(c->data, ""),   /* XXX different from verbose ? */
                 S_OR(c->cid.cid_num, ""),
                 S_OR(c->accountcode, ""),
            c->amaflags, 
                 durbuf,
            bc ? bc->name : "(None)");
      } else if (verbose) {
         ast_cli(fd, VERBOSE_FORMAT_STRING, c->name, c->context, c->exten, c->priority, ast_state2str(c->_state),
                 c->appl ? c->appl : "(None)",
            c->data ? S_OR(c->data, "(Empty)" ): "(None)",
                 S_OR(c->cid.cid_num, ""),
            durbuf,
                 S_OR(c->accountcode, ""),
            bc ? bc->name : "(None)");
      } else {
         if (!ast_strlen_zero(c->context) && !ast_strlen_zero(c->exten)) 
            snprintf(locbuf, sizeof(locbuf), "%s@%s:%d", c->exten, c->context, c->priority);
         else
            strcpy(locbuf, "(None)");
         if (c->appl)
            snprintf(appdata, sizeof(appdata), "%s(%s)", c->appl, c->data ? c->data : "");
         else
            strcpy(appdata, "(None)");
         ast_cli(fd, FORMAT_STRING, c->name, locbuf, ast_state2str(c->_state), appdata);
      }
      numchans++;
      ast_channel_unlock(c);
   }
   if (!concise) {
      ast_cli(fd, "%d active channel%s\n", numchans, ESS(numchans));
      if (option_maxcalls)
         ast_cli(fd, "%d of %d max active call%s (%5.2f%% of capacity)\n",
            ast_active_calls(), option_maxcalls, ESS(ast_active_calls()),
            ((double)ast_active_calls() / (double)option_maxcalls) * 100.0);
      else
         ast_cli(fd, "%d active call%s\n", ast_active_calls(), ESS(ast_active_calls()));
   }
   return RESULT_SUCCESS;
}
   
#undef FORMAT_STRING
#undef FORMAT_STRING2
#undef CONCISE_FORMAT_STRING
#undef VERBOSE_FORMAT_STRING
#undef VERBOSE_FORMAT_STRING2

static char showchan_help[] = 
"Usage: core show channel <channel>\n"
"       Shows lots of information about the specified channel.\n";

static char debugchan_help[] = 
"Usage: core set debug channel <channel> [off]\n"
"       Enables/disables debugging on a specific channel.\n";

static char commandcomplete_help[] = 
"Usage: _command complete \"<line>\" text state\n"
"       This function is used internally to help with command completion and should.\n"
"       never be called by the user directly.\n";

static char commandnummatches_help[] = 
"Usage: _command nummatches \"<line>\" text \n"
"       This function is used internally to help with command completion and should.\n"
"       never be called by the user directly.\n";

static char commandmatchesarray_help[] = 
"Usage: _command matchesarray \"<line>\" text \n"
"       This function is used internally to help with command completion and should.\n"
"       never be called by the user directly.\n";

static int handle_softhangup(int fd, int argc, char *argv[])
{
   struct ast_channel *c=NULL;
   if (argc != 3)
      return RESULT_SHOWUSAGE;
   c = ast_get_channel_by_name_locked(argv[2]);
   if (c) {
      ast_cli(fd, "Requested Hangup on channel '%s'\n", c->name);
      ast_softhangup(c, AST_SOFTHANGUP_EXPLICIT);
      ast_channel_unlock(c);
   } else
      ast_cli(fd, "%s is not a known channel\n", argv[2]);
   return RESULT_SUCCESS;
}

static char *__ast_cli_generator(const char *text, const char *word, int state, int lock);

static int handle_commandmatchesarray(int fd, int argc, char *argv[])
{
   char *buf, *obuf;
   int buflen = 2048;
   int len = 0;
   char **matches;
   int x, matchlen;

   if (argc != 4)
      return RESULT_SHOWUSAGE;
   if (!(buf = ast_malloc(buflen)))
      return RESULT_FAILURE;
   buf[len] = '\0';
   matches = ast_cli_completion_matches(argv[2], argv[3]);
   if (matches) {
      for (x=0; matches[x]; x++) {
         matchlen = strlen(matches[x]) + 1;
         if (len + matchlen >= buflen) {
            buflen += matchlen * 3;
            obuf = buf;
            if (!(buf = ast_realloc(obuf, buflen))) 
               /* Memory allocation failure...  Just free old buffer and be done */
               free(obuf);
         }
         if (buf)
            len += sprintf( buf + len, "%s ", matches[x]);
         free(matches[x]);
         matches[x] = NULL;
      }
      free(matches);
   }

   if (buf) {
      ast_cli(fd, "%s%s",buf, AST_CLI_COMPLETE_EOF);
      free(buf);
   } else
      ast_cli(fd, "NULL\n");

   return RESULT_SUCCESS;
}



static int handle_commandnummatches(int fd, int argc, char *argv[])
{
   int matches = 0;

   if (argc != 4)
      return RESULT_SHOWUSAGE;

   matches = ast_cli_generatornummatches(argv[2], argv[3]);

   ast_cli(fd, "%d", matches);

   return RESULT_SUCCESS;
}

static int handle_commandcomplete(int fd, int argc, char *argv[])
{
   char *buf;

   if (argc != 5)
      return RESULT_SHOWUSAGE;
   buf = __ast_cli_generator(argv[2], argv[3], atoi(argv[4]), 0);
   if (buf) {
      ast_cli(fd, buf);
      free(buf);
   } else
      ast_cli(fd, "NULL\n");
   return RESULT_SUCCESS;
}

static int handle_debugchan_deprecated(int fd, int argc, char *argv[])
{
   struct ast_channel *c=NULL;
   int is_all;

   /* 'debug channel {all|chan_id}' */
   if (argc != 3)
      return RESULT_SHOWUSAGE;

   is_all = !strcasecmp("all", argv[2]);
   if (is_all) {
      global_fin |= DEBUGCHAN_FLAG;
      global_fout |= DEBUGCHAN_FLAG;
      c = ast_channel_walk_locked(NULL);
   } else {
      c = ast_get_channel_by_name_locked(argv[2]);
      if (c == NULL)
         ast_cli(fd, "No such channel %s\n", argv[2]);
   }
   while (c) {
      if (!(c->fin & DEBUGCHAN_FLAG) || !(c->fout & DEBUGCHAN_FLAG)) {
         c->fin |= DEBUGCHAN_FLAG;
         c->fout |= DEBUGCHAN_FLAG;
         ast_cli(fd, "Debugging enabled on channel %s\n", c->name);
      }
      ast_channel_unlock(c);
      if (!is_all)
         break;
      c = ast_channel_walk_locked(c);
   }
   ast_cli(fd, "Debugging on new channels is enabled\n");
   return RESULT_SUCCESS;
}

static int handle_core_set_debug_channel(int fd, int argc, char *argv[])
{
   struct ast_channel *c = NULL;
   int is_all, is_off = 0;

   /* 'core set debug channel {all|chan_id}' */
   if (argc == 6 && strcmp(argv[5], "off") == 0)
      is_off = 1;
   else if (argc != 5)
      return RESULT_SHOWUSAGE;

   is_all = !strcasecmp("all", argv[4]);
   if (is_all) {
      if (is_off) {
         global_fin &= ~DEBUGCHAN_FLAG;
         global_fout &= ~DEBUGCHAN_FLAG;
      } else {
         global_fin |= DEBUGCHAN_FLAG;
         global_fout |= DEBUGCHAN_FLAG;
      }
      c = ast_channel_walk_locked(NULL);
   } else {
      c = ast_get_channel_by_name_locked(argv[4]);
      if (c == NULL)
         ast_cli(fd, "No such channel %s\n", argv[4]);
   }
   while (c) {
      if (!(c->fin & DEBUGCHAN_FLAG) || !(c->fout & DEBUGCHAN_FLAG)) {
         if (is_off) {
            c->fin &= ~DEBUGCHAN_FLAG;
            c->fout &= ~DEBUGCHAN_FLAG;
         } else {
            c->fin |= DEBUGCHAN_FLAG;
            c->fout |= DEBUGCHAN_FLAG;
         }
         ast_cli(fd, "Debugging %s on channel %s\n", is_off ? "disabled" : "enabled", c->name);
      }
      ast_channel_unlock(c);
      if (!is_all)
         break;
      c = ast_channel_walk_locked(c);
   }
   ast_cli(fd, "Debugging on new channels is %s\n", is_off ? "disabled" : "enabled");
   return RESULT_SUCCESS;
}

static int handle_nodebugchan_deprecated(int fd, int argc,