#include <switch.h>
#include <switch_console.h>
#include <switch_private.h>

Include dependency graph for switch_console.c:

Data Structures
struct	helper

struct	match_helper

Macros
#define	CMD_BUFLEN 1024

#define	CC_NORM 0

#define	CC_NEWLINE 1

#define	CC_EOF 2

#define	CC_ARGHACK 3

#define	CC_REFRESH 4

#define	CC_CURSOR 5

#define	CC_ERROR 6

#define	CC_FATAL 7

#define	CC_REDISPLAY 8

#define	CC_REFRESH_BEEP 9

Functions
static switch_status_t	console_xml_config (void)

switch_status_t	switch_console_stream_raw_write (switch_stream_handle_t handle, uint8_t data, switch_size_t datalen)

switch_status_t	switch_console_stream_write (switch_stream_handle_t handle, const char fmt,...)

switch_status_t	switch_stream_write_file_contents (switch_stream_handle_t stream, const char path)

static int	alias_callback (void pArg, int argc, char argv, char *columnNames)

char *	switch_console_expand_alias (char cmd, char arg)

static int	switch_console_process (char *xcmd)

switch_status_t	switch_console_execute (char xcmd, int rec, switch_stream_handle_t istream)

void	switch_console_printf (switch_text_channel_t channel, const char file, const char func, int line, const char *fmt,...)

static int	comp_callback (void pArg, int argc, char argv, char *columnNames)

static int	modulename_callback (void pArg, const char module_name)

switch_status_t	switch_console_list_available_modules (const char line, const char cursor, switch_console_callback_match_t **matches)

switch_status_t	switch_console_list_loaded_modules (const char line, const char cursor, switch_console_callback_match_t **matches)

switch_status_t	switch_console_list_interfaces (const char line, const char cursor, switch_console_callback_match_t **matches)

static int	uuid_callback (void pArg, int argc, char argv, char *columnNames)

switch_status_t	switch_console_list_uuid (const char line, const char cursor, switch_console_callback_match_t **matches)

unsigned char	switch_console_complete (const char line, const char cursor, FILE console_out, switch_stream_handle_t stream, switch_xml_t xml)

void	switch_console_save_history (void)

void	switch_console_loop (void)
	A simple comand loop that reads input from the terminal. More...

switch_status_t	switch_console_init (switch_memory_pool_t *pool)

switch_status_t	switch_console_shutdown (void)

switch_status_t	switch_console_add_complete_func (const char *name, switch_console_complete_callback_t cb)

switch_status_t	switch_console_del_complete_func (const char *name)

void	switch_console_free_matches (switch_console_callback_match_t **matches)

void	switch_console_sort_matches (switch_console_callback_match_t *matches)

void	switch_console_push_match_unique (switch_console_callback_match_t *matches, const char new_val)

void	switch_console_push_match (switch_console_callback_match_t *matches, const char new_val)

switch_status_t	switch_console_run_complete_func (const char func, const char line, const char last_word, switch_console_callback_match_t *matches)

switch_status_t	switch_console_set_complete (const char *string)

switch_status_t	switch_console_set_alias (const char *string)

Variables
static char *	console_fnkeys [12]

static int32_t	running = 1

struct {
switch_hash_t * func_hash

switch_mutex_t * func_mutex

}	globals

Macro Definition Documentation

#define CC_ARGHACK 3

Definition at line 53 of file switch_console.c.

#define CC_CURSOR 5

Definition at line 55 of file switch_console.c.

#define CC_EOF 2

Definition at line 52 of file switch_console.c.

#define CC_ERROR 6

Definition at line 56 of file switch_console.c.

Referenced by switch_console_complete().

#define CC_FATAL 7

Definition at line 57 of file switch_console.c.

#define CC_NEWLINE 1

Definition at line 51 of file switch_console.c.

#define CC_NORM 0

Definition at line 50 of file switch_console.c.

#define CC_REDISPLAY 8

Definition at line 58 of file switch_console.c.

Referenced by switch_console_complete().

#define CC_REFRESH 4

Definition at line 54 of file switch_console.c.

#define CC_REFRESH_BEEP 9

Definition at line 59 of file switch_console.c.

#define CMD_BUFLEN 1024

Definition at line 38 of file switch_console.c.

Referenced by switch_console_loop().

Function Documentation

static int alias_callback	(	void *	pArg,
		int	argc,
		char **	argv,
		char **	columnNames
	)

static

Definition at line 233 of file switch_console.c.

Referenced by switch_console_expand_alias().

 {
         char **r = (char **) pArg;
         *r = strdup(argv[0]);
         return -1;
 }

static int comp_callback	(	void *	pArg,
		int	argc,
		char **	argv,
		char **	columnNames
	)

static

Definition at line 466 of file switch_console.c.

References cur, switch_console_callback_match::head, helper::hits, helper::last, switch_console_callback_match_node::next, helper::out, helper::partial, helper::stream, switch_console_free_matches(), switch_console_run_complete_func(), switch_copy_string(), switch_safe_free, switch_separate_string(), SWITCH_STATUS_SUCCESS, switch_xml_add_child_d, switch_xml_set_txt_d, switch_console_callback_match_node::val, switch_stream_handle::write_function, helper::xml, helper::xml_off, and zstr.

Referenced by switch_console_complete().

 {
         struct helper *h = (struct helper *) pArg;
         char *target = NULL, *str = NULL, *cur = NULL;
         switch_size_t x, y, i;
 
 
         if (argc > 0)
                 target = argv[0];
         if (argc > 1)
                 str = argv[1];
         if (argc > 2)
                 cur = argv[2];
 
         if (cur) {
                 while (*cur == ' ')
                         cur++;
         }
 
         if (zstr(cur))
                 cur = NULL;
         if (zstr(str))
                 str = NULL;
 
         if (!target) {
                 return -1;
         }
 
         if (!zstr(target) && *target == ':' && *(target + 1) == ':' && *(target + 2) == '[') {
                 char *p = target + 3, *list = NULL;
 
                 if (p) {
                         char *s_argv[100] = { 0 };
                         char *r_argv[1] = { 0 }, *r_cols[1] = {0};
                         list = strdup(p);
                         
                         argc = switch_separate_string(list, ':', s_argv, (sizeof(s_argv) / sizeof(s_argv[0])));
 
                         for (i = 0; (int)i < argc; i++) {
                                 if (!cur || !strncmp(s_argv[i], cur, strlen(cur))) {
                                         r_argv[0] = s_argv[i];
                                         comp_callback(h, 1, r_argv, r_cols);
                                 }
                         }
                         switch_safe_free(list);
                 }
                 return 0;
         }
 
         if (!zstr(target) && *target == ':' && *(target + 1) == ':') {
                 char *r_argv[1] = { 0 }, *r_cols[1] = {0};
                 switch_console_callback_match_t *matches;
                 if (switch_console_run_complete_func(target, str, cur, &matches) == SWITCH_STATUS_SUCCESS) {
                         switch_console_callback_match_node_t *m;
                         for (m = matches->head; m; m = m->next) {
                                 if (!cur || !strncmp(m->val, cur, strlen(cur))) {
                                         r_argv[0] = m->val;
                                         comp_callback(h, 1, r_argv, r_cols);
                                 }
                         }
                         switch_console_free_matches(&matches);
                 }
                 return 0;
         }
 
         if (!zstr(target)) {
                 if (h->out) {
                         fprintf(h->out, "[%20s]\t", target);
                 }
                 if (h->stream) {
                         h->stream->write_function(h->stream, "[%20s]\t", target);
                 }
                 if (h->xml) {
                         switch_xml_set_txt_d(switch_xml_add_child_d(h->xml, "match", h->xml_off++), target);
                 }
 
                 switch_copy_string(h->last, target, sizeof(h->last));
                 h->hits++;
         }
 
         x = strlen(h->last);
         y = strlen(h->partial);
 
         if (h->hits > 1) {
                 for (i = 0; i < x && i < y; i++) {
                         if (h->last[i] != h->partial[i]) {
                                 h->partial[i] = '\0';
                                 break;
                         }
                 }
         } else if (h->hits == 1) {
                 switch_copy_string(h->partial, target, sizeof(h->last));
         }
 
         if (!zstr(target)) {
 #ifdef _MSC_VER
                 if ((h->hits % 3) == 0) {
 #else
                 if ((h->hits % 4) == 0) {
 #endif
                         if (h->out) {
                                 fprintf(h->out, "\n");
                         }
                         if (h->stream) {
                                 h->stream->write_function(h->stream, "\n");
                         }
                 }
         }
 
         return 0;
 }

static switch_status_t console_xml_config ( void )

static

Definition at line 90 of file switch_console.c.

References console_fnkeys, switch_xml::next, SWITCH_CHANNEL_LOG, switch_core_permanent_strdup, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TERM, switch_xml_attr_soft(), switch_xml_child(), switch_xml_free(), and switch_xml_open_cfg().

Referenced by switch_console_loop().

 {
         char *cf = "switch.conf";
         switch_xml_t cfg, xml, settings, param;
 
         /* clear the keybind array */
         int i;
 
         for (i = 0; i < 12; i++) {
                 console_fnkeys[i] = NULL;
         }
 
         if (!(xml = switch_xml_open_cfg(cf, &cfg, NULL))) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Open of %s failed\n", cf);
                 return SWITCH_STATUS_TERM;
         }
 
         if ((settings = switch_xml_child(cfg, "cli-keybindings"))) {
                 for (param = switch_xml_child(settings, "key"); param; param = param->next) {
                         char *var = (char *) switch_xml_attr_soft(param, "name");
                         char *val = (char *) switch_xml_attr_soft(param, "value");
                         i = atoi(var);
                         if ((i < 1) || (i > 12)) {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Keybind %s is invalid, range is from 1 to 12\n", var);
                         } else {
                                 /* Add the command to the fnkey array */
                                 console_fnkeys[i - 1] = switch_core_permanent_strdup(val);
                         }
                 }
         }
 
         switch_xml_free(xml);
 
         return SWITCH_STATUS_SUCCESS;
 }

static int modulename_callback	(	void *	pArg,
		const char *	module_name
	)

static

Definition at line 584 of file switch_console.c.

References match_helper::my_matches, and switch_console_push_match().

Referenced by switch_console_list_available_modules(), and switch_console_list_loaded_modules().

 {
         struct match_helper *h = (struct match_helper *) pArg;
 
         switch_console_push_match(&h->my_matches, module_name);
         return 0;
 }

switch_status_t switch_console_add_complete_func	(	const char *	name,
		switch_console_complete_callback_t	cb
	)

Definition at line 1676 of file switch_console.c.

References globals, switch_core_hash_insert, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_console_init().

 {
         switch_status_t status;
 
         switch_mutex_lock(globals.func_mutex);
         status = switch_core_hash_insert(globals.func_hash, name, (void *) (intptr_t) cb);
         switch_mutex_unlock(globals.func_mutex);
 
         return status;
 }

unsigned char switch_console_complete	(	const char *	line,
		const char *	cursor,
		FILE *	console_out,
		switch_stream_handle_t *	stream,
		switch_xml_t	xml
	)

Definition at line 699 of file switch_console.c.

References buf, CC_ERROR, CC_REDISPLAY, comp_callback(), switch_stream_handle::data, end_of_p, helper::hits, helper::last, helper::len, helper::out, helper::partial, SCDB_TYPE_CORE_DB, helper::stream, switch_assert, switch_cache_db_execute_sql_callback(), switch_cache_db_get_type(), switch_cache_db_release_db_handle(), SWITCH_CHANNEL_LOG, switch_core_db_handle, switch_core_get_hostname(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mprintf(), switch_safe_free, switch_separate_string(), SWITCH_STANDARD_STREAM, SWITCH_STATUS_SUCCESS, switch_str_nil, switch_xml_add_child_d, switch_xml_set_attr_d_buf, switch_xml_set_txt_d, helper::words, switch_stream_handle::write_function, helper::xml, helper::xml_off, and zstr.

 {
         switch_cache_db_handle_t *db = NULL;
         char *sql = NULL;
         char *dup = strdup(line);
         char *buf = dup;
         char *p, *lp = NULL;
         char *errmsg = NULL;
         struct helper h = { 0 };
         unsigned char ret = CC_REDISPLAY;
         int pos = 0;
         int sc = 0;
 
 #ifndef HAVE_LIBEDIT
 #ifndef _MSC_VER
         if (!stream) {
                 return CC_ERROR;
         }
 #endif
 #endif
 
         if (switch_core_db_handle(&db) != SWITCH_STATUS_SUCCESS) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Database Error\n");
                 return CC_ERROR;
         }
 
         if (!zstr(cursor) && !zstr(line)) {
                 pos = (int)(cursor - line);
         }
 
         h.out = console_out;
         h.stream = stream;
         h.xml = xml;
 
         if (pos > 0) {
                 *(buf + pos) = '\0';
         }
 
         if ((p = strchr(buf, '\r')) || (p = strchr(buf, '\n'))) {
                 *p = '\0';
         }
 
         while (*buf == ' ') {
                 sc++;
                 buf++;
         }
 
         if (!*buf) {
 #ifdef HAVE_LIBEDIT
                 if (h.out && sc) {
                         el_deletestr(el, sc);
                 }
 #endif
         }
 
         sc = 0;
         p = end_of_p(buf);
         while (p >= buf && *p == ' ') {
                 sc++;
                 p--;
         }
 
         if (sc > 1) {
 #ifdef HAVE_LIBEDIT
                 if (h.out) {
                         el_deletestr(el, sc - 1);
                 }
 #endif
                 *(p + 2) = '\0';
         }
 
         for (p = buf; p && *p; p++) {
                 if (*p == ' ') {
                         lp = p;
                         h.words++;
                         while (*p == ' ')
                                 p++;
                         if (!*p)
                                 break;
                 }
         }
 
         if (lp) {
                 buf = lp + 1;
         }
 
         h.len = (int)strlen(buf);
 
         if (h.out) {
                 fprintf(h.out, "\n\n");
         }
 
         if (h.stream) {
                 h.stream->write_function(h.stream, "\n\n");
         }
 
 
 
         if (h.words == 0) {
                 sql = switch_mprintf("select distinct name from interfaces where type='api' and name like '%q%%' and hostname='%q' order by name",
                                                          buf, switch_core_get_hostname());
         }
 
         if (sql) {
                 switch_cache_db_execute_sql_callback(db, sql, comp_callback, &h, &errmsg);
 
                 if (errmsg) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "error [%s][%s]\n", sql, errmsg);
                         free(errmsg);
                         ret = CC_ERROR;
                         goto end;
                 }
                 free(sql);
                 sql = NULL;
         }
 
         if (h.hits != -1) {
                 char *dupdup = strdup(dup);
                 int x, argc = 0;
                 char *argv[10] = { 0 };
                 switch_stream_handle_t stream = { 0 };
                 SWITCH_STANDARD_STREAM(stream);
                 switch_assert(dupdup);
 
                 argc = switch_separate_string(dupdup, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
 
                 if (h.words == 0) {
                         stream.write_function(&stream, "select distinct a1 from complete where " "a1 not in (select name from interfaces where hostname='%s') %s ",
                                                                   switch_core_get_hostname(), argc ? "and" : "");
                 } else {
                         if (switch_cache_db_get_type(db) == SCDB_TYPE_CORE_DB) {
                                 stream.write_function(&stream, "select distinct a%d,'%q','%q' from complete where ", h.words + 1, switch_str_nil(dup), switch_str_nil(lp));
                         } else {
                                 stream.write_function(&stream, "select distinct a%d,'%q','%w' from complete where ", h.words + 1, switch_str_nil(dup), switch_str_nil(lp));
                         }
                 }
 
                 for (x = 0; x < argc && x < 11; x++) {
                         if (h.words + 1 > argc) {
                                 if (switch_cache_db_get_type(db) == SCDB_TYPE_CORE_DB) {
                                         stream.write_function(&stream, "(a%d like '::%%' or a%d = '' or a%d = '%q')%q",
                                                                                   x + 1, x + 1, x + 1, switch_str_nil(argv[x]), x == argc - 1 ? "" : " and ");
                                 } else {
                                         stream.write_function(&stream, "(a%d like '::%%' or a%d = '' or a%d = '%w')%w",
                                                                                   x + 1, x + 1, x + 1, switch_str_nil(argv[x]), x == argc - 1 ? "" : " and ");
                                 }
                         } else {
                                 if (switch_cache_db_get_type(db) == SCDB_TYPE_CORE_DB) {
                                         stream.write_function(&stream, "(a%d like '::%%' or a%d = '' or a%d like '%q%%')%q",
                                                                                   x + 1, x + 1, x + 1, switch_str_nil(argv[x]), x == argc - 1 ? "" : " and ");
                                 } else {
                                         stream.write_function(&stream, "(a%d like '::%%' or a%d = '' or a%d like '%w%%')%w",
                                                                                   x + 1, x + 1, x + 1, switch_str_nil(argv[x]), x == argc - 1 ? "" : " and ");
                                 }
                         }
                 }
 
                 stream.write_function(&stream, " and hostname='%s' order by a%d", switch_core_get_hostname(), h.words + 1);
                 
                 switch_cache_db_execute_sql_callback(db, stream.data, comp_callback, &h, &errmsg);
 
                 if (errmsg) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "error [%s][%s]\n", (char *) stream.data, errmsg);
                         free(errmsg);
                         ret = CC_ERROR;
                 }
 
                 switch_safe_free(dupdup);
                 switch_safe_free(stream.data);
 
                 if (ret == CC_ERROR) {
                         goto end;
                 }
         }
 
         if (h.out) {
                 fprintf(h.out, "\n\n");
         }
 
         if (h.stream) {
                 h.stream->write_function(h.stream, "\n\n");
                 if (h.hits == 1 && !zstr(h.last)) {
                         h.stream->write_function(h.stream, "write=%d:%s ", h.len, h.last);
                 } else if (h.hits > 1 && !zstr(h.partial)) {
                         h.stream->write_function(h.stream, "write=%d:%s", h.len, h.partial);
                 }
         }
 
         if (h.xml) {
                 switch_xml_t x_write = switch_xml_add_child_d(h.xml, "write", h.xml_off++);
                 char buf[32];
 
                 snprintf(buf, sizeof(buf), "%d", h.len);
                 switch_xml_set_attr_d_buf(x_write, "length", buf);
 
                 if (h.hits == 1 && !zstr(h.last)) {
                         switch_xml_set_txt_d(x_write, h.last);
                 } else if (h.hits > 1 && !zstr(h.partial)) {
                         switch_xml_set_txt_d(x_write, h.partial);
                 }
         }
 #ifdef HAVE_LIBEDIT
         if (h.out) {
                 if (h.hits == 1 && !zstr(h.last)) {
                         el_deletestr(el, h.len);
                         el_insertstr(el, h.last);
                         el_insertstr(el, " ");
                 } else if (h.hits > 1 && !zstr(h.partial)) {
                         el_deletestr(el, h.len);
                         el_insertstr(el, h.partial);
                 }
         }
 #else
 #ifdef _MSC_VER
         if (h.out) {
                 if (h.hits == 1 && !zstr(h.last)) {
                         console_bufferInput(0, h.len, (char *) line, DELETE_REFRESH_OP);
                         console_bufferInput(h.last, (int) strlen(h.last), (char *) line, 0);
                         console_bufferInput(" ", 1, (char *) line, 0);
                 } else if (h.hits > 1 && !zstr(h.partial)) {
                         console_bufferInput(0, h.len, (char *) line, DELETE_REFRESH_OP);
                         console_bufferInput(h.partial, (int) strlen(h.partial), (char *) line, 0);
                 } else {
                         console_bufferInput(0, 0, (char *) line, DELETE_REFRESH_OP);
                 }
         }
 #endif
 #endif
 
   end:
 
         if (h.out) {
                 fflush(h.out);
         }
 
         switch_safe_free(sql);
         switch_safe_free(dup);
 
         switch_cache_db_release_db_handle(&db);
 
         return (ret);
 }

switch_status_t switch_console_del_complete_func ( const char * name )

Definition at line 1687 of file switch_console.c.

References globals, switch_core_hash_insert, switch_mutex_lock(), and switch_mutex_unlock().

 {
         switch_status_t status;
 
         switch_mutex_lock(globals.func_mutex);
         status = switch_core_hash_insert(globals.func_hash, name, NULL);
         switch_mutex_unlock(globals.func_mutex);
 
         return status;
 }

switch_status_t switch_console_execute	(	char *	xcmd,
		int	rec,
		switch_stream_handle_t *	istream
	)

Definition at line 347 of file switch_console.c.

References switch_api_execute(), SWITCH_CHANNEL_LOG, switch_console_expand_alias(), SWITCH_LOG_CRIT, switch_log_printf(), switch_safe_free, switch_separate_string_string(), and SWITCH_STATUS_FALSE.

Referenced by switch_console_process(), and switch_core_init_and_modload().

 {
         char *arg = NULL, *alias = NULL;
 
         char *delim = ";;";
         int argc;
         char *argv[128];
         int x;
         char *dup = strdup(xcmd);
         char *cmd;
 
         switch_status_t status = SWITCH_STATUS_FALSE;
 
 
         if (rec > 100) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Too much recursion!\n");
                 goto end;
         }
 
         if (!strncasecmp(xcmd, "alias", 5)) {
                 argc = 1;
                 argv[0] = xcmd;
         } else {
                 argc = switch_separate_string_string(dup, delim, argv, 128);
         }
 
         for (x = 0; x < argc; x++) {
                 cmd = argv[x];
                 if ((arg = strchr(cmd, '\r')) != 0 || (arg = strchr(cmd, '\n')) != 0) {
                         *arg = '\0';
                         arg = NULL;
                 }
                 if ((arg = strchr(cmd, ' ')) != 0) {
                         *arg++ = '\0';
                 }
 
                 if ((alias = switch_console_expand_alias(cmd, arg)) && alias != cmd) {
                         istream->write_function(istream, "\nExpand Alias [%s]->[%s]\n\n", cmd, alias);
                         status = switch_console_execute(alias, ++rec, istream);
                         free(alias);
                         continue;
                 }
 
 
                 status = switch_api_execute(cmd, arg, NULL, istream);
         }
 
   end:
 
         switch_safe_free(dup);
 
         return status;
 }

char* switch_console_expand_alias	(	char *	cmd,
		char *	arg
	)

Definition at line 240 of file switch_console.c.

References alias_callback(), SCDB_TYPE_CORE_DB, SCF_USE_SQL, switch_cache_db_execute_sql_callback(), switch_cache_db_get_type(), switch_cache_db_release_db_handle(), SWITCH_CHANNEL_LOG, switch_core_db_handle, switch_core_flags(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mprintf(), switch_safe_free, and SWITCH_STATUS_SUCCESS.

Referenced by switch_console_execute().

 {
         char *errmsg = NULL;
         char *r = NULL;
         char *sql = NULL;
         char *exp = NULL;
         switch_cache_db_handle_t *db = NULL;
         switch_core_flag_t cflags = switch_core_flags();
         int full = 0;
 
         
         if (!(cflags & SCF_USE_SQL)) {
                 return NULL;
         }
 
         if (switch_core_db_handle(&db) != SWITCH_STATUS_SUCCESS) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Database Error\n");
                 return NULL;
         }
 
 
         if (switch_cache_db_get_type(db) == SCDB_TYPE_CORE_DB) {
                 sql = switch_mprintf("select command from aliases where alias='%q'", cmd);
         } else {
                 sql = switch_mprintf("select command from aliases where alias='%w'", cmd);
         }
 
         switch_cache_db_execute_sql_callback(db, sql, alias_callback, &r, &errmsg);
 
         if (errmsg) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "error [%s][%s]\n", sql, errmsg);
                 free(errmsg);
         }
 
         switch_safe_free(sql);
 
         if (!r) {
                 if (switch_cache_db_get_type(db) == SCDB_TYPE_CORE_DB) {
                         sql = switch_mprintf("select command from aliases where alias='%q %q'", cmd, arg);
                 } else {
                         sql = switch_mprintf("select command from aliases where alias='%w %w'", cmd, arg);
                 }
 
                 switch_cache_db_execute_sql_callback(db, sql, alias_callback, &r, &errmsg);
 
                 if (errmsg) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "error [%s][%s]\n", sql, errmsg);
                         free(errmsg);
                 }
                 if (r) {
                         full++;
                 }
         }
 
         switch_safe_free(sql);
 
         if (r) {
                 if (arg && !full) {
                         exp = switch_mprintf("%s %s", r, arg);
                         free(r);
                 } else {
                         exp = r;
                 }
         } else {
                 exp = cmd;
         }
 
         switch_cache_db_release_db_handle(&db);
 
         return exp;
 }

void switch_console_free_matches ( switch_console_callback_match_t ** matches )

Definition at line 1698 of file switch_console.c.

References cur, switch_console_callback_match::dynamic, switch_console_callback_match::head, switch_console_callback_match_node::next, and switch_console_callback_match_node::val.

Referenced by comp_callback().

 {
         switch_console_callback_match_t *my_match = *matches;
         switch_console_callback_match_node_t *m, *cur;
 
         /* Don't play with matches */
         *matches = NULL;
 
         m = my_match->head;
         while (m) {
                 cur = m;
                 m = m->next;
                 free(cur->val);
                 free(cur);
         }
 
         if (my_match->dynamic) {
                 free(my_match);
         }
 }

switch_status_t switch_console_init ( switch_memory_pool_t * pool )

Definition at line 1660 of file switch_console.c.

References globals, switch_console_add_complete_func(), switch_console_list_available_modules(), switch_console_list_interfaces(), switch_console_list_loaded_modules(), switch_console_list_uuid(), switch_core_hash_init, switch_mutex_init(), SWITCH_MUTEX_NESTED, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_init().

 {
         switch_mutex_init(&globals.func_mutex, SWITCH_MUTEX_NESTED, pool);
         switch_core_hash_init(&globals.func_hash);
         switch_console_add_complete_func("::console::list_available_modules", (switch_console_complete_callback_t) switch_console_list_available_modules);
         switch_console_add_complete_func("::console::list_loaded_modules", (switch_console_complete_callback_t) switch_console_list_loaded_modules);
         switch_console_add_complete_func("::console::list_interfaces", (switch_console_complete_callback_t) switch_console_list_interfaces);
         switch_console_add_complete_func("::console::list_uuid", (switch_console_complete_callback_t) switch_console_list_uuid);
         return SWITCH_STATUS_SUCCESS;
 }

switch_status_t switch_console_list_available_modules	(	const char *	line,
		const char *	cursor,
		switch_console_callback_match_t **	matches
	)

Definition at line 592 of file switch_console.c.

References switch_directories::mod_dir, modulename_callback(), match_helper::my_matches, SWITCH_GLOBAL_dirs, switch_loadable_module_enumerate_available(), SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, and SWITCH_STATUS_SUCCESS.

Referenced by switch_console_init().

 {
         struct match_helper h = { 0 };
 
         if (switch_loadable_module_enumerate_available(SWITCH_GLOBAL_dirs.mod_dir, modulename_callback, &h) != SWITCH_STATUS_SUCCESS) {
                 return SWITCH_STATUS_GENERR;
         }
 
         if (h.my_matches) {
                 *matches = h.my_matches;
                 return SWITCH_STATUS_SUCCESS;
         }
 
         return SWITCH_STATUS_FALSE;
 }

switch_status_t switch_console_list_interfaces	(	const char *	line,
		const char *	cursor,
		switch_console_callback_match_t **	matches
	)

Definition at line 648 of file switch_console.c.

References SWITCH_STATUS_FALSE.

Referenced by switch_console_init().

 {
         return SWITCH_STATUS_FALSE;
 }

switch_status_t switch_console_list_loaded_modules	(	const char *	line,
		const char *	cursor,
		switch_console_callback_match_t **	matches
	)

Definition at line 608 of file switch_console.c.

References modulename_callback(), match_helper::my_matches, switch_loadable_module_enumerate_loaded(), SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, and SWITCH_STATUS_SUCCESS.

Referenced by switch_console_init().

 {
         struct match_helper h = { 0 };
 
         if (switch_loadable_module_enumerate_loaded(modulename_callback, &h) != SWITCH_STATUS_SUCCESS) {
                 return SWITCH_STATUS_GENERR;
         }
 
         if (h.my_matches) {
                 *matches = h.my_matches;
                 return SWITCH_STATUS_SUCCESS;
         }
 
         return SWITCH_STATUS_FALSE;
 }

switch_status_t switch_console_list_uuid	(	const char *	line,
		const char *	cursor,
		switch_console_callback_match_t **	matches
	)

Definition at line 663 of file switch_console.c.

References match_helper::my_matches, switch_cache_db_execute_sql_callback(), switch_cache_db_release_db_handle(), SWITCH_CHANNEL_LOG, switch_core_db_handle, switch_core_get_switchname(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mprintf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, uuid_callback(), and zstr.

Referenced by switch_console_init().

 {
         char *sql;
         struct match_helper h = { 0 };
         switch_cache_db_handle_t *db = NULL;
         switch_status_t status = SWITCH_STATUS_FALSE;
         char *errmsg;
 
 
         if (switch_core_db_handle(&db) != SWITCH_STATUS_SUCCESS) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Database Error\n");
                 return SWITCH_STATUS_GENERR;
         }
 
         if (!zstr(cursor)) {
                 sql = switch_mprintf("select distinct uuid from channels where uuid like '%q%%' and hostname='%q' order by uuid",
                                                          cursor, switch_core_get_switchname());
         } else {
                 sql = switch_mprintf("select distinct uuid from channels where hostname='%q' order by uuid", switch_core_get_switchname());
         }
 
         switch_cache_db_execute_sql_callback(db, sql, uuid_callback, &h, &errmsg);
         free(sql);
 
         switch_cache_db_release_db_handle(&db);
 
         if (h.my_matches) {
                 *matches = h.my_matches;
                 status = SWITCH_STATUS_SUCCESS;
         }
 
 
         return status;
 }

void switch_console_loop ( void )

A simple comand loop that reads input from the terminal.

Definition at line 1552 of file switch_console.c.

References CMD_BUFLEN, console_xml_config(), memset(), running, SCSC_CHECK_RUNNING, SWITCH_CHANNEL_LOG_CLEAN, switch_console_process(), switch_core_get_switchname(), switch_core_session_ctl(), SWITCH_LOG_CONSOLE, and switch_log_printf().

Referenced by fs_console_loop(), and switch_core_runtime_loop().

 {
         char cmd[CMD_BUFLEN + 1] = "";
         int32_t activity = 1;
 #ifndef _MSC_VER
         int x = 0;
 #else
         char keys[CMD_BUFLEN];
 #endif
 
         /* Load/Init the config first */
         console_xml_config();
 
 #ifdef _MSC_VER
         sprintf(cmd, "\nfreeswitch@%s> ", switch_core_get_switchname());
         console_bufferInput(0, 0, cmd, PROMPT_OP);
         memset(cmd, 0, sizeof(cmd));
 #endif
 
         while (running) {
                 int32_t arg;
 #ifdef _MSC_VER
                 int read, key;
                 HANDLE stdinHandle = GetStdHandle(STD_INPUT_HANDLE);
 #else
                 fd_set rfds, efds;
                 struct timeval tv = { 0, 20000 };
 #endif
 
                 switch_core_session_ctl(SCSC_CHECK_RUNNING, &arg);
                 if (!arg) {
                         break;
                 }
 
                 if (activity) {
                         switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, SWITCH_LOG_CONSOLE, "\nfreeswitch@%s> ", switch_core_get_switchname());
                 }
 #ifdef _MSC_VER
                 activity = 0;
                 if (console_readConsole(stdinHandle, keys, (int) sizeof(keys), &read, &key)) {
                         if (console_bufferInput(keys, read, cmd, key)) {
                                 if (!strcmp(cmd, "Empty")) {
                                         cmd[0] = 0;
                                 }
                                 activity = 1;
                                 if (cmd[0]) {
                                         running = switch_console_process(cmd);
                                 }
                                 memset(cmd, 0, sizeof(cmd));
                         }
                 }
                 Sleep(20);
 #else
                 FD_ZERO(&rfds);
                 FD_ZERO(&efds);
                 FD_SET(fileno(stdin), &rfds);
                 FD_SET(fileno(stdin), &efds);
                 if ((activity = select(fileno(stdin) + 1, &rfds, NULL, &efds, &tv)) < 0) {
                         break;
                 }
 
                 if (FD_ISSET(fileno(stdin), &efds)) {
                         continue;
                 }
 
                 if (!FD_ISSET(fileno(stdin), &rfds)) {
                         activity = 0;
                 }
 
                 if (activity == 0) {
                         fflush(stdout);
                         continue;
                 }
 
                 memset(&cmd, 0, sizeof(cmd));
                 for (x = 0; x < (sizeof(cmd) - 1); x++) {
                         int c = getchar();
                         if (c < 0) {
                                 int y = read(fileno(stdin), cmd, sizeof(cmd) - 1);
                                 cmd[y - 1] = '\0';
                                 break;
                         }
 
                         cmd[x] = (char) c;
 
                         if (cmd[x] == '\n') {
                                 cmd[x] = '\0';
                                 break;
                         }
                 }
 
                 if (cmd[0]) {
                         running = switch_console_process(cmd);
                 }
 #endif
         }
 }

void switch_console_printf	(	switch_text_channel_t	channel,
		const char *	file,
		const char *	func,
		int	line,
		const char *	fmt,
			...
	)

Definition at line 401 of file switch_console.c.

References SWITCH_CHANNEL_ID_EVENT, SWITCH_CHANNEL_ID_LOG, SWITCH_CHANNEL_ID_LOG_CLEAN, switch_core_data_channel(), switch_cut_path(), switch_event_add_header(), switch_event_add_header_string(), switch_event_create, switch_event_fire, SWITCH_EVENT_LOG, switch_event_running(), switch_micro_time_now(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, switch_strftime_nocheck(), switch_time_exp_lt(), and switch_vasprintf().

 {
         char *data = NULL;
         int ret = 0;
         va_list ap;
         FILE *handle = switch_core_data_channel(channel);
         const char *filep = switch_cut_path(file);
         char date[80] = "";
         switch_size_t retsize;
         switch_time_exp_t tm;
         switch_event_t *event;
 
         va_start(ap, fmt);
         ret = switch_vasprintf(&data, fmt, ap);
         va_end(ap);
 
         if (ret == -1) {
                 fprintf(stderr, "Memory Error\n");
                 goto done;
         }
 
         if (channel == SWITCH_CHANNEL_ID_LOG_CLEAN) {
                 fprintf(handle, "%s", data);
                 goto done;
         }
 
         switch_time_exp_lt(&tm, switch_micro_time_now());
         switch_strftime_nocheck(date, &retsize, sizeof(date), "%Y-%m-%d %T", &tm);
 
         if (channel == SWITCH_CHANNEL_ID_LOG) {
                 fprintf(handle, "[%d] %s %s:%d %s() %s", (int) getpid(), date, filep, line, func, data);
                 goto done;
         }
 
         if (channel == SWITCH_CHANNEL_ID_EVENT &&
                 switch_event_running() == SWITCH_STATUS_SUCCESS && switch_event_create(&event, SWITCH_EVENT_LOG) == SWITCH_STATUS_SUCCESS) {
 
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Log-Data", data);
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Log-File", filep);
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Log-Function", func);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Log-Line", "%d", line);
                 switch_event_fire(&event);
         }
 
   done:
         if (data) {
                 free(data);
         }
         fflush(handle);
 }

static int switch_console_process ( char * xcmd )

static

Definition at line 313 of file switch_console.c.

References switch_stream_handle::data, switch_assert, switch_console_execute(), switch_core_get_console(), switch_safe_free, SWITCH_STANDARD_STREAM, and SWITCH_STATUS_SUCCESS.

Referenced by switch_console_loop().

 {
         switch_stream_handle_t stream = { 0 };
         switch_status_t status;
         FILE *handle = switch_core_get_console();
         int r = 1;
 
         SWITCH_STANDARD_STREAM(stream);
         switch_assert(stream.data);
 
         status = switch_console_execute(xcmd, 0, &stream);
 
         if (status == SWITCH_STATUS_SUCCESS) {
                 if (handle) {
                         fprintf(handle, "\n%s\n", (char *) stream.data);
                         fflush(handle);
                 }
         } else {
                 if (!strcasecmp(xcmd, "...") || !strcasecmp(xcmd, "shutdown")) {
                         r = 0;
                 }
                 if (handle) {
                         fprintf(handle, "Unknown Command: %s\n", xcmd);
                         fflush(handle);
                 }
         }
 
         switch_safe_free(stream.data);
 
         return r;
 
 }

void switch_console_push_match	(	switch_console_callback_match_t **	matches,
		const char *	new_val
	)

Definition at line 1791 of file switch_console.c.

References switch_zmalloc, and switch_console_callback_match_node::val.

Referenced by modulename_callback(), switch_console_push_match_unique(), switch_core_session_findall(), switch_core_session_findall_matching_var(), switch_event_get_custom_events(), and uuid_callback().

 {
         switch_console_callback_match_node_t *match;
 
         if (!*matches) {
                 switch_zmalloc(*matches, sizeof(**matches));
                 (*matches)->dynamic = 1;
         }
 
         switch_zmalloc(match, sizeof(*match));
         match->val = strdup(new_val);
 
         if ((*matches)->head) {
                 (*matches)->end->next = match;
         } else {
                 (*matches)->head = match;
         }
 
         (*matches)->count++;
 
         (*matches)->end = match;
 }

void switch_console_push_match_unique	(	switch_console_callback_match_t **	matches,
		const char *	new_val
	)

Definition at line 1777 of file switch_console.c.

References switch_console_callback_match_node::next, switch_console_push_match(), and switch_console_callback_match_node::val.

 {
         /* Ignore the entry if it is already in the list */
         if (*matches) {
                 switch_console_callback_match_node_t *node;
 
                 for(node = (*matches)->head; node; node = node->next) {
                         if (!strcasecmp(node->val, new_val)) return;
                 }
         }
 
         switch_console_push_match(matches, new_val);
 }

switch_status_t switch_console_run_complete_func	(	const char *	func,
		const char *	line,
		const char *	last_word,
		switch_console_callback_match_t **	matches
	)

Definition at line 1814 of file switch_console.c.

References globals, switch_console_sort_matches(), switch_core_hash_find(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by comp_callback().

 {
         switch_console_complete_callback_t cb;
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         switch_mutex_lock(globals.func_mutex);
         if ((cb = (switch_console_complete_callback_t) (intptr_t) switch_core_hash_find(globals.func_hash, func))) {
                 if ((status = cb(line, last_word, matches)) == SWITCH_STATUS_SUCCESS) {
                         switch_console_sort_matches(*matches);
                 }
         }
         switch_mutex_unlock(globals.func_mutex);
 
         return status;
 }

void switch_console_save_history ( void )

Definition at line 972 of file switch_console.c.

References SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, and switch_log_printf().

Referenced by switch_core_session_ctl().

 {
 #ifdef HAVE_LIBEDIT
         history(myhistory, &ev, H_SAVE, hfile);
 #else
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "NOT IMPLEMENTED!\n");
 #endif
 }

switch_status_t switch_console_shutdown ( void )

Definition at line 1671 of file switch_console.c.

References globals, and switch_core_hash_destroy().

Referenced by switch_core_destroy().

 {
         return switch_core_hash_destroy(&globals.func_hash);
 }

void switch_console_sort_matches ( switch_console_callback_match_t * matches )

Definition at line 1719 of file switch_console.c.

References if(), switch_console_callback_match_node::next, and switch_assert.

Referenced by switch_console_run_complete_func().

 {
         switch_console_callback_match_node_t *p = NULL, *sort[4] = { 0 };
         int i, j;
 
         switch_assert(matches);
 
         if (matches->count < 2) {
                 return;
         }
 
         for (i = 1; i < matches->count; i++) {
                 sort[0] = NULL;
                 sort[1] = matches->head;
                 sort[2] = sort[1] ? sort[1]->next : NULL;
                 sort[3] = sort[2] ? sort[2]->next : NULL;
 
                 for (j = 1; j <= (matches->count - i); j++) {
                         switch_assert(sort[1] && sort[2]);
                         if (strcmp(sort[1]->val, sort[2]->val) > 0) {
                                 sort[1]->next = sort[3];
                                 sort[2]->next = sort[1];
 
                                 if (sort[0])
                                         sort[0]->next = sort[2];
                                 if (sort[1] == matches->head)
                                         matches->head = sort[2];
 
 
 
 
                                 sort[0] = sort[2];
                                 sort[2] = sort[1]->next;
                                 if (sort[3] && sort[3]->next)
                                         sort[3] = sort[3]->next;
 
                         } else {
                                 sort[0] = sort[1];
                                 sort[1] = sort[2];
                                 sort[2] = sort[3];
                                 if (sort[3] && sort[3]->next)
                                         sort[3] = sort[3]->next;
                         }
 
                 }
         }
 
         p = matches->head;
 
         for (i = 1; i < matches->count; i++)
                 p = p->next;
 
         if (p) {
                 p->next = NULL;
                 matches->end = p;
         }
 }

switch_status_t switch_console_stream_raw_write	(	switch_stream_handle_t *	handle,
		uint8_t *	data,
		switch_size_t	datalen
	)

Definition at line 126 of file switch_console.c.

References SWITCH_STATUS_MEMERR, and SWITCH_STATUS_SUCCESS.

 {
         switch_size_t need = handle->data_len + datalen;
 
         if (need >= handle->data_size) {
                 void *new_data;
                 need += handle->alloc_chunk;
 
                 if (!(new_data = realloc(handle->data, need))) {
                         return SWITCH_STATUS_MEMERR;
                 }
 
                 handle->data = new_data;
                 handle->data_size = need;
         }
 
         memcpy((uint8_t *) (handle->data) + handle->data_len, data, datalen);
         handle->data_len += datalen;
         handle->end = (uint8_t *) (handle->data) + handle->data_len;
         *(uint8_t *) handle->end = '\0';
 
         return SWITCH_STATUS_SUCCESS;
 }

switch_status_t switch_console_stream_write	(	switch_stream_handle_t *	handle,
		const char *	fmt,
			...
	)

Definition at line 150 of file switch_console.c.

References buf, SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, switch_log_printf(), switch_snprintf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_vmprintf().

 {
         va_list ap;
         char *buf = handle->data;
         char *end = handle->end;
         int ret = 0;
         char *data = NULL;
 
         if (handle->data_len >= handle->data_size) {
                 return SWITCH_STATUS_FALSE;
         }
 
         va_start(ap, fmt);
         //ret = switch_vasprintf(&data, fmt, ap);
         if (!(data = switch_vmprintf(fmt, ap))) {
                 ret = -1;
         }
         va_end(ap);
 
         if (data) {
                 switch_size_t remaining = handle->data_size - handle->data_len;
                 switch_size_t need = strlen(data) + 1;
 
                 if ((remaining < need) && handle->alloc_len) {
                         switch_size_t new_len;
                         void *new_data;
 
                         new_len = handle->data_size + need + handle->alloc_chunk;
                         if ((new_data = realloc(handle->data, new_len))) {
                                 handle->data_size = handle->alloc_len = new_len;
                                 handle->data = new_data;
                                 buf = handle->data;
                                 remaining = handle->data_size - handle->data_len;
                                 handle->end = (uint8_t *) (handle->data) + handle->data_len;
                                 end = handle->end;
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
                                 free(data);
                                 return SWITCH_STATUS_FALSE;
                         }
                 }
 
                 if (remaining < need) {
                         ret = -1;
                 } else {
                         ret = 0;
                         switch_snprintf(end, remaining, "%s", data);
                         handle->data_len = strlen(buf);
                         handle->end = (uint8_t *) (handle->data) + handle->data_len;
                 }
                 free(data);
         }
 
         return ret ? SWITCH_STATUS_FALSE : SWITCH_STATUS_SUCCESS;
 }

switch_status_t switch_stream_write_file_contents	(	switch_stream_handle_t *	stream,
		const char *	path
	)

Definition at line 206 of file switch_console.c.

References switch_directories::conf_dir, switch_fp_read_dline(), SWITCH_GLOBAL_dirs, switch_is_file_path(), switch_mprintf(), SWITCH_PATH_SEPARATOR, switch_safe_free, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         char *dpath = NULL;
         FILE *fd = NULL;
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         if (!switch_is_file_path(path)) {
                 dpath = switch_mprintf("%s%s%s", SWITCH_GLOBAL_dirs.conf_dir, SWITCH_PATH_SEPARATOR, path);
                 path = dpath;
         }
 
         if ((fd = fopen(path, "r"))) {
                 char *line_buf = NULL;
                 switch_size_t llen = 0;
 
                 while (switch_fp_read_dline(fd, &line_buf, &llen)) {
                         stream->write_function(stream, "%s", line_buf);
                 }
                 fclose(fd);
                 switch_safe_free(line_buf);
                 status = SWITCH_STATUS_SUCCESS;
         }
 
         switch_safe_free(dpath);
         return status;
 }

static int uuid_callback	(	void *	pArg,
		int	argc,
		char **	argv,
		char **	columnNames
	)

static

Definition at line 654 of file switch_console.c.

References match_helper::my_matches, and switch_console_push_match().

Referenced by switch_console_list_uuid().

 {
         struct match_helper *h = (struct match_helper *) pArg;
 
         switch_console_push_match(&h->my_matches, argv[0]);
         return 0;
 
 }