XML Library Functions
[Core Library]

Data Structures
struct	switch_xml
	A representation of an XML tree. More...
Defines
#define	SWITCH_XML_BUFSIZE   1024
#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
#define	switch_xml_name(xml)   ((xml) ? xml->name : NULL)
	returns the name of the given tag
#define	switch_xml_txt(xml)   ((xml) ? xml->txt : "")
	returns the given tag's character content or empty string if none
#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
#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
#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
#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.
#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.
#define	switch_xml_remove(xml)   switch_xml_free(switch_xml_cut(xml))
	removes a tag along with all its subtags
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 (char *s, 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.
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.
switch_xml_t	switch_xml_parse_file (const char *file)
	a wrapper for switch_xml_parse_fd() that accepts a file name
switch_xml_t	switch_xml_parse_file_simple (const char *file)
switch_xml_t	switch_xml_parse_fp (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().
switch_xml_t	switch_xml_child (switch_xml_t xml, const char *name)
	returns the first child tag (one level deeper) with the given name or NULL \ if not found
switch_xml_t	switch_xml_find_child (switch_xml_t node, const char *childname, const char *attrname, const char *value)
	find a child tag in a node called 'childname' with an attribute 'attrname' which equals 'value'
switch_xml_t	switch_xml_idx (switch_xml_t xml, 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.
const char *	switch_xml_attr (switch_xml_t xml, const char *attr)
	returns the value of the requested tag attribute, or NULL if not found
const char *	switch_xml_attr_soft (switch_xml_t xml, const char *attr)
	returns the value of the requested tag attribute, or "" if not found
switch_xml_t	switch_xml_get (switch_xml_t xml,...)
	Traverses the switch_xml sturcture 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.
char *	switch_xml_toxml (switch_xml_t xml, switch_bool_t prn_header)
	Converts an switch_xml structure back to xml. Returns a string of xml data that \ must be freed.
char *	switch_xml_toxml_buf (switch_xml_t xml, char *buf, switch_size_t buflen, switch_size_t offset, switch_bool_t prn_header)
	Converts an switch_xml structure back to xml using the buffer passed in the parameters.
const char **	switch_xml_pi (switch_xml_t xml, const char *target)
	returns a NULL terminated array of processing instructions for the given \ target
void	switch_xml_free (switch_xml_t xml)
	frees the memory allocated for an switch_xml structure
void	switch_xml_free_in_thread (switch_xml_t xml, int stacksize)
const char *	switch_xml_error (switch_xml_t xml)
	returns parser error message or empty string if none
switch_xml_t	switch_xml_new (const char *name)
	returns a new empty switch_xml structure with the given root tag name
switch_xml_t	switch_xml_add_child (switch_xml_t xml, const char *name, 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.
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
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.
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
switch_xml_t	switch_xml_cut (switch_xml_t xml)
	removes a tag along with its subtags without freeing its memory
switch_xml_t	switch_xml_insert (switch_xml_t xml, switch_xml_t dest, switch_size_t off)
	inserts an existing tag into an ezxml structure
switch_xml_t	switch_xml_open_root (uint8_t reload, const char **err)
	open the Core xml root
switch_status_t	switch_xml_init (switch_memory_pool_t *pool, const char **err)
	initilize the core XML backend
switch_status_t	switch_xml_destroy (void)
switch_xml_t	switch_xml_root (void)
	retrieve the core XML root node
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)
	locate an xml pointer in the core registry
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_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_event_t *params)
switch_xml_t	switch_xml_open_cfg (const char *file_path, switch_xml_t *node, switch_event_t *params)
	open a config in the core registry
switch_status_t	switch_xml_bind_search_function (switch_xml_search_function_t function, switch_xml_section_t sections, void *user_data)
	bind a search function to an external gateway
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)
switch_xml_section_t	switch_xml_parse_section_string (const char *str)
	parse a string for a list of sections

---

Define 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

#define SWITCH_XML_BUFSIZE   1024

#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.

#define switch_xml_name (  xml   )     ((xml) ? xml->name : NULL)

returns the name of the given tag Parameters: xml  the xml node Returns: the name

#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

#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

#define switch_xml_remove (  xml   )     switch_xml_free(switch_xml_cut(xml))

removes a tag along with all its subtags

#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

#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_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

#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

---

Enumeration Type Documentation

enum switch_xml_flag_t

Enumeration values: SWITCH_XML_ROOT  SWITCH_XML_NAMEM  SWITCH_XML_TXTM  SWITCH_XML_DUP  { 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 (  switch_xml_t  xml, const char *  name, 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 { switch_xml_t child; if (!xml) return NULL; child = (switch_xml_t) memset(malloc(sizeof(struct switch_xml)), '\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); }

Here is the call graph for this function:

const char* switch_xml_attr (  switch_xml_t  xml, 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 { 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] && 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 for (i = 0; root->attr[i] && strcmp(xml->name, root->attr[i][0]); i++); if (!root->attr[i]) return NULL; // no matching default attributes while (root->attr[i][j] && 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 )

returns the value of the requested tag attribute, or "" if not found Parameters: xml  the xml node attr  the attribute Returns: the value { const char *ret = switch_xml_attr(xml, attr); return ret ? ret : ""; }

Here is the call graph for this function:

switch_status_t switch_xml_bind_search_function (  switch_xml_search_function_t  function, switch_xml_section_t  sections, void *  user_data )

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 { 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; } switch_thread_rwlock_unlock(B_RWLOCK); return SWITCH_STATUS_SUCCESS; }

Here is the call graph for this function:

switch_xml_t switch_xml_child (  switch_xml_t  xml, 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 { xml = (xml) ? xml->child : NULL; while (xml && strcmp(name, xml->name)) xml = xml->sibling; return xml; }

switch_xml_t switch_xml_cut (  switch_xml_t  xml  )

removes a tag along with its subtags without freeing its memory Parameters: xml  the xml node { switch_xml_t cur; if (!xml) return NULL; // nothing to do if (xml->next) xml->next->sibling = xml->sibling; // patch sibling list if (xml->parent) { // not root tag cur = xml->parent->child; // find head of subtag list if (cur == xml) xml->parent->child = xml->ordered; // first subtag else { // not first subtag while (cur->ordered != xml) cur = cur->ordered; cur->ordered = cur->ordered->ordered; // patch ordered list cur = xml->parent->child; // go back to head of subtag list if (strcmp(cur->name, xml->name)) { // not in first sibling list while (strcmp(cur->sibling->name, xml->name)) cur = cur->sibling; if (cur->sibling == xml) { // first of a sibling list cur->sibling = (xml->next) ? xml->next : cur->sibling->sibling; } else cur = cur->sibling; // not first of a sibling list } while (cur->next && cur->next != xml) cur = cur->next; if (cur->next) cur->next = cur->next->next; // patch next list } } xml->ordered = xml->sibling = xml->next = NULL; // prevent switch_xml_free() from clobbering ordered list return xml; }

switch_status_t switch_xml_destroy (  void   )

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

Here is the call graph for this function:

const char* switch_xml_error (  switch_xml_t  xml  )

returns parser error message or empty string if none Parameters: xml  the xml node Returns: the error string or nothing { 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 )

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

Here is the call graph for this function:

void switch_xml_free (  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 { switch_xml_root_t root = (switch_xml_root_t) xml; int i, j; char **a, *s; if (!xml) return; if (switch_test_flag(xml, SWITCH_XML_ROOT)) { switch_mutex_lock(XML_COUNT_LOCK); if (lock_count > 0) { switch_thread_rwlock_unlock(RWLOCK); lock_count--; } switch_mutex_unlock(XML_COUNT_LOCK); } if (xml == MAIN_XML_ROOT) { return; } if (xml->free_path) { if (!switch_stristr("freeswitch.xml.fsxml", 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 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 #ifdef HAVE_MMAP else if (root->len) munmap(root->m, root->len); // mem mapped xml data #endif // HAVE_MMAP 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 free(xml); }

Here is the call graph for this function:

void switch_xml_free_in_thread (  switch_xml_t  xml, int  stacksize )

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

Here is the call graph for this function:

switch_xml_t switch_xml_get (  switch_xml_t  xml,   ... )

Traverses the switch_xml sturcture 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 { va_list ap; switch_xml_t r; va_start(ap, xml); r = switch_xml_vget(xml, ap); va_end(ap); return r; }

switch_xml_t switch_xml_idx (  switch_xml_t  xml, 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 { for (; xml && idx; idx--) xml = xml->next; return xml; }

switch_status_t switch_xml_init (  switch_memory_pool_t *  pool, 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 { switch_xml_t xml; XML_MEMORY_POOL = pool; *err = "Success"; switch_mutex_init(&XML_LOCK, SWITCH_MUTEX_NESTED, XML_MEMORY_POOL); switch_mutex_init(&XML_COUNT_LOCK, SWITCH_MUTEX_NESTED, XML_MEMORY_POOL); switch_thread_rwlock_create(&RWLOCK, XML_MEMORY_POOL); 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; } }

Here is the call graph for this function:

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

inserts an existing tag into an ezxml structure { switch_xml_t cur, prev, head; xml->next = xml->sibling = xml->ordered = NULL; xml->off = off; xml->parent = dest; if ((head = dest->child)) { // already have sub tags if (head->off <= off) { // not first subtag for (cur = head; cur->ordered && cur->ordered->off <= off; cur = cur->ordered); xml->ordered = cur->ordered; cur->ordered = xml; } else { // first subtag xml->ordered = head; dest->child = xml; } for (cur = head, prev = NULL; cur && strcmp(cur->name, xml->name); prev = cur, cur = cur->sibling); // find tag type if (cur && cur->off <= off) { // not first of type while (cur->next && cur->next->off <= off) cur = cur->next; xml->next = cur->next; cur->next = xml; } else { // first tag of this type if (prev && cur) prev->sibling = cur->sibling; // remove old first xml->next = cur; // old first tag is now next for (cur = head, prev = NULL; cur && cur->off <= off; prev = cur, cur = cur->sibling); // new sibling insert point xml->sibling = cur; if (prev) prev->sibling = xml; } } else dest->child = xml; // only sub tag return xml; }

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

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_xml_t conf = NULL; switch_xml_t tag = NULL; switch_xml_t xml = NULL; switch_xml_binding_t *binding; uint8_t loops = 0; switch_thread_rwlock_rdlock(B_RWLOCK); for (binding = BINDINGS; binding; binding = binding->next) { switch_xml_section_t sections = switch_xml_parse_section_string(section); 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 (switch_strlen_zero(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))) { *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; }

Here is the call graph for this function:

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

{ 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); if (my_params) { switch_event_destroy(&my_params); } return status; }

Here is the call graph for this function:

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

{ switch_status_t status = SWITCH_STATUS_FALSE; switch_event_t *my_params = NULL; *root = NULL; *user = NULL; *domain = 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 (ip) { if ((*user = switch_xml_find_child(*domain, "user", "ip", ip))) { status = SWITCH_STATUS_SUCCESS; goto end; } } if (user_name) { if (params != my_params && switch_event_get_header(params, (char *) "mailbox")) { if ((*user = switch_xml_find_child(*domain, "user", "mailbox", user_name))) { status = SWITCH_STATUS_SUCCESS; goto end; } } if ((*user = switch_xml_find_child(*domain, "user", key, user_name))) { status = SWITCH_STATUS_SUCCESS; goto end; } } end: if (my_params) { switch_event_destroy(&my_params); } return status; }

Here is the call graph for this function:

switch_xml_t switch_xml_new (  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 { static const char *ent[] = { "lt;", "<", "gt;", ">", "quot;", """, "apos;", "'", "amp;", "&", NULL }; switch_xml_root_t root = (switch_xml_root_t) memset(malloc(sizeof(struct switch_xml_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(malloc(sizeof(ent)), ent, sizeof(ent)); root->attr = root->pi = (char ***) (root->xml.attr = SWITCH_XML_NIL); return &root->xml; }

Here is the call graph for this function:

switch_xml_t switch_xml_open_cfg (  const char *  file_path, switch_xml_t *  node, 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 { switch_xml_t xml = NULL, cfg = NULL; *node = NULL; assert(MAIN_XML_ROOT != NULL); if (switch_xml_locate("configuration",