XML Library Functions

Collaboration diagram for XML Library Functions:

Data Structures
struct	switch_xml
	A representation of an XML tree. More...

Macros
#define	SWITCH_XML_BUFSIZE   1024
#define	switch_xml_parse_str_dup(x)   switch_xml_parse_str_dynamic(x, SWITCH_TRUE)
	Parses a string into a switch_xml_t. More...
#define	switch_xml_next(xml)   ((xml) ? xml->next : NULL)
	returns the next tag of the same name in the same section and depth or NULL \ if not found More...
#define	switch_xml_name(xml)   ((xml) ? xml->name : NULL)
	returns the name of the given tag More...
#define	switch_xml_txt(xml)   ((xml) ? xml->txt : "")
	returns the given tag's character content or empty string if none More...
#define	switch_xml_new_d(name)   switch_xml_set_flag(switch_xml_new(strdup(name)), SWITCH_XML_NAMEM)
	wrapper for switch_xml_new() that strdup()s name More...
#define	switch_xml_add_child_d(xml, name, off)   switch_xml_set_flag(switch_xml_add_child(xml, strdup(name), off), SWITCH_XML_NAMEM)
	wrapper for switch_xml_add_child() that strdup()s name More...
#define	switch_xml_set_txt_d(xml, txt)   switch_xml_set_flag(switch_xml_set_txt(xml, strdup(txt)), SWITCH_XML_TXTM)
	wrapper for switch_xml_set_txt() that strdup()s txt \ sets the character content for the given tag and returns the tag More...
#define	switch_xml_set_attr_d(xml, name, value)   switch_xml_set_attr(switch_xml_set_flag(xml, SWITCH_XML_DUP), strdup(name), strdup(switch_str_nil(value)))
	Wrapper for switch_xml_set_attr() that strdup()s name/value. Value cannot be NULL. More...
#define	switch_xml_set_attr_d_buf(xml, name, value)   switch_xml_set_attr(switch_xml_set_flag(xml, SWITCH_XML_DUP), strdup(name), strdup(value))
#define	switch_xml_move(xml, dest, off)   switch_xml_insert(switch_xml_cut(xml), dest, off)
	Moves an existing tag to become a subtag of dest at the given offset from \ the start of dest's character content. Returns the moved tag. More...
#define	switch_xml_remove(xml)   switch_xml_free(switch_xml_cut(xml))
	removes a tag along with all its subtags More...
#define	switch_xml_bind_search_function(_f, _s, _u)   switch_xml_bind_search_function_ret(_f, _s, _u, NULL)

Enumerations
enum	switch_xml_flag_t { SWITCH_XML_ROOT = (1 << 0), SWITCH_XML_NAMEM = (1 << 1), SWITCH_XML_TXTM = (1 << 2), SWITCH_XML_DUP = (1 << 3) }

Functions
switch_xml_t	switch_xml_parse_str_dynamic (_In_z_ char *s, _In_ switch_bool_t dup)
	Parses a string into a switch_xml_t, ensuring the memory will be freed with switch_xml_free. More...
switch_xml_t	switch_xml_parse_str (_In_z_ char *s, _In_ switch_size_t len)
	Given a string of xml data and its length, parses it and creates an switch_xml \ structure. For efficiency, modifies the data by adding null terminators \ and decoding ampersand sequences. If you don't want this, copy the data and \ pass in the copy. Returns NULL on failure. More...
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...
switch_xml_t	switch_xml_parse_file (_In_z_ const char *file)
	a wrapper for switch_xml_parse_fd() that accepts a file name More...
switch_xml_t	switch_xml_parse_file_simple (_In_z_ const char *file)
switch_xml_t	switch_xml_parse_fp (_In_ FILE *fp)
	Wrapper for switch_xml_parse_str() that accepts a file stream. Reads the entire \ stream into memory and then parses it. For xml files, use switch_xml_parse_file() \ or switch_xml_parse_fd() More...
switch_xml_t	switch_xml_child (_In_ switch_xml_t xml, _In_z_ const char *name)
	returns the first child tag (one level deeper) with the given name or NULL \ if not found More...
switch_xml_t	switch_xml_find_child (_In_ switch_xml_t node, _In_z_ const char *childname, _In_opt_z_ const char *attrname, _In_opt_z_ const char *value)
	find a child tag in a node called 'childname' with an attribute 'attrname' which equals 'value' More...
switch_xml_t	switch_xml_find_child_multi (_In_ switch_xml_t node, _In_z_ const char *childname,...)
switch_xml_t	switch_xml_idx (_In_ switch_xml_t xml, _In_ int idx)
	Returns the Nth tag with the same name in the same section at the same depth \ or NULL if not found. An index of 0 returns the tag given. More...
const char *	switch_xml_attr (_In_opt_ switch_xml_t xml, _In_opt_z_ const char *attr)
	returns the value of the requested tag attribute, or NULL if not found More...
const char *	switch_xml_attr_soft (_In_ switch_xml_t xml, _In_z_ const char *attr)
	returns the value of the requested tag attribute, or "" if not found More...
switch_xml_t	switch_xml_get (_In_ switch_xml_t xml,...)
	Traverses the switch_xml structure to retrieve a specific subtag. Takes a \ variable length list of tag names and indexes. The argument list must be \ terminated by either an index of -1 or an empty string tag name. Example: \ title = switch_xml_get(library, "shelf", 0, "book", 2, "title", -1); \ This retrieves the title of the 3rd book on the 1st shelf of library. \ Returns NULL if not found. More...
char *	switch_xml_toxml (_In_ switch_xml_t xml, _In_ switch_bool_t prn_header)
	Converts an switch_xml structure back to xml in html format. Returns a string of html data that \ must be freed. More...
char *	switch_xml_toxml_nolock (switch_xml_t xml, _In_ switch_bool_t prn_header)
char *	switch_xml_tohtml (_In_ switch_xml_t xml, _In_ switch_bool_t prn_header)
char *	switch_xml_toxml_buf (_In_ switch_xml_t xml, _In_z_ char *buf, _In_ switch_size_t buflen, _In_ switch_size_t offset, _In_ switch_bool_t prn_header)
	Converts an switch_xml structure back to xml using the buffer passed in the parameters. More...
const char **	switch_xml_pi (_In_ switch_xml_t xml, _In_z_ const char *target)
	returns a NULL terminated array of processing instructions for the given \ target More...
void	switch_xml_free (_In_opt_ switch_xml_t xml)
	frees the memory allocated for an switch_xml structure More...
void	switch_xml_free_in_thread (_In_ switch_xml_t xml, _In_ int stacksize)
const char *	switch_xml_error (_In_ switch_xml_t xml)
	returns parser error message or empty string if none More...
switch_xml_t	switch_xml_new (_In_opt_z_ const char *name)
	returns a new empty switch_xml structure with the given root tag name More...
switch_xml_t	switch_xml_add_child (_In_ switch_xml_t xml, _In_z_ const char *name, _In_ switch_size_t off)
	Adds a child tag. off is the offset of the child tag relative to the start \ of the parent tag's character content. Returns the child tag. More...
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 (_In_ switch_xml_t xml)
	removes a tag along with its subtags without freeing its memory More...
switch_xml_t	switch_xml_insert (_In_ switch_xml_t xml, _In_ switch_xml_t dest, _In_ switch_size_t off)
	inserts an existing tag into an ezxml structure More...
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 (_In_ uint8_t reload, _Out_ const char **err)
	open the Core xml root More...
switch_status_t	switch_xml_init (_In_ switch_memory_pool_t *pool, _Out_ const char **err)
	initilize the core XML backend More...
switch_status_t	switch_xml_reload (const char **err)
switch_status_t	switch_xml_destroy (void)
switch_xml_t	switch_xml_root (void)
	retrieve the core XML root node More...
switch_status_t	switch_xml_locate (_In_z_ const char *section, _In_opt_z_ const char *tag_name, _In_opt_z_ const char *key_name, _In_opt_z_ const char *key_value, _Out_ switch_xml_t *root, _Out_ switch_xml_t *node, _In_opt_ switch_event_t *params, _In_ switch_bool_t clone)
	locate an xml pointer in the core registry More...
switch_status_t	switch_xml_locate_domain (_In_z_ const char *domain_name, _In_opt_ switch_event_t *params, _Out_ switch_xml_t *root, _Out_ switch_xml_t *domain)
switch_status_t	switch_xml_locate_group (_In_z_ const char *group_name, _In_z_ const char *domain_name, _Out_ switch_xml_t *root, _Out_ switch_xml_t *domain, _Out_ switch_xml_t *group, _In_opt_ switch_event_t *params)
switch_status_t	switch_xml_locate_user (_In_z_ const char *key, _In_z_ const char *user_name, _In_z_ const char *domain_name, _In_opt_z_ const char *ip, _Out_ switch_xml_t *root, _Out_ switch_xml_t *domain, _Out_ switch_xml_t *user, _Out_opt_ switch_xml_t *ingroup, _In_opt_ switch_event_t *params)
switch_status_t	switch_xml_locate_user_in_domain (_In_z_ const char *user_name, _In_ switch_xml_t domain, _Out_ switch_xml_t *user, _Out_opt_ switch_xml_t *ingroup)
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)
uint32_t	switch_xml_clear_user_cache (const char *key, const char *user_name, const char *domain_name)
void	switch_xml_merge_user (switch_xml_t user, switch_xml_t domain, switch_xml_t group)
switch_xml_t	switch_xml_dup (switch_xml_t xml)
switch_xml_t	switch_xml_open_cfg (_In_z_ const char *file_path, _Out_ switch_xml_t *node, _In_opt_ switch_event_t *params)
	open a config in the core registry More...
void	switch_xml_set_binding_sections (_In_ switch_xml_binding_t *binding, _In_ switch_xml_section_t sections)
	bind a search function to an external gateway More...
void	switch_xml_set_binding_user_data (_In_ switch_xml_binding_t *binding, _In_opt_ void *user_data)
switch_xml_section_t	switch_xml_get_binding_sections (_In_ switch_xml_binding_t *binding)
void *	switch_xml_get_binding_user_data (_In_ switch_xml_binding_t *binding)
switch_status_t	switch_xml_bind_search_function_ret (_In_ switch_xml_search_function_t function, _In_ switch_xml_section_t sections, _In_opt_ void *user_data, switch_xml_binding_t **ret_binding)
switch_status_t	switch_xml_unbind_search_function (_In_ switch_xml_binding_t **binding)
switch_status_t	switch_xml_unbind_search_function_ptr (_In_ switch_xml_search_function_t function)
switch_xml_section_t	switch_xml_parse_section_string (_In_opt_z_ const char *str)
	parse a string for a list of sections More...
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)

Detailed Description

Macro Definition Documentation

#define switch_xml_add_child_d	(		xml,
			name,
			off
	)		switch_xml_set_flag(switch_xml_add_child(xml, strdup(name), off), SWITCH_XML_NAMEM)

wrapper for switch_xml_add_child() that strdup()s name

Parameters

xml	the xml node
name	the name of the child
off	the offset

Definition at line 269 of file switch_xml.h.

Referenced by add_xml_header(), comp_callback(), do_merge(), switch_console_complete(), switch_event_xmlize(), switch_ivr_generate_xml_cdr(), switch_ivr_set_xml_call_stats(), switch_ivr_set_xml_chan_var(), and switch_ivr_set_xml_profile_data().

#define switch_xml_bind_search_function	(		_f,
			_s,
			_u
	)		switch_xml_bind_search_function_ret(_f, _s, _u, NULL)

Definition at line 415 of file switch_xml.h.

#define SWITCH_XML_BUFSIZE   1024

Definition at line 67 of file switch_xml.h.

Referenced by switch_xml_ampencode(), switch_xml_parse_fp(), switch_xml_str2utf8(), switch_xml_tohtml(), switch_xml_toxml(), switch_xml_toxml_buf(), switch_xml_toxml_nolock(), and switch_xml_toxml_r().

#define switch_xml_move	(		xml,
			dest,
			off
	)		switch_xml_insert(switch_xml_cut(xml), dest, off)

Moves an existing tag to become a subtag of dest at the given offset from \ the start of dest's character content. Returns the moved tag.

Definition at line 320 of file switch_xml.h.

#define switch_xml_name

(

xml

)

((xml) ? xml->name : NULL)

returns the name of the given tag

Parameters

xml	the xml node

Returns

the name

Definition at line 182 of file switch_xml.h.

#define switch_xml_new_d

(

name

)

switch_xml_set_flag(switch_xml_new(strdup(name)), SWITCH_XML_NAMEM)

wrapper for switch_xml_new() that strdup()s name

Parameters

name	the name of the root

Returns

an xml node or NULL

Definition at line 255 of file switch_xml.h.

#define switch_xml_next

(

xml

)

((xml) ? xml->next : NULL)

returns the next tag of the same name in the same section and depth or NULL \ if not found

Parameters

xml	an xml node

Returns

an xml node or NULL

Definition at line 170 of file switch_xml.h.

Referenced by switch_nat_republish().

#define switch_xml_parse_str_dup

(

x

)

switch_xml_parse_str_dynamic(x, SWITCH_TRUE)

Parses a string into a switch_xml_t.

Parameters

s	The string to parse

Returns

the switch_xml_t or NULL if an error occured

Definition at line 117 of file switch_xml.h.

Referenced by switch_nat_republish().

#define switch_xml_remove

(

xml

)

switch_xml_free(switch_xml_cut(xml))

removes a tag along with all its subtags

Definition at line 323 of file switch_xml.h.

#define switch_xml_set_attr_d	(		xml,
			name,
			value
	)		switch_xml_set_attr(switch_xml_set_flag(xml, SWITCH_XML_DUP), strdup(name), strdup(switch_str_nil(value)))

Wrapper for switch_xml_set_attr() that strdup()s name/value. Value cannot be NULL.

Parameters

xml	the xml node
name	the attribute name
value	the attribute value

Returns

an xml node or NULL

Definition at line 299 of file switch_xml.h.

Referenced by do_merge(), switch_ivr_generate_xml_cdr(), and switch_xml_merge_user().

#define switch_xml_set_attr_d_buf	(		xml,
			name,
			value
	)		switch_xml_set_attr(switch_xml_set_flag(xml, SWITCH_XML_DUP), strdup(name), strdup(value))

Definition at line 302 of file switch_xml.h.

Referenced by switch_console_complete(), and switch_ivr_generate_xml_cdr().

#define switch_xml_set_txt_d	(		xml,
			txt
	)		switch_xml_set_flag(switch_xml_set_txt(xml, strdup(txt)), SWITCH_XML_TXTM)

wrapper for switch_xml_set_txt() that strdup()s txt \ sets the character content for the given tag and returns the tag

Parameters

xml	the xml node
txt	the text

Returns

an xml node or NULL

Definition at line 283 of file switch_xml.h.

Referenced by add_xml_header(), comp_callback(), switch_console_complete(), switch_event_xmlize(), switch_ivr_generate_xml_cdr(), switch_ivr_set_xml_call_stats(), switch_ivr_set_xml_chan_var(), and switch_ivr_set_xml_profile_data().

#define switch_xml_txt

(

xml

)

((xml) ? xml->txt : "")

returns the given tag's character content or empty string if none

Parameters

xml	the xml node

Returns

the content

Definition at line 187 of file switch_xml.h.

Enumeration Type Documentation

enum switch_xml_flag_t

Enumerator
SWITCH_XML_ROOT
SWITCH_XML_NAMEM
SWITCH_XML_TXTM
SWITCH_XML_DUP

Definition at line 68 of file switch_xml.h.

                     {
        SWITCH_XML_ROOT = (1 << 0),     // root
        SWITCH_XML_NAMEM = (1 << 1),    // name is malloced
        SWITCH_XML_TXTM = (1 << 2),     // txt is malloced
        SWITCH_XML_DUP = (1 << 3)       // attribute name and value are strduped
} switch_xml_flag_t;

Function Documentation

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

Adds a child tag. off is the offset of the child tag relative to the start \ of the parent tag's character content. Returns the child tag.

Parameters

xml	the xml node
name	the name of the tag
off	the offset

Returns

an xml node or NULL

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

returns the value of the requested tag attribute, or NULL if not found

Parameters

xml	the xml node
attr	the attribute

Returns

the value

Referenced by load_configuration(), switch_ivr_check_presence_mapping(), switch_ivr_menu_stack_xml_build(), switch_ivr_phrase_macro_event(), switch_ivr_say(), switch_ivr_say_string(), switch_ivr_set_user_xml(), switch_load_network_lists(), and switch_load_timezones().

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

returns the value of the requested tag attribute, or "" if not found

Parameters

xml	the xml node
attr	the attribute

Returns

the value

Referenced by console_xml_config(), recover_callback(), switch_event_import_xml(), switch_ivr_menu_stack_xml_build(), switch_ivr_phrase_macro_event(), switch_load_core_config(), and switch_loadable_module_init().

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

switch_xml_t switch_xml_child	(	_In_ switch_xml_t	xml,
		_In_z_ const char *	name
	)

returns the first child tag (one level deeper) with the given name or NULL \ if not found

Parameters

xml	an xml node
name	the name of the child tag

Returns

an xml node or NULL

Referenced by console_xml_config(), load_configuration(), recover_callback(), switch_core_session_request_xml(), switch_ivr_check_presence_mapping(), switch_ivr_menu_stack_xml_build(), switch_ivr_phrase_macro_event(), switch_ivr_set_user_xml(), switch_load_core_config(), switch_load_network_lists(), switch_load_timezones(), switch_loadable_module_init(), switch_nat_republish(), switch_xml_config_parse_module_settings(), and xml_find_var().

uint32_t switch_xml_clear_user_cache	(	const char *	key,
		const char *	user_name,
		const char *	domain_name
	)

Definition at line 1920 of file switch_xml.c.

References CACHE_EXPIRES_HASH, CACHE_HASH, switch_core_hash_delete(), switch_core_hash_find(), switch_core_hash_first_iter(), switch_core_hash_this(), switch_mutex_lock(), switch_mutex_unlock(), switch_safe_free, switch_snprintf(), and switch_xml_free().

Referenced by switch_xml_destroy().

{
        switch_hash_index_t *hi = NULL;
        void *val;
        const void *var;
        char mega_key[1024];
        int r = 0;
        switch_xml_t lookup;
        char *expires_val = NULL;

        switch_mutex_lock(CACHE_MUTEX);

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

                if ((lookup = switch_core_hash_find(CACHE_HASH, mega_key))) {
                        switch_core_hash_delete(CACHE_HASH, mega_key);
                        if ((expires_val = switch_core_hash_find(CACHE_EXPIRES_HASH, mega_key))) {
                                switch_core_hash_delete(CACHE_EXPIRES_HASH, mega_key);
                                free(expires_val);
                                expires_val = NULL;
                        }
                        switch_xml_free(lookup);
                        r++;
                }

        } else {

                while ((hi = switch_core_hash_first_iter( CACHE_HASH, hi))) {
                        switch_core_hash_this(hi, &var, NULL, &val);
                        switch_xml_free(val);
                        switch_core_hash_delete(CACHE_HASH, var);
                        r++;
                }

                while ((hi = switch_core_hash_first_iter( CACHE_EXPIRES_HASH, hi))) {
                        switch_core_hash_this(hi, &var, NULL, &val);
                        switch_safe_free(val);
                        switch_core_hash_delete(CACHE_EXPIRES_HASH, var);
                }

                switch_safe_free(hi);
        }

        switch_mutex_unlock(CACHE_MUTEX);

        return r;

}

switch_xml_t switch_xml_cut

(

_In_ switch_xml_t

xml

)

removes a tag along with its subtags without freeing its memory

Parameters

xml	the xml node

switch_status_t switch_xml_destroy

(

void

)

Definition at line 2358 of file switch_xml.c.

References CACHE_HASH, MAIN_XML_ROOT, switch_core_hash_destroy(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_xml_clear_user_cache(), switch_xml_free(), and destroy_xml::xml.

Referenced by switch_core_destroy().

{
        switch_status_t status = SWITCH_STATUS_FALSE;


        switch_mutex_lock(XML_LOCK);
        switch_mutex_lock(REFLOCK);

        if (MAIN_XML_ROOT) {
                switch_xml_t xml = MAIN_XML_ROOT;
                MAIN_XML_ROOT = NULL;
                switch_xml_free(xml);
                status = SWITCH_STATUS_SUCCESS;
        }

        switch_mutex_unlock(XML_LOCK);
        switch_mutex_unlock(REFLOCK);

        switch_xml_clear_user_cache(NULL, NULL, NULL);

        switch_core_hash_destroy(&CACHE_HASH);

        return status;
}

switch_xml_t switch_xml_dup

(

switch_xml_t

xml

)

Definition at line 1862 of file switch_xml.c.

References SWITCH_FALSE, switch_xml_parse_str_dynamic(), and switch_xml_toxml().

Referenced by switch_xml_locate_user_cache(), switch_xml_locate_user_merged(), and switch_xml_user_cache().

{
        char *x = switch_xml_toxml(xml, SWITCH_FALSE);
        return switch_xml_parse_str_dynamic(x, SWITCH_FALSE);
}

const char* switch_xml_error

(

_In_ switch_xml_t

xml

)

returns parser error message or empty string if none

Parameters

xml	the xml node

Returns

the error string or nothing

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

find a child tag in a node called 'childname' with an attribute 'attrname' which equals 'value'

Parameters

node	the xml node
childname	the child tag name
attrname	the attribute name
value	the value

Returns

an xml node or NULL

Referenced by switch_ivr_menu_stack_xml_build(), switch_ivr_phrase_macro_event(), and switch_nat_republish().

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

void switch_xml_free

(

_In_opt_ switch_xml_t

xml

)

frees the memory allocated for an switch_xml structure

Parameters

xml	the xml node

Note

in the case of the root node the readlock will be lifted

Referenced by console_xml_config(), CoreSession::getXMLCDR(), load_configuration(), recover_callback(), Event::serialize(), switch_channel_clear_device_record(), switch_core_recovery_track(), switch_core_session_reporting_state(), switch_ivr_check_presence_mapping(), switch_ivr_generate_xml_cdr(), switch_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_ivr_phrase_macro_event(), switch_ivr_say(), switch_ivr_say_string(), switch_ivr_set_user(), switch_load_core_config(), switch_load_network_lists(), switch_load_timezones(), switch_loadable_module_init(), switch_nat_republish(), and switch_xml_config_parse_module_settings().

void switch_xml_free_in_thread	(	_In_ switch_xml_t	xml,
		_In_ int	stacksize
	)

switch_xml_t switch_xml_get	(	_In_ switch_xml_t	xml,
			...
	)

Traverses the switch_xml structure to retrieve a specific subtag. Takes a \ variable length list of tag names and indexes. The argument list must be \ terminated by either an index of -1 or an empty string tag name. Example: \ title = switch_xml_get(library, "shelf", 0, "book", 2, "title", -1); \ This retrieves the title of the 3rd book on the 1st shelf of library. \ Returns NULL if not found.

Parameters

xml	the xml node

Returns

an xml node or NULL

switch_xml_section_t switch_xml_get_binding_sections

(

_In_ switch_xml_binding_t *

binding

)

void* switch_xml_get_binding_user_data

(

_In_ switch_xml_binding_t *

binding

)

switch_xml_t switch_xml_idx	(	_In_ switch_xml_t	xml,
		_In_ int	idx
	)

Returns the Nth tag with the same name in the same section at the same depth \ or NULL if not found. An index of 0 returns the tag given.

Parameters

xml	the xml node
idx	the index

Returns

an xml node or NULL

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

initilize the core XML backend

Parameters

pool	a memory pool to use
err	a pointer to set error strings

Returns

SWITCH_STATUS_SUCCESS if successful

Referenced by switch_core_init().

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

inserts an existing tag into an ezxml structure

switch_status_t switch_xml_locate	(	_In_z_ const char *	section,
		_In_opt_z_ const char *	tag_name,
		_In_opt_z_ const char *	key_name,
		_In_opt_z_ const char *	key_value,
		_Out_ switch_xml_t *	root,
		_Out_ switch_xml_t *	node,
		_In_opt_ switch_event_t *	params,
		_In_ switch_bool_t	clone
	)

locate an xml pointer in the core registry

Parameters

section	the section to look in
tag_name	the type of tag in that section
key_name	the name of the key
key_value	the value of the key
root	a pointer to point at the root node
node	a pointer to the requested node
params	optional URL formatted params to pass to external gateways

Returns

SWITCH_STATUS_SUCCESS if successful root and node will be assigned

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

Referenced by switch_load_network_lists().

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

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
	)

Definition at line 3147 of file switch_xml.c.

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

Referenced by switch_ivr_phrase_macro_event(), switch_ivr_say(), and switch_ivr_say_string().

                                                                                                                                                                                                                          {
        switch_status_t status = SWITCH_STATUS_FALSE;

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

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

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

done:
        return status;
}

switch_status_t switch_xml_locate_user	(	_In_z_ const char *	key,
		_In_z_ const char *	user_name,
		_In_z_ const char *	domain_name,
		_In_opt_z_ const char *	ip,
		_Out_ switch_xml_t *	root,
		_Out_ switch_xml_t *	domain,
		_Out_ switch_xml_t *	user,
		_Out_opt_ switch_xml_t *	ingroup,
		_In_opt_ switch_event_t *	params
	)

switch_status_t switch_xml_locate_user_in_domain	(	_In_z_ const char *	user_name,
		_In_ switch_xml_t	domain,
		_Out_ switch_xml_t *	user,
		_Out_opt_ switch_xml_t *	ingroup
	)

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
	)

Definition at line 2034 of file switch_xml.c.

References SWITCH_CHANNEL_LOG, switch_is_number(), SWITCH_LOG_DEBUG, switch_log_printf(), switch_micro_time_now(), switch_must_strdup(), switch_safe_free, switch_split, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_xml_attr(), switch_xml_dup(), switch_xml_free(), switch_xml_locate_user(), switch_xml_locate_user_cache(), switch_xml_merge_user(), switch_xml_user_cache(), time_now(), and zstr.

Referenced by switch_ivr_set_user().

{
        switch_xml_t xml, domain, group, x_user, x_user_dup;
        switch_status_t status = SWITCH_STATUS_FALSE;
        char *kdup = NULL;
        char *keys[10] = {0};
        int i, nkeys;

        if (strchr(key, ':')) {
                kdup = switch_must_strdup(key);
                nkeys  = switch_split(kdup, ':', keys);
        } else {
                keys[0] = (char *)key;
                nkeys = 1;
        }

        for(i = 0; i < nkeys; i++) {
                if ((status = switch_xml_locate_user_cache(keys[i], user_name, domain_name, &x_user)) == SWITCH_STATUS_SUCCESS) {
                        *user = x_user;
                        break;
                } else if ((status = switch_xml_locate_user(keys[i], user_name, domain_name, ip, &xml, &domain, &x_user, &group, params)) == SWITCH_STATUS_SUCCESS) {
                        const char *cacheable = NULL;

                        x_user_dup = switch_xml_dup(x_user);
                        switch_xml_merge_user(x_user_dup, domain, group);

                        cacheable = switch_xml_attr(x_user_dup, "cacheable");
                        if (!zstr(cacheable)) {
                                switch_time_t expires = 0;
                                switch_time_t time_now = 0;

                                if (switch_is_number(cacheable)) {
                                        int cache_ms = atol(cacheable);
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "caching lookup for user %s@%s for %d milliseconds\n", 
                                                                          user_name, domain_name, cache_ms);
                                        time_now = switch_micro_time_now();
                                        expires = time_now + (cache_ms * 1000);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "caching lookup for user %s@%s indefinitely\n", user_name, domain_name);
                                }
                                switch_xml_user_cache(keys[i], user_name, domain_name, x_user_dup, expires);
                        }
                        *user = x_user_dup;
                        switch_xml_free(xml);
                        break;
                }
        }

        switch_safe_free(kdup);

        return status;

}

void switch_xml_merge_user	(	switch_xml_t	user,
		switch_xml_t	domain,
		switch_xml_t	group
	)

Definition at line 1904 of file switch_xml.c.

References do_merge(), switch_xml_attr(), switch_xml_set_attr_d, and zstr.

Referenced by switch_xml_locate_user_merged().

{
        const char *domain_name = switch_xml_attr(domain, "name");

        do_merge(user, group, "params", "param");
        do_merge(user, group, "variables", "variable");
        do_merge(user, group, "profile-variables", "variable");
        do_merge(user, domain, "params", "param");
        do_merge(user, domain, "variables", "variable");
        do_merge(user, domain, "profile-variables", "variable");

        if (!zstr(domain_name)) {
                switch_xml_set_attr_d(user, "domain-name", domain_name);
        }
}

switch_xml_t switch_xml_new

(

_In_opt_z_ const char *

name

)

returns a new empty switch_xml structure with the given root tag name

Parameters

name	the name of the new root tag

Referenced by switch_event_xmlize(), and switch_ivr_generate_xml_cdr().

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

open a config in the core registry

Parameters

file_path	the name of the config section e.g. modules.conf
node	a pointer to point to the node if it is found
params	optional URL formatted params to pass to external gateways

Returns

the root xml node associated with the current request or NULL

Referenced by console_xml_config(), load_configuration(), switch_ivr_check_presence_mapping(), switch_load_core_config(), switch_load_network_lists(), switch_load_timezones(), switch_loadable_module_init(), and switch_xml_config_parse_module_settings().

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

open the Core xml root

Parameters

reload	if it's is already open close it and open it again as soon as permissable (blocking)
err	a pointer to set error strings

Returns

the xml root node or NULL

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.

Parameters

fd

Returns

a formated xml node or NULL

Definition at line 1157 of file switch_xml.c.

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

Referenced by switch_xml_parse_file().

{
        switch_xml_root_t root;
        struct stat st;
        switch_ssize_t l;
        void *m;

        if (fd < 0)
                return NULL;
        fstat(fd, &st);

        if (!st.st_size) {
                return NULL;
        }

        m = switch_must_malloc(st.st_size);

        if (!(0<(l = read(fd, m, st.st_size)))
                || !(root = (switch_xml_root_t) switch_xml_parse_str((char *) m, l))) {
                free(m);
                return NULL;
        }
        root->dynamic = 1;              /* so we know to free s in switch_xml_free() */

        return &root->xml;
}

switch_xml_t switch_xml_parse_file

(

_In_z_ const char *

file

)

a wrapper for switch_xml_parse_fd() that accepts a file name

Parameters

file	a file to parse

Returns

a formated xml node or NULL

switch_xml_t switch_xml_parse_file_simple

(

_In_z_ const char *

file

)

switch_xml_t switch_xml_parse_fp

(

_In_ FILE *

fp

)

Wrapper for switch_xml_parse_str() that accepts a file stream. Reads the entire \ stream into memory and then parses it. For xml files, use switch_xml_parse_file() \ or switch_xml_parse_fd()

Parameters

fp	a FILE pointer to parse

Returns

an xml node or NULL

switch_xml_section_t switch_xml_parse_section_string

(

_In_opt_z_ const char *

str

)

parse a string for a list of sections

Parameters

str	a | delimited list of section names

Returns

the section mask

switch_xml_t switch_xml_parse_str	(	_In_z_ char *	s,
		_In_ switch_size_t	len
	)

Given a string of xml data and its length, parses it and creates an switch_xml \ structure. For efficiency, modifies the data by adding null terminators \ and decoding ampersand sequences. If you don't want this, copy the data and \ pass in the copy. Returns NULL on failure.

Parameters

s	a string
len	the length of the string

Returns

a formated xml node or NULL

switch_xml_t switch_xml_parse_str_dynamic	(	_In_z_ char *	s,
		_In_ switch_bool_t	dup
	)

Parses a string into a switch_xml_t, ensuring the memory will be freed with switch_xml_free.

Parameters

s	The string to parse
dup	true if you want the string to be strdup()'d automatically

Returns

the switch_xml_t or NULL if an error occured

Referenced by recover_callback().

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

returns a NULL terminated array of processing instructions for the given \ target

Parameters

xml	the xml node
target	the instructions

Returns

the array

switch_status_t switch_xml_reload

(

const char **

err

)

Definition at line 2321 of file switch_xml.c.

References SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_xml_free(), and switch_xml_open_root().

{
        switch_xml_t xml_root;

        if ((xml_root = switch_xml_open_root(1, err))) {
                switch_xml_free(xml_root);
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_GENERR;
}

switch_xml_t switch_xml_root

(

void

)

retrieve the core XML root node

Returns

the xml root node

Note

this will cause a readlock on the root until it's released with

See also

switch_xml_free

Definition at line 2166 of file switch_xml.c.

References MAIN_XML_ROOT, switch_xml::refs, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by __switch_xml_open_root(), and switch_xml_locate().

{
        switch_xml_t xml;

        switch_mutex_lock(REFLOCK);
        xml = MAIN_XML_ROOT;
        xml->refs++;
        switch_mutex_unlock(REFLOCK);

        return xml;
}

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.

Parameters

xml	the xml node
name	the attribute name
value	the attribute value

Returns

the tag given

Definition at line 2884 of file switch_xml.c.

References switch_xml::attr, switch_must_malloc(), switch_must_realloc(), switch_must_strdup(), SWITCH_XML_DUP, SWITCH_XML_NAMEM, SWITCH_XML_TXTM, and destroy_xml::xml.

{
        int l = 0, c;

        if (!xml)
                return NULL;
        while (xml->attr[l] && strcmp(xml->attr[l], name))
                l += 2;
        if (!xml->attr[l]) {            /* not found, add as new attribute */
                if (!value)
                        return xml;                     /* nothing to do */
                if (xml->attr == SWITCH_XML_NIL) {      /* first attribute */
                        xml->attr = (char **) switch_must_malloc(4 * sizeof(char *));
                        xml->attr[1] = switch_must_strdup("");  /* empty list of malloced names/vals */
                } else {
                        xml->attr = (char **) switch_must_realloc(xml->attr, (l + 4) * sizeof(char *));
                }

                xml->attr[l] = (char *) name;   /* set attribute name */
                xml->attr[l + 2] = NULL;        /* null terminate attribute list */
                xml->attr[l + 3] = (char *) switch_must_realloc(xml->attr[l + 1], (c = (int) strlen(xml->attr[l + 1])) + 2);
                strcpy(xml->attr[l + 3] + c, " ");      /* set name/value as not malloced */
                if (xml->flags & SWITCH_XML_DUP)
                        xml->attr[l + 3][c] = SWITCH_XML_NAMEM;
        } else if (xml->flags & SWITCH_XML_DUP)
                free((char *) name);    /* name was strduped */

        for (c = l; xml->attr[c]; c += 2);      /* find end of attribute list */
        if (xml->attr[c + 1][l / 2] & SWITCH_XML_TXTM)
                free(xml->attr[l + 1]); /* old val */
        if (xml->flags & SWITCH_XML_DUP)
                xml->attr[c + 1][l / 2] |= SWITCH_XML_TXTM;
        else
                xml->attr[c + 1][l / 2] &= ~SWITCH_XML_TXTM;

        if (value)
                xml->attr[l + 1] = (char *) value;      /* set attribute value */
        else {                                          /* remove attribute */
                if (xml->attr[c + 1][l / 2] & SWITCH_XML_NAMEM)
                        free(xml->attr[l]);
                memmove(xml->attr + l, xml->attr + l + 2, (c - l + 2) * sizeof(char *));
                xml->attr = (char **) switch_must_realloc(xml->attr, (c + 2) * sizeof(char *));
                memmove(xml->attr[c + 1] + (l / 2), xml->attr[c + 1] + (l / 2) + 1, (c / 2) - (l / 2)); /* fix list of which name/vals are malloced */
        }
        xml->flags &= ~SWITCH_XML_DUP;  /* clear strdup() flag */

        return xml;
}

void switch_xml_set_binding_sections	(	_In_ switch_xml_binding_t *	binding,
		_In_ switch_xml_section_t	sections
	)

bind a search function to an external gateway

Parameters

function	the search function to bind
sections	a bitmask of sections you wil service
user_data	a pointer to private data to be used during the callback

Returns

SWITCH_STATUS_SUCCESS if successful

Note

gateway functions will be executed in the order they were binded until a success is found else the root registry will be used

void switch_xml_set_binding_user_data	(	_In_ switch_xml_binding_t *	binding,
		_In_opt_ void *	user_data
	)

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

Parameters

xml	the xml node
flag	the flag to set

Returns

an xml node or NULL

Definition at line 2934 of file switch_xml.c.

References switch_xml::flags, and destroy_xml::xml.

Referenced by switch_xml_char_content().

{
        if (xml)
                xml->flags |= flag;
        return xml;
}

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.

Definition at line 2241 of file switch_xml.c.

References switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, XML_OPEN_ROOT_FUNCTION, and XML_OPEN_ROOT_FUNCTION_USER_DATA.

{
        if (XML_LOCK) {
                switch_mutex_lock(XML_LOCK);
        }

        XML_OPEN_ROOT_FUNCTION = func;
        XML_OPEN_ROOT_FUNCTION_USER_DATA = user_data;

        if (XML_LOCK) {
                switch_mutex_unlock(XML_LOCK);
        }
        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_xml_set_root

(

switch_xml_t

new_main

)

set new core xml root

Definition at line 2215 of file switch_xml.c.

References MAIN_XML_ROOT, switch_xml::refs, switch_mutex_lock(), switch_mutex_unlock(), switch_set_flag, SWITCH_STATUS_SUCCESS, switch_xml_free(), and SWITCH_XML_ROOT.

Referenced by __switch_xml_open_root().

{
        switch_xml_t old_root = NULL;

        switch_mutex_lock(REFLOCK);

        old_root = MAIN_XML_ROOT;
        MAIN_XML_ROOT = new_main;
        switch_set_flag(MAIN_XML_ROOT, SWITCH_XML_ROOT);
        MAIN_XML_ROOT->refs++;

        if (old_root) {
                if (old_root->refs) {
                        old_root->refs--;
                }

                if (!old_root->refs) {
                        switch_xml_free(old_root);
                }
        }

        switch_mutex_unlock(REFLOCK);

        return SWITCH_STATUS_SUCCESS;
}

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

Parameters

xml	the xml node
txt	the text

Returns

an xml node or NULL

Definition at line 2871 of file switch_xml.c.

References SWITCH_XML_TXTM, and destroy_xml::xml.

{
        if (!xml)
                return NULL;
        if (xml->flags & SWITCH_XML_TXTM)
                free(xml->txt);                 /* existing txt was malloced */
        xml->flags &= ~SWITCH_XML_TXTM;
        xml->txt = (char *) txt;
        return xml;
}

int switch_xml_std_datetime_check	(	switch_xml_t	xcond,
		int *	offset,
		const char *	tzname
	)

Definition at line 2980 of file switch_xml.c.

References SWITCH_CHANNEL_LOG, switch_dow_cmp(), switch_dow_int2str(), switch_fulldate_cmp(), switch_is_number(), SWITCH_LOG_DEBUG, SWITCH_LOG_DEBUG9, switch_log_printf(), switch_micro_time_now(), switch_number_cmp(), switch_snprintf(), switch_strftime(), switch_time_exp_lt(), switch_time_exp_tz(), switch_time_exp_tz_name(), switch_tod_cmp(), switch_true(), switch_xml_attr(), switch_time_exp_t::tm_gmtoff, switch_time_exp_t::tm_hour, switch_time_exp_t::tm_isdst, switch_time_exp_t::tm_mday, switch_time_exp_t::tm_min, switch_time_exp_t::tm_mon, switch_time_exp_t::tm_sec, switch_time_exp_t::tm_wday, switch_time_exp_t::tm_yday, switch_time_exp_t::tm_year, and zstr.

{

        const char *xdt = switch_xml_attr(xcond, "date-time");
        const char *xyear = switch_xml_attr(xcond, "year");
        const char *xyday = switch_xml_attr(xcond, "yday");
        const char *xmon = switch_xml_attr(xcond, "mon");
        const char *xmday = switch_xml_attr(xcond, "mday");
        const char *xweek = switch_xml_attr(xcond, "week");
        const char *xmweek = switch_xml_attr(xcond, "mweek");
        const char *xwday = switch_xml_attr(xcond, "wday");
        const char *xhour = switch_xml_attr(xcond, "hour");
        const char *xminute = switch_xml_attr(xcond, "minute");
        const char *xminday = switch_xml_attr(xcond, "minute-of-day");
        const char *xtod = switch_xml_attr(xcond, "time-of-day");
        const char *tzoff = switch_xml_attr(xcond, "tz-offset");
        const char *isdst = switch_xml_attr(xcond, "dst");

        int loffset = -1000;
        int eoffset = -1000;
        int dst = -1000;
        switch_time_t ts = switch_micro_time_now();
        int time_match = -1;
        switch_time_exp_t tm, tm2;

        if (!zstr(isdst)) {
                dst = switch_true(isdst);
        }

        if (!zstr(tzoff) && switch_is_number(tzoff)) {
                loffset = atoi(tzoff);
        }

        switch_time_exp_lt(&tm2, ts);

        if (offset) {
                eoffset = *offset;
                switch_time_exp_tz(&tm, ts, *offset * 3600);
        } else if (!zstr(tzname)) {
                switch_time_exp_tz_name(tzname, &tm, ts);
        } else {
                tm = tm2;
        }

        if (eoffset == -1000) {
                eoffset = tm.tm_gmtoff / 3600;
        }

        if (loffset == -1000) {
                loffset = eoffset;
        }


        if (time_match && tzoff) {
                time_match = loffset == eoffset;
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG9,
                                                  "XML DateTime Check: TZOFFSET[%d] == %d (%s)\n", eoffset, loffset, time_match ? "PASS" : "FAIL");

        }

        if (time_match && dst > -1) {
                time_match = (tm2.tm_isdst > 0 && dst > 0);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG9,
                                                  "XML DateTime Check: DST[%s] == %s (%s)\n",
                                                  tm2.tm_isdst > 0 ? "true" : "false", dst > 0 ? "true" : "false", time_match ? "PASS" : "FAIL");

        }

        if (time_match && xdt) {
                char tmpdate[80];
                switch_size_t retsize;
                switch_strftime(tmpdate, &retsize, sizeof(tmpdate), "%Y-%m-%d %H:%M:%S", &tm);
                time_match = switch_fulldate_cmp(xdt, &ts);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
                                "XML DateTime Check: date time[%s] =~ %s (%s)\n", tmpdate, xdt, time_match ? "PASS" : "FAIL");
        }

        if (time_match && xyear) {
                int test = tm.tm_year + 1900;
                time_match = switch_number_cmp(xyear, test);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG9,
                                "XML DateTime Check: year[%d] =~ %s (%s)\n", test, xyear, time_match ? "PASS" : "FAIL");
        }

        if (time_match && xyday) {
                int test = tm.tm_yday + 1;
                time_match = switch_number_cmp(xyday, test);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG9,
                                "XML DateTime Check: day of year[%d] =~ %s (%s)\n", test, xyday, time_match ? "PASS" : "FAIL");
        }

        if (time_match && xmon) {
                int test = tm.tm_mon + 1;
                time_match = switch_number_cmp(xmon, test);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG9,
                                "XML DateTime Check: month[%d] =~ %s (%s)\n", test, xmon, time_match ? "PASS" : "FAIL");
        }

        if (time_match && xmday) {
                int test = tm.tm_mday;
                time_match = switch_number_cmp(xmday, test);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG9,
                                "XML DateTime Check: day of month[%d] =~ %s (%s)\n", test, xmday, time_match ? "PASS" : "FAIL");
        }

        if (time_match && xweek) {
                int test = (int) (tm.tm_yday / 7 + 1);
                time_match = switch_number_cmp(xweek, test);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG9,
                                "XML DateTime Check: week of year[%d] =~ %s (%s)\n", test, xweek, time_match ? "PASS" : "FAIL");
        }
        if (time_match && xweek) {
                int test = (int) (tm.tm_yday / 7 + 1);
                time_match = switch_number_cmp(xweek, test);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG9,
                                "XML DateTime Check: week of year[%d] =~ %s (%s)\n", test, xweek, time_match ? "PASS" : "FAIL");
        }

        if (time_match && xmweek) {
                /* calculate the day of the week of the first of the month (0-6) */
                int firstdow = (int) (7 - (tm.tm_mday - (tm.tm_wday + 1)) % 7) % 7;
                /* calculate the week of the month (1-6)*/
                int test = (int) ceil((tm.tm_mday + firstdow) / 7.0);
                time_match = switch_number_cmp(xmweek, test);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG9,
                                "XML DateTime: week of month[%d] =~ %s (%s)\n", test, xmweek, time_match ? "PASS" : "FAIL");
        }

        if (time_match && xwday) {
                int test = tm.tm_wday + 1;
                time_match = switch_dow_cmp(xwday, test);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG9,
                                "XML DateTime Check: day of week[%s] =~ %s (%s)\n", switch_dow_int2str(test), xwday, time_match ? "PASS" : "FAIL");
        }
        if (time_match && xhour) {
                int test = tm.tm_hour;
                time_match = switch_number_cmp(xhour, test);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG9,
                                "XML DateTime Check: hour[%d] =~ %s (%s)\n", test, xhour, time_match ? "PASS" : "FAIL");
        }

        if (time_match && xminute) {
                int test = tm.tm_min;
                time_match = switch_number_cmp(xminute, test);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG9,
                                "XML DateTime Check: minute[%d] =~ %s (%s)\n", test, xminute, time_match ? "PASS" : "FAIL");
        }

        if (time_match && xminday) {
                int test = (tm.tm_hour * 60) + (tm.tm_min + 1);
                time_match = switch_number_cmp(xminday, test);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG9,
                                "XML DateTime Check: minute of day[%d] =~ %s (%s)\n", test, xminday, time_match ? "PASS" : "FAIL");
        }

        if (time_match && xtod) {
                int test = (tm.tm_hour * 60 * 60) + (tm.tm_min * 60) + tm.tm_sec;
                char tmpdate[10];
                switch_snprintf(tmpdate, 10, "%d:%d:%d", tm.tm_hour, tm.tm_min, tm.tm_sec);
                time_match = switch_tod_cmp(xtod, test);
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG9,
                                "XML DateTime Check: time of day[%s] =~ %s (%s)\n", tmpdate, xtod, time_match ? "PASS" : "FAIL");
        }

        return time_match;
}

char* switch_xml_tohtml	(	_In_ switch_xml_t	xml,
		_In_ switch_bool_t	prn_header
	)

char* switch_xml_toxml	(	_In_ switch_xml_t	xml,
		_In_ switch_bool_t	prn_header
	)

Converts an switch_xml structure back to xml in html format. Returns a string of html data that \ must be freed.

Parameters

xml	the xml node
prn_header	add <?xml version..> header too

Returns

the ampersanded html text string to display xml

Referenced by CoreSession::getXMLCDR(), Event::serialize(), switch_core_session_reporting_state(), switch_ivr_multi_threaded_bridge(), and switch_ivr_originate().

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

Converts an switch_xml structure back to xml using the buffer passed in the parameters.

Parameters

xml	the xml node
buf	buffer to use
buflen	size of buffer
offset	offset to start at
prn_header	add <?xml version..> header too

Returns

the xml text string

char* switch_xml_toxml_nolock	(	switch_xml_t	xml,
		_In_ switch_bool_t	prn_header
	)

Referenced by switch_core_recovery_track().

switch_status_t switch_xml_unbind_search_function

(

_In_ switch_xml_binding_t **

binding

)

switch_status_t switch_xml_unbind_search_function_ptr

(

_In_ switch_xml_search_function_t

function

)