If any field is not null, but has no default, then it must be set or the insert will...
[asterisk/asterisk.git] / cdr / cdr_sqlite3_custom.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2007, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com> and others.
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
19 /*! \file
20  *
21  * \brief Custom SQLite3 CDR records.
22  *
23  * \author Adapted by Alejandro Rios <alejandro.rios@avatar.com.co> and
24  *  Russell Bryant <russell@digium.com> from 
25  *  cdr_mysql_custom by Edward Eastman <ed@dm3.co.uk>,
26  *      and cdr_sqlite by Holger Schurig <hs4233@mail.mn-solutions.de>
27  *      
28  *
29  * \arg See also \ref AstCDR
30  *
31  *
32  * \ingroup cdr_drivers
33  */
34
35 /*** MODULEINFO
36         <depend>sqlite3</depend>
37  ***/
38
39 #include "asterisk.h"
40
41 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
42
43 #include <time.h>
44 #include <sqlite3.h>
45
46 #include "asterisk/paths.h"     /* use ast_config_AST_LOG_DIR */
47 #include "asterisk/channel.h"
48 #include "asterisk/cdr.h"
49 #include "asterisk/module.h"
50 #include "asterisk/config.h"
51 #include "asterisk/pbx.h"
52 #include "asterisk/utils.h"
53 #include "asterisk/cli.h"
54
55 AST_MUTEX_DEFINE_STATIC(lock);
56
57 static const char config_file[] = "cdr_sqlite3_custom.conf";
58
59 static char *desc = "Customizable SQLite3 CDR Backend";
60 static char *name = "cdr_sqlite3_custom";
61 static sqlite3 *db = NULL;
62
63 static char table[80];
64 static char *columns;
65
66 struct values {
67         char *expression;
68         AST_LIST_ENTRY(values) list;
69 };
70
71 static AST_LIST_HEAD_STATIC(sql_values, values);
72
73 static int free_config(void);
74
75 static int load_column_config(const char *tmp)
76 {
77         char *col = NULL;
78         char *cols = NULL;
79         char *escaped = NULL;
80         struct ast_str *column_string = NULL;
81
82         if (ast_strlen_zero(tmp)) {
83                 ast_log(LOG_WARNING, "Column names not specified. Module not loaded.\n");
84                 return -1;
85         }
86         if (!(column_string = ast_str_create(1024))) {
87                 ast_log(LOG_ERROR, "Out of memory creating temporary buffer for column list for table '%s.'\n", table);
88                 return -1;
89         }
90         if (!(cols = ast_strdup(tmp))) {
91                 ast_log(LOG_ERROR, "Out of memory creating temporary buffer for column list for table '%s.'\n", table);
92                 ast_free(column_string);
93                 return -1;
94         }
95         while ((col = strsep(&cols, ","))) {
96                 col = ast_strip(col);
97                 escaped = sqlite3_mprintf("%q", col);
98                 if (!escaped) {
99                         ast_log(LOG_ERROR, "Out of memory creating entry for column '%s' in table '%s.'\n", col, table);
100                         ast_free(column_string);
101                         ast_free(cols);
102                         return -1;
103                 }
104                 if (!column_string->used)
105                         ast_str_set(&column_string, 0, "%s", escaped);
106                 else
107                         ast_str_append(&column_string, 0, ",%s", escaped);
108                 sqlite3_free(escaped);
109         }
110         if (!(columns = ast_strdup(column_string->str))) {
111                 ast_log(LOG_ERROR, "Out of memory copying columns string for table '%s.'\n", table);
112                 ast_free(column_string);
113                 ast_free(cols);
114                 return -1;
115         }
116         ast_free(column_string);
117         ast_free(cols);
118
119         return 0;
120 }
121
122 static int load_values_config(const char *tmp)
123 {
124         char *val = NULL;
125         char *vals = NULL;
126         struct values *value = NULL;
127
128         if (ast_strlen_zero(tmp)) {
129                 ast_log(LOG_WARNING, "Values not specified. Module not loaded.\n");
130                 return -1;
131         }
132         if (!(vals = ast_strdup(tmp))) {
133                 ast_log(LOG_ERROR, "Out of memory creating temporary buffer for value '%s'\n", tmp);
134                 return -1;
135         }
136         while ((val = strsep(&vals, ","))) {
137                 /* Strip the single quotes off if they are there */
138                 val = ast_strip_quoted(val, "'", "'");
139                 value = ast_calloc(sizeof(char), sizeof(*value) + strlen(val) + 1);
140                 if (!value) {
141                         ast_log(LOG_ERROR, "Out of memory creating entry for value '%s'\n", val);
142                         ast_free(vals);
143                         return -1;
144                 }
145                 value->expression = (char *) value + sizeof(*value);
146                 ast_copy_string(value->expression, val, strlen(val) + 1);
147                 AST_LIST_INSERT_TAIL(&sql_values, value, list);
148         }
149         ast_free(vals);
150
151         return 0;
152 }
153
154 static int load_config(int reload)
155 {
156         struct ast_config *cfg;
157         struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
158         struct ast_variable *mappingvar;
159         const char *tmp;
160
161         if (!(cfg = ast_config_load(config_file, config_flags))) {
162                 if (reload)
163                         ast_log(LOG_WARNING, "Failed to reload configuration file.\n");
164                 else
165                         ast_log(LOG_WARNING, "Failed to load configuration file. Module not activated.\n");
166                 return -1;
167         } else if (cfg == CONFIG_STATUS_FILEUNCHANGED)
168                 return 0;
169
170         if (reload)
171                 free_config();
172
173         ast_mutex_lock(&lock);
174
175         if (!(mappingvar = ast_variable_browse(cfg, "master"))) {
176                 /* Nothing configured */
177                 ast_mutex_unlock(&lock);
178                 ast_config_destroy(cfg);
179                 return 0;
180         }
181         
182         /* Mapping must have a table name */
183         tmp = ast_variable_retrieve(cfg, "master", "table");
184         if (!ast_strlen_zero(tmp))
185                 ast_copy_string(table, tmp, sizeof(table));
186         else {
187                 ast_log(LOG_WARNING, "Table name not specified.  Assuming cdr.\n");
188                 strcpy(table, "cdr");
189         }
190
191         /* Columns */
192         tmp = ast_variable_retrieve(cfg, "master", "columns");
193         if (load_column_config(tmp)) {
194                 ast_mutex_unlock(&lock);
195                 ast_config_destroy(cfg);
196                 free_config();
197                 return -1;
198         }
199
200         /* Values */
201         tmp = ast_variable_retrieve(cfg, "master", "values");
202         if (load_values_config(tmp)) {
203                 ast_mutex_unlock(&lock);
204                 ast_config_destroy(cfg);
205                 free_config();
206                 return -1;
207         }
208
209         ast_verb(3, "cdr_sqlite3_custom: Logging CDR records to table '%s' in 'master.db'\n", table);
210
211         ast_mutex_unlock(&lock);
212         ast_config_destroy(cfg);
213
214         return 0;
215 }
216
217 static int free_config(void)
218 {
219         struct values *value;
220
221         ast_mutex_lock(&lock);
222
223         if (db) {
224                 sqlite3_close(db);
225                 db = NULL;
226         }
227
228         if (columns) {
229                 ast_free(columns);
230                 columns = NULL;
231         }
232
233         while ((value = AST_LIST_REMOVE_HEAD(&sql_values, list)))
234                 ast_free(value);
235
236         ast_mutex_unlock(&lock);
237
238         return 0;
239 }
240
241 static int sqlite3_log(struct ast_cdr *cdr)
242 {
243         int res = 0;
244         char *error = NULL;
245         char *sql = NULL;
246         struct ast_channel dummy = { 0, };
247         int count = 0;
248
249         { /* Make it obvious that only sql should be used outside of this block */
250                 char *escaped;
251                 char subst_buf[2048];
252                 struct values *value;
253                 struct ast_str *value_string = ast_str_create(1024);
254                 dummy.cdr = cdr;
255                 AST_LIST_TRAVERSE(&sql_values, value, list) {
256                         memset(subst_buf, 0, sizeof(subst_buf));
257                         pbx_substitute_variables_helper(&dummy, value->expression, subst_buf, sizeof(subst_buf) - 1);
258                         escaped = sqlite3_mprintf("%q", subst_buf);
259                         if (!value_string->used)
260                                 ast_str_append(&value_string, 0, "'%s'", escaped);
261                         else
262                                 ast_str_append(&value_string, 0, ",'%s'", escaped);
263                         sqlite3_free(escaped);
264                 }
265                 sql = sqlite3_mprintf("INSERT INTO %q (%s) VALUES (%s)", table, columns, value_string->str);
266                 ast_debug(1, "About to log: %s\n", sql);
267                 ast_free(value_string);
268         }
269
270         ast_mutex_lock(&lock);
271
272         /* XXX This seems awful arbitrary... */
273         for (count = 0; count < 5; count++) {
274                 res = sqlite3_exec(db, sql, NULL, NULL, &error);
275                 if (res != SQLITE_BUSY && res != SQLITE_LOCKED)
276                         break;
277                 usleep(200);
278         }
279
280         if (error) {
281                 ast_log(LOG_ERROR, "%s. SQL: %s.\n", error, sql);
282                 sqlite3_free(error);
283         }
284
285         if (sql)
286                 sqlite3_free(sql);
287
288         ast_mutex_unlock(&lock);
289
290         return res;
291 }
292
293 static int unload_module(void)
294 {
295         free_config();
296
297         ast_cdr_unregister(name);
298
299         return 0;
300 }
301
302 static int load_module(void)
303 {
304         char *error;
305         char filename[PATH_MAX];
306         int res;
307         char *sql;
308
309         if (!load_config(0)) {
310                 res = ast_cdr_register(name, desc, sqlite3_log);
311                 if (res) {
312                         ast_log(LOG_ERROR, "Unable to register custom SQLite3 CDR handling\n");
313                         free_config();
314                         return AST_MODULE_LOAD_DECLINE;
315                 }
316         } else
317                 return AST_MODULE_LOAD_DECLINE;
318
319         /* is the database there? */
320         snprintf(filename, sizeof(filename), "%s/master.db", ast_config_AST_LOG_DIR);
321         res = sqlite3_open(filename, &db);
322         if (res != SQLITE_OK) {
323                 ast_log(LOG_ERROR, "Could not open database %s.\n", filename);
324                 free_config();
325                 return AST_MODULE_LOAD_DECLINE;
326         }
327
328         /* is the table there? */
329         sql = sqlite3_mprintf("SELECT COUNT(AcctId) FROM %q;", table);
330         res = sqlite3_exec(db, sql, NULL, NULL, NULL);
331         sqlite3_free(sql);
332         if (res != SQLITE_OK) {
333                 /* We don't use %q for the column list here since we already escaped when building it */
334                 sql = sqlite3_mprintf("CREATE TABLE %q (AcctId INTEGER PRIMARY KEY, %s)", table, columns);
335                 res = sqlite3_exec(db, sql, NULL, NULL, &error);
336                 sqlite3_free(sql);
337                 if (res != SQLITE_OK) {
338                         ast_log(LOG_WARNING, "Unable to create table '%s': %s.\n", table, error);
339                         sqlite3_free(error);
340                         free_config();
341                         return AST_MODULE_LOAD_DECLINE;
342                 }
343         }
344
345         return 0;
346 }
347
348 static int reload(void)
349 {
350         return load_config(1);
351 }
352
353 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "SQLite3 Custom CDR Module",
354         .load = load_module,
355         .unload = unload_module,
356         .reload = reload,
357 );