install_prereq: Add SUSE.
[asterisk/asterisk.git] / res / res_config_sqlite3.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2011, Terry Wilson
5  *
6  * Terry Wilson <twilson@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  *
18  * Please follow coding guidelines
19  * http://svn.digium.com/view/asterisk/trunk/doc/CODING-GUIDELINES
20  */
21
22 /*! \file
23  *
24  * \brief SQLite 3 configuration engine
25  *
26  * \author\verbatim Terry Wilson <twilson@digium.com> \endverbatim
27  *
28  * This is a realtime configuration engine for the SQLite 3 Database
29  * \ingroup resources
30  */
31
32 /*! \li \ref res_config_sqlite3.c uses the configuration file \ref res_config_sqlite3.conf
33  * \addtogroup configuration_file Configuration Files
34  */
35
36 /*!
37  * \page res_config_sqlite3.conf res_config_sqlite3.conf
38  * \verbinclude res_config_sqlite3.conf.sample
39  */
40
41 /*** MODULEINFO
42         <depend>sqlite3</depend>
43         <support_level>core</support_level>
44  ***/
45
46 #include "asterisk.h"
47
48 #include <sqlite3.h>
49
50 #include "asterisk/module.h"
51 #include "asterisk/config.h"
52 #include "asterisk/paths.h"
53 #include "asterisk/astobj2.h"
54 #include "asterisk/lock.h"
55 #include "asterisk/utils.h"
56 #include "asterisk/app.h"
57
58 /*** DOCUMENTATION
59  ***/
60
61 static int has_explicit_like_escaping;
62
63 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);
64 static struct ast_variable *realtime_sqlite3(const char *database, const char *table, const struct ast_variable *fields);
65 static struct ast_config *realtime_sqlite3_multi(const char *database, const char *table, const struct ast_variable *fields);
66 static int realtime_sqlite3_update(const char *database, const char *table, const char *keyfield, const char *entity, const struct ast_variable *fields);
67 static int realtime_sqlite3_update2(const char *database, const char *table, const struct ast_variable *lookup_fields, const struct ast_variable *update_fields);
68 static int realtime_sqlite3_store(const char *database, const char *table, const struct ast_variable *fields);
69 static int realtime_sqlite3_destroy(const char *database, const char *table, const char *keyfield, const char *entity, const struct ast_variable *fields);
70 static int realtime_sqlite3_require(const char *database, const char *table, va_list ap);
71 static int realtime_sqlite3_unload(const char *database, const char *table);
72
73 struct ast_config_engine sqlite3_config_engine = {
74         .name = "sqlite3",
75         .load_func = realtime_sqlite3_load,
76         .realtime_func = realtime_sqlite3,
77         .realtime_multi_func = realtime_sqlite3_multi,
78         .update_func = realtime_sqlite3_update,
79         .update2_func = realtime_sqlite3_update2,
80         .store_func = realtime_sqlite3_store,
81         .destroy_func = realtime_sqlite3_destroy,
82         .require_func = realtime_sqlite3_require,
83         .unload_func = realtime_sqlite3_unload,
84 };
85
86 enum {
87         REALTIME_SQLITE3_REQ_WARN,
88         REALTIME_SQLITE3_REQ_CLOSE,
89         REALTIME_SQLITE3_REQ_CHAR,
90 };
91
92 struct realtime_sqlite3_db {
93         AST_DECLARE_STRING_FIELDS(
94                 AST_STRING_FIELD(name);
95                 AST_STRING_FIELD(filename);
96         );
97         sqlite3 *handle;
98         pthread_t syncthread;
99         ast_cond_t cond;
100         unsigned int requirements:2;
101         unsigned int dirty:1;
102         unsigned int debug:1;
103         unsigned int exiting:1;
104         unsigned int wakeup:1;
105         unsigned int batch;
106         int busy_timeout;
107 };
108
109 struct ao2_container *databases;
110 #define DB_BUCKETS 7
111
112 AST_MUTEX_DEFINE_STATIC(config_lock);
113
114 /* We need a separate buffer for each field we might use concurrently */
115 AST_THREADSTORAGE(escape_table_buf);
116 AST_THREADSTORAGE(escape_column_buf);
117 AST_THREADSTORAGE(escape_value_buf);
118
119 typedef int (*callback_t)(void*, int, char **, char **);
120
121 static int realtime_sqlite3_exec_query_with_handle(struct realtime_sqlite3_db *, const char *, callback_t, void *);
122 static int realtime_sqlite3_exec_query(const char *, const char *, callback_t, void *);
123 static int realtime_sqlite3_exec_update_with_handle(struct realtime_sqlite3_db *, const char *);
124 static int realtime_sqlite3_exec_update(const char *, const char *);
125
126 void db_start_batch(struct realtime_sqlite3_db *db);
127 void db_stop_batch(struct realtime_sqlite3_db *db);
128
129 static inline const char *sqlite3_escape_string_helper(struct ast_threadstorage *ts, const char *param)
130 {
131         size_t maxlen = strlen(param) * 2 + sizeof("\"\"");
132         /* It doesn't appear that sqlite3_snprintf will do more than double the
133          * length of a string with %q as an option. %Q could double and possibly
134          * add two quotes, and convert NULL pointers to the word "NULL", but we
135          * don't allow those anyway. Just going to use %q for now. */
136         struct ast_str *buf = ast_str_thread_get(ts, maxlen);
137         char q = ts == &escape_value_buf ? '\'' : '"';
138         char *tmp;
139
140         if (ast_str_size(buf) < maxlen) {
141                 /* realloc if buf is too small */
142                 ast_str_make_space(&buf, maxlen);
143         }
144         tmp = ast_str_buffer(buf);
145
146         ast_str_reset(buf);
147         *tmp++ = q; /* Initial quote */
148         while ((*tmp++ = *param++)) {
149                 /* Did we just copy a quote? Then double it. */
150                 if (*(tmp - 1) == q) {
151                         *tmp++ = q;
152                 }
153         }
154         *tmp = '\0'; /* Terminate past NULL from copy */
155         *(tmp - 1) = q; /* Replace original NULL with the quote */
156         ast_str_update(buf);
157
158         return ast_str_buffer(buf);
159 }
160
161 static inline const char *sqlite3_escape_table(const char *param)
162 {
163         return sqlite3_escape_string_helper(&escape_table_buf, param);
164 }
165
166 static inline const char *sqlite3_escape_column(const char *param)
167 {
168         return sqlite3_escape_string_helper(&escape_column_buf, param);
169 }
170
171 /* Not inlining this function because it uses strdupa and I don't know if the compiler would be dumb */
172 static const char *sqlite3_escape_column_op(const char *param)
173 {
174         size_t maxlen = strlen(param) * 2 + sizeof("\"\" =");
175         struct ast_str *buf = ast_str_thread_get(&escape_column_buf, maxlen);
176         char *tmp;
177         int space = 0;
178
179         if (ast_str_size(buf) < maxlen) {
180                 /* realloc if buf is too small */
181                 ast_str_make_space(&buf, maxlen);
182         }
183         tmp = ast_str_buffer(buf);
184
185         ast_str_reset(buf);
186         *tmp++ = '"';
187         while ((*tmp++ = *param++)) {
188                 /* If we have seen a space, don't double quotes. XXX If we ever make the column/op field
189                  * available to users via an API, we will definitely need to avoid allowing special
190                  * characters like ';' in the data past the space as it will be unquoted data */
191                 if (space) {
192                         continue;
193                 }
194                 if (*(tmp - 1) == ' ') {
195                         *(tmp - 1) = '"';
196                         *tmp++ = ' ';
197                         space = 1;
198                 } else if (*(tmp - 1) == '"') {
199                         *tmp++ = '"';
200                 }
201         }
202         if (!space) {
203                 strcpy(tmp - 1, "\" =");
204         }
205
206         ast_str_update(buf);
207
208         return ast_str_buffer(buf);
209 }
210
211 static inline const char *sqlite3_escape_value(const char *param)
212 {
213         return sqlite3_escape_string_helper(&escape_value_buf, param);
214 }
215
216 static int db_hash_fn(const void *obj, const int flags)
217 {
218         const struct realtime_sqlite3_db *db = obj;
219
220         return ast_str_hash(flags & OBJ_KEY ? (const char *) obj : db->name);
221 }
222
223 static int db_cmp_fn(void *obj, void *arg, int flags) {
224         struct realtime_sqlite3_db *db = obj, *other = arg;
225         const char *name = arg;
226
227         return !strcasecmp(db->name, flags & OBJ_KEY ? name : other->name) ? CMP_MATCH | CMP_STOP : 0;
228 }
229
230 static void db_destructor(void *obj)
231 {
232         struct realtime_sqlite3_db *db = obj;
233
234         ast_debug(1, "Destroying db: %s\n", db->name);
235         ast_string_field_free_memory(db);
236         db_stop_batch(db);
237         if (db->handle) {
238                 ao2_lock(db);
239                 sqlite3_close(db->handle);
240                 ao2_unlock(db);
241         }
242 }
243
244 static struct realtime_sqlite3_db *find_database(const char *database)
245 {
246         return ao2_find(databases, database, OBJ_KEY);
247 }
248
249 static void unref_db(struct realtime_sqlite3_db **db)
250 {
251         ao2_ref(*db, -1);
252         *db = NULL;
253 }
254
255 static int stop_batch_cb(void *obj, void *arg, int flags)
256 {
257         struct realtime_sqlite3_db *db = obj;
258
259         db_stop_batch(db);
260         return CMP_MATCH;
261 }
262
263 static int mark_dirty_cb(void *obj, void *arg, int flags)
264 {
265         struct realtime_sqlite3_db *db = obj;
266         db->dirty = 1;
267         return CMP_MATCH;
268 }
269
270 static void mark_all_databases_dirty(void)
271 {
272         ao2_callback(databases, OBJ_MULTIPLE | OBJ_NODATA, mark_dirty_cb, NULL);
273 }
274
275 static int is_dirty_cb(void *obj, void *arg, int flags)
276 {
277         struct realtime_sqlite3_db *db = obj;
278         if (db->dirty) {
279                 db_stop_batch(db);
280                 return CMP_MATCH;
281         }
282         return 0;
283 }
284
285 static void unlink_dirty_databases(void)
286 {
287         ao2_callback(databases, OBJ_MULTIPLE | OBJ_NODATA | OBJ_UNLINK, is_dirty_cb, NULL);
288 }
289
290 static int str_to_requirements(const char *data)
291 {
292         if (!strcasecmp(data, "createclose")) {
293                 return REALTIME_SQLITE3_REQ_CLOSE;
294         } else if (!strcasecmp(data, "createchar")) {
295                 return REALTIME_SQLITE3_REQ_CHAR;
296         }
297         /* default */
298         return REALTIME_SQLITE3_REQ_WARN;
299 }
300
301 /*! \note Since this is called while a query is executing, we should already hold the db lock */
302 static void trace_cb(void *arg, const char *sql)
303 {
304         struct realtime_sqlite3_db *db = arg;
305         ast_debug(3, "DB: %s SQL: %s\n", db->name, sql);
306 }
307
308 /*! \brief Wrap commands in transactions increased write performance */
309 static void *db_sync_thread(void *data)
310 {
311         struct realtime_sqlite3_db *db = data;
312         ao2_lock(db);
313         realtime_sqlite3_exec_query_with_handle(db, "BEGIN TRANSACTION", NULL, NULL);
314         for (;;) {
315                 if (!db->wakeup) {
316                         ast_cond_wait(&db->cond, ao2_object_get_lockaddr(db));
317                 }
318                 db->wakeup = 0;
319                 if (realtime_sqlite3_exec_query_with_handle(db, "COMMIT", NULL, NULL) < 0) {
320                         realtime_sqlite3_exec_query_with_handle(db, "ROLLBACK", NULL, NULL);
321                 }
322                 if (db->exiting) {
323                         ao2_unlock(db);
324                         break;
325                 }
326                 realtime_sqlite3_exec_query_with_handle(db, "BEGIN TRANSACTION", NULL, NULL);
327                 ao2_unlock(db);
328                 usleep(1000 * db->batch);
329                 ao2_lock(db);
330         }
331
332         unref_db(&db);
333
334         return NULL;
335 }
336
337 /*! \brief Open a database and appropriately set debugging on the db handle */
338 static int db_open(struct realtime_sqlite3_db *db)
339 {
340         ao2_lock(db);
341         if (sqlite3_open(db->filename, &db->handle) != SQLITE_OK) {
342                 ast_log(LOG_WARNING, "Could not open %s: %s\n", db->filename, sqlite3_errmsg(db->handle));
343                 ao2_unlock(db);
344                 return -1;
345         }
346         sqlite3_busy_timeout(db->handle, db->busy_timeout);
347
348         if (db->debug) {
349                 sqlite3_trace(db->handle, trace_cb, db);
350         } else {
351                 sqlite3_trace(db->handle, NULL, NULL);
352         }
353
354         ao2_unlock(db);
355
356         return 0;
357 }
358
359 static void db_sync(struct realtime_sqlite3_db *db)
360 {
361         db->wakeup = 1;
362         ast_cond_signal(&db->cond);
363 }
364
365 void db_start_batch(struct realtime_sqlite3_db *db)
366 {
367         if (db->batch) {
368                 ast_cond_init(&db->cond, NULL);
369                 ao2_ref(db, +1);
370                 ast_pthread_create_background(&db->syncthread, NULL, db_sync_thread, db);
371         }
372 }
373
374 void db_stop_batch(struct realtime_sqlite3_db *db)
375 {
376         if (db->batch) {
377                 db->exiting = 1;
378                 db_sync(db);
379                 pthread_join(db->syncthread, NULL);
380         }
381 }
382
383 /*! \brief Create a db object based on a config category
384  * \note Opening the db handle and linking to databases must be handled outside of this function
385  */
386 static struct realtime_sqlite3_db *new_realtime_sqlite3_db(struct ast_config *config, const char *cat)
387 {
388         struct ast_variable *var;
389         struct realtime_sqlite3_db *db;
390
391         if (!(db = ao2_alloc(sizeof(*db), db_destructor))) {
392                 return NULL;
393         }
394
395         if (ast_string_field_init(db, 64)) {
396                 unref_db(&db);
397                 return NULL;
398         }
399
400         /* Set defaults */
401         db->requirements = REALTIME_SQLITE3_REQ_WARN;
402         db->batch = 100;
403         ast_string_field_set(db, name, cat);
404         db->busy_timeout = 1000;
405
406         for (var = ast_variable_browse(config, cat); var; var = var->next) {
407                 if (!strcasecmp(var->name, "dbfile")) {
408                         ast_string_field_set(db, filename, var->value);
409                 } else if (!strcasecmp(var->name, "requirements")) {
410                         db->requirements = str_to_requirements(var->value);
411                 } else if (!strcasecmp(var->name, "batch")) {
412                         ast_app_parse_timelen(var->value, (int *) &db->batch, TIMELEN_MILLISECONDS);
413                 } else if (!strcasecmp(var->name, "debug")) {
414                         db->debug = ast_true(var->value);
415                 } else if (!strcasecmp(var->name, "busy_timeout")) {
416                         if (ast_parse_arg(var->value, PARSE_INT32|PARSE_DEFAULT, &(db->busy_timeout), 1000) != 0) {
417                                 ast_log(LOG_WARNING, "Invalid busy_timeout value '%s' at res_config_sqlite3.conf:%d. Using 1000 instead.\n", var->value, var->lineno);
418                         }
419                 }
420         }
421
422         if (ast_strlen_zero(db->filename)) {
423                 ast_log(LOG_WARNING, "Must specify dbfile in res_config_sqlite3.conf\n");
424                 unref_db(&db);
425                 return NULL;
426         }
427
428         return db;
429 }
430
431 /*! \brief Update an existing db object based on config data
432  * \param db The database object to update
433  * \param config The configuration data with which to update the db
434  * \param cat The config category (which becomes db->name)
435  */
436 static int update_realtime_sqlite3_db(struct realtime_sqlite3_db *db, struct ast_config *config, const char *cat)
437 {
438         struct realtime_sqlite3_db *new;
439
440         if (!(new = new_realtime_sqlite3_db(config, cat))) {
441                 return -1;
442         }
443
444         /* Copy fields that don't need anything special done on change */
445         db->requirements = new->requirements;
446
447         /* Handle changes that require immediate behavior modification */
448         if (db->debug != new->debug) {
449                 if (db->debug) {
450                         sqlite3_trace(db->handle, NULL, NULL);
451                 } else {
452                         sqlite3_trace(db->handle, trace_cb, db);
453                 }
454                 db->debug = new->debug;
455         }
456
457         if (strcmp(db->filename, new->filename)) {
458                 sqlite3_close(db->handle);
459                 ast_string_field_set(db, filename, new->filename);
460                 db_open(db); /* Also handles setting appropriate debug on new handle */
461         }
462
463         if (db->busy_timeout != new->busy_timeout) {
464                 db->busy_timeout = new->busy_timeout;
465                 sqlite3_busy_timeout(db->handle, db->busy_timeout);
466         }
467
468         if (db->batch != new->batch) {
469                 if (db->batch == 0) {
470                         db->batch = new->batch;
471                         db_start_batch(db);
472                 } else if (new->batch == 0) {
473                         db->batch = new->batch;
474                         db_stop_batch(db);
475                 }
476                 db->batch = new->batch;
477         }
478
479         db->dirty = 0;
480         unref_db(&new);
481
482         return 0;
483 }
484
485 /*! \brief Create a varlist from a single sqlite3 result row */
486 static int row_to_varlist(void *arg, int num_columns, char **values, char **columns)
487 {
488         struct ast_variable **head = arg, *tail;
489         int i;
490         struct ast_variable *new;
491
492         if (!(new = ast_variable_new(columns[0], S_OR(values[0], ""), ""))) {
493                 return SQLITE_ABORT;
494         }
495         *head = tail = new;
496
497         for (i = 1; i < num_columns; i++) {
498                 if (!(new = ast_variable_new(columns[i], S_OR(values[i], ""), ""))) {
499                         ast_variables_destroy(*head);
500                         *head = NULL;
501                         return SQLITE_ABORT;
502                 }
503                 tail->next = new;
504                 tail = new;
505         }
506
507         return 0;
508 }
509
510 /*! \brief Callback for creating an ast_config from a successive sqlite3 result rows */
511 static int append_row_to_cfg(void *arg, int num_columns, char **values, char **columns)
512 {
513         struct ast_config *cfg = arg;
514         struct ast_category *cat;
515         int i;
516
517         cat = ast_category_new_anonymous();
518         if (!cat) {
519                 return SQLITE_ABORT;
520         }
521
522         for (i = 0; i < num_columns; i++) {
523                 struct ast_variable *var;
524                 if (!(var = ast_variable_new(columns[i], S_OR(values[i], ""), ""))) {
525                         ast_log(LOG_ERROR, "Could not create new variable for '%s: %s', throwing away list\n", columns[i], values[i]);
526                         continue;
527                 }
528                 ast_variable_append(cat, var);
529         }
530         ast_category_append(cfg, cat);
531
532         return 0;
533 }
534
535 /*!
536  * Structure sent to the SQLite 3 callback function for static configuration.
537  *
538  * \see static_realtime_cb()
539  */
540 struct cfg_entry_args {
541         struct ast_config *cfg;
542         struct ast_category *cat;
543         char *cat_name;
544         struct ast_flags flags;
545         const char *who_asked;
546 };
547
548 /*!
549  * Structure passed to row counting SQLite callback.
550  */
551 struct row_counter_args {
552         callback_t wrapped_callback;
553         void *wrapped_arg;
554         int row_count;
555 };
556
557 /*!
558  * \internal
559  * \brief SQLite3 callback that counts rows of a result set.
560  *
561  * \details
562  * This is used to decorate existing callbacks so that we can count the number
563  * of rows returned from a SELECT statement and still process each row
564  * independently.
565  *
566  * \param data user data pointer passed in via sqlite3_exec()
567  * \param num_columns number of columns in the result
568  * \param values array of pointers to column values
569  * \param columns array of pointers of to column names
570  *
571  * \return the return value of the wrapped callback, or 0 if no wrapped callback
572  *         is provided.
573  */
574 static int row_counter_wrapper(void *arg, int num_columns, char **values, char **columns)
575 {
576         struct row_counter_args *wrapped = arg;
577         wrapped->row_count++;
578         if (wrapped->wrapped_callback) {
579                 return wrapped->wrapped_callback(wrapped->wrapped_arg, num_columns, values, columns);
580         }
581         return 0;
582 }
583
584 /*!
585  * \internal
586  * \brief Execute a SQL SELECT statement using a database handle
587  *
588  * \param db the database handle to use for the query
589  * \param sql the SQL statement to execute
590  * \param callback a user defined callback that will be called for each row of
591  *        the result set
592  * \param arg data to be passed to the user defined callback
593  *
594  * \return if successful, the number of rows returned from the provided SELECT
595  *         statement. -1 on failure.
596  */
597 static int realtime_sqlite3_exec_query_with_handle(struct realtime_sqlite3_db *db, const char *sql, callback_t callback, void *arg)
598 {
599         int res = 0;
600         char *errmsg;
601         struct row_counter_args wrapper = {
602                 .wrapped_callback = callback,
603                 .wrapped_arg = arg,
604                 .row_count = 0,
605         };
606
607         ao2_lock(db);
608         if (sqlite3_exec(db->handle, sql, row_counter_wrapper, &wrapper, &errmsg) != SQLITE_OK) {
609                 ast_log(LOG_WARNING, "Could not execute '%s': %s\n", sql, errmsg);
610                 sqlite3_free(errmsg);
611                 res = -1;
612         }
613         ao2_unlock(db);
614
615         return res == 0 ? wrapper.row_count : res;
616 }
617
618 /*!
619  * \internal
620  * \brief Execute a SQL SELECT statement on the specified database
621  *
622  * \param database the name of the database to query
623  * \param sql the SQL statement to execute
624  * \param callback a user defined callback that will be called for each row of
625  *        the result set
626  * \param arg data to be passed to the user defined callback
627  *
628  * \return if successful, the number of rows returned from the provided SELECT
629  *         statement. -1 on failure.
630  */
631 static int realtime_sqlite3_exec_query(const char *database, const char *sql, callback_t callback, void *arg)
632 {
633         struct realtime_sqlite3_db *db;
634         int res;
635
636         if (!(db = find_database(database))) {
637                 ast_log(LOG_WARNING, "Could not find database: %s\n", database);
638                 return -1;
639         }
640
641         res = realtime_sqlite3_exec_query_with_handle(db, sql, callback, arg);
642         ao2_ref(db, -1);
643
644         return res;
645 }
646
647 /*!
648  * \internal
649  * \brief Execute a SQL INSERT/UPDATE/DELETE statement using a database handle
650  *
651  * \note A database sync operation is always performed after a statement
652  *       is executed.
653  *
654  * \param db the database handle to use for the query
655  * \param sql the SQL statement to execute
656  *
657  * \return if successful, the number of rows modified by the provided SQL
658  *         statement. -1 on failure.
659  */
660 static int realtime_sqlite3_exec_update_with_handle(struct realtime_sqlite3_db *db, const char *sql)
661 {
662         int res = 0;
663         char *errmsg;
664
665         ao2_lock(db);
666         if (sqlite3_exec(db->handle, sql, NULL, NULL, &errmsg) != SQLITE_OK) {
667                 ast_log(LOG_WARNING, "Could not execute '%s': %s\n", sql, errmsg);
668                 sqlite3_free(errmsg);
669                 res = -1;
670         } else {
671                 res = sqlite3_changes(db->handle);
672         }
673         ao2_unlock(db);
674
675         db_sync(db);
676
677         return res;
678 }
679
680 /*!
681  * \internal
682  * \brief Execute a SQL INSERT/UPDATE/DELETE statement using a database handle
683  *
684  * \note A database sync operation is always performed after a statement
685  *       is executed.
686  *
687  * \param database the name of the database to query
688  * \param sql the SQL statement to execute
689  *
690  * \return if successful, the number of rows modified by the provided SQL
691  *         statement. -1 on failure.
692  */
693 static int realtime_sqlite3_exec_update(const char *database, const char *sql)
694 {
695         struct realtime_sqlite3_db *db;
696         int res;
697
698         if (!(db = find_database(database))) {
699                 ast_log(LOG_WARNING, "Could not find database: %s\n", database);
700                 return -1;
701         }
702
703         res = realtime_sqlite3_exec_update_with_handle(db, sql);
704         ao2_ref(db, -1);
705
706         return res;
707 }
708
709 /*! \note It is important that the COL_* enum matches the order of the columns selected in static_sql */
710 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";
711 enum {
712         COL_CATEGORY,
713         COL_VAR_NAME,
714         COL_VAR_VAL,
715         COL_COLUMNS,
716 };
717
718 static int static_realtime_cb(void *arg, int num_columns, char **values, char **columns)
719 {
720         struct cfg_entry_args *args = arg;
721         struct ast_variable *var;
722
723         if (!strcmp(values[COL_VAR_NAME], "#include")) {
724                 struct ast_config *cfg;
725                 char *val;
726
727                 val = values[COL_VAR_VAL];
728                 if (!(cfg = ast_config_internal_load(val, args->cfg, args->flags, "", args->who_asked))) {
729                         ast_log(LOG_WARNING, "Unable to include %s\n", val);
730                         return SQLITE_ABORT;
731                 } else {
732                         args->cfg = cfg;
733                         return 0;
734                 }
735         }
736
737         if (!args->cat_name || strcmp(args->cat_name, values[COL_CATEGORY])) {
738                 args->cat = ast_category_new_dynamic(values[COL_CATEGORY]);
739                 if (!args->cat) {
740                         return SQLITE_ABORT;
741                 }
742
743                 ast_free(args->cat_name);
744
745                 if (!(args->cat_name = ast_strdup(values[COL_CATEGORY]))) {
746                         ast_category_destroy(args->cat);
747                         return SQLITE_ABORT;
748                 }
749
750                 ast_category_append(args->cfg, args->cat);
751         }
752
753         if (!(var = ast_variable_new(values[COL_VAR_NAME], values[COL_VAR_VAL], ""))) {
754                 ast_log(LOG_WARNING, "Unable to allocate variable\n");
755                 return SQLITE_ABORT;
756         }
757
758         ast_variable_append(args->cat, var);
759
760         return 0;
761 }
762
763 /*! \brief Realtime callback for static realtime
764  * \return ast_config on success, NULL on failure
765  */
766 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)
767 {
768         char *sql;
769         struct cfg_entry_args args;
770
771         if (ast_strlen_zero(table)) {
772                 ast_log(LOG_WARNING, "Must have a table to query!\n");
773                 return NULL;
774         }
775
776         if (!(sql = sqlite3_mprintf(static_sql, table, configfile))) {
777                 ast_log(LOG_WARNING, "Couldn't allocate query\n");
778                 return NULL;
779         };
780
781         args.cfg = config;
782         args.cat = NULL;
783         args.cat_name = NULL;
784         args.flags = flags;
785         args.who_asked = who_asked;
786
787         realtime_sqlite3_exec_query(database, sql, static_realtime_cb, &args);
788
789         sqlite3_free(sql);
790
791         return config;
792 }
793
794 #define IS_SQL_LIKE_CLAUSE(x) ((x) && ast_ends_with(x, " LIKE"))
795
796 /*! \brief Helper function for single and multi-row realtime load functions */
797 static int realtime_sqlite3_helper(const char *database, const char *table, const struct ast_variable *fields, int is_multi, void *arg)
798 {
799         struct ast_str *sql;
800         const struct ast_variable *field;
801         int first = 1;
802
803         if (ast_strlen_zero(table)) {
804                 ast_log(LOG_WARNING, "Must have a table to query!\n");
805                 return -1;
806         }
807
808         if (!(sql = ast_str_create(128))) {
809                 return -1;
810         }
811
812         for (field = fields; field; field = field->next) {
813                 if (first) {
814                         ast_str_set(&sql, 0, "SELECT * FROM %s WHERE %s %s", sqlite3_escape_table(table),
815                                     sqlite3_escape_column_op(field->name), sqlite3_escape_value(field->value));
816                         first = 0;
817                 } else {
818                         ast_str_append(&sql, 0, " AND %s %s", sqlite3_escape_column_op(field->name),
819                                         sqlite3_escape_value(field->value));
820                 }
821
822                 if (has_explicit_like_escaping && IS_SQL_LIKE_CLAUSE(field->name)) {
823                         /*
824                          * The realtime framework is going to pre-escape these
825                          * for us with a backslash. We just need to make sure
826                          * to tell SQLite about it
827                          */
828                         ast_str_append(&sql, 0, " ESCAPE '\\'");
829                 }
830         }
831
832         if (!is_multi) {
833                 ast_str_append(&sql, 0, "%s", " LIMIT 1");
834         }
835
836         if (realtime_sqlite3_exec_query(database, ast_str_buffer(sql), is_multi ? append_row_to_cfg : row_to_varlist, arg) < 0) {
837                 ast_free(sql);
838                 return -1;
839         }
840
841         ast_free(sql);
842
843         return 0;
844 }
845
846 /*! \brief Realtime callback for a single row query
847  * \return ast_variable list for single result on success, NULL on empty/failure
848  */
849 static struct ast_variable *realtime_sqlite3(const char *database, const char *table, const struct ast_variable *fields)
850 {
851         struct ast_variable *result_row = NULL;
852
853         realtime_sqlite3_helper(database, table, fields, 0, &result_row);
854
855         return result_row;
856 }
857
858 /*! \brief Realtime callback for a multi-row query
859  * \return ast_config containing possibly many results on success, NULL on empty/failure
860  */
861 static struct ast_config *realtime_sqlite3_multi(const char *database, const char *table, const struct ast_variable *fields)
862 {
863         struct ast_config *cfg;
864
865         if (!(cfg = ast_config_new())) {
866                 return NULL;
867         }
868
869         if (realtime_sqlite3_helper(database, table, fields, 1, cfg)) {
870                 ast_config_destroy(cfg);
871                 return NULL;
872         }
873
874         return cfg;
875 }
876
877 /*! \brief Realtime callback for updating a row based on a single criteria
878  * \return Number of rows affected or -1 on error
879  */
880 static int realtime_sqlite3_update(const char *database, const char *table, const char *keyfield, const char *entity, const struct ast_variable *fields)
881 {
882         struct ast_str *sql;
883         const struct ast_variable *field;
884         int first = 1, res;
885
886         if (ast_strlen_zero(table)) {
887                 ast_log(LOG_WARNING, "Must have a table to query!\n");
888                 return -1;
889         }
890
891         if (!(sql = ast_str_create(128))) {
892                 return -1;
893         }
894
895         for (field = fields; field; field = field->next) {
896                 if (first) {
897                         ast_str_set(&sql, 0, "UPDATE %s SET %s = %s",
898                                         sqlite3_escape_table(table), sqlite3_escape_column(field->name), sqlite3_escape_value(field->value));
899                         first = 0;
900                 } else {
901                         ast_str_append(&sql, 0, ", %s = %s", sqlite3_escape_column(field->name), sqlite3_escape_value(field->value));
902                 }
903         }
904
905         ast_str_append(&sql, 0, " WHERE %s %s", sqlite3_escape_column_op(keyfield), sqlite3_escape_value(entity));
906
907         res = realtime_sqlite3_exec_update(database, ast_str_buffer(sql));
908         ast_free(sql);
909
910         return res;
911 }
912
913 /*! \brief Realtime callback for updating a row based on multiple criteria
914  * \return Number of rows affected or -1 on error
915  */
916 static int realtime_sqlite3_update2(const char *database, const char *table, const struct ast_variable *lookup_fields, const struct ast_variable *update_fields)
917 {
918         struct ast_str *sql;
919         struct ast_str *where_clause;
920         const struct ast_variable *field;
921         int first = 1, res;
922
923         if (ast_strlen_zero(table)) {
924                 ast_log(LOG_WARNING, "Must have a table to query!\n");
925                 return -1;
926         }
927
928         if (!(sql = ast_str_create(128))) {
929                 return -1;
930         }
931
932         if (!(where_clause = ast_str_create(128))) {
933                 ast_free(sql);
934                 return -1;
935         }
936
937         for (field = lookup_fields; field; field = field->next) {
938                 if (first) {
939                         ast_str_set(&where_clause, 0, " WHERE %s %s", sqlite3_escape_column_op(field->name), sqlite3_escape_value(field->value));
940                         first = 0;
941                 } else {
942                         ast_str_append(&where_clause, 0, " AND %s %s", sqlite3_escape_column_op(field->name), sqlite3_escape_value(field->value));
943                 }
944         }
945
946         first = 1;
947         for (field = update_fields; field; field = field->next) {
948                 if (first) {
949                         ast_str_set(&sql, 0, "UPDATE %s SET %s = %s", sqlite3_escape_table(table), sqlite3_escape_column(field->name), sqlite3_escape_value(field->value));
950                         first = 0;
951                 } else {
952                         ast_str_append(&sql, 0, ", %s = %s", sqlite3_escape_column(field->name), sqlite3_escape_value(field->value));
953                 }
954         }
955
956         ast_str_append(&sql, 0, "%s", ast_str_buffer(where_clause));
957
958         res = realtime_sqlite3_exec_update(database, ast_str_buffer(sql));
959
960         ast_free(sql);
961         ast_free(where_clause);
962
963         return res;
964 }
965
966 /*! \brief Realtime callback for inserting a row
967  * \return Number of rows affected or -1 on error
968  */
969 static int realtime_sqlite3_store(const char *database, const char *table, const struct ast_variable *fields)
970 {
971         struct ast_str *sql, *values;
972         const struct ast_variable *field;
973         int first = 1, res;
974
975         if (ast_strlen_zero(table)) {
976                 ast_log(LOG_WARNING, "Must have a table to query!\n");
977                 return -1;
978         }
979
980         if (!(sql = ast_str_create(128))) {
981                 return -1;
982         }
983
984         if (!(values = ast_str_create(128))) {
985                 ast_free(sql);
986                 return -1;
987         }
988
989         for (field = fields; field; field = field->next) {
990                 if (first) {
991                         ast_str_set(&sql, 0, "INSERT INTO %s (%s", sqlite3_escape_table(table), sqlite3_escape_column(field->name));
992                         ast_str_set(&values, 0, ") VALUES (%s", sqlite3_escape_value(field->value));
993                         first = 0;
994                 } else {
995                         ast_str_append(&sql, 0, ", %s", sqlite3_escape_column(field->name));
996                         ast_str_append(&values, 0, ", %s", sqlite3_escape_value(field->value));
997                 }
998         }
999
1000         ast_str_append(&sql, 0, "%s)", ast_str_buffer(values));
1001
1002         res = realtime_sqlite3_exec_update(database, ast_str_buffer(sql));
1003
1004         ast_free(sql);
1005         ast_free(values);
1006
1007         return res;
1008 }
1009
1010 /*! \brief Realtime callback for deleting a row
1011  * \return Number of rows affected or -1 on error
1012  */
1013 static int realtime_sqlite3_destroy(const char *database, const char *table, const char *keyfield, const char *entity, const struct ast_variable *fields)
1014 {
1015         struct ast_str *sql;
1016         const struct ast_variable *field;
1017         int first = 1, res;
1018
1019         if (ast_strlen_zero(table)) {
1020                 ast_log(LOG_WARNING, "Must have a table to query!\n");
1021                 return -1;
1022         }
1023
1024         if (!(sql = ast_str_create(128))) {
1025                 return -1;
1026         }
1027
1028         for (field = fields; field; field = field->next) {
1029                 if (first) {
1030                         ast_str_set(&sql, 0, "DELETE FROM %s WHERE %s %s", sqlite3_escape_table(table),
1031                                         sqlite3_escape_column_op(field->name), sqlite3_escape_value(field->value));
1032                         first = 0;
1033                 } else {
1034                         ast_str_append(&sql, 0, " AND %s %s", sqlite3_escape_column_op(field->name), sqlite3_escape_value(field->value));
1035                 }
1036         }
1037
1038         res = realtime_sqlite3_exec_update(database, ast_str_buffer(sql));
1039
1040         ast_free(sql);
1041
1042         return res;
1043 }
1044
1045 /*! \brief Convert Asterisk realtime types to SQLite 3 types
1046  * \note SQLite 3 has NULL, INTEGER, REAL, TEXT, and BLOB types. Any column other than
1047  * an INTEGER PRIMARY KEY will actually store any kind of data due to its dynamic
1048  * typing. When we create columns, we'll go ahead and use these base types instead
1049  * of messing with column widths, etc. */
1050
1051 static const char *get_sqlite_column_type(int type)
1052 {
1053         switch(type) {
1054         case RQ_INTEGER1 :
1055         case RQ_UINTEGER1 :
1056         case RQ_INTEGER2 :
1057         case RQ_UINTEGER2 :
1058         case RQ_INTEGER3 :
1059         case RQ_UINTEGER3 :
1060         case RQ_INTEGER4 :
1061         case RQ_UINTEGER4 :
1062         case RQ_INTEGER8 :
1063                 return "INTEGER";
1064         case RQ_UINTEGER8 : /* SQLite3 stores INTEGER as signed 8-byte */
1065         case RQ_CHAR :
1066         case RQ_DATE :
1067         case RQ_DATETIME :
1068                 return "TEXT";
1069         case RQ_FLOAT :
1070                 return "REAL";
1071         default :
1072                 return "TEXT";
1073         }
1074
1075         return "TEXT";
1076 }
1077
1078 /*! \brief Create a table if ast_realtime_require shows that we are configured to handle the data
1079  */
1080 static int handle_missing_table(struct realtime_sqlite3_db *db, const char *table, va_list ap)
1081 {
1082         const char *column;
1083         int type, first = 1, res;
1084         size_t sz;
1085         struct ast_str *sql;
1086
1087         if (!(sql = ast_str_create(128))) {
1088                 return -1;
1089         }
1090
1091         while ((column = va_arg(ap, typeof(column)))) {
1092                 type = va_arg(ap, typeof(type));
1093                 sz = va_arg(ap, typeof(sz));
1094                 if (first) {
1095                         ast_str_set(&sql, 0, "CREATE TABLE IF NOT EXISTS %s (%s %s", sqlite3_escape_table(table),
1096                                         sqlite3_escape_column(column), get_sqlite_column_type(type));
1097                         first = 0;
1098                 } else {
1099                         ast_str_append(&sql, 0, ", %s %s", sqlite3_escape_column(column), get_sqlite_column_type(type));
1100                 }
1101         }
1102
1103         ast_str_append(&sql, 0, ")");
1104
1105         res = realtime_sqlite3_exec_update_with_handle(db, ast_str_buffer(sql)) < 0 ? -1 : 0;
1106         ast_free(sql);
1107
1108         return res;
1109 }
1110
1111 /*! \brief If ast_realtime_require sends info about a column we don't have, create it
1112  */
1113 static int handle_missing_column(struct realtime_sqlite3_db *db, const char *table, const char *column, int type, size_t sz)
1114 {
1115         char *sql;
1116         const char *sqltype = get_sqlite_column_type(type);
1117         int res;
1118
1119         if (db->requirements == REALTIME_SQLITE3_REQ_WARN) {
1120                 ast_log(LOG_WARNING, "Missing column '%s' of type '%s' in %s.%s\n", column, sqltype, db->name, table);
1121                 return -1;
1122         } else if (db->requirements == REALTIME_SQLITE3_REQ_CHAR) {
1123                 sqltype = "TEXT";
1124         }
1125
1126         if (!(sql = sqlite3_mprintf("ALTER TABLE \"%q\" ADD COLUMN \"%q\" %s", table, column, sqltype))) {
1127                 return -1;
1128         }
1129
1130         if (!(res = (realtime_sqlite3_exec_update_with_handle(db, sql) < 0 ? -1 : 0))) {
1131                 ast_log(LOG_NOTICE, "Creating column '%s' type %s for table %s\n", column, sqltype, table);
1132         }
1133
1134         sqlite3_free(sql);
1135
1136         return res;
1137 }
1138
1139 static int str_hash_fn(const void *obj, const int flags)
1140 {
1141         return ast_str_hash((const char *) obj);
1142 }
1143
1144 static int str_cmp_fn(void *obj, void *arg, int flags) {
1145         return !strcasecmp((const char *) obj, (const char *) arg);
1146 }
1147
1148 /*! \brief Callback for creating a hash of column names for comparison in realtime_sqlite3_require
1149  */
1150 static int add_column_name(void *arg, int num_columns, char **values, char **columns)
1151 {
1152         char *column;
1153         struct ao2_container *cnames = arg;
1154
1155
1156         if (!(column = ao2_alloc(strlen(values[1]) + 1, NULL))) {
1157                 return -1;
1158         }
1159
1160         strcpy(column, values[1]);
1161
1162         ao2_link(cnames, column);
1163         ao2_ref(column, -1);
1164
1165         return 0;
1166 }
1167
1168 /*! \brief Callback for ast_realtime_require
1169  * \retval 0 Required fields met specified standards
1170  * \retval -1 One or more fields was missing or insufficient
1171  */
1172 static int realtime_sqlite3_require(const char *database, const char *table, va_list ap)
1173 {
1174         const char *column;
1175         char *sql;
1176         int type;
1177         int res;
1178         size_t sz;
1179         struct ao2_container *columns;
1180         struct realtime_sqlite3_db *db;
1181
1182         /* SQLite3 columns are dynamically typed, with type affinity. Built-in functions will
1183          * return the results as char * anyway. The only field that cannot contain text
1184          * data is an INTEGER PRIMARY KEY, which must be a 64-bit signed integer. So, for
1185          * the purposes here we really only care whether the column exists and not what its
1186          * type or length is. */
1187
1188         if (ast_strlen_zero(table)) {
1189                 ast_log(LOG_WARNING, "Must have a table to query!\n");
1190                 return -1;
1191         }
1192
1193         if (!(db = find_database(database))) {
1194                 return -1;
1195         }
1196
1197         if (!(columns = ao2_container_alloc(31, str_hash_fn, str_cmp_fn))) {
1198                 unref_db(&db);
1199            return -1;
1200         }
1201
1202         if (!(sql = sqlite3_mprintf("PRAGMA table_info(\"%q\")", table))) {
1203                 unref_db(&db);
1204                 ao2_ref(columns, -1);
1205                 return -1;
1206         }
1207
1208         if ((res = realtime_sqlite3_exec_query_with_handle(db, sql, add_column_name, columns)) < 0) {
1209                 unref_db(&db);
1210                 ao2_ref(columns, -1);
1211                 sqlite3_free(sql);
1212                 return -1;
1213         } else if (res == 0) {
1214                 /* Table does not exist */
1215                 sqlite3_free(sql);
1216                 res = handle_missing_table(db, table, ap);
1217                 ao2_ref(columns, -1);
1218                 unref_db(&db);
1219                 return res;
1220         }
1221
1222         sqlite3_free(sql);
1223
1224         while ((column = va_arg(ap, typeof(column)))) {
1225                 char *found;
1226                 type = va_arg(ap, typeof(type));
1227                 sz = va_arg(ap, typeof(sz));
1228                 if (!(found = ao2_find(columns, column, OBJ_POINTER | OBJ_UNLINK))) {
1229                         if (handle_missing_column(db, table, column, type, sz)) {
1230                                 unref_db(&db);
1231                                 ao2_ref(columns, -1);
1232                                 return -1;
1233                         }
1234                 } else {
1235                         ao2_ref(found, -1);
1236                 }
1237         }
1238
1239         ao2_ref(columns, -1);
1240         unref_db(&db);
1241
1242         return 0;
1243 }
1244
1245 /*! \brief Callback for clearing any cached info
1246  * \note We don't currently cache anything
1247  * \retval 0 If any cache was purged
1248  * \retval -1 If no cache was found
1249  */
1250 static int realtime_sqlite3_unload(const char *database, const char *table)
1251 {
1252         /* We currently do no caching */
1253         return -1;
1254 }
1255
1256 /*! \brief Parse the res_config_sqlite3 config file
1257  */
1258 static int parse_config(int reload)
1259 {
1260         struct ast_config *config;
1261         struct ast_flags config_flags = { CONFIG_FLAG_NOREALTIME | (reload ? CONFIG_FLAG_FILEUNCHANGED : 0) };
1262         static const char *config_filename = "res_config_sqlite3.conf";
1263
1264         config = ast_config_load(config_filename, config_flags);
1265
1266         if (config == CONFIG_STATUS_FILEUNCHANGED) {
1267                 ast_debug(1, "%s was unchanged, skipping parsing\n", config_filename);
1268                 return 0;
1269         }
1270
1271         ast_mutex_lock(&config_lock);
1272
1273         if (config == CONFIG_STATUS_FILEMISSING || config == CONFIG_STATUS_FILEINVALID) {
1274                 ast_log(LOG_ERROR, "%s config file '%s'\n",
1275                         config == CONFIG_STATUS_FILEMISSING ? "Missing" : "Invalid", config_filename);
1276                 ast_mutex_unlock(&config_lock);
1277                 return 0;
1278         } else {
1279                 const char *cat;
1280                 struct realtime_sqlite3_db *db;
1281
1282                 mark_all_databases_dirty();
1283                 for (cat = ast_category_browse(config, NULL); cat; cat = ast_category_browse(config, cat)) {
1284                         if (!strcasecmp(cat, "general")) {
1285                                 continue;
1286                         }
1287                         if (!(db = find_database(cat))) {
1288                                 if (!(db = new_realtime_sqlite3_db(config, cat))) {
1289                                         ast_log(LOG_WARNING, "Could not allocate new db for '%s' - skipping.\n", cat);
1290                                         continue;
1291                                 }
1292                                 if (db_open(db)) {
1293                                         unref_db(&db);
1294                                         continue;
1295                                 }
1296                                 db_start_batch(db);
1297                                 ao2_link(databases, db);
1298                                 unref_db(&db);
1299                         } else  {
1300                                 if (update_realtime_sqlite3_db(db, config, cat)) {
1301                                         unref_db(&db);
1302                                         continue;
1303                                 }
1304                                 unref_db(&db);
1305                         }
1306                 }
1307                 unlink_dirty_databases();
1308         }
1309
1310         ast_mutex_unlock(&config_lock);
1311
1312         ast_config_destroy(config);
1313
1314         return 0;
1315 }
1316
1317 static int reload(void)
1318 {
1319         parse_config(1);
1320         return 0;
1321 }
1322
1323 static int unload_module(void)
1324 {
1325         ast_mutex_lock(&config_lock);
1326         ao2_callback(databases, OBJ_MULTIPLE | OBJ_NODATA | OBJ_UNLINK, stop_batch_cb, NULL);
1327         ao2_ref(databases, -1);
1328         databases = NULL;
1329         ast_config_engine_deregister(&sqlite3_config_engine);
1330         ast_mutex_unlock(&config_lock);
1331
1332         return 0;
1333 }
1334
1335 static void discover_sqlite3_caps(void)
1336 {
1337         /*
1338          * So we cheat a little bit here. SQLite3 added support for the
1339          * 'ESCAPE' keyword in 3.1.0. They added SQLITE_VERSION_NUMBER
1340          * in 3.1.2. So if we run into 3.1.0 or 3.1.1 in the wild, we
1341          * just treat it like < 3.1.0.
1342          *
1343          * For reference: 3.1.0, 3.1.1, and 3.1.2 were all released
1344          * within 30 days of each other in Jan/Feb 2005, so I don't
1345          * imagine we'll be finding something pre-3.1.2 that often in
1346          * practice.
1347          */
1348 #if defined(SQLITE_VERSION_NUMBER)
1349         has_explicit_like_escaping = 1;
1350 #else
1351         has_explicit_like_escaping = 0;
1352 #endif
1353
1354         ast_debug(3, "SQLite3 has 'LIKE ... ESCAPE ...' support? %s\n",
1355                         has_explicit_like_escaping ? "Yes" : "No");
1356 }
1357
1358 /*!
1359  * \brief Load the module
1360  *
1361  * Module loading including tests for configuration or dependencies.
1362  * This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE,
1363  * or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails
1364  * tests return AST_MODULE_LOAD_FAILURE. If the module can not load the
1365  * configuration file or other non-critical problem return
1366  * AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.
1367  */
1368 static int load_module(void)
1369 {
1370         discover_sqlite3_caps();
1371
1372         if (!((databases = ao2_container_alloc(DB_BUCKETS, db_hash_fn, db_cmp_fn)))) {
1373                 return AST_MODULE_LOAD_DECLINE;
1374         }
1375
1376         if (parse_config(0)) {
1377                 ao2_ref(databases, -1);
1378                 return AST_MODULE_LOAD_DECLINE;
1379         }
1380
1381         if (!(ast_config_engine_register(&sqlite3_config_engine))) {
1382                 ast_log(LOG_ERROR, "The config API must have changed, this shouldn't happen.\n");
1383                 ao2_ref(databases, -1);
1384                 return AST_MODULE_LOAD_DECLINE;
1385         }
1386
1387         return AST_MODULE_LOAD_SUCCESS;
1388 }
1389
1390 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "SQLite 3 realtime config engine",
1391         .support_level = AST_MODULE_SUPPORT_CORE,
1392         .load = load_module,
1393         .unload = unload_module,
1394         .reload = reload,
1395         .load_pri = AST_MODPRI_REALTIME_DRIVER,
1396 );