CMake: test/libapt: Use a prebuilt GTest library if available

[apt.git] / methods / server.cc

diff --git a/methods/server.cc b/methods/server.cc
index b323ef4f3cdad29e80f9b9edbec9c5095a6cde29..af7276badd7a9f2ca2b7670b78ebb14b4f4f2efc 100644 (file)
--- a/methods/server.cc
+++ b/methods/server.cc
@@ -10,7 +10,6 @@
 // Include Files                                                       /*{{{*/
 #include <config.h>
 
 // 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>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/fileutl.h>


@@ -47,20 +46,9 @@ time_t ServerMethod::FailTime = 0;
 ServerState::RunHeadersResult ServerState::RunHeaders(FileFd * const File,
                                                       const std::string &Uri)
 {
 ServerState::RunHeadersResult ServerState::RunHeaders(FileFd * const File,
                                                       const std::string &Uri)
 {

-   State = Header;
-   
+   Reset(false);

    Owner->Status(_("Waiting for headers"));
 
    Owner->Status(_("Waiting for headers"));
 

-   Major = 0; 
-   Minor = 0; 
-   Result = 0; 
-   TotalFileSize = 0;
-   JunkSize = 0;
-   StartPos = 0;
-   Encoding = Closes;
-   HaveContent = false;
-   time(&Date);
-

    do
    {
       string Data;
    do
    {
       string Data;


@@ -102,25 +90,7 @@ bool ServerState::HeaderLine(string Line)
    if (Line.empty() == true)
       return true;
 
    if (Line.empty() == true)
       return true;
 

-   string::size_type Pos = Line.find(' ');
-   if (Pos == string::npos || Pos+1 > Line.length())
-   {
-      // Blah, some servers use "connection:closes", evil.
-      Pos = Line.find(':');
-      if (Pos == string::npos || Pos + 2 > Line.length())
-        return _error->Error(_("Bad header line"));
-      Pos++;
-   }
-
-   // Parse off any trailing spaces between the : and the next word.
-   string::size_type Pos2 = Pos;
-   while (Pos2 < Line.length() && isspace_ascii(Line[Pos2]) != 0)
-      Pos2++;
-
-   string Tag = string(Line,0,Pos);
-   string Val = string(Line,Pos2);
-
-   if (stringcasecmp(Tag.c_str(),Tag.c_str()+4,"HTTP") == 0)
+   if (Line.size() > 4 && stringcasecmp(Line.data(), Line.data()+4, "HTTP") == 0)

    {
       // Evil servers return no version
       if (Line[4] == '/')
    {
       // Evil servers return no version
       if (Line[4] == '/')


@@ -130,7 +100,7 @@ bool ServerState::HeaderLine(string Line)
         {
            Code[0] = '\0';
            if (Owner != NULL && Owner->Debug == true)
         {
            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"));
         }
         else if (elements != 4)
            return _error->Error(_("The HTTP server sent an invalid reply header"));


@@ -164,6 +134,21 @@ bool ServerState::HeaderLine(string Line)
       return true;
    }
 
       return true;
    }
 

+   // Blah, some servers use "connection:closes", evil.
+   // and some even send empty header fields…
+   string::size_type Pos = Line.find(':');
+   if (Pos == string::npos)
+      return _error->Error(_("Bad header line"));
+   ++Pos;
+
+   // Parse off any trailing spaces between the : and the next word.
+   string::size_type Pos2 = Pos;
+   while (Pos2 < Line.length() && isspace_ascii(Line[Pos2]) != 0)
+      Pos2++;
+
+   string const Tag(Line,0,Pos);
+   string const Val(Line,Pos2);
+

    if (stringcasecmp(Tag,"Content-Length:") == 0)
    {
       if (Encoding == Closes)
    if (stringcasecmp(Tag,"Content-Length:") == 0)
    {
       if (Encoding == Closes)


@@ -171,7 +156,7 @@ bool ServerState::HeaderLine(string Line)
       HaveContent = true;
 
       unsigned long long * DownloadSizePtr = &DownloadSize;
       HaveContent = true;
 
       unsigned long long * DownloadSizePtr = &DownloadSize;

-      if (Result == 416)
+      if (Result == 416 || (Result >= 300 && Result < 400))

         DownloadSizePtr = &JunkSize;
 
       *DownloadSizePtr = strtoull(Val.c_str(), NULL, 10);
         DownloadSizePtr = &JunkSize;
 
       *DownloadSizePtr = strtoull(Val.c_str(), NULL, 10);


@@ -223,8 +208,16 @@ bool ServerState::HeaderLine(string Line)
    if (stringcasecmp(Tag,"Connection:") == 0)
    {
       if (stringcasecmp(Val,"close") == 0)
    if (stringcasecmp(Tag,"Connection:") == 0)
    {
       if (stringcasecmp(Val,"close") == 0)

+      {

         Persistent = false;
         Persistent = false;

-      if (stringcasecmp(Val,"keep-alive") == 0)
+        Pipeline = false;
+        /* Some servers send error pages (as they are dynamically generated)
+           for simplicity via a connection close instead of e.g. chunked,
+           so assuming an always closing server only if we get a file + close */
+        if (Result >= 200 && Result < 300)
+           PipelineAllowed = false;
+      }
+      else if (stringcasecmp(Val,"keep-alive") == 0)

         Persistent = true;
       return true;
    }
         Persistent = true;
       return true;
    }


@@ -242,6 +235,15 @@ bool ServerState::HeaderLine(string Line)
       return true;
    }
 
       return true;
    }
 

+   if (stringcasecmp(Tag, "Accept-Ranges:") == 0)
+   {
+      std::string ranges = ',' + Val + ',';
+      ranges.erase(std::remove(ranges.begin(), ranges.end(), ' '), ranges.end());
+      if (ranges.find(",bytes,") == std::string::npos)
+        RangesAllowed = false;
+      return true;
+   }
+

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/


@@ -258,6 +260,19 @@ bool ServerState::AddPartialFileToHashes(FileFd &File)                     /*{{{*/
    return GetHashes()->AddFD(File, StartPos);
 }
                                                                        /*}}}*/
    return GetHashes()->AddFD(File, StartPos);
 }
                                                                        /*}}}*/

+void ServerState::Reset(bool const Everything)                         /*{{{*/
+{
+   Major = 0; Minor = 0; Result = 0; Code[0] = '\0';
+   TotalFileSize = 0; JunkSize = 0; StartPos = 0;
+   Encoding = Closes; time(&Date); HaveContent = false;
+   State = Header; MaximumSize = 0;
+   if (Everything)
+   {
+      Persistent = false; Pipeline = false; PipelineAllowed = true;
+      RangesAllowed = true;
+   }
+}
+                                                                       /*}}}*/

 
 // ServerMethod::DealWithHeaders - Handle the retrieved header data    /*{{{*/
 // ---------------------------------------------------------------------
 
 // ServerMethod::DealWithHeaders - Handle the retrieved header data    /*{{{*/
 // ---------------------------------------------------------------------


@@ -273,6 +288,7 @@ ServerMethod::DealWithHeaders(FetchResult &Res)
       RemoveFile("server", Queue->DestFile);
       Res.IMSHit = true;
       Res.LastModified = Queue->LastModified;
       RemoveFile("server", Queue->DestFile);
       Res.IMSHit = true;
       Res.LastModified = Queue->LastModified;

+      Res.Size = 0;

       return IMS_HIT;
    }
 
       return IMS_HIT;
    }
 


@@ -289,7 +305,8 @@ ServerMethod::DealWithHeaders(FetchResult &Res)
            && Server->Result != 304    // Not Modified
            && Server->Result != 306))  // (Not part of HTTP/1.1, reserved)
    {
            && Server->Result != 304    // Not Modified
            && Server->Result != 306))  // (Not part of HTTP/1.1, reserved)
    {

-      if (Server->Location.empty() == true);
+      if (Server->Location.empty() == true)
+        ;

       else if (Server->Location[0] == '/' && Queue->Uri.empty() == false)
       {
         URI Uri = Queue->Uri;
       else if (Server->Location[0] == '/' && Queue->Uri.empty() == false)
       {
         URI Uri = Queue->Uri;


@@ -298,19 +315,77 @@ ServerMethod::DealWithHeaders(FetchResult &Res)
         else
            NextURI.clear();
         NextURI.append(DeQuoteString(Server->Location));
         else
            NextURI.clear();
         NextURI.append(DeQuoteString(Server->Location));

+        if (Queue->Uri == NextURI)
+        {
+           SetFailReason("RedirectionLoop");
+           _error->Error("Redirection loop encountered");
+           if (Server->HaveContent == true)
+              return ERROR_WITH_CONTENT_PAGE;
+           return ERROR_UNRECOVERABLE;
+        }

         return TRY_AGAIN_OR_REDIRECT;
       }
       else
       {
         NextURI = DeQuoteString(Server->Location);
         URI tmpURI = NextURI;
         return TRY_AGAIN_OR_REDIRECT;
       }
       else
       {
         NextURI = DeQuoteString(Server->Location);
         URI tmpURI = NextURI;

+        if (tmpURI.Access.find('+') != std::string::npos)
+        {
+           _error->Error("Server tried to trick us into using a specific implementation: %s", tmpURI.Access.c_str());
+           if (Server->HaveContent == true)
+              return ERROR_WITH_CONTENT_PAGE;
+           return ERROR_UNRECOVERABLE;
+        }

         URI Uri = Queue->Uri;
         URI Uri = Queue->Uri;

+        if (Binary.find('+') != std::string::npos)
+        {
+           auto base = Binary.substr(0, Binary.find('+'));
+           if (base != tmpURI.Access)
+           {
+              tmpURI.Access = base + '+' + tmpURI.Access;
+              if (tmpURI.Access == Binary)
+              {
+                 std::string tmpAccess = Uri.Access;
+                 std::swap(tmpURI.Access, Uri.Access);
+                 NextURI = tmpURI;
+                 std::swap(tmpURI.Access, Uri.Access);
+              }
+              else
+                 NextURI = tmpURI;
+           }
+        }
+        if (Queue->Uri == NextURI)
+        {
+           SetFailReason("RedirectionLoop");
+           _error->Error("Redirection loop encountered");
+           if (Server->HaveContent == true)
+              return ERROR_WITH_CONTENT_PAGE;
+           return ERROR_UNRECOVERABLE;
+        }
+        Uri.Access = Binary;

         // same protocol redirects are okay
         if (tmpURI.Access == Uri.Access)
            return TRY_AGAIN_OR_REDIRECT;
         // as well as http to https
         // same protocol redirects are okay
         if (tmpURI.Access == Uri.Access)
            return TRY_AGAIN_OR_REDIRECT;
         // as well as http to https

-        else if (Uri.Access == "http" && tmpURI.Access == "https")
+        else if ((Uri.Access == "http" || Uri.Access == "https+http") && tmpURI.Access == "https")

            return TRY_AGAIN_OR_REDIRECT;
            return TRY_AGAIN_OR_REDIRECT;

+        else
+        {
+           auto const tmpplus = tmpURI.Access.find('+');
+           if (tmpplus != std::string::npos && tmpURI.Access.substr(tmpplus + 1) == "https")
+           {
+              auto const uriplus = Uri.Access.find('+');
+              if (uriplus == std::string::npos)
+              {
+                 if (Uri.Access == tmpURI.Access.substr(0, tmpplus)) // foo -> foo+https
+                    return TRY_AGAIN_OR_REDIRECT;
+              }
+              else if (Uri.Access.substr(uriplus + 1) == "http" &&
+                    Uri.Access.substr(0, uriplus) == tmpURI.Access.substr(0, tmpplus)) // foo+http -> foo+https
+                 return TRY_AGAIN_OR_REDIRECT;
+           }
+        }
+        _error->Error("Redirection from %s to '%s' is forbidden", Uri.Access.c_str(), NextURI.c_str());

       }
       /* else pass through for error message */
    }
       }
       /* else pass through for error message */
    }


@@ -338,11 +413,10 @@ ServerMethod::DealWithHeaders(FetchResult &Res)
            // the file is completely downloaded, but was not moved
            if (Server->HaveContent == true)
            {
            // the file is completely downloaded, but was not moved
            if (Server->HaveContent == true)
            {

-              // Send to error page to dev/null
-              FileFd DevNull("/dev/null",FileFd::WriteExists);
-              Server->RunData(&DevNull);
+              // nuke the sent error page
+              Server->RunDataToDevNull();
+              Server->HaveContent = false;

            }
            }

-           Server->HaveContent = false;

            Server->StartPos = Server->TotalFileSize;
            Server->Result = 200;
         }
            Server->StartPos = Server->TotalFileSize;
            Server->Result = 200;
         }


@@ -358,10 +432,13 @@ ServerMethod::DealWithHeaders(FetchResult &Res)
       failure */
    if (Server->Result < 200 || Server->Result >= 300)
    {
       failure */
    if (Server->Result < 200 || Server->Result >= 300)
    {

-      std::string err;
-      strprintf(err, "HttpError%u", Server->Result);
-      SetFailReason(err);
-      _error->Error("%u %s", Server->Result, Server->Code);
+      if (_error->PendingError() == false)
+      {
+        std::string err;
+        strprintf(err, "HttpError%u", Server->Result);
+        SetFailReason(err);
+        _error->Error("%u %s", Server->Result, Server->Code);
+      }

       if (Server->HaveContent == true)
         return ERROR_WITH_CONTENT_PAGE;
       return ERROR_UNRECOVERABLE;
       if (Server->HaveContent == true)
         return ERROR_WITH_CONTENT_PAGE;
       return ERROR_UNRECOVERABLE;


@@ -370,27 +447,6 @@ ServerMethod::DealWithHeaders(FetchResult &Res)
    // This is some sort of 2xx 'data follows' reply
    Res.LastModified = Server->Date;
    Res.Size = Server->TotalFileSize;
    // This is some sort of 2xx 'data follows' reply
    Res.LastModified = Server->Date;
    Res.Size = Server->TotalFileSize;

-   
-   // Open the file
-   delete File;
-   File = new FileFd(Queue->DestFile,FileFd::WriteAny);
-   if (_error->PendingError() == true)
-      return ERROR_NOT_FROM_SERVER;
-
-   FailFile = Queue->DestFile;
-   FailFile.c_str();   // Make sure we don't do a malloc in the signal handler
-   FailFd = File->Fd();
-   FailTime = Server->Date;
-
-   if (Server->InitHashes(Queue->ExpectedHashes) == false || Server->AddPartialFileToHashes(*File) == false)
-   {
-      _error->Errno("read",_("Problem hashing file"));
-      return ERROR_NOT_FROM_SERVER;
-   }
-   if (Server->StartPos > 0)
-      Res.ResumePoint = Server->StartPos;
-
-   SetNonBlock(File->Fd(),true);

    return FILE_IS_OPEN;
 }
                                                                        /*}}}*/
    return FILE_IS_OPEN;
 }
                                                                        /*}}}*/


@@ -428,6 +484,8 @@ bool ServerMethod::Fetch(FetchItem *)
    decltype(PipelineDepth) CurrentDepth = 0;
    for (FetchItem const *I = Queue; I != QueueBack; I = I->Next)
       ++CurrentDepth;
    decltype(PipelineDepth) CurrentDepth = 0;
    for (FetchItem const *I = Queue; I != QueueBack; I = I->Next)
       ++CurrentDepth;

+   if (CurrentDepth > AllowedDepth)
+      return true;

 
    do {
       // Make sure we stick with the same server
 
    do {
       // Make sure we stick with the same server


@@ -485,10 +543,6 @@ bool ServerMethod::Fetch(FetchItem *)
 // ServerMethod::Loop - Main loop                                      /*{{{*/
 int ServerMethod::Loop()
 {
 // ServerMethod::Loop - Main loop                                      /*{{{*/
 int ServerMethod::Loop()
 {

-   typedef vector<string> StringVector;
-   typedef vector<string>::iterator StringVectorIterator;
-   map<string, StringVector> Redirected;
-

    signal(SIGTERM,SigTerm);
    signal(SIGINT,SigTerm);
    
    signal(SIGTERM,SigTerm);
    signal(SIGINT,SigTerm);
    


@@ -510,7 +564,7 @@ int ServerMethod::Loop()
       if (Result != -1 && (Result != 0 || Queue == 0))
       {
         if(FailReason.empty() == false ||
       if (Result != -1 && (Result != 0 || Queue == 0))
       {
         if(FailReason.empty() == false ||

-           _config->FindB("Acquire::http::DependOnSTDIN", true) == true)
+           ConfigFindB("DependOnSTDIN", true) == true)

            return 100;
         else
            return 0;
            return 100;
         else
            return 0;


@@ -521,7 +575,13 @@ int ServerMethod::Loop()
       
       // Connect to the server
       if (Server == 0 || Server->Comp(Queue->Uri) == false)
       
       // Connect to the server
       if (Server == 0 || Server->Comp(Queue->Uri) == false)

+      {

         Server = CreateServerState(Queue->Uri);
         Server = CreateServerState(Queue->Uri);

+        setPostfixForMethodNames(::URI(Queue->Uri).Host.c_str());
+        AllowRedirect = ConfigFindB("AllowRedirect", true);
+        PipelineDepth = ConfigFindI("Pipeline-Depth", 10);
+        Debug = DebugEnabled();
+      }

 
       /* If the server has explicitly said this is the last connection
          then we pre-emptively shut down the pipeline and tear down 
 
       /* If the server has explicitly said this is the last connection
          then we pre-emptively shut down the pipeline and tear down 


@@ -557,6 +617,7 @@ int ServerMethod::Loop()
         {
            _error->Error(_("Bad header data"));
            Fail(true);
         {
            _error->Error(_("Bad header data"));
            Fail(true);

+           Server->Close();

            RotateDNS();
            continue;
         }
            RotateDNS();
            continue;
         }


@@ -637,10 +698,7 @@ int ServerMethod::Loop()
                        // yes, he did! Disable pipelining and rewrite queue
                        if (Server->Pipeline == true)
                        {
                        // yes, he did! Disable pipelining and rewrite queue
                        if (Server->Pipeline == true)
                        {

-                          // FIXME: fake a warning message as we have no proper way of communicating here
-                          std::string out;
-                          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;
+                          Warning(_("Automatically disabled %s due to incorrect response from server/proxy. (man 5 apt.conf)"), "Acquire::http::Pipeline-Depth");

                           Server->Pipeline = false;
                           Server->PipelineAllowed = false;
                           // we keep the PipelineDepth value so that the rest of the queue can be fixed up as well
                           Server->Pipeline = false;
                           Server->PipelineAllowed = false;
                           // we keep the PipelineDepth value so that the rest of the queue can be fixed up as well


@@ -713,54 +771,19 @@ int ServerMethod::Loop()
         case ERROR_WITH_CONTENT_PAGE:
         {
            Fail();
         case ERROR_WITH_CONTENT_PAGE:
         {
            Fail();

-           
-           // Send to content to dev/null
-           File = new FileFd("/dev/null",FileFd::WriteExists);
-           Server->RunData(File);
-           delete File;
-           File = 0;
+           Server->RunDataToDevNull();
+           break;
+        }
+
+        // Try again with a new URL
+        case TRY_AGAIN_OR_REDIRECT:
+        {
+           // Clear rest of response if there is content
+           if (Server->HaveContent)
+              Server->RunDataToDevNull();
+           Redirect(NextURI);

            break;
         }
            break;
         }

-        
-         // Try again with a new URL
-         case TRY_AGAIN_OR_REDIRECT:
-         {
-            // Clear rest of response if there is content
-            if (Server->HaveContent)
-            {
-               File = new FileFd("/dev/null",FileFd::WriteExists);
-               Server->RunData(File);
-               delete File;
-               File = 0;
-            }
-
-            /* Detect redirect loops.  No more redirects are allowed
-               after the same URI is seen twice in a queue item. */
-            StringVector &R = Redirected[Queue->DestFile];
-            bool StopRedirects = false;
-            if (R.empty() == true)
-               R.push_back(Queue->Uri);
-            else if (R[0] == "STOP" || R.size() > 10)
-               StopRedirects = true;
-            else
-            {
-               for (StringVectorIterator I = R.begin(); I != R.end(); ++I)
-                  if (Queue->Uri == *I)
-                  {
-                     R[0] = "STOP";
-                     break;
-                  }
- 
-               R.push_back(Queue->Uri);
-            }
- 
-            if (StopRedirects == false)
-               Redirect(NextURI);
-            else
-               Fail();
- 
-            break;
-         }

 
         default:
         Fail(_("Internal error"));
 
         default:
         Fail(_("Internal error"));


@@ -781,9 +804,35 @@ unsigned long long ServerMethod::FindMaximumObjectSizeInQueue() const      /*{{{*/
    return MaxSizeInQueue;
 }
                                                                        /*}}}*/
    return MaxSizeInQueue;
 }
                                                                        /*}}}*/

-ServerMethod::ServerMethod(char const * const Binary, char const * const Ver,unsigned long const Flags) :/*{{{*/
-   aptMethod(Binary, Ver, Flags), Server(nullptr), File(NULL), PipelineDepth(10),
+ServerMethod::ServerMethod(std::string &&Binary, char const * const Ver,unsigned long const Flags) :/*{{{*/
+   aptMethod(std::move(Binary), Ver, Flags), Server(nullptr), File(NULL), PipelineDepth(10),

    AllowRedirect(false), Debug(false)
 {
 }
                                                                        /*}}}*/
    AllowRedirect(false), Debug(false)
 {
 }
                                                                        /*}}}*/

+bool ServerMethod::Configuration(std::string Message)                  /*{{{*/
+{
+   if (aptMethod::Configuration(Message) == false)
+      return false;
+
+   _config->CndSet("Acquire::tor::Proxy",
+        "socks5h://apt-transport-tor@localhost:9050");
+   return true;
+}
+                                                                       /*}}}*/
+bool ServerMethod::AddProxyAuth(URI &Proxy, URI const &Server) const   /*{{{*/
+{
+   if (std::find(methodNames.begin(), methodNames.end(), "tor") != methodNames.end() &&
+        Proxy.User == "apt-transport-tor" && Proxy.Password.empty())
+   {
+      std::string pass = Server.Host;
+      pass.erase(std::remove_if(pass.begin(), pass.end(), [](char const c) { return std::isalnum(c) == 0; }), pass.end());
+      if (pass.length() > 255)
+        Proxy.Password = pass.substr(0, 255);
+      else
+        Proxy.Password = std::move(pass);
+   }
+   // FIXME: should we support auth.conf for proxies?
+   return true;
+}
+                                                                       /*}}}*/