main/cli.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 1999 - 2006, Digium, Inc.
   5  *
   6  * Mark Spencer <markster@digium.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*! \file
  20  *
  21  * \brief Standard Command Line Interface
  22  *
  23  * \author Mark Spencer <markster@digium.com>
  24  */
  25
  26 #include "asterisk.h"
  27
  28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  29
  30 #include <unistd.h>
  31 #include <stdlib.h>
  32 #include <sys/signal.h>
  33 #include <stdio.h>
  34 #include <signal.h>
  35 #include <string.h>
  36 #include <ctype.h>
  37 #include <regex.h>
  38
  39 #include "asterisk/logger.h"
  40 #include "asterisk/options.h"
  41 #include "asterisk/cli.h"
  42 #include "asterisk/linkedlists.h"
  43 #include "asterisk/module.h"
  44 #include "asterisk/pbx.h"
  45 #include "asterisk/channel.h"
  46 #include "asterisk/utils.h"
  47 #include "asterisk/app.h"
  48 #include "asterisk/lock.h"
  49 #include "editline/readline/readline.h"
  50 #include "asterisk/threadstorage.h"
  51
  52 extern unsigned long global_fin, global_fout;
  53
  54 AST_THREADSTORAGE(ast_cli_buf);
  55
  56 /*! \brief Initial buffer size for resulting strings in ast_cli() */
  57 #define AST_CLI_INITLEN   256
  58
  59 void ast_cli(int fd, char *fmt, ...)
  60 {
  61         int res;
  62         struct ast_dynamic_str *buf;
  63         va_list ap;
  64
  65         if (!(buf = ast_dynamic_str_thread_get(&ast_cli_buf, AST_CLI_INITLEN)))
  66                 return;
  67
  68         va_start(ap, fmt);
  69         res = ast_dynamic_str_thread_set_va(&buf, 0, &ast_cli_buf, fmt, ap);
  70         va_end(ap);
  71
  72         if (res != AST_DYNSTR_BUILD_FAILED)
  73                 ast_carefulwrite(fd, buf->str, strlen(buf->str), 100);
  74 }
  75
  76 static AST_LIST_HEAD_STATIC(helpers, ast_cli_entry);
  77
  78 static char load_help[] =
  79 "Usage: module load <module name>\n"
  80 "       Loads the specified module into Asterisk.\n";
  81
  82 static char unload_help[] =
  83 "Usage: module unload [-f|-h] <module name>\n"
  84 "       Unloads the specified module from Asterisk. The -f\n"
  85 "       option causes the module to be unloaded even if it is\n"
  86 "       in use (may cause a crash) and the -h module causes the\n"
  87 "       module to be unloaded even if the module says it cannot, \n"
  88 "       which almost always will cause a crash.\n";
  89
  90 static char help_help[] =
  91 "Usage: help [topic]\n"
  92 "       When called with a topic as an argument, displays usage\n"
  93 "       information on the given command. If called without a\n"
  94 "       topic, it provides a list of commands.\n";
  95
  96 static char chanlist_help[] =
  97 "Usage: core show channels [concise|verbose]\n"
  98 "       Lists currently defined channels and some information about them. If\n"
  99 "       'concise' is specified, the format is abridged and in a more easily\n"
 100 "       machine parsable format. If 'verbose' is specified, the output includes\n"
 101 "       more and longer fields.\n";
 102
 103 static char reload_help[] =
 104 "Usage: module reload [module ...]\n"
 105 "       Reloads configuration files for all listed modules which support\n"
 106 "       reloading, or for all supported modules if none are listed.\n";
 107
 108 static char verbose_help[] =
 109 "Usage: core set verbose <level>\n"
 110 "       Sets level of verbose messages to be displayed.  0 means\n"
 111 "       no messages should be displayed. Equivalent to -v[v[v...]]\n"
 112 "       on startup\n";
 113
 114 static char debug_help[] =
 115 "Usage: core set debug <level> [filename]\n"
 116 "       Sets level of core debug messages to be displayed.  0 means\n"
 117 "       no messages should be displayed.  Equivalent to -d[d[d...]]\n"
 118 "       on startup.  If filename is specified, debugging will be\n"
 119 "       limited to just that file.\n";
 120
 121 static char nodebug_help[] =
 122 "Usage: core set debug off\n"
 123 "       Turns off core debug messages.\n";
 124
 125 static char logger_mute_help[] =
 126 "Usage: logger mute\n"
 127 "       Disables logging output to the current console, making it possible to\n"
 128 "       gather information without being disturbed by scrolling lines.\n";
 129
 130 static char softhangup_help[] =
 131 "Usage: soft hangup <channel>\n"
 132 "       Request that a channel be hung up. The hangup takes effect\n"
 133 "       the next time the driver reads or writes from the channel\n";
 134
 135 static char group_show_channels_help[] =
 136 "Usage: group show channels [pattern]\n"
 137 "       Lists all currently active channels with channel group(s) specified.\n"
 138 "       Optional regular expression pattern is matched to group names for each\n"
 139 "       channel.\n";
 140
 141 static int handle_load_deprecated(int fd, int argc, char *argv[])
 142 {
 143         if (argc != 2)
 144                 return RESULT_SHOWUSAGE;
 145         if (ast_load_resource(argv[1])) {
 146                 ast_cli(fd, "Unable to load module %s\n", argv[1]);
 147                 return RESULT_FAILURE;
 148         }
 149         return RESULT_SUCCESS;
 150 }
 151
 152 static int handle_load(int fd, int argc, char *argv[])
 153 {
 154         if (argc != 3)
 155                 return RESULT_SHOWUSAGE;
 156         if (ast_load_resource(argv[2])) {
 157                 ast_cli(fd, "Unable to load module %s\n", argv[2]);
 158                 return RESULT_FAILURE;
 159         }
 160         return RESULT_SUCCESS;
 161 }
 162
 163 static int handle_reload_deprecated(int fd, int argc, char *argv[])
 164 {
 165         int x;
 166         int res;
 167         if (argc < 1)
 168                 return RESULT_SHOWUSAGE;
 169         if (argc > 1) {
 170                 for (x = 1; x < argc; x++) {
 171                         res = ast_module_reload(argv[x]);
 172                         switch(res) {
 173                         case 0:
 174                                 ast_cli(fd, "No such module '%s'\n", argv[x]);
 175                                 break;
 176                         case 1:
 177                                 ast_cli(fd, "Module '%s' does not support reload\n", argv[x]);
 178                                 break;
 179                         }
 180                 }
 181         } else
 182                 ast_module_reload(NULL);
 183         return RESULT_SUCCESS;
 184 }
 185
 186 static int handle_reload(int fd, int argc, char *argv[])
 187 {
 188         int x;
 189         int res;
 190         if (argc < 2)
 191                 return RESULT_SHOWUSAGE;
 192         if (argc > 2) {
 193                 for (x = 2; x < argc; x++) {
 194                         res = ast_module_reload(argv[x]);
 195                         switch(res) {
 196                         case 0:
 197                                 ast_cli(fd, "No such module '%s'\n", argv[x]);
 198                                 break;
 199                         case 1:
 200                                 ast_cli(fd, "Module '%s' does not support reload\n", argv[x]);
 201                                 break;
 202                         }
 203                 }
 204         } else
 205                 ast_module_reload(NULL);
 206         return RESULT_SUCCESS;
 207 }
 208
 209 static int handle_set_verbose_deprecated(int fd, int argc, char *argv[])
 210 {
 211         int val = 0;
 212         int oldval = option_verbose;
 213
 214         /* "set verbose [atleast] N" */
 215         if (argc == 3)
 216                 option_verbose = atoi(argv[2]);
 217         else if (argc == 4) {
 218                 if (strcasecmp(argv[2], "atleast"))
 219                         return RESULT_SHOWUSAGE;
 220                 val = atoi(argv[3]);
 221                 if (val > option_verbose)
 222                         option_verbose = val;
 223         } else
 224                 return RESULT_SHOWUSAGE;
 225
 226         if (oldval != option_verbose && option_verbose > 0)
 227                 ast_cli(fd, "Verbosity was %d and is now %d\n", oldval, option_verbose);
 228         else if (oldval > 0 && option_verbose > 0)
 229                 ast_cli(fd, "Verbosity is at least %d\n", option_verbose);
 230         else if (oldval > 0 && option_verbose == 0)
 231                 ast_cli(fd, "Verbosity is now OFF\n");
 232
 233         return RESULT_SUCCESS;
 234 }
 235
 236 static int handle_verbose(int fd, int argc, char *argv[])
 237 {
 238         int oldval = option_verbose;
 239         int newlevel;
 240         int atleast = 0;
 241
 242         if ((argc < 4) || (argc > 5))
 243                 return RESULT_SHOWUSAGE;
 244
 245         if (!strcasecmp(argv[3], "atleast"))
 246                 atleast = 1;
 247
 248         if (!atleast) {
 249                 if (argc > 4)
 250                         return RESULT_SHOWUSAGE;
 251
 252                 option_verbose = atoi(argv[3]);
 253         } else {
 254                 if (argc < 5)
 255                         return RESULT_SHOWUSAGE;
 256
 257                 newlevel = atoi(argv[4]);
 258                 if (newlevel > option_verbose)
 259                         option_verbose = newlevel;
 260         }
 261         if (oldval > 0 && option_verbose == 0)
 262                 ast_cli(fd, "Verbosity is now OFF\n");
 263         else if (option_verbose > 0) {
 264                 if (oldval == option_verbose)
 265                         ast_cli(fd, "Verbosity is at least %d\n", option_verbose);
 266                 else
 267                         ast_cli(fd, "Verbosity was %d and is now %d\n", oldval, option_verbose);
 268         }
 269
 270         return RESULT_SUCCESS;
 271 }
 272
 273 static int handle_set_debug(int fd, int argc, char *argv[])
 274 {
 275         int oldval = option_debug;
 276         int newlevel;
 277         int atleast = 0;
 278         char *filename = '\0';
 279
 280         /* 'core set debug <level>'
 281          * 'core set debug <level> <fn>'
 282          * 'core set debug atleast <level>'
 283          * 'core set debug atleast <level> <fn>'
 284          */
 285         if ((argc < 4) || (argc > 6))
 286                 return RESULT_SHOWUSAGE;
 287
 288         if (!strcasecmp(argv[3], "atleast"))
 289                 atleast = 1;
 290
 291         if (!atleast) {
 292                 if (argc > 5)
 293                         return RESULT_SHOWUSAGE;
 294
 295                 if (sscanf(argv[3], "%d", &newlevel) != 1)
 296                         return RESULT_SHOWUSAGE;
 297
 298                 if (argc == 4) {
 299                         debug_filename[0] = '\0';
 300                 } else {
 301                         filename = argv[4];
 302                         ast_copy_string(debug_filename, filename, sizeof(debug_filename));
 303                 }
 304
 305                 option_debug = newlevel;
 306         } else {
 307                 if (argc < 5 || argc > 6)
 308                         return RESULT_SHOWUSAGE;
 309
 310                 if (sscanf(argv[4], "%d", &newlevel) != 1)
 311                         return RESULT_SHOWUSAGE;
 312
 313                 if (argc == 5) {
 314                         debug_filename[0] = '\0';
 315                 } else {
 316                         filename = argv[5];
 317                         ast_copy_string(debug_filename, filename, sizeof(debug_filename));
 318                 }
 319
 320                 if (newlevel > option_debug)
 321                         option_debug = newlevel;
 322         }
 323
 324         if (oldval > 0 && option_debug == 0)
 325                 ast_cli(fd, "Core debug is now OFF\n");
 326         else if (option_debug > 0) {
 327                 if (filename) {
 328                         if (oldval == option_debug)
 329                                 ast_cli(fd, "Core debug is at least %d, file '%s'\n", option_debug, filename);
 330                         else
 331                                 ast_cli(fd, "Core debug was %d and is now %d, file '%s'\n", oldval, option_debug, filename);
 332                 } else {
 333                         if (oldval == option_debug)
 334                                 ast_cli(fd, "Core debug is at least %d\n", option_debug);
 335                         else
 336                                 ast_cli(fd, "Core debug was %d and is now %d\n", oldval, option_debug);
 337                 }
 338         }
 339
 340         return RESULT_SUCCESS;
 341 }
 342
 343 static int handle_nodebug(int fd, int argc, char *argv[])
 344 {
 345         int oldval = option_debug;
 346         if (argc != 4)
 347                 return RESULT_SHOWUSAGE;
 348
 349         option_debug = 0;
 350         debug_filename[0] = '\0';
 351
 352         if (oldval > 0)
 353                 ast_cli(fd, "Core debug is now OFF\n");
 354         return RESULT_SUCCESS;
 355 }
 356
 357 static int handle_logger_mute(int fd, int argc, char *argv[])
 358 {
 359         if (argc != 2)
 360                 return RESULT_SHOWUSAGE;
 361         ast_console_toggle_mute(fd);
 362         return RESULT_SUCCESS;
 363 }
 364
 365 static int handle_unload_deprecated(int fd, int argc, char *argv[])
 366 {
 367         int x;
 368         int force = AST_FORCE_SOFT;
 369         if (argc < 2)
 370                 return RESULT_SHOWUSAGE;
 371         for (x = 1; x < argc; x++) {
 372                 if (argv[x][0] == '-') {
 373                         switch(argv[x][1]) {
 374                         case 'f':
 375                                 force = AST_FORCE_FIRM;
 376                                 break;
 377                         case 'h':
 378                                 force = AST_FORCE_HARD;
 379                                 break;
 380                         default:
 381                                 return RESULT_SHOWUSAGE;
 382                         }
 383                 } else if (x != argc - 1)
 384                         return RESULT_SHOWUSAGE;
 385                 else if (ast_unload_resource(argv[x], force)) {
 386                         ast_cli(fd, "Unable to unload resource %s\n", argv[x]);
 387                         return RESULT_FAILURE;
 388                 }
 389         }
 390         return RESULT_SUCCESS;
 391 }
 392
 393 static int handle_unload(int fd, int argc, char *argv[])
 394 {
 395         int x;
 396         int force = AST_FORCE_SOFT;
 397         if (argc < 3)
 398                 return RESULT_SHOWUSAGE;
 399         for (x = 2; x < argc; x++) {
 400                 if (argv[x][0] == '-') {
 401                         switch(argv[x][1]) {
 402                         case 'f':
 403                                 force = AST_FORCE_FIRM;
 404                                 break;
 405                         case 'h':
 406                                 force = AST_FORCE_HARD;
 407                                 break;
 408                         default:
 409                                 return RESULT_SHOWUSAGE;
 410                         }
 411                 } else if (x != argc - 1)
 412                         return RESULT_SHOWUSAGE;
 413                 else if (ast_unload_resource(argv[x], force)) {
 414                         ast_cli(fd, "Unable to unload resource %s\n", argv[x]);
 415                         return RESULT_FAILURE;
 416                 }
 417         }
 418         return RESULT_SUCCESS;
 419 }
 420
 421 #define MODLIST_FORMAT  "%-30s %-40.40s %-10d\n"
 422 #define MODLIST_FORMAT2 "%-30s %-40.40s %-10s\n"
 423
 424 AST_MUTEX_DEFINE_STATIC(climodentrylock);
 425 static int climodentryfd = -1;
 426
 427 static int modlist_modentry(const char *module, const char *description, int usecnt, const char *like)
 428 {
 429         /* Comparing the like with the module */
 430         if (strcasestr(module, like) ) {
 431                 ast_cli(climodentryfd, MODLIST_FORMAT, module, description, usecnt);
 432                 return 1;
 433         }
 434         return 0;
 435 }
 436
 437 static char modlist_help[] =
 438 "Usage: core show modules [like keyword]\n"
 439 "       Shows Asterisk modules currently in use, and usage statistics.\n";
 440
 441 static char uptime_help[] =
 442 "Usage: core show uptime [seconds]\n"
 443 "       Shows Asterisk uptime information.\n"
 444 "       The seconds word returns the uptime in seconds only.\n";
 445
 446 static void print_uptimestr(int fd, time_t timeval, const char *prefix, int printsec)
 447 {
 448         int x; /* the main part - years, weeks, etc. */
 449         char timestr[256]="", *s = timestr;
 450         size_t maxbytes = sizeof(timestr);
 451
 452 #define SECOND (1)
 453 #define MINUTE (SECOND*60)
 454 #define HOUR (MINUTE*60)
 455 #define DAY (HOUR*24)
 456 #define WEEK (DAY*7)
 457 #define YEAR (DAY*365)
 458 #define ESS(x) ((x == 1) ? "" : "s")    /* plural suffix */
 459 #define NEEDCOMMA(x) ((x)? ",": "")     /* define if we need a comma */
 460         if (timeval < 0)        /* invalid, nothing to show */
 461                 return;
 462         if (printsec)  {        /* plain seconds output */
 463                 ast_build_string(&s, &maxbytes, "%lu", (u_long)timeval);
 464                 timeval = 0; /* bypass the other cases */
 465         }
 466         if (timeval > YEAR) {
 467                 x = (timeval / YEAR);
 468                 timeval -= (x * YEAR);
 469                 ast_build_string(&s, &maxbytes, "%d year%s%s ", x, ESS(x),NEEDCOMMA(timeval));
 470         }
 471         if (timeval > WEEK) {
 472                 x = (timeval / WEEK);
 473                 timeval -= (x * WEEK);
 474                 ast_build_string(&s, &maxbytes, "%d week%s%s ", x, ESS(x),NEEDCOMMA(timeval));
 475         }
 476         if (timeval > DAY) {
 477                 x = (timeval / DAY);
 478                 timeval -= (x * DAY);
 479                 ast_build_string(&s, &maxbytes, "%d day%s%s ", x, ESS(x),NEEDCOMMA(timeval));
 480         }
 481         if (timeval > HOUR) {
 482                 x = (timeval / HOUR);
 483                 timeval -= (x * HOUR);
 484                 ast_build_string(&s, &maxbytes, "%d hour%s%s ", x, ESS(x),NEEDCOMMA(timeval));
 485         }
 486         if (timeval > MINUTE) {
 487                 x = (timeval / MINUTE);
 488                 timeval -= (x * MINUTE);
 489                 ast_build_string(&s, &maxbytes, "%d minute%s%s ", x, ESS(x),NEEDCOMMA(timeval));
 490         }
 491         x = timeval;
 492         if (x > 0)
 493                 ast_build_string(&s, &maxbytes, "%d second%s ", x, ESS(x));
 494         if (timestr[0] != '\0')
 495                 ast_cli(fd, "%s: %s\n", prefix, timestr);
 496 }
 497
 498 static int handle_showuptime(int fd, int argc, char *argv[])
 499 {
 500         /* 'show uptime [seconds]' */
 501         time_t curtime = time(NULL);
 502         int printsec = (argc == 4 && !strcasecmp(argv[3],"seconds"));
 503
 504         if (argc != 3 && !printsec)
 505                 return RESULT_SHOWUSAGE;
 506         if (ast_startuptime)
 507                 print_uptimestr(fd, curtime - ast_startuptime, "System uptime", printsec);
 508         if (ast_lastreloadtime)
 509                 print_uptimestr(fd, curtime - ast_lastreloadtime, "Last reload", printsec);
 510         return RESULT_SUCCESS;
 511 }
 512
 513 /* core show modules [like keyword] */
 514 static int handle_modlist(int fd, int argc, char *argv[])
 515 {
 516         char *like = "";
 517         if (argc != 3 && argc != 5)
 518                 return RESULT_SHOWUSAGE;
 519         else if (argc == 5) {
 520                 if (strcmp(argv[3],"like"))
 521                         return RESULT_SHOWUSAGE;
 522                 like = argv[4];
 523         }
 524
 525         ast_mutex_lock(&climodentrylock);
 526         climodentryfd = fd; /* global, protected by climodentrylock */
 527         ast_cli(fd, MODLIST_FORMAT2, "Module", "Description", "Use Count");
 528         ast_cli(fd,"%d modules loaded\n", ast_update_module_list(modlist_modentry, like));
 529         climodentryfd = -1;
 530         ast_mutex_unlock(&climodentrylock);
 531         return RESULT_SUCCESS;
 532 }
 533 #undef MODLIST_FORMAT
 534 #undef MODLIST_FORMAT2
 535
 536 /* core show channels [concise|verbose] */
 537 static int handle_chanlist(int fd, int argc, char *argv[])
 538 {
 539 #define FORMAT_STRING  "%-20.20s %-20.20s %-7.7s %-30.30s\n"
 540 #define FORMAT_STRING2 "%-20.20s %-20.20s %-7.7s %-30.30s\n"
 541 #define CONCISE_FORMAT_STRING  "%s!%s!%s!%d!%s!%s!%s!%s!%s!%d!%s!%s\n"
 542 #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"
 543 #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"
 544
 545         struct ast_channel *c = NULL;
 546         char durbuf[10] = "-";
 547         char locbuf[40];
 548         char appdata[40];
 549         int duration;
 550         int durh, durm, durs;
 551         int numchans = 0, concise = 0, verbose = 0;
 552
 553         concise = (argc == 4 && (!strcasecmp(argv[3],"concise")));
 554         verbose = (argc == 4 && (!strcasecmp(argv[3],"verbose")));
 555
 556         if (argc < 3 || argc > 4 || (argc == 4 && !concise && !verbose))
 557                 return RESULT_SHOWUSAGE;
 558
 559         if (!concise && !verbose)
 560                 ast_cli(fd, FORMAT_STRING2, "Channel", "Location", "State", "Application(Data)");
 561         else if (verbose)
 562                 ast_cli(fd, VERBOSE_FORMAT_STRING2, "Channel", "Context", "Extension", "Priority", "State", "Application", "Data",
 563                         "CallerID", "Duration", "Accountcode", "BridgedTo");
 564
 565         while ((c = ast_channel_walk_locked(c)) != NULL) {
 566                 struct ast_channel *bc = ast_bridged_channel(c);
 567                 if ((concise || verbose)  && c->cdr && !ast_tvzero(c->cdr->start)) {
 568                         duration = (int)(ast_tvdiff_ms(ast_tvnow(), c->cdr->start) / 1000);
 569                         if (verbose) {
 570                                 durh = duration / 3600;
 571                                 durm = (duration % 3600) / 60;
 572                                 durs = duration % 60;
 573                                 snprintf(durbuf, sizeof(durbuf), "%02d:%02d:%02d", durh, durm, durs);
 574                         } else {
 575                                 snprintf(durbuf, sizeof(durbuf), "%d", duration);
 576                         }
 577                 } else {
 578                         durbuf[0] = '\0';
 579                 }
 580                 if (concise) {
 581                         ast_cli(fd, CONCISE_FORMAT_STRING, c->name, c->context, c->exten, c->priority, ast_state2str(c->_state),
 582                                 c->appl ? c->appl : "(None)",
 583                                 S_OR(c->data, ""),      /* XXX different from verbose ? */
 584                                 S_OR(c->cid.cid_num, ""),
 585                                 S_OR(c->accountcode, ""),
 586                                 c->amaflags,
 587                                 durbuf,
 588                                 bc ? bc->name : "(None)");
 589                 } else if (verbose) {
 590                         ast_cli(fd, VERBOSE_FORMAT_STRING, c->name, c->context, c->exten, c->priority, ast_state2str(c->_state),
 591                                 c->appl ? c->appl : "(None)",
 592                                 c->data ? S_OR(c->data, "(Empty)" ): "(None)",
 593                                 S_OR(c->cid.cid_num, ""),
 594                                 durbuf,
 595                                 S_OR(c->accountcode, ""),
 596                                 bc ? bc->name : "(None)");
 597                 } else {
 598                         if (!ast_strlen_zero(c->context) && !ast_strlen_zero(c->exten))
 599                                 snprintf(locbuf, sizeof(locbuf), "%s@%s:%d", c->exten, c->context, c->priority);
 600                         else
 601                                 strcpy(locbuf, "(None)");
 602                         if (c->appl)
 603                                 snprintf(appdata, sizeof(appdata), "%s(%s)", c->appl, c->data ? c->data : "");
 604                         else
 605                                 strcpy(appdata, "(None)");
 606                         ast_cli(fd, FORMAT_STRING, c->name, locbuf, ast_state2str(c->_state), appdata);
 607                 }
 608                 numchans++;
 609                 ast_channel_unlock(c);
 610         }
 611         if (!concise) {
 612                 ast_cli(fd, "%d active channel%s\n", numchans, ESS(numchans));
 613                 if (option_maxcalls)
 614                         ast_cli(fd, "%d of %d max active call%s (%5.2f%% of capacity)\n",
 615                                 ast_active_calls(), option_maxcalls, ESS(ast_active_calls()),
 616                                 ((double)ast_active_calls() / (double)option_maxcalls) * 100.0);
 617                 else
 618                         ast_cli(fd, "%d active call%s\n", ast_active_calls(), ESS(ast_active_calls()));
 619         }
 620         return RESULT_SUCCESS;
 621
 622 #undef FORMAT_STRING
 623 #undef FORMAT_STRING2
 624 #undef CONCISE_FORMAT_STRING
 625 #undef VERBOSE_FORMAT_STRING
 626 #undef VERBOSE_FORMAT_STRING2
 627 }
 628
 629 static char showchan_help[] =
 630 "Usage: core show channel <channel>\n"
 631 "       Shows lots of information about the specified channel.\n";
 632
 633 static char debugchan_help[] =
 634 "Usage: core set debug channel <channel> [off]\n"
 635 "       Enables/disables debugging on a specific channel.\n";
 636
 637 static char commandcomplete_help[] =
 638 "Usage: _command complete \"<line>\" text state\n"
 639 "       This function is used internally to help with command completion and should.\n"
 640 "       never be called by the user directly.\n";
 641
 642 static char commandnummatches_help[] =
 643 "Usage: _command nummatches \"<line>\" text \n"
 644 "       This function is used internally to help with command completion and should.\n"
 645 "       never be called by the user directly.\n";
 646
 647 static char commandmatchesarray_help[] =
 648 "Usage: _command matchesarray \"<line>\" text \n"
 649 "       This function is used internally to help with command completion and should.\n"
 650 "       never be called by the user directly.\n";
 651
 652 static int handle_softhangup(int fd, int argc, char *argv[])
 653 {
 654         struct ast_channel *c=NULL;
 655         if (argc != 3)
 656                 return RESULT_SHOWUSAGE;
 657         c = ast_get_channel_by_name_locked(argv[2]);
 658         if (c) {
 659                 ast_cli(fd, "Requested Hangup on channel '%s'\n", c->name);
 660                 ast_softhangup(c, AST_SOFTHANGUP_EXPLICIT);
 661                 ast_channel_unlock(c);
 662         } else
 663                 ast_cli(fd, "%s is not a known channel\n", argv[2]);
 664         return RESULT_SUCCESS;
 665 }
 666
 667 static char *__ast_cli_generator(const char *text, const char *word, int state, int lock);
 668
 669 static int handle_commandmatchesarray(int fd, int argc, char *argv[])
 670 {
 671         char *buf, *obuf;
 672         int buflen = 2048;
 673         int len = 0;
 674         char **matches;
 675         int x, matchlen;
 676
 677         if (argc != 4)
 678                 return RESULT_SHOWUSAGE;
 679         if (!(buf = ast_malloc(buflen)))
 680                 return RESULT_FAILURE;
 681         buf[len] = '\0';
 682         matches = ast_cli_completion_matches(argv[2], argv[3]);
 683         if (matches) {
 684                 for (x=0; matches[x]; x++) {
 685                         matchlen = strlen(matches[x]) + 1;
 686                         if (len + matchlen >= buflen) {
 687                                 buflen += matchlen * 3;
 688                                 obuf = buf;
 689                                 if (!(buf = ast_realloc(obuf, buflen)))
 690                                         /* Memory allocation failure...  Just free old buffer and be done */
 691                                         free(obuf);
 692                         }
 693                         if (buf)
 694                                 len += sprintf( buf + len, "%s ", matches[x]);
 695                         free(matches[x]);
 696                         matches[x] = NULL;
 697                 }
 698                 free(matches);
 699         }
 700
 701         if (buf) {
 702                 ast_cli(fd, "%s%s",buf, AST_CLI_COMPLETE_EOF);
 703                 free(buf);
 704         } else
 705                 ast_cli(fd, "NULL\n");
 706
 707         return RESULT_SUCCESS;
 708 }
 709
 710
 711
 712 static int handle_commandnummatches(int fd, int argc, char *argv[])
 713 {
 714         int matches = 0;
 715
 716         if (argc != 4)
 717                 return RESULT_SHOWUSAGE;
 718
 719         matches = ast_cli_generatornummatches(argv[2], argv[3]);
 720
 721         ast_cli(fd, "%d", matches);
 722
 723         return RESULT_SUCCESS;
 724 }
 725
 726 static int handle_commandcomplete(int fd, int argc, char *argv[])
 727 {
 728         char *buf;
 729
 730         if (argc != 5)
 731                 return RESULT_SHOWUSAGE;
 732         buf = __ast_cli_generator(argv[2], argv[3], atoi(argv[4]), 0);
 733         if (buf) {
 734                 ast_cli(fd, buf);
 735                 free(buf);
 736         } else
 737                 ast_cli(fd, "NULL\n");
 738         return RESULT_SUCCESS;
 739 }
 740
 741 static int handle_debugchan_deprecated(int fd, int argc, char *argv[])
 742 {
 743         struct ast_channel *c=NULL;
 744         int is_all;
 745
 746         /* 'debug channel {all|chan_id}' */
 747         if (argc != 4)
 748                 return RESULT_SHOWUSAGE;
 749
 750         is_all = !strcasecmp("all", argv[3]);
 751         if (is_all) {
 752                 global_fin |= DEBUGCHAN_FLAG;
 753                 global_fout |= DEBUGCHAN_FLAG;
 754                 c = ast_channel_walk_locked(NULL);
 755         } else {
 756                 c = ast_get_channel_by_name_locked(argv[3]);
 757                 if (c == NULL)
 758                         ast_cli(fd, "No such channel %s\n", argv[3]);
 759         }
 760         while (c) {
 761                 if (!(c->fin & DEBUGCHAN_FLAG) || !(c->fout & DEBUGCHAN_FLAG)) {
 762                         c->fin |= DEBUGCHAN_FLAG;
 763                         c->fout |= DEBUGCHAN_FLAG;
 764                         ast_cli(fd, "Debugging enabled on channel %s\n", c->name);
 765                 }
 766                 ast_channel_unlock(c);
 767                 if (!is_all)
 768                         break;
 769                 c = ast_channel_walk_locked(c);
 770         }
 771         ast_cli(fd, "Debugging on new channels is enabled\n");
 772         return RESULT_SUCCESS;
 773 }
 774
 775 static int handle_core_set_debug_channel(int fd, int argc, char *argv[])
 776 {
 777         struct ast_channel *c = NULL;
 778         int is_all, is_off = 0;
 779
 780         /* 'core set debug channel {all|chan_id}' */
 781         if (argc == 6 && strcmp(argv[5], "off") == 0)
 782                 is_off = 1;
 783         else if (argc != 5)
 784                 return RESULT_SHOWUSAGE;
 785
 786         is_all = !strcasecmp("all", argv[4]);
 787         if (is_all) {
 788                 if (is_off) {
 789                         global_fin &= ~DEBUGCHAN_FLAG;
 790                         global_fout &= ~DEBUGCHAN_FLAG;
 791                 } else {
 792                         global_fin |= DEBUGCHAN_FLAG;
 793                         global_fout |= DEBUGCHAN_FLAG;
 794                 }
 795                 c = ast_channel_walk_locked(NULL);
 796         } else {
 797                 c = ast_get_channel_by_name_locked(argv[4]);
 798                 if (c == NULL)
 799                         ast_cli(fd, "No such channel %s\n", argv[4]);
 800         }
 801         while (c) {
 802                 if (!(c->fin & DEBUGCHAN_FLAG) || !(c->fout & DEBUGCHAN_FLAG)) {
 803                         if (is_off) {
 804                                 c->fin &= ~DEBUGCHAN_FLAG;
 805                                 c->fout &= ~DEBUGCHAN_FLAG;
 806                         } else {
 807                                 c->fin |= DEBUGCHAN_FLAG;
 808                                 c->fout |= DEBUGCHAN_FLAG;
 809                         }
 810                         ast_cli(fd, "Debugging %s on channel %s\n", is_off ? "disabled" : "enabled", c->name);
 811                 }
 812                 ast_channel_unlock(c);
 813                 if (!is_all)
 814                         break;
 815                 c = ast_channel_walk_locked(c);
 816         }
 817         ast_cli(fd, "Debugging on new channels is %s\n", is_off ? "disabled" : "enabled");
 818         return RESULT_SUCCESS;
 819 }
 820
 821 static int handle_nodebugchan_deprecated(int fd, int argc, char *argv[])
 822 {
 823         struct ast_channel *c=NULL;
 824         int is_all;
 825         /* 'no debug channel {all|chan_id}' */
 826         if (argc != 4)
 827                 return RESULT_SHOWUSAGE;
 828         is_all = !strcasecmp("all", argv[3]);
 829         if (is_all) {
 830                 global_fin &= ~DEBUGCHAN_FLAG;
 831                 global_fout &= ~DEBUGCHAN_FLAG;
 832                 c = ast_channel_walk_locked(NULL);
 833         } else {
 834                 c = ast_get_channel_by_name_locked(argv[3]);
 835                 if (c == NULL)
 836                         ast_cli(fd, "No such channel %s\n", argv[3]);
 837         }
 838         while(c) {
 839                 if ((c->fin & DEBUGCHAN_FLAG) || (c->fout & DEBUGCHAN_FLAG)) {
 840                         c->fin &= ~DEBUGCHAN_FLAG;
 841                         c->fout &= ~DEBUGCHAN_FLAG;
 842                         ast_cli(fd, "Debugging disabled on channel %s\n", c->name);
 843                 }
 844                 ast_channel_unlock(c);
 845                 if (!is_all)
 846                         break;
 847                 c = ast_channel_walk_locked(c);
 848         }
 849         ast_cli(fd, "Debugging on new channels is disabled\n");
 850         return RESULT_SUCCESS;
 851 }
 852
 853 static int handle_showchan(int fd, int argc, char *argv[])
 854 {
 855         struct ast_channel *c=NULL;
 856         struct timeval now;
 857         char buf[2048];
 858         char cdrtime[256];
 859         char nf[256], wf[256], rf[256];
 860         long elapsed_seconds=0;
 861         int hour=0, min=0, sec=0;
 862
 863         if (argc != 4)
 864                 return RESULT_SHOWUSAGE;
 865         now = ast_tvnow();
 866         c = ast_get_channel_by_name_locked(argv[3]);
 867         if (!c) {
 868                 ast_cli(fd, "%s is not a known channel\n", argv[3]);
 869                 return RESULT_SUCCESS;
 870         }
 871         if(c->cdr) {
 872                 elapsed_seconds = now.tv_sec - c->cdr->start.tv_sec;
 873                 hour = elapsed_seconds / 3600;
 874                 min = (elapsed_seconds % 3600) / 60;
 875                 sec = elapsed_seconds % 60;
 876                 snprintf(cdrtime, sizeof(cdrtime), "%dh%dm%ds", hour, min, sec);
 877         } else
 878                 strcpy(cdrtime, "N/A");
 879         ast_cli(fd,
 880                 " -- General --\n"
 881                 "           Name: %s\n"
 882                 "           Type: %s\n"
 883                 "       UniqueID: %s\n"
 884                 "      Caller ID: %s\n"
 885                 " Caller ID Name: %s\n"
 886                 "    DNID Digits: %s\n"
 887                 "          State: %s (%d)\n"
 888                 "          Rings: %d\n"
 889                 "  NativeFormats: %s\n"
 890                 "    WriteFormat: %s\n"
 891                 "     ReadFormat: %s\n"
 892                 " WriteTranscode: %s\n"
 893                 "  ReadTranscode: %s\n"
 894                 "1st File Descriptor: %d\n"
 895                 "      Frames in: %d%s\n"
 896                 "     Frames out: %d%s\n"
 897                 " Time to Hangup: %ld\n"
 898                 "   Elapsed Time: %s\n"
 899                 "  Direct Bridge: %s\n"
 900                 "Indirect Bridge: %s\n"
 901                 " --   PBX   --\n"
 902                 "        Context: %s\n"
 903                 "      Extension: %s\n"
 904                 "       Priority: %d\n"
 905                 "     Call Group: %llu\n"
 906                 "   Pickup Group: %llu\n"
 907                 "    Application: %s\n"
 908                 "           Data: %s\n"
 909                 "    Blocking in: %s\n",
 910                 c->name, c->tech->type, c->uniqueid,
 911                 S_OR(c->cid.cid_num, "(N/A)"),
 912                 S_OR(c->cid.cid_name, "(N/A)"),
 913                 S_OR(c->cid.cid_dnid, "(N/A)"), ast_state2str(c->_state), c->_state, c->rings,
 914                 ast_getformatname_multiple(nf, sizeof(nf), c->nativeformats),
 915                 ast_getformatname_multiple(wf, sizeof(wf), c->writeformat),
 916                 ast_getformatname_multiple(rf, sizeof(rf), c->readformat),
 917                 c->writetrans ? "Yes" : "No",
 918                 c->readtrans ? "Yes" : "No",
 919                 c->fds[0],
 920                 c->fin & ~DEBUGCHAN_FLAG, (c->fin & DEBUGCHAN_FLAG) ? " (DEBUGGED)" : "",
 921                 c->fout & ~DEBUGCHAN_FLAG, (c->fout & DEBUGCHAN_FLAG) ? " (DEBUGGED)" : "",
 922                 (long)c->whentohangup,
 923                 cdrtime, c->_bridge ? c->_bridge->name : "<none>", ast_bridged_channel(c) ? ast_bridged_channel(c)->name : "<none>",
 924                 c->context, c->exten, c->priority, c->callgroup, c->pickupgroup, ( c->appl ? c->appl : "(N/A)" ),
 925                 ( c-> data ? S_OR(c->data, "(Empty)") : "(None)"),
 926                 (ast_test_flag(c, AST_FLAG_BLOCKING) ? c->blockproc : "(Not Blocking)"));
 927
 928         if(pbx_builtin_serialize_variables(c,buf,sizeof(buf)))
 929                 ast_cli(fd,"      Variables:\n%s\n",buf);
 930         if(c->cdr && ast_cdr_serialize_variables(c->cdr,buf, sizeof(buf), '=', '\n', 1))
 931                 ast_cli(fd,"  CDR Variables:\n%s\n",buf);
 932
 933         ast_channel_unlock(c);
 934         return RESULT_SUCCESS;
 935 }
 936
 937 /*
 938  * helper function to generate CLI matches from a fixed set of values.
 939  * A NULL word is acceptable.
 940  */
 941 char *ast_cli_complete(const char *word, char *const choices[], int state)
 942 {
 943         int i, which = 0, len;
 944         len = ast_strlen_zero(word) ? 0 : strlen(word);
 945
 946         for (i = 0; choices[i]; i++) {
 947                 if ((!len || !strncasecmp(word, choices[i], len)) && ++which > state)
 948                         return ast_strdup(choices[i]);
 949         }
 950         return NULL;
 951 }
 952
 953 static char *complete_show_channels(const char *line, const char *word, int pos, int state)
 954 {
 955         static char *choices[] = { "concise", "verbose", NULL };
 956
 957         return (pos != 3) ? NULL : ast_cli_complete(word, choices, state);
 958 }
 959
 960 char *ast_complete_channels(const char *line, const char *word, int pos, int state, int rpos)
 961 {
 962         struct ast_channel *c = NULL;
 963         int which = 0;
 964         int wordlen;
 965         char notfound = '\0';
 966         char *ret = &notfound; /* so NULL can break the loop */
 967
 968         if (pos != rpos)
 969                 return NULL;
 970
 971         wordlen = strlen(word);
 972
 973         while (ret == &notfound && (c = ast_channel_walk_locked(c))) {
 974                 if (!strncasecmp(word, c->name, wordlen) && ++which > state)
 975                         ret = ast_strdup(c->name);
 976                 ast_channel_unlock(c);
 977         }
 978         return ret == &notfound ? NULL : ret;
 979 }
 980
 981 static char *complete_ch_3(const char *line, const char *word, int pos, int state)
 982 {
 983         return ast_complete_channels(line, word, pos, state, 2);
 984 }
 985
 986 static char *complete_ch_4(const char *line, const char *word, int pos, int state)
 987 {
 988         return ast_complete_channels(line, word, pos, state, 3);
 989 }
 990
 991 static char *complete_ch_5(const char *line, const char *word, int pos, int state)
 992 {
 993         return ast_complete_channels(line, word, pos, state, 4);
 994 }
 995
 996 static char *complete_mod_2(const char *line, const char *word, int pos, int state)
 997 {
 998         return ast_module_helper(line, word, pos, state, 1, 1);
 999 }
1000
1001 static char *complete_mod_3_nr(const char *line, const char *word, int pos, int state)
1002 {
1003         return ast_module_helper(line, word, pos, state, 2, 0);
1004 }
1005
1006 static char *complete_mod_3(const char *line, const char *word, int pos, int state)
1007 {
1008         return ast_module_helper(line, word, pos, state, 2, 1);
1009 }
1010
1011 static char *complete_mod_4(const char *line, const char *word, int pos, int state)
1012 {
1013         return ast_module_helper(line, word, pos, state, 3, 0);
1014 }
1015
1016 static char *complete_fn(const char *line, const char *word, int pos, int state)
1017 {
1018         char *c;
1019         char filename[256];
1020
1021         if (pos != 1)
1022                 return NULL;
1023
1024         if (word[0] == '/')
1025                 ast_copy_string(filename, word, sizeof(filename));
1026         else
1027                 snprintf(filename, sizeof(filename), "%s/%s", ast_config_AST_MODULE_DIR, word);
1028
1029         c = filename_completion_function(filename, state);
1030
1031         if (c && word[0] != '/')
1032                 c += (strlen(ast_config_AST_MODULE_DIR) + 1);
1033
1034         return c ? strdup(c) : c;
1035 }
1036
1037 static int group_show_channels(int fd, int argc, char *argv[])
1038 {
1039 #define FORMAT_STRING  "%-25s  %-20s  %-20s\n"
1040
1041         struct ast_channel *c = NULL;
1042         int numchans = 0;
1043         struct ast_var_t *current;
1044         struct varshead *headp;
1045         regex_t regexbuf;
1046         int havepattern = 0;
1047
1048         if (argc < 3 || argc > 4)
1049                 return RESULT_SHOWUSAGE;
1050
1051         if (argc == 4) {
1052                 if (regcomp(&regexbuf, argv[3], REG_EXTENDED | REG_NOSUB))
1053                         return RESULT_SHOWUSAGE;
1054                 havepattern = 1;
1055         }
1056
1057         ast_cli(fd, FORMAT_STRING, "Channel", "Group", "Category");
1058         while ( (c = ast_channel_walk_locked(c)) != NULL) {
1059                 headp=&c->varshead;
1060                 AST_LIST_TRAVERSE(headp,current,entries) {
1061                         if (!strncmp(ast_var_name(current), GROUP_CATEGORY_PREFIX "_", strlen(GROUP_CATEGORY_PREFIX) + 1)) {
1062                                 if (!havepattern || !regexec(&regexbuf, ast_var_value(current), 0, NULL, 0)) {
1063                                         ast_cli(fd, FORMAT_STRING, c->name, ast_var_value(current),
1064                                                 (ast_var_name(current) + strlen(GROUP_CATEGORY_PREFIX) + 1));
1065                                         numchans++;
1066                                 }
1067                         } else if (!strcmp(ast_var_name(current), GROUP_CATEGORY_PREFIX)) {
1068                                 if (!havepattern || !regexec(&regexbuf, ast_var_value(current), 0, NULL, 0)) {
1069                                         ast_cli(fd, FORMAT_STRING, c->name, ast_var_value(current), "(default)");
1070                                         numchans++;
1071                                 }
1072                         }
1073                 }
1074                 numchans++;
1075                 ast_channel_unlock(c);
1076         }
1077
1078         if (havepattern)
1079                 regfree(&regexbuf);
1080
1081         ast_cli(fd, "%d active channel%s\n", numchans, (numchans != 1) ? "s" : "");
1082         return RESULT_SUCCESS;
1083 #undef FORMAT_STRING
1084 }
1085
1086 static int handle_help(int fd, int argc, char *argv[]);
1087
1088 static char * complete_help(const char *text, const char *word, int pos, int state)
1089 {
1090         /* skip first 4 or 5 chars, "help "*/
1091         int l = strlen(text);
1092
1093         if (l > 5)
1094                 l = 5;
1095         text += l;
1096         /* XXX watch out, should stop to the non-generator parts */
1097         return __ast_cli_generator(text, word, state, 0);
1098 }
1099
1100 /* XXX Nothing in this array can currently be deprecated...
1101    You have to change the way find_cli works in order to remove this array
1102    I recommend doing this eventually...
1103  */
1104 static struct ast_cli_entry builtins[] = {
1105         /* Keep alphabetized, with longer matches first (example: abcd before abc) */
1106         { { "_command", "complete", NULL },
1107         handle_commandcomplete, "Command complete",
1108         commandcomplete_help },
1109
1110         { { "_command", "nummatches", NULL },
1111         handle_commandnummatches, "Returns number of command matches",
1112         commandnummatches_help },
1113
1114         { { "_command", "matchesarray", NULL },
1115         handle_commandmatchesarray, "Returns command matches array",
1116         commandmatchesarray_help },
1117
1118         { { NULL }, NULL, NULL, NULL }
1119 };
1120
1121 static struct ast_cli_entry cli_debug_channel_deprecated = {
1122         { "debug", "channel", NULL },
1123         handle_debugchan_deprecated, NULL,
1124         NULL, complete_ch_3 };
1125
1126 static struct ast_cli_entry cli_debug_level_deprecated = {
1127         { "debug", "level", NULL },
1128         handle_debuglevel_deprecated, NULL,
1129         NULL };
1130
1131 static struct ast_cli_entry cli_set_debug_deprecated = {
1132         { "set", "debug", NULL },
1133         handle_set_debug_deprecated, NULL,
1134         NULL, NULL, &cli_debug_level_deprecated };
1135
1136 static struct ast_cli_entry cli_set_verbose_deprecated = {
1137         { "set", "verbose", NULL },
1138         handle_set_verbose_deprecated, NULL,
1139         NULL };
1140
1141 static struct ast_cli_entry cli_show_channel_deprecated = {
1142         { "show", "channel", NULL },
1143         handle_showchan, NULL,
1144         NULL, complete_ch_3 };
1145
1146 static struct ast_cli_entry cli_show_channels_deprecated = {
1147         { "show", "channels", NULL },
1148         handle_chanlist, NULL,
1149         NULL, complete_show_channels };
1150
1151 static struct ast_cli_entry cli_show_modules_deprecated = {
1152         { "show", "modules", NULL },
1153         handle_modlist, NULL,
1154         NULL };
1155
1156 static struct ast_cli_entry cli_show_modules_like_deprecated = {
1157         { "show", "modules", "like", NULL },
1158         handle_modlist, NULL,
1159         NULL, complete_mod_4 };
1160
1161 static struct ast_cli_entry cli_module_load_deprecated = {
1162         { "load", NULL },
1163         handle_load_deprecated, NULL,
1164         NULL, complete_fn };
1165
1166 static struct ast_cli_entry cli_module_reload_deprecated = {
1167         { "reload", NULL },
1168         handle_reload_deprecated, NULL,
1169         NULL, complete_mod_2 };
1170
1171 static struct ast_cli_entry cli_module_unload_deprecated = {
1172         { "unload", NULL },
1173         handle_unload_deprecated, NULL,
1174         NULL, complete_mod_2 };
1175
1176 static struct ast_cli_entry cli_cli[] = {
1177         /* Deprecated, but preferred command is now consolidated (and already has a deprecated command for it). */
1178         { { "no", "debug", "channel", NULL },
1179         handle_nodebugchan_deprecated, NULL,
1180         NULL, complete_ch_4 },
1181
1182         { { "core", "show", "channels", NULL },
1183         handle_chanlist, "Display information on channels",
1184         chanlist_help, complete_show_channels },
1185
1186         { { "core", "show", "channel", NULL },
1187         handle_showchan, "Display information on a specific channel",
1188         showchan_help, complete_ch_4 },
1189
1190         { { "core", "set", "debug", "channel", NULL },
1191         handle_core_set_debug_channel, "Enable/disable debugging on a channel",
1192         debugchan_help, complete_ch_5, &cli_debug_channel_deprecated },
1193
1194         { { "core", "set", "debug", NULL },
1195         handle_set_debug, "Set level of debug chattiness",
1196         debug_help },
1197
1198         { { "core", "set", "debug", "off", NULL },
1199         handle_nodebug, "Turns off debug chattiness",
1200         nodebug_help },
1201
1202         { { "core", "set", "verbose", NULL },
1203         handle_verbose, "Set level of verboseness",
1204         verbose_help },
1205
1206         { { "group", "show", "channels", NULL },
1207         group_show_channels, "Display active channels with group(s)",
1208         group_show_channels_help },
1209
1210         { { "help", NULL },
1211         handle_help, "Display help list, or specific help on a command",
1212         help_help, complete_help },
1213
1214         { { "logger", "mute", NULL },
1215         handle_logger_mute, "Toggle logging output to a console",
1216         logger_mute_help },
1217
1218         { { "module", "show", NULL },
1219         handle_modlist, "List modules and info",
1220         modlist_help },
1221
1222         { { "module", "show", "like", NULL },
1223         handle_modlist, "List modules and info",
1224         modlist_help, complete_mod_4 },
1225
1226         { { "module", "load", NULL },
1227         handle_load, "Load a module by name",
1228         load_help, complete_fn, &cli_module_load_deprecated },
1229
1230         { { "module", "reload", NULL },
1231         handle_reload, "Reload configuration",
1232         reload_help, complete_mod_3, &cli_module_reload_deprecated },
1233
1234         { { "module", "unload", NULL },
1235         handle_unload, "Unload a module by name",
1236         unload_help, complete_mod_3_nr, &cli_module_unload_deprecated },
1237
1238         { { "core", "show", "uptime", NULL },
1239         handle_showuptime, "Show uptime information",
1240         uptime_help },
1241
1242         { { "soft", "hangup", NULL },
1243         handle_softhangup, "Request a hangup on a given channel",
1244         softhangup_help, complete_ch_3 },
1245 };
1246
1247 /*! \brief initialize the _full_cmd string in * each of the builtins. */
1248 void ast_builtins_init(void)
1249 {
1250         struct ast_cli_entry *e;
1251
1252         for (e = builtins; e->cmda[0] != NULL; e++) {
1253                 char buf[80];
1254                 ast_join(buf, sizeof(buf), e->cmda);
1255                 e->_full_cmd = strdup(buf);
1256                 if (!e->_full_cmd)
1257                         ast_log(LOG_WARNING, "-- cannot allocate <%s>\n", buf);
1258         }
1259
1260         ast_cli_register_multiple(cli_cli, sizeof(cli_cli) / sizeof(struct ast_cli_entry));
1261 }
1262
1263 /*
1264  * We have two sets of commands: builtins are stored in a
1265  * NULL-terminated array of ast_cli_entry, whereas external
1266  * commands are in a list.
1267  * When navigating, we need to keep two pointers and get
1268  * the next one in lexicographic order. For the purpose,
1269  * we use a structure.
1270  */
1271
1272 struct cli_iterator {
1273         struct ast_cli_entry *builtins;
1274         struct ast_cli_entry *helpers;
1275 };
1276
1277 static struct ast_cli_entry *cli_next(struct cli_iterator *i)
1278 {
1279         struct ast_cli_entry *e;
1280
1281         if (i->builtins == NULL && i->helpers == NULL) {
1282                 /* initialize */
1283                 i->builtins = builtins;
1284                 i->helpers = AST_LIST_FIRST(&helpers);
1285         }
1286         e = i->builtins; /* temporary */
1287         if (!e->cmda[0] || (i->helpers &&
1288                     strcmp(i->helpers->_full_cmd, e->_full_cmd) < 0)) {
1289                 /* Use helpers */
1290                 e = i->helpers;
1291                 if (e)
1292                         i->helpers = AST_LIST_NEXT(e, list);
1293         } else { /* use builtin. e is already set  */
1294                 (i->builtins)++;        /* move to next */
1295         }
1296         return e;
1297 }
1298
1299 /*!
1300  * \brief locate a cli command in the 'helpers' list (which must be locked).
1301  * exact has 3 values:
1302  *      0       returns if the search key is equal or longer than the entry.
1303  *      -1      true if the mismatch is on the last word XXX not true!
1304  *      1       true only on complete, exact match.
1305  */
1306 static struct ast_cli_entry *find_cli(char *const cmds[], int match_type)
1307 {
1308         int matchlen = -1;      /* length of longest match so far */
1309         struct ast_cli_entry *cand = NULL, *e=NULL;
1310         struct cli_iterator i = { NULL, NULL};
1311
1312         while( (e = cli_next(&i)) ) {
1313                 int y;
1314                 for (y = 0 ; cmds[y] && e->cmda[y]; y++) {
1315                         if (strcasecmp(e->cmda[y], cmds[y]))
1316                                 break;
1317                 }
1318                 if (e->cmda[y] == NULL) {       /* no more words in candidate */
1319                         if (cmds[y] == NULL)    /* this is an exact match, cannot do better */
1320                                 break;
1321                         /* here the search key is longer than the candidate */
1322                         if (match_type != 0)    /* but we look for almost exact match... */
1323                                 continue;       /* so we skip this one. */
1324                         /* otherwise we like it (case 0) */
1325                 } else {                        /* still words in candidate */
1326                         if (cmds[y] == NULL)    /* search key is shorter, not good */
1327                                 continue;
1328                         /* if we get here, both words exist but there is a mismatch */
1329                         if (match_type == 0)    /* not the one we look for */
1330                                 continue;
1331                         if (match_type == 1)    /* not the one we look for */
1332                                 continue;
1333                         if (cmds[y+1] != NULL || e->cmda[y+1] != NULL)  /* not the one we look for */
1334                                 continue;
1335                         /* we are in case match_type == -1 and mismatch on last word */
1336                 }
1337                 if (cand == NULL || y > matchlen)       /* remember the candidate */
1338                         cand = e;
1339         }
1340         return e ? e : cand;
1341 }
1342
1343 static char *find_best(char *argv[])
1344 {
1345         static char cmdline[80];
1346         int x;
1347         /* See how close we get, then print the candidate */
1348         char *myargv[AST_MAX_CMD_LEN];
1349         for (x=0;x<AST_MAX_CMD_LEN;x++)
1350                 myargv[x]=NULL;
1351         AST_LIST_LOCK(&helpers);
1352         for (x=0;argv[x];x++) {
1353                 myargv[x] = argv[x];
1354                 if (!find_cli(myargv, -1))
1355                         break;
1356         }
1357         AST_LIST_UNLOCK(&helpers);
1358         ast_join(cmdline, sizeof(cmdline), myargv);
1359         return cmdline;
1360 }
1361
1362 static int __ast_cli_unregister(struct ast_cli_entry *e, struct ast_cli_entry *ed)
1363 {
1364         if (e->deprecate_cmd) {
1365                 __ast_cli_unregister(e->deprecate_cmd, e);
1366         }
1367         if (e->inuse) {
1368                 ast_log(LOG_WARNING, "Can't remove command that is in use\n");
1369         } else {
1370                 AST_LIST_LOCK(&helpers);
1371                 AST_LIST_REMOVE(&helpers, e, list);
1372                 AST_LIST_UNLOCK(&helpers);
1373         }
1374         return 0;
1375 }
1376
1377 static int __ast_cli_register(struct ast_cli_entry *e, struct ast_cli_entry *ed)
1378 {
1379         struct ast_cli_entry *cur;
1380         char fulle[80] ="";
1381         int lf, ret = -1;
1382
1383         ast_join(fulle, sizeof(fulle), e->cmda);
1384         AST_LIST_LOCK(&helpers);
1385
1386         if (find_cli(e->cmda, 1)) {
1387                 AST_LIST_UNLOCK(&helpers);
1388                 ast_log(LOG_WARNING, "Command '%s' already registered (or something close enough)\n", fulle);
1389                 goto done;
1390         }
1391         e->_full_cmd = ast_strdup(fulle);
1392         if (!e->_full_cmd)
1393                 goto done;
1394
1395         if (ed) {
1396                 e->deprecated = 1;
1397                 e->summary = ed->summary;
1398                 e->usage = ed->usage;
1399                 /* XXX If command A deprecates command B, and command B deprecates command C...
1400                    Do we want to show command A or command B when telling the user to use new syntax?
1401                    This currently would show command A.
1402                    To show command B, you just need to always use ed->_full_cmd.
1403                  */
1404                 e->_deprecated_by = S_OR(ed->_deprecated_by, ed->_full_cmd);
1405         } else {
1406                 e->deprecated = 0;
1407         }
1408
1409         lf = strlen(fulle);
1410         AST_LIST_TRAVERSE_SAFE_BEGIN(&helpers, cur, list) {
1411                 int len = strlen(cur->_full_cmd);
1412                 if (lf < len)
1413                         len = lf;
1414                 if (strncasecmp(fulle, cur->_full_cmd, len) < 0) {
1415                         AST_LIST_INSERT_BEFORE_CURRENT(&helpers, e, list);
1416                         break;
1417                 }
1418         }
1419         AST_LIST_TRAVERSE_SAFE_END;
1420
1421         if (!cur)
1422                 AST_LIST_INSERT_TAIL(&helpers, e, list);
1423         ret = 0;        /* success */
1424
1425 done:
1426         AST_LIST_UNLOCK(&helpers);
1427
1428         if (e->deprecate_cmd) {
1429                 /* This command deprecates another command.  Register that one also. */
1430                 __ast_cli_register(e->deprecate_cmd, e);
1431         }
1432
1433         return ret;
1434 }
1435
1436 /* wrapper function, so we can unregister deprecated commands recursively */
1437 int ast_cli_unregister(struct ast_cli_entry *e)
1438 {
1439         return __ast_cli_unregister(e, NULL);
1440 }
1441
1442 /* wrapper function, so we can register deprecated commands recursively */
1443 int ast_cli_register(struct ast_cli_entry *e)
1444 {
1445         return __ast_cli_register(e, NULL);
1446 }
1447
1448 /*
1449  * register/unregister an array of entries.
1450  */
1451 void ast_cli_register_multiple(struct ast_cli_entry *e, int len)
1452 {
1453         int i;
1454
1455         for (i = 0; i < len; i++)
1456                 ast_cli_register(e + i);
1457 }
1458
1459 void ast_cli_unregister_multiple(struct ast_cli_entry *e, int len)
1460 {
1461         int i;
1462
1463         for (i = 0; i < len; i++)
1464                 ast_cli_unregister(e + i);
1465 }
1466
1467
1468 /*! \brief helper for help_workhorse and final part of
1469  * handle_help. if locked = 0 it's just help_workhorse,
1470  * otherwise assume the list is already locked and print
1471  * an error message if not found.
1472  */
1473 static int help1(int fd, char *match[], int locked)
1474 {
1475         char matchstr[80] = "";
1476         struct ast_cli_entry *e;
1477         int len = 0;
1478         int found = 0;
1479         struct cli_iterator i = { NULL, NULL};
1480
1481         if (match) {
1482                 ast_join(matchstr, sizeof(matchstr), match);
1483                 len = strlen(matchstr);
1484         }
1485         if (!locked)
1486                 AST_LIST_LOCK(&helpers);
1487         while ( (e = cli_next(&i)) ) {
1488                 /* Hide commands that start with '_' */
1489                 if (e->_full_cmd[0] == '_')
1490                         continue;
1491                 /* Hide commands that are marked as deprecated. */
1492                 if (e->deprecated)
1493                         continue;
1494                 if (match && strncasecmp(matchstr, e->_full_cmd, len))
1495                         continue;
1496                 ast_cli(fd, "%25.25s  %s\n", e->_full_cmd, e->summary);
1497                 found++;
1498         }
1499         AST_LIST_UNLOCK(&helpers);
1500         if (!locked && !found && matchstr[0])
1501                 ast_cli(fd, "No such command '%s'.\n", matchstr);
1502         return 0;
1503 }
1504
1505 static int help_workhorse(int fd, char *match[])
1506 {
1507         return help1(fd, match, 0 /* do not print errors */);
1508 }
1509
1510 static int handle_help(int fd, int argc, char *argv[])
1511 {
1512         char fullcmd[80];
1513         struct ast_cli_entry *e;
1514
1515         if (argc < 1)
1516                 return RESULT_SHOWUSAGE;
1517         if (argc == 1)
1518                 return help_workhorse(fd, NULL);
1519
1520         AST_LIST_LOCK(&helpers);
1521         e = find_cli(argv + 1, 1);      /* try exact match first */
1522         if (!e)
1523                 return help1(fd, argv + 1, 1 /* locked */);
1524         if (e->usage)
1525                 ast_cli(fd, "%s", e->usage);
1526         else {
1527                 ast_join(fullcmd, sizeof(fullcmd), argv+1);
1528                 ast_cli(fd, "No help text available for '%s'.\n", fullcmd);
1529         }
1530         AST_LIST_UNLOCK(&helpers);
1531         return RESULT_SUCCESS;
1532 }
1533
1534 static char *parse_args(const char *s, int *argc, char *argv[], int max, int *trailingwhitespace)
1535 {
1536         char *dup, *cur;
1537         int x = 0;
1538         int quoted = 0;
1539         int escaped = 0;
1540         int whitespace = 1;
1541
1542         *trailingwhitespace = 0;
1543         if (s == NULL)  /* invalid, though! */
1544                 return NULL;
1545         /* make a copy to store the parsed string */
1546         if (!(dup = ast_strdup(s)))
1547                 return NULL;
1548
1549         cur = dup;
1550         /* scan the original string copying into cur when needed */
1551         for (; *s ; s++) {
1552                 if (x >= max - 1) {
1553                         ast_log(LOG_WARNING, "Too many arguments, truncating at %s\n", s);
1554                         break;
1555                 }
1556                 if (*s == '"' && !escaped) {
1557                         quoted = !quoted;
1558                         if (quoted && whitespace) {
1559                                 /* start a quoted string from previous whitespace: new argument */
1560                                 argv[x++] = cur;
1561                                 whitespace = 0;
1562                         }
1563                 } else if ((*s == ' ' || *s == '\t') && !(quoted || escaped)) {
1564                         /* If we are not already in whitespace, and not in a quoted string or
1565                            processing an escape sequence, and just entered whitespace, then
1566                            finalize the previous argument and remember that we are in whitespace
1567                         */
1568                         if (!whitespace) {
1569                                 *cur++ = '\0';
1570                                 whitespace = 1;
1571                         }
1572                 } else if (*s == '\\' && !escaped) {
1573                         escaped = 1;
1574                 } else {
1575                         if (whitespace) {
1576                                 /* we leave whitespace, and are not quoted. So it's a new argument */
1577                                 argv[x++] = cur;
1578                                 whitespace = 0;
1579                         }
1580                         *cur++ = *s;
1581                         escaped = 0;
1582                 }
1583         }
1584         /* Null terminate */
1585         *cur++ = '\0';
1586         /* XXX put a NULL in the last argument, because some functions that take
1587          * the array may want a null-terminated array.
1588          * argc still reflects the number of non-NULL entries.
1589          */
1590         argv[x] = NULL;
1591         *argc = x;
1592         *trailingwhitespace = whitespace;
1593         return dup;
1594 }
1595
1596 /*! \brief Return the number of unique matches for the generator */
1597 int ast_cli_generatornummatches(const char *text, const char *word)
1598 {
1599         int matches = 0, i = 0;
1600         char *buf = NULL, *oldbuf = NULL;
1601
1602         while ((buf = ast_cli_generator(text, word, i++))) {
1603                 if (!oldbuf || strcmp(buf,oldbuf))
1604                         matches++;
1605                 if (oldbuf)
1606                         free(oldbuf);
1607                 oldbuf = buf;
1608         }
1609         if (oldbuf)
1610                 free(oldbuf);
1611         return matches;
1612 }
1613
1614 char **ast_cli_completion_matches(const char *text, const char *word)
1615 {
1616         char **match_list = NULL, *retstr, *prevstr;
1617         size_t match_list_len, max_equal, which, i;
1618         int matches = 0;
1619
1620         /* leave entry 0 free for the longest common substring */
1621         match_list_len = 1;
1622         while ((retstr = ast_cli_generator(text, word, matches)) != NULL) {
1623                 if (matches + 1 >= match_list_len) {
1624                         match_list_len <<= 1;
1625                         if (!(match_list = ast_realloc(match_list, match_list_len * sizeof(*match_list))))
1626                                 return NULL;
1627                 }
1628                 match_list[++matches] = retstr;
1629         }
1630
1631         if (!match_list)
1632                 return match_list; /* NULL */
1633
1634         /* Find the longest substring that is common to all results
1635          * (it is a candidate for completion), and store a copy in entry 0.
1636          */
1637         prevstr = match_list[1];
1638         max_equal = strlen(prevstr);
1639         for (which = 2; which <= matches; which++) {
1640                 for (i = 0; i < max_equal && toupper(prevstr[i]) == toupper(match_list[which][i]); i++)
1641                         continue;
1642                 max_equal = i;
1643         }
1644
1645         if (!(retstr = ast_malloc(max_equal + 1)))
1646                 return NULL;
1647
1648         ast_copy_string(retstr, match_list[1], max_equal + 1);
1649         match_list[0] = retstr;
1650
1651         /* ensure that the array is NULL terminated */
1652         if (matches + 1 >= match_list_len) {
1653                 if (!(match_list = ast_realloc(match_list, (match_list_len + 1) * sizeof(*match_list))))
1654                         return NULL;
1655         }
1656         match_list[matches + 1] = NULL;
1657
1658         return match_list;
1659 }
1660
1661 static char *__ast_cli_generator(const char *text, const char *word, int state, int lock)
1662 {
1663         char *argv[AST_MAX_ARGS];
1664         struct ast_cli_entry *e;
1665         struct cli_iterator i = { NULL, NULL };
1666         int x = 0, argindex, matchlen;
1667         int matchnum=0;
1668         char *ret = NULL;
1669         char matchstr[80] = "";
1670         int tws = 0;
1671         char *dup = parse_args(text, &x, argv, sizeof(argv) / sizeof(argv[0]), &tws);
1672
1673         if (!dup)       /* error */
1674                 return NULL;
1675         argindex = (!ast_strlen_zero(word) && x>0) ? x-1 : x;
1676         /* rebuild the command, ignore tws */
1677         ast_join(matchstr, sizeof(matchstr)-1, argv);
1678         matchlen = strlen(matchstr);
1679         if (tws) {
1680                 strcat(matchstr, " "); /* XXX */
1681                 if (matchlen)
1682                         matchlen++;
1683         }
1684         if (lock)
1685                 AST_LIST_LOCK(&helpers);
1686         while( !ret && (e = cli_next(&i)) ) {
1687                 int lc = strlen(e->_full_cmd);
1688                 if (e->_full_cmd[0] != '_' && lc > 0 && matchlen <= lc &&
1689                                 !strncasecmp(matchstr, e->_full_cmd, matchlen)) {
1690                         /* Found initial part, return a copy of the next word... */
1691                         if (e->cmda[argindex] && ++matchnum > state)
1692                                 ret = strdup(e->cmda[argindex]); /* we need a malloced string */
1693                 } else if (e->generator && !strncasecmp(matchstr, e->_full_cmd, lc) && matchstr[lc] < 33) {
1694                         /* We have a command in its entirity within us -- theoretically only one
1695                            command can have this occur */
1696                         ret = e->generator(matchstr, word, argindex, state);
1697                 }
1698         }
1699         if (lock)
1700                 AST_LIST_UNLOCK(&helpers);
1701         free(dup);
1702         return ret;
1703 }
1704
1705 char *ast_cli_generator(const char *text, const char *word, int state)
1706 {
1707         return __ast_cli_generator(text, word, state, 1);
1708 }
1709
1710 int ast_cli_command(int fd, const char *s)
1711 {
1712         char *argv[AST_MAX_ARGS];
1713         struct ast_cli_entry *e;
1714         int x;
1715         char *dup;
1716         int tws;
1717
1718         if (!(dup = parse_args(s, &x, argv, sizeof(argv) / sizeof(argv[0]), &tws)))
1719                 return -1;
1720
1721         /* We need at least one entry, or ignore */
1722         if (x > 0) {
1723                 AST_LIST_LOCK(&helpers);
1724                 e = find_cli(argv, 0);
1725                 if (e)
1726                         e->inuse++;
1727                 AST_LIST_UNLOCK(&helpers);
1728                 if (e) {
1729                         switch(e->handler(fd, x, argv)) {
1730                         case RESULT_SHOWUSAGE:
1731                                 if (e->usage)
1732                                         ast_cli(fd, "%s", e->usage);
1733                                 else
1734                                         ast_cli(fd, "Invalid usage, but no usage information available.\n");
1735                                 break;
1736                         default:
1737                                 AST_LIST_LOCK(&helpers);
1738                                 if (e->deprecated == 1) {
1739                                         ast_cli(fd, "The '%s' command is deprecated and will be removed in a future release. Please use '%s' instead.\n", e->_full_cmd, e->_deprecated_by);
1740                                         e->deprecated = 2;
1741                                 }
1742                                 AST_LIST_UNLOCK(&helpers);
1743                                 break;
1744                         }
1745                 } else
1746                         ast_cli(fd, "No such command '%s' (type 'help' for help)\n", find_best(argv));
1747                 if (e)
1748                         ast_atomic_fetchadd_int(&e->inuse, -1);
1749         }
1750         free(dup);
1751
1752         return 0;
1753 }