netrtu.cpp

cdma无线通信转发程序 用于电力调度数据的转发

#include "stdafx.h"
#include "netrtu.h"
#include "mydata.h"
//******************************************************** 
int split_name(char *dev, int *remoteport,int *localport, char *hostname)
{
	char	devbuf[100]="";
	char	*tmpport,*tmpport1;
	*remoteport=0;
	*localport=0;	

	strcpy(devbuf,dev);
	tmpport=strchr(devbuf,',');

	if(tmpport!=NULL)
	{
		*remoteport=atoi(tmpport+1);
		if(*remoteport>MAX_RTUPORT_NO || *remoteport<MIN_RTUPORT_NO)	return DEVICE_PORT_ERROR;
		tmpport1=tmpport;
		tmpport1++;
		tmpport1=strchr(tmpport1,',');
		if(tmpport1!=NULL)
		{
		   *localport = atoi(tmpport1+1);
		   if(*localport>MAX_RTUPORT_NO || *localport<MIN_RTUPORT_NO)	return DEVICE_PORT_ERROR;
		}
		*tmpport='\0';
		strcpy(hostname, devbuf);
		return 1;
	}

	return DEVICE_NAME_ERROR; 
}
//打开TCP通道
int  OpenPort(char *dev)
{
	if(!dev) return DEVICE_NAME_ERROR;

	SOCKET		sockid;
	int			localport,remoteport;
	char		hostname[140];
	struct sockaddr_in txaddr;
	txaddr.sin_family = AF_INET;

	if(split_name(dev, &remoteport,&localport, hostname)<0)	   return DEVICE_NAME_ERROR;
	txaddr.sin_port   = htons(remoteport);
	txaddr.sin_addr.s_addr = inet_addr(hostname);
	if (txaddr.sin_addr.s_addr==INADDR_NONE)	return DEVICE_HOST_ERROR;
    //****************************************************************
	if((sockid=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP))<=0)//打开tcp通道
	{ 
#ifdef __unix
		perror("创建SOCKET失败");
#endif
		return DEVICE_CREATE_SOCK_ERROR;
	}

	struct timeval tv;

#if defined(WIN32)
	unsigned long block_flag = TRUE;
	ioctlsocket(sockid,FIONBIO, &block_flag);
#elif defined(__unix)
	fcntl(sockid,F_SETFL,O_NDELAY);
#endif	  

    if( (connect(sockid,(struct sockaddr *)&txaddr,sizeof(txaddr))==0)
		||(get_last_error()==EISCONN))
	{

#if defined(WIN32)
		unsigned long block_flag = TRUE;
		ioctlsocket(sockid,FIONBIO,&block_flag);
#endif
		
#if (defined (WIN32) || defined(__alpha))
		tv.tv_sec =  0;
		tv.tv_usec =1000;
		setsockopt(sockid,SOL_SOCKET,SO_SNDTIMEO,(char *)&tv,sizeof(tv));
		setsockopt(sockid,SOL_SOCKET,SO_RCVTIMEO,(char *)&tv,sizeof(tv));
#endif
		char keep_alive=TRUE;
		setsockopt(sockid,SOL_SOCKET,SO_KEEPALIVE,(char *)&keep_alive,sizeof(keep_alive));

		int temp = DEVICE_TX_BUF_SIZE;
		setsockopt(sockid,SOL_SOCKET,SO_SNDBUF,(char *) &temp,sizeof(temp));
		temp = DEVICE_RX_BUF_SIZE;
		setsockopt(sockid,SOL_SOCKET,SO_RCVBUF,(char *) &temp,sizeof(temp)); 

		return sockid;
	}
	else {
		if((get_last_error()==EINPROGRESS)||(get_last_error()==EWOULDBLOCK))
		{
#if defined (WIN32)
			tv.tv_sec=10;
			tv.tv_usec=0;
			fd_set fd;
			FD_ZERO(&fd);
			FD_SET(sockid, &fd);
			int ret=select(FD_SETSIZE,0,&fd,0, &tv);
			if(ret>0)
#elif defined (__unix)
				delay_t(10000);
			if((connect(sockid,(struct sockaddr *)&txaddr,sizeof(txaddr))==0)
				||(get_last_error()==EISCONN))
#endif
			{
#if (defined (WIN32) || defined(__alpha))
				tv.tv_sec =  0;
				tv.tv_usec =1000;
				setsockopt(sockid,SOL_SOCKET,SO_SNDTIMEO,(char *)&tv,sizeof(tv));
				setsockopt(sockid,SOL_SOCKET,SO_RCVTIMEO,(char *)&tv,sizeof(tv));
#endif
				
				int temp = DEVICE_TX_BUF_SIZE;
				setsockopt(sockid,SOL_SOCKET,SO_SNDBUF,(char *) &temp,sizeof(temp));
				temp = DEVICE_RX_BUF_SIZE;
				setsockopt(sockid,SOL_SOCKET,SO_RCVBUF,(char *) &temp,sizeof(temp)); 
				
				return sockid;
			}
			
			if((get_last_error()==EINPROGRESS)||(get_last_error()==EWOULDBLOCK))
			{
				ClosePort(sockid);
				return DEVICE_CONNECT_ERROR;
			}
		}
	}


	ClosePort(sockid);
	return DEVICE_CONNECT_ERROR;
}

int ClosePort(int id)
{
    struct linger linger;

    if(id>0)
    {
		linger.l_onoff = 1;
		linger.l_linger = 0;
		setsockopt(id, SOL_SOCKET, SO_LINGER, (char *)&linger,sizeof(linger));
		
#if defined (WIN32)
		unsigned long block_flag = FALSE;
		ioctlsocket(id,FIONBIO,&block_flag);
		for(int xx=0;xx<5;xx++)
		{
			int ret= closesocket(id);
			if (ret==0)  break;
			//	   AfxMessageBox("关闭SOCKET错误");
		}
#elif defined (__unix)
		close(id);
#endif
    }

	id=-1;
	return (0);
}

int ReadPort(int sock,char *buf,int size,int retry)
{
	if(sock<0)		return DEVICE_ID_ERROR;
	int rxn,rxnum = 0;
	if(size==0)		return DEVICE_READ_ERROR;
	if(buf==NULL)	return DEVICE_READ_ERROR;

#if defined(WIN32)
	int rxntime = 0;
#endif

	while(TRUE)
	{
		rxn = recv(sock,buf+rxnum,size-rxnum,0);
#if defined(__unix)
		if(rxn==0) break;
		if(rxn<0)
		{
			perror("ReadPort -- read"); 
			break; 
		}
#else
		if(rxn==SOCKET_ERROR)
		{
			if(WSAGetLastError()==WSAEWOULDBLOCK)
			{
				if((rxntime++)>=retry) return 0;	//break;
				delay_t(ONE_DELAY);
				continue;
			}
			else break;
		}
		else if(rxn==0) break;
#endif
		rxnum+=rxn;
		return rxnum;
	}

	return DEVICE_READ_ERROR;
}

int WritePort(int sock,char *buf,int size,int retry)
{
	if(sock<0) return DEVICE_ID_ERROR;

	char *ptr = (char *)buf;
	int txn, txsize;
	if(size==0)		return DEVICE_WRITE_ERROR;
	if(buf==NULL)	return DEVICE_WRITE_ERROR;

#if defined(WIN32)
	int txntime = 0;
#endif
	txsize=0;
	while(TRUE)
	{
		txn = send(sock,ptr,size,0);
#if defined(__unix)
		if(txn==0) break;
		if(txn<=0)
		{
			perror("CNetLink -- write"); 
			break; 
		}
#else
		if(txn==SOCKET_ERROR)
		{
			if(WSAGetLastError()==WSAEWOULDBLOCK)
			{
				if((txntime++)>=retry) break;
				delay_t(ONE_DELAY);
				continue;
			}
			else break;
		}
		else if(txn==0) break;
		txntime = 0;
#endif
		txsize += txn;
		size -= txn;
		ptr += txn;
		if(size>0) continue;

		return txsize;
	}

	return DEVICE_WRITE_ERROR;
}

int udp_open(char *dev)
{
	if(!dev) return DEVICE_NAME_ERROR;

	SOCKET		sockid;
	int			localport,remoteport;
	char		hostname[140];
	struct sockaddr_in txaddr, rxaddr;
	txaddr.sin_family = AF_INET;
	//txaddr.sin_port   = htons(4000);
	//txaddr.sin_addr.s_addr = inet_addr("192.168.1.168");

	if(split_name(dev, &remoteport,&localport ,hostname)<0)	   return DEVICE_NAME_ERROR;
	txaddr.sin_port   = htons(remoteport);
	txaddr.sin_addr.s_addr = inet_addr(hostname);
	if (txaddr.sin_addr.s_addr==INADDR_NONE)	return DEVICE_HOST_ERROR;

	rxaddr.sin_family = AF_INET;
	rxaddr.sin_port = htons(localport);
	rxaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	
	if((sockid=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP))<=0)
	{ 
#ifdef __unix
		perror("创建SOCKET失败");
#endif
		return DEVICE_CREATE_SOCK_ERROR;
	}

	if(bind(sockid,(struct sockaddr *)&rxaddr,sizeof(rxaddr))<0)
	{
#if defined  (__unix)
		close(sockid);
#elif defined(WIN32)
		closesocket(sockid);
#endif	
		return DEVICE_CREATE_SOCK_ERROR;
	}


#if defined(WIN32)
	int temp = TRUE;
	setsockopt(sockid,SOL_SOCKET,SO_BROADCAST,(char *)&temp,sizeof(temp));

	unsigned long block_flag = TRUE;
	ioctlsocket(sockid,FIONBIO, &block_flag);
#elif defined(__unix)
	fcntl(sockid,F_SETFL,O_NDELAY);
#endif	  

	temp = DEVICE_TX_BUF_SIZE;
	setsockopt(sockid,SOL_SOCKET,SO_SNDBUF,(char *) &temp,sizeof(temp));
	temp = DEVICE_RX_BUF_SIZE;
	setsockopt(sockid,SOL_SOCKET,SO_RCVBUF,(char *) &temp,sizeof(temp)); 

	return sockid;
}
/*
int udp_read(int  handle,char *buf,int len,char *dev)
{
	int			localport,remoteport;
	char		hostname[140];
 	struct sockaddr_in rxaddr;
	int addrlen = sizeof(rxaddr);

	rxaddr.sin_family = AF_INET;
	if(dev==NULL) {
		rxaddr.sin_port   = htons(0x1801);
		rxaddr.sin_addr.s_addr =  htonl(INADDR_BROADCAST);
	}
	else {
		if(split_name(dev, &remoteport,&localport, hostname)<0)	   return DEVICE_NAME_ERROR;
		rxaddr.sin_port   = htons(localport);
		rxaddr.sin_addr.s_addr = inet_addr(hostname);
		if (rxaddr.sin_addr.s_addr==INADDR_NONE) {
			return DEVICE_HOST_ERROR;
			//rxaddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
		}
	}

	int rxnum = recvfrom(handle,buf,len,0,(struct sockaddr *)&rxaddr,&addrlen);
	if(rxnum==	
#if defined(WIN32)
		SOCKET_ERROR
#elif defined(__unix)
		-1
#endif
		) 
		return DEVICE_READ_ERROR;	
	
	return rxnum;
}

int udp_write(int handle,char *buf,int len,char *dev)
{
	int			localport,remoteport;
	char		hostname[140];
 	struct sockaddr_in txaddr;
	int addrlen = sizeof(txaddr);
	
	txaddr.sin_family = AF_INET;
	if(split_name(dev, &remoteport,&localport ,hostname)<0)	   return DEVICE_NAME_ERROR;
	txaddr.sin_port   = htons(remoteport);

	txaddr.sin_addr.s_addr = inet_addr(hostname);
	if (txaddr.sin_addr.s_addr==INADDR_NONE) {
		txaddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
	}		

	int txnum = sendto(handle,(char *)buf,len,0,(struct sockaddr *)&txaddr,sizeof(txaddr));
	if (txnum ==
#if defined(WIN32)
		SOCKET_ERROR
#elif defined(__unix)
		-1
#endif
		) 
		return DEVICE_WRITE_ERROR;
	
	return txnum;
}
*/
int udp_read(int tdNo,int handle,char *buf,int len,char *dev)
{
	int			localport,remoteport;
	char		hostname[140];
 	struct sockaddr_in rxaddr;
	int addrlen = sizeof(rxaddr);

	rxaddr.sin_family = AF_INET;
	if(dev==NULL) {
		rxaddr.sin_port   = htons(0x1801);
		rxaddr.sin_addr.s_addr =  htonl(INADDR_BROADCAST);
	}
	else {
		if(split_name(dev, &remoteport,&localport, hostname)<0)	   return DEVICE_NAME_ERROR;
		rxaddr.sin_port   = htons(localport);
		if(G_Channel.DynamicIpFlag >0)
			rxaddr.sin_addr.s_addr =  htonl(INADDR_BROADCAST);
		else
		{
			rxaddr.sin_addr.s_addr = inet_addr(hostname);
			if (rxaddr.sin_addr.s_addr==INADDR_NONE) {
				return DEVICE_HOST_ERROR;
				//rxaddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
			}
		}
	}

	int rxnum = recvfrom(handle,buf,len,0,(struct sockaddr *)&rxaddr,&addrlen);
	if(rxnum==	
#if defined(WIN32)
		SOCKET_ERROR
#elif defined(__unix)
		-1
#endif
		) 
		return DEVICE_READ_ERROR;	
	if(G_Channel.DynamicIpFlag >0)
	{
		if (G_Channel.chan_data[tdNo].PrefixByteFlag)
		{
			if( rxnum >= 4)
			{
				rxnum -= 4;
				if (rxnum > 0)	memmove(buf, &buf[4], rxnum);
				
			}
			else rxnum =0;
		}
	
		G_Channel.chan_data[tdNo].addr = rxaddr.sin_addr;
	}

	return rxnum;
}

int udp_write(int tdNo,int handle,char *buf,int len,char *dev)
{
	int			localport,remoteport;
	char		hostname[140];
 	struct sockaddr_in txaddr;
	int addrlen = sizeof(txaddr);
	
	txaddr.sin_family = AF_INET;
	if(split_name(dev, &remoteport,&localport ,hostname)<0)	   return DEVICE_NAME_ERROR;
	txaddr.sin_port   = htons(remoteport);

	if(G_Channel.DynamicIpFlag>0)
		txaddr.sin_addr = G_Channel.chan_data[tdNo].addr;  //inet_addr(hostname);
	else
		txaddr.sin_addr.s_addr = inet_addr(hostname);

	if (txaddr.sin_addr.s_addr==INADDR_NONE) {
		txaddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
	}		
	int txnum = sendto(handle,(char *)buf,len,0,(struct sockaddr *)&txaddr,sizeof(txaddr));
	if (txnum ==
#if defined(WIN32)
		SOCKET_ERROR
#elif defined(__unix)
		-1
#endif
		) 
		return DEVICE_WRITE_ERROR;
	
	return txnum;
}

int udp_close(int handle)
{
    if(handle>0)
    {
#if defined (WIN32)
		int temp = 0;
		setsockopt(handle,SOL_SOCKET,SO_BROADCAST,(char *)&temp,sizeof(temp));
		int ret= closesocket(handle);
#elif defined (__unix)
		close(handle);
#endif
    }

	handle=-1;
	return (0);
}

//*******************************************************
void delay_t(int n)
{
#if defined (WIN32)
	Sleep(n/1000);
#elif defined (__unix)
	struct timeval tt;
	tt.tv_sec=n/1000000;
	tt.tv_usec=n%1000000;
	select(0,0,0,0,&tt);
#endif
}

int get_last_error()
{
#if defined (WIN32)
	return GetLastError();
#elif defined (__unix)
	#if   defined (__alpha)
		  return _Geterrno();
	#elif defined(__linux)
		  return errno;	
	#elif defined (__sun)
		  return errno;
#endif
#endif
}