sockwrap.h

Windows Socket封装类,网络编程有

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

#ifndef SOCK_WRAP_H_
#define SOCK_WRAP_H_

namespace Lee
{
	namespace Net
	{
		/*
		 *	Summary:
		 *		网络控制常用函数封装
		 */
		class CWinsockets
		{
		private:
			CWinsockets(){}
		public:
			/*
			 *	Summary:
			 *		启动socket库
			 *	Parameters:
			 *		majorVer	-	socket库主版本号
			 *		minorVer	-	socket库副版本号
			 *	Returns:
			 *		成功返回true，失败返回false
			 */
			static bool	StartUp(const byte majorVer = 2, const byte minorVer = 2);
			/*
			 *	Summary:
			 *		关闭socket库
			 *	Returns:
			 *		成功返回true，失败返回false
			*/
			static bool	CleanUp();
			//	获取最近错误值
			static int	GetLastError();
			/*
			 *	Summary:
			 *		设置最近错误值
			 *	Parameters:
			 *		iError	-	要设置的错误值
			 */
			static void	SetLastError(int iError);

			/*
			 *	Summary:
			 *		判断是否为点分法表示的IP地址字符串
			 *	Parameters:
			 *		lpctExpr	-	要判断的字符串
			 *	Returns:
			 *		判断成功true,失败返回false
			 */
			static bool	IsIPString(LPCTSTR lpctExpr);
		};
		
		//地址类型定义
		typedef	struct sockaddr		SOCKADDR, *LPSOCKADDR;
		typedef	struct sockaddr_in	SOCKADDR_IN, *LPSOCKADDR_IN;
		typedef	struct in_addr		IN_ADDR, *LPIN_ADDR;

		/*
		 *	Summary:
		 *		网络地址封装类
		 */
		class CSockaddr : public SOCKADDR_IN
		{
		public:
			class CInAddr;	//类前向声明，为了变态的M$vc6编译器！
		public:
			CSockaddr();
			CSockaddr(const CSockaddr& addr);
			CSockaddr(const u_short port, LPCTSTR lpctAddr, 
				const u_short family = AF_INET);
			CSockaddr(const u_short port, const CInAddr& inAddr, 
				const u_short family = AF_INET);

			//	获取地址簇
			const u_short	GetFamily()	const
			{	return	sin_family;		}
			//	设置地址簇
			void	SetFamily(const u_short family)
			{	sin_family = family;	}

			//	获取端口
			const u_short	GetPort()	const;
			//	设置端口
			void	SetPort(const u_short port);

			//	获取IP
			const CSockaddr::CInAddr	GetIP()	const
			{	return CInAddr( sin_addr );		}
			//	设置IP
			void	SetIP(const CInAddr inAddr)
			{	sin_addr.s_addr = inAddr.s_addr;	}

			operator	struct sockaddr*()	const
			{	return (struct sockaddr*)this;	}
		public:
			/*
			 *	Summary:
			 *		IP地址内嵌类
			 */
			class CInAddr : public IN_ADDR
			{
			public:
				//获取本地IP地址
				static CInAddr	GetLocalIP();
			public:
				CInAddr()
				{	s_addr = INADDR_NONE;	}
				CInAddr(const IN_ADDR& inAddr)
				{	s_addr = inAddr.s_addr;	}
				CInAddr(const CInAddr& inAddr)
				{	s_addr = inAddr.s_addr;	}
				CInAddr(LPCTSTR lpctAddr);

				/*
				 *	Summary:
				 *		转化点分法表示的IP地址
				 *	Parameters:
				 *		lpctID	-	点分法表示的IP地址字符串
				 *	Returns:
				 *		成功返回true，失败返回false
				 */
				bool	EncodeAddr(LPCTSTR lpctIP);
				/*
				 *	Summary:
				 *		解析主机名或地址字符串为IP地址
				 *	Parameters:
				 *		lpctHost	-	主机名称或地址
				 *	Returns:
				 *		成功返回true，失败返回false
				 */
				bool	ResolveAddr(LPCTSTR lpctHost);
				//	返回IP地址的点分法表示字符串
				LPCTSTR	ToString();
				//	地址是否合法
				bool	IsValid()
				{	return s_addr != INADDR_NONE;	}

				bool		operator	==	(const CInAddr& inAddr)
				{	return s_addr == inAddr.s_addr;	}
				bool		operator	!=	(const CInAddr& inAddr)
				{	return s_addr != inAddr.s_addr;	}
				CInAddr&	operator	=	(LPCTSTR lpctAddr)
				{	if( !ResolveAddr( lpctAddr ) )	s_addr = INADDR_NONE;
					return *this;					}
			};
		};

		/*
		 *	Summary:
		 *		网络socket类基类
		 */
		class CSockBase
		{
		public:
			typedef enum
			{	
				SST_READ	=	1,
				SST_WRITE	=	2,
				SST_EXCEPT	=	4
			} SockSelectType;
		protected:
			SOCKET	m_hSock;
		public:
			CSockBase(int type, int af = AF_INET, int protocol = 0);
			CSockBase()	{	m_hSock = INVALID_SOCKET;	}
			~CSockBase();

			//	判断网络连接是否有效
			bool	IsValid()
			{	return m_hSock != INVALID_SOCKET;	}

			bool	Select(DWORD dwMicroSec, SockSelectType type);
			virtual	bool	Close();
		};

		/*
		 *	Summary:
		 *		socket服务器类
		 */
		class CServerSocket : public CSockBase
		{
		protected:
			bool	Bind(const CSockaddr& addr);
		public:
			CServerSocket(int type, int af = AF_INET, int protocol = 0) : CSockBase(type,af,protocol)	{}

			bool	Listen(const int backlog = SOMAXCONN);
		};

		class CTcpClient;

		/*
		 *	Summary:
		 *		Tcp服务器类
		 */
		class CTcpServer : public CServerSocket
		{
		public:
			CTcpServer(const u_short port) : CServerSocket(SOCK_STREAM,AF_INET,0)
			{
				if ( m_hSock != INVALID_SOCKET ) 
					if ( !Bind( CSockaddr( port,CSockaddr::CInAddr::GetLocalIP() ) ) )
						Close();
			}

			/*
			 *	Summary:
			 *		等待一个客户连接
			 *	Parameters:
			 *		dwTimeout	-	超时时间
			 *	Returns:
			 *		如果有用户连接可以接收返回true，否则返回false
			 */
			bool	Wait(const DWORD dwTimeout);
			/*
			 *	Summary:
			 *		接入一个客户端连接
			 *	Parameters:
			 *		client	-	客户端连接
			 *		lpAddr	-	客户端地址信息，传入NULL时忽略
			 *	Returns:
			 *		成功返回true，失败返回false
			 */
			bool	Accept(CTcpClient& client, CSockaddr* lpAddr);
		};

		/*
		 *	Summary:
		 *		Tcp客户端类
		 */
		class CTcpClient : public CSockBase
		{
		public:
			CTcpClient() /*: CSockBase(SOCK_STREAM,AF_INET,0)*/	{}

			/*
			 *	Summary:
			 *		连接服务器
			 *	Parameters:
			 *		srvAddr	-	服务器地址
			 *	Returns:
			 *		成功返回true，失败返回false
			 */
			bool	Connect(const CSockaddr& srvAddr);
			/*
			 *	Summary:
			 *		绑定到socket连接
			 *	Parameters:
			 *		hSocket	-	要绑定的socket句柄
			 *	Returns:
			 *		成功返回true，失败返回false
			 */
			bool	Attach(const SOCKET hSocket);

			/*
			 *	Summary:
			 *		读取数据
			 *	Description:
			 *		读取网络数据，不会阻塞
			 *	Parameters:
			 *		buf	-	读取数据缓冲区
			 *		len	-	缓冲区大小
			 *	Returns:
			 *		读取成功返回读取字节数，否则返回SOCKET_ERROR
			 */
			int	Read(char* buf, int len);
			/*
			 *	Summary:
			 *		发送数据
			 *	Description:
			 *		发送网络数据，不会阻塞
			 *	Parameters:
			 *		buf	-	发送数据缓冲区
			 *		len	-	缓冲区大小
			 *	Returns:
			 *		发送成功返回发送数据大小，否则返回SOCKET_ERROR
			 */
			int	Write(const char* buf,int len);

			/*
			 *	Summary:
			 *		阻塞读取数据
			 *	Description:
			 *		以阻塞方式读取网络数据，直到数据读取完全或网络连接错误
			 *	Parameters:
			 *		buf	-	读取数据缓冲区
			 *		len	-	缓冲区大小
			 *	Returns:
			 *		成功返回true，失败返回false
			 */
			bool	ReadBuffer(char* buf, int len);
			/*
			 *	Summary:
			 *		阻塞发送数据
			 *	Description:
			 *		以阻塞方式发送网络数据，直到数据发送完全或网络连接错误
			 *	Parameters:
			 *		buf	-	发送数据缓冲区
			 *		len	-	缓冲区大小
			 *	Returns:
			 *		成功返回true，失败返回false
			 */
			bool	WriteBuffer(char* buf, int len);
		};
	}
}

#endif	//SOCK_WRAP_H_