hmtsocket.cpp

VC++高级编程技巧与示例

// HMTSocket.cpp: implementation of the CMTSocket class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "HMTSocket.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

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

CMTSocket::CMTSocket()
{
	m_Socket = NULL;
	m_SrvrAddr=NULL;
	m_Port=0;
	memset(&m_Sa,0,sizeof(m_Sa));
}

CMTSocket::~CMTSocket()
{

}

//返回m_Socket的值用于操作：
SOCKET CMTSocket::GetSocket()
{
	return m_Socket;
}

/************************/
/*  与服务器相关的代码：*/
/************************/

//创建一个套接字：
BOOL CMTSocket::Create(unsigned int port, LPCTSTR Srvr, unsigned int socktype)
{
	if(!AfxSocketInit())
	{
		throw new CMTSocketException("初始化Winsock动态连接库出错！");
		return FALSE;
	}
	if((m_Socket=socket(AF_INET,socktype,0))==INVALID_SOCKET) 
	{
		throw new CMTSocketException("创建套接口失败！");
		return FALSE;
	}
	m_SrvrAddr=Srvr;
	m_Port=port;
	return TRUE;
}

BOOL CMTSocket::Bind()
{
	memset(&m_Sa,0,sizeof(m_Sa));
	//准备sockaddr_in 结构：
	m_Sa.sin_family=AF_INET;
	m_Sa.sin_port=htons(m_Port);
	m_Sa.sin_addr.s_addr=INADDR_ANY;
	//进行捆绑：
	if(bind(m_Socket,(sockaddr * )&m_Sa,sizeof(m_Sa))== SOCKET_ERROR)
	{
		throw new CMTSocketException("捆绑失败！");
		return FALSE;
	}
	return TRUE;
}

BOOL CMTSocket::Listen()
{
	if(listen(m_Socket,5)==SOCKET_ERROR)
	{
		throw new CMTSocketException("Listen（）调用失败！");
		return FALSE;
	}
	return TRUE;
}

SOCKET CMTSocket::Accept()
{
	SOCKET sock=0;
	int nl=sizeof(m_Sa);
	if((sock=accept(m_Socket,(sockaddr *)&m_Sa,&nl))==INVALID_SOCKET)
	{
		throw new CMTSocketException("Accept调用失败！");
		return FALSE;
	}
	m_Clients.AddTail(sock);
	return sock;
}

BOOL CMTSocket::Close(SOCKET sock)
{
	if(sock==NULL)
	{
		throw new CMTSocketException("套接字为0，无法关闭！");
		return FALSE;
	}
	if(closesocket(sock)==SOCKET_ERROR) 
	{
		throw new CMTSocketException("关闭套接口失败！");
		return FALSE;
	}
	return TRUE;
}

BOOL CMTSocket::Close()
{
	return Close(m_Socket);
}

/************************/
/*  与客户机相关的代码：*/
/************************/

//连接到服务器：
BOOL CMTSocket::Connect()
{
	if(m_SrvrAddr==NULL)
	{
			WSASetLastError(WSAEINVAL);
			throw new CMTSocketException("连接失败！");
			return FALSE;
	}

	memset(&m_Sa,0,sizeof(m_Sa));

	m_Sa.sin_family = AF_INET;
	m_Sa.sin_addr.s_addr = inet_addr(( LPSTR )m_SrvrAddr);

	if (m_Sa.sin_addr.s_addr == INADDR_NONE)
	{
		LPHOSTENT lphost;
		lphost = gethostbyname(( LPSTR )m_SrvrAddr);
		if (lphost != NULL)
		{
			m_Sa.sin_addr.s_addr = ((LPIN_ADDR)lphost->h_addr)->s_addr;
		}
		else
		{
			WSASetLastError(WSAEINVAL);
			throw new CMTSocketException("连接失败！");
			return FALSE;
		}
	}
	m_Sa.sin_port = htons((u_short)m_Port);
	if(connect(m_Socket,(sockaddr * )&m_Sa,sizeof(m_Sa))==SOCKET_ERROR)
	{
		if(GetLastError()!=WSAECONNREFUSED)
		{
			throw new CMTSocketException("连接失败！");
			return FALSE;
		}
		else
		{
			return FALSE;
		}
	}
	return TRUE;
}

//设置套接字属性：
BOOL CMTSocket::SetSockOpt(SOCKET sock,
						   int nOptionName,
						   const char * lpOptionValue, 
						   int nOptionLen, 
						   int nLevel
						   )
{
	if(setsockopt(sock,nLevel,nOptionName,lpOptionValue,nOptionLen)==SOCKET_ERROR)
	{
		throw new CMTSocketException("套接口设置失败！");
		return FALSE;
	}
	return TRUE;
}

BOOL CMTSocket::SetSockOpt(int nOptionName,
						   const char * lpOptionValue, 
						   int nOptionLen, 
						   int nLevel
						   )
{
	return SetSockOpt(m_Socket,nOptionName,lpOptionValue,nOptionLen,nLevel);
}
/************************/
/*  与读、写相关的代码：*/
/************************/

//从套接口读取字节流：
int CMTSocket::Receive(SOCKET sock,char FAR* buf,int len,int RecvAll,int flags)
{
	int re;
	re=1;
	if(RecvAll)
	{
		while(re!=SOCKET_ERROR&&len>0)
		{
			if((re=recv(sock,buf,len,flags))==SOCKET_ERROR)
			{
				throw new CMTSocketException("读取数据失败！");
				return SOCKET_ERROR;
			}
			buf+=re;
			len-=re;
		}
	}
	else
	{
		if((re=recv(sock,buf,len,flags))==SOCKET_ERROR)
		{
			throw new CMTSocketException("读取数据失败！");
			return SOCKET_ERROR;
		}
	}
	return re;
}

int CMTSocket::Receive(char FAR* buf,int len,int flags)
{
	return Receive(m_Socket,buf,len,flags);
}
//从套接口读取字节流，并且返回数据的源地址：
int CMTSocket::ReceiveFrom(SOCKET sock,char * lpBuf, int nBufLen,
						   CString& rSocketAddress,
						   UINT& rSocketPort,
						   int nFlags)
{
	int re;
	memset(&m_Sa, 0, sizeof(m_Sa));
	int nl= sizeof(m_Sa);
	re=1;
	re=recvfrom(sock,lpBuf,nBufLen,nFlags,(sockaddr * )&m_Sa, &nl);
	if(re!= SOCKET_ERROR)
	{
		rSocketPort = ntohs(m_Sa.sin_port);
		rSocketAddress = inet_ntoa(m_Sa.sin_addr);
	}
	else
	{
		throw new CMTSocketException("以Recvfrom（）方式读取数据失败！");
		return FALSE;
	}
	return re;
}

int CMTSocket::ReceiveFrom(char * lpBuf, int nBufLen,
						   CString& rSocketAddress,
						   UINT& rSocketPort,
						   int RecvAll,int nFlags)
{
	return ReceiveFrom(m_Socket,lpBuf,nBufLen,rSocketAddress,rSocketPort,nFlags);
}

//发送数据：
int CMTSocket::Send(SOCKET sock,const char * buf, int len, int flags)
{
	int re;
	if((re=send(sock,buf,len,flags))==SOCKET_ERROR)
	{
		throw new CMTSocketException("发送数据失败！");
		return SOCKET_ERROR;
	}
	return re;
}

int CMTSocket::Send(const char * buf, int len, int flags)
{
	return Send(m_Socket,buf,len,flags);
}

//发送数据，并且返回地址：
int CMTSocket::SendTo(SOCKET sock,
					   const char * lpBuf,
					   int nBufLen,
					   UINT nHostPort,
					   LPCTSTR lpszHostAddress,
					   int nFlags)
{
	int re;
	memset(&m_Sa,0,sizeof(m_Sa));
	LPSTR addr=(LPSTR)m_SrvrAddr;
	m_Sa.sin_family = AF_INET;
	if (addr == NULL)
	{
		m_Sa.sin_addr.s_addr = htonl(INADDR_BROADCAST);
	}
	else
	{
		m_Sa.sin_addr.s_addr = inet_addr(addr);
		if (m_Sa.sin_addr.s_addr == INADDR_NONE)
		{
			LPHOSTENT lphost;
			lphost = gethostbyname(addr);
			if (lphost != NULL)
			{
				m_Sa.sin_addr.s_addr = ((LPIN_ADDR)lphost->h_addr)->s_addr;
			}
			else
			{
				WSASetLastError(WSAEINVAL);
				throw new CMTSocketException("以snedto（）方式发送数据失败！");
				return FALSE;
			}
		}
	}
	m_Sa.sin_port = htons((u_short)nHostPort);
	int nl=sizeof(m_Sa);
	if((re=sendto(sock,lpBuf,nBufLen,nFlags,(sockaddr *)&m_Sa,nl))==SOCKET_ERROR)
	{
		throw new CMTSocketException("以snedto（）方式发送数据失败！");
		return SOCKET_ERROR;
	}
	return re;
}

int CMTSocket::SendTo(const char * lpBuf,
					   int nBufLen,
					   UINT nHostPort,
					   LPCTSTR lpszHostAddress,
					   int nFlags)
{
	return SendTo(m_Socket,lpBuf,nBufLen,nHostPort,lpszHostAddress,nFlags);
}

//利用该函数“文明地”关闭套接口：
BOOL CMTSocket::ShutDown(SOCKET sock)
{
	if(shutdown(sock,0)==SOCKET_ERROR)
	{
		throw new CMTSocketException("文明关闭套接口失败！");
		return FALSE;
	}
	return TRUE;
}

BOOL CMTSocket::ShutDown()
{
	return ShutDown(m_Socket);
}

//确定套接口的状态：
BOOL CMTSocket::Select(fd_set FAR * readfds,               
					   fd_set FAR * writefds,              
					   fd_set FAR * exceptfds,             
					   const struct timeval FAR * timeout
					   )
{
	if(select(0,readfds,writefds,exceptfds,timeout)==SOCKET_ERROR)
	{
		throw new CMTSocketException("确定套接口调用失败！");
		return FALSE;
	}
	return TRUE;
}

//////////////////////////////////////////////////////////////////////
// CMTSocketException Class
//////////////////////////////////////////////////////////////////////

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

CMTSocketException::CMTSocketException(LPCTSTR einfo)
{
	m_EInfo=einfo;
	m_EInfo=m_EInfo+"\r\n";
}

CMTSocketException::~CMTSocketException()
{
}

LPCTSTR CMTSocketException::GetErrorMsg()
{
	m_ErrorCode=WSAGetLastError();
	switch(m_ErrorCode)
	{
		case WSAEACCES:
			{
				m_EInfo=m_EInfo+"错误WSAEACCES：对套接口的访问方式非法！";
				break;
			}
		case WSAEADDRINUSE:
			{
				m_EInfo=m_EInfo+"错误WSAEADDRINUSE：试图将套接口捆绑到正在使用的地址或端口！";
				break;
			}
		case WSAEADDRNOTAVAIL:
			{
				m_EInfo=m_EInfo+"错误WSAEADDRNOTAVAIL：指定的地址或端口非法！";
				break;
			}
		case WSAEAFNOSUPPORT:
			{
				m_EInfo=m_EInfo+"错误WSAEAFNOSUPPORT：地址同目前协议不兼容！";
				break;
			}
		case WSAEALREADY:
			{
				m_EInfo=m_EInfo+"错误WSAEALREADY：当前操作正在执行！";
				break;
			}
		case WSAECONNABORTED:
			{
				m_EInfo=m_EInfo+"错误WSAECONNABORTED：同服务器的连接中断！";
				break;
			}

		case WSAECONNREFUSED:
			{
				m_EInfo=m_EInfo+"错误WSAECONNREFUSED：同服务器的连接被拒绝！";
				break;
			}
		case WSAECONNRESET:
			{
				m_EInfo=m_EInfo+"错误WSAECONNRESET：同服务器的连接被服务器强行中断！";
				break;
			}
		case WSAEDESTADDRREQ:
			{
				m_EInfo=m_EInfo+"错误WSAEDESTADDRREQ：没有指明目标地址！";
				break;
			}
		case WSAEFAULT:
			{
				m_EInfo=m_EInfo+"错误WSAEFAULT：错误的地址！";
				break;
			}
		case WSAEHOSTDOWN:
			{
				m_EInfo=m_EInfo+"错误WSAEHOSTDOWN：服务器死锁！";
				break;
			}
		case WSAEHOSTUNREACH:
			{
				m_EInfo=m_EInfo+"错误WSAEHOSTUNREACH：试图同无法到达的服务器相连接！";
				break;
			}

		case WSAEINPROGRESS:
			{
				m_EInfo=m_EInfo+"错误WSAEINPROGRESS：只允许有一个阻塞的函数调用！";
				break;
			}
		case WSAEINTR:
			{
				m_EInfo=m_EInfo+"错误WSAEINTR：阻塞函数调用被终止！";
				break;
			}
		case WSAEINVAL:
			{
				m_EInfo=m_EInfo+"错误WSAEINVAL：参数无效！";
				break;
			}
		case WSAEISCONN:
			{
				m_EInfo=m_EInfo+"错误WSAEISCONN：套接口处于连接状态中！";
				break;
			}
		case WSAEMFILE:
			{
				m_EInfo=m_EInfo+"错误WSAEMFILE：被打开的套接口太多！";
				break;
			}
		case WSAEMSGSIZE:
			{
				m_EInfo=m_EInfo+"错误WSAEMSGSIZE：数据报套接口中传送的信息太长！";
				break;
			}
		case WSAENETDOWN :
			{
				m_EInfo=m_EInfo+"错误WSAENETDOWN：网络系统死锁！";
				break;
			}
		case WSAENETRESET :
			{
				m_EInfo=m_EInfo+"错误WSAENETRESET：操作过程出错，连接中断！";
				break;
			}
		case WSAENETUNREACH :
			{
				m_EInfo=m_EInfo+"错误WSAENETUNREACH：无法连接到网络！";
				break;
			}
		case WSAENOBUFS :
			{
				m_EInfo=m_EInfo+"错误WSAENOBUFS：缓冲区已满，无法进行操作！";
				break;
			}
		case WSAENOPROTOOPT :
			{
				m_EInfo=m_EInfo+"错误WSAENOPROTOOPT：无效的套接口选项！";
				break;
			}
		case WSAENOTCONN :
			{
				m_EInfo=m_EInfo+"错误WSAENOTCONN：无法进行读写操作！";
				break;
			}
		case WSAENOTSOCK :
			{
				m_EInfo=m_EInfo+"错误WSAENOTSOCK：试图对非套接口类型的变量进行操作！";
				break;
			}
		case WSAEOPNOTSUPP :
			{
				m_EInfo=m_EInfo+"错误WSAEOPNOTSUPP：不支持这种操作！";
				break;
			}
		case WSAEPFNOSUPPORT :
			{
				m_EInfo=m_EInfo+"错误WSAEPFNOSUPPORT：不支持当前协议族！";
				break;
			}
		case WSAEPROCLIM :
			{
				m_EInfo=m_EInfo+"错误WSAEPROCLIM：使用Windows Sock的应用程序太多！";
				break;
			}
		case WSAEPROTONOSUPPORT :
			{
				m_EInfo=m_EInfo+"错误WSAEPROTONOSUPPORT：当前协议不被支持！";
				break;
			}
		case WSAEPROTOTYPE :
			{
				m_EInfo=m_EInfo+"错误WSAEPROTOTYPE：当前协议不支持指定的套接口类型！";
				break;
			}
		case WSAESHUTDOWN :
			{
				m_EInfo=m_EInfo+"错误WSAESHUTDOWN：套接口已经关闭，无法发送数据！";
				break;
			}
		case WSAESOCKTNOSUPPORT :
			{
				m_EInfo=m_EInfo+"错误WSAESOCKTNOSUPPORT：指定的套接口类型不被支持！";
				break;
			}
		case WSAETIMEDOUT :
			{
				m_EInfo=m_EInfo+"错误WSAETIMEDOUT：连接超时！";
				break;
			}
		case 10109:
			{
				m_EInfo=m_EInfo+"错误WSATYPE_NOT_FOUND：无法找到指定的类！";
				break;
			}
		case WSAEWOULDBLOCK :
			{
				m_EInfo=m_EInfo+"错误WSAEWOULDBLOCK：资源暂时无法使用！";
				break;
			}
		case WSAHOST_NOT_FOUND :
			{
				m_EInfo=m_EInfo+"错误WSAHOST_NOT_FOUND：找不到服务器！";
				break;
			}
		case WSANOTINITIALISED:
			{
				m_EInfo=m_EInfo+"错误WSANOTINITIALISED：没有调用WSAStartup（）初始化！";
				break;
			}
		case WSANO_DATA:
			{
				m_EInfo=m_EInfo+"错误WSANO_DATA：指定的机器名称存在，但相应的数据不存在！";
				break;
			}
		case WSANO_RECOVERY:
			{
				m_EInfo=m_EInfo+"错误WSANO_RECOVERY：无法恢复的错误（同机器名称的查找相关）！";
				break;
			}
		case WSASYSNOTREADY :
			{
				m_EInfo=m_EInfo+"错误WSASYSNOTREADY：Windows Socket 系统不能工作！";
				break;
			}
		case WSATRY_AGAIN :
			{
				m_EInfo=m_EInfo+"错误WSATRY_AGAIN：主机名解析时没有发现授权服务器！";
				break;
			}
		case WSAVERNOTSUPPORTED:
			{
				m_EInfo=m_EInfo+"错误WSAVERNOTSUPPORTED：无法初始化服务提供者！";
				break;
			}
		case WSAEDISCON:
			{
				m_EInfo=m_EInfo+"错误WSAEDISCON：服务器已经\"文明地\"关闭了！";
				break;
			}
		default:
			{
				m_EInfo=m_EInfo+"未知网络错误！";
				break;
			}
	};
	return m_EInfo;
}

DWORD CMTSocketException::GetErrorNumber()
{
	return m_ErrorCode=WSAGetLastError();
}