书籍“Unix网络编程”中的拒绝服务攻击问题

Question

我在阅读“Unix网络编程”第3版。

我遇到6.8节的一个问题“TCP回声服务器（再访）”，在座的代码如下：

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

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

      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 */ 
      } 
     } 
    } 
} 

关于这个节目，作者说，服务器将从如下DDOS攻击苦： enter image description here

该点一旦客户端请求到来，服务器读取整行然后回显它。但是这个代码，我们看到服务器使用Read函数从客户端读取数据，而不是ReadLine或Readn，在遇到'\ n'或者获取指定大小的数据之前，后者不会返回，但是Read函数在这种情况下立即返回。 阅读功能只是系统调用的包装“读”，如下：

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

所以我感到困惑，为什么这个服务器将从DDoS攻击受苦？

任何人都可以解释它吗？非常感谢你！

Answer 1

我认为这种混淆是由于本书的第二版和第三版可能存在差异。

我有第二版，其中“Read”实际上是一个“Readline”。然后，解释是有道理的，因为Readline坚持阅读直到换行。

我没有第三版的副本与之比较。

至于Drunken Code Monkey的解释，true表示read是阻塞的，但是它受select的保护，这将保证只有在套接字上有活动（断开连接或在至少1个字节读取）。所以保证读取不会被阻塞。但是看到我，如果读取被替换的Readline有关解释（在第2版）

又见一前一后上堆栈溢出Unix Network Programming Clarification

Answer 2

按斯特凡的回应，在这里是为了说明正确的连接在一个处理的例子多线程TCP服务器。请注意，我对Linux开发很不舒服，很容易编写它，所以这是C＃，但程序流程应该是相同的。如果您必须将其视为伪代码。

// We use a wait handle here to synchronize the client threads with the main thread. 
    private static AutoResetEvent _waitHandle = new AutoResetEvent(false); 

    static void Main(string[] args) 
    { 
     // Start the server on port 1337 
     StartServer(1337); 
    } 

    private static void StartServer(int port) 
    { 
     // Create a connection listener 
     var listener = new TcpListener(IPAddress.Any, port); 

     try 
     { 
      // Start the listener 
      listener.Start(); 
      while (true) 
      { 
       // Wait for a connection, and defer connection handling asynchronously. 
       listener.BeginAcceptTcpClient(new AsyncCallback(HandleAsyncConnection), listener); 
       _waitHandle.WaitOne(); 
       _waitHandle.Reset(); 
      } 
     } 
     catch (SocketException ex) 
     { 
      // Handle socket errors or any other exception you deem necessary here 
     } 
     finally 
     { 
      // Stop the server. 
      listener.Stop(); 
     } 
    } 

    private static void HandleAsyncConnection(IAsyncResult state) 
    { 
     // Get the listener and the client references 
     var listener = (TcpListener)state.AsyncState; 
     using (var tcpClient = listener.EndAcceptTcpClient(state)) 
     { 
      // Signal the main thread that we have started handling this request. 
      // At this point the server is ready to handle another connection, and no amount 
      // of tomfoolery on the client's side will prevent this. 
      _waitHandle.Set(); 

      // Declare buffers 
      var inBuff = new byte[tcpClient.ReceiveBufferSize]; 
      var outBuff = new byte[tcpClient.SendBufferSize]; 

      // Get the connection stream 
      using (var stream = tcpClient.GetStream()) 
      { 
       try 
       { 
        // Read some data into inBuff 
        stream.Read(inBuff, 0, tcpClient.ReceiveBufferSize); 

        // Do something with the data here, put response in outBuff... 

        // Send response to client 
        stream.Write(outBuff, 0, outBuff.Length); 
       } 
       catch (SocketException ex) 
       { 
        // Handle socket errors or any other exception you deem necessary here 
       } 
      } 
     } 
    }