close server if parsing of header field failed

[apt.git] / methods / server.cc

diff --git a/methods/server.cc b/methods/server.cc
index e89af2dfecd37140a50c046d8a69f8d147ca2e6c..5ab97a66037c1dcc8f56a6d6d1a45b4a03eadb85 100644 (file)
--- a/methods/server.cc
+++ b/methods/server.cc
@@ -10,7 +10,6 @@
 // Include Files                                                       /*{{{*/
 #include <config.h>
 
-#include <apt-pkg/acquire-method.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/fileutl.h>
@@ -114,7 +113,7 @@ bool ServerState::HeaderLine(string Line)
 
    // Parse off any trailing spaces between the : and the next word.
    string::size_type Pos2 = Pos;
-   while (Pos2 < Line.length() && isspace(Line[Pos2]) != 0)
+   while (Pos2 < Line.length() && isspace_ascii(Line[Pos2]) != 0)
       Pos2++;
 
    string Tag = string(Line,0,Pos);
@@ -130,7 +129,7 @@ bool ServerState::HeaderLine(string Line)
         {
            Code[0] = '\0';
            if (Owner != NULL && Owner->Debug == true)
-              clog << "HTTP server doesn't give Reason-Phrase for " << Result << std::endl;
+              clog << "HTTP server doesn't give Reason-Phrase for " << std::to_string(Result) << std::endl;
         }
         else if (elements != 4)
            return _error->Error(_("The HTTP server sent an invalid reply header"));
@@ -150,9 +149,15 @@ bool ServerState::HeaderLine(string Line)
       else
       {
         if (Major == 1 && Minor == 0)
+        {
            Persistent = false;
+        }
         else
+        {
            Persistent = true;
+           if (PipelineAllowed)
+              Pipeline = true;
+        }
       }
 
       return true;
@@ -240,7 +245,8 @@ bool ServerState::HeaderLine(string Line)
 }
                                                                        /*}}}*/
 // ServerState::ServerState - Constructor                              /*{{{*/
-ServerState::ServerState(URI Srv, ServerMethod *Owner) : ServerName(Srv), TimeOut(120), Owner(Owner)
+ServerState::ServerState(URI Srv, ServerMethod *Owner) :
+   DownloadSize(0), ServerName(Srv), TimeOut(120), Owner(Owner)
 {
    Reset();
 }
@@ -412,36 +418,66 @@ void ServerMethod::SigTerm(int)
    depth. */
 bool ServerMethod::Fetch(FetchItem *)
 {
-   if (Server == 0)
+   if (Server == nullptr || QueueBack == nullptr)
       return true;
 
-   // Queue the requests
-   int Depth = -1;
-   for (FetchItem *I = Queue; I != 0 && Depth < (signed)PipelineDepth; 
-       I = I->Next, Depth++)
-   {
-      if (Depth >= 0)
-      {
-        // If pipelining is disabled, we only queue 1 request
-        if (Server->Pipeline == false)
-           break;
-        // if we have no hashes, do at most one such request
-        // as we can't fixup pipeling misbehaviors otherwise
-        else if (I->ExpectedHashes.usable() == false)
-           break;
-      }
-      
+   // If pipelining is disabled, we only queue 1 request
+   auto const AllowedDepth = Server->Pipeline ? PipelineDepth : 0;
+   // how deep is our pipeline currently?
+   decltype(PipelineDepth) CurrentDepth = 0;
+   for (FetchItem const *I = Queue; I != QueueBack; I = I->Next)
+      ++CurrentDepth;
+
+   do {
       // Make sure we stick with the same server
-      if (Server->Comp(I->Uri) == false)
+      if (Server->Comp(QueueBack->Uri) == false)
         break;
-      if (QueueBack == I)
+
+      bool const UsableHashes = QueueBack->ExpectedHashes.usable();
+      // if we have no hashes, do at most one such request
+      // as we can't fixup pipeling misbehaviors otherwise
+      if (CurrentDepth != 0 && UsableHashes == false)
+        break;
+
+      if (UsableHashes && FileExists(QueueBack->DestFile))
       {
-        QueueBack = I->Next;
-        SendReq(I);
-        continue;
+        FileFd partial(QueueBack->DestFile, FileFd::ReadOnly);
+        Hashes wehave(QueueBack->ExpectedHashes);
+        if (QueueBack->ExpectedHashes.FileSize() == partial.FileSize())
+        {
+           if (wehave.AddFD(partial) &&
+                 wehave.GetHashStringList() == QueueBack->ExpectedHashes)
+           {
+              FetchResult Res;
+              Res.Filename = QueueBack->DestFile;
+              Res.ResumePoint = QueueBack->ExpectedHashes.FileSize();
+              URIStart(Res);
+              // move item to the start of the queue as URIDone will
+              // always dequeued the first item in the queue
+              if (Queue != QueueBack)
+              {
+                 FetchItem *Prev = Queue;
+                 for (; Prev->Next != QueueBack; Prev = Prev->Next)
+                    /* look for the previous queue item */;
+                 Prev->Next = QueueBack->Next;
+                 QueueBack->Next = Queue;
+                 Queue = QueueBack;
+                 QueueBack = Prev->Next;
+              }
+              Res.TakeHashes(wehave);
+              URIDone(Res);
+              continue;
+           }
+           else
+              RemoveFile("Fetch-Partial", QueueBack->DestFile);
+        }
       }
-   }
-   
+      auto const Tmp = QueueBack;
+      QueueBack = QueueBack->Next;
+      SendReq(Tmp);
+      ++CurrentDepth;
+   } while (CurrentDepth <= AllowedDepth && QueueBack != nullptr);
+
    return true;
 }
                                                                        /*}}}*/
@@ -520,6 +556,7 @@ int ServerMethod::Loop()
         {
            _error->Error(_("Bad header data"));
            Fail(true);
+           Server->Close();
            RotateDNS();
            continue;
         }
@@ -532,6 +569,7 @@ int ServerMethod::Loop()
            _error->Discard();
            Server->Close();
            Server->Pipeline = false;
+           Server->PipelineAllowed = false;
            
            if (FailCounter >= 2)
            {
@@ -604,6 +642,7 @@ int ServerMethod::Loop()
                           strprintf(out, _("Automatically disabled %s due to incorrect response from server/proxy. (man 5 apt.conf)"), "Acquire::http::PipelineDepth");
                           std::cerr << "W: " << out << std::endl;
                           Server->Pipeline = false;
+                          Server->PipelineAllowed = false;
                           // we keep the PipelineDepth value so that the rest of the queue can be fixed up as well
                        }
                        Rename(Res.Filename, I->DestFile);