vrssocket.cpp

otl简单包装实现类,对数据库进行操作的,简单易用.

int CRSSocket::Writen(char* pData,int nLen)
{
	int sLen = 0,n;
	while(sLen<nLen){
		 n = Send(pData+sLen,nLen-sLen);
		 if(n==-1) return -1;
		 else if(n==0) break;
		 sLen += n;
	}
	return sLen;
}

int CRSSocket::Writen(char* pData,int nLen,int MSec)
{
	if(MSec==0) return Writen(pData,nLen);
	int sLen = 0,n,sn;
	fd_set fdw;
	while(sLen<nLen){
		 FD_ZERO(&fdw);
		 FD_SET(m_socket,&fdw);
		 sn = Select(NULL,&fdw,NULL,MSec);
		 if(sn>0){
		 	n = Send(pData+sLen,nLen-sLen);
		 	if(n==-1) return -1;
		 	else if(n==0) break;
		 	sLen += n;
		 }
		 else{
		 	return sn;
		 }
	}
	return sLen;
}

int CRSSocket::Readn(char* pData,int nLen)
{
	int rLen = 0,n;
	while(rLen<nLen){
		 n = Recv(pData+rLen,nLen-rLen);
		 if(n<0){
		      if(errno==EINTR) n=0;
		      else  return -1;
		 }
		 else if(n==0){
		    rLen = 0;
		    break;
		 }
		 rLen += n;
	}
	return rLen;	
}

int CRSSocket::Readn(char* pData,int nLen,int MSec)
{
	if(MSec==0) return Readn(pData,nLen);
	int rLen = 0,n,sn;
	fd_set  fdr;
	while(rLen<nLen){
		FD_ZERO(&fdr);
		FD_SET(m_socket,&fdr);
		sn = Select(&fdr,NULL,NULL,MSec);
		if(sn>0){ 
			n = Recv(pData+rLen,nLen-rLen);
			if(n<0){
			     if(errno==EINTR) n=0;
			     else return -1;
			}
			else if(n==0){
			    rLen = 0;
			    break;
			}
			rLen += n;
		}
		else{
			return RS_TIMEOUT;
		}
	}
	return rLen;	
}

int CRSSocket::ReadLine(char* pData,int MaxLen)
{
	int  n,rLen=0;
	char c, *ptr;

	ptr = pData;
	while(rLen<MaxLen){
		n = Recv(&c,1);
		if(n<0){
			if(errno==EINTR){
			    n=0;
			}
			else return -1;
		}
		else if(n==0){
			rLen = 0;
			break;
		}
		else{
			*ptr++ = c;
			rLen += n;
			if(c == '\n') break;	//readover
		}
	}
	*ptr = 0;
	return rLen;    
}

int CRSSocket::ReadLine(char* pData,int MaxLen,int MSec)
{
	int  n, sn,rLen=0;
	char c, *ptr;
	fd_set fdr;
    
    if(MSec<=0){
    	return ReadLine(pData,MaxLen);	
    }
	ptr = pData;
	while(rLen<MaxLen){
		FD_ZERO(&fdr);
		FD_SET(m_socket,&fdr);
		sn = Select(&fdr,NULL,NULL,MSec);
		if(sn>0){ 
			n = Recv(&c,1);
			if(n<0){
			     if(errno==EINTR){
			         n=0;
			     }
			     else return -1;
			}
			else if(n==0){
			    rLen = 0;
			    break;
			}
			else{
			    *ptr++ = c;
			    rLen += n;
			    if(c == '\n') break;	//readover
			}
		}
		else{
			return RS_TIMEOUT;
		}
	}
	*ptr = 0;
	return rLen;    
}

int CRSSocket::RecvFrom(char *pData, int nLen)
{
	if( m_socket ==SockInvalid)
	{
		return RS_FAIL;
	}
	socklen_t slen = sizeof(sockaddr);
	int len = recvfrom(m_socket,pData,nLen,0,&m_sockRecvFrom,&slen);
	if(len==SockError) return RS_FAIL;
	else return len;
}

int CRSSocket::RecvFrom(char* pData, int nLen,int MSec)
{
	if( m_socket ==SockInvalid)
	{
		return RS_FAIL;
	}
	if(MSec<=0) return RecvFrom(pData,nLen);
	int sn;
	fd_set  fdr;
	FD_ZERO(&fdr);
	FD_SET(m_socket,&fdr);
	sn = Select(&fdr,NULL,NULL,MSec);
	if(sn>0){ 
		return RecvFrom(pData,nLen);
	}
	else if(sn==0){
		return RS_TIMEOUT;
	}
	else return RS_FAIL;	
}

int CRSSocket::SendTo(char *pData, int nLen)
{
	if( m_socket == SockInvalid )
	{
		return RS_FAIL;
	}
	int len = sendto(m_socket,pData,nLen,0,&m_sockDest,sizeof(sockaddr));
	if(len==SockError) return RS_FAIL;
	else return len;
}

int CRSSocket::Bind(char *localAddr, int localPort)
{
	char Port[10];
	sprintf(Port,"%d",localPort);
	return Bind(localAddr,Port);
}

int CRSSocket::Bind(char *localAddr, char *localPort)
{
	if(m_socket == SockInvalid){
		return RS_FAIL;
	}
    struct hostent  pphhee,*phe;
    char  phebuf[1024];
    int   herr;
    struct sockaddr_in sin;
	memset(&sin,0,sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons((u_short)atoi(localPort));
	gethostbyname_r(localAddr,&pphhee,phebuf,herr,&phe,&herr);
	// phe = gethostbyname(localAddr);
	if(phe){
		memcpy(&sin.sin_addr, phe->h_addr, phe->h_length);
	}
	else if ((sin.sin_addr.s_addr = inet_addr(localAddr))== INADDR_NONE )
	{
		sin.sin_addr.s_addr = INADDR_ANY;
	}

	if(bind(m_socket,(struct sockaddr*)&sin,sizeof(sin))==SockError)
	{
		return RS_FAIL;
	}
	socklen_t namelen=sizeof(m_sockLocal);
	getsockname(m_socket,&m_sockLocal,&namelen);

	return RS_OK;
}

int CRSSocket::Listen(int BackLog)
{
	if(listen(m_socket,BackLog)==0){
		return RS_OK;
	}
	else{
		return RS_FAIL;
	}	
}

SOCKET CRSSocket::Accept(struct sockaddr *cliaddr,socklen_t *addrlen)
{
	SOCKET newsocket;
	newsocket = accept(m_socket,cliaddr,addrlen);
	return newsocket;
}

int  CRSSocket::Accept(CRSSocket* newrs)
{
	socklen_t addrlen = sizeof(struct sockaddr);
	SOCKET newsocket;
	while((newsocket = Accept(&m_sockDest,&addrlen))<0){
		if(errno!=EINTR) break;		
	}
	if(newsocket>=0){
		newrs->SetSocket(newsocket);
		newrs->SetDestAddr(&m_sockDest);
		newrs->SetLocalAddr(&m_sockLocal);
		
		return RS_OK;	
	}
	else{
		return RS_FAIL;
	}
}

void CRSSocket::SetSocket(SOCKET s)
{
	m_socket = s;	
}

int CRSSocket::SetDestAddr(char *destIP, char *destPort)
{
	char transport[10];
	if(m_nSocketType == SOCK_DGRAM)	strcpy(transport,"udp");
	else if(m_nSocketType == SOCK_STREAM) strcpy(transport,"tcp");
	else return RS_FAIL;

	struct hostent pphhee,*phe;
	struct servent* pse;
	struct sockaddr_in sin;
	char  phebuf[1024];
	int   herr;

	memset(&sin,0,sizeof(sin));
	sin.sin_family = AF_INET;
	if(pse=getservbyname(destPort,transport)){
		sin.sin_port = pse->s_port;
	}
	else if ((sin.sin_port = htons((u_short)atoi(destPort)))==0)
	{
		return RS_FAIL;
	}
	gethostbyname_r(destIP,&pphhee,phebuf,1024,&phe,&herr);
//	phe = gethostbyname(destIP);
	if(phe){
		memcpy(&sin.sin_addr, phe->h_addr, phe->h_length);
	}
	else if ((sin.sin_addr.s_addr = inet_addr(destIP))== INADDR_NONE )
	{
		return RS_FAIL;
	}
	memcpy(&m_sockDest,&sin,sizeof(sin));
	return RS_OK;
}

int CRSSocket::SetDestAddr(char *destIP, short destPort)
{
	struct hostent pphhee,*phe;
	struct servent* pse;
	struct sockaddr_in sin;
	char  phebuf[1024];
	int   herr;

	memset(&sin,0,sizeof(sin));
	sin.sin_family = AF_INET;
	if ((sin.sin_port = htons((u_short)destPort))==0)
	{
		return RS_FAIL;
	}
	gethostbyname_r(destIP,&pphhee,phebuf,1024,&phe,&herr);
	if(phe){
		memcpy(&sin.sin_addr, phe->h_addr, phe->h_length);
	}
	else if ((sin.sin_addr.s_addr = inet_addr(destIP))== INADDR_NONE )
	{
		return RS_FAIL;
	}
	memcpy(&m_sockDest,&sin,sizeof(sin));
	return RS_OK;
}

int CRSSocket::SetDestAddr(long destIP, short destPort)
{
	struct sockaddr_in sin;
	memset(&sin,0,sizeof(sin));
	sin.sin_family = AF_INET;
	if((sin.sin_port=htons((u_short)destPort))==0)
	{
		return RS_FAIL;
	}
	if ((sin.sin_addr.s_addr = htonl((u_long)destIP))== INADDR_NONE )
	{
		return RS_FAIL;
	}
	memcpy(&m_sockDest,&sin,sizeof(sin));
	return RS_OK;
}

int CRSSocket::SetDestNetAddr(long destIP, short destPort)
{
	struct sockaddr_in sin;

	memset(&sin,0,sizeof(sin));
	sin.sin_family = AF_INET;
	if((sin.sin_port=((u_short)destPort))==0)
	{
		return RS_FAIL;
	}
	if ((sin.sin_addr.s_addr = ((u_long)destIP))== INADDR_NONE )
	{
		return RS_FAIL;
	}
	memcpy(&m_sockDest,&sin,sizeof(sin));
	return RS_OK;
}

int CRSSocket::SetDestAddr(struct sockaddr* destAddr)
{
	//m_sockDest = *destAddr;	
	memcpy(&m_sockDest,destAddr,sizeof(m_sockDest));
	return RS_OK;
}
 
int CRSSocket::SetLocalAddr(struct sockaddr* localAddr)
{
	//m_sockLocal = *localAddr;
	memcpy(&m_sockLocal,localAddr,sizeof(m_sockLocal));
	return RS_OK;
}

SOCKET CRSSocket::GetSocket()
{
	return m_socket;
}

int CRSSocket::SetNonBlockMode(DWORD bBlock)
{
	if(ioctl(m_socket,FIONBIO,&bBlock)==0) return RS_OK;
	else return RS_FAIL;
}

int CRSSocket::GetUdpSize()
{
	socklen_t slen = sizeof(sockaddr);
	int len = recvfrom(m_socket,0,0,MSG_PEEK,&m_sockRecvFrom,&slen);
	if(len==SockError) return RS_FAIL;
	else return len;
}


int CRSSocket::GetNetAddr(sockaddr *sa, char *addr,int *port)
{
	sockaddr_in sin;
	memcpy(&sin,sa,sizeof(sin));
	sprintf(addr,"%s",inet_ntoa(sin.sin_addr));
	*port = ntohs(sin.sin_port);
	return RS_OK;
}

int CRSSocket::GetLocalAddr(char *addr,int *port)
{
	return GetNetAddr(&m_sockLocal,addr,port);
}

int CRSSocket::GetDestAddr(char *addr,int *port)
{
	return GetNetAddr(&m_sockDest,addr,port);
}

int CRSSocket::GetRecvFromAddr(char *addr,int *port)
{
	return GetNetAddr(&m_sockRecvFrom,addr,port);
}

int CRSSocket::GetLastSocketError()
{
	return  0;
}