switch_console.c File Reference

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

Include dependency graph for switch_console.c:

Go to the source code of this file.

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

CC_ARGHACK

#define CC_ARGHACK   3

Definition at line 53 of file switch_console.c.

CC_CURSOR

#define CC_CURSOR   5

Definition at line 55 of file switch_console.c.

CC_EOF

#define CC_EOF   2

Definition at line 52 of file switch_console.c.

CC_ERROR

#define CC_ERROR   6

Definition at line 56 of file switch_console.c.

Referenced by switch_console_complete().

CC_FATAL

#define CC_FATAL   7

Definition at line 57 of file switch_console.c.

CC_NEWLINE

#define CC_NEWLINE   1

Definition at line 51 of file switch_console.c.

CC_NORM

#define CC_NORM   0

Definition at line 50 of file switch_console.c.

CC_REDISPLAY

#define CC_REDISPLAY   8

Definition at line 58 of file switch_console.c.

Referenced by switch_console_complete().

CC_REFRESH

#define CC_REFRESH   4

Definition at line 54 of file switch_console.c.

CC_REFRESH_BEEP

#define CC_REFRESH_BEEP   9

Definition at line 59 of file switch_console.c.

CMD_BUFLEN

#define CMD_BUFLEN   1024

Definition at line 38 of file switch_console.c.

Referenced by switch_console_loop(), and switch_console_save_history().

Function Documentation

alias_callback()

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

static

Definition at line 231 of file switch_console.c.

Referenced by switch_console_expand_alias().

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

comp_callback()

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

static

Definition at line 468 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(), target, 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;
}

console_xml_config()

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(), and switch_console_save_history().

{
        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;
}

modulename_callback()

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

static

Definition at line 586 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_console_add_complete_func()

switch_status_t switch_console_add_complete_func	(	const char *	name,
		switch_console_complete_callback_t	cb
	)

Definition at line 1679 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;
}

switch_console_complete()

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 701 of file switch_console.c.

References buf, CC_ERROR, CC_REDISPLAY, comp_callback(), console_fnkeys, 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_CHANNEL_LOG_CLEAN, switch_console_process(), switch_core_db_handle, switch_core_get_hostname(), SWITCH_LOG_CONSOLE, 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.

Referenced by switch_console_save_history().

{
        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");
                switch_safe_free(dup);
                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='%q') %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++) {
                        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_console_del_complete_func()

switch_status_t switch_console_del_complete_func

(

const char *

name

)

Definition at line 1690 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_console_execute()

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

Definition at line 345 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(), SWITCH_STATUS_FALSE, and switch_stream_handle::write_function.

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 = NULL;
        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;
        }

        while (*xcmd == ' ') xcmd++;

        dup = strdup(xcmd);

        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;
}

switch_console_expand_alias()

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

Definition at line 238 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;
}

switch_console_free_matches()

void switch_console_free_matches

(

switch_console_callback_match_t **

matches

)

Definition at line 1701 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_console_init()

switch_status_t switch_console_init

(

switch_memory_pool_t *

pool

)

Definition at line 1663 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_console_list_available_modules()

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

Definition at line 594 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_console_list_interfaces()

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

Definition at line 650 of file switch_console.c.

References SWITCH_STATUS_FALSE.

Referenced by switch_console_init(), and switch_console_list_loaded_modules().

{
        return SWITCH_STATUS_FALSE;
}

switch_console_list_loaded_modules()

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

Definition at line 610 of file switch_console.c.

References modulename_callback(), match_helper::my_matches, switch_console_list_interfaces(), switch_console_push_match_unique(), SWITCH_DECLARE_NONSTD, 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_console_list_uuid()

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

Definition at line 665 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;
}

switch_console_loop()

void switch_console_loop

(

void

)

A simple comand loop that reads input from the terminal.

Definition at line 1555 of file switch_console.c.

References CMD_BUFLEN, console_xml_config(), key, 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(), switch_console_save_history(), 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
        }
}

switch_console_printf()

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

Definition at line 403 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);
}

switch_console_process()

static int switch_console_process ( char *  xcmd )

static

Definition at line 311 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_complete(), switch_console_loop(), and switch_console_save_history().

{
        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;

}

switch_console_push_match()

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

Definition at line 1794 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;
}

switch_console_push_match_unique()

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

Definition at line 1780 of file switch_console.c.

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

Referenced by switch_console_list_loaded_modules().

{
        /* 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_console_run_complete_func()

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 1817 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;
}

switch_console_save_history()

void switch_console_save_history

(

void

)

Definition at line 975 of file switch_console.c.

References buf, CMD_BUFLEN, console_xml_config(), count, FALSE, if(), key, helper::len, switch_directories::log_dir, memset(), pool, running, SCSC_CHECK_RUNNING, SWITCH_CHANNEL_LOG, switch_cond_next(), switch_console_complete(), switch_console_loop(), switch_console_process(), switch_core_destroy_memory_pool, switch_core_get_console(), switch_core_get_switchname(), switch_core_new_memory_pool, switch_core_session_ctl(), SWITCH_DECLARE, SWITCH_GLOBAL_dirs, SWITCH_LOG_CONSOLE, SWITCH_LOG_CRIT, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_LOG_WARNING, switch_mprintf(), SWITCH_PATH_SEPARATOR, switch_snprintf(), SWITCH_STATUS_SUCCESS, switch_thread_create(), SWITCH_THREAD_FUNC, SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_detach_set(), switch_threadattr_stacksize_set(), switch_yield, thread, TRUE, and zstr.

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_console_shutdown()

switch_status_t switch_console_shutdown

(

void

)

Definition at line 1674 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);
}

switch_console_sort_matches()

void switch_console_sort_matches

(

switch_console_callback_match_t *

matches

)

Definition at line 1722 of file switch_console.c.

References switch_console_callback_match::count, switch_console_callback_match::end, switch_console_callback_match::head, 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_console_stream_raw_write()

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_stream_handle::alloc_chunk, switch_stream_handle::data, switch_stream_handle::data_len, switch_stream_handle::data_size, switch_stream_handle::end, 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_console_stream_write()

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 switch_stream_handle::alloc_chunk, switch_stream_handle::alloc_len, switch_stream_handle::data, switch_stream_handle::data_len, switch_stream_handle::data_size, switch_stream_handle::end, SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, switch_log_printf(), switch_snprintf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_vmprintf().

{
        va_list ap;
        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;
                                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(data);
                        handle->end = (uint8_t *) (handle->data) + handle->data_len;
                }
                free(data);
        }

        return ret ? SWITCH_STATUS_FALSE : SWITCH_STATUS_SUCCESS;
}

switch_stream_write_file_contents()

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

Definition at line 204 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, SWITCH_STATUS_SUCCESS, and switch_stream_handle::write_function.

{
        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;
}

uuid_callback()

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

static

Definition at line 656 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;

}

Variable Documentation

console_fnkeys

char* console_fnkeys[12]

static

Definition at line 82 of file switch_console.c.

Referenced by console_xml_config(), and switch_console_complete().

func_hash

switch_hash_t* func_hash

Definition at line 1659 of file switch_console.c.

func_mutex

switch_mutex_t* func_mutex

Definition at line 1660 of file switch_console.c.

globals

struct { ... } globals

Referenced by switch_console_add_complete_func(), switch_console_del_complete_func(), switch_console_init(), switch_console_run_complete_func(), and switch_console_shutdown().

running

int32_t running = 1

static

Definition at line 454 of file switch_console.c.

Referenced by switch_cache_db_execute_sql2str(), switch_console_loop(), switch_console_save_history(), switch_ivr_enterprise_originate(), and switch_ivr_menu_execute().