sockwrap.cpp

Windows Socket封装类,网络编程有

/*
 *	Summary:
 *		网络封装类库源文件
 *	Description:
 *		对Windows基本Socket控制数据和函数进行封装实现
 *	Author:
 *		Steven Lee
 *	Version:
 *		1.0.0
 *	History:
 *		2004.4.17创建本文件
 */

#include <windows.h>
#include <assert.h>
#include <tchar.h>
#include <stdio.h>

#include "SockWrap.h"

#pragma comment(lib,"Ws2_32")

namespace Lee
{
	namespace Net
	{
		/************************************************************************/
		/* CWinsockets实现                                                      */
		/************************************************************************/
	
		bool CWinsockets::StartUp(const byte majorVer, const byte minorVer)
		{
			WORD	wVersion = MAKEWORD(majorVer,minorVer);
			WSADATA	wsaData;

			if( WSAStartup(wVersion,&wsaData) != 0 )
				return false;

			if( LOBYTE(wsaData.wVersion) != majorVer 
				&& HIBYTE(wsaData.wVersion) != minorVer )
			{
				CleanUp();
				return false;
			}

			return true;
		}

		bool CWinsockets::CleanUp()
		{
			return WSACleanup() == 0;
		}

		int CWinsockets::GetLastError()
		{
			return WSAGetLastError();
		}
		
		void CWinsockets::SetLastError(int iError)
		{
			WSASetLastError(iError);
		}

		bool CWinsockets::IsIPString(LPCTSTR lpctExpr)
		{
			assert( lpctExpr );

			int	b1,b2,b3,b4;
			int	dots = _stscanf( lpctExpr,_T("%d.%d.%d.%d"),&b1,&b2,&b3,&b4 );
			
			return 4 == dots;
		}
		
		/************************************************************************/
		/*  CSockaddr实现                                                       */
		/************************************************************************/

		CSockaddr::CSockaddr()
		{
			sin_family = AF_INET;
			sin_port = 0;
			ZeroMemory(&sin_addr,sizeof(struct in_addr));
			ZeroMemory(sin_zero,8);
		}

		CSockaddr::CSockaddr(const CSockaddr& addr)
		{
			sin_family = addr.sin_family;
			sin_port = addr.sin_port;
			memcpy(&sin_addr,&addr.sin_addr,sizeof(struct in_addr));
			memcpy(sin_zero,addr.sin_zero,8);
		}

		CSockaddr::CSockaddr(const u_short port, LPCTSTR lpctAddr, const u_short family)
		{
			sin_family = family;
			SetPort( port );
			SetIP( CInAddr( lpctAddr ) );
		}

		CSockaddr::CSockaddr(const u_short port, const CInAddr& inAddr, 
			const u_short family)
		{
			sin_family = family;
			SetPort( port );
			SetIP( inAddr );
		}
		
		const u_short CSockaddr::GetPort() const
		{
			return ntohs(sin_port);
		}

		void CSockaddr::SetPort(const u_short port)
		{
			sin_port = htons(port);
		}

		/************************************************************************/
		/* CSockaddr::CInAddr实现                                               */
		/************************************************************************/
				
		CSockaddr::CInAddr::CInAddr(LPCTSTR lpctAddr)
		{
			CInAddr();
			
			if( !EncodeAddr(lpctAddr) )
				ResolveAddr(lpctAddr);
		}

		CSockaddr::CInAddr CSockaddr::CInAddr::GetLocalIP()
		{
			char				szHost[MAX_PATH];
			struct hostent*		lpHost;
			struct in_addr		in;
			
			if( gethostname( szHost,MAX_PATH ) == 0 )
			{			
				lpHost = gethostbyname( szHost );
				if( !lpHost )
					return NULL;
				
				memcpy( &in.s_addr,lpHost->h_addr_list[0],sizeof(struct in_addr) );
			}
			else
				in.s_addr = INADDR_NONE;

			return CSockaddr::CInAddr(in);
		}

		bool CSockaddr::CInAddr::EncodeAddr(LPCTSTR lpctIP)
		{
			assert( lpctIP );

#ifdef UNICODE
			char	szAddr[MAX_PATH];
			
			if( WideCharToMultiByte( CP_ACP,0,lpctIP,-1,szAddr,MAX_PATH,NULL,NULL ) == 0 )
				return false;
			
			return (s_addr = inet_addr( szAddr )) != INADDR_NONE;
#else
			return (s_addr = inet_addr( lpctIP )) != INADDR_NONE;
#endif
		}

		bool CSockaddr::CInAddr::ResolveAddr(LPCTSTR lpctHost)
		{
			assert( lpctHost );

			if( CWinsockets::IsIPString( lpctHost ) )
				return EncodeAddr( lpctHost );

			struct hostent*		lpHostent;
#ifdef UNICODE
			char				szName[MAX_PATH];
			
			if( WideCharToMultiByte( CP_ACP,0,lpctHost,-1,szName,MAX_PATH,NULL,NULL ) == 0 )
				return false;
			lpHostent = gethostbyname( szName );
#else
			lpHostent = gethostbyname( lpctHost );
#endif
			if( !lpHostent )
				return false;
			
			memcpy( &s_addr,lpHostent->h_addr_list[0],sizeof(struct in_addr) );

			return true;
		}

		LPCTSTR	CSockaddr::CInAddr::ToString()
		{
#ifdef UNICODE
			static TCHAR			szIP[MAX_PATH];
			char*					lpIP;

			lpIP = inet_ntoa( *this );
			if( !lpIP )
				return NULL;
			
			if( MultiByteToWideChar( CP_ACP,0,lpIP,-1,szIP,MAX_PATH ) == 0 )
				return NULL;

			return szIP;
#else
			return inet_ntoa( *this );
#endif
		}

		/************************************************************************/
		/* CSockBase类实现                                                      */
		/************************************************************************/

		CSockBase::CSockBase(int type, int af, int protocol)
		{
			m_hSock = socket( af,type,protocol );
		}

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

		bool CSockBase::Select(DWORD dwMicroSec, SockSelectType type)
		{
			fd_set			fds;
			struct timeval	timeout;
			int				rc = 0;

			FD_ZERO( &fds );
			FD_SET( m_hSock,&fds );

			timeout.tv_sec = dwMicroSec / 1000;
			timeout.tv_usec = dwMicroSec % 1000;

			switch( type ) 
			{
				case SST_READ:
					rc = select( m_hSock + 1,&fds,NULL,NULL,&timeout );
					break;
				case SST_WRITE:
					rc = select( m_hSock + 1,NULL,&fds,NULL,&timeout );
					break;
				case SST_EXCEPT:
					rc = select( m_hSock + 1,NULL,NULL,&fds,&timeout );
					break;
				default:
					return false;
			}

			if( rc > 0 && FD_ISSET( m_hSock,&fds ) )
				return true;
			
			return false;
		}

		bool CSockBase::Close()
		{
			if( m_hSock != INVALID_SOCKET )
			{
				if( closesocket( m_hSock ) != 0 )
					return false;
				
				m_hSock = INVALID_SOCKET;
			}

			return true;
		}

		/************************************************************************/
		/* CServerSocket类实现                                                  */
		/************************************************************************/
		
		bool CServerSocket::Bind(const CSockaddr& addr)
		{
			return bind( m_hSock,addr,sizeof(struct sockaddr) ) == 0;
		}

		bool CServerSocket::Listen(const int backlog)
		{
			return listen( m_hSock,backlog ) == 0;
		}

		/************************************************************************/
		/* CTcpServer类实现                                                     */
		/************************************************************************/

		bool CTcpServer::Wait(const DWORD dwTimeout)
		{
			return Select( dwTimeout,CSockBase::SST_READ );
		}

		bool CTcpServer::Accept(CTcpClient& client, CSockaddr* lpAddr)
		{
			CSockaddr	addr;
			int			addr_len = sizeof(struct sockaddr);

			client.Close();

			SOCKET	hSock = accept( m_hSock,addr,&addr_len );
			if( !client.Attach(hSock) )
				return false;

			if( lpAddr )
				*lpAddr = addr;

			return true;
		}

		/************************************************************************/
		/* CTcpClient类实现                                                     */
		/************************************************************************/
		
		bool CTcpClient::Connect(const CSockaddr& srvAddr)
		{
			if( !Close() )
				return false;

			m_hSock = socket( AF_INET,SOCK_STREAM,0 );
			if( INVALID_SOCKET == m_hSock )
				return false;

			return connect( m_hSock,srvAddr,sizeof(struct sockaddr) ) == 0;
		}

		bool CTcpClient::Attach(const SOCKET hSocket)
		{
			if( !Close() || INVALID_SOCKET == hSocket )
				return false;

			m_hSock = hSocket;

			return true;
		}

		int CTcpClient::Read(char * buf, int len)
		{
			return recv( m_hSock,buf,len,0 );
		}

		int CTcpClient::Write(const char* buf,int len)
		{
			return send( m_hSock,buf,len,0 );
		}

		bool CTcpClient::ReadBuffer(char* buf, int len)
		{
			int	nRead = 0;

			while( len > 0 )
			{
				nRead = Read( buf,len );
				if ( SOCKET_ERROR == nRead )
					return false;
				buf += nRead;
				len -= nRead;
			}

			return true;
		}

		bool CTcpClient::WriteBuffer(char* buf, int len)
		{
			int	nWrite = 0;

			while( len > 0 )
			{
				nWrite = Write( buf,len );
				if( SOCKET_ERROR == nWrite )
					return false;
				buf += nWrite;
				len -= nWrite;
			}

			return true;
		}
	}
}