/* * openser osp module.  * * This module enables openser to communicate with an Open Settlement  * Protocol (OSP) server.  The Open Settlement Protocol is an ETSI  * defined standard for Inter-Domain VoIP pricing, authorization * and usage exchange.  The technical specifications for OSP  * (ETSI TS 101 321 V4.1.1) are available at www.etsi.org. * * Uli Abend was the original contributor to this module. *  * Copyright (C) 2001-2005 Fhg Fokus * * This file is part of openser, a free SIP server. * * openser is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version * * openser is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA *  * History: * --------- *  2006-03-13  RR functions are loaded via API function (bogdan) */#include "usage.h"#include "sipheader.h"#include "destination.h"#include "osptoolkit.h"#include "../../sr_module.h"#include "../../usr_avp.h"#include "../../str.h"#include "../rr/api.h"#include <string.h>extern OSPTPROVHANDLE _provider;extern char* _device_ip;extern str ORIG_OSPDESTS_LABEL;extern struct rr_binds osp_rrb;int buildUsageFromDestination(OSPTTRANHANDLE transaction, osp_dest* dest, int last_code_for_previous_destination);int reportUsageFromDestination(OSPTTRANHANDLE transaction, osp_dest* dest);int reportUsageFromCooky(char* cooky, OSPTCALLID* call_id, int isOrig, struct sip_msg* msg);#define OSP_ORIG_COOKY "osp-o"#define OSP_TERM_COOKY "osp-t"#define RELEASE_SOURCE_ORIG 0#define RELEASE_SOURCE_TERM 1/* * * */void record_transaction_info(struct sip_msg* msg, OSPTTRANHANDLE transaction, char* uac, char* from, char* to, time_t time_auth, int isOrig){#define RTI_BUF_SIZE 1000	char buf[RTI_BUF_SIZE];	str s;	if (osp_rrb.add_rr_param==0) {		LOG(L_WARN,"WARNING:osp:record_transaction_info: add_rr_param "			"function is not found, can not record information about the "			"OSP transaction\n");		return;	}	s.s = buf;	s.len = snprintf(buf,RTI_BUF_SIZE,		";%s=t%llu_s%s_T%d",		(isOrig==1?OSP_ORIG_COOKY:OSP_TERM_COOKY),		get_transaction_id(transaction),		uac,		(unsigned int)time_auth);	if (s.len<0) {		LOG(L_ERR,"ERROR:osp:record_transaction_info: snprintf() failed\n");		return;	}	/* truncated? */	if (s.len >= RTI_BUF_SIZE)		s.len = RTI_BUF_SIZE -1;	DBG("osp:record_transaction_info: adding rr param '%s'\n",buf);	osp_rrb.add_rr_param( msg, &s);}void record_orig_transaction(struct sip_msg* msg, OSPTTRANHANDLE transaction, char* uac, char* from, char* to, time_t time_auth){	int isOrig = 1;	record_transaction_info(msg,transaction,uac,from,to,time_auth,isOrig);}void record_term_transaction(struct sip_msg* msg, OSPTTRANHANDLE transaction, char* uac, char* from, char* to, time_t time_auth){	int isOrig = 0;	record_transaction_info(msg,transaction,uac,from,to,time_auth,isOrig);}int reportospusage(struct sip_msg* msg, char* ignore1, char* ignore2){	int result = MODULE_RETURNCODE_FALSE;	char route_params[2000];	int  isOrig;	char *tmp;	char *token;	OSPTCALLID* call_id = NULL;	getCallId(msg, &call_id);	if (call_id!=NULL && getRouteParams(msg,route_params,sizeof(route_params))==0) {		for (token = strtok_r(route_params,";",&tmp);		     token;		     token = strtok_r(NULL,";",&tmp)) {			if (strncmp(token,OSP_ORIG_COOKY,strlen(OSP_ORIG_COOKY))==0) {				LOG(L_INFO,"osp: Reporting originating call duration usage for call-id '%.*s'\n",call_id->ospmCallIdLen,call_id->ospmCallIdVal);				isOrig = 1;				reportUsageFromCooky(token+strlen(OSP_ORIG_COOKY)+1, call_id, isOrig, msg);				result = MODULE_RETURNCODE_TRUE;			} else if (strncmp(token,OSP_TERM_COOKY,strlen(OSP_TERM_COOKY))==0) {				LOG(L_INFO,"osp: Reporting terminating call duration usage for call-id '%.*s'\n",call_id->ospmCallIdLen,call_id->ospmCallIdVal);				isOrig = 0;				reportUsageFromCooky(token+strlen(OSP_TERM_COOKY)+1, call_id, isOrig, msg);				result = MODULE_RETURNCODE_TRUE;			} else {				DBG("osp:reportusage: ignoring param '%s'\n",token);			}		}	}	if (call_id!=NULL) {		OSPPCallIdDelete(&call_id);	}	if (result==MODULE_RETURNCODE_FALSE) {		DBG("There is no OSP originating or terminating usage information\n");	}	return result;}int reportUsageFromCooky(char* cooky, OSPTCALLID* call_id, int isOrig, struct sip_msg* msg){	int errorCode = 0;	char *tmp;	char *token;	char name;	char *value;	unsigned long long transaction_id = 0;	char *user_agent_client = "";	time_t auth_time = -1;	time_t end_time = time(NULL);	int release_source;	char first_via[200];	char from[200];	char to[200];	char next_hop[200];	char *calling;	char *called;	char *terminator;	OSPTTRANHANDLE transaction_handle = -1;	DBG("osp:reportUsageFromCooky: '%s' isOrig '%d'\n",cooky,isOrig);	for (token = strtok_r(cooky,"_",&tmp);	     token;	     token = strtok_r(NULL,"_",&tmp)) {		name = *token;		value= token + 1;		switch (name) {			case 't':				transaction_id = atoll(value);				break;			case 'T':				auth_time = atoi(value);				break;			case 's':				user_agent_client = value;				break;			default:				LOG(L_ERR,"osp:reportUsageFromCooky: unexpected tag '%c' / value '%s'\n",name,value);				break;		}	}	getSourceAddress(msg,first_via,sizeof(first_via));	getFromUserpart( msg,from,sizeof(from));	getToUserpart(   msg,to,sizeof(to));	getNextHop(      msg,next_hop,sizeof(next_hop));	if (strcmp(first_via,user_agent_client)==0) {		LOG(L_INFO,"osp: Originator '%s' released the call, call-id '%.*s', transaction-id '%lld'\n",			first_via,call_id->ospmCallIdLen,call_id->ospmCallIdVal,transaction_id);		release_source = RELEASE_SOURCE_ORIG;		calling = from;		called = to;		terminator = next_hop;	} else {		LOG(L_INFO,"osp: Terminator '%s' released the cal, call-id '%.*s', transaction-id '%lld'\n",			first_via,call_id->ospmCallIdLen,call_id->ospmCallIdVal,transaction_id);		release_source = RELEASE_SOURCE_TERM;		calling = to;		called = from;		terminator = first_via;	}	errorCode = OSPPTransactionNew(_provider, &transaction_handle);	DBG("osp:reportUsageFromCooky: created new transaction handle %d / code %d\n",transaction_handle,errorCode);	errorCode = OSPPTransactionBuildUsageFromScratch(		transaction_handle,		transaction_id,		isOrig==1?OSPC_SOURCE:OSPC_DESTINATION,		isOrig==1?_device_ip:user_agent_client,		isOrig==1?terminator:_device_ip,		isOrig==1?user_agent_client:"",		"",		calling,		OSPC_E164,		called,		OSPC_E164,		call_id->ospmCallIdLen,		call_id->ospmCallIdVal,		(enum OSPEFAILREASON)0,		NULL,		NULL);	DBG("osp:reportUsageFromCooky: started building usage handle %d / code %d\n",transaction_handle,errorCode);	report_usage(		transaction_handle,		10016,		end_time - auth_time,		auth_time,		end_time,		0,0,		0,0,		release_source);	return errorCode;}void reportOrigCallSetUpUsage(){	osp_dest*       dest          = NULL;	osp_dest*       last_used_dest= NULL;	struct usr_avp* dest_avp      = NULL;	int_str         dest_val;	int             errorCode     = 0;	OSPTTRANHANDLE  transaction   = -1;	int             last_code_for_previous_destination = 0;	DBG("osp: reportOrigCallSetUpUsage: IN\n");	errorCode = OSPPTransactionNew(_provider, &transaction);	for (	dest_avp=search_first_avp(AVP_NAME_STR|AVP_VAL_STR,(int_str)ORIG_OSPDESTS_LABEL,NULL,0);		dest_avp != NULL;		dest_avp=search_next_avp(dest_avp,NULL)) {		get_avp_val(dest_avp, &dest_val);		/* osp dest is wrapped in a string */		dest = (osp_dest *)dest_val.s.s;		if (dest->used == 1) {			if (dest->reported == 1) {				DBG("osp: reportOrigCallSetUpUsage: source usage has already been reported\n");				break;			}			DBG("osp: reportOrigCallSetUpUsage: iterating through a used destination\n");			dumbDestDebugInfo(dest);			last_used_dest = dest;			errorCode = buildUsageFromDestination(transaction,dest,last_code_for_previous_destination);			last_code_for_previous_destination = dest->last_code;		} else {			DBG("osp: reportOrigCallSetUpUsage: this destination has not been used, breaking out\n");			break;		}	}	if (last_used_dest) {		LOG(L_INFO,"osp: Reporting originating call set-up usage for call-id '%.*s' transaction-id '%lld'\n",			last_used_dest->sizeofcallid,last_used_dest->callid,last_used_dest->tid);		errorCode = reportUsageFromDestination(transaction, last_used_dest);	} else {		/* If a toolkit transaction handle was created, but we did not find		 * any destinations to report, we need to release the handle.  Otherwise,		 * the 'reportUsageFromDestination' will release it.		 */		OSPPTransactionDelete(transaction);	}	DBG("osp: reportOrigCallSetUpUsage: OUT\n");}void reportTermCallSetUpUsage(){	osp_dest*       dest          = NULL;	int             errorCode     = 0;	OSPTTRANHANDLE  transaction   = -1;	DBG("osp: reportTermCallSetUpUsage: IN\n");	if ((dest=getTermDestination())) {		if (dest->reported == 0) {			LOG(L_INFO,"osp: Reporting terminating call set-up usage for call-id '%.*s' transaction-id '%lld'\n",				dest->sizeofcallid,dest->callid,dest->tid);			errorCode = OSPPTransactionNew(_provider, &transaction);			errorCode = buildUsageFromDestination(transaction,dest,0);			errorCode = reportUsageFromDestination(transaction,dest);		} else {			DBG("osp: reporTermtCallSetUpUsage: destination usage has already been reported\n");		}	} else {		DBG("osp: reportTermCallSetUpUsage: There is no term dest to report\n");	}	DBG("osp: reportTermCallSetUpUsage: OUT\n");}int buildUsageFromDestination(OSPTTRANHANDLE transaction, osp_dest* dest, int last_code_for_previous_destination){	int errorCode;	dest->reported = 1;	errorCode = OSPPTransactionBuildUsageFromScratch(		transaction,		dest->tid,		dest->type,		dest->source,		dest->destination,		dest->sourcedevice,		dest->destinationdevice,		dest->callingnumber,		OSPC_E164,		dest->callednumber,		OSPC_E164,		dest->sizeofcallid,		dest->callid,		(enum OSPEFAILREASON)last_code_for_previous_destination,		NULL,		NULL);	return errorCode;}int reportUsageFromDestination(OSPTTRANHANDLE transaction, osp_dest* dest){	report_usage(		transaction,		/* In - Transaction handle */		dest->last_code,	/* In - Release Code */			0,			/* In - Length of call */		dest->time_auth,	/* In - Call start time */		0,			/* In - Call end time */		dest->time_180,		/* In - Call alert time */		dest->time_200,		/* In - Call connect time */		dest->time_180 ? 1:0,	/* In - Is PDD Info present */ 					/* In - Post Dial Delay */		dest->time_180 ? dest->time_180 - dest->time_auth : 0,		0);	return 0;}