switch_xml_config.c File Reference

#include <switch.h>

Include dependency graph for switch_xml_config.c:

Go to the source code of this file.

Functions
switch_size_t	switch_event_import_xml (switch_xml_t xml, const char *keyname, const char *valuename, switch_event_t **event)
	Parses a list of xml elements into an event. More...
switch_status_t	switch_xml_config_parse_module_settings (const char *file, switch_bool_t reload, switch_xml_config_item_t *instructions)
	Parses a module's settings. More...
void	switch_xml_config_item_print_doc (int level, switch_xml_config_item_t *item)
	Prints out an item's documentation on the console. More...
switch_status_t	switch_xml_config_parse (switch_xml_t xml, switch_bool_t reload, switch_xml_config_item_t *instructions)
	Parses all the xml elements, following a ruleset defined by an array of switch_xml_config_item_t. More...
switch_status_t	switch_xml_config_enum_str2int (switch_xml_config_enum_item_t *enum_options, const char *value, int *out)
	Gets the int representation of an enum. More...
const char *	switch_xml_config_enum_int2str (switch_xml_config_enum_item_t *enum_options, int value)
	Gets the string representation of an enum. More...
switch_status_t	switch_xml_config_parse_event (switch_event_t *event, int count, switch_bool_t reload, switch_xml_config_item_t *instructions)
	Parses all of an event's elements, following a ruleset defined by an array of switch_xml_config_item_t. More...
void	switch_xml_config_cleanup (switch_xml_config_item_t *instructions)
	Free any memory allocated by the configuration. More...
void	switch_config_perform_set_item (switch_xml_config_item_t *item, const char *key, switch_xml_config_type_t type, int flags, void *ptr, const void *defaultvalue, void *data, switch_xml_config_callback_t function, const char *syntax, const char *helptext)

Variables
switch_xml_config_string_options_t	switch_config_string_strdup = { NULL, 0, NULL }
static switch_xml_config_enum_item_t	switch_config_types_enum []

Function Documentation

void switch_config_perform_set_item	(	switch_xml_config_item_t *	item,
		const char *	key,
		switch_xml_config_type_t	type,
		int	flags,
		void *	ptr,
		const void *	defaultvalue,
		void *	data,
		switch_xml_config_callback_t	function,
		const char *	syntax,
		const char *	helptext
	)

Definition at line 477 of file switch_xml_config.c.

{
        item->key = key;
        item->type = type;
        item->flags = flags;
        item->ptr = ptr;
        item->defaultvalue = defaultvalue;
        item->data = data;
        item->function = function;
        item->syntax = syntax;
        item->helptext = helptext;
}

switch_size_t switch_event_import_xml	(	switch_xml_t	xml,
		const char *	keyname,
		const char *	valuename,
		switch_event_t **	event
	)

Parses a list of xml elements into an event.

Parameters

xml	First element of the xml list to parse
keyname	Name of the key attribute
keyvalue	Name of the value attribute
event	[out] event (if *event is NOT NULL, the headers will be appended to the existing event)

Definition at line 49 of file switch_xml_config.c.

References switch_xml::next, switch_assert, switch_event_add_header_string(), SWITCH_EVENT_CLONE, switch_event_create, SWITCH_STACK_BOTTOM, and switch_xml_attr_soft().

Referenced by switch_xml_config_parse().

{
        switch_xml_t node;
        switch_size_t count = 0;

        if (!*event) {
                /* SWITCH_EVENT_CLONE will not insert any generic event headers */
                switch_event_create(event, SWITCH_EVENT_CLONE);
                switch_assert(*event);
        }

        for (node = xml; node; node = node->next) {
                const char *key = switch_xml_attr_soft(node, keyname);
                const char *value = switch_xml_attr_soft(node, valuename);
                if (key && value) {
                        switch_event_add_header_string(*event, SWITCH_STACK_BOTTOM, key, value);
                        count++;
                }
        }

        return count;
}

void switch_xml_config_cleanup

(

switch_xml_config_item_t *

instructions

)

Free any memory allocated by the configuration.

Parameters

instructions

instrutions on how to parse the elements

Definition at line 447 of file switch_xml_config.c.

References CONFIG_SHUTDOWN, switch_xml_config_item::data, switch_xml_config_item::function, switch_xml_config_item::key, switch_xml_config_item::ptr, SWITCH_CONFIG_STRING, SWITCH_FALSE, switch_safe_free, and switch_xml_config_item::type.

{
        switch_xml_config_item_t *item;

        for (item = instructions; item->key; item++) {
                switch_xml_config_callback_t callback = (switch_xml_config_callback_t) item->function;

                switch (item->type) {
                case SWITCH_CONFIG_STRING:
                        {
                                char **ptr = (char **) item->ptr;
                                switch_xml_config_string_options_t *string_options = (switch_xml_config_string_options_t *) item->data;
                                /* if (using_strdup) */
                                if (string_options && !string_options->pool && !string_options->length) {
                                        switch_safe_free(*ptr);
                                }
                        }
                        break;
                default:
                        break;
                }

                if (callback) {
                        callback(item, NULL, CONFIG_SHUTDOWN, SWITCH_FALSE);
                }

        }
}

const char* switch_xml_config_enum_int2str	(	switch_xml_config_enum_item_t *	enum_options,
		int	value
	)

Gets the string representation of an enum.

Parameters

enum_options	the switch_xml_config_enum_item_t array for this enum
value	int value to search

Definition at line 127 of file switch_xml_config.c.

Referenced by switch_xml_config_item_print_doc().

{
        for (; enum_options->key; enum_options++) {
                if (value == enum_options->value) {
                        return enum_options->key;
                }
        }
        return NULL;
}

switch_status_t switch_xml_config_enum_str2int	(	switch_xml_config_enum_item_t *	enum_options,
		const char *	value,
		int *	out
	)

Gets the int representation of an enum.

Parameters

enum_options	the switch_xml_config_enum_item_t array for this enum
value	string value to search

Definition at line 115 of file switch_xml_config.c.

References SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_xml_config_parse_event().

{
        for (; enum_options->key; enum_options++) {
                if (!strcasecmp(value, enum_options->key)) {
                        *out = enum_options->value;
                        return SWITCH_STATUS_SUCCESS;
                }
        }

        return SWITCH_STATUS_FALSE;
}

void switch_xml_config_item_print_doc	(	int	level,
		switch_xml_config_item_t *	item
	)

Prints out an item's documentation on the console.

Parameters

level	loglevel to use
item	item which the doc should be printed

Definition at line 91 of file switch_xml_config.c.

References CONFIG_REQUIRED, SWITCH_CHANNEL_LOG_CLEAN, switch_log_printf(), switch_test_flag, and switch_xml_config_enum_int2str().

Referenced by switch_xml_config_parse_event().

{
        if (item->syntax && item->helptext) {
                switch_log_printf(SWITCH_CHANNEL_LOG_CLEAN, level, "Item name: [%s]\nType: %s (%s)\nSyntax: %s\nHelp: %s\n\n",
                                                  item->key, switch_xml_config_enum_int2str(switch_config_types_enum, item->type),
                                                  switch_test_flag(item, CONFIG_REQUIRED) ? "required" : "optional", item->syntax, item->helptext);
        }
}

switch_status_t switch_xml_config_parse	(	switch_xml_t	xml,
		switch_bool_t	reload,
		switch_xml_config_item_t *	instructions
	)

Parses all the xml elements, following a ruleset defined by an array of switch_xml_config_item_t.

Parameters

xml	The first element of the list to parse
reload	true to skip all non-reloadable options
instructions	instrutions on how to parse the elements

See also

switch_xml_config_item_t

Definition at line 100 of file switch_xml_config.c.

References switch_event_destroy(), switch_event_import_xml(), and switch_xml_config_parse_event().

Referenced by switch_xml_config_parse_module_settings().

{
        switch_event_t *event = NULL;
        switch_status_t result;
        int count = (int)switch_event_import_xml(xml, "name", "value", &event);

        result = switch_xml_config_parse_event(event, count, reload, instructions);

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

        return result;
}

switch_status_t switch_xml_config_parse_event	(	switch_event_t *	event,
		int	count,
		switch_bool_t	reload,
		switch_xml_config_item_t *	instructions
	)

Parses all of an event's elements, following a ruleset defined by an array of switch_xml_config_item_t.

Parameters

event	The event structure containing the key and values to parse
reload	true to skip all non-reloadable options
instructions	instrutions on how to parse the elements

See also

switch_xml_config_item_t

Definition at line 137 of file switch_xml_config.c.

References CONFIG_LOAD, CONFIG_RELOAD, CONFIG_RELOADABLE, CONFIG_REQUIRED, switch_xml_config_item::data, switch_xml_config_item::defaultvalue, switch_xml_config_int_options_t::enforce_max, switch_xml_config_atomic_options_t::enforce_max, switch_xml_config_int_options_t::enforce_min, switch_xml_config_atomic_options_t::enforce_min, switch_xml_config_item::function, if(), switch_xml_config_item::key, switch_xml_config_string_options_t::length, switch_xml_config_int_options_t::max, switch_xml_config_atomic_options_t::max, switch_xml_config_int_options_t::min, switch_xml_config_atomic_options_t::min, switch_event_header::name, switch_event_header::next, switch_xml_config_string_options_t::pool, switch_xml_config_item::ptr, switch_atomic_read(), switch_atomic_set(), SWITCH_CHANNEL_LOG, SWITCH_CONFIG_ATOMIC, SWITCH_CONFIG_BOOL, SWITCH_CONFIG_CUSTOM, SWITCH_CONFIG_ENUM, SWITCH_CONFIG_FLAG, SWITCH_CONFIG_FLAGARRAY, SWITCH_CONFIG_INT, SWITCH_CONFIG_LAST, SWITCH_CONFIG_STRING, switch_copy_string(), switch_core_strdup, switch_event_get_header, SWITCH_FALSE, switch_false(), switch_is_number(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_regex_match(), switch_safe_free, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_test_flag, SWITCH_TRUE, switch_true(), switch_xml_config_enum_str2int(), switch_xml_config_item_print_doc(), switch_xml_config_item::type, switch_xml_config_string_options_t::validation_regex, and zstr.

Referenced by switch_xml_config_parse().

{
        switch_xml_config_item_t *item;
        int matched_count = 0;

        for (item = instructions; item->key; item++) {
                const char *value = switch_event_get_header(event, item->key);
                switch_bool_t changed = SWITCH_FALSE;
                switch_xml_config_callback_t callback = (switch_xml_config_callback_t) item->function;
                void *ptr = item->ptr;

                //switch_assert(ptr);

                if (value) {
                        matched_count++;
                }

                if (reload && !switch_test_flag(item, CONFIG_RELOADABLE)) {
                        continue;
                }

                if (!value && switch_test_flag(item, CONFIG_REQUIRED)) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Required parameter [%s] is missing\n", item->key);
                        return SWITCH_STATUS_FALSE;
                }

                switch (item->type) {
                case SWITCH_CONFIG_INT:
                        {
                                switch_xml_config_int_options_t *int_options = (switch_xml_config_int_options_t *) item->data;
                                int *dest = (int *) ptr;
                                int intval;
                                if (value) {
                                        if (switch_is_number(value)) {
                                                intval = atoi(value);
                                        } else {
                                                intval = (int) (intptr_t) item->defaultvalue;
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid value [%s] for parameter [%s], setting default [%d]\n",
                                                                                  value, item->key, intval);
                                        }

                                        if (int_options) {
                                                /* Enforce validation options */
                                                if ((int_options->enforce_min && !(intval >= int_options->min)) || (int_options->enforce_max && !(intval <= int_options->max))) {
                                                        /* Validation failed, set default */
                                                        intval = (int) (intptr_t) item->defaultvalue;
                                                        /* Then complain */
                                                        if (int_options->enforce_min && int_options->enforce_max) {
                                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
                                                                                                  "Invalid value [%s] for parameter [%s], should be between [%d] and [%d], setting default [%d]\n", value,
                                                                                                  item->key, int_options->min, int_options->max, intval);
                                                        } else {
                                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
                                                                                                  "Invalid value [%s] for parameter [%s], should be %s [%d], setting default [%d]\n", value, item->key,
                                                                                                  int_options->enforce_min ? "at least" : "at max",
                                                                                                  int_options->enforce_min ? int_options->min : int_options->max, intval);
                                                        }
                                                }
                                        }
                                } else {
                                        intval = (int) (intptr_t) item->defaultvalue;
                                }

                                if (*dest != intval) {
                                        *dest = intval;
                                        changed = SWITCH_TRUE;
                                }
                        }
                        break;
                case SWITCH_CONFIG_ATOMIC:
                        {
                                switch_xml_config_atomic_options_t *atomic_options = (switch_xml_config_atomic_options_t *) item->data;
                                switch_atomic_t *dest = (switch_atomic_t *) ptr;
                                uint32_t uintval;
                                if (value) {
                                        if (switch_is_number(value)) {
                                                uintval = (uint32_t) strtol(value, NULL, 10);
                                        } else {
                                                uintval = (uint32_t) (uintptr_t) item->defaultvalue;
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid value [%s] for parameter [%s], setting default [%u]\n",
                                                                                  value, item->key, uintval);
                                        }

                                        if (atomic_options) {
                                                /* Enforce validation options */
                                                if ((atomic_options->enforce_min && !(uintval >= atomic_options->min)) || (atomic_options->enforce_max && !(uintval <= atomic_options->max))) {
                                                        /* Validation failed, set default */
                                                        uintval = (uint32_t) (uintptr_t) item->defaultvalue;
                                                        /* Then complain */
                                                        if (atomic_options->enforce_min && atomic_options->enforce_max) {
                                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
                                                                                                  "Invalid value [%s] for parameter [%s], should be between [%u] and [%u], setting default [%u]\n", value,
                                                                                                  item->key, atomic_options->min, atomic_options->max, uintval);
                                                        } else {
                                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
                                                                                                  "Invalid value [%s] for parameter [%s], should be %s [%u], setting default [%u]\n", value, item->key,
                                                                                                  atomic_options->enforce_min ? "at least" : "at max",
                                                                                                  atomic_options->enforce_min ? atomic_options->min : atomic_options->max, uintval);
                                                        }
                                                }
                                        }
                                } else {
                                        uintval = (uint32_t) (uintptr_t) item->defaultvalue;
                                }

                                if (switch_atomic_read(dest) != uintval) {
                                        switch_atomic_set(dest, uintval);
                                        changed = SWITCH_TRUE;
                                }
                        }
                        break;
                case SWITCH_CONFIG_STRING:
                        {
                                switch_xml_config_string_options_t string_options_default = { 0 };
                                switch_xml_config_string_options_t *string_options =
                                        item->data ? (switch_xml_config_string_options_t *) item->data : &string_options_default;
                                const char *newstring = NULL;

                                /* Perform validation */
                                if (value) {
                                        if (!zstr(string_options->validation_regex)) {
                                                if (switch_regex_match(value, string_options->validation_regex) == SWITCH_STATUS_SUCCESS) {
                                                        newstring = value;      /* Regex match, accept value */
                                                } else {
                                                        newstring = (char *) item->defaultvalue;        /* Regex failed */
                                                        if (newstring) {
                                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid value [%s] for parameter [%s], setting default [%s]\n",
                                                                                                  value, item->key, newstring);
                                                        } else {
                                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid value [%s] for parameter [%s]\n", value, item->key);
                                                        }
                                                        switch_xml_config_item_print_doc(SWITCH_LOG_ERROR, item);
                                                }
                                        } else {
                                                newstring = value;      /* No validation */
                                        }
                                } else {
                                        newstring = (char *) item->defaultvalue;
                                }

                                if (string_options->length > 0) {
                                        /* We have a preallocated buffer */
                                        char *dest = (char *) ptr;

                                        if (newstring) {
                                                if (strncasecmp(dest, newstring, string_options->length)) {
                                                        switch_copy_string(dest, newstring, string_options->length);
                                                        changed = SWITCH_TRUE;
                                                }
                                        } else {
                                                if (*dest != '\0') {
                                                        *dest = '\0';
                                                        changed = SWITCH_TRUE;
                                                }
                                        }
                                } else if (string_options->pool) {
                                        /* Pool-allocated buffer */
                                        char **dest = (char **) ptr;

                                        if (newstring) {
                                                if (!*dest || strcmp(*dest, newstring)) {
                                                        *dest = switch_core_strdup(string_options->pool, newstring);
                                                }
                                        } else {
                                                if (*dest) {
                                                        changed = SWITCH_TRUE;
                                                        *dest = NULL;
                                                }
                                        }
                                } else {
                                        /* Dynamically allocated buffer */
                                        char **dest = (char **) ptr;

                                        if (newstring) {
                                                if (!*dest || strcmp(*dest, newstring)) {
                                                        switch_safe_free(*dest);
                                                        *dest = strdup(newstring);
                                                        changed = SWITCH_TRUE;
                                                }
                                        } else {
                                                if (*dest) {
                                                        switch_safe_free(*dest);
                                                        changed = SWITCH_TRUE;
                                                }
                                        }
                                }
                        }
                        break;
                case SWITCH_CONFIG_BOOL:
                        {
                                switch_bool_t *dest = (switch_bool_t *) ptr;
                                switch_bool_t newval = SWITCH_FALSE;

                                if (value && switch_true(value)) {
                                        newval = SWITCH_TRUE;
                                } else if (value && switch_false(value)) {
                                        newval = SWITCH_FALSE;
                                } else if (value) {
                                        /* Value isnt true or false */
                                        newval = (switch_bool_t) (intptr_t) item->defaultvalue;
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid value [%s] for parameter [%s], setting default [%s]\n",
                                                                          value, item->key, newval ? "true" : "false");
                                        switch_xml_config_item_print_doc(SWITCH_LOG_ERROR, item);
                                } else {
                                        newval = (switch_bool_t) (intptr_t) item->defaultvalue;
                                }

                                if (*dest != newval) {
                                        *dest = newval;
                                        changed = SWITCH_TRUE;
                                }
                        }
                        break;
                case SWITCH_CONFIG_CUSTOM:
                        break;
                case SWITCH_CONFIG_ENUM:
                        {
                                switch_xml_config_enum_item_t *enum_options = (switch_xml_config_enum_item_t *) item->data;
                                int *dest = (int *) ptr;
                                int newval = 0;
                                switch_status_t lookup_result = SWITCH_STATUS_SUCCESS;

                                if (value) {
                                        lookup_result = switch_xml_config_enum_str2int(enum_options, value, &newval);
                                } else {
                                        newval = (int) (intptr_t) item->defaultvalue;
                                }

                                if (lookup_result != SWITCH_STATUS_SUCCESS) {
                                        newval = (int) (intptr_t) item->defaultvalue;
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid value [%s] for parameter [%s]\n", value, item->key);
                                        switch_xml_config_item_print_doc(SWITCH_LOG_ERROR, item);
                                }

                                if (*dest != newval) {
                                        changed = SWITCH_TRUE;
                                        *dest = newval;
                                }
                        }
                        break;
                case SWITCH_CONFIG_FLAG:
                        {
                                int32_t *dest = (int32_t *) ptr;
                                int index = (int) (intptr_t) item->data;
                                int8_t currentval = (int8_t) ! !(*dest & index);
                                int newval = 0;

                                if (value) {
                                        newval = switch_true(value);
                                } else {
                                        newval = (switch_bool_t) (intptr_t) item->defaultvalue;
                                }

                                if (newval != currentval) {
                                        changed = SWITCH_TRUE;
                                        if (newval) {
                                                *dest |= (1 << index);
                                        } else {
                                                *dest &= ~(1 << index);
                                        }
                                }
                        }
                        break;
                case SWITCH_CONFIG_FLAGARRAY:
                        {
                                int8_t *dest = (int8_t *) ptr;
                                unsigned int index = (unsigned int) (intptr_t) item->data;
                                int8_t newval = value ? !!switch_true(value) : (int8_t) ((intptr_t) item->defaultvalue);
                                if (dest[index] != newval) {
                                        changed = SWITCH_TRUE;
                                        dest[index] = newval;
                                }
                        }
                        break;
                case SWITCH_CONFIG_LAST:
                        break;
                default:
                        break;
                }

                if (callback) {
                        callback(item, value, (reload ? CONFIG_RELOAD : CONFIG_LOAD), changed);
                }
        }

        if (count != matched_count) {
                /* User made a mistake, find it */
                switch_event_header_t *header;
                for (header = event->headers; header; header = header->next) {
                        switch_bool_t found = SWITCH_FALSE;
                        for (item = instructions; item->key; item++) {
                                if (!strcasecmp(header->name, item->key)) {
                                        found = SWITCH_TRUE;
                                        break;
                                }
                        }

                        if (!found) {
                                /* Tell the user */
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING,
                                                                  "Configuration parameter [%s] is unfortunately not valid, you might want to double-check that.\n", header->name);
                        }
                }
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_xml_config_parse_module_settings	(	const char *	file,
		switch_bool_t	reload,
		switch_xml_config_item_t *	instructions
	)

Parses a module's settings.

Parameters

reload	true to skip all non-reloadable options
file	the configuration file to look for
instructions	the instructions

Definition at line 72 of file switch_xml_config.c.

References SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_xml_child(), switch_xml_config_parse(), switch_xml_free(), and switch_xml_open_cfg().

{
        switch_xml_t cfg, xml, settings;
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        if (!(xml = switch_xml_open_cfg(file, &cfg, NULL))) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not open %s\n", file);
                return SWITCH_STATUS_FALSE;
        }

        if ((settings = switch_xml_child(cfg, "settings"))) {
                status = switch_xml_config_parse(switch_xml_child(settings, "param"), reload, instructions);
        }

        switch_xml_free(xml);

        return status;
}

Variable Documentation

switch_xml_config_string_options_t switch_config_string_strdup = { NULL, 0, NULL }

Definition at line 35 of file switch_xml_config.c.

switch_xml_config_enum_item_t switch_config_types_enum[]

static

Initial value:

= {
        {"int", SWITCH_CONFIG_INT},
        {"switch_atomic_t", SWITCH_CONFIG_INT},
        {"string", SWITCH_CONFIG_STRING},
        {"bool", SWITCH_CONFIG_BOOL},
        {"custom", SWITCH_CONFIG_CUSTOM},
        {"enum", SWITCH_CONFIG_ENUM},
        {"flag", SWITCH_CONFIG_FLAG},
        {"flagarray", SWITCH_CONFIG_FLAGARRAY},
        {NULL, 0}
}

Definition at line 37 of file switch_xml_config.c.