config.c File Reference

Common config file handling for res_cdrel_custom. More...

#include "cdrel.h"
#include "asterisk/config.h"
#include "asterisk/module.h"
#include "asterisk/paths.h"

Include dependency graph for res/cdrel_custom/config.c:

Go to the source code of this file.

Data Structures
struct	field_parse_result

Functions
struct cdrel_configs *	cdrel_load_module (enum cdrel_backend_type backend_type, enum cdrel_record_type record_type, const char *filename, const char *backend_name, void *log_cb)
	Perform initial module load.
int	cdrel_reload_module (enum cdrel_backend_type output_type, enum cdrel_record_type record_type, struct cdrel_configs **configs, const char *filename)
	Perform module reload.
int	cdrel_unload_module (enum cdrel_backend_type backend_type, enum cdrel_record_type record_type, struct cdrel_configs *configs, const char *backend_name)
	Perform module unload.
static struct cdrel_config *	config_alloc (enum cdrel_record_type record_type, enum cdrel_backend_type backend_type, enum cdrel_config_type config_type, const char *config_filename, const char *output_filename, const char *template)
static void	config_free (struct cdrel_config *config)
static struct cdrel_field *	field_alloc (struct cdrel_config *config, const char *input_field_template)
static void	field_template_vector_free (struct ast_vector_string *fields)
static int	load_config_file (enum cdrel_backend_type output_type, enum cdrel_record_type record_type, struct cdrel_configs *configs, const char *filename, int reload)
static int	load_database_columns (struct cdrel_config *config, const char *columns, int *column_count)
static struct cdrel_config *	load_database_config (enum cdrel_record_type record_type, struct ast_category *category, const char *config_filename)
static int	load_database_config_file (enum cdrel_record_type record_type, struct cdrel_configs *configs, const char *config_filename, int reload)
static int	load_fields (struct cdrel_config *config, struct ast_vector_string *fields)
static struct cdrel_config *	load_text_file_advanced_config (enum cdrel_record_type record_type, struct ast_category *category, const char *config_filename)
static int	load_text_file_config_file (enum cdrel_record_type record_type, struct cdrel_configs *configs, const char *config_filename, int reload)
static struct cdrel_config *	load_text_file_legacy_config (enum cdrel_record_type record_type, const char *config_filename, const char *output_filename, const char *template)
static int	load_text_file_legacy_mappings (enum cdrel_record_type record_type, struct cdrel_configs *configs, struct ast_category *category, const char *config_filename)
static char *	make_stmt_placeholders (int columns)
static int	open_database (struct cdrel_config *config)
static struct field_parse_result	parse_field (enum cdrel_record_type record_type, char *input_field_template)
static int	parse_legacy_template (enum cdrel_record_type record_type, const char *config_filename, const char *output_filename, const char *input_template, struct ast_vector_string *fields)
static int	register_backend (enum cdrel_record_type record_type, const char *backend_name, void *log_cb)
static int	unregister_backend (enum cdrel_record_type record_type, const char *backend_name)

Variables
static const char *	allowed_functions []
static const char *	dirname_map [cdrel_backend_type_end][cdrel_record_type_end]
static const char *	special_vars []

Detailed Description

Common config file handling for res_cdrel_custom.

Author

George Joseph gjose.nosp@m.ph@s.nosp@m.angom.nosp@m.a.co.nosp@m.m

This file is a 'bit' complex. The reasoning is that the functions do as much work as possible at module load time to reduce the workload at run time.

Definition in file res/cdrel_custom/config.c.

Function Documentation

cdrel_load_module()

struct cdrel_configs * cdrel_load_module	(	enum cdrel_backend_type	backend_type,
		enum cdrel_record_type	record_type,
		const char *	config_filename,
		const char *	backend_name,
		void *	logging_cb
	)

Perform initial module load.

Needs to be called by each "custom" module

Parameters

backend_type	One of cdrel_backend_type.
record_type	One of cdrel_record_type.
config_filename	The config file name.
backend_name	The name to register the backend as.
logging_cb	The logging callback to register with CDR or CEL.

Returns

A pointer to a VECTOR or config objects read from the config file.

Definition at line 1431 of file res/cdrel_custom/config.c.

{
    struct cdrel_configs *configs = ast_calloc(1, sizeof(*configs));
    if (!configs) {
        return NULL;
    }
    ast_debug(1, "Loading %s %s\n", RECORD_TYPE_STR(record_type), MODULE_TYPE_STR(backend_type));
 
    if (AST_VECTOR_INIT(configs, 5) != 0) {
        cdrel_unload_module(backend_type, record_type, configs, backend_name);
        return NULL;
    }
 
    if (load_config_file(backend_type, record_type, configs, filename, 0) != 0) {
        cdrel_unload_module(backend_type, record_type, configs, backend_name);
        return NULL;
    }
 
    if (register_backend(record_type, backend_name, log_cb)) {
        cdrel_unload_module(backend_type, record_type, configs, backend_name);
        return NULL;
    }
 
    return configs;
}

References ast_calloc, ast_debug, AST_VECTOR_INIT, cdrel_unload_module(), load_config_file(), MODULE_TYPE_STR, NULL, RECORD_TYPE_STR, and register_backend().

Referenced by load_module(), load_module(), load_module(), and load_module().

cdrel_reload_module()

int cdrel_reload_module	(	enum cdrel_backend_type	backend_type,
		enum cdrel_record_type	record_type,
		struct cdrel_configs **	configs,
		const char *	config_filename
	)

Perform module reload.

Needs to be called by each "custom" module

Warning

This function MUST be called with the module's config_lock held for writing to prevent reloads from happening while we're logging.

Parameters

backend_type	One of cdrel_backend_type.
record_type	One of cdrel_record_type.
configs	A pointer to the VECTOR of config objects returned by cdrel_load_module.
config_filename	The config file name.

Return values

AST_MODULE_LOAD_SUCCESS
AST_MODULE_LOAD_DECLINE

Definition at line 1391 of file res/cdrel_custom/config.c.

{
    int res = 0;
    struct cdrel_configs *old_configs = *configs;
    struct cdrel_configs *new_configs = NULL;
 
    /*
     * Save new config to a temporary vector to make sure the
     * configs are valid before swapping them in.
     */
    new_configs = ast_malloc(sizeof(*new_configs));
    if (!new_configs) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (AST_VECTOR_INIT(new_configs, AST_VECTOR_SIZE(old_configs)) != 0) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    res = load_config_file(output_type, record_type, new_configs, filename, 1);
    if (res != 0) {
        AST_VECTOR_RESET(new_configs, config_free);
        AST_VECTOR_PTR_FREE(new_configs);
        return AST_MODULE_LOAD_DECLINE;
    }
 
    /* Now swap the new ones in. */
    *configs = new_configs;
 
    /* Free the old ones. */
    AST_VECTOR_RESET(old_configs, config_free);
    AST_VECTOR_PTR_FREE(old_configs);
 
    return AST_MODULE_LOAD_SUCCESS;
 
 
    return -1;
}

References ast_malloc, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, AST_VECTOR_INIT, AST_VECTOR_PTR_FREE, AST_VECTOR_RESET, AST_VECTOR_SIZE, config_free(), load_config_file(), and NULL.

Referenced by reload(), reload(), reload(), and reload().

cdrel_unload_module()

int cdrel_unload_module	(	enum cdrel_backend_type	backend_type,
		enum cdrel_record_type	record_type,
		struct cdrel_configs *	configs,
		const char *	backend_name
	)

Perform module unload.

Needs to be called by each "custom" module

Warning

This function MUST be called with the module's config_lock held for writing to prevent the module from being unloaded while we're logging.

Parameters

backend_type	One of cdrel_backend_type.
record_type	One of cdrel_record_type.
configs	A pointer to the VECTOR of config objects returned by cdrel_load_module.
backend_name	The backend name to unregister.

Return values

0	Success.
-1	Failure.

Definition at line 1459 of file res/cdrel_custom/config.c.

{
    if (unregister_backend(record_type, backend_name) != 0) {
        return -1;
    }
 
    AST_VECTOR_RESET(configs, config_free);
    AST_VECTOR_PTR_FREE(configs);
 
    return 0;
}

References AST_VECTOR_PTR_FREE, AST_VECTOR_RESET, config_free(), and unregister_backend().

Referenced by cdrel_load_module(), unload_module(), unload_module(), unload_module(), and unload_module().

config_alloc()

static struct cdrel_config * config_alloc ( enum cdrel_record_type  record_type, enum cdrel_backend_type  backend_type, enum cdrel_config_type  config_type, const char *  config_filename, const char *  output_filename, const char *  template  )

static

Definition at line 655 of file res/cdrel_custom/config.c.

{
    RAII_VAR(struct cdrel_config *, config, NULL, config_free);
    struct cdrel_config *rtn_config = NULL;
    const char *file_suffix = "";
    int res = 0;
 
    ast_debug(1, "%s->%s: Loading\n", cdrel_basename(config_filename), cdrel_basename(output_filename));
 
    config = ast_calloc_with_stringfields(1, struct cdrel_config, 1024);
    if (!config) {
        return NULL;
    }
 
    if (ast_string_field_set(config, config_filename, config_filename) != 0) {
        return NULL;
    }
 
    config->record_type = record_type;
    config->backend_type = backend_type;
    config->dummy_channel_alloc = cdrel_dummy_channel_allocators[record_type];
    config->config_type = config_type;
 
    /* Set defaults */
    config->format_type = cdrel_format_dsv;
    config->separator[0] = ',';
    switch(backend_type) {
    case cdrel_backend_text:
        config->quote[0] = '"';
        config->quoting_method = cdrel_quoting_method_all;
        break;
    case cdrel_backend_db:
        config->quote[0] = '\0';
        config->format_type = cdrel_format_sql;
        config->quoting_method = cdrel_quoting_method_none;
        if (!ast_ends_with(output_filename, ".db")) {
            file_suffix = ".db";
        }
        break;
    default:
        ast_log(LOG_ERROR, "%s->%s: Unknown backend type '%d'\n", cdrel_basename(config_filename),
            cdrel_basename(output_filename), backend_type);
        break;
    }
    config->quote_escape[0] = config->quote[0];
 
    res = ast_string_field_set(config, template, template);
    if (res != 0) {
        return NULL;
    }
 
    if (output_filename[0] == '/') {
        res = ast_string_field_build(config, output_filename, "%s%s", output_filename, file_suffix);
    } else {
        const char *subdir = dirname_map[backend_type][record_type];
        res = ast_string_field_build(config, output_filename, "%s/%s%s%s%s",
            ast_config_AST_LOG_DIR, S_OR(subdir, ""), ast_strlen_zero(subdir) ? "" : "/", output_filename, file_suffix);
    }
    if (res != 0) {
        return NULL;
    }
    ast_mutex_init(&config->lock);
 
    rtn_config = config;
    config = NULL;
    return rtn_config;
}

References ast_calloc_with_stringfields, ast_config_AST_LOG_DIR, ast_debug, ast_ends_with(), ast_log, ast_mutex_init, ast_string_field_build, ast_string_field_set, ast_strlen_zero(), cdrel_backend_db, cdrel_backend_text, cdrel_basename(), cdrel_dummy_channel_allocators, cdrel_format_dsv, cdrel_format_sql, cdrel_quoting_method_all, cdrel_quoting_method_none, config, config_filename, config_free(), dirname_map, LOG_ERROR, NULL, RAII_VAR, and S_OR.

config_free()

static void config_free ( struct cdrel_config *  config )

static

Definition at line 618 of file res/cdrel_custom/config.c.

{
    if (!config) {
        return;
    }
 
    if (config->insert) {
        sqlite3_finalize(config->insert);
        config->insert = NULL;
    }
 
    if (config->db) {
        sqlite3_close(config->db);
        config->db = NULL;
    }
 
    ast_mutex_destroy(&config->lock);
    ast_string_field_free_memory(config);
    AST_VECTOR_RESET(&config->fields, ast_free);
    AST_VECTOR_FREE(&config->fields);
    ast_free(config);
}

References ast_free, ast_mutex_destroy, ast_string_field_free_memory, AST_VECTOR_FREE, AST_VECTOR_RESET, config, and NULL.

Referenced by cdrel_reload_module(), cdrel_unload_module(), config_alloc(), load_database_config(), load_database_config_file(), load_text_file_advanced_config(), load_text_file_config_file(), and load_text_file_legacy_mappings().

field_alloc()

static struct cdrel_field * field_alloc ( struct cdrel_config *  config, const char *  input_field_template  )

static

Definition at line 336 of file res/cdrel_custom/config.c.

{
    RAII_VAR(struct cdrel_field *, field, NULL, ast_free);
    const struct cdrel_field *registered_field = NULL;
    struct cdrel_field *rtn_field = NULL;
    char *field_name = NULL;
    char *data = NULL;
    char *tmp_data = NULL;
    char *closeparen = NULL;
    char *qualifier = NULL;
    enum cdrel_data_type forced_output_data_type = cdrel_data_type_end;
    struct ast_flags field_flags = { 0 };
 
    /*
     * The database fields are specified field-by-field for legacy so we treat them
     * as literals containing expressions which will be evaluated record-by-record.
     */
    if (config->backend_type == cdrel_backend_db && config->config_type == cdrel_config_legacy) {
        registered_field = get_registered_field_by_name(config->record_type, "literal");
        ast_assert(registered_field != NULL);
        rtn_field = ast_calloc(1, sizeof(*field) + strlen(input_field_template) + 1);
        if (!rtn_field) {
            return NULL;
        }
        memcpy(rtn_field, registered_field, sizeof(*registered_field));
        strcpy(rtn_field->data, input_field_template); /* Safe */
        return rtn_field;
    }
 
    /*
     * If the field template is a quoted string, it's a literal.
     * We don't check for qualifiers.
     */
    if (input_field_template[0] == '"' || input_field_template[0] == '\'') {
        data = ast_strip_quoted(ast_strdupa(input_field_template), "\"'", "\"'");
        ast_set_flag(&field_flags, cdrel_flag_literal);
        ast_debug(3, "   Using qualifier 'literal' for field '%s' flags: %s\n", data,
            ast_str_tmp(128, cdrel_get_field_flags(&field_flags, &STR_TMP)));
        field_name = "literal";
    } else {
        field_name = ast_strdupa(input_field_template);
        data = strchr(field_name, '(');
 
        if (data) {
            *data = '\0';
            data++;
            closeparen = strchr(data, ')');
            if (closeparen) {
                *closeparen = '\0';
            }
        }
    }
 
    if (!ast_strlen_zero(data) && !ast_test_flag(&field_flags, cdrel_flag_literal)) {
        char *data_swap = NULL;
        tmp_data = ast_strdupa(data);
 
        while((qualifier = ast_strsep(&tmp_data, '^', AST_STRSEP_STRIP | AST_STRSEP_TRIM))) {
            enum cdrel_data_type fodt = cdrel_data_type_end;
            if (ast_strlen_zero(qualifier)) {
                continue;
            }
            fodt = cdrel_data_type_from_str(qualifier);
            if (fodt < cdrel_data_type_end) {
                ast_set_flag(&field_flags, cdrel_flag_type_forced);
                if (fodt == cdrel_type_uservar) {
                    ast_set_flag(&field_flags, cdrel_flag_uservar);
                    ast_debug(3, "   Using qualifier '%s' for field '%s' flags: %s\n", qualifier,
                        field_name, ast_str_tmp(128, cdrel_get_field_flags(&field_flags, &STR_TMP)));
                    data_swap = ast_strdupa(field_name);
                    field_name = "uservar";
                } else if (fodt == cdrel_type_literal) {
                    ast_set_flag(&field_flags, cdrel_flag_literal);
                    ast_debug(3, "   Using qualifier '%s' for field '%s' flags: %s\n", qualifier,
                        field_name, ast_str_tmp(128, cdrel_get_field_flags(&field_flags, &STR_TMP)));
                    data_swap = ast_strdupa(field_name);
                    field_name = "literal";
                } else {
                    forced_output_data_type = fodt;
                    ast_debug(3, "   Using qualifier '%s' for field '%s' flags: %s\n", qualifier,
                        field_name, ast_str_tmp(128, cdrel_get_field_flags(&field_flags, &STR_TMP)));
                }
                continue;
            }
            if (strcasecmp(qualifier, "quote") == 0) {
                ast_set_flag(&field_flags, cdrel_flag_quote);
                ast_debug(3, "   Using qualifier '%s' for field '%s' flags: %s\n", qualifier,
                    field_name, ast_str_tmp(128, cdrel_get_field_flags(&field_flags, &STR_TMP)));
                continue;
            }
            if (strcasecmp(qualifier, "noquote") == 0) {
                ast_set_flag(&field_flags, cdrel_flag_noquote);
                ast_debug(3, "   Using qualifier '%s' for field '%s' flags: %s\n", qualifier,
                    field_name, ast_str_tmp(128, cdrel_get_field_flags(&field_flags, &STR_TMP)));
                continue;
            }
            if (strchr(qualifier, '%') != NULL) {
                data_swap = ast_strdupa(qualifier);
                ast_set_flag(&field_flags, cdrel_flag_format_spec);
                forced_output_data_type = cdrel_type_string;
                ast_debug(3, "   Using qualifier '%s' for field '%s' flags: %s\n", qualifier,
                    field_name, ast_str_tmp(128, cdrel_get_field_flags(&field_flags, &STR_TMP)));
            }
        }
        if (ast_test_flag(&field_flags, cdrel_flag_quote) && ast_test_flag(&field_flags, cdrel_flag_noquote)) {
            ast_log(LOG_WARNING, "%s->%s: Field '%s(%s)' has both quote and noquote\n",
                config->config_filename, config->output_filename, field_name, data);
            return NULL;
        }
        data = data_swap;
    }
 
    /*
     * Check again for literal.
     */
    if (ast_test_flag(&field_flags, cdrel_flag_literal)) {
        if (config->format_type == cdrel_format_json && !strchr(data, ':')) {
            ast_log(LOG_WARNING, "%s->%s: Literal field '%s' must be formatted as \"name: value\" when using the 'json' format\n",
                cdrel_basename(config->config_filename), cdrel_basename(config->output_filename),
                input_field_template);
            return NULL;
        }
    }
 
    /*
     * Now look the field up by just the field name without any data.
     */
    registered_field = get_registered_field_by_name(config->record_type, field_name);
    if (!registered_field) {
        ast_log(LOG_WARNING, "%s->%s: Field '%s' not found\n",
            cdrel_basename(config->config_filename), cdrel_basename(config->output_filename), field_name);
        return NULL;
    }
 
    if (ast_test_flag(&field_flags, cdrel_flag_format_spec)
        && registered_field->input_data_type != cdrel_type_timeval) {
        ast_log(LOG_WARNING, "%s->%s: Custom format '%s' ignored for field '%s'."
            " Only timeval types can use custom format strings.\n",
            cdrel_basename(config->config_filename), cdrel_basename(config->output_filename),
            data, field_name);
        forced_output_data_type = cdrel_data_type_end;
        ast_clear_flag(&field_flags, cdrel_flag_format_spec);
        data = NULL;
    }
 
    field = ast_calloc(1, sizeof(*registered_field) + strlen(input_field_template) + 1);
    if (!field) {
        return NULL;
    }
    memcpy(field, registered_field, sizeof(*field));
 
    if (!ast_strlen_zero(data)) {
        strcpy(field->data, data); /* Safe */
    }
 
    /*
     * For user variables, we use the field name from the data
     * we set above.
     */
    if (field->input_data_type == cdrel_type_uservar) {
        field->name = field->data;
    }
 
    if (field->input_data_type == cdrel_type_literal && config->format_type == cdrel_format_json) {
        /*
         * data should look something like this...  lname: lvalue
         * We'll need to make field->name point to "lname" and
         * field->data point to "lvalue" so that when output the
         * json will look like...  "lname": "lvalue".
         * Since field->data is already long enough to to handle both,
         * we'll do this...
         * field->data = lvalue\0lname\0
         * field->name =         ^
         */
        char *ptr = strchr(data, ':');/* Safe since we checked data for a ':' above */
        *ptr = '\0';
        ptr++;
        /*
         * data: lname\0 lvalue
         * ptr:         ^
         */
        strcpy(field->data, ast_strip_quoted(ptr, "\"", "\"")); /* Safe */
        /*
         * field->data: lvalue\0
         */
        ptr = field->data + strlen(field->data);
        ptr++;
        /*
         * field->data: lvalue\0
         * ptr:                 ^
         * data: lname\0 lvalue
         */
        strcpy(ptr, data); /* Safe */
        /*
         * field->data: lvalue\0lname\0
         */
        field->name = ptr;
        /*
         * field->data: lvalue\0lname\0
         * field->name:         ^
         */
    }
 
    if (forced_output_data_type < cdrel_data_type_end) {
        field->output_data_type = forced_output_data_type;
    }
    field->flags = field_flags;
 
    /*
     * Unless the field has the 'noquote' flag, we'll set the 'quote'
     * flag if quoting method is 'all' or 'non_numeric'.
     */
    if (!ast_test_flag(&field->flags, cdrel_flag_noquote)) {
        if (config->quoting_method == cdrel_quoting_method_all) {
            ast_set_flag(&field->flags, cdrel_flag_quote);
        } else if (config->quoting_method == cdrel_quoting_method_non_numeric) {
            if (field->output_data_type > cdrel_data_type_strings_end) {
                ast_set_flag(&field->flags, cdrel_flag_noquote);
            } else {
                ast_set_flag(&field->flags, cdrel_flag_quote);
            }
        }
    }
 
    if (config->quoting_method == cdrel_quoting_method_none) {
        ast_clear_flag(&field->flags, cdrel_flag_quote);
        ast_set_flag(&field->flags, cdrel_flag_noquote);
    }
 
    ast_debug(2, "%s->%s: Field '%s' processed -> name:'%s' input_type:%s output_type:%s flags:'%s' data:'%s'\n",
        cdrel_basename(config->config_filename), cdrel_basename(config->output_filename), input_field_template,
        field->name, DATA_TYPE_STR(field->input_data_type),
        DATA_TYPE_STR(field->output_data_type),
        ast_str_tmp(128, cdrel_get_field_flags(&field->flags, &STR_TMP)),
        field->data);
 
    rtn_field = field;
    field = NULL;
    return rtn_field;
}

References ast_assert, ast_calloc, ast_clear_flag, ast_debug, ast_free, ast_log, ast_set_flag, ast_str_tmp, ast_strdupa, ast_strip_quoted(), ast_strlen_zero(), ast_strsep(), AST_STRSEP_STRIP, AST_STRSEP_TRIM, ast_test_flag, cdrel_backend_db, cdrel_basename(), cdrel_config_legacy, cdrel_data_type_end, cdrel_data_type_from_str(), cdrel_data_type_strings_end, cdrel_flag_format_spec, cdrel_flag_literal, cdrel_flag_noquote, cdrel_flag_quote, cdrel_flag_type_forced, cdrel_flag_uservar, cdrel_format_json, cdrel_get_field_flags(), cdrel_quoting_method_all, cdrel_quoting_method_non_numeric, cdrel_quoting_method_none, cdrel_type_literal, cdrel_type_string, cdrel_type_timeval, cdrel_type_uservar, config, cdrel_field::data, DATA_TYPE_STR, get_registered_field_by_name(), cdrel_field::input_data_type, LOG_WARNING, NULL, and RAII_VAR.

Referenced by load_fields().

field_template_vector_free()

static void field_template_vector_free ( struct ast_vector_string *  fields )

static

Definition at line 577 of file res/cdrel_custom/config.c.

                                                                         {
    AST_VECTOR_RESET(fields, ast_free);
    AST_VECTOR_PTR_FREE(fields);
}

References ast_free, AST_VECTOR_PTR_FREE, and AST_VECTOR_RESET.

Referenced by load_database_config(), load_text_file_advanced_config(), and load_text_file_legacy_config().

load_config_file()

static int load_config_file ( enum cdrel_backend_type  output_type, enum cdrel_record_type  record_type, struct cdrel_configs *  configs, const char *  filename, int  reload  )

static

Definition at line 1378 of file res/cdrel_custom/config.c.

{
    switch(output_type) {
    case cdrel_backend_text:
        return load_text_file_config_file(record_type, configs, filename, reload);
    case cdrel_backend_db:
        return load_database_config_file(record_type, configs, filename, reload);
    default:
        return -1;
    }
}

References cdrel_backend_db, cdrel_backend_text, load_database_config_file(), load_text_file_config_file(), cdrel_config::record_type, and reload().

Referenced by cdrel_load_module(), and cdrel_reload_module().

load_database_columns()

static int load_database_columns ( struct cdrel_config *  config, const char *  columns, int *  column_count  )

static

Definition at line 735 of file res/cdrel_custom/config.c.

{
    char *col = NULL;
    char *cols = NULL;
    RAII_VAR(struct ast_str *, column_string, NULL, ast_free);
 
    ast_debug(1, "%s->%s: Loading columns\n", cdrel_basename(config->config_filename),
        cdrel_basename(config->output_filename));
 
    if (!(column_string = ast_str_create(1024))) {
        return -1;
    }
 
    cols = ast_strdupa(columns);
    *column_count = 0;
 
    /* We need to trim and remove any single or double quotes from each column name. */
    while((col = ast_strsep(&cols, ',', AST_STRSEP_TRIM))) {
        col = ast_strip(ast_strip_quoted(col, "'\"", "'\""));
        if (ast_str_append(&column_string, 0, "%s%s", *column_count ? "," : "", col) <= 0) {
            return -1;
        }
        (*column_count)++;
    }
 
    if (ast_string_field_set(config, db_columns, ast_str_buffer(column_string)) != 0) {
        return -1;
    }
 
    return 0;
}

References ast_debug, ast_free, ast_str_append(), ast_str_buffer(), ast_str_create, ast_strdupa, ast_string_field_set, ast_strip(), ast_strip_quoted(), ast_strsep(), AST_STRSEP_TRIM, cdrel_basename(), config, NULL, and RAII_VAR.

Referenced by load_database_config().

load_database_config()

static struct cdrel_config * load_database_config ( enum cdrel_record_type  record_type, struct ast_category *  category, const char *  config_filename  )

static

Definition at line 896 of file res/cdrel_custom/config.c.

{
    const char *category_name = ast_category_get_name(category);
    RAII_VAR(struct cdrel_config *, config, NULL, config_free);
    struct cdrel_config *rtn_config = NULL;
    int res = 0;
    int column_count = 0;
    int value_count = 0;
    int field_check_passed = 0;
    const char *template = ast_variable_find(category, "values");
    enum cdrel_config_type config_type;
    const char *value;
    char *tmp_fields = NULL;
    RAII_VAR(struct ast_vector_string *, field_templates, ast_calloc(1, sizeof(*field_templates)), field_template_vector_free);
 
    if (!ast_strlen_zero(template)) {
        config_type = cdrel_config_legacy;
    } else {
        template = ast_variable_find(category, "fields");
        if (!ast_strlen_zero(template)) {
            config_type = cdrel_config_advanced;
        }
    }
    if (ast_strlen_zero(template)) {
        ast_log(LOG_WARNING, "%s->%s: Neither 'values' nor 'fields' specified\n",
            cdrel_basename(config_filename), cdrel_basename(category_name));
        return NULL;
    }
 
    res = AST_VECTOR_INIT(field_templates, 25);
    if (res != 0) {
        return NULL;
    }
 
    /*
     * Let's try and and parse a legacy config to see if we can turn
     * it into an advanced condig.
     */
    if (config_type == cdrel_config_legacy) {
        field_check_passed = parse_legacy_template(record_type, config_filename,
            category_name, template, field_templates);
        if (field_check_passed) {
            config_type = cdrel_config_advanced;
            ast_log(LOG_NOTICE, "%s->%s: Legacy config upgraded to advanced\n",
                cdrel_basename(config_filename), cdrel_basename(category_name));
        } else {
            AST_VECTOR_RESET(field_templates, ast_free);
            ast_log(LOG_NOTICE, "%s->%s: Unable to upgrade legacy config to advanced. Continuing to process as legacy\n",
                cdrel_basename(config_filename), cdrel_basename(category_name));
        }
    }
 
    /*
     * If we could, the fields vector will be populated so we don't need to do it again.
     * If it was an advanced config or a legacy one we couldn't parse,
     * we need to split the string into the vector.
     */
    if (AST_VECTOR_SIZE(field_templates) == 0) {
        tmp_fields = ast_strdupa(template);
        while((value = ast_strsep(&tmp_fields, ',', AST_STRSEP_TRIM))) {
            res = AST_VECTOR_APPEND(field_templates, ast_strdup(value));
            if (res != 0) {
                return NULL;
            }
        }
    }
 
    config = config_alloc(record_type, cdrel_backend_db, config_type,
        config_filename, category_name, template);
    if (!config) {
        return NULL;
    }
 
    config->busy_timeout = 1000;
 
    res = ast_string_field_set(config, db_table,
        S_OR(ast_variable_find(category, "table"), config->record_type == cdrel_record_cdr ? "cdr" : "cel"));
    if (res != 0) {
        return NULL;
    }
 
    /* sqlite3_busy_timeout in miliseconds */
    if ((value = ast_variable_find(category, "busy_timeout")) != NULL) {
        if (ast_parse_arg(value, PARSE_INT32|PARSE_DEFAULT, &config->busy_timeout, 1000) != 0) {
            ast_log(LOG_WARNING, "%s->%s: Invalid busy_timeout value '%s' specified. Using 1000 instead.\n",
                cdrel_basename(config->config_filename), cdrel_basename(config->output_filename), value);
        }
    }
 
    /* Columns */
    value = ast_variable_find(category, "columns");
    if (ast_strlen_zero(value)) {
        ast_log(LOG_WARNING, "%s->%s: The 'columns' parameter is missing",
            cdrel_basename(config->config_filename), cdrel_basename(config->output_filename));
        return NULL;
    }
 
    if (load_database_columns(config, value, &column_count) != 0) {
        return NULL;
    }
 
    if (AST_VECTOR_INIT(&config->fields, AST_VECTOR_SIZE(field_templates)) != 0) {
        return NULL;
    }
 
    if (load_fields(config, field_templates) != 0) {
        return NULL;
    }
 
    value_count = AST_VECTOR_SIZE(&config->fields);
 
    if (value_count != column_count) {
        ast_log(LOG_WARNING, "%s->%s: There are %d columns but %d values\n",
            cdrel_basename(config->config_filename), cdrel_basename(config->output_filename),
            column_count, value_count);
        return NULL;
    }
 
    res = open_database(config);
    if (res != 0) {
        return NULL;
    }
 
    ast_log(LOG_NOTICE, "%s->%s: Logging %s records to table '%s'\n",
        cdrel_basename(config->config_filename), cdrel_basename(config->output_filename),
        RECORD_TYPE_STR(config->record_type),
        config->db_table);
 
    rtn_config = config;
    config = NULL;
    return rtn_config;
}

References ast_calloc, ast_category_get_name(), ast_free, ast_log, ast_parse_arg(), ast_strdup, ast_strdupa, ast_string_field_set, ast_strlen_zero(), ast_strsep(), AST_STRSEP_TRIM, ast_variable_find(), AST_VECTOR_APPEND, AST_VECTOR_INIT, AST_VECTOR_RESET, AST_VECTOR_SIZE, cdrel_backend_db, cdrel_basename(), cdrel_config_advanced, cdrel_config_legacy, cdrel_record_cdr, config, config_alloc(), config_filename, config_free(), field_template_vector_free(), load_database_columns(), load_fields(), LOG_NOTICE, LOG_WARNING, NULL, open_database(), PARSE_DEFAULT, PARSE_INT32, parse_legacy_template(), RAII_VAR, RECORD_TYPE_STR, S_OR, and value.

Referenced by load_database_config_file().

load_database_config_file()

static int load_database_config_file ( enum cdrel_record_type  record_type, struct cdrel_configs *  configs, const char *  config_filename, int  reload  )

static

Definition at line 1041 of file res/cdrel_custom/config.c.

{
    struct ast_config *cfg;
    struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
    struct ast_category *category = NULL;
 
    ast_debug(1, "%s: %soading\n", config_filename, reload ? "Rel" : "L");
    cfg = ast_config_load(config_filename, config_flags);
    if (!cfg || cfg == CONFIG_STATUS_FILEINVALID) {
        ast_log(LOG_ERROR, "Unable to load %s. Not logging %ss to custom database\n",
            config_filename, RECORD_TYPE_STR(record_type));
        return -1;
    } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
        ast_debug(1, "%s: Config file unchanged, not reloading\n", config_filename);
        return 0;
    }
 
    while ((category = ast_category_browse_filtered(cfg, NULL, category, NULL))) {
        struct cdrel_config *config = NULL;
 
        config = load_database_config(record_type, category, config_filename);
        if (!config) {
            continue;
        }
 
        if (AST_VECTOR_APPEND(configs, config) != 0) {
            config_free(config);
            break;
        }
    }
 
    ast_config_destroy(cfg);
 
    ast_log(LOG_NOTICE, "%s: Loaded %d configs\n", config_filename, (int)AST_VECTOR_SIZE(configs));
 
    /* Only fail if no configs were valid. */
    return AST_VECTOR_SIZE(configs) > 0 ? 0 : -1;
}

References ast_category_browse_filtered(), ast_config_destroy(), ast_config_load, ast_debug, ast_log, AST_VECTOR_APPEND, AST_VECTOR_SIZE, config, config_filename, CONFIG_FLAG_FILEUNCHANGED, config_free(), CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, load_database_config(), LOG_ERROR, LOG_NOTICE, NULL, RECORD_TYPE_STR, and reload().

Referenced by load_config_file().

load_fields()

static int load_fields ( struct cdrel_config *  config, struct ast_vector_string *  fields  )

static

Definition at line 591 of file res/cdrel_custom/config.c.

{
    int res = 0;
    int ix = 0;
 
    ast_debug(1, "%s->%s: Loading fields\n", cdrel_basename(config->config_filename),
        cdrel_basename(config->output_filename));
 
    for (ix = 0; ix < AST_VECTOR_SIZE(fields); ix++) {
        char *field_name = AST_VECTOR_GET(fields, ix);
        struct cdrel_field *field = NULL;
 
        field = field_alloc(config, field_name);
        if (!field) {
            res = -1;
            continue;
        }
 
        if (AST_VECTOR_APPEND(&config->fields, field) != 0) {
            ast_free(field);
            return -1;
        }
    }
 
    return res;
}

References ast_debug, ast_free, AST_VECTOR_APPEND, AST_VECTOR_GET, AST_VECTOR_SIZE, cdrel_basename(), config, field_alloc(), and NULL.

Referenced by load_database_config(), load_text_file_advanced_config(), and load_text_file_legacy_config().

load_text_file_advanced_config()

static struct cdrel_config * load_text_file_advanced_config ( enum cdrel_record_type  record_type, struct ast_category *  category, const char *  config_filename  )

static

Definition at line 1158 of file res/cdrel_custom/config.c.

{
    const char *category_name = ast_category_get_name(category);
    RAII_VAR(struct cdrel_config *, config, NULL, config_free);
    struct cdrel_config *rtn_config = NULL;
    const char *value;
    int res = 0;
    const char *fields_value = ast_variable_find(category, "fields");
    char *tmp_fields = NULL;
    RAII_VAR(struct ast_vector_string *, fields, ast_calloc(1, sizeof(*fields)), field_template_vector_free);
 
    if (ast_strlen_zero(fields_value)) {
        ast_log(LOG_WARNING, "%s->%s: Missing 'fields' parameter\n",
            cdrel_basename(config_filename), category_name);
        return NULL;
    }
 
    config = config_alloc(record_type, cdrel_backend_text, cdrel_config_advanced,
        config_filename, category_name, fields_value);
 
    value = ast_variable_find(category, "format");
    if (!ast_strlen_zero(value)) {
        if (ast_strings_equal(value, "json")) {
            config->format_type = cdrel_format_json;
            config->separator[0] = ',';
            config->quote[0] = '"';
            config->quote_escape[0] = '\\';
            config->quoting_method = cdrel_quoting_method_non_numeric;
        } else if (ast_strings_equal(value, "dsv")) {
            config->format_type = cdrel_format_dsv;
        } else {
            ast_log(LOG_WARNING, "%s->%s: Invalid format '%s'\n",
                cdrel_basename(config->config_filename), cdrel_basename(config->output_filename), value);
            return NULL;
        }
    }
 
    if (config->format_type != cdrel_format_json) {
        value = ast_variable_find(category, "separator_character");
        if (!ast_strlen_zero(value)) {
            ast_copy_string(config->separator, ast_unescape_c(ast_strdupa(value)), 2);
        }
 
        value = ast_variable_find(category, "quote_character");
        if (!ast_strlen_zero(value)) {
            ast_copy_string(config->quote, value, 2);
        }
 
        value = ast_variable_find(category, "quote_escape_character");
        if (!ast_strlen_zero(value)) {
            ast_copy_string(config->quote_escape, value, 2);
        }
 
        value = ast_variable_find(category, "quoting_method");
        if (!ast_strlen_zero(value)) {
            if (ast_strings_equal(value, "all")) {
                config->quoting_method = cdrel_quoting_method_all;
            } else if (ast_strings_equal(value, "minimal")) {
                config->quoting_method = cdrel_quoting_method_minimal;
            } else if (ast_strings_equal(value, "non_numeric")) {
                config->quoting_method = cdrel_quoting_method_non_numeric;
            } else if (ast_strings_equal(value, "none")) {
                config->quoting_method = cdrel_quoting_method_none;
            } else {
                ast_log(LOG_WARNING, "%s->%s: Invalid quoting method '%s'\n",
                    cdrel_basename(config->config_filename), cdrel_basename(config->output_filename), value);
                return NULL;
            }
        }
    }
 
    res = AST_VECTOR_INIT(fields, 20);
    if (res != 0) {
        return NULL;
    }
    tmp_fields = ast_strdupa(fields_value);
    while((value = ast_strsep(&tmp_fields, ',', AST_STRSEP_TRIM))) {
        res = AST_VECTOR_APPEND(fields, ast_strdup(value));
        if (res != 0) {
            return NULL;
        }
    }
 
    if (AST_VECTOR_INIT(&config->fields, AST_VECTOR_SIZE(fields)) != 0) {
        return NULL;
    }
 
    if (load_fields(config, fields) != 0) {
        return NULL;
    }
 
    ast_log(LOG_NOTICE, "%s->%s: Logging %s records\n",
        cdrel_basename(config->config_filename), cdrel_basename(config->output_filename),
        RECORD_TYPE_STR(config->record_type));
 
    rtn_config = config;
    config = NULL;
 
    return rtn_config;
}

References ast_calloc, ast_category_get_name(), ast_copy_string(), ast_log, ast_strdup, ast_strdupa, ast_strings_equal(), ast_strlen_zero(), ast_strsep(), AST_STRSEP_TRIM, ast_unescape_c(), ast_variable_find(), AST_VECTOR_APPEND, AST_VECTOR_INIT, AST_VECTOR_SIZE, cdrel_backend_text, cdrel_basename(), cdrel_config_advanced, cdrel_format_dsv, cdrel_format_json, cdrel_quoting_method_all, cdrel_quoting_method_minimal, cdrel_quoting_method_non_numeric, cdrel_quoting_method_none, config, config_alloc(), config_filename, config_free(), field_template_vector_free(), cdrel_config::fields, load_fields(), LOG_NOTICE, LOG_WARNING, NULL, RAII_VAR, cdrel_config::record_type, RECORD_TYPE_STR, and value.

Referenced by load_text_file_config_file().

load_text_file_config_file()

static int load_text_file_config_file ( enum cdrel_record_type  record_type, struct cdrel_configs *  configs, const char *  config_filename, int  reload  )

static

Definition at line 1310 of file res/cdrel_custom/config.c.

{
    struct ast_config *cfg;
    struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
    struct ast_category *category = NULL;
 
    ast_debug(1, "%s: %soading\n", config_filename, reload ? "Rel" : "L");
    cfg = ast_config_load(config_filename, config_flags);
    if (!cfg || cfg == CONFIG_STATUS_FILEINVALID) {
        ast_log(LOG_ERROR, "Unable to load %s. Not logging %ss to custom files\n",
            config_filename, RECORD_TYPE_STR(record_type));
        return -1;
    } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
        ast_debug(1, "%s: Config file unchanged, not reloading\n", config_filename);
        return 0;
    }
 
    while ((category = ast_category_browse_filtered(cfg, NULL, category, NULL))) {
        const char *category_name = ast_category_get_name(category);
 
        if (ast_strings_equal(category_name, "mappings")) {
            load_text_file_legacy_mappings(record_type, configs, category, config_filename);
        } else {
            struct cdrel_config * config = load_text_file_advanced_config(record_type, category,
                config_filename);
            if (!config) {
                continue;
            }
            if (AST_VECTOR_APPEND(configs, config) != 0) {
                config_free(config);
                return -1;
            }
        }
    }
 
    ast_config_destroy(cfg);
 
    ast_log(LOG_NOTICE, "%s: Loaded %d configs\n", config_filename, (int)AST_VECTOR_SIZE(configs));
 
    /* Only fail if no configs were valid. */
    return AST_VECTOR_SIZE(configs) > 0 ? 0 : -1;
}

References ast_category_browse_filtered(), ast_category_get_name(), ast_config_destroy(), ast_config_load, ast_debug, ast_log, ast_strings_equal(), AST_VECTOR_APPEND, AST_VECTOR_SIZE, config, config_filename, CONFIG_FLAG_FILEUNCHANGED, config_free(), CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, load_text_file_advanced_config(), load_text_file_legacy_mappings(), LOG_ERROR, LOG_NOTICE, NULL, cdrel_config::record_type, RECORD_TYPE_STR, and reload().

Referenced by load_config_file().

load_text_file_legacy_config()

static struct cdrel_config * load_text_file_legacy_config ( enum cdrel_record_type  record_type, const char *  config_filename, const char *  output_filename, const char *  template  )

static

Definition at line 1091 of file res/cdrel_custom/config.c.

{
    struct cdrel_config *config = NULL;
    int field_check_passed = 0;
    int res = 0;
    RAII_VAR(struct ast_vector_string *, fields, ast_calloc(1, sizeof(*fields)), field_template_vector_free);
 
    res = AST_VECTOR_INIT(fields, 25);
    if (res != 0) {
        return NULL;
    }
 
    /*
     * Let's try and and parse a legacy config to see if we can turn
     * it into an advanced condig.
     */
    field_check_passed = parse_legacy_template(record_type, config_filename,
        output_filename, template, fields);
 
    /*
     * If we couldn't, treat as legacy.
     */
    if (!field_check_passed) {
        config = config_alloc(record_type, cdrel_backend_text, cdrel_config_legacy,
            config_filename, output_filename, template);
        ast_log(LOG_NOTICE, "%s->%s: Logging legacy %s records\n",
            cdrel_basename(config->config_filename), cdrel_basename(config->output_filename),
            RECORD_TYPE_STR(config->record_type));
        return config;
    }
 
    config = config_alloc(record_type, cdrel_backend_text, cdrel_config_advanced,
        config_filename, output_filename, template);
    if (!config) {
        return NULL;
    }
    config->format_type = cdrel_format_dsv;
    config->quote[0] = '"';
    config->quote_escape[0] = '"';
    config->separator[0] = ',';
    config->quoting_method = cdrel_quoting_method_all;
 
    if (AST_VECTOR_INIT(&config->fields, AST_VECTOR_SIZE(fields)) != 0) {
        return NULL;
    }
 
    if (load_fields(config, fields) != 0) {
        return NULL;
    }
 
    ast_log(LOG_NOTICE, "%s->%s: Logging legacy %s records as advanced\n",
        cdrel_basename(config->config_filename), cdrel_basename(config->output_filename),
        RECORD_TYPE_STR(config->record_type));
 
    return config;
}

References ast_calloc, ast_log, AST_VECTOR_INIT, AST_VECTOR_SIZE, cdrel_backend_text, cdrel_basename(), cdrel_config_advanced, cdrel_config_legacy, cdrel_format_dsv, cdrel_quoting_method_all, config, config_alloc(), config_filename, field_template_vector_free(), cdrel_config::fields, load_fields(), LOG_NOTICE, NULL, cdrel_config::output_filename, parse_legacy_template(), RAII_VAR, cdrel_config::record_type, and RECORD_TYPE_STR.

Referenced by load_text_file_legacy_mappings().

load_text_file_legacy_mappings()

static int load_text_file_legacy_mappings ( enum cdrel_record_type  record_type, struct cdrel_configs *  configs, struct ast_category *  category, const char *  config_filename  )

static

Definition at line 1271 of file res/cdrel_custom/config.c.

{
    struct ast_variable *var = NULL;
 
    for (var = ast_category_first(category); var; var = var->next) {
        struct cdrel_config *config = NULL;
 
        if (ast_strlen_zero(var->name) || ast_strlen_zero(var->value)) {
            ast_log(LOG_WARNING, "%s: %s mapping must have both a filename and a template at line %d\n",
                cdrel_basename(config_filename), RECORD_TYPE_STR(config->record_type), var->lineno);
            continue;
        }
 
        config = load_text_file_legacy_config(record_type, config_filename, var->name, var->value);
        if (!config) {
            continue;
        }
 
        if (AST_VECTOR_APPEND(configs, config) != 0) {
            config_free(config);
            return -1;
        }
    }
 
    return 0;
}

References ast_category_first(), ast_log, ast_strlen_zero(), AST_VECTOR_APPEND, cdrel_basename(), config, config_filename, config_free(), load_text_file_legacy_config(), LOG_WARNING, ast_variable::next, NULL, cdrel_config::record_type, RECORD_TYPE_STR, and var.

Referenced by load_text_file_config_file().

make_stmt_placeholders()

static char * make_stmt_placeholders ( int  columns )

static

Definition at line 767 of file res/cdrel_custom/config.c.

{
    char *placeholders = ast_malloc(2 * columns), *c = placeholders;
    if (placeholders) {
        for (; columns; columns--) {
            *c++ = '?';
            *c++ = ',';
        }
        *(c - 1) = 0;
    }
    return placeholders;
}

References ast_malloc, and c.

Referenced by open_database().

open_database()

static int open_database ( struct cdrel_config *  config )

static

Definition at line 788 of file res/cdrel_custom/config.c.

{
    char *sql = NULL;
    int res = 0;
    char *placeholders = NULL;
 
    ast_debug(1, "%s->%s: opening database\n", cdrel_basename(config->config_filename),
        cdrel_basename(config->output_filename));
    res = sqlite3_open(config->output_filename, &config->db);
    if (res != SQLITE_OK) {
        ast_log(LOG_WARNING, "%s->%s: Could not open database\n", cdrel_basename(config->config_filename),
            cdrel_basename(config->output_filename));
        return -1;
    }
 
    sqlite3_busy_timeout(config->db, config->busy_timeout);
 
    /* is the table there? */
    sql = sqlite3_mprintf("SELECT COUNT(*) FROM %q;", config->db_table);
    if (!sql) {
        return -1;
    }
    res = sqlite3_exec(config->db, sql, NULL, NULL, NULL);
    sqlite3_free(sql);
    if (res != SQLITE_OK) {
        /*
         * Create the table.
         * We don't use %q for the column list here since we already escaped when building it
         */
        sql = sqlite3_mprintf("CREATE TABLE %q (AcctId INTEGER PRIMARY KEY, %s)",
            config->db_table, config->db_columns);
        res = sqlite3_exec(config->db, sql, NULL, NULL, NULL);
        sqlite3_free(sql);
        if (res != SQLITE_OK) {
            ast_log(LOG_WARNING, "%s->%s: Unable to create table '%s': %s\n",
                cdrel_basename(config->config_filename), cdrel_basename(config->output_filename),
                config->db_table, sqlite3_errmsg(config->db));
            return -1;
        }
    } else {
        /*
         * If the table exists, make sure the number of columns
         * matches the config.
         */
        sqlite3_stmt *get_stmt;
        int existing_columns = 0;
        int config_columns = AST_VECTOR_SIZE(&config->fields);
 
        sql = sqlite3_mprintf("SELECT * FROM %q;", config->db_table);
        if (!sql) {
            return -1;
        }
        res = sqlite3_prepare_v2(config->db, sql, -1, &get_stmt, NULL);
        sqlite3_free(sql);
        if (res != SQLITE_OK) {
            ast_log(LOG_WARNING, "%s->%s: Unable to get column count for table '%s': %s\n",
                cdrel_basename(config->config_filename), cdrel_basename(config->output_filename),
                config->db_table, sqlite3_errmsg(config->db));
            return -1;
        }
        /*
         * prepare figures out the number of columns that would be in a result
         * set. We don't need to execute the statement.
         */
        existing_columns = sqlite3_column_count(get_stmt);
        sqlite3_finalize(get_stmt);
        /* config_columns doesn't include the sequence field */
        if ((config_columns + 1) != existing_columns) {
            ast_log(LOG_WARNING, "%s->%s: The number of fields in the config (%d) doesn't equal the"
                " nummber of data columns (%d) in the existing %s table. This config is disabled.\n",
                cdrel_basename(config->config_filename), cdrel_basename(config->output_filename),
                config_columns, existing_columns - 1, config->db_table);
            return -1;
        }
    }
 
    placeholders = make_stmt_placeholders(AST_VECTOR_SIZE(&config->fields));
    if (!placeholders) {
        return -1;
    }
 
    /* Inserting NULL in the ID column still generates an ID */
    sql = sqlite3_mprintf("INSERT INTO %q VALUES (NULL,%s)", config->db_table, placeholders);
    ast_free(placeholders);
    if (!sql) {
        return -1;
    }
 
    res = sqlite3_prepare_v3(config->db, sql, -1, SQLITE_PREPARE_PERSISTENT, &config->insert, NULL);
    if (res != SQLITE_OK) {
        ast_log(LOG_ERROR, "%s->%s: Unable to prepare INSERT statement '%s': %s\n",
            cdrel_basename(config->config_filename), cdrel_basename(config->output_filename),
            sql, sqlite3_errmsg(config->db));
        return -1;
    }
 
    return 0;
}

References ast_debug, ast_free, ast_log, AST_VECTOR_SIZE, cdrel_basename(), config, LOG_ERROR, LOG_WARNING, make_stmt_placeholders(), and NULL.

Referenced by load_database_config().

parse_field()

static struct field_parse_result parse_field ( enum cdrel_record_type  record_type, char *  input_field_template  )

static

Definition at line 95 of file res/cdrel_custom/config.c.

{
    char *tmp_field = NULL;
    struct field_parse_result result = { 0, };
 
    /*
     * If the template starts with a double-quote, it's automatically
     * a literal.
     */
    if (input_field_template[0] == '"') {
        result.result = ast_strdup(ast_strip_quoted(ast_strdupa(input_field_template), "\"", "\""));
        result.csv_quote = 1;
        result.is_literal = 1;
        return result;
    }
 
    /*
     * If it starts with a single quote, it's probably a legacy SQL template
     * so we need to force quote it on output.
     */
    tmp_field = ast_strip(ast_strdupa(input_field_template));
 
    if (tmp_field[0] == '\'') {
        result.csv_quote = 1;
    }
 
    /*
     * I really hate the fact that ast_strip really trims whitespace
     * and ast_strip_quoted will strip anything in pairs.
     * Anyway, get rid of any remaining enclosing quotes.
     */
    tmp_field = ast_strip(ast_strip_quoted(tmp_field, "\"'", "\"'"));
 
    /*
     * If the template now starts with a '$' it's either a dialplan function
     * call or one of the special CEL field names.
     *
     * Examples: ${CSV_QUOTE(${CALLERID(name)})}
     *           ${eventtime}
     * We're going to iterate over function removal until there's just
     * a plain text string left.
     *
     */
    while (tmp_field[0] == '$') {
        char *ptr = NULL;
        /*
         * A function name longer that 64 characters is highly unlikely but
         * we'll check later.
         */
        char func_name[65];
 
        /*
         * Skip over the '$'
         * {CSV_QUOTE(${CALLERID(name)})}
         * {eventtime}
         */
        tmp_field++;
        /*
         * Remove any enclosing brace-like characters
         * CSV_QUOTE(${CALLERID(name)})
         * eventtime
         */
        tmp_field = ast_strip(ast_strip_quoted(tmp_field, "[{(", "]})"));
 
        /*
         * Check what's left to see if it matches a special variable.
         * If it does (like "eventtime" in the example), we're done.
         */
        if (strstr(special_vars[record_type], tmp_field) != NULL) {
            result.functions++;
            break;
        }
 
        /*
         * At this point, it has to be a function name so find the
         * openening '('.
         * CSV_QUOTE(${CALLERID(name)})
         *          ^
         * If we don't find one, it's something we don't recognise
         * so bail.
         */
        ptr = strchr(tmp_field, '(');
        if (!ptr) {
            result.parse_failed++;
            continue;
        }
 
        /*
         * Copy from the beginning to the '(' to func_name,
         * not exceeding func_name's size.
         *
         * CSV_QUOTE(${CALLERID(name)})
         *          ^
         * CSV_QUOTE
         *
         * Then check that it's a function we can handle.
         * If not, bail.
         */
        ast_copy_string(func_name, tmp_field, MIN(sizeof(func_name), ptr - tmp_field + 1));
        if (strstr(allowed_functions[record_type], func_name) == NULL) {
            result.parse_failed++;
            result.unknown_functions++;
            continue;
        }
        result.functions++;
        /*
         * If the function is CSV_QUOTE, we need to set the csv_quote flag.
         */
        if (strcmp("CSV_QUOTE", func_name) == 0) {
            result.csv_quote = 1;
        } else if (strcmp("CDR", func_name) == 0) {
            result.cdr = 1;
        }
 
        /*
         * ptr still points to the opening '(' so now strip it and the
         * matching parens.
         *
         * ${CALLERID(name)}
         *
         */
        tmp_field = ast_strip_quoted(ptr, "(", ")");
        if (tmp_field[0] == '"' || tmp_field[0] == '\'') {
            result.result = ast_strdup(ast_strip_quoted(tmp_field, "\"'", "\"'"));
            result.csv_quote = 1;
            result.is_literal = 1;
            return result;
        }
 
        /* Repeat the loop until there are no more functions or variables */
    }
 
    /*
     * If the parse failed we'll send back the entire template.
     */
    if (result.parse_failed) {
        tmp_field = input_field_template;
    } else {
        /*
         * If there were no functions or variables parsed then we'll
         * assume it's a literal.
         */
        if (result.functions == 0) {
            result.is_literal = 1;
        }
    }
 
    result.result = ast_strdup(tmp_field);
    if (result.result == NULL) {
        result.parse_failed = 1;
    }
 
    return result;
}

References allowed_functions, ast_copy_string(), ast_strdup, ast_strdupa, ast_strip(), ast_strip_quoted(), MIN, NULL, result, field_parse_result::result, and special_vars.

Referenced by parse_legacy_template().

parse_legacy_template()

static int parse_legacy_template ( enum cdrel_record_type  record_type, const char *  config_filename, const char *  output_filename, const char *  input_template, struct ast_vector_string *  fields  )

static

Definition at line 265 of file res/cdrel_custom/config.c.

{
    char *template = ast_strdupa(input_template);
    char *field_template = NULL;
    int res = 0;
 
    /*
     * We have no choice but to assume that a legacy config template uses commas
     * as field delimiters.  We don't have a reliable way to determine this ourselves.
     */
    while((field_template = ast_strsep(&template, ',', AST_STRSEP_TRIM))) {
        char *uservar = "";
        char *literal = "";
        /* Try to parse the field. */
        struct field_parse_result result = parse_field(record_type, field_template);
 
        ast_debug(2, "field: '%s' literal: %d quote: %d cdr: %d failed: %d funcs: %d unknfuncs: %d\n", result.result,
            result.is_literal, result.csv_quote, result.cdr,
            result.parse_failed, result.functions, result.unknown_functions);
 
        /*
         * If it failed,
         */
        if (!result.result || result.parse_failed) {
            ast_free(result.result);
            return 0;
        }
        if (result.is_literal) {
            literal = "literal^";
        }
 
        if (!get_registered_field_by_name(record_type, result.result)) {
            ast_debug(3, "   %s->%s: field '%s' not found\n", cdrel_basename(config_filename),
                cdrel_basename(output_filename), result.result);
            /*
             * If the result was found in a CDR function, treat it as a CDR user variable
             * otherwise treat it as a literal.
             */
            if (result.cdr) {
                uservar = "uservar^";
            } else {
                literal = "literal^";
            }
        }
        res = ast_asprintf(&field_template, "%s(%s%s)", result.result, S_OR(literal,uservar), result.csv_quote ? "quote" : "noquote");
        ast_free(result.result);
 
        if (!field_template || res < 0) {
            ast_free(field_template);
            return 0;
        }
        res = AST_VECTOR_APPEND(fields, field_template);
        if (res != 0) {
            ast_free(field_template);
            return 0;
        }
        ast_debug(2, "   field template: %s\n", field_template);
    }
 
    return 1;
}

References ast_asprintf, ast_debug, ast_free, ast_strdupa, ast_strsep(), AST_STRSEP_TRIM, AST_VECTOR_APPEND, cdrel_basename(), config_filename, get_registered_field_by_name(), NULL, parse_field(), result, and S_OR.

Referenced by load_database_config(), and load_text_file_legacy_config().

register_backend()

static int register_backend ( enum cdrel_record_type  record_type, const char *  backend_name, void *  log_cb  )

static

Definition at line 1354 of file res/cdrel_custom/config.c.

{
    switch(record_type) {
    case cdrel_record_cdr:
        return  ast_cdr_register(backend_name, "", log_cb);
    case cdrel_backend_db:
        return ast_cel_backend_register(backend_name, log_cb);
    default:
        return -1;
    }
}

References ast_cdr_register(), ast_cel_backend_register(), cdrel_backend_db, cdrel_record_cdr, and cdrel_config::record_type.

Referenced by cdrel_load_module().

unregister_backend()

static int unregister_backend ( enum cdrel_record_type  record_type, const char *  backend_name  )

static

Definition at line 1366 of file res/cdrel_custom/config.c.

{
    switch(record_type) {
    case cdrel_record_cdr:
        return ast_cdr_unregister(backend_name);
    case cdrel_record_cel:
        return ast_cel_backend_unregister(backend_name);
    default:
        return -1;
    }
}

References ast_cdr_unregister(), ast_cel_backend_unregister(), cdrel_record_cdr, cdrel_record_cel, and cdrel_config::record_type.

Referenced by cdrel_unload_module().

Variable Documentation

allowed_functions

const char* allowed_functions[]

static

Initial value:

= {
    [cdrel_record_cdr] = "CSV_QUOTE CDR CALLERID CHANNEL",
    [cdrel_record_cel] = "CSV_QUOTE CALLERID CHANNEL eventtype eventtime eventenum userdeftype eventextra BRIDGEPEER",
}

Definition at line 67 of file res/cdrel_custom/config.c.

                                         {
    [cdrel_record_cdr] = "CSV_QUOTE CDR CALLERID CHANNEL",
    [cdrel_record_cel] = "CSV_QUOTE CALLERID CHANNEL eventtype eventtime eventenum userdeftype eventextra BRIDGEPEER",
};

Referenced by parse_field().

dirname_map

const char* dirname_map[cdrel_backend_type_end][cdrel_record_type_end]

static

Definition at line 41 of file res/cdrel_custom/config.c.

                                                                                {
    [cdrel_backend_text] = {
        [cdrel_record_cdr] = "cdr-custom",
        [cdrel_record_cel] = "cel-custom",
    },
    [cdrel_backend_db] = {
        [cdrel_record_cdr] = NULL,
        [cdrel_record_cel] = NULL,
    }
};

Referenced by config_alloc().

special_vars

const char* special_vars[]

static

Initial value:

= {
    [cdrel_record_cdr] = "",
    [cdrel_record_cel] = "eventtype eventtime eventenum userdeftype eventextra BRIDGEPEER",
}

Definition at line 72 of file res/cdrel_custom/config.c.

                                    {
    [cdrel_record_cdr] = "",
    [cdrel_record_cel] = "eventtype eventtime eventenum userdeftype eventextra BRIDGEPEER",
};

Referenced by parse_field().