1999-12-19 22:38:55 +00:00
|
|
|
/*
|
2005-09-14 20:46:50 +00:00
|
|
|
* Asterisk -- An open source telephony toolkit.
|
1999-12-19 22:38:55 +00:00
|
|
|
*
|
2006-02-14 22:44:20 +00:00
|
|
|
* Copyright (C) 1999 - 2006, Digium, Inc.
|
1999-12-19 22:38:55 +00:00
|
|
|
*
|
2004-09-03 03:44:35 +00:00
|
|
|
* Mark Spencer <markster@digium.com>
|
1999-12-19 22:38:55 +00:00
|
|
|
*
|
2005-09-14 20:46:50 +00:00
|
|
|
* See http://www.asterisk.org for more information about
|
|
|
|
* the Asterisk project. Please do not directly contact
|
|
|
|
* any of the maintainers of this project for assistance;
|
|
|
|
* the project provides a web site, mailing lists and IRC
|
|
|
|
* channels for your use.
|
|
|
|
*
|
1999-12-19 22:38:55 +00:00
|
|
|
* This program is free software, distributed under the terms of
|
2005-09-14 20:46:50 +00:00
|
|
|
* the GNU General Public License Version 2. See the LICENSE file
|
|
|
|
* at the top of the source tree.
|
|
|
|
*/
|
|
|
|
|
2005-10-24 20:12:06 +00:00
|
|
|
/*! \file
|
2005-09-14 20:46:50 +00:00
|
|
|
*
|
2005-10-24 20:12:06 +00:00
|
|
|
* \brief Standard Command Line Interface
|
2005-12-30 21:18:06 +00:00
|
|
|
*
|
|
|
|
* \author Mark Spencer <markster@digium.com>
|
1999-12-19 22:38:55 +00:00
|
|
|
*/
|
|
|
|
|
2006-06-07 18:54:56 +00:00
|
|
|
#include "asterisk.h"
|
|
|
|
|
|
|
|
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
|
|
|
|
|
2007-11-20 22:18:21 +00:00
|
|
|
#include "asterisk/_private.h"
|
2007-11-20 23:16:15 +00:00
|
|
|
#include "asterisk/paths.h" /* use ast_config_AST_MODULE_DIR */
|
2005-04-22 13:11:34 +00:00
|
|
|
#include <sys/signal.h>
|
|
|
|
#include <signal.h>
|
|
|
|
#include <ctype.h>
|
This is the first round of removing applications that were marked as deprecated
in the 1.2 release. They are being removed from the trunk and will not be in
the next major release. The following is a list of the applications that are
being removed in this commit:
Curl, Cut, Sort, DBPut, DBGet, ENUMLookup, Eval
GetGroupCount, SetGroup, CheckGroup, GetGroupMatchCount
MD5, MD5Check, Math, SetCIDName, SetCIDNum, SetRDNIS, SetCallerID
TXTCIDName, AbsoluteTimeout, DigitTimeout, ResponseTimeout, SetAccount
SetLanguage, SetVar (renamed to Set)
These changes also include moving the "group show channels" cli command from
app_groupcount.c to cli.c.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@7379 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2005-12-07 15:36:55 +00:00
|
|
|
#include <regex.h>
|
2008-12-01 18:52:14 +00:00
|
|
|
#include <pwd.h>
|
|
|
|
#include <grp.h>
|
2005-04-22 13:11:34 +00:00
|
|
|
|
2005-04-21 06:02:45 +00:00
|
|
|
#include "asterisk/cli.h"
|
2006-03-28 22:25:08 +00:00
|
|
|
#include "asterisk/linkedlists.h"
|
2005-04-21 06:02:45 +00:00
|
|
|
#include "asterisk/module.h"
|
|
|
|
#include "asterisk/pbx.h"
|
|
|
|
#include "asterisk/channel.h"
|
|
|
|
#include "asterisk/utils.h"
|
This is the first round of removing applications that were marked as deprecated
in the 1.2 release. They are being removed from the trunk and will not be in
the next major release. The following is a list of the applications that are
being removed in this commit:
Curl, Cut, Sort, DBPut, DBGet, ENUMLookup, Eval
GetGroupCount, SetGroup, CheckGroup, GetGroupMatchCount
MD5, MD5Check, Math, SetCIDName, SetCIDNum, SetRDNIS, SetCallerID
TXTCIDName, AbsoluteTimeout, DigitTimeout, ResponseTimeout, SetAccount
SetLanguage, SetVar (renamed to Set)
These changes also include moving the "group show channels" cli command from
app_groupcount.c to cli.c.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@7379 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2005-12-07 15:36:55 +00:00
|
|
|
#include "asterisk/app.h"
|
2005-04-21 06:02:45 +00:00
|
|
|
#include "asterisk/lock.h"
|
2003-01-30 15:03:20 +00:00
|
|
|
#include "editline/readline/readline.h"
|
Merge team/russell/ast_verbose_threadstorage
- instead of defining a free() wrapper in a bunch of files, define it as
ast_free() in utils.h and remove the copies from all the files.
- centralize and abstract the code used for doing thread storage. The code
lives in threadstorage.h, with one function being implemented in utils.c.
This new API includes generic thread storage as well as special functions
for handling thread local dynamic length string buffers.
- update ast_inet_ntoa() to use the new threadstorage API
- update ast_state2str() to use the new threadstorage API
- update ast_cli() to use the new threadstorage API
- Modify manager_event() to use thread storage. Instead of using a buffer of
4096 characters as the workspace for building the manager event, use a thread
local dynamic string. Now there is no length limitation on the length of the
body of a manager event.
- Significantly simplify the handling of ast_verbose() ...
- Instead of using a static char buffer and a lock to make sure only one
thread can be using ast_verbose() at a time, use a thread local dynamic
string as the workspace for preparing the verbose message. Instead of
locking around the entire function, the only locking done now is when the
message has been built and is being deliviered to the list of registered
verbose message handlers.
- This function was doing a strdup() on every message passed to it and
keeping a queue of the last 200 messages in memory. This has been
completely removed. The only place this was used was that if there were
any messages in the verbose queue when a verbose handler was registered,
all of the messages in the queue would be fed to it. So, I just made sure
that the console verbose handler and the network verbose handler (for
remote asterisk consoles) were registered before any verbose messages.
pbx_gtkconsole and pbx_kdeconsole will now lose a few verbose messages at
startup, but I didn't feel the performance hit of this message queue was
worth saving the initial verbose output for these very rarely used modules.
- I have removed the last three arguments to the verbose handlers, leaving
only the string itself because they aren't needed anymore. For example,
ast_verbose had some logic for telling the verbose handler to add
a newline if the buffer was completely full. Now that the buffer can grow
as needed, this doesn't matter anymore.
- remove unused function, ast_verbose_dmesg() which was to dispatch the
message queue
- Convert the list of verbose handlers to use the linked list macros.
- add missing newline characters to a few ast_verbose() calls
- convert the list of log channels to use the linked list macros in logger.c
- fix close_logger() to close all of the files it opened for logging
- update ast_log() to use a thread local dynamic string for its workspace
for preparing log messages instead of a buffer of size BUFSIZ (8kB on my
system) allocated on the stack. The dynamic string in this case is limited
to only growing to a maximum size of BUFSIZ.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@39272 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-08-08 06:32:04 +00:00
|
|
|
#include "asterisk/threadstorage.h"
|
2010-08-12 20:17:17 +00:00
|
|
|
#include "asterisk/translate.h"
|
2005-11-05 18:58:27 +00:00
|
|
|
|
2008-12-01 18:52:14 +00:00
|
|
|
/*!
|
|
|
|
* \brief List of restrictions per user.
|
|
|
|
*/
|
|
|
|
struct cli_perm {
|
|
|
|
unsigned int permit:1; /*!< 1=Permit 0=Deny */
|
|
|
|
char *command; /*!< Command name (to apply restrictions) */
|
|
|
|
AST_LIST_ENTRY(cli_perm) list;
|
|
|
|
};
|
|
|
|
|
|
|
|
AST_LIST_HEAD_NOLOCK(cli_perm_head, cli_perm);
|
|
|
|
|
|
|
|
/*! \brief list of users to apply restrictions. */
|
|
|
|
struct usergroup_cli_perm {
|
|
|
|
int uid; /*!< User ID (-1 disabled) */
|
|
|
|
int gid; /*!< Group ID (-1 disabled) */
|
|
|
|
struct cli_perm_head *perms; /*!< List of permissions. */
|
|
|
|
AST_LIST_ENTRY(usergroup_cli_perm) list;/*!< List mechanics */
|
|
|
|
};
|
|
|
|
/*! \brief CLI permissions config file. */
|
|
|
|
static const char perms_config[] = "cli_permissions.conf";
|
|
|
|
/*! \brief Default permissions value 1=Permit 0=Deny */
|
|
|
|
static int cli_default_perm = 1;
|
|
|
|
|
|
|
|
/*! \brief mutex used to prevent a user from running the 'cli reload permissions' command while
|
|
|
|
* it is already running. */
|
|
|
|
AST_MUTEX_DEFINE_STATIC(permsconfiglock);
|
|
|
|
/*! \brief List of users and permissions. */
|
2009-06-15 17:34:30 +00:00
|
|
|
static AST_RWLIST_HEAD_STATIC(cli_perms, usergroup_cli_perm);
|
2008-12-01 18:52:14 +00:00
|
|
|
|
2007-07-23 14:21:41 +00:00
|
|
|
/*!
|
2010-03-23 14:22:27 +00:00
|
|
|
* \brief map a debug or verbose level to a module name
|
2007-07-23 14:21:41 +00:00
|
|
|
*/
|
2010-03-23 14:22:27 +00:00
|
|
|
struct module_level {
|
2007-07-23 14:21:41 +00:00
|
|
|
unsigned int level;
|
2010-03-23 14:22:27 +00:00
|
|
|
AST_RWLIST_ENTRY(module_level) entry;
|
|
|
|
char module[0];
|
2007-07-23 14:21:41 +00:00
|
|
|
};
|
|
|
|
|
2010-03-23 14:22:27 +00:00
|
|
|
AST_RWLIST_HEAD(module_level_list, module_level);
|
2007-07-23 14:21:41 +00:00
|
|
|
|
2010-03-23 14:22:27 +00:00
|
|
|
/*! list of module names and their debug levels */
|
|
|
|
static struct module_level_list debug_modules;
|
|
|
|
/*! list of module names and their verbose levels */
|
|
|
|
static struct module_level_list verbose_modules;
|
2007-07-23 14:21:41 +00:00
|
|
|
|
2006-10-19 01:00:57 +00:00
|
|
|
AST_THREADSTORAGE(ast_cli_buf);
|
2006-07-23 15:19:16 +00:00
|
|
|
|
2006-07-26 07:48:48 +00:00
|
|
|
/*! \brief Initial buffer size for resulting strings in ast_cli() */
|
2006-08-08 06:36:47 +00:00
|
|
|
#define AST_CLI_INITLEN 256
|
2006-07-23 15:19:16 +00:00
|
|
|
|
2007-02-13 05:57:52 +00:00
|
|
|
void ast_cli(int fd, const char *fmt, ...)
|
1999-12-19 22:38:55 +00:00
|
|
|
{
|
2006-02-09 16:59:50 +00:00
|
|
|
int res;
|
2006-12-15 23:10:42 +00:00
|
|
|
struct ast_str *buf;
|
1999-12-19 22:38:55 +00:00
|
|
|
va_list ap;
|
2005-07-15 22:06:15 +00:00
|
|
|
|
2006-12-15 23:10:42 +00:00
|
|
|
if (!(buf = ast_str_thread_get(&ast_cli_buf, AST_CLI_INITLEN)))
|
Merge team/russell/ast_verbose_threadstorage
- instead of defining a free() wrapper in a bunch of files, define it as
ast_free() in utils.h and remove the copies from all the files.
- centralize and abstract the code used for doing thread storage. The code
lives in threadstorage.h, with one function being implemented in utils.c.
This new API includes generic thread storage as well as special functions
for handling thread local dynamic length string buffers.
- update ast_inet_ntoa() to use the new threadstorage API
- update ast_state2str() to use the new threadstorage API
- update ast_cli() to use the new threadstorage API
- Modify manager_event() to use thread storage. Instead of using a buffer of
4096 characters as the workspace for building the manager event, use a thread
local dynamic string. Now there is no length limitation on the length of the
body of a manager event.
- Significantly simplify the handling of ast_verbose() ...
- Instead of using a static char buffer and a lock to make sure only one
thread can be using ast_verbose() at a time, use a thread local dynamic
string as the workspace for preparing the verbose message. Instead of
locking around the entire function, the only locking done now is when the
message has been built and is being deliviered to the list of registered
verbose message handlers.
- This function was doing a strdup() on every message passed to it and
keeping a queue of the last 200 messages in memory. This has been
completely removed. The only place this was used was that if there were
any messages in the verbose queue when a verbose handler was registered,
all of the messages in the queue would be fed to it. So, I just made sure
that the console verbose handler and the network verbose handler (for
remote asterisk consoles) were registered before any verbose messages.
pbx_gtkconsole and pbx_kdeconsole will now lose a few verbose messages at
startup, but I didn't feel the performance hit of this message queue was
worth saving the initial verbose output for these very rarely used modules.
- I have removed the last three arguments to the verbose handlers, leaving
only the string itself because they aren't needed anymore. For example,
ast_verbose had some logic for telling the verbose handler to add
a newline if the buffer was completely full. Now that the buffer can grow
as needed, this doesn't matter anymore.
- remove unused function, ast_verbose_dmesg() which was to dispatch the
message queue
- Convert the list of verbose handlers to use the linked list macros.
- add missing newline characters to a few ast_verbose() calls
- convert the list of log channels to use the linked list macros in logger.c
- fix close_logger() to close all of the files it opened for logging
- update ast_log() to use a thread local dynamic string for its workspace
for preparing log messages instead of a buffer of size BUFSIZ (8kB on my
system) allocated on the stack. The dynamic string in this case is limited
to only growing to a maximum size of BUFSIZ.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@39272 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-08-08 06:32:04 +00:00
|
|
|
return;
|
2006-07-23 15:19:16 +00:00
|
|
|
|
1999-12-19 22:38:55 +00:00
|
|
|
va_start(ap, fmt);
|
2006-12-15 23:10:42 +00:00
|
|
|
res = ast_str_set_va(&buf, 0, fmt, ap);
|
1999-12-19 22:38:55 +00:00
|
|
|
va_end(ap);
|
2006-07-23 15:19:16 +00:00
|
|
|
|
2008-12-13 08:36:35 +00:00
|
|
|
if (res != AST_DYNSTR_BUILD_FAILED) {
|
|
|
|
ast_carefulwrite(fd, ast_str_buffer(buf), ast_str_strlen(buf), 100);
|
|
|
|
}
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
|
|
|
|
2010-03-23 14:22:27 +00:00
|
|
|
unsigned int ast_debug_get_by_module(const char *module)
|
2007-07-23 14:21:41 +00:00
|
|
|
{
|
2010-03-23 14:22:27 +00:00
|
|
|
struct module_level *ml;
|
2007-07-23 14:21:41 +00:00
|
|
|
unsigned int res = 0;
|
|
|
|
|
2010-03-23 14:22:27 +00:00
|
|
|
AST_RWLIST_RDLOCK(&debug_modules);
|
|
|
|
AST_LIST_TRAVERSE(&debug_modules, ml, entry) {
|
|
|
|
if (!strcasecmp(ml->module, module)) {
|
|
|
|
res = ml->level;
|
2007-07-23 14:21:41 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-03-23 14:22:27 +00:00
|
|
|
AST_RWLIST_UNLOCK(&debug_modules);
|
2007-07-23 14:21:41 +00:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2010-03-23 14:22:27 +00:00
|
|
|
unsigned int ast_verbose_get_by_module(const char *module)
|
2007-07-23 14:21:41 +00:00
|
|
|
{
|
2010-03-23 14:22:27 +00:00
|
|
|
struct module_level *ml;
|
2007-07-23 14:21:41 +00:00
|
|
|
unsigned int res = 0;
|
|
|
|
|
2010-03-23 14:22:27 +00:00
|
|
|
AST_RWLIST_RDLOCK(&verbose_modules);
|
|
|
|
AST_LIST_TRAVERSE(&verbose_modules, ml, entry) {
|
|
|
|
if (!strcasecmp(ml->module, module)) {
|
|
|
|
res = ml->level;
|
2007-07-23 14:21:41 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-03-23 14:22:27 +00:00
|
|
|
AST_RWLIST_UNLOCK(&verbose_modules);
|
2007-07-23 14:21:41 +00:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2008-12-01 18:52:14 +00:00
|
|
|
/*! \internal
|
|
|
|
* \brief Check if the user with 'uid' and 'gid' is allow to execute 'command',
|
|
|
|
* if command starts with '_' then not check permissions, just permit
|
|
|
|
* to run the 'command'.
|
|
|
|
* 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.
|
|
|
|
* \param uid User ID.
|
|
|
|
* \param gid Group ID.
|
|
|
|
* \param command Command name to check permissions.
|
|
|
|
* \retval 1 if has permission
|
|
|
|
* \retval 0 if it is not allowed.
|
|
|
|
*/
|
|
|
|
static int cli_has_permissions(int uid, int gid, const char *command)
|
|
|
|
{
|
|
|
|
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(®exbuf, perm->command, REG_EXTENDED | REG_NOSUB | REG_ICASE);
|
|
|
|
if (ispattern && regexec(®exbuf, command, 0, NULL, 0)) {
|
|
|
|
regfree(®exbuf);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!ispattern) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
regfree(®exbuf);
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2007-08-01 15:28:02 +00:00
|
|
|
static AST_RWLIST_HEAD_STATIC(helpers, ast_cli_entry);
|
1999-12-19 22:38:55 +00:00
|
|
|
|
2006-11-15 16:39:38 +00:00
|
|
|
static char *complete_fn(const char *word, int state)
|
|
|
|
{
|
2008-01-09 00:51:59 +00:00
|
|
|
char *c, *d;
|
2008-08-05 13:26:34 +00:00
|
|
|
char filename[PATH_MAX];
|
2006-11-15 16:39:38 +00:00
|
|
|
|
|
|
|
if (word[0] == '/')
|
|
|
|
ast_copy_string(filename, word, sizeof(filename));
|
|
|
|
else
|
|
|
|
snprintf(filename, sizeof(filename), "%s/%s", ast_config_AST_MODULE_DIR, word);
|
|
|
|
|
2008-01-09 00:51:59 +00:00
|
|
|
c = d = filename_completion_function(filename, state);
|
2006-11-15 16:39:38 +00:00
|
|
|
|
|
|
|
if (c && word[0] != '/')
|
|
|
|
c += (strlen(ast_config_AST_MODULE_DIR) + 1);
|
2008-01-09 00:51:59 +00:00
|
|
|
if (c)
|
|
|
|
c = ast_strdup(c);
|
2009-06-25 21:15:11 +00:00
|
|
|
|
|
|
|
free(d);
|
2006-11-15 16:39:38 +00:00
|
|
|
|
2008-01-09 00:51:59 +00:00
|
|
|
return c;
|
2006-11-15 16:39:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static char *handle_load(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
2006-11-10 17:01:06 +00:00
|
|
|
{
|
2006-11-14 16:31:57 +00:00
|
|
|
/* "module load <mod>" */
|
2006-11-15 16:39:38 +00:00
|
|
|
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:
|
2007-01-18 19:03:25 +00:00
|
|
|
if (a->pos != e->args)
|
2006-11-15 16:39:38 +00:00
|
|
|
return NULL;
|
|
|
|
return complete_fn(a->word, a->n);
|
2006-11-10 17:01:06 +00:00
|
|
|
}
|
2006-11-15 16:39:38 +00:00
|
|
|
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;
|
|
|
|
}
|
2010-05-12 19:59:16 +00:00
|
|
|
ast_cli(a->fd, "Loaded %s\n", a->argv[e->args]);
|
2006-11-15 16:39:38 +00:00
|
|
|
return CLI_SUCCESS;
|
2006-11-10 17:01:06 +00:00
|
|
|
}
|
|
|
|
|
2006-11-15 15:02:56 +00:00
|
|
|
static char *handle_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
2006-11-10 17:01:06 +00:00
|
|
|
{
|
2006-11-15 15:02:56 +00:00
|
|
|
int x;
|
2006-11-14 16:55:27 +00:00
|
|
|
|
2006-11-15 15:02:56 +00:00
|
|
|
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, 1);
|
|
|
|
}
|
|
|
|
if (a->argc == e->args) {
|
2006-11-14 16:55:27 +00:00
|
|
|
ast_module_reload(NULL);
|
2006-11-15 15:02:56 +00:00
|
|
|
return CLI_SUCCESS;
|
|
|
|
}
|
|
|
|
for (x = e->args; x < a->argc; x++) {
|
|
|
|
int res = ast_module_reload(a->argv[x]);
|
2006-11-15 16:13:30 +00:00
|
|
|
/* XXX reload has multiple error returns, including -1 on error and 2 on success */
|
2007-01-23 00:11:32 +00:00
|
|
|
switch (res) {
|
2006-11-15 15:02:56 +00:00
|
|
|
case 0:
|
|
|
|
ast_cli(a->fd, "No such module '%s'\n", a->argv[x]);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
ast_cli(a->fd, "Module '%s' does not support reload\n", a->argv[x]);
|
|
|
|
break;
|
2006-09-18 19:54:18 +00:00
|
|
|
}
|
2006-11-14 16:55:27 +00:00
|
|
|
}
|
2006-11-15 15:02:56 +00:00
|
|
|
return CLI_SUCCESS;
|
2006-09-18 19:54:18 +00:00
|
|
|
}
|
|
|
|
|
2010-08-12 20:44:39 +00:00
|
|
|
static char *handle_core_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
2007-07-23 14:21:41 +00:00
|
|
|
/*!
|
|
|
|
* \brief Find the debug or verbose file setting
|
|
|
|
* \arg debug 1 for debug, 0 for verbose
|
|
|
|
*/
|
2010-03-23 14:22:27 +00:00
|
|
|
static struct module_level *find_module_level(const char *module, unsigned int debug)
|
2007-07-23 14:21:41 +00:00
|
|
|
{
|
2010-03-23 14:22:27 +00:00
|
|
|
struct module_level *ml;
|
|
|
|
struct module_level_list *mll = debug ? &debug_modules : &verbose_modules;
|
2007-07-23 14:21:41 +00:00
|
|
|
|
2010-03-23 14:22:27 +00:00
|
|
|
AST_LIST_TRAVERSE(mll, ml, entry) {
|
|
|
|
if (!strcasecmp(ml->module, module))
|
|
|
|
return ml;
|
2007-07-23 14:21:41 +00:00
|
|
|
}
|
|
|
|
|
2010-03-23 14:22:27 +00:00
|
|
|
return NULL;
|
2007-07-23 14:21:41 +00:00
|
|
|
}
|
|
|
|
|
2008-12-10 17:09:15 +00:00
|
|
|
static char *complete_number(const char *partial, unsigned int min, unsigned int max, int n)
|
|
|
|
{
|
|
|
|
int i, count = 0;
|
|
|
|
unsigned int prospective[2];
|
|
|
|
unsigned int part = strtoul(partial, NULL, 10);
|
|
|
|
char next[12];
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2006-11-15 14:11:28 +00:00
|
|
|
static char *handle_verbose(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
2006-09-18 19:54:18 +00:00
|
|
|
{
|
2007-06-05 22:59:36 +00:00
|
|
|
int oldval;
|
2006-09-29 22:36:29 +00:00
|
|
|
int newlevel;
|
2010-10-11 16:44:32 +00:00
|
|
|
unsigned int is_debug;
|
2006-09-29 22:36:29 +00:00
|
|
|
int atleast = 0;
|
2006-11-15 14:11:28 +00:00
|
|
|
int fd = a->fd;
|
|
|
|
int argc = a->argc;
|
2009-05-21 21:13:09 +00:00
|
|
|
const char * const *argv = a->argv;
|
|
|
|
const char *argv3 = a->argv ? S_OR(a->argv[3], "") : "";
|
2006-11-17 12:26:15 +00:00
|
|
|
int *dst;
|
|
|
|
char *what;
|
2010-03-23 14:22:27 +00:00
|
|
|
struct module_level_list *mll;
|
|
|
|
struct module_level *ml;
|
2006-11-15 14:11:28 +00:00
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case CLI_INIT:
|
2008-12-10 17:09:15 +00:00
|
|
|
e->command = "core set {debug|verbose}";
|
2006-11-15 14:11:28 +00:00
|
|
|
e->usage =
|
2009-12-30 20:34:41 +00:00
|
|
|
#if !defined(LOW_MEMORY)
|
2010-03-23 14:22:27 +00:00
|
|
|
"Usage: core set {debug|verbose} [atleast] <level> [module]\n"
|
2009-12-30 20:34:41 +00:00
|
|
|
#else
|
|
|
|
"Usage: core set {debug|verbose} [atleast] <level>\n"
|
|
|
|
#endif
|
2006-11-17 12:26:15 +00:00
|
|
|
" core set {debug|verbose} off\n"
|
2009-12-30 20:34:41 +00:00
|
|
|
#if !defined(LOW_MEMORY)
|
2010-03-23 14:22:27 +00:00
|
|
|
" Sets level of debug or verbose messages to be displayed or\n"
|
|
|
|
" sets a module name to display debug messages from.\n"
|
2009-12-30 20:34:41 +00:00
|
|
|
#else
|
|
|
|
" Sets level of debug or verbose messages to be displayed.\n"
|
|
|
|
#endif
|
2006-11-17 12:26:15 +00:00
|
|
|
" 0 or off means no messages should be displayed.\n"
|
|
|
|
" Equivalent to -d[d[...]] or -v[v[v...]] on startup\n";
|
2006-11-15 14:11:28 +00:00
|
|
|
return NULL;
|
2006-09-29 22:36:29 +00:00
|
|
|
|
2006-11-14 16:55:27 +00:00
|
|
|
case CLI_GENERATE:
|
2008-12-10 17:09:15 +00:00
|
|
|
if (a->pos == 3 || (a->pos == 4 && !strcasecmp(a->argv[3], "atleast"))) {
|
2009-05-21 21:13:09 +00:00
|
|
|
const char *pos = a->pos == 3 ? argv3 : S_OR(a->argv[4], "");
|
2008-12-10 17:09:15 +00:00
|
|
|
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 {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
} 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");
|
|
|
|
}
|
2009-12-30 20:34:41 +00:00
|
|
|
#if !defined(LOW_MEMORY)
|
2008-12-10 17:09:15 +00:00
|
|
|
} else if (a->pos == 4 || (a->pos == 5 && !strcasecmp(argv3, "atleast"))) {
|
|
|
|
return ast_complete_source_filename(a->pos == 4 ? S_OR(a->argv[4], "") : S_OR(a->argv[5], ""), a->n);
|
2009-12-30 20:34:41 +00:00
|
|
|
#endif
|
2008-12-10 17:09:15 +00:00
|
|
|
}
|
2006-11-17 11:12:13 +00:00
|
|
|
return NULL;
|
2006-11-14 16:55:27 +00:00
|
|
|
}
|
|
|
|
/* all the above return, so we proceed with the handler.
|
|
|
|
* we are guaranteed to be called with argc >= e->args;
|
|
|
|
*/
|
2006-09-29 22:36:29 +00:00
|
|
|
|
2009-01-14 23:10:48 +00:00
|
|
|
if (argc <= e->args)
|
2006-11-15 14:11:28 +00:00
|
|
|
return CLI_SHOWUSAGE;
|
2008-12-10 17:09:15 +00:00
|
|
|
if (!strcasecmp(argv[e->args - 1], "debug")) {
|
2006-11-17 12:26:15 +00:00
|
|
|
dst = &option_debug;
|
2007-06-05 22:59:36 +00:00
|
|
|
oldval = option_debug;
|
2006-11-17 12:26:15 +00:00
|
|
|
what = "Core debug";
|
2010-10-11 16:44:32 +00:00
|
|
|
is_debug = 1;
|
2006-11-17 12:26:15 +00:00
|
|
|
} else {
|
|
|
|
dst = &option_verbose;
|
2007-06-05 22:59:36 +00:00
|
|
|
oldval = option_verbose;
|
2006-11-17 12:26:15 +00:00
|
|
|
what = "Verbosity";
|
2010-10-11 16:44:32 +00:00
|
|
|
is_debug = 0;
|
2006-11-17 12:26:15 +00:00
|
|
|
}
|
2008-12-10 17:09:15 +00:00
|
|
|
if (argc == e->args + 1 && !strcasecmp(argv[e->args], "off")) {
|
2006-11-14 16:55:27 +00:00
|
|
|
newlevel = 0;
|
2007-07-23 14:21:41 +00:00
|
|
|
|
2010-10-11 16:44:32 +00:00
|
|
|
mll = is_debug ? &debug_modules : &verbose_modules;
|
2007-07-23 14:21:41 +00:00
|
|
|
|
2010-03-23 14:22:27 +00:00
|
|
|
AST_RWLIST_WRLOCK(mll);
|
|
|
|
while ((ml = AST_RWLIST_REMOVE_HEAD(mll, entry))) {
|
|
|
|
ast_free(ml);
|
|
|
|
}
|
2010-10-11 16:44:32 +00:00
|
|
|
ast_clear_flag(&ast_options, is_debug ? AST_OPT_FLAG_DEBUG_MODULE : AST_OPT_FLAG_VERBOSE_MODULE);
|
2010-03-23 14:22:27 +00:00
|
|
|
AST_RWLIST_UNLOCK(mll);
|
2007-07-23 14:21:41 +00:00
|
|
|
|
2006-11-14 16:55:27 +00:00
|
|
|
goto done;
|
|
|
|
}
|
2008-12-10 17:09:15 +00:00
|
|
|
if (!strcasecmp(argv[e->args], "atleast"))
|
2006-11-14 16:55:27 +00:00
|
|
|
atleast = 1;
|
2008-12-10 17:09:15 +00:00
|
|
|
if (argc != e->args + atleast + 1 && argc != e->args + atleast + 2)
|
2006-11-15 14:11:28 +00:00
|
|
|
return CLI_SHOWUSAGE;
|
2009-08-10 19:20:57 +00:00
|
|
|
if (sscanf(argv[e->args + atleast], "%30d", &newlevel) != 1)
|
2006-11-15 14:11:28 +00:00
|
|
|
return CLI_SHOWUSAGE;
|
2008-12-10 17:09:15 +00:00
|
|
|
if (argc == e->args + atleast + 2) {
|
2010-10-11 16:44:32 +00:00
|
|
|
/* We have specified a module name. */
|
2010-03-23 14:22:27 +00:00
|
|
|
char *mod = ast_strdupa(argv[e->args + atleast + 1]);
|
2007-07-23 14:21:41 +00:00
|
|
|
|
2010-03-23 14:22:27 +00:00
|
|
|
if ((strlen(mod) > 3) && !strcasecmp(mod + strlen(mod) - 3, ".so")) {
|
|
|
|
mod[strlen(mod) - 3] = '\0';
|
|
|
|
}
|
2007-07-23 14:21:41 +00:00
|
|
|
|
2010-10-11 16:44:32 +00:00
|
|
|
mll = is_debug ? &debug_modules : &verbose_modules;
|
|
|
|
|
2010-03-23 14:22:27 +00:00
|
|
|
AST_RWLIST_WRLOCK(mll);
|
2007-07-23 14:21:41 +00:00
|
|
|
|
2010-10-11 16:44:32 +00:00
|
|
|
ml = find_module_level(mod, is_debug);
|
|
|
|
if (!newlevel) {
|
|
|
|
if (!ml) {
|
|
|
|
/* Specified off for a nonexistent entry. */
|
|
|
|
AST_RWLIST_UNLOCK(mll);
|
|
|
|
return CLI_SUCCESS;
|
|
|
|
}
|
2010-03-23 14:22:27 +00:00
|
|
|
AST_RWLIST_REMOVE(mll, ml, entry);
|
|
|
|
if (AST_RWLIST_EMPTY(mll))
|
2010-10-11 16:44:32 +00:00
|
|
|
ast_clear_flag(&ast_options, is_debug ? AST_OPT_FLAG_DEBUG_MODULE : AST_OPT_FLAG_VERBOSE_MODULE);
|
2010-03-23 14:22:27 +00:00
|
|
|
AST_RWLIST_UNLOCK(mll);
|
|
|
|
ast_cli(fd, "%s was %d and has been set to 0 for '%s'\n", what, ml->level, mod);
|
|
|
|
ast_free(ml);
|
2007-07-23 14:21:41 +00:00
|
|
|
return CLI_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2010-03-23 14:22:27 +00:00
|
|
|
if (ml) {
|
|
|
|
if ((atleast && newlevel < ml->level) || ml->level == newlevel) {
|
|
|
|
ast_cli(fd, "%s is %d for '%s'\n", what, ml->level, mod);
|
|
|
|
AST_RWLIST_UNLOCK(mll);
|
2007-07-23 14:21:41 +00:00
|
|
|
return CLI_SUCCESS;
|
|
|
|
}
|
2010-10-11 16:44:32 +00:00
|
|
|
oldval = ml->level;
|
|
|
|
ml->level = newlevel;
|
|
|
|
} else {
|
|
|
|
ml = ast_calloc(1, sizeof(*ml) + strlen(mod) + 1);
|
|
|
|
if (!ml) {
|
|
|
|
AST_RWLIST_UNLOCK(mll);
|
|
|
|
return CLI_FAILURE;
|
|
|
|
}
|
|
|
|
oldval = ml->level;
|
|
|
|
ml->level = newlevel;
|
|
|
|
strcpy(ml->module, mod);
|
|
|
|
AST_RWLIST_INSERT_TAIL(mll, ml, entry);
|
2007-07-23 14:21:41 +00:00
|
|
|
}
|
|
|
|
|
2010-10-11 16:44:32 +00:00
|
|
|
ast_set_flag(&ast_options, is_debug ? AST_OPT_FLAG_DEBUG_MODULE : AST_OPT_FLAG_VERBOSE_MODULE);
|
2007-07-23 14:21:41 +00:00
|
|
|
|
2010-03-23 14:22:27 +00:00
|
|
|
AST_RWLIST_UNLOCK(mll);
|
2007-07-23 14:21:41 +00:00
|
|
|
|
2010-03-23 14:22:27 +00:00
|
|
|
ast_cli(fd, "%s was %d and has been set to %d for '%s'\n", what, oldval, ml->level, ml->module);
|
2007-07-23 14:21:41 +00:00
|
|
|
|
|
|
|
return CLI_SUCCESS;
|
2010-10-11 16:44:32 +00:00
|
|
|
} else if (!newlevel) {
|
|
|
|
/* Specified level as 0 instead of off. */
|
|
|
|
mll = is_debug ? &debug_modules : &verbose_modules;
|
|
|
|
|
|
|
|
AST_RWLIST_WRLOCK(mll);
|
|
|
|
while ((ml = AST_RWLIST_REMOVE_HEAD(mll, entry))) {
|
|
|
|
ast_free(ml);
|
|
|
|
}
|
|
|
|
ast_clear_flag(&ast_options, is_debug ? AST_OPT_FLAG_DEBUG_MODULE : AST_OPT_FLAG_VERBOSE_MODULE);
|
|
|
|
AST_RWLIST_UNLOCK(mll);
|
2007-07-23 14:21:41 +00:00
|
|
|
}
|
2006-11-14 16:55:27 +00:00
|
|
|
|
|
|
|
done:
|
2006-11-17 12:26:15 +00:00
|
|
|
if (!atleast || newlevel > *dst)
|
|
|
|
*dst = newlevel;
|
|
|
|
if (oldval > 0 && *dst == 0)
|
|
|
|
ast_cli(fd, "%s is now OFF\n", what);
|
|
|
|
else if (*dst > 0) {
|
|
|
|
if (oldval == *dst)
|
|
|
|
ast_cli(fd, "%s is at least %d\n", what, *dst);
|
2006-09-18 19:54:18 +00:00
|
|
|
else
|
2006-11-17 12:26:15 +00:00
|
|
|
ast_cli(fd, "%s was %d and is now %d\n", what, oldval, *dst);
|
2006-09-18 19:54:18 +00:00
|
|
|
}
|
|
|
|
|
2006-11-15 14:11:28 +00:00
|
|
|
return CLI_SUCCESS;
|
2006-09-18 19:54:18 +00:00
|
|
|
}
|
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
static char *handle_logger_mute(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
2006-05-26 19:48:17 +00:00
|
|
|
{
|
2007-10-11 19:03:06 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2007-10-13 05:53:19 +00:00
|
|
|
if (a->argc < 2 || a->argc > 3)
|
2007-10-11 19:03:06 +00:00
|
|
|
return CLI_SHOWUSAGE;
|
2007-10-13 05:53:19 +00:00
|
|
|
|
2007-10-13 08:38:50 +00:00
|
|
|
if (a->argc == 3 && !strcasecmp(a->argv[2], "silent"))
|
2007-10-13 05:53:19 +00:00
|
|
|
ast_console_toggle_mute(a->fd, 1);
|
|
|
|
else
|
|
|
|
ast_console_toggle_mute(a->fd, 0);
|
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
return CLI_SUCCESS;
|
2006-05-26 19:48:17 +00:00
|
|
|
}
|
|
|
|
|
2006-11-15 15:02:56 +00:00
|
|
|
static char *handle_unload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
2006-11-10 17:01:06 +00:00
|
|
|
{
|
2006-11-14 16:38:35 +00:00
|
|
|
/* "module unload mod_1 [mod_2 .. mod_N]" */
|
2006-11-10 17:01:06 +00:00
|
|
|
int x;
|
|
|
|
int force = AST_FORCE_SOFT;
|
2009-05-21 21:13:09 +00:00
|
|
|
const char *s;
|
2006-11-15 15:02:56 +00:00
|
|
|
|
|
|
|
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, 0);
|
|
|
|
}
|
|
|
|
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;
|
2006-09-18 19:54:18 +00:00
|
|
|
}
|
2010-05-12 19:59:16 +00:00
|
|
|
ast_cli(a->fd, "Unloaded %s\n", a->argv[x]);
|
2006-09-18 19:54:18 +00:00
|
|
|
}
|
2010-05-12 19:59:16 +00:00
|
|
|
|
2006-11-15 15:02:56 +00:00
|
|
|
return CLI_SUCCESS;
|
2006-09-18 19:54:18 +00:00
|
|
|
}
|
|
|
|
|
2005-06-06 20:27:51 +00:00
|
|
|
#define MODLIST_FORMAT "%-30s %-40.40s %-10d\n"
|
|
|
|
#define MODLIST_FORMAT2 "%-30s %-40.40s %-10s\n"
|
1999-12-19 22:38:55 +00:00
|
|
|
|
2004-06-09 01:45:08 +00:00
|
|
|
AST_MUTEX_DEFINE_STATIC(climodentrylock);
|
1999-12-19 22:38:55 +00:00
|
|
|
static int climodentryfd = -1;
|
|
|
|
|
2005-06-06 20:27:51 +00:00
|
|
|
static int modlist_modentry(const char *module, const char *description, int usecnt, const char *like)
|
1999-12-19 22:38:55 +00:00
|
|
|
{
|
2004-10-14 04:38:29 +00:00
|
|
|
/* Comparing the like with the module */
|
2005-08-22 18:43:32 +00:00
|
|
|
if (strcasestr(module, like) ) {
|
2005-06-06 20:27:51 +00:00
|
|
|
ast_cli(climodentryfd, MODLIST_FORMAT, module, description, usecnt);
|
2004-10-14 04:38:29 +00:00
|
|
|
return 1;
|
|
|
|
}
|
1999-12-19 22:38:55 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-07-18 19:47:20 +00:00
|
|
|
static void print_uptimestr(int fd, struct timeval timeval, const char *prefix, int printsec)
|
2003-05-02 15:37:34 +00:00
|
|
|
{
|
2006-01-18 00:05:09 +00:00
|
|
|
int x; /* the main part - years, weeks, etc. */
|
2006-12-16 09:56:31 +00:00
|
|
|
struct ast_str *out;
|
2006-01-18 00:05:09 +00:00
|
|
|
|
2003-05-02 15:37:34 +00:00
|
|
|
#define SECOND (1)
|
2004-06-22 17:42:14 +00:00
|
|
|
#define MINUTE (SECOND*60)
|
|
|
|
#define HOUR (MINUTE*60)
|
2003-05-02 15:37:34 +00:00
|
|
|
#define DAY (HOUR*24)
|
|
|
|
#define WEEK (DAY*7)
|
|
|
|
#define YEAR (DAY*365)
|
2006-01-18 00:05:09 +00:00
|
|
|
#define NEEDCOMMA(x) ((x)? ",": "") /* define if we need a comma */
|
2007-07-18 19:47:20 +00:00
|
|
|
if (timeval.tv_sec < 0) /* invalid, nothing to show */
|
2006-01-18 00:05:09 +00:00
|
|
|
return;
|
2006-12-16 09:56:31 +00:00
|
|
|
|
2006-01-18 00:05:09 +00:00
|
|
|
if (printsec) { /* plain seconds output */
|
2007-07-18 19:47:20 +00:00
|
|
|
ast_cli(fd, "%s: %lu\n", prefix, (u_long)timeval.tv_sec);
|
2006-12-16 09:56:31 +00:00
|
|
|
return;
|
2006-01-18 00:05:09 +00:00
|
|
|
}
|
2006-12-16 09:56:31 +00:00
|
|
|
out = ast_str_alloca(256);
|
2007-07-18 19:47:20 +00:00
|
|
|
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));
|
2003-05-02 15:37:34 +00:00
|
|
|
}
|
2007-07-18 19:47:20 +00:00
|
|
|
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));
|
2003-05-02 15:37:34 +00:00
|
|
|
}
|
2007-07-18 19:47:20 +00:00
|
|
|
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));
|
2003-05-02 15:37:34 +00:00
|
|
|
}
|
2007-07-18 19:47:20 +00:00
|
|
|
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));
|
2003-05-02 15:37:34 +00:00
|
|
|
}
|
2007-07-18 19:47:20 +00:00
|
|
|
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));
|
2003-05-02 15:37:34 +00:00
|
|
|
}
|
2007-07-18 19:47:20 +00:00
|
|
|
x = timeval.tv_sec;
|
2008-12-13 08:36:35 +00:00
|
|
|
if (x > 0 || ast_str_strlen(out) == 0) /* if there is nothing, print 0 seconds */
|
2006-12-16 09:56:31 +00:00
|
|
|
ast_str_append(&out, 0, "%d second%s ", x, ESS(x));
|
2008-12-13 08:36:35 +00:00
|
|
|
ast_cli(fd, "%s: %s\n", prefix, ast_str_buffer(out));
|
2003-05-02 15:37:34 +00:00
|
|
|
}
|
|
|
|
|
2008-12-01 18:52:14 +00:00
|
|
|
static struct ast_cli_entry *cli_next(struct ast_cli_entry *e)
|
|
|
|
{
|
|
|
|
if (e) {
|
|
|
|
return AST_LIST_NEXT(e, list);
|
|
|
|
} else {
|
|
|
|
return AST_LIST_FIRST(&helpers);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-15 14:11:28 +00:00
|
|
|
static char * handle_showuptime(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
2003-05-02 15:37:34 +00:00
|
|
|
{
|
2007-07-18 19:47:20 +00:00
|
|
|
struct timeval curtime = ast_tvnow();
|
2006-11-14 16:09:08 +00:00
|
|
|
int printsec;
|
|
|
|
|
2006-11-15 14:11:28 +00:00
|
|
|
switch (cmd) {
|
2008-03-04 23:04:29 +00:00
|
|
|
case CLI_INIT:
|
2007-06-27 22:27:09 +00:00
|
|
|
e->command = "core show uptime [seconds]";
|
2006-11-15 14:11:28 +00:00
|
|
|
e->usage =
|
2006-11-14 16:09:08 +00:00
|
|
|
"Usage: core show uptime [seconds]\n"
|
|
|
|
" Shows Asterisk uptime information.\n"
|
|
|
|
" The seconds word returns the uptime in seconds only.\n";
|
2006-11-15 14:11:28 +00:00
|
|
|
return NULL;
|
2005-02-05 16:49:14 +00:00
|
|
|
|
2006-11-14 16:09:08 +00:00
|
|
|
case CLI_GENERATE:
|
2007-06-27 22:27:09 +00:00
|
|
|
return NULL;
|
2006-11-14 16:09:08 +00:00
|
|
|
}
|
|
|
|
/* regular handler */
|
2007-06-27 22:27:09 +00:00
|
|
|
if (a->argc == e->args && !strcasecmp(a->argv[e->args-1],"seconds"))
|
2006-11-14 16:09:08 +00:00
|
|
|
printsec = 1;
|
2007-06-27 22:27:09 +00:00
|
|
|
else if (a->argc == e->args-1)
|
2006-11-14 16:09:08 +00:00
|
|
|
printsec = 0;
|
|
|
|
else
|
2006-11-15 14:11:28 +00:00
|
|
|
return CLI_SHOWUSAGE;
|
2007-07-18 19:47:20 +00:00
|
|
|
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);
|
2006-11-15 14:11:28 +00:00
|
|
|
return CLI_SUCCESS;
|
2003-05-02 15:37:34 +00:00
|
|
|
}
|
|
|
|
|
2006-11-15 14:11:28 +00:00
|
|
|
static char *handle_modlist(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
1999-12-19 22:38:55 +00:00
|
|
|
{
|
2009-05-21 21:13:09 +00:00
|
|
|
const char *like;
|
Bring in the improved internal API for the CLI.
WATCH OUT: this changes the binary interface (ABI) for modules,
so e.g. users of g729 codecs need a rebuilt module (but read below).
The new way to write CLI handlers is described in detail in cli.h,
and there are a few converted handlers in cli.c, look for NEW_CLI.
After converting a couple of commands i am convinced that
it is reasonably convenient to use, and it makes it easier to fix the
pending CLI issues.
On passing, note a bug with the current 'complete' architecture:
if a command is a prefix of multiple CLI entries, we miss some
of the possible options. As an example, "core set debug" can
continue with "channel" from one CLI entry, and "off" or "atleast"
from another one.
We address this problem in a separate commit
(when i have figured out a fix, that is).
ABI issues:
I asked Kevin if it was ok to make this change and he said yes.
While it would have been possible to make the change without breaking
the module ABI, the code would have been more convoluted.
I am happy to restore the old ABI (while still being able
to use the "new style" handlers) if there is demand.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@47606 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-11-14 15:23:35 +00:00
|
|
|
|
2006-11-15 14:11:28 +00:00
|
|
|
switch (cmd) {
|
|
|
|
case CLI_INIT:
|
2006-11-17 22:02:15 +00:00
|
|
|
e->command = "module show [like]";
|
2006-11-15 14:11:28 +00:00
|
|
|
e->usage =
|
Bring in the improved internal API for the CLI.
WATCH OUT: this changes the binary interface (ABI) for modules,
so e.g. users of g729 codecs need a rebuilt module (but read below).
The new way to write CLI handlers is described in detail in cli.h,
and there are a few converted handlers in cli.c, look for NEW_CLI.
After converting a couple of commands i am convinced that
it is reasonably convenient to use, and it makes it easier to fix the
pending CLI issues.
On passing, note a bug with the current 'complete' architecture:
if a command is a prefix of multiple CLI entries, we miss some
of the possible options. As an example, "core set debug" can
continue with "channel" from one CLI entry, and "off" or "atleast"
from another one.
We address this problem in a separate commit
(when i have figured out a fix, that is).
ABI issues:
I asked Kevin if it was ok to make this change and he said yes.
While it would have been possible to make the change without breaking
the module ABI, the code would have been more convoluted.
I am happy to restore the old ABI (while still being able
to use the "new style" handlers) if there is demand.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@47606 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-11-14 15:23:35 +00:00
|
|
|
"Usage: module show [like keyword]\n"
|
|
|
|
" Shows Asterisk modules currently in use, and usage statistics.\n";
|
2006-11-15 14:11:28 +00:00
|
|
|
return NULL;
|
Bring in the improved internal API for the CLI.
WATCH OUT: this changes the binary interface (ABI) for modules,
so e.g. users of g729 codecs need a rebuilt module (but read below).
The new way to write CLI handlers is described in detail in cli.h,
and there are a few converted handlers in cli.c, look for NEW_CLI.
After converting a couple of commands i am convinced that
it is reasonably convenient to use, and it makes it easier to fix the
pending CLI issues.
On passing, note a bug with the current 'complete' architecture:
if a command is a prefix of multiple CLI entries, we miss some
of the possible options. As an example, "core set debug" can
continue with "channel" from one CLI entry, and "off" or "atleast"
from another one.
We address this problem in a separate commit
(when i have figured out a fix, that is).
ABI issues:
I asked Kevin if it was ok to make this change and he said yes.
While it would have been possible to make the change without breaking
the module ABI, the code would have been more convoluted.
I am happy to restore the old ABI (while still being able
to use the "new style" handlers) if there is demand.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@47606 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-11-14 15:23:35 +00:00
|
|
|
|
|
|
|
case CLI_GENERATE:
|
|
|
|
if (a->pos == e->args)
|
2006-11-15 14:11:28 +00:00
|
|
|
return ast_module_helper(a->line, a->word, a->pos, a->n, a->pos, 0);
|
Bring in the improved internal API for the CLI.
WATCH OUT: this changes the binary interface (ABI) for modules,
so e.g. users of g729 codecs need a rebuilt module (but read below).
The new way to write CLI handlers is described in detail in cli.h,
and there are a few converted handlers in cli.c, look for NEW_CLI.
After converting a couple of commands i am convinced that
it is reasonably convenient to use, and it makes it easier to fix the
pending CLI issues.
On passing, note a bug with the current 'complete' architecture:
if a command is a prefix of multiple CLI entries, we miss some
of the possible options. As an example, "core set debug" can
continue with "channel" from one CLI entry, and "off" or "atleast"
from another one.
We address this problem in a separate commit
(when i have figured out a fix, that is).
ABI issues:
I asked Kevin if it was ok to make this change and he said yes.
While it would have been possible to make the change without breaking
the module ABI, the code would have been more convoluted.
I am happy to restore the old ABI (while still being able
to use the "new style" handlers) if there is demand.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@47606 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-11-14 15:23:35 +00:00
|
|
|
else
|
2006-11-15 14:11:28 +00:00
|
|
|
return NULL;
|
2004-10-14 04:38:29 +00:00
|
|
|
}
|
Bring in the improved internal API for the CLI.
WATCH OUT: this changes the binary interface (ABI) for modules,
so e.g. users of g729 codecs need a rebuilt module (but read below).
The new way to write CLI handlers is described in detail in cli.h,
and there are a few converted handlers in cli.c, look for NEW_CLI.
After converting a couple of commands i am convinced that
it is reasonably convenient to use, and it makes it easier to fix the
pending CLI issues.
On passing, note a bug with the current 'complete' architecture:
if a command is a prefix of multiple CLI entries, we miss some
of the possible options. As an example, "core set debug" can
continue with "channel" from one CLI entry, and "off" or "atleast"
from another one.
We address this problem in a separate commit
(when i have figured out a fix, that is).
ABI issues:
I asked Kevin if it was ok to make this change and he said yes.
While it would have been possible to make the change without breaking
the module ABI, the code would have been more convoluted.
I am happy to restore the old ABI (while still being able
to use the "new style" handlers) if there is demand.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@47606 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-11-14 15:23:35 +00:00
|
|
|
/* all the above return, so we proceed with the handler.
|
|
|
|
* we are guaranteed to have argc >= e->args
|
|
|
|
*/
|
2006-11-17 22:02:15 +00:00
|
|
|
if (a->argc == e->args - 1)
|
Bring in the improved internal API for the CLI.
WATCH OUT: this changes the binary interface (ABI) for modules,
so e.g. users of g729 codecs need a rebuilt module (but read below).
The new way to write CLI handlers is described in detail in cli.h,
and there are a few converted handlers in cli.c, look for NEW_CLI.
After converting a couple of commands i am convinced that
it is reasonably convenient to use, and it makes it easier to fix the
pending CLI issues.
On passing, note a bug with the current 'complete' architecture:
if a command is a prefix of multiple CLI entries, we miss some
of the possible options. As an example, "core set debug" can
continue with "channel" from one CLI entry, and "off" or "atleast"
from another one.
We address this problem in a separate commit
(when i have figured out a fix, that is).
ABI issues:
I asked Kevin if it was ok to make this change and he said yes.
While it would have been possible to make the change without breaking
the module ABI, the code would have been more convoluted.
I am happy to restore the old ABI (while still being able
to use the "new style" handlers) if there is demand.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@47606 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-11-14 15:23:35 +00:00
|
|
|
like = "";
|
2006-11-17 22:02:15 +00:00
|
|
|
else if (a->argc == e->args + 1 && !strcasecmp(a->argv[e->args-1], "like") )
|
|
|
|
like = a->argv[e->args];
|
Bring in the improved internal API for the CLI.
WATCH OUT: this changes the binary interface (ABI) for modules,
so e.g. users of g729 codecs need a rebuilt module (but read below).
The new way to write CLI handlers is described in detail in cli.h,
and there are a few converted handlers in cli.c, look for NEW_CLI.
After converting a couple of commands i am convinced that
it is reasonably convenient to use, and it makes it easier to fix the
pending CLI issues.
On passing, note a bug with the current 'complete' architecture:
if a command is a prefix of multiple CLI entries, we miss some
of the possible options. As an example, "core set debug" can
continue with "channel" from one CLI entry, and "off" or "atleast"
from another one.
We address this problem in a separate commit
(when i have figured out a fix, that is).
ABI issues:
I asked Kevin if it was ok to make this change and he said yes.
While it would have been possible to make the change without breaking
the module ABI, the code would have been more convoluted.
I am happy to restore the old ABI (while still being able
to use the "new style" handlers) if there is demand.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@47606 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-11-14 15:23:35 +00:00
|
|
|
else
|
2006-11-15 14:11:28 +00:00
|
|
|
return CLI_SHOWUSAGE;
|
2004-10-14 04:38:29 +00:00
|
|
|
|
2003-08-13 15:25:16 +00:00
|
|
|
ast_mutex_lock(&climodentrylock);
|
2006-11-15 14:11:28 +00:00
|
|
|
climodentryfd = a->fd; /* global, protected by climodentrylock */
|
|
|
|
ast_cli(a->fd, MODLIST_FORMAT2, "Module", "Description", "Use Count");
|
|
|
|
ast_cli(a->fd,"%d modules loaded\n", ast_update_module_list(modlist_modentry, like));
|
1999-12-19 22:38:55 +00:00
|
|
|
climodentryfd = -1;
|
2003-08-13 15:25:16 +00:00
|
|
|
ast_mutex_unlock(&climodentrylock);
|
2007-11-28 20:27:40 +00:00
|
|
|
return CLI_SUCCESS;
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
2005-08-08 01:45:29 +00:00
|
|
|
#undef MODLIST_FORMAT
|
|
|
|
#undef MODLIST_FORMAT2
|
1999-12-19 22:38:55 +00:00
|
|
|
|
2007-12-07 16:11:05 +00:00
|
|
|
static char *handle_showcalls(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
|
|
|
{
|
|
|
|
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 a->n == 0 ? ast_strdup("seconds") : NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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 (option_maxcalls) {
|
|
|
|
ast_cli(a->fd, "%d of %d max active call%s (%5.2f%% of capacity)\n",
|
|
|
|
ast_active_calls(), option_maxcalls, ESS(ast_active_calls()),
|
|
|
|
((double)ast_active_calls() / (double)option_maxcalls) * 100.0);
|
|
|
|
} else {
|
|
|
|
ast_cli(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;
|
|
|
|
}
|
|
|
|
|
2006-11-15 17:05:55 +00:00
|
|
|
static char *handle_chanlist(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
1999-12-19 22:38:55 +00:00
|
|
|
{
|
2005-08-08 01:45:29 +00:00
|
|
|
#define FORMAT_STRING "%-20.20s %-20.20s %-7.7s %-30.30s\n"
|
|
|
|
#define FORMAT_STRING2 "%-20.20s %-20.20s %-7.7s %-30.30s\n"
|
2009-06-26 15:28:53 +00:00
|
|
|
#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"
|
2005-08-08 01:45:29 +00:00
|
|
|
|
2006-03-28 22:25:08 +00:00
|
|
|
struct ast_channel *c = NULL;
|
2007-01-29 17:49:04 +00:00
|
|
|
int numchans = 0, concise = 0, verbose = 0, count = 0;
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
struct ast_channel_iterator *iter = NULL;
|
2004-06-11 00:18:30 +00:00
|
|
|
|
2006-11-15 17:05:55 +00:00
|
|
|
switch (cmd) {
|
|
|
|
case CLI_INIT:
|
2007-01-29 17:49:04 +00:00
|
|
|
e->command = "core show channels [concise|verbose|count]";
|
2006-11-15 17:05:55 +00:00
|
|
|
e->usage =
|
2007-01-29 17:49:04 +00:00
|
|
|
"Usage: core show channels [concise|verbose|count]\n"
|
2006-11-15 17:05:55 +00:00
|
|
|
" 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"
|
2007-01-29 17:49:04 +00:00
|
|
|
" more and longer fields. If 'count' is specified only the channel and call\n"
|
2007-11-26 19:24:23 +00:00
|
|
|
" count is output.\n"
|
|
|
|
" The 'concise' option is deprecated and will be removed from future versions\n"
|
|
|
|
" of Asterisk.\n";
|
2006-11-15 17:05:55 +00:00
|
|
|
return NULL;
|
2004-06-11 00:18:30 +00:00
|
|
|
|
2006-11-17 11:12:13 +00:00
|
|
|
case CLI_GENERATE:
|
|
|
|
return NULL;
|
2006-11-15 17:05:55 +00:00
|
|
|
}
|
|
|
|
|
2006-11-17 11:12:13 +00:00
|
|
|
if (a->argc == e->args) {
|
2009-05-21 21:13:09 +00:00
|
|
|
if (!strcasecmp(a->argv[e->args-1],"concise"))
|
2006-11-15 17:05:55 +00:00
|
|
|
concise = 1;
|
2009-05-21 21:13:09 +00:00
|
|
|
else if (!strcasecmp(a->argv[e->args-1],"verbose"))
|
2006-11-15 17:05:55 +00:00
|
|
|
verbose = 1;
|
2009-05-21 21:13:09 +00:00
|
|
|
else if (!strcasecmp(a->argv[e->args-1],"count"))
|
2007-01-29 17:49:04 +00:00
|
|
|
count = 1;
|
2006-11-15 17:05:55 +00:00
|
|
|
else
|
|
|
|
return CLI_SHOWUSAGE;
|
2006-11-17 11:12:13 +00:00
|
|
|
} else if (a->argc != e->args - 1)
|
2006-11-15 17:05:55 +00:00
|
|
|
return CLI_SHOWUSAGE;
|
2005-08-08 01:45:29 +00:00
|
|
|
|
2007-01-29 17:49:04 +00:00
|
|
|
if (!count) {
|
|
|
|
if (!concise && !verbose)
|
2009-05-21 21:13:09 +00:00
|
|
|
ast_cli(a->fd, FORMAT_STRING2, "Channel", "Location", "State", "Application(Data)");
|
2007-01-29 17:49:04 +00:00
|
|
|
else if (verbose)
|
2009-05-21 21:13:09 +00:00
|
|
|
ast_cli(a->fd, VERBOSE_FORMAT_STRING2, "Channel", "Context", "Extension", "Priority", "State", "Application", "Data",
|
2009-06-26 15:28:53 +00:00
|
|
|
"CallerID", "Duration", "Accountcode", "PeerAccount", "BridgedTo");
|
2007-01-29 17:49:04 +00:00
|
|
|
}
|
2006-03-28 22:25:08 +00:00
|
|
|
|
2009-10-21 21:08:47 +00:00
|
|
|
if (!count && !(iter = ast_channel_iterator_all_new())) {
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
return CLI_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (; iter && (c = ast_channel_iterator_next(iter)); ast_channel_unref(c)) {
|
|
|
|
struct ast_channel *bc;
|
2006-11-15 17:17:07 +00:00
|
|
|
char durbuf[10] = "-";
|
|
|
|
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
ast_channel_lock(c);
|
|
|
|
|
|
|
|
bc = ast_bridged_channel(c);
|
|
|
|
|
2007-01-29 17:49:04 +00:00
|
|
|
if (!count) {
|
2012-02-20 23:43:27 +00:00
|
|
|
if ((concise || verbose) && ast_channel_cdr(c) && !ast_tvzero(ast_channel_cdr(c)->start)) {
|
|
|
|
int duration = (int)(ast_tvdiff_ms(ast_tvnow(), ast_channel_cdr(c)->start) / 1000);
|
2007-01-29 17:49:04 +00:00
|
|
|
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) {
|
2012-02-20 23:43:27 +00:00
|
|
|
ast_cli(a->fd, CONCISE_FORMAT_STRING, ast_channel_name(c), ast_channel_context(c), ast_channel_exten(c), ast_channel_priority(c), ast_state2str(ast_channel_state(c)),
|
2012-02-13 17:27:06 +00:00
|
|
|
ast_channel_appl(c) ? ast_channel_appl(c) : "(None)",
|
|
|
|
S_OR(ast_channel_data(c), ""), /* XXX different from verbose ? */
|
2012-02-29 16:52:47 +00:00
|
|
|
S_COR(ast_channel_caller(c)->id.number.valid, ast_channel_caller(c)->id.number.str, ""),
|
2012-01-24 20:12:09 +00:00
|
|
|
S_OR(ast_channel_accountcode(c), ""),
|
|
|
|
S_OR(ast_channel_peeraccount(c), ""),
|
2012-02-20 23:43:27 +00:00
|
|
|
ast_channel_amaflags(c),
|
2007-01-29 17:49:04 +00:00
|
|
|
durbuf,
|
2012-01-09 22:15:50 +00:00
|
|
|
bc ? ast_channel_name(bc) : "(None)",
|
2012-01-24 20:12:09 +00:00
|
|
|
ast_channel_uniqueid(c));
|
2007-01-29 17:49:04 +00:00
|
|
|
} else if (verbose) {
|
2012-02-20 23:43:27 +00:00
|
|
|
ast_cli(a->fd, VERBOSE_FORMAT_STRING, ast_channel_name(c), ast_channel_context(c), ast_channel_exten(c), ast_channel_priority(c), ast_state2str(ast_channel_state(c)),
|
2012-02-13 17:27:06 +00:00
|
|
|
ast_channel_appl(c) ? ast_channel_appl(c) : "(None)",
|
|
|
|
ast_channel_data(c) ? S_OR(ast_channel_data(c), "(Empty)" ): "(None)",
|
2012-02-29 16:52:47 +00:00
|
|
|
S_COR(ast_channel_caller(c)->id.number.valid, ast_channel_caller(c)->id.number.str, ""),
|
2007-01-29 17:49:04 +00:00
|
|
|
durbuf,
|
2012-01-24 20:12:09 +00:00
|
|
|
S_OR(ast_channel_accountcode(c), ""),
|
|
|
|
S_OR(ast_channel_peeraccount(c), ""),
|
2012-01-09 22:15:50 +00:00
|
|
|
bc ? ast_channel_name(bc) : "(None)");
|
2005-08-08 01:45:29 +00:00
|
|
|
} else {
|
2007-01-29 17:49:04 +00:00
|
|
|
char locbuf[40] = "(None)";
|
|
|
|
char appdata[40] = "(None)";
|
|
|
|
|
2012-02-13 17:27:06 +00:00
|
|
|
if (!ast_strlen_zero(ast_channel_context(c)) && !ast_strlen_zero(ast_channel_exten(c)))
|
2012-02-20 23:43:27 +00:00
|
|
|
snprintf(locbuf, sizeof(locbuf), "%s@%s:%d", ast_channel_exten(c), ast_channel_context(c), ast_channel_priority(c));
|
2012-02-13 17:27:06 +00:00
|
|
|
if (ast_channel_appl(c))
|
|
|
|
snprintf(appdata, sizeof(appdata), "%s(%s)", ast_channel_appl(c), S_OR(ast_channel_data(c), ""));
|
2012-02-20 23:43:27 +00:00
|
|
|
ast_cli(a->fd, FORMAT_STRING, ast_channel_name(c), locbuf, ast_state2str(ast_channel_state(c)), appdata);
|
2007-01-29 17:49:04 +00:00
|
|
|
}
|
2005-08-08 01:45:29 +00:00
|
|
|
}
|
2006-04-29 14:50:18 +00:00
|
|
|
ast_channel_unlock(c);
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
|
|
|
|
if (iter) {
|
|
|
|
ast_channel_iterator_destroy(iter);
|
|
|
|
}
|
|
|
|
|
2005-08-08 01:45:29 +00:00
|
|
|
if (!concise) {
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
numchans = ast_active_channels();
|
2009-05-21 21:13:09 +00:00
|
|
|
ast_cli(a->fd, "%d active channel%s\n", numchans, ESS(numchans));
|
2005-05-18 01:49:13 +00:00
|
|
|
if (option_maxcalls)
|
2009-05-21 21:13:09 +00:00
|
|
|
ast_cli(a->fd, "%d of %d max active call%s (%5.2f%% of capacity)\n",
|
2006-03-28 22:25:08 +00:00
|
|
|
ast_active_calls(), option_maxcalls, ESS(ast_active_calls()),
|
|
|
|
((double)ast_active_calls() / (double)option_maxcalls) * 100.0);
|
2005-05-18 01:49:13 +00:00
|
|
|
else
|
2009-05-21 21:13:09 +00:00
|
|
|
ast_cli(a->fd, "%d active call%s\n", ast_active_calls(), ESS(ast_active_calls()));
|
2007-12-07 16:11:05 +00:00
|
|
|
|
2009-05-21 21:13:09 +00:00
|
|
|
ast_cli(a->fd, "%d call%s processed\n", ast_processed_calls(), ESS(ast_processed_calls()));
|
2005-05-18 01:49:13 +00:00
|
|
|
}
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
|
2006-11-15 17:05:55 +00:00
|
|
|
return CLI_SUCCESS;
|
2005-08-08 01:45:29 +00:00
|
|
|
|
|
|
|
#undef FORMAT_STRING
|
|
|
|
#undef FORMAT_STRING2
|
|
|
|
#undef CONCISE_FORMAT_STRING
|
|
|
|
#undef VERBOSE_FORMAT_STRING
|
|
|
|
#undef VERBOSE_FORMAT_STRING2
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
static char *handle_softhangup(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
2001-05-09 03:11:22 +00:00
|
|
|
{
|
|
|
|
struct ast_channel *c=NULL;
|
2007-10-11 19:03:06 +00:00
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case CLI_INIT:
|
2008-09-28 23:32:14 +00:00
|
|
|
e->command = "channel request hangup";
|
2007-10-11 19:03:06 +00:00
|
|
|
e->usage =
|
2010-05-19 15:12:18 +00:00
|
|
|
"Usage: channel request hangup <channel>|<all>\n"
|
2007-10-11 19:03:06 +00:00
|
|
|
" Request that a channel be hung up. The hangup takes effect\n"
|
2010-05-19 15:12:18 +00:00
|
|
|
" 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";
|
2007-10-11 19:03:06 +00:00
|
|
|
return NULL;
|
|
|
|
case CLI_GENERATE:
|
2008-10-17 17:31:07 +00:00
|
|
|
return ast_complete_channels(a->line, a->word, a->pos, a->n, e->args);
|
2007-10-11 19:03:06 +00:00
|
|
|
}
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
|
|
|
|
if (a->argc != 4) {
|
2007-10-11 19:03:06 +00:00
|
|
|
return CLI_SHOWUSAGE;
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
}
|
|
|
|
|
2010-05-19 15:12:18 +00:00
|
|
|
if (!strcasecmp(a->argv[3], "all")) {
|
|
|
|
struct ast_channel_iterator *iter = NULL;
|
2010-05-19 15:39:39 +00:00
|
|
|
if (!(iter = ast_channel_iterator_all_new())) {
|
2010-05-19 15:12:18 +00:00
|
|
|
return CLI_FAILURE;
|
|
|
|
}
|
|
|
|
for (; iter && (c = ast_channel_iterator_next(iter)); ast_channel_unref(c)) {
|
|
|
|
ast_channel_lock(c);
|
2012-01-09 22:15:50 +00:00
|
|
|
ast_cli(a->fd, "Requested Hangup on channel '%s'\n", ast_channel_name(c));
|
2010-05-19 15:12:18 +00:00
|
|
|
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]))) {
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
ast_channel_lock(c);
|
2012-01-09 22:15:50 +00:00
|
|
|
ast_cli(a->fd, "Requested Hangup on channel '%s'\n", ast_channel_name(c));
|
2005-06-06 02:29:18 +00:00
|
|
|
ast_softhangup(c, AST_SOFTHANGUP_EXPLICIT);
|
2006-04-29 14:50:18 +00:00
|
|
|
ast_channel_unlock(c);
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
c = ast_channel_unref(c);
|
|
|
|
} else {
|
2008-10-17 17:31:07 +00:00
|
|
|
ast_cli(a->fd, "%s is not a known channel\n", a->argv[3]);
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
}
|
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
return CLI_SUCCESS;
|
2001-05-09 03:11:22 +00:00
|
|
|
}
|
|
|
|
|
2008-12-01 18:52:14 +00:00
|
|
|
/*! \brief handles CLI command 'cli show permissions' */
|
|
|
|
static char *handle_cli_show_permissions(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief handles CLI command 'cli reload permissions' */
|
|
|
|
static char *handle_cli_reload_permissions(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief handles CLI command 'cli check permissions' */
|
|
|
|
static char *handle_cli_check_permissions(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2006-01-18 22:17:31 +00:00
|
|
|
static char *__ast_cli_generator(const char *text, const char *word, int state, int lock);
|
2001-05-09 03:11:22 +00:00
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
static char *handle_commandmatchesarray(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
2003-01-30 15:03:20 +00:00
|
|
|
{
|
2004-10-14 04:12:05 +00:00
|
|
|
char *buf, *obuf;
|
2004-04-06 07:42:01 +00:00
|
|
|
int buflen = 2048;
|
2003-01-30 15:03:20 +00:00
|
|
|
int len = 0;
|
|
|
|
char **matches;
|
2004-10-14 04:12:05 +00:00
|
|
|
int x, matchlen;
|
2007-10-11 19:03:06 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2003-01-30 15:03:20 +00:00
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
if (a->argc != 4)
|
|
|
|
return CLI_SHOWUSAGE;
|
2006-02-09 16:59:50 +00:00
|
|
|
if (!(buf = ast_malloc(buflen)))
|
2007-10-11 19:03:06 +00:00
|
|
|
return CLI_FAILURE;
|
2003-01-30 15:03:20 +00:00
|
|
|
buf[len] = '\0';
|
2007-10-11 19:03:06 +00:00
|
|
|
matches = ast_cli_completion_matches(a->argv[2], a->argv[3]);
|
2003-01-30 15:03:20 +00:00
|
|
|
if (matches) {
|
|
|
|
for (x=0; matches[x]; x++) {
|
2004-10-14 04:12:05 +00:00
|
|
|
matchlen = strlen(matches[x]) + 1;
|
|
|
|
if (len + matchlen >= buflen) {
|
|
|
|
buflen += matchlen * 3;
|
|
|
|
obuf = buf;
|
2006-02-09 16:59:50 +00:00
|
|
|
if (!(buf = ast_realloc(obuf, buflen)))
|
|
|
|
/* Memory allocation failure... Just free old buffer and be done */
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(obuf);
|
2004-04-06 07:42:01 +00:00
|
|
|
}
|
2004-10-14 04:12:05 +00:00
|
|
|
if (buf)
|
|
|
|
len += sprintf( buf + len, "%s ", matches[x]);
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(matches[x]);
|
2003-04-08 13:45:36 +00:00
|
|
|
matches[x] = NULL;
|
2003-01-30 15:03:20 +00:00
|
|
|
}
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(matches);
|
2003-01-30 15:03:20 +00:00
|
|
|
}
|
2006-03-28 22:25:08 +00:00
|
|
|
|
2003-01-30 15:03:20 +00:00
|
|
|
if (buf) {
|
2007-10-11 19:03:06 +00:00
|
|
|
ast_cli(a->fd, "%s%s",buf, AST_CLI_COMPLETE_EOF);
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(buf);
|
2003-01-30 15:03:20 +00:00
|
|
|
} else
|
2007-10-11 19:03:06 +00:00
|
|
|
ast_cli(a->fd, "NULL\n");
|
2003-01-30 15:03:20 +00:00
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
return CLI_SUCCESS;
|
2003-01-30 15:03:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
static char *handle_commandnummatches(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
2003-01-30 15:03:20 +00:00
|
|
|
{
|
|
|
|
int matches = 0;
|
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
switch (cmd) {
|
|
|
|
case CLI_INIT:
|
|
|
|
e->command = "_command nummatches";
|
|
|
|
e->usage =
|
|
|
|
"Usage: _command nummatches \"<line>\" text \n"
|
|
|
|
" This function is used internally to help with command completion and should.\n"
|
|
|
|
" never be called by the user directly.\n";
|
|
|
|
return NULL;
|
|
|
|
case CLI_GENERATE:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (a->argc != 4)
|
|
|
|
return CLI_SHOWUSAGE;
|
2003-01-30 15:03:20 +00:00
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
matches = ast_cli_generatornummatches(a->argv[2], a->argv[3]);
|
2003-01-30 15:03:20 +00:00
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
ast_cli(a->fd, "%d", matches);
|
2003-01-30 15:03:20 +00:00
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
return CLI_SUCCESS;
|
2003-01-30 15:03:20 +00:00
|
|
|
}
|
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
static char *handle_commandcomplete(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
2001-05-09 03:11:22 +00:00
|
|
|
{
|
|
|
|
char *buf;
|
2007-10-11 19:03:06 +00:00
|
|
|
switch (cmd) {
|
|
|
|
case CLI_INIT:
|
|
|
|
e->command = "_command complete";
|
|
|
|
e->usage =
|
|
|
|
"Usage: _command complete \"<line>\" text state\n"
|
|
|
|
" This function is used internally to help with command completion and should.\n"
|
|
|
|
" never be called by the user directly.\n";
|
|
|
|
return NULL;
|
|
|
|
case CLI_GENERATE:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (a->argc != 5)
|
|
|
|
return CLI_SHOWUSAGE;
|
|
|
|
buf = __ast_cli_generator(a->argv[2], a->argv[3], atoi(a->argv[4]), 0);
|
2001-05-09 03:11:22 +00:00
|
|
|
if (buf) {
|
2008-03-18 15:43:34 +00:00
|
|
|
ast_cli(a->fd, "%s", buf);
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(buf);
|
2001-05-09 03:11:22 +00:00
|
|
|
} else
|
2007-10-11 19:03:06 +00:00
|
|
|
ast_cli(a->fd, "NULL\n");
|
|
|
|
return CLI_SUCCESS;
|
2001-05-09 03:11:22 +00:00
|
|
|
}
|
|
|
|
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
struct channel_set_debug_args {
|
|
|
|
int fd;
|
|
|
|
int is_off;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int channel_set_debug(void *obj, void *arg, void *data, int flags)
|
|
|
|
{
|
|
|
|
struct ast_channel *chan = obj;
|
|
|
|
struct channel_set_debug_args *args = data;
|
|
|
|
|
|
|
|
ast_channel_lock(chan);
|
|
|
|
|
2012-02-20 23:43:27 +00:00
|
|
|
if (!(ast_channel_fin(chan) & DEBUGCHAN_FLAG) || !(ast_channel_fout(chan) & DEBUGCHAN_FLAG)) {
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
if (args->is_off) {
|
2012-02-20 23:43:27 +00:00
|
|
|
ast_channel_fin_set(chan, ast_channel_fin(chan) & ~DEBUGCHAN_FLAG);
|
|
|
|
ast_channel_fout_set(chan, ast_channel_fout(chan) & ~DEBUGCHAN_FLAG);
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
} else {
|
2012-02-20 23:43:27 +00:00
|
|
|
ast_channel_fin_set(chan, ast_channel_fin(chan) | DEBUGCHAN_FLAG);
|
|
|
|
ast_channel_fout_set(chan, ast_channel_fout(chan) | DEBUGCHAN_FLAG);
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
}
|
|
|
|
ast_cli(args->fd, "Debugging %s on channel %s\n", args->is_off ? "disabled" : "enabled",
|
2012-01-09 22:15:50 +00:00
|
|
|
ast_channel_name(chan));
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-11-15 16:13:30 +00:00
|
|
|
static char *handle_core_set_debug_channel(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
2006-11-10 17:01:06 +00:00
|
|
|
{
|
|
|
|
struct ast_channel *c = NULL;
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
struct channel_set_debug_args args = {
|
|
|
|
.fd = a->fd,
|
|
|
|
};
|
2006-11-10 17:01:06 +00:00
|
|
|
|
2006-11-15 16:13:30 +00:00
|
|
|
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:
|
|
|
|
/* XXX remember to handle the optional "off" */
|
|
|
|
if (a->pos != e->args)
|
|
|
|
return NULL;
|
2007-06-14 23:01:01 +00:00
|
|
|
return a->n == 0 ? ast_strdup("all") : ast_complete_channels(a->line, a->word, a->pos, a->n - 1, e->args);
|
2006-11-15 16:13:30 +00:00
|
|
|
}
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
|
2009-05-21 21:13:09 +00:00
|
|
|
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}' */
|
2006-11-15 16:13:30 +00:00
|
|
|
if (!strcasecmp(a->argv[e->args + 1], "off"))
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
args.is_off = 1;
|
2006-11-15 16:13:30 +00:00
|
|
|
else
|
|
|
|
return CLI_SHOWUSAGE;
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
} else if (a->argc != e->args + 1) {
|
2006-11-15 16:13:30 +00:00
|
|
|
return CLI_SHOWUSAGE;
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
}
|
2006-11-10 17:01:06 +00:00
|
|
|
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
if (!strcasecmp("all", a->argv[e->args])) {
|
|
|
|
if (args.is_off) {
|
2006-11-10 17:01:06 +00:00
|
|
|
global_fin &= ~DEBUGCHAN_FLAG;
|
|
|
|
global_fout &= ~DEBUGCHAN_FLAG;
|
|
|
|
} else {
|
|
|
|
global_fin |= DEBUGCHAN_FLAG;
|
|
|
|
global_fout |= DEBUGCHAN_FLAG;
|
|
|
|
}
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
ast_channel_callback(channel_set_debug, NULL, &args, OBJ_NODATA | OBJ_MULTIPLE);
|
2006-11-10 17:01:06 +00:00
|
|
|
} else {
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
if ((c = ast_channel_get_by_name(a->argv[e->args]))) {
|
|
|
|
channel_set_debug(c, NULL, &args, 0);
|
|
|
|
ast_channel_unref(c);
|
|
|
|
} else {
|
2006-11-15 16:13:30 +00:00
|
|
|
ast_cli(a->fd, "No such channel %s\n", a->argv[e->args]);
|
2006-11-10 17:01:06 +00:00
|
|
|
}
|
|
|
|
}
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
|
|
|
|
ast_cli(a->fd, "Debugging on new channels is %s\n", args.is_off ? "disabled" : "enabled");
|
|
|
|
|
2007-11-28 20:27:40 +00:00
|
|
|
return CLI_SUCCESS;
|
2006-11-10 17:01:06 +00:00
|
|
|
}
|
|
|
|
|
2006-11-15 16:13:30 +00:00
|
|
|
static char *handle_nodebugchan_deprecated(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
2006-09-18 19:54:18 +00:00
|
|
|
{
|
2006-11-15 16:13:30 +00:00
|
|
|
char *res;
|
2009-05-21 21:13:09 +00:00
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case CLI_INIT:
|
2006-11-15 16:13:30 +00:00
|
|
|
e->command = "no debug channel";
|
2009-05-21 21:13:09 +00:00
|
|
|
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);
|
|
|
|
|
2006-11-15 16:13:30 +00:00
|
|
|
return res;
|
2006-09-18 19:54:18 +00:00
|
|
|
}
|
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
static char *handle_showchan(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
1999-12-19 22:38:55 +00:00
|
|
|
{
|
|
|
|
struct ast_channel *c=NULL;
|
2004-08-03 17:48:18 +00:00
|
|
|
struct timeval now;
|
2004-12-26 11:08:34 +00:00
|
|
|
char cdrtime[256];
|
2011-02-03 16:22:10 +00:00
|
|
|
char nf[256];
|
2010-08-12 20:17:17 +00:00
|
|
|
struct ast_str *write_transpath = ast_str_alloca(256);
|
|
|
|
struct ast_str *read_transpath = ast_str_alloca(256);
|
2011-11-11 18:02:52 +00:00
|
|
|
struct ast_str *obuf;/*!< Buffer for variable, CDR variable, and trace output. */
|
|
|
|
struct ast_str *output;/*!< Accumulation buffer for all output. */
|
2004-08-03 17:48:18 +00:00
|
|
|
long elapsed_seconds=0;
|
2004-09-03 03:44:35 +00:00
|
|
|
int hour=0, min=0, sec=0;
|
2008-02-18 04:43:33 +00:00
|
|
|
#ifdef CHANNEL_TRACE
|
|
|
|
int trace_enabled;
|
|
|
|
#endif
|
2007-10-11 19:03:06 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2005-02-23 22:48:47 +00:00
|
|
|
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
if (a->argc != 4) {
|
2007-10-11 19:03:06 +00:00
|
|
|
return CLI_SHOWUSAGE;
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
}
|
|
|
|
|
2005-07-15 23:00:47 +00:00
|
|
|
now = ast_tvnow();
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
|
|
|
|
if (!(c = ast_channel_get_by_name(a->argv[3]))) {
|
2007-10-11 19:03:06 +00:00
|
|
|
ast_cli(a->fd, "%s is not a known channel\n", a->argv[3]);
|
|
|
|
return CLI_SUCCESS;
|
2005-06-06 02:29:18 +00:00
|
|
|
}
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
|
2011-11-11 18:02:52 +00:00
|
|
|
obuf = ast_str_thread_get(&ast_str_thread_global_buf, 16);
|
|
|
|
if (!obuf) {
|
|
|
|
return CLI_FAILURE;
|
|
|
|
}
|
|
|
|
output = ast_str_create(8192);
|
|
|
|
if (!output) {
|
|
|
|
return CLI_FAILURE;
|
|
|
|
}
|
|
|
|
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
ast_channel_lock(c);
|
|
|
|
|
2012-02-20 23:43:27 +00:00
|
|
|
if (ast_channel_cdr(c)) {
|
|
|
|
elapsed_seconds = now.tv_sec - ast_channel_cdr(c)->start.tv_sec;
|
2005-06-06 02:29:18 +00:00
|
|
|
hour = elapsed_seconds / 3600;
|
|
|
|
min = (elapsed_seconds % 3600) / 60;
|
|
|
|
sec = elapsed_seconds % 60;
|
|
|
|
snprintf(cdrtime, sizeof(cdrtime), "%dh%dm%ds", hour, min, sec);
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
} else {
|
2005-07-10 22:56:21 +00:00
|
|
|
strcpy(cdrtime, "N/A");
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
}
|
|
|
|
|
2011-11-11 18:02:52 +00:00
|
|
|
ast_str_append(&output, 0,
|
2005-06-06 02:29:18 +00:00
|
|
|
" -- General --\n"
|
|
|
|
" Name: %s\n"
|
|
|
|
" Type: %s\n"
|
|
|
|
" UniqueID: %s\n"
|
2009-06-26 15:28:53 +00:00
|
|
|
" LinkedID: %s\n"
|
2005-06-06 02:29:18 +00:00
|
|
|
" Caller ID: %s\n"
|
|
|
|
" Caller ID Name: %s\n"
|
2011-04-11 22:28:43 +00:00
|
|
|
"Connected Line ID: %s\n"
|
|
|
|
"Connected Line ID Name: %s\n"
|
2005-06-06 02:29:18 +00:00
|
|
|
" DNID Digits: %s\n"
|
2007-03-02 16:59:22 +00:00
|
|
|
" Language: %s\n"
|
2005-06-06 02:29:18 +00:00
|
|
|
" State: %s (%d)\n"
|
|
|
|
" Rings: %d\n"
|
2006-01-07 17:54:22 +00:00
|
|
|
" NativeFormats: %s\n"
|
|
|
|
" WriteFormat: %s\n"
|
|
|
|
" ReadFormat: %s\n"
|
2010-08-12 20:17:17 +00:00
|
|
|
" WriteTranscode: %s %s\n"
|
|
|
|
" ReadTranscode: %s %s\n"
|
2005-06-06 02:29:18 +00:00
|
|
|
"1st File Descriptor: %d\n"
|
|
|
|
" Frames in: %d%s\n"
|
|
|
|
" Frames out: %d%s\n"
|
|
|
|
" Time to Hangup: %ld\n"
|
|
|
|
" Elapsed Time: %s\n"
|
|
|
|
" Direct Bridge: %s\n"
|
|
|
|
"Indirect Bridge: %s\n"
|
|
|
|
" -- PBX --\n"
|
|
|
|
" Context: %s\n"
|
|
|
|
" Extension: %s\n"
|
|
|
|
" Priority: %d\n"
|
2006-09-29 13:46:33 +00:00
|
|
|
" Call Group: %llu\n"
|
|
|
|
" Pickup Group: %llu\n"
|
2005-06-06 02:29:18 +00:00
|
|
|
" Application: %s\n"
|
|
|
|
" Data: %s\n"
|
|
|
|
" Blocking in: %s\n",
|
2012-02-20 23:43:27 +00:00
|
|
|
ast_channel_name(c), ast_channel_tech(c)->type, ast_channel_uniqueid(c), ast_channel_linkedid(c),
|
2012-02-29 16:52:47 +00:00
|
|
|
S_COR(ast_channel_caller(c)->id.number.valid, ast_channel_caller(c)->id.number.str, "(N/A)"),
|
|
|
|
S_COR(ast_channel_caller(c)->id.name.valid, ast_channel_caller(c)->id.name.str, "(N/A)"),
|
|
|
|
S_COR(ast_channel_connected(c)->id.number.valid, ast_channel_connected(c)->id.number.str, "(N/A)"),
|
|
|
|
S_COR(ast_channel_connected(c)->id.name.valid, ast_channel_connected(c)->id.name.str, "(N/A)"),
|
|
|
|
S_OR(ast_channel_dialed(c)->number.str, "(N/A)"),
|
2012-01-24 20:12:09 +00:00
|
|
|
ast_channel_language(c),
|
2012-02-20 23:43:27 +00:00
|
|
|
ast_state2str(ast_channel_state(c)), ast_channel_state(c), ast_channel_rings(c),
|
|
|
|
ast_getformatname_multiple(nf, sizeof(nf), ast_channel_nativeformats(c)),
|
2012-02-24 00:32:20 +00:00
|
|
|
ast_getformatname(ast_channel_writeformat(c)),
|
|
|
|
ast_getformatname(ast_channel_readformat(c)),
|
2012-02-20 23:43:27 +00:00
|
|
|
ast_channel_writetrans(c) ? "Yes" : "No",
|
|
|
|
ast_translate_path_to_str(ast_channel_writetrans(c), &write_transpath),
|
|
|
|
ast_channel_readtrans(c) ? "Yes" : "No",
|
|
|
|
ast_translate_path_to_str(ast_channel_readtrans(c), &read_transpath),
|
2012-03-01 22:09:18 +00:00
|
|
|
ast_channel_fd(c, 0),
|
2012-02-20 23:43:27 +00:00
|
|
|
ast_channel_fin(c) & ~DEBUGCHAN_FLAG, (ast_channel_fin(c) & DEBUGCHAN_FLAG) ? " (DEBUGGED)" : "",
|
|
|
|
ast_channel_fout(c) & ~DEBUGCHAN_FLAG, (ast_channel_fout(c) & DEBUGCHAN_FLAG) ? " (DEBUGGED)" : "",
|
2012-02-29 16:52:47 +00:00
|
|
|
(long)ast_channel_whentohangup(c)->tv_sec,
|
2012-01-09 22:15:50 +00:00
|
|
|
cdrtime, c->_bridge ? ast_channel_name(c->_bridge) : "<none>", ast_bridged_channel(c) ? ast_channel_name(ast_bridged_channel(c)) : "<none>",
|
2012-03-01 22:09:18 +00:00
|
|
|
ast_channel_context(c), ast_channel_exten(c), ast_channel_priority(c), ast_channel_callgroup(c), ast_channel_pickupgroup(c), (ast_channel_appl(c) ? ast_channel_appl(c) : "(N/A)" ),
|
2012-02-13 17:27:06 +00:00
|
|
|
(ast_channel_data(c) ? S_OR(ast_channel_data(c), "(Empty)") : "(None)"),
|
|
|
|
(ast_test_flag(c, AST_FLAG_BLOCKING) ? ast_channel_blockproc(c) : "(Not Blocking)"));
|
2005-06-06 02:29:18 +00:00
|
|
|
|
2011-11-11 18:02:52 +00:00
|
|
|
if (pbx_builtin_serialize_variables(c, &obuf)) {
|
|
|
|
ast_str_append(&output, 0, " Variables:\n%s\n", ast_str_buffer(obuf));
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
}
|
|
|
|
|
2012-02-20 23:43:27 +00:00
|
|
|
if (ast_channel_cdr(c) && ast_cdr_serialize_variables(ast_channel_cdr(c), &obuf, '=', '\n', 1)) {
|
2011-11-11 18:02:52 +00:00
|
|
|
ast_str_append(&output, 0, " CDR Variables:\n%s\n", ast_str_buffer(obuf));
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
}
|
|
|
|
|
2008-02-18 04:43:33 +00:00
|
|
|
#ifdef CHANNEL_TRACE
|
|
|
|
trace_enabled = ast_channel_trace_is_enabled(c);
|
2011-11-11 18:02:52 +00:00
|
|
|
ast_str_append(&output, 0, " Context Trace: %s\n",
|
|
|
|
trace_enabled ? "Enabled" : "Disabled");
|
|
|
|
if (trace_enabled && ast_channel_trace_serialize(c, &obuf)) {
|
|
|
|
ast_str_append(&output, 0, " Trace:\n%s\n", ast_str_buffer(obuf));
|
|
|
|
}
|
2008-02-18 04:43:33 +00:00
|
|
|
#endif
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
|
2006-04-29 14:50:18 +00:00
|
|
|
ast_channel_unlock(c);
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
c = ast_channel_unref(c);
|
|
|
|
|
2011-11-11 18:02:52 +00:00
|
|
|
ast_cli(a->fd, "%s", ast_str_buffer(output));
|
|
|
|
ast_free(output);
|
2007-10-11 19:03:06 +00:00
|
|
|
return CLI_SUCCESS;
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
|
|
|
|
2006-03-28 22:25:08 +00:00
|
|
|
/*
|
|
|
|
* helper function to generate CLI matches from a fixed set of values.
|
|
|
|
* A NULL word is acceptable.
|
|
|
|
*/
|
2009-05-21 21:13:09 +00:00
|
|
|
char *ast_cli_complete(const char *word, const char * const choices[], int state)
|
2005-08-08 01:45:29 +00:00
|
|
|
{
|
2006-03-28 22:25:08 +00:00
|
|
|
int i, which = 0, len;
|
|
|
|
len = ast_strlen_zero(word) ? 0 : strlen(word);
|
2005-11-29 04:25:28 +00:00
|
|
|
|
2006-03-28 22:25:08 +00:00
|
|
|
for (i = 0; choices[i]; i++) {
|
|
|
|
if ((!len || !strncasecmp(word, choices[i], len)) && ++which > state)
|
|
|
|
return ast_strdup(choices[i]);
|
2005-08-08 01:45:29 +00:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-02-16 17:37:03 +00:00
|
|
|
char *ast_complete_channels(const char *line, const char *word, int pos, int state, int rpos)
|
1999-12-19 22:38:55 +00:00
|
|
|
{
|
2005-06-06 02:29:18 +00:00
|
|
|
struct ast_channel *c = NULL;
|
2005-11-29 04:25:28 +00:00
|
|
|
int which = 0;
|
2006-03-28 22:25:08 +00:00
|
|
|
char notfound = '\0';
|
|
|
|
char *ret = ¬found; /* so NULL can break the loop */
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
struct ast_channel_iterator *iter;
|
2005-06-06 02:29:18 +00:00
|
|
|
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
if (pos != rpos) {
|
2004-08-07 19:27:54 +00:00
|
|
|
return NULL;
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
}
|
2005-11-29 04:25:28 +00:00
|
|
|
|
2010-08-10 16:22:58 +00:00
|
|
|
if (ast_strlen_zero(word)) {
|
|
|
|
iter = ast_channel_iterator_all_new();
|
|
|
|
} else {
|
|
|
|
iter = ast_channel_iterator_by_name_new(word, strlen(word));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!iter) {
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
2005-11-29 04:25:28 +00:00
|
|
|
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
while (ret == ¬found && (c = ast_channel_iterator_next(iter))) {
|
|
|
|
if (++which > state) {
|
|
|
|
ast_channel_lock(c);
|
2012-01-09 22:15:50 +00:00
|
|
|
ret = ast_strdup(ast_channel_name(c));
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
ast_channel_unlock(c);
|
|
|
|
}
|
|
|
|
ast_channel_unref(c);
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
Convert the ast_channel data structure over to the astobj2 framework.
There is a lot that could be said about this, but the patch is a big
improvement for performance, stability, code maintainability,
and ease of future code development.
The channel list is no longer an unsorted linked list. The main container
for channels is an astobj2 hash table. All of the code related to searching
for channels or iterating active channels has been rewritten. Let n be
the number of active channels. Iterating the channel list has gone from
O(n^2) to O(n). Searching for a channel by name went from O(n) to O(1).
Searching for a channel by extension is still O(n), but uses a new method
for doing so, which is more efficient.
The ast_channel object is now a reference counted object. The benefits
here are plentiful. Some benefits directly related to issues in the
previous code include:
1) When threads other than the channel thread owning a channel wanted
access to a channel, it had to hold the lock on it to ensure that it didn't
go away. This is no longer a requirement. Holding a reference is
sufficient.
2) There are places that now require less dealing with channel locks.
3) There are places where channel locks are held for much shorter periods
of time.
4) There are places where dealing with more than one channel at a time becomes
_MUCH_ easier. ChanSpy is a great example of this. Writing code in the
future that deals with multiple channels will be much easier.
Some additional information regarding channel locking and reference count
handling can be found in channel.h, where a new section has been added that
discusses some of the rules associated with it.
Mark Michelson also assisted with the development of this patch. He did the
conversion of ChanSpy and introduced a new API, ast_autochan, which makes it
much easier to deal with holding on to a channel pointer for an extended period
of time and having it get automatically updated if the channel gets masqueraded.
Mark was also a huge help in the code review process.
Thanks to David Vossel for his assistance with this branch, as well. David
did the conversion of the DAHDIScan application by making it become a wrapper
for ChanSpy internally.
The changes come from the svn/asterisk/team/russell/ast_channel_ao2 branch.
Review: http://reviewboard.digium.com/r/203/
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@190423 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2009-04-24 14:04:26 +00:00
|
|
|
|
2009-10-21 21:08:47 +00:00
|
|
|
ast_channel_iterator_destroy(iter);
|
|
|
|
|
2006-03-28 22:25:08 +00:00
|
|
|
return ret == ¬found ? NULL : ret;
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
static char *group_show_channels(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
This is the first round of removing applications that were marked as deprecated
in the 1.2 release. They are being removed from the trunk and will not be in
the next major release. The following is a list of the applications that are
being removed in this commit:
Curl, Cut, Sort, DBPut, DBGet, ENUMLookup, Eval
GetGroupCount, SetGroup, CheckGroup, GetGroupMatchCount
MD5, MD5Check, Math, SetCIDName, SetCIDNum, SetRDNIS, SetCallerID
TXTCIDName, AbsoluteTimeout, DigitTimeout, ResponseTimeout, SetAccount
SetLanguage, SetVar (renamed to Set)
These changes also include moving the "group show channels" cli command from
app_groupcount.c to cli.c.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@7379 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2005-12-07 15:36:55 +00:00
|
|
|
{
|
|
|
|
#define FORMAT_STRING "%-25s %-20s %-20s\n"
|
|
|
|
|
2007-04-25 19:27:42 +00:00
|
|
|
struct ast_group_info *gi = NULL;
|
This is the first round of removing applications that were marked as deprecated
in the 1.2 release. They are being removed from the trunk and will not be in
the next major release. The following is a list of the applications that are
being removed in this commit:
Curl, Cut, Sort, DBPut, DBGet, ENUMLookup, Eval
GetGroupCount, SetGroup, CheckGroup, GetGroupMatchCount
MD5, MD5Check, Math, SetCIDName, SetCIDNum, SetRDNIS, SetCallerID
TXTCIDName, AbsoluteTimeout, DigitTimeout, ResponseTimeout, SetAccount
SetLanguage, SetVar (renamed to Set)
These changes also include moving the "group show channels" cli command from
app_groupcount.c to cli.c.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@7379 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2005-12-07 15:36:55 +00:00
|
|
|
int numchans = 0;
|
|
|
|
regex_t regexbuf;
|
|
|
|
int havepattern = 0;
|
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
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;
|
This is the first round of removing applications that were marked as deprecated
in the 1.2 release. They are being removed from the trunk and will not be in
the next major release. The following is a list of the applications that are
being removed in this commit:
Curl, Cut, Sort, DBPut, DBGet, ENUMLookup, Eval
GetGroupCount, SetGroup, CheckGroup, GetGroupMatchCount
MD5, MD5Check, Math, SetCIDName, SetCIDNum, SetRDNIS, SetCallerID
TXTCIDName, AbsoluteTimeout, DigitTimeout, ResponseTimeout, SetAccount
SetLanguage, SetVar (renamed to Set)
These changes also include moving the "group show channels" cli command from
app_groupcount.c to cli.c.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@7379 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2005-12-07 15:36:55 +00:00
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
if (a->argc == 4) {
|
|
|
|
if (regcomp(®exbuf, a->argv[3], REG_EXTENDED | REG_NOSUB))
|
|
|
|
return CLI_SHOWUSAGE;
|
This is the first round of removing applications that were marked as deprecated
in the 1.2 release. They are being removed from the trunk and will not be in
the next major release. The following is a list of the applications that are
being removed in this commit:
Curl, Cut, Sort, DBPut, DBGet, ENUMLookup, Eval
GetGroupCount, SetGroup, CheckGroup, GetGroupMatchCount
MD5, MD5Check, Math, SetCIDName, SetCIDNum, SetRDNIS, SetCallerID
TXTCIDName, AbsoluteTimeout, DigitTimeout, ResponseTimeout, SetAccount
SetLanguage, SetVar (renamed to Set)
These changes also include moving the "group show channels" cli command from
app_groupcount.c to cli.c.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@7379 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2005-12-07 15:36:55 +00:00
|
|
|
havepattern = 1;
|
|
|
|
}
|
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
ast_cli(a->fd, FORMAT_STRING, "Channel", "Group", "Category");
|
2007-04-25 19:27:42 +00:00
|
|
|
|
2007-06-13 18:23:12 +00:00
|
|
|
ast_app_group_list_rdlock();
|
2007-04-25 19:27:42 +00:00
|
|
|
|
|
|
|
gi = ast_app_group_list_head();
|
|
|
|
while (gi) {
|
|
|
|
if (!havepattern || !regexec(®exbuf, gi->group, 0, NULL, 0)) {
|
2012-01-09 22:15:50 +00:00
|
|
|
ast_cli(a->fd, FORMAT_STRING, ast_channel_name(gi->chan), gi->group, (ast_strlen_zero(gi->category) ? "(default)" : gi->category));
|
2007-04-25 19:27:42 +00:00
|
|
|
numchans++;
|
This is the first round of removing applications that were marked as deprecated
in the 1.2 release. They are being removed from the trunk and will not be in
the next major release. The following is a list of the applications that are
being removed in this commit:
Curl, Cut, Sort, DBPut, DBGet, ENUMLookup, Eval
GetGroupCount, SetGroup, CheckGroup, GetGroupMatchCount
MD5, MD5Check, Math, SetCIDName, SetCIDNum, SetRDNIS, SetCallerID
TXTCIDName, AbsoluteTimeout, DigitTimeout, ResponseTimeout, SetAccount
SetLanguage, SetVar (renamed to Set)
These changes also include moving the "group show channels" cli command from
app_groupcount.c to cli.c.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@7379 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2005-12-07 15:36:55 +00:00
|
|
|
}
|
2009-04-22 21:15:55 +00:00
|
|
|
gi = AST_LIST_NEXT(gi, group_list);
|
This is the first round of removing applications that were marked as deprecated
in the 1.2 release. They are being removed from the trunk and will not be in
the next major release. The following is a list of the applications that are
being removed in this commit:
Curl, Cut, Sort, DBPut, DBGet, ENUMLookup, Eval
GetGroupCount, SetGroup, CheckGroup, GetGroupMatchCount
MD5, MD5Check, Math, SetCIDName, SetCIDNum, SetRDNIS, SetCallerID
TXTCIDName, AbsoluteTimeout, DigitTimeout, ResponseTimeout, SetAccount
SetLanguage, SetVar (renamed to Set)
These changes also include moving the "group show channels" cli command from
app_groupcount.c to cli.c.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@7379 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2005-12-07 15:36:55 +00:00
|
|
|
}
|
2007-04-25 19:27:42 +00:00
|
|
|
|
|
|
|
ast_app_group_list_unlock();
|
|
|
|
|
This is the first round of removing applications that were marked as deprecated
in the 1.2 release. They are being removed from the trunk and will not be in
the next major release. The following is a list of the applications that are
being removed in this commit:
Curl, Cut, Sort, DBPut, DBGet, ENUMLookup, Eval
GetGroupCount, SetGroup, CheckGroup, GetGroupMatchCount
MD5, MD5Check, Math, SetCIDName, SetCIDNum, SetRDNIS, SetCallerID
TXTCIDName, AbsoluteTimeout, DigitTimeout, ResponseTimeout, SetAccount
SetLanguage, SetVar (renamed to Set)
These changes also include moving the "group show channels" cli command from
app_groupcount.c to cli.c.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@7379 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2005-12-07 15:36:55 +00:00
|
|
|
if (havepattern)
|
|
|
|
regfree(®exbuf);
|
|
|
|
|
2007-10-11 19:03:06 +00:00
|
|
|
ast_cli(a->fd, "%d active channel%s\n", numchans, ESS(numchans));
|
|
|
|
return CLI_SUCCESS;
|
This is the first round of removing applications that were marked as deprecated
in the 1.2 release. They are being removed from the trunk and will not be in
the next major release. The following is a list of the applications that are
being removed in this commit:
Curl, Cut, Sort, DBPut, DBGet, ENUMLookup, Eval
GetGroupCount, SetGroup, CheckGroup, GetGroupMatchCount
MD5, MD5Check, Math, SetCIDName, SetCIDNum, SetRDNIS, SetCallerID
TXTCIDName, AbsoluteTimeout, DigitTimeout, ResponseTimeout, SetAccount
SetLanguage, SetVar (renamed to Set)
These changes also include moving the "group show channels" cli command from
app_groupcount.c to cli.c.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@7379 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2005-12-07 15:36:55 +00:00
|
|
|
#undef FORMAT_STRING
|
|
|
|
}
|
|
|
|
|
2010-06-02 18:53:38 +00:00
|
|
|
static char *handle_cli_wait_fullybooted(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2006-11-17 22:53:57 +00:00
|
|
|
static char *handle_help(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
|
|
|
|
|
2006-09-18 19:54:18 +00:00
|
|
|
static struct ast_cli_entry cli_cli[] = {
|
2006-11-10 17:01:06 +00:00
|
|
|
/* Deprecated, but preferred command is now consolidated (and already has a deprecated command for it). */
|
2007-10-22 20:05:18 +00:00
|
|
|
AST_CLI_DEFINE(handle_commandcomplete, "Command complete"),
|
|
|
|
AST_CLI_DEFINE(handle_commandnummatches, "Returns number of command matches"),
|
|
|
|
AST_CLI_DEFINE(handle_commandmatchesarray, "Returns command matches array"),
|
2007-10-15 13:44:53 +00:00
|
|
|
|
2007-10-22 20:05:18 +00:00
|
|
|
AST_CLI_DEFINE(handle_nodebugchan_deprecated, "Disable debugging on channel(s)"),
|
2006-11-10 17:01:06 +00:00
|
|
|
|
2007-10-22 20:05:18 +00:00
|
|
|
AST_CLI_DEFINE(handle_chanlist, "Display information on channels"),
|
2006-09-18 19:54:18 +00:00
|
|
|
|
2007-12-07 16:11:05 +00:00
|
|
|
AST_CLI_DEFINE(handle_showcalls, "Display information on calls"),
|
|
|
|
|
2007-10-22 20:05:18 +00:00
|
|
|
AST_CLI_DEFINE(handle_showchan, "Display information on a specific channel"),
|
2006-09-18 19:54:18 +00:00
|
|
|
|
2008-11-12 06:46:04 +00:00
|
|
|
AST_CLI_DEFINE(handle_core_set_debug_channel, "Enable/disable debugging on a channel"),
|
2006-09-18 19:54:18 +00:00
|
|
|
|
2007-10-22 20:05:18 +00:00
|
|
|
AST_CLI_DEFINE(handle_verbose, "Set level of debug/verbose chattiness"),
|
2006-09-18 19:54:18 +00:00
|
|
|
|
2007-10-22 20:05:18 +00:00
|
|
|
AST_CLI_DEFINE(group_show_channels, "Display active channels with group(s)"),
|
2006-09-18 19:54:18 +00:00
|
|
|
|
2007-10-22 20:05:18 +00:00
|
|
|
AST_CLI_DEFINE(handle_help, "Display help list, or specific help on a command"),
|
2006-09-18 19:54:18 +00:00
|
|
|
|
2007-10-22 20:05:18 +00:00
|
|
|
AST_CLI_DEFINE(handle_logger_mute, "Toggle logging output to a console"),
|
2006-09-18 19:54:18 +00:00
|
|
|
|
2007-10-22 20:05:18 +00:00
|
|
|
AST_CLI_DEFINE(handle_modlist, "List modules and info"),
|
2006-09-18 19:54:18 +00:00
|
|
|
|
2008-11-12 06:46:04 +00:00
|
|
|
AST_CLI_DEFINE(handle_load, "Load a module by name"),
|
2006-09-18 19:54:18 +00:00
|
|
|
|
2010-08-12 20:44:39 +00:00
|
|
|
AST_CLI_DEFINE(handle_reload, "Reload configuration for a module"),
|
|
|
|
|
|
|
|
AST_CLI_DEFINE(handle_core_reload, "Global reload"),
|
2006-09-18 19:54:18 +00:00
|
|
|
|
2008-11-12 06:46:04 +00:00
|
|
|
AST_CLI_DEFINE(handle_unload, "Unload a module by name"),
|
2006-09-18 19:54:18 +00:00
|
|
|
|
2007-10-22 20:05:18 +00:00
|
|
|
AST_CLI_DEFINE(handle_showuptime, "Show uptime information"),
|
2006-09-18 19:54:18 +00:00
|
|
|
|
2007-10-22 20:05:18 +00:00
|
|
|
AST_CLI_DEFINE(handle_softhangup, "Request a hangup on a given channel"),
|
2008-12-01 18:52:14 +00:00
|
|
|
|
|
|
|
AST_CLI_DEFINE(handle_cli_reload_permissions, "Reload CLI permissions config"),
|
|
|
|
|
|
|
|
AST_CLI_DEFINE(handle_cli_show_permissions, "Show CLI permissions"),
|
|
|
|
|
|
|
|
AST_CLI_DEFINE(handle_cli_check_permissions, "Try a permissions config for a user"),
|
2010-06-02 18:53:38 +00:00
|
|
|
|
|
|
|
AST_CLI_DEFINE(handle_cli_wait_fullybooted, "Wait for Asterisk to be fully booted"),
|
2006-09-18 19:54:18 +00:00
|
|
|
};
|
|
|
|
|
2006-11-17 11:12:13 +00:00
|
|
|
/*!
|
|
|
|
* Some regexp characters in cli arguments are reserved and used as separators.
|
|
|
|
*/
|
2006-11-17 21:50:55 +00:00
|
|
|
static const char cli_rsvd[] = "[]{}|*%";
|
2006-11-17 11:12:13 +00:00
|
|
|
|
|
|
|
/*!
|
|
|
|
* initialize the _full_cmd string and related parameters,
|
|
|
|
* return 0 on success, -1 on error.
|
|
|
|
*/
|
|
|
|
static int set_full_cmd(struct ast_cli_entry *e)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
char buf[80];
|
|
|
|
|
|
|
|
ast_join(buf, sizeof(buf), e->cmda);
|
2007-06-14 23:01:01 +00:00
|
|
|
e->_full_cmd = ast_strdup(buf);
|
2006-11-17 11:12:13 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-12-01 18:52:14 +00:00
|
|
|
/*! \brief cleanup (free) cli_perms linkedlist. */
|
2008-12-04 19:31:48 +00:00
|
|
|
static void destroy_user_perms(void)
|
1999-12-19 22:38:55 +00:00
|
|
|
{
|
2008-12-01 18:52:14 +00:00
|
|
|
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);
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
|
|
|
|
2008-12-04 19:31:48 +00:00
|
|
|
int ast_cli_perms_init(int reload)
|
|
|
|
{
|
2008-12-01 18:52:14 +00:00
|
|
|
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;
|
2008-10-03 22:10:18 +00:00
|
|
|
}
|
2008-12-01 18:52:14 +00:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief initialize the _full_cmd string in * each of the builtins. */
|
|
|
|
void ast_builtins_init(void)
|
|
|
|
{
|
2008-12-05 10:31:25 +00:00
|
|
|
ast_cli_register_multiple(cli_cli, ARRAY_LEN(cli_cli));
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
|
|
|
|
2006-11-17 11:12:13 +00:00
|
|
|
/*!
|
|
|
|
* 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.
|
2006-11-17 21:50:55 +00:00
|
|
|
*
|
|
|
|
* The pattern can be
|
2009-01-29 23:15:20 +00:00
|
|
|
* any_word match for equal
|
|
|
|
* [foo|bar|baz] optionally, one of these words
|
|
|
|
* {foo|bar|baz} exactly, one of these words
|
|
|
|
* % any word
|
2006-11-17 11:12:13 +00:00
|
|
|
*/
|
|
|
|
static int word_match(const char *cmd, const char *cli_word)
|
|
|
|
{
|
|
|
|
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);
|
2006-11-17 21:50:55 +00:00
|
|
|
/* wildcard match - will extend in the future */
|
|
|
|
if (l > 0 && cli_word[0] == '%') {
|
|
|
|
return 1; /* wildcard */
|
|
|
|
}
|
2011-04-15 15:20:46 +00:00
|
|
|
|
|
|
|
/* Start a search for the command entered against the cli word in question */
|
2006-11-17 11:12:13 +00:00
|
|
|
pos = strcasestr(cli_word, cmd);
|
2011-04-15 15:20:46 +00:00
|
|
|
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;
|
2006-11-17 11:12:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*! \brief 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.
|
|
|
|
*/
|
|
|
|
static char *is_prefix(const char *word, const char *token,
|
|
|
|
int pos, int *actual)
|
|
|
|
{
|
|
|
|
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;
|
2007-06-14 23:01:01 +00:00
|
|
|
return (pos != 0) ? NULL : ast_strdup(token);
|
2006-11-17 11:12:13 +00:00
|
|
|
}
|
|
|
|
/* now handle regexp match */
|
2006-11-17 21:50:55 +00:00
|
|
|
|
|
|
|
/* Wildcard always matches, so we never do is_prefix on them */
|
|
|
|
|
2006-11-17 11:12:13 +00:00
|
|
|
t1 = ast_strdupa(token + 1); /* copy, skipping first char */
|
|
|
|
while (pos >= 0 && (s = strsep(&t1, cli_rsvd)) && *s) {
|
2006-11-17 21:50:55 +00:00
|
|
|
if (*s == '%') /* wildcard */
|
|
|
|
continue;
|
2006-11-17 11:12:13 +00:00
|
|
|
if (strncasecmp(s, word, lw)) /* no match */
|
|
|
|
continue;
|
|
|
|
(*actual)++;
|
|
|
|
if (pos-- == 0)
|
2007-06-14 23:01:01 +00:00
|
|
|
return ast_strdup(s);
|
2006-11-17 11:12:13 +00:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-03-28 22:25:08 +00:00
|
|
|
/*!
|
2008-11-12 06:46:04 +00:00
|
|
|
* \internal
|
2006-03-28 22:25:08 +00:00
|
|
|
* \brief locate a cli command in the 'helpers' list (which must be locked).
|
2008-11-12 06:46:04 +00:00
|
|
|
* The search compares word by word taking care of regexps in e->cmda
|
|
|
|
* This function will return NULL when nothing is matched, or the ast_cli_entry that matched.
|
|
|
|
* \param cmds
|
|
|
|
* \param match_type has 3 possible values:
|
2006-03-28 22:25:08 +00:00
|
|
|
* 0 returns if the search key is equal or longer than the entry.
|
2008-11-12 06:46:04 +00:00
|
|
|
* note that trailing optional arguments are skipped.
|
2006-03-28 22:25:08 +00:00
|
|
|
* -1 true if the mismatch is on the last word XXX not true!
|
|
|
|
* 1 true only on complete, exact match.
|
2006-11-17 11:12:13 +00:00
|
|
|
*
|
2006-03-28 22:25:08 +00:00
|
|
|
*/
|
2009-05-21 21:13:09 +00:00
|
|
|
static struct ast_cli_entry *find_cli(const char * const cmds[], int match_type)
|
1999-12-27 19:20:20 +00:00
|
|
|
{
|
2006-03-28 22:25:08 +00:00
|
|
|
int matchlen = -1; /* length of longest match so far */
|
|
|
|
struct ast_cli_entry *cand = NULL, *e=NULL;
|
|
|
|
|
2007-10-15 13:44:53 +00:00
|
|
|
while ( (e = cli_next(e)) ) {
|
2006-11-17 11:12:13 +00:00
|
|
|
/* word-by word regexp comparison */
|
2009-05-21 21:13:09 +00:00
|
|
|
const char * const *src = cmds;
|
|
|
|
const char * const *dst = e->cmda;
|
2006-11-17 11:12:13 +00:00
|
|
|
int n = 0;
|
|
|
|
for (;; dst++, src += n) {
|
|
|
|
n = word_match(*src, *dst);
|
|
|
|
if (n < 0)
|
2006-03-28 22:25:08 +00:00
|
|
|
break;
|
|
|
|
}
|
2006-11-17 11:12:13 +00:00
|
|
|
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 */
|
2006-03-28 22:25:08 +00:00
|
|
|
break;
|
2006-11-17 11:12:13 +00:00
|
|
|
/* Here, cmds has more words than the entry 'e' */
|
2006-03-28 22:25:08 +00:00
|
|
|
if (match_type != 0) /* but we look for almost exact match... */
|
|
|
|
continue; /* so we skip this one. */
|
|
|
|
/* otherwise we like it (case 0) */
|
2006-11-17 11:12:13 +00:00
|
|
|
} 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 */
|
2006-03-28 22:25:08 +00:00
|
|
|
continue;
|
2006-11-17 11:12:13 +00:00
|
|
|
/* good, we are in case match_type == -1 and mismatch on last word */
|
2006-03-28 22:25:08 +00:00
|
|
|
}
|
2006-11-17 11:12:13 +00:00
|
|
|
if (src - cmds > matchlen) { /* remember the candidate */
|
|
|
|
matchlen = src - cmds;
|
2006-03-28 22:25:08 +00:00
|
|
|
cand = e;
|
2006-11-15 16:13:30 +00:00
|
|
|
}
|
1999-12-27 19:20:20 +00:00
|
|
|
}
|
2008-11-12 06:46:04 +00:00
|
|
|
|
2006-03-28 22:25:08 +00:00
|
|
|
return e ? e : cand;
|
1999-12-27 19:20:20 +00:00
|
|
|
}
|
|
|
|
|
2009-05-21 21:13:09 +00:00
|
|
|
static char *find_best(const char *argv[])
|
1999-12-19 22:38:55 +00:00
|
|
|
{
|
|
|
|
static char cmdline[80];
|
|
|
|
int x;
|
2006-03-28 22:25:08 +00:00
|
|
|
/* See how close we get, then print the candidate */
|
2009-05-21 21:13:09 +00:00
|
|
|
const char *myargv[AST_MAX_CMD_LEN] = { NULL, };
|
|
|
|
|
2007-08-01 15:28:02 +00:00
|
|
|
AST_RWLIST_RDLOCK(&helpers);
|
2009-05-21 21:13:09 +00:00
|
|
|
for (x = 0; argv[x]; x++) {
|
1999-12-19 22:38:55 +00:00
|
|
|
myargv[x] = argv[x];
|
|
|
|
if (!find_cli(myargv, -1))
|
|
|
|
break;
|
|
|
|
}
|
2007-08-01 15:28:02 +00:00
|
|
|
AST_RWLIST_UNLOCK(&helpers);
|
2006-03-28 22:25:08 +00:00
|
|
|
ast_join(cmdline, sizeof(cmdline), myargv);
|
1999-12-19 22:38:55 +00:00
|
|
|
return cmdline;
|
|
|
|
}
|
|
|
|
|
2006-09-18 19:54:18 +00:00
|
|
|
static int __ast_cli_unregister(struct ast_cli_entry *e, struct ast_cli_entry *ed)
|
1999-12-27 19:20:20 +00:00
|
|
|
{
|
2006-02-14 22:44:20 +00:00
|
|
|
if (e->inuse) {
|
|
|
|
ast_log(LOG_WARNING, "Can't remove command that is in use\n");
|
|
|
|
} else {
|
2007-08-01 15:28:02 +00:00
|
|
|
AST_RWLIST_WRLOCK(&helpers);
|
|
|
|
AST_RWLIST_REMOVE(&helpers, e, list);
|
|
|
|
AST_RWLIST_UNLOCK(&helpers);
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(e->_full_cmd);
|
Bring in the improved internal API for the CLI.
WATCH OUT: this changes the binary interface (ABI) for modules,
so e.g. users of g729 codecs need a rebuilt module (but read below).
The new way to write CLI handlers is described in detail in cli.h,
and there are a few converted handlers in cli.c, look for NEW_CLI.
After converting a couple of commands i am convinced that
it is reasonably convenient to use, and it makes it easier to fix the
pending CLI issues.
On passing, note a bug with the current 'complete' architecture:
if a command is a prefix of multiple CLI entries, we miss some
of the possible options. As an example, "core set debug" can
continue with "channel" from one CLI entry, and "off" or "atleast"
from another one.
We address this problem in a separate commit
(when i have figured out a fix, that is).
ABI issues:
I asked Kevin if it was ok to make this change and he said yes.
While it would have been possible to make the change without breaking
the module ABI, the code would have been more convoluted.
I am happy to restore the old ABI (while still being able
to use the "new style" handlers) if there is demand.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@47606 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-11-14 15:23:35 +00:00
|
|
|
e->_full_cmd = NULL;
|
2007-11-28 20:27:40 +00:00
|
|
|
if (e->handler) {
|
Bring in the improved internal API for the CLI.
WATCH OUT: this changes the binary interface (ABI) for modules,
so e.g. users of g729 codecs need a rebuilt module (but read below).
The new way to write CLI handlers is described in detail in cli.h,
and there are a few converted handlers in cli.c, look for NEW_CLI.
After converting a couple of commands i am convinced that
it is reasonably convenient to use, and it makes it easier to fix the
pending CLI issues.
On passing, note a bug with the current 'complete' architecture:
if a command is a prefix of multiple CLI entries, we miss some
of the possible options. As an example, "core set debug" can
continue with "channel" from one CLI entry, and "off" or "atleast"
from another one.
We address this problem in a separate commit
(when i have figured out a fix, that is).
ABI issues:
I asked Kevin if it was ok to make this change and he said yes.
While it would have been possible to make the change without breaking
the module ABI, the code would have been more convoluted.
I am happy to restore the old ABI (while still being able
to use the "new style" handlers) if there is demand.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@47606 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-11-14 15:23:35 +00:00
|
|
|
/* this is a new-style entry. Reset fields and free memory. */
|
2008-12-02 00:37:21 +00:00
|
|
|
char *cmda = (char *) e->cmda;
|
|
|
|
memset(cmda, '\0', sizeof(e->cmda));
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(e->command);
|
Bring in the improved internal API for the CLI.
WATCH OUT: this changes the binary interface (ABI) for modules,
so e.g. users of g729 codecs need a rebuilt module (but read below).
The new way to write CLI handlers is described in detail in cli.h,
and there are a few converted handlers in cli.c, look for NEW_CLI.
After converting a couple of commands i am convinced that
it is reasonably convenient to use, and it makes it easier to fix the
pending CLI issues.
On passing, note a bug with the current 'complete' architecture:
if a command is a prefix of multiple CLI entries, we miss some
of the possible options. As an example, "core set debug" can
continue with "channel" from one CLI entry, and "off" or "atleast"
from another one.
We address this problem in a separate commit
(when i have figured out a fix, that is).
ABI issues:
I asked Kevin if it was ok to make this change and he said yes.
While it would have been possible to make the change without breaking
the module ABI, the code would have been more convoluted.
I am happy to restore the old ABI (while still being able
to use the "new style" handlers) if there is demand.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@47606 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-11-14 15:23:35 +00:00
|
|
|
e->command = NULL;
|
|
|
|
e->usage = NULL;
|
|
|
|
}
|
1999-12-27 19:20:20 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-09-18 19:54:18 +00:00
|
|
|
static int __ast_cli_register(struct ast_cli_entry *e, struct ast_cli_entry *ed)
|
1999-12-19 22:38:55 +00:00
|
|
|
{
|
2006-02-14 22:44:20 +00:00
|
|
|
struct ast_cli_entry *cur;
|
Bring in the improved internal API for the CLI.
WATCH OUT: this changes the binary interface (ABI) for modules,
so e.g. users of g729 codecs need a rebuilt module (but read below).
The new way to write CLI handlers is described in detail in cli.h,
and there are a few converted handlers in cli.c, look for NEW_CLI.
After converting a couple of commands i am convinced that
it is reasonably convenient to use, and it makes it easier to fix the
pending CLI issues.
On passing, note a bug with the current 'complete' architecture:
if a command is a prefix of multiple CLI entries, we miss some
of the possible options. As an example, "core set debug" can
continue with "channel" from one CLI entry, and "off" or "atleast"
from another one.
We address this problem in a separate commit
(when i have figured out a fix, that is).
ABI issues:
I asked Kevin if it was ok to make this change and he said yes.
While it would have been possible to make the change without breaking
the module ABI, the code would have been more convoluted.
I am happy to restore the old ABI (while still being able
to use the "new style" handlers) if there is demand.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@47606 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-11-14 15:23:35 +00:00
|
|
|
int i, lf, ret = -1;
|
|
|
|
|
2007-11-28 20:27:40 +00:00
|
|
|
struct ast_cli_args a; /* fake argument */
|
|
|
|
char **dst = (char **)e->cmda; /* need to cast as the entry is readonly */
|
|
|
|
char *s;
|
|
|
|
|
2008-10-09 14:17:33 +00:00
|
|
|
memset(&a, '\0', sizeof(a));
|
2007-11-28 20:27:40 +00:00
|
|
|
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);
|
Bring in the improved internal API for the CLI.
WATCH OUT: this changes the binary interface (ABI) for modules,
so e.g. users of g729 codecs need a rebuilt module (but read below).
The new way to write CLI handlers is described in detail in cli.h,
and there are a few converted handlers in cli.c, look for NEW_CLI.
After converting a couple of commands i am convinced that
it is reasonably convenient to use, and it makes it easier to fix the
pending CLI issues.
On passing, note a bug with the current 'complete' architecture:
if a command is a prefix of multiple CLI entries, we miss some
of the possible options. As an example, "core set debug" can
continue with "channel" from one CLI entry, and "off" or "atleast"
from another one.
We address this problem in a separate commit
(when i have figured out a fix, that is).
ABI issues:
I asked Kevin if it was ok to make this change and he said yes.
While it would have been possible to make the change without breaking
the module ABI, the code would have been more convoluted.
I am happy to restore the old ABI (while still being able
to use the "new style" handlers) if there is demand.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@47606 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-11-14 15:23:35 +00:00
|
|
|
}
|
2007-11-28 20:27:40 +00:00
|
|
|
*dst++ = NULL;
|
|
|
|
|
2007-08-01 15:28:02 +00:00
|
|
|
AST_RWLIST_WRLOCK(&helpers);
|
2005-11-29 04:25:28 +00:00
|
|
|
|
2006-03-28 22:25:08 +00:00
|
|
|
if (find_cli(e->cmda, 1)) {
|
2008-11-12 06:46:04 +00:00
|
|
|
ast_log(LOG_WARNING, "Command '%s' already registered (or something close enough)\n", S_OR(e->_full_cmd, e->command));
|
2006-03-28 22:25:08 +00:00
|
|
|
goto done;
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
2007-10-01 14:55:10 +00:00
|
|
|
if (set_full_cmd(e))
|
|
|
|
goto done;
|
2006-09-18 19:54:18 +00:00
|
|
|
|
2006-11-17 11:12:13 +00:00
|
|
|
lf = e->cmdlen;
|
2007-08-01 15:28:02 +00:00
|
|
|
AST_RWLIST_TRAVERSE_SAFE_BEGIN(&helpers, cur, list) {
|
2006-11-17 11:12:13 +00:00
|
|
|
int len = cur->cmdlen;
|
2006-03-28 22:25:08 +00:00
|
|
|
if (lf < len)
|
|
|
|
len = lf;
|
2006-11-17 11:12:13 +00:00
|
|
|
if (strncasecmp(e->_full_cmd, cur->_full_cmd, len) < 0) {
|
2007-11-08 05:28:47 +00:00
|
|
|
AST_RWLIST_INSERT_BEFORE_CURRENT(e, list);
|
1999-12-19 22:38:55 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2007-08-01 15:28:02 +00:00
|
|
|
AST_RWLIST_TRAVERSE_SAFE_END;
|
2005-11-29 04:25:28 +00:00
|
|
|
|
2006-02-14 22:44:20 +00:00
|
|
|
if (!cur)
|
2007-08-01 15:28:02 +00:00
|
|
|
AST_RWLIST_INSERT_TAIL(&helpers, e, list);
|
2006-03-28 22:25:08 +00:00
|
|
|
ret = 0; /* success */
|
2005-11-29 04:25:28 +00:00
|
|
|
|
2006-03-28 22:25:08 +00:00
|
|
|
done:
|
2007-08-01 15:28:02 +00:00
|
|
|
AST_RWLIST_UNLOCK(&helpers);
|
2006-09-18 19:54:18 +00:00
|
|
|
|
2006-03-28 22:25:08 +00:00
|
|
|
return ret;
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
|
|
|
|
2006-09-18 19:54:18 +00:00
|
|
|
/* wrapper function, so we can unregister deprecated commands recursively */
|
|
|
|
int ast_cli_unregister(struct ast_cli_entry *e)
|
|
|
|
{
|
|
|
|
return __ast_cli_unregister(e, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* wrapper function, so we can register deprecated commands recursively */
|
|
|
|
int ast_cli_register(struct ast_cli_entry *e)
|
|
|
|
{
|
|
|
|
return __ast_cli_register(e, NULL);
|
|
|
|
}
|
|
|
|
|
2005-05-15 03:03:48 +00:00
|
|
|
/*
|
|
|
|
* register/unregister an array of entries.
|
|
|
|
*/
|
2007-02-13 22:02:20 +00:00
|
|
|
int ast_cli_register_multiple(struct ast_cli_entry *e, int len)
|
2005-05-15 03:03:48 +00:00
|
|
|
{
|
2007-02-13 22:02:20 +00:00
|
|
|
int i, res = 0;
|
2005-05-15 03:03:48 +00:00
|
|
|
|
2005-11-29 04:25:28 +00:00
|
|
|
for (i = 0; i < len; i++)
|
2007-02-13 22:02:20 +00:00
|
|
|
res |= ast_cli_register(e + i);
|
|
|
|
|
|
|
|
return res;
|
2005-05-15 03:03:48 +00:00
|
|
|
}
|
|
|
|
|
2007-02-13 22:02:20 +00:00
|
|
|
int ast_cli_unregister_multiple(struct ast_cli_entry *e, int len)
|
2005-05-15 03:03:48 +00:00
|
|
|
{
|
2007-02-13 22:02:20 +00:00
|
|
|
int i, res = 0;
|
2005-05-15 03:03:48 +00:00
|
|
|
|
2005-11-29 04:25:28 +00:00
|
|
|
for (i = 0; i < len; i++)
|
2007-02-13 22:02:20 +00:00
|
|
|
res |= ast_cli_unregister(e + i);
|
|
|
|
|
|
|
|
return res;
|
2005-05-15 03:03:48 +00:00
|
|
|
}
|
|
|
|
|
2006-03-28 22:25:08 +00:00
|
|
|
|
2008-01-09 20:30:54 +00:00
|
|
|
/*! \brief helper for final part of handle_help
|
|
|
|
* if locked = 1, assume the list is already locked
|
2006-03-28 22:25:08 +00:00
|
|
|
*/
|
2009-05-21 21:13:09 +00:00
|
|
|
static char *help1(int fd, const char * const match[], int locked)
|
1999-12-19 22:38:55 +00:00
|
|
|
{
|
2006-03-28 22:25:08 +00:00
|
|
|
char matchstr[80] = "";
|
2007-10-15 13:44:53 +00:00
|
|
|
struct ast_cli_entry *e = NULL;
|
2006-03-28 22:25:08 +00:00
|
|
|
int len = 0;
|
|
|
|
int found = 0;
|
|
|
|
|
|
|
|
if (match) {
|
|
|
|
ast_join(matchstr, sizeof(matchstr), match);
|
|
|
|
len = strlen(matchstr);
|
|
|
|
}
|
|
|
|
if (!locked)
|
2007-08-01 15:28:02 +00:00
|
|
|
AST_RWLIST_RDLOCK(&helpers);
|
2007-10-15 13:44:53 +00:00
|
|
|
while ( (e = cli_next(e)) ) {
|
2001-05-09 03:11:22 +00:00
|
|
|
/* Hide commands that start with '_' */
|
2006-03-28 22:25:08 +00:00
|
|
|
if (e->_full_cmd[0] == '_')
|
2001-05-09 03:11:22 +00:00
|
|
|
continue;
|
2006-03-28 22:25:08 +00:00
|
|
|
if (match && strncasecmp(matchstr, e->_full_cmd, len))
|
|
|
|
continue;
|
2006-11-17 11:12:13 +00:00
|
|
|
ast_cli(fd, "%30.30s %s\n", e->_full_cmd, S_OR(e->summary, "<no description available>"));
|
2006-03-28 22:25:08 +00:00
|
|
|
found++;
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
2006-11-17 22:53:57 +00:00
|
|
|
if (!locked)
|
2007-08-01 15:28:02 +00:00
|
|
|
AST_RWLIST_UNLOCK(&helpers);
|
2008-01-09 20:30:54 +00:00
|
|
|
if (!found && matchstr[0])
|
2006-03-28 22:25:08 +00:00
|
|
|
ast_cli(fd, "No such command '%s'.\n", matchstr);
|
2006-11-17 22:53:57 +00:00
|
|
|
return CLI_SUCCESS;
|
2006-03-28 22:25:08 +00:00
|
|
|
}
|
|
|
|
|
2006-11-17 22:53:57 +00:00
|
|
|
static char *handle_help(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
2006-03-28 22:25:08 +00:00
|
|
|
{
|
1999-12-19 22:38:55 +00:00
|
|
|
char fullcmd[80];
|
2006-11-17 22:53:57 +00:00
|
|
|
struct ast_cli_entry *my_e;
|
2008-01-09 20:13:14 +00:00
|
|
|
char *res = CLI_SUCCESS;
|
2006-03-28 22:25:08 +00:00
|
|
|
|
2006-11-17 22:53:57 +00:00
|
|
|
if (cmd == CLI_INIT) {
|
2008-11-12 06:46:04 +00:00
|
|
|
e->command = "core show help";
|
2006-11-17 22:53:57 +00:00
|
|
|
e->usage =
|
2008-11-12 06:46:04 +00:00
|
|
|
"Usage: core show help [topic]\n"
|
2006-11-17 22:53:57 +00:00
|
|
|
" 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) {
|
2008-11-12 06:46:04 +00:00
|
|
|
/* skip first 14 or 15 chars, "core show help " */
|
2006-11-17 22:53:57 +00:00
|
|
|
int l = strlen(a->line);
|
|
|
|
|
2008-11-12 06:46:04 +00:00
|
|
|
if (l > 15) {
|
|
|
|
l = 15;
|
|
|
|
}
|
2006-11-17 22:53:57 +00:00
|
|
|
/* XXX watch out, should stop to the non-generator parts */
|
|
|
|
return __ast_cli_generator(a->line + l, a->word, a->n, 0);
|
|
|
|
}
|
2008-11-12 06:46:04 +00:00
|
|
|
if (a->argc == e->args) {
|
2006-11-17 22:53:57 +00:00
|
|
|
return help1(a->fd, NULL, 0);
|
2008-11-12 06:46:04 +00:00
|
|
|
}
|
2006-03-28 22:25:08 +00:00
|
|
|
|
2007-08-01 15:28:02 +00:00
|
|
|
AST_RWLIST_RDLOCK(&helpers);
|
2008-11-12 06:46:04 +00:00
|
|
|
my_e = find_cli(a->argv + 3, 1); /* try exact match first */
|
2008-01-09 20:13:14 +00:00
|
|
|
if (!my_e) {
|
2008-11-12 06:46:04 +00:00
|
|
|
res = help1(a->fd, a->argv + 3, 1 /* locked */);
|
2008-01-09 20:13:14 +00:00
|
|
|
AST_RWLIST_UNLOCK(&helpers);
|
|
|
|
return res;
|
|
|
|
}
|
2006-11-17 22:53:57 +00:00
|
|
|
if (my_e->usage)
|
|
|
|
ast_cli(a->fd, "%s", my_e->usage);
|
2006-03-28 22:25:08 +00:00
|
|
|
else {
|
2008-11-12 06:46:04 +00:00
|
|
|
ast_join(fullcmd, sizeof(fullcmd), a->argv + 3);
|
2006-11-17 22:53:57 +00:00
|
|
|
ast_cli(a->fd, "No help text available for '%s'.\n", fullcmd);
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
2007-08-01 15:28:02 +00:00
|
|
|
AST_RWLIST_UNLOCK(&helpers);
|
2008-01-09 20:13:14 +00:00
|
|
|
return res;
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
|
|
|
|
2009-05-21 21:13:09 +00:00
|
|
|
static char *parse_args(const char *s, int *argc, const char *argv[], int max, int *trailingwhitespace)
|
1999-12-19 22:38:55 +00:00
|
|
|
{
|
2008-08-10 20:23:50 +00:00
|
|
|
char *duplicate, *cur;
|
2005-06-10 20:25:23 +00:00
|
|
|
int x = 0;
|
|
|
|
int quoted = 0;
|
|
|
|
int escaped = 0;
|
|
|
|
int whitespace = 1;
|
2006-11-16 14:58:24 +00:00
|
|
|
int dummy = 0;
|
2005-06-10 20:25:23 +00:00
|
|
|
|
2006-11-16 14:58:24 +00:00
|
|
|
if (trailingwhitespace == NULL)
|
|
|
|
trailingwhitespace = &dummy;
|
2005-09-25 03:13:00 +00:00
|
|
|
*trailingwhitespace = 0;
|
2006-03-28 22:25:08 +00:00
|
|
|
if (s == NULL) /* invalid, though! */
|
|
|
|
return NULL;
|
|
|
|
/* make a copy to store the parsed string */
|
2008-08-10 20:23:50 +00:00
|
|
|
if (!(duplicate = ast_strdup(s)))
|
2005-06-10 20:25:23 +00:00
|
|
|
return NULL;
|
|
|
|
|
2008-08-10 20:23:50 +00:00
|
|
|
cur = duplicate;
|
2006-03-28 22:25:08 +00:00
|
|
|
/* 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) {
|
2005-06-10 20:25:23 +00:00
|
|
|
quoted = !quoted;
|
2006-03-28 22:25:08 +00:00
|
|
|
if (quoted && whitespace) {
|
|
|
|
/* start a quoted string from previous whitespace: new argument */
|
2005-06-10 20:25:23 +00:00
|
|
|
argv[x++] = cur;
|
|
|
|
whitespace = 0;
|
|
|
|
}
|
2006-03-28 22:25:08 +00:00
|
|
|
} else if ((*s == ' ' || *s == '\t') && !(quoted || escaped)) {
|
2005-06-10 20:25:23 +00:00
|
|
|
/* 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) {
|
2006-03-28 22:25:08 +00:00
|
|
|
*cur++ = '\0';
|
2005-06-10 20:25:23 +00:00
|
|
|
whitespace = 1;
|
|
|
|
}
|
2006-03-28 22:25:08 +00:00
|
|
|
} else if (*s == '\\' && !escaped) {
|
2005-06-10 20:25:23 +00:00
|
|
|
escaped = 1;
|
|
|
|
} else {
|
|
|
|
if (whitespace) {
|
2006-03-28 22:25:08 +00:00
|
|
|
/* we leave whitespace, and are not quoted. So it's a new argument */
|
2005-06-10 20:25:23 +00:00
|
|
|
argv[x++] = cur;
|
|
|
|
whitespace = 0;
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
2006-03-28 22:25:08 +00:00
|
|
|
*cur++ = *s;
|
2005-06-10 20:25:23 +00:00
|
|
|
escaped = 0;
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
|
|
|
}
|
2005-06-10 20:25:23 +00:00
|
|
|
/* Null terminate */
|
2006-03-28 22:25:08 +00:00
|
|
|
*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.
|
|
|
|
*/
|
2005-06-10 20:25:23 +00:00
|
|
|
argv[x] = NULL;
|
|
|
|
*argc = x;
|
2005-09-25 03:13:00 +00:00
|
|
|
*trailingwhitespace = whitespace;
|
2008-08-10 20:23:50 +00:00
|
|
|
return duplicate;
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
|
|
|
|
2006-03-28 22:25:08 +00:00
|
|
|
/*! \brief Return the number of unique matches for the generator */
|
2006-01-18 22:17:31 +00:00
|
|
|
int ast_cli_generatornummatches(const char *text, const char *word)
|
2003-01-30 15:03:20 +00:00
|
|
|
{
|
|
|
|
int matches = 0, i = 0;
|
2004-11-17 19:28:08 +00:00
|
|
|
char *buf = NULL, *oldbuf = NULL;
|
2003-01-30 15:03:20 +00:00
|
|
|
|
2005-11-29 04:25:28 +00:00
|
|
|
while ((buf = ast_cli_generator(text, word, i++))) {
|
2005-09-24 15:25:52 +00:00
|
|
|
if (!oldbuf || strcmp(buf,oldbuf))
|
|
|
|
matches++;
|
|
|
|
if (oldbuf)
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(oldbuf);
|
2003-01-30 15:03:20 +00:00
|
|
|
oldbuf = buf;
|
|
|
|
}
|
2005-09-24 15:25:52 +00:00
|
|
|
if (oldbuf)
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(oldbuf);
|
2003-01-30 15:03:20 +00:00
|
|
|
return matches;
|
|
|
|
}
|
|
|
|
|
2006-01-18 22:17:31 +00:00
|
|
|
char **ast_cli_completion_matches(const char *text, const char *word)
|
2003-01-30 15:03:20 +00:00
|
|
|
{
|
|
|
|
char **match_list = NULL, *retstr, *prevstr;
|
|
|
|
size_t match_list_len, max_equal, which, i;
|
|
|
|
int matches = 0;
|
|
|
|
|
2006-03-28 22:25:08 +00:00
|
|
|
/* leave entry 0 free for the longest common substring */
|
2003-01-30 15:03:20 +00:00
|
|
|
match_list_len = 1;
|
|
|
|
while ((retstr = ast_cli_generator(text, word, matches)) != NULL) {
|
|
|
|
if (matches + 1 >= match_list_len) {
|
|
|
|
match_list_len <<= 1;
|
2006-02-09 16:59:50 +00:00
|
|
|
if (!(match_list = ast_realloc(match_list, match_list_len * sizeof(*match_list))))
|
|
|
|
return NULL;
|
2003-01-30 15:03:20 +00:00
|
|
|
}
|
|
|
|
match_list[++matches] = retstr;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!match_list)
|
2006-03-28 22:25:08 +00:00
|
|
|
return match_list; /* NULL */
|
2003-01-30 15:03:20 +00:00
|
|
|
|
2006-03-28 22:25:08 +00:00
|
|
|
/* Find the longest substring that is common to all results
|
|
|
|
* (it is a candidate for completion), and store a copy in entry 0.
|
|
|
|
*/
|
2003-01-30 15:03:20 +00:00
|
|
|
prevstr = match_list[1];
|
|
|
|
max_equal = strlen(prevstr);
|
2006-03-28 22:25:08 +00:00
|
|
|
for (which = 2; which <= matches; which++) {
|
2004-11-18 04:11:51 +00:00
|
|
|
for (i = 0; i < max_equal && toupper(prevstr[i]) == toupper(match_list[which][i]); i++)
|
2003-01-30 15:03:20 +00:00
|
|
|
continue;
|
|
|
|
max_equal = i;
|
|
|
|
}
|
|
|
|
|
2006-02-09 16:59:50 +00:00
|
|
|
if (!(retstr = ast_malloc(max_equal + 1)))
|
|
|
|
return NULL;
|
|
|
|
|
2006-10-25 14:44:50 +00:00
|
|
|
ast_copy_string(retstr, match_list[1], max_equal + 1);
|
2003-01-30 15:03:20 +00:00
|
|
|
match_list[0] = retstr;
|
|
|
|
|
2006-03-28 22:25:08 +00:00
|
|
|
/* ensure that the array is NULL terminated */
|
2006-02-09 16:59:50 +00:00
|
|
|
if (matches + 1 >= match_list_len) {
|
|
|
|
if (!(match_list = ast_realloc(match_list, (match_list_len + 1) * sizeof(*match_list))))
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
match_list[matches + 1] = NULL;
|
2003-01-30 15:03:20 +00:00
|
|
|
|
2005-11-29 04:25:28 +00:00
|
|
|
return match_list;
|
2003-01-30 15:03:20 +00:00
|
|
|
}
|
|
|
|
|
2006-11-17 22:53:57 +00:00
|
|
|
/*! \brief returns true if there are more words to match */
|
2009-05-21 21:13:09 +00:00
|
|
|
static int more_words (const char * const *dst)
|
2006-11-17 22:53:57 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; dst[i]; i++) {
|
|
|
|
if (dst[i][0] != '[')
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-11-17 11:12:13 +00:00
|
|
|
/*
|
|
|
|
* generate the entry at position 'state'
|
|
|
|
*/
|
2006-01-18 22:17:31 +00:00
|
|
|
static char *__ast_cli_generator(const char *text, const char *word, int state, int lock)
|
1999-12-19 22:38:55 +00:00
|
|
|
{
|
2009-05-21 21:13:09 +00:00
|
|
|
const char *argv[AST_MAX_ARGS];
|
2007-10-15 13:44:53 +00:00
|
|
|
struct ast_cli_entry *e = NULL;
|
2006-03-28 22:25:08 +00:00
|
|
|
int x = 0, argindex, matchlen;
|
1999-12-19 22:38:55 +00:00
|
|
|
int matchnum=0;
|
2006-03-28 22:25:08 +00:00
|
|
|
char *ret = NULL;
|
2005-08-14 01:48:14 +00:00
|
|
|
char matchstr[80] = "";
|
2006-05-19 19:35:16 +00:00
|
|
|
int tws = 0;
|
2006-12-12 09:40:45 +00:00
|
|
|
/* Split the argument into an array of words */
|
2008-08-10 20:23:50 +00:00
|
|
|
char *duplicate = parse_args(text, &x, argv, ARRAY_LEN(argv), &tws);
|
1999-12-19 22:38:55 +00:00
|
|
|
|
2008-08-10 20:23:50 +00:00
|
|
|
if (!duplicate) /* malloc error */
|
2006-03-28 22:25:08 +00:00
|
|
|
return NULL;
|
2006-12-12 09:40:45 +00:00
|
|
|
|
|
|
|
/* Compute the index of the last argument (could be an empty string) */
|
2006-03-28 22:25:08 +00:00
|
|
|
argindex = (!ast_strlen_zero(word) && x>0) ? x-1 : x;
|
2006-12-12 09:40:45 +00:00
|
|
|
|
|
|
|
/* rebuild the command, ignore terminating white space and flatten space */
|
2006-03-28 22:25:08 +00:00
|
|
|
ast_join(matchstr, sizeof(matchstr)-1, argv);
|
|
|
|
matchlen = strlen(matchstr);
|
2006-05-19 19:35:16 +00:00
|
|
|
if (tws) {
|
|
|
|
strcat(matchstr, " "); /* XXX */
|
|
|
|
if (matchlen)
|
|
|
|
matchlen++;
|
|
|
|
}
|
2006-03-28 22:25:08 +00:00
|
|
|
if (lock)
|
2007-08-01 15:28:02 +00:00
|
|
|
AST_RWLIST_RDLOCK(&helpers);
|
2007-10-15 13:44:53 +00:00
|
|
|
while ( (e = cli_next(e)) ) {
|
2006-11-17 11:12:13 +00:00
|
|
|
/* XXX repeated code */
|
|
|
|
int src = 0, dst = 0, n = 0;
|
2006-12-12 09:40:45 +00:00
|
|
|
|
2007-11-28 15:48:00 +00:00
|
|
|
if (e->command[0] == '_')
|
|
|
|
continue;
|
|
|
|
|
2006-12-12 09:40:45 +00:00
|
|
|
/*
|
|
|
|
* 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) {
|
2006-11-17 11:12:13 +00:00
|
|
|
n = word_match(argv[src], e->cmda[dst]);
|
|
|
|
if (n < 0)
|
2006-11-13 12:04:05 +00:00
|
|
|
break;
|
2006-11-17 11:12:13 +00:00
|
|
|
}
|
|
|
|
|
2006-11-17 22:53:57 +00:00
|
|
|
if (src != argindex && more_words(e->cmda + dst)) /* not a match */
|
2006-11-17 11:12:13 +00:00
|
|
|
continue;
|
|
|
|
ret = is_prefix(argv[src], e->cmda[dst], state - matchnum, &n);
|
|
|
|
matchnum += n; /* this many matches here */
|
|
|
|
if (ret) {
|
2006-12-12 09:40:45 +00:00
|
|
|
/*
|
|
|
|
* argv[src] is a valid prefix of the next word in this
|
|
|
|
* command. If this is also the correct entry, return it.
|
|
|
|
*/
|
2006-11-17 11:12:13 +00:00
|
|
|
if (matchnum > state)
|
|
|
|
break;
|
2007-06-06 21:20:11 +00:00
|
|
|
ast_free(ret);
|
2006-11-17 11:12:13 +00:00
|
|
|
ret = NULL;
|
|
|
|
} else if (ast_strlen_zero(e->cmda[dst])) {
|
2006-12-12 09:40:45 +00:00
|
|
|
/*
|
|
|
|
* This entry is a prefix of the command string entered
|
Bring in the improved internal API for the CLI.
WATCH OUT: this changes the binary interface (ABI) for modules,
so e.g. users of g729 codecs need a rebuilt module (but read below).
The new way to write CLI handlers is described in detail in cli.h,
and there are a few converted handlers in cli.c, look for NEW_CLI.
After converting a couple of commands i am convinced that
it is reasonably convenient to use, and it makes it easier to fix the
pending CLI issues.
On passing, note a bug with the current 'complete' architecture:
if a command is a prefix of multiple CLI entries, we miss some
of the possible options. As an example, "core set debug" can
continue with "channel" from one CLI entry, and "off" or "atleast"
from another one.
We address this problem in a separate commit
(when i have figured out a fix, that is).
ABI issues:
I asked Kevin if it was ok to make this change and he said yes.
While it would have been possible to make the change without breaking
the module ABI, the code would have been more convoluted.
I am happy to restore the old ABI (while still being able
to use the "new style" handlers) if there is demand.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@47606 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-11-14 15:23:35 +00:00
|
|
|
* (only one entry in the list should have this property).
|
|
|
|
* Run the generator if one is available. In any case we are done.
|
|
|
|
*/
|
2007-11-28 20:27:40 +00:00
|
|
|
if (e->handler) { /* new style command */
|
Bring in the improved internal API for the CLI.
WATCH OUT: this changes the binary interface (ABI) for modules,
so e.g. users of g729 codecs need a rebuilt module (but read below).
The new way to write CLI handlers is described in detail in cli.h,
and there are a few converted handlers in cli.c, look for NEW_CLI.
After converting a couple of commands i am convinced that
it is reasonably convenient to use, and it makes it easier to fix the
pending CLI issues.
On passing, note a bug with the current 'complete' architecture:
if a command is a prefix of multiple CLI entries, we miss some
of the possible options. As an example, "core set debug" can
continue with "channel" from one CLI entry, and "off" or "atleast"
from another one.
We address this problem in a separate commit
(when i have figured out a fix, that is).
ABI issues:
I asked Kevin if it was ok to make this change and he said yes.
While it would have been possible to make the change without breaking
the module ABI, the code would have been more convoluted.
I am happy to restore the old ABI (while still being able
to use the "new style" handlers) if there is demand.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@47606 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-11-14 15:23:35 +00:00
|
|
|
struct ast_cli_args a = {
|
|
|
|
.line = matchstr, .word = word,
|
|
|
|
.pos = argindex,
|
2008-09-06 12:03:11 +00:00
|
|
|
.n = state - matchnum,
|
|
|
|
.argv = argv,
|
|
|
|
.argc = x};
|
2007-11-28 20:27:40 +00:00
|
|
|
ret = e->handler(e, CLI_GENERATE, &a);
|
Bring in the improved internal API for the CLI.
WATCH OUT: this changes the binary interface (ABI) for modules,
so e.g. users of g729 codecs need a rebuilt module (but read below).
The new way to write CLI handlers is described in detail in cli.h,
and there are a few converted handlers in cli.c, look for NEW_CLI.
After converting a couple of commands i am convinced that
it is reasonably convenient to use, and it makes it easier to fix the
pending CLI issues.
On passing, note a bug with the current 'complete' architecture:
if a command is a prefix of multiple CLI entries, we miss some
of the possible options. As an example, "core set debug" can
continue with "channel" from one CLI entry, and "off" or "atleast"
from another one.
We address this problem in a separate commit
(when i have figured out a fix, that is).
ABI issues:
I asked Kevin if it was ok to make this change and he said yes.
While it would have been possible to make the change without breaking
the module ABI, the code would have been more convoluted.
I am happy to restore the old ABI (while still being able
to use the "new style" handlers) if there is demand.
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@47606 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2006-11-14 15:23:35 +00:00
|
|
|
}
|
|
|
|
if (ret)
|
|
|
|
break;
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
|
|
|
}
|
2006-03-28 22:25:08 +00:00
|
|
|
if (lock)
|
2007-08-01 15:28:02 +00:00
|
|
|
AST_RWLIST_UNLOCK(&helpers);
|
2008-08-10 20:23:50 +00:00
|
|
|
ast_free(duplicate);
|
2006-03-28 22:25:08 +00:00
|
|
|
return ret;
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
|
|
|
|
2006-01-18 22:17:31 +00:00
|
|
|
char *ast_cli_generator(const char *text, const char *word, int state)
|
2001-05-09 03:11:22 +00:00
|
|
|
{
|
|
|
|
return __ast_cli_generator(text, word, state, 1);
|
|
|
|
}
|
|
|
|
|
2008-12-01 18:52:14 +00:00
|
|
|
int ast_cli_command_full(int uid, int gid, int fd, const char *s)
|
1999-12-19 22:38:55 +00:00
|
|
|
{
|
2009-05-21 21:13:09 +00:00
|
|
|
const char *args[AST_MAX_ARGS + 1];
|
1999-12-19 22:38:55 +00:00
|
|
|
struct ast_cli_entry *e;
|
|
|
|
int x;
|
2008-08-10 20:23:50 +00:00
|
|
|
char *duplicate = parse_args(s, &x, args + 1, AST_MAX_ARGS, NULL);
|
2008-12-01 18:52:14 +00:00
|
|
|
char tmp[AST_MAX_ARGS + 1];
|
2007-11-28 22:32:57 +00:00
|
|
|
char *retval = NULL;
|
|
|
|
struct ast_cli_args a = {
|
|
|
|
.fd = fd, .argc = x, .argv = args+1 };
|
2006-11-16 14:58:24 +00:00
|
|
|
|
2008-08-10 20:23:50 +00:00
|
|
|
if (duplicate == NULL)
|
2005-11-29 04:25:28 +00:00
|
|
|
return -1;
|
|
|
|
|
2006-11-16 14:58:24 +00:00
|
|
|
if (x < 1) /* We need at least one entry, otherwise ignore */
|
|
|
|
goto done;
|
|
|
|
|
2007-08-01 15:28:02 +00:00
|
|
|
AST_RWLIST_RDLOCK(&helpers);
|
2006-11-16 14:58:24 +00:00
|
|
|
e = find_cli(args + 1, 0);
|
|
|
|
if (e)
|
|
|
|
ast_atomic_fetchadd_int(&e->inuse, 1);
|
2007-08-01 15:28:02 +00:00
|
|
|
AST_RWLIST_UNLOCK(&helpers);
|
2006-11-16 14:58:24 +00:00
|
|
|
if (e == NULL) {
|
2008-11-12 06:46:04 +00:00
|
|
|
ast_cli(fd, "No such command '%s' (type 'core show help %s' for other possible commands)\n", s, find_best(args + 1));
|
2006-11-16 14:58:24 +00:00
|
|
|
goto done;
|
|
|
|
}
|
2008-12-01 18:52:14 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
ast_free(duplicate);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-11-16 14:58:24 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
2007-11-28 22:32:57 +00:00
|
|
|
retval = e->handler(e, CLI_HANDLER, &a);
|
2007-11-28 20:27:40 +00:00
|
|
|
|
|
|
|
if (retval == CLI_SHOWUSAGE) {
|
2006-11-16 14:58:24 +00:00
|
|
|
ast_cli(fd, "%s", S_OR(e->usage, "Invalid usage, but no usage information available.\n"));
|
2007-11-28 20:27:40 +00:00
|
|
|
} else {
|
|
|
|
if (retval == CLI_FAILURE)
|
|
|
|
ast_cli(fd, "Command '%s' failed.\n", s);
|
1999-12-19 22:38:55 +00:00
|
|
|
}
|
2006-11-16 14:58:24 +00:00
|
|
|
ast_atomic_fetchadd_int(&e->inuse, -1);
|
|
|
|
done:
|
2008-08-10 20:23:50 +00:00
|
|
|
ast_free(duplicate);
|
1999-12-19 22:38:55 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2007-10-21 22:52:20 +00:00
|
|
|
|
2008-12-01 18:52:14 +00:00
|
|
|
int ast_cli_command_multiple_full(int uid, int gid, int fd, size_t size, const char *s)
|
2007-10-21 22:52:20 +00:00
|
|
|
{
|
|
|
|
char cmd[512];
|
|
|
|
int x, y = 0, count = 0;
|
|
|
|
|
|
|
|
for (x = 0; x < size; x++) {
|
|
|
|
cmd[y] = s[x];
|
|
|
|
y++;
|
|
|
|
if (s[x] == '\0') {
|
2008-12-01 18:52:14 +00:00
|
|
|
ast_cli_command_full(uid, gid, fd, cmd);
|
2007-10-21 22:52:20 +00:00
|
|
|
y = 0;
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return count;
|
|
|
|
}
|