sessionobject.cpp

linux 下的sgip 协议中的session object 实现源代码

/****************************************************************
Copyright ?, 1989-2002, Hisunsray Tech. Co., Ltd.
File name: SessionObject.cpp
Author: lizhigang
Version:  V3.0.0.0#20030320-1
Date: 2003-03-20
Description:
History:
*****************************************************************/


#ifndef _SOLARIS
//#include "StdAfx.h"
#endif

#include "SessionObject.h"
#include "SMGModule.h"
#include "RTCStime.h"
#include "PublicDefine.h"
#include "IDBProxy.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define DEFAULT_DBTIMEOUT_VALUE			30000  //30秒

extern void PrintConsole(LPCTSTR ModuleName,char* fmt,...);

extern char * strupr(char *mystr);
extern char * strlwr(char *mystr);

TSessionObject::TSessionObject(TSMGModule* Owner, RTCS_CTuint SessionID)
:TRealtimeObject((TBaseService *)Owner, SessionID )
{
	m_SessionID = SessionID;
	m_CreateTime = time(NULL);
	m_pOwner = Owner;
	for(int i=0; i<MAX_FIELD_COUNT; i++)
		memset(m_Field[i], 0, sizeof(char)*(MAX_FIELD_LEN+1));

	m_PacketSender = 0;
	m_PacketSenderObj = 0;
	m_PacketReceiverObj	 = 0;
	m_CurrResult = 0;
	m_CommandID = 0;

	m_TimerID = 0;
	m_DBTimeOutValue = DEFAULT_DBTIMEOUT_VALUE;
	m_pOwner->logfile->Trace(1, "TSessionObject::TSessionObject\n");
}

TSessionObject::~TSessionObject()
{
	m_pOwner->logfile->Trace(1, "TSessionObject::~TSessionObject\n");
}

TSessionObject& TSessionObject::operator=(TSessionObject& obj)
{
	m_SessionID = obj.m_SessionID;
	m_CreateTime = obj.m_CreateTime;
	m_pOwner = obj.m_pOwner; 
	for(int i=0; i<MAX_FIELD_COUNT; i++)
		strcpy(m_Field[i], obj.m_Field[i]);

	m_PacketSender = obj.m_PacketSender;
	m_PacketSenderObj = obj.m_PacketSenderObj;
	m_PacketReceiverObj	 = obj.m_PacketReceiverObj;
	m_CurrResult = obj.m_CurrResult;
	m_CommandID = obj.m_CommandID; 

	m_TimerID = obj.m_TimerID;
	m_DBTimeOutValue = obj.m_DBTimeOutValue; 

	return *this;
}

void TSessionObject::Snapshot(FILE *fp)
{
	if(!fp)
		return;
	RTCS_CTime disptime(m_CreateTime);
	RTCS_CTstring dispstr;
	disptime.Format(dispstr);
	fprintf(fp, "\t SessionID=%d, CreateTime=%s\n", m_SessionID, (LPCTSTR)dispstr);

	fprintf(fp, "\t\t m_PacketSender=%u, m_PacketSenderObj=%u, m_PacketReceiverObj=%u, m_CurrResult=%u, m_CommandID=%u\n",
		    m_PacketSender, m_PacketSenderObj, m_PacketReceiverObj, m_CurrResult, m_CommandID);

}


void * TSessionObject::GetSysVarAddr(RTCS_CTuint index,RTCS_CTbyte &vtype)
{
	switch( index )
	{
		case _FIELD1:
		case _FIELD2:
		case _FIELD3:
		case _FIELD4:
		case _FIELD5:
		case _FIELD6:
		case _FIELD7:
		case _FIELD8:
		case _FIELD9:
		case _FIELD10:
		case _FIELD11:
		case _FIELD12:
		case _FIELD13:
		case _FIELD14:
		case _FIELD15:
		case _FIELD16:
		case _FIELD17:
		case _FIELD18:
		case _FIELD19:
		case _FIELD20:
		case _FIELD21:
		case _FIELD22:
		case _FIELD23:
		case _FIELD24:
		case _FIELD25:
		case _FIELD26:
		case _FIELD27:
		case _FIELD28:
		case _FIELD29:
		case _FIELD30:
		case _FIELD31:
		case _FIELD32:
			vtype = S_P;
			return (void *)m_Field[index-_FIELD1];

		case _SessionID:
			vtype = I_P;
			return (void *)&m_SessionID;

		case _CreateTime:
			vtype = I_P;
			return (void *)&m_CreateTime;

		case _PacketSender:
			vtype = I_P;
			return (void *)&m_PacketSender;

		case _PacketSenderObj:
			vtype = I_P;
			return (void *)&m_PacketSenderObj;

		case _PacketReceiverObj:
			vtype = I_P;
			return (void *)&m_PacketReceiverObj;

		case _Result:
			vtype = I_P;
			return (void *)&m_CurrResult;

		case _SMASrcterminalid:
			vtype = S_P;
			return &SMA_Srcterminalid[0];

		case _SMADestUsrtl:
			vtype = I_P;
			return &SMA_DestUsrtl;

		case _SMADestterminalid:
			vtype = S_P;
			return &SMA_Destterminalid[0];

		case _SMAMsgLength:
			vtype = I_P;
			return &SMA_MsgLength;

		case _SMAMsgContent:
			vtype = S_P;
			return &SMA_MsgContent[0];

		case _TempSysStrVar:
			vtype = S_P;
			return &m_TempSysStrVar[0];

		default:
			break;
	}

	return TRealtimeObject::GetSysVarAddr ( index , vtype );

}

void TSessionObject::ClearTimer(RTCS_CTuint TimerID)
{
	m_pOwner->ClearTimer(TimerID);
}

RTCS_CTuint TSessionObject::SetTimer(RTCS_CTuint owner, RTCS_CTuint interval, RTCS_CTuint attr)
{
	return m_pOwner->SetTimer(owner, interval, attr);
}

RTCS_CTuint TSessionObject::PostMessage(RTCS_CTpdu pdu)
{
	return m_pOwner->PostMessage(pdu);
}

RTCS_CTuint TSessionObject::PostMessageToSelf(RTCS_CTuint messageID, RTCS_CTuint status)
{
	RTCS_CTpdu pdu;
	pdu.messageID = messageID;
	pdu.status = status;
	pdu.sender = m_pOwner->GetGOR();
	pdu.receiver = pdu.sender;
	pdu.receiverObj = m_SessionID;

	return m_pOwner->PostMessage(pdu);
}

void TSessionObject::SMAInitData()
{
	memset(SMA_Srcterminalid,0,CMPP_SIZE_Src_terminal_id + 1);
	SMA_DestUsrtl = 0;
	memset(SMA_Destterminalid,0,CMPP_SIZE_Dest_terminal_id + 1);
	SMA_MsgLength = 0;
	memset(SMA_MsgContent,0,CMPP_SIZE_Msg_Content);
}

/************************************************************************************
	DataAccess(TArg *argv)
	参数1：数据操作模板号
	参数2：整型参数，数据源索引号 0 base
	参数3：整形参数，超时时长, 以毫秒为单位
	功能：数据操作，(_FIELD1 - _FIELD32)是数据存取操作的参数值
	返回结果：
	evtReturn [0] 表示数据操作成功，数据结果存放在(_FIELD1 - _FIELD32)中
	其它返回表示失败，返回值存放在系统变量中_result中，事件表示方法为：evtReturn [-1]；
************************************************************************************/
RTCS_CTuint TSessionObject::DataAccess(TArg *argv)
{
	RTCS_CTpdu pdu;
	pdu.messageID = CmdRTCS_IDBP_DataAccess;
	pdu.sender = m_pOwner->GetGOR();
	pdu.senderObj = m_SessionID;

	pdu.receiver = m_pOwner->GetDataSource(*(argv[1].iptr));

	if(pdu.receiver == 0)
	{
		Return(-1);
		return RTCS_Error_OK;
	}
	
//	pdu.senderObj = TaskRefID;

	RTCS_CTstring field[MAX_FIELD_COUNT];
	RTCS_CTstringArray pfield = field;

	for(int i=0;i<MAX_FIELD_COUNT;i++)
	{
		field[i] = m_Field[i];
	}

	pdu.PutUInt(RTCS_IDBP_DataAccessID,*(argv[0].iptr));
	pdu.PutStringArray(RTCS_IDBP_ParamData,pfield,MAX_FIELD_COUNT);

	m_pOwner->PostMessage(pdu);
	
	switch(*(argv[0].iptr))
	{
	case 2:
		PrintConsole(m_pOwner->m_ModuleName, "流程模块->>应用服务器: 卡认证请求,卡号【%s】",
			(LPCTSTR)field[0]);
		break;
	case 7:
		PrintConsole(m_pOwner->m_ModuleName, "流程模块->>应用服务器: 缴费帐号认证,帐号【%s】,帐号类型【%s】",
			(LPCTSTR)field[0],(LPCTSTR)field[1]);
		break;
	case 8:
		PrintConsole(m_pOwner->m_ModuleName, "流程模块->>应用服务器: 缴费请求,卡号【%s】,帐号【%s】,帐号类型【%s】,金额【%s】",
			(LPCTSTR)field[0],(LPCTSTR)field[3],(LPCTSTR)field[4],(LPCTSTR)field[2]);
		break;
	default:
		PrintConsole(m_pOwner->m_ModuleName, "流程模块->>应用服务器: 未知的请求类型");
		break;				
	}
	
	StartTimer(*(argv[2].iptr));
	return RTCS_Error_OK;
}

/************************************************************************************
	_SubStr(TArg *argv)
	参数1：源字符串
	参数2：起始位置
	参数3：位数
	功能： 取字符串中指定长度的子串
	返回结果：返回的子串放在_TempSysStrVar中
************************************************************************************/
RTCS_CTuint TSessionObject::SubStr(TArg *argv)
{
	char* SourceStr =  argv[0].sptr;
	int   StartPos  = *argv[1].iptr;
	int   Len		= *argv[2].iptr;
	char* deststr   =  &m_TempSysStrVar[0];

	if (StartPos>strlen(SourceStr))
	{
		deststr[0] = '\0';
		return RTCS_Error_OK;
	}
	Len = (strlen(SourceStr) - StartPos) > Len ? Len:(strlen(SourceStr) - StartPos);

	strncpy(deststr, SourceStr+StartPos, Len);
	deststr[Len] = '\0';

	return RTCS_Error_OK;
}

/************************************************************************************
	_SubLen(TArg *argv)
	参数1：字符串长度
	参数2：源字符串
	功能： 求字符串的长度
	返回结果：返回值放在参数1中
************************************************************************************/
RTCS_CTuint TSessionObject::StrLen(TArg *argv)
{
	char* StrLen = argv[0].sptr;
	char* SourceStr = argv[1].sptr;
	
	memset(StrLen, 0, 10);
	sprintf(StrLen, "%d", strlen(SourceStr));

	return RTCS_Error_OK;
}

/************************************************************************************
	_ParseParam(TArg *argv)
	参数1：源字符串
	参数2：子串位置
	参数3：分隔符串
	功能： 取字符串中用分隔符分开的子串
	返回结果：返回的子串放在_TempSysStrVar中
************************************************************************************/
RTCS_CTuint TSessionObject::ParseParam(TArg *argv)
{
	char* parameter =  argv[0].sptr;
	int   index     = *argv[1].iptr;
	char* separator =  argv[2].sptr;
	char* deststr   =  &m_TempSysStrVar[0];
	char *temp=NULL ;
	char* p;
	size_t len;
	
	temp = new char[strlen(parameter)+1];
	strcpy(temp, parameter);
	p = temp;
	deststr[0] = '\0';
	
	int i = 1;
	while (*p)
	{
		len = strcspn(p, separator);
		if ( i == index )
		{
			int maxlen = (MAX_FIELD_LEN - 1) > len? len : (MAX_FIELD_LEN - 1);
			strncpy(deststr, p, maxlen);
			deststr[maxlen] = '\0';
		}
		p += len;
		if (*p)	p++;
//Modify For search two or more space 
		if (!strcmp(" ",separator))
			while ((*p) && (*p==' ')) p++;
//Modify End
		i++;
	}

	delete [] temp ;
	return RTCS_Error_OK;
}
/************************************************************************************