ylfwappushsock.cpp

移动

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

#include "stdafx.h"
#include "ylfWapPushSock.h"

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



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

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

	m_hSocket=INVALID_SOCKET;
}
int ylfWapPushSock::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;
}

ylfWapPushSock::~ylfWapPushSock()
{	
	fDisconnect();
}
/////////////////////////////////////////////////////////////////////////////
// ylfWapPushSock 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
			clientStatus.WapPushGWHttp=Common.Bytes2String(buf,8,20);
			clientStatus.Timeout=BitConverter.ToInt32(buf,28);
			clientStatus.ContentType=Common.Bytes2String(buf,32,20);
			clientStatus.IP=clientSoc.RemoteEndPoint.ToString();

**************************************************************************************/
int ylfWapPushSock::fLogin(char* WapPushGWHttp,char* ContentType)
{

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

	if(strlen(WapPushGWHttp)>199
		||strlen(ContentType)>199)
	{
		return -1;
	}

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

	BYTE buffer[WAP_MAX_SEND_BUF];
	memset(buffer,0,WAP_MAX_SEND_BUF);

	BYTE *p=buffer;

	int len=500;
	*((int*)p)=len;					p+=4;	//total length
	*((int*)p)=WAP_COMMAND_LOGIN;				p+=4;	//command
	strcpy((char*)p,WapPushGWHttp);	p+=200;	//SmsIP
	*((int*)p)=10;				p+=4;	//port
	strcpy((char*)p,ContentType);		p+=200;	//systemid

	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;
			if(dRevLen==len && *((int*)p)==WAP_COMMAND_LOGIN)
			{
				p+=4;
				if(*((int*)p)==0)
				{
					m_bAlive=TRUE; TRACE("Login +OK.");
					nReceiveError=0;
					nextAliveTstTime=CTime::GetCurrentTime()+CTimeSpan(0,0,0,WAP_NEXTALIVETSTTIME);

					return 1;
				}
				else
				{
					int status=*((int*)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)    //WAP_MAX_LOGINTIME 5--10s  
		{
			TRACE("FAILED:LOGIN receive timeout");	
			fDisconnect();
			return -4;		
		}
	}	
	return -4;
}
/*****************************************************************************************
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
				int len=System.BitConverter.ToInt32(buf,0);
				string descAddr=Common.Bytes2String(buf,8,20);
				string href=Common.Bytes2String(buf,28,100);
				string msg=Common.Bytes2String(buf,128,len-128);

0xff  : no send sm alarm
*****************************************************************************************/
int ylfWapPushSock::fSendSM(const char* destaddr,const char* href,const char* sendmsg)
{
	if(strlen(destaddr)>16||strlen(sendmsg)>140||strlen(href)>100) 
	{
		return -1;
	}
	if(!m_bConnected)
	{
		return 0xFF;
	}
	if(!m_bAlive)
	{
		return -2;
	}
	if(destaddr[0]==0 || sendmsg[0]==0 )  
	{
		TRACE("FAILED: Submit , destadd or sendmsg is NULL") ;	
		return -1;
	}

	BYTE buffer[WAP_MAX_SEND_BUF];
	BYTE* p=buffer;

	int len=128+strlen(sendmsg);

	memset(buffer,0,WAP_MAX_SEND_BUF);
	*((int*)p)=len;					p+=4;	//total length
	*((int*)p)=WAP_COMMAND_SUBMIT;		p+=4;	//command
	strcpy((char*)p,destaddr);		p+=20;	//destaddr
	strcpy((char*)p,href);  		p+=100;	//destaddr
	strcpy((char*)p,sendmsg);				//sendmsg
	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,WAP_NEXTALIVETSTTIME);
	return 1;
}


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

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

	int len=12;

	memset(buffer,0,WAP_MAX_SEND_BUF);
	*((int*)p)=len;					p+=4;	//total length
	*((int*)p)=WAP_COMMAND_ALIVE_TEST;	p+=4;	//command
	*((int*)p)=0;	p+=4;	//status
	if(Send(buffer,len)==SOCKET_ERROR)
	{
		TRACE("FAILED: Send Short Message ,send packet failed.disconnect...\r\n"); 
		//fDisconnect();
		return -0xff;
	}
	//receive resp	
	int dRevLen;
	UINT starttime=time(NULL);	

	Sleep(100);
	//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;
			if(dRevLen==len && *((int*)p)==WAP_COMMAND_ALIVE_TEST)
			{
				p+=4;
				int status=*((int*)p);
				if(status==0)
				{
					nReceiveError=0;
					return 1;
				}
				else
				{
					return -status;
				}
			}
		}
		Sleep(100);
//		if(WaitForSingleObject(m_hEventMainOver,0)==WAIT_OBJECT_0) {break;}
		if(time(NULL)-starttime>30)    //WAP_MAX_LOGINTIME 5--10s  
		{
			TRACE("FAILED:LOGIN receive timeout");	
			fDisconnect();
			return -4;		
		}
	}	
	return -4;
}
/*******************************************************************************
return 
     -1:host or port is unexpect
	 -2:create  error
	 -3:connect failed
	  1:success connect
/*******************************************************************************/
int ylfWapPushSock::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 ylfWapPushSock::fDisconnect()
{	
	if(m_bConnected) 
	{
		closesocket(m_hSocket);
		m_hSocket=INVALID_SOCKET;
		m_bConnected=FALSE;	
		m_bAlive=FALSE;
		TRACE("FAILED: socket连接已断开. ");
	}
	return 1;
}

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

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

	nLen=*((int*)lpBuf)-8;
	lpBuf+=8;	

	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+8;
}



void ylfWapPushSock::ReadAllMsg()
{
}

int ylfWapPushSock::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 ylfWapPushSock::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<WAP_MAX_SEND_BUF)
			TempLen=cLength;
	}
  }
	return(TotalSize);
}