switch_console.h File Reference

Simple Console. More...

#include <switch.h>

Include dependency graph for switch_console.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	SWITCH_CMD_CHUNK_LEN   1024
#define	SWITCH_STANDARD_STREAM(s)

Functions
void	switch_console_loop (void)
	A simple comand loop that reads input from the terminal. More...
void	switch_console_printf (switch_text_channel_t channel, const char *file, const char *func, int line, const char *fmt,...) PRINTF_FUNCTION(5
	A method akin to printf that allows you to redirect output to a specific console "channel". More...
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,...) PRINTF_FUNCTION(2
	A method akin to printf for dealing with api streams. More...
switch_status_t switch_status_t	switch_stream_write_file_contents (switch_stream_handle_t *stream, const char *path)
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)
switch_status_t	switch_console_run_complete_func (const char *func, const char *line, const char *last_word, 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)
void	switch_console_free_matches (switch_console_callback_match_t **matches)
unsigned char	switch_console_complete (const char *line, const char *last_word, FILE *console_out, switch_stream_handle_t *stream, switch_xml_t xml)
void	switch_console_sort_matches (switch_console_callback_match_t *matches)
void	switch_console_save_history (void)
char *	switch_console_expand_alias (char *cmd, char *arg)
switch_status_t	switch_console_execute (char *xcmd, int rec, switch_stream_handle_t *istream)

Detailed Description

Simple Console.

This module implements a basic console i/o and by basic I mean, um yeah, basic Right now the primary function of this portion of the program is to keep it from exiting.

Definition in file switch_console.h.

Macro Definition Documentation

SWITCH_CMD_CHUNK_LEN

#define SWITCH_CMD_CHUNK_LEN   1024

Definition at line 45 of file switch_console.h.

SWITCH_STANDARD_STREAM

#define SWITCH_STANDARD_STREAM

(

s

)

Value:

memset(&s, 0, sizeof(s)); s.data = malloc(SWITCH_CMD_CHUNK_LEN); \
        switch_assert(s.data);                                                                                          \
        memset(s.data, 0, SWITCH_CMD_CHUNK_LEN);                                                        \
        s.end = s.data;                                                                                                         \
        s.data_size = SWITCH_CMD_CHUNK_LEN;                                                                     \
        s.write_function = switch_console_stream_write;                                         \
        s.raw_write_function = switch_console_stream_raw_write;                         \
        s.alloc_len = SWITCH_CMD_CHUNK_LEN;                                                                     \
        s.alloc_chunk = SWITCH_CMD_CHUNK_LEN

Definition at line 46 of file switch_console.h.

Referenced by api_hook(), do_api_on(), API::execute(), API::executeString(), parse_presence_data_cols(), preprocess_exec_set(), record_helper_post_process(), Stream::Stream(), switch_channel_build_param_string(), switch_channel_expand_variables_check(), switch_channel_get_cap_string(), switch_channel_get_flag_string(), switch_channel_set_timestamps(), switch_console_complete(), switch_console_process(), switch_console_set_complete(), switch_core_init_and_modload(), switch_core_perform_file_open(), switch_event_build_param_string(), switch_event_expand_headers_check(), switch_html_strip(), switch_ivr_parse_event(), switch_ivr_record_file_event(), switch_nat_republish(), switch_nat_status(), and switch_say_file_handle_create().

Function Documentation

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 *	last_word,
		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_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,
			...
	)

A method akin to printf that allows you to redirect output to a specific console "channel".

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

void 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,
			...
	)

A method akin to printf for dealing with api streams.

switch_stream_write_file_contents()

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