res_config_sqlite3.c File Reference

SQLite 3 configuration engine. More...

#include "asterisk.h"
#include <sqlite3.h>
#include "asterisk/module.h"
#include "asterisk/config.h"
#include "asterisk/paths.h"
#include "asterisk/astobj2.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "asterisk/app.h"

Include dependency graph for res_config_sqlite3.c:

Go to the source code of this file.

Data Structures
struct	cfg_entry_args
struct	realtime_sqlite3_db
struct	row_counter_args

Macros
#define	DB_BUCKETS   7
#define	IS_SQL_LIKE_CLAUSE(x)   ((x) && ast_ends_with(x, " LIKE"))

Typedefs
typedef int(*	callback_t) (void *, int, char **, char **)

Enumerations
enum	{ REALTIME_SQLITE3_REQ_WARN , REALTIME_SQLITE3_REQ_CLOSE , REALTIME_SQLITE3_REQ_CHAR }
enum	{ COL_CATEGORY , COL_VAR_NAME , COL_VAR_VAL , COL_COLUMNS }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static int	add_column_name (void *arg, int num_columns, char **values, char **columns)
	Callback for creating a hash of column names for comparison in realtime_sqlite3_require.
static int	append_row_to_cfg (void *arg, int num_columns, char **values, char **columns)
	Callback for creating an ast_config from a successive sqlite3 result rows.
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_THREADSTORAGE_CUSTOM_SCOPE (escape_column_buf, NULL, ast_free_ptr, static)
	AST_THREADSTORAGE_CUSTOM_SCOPE (escape_table_buf, NULL, ast_free_ptr, static)
	AST_THREADSTORAGE_CUSTOM_SCOPE (escape_value_buf, NULL, ast_free_ptr, static)
static int	db_cmp_fn (void *obj, void *arg, int flags)
static void	db_destructor (void *obj)
static int	db_hash_fn (const void *obj, const int flags)
static int	db_open (struct realtime_sqlite3_db *db)
	Open a database and appropriately set debugging on the db handle.
void	db_start_batch (struct realtime_sqlite3_db *db)
void	db_stop_batch (struct realtime_sqlite3_db *db)
static void	db_sync (struct realtime_sqlite3_db *db)
static void *	db_sync_thread (void *data)
	Wrap commands in transactions increased write performance.
static void	discover_sqlite3_caps (void)
static struct realtime_sqlite3_db *	find_database (const char *database)
static const char *	get_sqlite_column_type (int type)
	Convert Asterisk realtime types to SQLite 3 types.
static int	handle_missing_column (struct realtime_sqlite3_db *db, const char *table, const char *column, int type, size_t sz)
	If ast_realtime_require sends info about a column we don't have, create it.
static int	handle_missing_table (struct realtime_sqlite3_db *db, const char *table, va_list ap)
	Create a table if ast_realtime_require shows that we are configured to handle the data.
static int	is_dirty_cb (void *obj, void *arg, int flags)
static int	load_module (void)
	Load the module.
static void	mark_all_databases_dirty (void)
static int	mark_dirty_cb (void *obj, void *arg, int flags)
static struct realtime_sqlite3_db *	new_realtime_sqlite3_db (struct ast_config *config, const char *cat)
	Create a db object based on a config category.
static int	parse_config (int reload)
	Parse the res_config_sqlite3 config file.
static struct ast_variable *	realtime_sqlite3 (const char *database, const char *table, const struct ast_variable *fields)
	Realtime callback for a single row query.
static int	realtime_sqlite3_destroy (const char *database, const char *table, const char *keyfield, const char *entity, const struct ast_variable *fields)
	Realtime callback for deleting a row.
static int	realtime_sqlite3_exec_query (const char *, const char *, callback_t, void *)
static int	realtime_sqlite3_exec_query_with_handle (struct realtime_sqlite3_db *, const char *, callback_t, void *)
static int	realtime_sqlite3_exec_update (const char *, const char *)
static int	realtime_sqlite3_exec_update_with_handle (struct realtime_sqlite3_db *, const char *)
static int	realtime_sqlite3_helper (const char *database, const char *table, const struct ast_variable *fields, int is_multi, void *arg)
	Helper function for single and multi-row realtime load functions.
static struct ast_config *	realtime_sqlite3_load (const char *database, const char *table, const char *configfile, struct ast_config *config, struct ast_flags flags, const char *suggested_include_file, const char *who_asked)
	Realtime callback for static realtime.
static struct ast_config *	realtime_sqlite3_multi (const char *database, const char *table, const struct ast_variable *fields)
	Realtime callback for a multi-row query.
static int	realtime_sqlite3_require (const char *database, const char *table, va_list ap)
	Callback for ast_realtime_require.
static int	realtime_sqlite3_store (const char *database, const char *table, const struct ast_variable *fields)
	Realtime callback for inserting a row.
static int	realtime_sqlite3_unload (const char *database, const char *table)
	Callback for clearing any cached info.
static int	realtime_sqlite3_update (const char *database, const char *table, const char *keyfield, const char *entity, const struct ast_variable *fields)
	Realtime callback for updating a row based on a single criteria.
static int	realtime_sqlite3_update2 (const char *database, const char *table, const struct ast_variable *lookup_fields, const struct ast_variable *update_fields)
	Realtime callback for updating a row based on multiple criteria.
static int	reload (void)
static int	row_counter_wrapper (void *arg, int num_columns, char **values, char **columns)
static int	row_to_varlist (void *arg, int num_columns, char **values, char **columns)
	Create a varlist from a single sqlite3 result row.
static const char *	sqlite3_escape_column (const char *param)
static const char *	sqlite3_escape_column_op (const char *param)
static const char *	sqlite3_escape_string_helper (struct ast_threadstorage *ts, const char *param)
static const char *	sqlite3_escape_table (const char *param)
static const char *	sqlite3_escape_value (const char *param)
static int	static_realtime_cb (void *arg, int num_columns, char **values, char **columns)
static int	stop_batch_cb (void *obj, void *arg, int flags)
static int	str_cmp_fn (void *obj, void *arg, int flags)
static int	str_hash_fn (const void *obj, const int flags)
static int	str_to_requirements (const char *data)
static void	trace_cb (void *arg, const char *sql)
static void	unlink_dirty_databases (void)
static int	unload_module (void)
static void	unref_db (struct realtime_sqlite3_db **db)
static int	update_realtime_sqlite3_db (struct realtime_sqlite3_db *db, struct ast_config *config, const char *cat)
	Update an existing db object based on config data.

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "SQLite 3 realtime config engine" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_REALTIME_DRIVER, .requires = "extconfig", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static ast_mutex_t	config_lock = AST_MUTEX_INIT_VALUE
struct ao2_container *	databases
static int	has_explicit_like_escaping
struct ast_config_engine	sqlite3_config_engine
static const char *	static_sql = "SELECT category, var_name, var_val FROM \"%q\" WHERE filename = %Q AND commented = 0 ORDER BY cat_metric ASC, var_metric ASC"

Detailed Description

SQLite 3 configuration engine.

Author

Terry Wilson <twilson@digium.com> 

This is a realtime configuration engine for the SQLite 3 Database

Definition in file res_config_sqlite3.c.

Macro Definition Documentation

DB_BUCKETS

#define DB_BUCKETS   7

Definition at line 108 of file res_config_sqlite3.c.

IS_SQL_LIKE_CLAUSE

#define IS_SQL_LIKE_CLAUSE

(

x

)

((x) && ast_ends_with(x, " LIKE"))

Definition at line 793 of file res_config_sqlite3.c.

Typedef Documentation

callback_t

typedef int(* callback_t) (void *, int, char **, char **)

Definition at line 117 of file res_config_sqlite3.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
REALTIME_SQLITE3_REQ_WARN
REALTIME_SQLITE3_REQ_CLOSE
REALTIME_SQLITE3_REQ_CHAR

Definition at line 83 of file res_config_sqlite3.c.

     {
    REALTIME_SQLITE3_REQ_WARN,
    REALTIME_SQLITE3_REQ_CLOSE,
    REALTIME_SQLITE3_REQ_CHAR,
};

anonymous enum

anonymous enum

Enumerator
COL_CATEGORY
COL_VAR_NAME
COL_VAR_VAL
COL_COLUMNS

Definition at line 710 of file res_config_sqlite3.c.

     {
    COL_CATEGORY,
    COL_VAR_NAME,
    COL_VAR_VAL,
    COL_COLUMNS,
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1400 of file res_config_sqlite3.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1400 of file res_config_sqlite3.c.

add_column_name()

static int add_column_name ( void *  arg, int  num_columns, char **  values, char **  columns  )

static

Callback for creating a hash of column names for comparison in realtime_sqlite3_require.

Definition at line 1149 of file res_config_sqlite3.c.

{
    char *column;
    struct ao2_container *cnames = arg;
 
 
    if (!(column = ao2_alloc(strlen(values[1]) + 1, NULL))) {
        return -1;
    }
 
    strcpy(column, values[1]);
 
    ao2_link(cnames, column);
    ao2_ref(column, -1);
 
    return 0;
}

References ao2_alloc, ao2_link, ao2_ref, and NULL.

Referenced by realtime_sqlite3_require().

append_row_to_cfg()

static int append_row_to_cfg ( void *  arg, int  num_columns, char **  values, char **  columns  )

static

Callback for creating an ast_config from a successive sqlite3 result rows.

Definition at line 510 of file res_config_sqlite3.c.

{
    struct ast_config *cfg = arg;
    struct ast_category *cat;
    int i;
 
    cat = ast_category_new_anonymous();
    if (!cat) {
        return SQLITE_ABORT;
    }
 
    for (i = 0; i < num_columns; i++) {
        struct ast_variable *var;
        if (!(var = ast_variable_new(columns[i], S_OR(values[i], ""), ""))) {
            ast_log(LOG_ERROR, "Could not create new variable for '%s: %s', throwing away list\n", columns[i], values[i]);
            continue;
        }
        ast_variable_append(cat, var);
    }
    ast_category_append(cfg, cat);
 
    return 0;
}

References ast_category_append(), ast_category_new_anonymous, ast_log, ast_variable_append(), ast_variable_new, LOG_ERROR, S_OR, and var.

Referenced by realtime_sqlite3_helper().

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 1400 of file res_config_sqlite3.c.

AST_THREADSTORAGE_CUSTOM_SCOPE() [1/3]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	escape_column_buf	,
		NULL	,
		ast_free_ptr	,
		static
	)

AST_THREADSTORAGE_CUSTOM_SCOPE() [2/3]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	escape_table_buf	,
		NULL	,
		ast_free_ptr	,
		static
	)

AST_THREADSTORAGE_CUSTOM_SCOPE() [3/3]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	escape_value_buf	,
		NULL	,
		ast_free_ptr	,
		static
	)

db_cmp_fn()

static int db_cmp_fn ( void *  obj, void *  arg, int  flags  )

static

Definition at line 221 of file res_config_sqlite3.c.

                                                      {
    struct realtime_sqlite3_db *db = obj, *other = arg;
    const char *name = arg;
 
    return !strcasecmp(db->name, flags & OBJ_KEY ? name : other->name) ? CMP_MATCH | CMP_STOP : 0;
}

References CMP_MATCH, CMP_STOP, db, name, and OBJ_KEY.

Referenced by load_module().

db_destructor()

static void db_destructor ( void *  obj )

static

Definition at line 228 of file res_config_sqlite3.c.

{
    struct realtime_sqlite3_db *db = obj;
 
    ast_debug(1, "Destroying db: %s\n", db->name);
    ast_string_field_free_memory(db);
    db_stop_batch(db);
    if (db->handle) {
        ao2_lock(db);
        sqlite3_close(db->handle);
        ao2_unlock(db);
    }
}

References ao2_lock, ao2_unlock, ast_debug, ast_string_field_free_memory, db, and db_stop_batch().

Referenced by new_realtime_sqlite3_db().

db_hash_fn()

static int db_hash_fn ( const void *  obj, const int  flags  )

static

Definition at line 214 of file res_config_sqlite3.c.

{
    const struct realtime_sqlite3_db *db = obj;
 
    return ast_str_hash(flags & OBJ_KEY ? (const char *) obj : db->name);
}

References ast_str_hash(), db, and OBJ_KEY.

Referenced by load_module().

db_open()

static int db_open ( struct realtime_sqlite3_db *  db )

static

Open a database and appropriately set debugging on the db handle.

Definition at line 336 of file res_config_sqlite3.c.

{
    ao2_lock(db);
    if (sqlite3_open(db->filename, &db->handle) != SQLITE_OK) {
        ast_log(LOG_WARNING, "Could not open %s: %s\n", db->filename, sqlite3_errmsg(db->handle));
        ao2_unlock(db);
        return -1;
    }
    sqlite3_busy_timeout(db->handle, db->busy_timeout);
 
    if (db->debug) {
        sqlite3_trace(db->handle, trace_cb, db);
    } else {
        sqlite3_trace(db->handle, NULL, NULL);
    }
 
    ao2_unlock(db);
 
    return 0;
}

References ao2_lock, ao2_unlock, ast_log, db, LOG_WARNING, NULL, and trace_cb().

db_start_batch()

void db_start_batch

(

struct realtime_sqlite3_db *

db

)

Definition at line 363 of file res_config_sqlite3.c.

{
    if (db->batch) {
        ast_cond_init(&db->cond, NULL);
        ao2_ref(db, +1);
        db->has_batch_thread = !ast_pthread_create_background(&db->syncthread, NULL, db_sync_thread, db);
    }
}

References ao2_ref, ast_cond_init, ast_pthread_create_background, db, db_sync_thread(), and NULL.

Referenced by parse_config(), and update_realtime_sqlite3_db().

db_stop_batch()

void db_stop_batch

(

struct realtime_sqlite3_db *

db

)

Definition at line 372 of file res_config_sqlite3.c.

{
    if (db->has_batch_thread) {
        db->has_batch_thread = 0;
        db->exiting = 1;
        db_sync(db);
        pthread_join(db->syncthread, NULL);
    }
}

References db, db_sync(), and NULL.

Referenced by db_destructor(), is_dirty_cb(), stop_batch_cb(), and update_realtime_sqlite3_db().

db_sync()

static void db_sync ( struct realtime_sqlite3_db *  db )

static

Definition at line 357 of file res_config_sqlite3.c.

{
    db->wakeup = 1;
    ast_cond_signal(&db->cond);
}

References ast_cond_signal, and db.

db_sync_thread()

static void * db_sync_thread ( void *  data )

static

Wrap commands in transactions increased write performance.

Definition at line 307 of file res_config_sqlite3.c.

{
    struct realtime_sqlite3_db *db = data;
    ao2_lock(db);
    realtime_sqlite3_exec_query_with_handle(db, "BEGIN TRANSACTION", NULL, NULL);
    for (;;) {
        if (!db->wakeup) {
            ast_cond_wait(&db->cond, ao2_object_get_lockaddr(db));
        }
        db->wakeup = 0;
        if (realtime_sqlite3_exec_query_with_handle(db, "COMMIT", NULL, NULL) < 0) {
            realtime_sqlite3_exec_query_with_handle(db, "ROLLBACK", NULL, NULL);
        }
        if (db->exiting) {
            ao2_unlock(db);
            break;
        }
        realtime_sqlite3_exec_query_with_handle(db, "BEGIN TRANSACTION", NULL, NULL);
        ao2_unlock(db);
        usleep(1000 * db->batch);
        ao2_lock(db);
    }
 
    unref_db(&db);
 
    return NULL;
}

References ao2_lock, ao2_object_get_lockaddr(), ao2_unlock, ast_cond_wait, db, NULL, realtime_sqlite3_exec_query_with_handle(), and unref_db().

Referenced by db_start_batch().

discover_sqlite3_caps()

static void discover_sqlite3_caps ( void  )

static

Definition at line 1336 of file res_config_sqlite3.c.

{
    /*
     * So we cheat a little bit here. SQLite3 added support for the
     * 'ESCAPE' keyword in 3.1.0. They added SQLITE_VERSION_NUMBER
     * in 3.1.2. So if we run into 3.1.0 or 3.1.1 in the wild, we
     * just treat it like < 3.1.0.
     *
     * For reference: 3.1.0, 3.1.1, and 3.1.2 were all released
     * within 30 days of each other in Jan/Feb 2005, so I don't
     * imagine we'll be finding something pre-3.1.2 that often in
     * practice.
     */
#if defined(SQLITE_VERSION_NUMBER)
    has_explicit_like_escaping = 1;
#else
    has_explicit_like_escaping = 0;
#endif
 
    ast_debug(3, "SQLite3 has 'LIKE ... ESCAPE ...' support? %s\n",
            has_explicit_like_escaping ? "Yes" : "No");
}

References ast_debug, and has_explicit_like_escaping.

Referenced by load_module().

find_database()

static struct realtime_sqlite3_db * find_database ( const char *  database )

static

Definition at line 242 of file res_config_sqlite3.c.

{
    return ao2_find(databases, database, OBJ_KEY);
}

References ao2_find, and OBJ_KEY.

Referenced by parse_config(), realtime_sqlite3_exec_query(), realtime_sqlite3_exec_update(), and realtime_sqlite3_require().

get_sqlite_column_type()

static const char * get_sqlite_column_type ( int  type )

static

Convert Asterisk realtime types to SQLite 3 types.

Note

SQLite 3 has NULL, INTEGER, REAL, TEXT, and BLOB types. Any column other than an INTEGER PRIMARY KEY will actually store any kind of data due to its dynamic typing. When we create columns, we'll go ahead and use these base types instead of messing with column widths, etc.

Definition at line 1050 of file res_config_sqlite3.c.

{
    switch(type) {
    case RQ_INTEGER1 :
    case RQ_UINTEGER1 :
    case RQ_INTEGER2 :
    case RQ_UINTEGER2 :
    case RQ_INTEGER3 :
    case RQ_UINTEGER3 :
    case RQ_INTEGER4 :
    case RQ_UINTEGER4 :
    case RQ_INTEGER8 :
        return "INTEGER";
    case RQ_UINTEGER8 : /* SQLite3 stores INTEGER as signed 8-byte */
    case RQ_CHAR :
    case RQ_DATE :
    case RQ_DATETIME :
        return "TEXT";
    case RQ_FLOAT :
        return "REAL";
    default :
        return "TEXT";
    }
 
    return "TEXT";
}

References RQ_CHAR, RQ_DATE, RQ_DATETIME, RQ_FLOAT, RQ_INTEGER1, RQ_INTEGER2, RQ_INTEGER3, RQ_INTEGER4, RQ_INTEGER8, RQ_UINTEGER1, RQ_UINTEGER2, RQ_UINTEGER3, RQ_UINTEGER4, RQ_UINTEGER8, and type.

Referenced by handle_missing_column(), and handle_missing_table().

handle_missing_column()

static int handle_missing_column ( struct realtime_sqlite3_db *  db, const char *  table, const char *  column, int  type, size_t  sz  )

static

If ast_realtime_require sends info about a column we don't have, create it.

Definition at line 1112 of file res_config_sqlite3.c.

{
    char *sql;
    const char *sqltype = get_sqlite_column_type(type);
    int res;
 
    if (db->requirements == REALTIME_SQLITE3_REQ_WARN) {
        ast_log(LOG_WARNING, "Missing column '%s' of type '%s' in %s.%s\n", column, sqltype, db->name, table);
        return -1;
    } else if (db->requirements == REALTIME_SQLITE3_REQ_CHAR) {
        sqltype = "TEXT";
    }
 
    if (!(sql = sqlite3_mprintf("ALTER TABLE \"%q\" ADD COLUMN \"%q\" %s", table, column, sqltype))) {
        return -1;
    }
 
    if (!(res = (realtime_sqlite3_exec_update_with_handle(db, sql) < 0 ? -1 : 0))) {
        ast_log(LOG_NOTICE, "Creating column '%s' type %s for table %s\n", column, sqltype, table);
    }
 
    sqlite3_free(sql);
 
    return res;
}

References ast_log, db, get_sqlite_column_type(), LOG_NOTICE, LOG_WARNING, realtime_sqlite3_exec_update_with_handle(), REALTIME_SQLITE3_REQ_CHAR, REALTIME_SQLITE3_REQ_WARN, and type.

Referenced by realtime_sqlite3_require().

handle_missing_table()

static int handle_missing_table ( struct realtime_sqlite3_db *  db, const char *  table, va_list  ap  )

static

Create a table if ast_realtime_require shows that we are configured to handle the data.

Definition at line 1079 of file res_config_sqlite3.c.

{
    const char *column;
    int type, first = 1, res;
    size_t sz;
    struct ast_str *sql;
 
    if (!(sql = ast_str_create(128))) {
        return -1;
    }
 
    while ((column = va_arg(ap, typeof(column)))) {
        type = va_arg(ap, typeof(type));
        sz = va_arg(ap, typeof(sz));
        if (first) {
            ast_str_set(&sql, 0, "CREATE TABLE IF NOT EXISTS %s (%s %s", sqlite3_escape_table(table),
                    sqlite3_escape_column(column), get_sqlite_column_type(type));
            first = 0;
        } else {
            ast_str_append(&sql, 0, ", %s %s", sqlite3_escape_column(column), get_sqlite_column_type(type));
        }
    }
 
    ast_str_append(&sql, 0, ")");
 
    res = realtime_sqlite3_exec_update_with_handle(db, ast_str_buffer(sql)) < 0 ? -1 : 0;
    ast_free(sql);
 
    return res;
}

References ast_free, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_set(), db, first, get_sqlite_column_type(), realtime_sqlite3_exec_update_with_handle(), sqlite3_escape_column(), sqlite3_escape_table(), type, and typeof().

Referenced by realtime_sqlite3_require().

is_dirty_cb()

static int is_dirty_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 273 of file res_config_sqlite3.c.

{
    struct realtime_sqlite3_db *db = obj;
    if (db->dirty) {
        db_stop_batch(db);
        return CMP_MATCH;
    }
    return 0;
}

References CMP_MATCH, db, and db_stop_batch().

Referenced by unlink_dirty_databases().

load_module()

static int load_module ( void  )

static

Load the module.

Module loading including tests for configuration or dependencies. This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE, or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails tests return AST_MODULE_LOAD_FAILURE. If the module can not load the configuration file or other non-critical problem return AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.

Definition at line 1369 of file res_config_sqlite3.c.

{
    discover_sqlite3_caps();
 
    databases = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, DB_BUCKETS,
        db_hash_fn, NULL, db_cmp_fn);
    if (!databases) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (parse_config(0)) {
        ao2_ref(databases, -1);
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (!(ast_config_engine_register(&sqlite3_config_engine))) {
        ast_log(LOG_ERROR, "The config API must have changed, this shouldn't happen.\n");
        ao2_ref(databases, -1);
        return AST_MODULE_LOAD_DECLINE;
    }
 
    return AST_MODULE_LOAD_SUCCESS;
}

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_ref, ast_config_engine_register(), ast_log, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, DB_BUCKETS, db_cmp_fn(), db_hash_fn(), discover_sqlite3_caps(), LOG_ERROR, NULL, parse_config(), and sqlite3_config_engine.

mark_all_databases_dirty()

static void mark_all_databases_dirty ( void  )

static

Definition at line 268 of file res_config_sqlite3.c.

{
    ao2_callback(databases, OBJ_MULTIPLE | OBJ_NODATA, mark_dirty_cb, NULL);
}

References ao2_callback, mark_dirty_cb(), NULL, OBJ_MULTIPLE, and OBJ_NODATA.

Referenced by parse_config().

mark_dirty_cb()

static int mark_dirty_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 261 of file res_config_sqlite3.c.

{
    struct realtime_sqlite3_db *db = obj;
    db->dirty = 1;
    return CMP_MATCH;
}

References CMP_MATCH, db, and realtime_sqlite3_db::dirty.

Referenced by mark_all_databases_dirty().

new_realtime_sqlite3_db()

static struct realtime_sqlite3_db * new_realtime_sqlite3_db ( struct ast_config *  config, const char *  cat  )

static

Create a db object based on a config category.

Note

Opening the db handle and linking to databases must be handled outside of this function

Definition at line 385 of file res_config_sqlite3.c.

{
    struct ast_variable *var;
    struct realtime_sqlite3_db *db;
 
    if (!(db = ao2_alloc(sizeof(*db), db_destructor))) {
        return NULL;
    }
 
    if (ast_string_field_init(db, 64)) {
        unref_db(&db);
        return NULL;
    }
 
    /* Set defaults */
    db->requirements = REALTIME_SQLITE3_REQ_WARN;
    db->batch = 100;
    ast_string_field_set(db, name, cat);
    db->busy_timeout = 1000;
 
    for (var = ast_variable_browse(config, cat); var; var = var->next) {
        if (!strcasecmp(var->name, "dbfile")) {
            ast_string_field_set(db, filename, var->value);
        } else if (!strcasecmp(var->name, "requirements")) {
            db->requirements = str_to_requirements(var->value);
        } else if (!strcasecmp(var->name, "batch")) {
            ast_app_parse_timelen(var->value, (int *) &db->batch, TIMELEN_MILLISECONDS);
        } else if (!strcasecmp(var->name, "debug")) {
            db->debug = ast_true(var->value);
        } else if (!strcasecmp(var->name, "busy_timeout")) {
            if (ast_parse_arg(var->value, PARSE_INT32|PARSE_DEFAULT, &(db->busy_timeout), 1000) != 0) {
                ast_log(LOG_WARNING, "Invalid busy_timeout value '%s' at res_config_sqlite3.conf:%d. Using 1000 instead.\n", var->value, var->lineno);
            }
        }
    }
 
    if (ast_strlen_zero(db->filename)) {
        ast_log(LOG_WARNING, "Must specify dbfile in res_config_sqlite3.conf\n");
        unref_db(&db);
        return NULL;
    }
 
    return db;
}

References ao2_alloc, ast_app_parse_timelen(), ast_log, ast_parse_arg(), ast_string_field_init, ast_string_field_set, ast_strlen_zero(), ast_true(), ast_variable_browse(), config, db, db_destructor(), realtime_sqlite3_db::filename, LOG_WARNING, name, ast_variable::next, NULL, PARSE_DEFAULT, PARSE_INT32, REALTIME_SQLITE3_REQ_WARN, str_to_requirements(), TIMELEN_MILLISECONDS, unref_db(), and var.

Referenced by parse_config(), and update_realtime_sqlite3_db().

parse_config()

static int parse_config ( int  reload )

static

Parse the res_config_sqlite3 config file.

Definition at line 1259 of file res_config_sqlite3.c.

{
    struct ast_config *config;
    struct ast_flags config_flags = { CONFIG_FLAG_NOREALTIME | (reload ? CONFIG_FLAG_FILEUNCHANGED : 0) };
    static const char *config_filename = "res_config_sqlite3.conf";
 
    config = ast_config_load(config_filename, config_flags);
 
    if (config == CONFIG_STATUS_FILEUNCHANGED) {
        ast_debug(1, "%s was unchanged, skipping parsing\n", config_filename);
        return 0;
    }
 
    ast_mutex_lock(&config_lock);
 
    if (config == CONFIG_STATUS_FILEMISSING || config == CONFIG_STATUS_FILEINVALID) {
        ast_log(LOG_ERROR, "%s config file '%s'\n",
            config == CONFIG_STATUS_FILEMISSING ? "Missing" : "Invalid", config_filename);
        ast_mutex_unlock(&config_lock);
        return 0;
    } else {
        const char *cat;
        struct realtime_sqlite3_db *db;
 
        mark_all_databases_dirty();
        for (cat = ast_category_browse(config, NULL); cat; cat = ast_category_browse(config, cat)) {
            if (!strcasecmp(cat, "general")) {
                continue;
            }
            if (!(db = find_database(cat))) {
                if (!(db = new_realtime_sqlite3_db(config, cat))) {
                    ast_log(LOG_WARNING, "Could not allocate new db for '%s' - skipping.\n", cat);
                    continue;
                }
                if (db_open(db)) {
                    unref_db(&db);
                    continue;
                }
                db_start_batch(db);
                ao2_link(databases, db);
                unref_db(&db);
            } else  {
                if (update_realtime_sqlite3_db(db, config, cat)) {
                    unref_db(&db);
                    continue;
                }
                unref_db(&db);
            }
        }
        unlink_dirty_databases();
    }
 
    ast_mutex_unlock(&config_lock);
 
    ast_config_destroy(config);
 
    return 0;
}

References ao2_link, ast_category_browse(), ast_config_destroy(), ast_config_load, ast_debug, ast_log, ast_mutex_lock, ast_mutex_unlock, config, config_filename, CONFIG_FLAG_FILEUNCHANGED, CONFIG_FLAG_NOREALTIME, config_lock, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEMISSING, CONFIG_STATUS_FILEUNCHANGED, db, db_open(), db_start_batch(), find_database(), LOG_ERROR, LOG_WARNING, mark_all_databases_dirty(), new_realtime_sqlite3_db(), NULL, reload(), unlink_dirty_databases(), unref_db(), and update_realtime_sqlite3_db().

realtime_sqlite3()

static struct ast_variable * realtime_sqlite3 ( const char *  database, const char *  table, const struct ast_variable *  fields  )

static

Realtime callback for a single row query.

Returns

ast_variable list for single result on success, NULL on empty/failure

Definition at line 848 of file res_config_sqlite3.c.

{
    struct ast_variable *result_row = NULL;
 
    realtime_sqlite3_helper(database, table, fields, 0, &result_row);
 
    return result_row;
}

References NULL, and realtime_sqlite3_helper().

realtime_sqlite3_destroy()

static int realtime_sqlite3_destroy ( const char *  database, const char *  table, const char *  keyfield, const char *  entity, const struct ast_variable *  fields  )

static

Realtime callback for deleting a row.

Returns

Number of rows affected or -1 on error

Definition at line 1012 of file res_config_sqlite3.c.

{
    struct ast_str *sql;
    const struct ast_variable *field;
    int first = 1, res;
 
    if (ast_strlen_zero(table)) {
        ast_log(LOG_WARNING, "Must have a table to query!\n");
        return -1;
    }
 
    if (!(sql = ast_str_create(128))) {
        return -1;
    }
 
    for (field = fields; field; field = field->next) {
        if (first) {
            ast_str_set(&sql, 0, "DELETE FROM %s WHERE %s %s", sqlite3_escape_table(table),
                    sqlite3_escape_column_op(field->name), sqlite3_escape_value(field->value));
            first = 0;
        } else {
            ast_str_append(&sql, 0, " AND %s %s", sqlite3_escape_column_op(field->name), sqlite3_escape_value(field->value));
        }
    }
 
    res = realtime_sqlite3_exec_update(database, ast_str_buffer(sql));
 
    ast_free(sql);
 
    return res;
}

References ast_free, ast_log, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_strlen_zero(), first, LOG_WARNING, ast_variable::name, ast_variable::next, realtime_sqlite3_exec_update(), sqlite3_escape_column_op(), sqlite3_escape_table(), sqlite3_escape_value(), and ast_variable::value.

realtime_sqlite3_exec_query()

static int realtime_sqlite3_exec_query ( const char *  database, const char *  sql, callback_t  callback, void *  arg  )

static

Definition at line 630 of file res_config_sqlite3.c.

{
    struct realtime_sqlite3_db *db;
    int res;
 
    if (!(db = find_database(database))) {
        ast_log(LOG_WARNING, "Could not find database: %s\n", database);
        return -1;
    }
 
    res = realtime_sqlite3_exec_query_with_handle(db, sql, callback, arg);
    ao2_ref(db, -1);
 
    return res;
}

References ao2_ref, ast_log, callback(), db, find_database(), LOG_WARNING, and realtime_sqlite3_exec_query_with_handle().

Referenced by realtime_sqlite3_helper(), and realtime_sqlite3_load().

realtime_sqlite3_exec_query_with_handle()

static int realtime_sqlite3_exec_query_with_handle ( struct realtime_sqlite3_db *  db, const char *  sql, callback_t  callback, void *  arg  )

static

Definition at line 596 of file res_config_sqlite3.c.

{
    int res = 0;
    char *errmsg;
    struct row_counter_args wrapper = {
        .wrapped_callback = callback,
        .wrapped_arg = arg,
        .row_count = 0,
    };
 
    ao2_lock(db);
    if (sqlite3_exec(db->handle, sql, row_counter_wrapper, &wrapper, &errmsg) != SQLITE_OK) {
        ast_log(LOG_WARNING, "Could not execute '%s': %s\n", sql, errmsg);
        sqlite3_free(errmsg);
        res = -1;
    }
    ao2_unlock(db);
 
    return res == 0 ? wrapper.row_count : res;
}

References ao2_lock, ao2_unlock, ast_log, callback(), db, LOG_WARNING, row_counter_args::row_count, row_counter_wrapper(), and row_counter_args::wrapped_callback.

Referenced by db_sync_thread(), realtime_sqlite3_exec_query(), and realtime_sqlite3_require().

realtime_sqlite3_exec_update()

static int realtime_sqlite3_exec_update ( const char *  database, const char *  sql  )

static

Definition at line 692 of file res_config_sqlite3.c.

{
    struct realtime_sqlite3_db *db;
    int res;
 
    if (!(db = find_database(database))) {
        ast_log(LOG_WARNING, "Could not find database: %s\n", database);
        return -1;
    }
 
    res = realtime_sqlite3_exec_update_with_handle(db, sql);
    ao2_ref(db, -1);
 
    return res;
}

References ao2_ref, ast_log, db, find_database(), LOG_WARNING, and realtime_sqlite3_exec_update_with_handle().

Referenced by realtime_sqlite3_destroy(), realtime_sqlite3_store(), realtime_sqlite3_update(), and realtime_sqlite3_update2().

realtime_sqlite3_exec_update_with_handle()

static int realtime_sqlite3_exec_update_with_handle ( struct realtime_sqlite3_db *  db, const char *  sql  )

static

Definition at line 659 of file res_config_sqlite3.c.

{
    int res = 0;
    char *errmsg;
 
    ao2_lock(db);
    if (sqlite3_exec(db->handle, sql, NULL, NULL, &errmsg) != SQLITE_OK) {
        ast_log(LOG_WARNING, "Could not execute '%s': %s\n", sql, errmsg);
        sqlite3_free(errmsg);
        res = -1;
    } else {
        res = sqlite3_changes(db->handle);
    }
    ao2_unlock(db);
 
    db_sync(db);
 
    return res;
}

References ao2_lock, ao2_unlock, ast_log, db, db_sync(), LOG_WARNING, and NULL.

Referenced by handle_missing_column(), handle_missing_table(), and realtime_sqlite3_exec_update().

realtime_sqlite3_helper()

static int realtime_sqlite3_helper ( const char *  database, const char *  table, const struct ast_variable *  fields, int  is_multi, void *  arg  )

static

Helper function for single and multi-row realtime load functions.

Definition at line 796 of file res_config_sqlite3.c.

{
    struct ast_str *sql;
    const struct ast_variable *field;
    int first = 1;
 
    if (ast_strlen_zero(table)) {
        ast_log(LOG_WARNING, "Must have a table to query!\n");
        return -1;
    }
 
    if (!(sql = ast_str_create(128))) {
        return -1;
    }
 
    for (field = fields; field; field = field->next) {
        if (first) {
            ast_str_set(&sql, 0, "SELECT * FROM %s WHERE %s %s", sqlite3_escape_table(table),
                    sqlite3_escape_column_op(field->name), sqlite3_escape_value(field->value));
            first = 0;
        } else {
            ast_str_append(&sql, 0, " AND %s %s", sqlite3_escape_column_op(field->name),
                    sqlite3_escape_value(field->value));
        }
 
        if (has_explicit_like_escaping && IS_SQL_LIKE_CLAUSE(field->name)) {
            /*
             * The realtime framework is going to pre-escape these
             * for us with a backslash. We just need to make sure
             * to tell SQLite about it
             */
            ast_str_append(&sql, 0, " ESCAPE '\\'");
        }
    }
 
    if (!is_multi) {
        ast_str_append(&sql, 0, "%s", " LIMIT 1");
    }
 
    if (realtime_sqlite3_exec_query(database, ast_str_buffer(sql), is_multi ? append_row_to_cfg : row_to_varlist, arg) < 0) {
        ast_free(sql);
        return -1;
    }
 
    ast_free(sql);
 
    return 0;
}

References append_row_to_cfg(), ast_free, ast_log, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_strlen_zero(), first, has_explicit_like_escaping, IS_SQL_LIKE_CLAUSE, LOG_WARNING, ast_variable::name, ast_variable::next, realtime_sqlite3_exec_query(), row_to_varlist(), sqlite3_escape_column_op(), sqlite3_escape_table(), sqlite3_escape_value(), and ast_variable::value.

Referenced by realtime_sqlite3(), and realtime_sqlite3_multi().

realtime_sqlite3_load()

static struct ast_config * realtime_sqlite3_load ( const char *  database, const char *  table, const char *  configfile, struct ast_config *  config, struct ast_flags  flags, const char *  suggested_include_file, const char *  who_asked  )

static

Realtime callback for static realtime.

Returns

ast_config on success, NULL on failure

Definition at line 765 of file res_config_sqlite3.c.

{
    char *sql;
    struct cfg_entry_args args;
 
    if (ast_strlen_zero(table)) {
        ast_log(LOG_WARNING, "Must have a table to query!\n");
        return NULL;
    }
 
    if (!(sql = sqlite3_mprintf(static_sql, table, configfile))) {
        ast_log(LOG_WARNING, "Couldn't allocate query\n");
        return NULL;
    };
 
    args.cfg = config;
    args.cat = NULL;
    args.cat_name = NULL;
    args.flags = flags;
    args.who_asked = who_asked;
 
    realtime_sqlite3_exec_query(database, sql, static_realtime_cb, &args);
 
    sqlite3_free(sql);
 
    return config;
}

References args, ast_log, ast_strlen_zero(), config, cfg_entry_args::flags, LOG_WARNING, NULL, realtime_sqlite3_exec_query(), static_realtime_cb(), static_sql, and cfg_entry_args::who_asked.

realtime_sqlite3_multi()

static struct ast_config * realtime_sqlite3_multi ( const char *  database, const char *  table, const struct ast_variable *  fields  )

static

Realtime callback for a multi-row query.

Returns

ast_config containing possibly many results on success, NULL on empty/failure

Definition at line 860 of file res_config_sqlite3.c.

{
    struct ast_config *cfg;
 
    if (!(cfg = ast_config_new())) {
        return NULL;
    }
 
    if (realtime_sqlite3_helper(database, table, fields, 1, cfg)) {
        ast_config_destroy(cfg);
        return NULL;
    }
 
    return cfg;
}

References ast_config_destroy(), ast_config_new(), NULL, and realtime_sqlite3_helper().

realtime_sqlite3_require()

static int realtime_sqlite3_require ( const char *  database, const char *  table, va_list  ap  )

static

Callback for ast_realtime_require.

Return values

0	Required fields met specified standards
-1	One or more fields was missing or insufficient

Definition at line 1171 of file res_config_sqlite3.c.

{
    const char *column;
    char *sql;
    int type;
    int res;
    size_t sz;
    struct ao2_container *columns;
    struct realtime_sqlite3_db *db;
 
    /* SQLite3 columns are dynamically typed, with type affinity. Built-in functions will
     * return the results as char * anyway. The only field that cannot contain text
     * data is an INTEGER PRIMARY KEY, which must be a 64-bit signed integer. So, for
     * the purposes here we really only care whether the column exists and not what its
     * type or length is. */
 
    if (ast_strlen_zero(table)) {
        ast_log(LOG_WARNING, "Must have a table to query!\n");
        return -1;
    }
 
    if (!(db = find_database(database))) {
        return -1;
    }
 
    columns = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 31,
        str_hash_fn, NULL, str_cmp_fn);
    if (!columns) {
        unref_db(&db);
       return -1;
    }
 
    if (!(sql = sqlite3_mprintf("PRAGMA table_info(\"%q\")", table))) {
        unref_db(&db);
        ao2_ref(columns, -1);
        return -1;
    }
 
    if ((res = realtime_sqlite3_exec_query_with_handle(db, sql, add_column_name, columns)) < 0) {
        unref_db(&db);
        ao2_ref(columns, -1);
        sqlite3_free(sql);
        return -1;
    } else if (res == 0) {
        /* Table does not exist */
        sqlite3_free(sql);
        res = handle_missing_table(db, table, ap);
        ao2_ref(columns, -1);
        unref_db(&db);
        return res;
    }
 
    sqlite3_free(sql);
 
    while ((column = va_arg(ap, typeof(column)))) {
        char *found;
        type = va_arg(ap, typeof(type));
        sz = va_arg(ap, typeof(sz));
        if (!(found = ao2_find(columns, column, OBJ_POINTER | OBJ_UNLINK))) {
            if (handle_missing_column(db, table, column, type, sz)) {
                unref_db(&db);
                ao2_ref(columns, -1);
                return -1;
            }
        } else {
            ao2_ref(found, -1);
        }
    }
 
    ao2_ref(columns, -1);
    unref_db(&db);
 
    return 0;
}

References add_column_name(), AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_find, ao2_ref, ast_log, ast_strlen_zero(), db, find_database(), handle_missing_column(), handle_missing_table(), LOG_WARNING, NULL, OBJ_POINTER, OBJ_UNLINK, realtime_sqlite3_exec_query_with_handle(), str_cmp_fn(), str_hash_fn(), type, typeof(), and unref_db().

realtime_sqlite3_store()

static int realtime_sqlite3_store ( const char *  database, const char *  table, const struct ast_variable *  fields  )

static

Realtime callback for inserting a row.

Returns

Number of rows affected or -1 on error

Definition at line 968 of file res_config_sqlite3.c.

{
    struct ast_str *sql, *values;
    const struct ast_variable *field;
    int first = 1, res;
 
    if (ast_strlen_zero(table)) {
        ast_log(LOG_WARNING, "Must have a table to query!\n");
        return -1;
    }
 
    if (!(sql = ast_str_create(128))) {
        return -1;
    }
 
    if (!(values = ast_str_create(128))) {
        ast_free(sql);
        return -1;
    }
 
    for (field = fields; field; field = field->next) {
        if (first) {
            ast_str_set(&sql, 0, "INSERT INTO %s (%s", sqlite3_escape_table(table), sqlite3_escape_column(field->name));
            ast_str_set(&values, 0, ") VALUES (%s", sqlite3_escape_value(field->value));
            first = 0;
        } else {
            ast_str_append(&sql, 0, ", %s", sqlite3_escape_column(field->name));
            ast_str_append(&values, 0, ", %s", sqlite3_escape_value(field->value));
        }
    }
 
    ast_str_append(&sql, 0, "%s)", ast_str_buffer(values));
 
    res = realtime_sqlite3_exec_update(database, ast_str_buffer(sql));
 
    ast_free(sql);
    ast_free(values);
 
    return res;
}

References ast_free, ast_log, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_strlen_zero(), first, LOG_WARNING, ast_variable::name, ast_variable::next, realtime_sqlite3_exec_update(), sqlite3_escape_column(), sqlite3_escape_table(), sqlite3_escape_value(), and ast_variable::value.

realtime_sqlite3_unload()

static int realtime_sqlite3_unload ( const char *  database, const char *  table  )

static

Callback for clearing any cached info.

Note

We don't currently cache anything

Return values

0	If any cache was purged
-1	If no cache was found

Definition at line 1251 of file res_config_sqlite3.c.

{
    /* We currently do no caching */
    return -1;
}

realtime_sqlite3_update()

static int realtime_sqlite3_update ( const char *  database, const char *  table, const char *  keyfield, const char *  entity, const struct ast_variable *  fields  )

static

Realtime callback for updating a row based on a single criteria.

Returns

Number of rows affected or -1 on error

Definition at line 879 of file res_config_sqlite3.c.

{
    struct ast_str *sql;
    const struct ast_variable *field;
    int first = 1, res;
 
    if (ast_strlen_zero(table)) {
        ast_log(LOG_WARNING, "Must have a table to query!\n");
        return -1;
    }
 
    if (!(sql = ast_str_create(128))) {
        return -1;
    }
 
    for (field = fields; field; field = field->next) {
        if (first) {
            ast_str_set(&sql, 0, "UPDATE %s SET %s = %s",
                    sqlite3_escape_table(table), sqlite3_escape_column(field->name), sqlite3_escape_value(field->value));
            first = 0;
        } else {
            ast_str_append(&sql, 0, ", %s = %s", sqlite3_escape_column(field->name), sqlite3_escape_value(field->value));
        }
    }
 
    ast_str_append(&sql, 0, " WHERE %s %s", sqlite3_escape_column_op(keyfield), sqlite3_escape_value(entity));
 
    res = realtime_sqlite3_exec_update(database, ast_str_buffer(sql));
    ast_free(sql);
 
    return res;
}

References ast_free, ast_log, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_strlen_zero(), first, LOG_WARNING, ast_variable::name, ast_variable::next, realtime_sqlite3_exec_update(), sqlite3_escape_column(), sqlite3_escape_column_op(), sqlite3_escape_table(), sqlite3_escape_value(), and ast_variable::value.

realtime_sqlite3_update2()

static int realtime_sqlite3_update2 ( const char *  database, const char *  table, const struct ast_variable *  lookup_fields, const struct ast_variable *  update_fields  )

static

Realtime callback for updating a row based on multiple criteria.

Returns

Number of rows affected or -1 on error

Definition at line 915 of file res_config_sqlite3.c.

{
    struct ast_str *sql;
    struct ast_str *where_clause;
    const struct ast_variable *field;
    int first = 1, res;
 
    if (ast_strlen_zero(table)) {
        ast_log(LOG_WARNING, "Must have a table to query!\n");
        return -1;
    }
 
    if (!(sql = ast_str_create(128))) {
        return -1;
    }
 
    if (!(where_clause = ast_str_create(128))) {
        ast_free(sql);
        return -1;
    }
 
    for (field = lookup_fields; field; field = field->next) {
        if (first) {
            ast_str_set(&where_clause, 0, " WHERE %s %s", sqlite3_escape_column_op(field->name), sqlite3_escape_value(field->value));
            first = 0;
        } else {
            ast_str_append(&where_clause, 0, " AND %s %s", sqlite3_escape_column_op(field->name), sqlite3_escape_value(field->value));
        }
    }
 
    first = 1;
    for (field = update_fields; field; field = field->next) {
        if (first) {
            ast_str_set(&sql, 0, "UPDATE %s SET %s = %s", sqlite3_escape_table(table), sqlite3_escape_column(field->name), sqlite3_escape_value(field->value));
            first = 0;
        } else {
            ast_str_append(&sql, 0, ", %s = %s", sqlite3_escape_column(field->name), sqlite3_escape_value(field->value));
        }
    }
 
    ast_str_append(&sql, 0, "%s", ast_str_buffer(where_clause));
 
    res = realtime_sqlite3_exec_update(database, ast_str_buffer(sql));
 
    ast_free(sql);
    ast_free(where_clause);
 
    return res;
}

References ast_free, ast_log, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_strlen_zero(), first, LOG_WARNING, ast_variable::name, ast_variable::next, realtime_sqlite3_exec_update(), sqlite3_escape_column(), sqlite3_escape_column_op(), sqlite3_escape_table(), sqlite3_escape_value(), and ast_variable::value.

reload()

static int reload ( void  )

static

Definition at line 1318 of file res_config_sqlite3.c.

{
    parse_config(1);
    return 0;
}

References parse_config().

Referenced by parse_config().

row_counter_wrapper()

static int row_counter_wrapper ( void *  arg, int  num_columns, char **  values, char **  columns  )

static

Definition at line 573 of file res_config_sqlite3.c.

{
    struct row_counter_args *wrapped = arg;
    wrapped->row_count++;
    if (wrapped->wrapped_callback) {
        return wrapped->wrapped_callback(wrapped->wrapped_arg, num_columns, values, columns);
    }
    return 0;
}

References row_counter_args::row_count, row_counter_args::wrapped_arg, and row_counter_args::wrapped_callback.

Referenced by realtime_sqlite3_exec_query_with_handle().

row_to_varlist()

static int row_to_varlist ( void *  arg, int  num_columns, char **  values, char **  columns  )

static

Create a varlist from a single sqlite3 result row.

Definition at line 485 of file res_config_sqlite3.c.

{
    struct ast_variable **head = arg, *tail;
    int i;
    struct ast_variable *new;
 
    if (!(new = ast_variable_new(columns[0], S_OR(values[0], ""), ""))) {
        return SQLITE_ABORT;
    }
    *head = tail = new;
 
    for (i = 1; i < num_columns; i++) {
        if (!(new = ast_variable_new(columns[i], S_OR(values[i], ""), ""))) {
            ast_variables_destroy(*head);
            *head = NULL;
            return SQLITE_ABORT;
        }
        tail->next = new;
        tail = new;
    }
 
    return 0;
}

References ast_variable_new, ast_variables_destroy(), ast_variable::next, NULL, and S_OR.

Referenced by realtime_sqlite3_helper().

sqlite3_escape_column()

static const char * sqlite3_escape_column ( const char *  param )

inlinestatic

Definition at line 164 of file res_config_sqlite3.c.

{
    return sqlite3_escape_string_helper(&escape_column_buf, param);
}

References sqlite3_escape_string_helper().

Referenced by handle_missing_table(), realtime_sqlite3_store(), realtime_sqlite3_update(), and realtime_sqlite3_update2().

sqlite3_escape_column_op()

static const char * sqlite3_escape_column_op ( const char *  param )

static

Definition at line 170 of file res_config_sqlite3.c.

{
    size_t maxlen = strlen(param) * 2 + sizeof("\"\" =");
    struct ast_str *buf = ast_str_thread_get(&escape_column_buf, maxlen);
    char *tmp;
    int space = 0;
 
    if (ast_str_size(buf) < maxlen) {
        /* realloc if buf is too small */
        ast_str_make_space(&buf, maxlen);
    }
    tmp = ast_str_buffer(buf);
 
    ast_str_reset(buf);
    *tmp++ = '"';
    while ((*tmp++ = *param++)) {
        /* If we have seen a space, don't double quotes. XXX If we ever make the column/op field
         * available to users via an API, we will definitely need to avoid allowing special
         * characters like ';' in the data past the space as it will be unquoted data */
        if (space) {
            continue;
        }
        if (*(tmp - 1) == ' ') {
            *(tmp - 1) = '"';
            *tmp++ = ' ';
            space = 1;
        } else if (*(tmp - 1) == '"') {
            *tmp++ = '"';
        }
    }
    if (!space) {
        strcpy(tmp - 1, "\" =");
    }
 
    ast_str_update(buf);
 
    return ast_str_buffer(buf);
}

References ast_str_buffer(), ast_str_make_space, ast_str_reset(), ast_str_size(), ast_str_thread_get(), ast_str_update(), and buf.

Referenced by realtime_sqlite3_destroy(), realtime_sqlite3_helper(), realtime_sqlite3_update(), and realtime_sqlite3_update2().

sqlite3_escape_string_helper()

static const char * sqlite3_escape_string_helper ( struct ast_threadstorage *  ts, const char *  param  )

inlinestatic

Definition at line 127 of file res_config_sqlite3.c.

{
    size_t maxlen = strlen(param) * 2 + sizeof("\"\"");
    /* It doesn't appear that sqlite3_snprintf will do more than double the
     * length of a string with %q as an option. %Q could double and possibly
     * add two quotes, and convert NULL pointers to the word "NULL", but we
     * don't allow those anyway. Just going to use %q for now. */
    struct ast_str *buf = ast_str_thread_get(ts, maxlen);
    char q = ts == &escape_value_buf ? '\'' : '"';
    char *tmp;
 
    if (ast_str_size(buf) < maxlen) {
        /* realloc if buf is too small */
        ast_str_make_space(&buf, maxlen);
    }
    tmp = ast_str_buffer(buf);
 
    ast_str_reset(buf);
    *tmp++ = q; /* Initial quote */
    while ((*tmp++ = *param++)) {
        /* Did we just copy a quote? Then double it. */
        if (*(tmp - 1) == q) {
            *tmp++ = q;
        }
    }
    *tmp = '\0'; /* Terminate past NULL from copy */
    *(tmp - 1) = q; /* Replace original NULL with the quote */
    ast_str_update(buf);
 
    return ast_str_buffer(buf);
}

References ast_str_buffer(), ast_str_make_space, ast_str_reset(), ast_str_size(), ast_str_thread_get(), ast_str_update(), and buf.

Referenced by sqlite3_escape_column(), sqlite3_escape_table(), and sqlite3_escape_value().

sqlite3_escape_table()

static const char * sqlite3_escape_table ( const char *  param )

inlinestatic

Definition at line 159 of file res_config_sqlite3.c.

{
    return sqlite3_escape_string_helper(&escape_table_buf, param);
}

References sqlite3_escape_string_helper().

Referenced by handle_missing_table(), realtime_sqlite3_destroy(), realtime_sqlite3_helper(), realtime_sqlite3_store(), realtime_sqlite3_update(), and realtime_sqlite3_update2().

sqlite3_escape_value()

static const char * sqlite3_escape_value ( const char *  param )

inlinestatic

Definition at line 209 of file res_config_sqlite3.c.

{
    return sqlite3_escape_string_helper(&escape_value_buf, param);
}

References sqlite3_escape_string_helper().

Referenced by realtime_sqlite3_destroy(), realtime_sqlite3_helper(), realtime_sqlite3_store(), realtime_sqlite3_update(), and realtime_sqlite3_update2().

static_realtime_cb()

static int static_realtime_cb ( void *  arg, int  num_columns, char **  values, char **  columns  )

static

Definition at line 717 of file res_config_sqlite3.c.

{
    struct cfg_entry_args *args = arg;
    struct ast_variable *var;
 
    if (!strcmp(values[COL_VAR_NAME], "#include")) {
        struct ast_config *cfg;
        char *val;
 
        val = values[COL_VAR_VAL];
        if (!(cfg = ast_config_internal_load(val, args->cfg, args->flags, "", args->who_asked))) {
            ast_log(LOG_WARNING, "Unable to include %s\n", val);
            return SQLITE_ABORT;
        } else {
            args->cfg = cfg;
            return 0;
        }
    }
 
    if (!args->cat_name || strcmp(args->cat_name, values[COL_CATEGORY])) {
        args->cat = ast_category_new_dynamic(values[COL_CATEGORY]);
        if (!args->cat) {
            return SQLITE_ABORT;
        }
 
        ast_free(args->cat_name);
 
        if (!(args->cat_name = ast_strdup(values[COL_CATEGORY]))) {
            ast_category_destroy(args->cat);
            return SQLITE_ABORT;
        }
 
        ast_category_append(args->cfg, args->cat);
    }
 
    if (!(var = ast_variable_new(values[COL_VAR_NAME], values[COL_VAR_VAL], ""))) {
        ast_log(LOG_WARNING, "Unable to allocate variable\n");
        return SQLITE_ABORT;
    }
 
    ast_variable_append(args->cat, var);
 
    return 0;
}

References args, ast_category_append(), ast_category_destroy(), ast_category_new_dynamic, ast_config_internal_load(), ast_free, ast_log, ast_strdup, ast_variable_append(), ast_variable_new, COL_CATEGORY, COL_VAR_NAME, COL_VAR_VAL, LOG_WARNING, and var.

Referenced by realtime_sqlite3_load().

stop_batch_cb()

static int stop_batch_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 253 of file res_config_sqlite3.c.

{
    struct realtime_sqlite3_db *db = obj;
 
    db_stop_batch(db);
    return CMP_MATCH;
}

References CMP_MATCH, db, and db_stop_batch().

Referenced by unload_module().

str_cmp_fn()

static int str_cmp_fn ( void *  obj, void *  arg, int  flags  )

static

Definition at line 1143 of file res_config_sqlite3.c.

                                                       {
    return !strcasecmp((const char *) obj, (const char *) arg);
}

Referenced by realtime_sqlite3_require().

str_hash_fn()

static int str_hash_fn ( const void *  obj, const int  flags  )

static

Definition at line 1138 of file res_config_sqlite3.c.

{
    return ast_str_hash((const char *) obj);
}

References ast_str_hash().

Referenced by realtime_sqlite3_require().

str_to_requirements()

static int str_to_requirements ( const char *  data )

static

Definition at line 288 of file res_config_sqlite3.c.

{
    if (!strcasecmp(data, "createclose")) {
        return REALTIME_SQLITE3_REQ_CLOSE;
    } else if (!strcasecmp(data, "createchar")) {
        return REALTIME_SQLITE3_REQ_CHAR;
    }
    /* default */
    return REALTIME_SQLITE3_REQ_WARN;
}

References REALTIME_SQLITE3_REQ_CHAR, REALTIME_SQLITE3_REQ_CLOSE, and REALTIME_SQLITE3_REQ_WARN.

Referenced by new_realtime_sqlite3_db().

trace_cb()

static void trace_cb ( void *  arg, const char *  sql  )

static

Note

Since this is called while a query is executing, we should already hold the db lock

Definition at line 300 of file res_config_sqlite3.c.

{
    struct realtime_sqlite3_db *db = arg;
    ast_debug(3, "DB: %s SQL: %s\n", db->name, sql);
}

References ast_debug, and db.

Referenced by db_open(), and update_realtime_sqlite3_db().

unlink_dirty_databases()

static void unlink_dirty_databases ( void  )

static

Definition at line 283 of file res_config_sqlite3.c.

{
    ao2_callback(databases, OBJ_MULTIPLE | OBJ_NODATA | OBJ_UNLINK, is_dirty_cb, NULL);
}

References ao2_callback, is_dirty_cb(), NULL, OBJ_MULTIPLE, OBJ_NODATA, and OBJ_UNLINK.

Referenced by parse_config().

unload_module()

static int unload_module ( void  )

static

Definition at line 1324 of file res_config_sqlite3.c.

{
    ast_mutex_lock(&config_lock);
    ao2_callback(databases, OBJ_MULTIPLE | OBJ_NODATA | OBJ_UNLINK, stop_batch_cb, NULL);
    ao2_ref(databases, -1);
    databases = NULL;
    ast_config_engine_deregister(&sqlite3_config_engine);
    ast_mutex_unlock(&config_lock);
 
    return 0;
}

References ao2_callback, ao2_ref, ast_config_engine_deregister(), ast_mutex_lock, ast_mutex_unlock, config_lock, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_UNLINK, sqlite3_config_engine, and stop_batch_cb().

unref_db()

static void unref_db ( struct realtime_sqlite3_db **  db )

static

Definition at line 247 of file res_config_sqlite3.c.

{
    ao2_ref(*db, -1);
    *db = NULL;
}

References ao2_ref, db, and NULL.

Referenced by db_sync_thread(), new_realtime_sqlite3_db(), parse_config(), realtime_sqlite3_require(), and update_realtime_sqlite3_db().

update_realtime_sqlite3_db()

static int update_realtime_sqlite3_db ( struct realtime_sqlite3_db *  db, struct ast_config *  config, const char *  cat  )

static

Update an existing db object based on config data.

Parameters

db	The database object to update
config	The configuration data with which to update the db
cat	The config category (which becomes db->name)

Definition at line 435 of file res_config_sqlite3.c.

{
    struct realtime_sqlite3_db *new;
 
    if (!(new = new_realtime_sqlite3_db(config, cat))) {
        return -1;
    }
 
    /* Copy fields that don't need anything special done on change */
    db->requirements = new->requirements;
 
    /* Handle changes that require immediate behavior modification */
    if (db->debug != new->debug) {
        if (db->debug) {
            sqlite3_trace(db->handle, NULL, NULL);
        } else {
            sqlite3_trace(db->handle, trace_cb, db);
        }
        db->debug = new->debug;
    }
 
    if (strcmp(db->filename, new->filename)) {
        sqlite3_close(db->handle);
        ast_string_field_set(db, filename, new->filename);
        db_open(db); /* Also handles setting appropriate debug on new handle */
    }
 
    if (db->busy_timeout != new->busy_timeout) {
        db->busy_timeout = new->busy_timeout;
        sqlite3_busy_timeout(db->handle, db->busy_timeout);
    }
 
    if (db->batch != new->batch) {
        if (db->batch == 0) {
            db->batch = new->batch;
            db_start_batch(db);
        } else if (new->batch == 0) {
            db->batch = new->batch;
            db_stop_batch(db);
        }
        db->batch = new->batch;
    }
 
    db->dirty = 0;
    unref_db(&new);
 
    return 0;
}

References ast_string_field_set, config, db, db_open(), db_start_batch(), db_stop_batch(), realtime_sqlite3_db::filename, new_realtime_sqlite3_db(), NULL, realtime_sqlite3_db::requirements, trace_cb(), and unref_db().

Referenced by parse_config().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "SQLite 3 realtime config engine" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_REALTIME_DRIVER, .requires = "extconfig", }

static

Definition at line 1400 of file res_config_sqlite3.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1400 of file res_config_sqlite3.c.

config_lock

ast_mutex_t config_lock = AST_MUTEX_INIT_VALUE

static

Definition at line 110 of file res_config_sqlite3.c.

Referenced by parse_config(), and unload_module().

databases

struct ao2_container* databases

Definition at line 107 of file res_config_sqlite3.c.

has_explicit_like_escaping

int has_explicit_like_escaping

static

Definition at line 58 of file res_config_sqlite3.c.

Referenced by discover_sqlite3_caps(), and realtime_sqlite3_helper().

sqlite3_config_engine

struct ast_config_engine sqlite3_config_engine

Definition at line 70 of file res_config_sqlite3.c.

                                                 {
    .name = "sqlite3",
    .load_func = realtime_sqlite3_load,
    .realtime_func = realtime_sqlite3,
    .realtime_multi_func = realtime_sqlite3_multi,
    .update_func = realtime_sqlite3_update,
    .update2_func = realtime_sqlite3_update2,
    .store_func = realtime_sqlite3_store,
    .destroy_func = realtime_sqlite3_destroy,
    .require_func = realtime_sqlite3_require,
    .unload_func = realtime_sqlite3_unload,
};

Referenced by load_module(), and unload_module().

static_sql

const char* static_sql = "SELECT category, var_name, var_val FROM \"%q\" WHERE filename = %Q AND commented = 0 ORDER BY cat_metric ASC, var_metric ASC"

static

Note

It is important that the COL_* enum matches the order of the columns selected in static_sql

Definition at line 709 of file res_config_sqlite3.c.

Referenced by realtime_sqlite3_load().