首页 > 代码库 > 《网络编程》非堵塞 I/O

《网络编程》非堵塞 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 函数一直等待client收到对自己的 SYN 的应答响应 ACK 才返回。因此,每一个 connect 发起的连接请求在 RTT 时间内处于堵塞状态;对于 非堵塞 TCP 套接字调用 connect 函数时,若连接不能马上建立,则连接请求正常发出,可是会返回一个 EINPROGRESS 错误。但此时已经发起的 TCP 连接请求三次握手过程会继续进行。


非堵塞读写

        在非堵塞读写的编程中,维护两个缓冲区:to 容纳从标准输入到server去的数据。fr 容纳自server到标准输出来的数据,这两个缓冲区详细结构例如以下图所看到的:

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

技术分享



技术分享

/* 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)和第二种连接正常的情况区分开,就是连接建立好了之后,server端发送了数据给client。此时 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 函数之前连接已经建立,并server发送的数据已到达client。此时非堵塞套接字处于就可以读又可写状态。然而由 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