apue和unp的学习之旅08——I/O复用(2)

函数的行为取决于howto参数的值：

SHUT_RD:关闭连接的读这一半——套接字中不再有数据可接收，而且套接字接收缓冲区中的现有数据都被抛弃。进程不能再对这种的套接字调用任何读函数。对一个TCP套接字这样调用shutdown函数后，由该套接字接收的来自对端的任何数据都被确定，然后逐渐抛弃。

SHUT_WR:关闭连接的写这一版——当前留在套接字发送缓冲区中的数据将被发送掉，后跟TCP的正常终止系列。我们终于讲到，不管套接字描述符引用计数是否等于0，这样的写半部关闭照样执行，进程不能再对这种的套接字调用任何写变量。

SHUT_RDWR:连接的读半部和写半部都关闭——这与分别读取shutdown指定SHUT_RD，和shutdown指定SHUT_WR等效。

于是改进版的客户str_cli函数如下：

#include	"unp.h"
void
str_cli(FILE *fp, int sockfd)
{
	int			maxfdp1, stdineof;
	fd_set		rset;
	char		buf[MAXLINE];
	int		n;
	stdineof = 0;
	FD_ZERO(&rset);
	for ( ; ; ) {
		if (stdineof == 0)
			FD_SET(fileno(fp), &rset);
		FD_SET(sockfd, &rset);
		maxfdp1 = max(fileno(fp), sockfd) + 1;
		Select(maxfdp1, &rset, NULL, NULL, NULL);
		if (FD_ISSET(sockfd, &rset)) {	/* socket is readable */
			if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {
				if (stdineof == 1)
					return;		/* normal termination */
				else
					err_quit("str_cli: server terminated prematurely");
			}
			Write(fileno(stdout), buf, n);
		}
		if (FD_ISSET(fileno(fp), &rset)) {  /* input is readable */
			if ( (n = Read(fileno(fp), buf, MAXLINE)) == 0) {
				stdineof = 1;
				Shutdown(sockfd, SHUT_WR);	/* send FIN */
				FD_CLR(fileno(fp), &rset);
				continue;
			}
			Writen(sockfd, buf, n);
		}
	}
}

当我们在套接字上读到EOF时，如果我们已在标准输入上碰到EOF，那就是正常的中止，于是函数返回。但是一旦我们

在标准输入上没有遇到EOF，那么是服务器进程频繁终止。

而且目前改为read和write针对缓冲区操作，而不是针对文本行操作。

//-----------------------------------7.使用select的服务器----------------------------------------

#include	"unp.h"
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);
/* end fig01 */
/* include fig02 */
	for ( ; ; ) {
		rset = allset;		/* structure assignment */
		nready = Select(maxfd+1, &rset, NULL, NULL, NULL);
		if (FD_ISSET(listenfd, &rset)) {	/* new client connection */
			clilen = sizeof(cliaddr);
			connfd = Accept(listenfd, (SA *) &cliaddr, &clilen);
#ifdef	NOTDEF
			printf("new client: %s, port %d\n",
					Inet_ntop(AF_INET, &cliaddr.sin_addr, 4, NULL),
					ntohs(cliaddr.sin_port));
#endif
			for (i = 0; i < FD_SETSIZE; i++)
				if (client[i] < 0) {
					client[i] = connfd;	/* save descriptor */
					break;
				}
			if (i == FD_SETSIZE)
				err_quit("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
					Writen(sockfd, buf, n);
				if (--nready <= 0)
					break;				/* no more readable descriptors */
			}
		}
	}
}

//-------------------------------------8.拒绝服务型攻击----------------------------------------

上面的select服务器程序还是存在疑问，假如有一个恶意的用户连接到服务器，发送一个字节的数据（不是换行符）后开启睡眠，将会发哪个？服务器将读取read，它从用户调用这个单字节的数据，然后阻塞于下一个read调用，以期待来自用户的其余数据（假设今天面向的是文本行的回射服务器，而后面的程序时对于缓冲区而文问本行的），服务器于是由于一个客户而被阻塞，不能再为其它任何用户提供服务，知道哪个而已的用户发出一个换行符或者终止为止。

可能解决的方法比如如下：

a).使用非阻塞式I/O

b).让每位用户由单独的控制线程提供服务。

c).对I/O操作设置一超时。

//-----------------------------------9.pselect函数-----------------------------------------

#include <sys/select.h>

#include <signal.h>

#include <time.h>

int pselect(int maxfdp1, fd_set* readset, fd_set* writeset, fd_set* exceptset.const stuct timespec* timeout, const sigset_t sigmask);

// ret: 若有就绪描述符则为其数目，若超时则为0，若出错则为-1

struct timespec {

time_t tv_sec; // seconds

long tv_nsec; // nanoseconds 纳秒

}；

pselect函数增加了第6个参数：一个指向信号掩码的指针。该参数允许程序先禁止递交某些信号，再检测由很多当前被允许信号的信号处理数组设置的全局函数，然后读取pselect，告诉它再次修改信号掩码。

if(intr_flag)

{

handle_intr();

} // mark1

if((nready = select(...) ) < 0 ) // mark2

{

if(errno == EINTR)

{

if(intr_flag)

{

handle_intr();

}

}

}

问题是，在mark1和mark2之间可能会有SIGINT信号出现，那么若select永远阻塞，该信号将损坏。但是有了pselect后，就能根据上面的方法靠谱地编写这个事例了，

sigset_t newmask,oldmask,zeromask;

sigemptyset(&zeromask);

sigempty(&newmask);

sigaddset(&newmask, SIGINT);

sigprocmask(SIG_BLOCK, &newmask, &oldmask); // block SIGINT

本文来自电脑杂谈，转载请注明本文网址：
https://www.pc-fly.com/a/jisuanjixue/article-124075-2.html