cmppsock.cpp

移动

		}
		if(bEventMainOver) {break;}
		Sleep(10);
		if(time(NULL)-starttime>MAX_CMPP_SUBTIME)    //5--10s  
		{
			PRINTOUT("CMPP FAILED: SendSM receive timeout");	
			fLogout(FALSE);
			fDisconnect();
			Sleep(2000);
			return -4;		
		}
	}	
	return -4;	
}


/*******************************************************************************
return 
0 : no login or socket connect
-1: send buf failed
-4: receive response timeout
-5: logout be rejected
>0: success
*******************************************************************************/
int CCmppSock::fLogout(bool bResp)
{
	PRINTOUT("Logouting.....") ;
	if(!m_bAlive) {PRINTOUT("FAILED: logout,but no login."); return 0;}
	
	MESSAGE_HEAD head;
	UINT logout_sequence=m_sequence++;
	UINT packet_len=sizeof(MESSAGE_HEAD);
	head.command_length=network_dword(packet_len);
	head.command_id=network_dword(CMPP_TERMINATE);
	head.sequence_no=network_dword(logout_sequence);

	if(send(m_hSocket,(const char*)&head,packet_len,0)<0)
		if(send(m_hSocket,(const char*)&head,packet_len,0)<0)
		{
			PRINTOUT("FAILED: send packet failed."); 
			return -0xff;
		}
	Sleep(100);	

	if(!bResp) return 1;
	//receive
	DWORD dRevLen;
	UINT starttime=time(NULL);
	//MSG msg;
	while(1)//GetMessage(&msg, NULL, 0, 0) ) 
	{
		ioctlsocket(m_hSocket,FIONREAD,&dRevLen);
	    if(dRevLen>=sizeof(MESSAGE_HEAD))
		{
			memset(&head,0,sizeof(MESSAGE_HEAD));
			dRevLen=fReceive((BYTE*)&head,sizeof(MAX_CMPP_COM_BUF));
			if(logout_sequence==head.sequence_no && head.command_id==CMPP_TERMINATE_REP)
			{
				//if(head.command_status==E_SUCCESS)
				{
					m_bAlive=FALSE; PRINTOUT("Logout +OK.");
					return 1;
				}
				//else
				{
					//PRINTOUT("FAILED: Logout ");
					//return -5;
				}			
			}
		}
		Sleep(100);
		if(bEventMainOver) {break;}
		if(time(NULL)-starttime>MAX_CMPP_LOGOUTTIME)    //5--10s		
		{
			PRINTOUT("FAILED: Logout,receive timeout");	
			return -4;		
		}
	}
	return -4;
}
/*********************************************************************************
return 

/*********************************************************************************/
int CCmppSock::fAliveTst(BOOL bResp)
{
//	fReadAndAtuoAnswer();
//	return 0;

	PRINTOUT("Alive test.....") ;
	if(!m_bConnected) {PRINTOUT("FAILED: have not connected."); return 0;}
	
	MESSAGE_HEAD head;
	UINT packet_len=sizeof(MESSAGE_HEAD);
	UINT querylink_sequence=m_sequence++;
	head.command_length=network_dword(packet_len);
	head.command_id=network_dword(CMPP_ACTIVE_TEST);
	head.sequence_no=network_dword(querylink_sequence);

	if(send(m_hSocket,(const char*)&head,packet_len,0)<0)
		if(send(m_hSocket,(const char*)&head,packet_len,0)<0)
		{
			PRINTOUT("FAILED: send packet failed."); 
			return -0xff;
		}
	Sleep(100);	
	if(!bResp)	return 1;

	//receive
	DWORD dRevLen;
	UINT starttime=time(NULL);
	while(1)// GetMessage(&msg, NULL, 0, 0) ) 
	{
		ioctlsocket(m_hSocket,FIONREAD,&dRevLen);
	    if(dRevLen>=sizeof(MESSAGE_HEAD))
		{
			memset(&head,0,sizeof(MESSAGE_HEAD));
			dRevLen=fReceive((BYTE*)&head,sizeof(MAX_CMPP_COM_BUF));
			if(querylink_sequence==head.sequence_no && head.command_id==CMPP_ACTIVE_TEST_REP)
			{
				//if(head.command_status==E_SUCCESS)
				{
					m_bAlive=TRUE; PRINTOUT("Alivet test +OK.");
					return 1;
				}
				//else
				{
					//m_bAlive=FALSE;
					//PRINTOUT("FAILED: Alive test.");
					//return -5;
				}			
			}
		}
		Sleep(100);
		if(bEventMainOver) {break;}
		if(time(NULL)-starttime>MAX_CMPP_ALIVETESTTIME)    //5--10s		
		{
			PRINTOUT("FAILED: Alive test receive timeout");
			//fDisconnect();
			return -4;		
		}
	}
	return m_bAlive;
}
/*******************************************************************************
return 
     -1:host or port is unexpect
	 -2:create  error
	 -3:connect failed
	  1:success connect
/*******************************************************************************/
int CCmppSock::fConnect(char *host, unsigned int port)
{
	int ret=1;   
	if( (!host)||(port<1) )
	{  
		//PRINTOUT("FAILED: host or port is unexpect.");    
		return -1;
	}
	strcpy(m_smscInfo.SMSCIP,host);
	m_smscInfo.uPort=port;

	char degTemp[100];
	sprintf(degTemp,"connecting to %s...",host);	
	if(m_bAlive)	fLogout(FALSE);
	if(m_bConnected)	
	{
		fDisconnect();	Sleep(1000);		
	}
	if(m_hSocket==INVALID_SOCKET)
	{
		if(CreateSocket()==0) return -2;
	}

	m_sequence=0;
	m_bConnected=m_bAlive=FALSE;

	m_smscInfo.uPort=port;    
	strcpy(m_smscInfo.SMSCIP,host);	

	SOCKADDR_IN  sockaddr_inServer;
	memset(&sockaddr_inServer,0,sizeof(SOCKADDR_IN));
	sockaddr_inServer.sin_family=AF_INET;
	sockaddr_inServer.sin_addr.s_addr=inet_addr(host);
	sockaddr_inServer.sin_port=htons(port);
	if(connect(m_hSocket,(SOCKADDR *)&sockaddr_inServer,sizeof(SOCKADDR_IN)) == SOCKET_ERROR)
	{
		//PRINTOUT("FAILED: connect failed!"); 
		int nErrorCode_=WSAGetLastError();
		//ShowTcpErr(nErrorCode_);
		//out("Error:connect()\n");
		return(-3);
	}
	m_smscInfo.uPort=port;    strcpy(m_smscInfo.SMSCIP,host);	
	//PRINTOUT("connect +OK."); 
  /* set socket to non-blocking */
  u_long temp=1;
  if (ioctlsocket(m_hSocket,FIONBIO,&temp) == SOCKET_ERROR)
  {
	return WSAGetLastError();
//	perror("Notice:ioctlsocket(non-block)\n");
  }
	/* set socket to SO_LINGER */
	 LINGER  optval;
	 optval.l_onoff=1;
	 optval.l_linger=0;	//abort

	 if(setsockopt(m_hSocket, SOL_SOCKET,SO_LINGER,(char *)&optval, sizeof(LINGER)) == SOCKET_ERROR)
	 {
	    return WSAGetLastError();
	 }

	 //keepalive = yes
	 int bkeep=true;
	 if(setsockopt(m_hSocket, SOL_SOCKET,SO_KEEPALIVE,(char *)&bkeep, sizeof(int)) == SOCKET_ERROR)
	 {
	  return WSAGetLastError();
	 }

	
	m_bConnected=TRUE;

	return 1;
}
/*******************************************************************************
return ;
/*******************************************************************************/
int CCmppSock::fDisconnect()
{	
	if(m_bConnected) 
	{
		closesocket(m_hSocket);
		m_hSocket=INVALID_SOCKET;
		m_bConnected=FALSE;	
		m_bAlive=FALSE;
		PRINTOUT("FAILED: socket连接已断开. ");
	}
	return 1;
}

int CCmppSock::fReceive(BYTE* lpBuf, int nBufLen) 
{
	int    iRet=0;
	int  nLen;		

	nLen=sizeof(MESSAGE_HEAD);
	struct MESSAGE_HEAD *phead=(struct MESSAGE_HEAD *)lpBuf;
	//if(Receive(lpBuf,nLen)!=nLen)
	if(recv(m_hSocket,(char*)lpBuf,nLen,0)!=nLen)
	{
		//fGetSockErr(degTemp); PRINTOUT(degTemp) ;
		PRINTOUT("FAILED: Receive -FAILED"); 
		return -1;
	}
	network_head(phead);
	lpBuf+=nLen;	
	nLen=phead->command_length-sizeof(MESSAGE_HEAD);
	if(nLen>1000)	nLen=0;		//added for assert
	if(nLen>0)
	{
		//if(Receive(lpBuf,nLen)!=nLen)
		if(recv(m_hSocket,(char*)lpBuf,nLen,0)!=nLen)
		{
			//fGetSockErr(degTemp); PRINTOUT(degTemp) ;
			PRINTOUT("FAILED: Receive -FAILED"); 
			return -1;
		}	
	}
	return nLen+sizeof(MESSAGE_HEAD);
}

/*void CCmppSock::OnClose(int nErrorCode) 
{
	fDisconnect();
	CSocket::OnClose(nErrorCode);
}*/




int CCmppSock::fReadAndAtuoAnswer()
{
	if(!m_bConnected) {PRINTOUT("FAILED: have not connected."); return 0;}
	if(!m_bAlive){PRINTOUT("FAILED: have not login."); return 0;}
	BYTE buffer[MAX_CMPP_COM_BUF];
	struct MESSAGE_HEAD *phead=(struct MESSAGE_HEAD *)buffer;
	BYTE* p=buffer+sizeof(struct MESSAGE_HEAD);

	int dRevLen;
	UINT starttime=time(NULL);
	while(1)// GetMessage(&msg, NULL, 0, 0) ) 
	{
		ioctlsocket(m_hSocket,FIONREAD,(unsigned long*)&dRevLen);
		if(dRevLen<sizeof(MESSAGE_HEAD))break;

	    if(dRevLen>=sizeof(MESSAGE_HEAD))
		{
			memset(buffer,0,MAX_CMPP_COM_BUF);
			dRevLen=fReceive(buffer,sizeof(MAX_CMPP_COM_BUF));
			if(phead->command_id==CMPP_ACTIVE_TEST)
			{
				phead->command_id=network_dword(CMPP_ACTIVE_TEST_REP);
				phead->sequence_no=network_dword(phead->sequence_no);
				phead->command_length=network_dword(sizeof(MESSAGE_HEAD)+1); 
				buffer[sizeof(MESSAGE_HEAD)]=0;		//status
				send(m_hSocket,(const char*)buffer,sizeof(MESSAGE_HEAD)+1,0);
			}
			else if(phead->command_id==CMPP_SUBMIT_REP)// && send_sequence==phead->sequence_no)
			{
				PRINTOUT("Submit_rep\r\n");
				return -2; 
			}
		}
	}	
	return -4;
}

void CCmppSock::Check()
{
	fReadAndAtuoAnswer();
}