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