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	__init_escape_column_buf (void)
static void	__init_escape_table_buf (void)
static void	__init_escape_value_buf (void)
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. More...
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. More...
struct ast_module *	AST_MODULE_SELF_SYM (void)
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. More...
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. More...
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. More...
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. More...
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. More...
static int	is_dirty_cb (void *obj, void *arg, int flags)
static int	load_module (void)
	Load the module. More...
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. More...
static int	parse_config (int reload)
	Parse the res_config_sqlite3 config file. More...
static struct ast_variable *	realtime_sqlite3 (const char *database, const char *table, const struct ast_variable *fields)
	Realtime callback for a single row query. More...
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. More...
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. More...
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. More...
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. More...
static int	realtime_sqlite3_require (const char *database, const char *table, va_list ap)
	Callback for ast_realtime_require. More...
static int	realtime_sqlite3_store (const char *database, const char *table, const struct ast_variable *fields)
	Realtime callback for inserting a row. More...
static int	realtime_sqlite3_unload (const char *database, const char *table)
	Callback for clearing any cached info. More...
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. More...
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. More...
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. More...
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. More...

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "SQLite 3 realtime config engine" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .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 = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
struct ao2_container *	databases
static struct ast_threadstorage	escape_column_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_escape_column_buf , .custom_init = NULL , }
static struct ast_threadstorage	escape_table_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_escape_table_buf , .custom_init = NULL , }
static struct ast_threadstorage	escape_value_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_escape_value_buf , .custom_init = NULL , }
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 <[email protected]> 

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 111 of file res_config_sqlite3.c.

Referenced by load_module().

IS_SQL_LIKE_CLAUSE

#define IS_SQL_LIKE_CLAUSE

(

x

)

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

Definition at line 796 of file res_config_sqlite3.c.

Referenced by realtime_sqlite3_helper().

Typedef Documentation

callback_t

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

Definition at line 120 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 86 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 713 of file res_config_sqlite3.c.

     {
   COL_CATEGORY,
   COL_VAR_NAME,
   COL_VAR_VAL,
   COL_COLUMNS,
};

Function Documentation

__init_escape_column_buf()

static void __init_escape_column_buf ( void  )

static

Definition at line 117 of file res_config_sqlite3.c.

{

__init_escape_table_buf()

static void __init_escape_table_buf ( void  )

static

Definition at line 116 of file res_config_sqlite3.c.

{

__init_escape_value_buf()

static void __init_escape_value_buf ( void  )

static

Definition at line 118 of file res_config_sqlite3.c.

{

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1403 of file res_config_sqlite3.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1403 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 1152 of file res_config_sqlite3.c.

References ao2_alloc, ao2_link, ao2_ref, and NULL.

Referenced by realtime_sqlite3_require().

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

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 513 of file res_config_sqlite3.c.

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().

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

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 1403 of file res_config_sqlite3.c.

db_cmp_fn()

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

static

Definition at line 224 of file res_config_sqlite3.c.

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

Referenced by load_module().

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

db_destructor()

static void db_destructor ( void *  obj )

static

Definition at line 231 of file res_config_sqlite3.c.

References ao2_lock, ao2_unlock, ast_debug, ast_string_field_free_memory, db, db_stop_batch(), realtime_sqlite3_db::handle, and realtime_sqlite3_db::name.

Referenced by new_realtime_sqlite3_db().

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

db_hash_fn()

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

static

Definition at line 217 of file res_config_sqlite3.c.

References ast_str_hash(), db, realtime_sqlite3_db::name, and OBJ_KEY.

Referenced by load_module().

{
   const struct realtime_sqlite3_db *db = obj;

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

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 339 of file res_config_sqlite3.c.

References ao2_lock, ao2_unlock, ast_log, realtime_sqlite3_db::busy_timeout, realtime_sqlite3_db::debug, realtime_sqlite3_db::filename, realtime_sqlite3_db::handle, LOG_WARNING, NULL, and trace_cb().

Referenced by parse_config(), and update_realtime_sqlite3_db().

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

db_start_batch()

void db_start_batch

(

struct realtime_sqlite3_db *

db

)

Definition at line 366 of file res_config_sqlite3.c.

References ao2_ref, ast_cond_init, ast_pthread_create_background, realtime_sqlite3_db::batch, realtime_sqlite3_db::cond, db_sync_thread(), realtime_sqlite3_db::has_batch_thread, NULL, and realtime_sqlite3_db::syncthread.

Referenced by parse_config(), and update_realtime_sqlite3_db().

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

db_stop_batch()

void db_stop_batch

(

struct realtime_sqlite3_db *

db

)

Definition at line 375 of file res_config_sqlite3.c.

References db_sync(), realtime_sqlite3_db::exiting, realtime_sqlite3_db::has_batch_thread, NULL, and realtime_sqlite3_db::syncthread.

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

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

db_sync()

static void db_sync ( struct realtime_sqlite3_db *  db )

static

Definition at line 360 of file res_config_sqlite3.c.

References ast_cond_signal, realtime_sqlite3_db::cond, and realtime_sqlite3_db::wakeup.

Referenced by db_stop_batch(), and realtime_sqlite3_exec_update_with_handle().

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

db_sync_thread()

static void* db_sync_thread ( void *  data )

static

Wrap commands in transactions increased write performance.

Definition at line 310 of file res_config_sqlite3.c.

References ao2_lock, ao2_object_get_lockaddr(), ao2_unlock, ast_cond_wait, realtime_sqlite3_db::batch, realtime_sqlite3_db::cond, db, realtime_sqlite3_db::exiting, NULL, realtime_sqlite3_exec_query_with_handle(), unref_db(), and realtime_sqlite3_db::wakeup.

Referenced by db_start_batch().

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

discover_sqlite3_caps()

static void discover_sqlite3_caps ( void  )

static

Definition at line 1339 of file res_config_sqlite3.c.

References ast_debug, and has_explicit_like_escaping.

Referenced by load_module().

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

find_database()

static struct realtime_sqlite3_db* find_database ( const char *  database )

static

Definition at line 245 of file res_config_sqlite3.c.

References ao2_find, and OBJ_KEY.

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

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

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 1053 of file res_config_sqlite3.c.

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, and RQ_UINTEGER8.

Referenced by handle_missing_column(), and handle_missing_table().

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

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 1115 of file res_config_sqlite3.c.

References ast_log, get_sqlite_column_type(), LOG_NOTICE, LOG_WARNING, realtime_sqlite3_db::name, realtime_sqlite3_exec_update_with_handle(), REALTIME_SQLITE3_REQ_CHAR, REALTIME_SQLITE3_REQ_WARN, and realtime_sqlite3_db::requirements.

Referenced by realtime_sqlite3_require().

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

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 1082 of file res_config_sqlite3.c.

References ast_free, ast_str_append(), ast_str_buffer(), ast_str_create, ast_str_set(), 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().

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

is_dirty_cb()

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

static

Definition at line 276 of file res_config_sqlite3.c.

References CMP_MATCH, db, db_stop_batch(), and realtime_sqlite3_db::dirty.

Referenced by unlink_dirty_databases().

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

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 1372 of file res_config_sqlite3.c.

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_ref, ast_config_engine_register(), ast_log, AST_MODFLAG_LOAD_ORDER, AST_MODPRI_REALTIME_DRIVER, AST_MODULE_INFO(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, AST_MODULE_SUPPORT_CORE, ASTERISK_GPL_KEY, DB_BUCKETS, db_cmp_fn(), db_hash_fn(), discover_sqlite3_caps(), LOG_ERROR, NULL, parse_config(), reload(), and unload_module().

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

mark_all_databases_dirty()

static void mark_all_databases_dirty ( void  )

static

Definition at line 271 of file res_config_sqlite3.c.

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

Referenced by parse_config().

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

mark_dirty_cb()

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

static

Definition at line 264 of file res_config_sqlite3.c.

References CMP_MATCH, db, and realtime_sqlite3_db::dirty.

Referenced by mark_all_databases_dirty().

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

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 388 of file res_config_sqlite3.c.

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(), realtime_sqlite3_db::batch, realtime_sqlite3_db::busy_timeout, db, db_destructor(), realtime_sqlite3_db::debug, realtime_sqlite3_db::filename, ast_variable::lineno, LOG_WARNING, ast_variable::name, realtime_sqlite3_db::name, ast_variable::next, NULL, PARSE_DEFAULT, PARSE_INT32, REALTIME_SQLITE3_REQ_WARN, realtime_sqlite3_db::requirements, str_to_requirements(), TIMELEN_MILLISECONDS, unref_db(), ast_variable::value, and var.

Referenced by parse_config(), and update_realtime_sqlite3_db().

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

parse_config()

static int parse_config ( int  reload )

static

Parse the res_config_sqlite3 config file.

Definition at line 1262 of file res_config_sqlite3.c.

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, unlink_dirty_databases(), unref_db(), and update_realtime_sqlite3_db().

Referenced by load_module(), and reload().

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

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 851 of file res_config_sqlite3.c.

References NULL, and realtime_sqlite3_helper().

{
   struct ast_variable *result_row = NULL;

   realtime_sqlite3_helper(database, table, fields, 0, &result_row);

   return result_row;
}

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 1015 of file res_config_sqlite3.c.

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.

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

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 633 of file res_config_sqlite3.c.

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

Referenced by realtime_sqlite3_helper(), and realtime_sqlite3_load().

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

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 599 of file res_config_sqlite3.c.

References ao2_lock, ao2_unlock, ast_log, realtime_sqlite3_db::handle, 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().

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

realtime_sqlite3_exec_update()

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

static

Definition at line 695 of file res_config_sqlite3.c.

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().

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

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 662 of file res_config_sqlite3.c.

References ao2_lock, ao2_unlock, ast_log, db_sync(), realtime_sqlite3_db::handle, LOG_WARNING, and NULL.

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

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

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 799 of file res_config_sqlite3.c.

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().

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

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 768 of file res_config_sqlite3.c.

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

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

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 863 of file res_config_sqlite3.c.

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

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

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 1174 of file res_config_sqlite3.c.

References add_column_name(), AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_find, ao2_ref, ast_log, ast_strlen_zero, columns, 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().

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

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 971 of file res_config_sqlite3.c.

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.

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

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 1254 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 882 of file res_config_sqlite3.c.

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.

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

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 918 of file res_config_sqlite3.c.

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.

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

reload()

static int reload ( void  )

static

Definition at line 1321 of file res_config_sqlite3.c.

References parse_config().

Referenced by load_module().

{
   parse_config(1);
   return 0;
}

row_counter_wrapper()

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

static

Definition at line 576 of file res_config_sqlite3.c.

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().

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

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 488 of file res_config_sqlite3.c.

References ast_variable_new, ast_variables_destroy(), NULL, and S_OR.

Referenced by realtime_sqlite3_helper().

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

sqlite3_escape_column()

static const char* sqlite3_escape_column ( const char *  param )

inlinestatic

Definition at line 167 of file res_config_sqlite3.c.

References escape_column_buf, and sqlite3_escape_string_helper().

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

{
   return sqlite3_escape_string_helper(&escape_column_buf, param);
}

sqlite3_escape_column_op()

static const char* sqlite3_escape_column_op ( const char *  param )

static

Definition at line 173 of file res_config_sqlite3.c.

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

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

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

sqlite3_escape_string_helper()

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

inlinestatic

Definition at line 130 of file res_config_sqlite3.c.

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

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

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

sqlite3_escape_table()

static const char* sqlite3_escape_table ( const char *  param )

inlinestatic

Definition at line 162 of file res_config_sqlite3.c.

References escape_table_buf, and 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().

{
   return sqlite3_escape_string_helper(&escape_table_buf, param);
}

sqlite3_escape_value()

static const char* sqlite3_escape_value ( const char *  param )

inlinestatic

Definition at line 212 of file res_config_sqlite3.c.

References escape_value_buf, and sqlite3_escape_string_helper().

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

{
   return sqlite3_escape_string_helper(&escape_value_buf, param);
}

static_realtime_cb()

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

static

Definition at line 720 of file res_config_sqlite3.c.

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, cfg_entry_args::cat, cfg_entry_args::cat_name, cfg_entry_args::cfg, COL_CATEGORY, COL_VAR_NAME, COL_VAR_VAL, cfg_entry_args::flags, LOG_WARNING, var, and cfg_entry_args::who_asked.

Referenced by realtime_sqlite3_load().

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

stop_batch_cb()

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

static

Definition at line 256 of file res_config_sqlite3.c.

References CMP_MATCH, db, and db_stop_batch().

Referenced by unload_module().

{
   struct realtime_sqlite3_db *db = obj;

   db_stop_batch(db);
   return CMP_MATCH;
}

str_cmp_fn()

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

static

Definition at line 1146 of file res_config_sqlite3.c.

Referenced by realtime_sqlite3_require().

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

str_hash_fn()

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

static

Definition at line 1141 of file res_config_sqlite3.c.

References ast_str_hash().

Referenced by realtime_sqlite3_require().

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

str_to_requirements()

static int str_to_requirements ( const char *  data )

static

Definition at line 291 of file res_config_sqlite3.c.

References REALTIME_SQLITE3_REQ_CHAR, REALTIME_SQLITE3_REQ_CLOSE, and REALTIME_SQLITE3_REQ_WARN.

Referenced by new_realtime_sqlite3_db().

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

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 303 of file res_config_sqlite3.c.

References ast_debug, db, and realtime_sqlite3_db::name.

Referenced by db_open(), and update_realtime_sqlite3_db().

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

unlink_dirty_databases()

static void unlink_dirty_databases ( void  )

static

Definition at line 286 of file res_config_sqlite3.c.

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

Referenced by parse_config().

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

unload_module()

static int unload_module ( void  )

static

Definition at line 1327 of file res_config_sqlite3.c.

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

Referenced by load_module().

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

unref_db()

static void unref_db ( struct realtime_sqlite3_db **  db )

static

Definition at line 250 of file res_config_sqlite3.c.

References ao2_ref, and NULL.

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

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

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 438 of file res_config_sqlite3.c.

References ast_string_field_set, realtime_sqlite3_db::batch, realtime_sqlite3_db::busy_timeout, db_open(), db_start_batch(), db_stop_batch(), realtime_sqlite3_db::debug, realtime_sqlite3_db::dirty, realtime_sqlite3_db::filename, realtime_sqlite3_db::handle, new_realtime_sqlite3_db(), NULL, realtime_sqlite3_db::requirements, trace_cb(), and unref_db().

Referenced by parse_config().

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

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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .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 1403 of file res_config_sqlite3.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1403 of file res_config_sqlite3.c.

config_lock

ast_mutex_t config_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

static

Definition at line 113 of file res_config_sqlite3.c.

Referenced by parse_config(), and unload_module().

databases

struct ao2_container* databases

Definition at line 110 of file res_config_sqlite3.c.

escape_column_buf

struct ast_threadstorage escape_column_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_escape_column_buf , .custom_init = NULL , }

static

Definition at line 117 of file res_config_sqlite3.c.

Referenced by sqlite3_escape_column(), and sqlite3_escape_column_op().

escape_table_buf

struct ast_threadstorage escape_table_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_escape_table_buf , .custom_init = NULL , }

static

Definition at line 116 of file res_config_sqlite3.c.

Referenced by sqlite3_escape_table().

escape_value_buf

struct ast_threadstorage escape_value_buf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_escape_value_buf , .custom_init = NULL , }

static

Definition at line 118 of file res_config_sqlite3.c.

Referenced by sqlite3_escape_string_helper(), and sqlite3_escape_value().

has_explicit_like_escaping

int has_explicit_like_escaping

static

Definition at line 61 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 73 of file res_config_sqlite3.c.

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 712 of file res_config_sqlite3.c.

Referenced by realtime_sqlite3_load().