really do not download Release if InRelease does not verify

[apt.git] / apt-pkg / acquire-item.cc

diff --git a/apt-pkg/acquire-item.cc b/apt-pkg/acquire-item.cc
index d36c47a49c2d84b65caf9a74efc3841a6c6df6b4..3c66369cf8bcbbbecd5176360ef79645ef9f380e 100644 (file)
--- a/apt-pkg/acquire-item.cc
+++ b/apt-pkg/acquire-item.cc
@@ -64,6 +64,10 @@ static void printHashSumComparision(std::string const &URI, HashStringList const
                                                                        /*}}}*/
 
 // Acquire::Item::Item - Constructor                                   /*{{{*/
                                                                        /*}}}*/
 
 // Acquire::Item::Item - Constructor                                   /*{{{*/

+#if __GNUC__ >= 4
+       #pragma GCC diagnostic push
+       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif

 pkgAcquire::Item::Item(pkgAcquire *Owner,
                        HashStringList const &ExpectedHashes,
                        pkgAcqMetaBase *TransactionManager)
 pkgAcquire::Item::Item(pkgAcquire *Owner,
                        HashStringList const &ExpectedHashes,
                        pkgAcqMetaBase *TransactionManager)


@@ -76,6 +80,9 @@ pkgAcquire::Item::Item(pkgAcquire *Owner,
    if(TransactionManager != NULL)
       TransactionManager->Add(this);
 }
    if(TransactionManager != NULL)
       TransactionManager->Add(this);
 }

+#if __GNUC__ >= 4
+       #pragma GCC diagnostic pop
+#endif

                                                                        /*}}}*/
 // Acquire::Item::~Item - Destructor                                   /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // Acquire::Item::~Item - Destructor                                   /*{{{*/
 // ---------------------------------------------------------------------


@@ -157,7 +164,7 @@ void pkgAcquire::Item::Done(string Message,unsigned long long Size,HashStringLis
 // ---------------------------------------------------------------------
 /* This helper function is used by a lot of item methods as their final
    step */
 // ---------------------------------------------------------------------
 /* This helper function is used by a lot of item methods as their final
    step */

-void pkgAcquire::Item::Rename(string From,string To)
+bool pkgAcquire::Item::Rename(string From,string To)

 {
    if (rename(From.c_str(),To.c_str()) != 0)
    {
 {
    if (rename(From.c_str(),To.c_str()) != 0)
    {


@@ -165,8 +172,10 @@ void pkgAcquire::Item::Rename(string From,string To)
       snprintf(S,sizeof(S),_("rename failed, %s (%s -> %s)."),strerror(errno),
              From.c_str(),To.c_str());
       Status = StatError;
       snprintf(S,sizeof(S),_("rename failed, %s (%s -> %s)."),strerror(errno),
              From.c_str(),To.c_str());
       Status = StatError;

-      ErrorText = S;
+      ErrorText += S;
+      return false;

    }   
    }   

+   return true;

 }
                                                                        /*}}}*/
 bool pkgAcquire::Item::RenameOnError(pkgAcquire::Item::RenameOnErrorState const error)/*{{{*/
 }
                                                                        /*}}}*/
 bool pkgAcquire::Item::RenameOnError(pkgAcquire::Item::RenameOnErrorState const error)/*{{{*/


@@ -191,6 +200,14 @@ bool pkgAcquire::Item::RenameOnError(pkgAcquire::Item::RenameOnErrorState const
         Status = StatError;
         // do not report as usually its not the mirrors fault, but Portal/Proxy
         break;
         Status = StatError;
         // do not report as usually its not the mirrors fault, but Portal/Proxy
         break;

+      case SignatureError:
+        ErrorText = _("Signature error");
+        Status = StatError;
+        break;
+      case NotClearsigned:
+         ErrorText = _("Does not start with a cleartext signature");
+        Status = StatError;
+        break;

    }
    return false;
 }
    }
    return false;
 }


@@ -252,7 +269,7 @@ pkgAcqDiffIndex::pkgAcqDiffIndex(pkgAcquire *Owner,
                                 HashStringList const &ExpectedHashes,
                                  indexRecords *MetaIndexParser)
    : pkgAcqBaseIndex(Owner, TransactionManager, Target, ExpectedHashes, 
                                 HashStringList const &ExpectedHashes,
                                  indexRecords *MetaIndexParser)
    : pkgAcqBaseIndex(Owner, TransactionManager, Target, ExpectedHashes, 

-                     MetaIndexParser)
+                     MetaIndexParser), PackagesFileReadyInPartial(false)

 {
    
    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 {
    
    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);


@@ -348,6 +365,10 @@ bool pkgAcqDiffIndex::ParseDiffIndex(string IndexDiffFile)         /*{{{*/
         // we have the same sha1 as the server so we are done here
         if(Debug)
            std::clog << "Package file is up-to-date" << std::endl;
         // we have the same sha1 as the server so we are done here
         if(Debug)
            std::clog << "Package file is up-to-date" << std::endl;

+         // ensure we have no leftovers from previous runs
+         std::string Partial = _config->FindDir("Dir::State::lists");
+         Partial += "partial/" + URItoFileName(RealURI);
+         unlink(Partial.c_str());

         // list cleanup needs to know that this file as well as the already
         // present index is ours, so we create an empty diff to save it for us
         new pkgAcqIndexDiffs(Owner, TransactionManager, Target, 
         // list cleanup needs to know that this file as well as the already
         // present index is ours, so we create an empty diff to save it for us
         new pkgAcqIndexDiffs(Owner, TransactionManager, Target, 


@@ -418,6 +439,21 @@ bool pkgAcqDiffIndex::ParseDiffIndex(string IndexDiffFile)         /*{{{*/
       // we have something, queue the next diff
       if(found)
       {
       // we have something, queue the next diff
       if(found)
       {

+         // FIXME: make this use the method
+         PackagesFileReadyInPartial = true;
+         std::string Partial = _config->FindDir("Dir::State::lists");
+         Partial += "partial/" + URItoFileName(RealURI);
+
+         FileFd From(CurrentPackagesFile, FileFd::ReadOnly);
+         FileFd To(Partial, FileFd::WriteEmpty);
+         if(CopyFile(From, To) == false)
+            return _error->Errno("CopyFile", "failed to copy");
+
+         if(Debug)
+            std::cerr << "Done copying " << CurrentPackagesFile
+                      << " -> " << Partial
+                      << std::endl;
+

         // queue the diffs
         string::size_type const last_space = Description.rfind(" ");
         if(last_space != string::npos)
         // queue the diffs
         string::size_type const last_space = Description.rfind(" ");
         if(last_space != string::npos)


@@ -455,10 +491,10 @@ bool pkgAcqDiffIndex::ParseDiffIndex(string IndexDiffFile)                /*{{{*/
                                                        diffs);
         }
 
                                                        diffs);
         }
 

-        Complete = false;
-        Status = StatDone;
-        Dequeue();
-        return true;
+         Complete = false;
+         Status = StatDone;
+         Dequeue();
+         return true;

       }
    }
    
       }
    }
    


@@ -491,6 +527,21 @@ void pkgAcqDiffIndex::Done(string Message,unsigned long long Size,HashStringList
 
    Item::Done(Message, Size, Hashes, Cnf);
 
 
    Item::Done(Message, Size, Hashes, Cnf);
 

+   // verify the index target
+   if(Target && Target->MetaKey != "" && MetaIndexParser && Hashes.usable())
+   {
+      std::string IndexMetaKey  = Target->MetaKey + ".diff/Index";
+      indexRecords::checkSum *Record = MetaIndexParser->Lookup(IndexMetaKey);
+      if(Record && Record->Hashes.usable() && Hashes != Record->Hashes)
+      {
+         RenameOnError(HashSumMismatch);
+         printHashSumComparision(RealURI, Record->Hashes, Hashes);
+         Failed(Message, Cnf);
+         return;
+      }
+
+   }
+

    string FinalFile;
    FinalFile = _config->FindDir("Dir::State::lists")+URItoFileName(RealURI);
 
    string FinalFile;
    FinalFile = _config->FindDir("Dir::State::lists")+URItoFileName(RealURI);
 


@@ -541,7 +592,9 @@ pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire *Owner,
 
    if(available_patches.empty() == true)
    {
 
    if(available_patches.empty() == true)
    {

-      // we are done (yeah!)
+      // we are done (yeah!), check hashes against the final file
+      DestFile = _config->FindDir("Dir::State::lists");
+      DestFile += URItoFileName(Target->URI);

       Finish(true);
    }
    else
       Finish(true);
    }
    else


@@ -573,13 +626,6 @@ void pkgAcqIndexDiffs::Finish(bool allDone)
    // the file will be cleaned
    if(allDone) 
    {
    // the file will be cleaned
    if(allDone) 
    {

-      DestFile = _config->FindDir("Dir::State::lists");
-      DestFile += URItoFileName(RealURI);
-      
-      // FIXME: we want the rred stuff to use the real transactional update
-      //        this is just a workaround
-      PartialFile = DestFile;
-

       if(HashSums().usable() && !HashSums().VerifyFile(DestFile))
       {
         RenameOnError(HashSumMismatch);
       if(HashSums().usable() && !HashSums().VerifyFile(DestFile))
       {
         RenameOnError(HashSumMismatch);


@@ -587,6 +633,18 @@ void pkgAcqIndexDiffs::Finish(bool allDone)
         return;
       }
 
         return;
       }
 

+      // queue for copy
+      PartialFile = _config->FindDir("Dir::State::lists")+"partial/"+URItoFileName(RealURI);
+
+      DestFile = _config->FindDir("Dir::State::lists");
+      DestFile += URItoFileName(RealURI);
+
+      // this happens if we have a up-to-date indexfile
+      if(!FileExists(PartialFile))
+         PartialFile = DestFile;
+
+      TransactionManager->TransactionStageCopy(this, PartialFile, DestFile);
+

       // this is for the "real" finish
       Complete = true;
       Status = StatDone;
       // this is for the "real" finish
       Complete = true;
       Status = StatDone;


@@ -606,10 +664,15 @@ void pkgAcqIndexDiffs::Finish(bool allDone)
                                                                        /*}}}*/
 bool pkgAcqIndexDiffs::QueueNextDiff()                                 /*{{{*/
 {
                                                                        /*}}}*/
 bool pkgAcqIndexDiffs::QueueNextDiff()                                 /*{{{*/
 {

-

    // calc sha1 of the just patched file
    string FinalFile = _config->FindDir("Dir::State::lists");
    // calc sha1 of the just patched file
    string FinalFile = _config->FindDir("Dir::State::lists");

-   FinalFile += URItoFileName(RealURI);
+   FinalFile += "partial/" + URItoFileName(RealURI);
+
+   if(!FileExists(FinalFile))
+   {
+      Failed("No FinalFile " + FinalFile + " available", NULL);
+      return false;
+   }

 
    FileFd fd(FinalFile, FileFd::ReadOnly);
    SHA1Summation SHA1;
 
    FileFd fd(FinalFile, FileFd::ReadOnly);
    SHA1Summation SHA1;


@@ -619,6 +682,7 @@ bool pkgAcqIndexDiffs::QueueNextDiff()                                      /*{{{*/
       std::clog << "QueueNextDiff: " 
                << FinalFile << " (" << local_sha1 << ")"<<std::endl;
 
       std::clog << "QueueNextDiff: " 
                << FinalFile << " (" << local_sha1 << ")"<<std::endl;
 

+

    // final file reached before all patches are applied
    if(local_sha1 == ServerSha1)
    {
    // final file reached before all patches are applied
    if(local_sha1 == ServerSha1)
    {


@@ -640,7 +704,7 @@ bool pkgAcqIndexDiffs::QueueNextDiff()                                      /*{{{*/
    // error checking and falling back if no patch was found
    if(available_patches.empty() == true)
    {
    // error checking and falling back if no patch was found
    if(available_patches.empty() == true)
    {

-      Failed("", NULL);
+      Failed("No patches available", NULL);

       return false;
    }
 
       return false;
    }
 


@@ -666,8 +730,10 @@ void pkgAcqIndexDiffs::Done(string Message,unsigned long long Size, HashStringLi
 
    Item::Done(Message, Size, Hashes, Cnf);
 
 
    Item::Done(Message, Size, Hashes, Cnf);
 

+   // FIXME: verify this download too before feeding it to rred
+

    string FinalFile;
    string FinalFile;

-   FinalFile = _config->FindDir("Dir::State::lists")+URItoFileName(RealURI);
+   FinalFile = _config->FindDir("Dir::State::lists")+"partial/"+URItoFileName(RealURI);

 
    // success in downloading a diff, enter ApplyDiff state
    if(State == StateFetchDiff)
 
    // success in downloading a diff, enter ApplyDiff state
    if(State == StateFetchDiff)


@@ -683,7 +749,15 @@ void pkgAcqIndexDiffs::Done(string Message,unsigned long long Size, HashStringLi
       Local = true;
       Desc.URI = "rred:" + FinalFile;
       QueueURI(Desc);
       Local = true;
       Desc.URI = "rred:" + FinalFile;
       QueueURI(Desc);

+      ActiveSubprocess = "rred";
+#if __GNUC__ >= 4
+       #pragma GCC diagnostic push
+       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif

       Mode = "rred";
       Mode = "rred";

+#if __GNUC__ >= 4
+       #pragma GCC diagnostic pop
+#endif

       return;
    } 
 
       return;
    } 
 


@@ -711,6 +785,8 @@ void pkgAcqIndexDiffs::Done(string Message,unsigned long long Size, HashStringLi
                               ServerSha1, available_patches);
         return Finish();
       } else 
                               ServerSha1, available_patches);
         return Finish();
       } else 

+         // update
+         DestFile = FinalFile;

         return Finish(true);
    }
 }
         return Finish(true);
    }
 }


@@ -777,7 +853,9 @@ void pkgAcqIndexMergeDiffs::Done(string Message,unsigned long long Size,HashStri
 
    Item::Done(Message,Size,Hashes,Cnf);
 
 
    Item::Done(Message,Size,Hashes,Cnf);
 

-   string const FinalFile = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
+   // FIXME: verify download before feeding it to rred
+
+   string const FinalFile = _config->FindDir("Dir::State::lists") + "partial/" + URItoFileName(RealURI);

 
    if (State == StateFetchDiff)
    {
 
    if (State == StateFetchDiff)
    {


@@ -804,7 +882,15 @@ void pkgAcqIndexMergeDiffs::Done(string Message,unsigned long long Size,HashStri
       Local = true;
       Desc.URI = "rred:" + FinalFile;
       QueueURI(Desc);
       Local = true;
       Desc.URI = "rred:" + FinalFile;
       QueueURI(Desc);

+      ActiveSubprocess = "rred";
+#if __GNUC__ >= 4
+       #pragma GCC diagnostic push
+       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif

       Mode = "rred";
       Mode = "rred";

+#if __GNUC__ >= 4
+       #pragma GCC diagnostic pop
+#endif

       return;
    }
    // success in download/apply all diffs, clean up
       return;
    }
    // success in download/apply all diffs, clean up


@@ -817,23 +903,26 @@ void pkgAcqIndexMergeDiffs::Done(string Message,unsigned long long Size,HashStri
         return;
       }
 
         return;
       }
 

+
+      std::string FinalFile = _config->FindDir("Dir::State::lists");
+      FinalFile += URItoFileName(RealURI);
+

       // move the result into place
       if(Debug)
       // move the result into place
       if(Debug)

-        std::clog << "Moving patched file in place: " << std::endl
+        std::clog << "Queue patched file in place: " << std::endl

                   << DestFile << " -> " << FinalFile << std::endl;
                   << DestFile << " -> " << FinalFile << std::endl;

-      Rename(DestFile, FinalFile);
-      chmod(FinalFile.c_str(), 0644);

 
 

-      // otherwise lists cleanup will eat the file
-      DestFile = FinalFile;
-      // FIXME: make the merged rred code really transactional
-      PartialFile = FinalFile;
+      // queue for copy by the transaction manager
+      TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);

 
       // ensure the ed's are gone regardless of list-cleanup
       for (std::vector<pkgAcqIndexMergeDiffs *>::const_iterator I = allPatches->begin();
            I != allPatches->end(); ++I)
       {
 
       // ensure the ed's are gone regardless of list-cleanup
       for (std::vector<pkgAcqIndexMergeDiffs *>::const_iterator I = allPatches->begin();
            I != allPatches->end(); ++I)
       {

-           std::string patch = FinalFile + ".ed." + (*I)->patch.file + ".gz";
+            std::string PartialFile = _config->FindDir("Dir::State::lists");
+            PartialFile += "partial/" + URItoFileName(RealURI);
+           std::string patch = PartialFile + ".ed." + (*I)->patch.file + ".gz";
+            std::cerr << patch << std::endl;

            unlink(patch.c_str());
       }
 
            unlink(patch.c_str());
       }
 


@@ -844,15 +933,34 @@ void pkgAcqIndexMergeDiffs::Done(string Message,unsigned long long Size,HashStri
    }
 }
                                                                        /*}}}*/
    }
 }
                                                                        /*}}}*/

+
+// AcqBaseIndex::VerifyHashByMetaKey - verify hash for the given metakey /*{{{*/
+bool pkgAcqBaseIndex::VerifyHashByMetaKey(HashStringList const &Hashes)
+{
+   if(MetaKey != "" && Hashes.usable())
+   {
+      indexRecords::checkSum *Record = MetaIndexParser->Lookup(MetaKey);
+      if(Record && Record->Hashes.usable() && Hashes != Record->Hashes)
+      {
+         printHashSumComparision(RealURI, Record->Hashes, Hashes);
+         return false;
+      }
+   }
+   return true;
+}
+
+

 // AcqIndex::AcqIndex - Constructor                                    /*{{{*/
 // ---------------------------------------------------------------------
 /* The package file is added to the queue and a second class is 
    instantiated to fetch the revision file */   
 pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
                         string URI,string URIDesc,string ShortDesc,
 // AcqIndex::AcqIndex - Constructor                                    /*{{{*/
 // ---------------------------------------------------------------------
 /* The package file is added to the queue and a second class is 
    instantiated to fetch the revision file */   
 pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
                         string URI,string URIDesc,string ShortDesc,

-                        HashStringList const  &ExpectedHash, string comprExt)
-   : pkgAcqBaseIndex(Owner, 0, NULL, ExpectedHash, NULL), RealURI(URI)
+                        HashStringList const  &ExpectedHash)
+   : pkgAcqBaseIndex(Owner, 0, NULL, ExpectedHash, NULL)

 {
 {

+   RealURI = URI;
+

    AutoSelectCompression();
    Init(URI, URIDesc, ShortDesc);
 
    AutoSelectCompression();
    Init(URI, URIDesc, ShortDesc);
 


@@ -869,8 +977,10 @@ pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
                         HashStringList const &ExpectedHash, 
                          indexRecords *MetaIndexParser)
    : pkgAcqBaseIndex(Owner, TransactionManager, Target, ExpectedHash, 
                         HashStringList const &ExpectedHash, 
                          indexRecords *MetaIndexParser)
    : pkgAcqBaseIndex(Owner, TransactionManager, Target, ExpectedHash, 

-                     MetaIndexParser), RealURI(Target->URI)
+                     MetaIndexParser)

 {
 {

+   RealURI = Target->URI;
+

    // autoselect the compression method
    AutoSelectCompression();
    Init(Target->URI, Target->Description, Target->ShortDesc);
    // autoselect the compression method
    AutoSelectCompression();
    Init(Target->URI, Target->Description, Target->ShortDesc);


@@ -885,31 +995,38 @@ pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
 void pkgAcqIndex::AutoSelectCompression()
 {
    std::vector<std::string> types = APT::Configuration::getCompressionTypes();
 void pkgAcqIndex::AutoSelectCompression()
 {
    std::vector<std::string> types = APT::Configuration::getCompressionTypes();

-   CompressionExtension = "";
+   CompressionExtensions = "";

    if (ExpectedHashes.usable())
    {
    if (ExpectedHashes.usable())
    {

-      for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
-        if (*t == "uncompressed" || MetaIndexParser->Exists(string(Target->MetaKey).append(".").append(*t)) == true)
-           CompressionExtension.append(*t).append(" ");
+      for (std::vector<std::string>::const_iterator t = types.begin();
+           t != types.end(); ++t)
+      {
+         std::string CompressedMetaKey = string(Target->MetaKey).append(".").append(*t);
+         if (*t == "uncompressed" || 
+             MetaIndexParser->Exists(CompressedMetaKey) == true)
+            CompressionExtensions.append(*t).append(" ");
+      }

    }
    else
    {
       for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
    }
    else
    {
       for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)

-        CompressionExtension.append(*t).append(" ");
+        CompressionExtensions.append(*t).append(" ");

    }
    }

-   if (CompressionExtension.empty() == false)
-      CompressionExtension.erase(CompressionExtension.end()-1);
+   if (CompressionExtensions.empty() == false)
+      CompressionExtensions.erase(CompressionExtensions.end()-1);

 }
 // AcqIndex::Init - defered Constructor                                        /*{{{*/
 }
 // AcqIndex::Init - defered Constructor                                        /*{{{*/

-void pkgAcqIndex::Init(string const &URI, string const &URIDesc, string const &ShortDesc) {
-   Decompression = false;
-   Erase = false;
+// ---------------------------------------------------------------------
+void pkgAcqIndex::Init(string const &URI, string const &URIDesc, 
+                       string const &ShortDesc)
+{
+   Stage = STAGE_DOWNLOAD;

 
    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
    DestFile += URItoFileName(URI);
 
 
    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
    DestFile += URItoFileName(URI);
 

-   std::string const comprExt = CompressionExtension.substr(0, CompressionExtension.find(' '));
-   if (comprExt == "uncompressed")
+   CurrentCompressionExtension = CompressionExtensions.substr(0, CompressionExtensions.find(' '));
+   if (CurrentCompressionExtension == "uncompressed")

    {
       Desc.URI = URI;
       if(Target)
    {
       Desc.URI = URI;
       if(Target)


@@ -917,9 +1034,10 @@ void pkgAcqIndex::Init(string const &URI, string const &URIDesc, string const &S
    }
    else
    {
    }
    else
    {

-      Desc.URI = URI + '.' + comprExt;
+      Desc.URI = URI + '.' + CurrentCompressionExtension;
+      DestFile = DestFile + '.' + CurrentCompressionExtension;

       if(Target)
       if(Target)

-         MetaKey = string(Target->MetaKey) + '.' + comprExt;
+         MetaKey = string(Target->MetaKey) + '.' + CurrentCompressionExtension;

    }
 
    // load the filesize
    }
 
    // load the filesize


@@ -976,16 +1094,9 @@ void pkgAcqIndex::InitByHashIfNeeded(const std::string MetaKey)
 /* The only header we use is the last-modified header. */
 string pkgAcqIndex::Custom600Headers() const
 {
 /* The only header we use is the last-modified header. */
 string pkgAcqIndex::Custom600Headers() const
 {

-   string Final = _config->FindDir("Dir::State::lists");
-   Final += URItoFileName(RealURI);
-   if (_config->FindB("Acquire::GzipIndexes",false))
-      Final += ".gz";
+   string Final = GetFinalFilename();

    
    string msg = "\nIndex-File: true";
    
    string msg = "\nIndex-File: true";

-   // FIXME: this really should use "IndexTarget::IsOptional()" but that
-   //        seems to be difficult without breaking ABI
-   if (ShortDesc().find("Translation") != 0)
-      msg += "\nFail-Ignore: true";

    struct stat Buf;
    if (stat(Final.c_str(),&Buf) == 0)
       msg += "\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
    struct stat Buf;
    if (stat(Final.c_str(),&Buf) == 0)
       msg += "\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);


@@ -998,19 +1109,18 @@ string pkgAcqIndex::Custom600Headers() const
 /* */
 void pkgAcqIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf) /*{{{*/
 {
 /* */
 void pkgAcqIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf) /*{{{*/
 {

-   size_t const nextExt = CompressionExtension.find(' ');
+   size_t const nextExt = CompressionExtensions.find(' ');

    if (nextExt != std::string::npos)
    {
    if (nextExt != std::string::npos)
    {

-      CompressionExtension = CompressionExtension.substr(nextExt+1);
+      CompressionExtensions = CompressionExtensions.substr(nextExt+1);

       Init(RealURI, Desc.Description, Desc.ShortDesc);
       return;
    }
 
    // on decompression failure, remove bad versions in partial/
       Init(RealURI, Desc.Description, Desc.ShortDesc);
       return;
    }
 
    // on decompression failure, remove bad versions in partial/

-   if (Decompression && Erase) {
-      string s = _config->FindDir("Dir::State::lists") + "partial/";
-      s.append(URItoFileName(RealURI));
-      unlink(s.c_str());
+   if (Stage == STAGE_DECOMPRESS_AND_VERIFY)
+   {
+      unlink(EraseFileName.c_str());

    }
 
    Item::Failed(Message,Cnf);
    }
 
    Item::Failed(Message,Cnf);


@@ -1022,32 +1132,65 @@ void pkgAcqIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)  /*{{{*/
 // pkgAcqIndex::GetFinalFilename - Return the full final file path      /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // pkgAcqIndex::GetFinalFilename - Return the full final file path      /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-std::string pkgAcqIndex::GetFinalFilename(std::string const &URI,
-                                          std::string const &compExt)
+std::string pkgAcqIndex::GetFinalFilename() const

 {
    std::string FinalFile = _config->FindDir("Dir::State::lists");
 {
    std::string FinalFile = _config->FindDir("Dir::State::lists");

-   FinalFile += URItoFileName(URI);
-   if (_config->FindB("Acquire::GzipIndexes",false) && compExt == "gz")
-      FinalFile += ".gz";
+   FinalFile += URItoFileName(RealURI);
+   if (_config->FindB("Acquire::GzipIndexes",false) == true)
+      FinalFile += '.' + CurrentCompressionExtension;

    return FinalFile;
 }
                                                                        /*}}}*/
 // AcqIndex::ReverifyAfterIMS - Reverify index after an ims-hit        /*{{{*/
 // ---------------------------------------------------------------------
 /* */
    return FinalFile;
 }
                                                                        /*}}}*/
 // AcqIndex::ReverifyAfterIMS - Reverify index after an ims-hit        /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-void pkgAcqIndex::ReverifyAfterIMS(std::string const &FileName)
+void pkgAcqIndex::ReverifyAfterIMS()

 {
 {

-   std::string const compExt = CompressionExtension.substr(0, CompressionExtension.find(' '));
-   if (_config->FindB("Acquire::GzipIndexes",false) && compExt == "gz")
-      DestFile += ".gz";
+   // update destfile to *not* include the compression extension when doing
+   // a reverify (as its uncompressed on disk already)
+   DestFile =  _config->FindDir("Dir::State::lists") + "partial/";
+   DestFile += URItoFileName(RealURI);
+
+   // adjust DestFile if its compressed on disk
+   if (_config->FindB("Acquire::GzipIndexes",false) == true)
+      DestFile += '.' + CurrentCompressionExtension;

 
    // copy FinalFile into partial/ so that we check the hash again
 
    // copy FinalFile into partial/ so that we check the hash again

-   string FinalFile = GetFinalFilename(RealURI, compExt);
-   Decompression = true;
+   string FinalFile = GetFinalFilename();
+   Stage = STAGE_DECOMPRESS_AND_VERIFY;

    Desc.URI = "copy:" + FinalFile;
    QueueURI(Desc);
 }
                                                                        /*}}}*/
    Desc.URI = "copy:" + FinalFile;
    QueueURI(Desc);
 }
                                                                        /*}}}*/

+
+// AcqIndex::ValidateFile - Validate the content of the downloaded file  /*{{{*/
+// --------------------------------------------------------------------------
+bool pkgAcqIndex::ValidateFile(const std::string &FileName)
+{
+   // FIXME: this can go away once we only ever download stuff that
+   //        has a valid hash and we never do GET based probing
+   // FIXME2: this also leaks debian-isms into the code and should go therefore
+
+   /* Always validate the index file for correctness (all indexes must
+    * have a Package field) (LP: #346386) (Closes: #627642) 
+    */
+   FileFd fd(FileName, FileFd::ReadOnly, FileFd::Extension);
+   // Only test for correctness if the content of the file is not empty
+   // (empty is ok)
+   if (fd.Size() > 0)
+   {
+      pkgTagSection sec;
+      pkgTagFile tag(&fd);
+      
+      // all our current indexes have a field 'Package' in each section
+      if (_error->PendingError() == true ||
+          tag.Step(sec) == false ||
+          sec.Exists("Package") == false)
+         return false;
+   }
+   return true;
+}
+                                                                        /*}}}*/

 // AcqIndex::Done - Finished a fetch                                   /*{{{*/
 // ---------------------------------------------------------------------
 /* This goes through a number of states.. On the initial fetch the
 // AcqIndex::Done - Finished a fetch                                   /*{{{*/
 // ---------------------------------------------------------------------
 /* This goes through a number of states.. On the initial fetch the


@@ -1055,92 +1198,58 @@ void pkgAcqIndex::ReverifyAfterIMS(std::string const &FileName)
    to the uncompressed version of the file. If this is so the file
    is copied into the partial directory. In all other cases the file
    is decompressed with a compressed uri. */
    to the uncompressed version of the file. If this is so the file
    is copied into the partial directory. In all other cases the file
    is decompressed with a compressed uri. */

-void pkgAcqIndex::Done(string Message,unsigned long long Size,HashStringList const &Hashes,
+void pkgAcqIndex::Done(string Message,
+                       unsigned long long Size,
+                       HashStringList const &Hashes,

                       pkgAcquire::MethodConfig *Cfg)
 {
    Item::Done(Message,Size,Hashes,Cfg);
                       pkgAcquire::MethodConfig *Cfg)
 {
    Item::Done(Message,Size,Hashes,Cfg);

-   std::string const compExt = CompressionExtension.substr(0, CompressionExtension.find(' '));

 
 

-   if (Decompression == true)
+   switch(Stage) 

    {
    {

-      if (ExpectedHashes.usable() && ExpectedHashes != Hashes)
-      {
-        RenameOnError(HashSumMismatch);
-        printHashSumComparision(RealURI, ExpectedHashes, Hashes);
-         Failed(Message, Cfg);
-         return;
-      }
-
-      // FIXME: this can go away once we only ever download stuff that
-      //        has a valid hash and we never do GET based probing
-      //
-      /* Always verify the index file for correctness (all indexes must
-       * have a Package field) (LP: #346386) (Closes: #627642) 
-       */
-      FileFd fd(DestFile, FileFd::ReadOnly, FileFd::Extension);
-      // Only test for correctness if the content of the file is not empty
-      // (empty is ok)
-      if (fd.Size() > 0)
-      {
-         pkgTagSection sec;
-         pkgTagFile tag(&fd);
-         
-         // all our current indexes have a field 'Package' in each section
-         if (_error->PendingError() == true || tag.Step(sec) == false || sec.Exists("Package") == false)
-         {
-            RenameOnError(InvalidFormat);
-            Failed(Message, Cfg);
-            return;
-         }
-      }
-       
-      // FIXME: can we void the "Erase" bool here as its very non-local?
-      std::string CompressedFile = _config->FindDir("Dir::State::lists") + "partial/";
-      CompressedFile += URItoFileName(RealURI);
-      // Remove the compressed version.
-      if (Erase == true)
-        unlink(CompressedFile.c_str());
-
-      // Done, queue for rename on transaction finished
-      PartialFile = DestFile;
-      DestFile = GetFinalFilename(RealURI, compExt);
-
-      return;
+      case STAGE_DOWNLOAD:
+         StageDownloadDone(Message, Hashes, Cfg);
+         break;
+      case STAGE_DECOMPRESS_AND_VERIFY:
+         StageDecompressDone(Message, Hashes, Cfg);
+         break;

    }
    }

-   
-   // FIXME: use the same method to find 
-   // check the compressed hash too
-   if(MetaKey != "" && Hashes.size() > 0)
+}
+
+// AcqIndex::StageDownloadDone - Queue for decompress and verify        /*{{{*/
+void pkgAcqIndex::StageDownloadDone(string Message,
+                                    HashStringList const &Hashes,
+                                    pkgAcquire::MethodConfig *Cfg)
+{
+   // First check if the calculcated Hash of the (compressed) downloaded
+   // file matches the hash we have in the MetaIndexRecords for this file
+   if(VerifyHashByMetaKey(Hashes) == false)

    {
    {

-      indexRecords::checkSum *Record = MetaIndexParser->Lookup(MetaKey);
-      if(Record && Record->Hashes.usable() && Hashes != Record->Hashes)
-      {
-         RenameOnError(HashSumMismatch);
-         printHashSumComparision(RealURI, Record->Hashes, Hashes);
-         Failed(Message, Cfg);
-         return;
-      }
+      RenameOnError(HashSumMismatch);
+      Failed(Message, Cfg);
+      return;

    }
 
    }
 

-   Erase = false;

    Complete = true;
    
    // Handle the unzipd case
    string FileName = LookupTag(Message,"Alt-Filename");
    if (FileName.empty() == false)
    {
    Complete = true;
    
    // Handle the unzipd case
    string FileName = LookupTag(Message,"Alt-Filename");
    if (FileName.empty() == false)
    {

-      // The files timestamp matches
-      if (StringToBool(LookupTag(Message,"Alt-IMS-Hit"),false) == true)
-      {
-         ReverifyAfterIMS(FileName);
-        return;
-      }
-      Decompression = true;
+      Stage = STAGE_DECOMPRESS_AND_VERIFY;

       Local = true;
       DestFile += ".decomp";
       Desc.URI = "copy:" + FileName;
       QueueURI(Desc);
       Local = true;
       DestFile += ".decomp";
       Desc.URI = "copy:" + FileName;
       QueueURI(Desc);

+      ActiveSubprocess = "copy";
+#if __GNUC__ >= 4
+       #pragma GCC diagnostic push
+       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif

       Mode = "copy";
       Mode = "copy";

+#if __GNUC__ >= 4
+       #pragma GCC diagnostic pop
+#endif

       return;
    }
 
       return;
    }
 


@@ -1151,53 +1260,107 @@ void pkgAcqIndex::Done(string Message,unsigned long long Size,HashStringList con
       ErrorText = "Method gave a blank filename";
    }
 
       ErrorText = "Method gave a blank filename";
    }
 

-   // The files timestamp matches
-   if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
+   // Methods like e.g. "file:" will give us a (compressed) FileName that is
+   // not the "DestFile" we set, in this case we uncompress from the local file
+   if (FileName != DestFile)
+      Local = true;
+   else
+      EraseFileName = FileName;
+
+   // we need to verify the file against the current Release file again
+   // on if-modfied-since hit to avoid a stale attack against us
+   if(StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)

    {
    {

-      ReverifyAfterIMS(FileName);
+      // do not reverify cdrom sources as apt-cdrom may rewrite the Packages
+      // file when its doing the indexcopy
+      if (RealURI.substr(0,6) == "cdrom:")
+         return;
+
+      // The files timestamp matches, reverify by copy into partial/
+      EraseFileName = "";
+      ReverifyAfterIMS();

       return;
       return;

-    }
+   }

 
 

-   if (FileName == DestFile)
-      Erase = true;
-   else
-      Local = true;
-   
-   string decompProg;
+   // If we have compressed indexes enabled, queue for hash verification
+   if (_config->FindB("Acquire::GzipIndexes",false))
+   {
+      DestFile = _config->FindDir("Dir::State::lists") + "partial/";
+      DestFile += URItoFileName(RealURI) + '.' + CurrentCompressionExtension;
+      EraseFileName = "";
+      Stage = STAGE_DECOMPRESS_AND_VERIFY;
+      Desc.URI = "copy:" + FileName;
+      QueueURI(Desc);

 
 

-   // If we enable compressed indexes and already have gzip, keep it
-   if (_config->FindB("Acquire::GzipIndexes",false) && compExt == "gz" && !Local) {
-      // Done, queue for rename on transaction finished
-      PartialFile = DestFile;
-      DestFile = GetFinalFilename(RealURI, compExt);

       return;
     }
 
    // get the binary name for your used compression type
       return;
     }
 
    // get the binary name for your used compression type

-   decompProg = _config->Find(string("Acquire::CompressionTypes::").append(compExt),"");
-   if(decompProg.empty() == false);
-   else if(compExt == "uncompressed")
+   string decompProg;
+   if(CurrentCompressionExtension == "uncompressed")

       decompProg = "copy";
       decompProg = "copy";

-   else {
-      _error->Error("Unsupported extension: %s", compExt.c_str());
+   else
+      decompProg = _config->Find(string("Acquire::CompressionTypes::").append(CurrentCompressionExtension),"");
+   if(decompProg.empty() == true)
+   {
+      _error->Error("Unsupported extension: %s", CurrentCompressionExtension.c_str());

       return;
    }
 
       return;
    }
 

-   Decompression = true;
+   // queue uri for the next stage
+   Stage = STAGE_DECOMPRESS_AND_VERIFY;

    DestFile += ".decomp";
    Desc.URI = decompProg + ":" + FileName;
    QueueURI(Desc);
 
    DestFile += ".decomp";
    Desc.URI = decompProg + ":" + FileName;
    QueueURI(Desc);
 

-   // FIXME: this points to a c++ string that goes out of scope
-   Mode = decompProg.c_str();
+   ActiveSubprocess = decompProg;
+#if __GNUC__ >= 4
+       #pragma GCC diagnostic push
+       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+      Mode = ActiveSubprocess.c_str();
+#if __GNUC__ >= 4
+       #pragma GCC diagnostic pop
+#endif

 }
 }

+                                                                        /*}}}*/
+// pkgAcqIndex::StageDecompressDone - Final verification               /*{{{*/
+void pkgAcqIndex::StageDecompressDone(string Message,
+                                      HashStringList const &Hashes,
+                                      pkgAcquire::MethodConfig *Cfg)
+{
+   if (ExpectedHashes.usable() && ExpectedHashes != Hashes)
+   {
+      Desc.URI = RealURI;
+      RenameOnError(HashSumMismatch);
+      printHashSumComparision(RealURI, ExpectedHashes, Hashes);
+      Failed(Message, Cfg);
+      return;
+   }
+
+   if(!ValidateFile(DestFile))
+   {
+      RenameOnError(InvalidFormat);
+      Failed(Message, Cfg);
+      return;
+   }
+   
+   // remove the compressed version of the file
+   unlink(EraseFileName.c_str());
+   
+   // Done, queue for rename on transaction finished
+   TransactionManager->TransactionStageCopy(this, DestFile, GetFinalFilename());
+   
+   return;
+}
+                                                                        /*}}}*/

                                                                        /*}}}*/
 // AcqIndexTrans::pkgAcqIndexTrans - Constructor                       /*{{{*/
 // ---------------------------------------------------------------------
 /* The Translation file is added to the queue */
 pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire *Owner,
                            string URI,string URIDesc,string ShortDesc) 
                                                                        /*}}}*/
 // AcqIndexTrans::pkgAcqIndexTrans - Constructor                       /*{{{*/
 // ---------------------------------------------------------------------
 /* The Translation file is added to the queue */
 pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire *Owner,
                            string URI,string URIDesc,string ShortDesc) 

-  : pkgAcqIndex(Owner, URI, URIDesc, ShortDesc, HashStringList(), "")
+  : pkgAcqIndex(Owner, URI, URIDesc, ShortDesc, HashStringList())

 {
 }
                                                                        /*}}}*/
 {
 }
                                                                        /*}}}*/


@@ -1218,8 +1381,7 @@ pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire *Owner,
 // ---------------------------------------------------------------------
 string pkgAcqIndexTrans::Custom600Headers() const
 {
 // ---------------------------------------------------------------------
 string pkgAcqIndexTrans::Custom600Headers() const
 {

-   string Final = _config->FindDir("Dir::State::lists");
-   Final += URItoFileName(RealURI);
+   string Final = GetFinalFilename();

 
    struct stat Buf;
    if (stat(Final.c_str(),&Buf) != 0)
 
    struct stat Buf;
    if (stat(Final.c_str(),&Buf) != 0)


@@ -1232,10 +1394,10 @@ string pkgAcqIndexTrans::Custom600Headers() const
 /* */
 void pkgAcqIndexTrans::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 {
 /* */
 void pkgAcqIndexTrans::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
 {

-   size_t const nextExt = CompressionExtension.find(' ');
+   size_t const nextExt = CompressionExtensions.find(' ');

    if (nextExt != std::string::npos)
    {
    if (nextExt != std::string::npos)
    {

-      CompressionExtension = CompressionExtension.substr(nextExt+1);
+      CompressionExtensions = CompressionExtensions.substr(nextExt+1);

       Init(RealURI, Desc.Description, Desc.ShortDesc);
       Status = StatIdle;
       return;
       Init(RealURI, Desc.Description, Desc.ShortDesc);
       Status = StatIdle;
       return;


@@ -1255,17 +1417,23 @@ void pkgAcqIndexTrans::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
    Item::Failed(Message,Cnf);
 }
                                                                        /*}}}*/
    Item::Failed(Message,Cnf);
 }
                                                                        /*}}}*/

-
+// AcqMetaBase::Add - Add a item to the current Transaction            /*{{{*/
+// ---------------------------------------------------------------------
+/* */

 void pkgAcqMetaBase::Add(Item *I)
 {
    Transaction.push_back(I);
 }
 void pkgAcqMetaBase::Add(Item *I)
 {
    Transaction.push_back(I);
 }

-
+                                                                       /*}}}*/
+// AcqMetaBase::AbortTransaction - Abort the current Transaction       /*{{{*/
+// ---------------------------------------------------------------------
+/* */

 void pkgAcqMetaBase::AbortTransaction()
 {
    if(_config->FindB("Debug::Acquire::Transaction", false) == true)
       std::clog << "AbortTransaction: " << TransactionManager << std::endl;
 
 void pkgAcqMetaBase::AbortTransaction()
 {
    if(_config->FindB("Debug::Acquire::Transaction", false) == true)
       std::clog << "AbortTransaction: " << TransactionManager << std::endl;
 

+   // ensure the toplevel is in error state too

    for (std::vector<Item*>::iterator I = Transaction.begin();
         I != Transaction.end(); ++I)
    {
    for (std::vector<Item*>::iterator I = Transaction.begin();
         I != Transaction.end(); ++I)
    {


@@ -1274,9 +1442,19 @@ void pkgAcqMetaBase::AbortTransaction()
       // the transaction will abort, so stop anything that is idle
       if ((*I)->Status == pkgAcquire::Item::StatIdle)
          (*I)->Status = pkgAcquire::Item::StatDone;
       // the transaction will abort, so stop anything that is idle
       if ((*I)->Status == pkgAcquire::Item::StatIdle)
          (*I)->Status = pkgAcquire::Item::StatDone;

+
+      // kill files in partial
+      string PartialFile = _config->FindDir("Dir::State::lists");
+      PartialFile += "partial/";
+      PartialFile += flNotDir((*I)->DestFile);
+      if(FileExists(PartialFile))
+         Rename(PartialFile, PartialFile + ".FAILED");

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

+// AcqMetaBase::TransactionHasError - Check for errors in Transaction          /*{{{*/
+// ---------------------------------------------------------------------
+/* */

 bool pkgAcqMetaBase::TransactionHasError()
 {
    for (pkgAcquire::ItemIterator I = Transaction.begin();
 bool pkgAcqMetaBase::TransactionHasError()
 {
    for (pkgAcquire::ItemIterator I = Transaction.begin();


@@ -1287,7 +1465,10 @@ bool pkgAcqMetaBase::TransactionHasError()
 
    return false;
 }
 
    return false;
 }

-// Acquire::CommitTransaction - Commit a transaction                   /*{{{*/
+                                                                       /*}}}*/
+// AcqMetaBase::CommitTransaction - Commit a transaction               /*{{{*/
+// ---------------------------------------------------------------------
+/* */

 void pkgAcqMetaBase::CommitTransaction()
 {
    if(_config->FindB("Debug::Acquire::Transaction", false) == true)
 void pkgAcqMetaBase::CommitTransaction()
 {
    if(_config->FindB("Debug::Acquire::Transaction", false) == true)


@@ -1303,21 +1484,50 @@ void pkgAcqMetaBase::CommitTransaction()
          if(_config->FindB("Debug::Acquire::Transaction", false) == true)
             std::clog << "mv " 
                       << (*I)->PartialFile << " -> " 
          if(_config->FindB("Debug::Acquire::Transaction", false) == true)
             std::clog << "mv " 
                       << (*I)->PartialFile << " -> " 

-                      <<  (*I)->DestFile << std::endl;
+                      <<  (*I)->DestFile << " " 
+                      << (*I)->DescURI()
+                      << std::endl;

          Rename((*I)->PartialFile, (*I)->DestFile);
          chmod((*I)->DestFile.c_str(),0644);
       } else {
          if(_config->FindB("Debug::Acquire::Transaction", false) == true)
             std::clog << "rm " 
          Rename((*I)->PartialFile, (*I)->DestFile);
          chmod((*I)->DestFile.c_str(),0644);
       } else {
          if(_config->FindB("Debug::Acquire::Transaction", false) == true)
             std::clog << "rm " 

-                      <<  (*I)->DestFile << std::endl;
+                      <<  (*I)->DestFile
+                      << " " 
+                      << (*I)->DescURI()
+                      << std::endl;

          unlink((*I)->DestFile.c_str());
       }
       // mark that this transaction is finished
       (*I)->TransactionManager = 0;
    }
 }
          unlink((*I)->DestFile.c_str());
       }
       // mark that this transaction is finished
       (*I)->TransactionManager = 0;
    }
 }

-
+                                                                       /*}}}*/
+// AcqMetaBase::CommitTransaction - Commit a transaction               /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+void pkgAcqMetaBase::TransactionStageCopy(Item *I,
+                                          const std::string &From,
+                                          const std::string &To)
+{
+   I->PartialFile = From;
+   I->DestFile = To;
+}
+                                                                       /*}}}*/
+// AcqMetaBase::CommitTransaction - Commit a transaction               /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+void pkgAcqMetaBase::TransactionStageRemoval(Item *I,
+                                             const std::string &FinalFile)
+{
+   I->PartialFile = "";
+   I->DestFile = FinalFile; 
+}
+                                                                       /*}}}*/

                                                                        /*{{{*/
                                                                        /*{{{*/

+// AcqMetaBase::GenerateAuthWarning - Check gpg authentication error   /*{{{*/
+// ---------------------------------------------------------------------
+/* */

 bool pkgAcqMetaBase::GenerateAuthWarning(const std::string &RealURI,
                                          const std::string &Message)
 {
 bool pkgAcqMetaBase::GenerateAuthWarning(const std::string &RealURI,
                                          const std::string &Message)
 {


@@ -1351,20 +1561,22 @@ bool pkgAcqMetaBase::GenerateAuthWarning(const std::string &RealURI,
    return false;
 }
                                                                        /*}}}*/
    return false;
 }
                                                                        /*}}}*/

-
-
-pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire *Owner,                        /*{{{*/
+// AcqMetaSig::AcqMetaSig - Constructor                                /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire *Owner,

                              pkgAcqMetaBase *TransactionManager,
                             string URI,string URIDesc,string ShortDesc,
                              string MetaIndexFile,
                             const vector<IndexTarget*>* IndexTargets,
                             indexRecords* MetaIndexParser) :
                              pkgAcqMetaBase *TransactionManager,
                             string URI,string URIDesc,string ShortDesc,
                              string MetaIndexFile,
                             const vector<IndexTarget*>* IndexTargets,
                             indexRecords* MetaIndexParser) :

-   pkgAcqMetaBase(Owner, HashStringList(), TransactionManager), RealURI(URI), 
-   MetaIndexParser(MetaIndexParser), MetaIndexFile(MetaIndexFile),
-   IndexTargets(IndexTargets), AuthPass(false), IMSHit(false)
+   pkgAcqMetaBase(Owner, IndexTargets, MetaIndexParser, 
+                  HashStringList(), TransactionManager),
+   RealURI(URI), MetaIndexFile(MetaIndexFile), URIDesc(URIDesc),
+   ShortDesc(ShortDesc)

 {
    DestFile = _config->FindDir("Dir::State::lists") + "partial/";
 {
    DestFile = _config->FindDir("Dir::State::lists") + "partial/";

-   DestFile += URItoFileName(URI);
+   DestFile += URItoFileName(RealURI);

 
    // remove any partial downloaded sig-file in partial/. 
    // it may confuse proxies and is too small to warrant a 
 
    // remove any partial downloaded sig-file in partial/. 
    // it may confuse proxies and is too small to warrant a 


@@ -1403,76 +1615,81 @@ string pkgAcqMetaSig::Custom600Headers() const
 
    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 }
 
    return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 }

-
-void pkgAcqMetaSig::Done(string Message,unsigned long long Size, HashStringList const &Hashes,
+                                                                       /*}}}*/
+// pkgAcqMetaSig::Done - The signature was downloaded/verified         /*{{{*/
+// ---------------------------------------------------------------------
+/* The only header we use is the last-modified header. */
+void pkgAcqMetaSig::Done(string Message,unsigned long long Size,
+                         HashStringList const &Hashes,

                         pkgAcquire::MethodConfig *Cfg)
 {
    Item::Done(Message, Size, Hashes, Cfg);
 
                         pkgAcquire::MethodConfig *Cfg)
 {
    Item::Done(Message, Size, Hashes, Cfg);
 

-   string FileName = LookupTag(Message,"Filename");
-   if (FileName.empty() == true)
+   if(AuthPass == false)

    {
    {

-      Status = StatError;
-      ErrorText = "Method gave a blank filename";
-      return;
-   }
+      // queue for verify, note that we change DestFile here to point to
+      // the file we want to verify (needed to make gpgv work)

 
 

-   if (FileName != DestFile)
-   {
-      // We have to copy it into place
-      Local = true;
-      Desc.URI = "copy:" + FileName;
-      QueueURI(Desc);
-      return;
-   }
+      string FileName = LookupTag(Message,"Filename");
+      if (FileName.empty() == true)
+      {
+         Status = StatError;
+         ErrorText = "Method gave a blank filename";
+         return;
+      }

 
 

-   if(StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
-      IMSHit = true;
+      if (FileName != DestFile)
+      {
+         // We have to copy it into place
+         Local = true;
+         Desc.URI = "copy:" + FileName;
+         QueueURI(Desc);
+         return;
+      }

 
 

-   // adjust paths if its a ims-hit
-   if(IMSHit)
-   {
-      string FinalFile = _config->FindDir("Dir::State::lists");
-      FinalFile += URItoFileName(RealURI);
-         
-      DestFile = PartialFile = FinalFile;
-   }
+      if(StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
+      {
+         IMSHit = true;
+         // adjust DestFile on i-m-s hit to the one we already have on disk
+         DestFile = _config->FindDir("Dir::State::lists");
+         DestFile += URItoFileName(RealURI);
+      }
+
+      // this is the file we verify from
+      MetaIndexFileSignature = DestFile;

 
 

-   // queue for verify
-   if(AuthPass == false)
-   {

       AuthPass = true;
       AuthPass = true;

-      Desc.URI = "gpgv:" + DestFile;
+      Desc.URI = "gpgv:" + MetaIndexFileSignature;

       DestFile = MetaIndexFile;
       QueueURI(Desc);
       DestFile = MetaIndexFile;
       QueueURI(Desc);

+      ActiveSubprocess = "gpgv";

       return;
    }
       return;
    }

-
-   // queue to copy the file in place if it was not a ims hit, on ims
-   // hit the file is already at the right place
-   if(IMSHit == false)
+   else 

    {
    {

-      PartialFile = _config->FindDir("Dir::State::lists") + "partial/";
-      PartialFile += URItoFileName(RealURI);
-      
-      DestFile = _config->FindDir("Dir::State::lists");
-      DestFile += URItoFileName(RealURI);
-   }
+      // verify was successful

 
 

-   Complete = true;
+      // we parse the MetaIndexFile here (and not right after getting 
+      // the pkgAcqMetaIndex) because at this point we can trust the data
+      //
+      // load indexes and queue further downloads
+      MetaIndexParser->Load(MetaIndexFile);
+      QueueIndexes(true);

 
 

+      // DestFile points to the the MetaIndeFile at this point, make it
+      // point back to the Release.gpg file
+      std::string FinalFile = _config->FindDir("Dir::State::lists");
+      FinalFile += URItoFileName(RealURI);
+      TransactionManager->TransactionStageCopy(this, MetaIndexFileSignature, FinalFile);
+
+      Complete = true;
+   }

 }
                                                                        /*}}}*/
 void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf)/*{{{*/
 {
    string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
 
 }
                                                                        /*}}}*/
 void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf)/*{{{*/
 {
    string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
 

-   // this ensures that any file in the lists/ dir is removed by the
-   // transaction
-   DestFile =  _config->FindDir("Dir::State::lists") + "partial/";
-   DestFile += URItoFileName(RealURI);
-   PartialFile = "";
-

    // FIXME: duplicated code from pkgAcqMetaIndex
    if (AuthPass == true)
    {
    // FIXME: duplicated code from pkgAcqMetaIndex
    if (AuthPass == true)
    {


@@ -1481,6 +1698,53 @@ void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf)/*{{{*/
          return;
    }
 
          return;
    }
 

+   // FIXME: meh, this is not really elegant
+   string InReleaseURI = RealURI.replace(RealURI.rfind("Release.gpg"), 12,
+                                         "InRelease");
+   string FinalInRelease = _config->FindDir("Dir::State::lists") + URItoFileName(InReleaseURI);
+
+   if (RealFileExists(Final) || RealFileExists(FinalInRelease))
+   {
+      std::string downgrade_msg;
+      strprintf(downgrade_msg, _("The repository '%s' is no longer signed."),
+                URIDesc.c_str());
+      if(_config->FindB("Acquire::AllowDowngradeToInsecureRepositories"))
+      {
+         // meh, the users wants to take risks (we still mark the packages
+         // from this repository as unauthenticated)
+         _error->Warning("%s", downgrade_msg.c_str());
+         _error->Warning(_("This is normally not allowed, but the option "
+                           "Acquire::AllowDowngradeToInsecureRepositories was "
+                           "given to override it."));
+         
+      } else {
+         _error->Error("%s", downgrade_msg.c_str());
+         Rename(MetaIndexFile, MetaIndexFile+".FAILED");
+         Status = pkgAcquire::Item::StatError;
+         TransactionManager->AbortTransaction();
+         return;
+      }
+   }
+
+   // this ensures that any file in the lists/ dir is removed by the
+   // transaction
+   DestFile =  _config->FindDir("Dir::State::lists") + "partial/";
+   DestFile += URItoFileName(RealURI);
+   TransactionManager->TransactionStageRemoval(this, DestFile);
+
+   // only allow going further if the users explicitely wants it
+   if(_config->FindB("Acquire::AllowInsecureRepositories") == true)
+   {
+      // we parse the indexes here because at this point the user wanted
+      // a repository that may potentially harm him
+      MetaIndexParser->Load(MetaIndexFile);
+      QueueIndexes(true);
+   } 
+   else 
+   {
+      _error->Warning("Use --allow-insecure-repositories to force the update");
+   }
+

    // FIXME: this is used often (e.g. in pkgAcqIndexTrans) so refactor
    if (Cnf->LocalOnly == true || 
        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
    // FIXME: this is used often (e.g. in pkgAcqIndexTrans) so refactor
    if (Cnf->LocalOnly == true || 
        StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)


@@ -1500,8 +1764,9 @@ pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire *Owner,                       /*{{{*/
                                  string MetaIndexSigURI,string MetaIndexSigURIDesc, string MetaIndexSigShortDesc,
                                 const vector<IndexTarget*>* IndexTargets,
                                 indexRecords* MetaIndexParser) :
                                  string MetaIndexSigURI,string MetaIndexSigURIDesc, string MetaIndexSigShortDesc,
                                 const vector<IndexTarget*>* IndexTargets,
                                 indexRecords* MetaIndexParser) :

-   pkgAcqMetaBase(Owner, HashStringList(), TransactionManager), RealURI(URI), IndexTargets(IndexTargets),
-   MetaIndexParser(MetaIndexParser), AuthPass(false), IMSHit(false),
+   pkgAcqMetaBase(Owner, IndexTargets, MetaIndexParser, HashStringList(),
+                  TransactionManager), 
+   RealURI(URI), URIDesc(URIDesc), ShortDesc(ShortDesc),

    MetaIndexSigURI(MetaIndexSigURI), MetaIndexSigURIDesc(MetaIndexSigURIDesc),
    MetaIndexSigShortDesc(MetaIndexSigShortDesc)
 {
    MetaIndexSigURI(MetaIndexSigURI), MetaIndexSigURIDesc(MetaIndexSigURIDesc),
    MetaIndexSigShortDesc(MetaIndexSigShortDesc)
 {


@@ -1573,13 +1838,7 @@ void pkgAcqMetaIndex::Done(string Message,unsigned long long Size,HashStringList
          // Still more retrieving to do
          return;
 
          // Still more retrieving to do
          return;
 

-      if (SigFile == "")
-      {
-         // load indexes, the signature will downloaded afterwards
-         MetaIndexParser->Load(DestFile);
-         QueueIndexes(true);
-      }
-      else
+      if (SigFile != "")

       {
          // There was a signature file, so pass it to gpgv for
          // verification
       {
          // There was a signature file, so pass it to gpgv for
          // verification


@@ -1589,7 +1848,15 @@ void pkgAcqMetaIndex::Done(string Message,unsigned long long Size,HashStringList
          AuthPass = true;
          Desc.URI = "gpgv:" + SigFile;
          QueueURI(Desc);
          AuthPass = true;
          Desc.URI = "gpgv:" + SigFile;
          QueueURI(Desc);

-         Mode = "gpgv";
+        ActiveSubprocess = "gpgv";
+#if __GNUC__ >= 4
+       #pragma GCC diagnostic push
+       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+        Mode = "gpgv";
+#if __GNUC__ >= 4
+       #pragma GCC diagnostic pop
+#endif

         return;
       }
    }
         return;
       }
    }


@@ -1600,9 +1867,9 @@ void pkgAcqMetaIndex::Done(string Message,unsigned long long Size,HashStringList
       FinalFile += URItoFileName(RealURI);
       if (SigFile == DestFile)
         SigFile = FinalFile;
       FinalFile += URItoFileName(RealURI);
       if (SigFile == DestFile)
         SigFile = FinalFile;

+

       // queue for copy in place
       // queue for copy in place

-      PartialFile = DestFile;
-      DestFile = FinalFile;
+      TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);

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


@@ -1680,7 +1947,41 @@ void pkgAcqMetaIndex::AuthDone(string Message)                           /*{{{*/
       std::cerr << "Signature verification succeeded: "
                 << DestFile << std::endl;
 
       std::cerr << "Signature verification succeeded: "
                 << DestFile << std::endl;
 

-   // Download further indexes with verification
+// we ensure this by other means
+#if 0 
+   // do not trust any previously unverified content that we may have
+   string LastGoodSigFile = _config->FindDir("Dir::State::lists").append("partial/").append(URItoFileName(RealURI));
+   if (DestFile != SigFile)
+      LastGoodSigFile.append(".gpg");
+   LastGoodSigFile.append(".reverify");
+   if(IMSHit == false && RealFileExists(LastGoodSigFile) == false)
+   {
+      for (vector <struct IndexTarget*>::const_iterator Target = IndexTargets->begin();
+           Target != IndexTargets->end();
+           ++Target)
+      {
+         // remove old indexes
+         std::string index = _config->FindDir("Dir::State::lists") +
+            URItoFileName((*Target)->URI);
+         unlink(index.c_str());
+         // and also old gzipindexes
+         std::vector<std::string> types = APT::Configuration::getCompressionTypes();
+         for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
+         {
+            index += '.' + (*t);
+            unlink(index.c_str());
+         }
+      }
+   }
+#endif
+
+   // Download further indexes with verification 
+   //
+   // it would be really nice if we could simply do
+   //    if (IMSHit == false) QueueIndexes(true)
+   // and skip the download if the Release file has not changed
+   // - but right now the list cleaner will needs to be tricked
+   //   to not delete all our packages/source indexes in this case

    QueueIndexes(true);
 
 #if 0
    QueueIndexes(true);
 
 #if 0


@@ -1696,7 +1997,7 @@ void pkgAcqMetaIndex::AuthDone(string Message)                            /*{{{*/
 #endif
 }
                                                                        /*}}}*/
 #endif
 }
                                                                        /*}}}*/

-void pkgAcqMetaIndex::QueueIndexes(bool verify)                                /*{{{*/
+void pkgAcqMetaBase::QueueIndexes(bool verify)                         /*{{{*/

 {
    bool transInRelease = false;
    {
 {
    bool transInRelease = false;
    {


@@ -1874,29 +2175,44 @@ void pkgAcqMetaIndex::Failed(string Message,
          return;
    }
 
          return;
    }
 

-   /* Always move the meta index, even if gpgv failed. This ensures
-    * that PackageFile objects are correctly filled in */
-   if (FileExists(DestFile)) {
-      string FinalFile = _config->FindDir("Dir::State::lists");
-      FinalFile += URItoFileName(RealURI);
-      /* InRelease files become Release files, otherwise
-       * they would be considered as trusted later on */
-      if (SigFile == DestFile) {
-        RealURI = RealURI.replace(RealURI.rfind("InRelease"), 9,
-                                      "Release");
-        FinalFile = FinalFile.replace(FinalFile.rfind("InRelease"), 9,
-                                      "Release");
-        SigFile = FinalFile;
-      }
-
-      // Done, queue for rename on transaction finished
-      PartialFile = DestFile;
-      DestFile = FinalFile;
-   }
+   _error->Warning(_("The data from '%s' is not signed. Packages "
+                     "from that repository can not be authenticated."),
+                   URIDesc.c_str());

 
    // No Release file was present, or verification failed, so fall
    // back to queueing Packages files without verification
 
    // No Release file was present, or verification failed, so fall
    // back to queueing Packages files without verification

-   QueueIndexes(false);
+   // only allow going further if the users explicitely wants it
+   if(_config->FindB("Acquire::AllowInsecureRepositories") == true)
+   {
+      /* Always move the meta index, even if gpgv failed. This ensures
+       * that PackageFile objects are correctly filled in */
+      if (FileExists(DestFile)) 
+      {
+         string FinalFile = _config->FindDir("Dir::State::lists");
+         FinalFile += URItoFileName(RealURI);
+         /* InRelease files become Release files, otherwise
+          * they would be considered as trusted later on */
+         if (SigFile == DestFile) {
+            RealURI = RealURI.replace(RealURI.rfind("InRelease"), 9,
+                                      "Release");
+            FinalFile = FinalFile.replace(FinalFile.rfind("InRelease"), 9,
+                                          "Release");
+            SigFile = FinalFile;
+         }
+
+         // Done, queue for rename on transaction finished
+         TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
+      }
+
+      QueueIndexes(false);
+   } else {
+      // warn if the repository is unsinged
+      _error->Warning("Use --allow-insecure-repositories to force the update");
+      TransactionManager->AbortTransaction();
+      Status = StatError;
+      return;
+   } 
+

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


@@ -1980,7 +2296,8 @@ void pkgAcqMetaClearSig::Done(std::string Message,unsigned long long Size,
    if (FileExists(DestFile) && !StartsWithGPGClearTextSignature(DestFile))
    {
       pkgAcquire::Item::Failed(Message, Cnf);
    if (FileExists(DestFile) && !StartsWithGPGClearTextSignature(DestFile))
    {
       pkgAcquire::Item::Failed(Message, Cnf);

-      ErrorText = _("Does not start with a cleartext signature");
+      RenameOnError(NotClearsigned);
+      TransactionManager->AbortTransaction();

       return;
    }
    pkgAcqMetaIndex::Done(Message, Size, Hashes, Cnf);
       return;
    }
    pkgAcqMetaIndex::Done(Message, Size, Hashes, Cnf);


@@ -1998,8 +2315,7 @@ void pkgAcqMetaClearSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf) /*
       // impression (CVE-2012-0214)
       string FinalFile = _config->FindDir("Dir::State::lists");
       FinalFile.append(URItoFileName(RealURI));
       // impression (CVE-2012-0214)
       string FinalFile = _config->FindDir("Dir::State::lists");
       FinalFile.append(URItoFileName(RealURI));

-      PartialFile = "";
-      DestFile = FinalFile;
+      TransactionManager->TransactionStageRemoval(this, FinalFile);

 
       new pkgAcqMetaIndex(Owner, TransactionManager,
                        MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
 
       new pkgAcqMetaIndex(Owner, TransactionManager,
                        MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,