tcpsocket.cpp

网络socket,IO,线程池

/*
   2003 by zhy
*/
#include "stdafx.h"
#include <winsock2.h>
#pragma comment(lib,"Ws2_32")

#include "TcpSocket.h"
using namespace NET;

#include "../include/exception.h"
using namespace CommonInclude;


  
////////////////////////////////////////////////////////////////////////////
// Constructors / Destructor                                              //
////////////////////////////////////////////////////////////////////////////

// Constructor
CTcpSocket::CTcpSocket(SOCKET sock) : CSocketBase(sock,sock == INVALID_SOCKET ? CSocketBase::STATE_CLOSE : CSocketBase::STATE_OPEN),
													   m_timeout(1),m_timeoutU(0),m_isserver(false)
{
	memset(&m_peeradd, 0, sizeof(m_peeradd));
	m_peeradd.sin_family = AF_INET;
}

// Destructor
CTcpSocket::~CTcpSocket()
{
	Close();
}

////////////////////////////////////////////////////////////////////////////
// Inline Set/Get Operations                                              //
////////////////////////////////////////////////////////////////////////////

// if success,return 0
inline	int 	CTcpSocket::Getsockname()
{
	if ( m_sock==INVALID_SOCKET ) 
		return -1;
	int ret = ::getsockname(m_sock,(struct sockaddr *)&m_sockadd, (int *) &m_nLensockaddr);
	return ret;
}

inline	bool 	CTcpSocket::Getsockip(unsigned char* ip)
{
	char hostname[256];	
	gethostname(hostname,256);

	struct in_addr result = GetIPAddr( hostname );
	ip[0] = result.S_un.S_un_b.s_b1;
	ip[1] = result.S_un.S_un_b.s_b2;
	ip[2] = result.S_un.S_un_b.s_b3;
	ip[3] = result.S_un.S_un_b.s_b4;	
	
}

inline	bool 	CTcpSocket::Getsockip(string& ip)
{
    unsigned char cip[4];
    Getsockip(cip);
	char buf[10];
	ip = "";	
	for(int i = 0; i < 4; i++)
	{
		itoa(cip[i],buf,10);
        ip += buf;
		if(i != 3)
			ip += ".";
	}
	
}

// if success,return 0
inline	int	CTcpSocket::Getpeername()
{
	if ( m_sock==INVALID_SOCKET ) 
		return -1;
	int ret = ::getpeername(m_sock,(struct sockaddr *)&m_peeradd, (int *)&m_nLenpeeraddr);

	return ret;
}

inline	bool 	CTcpSocket::Getpeerip(unsigned char* ip)
{	
	if(0 == Getpeername())
	{
		memcpy(ip,&m_peeradd.sin_addr.S_un.S_un_b,sizeof(in_addr));
		return true;
	}	
	return false;
}

inline	bool 	CTcpSocket::Getpeerip(string& ip)
{
   	unsigned char cip[4];
    	if(!Getpeerip(cip))
    		return false;
    	
	char buf[10];
	ip = "";	
	for(int i = 0; i < 4; i++)
	{
		itoa(cip[i],buf,10);
        	ip += buf;
		if(i != 3)
			ip += ".";
	}
	return true;
}


////////////////////////////////////////////////////////////////////////////
// Operations		                                                  //
////////////////////////////////////////////////////////////////////////////
bool	CTcpSocket::Listen(unsigned short port,int len,unsigned long ip,bool boBlocking)
{
 	struct sockaddr_in sin;
	memset(&sin,0,sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_addr.s_addr=htonl(ip);

	if (m_sock!=INVALID_SOCKET) 
		Close();
	
	sin.sin_port = htons(port);
	Initsocket(AF_INET, SOCK_STREAM,0);	
	int arg=1;
	
	setsockopt(m_sock,SOL_SOCKET,SO_REUSEADDR,(char*)&arg,sizeof(arg));
	
	if (bind(m_sock,(struct sockaddr *)&sin,sizeof(sin))!=0)		
	{	
		Onlyclose();
		return false;			
	}

	u_long flag = !boBlocking;	
	if (ioctlsocket( m_sock, FIONBIO , &flag ) == -1)
	{
		Onlyclose();
		return false;			
	}
	if (::listen(m_sock,len)!=0 )
	{
		Onlyclose();
		return false;
	}
	return true;		
}

bool	CTcpSocket::Connect(const char * ip,unsigned short port)
{
	struct sockaddr_in sin;
	memset(&sin,0,sizeof(sin));
	sin.sin_family = AF_INET;

	if (m_sock != INVALID_SOCKET) 
		Close();

	sin.sin_port = htons(port);
	sin.sin_addr = GetIPAddr( ip );

	if(false == Initsocket(AF_INET, SOCK_STREAM,0))
		return false;

	u_long flag = 0;		
	ioctlsocket( m_sock, FIONBIO , &flag );

	if (::connect(m_sock,(struct sockaddr *)&sin,sizeof(sin))==0)
	{
		flag = 0;
		ioctlsocket( m_sock, FIONBIO , &flag );
		
		return true;
	}
	
	Onlyclose();
	return false;		
}
 
bool  CTcpSocket::Accept(CTcpSocket& tcpSocket)
{
	if ( m_sock == INVALID_SOCKET )
		return false;

	struct sockaddr_in fsin;
	int alen=sizeof(fsin);
	SOCKET sock = ::accept(m_sock,(struct sockaddr *)&fsin,(int *)&alen);
	if(INVALID_SOCKET == sock)
		return false;

	tcpSocket.FromSocket(sock,&fsin,&alen);

	return true;
}

bool 	CTcpSocket::Acceptfrom(CTcpSocket& slisten)
{
	if ( slisten.m_sock==INVALID_SOCKET ) 
		return false;

	if ( m_sock != INVALID_SOCKET) 
		Close();

	struct sockaddr_in fsin;
	int alen=sizeof(fsin);
	m_sock= ::accept(slisten.m_sock,(struct sockaddr *)&fsin,(int *) &alen);
	if(m_sock == INVALID_SOCKET)
		return false;

	return true;
}

////////////////////////////////////////////////////////////////////////////
// the Main R/W Operation						  //	
////////////////////////////////////////////////////////////////////////////

// Write
int	CTcpSocket::Write(const void * lpszBuf,size_t nByteCount)
{
	int cc = -1;
	if (m_sock == INVALID_SOCKET) 
		return -1;

	if ( (cc = SocketTimeCheck( m_sock,2,m_timeout,m_timeoutU)) == 0)
     		cc = ::send( m_sock, reinterpret_cast<const char *>(lpszBuf), nByteCount,0); 

	return cc;
}

// Read
int 	CTcpSocket::Read(void * lpszBuf,size_t nBufSize)
{
	int cc = -1;
	if ( m_sock == INVALID_SOCKET ) 
		return -1;

	if ( (cc = SocketTimeCheck( m_sock,1,m_timeout,m_timeoutU)) == 0)
		cc = ::recv(m_sock,reinterpret_cast<char *>(lpszBuf),nBufSize,0);

	return cc;
}

////////////////////////////////////////////////////////////////////////////
//  About Close Operations		                                  //
////////////////////////////////////////////////////////////////////////////

void	 CTcpSocket::Close()
{
	CSocketBase::Close();
}

void 	CTcpSocket::Shutdown()
{
	CSocketBase::Shutdown();
}

void 	CTcpSocket::Onlyclose()
{
	CSocketBase::Onlyclose();
}

////////////////////////////////////////////////////////////////////////////
// Inner Operations		                                          //
////////////////////////////////////////////////////////////////////////////
void	CTcpSocket::FromSocket(SOCKET id) 
{
	m_nState = (id == INVALID_SOCKET ? CSocketBase::STATE_CLOSE : CSocketBase::STATE_OPEN);
	m_sock = id;
	
	m_timeout = 1;
	m_timeoutU = 0;
}

void	CTcpSocket::FromSocket(SOCKET id ,struct sockaddr_in  *name, int *namelen) 
{
	m_nState = (id == INVALID_SOCKET ? CSocketBase::STATE_CLOSE : CSocketBase::STATE_OPEN);
	m_sock = id;
	m_timeout = 1;
	m_timeoutU = 0;
	
	memcpy(&m_peeradd,name,*namelen);
	memcpy(&m_nLenpeeraddr,namelen,sizeof(int));
}