tcp socket阻塞与非阻塞

1.sock默认为阻塞模式，下面的代码可对sock设置为非阻塞模式 

int flags = fcntl(sock, F_GETFL, 0); 

fcntl(sock, F_SETFL, flags | O_NONBLOCK); 

假设当前代码为服务器，并且已经执行过如下代码， 

当sock为阻塞模式，调用accept会阻塞直到一个请求到来 

当sock为非阻塞模式，accept会返回-1，errno设置为EAGAIN或者EWOULDBLOCK 

static int ns_open_listening_socket_tcp()
{
    struct sockaddr_in cin;
    struct sockaddr_in sin;
    int sock = -1;
    int on = 1;
    sin.sin_family = AF_INET;
    sin.sin_port = htons(7888);
    sin.sin_addr.s_addr = INADDR_ANY;//inet_addr("192.168.10.80");
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) != -1 &&
            !setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *) &on, sizeof(on)) &&
            !bind(sock, (struct sockaddr *)&sin, sizeof(sin)) &&
            (listen(sock, SOMAXCONN) == 0))
    {
        ns_set_non_blocking_mode(sock);
    }
    else if (sock != -1)
    {
        close(sock);
        sock = -1;
    }
    return sock;
}

3，对于sock_stream 套接字，应用程序意识不到报文边界，因为套接字提供的是字节流服务，因此当从套接字读出数据时，它也许不会返回所有由发送进程所写的字节，最终获取所有数据，也许要通过若干次函数调用得到 sock为阻塞和非阻塞对recv是没有影响的， recv在accept没有建立新的sock之前，都是立即返回-1，并且errno 为 9，　#define EBADF 9 /* Bad file number */

 在accept建立好连接以后，没有数据接收之前都会一直阻塞，

若有数据接收，recv则返回值>0；

若无数据接收，recv阻塞；

若对方断开连接，则recv返回值为0； 

那么有错误处理函数： 当recv返回0时，套接字关闭，出错close退出 当recv返回负数，并且不为以下几种情况时，出错退出： 

#define EINTR 4 /* Interrupted system call */ 

#define EINPROGRESS 115 /* Operation now in progress */ 

#define EAGAIN 11 /* Try again */ 

#define EWOULDBLOCK EAGAIN /* Operation would block */ 

static int ns_is_error(int n)
{
return n == 0 ||
  (n < 0 && errno != EINTR && errno != EINPROGRESS &&
errno != EAGAIN && errno != EWOULDBLOCK);
}

recv函数

int recv( SOCKET s, char FAR *buf, int len, int flags);

不论是客户还是服务器应用程序都用recv函数从TCP连接的另一端接收数据。

该函数的第一个参数指定接收端套接字描述符； 

第二个参数指明一个缓冲区，该缓冲区用来存放recv函数接收到的数据； 

第三个参数指明buf的长度； 第四个参数一般置0。

这里只描述同步Socket的recv函数的执行流程。当应用程序调用recv函数时，

（1）recv先等待s的发送缓冲中的数据被协议传送完毕，如果协议在传送s的发送缓冲中的数据时出现网络错误，那么recv函数返回SOCKET_ERROR，

（2）如果s的发送缓冲中没有数据或者数据被协议成功发送完毕后，recv先检查套接字s的接收缓冲区，

如果s接收缓冲区中没有数据或者协议正在接收数 据，那么recv就一直等待，直到协议把数据接收完毕。

当协议把数据接收完毕，recv函数就把s的接收缓冲中的数据copy到buf中

（注意协议接收到的数据可能大于buf的长度，所以 在这种情况下要调用几次recv函数才能把s的接收缓冲中的数据copy完。

recv函数仅仅是copy数据，真正的接收数据是协议来完成的）， recv函数返回其实际copy的字节数。

如果recv在copy时出错，那么它返回SOCKET_ERROR；

如果recv函数在等待协议接收数据时网络中断了，那么它返回0。

默认 socket 是阻塞的 解阻塞与非阻塞recv返回值没有区分，都是 <0 出错 =0 连接关闭 >0 接收到数据大小，

特别：

返回值<0时并且(errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)的情况下认为连接是正常的，继续接收。

只是阻塞模式下recv会阻塞着接收数据，非阻塞模式下如果没有数据会返回，不会阻塞着读，因此需要循环读取）。

返回说明： 

成功执行时，返回接收到的字节数。

另一端已关闭则返回0。

失败返回-1，

errno被设为以下的某个值 

EAGAIN：套接字已标记为非阻塞，而接收操作被阻塞或者接收超时 

EBADF：sock不是有效的描述词 

ECONNREFUSE：远程主机阻绝网络连接 

EFAULT：内存空间访问出错 

EINTR：操作被信号中断 

EINVAL：参数无效 

ENOMEM：内存不足 

ENOTCONN：与面向连接关联的套接字尚未被连接上 

ENOTSOCK：sock索引的不是套接字 当返回值是0时，为正常关闭连接；

思考：

当对侧没有send，即本侧的套接字s的接收缓冲区无数据，返回值是什么（EAGAIN，原因为超时，待测）

测试代码：

#include <sys/socket.h>
#include <pthread.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/select.h>
#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <time.h>
#include <stddef.h> //offsetof
#include <sys/stat.h>

static int ns_is_error(int n)
{
	//printf("n:%d\n",n);
    return n == 0 ||
           (n < 0 && errno != EINTR && errno != EINPROGRESS &&
            errno != EAGAIN && errno != EWOULDBLOCK);
}

static void ns_set_non_blocking_mode(int sock)
{
    int flags = fcntl(sock, F_GETFL, 0);
    fcntl(sock, F_SETFL, flags | O_NONBLOCK);
}
static int ns_open_listening_socket_tcp()
{
    struct sockaddr_in cin;
    struct sockaddr_in sin;
    int sock = -1;
    int on = 1;
    sin.sin_family = AF_INET;
    sin.sin_port = htons(7888);
    sin.sin_addr.s_addr = INADDR_ANY;//inet_addr("192.168.10.80");
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) != -1 &&
            !setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *) &on, sizeof(on)) &&
            !bind(sock, (struct sockaddr *)&sin, sizeof(sin)) &&
            (listen(sock, SOMAXCONN) == 0))
    {
        //ns_set_non_blocking_mode(sock);
    }
    else if (sock != -1)
    {
        close(sock);
        sock = -1;
    }
    return sock;
}

void main()
{
	    struct sockaddr_in tcpcin;
    socklen_t tcplen;
    int newsock,n;
    char buf[1024];
    int sock = ns_open_listening_socket_tcp();
newsock = -1;
   
	while(1)
	{
		if(newsock <0 )
		 newsock =accept(sock, (struct sockaddr *)&tcpcin, &tcplen);
		
			n = (int)recv(newsock, buf, 1024, 0);
			//if(n>0)
		//	perror("xas");
			printf("n:%d,%s,newsock:%d,errno:%d\n",n,buf,newsock,errno);
			if(ns_is_error(n))
			{
					printf("n:%d\n",errno);
					//perror("error");
					close(newsock);
					newsock = -1;
				}
			sleep(1);
		}
	
	
	}

若要接收大文件，则当客户端断开后，n为0 ，才会断开连接，认为一次接收完毕。

若recv返回了，但没有出错，则不会关闭newsock，在下一轮中继续接收

代码如下：

void main()
{
	    struct sockaddr_in tcpcin;
    socklen_t tcplen;
    int newsock=0,n=0;
    char buf[1024]={0};
   char out[10240];
    int sock = ns_open_listening_socket_tcp();
newsock = -1;
   
	while(1)
	{
		if(newsock <0 )
		 {
		 	newsock =	accept(sock, (struct sockaddr *)&tcpcin, &tcplen);
				memset(out,0,sizeof(out));
		}if(newsock>=0)			
	strcat(out,buf);
				memset(buf,0,sizeof(buf));
		}
			if(ns_is_error(n))
			{
				printf("recv finish %s\n",out);
					close(newsock);
					newsock = -1;
			}
	}
	}

若把accept以后的newsock设置为非阻塞，则为以下模式：设置newsock的超时时间，当recv超时后，返回，返回的n为-1，errno为11，这个时候，仍然不会认为出错，等待下一次接收。

void main()
{
	    struct sockaddr_in tcpcin;
    socklen_t tcplen;
    int newsock=0,n=0;
    char buf[1024]={0};
   char out[10240];
    int sock = ns_open_listening_socket_tcp();
  //  int timeout=1;
struct timeval timeout = {3, 0};
newsock = -1;
   
	while(1)
	{
		if(newsock <0 )
		 {
		 	newsock =	accept(sock, (struct sockaddr *)&tcpcin, &tcplen);
		 	setsockopt(newsock,SOL_SOCKET,SO_RCVTIMEO,(char *)&timeout, sizeof(struct timeval));
				memset(out,0,sizeof(out));
		}
		if(newsock>0)
			{
			while((n = (int)recv(newsock, buf, 1024, 0))>0)
			{
				strcat(out,buf);
				memset(buf,0,sizeof(buf));
				}
				printf("n:%d,errno:%d\n",n,errno);
			if(ns_is_error(n))
			{
				printf("sock %d n:%d,recv finish %s,%d\n",newsock,n,out,errno);
				//perror("errno");
					close(newsock);
					newsock = -1;
				}
		}
	}
	
}

综上，recv只有返回0时，才结束传输。

ns_is_error（n）为真 时，才关闭socket（真的结束了，即n==0，或者出错了）

                              为假时，不用关闭socket下一轮继续接收。