一种健壮的网络发送接收函数

 在广域网条件下，客户端与服务器打交道，如果仅仅是简单的send-recv方式，那么潜在的bug是无法避免的，尤其是在一个指令序列不断交互，问题更大了。

例如，你预期的情况是这样的：

C->S: Hello，server.  \r\n

S->C:Hello，client \r\n

C->S:Tell me your name \r\n

S->C:My name is Jimmy \r\n

而实际却得到这样的结果：

C->S: Hello，server \r\n

S->C:Hello，cli

C->S:Tell me your name \r\n

S->C:eint  \r\n My name is Jimmy \r\n

为此，必须充分考虑广域网的阻塞，延迟等非常规情况出现。

#include <iostream>
#include <assert.h>
#include <winsock2.h>

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

using namespace std;

class CMySocket
{
public:
	CMySocket(){};
	~CMySocket(){};
	bool  SendData();
	bool  ReceiveData();
private:
	SOCKET	m_socket;
	char*   m_dataBuf;
	int		m_dataLen;
	int		m_waitSeconds;
};


bool CMySocket::SendData()
{
	int idx = 0,res;
	int nLeft=m_dataLen;

	if(m_dataLen==0){
		return false;
	}

	fd_set  fdwrite;
	timeval time;

	time.tv_sec = m_waitSeconds;
	time.tv_usec = 0;

	while(1)
	{
		FD_ZERO(&fdwrite);

		FD_SET(m_socket,&fdwrite);

		if((res = select(m_socket+1,NULL,&fdwrite,NULL,&time)) == SOCKET_ERROR)
		{
			FD_CLR(m_socket,&fdwrite);
			return false;
		}

		if(!res)//timeout
		{
			FD_CLR(m_socket,&fdwrite);
			return false;
		}

		if(res && FD_ISSET(m_socket,&fdwrite))
		{
			if(nLeft > 0)
			{
				if((res = send(m_socket,&m_dataBuf[idx],nLeft,0)) == SOCKET_ERROR)
				{
					FD_CLR(m_socket,&fdwrite);
				}
				if(!res)
					break;
				nLeft -= res;
				idx += res;
			}
			else
				break;
		}
	}

	FD_CLR(m_socket,&fdwrite);

	return true;
}


bool CMySocket::ReceiveData()
{
	int res,i = 0;
	fd_set fdread;
	timeval time;

	time.tv_sec = m_waitSeconds;
	time.tv_usec = 0;

	assert(m_dataBuf);
	
	if(m_dataBuf == NULL)
		return false;

	while(1)
	{
		FD_ZERO(&fdread);

		FD_SET(m_socket,&fdread);

		if((res = select(m_socket+1, &fdread, NULL, NULL, &time)) == SOCKET_ERROR)
		{
			FD_CLR(m_socket,&fdread);
			return false;
		}

		if(!res)//timeout
		{
			FD_CLR(m_socket,&fdread);
			return false;
		}

		if(res && FD_ISSET(m_socket,&fdread))
		{
			if(i >= m_dataLen)
			{
				FD_CLR(m_socket,&fdread);
				return false;//lack of memory
			}
			if(recv(m_socket,&m_dataBuf[i++],1,0) == SOCKET_ERROR)
			{
				FD_CLR(m_socket,&fdread);
				return false;
			}
			if(m_dataBuf[i-1]=='\n')
			{
				m_dataBuf[i] = '\0';
				break;
			}
		}
	}

	FD_CLR(m_socket,&fdread);
	return true;
}

注解：

select函数用于确定一个或多个套接口的状态。对每一个套接口，调用者可查询它的可读性、可写性及错误状态信息。用fd_set结构来表示一组等待检查的套接口。

原型

int select(
int nfds,
fd_set* readfds,
fd_set* writefds,
fd_set* exceptfds,
const struct timeval* timeout
);

nfds：本参数忽略，仅起到兼容作用。
readfds：（可选）指针，指向一组等待可读性检查的套接口。
writefds：（可选）指针，指向一组等待可写性检查的套接口。
exceptfds：（可选）指针，指向一组等待错误检查的套接口。
timeout：select()最多等待时间，对阻塞操作则为NULL。

   FD_CLR(s,*set)：从集合set中删除描述字s。
   FD_ISSET(s,*set)：若s为集合中一员，非零；否则为零。
   FD_SET(s,*set)：向集合添加描述字s。
   FD_ZERO(*set)：将set初始化为空集NULL。

 

返回值：

   select()调用返回处于就绪状态并且已经包含在fd_set结构中的描述字总数；如果超时则返回0；否则的话，返回SOCKET_ERROR错误，应用程序可通过WSAGetLastError()获取相应错误代码。

错误代码：
   WSANOTINITIALISED：在使用此API之前应首先成功地调用WSAStartup()。
   WSAENETDOWN：WINDOWS套接口实现检测到网络子系统失效。
   WSAEINVAL：超时时间值非法。
   WSAEINTR：通过一个WSACancelBlockingCall()来取消一个（阻塞的）调用。
   WSAEINPROGRESS：一个阻塞的WINDOWS套接口调用正在运行中。
   WSAENOTSOCK：描述字集合中包含有非套接口的元素。

附带别人的一篇文章：

/*

Socket中如何设置连接超时【转】

http://fcxz.blogbus.com/logs/1564481.html


设置connect的超时很简单，CSDN上也有人提到过使用select，但却没有一个令人满意与完整的答案。
偶所讲的也正是select函数，此函数集成在winsock1.1中，
简单点讲，"作用使那些想避免在套接字调用过程中被锁定的应用程序，采取一种有序的方式，同时对多个套接字进行管理"(《Windows网络编程技术》原话)。
使用方法与解释请见《Windows网络编程技术》。
　　
在使用此函数前，需先将socket设置为非锁定模式，这样，在connect时，才会立马跳过，
同时，通常也会产生一个WSAEWOULDBLOCK错误，这个错误没关系。再执行select则是真正的超时。

*/

void main()
{

	WSADATA wsd;
	SOCKET cClient;
	int ret;
	struct sockaddr_in server;
	hostent *host=NULL;

	if(WSAStartup(MAKEWORD(2,0),&wsd)){return 0;}
	cClient=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
	
	if(cClient==INVALID_SOCKET){
		return 0;
	}

	//set Recv and Send time out
	int TimeOut=6000; //设置发送超时6秒
	
	if(::setsockopt(cClient,SOL_SOCKET,SO_SNDTIMEO,(char *)&TimeOut,sizeof(TimeOut))==SOCKET_ERROR){
		return 0;
	}

	TimeOut=6000;//设置接收超时6秒
	if(::setsockopt(cClient,SOL_SOCKET,SO_RCVTIMEO,(char *)&TimeOut,sizeof(TimeOut))==SOCKET_ERROR){
		return 0;
	}

	//设置非阻塞方式连接
	unsigned long ul = 1;
	ret = ioctlsocket(cClient, FIONBIO, (unsigned long*)&ul);
	
	if(ret==SOCKET_ERROR)
		return 0;

	//连接
	server.sin_family = AF_INET;
	server.sin_port = htons(25);
	server.sin_addr .s_addr = inet_addr((LPCSTR)pSmtp);
	if(server.sin_addr.s_addr == INADDR_NONE){
		return 0;
	}

	connect(cClient,(const struct sockaddr *)&server,sizeof(server));

	//select模型，即设置超时
	struct timeval timeout ;
	fd_set r;

	FD_ZERO(&r);
	FD_SET(cClient,&r);
	timeout.tv_sec = 15; //连接超时15秒
	timeout.tv_usec =0;
	ret = select(0, 0,&r, 0,&timeout);
	if ( ret<= 0 )
	{
		::closesocket(cClient);
		return 0;
	}

	//一般非锁定模式套接比较难控制，可以根据实际情况考虑 再设回阻塞模式
	unsigned long ul1= 0 ;
	ret = ioctlsocket(cClient, FIONBIO, (unsigned long*)&ul1);
	if(ret==SOCKET_ERROR){
		::closesocket (cClient);
		return 0;
	}
}