switch_xml.c File Reference

#include <switch.h>
#include <switch_stun.h>
#include <sys/wait.h>
#include <switch_private.h>
#include <glob.h>

Include dependency graph for switch_xml.c:

Go to the source code of this file.

Data Structures
struct	switch_xml_root
struct	switch_xml_binding
struct	xml_section_t
struct	destroy_xml

Macros
#define	SWITCH_XML_WS   "\t\r\n " /* whitespace */
#define	SWITCH_XML_ERRL   128 /* maximum error string length */
#define	XML_INDENT   " "

Typedefs
typedef struct switch_xml_root *	switch_xml_root_t

Functions
static void	preprocess_exec_set (char *keyval)
static void	preprocess_stun_set (char *keyval)
static void	preprocess_env_set (char *keyval)
static int	preprocess (const char *cwd, const char *file, FILE *write_fd, int rlevel)
switch_xml_t	__switch_xml_open_root (uint8_t reload, const char **err, void *user_data)
switch_xml_section_t	switch_xml_parse_section_string (const char *str)
switch_status_t	switch_xml_unbind_search_function (switch_xml_binding_t **binding)
switch_status_t	switch_xml_unbind_search_function_ptr (switch_xml_search_function_t function)
void	switch_xml_set_binding_sections (switch_xml_binding_t *binding, switch_xml_section_t sections)
void	switch_xml_set_binding_user_data (switch_xml_binding_t *binding, void *user_data)
switch_xml_section_t	switch_xml_get_binding_sections (switch_xml_binding_t *binding)
void *	switch_xml_get_binding_user_data (switch_xml_binding_t *binding)
switch_status_t	switch_xml_bind_search_function_ret (switch_xml_search_function_t function, switch_xml_section_t sections, void *user_data, switch_xml_binding_t **ret_binding)
switch_xml_t	switch_xml_find_child (switch_xml_t node, const char *childname, const char *attrname, const char *value)
switch_xml_t	switch_xml_find_child_multi (switch_xml_t node, const char *childname,...)
switch_xml_t	switch_xml_child (switch_xml_t xml, const char *name)
switch_xml_t	switch_xml_idx (switch_xml_t xml, int idx)
const char *	switch_xml_attr_soft (switch_xml_t xml, const char *attr)
const char *	switch_xml_attr (switch_xml_t xml, const char *attr)
static switch_xml_t	switch_xml_vget (switch_xml_t xml, va_list ap)
switch_xml_t	switch_xml_get (switch_xml_t xml,...)
const char **	switch_xml_pi (switch_xml_t xml, const char *target)
static switch_xml_t	switch_xml_err (switch_xml_root_t root, char *s, const char *err,...)
static char *	switch_xml_decode (char *s, char **ent, char t)
static void	switch_xml_open_tag (switch_xml_root_t root, char *name, char *open_pos, char **attr)
static void	switch_xml_char_content (switch_xml_root_t root, char *s, switch_size_t len, char t)
static switch_xml_t	switch_xml_close_tag (switch_xml_root_t root, char *name, char *s, char *close_pos)
static int	switch_xml_ent_ok (char *name, char *s, char **ent)
static void	switch_xml_proc_inst (switch_xml_root_t root, char *s, switch_size_t len)
static short	switch_xml_internal_dtd (switch_xml_root_t root, char *s, switch_size_t len)
static char *	switch_xml_str2utf8 (char **s, switch_size_t *len)
static void	switch_xml_free_attr (char **attr)
switch_xml_t	switch_xml_parse_str_dynamic (char *s, switch_bool_t dup)
switch_xml_t	switch_xml_parse_str (char *s, switch_size_t len)
switch_xml_t	switch_xml_parse_fp (FILE *fp)
switch_xml_t	switch_xml_parse_fd (int fd)
	A wrapper for switch_xml_parse_str() that accepts a file descriptor. First \ attempts to mem map the file. Failing that, reads the file into memory. \ Returns NULL on failure. More...
static char *	expand_vars (char *buf, char *ebuf, switch_size_t elen, switch_size_t *newlen, const char **err)
static FILE *	preprocess_exec (const char *cwd, const char *command, FILE *write_fd, int rlevel)
static FILE *	preprocess_glob (const char *cwd, const char *pattern, FILE *write_fd, int rlevel)
switch_xml_t	switch_xml_parse_file_simple (const char *file)
switch_xml_t	switch_xml_parse_file (const char *file)
switch_status_t	switch_xml_locate (const char *section, const char *tag_name, const char *key_name, const char *key_value, switch_xml_t *root, switch_xml_t *node, switch_event_t *params, switch_bool_t clone)
switch_status_t	switch_xml_locate_domain (const char *domain_name, switch_event_t *params, switch_xml_t *root, switch_xml_t *domain)
switch_status_t	switch_xml_locate_group (const char *group_name, const char *domain_name, switch_xml_t *root, switch_xml_t *domain, switch_xml_t *group, switch_event_t *params)
static switch_status_t	find_user_in_tag (switch_xml_t tag, const char *ip, const char *user_name, const char *key, switch_event_t *params, switch_xml_t *user)
switch_status_t	switch_xml_locate_user_in_domain (const char *user_name, switch_xml_t domain, switch_xml_t *user, switch_xml_t *ingroup)
switch_xml_t	switch_xml_dup (switch_xml_t xml)
static void	do_merge (switch_xml_t in, switch_xml_t src, const char *container, const char *tag_name)
void	switch_xml_merge_user (switch_xml_t user, switch_xml_t domain, switch_xml_t group)
uint32_t	switch_xml_clear_user_cache (const char *key, const char *user_name, const char *domain_name)
static switch_status_t	switch_xml_locate_user_cache (const char *key, const char *user_name, const char *domain_name, switch_xml_t *user)
static void	switch_xml_user_cache (const char *key, const char *user_name, const char *domain_name, switch_xml_t user, switch_time_t expires)
switch_status_t	switch_xml_locate_user_merged (const char *key, const char *user_name, const char *domain_name, const char *ip, switch_xml_t *user, switch_event_t *params)
switch_status_t	switch_xml_locate_user (const char *key, const char *user_name, const char *domain_name, const char *ip, switch_xml_t *root, switch_xml_t *domain, switch_xml_t *user, switch_xml_t *ingroup, switch_event_t *params)
switch_xml_t	switch_xml_root (void)
	retrieve the core XML root node More...
static void *SWITCH_THREAD_FUNC	destroy_thread (switch_thread_t *thread, void *obj)
void	switch_xml_free_in_thread (switch_xml_t xml, int stacksize)
switch_status_t	switch_xml_set_root (switch_xml_t new_main)
	set new core xml root More...
switch_status_t	switch_xml_set_open_root_function (switch_xml_open_root_function_t func, void *user_data)
	Set and alternate function for opening xml root. More...
switch_xml_t	switch_xml_open_root (uint8_t reload, const char **err)
switch_status_t	switch_xml_reload (const char **err)
switch_status_t	switch_xml_init (switch_memory_pool_t *pool, const char **err)
switch_status_t	switch_xml_destroy (void)
switch_xml_t	switch_xml_open_cfg (const char *file_path, switch_xml_t *node, switch_event_t *params)
static char *	switch_xml_ampencode (const char *s, switch_size_t len, char **dst, switch_size_t *dlen, switch_size_t *max, short a, switch_bool_t use_utf8_encoding)
static char *	switch_xml_toxml_r (switch_xml_t xml, char **s, switch_size_t *len, switch_size_t *max, switch_size_t start, char ***attr, uint32_t *count, int isroot, switch_bool_t use_utf8_encoding)
char *	switch_xml_toxml_nolock_ex (switch_xml_t xml, switch_bool_t prn_header, switch_bool_t use_utf8_encoding)
char *	switch_xml_toxml_ex (switch_xml_t xml, switch_bool_t prn_header, switch_bool_t use_utf8_encoding)
char *	switch_xml_tohtml_ex (switch_xml_t xml, switch_bool_t prn_header, switch_bool_t use_utf8_encoding)
char *	switch_xml_toxml_buf_ex (switch_xml_t xml, char *buf, switch_size_t buflen, switch_size_t offset, switch_bool_t prn_header, switch_bool_t use_utf8_encoding)
void	switch_xml_free (switch_xml_t xml)
const char *	switch_xml_error (switch_xml_t xml)
switch_xml_t	switch_xml_new (const char *name)
switch_xml_t	switch_xml_insert (switch_xml_t xml, switch_xml_t dest, switch_size_t off)
switch_xml_t	switch_xml_add_child (switch_xml_t xml, const char *name, switch_size_t off)
switch_xml_t	switch_xml_add_child_d (switch_xml_t xml, const char *name, switch_size_t off)
switch_xml_t	switch_xml_set_txt (switch_xml_t xml, const char *txt)
	sets the character content for the given tag and returns the tag More...
switch_xml_t	switch_xml_set_txt_d (switch_xml_t xml, const char *txt)
	wrapper for switch_xml_set_txt() that strdup()s txt \ sets the character content for the given tag and returns the tag More...
switch_xml_t	switch_xml_set_attr (switch_xml_t xml, const char *name, const char *value)
	Sets the given tag attribute or adds a new attribute if not found. A value \ of NULL will remove the specified attribute. More...
switch_xml_t	switch_xml_set_attr_d (switch_xml_t xml, const char *name, const char *value)
	Wrapper for switch_xml_set_attr() that strdup()s name/value. Value cannot be NULL. More...
switch_xml_t	switch_xml_set_attr_d_buf (switch_xml_t xml, const char *name, const char *value)
	Wrapper for switch_xml_set_attr() that strdup()s name/value. Value cannot be NULL. More...
switch_xml_t	switch_xml_set_flag (switch_xml_t xml, switch_xml_flag_t flag)
	sets a flag for the given tag and returns the tag More...
switch_xml_t	switch_xml_cut (switch_xml_t xml)
int	switch_xml_std_datetime_check (switch_xml_t xcond, int *offset, const char *tzname)
switch_status_t	switch_xml_locate_language_ex (switch_xml_t *root, switch_xml_t *node, switch_event_t *params, switch_xml_t *language, switch_xml_t *phrases, switch_xml_t *macros, const char *str_language)
switch_status_t	switch_xml_locate_language (switch_xml_t *root, switch_xml_t *node, switch_event_t *params, switch_xml_t *language, switch_xml_t *phrases, switch_xml_t *macros, const char *str_language)

Variables
char *	SWITCH_XML_NIL [] = { NULL }
static switch_xml_binding_t *	BINDINGS = NULL
static switch_xml_t	MAIN_XML_ROOT = NULL
static switch_memory_pool_t *	XML_MEMORY_POOL = NULL
static switch_thread_rwlock_t *	B_RWLOCK = NULL
static switch_mutex_t *	XML_LOCK = NULL
static switch_mutex_t *	CACHE_MUTEX = NULL
static switch_mutex_t *	REFLOCK = NULL
static switch_mutex_t *	FILE_LOCK = NULL
static switch_xml_open_root_function_t	XML_OPEN_ROOT_FUNCTION = (switch_xml_open_root_function_t)__switch_xml_open_root
static void *	XML_OPEN_ROOT_FUNCTION_USER_DATA = NULL
static switch_hash_t *	CACHE_HASH = NULL
static switch_hash_t *	CACHE_EXPIRES_HASH = NULL
static struct xml_section_t	SECTIONS []
static char	not_so_threadsafe_error_buffer [256] = ""

Macro Definition Documentation

SWITCH_XML_ERRL

#define SWITCH_XML_ERRL   128 /* maximum error string length */

Definition at line 104 of file switch_xml.c.

Referenced by switch_xml_err().

SWITCH_XML_WS

#define SWITCH_XML_WS   "\t\r\n " /* whitespace */

Definition at line 103 of file switch_xml.c.

Referenced by switch_xml_internal_dtd(), switch_xml_parse_str(), and switch_xml_proc_inst().

XML_INDENT

#define XML_INDENT   " "

Definition at line 2619 of file switch_xml.c.

Referenced by switch_xml_toxml_r().

Typedef Documentation

switch_xml_root_t

typedef struct switch_xml_root* switch_xml_root_t

Definition at line 202 of file switch_xml.c.

Function Documentation

__switch_xml_open_root()

switch_xml_t __switch_xml_open_root	(	uint8_t	reload,
		const char **	err,
		void *	user_data
	)

Definition at line 2395 of file switch_xml.c.

References switch_directories::conf_dir, switch_filenames::conf_name, not_so_threadsafe_error_buffer, switch_copy_string(), SWITCH_GLOBAL_dirs, SWITCH_GLOBAL_filenames, SWITCH_PATH_SEPARATOR, switch_snprintf(), switch_xml_error(), switch_xml_free(), switch_xml_parse_file(), switch_xml_root(), switch_xml_set_root(), and zstr.

{
        char path_buf[1024];
        uint8_t errcnt = 0;
        switch_xml_t new_main, r = NULL;

        if (MAIN_XML_ROOT) {
                if (!reload) {
                        r = switch_xml_root();
                        goto done;
                }
        }

        switch_snprintf(path_buf, sizeof(path_buf), "%s%s%s", SWITCH_GLOBAL_dirs.conf_dir, SWITCH_PATH_SEPARATOR, SWITCH_GLOBAL_filenames.conf_name);
        if ((new_main = switch_xml_parse_file(path_buf))) {
                *err = switch_xml_error(new_main);
                switch_copy_string(not_so_threadsafe_error_buffer, *err, sizeof(not_so_threadsafe_error_buffer));
                *err = not_so_threadsafe_error_buffer;
                if (!zstr(*err)) {
                        switch_xml_free(new_main);
                        new_main = NULL;
                        errcnt++;
                } else {
                        *err = "Success";
                        switch_xml_set_root(new_main);

                }
        } else {
                *err = "Cannot Open log directory or XML Root!";
                errcnt++;
        }

        if (errcnt == 0) {
                r = switch_xml_root();
        }

 done:

        return r;
}

destroy_thread()

static void* SWITCH_THREAD_FUNC destroy_thread ( switch_thread_t *  thread, void *  obj  )

static

Definition at line 2298 of file switch_xml.c.

References pool, destroy_xml::pool, switch_core_destroy_memory_pool, switch_xml_free(), and destroy_xml::xml.

Referenced by switch_xml_free_in_thread().

{
        struct destroy_xml *dx = (struct destroy_xml *) obj;
        switch_memory_pool_t *pool = dx->pool;
        switch_xml_free(dx->xml);
        switch_core_destroy_memory_pool(&pool);
        return NULL;
}

do_merge()

static void do_merge ( switch_xml_t  in, switch_xml_t  src, const char *  container, const char *  tag_name  )

static

Definition at line 1977 of file switch_xml.c.

References switch_xml::next, SWITCH_FALSE, SWITCH_TRUE, switch_xml_add_child_d(), switch_xml_attr(), switch_xml_child(), and switch_xml_set_attr_d().

Referenced by switch_xml_merge_user().

{
        switch_xml_t itag, tag, param, iparam, iitag;

        if (!(itag = switch_xml_child(in, container))) {
                itag = switch_xml_add_child_d(in, container, 0);
        }

        if ((tag = switch_xml_child(src, container))) {
                for (param = switch_xml_child(tag, tag_name); param; param = param->next) {
                        const char *var = switch_xml_attr(param, "name");
                        const char *val = switch_xml_attr(param, "value");

                        switch_bool_t add_child = SWITCH_TRUE;

                        for (iparam = switch_xml_child(itag, tag_name); iparam; iparam = iparam->next) {
                                const char *ivar = switch_xml_attr(iparam, "name");

                                if (var && ivar && !strcasecmp(var, ivar)) {
                                        add_child = SWITCH_FALSE;
                                        break;
                                }
                        }

                        if (add_child) {
                                iitag = switch_xml_add_child_d(itag, tag_name, 0);
                                switch_xml_set_attr_d(iitag, "name", var);
                                switch_xml_set_attr_d(iitag, "value", val);
                        }
                }
        }

}

expand_vars()

static char* expand_vars ( char *  buf, char *  ebuf, switch_size_t  elen, switch_size_t *  newlen, const char **  err  )

static

Definition at line 1269 of file switch_xml.c.

References buf, switch_core_get_variable_dup(), and switch_find_end_paren().

Referenced by preprocess().

{
        char *var, *val;
        char *rp = buf;
        char *wp = ebuf;
        char *ep = ebuf + elen - 1;

        if (!strstr(rp, "$${")) {
                *newlen = strlen(buf);
                return buf;
        }

        while (*rp && wp < ep) {

                if (*rp == '$' && *(rp + 1) == '$' && *(rp + 2) == '{') {
                        char *e = switch_find_end_paren(rp + 2, '{', '}');

                        if (e) {
                                rp += 3;
                                var = rp;
                                *e++ = '\0';
                                rp = e;
                                if ((val = switch_core_get_variable_dup(var))) {
                                        char *p;
                                        for (p = val; p && *p && wp <= ep; p++) {
                                                *wp++ = *p;
                                        }
                                        free(val);
                                }
                                continue;
                        } else if (err) {
                                *err = "unterminated ${var}";
                        }
                }

                *wp++ = *rp++;
        }

        if (wp == ep) {
                return NULL;
        }

        *wp++ = '\0';
        *newlen = strlen(ebuf);

        return ebuf;
}

find_user_in_tag()

static switch_status_t find_user_in_tag ( switch_xml_t  tag, const char *  ip, const char *  user_name, const char *  key, switch_event_t *  params, switch_xml_t *  user  )

static

Definition at line 1906 of file switch_xml.c.

References switch_event_get_header, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_xml_find_child_multi().

Referenced by switch_xml_locate_user(), and switch_xml_locate_user_in_domain().

{
        const char *type = "!pointer";
        const char *val;

        if (params && (val = switch_event_get_header(params, "user_type"))) {
                if (!strcasecmp(val, "any")) {
                        type = NULL;
                } else {
                        type = val;
                }
        }

        if (ip) {
                if ((*user = switch_xml_find_child_multi(tag, "user", "ip", ip, "type", type, NULL))) {
                        return SWITCH_STATUS_SUCCESS;
                }
        }

        if (user_name) {
                if (!strcasecmp(key, "id")) {
                        if ((*user = switch_xml_find_child_multi(tag, "user", key, user_name, "number-alias", user_name, "type", type, NULL))) {
                                return SWITCH_STATUS_SUCCESS;
                        }
                } else {
                        if ((*user = switch_xml_find_child_multi(tag, "user", key, user_name, "type", type, NULL))) {
                                return SWITCH_STATUS_SUCCESS;
                        }
                }
        }

        return SWITCH_STATUS_FALSE;

}

preprocess()

static int preprocess ( const char *  cwd, const char *  file, FILE *  write_fd, int  rlevel  )

static

Definition at line 1424 of file switch_xml.c.

References buf, cur, expand_vars(), memset(), name, preprocess_env_set(), preprocess_exec(), preprocess_exec_set(), preprocess_glob(), preprocess_stun_set(), SWITCH_CHANNEL_LOG, switch_core_set_variable(), switch_fp_read_dline(), SWITCH_LOG_ERROR, switch_log_printf(), switch_must_malloc(), switch_must_realloc(), switch_safe_free, and switch_stristr().

Referenced by preprocess_env_set(), preprocess_glob(), and switch_xml_parse_file().

{
        FILE *read_fd = NULL;
        switch_size_t cur = 0, ml = 0;
        char *q, *cmd, *buf = NULL, *ebuf = NULL;
        char *tcmd, *targ;
        int line = 0;
        switch_size_t len = 0, eblen = 0;

        if (rlevel > 100) {
                return -1;
        }

        if (!(read_fd = fopen(file, "r"))) {
                const char *reason = strerror(errno);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Couldn't open %s (%s)\n", file, reason);
                return -1;
        }

        setvbuf(read_fd, (char *) NULL, _IOFBF, 65536);

        for(;;) {
                char *arg, *e;
                const char *err = NULL;
                char *bp;

                switch_safe_free(ebuf);

                if ((cur = switch_fp_read_dline(read_fd, &buf, &len)) <= 0) {
                        break;
                }

                eblen = len * 2;
                ebuf = switch_must_malloc(eblen);
                memset(ebuf, 0, eblen);

                while (!(bp = expand_vars(buf, ebuf, eblen, &cur, &err))) {
                        eblen *= 2;
                        ebuf = switch_must_realloc(ebuf, eblen);
                        memset(ebuf, 0, eblen);
                }

                line++;

                if (err) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error [%s] in file %s line %d\n", err, file, line);
                }

                /* we ignore <include> or </include> for the sake of validators as well as <?xml version="1.0"?> type stuff */
                if (strstr(buf, "<include>") || strstr(buf, "</include>") || strstr(buf, "<?")) {
                        continue;
                }

                if (ml) {
                        if ((e = strstr(buf, "-->"))) {
                                ml = 0;
                                bp = e + 3;
                                cur = strlen(bp);
                        } else {
                                continue;
                        }
                }

                if ((tcmd = (char *) switch_stristr("X-pre-process", bp))) {
                        if (*(tcmd - 1) != '<') {
                                continue;
                        }
                        if ((e = strstr(tcmd, "/>"))) {
                                e += 2;
                                *e = '\0';
                                if (fwrite(e, 1, (unsigned) strlen(e), write_fd) != (int) strlen(e)) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Short write!\n");
                                }
                        }

                        if (!(tcmd = (char *) switch_stristr("cmd", tcmd))) {
                                continue;
                        }

                        if (!(tcmd = (char *) switch_stristr("=", tcmd))) {
                                continue;
                        }

                        if (!(tcmd = (char *) switch_stristr("\"", tcmd))) {
                                continue;
                        }

                        tcmd++;


                        if ((e = strchr(tcmd, '"'))) {
                                *e++ = '\0';
                        }

                        if (!(targ = (char *) switch_stristr("data", e))) {
                                continue;
                        }

                        if (!(targ = (char *) switch_stristr("=", targ))) {
                                continue;
                        }

                        if (!(targ = (char *) switch_stristr("\"", targ))) {
                                continue;
                        }

                        targ++;

                        if ((e = strchr(targ, '"'))) {
                                *e++ = '\0';
                        }

                        if (!strcasecmp(tcmd, "set")) {
                                char *name = (char *) targ;
                                char *val = strchr(name, '=');

                                if (val) {
                                        char *ve = val++;
                                        while (*val && *val == ' ') {
                                                val++;
                                        }
                                        *ve-- = '\0';
                                        while (*ve && *ve == ' ') {
                                                *ve-- = '\0';
                                        }
                                }

                                if (val) {
                                        switch_core_set_variable(name, val);
                                }

                        } else if (!strcasecmp(tcmd, "exec-set")) {
                                preprocess_exec_set(targ);
                        } else if (!strcasecmp(tcmd, "stun-set")) {
                                preprocess_stun_set(targ);
                        } else if (!strcasecmp(tcmd, "env-set")) {
                                preprocess_env_set(targ);
                        } else if (!strcasecmp(tcmd, "include")) {
                                preprocess_glob(cwd, targ, write_fd, rlevel + 1);
                        } else if (!strcasecmp(tcmd, "exec")) {
                                preprocess_exec(cwd, targ, write_fd, rlevel + 1);
                        }

                        continue;
                }

                if ((cmd = strstr(bp, "<!--#"))) {
                        if (fwrite(bp, 1, (unsigned) (cmd - bp), write_fd) != (unsigned) (cmd - bp)) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Short write!\n");
                        }
                        if ((e = strstr(cmd, "-->"))) {
                                *e = '\0';
                                e += 3;
                                if (fwrite(e, 1, (unsigned) strlen(e), write_fd) != (int) strlen(e)) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Short write!\n");
                                }
                        } else {
                                ml++;
                        }

                        cmd += 5;
                        if ((e = strchr(cmd, '\r')) || (e = strchr(cmd, '\n'))) {
                                *e = '\0';
                        }

                        if ((arg = strchr(cmd, ' '))) {
                                *arg++ = '\0';
                                if ((q = strchr(arg, '"'))) {
                                        char *qq = q + 1;

                                        if ((qq = strchr(qq, '"'))) {
                                                *qq = '\0';
                                                arg = q + 1;
                                        }
                                }

                                if (!strcasecmp(cmd, "set")) {
                                        char *name = arg;
                                        char *val = strchr(name, '=');

                                        if (val) {
                                                char *ve = val++;
                                                while (*val && *val == ' ') {
                                                        val++;
                                                }
                                                *ve-- = '\0';
                                                while (*ve && *ve == ' ') {
                                                        *ve-- = '\0';
                                                }
                                        }

                                        if (val) {
                                                switch_core_set_variable(name, val);
                                        }

                                } else if (!strcasecmp(cmd, "exec-set")) {
                                        preprocess_exec_set(arg);
                                } else if (!strcasecmp(cmd, "stun-set")) {
                                        preprocess_stun_set(arg);
                                } else if (!strcasecmp(cmd, "include")) {
                                        preprocess_glob(cwd, arg, write_fd, rlevel + 1);
                                } else if (!strcasecmp(cmd, "exec")) {
                                        preprocess_exec(cwd, arg, write_fd, rlevel + 1);
                                }
                        }

                        continue;
                }

                if (fwrite(bp, 1, (unsigned) cur, write_fd) != (int) cur) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Short write!\n");
                }

        }

        switch_safe_free(buf);
        switch_safe_free(ebuf);

        fclose(read_fd);

        return 0;
}

preprocess_env_set()

static void preprocess_env_set ( char *  keyval )

static

Definition at line 182 of file switch_xml.c.

References key, preprocess(), and switch_core_set_variable().

Referenced by preprocess().

{
        char *key = keyval;
        char *val = strchr(keyval, '=');

        if (key && val) {
                *val++ = '\0';

                if (*val++ == '$') {
                        char *data = getenv(val);

                        if (data) {
                                switch_core_set_variable(key, data);
                        }
                }
        }
}

preprocess_exec()

static FILE* preprocess_exec ( const char *  cwd, const char *  command, FILE *  write_fd, int  rlevel  )

static

Definition at line 1317 of file switch_xml.c.

References buf, buffer, SWITCH_CHANNEL_LOG, switch_close_extra_files(), switch_fork(), SWITCH_LOG_ERROR, switch_log_printf(), switch_snprintf(), switch_system(), and SWITCH_TRUE.

Referenced by preprocess().

{
#ifdef WIN32
        FILE *fp = NULL;
        char buffer[1024];

        if (!command || !strlen(command)) goto end;

        if ((fp = _popen(command, "r"))) {
                while (fgets(buffer, sizeof(buffer), fp) != NULL) {
                        if (fwrite(buffer, 1, strlen(buffer), write_fd) <= 0) {
                                        break;
                        }
                }

                if(feof(fp)) {
                        _pclose(fp);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Exec failed to read the pipe of [%s] to the end\n", command);
                }
        } else {
                switch_snprintf(buffer, sizeof(buffer), "<!-- exec can not execute [%s] -->", command);
                fwrite( buffer, 1, strlen(buffer), write_fd);
        }
#else
        int fds[2], pid = 0;

        if (pipe(fds)) {
                goto end;
        } else {                                        /* good to go */
                pid = switch_fork();

                if (pid < 0) {                  /* ok maybe not */
                        close(fds[0]);
                        close(fds[1]);
                        goto end;
                } else if (pid) {               /* parent */
                        char buf[1024] = "";
                        int bytes;
                        close(fds[1]);
                        while ((bytes = read(fds[0], buf, sizeof(buf))) > 0) {
                                if (fwrite(buf, 1, bytes, write_fd) <= 0) {
                                        break;
                                }
                        }
                        close(fds[0]);
                        waitpid(pid, NULL, 0);
                } else {                                /*  child */
                        switch_close_extra_files(fds, 2);
                        close(fds[0]);
                        dup2(fds[1], STDOUT_FILENO);
                        switch_system(command, SWITCH_TRUE);
                        close(fds[1]);
                        exit(0);
                }
        }
#endif
  end:

        return write_fd;

}

preprocess_exec_set()

static void preprocess_exec_set ( char *  keyval )

static

Definition at line 106 of file switch_xml.c.

References switch_stream_handle::data, key, SWITCH_CHANNEL_LOG, switch_core_set_variable(), SWITCH_LOG_ERROR, switch_log_printf(), switch_safe_free, SWITCH_STANDARD_STREAM, switch_stream_system(), and zstr.

Referenced by preprocess().

{
        char *key = keyval;
        char *val = strchr(keyval, '=');

        if (val) {
                char *ve = val++;
                while (*val && *val == ' ') {
                        val++;
                }
                *ve-- = '\0';
                while (*ve && *ve == ' ') {
                        *ve-- = '\0';
                }
        }

        if (key && val) {
                switch_stream_handle_t exec_result = { 0 };
                SWITCH_STANDARD_STREAM(exec_result);
                if (switch_stream_system(val, &exec_result) == 0) {
                        if (!zstr(exec_result.data)) {
                                char *tmp = (char *) exec_result.data;
                                tmp = &tmp[strlen(tmp)-1];
                                while (tmp >= (char *) exec_result.data && ( tmp[0] == ' ' || tmp[0] == '\n') ) {
                                        tmp[0] = '\0'; /* remove trailing spaces and newlines */
                                        tmp--;
                                }
                                switch_core_set_variable(key, exec_result.data);
                        }
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error while executing command: %s\n", val);
                }
                switch_safe_free(exec_result.data);
        }
}

preprocess_glob()

static FILE* preprocess_glob ( const char *  cwd, const char *  pattern, FILE *  write_fd, int  rlevel  )

static

Definition at line 1380 of file switch_xml.c.

References preprocess(), SWITCH_CHANNEL_LOG, switch_is_file_path(), SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), switch_mprintf(), switch_must_strdup(), SWITCH_PATH_SEPARATOR, and switch_safe_free.

Referenced by preprocess().

{
        char *full_path = NULL;
        char *dir_path = NULL, *e = NULL;
        glob_t glob_data;
        size_t n;
        int glob_return;

        if (!switch_is_file_path(pattern)) {
                full_path = switch_mprintf("%s%s%s", cwd, SWITCH_PATH_SEPARATOR, pattern);
                pattern = full_path;
        }

        glob_return = glob(pattern, GLOB_ERR, NULL, &glob_data);
        if (glob_return == GLOB_NOSPACE || glob_return == GLOB_ABORTED) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error including %s\n", pattern);
                goto end;
        } else if (glob_return == GLOB_NOMATCH) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "No files to include at %s\n", pattern);
                goto end;
        }

        for (n = 0; n < glob_data.gl_pathc; ++n) {
                dir_path = switch_must_strdup(glob_data.gl_pathv[n]);

                if ((e = strrchr(dir_path, *SWITCH_PATH_SEPARATOR))) {
                        *e = '\0';
                }
                if (preprocess(dir_path, glob_data.gl_pathv[n], write_fd, rlevel) < 0) {
                        if (rlevel > 100) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error including %s (Maximum recursion limit reached)\n", pattern);
                        }
                }
                free(dir_path);
        }
        globfree(&glob_data);

 end:

        switch_safe_free(full_path);

        return write_fd;
}

preprocess_stun_set()

static void preprocess_stun_set ( char *  keyval )

static

Definition at line 142 of file switch_xml.c.

References key, pool, SWITCH_CHANNEL_LOG, switch_core_destroy_memory_pool, switch_core_new_memory_pool, switch_core_set_variable(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_SUCCESS, switch_stun_ip_lookup(), and zstr.

Referenced by preprocess().

{
        char *key = keyval;
        char *val = strchr(keyval, '=');

        if (val) {
                char *ve = val++;
                while (*val && *val == ' ') {
                        val++;
                }
                *ve-- = '\0';
                while (*ve && *ve == ' ') {
                        *ve-- = '\0';
                }
        }

        if (key && val) {
                char *external_ip = NULL;
                switch_memory_pool_t *pool;

                switch_core_new_memory_pool(&pool);

                if (switch_stun_ip_lookup(&external_ip, val, pool) == SWITCH_STATUS_SUCCESS) {
                        if (!zstr(external_ip)) {
                                char *tmp = external_ip;
                                tmp = &tmp[strlen(tmp) - 1];
                                while (tmp >= external_ip && (tmp[0] == ' ' || tmp[0] == '\n')) {
                                        tmp[0] = '\0'; /* remove trailing spaces and newlines */
                                        tmp--;
                                }
                                switch_core_set_variable(key, external_ip);
                        }
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "stun-set failed.\n");
                }

                switch_core_destroy_memory_pool(&pool);
        }
}

switch_xml_add_child()

switch_xml_t switch_xml_add_child	(	switch_xml_t	xml,
		const char *	name,
		switch_size_t	off
	)

Definition at line 2966 of file switch_xml.c.

References switch_xml::attr, memset(), switch_xml::name, switch_xml::off, switch_xml::parent, switch_must_malloc(), switch_xml_insert(), SWITCH_XML_NIL, switch_xml::txt, and destroy_xml::xml.

Referenced by switch_xml_add_child_d(), and switch_xml_open_tag().

{
        switch_xml_t child;

        if (!xml)
                return NULL;
        child = (switch_xml_t) switch_must_malloc(sizeof(struct switch_xml));

        memset(child, '\0', sizeof(struct switch_xml));
        child->name = (char *) name;
        child->attr = SWITCH_XML_NIL;
        child->off = off;
        child->parent = xml;
        child->txt = (char *) "";

        return switch_xml_insert(child, xml, off);
}

switch_xml_add_child_d()

switch_xml_t switch_xml_add_child_d	(	switch_xml_t	xml,
		const char *	name,
		switch_size_t	off
	)

Definition at line 2986 of file switch_xml.c.

References switch_xml_add_child(), SWITCH_XML_NAMEM, and switch_xml_set_flag().

Referenced by do_merge().

{
        if (!xml) return NULL;
        return switch_xml_set_flag(switch_xml_add_child(xml, strdup(name), off), SWITCH_XML_NAMEM);
}

switch_xml_ampencode()

static char* switch_xml_ampencode ( const char *  s, switch_size_t  len, char **  dst, switch_size_t *  dlen, switch_size_t *  max, short  a, switch_bool_t  use_utf8_encoding  )

static

Definition at line 2517 of file switch_xml.c.

References SWITCH_CHANNEL_LOG, switch_log_printf(), SWITCH_LOG_WARNING, switch_must_realloc(), and SWITCH_XML_BUFSIZE.

Referenced by switch_xml_tohtml_ex(), and switch_xml_toxml_r().

{
        const char *e = NULL;
        int immune = 0;
        int expecting_x_utf_8_char = 0;
        int unicode_char = 0x000000;

        if (!(s && *s))
                return *dst;

        if (len) {
                e = s + len;
        }

        while (s != e) {
                while (*dlen + 10 > *max) {
                        *dst = (char *) switch_must_realloc(*dst, *max += SWITCH_XML_BUFSIZE);
                }

                if (immune) {
                        if (*s == '\0') {
                                return *dst;
                        }
                        (*dst)[(*dlen)++] = *s;
                } else
                        switch (*s) {
                        case '\0':
                                return *dst;
                        case '&':
                                *dlen += sprintf(*dst + *dlen, "&");
                                break;
                        case '<':
                                if (*(s + 1) == '!') {
                                        (*dst)[(*dlen)++] = *s;
                                        immune++;
                                        break;
                                }
                                *dlen += sprintf(*dst + *dlen, "&lt;");
                                break;
                        case '>':
                                *dlen += sprintf(*dst + *dlen, "&gt;");
                                break;
                        case '"':
                                *dlen += sprintf(*dst + *dlen, (a) ? "&quot;" : "\"");
                                break;
                        case '\n':
                                *dlen += sprintf(*dst + *dlen, (a) ? "&#xA;" : "\n");
                                break;
                        case '\t':
                                *dlen += sprintf(*dst + *dlen, (a) ? "&#x9;" : "\t");
                                break;
                        case '\r':
                                *dlen += sprintf(*dst + *dlen, "&#xD;");
                                break;
                        default:
                                if (use_utf8_encoding && expecting_x_utf_8_char == 0 && ((*s >> 8) & 0x01)) {
                                        int num = 1;
                                        for (;num<4;num++) {
                                                if (! ((*s >> (7-num)) & 0x01)) {
                                                        break;
                                                }
                                        }
                                        switch (num) {
                                                case 2:
                                                        unicode_char = *s & 0x1f;
                                                        break;
                                                case 3:
                                                        unicode_char = *s & 0x0f;
                                                        break;
                                                case 4:
                                                        unicode_char = *s & 0x07;
                                                        break;
                                                default:
                                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Invalid UTF-8 Initial charactere, skip it\n");
                                                        /* ERROR HERE */
                                                        break;
                                        }
                                        expecting_x_utf_8_char = num - 1;

                                } else if (use_utf8_encoding && expecting_x_utf_8_char > 0) {
                                        if (((*s >> 6) & 0x03) == 0x2) {

                                                unicode_char = unicode_char << 6;
                                                unicode_char = unicode_char | (*s & 0x3f);
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Invalid UTF-8 character to ampersand, skip it\n");
                                                expecting_x_utf_8_char = 0;
                                                break;
                                        }
                                        expecting_x_utf_8_char--;
                                        if (expecting_x_utf_8_char == 0) {
                                                *dlen += sprintf(*dst + *dlen, "&#x%X;", unicode_char);
                                        }
                                } else {
                                        (*dst)[(*dlen)++] = *s;
                                }
                        }
                s++;
        }
        return *dst;
}

switch_xml_attr()

const char* switch_xml_attr	(	switch_xml_t	xml,
		const char *	attr
	)

Definition at line 490 of file switch_xml.c.

References switch_xml::attr, switch_xml_root::attr, if(), switch_xml::name, switch_xml::parent, and switch_xml_root::xml.

Referenced by do_merge(), switch_xml_attr_soft(), switch_xml_find_child(), switch_xml_find_child_multi(), switch_xml_locate(), switch_xml_locate_user_merged(), switch_xml_merge_user(), switch_xml_std_datetime_check(), and switch_xml_toxml_r().

{
        int i = 0, j = 1;
        switch_xml_root_t root = (switch_xml_root_t) xml;

        if (!xml || !xml->attr)
                return NULL;
        while (xml->attr[i] && attr && strcmp(attr, xml->attr[i]))
                i += 2;
        if (xml->attr[i])
                return xml->attr[i + 1];        /* found attribute */

        while (root->xml.parent)
                root = (switch_xml_root_t) root->xml.parent;    /* root tag */

        if (!root->attr) {
                return NULL;
        }

        for (i = 0; root->attr[i] && xml->name && strcmp(xml->name, root->attr[i][0]); i++);
        if (!root->attr[i])
                return NULL;                    /* no matching default attributes */
        while (root->attr[i][j] && attr && strcmp(attr, root->attr[i][j]))
                j += 3;
        return (root->attr[i][j]) ? root->attr[i][j + 1] : NULL;        /* found default */
}

switch_xml_attr_soft()

const char* switch_xml_attr_soft	(	switch_xml_t	xml,
		const char *	attr
	)

Definition at line 482 of file switch_xml.c.

References switch_xml_attr().

{
        const char *ret = switch_xml_attr(xml, attr);

        return ret ? ret : "";
}

switch_xml_bind_search_function_ret()

switch_status_t switch_xml_bind_search_function_ret	(	switch_xml_search_function_t	function,
		switch_xml_section_t	sections,
		void *	user_data,
		switch_xml_binding_t **	ret_binding
	)

Definition at line 358 of file switch_xml.c.

References switch_xml_binding::function, switch_xml_binding::next, switch_xml_binding::sections, switch_core_alloc, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, switch_thread_rwlock_unlock(), switch_thread_rwlock_wrlock(), and switch_xml_binding::user_data.

{
        switch_xml_binding_t *binding = NULL, *ptr = NULL;
        assert(function != NULL);

        if (!(binding = (switch_xml_binding_t *) switch_core_alloc(XML_MEMORY_POOL, sizeof(*binding)))) {
                return SWITCH_STATUS_MEMERR;
        }

        binding->function = function;
        binding->sections = sections;
        binding->user_data = user_data;

        switch_thread_rwlock_wrlock(B_RWLOCK);
        for (ptr = BINDINGS; ptr && ptr->next; ptr = ptr->next);

        if (ptr) {
                ptr->next = binding;
        } else {
                BINDINGS = binding;
        }

        if (ret_binding) {
                *ret_binding = binding;
        }

        switch_thread_rwlock_unlock(B_RWLOCK);

        return SWITCH_STATUS_SUCCESS;
}

switch_xml_char_content()

static void switch_xml_char_content ( switch_xml_root_t  root, char *  s, switch_size_t  len, char  t  )

static

Definition at line 715 of file switch_xml.c.

References switch_xml_root::cur, switch_xml_root::ent, switch_xml::flags, switch_xml::name, switch_must_malloc(), switch_must_realloc(), switch_xml_decode(), switch_xml_set_flag(), SWITCH_XML_TXTM, and switch_xml::txt.

Referenced by switch_xml_parse_str().

{
        switch_xml_t xml;
        char *m = s;
        switch_size_t l;

        if (!root || !root->cur) {
                return;
        }

        xml = root->cur;

        if (!xml || !xml->name || !len)
                return;                                 /* sanity check */

        s[len] = '\0';                          /* null terminate text (calling functions anticipate this) */
        len = strlen(s = switch_xml_decode(s, root->ent, t)) + 1;

        if (!*(xml->txt))
                xml->txt = s;                   /* initial character content */
        else {                                          /* allocate our own memory and make a copy */
                if ((xml->flags & SWITCH_XML_TXTM)) {   /* allocate some space */
                        xml->txt = (char *) switch_must_realloc(xml->txt, (l = strlen(xml->txt)) + len);
                } else {
                        char *tmp = (char *) switch_must_malloc((l = strlen(xml->txt)) + len);

                        xml->txt = strcpy(tmp, xml->txt);
                }
                strcpy(xml->txt + l, s);        /* add new char content */
                if (s != m)
                        free(s);                        /* free s if it was malloced by switch_xml_decode() */
        }

        if (xml->txt != m)
                switch_xml_set_flag(xml, SWITCH_XML_TXTM);
}

switch_xml_child()

switch_xml_t switch_xml_child	(	switch_xml_t	xml,
		const char *	name
	)

Definition at line 465 of file switch_xml.c.

References switch_xml::child, switch_xml::name, switch_xml::sibling, and while().

Referenced by do_merge(), switch_xml_find_child(), switch_xml_find_child_multi(), switch_xml_locate(), switch_xml_locate_group(), switch_xml_locate_language_ex(), switch_xml_locate_user(), switch_xml_locate_user_in_domain(), and switch_xml_vget().

{
        xml = (xml) ? xml->child : NULL;
        while (xml && strcmp(name, xml->name))
                xml = xml->sibling;
        return xml;
}

switch_xml_close_tag()

static switch_xml_t switch_xml_close_tag ( switch_xml_root_t  root, char *  name, char *  s, char *  close_pos  )

static

Definition at line 753 of file switch_xml.c.

References switch_xml::close, switch_xml_root::cur, switch_xml::name, switch_xml::parent, and switch_xml_err().

Referenced by switch_xml_parse_str().

{
        if (!root || !root->cur || !root->cur->name || strcmp(name, root->cur->name))
                return switch_xml_err(root, s, "unexpected closing tag </%s>", name);

        root->cur->close = close_pos;
        root->cur = root->cur->parent;
        return NULL;
}

switch_xml_cut()

switch_xml_t switch_xml_cut

(

switch_xml_t

xml

)

Definition at line 3100 of file switch_xml.c.

References switch_xml::child, cur, switch_xml::name, switch_xml::next, switch_xml::ordered, switch_xml::parent, switch_xml::sibling, and destroy_xml::xml.

{
        switch_xml_t cur;

        if (!xml)
                return NULL;                    /* nothing to do */
        if (xml->next)
                xml->next->sibling = xml->sibling;      /* patch sibling list */

        if (xml->parent) {                      /* not root tag */
                cur = xml->parent->child;       /* find head of subtag list */
                if (cur == xml)
                        xml->parent->child = xml->ordered;      /* first subtag */
                else {                                  /* not first subtag */
                        while (cur->ordered != xml)
                                cur = cur->ordered;
                        cur->ordered = cur->ordered->ordered;   /* patch ordered list */

                        cur = xml->parent->child;       /* go back to head of subtag list */
                        if (strcmp(cur->name, xml->name)) {     /* not in first sibling list */
                                while (strcmp(cur->sibling->name, xml->name))
                                        cur = cur->sibling;
                                if (cur->sibling == xml) {      /* first of a sibling list */
                                        cur->sibling = (xml->next) ? xml->next : cur->sibling->sibling;
                                } else
                                        cur = cur->sibling;     /* not first of a sibling list */
                        }

                        while (cur->next && cur->next != xml)
                                cur = cur->next;
                        if (cur->next)
                                cur->next = cur->next->next;    /* patch next list */
                }
        }
        xml->ordered = xml->sibling = xml->next = NULL; /* prevent switch_xml_free() from clobbering ordered list */
        return xml;
}

switch_xml_decode()

static char* switch_xml_decode ( char *  s, char **  ent, char  t  )

static

Definition at line 601 of file switch_xml.c.

References b, switch_must_malloc(), and switch_must_realloc().

Referenced by switch_xml_char_content(), switch_xml_internal_dtd(), and switch_xml_parse_str().

{
        char *e, *r = s, *m = s;
        unsigned long b, c, d, l;

        for (; *s; s++) {                       /* normalize line endings */
                while (*s == '\r') {
                        *(s++) = '\n';
                        if (*s == '\n')
                                memmove(s, (s + 1), strlen(s));
                }
        }

        for (s = r;;) {
                while (*s && *s != '&' && (*s != '%' || t != '%') && !isspace((unsigned char) (*s)))
                        s++;

                if (!*s)
                        break;
                else if (t != 'c' && !strncmp(s, "&#", 2)) {    /* character reference */
                        char *code = s + 2;
                        int base = 10;
                        if (*code == 'x') {
                                code++;
                                base = 16;
                        }
                        if (!isxdigit((int)*code)) { /* "&# 1;" and "&#-1;" are invalid */
                                s++;
                                continue;
                        }
                        c = strtoul(code, &e, base);
                        if (!c || *e != ';') {
                                s++;
                                continue;
                        }
                        /* not a character ref */
                        if (c < 0x80)
                                *(s++) = (char) c;      /* US-ASCII subset */
                        else if (c > 0x7FFFFFFF) { /* out of UTF-8 range */
                                s++;
                                continue;
                        } else {                                /* multi-byte UTF-8 sequence */
                                for (b = 0, d = c; d; d /= 2)
                                        b++;            /* number of bits in c */
                                b = (b - 2) / 5;        /* number of bytes in payload */
                                assert(b < 7);          /* because c <= 0x7FFFFFFF */
                                *(s++) = (char) ((0xFF << (7 - b)) | (c >> (6 * b)));   /* head */
                                while (b)
                                        *(s++) = (char) (0x80 | ((c >> (6 * --b)) & 0x3F));     /* payload */
                        }

                        memmove(s, strchr(s, ';') + 1, strlen(strchr(s, ';')));
                } else if ((*s == '&' && (t == '&' || t == ' ' || t == '*')) || (*s == '%' && t == '%')) {      /* entity reference */
                        for (b = 0; ent[b] && strncmp(s + 1, ent[b], strlen(ent[b])); b += 2);  /* find entity in entity list */

                        if (ent[b++]) {         /* found a match */
                                if ((c = (unsigned long) strlen(ent[b])) - 1 > (e = strchr(s, ';')) - s) {
                                        l = (d = (unsigned long) (s - r)) + c + (unsigned long) strlen(e);      /* new length */
                                        if (l) {
                                                if (r == m) {
                                                        char *tmp = (char *) switch_must_malloc(l);
                                                        r = strcpy(tmp, r);
                                                } else {
                                                        r = (char *) switch_must_realloc(r, l);
                                                }
                                        }
                                        e = strchr((s = r + d), ';');   /* fix up pointers */
                                }

                                memmove(s + c, e + 1, strlen(e));       /* shift rest of string */
                                strncpy(s, ent[b], c);  /* copy in replacement text */
                        } else
                                s++;                    /* not a known entity */
                } else if ((t == ' ' || t == '*') && isspace((int) (*s)))
                        *(s++) = ' ';
                else
                        s++;                            /* no decoding needed */
        }

        if (t == '*') {                         /* normalize spaces for non-cdata attributes */
                for (s = r; *s; s++) {
                        if ((l = (unsigned long) strspn(s, " ")))
                                memmove(s, s + l, strlen(s + l) + 1);
                        while (*s && *s != ' ')
                                s++;
                }
                if (--s >= r && *s == ' ')
                        *s = '\0';                      /* trim any trailing space */
        }
        return r;
}

switch_xml_ent_ok()

static int switch_xml_ent_ok ( char *  name, char *  s, char **  ent  )

static

Definition at line 765 of file switch_xml.c.

Referenced by switch_xml_internal_dtd().

{
        int i;

        for (;; s++) {
                while (*s && *s != '&')
                        s++;                            /* find next entity reference */
                if (!*s)
                        return 1;
                if (!strncmp(s + 1, name, strlen(name)))
                        return 0;                       /* circular ref. */
                for (i = 0; ent[i] && strncmp(ent[i], s + 1, strlen(ent[i])); i += 2);
                if (ent[i] && !switch_xml_ent_ok(name, ent[i + 1], ent))
                        return 0;
        }
}

switch_xml_err()

static switch_xml_t switch_xml_err ( switch_xml_root_t  root, char *  s, const char *  err,   ...  )

static

Definition at line 573 of file switch_xml.c.

References switch_xml_root::err, fmt, switch_xml_root::s, switch_snprintf(), SWITCH_XML_ERRL, and switch_xml_root::xml.

Referenced by switch_xml_close_tag(), switch_xml_internal_dtd(), and switch_xml_parse_str().

{
        va_list ap;
        int line = 1;
        char *t, fmt[SWITCH_XML_ERRL];

        if (!root || !root->s) {
                return NULL;
        }

        for (t = root->s; t && t < s; t++)
                if (*t == '\n')
                        line++;
        switch_snprintf(fmt, SWITCH_XML_ERRL, "[error near line %d]: %s", line, err);

        va_start(ap, err);
        vsnprintf(root->err, SWITCH_XML_ERRL, fmt, ap);
        va_end(ap);

        return &root->xml;
}

switch_xml_error()

const char* switch_xml_error

(

switch_xml_t

xml

)

Definition at line 2900 of file switch_xml.c.

References switch_xml::parent.

Referenced by __switch_xml_open_root(), and switch_xml_locate().

{
        while (xml && xml->parent)
                xml = xml->parent;              /* find root tag */
        return (xml) ? ((switch_xml_root_t) xml)->err : "";
}

switch_xml_find_child()

switch_xml_t switch_xml_find_child	(	switch_xml_t	node,
		const char *	childname,
		const char *	attrname,
		const char *	value
	)

Definition at line 390 of file switch_xml.c.

References switch_xml::next, switch_xml_attr(), and switch_xml_child().

Referenced by switch_xml_locate(), switch_xml_locate_group(), and switch_xml_locate_language_ex().

{
        switch_xml_t p = NULL;

        if (!(childname && attrname && value)) {
                return node;
        }

        for (p = switch_xml_child(node, childname); p; p = p->next) {
                const char *aname = switch_xml_attr(p, attrname);
                if (aname && !strcasecmp(aname, value)) {
                        break;
                }
        }

        return p;
}

switch_xml_find_child_multi()

switch_xml_t switch_xml_find_child_multi	(	switch_xml_t	node,
		const char *	childname,
			...
	)

Definition at line 408 of file switch_xml.c.

References switch_xml::next, switch_xml_attr(), switch_xml_child(), and value.

Referenced by find_user_in_tag().

{
        switch_xml_t p = NULL;
        const char *names[256] = { 0 };
        const char *vals[256] = { 0 };
        int x, i = 0;
        va_list ap;
        const char *attrname, *value = NULL;

        va_start(ap, childname);

        while (i < 255) {
                if ((attrname = va_arg(ap, const char *))) {
                        value = va_arg(ap, const char *);
                }
                if (attrname && value) {
                        names[i] = attrname;
                        vals[i] = value;
                } else {
                        break;
                }
                i++;
        }

        va_end(ap);

        if (!(childname && i)) {
                return node;
        }

        for (p = switch_xml_child(node, childname); p; p = p->next) {
                for (x = 0; x < i; x++) {
                        if (names[x] && vals[x]) {
                                const char *aname = switch_xml_attr(p, names[x]);

                                if (aname) {
                                        if (*vals[x] == '!') {
                                                const char *sval = vals[x] + 1;
                                                if (strcasecmp(aname, sval)) {
                                                        goto done;
                                                }
                                        } else {
                                                if (!strcasecmp(aname, vals[x])) {
                                                        goto done;
                                                }
                                        }
                                }
                        }
                }
        }

  done:

        return p;
}

switch_xml_free()

void switch_xml_free

(

switch_xml_t

xml

)

Definition at line 2815 of file switch_xml.c.

References switch_xml::attr, switch_xml_root::attr, switch_xml::child, switch_xml_root::dynamic, switch_xml_root::e, switch_xml_root::ent, switch_xml::flags, switch_xml::free_path, switch_xml_root::m, switch_xml::name, switch_xml::ordered, switch_xml::parent, switch_xml_root::pi, switch_xml::refs, switch_xml_root::s, SWITCH_CHANNEL_LOG, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), switch_mutex_unlock(), switch_safe_free, switch_test_flag, switch_xml_free_attr(), SWITCH_XML_NAMEM, SWITCH_XML_ROOT, SWITCH_XML_TXTM, switch_xml::txt, switch_xml_root::u, and destroy_xml::xml.

Referenced by __switch_xml_open_root(), destroy_thread(), switch_xml_clear_user_cache(), switch_xml_destroy(), switch_xml_init(), switch_xml_locate(), switch_xml_locate_language_ex(), switch_xml_locate_user(), switch_xml_locate_user_merged(), switch_xml_reload(), switch_xml_set_root(), and switch_xml_user_cache().

{
        switch_xml_root_t root;
        int i, j;
        char **a, *s;
        switch_xml_t orig_xml;
        int refs = 0;

  tailrecurse:
        root = (switch_xml_root_t) xml;
        if (!xml) {
                return;
        }

        if (switch_test_flag(xml, SWITCH_XML_ROOT)) {
                switch_mutex_lock(REFLOCK);

                if (xml->refs) {
                        xml->refs--;
                        refs = xml->refs;
                }
                switch_mutex_unlock(REFLOCK);
        }

        if (refs) {
                return;
        }

        if (xml->free_path) {
                if (unlink(xml->free_path) != 0) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Failed to delete file [%s]\n", xml->free_path);
                }
                switch_safe_free(xml->free_path);
        }

        switch_xml_free(xml->child);
        /*switch_xml_free(xml->ordered); */

        if (!xml->parent) {                     /* free root tag allocations */
#if (_MSC_VER >= 1400)                  // VC8+
                __analysis_assume(sizeof(root->ent) > 44);      /* tail recursion confuses code analysis */
#endif
                for (i = 10; root->ent[i]; i += 2)      /* 0 - 9 are default entities (<>&"') */
                        if ((s = root->ent[i + 1]) < root->s || s > root->e)
                                free(s);
                free(root->ent);                /* free list of general entities */

                for (i = 0; (a = root->attr[i]); i++) {
                        for (j = 1; a[j++]; j += 2)     /* free malloced attribute values */
                                if (a[j] && (a[j] < root->s || a[j] > root->e))
                                        free(a[j]);
                        free(a);
                }
                if (root->attr[0])
                        free(root->attr);       /* free default attribute list */

                for (i = 0; root->pi[i]; i++) {
                        for (j = 1; root->pi[i][j]; j++);
                        free(root->pi[i][j + 1]);
                        free(root->pi[i]);
                }
                if (root->pi[0])
                        free(root->pi);         /* free processing instructions */

                if (root->dynamic == 1)
                        free(root->m);          /* malloced xml data */
                if (root->u)
                        free(root->u);          /* utf8 conversion */
        }

        switch_xml_free_attr(xml->attr);        /* tag attributes */
        if ((xml->flags & SWITCH_XML_TXTM))
                free(xml->txt);                 /* character content */
        if ((xml->flags & SWITCH_XML_NAMEM))
                free(xml->name);                /* tag name */
        if (xml->ordered) {
                orig_xml = xml;
                xml = xml->ordered;
                free(orig_xml);
                goto tailrecurse;
        }
        free(xml);
}

switch_xml_free_attr()

static void switch_xml_free_attr ( char **  attr )

static

Definition at line 1013 of file switch_xml.c.

References SWITCH_XML_NAMEM, and SWITCH_XML_TXTM.

Referenced by switch_xml_free(), and switch_xml_parse_str().

{
        int i, c = 0;
        char *m;

        if (!attr || attr == SWITCH_XML_NIL)
                return;                                 /* nothing to free */
        while (attr[c])
                c += 2;                                 /* find end of attribute list */
        m = attr[c + 1];                        /* list of which names and values are malloced */
        for (i = c / 2 - 1; i >= 0 ; i--) {
                if (m[i] & SWITCH_XML_NAMEM)
                        free(attr[i * 2]);
                if (m[i] & SWITCH_XML_TXTM)
                        free(attr[(i * 2) + 1]);
        }
        free(m);
        free(attr);
}

switch_xml_free_in_thread()

void switch_xml_free_in_thread	(	switch_xml_t	xml,
		int	stacksize
	)

Definition at line 2307 of file switch_xml.c.

References destroy_thread(), pool, destroy_xml::pool, switch_core_alloc, switch_core_new_memory_pool, switch_thread_create(), switch_threadattr_create(), switch_threadattr_detach_set(), switch_threadattr_stacksize_set(), thread, and destroy_xml::xml.

{
        switch_thread_t *thread;
        switch_threadattr_t *thd_attr;
        switch_memory_pool_t *pool = NULL;
        struct destroy_xml *dx;

        switch_core_new_memory_pool(&pool);

        switch_threadattr_create(&thd_attr, pool);
        switch_threadattr_detach_set(thd_attr, 1);
        /* TBD figure out how much space we need by looking at the xml_t when stacksize == 0 */
        switch_threadattr_stacksize_set(thd_attr, stacksize);

        dx = switch_core_alloc(pool, sizeof(*dx));
        dx->pool = pool;
        dx->xml = xml;

        switch_thread_create(&thread, thd_attr, destroy_thread, dx, pool);
}

switch_xml_get()

switch_xml_t switch_xml_get	(	switch_xml_t	xml,
			...
	)

Definition at line 536 of file switch_xml.c.

References switch_xml_vget().

{
        va_list ap;
        switch_xml_t r;

        va_start(ap, xml);
        r = switch_xml_vget(xml, ap);
        va_end(ap);
        return r;
}

switch_xml_get_binding_sections()

switch_xml_section_t switch_xml_get_binding_sections

(

switch_xml_binding_t *

binding

)

Definition at line 348 of file switch_xml.c.

References switch_xml_binding::sections.

{
        return binding->sections;
}

switch_xml_get_binding_user_data()

void* switch_xml_get_binding_user_data

(

switch_xml_binding_t *

binding

)

Definition at line 353 of file switch_xml.c.

References switch_xml_binding::user_data.

{
        return binding->user_data;
}

switch_xml_idx()

switch_xml_t switch_xml_idx	(	switch_xml_t	xml,
		int	idx
	)

Definition at line 474 of file switch_xml.c.

References switch_xml::next.

Referenced by switch_xml_vget().

{
        for (; xml && idx; idx--)
                xml = xml->next;
        return xml;
}

switch_xml_init()

switch_status_t switch_xml_init	(	switch_memory_pool_t *	pool,
		const char **	err
	)

Definition at line 2448 of file switch_xml.c.

References FALSE, pool, switch_core_hash_init, switch_mutex_init(), SWITCH_MUTEX_NESTED, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_rwlock_create(), switch_xml_free(), switch_xml_open_root(), and destroy_xml::xml.

{
        switch_xml_t xml;
        XML_MEMORY_POOL = pool;
        *err = "Success";

        switch_mutex_init(&CACHE_MUTEX, SWITCH_MUTEX_NESTED, XML_MEMORY_POOL);
        switch_mutex_init(&XML_LOCK, SWITCH_MUTEX_NESTED, XML_MEMORY_POOL);
        switch_mutex_init(&REFLOCK, SWITCH_MUTEX_NESTED, XML_MEMORY_POOL);
        switch_mutex_init(&FILE_LOCK, SWITCH_MUTEX_NESTED, XML_MEMORY_POOL);
        switch_core_hash_init(&CACHE_HASH);
        switch_core_hash_init(&CACHE_EXPIRES_HASH);

        switch_thread_rwlock_create(&B_RWLOCK, XML_MEMORY_POOL);

        assert(pool != NULL);

        if ((xml = switch_xml_open_root(FALSE, err))) {
                switch_xml_free(xml);
                return SWITCH_STATUS_SUCCESS;
        } else {
                return SWITCH_STATUS_FALSE;
        }
}

switch_xml_insert()

switch_xml_t switch_xml_insert	(	switch_xml_t	xml,
		switch_xml_t	dest,
		switch_size_t	off
	)

Definition at line 2925 of file switch_xml.c.

References switch_xml::child, cur, switch_xml::name, switch_xml::next, switch_xml::off, switch_xml::ordered, switch_xml::parent, switch_xml::sibling, and destroy_xml::xml.

Referenced by switch_xml_add_child().

{
        switch_xml_t cur, prev, head;

        xml->next = xml->sibling = xml->ordered = NULL;
        xml->off = off;
        xml->parent = dest;

        if ((head = dest->child)) {     /* already have sub tags */
                if (head->off <= off) { /* not first subtag */
                        for (cur = head; cur->ordered && cur->ordered->off <= off; cur = cur->ordered);
                        xml->ordered = cur->ordered;
                        cur->ordered = xml;
                } else {                                /* first subtag */
                        xml->ordered = head;
                        dest->child = xml;
                }

                for (cur = head, prev = NULL; cur && strcmp(cur->name, xml->name); prev = cur, cur = cur->sibling);     /* find tag type */
                if (cur && cur->off <= off) {   /* not first of type */
                        while (cur->next && cur->next->off <= off)
                                cur = cur->next;
                        xml->next = cur->next;
                        cur->next = xml;
                } else {                                /* first tag of this type */
                        if (prev && cur)
                                prev->sibling = cur->sibling;   /* remove old first */
                        xml->next = cur;        /* old first tag is now next */
                        for (cur = head, prev = NULL; cur && cur->off <= off; prev = cur, cur = cur->sibling);  /* new sibling insert point */
                        xml->sibling = cur;
                        if (prev)
                                prev->sibling = xml;
                }
        } else
                dest->child = xml;              /* only sub tag */

        return xml;
}

switch_xml_internal_dtd()

static short switch_xml_internal_dtd ( switch_xml_root_t  root, char *  s, switch_size_t  len  )

static

Definition at line 836 of file switch_xml.c.

References switch_xml_root::attr, switch_xml_root::ent, switch_xml_root::err, switch_xml_root::standalone, switch_must_malloc(), switch_must_realloc(), switch_xml_decode(), switch_xml_ent_ok(), switch_xml_err(), SWITCH_XML_NIL, switch_xml_proc_inst(), and SWITCH_XML_WS.

Referenced by switch_xml_parse_str().

{
        char q, *c, *t, *n = NULL, *v, **ent, **pe;
        int i, j;
        char **sstmp;

        pe = (char **) memcpy(switch_must_malloc(sizeof(SWITCH_XML_NIL)), SWITCH_XML_NIL, sizeof(SWITCH_XML_NIL));

        for (s[len] = '\0'; s;) {
                while (*s && *s != '<' && *s != '%')
                        s++;                            /* find next declaration */

                if (!*s)
                        break;
                else if (!strncmp(s, "<!ENTITY", 8)) {  /* parse entity definitions */
                        int use_pe;

                        c = s += strspn(s + 8, SWITCH_XML_WS) + 8;      /* skip white space separator */
                        n = s + strspn(s, SWITCH_XML_WS "%");   /* find name */
                        *(s = n + strcspn(n, SWITCH_XML_WS)) = ';';     /* append ; to name */

                        v = s + strspn(s + 1, SWITCH_XML_WS) + 1;       /* find value */
                        if ((q = *(v++)) != '"' && q != '\'') { /* skip externals */
                                s = strchr(s, '>');
                                continue;
                        }

                        use_pe = (*c == '%');
                        for (i = 0, ent = (use_pe) ? pe : root->ent; ent[i]; i++);
                        sstmp = (char **) switch_must_realloc(ent, (i + 3) * sizeof(char *));   /* space for next ent */
                        ent = sstmp;
                        if (use_pe)
                                pe = ent;
                        else
                                root->ent = ent;

                        *(++s) = '\0';          /* null terminate name */
                        if ((s = strchr(v, q)))
                                *(s++) = '\0';  /* null terminate value */
                        ent[i + 1] = switch_xml_decode(v, pe, '%');     /* set value */
                        ent[i + 2] = NULL;      /* null terminate entity list */
                        if (!switch_xml_ent_ok(n, ent[i + 1], ent)) {   /* circular reference */
                                if (ent[i + 1] != v)
                                        free(ent[i + 1]);
                                switch_xml_err(root, v, "circular entity declaration &%s", n);
                                break;
                        } else
                                ent[i] = n;             /* set entity name */
                } else if (!strncmp(s, "<!ATTLIST", 9)) {       /* parse default attributes */
                        t = s + strspn(s + 9, SWITCH_XML_WS) + 9;       /* skip whitespace separator */
                        if (!*t) {
                                switch_xml_err(root, t, "unclosed <!ATTLIST");
                                break;
                        }
                        if (*(s = t + strcspn(t, SWITCH_XML_WS ">")) == '>')
                                continue;
                        else
                                *s = '\0';              /* null terminate tag name */
                        for (i = 0; root->attr[i] && n && strcmp(n, root->attr[i][0]); i++);

                        //while (*(n = ++s + strspn(s, SWITCH_XML_WS)) && *n != '>') {
                        // gcc 4.4 you are a creep
                        for (;;) {
                                s++;
                                if (!(*(n = s + strspn(s, SWITCH_XML_WS)) && *n != '>')) {
                                        break;
                                }
                                if (*(s = n + strcspn(n, SWITCH_XML_WS)))
                                        *s = '\0';      /* attr name */
                                else {
                                        switch_xml_err(root, t, "malformed <!ATTLIST");
                                        break;
                                }

                                s += strspn(s + 1, SWITCH_XML_WS) + 1;  /* find next token */
                                c = (strncmp(s, "CDATA", 5)) ? (char *) "*" : (char *) " ";     /* is it cdata? */
                                if (!strncmp(s, "NOTATION", 8))
                                        s += strspn(s + 8, SWITCH_XML_WS) + 8;
                                s = (*s == '(') ? strchr(s, ')') : s + strcspn(s, SWITCH_XML_WS);
                                if (!s) {
                                        switch_xml_err(root, t, "malformed <!ATTLIST");
                                        break;
                                }

                                s += strspn(s, SWITCH_XML_WS ")");      /* skip white space separator */
                                if (!strncmp(s, "#FIXED", 6))
                                        s += strspn(s + 6, SWITCH_XML_WS) + 6;
                                if (*s == '#') {        /* no default value */
                                        s += strcspn(s, SWITCH_XML_WS ">") - 1;
                                        if (*c == ' ')
                                                continue;       /* cdata is default, nothing to do */
                                        v = NULL;
                                } else if ((*s == '"' || *s == '\'') && /* default value */
                                                   (s = strchr(v = s + 1, *s)))
                                        *s = '\0';
                                else {
                                        switch_xml_err(root, t, "malformed <!ATTLIST");
                                        break;
                                }

                                if (!root->attr[i]) {   /* new tag name */
                                        root->attr = (!i) ? (char ***) switch_must_malloc(2 * sizeof(char **))
                                                : (char ***) switch_must_realloc(root->attr, (i + 2) * sizeof(char **));
                                        root->attr[i] = (char **) switch_must_malloc(2 * sizeof(char *));
                                        root->attr[i][0] = t;   /* set tag name */
                                        root->attr[i][1] = (char *) (root->attr[i + 1] = NULL);
                                }

                                for (j = 1; root->attr[i][j]; j += 3);  /* find end of list */
                                sstmp = (char **) switch_must_realloc(root->attr[i], (j + 4) * sizeof(char *));

                                root->attr[i] = sstmp;
                                root->attr[i][j + 3] = NULL;    /* null terminate list */
                                root->attr[i][j + 2] = c;       /* is it cdata? */
                                root->attr[i][j + 1] = (v) ? switch_xml_decode(v, root->ent, *c) : NULL;
                                root->attr[i][j] = n;   /* attribute name  */
                        }
                } else if (!strncmp(s, "<!--", 4))
                        s = strstr(s + 4, "-->");       /* comments */
                else if (!strncmp(s, "<?", 2)) {        /* processing instructions */
                        if ((s = strstr(c = s + 2, "?>")))
                                switch_xml_proc_inst(root, c, s++ - c);
                } else if (*s == '<')
                        s = strchr(s, '>');     /* skip other declarations */
                else if (*(s++) == '%' && !root->standalone)
                        break;
        }

        free(pe);
        return !*root->err;
}

switch_xml_locate()

switch_status_t switch_xml_locate	(	const char *	section,
		const char *	tag_name,
		const char *	key_name,
		const char *	key_value,
		switch_xml_t *	root,
		switch_xml_t *	node,
		switch_event_t *	params,
		switch_bool_t	clone
	)

Definition at line 1757 of file switch_xml.c.

References switch_xml_binding::function, switch_xml_binding::next, switch_xml_binding::sections, switch_assert, SWITCH_CHANNEL_LOG, SWITCH_FALSE, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_rwlock_rdlock(), switch_thread_rwlock_unlock(), switch_xml_attr(), switch_xml_child(), switch_xml_error(), switch_xml_find_child(), switch_xml_free(), switch_xml_parse_section_string(), switch_xml_parse_str_dynamic(), switch_xml_root(), switch_xml_toxml, switch_xml_binding::user_data, and zstr.

Referenced by switch_xml_locate_domain(), switch_xml_locate_language_ex(), and switch_xml_open_cfg().

{
        switch_xml_t conf = NULL;
        switch_xml_t tag = NULL;
        switch_xml_t xml = NULL;
        switch_xml_binding_t *binding;
        uint8_t loops = 0;
        switch_xml_section_t sections = BINDINGS ? switch_xml_parse_section_string(section) : 0;

        switch_thread_rwlock_rdlock(B_RWLOCK);

        for (binding = BINDINGS; binding; binding = binding->next) {
                if (binding->sections && !(sections & binding->sections)) {
                        continue;
                }

                if ((xml = binding->function(section, tag_name, key_name, key_value, params, binding->user_data))) {
                        const char *err = NULL;

                        err = switch_xml_error(xml);
                        if (zstr(err)) {
                                if ((conf = switch_xml_find_child(xml, "section", "name", "result"))) {
                                        switch_xml_t p;
                                        const char *aname;

                                        if ((p = switch_xml_child(conf, "result"))) {
                                                aname = switch_xml_attr(p, "status");
                                                if (aname && !strcasecmp(aname, "not found")) {
                                                        switch_xml_free(xml);
                                                        xml = NULL;
                                                        continue;
                                                }
                                        }
                                }
                                break;
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error[%s]\n", err);
                                switch_xml_free(xml);
                                xml = NULL;
                        }
                }
        }
        switch_thread_rwlock_unlock(B_RWLOCK);

        for (;;) {
                if (!xml) {
                        if (!(xml = switch_xml_root())) {
                                *node = NULL;
                                *root = NULL;
                                return SWITCH_STATUS_FALSE;
                        }
                }

                if ((conf = switch_xml_find_child(xml, "section", "name", section)) && (tag = switch_xml_find_child(conf, tag_name, key_name, key_value))) {
                        if (clone) {
                                char *x = switch_xml_toxml(tag, SWITCH_FALSE);
                                switch_assert(x);
                                *node = *root = switch_xml_parse_str_dynamic(x, SWITCH_FALSE);  /* x will be free()'d in switch_xml_free() */
                                switch_xml_free(xml);
                        } else {
                                *node = tag;
                                *root = xml;
                        }
                        return SWITCH_STATUS_SUCCESS;
                } else {
                        switch_xml_free(xml);
                        xml = NULL;
                        *node = NULL;
                        *root = NULL;
                        if (loops++ > 1) {
                                break;
                        }
                }
        }

        return SWITCH_STATUS_FALSE;
}

switch_xml_locate_domain()

switch_status_t switch_xml_locate_domain	(	const char *	domain_name,
		switch_event_t *	params,
		switch_xml_t *	root,
		switch_xml_t *	domain
	)

Definition at line 1839 of file switch_xml.c.

References switch_assert, switch_event_add_header_string(), switch_event_create, switch_event_destroy(), SWITCH_EVENT_REQUEST_PARAMS, SWITCH_FALSE, SWITCH_STACK_BOTTOM, and switch_xml_locate().

Referenced by switch_xml_locate_group(), and switch_xml_locate_user().

{
        switch_event_t *my_params = NULL;
        switch_status_t status;
        *domain = NULL;

        if (!params) {
                switch_event_create(&my_params, SWITCH_EVENT_REQUEST_PARAMS);
                switch_assert(my_params);
                switch_event_add_header_string(my_params, SWITCH_STACK_BOTTOM, "domain", domain_name);
                params = my_params;
        }

        status = switch_xml_locate("directory", "domain", "name", domain_name, root, domain, params, SWITCH_FALSE);
        if (my_params) {
                switch_event_destroy(&my_params);
        }
        return status;
}

switch_xml_locate_group()

switch_status_t switch_xml_locate_group	(	const char *	group_name,
		const char *	domain_name,
		switch_xml_t *	root,
		switch_xml_t *	domain,
		switch_xml_t *	group,
		switch_event_t *	params
	)

Definition at line 1859 of file switch_xml.c.

References switch_assert, switch_event_add_header_string(), switch_event_create, switch_event_destroy(), SWITCH_EVENT_REQUEST_PARAMS, SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_xml_child(), switch_xml_find_child(), and switch_xml_locate_domain().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_event_t *my_params = NULL;
        switch_xml_t groups = NULL;

        *root = NULL;
        *group = NULL;
        *domain = NULL;

        if (!params) {
                switch_event_create(&my_params, SWITCH_EVENT_REQUEST_PARAMS);
                switch_assert(my_params);
                params = my_params;
        }

        if (group_name) {
                switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "group_name", group_name);
        }

        if (domain_name) {
                switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "domain", domain_name);
        }

        if ((status = switch_xml_locate_domain(domain_name, params, root, domain)) != SWITCH_STATUS_SUCCESS) {
                goto end;
        }

        status = SWITCH_STATUS_FALSE;

        if ((groups = switch_xml_child(*domain, "groups"))) {
                if ((*group = switch_xml_find_child(groups, "group", "name", group_name))) {
                        status = SWITCH_STATUS_SUCCESS;
                }
        }

  end:

        if (my_params) {
                switch_event_destroy(&my_params);
        }

        return status;
}

switch_xml_locate_language_ex()

switch_status_t switch_xml_locate_language_ex	(	switch_xml_t *	root,
		switch_xml_t *	node,
		switch_event_t *	params,
		switch_xml_t *	language,
		switch_xml_t *	phrases,
		switch_xml_t *	macros,
		const char *	str_language
	)

Definition at line 3299 of file switch_xml.c.

References SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_TRUE, switch_xml_child(), switch_xml_find_child(), switch_xml_free(), and switch_xml_locate().

Referenced by switch_xml_locate_language().

                                                                                                                                                                                                                             {
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (switch_xml_locate("languages", NULL, NULL, NULL, root, node, params, SWITCH_TRUE) != SWITCH_STATUS_SUCCESS) {
                switch_xml_t sub_macros;

                if (switch_xml_locate("phrases", NULL, NULL, NULL, root, node, params, SWITCH_TRUE) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Open of languages and phrases failed.\n");
                        goto done;
                }
                if (!(sub_macros = switch_xml_child(*node, "macros"))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't find macros tag.\n");
                        switch_xml_free(*root);
                        *root = NULL;
                        *node = NULL;
                        goto done;
                }
                if (!(*language = switch_xml_find_child(sub_macros, "language", "name", str_language))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't find language %s.\n", str_language);
                        switch_xml_free(*root);
                        *root = NULL;
                        *node = NULL;
                        goto done;
                }
                *macros = *language;
        } else {
                if (!(*language = switch_xml_find_child(*node, "language", "name", str_language))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't find language %s.\n", str_language);
                        switch_xml_free(*root);
                        *root = NULL;
                        goto done;
                }
                if (!(*phrases = switch_xml_child(*language, "phrases"))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't find phrases tag.\n");
                        switch_xml_free(*root);
                        *root = NULL;
                        *node = NULL;
                        *language = NULL;
                        goto done;
                }

                if (!(*macros = switch_xml_child(*phrases, "macros"))) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't find macros tag.\n");
                        switch_xml_free(*root);
                        *root = NULL;
                        *node = NULL;
                        *language = NULL;
                        *phrases = NULL;
                        goto done;
                }
        }
        status = SWITCH_STATUS_SUCCESS;

done:
        return status;
}

switch_xml_locate_user()

switch_status_t switch_xml_locate_user	(	const char *	key,
		const char *	user_name,
		const char *	domain_name,
		const char *	ip,
		switch_xml_t *	root,
		switch_xml_t *	domain,
		switch_xml_t *	user,
		switch_xml_t *	ingroup,
		switch_event_t *	params
	)

Definition at line 2200 of file switch_xml.c.

References find_user_in_tag(), switch_xml::next, switch_assert, switch_event_add_header_string(), switch_event_create, switch_event_destroy(), SWITCH_EVENT_REQUEST_PARAMS, SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_xml_child(), switch_xml_free(), and switch_xml_locate_domain().

Referenced by switch_xml_locate_user_merged().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_event_t *my_params = NULL;
        switch_xml_t group = NULL, groups = NULL, users = NULL;

        *root = NULL;
        *user = NULL;
        *domain = NULL;

        if (ingroup) {
                *ingroup = NULL;
        }

        if (!params) {
                switch_event_create(&my_params, SWITCH_EVENT_REQUEST_PARAMS);
                switch_assert(my_params);
                params = my_params;
        }

        switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "key", key);

        if (user_name) {
                switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "user", user_name);
        }

        if (domain_name) {
                switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "domain", domain_name);
        }

        if (ip) {
                switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "ip", ip);
        }

        if ((status = switch_xml_locate_domain(domain_name, params, root, domain)) != SWITCH_STATUS_SUCCESS) {
                goto end;
        }

        status = SWITCH_STATUS_FALSE;

        if ((groups = switch_xml_child(*domain, "groups"))) {
                for (group = switch_xml_child(groups, "group"); group; group = group->next) {
                        if ((users = switch_xml_child(group, "users"))) {
                                if ((status = find_user_in_tag(users, ip, user_name, key, params, user)) == SWITCH_STATUS_SUCCESS) {
                                        if (ingroup) {
                                                *ingroup = group;
                                        }
                                        break;
                                }
                        }
                }
        }

        if (status != SWITCH_STATUS_SUCCESS) {
                if ((users = switch_xml_child(*domain, "users"))) {
                        status = find_user_in_tag(users, ip, user_name, key, params, user);
                } else {
                        status = find_user_in_tag(*domain, ip, user_name, key, params, user);
                }
        }

  end:

        if (my_params) {
                switch_event_destroy(&my_params);
        }

        if (status != SWITCH_STATUS_SUCCESS && *root) {
                switch_xml_free(*root);
                *root = NULL;
                *domain = NULL;
        }

        return status;
}

switch_xml_locate_user_cache()

static switch_status_t switch_xml_locate_user_cache ( const char *  key, const char *  user_name, const char *  domain_name, switch_xml_t *  user  )

static

Definition at line 2082 of file switch_xml.c.

References SWITCH_CHANNEL_LOG, switch_core_hash_find(), SWITCH_LOG_DEBUG, switch_log_printf(), switch_micro_time_now(), switch_mutex_lock(), switch_mutex_unlock(), switch_snprintf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_TIME_T_FMT, switch_xml_dup(), and time_now().

Referenced by switch_xml_locate_user_merged().

{
        char mega_key[1024];
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_xml_t lookup;

        switch_snprintf(mega_key, sizeof(mega_key), "%s%s%s", key, user_name, domain_name);

        switch_mutex_lock(CACHE_MUTEX);
        if ((lookup = switch_core_hash_find(CACHE_HASH, mega_key))) {
                char *expires_lookup = NULL;

                if ((expires_lookup = switch_core_hash_find(CACHE_EXPIRES_HASH, mega_key))) {
                        switch_time_t time_expires = 0;
                        switch_time_t time_now = 0;

                        time_now = switch_micro_time_now();
                        time_expires = atoll(expires_lookup);
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Cache Info\nTime Now:\t%" SWITCH_TIME_T_FMT "\nExpires:\t%" SWITCH_TIME_T_FMT "\n", time_now, time_expires);
                        if (time_expires < time_now) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Cache expired for %s@%s, doing fresh lookup\n", user_name, domain_name);
                        } else {
                                *user = switch_xml_dup(lookup);
                                status = SWITCH_STATUS_SUCCESS;
                        }
                } else {
                        *user = switch_xml_dup(lookup);
                        status = SWITCH_STATUS_SUCCESS;
                }
        }
        switch_mutex_unlock(CACHE_MUTEX);

        return status;
}

switch_xml_locate_user_in_domain()

switch_status_t switch_xml_locate_user_in_domain	(	const char *	user_name,
		switch_xml_t	domain,
		switch_xml_t *	user,
		switch_xml_t *	ingroup
	)

Definition at line 1942 of file switch_xml.c.

References find_user_in_tag(), switch_xml::next, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_xml_child().

{
        switch_xml_t group = NULL, groups = NULL, users = NULL;
        switch_status_t status = SWITCH_STATUS_FALSE;

        if ((groups = switch_xml_child(domain, "groups"))) {
                for (group = switch_xml_child(groups, "group"); group; group = group->next) {
                        if ((users = switch_xml_child(group, "users"))) {
                                if ((status = find_user_in_tag(users, NULL, user_name, "id", NULL, user)) == SWITCH_STATUS_SUCCESS) {
                                        if (ingroup) {
                                                *ingroup = group;
                                        }
                                        break;
                                }
                        }
                }
        } else {
                if ((users = switch_xml_child(domain, "users"))) {
                        status = find_user_in_tag(users, NULL, user_name, "id", NULL, user);
                } else {
                        status = find_user_in_tag(domain, NULL, user_name, "id", NULL, user);
                }
        }

        return status;
}

switch_xml_new()

switch_xml_t switch_xml_new

(

const char *

name

)

Definition at line 2908 of file switch_xml.c.

References switch_xml::attr, switch_xml_root::attr, switch_xml_root::cur, switch_xml_root::ent, switch_xml_root::err, memset(), switch_xml::name, switch_xml_root::pi, switch_must_malloc(), switch_xml::txt, and switch_xml_root::xml.

Referenced by switch_xml_parse_str().

{
        static const char *ent[] = { "lt;", "<", "gt;", ">", "quot;", """,
                "apos;", "'", "amp;", "&", NULL
        };
        switch_xml_root_t root = (switch_xml_root_t) switch_must_malloc(sizeof(struct switch_xml_root));

        memset(root, '\0', sizeof(struct switch_xml_root));
        root->xml.name = (char *) name;
        root->cur = &root->xml;
        strcpy(root->err, root->xml.txt = (char *) "");
        root->ent = (char **) memcpy(switch_must_malloc(sizeof(ent)), ent, sizeof(ent));
        root->attr = root->pi = (char ***) (root->xml.attr = SWITCH_XML_NIL);
        return &root->xml;
}

switch_xml_open_cfg()

switch_xml_t switch_xml_open_cfg	(	const char *	file_path,
		switch_xml_t *	node,
		switch_event_t *	params
	)

Definition at line 2499 of file switch_xml.c.

References SWITCH_FALSE, SWITCH_STATUS_SUCCESS, switch_xml_locate(), and destroy_xml::xml.

{
        switch_xml_t xml = NULL, cfg = NULL;

        *node = NULL;

        assert(MAIN_XML_ROOT != NULL);

        if (switch_xml_locate("configuration", "configuration", "name", file_path, &xml, &cfg, params, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
                *node = cfg;
        }

        return xml;

}

switch_xml_open_root()

switch_xml_t switch_xml_open_root	(	uint8_t	reload,
		const char **	err
	)

Definition at line 2371 of file switch_xml.c.

References switch_event_create, switch_event_destroy(), switch_event_fire, SWITCH_EVENT_RELOADXML, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, and XML_OPEN_ROOT_FUNCTION.

Referenced by switch_xml_init(), and switch_xml_reload().

{
        switch_xml_t root = NULL;
        switch_event_t *event;

        switch_mutex_lock(XML_LOCK);

        if (XML_OPEN_ROOT_FUNCTION) {
                root = XML_OPEN_ROOT_FUNCTION(reload, err, XML_OPEN_ROOT_FUNCTION_USER_DATA);
        }
        switch_mutex_unlock(XML_LOCK);


        if (root) {
                if (switch_event_create(&event, SWITCH_EVENT_RELOADXML) == SWITCH_STATUS_SUCCESS) {
                        if (switch_event_fire(&event) != SWITCH_STATUS_SUCCESS) {
                                switch_event_destroy(&event);
                        }
                }
        }

        return root;
}

switch_xml_open_tag()

static void switch_xml_open_tag ( switch_xml_root_t  root, char *  name, char *  open_pos, char **  attr  )

static

Definition at line 694 of file switch_xml.c.

References switch_xml::attr, switch_xml_root::cur, switch_xml::name, name, switch_xml::open, switch_xml_add_child(), and switch_xml::txt.

Referenced by switch_xml_parse_str().

{
        switch_xml_t xml;

        if (!root || !root->cur) {
                return;
        }

        xml = root->cur;

        if (xml->name)
                xml = switch_xml_add_child(xml, name, strlen(xml->txt));
        else
                xml->name = name;               /* first open tag */

        xml->attr = attr;
        root->cur = xml;                        /* update tag insertion point */
        root->cur->open = open_pos;
}

switch_xml_parse_file()

switch_xml_t switch_xml_parse_file

(

const char *

file

)

Definition at line 1688 of file switch_xml.c.

References switch_directories::conf_dir, switch_filenames::conf_name, switch_xml::free_path, switch_directories::log_dir, preprocess(), SWITCH_GLOBAL_dirs, SWITCH_GLOBAL_filenames, switch_mprintf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_PATH_SEPARATOR, switch_safe_free, and switch_xml_parse_fd().

Referenced by __switch_xml_open_root().

{
        int fd = -1;
        FILE *write_fd = NULL;
        switch_xml_t xml = NULL;
        char *new_file = NULL;
        char *new_file_tmp = NULL;
        const char *abs, *absw;

        abs = strrchr(file, '/');
        absw = strrchr(file, '\\');
        if (abs || absw) {
                abs > absw ? abs++ : (abs = ++absw);
        } else {
                abs = file;
        }

        switch_mutex_lock(FILE_LOCK);

        if (!(new_file = switch_mprintf("%s%s%s.fsxml", SWITCH_GLOBAL_dirs.log_dir, SWITCH_PATH_SEPARATOR, abs))) {
                goto done;
        }

        if (!(new_file_tmp = switch_mprintf("%s%s%s.fsxml.tmp", SWITCH_GLOBAL_dirs.log_dir, SWITCH_PATH_SEPARATOR, abs))) {
                goto done;
        }

        if ((write_fd = fopen(new_file_tmp, "w+")) == NULL) {
                goto done;
        }

        setvbuf(write_fd, (char *) NULL, _IOFBF, 65536);

        if (preprocess(SWITCH_GLOBAL_dirs.conf_dir, file, write_fd, 0) > -1) {
                fclose(write_fd);
                write_fd = NULL;
                unlink (new_file);

                if ( rename(new_file_tmp,new_file) ) {
                        goto done;
                }

                if ((fd = open(new_file, O_RDONLY, 0)) > -1) {
                        if ((xml = switch_xml_parse_fd(fd))) {
                                if (strcmp(abs, SWITCH_GLOBAL_filenames.conf_name)) {
                                        xml->free_path = new_file;
                                        new_file = NULL;
                                }
                        }

                        close(fd);
                }
        }

  done:

        switch_mutex_unlock(FILE_LOCK);

        if (write_fd) {
                fclose(write_fd);
                write_fd = NULL;
        }

        switch_safe_free(new_file_tmp);
        switch_safe_free(new_file);

        return xml;
}

switch_xml_parse_file_simple()

switch_xml_t switch_xml_parse_file_simple

(

const char *

file

)

Definition at line 1647 of file switch_xml.c.

References switch_xml_root::dynamic, SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(), switch_must_malloc(), switch_xml_parse_str(), and switch_xml_root::xml.

{
        int fd = -1;
        struct stat st;
        switch_ssize_t l;
        void *m;
        switch_xml_root_t root;

        if ((fd = open(file, O_RDONLY, 0)) > -1) {
                if (fstat(fd, &st) == -1 || !st.st_size) {
                        close(fd);
                        goto error;
                }

                m = switch_must_malloc(st.st_size);

                if (!(0 < (l = read(fd, m, st.st_size)))) {
                        free(m);
                        close(fd);
                        goto error;
                }

                if (!(root = (switch_xml_root_t)switch_xml_parse_str((char*)m, l))) {
                        free(m);
                        close(fd);
                        goto error;
                }

                root->dynamic = 1;
                close(fd);

                return &root->xml;
        }

 error:

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error Parsing File [%s]\n", file);

        return NULL;
}

switch_xml_parse_fp()

switch_xml_t switch_xml_parse_fp

(

FILE *

fp

)

Definition at line 1208 of file switch_xml.c.

References switch_xml_root::dynamic, switch_must_malloc(), switch_must_realloc(), SWITCH_XML_BUFSIZE, switch_xml_parse_str(), and switch_xml_root::xml.

{
        switch_xml_root_t root;
        switch_size_t l, len = 0;
        char *s;

        s = (char *) switch_must_malloc(SWITCH_XML_BUFSIZE);

        do {
                len += (l = fread((s + len), 1, SWITCH_XML_BUFSIZE, fp));
                if (l == SWITCH_XML_BUFSIZE) {
                        s = (char *) switch_must_realloc(s, len + SWITCH_XML_BUFSIZE);
                }
        } while (s && l == SWITCH_XML_BUFSIZE);

        if (!s) {
                return NULL;
        }

        if (!(root = (switch_xml_root_t) switch_xml_parse_str(s, len))) {
                free(s);

                return NULL;
        }

        root->dynamic = 1;                      /* so we know to free s in switch_xml_free() */

        return &root->xml;
}

switch_xml_parse_section_string()

switch_xml_section_t switch_xml_parse_section_string

(

const char *

str

)

Definition at line 264 of file switch_xml.c.

References buf, name, xml_section_t::section, and SWITCH_XML_SECTION_RESULT.

Referenced by switch_xml_locate().

{
        size_t x;
        char buf[1024] = "";
        /*switch_xml_section_t sections = SWITCH_XML_SECTION_RESULT; */
        uint32_t sections = SWITCH_XML_SECTION_RESULT;

        if (str) {
                for (x = 0; x < strlen(str); x++) {
                        buf[x] = (char) tolower((int) str[x]);
                }
                for (x = 0;; x++) {
                        if (!SECTIONS[x].name) {
                                break;
                        }
                        if (strstr(buf, SECTIONS[x].name)) {
                                sections |= SECTIONS[x].section;
                        }
                }
        }
        return (switch_xml_section_t) sections;
}

switch_xml_parse_str()

switch_xml_t switch_xml_parse_str	(	char *	s,
		switch_size_t	len
	)

Definition at line 1053 of file switch_xml.c.

References switch_xml_root::attr, switch_xml_root::cur, switch_xml_root::e, switch_xml_root::ent, switch_xml::flags, switch_xml_root::m, switch_xml::name, switch_xml_root::s, switch_must_malloc(), switch_must_realloc(), SWITCH_XML_CDATA, switch_xml_char_content(), switch_xml_close_tag(), switch_xml_decode(), switch_xml_err(), switch_xml_free_attr(), switch_xml_internal_dtd(), switch_xml_new(), switch_xml_open_tag(), switch_xml_proc_inst(), switch_xml_str2utf8(), SWITCH_XML_TXTM, SWITCH_XML_WS, switch_xml_root::u, and switch_xml_root::xml.

Referenced by switch_xml_parse_fd(), switch_xml_parse_file_simple(), switch_xml_parse_fp(), and switch_xml_parse_str_dynamic().

{
        switch_xml_root_t root = (switch_xml_root_t) switch_xml_new(NULL);
        char q, e, *d, **attr, **a = NULL;      /* initialize a to avoid compile warning */
        int l, i, j;

        root->m = s;
        if (!len)
                return switch_xml_err(root, s, "root tag missing");
        root->u = switch_xml_str2utf8(&s, &len);        /* convert utf-16 to utf-8 */
        root->e = (root->s = s) + len;  /* record start and end of work area */

        e = s[len - 1];                         /* save end char */
        s[len - 1] = '\0';                      /* turn end char into null terminator */

        while (*s && *s != '<')
                s++;                                    /* find first tag */
        if (!*s)
                return switch_xml_err(root, s, "root tag missing");

        for (;;) {
                attr = (char **) SWITCH_XML_NIL;
                d = ++s;

                if (isalpha((int) (*s)) || *s == '_' || *s == ':' || (int8_t) * s < '\0') {     /* new tag */
                        if (!root->cur)
                                return switch_xml_err(root, d, "markup outside of root element");

                        s += strcspn(s, SWITCH_XML_WS "/>");
                        while (isspace((int) (*s)))
                                *(s++) = '\0';  /* null terminate tag name */

                        if (*s && *s != '/' && *s != '>')       /* find tag in default attr list */
                                for (i = 0; (a = root->attr[i]) && strcmp(a[0], d); i++);

                        for (l = 0; *s && *s != '/' && *s != '>'; l += 2) {     /* new attrib */
                                attr = (l) ? (char **) switch_must_realloc(attr, (l + 4) * sizeof(char *))
                                        : (char **) switch_must_malloc(4 * sizeof(char *));     /* allocate space */
                                attr[l + 3] = (l) ? (char *) switch_must_realloc(attr[l + 1], (l / 2) + 2)
                                        : (char *) switch_must_malloc(2);       /* mem for list of maloced vals */
                                strcpy(attr[l + 3] + (l / 2), " ");     /* value is not malloced */
                                attr[l + 2] = NULL;     /* null terminate list */
                                attr[l + 1] = (char *) "";      /* temporary attribute value */
                                attr[l] = s;    /* set attribute name */

                                s += strcspn(s, SWITCH_XML_WS "=/>");
                                if (*s == '=' || isspace((int) (*s))) {
                                        *(s++) = '\0';  /* null terminate tag attribute name */
                                        q = *(s += strspn(s, SWITCH_XML_WS "="));
                                        if (q == '"' || q == '\'') {    /* attribute value */
                                                attr[l + 1] = ++s;
                                                while (*s && *s != q)
                                                        s++;
                                                if (*s)
                                                        *(s++) = '\0';  /* null terminate attribute val */
                                                else {
                                                        switch_xml_free_attr(attr);
                                                        return switch_xml_err(root, d, "missing %c", q);
                                                }

                                                for (j = 1; a && a[j] && strcmp(a[j], attr[l]); j += 3);
                                                attr[l + 1] = switch_xml_decode(attr[l + 1], root->ent, (a && a[j]) ? *a[j + 2] : ' ');
                                                if (attr[l + 1] < d || attr[l + 1] > s)
                                                        attr[l + 3][l / 2] = SWITCH_XML_TXTM;   /* value malloced */
                                        }
                                }
                                while (isspace((int) (*s)))
                                        s++;
                        }

                        if (*s == '/') {        /* self closing tag */
                                *(s++) = '\0';
                                if ((*s && *s != '>') || (!*s && e != '>')) {
                                        if (l)
                                                switch_xml_free_attr(attr);
                                        return switch_xml_err(root, d, "missing >");
                                }
                                switch_xml_open_tag(root, d, s + 1, attr);
                                switch_xml_close_tag(root, d, s, NULL);
                        } else if ((q = *s) == '>' || (!*s && e == '>')) {      /* open tag */
                                *s = '\0';              /* temporarily null terminate tag name */
                                switch_xml_open_tag(root, d, s, attr);
                                *s = q;
                        } else {
                                if (l)
                                        switch_xml_free_attr(attr);
                                return switch_xml_err(root, d, "missing >");
                        }
                } else if (*s == '/') { /* close tag */
                        char *close_pos = d - 1;
                        s += strcspn(d = s + 1, SWITCH_XML_WS ">") + 1;
                        if (!(q = *s) && e != '>')
                                return switch_xml_err(root, d, "missing >");
                        *s = '\0';                      /* temporarily null terminate tag name */
                        if (switch_xml_close_tag(root, d, s, close_pos))
                                return &root->xml;
                        if (isspace((int) (*s = q)))
                                s += strspn(s, SWITCH_XML_WS);
                } else if (!strncmp(s, "!--", 3)) {     /* xml comment */
                        if (!(s = strstr(s + 3, "--")) || (*(s += 2) != '>' && *s) || (!*s && e != '>'))
                                return switch_xml_err(root, d, "unclosed <!--");
                } else if (!strncmp(s, "![CDATA[", 8)) {        /* cdata */
                        if ((s = strstr(s, "]]>"))) {
                                if (root->cur) {
                                        root->cur->flags |= SWITCH_XML_CDATA;
                                }
                                switch_xml_char_content(root, d + 8, (s += 2) - d - 10, 'c');
                        } else {
                                return switch_xml_err(root, d, "unclosed <![CDATA[");
                        }
                } else if (!strncmp(s, "!DOCTYPE", 8)) {        /* dtd */
                        for (l = 0; *s && ((!l && *s != '>') || (l && (*s != ']' || *(s + strspn(s + 1, SWITCH_XML_WS) + 1) != '>'))); l = (*s == '[') ? 1 : l)
                                s += strcspn(s + 1, "[]>") + 1;
                        if (!*s && e != '>')
                                return switch_xml_err(root, d, "unclosed <!DOCTYPE");
                        d = (l) ? strchr(d, '[') + 1 : d;
                        if (l && !switch_xml_internal_dtd(root, d, s++ - d))
                                return &root->xml;
                } else if (*s == '?') { /* <?...?> processing instructions */
                        do {
                                s = strchr(s, '?');
                        } while (s && *(++s) && *s != '>');
                        if (!s || (!*s && e != '>'))
                                return switch_xml_err(root, d, "unclosed <?");
                        else
                                switch_xml_proc_inst(root, d + 1, s - d - 2);
                } else
                        return switch_xml_err(root, d, "unexpected <");

                if (!s || !*s)
                        break;
                *s = '\0';
                d = ++s;
                if (*s && *s != '<') {  /* tag character content */
                        while (*s && *s != '<')
                                s++;
                        if (*s)
                                switch_xml_char_content(root, d, s - d, '&');
                        else
                                break;
                } else if (!*s)
                        break;
        }

        if (!root->cur)
                return &root->xml;
        else if (!root->cur->name)
                return switch_xml_err(root, d, "root tag missing");
        else
                return switch_xml_err(root, d, "unclosed tag <%s>", root->cur->name);
}

switch_xml_parse_str_dynamic()

switch_xml_t switch_xml_parse_str_dynamic	(	char *	s,
		switch_bool_t	dup
	)

Definition at line 1033 of file switch_xml.c.

References switch_xml_root::dynamic, switch_assert, switch_must_strdup(), switch_xml_parse_str(), and switch_xml_root::xml.

Referenced by switch_xml_dup(), and switch_xml_locate().

{
        switch_xml_root_t root;
        char *data;

        switch_assert(s);
        data = dup ? switch_must_strdup(s) : s;

        if ((root = (switch_xml_root_t) switch_xml_parse_str(data, strlen(data)))) {
                root->dynamic = 1;              /* Make sure we free the memory is switch_xml_free() */
                return &root->xml;
        } else {
                if (dup) {
                        free(data);
                }
                return NULL;
        }
}

switch_xml_pi()

const char** switch_xml_pi	(	switch_xml_t	xml,
		const char *	target
	)

Definition at line 548 of file switch_xml.c.

References switch_xml::parent, switch_xml_root::pi, SWITCH_XML_NIL, and switch_xml_root::xml.

{
        switch_xml_root_t root = (switch_xml_root_t) xml;
        int i = 0;

        if (!root) {
                return (const char **) SWITCH_XML_NIL;
        }

        while (root && root->xml.parent) {
                root = (switch_xml_root_t) root->xml.parent;    /* root tag */
        }

        if (!root || !root->pi) {
                return (const char **) SWITCH_XML_NIL;
        }

        while (root->pi[i] && strcmp(target, root->pi[i][0])) {
                i++;                                    /* find target */
        }

        return (const char **) ((root->pi[i]) ? root->pi[i] + 1 : SWITCH_XML_NIL);
}

switch_xml_proc_inst()

static void switch_xml_proc_inst ( switch_xml_root_t  root, char *  s, switch_size_t  len  )

static

Definition at line 783 of file switch_xml.c.

References switch_xml::name, switch_xml_root::pi, switch_xml_root::standalone, switch_must_malloc(), switch_must_realloc(), switch_must_strdup(), SWITCH_XML_WS, target, and switch_xml_root::xml.

Referenced by switch_xml_internal_dtd(), and switch_xml_parse_str().

{
        int i = 0, j = 1;
        char *target = s;
        char **sstmp;
        char *stmp;

        s[len] = '\0';                          /* null terminate instruction */
        if (*(s += strcspn(s, SWITCH_XML_WS))) {
                *s = '\0';                              /* null terminate target */
                s += strspn(s + 1, SWITCH_XML_WS) + 1;  /* skip whitespace after target */
        }

        if (!root)
                return;

        if (!strcmp(target, "xml")) {   /* <?xml ... ?> */
                if ((s = strstr(s, "standalone")) && !strncmp(s + strspn(s + 10, SWITCH_XML_WS "='\"") + 10, "yes", 3))
                        root->standalone = 1;
                return;
        }

        if (root->pi == (char ***)(SWITCH_XML_NIL) || !root->pi || !root->pi[0]) {
                root->pi = (char ***) switch_must_malloc(sizeof(char **));
                *(root->pi) = NULL;             /* first pi */
        }

        while (root->pi[i] && strcmp(target, root->pi[i][0]))
                i++;                                    /* find target */
        if (!root->pi[i]) {                     /* new target */
                char ***ssstmp = (char ***) switch_must_realloc(root->pi, sizeof(char **) * (i + 2));

                root->pi = ssstmp;
                if (!root->pi)
                        return;
                root->pi[i] = (char **) switch_must_malloc(sizeof(char *) * 3);
                root->pi[i][0] = target;
                root->pi[i][1] = (char *) (root->pi[i + 1] = NULL);     /* terminate pi list */
                root->pi[i][2] = switch_must_strdup("");        /* empty document position list */
        }

        while (root->pi[i][j])
                j++;                                    /* find end of instruction list for this target */
        sstmp = (char **) switch_must_realloc(root->pi[i], sizeof(char *) * (j + 3));
        root->pi[i] = sstmp;
        stmp = (char *) switch_must_realloc(root->pi[i][j + 1], j + 1);
        root->pi[i][j + 2] = stmp;
        strcpy(root->pi[i][j + 2] + j - 1, (root->xml.name) ? ">" : "<");
        root->pi[i][j + 1] = NULL;      /* null terminate pi list for this target */
        root->pi[i][j] = s;                     /* set instruction */
}

switch_xml_set_binding_sections()

void switch_xml_set_binding_sections	(	switch_xml_binding_t *	binding,
		switch_xml_section_t	sections
	)

Definition at line 336 of file switch_xml.c.

References switch_xml_binding::sections, and switch_assert.

{
        switch_assert(binding);
        binding->sections = sections;
}

switch_xml_set_binding_user_data()

void switch_xml_set_binding_user_data	(	switch_xml_binding_t *	binding,
		void *	user_data
	)

Definition at line 342 of file switch_xml.c.

References switch_assert, and switch_xml_binding::user_data.

{
        switch_assert(binding);
        binding->user_data = user_data;
}

switch_xml_str2utf8()

static char* switch_xml_str2utf8 ( char **  s, switch_size_t *  len  )

static

Definition at line 970 of file switch_xml.c.

References b, switch_must_malloc(), switch_must_realloc(), and SWITCH_XML_BUFSIZE.

Referenced by switch_xml_parse_str().

{
        char *u;
        switch_size_t l = 0, sl, max = *len;
        long c, d;
        int b, be = (**s == '\xFE') ? 1 : (**s == '\xFF') ? 0 : -1;

        if (be == -1)
                return NULL;                    /* not UTF-16 */

        if (*len <= 3)
                return NULL;

        u = (char *) switch_must_malloc(max);
        for (sl = 2; sl < *len - 1; sl += 2) {
                c = (be) ? (((*s)[sl] & 0xFF) << 8) | ((*s)[sl + 1] & 0xFF)     /* UTF-16BE */
                        : (((*s)[sl + 1] & 0xFF) << 8) | ((*s)[sl] & 0xFF);     /* UTF-16LE */
                if (c >= 0xD800 && c <= 0xDFFF && (sl += 2) < *len - 1) {       /* high-half */
                        d = (be) ? (((*s)[sl] & 0xFF) << 8) | ((*s)[sl + 1] & 0xFF)
                                : (((*s)[sl + 1] & 0xFF) << 8) | ((*s)[sl] & 0xFF);
                        c = (((c & 0x3FF) << 10) | (d & 0x3FF)) + 0x10000;
                }

                while (l + 6 > max) {
                        char *tmp;
                        tmp = (char *) switch_must_realloc(u, max += SWITCH_XML_BUFSIZE);
                        u = tmp;
                }
                if (c < 0x80)
                        u[l++] = (char) c;      /* US-ASCII subset */
                else {                                  /* multi-byte UTF-8 sequence */
                        for (b = 0, d = c; d; d /= 2)
                                b++;                    /* bits in c */
                        b = (b - 2) / 5;        /* bytes in payload */
                        u[l++] = (char) ((0xFF << (7 - b)) | (c >> (6 * b)));   /* head */
                        while (b)
                                u[l++] = (char) (0x80 | ((c >> (6 * --b)) & 0x3F));     /* payload */
                }
        }
        return *s = (char *) switch_must_realloc(u, *len = l);
}

switch_xml_tohtml_ex()

char* switch_xml_tohtml_ex	(	switch_xml_t	xml,
		switch_bool_t	prn_header,
		switch_bool_t	use_utf8_encoding
	)

Definition at line 2741 of file switch_xml.c.

References switch_must_malloc(), switch_safe_free, switch_xml_ampencode(), SWITCH_XML_BUFSIZE, and switch_xml_toxml_buf_ex().

{
        char *r, *s, *h;
        switch_size_t rlen = 0;
        switch_size_t len = SWITCH_XML_BUFSIZE;

        s = (char *) switch_must_malloc(SWITCH_XML_BUFSIZE);
        h = (char *) switch_must_malloc(SWITCH_XML_BUFSIZE);

        r = switch_xml_toxml_buf_ex(xml, s, SWITCH_XML_BUFSIZE, 0, prn_header, use_utf8_encoding);
        h = switch_xml_ampencode(r, 0, &h, &rlen, &len, 1, use_utf8_encoding);
        switch_safe_free(r);
        return h;
}

switch_xml_toxml_buf_ex()

char* switch_xml_toxml_buf_ex	(	switch_xml_t	xml,
		char *	buf,
		switch_size_t	buflen,
		switch_size_t	offset,
		switch_bool_t	prn_header,
		switch_bool_t	use_utf8_encoding
	)

Definition at line 2758 of file switch_xml.c.

References switch_xml::attr, buf, buflen, count, memset(), switch_xml::name, switch_xml::parent, switch_must_realloc(), SWITCH_XML_BUFSIZE, switch_xml_toxml_r(), and destroy_xml::xml.

Referenced by switch_xml_tohtml_ex(), switch_xml_toxml_ex(), and switch_xml_toxml_nolock_ex().

{
        switch_xml_t p = (xml) ? xml->parent : NULL;
        switch_xml_root_t root = (switch_xml_root_t) xml;
        switch_size_t len = 0, max = buflen;
        char *s, *t, *n;
        int i, j, k;
        uint32_t count = 0;

        s = buf;
        assert(s != NULL);
        memset(s, 0, max);
        len += offset;
        if (prn_header) {
                len += sprintf(s + len, "<?xml version=\"1.0\"?>\n");
        }

        if (!xml || !xml->name) {
                return (char *) switch_must_realloc(s, len + 1);
        }

        while (root->xml.parent) {
                root = (switch_xml_root_t) root->xml.parent;    /* root tag */
        }

        for (i = 0; !p && root->pi[i]; i++) {   /* pre-root processing instructions */
                for (k = 2; root->pi[i][k - 1]; k++);
                for (j = 1; (n = root->pi[i][j]); j++) {
                        if (root->pi[i][k][j - 1] == '>') {
                                continue;               /* not pre-root */
                        }
                        while (len + strlen(t = root->pi[i][0]) + strlen(n) + 7 > max) {
                                s = (char *) switch_must_realloc(s, max += SWITCH_XML_BUFSIZE);
                        }
                        len += sprintf(s + len, "<?%s%s%s?>", t, *n ? " " : "", n);
                }
        }

        s = switch_xml_toxml_r(xml, &s, &len, &max, 0, root->attr, &count, 1, use_utf8_encoding);

        for (i = 0; !p && root->pi[i]; i++) {   /* post-root processing instructions */
                for (k = 2; root->pi[i][k - 1]; k++);
                for (j = 1; (n = root->pi[i][j]); j++) {
                        if (root->pi[i][k][j - 1] == '<') {
                                continue;               /* not post-root */
                        }
                        while (len + strlen(t = root->pi[i][0]) + strlen(n) + 7 > max) {
                                s = (char *) switch_must_realloc(s, max += SWITCH_XML_BUFSIZE);
                        }
                        len += sprintf(s + len, "\n<?%s%s%s?>", t, *n ? " " : "", n);
                }
        }

        return (char *) switch_must_realloc(s, len + 1);
}

switch_xml_toxml_ex()

char* switch_xml_toxml_ex	(	switch_xml_t	xml,
		switch_bool_t	prn_header,
		switch_bool_t	use_utf8_encoding
	)

Definition at line 2730 of file switch_xml.c.

References switch_must_malloc(), SWITCH_XML_BUFSIZE, and switch_xml_toxml_buf_ex().

{
        char *r, *s;

        s = (char *) switch_must_malloc(SWITCH_XML_BUFSIZE);

        r = switch_xml_toxml_buf_ex(xml, s, SWITCH_XML_BUFSIZE, 0, prn_header, use_utf8_encoding);

        return r;
}

switch_xml_toxml_nolock_ex()

char* switch_xml_toxml_nolock_ex	(	switch_xml_t	xml,
		switch_bool_t	prn_header,
		switch_bool_t	use_utf8_encoding
	)

Definition at line 2723 of file switch_xml.c.

References switch_must_malloc(), SWITCH_XML_BUFSIZE, and switch_xml_toxml_buf_ex().

{
        char *s = (char *) switch_must_malloc(SWITCH_XML_BUFSIZE);

        return switch_xml_toxml_buf_ex(xml, s, SWITCH_XML_BUFSIZE, 0, prn_header, use_utf8_encoding);
}

switch_xml_toxml_r()

static char* switch_xml_toxml_r ( switch_xml_t  xml, char **  s, switch_size_t *  len, switch_size_t *  max, switch_size_t  start, char ***  attr, uint32_t *  count, int  isroot, switch_bool_t  use_utf8_encoding  )

static

Definition at line 2623 of file switch_xml.c.

References switch_xml::attr, switch_xml::child, count, switch_xml::name, switch_xml::off, switch_xml::ordered, switch_xml::parent, switch_must_realloc(), switch_xml_ampencode(), switch_xml_attr(), SWITCH_XML_BUFSIZE, switch_xml::txt, and XML_INDENT.

Referenced by switch_xml_toxml_buf_ex().

{
        int i, j;
        char *txt;
        switch_size_t off;
        uint32_t lcount;
        uint32_t loops = 0;

  tailrecurse:
        off = 0;
        txt = "";

        if (loops++) {
                isroot = 0;
        }

        if (!isroot && xml->parent) {
                txt = (char *) xml->parent->txt;
        }

        /* parent character content up to this tag */
        *s = switch_xml_ampencode(txt + start, xml->off - start, s, len, max, 0, use_utf8_encoding);

        while (*len + strlen(xml->name) + 5 + (strlen(XML_INDENT) * (*count)) + 1 > *max) {     /* reallocate s */
                *s = (char *) switch_must_realloc(*s, *max += SWITCH_XML_BUFSIZE);
        }

        if (*len && *(*s + (*len) - 1) == '>') {
                *len += sprintf(*s + *len, "\n");       /* indent */
        }
        for (lcount = 0; lcount < *count; lcount++) {
                *len += sprintf(*s + *len, "%s", XML_INDENT);   /* indent */
        }

        *len += sprintf(*s + *len, "<%s", xml->name);   /* open tag */
        for (i = 0; xml->attr[i]; i += 2) {     /* tag attributes */
                if (switch_xml_attr(xml, xml->attr[i]) != xml->attr[i + 1])
                        continue;
                while (*len + strlen(xml->attr[i]) + 7 + (strlen(XML_INDENT) * (*count)) > *max) {      /* reallocate s */
                        *s = (char *) switch_must_realloc(*s, *max += SWITCH_XML_BUFSIZE);
                }

                *len += sprintf(*s + *len, " %s=\"", xml->attr[i]);
                switch_xml_ampencode(xml->attr[i + 1], 0, s, len, max, 1, use_utf8_encoding);
                *len += sprintf(*s + *len, "\"");
        }

        for (i = 0; attr[i] && strcmp(attr[i][0], xml->name); i++);
        for (j = 1; attr[i] && attr[i][j]; j += 3) {    /* default attributes */
                if (!attr[i][j + 1] || switch_xml_attr(xml, attr[i][j]) != attr[i][j + 1])
                        continue;                       /* skip duplicates and non-values */
                while (*len + strlen(attr[i][j]) + 8 + (strlen(XML_INDENT) * (*count)) > *max) {        /* reallocate s */
                        *s = (char *) switch_must_realloc(*s, *max += SWITCH_XML_BUFSIZE);
                }

                *len += sprintf(*s + *len, " %s=\"", attr[i][j]);
                switch_xml_ampencode(attr[i][j + 1], 0, s, len, max, 1, use_utf8_encoding);
                *len += sprintf(*s + *len, "\"");
        }

        *len += sprintf(*s + *len, (xml->child || xml->txt) ? ">" : "/>\n");

        if (xml->child) {
                (*count)++;
                *s = switch_xml_toxml_r(xml->child, s, len, max, 0, attr, count, 0, use_utf8_encoding);

        } else {
                *s = switch_xml_ampencode(xml->txt, 0, s, len, max, 0, use_utf8_encoding);      /* data */
        }

        while (*len + strlen(xml->name) + 5 + (strlen(XML_INDENT) * (*count)) > *max) { /* reallocate s */
                *s = (char *) switch_must_realloc(*s, *max += SWITCH_XML_BUFSIZE);
        }

        if (xml->child || xml->txt) {
                if (*(*s + (*len) - 1) == '\n') {
                        for (lcount = 0; lcount < *count; lcount++) {
                                *len += sprintf(*s + *len, "%s", XML_INDENT);   /* indent */
                        }
                }
                *len += sprintf(*s + (*len), "</%s>\n", xml->name);     /* close tag */
        }

        while (txt[off] && off < xml->off)
                off++;                                  /* make sure off is within bounds */

        if (!isroot && xml->ordered) {
                xml = xml->ordered;
                start = off;
                goto tailrecurse;
/*
                return switch_xml_toxml_r(xml->ordered, s, len, max, off, attr, count, use_utf8_encoding);
*/
        } else {
                if (*count > 0)
                        (*count)--;
                return switch_xml_ampencode(txt + off, 0, s, len, max, 0, use_utf8_encoding);
        }
}

switch_xml_unbind_search_function()

switch_status_t switch_xml_unbind_search_function

(

switch_xml_binding_t **

binding

)

Definition at line 287 of file switch_xml.c.

References switch_xml_binding::next, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_rwlock_unlock(), and switch_thread_rwlock_wrlock().

{
        switch_xml_binding_t *ptr, *last = NULL;
        switch_status_t status = SWITCH_STATUS_FALSE;


        switch_thread_rwlock_wrlock(B_RWLOCK);
        for (ptr = BINDINGS; ptr; ptr = ptr->next) {
                if (ptr == *binding) {
                        if (last) {
                                last->next = (*binding)->next;
                        } else {
                                BINDINGS = (*binding)->next;
                        }
                        status = SWITCH_STATUS_SUCCESS;
                        break;
                }
                last = ptr;
        }
        switch_thread_rwlock_unlock(B_RWLOCK);

        return status;
}

switch_xml_unbind_search_function_ptr()

switch_status_t switch_xml_unbind_search_function_ptr

(

switch_xml_search_function_t

function

)

Definition at line 311 of file switch_xml.c.

References switch_xml_binding::function, switch_xml_binding::next, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_thread_rwlock_unlock(), and switch_thread_rwlock_wrlock().

{
        switch_xml_binding_t *ptr, *last = NULL;
        switch_status_t status = SWITCH_STATUS_FALSE;

        switch_thread_rwlock_wrlock(B_RWLOCK);
        for (ptr = BINDINGS; ptr; ptr = ptr->next) {
                if (ptr->function == function) {
                        status = SWITCH_STATUS_SUCCESS;

                        if (last) {
                                last->next = ptr->next;
                        } else {
                                BINDINGS = ptr->next;
                                last = NULL;
                                continue;
                        }
                }
                last = ptr;
        }
        switch_thread_rwlock_unlock(B_RWLOCK);

        return status;
}

switch_xml_user_cache()

static void switch_xml_user_cache ( const char *  key, const char *  user_name, const char *  domain_name, switch_xml_t  user, switch_time_t  expires  )

static

Definition at line 2117 of file switch_xml.c.

References switch_core_hash_delete(), switch_core_hash_find(), switch_core_hash_insert, switch_core_hash_insert_alloc, switch_mutex_lock(), switch_mutex_unlock(), switch_safe_free, switch_snprintf(), SWITCH_TIME_T_FMT, switch_xml_dup(), and switch_xml_free().

Referenced by switch_xml_locate_user_merged().

{
        char mega_key[1024];
        switch_xml_t lookup;
        char *expires_lookup;

        switch_snprintf(mega_key, sizeof(mega_key), "%s%s%s", key, user_name, domain_name);

        switch_mutex_lock(CACHE_MUTEX);
        if ((lookup = switch_core_hash_find(CACHE_HASH, mega_key))) {
                switch_core_hash_delete(CACHE_HASH, mega_key);
                switch_xml_free(lookup);
        }
        if ((expires_lookup = switch_core_hash_find(CACHE_EXPIRES_HASH, mega_key))) {
                switch_core_hash_delete(CACHE_EXPIRES_HASH, mega_key);
                switch_safe_free(expires_lookup);
        }
        if (expires) {
                char *expires_val = (char *)switch_core_hash_insert_alloc(CACHE_EXPIRES_HASH, mega_key, 22);
                if (!snprintf(expires_val, 22, "%" SWITCH_TIME_T_FMT, expires)) {
                        switch_core_hash_delete(CACHE_EXPIRES_HASH, mega_key);
                        switch_safe_free(expires_val);
                }
        }
        switch_core_hash_insert(CACHE_HASH, mega_key, switch_xml_dup(user));
        switch_mutex_unlock(CACHE_MUTEX);
}

switch_xml_vget()

static switch_xml_t switch_xml_vget ( switch_xml_t  xml, va_list  ap  )

static

Definition at line 518 of file switch_xml.c.

References name, switch_xml_child(), and switch_xml_idx().

Referenced by switch_xml_get().

{
        char *name = va_arg(ap, char *);
        int idx = -1;

        if (name && *name) {
                idx = va_arg(ap, int);
                xml = switch_xml_child(xml, name);
        }
        return (idx < 0) ? xml : switch_xml_vget(switch_xml_idx(xml, idx), ap);
}

Variable Documentation

B_RWLOCK

switch_thread_rwlock_t* B_RWLOCK = NULL

static

Definition at line 233 of file switch_xml.c.

BINDINGS

switch_xml_binding_t* BINDINGS = NULL

static

Definition at line 229 of file switch_xml.c.

CACHE_EXPIRES_HASH

switch_hash_t* CACHE_EXPIRES_HASH = NULL

static

Definition at line 245 of file switch_xml.c.

CACHE_HASH

switch_hash_t* CACHE_HASH = NULL

static

Definition at line 244 of file switch_xml.c.

CACHE_MUTEX

switch_mutex_t* CACHE_MUTEX = NULL

static

Definition at line 235 of file switch_xml.c.

FILE_LOCK

switch_mutex_t* FILE_LOCK = NULL

static

Definition at line 237 of file switch_xml.c.

MAIN_XML_ROOT

switch_xml_t MAIN_XML_ROOT = NULL

static

Definition at line 230 of file switch_xml.c.

Referenced by switch_xml_destroy(), switch_xml_root(), and switch_xml_set_root().

not_so_threadsafe_error_buffer

char not_so_threadsafe_error_buffer[256] = ""

static

Definition at line 2328 of file switch_xml.c.

Referenced by __switch_xml_open_root().

REFLOCK

switch_mutex_t* REFLOCK = NULL

static

Definition at line 236 of file switch_xml.c.

SECTIONS

struct xml_section_t SECTIONS[]

static

Initial value:

= {
        {"result", SWITCH_XML_SECTION_RESULT},
        {"config", SWITCH_XML_SECTION_CONFIG},
        {"directory", SWITCH_XML_SECTION_DIRECTORY},
        {"dialplan", SWITCH_XML_SECTION_DIALPLAN},
        {"languages", SWITCH_XML_SECTION_LANGUAGES},
        {"chatplan", SWITCH_XML_SECTION_CHATPLAN},
        {"channels", SWITCH_XML_SECTION_CHANNELS},
        {NULL, 0}
}

Definition at line 253 of file switch_xml.c.

SWITCH_XML_NIL

char* SWITCH_XML_NIL[] = { NULL }

Definition at line 219 of file switch_xml.c.

Referenced by switch_xml_add_child(), switch_xml_internal_dtd(), switch_xml_pi(), and switch_xml_set_attr().

XML_LOCK

switch_mutex_t* XML_LOCK = NULL

static

Definition at line 234 of file switch_xml.c.

XML_MEMORY_POOL

switch_memory_pool_t* XML_MEMORY_POOL = NULL

static

Definition at line 231 of file switch_xml.c.

XML_OPEN_ROOT_FUNCTION

switch_xml_open_root_function_t XML_OPEN_ROOT_FUNCTION = (switch_xml_open_root_function_t)__switch_xml_open_root

static

Definition at line 241 of file switch_xml.c.

Referenced by switch_xml_open_root().

XML_OPEN_ROOT_FUNCTION_USER_DATA

void* XML_OPEN_ROOT_FUNCTION_USER_DATA = NULL

static

Definition at line 242 of file switch_xml.c.