Italian program translation update

[apt.git] / methods / server.cc

diff --git a/methods/server.cc b/methods/server.cc
index e12c23c0759b98156c92b2d01b16c11bf150caef..e403f10713c6c1c0acc69409237d48a36fa653cf 100644 (file)
--- a/methods/server.cc
+++ b/methods/server.cc
@@ -10,32 +10,27 @@
 // Include Files                                                       /*{{{*/
 #include <config.h>
 
 // Include Files                                                       /*{{{*/
 #include <config.h>
 

-#include <apt-pkg/fileutl.h>

 #include <apt-pkg/acquire-method.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/acquire-method.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/error.h>

-#include <apt-pkg/hashes.h>
-#include <apt-pkg/netrc.h>
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/strutl.h>

 
 

-#include <fcntl.h>
+#include <ctype.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>

 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/stat.h>
 #include <sys/time.h>

+#include <time.h>

 #include <unistd.h>
 #include <unistd.h>

-#include <signal.h>
-#include <stdio.h>
-#include <errno.h>
-#include <string.h>
-#include <climits>

 #include <iostream>
 #include <iostream>

+#include <limits>

 #include <map>
 #include <map>

+#include <string>
+#include <vector>

 
 

-// Internet stuff
-#include <netdb.h>
-
-#include "config.h"
-#include "connect.h"
-#include "rfc2553emu.h"
-#include "http.h"
+#include "server.h"

 
 #include <apti18n.h>
                                                                        /*}}}*/
 
 #include <apti18n.h>
                                                                        /*}}}*/


@@ -49,7 +44,8 @@ time_t ServerMethod::FailTime = 0;
 // ---------------------------------------------------------------------
 /* Returns 0 if things are OK, 1 if an IO error occurred and 2 if a header
    parse error occurred */
 // ---------------------------------------------------------------------
 /* Returns 0 if things are OK, 1 if an IO error occurred and 2 if a header
    parse error occurred */

-ServerState::RunHeadersResult ServerState::RunHeaders(FileFd * const File)
+ServerState::RunHeadersResult ServerState::RunHeaders(FileFd * const File,
+                                                      const std::string &Uri)

 {
    State = Header;
    
 {
    State = Header;
    


@@ -59,6 +55,7 @@ ServerState::RunHeadersResult ServerState::RunHeaders(FileFd * const File)
    Minor = 0; 
    Result = 0; 
    Size = 0; 
    Minor = 0; 
    Result = 0; 
    Size = 0; 

+   JunkSize = 0;

    StartPos = 0;
    Encoding = Closes;
    HaveContent = false;
    StartPos = 0;
    Encoding = Closes;
    HaveContent = false;


@@ -71,7 +68,7 @@ ServerState::RunHeadersResult ServerState::RunHeaders(FileFd * const File)
         continue;
 
       if (Owner->Debug == true)
         continue;
 
       if (Owner->Debug == true)

-        clog << Data;
+        clog << "Answer for: " << Uri << endl << Data;

       
       for (string::const_iterator I = Data.begin(); I < Data.end(); ++I)
       {
       
       for (string::const_iterator I = Data.begin(); I < Data.end(); ++I)
       {


@@ -86,7 +83,7 @@ ServerState::RunHeadersResult ServerState::RunHeaders(FileFd * const File)
       if (Result == 100)
         continue;
       
       if (Result == 100)
         continue;
       

-      // Tidy up the connection persistance state.
+      // Tidy up the connection persistence state.

       if (Encoding == Closes && HaveContent == true)
         Persistent = false;
       
       if (Encoding == Closes && HaveContent == true)
         Persistent = false;
       


@@ -119,10 +116,10 @@ bool ServerState::HeaderLine(string Line)
    string::size_type Pos2 = Pos;
    while (Pos2 < Line.length() && isspace(Line[Pos2]) != 0)
       Pos2++;
    string::size_type Pos2 = Pos;
    while (Pos2 < Line.length() && isspace(Line[Pos2]) != 0)
       Pos2++;

-      
+

    string Tag = string(Line,0,Pos);
    string Val = string(Line,Pos2);
    string Tag = string(Line,0,Pos);
    string Val = string(Line,Pos2);

-   
+

    if (stringcasecmp(Tag.c_str(),Tag.c_str()+4,"HTTP") == 0)
    {
       // Evil servers return no version
    if (stringcasecmp(Tag.c_str(),Tag.c_str()+4,"HTTP") == 0)
    {
       // Evil servers return no version


@@ -132,7 +129,7 @@ bool ServerState::HeaderLine(string Line)
         if (elements == 3)
         {
            Code[0] = '\0';
         if (elements == 3)
         {
            Code[0] = '\0';

-           if (Owner->Debug == true)
+           if (Owner != NULL && Owner->Debug == true)

               clog << "HTTP server doesn't give Reason-Phrase for " << Result << std::endl;
         }
         else if (elements != 4)
               clog << "HTTP server doesn't give Reason-Phrase for " << Result << std::endl;
         }
         else if (elements != 4)


@@ -146,7 +143,7 @@ bool ServerState::HeaderLine(string Line)
            return _error->Error(_("The HTTP server sent an invalid reply header"));
       }
 
            return _error->Error(_("The HTTP server sent an invalid reply header"));
       }
 

-      /* Check the HTTP response header to get the default persistance
+      /* Check the HTTP response header to get the default persistence

          state. */
       if (Major < 1)
         Persistent = false;
          state. */
       if (Major < 1)
         Persistent = false;


@@ -159,22 +156,22 @@ bool ServerState::HeaderLine(string Line)
       }
 
       return true;
       }
 
       return true;

-   }      
-      
+   }
+

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

-      
-      // The length is already set from the Content-Range header
-      if (StartPos != 0)
-        return true;

 
 

-      Size = strtoull(Val.c_str(), NULL, 10);
-      if (Size >= std::numeric_limits<unsigned long long>::max())
+      unsigned long long * SizePtr = &Size;
+      if (Result == 416)
+        SizePtr = &JunkSize;
+
+      *SizePtr = strtoull(Val.c_str(), NULL, 10);
+      if (*SizePtr >= std::numeric_limits<unsigned long long>::max())

         return _error->Errno("HeaderLine", _("The HTTP server sent an invalid Content-Length header"));
         return _error->Errno("HeaderLine", _("The HTTP server sent an invalid Content-Length header"));

-      else if (Size == 0)
+      else if (*SizePtr == 0)

         HaveContent = false;
       return true;
    }
         HaveContent = false;
       return true;
    }


@@ -184,29 +181,26 @@ bool ServerState::HeaderLine(string Line)
       HaveContent = true;
       return true;
    }
       HaveContent = true;
       return true;
    }

-   
+

    if (stringcasecmp(Tag,"Content-Range:") == 0)
    {
       HaveContent = true;
 
       // §14.16 says 'byte-range-resp-spec' should be a '*' in case of 416
       if (Result == 416 && sscanf(Val.c_str(), "bytes */%llu",&Size) == 1)
    if (stringcasecmp(Tag,"Content-Range:") == 0)
    {
       HaveContent = true;
 
       // §14.16 says 'byte-range-resp-spec' should be a '*' in case of 416
       if (Result == 416 && sscanf(Val.c_str(), "bytes */%llu",&Size) == 1)

-      {
-        StartPos = 1; // ignore Content-Length, it would override Size
-        HaveContent = false;
-      }
+        ; // we got the expected filesize which is all we wanted

       else if (sscanf(Val.c_str(),"bytes %llu-%*u/%llu",&StartPos,&Size) != 2)
         return _error->Error(_("The HTTP server sent an invalid Content-Range header"));
       if ((unsigned long long)StartPos > Size)
         return _error->Error(_("This HTTP server has broken range support"));
       return true;
    }
       else if (sscanf(Val.c_str(),"bytes %llu-%*u/%llu",&StartPos,&Size) != 2)
         return _error->Error(_("The HTTP server sent an invalid Content-Range header"));
       if ((unsigned long long)StartPos > Size)
         return _error->Error(_("This HTTP server has broken range support"));
       return true;
    }

-   
+

    if (stringcasecmp(Tag,"Transfer-Encoding:") == 0)
    {
       HaveContent = true;
       if (stringcasecmp(Val,"chunked") == 0)
    if (stringcasecmp(Tag,"Transfer-Encoding:") == 0)
    {
       HaveContent = true;
       if (stringcasecmp(Val,"chunked") == 0)

-        Encoding = Chunked;      
+        Encoding = Chunked;

       return true;
    }
 
       return true;
    }
 


@@ -218,7 +212,7 @@ bool ServerState::HeaderLine(string Line)
         Persistent = true;
       return true;
    }
         Persistent = true;
       return true;
    }

-   
+

    if (stringcasecmp(Tag,"Last-Modified:") == 0)
    {
       if (RFC1123StrToTime(Val.c_str(), Date) == false)
    if (stringcasecmp(Tag,"Last-Modified:") == 0)
    {
       if (RFC1123StrToTime(Val.c_str(), Date) == false)


@@ -244,7 +238,12 @@ ServerState::ServerState(URI Srv, ServerMethod *Owner) : ServerName(Srv), TimeOu
 
 bool ServerMethod::Configuration(string Message)                       /*{{{*/
 {
 
 bool ServerMethod::Configuration(string Message)                       /*{{{*/
 {

-   return pkgAcqMethod::Configuration(Message);
+   if (pkgAcqMethod::Configuration(Message) == false)
+      return false;
+
+   DropPrivsOrDie();
+
+   return true;

 }
                                                                        /*}}}*/
 
 }
                                                                        /*}}}*/
 


@@ -291,11 +290,15 @@ ServerMethod::DealWithHeaders(FetchResult &Res)
       }
       else
       {
       }
       else
       {

-         NextURI = DeQuoteString(Server->Location);
-         URI tmpURI = NextURI;
-         // Do not allow a redirection to switch protocol
-         if (tmpURI.Access == "http")
-            return TRY_AGAIN_OR_REDIRECT;
+        NextURI = DeQuoteString(Server->Location);
+        URI tmpURI = NextURI;
+        URI Uri = Queue->Uri;
+        // 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")
+           return TRY_AGAIN_OR_REDIRECT;

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


@@ -308,9 +311,15 @@ ServerMethod::DealWithHeaders(FetchResult &Res)
         if ((unsigned long long)SBuf.st_size == Server->Size)
         {
            // the file is completely downloaded, but was not moved
         if ((unsigned long long)SBuf.st_size == Server->Size)
         {
            // 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);
+           }
+           Server->HaveContent = false;

            Server->StartPos = Server->Size;
            Server->Result = 200;
            Server->StartPos = Server->Size;
            Server->Result = 200;

-           Server->HaveContent = false;

         }
         else if (unlink(Queue->DestFile.c_str()) == 0)
         {
         }
         else if (unlink(Queue->DestFile.c_str()) == 0)
         {


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

-      char err[255];
-      snprintf(err,sizeof(err)-1,"HttpError%i",Server->Result);
+      std::string err;
+      strprintf(err, "HttpError%u", Server->Result);

       SetFailReason(err);
       SetFailReason(err);

-      _error->Error("%u %s",Server->Result,Server->Code);
+      _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;


@@ -348,7 +357,7 @@ ServerMethod::DealWithHeaders(FetchResult &Res)
    FailFd = File->Fd();
    FailTime = Server->Date;
 
    FailFd = File->Fd();
    FailTime = Server->Date;
 

-   if (Server->InitHashes(*File) == false)
+   if (Server->InitHashes(*File, Queue->ExpectedHashes) == false)

    {
       _error->Errno("read",_("Problem hashing file"));
       return ERROR_NOT_FROM_SERVER;
    {
       _error->Errno("read",_("Problem hashing file"));
       return ERROR_NOT_FROM_SERVER;


@@ -362,18 +371,18 @@ ServerMethod::DealWithHeaders(FetchResult &Res)
                                                                        /*}}}*/
 // ServerMethod::SigTerm - Handle a fatal signal                       /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // ServerMethod::SigTerm - Handle a fatal signal                       /*{{{*/
 // ---------------------------------------------------------------------

-/* This closes and timestamps the open file. This is neccessary to get
+/* This closes and timestamps the open file. This is necessary to get

    resume behavoir on user abort */
 void ServerMethod::SigTerm(int)
 {
    if (FailFd == -1)
       _exit(100);
 
    resume behavoir on user abort */
 void ServerMethod::SigTerm(int)
 {
    if (FailFd == -1)
       _exit(100);
 

-   struct timespec times[2];
+   struct timeval times[2];

    times[0].tv_sec = FailTime;
    times[1].tv_sec = FailTime;
    times[0].tv_sec = FailTime;
    times[1].tv_sec = FailTime;

-   times[0].tv_nsec = times[1].tv_nsec = 0;
-   futimens(FailFd, times);
+   times[0].tv_usec = times[1].tv_usec = 0;
+   utimes(FailFile.c_str(), times);

    close(FailFd);
 
    _exit(100);
    close(FailFd);
 
    _exit(100);


@@ -393,9 +402,16 @@ bool ServerMethod::Fetch(FetchItem *)
    for (FetchItem *I = Queue; I != 0 && Depth < (signed)PipelineDepth; 
        I = I->Next, Depth++)
    {
    for (FetchItem *I = Queue; I != 0 && Depth < (signed)PipelineDepth; 
        I = I->Next, Depth++)
    {

-      // If pipelining is disabled, we only queue 1 request
-      if (Server->Pipeline == false && Depth >= 0)
-        break;
+      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;
+      }

       
       // Make sure we stick with the same server
       if (Server->Comp(I->Uri) == false)
       
       // Make sure we stick with the same server
       if (Server->Comp(I->Uri) == false)


@@ -409,7 +425,7 @@ bool ServerMethod::Fetch(FetchItem *)
    }
    
    return true;
    }
    
    return true;

-};
+}

                                                                        /*}}}*/
 // ServerMethod::Loop - Main loop                                      /*{{{*/
 int ServerMethod::Loop()
                                                                        /*}}}*/
 // ServerMethod::Loop - Main loop                                      /*{{{*/
 int ServerMethod::Loop()


@@ -479,7 +495,7 @@ int ServerMethod::Loop()
       Fetch(0);
       
       // Fetch the next URL header data from the server.
       Fetch(0);
       
       // Fetch the next URL header data from the server.

-      switch (Server->RunHeaders(File))
+      switch (Server->RunHeaders(File, Queue->Uri))

       {
         case ServerState::RUN_HEADERS_OK:
         break;
       {
         case ServerState::RUN_HEADERS_OK:
         break;


@@ -525,6 +541,13 @@ int ServerMethod::Loop()
 
            // Run the data
            bool Result = true;
 
            // Run the data
            bool Result = true;

+
+            // ensure we don't fetch too much
+            // we could do "Server->MaximumSize = Queue->MaximumSize" here
+            // but that would break the clever pipeline messup detection
+            // so instead we use the size of the biggest item in the queue
+            Server->MaximumSize = FindMaximumObjectSizeInQueue();
+

             if (Server->HaveContent)
               Result = Server->RunData(File);
 
             if (Server->HaveContent)
               Result = Server->RunData(File);
 


@@ -539,15 +562,46 @@ int ServerMethod::Loop()
            File = 0;
            
            // Timestamp
            File = 0;
            
            // Timestamp

-           struct timespec times[2];
+           struct timeval times[2];

            times[0].tv_sec = times[1].tv_sec = Server->Date;
            times[0].tv_sec = times[1].tv_sec = Server->Date;

-           times[0].tv_nsec = times[1].tv_nsec = 0;
-           utimensat(AT_FDCWD, Queue->DestFile.c_str(), times, AT_SYMLINK_NOFOLLOW);
+           times[0].tv_usec = times[1].tv_usec = 0;
+           utimes(Queue->DestFile.c_str(), times);

 
            // Send status to APT
            if (Result == true)
            {
 
            // Send status to APT
            if (Result == true)
            {

-              Res.TakeHashes(*Server->GetHashes());
+              Hashes * const resultHashes = Server->GetHashes();
+              HashStringList const hashList = resultHashes->GetHashStringList();
+              if (PipelineDepth != 0 && Queue->ExpectedHashes.usable() == true && Queue->ExpectedHashes != hashList)
+              {
+                 // we did not get the expected hash… mhhh:
+                 // could it be that server/proxy messed up pipelining?
+                 FetchItem * BeforeI = Queue;
+                 for (FetchItem *I = Queue->Next; I != 0 && I != QueueBack; I = I->Next)
+                 {
+                    if (I->ExpectedHashes.usable() == true && I->ExpectedHashes == hashList)
+                    {
+                       // 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;
+                          Server->Pipeline = false;
+                          // we keep the PipelineDepth value so that the rest of the queue can be fixed up as well
+                       }
+                       Rename(Res.Filename, I->DestFile);
+                       Res.Filename = I->DestFile;
+                       BeforeI->Next = I->Next;
+                       I->Next = Queue;
+                       Queue = I;
+                       break;
+                    }
+                    BeforeI = I;
+                 }
+              }
+              Res.TakeHashes(*resultHashes);

               URIDone(Res);
            }
            else
               URIDone(Res);
            }
            else


@@ -567,7 +621,10 @@ int ServerMethod::Loop()
                  QueueBack = Queue;
               }
               else
                  QueueBack = Queue;
               }
               else

+               {
+                  Server->Close();

                  Fail(true);
                  Fail(true);

+               }

            }
            break;
         }
            }
            break;
         }


@@ -660,5 +717,15 @@ int ServerMethod::Loop()
    }
    
    return 0;
    }
    
    return 0;

+}
+                                                                       /*}}}*/
+                                                                       /*{{{*/
+unsigned long long
+ServerMethod::FindMaximumObjectSizeInQueue() const 
+{
+   unsigned long long MaxSizeInQueue = 0;
+   for (FetchItem *I = Queue; I != 0 && I != QueueBack; I = I->Next)
+      MaxSizeInQueue = std::max(MaxSizeInQueue, I->MaximumSize);
+   return MaxSizeInQueue;

 }
                                                                        /*}}}*/
 }
                                                                        /*}}}*/