smppsock.cpp

移动

#else
			
			ioctlsocket(m_hSocket,FIONREAD,(unsigned long *)&dRevLen);
			if(dRevLen>=sizeof(Smpp_MESSAGE_HEAD))
			{
				memset(buffer,0,MAX_SMPP_COM_BUF);
				dRevLen=fReceive(buffer,sizeof(MAX_SMPP_COM_BUF));
//				if(send_sequence==phead->sequence_no && phead->command_id==ESME_SUB_SM_RESP)
				if(send_sequence==phead->sequence_no &&phead->command_id==ESME_SUB_SM_RESP)
				{
					if(phead->command_status==E_SUCCESS)
					{
						Smpp_PRINTOUT((CString)destaddr + "  Submit +OK.\n");
//						return 1;
					}
					else
					{
						Smpp_PRINTOUT("FAILED: Submit.\n");
//						fLogout(FALSE);
//						fDisconnect();
//						return -2; 
					}
					return phead->command_status;
				}
			}
			
#endif
		}
	}	
	else if(result<0)
	{
//		Sleep(50);
//		if(WaitForSingleObject(m_hEventMainOver,0)==WAIT_OBJECT_0) {break;}
//		if(time(NULL)-starttime>MAX_SUBTIME)    //5--10s  
		{
			Smpp_PRINTOUT("FAILED: SendSM receive timeout");	
			fLogout(FALSE);
			fDisconnect();
			Sleep(3000);
//			return -4;		
		}
	}
	FD_CLR(m_hSocket,&sockset);
//	return 1;
	return -4;
}
int CSmppSock::fSendSM1(const char* destaddr,const char* srcaddr, const char* sendmsg,bool bResp)
{
	//Smpp_PRINTOUT((CString)destaddr + "  Submit +OK.\n");
	//return 1;

	if(!m_bConnected)
	{
		return 0xFF;
	}
	if(!m_bAlive)
	{
		if(fLogin(m_smscInfo.usrName,m_smscInfo.passWd)<1)
		{
			Smpp_PRINTOUT("FAILED: Submit , login retrying");
			fDisconnect();
			Sleep(3000);
			return -2;
		}		 
	}
	if(destaddr[0]==0 || sendmsg[0]==0 )  
	{
		Smpp_PRINTOUT("FAILED: Submit , destadd or sendmsg is NULL") ;	
		return -1;
	}
	int len=strlen(sendmsg);
	if(len>420) len=420;
	wchar_t bb[1000]; memset(bb,0,sizeof(bb));
	BYTE *pbb=(BYTE *)bb;
	MultiByteToWideChar(CP_ACP,0,(const char*)sendmsg,len,bb,sizeof(bb));
	len=wcslen(bb)*2;
	int total_msg_len=len;
	BYTE temp;
	int i;
	for(i=0;i<len/2;i++)
	{
		temp=pbb[i*2];pbb[i*2]=pbb[i*2+1];pbb[i*2+1]=temp;
	}

	BYTE buffer[MAX_SMPP_COM_BUF];
	struct Smpp_MESSAGE_HEAD *phead=(struct Smpp_MESSAGE_HEAD *)buffer;
	BYTE* p=buffer+sizeof(struct Smpp_MESSAGE_HEAD);
	memset(buffer,0,MAX_SMPP_COM_BUF);
	
	*p++='0';	*p++=0;	//service_type
	*p++=1;		//pbody->source_address_ton=1;
	*p++=1;		//pbody->source_address_npi=1;
	strcpy((char*)p,srcaddr);	p+=strlen(srcaddr)+1;	//source_address
	*p++=1;		//pbody->dest_address_ton=1;
	*p++=1;		//pbody->dest_address_npi=1;
	strcpy((char*)p,destaddr);	p+=strlen(destaddr)+1;	//dest_address
	if(total_msg_len>m_msg_len)
	{
		*p++=0x40;		//pbody->esm_class=64=0x40
	}
	else
	{
		*p++=0;		//pbody->esm_class=64=0x40
	}
	//*p++=0;		//pbody->esm_class=0; 
	*p++=0;		//pbody->protocol_ID=0;
	*p++=0;		//pbody->priority_flag=0; 
	*p++=0;		//schedule_delivery_time
	if(m_life.bUsed==1)///生存期限
		p+=FillTimeStrToStr((char *)p);
	else
		*p++=0;		//validity_peroid
	*p++=0;		//registered_delivery_flag
	*p++=0;		//replace_if_presend_flag
	if(m_bFlashMsg==1)
		*p++=24;		//快闪短信
	else
		*p++=8;		//data_codeing
	*p++=0;		//sme_default_msgid



	UINT send_sequence=0;
	BYTE* pmsg=p;
	BYTE mlen=0;
	WORD sar_msg_ref_num=1;
	BYTE sar_total_segments=len/134+((len%134>0)?1:0);
	BYTE sar_segment_seqnum=1;
	while(len>0)
	{
		p=pmsg;
		if(len>m_msg_len)
		{
			mlen=m_msg_len;
		}
		else
		{
			mlen=len;
		}
		len-=mlen;
		*p++=mlen;
		memcpy(p,pbb,mlen);
		pbb+=mlen;
		p+=mlen;
		if(total_msg_len>m_msg_len)//还有 more_messages_to_send 0x0426 GSM
		{
			/*
sar_msg_ref_num 0x020C Generic
sar_total_segments 0x020E Generic
sar_segment_seqnum 0x020F Generic
			*/
			*p++=0x02;*p++=0x0c;//sar_msg_ref_num
			*p++=0;*p++=2;//Length 
			*p++=0;*p++=10;
			*p++=0x02;*p++=0x0e;//sar_total_segments
			*p++=0;*p++=1;//Length 
			*p++=sar_total_segments;
			*p++=0x02;*p++=0x0f;//sar_segment_seqnum
			*p++=0;*p++=1;//Length 
			*p++=sar_segment_seqnum++;
		}

		UINT packet_len=p-buffer;
		phead->command_length=packet_len;
		phead->sequence_no=m_sequence++;
		send_sequence=phead->sequence_no; 
		phead->command_id=ESME_SUB_SM;
		phead->command_status=0;

		network_head(phead);
		//if(Send(buffer,packet_len)==SOCKET_ERROR)
		if(Send(buffer,packet_len)==SOCKET_ERROR)
		{
			if(Send(buffer,packet_len)==SOCKET_ERROR)//重发
			{
				Smpp_PRINTOUT("FAILED: Send Short Message ,send packet failed.disconnect...\r\n"); 
				//fDisconnect();
				return -0xff;
			}
		}
	}

	
//	Sleep(50);
	if(!bResp)	return 1;
	FD_SET sockset = {1, m_hSocket};
	TIMEVAL tv = {10, 0};
    int result=select(0, &sockset, NULL, NULL, &tv);
	
	int dRevLen;
//	UINT starttime=time(NULL);
	//MSG msg;
	if(result>0)//while(1)// GetMessage(&msg, NULL, 0, 0) ) 
	{
		//TranslateMessage(&msg);
		//DispatchMessage(&msg);
		//IOCtl(FIONREAD,&dRevLen); 
		if ( FD_ISSET( m_hSocket, &sockset))
		{
#if 0
			while(1){
				dRevLen=recv(m_hSocket,(char *)buffer,MAX_SMPP_COM_BUF,0);
				break;
				if(dRevLen<=0)
					break;
				result=select(0, &sockset, NULL, NULL, &tv);
				if(result>0)
				{
					if ( FD_ISSET( m_hSocket, &sockset))
						continue;
					else
						break;
				}
				else
					break;
			}
#else
			
			ioctlsocket(m_hSocket,FIONREAD,(unsigned long *)&dRevLen);
			if(dRevLen>=sizeof(Smpp_MESSAGE_HEAD))
			{
				memset(buffer,0,MAX_SMPP_COM_BUF);
				dRevLen=fReceive(buffer,sizeof(MAX_SMPP_COM_BUF));
//				if(send_sequence==phead->sequence_no && phead->command_id==ESME_SUB_SM_RESP)
				if(send_sequence==phead->sequence_no &&phead->command_id==ESME_SUB_SM_RESP)
				{
					if(phead->command_status==E_SUCCESS)
					{
						Smpp_PRINTOUT((CString)destaddr + "  Submit +OK.\n");
//						return 1;
					}
					else
					{
						Smpp_PRINTOUT("FAILED: Submit.\n");
//						fLogout(FALSE);
//						fDisconnect();
//						return -2; 
					}
					return phead->command_status;
				}
			}
			
#endif
		}
	}	
	else if(result<0)
	{
//		Sleep(50);
//		if(WaitForSingleObject(m_hEventMainOver,0)==WAIT_OBJECT_0) {break;}
//		if(time(NULL)-starttime>MAX_SUBTIME)    //5--10s  
		{
			Smpp_PRINTOUT("FAILED: SendSM receive timeout");	
			fLogout(FALSE);
			fDisconnect();
			Sleep(3000);
//			return -4;		
		}
	}
	FD_CLR(m_hSocket,&sockset);
//	return 1;
	return -4;
}

/*******************************************************************************
return 
0 : no login or socket connect
-1: send buf failed
-4: receive response timeout
-5: logout be rejected
>0: success
*******************************************************************************/
int CSmppSock::fLogout(bool bResp)
{
	Smpp_PRINTOUT("Logouting.....") ;
	if(!m_bAlive) {Smpp_PRINTOUT("FAILED: logout,but no login."); return 0;}
	
	Smpp_MESSAGE_HEAD head;
	UINT packet_len=sizeof(Smpp_MESSAGE_HEAD);
	head.command_length=packet_len;
	head.command_id=ESME_UBD;
	head.command_status=0;
	head.sequence_no=m_sequence++;
	UINT logout_sequence=head.sequence_no;
	network_head(&head);
	//Send(&head,packet_len);
	if(Send((BYTE*)&head,packet_len)<0)
		if(Send((BYTE*)&head,packet_len)<0)
		{
			Smpp_PRINTOUT("FAILED: send packet failed."); 
			m_bAlive=false;
			return -0xff;
		}
	Sleep(100);	

	if(!bResp) return 1;
	//receive
	int dRevLen;
	UINT starttime=time(NULL);
	//MSG msg;
	while(1)//GetMessage(&msg, NULL, 0, 0) ) 
	{
		//TranslateMessage(&msg);		DispatchMessage(&msg);
		//IOCtl(FIONREAD,&dRevLen); 
		ioctlsocket(m_hSocket,FIONREAD,(unsigned long *)&dRevLen);
	    if(dRevLen>=sizeof(Smpp_MESSAGE_HEAD))
		{
			memset(&head,0,sizeof(Smpp_MESSAGE_HEAD));
			dRevLen=fReceive((BYTE*)&head,sizeof(MAX_SMPP_COM_BUF));
			if(logout_sequence==head.sequence_no && head.command_id==ESME_UBD_RESP)
			{
				if(head.command_status==E_SUCCESS)
				{
					m_bAlive=FALSE; Smpp_PRINTOUT("Logout +OK.");
					return 1;
				}
				else
				{
					Smpp_PRINTOUT("FAILED: Logout ");
					return -5;
				}			
			}
		}
		Sleep(100);
//		if(WaitForSingleObject(m_hEventMainOver,0)==WAIT_OBJECT_0) {break;}
		if(time(NULL)-starttime>MAX_LOGOUTTIME)    //5--10s		
		{
			Smpp_PRINTOUT("FAILED: Logout,receive timeout");	
			return -4;		
		}
	}
	return -4;
}
/*********************************************************************************
return 

/*********************************************************************************/
int CSmppSock::fAliveTst()
{
	Smpp_PRINTOUT("Alive test.....") ;
	if(!m_bConnected) {Smpp_PRINTOUT("FAILED: have not connected."); return 0;}
	
	Smpp_MESSAGE_HEAD head;
	UINT packet_len=sizeof(Smpp_MESSAGE_HEAD);
	head.command_length=packet_len;
	head.command_id=ESME_QRYLINK;
	head.command_status=0;
	head.sequence_no=m_sequence++;
	UINT querylink_sequence=head.sequence_no;
	network_head(&head);
	//Send(&head,packet_len);
	if(Send((BYTE*)&head,packet_len)<0)
	{
		if(Send((BYTE*)&head,packet_len)<0)
		{
			Smpp_PRINTOUT("FAILED: send packet failed."); 
			return -0xff;
		}
	}
//	ReadAllMsg();
//	return 1;
	BYTE buffer[MAX_SMPP_COM_BUF];
//	ClearBuffer();
	Sleep(100);	

	//receive
	int dRevLen;
	UINT starttime=time(NULL);
	//MSG msg;
	while(1)// GetMessage(&msg, NULL, 0, 0) ) 
	{
		//TranslateMessage(&msg);
		//DispatchMessage(&msg);
		//IOCtl(FIONREAD,&dRevLen);
		ioctlsocket(m_hSocket,FIONREAD,(unsigned long *)&dRevLen);
	    if(dRevLen>=sizeof(Smpp_MESSAGE_HEAD))
		{
			memset(&head,0,sizeof(Smpp_MESSAGE_HEAD));
			dRevLen=fReceive((BYTE*)&head,sizeof(MAX_SMPP_COM_BUF));
			if(querylink_sequence==head.sequence_no && head.command_id==ESME_QRYLINK_RESP)
			{
				if(head.command_status==E_SUCCESS)
				{
					m_bAlive=TRUE; Smpp_PRINTOUT("Alivet test +OK.");
					return 1;
				}
				else
				{
					m_bAlive=FALSE;
					Smpp_PRINTOUT("FAILED: Alive test.");
					return -5;
				}			
			}
		}
		Sleep(100);
//		if(WaitForSingleObject(m_hEventMainOver,0)==WAIT_OBJECT_0) {break;}
		if(time(NULL)-starttime>MAX_ALIVETESTTIME)    //5--10s		
		{
			Smpp_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 CSmppSock::fConnect(char *host, unsigned int port)
{
	int ret=1;   
	if( (!host)||(port<1) )
	{  
		Smpp_PRINTOUT("FAILED: host or port is unexpect.");    
		return -1;
	}
	strncpy(m_smscInfo.SMSCIP,host,MAX_HOSTNAME);
	m_smscInfo.SMSCIP[MAX_HOSTNAME-1]=0;

	m_smscInfo.uPort=port;

	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;    

	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)
	{
		Smpp_PRINTOUT("FAILED: connect failed!"); 
		int nErrorCode_=WSAGetLastError();
		//ShowTcpErr(nErrorCode_);
		//out("Error:connect()\n");
		return(-3);
	}
	m_smscInfo.uPort=port;    

	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 CSmppSock::fDisconnect()
{	
	if(m_bConnected) 
	{
		closesocket(m_hSocket);
		m_hSocket=INVALID_SOCKET;
		m_bConnected=FALSE;	
		m_bAlive=FALSE;
		Smpp_PRINTOUT("FAILED: socket连接已断开. ");
	}
	return 1;
}

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

	nLen=sizeof(Smpp_MESSAGE_HEAD);
	struct Smpp_MESSAGE_HEAD *phead=(struct Smpp_MESSAGE_HEAD *)lpBuf;
	//if(Receive(lpBuf,nLen)!=nLen)
	if(Receive(lpBuf,nLen)!=nLen)
	{
		//fGetSockErr(degTemp); Smpp_PRINTOUT(degTemp) ;
		Smpp_PRINTOUT("FAILED: Receive -FAILED"); 
		return -1;
	}
	network_head(phead);
	lpBuf+=nLen;	
	nLen=phead->command_length-sizeof(Smpp_MESSAGE_HEAD);
	if(nLen>1000)	
	{
		//fGetSockErr(degTemp); Smpp_PRINTOUT(degTemp) ;
		Smpp_PRINTOUT("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); Smpp_PRINTOUT(degTemp) ;
			Smpp_PRINTOUT("FAILED: Receive -FAILED"); 
			return -1;
		}	
	}
	return nLen+sizeof(Smpp_MESSAGE_HEAD);
}

/*int CSmppSock::fCodeMsg(BYTE *msg,int& nMsglen)
{
	int i=0,j=0,iRet=0;
	while(i++<nMsglen)
	{
		if((int)msg[i-1]>0x7f)
		{ iRet=8; break;}
		if((int)msg[i-1]=='_')
		{ iRet=8;break;}
	}
	if(iRet==8)  
	{
		BYTE*  lbTemp=msg;
		WCHAR wTemp[MAX_MSGLEN/2]; memset((BYTE*)wTemp,0,MAX_MSGLEN);		
		nMsglen=MultiByteToWideChar(CP_ACP,0,(char*)lbTemp, -1,wTemp,int(MAX_SENDBUF/2));
		if(nMsglen>0)
		{
			for(i=0;i<nMsglen-1;i++)
			{
				char cTemp[5]="\0";
				int xxx=*((WORD*)(wTemp+i));
				itoa(xxx,cTemp,16);	
				if((cTemp[3]==0)&&(cTemp[2])==0)
				{
					cTemp[3]=cTemp[1];cTemp[2]=cTemp[0];
					cTemp[1]=0;cTemp[0]=0;
				}
				if(cTemp[3]==0) cTemp[3]=48;
				if(cTemp[2]==0) cTemp[2]=48;
				if(cTemp[1]==0) cTemp[1]=48;
				if(cTemp[0]==0) cTemp[0]=48;				
				memcpy(lbTemp,cTemp,4);
				lbTemp+=4; 
			}
			nMsglen=lbTemp-msg;
		}