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