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

Include dependency graph for switch_xml.c:

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

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)

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)

char *	switch_xml_toxml_nolock (switch_xml_t xml, switch_bool_t prn_header)

char *	switch_xml_toxml (switch_xml_t xml, switch_bool_t prn_header)

char *	switch_xml_tohtml (switch_xml_t xml, switch_bool_t prn_header)

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

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_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_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_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 (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
static switch_bool_t	USE_UTF_8_ENCODING = SWITCH_TRUE

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

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

Definition at line 103 of file switch_xml.c.

Referenced by switch_xml_err().

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

Definition at line 102 of file switch_xml.c.

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

#define XML_INDENT " "

Definition at line 2503 of file switch_xml.c.

Referenced by switch_xml_toxml_r().

Typedef Documentation

typedef struct switch_xml_root* switch_xml_root_t

Definition at line 146 of file switch_xml.c.

Function Documentation

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

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

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

static

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

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

static

Definition at line 1869 of file switch_xml.c.

References switch_xml::next, 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");
 
                         int go = 1;
 
                         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)) {
                                         go = 0;
                                         break;
                                 }
                         }
 
                         if (go) {
                                 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);
                         }
                 }
         }
 
 }

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

static

Definition at line 1184 of file switch_xml.c.

References buf, ep, 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 (!(var = 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;
 }

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

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

static

Definition at line 1339 of file switch_xml.c.

References buf, cur, expand_vars(), memset(), preprocess_exec(), preprocess_exec_set(), preprocess_glob(), 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_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 (name && val) {
                                         switch_core_set_variable(name, val);
                                 }
 
                         } else if (!strcasecmp(tcmd, "exec-set")) {
                                 preprocess_exec_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 (name && val) {
                                                 switch_core_set_variable(name, val);
                                         }
 
                                 } else if (!strcasecmp(cmd, "exec-set")) {
                                         preprocess_exec_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;
 }

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

static

Definition at line 1232 of file switch_xml.c.

References buf, 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;
 
 }

static void preprocess_exec_set ( char * keyval )

static

Definition at line 108 of file switch_xml.c.

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

Referenced by preprocess().

 {
         char *key = keyval;
         char *val = strchr(key, '=');
 
         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_fork(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);
         }
 }

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

static

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

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

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

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

static

Definition at line 2401 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(), 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, "&amp;");
                                 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_UTF_8_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_UTF_8_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;
 }

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

Definition at line 434 of file switch_xml.c.

References switch_xml_root::attr, if(), 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 */
 }

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

Definition at line 426 of file switch_xml.c.

References switch_xml_attr().

 {
         const char *ret = switch_xml_attr(xml, attr);
 
         return ret ? 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 302 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;
 }

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

static

Definition at line 651 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_t switch_xml_child	(	switch_xml_t	xml,
		const char *	name
	)

Definition at line 409 of file switch_xml.c.

References switch_xml::child, 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(), 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;
 }

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

static

Definition at line 689 of file switch_xml.c.

References 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 = root->cur->parent;
         return NULL;
 }

switch_xml_t switch_xml_cut ( switch_xml_t xml )

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

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

static

Definition at line 538 of file switch_xml.c.

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

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

static

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

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

static

Definition at line 510 of file switch_xml.c.

References switch_xml_root::err, 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;
 }

const char* switch_xml_error ( switch_xml_t xml )

Definition at line 2786 of file switch_xml.c.

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_t switch_xml_find_child	(	switch_xml_t	node,
		const char *	childname,
		const char *	attrname,
		const char *	value
	)

Definition at line 334 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().

 {
         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 && value && !strcasecmp(aname, value)) {
                         break;
                 }
         }
 
         return p;
 }

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

Definition at line 352 of file switch_xml.c.

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

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 (sval && strcasecmp(aname, sval)) {
                                                         goto done;
                                                 }
                                         } else {
                                                 if (!strcasecmp(aname, vals[x])) {
                                                         goto done;
                                                 }
                                         }
                                 }
                         }
                 }
         }
 
   done:
 
         return p;
 }

void switch_xml_free ( switch_xml_t xml )

Definition at line 2701 of file switch_xml.c.

References switch_xml_root::attr, switch_xml_root::dynamic, switch_xml_root::e, switch_xml_root::ent, switch_xml_root::m, switch_xml::ordered, switch_xml_root::pi, 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_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(), 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);
 }

static void switch_xml_free_attr ( char ** attr )

static

Definition at line 942 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 = 0;
         char *m;
 
         if (!attr || attr == SWITCH_XML_NIL)
                 return;                                 /* nothing to free */
         while (attr[i])
                 i += 2;                                 /* find end of attribute list */
         m = attr[i + 1];                        /* list of which names and values are malloced */
         for (i = 0; m[i]; 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);
 }

void switch_xml_free_in_thread	(	switch_xml_t	xml,
		int	stacksize
	)

Definition at line 2192 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_t switch_xml_get	(	switch_xml_t	xml,
			...
	)

Definition at line 480 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_section_t switch_xml_get_binding_sections ( switch_xml_binding_t * binding )

Definition at line 292 of file switch_xml.c.

 {
         return binding->sections;
 }

void* switch_xml_get_binding_user_data ( switch_xml_binding_t * binding )

Definition at line 297 of file switch_xml.c.

 {
         return binding->user_data;
 }

switch_xml_t switch_xml_idx	(	switch_xml_t	xml,
		int	idx
	)

Definition at line 418 of file switch_xml.c.

References switch_xml::next.

Referenced by switch_xml_vget().

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

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

Definition at line 2333 of file switch_xml.c.

References CACHE_EXPIRES_HASH, CACHE_HASH, 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_t switch_xml_insert	(	switch_xml_t	xml,
		switch_xml_t	dest,
		switch_size_t	off
	)

Definition at line 2811 of file switch_xml.c.

References switch_xml::child, cur, switch_xml::name, switch_xml::next, switch_xml::off, switch_xml::ordered, 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;
 }

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

static

Definition at line 771 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 */
                         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;
                         }
 
                         for (i = 0, ent = (*c == '%') ? pe : root->ent; ent[i]; i++);
                         sstmp = (char **) switch_must_realloc(ent, (i + 3) * sizeof(char *));   /* space for next ent */
                         ent = sstmp;
                         if (*c == '%')
                                 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] && 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_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 1655 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(), 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_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 1737 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_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 1757 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_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 2089 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) {
                 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 && *root) {
                 switch_xml_free(*root);
                 *root = NULL;
                 *domain = NULL;
         }
 
         return status;
 }

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 1970 of file switch_xml.c.

References CACHE_EXPIRES_HASH, CACHE_HASH, 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_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 = atol(expires_lookup);
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Cache Info\nTime Now:\t%ld\nExpires:\t%ld\n", (long)time_now, (long)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_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 1840 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;
                                 }
                         }
                 }
         }
 
         return status;
 }

switch_xml_t switch_xml_new ( const char * name )

Definition at line 2794 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;", "&#60;", "gt;", "&#62;", "quot;", "&#34;",
                 "apos;", "&#39;", "amp;", "&#38;", 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_t switch_xml_open_cfg	(	const char *	file_path,
		switch_xml_t *	node,
		switch_event_t *	params
	)

Definition at line 2383 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_t switch_xml_open_root	(	uint8_t	reload,
		const char **	err
	)

Definition at line 2256 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, XML_OPEN_ROOT_FUNCTION, and XML_OPEN_ROOT_FUNCTION_USER_DATA.

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

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

static

Definition at line 631 of file switch_xml.c.

References switch_xml::attr, switch_xml_root::cur, switch_xml::name, xml_section_t::name, 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 */
 }

switch_xml_t switch_xml_parse_file ( const char * file )

Definition at line 1583 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);
                         fd = -1;
                 }
         }
 
   done:
 
         switch_mutex_unlock(FILE_LOCK);
 
         if (write_fd) {
                 fclose(write_fd);
                 write_fd = NULL;
         }
 
         if (fd > -1) {
                 close(fd);
         }
 
         switch_safe_free(new_file_tmp);
         switch_safe_free(new_file);
 
         return xml;
 }

switch_xml_t switch_xml_parse_file_simple ( const char * file )

Definition at line 1556 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) {
                 fstat(fd, &st);
                 if (!st.st_size) goto error;
                 m = switch_must_malloc(st.st_size);
 
                 if (!(0<(l = read(fd, m, st.st_size)))) goto error;
                 if (!(root = (switch_xml_root_t) switch_xml_parse_str((char *) m, l))) 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_t switch_xml_parse_fp ( FILE * fp )

Definition at line 1132 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;
         root = (switch_xml_root_t) switch_xml_parse_str(s, len);
         root->dynamic = 1;                      /* so we know to free s in switch_xml_free() */
         return &root->xml;
 }

switch_xml_section_t switch_xml_parse_section_string ( const char * str )

Definition at line 208 of file switch_xml.c.

References buf, xml_section_t::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_t switch_xml_parse_str	(	char *	s,
		switch_size_t	len
	)

Definition at line 982 of file switch_xml.c.

References switch_xml_root::attr, switch_xml_root::cur, switch_xml_root::e, switch_xml_root::ent, switch_xml_root::m, switch_xml::name, switch_xml_root::s, switch_must_malloc(), switch_must_realloc(), 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, attr);
                                 switch_xml_close_tag(root, d, s);
                         } else if ((q = *s) == '>' || (!*s && e == '>')) {      /* open tag */
                                 *s = '\0';              /* temporarily null terminate tag name */
                                 switch_xml_open_tag(root, d, attr);
                                 *s = q;
                         } else {
                                 if (l)
                                         switch_xml_free_attr(attr);
                                 return switch_xml_err(root, d, "missing >");
                         }
                 } else if (*s == '/') { /* close tag */
                         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))
                                 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, "]]>")))
                                 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_t switch_xml_parse_str_dynamic	(	char *	s,
		switch_bool_t	dup
	)

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

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

Definition at line 492 of file switch_xml.c.

References if(), 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->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);
 }

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

static

Definition at line 718 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, 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 || !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 */
 }

void switch_xml_set_binding_sections	(	switch_xml_binding_t *	binding,
		switch_xml_section_t	sections
	)

Definition at line 280 of file switch_xml.c.

References switch_assert.

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

void switch_xml_set_binding_user_data	(	switch_xml_binding_t *	binding,
		void *	user_data
	)

Definition at line 286 of file switch_xml.c.

References switch_assert.

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

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

static

Definition at line 902 of file switch_xml.c.

References 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 */
 
         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);
 }

char* switch_xml_tohtml	(	switch_xml_t	xml,
		switch_bool_t	prn_header
	)

Definition at line 2627 of file switch_xml.c.

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

 {
         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(xml, s, SWITCH_XML_BUFSIZE, 0, prn_header);
         h = switch_xml_ampencode(r, 0, &h, &rlen, &len, 1);
         switch_safe_free(r);
         return h;
 }

char* switch_xml_toxml	(	switch_xml_t	xml,
		switch_bool_t	prn_header
	)

Definition at line 2616 of file switch_xml.c.

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

Referenced by switch_xml_dup(), and switch_xml_locate().

 {
         char *r, *s;
 
         s = (char *) switch_must_malloc(SWITCH_XML_BUFSIZE);
 
         r = switch_xml_toxml_buf(xml, s, SWITCH_XML_BUFSIZE, 0, prn_header);
 
         return r;
 }

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

Definition at line 2644 of file switch_xml.c.

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

Referenced by switch_xml_tohtml(), switch_xml_toxml(), and switch_xml_toxml_nolock().

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

char* switch_xml_toxml_nolock	(	switch_xml_t	xml,
		switch_bool_t	prn_header
	)

Definition at line 2608 of file switch_xml.c.

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

 {
         char *s = (char *) switch_must_malloc(SWITCH_XML_BUFSIZE);
 
         return switch_xml_toxml_buf(xml, s, SWITCH_XML_BUFSIZE, 0, prn_header);
 }

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
	)

static

Definition at line 2507 of file switch_xml.c.

References switch_xml::attr, switch_xml::child, 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().

 {
         int i, j;
         char *txt;
         switch_size_t off;
         uint32_t lcount;
         uint32_t loops = 0;
 
   tailrecurse:
         off = 0;
         lcount = 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);
 
         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);
                 *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);
                 *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);
 
         } else {
                 *s = switch_xml_ampencode(xml->txt, 0, s, len, max, 0); /* 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);
 */
         } else {
                 if (*count > 0)
                         (*count)--;
                 return switch_xml_ampencode(txt + off, 0, s, len, max, 0);
         }
 }

switch_status_t switch_xml_unbind_search_function ( switch_xml_binding_t ** binding )

Definition at line 231 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_status_t switch_xml_unbind_search_function_ptr ( switch_xml_search_function_t function )

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

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 2005 of file switch_xml.c.

References CACHE_EXPIRES_HASH, CACHE_HASH, switch_core_hash_delete(), switch_core_hash_find(), switch_core_hash_insert, switch_must_malloc(), switch_mutex_lock(), switch_mutex_unlock(), switch_safe_free, switch_snprintf(), 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 = switch_must_malloc(1024);
                 if (sprintf(expires_val, "%ld", (long)expires)) {
                         switch_core_hash_insert(CACHE_EXPIRES_HASH, mega_key, expires_val);
                 } else {
                         switch_safe_free(expires_val);
                 }
         }
         switch_core_hash_insert(CACHE_HASH, mega_key, switch_xml_dup(user));
         switch_mutex_unlock(CACHE_MUTEX);
 }

static switch_xml_t switch_xml_vget	(	switch_xml_t	xml,
		va_list	ap
	)

static

Definition at line 462 of file switch_xml.c.

References xml_section_t::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

switch_thread_rwlock_t* B_RWLOCK = NULL

static

Definition at line 177 of file switch_xml.c.

switch_xml_binding_t* BINDINGS = NULL

static

Definition at line 173 of file switch_xml.c.

switch_hash_t* CACHE_EXPIRES_HASH = NULL

static

Definition at line 189 of file switch_xml.c.

Referenced by switch_xml_clear_user_cache(), switch_xml_init(), switch_xml_locate_user_cache(), and switch_xml_user_cache().

switch_hash_t* CACHE_HASH = NULL

static

Definition at line 188 of file switch_xml.c.

Referenced by switch_xml_clear_user_cache(), switch_xml_destroy(), switch_xml_init(), switch_xml_locate_user_cache(), and switch_xml_user_cache().

switch_mutex_t* CACHE_MUTEX = NULL

static

Definition at line 179 of file switch_xml.c.

switch_mutex_t* FILE_LOCK = NULL

static

Definition at line 181 of file switch_xml.c.

switch_xml_t MAIN_XML_ROOT = NULL

static

Definition at line 174 of file switch_xml.c.

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

char not_so_threadsafe_error_buffer[256] = ""

static

Definition at line 2213 of file switch_xml.c.

Referenced by __switch_xml_open_root().

switch_mutex_t* REFLOCK = NULL

static

Definition at line 180 of file switch_xml.c.

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