Convert cdr_odbc to use res_odbc managed connections
[asterisk/asterisk.git] / cdr / cdr_odbc.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2003-2005, Digium, Inc.
5  *
6  * Brian K. West <brian@bkw.org>
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 ODBC CDR Backend
22  * 
23  * \author Brian K. West <brian@bkw.org>
24  *
25  * See also:
26  * \arg http://www.unixodbc.org
27  * \arg \ref Config_cdr
28  * \ingroup cdr_drivers
29  */
30
31 /*** MODULEINFO
32         <depend>unixodbc</depend>
33         <depend>ltdl</depend>
34  ***/
35
36 #include "asterisk.h"
37
38 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
39
40 #include <sys/types.h>
41 #include <stdio.h>
42 #include <string.h>
43
44 #include <stdlib.h>
45 #include <unistd.h>
46 #include <time.h>
47
48 #include "asterisk/config.h"
49 #include "asterisk/options.h"
50 #include "asterisk/channel.h"
51 #include "asterisk/cdr.h"
52 #include "asterisk/module.h"
53 #include "asterisk/logger.h"
54 #include "asterisk/res_odbc.h"
55
56 #define DATE_FORMAT "%Y-%m-%d %T"
57
58 static char *name = "ODBC";
59 static char *config_file = "cdr_odbc.conf";
60 static char *dsn = NULL, *table = NULL;
61
62 enum {
63         CONFIG_LOGUNIQUEID =       1 << 0,
64         CONFIG_USEGMTIME =         1 << 1,
65         CONFIG_DISPOSITIONSTRING = 1 << 2,
66 };
67
68 static struct ast_flags config = { 0 };
69
70 static SQLHSTMT prepare_cb(struct odbc_obj *obj, void *data)
71 {
72         struct ast_cdr *cdr = data;
73         SQLRETURN ODBC_res;
74         char sqlcmd[2048] = "", timestr[128];
75         struct ast_tm tm;
76         SQLHSTMT stmt;
77
78         ast_localtime(&cdr->start, &tm, ast_test_flag(&config, CONFIG_USEGMTIME) ? "GMT" : NULL);
79
80         ast_strftime(timestr, sizeof(timestr), DATE_FORMAT, &tm);
81         if (ast_test_flag(&config, CONFIG_LOGUNIQUEID)) {
82                 snprintf(sqlcmd,sizeof(sqlcmd),"INSERT INTO %s "
83                 "(calldate,clid,src,dst,dcontext,channel,dstchannel,lastapp,"
84                 "lastdata,duration,billsec,disposition,amaflags,accountcode,uniqueid,userfield) "
85                 "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", table);
86         } else {
87                 snprintf(sqlcmd,sizeof(sqlcmd),"INSERT INTO %s "
88                 "(calldate,clid,src,dst,dcontext,channel,dstchannel,lastapp,lastdata,"
89                 "duration,billsec,disposition,amaflags,accountcode) "
90                 "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)", table);
91         }
92
93         ODBC_res = SQLAllocHandle(SQL_HANDLE_STMT, obj->con, &stmt);
94
95         if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) {
96                 ast_verb(11, "cdr_odbc: Failure in AllocStatement %d\n", ODBC_res);
97                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
98                 return NULL;
99         }
100
101         ODBC_res = SQLPrepare(stmt, (unsigned char *)sqlcmd, SQL_NTS);
102         
103         if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) {
104                 ast_verb(11, "cdr_odbc: Error in PREPARE %d\n", ODBC_res);
105                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
106                 return NULL;
107         }
108
109         SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(timestr), 0, &timestr, 0, NULL);
110         SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->clid), 0, cdr->clid, 0, NULL);
111         SQLBindParameter(stmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->src), 0, cdr->src, 0, NULL);
112         SQLBindParameter(stmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->dst), 0, cdr->dst, 0, NULL);
113         SQLBindParameter(stmt, 5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->dcontext), 0, cdr->dcontext, 0, NULL);
114         SQLBindParameter(stmt, 6, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->channel), 0, cdr->channel, 0, NULL);
115         SQLBindParameter(stmt, 7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->dstchannel), 0, cdr->dstchannel, 0, NULL);
116         SQLBindParameter(stmt, 8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->lastapp), 0, cdr->lastapp, 0, NULL);
117         SQLBindParameter(stmt, 9, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->lastdata), 0, cdr->lastdata, 0, NULL);
118         SQLBindParameter(stmt, 10, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &cdr->duration, 0, NULL);
119         SQLBindParameter(stmt, 11, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &cdr->billsec, 0, NULL);
120         if (ast_test_flag(&config, CONFIG_DISPOSITIONSTRING))
121                 SQLBindParameter(stmt, 12, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(ast_cdr_disp2str(cdr->disposition)) + 1, 0, ast_cdr_disp2str(cdr->disposition), 0, NULL);
122         else
123                 SQLBindParameter(stmt, 12, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &cdr->disposition, 0, NULL);
124         SQLBindParameter(stmt, 13, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &cdr->amaflags, 0, NULL);
125         SQLBindParameter(stmt, 14, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->accountcode), 0, cdr->accountcode, 0, NULL);
126
127         if (ast_test_flag(&config, CONFIG_LOGUNIQUEID)) {
128                 SQLBindParameter(stmt, 15, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->uniqueid), 0, cdr->uniqueid, 0, NULL);
129                 SQLBindParameter(stmt, 16, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->userfield), 0, cdr->userfield, 0, NULL);
130         }
131
132         return stmt;
133 }
134
135
136 static int odbc_log(struct ast_cdr *cdr)
137 {
138         struct odbc_obj *obj = ast_odbc_request_obj(dsn, 0);
139         SQLHSTMT stmt;
140
141         if (!obj) {
142                 ast_log(LOG_ERROR, "Unable to retrieve database handle.  CDR failed.\n");
143                 return -1;
144         }
145
146         stmt = ast_odbc_prepare_and_execute(obj, prepare_cb, cdr);
147         if (stmt) {
148                 SQLINTEGER rows = 0;
149
150                 SQLRowCount(stmt, &rows);
151                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
152
153                 if (rows == 0)
154                         ast_log(LOG_WARNING, "CDR successfully ran, but inserted 0 rows?\n");
155         } else
156                 ast_log(LOG_ERROR, "CDR prepare or execute failed\n");
157         ast_odbc_release_obj(obj);
158         return 0;
159 }
160
161 static int odbc_load_module(int reload)
162 {
163         int res = 0;
164         struct ast_config *cfg;
165         struct ast_variable *var;
166         const char *tmp;
167         struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
168
169         do {
170                 cfg = ast_config_load(config_file, config_flags);
171                 if (!cfg) {
172                         ast_log(LOG_WARNING, "cdr_odbc: Unable to load config for ODBC CDR's: %s\n", config_file);
173                         res = AST_MODULE_LOAD_DECLINE;
174                         break;
175                 } else if (cfg == CONFIG_STATUS_FILEUNCHANGED)
176                         break;
177         
178                 var = ast_variable_browse(cfg, "global");
179                 if (!var) {
180                         /* nothing configured */
181                         break;
182                 }
183
184                 if ((tmp = ast_variable_retrieve(cfg, "global", "dsn")) == NULL) {
185                         ast_log(LOG_WARNING, "cdr_odbc: dsn not specified.  Assuming asteriskdb\n");
186                         tmp = "asteriskdb";
187                 }
188                 if (dsn)
189                         ast_free(dsn);
190                 dsn = ast_strdup(tmp);
191                 if (dsn == NULL) {
192                         res = -1;
193                         break;
194                 }
195
196                 if (((tmp = ast_variable_retrieve(cfg, "global", "dispositionstring"))) && ast_true(tmp))
197                         ast_set_flag(&config, CONFIG_DISPOSITIONSTRING);
198                 else
199                         ast_clear_flag(&config, CONFIG_DISPOSITIONSTRING);
200
201                 if (((tmp = ast_variable_retrieve(cfg, "global", "loguniqueid"))) && ast_true(tmp)) {
202                         ast_set_flag(&config, CONFIG_LOGUNIQUEID);
203                         ast_debug(1, "cdr_odbc: Logging uniqueid\n");
204                 } else {
205                         ast_clear_flag(&config, CONFIG_LOGUNIQUEID);
206                         ast_debug(1, "cdr_odbc: Not logging uniqueid\n");
207                 }
208
209                 if (((tmp = ast_variable_retrieve(cfg, "global", "usegmtime"))) && ast_true(tmp)) {
210                         ast_set_flag(&config, CONFIG_USEGMTIME);
211                         ast_debug(1, "cdr_odbc: Logging in GMT\n");
212                 } else {
213                         ast_clear_flag(&config, CONFIG_USEGMTIME);
214                         ast_debug(1, "cdr_odbc: Logging in local time\n");
215                 }
216
217                 if ((tmp = ast_variable_retrieve(cfg, "global", "table")) == NULL) {
218                         ast_log(LOG_WARNING, "cdr_odbc: table not specified.  Assuming cdr\n");
219                         tmp = "cdr";
220                 }
221                 if (table)
222                         ast_free(table);
223                 table = ast_strdup(tmp);
224                 if (table == NULL) {
225                         res = -1;
226                         break;
227                 }
228
229                 ast_verb(3, "cdr_odbc: dsn is %s\n", dsn);
230                 ast_verb(3, "cdr_odbc: table is %s\n", table);
231
232                 res = ast_cdr_register(name, ast_module_info->description, odbc_log);
233                 if (res) {
234                         ast_log(LOG_ERROR, "cdr_odbc: Unable to register ODBC CDR handling\n");
235                 }
236         } while (0);
237
238         if (cfg && cfg != CONFIG_STATUS_FILEUNCHANGED)
239                 ast_config_destroy(cfg);
240         return res;
241 }
242
243 static int load_module(void)
244 {
245         return odbc_load_module(0);
246 }
247
248 static int unload_module(void)
249 {
250         ast_cdr_unregister(name);
251
252         if (dsn) {
253                 ast_verb(11, "cdr_odbc: free dsn\n");
254                 ast_free(dsn);
255         }
256         if (table) {
257                 ast_verb(11, "cdr_odbc: free table\n");
258                 ast_free(table);
259         }
260
261         return 0;
262 }
263
264 static int reload(void)
265 {
266         return odbc_load_module(1);
267 }
268
269 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "ODBC CDR Backend",
270                 .load = load_module,
271                 .unload = unload_module,
272                 .reload = reload,
273                );