Winsock开发基类

代码正文
/********************************************************************
created:	2010/11/30
filename: 	e:NewWorldCommonCSock.h
file base:	CSock
author:		Kingmoon
purpose:
使用方法与说明:
这个头文件包含了3个关于SOCKET的类.
CSock为CTcpSock和CListenSock的基类.他提供了SOCKET环境初始化.获得本机IP地址
的功能.用户一般只需使用CSock::InitEnvir()即可完成版本为2.2的winsock环境
初始化.这里最好在WinApp中完成Winsock初始化.每个Socket使用完应该调用Close
释放系统资源.
*********************
CListenSock使用:
1.InitSock->BindAddr->Listen
2.通过用
while(1)
{
	判断CListenSock::IORead
		Accept(CTcpSock,ADDR)
}
*********************
CTcpSock使用:
1.通过Connect或者SetTcpSock 设置传输Socket.
2.通过判断IORead判断是否可读.调用Recv();
3.调用Send()发送.
*********************************************************************/


#pragma once

#include <string>
#include <WinSock2.h>

#pragma comment(lib,"ws2_32.lib")

using namespace std;

class CTcpSock;
class CSock
{
public:
	CSock();	
	virtual ~CSock();

	static void InitEnvir();

	static int GetIpList(string arrIpList[]);

protected:
	SOCKET InitSocket(UINT Type=SOCK_STREAM);
	bool IORead(SOCKET sock);
	void CloseSocket(SOCKET sock);   //不要在派生类的析构函数中关闭sock.会导致拷贝的时候产生严重bug.
private:
	
};

class CListenSock:public CSock
{
public:
	CListenSock();
	virtual ~CListenSock();

	bool InitSock();
	bool BindAddr(const char* szaddr=NULL,int Port=0);
	bool Listen();
	bool IORead();
	bool Accept(CTcpSock& sock,sockaddr_in *addr=NULL);
	void Close();

private:
	SOCKET m_listen;
};

class CTcpSock:public CSock
{
public:

	CTcpSock();
	virtual ~CTcpSock();

	/*通过主动连接*/
	bool Conncet(const char* szaddr,int Port);
	/*通过监听套接字得到连接*/
	void SetTcpSock(SOCKET sock);

	bool Recv(char* szBuf,int nLen);
	bool Send(char* szBuf,int nLen);
	bool IORead();
	void Close();
	SOCKET GetSocket();
	void SetSocket(SOCKET sock);
	void SetLinkIP(char* szIP);
	char* GetLinkIP();

private:
	SOCKET m_Tcpsock;
	char m_szLinkIP[21];
};


//CPP

#include "stdafx.h"
#include "CSock.h"

CSock::CSock()
{
	
}

CSock::~CSock()
{

}

/**************************************************
Method:    InitEnvir
FullName:  CSock::InitEnvir
Access:    public   
Returns:   void <>
Parameter:  <>
Usage And Note: It just a static function.And Should
Use it in your application entrance or main. It just
can be used only once.
***************************************************/
void CSock::InitEnvir()
{
	WSAData wsd;
	WSAStartup(MAKEWORD(2,2),&wsd);
}


/**************************************************
Method:    InitSocket
FullName:  CSock::InitSocket
Access:    protected   
Returns:   SOCKET
<Return Initliaze socket if success or return 
SOCKET_ERROR if failed.>
Parameter: UINT [in]Type=SOCK_STREAM 
<Type=SOCK_STREAM/DGREAM>
Usage And Note: It can initialize the tcp socket or
udp socket .And when you derive from the base class
you can use it to initialize your socket.
***************************************************/
SOCKET CSock::InitSocket(UINT Type/* =SOCK_STREAM */)
{
	return socket(AF_INET,Type,0);
}

/**************************************************
Method:    GetIpList
FullName:  CSock::GetIpList
Access:    public   
Returns:   int 
<the count of Host Ip.it will return -1 if error.>
Parameter: string [out]arrIpList[]
<>
Usage And Note: Make sure you have the enough space 
to contain the array of Host Ip.Otherwise your application
will crash because of the "Memory Error".
***************************************************/
int CSock::GetIpList(string arrIpList[])
{
	char hostname[256];
	int count=0;
	memset(hostname,0,256);
	if(gethostname(hostname,256)==SOCKET_ERROR)
		goto GETIPLIST_FAIL;

	HOSTENT *host=gethostbyname(hostname);
	if(host==NULL)
		goto GETIPLIST_FAIL;

	while(1)
	{
		arrIpList[count]=inet_ntoa(*(IN_ADDR*)host->h_addr_list[count]);
		if(host->h_addr_list[count]+host->h_length>=host->h_name)
			break;
		count++;
	}
	goto GETIPLIST_SUCCESS;

GETIPLIST_FAIL:
	return -1;
GETIPLIST_SUCCESS:
	return count+1;
}

/**************************************************
Method:    IORead
FullName:  CSock::IORead
Access:    protected   
Returns:   bool 
<if the socket can be read return 1.otherwise return 0>
Parameter: SOCKET [in]sock
<the checked of the socket.>
Usage And Note:It will block 100s to Check the Socket
is it can be read.
***************************************************/
bool CSock::IORead(SOCKET sock)
{
	if(sock==SOCKET_ERROR)
		goto IOREAD_FAIL;
	fd_set fdread;
	FD_ZERO(&fdread);
	FD_SET(sock,&fdread);
	timeval t;
	t.tv_sec=100;  //set the wait time.
	t.tv_usec=100;
	select(0,&fdread,NULL,NULL,&t);
	if(FD_ISSET(sock,&fdread))
		goto IOREAD_SUCCESS;
	else
		goto IOREAD_FAIL;

IOREAD_FAIL:
	return 0;
IOREAD_SUCCESS:
	return 1;
}

/**************************************************
Method:    CloseSocket
FullName:  CSock::CloseSocket
Access:    protected   
Returns:   void <>
Parameter: [in]SOCKET sock 
<[in]the socket want to close>
Usage And Note:
Your can use it in your derive class to close your
socket .
!!Warning : Do no use it in your derive destructor.
It will Make some serious bug when you copy the object.
***************************************************/
void CSock::CloseSocket(SOCKET sock)
{
	if(sock!=SOCKET_ERROR)
	{
		shutdown(sock,SD_BOTH);
		closesocket(sock);
	}
}

/**************************************************
Method:    CListenSock
FullName:  CListenSock::CListenSock
Access:    public   
Returns:    
<>
Parameter:  
<>
Usage And Note:
***************************************************/
CListenSock::CListenSock()
{
	m_listen=SOCKET_ERROR;
}

/**************************************************
Method:    InitSock
FullName:  CListenSock::InitSock
Access:    public   
Returns:   bool 
<If success return true.Otherwise return fales>
Parameter:  
<>
Usage And Note:
***************************************************/
bool CListenSock::InitSock()
{
	m_listen=CSock::InitSocket();
	if(m_listen==SOCKET_ERROR)
		return false;
	else
		return true;
}

/**************************************************
Method:    BindAddr
FullName:  CListenSock::BindAddr
Access:    public   
Returns:   bool 
<If success return true.Otherwise return fales>
Parameter: [in]const char* szaddr=NULL,[in]int Port=0
<>
Usage And Note:
if szaddr=NULL,it will bind addr any addr can be used.
***************************************************/
bool CListenSock::BindAddr(const char* szaddr/* =NULL */,int Port/* =0 */)
{
	sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(Port);
	memset(saddr.sin_zero,0,8);
	if(szaddr==NULL)
		saddr.sin_addr.s_addr = htonl(INADDR_ANY);
	else
		saddr.sin_addr.s_addr = inet_addr(szaddr);

	int ret=bind(m_listen,(sockaddr*)&saddr,sizeof(saddr));
	if(ret==SOCKET_ERROR)
		return false;
	return true;
}

/**************************************************
Method:    Listen
FullName:  CListenSock::Listen
Access:    public   
Returns:   bool 
<If success return true.Otherwise return fales>
Parameter:  
<>
Usage And Note:
***************************************************/
bool CListenSock::Listen()
{
	int ret=listen(m_listen,10);
	if(ret==SOCKET_ERROR)
		return false;
	return true;
}

/**************************************************
Method:    Accept
FullName:  CListenSock::Accept
Access:    public   
Returns:   bool 
<If success return true.Otherwise return fales>
Parameter: [out]CTcpSock& tcpsock,[out]sockaddr_in* addr 
<If success it will return available CTcpSock and addr.>
Usage And Note:
It will block until accept a socket.
***************************************************/
bool CListenSock::Accept(CTcpSock& tcpsock,sockaddr_in* addr)
{
	if(m_listen==SOCKET_ERROR)
		goto CLISTENSOCK_ACCEPT_FAIL;
	int len=sizeof(struct sockaddr);
	if(addr!=NULL)  //Re Initialize addr.
	{
		addr->sin_family=AF_INET;
		memset(addr->sin_zero,0,8);
	}

	//it will block here.
	SOCKET sock=accept(m_listen,(sockaddr*)addr,&len);

	if(sock==SOCKET_ERROR)
		goto CLISTENSOCK_ACCEPT_FAIL;
	tcpsock.SetTcpSock(sock);
		goto CLISTENSOCK_ACCEPT_SUCCESS;
	

CLISTENSOCK_ACCEPT_FAIL:
	return 0;
CLISTENSOCK_ACCEPT_SUCCESS:
	return 1;
}

/**************************************************
Method:    IORead
FullName:  CListenSock::IORead
Access:    public   
Returns:   bool 
<If success return true.Otherwise return fales>
Parameter:  
<>
Usage And Note:
***************************************************/
bool CListenSock::IORead()
{
	return CSock::IORead(m_listen);
}

/**************************************************
Method:    ~CListenSock
FullName:  CListenSock::~CListenSock
Access:    public   
Returns:    
<>
Parameter:  
<>
Usage And Note:
***************************************************/
CListenSock::~CListenSock()
{

}



/**************************************************
Method:    Close
FullName:  CListenSock::Close
Access:    public   
Returns:   void 
<>
Parameter:  
<>
Usage And Note:
Client Should use it and release system source when 
you won't use this listen socket again.
***************************************************/
void CListenSock::Close()
{
	CSock::CloseSocket(m_listen);
}

/**************************************************
Method:    CTcpSock
FullName:  CTcpSock::CTcpSock
Access:    public   
Returns:    
<>
Parameter:  
<>
Usage And Note:
***************************************************/
CTcpSock::CTcpSock()
{
	m_Tcpsock=SOCKET_ERROR;
}

/**************************************************
Method:    Conncet
FullName:  CTcpSock::Conncet
Access:    public   
Returns:   bool 
<If success return true.Otherwise return fales>
Parameter: const char* [in]szaddr,int [in]Port 
<>
Usage And Note:
***************************************************/
bool CTcpSock::Conncet(const char* szaddr,int Port)
{
	m_Tcpsock=CSock::InitSocket(); 
	sockaddr_in addr;
	addr.sin_family=AF_INET;
	addr.sin_addr.s_addr=inet_addr(szaddr);
	addr.sin_port=htons(Port);
	memset(addr.sin_zero,0,8);

	int ret= ::connect(m_Tcpsock,(sockaddr*)&addr,sizeof(addr));
	if(ret==-1)
		return false;
	else
		return true;
}

/**************************************************
Method:    Recv
FullName:  CTcpSock::Recv
Access:    public   
Returns:   bool 
<If success return true.Otherwise return fales>
Parameter: char* [out]szBuf,int [in]nLen 
<If success it will return szBuf>
Usage And Note:
Make Sure Your szBuf has nLen+1 space. it will block
until it receive nLen byte.
***************************************************/
bool CTcpSock::Recv(char* szBuf,int nLen)
{
	int ret=0;
	int idx=0;
	int nleft=nLen;

	while(nleft>0)
	{
		ret=recv(m_Tcpsock,(char*)&szBuf[idx],nleft,0);
		if(ret==SOCKET_ERROR||ret==0)
			return 0;
		idx+=ret;
		nleft-=ret;
		Sleep(1);
	}
	return 1;
}

/**************************************************
Method:    Send
FullName:  CTcpSock::Send
Access:    public   
Returns:   bool 
<If success return true.Otherwise return fales>
Parameter: char* [in]szBuf,int [in]nLen 
<>
Usage And Note:
MakeSure szBuf has nLen Space.
***************************************************/
bool CTcpSock::Send(char* szBuf,int nLen)
{
	int ret=0;
	int idx=0;
	int nleft=nLen;

	while(nleft>0)
	{
		ret=send(m_Tcpsock,&szBuf[idx],nleft,0);
		if(ret==SOCKET_ERROR)
			return 0;
		idx+=ret;
		nleft-=ret;
		Sleep(1);
	}
	return 1;
}

/**************************************************
Method:    IORead
FullName:  CTcpSock::IORead
Access:    public   
Returns:   bool 
<If success return true.Otherwise return fales>
Parameter:  
<>
Usage And Note:
***************************************************/
bool CTcpSock::IORead()
{
	return CSock::IORead(m_Tcpsock);
}

/**************************************************
Method:    SetTcpSock
FullName:  CTcpSock::SetTcpSock
Access:    public   
Returns:   void 
<>
Parameter: SOCKET [in]sock 
<>
Usage And Note:
Your can use it when you according CListenSock::Accept
to get the socket.
***************************************************/
void CTcpSock::SetTcpSock(SOCKET sock)
{
	m_Tcpsock=sock;
}

/**************************************************
Method:    ~CTcpSock
FullName:  CTcpSock::~CTcpSock
Access:    public   
Returns:    
<>
Parameter:  
<>
Usage And Note:
***************************************************/
CTcpSock::~CTcpSock()
{

}

/**************************************************
Method:    Close
FullName:  CTcpSock::Close
Access:    public   
Returns:   void 
<>
Parameter:  
<>
Usage And Note:
***************************************************/
void CTcpSock::Close()
{
	if(m_Tcpsock!=SOCKET_ERROR)
		CSock::CloseSocket(m_Tcpsock);
}

SOCKET CTcpSock::GetSocket()
{
	return m_Tcpsock;
}

void CTcpSock::SetSocket( SOCKET sock )
{
	m_Tcpsock=sock;
}

void CTcpSock::SetLinkIP( char* szIP )
{
	strcpy(m_szLinkIP,szIP);
}

char* CTcpSock::GetLinkIP()
{
	return m_szLinkIP;
}
类型/语言：C/C++
查看：240次
评论：2条
发布者：Kingmn
时间：2011年6月11日 22:50
发给朋友举报
微博与分享 Share
CorePlex

代码正文

评论 Comments

信息 Details

微博与分享 Share

相关代码 Related
