vrssocket.cpp

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

/***************************************************************************
                          vrssocket.cpp  -  description
                             -------------------
    begin                : 二  3月  4 11:42:06 CST 2003
    copyright            : (C) 2003 by |刘忠|
    email                : |[e-mail]|
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include "linuxh.h"

#include "vrssocket.h"
//---------------------------------------------------------------------------------------------
void VNetTS::PutString(char* Buf,char* Str,int Len)
{
	memset(Buf,0,Len);
	if(strlen(Str)>=Len) memcpy(Buf,Str,Len);
	else memcpy(Buf,Str,strlen(Str));
}

void VNetTS::GetString(char* Buf,char* Str,int Len)
{
	if(strlen(Buf)>Len){
		strncpy(Str,Buf,Len);
		strcat(Str,"\0");
	}
	else{
		strcpy(Str,Buf);
	}
}

unsigned long VNetTS::GetULong(unsigned char* Buf)
{
	return ntohl(*(unsigned long*)Buf);
}

unsigned short VNetTS::GetUShort(unsigned char* Buf)
{
	return ntohs(*(unsigned short*)Buf);
}

void VNetTS::SetULong(unsigned char* Buf,unsigned long Val)
{
	*(unsigned long*)Buf = htonl(Val);
}

void VNetTS::SetUShort(unsigned char* Buf,u_short Val)
{
	*(unsigned short*)Buf = htons(Val);
}

//---------------------------------------------------------------------------------------------

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

CRSSocket::CRSSocket()
{
	m_socket = SockInvalid;
	m_nSocketType = SOCK_DGRAM;
	Initialize();
}

CRSSocket::~CRSSocket()
{
	Close();
}

void CRSSocket::Initialize()
{
	memset(&m_sockDest,0,sizeof(m_sockDest));
	memset(&m_sockLocal,0,sizeof(m_sockLocal));
	memset(&m_sockRecvFrom,0,sizeof(m_sockRecvFrom));
	memset(m_MulticastIp,0,sizeof(m_MulticastIp));
}

void CRSSocket::Close()
{
	CloseMulticast();
	if(m_socket != SockInvalid ){
		close(m_socket);
	}
	m_socket = SockInvalid;
	m_nSocketType = SOCK_DGRAM;
	Initialize();
}	

void CRSSocket::CloseMulticast()
{
	if(strlen(m_MulticastIp)>0){
		struct ip_mreq mreq;
		bzero(&mreq, sizeof(struct ip_mreq));
		inet_aton(m_MulticastIp, &mreq.imr_multiaddr);
		mreq.imr_interface.s_addr = htonl(INADDR_ANY);	
    	SetSockOpt((int)IPPROTO_IP,IP_DROP_MEMBERSHIP,(char*)&mreq,sizeof(mreq));
    	memset(m_MulticastIp,0,20);
    }
}

int CRSSocket::Create(int nSocketType)
{
	Initialize();
	m_nSocketType = nSocketType;
	m_socket = socket(PF_INET, m_nSocketType, 0 );
	if(m_socket==SockInvalid) return RS_FAIL;
	else return RS_OK;
}

int CRSSocket::CreateClient(char* Address , UINT nSocketPort, int nSocketType,int BufSize)
{
	char port[20];
	sprintf(port,"%d",nSocketPort);
	return CreateClient(Address,port,nSocketType,BufSize);
}

int CRSSocket::CreateClient(char* Address, char* Port, int nSocketType,int BufSize)
{
	Initialize();
	m_nSocketType = nSocketType;
	m_socket = socket(PF_INET,m_nSocketType,0);
	if(m_socket!=SockInvalid){
		if(BufSize>0) SetRecvBufSize(BufSize);
		else if(BufSize<0) SetRecvBufSize(64*1024L);
		if(Connect(Address,Port)==RS_OK){
			return RS_OK;
		}
	}
	return RS_FAIL;
}

int CRSSocket::CreateMulticast(char* Address,int Port,int BufSize)
{
	int ret = RS_FAIL;
	strcpy(m_MulticastIp,Address);
	if(Create(SOCK_DGRAM)==RS_OK){
		SetReUseAddr(true);
		if(Bind(Address,Port)==RS_OK){
			if(BufSize>0) SetRecvBufSize(BufSize);
			struct ip_mreq mreq;
			bzero(&mreq, sizeof(struct ip_mreq));
			inet_aton(Address, &mreq.imr_multiaddr);
			mreq.imr_interface.s_addr = htonl(INADDR_ANY);
			if(SetSockOpt ((int)IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&mreq, sizeof(struct ip_mreq))==0){
				ret = RS_OK;
			}
		}
	}
	return ret;
}

int CRSSocket::SetMulticastTtl(unsigned char Ttl)
{
	return SetSockOpt(IPPROTO_IP,IP_MULTICAST_TTL,(char*)&Ttl,sizeof(Ttl));
}

int CRSSocket::SetMulticastLoop(unsigned char Loop)
{
	return SetSockOpt(IPPROTO_IP,IP_MULTICAST_LOOP,(char*)&Loop,sizeof(Loop));
}

int CRSSocket::Connect(char* destAddr,int destPort)
{
	char Port[10];
	sprintf(Port,"%d",destPort);
	return Connect(destAddr,Port);	
}

int CRSSocket::Connect(char* destAddr,char* destPort)
{
	struct hostent pphhee,*phe;
	char   phebuf[1024];
	int    herr;
    struct sockaddr_in sin;
 	
	memset(&sin,0,sizeof(sin));
	sin.sin_family = AF_INET;
	if ((sin.sin_port = htons((u_short)atoi(destPort)))==0)
	{
		return RS_FAIL;
	}

	//search hostname
	gethostbyname_r(destAddr,&pphhee,phebuf,1024,&phe,&herr);
	// phe=gethostbyname(destAddr);
	if(phe){
		memcpy(&sin.sin_addr, phe->h_addr, phe->h_length);
	}
	else if((sin.sin_addr.s_addr = inet_addr(destAddr))== INADDR_NONE )
	{
		return RS_FAIL;
	}

	memcpy(&m_sockDest,&sin,sizeof(sin));	
	if(m_nSocketType==SOCK_DGRAM)
	{
		int share=1;
		sin.sin_family=AF_INET ;
		sin.sin_port=0 ;
		sin.sin_addr.s_addr=INADDR_ANY ;
		SetSockOpt((int)SOL_SOCKET,SO_REUSEADDR,(char*)&share,sizeof(share));
		if(bind(m_socket,(struct sockaddr*)&sin,sizeof(sin))==SockError)
		{
			close(m_socket);
			m_socket = SockInvalid;
		}
		else
		{
			socklen_t namelen=sizeof(m_sockLocal);
			getsockname(m_socket,&m_sockLocal,&namelen);
		}
	}
	if(connect(m_socket, (struct sockaddr*)&m_sockDest, sizeof(m_sockDest))==SockError)
	{
		close(m_socket);
		m_socket = SockInvalid;
	}
    
	if(m_socket==SockInvalid) return RS_FAIL;
	else return RS_OK;
}

int CRSSocket::Connect(char* destAddr,int destPort,long MSec)
{
	struct hostent pphhee,*phe;
	char phebuf[1024];
	int  herr;
    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;
	}

	//search hostname
	gethostbyname_r(destAddr,&pphhee,phebuf,1024,&phe,&herr);
	// phe = gethostbyname(destAddr);
	if(phe){
		memcpy(&sin.sin_addr, phe->h_addr, phe->h_length);
	}
	else if((sin.sin_addr.s_addr = inet_addr(destAddr))== INADDR_NONE )
	{
		return RS_FAIL;
	}

	memcpy(&m_sockDest,&sin,sizeof(sin));	
	if(m_nSocketType==SOCK_DGRAM)
	{
		int share=1;
		sin.sin_family=AF_INET ;
		sin.sin_port=0 ;
		sin.sin_addr.s_addr=INADDR_ANY ;
		SetSockOpt((int)SOL_SOCKET,SO_REUSEADDR,(char*)&share,sizeof(share));
		if(bind(m_socket,(struct sockaddr*)&sin,sizeof(sin))==SockError)
		{
			close(m_socket);
			m_socket = SockInvalid;
		}
		else
		{
			socklen_t namelen=sizeof(m_sockLocal);
			getsockname(m_socket,&m_sockLocal,&namelen);
		}
	}

	SetNonBlockMode(1);
	int ret = connect(m_socket, (struct sockaddr*)&m_sockDest, sizeof(m_sockDest));
	if(ret!=0){
		fd_set fdw,fdr;
		FD_ZERO( &fdw );
		FD_SET(m_socket, &fdw );
		fdr = fdw;
		ret = Select(&fdr,&fdw,NULL,MSec);
		if(ret<=0){
	    	SetNonBlockMode(0);
			close(m_socket);
			m_socket = SockInvalid;
			return RS_TIMEOUT;
		}
		else{
			if(FD_ISSET(m_socket,&fdr) || !FD_ISSET(m_socket,&fdw)){
				SetNonBlockMode(0);
				close(m_socket);
				m_socket = SockInvalid;
				return RS_FAIL;		
			}
		}
	} 
    SetNonBlockMode(0);
	
	if(m_socket==SockInvalid) return RS_FAIL;
	else return RS_OK;
	
}

int CRSSocket::SelectWait(long SEvent,long MSec)
{
    fd_set fdr,fdw,*pfdr=NULL,*pfdw=NULL;
    if(SEvent & FD_READ){
		FD_ZERO(&fdr);
		pfdr = &fdr;
		FD_SET(m_socket, &fdr);
	}
	if(SEvent & FD_WRITE){
		FD_ZERO(&fdw);
		pfdw = &fdw;
		FD_SET(m_socket, &fdw);
	}
	int sn=Select(pfdr,pfdw, NULL,MSec);
	if (sn > 0){
		if(SEvent==FD_READWRITE){
			if(FD_ISSET(m_socket, pfdr) && FD_ISSET(m_socket,pfdw)) { 
				return (sn = FD_READWRITE);
			}
			else if(FD_ISSET(m_socket, pfdr)){
				return (sn = FD_READ);
			}
			else if(FD_ISSET(m_socket, pfdw)){
				return (sn = FD_WRITE);
			}
		}
		else if(SEvent==FD_READ){
			if(FD_ISSET(m_socket, pfdr)){
				return (sn = FD_READ);
			}
		}
		else if(SEvent==FD_WRITE){
			if(FD_ISSET(m_socket, pfdw)){
				return (sn = FD_WRITE);	
			}
		}
		sn = FD_NONE;
	}	
	return sn;
}

int CRSSocket::Select(fd_set *readfds, fd_set *writefds,fd_set *exceptfds,long msec)
{
	struct timeval tv,*ptv=NULL;
	if(msec>0){
		tv.tv_sec = msec / 1000;
		tv.tv_usec = (msec % 1000)*1000;
		ptv = &tv;
	}
	return select(m_socket+1,readfds,writefds,exceptfds,ptv);
}

int CRSSocket::SetRecvBufSize(int bufsize)
{	
	return SetSockOpt(SOL_SOCKET,SO_RCVBUF,(char*)(&bufsize),sizeof(bufsize));
}

int CRSSocket::SetSendBufSize(int bufsize)
{
	return SetSockOpt(SOL_SOCKET,SO_SNDBUF,(char*)(&bufsize),sizeof(bufsize));
}

int CRSSocket::SetLinger(int OnOff,int LSec)
{
    struct linger lg;
    lg.l_onoff= OnOff?1:0;
    lg.l_linger= LSec;
    return SetSockOpt(SOL_SOCKET,SO_LINGER,(const char*)&lg,sizeof(lg));	
}

int CRSSocket::SetReUseAddr(bool bReUse)
{
	int Share= (bReUse)?1:0;
   	return SetSockOpt (SOL_SOCKET, SO_REUSEADDR, (const char*)&Share, sizeof (Share));
}

int CRSSocket::SetTcpNoDelay(bool bNoDelay)
{
	int One = (bNoDelay?1:0);
	return 0; //SetSockOpt(IPPROTO_TCP, TCP_NODELAY, (const char * ) &One, sizeof (One));
}

int CRSSocket::SetSockOpt(int level,int optname,const char *optval,int optlen)
{
   return setsockopt(m_socket,level,optname,optval,optlen);
}

int CRSSocket::GetSockOpt(int level,int optname,char *optval,int *optlen)
{
   return getsockopt(m_socket,level,optname,optval,(socklen_t*)optlen);
}

int CRSSocket::Send(char* pData, int nLen)
{
	if( m_socket == SockInvalid )
	{
		return RS_FAIL;
	}
	int len = send(m_socket,pData,nLen,0);
	if(len==SockError) return RS_FAIL;
	else return len;
}

int CRSSocket::Recv(char* pData, int nLen)
{
	if( m_socket == SockInvalid )
	{
		return RS_FAIL;
	}
	int len = recv(m_socket,pData,nLen,0);
	if(len==SockError) return RS_FAIL;
	else return len;
}

int CRSSocket::RecvPeek(char* pData, int nLen)
{
	if( m_socket == SockInvalid )
	{
		return RS_FAIL;
	}
	int len = recv(m_socket,pData,nLen,MSG_PEEK);
	if(len==SockError) return RS_FAIL;
	else return len;
}