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