cdr/cdr_csv.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * Comma Separated Value CDR records.
   5  *
   6  * Copyright (C) 1999, Mark Spencer
   7  *
   8  * Mark Spencer <markster@linux-support.net>
   9  *
  10  * This program is free software, distributed under the terms of
  11  * the GNU General Public License.
  12  *
  13  * Includes code and algorithms from the Zapata library.
  14  *
  15  */
  16
  17 #include <sys/types.h>
  18 #include <asterisk/channel.h>
  19 #include <asterisk/cdr.h>
  20 #include <asterisk/module.h>
  21 #include <asterisk/logger.h>
  22 #include <asterisk/utils.h>
  23 #include "../asterisk.h"
  24 #include "../astconf.h"
  25
  26 #define CSV_LOG_DIR "/cdr-csv"
  27 #define CSV_MASTER  "/Master.csv"
  28
  29 #define DATE_FORMAT "%Y-%m-%d %T"
  30
  31 /* #define CSV_LOGUNIQUEID 1 */
  32 /* #define CSV_LOGUSERFIELD 1 */
  33
  34 #include <stdio.h>
  35 #include <string.h>
  36
  37 #include <stdlib.h>
  38 #include <unistd.h>
  39 #include <time.h>
  40
  41 /* The values are as follows:
  42
  43
  44   "accountcode",        // accountcode is the account name of detail records, Master.csv contains all records
  45                         // Detail records are configured on a channel basis, IAX and SIP are determined by user
  46                         // Zap is determined by channel in zaptel.conf
  47   "source",
  48   "destination",
  49   "destination context",
  50   "callerid",
  51   "channel",
  52   "destination channel",        (if applicable)
  53   "last application",   // Last application run on the channel
  54   "last app argument",  // argument to the last channel
  55   "start time",
  56   "answer time",
  57   "end time",
  58   duration,             // Duration is the whole length that the entire call lasted. ie. call rx'd to hangup
  59                         // "end time" minus "start time"
  60   billable seconds,     // the duration that a call was up after other end answered which will be <= to duration
  61                         // "end time" minus "answer time"
  62   "disposition",        // ANSWERED, NO ANSWER, BUSY
  63   "amaflags",           // DOCUMENTATION, BILL, IGNORE etc, specified on a per channel basis like accountcode.
  64   "uniqueid",           // unique call identifier
  65   "userfield"           // user field set via SetCDRUserField
  66 */
  67
  68 static char *desc = "Comma Separated Values CDR Backend";
  69
  70 static char *name = "csv";
  71
  72 static FILE *mf = NULL;
  73
  74 static int append_string(char *buf, char *s, int len)
  75 {
  76         int pos = strlen(buf);
  77         int spos = 0;
  78         int error = 0;
  79         if (pos >= len - 4)
  80                 return -1;
  81         buf[pos++] = '\"';
  82         error = -1;
  83         while(pos < len - 3) {
  84                 if (!s[spos]) {
  85                         error = 0;
  86                         break;
  87                 }
  88                 if (s[spos] == '\"')
  89                         buf[pos++] = '\"';
  90                 buf[pos++] = s[spos];
  91                 spos++;
  92         }
  93         buf[pos++] = '\"';
  94         buf[pos++] = ',';
  95         buf[pos++] = '\0';
  96         return error;
  97 }
  98
  99 static int append_int(char *buf, int s, int len)
 100 {
 101         char tmp[32];
 102         int pos = strlen(buf);
 103         snprintf(tmp, sizeof(tmp), "%d", s);
 104         if (pos + strlen(tmp) > len - 3)
 105                 return -1;
 106         strncat(buf, tmp, len);
 107         pos = strlen(buf);
 108         buf[pos++] = ',';
 109         buf[pos++] = '\0';
 110         return 0;
 111 }
 112
 113 static int append_date(char *buf, struct timeval tv, int len)
 114 {
 115         char tmp[80];
 116         struct tm tm;
 117         time_t t;
 118         t = tv.tv_sec;
 119         if (strlen(buf) > len - 3)
 120                 return -1;
 121         if (!tv.tv_sec && !tv.tv_usec) {
 122                 strncat(buf, ",", len);
 123                 return 0;
 124         }
 125         localtime_r(&t,&tm);
 126         strftime(tmp, sizeof(tmp), DATE_FORMAT, &tm);
 127         return append_string(buf, tmp, len);
 128 }
 129
 130 static int build_csv_record(char *buf, int len, struct ast_cdr *cdr)
 131 {
 132
 133         buf[0] = '\0';
 134         /* Account code */
 135         append_string(buf, cdr->accountcode, len);
 136         /* Source */
 137         append_string(buf, cdr->src, len);
 138         /* Destination */
 139         append_string(buf, cdr->dst, len);
 140         /* Destination context */
 141         append_string(buf, cdr->dcontext, len);
 142         /* Caller*ID */
 143         append_string(buf, cdr->clid, len);
 144         /* Channel */
 145         append_string(buf, cdr->channel, len);
 146         /* Destination Channel */
 147         append_string(buf, cdr->dstchannel, len);
 148         /* Last Application */
 149         append_string(buf, cdr->lastapp, len);
 150         /* Last Data */
 151         append_string(buf, cdr->lastdata, len);
 152         /* Start Time */
 153         append_date(buf, cdr->start, len);
 154         /* Answer Time */
 155         append_date(buf, cdr->answer, len);
 156         /* End Time */
 157         append_date(buf, cdr->end, len);
 158         /* Duration */
 159         append_int(buf, cdr->duration, len);
 160         /* Billable seconds */
 161         append_int(buf, cdr->billsec, len);
 162         /* Disposition */
 163         append_string(buf, ast_cdr_disp2str(cdr->disposition), len);
 164         /* AMA Flags */
 165         append_string(buf, ast_cdr_flags2str(cdr->amaflags), len);
 166
 167 #ifdef CSV_LOGUNIQUEID
 168         /* Unique ID */
 169         append_string(buf, cdr->uniqueid, len);
 170 #endif
 171 #ifdef CSV_LOGUSERFIELD
 172         /* append the user field */
 173         append_string(buf, cdr->userfield,len);
 174 #endif
 175         /* If we hit the end of our buffer, log an error */
 176         if (strlen(buf) < len - 5) {
 177                 /* Trim off trailing comma */
 178                 buf[strlen(buf) - 1] = '\0';
 179                 strncat(buf, "\n", len);
 180                 return 0;
 181         }
 182         return -1;
 183 }
 184
 185 static int writefile(char *s, char *acc)
 186 {
 187         char tmp[256];
 188         FILE *f;
 189         if (strchr(acc, '/') || (acc[0] == '.')) {
 190                 ast_log(LOG_WARNING, "Account code '%s' insecure for writing file\n", acc);
 191                 return -1;
 192         }
 193         snprintf(tmp, sizeof(tmp), "%s/%s/%s.csv", (char *)ast_config_AST_LOG_DIR,CSV_LOG_DIR, acc);
 194         f = fopen(tmp, "a");
 195         if (!f)
 196                 return -1;
 197         fputs(s, f);
 198         fclose(f);
 199         return 0;
 200 }
 201
 202
 203 static int csv_log(struct ast_cdr *cdr)
 204 {
 205         /* Make sure we have a big enough buf */
 206         char buf[1024];
 207         char csvmaster[AST_CONFIG_MAX_PATH];
 208         snprintf((char *)csvmaster,sizeof(csvmaster)-1,"%s/%s/%s",(char *)ast_config_AST_LOG_DIR,CSV_LOG_DIR,CSV_MASTER);
 209 #if 0
 210         printf("[CDR] %s ('%s' -> '%s') Dur: %ds Bill: %ds Disp: %s Flags: %s Account: [%s]\n", cdr->channel, cdr->src, cdr->dst, cdr->duration, cdr->billsec, ast_cdr_disp2str(cdr->disposition), ast_cdr_flags2str(cdr->amaflags), cdr->accountcode);
 211 #endif
 212         if (build_csv_record(buf, sizeof(buf), cdr)) {
 213                 ast_log(LOG_WARNING, "Unable to create CSV record in %d bytes.  CDR not recorded!\n", (int)sizeof(buf));
 214         } else {
 215                 /* because of the absolutely unconditional need for the
 216                    highest reliability possible in writing billing records,
 217                    we open write and close the log file each time */
 218                 mf = fopen(csvmaster, "a");
 219                 if (!mf) {
 220                         ast_log(LOG_ERROR, "Unable to re-open master file %s\n", csvmaster);
 221                 }
 222                 if (mf) {
 223                         fputs(buf, mf);
 224                         fflush(mf); /* be particularly anal here */
 225                         fclose(mf);
 226                         mf = NULL;
 227                 }
 228                 if (!ast_strlen_zero(cdr->accountcode)) {
 229                         if (writefile(buf, cdr->accountcode))
 230                                 ast_log(LOG_WARNING, "Unable to write CSV record to account file '%s'\n", cdr->accountcode);
 231                 }
 232         }
 233         return 0;
 234 }
 235
 236 char *description(void)
 237 {
 238         return desc;
 239 }
 240
 241 int unload_module(void)
 242 {
 243         if (mf)
 244                 fclose(mf);
 245         ast_cdr_unregister(name);
 246         return 0;
 247 }
 248
 249 int load_module(void)
 250 {
 251         int res;
 252
 253         res = ast_cdr_register(name, desc, csv_log);
 254         if (res) {
 255                 ast_log(LOG_ERROR, "Unable to register CSV CDR handling\n");
 256                 if (mf)
 257                         fclose(mf);
 258         }
 259         return res;
 260 }
 261
 262 int reload(void)
 263 {
 264         return 0;
 265 }
 266
 267 int usecount(void)
 268 {
 269         return 0;
 270 }
 271
 272 char *key()
 273 {
 274         return ASTERISK_GPL_KEY;
 275 }