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