UNP学习第六章（二）

一、描述符就绪条件

对于引起select返回套接字“就绪”的条件我们必须讨论得更明确：

（1）满足一下塞个条件中的仍和一个时，一个套接字准备好读。

a）该套接字接收缓冲区中的数据字节数不大于等于套接字接收缓冲区低水位标记的当前大小。相关SO_RCVLOWAT默认值为1

b）该连接的读半部关闭（也就接收了FIN的TCP连接）。对这样的套接字读操作将不阻塞并返回0（返回EOF）

c）该套接字是一个监听套接字且已完成的连接数不为0（accept不阻塞）

d）其上有一个套接字错误待处理。

（2）下列四个条件中任何一个满足时，一个套接字准备好写。

a）该套接字发送发送缓冲区中的可用空间字节数大于等于套接字发送缓冲区低水位标记的当前大小，

并且该套接字已连接，或者该套接字不需要连接。相关SO_SNDLOWAT默认2048

b）该链接写半部关闭。写操作将产生SIGPIPE

c）使用非阻塞式connect套接字已建立连接，或者connect已经以失败告终

d）其上有一个套接字错误待处理。

（3）如果一个套接字存在带外数据或者仍处于带外标记，那么它有异常条件待处理。

二、shutdown函数

#include <sys/socket.h>

int shutdown(int sockfd, int howto);
返回：成功为0，出错-
sockfd：套接字描述符
howto：
SHUT_RD:关闭连接的读这一半，套接字不再有数据可接收
SHUT_WR:关闭连接的写这一半，套接字不再有数据可发送
SHUT_RDWR:连接的读半部和写半部都关闭

str_cli函数（再修订版）：

 #include "unp.h"

 void
 str_cli(FILE *fp, int sockfd)
 {
     int maxfdp1, stdineof;
     fd_set rset;
     char buf[MAXLINE];
     int n;

     stdineof = ;
     FD_ZERO(&rset);
     for( ; ;) {
         if(stdineof == )
             FD_SET(fileno(fp), &rset);
         FD_SET(sockfd, &rset);
         maxfdp1 = max(fileno(fp), sockfd) + ;
         Select(maxfdp1, &rset, NULL, NULL, NULL);
         if(FD_ISSET(sockfd, &rset)) {
             if((n = Read(sockfd, buf, MAXLINE)) == ) {
                 if(stdineof == )
                     return;
                 else
                     err_quit("str_cli: server terminated prematurely");
             }
             Write(fileno(stdout), buf, n);
         }
         if(FD_ISSET(fileno(fp), &rset)) {
             if((n = Read(fileno(fp), buf, MAXLINE)) == ) {
                 stdineof = ;
                 Shutdown(sockfd, SHUT_WR);
                 FD_CLR(fileno(fp), &rset);
                 continue;
             }
             Writen(sockfd, buf, n);
         }
     }
 }

str_cli

三、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 struct timespec *timeout, const sigset_t *sigmask);
返回：若有就绪描述符则为其数目，若超时则为0，若出错则为-1
maxfdp1:最大描述符集+1
readset:读集
writeset:写集
exceptset:异常集
timeout:延时
sigmask:掩码

pselect()用来等待文件描述词状态的改变，和select()类似，它增加了超时值的精度，并且可以在等待文件描述符“准备好”的同时指定一组信号掩码。

四、poll函数

#include <poll.h>

int poll(struct pollfd *fdarray, unsigned long nfds, int timeout);
返回：若有就绪描述符则为其数目，若超时则为0，若出错则为-1
struct pollfd {
    int fd;
    short events;
    short revents;
}
fdarray:指向结构数组第一个元素的指针
nfds:用于标记数组fds中的结构体元素的总数量
timeout:是poll函数调用阻塞的时间，单位：毫秒

poll的百度示例，和select类似

 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 #include <string.h>
 #include <errno.h>
 #include <poll.h>
 #include <fcntl.h>
 #include <unistd.h>

 #define MAX_BUFFER_SIZE 1024
 #define IN_FILES 3
 #define TIME_DELAY 60*5
 #define MAX(a,b) ((a>b)?(a):(b))

 int
 main(int argc, char **argv)
 {
     struct pollfd fds[IN_FILES];
     char buf[MAX_BUFFER_SIZE];
     int i, res, real_read, maxfd;
     fds[].fd = ;
     if((fds[].fd = open("data1", O_RDONLY|O_NONBLOCK)) < ) {
         fprintf(stderr, "open data1 error:%s", strerror(errno));
         return ;
     }
     if((fds[].fd = open("data2", O_RDONLY|O_NONBLOCK)) < ) {
         fprintf(stderr, "open data2 error:%s", strerror(errno));
         return ;
     }

     for(i=;i<IN_FILES;i++)
         fds[i].events = POLLIN;

     while(fds[].events || fds[].events || fds[].events) {
         if(poll(fds, IN_FILES, TIME_DELAY) <= ) {
             printf("Poll error\n");
             return ;
         }
         for(i=;i<IN_FILES;i++) {
             if(fds[i].revents) {
                 memset(buf, , MAX_BUFFER_SIZE);
                 real_read = read(fds[i].fd, buf, MAX_BUFFER_SIZE);
                 if(real_read < ) {
                     if(errno != EAGAIN)
                         return ;
                 } else if(!real_read) {
                     close(fds[i].fd);
                     fds[i].events = ;
                 } else {
                     if(i == ) {
                         if((buf[] == 'q') || (buf[] == 'Q'))
                             return ;
                     } else {
                         buf[real_read] = '\0';
                         printf("%s", buf);
                     }
                 }
             }

         }
     }
     exit();
 }

poll

 #include "unp.h"
 #include <limits.h>

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

     listenfd = Socket(AF_INET, SOCK_STREAM, ); 

     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);

     client[].fd = listenfd;
     client[].events = POLLRDNORM;
     for(i=;i<OPEN_MAX;i++)
         client[i].fd = -;
     maxi = ;

     for( ; ; ) {
         nready = Poll(client, maxi+, INFTIM);

         if(client[].revents & POLLRDNORM) {
             clilen = sizeof(cliaddr);
             connfd = Accept(listenfd, (SA *)&cliaddr, &clilen);

             for(i=;i<OPEN_MAX;i++)
                 if(client[i].fd < ) {
                     client[i].fd = connfd;
                     break;
                 }
             if(i == OPEN_MAX)
                 err_quit("too many clients");

             client[i].events = POLLRDNORM;
             if(i > maxi)
                 maxi = i;

             if(--nready <= )
                 continue;
         }
         for(i = ;i<=maxi;i++) {
             if((sockfd = client[i].fd) < )
                 continue;
             if(client[i].revents & (POLLRDNORM | POLLERR)) {
                 if((n = read(sockfd, buf, MAXLINE)) < ) {
                     if(errno = ECONNRESET) {
                         Close(sockfd);
                         client[i].fd = -;
                     } else
                         err_sys("read error");
                 } else if(n == ) {
                     Close(sockfd);
                     client[i].fd = -;
                 } else
                     Writen(sockfd, buf, n);

                 if(--nready <= )
                     break;
             }
         }
     }
 }

tcp