unix网络编程 恶意客户端疑问

LevinYan

在看《unix网络编程》6.8节-TCP Echo Server最后的描述的时候感觉很疑问，作者认为恶意的客户端发送一个字节，然后进行sleep，服务器read完之后，就是会在下一次read的时候阻塞。但是我怎么理解不了为什么下一次read的时候

ssize_t                                                /* Write "n" bytes to a descriptor. */
writen(int fd, const void *vptr, size_t n)
{
        size_t                nleft;
        ssize_t                nwritten;
        const char        *ptr;

        ptr = vptr;
        nleft = n;
        while (nleft > 0) {
                if ( (nwritten = write(fd, ptr, nleft)) <= 0) {
                        if (nwritten < 0 && errno == EINTR)
                                nwritten = 0;                /* and call write() again */
                        else
                                return(-1);                        /* error */
                }

                nleft -= nwritten;
                ptr   += nwritten;
        }
        return(n);
}
/* end writen */

void
Writen(int fd, void *ptr, size_t nbytes)
{
        if (writen(fd, ptr, nbytes) != nbytes)
                err_sys("writen error");
}

ssize_t
Read(int fd, void *ptr, size_t nbytes)
{
        ssize_t                n;

        if ( (n = read(fd, ptr, nbytes)) == -1)
                err_sys("read error");
        return(n);
}

/* include fig01 */
#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 = -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 < 0) {
                                        client = 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) < 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 = -1;
                                } else
                                        Writen(sockfd, buf, n);

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




我也不是纠结于细节，我觉得这本书写的很好，应该是我哪里理解错，希望正在读或之前读过这本书可以出来交流一下

ssffzz1

你想想要是这次就阻塞了的话，是不是连那个“恶意的客户端发送一个字节”也读不到啊。

incle

代码建议用code符弄起来,这样大家看起来方便一点.

LevinYan

回复 2# ssffzz1

问题我困惑在为什么会阻塞，作者描述在下一个read的时候会阻塞，但是要是没有数据到来，select就不会去调用read，所以何来阻塞。


   

LevinYan

回复 3# incle


    第一次发帖，以后我会注意的

tc1989tc

回复 5# LevinYan


    应该是你的资源得不到释放吧   虽然是select。。但是这时候也会阻塞在select吧