ylfsriphostsock.cpp

移动

// ylfSRIPHostSock.cpp: implementation of the ylfSRIPHostSock class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "SmsSend.h"
#include "ylfSRIPHostSock.h"

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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
ylfSRIPHostSock::ylfSRIPHostSock()
{
	nReceiveError=0;

	nextAliveTstTime=CTime::GetCurrentTime()+CTimeSpan(0,0,0,NEXTALIVETSTTIME);
	m_bConnected=m_bAlive=FALSE;

	m_hSocket=INVALID_SOCKET;
	sequence=0;
	msisdnPos=0;
}
int ylfSRIPHostSock::CreateSocket()
{
	m_hSocket=socket(AF_INET,SOCK_STREAM,0);
	if(m_hSocket==INVALID_SOCKET)
	{
		TRACE("FAILED:socket create failed.....");
		//nErrorCode_=WSAGetLastError();
		return 0;
	}
	SOCKADDR_IN  sockaddr;
	memset(&sockaddr,0,sizeof(sockaddr));
	sockaddr.sin_family=AF_INET;
	sockaddr.sin_addr.s_addr=htonl(INADDR_ANY);
	sockaddr.sin_port=htons(0);
	if(bind(m_hSocket,(LPSOCKADDR)&sockaddr,sizeof(sockaddr)) == SOCKET_ERROR)
	{
		closesocket(m_hSocket);
		TRACE("FAILED:socket bind failed,close socket.....");
		//int nErrorCode_=WSAGetLastError();
		m_hSocket=INVALID_SOCKET;
		return 0;
	}
	return 1;
}

ylfSRIPHostSock::~ylfSRIPHostSock()
{	
	fDisconnect();
}
/////////////////////////////////////////////////////////////////////////////
// ylfSRIPHostSock member functions
/**************************************************************************************
return 
0 : already have login
-1: usrname is null
-2: no socket connected
-4: receive response timeout
-5: login be rejected
>0: success
**************************************************************************************/
int ylfSRIPHostSock::fLogin(char *usrname, char *passwd)
{

	if(m_bAlive)     {TRACE("已登录."); return 0;}
	if(!m_bConnected){TRACE("FAILED:socket连接尚未建立."); return -2;}
	if(!usrname)     {TRACE("FAILED:用户名为空.") ; return -1;}	

	sequence=0;
	if(strlen(usrname)>16
		||strlen(passwd)>9) 
	{
		return -1;
	}

	TRACE("Logining.....");


	BYTE *p=buffer;

	int len=40;
	memset(buffer,0,len);

	*((unsigned int*)p)=len;	networkByte(p,0,4);					p+=4;	//total length
	*((unsigned short*)p)=SRIP_BIND_RECEIVER;networkByte(p,0,2);	p+=2;	//command
	*((unsigned short*)p)=0;					p+=2;	//status
	*((unsigned int*)p)=sequence++;networkByte(p,0,4);			p+=4;	//seq

	strcpy((char*)p,usrname);		p+=16;	//usrname
	strcpy((char*)p,passwd);		p+=9;	//passwd

	*(p)=0;							p+=1;	//hlr_type
	*(p)=0;							p+=1;	//vlr_type

	if(Send(buffer,len)==SOCKET_ERROR)
	{
		TRACE("FAILED:Login ,send packet failed.Disconnect..."); 
		fDisconnect();
		return -0xff;
	}
	
	//receive resp	
	int dRevLen;
	UINT starttime=time(NULL);	
	//MSG msg;
	while(1) 
	{
		len=12;
		ioctlsocket(m_hSocket,FIONREAD,(unsigned long *)&dRevLen);
	    if(dRevLen>=len)
		{
			memset(buffer,0,len);
			dRevLen=fReceive(buffer,len);
			p=buffer+4;
			networkByte(p,0,2);	
			if(dRevLen==len && *((unsigned short*)p)==SRIP_BIND_RECEIVER_RESP)
			{
				p+=2;
				networkByte(p,0,2);	
				if(*((unsigned short*)p)==0)
				{
					m_bAlive=TRUE; TRACE("Login +OK.");
					nReceiveError=0;
					nextAliveTstTime=CTime::GetCurrentTime()+CTimeSpan(0,0,0,NEXTALIVETSTTIME);

					return 1;
				}
				else
				{
					int status=*((unsigned short*)p);
					if(status==1)
					{
						TRACE("FAILED: Login fail from user and password error");
					}
					else
					{
						TRACE("FAILED: Login fail from connect sms");
					}
					return -status;
				}
			}
		}
		Sleep(100);
//		if(WaitForSingleObject(m_hEventMainOver,0)==WAIT_OBJECT_0) {break;}
		if(time(NULL)-starttime>30)    //SRIP_MAX_LOGINTIME 5--10s  
		{
			TRACE("FAILED:LOGIN receive timeout");	
			fDisconnect();
			return -4;		
		}
	}	
	return -4;
}

bool ylfSRIPHostSock::AddMsisdn(int msisdn,int hlrCity,int vlr,int vlrCity,int stime,bool begin)
{
	if(begin)
	{
		msisdnPos=0;
	}
	int bufpos=msisdnPos*16+14;
	if(msisdnPos+16>SRIP_MAX_SEND_BUF)
	{
		return false;
	}
	BYTE* p=buffer+bufpos;

	*((unsigned int*)p)=msisdn;	networkByte(p,0,4);					p+=4;	//msisdn
	*((unsigned short*)p)=hlrCity;networkByte(p,0,2);					p+=2;	//hlrCity
	*((unsigned int*)p)=vlr;		networkByte(p,0,4);					p+=4;	//vlr
	*((unsigned short*)p)=vlrCity;networkByte(p,0,2);					p+=2;	//vlrCity length
	*((unsigned int*)p)=stime;	networkByte(p,0,4);					p+=4;	//stime
	msisdnPos++;
	return true;
}
/*****************************************************************************************
return 
0 : no login or socket connect
-1: destadd or sendmsg is null
-2: sendmsg error
-3: sendpack error
-4: receive response timeout
-5: 
-6: sendsm resperror
1: success

0xff  : no send sm alarm
*****************************************************************************************/
int ylfSRIPHostSock::Submit()
{
	if(!m_bConnected)
	{
		return 0xFF;
	}
	if(!m_bAlive)
	{
		return -2;
	}
	if(msisdnPos==0)return -1;

	int len=12+msisdnPos*16+2;
	BYTE* p=buffer;

	*((unsigned int*)p)=len;	networkByte(p,0,4);	p+=4;	//total length
	*((unsigned short*)p)=SRIP_SUBMIT;networkByte(p,0,2);p+=2;	//command
	*((unsigned short*)p)=0;					p+=2;	//status
	*((unsigned int*)p)=sequence++;	networkByte(p,0,4);			p+=4;	//sequence

	*((unsigned short*)p)=msisdnPos;	networkByte(p,0,2);			p+=2;	//user count
	*p=16;

	msisdnPos=0;

	if(Send(buffer,len)==SOCKET_ERROR)
	{
		TRACE("FAILED: Send Short Message ,send packet failed.disconnect...\r\n"); 
		//fDisconnect();
		return -0xff;
	}
	nextAliveTstTime=CTime::GetCurrentTime()+CTimeSpan(0,0,0,NEXTALIVETSTTIME);
	return 1;
}


/*********************************************************************************/
int ylfSRIPHostSock::fAliveTst()
{
	if(CTime::GetCurrentTime()<nextAliveTstTime)return 1;

	nextAliveTstTime=CTime::GetCurrentTime()+CTimeSpan(0,0,0,NEXTALIVETSTTIME);
	if(!m_bConnected)
	{
		return 0xFF;
	}
	if(!m_bAlive)
	{
		return -2;
	}
	BYTE* p=buffer;

	int len=12;

	memset(buffer,0,len);
	*((int*)p)=len;					p+=4;	//total length
	*((short*)p)=SRIP_ALIVE_TEST;	p+=2;	//command
	*((short*)p)=0;					p+=2;	//status
	*((int*)p)=sequence++;			p+=4;	//sequence
	if(Send(buffer,len)==SOCKET_ERROR)
	{
		TRACE("FAILED: Send Short Message ,send packet failed.disconnect...\r\n"); 
		//fDisconnect();
		return -0xff;
	}
	return 1;
}
/*******************************************************************************
return 
     -1:host or port is unexpect
	 -2:create  error
	 -3:connect failed
	  1:success connect
/*******************************************************************************/
int ylfSRIPHostSock::fConnect(char *host, unsigned int port)
{
	int ret=1;   
	if( (!host)||(port<1) )
	{  
		TRACE("FAILED: host or port is unexpect.");    
		return -1;
	}
	if(m_bConnected)	
	{
		fDisconnect();	Sleep(1000);		
	}
	if(m_hSocket==INVALID_SOCKET)
	{
		if(CreateSocket()==0) return -2;
	}

	m_bConnected=m_bAlive=FALSE;


	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)
	{
		TRACE("FAILED: connect failed!"); 
		int nErrorCode_=WSAGetLastError();
		//ShowTcpErr(nErrorCode_);
		//out("Error:connect()\n");
		return(-3);
	}
	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 ylfSRIPHostSock::fDisconnect()
{	
	if(m_bConnected) 
	{
		closesocket(m_hSocket);
		m_hSocket=INVALID_SOCKET;
		m_bConnected=FALSE;	
		m_bAlive=FALSE;
		TRACE("FAILED: socket连接已断开. ");
	}
	return 1;
}

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

	if(Receive(lpBuf,nLen)!=nLen)
	{
		//fGetSockErr(degTemp); TRACE(degTemp) ;
		TRACE("FAILED: Receive -FAILED"); 
		return -1;
	}

	networkByte(lpBuf,0,4);
	nLen=*((int*)lpBuf)-4;
	lpBuf+=4;	

	if(nLen>1000)	
	{
		//fGetSockErr(degTemp); TRACE(degTemp) ;
		TRACE("FAILED: Receive -FAILED"); 
		nLen=0;		//added for assert
		return -1;
	}
	if(nLen>0)
	{
		//if(Receive(lpBuf,nLen)!=nLen)
		if(Receive(lpBuf,nLen)!=nLen)
		{
			//fGetSockErr(degTemp); TRACE(degTemp) ;
			TRACE("FAILED: Receive -FAILED"); 
			return -1;
		}	
	}
	return nLen+4;
}



void ylfSRIPHostSock::ReadAllMsg()
{
}
void ylfSRIPHostSock::networkByte(BYTE *buf,int pos,int len)
{
	BYTE t;
	for(int i=0;i<len/2;i++)
	{
		t=buf[pos+i];
		buf[pos+i]=buf[pos+len-1-i];
		buf[pos+len-1-i]=t;
	}
}
int ylfSRIPHostSock::Receive(unsigned char *lpBuf, int nBufLen)
{
	unsigned char * buf;
	int byRet,ErrCode;
	int TempLen;			//every frame 2048 bytes
	int Num=0;
	TempLen=nBufLen;
	buf=lpBuf;

	while((byRet=recv (m_hSocket,(char *)buf,TempLen,0))!=TempLen)
	{
		if(byRet<0)
		{
			ErrCode=WSAGetLastError();
			if(ErrCode!= WSAEWOULDBLOCK)//block err closeconnect
			{
				return(-1);
			}
			else	//if no data not return byRet=0,return an err WSAEWOULDBLOCK
			{		//本来应正常退出，但在MPU关电时也返回WSAEWOULDBLOC，新开电无法正常连接，才调用退出
				nReceiveError++;
				if(nReceiveError>100)
				{
					return(-1);
				}
				return(0);
			}
		}
		else if(byRet==0)
		{
			return(0);
		}
		else
		{
			Num+=byRet;				
			buf+= byRet;
			TempLen=nBufLen-Num;
			if(TempLen<=0)return nBufLen;
		}
 	}
	nReceiveError=0;
	return nBufLen;
}

int ylfSRIPHostSock::Send(unsigned char *pBuffer, int cLength)
{
  int cBytes,ErrCode;
  int TempLen;			//every frame 2048 bytes
  int TotalSize=cLength;
  int Num=0,SendNum=0;
  BOOL bBeginSend=FALSE;
  unsigned char *buf;
  buf=pBuffer;

  TempLen=cLength;
  while ((cBytes=send(m_hSocket,(char *)buf,TempLen,0))!=cLength)
  {
	 if(cBytes<0)
	 {
		ErrCode=WSAGetLastError();
		if(ErrCode!= WSAEWOULDBLOCK)
		{
			return(-1);
		}
		else
		{
			if(bBeginSend)
			{
				SendNum++;	//blocke err closeconnect
				if(SendNum>2000)
				{
					return(-1);
				}
				Sleep(5);
			}
			else
			{
				SendNum++;	//block err closeconnect
				if(SendNum>2000)
				{
					return(-1);
				}
				Sleep(5);
			}
		}
	}
	else
	{
		bBeginSend=TRUE;
		if(cBytes==cLength)
			return(TotalSize);
		Num+=cBytes;
		if(Num>TotalSize)	//lose frames
		{
			return(-1);
		}
		buf+= cBytes;
		cLength-= cBytes;
		if(cLength<SRIP_MAX_SEND_BUF)
			TempLen=cLength;
	}
  }
	return(TotalSize);
}