Asterisk - The Open Source Telephony Project  21.4.1
cel_sqlite3_custom.c
Go to the documentation of this file.
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2007, Digium, Inc.
5  *
6  * Steve Murphy <murf@digium.com> borrowed code from cdr,
7  * Mark Spencer <markster@digium.com> and others.
8  *
9  * See http://www.asterisk.org for more information about
10  * the Asterisk project. Please do not directly contact
11  * any of the maintainers of this project for assistance;
12  * the project provides a web site, mailing lists and IRC
13  * channels for your use.
14  *
15  * This program is free software, distributed under the terms of
16  * the GNU General Public License Version 2. See the LICENSE file
17  * at the top of the source tree.
18  */
19 
20 /*! \file
21  *
22  * \brief Custom SQLite3 CEL records.
23  *
24  * \author Adapted by Steve Murphy <murf@digium.com> from
25  * Alejandro Rios <alejandro.rios@avatar.com.co> and
26  * Russell Bryant <russell@digium.com> from
27  * cdr_mysql_custom by Edward Eastman <ed@dm3.co.uk>,
28  * and cdr_sqlite by Holger Schurig <hs4233@mail.mn-solutions.de>
29  * \ingroup cel_drivers
30  */
31 
32 /*** MODULEINFO
33  <depend>sqlite3</depend>
34  <support_level>extended</support_level>
35  ***/
36 
37 #include "asterisk.h"
38 
39 #include <sqlite3.h>
40 
41 #include "asterisk/paths.h"
42 #include "asterisk/channel.h"
43 #include "asterisk/cel.h"
44 #include "asterisk/module.h"
45 #include "asterisk/config.h"
46 #include "asterisk/pbx.h"
47 #include "asterisk/logger.h"
48 #include "asterisk/utils.h"
49 #include "asterisk/cli.h"
50 #include "asterisk/options.h"
51 #include "asterisk/stringfields.h"
52 
53 #define SQLITE_BACKEND_NAME "CEL sqlite3 custom backend"
54 
55 AST_MUTEX_DEFINE_STATIC(lock);
56 
57 static const char config_file[] = "cel_sqlite3_custom.conf";
58 
59 static sqlite3 *db = NULL;
60 
61 static char table[80];
62 /*!
63  * \bug Handling of this var is crash prone on reloads
64  */
65 static char *columns;
66 static int busy_timeout;
67 
68 struct values {
69  char *expression;
70  AST_LIST_ENTRY(values) list;
71 };
72 
74 
75 static void free_config(void);
76 
77 static int load_column_config(const char *tmp)
78 {
79  char *col = NULL;
80  char *cols = NULL, *save = NULL;
81  char *escaped = NULL;
82  struct ast_str *column_string = NULL;
83 
84  if (ast_strlen_zero(tmp)) {
85  ast_log(LOG_WARNING, "Column names not specified. Module not loaded.\n");
86  return -1;
87  }
88  if (!(column_string = ast_str_create(1024))) {
89  ast_log(LOG_ERROR, "Out of memory creating temporary buffer for column list for table '%s.'\n", table);
90  return -1;
91  }
92  if (!(save = cols = ast_strdup(tmp))) {
93  ast_log(LOG_ERROR, "Out of memory creating temporary buffer for column list for table '%s.'\n", table);
94  ast_free(column_string);
95  return -1;
96  }
97  while ((col = strsep(&cols, ","))) {
98  col = ast_strip(col);
99  escaped = sqlite3_mprintf("%q", col);
100  if (!escaped) {
101  ast_log(LOG_ERROR, "Out of memory creating entry for column '%s' in table '%s.'\n", col, table);
102  ast_free(column_string);
103  ast_free(save);
104  return -1;
105  }
106  ast_str_append(&column_string, 0, "%s%s", ast_str_strlen(column_string) ? "," : "", escaped);
107  sqlite3_free(escaped);
108  }
109  if (!(columns = ast_strdup(ast_str_buffer(column_string)))) {
110  ast_log(LOG_ERROR, "Out of memory copying columns string for table '%s.'\n", table);
111  ast_free(column_string);
112  ast_free(save);
113  return -1;
114  }
115  ast_free(column_string);
116  ast_free(save);
117 
118  return 0;
119 }
120 
121 static int load_values_config(const char *tmp)
122 {
123  char *val = NULL;
124  char *vals = NULL, *save = NULL;
125  struct values *value = NULL;
126 
127  if (ast_strlen_zero(tmp)) {
128  ast_log(LOG_WARNING, "Values not specified. Module not loaded.\n");
129  return -1;
130  }
131  if (!(save = vals = ast_strdup(tmp))) {
132  ast_log(LOG_ERROR, "Out of memory creating temporary buffer for value '%s'\n", tmp);
133  return -1;
134  }
135  while ((val = strsep(&vals, ","))) {
136  /* Strip the single quotes off if they are there */
137  val = ast_strip_quoted(val, "'", "'");
138  value = ast_calloc(sizeof(char), sizeof(*value) + strlen(val) + 1);
139  if (!value) {
140  ast_log(LOG_ERROR, "Out of memory creating entry for value '%s'\n", val);
141  ast_free(save);
142  return -1;
143  }
144  value->expression = (char *) value + sizeof(*value);
145  ast_copy_string(value->expression, val, strlen(val) + 1);
146  AST_LIST_INSERT_TAIL(&sql_values, value, list);
147  }
148  ast_free(save);
149 
150  return 0;
151 }
152 
153 static int load_config(int reload)
154 {
155  struct ast_config *cfg;
156  struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
157  struct ast_variable *mappingvar;
158  const char *tmp;
159 
160  if ((cfg = ast_config_load(config_file, config_flags)) == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEINVALID) {
161  ast_log(LOG_WARNING, "Failed to %sload configuration file. %s\n",
162  reload ? "re" : "", reload ? "" : "Module not activated.");
163  return -1;
164  } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
165  return 0;
166  }
167 
168  if (reload) {
169  free_config();
170  }
171 
172  if (!(mappingvar = ast_variable_browse(cfg, "master"))) {
173  /* Nothing configured */
174  ast_config_destroy(cfg);
175  return -1;
176  }
177 
178  /* Mapping must have a table name */
179  if (!ast_strlen_zero(tmp = ast_variable_retrieve(cfg, "master", "table"))) {
180  ast_copy_string(table, tmp, sizeof(table));
181  } else {
182  ast_log(LOG_WARNING, "Table name not specified. Assuming cel.\n");
183  strcpy(table, "cel");
184  }
185 
186  /* sqlite3_busy_timeout in miliseconds */
187  if ((tmp = ast_variable_retrieve(cfg, "master", "busy_timeout")) != NULL) {
188  if (ast_parse_arg(tmp, PARSE_INT32|PARSE_DEFAULT, &busy_timeout, 1000) != 0) {
189  ast_log(LOG_WARNING, "Invalid busy_timeout value '%s' specified. Using 1000 instead.\n", tmp);
190  }
191  } else {
192  busy_timeout = 1000;
193  }
194 
195  /* Columns */
196  if (load_column_config(ast_variable_retrieve(cfg, "master", "columns"))) {
197  ast_config_destroy(cfg);
198  free_config();
199  return -1;
200  }
201 
202  /* Values */
203  if (load_values_config(ast_variable_retrieve(cfg, "master", "values"))) {
204  ast_config_destroy(cfg);
205  free_config();
206  return -1;
207  }
208 
209  ast_verb(3, "Logging CEL records to table '%s' in 'master.db'\n", table);
210 
211  ast_config_destroy(cfg);
212 
213  return 0;
214 }
215 
216 static void free_config(void)
217 {
218  struct values *value;
219 
220  if (db) {
221  sqlite3_close(db);
222  db = NULL;
223  }
224 
225  if (columns) {
226  ast_free(columns);
227  columns = NULL;
228  }
229 
230  while ((value = AST_LIST_REMOVE_HEAD(&sql_values, list))) {
231  ast_free(value);
232  }
233 }
234 
235 static void write_cel(struct ast_event *event)
236 {
237  char *error = NULL;
238  char *sql = NULL;
239 
240  if (db == NULL) {
241  /* Should not have loaded, but be failsafe. */
242  return;
243  }
244 
245  ast_mutex_lock(&lock);
246 
247  { /* Make it obvious that only sql should be used outside of this block */
248  char *escaped;
249  char subst_buf[2048];
250  struct values *value;
251  struct ast_channel *dummy;
252  struct ast_str *value_string = ast_str_create(1024);
253 
255  if (!dummy) {
256  ast_log(LOG_ERROR, "Unable to fabricate channel from CEL event.\n");
257  ast_free(value_string);
258  ast_mutex_unlock(&lock);
259  return;
260  }
261  AST_LIST_TRAVERSE(&sql_values, value, list) {
262  pbx_substitute_variables_helper(dummy, value->expression, subst_buf, sizeof(subst_buf) - 1);
263  escaped = sqlite3_mprintf("%q", subst_buf);
264  ast_str_append(&value_string, 0, "%s'%s'", ast_str_strlen(value_string) ? "," : "", escaped);
265  sqlite3_free(escaped);
266  }
267  sql = sqlite3_mprintf("INSERT INTO %q (%s) VALUES (%s)", table, columns, ast_str_buffer(value_string));
268  ast_debug(1, "About to log: %s\n", sql);
269  dummy = ast_channel_unref(dummy);
270  ast_free(value_string);
271  }
272 
273  if (sqlite3_exec(db, sql, NULL, NULL, &error) != SQLITE_OK) {
274  ast_log(LOG_ERROR, "%s. SQL: %s.\n", error, sql);
275  sqlite3_free(error);
276  }
277 
278  if (sql) {
279  sqlite3_free(sql);
280  }
281  ast_mutex_unlock(&lock);
282 
283  return;
284 }
285 
286 static int unload_module(void)
287 {
288  ast_cel_backend_unregister(SQLITE_BACKEND_NAME);
289 
290  free_config();
291 
292  return 0;
293 }
294 
295 static int load_module(void)
296 {
297  char *error;
298  char filename[PATH_MAX];
299  int res;
300  char *sql;
301 
302  if (load_config(0)) {
304  }
305 
306  /* is the database there? */
307  snprintf(filename, sizeof(filename), "%s/master.db", ast_config_AST_LOG_DIR);
308  res = sqlite3_open(filename, &db);
309  if (res != SQLITE_OK) {
310  ast_log(LOG_ERROR, "Could not open database %s.\n", filename);
311  free_config();
313  }
314  sqlite3_busy_timeout(db, busy_timeout);
315  /* is the table there? */
316  sql = sqlite3_mprintf("SELECT COUNT(*) FROM %q;", table);
317  res = sqlite3_exec(db, sql, NULL, NULL, NULL);
318  sqlite3_free(sql);
319  if (res != SQLITE_OK) {
320  /* We don't use %q for the column list here since we already escaped when building it */
321  sql = sqlite3_mprintf("CREATE TABLE %q (AcctId INTEGER PRIMARY KEY, %s)", table, columns);
322  res = sqlite3_exec(db, sql, NULL, NULL, &error);
323  sqlite3_free(sql);
324  if (res != SQLITE_OK) {
325  ast_log(LOG_WARNING, "Unable to create table '%s': %s.\n", table, error);
326  sqlite3_free(error);
327  free_config();
329  }
330  }
331 
332  if (ast_cel_backend_register(SQLITE_BACKEND_NAME, write_cel)) {
333  ast_log(LOG_ERROR, "Unable to register custom SQLite3 CEL handling\n");
334  free_config();
336  }
337 
339 }
340 
341 static int reload(void)
342 {
343  int res = 0;
344 
345  ast_mutex_lock(&lock);
346  res = load_config(1);
347  ast_mutex_unlock(&lock);
348 
349  return res;
350 }
351 
352 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "SQLite3 Custom CEL Module",
353  .support_level = AST_MODULE_SUPPORT_EXTENDED,
354  .load = load_module,
355  .unload = unload_module,
356  .reload = reload,
357  .load_pri = AST_MODPRI_CDR_DRIVER,
358  .requires = "cel",
359 );
Main Channel structure associated with a channel.
An event.
Definition: event.c:81
Asterisk main include file. File version handling, generic pbx functions.
int ast_parse_arg(const char *arg, enum ast_parse_flags flags, void *p_result,...)
The argument parsing routine.
Definition: main/config.c:3827
#define ast_channel_unref(c)
Decrease channel reference count.
Definition: channel.h:2958
Call Event Logging API.
int ast_cel_backend_register(const char *name, ast_cel_backend_cb backend_callback)
Register a CEL backend.
Definition: cel.c:1781
char * ast_str_buffer(const struct ast_str *buf)
Returns the string buffer within the ast_str buf.
Definition: strings.h:761
Structure for variables, used for configurations and for channel variables.
Definition: astman.c:222
int ast_str_append(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Append to a thread local dynamic string.
Definition: strings.h:1139
#define ast_strdup(str)
A wrapper for strdup()
Definition: astmm.h:241
Utility functions.
Configuration File Parser.
static const char config_file[]
char * ast_strip_quoted(char *s, const char *beg_quotes, const char *end_quotes)
Strip leading/trailing whitespace and quotes from a string.
Definition: utils.c:1818
#define ast_config_load(filename, flags)
Load a config file.
ast_mutex_t lock
General Asterisk PBX channel definitions.
Asterisk file paths, configured in asterisk.conf.
char * ast_strip(char *s)
Strip leading/trailing whitespace from a string.
Definition: strings.h:223
#define ast_debug(level,...)
Log a DEBUG message.
#define AST_LIST_REMOVE_HEAD(head, field)
Removes and returns the head entry from a list.
Definition: linkedlists.h:833
Core PBX routines and definitions.
int ast_cel_backend_unregister(const char *name)
Unregister a CEL backend.
Definition: cel.c:1769
#define AST_LIST_HEAD_STATIC(name, type)
Defines a structure to be used to hold a list of specified type, statically initialized.
Definition: linkedlists.h:291
#define AST_LIST_INSERT_TAIL(head, elm, field)
Appends a list entry to the tail of a list.
Definition: linkedlists.h:731
Support for dynamic strings.
Definition: strings.h:623
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
Definition: linkedlists.h:491
#define AST_LIST_ENTRY(type)
Declare a forward link structure inside a list entry.
Definition: linkedlists.h:410
static char * columns
#define ast_calloc(num, len)
A wrapper for calloc()
Definition: astmm.h:202
struct ast_channel * ast_cel_fabricate_channel_from_event(const struct ast_event *event)
Create a fake channel from data in a CEL event.
Definition: cel.c:662
Support for logging to various files, console and syslog Configuration in file logger.conf.
Module has failed to load, may be in an inconsistent state.
Definition: module.h:78
Structure used to handle boolean flags.
Definition: utils.h:199
size_t ast_str_strlen(const struct ast_str *buf)
Returns the current length of the string stored within buf.
Definition: strings.h:730
Standard Command Line Interface.
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:425
Options provided by main asterisk program.
void ast_config_destroy(struct ast_config *cfg)
Destroys a config.
Definition: extconf.c:1289
#define ASTERISK_GPL_KEY
The text the key() function should return.
Definition: module.h:46
Asterisk module definitions.
#define ast_str_create(init_len)
Create a malloc'ed dynamic length string.
Definition: strings.h:659