protutil.cpp

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

CCServiceData::~CCServiceData()
{
	if(m_OutBuffer!=NULL)
		delete []m_OutBuffer;
	if(m_InBuffer!=NULL)
		delete []m_InBuffer;	
	
	if(m_SendPDU!=NULL)
		delete m_SendPDU;
		
}

void CCServiceData::GetSendLogString(char *LogStr,BOOL bBufferChar)
{                   
	CString tmpString;
	char tmpstr[20];
//display sequence number	
	tmpString="Sequence Num:";
	sprintf(tmpstr,"%lu ",m_SequenceNumber);	
	tmpString+=tmpstr;

	tmpString+="Critical:";	
	if(m_bCritical)
		tmpString+="TRUE ";
	else
		tmpString+="FALSE ";	
	
	tmpString+="Reply:";	
	if(m_bReply)
		tmpString+="TRUE ";
	else
		tmpString+="FALSE ";	
                            
    tmpString+="Out Len:";                        
    sprintf(tmpstr,"%u ",m_OutBufLen);
    tmpString+=tmpstr;        
    
	char *tmpBuf=new char[m_OutBufLen+1];			
    if(bBufferChar){
		memcpy(tmpBuf,m_OutBuffer,m_OutBufLen);
		tmpBuf[m_OutBufLen]='\0';
		tmpString+=tmpBuf;
	}
	else{
		for(WORD i=0;i<m_OutBufLen;i++){
			sprintf(tmpstr,"%x ",((char *)m_OutBuffer)[i]);
			tmpString+=tmpstr;
		}
	}
	 
	strcpy(LogStr,tmpString); 
	delete []tmpBuf;
}
	
void CCServiceData::GetReceiveLogString(char *LogStr,BOOL bBufferChar)
{
	CString tmpString;
	char tmpstr[20];
//display sequence number	
	tmpString="Sequence Num:";
	sprintf(tmpstr,"%lu ",m_SequenceNumber);	
	tmpString+=tmpstr;

	tmpString+="Critical:";	
	if(m_bCritical)
		tmpString+="TRUE ";
	else
		tmpString+="FALSE ";	
	
	tmpString+="Reply:";	
	if(m_bReply)
		tmpString+="TRUE ";
	else
		tmpString+="FALSE ";	

	if(m_InBufLen){                            
    	tmpString+="Out Len:";                        
    	sprintf(tmpstr,"%u ",m_InBufLen);
    	tmpString+=tmpstr;        
    
		char *tmpBuf=new char[m_InBufLen+1];
    	if(bBufferChar){
			memcpy(tmpBuf,m_InBuffer,m_InBufLen);
			tmpBuf[m_InBufLen]='\0';
			tmpString+=tmpBuf;
		}
		else{
			for(WORD i=0;i<m_InBufLen;i++){
				sprintf(tmpstr,"%x ",((char *)m_InBuffer)[i]);
				tmpString+=tmpstr;
			}
		}
		delete []tmpBuf;
	} 
	strcpy(LogStr,tmpString); 

}

const void *CCServiceData::GetSendPDU()
{
	if(m_SendPDU==NULL)
	{   //send has not been created
						   //create a PDU,not include checksum	
		m_SendPDULen=sizeof(m_SequenceNumber)+sizeof(m_bCritical)+
					sizeof(m_bReply)+sizeof(m_OutBufLen)+m_OutBufLen+
					sizeof(m_InBufLen)+m_InBufLen+sizeof(m_ReceiveError);
		m_SendPDU=new char[m_SendPDULen];
		ASSERT(m_SendPDU!=NULL);
		char *ptmp=(char *)m_SendPDU;
		memcpy(ptmp,&m_SequenceNumber,sizeof(m_SequenceNumber));
		ptmp+=sizeof(m_SequenceNumber);
		
		memcpy(ptmp,&m_bCritical,sizeof(m_bCritical));
		ptmp+=sizeof(m_bCritical);
		
		memcpy(ptmp,&m_bReply,sizeof(m_bReply));
		ptmp+=sizeof(m_bReply);
		
		memcpy(ptmp,&m_OutBufLen,sizeof(m_OutBufLen));
		ptmp+=sizeof(m_OutBufLen); 
		
		if(m_OutBufLen!=0){
			memcpy(ptmp,m_OutBuffer,m_OutBufLen);
			ptmp+=m_OutBufLen;
		}	                  
		memcpy(ptmp,&m_InBufLen,sizeof(m_InBufLen));
		ptmp+=sizeof(m_InBufLen); 
		
		if(m_InBufLen!=0){
			memcpy(ptmp,m_InBuffer,m_InBufLen);
			ptmp+=m_InBufLen;
		}	                  
		memcpy(ptmp,&m_ReceiveError,sizeof(m_ReceiveError));
		
	}	                      
	return m_SendPDU;
}

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

//receive a PDU,if this PDU is a reply, copy the input data, and return TRUE 
BOOL CCServiceData::ReceivePDU(const void *InPDU,WORD InPDULen)
{                   
	char *ptmp=(char *)InPDU;
	m_SequenceNumber=*((UINT32 *)ptmp); //Isn't this data's reply
	ptmp+=sizeof(m_SequenceNumber);		
	
	m_bCritical=*((UINT16 *)ptmp);
	ptmp+=sizeof(m_bCritical);	
	
	m_bReply=*((UINT16 *)ptmp);
	ptmp+=sizeof(m_bReply);	
	
	m_OutBufLen=*((UINT16 *)ptmp);
//	ASSERT(tmpSendLen==0);
	ptmp+=sizeof(m_OutBufLen);
	if(m_OutBufLen!=0){
		m_OutBuffer=new char[m_OutBufLen];
		memcpy(m_OutBuffer,ptmp,m_OutBufLen);	
	}	
	ptmp+=m_OutBufLen;
	
	memcpy(&m_InBufLen,ptmp,sizeof(m_InBufLen));				
	
	ptmp+=sizeof(m_InBufLen);
//	ASSERT(m_InBufLen!=0);
	ASSERT(m_InBuffer==NULL);  //No PDU should be received before
	
	if(m_InBufLen){
		m_InBuffer=new char[m_InBufLen];
		memcpy(m_InBuffer,ptmp,m_InBufLen);
	}
	ptmp+=m_InBufLen;
	memcpy(&m_ReceiveError,ptmp,sizeof(m_ReceiveError));
	
	m_ReplyTime=CTime::GetCurrentTime();
	return TRUE;
}


unsigned long CCServiceData::GetTimeSpan()
{
	CTimeSpan TimeSpan=m_ReplyTime-m_RequestTime;
	return TimeSpan.GetTotalSeconds();
}

//end of class CCServiceData

/*********************************************************/
//class CCSUser
//
//protocol user, who has a interface to the protocol entity
/*********************************************************/
CCSUser::CCSUser()
{
	m_CSEntity=NULL;
	m_bLink=FALSE;
	m_UserId=0;
}              

CCSUser::~CCSUser()
{
	if(m_bLink)
		UnLink();
}

BOOL CCSUser::Link(CCSEntity *CSEntity,WORD UserId)
{
	return CSEntity->Link(this,UserId);
}

void CCSUser::UnLink()
{
	m_CSEntity->UnLink(this);
}

//OnReply function notify the service user that a reply has com in
//Delay is the time between user request a service and user get a reply
void CCSUser::OnReply(UINT32 SequenceNum,const void *InBuffer,int InBufLen,unsigned long Delay,int Error)
{
	if(Error==SENDTIMEOUT){
		
	}
}

//end of class CCSUser  

/***************************************************************/
//class CSequenceNum
//
//class CSequenceNum create sequence num for every protocol data
/***************************************************************/
#include "time.h"                                         
CSequenceNum::CSequenceNum()
{
	time_t CurTime;
	time(&CurTime);
	m_TimerCounter=ShiftLeft(CurTime)+255;
	m_SequenceNum=ShiftLeft(CurTime);
}

UINT32 CSequenceNum::Get()
{
	time_t CurTime;
	time(&CurTime);               
	unsigned long NewTimerCounter=ShiftLeft(CurTime)+255;
	if(NewTimerCounter<m_TimerCounter){
	//if the timer counter has run around to 0
		m_TimerCounter=NewTimerCounter;
		m_SequenceNum=ShiftLeft(CurTime)+1;
		return m_SequenceNum;
	}
	
	m_TimerCounter=NewTimerCounter;
	if(m_SequenceNum<m_TimerCounter){
		m_SequenceNum++;             
		if(m_SequenceNum==0)
			m_SequenceNum=m_TimerCounter-254;
		return m_SequenceNum;	
	}
	else{      	
		while(m_SequenceNum>=m_TimerCounter){
			Delay(1);       
			time(&CurTime);               
			m_TimerCounter=ShiftLeft(CurTime)+255;
		}
		m_SequenceNum=m_TimerCounter-254;
		return m_SequenceNum;	
	}	
}               

unsigned long CSequenceNum::ShiftLeft(time_t &CurTime)
{
	unsigned long Value=*((unsigned long*)&CurTime);
	unsigned char ValueChar[4];
	memcpy(ValueChar,&Value,sizeof(Value));
	
	for(int i=sizeof(Value)-1;i>0;i--){
		ValueChar[i]=ValueChar[i-1];
	}                             
	ValueChar[0]=0;
	memcpy(&Value,ValueChar,sizeof(Value));                               
	return Value;
}


void CSequenceNum::Delay(int Seconds)
{                  
	ASSERT(Seconds<30);
/////
//
//		/
//
//
//
}
//Local to Center socket
CCenterSocket::CCenterSocket(CCSEntity *Entity)
{
	m_Entity=Entity;
	m_InPacketLen=0;
}

void CCenterSocket::OnReceive(int nErrorCode)
{   
	if(nErrorCode==WSAENETDOWN){
#ifdef _DEBUG
		AfxMessageBox("The network is down!");
#endif	                               
		return;
	}
	if(nErrorCode==0){
		int Result=Receive(m_InBuffer,MAXPACKETLEN);
		if(Result==SOCKET_ERROR){
#ifdef _DEBUG
		AfxMessageBox("Socket recieve error!");
#endif		
	    return;
		}
		m_InPacketLen=Result;
//if the data length error		
		if (m_InPacketLen <= 28)
			return;
		
		m_Entity->OnReceive(m_InBuffer,m_InPacketLen);
	}
}

int CCenterSocket::SendTo(const void* lpBuf, int nBufLen, UINT nHostPort, LPCTSTR lpszHostAddress)
{      
	ASSERT(nBufLen<MAXPACKETLEN);
	ASSERT(nBufLen>0); 
	CopyMemory(m_OutBuffer,(char*)lpBuf,nBufLen);
	int Result=CAsyncSocket::SendTo(m_OutBuffer,nBufLen,nHostPort,lpszHostAddress);
	if(Result!=SOCKET_ERROR)
		return Result;
	else{
#ifdef _DEBUG
		AfxMessageBox("Socket SendTo failed!");
#endif		
		return 0;	
	}
}

//End of implementation of class CSequenceNum

/***************************************************************/
//class CCSEntitySocket
//
//class CCSEntitySocket send and receive data to and from network,
//it also create and check checksum,if the checksum is error,it will
//not pass the data to up layer
/***************************************************************/
CEntitySocket::CEntitySocket(CCSEntity *Entity)
{
	m_Entity=Entity;
	m_InPacketLen=0;
}

void CEntitySocket::OnReceive(int nErrorCode)
{   
	if(nErrorCode==WSAENETDOWN){
#ifdef _DEBUG
		AfxMessageBox("The network is down!");
#endif	                               
#ifdef _LOGDATA
	((CClientApp *)AfxGetApp())->AddLog("The network is down on \"OnReceive\"");
#endif

		return;
	}
	if(nErrorCode==0){
		int Result=Receive(m_InBuffer,MAXPACKETLEN);
		if(Result==SOCKET_ERROR){
#ifdef _DEBUG
		AfxMessageBox("Socket recieve error!");
#endif		
			return;
		}
		m_InPacketLen=Result;
//if the data length error		
		if(m_InPacketLen!=(*((UINT16 *)m_InBuffer)))
			return;
//check received data		
		char CheckSum=0;
		for(WORD i=0;i<m_InPacketLen;i++)
			CheckSum=CheckSum^m_InBuffer[i];
		if(CheckSum==0){	
			m_InPacketLen--;
			m_InPacketLen-=sizeof(m_InPacketLen);
			m_Entity->OnReceive(m_InBuffer+sizeof(m_InPacketLen),m_InPacketLen);
		}	
	}
}
    
int CEntitySocket::SendTo(const void* lpBuf, int nBufLen, UINT nHostPort, LPCTSTR lpszHostAddress)
{      
	ASSERT(nBufLen<MAXPACKETLEN);
	ASSERT(nBufLen>0); 
	UINT16 TotalLen=nBufLen+sizeof(UINT16)+1;   //total PDU length,data+length+                                 

	*((UINT16 *)m_OutBuffer)=TotalLen;
	memcpy(m_OutBuffer+sizeof(UINT16),lpBuf,nBufLen);	
	
	char CheckSum=((char *)m_OutBuffer)[0];
	for(UINT16 i=1;i<TotalLen-1;i++)
		CheckSum=CheckSum^m_OutBuffer[i];
	m_OutBuffer[TotalLen-1]=CheckSum;	
	
	int Result=CAsyncSocket::SendTo(m_OutBuffer,TotalLen,nHostPort,lpszHostAddress);
	if(Result!=SOCKET_ERROR)
		return Result;
	else{
#ifdef _DEBUG
		AfxMessageBox("Socket SendTo failed!");
#endif		
		return 0;	
	}
}
//end of implementation of class CCSEntitySocket