UNIX网络编程——非阻塞accept

当有一个已完成的连接准备好被accept时，select将作为可读描述符返回该连接的监听套接字。因此，如果我们使用select在某个监听套接字上等待一个外来连接，那就没有必要把监听套接字设置为非阻塞，这是因为如果select告诉我们该套接字上已有连接就绪，那么随后的accept调用不应该阻塞。

不幸的是，这里存在一个可能让我们掉入陷阱的定时问题。

为了查看这个问题，我们把TCP回射客户程序改成建立连接后发送一个RST到服务器：

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<signal.h>
#include <fcntl.h>
#define SERV_PORT 3333

#define ERR_EXIT(m) \
    do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while (0)
typedef  struct sockaddr SA;
int main(int argc, char **argv)
{
	int					sockfd;
	struct linger		ling;
	struct sockaddr_in	servaddr;

	if (argc != 2)
		ERR_EXIT("usage: tcpcli <IPaddress>");

	sockfd = socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SERV_PORT);
	inet_pton(AF_INET, argv[1], &servaddr.sin_addr);

	connect(sockfd, (SA *) &servaddr, sizeof(servaddr));

	ling.l_onoff = 1;		/* cause RST to be sent on close() */
	ling.l_linger = 0;
	setsockopt(sockfd, SOL_SOCKET, SO_LINGER, &ling, sizeof(ling));
	close(sockfd);

	exit(0);
}

服务器serv.c：

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<signal.h>
#include <fcntl.h>
#define SERV_PORT 3333
#define MAXLINE 1024
#define LISTENQ 5

#define ERR_EXIT(m) \
    do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while (0)
typedef  struct sockaddr SA;

int main(int argc, char **argv)
{
	int					i, maxi, maxfd, listenfd, connfd, sockfd;
	int					nready, client[FD_SETSIZE];
	ssize_t				n;
	fd_set				rset, allset;
	char				buf[MAXLINE];
	socklen_t			clilen;
	struct sockaddr_in	cliaddr, servaddr;

	listenfd = socket(AF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family      = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port        = htons(SERV_PORT);

	bind(listenfd, (SA *) &servaddr, sizeof(servaddr));

	listen(listenfd, LISTENQ);

	maxfd = listenfd;			/* initialize */
	maxi = -1;					/* index into client[] array */
	for (i = 0; i < FD_SETSIZE; i++)
		client[i] = -1;			/* -1 indicates available entry */
	FD_ZERO(&allset);
	FD_SET(listenfd, &allset);
	for ( ; ; ) {
		rset = allset;		/* structure assignment */
		nready = select(maxfd+1, &rset, NULL, NULL, NULL);

		if (FD_ISSET(listenfd, &rset)) {	/* new client connection */
		    printf("listening socket readable\n");
            sleep(5);
			clilen = sizeof(cliaddr);
			connfd = accept(listenfd, (SA *) &cliaddr, &clilen);
			if(connfd < 0)
			   perror("accept:");
			printf("connfd = %d\n",connfd);
			char dst[MAXLINE];
            printf("new client: %s, port %d\n",(char *)inet_ntop(AF_INET, &cliaddr.sin_addr, dst, sizeof(dst)),ntohs(cliaddr.sin_port));

			for (i = 0; i < FD_SETSIZE; i++)
				if (client[i] < 0) {
					client[i] = connfd;	/* save descriptor */
					break;
				}
			if (i == FD_SETSIZE)
				ERR_EXIT("too many clients");

			FD_SET(connfd, &allset);	/* add new descriptor to set */
			if (connfd > maxfd)
				maxfd = connfd;			/* for select */
			if (i > maxi)
				maxi = i;				/* max index in client[] array */

			if (--nready <= 0)
				continue;				/* no more readable descriptors */
		}

		for (i = 0; i <= maxi; i++) {	/* check all clients for data */
			if ( (sockfd = client[i]) < 0)
				continue;
			if (FD_ISSET(sockfd, &rset)) {
				if ( (n = read(sockfd, buf, MAXLINE)) == 0) {
						/*4connection closed by client */
					close(sockfd);
					FD_CLR(sockfd, &allset);
					client[i] = -1;
				} else
					write(sockfd, buf, n);

				if (--nready <= 0)
					break;				/* no more readable descriptors */
			}
		}
	}
}

54~59改为：

		if (FD_ISSET(listenfd, &rset)) {	/* new client connection */
		    printf("listening socket readable\n");
            sleep(5);
			clilen = sizeof(cliaddr);
			connfd = accept(listenfd, (SA *) &cliaddr, &clilen);
			if(connfd < 0)
			   perror("accept:");
			printf("connfd = %d\n",connfd);

在Ubuntu 10.04系统下，先运行服务器，在运行客户端2次，运行结果：

huangcheng@ubuntu:~$ ./serv
huangcheng@ubuntu:~$ ./cli 192.168.2.103
huangcheng@ubuntu:~$ ./cli 192.168.2.103

huangcheng@ubuntu:~$ ./serv
listening socket readable
connfd = 4
new client: 192.168.2.103, port 52336
listening socket readable
connfd = 5
new client: 192.168.2.103, port 52337

即没有出现后面accept返回错误，而是正常返回已完成连接队列的套接字ID。

后面的说法虽然没有出现，但是可以了解。

这里我们是模拟一个繁忙的服务器，它无法在select返回监听套接字的可读条件后就马上调用accept。通常情况下服务器的这种迟钝不成问题（实际上这就是要维护一个已完成连接队列的原因），但是结合上连接建立之后到达的来自客户的RST，问题就出现了。

当客户在服务器调用accept之前终止某个连接时，源自Berkeley的实现不把这个终止的连接返回给服务器，而其他实现应该返回ECONNABORTED错误，却往往代之以返回EPROTO错误。考虑一个源自Berkeley的实现上的如下例子。

（1）客户建立一个连接并随后终止它。

（2）select向服务器进程返回到调用accept期间，服务器TCP收到来自客户的RST。

（3）在服务器从select返回到调用accept期间，服务器TCP收到来自客户的RST。

（4）这个已完成的连接被服务器TCP驱除出队列，我们假设队列中没有其他已完成的连接。

（5）服务器调用accept，但是由于没有任何已完成的连接，服务器于是阻塞。

服务器会一直阻塞在accept调用上，直到其他客户建立一个连接为止。但是在此期间，服务器单纯阻塞在accept调用上，无法处理任何其他已就绪的描述符。

本问题的解决办法如下：

（1）当使用select获悉某个监听套接字上何时有已完成连接准备好被accept时，总是把这个监听套接字设置为非阻塞。

（2）在后续的accept调用中忽略以下错误：EWOULDBLOCK（源自Berkeley的实现，客户终止连接时），ECONNABORTED（POSIX实现，客户终止连接时），EPROTO（SVR4实现，客户终止连接时）和EINTR（如果有信号被捕获）。