include "logger.h" and errno.h from asterisk.h - usage shows that they
[asterisk/asterisk.git] / res / res_config_sqlite.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2006, Proformatique
5  *
6  * Written by Richard Braun <rbraun@proformatique.com>
7  *
8  * Based on res_sqlite3 by Anthony Minessale II,
9  * and res_config_mysql by Matthew Boehm
10  *
11  * See http://www.asterisk.org for more information about
12  * the Asterisk project. Please do not directly contact
13  * any of the maintainers of this project for assistance;
14  * the project provides a web site, mailing lists and IRC
15  * channels for your use.
16  *
17  * This program is free software, distributed under the terms of
18  * the GNU General Public License Version 2. See the LICENSE file
19  * at the top of the source tree.
20  */
21
22 /*!
23  * \page res_config_sqlite
24  *
25  * \section intro_sec Presentation
26  *
27  * res_config_sqlite is a module for the Asterisk Open Source PBX to
28  * support SQLite 2 databases. It can be used to fetch configuration
29  * from a database (static configuration files and/or using the Asterisk
30  * RealTime Architecture - ARA).
31  * It can also be used to log CDR entries. Finally, it can be used for simple
32  * queries in the Dialplan. Note that Asterisk already comes with a module
33  * named cdr_sqlite. There are two reasons for including it in res_config_sqlite:
34  * the first is that rewriting it was a training to learn how to write a
35  * simple module for Asterisk, the other is to have the same database open for
36  * all kinds of operations, which improves reliability and performance.
37  *
38  * There is already a module for SQLite 3 (named res_sqlite3) in the Asterisk
39  * addons. res_config_sqlite was developed because we, at Proformatique, are using
40  * PHP 4 in our embedded systems, and PHP 4 has no stable support for SQLite 3
41  * at this time. We also needed RealTime support.
42  *
43  * \section conf_sec Configuration
44  *
45  * The main configuration file is res_config_sqlite.conf. It must be readable or
46  * res_config_sqlite will fail to start. It is suggested to use the sample file
47  * in this package as a starting point. The file has only one section
48  * named <code>general</code>. Here are the supported parameters :
49  *
50  * <dl>
51  *      <dt><code>dbfile</code></dt>
52  *      <dd>The absolute path to the SQLite database (the file can be non existent,
53  *                      res_config_sqlite will create it if it has the appropriate rights)</dd>
54  *      <dt><code>config_table</code></dt>
55  *      <dd>The table used for static configuration</dd>
56  *      <dt><code>cdr_table</code></dt>
57  *      <dd>The table used to store CDR entries (if ommitted, CDR support is
58  *                      disabled)</dd>
59  * </dl>
60  *
61  * To use res_config_sqlite for static and/or RealTime configuration, refer to the
62  * Asterisk documentation. The file tables.sql can be used to create the
63  * needed tables.
64  *
65  * \section status_sec Driver status
66  *
67  * The CLI command <code>show sqlite status</code> returns status information
68  * about the running driver.
69  *
70  * \section credits_sec Credits
71  *
72  * res_config_sqlite was developed by Richard Braun at the Proformatique company.
73  */
74
75 /*!
76  * \file
77  * \brief res_config_sqlite module.
78  */
79
80 /*** MODULEINFO
81         <depend>sqlite</depend>
82  ***/
83
84 #include "asterisk.h"
85 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
86
87 #include <sqlite.h>
88
89 #include "asterisk/pbx.h"
90 #include "asterisk/cdr.h"
91 #include "asterisk/cli.h"
92 #include "asterisk/lock.h"
93 #include "asterisk/config.h"
94 #include "asterisk/module.h"
95 #include "asterisk/options.h"
96 #include "asterisk/linkedlists.h"
97
98 #define MACRO_BEGIN     do {
99 #define MACRO_END       } while (0)
100
101 #define RES_CONFIG_SQLITE_NAME "res_config_sqlite"
102 #define RES_CONFIG_SQLITE_DRIVER "sqlite"
103 #define RES_CONFIG_SQLITE_DESCRIPTION "Resource Module for SQLite 2"
104 #define RES_CONFIG_SQLITE_CONF_FILE "res_config_sqlite.conf"
105
106 enum {
107         RES_CONFIG_SQLITE_CONFIG_ID,
108         RES_CONFIG_SQLITE_CONFIG_CAT_METRIC,
109         RES_CONFIG_SQLITE_CONFIG_VAR_METRIC,
110         RES_CONFIG_SQLITE_CONFIG_COMMENTED,
111         RES_CONFIG_SQLITE_CONFIG_FILENAME,
112         RES_CONFIG_SQLITE_CONFIG_CATEGORY,
113         RES_CONFIG_SQLITE_CONFIG_VAR_NAME,
114         RES_CONFIG_SQLITE_CONFIG_VAR_VAL,
115         RES_CONFIG_SQLITE_CONFIG_COLUMNS,
116 };
117
118 #define SET_VAR(config, to, from)                       \
119 MACRO_BEGIN                                             \
120         int __error;                                    \
121                                                         \
122         __error = set_var(&to, #to, from->value);       \
123                                                         \
124         if (__error) {                                  \
125                 ast_config_destroy(config);             \
126                 unload_config();                        \
127                 return 1;                               \
128         }                                               \
129 MACRO_END
130
131 /*!
132  * Maximum number of loops before giving up executing a query. Calls to
133  * sqlite_xxx() functions which can return SQLITE_BUSY or SQLITE_LOCKED
134  * are enclosed by RES_CONFIG_SQLITE_BEGIN and RES_CONFIG_SQLITE_END, e.g.
135  * <pre>
136  * char *errormsg;
137  * int error;
138  *
139  * RES_CONFIG_SQLITE_BEGIN
140  *       error = sqlite_exec(db, query, NULL, NULL, &errormsg);
141  * RES_CONFIG_SQLITE_END(error)
142  *
143  * if (error)
144  *       ...;
145  * </pre>
146  */
147 #define RES_CONFIG_SQLITE_MAX_LOOPS 10
148
149 /*!
150  * Macro used before executing a query.
151  *
152  * \see RES_CONFIG_SQLITE_MAX_LOOPS.
153  */
154 #define RES_CONFIG_SQLITE_BEGIN                                         \
155 MACRO_BEGIN                                                             \
156         int __i;                                                        \
157                                                                         \
158         for (__i = 0; __i < RES_CONFIG_SQLITE_MAX_LOOPS; __i++) {
159
160 /*!
161  * Macro used after executing a query.
162  *
163  * \see RES_CONFIG_SQLITE_MAX_LOOPS.
164  */
165 #define RES_CONFIG_SQLITE_END(error)                                    \
166                 if (error != SQLITE_BUSY && error != SQLITE_LOCKED)     \
167                         break;                                          \
168                 usleep(1000);                                           \
169         }                                                               \
170 MACRO_END;
171
172 /*!
173  * Structure sent to the SQLite callback function for static configuration.
174  *
175  * \see add_cfg_entry()
176  */
177 struct cfg_entry_args {
178         struct ast_config *cfg;
179         struct ast_category *cat;
180         char *cat_name;
181         struct ast_flags flags;
182 };
183
184 /*!
185  * Structure sent to the SQLite callback function for RealTime configuration.
186  *
187  * \see add_rt_cfg_entry()
188  */
189 struct rt_cfg_entry_args {
190         struct ast_variable *var;
191         struct ast_variable *last;
192 };
193
194 /*!
195  * Structure sent to the SQLite callback function for RealTime configuration
196  * (realtime_multi_handler()).
197  *
198  * \see add_rt_multi_cfg_entry()
199  */
200 struct rt_multi_cfg_entry_args {
201         struct ast_config *cfg;
202         char *initfield;
203 };
204
205 /*!
206  * \brief Allocate a variable.
207  * \param var the address of the variable to set (it will be allocated)
208  * \param name the name of the variable (for error handling)
209  * \param value the value to store in var
210  * \retval 0 on success
211  * \retval 1 if an allocation error occurred
212  */
213 static int set_var(char **var, const char *name, const char *value);
214
215 /*!
216  * \brief Load the configuration file.
217  * \see unload_config()
218  *
219  * This function sets dbfile, config_table, and cdr_table. It calls
220  * check_vars() before returning, and unload_config() if an error occurred.
221  *
222  * \retval 0 on success
223  * \retval 1 if an error occurred
224  */
225 static int load_config(void);
226
227 /*!
228  * \brief Free resources related to configuration.
229  * \see load_config()
230  */
231 static void unload_config(void);
232
233 /*!
234  * \brief Asterisk callback function for CDR support.
235  * \param cdr the CDR entry Asterisk sends us.
236  *
237  * Asterisk will call this function each time a CDR entry must be logged if
238  * CDR support is enabled.
239  *
240  * \retval 0 on success
241  * \retval 1 if an error occurred
242  */
243 static int cdr_handler(struct ast_cdr *cdr);
244
245 /*!
246  * \brief SQLite callback function for static configuration.
247  *
248  * This function is passed to the SQLite engine as a callback function to
249  * parse a row and store it in a struct ast_config object. It relies on
250  * resulting rows being sorted by category.
251  *
252  * \param arg a pointer to a struct cfg_entry_args object
253  * \param argc number of columns
254  * \param argv values in the row
255  * \param columnNames names and types of the columns
256  * \retval 0 on success
257  * \retval 1 if an error occurred
258  * \see cfg_entry_args
259  * \see sql_get_config_table
260  * \see config_handler()
261  */
262 static int add_cfg_entry(void *arg, int argc, char **argv, char **columnNames);
263
264 /*!
265  * \brief Asterisk callback function for static configuration.
266  *
267  * Asterisk will call this function when it loads its static configuration,
268  * which usually happens at startup and reload.
269  *
270  * \param database the database to use (ignored)
271  * \param table the table to use
272  * \param file the file to load from the database
273  * \param cfg the struct ast_config object to use when storing variables
274  * \param flags Optional flags.  Not used.
275  * \param suggested_incl suggest include.
276  * \retval cfg object
277  * \retval NULL if an error occurred
278  * \see add_cfg_entry()
279  */
280 static struct ast_config * config_handler(const char *database, const char *table, const char *file,
281         struct ast_config *cfg, struct ast_flags flags, const char *suggested_incl);
282
283 /*!
284  * \brief Helper function to parse a va_list object into 2 dynamic arrays of
285  * strings, parameters and values.
286  *
287  * ap must have the following format : param1 val1 param2 val2 param3 val3 ...
288  * arguments will be extracted to create 2 arrays:
289  *
290  * <ul>
291  *      <li>params : param1 param2 param3 ...</li>
292  *      <li>vals : val1 val2 val3 ...</li>
293  * </ul>
294  *
295  * The address of these arrays are stored in params_ptr and vals_ptr. It
296  * is the responsibility of the caller to release the memory of these arrays.
297  * It is considered an error that va_list has a null or odd number of strings.
298  *
299  * \param ap the va_list object to parse
300  * \param params_ptr where the address of the params array is stored
301  * \param vals_ptr where the address of the vals array is stored
302  * \retval the number of elements in the arrays (which have the same size).
303  * \retval 0 if an error occurred.
304  */
305 static size_t get_params(va_list ap, const char ***params_ptr,
306         const char ***vals_ptr);
307
308 /*!
309  * \brief SQLite callback function for RealTime configuration.
310  *
311  * This function is passed to the SQLite engine as a callback function to
312  * parse a row and store it in a linked list of struct ast_variable objects.
313  *
314  * \param arg a pointer to a struct rt_cfg_entry_args object
315  * \param argc number of columns
316  * \param argv values in the row
317  * \param columnNames names and types of the columns
318  * \retval 0 on success.
319  * \retval 1 if an error occurred.
320  * \see rt_cfg_entry_args
321  * \see realtime_handler()
322  */
323 static int add_rt_cfg_entry(void *arg, int argc, char **argv,
324         char **columnNames);
325
326 /*!
327  * Asterisk callback function for RealTime configuration.
328  *
329  * Asterisk will call this function each time it requires a variable
330  * through the RealTime architecture. ap is a list of parameters and
331  * values used to find a specific row, e.g one parameter "name" and
332  * one value "123" so that the SQL query becomes <code>SELECT * FROM
333  * table WHERE name = '123';</code>.
334  *
335  * \param database the database to use (ignored)
336  * \param table the table to use
337  * \param ap list of parameters and values to match
338  *
339  * \retval a linked list of struct ast_variable objects
340  * \retval NULL if an error occurred
341  * \see add_rt_cfg_entry()
342  */
343 static struct ast_variable * realtime_handler(const char *database,
344         const char *table, va_list ap);
345
346 /*!
347  * \brief SQLite callback function for RealTime configuration.
348  *
349  * This function performs the same actions as add_rt_cfg_entry() except
350  * that the rt_multi_cfg_entry_args structure is designed to store
351  * categories in addition to variables.
352  *
353  * \param arg a pointer to a struct rt_multi_cfg_entry_args object
354  * \param argc number of columns
355  * \param argv values in the row
356  * \param columnNames names and types of the columns
357  * \retval 0 on success.
358  * \retval 1 if an error occurred.
359  * \see rt_multi_cfg_entry_args
360  * \see realtime_multi_handler()
361  */
362 static int add_rt_multi_cfg_entry(void *arg, int argc, char **argv,
363         char **columnNames);
364
365 /*!
366  * \brief Asterisk callback function for RealTime configuration.
367  *
368  * This function performs the same actions as realtime_handler() except
369  * that it can store variables per category, and can return several
370  * categories.
371  *
372  * \param database the database to use (ignored)
373  * \param table the table to use
374  * \param ap list of parameters and values to match
375  * \retval a struct ast_config object storing categories and variables.
376  * \retval NULL if an error occurred.
377  *
378  * \see add_rt_multi_cfg_entry()
379  */
380 static struct ast_config * realtime_multi_handler(const char *database,
381         const char *table, va_list ap);
382
383 /*!
384  * \brief Asterisk callback function for RealTime configuration (variable
385  * update).
386  *
387  * Asterisk will call this function each time a variable has been modified
388  * internally and must be updated in the backend engine. keyfield and entity
389  * are used to find the row to update, e.g. <code>UPDATE table SET ... WHERE
390  * keyfield = 'entity';</code>. ap is a list of parameters and values with the
391  * same format as the other realtime functions.
392  *
393  * \param database the database to use (ignored)
394  * \param table the table to use
395  * \param keyfield the column of the matching cell
396  * \param entity the value of the matching cell
397  * \param ap list of parameters and new values to update in the database
398  * \retval the number of affected rows.
399  * \retval -1 if an error occurred.
400  */
401 static int realtime_update_handler(const char *database, const char *table,
402         const char *keyfield, const char *entity, va_list ap);
403
404 /*!
405  * \brief Asterisk callback function for RealTime configuration (variable
406  * create/store).
407  *
408  * Asterisk will call this function each time a variable has been created
409  * internally and must be stored in the backend engine.
410  * are used to find the row to update, e.g. ap is a list of parameters and
411  * values with the same format as the other realtime functions.
412  *
413  * \param database the database to use (ignored)
414  * \param table the table to use
415  * \param ap list of parameters and new values to insert into the database
416  * \retval the rowid of inserted row.
417  * \retval -1 if an error occurred.
418  */
419 static int realtime_store_handler(const char *database, const char *table,
420         va_list ap);
421
422 /*!
423  * \brief Asterisk callback function for RealTime configuration (destroys
424  * variable).
425  *
426  * Asterisk will call this function each time a variable has been destroyed
427  * internally and must be removed from the backend engine. keyfield and entity
428  * are used to find the row to delete, e.g. <code>DELETE FROM table WHERE
429  * keyfield = 'entity';</code>. ap is a list of parameters and values with the
430  * same format as the other realtime functions.
431  *
432  * \param database the database to use (ignored)
433  * \param table the table to use
434  * \param keyfield the column of the matching cell
435  * \param entity the value of the matching cell
436  * \param ap list of additional parameters for cell matching
437  * \retval the number of affected rows.
438  * \retval -1 if an error occurred.
439  */
440 static int realtime_destroy_handler(const char *database, const char *table,
441         const char *keyfield, const char *entity, va_list ap);
442
443 /*!
444  * \brief Asterisk callback function for the CLI status command.
445  *
446  * \param e CLI command
447  * \param cmd 
448  * \param a CLI argument list
449  * \return RESULT_SUCCESS
450  */
451 static char *handle_cli_show_sqlite_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a);
452
453 /*! The SQLite database object. */
454 static sqlite *db;
455
456 /*! Set to 1 if CDR support is enabled. */
457 static int use_cdr;
458
459 /*! Set to 1 if the CDR callback function was registered. */
460 static int cdr_registered;
461
462 /*! Set to 1 if the CLI status command callback function was registered. */
463 static int cli_status_registered;
464
465 /*! The path of the database file. */
466 static char *dbfile;
467
468 /*! The name of the static configuration table. */
469 static char *config_table;
470
471 /*! The name of the table used to store CDR entries. */
472 static char *cdr_table;
473
474 /*!
475  * The structure specifying all callback functions used by Asterisk for static
476  * and RealTime configuration.
477  */
478 static struct ast_config_engine sqlite_engine =
479 {
480         .name = RES_CONFIG_SQLITE_DRIVER,
481         .load_func = config_handler,
482         .realtime_func = realtime_handler,
483         .realtime_multi_func = realtime_multi_handler,
484         .store_func = realtime_store_handler,
485         .destroy_func = realtime_destroy_handler,
486         .update_func = realtime_update_handler
487 };
488
489 /*!
490  * The mutex used to prevent simultaneous access to the SQLite database.
491  */
492 AST_MUTEX_DEFINE_STATIC(mutex);
493
494 /*!
495  * Structure containing details and callback functions for the CLI status
496  * command.
497  */
498 static struct ast_cli_entry cli_status[] = {
499         AST_CLI_DEFINE(handle_cli_show_sqlite_status, "Show status information about the SQLite 2 driver"),
500 };
501
502 /*
503  * Taken from Asterisk 1.2 cdr_sqlite.so.
504  */
505
506 /*! SQL query format to create the CDR table if non existent. */
507 static char *sql_create_cdr_table =
508 "CREATE TABLE '%q' (\n"
509 "       id              INTEGER,\n"
510 "       clid            VARCHAR(80)     NOT NULL        DEFAULT '',\n"
511 "       src             VARCHAR(80)     NOT NULL        DEFAULT '',\n"
512 "       dst             VARCHAR(80)     NOT NULL        DEFAULT '',\n"
513 "       dcontext        VARCHAR(80)     NOT NULL        DEFAULT '',\n"
514 "       channel         VARCHAR(80)     NOT NULL        DEFAULT '',\n"
515 "       dstchannel      VARCHAR(80)     NOT NULL        DEFAULT '',\n"
516 "       lastapp         VARCHAR(80)     NOT NULL        DEFAULT '',\n"
517 "       lastdata        VARCHAR(80)     NOT NULL        DEFAULT '',\n"
518 "       start           DATETIME        NOT NULL        DEFAULT '0000-00-00 00:00:00',\n"
519 "       answer          DATETIME        NOT NULL        DEFAULT '0000-00-00 00:00:00',\n"
520 "       end             DATETIME        NOT NULL        DEFAULT '0000-00-00 00:00:00',\n"
521 "       duration        INT(11)         NOT NULL        DEFAULT 0,\n"
522 "       billsec         INT(11)         NOT NULL        DEFAULT 0,\n"
523 "       disposition     VARCHAR(45)     NOT NULL        DEFAULT '',\n"
524 "       amaflags        INT(11)         NOT NULL        DEFAULT 0,\n"
525 "       accountcode     VARCHAR(20)     NOT NULL        DEFAULT '',\n"
526 "       uniqueid        VARCHAR(32)     NOT NULL        DEFAULT '',\n"
527 "       userfield       VARCHAR(255)    NOT NULL        DEFAULT '',\n"
528 "       PRIMARY KEY     (id)\n"
529 ");";
530
531 /*! SQL query format to insert a CDR entry. */
532 static char *sql_add_cdr_entry =
533 "INSERT INTO '%q' ("
534 "       clid,"
535 "       src,"
536 "       dst,"
537 "       dcontext,"
538 "       channel,"
539 "       dstchannel,"
540 "       lastapp,"
541 "       lastdata,"
542 "       start,"
543 "       answer,"
544 "       end,"
545 "       duration,"
546 "       billsec,"
547 "       disposition,"
548 "       amaflags,"
549 "       accountcode,"
550 "       uniqueid,"
551 "       userfield"
552 ") VALUES ("
553 "       '%q',"
554 "       '%q',"
555 "       '%q',"
556 "       '%q',"
557 "       '%q',"
558 "       '%q',"
559 "       '%q',"
560 "       '%q',"
561 "       datetime(%d,'unixepoch'),"
562 "       datetime(%d,'unixepoch'),"
563 "       datetime(%d,'unixepoch'),"
564 "       '%ld',"
565 "       '%ld',"
566 "       '%ld',"
567 "       '%ld',"
568 "       '%q',"
569 "       '%q',"
570 "       '%q'"
571 ");";
572
573 /*!
574  * SQL query format to fetch the static configuration of a file.
575  * Rows must be sorted by category.
576  *
577  * \see add_cfg_entry()
578  */
579 static char *sql_get_config_table =
580 "SELECT *"
581 "       FROM '%q'"
582 "       WHERE filename = '%q' AND commented = 0"
583 "       ORDER BY cat_metric ASC, var_metric ASC;";
584
585 static int set_var(char **var, const char *name, const char *value)
586 {
587         if (*var)
588                 ast_free(*var);
589
590         *var = ast_strdup(value);
591
592         if (!*var) {
593                 ast_log(LOG_WARNING, "Unable to allocate variable %s\n", name);
594                 return 1;
595         }
596
597         return 0;
598 }
599
600 static int check_vars(void)
601 {
602         if (!dbfile) {
603                 ast_log(LOG_ERROR, "Undefined parameter %s\n", dbfile);
604                 return 1;
605         }
606
607         use_cdr = (cdr_table != NULL);
608
609         return 0;
610 }
611
612 static int load_config(void)
613 {
614         struct ast_config *config;
615         struct ast_variable *var;
616         int error;
617         struct ast_flags config_flags = { 0 };
618
619         config = ast_config_load(RES_CONFIG_SQLITE_CONF_FILE, config_flags);
620
621         if (!config) {
622                 ast_log(LOG_ERROR, "Unable to load " RES_CONFIG_SQLITE_CONF_FILE "\n");
623                 return 1;
624         }
625
626         for (var = ast_variable_browse(config, "general"); var; var = var->next) {
627                 if (!strcasecmp(var->name, "dbfile"))
628                         SET_VAR(config, dbfile, var);
629                 else if (!strcasecmp(var->name, "config_table"))
630                         SET_VAR(config, config_table, var);
631                 else if (!strcasecmp(var->name, "cdr_table"))
632                         SET_VAR(config, cdr_table, var);
633                 else
634                         ast_log(LOG_WARNING, "Unknown parameter : %s\n", var->name);
635         }
636
637         ast_config_destroy(config);
638         error = check_vars();
639
640         if (error) {
641                 unload_config();
642                 return 1;
643         }
644
645         return 0;
646 }
647
648 static void unload_config(void)
649 {
650         ast_free(dbfile);
651         dbfile = NULL;
652         ast_free(config_table);
653         config_table = NULL;
654         ast_free(cdr_table);
655         cdr_table = NULL;
656 }
657
658 static int cdr_handler(struct ast_cdr *cdr)
659 {
660         char *query, *errormsg;
661         int error;
662
663         query = sqlite_mprintf(sql_add_cdr_entry, cdr_table, cdr->clid,
664                         cdr->src, cdr->dst, cdr->dcontext, cdr->channel,
665                         cdr->dstchannel, cdr->lastapp, cdr->lastdata,
666                         cdr->start.tv_sec, cdr->answer.tv_sec,
667                         cdr->end.tv_sec, cdr->duration, cdr->billsec,
668                         cdr->disposition, cdr->amaflags, cdr->accountcode,
669                         cdr->uniqueid, cdr->userfield);
670
671         if (!query) {
672                 ast_log(LOG_WARNING, "Unable to allocate SQL query\n");
673                 return 1;
674         }
675
676         ast_debug(1, "SQL query: %s\n", query);
677
678         ast_mutex_lock(&mutex);
679
680         RES_CONFIG_SQLITE_BEGIN
681                 error = sqlite_exec(db, query, NULL, NULL, &errormsg);
682         RES_CONFIG_SQLITE_END(error)
683
684         ast_mutex_unlock(&mutex);
685
686         sqlite_freemem(query);
687
688         if (error) {
689                 ast_log(LOG_ERROR, "%s\n", errormsg);
690                 sqlite_freemem(errormsg);
691                 return 1;
692         }
693
694         return 0;
695 }
696
697 static int add_cfg_entry(void *arg, int argc, char **argv, char **columnNames)
698 {
699         struct cfg_entry_args *args;
700         struct ast_variable *var;
701
702         if (argc != RES_CONFIG_SQLITE_CONFIG_COLUMNS) {
703                 ast_log(LOG_WARNING, "Corrupt table\n");
704                 return 1;
705         }
706
707         args = arg;
708
709         if (!strcmp(argv[RES_CONFIG_SQLITE_CONFIG_VAR_NAME], "#include")) {
710                 struct ast_config *cfg;
711                 char *val;
712
713                 val = argv[RES_CONFIG_SQLITE_CONFIG_VAR_VAL];
714                 cfg = ast_config_internal_load(val, args->cfg, args->flags, "");
715
716                 if (!cfg) {
717                         ast_log(LOG_WARNING, "Unable to include %s\n", val);
718                         return 1;
719                 } else {
720                         args->cfg = cfg;
721                         return 0;
722                 }
723         }
724
725         if (!args->cat_name || strcmp(args->cat_name, argv[RES_CONFIG_SQLITE_CONFIG_CATEGORY])) {
726                 args->cat = ast_category_new(argv[RES_CONFIG_SQLITE_CONFIG_CATEGORY], "", 99999);
727
728                 if (!args->cat) {
729                         ast_log(LOG_WARNING, "Unable to allocate category\n");
730                         return 1;
731                 }
732
733                 ast_free(args->cat_name);
734                 args->cat_name = ast_strdup(argv[RES_CONFIG_SQLITE_CONFIG_CATEGORY]);
735
736                 if (!args->cat_name) {
737                         ast_category_destroy(args->cat);
738                         return 1;
739                 }
740
741                 ast_category_append(args->cfg, args->cat);
742         }
743
744         var = ast_variable_new(argv[RES_CONFIG_SQLITE_CONFIG_VAR_NAME], argv[RES_CONFIG_SQLITE_CONFIG_VAR_VAL], "");
745
746         if (!var) {
747                 ast_log(LOG_WARNING, "Unable to allocate variable");
748                 return 1;
749         }
750
751         ast_variable_append(args->cat, var);
752
753         return 0;
754 }
755
756 static struct ast_config *config_handler(const char *database,  const char *table, const char *file,
757         struct ast_config *cfg, struct ast_flags flags, const char *suggested_incl)
758 {
759         struct cfg_entry_args args;
760         char *query, *errormsg;
761         int error;
762
763         if (!config_table) {
764                 if (!table) {
765                         ast_log(LOG_ERROR, "Table name unspecified\n");
766                         return NULL;
767                 }
768         } else
769                 table = config_table;
770
771         query = sqlite_mprintf(sql_get_config_table, table, file);
772
773         if (!query) {
774                 ast_log(LOG_WARNING, "Unable to allocate SQL query\n");
775                 return NULL;
776         }
777
778         ast_debug(1, "SQL query: %s\n", query);
779         args.cfg = cfg;
780         args.cat = NULL;
781         args.cat_name = NULL;
782         args.flags = flags;
783
784         ast_mutex_lock(&mutex);
785
786         RES_CONFIG_SQLITE_BEGIN
787                 error = sqlite_exec(db, query, add_cfg_entry, &args, &errormsg);
788         RES_CONFIG_SQLITE_END(error)
789
790         ast_mutex_unlock(&mutex);
791
792         ast_free(args.cat_name);
793         sqlite_freemem(query);
794
795         if (error) {
796                 ast_log(LOG_ERROR, "%s\n", errormsg);
797                 sqlite_freemem(errormsg);
798                 return NULL;
799         }
800
801         return cfg;
802 }
803
804 static size_t get_params(va_list ap, const char ***params_ptr, const char ***vals_ptr)
805 {
806         const char **tmp, *param, *val, **params, **vals;
807         size_t params_count;
808
809         params = NULL;
810         vals = NULL;
811         params_count = 0;
812
813         while ((param = va_arg(ap, const char *)) && (val = va_arg(ap, const char *))) {
814                 if (!(tmp = ast_realloc(params, (params_count + 1) * sizeof(char *)))) {
815                         ast_free(params);
816                         ast_free(vals);
817                         return 0;
818                 }
819                 params = tmp;
820
821                 if (!(tmp = ast_realloc(vals, (params_count + 1) * sizeof(char *)))) {
822                         ast_free(params);
823                         ast_free(vals);
824                         return 0;
825                 }
826                 vals = tmp;
827
828                 params[params_count] = param;
829                 vals[params_count] = val;
830                 params_count++;
831         }
832
833         if (params_count > 0) {
834                 *params_ptr = params;
835                 *vals_ptr = vals;
836         } else
837                 ast_log(LOG_WARNING, "1 parameter and 1 value at least required\n");
838
839         return params_count;
840 }
841
842 static int add_rt_cfg_entry(void *arg, int argc, char **argv, char **columnNames)
843 {
844         struct rt_cfg_entry_args *args;
845         struct ast_variable *var;
846         int i;
847
848         args = arg;
849
850         for (i = 0; i < argc; i++) {
851                 if (!argv[i])
852                         continue;
853
854                 if (!(var = ast_variable_new(columnNames[i], argv[i], "")))
855                         return 1;
856
857                 if (!args->var)
858                         args->var = var;
859
860                 if (!args->last)
861                         args->last = var;
862                 else {
863                         args->last->next = var;
864                         args->last = var;
865                 }
866         }
867
868         return 0;
869 }
870
871 static struct ast_variable * realtime_handler(const char *database, const char *table, va_list ap)
872 {
873         char *query, *errormsg, *op, *tmp_str;
874         struct rt_cfg_entry_args args;
875         const char **params, **vals;
876         size_t params_count;
877         int error;
878
879         if (!table) {
880                 ast_log(LOG_WARNING, "Table name unspecified\n");
881                 return NULL;
882         }
883
884         params_count = get_params(ap, &params, &vals);
885
886         if (params_count == 0)
887                 return NULL;
888
889         op = (strchr(params[0], ' ') == NULL) ? " =" : "";
890
891 /* \cond DOXYGEN_CAN_PARSE_THIS */
892 #undef QUERY
893 #define QUERY "SELECT * FROM '%q' WHERE commented = 0 AND %q%s '%q'"
894 /* \endcond */
895
896         query = sqlite_mprintf(QUERY, table, params[0], op, vals[0]);
897
898         if (!query) {
899                 ast_log(LOG_WARNING, "Unable to allocate SQL query\n");
900                 ast_free(params);
901                 ast_free(vals);
902                 return NULL;
903         }
904
905         if (params_count > 1) {
906                 size_t i;
907
908                 for (i = 1; i < params_count; i++) {
909                         op = (strchr(params[i], ' ') == NULL) ? " =" : "";
910                         tmp_str = sqlite_mprintf("%s AND %q%s '%q'", query, params[i], op, vals[i]);
911                         sqlite_freemem(query);
912
913                         if (!tmp_str) {
914                                 ast_log(LOG_WARNING, "Unable to reallocate SQL query\n");
915                                 ast_free(params);
916                                 ast_free(vals);
917                                 return NULL;
918                         }
919
920                         query = tmp_str;
921                 }
922         }
923
924         ast_free(params);
925         ast_free(vals);
926
927         tmp_str = sqlite_mprintf("%s LIMIT 1;", query);
928         sqlite_freemem(query);
929
930         if (!tmp_str) {
931                 ast_log(LOG_WARNING, "Unable to reallocate SQL query\n");
932                 return NULL;
933         }
934
935         query = tmp_str;
936         ast_debug(1, "SQL query: %s\n", query);
937         args.var = NULL;
938         args.last = NULL;
939
940         ast_mutex_lock(&mutex);
941
942         RES_CONFIG_SQLITE_BEGIN
943                 error = sqlite_exec(db, query, add_rt_cfg_entry, &args, &errormsg);
944         RES_CONFIG_SQLITE_END(error)
945
946         ast_mutex_unlock(&mutex);
947
948         sqlite_freemem(query);
949
950         if (error) {
951                 ast_log(LOG_WARNING, "%s\n", errormsg);
952                 sqlite_freemem(errormsg);
953                 ast_variables_destroy(args.var);
954                 return NULL;
955         }
956
957         return args.var;
958 }
959
960 static int add_rt_multi_cfg_entry(void *arg, int argc, char **argv, char **columnNames)
961 {
962         struct rt_multi_cfg_entry_args *args;
963         struct ast_category *cat;
964         struct ast_variable *var;
965         char *cat_name;
966         size_t i;
967
968         args = arg;
969         cat_name = NULL;
970
971         /*
972          * cat_name should always be set here, since initfield is forged from
973          * params[0] in realtime_multi_handler(), which is a search parameter
974          * of the SQL query.
975          */
976         for (i = 0; i < argc; i++) {
977                 if (!strcmp(args->initfield, columnNames[i]))
978                         cat_name = argv[i];
979         }
980
981         if (!cat_name) {
982                 ast_log(LOG_ERROR, "Bogus SQL results, cat_name is NULL !\n");
983                 return 1;
984         }
985
986         if (!(cat = ast_category_new(cat_name, "", 99999))) {
987                 ast_log(LOG_WARNING, "Unable to allocate category\n");
988                 return 1;
989         }
990
991         ast_category_append(args->cfg, cat);
992
993         for (i = 0; i < argc; i++) {
994                 if (!argv[i] || !strcmp(args->initfield, columnNames[i]))
995                         continue;
996
997                 if (!(var = ast_variable_new(columnNames[i], argv[i], ""))) {
998                         ast_log(LOG_WARNING, "Unable to allocate variable\n");
999                         return 1;
1000                 }
1001
1002                 ast_variable_append(cat, var);
1003         }
1004
1005         return 0;
1006 }
1007
1008 static struct ast_config *realtime_multi_handler(const char *database,
1009         const char *table, va_list ap)
1010 {
1011         char *query, *errormsg, *op, *tmp_str, *initfield;
1012         struct rt_multi_cfg_entry_args args;
1013         const char **params, **vals;
1014         struct ast_config *cfg;
1015         size_t params_count;
1016         int error;
1017
1018         if (!table) {
1019                 ast_log(LOG_WARNING, "Table name unspecified\n");
1020                 return NULL;
1021         }
1022
1023         if (!(cfg = ast_config_new())) {
1024                 ast_log(LOG_WARNING, "Unable to allocate configuration structure\n");
1025                 return NULL;
1026         }
1027
1028         if (!(params_count = get_params(ap, &params, &vals))) {
1029                 ast_config_destroy(cfg);
1030                 return NULL;
1031         }
1032
1033         if (!(initfield = ast_strdup(params[0]))) {
1034                 ast_config_destroy(cfg);
1035                 ast_free(params);
1036                 ast_free(vals);
1037                 return NULL;
1038         }
1039
1040         tmp_str = strchr(initfield, ' ');
1041
1042         if (tmp_str)
1043                 *tmp_str = '\0';
1044
1045         op = (!strchr(params[0], ' ')) ? " =" : "";
1046
1047         /*
1048          * Asterisk sends us an already escaped string when searching for
1049          * "exten LIKE" (uh!). Handle it separately.
1050          */
1051         tmp_str = (!strcmp(vals[0], "\\_%")) ? "_%" : (char *)vals[0];
1052
1053 /* \cond DOXYGEN_CAN_PARSE_THIS */
1054 #undef QUERY
1055 #define QUERY "SELECT * FROM '%q' WHERE commented = 0 AND %q%s '%q'"
1056 /* \endcond */
1057
1058         if (!(query = sqlite_mprintf(QUERY, table, params[0], op, tmp_str))) {
1059                 ast_log(LOG_WARNING, "Unable to allocate SQL query\n");
1060                 ast_config_destroy(cfg);
1061                 ast_free(params);
1062                 ast_free(vals);
1063                 ast_free(initfield);
1064                 return NULL;
1065         }
1066
1067         if (params_count > 1) {
1068                 size_t i;
1069
1070                 for (i = 1; i < params_count; i++) {
1071                         op = (!strchr(params[i], ' ')) ? " =" : "";
1072                         tmp_str = sqlite_mprintf("%s AND %q%s '%q'", query, params[i], op, vals[i]);
1073                         sqlite_freemem(query);
1074
1075                         if (!tmp_str) {
1076                                 ast_log(LOG_WARNING, "Unable to reallocate SQL query\n");
1077                                 ast_config_destroy(cfg);
1078                                 ast_free(params);
1079                                 ast_free(vals);
1080                                 ast_free(initfield);
1081                                 return NULL;
1082                         }
1083
1084                         query = tmp_str;
1085                 }
1086         }
1087
1088         ast_free(params);
1089         ast_free(vals);
1090
1091         if (!(tmp_str = sqlite_mprintf("%s ORDER BY %q;", query, initfield))) {
1092                 ast_log(LOG_WARNING, "Unable to reallocate SQL query\n");
1093                 ast_config_destroy(cfg);
1094                 ast_free(initfield);
1095                 return NULL;
1096         }
1097
1098         sqlite_freemem(query);
1099         query = tmp_str;
1100         ast_debug(1, "SQL query: %s\n", query);
1101         args.cfg = cfg;
1102         args.initfield = initfield;
1103
1104         ast_mutex_lock(&mutex);
1105
1106         RES_CONFIG_SQLITE_BEGIN
1107                 error = sqlite_exec(db, query, add_rt_multi_cfg_entry, &args, &errormsg);
1108         RES_CONFIG_SQLITE_END(error)
1109
1110         ast_mutex_unlock(&mutex);
1111
1112         sqlite_freemem(query);
1113         ast_free(initfield);
1114
1115         if (error) {
1116                 ast_log(LOG_WARNING, "%s\n", errormsg);
1117                 sqlite_freemem(errormsg);
1118                 ast_config_destroy(cfg);
1119                 return NULL;
1120         }
1121
1122         return cfg;
1123 }
1124
1125 static int realtime_update_handler(const char *database, const char *table,
1126         const char *keyfield, const char *entity, va_list ap)
1127 {
1128         char *query, *errormsg, *tmp_str;
1129         const char **params, **vals;
1130         size_t params_count;
1131         int error, rows_num;
1132
1133         if (!table) {
1134                 ast_log(LOG_WARNING, "Table name unspecified\n");
1135                 return -1;
1136         }
1137
1138         if (!(params_count = get_params(ap, &params, &vals)))
1139                 return -1;
1140
1141 /* \cond DOXYGEN_CAN_PARSE_THIS */
1142 #undef QUERY
1143 #define QUERY "UPDATE '%q' SET %q = '%q'"
1144 /* \endcond */
1145
1146         if (!(query = sqlite_mprintf(QUERY, table, params[0], vals[0]))) {
1147                 ast_log(LOG_WARNING, "Unable to allocate SQL query\n");
1148                 ast_free(params);
1149                 ast_free(vals);
1150                 return -1;
1151         }
1152
1153         if (params_count > 1) {
1154                 size_t i;
1155
1156                 for (i = 1; i < params_count; i++) {
1157                         tmp_str = sqlite_mprintf("%s, %q = '%q'", query, params[i], vals[i]);
1158                         sqlite_freemem(query);
1159
1160                         if (!tmp_str) {
1161                                 ast_log(LOG_WARNING, "Unable to reallocate SQL query\n");
1162                                 ast_free(params);
1163                                 ast_free(vals);
1164                                 return -1;
1165                         }
1166
1167                         query = tmp_str;
1168                 }
1169         }
1170
1171         ast_free(params);
1172         ast_free(vals);
1173
1174         if (!(tmp_str = sqlite_mprintf("%s WHERE %q = '%q';", query, keyfield, entity))) {
1175                 ast_log(LOG_WARNING, "Unable to reallocate SQL query\n");
1176                 return -1;
1177         }
1178
1179         sqlite_freemem(query);
1180         query = tmp_str;
1181         ast_debug(1, "SQL query: %s\n", query);
1182
1183         ast_mutex_lock(&mutex);
1184
1185         RES_CONFIG_SQLITE_BEGIN
1186                 error = sqlite_exec(db, query, NULL, NULL, &errormsg);
1187         RES_CONFIG_SQLITE_END(error)
1188
1189         if (!error)
1190                 rows_num = sqlite_changes(db);
1191         else
1192                 rows_num = -1;
1193
1194         ast_mutex_unlock(&mutex);
1195
1196         sqlite_freemem(query);
1197
1198         if (error) {
1199                 ast_log(LOG_WARNING, "%s\n", errormsg);
1200                 sqlite_freemem(errormsg);
1201         }
1202
1203         return rows_num;
1204 }
1205
1206 static int realtime_store_handler(const char *database, const char *table, va_list ap) {
1207         char *errormsg, *tmp_str, *tmp_keys, *tmp_keys2, *tmp_vals, *tmp_vals2;
1208         const char **params, **vals;
1209         size_t params_count;
1210         int error, rows_id;
1211         size_t i;
1212
1213         if (!table) {
1214                 ast_log(LOG_WARNING, "Table name unspecified\n");
1215                 return -1;
1216         }
1217
1218         if (!(params_count = get_params(ap, &params, &vals)))
1219                 return -1;
1220
1221 /* \cond DOXYGEN_CAN_PARSE_THIS */
1222 #undef QUERY
1223 #define QUERY "INSERT into '%q' (%s) VALUES (%s);"
1224 /* \endcond */
1225
1226         tmp_keys2 = NULL;
1227         tmp_vals2 = NULL;
1228         for (i = 0; i < params_count; i++) {
1229                 if ( tmp_keys2 ) {
1230                         tmp_keys = sqlite_mprintf("%s, %q", tmp_keys2, params[i]);
1231                         sqlite_freemem(tmp_keys2);
1232                 } else {
1233                         tmp_keys = sqlite_mprintf("%q", params[i]);
1234                 }
1235                 if (!tmp_keys) {
1236                         ast_log(LOG_WARNING, "Unable to reallocate SQL query\n");
1237                         ast_free(params);
1238                         ast_free(vals);
1239                         return -1;
1240                 }
1241
1242                 if ( tmp_vals2 ) {
1243                         tmp_vals = sqlite_mprintf("%s, '%q'", tmp_vals2, params[i]);
1244                         sqlite_freemem(tmp_vals2);
1245                 } else {
1246                         tmp_vals = sqlite_mprintf("'%q'", params[i]);
1247                 }
1248                 if (!tmp_vals) {
1249                         ast_log(LOG_WARNING, "Unable to reallocate SQL query\n");
1250                         ast_free(params);
1251                         ast_free(vals);
1252                         return -1;
1253                 }
1254
1255
1256                 tmp_keys2 = tmp_keys;
1257                 tmp_vals2 = tmp_vals;
1258         }
1259
1260         ast_free(params);
1261         ast_free(vals);
1262
1263         if (!(tmp_str = sqlite_mprintf(QUERY, table, tmp_keys, tmp_vals))) {
1264                 ast_log(LOG_WARNING, "Unable to reallocate SQL query\n");
1265                 return -1;
1266         }
1267
1268         sqlite_freemem(tmp_keys);
1269         sqlite_freemem(tmp_vals);
1270
1271         ast_debug(1, "SQL query: %s\n", tmp_str);
1272
1273         ast_mutex_lock(&mutex);
1274
1275         RES_CONFIG_SQLITE_BEGIN
1276                 error = sqlite_exec(db, tmp_str, NULL, NULL, &errormsg);
1277         RES_CONFIG_SQLITE_END(error)
1278
1279         if (!error) {
1280                 rows_id = sqlite_last_insert_rowid(db);
1281         } else {
1282                 rows_id = -1;
1283         }
1284
1285         ast_mutex_unlock(&mutex);
1286
1287         sqlite_freemem(tmp_str);
1288
1289         if (error) {
1290                 ast_log(LOG_WARNING, "%s\n", errormsg);
1291                 sqlite_freemem(errormsg);
1292         }
1293
1294         return rows_id;
1295 }
1296
1297 static int realtime_destroy_handler(const char *database, const char *table,
1298         const char *keyfield, const char *entity, va_list ap)
1299 {
1300         char *query, *errormsg, *tmp_str;
1301         const char **params, **vals;
1302         size_t params_count;
1303         int error, rows_num;
1304         size_t i;
1305
1306         if (!table) {
1307                 ast_log(LOG_WARNING, "Table name unspecified\n");
1308                 return -1;
1309         }
1310
1311         if (!(params_count = get_params(ap, &params, &vals)))
1312                 return -1;
1313
1314 /* \cond DOXYGEN_CAN_PARSE_THIS */
1315 #undef QUERY
1316 #define QUERY "DELETE FROM '%q' WHERE"
1317 /* \endcond */
1318
1319         if (!(query = sqlite_mprintf(QUERY, table))) {
1320                 ast_log(LOG_WARNING, "Unable to allocate SQL query\n");
1321                 ast_free(params);
1322                 ast_free(vals);
1323                 return -1;
1324         }
1325
1326         for (i = 0; i < params_count; i++) {
1327                 tmp_str = sqlite_mprintf("%s %q = '%q' AND", query, params[i], vals[i]);
1328                 sqlite_freemem(query);
1329
1330                 if (!tmp_str) {
1331                         ast_log(LOG_WARNING, "Unable to reallocate SQL query\n");
1332                         ast_free(params);
1333                         ast_free(vals);
1334                         return -1;
1335                 }
1336
1337                 query = tmp_str;
1338         }
1339
1340         ast_free(params);
1341         ast_free(vals);
1342         if (!(tmp_str = sqlite_mprintf("%s %q = '%q';", query, keyfield, entity))) {
1343                 ast_log(LOG_WARNING, "Unable to reallocate SQL query\n");
1344                 return -1;
1345         }
1346         sqlite_freemem(query);
1347         query = tmp_str;
1348         ast_debug(1, "SQL query: %s\n", query);
1349
1350         ast_mutex_lock(&mutex);
1351
1352         RES_CONFIG_SQLITE_BEGIN
1353                 error = sqlite_exec(db, query, NULL, NULL, &errormsg);
1354         RES_CONFIG_SQLITE_END(error)
1355
1356         if (!error)
1357                 rows_num = sqlite_changes(db);
1358         else
1359                 rows_num = -1;
1360
1361         ast_mutex_unlock(&mutex);
1362
1363         sqlite_freemem(query);
1364
1365         if (error) {
1366                 ast_log(LOG_WARNING, "%s\n", errormsg);
1367                 sqlite_freemem(errormsg);
1368         }
1369
1370         return rows_num;
1371 }
1372
1373 static char *handle_cli_show_sqlite_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1374 {
1375         switch (cmd) {
1376         case CLI_INIT:
1377                 e->command = "show sqlite status";
1378                 e->usage =
1379                         "Usage: show sqlite status\n"
1380                         "       Show status information about the SQLite 2 driver\n";
1381                 return NULL;
1382         case CLI_GENERATE:
1383                 return NULL;
1384         }
1385
1386         if (a->argc != 3)
1387                 return CLI_SHOWUSAGE;
1388
1389         ast_cli(a->fd, "SQLite database path: %s\n", dbfile);
1390         ast_cli(a->fd, "config_table: ");
1391
1392         if (!config_table)
1393                 ast_cli(a->fd, "unspecified, must be present in extconfig.conf\n");
1394         else
1395                 ast_cli(a->fd, "%s\n", config_table);
1396
1397         ast_cli(a->fd, "cdr_table: ");
1398
1399         if (!cdr_table)
1400                 ast_cli(a->fd, "unspecified, CDR support disabled\n");
1401         else
1402                 ast_cli(a->fd, "%s\n", cdr_table);
1403
1404         return CLI_SUCCESS;
1405 }
1406
1407 static int unload_module(void)
1408 {
1409         if (cli_status_registered)
1410                 ast_cli_unregister_multiple(cli_status, sizeof(cli_status) / sizeof(struct ast_cli_entry));
1411
1412         if (cdr_registered)
1413                 ast_cdr_unregister(RES_CONFIG_SQLITE_NAME);
1414
1415         ast_config_engine_deregister(&sqlite_engine);
1416
1417         if (db)
1418                 sqlite_close(db);
1419
1420         unload_config();
1421
1422         return 0;
1423 }
1424
1425 static int load_module(void)
1426 {
1427         char *errormsg;
1428         int error;
1429
1430         db = NULL;
1431         cdr_registered = 0;
1432         cli_status_registered = 0;
1433         dbfile = NULL;
1434         config_table = NULL;
1435         cdr_table = NULL;
1436         error = load_config();
1437
1438         if (error)
1439                 return AST_MODULE_LOAD_DECLINE;
1440
1441         if (!(db = sqlite_open(dbfile, 0660, &errormsg))) {
1442                 ast_log(LOG_ERROR, "%s\n", errormsg);
1443                 sqlite_freemem(errormsg);
1444                 unload_module();
1445                 return 1;
1446         }
1447
1448         ast_config_engine_register(&sqlite_engine);
1449
1450         if (use_cdr) {
1451                 char *query;
1452
1453 /* \cond DOXYGEN_CAN_PARSE_THIS */
1454 #undef QUERY
1455 #define QUERY "SELECT COUNT(id) FROM %Q;"
1456 /* \endcond */
1457
1458                 query = sqlite_mprintf(QUERY, cdr_table);
1459
1460                 if (!query) {
1461                         ast_log(LOG_ERROR, "Unable to allocate SQL query\n");
1462                         unload_module();
1463                         return 1;
1464                 }
1465
1466                 ast_debug(1, "SQL query: %s\n", query);
1467
1468                 RES_CONFIG_SQLITE_BEGIN
1469                         error = sqlite_exec(db, query, NULL, NULL, &errormsg);
1470                 RES_CONFIG_SQLITE_END(error)
1471
1472                 sqlite_freemem(query);
1473
1474                 if (error) {
1475                         /*
1476                          * Unexpected error.
1477                          */
1478                         if (error != SQLITE_ERROR) {
1479                                 ast_log(LOG_ERROR, "%s\n", errormsg);
1480                                 sqlite_freemem(errormsg);
1481                                 unload_module();
1482                                 return 1;
1483                         }
1484
1485                         sqlite_freemem(errormsg);
1486                         query = sqlite_mprintf(sql_create_cdr_table, cdr_table);
1487
1488                         if (!query) {
1489                                 ast_log(LOG_ERROR, "Unable to allocate SQL query\n");
1490                                 unload_module();
1491                                 return 1;
1492                         }
1493
1494                         ast_debug(1, "SQL query: %s\n", query);
1495
1496                         RES_CONFIG_SQLITE_BEGIN
1497                                 error = sqlite_exec(db, query, NULL, NULL, &errormsg);
1498                         RES_CONFIG_SQLITE_END(error)
1499
1500                         sqlite_freemem(query);
1501
1502                         if (error) {
1503                                 ast_log(LOG_ERROR, "%s\n", errormsg);
1504                                 sqlite_freemem(errormsg);
1505                                 unload_module();
1506                                 return 1;
1507                         }
1508                 }
1509
1510                 error = ast_cdr_register(RES_CONFIG_SQLITE_NAME, RES_CONFIG_SQLITE_DESCRIPTION, cdr_handler);
1511
1512                 if (error) {
1513                         unload_module();
1514                         return 1;
1515                 }
1516
1517                 cdr_registered = 1;
1518         }
1519
1520         error = ast_cli_register_multiple(cli_status, sizeof(cli_status) / sizeof(struct ast_cli_entry));
1521
1522         if (error) {
1523                 unload_module();
1524                 return 1;
1525         }
1526
1527         cli_status_registered = 1;
1528
1529         return 0;
1530 }
1531
1532 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS, "Realtime SQLite configuration",
1533                 .load = load_module,
1534                 .unload = unload_module,
1535 );