main/cli.c File Reference

Standard Command Line Interface. More...

#include "asterisk.h"
#include "asterisk/_private.h"
#include "asterisk/paths.h"
#include <signal.h>
#include <ctype.h>
#include <regex.h>
#include <pwd.h>
#include <grp.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 "asterisk/threadstorage.h"
#include "asterisk/logger_category.h"
#include "asterisk/translate.h"
#include "asterisk/bridge.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_bridges.h"
#include "asterisk/vector.h"
#include "asterisk/stream.h"

Include dependency graph for main/cli.c:

Go to the source code of this file.

Data Structures
struct	channel_set_debug_args
struct	cli_perm
	List of restrictions per user. More...
struct	cli_perm_head
struct	cli_perms
	List of users and permissions. More...
struct	helpers
struct	module_level
	map a debug or verbose level to a module name More...
struct	module_level_list
struct	usergroup_cli_perm
	list of users to apply restrictions. More...

Macros
#define	AST_CLI_INITLEN   256
#define	CONCISE_FORMAT_STRING   "%s!%s!%s!%d!%s!%s!%s!%s!%s!%s!%d!%s!%s!%s\n"
#define	DAY   (HOUR*24)
#define	DEBUG_HANDLER   0
#define	FORMAT_STRING   "%-20.20s %-20.20s %-7.7s %-30.30s\n"
#define	FORMAT_STRING   "%-25s %-20s %-20s\n"
#define	FORMAT_STRING2   "%-20.20s %-20.20s %-7.7s %-30.30s\n"
#define	HOUR   (MINUTE*60)
#define	MINUTE   (SECOND*60)
#define	MODLIST_FORMAT   "%-30s %-40.40s %-10d %-11s %13s\n"
#define	MODLIST_FORMAT2   "%-30s %-40.40s %-10s %-11s %13s\n"
#define	NEEDCOMMA(x)   ((x) ? ", " : "") /* define if we need a comma */
#define	SECOND   (1)
#define	TRACE_HANDLER   1
#define	VERBOSE_FORMAT_STRING   "%-20.20s %-20.20s %-16.16s %4d %-7.7s %-12.12s %-25.25s %-15.15s %8.8s %-11.11s %-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 %-11.11s %-20.20s\n"
#define	VERBOSE_HANDLER   2
#define	WEEK   (DAY*7)
#define	YEAR   (DAY*365)

Functions
static char *	__ast_cli_generator (const char *text, const char *word, int state, int lock)
int	__ast_cli_register (struct ast_cli_entry *e, struct ast_module *module)
int	__ast_cli_register_multiple (struct ast_cli_entry *e, int len, struct ast_module *module)
static void	__init_ast_cli_buf (void)
static int	allowed_on_shutdown (struct ast_cli_entry *e)
void	ast_builtins_init (void)
	initialize the _full_cmd string in * each of the builtins. More...
int	ast_cli_allow_at_shutdown (struct ast_cli_entry *e)
int	ast_cli_command_full (int uid, int gid, int fd, const char *s)
	Interprets a command Interpret a command s, sending output to fd if uid:gid has permissions to run this command. uid = CLI_NO_PERMS to avoid checking user permissions gid = CLI_NO_PERMS to avoid checking group permissions. More...
int	ast_cli_command_multiple_full (int uid, int gid, int fd, size_t size, const char *s)
	Executes multiple CLI commands Interpret strings separated by NULL and execute each one, sending output to fd if uid has permissions, uid = CLI_NO_PERMS to avoid checking users permissions. gid = CLI_NO_PERMS to avoid checking group permissions. More...
char *	ast_cli_complete (const char *word, const char *const choices[], int state)
int	ast_cli_completion_add (char *value)
	Add a result to a request for completion options. More...
char **	ast_cli_completion_matches (const char *text, const char *word)
	Generates a NULL-terminated array of strings that 1) begin with the string in the second parameter, and 2) are valid in a command after the string in the first parameter. More...
struct ast_vector_string *	ast_cli_completion_vector (const char *text, const char *word)
	Generates a vector of strings for CLI completion. More...
char *	ast_cli_generator (const char *text, const char *word, int state)
	Readline madness Useful for readline, that's about it. More...
int	ast_cli_perms_init (int reload)
void	ast_cli_print_timestr_fromseconds (int fd, int seconds, const char *prefix)
	Print on cli a duration in seconds in format s year(s), s week(s), s day(s), s hour(s), s second(s) More...
int	ast_cli_unregister (struct ast_cli_entry *e)
	Unregisters a command or an array of commands. More...
int	ast_cli_unregister_multiple (struct ast_cli_entry *e, int len)
	Unregister multiple commands. More...
char *	ast_complete_channels (const char *line, const char *word, int pos, int state, int rpos)
	Command completion for the list of active channels. More...
unsigned int	ast_debug_get_by_module (const char *module)
	Get the debug level for a module. More...
	AST_THREADSTORAGE_RAW (completion_storage)
unsigned int	ast_trace_get_by_module (const char *module)
	Get the trace level for a module. More...
static	AST_VECTOR (struct ast_cli_entry *)
static int	channel_set_debug (void *obj, void *arg, void *data, int flags)
static int	cli_completion_vector_add (struct ast_vector_string *vec, char *value)
static int	cli_has_permissions (int uid, int gid, const char *command)
static int	cli_is_registered (struct ast_cli_entry *e)
static struct ast_cli_entry *	cli_next (struct ast_cli_entry *e)
static void	cli_shutdown (void)
static char *	complete_number (const char *partial, unsigned int min, unsigned int max, int n)
static void	destroy_user_perms (void)
	cleanup (free) cli_perms linkedlist. More...
static char *	find_best (const char *argv[])
static struct ast_cli_entry *	find_cli (const char *const cmds[], int match_type)
static struct module_level *	find_module_level (const char *module, struct module_level_list *mll)
	Find the module level setting. More...
static char *	group_show_channels (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_chanlist (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_check_permissions (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	handles CLI command 'cli check permissions' More...
static char *	handle_cli_malloc_trim (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_reload_permissions (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	handles CLI command 'cli reload permissions' More...
static char *	handle_cli_show_permissions (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	handles CLI command 'cli show permissions' More...
static char *	handle_cli_wait_fullybooted (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_commandmatchesarray (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_core_reload (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_core_set_debug_channel (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_debug (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_debug_category (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_debug_or_trace (int handler, struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_help (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_load (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_logger_mute (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_modlist (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_nodebugchan_deprecated (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_reload (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_showcalls (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_showchan (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_showuptime (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_softhangup (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_trace (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_unload (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_verbose (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	help1 (int fd, const char *const match[], int locked)
	helper for final part of handle_help if locked = 1, assume the list is already locked More...
static char *	is_prefix (const char *word, const char *token, int pos, int *actual)
	if word is a valid prefix for token, returns the pos-th match as a malloced string, or NULL otherwise. Always tell in *actual how many matches we got. More...
static int	modlist_modentry (const char *module, const char *description, int usecnt, const char *status, const char *like, enum ast_module_support_level support_level)
static int	more_words (const char *const *dst)
	returns true if there are more words to match More...
static char *	parse_args (const char *s, int *argc, const char *argv[], int max, int *trailingwhitespace)
static void	print_uptimestr (int fd, struct timeval timeval, const char *prefix, int printsec)
static void	remove_shutdown_command (struct ast_cli_entry *e)
static int	set_full_cmd (struct ast_cli_entry *e)
static void	status_debug_verbose (struct ast_cli_args *a, int handler, int old_val, int cur_val)
static int	word_match (const char *cmd, const char *cli_word)

Variables
static struct ast_threadstorage	ast_cli_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_ast_cli_buf , .custom_init = NULL , }
static struct ast_cli_entry	cli_cli []
static int	cli_default_perm = 1
	Default permissions value 1=Permit 0=Deny. More...
static struct cli_perms	cli_perms = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
static const char	cli_rsvd [] = "[]{}|*%"
static int	climodentryfd = -1
static ast_mutex_t	climodentrylock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
static struct module_level_list	debug_modules = AST_RWLIST_HEAD_INIT_VALUE
static struct helpers	helpers = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
static const char	perms_config [] = "cli_permissions.conf"
	CLI permissions config file. More...
static ast_mutex_t	permsconfiglock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
	mutex used to prevent a user from running the 'cli reload permissions' command while it is already running. More...
static ast_rwlock_t	shutdown_commands_lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} }
static struct module_level_list	trace_modules = AST_RWLIST_HEAD_INIT_VALUE

Detailed Description

Standard Command Line Interface.

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Definition in file main/cli.c.

Macro Definition Documentation

AST_CLI_INITLEN

#define AST_CLI_INITLEN   256

Referenced by AST_VECTOR().

CONCISE_FORMAT_STRING

#define CONCISE_FORMAT_STRING   "%s!%s!%s!%d!%s!%s!%s!%s!%s!%s!%d!%s!%s!%s\n"

Referenced by handle_chanlist().

DAY

#define DAY   (HOUR*24)

Referenced by print_uptimestr().

DEBUG_HANDLER

#define DEBUG_HANDLER   0

Definition at line 403 of file main/cli.c.

Referenced by handle_debug(), handle_debug_or_trace(), and status_debug_verbose().

FORMAT_STRING [1/2]

#define FORMAT_STRING   "%-20.20s %-20.20s %-7.7s %-30.30s\n"

Referenced by group_show_channels(), and handle_chanlist().

FORMAT_STRING [2/2]

#define FORMAT_STRING   "%-25s %-20s %-20s\n"

FORMAT_STRING2

#define FORMAT_STRING2   "%-20.20s %-20.20s %-7.7s %-30.30s\n"

Referenced by handle_chanlist().

HOUR

#define HOUR   (MINUTE*60)

Referenced by print_uptimestr().

MINUTE

#define MINUTE   (SECOND*60)

Referenced by print_uptimestr().

MODLIST_FORMAT

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

Definition at line 857 of file main/cli.c.

Referenced by modlist_modentry().

MODLIST_FORMAT2

#define MODLIST_FORMAT2   "%-30s %-40.40s %-10s %-11s %13s\n"

Definition at line 858 of file main/cli.c.

Referenced by handle_modlist().

NEEDCOMMA

#define NEEDCOMMA

(

x

)

((x) ? ", " : "") /* define if we need a comma */

Referenced by print_uptimestr().

SECOND

#define SECOND   (1)

TRACE_HANDLER

#define TRACE_HANDLER   1

Definition at line 404 of file main/cli.c.

Referenced by handle_trace(), and status_debug_verbose().

VERBOSE_FORMAT_STRING

#define VERBOSE_FORMAT_STRING   "%-20.20s %-20.20s %-16.16s %4d %-7.7s %-12.12s %-25.25s %-15.15s %8.8s %-11.11s %-11.11s %-20.20s\n"

Referenced by handle_chanlist().

VERBOSE_FORMAT_STRING2

#define VERBOSE_FORMAT_STRING2   "%-20.20s %-20.20s %-16.16s %-4.4s %-7.7s %-12.12s %-25.25s %-15.15s %8.8s %-11.11s %-11.11s %-20.20s\n"

Referenced by handle_chanlist().

VERBOSE_HANDLER

#define VERBOSE_HANDLER   2

Definition at line 405 of file main/cli.c.

Referenced by handle_verbose(), and status_debug_verbose().

WEEK

#define WEEK   (DAY*7)

Referenced by print_uptimestr().

YEAR

#define YEAR   (DAY*365)

Referenced by print_uptimestr().

Function Documentation

__ast_cli_generator()

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

static

Definition at line 2829 of file main/cli.c.

References ast_cli_args::argv, ARRAY_LEN, ast_free, ast_join, AST_MAX_ARGS, ast_module_running_ref, ast_module_unref, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, ast_strlen_zero, CLI_GENERATE, cli_next(), ast_cli_entry::cmda, ast_cli_entry::command, ast_cli_entry::handler, is_prefix(), ast_cli_args::line, ast_cli_entry::module, more_words(), NULL, parse_args(), and word_match().

Referenced by ast_cli_generator(), handle_cli_check_permissions(), and handle_help().

{
   const char *argv[AST_MAX_ARGS];
   struct ast_cli_entry *e = NULL;
   int x = 0, argindex, matchlen;
   int matchnum=0;
   char *ret = NULL;
   char matchstr[80] = "";
   int tws = 0;
   /* Split the argument into an array of words */
   char *duplicate = parse_args(text, &x, argv, ARRAY_LEN(argv), &tws);

   if (!duplicate)   /* malloc error */
      return NULL;

   /* Compute the index of the last argument (could be an empty string) */
   argindex = (!ast_strlen_zero(word) && x>0) ? x-1 : x;

   /* rebuild the command, ignore terminating white space and flatten space */
   ast_join(matchstr, sizeof(matchstr)-1, argv);
   matchlen = strlen(matchstr);
   if (tws) {
      strcat(matchstr, " "); /* XXX */
      if (matchlen)
         matchlen++;
   }
   if (lock)
      AST_RWLIST_RDLOCK(&helpers);
   while ( (e = cli_next(e)) ) {
      /* XXX repeated code */
      int src = 0, dst = 0, n = 0;

      if (e->command[0] == '_')
         continue;

      /*
       * Try to match words, up to and excluding the last word, which
       * is either a blank or something that we want to extend.
       */
      for (;src < argindex; dst++, src += n) {
         n = word_match(argv[src], e->cmda[dst]);
         if (n < 0)
            break;
      }

      if (src != argindex && more_words(e->cmda + dst))  /* not a match */
         continue;
      ret = is_prefix(argv[src], e->cmda[dst], state - matchnum, &n);
      matchnum += n; /* this many matches here */
      if (ret) {
         /*
          * argv[src] is a valid prefix of the next word in this
          * command. If this is also the correct entry, return it.
          */
         if (matchnum > state)
            break;
         ast_free(ret);
         ret = NULL;
      } else if (ast_strlen_zero(e->cmda[dst])) {
         /*
          * This entry is a prefix of the command string entered
          * (only one entry in the list should have this property).
          * Run the generator if one is available. In any case we are done.
          */
         if (e->handler) { /* new style command */
            struct ast_cli_args a = {
               .line = matchstr, .word = word,
               .pos = argindex,
               .n = state - matchnum,
               .argv = argv,
               .argc = x};

            /* If the command is in a module it must be running. */
            if (!e->module || ast_module_running_ref(e->module)) {
               ret = e->handler(e, CLI_GENERATE, &a);
               ast_module_unref(e->module);
            }
         }
         if (ret)
            break;
      }
   }
   if (lock)
      AST_RWLIST_UNLOCK(&helpers);
   ast_free(duplicate);
   return ret;
}

__ast_cli_register()

int __ast_cli_register	(	struct ast_cli_entry *	e,
		struct ast_module *	module
	)

Definition at line 2420 of file main/cli.c.

References ast_cli_entry::_full_cmd, ast_free, ast_log, AST_MAX_CMD_LEN, AST_RWLIST_INSERT_BEFORE_CURRENT, AST_RWLIST_INSERT_TAIL, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_skip_blanks(), ast_skip_nonblanks(), ast_strdup, ast_strlen_zero, CLI_INIT, cli_is_registered(), ast_cli_entry::cmda, ast_cli_entry::cmdlen, ast_cli_entry::command, done, find_cli(), ast_cli_entry::handler, len(), cli_perm::list, LOG_WARNING, ast_cli_entry::module, NULL, S_OR, and set_full_cmd().

Referenced by __ast_cli_register_multiple().

{
   struct ast_cli_entry *cur;
   int i, lf, ret = -1;

   struct ast_cli_args a;  /* fake argument */
   char **dst = (char **)e->cmda;   /* need to cast as the entry is readonly */
   char *s;

   AST_RWLIST_WRLOCK(&helpers);

   if (cli_is_registered(e)) {
      ast_log(LOG_WARNING, "Command '%s' already registered (the same ast_cli_entry)\n",
         S_OR(e->_full_cmd, e->command));
      ret = 0;  /* report success */
      goto done;
   }

   memset(&a, '\0', sizeof(a));

   e->module = module;
   /* No module reference needed here, the module called us. */
   e->handler(e, CLI_INIT, &a);

   /* XXX check that usage and command are filled up */
   s = ast_skip_blanks(e->command);
   s = e->command = ast_strdup(s);
   for (i=0; !ast_strlen_zero(s) && i < AST_MAX_CMD_LEN-1; i++) {
      *dst++ = s; /* store string */
      s = ast_skip_nonblanks(s);
      if (*s == '\0')   /* we are done */
         break;
      *s++ = '\0';
      s = ast_skip_blanks(s);
   }
   *dst++ = NULL;

   if (find_cli(e->cmda, 1)) {
      ast_log(LOG_WARNING, "Command '%s' already registered (or something close enough)\n",
         S_OR(e->_full_cmd, e->command));
      goto done;
   }
   if (set_full_cmd(e)) {
      ast_log(LOG_WARNING, "Error registering CLI Command '%s'\n",
         S_OR(e->_full_cmd, e->command));
      goto done;
   }

   lf = e->cmdlen;
   AST_RWLIST_TRAVERSE_SAFE_BEGIN(&helpers, cur, list) {
      int len = cur->cmdlen;
      if (lf < len)
         len = lf;
      if (strncasecmp(e->_full_cmd, cur->_full_cmd, len) < 0) {
         AST_RWLIST_INSERT_BEFORE_CURRENT(e, list);
         break;
      }
   }
   AST_RWLIST_TRAVERSE_SAFE_END;

   if (!cur)
      AST_RWLIST_INSERT_TAIL(&helpers, e, list);
   ret = 0; /* success */

done:
   AST_RWLIST_UNLOCK(&helpers);
   if (ret) {
      ast_free(e->command);
      e->command = NULL;
   }

   return ret;
}

__ast_cli_register_multiple()

int __ast_cli_register_multiple	(	struct ast_cli_entry *	e,
		int	len,
		struct ast_module *	module
	)

Definition at line 2497 of file main/cli.c.

References __ast_cli_register(), and len().

{
   int i, res = 0;

   for (i = 0; i < len; i++) {
      res |= __ast_cli_register(e + i, module);
   }

   return res;
}

__init_ast_cli_buf()

static void __init_ast_cli_buf ( void  )

static

Definition at line 110 of file main/cli.c.

{

allowed_on_shutdown()

static int allowed_on_shutdown ( struct ast_cli_entry *  e )

static

Definition at line 2922 of file main/cli.c.

References ast_rwlock_rdlock, ast_rwlock_unlock, AST_VECTOR_GET, AST_VECTOR_SIZE, and shutdown_commands_lock.

Referenced by ast_cli_command_full().

{
   int found = 0;
   int i;

   ast_rwlock_rdlock(&shutdown_commands_lock);
   for (i = 0; i < AST_VECTOR_SIZE(&shutdown_commands); ++i) {
      if (e == AST_VECTOR_GET(&shutdown_commands, i)) {
         found = 1;
         break;
      }
   }
   ast_rwlock_unlock(&shutdown_commands_lock);

   return found;
}

ast_builtins_init()

void ast_builtins_init

(

void

)

initialize the _full_cmd string in * each of the builtins.

Provided by cli.c

Definition at line 2209 of file main/cli.c.

References ARRAY_LEN, ast_cli_register_multiple, ast_register_cleanup(), AST_VECTOR_INIT, and cli_shutdown().

Referenced by asterisk_daemon().

{
   AST_VECTOR_INIT(&shutdown_commands, 0);
   ast_cli_register_multiple(cli_cli, ARRAY_LEN(cli_cli));
   ast_register_cleanup(cli_shutdown);
}

ast_cli_allow_at_shutdown()

int ast_cli_allow_at_shutdown

(

struct ast_cli_entry *

e

)

Definition at line 3026 of file main/cli.c.

References ast_rwlock_unlock, ast_rwlock_wrlock, AST_VECTOR_APPEND, and shutdown_commands_lock.

Referenced by handle_abort_shutdown(), handle_restart_gracefully(), handle_restart_now(), handle_restart_when_convenient(), handle_show_locks(), handle_stop_gracefully(), handle_stop_now(), and handle_stop_when_convenient().

{
   int res;

   ast_rwlock_wrlock(&shutdown_commands_lock);
   res = AST_VECTOR_APPEND(&shutdown_commands, e);
   ast_rwlock_unlock(&shutdown_commands_lock);

   return res;
}

ast_cli_command_full()

int ast_cli_command_full	(	int	uid,
		int	gid,
		int	fd,
		const char *	s
	)

Interprets a command Interpret a command s, sending output to fd if uid:gid has permissions to run this command. uid = CLI_NO_PERMS to avoid checking user permissions gid = CLI_NO_PERMS to avoid checking group permissions.

Parameters

uid	User ID that is trying to run the command.
gid	Group ID that is trying to run the command.
fd	pipe
s	incoming string

Return values

0	on success
-1	on failure

Definition at line 2939 of file main/cli.c.

References allowed_on_shutdown(), args, ast_atomic_fetchadd_int(), ast_cli(), ast_free, ast_join, AST_MAX_ARGS, ast_module_running_ref, ast_module_unref, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, ast_shutting_down(), CLI_FAILURE, CLI_HANDLER, cli_has_permissions(), CLI_SHOWUSAGE, CLI_SUCCESS, done, ast_cli_args::fd, find_best(), find_cli(), ast_cli_entry::handler, ast_cli_entry::inuse, ast_cli_entry::module, NULL, parse_args(), RESULT_FAILURE, RESULT_SUCCESS, retval, S_OR, tmp(), and ast_cli_entry::usage.

Referenced by ast_cli_command_multiple_full().

{
   const char *args[AST_MAX_ARGS + 1];
   struct ast_cli_entry *e = NULL;
   int x;
   char *duplicate = parse_args(s, &x, args + 1, AST_MAX_ARGS, NULL);
   char tmp[AST_MAX_ARGS + 1];
   char *retval = CLI_FAILURE;
   struct ast_cli_args a = {
      .fd = fd, .argc = x, .argv = args+1 };

   if (duplicate == NULL)
      return RESULT_FAILURE;

   if (x < 1)  /* We need at least one entry, otherwise ignore */
      goto done;

   AST_RWLIST_RDLOCK(&helpers);
   e = find_cli(args + 1, 0);
   if (e)
      ast_atomic_fetchadd_int(&e->inuse, 1);
   AST_RWLIST_UNLOCK(&helpers);
   if (e == NULL) {
      ast_cli(fd, "No such command '%s' (type 'core show help %s' for other possible commands)\n", s, find_best(args + 1));
      goto done;
   }

   if (ast_shutting_down() && !allowed_on_shutdown(e)) {
      ast_cli(fd, "Command '%s' cannot be run during shutdown\n", s);
      goto done;
   }

   ast_join(tmp, sizeof(tmp), args + 1);
   /* Check if the user has rights to run this command. */
   if (!cli_has_permissions(uid, gid, tmp)) {
      ast_cli(fd, "You don't have permissions to run '%s' command\n", tmp);
      goto done;
   }

   /*
    * Within the handler, argv[-1] contains a pointer to the ast_cli_entry.
    * Remember that the array returned by parse_args is NULL-terminated.
    */
   args[0] = (char *)e;

   /* If the command is in a module it must be running. */
   if (!e->module || ast_module_running_ref(e->module)) {
      retval = e->handler(e, CLI_HANDLER, &a);
      ast_module_unref(e->module);
   }

   if (retval == CLI_SHOWUSAGE) {
      ast_cli(fd, "%s", S_OR(e->usage, "Invalid usage, but no usage information available.\n"));
   } else if (retval == CLI_FAILURE) {
      ast_cli(fd, "Command '%s' failed.\n", s);
   }

done:
   if (e) {
      ast_atomic_fetchadd_int(&e->inuse, -1);
   }
   ast_free(duplicate);
   return retval == CLI_SUCCESS ? RESULT_SUCCESS : RESULT_FAILURE;
}

ast_cli_command_multiple_full()

int ast_cli_command_multiple_full	(	int	uid,
		int	gid,
		int	fd,
		size_t	size,
		const char *	s
	)

Executes multiple CLI commands Interpret strings separated by NULL and execute each one, sending output to fd if uid has permissions, uid = CLI_NO_PERMS to avoid checking users permissions. gid = CLI_NO_PERMS to avoid checking group permissions.

Parameters

uid	User ID that is trying to run the command.
gid	Group ID that is trying to run the command.
fd	pipe
size	is the total size of the string
s	incoming string

Return values

number

of commands executed

Definition at line 3004 of file main/cli.c.

References ast_cli_command_full().

Referenced by netconsole().

{
   char cmd[512];
   int x, y = 0, count = 0;

   for (x = 0; x < size; x++) {
      cmd[y] = s[x];
      y++;
      if (s[x] == '\0') {
         ast_cli_command_full(uid, gid, fd, cmd);
         y = 0;
         count++;
      }
   }
   return count;
}

ast_cli_complete()

char* ast_cli_complete	(	const char *	word,
		const char *const	choices[],
		int	pos
	)

Helper function to generate cli entries from a NULL-terminated array. Returns the n-th matching entry from the array, or NULL if not found. Can be used to implement generate() for static entries as below (in this example we complete the word in position 2):

 char *my_generate(const char *line, const char *word, int pos, int n)
 {
     static const char * const choices[] = { "one", "two", "three", NULL };
if (pos == 2)
        return ast_cli_complete(word, choices, n);
else
  return NULL;
 }

Definition at line 1811 of file main/cli.c.

References ast_cli_completion_add(), ast_strdup, ast_strlen_zero, len(), and NULL.

Referenced by cli_odbc_read(), cli_odbc_write(), complete_skinny_reset(), complete_skinny_show_line(), handle_bridge_kick_channel(), handle_cli_core_show_translation(), handle_cli_devstate_change(), handle_cli_iax2_prune_realtime(), handle_cli_presencestate_change(), handle_cli_rtp_drop_incoming_packets(), handle_core_set_debug_channel(), handle_orig(), handle_showcalls(), handle_softhangup(), sip_prune_realtime(), sip_qualify_peer(), sip_show_peer(), sip_show_user(), sorcery_memory_cache_stale(), test_cli_execute_registered(), test_cli_generate_results(), test_cli_show_registered(), and test_cli_show_results().

{
   int i, which = 0, len;
   len = ast_strlen_zero(word) ? 0 : strlen(word);

   for (i = 0; choices[i]; i++) {
      if ((!len || !strncasecmp(word, choices[i], len)) && ++which > state) {
         if (state != -1) {
            return ast_strdup(choices[i]);
         }

         if (ast_cli_completion_add(ast_strdup(choices[i]))) {
            return NULL;
         }
      }
   }
   return NULL;
}

ast_cli_completion_add()

int ast_cli_completion_add

(

char *

value

)

Add a result to a request for completion options.

Parameters

value

A completion option text.

Return values

0	Success
-1	Failure

This is an alternative to returning individual values from CLI_GENERATE. Instead of repeatedly being asked for the next match and having to start over, you can call this function repeatedly from your own stateful loop. When all matches have been added you can return NULL from the CLI_GENERATE function.

Note

This function always eventually results in calling ast_free on value.

Definition at line 2726 of file main/cli.c.

References ast_threadstorage_get_ptr(), and cli_completion_vector_add().

Referenced by ao2_container_unregister(), ast_cli_complete(), ast_complete_applications(), ast_complete_channels(), category_complete(), cli_complete_endpoint(), cli_complete_show(), cli_complete_uri(), complete_bridge_live_search(), complete_bridge_participant(), complete_bridge_technology(), complete_channeltypes(), complete_config_module(), complete_config_option(), complete_config_type(), complete_core_id(), complete_country(), complete_indications(), complete_show_sorcery_object(), complete_test_category(), complete_test_name(), complete_trans_path_choice(), handle_cli_config_reload(), handle_cli_rtp_drop_incoming_packets(), handle_cli_sound_show(), handle_debug_category(), handle_manager_show_event(), handle_show_named_acl_cmd(), handle_showmanager(), handle_showmancmd(), module_load_helper_on_file(), stir_shaken_tab_complete_name(), topic_complete_name(), and tps_taskprocessor_tab_complete().

{
   return cli_completion_vector_add(ast_threadstorage_get_ptr(&completion_storage), value);
}

ast_cli_completion_matches()

char** ast_cli_completion_matches	(	const char *	,
		const char *
	)

Generates a NULL-terminated array of strings that 1) begin with the string in the second parameter, and 2) are valid in a command after the string in the first parameter.

The first entry (offset 0) of the result is the longest common substring in the results, useful to extend the string that has been completed. Subsequent entries are all possible values, followed by a NULL. All strings and the array itself are malloc'ed and must be freed by the caller.

Warning

This function cannot be called recursively so it will always fail if called from a CLI_GENERATE callback.

Definition at line 2670 of file main/cli.c.

References ast_cli_completion_vector(), ast_free, AST_THREADSTORAGE_RAW(), AST_VECTOR_APPEND, AST_VECTOR_CALLBACK_VOID, AST_VECTOR_PTR_FREE, AST_VECTOR_STEAL_ELEMENTS, and NULL.

Referenced by handle_commandmatchesarray().

{
   struct ast_vector_string *vec = ast_cli_completion_vector(text, word);
   char **match_list;

   if (!vec) {
      return NULL;
   }

   if (AST_VECTOR_APPEND(vec, NULL)) {
      /* We failed to NULL terminate the elements */
      AST_VECTOR_CALLBACK_VOID(vec, ast_free);
      AST_VECTOR_PTR_FREE(vec);

      return NULL;
   }

   match_list = AST_VECTOR_STEAL_ELEMENTS(vec);
   AST_VECTOR_PTR_FREE(vec);

   return match_list;
}

ast_cli_completion_vector()

struct ast_vector_string* ast_cli_completion_vector	(	const char *	text,
		const char *	word
	)

Generates a vector of strings for CLI completion.

Parameters

text	Complete input being matched.
word	Current word being matched

The results contain strings that both: 1) Begin with the string in word. 2) Are valid in a command after the string in text.

The first entry (offset 0) of the result is the longest common substring in the results, useful to extend the string that has been completed. Subsequent entries are all possible values.

Note

All strings and the vector itself are malloc'ed and must be freed by the caller.

The vector is sorted and does not contain any duplicates.

Warning

This function cannot be called recursively so it will always fail if called from a CLI_GENERATE callback.

Definition at line 2731 of file main/cli.c.

References ast_assert, ast_calloc, ast_cli_generator(), ast_free, ast_log, ast_strndup, ast_threadstorage_get_ptr(), ast_threadstorage_set_ptr(), AST_VECTOR_CALLBACK_VOID, AST_VECTOR_GET, AST_VECTOR_INSERT_AT, AST_VECTOR_PTR_FREE, AST_VECTOR_REMOVE, AST_VECTOR_SIZE, cli_completion_vector_add(), LOG_ERROR, and NULL.

Referenced by ast_cli_completion_matches(), AST_TEST_DEFINE(), and cli_complete().

{
   char *retstr, *prevstr;
   size_t max_equal;
   size_t which = 0;
   struct ast_vector_string *vec = ast_calloc(1, sizeof(*vec));

   /* Recursion into this function is a coding error. */
   ast_assert(!ast_threadstorage_get_ptr(&completion_storage));

   if (!vec) {
      return NULL;
   }

   if (ast_threadstorage_set_ptr(&completion_storage, vec)) {
      ast_log(LOG_ERROR, "Failed to initialize threadstorage for completion.\n");
      ast_free(vec);

      return NULL;
   }

   while ((retstr = ast_cli_generator(text, word, which)) != NULL) {
      if (cli_completion_vector_add(vec, retstr)) {
         ast_threadstorage_set_ptr(&completion_storage, NULL);

         goto vector_cleanup;
      }

      ++which;
   }

   ast_threadstorage_set_ptr(&completion_storage, NULL);

   if (!AST_VECTOR_SIZE(vec)) {
      AST_VECTOR_PTR_FREE(vec);

      return NULL;
   }

   prevstr = AST_VECTOR_GET(vec, 0);
   max_equal = strlen(prevstr);
   which = 1;

   /* Find the longest substring that is common to all results
    * (it is a candidate for completion), and store a copy in entry 0.
    */
   while (which < AST_VECTOR_SIZE(vec)) {
      size_t i = 0;

      retstr = AST_VECTOR_GET(vec, which);
      /* Check for and remove duplicate strings. */
      if (!strcasecmp(prevstr, retstr)) {
         AST_VECTOR_REMOVE(vec, which, 1);
         ast_free(retstr);

         continue;
      }

      while (i < max_equal && toupper(prevstr[i]) == toupper(retstr[i])) {
         i++;
      }

      max_equal = i;
      prevstr = retstr;
      ++which;
   }

   /* Insert longest match to position 0. */
   retstr = ast_strndup(AST_VECTOR_GET(vec, 0), max_equal);
   if (!retstr || AST_VECTOR_INSERT_AT(vec, 0, retstr)) {
      ast_free(retstr);

      goto vector_cleanup;
   }

   return vec;

vector_cleanup:
   AST_VECTOR_CALLBACK_VOID(vec, ast_free);
   AST_VECTOR_PTR_FREE(vec);

   return NULL;
}

ast_cli_generator()

char* ast_cli_generator	(	const char *	,
		const char *	,
		int
	)

Readline madness Useful for readline, that's about it.

Return values

0	on success
-1	on failure

Only call this function to proxy the CLI generator to another.

Definition at line 2917 of file main/cli.c.

References __ast_cli_generator().

Referenced by ast_cli_completion_vector(), cli_alias_passthrough(), and handle_cli_check_permissions().

{
   return __ast_cli_generator(text, word, state, 1);
}

ast_cli_perms_init()

int ast_cli_perms_init

(

int

reload

)

Provided by cli.c

Definition at line 2081 of file main/cli.c.

References ast_calloc, ast_category_browse(), ast_config_destroy(), ast_config_load2(), ast_free, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_log, ast_mutex_trylock, ast_mutex_unlock, AST_RWLIST_INSERT_TAIL, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_strdup, ast_strlen_zero, ast_variable_browse(), cli_default_perm, cli_perm::command, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEUNCHANGED, destroy_user_perms(), usergroup_cli_perm::gid, cli_perm::list, LOG_NOTICE, LOG_WARNING, ast_variable::name, ast_variable::next, NULL, cli_perm::permit, usergroup_cli_perm::perms, perms_config, permsconfiglock, usergroup_cli_perm::uid, and ast_variable::value.

Referenced by asterisk_daemon(), and handle_cli_reload_permissions().

{
   struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
   struct ast_config *cfg;
   char *cat = NULL;
   struct ast_variable *v;
   struct usergroup_cli_perm *user_group, *cp_entry;
   struct cli_perm *perm = NULL;
   struct passwd *pw;
   struct group *gr;

   if (ast_mutex_trylock(&permsconfiglock)) {
      ast_log(LOG_NOTICE, "You must wait until last 'cli reload permissions' command finish\n");
      return 1;
   }

   cfg = ast_config_load2(perms_config, "" /* core, can't reload */, config_flags);
   if (!cfg) {
      ast_mutex_unlock(&permsconfiglock);
      return 1;
   } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
      ast_mutex_unlock(&permsconfiglock);
      return 0;
   }

   /* free current structures. */
   destroy_user_perms();

   while ((cat = ast_category_browse(cfg, cat))) {
      if (!strcasecmp(cat, "general")) {
         /* General options */
         for (v = ast_variable_browse(cfg, cat); v; v = v->next) {
            if (!strcasecmp(v->name, "default_perm")) {
               cli_default_perm = (!strcasecmp(v->value, "permit")) ? 1: 0;
            }
         }
         continue;
      }

      /* users or groups */
      gr = NULL, pw = NULL;
      if (cat[0] == '@') {
         /* This is a group */
         gr = getgrnam(&cat[1]);
         if (!gr) {
            ast_log (LOG_WARNING, "Unknown group '%s'\n", &cat[1]);
            continue;
         }
      } else {
         /* This is a user */
         pw = getpwnam(cat);
         if (!pw) {
            ast_log (LOG_WARNING, "Unknown user '%s'\n", cat);
            continue;
         }
      }
      user_group = NULL;
      /* Check for duplicates */
      AST_RWLIST_WRLOCK(&cli_perms);
      AST_LIST_TRAVERSE(&cli_perms, cp_entry, list) {
         if ((pw && cp_entry->uid == pw->pw_uid) || (gr && cp_entry->gid == gr->gr_gid)) {
            /* if it is duplicated, just added this new settings, to
            the current list. */
            user_group = cp_entry;
            break;
         }
      }
      AST_RWLIST_UNLOCK(&cli_perms);

      if (!user_group) {
         /* alloc space for the new user config. */
         user_group = ast_calloc(1, sizeof(*user_group));
         if (!user_group) {
            continue;
         }
         user_group->uid = (pw ? pw->pw_uid : -1);
         user_group->gid = (gr ? gr->gr_gid : -1);
         user_group->perms = ast_calloc(1, sizeof(*user_group->perms));
         if (!user_group->perms) {
            ast_free(user_group);
            continue;
         }
      }
      for (v = ast_variable_browse(cfg, cat); v; v = v->next) {
         if (ast_strlen_zero(v->value)) {
            /* we need to check this condition cause it could break security. */
            ast_log(LOG_WARNING, "Empty permit/deny option in user '%s'\n", cat);
            continue;
         }
         if (!strcasecmp(v->name, "permit")) {
            perm = ast_calloc(1, sizeof(*perm));
            if (perm) {
               perm->permit = 1;
               perm->command = ast_strdup(v->value);
            }
         } else if (!strcasecmp(v->name, "deny")) {
            perm = ast_calloc(1, sizeof(*perm));
            if (perm) {
               perm->permit = 0;
               perm->command = ast_strdup(v->value);
            }
         } else {
            /* up to now, only 'permit' and 'deny' are possible values. */
            ast_log(LOG_WARNING, "Unknown '%s' option\n", v->name);
            continue;
         }
         if (perm) {
            /* Added the permission to the user's list. */
            AST_LIST_INSERT_TAIL(user_group->perms, perm, list);
            perm = NULL;
         }
      }
      AST_RWLIST_WRLOCK(&cli_perms);
      AST_RWLIST_INSERT_TAIL(&cli_perms, user_group, list);
      AST_RWLIST_UNLOCK(&cli_perms);
   }

   ast_config_destroy(cfg);
   ast_mutex_unlock(&permsconfiglock);
   return 0;
}

ast_cli_print_timestr_fromseconds()

void ast_cli_print_timestr_fromseconds	(	int	fd,
		int	seconds,
		const char *	prefix
	)

Print on cli a duration in seconds in format s year(s), s week(s), s day(s), s hour(s), s second(s)

Since

13.8

Parameters

ast_cli_args	fd to print by ast_cli
duration	The time (in seconds) to print
prefix	A Prefix string to add before of duration formatted

Definition at line 3021 of file main/cli.c.

References ast_tv(), and print_uptimestr().

Referenced by handle_cdr_pgsql_status(), handle_cli_cdr_mysql_status(), handle_cli_realtime_pgsql_status(), and realtime_ldap_status().

{
   print_uptimestr(fd, ast_tv(seconds, 0), prefix, 0);
}

ast_cli_unregister()

int ast_cli_unregister

(

struct ast_cli_entry *

e

)

Unregisters a command or an array of commands.

Parameters

e	which cli entry to unregister Unregister your own command. You must pass a completed ast_cli_entry structure

Returns

0

Definition at line 2397 of file main/cli.c.

References ast_cli_entry::_full_cmd, ast_free, ast_log, AST_RWLIST_REMOVE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_cli_entry::cmda, ast_cli_entry::command, ast_cli_entry::handler, ast_cli_entry::inuse, cli_perm::list, LOG_WARNING, NULL, remove_shutdown_command(), and ast_cli_entry::usage.

Referenced by aco_deinit(), alias_unregister_cb(), ast_cli_unregister_multiple(), unload_module(), and xmldoc_unload_documentation().

{
   if (e->inuse) {
      ast_log(LOG_WARNING, "Can't remove command that is in use\n");
   } else {
      AST_RWLIST_WRLOCK(&helpers);
      AST_RWLIST_REMOVE(&helpers, e, list);
      AST_RWLIST_UNLOCK(&helpers);
      remove_shutdown_command(e);
      ast_free(e->_full_cmd);
      e->_full_cmd = NULL;
      if (e->handler) {
         /* this is a new-style entry. Reset fields and free memory. */
         char *cmda = (char *) e->cmda;
         memset(cmda, '\0', sizeof(e->cmda));
         ast_free(e->command);
         e->command = NULL;
         e->usage = NULL;
      }
   }
   return 0;
}

ast_cli_unregister_multiple()

int ast_cli_unregister_multiple	(	struct ast_cli_entry *	e,
		int	len
	)

Unregister multiple commands.

Parameters

e	pointer to first cli entry to unregister
len	number of entries to unregister

Definition at line 2508 of file main/cli.c.

References ast_cli_unregister(), and len().

Referenced by cli_shutdown().

{
   int i, res = 0;

   for (i = 0; i < len; i++)
      res |= ast_cli_unregister(e + i);

   return res;
}

ast_complete_channels()

char* ast_complete_channels	(	const char *	line,
		const char *	word,
		int	pos,
		int	state,
		int	rpos
	)

Command completion for the list of active channels.

This can be called from a CLI command completion function that wants to complete from the list of active channels. 'rpos' is the required position in the command. This function will return NULL immediately if 'rpos' is not the same as the current position, 'pos'.

Definition at line 1830 of file main/cli.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_channel_cache_all(), ast_cli_completion_add(), ast_strdup, ast_channel_snapshot::base, ast_channel_snapshot_base::name, NULL, and state.

Referenced by complete_ch(), handle_cli_agi_add_cmd(), handle_cli_mixmonitor(), handle_core_set_debug_channel(), handle_redirect(), handle_remb_set(), handle_set_chanvar(), handle_show_chanvar(), handle_show_hangup_channel(), handle_showchan(), and handle_softhangup().

{
   int wordlen = strlen(word), which = 0;
   struct ao2_container *cached_channels;
   char *ret = NULL;
   struct ao2_iterator iter;
   struct ast_channel_snapshot *snapshot;

   if (pos != rpos) {
      return NULL;
   }

   cached_channels = ast_channel_cache_all();

   iter = ao2_iterator_init(cached_channels, 0);
   for (; (snapshot = ao2_iterator_next(&iter)); ao2_ref(snapshot, -1)) {
      if (!strncasecmp(word, snapshot->base->name, wordlen) && (++which > state)) {
         if (state != -1) {
            ret = ast_strdup(snapshot->base->name);
            ao2_ref(snapshot, -1);
            break;
         }

         if (ast_cli_completion_add(ast_strdup(snapshot->base->name))) {
            ao2_ref(snapshot, -1);
            break;
         }
      }
   }
   ao2_iterator_destroy(&iter);
   ao2_ref(cached_channels, -1);

   return ret;
}

ast_debug_get_by_module()

unsigned int ast_debug_get_by_module

(

const char *

module

)

Get the debug level for a module.

Parameters

module

the name of module

Returns

the debug level

Definition at line 136 of file main/cli.c.

References AST_LIST_TRAVERSE, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, and module_level::level.

{
   struct module_level *ml;
   unsigned int res = 0;

   AST_RWLIST_RDLOCK(&debug_modules);
   AST_LIST_TRAVERSE(&debug_modules, ml, entry) {
      if (!strcasecmp(ml->module, module)) {
         res = ml->level;
         break;
      }
   }
   AST_RWLIST_UNLOCK(&debug_modules);

   return res;
}

AST_THREADSTORAGE_RAW()

AST_THREADSTORAGE_RAW

(

completion_storage

)

Referenced by ast_cli_completion_matches().

ast_trace_get_by_module()

unsigned int ast_trace_get_by_module

(

const char *

module

)

Get the trace level for a module.

Parameters

module

the name of module

Returns

the trace level

Definition at line 153 of file main/cli.c.

References AST_LIST_TRAVERSE, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, and module_level::level.

{
   struct module_level *ml;
   unsigned int res = 0;

   AST_RWLIST_RDLOCK(&trace_modules);
   AST_LIST_TRAVERSE(&trace_modules, ml, entry) {
      if (!strcasecmp(ml->module, module)) {
         res = ml->level;
         break;
      }
   }
   AST_RWLIST_UNLOCK(&trace_modules);

   return res;
}

AST_VECTOR()

static AST_VECTOR ( struct ast_cli_entry *  )

static

Definition at line 113 of file main/cli.c.

References ast_carefulwrite(), ast_cli_buf, AST_CLI_INITLEN, AST_DYNSTR_BUILD_FAILED, ast_str_buffer(), ast_str_set_va(), ast_str_strlen(), ast_str_thread_get(), and buf.

{
   int res;
   struct ast_str *buf;
   va_list ap;

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

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

   if (res != AST_DYNSTR_BUILD_FAILED) {
      ast_carefulwrite(fd, ast_str_buffer(buf), ast_str_strlen(buf), 100);
   }
}

channel_set_debug()

static int channel_set_debug ( void *  obj, void *  arg, void *  data, int  flags  )

static

Definition at line 1452 of file main/cli.c.

References args, ast_channel_fin(), ast_channel_fin_set(), ast_channel_fout(), ast_channel_fout_set(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_cli(), DEBUGCHAN_FLAG, channel_set_debug_args::fd, and channel_set_debug_args::is_off.

Referenced by handle_core_set_debug_channel().

{
   struct ast_channel *chan = obj;
   struct channel_set_debug_args *args = data;

   ast_channel_lock(chan);

   if (!(ast_channel_fin(chan) & DEBUGCHAN_FLAG) || !(ast_channel_fout(chan) & DEBUGCHAN_FLAG)) {
      if (args->is_off) {
         ast_channel_fin_set(chan, ast_channel_fin(chan) & ~DEBUGCHAN_FLAG);
         ast_channel_fout_set(chan, ast_channel_fout(chan) & ~DEBUGCHAN_FLAG);
      } else {
         ast_channel_fin_set(chan, ast_channel_fin(chan) | DEBUGCHAN_FLAG);
         ast_channel_fout_set(chan, ast_channel_fout(chan) | DEBUGCHAN_FLAG);
      }
      ast_cli(args->fd, "Debugging %s on channel %s\n", args->is_off ? "disabled" : "enabled",
            ast_channel_name(chan));
   }

   ast_channel_unlock(chan);

   return 0;
}

cli_completion_vector_add()

static int cli_completion_vector_add ( struct ast_vector_string *  vec, char *  value  )

static

Definition at line 2705 of file main/cli.c.

References ast_free, ast_threadstorage_set_ptr(), AST_VECTOR_ADD_SORTED, AST_VECTOR_CALLBACK_VOID, AST_VECTOR_FREE, and NULL.

Referenced by ast_cli_completion_add(), and ast_cli_completion_vector().

{
   if (!value) {
      return 0;
   }

   if (!vec || AST_VECTOR_ADD_SORTED(vec, value, strcasecmp)) {
      if (vec) {
         ast_threadstorage_set_ptr(&completion_storage, NULL);

         AST_VECTOR_CALLBACK_VOID(vec, ast_free);
         AST_VECTOR_FREE(vec);
      }
      ast_free(value);

      return -1;
   }

   return 0;
}

cli_has_permissions()

static int cli_has_permissions ( int  uid, int  gid, const char *  command  )

static

Definition at line 183 of file main/cli.c.

References AST_LIST_TRAVERSE, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, cli_default_perm, CLI_NO_PERMS, cli_perm::command, usergroup_cli_perm::gid, cli_perm::list, NULL, cli_perm::permit, usergroup_cli_perm::perms, and usergroup_cli_perm::uid.

Referenced by ast_cli_command_full(), and handle_cli_check_permissions().

{
   struct usergroup_cli_perm *user_perm;
   struct cli_perm *perm;
   /* set to the default permissions general option. */
   int isallowg = cli_default_perm, isallowu = -1, ispattern;
   regex_t regexbuf;

   /* if uid == -1 or gid == -1 do not check permissions.
      if uid == -2 and gid == -2 is because rasterisk client didn't send
      the credentials, so the cli_default_perm will be applied. */
   if ((uid == CLI_NO_PERMS && gid == CLI_NO_PERMS) || command[0] == '_') {
      return 1;
   }

   if (gid < 0 && uid < 0) {
      return cli_default_perm;
   }

   AST_RWLIST_RDLOCK(&cli_perms);
   AST_LIST_TRAVERSE(&cli_perms, user_perm, list) {
      if (user_perm->gid != gid && user_perm->uid != uid) {
         continue;
      }
      AST_LIST_TRAVERSE(user_perm->perms, perm, list) {
         if (strcasecmp(perm->command, "all") && strncasecmp(perm->command, command, strlen(perm->command))) {
            /* if the perm->command is a pattern, check it against command. */
            ispattern = !regcomp(&regexbuf, perm->command, REG_EXTENDED | REG_NOSUB | REG_ICASE);
            if (ispattern && regexec(&regexbuf, command, 0, NULL, 0)) {
               regfree(&regexbuf);
               continue;
            }
            if (!ispattern) {
               continue;
            }
            regfree(&regexbuf);
         }
         if (user_perm->uid == uid) {
            /* this is a user definition. */
            isallowu = perm->permit;
         } else {
            /* otherwise is a group definition. */
            isallowg = perm->permit;
         }
      }
   }
   AST_RWLIST_UNLOCK(&cli_perms);
   if (isallowu > -1) {
      /* user definition override group definition. */
      isallowg = isallowu;
   }

   return isallowg;
}

cli_is_registered()

static int cli_is_registered ( struct ast_cli_entry *  e )

static

Definition at line 2378 of file main/cli.c.

References cli_next(), and NULL.

Referenced by __ast_cli_register().

{
   struct ast_cli_entry *cur = NULL;

   while ((cur = cli_next(cur))) {
      if (cur == e) {
         return 1;
      }
   }
   return 0;
}

cli_next()

static struct ast_cli_entry* cli_next ( struct ast_cli_entry *  e )

static

Definition at line 929 of file main/cli.c.

References AST_LIST_FIRST, AST_LIST_NEXT, and cli_perm::list.

Referenced by __ast_cli_generator(), cli_is_registered(), find_cli(), handle_cli_check_permissions(), and help1().

{
   if (e) {
      return AST_LIST_NEXT(e, list);
   } else {
      return AST_LIST_FIRST(&helpers);
   }
}

cli_shutdown()

static void cli_shutdown ( void  )

static

Definition at line 2203 of file main/cli.c.

References ARRAY_LEN, and ast_cli_unregister_multiple().

Referenced by ast_builtins_init().

{
   ast_cli_unregister_multiple(cli_cli, ARRAY_LEN(cli_cli));
}

complete_number()

static char* complete_number ( const char *  partial, unsigned int  min, unsigned int  max, int  n  )

static

Definition at line 363 of file main/cli.c.

References ast_strdup, ast_strlen_zero, cli_perm::next, and NULL.

Referenced by handle_debug(), handle_trace(), and handle_verbose().

{
   int i, count = 0;
   unsigned int prospective[2];
   unsigned int part = strtoul(partial, NULL, 10);
   char next[13];

   if (part < min || part > max) {
      return NULL;
   }

   for (i = 0; i < 21; i++) {
      if (i == 0) {
         prospective[0] = prospective[1] = part;
      } else if (part == 0 && !ast_strlen_zero(partial)) {
         break;
      } else if (i < 11) {
         prospective[0] = prospective[1] = part * 10 + (i - 1);
      } else {
         prospective[0] = (part * 10 + (i - 11)) * 10;
         prospective[1] = prospective[0] + 9;
      }
      if (i < 11 && (prospective[0] < min || prospective[0] > max)) {
         continue;
      } else if (prospective[1] < min || prospective[0] > max) {
         continue;
      }

      if (++count > n) {
         if (i < 11) {
            snprintf(next, sizeof(next), "%u", prospective[0]);
         } else {
            snprintf(next, sizeof(next), "%u...", prospective[0] / 10);
         }
         return ast_strdup(next);
      }
   }
   return NULL;
}

destroy_user_perms()

static void destroy_user_perms ( void  )

static

cleanup (free) cli_perms linkedlist.

Definition at line 2065 of file main/cli.c.

References ast_free, AST_LIST_REMOVE_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, cli_perm::command, cli_perm::list, and usergroup_cli_perm::perms.

Referenced by ast_cli_perms_init().

{
   struct cli_perm *perm;
   struct usergroup_cli_perm *user_perm;

   AST_RWLIST_WRLOCK(&cli_perms);
   while ((user_perm = AST_LIST_REMOVE_HEAD(&cli_perms, list))) {
      while ((perm = AST_LIST_REMOVE_HEAD(user_perm->perms, list))) {
         ast_free(perm->command);
         ast_free(perm);
      }
      ast_free(user_perm);
   }
   AST_RWLIST_UNLOCK(&cli_perms);
}

find_best()

static char* find_best ( const char *  argv[] )

static

Definition at line 2360 of file main/cli.c.

References ast_join, AST_MAX_CMD_LEN, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, find_cli(), and NULL.

Referenced by ast_cli_command_full().

{
   static char cmdline[80];
   int x;
   /* See how close we get, then print the candidate */
   const char *myargv[AST_MAX_CMD_LEN] = { NULL, };

   AST_RWLIST_RDLOCK(&helpers);
   for (x = 0; argv[x]; x++) {
      myargv[x] = argv[x];
      if (!find_cli(myargv, -1))
         break;
   }
   AST_RWLIST_UNLOCK(&helpers);
   ast_join(cmdline, sizeof(cmdline), myargv);
   return cmdline;
}

find_cli()

static struct ast_cli_entry* find_cli ( const char *const  cmds[], int  match_type  )

static

Definition at line 2316 of file main/cli.c.

References ast_strlen_zero, cli_next(), NULL, and word_match().

Referenced by __ast_cli_register(), ast_cli_command_full(), find_best(), and handle_help().

{
   int matchlen = -1;   /* length of longest match so far */
   struct ast_cli_entry *cand = NULL, *e=NULL;

   while ( (e = cli_next(e)) ) {
      /* word-by word regexp comparison */
      const char * const *src = cmds;
      const char * const *dst = e->cmda;
      int n = 0;
      for (;; dst++, src += n) {
         n = word_match(*src, *dst);
         if (n < 0)
            break;
      }
      if (ast_strlen_zero(*dst) || ((*dst)[0] == '[' && ast_strlen_zero(dst[1]))) {
         /* no more words in 'e' */
         if (ast_strlen_zero(*src)) /* exact match, cannot do better */
            break;
         /* Here, cmds has more words than the entry 'e' */
         if (match_type != 0) /* but we look for almost exact match... */
            continue;   /* so we skip this one. */
         /* otherwise we like it (case 0) */
      } else { /* still words in 'e' */
         if (ast_strlen_zero(*src))
            continue; /* cmds is shorter than 'e', not good */
         /* Here we have leftover words in cmds and 'e',
          * but there is a mismatch. We only accept this one if match_type == -1
          * and this is the last word for both.
          */
         if (match_type != -1 || !ast_strlen_zero(src[1]) ||
             !ast_strlen_zero(dst[1])) /* not the one we look for */
            continue;
         /* good, we are in case match_type == -1 and mismatch on last word */
      }
      if (src - cmds > matchlen) {  /* remember the candidate */
         matchlen = src - cmds;
         cand = e;
      }
   }

   return e ? e : cand;
}

find_module_level()

static struct module_level* find_module_level ( const char *  module, struct module_level_list *  mll  )

static

Find the module level setting.

Parameters

module	Module name to look for.
mll	List to search.

Return values

level	struct found on success.
NULL	not found.

Definition at line 351 of file main/cli.c.

References AST_LIST_TRAVERSE, and NULL.

Referenced by handle_debug_or_trace().

{
   struct module_level *ml;

   AST_LIST_TRAVERSE(mll, ml, entry) {
      if (!strcasecmp(ml->module, module))
         return ml;
   }

   return NULL;
}

group_show_channels()

static char* group_show_channels ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1865 of file main/cli.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_app_group_list_head(), ast_app_group_list_rdlock(), ast_app_group_list_unlock(), ast_channel_name(), ast_cli(), AST_LIST_NEXT, ast_strlen_zero, ast_group_info::category, ast_group_info::chan, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ESS, ast_cli_args::fd, FORMAT_STRING, ast_group_info::group, ast_group_info::group_list, NULL, and ast_cli_entry::usage.

{
#define FORMAT_STRING  "%-25s  %-20s  %-20s\n"

   struct ast_group_info *gi = NULL;
   int numchans = 0;
   regex_t regexbuf;
   int havepattern = 0;

   switch (cmd) {
   case CLI_INIT:
      e->command = "group show channels";
      e->usage =
         "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";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   if (a->argc < 3 || a->argc > 4)
      return CLI_SHOWUSAGE;

   if (a->argc == 4) {
      if (regcomp(&regexbuf, a->argv[3], REG_EXTENDED | REG_NOSUB))
         return CLI_SHOWUSAGE;
      havepattern = 1;
   }

   ast_cli(a->fd, FORMAT_STRING, "Channel", "Group", "Category");

   ast_app_group_list_rdlock();

   gi = ast_app_group_list_head();
   while (gi) {
      if (!havepattern || !regexec(&regexbuf, gi->group, 0, NULL, 0)) {
         ast_cli(a->fd, FORMAT_STRING, ast_channel_name(gi->chan), gi->group, (ast_strlen_zero(gi->category) ? "(default)" : gi->category));
         numchans++;
      }
      gi = AST_LIST_NEXT(gi, group_list);
   }

   ast_app_group_list_unlock();

   if (havepattern)
      regfree(&regexbuf);

   ast_cli(a->fd, "%d active channel%s\n", numchans, ESS(numchans));
   return CLI_SUCCESS;
#undef FORMAT_STRING
}

handle_chanlist()

static char* handle_chanlist ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1067 of file main/cli.c.

References ast_channel_snapshot_peer::account, ast_channel_snapshot_base::accountcode, ast_channel_snapshot::amaflags, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_channel_snapshot_dialplan::appl, ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ast_active_calls(), ast_active_channels(), ast_channel_cache_by_name(), ast_cli(), ast_option_maxcalls, ast_processed_calls(), ast_state2str(), ast_strlen_zero, ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), ast_channel_snapshot::base, ast_channel_snapshot::bridge, ast_channel_snapshot::caller, channels, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, CONCISE_FORMAT_STRING, ast_channel_snapshot_dialplan::context, ast_channel_snapshot_base::creationtime, ast_channel_snapshot_dialplan::data, ast_channel_snapshot::dialplan, ESS, ast_channel_snapshot_dialplan::exten, ast_cli_args::fd, FORMAT_STRING, FORMAT_STRING2, ast_channel_snapshot_bridge::id, ast_channel_snapshot_base::name, NULL, ast_channel_snapshot_caller::number, ast_channel_snapshot::peer, ast_channel_snapshot_dialplan::priority, S_OR, ast_channel_snapshot::state, ast_channel_snapshot_base::uniqueid, ast_cli_entry::usage, VERBOSE_FORMAT_STRING, and VERBOSE_FORMAT_STRING2.

{
#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!%s!%d!%s!%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 %-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 %-11.11s %-20.20s\n"

   struct ao2_container *channels;
   struct ao2_iterator it_chans;
   struct ast_channel_snapshot *cs;
   int numchans = 0, concise = 0, verbose = 0, count = 0;

   switch (cmd) {
   case CLI_INIT:
      e->command = "core show channels [concise|verbose|count]";
      e->usage =
         "Usage: core show channels [concise|verbose|count]\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. If 'count' is specified only the channel and call\n"
         "       count is output.\n"
         "  The 'concise' option is deprecated and will be removed from future versions\n"
         "  of Asterisk.\n";
      return NULL;

   case CLI_GENERATE:
      return NULL;
   }

   if (a->argc == e->args) {
      if (!strcasecmp(a->argv[e->args-1],"concise"))
         concise = 1;
      else if (!strcasecmp(a->argv[e->args-1],"verbose"))
         verbose = 1;
      else if (!strcasecmp(a->argv[e->args-1],"count"))
         count = 1;
      else
         return CLI_SHOWUSAGE;
   } else if (a->argc != e->args - 1)
      return CLI_SHOWUSAGE;

   channels = ast_channel_cache_by_name();

   if (!count) {
      if (!concise && !verbose)
         ast_cli(a->fd, FORMAT_STRING2, "Channel", "Location", "State", "Application(Data)");
      else if (verbose)
         ast_cli(a->fd, VERBOSE_FORMAT_STRING2, "Channel", "Context", "Extension", "Priority", "State", "Application", "Data",
            "CallerID", "Duration", "Accountcode", "PeerAccount", "BridgeID");
   }

   it_chans = ao2_iterator_init(channels, 0);
   for (; (cs = ao2_iterator_next(&it_chans)); ao2_ref(cs, -1)) {
      char durbuf[16] = "-";

      if (!count) {
         if ((concise || verbose)  && !ast_tvzero(cs->base->creationtime)) {
            int duration = (int)(ast_tvdiff_ms(ast_tvnow(), cs->base->creationtime) / 1000);
            if (verbose) {
               int durh = duration / 3600;
               int durm = (duration % 3600) / 60;
               int durs = duration % 60;
               snprintf(durbuf, sizeof(durbuf), "%02d:%02d:%02d", durh, durm, durs);
            } else {
               snprintf(durbuf, sizeof(durbuf), "%d", duration);
            }
         }
         if (concise) {
            ast_cli(a->fd, CONCISE_FORMAT_STRING, cs->base->name, cs->dialplan->context, cs->dialplan->exten, cs->dialplan->priority, ast_state2str(cs->state),
               S_OR(cs->dialplan->appl, "(None)"),
               cs->dialplan->data,
               cs->caller->number,
               cs->base->accountcode,
               cs->peer->account,
               cs->amaflags,
               durbuf,
               cs->bridge->id,
               cs->base->uniqueid);
         } else if (verbose) {
            ast_cli(a->fd, VERBOSE_FORMAT_STRING, cs->base->name, cs->dialplan->context, cs->dialplan->exten, cs->dialplan->priority, ast_state2str(cs->state),
               S_OR(cs->dialplan->appl, "(None)"),
               S_OR(cs->dialplan->data, "(Empty)"),
               cs->caller->number,
               durbuf,
               cs->base->accountcode,
               cs->peer->account,
               cs->bridge->id);
         } else {
            char locbuf[40] = "(None)";
            char appdata[40] = "(None)";

            if (!ast_strlen_zero(cs->dialplan->context) && !ast_strlen_zero(cs->dialplan->exten)) {
               snprintf(locbuf, sizeof(locbuf), "%s@%s:%d", cs->dialplan->exten, cs->dialplan->context, cs->dialplan->priority);
            }
            if (!ast_strlen_zero(cs->dialplan->appl)) {
               snprintf(appdata, sizeof(appdata), "%s(%s)", cs->dialplan->appl, S_OR(cs->dialplan->data, ""));
            }
            ast_cli(a->fd, FORMAT_STRING, cs->base->name, locbuf, ast_state2str(cs->state), appdata);
         }
      }
   }
   ao2_iterator_destroy(&it_chans);

   if (!concise) {
      numchans = ast_active_channels();
      ast_cli(a->fd, "%d active channel%s\n", numchans, ESS(numchans));
      if (ast_option_maxcalls)
         ast_cli(a->fd, "%d of %d max active call%s (%5.2f%% of capacity)\n",
            ast_active_calls(), ast_option_maxcalls, ESS(ast_active_calls()),
            ((double)ast_active_calls() / (double)ast_option_maxcalls) * 100.0);
      else
         ast_cli(a->fd, "%d active call%s\n", ast_active_calls(), ESS(ast_active_calls()));

      ast_cli(a->fd, "%d call%s processed\n", ast_processed_calls(), ESS(ast_processed_calls()));
   }
   ao2_ref(channels, -1);

   return CLI_SUCCESS;

#undef FORMAT_STRING
#undef FORMAT_STRING2
#undef CONCISE_FORMAT_STRING
#undef VERBOSE_FORMAT_STRING
#undef VERBOSE_FORMAT_STRING2
}

handle_cli_check_permissions()

static char* handle_cli_check_permissions ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

handles CLI command 'cli check permissions'

Definition at line 1316 of file main/cli.c.

References __ast_cli_generator(), ast_cli_entry::_full_cmd, ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_cli_generator(), ast_join, AST_MAX_ARGS, ast_strdupa, ast_strlen_zero, CLI_FAILURE, CLI_GENERATE, cli_has_permissions(), CLI_INIT, cli_next(), CLI_SHOWUSAGE, CLI_SUCCESS, cli_perm::command, ast_cli_entry::command, ast_cli_args::fd, ast_cli_args::line, lock, ast_cli_args::n, NULL, ast_cli_args::pos, S_OR, ast_cli_entry::summary, text, tmp(), ast_cli_entry::usage, and ast_cli_args::word.

{
   struct passwd *pw = NULL;
   struct group *gr;
   int gid = -1, uid = -1;
   char command[AST_MAX_ARGS] = "";
   struct ast_cli_entry *ce = NULL;
   int found = 0;
   char *group, *tmp;

   switch (cmd) {
   case CLI_INIT:
      e->command = "cli check permissions";
      e->usage =
         "Usage: cli check permissions {<username>|@<groupname>|<username>@<groupname>} [<command>]\n"
         "       Check permissions config for a user@group or list the allowed commands for the specified user.\n"
         "       The username or the groupname may be omitted.\n";
      return NULL;
   case CLI_GENERATE:
      if (a->pos >= 4) {
         return ast_cli_generator(a->line + strlen("cli check permissions") + strlen(a->argv[3]) + 1, a->word, a->n);
      }
      return NULL;
   }

   if (a->argc < 4) {
      return CLI_SHOWUSAGE;
   }

   tmp = ast_strdupa(a->argv[3]);
   group = strchr(tmp, '@');
   if (group) {
      gr = getgrnam(&group[1]);
      if (!gr) {
         ast_cli(a->fd, "Unknown group '%s'\n", &group[1]);
         return CLI_FAILURE;
      }
      group[0] = '\0';
      gid = gr->gr_gid;
   }

   if (!group && ast_strlen_zero(tmp)) {
      ast_cli(a->fd, "You didn't supply a username\n");
   } else if (!ast_strlen_zero(tmp) && !(pw = getpwnam(tmp))) {
      ast_cli(a->fd, "Unknown user '%s'\n", tmp);
      return CLI_FAILURE;
   } else if (pw) {
      uid = pw->pw_uid;
   }

   if (a->argc == 4) {
      while ((ce = cli_next(ce))) {
         /* Hide commands that start with '_' */
         if (ce->_full_cmd[0] == '_') {
            continue;
         }
         if (cli_has_permissions(uid, gid, ce->_full_cmd)) {
            ast_cli(a->fd, "%30.30s %s\n", ce->_full_cmd, S_OR(ce->summary, "<no description available>"));
            found++;
         }
      }
      if (!found) {
         ast_cli(a->fd, "You are not allowed to run any command on Asterisk\n");
      }
   } else {
      ast_join(command, sizeof(command), a->argv + 4);
      ast_cli(a->fd, "%s '%s%s%s' is %s to run command: '%s'\n", uid >= 0 ? "User" : "Group", tmp,
         group && uid >= 0 ? "@" : "",
         group ? &group[1] : "",
         cli_has_permissions(uid, gid, command) ? "allowed" : "not allowed", command);
   }

   return CLI_SUCCESS;
}

handle_cli_malloc_trim()

static char* handle_cli_malloc_trim ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1956 of file main/cli.c.

References a, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, handle_help(), NULL, and ast_cli_entry::usage.

{
   extern int malloc_trim(size_t __pad) __THROW;

   switch (cmd) {
   case CLI_INIT:
      e->command = "malloc trim";
      e->usage =
         "Usage: malloc trim\n"
         "       Try to give excess memory back to the OS.\n";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   if (malloc_trim(0)) {
      ast_cli(a->fd, "Returned some memory to the OS.\n");
   } else {
      ast_cli(a->fd, "No memory returned to the OS.\n");
   }

   return CLI_SUCCESS;
}

handle_cli_reload_permissions()

static char* handle_cli_reload_permissions ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

handles CLI command 'cli reload permissions'

Definition at line 1297 of file main/cli.c.

References ast_cli_perms_init(), CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, NULL, and ast_cli_entry::usage.

{
   switch (cmd) {
   case CLI_INIT:
      e->command = "cli reload permissions";
      e->usage =
         "Usage: cli reload permissions\n"
         "       Reload the 'cli_permissions.conf' file.\n";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   ast_cli_perms_init(1);

   return CLI_SUCCESS;
}

handle_cli_show_permissions()

static char* handle_cli_show_permissions ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

handles CLI command 'cli show permissions'

Definition at line 1252 of file main/cli.c.

References ast_cli(), AST_LIST_TRAVERSE, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, cli_perm::command, ast_cli_entry::command, ast_cli_args::fd, usergroup_cli_perm::gid, cli_perm::list, NULL, cli_perm::permit, usergroup_cli_perm::perms, usergroup_cli_perm::uid, and ast_cli_entry::usage.

{
   struct usergroup_cli_perm *cp;
   struct cli_perm *perm;
   struct passwd *pw = NULL;
   struct group *gr = NULL;

   switch (cmd) {
   case CLI_INIT:
      e->command = "cli show permissions";
      e->usage =
         "Usage: cli show permissions\n"
         "       Shows CLI configured permissions.\n";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   AST_RWLIST_RDLOCK(&cli_perms);
   AST_LIST_TRAVERSE(&cli_perms, cp, list) {
      if (cp->uid >= 0) {
         pw = getpwuid(cp->uid);
         if (pw) {
            ast_cli(a->fd, "user: %s [uid=%d]\n", pw->pw_name, cp->uid);
         }
      } else {
         gr = getgrgid(cp->gid);
         if (gr) {
            ast_cli(a->fd, "group: %s [gid=%d]\n", gr->gr_name, cp->gid);
         }
      }
      ast_cli(a->fd, "Permissions:\n");
      if (cp->perms) {
         AST_LIST_TRAVERSE(cp->perms, perm, list) {
            ast_cli(a->fd, "\t%s -> %s\n", perm->permit ? "permit" : "deny", perm->command);
         }
      }
      ast_cli(a->fd, "\n");
   }
   AST_RWLIST_UNLOCK(&cli_perms);

   return CLI_SUCCESS;
}

handle_cli_wait_fullybooted()

static char* handle_cli_wait_fullybooted ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1919 of file main/cli.c.

References ast_cli(), AST_OPT_FLAG_FULLY_BOOTED, ast_options, ast_test_flag, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, NULL, and ast_cli_entry::usage.

{
   switch (cmd) {
   case CLI_INIT:
      e->command = "core waitfullybooted";
      e->usage =
         "Usage: core waitfullybooted\n"
         "  Wait until Asterisk has fully booted.\n";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   while (!ast_test_flag(&ast_options, AST_OPT_FLAG_FULLY_BOOTED)) {
      usleep(100);
   }

   ast_cli(a->fd, "Asterisk has fully booted.\n");

   return CLI_SUCCESS;
}

handle_commandmatchesarray()

static char* handle_commandmatchesarray ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1393 of file main/cli.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_cli(), AST_CLI_COMPLETE_EOF, ast_cli_completion_matches(), ast_free, ast_malloc, ast_realloc, buf, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, len(), NULL, and ast_cli_entry::usage.

{
   char *buf, *obuf;
   int buflen = 2048;
   int len = 0;
   char **matches;
   int x, matchlen;

   switch (cmd) {
   case CLI_INIT:
      e->command = "_command matchesarray";
      e->usage =
         "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";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   if (a->argc != 4)
      return CLI_SHOWUSAGE;
   if (!(buf = ast_malloc(buflen)))
      return CLI_FAILURE;
   buf[len] = '\0';
   matches = ast_cli_completion_matches(a->argv[2], a->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 */
               ast_free(obuf);
         }
         if (buf)
            len += sprintf( buf + len, "%s ", matches[x]);
         ast_free(matches[x]);
         matches[x] = NULL;
      }
      ast_free(matches);
   }

   if (buf) {
      ast_cli(a->fd, "%s%s",buf, AST_CLI_COMPLETE_EOF);
      ast_free(buf);
   } else
      ast_cli(a->fd, "NULL\n");

   return CLI_SUCCESS;
}

handle_core_reload()

static char* handle_core_reload ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 319 of file main/cli.c.

References ast_cli_args::argc, ast_cli_entry::args, ast_module_reload(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, and ast_cli_entry::usage.

{
   switch (cmd) {
   case CLI_INIT:
      e->command = "core reload";
      e->usage =
         "Usage: core reload\n"
         "       Execute a global reload.\n";
      return NULL;

   case CLI_GENERATE:
      return NULL;
   }

   if (a->argc != e->args) {
      return CLI_SHOWUSAGE;
   }

   ast_module_reload(NULL);

   return CLI_SUCCESS;
}

handle_core_set_debug_channel()

static char* handle_core_set_debug_channel ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1476 of file main/cli.c.

References ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ast_channel_callback(), ast_channel_get_by_name(), ast_channel_unref, ast_cli(), ast_cli_complete(), ast_complete_channels(), c, channel_set_debug(), CLI_GENERATE, CLI_HANDLER, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, DEBUGCHAN_FLAG, ast_cli_args::fd, channel_set_debug_args::fd, global_fin, global_fout, channel_set_debug_args::is_off, ast_cli_args::line, ast_cli_args::n, NULL, OBJ_MULTIPLE, OBJ_NODATA, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

Referenced by handle_nodebugchan_deprecated().

{
   struct ast_channel *c = NULL;
   static const char * const completions_all[] = { "all", NULL };
   static const char * const completions_off[] = { "off", NULL };
   struct channel_set_debug_args args = {
      .fd = a->fd,
   };

   switch (cmd) {
   case CLI_INIT:
      e->command = "core set debug channel";
      e->usage =
         "Usage: core set debug channel <all|channel> [off]\n"
         "       Enables/disables debugging on all or on a specific channel.\n";
      return NULL;
   case CLI_GENERATE:
      if (a->pos == 4) {
         char *complete = ast_cli_complete(a->word, completions_all, a->n);
         if (!complete) {
            complete = ast_complete_channels(a->line, a->word, a->pos, a->n - 1, e->args);
         }
         return complete;
      } else if (a->pos == 5) {
         return ast_cli_complete(a->word, completions_off, a->n);
      }

      return NULL;
   }

   if (cmd == (CLI_HANDLER + 1000)) {
      /* called from handle_nodebugchan_deprecated */
      args.is_off = 1;
   } else if (a->argc == e->args + 2) {
      /* 'core set debug channel {all|chan_id}' */
      if (!strcasecmp(a->argv[e->args + 1], "off"))
         args.is_off = 1;
      else
         return CLI_SHOWUSAGE;
   } else if (a->argc != e->args + 1) {
      return CLI_SHOWUSAGE;
   }

   if (!strcasecmp("all", a->argv[e->args])) {
      if (args.is_off) {
         global_fin &= ~DEBUGCHAN_FLAG;
         global_fout &= ~DEBUGCHAN_FLAG;
      } else {
         global_fin |= DEBUGCHAN_FLAG;
         global_fout |= DEBUGCHAN_FLAG;
      }
      ast_channel_callback(channel_set_debug, NULL, &args, OBJ_NODATA | OBJ_MULTIPLE);
   } else {
      if ((c = ast_channel_get_by_name(a->argv[e->args]))) {
         channel_set_debug(c, NULL, &args, 0);
         ast_channel_unref(c);
      } else {
         ast_cli(a->fd, "No such channel %s\n", a->argv[e->args]);
      }
   }

   ast_cli(a->fd, "Debugging on new channels is %s\n", args.is_off ? "disabled" : "enabled");

   return CLI_SUCCESS;
}

handle_debug()

static char* handle_debug ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 572 of file main/cli.c.

References ast_cli_args::argv, ast_module_helper(), AST_MODULE_HELPER_RUNNING, ast_strdup, ast_strlen_zero, CLI_GENERATE, CLI_INIT, ast_cli_entry::command, complete_number(), DEBUG_HANDLER, handle_debug_or_trace(), ast_cli_args::line, ast_cli_args::n, NULL, ast_cli_args::pos, S_OR, ast_cli_entry::usage, and ast_cli_args::word.

{
   int atleast = 0;
   const char *argv3 = a->argv ? S_OR(a->argv[3], "") : "";

   switch (cmd) {
   case CLI_INIT:
      e->command = "core set debug";
      e->usage =
         "Usage: core set debug [atleast] <level> [module]\n"
         "       core set debug off\n"
         "\n"
         "       Sets level of debug messages to be displayed or\n"
         "       sets a module name to display debug messages from.\n"
         "       0 or off means no messages should be displayed.\n"
         "       Equivalent to -d[d[...]] on startup\n";
      return NULL;

   case CLI_GENERATE:
      if (!strcasecmp(argv3, "category")) {
         return NULL;
      }

      if (!strcasecmp(argv3, "atleast")) {
         atleast = 1;
      }
      if (a->pos == 3 || (a->pos == 4 && atleast)) {
         const char *pos = a->pos == 3 ? argv3 : S_OR(a->argv[4], "");
         int numbermatch = (ast_strlen_zero(pos) || strchr("123456789", pos[0])) ? 0 : 21;

         if (a->n < 21 && numbermatch == 0) {
            return complete_number(pos, 0, 0x7fffffff, a->n);
         } else if (pos[0] == '0') {
            if (a->n == 0) {
               return ast_strdup("0");
            }
         } else if (a->n == (21 - numbermatch)) {
            if (a->pos == 3 && !strncasecmp(argv3, "off", strlen(argv3))) {
               return ast_strdup("off");
            } else if (a->pos == 3 && !strncasecmp(argv3, "atleast", strlen(argv3))) {
               return ast_strdup("atleast");
            }
         } else if (a->n == (22 - numbermatch) && a->pos == 3 && ast_strlen_zero(argv3)) {
            return ast_strdup("atleast");
         }
      } else if ((a->pos == 4 && !atleast && strcasecmp(argv3, "off") && strcasecmp(argv3, "channel"))
         || (a->pos == 5 && atleast)) {
         return ast_module_helper(a->line, a->word, a->pos, a->n, a->pos, AST_MODULE_HELPER_RUNNING);
      }
      return NULL;
   }
   /* all the above return, so we proceed with the handler.
    * we are guaranteed to be called with argc >= e->args;
    */

   return handle_debug_or_trace(DEBUG_HANDLER, e, cmd, a);
}

handle_debug_category()

static char* handle_debug_category ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1542 of file main/cli.c.

References ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ast_cli_completion_add(), ast_debug_category_complete(), ast_debug_category_set_sublevels(), AST_LOG_CATEGORY_DISABLED, AST_LOG_CATEGORY_ENABLED, ast_strdup, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::n, NULL, ast_cli_args::pos, S_OR, ast_cli_entry::usage, and ast_cli_args::word.

{
   const char *argv4 = a->argv ? S_OR(a->argv[4], "") : "";
   int offset = strncasecmp(argv4, "off", strlen(argv4)) ? 0 : 1;

   switch (cmd) {
   case CLI_INIT:
      e->command = "core set debug category";
      e->usage =
         "Usage: core set debug category <category>[:<sublevel>] [category[:<sublevel] ...]\n"
         "       core set debug category off [<category> [<category>] ...]\n\n"
         "       Allows enabling and disabling debug logging categories.\n"
         "       When a category is enabled all relevant debug messages are logged\n"
         "       for a given category. However, if a sublevel is specified only\n"
         "       those categorized messages at or below the coded debug sublevel\n"
         "       are logged.\n";
      return NULL;

   case CLI_GENERATE:
      if (a->pos < e->args) {
         return NULL;
      }

      if (a->pos == 4 && offset) {
         ast_cli_completion_add(ast_strdup("off"));
      }

      return ast_debug_category_complete(a->argv + 4,
         a->pos - e->args, a->word, a->n - 1);
   }

   if (a->argc <= e->args) {
      return CLI_SHOWUSAGE;
   }

   ast_debug_category_set_sublevels(a->argv + e->args + offset, a->argc - e->args - offset,
      offset ? AST_LOG_CATEGORY_DISABLED : AST_LOG_CATEGORY_ENABLED);

   return CLI_SUCCESS;
}

handle_debug_or_trace()

static char* handle_debug_or_trace ( int  handler, struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 449 of file main/cli.c.

References ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ast_calloc, ast_clear_flag, ast_cli(), ast_free, AST_OPT_FLAG_DEBUG_MODULE, AST_OPT_FLAG_TRACE_MODULE, ast_options, AST_RWLIST_EMPTY, AST_RWLIST_INSERT_TAIL, AST_RWLIST_REMOVE, AST_RWLIST_REMOVE_HEAD, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_set_flag, ast_strdupa, CLI_FAILURE, CLI_SHOWUSAGE, CLI_SUCCESS, DEBUG_HANDLER, debug_modules, ast_cli_args::fd, find_module_level(), module_level::level, option_debug, option_trace, status_debug_verbose(), and trace_modules.

Referenced by handle_debug(), and handle_trace().

{
   int oldval;
   int newlevel;
   int atleast = 0;
   struct module_level *ml;
   struct module_level_list *modules;
   unsigned int module_option;
   int *core_option;
   const char *handler_name;

   if (a->argc <= e->args) {
      return CLI_SHOWUSAGE;
   }

   if (handler == DEBUG_HANDLER) {
      modules = &debug_modules;
      module_option = AST_OPT_FLAG_DEBUG_MODULE;
      core_option = &option_debug;
      handler_name = "debug";
   } else {
      modules = &trace_modules;
      module_option = AST_OPT_FLAG_TRACE_MODULE;
      core_option = &option_trace;
      handler_name = "trace";
   }

   if (a->argc == e->args + 1 && !strcasecmp(a->argv[e->args], "off")) {
      newlevel = 0;
   } else {
      if (!strcasecmp(a->argv[e->args], "atleast")) {
         atleast = 1;
      }

      if (a->argc != e->args + atleast + 1 && a->argc != e->args + atleast + 2) {
         return CLI_SHOWUSAGE;
      }

      if (sscanf(a->argv[e->args + atleast], "%30d", &newlevel) != 1) {
         return CLI_SHOWUSAGE;
      }

      if (a->argc == e->args + atleast + 2) {
         /* We have specified a module name. */
         char *mod = ast_strdupa(a->argv[e->args + atleast + 1]);
         int mod_len = strlen(mod);

         if (3 < mod_len && !strcasecmp(mod + mod_len - 3, ".so")) {
            mod[mod_len - 3] = '\0';
         }

         AST_RWLIST_WRLOCK(modules);

         ml = find_module_level(mod, modules);
         if (!newlevel) {
            if (!ml) {
               /* Specified off for a nonexistent entry. */
               AST_RWLIST_UNLOCK(modules);
               ast_cli(a->fd, "Core %s is still 0 for '%s'.\n", handler_name, mod);
               return CLI_SUCCESS;
            }
            AST_RWLIST_REMOVE(modules, ml, entry);
            if (AST_RWLIST_EMPTY(modules)) {
               ast_clear_flag(&ast_options, module_option);
            }
            AST_RWLIST_UNLOCK(modules);
            ast_cli(a->fd, "Core %s was %u and has been set to 0 for '%s'.\n", handler_name,
               ml->level, mod);
            ast_free(ml);
            return CLI_SUCCESS;
         }

         if (ml) {
            if ((atleast && newlevel < ml->level) || ml->level == newlevel) {
               ast_cli(a->fd, "Core %s is still %u for '%s'.\n", handler_name, ml->level, mod);
               AST_RWLIST_UNLOCK(modules);
               return CLI_SUCCESS;
            }
            oldval = ml->level;
            ml->level = newlevel;
         } else {
            ml = ast_calloc(1, sizeof(*ml) + strlen(mod) + 1);
            if (!ml) {
               AST_RWLIST_UNLOCK(modules);
               return CLI_FAILURE;
            }
            oldval = ml->level;
            ml->level = newlevel;
            strcpy(ml->module, mod);
            AST_RWLIST_INSERT_TAIL(modules, ml, entry);
         }
         ast_set_flag(&ast_options, module_option);

         ast_cli(a->fd, "Core %s was %d and has been set to %u for '%s'.\n", handler_name,
            oldval, ml->level, ml->module);

         AST_RWLIST_UNLOCK(modules);

         return CLI_SUCCESS;
      }
   }

   /* Update global debug level */
   if (!newlevel) {
      /* Specified level was 0 or off. */
      AST_RWLIST_WRLOCK(modules);
      while ((ml = AST_RWLIST_REMOVE_HEAD(modules, entry))) {
         ast_free(ml);
      }
      ast_clear_flag(&ast_options, AST_OPT_FLAG_DEBUG_MODULE);
      AST_RWLIST_UNLOCK(modules);
   }
   oldval = *core_option;
   if (!atleast || newlevel > *core_option) {
      *core_option = newlevel;
   }

   /* Report debug level status */
   status_debug_verbose(a, handler, oldval, *core_option);

   return CLI_SUCCESS;
}

handle_help()

static char * handle_help ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 2552 of file main/cli.c.

References __ast_cli_generator(), ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ast_cli(), ast_join, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, find_cli(), help1(), ast_cli_args::line, ast_cli_args::n, NULL, ast_cli_entry::usage, and ast_cli_args::word.

Referenced by handle_cli_malloc_trim().

{
   char fullcmd[80];
   struct ast_cli_entry *my_e;
   char *res = CLI_SUCCESS;

   if (cmd == CLI_INIT) {
      e->command = "core show help";
      e->usage =
         "Usage: core show 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";
      return NULL;

   } else if (cmd == CLI_GENERATE) {
      /* skip first 14 or 15 chars, "core show help " */
      int l = strlen(a->line);

      if (l > 15) {
         l = 15;
      }
      /* XXX watch out, should stop to the non-generator parts */
      return __ast_cli_generator(a->line + l, a->word, a->n, 0);
   }
   if (a->argc == e->args) {
      return help1(a->fd, NULL, 0);
   }

   AST_RWLIST_RDLOCK(&helpers);
   my_e = find_cli(a->argv + 3, 1); /* try exact match first */
   if (!my_e) {
      res = help1(a->fd, a->argv + 3, 1 /* locked */);
      AST_RWLIST_UNLOCK(&helpers);
      return res;
   }
   if (my_e->usage)
      ast_cli(a->fd, "%s", my_e->usage);
   else {
      ast_join(fullcmd, sizeof(fullcmd), a->argv + 3);
      ast_cli(a->fd, "No help text available for '%s'.\n", fullcmd);
   }
   AST_RWLIST_UNLOCK(&helpers);
   return res;
}

handle_load()

static char* handle_load ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 240 of file main/cli.c.

References ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ast_cli(), ast_load_resource(), ast_module_helper(), AST_MODULE_HELPER_LOAD, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, ast_cli_args::line, ast_cli_args::n, NULL, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

{
   /* "module load <mod>" */
   switch (cmd) {
   case CLI_INIT:
      e->command = "module load";
      e->usage =
         "Usage: module load <module name>\n"
         "       Loads the specified module into Asterisk.\n";
      return NULL;

   case CLI_GENERATE:
      if (a->pos != e->args) {
         return NULL;
      }
      return ast_module_helper(a->line, a->word, a->pos, a->n, a->pos, AST_MODULE_HELPER_LOAD);
   }
   if (a->argc != e->args + 1) {
      return CLI_SHOWUSAGE;
   }
   if (ast_load_resource(a->argv[e->args])) {
      ast_cli(a->fd, "Unable to load module %s\n", a->argv[e->args]);
      return CLI_FAILURE;
   }
   ast_cli(a->fd, "Loaded %s\n", a->argv[e->args]);
   return CLI_SUCCESS;
}

handle_logger_mute()

static char* handle_logger_mute ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 783 of file main/cli.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_console_toggle_mute(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, NULL, and ast_cli_entry::usage.

{
   switch (cmd) {
   case CLI_INIT:
      e->command = "logger mute";
      e->usage =
         "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";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   if (a->argc < 2 || a->argc > 3)
      return CLI_SHOWUSAGE;

   if (a->argc == 3 && !strcasecmp(a->argv[2], "silent"))
      ast_console_toggle_mute(a->fd, 1);
   else
      ast_console_toggle_mute(a->fd, 0);

   return CLI_SUCCESS;
}

handle_modlist()

static char* handle_modlist ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 971 of file main/cli.c.

References ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ast_cli(), ast_module_helper(), AST_MODULE_HELPER_LOADED, ast_mutex_lock, ast_mutex_unlock, ast_update_module_list(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, climodentryfd, climodentrylock, ast_cli_entry::command, ast_cli_args::fd, ast_cli_args::line, MODLIST_FORMAT2, modlist_modentry(), ast_cli_args::n, NULL, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

{
   const char *like;

   switch (cmd) {
   case CLI_INIT:
      e->command = "module show [like]";
      e->usage =
         "Usage: module show [like keyword]\n"
         "       Shows Asterisk modules currently in use, and usage statistics.\n";
      return NULL;

   case CLI_GENERATE:
      if (a->pos == e->args) {
         return ast_module_helper(a->line, a->word, a->pos, a->n, a->pos, AST_MODULE_HELPER_LOADED);
      } else {
         return NULL;
      }
   }
   /* all the above return, so we proceed with the handler.
    * we are guaranteed to have argc >= e->args
    */
   if (a->argc == e->args - 1)
      like = "";
   else if (a->argc == e->args + 1 && !strcasecmp(a->argv[e->args-1], "like") )
      like = a->argv[e->args];
   else
      return CLI_SHOWUSAGE;

   ast_mutex_lock(&climodentrylock);
   climodentryfd = a->fd; /* global, protected by climodentrylock */
   ast_cli(a->fd, MODLIST_FORMAT2, "Module", "Description", "Use Count", "Status", "Support Level");
   ast_cli(a->fd,"%d modules loaded\n", ast_update_module_list(modlist_modentry, like));
   climodentryfd = -1;
   ast_mutex_unlock(&climodentrylock);
   return CLI_SUCCESS;
}

handle_nodebugchan_deprecated()

static char* handle_nodebugchan_deprecated ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1583 of file main/cli.c.

References ast_cli_args::argc, ast_cli_entry::args, CLI_HANDLER, CLI_INIT, CLI_SHOWUSAGE, ast_cli_entry::command, handle_core_set_debug_channel(), and NULL.

{
   char *res;

   switch (cmd) {
   case CLI_INIT:
      e->command = "no debug channel";
      return NULL;
   case CLI_HANDLER:
      /* exit out of switch statement */
      break;
   default:
      return NULL;
   }

   if (a->argc != e->args + 1)
      return CLI_SHOWUSAGE;

   /* add a 'magic' value to the CLI_HANDLER command so that
    * handle_core_set_debug_channel() will act as if 'off'
    * had been specified as part of the command
    */
   res = handle_core_set_debug_channel(e, CLI_HANDLER + 1000, a);

   return res;
}

handle_reload()

static char* handle_reload ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 268 of file main/cli.c.

References ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ast_cli(), ast_module_helper(), AST_MODULE_HELPER_RELOAD, ast_module_reload(), AST_MODULE_RELOAD_ERROR, AST_MODULE_RELOAD_IN_PROGRESS, AST_MODULE_RELOAD_NOT_FOUND, AST_MODULE_RELOAD_NOT_IMPLEMENTED, AST_MODULE_RELOAD_QUEUED, AST_MODULE_RELOAD_SUCCESS, AST_MODULE_RELOAD_UNINITIALIZED, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, ast_cli_args::line, ast_cli_args::n, NULL, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

{
   int x;

   switch (cmd) {
   case CLI_INIT:
      e->command = "module reload";
      e->usage =
         "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";
      return NULL;

   case CLI_GENERATE:
      return ast_module_helper(a->line, a->word, a->pos, a->n, a->pos, AST_MODULE_HELPER_RELOAD);
   }
   if (a->argc == e->args) {
      ast_module_reload(NULL);
      return CLI_SUCCESS;
   }
   for (x = e->args; x < a->argc; x++) {
      enum ast_module_reload_result res = ast_module_reload(a->argv[x]);
      switch (res) {
      case AST_MODULE_RELOAD_NOT_FOUND:
         ast_cli(a->fd, "No such module '%s'\n", a->argv[x]);
         break;
      case AST_MODULE_RELOAD_NOT_IMPLEMENTED:
         ast_cli(a->fd, "The module '%s' does not support reloads\n", a->argv[x]);
         break;
      case AST_MODULE_RELOAD_QUEUED:
         ast_cli(a->fd, "Asterisk cannot reload a module yet; request queued\n");
         break;
      case AST_MODULE_RELOAD_ERROR:
         ast_cli(a->fd, "The module '%s' reported a reload failure\n", a->argv[x]);
         break;
      case AST_MODULE_RELOAD_IN_PROGRESS:
         ast_cli(a->fd, "A module reload request is already in progress; please be patient\n");
         break;
      case AST_MODULE_RELOAD_UNINITIALIZED:
         ast_cli(a->fd, "The module '%s' was not properly initialized. Before reloading"
               " the module, you must run \"module load %s\" and fix whatever is"
               " preventing the module from being initialized.\n", a->argv[x], a->argv[x]);
         break;
      case AST_MODULE_RELOAD_SUCCESS:
         ast_cli(a->fd, "Module '%s' reloaded successfully.\n", a->argv[x]);
         break;
      }
   }
   return CLI_SUCCESS;
}

handle_showcalls()

static char* handle_showcalls ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1011 of file main/cli.c.

References ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ast_active_calls(), ast_cli(), ast_cli_complete(), ast_option_maxcalls, ast_processed_calls(), ast_startuptime, ast_tvnow(), ast_tvsub(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, ast_cli_entry::command, ESS, ast_cli_args::fd, ast_cli_args::n, NULL, ast_cli_args::pos, print_uptimestr(), RESULT_SUCCESS, ast_cli_entry::usage, and ast_cli_args::word.

{
   static const char * const completions[] = { "seconds", NULL };
   struct timeval curtime = ast_tvnow();
   int showuptime, printsec;

   switch (cmd) {
   case CLI_INIT:
      e->command = "core show calls [uptime]";
      e->usage =
         "Usage: core show calls [uptime [seconds]]\n"
         "       Lists number of currently active calls and total number of calls\n"
         "       processed through PBX since last restart. If 'uptime' is specified\n"
         "       the system uptime is also displayed. If 'seconds' is specified in\n"
         "       addition to 'uptime', the system uptime is displayed in seconds.\n";
      return NULL;

   case CLI_GENERATE:
      if (a->pos != e->args)
         return NULL;
      return ast_cli_complete(a->word, completions, a->n);
   }

   /* regular handler */
   if (a->argc >= e->args && !strcasecmp(a->argv[e->args-1],"uptime")) {
      showuptime = 1;

      if (a->argc == e->args+1 && !strcasecmp(a->argv[e->args],"seconds"))
         printsec = 1;
      else if (a->argc == e->args)
         printsec = 0;
      else
         return CLI_SHOWUSAGE;
   } else if (a->argc == e->args-1) {
      showuptime = 0;
      printsec = 0;
   } else
      return CLI_SHOWUSAGE;

   if (ast_option_maxcalls) {
      ast_cli(a->fd, "%d of %d max active call%s (%5.2f%% of capacity)\n",
         ast_active_calls(), ast_option_maxcalls, ESS(ast_active_calls()),
         ((double)ast_active_calls() / (double)ast_option_maxcalls) * 100.0);
   } else {
      ast_cli(a->fd, "%d active call%s\n", ast_active_calls(), ESS(ast_active_calls()));
   }

   ast_cli(a->fd, "%d call%s processed\n", ast_processed_calls(), ESS(ast_processed_calls()));

   if (ast_startuptime.tv_sec && showuptime) {
      print_uptimestr(a->fd, ast_tvsub(curtime, ast_startuptime), "System uptime: ", printsec);
   }

   return RESULT_SUCCESS;
}

handle_showchan()

static char* handle_showchan ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

< Buffer for CDR variables.

< Accumulation buffer for all output.

Definition at line 1610 of file main/cli.c.

References ao2_cleanup, ast_cli_args::argc, ast_cli_args::argv, ast_callid_strnprint(), ast_cdr_serialize_variables(), AST_CHAN_TP_INTERNAL, ast_channel_appl(), ast_channel_caller(), ast_channel_callgroup(), ast_channel_callid(), ast_channel_connected(), ast_channel_connected_effective_id(), ast_channel_context(), ast_channel_creationtime(), ast_channel_data(), ast_channel_dialed(), ast_channel_exten(), ast_channel_get_bridge(), ast_channel_get_by_name(), ast_channel_get_stream_topology(), ast_channel_language(), ast_channel_linkedid(), ast_channel_lock, ast_channel_name(), ast_channel_nativeformats(), ast_channel_pickupgroup(), ast_channel_priority(), ast_channel_readformat(), ast_channel_readtrans(), ast_channel_tech(), ast_channel_uniqueid(), ast_channel_unlock, ast_channel_unref, ast_channel_varshead(), ast_channel_whentohangup(), ast_channel_writeformat(), ast_channel_writetrans(), ast_cli(), ast_codec_media_type2str(), ast_complete_channels(), ast_format_cap_get_names(), AST_FORMAT_CAP_NAMES_LEN, ast_format_get_name(), ast_free, AST_LIST_TRAVERSE, ast_state2str(), ast_str_alloca, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_strlen(), ast_str_thread_get(), ast_stream_get_formats(), ast_stream_get_group(), ast_stream_get_metadata_list(), ast_stream_get_name(), ast_stream_get_state(), ast_stream_get_type(), ast_stream_state2str(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), ast_translate_path_to_str(), ast_tvnow(), ast_tvzero(), ast_var_name(), ast_var_value(), ast_variables_destroy(), ast_bridge::callid, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, ast_cli_args::line, min, ast_cli_args::n, name, ast_variable::name, ast_variable::next, NULL, ast_cli_args::pos, S_COR, S_OR, type, ast_bridge::uniqueid, ast_cli_entry::usage, ast_variable::value, var, and ast_cli_args::word.

{
   struct ast_channel *chan;
   struct timeval now;
   char cdrtime[256];
   struct ast_str *obuf;/*!< Buffer for CDR variables. */
   struct ast_str *output;/*!< Accumulation buffer for all output. */
   long elapsed_seconds=0;
   int hour=0, min=0, sec=0;
   struct ast_var_t *var;
   struct ast_str *write_transpath = ast_str_alloca(256);
   struct ast_str *read_transpath = ast_str_alloca(256);
   struct ast_str *codec_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
   struct ast_bridge *bridge;
   ast_callid callid;
   char callid_buf[32];
   int stream_num;

   switch (cmd) {
   case CLI_INIT:
      e->command = "core show channel";
      e->usage =
         "Usage: core show channel <channel>\n"
         "       Shows lots of information about the specified channel.\n";
      return NULL;
   case CLI_GENERATE:
      return ast_complete_channels(a->line, a->word, a->pos, a->n, 3);
   }

   if (a->argc != 4) {
      return CLI_SHOWUSAGE;
   }

   obuf = ast_str_thread_get(&ast_str_thread_global_buf, 16);
   if (!obuf) {
      return CLI_FAILURE;
   }

   chan = ast_channel_get_by_name(a->argv[3]);
   if (!chan) {
      ast_cli(a->fd, "%s is not a known channel\n", a->argv[3]);

      return CLI_SUCCESS;
   }

   output = ast_str_create(8192);
   if (!output) {
      ast_channel_unref(chan);

      return CLI_FAILURE;
   }

   now = ast_tvnow();
   ast_channel_lock(chan);

   if (!ast_tvzero(ast_channel_creationtime(chan))) {
      elapsed_seconds = now.tv_sec - ast_channel_creationtime(chan).tv_sec;
      hour = elapsed_seconds / 3600;
      min = (elapsed_seconds % 3600) / 60;
      sec = elapsed_seconds % 60;
      snprintf(cdrtime, sizeof(cdrtime), "%dh%dm%ds", hour, min, sec);
   } else {
      strcpy(cdrtime, "N/A");
   }

   ast_translate_path_to_str(ast_channel_writetrans(chan), &write_transpath);
   ast_translate_path_to_str(ast_channel_readtrans(chan), &read_transpath);

   bridge = ast_channel_get_bridge(chan);
   callid_buf[0] = '\0';
   callid = ast_channel_callid(chan);
   if (callid) {
      ast_callid_strnprint(callid_buf, sizeof(callid_buf), callid);
   }

   ast_str_append(&output, 0,
      " -- General --\n"
      "           Name: %s\n"
      "           Type: %s\n"
      "       UniqueID: %s\n"
      "       LinkedID: %s\n"
      "      Caller ID: %s\n"
      " Caller ID Name: %s\n"
      "Connected Line ID: %s\n"
      "Connected Line ID Name: %s\n"
      "Eff. Connected Line ID: %s\n"
      "Eff. Connected Line ID Name: %s\n"
      "    DNID Digits: %s\n"
      "       Language: %s\n"
      "          State: %s (%u)\n"
      "  NativeFormats: %s\n"
      "    WriteFormat: %s\n"
      "     ReadFormat: %s\n"
      " WriteTranscode: %s %s\n"
      "  ReadTranscode: %s %s\n"
      " Time to Hangup: %ld\n"
      "   Elapsed Time: %s\n"
      "      Bridge ID: %s\n"
      " --   PBX   --\n"
      "        Context: %s\n"
      "      Extension: %s\n"
      "       Priority: %d\n"
      "     Call Group: %llu\n"
      "   Pickup Group: %llu\n"
      "    Application: %s\n"
      "           Data: %s\n"
      " Call Identifer: %s\n",
      ast_channel_name(chan),
      ast_channel_tech(chan)->type,
      ast_channel_uniqueid(chan),
      ast_channel_linkedid(chan),
      S_COR(ast_channel_caller(chan)->id.number.valid,
            ast_channel_caller(chan)->id.number.str, "(N/A)"),
      S_COR(ast_channel_caller(chan)->id.name.valid,
            ast_channel_caller(chan)->id.name.str, "(N/A)"),
      S_COR(ast_channel_connected(chan)->id.number.valid,
            ast_channel_connected(chan)->id.number.str, "(N/A)"),
      S_COR(ast_channel_connected(chan)->id.name.valid,
            ast_channel_connected(chan)->id.name.str, "(N/A)"),
      S_COR(ast_channel_connected_effective_id(chan).number.valid,
            ast_channel_connected_effective_id(chan).number.str, "(N/A)"),
      S_COR(ast_channel_connected_effective_id(chan).name.valid,
            ast_channel_connected_effective_id(chan).name.str, "(N/A)"),
      S_OR(ast_channel_dialed(chan)->number.str, "(N/A)"),
      ast_channel_language(chan),
      ast_state2str(ast_channel_state(chan)),
      ast_channel_state(chan),
      ast_format_cap_get_names(ast_channel_nativeformats(chan), &codec_buf),
      ast_format_get_name(ast_channel_writeformat(chan)),
      ast_format_get_name(ast_channel_readformat(chan)),
      ast_str_strlen(write_transpath) ? "Yes" : "No",
      ast_str_buffer(write_transpath),
      ast_str_strlen(read_transpath) ? "Yes" : "No",
      ast_str_buffer(read_transpath),
      (long)ast_channel_whentohangup(chan)->tv_sec,
      cdrtime,
      bridge ? bridge->uniqueid : "(Not bridged)",
      ast_channel_context(chan),
      ast_channel_exten(chan),
      ast_channel_priority(chan),
      ast_channel_callgroup(chan),
      ast_channel_pickupgroup(chan),
      S_OR(ast_channel_appl(chan), "(N/A)"),
      S_OR(ast_channel_data(chan), "(Empty)"),
      S_OR(callid_buf, "(None)")
      );

   ast_str_append(&output, 0, "      Variables:\n");

   AST_LIST_TRAVERSE(ast_channel_varshead(chan), var, entries) {
      ast_str_append(&output, 0, "%s=%s\n", ast_var_name(var), ast_var_value(var));
   }

   if (!(ast_channel_tech(chan)->properties & AST_CHAN_TP_INTERNAL)
      && ast_cdr_serialize_variables(ast_channel_name(chan), &obuf, '=', '\n')) {
      ast_str_append(&output, 0, "  CDR Variables:\n%s\n", ast_str_buffer(obuf));
   }

   ast_str_append(&output, 0, " -- Streams --\n");
   for (stream_num = 0; stream_num < ast_stream_topology_get_count(ast_channel_get_stream_topology(chan)); stream_num++) {
      struct ast_stream *stream = ast_stream_topology_get_stream(ast_channel_get_stream_topology(chan), stream_num);
      struct ast_variable *metadata = ast_stream_get_metadata_list(stream);

      ast_str_append(&output, 0,
         "Name: %s\n"
         "    Type: %s\n"
         "    State: %s\n"
         "    Group: %d\n"
         "    Formats: %s\n"
         "    Metadata:\n",
         ast_stream_get_name(stream),
         ast_codec_media_type2str(ast_stream_get_type(stream)),
         ast_stream_state2str(ast_stream_get_state(stream)),
         ast_stream_get_group(stream),
         ast_format_cap_get_names(ast_stream_get_formats(stream), &codec_buf)
         );

      if (metadata) {
         struct ast_variable *v;
         for(v = metadata; v; v = v->next) {
            ast_str_append(&output, 0, "        %s: %s\n", v->name, v->value);
         }
         ast_variables_destroy(metadata);
      }
   }

   ast_channel_unlock(chan);

   ast_cli(a->fd, "%s", ast_str_buffer(output));
   ast_free(output);

   ao2_cleanup(bridge);
   ast_channel_unref(chan);

   return CLI_SUCCESS;
}

handle_showuptime()

static char* handle_showuptime ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 938 of file main/cli.c.

References ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ast_lastreloadtime, ast_startuptime, ast_tvnow(), ast_tvsub(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, NULL, print_uptimestr(), and ast_cli_entry::usage.

{
   struct timeval curtime = ast_tvnow();
   int printsec;

   switch (cmd) {
   case CLI_INIT:
      e->command = "core show uptime [seconds]";
      e->usage =
         "Usage: core show uptime [seconds]\n"
         "       Shows Asterisk uptime information.\n"
         "       The seconds word returns the uptime in seconds only.\n";
      return NULL;

   case CLI_GENERATE:
      return NULL;
   }
   /* regular handler */
   if (a->argc == e->args && !strcasecmp(a->argv[e->args-1],"seconds"))
      printsec = 1;
   else if (a->argc == e->args-1)
      printsec = 0;
   else
      return CLI_SHOWUSAGE;
   if (ast_startuptime.tv_sec) {
      print_uptimestr(a->fd, ast_tvsub(curtime, ast_startuptime), "System uptime: ", printsec);
   }
   if (ast_lastreloadtime.tv_sec) {
      print_uptimestr(a->fd, ast_tvsub(curtime, ast_lastreloadtime), "Last reload: ", printsec);
   }
   return CLI_SUCCESS;
}

handle_softhangup()

static char* handle_softhangup ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1195 of file main/cli.c.

References ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ast_channel_get_by_name(), ast_channel_iterator_all_new(), ast_channel_iterator_destroy(), ast_channel_iterator_next(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_channel_unref, ast_cli(), ast_cli_complete(), ast_complete_channels(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, c, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, ast_cli_args::line, ast_cli_args::n, NULL, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

{
   struct ast_channel *c = NULL;
   static const char * const completions[] = { "all", NULL };
   char *complete;

   switch (cmd) {
   case CLI_INIT:
      e->command = "channel request hangup";
      e->usage =
         "Usage: channel request hangup <channel>|<all>\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"
         "       If 'all' is specified instead of a channel name, all channels\n"
         "       will see the hangup request.\n";
      return NULL;
   case CLI_GENERATE:
      if (a->pos != e->args) {
         return NULL;
      }
      complete = ast_cli_complete(a->word, completions, a->n);
      if (!complete) {
         complete = ast_complete_channels(a->line, a->word, a->pos, a->n - 1, e->args);
      }
      return complete;
   }

   if (a->argc != 4) {
      return CLI_SHOWUSAGE;
   }

   if (!strcasecmp(a->argv[3], "all")) {
      struct ast_channel_iterator *iter = NULL;
      if (!(iter = ast_channel_iterator_all_new())) {
         return CLI_FAILURE;
      }
      for (; iter && (c = ast_channel_iterator_next(iter)); ast_channel_unref(c)) {
         ast_channel_lock(c);
         ast_cli(a->fd, "Requested Hangup on channel '%s'\n", ast_channel_name(c));
         ast_softhangup(c, AST_SOFTHANGUP_EXPLICIT);
         ast_channel_unlock(c);
      }
      ast_channel_iterator_destroy(iter);
   } else if ((c = ast_channel_get_by_name(a->argv[3]))) {
      ast_channel_lock(c);
      ast_cli(a->fd, "Requested Hangup on channel '%s'\n", ast_channel_name(c));
      ast_softhangup(c, AST_SOFTHANGUP_EXPLICIT);
      ast_channel_unlock(c);
      c = ast_channel_unref(c);
   } else {
      ast_cli(a->fd, "%s is not a known channel\n", a->argv[3]);
   }

   return CLI_SUCCESS;
}

handle_trace()

static char* handle_trace ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 630 of file main/cli.c.

References ast_cli_args::argv, ast_module_helper(), AST_MODULE_HELPER_RUNNING, ast_strdup, ast_strlen_zero, CLI_GENERATE, CLI_INIT, ast_cli_entry::command, complete_number(), handle_debug_or_trace(), ast_cli_args::line, ast_cli_args::n, NULL, ast_cli_args::pos, S_OR, TRACE_HANDLER, ast_cli_entry::usage, and ast_cli_args::word.

{
   int atleast = 0;
   const char *argv3 = a->argv ? S_OR(a->argv[3], "") : "";

   switch (cmd) {
   case CLI_INIT:
      e->command = "core set trace";
      e->usage =
         "Usage: core set trace [atleast] <level> [module]\n"
         "       core set trace off\n"
         "\n"
         "       Sets level of trace messages to be displayed or\n"
         "       sets a module name to display trace messages from.\n"
         "       0 or off means no messages should be displayed.\n";
      return NULL;

   case CLI_GENERATE:
      if (!strcasecmp(argv3, "atleast")) {
         atleast = 1;
      }
      if (a->pos == 3 || (a->pos == 4 && atleast)) {
         const char *pos = a->pos == 3 ? argv3 : S_OR(a->argv[4], "");
         int numbermatch = (ast_strlen_zero(pos) || strchr("123456789", pos[0])) ? 0 : 21;

         if (a->n < 21 && numbermatch == 0) {
            return complete_number(pos, 0, 0x7fffffff, a->n);
         } else if (pos[0] == '0') {
            if (a->n == 0) {
               return ast_strdup("0");
            }
         } else if (a->n == (21 - numbermatch)) {
            if (a->pos == 3 && !strncasecmp(argv3, "off", strlen(argv3))) {
               return ast_strdup("off");
            } else if (a->pos == 3 && !strncasecmp(argv3, "atleast", strlen(argv3))) {
               return ast_strdup("atleast");
            }
         } else if (a->n == (22 - numbermatch) && a->pos == 3 && ast_strlen_zero(argv3)) {
            return ast_strdup("atleast");
         }
      } else if ((a->pos == 4 && !atleast && strcasecmp(argv3, "off") && strcasecmp(argv3, "channel"))
         || (a->pos == 5 && atleast)) {
         return ast_module_helper(a->line, a->word, a->pos, a->n, a->pos, AST_MODULE_HELPER_RUNNING);
      }
      return NULL;
   }
   /* all the above return, so we proceed with the handler.
    * we are guaranteed to be called with argc >= e->args;
    */

   return handle_debug_or_trace(TRACE_HANDLER, e, cmd, a);
}

handle_unload()

static char* handle_unload ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 808 of file main/cli.c.

References ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ast_cli(), AST_FORCE_FIRM, AST_FORCE_HARD, AST_FORCE_SOFT, ast_module_helper(), AST_MODULE_HELPER_UNLOAD, ast_unload_resource(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, ast_cli_args::line, ast_cli_args::n, NULL, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

{
   /* "module unload mod_1 [mod_2 .. mod_N]" */
   int x;
   int force = AST_FORCE_SOFT;
   const char *s;

   switch (cmd) {
   case CLI_INIT:
      e->command = "module unload";
      e->usage =
         "Usage: module unload [-f|-h] <module_1> [<module_2> ... ]\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";
      return NULL;

   case CLI_GENERATE:
      return ast_module_helper(a->line, a->word, a->pos, a->n, a->pos, AST_MODULE_HELPER_UNLOAD);
   }
   if (a->argc < e->args + 1)
      return CLI_SHOWUSAGE;
   x = e->args;   /* first argument */
   s = a->argv[x];
   if (s[0] == '-') {
      if (s[1] == 'f')
         force = AST_FORCE_FIRM;
      else if (s[1] == 'h')
         force = AST_FORCE_HARD;
      else
         return CLI_SHOWUSAGE;
      if (a->argc < e->args + 2) /* need at least one module name */
         return CLI_SHOWUSAGE;
      x++;  /* skip this argument */
   }

   for (; x < a->argc; x++) {
      if (ast_unload_resource(a->argv[x], force)) {
         ast_cli(a->fd, "Unable to unload resource %s\n", a->argv[x]);
         return CLI_FAILURE;
      }
      ast_cli(a->fd, "Unloaded %s\n", a->argv[x]);
   }

   return CLI_SUCCESS;
}

handle_verbose()

static char* handle_verbose ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 683 of file main/cli.c.

References ast_cli_args::argc, ast_cli_entry::args, ast_cli_args::argv, ast_strdup, ast_strlen_zero, ast_verb_console_get(), ast_verb_console_set(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_number(), ast_cli_args::n, NULL, ast_cli_args::pos, S_OR, status_debug_verbose(), ast_cli_entry::usage, and VERBOSE_HANDLER.

{
   int oldval;
   int newlevel;
   int atleast = 0;
   int silent = 0;
   const char *argv3 = a->argv ? S_OR(a->argv[3], "") : "";

   switch (cmd) {
   case CLI_INIT:
      e->command = "core set verbose";
      e->usage =
         "Usage: core set verbose [atleast] <level> [silent]\n"
         "       core set verbose off\n"
         "\n"
         "       Sets level of verbose messages to be displayed.\n"
         "       0 or off means no verbose messages should be displayed.\n"
         "       The silent option means the command does not report what\n"
         "       happened to the verbose level.\n"
         "       Equivalent to -v[v[...]] on startup\n";
      return NULL;

   case CLI_GENERATE:
      if (!strcasecmp(argv3, "atleast")) {
         atleast = 1;
      }
      if (a->pos == 3 || (a->pos == 4 && atleast)) {
         const char *pos = a->pos == 3 ? argv3 : S_OR(a->argv[4], "");
         int numbermatch = (ast_strlen_zero(pos) || strchr("123456789", pos[0])) ? 0 : 21;

         if (a->n < 21 && numbermatch == 0) {
            return complete_number(pos, 0, 0x7fffffff, a->n);
         } else if (pos[0] == '0') {
            if (a->n == 0) {
               return ast_strdup("0");
            }
         } else if (a->n == (21 - numbermatch)) {
            if (a->pos == 3 && !strncasecmp(argv3, "off", strlen(argv3))) {
               return ast_strdup("off");
            } else if (a->pos == 3 && !strncasecmp(argv3, "atleast", strlen(argv3))) {
               return ast_strdup("atleast");
            }
         } else if (a->n == (22 - numbermatch) && a->pos == 3 && ast_strlen_zero(argv3)) {
            return ast_strdup("atleast");
         }
      } else if ((a->pos == 4 && !atleast && strcasecmp(argv3, "off"))
         || (a->pos == 5 && atleast)) {
         const char *pos = S_OR(a->argv[a->pos], "");

         if (a->n == 0 && !strncasecmp(pos, "silent", strlen(pos))) {
            return ast_strdup("silent");
         }
      }
      return NULL;
   }
   /* all the above return, so we proceed with the handler.
    * we are guaranteed to be called with argc >= e->args;
    */

   if (a->argc <= e->args) {
      return CLI_SHOWUSAGE;
   }

   if (a->argc == e->args + 1 && !strcasecmp(a->argv[e->args], "off")) {
      newlevel = 0;
   } else {
      if (!strcasecmp(a->argv[e->args], "atleast")) {
         atleast = 1;
      }
      if (a->argc == e->args + atleast + 2
         && !strcasecmp(a->argv[e->args + atleast + 1], "silent")) {
         silent = 1;
      }
      if (a->argc != e->args + atleast + silent + 1) {
         return CLI_SHOWUSAGE;
      }
      if (sscanf(a->argv[e->args + atleast], "%30d", &newlevel) != 1) {
         return CLI_SHOWUSAGE;
      }
   }

   /* Update verbose level */
   oldval = ast_verb_console_get();
   if (!atleast || newlevel > oldval) {
      ast_verb_console_set(newlevel);
   } else {
      newlevel = oldval;
   }

   if (silent) {
      /* Be silent after setting the level. */
      return CLI_SUCCESS;
   }

   /* Report verbose level status */
   status_debug_verbose(a, VERBOSE_HANDLER, oldval, newlevel);

   return CLI_SUCCESS;
}

help1()

static char* help1 ( int  fd, const char *const  match[], int  locked  )

static

helper for final part of handle_help if locked = 1, assume the list is already locked

Definition at line 2522 of file main/cli.c.

References ast_cli_entry::_full_cmd, ast_cli(), ast_join, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, cli_next(), CLI_SUCCESS, len(), NULL, S_OR, and ast_cli_entry::summary.

Referenced by handle_help().

{
   char matchstr[80] = "";
   struct ast_cli_entry *e = NULL;
   int len = 0;
   int found = 0;

   if (match) {
      ast_join(matchstr, sizeof(matchstr), match);
      len = strlen(matchstr);
   }
   if (!locked)
      AST_RWLIST_RDLOCK(&helpers);
   while ( (e = cli_next(e)) ) {
      /* Hide commands that start with '_' */
      if (e->_full_cmd[0] == '_')
         continue;
      if (match && strncasecmp(matchstr, e->_full_cmd, len))
         continue;
      ast_cli(fd, "%-30s -- %s\n", e->_full_cmd,
         S_OR(e->summary, "<no description available>"));
      found++;
   }
   if (!locked)
      AST_RWLIST_UNLOCK(&helpers);
   if (!found && matchstr[0])
      ast_cli(fd, "No such command '%s'.\n", matchstr);
   return CLI_SUCCESS;
}

is_prefix()

static char* is_prefix ( const char *  word, const char *  token, int  pos, int *  actual  )

static

if word is a valid prefix for token, returns the pos-th match as a malloced string, or NULL otherwise. Always tell in *actual how many matches we got.

Definition at line 2266 of file main/cli.c.

References ast_strdup, ast_strdupa, ast_strlen_zero, cli_rsvd, NULL, strsep(), and t1.

Referenced by __ast_cli_generator().

{
   int lw;
   char *s, *t1;

   *actual = 0;
   if (ast_strlen_zero(token))
      return NULL;
   if (ast_strlen_zero(word))
      word = "";  /* dummy */
   lw = strlen(word);
   if (strcspn(word, cli_rsvd) != lw)
      return NULL;   /* no match if word has reserved chars */
   if (strchr(cli_rsvd, token[0]) == NULL) { /* regular match */
      if (strncasecmp(token, word, lw))   /* no match */
         return NULL;
      *actual = 1;
      return (pos != 0) ? NULL : ast_strdup(token);
   }
   /* now handle regexp match */

   /* Wildcard always matches, so we never do is_prefix on them */

   t1 = ast_strdupa(token + 1);  /* copy, skipping first char */
   while (pos >= 0 && (s = strsep(&t1, cli_rsvd)) && *s) {
      if (*s == '%') /* wildcard */
         continue;
      if (strncasecmp(s, word, lw)) /* no match */
         continue;
      (*actual)++;
      if (pos-- == 0)
         return ast_strdup(s);
   }
   return NULL;
}

modlist_modentry()

static int modlist_modentry ( const char *  module, const char *  description, int  usecnt, const char *  status, const char *  like, enum ast_module_support_level  support_level  )

static

Definition at line 863 of file main/cli.c.

References ast_cli(), ast_module_support_level_to_string(), climodentryfd, MODLIST_FORMAT, and strcasestr().

Referenced by handle_modlist().

{
   /* Comparing the like with the module */
   if (strcasestr(module, like) ) {
      ast_cli(climodentryfd, MODLIST_FORMAT, module, description, usecnt,
            status, ast_module_support_level_to_string(support_level));
      return 1;
   }
   return 0;
}

more_words()

static int more_words ( const char *const *  dst )

static

returns true if there are more words to match

Definition at line 2816 of file main/cli.c.

Referenced by __ast_cli_generator().

{
   int i;
   for (i = 0; dst[i]; i++) {
      if (dst[i][0] != '[')
         return -1;
   }
   return 0;
}

parse_args()

static char* parse_args ( const char *  s, int *  argc, const char *  argv[], int  max, int *  trailingwhitespace  )

static

Definition at line 2598 of file main/cli.c.

References ast_log, ast_strdup, dummy(), LOG_WARNING, and NULL.

Referenced by __ast_cli_generator(), and ast_cli_command_full().

{
   char *duplicate, *cur;
   int x = 0;
   int quoted = 0;
   int escaped = 0;
   int whitespace = 1;
   int dummy = 0;

   if (trailingwhitespace == NULL)
      trailingwhitespace = &dummy;
   *trailingwhitespace = 0;
   if (s == NULL) /* invalid, though! */
      return NULL;
   /* make a copy to store the parsed string */
   if (!(duplicate = ast_strdup(s)))
      return NULL;

   cur = duplicate;

   /* Remove leading spaces from the command */
   while (isspace(*s)) {
      cur++;
      s++;
   }

   /* scan the original string copying into cur when needed */
   for (; *s ; s++) {
      if (x >= max - 1) {
         ast_log(LOG_WARNING, "Too many arguments, truncating at %s\n", s);
         break;
      }
      if (*s == '"' && !escaped) {
         quoted = !quoted;
         if (quoted && whitespace) {
            /* start a quoted string from previous whitespace: new argument */
            argv[x++] = cur;
            whitespace = 0;
         }
      } else if ((*s == ' ' || *s == '\t') && !(quoted || escaped)) {
         /* If we are not already in whitespace, and not in a quoted string or
            processing an escape sequence, and just entered whitespace, then
            finalize the previous argument and remember that we are in whitespace
         */
         if (!whitespace) {
            *cur++ = '\0';
            whitespace = 1;
         }
      } else if (*s == '\\' && !escaped) {
         escaped = 1;
      } else {
         if (whitespace) {
            /* we leave whitespace, and are not quoted. So it's a new argument */
            argv[x++] = cur;
            whitespace = 0;
         }
         *cur++ = *s;
         escaped = 0;
      }
   }
   /* Null terminate */
   *cur++ = '\0';
   /* XXX put a NULL in the last argument, because some functions that take
    * the array may want a null-terminated array.
    * argc still reflects the number of non-NULL entries.
    */
   argv[x] = NULL;
   *argc = x;
   *trailingwhitespace = whitespace;
   return duplicate;
}

print_uptimestr()

static void print_uptimestr ( int  fd, struct timeval  timeval, const char *  prefix, int  printsec  )

static

Definition at line 876 of file main/cli.c.

References ast_cli(), ast_str_alloca, ast_str_append(), ast_str_buffer(), ast_str_strlen(), DAY, ESS, HOUR, MINUTE, NEEDCOMMA, out, WEEK, and YEAR.

Referenced by ast_cli_print_timestr_fromseconds(), handle_showcalls(), and handle_showuptime().

{
   int x; /* the main part - years, weeks, etc. */
   struct ast_str *out;

#define SECOND (1)
#define MINUTE (SECOND*60)
#define HOUR (MINUTE*60)
#define DAY (HOUR*24)
#define WEEK (DAY*7)
#define YEAR (DAY*365)
#define NEEDCOMMA(x) ((x) ? ", " : "") /* define if we need a comma */
   if (timeval.tv_sec < 0) /* invalid, nothing to show */
      return;

   if (printsec)  {  /* plain seconds output */
      ast_cli(fd, "%s%lu\n", prefix, (u_long)timeval.tv_sec);
      return;
   }
   out = ast_str_alloca(256);
   if (timeval.tv_sec > YEAR) {
      x = (timeval.tv_sec / YEAR);
      timeval.tv_sec -= (x * YEAR);
      ast_str_append(&out, 0, "%d year%s%s", x, ESS(x), NEEDCOMMA(timeval.tv_sec));
   }
   if (timeval.tv_sec > WEEK) {
      x = (timeval.tv_sec / WEEK);
      timeval.tv_sec -= (x * WEEK);
      ast_str_append(&out, 0, "%d week%s%s", x, ESS(x), NEEDCOMMA(timeval.tv_sec));
   }
   if (timeval.tv_sec > DAY) {
      x = (timeval.tv_sec / DAY);
      timeval.tv_sec -= (x * DAY);
      ast_str_append(&out, 0, "%d day%s%s", x, ESS(x), NEEDCOMMA(timeval.tv_sec));
   }
   if (timeval.tv_sec > HOUR) {
      x = (timeval.tv_sec / HOUR);
      timeval.tv_sec -= (x * HOUR);
      ast_str_append(&out, 0, "%d hour%s%s", x, ESS(x), NEEDCOMMA(timeval.tv_sec));
   }
   if (timeval.tv_sec > MINUTE) {
      x = (timeval.tv_sec / MINUTE);
      timeval.tv_sec -= (x * MINUTE);
      ast_str_append(&out, 0, "%d minute%s%s", x, ESS(x), NEEDCOMMA(timeval.tv_sec));
   }
   x = timeval.tv_sec;
   if (x > 0 || ast_str_strlen(out) == 0) {
      /* if there is nothing, print 0 seconds */
      ast_str_append(&out, 0, "%d second%s", x, ESS(x));
   }
   ast_cli(fd, "%s%s\n", prefix, ast_str_buffer(out));
}

remove_shutdown_command()

static void remove_shutdown_command ( struct ast_cli_entry *  e )

static

Definition at line 2390 of file main/cli.c.

References ast_rwlock_unlock, ast_rwlock_wrlock, AST_VECTOR_ELEM_CLEANUP_NOOP, AST_VECTOR_REMOVE_ELEM_UNORDERED, and shutdown_commands_lock.

Referenced by ast_cli_unregister().

{
   ast_rwlock_wrlock(&shutdown_commands_lock);
   AST_VECTOR_REMOVE_ELEM_UNORDERED(&shutdown_commands, e, AST_VECTOR_ELEM_CLEANUP_NOOP);
   ast_rwlock_unlock(&shutdown_commands_lock);
}

set_full_cmd()

static int set_full_cmd ( struct ast_cli_entry *  e )

static

initialize the _full_cmd string and related parameters, return 0 on success, -1 on error.

Definition at line 2046 of file main/cli.c.

References ast_cli_entry::_full_cmd, ast_cli_entry::args, ast_join, ast_log, ast_strdup, buf, cli_rsvd, ast_cli_entry::cmda, ast_cli_entry::cmdlen, and LOG_WARNING.

Referenced by __ast_cli_register().

{
   int i;
   char buf[80];

   ast_join(buf, sizeof(buf), e->cmda);
   e->_full_cmd = ast_strdup(buf);
   if (!e->_full_cmd) {
      ast_log(LOG_WARNING, "-- cannot allocate <%s>\n", buf);
      return -1;
   }
   e->cmdlen = strcspn(e->_full_cmd, cli_rsvd);
   for (i = 0; e->cmda[i]; i++)
      ;
   e->args = i;
   return 0;
}

status_debug_verbose()

static void status_debug_verbose ( struct ast_cli_args *  a, int  handler, int  old_val, int  cur_val  )

static

Definition at line 407 of file main/cli.c.

References ast_cli(), DEBUG_HANDLER, ast_cli_args::fd, TRACE_HANDLER, and VERBOSE_HANDLER.

Referenced by handle_debug_or_trace(), and handle_verbose().

{
   char was_buf[30];
   const char *was;
   const char *what = "";

   switch(handler) {
   case DEBUG_HANDLER:
      what = "Core debug";
      break;
   case TRACE_HANDLER:
      what = "Core trace";
      break;
   case VERBOSE_HANDLER:
      what = "Console verbose";
      break;
   }

   if (old_val) {
      snprintf(was_buf, sizeof(was_buf), "%d", old_val);
      was = was_buf;
   } else {
      was = "OFF";
   }

   if (old_val == cur_val) {
      ast_cli(a->fd, "%s is still %s.\n", what, was);
   } else {
      char now_buf[30];
      const char *now;

      if (cur_val) {
         snprintf(now_buf, sizeof(now_buf), "%d", cur_val);
         now = now_buf;
      } else {
         now = "OFF";
      }

      ast_cli(a->fd, "%s was %s and is now %s.\n", what, was, now);
   }
}

word_match()

static int word_match ( const char *  cmd, const char *  cli_word  )

static

match a word in the CLI entry. returns -1 on mismatch, 0 on match of an optional word, 1 on match of a full word.

The pattern can be any_word match for equal [foo|bar|baz] optionally, one of these words {foo|bar|baz} exactly, one of these words % any word

Definition at line 2227 of file main/cli.c.

References ast_strlen_zero, cli_rsvd, and strcasestr().

Referenced by __ast_cli_generator(), and find_cli().

{
   int l;
   char *pos;

   if (ast_strlen_zero(cmd) || ast_strlen_zero(cli_word))
      return -1;
   if (!strchr(cli_rsvd, cli_word[0])) /* normal match */
      return (strcasecmp(cmd, cli_word) == 0) ? 1 : -1;
   l = strlen(cmd);
   /* wildcard match - will extend in the future */
   if (l > 0 && cli_word[0] == '%') {
      return 1;   /* wildcard */
   }

   /* Start a search for the command entered against the cli word in question */
   pos = strcasestr(cli_word, cmd);
   while (pos) {

      /*
       *Check if the word matched with is surrounded by reserved characters on both sides
       * and isn't at the beginning of the cli_word since that would make it check in a location we shouldn't know about.
       * If it is surrounded by reserved chars and isn't at the beginning, it's a match.
       */
      if (pos != cli_word && strchr(cli_rsvd, pos[-1]) && strchr(cli_rsvd, pos[l])) {
         return 1;   /* valid match */
      }

      /* Ok, that one didn't match, strcasestr to the next appearance of the command and start over.*/
      pos = strcasestr(pos + 1, cmd);
   }
   /* If no matches were found over the course of the while loop, we hit the end of the string. It's a mismatch. */
   return -1;
}

Variable Documentation

ast_cli_buf

struct ast_threadstorage ast_cli_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_ast_cli_buf , .custom_init = NULL , }

static

Definition at line 110 of file main/cli.c.

Referenced by AST_VECTOR().

cli_cli

struct ast_cli_entry cli_cli[]

static

Definition at line 1984 of file main/cli.c.

cli_default_perm

int cli_default_perm = 1

static

Default permissions value 1=Permit 0=Deny.

Definition at line 87 of file main/cli.c.

Referenced by ast_cli_perms_init(), and cli_has_permissions().

cli_perms

struct cli_perms cli_perms = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

static

cli_rsvd

const char cli_rsvd[] = "[]{}|*%"

static

Some regexp characters in cli arguments are reserved and used as separators.

Definition at line 2040 of file main/cli.c.

Referenced by is_prefix(), set_full_cmd(), and word_match().

climodentryfd

int climodentryfd = -1

static

Definition at line 861 of file main/cli.c.

Referenced by handle_modlist(), and modlist_modentry().

climodentrylock

ast_mutex_t climodentrylock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

static

Definition at line 860 of file main/cli.c.

Referenced by handle_modlist().

debug_modules

struct module_level_list debug_modules = AST_RWLIST_HEAD_INIT_VALUE

static

lists of module names and their debug/trace levels

Definition at line 107 of file main/cli.c.

Referenced by handle_debug_or_trace().

helpers

struct helpers helpers = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

static

perms_config

const char perms_config[] = "cli_permissions.conf"

static

CLI permissions config file.

Definition at line 85 of file main/cli.c.

Referenced by ast_cli_perms_init().

permsconfiglock

ast_mutex_t permsconfiglock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

static

mutex used to prevent a user from running the 'cli reload permissions' command while it is already running.

Definition at line 91 of file main/cli.c.

Referenced by ast_cli_perms_init().

shutdown_commands_lock

ast_rwlock_t shutdown_commands_lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} }

static

Definition at line 112 of file main/cli.c.

Referenced by allowed_on_shutdown(), ast_cli_allow_at_shutdown(), and remove_shutdown_command().

trace_modules

struct module_level_list trace_modules = AST_RWLIST_HEAD_INIT_VALUE

static

Definition at line 108 of file main/cli.c.

Referenced by handle_debug_or_trace().