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 /*!
  20  * \file
  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 /*! \li \ref cdr_odbc.c uses the configuration file \ref cdr_odbc.conf
  32  * \addtogroup configuration_file Configuration Files
  33  */
  34
  35 /*!
  36  * \page cdr_odbc.conf cdr_odbc.conf
  37  * \verbinclude cdr_odbc.conf.sample
  38  */
  39
  40 /*** MODULEINFO
  41         <depend>res_odbc</depend>
  42         <support_level>extended</support_level>
  43  ***/
  44
  45 #include "asterisk.h"
  46
  47 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  48
  49 #include "asterisk/config.h"
  50 #include "asterisk/channel.h"
  51 #include "asterisk/cdr.h"
  52 #include "asterisk/module.h"
  53 #include "asterisk/res_odbc.h"
  54
  55 #define DATE_FORMAT "%Y-%m-%d %T"
  56
  57 static const char name[] = "ODBC";
  58 static const char config_file[] = "cdr_odbc.conf";
  59 static char *dsn = NULL, *table = NULL;
  60
  61 enum {
  62         CONFIG_LOGUNIQUEID =       1 << 0,
  63         CONFIG_USEGMTIME =         1 << 1,
  64         CONFIG_DISPOSITIONSTRING = 1 << 2,
  65         CONFIG_HRTIME =            1 << 3,
  66         CONFIG_REGISTERED =        1 << 4,
  67 };
  68
  69 static struct ast_flags config = { 0 };
  70
  71 static SQLHSTMT execute_cb(struct odbc_obj *obj, void *data)
  72 {
  73         struct ast_cdr *cdr = data;
  74         SQLRETURN ODBC_res;
  75         char sqlcmd[2048] = "", timestr[128];
  76         struct ast_tm tm;
  77         SQLHSTMT stmt;
  78
  79         ast_localtime(&cdr->start, &tm, ast_test_flag(&config, CONFIG_USEGMTIME) ? "GMT" : NULL);
  80         ast_strftime(timestr, sizeof(timestr), DATE_FORMAT, &tm);
  81
  82         if (ast_test_flag(&config, CONFIG_LOGUNIQUEID)) {
  83                 snprintf(sqlcmd,sizeof(sqlcmd),"INSERT INTO %s "
  84                 "(calldate,clid,src,dst,dcontext,channel,dstchannel,lastapp,"
  85                 "lastdata,duration,billsec,disposition,amaflags,accountcode,uniqueid,userfield) "
  86                 "VALUES ({ts '%s'},?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", table, timestr);
  87         } else {
  88                 snprintf(sqlcmd,sizeof(sqlcmd),"INSERT INTO %s "
  89                 "(calldate,clid,src,dst,dcontext,channel,dstchannel,lastapp,lastdata,"
  90                 "duration,billsec,disposition,amaflags,accountcode) "
  91                 "VALUES ({ts '%s'},?,?,?,?,?,?,?,?,?,?,?,?,?)", table, timestr);
  92         }
  93
  94         ODBC_res = SQLAllocHandle(SQL_HANDLE_STMT, obj->con, &stmt);
  95
  96         if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) {
  97                 ast_log(LOG_WARNING, "cdr_odbc: Failure in AllocStatement %d\n", ODBC_res);
  98                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
  99                 return NULL;
 100         }
 101
 102         SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->clid), 0, cdr->clid, 0, NULL);
 103         SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->src), 0, cdr->src, 0, NULL);
 104         SQLBindParameter(stmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->dst), 0, cdr->dst, 0, NULL);
 105         SQLBindParameter(stmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->dcontext), 0, cdr->dcontext, 0, NULL);
 106         SQLBindParameter(stmt, 5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->channel), 0, cdr->channel, 0, NULL);
 107         SQLBindParameter(stmt, 6, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->dstchannel), 0, cdr->dstchannel, 0, NULL);
 108         SQLBindParameter(stmt, 7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->lastapp), 0, cdr->lastapp, 0, NULL);
 109         SQLBindParameter(stmt, 8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->lastdata), 0, cdr->lastdata, 0, NULL);
 110
 111         if (ast_test_flag(&config, CONFIG_HRTIME)) {
 112                 double hrbillsec = 0.0;
 113                 double hrduration;
 114
 115                 if (!ast_tvzero(cdr->answer)) {
 116                         hrbillsec = (double) ast_tvdiff_us(cdr->end, cdr->answer) / 1000000.0;
 117                 }
 118                 hrduration = (double) ast_tvdiff_us(cdr->end, cdr->start) / 1000000.0;
 119
 120                 SQLBindParameter(stmt, 9, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_FLOAT, 0, 0, &hrduration, 0, NULL);
 121                 SQLBindParameter(stmt, 10, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_FLOAT, 0, 0, &hrbillsec, 0, NULL);
 122         } else {
 123                 SQLBindParameter(stmt, 9, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &cdr->duration, 0, NULL);
 124                 SQLBindParameter(stmt, 10, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &cdr->billsec, 0, NULL);
 125         }
 126
 127         if (ast_test_flag(&config, CONFIG_DISPOSITIONSTRING))
 128                 SQLBindParameter(stmt, 11, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(ast_cdr_disp2str(cdr->disposition)) + 1, 0, ast_cdr_disp2str(cdr->disposition), 0, NULL);
 129         else
 130                 SQLBindParameter(stmt, 11, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &cdr->disposition, 0, NULL);
 131         SQLBindParameter(stmt, 12, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &cdr->amaflags, 0, NULL);
 132         SQLBindParameter(stmt, 13, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->accountcode), 0, cdr->accountcode, 0, NULL);
 133
 134         if (ast_test_flag(&config, CONFIG_LOGUNIQUEID)) {
 135                 SQLBindParameter(stmt, 14, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->uniqueid), 0, cdr->uniqueid, 0, NULL);
 136                 SQLBindParameter(stmt, 15, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->userfield), 0, cdr->userfield, 0, NULL);
 137         }
 138
 139         ODBC_res = SQLExecDirect(stmt, (unsigned char *)sqlcmd, SQL_NTS);
 140
 141         if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) {
 142                 ast_log(LOG_WARNING, "cdr_odbc: Error in ExecDirect: %d, query is: %s\n", ODBC_res, sqlcmd);
 143                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 144                 return NULL;
 145         }
 146
 147         return stmt;
 148 }
 149
 150
 151 static int odbc_log(struct ast_cdr *cdr)
 152 {
 153         struct odbc_obj *obj = ast_odbc_request_obj(dsn, 0);
 154         SQLHSTMT stmt;
 155
 156         if (!obj) {
 157                 ast_log(LOG_ERROR, "Unable to retrieve database handle.  CDR failed.\n");
 158                 return -1;
 159         }
 160
 161         stmt = ast_odbc_direct_execute(obj, execute_cb, cdr);
 162         if (stmt) {
 163                 SQLLEN rows = 0;
 164
 165                 SQLRowCount(stmt, &rows);
 166                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 167
 168                 if (rows == 0)
 169                         ast_log(LOG_WARNING, "CDR successfully ran, but inserted 0 rows?\n");
 170         } else
 171                 ast_log(LOG_ERROR, "CDR direct execute failed\n");
 172         ast_odbc_release_obj(obj);
 173         return 0;
 174 }
 175
 176 static int odbc_load_module(int reload)
 177 {
 178         int res = 0;
 179         struct ast_config *cfg;
 180         struct ast_variable *var;
 181         const char *tmp;
 182         struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
 183
 184         do {
 185                 cfg = ast_config_load(config_file, config_flags);
 186                 if (!cfg || cfg == CONFIG_STATUS_FILEINVALID) {
 187                         ast_log(LOG_WARNING, "cdr_odbc: Unable to load config for ODBC CDR's: %s\n", config_file);
 188                         res = AST_MODULE_LOAD_DECLINE;
 189                         break;
 190                 } else if (cfg == CONFIG_STATUS_FILEUNCHANGED)
 191                         break;
 192
 193                 var = ast_variable_browse(cfg, "global");
 194                 if (!var) {
 195                         /* nothing configured */
 196                         break;
 197                 }
 198
 199                 if ((tmp = ast_variable_retrieve(cfg, "global", "dsn")) == NULL) {
 200                         ast_log(LOG_WARNING, "cdr_odbc: dsn not specified.  Assuming asteriskdb\n");
 201                         tmp = "asteriskdb";
 202                 }
 203                 if (dsn)
 204                         ast_free(dsn);
 205                 dsn = ast_strdup(tmp);
 206                 if (dsn == NULL) {
 207                         res = -1;
 208                         break;
 209                 }
 210
 211                 if (((tmp = ast_variable_retrieve(cfg, "global", "dispositionstring"))) && ast_true(tmp))
 212                         ast_set_flag(&config, CONFIG_DISPOSITIONSTRING);
 213                 else
 214                         ast_clear_flag(&config, CONFIG_DISPOSITIONSTRING);
 215
 216                 if (((tmp = ast_variable_retrieve(cfg, "global", "loguniqueid"))) && ast_true(tmp)) {
 217                         ast_set_flag(&config, CONFIG_LOGUNIQUEID);
 218                         ast_debug(1, "cdr_odbc: Logging uniqueid\n");
 219                 } else {
 220                         ast_clear_flag(&config, CONFIG_LOGUNIQUEID);
 221                         ast_debug(1, "cdr_odbc: Not logging uniqueid\n");
 222                 }
 223
 224                 if (((tmp = ast_variable_retrieve(cfg, "global", "usegmtime"))) && ast_true(tmp)) {
 225                         ast_set_flag(&config, CONFIG_USEGMTIME);
 226                         ast_debug(1, "cdr_odbc: Logging in GMT\n");
 227                 } else {
 228                         ast_clear_flag(&config, CONFIG_USEGMTIME);
 229                         ast_debug(1, "cdr_odbc: Logging in local time\n");
 230                 }
 231
 232                 if (((tmp = ast_variable_retrieve(cfg, "global", "hrtime"))) && ast_true(tmp)) {
 233                         ast_set_flag(&config, CONFIG_HRTIME);
 234                         ast_debug(1, "cdr_odbc: Logging billsec and duration fields as floats\n");
 235                 } else {
 236                         ast_clear_flag(&config, CONFIG_HRTIME);
 237                         ast_debug(1, "cdr_odbc: Logging billsec and duration fields as integers\n");
 238                 }
 239
 240                 if ((tmp = ast_variable_retrieve(cfg, "global", "table")) == NULL) {
 241                         ast_log(LOG_WARNING, "cdr_odbc: table not specified.  Assuming cdr\n");
 242                         tmp = "cdr";
 243                 }
 244                 if (table)
 245                         ast_free(table);
 246                 table = ast_strdup(tmp);
 247                 if (table == NULL) {
 248                         res = -1;
 249                         break;
 250                 }
 251
 252                 ast_verb(3, "cdr_odbc: dsn is %s\n", dsn);
 253                 ast_verb(3, "cdr_odbc: table is %s\n", table);
 254
 255                 if (!ast_test_flag(&config, CONFIG_REGISTERED)) {
 256                         res = ast_cdr_register(name, ast_module_info->description, odbc_log);
 257                         if (res) {
 258                                 ast_log(LOG_ERROR, "cdr_odbc: Unable to register ODBC CDR handling\n");
 259                         } else {
 260                                 ast_set_flag(&config, CONFIG_REGISTERED);
 261                         }
 262                 }
 263         } while (0);
 264
 265         if (ast_test_flag(&config, CONFIG_REGISTERED) && (!cfg || dsn == NULL || table == NULL)) {
 266                 ast_cdr_unregister(name);
 267                 ast_clear_flag(&config, CONFIG_REGISTERED);
 268         }
 269
 270         if (cfg && cfg != CONFIG_STATUS_FILEUNCHANGED && cfg != CONFIG_STATUS_FILEINVALID) {
 271                 ast_config_destroy(cfg);
 272         }
 273         return res;
 274 }
 275
 276 static int load_module(void)
 277 {
 278         return odbc_load_module(0);
 279 }
 280
 281 static int unload_module(void)
 282 {
 283         ast_cdr_unregister(name);
 284
 285         if (dsn) {
 286                 ast_verb(11, "cdr_odbc: free dsn\n");
 287                 ast_free(dsn);
 288         }
 289         if (table) {
 290                 ast_verb(11, "cdr_odbc: free table\n");
 291                 ast_free(table);
 292         }
 293
 294         return 0;
 295 }
 296
 297 static int reload(void)
 298 {
 299         return odbc_load_module(1);
 300 }
 301
 302 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "ODBC CDR Backend",
 303                 .load = load_module,
 304                 .unload = unload_module,
 305                 .reload = reload,
 306                 .load_pri = AST_MODPRI_CDR_DRIVER,
 307                );