350 lines
11 KiB
C++
350 lines
11 KiB
C++
/*
|
|
* FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application Call Detail Recorder module
|
|
* Copyright 2006, Author: Yossi Neiman of Cartis Solutions, Inc. <freeswitch AT cartissolutions.com>
|
|
*
|
|
* Version: MPL 1.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application Call Detail Recorder module
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Yossi Neiman <freeswitch AT cartissolutions.com>
|
|
* Portions created by the Initial Developer are Copyright (C)
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*
|
|
* Yossi Neiman <freeswitch AT cartissolutions.com>
|
|
*
|
|
* Description: This C++ source file describes the CsvCDR class that handles processing CDRs to a CSV format.
|
|
* This is the standard CSV module, and has a list of predefined variables to log out which can be
|
|
* added to, but never have the default ones removed. If you want to use one that allows you to explicity
|
|
* set all data variables to be logged and in what order, then this is not the class you want to use, and
|
|
* one will be coming in the future to do just that.
|
|
*
|
|
* csvcdr.cpp
|
|
*
|
|
*/
|
|
|
|
#include <switch.h>
|
|
#include "csvcdr.h"
|
|
#include <string>
|
|
|
|
|
|
CsvCDR::CsvCDR() : BaseCDR()
|
|
{
|
|
memset(formattedcallstartdate,0,100);
|
|
memset(formattedcallanswerdate,0,100);
|
|
memset(formattedcallenddate,0,100);
|
|
}
|
|
|
|
CsvCDR::CsvCDR(switch_mod_cdr_newchannel_t *newchannel) : BaseCDR(newchannel)
|
|
{
|
|
memset(formattedcallstartdate,0,100);
|
|
memset(formattedcallanswerdate,0,100);
|
|
memset(formattedcalltransferdate,0,100);
|
|
memset(formattedcallenddate,0,100);
|
|
|
|
if(newchannel != 0)
|
|
{
|
|
switch_time_exp_t tempcallstart, tempcallanswer, tempcalltransfer, tempcallend;
|
|
memset(&tempcallstart,0,sizeof(tempcallstart));
|
|
memset(&tempcalltransfer,0,sizeof(tempcalltransfer));
|
|
memset(&tempcallanswer,0,sizeof(tempcallanswer));
|
|
memset(&tempcallend,0,sizeof(tempcallend));
|
|
convert_time(&tempcallstart, callstartdate);
|
|
convert_time(&tempcallanswer, callanswerdate);
|
|
convert_time(&tempcalltransfer, calltransferdate);
|
|
convert_time(&tempcallend, callenddate);
|
|
|
|
// Format the times
|
|
switch_size_t retsizecsd, retsizecad, retsizectd, retsizeced; //csd == callstartdate, cad == callanswerdate, ced == callenddate, ceff == callenddate_forfile
|
|
char format[] = "%Y-%m-%d %H:%M:%S";
|
|
switch_strftime(formattedcallstartdate,&retsizecsd,sizeof(formattedcallstartdate),format,&tempcallstart);
|
|
switch_strftime(formattedcallanswerdate,&retsizecad,sizeof(formattedcallanswerdate),format,&tempcallanswer);
|
|
switch_strftime(formattedcalltransferdate,&retsizectd,sizeof(formattedcalltransferdate),format,&tempcalltransfer);
|
|
switch_strftime(formattedcallenddate,&retsizeced,sizeof(formattedcallenddate),format,&tempcallend);
|
|
|
|
if(chanvars_fixed_list.size() > 0)
|
|
process_channel_variables(chanvars_fixed_list,newchannel->channel);
|
|
|
|
if(chanvars_supp_list.size() > 0)
|
|
process_channel_variables(chanvars_supp_list,chanvars_fixed_list,newchannel->channel,repeat_fixed_in_supp);
|
|
}
|
|
}
|
|
|
|
CsvCDR::~CsvCDR()
|
|
{
|
|
|
|
}
|
|
|
|
bool CsvCDR::activated=0;
|
|
bool CsvCDR::logchanvars=0;
|
|
bool CsvCDR::connectionstate=0;
|
|
bool CsvCDR::repeat_fixed_in_supp=0;
|
|
modcdr_time_convert_t CsvCDR::convert_time = switch_time_exp_lt;
|
|
std::string CsvCDR::outputfile_path;
|
|
std::ofstream CsvCDR::outputfile;
|
|
std::ofstream::pos_type CsvCDR::filesize_limit = (10 * 1024 * 1024); // Default file size is 10MB
|
|
std::list<std::string> CsvCDR::chanvars_fixed_list;
|
|
std::list<std::string> CsvCDR::chanvars_supp_list;
|
|
std::string CsvCDR::display_name = "CsvCDR - The simple comma separated values CDR logger";
|
|
|
|
void CsvCDR::connect(switch_xml_t& cfg, switch_xml_t& xml, switch_xml_t& settings, switch_xml_t& param)
|
|
{
|
|
switch_console_printf(SWITCH_CHANNEL_LOG, "CsvCDR::connect() - Loading configuration file.\n");
|
|
activated = 0; // Set it as inactive initially
|
|
connectionstate = 0; // Initialize it to false to show that we aren't yet connected.
|
|
|
|
if ((settings = switch_xml_child(cfg, "csvcdr")))
|
|
{
|
|
int count_config_params = 0; // Need to make sure all params are set before we load
|
|
for (param = switch_xml_child(settings, "param"); param; param = param->next)
|
|
{
|
|
char *var = (char *) switch_xml_attr_soft(param, "name");
|
|
char *val = (char *) switch_xml_attr_soft(param, "value");
|
|
|
|
if (!strcmp(var, "path"))
|
|
{
|
|
if(val != 0)
|
|
outputfile_path = val;
|
|
count_config_params++;
|
|
}
|
|
else if (!strcmp(var, "chanvars_supp"))
|
|
{
|
|
if(val != 0)
|
|
{
|
|
std::string unparsed;
|
|
unparsed = val;
|
|
if(unparsed.size() > 0)
|
|
{
|
|
bool fixed = 0;
|
|
parse_channel_variables_xconfig(unparsed,chanvars_supp_list,fixed);
|
|
logchanvars=1;
|
|
}
|
|
}
|
|
}
|
|
else if (!strcmp(var, "chanvars_fixed"))
|
|
{
|
|
if(val != 0)
|
|
{
|
|
std::string unparsed;
|
|
unparsed = val;
|
|
if(unparsed.size() > 0)
|
|
{
|
|
bool fixed = 1;
|
|
parse_channel_variables_xconfig(unparsed,chanvars_fixed_list,fixed);
|
|
logchanvars=1;
|
|
}
|
|
}
|
|
}
|
|
else if (!strcmp(var, "repeat_fixed_in_supp"))
|
|
{
|
|
if(!strcmp(val,"1"))
|
|
repeat_fixed_in_supp = 1;
|
|
else if (!strcmp(val,"y") || !strcmp(val,"y"))
|
|
repeat_fixed_in_supp = 0;
|
|
}
|
|
else if (!strcmp(var, "size_limit"))
|
|
{
|
|
if(val != 0)
|
|
{
|
|
filesize_limit = atoi(val) * 1024 * 1024; // Value is in MB
|
|
std::cout << "File size limit from config file is " << filesize_limit << " byte(s)." << std::endl;
|
|
}
|
|
}
|
|
else if(!strcmp(var,"timezone"))
|
|
{
|
|
if(!strcmp(val,"utc"))
|
|
convert_time = switch_time_exp_gmt;
|
|
else if(!strcmp(val,"local"))
|
|
convert_time = switch_time_exp_lt;
|
|
else
|
|
{
|
|
switch_console_printf(SWITCH_CHANNEL_LOG,"Invalid configuration parameter for timezone. Possible values are utc and local. You entered: %s\nDefaulting to local.\n",val);
|
|
convert_time = switch_time_exp_lt;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(count_config_params > 0)
|
|
{
|
|
open_file();
|
|
if(outputfile.good())
|
|
{
|
|
activated = 1;
|
|
switch_console_printf(SWITCH_CHANNEL_LOG,"CsvCDR activated, log rotation will occur at or after %d MB\n",(int)(filesize_limit >> 20));
|
|
}
|
|
}
|
|
else
|
|
switch_console_printf(SWITCH_CHANNEL_LOG,"CsvCDR::connect(): You did not specify the minimum parameters for using this module. You must specify at least a path to have the records logged to.\n");
|
|
}
|
|
}
|
|
|
|
void CsvCDR::check_file_size_and_open()
|
|
{
|
|
// Test if the file has been opened or not
|
|
if(outputfile)
|
|
{
|
|
if(outputfile.tellp() > filesize_limit)
|
|
outputfile.close();
|
|
}
|
|
|
|
if (!outputfile)
|
|
{
|
|
open_file();
|
|
}
|
|
}
|
|
|
|
void CsvCDR::open_file()
|
|
{
|
|
switch_time_t now = switch_time_now();
|
|
switch_time_exp_t now_converted;
|
|
memset(&now_converted,0,sizeof(now_converted));
|
|
|
|
switch_time_exp_lt(&now_converted,now);
|
|
|
|
switch_size_t retsize;
|
|
char format[] = "%Y-%m-%d-%H-%M-%S";
|
|
char formatteddate[100];
|
|
memset(formatteddate,0,100);
|
|
switch_strftime(formatteddate,&retsize,100,format,&now_converted);
|
|
|
|
std::string filename = outputfile_path;
|
|
filename.append(SWITCH_PATH_SEPARATOR);
|
|
filename.append(formatteddate);
|
|
filename.append(".csv");
|
|
outputfile.clear();
|
|
|
|
outputfile.open(filename.c_str(),std::ios_base::app|std::ios_base::binary);
|
|
if(outputfile.fail())
|
|
{
|
|
switch_console_printf(SWITCH_CHANNEL_LOG,"Could not open the CSV file %s . CsvCDR logger will not be functional until this is resolved and a reload is issued. Failbit is set to %d.\n",filename.c_str(),outputfile.fail());
|
|
activated = 0;
|
|
}
|
|
else
|
|
{
|
|
outputfile << "callstartdate,formattedcallstartdate,callanswerdate,formattedcallanswerdate,calltransferdate,formattedcalltransferdate,callendate,formattedcallenddate,hangupcause_text,hangupcause,clid,originated,dialplan,myuuid,destuuid,src,dst,srcchannel,dstchannel,ani,aniii,network_address,lastapp,lastdata,billusec,disposition,amaflags";
|
|
if(chanvars_fixed_list.size())
|
|
{
|
|
std::list<std::string>::iterator iItr, iEnd;
|
|
for(iItr = chanvars_fixed_list.begin(),iEnd = chanvars_fixed_list.end(); iItr != iEnd; iItr++)
|
|
outputfile << "," << *iItr;
|
|
}
|
|
|
|
if(logchanvars)
|
|
outputfile << ",chanvars_supp";
|
|
|
|
outputfile << std::endl;
|
|
}
|
|
}
|
|
|
|
bool CsvCDR::process_record()
|
|
{
|
|
check_file_size_and_open();
|
|
bool retval = 0;
|
|
|
|
// Format the call record and proceed from here...
|
|
outputfile << "\"" << callstartdate << "\",\"";
|
|
outputfile << formattedcallstartdate << "\",\"";
|
|
outputfile << callanswerdate << "\",\"";
|
|
outputfile << formattedcallanswerdate << "\",\"";
|
|
outputfile << calltransferdate << "\",\"";
|
|
outputfile << formattedcalltransferdate << "\",\"";
|
|
outputfile << callenddate << "\",\"";
|
|
outputfile << formattedcallenddate << "\",\"";
|
|
outputfile << hangupcause_text << "\",\"";
|
|
outputfile << hangupcause << "\",\"";
|
|
outputfile << clid << "\",\"";
|
|
outputfile << originated << "\",\"";
|
|
outputfile << dialplan << "\",\"";
|
|
outputfile << myuuid << "\",\"";
|
|
outputfile << destuuid << "\",\"";
|
|
outputfile << src << "\",\"";
|
|
outputfile << dst << "\",\"";
|
|
outputfile << srcchannel << "\",\"";
|
|
outputfile << dstchannel << "\",\"";
|
|
outputfile << ani << "\",\"";
|
|
outputfile << aniii << "\",\"";
|
|
outputfile << network_addr << "\",\"";
|
|
outputfile << lastapp << "\",\"";
|
|
outputfile << lastdata << "\",\"";
|
|
outputfile << billusec << "\",\"";
|
|
outputfile << disposition << "\",\"";
|
|
outputfile << amaflags << "\"";
|
|
|
|
// Now to process chanvars, fixed ones first
|
|
if(chanvars_fixed.size() > 0 )
|
|
{
|
|
std::list<std::pair<std::string,std::string> >::iterator iItr, iEnd;
|
|
for(iItr = chanvars_fixed.begin(), iEnd = chanvars_fixed.end(); iItr != iEnd; iItr++)
|
|
outputfile << ",\"" << iItr->second << "\"";
|
|
}
|
|
|
|
if(chanvars_supp.size() > 0 )
|
|
{
|
|
std::map<std::string,std::string>::iterator iItr,iEnd;
|
|
for(iItr = chanvars_supp.begin(), iEnd = chanvars_supp.end() ; iItr != iEnd; iItr++)
|
|
outputfile << ",\"" << iItr->first << "=" << iItr->second << "\"";
|
|
}
|
|
outputfile << std::endl;
|
|
retval = 1;
|
|
|
|
return retval;
|
|
}
|
|
|
|
bool CsvCDR::is_activated()
|
|
{
|
|
return activated;
|
|
}
|
|
|
|
void CsvCDR::tempdump_record()
|
|
{
|
|
|
|
}
|
|
|
|
void CsvCDR::reread_tempdumped_records()
|
|
{
|
|
|
|
}
|
|
|
|
std::string CsvCDR::get_display_name()
|
|
{
|
|
return display_name;
|
|
}
|
|
|
|
void CsvCDR::disconnect()
|
|
{
|
|
outputfile.close();
|
|
activated = 0;
|
|
logchanvars = 0;
|
|
repeat_fixed_in_supp = 0;
|
|
outputfile_path.clear();
|
|
chanvars_fixed_list.clear();
|
|
chanvars_supp_list.clear();
|
|
connectionstate = 0;
|
|
switch_console_printf(SWITCH_CHANNEL_LOG,"Shutting down CsvCDR... Done!\n");
|
|
}
|
|
|
|
AUTO_REGISTER_BASECDR(CsvCDR);
|
|
|
|
/* For Emacs:
|
|
* Local Variables:
|
|
* mode:c++
|
|
* indent-tabs-mode:t
|
|
* tab-width:4
|
|
* c-basic-offset:4
|
|
* End:
|
|
* For VIM:
|
|
* vim:set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:
|
|
*/
|