protutil.cpp

中间件编程,该程序用于传输客户端数据到服务器,可运行于WINDOWS2000,2003,XP,98等系统

}

inline void CCenterData::ReadDataFromFile(CFile *File,void *DataBuf,int BufLen)
{
	int byte=File->Read(DataBuf,BufLen);
	if(byte!=BufLen)
		CFileException::ThrowErrno(5);
}

BOOL CCenterData::LoadFromFile(CFile *File)
{                                              
//	char CheckSum=0;
	TRY{           
		ReadDataFromFile(File,sn,10);

		ReadDataFromFile(File,destination,4);
			
		ReadDataFromFile(File,source,4);	
		
		ReadDataFromFile(File,packettype,2);
		
		ReadDataFromFile(File,requesttype,2);
		
		ReadDataFromFile(File,oprcode,6);
		ReadDataFromFile(File,&messagelen,sizeof(messagelen));
		if((messagelen>0)&&(messagelen<300)){
			message=new char[messagelen];
			ReadDataFromFile(File,message,messagelen);
		}
		else
			CFileException::ThrowErrno(5);
			
		time_t atime;
		ReadDataFromFile(File,&atime,sizeof(atime));
		m_RequestTime=atime;
		ReadDataFromFile(File,&atime,sizeof(atime));	
		m_ReplyTime=atime;       

	}CATCH(CFileException,e){
		return FALSE;	
	}END_CATCH	
		return TRUE;
}

inline void CCenterData::SaveDataToFile(CFile *File,void *DataBuf,int BufLen)
{
	File->Write(DataBuf,BufLen);
}
         
BOOL CCenterData::SaveToFile(CFile *File)
{       
//		char CheckSum=0;
		ASSERT(File->m_hFile);
		SaveDataToFile(File,sn,10);
		SaveDataToFile(File,destination,4);
		SaveDataToFile(File,source,4);	          
		SaveDataToFile(File,packettype,2);
		SaveDataToFile(File,requesttype,2);
		SaveDataToFile(File,oprcode,6);
		SaveDataToFile(File,&messagelen,sizeof(messagelen));
		if(messagelen>0)
			SaveDataToFile(File,message,messagelen);	
		time_t atime;
		atime=m_RequestTime.GetTime();			
		SaveDataToFile(File,&atime,sizeof(time_t));
		atime=m_ReplyTime.GetTime();
		SaveDataToFile(File,&atime,sizeof(time_t));	
//		File->Write(&CheckSum,1);
		return TRUE;
}

void CCenterData::Serialize(CArchive &ar)
{
	CObject::Serialize(ar);
	if(ar.IsStoring())
	{  //store data
		ar.Write(sn,10);
		ar.Write(destination,4);
		ar.Write(source,4);	
		ar.Write(packettype,2);
		ar.Write(requesttype,2);
		ar.Write(oprcode,6);
		ar.Write(&messagelen,sizeof(messagelen));
		if(messagelen!=0)
           ar.Write(message,messagelen);
		ar<<m_RequestTime;
		ar<<m_ReplyTime;	
	}
	else{				 //load data
		ar.Read(sn,10);
		ar.Read(destination,4);
		ar.Read(source,4);	
		ar.Read(packettype,2);
		ar.Read(requesttype,2);
		ar.Read(oprcode,6);
		ar.Read(&messagelen,sizeof(messagelen));
		if(messagelen!=0){
			message=new char[messagelen];
			ar.Read(message,messagelen);
		}
		ar>>m_RequestTime;
		ar>>m_ReplyTime;	
	}
}

const void *CCenterData::GetSendPDU()
{
	if(m_SendPDU==NULL)
	{   //send has not been created
						   //create a PDU,not include checksum	
		m_SendPDULen=strlen(packettype)+strlen(sn)+
					strlen(requesttype)+strlen(oprcode)+
					strlen(source)+strlen(destination)+messagelen;
		m_SendPDU=new char[m_SendPDULen];
		ASSERT(m_SendPDU!=NULL);
		char *ptmp=(char *)m_SendPDU;
		memcpy(ptmp,packettype,	strlen(packettype));
		ptmp+=strlen(packettype);
		
		memcpy(ptmp,sn,strlen(sn));
		ptmp+=strlen(sn);
		
		memcpy(ptmp,requesttype,strlen(requesttype));
		ptmp+=strlen(requesttype);
		
		memcpy(ptmp,oprcode,strlen(oprcode));
		ptmp+=strlen(oprcode); 
		
		memcpy(ptmp,source,strlen(source));
		ptmp+=strlen(source); 
		
		memcpy(ptmp,destination,strlen(destination));
		ptmp += strlen(destination);

		memcpy(ptmp,message,messagelen);
	    	
	}
//	m_SendPDU[m_SendPDULen]='\0';
	return m_SendPDU;
}

WORD CCenterData::GetSendPDULen()
{          
	ASSERT(m_SendPDU);  //if the PDU hasn't been created,you shouldn't call this function
	return m_SendPDULen;
}

BOOL CCenterData::ReceivePDU(const void *InPDU,WORD InPDULen)
{
	char *ptmp=(char *)InPDU;
//	if(InPDULen>=28)
    {
	memcpy(packettype,ptmp,2); 
	memcpy(sn,ptmp+2,10);
	memcpy(requesttype,ptmp+12,2);
	memcpy(oprcode,ptmp+14,6);
	memcpy(source,ptmp+20,4);
	memcpy(destination ,ptmp+24,4);
	messagelen = InPDULen-28;
    if(messagelen>0)
      message = new char[messagelen];
	  memcpy(message ,ptmp+28,InPDULen-28);
	}
	return TRUE;    
}

void CCenterData::GetInputData(CCenterData *Data)
{
	CopyMemory(packettype,Data->packettype,2); 
	CopyMemory(sn,Data->sn,10);
	CopyMemory(requesttype,Data->requesttype,2);
	CopyMemory(oprcode,Data->oprcode,6);
	CopyMemory(source,Data->source,4);
	CopyMemory(destination ,Data->destination,4);
	messagelen=Data->messagelen;
	CopyMemory(message ,Data->message,messagelen);
}

BOOL CCenterData::IsDuplicated()
{
	if(!strcmp(message,"DUPLICATEDERROR"))
		return TRUE;
	else return FALSE;
}

unsigned long CCenterData::GetTimeSpan()
{
	CTimeSpan TimeSpan=m_ReplyTime-m_RequestTime;
	return TimeSpan.GetTotalSeconds();
}
/*********************************************************************/
//class CCServiceData
//
//Main data structure for protocol
/*********************************************************************/
IMPLEMENT_SERIAL(CCServiceData,CObject,1);
CCServiceData::CCServiceData(const void *OutBuffer,UINT16 OutBufLen,WORD UserId,
		BOOL bCritical,BOOL bReply,int TimeOutInterval)
{
//	char * tmpbuf = (char*)OutBuffer;
	m_bCritical=bCritical;   
	m_bReply=bReply;   
	
	ASSERT(OutBufLen);

//copy the data	    
	m_OutBufLen=OutBufLen;
	m_OutBuffer=new char[OutBufLen]; 
	//memcpy(m_OutBuffer,OutBuffer,m_OutBufLen);
	memcpy(m_OutBuffer,OutBuffer,m_OutBufLen);
	
	m_InBufLen=0;
	m_InBuffer=NULL;
	m_UserId=UserId;			

	m_SequenceNumber=0;
    m_RequestTime=CTime::GetCurrentTime();
    m_ReplyTime=m_RequestTime;
    
    m_SendPDULen=0;        //data of PDU
	m_SendPDU=NULL; 
	
	m_TimeOutInterval=TimeOutInterval;
	m_RetryCounter=0;	
	
//flag for recieve error  from network
	m_ReceiveError=0;
}

CCServiceData::CCServiceData()
{
	m_bCritical=FALSE;       //if data is critical,when send timeout,it should be save to HD
	m_bReply=FALSE;         //if data require reply,when receive data from network,call the
							//the user's function "OnReceive" 
	m_OutBufLen=0;
	m_OutBuffer=NULL;
	m_InBufLen=0;
	m_InBuffer=NULL;
	m_UserId=0;			//Id of Service User, every user has a distinct Id, it should >0
	
    m_SendPDULen=0;        //data of PDU
	m_SendPDU=NULL;            
	
	m_SequenceNumber=0;
	
//time out management
	m_TimeOutInterval=1000;   //ms
	m_RetryCounter=0;	

//flag for recieve error  from network
	m_ReceiveError=0;

}

void CCServiceData::GetInputData(CCServiceData *Data)
{
	m_InBufLen=Data->m_InBufLen;
	if(Data->m_InBufLen)
	{
		m_InBuffer=new char[m_InBufLen]; 
		memcpy(m_InBuffer,Data->m_InBuffer,m_InBufLen);
	}
}

void CCServiceData::Serialize(CArchive &ar)
{
	CObject::Serialize(ar);
	if(ar.IsStoring()){  //store data
		ar<<m_SequenceNumber;
		ar.Write(&m_bCritical,sizeof(m_bCritical));
		ar.Write(&m_bReply,sizeof(m_bReply));	
		ar.Write(&m_OutBufLen,sizeof(m_OutBufLen));
		if(m_OutBufLen!=0)
			ar.Write(m_OutBuffer,m_OutBufLen);
		ar.Write(&m_InBufLen,sizeof(m_InBufLen));
		if(m_InBufLen!=0)
			ar.Write(m_InBuffer,m_InBufLen);	
		ar<<m_RequestTime;
		ar<<m_ReplyTime;	
	}
	else{				 //load data
		ar>>m_SequenceNumber;
		ar.Read(&m_bCritical,sizeof(m_bCritical));
		ar.Read(&m_bReply,sizeof(m_bReply));	
		ar.Read(&m_OutBufLen,sizeof(m_OutBufLen));
		if(m_OutBufLen!=0){
			m_OutBuffer=new char[m_OutBufLen];
			ar.Read(m_OutBuffer,m_OutBufLen);
		}
			
		ar.Read(&m_InBufLen,sizeof(m_InBufLen));
		if(m_InBufLen!=0){
			m_InBuffer=new char[m_InBufLen];
			ar.Read(m_InBuffer,m_InBufLen);	
		}	
		ar>>m_RequestTime;
		ar>>m_ReplyTime;	
	}
}
         
inline void CCServiceData::SaveDataToFile(CFile *File,void *DataBuf,int BufLen,char *CheckSum)
{
	File->Write(DataBuf,BufLen);
	for(int i=0;i<BufLen;i++)
		*CheckSum=*CheckSum^*((char *)DataBuf);
}
         
BOOL CCServiceData::SaveToFile(CFile *File)
{       
		char CheckSum=0;
		ASSERT(File->m_hFile);
		SaveDataToFile(File,&m_SequenceNumber,sizeof(m_SequenceNumber),&CheckSum);
		SaveDataToFile(File,&m_bCritical,sizeof(m_bCritical),&CheckSum);
		SaveDataToFile(File,&m_bReply,sizeof(m_bReply),&CheckSum);	          
		SaveDataToFile(File,&m_OutBufLen,sizeof(m_OutBufLen),&CheckSum);
		if(m_OutBufLen>0)
			SaveDataToFile(File,m_OutBuffer,m_OutBufLen,&CheckSum);
		SaveDataToFile(File,&m_InBufLen,sizeof(m_InBufLen),&CheckSum);
		if(m_InBufLen>0)
			SaveDataToFile(File,m_InBuffer,m_InBufLen,&CheckSum);	
		time_t atime;
		atime=m_RequestTime.GetTime();			
		SaveDataToFile(File,&atime,sizeof(time_t),&CheckSum);
		atime=m_ReplyTime.GetTime();
		SaveDataToFile(File,&atime,sizeof(time_t),&CheckSum);	
		File->Write(&CheckSum,1);
		return TRUE;
}

inline void CCServiceData::ReadDataFromFile(CFile *File,void *DataBuf,int BufLen,char *CheckSum)
{
	int byte=File->Read(DataBuf,BufLen);
	if(byte!=BufLen)
		CFileException::ThrowErrno(5);
	for(int i=0;i<byte;i++)
		*CheckSum=*CheckSum^*((char *)DataBuf);
}

BOOL CCServiceData::LoadFromFile(CFile *File)
{                                              
	char CheckSum=0;
	TRY{           
		ReadDataFromFile(File,&m_SequenceNumber,sizeof(m_SequenceNumber),&CheckSum);

		ReadDataFromFile(File,&m_bCritical,sizeof(m_bCritical),&CheckSum);
			
		ReadDataFromFile(File,&m_bReply,sizeof(m_bReply),&CheckSum);	
		
		ReadDataFromFile(File,&m_OutBufLen,sizeof(m_OutBufLen),&CheckSum);
		
		if((m_OutBufLen>0)&&(m_OutBufLen<300)){
			m_OutBuffer=new char[m_OutBufLen];
			ReadDataFromFile(File,m_OutBuffer,m_OutBufLen,&CheckSum);
		}
		else
			CFileException::ThrowErrno(5);
			
			
		ReadDataFromFile(File,&m_InBufLen,sizeof(m_InBufLen),&CheckSum);
		
		if((m_InBufLen>=0)&&(m_InBufLen<200)){
			if(m_InBuffer){
				m_InBuffer=new char[m_InBufLen];
				ReadDataFromFile(File,m_InBuffer,m_InBufLen,&CheckSum);	
			}
		}
		else
			CFileException::ThrowErrno(5);
			
		time_t atime;
		ReadDataFromFile(File,&atime,sizeof(atime),&CheckSum);
		m_RequestTime=atime;
		ReadDataFromFile(File,&atime,sizeof(atime),&CheckSum);	
		m_ReplyTime=atime;       

		char FileChecksum=0;
		ReadDataFromFile(File,&FileChecksum,1,&CheckSum);			
		if(CheckSum!=0)
				CFileException::ThrowErrno(5);
/*		int bytes=File->Read(&m_SequenceNumber,sizeof(m_SequenceNumber));
		if(bytes<sizeof(m_SequenceNumber))
			CFileException::ThrowErrno(5);
		bytes=File->Read(&m_bCritical,sizeof(m_bCritical));
		if(bytes<sizeof(m_bCritical))
			CFileException::ThrowErrno(5);
			
		bytes=File->Read(&m_bReply,sizeof(m_bReply));	
		if(bytes<sizeof(m_bReply))
			CFileException::ThrowErrno(5);
		
		bytes=File->Read(&m_OutBufLen,sizeof(m_OutBufLen));
		if(bytes<sizeof(m_OutBufLen))
			CFileException::ThrowErrno(5);
		
		if(m_OutBufLen>0){
			m_OutBuffer=new char[m_OutBufLen];
			bytes=File->Read(m_OutBuffer,m_OutBufLen);
			if(bytes<m_OutBufLen)
				CFileException::ThrowErrno(5);
		}
		else
			CFileException::ThrowErrno(5);
			
			
		bytes=File->Read(&m_InBufLen,sizeof(m_InBufLen));
		if(bytes<sizeof(m_InBufLen))
			CFileException::ThrowErrno(5);
		
		if(m_InBufLen>0){
			m_InBuffer=new char[m_InBufLen];
			bytes=File->Read(m_InBuffer,m_InBufLen);	
			if(bytes<m_OutBufLen)
				CFileException::ThrowErrno(5);
		}
		else
			CFileException::ThrowErrno(5);
			
		time_t atime;
		bytes=File->Read(&atime,sizeof(atime));
		m_RequestTime=atime;
		bytes=File->Read(&atime,sizeof(atime));	
		m_ReplyTime=atime;       */
	}CATCH(CFileException,e){
		return FALSE;	
	}END_CATCH	
		return TRUE;
}