書籍「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 
       } 
      } 
     } 
    }