《网络编程》非阻塞 I/O

爱被打了一巴掌 2022-08-06 03:08 130阅读 0赞

### 概述 ###

在前面文章中，我们介绍了 I/O 的五种模型《[I/O 模型][I_O]》。从那里可以知道，非阻塞式的 I/O 是进程调用 I/O 操作时，若数据未准备就绪，则立即返回一个 EWOULDBLOCK 错误，在数据准备就绪之前，应用进程采用轮询的方式检查数据是否准备就绪。直到数据准备就绪，则内核把该数据复制到应用进程的缓冲区，完成数据复制之前进程处于阻塞状态，直到数据复制完成后才返回。即 I/O 操作第一阶段处于轮询检查状态，第二阶段处于阻塞状态。

套接字的 I/O 操作默认状态是采用阻塞式。即当不能立即完成套接字调用时，其进程会处于阻塞状态，直到相应操作完成。阻塞套接字大致可分为以下四种类型：

1.  **输入操作引起的阻塞状态，包括 read、readv、recv、recvfrom 和 recvmsg 函数**。若某个进程对一个阻塞的 TCP 调用这些输入函数，且此时套接字的接收缓冲区没有可读数据，则该进程会处于阻塞状态，直到有一些数据到达。对于字节流协议的 TCP 来说，只要有一些数据到达，哪怕是单个字节数据，或者是完成的 TCP 报文段数据，该进程都会被唤醒；对于数据报协议的 UDP 来说，若一个阻塞的 UDP 套接字接收缓冲区为空，则该进程也会处于阻塞状态，直到完整 UDP 数据报到达；对于非阻塞的套接字，若不能满足输入操作要求，则会立即返回一个 EWOULDBLOCK 错误；
2.  **输出操作引起的阻塞状态，包括 write、writev、send、sendto 和 sendmsg 函数**。对于一个阻塞 TCP 套接字，内核将从应用进程的缓冲区复制数据到该套接字的发送缓冲区，若该套接字的发送缓冲区没有存储空间，则进程会进入阻塞状态，直到有空间为止；对于一个非阻塞的 TCP 套接字，若其发送缓冲区没有存储空间，则输出函数调用立即返回一个 EWOULDBLOCK 错误，当发送缓冲区有空间时，则内核把应用进程缓冲区的数据复制到发送缓冲区中，并返回已复制的字节数；由于 UDP 套接字不存在真正的发送缓冲区，内核只是将应用进程的数据复制并把它沿协议栈向下传送，因此对于一个阻塞 UDP 套接字调用输出函数时不会和 TCP 一样的原因而阻塞，是因为其他的原因（在书本上没有说明是什么原因）；
3.  **接受连接请求引起的阻塞状态，即 accept 函数**。当阻塞套接字调用 accept 函数时，若没有新的连接请求，则进程就会进入阻塞状态；非阻塞套接字调用 accept 函数时，且不存在新的连接请求，则 accept 函数调用立即返回一个 EWOULDBLOCK 错误；
4.  **发出连接请求引起的阻塞状态，即用于 TCP 的 connect 函数**。由于 TCP 的连接建立需要三次握手过程，且 connect 函数一直等待客户端收到对自己的 SYN 的应答响应 ACK 才返回，因此，每个 connect 发起的连接请求在 RTT 时间内处于阻塞状态；对于 非阻塞 TCP 套接字调用 connect 函数时，若连接不能立即建立，则连接请求正常发出，但是会返回一个 EINPROGRESS 错误，但此时已经发起的 TCP 连接请求三次握手过程会继续进行；

### 非阻塞读写 ###

在非阻塞读写的编程中，维护两个缓冲区：to 容纳从标准输入到服务器去的数据，fr 容纳自服务器到标准输出来的数据，这两个缓冲区具体结构如下图所示：

其中 toiptr 指针指向标准输入读入的数据可以存放的下一个字节，tooptr 指向下一个必须写到套接字的字节。一旦 tooptr 移动到 toiptr，则这两个指针就一起恢复到缓冲区开始处。

![Center][]

![Center 1][]

/* include nonb1 */
    #include <sys/select.h>
    #include <sys/socket.h>
    #include <errno.h>
    #include <fcntl.h>
    #include <string.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    #define MAXLINE 4096
    inline int Max(int a, int b)
    {
        return(a >= b?a:b);
    }
    
    extern void err_sys(const char *, ...);
    extern void err_quit(const char *, ...);
    
    static void set_fl(int fd, int flags);
    
    void str_cli(FILE *fp, int sockfd)
    {
    	int			maxfdp1, stdineof;
    	ssize_t		n, nwritten;
    	fd_set		rset, wset;
    	char		to[MAXLINE], fr[MAXLINE];
    	char		*toiptr, *tooptr, *friptr, *froptr;
    
        /* 设置套接字描述符为非阻塞 */
        set_fl(sockfd, O_NONBLOCK);
        /* 设置标准输入为非阻塞 */
        set_fl(STDIN_FILENO, O_NONBLOCK);
        /* 设置标准输出为非阻塞 */
        set_fl(STDOUT_FILENO, O_NONBLOCK);
    
        /* 初始化两个缓冲区指针 */
    	toiptr = tooptr = to;	/* initialize buffer pointers */
    	friptr = froptr = fr;
    	stdineof = 0;/* 标准输入键入EOF的标志 */
    
    	maxfdp1 = Max(Max(STDIN_FILENO, STDOUT_FILENO), sockfd) + 1;
    	for ( ; ; ) {
            /* 初始化，为调用select函数做准备 */
    		FD_ZERO(&rset);
    		FD_ZERO(&wset);
    		if (stdineof == 0 && toiptr < &to[MAXLINE])
    			FD_SET(STDIN_FILENO, &rset);	/* read from stdin */
    		if (friptr < &fr[MAXLINE])
    			FD_SET(sockfd, &rset);			/* read from socket */
    		if (tooptr != toiptr)
    			FD_SET(sockfd, &wset);			/* data to write to socket */
    		if (froptr != friptr)
    			FD_SET(STDOUT_FILENO, &wset);	/* data to write to stdout */
    
    		if(select(maxfdp1, &rset, &wset, NULL, NULL) < 0)
                err_sys("select error");
    /* end nonb1 */
    /* include nonb2 */
            /* 若标准输入在rset有效，则从标准输入读取数据到发送缓冲区 */
    		if (FD_ISSET(STDIN_FILENO, &rset))
            {
    			if ( (n = read(STDIN_FILENO, toiptr, &to[MAXLINE] - toiptr)) < 0)
                {
    				if (errno != EWOULDBLOCK)
    					err_sys("read error on stdin");
    
    			}
                else if (n == 0)
                {
    				stdineof = 1;			/* all done with stdin */
    				if (tooptr == toiptr)
    					if(shutdown(sockfd, SHUT_WR) < 0)/* send FIN */
                            err_sys("shutdown error");
    
    			}
                else
                {
    				toiptr += n;			/* # just read */
    				FD_SET(sockfd, &wset);	/* try and write to socket below */
    			}
    		}
    
            /* 若套接字在rset有效，则从套接字读取数据到接收缓冲区中 */
    		if (FD_ISSET(sockfd, &rset))
            {
    			if ( (n = read(sockfd, friptr, &fr[MAXLINE] - friptr)) < 0)
                {
    				if (errno != EWOULDBLOCK)
    					err_sys("read error on socket");
    
    			}
                else if (n == 0)
                {
    				if (stdineof)
    					return;		/* normal termination */
    				else
    					err_quit("str_cli: server terminated prematurely");
    
    			}
                else
                {
    				friptr += n;		/* # just read */
    				FD_SET(STDOUT_FILENO, &wset);	/* try and write below */
    			}
    		}
    /* end nonb2 */
    /* include nonb3 */
            /* 若标准输出在wset有效，则从接收缓冲区写数据到标准输出 */
    		if (FD_ISSET(STDOUT_FILENO, &wset) && ( (n = friptr - froptr) > 0))
            {
    			if ( (nwritten = write(STDOUT_FILENO, froptr, n)) < 0)
                {
    				if (errno != EWOULDBLOCK)
    					err_sys("write error to stdout");
    
    			}
                else
                {
    				froptr += nwritten;		/* # just written */
    				if (froptr == friptr)
    					froptr = friptr = fr;	/* back to beginning of buffer */
    			}
    		}
    
            /* 若套接字在wset有效，则从发送缓冲区写数据到套接字中 */
    		if (FD_ISSET(sockfd, &wset) && ( (n = toiptr - tooptr) > 0))
            {
    			if ( (nwritten = write(sockfd, tooptr, n)) < 0)
                {
    				if (errno != EWOULDBLOCK)
    					err_sys("write error to socket");
    
    			}
                else
                {
    				tooptr += nwritten;	/* # just written */
    				if (tooptr == toiptr) {
    					toiptr = tooptr = to;	/* back to beginning of buffer */
                        /* 若套接字接收来自标准输入的数据，则关闭套接字写端，相当于从标准输入键入EOF */
    					if (stdineof)
    						if(shutdown(sockfd, SHUT_WR) <0)	/* send FIN */
                                err_sys("Shutdown error");
    				}
    			}
    		}
    	}
    }
    /* end nonb3 */
    
    static void set_fl(int fd, int flags)
    {
        int val;
        /* 获取描述符状态标志 */
        if( (val = fcntl(fd, F_GETFL, 0)) < 0)
            err_sys("fcntl get error");
        /* 添加描述符状态标志flags*/
        val |= flags;
    
        /* 设置描述符状态标志 */
        if(fcntl(fd, F_SETFL, val) < 0)
            err_sys("fcntl set error");
    }

### 非阻塞 connect ###

**非阻塞 connect 有以下好处：**

1.  发起连接请求 connect时，在处于 TCP 连接三次握手过程的时间，即 RTT 时间内，套接字可以处理其他事务，不必处于阻塞状态；
2.  在等待连接建立成功期间，套接字可以发起多个连接请求；
3.  在非阻塞 connect 中使用到 select 函数，因此可以通过 select 参数自由设置超时时间，不必由系统限制 connect 的超时时间；

**select 判断规则：**

1.  如果 select 返回 -1，表示 select 出错，可以关闭 socket 套接字，重新发起连接过程；  
    
2.  如果 select 返回 0，表示在 select 超时，超时时间内未能成功建立连接，也可以再次执行 select 进行检测，如若多次超时，需返回超时错误给用户；
3.  如果 select 返回大于 0 的值，则说明检测到可读或可写的套接字描述符。源自 Berkeley 的实现有两条与 select 和非阻塞 I/O 相关的规则：

*   *  1）当套接字连接建立成功时，套接口描述符变成 **可写**（连接建立时，写缓冲区空闲，所以可写）；
     *  2）当套接字连接建立出错时，套接口描述符变成 **既可读又可写**（由于有未决的错误，从而可读又可写）；

因此，当发现套接口描述符 **可读或可写**时，可进一步判断是连接成功还是出错。这里必须将 **2）**和另外一种连接正常的情况区分开，就是连接建立好了之后，服务器端发送了数据给客户端，此时 select 同样会返回非阻塞 socket 描述符既可读又可写。  
对于 Unix 环境，可通过调用 getsockopt 来检测描述符集合是连接成功还是出错，但是该方法在 Linux 环境上测试是无效的。因为在 Linux 下无论网络是否发生错误，getsockopt 始终返回 0，不返回-1。若采用 getsockopt 来检查：

1.  如果连接建立是成功的，则通过 getsockopt(sockfd,SOL\_SOCKET,SO\_ERROR, &error,&len) 获取的 error 值将是 0；
2.  如果建立连接时遇到错误，则 errno 的值是连接错误所对应的 errno 值，比如ECONNREFUSED，ETIMEDOUT 等；

在 Linux 环境下可以使用以下方法进行测试连接是成功还是出错：再次调用connect，相应返回失败，如果错误 errno 是EISCONN，表示 socket 连接已经建立，否则认为连接失败。即在一次 select 调用之后，若发现此时套接口描述字 **可读或可写**，则再次执行 connect 调用，此时 errno 始终仍为 EINPROGRESS，则再次执行 select 和 connect 函数，直到 errno 被置为EISCONN，表示 connect 成功。

**非阻塞 connect 编程步骤：**

1.  第一步：调用 socket 创建套接字，并使用 fcntl 函数使该套接字变为非阻塞式；
2.  第二步：调用 connect 函数请求建立连接，并判断连接是否成功建立；

*   *  若 connect 调用返回 0，则表示连接请求成功建立；
     *  若 connect 调用返回 -1，首先检查 errno 错误类型，若不为 EINPROGRESS 错误，则直接退出，否则只是当前连接不能立即建立，但是已经发起的 TCP 连接请求三次握手过程会继续进行，此时调用 select 函数判断连接是否建立成功：
        
         *  若 select 调用返回 0，则表示 select 超时期限内不能成功建立连接，则此时返回一个超时错误，且关闭该链接，以防止 TCP 连接的三次握手过程继续进行；
         *  若 select 调用返回正值，则表示在超时期限内检查到套接字可读或可写或异常，若可读或可写，在 Unix 系统中，此时通过调用 getsockopt 函数检查连接状态，若连接成功，则该值为 0，若连接建立发生错误，则该值是对应连接错误的 errno 值；

假设在调用 select 函数之前连接已经建立，并服务器发送的数据已到达客户端，此时非阻塞套接字处于即可读又可写状态。然而由 select 函数调用返回大于 0 值时，使用 getsockopt 检查到连接出错时，非阻塞套接字也是 既可读又可写。这样就会导致移植性问题，我们可以使用下列方法代替 getsockopt 调用：

1.  调用 getpeername 代替 getsockopt。若 getpeername 以 ENOTCONN 错误失败返回，则表示连接建立失败，紧接着必须以 SO\_ERROR 调用 getsockopt 取得套接字上待处理的错误；
2.  以值为 0 的长度参数调用 read 函数。若 read 调用失败，表示 connect 连接失败，read 返回的 errno 给出连接失败的原因，若连接建立成功，则 read 返回 0；
3.  再一次调用 connect 函数。如果返回错误 EISCONN，表示套接字已经连接，即连接建立成功；

#include <sys/select.h>
    #include <sys/socket.h>
    #include <errno.h>
    #include <fcntl.h>
    #include <string.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    extern void err_quit(const char *, ...);
    int
    connect_nonb(int sockfd, const struct sockaddr *saptr, socklen_t salen, int nsec)
    {
    	int				flags, n, error;
    	socklen_t		len;
    	fd_set			rset, wset;
    	struct timeval	tval;
    
        /* 将套接字设置为非阻塞状态 */
    	flags = fcntl(sockfd, F_GETFL, 0);
    	fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
    
    	error = 0;
        /* 发起连接请求，若返回EINPROGRESS，表示连接建立已经启动但是尚未完成 */
    	if ( (n = connect(sockfd, saptr, salen)) < 0)
    		if (errno != EINPROGRESS)/* 若是其他错误，则表示连接建立失败，直接退出 */
    			return(-1);
    
    	/* Do whatever we want while the connect is taking place. */
    
        /* 连接建立成功 */
    	if (n == 0)
    		goto done;	/* connect completed immediately */
    
        /* 若返回EINPROGRESS错误，表示连接建立已经启动但是尚未完成；
         * 此时调用select函数检查连接状态；
         */
    	FD_ZERO(&rset);
    	FD_SET(sockfd, &rset);
    	wset = rset;
    	tval.tv_sec = nsec;
    	tval.tv_usec = 0;
        /* 若select返回0，表示连接请求超时，建立连接失败，关闭该链接，并设置errno错误类型 */
    	if ( (n = select(sockfd+1, &rset, &wset, NULL,
    					 nsec ? &tval : NULL)) == 0) {
    		close(sockfd);		/* timeout */
    		errno = ETIMEDOUT;
    		return(-1);
    	}
        /* 若select返回大于0，则此时套接字处于可读或可写状态；
         * 则此时调用getsockopt函数检查连接状态，判断是连接成功还是失败；
         */
    	if (FD_ISSET(sockfd, &rset) || FD_ISSET(sockfd, &wset)) {
    		len = sizeof(error);
    		if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len) < 0)
    			return(-1);			/* Solaris pending error */
    	} else
    		err_quit("select error: sockfd not set");
    
    done:
    	fcntl(sockfd, F_SETFL, flags);	/* restore file status flags */
    
    	if (error) {
    		close(sockfd);		/* just in case */
    		errno = error;
    		return(-1);
    	}
    	return(0);
    }

### 非阻塞 accept ###

（1）使用 select 获悉某个监听套接字上何时有已完成连接准备好被 accept 时，总是把这个监听套接字设置为非阻塞。  
（2）在后续的 accept 调用中忽略以下错误：EWOULDBLOCK（源自Berkeley的实现，客户终止连接时），ECONNABORTED（POSIX实现，客户终止连接时），EPROTO（SVR4实现，客户终止连接时）和 EINTR（如果有信号被捕获）

参考资料：

《Unix 网络编程》

[I_O]: http://blog.csdn.net/chenhanzhun/article/details/41908045
[Center]: /images/20220806/137ed3e180864f0faec7444806235fd9.png
[Center 1]: /images/20220806/cb4cc57f4aa14706bd12f7a24166d0f2.png