]> git.saurik.com Git - apt.git/blobdiff - apt-pkg/acquire-item.cc
drop explicit check for EWOULDBLOCK if it has the same value as EAGAIN
[apt.git] / apt-pkg / acquire-item.cc
index 65c260f3a671924a89321fb0bcb11fa8122001b1..446551cc2ee1a7c8bf38fa7d00599f27c91b2e60 100644 (file)
 #include <apt-pkg/error.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/fileutl.h>
-#include <apt-pkg/sha1.h>
 #include <apt-pkg/tagfile.h>
-#include <apt-pkg/indexrecords.h>
+#include <apt-pkg/metaindex.h>
 #include <apt-pkg/acquire.h>
 #include <apt-pkg/hashes.h>
 #include <apt-pkg/indexfile.h>
 #include <apt-pkg/pkgcache.h>
 #include <apt-pkg/cacheiterators.h>
 #include <apt-pkg/pkgrecords.h>
+#include <apt-pkg/gpgv.h>
 
+#include <algorithm>
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <errno.h>
 #include <string>
-#include <sstream>
 #include <stdio.h>
 #include <ctime>
-#include <sys/types.h>
-#include <pwd.h>
-#include <grp.h>
+#include <sstream>
 
 #include <apti18n.h>
                                                                        /*}}}*/
@@ -65,69 +63,497 @@ static void printHashSumComparision(std::string const &URI, HashStringList const
       std::cerr <<  "\t- " << hs->toStr() << std::endl;
 }
                                                                        /*}}}*/
-static void ChangeOwnerAndPermissionOfFile(char const * const requester, char const * const file, char const * const user, char const * const group, mode_t const mode)
-{
-   // ensure the file is owned by root and has good permissions
-   struct passwd const * const pw = getpwnam(user);
-   struct group const * const gr = getgrnam(group);
-   if (getuid() == 0) // if we aren't root, we can't chown, so don't try it
-   {
-      if (pw != NULL && gr != NULL && chown(file, pw->pw_uid, gr->gr_gid) != 0)
-        _error->WarningE(requester, "chown to %s:%s of file %s failed", user, group, file);
-   }
-   if (chmod(file, mode) != 0)
-      _error->WarningE(requester, "chmod 0%o of file %s failed", mode, file);
-}
-static std::string GetPartialFileName(std::string const &file)
+static std::string GetPartialFileName(std::string const &file)         /*{{{*/
 {
    std::string DestFile = _config->FindDir("Dir::State::lists") + "partial/";
    DestFile += file;
    return DestFile;
 }
-static std::string GetPartialFileNameFromURI(std::string const &uri)
+                                                                       /*}}}*/
+static std::string GetPartialFileNameFromURI(std::string const &uri)   /*{{{*/
 {
    return GetPartialFileName(URItoFileName(uri));
 }
+                                                                       /*}}}*/
+static std::string GetFinalFileNameFromURI(std::string const &uri)     /*{{{*/
+{
+   return _config->FindDir("Dir::State::lists") + URItoFileName(uri);
+}
+                                                                       /*}}}*/
+static std::string GetKeepCompressedFileName(std::string file, IndexTarget const &Target)/*{{{*/
+{
+   if (Target.KeepCompressed == false)
+      return file;
+
+   std::string const KeepCompressedAs = Target.Option(IndexTarget::KEEPCOMPRESSEDAS);
+   if (KeepCompressedAs.empty() == false)
+   {
+      std::string const ext = KeepCompressedAs.substr(0, KeepCompressedAs.find(' '));
+      if (ext != "uncompressed")
+        file.append(".").append(ext);
+   }
+   return file;
+}
+                                                                       /*}}}*/
+static std::string GetMergeDiffsPatchFileName(std::string const &Final, std::string const &Patch)/*{{{*/
+{
+   // rred expects the patch as $FinalFile.ed.$patchname.gz
+   return Final + ".ed." + Patch + ".gz";
+}
+                                                                       /*}}}*/
+static std::string GetDiffsPatchFileName(std::string const &Final)     /*{{{*/
+{
+   // rred expects the patch as $FinalFile.ed
+   return Final + ".ed";
+}
+                                                                       /*}}}*/
+static std::string GetExistingFilename(std::string const &File)                /*{{{*/
+{
+   if (RealFileExists(File))
+      return File;
+   for (auto const &type : APT::Configuration::getCompressorExtensions())
+   {
+      std::string const Final = File + type;
+      if (RealFileExists(Final))
+        return Final;
+   }
+   return "";
+}
+                                                                       /*}}}*/
+
+static bool MessageInsecureRepository(bool const isError, std::string const &msg)/*{{{*/
+{
+   if (isError)
+   {
+      _error->Error("%s", msg.c_str());
+      _error->Notice("%s", _("Updating from such a repository can't be done securely, and is therefore disabled by default."));
+   }
+   else
+   {
+      _error->Warning("%s", msg.c_str());
+      _error->Notice("%s", _("Data from such a repository can't be authenticated and is therefore potentially dangerous to use."));
+   }
+   _error->Notice("%s", _("See apt-secure(8) manpage for repository creation and user configuration details."));
+   return false;
+}
+static bool MessageInsecureRepository(bool const isError, char const * const msg, std::string const &repo)
+{
+   std::string m;
+   strprintf(m, msg, repo.c_str());
+   return MessageInsecureRepository(isError, m);
+}
+                                                                       /*}}}*/
+static bool AllowInsecureRepositories(char const * const msg, std::string const &repo,/*{{{*/
+      metaIndex const * const MetaIndexParser, pkgAcqMetaClearSig * const TransactionManager, pkgAcquire::Item * const I)
+{
+   if(MetaIndexParser->GetTrusted() == metaIndex::TRI_YES)
+      return true;
+
+   if (_config->FindB("Acquire::AllowInsecureRepositories") == true)
+   {
+      MessageInsecureRepository(false, msg, repo);
+      return true;
+   }
+
+   MessageInsecureRepository(true, msg, repo);
+   TransactionManager->AbortTransaction();
+   I->Status = pkgAcquire::Item::StatError;
+   return false;
+}
+                                                                       /*}}}*/
+static HashStringList GetExpectedHashesFromFor(metaIndex * const Parser, std::string const &MetaKey)/*{{{*/
+{
+   if (Parser == NULL)
+      return HashStringList();
+   metaIndex::checkSum * const R = Parser->Lookup(MetaKey);
+   if (R == NULL)
+      return HashStringList();
+   return R->Hashes;
+}
+                                                                       /*}}}*/
+
+// all ::HashesRequired and ::GetExpectedHashes implementations                /*{{{*/
+/* ::GetExpectedHashes is abstract and has to be implemented by all subclasses.
+   It is best to implement it as broadly as possible, while ::HashesRequired defaults
+   to true and should be as restrictive as possible for false cases. Note that if
+   a hash is returned by ::GetExpectedHashes it must match. Only if it doesn't
+   ::HashesRequired is called to evaluate if its okay to have no hashes. */
+APT_CONST bool pkgAcqTransactionItem::HashesRequired() const
+{
+   /* signed repositories obviously have a parser and good hashes.
+      unsigned repositories, too, as even if we can't trust them for security,
+      we can at least trust them for integrity of the download itself.
+      Only repositories without a Release file can (obviously) not have
+      hashes – and they are very uncommon and strongly discouraged */
+   return TransactionManager->MetaIndexParser != NULL &&
+      TransactionManager->MetaIndexParser->GetLoadedSuccessfully() == metaIndex::TRI_YES;
+}
+HashStringList pkgAcqTransactionItem::GetExpectedHashes() const
+{
+   return GetExpectedHashesFor(GetMetaKey());
+}
+
+APT_CONST bool pkgAcqMetaBase::HashesRequired() const
+{
+   // Release and co have no hashes 'by design'.
+   return false;
+}
+HashStringList pkgAcqMetaBase::GetExpectedHashes() const
+{
+   return HashStringList();
+}
+
+APT_CONST bool pkgAcqIndexDiffs::HashesRequired() const
+{
+   /* We don't always have the diff of the downloaded pdiff file.
+      What we have for sure is hashes for the uncompressed file,
+      but rred uncompresses them on the fly while parsing, so not handled here.
+      Hashes are (also) checked while searching for (next) patch to apply. */
+   if (State == StateFetchDiff)
+      return available_patches[0].download_hashes.empty() == false;
+   return false;
+}
+HashStringList pkgAcqIndexDiffs::GetExpectedHashes() const
+{
+   if (State == StateFetchDiff)
+      return available_patches[0].download_hashes;
+   return HashStringList();
+}
+
+APT_CONST bool pkgAcqIndexMergeDiffs::HashesRequired() const
+{
+   /* @see #pkgAcqIndexDiffs::HashesRequired, with the difference that
+      we can check the rred result after all patches are applied as
+      we know the expected result rather than potentially apply more patches */
+   if (State == StateFetchDiff)
+      return patch.download_hashes.empty() == false;
+   return State == StateApplyDiff;
+}
+HashStringList pkgAcqIndexMergeDiffs::GetExpectedHashes() const
+{
+   if (State == StateFetchDiff)
+      return patch.download_hashes;
+   else if (State == StateApplyDiff)
+      return GetExpectedHashesFor(Target.MetaKey);
+   return HashStringList();
+}
+
+APT_CONST bool pkgAcqArchive::HashesRequired() const
+{
+   return LocalSource == false;
+}
+HashStringList pkgAcqArchive::GetExpectedHashes() const
+{
+   // figured out while parsing the records
+   return ExpectedHashes;
+}
+
+APT_CONST bool pkgAcqFile::HashesRequired() const
+{
+   // supplied as parameter at creation time, so the caller decides
+   return ExpectedHashes.usable();
+}
+HashStringList pkgAcqFile::GetExpectedHashes() const
+{
+   return ExpectedHashes;
+}
+                                                                       /*}}}*/
+// Acquire::Item::QueueURI and specialisations from child classes      /*{{{*/
+bool pkgAcquire::Item::QueueURI(pkgAcquire::ItemDesc &Item)
+{
+   Owner->Enqueue(Item);
+   return true;
+}
+/* The idea here is that an item isn't queued if it exists on disk and the
+   transition manager was a hit as this means that the files it contains
+   the checksums for can't be updated either (or they are and we are asking
+   for a hashsum mismatch to happen which helps nobody) */
+bool pkgAcqTransactionItem::QueueURI(pkgAcquire::ItemDesc &Item)
+{
+   std::string const FinalFile = GetFinalFilename();
+   if (TransactionManager != NULL && TransactionManager->IMSHit == true &&
+        FileExists(FinalFile) == true)
+   {
+      PartialFile = DestFile = FinalFile;
+      Status = StatDone;
+      return false;
+   }
+   return pkgAcquire::Item::QueueURI(Item);
+}
+/* The transition manager InRelease itself (or its older sisters-in-law
+   Release & Release.gpg) is always queued as this allows us to rerun gpgv
+   on it to verify that we aren't stalled with old files */
+bool pkgAcqMetaBase::QueueURI(pkgAcquire::ItemDesc &Item)
+{
+   return pkgAcquire::Item::QueueURI(Item);
+}
+/* the Diff/Index needs to queue also the up-to-date complete index file
+   to ensure that the list cleaner isn't eating it */
+bool pkgAcqDiffIndex::QueueURI(pkgAcquire::ItemDesc &Item)
+{
+   if (pkgAcqTransactionItem::QueueURI(Item) == true)
+      return true;
+   QueueOnIMSHit();
+   return false;
+}
+                                                                       /*}}}*/
+// Acquire::Item::GetFinalFilename and specialisations for child classes       /*{{{*/
+std::string pkgAcquire::Item::GetFinalFilename() const
+{
+   return GetFinalFileNameFromURI(Desc.URI);
+}
+std::string pkgAcqDiffIndex::GetFinalFilename() const
+{
+   // the logic we inherent from pkgAcqBaseIndex isn't what we need here
+   return pkgAcquire::Item::GetFinalFilename();
+}
+std::string pkgAcqIndex::GetFinalFilename() const
+{
+   std::string const FinalFile = GetFinalFileNameFromURI(Target.URI);
+   return GetKeepCompressedFileName(FinalFile, Target);
+}
+std::string pkgAcqMetaSig::GetFinalFilename() const
+{
+   return GetFinalFileNameFromURI(Target.URI);
+}
+std::string pkgAcqBaseIndex::GetFinalFilename() const
+{
+   return GetFinalFileNameFromURI(Target.URI);
+}
+std::string pkgAcqMetaBase::GetFinalFilename() const
+{
+   return GetFinalFileNameFromURI(Target.URI);
+}
+std::string pkgAcqArchive::GetFinalFilename() const
+{
+   return _config->FindDir("Dir::Cache::Archives") + flNotDir(StoreFilename);
+}
+                                                                       /*}}}*/
+// pkgAcqTransactionItem::GetMetaKey and specialisations for child classes     /*{{{*/
+std::string pkgAcqTransactionItem::GetMetaKey() const
+{
+   return Target.MetaKey;
+}
+std::string pkgAcqIndex::GetMetaKey() const
+{
+   if (Stage == STAGE_DECOMPRESS_AND_VERIFY || CurrentCompressionExtension == "uncompressed")
+      return Target.MetaKey;
+   return Target.MetaKey + "." + CurrentCompressionExtension;
+}
+std::string pkgAcqDiffIndex::GetMetaKey() const
+{
+   return Target.MetaKey + ".diff/Index";
+}
+                                                                       /*}}}*/
+//pkgAcqTransactionItem::TransactionState and specialisations for child classes        /*{{{*/
+bool pkgAcqTransactionItem::TransactionState(TransactionStates const state)
+{
+   bool const Debug = _config->FindB("Debug::Acquire::Transaction", false);
+   switch(state)
+   {
+      case TransactionAbort:
+        if(Debug == true)
+           std::clog << "  Cancel: " << DestFile << std::endl;
+        if (Status == pkgAcquire::Item::StatIdle)
+        {
+           Status = pkgAcquire::Item::StatDone;
+           Dequeue();
+        }
+        break;
+      case TransactionCommit:
+        if(PartialFile.empty() == false)
+        {
+           bool sameFile = (PartialFile == DestFile);
+           // we use symlinks on IMS-Hit to avoid copies
+           if (RealFileExists(DestFile))
+           {
+              struct stat Buf;
+              if (lstat(PartialFile.c_str(), &Buf) != -1)
+              {
+                 if (S_ISLNK(Buf.st_mode) && Buf.st_size > 0)
+                 {
+                    char partial[Buf.st_size + 1];
+                    ssize_t const sp = readlink(PartialFile.c_str(), partial, Buf.st_size);
+                    if (sp == -1)
+                       _error->Errno("pkgAcqTransactionItem::TransactionState-sp", _("Failed to readlink %s"), PartialFile.c_str());
+                    else
+                    {
+                       partial[sp] = '\0';
+                       sameFile = (DestFile == partial);
+                    }
+                 }
+              }
+              else
+                 _error->Errno("pkgAcqTransactionItem::TransactionState-stat", _("Failed to stat %s"), PartialFile.c_str());
+           }
+           if (sameFile == false)
+           {
+              // ensure that even without lists-cleanup all compressions are nuked
+              std::string FinalFile = GetFinalFileNameFromURI(Target.URI);
+              if (FileExists(FinalFile))
+              {
+                 if(Debug == true)
+                    std::clog << "rm " << FinalFile << " # " << DescURI() << std::endl;
+                 if (RemoveFile("TransactionStates-Cleanup", FinalFile) == false)
+                    return false;
+              }
+              for (auto const &ext: APT::Configuration::getCompressorExtensions())
+              {
+                 auto const Final = FinalFile + ext;
+                 if (FileExists(Final))
+                 {
+                    if(Debug == true)
+                       std::clog << "rm " << Final << " # " << DescURI() << std::endl;
+                    if (RemoveFile("TransactionStates-Cleanup", Final) == false)
+                       return false;
+                 }
+              }
+              if(Debug == true)
+                 std::clog << "mv " << PartialFile << " -> "<< DestFile << " # " << DescURI() << std::endl;
+              if (Rename(PartialFile, DestFile) == false)
+                 return false;
+           }
+           else if(Debug == true)
+              std::clog << "keep " << PartialFile << " # " << DescURI() << std::endl;
+
+        } else {
+           if(Debug == true)
+              std::clog << "rm " << DestFile << " # " << DescURI() << std::endl;
+           if (RemoveFile("TransactionCommit", DestFile) == false)
+              return false;
+        }
+        break;
+   }
+   return true;
+}
+bool pkgAcqMetaBase::TransactionState(TransactionStates const state)
+{
+   // Do not remove InRelease on IMSHit of Release.gpg [yes, this is very edgecasey]
+   if (TransactionManager->IMSHit == false)
+      return pkgAcqTransactionItem::TransactionState(state);
+   return true;
+}
+bool pkgAcqIndex::TransactionState(TransactionStates const state)
+{
+   if (pkgAcqTransactionItem::TransactionState(state) == false)
+      return false;
+
+   switch (state)
+   {
+      case TransactionAbort:
+        if (Stage == STAGE_DECOMPRESS_AND_VERIFY)
+        {
+           // keep the compressed file, but drop the decompressed
+           EraseFileName.clear();
+           if (PartialFile.empty() == false && flExtension(PartialFile) != CurrentCompressionExtension)
+              RemoveFile("TransactionAbort", PartialFile);
+        }
+        break;
+      case TransactionCommit:
+        if (EraseFileName.empty() == false)
+           RemoveFile("TransactionCommit", EraseFileName);
+        break;
+   }
+   return true;
+}
+bool pkgAcqDiffIndex::TransactionState(TransactionStates const state)
+{
+   if (pkgAcqTransactionItem::TransactionState(state) == false)
+      return false;
+
+   switch (state)
+   {
+      case TransactionCommit:
+        break;
+      case TransactionAbort:
+        std::string const Partial = GetPartialFileNameFromURI(Target.URI);
+        RemoveFile("TransactionAbort", Partial);
+        break;
+   }
+
+   return true;
+}
+                                                                       /*}}}*/
+
+class APT_HIDDEN NoActionItem : public pkgAcquire::Item                        /*{{{*/
+/* The sole purpose of this class is having an item which does nothing to
+   reach its done state to prevent cleanup deleting the mentioned file.
+   Handy in cases in which we know we have the file already, like IMS-Hits. */
+{
+   IndexTarget const Target;
+   public:
+   virtual std::string DescURI() const APT_OVERRIDE {return Target.URI;};
+   virtual HashStringList GetExpectedHashes()  const APT_OVERRIDE {return HashStringList();};
 
+   NoActionItem(pkgAcquire * const Owner, IndexTarget const &Target) :
+      pkgAcquire::Item(Owner), Target(Target)
+   {
+      Status = StatDone;
+      DestFile = GetFinalFileNameFromURI(Target.URI);
+   }
+   NoActionItem(pkgAcquire * const Owner, IndexTarget const &Target, std::string const &FinalFile) :
+      pkgAcquire::Item(Owner), Target(Target)
+   {
+      Status = StatDone;
+      DestFile = FinalFile;
+   }
+};
+                                                                       /*}}}*/
 
 // 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)
-   : Owner(Owner), FileSize(0), PartialSize(0), Mode(0), ID(0), Complete(false),
-     Local(false), QueueCounter(0), TransactionManager(TransactionManager),
-     ExpectedAdditionalItems(0), ExpectedHashes(ExpectedHashes)
+APT_IGNORE_DEPRECATED_PUSH
+pkgAcquire::Item::Item(pkgAcquire * const owner) :
+   FileSize(0), PartialSize(0), Mode(0), ID(0), Complete(false), Local(false),
+    QueueCounter(0), ExpectedAdditionalItems(0), Owner(owner), d(NULL)
 {
    Owner->Add(this);
    Status = StatIdle;
-   if(TransactionManager != NULL)
-      TransactionManager->Add(this);
 }
-#if __GNUC__ >= 4
-       #pragma GCC diagnostic pop
-#endif
+APT_IGNORE_DEPRECATED_POP
                                                                        /*}}}*/
 // Acquire::Item::~Item - Destructor                                   /*{{{*/
-// ---------------------------------------------------------------------
-/* */
 pkgAcquire::Item::~Item()
 {
    Owner->Remove(this);
 }
                                                                        /*}}}*/
+std::string pkgAcquire::Item::Custom600Headers() const                 /*{{{*/
+{
+   return std::string();
+}
+                                                                       /*}}}*/
+std::string pkgAcquire::Item::ShortDesc() const                                /*{{{*/
+{
+   return DescURI();
+}
+                                                                       /*}}}*/
+APT_CONST void pkgAcquire::Item::Finished()                            /*{{{*/
+{
+}
+                                                                       /*}}}*/
+APT_PURE pkgAcquire * pkgAcquire::Item::GetOwner() const               /*{{{*/
+{
+   return Owner;
+}
+                                                                       /*}}}*/
+APT_CONST pkgAcquire::ItemDesc &pkgAcquire::Item::GetItemDesc()                /*{{{*/
+{
+   return Desc;
+}
+                                                                       /*}}}*/
+APT_CONST bool pkgAcquire::Item::IsTrusted() const                     /*{{{*/
+{
+   return false;
+}
+                                                                       /*}}}*/
 // Acquire::Item::Failed - Item failed to download                     /*{{{*/
 // ---------------------------------------------------------------------
 /* We return to an idle state if there are still other queues that could
    fetch this object */
-void pkgAcquire::Item::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
+void pkgAcquire::Item::Failed(string const &Message,pkgAcquire::MethodConfig const * const Cnf)
 {
-   if(ErrorText == "")
+   if(ErrorText.empty())
       ErrorText = LookupTag(Message,"Message");
-   UsedMirror =  LookupTag(Message,"UsedMirror");
    if (QueueCounter <= 1)
    {
       /* This indicates that the file is not available right now but might
@@ -141,53 +567,80 @@ void pkgAcquire::Item::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
         return;
       }
 
-      Status = StatError;
+      switch (Status)
+      {
+        case StatIdle:
+        case StatFetching:
+        case StatDone:
+           Status = StatError;
+           break;
+        case StatAuthError:
+        case StatError:
+        case StatTransientNetworkError:
+           break;
+      }
       Complete = false;
       Dequeue();
    }
-   else
-      Status = StatIdle;
 
-   // check fail reason
-   string FailReason = LookupTag(Message, "FailReason");
-   if(FailReason == "MaximumSizeExceeded")
-      Rename(DestFile, DestFile+".FAILED");
+   string const FailReason = LookupTag(Message, "FailReason");
+   if (FailReason == "MaximumSizeExceeded")
+      RenameOnError(MaximumSizeExceeded);
+   else if (Status == StatAuthError)
+      RenameOnError(HashSumMismatch);
 
    // report mirror failure back to LP if we actually use a mirror
-   if(FailReason.size() != 0)
+   if (FailReason.empty() == false)
       ReportMirrorFailure(FailReason);
    else
       ReportMirrorFailure(ErrorText);
+
+   if (QueueCounter > 1)
+      Status = StatIdle;
 }
                                                                        /*}}}*/
 // Acquire::Item::Start - Item has begun to download                   /*{{{*/
 // ---------------------------------------------------------------------
-/* Stash status and the file size. Note that setting Complete means 
+/* Stash status and the file size. Note that setting Complete means
    sub-phases of the acquire process such as decompresion are operating */
-void pkgAcquire::Item::Start(string /*Message*/,unsigned long long Size)
+void pkgAcquire::Item::Start(string const &/*Message*/, unsigned long long const Size)
 {
    Status = StatFetching;
+   ErrorText.clear();
    if (FileSize == 0 && Complete == false)
       FileSize = Size;
 }
                                                                        /*}}}*/
-// Acquire::Item::Done - Item downloaded OK                            /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-void pkgAcquire::Item::Done(string Message,unsigned long long Size,HashStringList const &/*Hash*/,
-                           pkgAcquire::MethodConfig * /*Cnf*/)
+// Acquire::Item::VerifyDone - check if Item was downloaded OK         /*{{{*/
+/* Note that hash-verification is 'hardcoded' in acquire-worker and has
+ * already passed if this method is called. */
+bool pkgAcquire::Item::VerifyDone(std::string const &Message,
+        pkgAcquire::MethodConfig const * const /*Cnf*/)
 {
-   // We just downloaded something..
-   string FileName = LookupTag(Message,"Filename");
-   UsedMirror = LookupTag(Message,"UsedMirror");
-   if (Complete == false && !Local && FileName == DestFile)
+   std::string const FileName = LookupTag(Message,"Filename");
+   if (FileName.empty() == true)
    {
-      if (Owner->Log != 0)
-        Owner->Log->Fetched(Size,atoi(LookupTag(Message,"Resume-Point","0").c_str()));
+      Status = StatError;
+      ErrorText = "Method gave a blank filename";
+      return false;
    }
 
+   return true;
+}
+                                                                       /*}}}*/
+// Acquire::Item::Done - Item downloaded OK                            /*{{{*/
+void pkgAcquire::Item::Done(string const &/*Message*/, HashStringList const &Hashes,
+                           pkgAcquire::MethodConfig const * const /*Cnf*/)
+{
+   // We just downloaded something..
    if (FileSize == 0)
-      FileSize= Size;
+   {
+      unsigned long long const downloadedSize = Hashes.FileSize();
+      if (downloadedSize != 0)
+      {
+        FileSize = downloadedSize;
+      }
+   }
    Status = StatDone;
    ErrorText = string();
    Owner->Dequeue(this);
@@ -197,82 +650,79 @@ 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 */
-bool pkgAcquire::Item::Rename(string From,string To)
+bool pkgAcquire::Item::Rename(string const &From,string const &To)
 {
-   if (rename(From.c_str(),To.c_str()) != 0)
-   {
-      char S[300];
-      snprintf(S,sizeof(S),_("rename failed, %s (%s -> %s)."),strerror(errno),
-             From.c_str(),To.c_str());
-      Status = StatError;
-      ErrorText += S;
-      return false;
-   }   
-   return true;
-}
-                                                                       /*}}}*/
+   if (From == To || rename(From.c_str(),To.c_str()) == 0)
+      return true;
 
-void pkgAcquire::Item::QueueURI(ItemDesc &Item)
-{
-   if (RealFileExists(DestFile))
-      ChangeOwnerAndPermissionOfFile("GetPartialFileName", DestFile.c_str(), "_apt", "root", 0600);
-   Owner->Enqueue(Item);
+   std::string S;
+   strprintf(S, _("rename failed, %s (%s -> %s)."), strerror(errno),
+        From.c_str(),To.c_str());
+   Status = StatError;
+   if (ErrorText.empty())
+      ErrorText = S;
+   else
+      ErrorText = ErrorText + ": " + S;
+   return false;
 }
-void pkgAcquire::Item::Dequeue()
+                                                                       /*}}}*/
+void pkgAcquire::Item::Dequeue()                                       /*{{{*/
 {
    Owner->Dequeue(this);
 }
-
+                                                                       /*}}}*/
 bool pkgAcquire::Item::RenameOnError(pkgAcquire::Item::RenameOnErrorState const error)/*{{{*/
 {
-   if(FileExists(DestFile))
+   if (RealFileExists(DestFile))
       Rename(DestFile, DestFile + ".FAILED");
 
+   std::string errtext;
    switch (error)
    {
       case HashSumMismatch:
-        ErrorText = _("Hash Sum mismatch");
+        errtext = _("Hash Sum mismatch");
         Status = StatAuthError;
         ReportMirrorFailure("HashChecksumFailure");
         break;
       case SizeMismatch:
-        ErrorText = _("Size mismatch");
+        errtext = _("Size mismatch");
         Status = StatAuthError;
         ReportMirrorFailure("SizeFailure");
         break;
       case InvalidFormat:
-        ErrorText = _("Invalid file format");
+        errtext = _("Invalid file format");
         Status = StatError;
         // do not report as usually its not the mirrors fault, but Portal/Proxy
         break;
       case SignatureError:
-        ErrorText = _("Signature error");
+        errtext = _("Signature error");
         Status = StatError;
         break;
       case NotClearsigned:
-         ErrorText = _("Does not start with a cleartext signature");
+        strprintf(errtext, _("Clearsigned file isn't valid, got '%s' (does the network require authentication?)"), "NOSPLIT");
+        Status = StatAuthError;
+        break;
+      case MaximumSizeExceeded:
+        // the method is expected to report a good error for this
         Status = StatError;
         break;
+      case PDiffError:
+        // no handling here, done by callers
+        break;
    }
+   if (ErrorText.empty())
+      ErrorText = errtext;
    return false;
 }
                                                                        /*}}}*/
 void pkgAcquire::Item::SetActiveSubprocess(const std::string &subprocess)/*{{{*/
 {
       ActiveSubprocess = subprocess;
-#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
+      APT_IGNORE_DEPRECATED(Mode = ActiveSubprocess.c_str();)
 }
                                                                        /*}}}*/
 // Acquire::Item::ReportMirrorFailure                                  /*{{{*/
-// ---------------------------------------------------------------------
-void pkgAcquire::Item::ReportMirrorFailure(string FailCode)
+void pkgAcquire::Item::ReportMirrorFailure(string const &FailCode)
 {
    // we only act if a mirror was used at all
    if(UsedMirror.empty())
@@ -284,2036 +734,2067 @@ void pkgAcquire::Item::ReportMirrorFailure(string FailCode)
             << " FailCode: " 
             << FailCode << std::endl;
 #endif
-   const char *Args[40];
-   unsigned int i = 0;
    string report = _config->Find("Methods::Mirror::ProblemReporting", 
                                 "/usr/lib/apt/apt-report-mirror-failure");
    if(!FileExists(report))
       return;
-   Args[i++] = report.c_str();
-   Args[i++] = UsedMirror.c_str();
-   Args[i++] = DescURI().c_str();
-   Args[i++] = FailCode.c_str();
-   Args[i++] = NULL;
+
+   std::vector<char const*> Args;
+   Args.push_back(report.c_str());
+   Args.push_back(UsedMirror.c_str());
+   Args.push_back(DescURI().c_str());
+   Args.push_back(FailCode.c_str());
+   Args.push_back(NULL);
+
    pid_t pid = ExecFork();
-   if(pid < 0) 
+   if(pid < 0)
    {
       _error->Error("ReportMirrorFailure Fork failed");
       return;
    }
-   else if(pid == 0) 
+   else if(pid == 0)
    {
-      execvp(Args[0], (char**)Args);
+      execvp(Args[0], (char**)Args.data());
       std::cerr << "Could not exec " << Args[0] << std::endl;
       _exit(100);
    }
-   if(!ExecWait(pid, "report-mirror-failure")) 
+   if(!ExecWait(pid, "report-mirror-failure"))
    {
       _error->Warning("Couldn't report problem to '%s'",
                      _config->Find("Methods::Mirror::ProblemReporting").c_str());
    }
 }
                                                                        /*}}}*/
-// AcqDiffIndex::AcqDiffIndex - Constructor                            /*{{{*/
-// ---------------------------------------------------------------------
-/* Get the DiffIndex file first and see if there are patches available
- * If so, create a pkgAcqIndexDiffs fetcher that will get and apply the
- * patches. If anything goes wrong in that process, it will fall back to
- * the original packages file
- */
-pkgAcqDiffIndex::pkgAcqDiffIndex(pkgAcquire *Owner,
-                                 pkgAcqMetaBase *TransactionManager,
-                                 IndexTarget const * const Target,
-                                HashStringList const &ExpectedHashes,
-                                 indexRecords *MetaIndexParser)
-   : pkgAcqBaseIndex(Owner, TransactionManager, Target, ExpectedHashes, 
-                     MetaIndexParser), PackagesFileReadyInPartial(false)
+std::string pkgAcquire::Item::HashSum() const                          /*{{{*/
 {
-   
-   Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
-
-   RealURI = Target->URI;
-   Desc.Owner = this;
-   Desc.Description = Target->Description + ".diff/Index";
-   Desc.ShortDesc = Target->ShortDesc;
-   Desc.URI = Target->URI + ".diff/Index";
-
-   DestFile = GetPartialFileNameFromURI(Desc.URI);
+   HashStringList const hashes = GetExpectedHashes();
+   HashString const * const hs = hashes.find(NULL);
+   return hs != NULL ? hs->toStr() : "";
+}
+                                                                       /*}}}*/
 
-   if(Debug)
-      std::clog << "pkgAcqDiffIndex: " << Desc.URI << std::endl;
+pkgAcqTransactionItem::pkgAcqTransactionItem(pkgAcquire * const Owner, /*{{{*/
+      pkgAcqMetaClearSig * const transactionManager, IndexTarget const &target) :
+   pkgAcquire::Item(Owner), d(NULL), Target(target), TransactionManager(transactionManager)
+{
+   if (TransactionManager != this)
+      TransactionManager->Add(this);
+}
+                                                                       /*}}}*/
+pkgAcqTransactionItem::~pkgAcqTransactionItem()                                /*{{{*/
+{
+}
+                                                                       /*}}}*/
+HashStringList pkgAcqTransactionItem::GetExpectedHashesFor(std::string const &MetaKey) const   /*{{{*/
+{
+   return GetExpectedHashesFromFor(TransactionManager->MetaIndexParser, MetaKey);
+}
+                                                                       /*}}}*/
 
-   // look for the current package file
-   CurrentPackagesFile = _config->FindDir("Dir::State::lists");
-   CurrentPackagesFile += URItoFileName(RealURI);
+// AcqMetaBase - Constructor                                           /*{{{*/
+pkgAcqMetaBase::pkgAcqMetaBase(pkgAcquire * const Owner,
+      pkgAcqMetaClearSig * const TransactionManager,
+      std::vector<IndexTarget> const &IndexTargets,
+      IndexTarget const &DataTarget)
+: pkgAcqTransactionItem(Owner, TransactionManager, DataTarget), d(NULL),
+   IndexTargets(IndexTargets),
+   AuthPass(false), IMSHit(false)
+{
+}
+                                                                       /*}}}*/
+// AcqMetaBase::Add - Add a item to the current Transaction            /*{{{*/
+void pkgAcqMetaBase::Add(pkgAcqTransactionItem * const 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;
 
-   // FIXME: this file:/ check is a hack to prevent fetching
-   //        from local sources. this is really silly, and
-   //        should be fixed cleanly as soon as possible
-   if(!FileExists(CurrentPackagesFile) || 
-      Desc.URI.substr(0,strlen("file:/")) == "file:/")
+   // ensure the toplevel is in error state too
+   for (std::vector<pkgAcqTransactionItem*>::iterator I = Transaction.begin();
+        I != Transaction.end(); ++I)
    {
-      // we don't have a pkg file or we don't want to queue
-      Failed("No index file, local or canceld by user", NULL);
-      return;
+      (*I)->TransactionState(TransactionAbort);
    }
+   Transaction.clear();
+}
+                                                                       /*}}}*/
+// AcqMetaBase::TransactionHasError - Check for errors in Transaction  /*{{{*/
+APT_PURE bool pkgAcqMetaBase::TransactionHasError() const
+{
+   for (std::vector<pkgAcqTransactionItem*>::const_iterator I = Transaction.begin();
+        I != Transaction.end(); ++I)
+   {
+      switch((*I)->Status) {
+        case StatDone: break;
+        case StatIdle: break;
+        case StatAuthError: return true;
+        case StatError: return true;
+        case StatTransientNetworkError: return true;
+        case StatFetching: break;
+      }
+   }
+   return false;
+}
+                                                                       /*}}}*/
+// AcqMetaBase::CommitTransaction - Commit a transaction               /*{{{*/
+void pkgAcqMetaBase::CommitTransaction()
+{
+   if(_config->FindB("Debug::Acquire::Transaction", false) == true)
+      std::clog << "CommitTransaction: " << this << std::endl;
 
-   if(Debug)
-      std::clog << "pkgAcqDiffIndex::pkgAcqDiffIndex(): "
-        << CurrentPackagesFile << std::endl;
-
-   QueueURI(Desc);
+   // move new files into place *and* remove files that are not
+   // part of the transaction but are still on disk
+   for (std::vector<pkgAcqTransactionItem*>::iterator I = Transaction.begin();
+        I != Transaction.end(); ++I)
+   {
+      (*I)->TransactionState(TransactionCommit);
+   }
+   Transaction.clear();
+}
+                                                                       /*}}}*/
+// AcqMetaBase::TransactionStageCopy - Stage a file for copying                /*{{{*/
+void pkgAcqMetaBase::TransactionStageCopy(pkgAcqTransactionItem * const I,
+                                          const std::string &From,
+                                          const std::string &To)
+{
+   I->PartialFile = From;
+   I->DestFile = To;
+}
+                                                                       /*}}}*/
+// AcqMetaBase::TransactionStageRemoval - Stage a file for removal     /*{{{*/
+void pkgAcqMetaBase::TransactionStageRemoval(pkgAcqTransactionItem * const I,
+                                             const std::string &FinalFile)
+{
+   I->PartialFile = "";
+   I->DestFile = FinalFile;
+}
+                                                                       /*}}}*/
+// AcqMetaBase::GenerateAuthWarning - Check gpg authentication error   /*{{{*/
+bool pkgAcqMetaBase::CheckStopAuthentication(pkgAcquire::Item * const I, const std::string &Message)
+{
+   // FIXME: this entire function can do now that we disallow going to
+   //        a unauthenticated state and can cleanly rollback
 
+   string const Final = I->GetFinalFilename();
+   if(FileExists(Final))
+   {
+      I->Status = StatTransientNetworkError;
+      _error->Warning(_("An error occurred during the signature "
+                        "verification. The repository is not updated "
+                        "and the previous index files will be used. "
+                        "GPG error: %s: %s"),
+                      Desc.Description.c_str(),
+                      LookupTag(Message,"Message").c_str());
+      RunScripts("APT::Update::Auth-Failure");
+      return true;
+   } else if (LookupTag(Message,"Message").find("NODATA") != string::npos) {
+      /* Invalid signature file, reject (LP: #346386) (Closes: #627642) */
+      _error->Error(_("GPG error: %s: %s"),
+                    Desc.Description.c_str(),
+                    LookupTag(Message,"Message").c_str());
+      I->Status = StatAuthError;
+      return true;
+   } else {
+      _error->Warning(_("GPG error: %s: %s"),
+                      Desc.Description.c_str(),
+                      LookupTag(Message,"Message").c_str());
+   }
+   // gpgv method failed
+   ReportMirrorFailure("GPGFailure");
+   return false;
 }
                                                                        /*}}}*/
-// AcqIndex::Custom600Headers - Insert custom request headers          /*{{{*/
+// AcqMetaBase::Custom600Headers - Get header for AcqMetaBase          /*{{{*/
 // ---------------------------------------------------------------------
-/* The only header we use is the last-modified header. */
-string pkgAcqDiffIndex::Custom600Headers() const
+string pkgAcqMetaBase::Custom600Headers() const
 {
-   string Final = _config->FindDir("Dir::State::lists");
-   Final += URItoFileName(Desc.URI);
-
-   if(Debug)
-      std::clog << "Custom600Header-IMS: " << Final << std::endl;
+   std::string Header = "\nIndex-File: true";
+   std::string MaximumSize;
+   strprintf(MaximumSize, "\nMaximum-Size: %i",
+             _config->FindI("Acquire::MaxReleaseFileSize", 10*1000*1000));
+   Header += MaximumSize;
 
+   string const FinalFile = GetFinalFilename();
    struct stat Buf;
-   if (stat(Final.c_str(),&Buf) != 0)
-      return "\nIndex-File: true";
-   
-   return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
+   if (stat(FinalFile.c_str(),&Buf) == 0)
+      Header += "\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
+
+   return Header;
 }
                                                                        /*}}}*/
-bool pkgAcqDiffIndex::ParseDiffIndex(string IndexDiffFile)             /*{{{*/
+// AcqMetaBase::QueueForSignatureVerify                                        /*{{{*/
+void pkgAcqMetaBase::QueueForSignatureVerify(pkgAcqTransactionItem * const I, std::string const &File, std::string const &Signature)
 {
-   // failing here is fine: our caller will take care of trying to
-   // get the complete file if patching fails
-   if(Debug)
-      std::clog << "pkgAcqDiffIndex::ParseIndexDiff() " << IndexDiffFile
-        << std::endl;
-
-   FileFd Fd(IndexDiffFile,FileFd::ReadOnly);
-   pkgTagFile TF(&Fd);
-   if (_error->PendingError() == true)
-      return false;
+   AuthPass = true;
+   I->Desc.URI = "gpgv:" + Signature;
+   I->DestFile = File;
+   QueueURI(I->Desc);
+   I->SetActiveSubprocess("gpgv");
+}
+                                                                       /*}}}*/
+// AcqMetaBase::CheckDownloadDone                                      /*{{{*/
+bool pkgAcqMetaBase::CheckDownloadDone(pkgAcqTransactionItem * const I, const std::string &Message, HashStringList const &Hashes) const
+{
+   // We have just finished downloading a Release file (it is not
+   // verified yet)
 
-   pkgTagSection Tags;
-   if(unlikely(TF.Step(Tags) == false))
+   std::string const FileName = LookupTag(Message,"Filename");
+   if (FileName != I->DestFile && RealFileExists(I->DestFile) == false)
+   {
+      I->Local = true;
+      I->Desc.URI = "copy:" + FileName;
+      I->QueueURI(I->Desc);
       return false;
+   }
 
-   HashStringList ServerHashes;
-   unsigned long long ServerSize = 0;
-
-   for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
+   // make sure to verify against the right file on I-M-S hit
+   bool IMSHit = StringToBool(LookupTag(Message,"IMS-Hit"), false);
+   if (IMSHit == false && Hashes.usable())
    {
-      std::string tagname = *type;
-      tagname.append("-Current");
-      std::string const tmp = Tags.FindS(tagname.c_str());
-      if (tmp.empty() == true)
-        continue;
-
-      string hash;
-      unsigned long long size;
-      std::stringstream ss(tmp);
-      ss >> hash >> size;
-      if (unlikely(hash.empty() == true))
-        continue;
-      if (unlikely(ServerSize != 0 && ServerSize != size))
-        continue;
-      ServerHashes.push_back(HashString(*type, hash));
-      ServerSize = size;
+      // detect IMS-Hits servers haven't detected by Hash comparison
+      std::string const FinalFile = I->GetFinalFilename();
+      if (RealFileExists(FinalFile) && Hashes.VerifyFile(FinalFile) == true)
+      {
+        IMSHit = true;
+        RemoveFile("CheckDownloadDone", I->DestFile);
+      }
    }
 
-   if (ServerHashes.usable() == false)
+   if(IMSHit == true)
    {
-      if (Debug == true)
-        std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": Did not find a good hashsum in the index" << std::endl;
-      return false;
+      // for simplicity, the transaction manager is always InRelease
+      // even if it doesn't exist.
+      if (TransactionManager != NULL)
+        TransactionManager->IMSHit = true;
+      I->PartialFile = I->DestFile = I->GetFinalFilename();
    }
 
-   if (ServerHashes != HashSums())
+   // set Item to complete as the remaining work is all local (verify etc)
+   I->Complete = true;
+
+   return true;
+}
+                                                                       /*}}}*/
+bool pkgAcqMetaBase::CheckAuthDone(string const &Message)              /*{{{*/
+{
+   // At this point, the gpgv method has succeeded, so there is a
+   // valid signature from a key in the trusted keyring.  We
+   // perform additional verification of its contents, and use them
+   // to verify the indexes we are about to download
+
+   if (TransactionManager->IMSHit == false)
    {
-      if (Debug == true)
+      // open the last (In)Release if we have it
+      std::string const FinalFile = GetFinalFilename();
+      std::string FinalRelease;
+      std::string FinalInRelease;
+      if (APT::String::Endswith(FinalFile, "InRelease"))
       {
-        std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": Index has different hashes than parser, probably older, so fail pdiffing" << std::endl;
-         printHashSumComparision(CurrentPackagesFile, ServerHashes, HashSums());
+        FinalInRelease = FinalFile;
+        FinalRelease = FinalFile.substr(0, FinalFile.length() - strlen("InRelease")) + "Release";
+      }
+      else
+      {
+        FinalInRelease = FinalFile.substr(0, FinalFile.length() - strlen("Release")) + "InRelease";
+        FinalRelease = FinalFile;
+      }
+      if (RealFileExists(FinalInRelease) || RealFileExists(FinalRelease))
+      {
+        TransactionManager->LastMetaIndexParser = TransactionManager->MetaIndexParser->UnloadedClone();
+        if (TransactionManager->LastMetaIndexParser != NULL)
+        {
+           _error->PushToStack();
+           if (RealFileExists(FinalInRelease))
+              TransactionManager->LastMetaIndexParser->Load(FinalInRelease, NULL);
+           else
+              TransactionManager->LastMetaIndexParser->Load(FinalRelease, NULL);
+           // its unlikely to happen, but if what we have is bad ignore it
+           if (_error->PendingError())
+           {
+              delete TransactionManager->LastMetaIndexParser;
+              TransactionManager->LastMetaIndexParser = NULL;
+           }
+           _error->RevertToStack();
+        }
       }
-      return false;
    }
 
-   if (ServerHashes.VerifyFile(CurrentPackagesFile) == true)
+   if (TransactionManager->MetaIndexParser->Load(DestFile, &ErrorText) == false)
    {
-      // we have the same sha1 as the server so we are done here
-      if(Debug)
-        std::clog << "pkgAcqDiffIndex: Package file " << CurrentPackagesFile << " is up-to-date" << std::endl;
-
-      // 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,
-                           ExpectedHashes, MetaIndexParser);
-      return true;
+      Status = StatAuthError;
+      return false;
    }
 
-   FileFd fd(CurrentPackagesFile, FileFd::ReadOnly);
-   Hashes LocalHashesCalc;
-   LocalHashesCalc.AddFD(fd);
-   HashStringList const LocalHashes = LocalHashesCalc.GetHashStringList();
+   if (!VerifyVendor(Message))
+   {
+      Status = StatAuthError;
+      return false;
+   }
 
-   if(Debug)
-      std::clog << "Server-Current: " << ServerHashes.find(NULL)->toStr() << " and we start at "
-        << fd.Name() << " " << fd.FileSize() << " " << LocalHashes.find(NULL)->toStr() << std::endl;
+   if (_config->FindB("Debug::pkgAcquire::Auth", false))
+      std::cerr << "Signature verification succeeded: "
+                << DestFile << std::endl;
 
-   // parse all of (provided) history
-   vector<DiffInfo> available_patches;
-   bool firstAcceptedHashes = true;
-   for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
-   {
-      if (LocalHashes.find(*type) == NULL)
-        continue;
+   // Download further indexes with verification
+   QueueIndexes(true);
 
-      std::string tagname = *type;
-      tagname.append("-History");
-      std::string const tmp = Tags.FindS(tagname.c_str());
-      if (tmp.empty() == true)
-        continue;
+   return true;
+}
+                                                                       /*}}}*/
+void pkgAcqMetaBase::QueueIndexes(bool const verify)                   /*{{{*/
+{
+   // at this point the real Items are loaded in the fetcher
+   ExpectedAdditionalItems = 0;
 
-      string hash, filename;
-      unsigned long long size;
-      std::stringstream ss(tmp);
+  bool metaBaseSupportsByHash = false;
+  if (TransactionManager != NULL && TransactionManager->MetaIndexParser != NULL)
+     metaBaseSupportsByHash = TransactionManager->MetaIndexParser->GetSupportsAcquireByHash();
 
-      while (ss >> hash >> size >> filename)
+   for (std::vector <IndexTarget>::iterator Target = IndexTargets.begin();
+        Target != IndexTargets.end();
+        ++Target)
+   {
+      // all is an implementation detail. Users shouldn't use this as arch
+      // We need this support trickery here as e.g. Debian has binary-all files already,
+      // but arch:all packages are still in the arch:any files, so we would waste precious
+      // download time, bandwidth and diskspace for nothing, BUT Debian doesn't feature all
+      // in the set of supported architectures, so we can filter based on this property rather
+      // than invent an entirely new flag we would need to carry for all of eternity.
+      if (Target->Option(IndexTarget::ARCHITECTURE) == "all")
       {
-        if (unlikely(hash.empty() == true || filename.empty() == true))
+        if (TransactionManager->MetaIndexParser->IsArchitectureSupported("all") == false)
            continue;
+        if (TransactionManager->MetaIndexParser->IsArchitectureAllSupportedFor(*Target) == false)
+           continue;
+      }
 
-        // see if we have a record for this file already
-        std::vector<DiffInfo>::iterator cur = available_patches.begin();
-        for (; cur != available_patches.end(); ++cur)
+      bool trypdiff = Target->OptionBool(IndexTarget::PDIFFS);
+      if (verify == true)
+      {
+        if (TransactionManager->MetaIndexParser->Exists(Target->MetaKey) == false)
         {
-           if (cur->file != filename || unlikely(cur->result_size != size))
+           // optional targets that we do not have in the Release file are skipped
+           if (Target->IsOptional)
               continue;
-           cur->result_hashes.push_back(HashString(*type, hash));
-           break;
-        }
-        if (cur != available_patches.end())
-           continue;
-        if (firstAcceptedHashes == true)
-        {
-           DiffInfo next;
-           next.file = filename;
-           next.result_hashes.push_back(HashString(*type, hash));
-           next.result_size = size;
-           next.patch_size = 0;
-           available_patches.push_back(next);
+
+           std::string const &arch = Target->Option(IndexTarget::ARCHITECTURE);
+           if (arch.empty() == false)
+           {
+              if (TransactionManager->MetaIndexParser->IsArchitectureSupported(arch) == false)
+              {
+                 _error->Notice(_("Skipping acquire of configured file '%s' as repository '%s' doesn't support architecture '%s'"),
+                       Target->MetaKey.c_str(), TransactionManager->Target.Description.c_str(), arch.c_str());
+                 continue;
+              }
+              // if the architecture is officially supported but currently no packages for it available,
+              // ignore silently as this is pretty much the same as just shipping an empty file.
+              // if we don't know which architectures are supported, we do NOT ignore it to notify user about this
+              if (TransactionManager->MetaIndexParser->IsArchitectureSupported("*undefined*") == false)
+                 continue;
+           }
+
+           Status = StatAuthError;
+           strprintf(ErrorText, _("Unable to find expected entry '%s' in Release file (Wrong sources.list entry or malformed file)"), Target->MetaKey.c_str());
+           return;
         }
         else
         {
-           if (Debug == true)
-              std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": File " << filename
-                 << " wasn't in the list for the first parsed hash! (history)" << std::endl;
-           break;
+           auto const hashes = GetExpectedHashesFor(Target->MetaKey);
+           if (hashes.usable() == false && hashes.empty() == false)
+           {
+              _error->Warning(_("Skipping acquire of configured file '%s' as repository '%s' provides only weak security information for it"),
+                       Target->MetaKey.c_str(), TransactionManager->Target.Description.c_str());
+              continue;
+           }
         }
-      }
-      firstAcceptedHashes = false;
-   }
-
-   if (unlikely(available_patches.empty() == true))
-   {
-      if (Debug)
-        std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": "
-           << "Couldn't find any patches for the patch series." << std::endl;
-      return false;
-   }
 
-   for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
-   {
-      if (LocalHashes.find(*type) == NULL)
-        continue;
+        // autoselect the compression method
+        std::vector<std::string> types = VectorizeString(Target->Option(IndexTarget::COMPRESSIONTYPES), ' ');
+        types.erase(std::remove_if(types.begin(), types.end(), [&](std::string const &t) {
+           if (t == "uncompressed")
+              return TransactionManager->MetaIndexParser->Exists(Target->MetaKey) == false;
+           std::string const MetaKey = Target->MetaKey + "." + t;
+           return TransactionManager->MetaIndexParser->Exists(MetaKey) == false;
+        }), types.end());
+        if (types.empty() == false)
+        {
+           std::ostringstream os;
+           // add the special compressiontype byhash first if supported
+           std::string const useByHashConf = Target->Option(IndexTarget::BY_HASH);
+           bool useByHash = false;
+           if(useByHashConf == "force")
+              useByHash = true;
+           else
+              useByHash = StringToBool(useByHashConf) == true && metaBaseSupportsByHash;
+           if (useByHash == true)
+              os << "by-hash ";
+           std::copy(types.begin(), types.end()-1, std::ostream_iterator<std::string>(os, " "));
+           os << *types.rbegin();
+           Target->Options["COMPRESSIONTYPES"] = os.str();
+        }
+        else
+           Target->Options["COMPRESSIONTYPES"].clear();
 
-      std::string tagname = *type;
-      tagname.append("-Patches");
-      std::string const tmp = Tags.FindS(tagname.c_str());
-      if (tmp.empty() == true)
-        continue;
+        std::string filename = GetExistingFilename(GetFinalFileNameFromURI(Target->URI));
+        if (filename.empty() == false)
+        {
+           // if the Release file is a hit and we have an index it must be the current one
+           if (TransactionManager->IMSHit == true)
+              ;
+           else if (TransactionManager->LastMetaIndexParser != NULL)
+           {
+              // see if the file changed since the last Release file
+              // we use the uncompressed files as we might compress differently compared to the server,
+              // so the hashes might not match, even if they contain the same data.
+              HashStringList const newFile = GetExpectedHashesFromFor(TransactionManager->MetaIndexParser, Target->MetaKey);
+              HashStringList const oldFile = GetExpectedHashesFromFor(TransactionManager->LastMetaIndexParser, Target->MetaKey);
+              if (newFile != oldFile)
+                 filename.clear();
+           }
+           else
+              filename.clear();
+        }
+        else
+           trypdiff = false; // no file to patch
 
-      string hash, filename;
-      unsigned long long size;
-      std::stringstream ss(tmp);
+        if (filename.empty() == false)
+        {
+           new NoActionItem(Owner, *Target, filename);
+           std::string const idxfilename = GetFinalFileNameFromURI(Target->URI + ".diff/Index");
+           if (FileExists(idxfilename))
+              new NoActionItem(Owner, *Target, idxfilename);
+           continue;
+        }
 
-      while (ss >> hash >> size >> filename)
+        // check if we have patches available
+        trypdiff &= TransactionManager->MetaIndexParser->Exists(Target->MetaKey + ".diff/Index");
+      }
+      else
       {
-        if (unlikely(hash.empty() == true || filename.empty() == true))
-           continue;
+        // if we have no file to patch, no point in trying
+        trypdiff &= (GetExistingFilename(GetFinalFileNameFromURI(Target->URI)).empty() == false);
+      }
 
-        // see if we have a record for this file already
-        std::vector<DiffInfo>::iterator cur = available_patches.begin();
-        for (; cur != available_patches.end(); ++cur)
-        {
-           if (cur->file != filename)
-              continue;
-           if (unlikely(cur->patch_size != 0 && cur->patch_size != size))
-              continue;
-           cur->patch_hashes.push_back(HashString(*type, hash));
-           cur->patch_size = size;
-           break;
-        }
-        if (cur != available_patches.end())
-              continue;
-        if (Debug == true)
-           std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": File " << filename
-              << " wasn't in the list for the first parsed hash! (patches)" << std::endl;
-        break;
+      // no point in patching from local sources
+      if (trypdiff)
+      {
+        std::string const proto = Target->URI.substr(0, strlen("file:/"));
+        if (proto == "file:/" || proto == "copy:/" || proto == "cdrom:")
+           trypdiff = false;
       }
+
+      // Queue the Index file (Packages, Sources, Translation-$foo, …)
+      if (trypdiff)
+         new pkgAcqDiffIndex(Owner, TransactionManager, *Target);
+      else
+         new pkgAcqIndex(Owner, TransactionManager, *Target);
    }
+}
+                                                                       /*}}}*/
+bool pkgAcqMetaBase::VerifyVendor(string const &Message)               /*{{{*/
+{
+   string::size_type pos;
 
-   bool foundStart = false;
-   for (std::vector<DiffInfo>::iterator cur = available_patches.begin();
-        cur != available_patches.end(); ++cur)
+   // check for missing sigs (that where not fatal because otherwise we had
+   // bombed earlier)
+   string missingkeys;
+   string msg = _("There is no public key available for the "
+                 "following key IDs:\n");
+   pos = Message.find("NO_PUBKEY ");
+   if (pos != std::string::npos)
    {
-      if (LocalHashes != cur->result_hashes)
-        continue;
-
-      available_patches.erase(available_patches.begin(), cur);
-      foundStart = true;
-      break;
+      string::size_type start = pos+strlen("NO_PUBKEY ");
+      string Fingerprint = Message.substr(start, Message.find("\n")-start);
+      missingkeys += (Fingerprint);
    }
+   if(!missingkeys.empty())
+      _error->Warning("%s", (msg + missingkeys).c_str());
 
-   if (foundStart == false || unlikely(available_patches.empty() == true))
+   string Transformed = TransactionManager->MetaIndexParser->GetExpectedDist();
+
+   if (Transformed == "../project/experimental")
    {
-      if (Debug)
-        std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": "
-           << "Couldn't find the start of the patch series." << std::endl;
-      return false;
+      Transformed = "experimental";
    }
 
-   // patching with too many files is rather slow compared to a fast download
-   unsigned long const fileLimit = _config->FindI("Acquire::PDiffs::FileLimit", 0);
-   if (fileLimit != 0 && fileLimit < available_patches.size())
+   pos = Transformed.rfind('/');
+   if (pos != string::npos)
    {
-      if (Debug)
-        std::clog << "Need " << available_patches.size() << " diffs (Limit is " << fileLimit
-           << ") so fallback to complete download" << std::endl;
-      return false;
+      Transformed = Transformed.substr(0, pos);
    }
 
-   // calculate the size of all patches we have to get
-   // note that all sizes are uncompressed, while we download compressed files
-   unsigned long long patchesSize = 0;
-   for (std::vector<DiffInfo>::const_iterator cur = available_patches.begin();
-        cur != available_patches.end(); ++cur)
-      patchesSize += cur->patch_size;
-   unsigned long long const sizeLimit = ServerSize * _config->FindI("Acquire::PDiffs::SizeLimit", 100);
-   if (false && sizeLimit > 0 && (sizeLimit/100) < patchesSize)
+   if (Transformed == ".")
    {
-      if (Debug)
-        std::clog << "Need " << patchesSize << " bytes (Limit is " << sizeLimit/100
-           << ") so fallback to complete download" << std::endl;
-      return false;
+      Transformed = "";
    }
 
-   // FIXME: make this use the method
-   PackagesFileReadyInPartial = true;
-   std::string const Partial = GetPartialFileNameFromURI(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;
-
-   // we have something, queue the diffs
-   string::size_type const last_space = Description.rfind(" ");
-   if(last_space != string::npos)
-      Description.erase(last_space, Description.size()-last_space);
+   if (TransactionManager->MetaIndexParser->GetValidUntil() > 0)
+   {
+      time_t const invalid_since = time(NULL) - TransactionManager->MetaIndexParser->GetValidUntil();
+      if (invalid_since > 0)
+      {
+        std::string errmsg;
+        strprintf(errmsg,
+              // TRANSLATOR: The first %s is the URL of the bad Release file, the second is
+              // the time since then the file is invalid - formatted in the same way as in
+              // the download progress display (e.g. 7d 3h 42min 1s)
+              _("Release file for %s is expired (invalid since %s). "
+                 "Updates for this repository will not be applied."),
+              Target.URI.c_str(), TimeToStr(invalid_since).c_str());
+        if (ErrorText.empty())
+           ErrorText = errmsg;
+        return _error->Error("%s", errmsg.c_str());
+      }
+   }
 
-   /* decide if we should download patches one by one or in one go:
-      The first is good if the server merges patches, but many don't so client
-      based merging can be attempt in which case the second is better.
-      "bad things" will happen if patches are merged on the server,
-      but client side merging is attempt as well */
-   bool pdiff_merge = _config->FindB("Acquire::PDiffs::Merge", true);
-   if (pdiff_merge == true)
+   /* Did we get a file older than what we have? This is a last minute IMS hit and doubles
+      as a prevention of downgrading us to older (still valid) files */
+   if (TransactionManager->IMSHit == false && TransactionManager->LastMetaIndexParser != NULL &&
+        TransactionManager->LastMetaIndexParser->GetDate() > TransactionManager->MetaIndexParser->GetDate())
    {
-      // reprepro adds this flag if it has merged patches on the server
-      std::string const precedence = Tags.FindS("X-Patch-Precedence");
-      pdiff_merge = (precedence != "merged");
+      TransactionManager->IMSHit = true;
+      RemoveFile("VerifyVendor", DestFile);
+      PartialFile = DestFile = GetFinalFilename();
+      // load the 'old' file in the 'new' one instead of flipping pointers as
+      // the new one isn't owned by us, while the old one is so cleanup would be confused.
+      TransactionManager->MetaIndexParser->swapLoad(TransactionManager->LastMetaIndexParser);
+      delete TransactionManager->LastMetaIndexParser;
+      TransactionManager->LastMetaIndexParser = NULL;
    }
 
-   if (pdiff_merge == false)
+   if (_config->FindB("Debug::pkgAcquire::Auth", false)) 
    {
-      new pkgAcqIndexDiffs(Owner, TransactionManager, Target, ExpectedHashes, 
-                           MetaIndexParser, available_patches);
+      std::cerr << "Got Codename: " << TransactionManager->MetaIndexParser->GetCodename() << std::endl;
+      std::cerr << "Expecting Dist: " << TransactionManager->MetaIndexParser->GetExpectedDist() << std::endl;
+      std::cerr << "Transformed Dist: " << Transformed << std::endl;
    }
-   else
+
+   if (TransactionManager->MetaIndexParser->CheckDist(Transformed) == false)
    {
-      std::vector<pkgAcqIndexMergeDiffs*> *diffs = new std::vector<pkgAcqIndexMergeDiffs*>(available_patches.size());
-      for(size_t i = 0; i < available_patches.size(); ++i)
-        (*diffs)[i] = new pkgAcqIndexMergeDiffs(Owner, TransactionManager,
-               Target,
-              ExpectedHashes,
-              MetaIndexParser,
-              available_patches[i],
-              diffs);
+      // This might become fatal one day
+//       Status = StatAuthError;
+//       ErrorText = "Conflicting distribution; expected "
+//          + MetaIndexParser->GetExpectedDist() + " but got "
+//          + MetaIndexParser->GetCodename();
+//       return false;
+      if (!Transformed.empty())
+      {
+         _error->Warning(_("Conflicting distribution: %s (expected %s but got %s)"),
+                         Desc.Description.c_str(),
+                         Transformed.c_str(),
+                         TransactionManager->MetaIndexParser->GetCodename().c_str());
+      }
    }
 
-   Complete = false;
-   Status = StatDone;
-   Dequeue();
    return true;
 }
                                                                        /*}}}*/
-void pkgAcqDiffIndex::Failed(string Message,pkgAcquire::MethodConfig * Cnf)/*{{{*/
+pkgAcqMetaBase::~pkgAcqMetaBase()
 {
-   if(Debug)
-      std::clog << "pkgAcqDiffIndex failed: " << Desc.URI << " with " << Message << std::endl
-               << "Falling back to normal index file acquire" << std::endl;
-
-   new pkgAcqIndex(Owner, TransactionManager, Target, ExpectedHashes, MetaIndexParser);
+}
 
-   Item::Failed(Message,Cnf);
-   Status = StatDone;
+pkgAcqMetaClearSig::pkgAcqMetaClearSig(pkgAcquire * const Owner,       /*{{{*/
+      IndexTarget const &ClearsignedTarget,
+      IndexTarget const &DetachedDataTarget, IndexTarget const &DetachedSigTarget,
+      std::vector<IndexTarget> const &IndexTargets,
+      metaIndex * const MetaIndexParser) :
+   pkgAcqMetaIndex(Owner, this, ClearsignedTarget, DetachedSigTarget, IndexTargets),
+   d(NULL), ClearsignedTarget(ClearsignedTarget),
+   DetachedDataTarget(DetachedDataTarget),
+   MetaIndexParser(MetaIndexParser), LastMetaIndexParser(NULL)
+{
+   // index targets + (worst case:) Release/Release.gpg
+   ExpectedAdditionalItems = IndexTargets.size() + 2;
+   TransactionManager->Add(this);
 }
                                                                        /*}}}*/
-void pkgAcqDiffIndex::Done(string Message,unsigned long long Size,HashStringList const &Hashes,        /*{{{*/
-                          pkgAcquire::MethodConfig *Cnf)
+pkgAcqMetaClearSig::~pkgAcqMetaClearSig()                              /*{{{*/
 {
-   if(Debug)
-      std::clog << "pkgAcqDiffIndex::Done(): " << Desc.URI << std::endl;
-
-   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");
-   FinalFile += URItoFileName(Desc.URI);
-
-   if(StringToBool(LookupTag(Message,"IMS-Hit"),false))
-      DestFile = FinalFile;
-
-   if(!ParseDiffIndex(DestFile))
-      return Failed("Message: Couldn't parse pdiff index", Cnf);
-
-   // queue for final move
-   TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
+   if (LastMetaIndexParser != NULL)
+      delete LastMetaIndexParser;
+}
+                                                                       /*}}}*/
+// pkgAcqMetaClearSig::Custom600Headers - Insert custom request headers        /*{{{*/
+string pkgAcqMetaClearSig::Custom600Headers() const
+{
+   string Header = pkgAcqMetaBase::Custom600Headers();
+   Header += "\nFail-Ignore: true";
+   std::string const key = TransactionManager->MetaIndexParser->GetSignedBy();
+   if (key.empty() == false)
+      Header += "\nSigned-By: " + key;
 
-   Complete = true;
-   Status = StatDone;
-   Dequeue();
-   return;
+   return Header;
 }
                                                                        /*}}}*/
-// AcqIndexDiffs::AcqIndexDiffs - Constructor                          /*{{{*/
-// ---------------------------------------------------------------------
-/* The package diff is added to the queue. one object is constructed
- * for each diff and the index
- */
-pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire *Owner,
-                                   pkgAcqMetaBase *TransactionManager,
-                                   struct IndexTarget const * const Target,
-                                   HashStringList const &ExpectedHashes,
-                                   indexRecords *MetaIndexParser,
-                                  vector<DiffInfo> diffs)
-   : pkgAcqBaseIndex(Owner, TransactionManager, Target, ExpectedHashes, MetaIndexParser),
-     available_patches(diffs)
+bool pkgAcqMetaClearSig::VerifyDone(std::string const &Message,                /*{{{*/
+        pkgAcquire::MethodConfig const * const Cnf)
 {
-   DestFile = GetPartialFileNameFromURI(Target->URI);
+   Item::VerifyDone(Message, Cnf);
 
-   Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
+   if (FileExists(DestFile) && !StartsWithGPGClearTextSignature(DestFile))
+      return RenameOnError(NotClearsigned);
 
-   RealURI = Target->URI;
-   Desc.Owner = this;
-   Description = Target->Description;
-   Desc.ShortDesc = Target->ShortDesc;
+   return true;
+}
+                                                                       /*}}}*/
+// pkgAcqMetaClearSig::Done - We got a file                            /*{{{*/
+void pkgAcqMetaClearSig::Done(std::string const &Message,
+                              HashStringList const &Hashes,
+                              pkgAcquire::MethodConfig const * const Cnf)
+{
+   Item::Done(Message, Hashes, Cnf);
 
-   if(available_patches.empty() == true)
+   if(AuthPass == false)
    {
-      // we are done (yeah!), check hashes against the final file
-      DestFile = _config->FindDir("Dir::State::lists");
-      DestFile += URItoFileName(Target->URI);
-      Finish(true);
+      if(CheckDownloadDone(this, Message, Hashes) == true)
+         QueueForSignatureVerify(this, DestFile, DestFile);
+      return;
    }
-   else
+   else if(CheckAuthDone(Message) == true)
    {
-      // get the next diff
-      State = StateFetchDiff;
-      QueueNextDiff();
+      if (TransactionManager->IMSHit == false)
+        TransactionManager->TransactionStageCopy(this, DestFile, GetFinalFilename());
+      else if (RealFileExists(GetFinalFilename()) == false)
+      {
+        // We got an InRelease file IMSHit, but we haven't one, which means
+        // we had a valid Release/Release.gpg combo stepping in, which we have
+        // to 'acquire' now to ensure list cleanup isn't removing them
+        new NoActionItem(Owner, DetachedDataTarget);
+        new NoActionItem(Owner, DetachedSigTarget);
+      }
    }
 }
                                                                        /*}}}*/
-void pkgAcqIndexDiffs::Failed(string Message,pkgAcquire::MethodConfig * /*Cnf*/)/*{{{*/
-{
-   if(Debug)
-      std::clog << "pkgAcqIndexDiffs failed: " << Desc.URI << " with " << Message << std::endl
-               << "Falling back to normal index file acquire" << std::endl;
-   new pkgAcqIndex(Owner, TransactionManager, Target, ExpectedHashes, MetaIndexParser);
-   Finish();
-}
-                                                                       /*}}}*/
-// Finish - helper that cleans the item out of the fetcher queue       /*{{{*/
-void pkgAcqIndexDiffs::Finish(bool allDone)
+void pkgAcqMetaClearSig::Failed(string const &Message,pkgAcquire::MethodConfig const * const Cnf) /*{{{*/
 {
-   if(Debug)
-      std::clog << "pkgAcqIndexDiffs::Finish(): " 
-                << allDone << " "
-                << Desc.URI << std::endl;
+   Item::Failed(Message, Cnf);
 
-   // we restore the original name, this is required, otherwise
-   // the file will be cleaned
-   if(allDone) 
+   // we failed, we will not get additional items from this method
+   ExpectedAdditionalItems = 0;
+
+   if (AuthPass == false)
    {
-      if(HashSums().usable() && !HashSums().VerifyFile(DestFile))
+      if (Status == StatAuthError || Status == StatTransientNetworkError)
       {
-        RenameOnError(HashSumMismatch);
-        Dequeue();
+        // if we expected a ClearTextSignature (InRelease) but got a network
+        // error or got a file, but it wasn't valid, we end up here (see VerifyDone).
+        // As these is usually called by web-portals we do not try Release/Release.gpg
+        // as this is gonna fail anyway and instead abort our try (LP#346386)
+        TransactionManager->AbortTransaction();
         return;
       }
 
-      // queue for copy
-      std::string FinalFile = _config->FindDir("Dir::State::lists");
-      FinalFile += URItoFileName(RealURI);
-      TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
-
-      // this is for the "real" finish
-      Complete = true;
+      // Queue the 'old' InRelease file for removal if we try Release.gpg
+      // as otherwise the file will stay around and gives a false-auth
+      // impression (CVE-2012-0214)
+      TransactionManager->TransactionStageRemoval(this, GetFinalFilename());
       Status = StatDone;
-      Dequeue();
-      if(Debug)
-        std::clog << "\n\nallDone: " << DestFile << "\n" << std::endl;
-      return;
-   }
-
-   if(Debug)
-      std::clog << "Finishing: " << Desc.URI << std::endl;
-   Complete = false;
-   Status = StatDone;
-   Dequeue();
-   return;
-}
-                                                                       /*}}}*/
-bool pkgAcqIndexDiffs::QueueNextDiff()                                 /*{{{*/
-{
-   // calc sha1 of the just patched file
-   std::string const FinalFile = GetPartialFileNameFromURI(RealURI);
 
-   if(!FileExists(FinalFile))
-   {
-      Failed("Message: No FinalFile " + FinalFile + " available", NULL);
-      return false;
+      new pkgAcqMetaIndex(Owner, TransactionManager, DetachedDataTarget, DetachedSigTarget, IndexTargets);
    }
-
-   FileFd fd(FinalFile, FileFd::ReadOnly);
-   Hashes LocalHashesCalc;
-   LocalHashesCalc.AddFD(fd);
-   HashStringList const LocalHashes = LocalHashesCalc.GetHashStringList();
-
-   if(Debug)
-      std::clog << "QueueNextDiff: " << FinalFile << " (" << LocalHashes.find(NULL)->toStr() << ")" << std::endl;
-
-   if (unlikely(LocalHashes.usable() == false || ExpectedHashes.usable() == false))
+   else
    {
-      Failed("Local/Expected hashes are not usable", NULL);
-      return false;
-   }
+      if(CheckStopAuthentication(this, Message))
+         return;
 
+      // No Release file was present, or verification failed, so fall
+      // back to queueing Packages files without verification
+      // only allow going further if the user explicitly wants it
+      if(AllowInsecureRepositories(_("The repository '%s' is not signed."), ClearsignedTarget.Description, TransactionManager->MetaIndexParser, TransactionManager, this) == true)
+      {
+        Status = StatDone;
 
-   // final file reached before all patches are applied
-   if(LocalHashes == ExpectedHashes)
-   {
-      Finish(true);
-      return true;
-   }
+        /* InRelease files become Release files, otherwise
+         * they would be considered as trusted later on */
+        string const FinalRelease = GetFinalFileNameFromURI(DetachedDataTarget.URI);
+        string const PartialRelease = GetPartialFileNameFromURI(DetachedDataTarget.URI);
+        string const FinalReleasegpg = GetFinalFileNameFromURI(DetachedSigTarget.URI);
+        string const FinalInRelease = GetFinalFilename();
+        Rename(DestFile, PartialRelease);
+        TransactionManager->TransactionStageCopy(this, PartialRelease, FinalRelease);
 
-   // remove all patches until the next matching patch is found
-   // this requires the Index file to be ordered
-   for(vector<DiffInfo>::iterator I = available_patches.begin();
-       available_patches.empty() == false &&
-         I != available_patches.end() &&
-         I->result_hashes != LocalHashes;
-       ++I)
-   {
-      available_patches.erase(I);
-   }
+        if (RealFileExists(FinalReleasegpg) || RealFileExists(FinalInRelease))
+        {
+           // open the last Release if we have it
+           if (TransactionManager->IMSHit == false)
+           {
+              TransactionManager->LastMetaIndexParser = TransactionManager->MetaIndexParser->UnloadedClone();
+              if (TransactionManager->LastMetaIndexParser != NULL)
+              {
+                 _error->PushToStack();
+                 if (RealFileExists(FinalInRelease))
+                    TransactionManager->LastMetaIndexParser->Load(FinalInRelease, NULL);
+                 else
+                    TransactionManager->LastMetaIndexParser->Load(FinalRelease, NULL);
+                 // its unlikely to happen, but if what we have is bad ignore it
+                 if (_error->PendingError())
+                 {
+                    delete TransactionManager->LastMetaIndexParser;
+                    TransactionManager->LastMetaIndexParser = NULL;
+                 }
+                 _error->RevertToStack();
+              }
+           }
+        }
 
-   // error checking and falling back if no patch was found
-   if(available_patches.empty() == true)
-   {
-      Failed("No patches left to reach target", NULL);
-      return false;
+        // we parse the indexes here because at this point the user wanted
+        // a repository that may potentially harm him
+        if (TransactionManager->MetaIndexParser->Load(PartialRelease, &ErrorText) == false || VerifyVendor(Message) == false)
+           /* expired Release files are still a problem you need extra force for */;
+        else
+           QueueIndexes(true);
+      }
    }
+}
+                                                                       /*}}}*/
 
-   // queue the right diff
-   Desc.URI = RealURI + ".diff/" + available_patches[0].file + ".gz";
-   Desc.Description = Description + " " + available_patches[0].file + string(".pdiff");
-   DestFile = GetPartialFileNameFromURI(RealURI + ".diff/" + available_patches[0].file);
+pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire * const Owner,             /*{{{*/
+                                 pkgAcqMetaClearSig * const TransactionManager,
+                                IndexTarget const &DataTarget,
+                                IndexTarget const &DetachedSigTarget,
+                                vector<IndexTarget> const &IndexTargets) :
+   pkgAcqMetaBase(Owner, TransactionManager, IndexTargets, DataTarget), d(NULL),
+   DetachedSigTarget(DetachedSigTarget)
+{
+   if(_config->FindB("Debug::Acquire::Transaction", false) == true)
+      std::clog << "New pkgAcqMetaIndex with TransactionManager "
+                << this->TransactionManager << std::endl;
 
-   if(Debug)
-      std::clog << "pkgAcqIndexDiffs::QueueNextDiff(): " << Desc.URI << std::endl;
+   DestFile = GetPartialFileNameFromURI(DataTarget.URI);
 
-   QueueURI(Desc);
+   // Create the item
+   Desc.Description = DataTarget.Description;
+   Desc.Owner = this;
+   Desc.ShortDesc = DataTarget.ShortDesc;
+   Desc.URI = DataTarget.URI;
 
-   return true;
+   // we expect more item
+   ExpectedAdditionalItems = IndexTargets.size();
+   QueueURI(Desc);
 }
                                                                        /*}}}*/
-void pkgAcqIndexDiffs::Done(string Message,unsigned long long Size, HashStringList const &Hashes,      /*{{{*/
-                           pkgAcquire::MethodConfig *Cnf)
+void pkgAcqMetaIndex::Done(string const &Message,                      /*{{{*/
+                           HashStringList const &Hashes,
+                          pkgAcquire::MethodConfig const * const Cfg)
 {
-   if(Debug)
-      std::clog << "pkgAcqIndexDiffs::Done(): " << Desc.URI << std::endl;
-
-   Item::Done(Message, Size, Hashes, Cnf);
+   Item::Done(Message,Hashes,Cfg);
 
-   // FIXME: verify this download too before feeding it to rred
-   std::string const FinalFile = GetPartialFileNameFromURI(RealURI);
-
-   // success in downloading a diff, enter ApplyDiff state
-   if(State == StateFetchDiff)
+   if(CheckDownloadDone(this, Message, Hashes))
    {
-      FileFd fd(DestFile, FileFd::ReadOnly, FileFd::Gzip);
-      class Hashes LocalHashesCalc;
-      LocalHashesCalc.AddFD(fd);
-      HashStringList const LocalHashes = LocalHashesCalc.GetHashStringList();
-
-      if (fd.Size() != available_patches[0].patch_size ||
-           available_patches[0].patch_hashes != LocalHashes)
-      {
-        Failed("Patch has Size/Hashsum mismatch", NULL);
-        return;
-      }
-
-      // rred excepts the patch as $FinalFile.ed
-      Rename(DestFile,FinalFile+".ed");
-
-      if(Debug)
-        std::clog << "Sending to rred method: " << FinalFile << std::endl;
-
-      State = StateApplyDiff;
-      Local = true;
-      Desc.URI = "rred:" + FinalFile;
-      QueueURI(Desc);
-      SetActiveSubprocess("rred");
-      return;
-   } 
-
+      // we have a Release file, now download the Signature, all further
+      // verify/queue for additional downloads will be done in the
+      // pkgAcqMetaSig::Done() code
+      new pkgAcqMetaSig(Owner, TransactionManager, DetachedSigTarget, this);
+   }
+}
+                                                                       /*}}}*/
+// pkgAcqMetaIndex::Failed - no Release file present                   /*{{{*/
+void pkgAcqMetaIndex::Failed(string const &Message,
+                             pkgAcquire::MethodConfig const * const Cnf)
+{
+   pkgAcquire::Item::Failed(Message, Cnf);
+   Status = StatDone;
 
-   // success in download/apply a diff, queue next (if needed)
-   if(State == StateApplyDiff)
+   // No Release file was present so fall
+   // back to queueing Packages files without verification
+   // only allow going further if the user explicitly wants it
+   if(AllowInsecureRepositories(_("The repository '%s' does not have a Release file."), Target.Description, TransactionManager->MetaIndexParser, TransactionManager, this) == true)
    {
-      // remove the just applied patch
-      available_patches.erase(available_patches.begin());
-      unlink((FinalFile + ".ed").c_str());
-
-      // move into place
-      if(Debug) 
-      {
-        std::clog << "Moving patched file in place: " << std::endl
-                  << DestFile << " -> " << FinalFile << std::endl;
-      }
-      Rename(DestFile,FinalFile);
-      chmod(FinalFile.c_str(),0644);
+      // ensure old Release files are removed
+      TransactionManager->TransactionStageRemoval(this, GetFinalFilename());
 
-      // see if there is more to download
-      if(available_patches.empty() == false) {
-        new pkgAcqIndexDiffs(Owner, TransactionManager, Target,
-                             ExpectedHashes, MetaIndexParser,
-                             available_patches);
-        return Finish();
-      } else 
-         // update
-         DestFile = FinalFile;
-        return Finish(true);
+      // queue without any kind of hashsum support
+      QueueIndexes(false);
    }
 }
                                                                        /*}}}*/
-// AcqIndexMergeDiffs::AcqIndexMergeDiffs - Constructor                        /*{{{*/
-pkgAcqIndexMergeDiffs::pkgAcqIndexMergeDiffs(pkgAcquire *Owner,
-                                             pkgAcqMetaBase *TransactionManager,
-                                             struct IndexTarget const * const Target,
-                                             HashStringList const &ExpectedHashes,
-                                             indexRecords *MetaIndexParser,
-                                             DiffInfo const &patch,
-                                             std::vector<pkgAcqIndexMergeDiffs*> const * const allPatches)
-  : pkgAcqBaseIndex(Owner, TransactionManager, Target, ExpectedHashes, MetaIndexParser),
-     patch(patch), allPatches(allPatches), State(StateFetchDiff)
+void pkgAcqMetaIndex::Finished()                                       /*{{{*/
 {
-   Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
+   if(_config->FindB("Debug::Acquire::Transaction", false) == true)
+      std::clog << "Finished: " << DestFile <<std::endl;
+   if(TransactionManager != NULL &&
+      TransactionManager->TransactionHasError() == false)
+      TransactionManager->CommitTransaction();
+}
+                                                                       /*}}}*/
+std::string pkgAcqMetaIndex::DescURI() const                           /*{{{*/
+{
+   return Target.URI;
+}
+                                                                       /*}}}*/
+pkgAcqMetaIndex::~pkgAcqMetaIndex() {}
 
-   RealURI = Target->URI;
-   Desc.Owner = this;
-   Description = Target->Description;
-   Desc.ShortDesc = Target->ShortDesc;
+// AcqMetaSig::AcqMetaSig - Constructor                                        /*{{{*/
+pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire * const Owner,
+      pkgAcqMetaClearSig * const TransactionManager,
+      IndexTarget const &Target,
+      pkgAcqMetaIndex * const MetaIndex) :
+   pkgAcqTransactionItem(Owner, TransactionManager, Target), d(NULL), MetaIndex(MetaIndex)
+{
+   DestFile = GetPartialFileNameFromURI(Target.URI);
 
-   Desc.URI = RealURI + ".diff/" + patch.file + ".gz";
-   Desc.Description = Description + " " + patch.file + string(".pdiff");
+   // remove any partial downloaded sig-file in partial/.
+   // it may confuse proxies and is too small to warrant a
+   // partial download anyway
+   RemoveFile("pkgAcqMetaSig", DestFile);
 
-   DestFile = GetPartialFileNameFromURI(RealURI + ".diff/" + patch.file);
+   // set the TransactionManager
+   if(_config->FindB("Debug::Acquire::Transaction", false) == true)
+      std::clog << "New pkgAcqMetaSig with TransactionManager "
+                << TransactionManager << std::endl;
 
-   if(Debug)
-      std::clog << "pkgAcqIndexMergeDiffs: " << Desc.URI << std::endl;
+   // Create the item
+   Desc.Description = Target.Description;
+   Desc.Owner = this;
+   Desc.ShortDesc = Target.ShortDesc;
+   Desc.URI = Target.URI;
 
-   QueueURI(Desc);
+   // If we got a hit for Release, we will get one for Release.gpg too (or obscure errors),
+   // so we skip the download step and go instantly to verification
+   if (TransactionManager->IMSHit == true && RealFileExists(GetFinalFilename()))
+   {
+      Complete = true;
+      Status = StatDone;
+      PartialFile = DestFile = GetFinalFilename();
+      MetaIndexFileSignature = DestFile;
+      MetaIndex->QueueForSignatureVerify(this, MetaIndex->DestFile, DestFile);
+   }
+   else
+      QueueURI(Desc);
 }
                                                                        /*}}}*/
-void pkgAcqIndexMergeDiffs::Failed(string Message,pkgAcquire::MethodConfig * Cnf)/*{{{*/
+pkgAcqMetaSig::~pkgAcqMetaSig()                                                /*{{{*/
 {
-   if(Debug)
-      std::clog << "pkgAcqIndexMergeDiffs failed: " << Desc.URI << " with " << Message << std::endl;
-
-   Item::Failed(Message,Cnf);
-   Status = StatDone;
-
-   // check if we are the first to fail, otherwise we are done here
-   State = StateDoneDiff;
-   for (std::vector<pkgAcqIndexMergeDiffs *>::const_iterator I = allPatches->begin();
-        I != allPatches->end(); ++I)
-      if ((*I)->State == StateErrorDiff)
-        return;
-
-   // first failure means we should fallback
-   State = StateErrorDiff;
-   std::clog << "Falling back to normal index file acquire" << std::endl;
-   new pkgAcqIndex(Owner, TransactionManager, Target, ExpectedHashes, MetaIndexParser);
 }
                                                                        /*}}}*/
-void pkgAcqIndexMergeDiffs::Done(string Message,unsigned long long Size,HashStringList const &Hashes,  /*{{{*/
-                           pkgAcquire::MethodConfig *Cnf)
+// pkgAcqMetaSig::Custom600Headers - Insert custom request headers     /*{{{*/
+std::string pkgAcqMetaSig::Custom600Headers() const
 {
-   if(Debug)
-      std::clog << "pkgAcqIndexMergeDiffs::Done(): " << Desc.URI << std::endl;
-
-   Item::Done(Message,Size,Hashes,Cnf);
-
-   // FIXME: verify download before feeding it to rred
-   string const FinalFile = GetPartialFileNameFromURI(RealURI);
-
-   if (State == StateFetchDiff)
+   std::string Header = pkgAcqTransactionItem::Custom600Headers();
+   std::string const key = TransactionManager->MetaIndexParser->GetSignedBy();
+   if (key.empty() == false)
+      Header += "\nSigned-By: " + key;
+   return Header;
+}
+                                                                       /*}}}*/
+// AcqMetaSig::Done - The signature was downloaded/verified            /*{{{*/
+void pkgAcqMetaSig::Done(string const &Message, HashStringList const &Hashes,
+                        pkgAcquire::MethodConfig const * const Cfg)
+{
+   if (MetaIndexFileSignature.empty() == false)
    {
-      FileFd fd(DestFile, FileFd::ReadOnly, FileFd::Gzip);
-      class Hashes LocalHashesCalc;
-      LocalHashesCalc.AddFD(fd);
-      HashStringList const LocalHashes = LocalHashesCalc.GetHashStringList();
+      DestFile = MetaIndexFileSignature;
+      MetaIndexFileSignature.clear();
+   }
+   Item::Done(Message, Hashes, Cfg);
 
-      if (fd.Size() != patch.patch_size || patch.patch_hashes != LocalHashes)
+   if(MetaIndex->AuthPass == false)
+   {
+      if(MetaIndex->CheckDownloadDone(this, Message, Hashes) == true)
       {
-        Failed("Patch has Size/Hashsum mismatch", NULL);
-        return;
+        // destfile will be modified to point to MetaIndexFile for the
+        // gpgv method, so we need to save it here
+        MetaIndexFileSignature = DestFile;
+        MetaIndex->QueueForSignatureVerify(this, MetaIndex->DestFile, DestFile);
       }
-
-      // rred expects the patch as $FinalFile.ed.$patchname.gz
-      Rename(DestFile, FinalFile + ".ed." + patch.file + ".gz");
-
-      // check if this is the last completed diff
-      State = StateDoneDiff;
-      for (std::vector<pkgAcqIndexMergeDiffs *>::const_iterator I = allPatches->begin();
-           I != allPatches->end(); ++I)
-        if ((*I)->State != StateDoneDiff)
-        {
-           if(Debug)
-              std::clog << "Not the last done diff in the batch: " << Desc.URI << std::endl;
-           return;
-        }
-
-      // this is the last completed diff, so we are ready to apply now
-      State = StateApplyDiff;
-
-      if(Debug)
-        std::clog << "Sending to rred method: " << FinalFile << std::endl;
-
-      Local = true;
-      Desc.URI = "rred:" + FinalFile;
-      QueueURI(Desc);
-      SetActiveSubprocess("rred");
       return;
    }
-   // success in download/apply all diffs, clean up
-   else if (State == StateApplyDiff)
+   else if(MetaIndex->CheckAuthDone(Message) == true)
    {
-      // see if we really got the expected file
-      if(ExpectedHashes.usable() && !ExpectedHashes.VerifyFile(DestFile))
+      if (TransactionManager->IMSHit == false)
       {
-        RenameOnError(HashSumMismatch);
-        return;
+        TransactionManager->TransactionStageCopy(this, DestFile, GetFinalFilename());
+        TransactionManager->TransactionStageCopy(MetaIndex, MetaIndex->DestFile, MetaIndex->GetFinalFilename());
       }
+   }
+}
+                                                                       /*}}}*/
+void pkgAcqMetaSig::Failed(string const &Message,pkgAcquire::MethodConfig const * const Cnf)/*{{{*/
+{
+   Item::Failed(Message,Cnf);
 
+   // check if we need to fail at this point
+   if (MetaIndex->AuthPass == true && MetaIndex->CheckStopAuthentication(this, Message))
+         return;
 
-      std::string FinalFile = _config->FindDir("Dir::State::lists");
-      FinalFile += URItoFileName(RealURI);
+   string const FinalRelease = MetaIndex->GetFinalFilename();
+   string const FinalReleasegpg = GetFinalFilename();
+   string const FinalInRelease = TransactionManager->GetFinalFilename();
 
-      // move the result into place
-      if(Debug)
-        std::clog << "Queue patched file in place: " << std::endl
-                  << DestFile << " -> " << FinalFile << std::endl;
+   if (RealFileExists(FinalReleasegpg) || RealFileExists(FinalInRelease))
+   {
+      std::string downgrade_msg;
+      strprintf(downgrade_msg, _("The repository '%s' is no longer signed."),
+                MetaIndex->Target.Description.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."));
+         Status = StatDone;
+      } else {
+        MessageInsecureRepository(true, downgrade_msg);
+        if (TransactionManager->IMSHit == false)
+           Rename(MetaIndex->DestFile, MetaIndex->DestFile + ".FAILED");
+        Item::Failed("Message: " + downgrade_msg, Cnf);
+         TransactionManager->AbortTransaction();
+         return;
+      }
+   }
 
-      // queue for copy by the transaction manager
-      TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
+   // ensures that a Release.gpg file in the lists/ is removed by the transaction
+   TransactionManager->TransactionStageRemoval(this, DestFile);
 
-      // ensure the ed's are gone regardless of list-cleanup
-      for (std::vector<pkgAcqIndexMergeDiffs *>::const_iterator I = allPatches->begin();
-           I != allPatches->end(); ++I)
+   // only allow going further if the user explicitly wants it
+   if (AllowInsecureRepositories(_("The repository '%s' is not signed."), MetaIndex->Target.Description, TransactionManager->MetaIndexParser, TransactionManager, this) == true)
+   {
+      if (RealFileExists(FinalReleasegpg) || RealFileExists(FinalInRelease))
       {
-        std::string const PartialFile = GetPartialFileNameFromURI(RealURI);
-        std::string patch = PartialFile + ".ed." + (*I)->patch.file + ".gz";
-        unlink(patch.c_str());
+        // open the last Release if we have it
+        if (TransactionManager->IMSHit == false)
+        {
+           TransactionManager->LastMetaIndexParser = TransactionManager->MetaIndexParser->UnloadedClone();
+           if (TransactionManager->LastMetaIndexParser != NULL)
+           {
+              _error->PushToStack();
+              if (RealFileExists(FinalInRelease))
+                 TransactionManager->LastMetaIndexParser->Load(FinalInRelease, NULL);
+              else
+                 TransactionManager->LastMetaIndexParser->Load(FinalRelease, NULL);
+              // its unlikely to happen, but if what we have is bad ignore it
+              if (_error->PendingError())
+              {
+                 delete TransactionManager->LastMetaIndexParser;
+                 TransactionManager->LastMetaIndexParser = NULL;
+              }
+              _error->RevertToStack();
+           }
+        }
       }
 
-      // all set and done
-      Complete = true;
-      if(Debug)
-        std::clog << "allDone: " << DestFile << "\n" << std::endl;
+      // we parse the indexes here because at this point the user wanted
+      // a repository that may potentially harm him
+      bool const GoodLoad = TransactionManager->MetaIndexParser->Load(MetaIndex->DestFile, &ErrorText);
+      if (MetaIndex->VerifyVendor(Message) == false)
+        /* expired Release files are still a problem you need extra force for */;
+      else
+        MetaIndex->QueueIndexes(GoodLoad);
+
+      TransactionManager->TransactionStageCopy(MetaIndex, MetaIndex->DestFile, MetaIndex->GetFinalFilename());
    }
-}
-                                                                       /*}}}*/
-// AcqBaseIndex::VerifyHashByMetaKey - verify hash for the given metakey /*{{{*/
-bool pkgAcqBaseIndex::VerifyHashByMetaKey(HashStringList const &Hashes)
-{
-   if(MetaKey != "" && Hashes.usable())
+
+   // FIXME: this is used often (e.g. in pkgAcqIndexTrans) so refactor
+   if (Cnf->LocalOnly == true ||
+       StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
    {
-      indexRecords::checkSum *Record = MetaIndexParser->Lookup(MetaKey);
-      if(Record && Record->Hashes.usable() && Hashes != Record->Hashes)
-      {
-         printHashSumComparision(RealURI, Record->Hashes, Hashes);
-         return false;
-      }
+      // Ignore this
+      Status = StatDone;
    }
-   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,
-                        HashStringList const  &ExpectedHash)
-   : pkgAcqBaseIndex(Owner, 0, NULL, ExpectedHash, NULL)
-{
-   RealURI = URI;
 
-   AutoSelectCompression();
-   Init(URI, URIDesc, ShortDesc);
 
-   if(_config->FindB("Debug::Acquire::Transaction", false) == true)
-      std::clog << "New pkgIndex with TransactionManager "
-                << TransactionManager << std::endl;
-}
-                                                                       /*}}}*/
-// AcqIndex::AcqIndex - Constructor                                    /*{{{*/
-pkgAcqIndex::pkgAcqIndex(pkgAcquire *Owner,
-                         pkgAcqMetaBase *TransactionManager,
-                         IndexTarget const *Target,
-                        HashStringList const &ExpectedHash,
-                         indexRecords *MetaIndexParser)
-   : pkgAcqBaseIndex(Owner, TransactionManager, Target, ExpectedHash,
-                     MetaIndexParser)
+// AcqBaseIndex - Constructor                                          /*{{{*/
+pkgAcqBaseIndex::pkgAcqBaseIndex(pkgAcquire * const Owner,
+      pkgAcqMetaClearSig * const TransactionManager,
+      IndexTarget const &Target)
+: pkgAcqTransactionItem(Owner, TransactionManager, Target), d(NULL)
 {
-   RealURI = Target->URI;
-
-   // autoselect the compression method
-   AutoSelectCompression();
-   Init(Target->URI, Target->Description, Target->ShortDesc);
-
-   if(_config->FindB("Debug::Acquire::Transaction", false) == true)
-      std::clog << "New pkgIndex with TransactionManager "
-                << TransactionManager << std::endl;
 }
                                                                        /*}}}*/
-// AcqIndex::AutoSelectCompression - Select compression                        /*{{{*/
-void pkgAcqIndex::AutoSelectCompression()
-{
-   std::vector<std::string> types = APT::Configuration::getCompressionTypes();
-   CompressionExtensions = "";
-   if (ExpectedHashes.usable())
-   {
-      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)
-        CompressionExtensions.append(*t).append(" ");
-   }
-   if (CompressionExtensions.empty() == false)
-      CompressionExtensions.erase(CompressionExtensions.end()-1);
-}
-                                                                       /*}}}*/
-// AcqIndex::Init - defered Constructor                                        /*{{{*/
-void pkgAcqIndex::Init(string const &URI, string const &URIDesc,
-                       string const &ShortDesc)
-{
-   Stage = STAGE_DOWNLOAD;
-
-   DestFile = GetPartialFileNameFromURI(URI);
+pkgAcqBaseIndex::~pkgAcqBaseIndex() {}
 
-   CurrentCompressionExtension = CompressionExtensions.substr(0, CompressionExtensions.find(' '));
-   if (CurrentCompressionExtension == "uncompressed")
-   {
-      Desc.URI = URI;
-      if(Target)
-         MetaKey = string(Target->MetaKey);
-   }
-   else
-   {
-      Desc.URI = URI + '.' + CurrentCompressionExtension;
-      DestFile = DestFile + '.' + CurrentCompressionExtension;
-      if(Target)
-         MetaKey = string(Target->MetaKey) + '.' + CurrentCompressionExtension;
-   }
+// AcqDiffIndex::AcqDiffIndex - Constructor                            /*{{{*/
+// ---------------------------------------------------------------------
+/* Get the DiffIndex file first and see if there are patches available
+ * If so, create a pkgAcqIndexDiffs fetcher that will get and apply the
+ * patches. If anything goes wrong in that process, it will fall back to
+ * the original packages file
+ */
+pkgAcqDiffIndex::pkgAcqDiffIndex(pkgAcquire * const Owner,
+                                 pkgAcqMetaClearSig * const TransactionManager,
+                                 IndexTarget const &Target)
+   : pkgAcqBaseIndex(Owner, TransactionManager, Target), d(NULL), diffs(NULL)
+{
+   Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 
-   // load the filesize
-   if(MetaIndexParser)
-   {
-      indexRecords::checkSum *Record = MetaIndexParser->Lookup(MetaKey);
-      if(Record)
-         FileSize = Record->Size;
+   Desc.Owner = this;
+   Desc.Description = Target.Description + ".diff/Index";
+   Desc.ShortDesc = Target.ShortDesc;
+   Desc.URI = Target.URI + ".diff/Index";
 
-      InitByHashIfNeeded(MetaKey);
-   }
+   DestFile = GetPartialFileNameFromURI(Desc.URI);
 
-   Desc.Description = URIDesc;
-   Desc.Owner = this;
-   Desc.ShortDesc = ShortDesc;
+   if(Debug)
+      std::clog << "pkgAcqDiffIndex: " << Desc.URI << std::endl;
 
    QueueURI(Desc);
 }
                                                                        /*}}}*/
-// AcqIndex::AdjustForByHash - modify URI for by-hash support          /*{{{*/
-void pkgAcqIndex::InitByHashIfNeeded(const std::string MetaKey)
-{
-   // TODO:
-   //  - (maybe?) add support for by-hash into the sources.list as flag
-   //  - make apt-ftparchive generate the hashes (and expire?)
-   std::string HostKnob = "APT::Acquire::" + ::URI(Desc.URI).Host + "::By-Hash";
-   if(_config->FindB("APT::Acquire::By-Hash", false) == true ||
-      _config->FindB(HostKnob, false) == true ||
-      MetaIndexParser->GetSupportsAcquireByHash())
-   {
-      indexRecords::checkSum *Record = MetaIndexParser->Lookup(MetaKey);
-      if(Record)
-      {
-         // FIXME: should we really use the best hash here? or a fixed one?
-         const HashString *TargetHash = Record->Hashes.find("");
-         std::string ByHash = "/by-hash/" + TargetHash->HashType() + "/" + TargetHash->HashValue();
-         size_t trailing_slash = Desc.URI.find_last_of("/");
-         Desc.URI = Desc.URI.replace(
-            trailing_slash,
-            Desc.URI.substr(trailing_slash+1).size()+1,
-            ByHash);
-      } else {
-         _error->Warning(
-            "Fetching ByHash requested but can not find record for %s",
-            MetaKey.c_str());
-      }
-   }
-}
-                                                                       /*}}}*/
 // AcqIndex::Custom600Headers - Insert custom request headers          /*{{{*/
 // ---------------------------------------------------------------------
 /* The only header we use is the last-modified header. */
-string pkgAcqIndex::Custom600Headers() const
-{
-   string Final = GetFinalFilename();
-
-   string msg = "\nIndex-File: true";
-   struct stat Buf;
-   if (stat(Final.c_str(),&Buf) == 0)
-      msg += "\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
-
-   return msg;
-}
-                                                                       /*}}}*/
-// pkgAcqIndex::Failed - getting the indexfile failed                  /*{{{*/
-void pkgAcqIndex::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
+string pkgAcqDiffIndex::Custom600Headers() const
 {
-   size_t const nextExt = CompressionExtensions.find(' ');
-   if (nextExt != std::string::npos)
-   {
-      CompressionExtensions = CompressionExtensions.substr(nextExt+1);
-      Init(RealURI, Desc.Description, Desc.ShortDesc);
-      return;
-   }
+   if (TransactionManager->LastMetaIndexParser != NULL)
+      return "\nIndex-File: true";
 
-   // on decompression failure, remove bad versions in partial/
-   if (Stage == STAGE_DECOMPRESS_AND_VERIFY)
-   {
-      unlink(EraseFileName.c_str());
-   }
+   string const Final = GetFinalFilename();
 
-   Item::Failed(Message,Cnf);
+   if(Debug)
+      std::clog << "Custom600Header-IMS: " << Final << std::endl;
 
-   /// cancel the entire transaction
-   TransactionManager->AbortTransaction();
+   struct stat Buf;
+   if (stat(Final.c_str(),&Buf) != 0)
+      return "\nIndex-File: true";
+   
+   return "\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
 }
                                                                        /*}}}*/
-// pkgAcqIndex::GetFinalFilename - Return the full final file path     /*{{{*/
-std::string pkgAcqIndex::GetFinalFilename() const
+void pkgAcqDiffIndex::QueueOnIMSHit() const                            /*{{{*/
 {
-   std::string FinalFile = _config->FindDir("Dir::State::lists");
-   FinalFile += URItoFileName(RealURI);
-   if (_config->FindB("Acquire::GzipIndexes",false) == true)
-      FinalFile += '.' + CurrentCompressionExtension;
-   return FinalFile;
+   // 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);
 }
                                                                        /*}}}*/
-// AcqIndex::ReverifyAfterIMS - Reverify index after an ims-hit                /*{{{*/
-void pkgAcqIndex::ReverifyAfterIMS()
+bool pkgAcqDiffIndex::ParseDiffIndex(string const &IndexDiffFile)      /*{{{*/
 {
-   // update destfile to *not* include the compression extension when doing
-   // a reverify (as its uncompressed on disk already)
-   DestFile = GetPartialFileNameFromURI(RealURI);
+   // failing here is fine: our caller will take care of trying to
+   // get the complete file if patching fails
+   if(Debug)
+      std::clog << "pkgAcqDiffIndex::ParseIndexDiff() " << IndexDiffFile
+        << std::endl;
 
-   // adjust DestFile if its compressed on disk
-   if (_config->FindB("Acquire::GzipIndexes",false) == true)
-      DestFile += '.' + CurrentCompressionExtension;
+   FileFd Fd(IndexDiffFile,FileFd::ReadOnly);
+   pkgTagFile TF(&Fd);
+   if (Fd.IsOpen() == false || Fd.Failed())
+      return false;
 
-   // copy FinalFile into partial/ so that we check the hash again
-   string FinalFile = GetFinalFilename();
-   Stage = STAGE_DECOMPRESS_AND_VERIFY;
-   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
+   pkgTagSection Tags;
+   if(unlikely(TF.Step(Tags) == false))
+      return false;
+
+   HashStringList ServerHashes;
+   unsigned long long ServerSize = 0;
 
-   /* 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)
+   for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
    {
-      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;
+      std::string tagname = *type;
+      tagname.append("-Current");
+      std::string const tmp = Tags.FindS(tagname.c_str());
+      if (tmp.empty() == true)
+        continue;
+
+      string hash;
+      unsigned long long size;
+      std::stringstream ss(tmp);
+      ss >> hash >> size;
+      if (unlikely(hash.empty() == true))
+        continue;
+      if (unlikely(ServerSize != 0 && ServerSize != size))
+        continue;
+      ServerHashes.push_back(HashString(*type, hash));
+      ServerSize = size;
    }
-   return true;
-}
-                                                                       /*}}}*/
-// AcqIndex::Done - Finished a fetch                                   /*{{{*/
-// ---------------------------------------------------------------------
-/* This goes through a number of states.. On the initial fetch the
-   method could possibly return an alternate filename which points
-   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,
-                      pkgAcquire::MethodConfig *Cfg)
-{
-   Item::Done(Message,Size,Hashes,Cfg);
 
-   switch(Stage) 
+   if (ServerHashes.usable() == false)
    {
-      case STAGE_DOWNLOAD:
-         StageDownloadDone(Message, Hashes, Cfg);
-         break;
-      case STAGE_DECOMPRESS_AND_VERIFY:
-         StageDecompressDone(Message, Hashes, Cfg);
-         break;
+      if (Debug == true)
+        std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": Did not find a good hashsum in the index" << std::endl;
+      return false;
    }
-}
-                                                                       /*}}}*/
-// 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)
+
+   std::string const CurrentPackagesFile = GetFinalFileNameFromURI(Target.URI);
+   HashStringList const TargetFileHashes = GetExpectedHashesFor(Target.MetaKey);
+   if (TargetFileHashes.usable() == false || ServerHashes != TargetFileHashes)
    {
-      RenameOnError(HashSumMismatch);
-      Failed(Message, Cfg);
-      return;
+      if (Debug == true)
+      {
+        std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": Index has different hashes than parser, probably older, so fail pdiffing" << std::endl;
+         printHashSumComparision(CurrentPackagesFile, ServerHashes, TargetFileHashes);
+      }
+      return false;
    }
 
-   Complete = true;
-
-   // Handle the unzipd case
-   string FileName = LookupTag(Message,"Alt-Filename");
-   if (FileName.empty() == false)
+   HashStringList LocalHashes;
+   // try avoiding calculating the hash here as this is costly
+   if (TransactionManager->LastMetaIndexParser != NULL)
+      LocalHashes = GetExpectedHashesFromFor(TransactionManager->LastMetaIndexParser, Target.MetaKey);
+   if (LocalHashes.usable() == false)
    {
-      Stage = STAGE_DECOMPRESS_AND_VERIFY;
-      Local = true;
-      DestFile += ".decomp";
-      Desc.URI = "copy:" + FileName;
-      QueueURI(Desc);
-      SetActiveSubprocess("copy");
-      return;
+      FileFd fd(CurrentPackagesFile, FileFd::ReadOnly, FileFd::Auto);
+      Hashes LocalHashesCalc(ServerHashes);
+      LocalHashesCalc.AddFD(fd);
+      LocalHashes = LocalHashesCalc.GetHashStringList();
    }
 
-   FileName = LookupTag(Message,"Filename");
-   if (FileName.empty() == true)
+   if (ServerHashes == LocalHashes)
    {
-      Status = StatError;
-      ErrorText = "Method gave a blank filename";
+      // we have the same sha1 as the server so we are done here
+      if(Debug)
+        std::clog << "pkgAcqDiffIndex: Package file " << CurrentPackagesFile << " is up-to-date" << std::endl;
+      QueueOnIMSHit();
+      return 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;
+   if(Debug)
+      std::clog << "Server-Current: " << ServerHashes.find(NULL)->toStr() << " and we start at "
+        << CurrentPackagesFile << " " << LocalHashes.FileSize() << " " << LocalHashes.find(NULL)->toStr() << std::endl;
 
-   // 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)
+   // historically, older hashes have more info than newer ones, so start
+   // collecting with older ones first to avoid implementing complicated
+   // information merging techniques… a failure is after all always
+   // recoverable with a complete file and hashes aren't changed that often.
+   std::vector<char const *> types;
+   for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
+      types.push_back(*type);
+
+   // parse all of (provided) history
+   vector<DiffInfo> available_patches;
+   bool firstAcceptedHashes = true;
+   for (auto type = types.crbegin(); type != types.crend(); ++type)
    {
-      // 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;
+      if (LocalHashes.find(*type) == NULL)
+        continue;
 
-      // The files timestamp matches, reverify by copy into partial/
-      EraseFileName = "";
-      ReverifyAfterIMS();
-      return;
-   }
+      std::string tagname = *type;
+      tagname.append("-History");
+      std::string const tmp = Tags.FindS(tagname.c_str());
+      if (tmp.empty() == true)
+        continue;
 
-   // If we have compressed indexes enabled, queue for hash verification
-   if (_config->FindB("Acquire::GzipIndexes",false))
-   {
-      DestFile = GetPartialFileNameFromURI(RealURI + '.' + CurrentCompressionExtension);
-      EraseFileName = "";
-      Stage = STAGE_DECOMPRESS_AND_VERIFY;
-      Desc.URI = "copy:" + FileName;
-      QueueURI(Desc);
-      SetActiveSubprocess("copy");
-      return;
-    }
+      string hash, filename;
+      unsigned long long size;
+      std::stringstream ss(tmp);
 
-   // get the binary name for your used compression type
-   string decompProg;
-   if(CurrentCompressionExtension == "uncompressed")
-      decompProg = "copy";
-   else
-      decompProg = _config->Find(string("Acquire::CompressionTypes::").append(CurrentCompressionExtension),"");
-   if(decompProg.empty() == true)
-   {
-      _error->Error("Unsupported extension: %s", CurrentCompressionExtension.c_str());
-      return;
+      while (ss >> hash >> size >> filename)
+      {
+        if (unlikely(hash.empty() == true || filename.empty() == true))
+           continue;
+
+        // see if we have a record for this file already
+        std::vector<DiffInfo>::iterator cur = available_patches.begin();
+        for (; cur != available_patches.end(); ++cur)
+        {
+           if (cur->file != filename)
+              continue;
+           cur->result_hashes.push_back(HashString(*type, hash));
+           break;
+        }
+        if (cur != available_patches.end())
+           continue;
+        if (firstAcceptedHashes == true)
+        {
+           DiffInfo next;
+           next.file = filename;
+           next.result_hashes.push_back(HashString(*type, hash));
+           next.result_hashes.FileSize(size);
+           available_patches.push_back(next);
+        }
+        else
+        {
+           if (Debug == true)
+              std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": File " << filename
+                 << " wasn't in the list for the first parsed hash! (history)" << std::endl;
+           break;
+        }
+      }
+      firstAcceptedHashes = false;
    }
 
-   // queue uri for the next stage
-   Stage = STAGE_DECOMPRESS_AND_VERIFY;
-   DestFile += ".decomp";
-   Desc.URI = decompProg + ":" + FileName;
-   QueueURI(Desc);
-   SetActiveSubprocess(decompProg);
-}
-                                                                       /*}}}*/
-// pkgAcqIndex::StageDecompressDone - Final verification               /*{{{*/
-void pkgAcqIndex::StageDecompressDone(string Message,
-                                      HashStringList const &Hashes,
-                                      pkgAcquire::MethodConfig *Cfg)
-{
-   if (ExpectedHashes.usable() && ExpectedHashes != Hashes)
+   if (unlikely(available_patches.empty() == true))
    {
-      Desc.URI = RealURI;
-      RenameOnError(HashSumMismatch);
-      printHashSumComparision(RealURI, ExpectedHashes, Hashes);
-      Failed(Message, Cfg);
-      return;
+      if (Debug)
+        std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": "
+           << "Couldn't find any patches for the patch series." << std::endl;
+      return false;
    }
 
-   if(!ValidateFile(DestFile))
+   for (auto type = types.crbegin(); type != types.crend(); ++type)
    {
-      RenameOnError(InvalidFormat);
-      Failed(Message, Cfg);
-      return;
-   }
+      if (LocalHashes.find(*type) == NULL)
+        continue;
 
-   // remove the compressed version of the file
-   unlink(EraseFileName.c_str());
+      std::string tagname = *type;
+      tagname.append("-Patches");
+      std::string const tmp = Tags.FindS(tagname.c_str());
+      if (tmp.empty() == true)
+        continue;
 
-   // Done, queue for rename on transaction finished
-   TransactionManager->TransactionStageCopy(this, DestFile, GetFinalFilename());
+      string hash, filename;
+      unsigned long long size;
+      std::stringstream ss(tmp);
 
-   return;
-}
-                                                                       /*}}}*/
-// 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())
-{
-}
-pkgAcqIndexTrans::pkgAcqIndexTrans(pkgAcquire *Owner,
-                                   pkgAcqMetaBase *TransactionManager,
-                                   IndexTarget const * const Target,
-                                   HashStringList const &ExpectedHashes,
-                                   indexRecords *MetaIndexParser)
-   : pkgAcqIndex(Owner, TransactionManager, Target, ExpectedHashes, MetaIndexParser)
-{
-   // load the filesize
-   indexRecords::checkSum *Record = MetaIndexParser->Lookup(string(Target->MetaKey));
-   if(Record)
-      FileSize = Record->Size;
-}
-                                                                       /*}}}*/
-// AcqIndexTrans::Custom600Headers - Insert custom request headers     /*{{{*/
-string pkgAcqIndexTrans::Custom600Headers() const
-{
-   string Final = GetFinalFilename();
+      while (ss >> hash >> size >> filename)
+      {
+        if (unlikely(hash.empty() == true || filename.empty() == true))
+           continue;
 
-   struct stat Buf;
-   if (stat(Final.c_str(),&Buf) != 0)
-      return "\nFail-Ignore: true\nIndex-File: true";
-   return "\nFail-Ignore: true\nIndex-File: true\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
-}
-                                                                       /*}}}*/
-// AcqIndexTrans::Failed - Silence failure messages for missing files  /*{{{*/
-void pkgAcqIndexTrans::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
-{
-   size_t const nextExt = CompressionExtensions.find(' ');
-   if (nextExt != std::string::npos)
+        // see if we have a record for this file already
+        std::vector<DiffInfo>::iterator cur = available_patches.begin();
+        for (; cur != available_patches.end(); ++cur)
+        {
+           if (cur->file != filename)
+              continue;
+           if (cur->patch_hashes.empty())
+              cur->patch_hashes.FileSize(size);
+           cur->patch_hashes.push_back(HashString(*type, hash));
+           break;
+        }
+        if (cur != available_patches.end())
+              continue;
+        if (Debug == true)
+           std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": File " << filename
+              << " wasn't in the list for the first parsed hash! (patches)" << std::endl;
+        break;
+      }
+   }
+
+   for (auto type = types.crbegin(); type != types.crend(); ++type)
    {
-      CompressionExtensions = CompressionExtensions.substr(nextExt+1);
-      Init(RealURI, Desc.Description, Desc.ShortDesc);
-      Status = StatIdle;
-      return;
+      std::string tagname = *type;
+      tagname.append("-Download");
+      std::string const tmp = Tags.FindS(tagname.c_str());
+      if (tmp.empty() == true)
+        continue;
+
+      string hash, filename;
+      unsigned long long size;
+      std::stringstream ss(tmp);
+
+      // FIXME: all of pdiff supports only .gz compressed patches
+      while (ss >> hash >> size >> filename)
+      {
+        if (unlikely(hash.empty() == true || filename.empty() == true))
+           continue;
+        if (unlikely(APT::String::Endswith(filename, ".gz") == false))
+           continue;
+        filename.erase(filename.length() - 3);
+
+        // see if we have a record for this file already
+        std::vector<DiffInfo>::iterator cur = available_patches.begin();
+        for (; cur != available_patches.end(); ++cur)
+        {
+           if (cur->file != filename)
+              continue;
+           if (cur->download_hashes.empty())
+              cur->download_hashes.FileSize(size);
+           cur->download_hashes.push_back(HashString(*type, hash));
+           break;
+        }
+        if (cur != available_patches.end())
+              continue;
+        if (Debug == true)
+           std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": File " << filename
+              << " wasn't in the list for the first parsed hash! (download)" << std::endl;
+        break;
+      }
    }
 
-   Item::Failed(Message,Cnf);
 
-   // FIXME: this is used often (e.g. in pkgAcqIndexTrans) so refactor
-   if (Cnf->LocalOnly == true ||
-       StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
+   bool foundStart = false;
+   for (std::vector<DiffInfo>::iterator cur = available_patches.begin();
+        cur != available_patches.end(); ++cur)
    {
-      // Ignore this
-      Status = StatDone;
+      if (LocalHashes != cur->result_hashes)
+        continue;
+
+      available_patches.erase(available_patches.begin(), cur);
+      foundStart = true;
+      break;
    }
-}
-                                                                       /*}}}*/
-// AcqMetaBase::Add - Add a item to the current Transaction            /*{{{*/
-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;
 
-   // ensure the toplevel is in error state too
-   for (std::vector<Item*>::iterator I = Transaction.begin();
-        I != Transaction.end(); ++I)
+   if (foundStart == false || unlikely(available_patches.empty() == true))
    {
-      if(_config->FindB("Debug::Acquire::Transaction", false) == true)
-         std::clog << "  Cancel: " << (*I)->DestFile << std::endl;
-      // the transaction will abort, so stop anything that is idle
-      if ((*I)->Status == pkgAcquire::Item::StatIdle)
-         (*I)->Status = pkgAcquire::Item::StatDone;
+      if (Debug)
+        std::clog << "pkgAcqDiffIndex: " << IndexDiffFile << ": "
+           << "Couldn't find the start of the patch series." << std::endl;
+      return false;
+   }
 
-      // kill failed files in partial
-      if ((*I)->Status == pkgAcquire::Item::StatError)
+   // patching with too many files is rather slow compared to a fast download
+   unsigned long const fileLimit = _config->FindI("Acquire::PDiffs::FileLimit", 0);
+   if (fileLimit != 0 && fileLimit < available_patches.size())
+   {
+      if (Debug)
+        std::clog << "Need " << available_patches.size() << " diffs (Limit is " << fileLimit
+           << ") so fallback to complete download" << std::endl;
+      return false;
+   }
+
+   // calculate the size of all patches we have to get
+   unsigned short const sizeLimitPercent = _config->FindI("Acquire::PDiffs::SizeLimit", 100);
+   if (sizeLimitPercent > 0 && TransactionManager->MetaIndexParser != nullptr)
+   {
+      // compressed case
+      unsigned long long downloadSize = std::accumulate(available_patches.begin(),
+           available_patches.end(), 0llu, [](unsigned long long const T, DiffInfo const &I) {
+           return T + I.download_hashes.FileSize();
+           });
+      if (downloadSize != 0)
+      {
+        unsigned long long downloadSizeIdx = 0;
+        auto const types = VectorizeString(Target.Option(IndexTarget::COMPRESSIONTYPES), ' ');
+        for (auto const &t : types)
+        {
+           std::string MetaKey = Target.MetaKey;
+           if (t != "uncompressed")
+              MetaKey += '.' + t;
+           HashStringList const hsl = GetExpectedHashesFor(MetaKey);
+           if (unlikely(hsl.usable() == false))
+              continue;
+           downloadSizeIdx = hsl.FileSize();
+           break;
+        }
+        unsigned long long const sizeLimit = downloadSizeIdx * sizeLimitPercent;
+        if ((sizeLimit/100) < downloadSize)
+        {
+           if (Debug)
+              std::clog << "Need " << downloadSize << " compressed bytes (Limit is " << (sizeLimit/100) << ", "
+                 << "original is " << downloadSizeIdx << ") so fallback to complete download" << std::endl;
+           return false;
+        }
+      }
+      // uncompressed case
+      downloadSize = std::accumulate(available_patches.begin(),
+           available_patches.end(), 0llu, [](unsigned long long const T, DiffInfo const &I) {
+           return T + I.patch_hashes.FileSize();
+           });
+      if (downloadSize != 0)
       {
-         std::string const PartialFile = GetPartialFileName(flNotDir((*I)->DestFile));
-         if(FileExists(PartialFile))
-            Rename(PartialFile, PartialFile + ".FAILED");
+        unsigned long long const downloadSizeIdx = ServerSize;
+        unsigned long long const sizeLimit = downloadSizeIdx * sizeLimitPercent;
+        if ((sizeLimit/100) < downloadSize)
+        {
+           if (Debug)
+              std::clog << "Need " << downloadSize << " uncompressed bytes (Limit is " << (sizeLimit/100) << ", "
+                 << "original is " << downloadSizeIdx << ") so fallback to complete download" << std::endl;
+           return false;
+        }
       }
    }
-}
-                                                                       /*}}}*/
-// AcqMetaBase::TransactionHasError - Check for errors in Transaction  /*{{{*/
-bool pkgAcqMetaBase::TransactionHasError()
-{
-   for (pkgAcquire::ItemIterator I = Transaction.begin();
-        I != Transaction.end(); ++I)
-      if((*I)->Status != pkgAcquire::Item::StatDone &&
-         (*I)->Status != pkgAcquire::Item::StatIdle)
-         return true;
 
-   return false;
-}
-                                                                       /*}}}*/
-// AcqMetaBase::CommitTransaction - Commit a transaction               /*{{{*/
-void pkgAcqMetaBase::CommitTransaction()
-{
-   if(_config->FindB("Debug::Acquire::Transaction", false) == true)
-      std::clog << "CommitTransaction: " << this << std::endl;
+   // we have something, queue the diffs
+   string::size_type const last_space = Description.rfind(" ");
+   if(last_space != string::npos)
+      Description.erase(last_space, Description.size()-last_space);
 
-   // move new files into place *and* remove files that are not
-   // part of the transaction but are still on disk
-   for (std::vector<Item*>::iterator I = Transaction.begin();
-        I != Transaction.end(); ++I)
+   /* decide if we should download patches one by one or in one go:
+      The first is good if the server merges patches, but many don't so client
+      based merging can be attempt in which case the second is better.
+      "bad things" will happen if patches are merged on the server,
+      but client side merging is attempt as well */
+   bool pdiff_merge = _config->FindB("Acquire::PDiffs::Merge", true);
+   if (pdiff_merge == true)
    {
-      if((*I)->PartialFile != "")
-      {
-        if(_config->FindB("Debug::Acquire::Transaction", false) == true)
-           std::clog << "mv " << (*I)->PartialFile << " -> "<< (*I)->DestFile << " "
-              << (*I)->DescURI() << std::endl;
-
-        Rename((*I)->PartialFile, (*I)->DestFile);
-        ChangeOwnerAndPermissionOfFile("CommitTransaction", (*I)->DestFile.c_str(), "root", "root", 0644);
+      // reprepro adds this flag if it has merged patches on the server
+      std::string const precedence = Tags.FindS("X-Patch-Precedence");
+      pdiff_merge = (precedence != "merged");
+   }
 
-      } else {
-         if(_config->FindB("Debug::Acquire::Transaction", false) == true)
-            std::clog << "rm "
-                      <<  (*I)->DestFile
-                      << " "
-                      << (*I)->DescURI()
-                      << std::endl;
-         unlink((*I)->DestFile.c_str());
+   // clean the plate
+   {
+      std::string const Final = GetExistingFilename(CurrentPackagesFile);
+      if (unlikely(Final.empty())) // because we wouldn't be called in such a case
+        return false;
+      std::string const PartialFile = GetPartialFileNameFromURI(Target.URI);
+      if (FileExists(PartialFile) && RemoveFile("Bootstrap-linking", PartialFile) == false)
+      {
+        if (Debug)
+           std::clog << "Bootstrap-linking for patching " << CurrentPackagesFile
+              << " by removing stale " << PartialFile << " failed!" << std::endl;
+        return false;
+      }
+      for (auto const &ext : APT::Configuration::getCompressorExtensions())
+      {
+        std::string const Partial = PartialFile + ext;
+        if (FileExists(Partial) && RemoveFile("Bootstrap-linking", Partial) == false)
+        {
+           if (Debug)
+              std::clog << "Bootstrap-linking for patching " << CurrentPackagesFile
+                 << " by removing stale " << Partial << " failed!" << std::endl;
+           return false;
+        }
+      }
+      std::string const Ext = Final.substr(CurrentPackagesFile.length());
+      std::string const Partial = PartialFile + Ext;
+      if (symlink(Final.c_str(), Partial.c_str()) != 0)
+      {
+        if (Debug)
+           std::clog << "Bootstrap-linking for patching " << CurrentPackagesFile
+              << " by linking " << Final << " to " << Partial << " failed!" << std::endl;
+        return false;
       }
-      // mark that this transaction is finished
-      (*I)->TransactionManager = 0;
    }
+
+   if (pdiff_merge == false)
+      new pkgAcqIndexDiffs(Owner, TransactionManager, Target, available_patches);
+   else
+   {
+      diffs = new std::vector<pkgAcqIndexMergeDiffs*>(available_patches.size());
+      for(size_t i = 0; i < available_patches.size(); ++i)
+        (*diffs)[i] = new pkgAcqIndexMergeDiffs(Owner, TransactionManager,
+               Target,
+              available_patches[i],
+              diffs);
+   }
+
+   Complete = false;
+   Status = StatDone;
+   Dequeue();
+   return true;
 }
                                                                        /*}}}*/
-// AcqMetaBase::TransactionStageCopy - Stage a file for copying                /*{{{*/
-void pkgAcqMetaBase::TransactionStageCopy(Item *I,
-                                          const std::string &From,
-                                          const std::string &To)
-{
-   I->PartialFile = From;
-   I->DestFile = To;
-}
-                                                                       /*}}}*/
-// AcqMetaBase::TransactionStageRemoval - Sage a file for removal      /*{{{*/
-void pkgAcqMetaBase::TransactionStageRemoval(Item *I,
-                                             const std::string &FinalFile)
+void pkgAcqDiffIndex::Failed(string const &Message,pkgAcquire::MethodConfig const * const Cnf)/*{{{*/
 {
-   I->PartialFile = "";
-   I->DestFile = FinalFile; 
+   Item::Failed(Message,Cnf);
+   Status = StatDone;
+
+   if(Debug)
+      std::clog << "pkgAcqDiffIndex failed: " << Desc.URI << " with " << Message << std::endl
+               << "Falling back to normal index file acquire" << std::endl;
+
+   new pkgAcqIndex(Owner, TransactionManager, Target);
 }
                                                                        /*}}}*/
-// AcqMetaBase::GenerateAuthWarning - Check gpg authentication error   /*{{{*/
-bool pkgAcqMetaBase::CheckStopAuthentication(const std::string &RealURI,
-                                             const std::string &Message)
+void pkgAcqDiffIndex::Done(string const &Message,HashStringList const &Hashes, /*{{{*/
+                          pkgAcquire::MethodConfig const * const Cnf)
 {
-   // FIXME: this entire function can do now that we disallow going to
-   //        a unauthenticated state and can cleanly rollback
+   if(Debug)
+      std::clog << "pkgAcqDiffIndex::Done(): " << Desc.URI << std::endl;
 
-   string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
+   Item::Done(Message, Hashes, Cnf);
 
-   if(FileExists(Final))
+   string const FinalFile = GetFinalFilename();
+   if(StringToBool(LookupTag(Message,"IMS-Hit"),false))
+      DestFile = FinalFile;
+
+   if(ParseDiffIndex(DestFile) == false)
    {
-      Status = StatTransientNetworkError;
-      _error->Warning(_("An error occurred during the signature "
-                        "verification. The repository is not updated "
-                        "and the previous index files will be used. "
-                        "GPG error: %s: %s\n"),
-                      Desc.Description.c_str(),
-                      LookupTag(Message,"Message").c_str());
-      RunScripts("APT::Update::Auth-Failure");
-      return true;
-   } else if (LookupTag(Message,"Message").find("NODATA") != string::npos) {
-      /* Invalid signature file, reject (LP: #346386) (Closes: #627642) */
-      _error->Error(_("GPG error: %s: %s"),
-                    Desc.Description.c_str(),
-                    LookupTag(Message,"Message").c_str());
-      Status = StatError;
-      return true;
-   } else {
-      _error->Warning(_("GPG error: %s: %s"),
-                      Desc.Description.c_str(),
-                      LookupTag(Message,"Message").c_str());
+      Failed("Message: Couldn't parse pdiff index", Cnf);
+      // queue for final move - this should happen even if we fail
+      // while parsing (e.g. on sizelimit) and download the complete file.
+      TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
+      return;
    }
-   // gpgv method failed
-   ReportMirrorFailure("GPGFailure");
-   return false;
-}
-                                                                       /*}}}*/
-// AcqMetaSig::AcqMetaSig - Constructor                                        /*{{{*/
-pkgAcqMetaSig::pkgAcqMetaSig(pkgAcquire *Owner,
-                             pkgAcqMetaBase *TransactionManager,
-                            string URI,string URIDesc,string ShortDesc,
-                             string MetaIndexFile,
-                            const vector<IndexTarget*>* IndexTargets,
-                            indexRecords* MetaIndexParser) :
-   pkgAcqMetaBase(Owner, IndexTargets, MetaIndexParser,
-                  HashStringList(), TransactionManager),
-   RealURI(URI), MetaIndexFile(MetaIndexFile), URIDesc(URIDesc),
-   ShortDesc(ShortDesc)
-{
-   DestFile = _config->FindDir("Dir::State::lists") + "partial/";
-   DestFile += URItoFileName(RealURI);
-
-   // remove any partial downloaded sig-file in partial/.
-   // it may confuse proxies and is too small to warrant a
-   // partial download anyway
-   unlink(DestFile.c_str());
 
-   // set the TransactionManager
-   if(_config->FindB("Debug::Acquire::Transaction", false) == true)
-      std::clog << "New pkgAcqMetaSig with TransactionManager "
-                << TransactionManager << std::endl;
+   TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
 
-   // Create the item
-   Desc.Description = URIDesc;
-   Desc.Owner = this;
-   Desc.ShortDesc = ShortDesc;
-   Desc.URI = URI;
+   Complete = true;
+   Status = StatDone;
+   Dequeue();
 
-   QueueURI(Desc);
-}
-                                                                       /*}}}*/
-pkgAcqMetaSig::~pkgAcqMetaSig()                                                /*{{{*/
-{
+   return;
 }
                                                                        /*}}}*/
-// pkgAcqMetaSig::Custom600Headers - Insert custom request headers     /*{{{*/
-// ---------------------------------------------------------------------
-string pkgAcqMetaSig::Custom600Headers() const
+pkgAcqDiffIndex::~pkgAcqDiffIndex()
 {
-   std::string Header = GetCustom600Headers(RealURI);
-   return Header;
+   if (diffs != NULL)
+      delete diffs;
 }
-                                                                       /*}}}*/
-// pkgAcqMetaSig::Done - The signature was downloaded/verified         /*{{{*/
+
+// AcqIndexDiffs::AcqIndexDiffs - Constructor                          /*{{{*/
 // ---------------------------------------------------------------------
-/* 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)
+/* The package diff is added to the queue. one object is constructed
+ * for each diff and the index
+ */
+pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire * const Owner,
+                                   pkgAcqMetaClearSig * const TransactionManager,
+                                   IndexTarget const &Target,
+                                  vector<DiffInfo> const &diffs)
+   : pkgAcqBaseIndex(Owner, TransactionManager, Target), d(NULL),
+     available_patches(diffs)
 {
-   Item::Done(Message, Size, Hashes, Cfg);
+   DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target);
 
-   if(AuthPass == false)
+   Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
+
+   Desc.Owner = this;
+   Description = Target.Description;
+   Desc.ShortDesc = Target.ShortDesc;
+
+   if(available_patches.empty() == true)
    {
-      if(CheckDownloadDone(Message, RealURI) == true)
-      {
-         // destfile will be modified to point to MetaIndexFile for the
-         // gpgv method, so we need to save it here
-         MetaIndexFileSignature = DestFile;
-         QueueForSignatureVerify(MetaIndexFile, MetaIndexFileSignature);
-      }
-      return;
+      // we are done (yeah!), check hashes against the final file
+      DestFile = GetKeepCompressedFileName(GetFinalFileNameFromURI(Target.URI), Target);
+      Finish(true);
    }
    else
    {
-      if(CheckAuthDone(Message, RealURI) == true)
-      {
-         std::string FinalFile = _config->FindDir("Dir::State::lists");
-         FinalFile += URItoFileName(RealURI);
-         TransactionManager->TransactionStageCopy(this, MetaIndexFileSignature, FinalFile);
-      }
+      State = StateFetchDiff;
+      QueueNextDiff();
    }
 }
                                                                        /*}}}*/
-void pkgAcqMetaSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf)/*{{{*/
+void pkgAcqIndexDiffs::Failed(string const &Message,pkgAcquire::MethodConfig const * const Cnf)/*{{{*/
 {
-   string Final = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
-
-   // check if we need to fail at this point 
-   if (AuthPass == true && CheckStopAuthentication(RealURI, Message))
-         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");
-        Item::Failed("Message: " + downgrade_msg, Cnf);
-         TransactionManager->AbortTransaction();
-         return;
-      }
-   }
-
-   // this ensures that any file in the lists/ dir is removed by the
-   // transaction
-   DestFile = GetPartialFileNameFromURI(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");
-   }
-
    Item::Failed(Message,Cnf);
+   Status = StatDone;
 
-   // FIXME: this is used often (e.g. in pkgAcqIndexTrans) so refactor
-   if (Cnf->LocalOnly == true ||
-       StringToBool(LookupTag(Message,"Transient-Failure"),false) == false)
-   {
-      // Ignore this
-      Status = StatDone;
-   }
+   DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target);
+   if(Debug)
+      std::clog << "pkgAcqIndexDiffs failed: " << Desc.URI << " with " << Message << std::endl
+               << "Falling back to normal index file acquire " << std::endl;
+   RenameOnError(PDiffError);
+   std::string const patchname = GetDiffsPatchFileName(DestFile);
+   if (RealFileExists(patchname))
+      Rename(patchname, patchname + ".FAILED");
+   std::string const UnpatchedFile = GetExistingFilename(GetPartialFileNameFromURI(Target.URI));
+   if (UnpatchedFile.empty() == false && FileExists(UnpatchedFile))
+      Rename(UnpatchedFile, UnpatchedFile + ".FAILED");
+   new pkgAcqIndex(Owner, TransactionManager, Target);
+   Finish();
 }
                                                                        /*}}}*/
-pkgAcqMetaIndex::pkgAcqMetaIndex(pkgAcquire *Owner,                    /*{{{*/
-                                 pkgAcqMetaBase *TransactionManager,
-                                string URI,string URIDesc,string ShortDesc,
-                                 string MetaIndexSigURI,string MetaIndexSigURIDesc, string MetaIndexSigShortDesc,
-                                const vector<IndexTarget*>* IndexTargets,
-                                indexRecords* MetaIndexParser) :
-   pkgAcqMetaBase(Owner, IndexTargets, MetaIndexParser, HashStringList(),
-                  TransactionManager), 
-   RealURI(URI), URIDesc(URIDesc), ShortDesc(ShortDesc),
-   MetaIndexSigURI(MetaIndexSigURI), MetaIndexSigURIDesc(MetaIndexSigURIDesc),
-   MetaIndexSigShortDesc(MetaIndexSigShortDesc)
+// Finish - helper that cleans the item out of the fetcher queue       /*{{{*/
+void pkgAcqIndexDiffs::Finish(bool allDone)
 {
-   if(TransactionManager == NULL)
-   {
-      this->TransactionManager = this;
-      this->TransactionManager->Add(this);
-   }
-
-   if(_config->FindB("Debug::Acquire::Transaction", false) == true)
-      std::clog << "New pkgAcqMetaIndex with TransactionManager "
-                << this->TransactionManager << std::endl;
-
+   if(Debug)
+      std::clog << "pkgAcqIndexDiffs::Finish(): " 
+                << allDone << " "
+                << Desc.URI << std::endl;
 
-   Init(URIDesc, ShortDesc);
-}
-                                                                       /*}}}*/
-// pkgAcqMetaIndex::Init - Delayed constructor                         /*{{{*/
-void pkgAcqMetaIndex::Init(std::string URIDesc, std::string ShortDesc)
-{
-   DestFile = GetPartialFileNameFromURI(RealURI);
+   // we restore the original name, this is required, otherwise
+   // the file will be cleaned
+   if(allDone)
+   {
+      std::string const Final = GetKeepCompressedFileName(GetFinalFilename(), Target);
+      TransactionManager->TransactionStageCopy(this, DestFile, Final);
 
-   // Create the item
-   Desc.Description = URIDesc;
-   Desc.Owner = this;
-   Desc.ShortDesc = ShortDesc;
-   Desc.URI = RealURI;
+      // this is for the "real" finish
+      Complete = true;
+      Status = StatDone;
+      Dequeue();
+      if(Debug)
+        std::clog << "\n\nallDone: " << DestFile << "\n" << std::endl;
+      return;
+   }
+   else
+      DestFile.clear();
 
-   // we expect more item
-   ExpectedAdditionalItems = IndexTargets->size();
-   QueueURI(Desc);
-}
-                                                                       /*}}}*/
-// pkgAcqMetaIndex::Custom600Headers - Insert custom request headers   /*{{{*/
-// ---------------------------------------------------------------------
-string pkgAcqMetaIndex::Custom600Headers() const
-{
-   return GetCustom600Headers(RealURI);
+   if(Debug)
+      std::clog << "Finishing: " << Desc.URI << std::endl;
+   Complete = false;
+   Status = StatDone;
+   Dequeue();
+   return;
 }
                                                                        /*}}}*/
-void pkgAcqMetaIndex::Done(string Message,unsigned long long Size,     /*{{{*/
-                           HashStringList const &Hashes,
-                          pkgAcquire::MethodConfig *Cfg)
+bool pkgAcqIndexDiffs::QueueNextDiff()                                 /*{{{*/
 {
-   Item::Done(Message,Size,Hashes,Cfg);
-
-   if(CheckDownloadDone(Message, RealURI))
+   // calc sha1 of the just patched file
+   std::string const PartialFile = GetExistingFilename(GetPartialFileNameFromURI(Target.URI));
+   if(unlikely(PartialFile.empty()))
    {
-      // we have a Release file, now download the Signature, all further
-      // verify/queue for additional downloads will be done in the
-      // pkgAcqMetaSig::Done() code
-      std::string MetaIndexFile = DestFile;
-      new pkgAcqMetaSig(Owner, TransactionManager, 
-                        MetaIndexSigURI, MetaIndexSigURIDesc,
-                        MetaIndexSigShortDesc, MetaIndexFile, IndexTargets, 
-                        MetaIndexParser);
-
-      string FinalFile = _config->FindDir("Dir::State::lists");
-      FinalFile += URItoFileName(RealURI);
-      TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
+      Failed("Message: The file " + GetPartialFileNameFromURI(Target.URI) + " isn't available", NULL);
+      return false;
    }
-}
-                                                                       /*}}}*/
-bool pkgAcqMetaBase::CheckAuthDone(string Message, const string &RealURI)      /*{{{*/
-{
-   // At this point, the gpgv method has succeeded, so there is a
-   // valid signature from a key in the trusted keyring.  We
-   // perform additional verification of its contents, and use them
-   // to verify the indexes we are about to download
 
-   if (!MetaIndexParser->Load(DestFile))
+   FileFd fd(PartialFile, FileFd::ReadOnly, FileFd::Extension);
+   Hashes LocalHashesCalc;
+   LocalHashesCalc.AddFD(fd);
+   HashStringList const LocalHashes = LocalHashesCalc.GetHashStringList();
+
+   if(Debug)
+      std::clog << "QueueNextDiff: " << PartialFile << " (" << LocalHashes.find(NULL)->toStr() << ")" << std::endl;
+
+   HashStringList const TargetFileHashes = GetExpectedHashesFor(Target.MetaKey);
+   if (unlikely(LocalHashes.usable() == false || TargetFileHashes.usable() == false))
    {
-      Status = StatAuthError;
-      ErrorText = MetaIndexParser->ErrorText;
+      Failed("Local/Expected hashes are not usable for " + PartialFile, NULL);
       return false;
    }
 
-   if (!VerifyVendor(Message, RealURI))
+   // final file reached before all patches are applied
+   if(LocalHashes == TargetFileHashes)
+   {
+      Finish(true);
+      return true;
+   }
+
+   // remove all patches until the next matching patch is found
+   // this requires the Index file to be ordered
+   available_patches.erase(available_patches.begin(),
+        std::find_if(available_patches.begin(), available_patches.end(), [&](DiffInfo const &I) {
+           return I.result_hashes == LocalHashes;
+           }));
+
+   // error checking and falling back if no patch was found
+   if(available_patches.empty() == true)
    {
+      Failed("No patches left to reach target for " + PartialFile, NULL);
       return false;
    }
 
-   if (_config->FindB("Debug::pkgAcquire::Auth", false))
-      std::cerr << "Signature verification succeeded: "
-                << DestFile << std::endl;
+   // queue the right diff
+   Desc.URI = Target.URI + ".diff/" + available_patches[0].file + ".gz";
+   Desc.Description = Description + " " + available_patches[0].file + string(".pdiff");
+   DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI + ".diff/" + available_patches[0].file), Target);
 
-   // 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(Debug)
+      std::clog << "pkgAcqIndexDiffs::QueueNextDiff(): " << Desc.URI << std::endl;
+
+   QueueURI(Desc);
 
    return true;
 }
                                                                        /*}}}*/
-// pkgAcqMetaBase::GetCustom600Headers - Get header for AcqMetaBase     /*{{{*/
-// ---------------------------------------------------------------------
-string pkgAcqMetaBase::GetCustom600Headers(const string &RealURI) const
+void pkgAcqIndexDiffs::Done(string const &Message, HashStringList const &Hashes,       /*{{{*/
+                           pkgAcquire::MethodConfig const * const Cnf)
 {
-   std::string Header = "\nIndex-File: true";
-   std::string MaximumSize;
-   strprintf(MaximumSize, "\nMaximum-Size: %i",
-             _config->FindI("Acquire::MaxReleaseFileSize", 10*1000*1000));
-   Header += MaximumSize;
+   if (Debug)
+      std::clog << "pkgAcqIndexDiffs::Done(): " << Desc.URI << std::endl;
 
-   string FinalFile = _config->FindDir("Dir::State::lists");
-   FinalFile += URItoFileName(RealURI);
+   Item::Done(Message, Hashes, Cnf);
 
-   struct stat Buf;
-   if (stat(FinalFile.c_str(),&Buf) == 0)
-      Header += "\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
+   std::string const UncompressedUnpatchedFile = GetPartialFileNameFromURI(Target.URI);
+   std::string const UnpatchedFile = GetExistingFilename(UncompressedUnpatchedFile);
+   std::string const PatchFile = GetDiffsPatchFileName(UnpatchedFile);
+   std::string const PatchedFile = GetKeepCompressedFileName(UncompressedUnpatchedFile, Target);
 
-   return Header;
+   switch (State)
+   {
+      // success in downloading a diff, enter ApplyDiff state
+      case StateFetchDiff:
+        Rename(DestFile, PatchFile);
+        DestFile = GetKeepCompressedFileName(UncompressedUnpatchedFile + "-patched", Target);
+        if(Debug)
+           std::clog << "Sending to rred method: " << UnpatchedFile << std::endl;
+        State = StateApplyDiff;
+        Local = true;
+        Desc.URI = "rred:" + UnpatchedFile;
+        QueueURI(Desc);
+        SetActiveSubprocess("rred");
+        return;
+      // success in download/apply a diff, queue next (if needed)
+      case StateApplyDiff:
+        // remove the just applied patch and base file
+        available_patches.erase(available_patches.begin());
+        RemoveFile("pkgAcqIndexDiffs::Done", PatchFile);
+        RemoveFile("pkgAcqIndexDiffs::Done", UnpatchedFile);
+        if(Debug)
+           std::clog << "Moving patched file in place: " << std::endl
+              << DestFile << " -> " << PatchedFile << std::endl;
+        Rename(DestFile, PatchedFile);
+
+        // see if there is more to download
+        if(available_patches.empty() == false)
+        {
+           new pkgAcqIndexDiffs(Owner, TransactionManager, Target, available_patches);
+           Finish();
+        } else {
+           DestFile = PatchedFile;
+           Finish(true);
+        }
+        return;
+   }
 }
                                                                        /*}}}*/
-// pkgAcqMetaBase::QueueForSignatureVerify                             /*{{{*/
-void pkgAcqMetaBase::QueueForSignatureVerify(const std::string &MetaIndexFile,
-                                    const std::string &MetaIndexFileSignature)
+std::string pkgAcqIndexDiffs::Custom600Headers() const                 /*{{{*/
 {
-   AuthPass = true;
-   Desc.URI = "gpgv:" + MetaIndexFileSignature;
-   DestFile = MetaIndexFile;
-   QueueURI(Desc);
-   SetActiveSubprocess("gpgv");
+   if(State != StateApplyDiff)
+      return pkgAcqBaseIndex::Custom600Headers();
+   std::ostringstream patchhashes;
+   HashStringList const ExpectedHashes = available_patches[0].patch_hashes;
+   for (HashStringList::const_iterator hs = ExpectedHashes.begin(); hs != ExpectedHashes.end(); ++hs)
+      patchhashes <<  "\nPatch-0-" << hs->HashType() << "-Hash: " << hs->HashValue();
+   patchhashes << pkgAcqBaseIndex::Custom600Headers();
+   return patchhashes.str();
 }
                                                                        /*}}}*/
-// pkgAcqMetaBase::CheckDownloadDone                                   /*{{{*/
-bool pkgAcqMetaBase::CheckDownloadDone(const std::string &Message,
-                                       const std::string &RealURI)
-{
-   // We have just finished downloading a Release file (it is not
-   // verified yet)
-
-   string FileName = LookupTag(Message,"Filename");
-   if (FileName.empty() == true)
-   {
-      Status = StatError;
-      ErrorText = "Method gave a blank filename";
-      return false;
-   }
+pkgAcqIndexDiffs::~pkgAcqIndexDiffs() {}
 
-   if (FileName != DestFile)
-   {
-      Local = true;
-      Desc.URI = "copy:" + FileName;
-      QueueURI(Desc);
-      return false;
-   }
+// AcqIndexMergeDiffs::AcqIndexMergeDiffs - Constructor                        /*{{{*/
+pkgAcqIndexMergeDiffs::pkgAcqIndexMergeDiffs(pkgAcquire * const Owner,
+                                             pkgAcqMetaClearSig * const TransactionManager,
+                                             IndexTarget const &Target,
+                                             DiffInfo const &patch,
+                                             std::vector<pkgAcqIndexMergeDiffs*> const * const allPatches)
+  : pkgAcqBaseIndex(Owner, TransactionManager, Target), d(NULL),
+     patch(patch), allPatches(allPatches), State(StateFetchDiff)
+{
+   Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 
-   // make sure to verify against the right file on I-M-S hit
-   IMSHit = StringToBool(LookupTag(Message,"IMS-Hit"),false);
-   if(IMSHit)
-   {
-      string FinalFile = _config->FindDir("Dir::State::lists");
-      FinalFile += URItoFileName(RealURI);
-      DestFile = FinalFile;
-   }
+   Desc.Owner = this;
+   Description = Target.Description;
+   Desc.ShortDesc = Target.ShortDesc;
+   Desc.URI = Target.URI + ".diff/" + patch.file + ".gz";
+   Desc.Description = Description + " " + patch.file + ".pdiff";
+   DestFile = GetPartialFileNameFromURI(Desc.URI);
 
-   // set Item to complete as the remaining work is all local (verify etc)
-   Complete = true;
+   if(Debug)
+      std::clog << "pkgAcqIndexMergeDiffs: " << Desc.URI << std::endl;
 
-   return true;
+   QueueURI(Desc);
 }
                                                                        /*}}}*/
-void pkgAcqMetaBase::QueueIndexes(bool verify)                         /*{{{*/
+void pkgAcqIndexMergeDiffs::Failed(string const &Message,pkgAcquire::MethodConfig const * const Cnf)/*{{{*/
 {
-   bool transInRelease = false;
-   {
-      std::vector<std::string> const keys = MetaIndexParser->MetaKeys();
-      for (std::vector<std::string>::const_iterator k = keys.begin(); k != keys.end(); ++k)
-        // FIXME: Feels wrong to check for hardcoded string here, but what should we do else…
-        if (k->find("Translation-") != std::string::npos)
-        {
-           transInRelease = true;
-           break;
-        }
-   }
+   if(Debug)
+      std::clog << "pkgAcqIndexMergeDiffs failed: " << Desc.URI << " with " << Message << std::endl;
 
-   // at this point the real Items are loaded in the fetcher
-   ExpectedAdditionalItems = 0;
-   for (vector <IndexTarget*>::const_iterator Target = IndexTargets->begin();
-        Target != IndexTargets->end();
-        ++Target)
-   {
-      HashStringList ExpectedIndexHashes;
-      const indexRecords::checkSum *Record = MetaIndexParser->Lookup((*Target)->MetaKey);
-      bool compressedAvailable = false;
-      if (Record == NULL)
-      {
-        if ((*Target)->IsOptional() == true)
-        {
-           std::vector<std::string> types = APT::Configuration::getCompressionTypes();
-           for (std::vector<std::string>::const_iterator t = types.begin(); t != types.end(); ++t)
-              if (MetaIndexParser->Exists((*Target)->MetaKey + "." + *t) == true)
-              {
-                 compressedAvailable = true;
-                 break;
-              }
-        }
-        else if (verify == true)
-        {
-           Status = StatAuthError;
-           strprintf(ErrorText, _("Unable to find expected entry '%s' in Release file (Wrong sources.list entry or malformed file)"), (*Target)->MetaKey.c_str());
-           return;
-        }
-      }
-      else
-      {
-        ExpectedIndexHashes = Record->Hashes;
-        if (_config->FindB("Debug::pkgAcquire::Auth", false))
-        {
-           std::cerr << "Queueing: " << (*Target)->URI << std::endl
-              << "Expected Hash:" << std::endl;
-           for (HashStringList::const_iterator hs = ExpectedIndexHashes.begin(); hs != ExpectedIndexHashes.end(); ++hs)
-              std::cerr <<  "\t- " << hs->toStr() << std::endl;
-           std::cerr << "For: " << Record->MetaKeyFilename << std::endl;
-        }
-        if (verify == true && ExpectedIndexHashes.empty() == true && (*Target)->IsOptional() == false)
-        {
-           Status = StatAuthError;
-           strprintf(ErrorText, _("Unable to find hash sum for '%s' in Release file"), (*Target)->MetaKey.c_str());
-           return;
-        }
-      }
+   Item::Failed(Message,Cnf);
+   Status = StatDone;
 
-      if ((*Target)->IsOptional() == true)
-      {
-        if (transInRelease == false || Record != NULL || compressedAvailable == true)
-        {
-           if (_config->FindB("Acquire::PDiffs",true) == true && transInRelease == true &&
-               MetaIndexParser->Exists((*Target)->MetaKey + ".diff/Index") == true)
-              new pkgAcqDiffIndex(Owner, TransactionManager, *Target, ExpectedIndexHashes, MetaIndexParser);
-           else
-              new pkgAcqIndexTrans(Owner, TransactionManager, *Target, ExpectedIndexHashes, MetaIndexParser);
-        }
-        continue;
-      }
+   // check if we are the first to fail, otherwise we are done here
+   State = StateDoneDiff;
+   for (std::vector<pkgAcqIndexMergeDiffs *>::const_iterator I = allPatches->begin();
+        I != allPatches->end(); ++I)
+      if ((*I)->State == StateErrorDiff)
+        return;
 
-      /* Queue Packages file (either diff or full packages files, depending
-         on the users option) - we also check if the PDiff Index file is listed
-         in the Meta-Index file. Ideal would be if pkgAcqDiffIndex would test this
-         instead, but passing the required info to it is to much hassle */
-      if(_config->FindB("Acquire::PDiffs",true) == true && (verify == false ||
-         MetaIndexParser->Exists((*Target)->MetaKey + ".diff/Index") == true))
-        new pkgAcqDiffIndex(Owner, TransactionManager, *Target, ExpectedIndexHashes, MetaIndexParser);
-      else
-        new pkgAcqIndex(Owner, TransactionManager, *Target, ExpectedIndexHashes, MetaIndexParser);
+   // first failure means we should fallback
+   State = StateErrorDiff;
+   if (Debug)
+      std::clog << "Falling back to normal index file acquire" << std::endl;
+   RenameOnError(PDiffError);
+   std::string const patchname = GetPartialFileNameFromURI(Desc.URI);
+   if (RealFileExists(patchname))
+      Rename(patchname, patchname + ".FAILED");
+   std::string const UnpatchedFile = GetExistingFilename(GetPartialFileNameFromURI(Target.URI));
+   if (UnpatchedFile.empty() == false && FileExists(UnpatchedFile))
+      Rename(UnpatchedFile, UnpatchedFile + ".FAILED");
+   DestFile.clear();
+   new pkgAcqIndex(Owner, TransactionManager, Target);
+}
+                                                                       /*}}}*/
+void pkgAcqIndexMergeDiffs::Done(string const &Message, HashStringList const &Hashes,  /*{{{*/
+                           pkgAcquire::MethodConfig const * const Cnf)
+{
+   if(Debug)
+      std::clog << "pkgAcqIndexMergeDiffs::Done(): " << Desc.URI << std::endl;
+
+   Item::Done(Message, Hashes, Cnf);
+
+   std::string const UncompressedUnpatchedFile = GetPartialFileNameFromURI(Target.URI);
+   std::string const UnpatchedFile = GetExistingFilename(UncompressedUnpatchedFile);
+   std::string const PatchFile = GetMergeDiffsPatchFileName(UnpatchedFile, patch.file);
+   std::string const PatchedFile = GetKeepCompressedFileName(UncompressedUnpatchedFile, Target);
+
+   switch (State)
+   {
+      case StateFetchDiff:
+        Rename(DestFile, PatchFile);
+
+        // check if this is the last completed diff
+        State = StateDoneDiff;
+        for (std::vector<pkgAcqIndexMergeDiffs *>::const_iterator I = allPatches->begin();
+              I != allPatches->end(); ++I)
+           if ((*I)->State != StateDoneDiff)
+           {
+              if(Debug)
+                 std::clog << "Not the last done diff in the batch: " << Desc.URI << std::endl;
+              return;
+           }
+        // this is the last completed diff, so we are ready to apply now
+        DestFile = GetKeepCompressedFileName(UncompressedUnpatchedFile + "-patched", Target);
+        if(Debug)
+           std::clog << "Sending to rred method: " << UnpatchedFile << std::endl;
+        State = StateApplyDiff;
+        Local = true;
+        Desc.URI = "rred:" + UnpatchedFile;
+        QueueURI(Desc);
+        SetActiveSubprocess("rred");
+        return;
+      case StateApplyDiff:
+        // success in download & apply all diffs, finialize and clean up
+        if(Debug)
+           std::clog << "Queue patched file in place: " << std::endl
+              << DestFile << " -> " << PatchedFile << std::endl;
+
+        // queue for copy by the transaction manager
+        TransactionManager->TransactionStageCopy(this, DestFile, GetKeepCompressedFileName(GetFinalFilename(), Target));
+
+        // ensure the ed's are gone regardless of list-cleanup
+        for (std::vector<pkgAcqIndexMergeDiffs *>::const_iterator I = allPatches->begin();
+              I != allPatches->end(); ++I)
+           RemoveFile("pkgAcqIndexMergeDiffs::Done", GetMergeDiffsPatchFileName(UnpatchedFile, (*I)->patch.file));
+        RemoveFile("pkgAcqIndexMergeDiffs::Done", UnpatchedFile);
+
+        // all set and done
+        Complete = true;
+        if(Debug)
+           std::clog << "allDone: " << DestFile << "\n" << std::endl;
+        return;
+      case StateDoneDiff: _error->Fatal("Done called for %s which is in an invalid Done state", PatchFile.c_str()); break;
+      case StateErrorDiff: _error->Fatal("Done called for %s which is in an invalid Error state", PatchFile.c_str()); break;
    }
 }
                                                                        /*}}}*/
-bool pkgAcqMetaBase::VerifyVendor(string Message, const string &RealURI)/*{{{*/
+std::string pkgAcqIndexMergeDiffs::Custom600Headers() const            /*{{{*/
 {
-   string::size_type pos;
-
-   // check for missing sigs (that where not fatal because otherwise we had
-   // bombed earlier)
-   string missingkeys;
-   string msg = _("There is no public key available for the "
-                 "following key IDs:\n");
-   pos = Message.find("NO_PUBKEY ");
-   if (pos != std::string::npos)
+   if(State != StateApplyDiff)
+      return pkgAcqBaseIndex::Custom600Headers();
+   std::ostringstream patchhashes;
+   unsigned int seen_patches = 0;
+   for (std::vector<pkgAcqIndexMergeDiffs *>::const_iterator I = allPatches->begin();
+        I != allPatches->end(); ++I)
    {
-      string::size_type start = pos+strlen("NO_PUBKEY ");
-      string Fingerprint = Message.substr(start, Message.find("\n")-start);
-      missingkeys += (Fingerprint);
+      HashStringList const ExpectedHashes = (*I)->patch.patch_hashes;
+      for (HashStringList::const_iterator hs = ExpectedHashes.begin(); hs != ExpectedHashes.end(); ++hs)
+        patchhashes <<  "\nPatch-" << seen_patches << "-" << hs->HashType() << "-Hash: " << hs->HashValue();
+      ++seen_patches;
    }
-   if(!missingkeys.empty())
-      _error->Warning("%s", (msg + missingkeys).c_str());
-
-   string Transformed = MetaIndexParser->GetExpectedDist();
+   patchhashes << pkgAcqBaseIndex::Custom600Headers();
+   return patchhashes.str();
+}
+                                                                       /*}}}*/
+pkgAcqIndexMergeDiffs::~pkgAcqIndexMergeDiffs() {}
 
-   if (Transformed == "../project/experimental")
-   {
-      Transformed = "experimental";
-   }
+// AcqIndex::AcqIndex - Constructor                                    /*{{{*/
+pkgAcqIndex::pkgAcqIndex(pkgAcquire * const Owner,
+                         pkgAcqMetaClearSig * const TransactionManager,
+                         IndexTarget const &Target)
+   : pkgAcqBaseIndex(Owner, TransactionManager, Target), d(NULL), Stage(STAGE_DOWNLOAD),
+   CompressionExtensions(Target.Option(IndexTarget::COMPRESSIONTYPES))
+{
+   Init(Target.URI, Target.Description, Target.ShortDesc);
 
-   pos = Transformed.rfind('/');
-   if (pos != string::npos)
+   if(_config->FindB("Debug::Acquire::Transaction", false) == true)
+      std::clog << "New pkgIndex with TransactionManager "
+                << TransactionManager << std::endl;
+}
+                                                                       /*}}}*/
+// AcqIndex::Init - defered Constructor                                        /*{{{*/
+static void NextCompressionExtension(std::string &CurrentCompressionExtension, std::string &CompressionExtensions, bool const preview)
+{
+   size_t const nextExt = CompressionExtensions.find(' ');
+   if (nextExt == std::string::npos)
    {
-      Transformed = Transformed.substr(0, pos);
+      CurrentCompressionExtension = CompressionExtensions;
+      if (preview == false)
+        CompressionExtensions.clear();
    }
-
-   if (Transformed == ".")
+   else
    {
-      Transformed = "";
+      CurrentCompressionExtension = CompressionExtensions.substr(0, nextExt);
+      if (preview == false)
+        CompressionExtensions = CompressionExtensions.substr(nextExt+1);
    }
+}
+void pkgAcqIndex::Init(string const &URI, string const &URIDesc,
+                       string const &ShortDesc)
+{
+   Stage = STAGE_DOWNLOAD;
 
-   if (_config->FindB("Acquire::Check-Valid-Until", true) == true &&
-       MetaIndexParser->GetValidUntil() > 0) {
-      time_t const invalid_since = time(NULL) - MetaIndexParser->GetValidUntil();
-      if (invalid_since > 0)
-        // TRANSLATOR: The first %s is the URL of the bad Release file, the second is
-        // the time since then the file is invalid - formated in the same way as in
-        // the download progress display (e.g. 7d 3h 42min 1s)
-        return _error->Error(
-            _("Release file for %s is expired (invalid since %s). "
-              "Updates for this repository will not be applied."),
-            RealURI.c_str(), TimeToStr(invalid_since).c_str());
-   }
+   DestFile = GetPartialFileNameFromURI(URI);
+   NextCompressionExtension(CurrentCompressionExtension, CompressionExtensions, false);
 
-   if (_config->FindB("Debug::pkgAcquire::Auth", false)) 
+   if (CurrentCompressionExtension == "uncompressed")
    {
-      std::cerr << "Got Codename: " << MetaIndexParser->GetDist() << std::endl;
-      std::cerr << "Expecting Dist: " << MetaIndexParser->GetExpectedDist() << std::endl;
-      std::cerr << "Transformed Dist: " << Transformed << std::endl;
+      Desc.URI = URI;
    }
-
-   if (MetaIndexParser->CheckDist(Transformed) == false)
+   else if (CurrentCompressionExtension == "by-hash")
    {
-      // This might become fatal one day
-//       Status = StatAuthError;
-//       ErrorText = "Conflicting distribution; expected "
-//          + MetaIndexParser->GetExpectedDist() + " but got "
-//          + MetaIndexParser->GetDist();
-//       return false;
-      if (!Transformed.empty())
+      NextCompressionExtension(CurrentCompressionExtension, CompressionExtensions, true);
+      if(unlikely(TransactionManager->MetaIndexParser == NULL || CurrentCompressionExtension.empty()))
+        return;
+      if (CurrentCompressionExtension != "uncompressed")
       {
-         _error->Warning(_("Conflicting distribution: %s (expected %s but got %s)"),
-                         Desc.Description.c_str(),
-                         Transformed.c_str(),
-                         MetaIndexParser->GetDist().c_str());
+        Desc.URI = URI + '.' + CurrentCompressionExtension;
+        DestFile = DestFile + '.' + CurrentCompressionExtension;
       }
-   }
-
-   return true;
-}
-                                                                       /*}}}*/
-// pkgAcqMetaIndex::Failed - no Release file present                   /*{{{*/
-void pkgAcqMetaIndex::Failed(string Message,
-                             pkgAcquire::MethodConfig * Cnf)
-{
-   pkgAcquire::Item::Failed(Message, Cnf);
-   Status = StatDone;
-
-   string FinalFile = _config->FindDir("Dir::State::lists") + URItoFileName(RealURI);
-
-   _error->Warning(_("The repository '%s' does not have a Release file. "
-                     "This is deprecated, please contact the owner of the "
-                     "repository."), URIDesc.c_str());
-
-   // No Release file was present so fall
-   // back to queueing Packages files without verification
-   // only allow going further if the users explicitely wants it
-   if(_config->FindB("Acquire::AllowInsecureRepositories") == true)
-   {
-      // Done, queue for rename on transaction finished
-      if (FileExists(DestFile)) 
-         TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
 
-      // queue without any kind of hashsum support
-      QueueIndexes(false);
-   } else {
-      // warn if the repository is unsinged
-      _error->Warning("Use --allow-insecure-repositories to force the update");
-      TransactionManager->AbortTransaction();
-      Status = StatError;
+      HashStringList const Hashes = GetExpectedHashes();
+      HashString const * const TargetHash = Hashes.find(NULL);
+      if (unlikely(TargetHash == nullptr))
+        return;
+      std::string const ByHash = "/by-hash/" + TargetHash->HashType() + "/" + TargetHash->HashValue();
+      size_t const trailing_slash = Desc.URI.find_last_of("/");
+      if (unlikely(trailing_slash == std::string::npos))
+        return;
+      Desc.URI = Desc.URI.replace(
+           trailing_slash,
+           Desc.URI.substr(trailing_slash+1).size()+1,
+           ByHash);
+   }
+   else if (unlikely(CurrentCompressionExtension.empty()))
       return;
+   else
+   {
+      Desc.URI = URI + '.' + CurrentCompressionExtension;
+      DestFile = DestFile + '.' + CurrentCompressionExtension;
    }
+
+
+   Desc.Description = URIDesc;
+   Desc.Owner = this;
+   Desc.ShortDesc = ShortDesc;
+
+   QueueURI(Desc);
 }
                                                                        /*}}}*/
-void pkgAcqMetaIndex::Finished()                                       /*{{{*/
-{
-   if(_config->FindB("Debug::Acquire::Transaction", false) == true)
-      std::clog << "Finished: " << DestFile <<std::endl;
-   if(TransactionManager != NULL &&
-      TransactionManager->TransactionHasError() == false)
-      TransactionManager->CommitTransaction();
-}
-                                                                       /*}}}*/
-pkgAcqMetaClearSig::pkgAcqMetaClearSig(pkgAcquire *Owner,              /*{{{*/
-               string const &URI, string const &URIDesc, string const &ShortDesc,
-               string const &MetaIndexURI, string const &MetaIndexURIDesc, string const &MetaIndexShortDesc,
-               string const &MetaSigURI, string const &MetaSigURIDesc, string const &MetaSigShortDesc,
-               const vector<IndexTarget*>* IndexTargets,
-               indexRecords* MetaIndexParser) :
-   pkgAcqMetaIndex(Owner, NULL, URI, URIDesc, ShortDesc, MetaSigURI, MetaSigURIDesc,MetaSigShortDesc, IndexTargets, MetaIndexParser),
-       MetaIndexURI(MetaIndexURI), MetaIndexURIDesc(MetaIndexURIDesc), MetaIndexShortDesc(MetaIndexShortDesc),
-       MetaSigURI(MetaSigURI), MetaSigURIDesc(MetaSigURIDesc), MetaSigShortDesc(MetaSigShortDesc)
+// AcqIndex::Custom600Headers - Insert custom request headers          /*{{{*/
+// ---------------------------------------------------------------------
+/* The only header we use is the last-modified header. */
+string pkgAcqIndex::Custom600Headers() const
 {
-   // index targets + (worst case:) Release/Release.gpg
-   ExpectedAdditionalItems = IndexTargets->size() + 2;
 
+   string msg = "\nIndex-File: true";
+
+   if (TransactionManager->LastMetaIndexParser == NULL)
+   {
+      std::string const Final = GetFinalFilename();
+
+      struct stat Buf;
+      if (stat(Final.c_str(),&Buf) == 0)
+        msg += "\nLast-Modified: " + TimeRFC1123(Buf.st_mtime);
+   }
+
+   if(Target.IsOptional)
+      msg += "\nFail-Ignore: true";
+
+   return msg;
 }
                                                                        /*}}}*/
-pkgAcqMetaClearSig::~pkgAcqMetaClearSig()                              /*{{{*/
+// AcqIndex::Failed - getting the indexfile failed                     /*{{{*/
+void pkgAcqIndex::Failed(string const &Message,pkgAcquire::MethodConfig const * const Cnf)
 {
+   Item::Failed(Message,Cnf);
+
+   // authorisation matches will not be fixed by other compression types
+   if (Status != StatAuthError)
+   {
+      if (CompressionExtensions.empty() == false)
+      {
+        Init(Target.URI, Desc.Description, Desc.ShortDesc);
+        Status = StatIdle;
+        return;
+      }
+   }
+
+   if(Target.IsOptional && GetExpectedHashes().empty() && Stage == STAGE_DOWNLOAD)
+      Status = StatDone;
+   else
+      TransactionManager->AbortTransaction();
 }
                                                                        /*}}}*/
-// pkgAcqMetaClearSig::Custom600Headers - Insert custom request headers        /*{{{*/
+// AcqIndex::Done - Finished a fetch                                   /*{{{*/
 // ---------------------------------------------------------------------
-string pkgAcqMetaClearSig::Custom600Headers() const
+/* This goes through a number of states.. On the initial fetch the
+   method could possibly return an alternate filename which points
+   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 const &Message,
+                       HashStringList const &Hashes,
+                      pkgAcquire::MethodConfig const * const Cfg)
 {
-   string Header = GetCustom600Headers(RealURI);
-   Header += "\nFail-Ignore: true";
-   return Header;
+   Item::Done(Message,Hashes,Cfg);
+
+   switch(Stage) 
+   {
+      case STAGE_DOWNLOAD:
+         StageDownloadDone(Message);
+         break;
+      case STAGE_DECOMPRESS_AND_VERIFY:
+         StageDecompressDone();
+         break;
+   }
 }
                                                                        /*}}}*/
-// pkgAcqMetaClearSig::Done - We got a file                            /*{{{*/
-// ---------------------------------------------------------------------
-void pkgAcqMetaClearSig::Done(std::string Message,unsigned long long /*Size*/,
-                              HashStringList const &/*Hashes*/,
-                              pkgAcquire::MethodConfig *Cnf)
+// AcqIndex::StageDownloadDone - Queue for decompress and verify       /*{{{*/
+void pkgAcqIndex::StageDownloadDone(string const &Message)
 {
-   // if we expect a ClearTextSignature (InRelase), ensure that
-   // this is what we get and if not fail to queue a 
-   // Release/Release.gpg, see #346386
-   if (FileExists(DestFile) && !StartsWithGPGClearTextSignature(DestFile))
+   Local = true;
+   Complete = true;
+
+   std::string const AltFilename = LookupTag(Message,"Alt-Filename");
+   std::string Filename = LookupTag(Message,"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)
    {
-      pkgAcquire::Item::Failed(Message, Cnf);
-      RenameOnError(NotClearsigned);
-      TransactionManager->AbortTransaction();
+      // copy FinalFile into partial/ so that we check the hash again
+      string const FinalFile = GetExistingFilename(GetFinalFileNameFromURI(Target.URI));
+      if (symlink(FinalFile.c_str(), DestFile.c_str()) != 0)
+        _error->WarningE("pkgAcqIndex::StageDownloadDone", "Symlinking final file %s back to %s failed", FinalFile.c_str(), DestFile.c_str());
+      else
+      {
+        EraseFileName = DestFile;
+        Filename = DestFile;
+      }
+      Stage = STAGE_DECOMPRESS_AND_VERIFY;
+      Desc.URI = "store:" + Filename;
+      QueueURI(Desc);
+      SetActiveSubprocess(::URI(Desc.URI).Access);
       return;
    }
-
-   if(AuthPass == false)
+   // methods like file:// give us an alternative (uncompressed) file
+   else if (Target.KeepCompressed == false && AltFilename.empty() == false)
    {
-      if(CheckDownloadDone(Message, RealURI) == true)
-         QueueForSignatureVerify(DestFile, DestFile);
-      return;
+      if (CurrentCompressionExtension != "uncompressed")
+        DestFile.erase(DestFile.length() - (CurrentCompressionExtension.length() + 1));
+      Filename = AltFilename;
    }
-   else
+   // 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
+   else if (Filename != DestFile && RealFileExists(DestFile) == false)
    {
-      if(CheckAuthDone(Message, RealURI) == true)
+      // symlinking ensures that the filename can be used for compression detection
+      // that is e.g. needed for by-hash which has no extension over file
+      if (symlink(Filename.c_str(),DestFile.c_str()) != 0)
+        _error->WarningE("pkgAcqIndex::StageDownloadDone", "Symlinking file %s to %s failed", Filename.c_str(), DestFile.c_str());
+      else
       {
-         string FinalFile = _config->FindDir("Dir::State::lists");
-         FinalFile += URItoFileName(RealURI);
-
-         // queue for copy in place
-         TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
+        EraseFileName = DestFile;
+        Filename = DestFile;
       }
    }
-}
-                                                                       /*}}}*/
-void pkgAcqMetaClearSig::Failed(string Message,pkgAcquire::MethodConfig *Cnf) /*{{{*/
-{
-   Item::Failed(Message, Cnf);
-
-   // we failed, we will not get additional items from this method
-   ExpectedAdditionalItems = 0;
-
-   if (AuthPass == false)
-   {
-      // Queue the 'old' InRelease file for removal if we try Release.gpg
-      // as otherwise the file will stay around and gives a false-auth
-      // impression (CVE-2012-0214)
-      string FinalFile = _config->FindDir("Dir::State::lists");
-      FinalFile.append(URItoFileName(RealURI));
-      TransactionManager->TransactionStageRemoval(this, FinalFile);
-      Status = StatDone;
 
-      new pkgAcqMetaIndex(Owner, TransactionManager,
-                       MetaIndexURI, MetaIndexURIDesc, MetaIndexShortDesc,
-                       MetaSigURI, MetaSigURIDesc, MetaSigShortDesc,
-                       IndexTargets, MetaIndexParser);
-   }
+   Stage = STAGE_DECOMPRESS_AND_VERIFY;
+   DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target);
+   if (Filename != DestFile && flExtension(Filename) == flExtension(DestFile))
+      Desc.URI = "copy:" + Filename;
    else
+      Desc.URI = "store:" + Filename;
+   if (DestFile == Filename)
    {
-      if(CheckStopAuthentication(RealURI, Message))
-         return;
+      if (CurrentCompressionExtension == "uncompressed")
+        return StageDecompressDone();
+      DestFile = "/dev/null";
+   }
 
-      _error->Warning(_("The data from '%s' is not signed. Packages "
-                        "from that repository can not be authenticated."),
-                      URIDesc.c_str());
+   if (EraseFileName.empty())
+      EraseFileName = Filename;
 
-      // No Release file was present, or verification failed, so fall
-      // back to queueing Packages files without verification
-      // only allow going further if the users explicitely wants it
-      if(_config->FindB("Acquire::AllowInsecureRepositories") == true)
-      {
-        Status = StatDone;
+   // queue uri for the next stage
+   QueueURI(Desc);
+   SetActiveSubprocess(::URI(Desc.URI).Access);
+}
+                                                                       /*}}}*/
+// AcqIndex::StageDecompressDone - Final verification                  /*{{{*/
+void pkgAcqIndex::StageDecompressDone()
+{
+   if (DestFile == "/dev/null")
+      DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target);
 
-         /* 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 */
-            RealURI = RealURI.replace(RealURI.rfind("InRelease"), 9,
-                                      "Release");
-            FinalFile = FinalFile.replace(FinalFile.rfind("InRelease"), 9,
-                                          "Release");
-
-            // Done, queue for rename on transaction finished
-            TransactionManager->TransactionStageCopy(this, DestFile, FinalFile);
-         }
-         QueueIndexes(false);
-      } else {
-         // warn if the repository is unsigned
-         _error->Warning("Use --allow-insecure-repositories to force the update");
-         TransactionManager->AbortTransaction();
-         Status = StatError;
-      }
-   }
+   // Done, queue for rename on transaction finished
+   TransactionManager->TransactionStageCopy(this, DestFile, GetFinalFilename());
 }
                                                                        /*}}}*/
+pkgAcqIndex::~pkgAcqIndex() {}
+
+
 // AcqArchive::AcqArchive - Constructor                                        /*{{{*/
 // ---------------------------------------------------------------------
 /* This just sets up the initial fetch environment and queues the first
    possibilitiy */
-pkgAcqArchive::pkgAcqArchive(pkgAcquire *Owner,pkgSourceList *Sources,
-                            pkgRecords *Recs,pkgCache::VerIterator const &Version,
+pkgAcqArchive::pkgAcqArchive(pkgAcquire * const Owner,pkgSourceList * const Sources,
+                            pkgRecords * const Recs,pkgCache::VerIterator const &Version,
                             string &StoreFilename) :
-               Item(Owner, HashStringList()), Version(Version), Sources(Sources), Recs(Recs), 
-               StoreFilename(StoreFilename), Vf(Version.FileList()), 
+               Item(Owner), d(NULL), LocalSource(false), Version(Version), Sources(Sources), Recs(Recs),
+               StoreFilename(StoreFilename), Vf(Version.FileList()),
               Trusted(false)
 {
    Retries = _config->FindI("Acquire::Retries",0);
@@ -2333,7 +2814,7 @@ pkgAcqArchive::pkgAcqArchive(pkgAcquire *Owner,pkgSourceList *Sources,
    // Skip not source sources, they do not have file fields.
    for (; Vf.end() == false; ++Vf)
    {
-      if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0)
+      if (Vf.File().Flagged(pkgCache::Flag::NotSource))
         continue;
       break;
    }
@@ -2399,15 +2880,17 @@ bool pkgAcqArchive::QueueNext()
 {
    for (; Vf.end() == false; ++Vf)
    {
+      pkgCache::PkgFileIterator const PkgF = Vf.File();
       // Ignore not source sources
-      if ((Vf.File()->Flags & pkgCache::Flag::NotSource) != 0)
+      if (PkgF.Flagged(pkgCache::Flag::NotSource))
         continue;
 
       // Try to cross match against the source list
       pkgIndexFile *Index;
-      if (Sources->FindIndex(Vf.File(),Index) == false)
+      if (Sources->FindIndex(PkgF, Index) == false)
            continue;
-      
+      LocalSource = PkgF.Flagged(pkgCache::Flag::LocalSource);
+
       // only try to get a trusted package from another source if that source
       // is also trusted
       if(Trusted && !Index->IsTrusted()) 
@@ -2449,7 +2932,7 @@ bool pkgAcqArchive::QueueNext()
         
         /* Hmm, we have a file and its size does not match, this means it is
            an old style mismatched arch */
-        unlink(FinalFile.c_str());
+        RemoveFile("pkgAcqArchive::QueueNext", FinalFile);
       }
 
       // Check it again using the new style output filenames
@@ -2468,7 +2951,7 @@ bool pkgAcqArchive::QueueNext()
         
         /* Hmm, we have a file and its size does not match, this shouldn't
            happen.. */
-        unlink(FinalFile.c_str());
+        RemoveFile("pkgAcqArchive::QueueNext", FinalFile);
       }
 
       DestFile = _config->FindDir("Dir::Cache::Archives") + "partial/" + flNotDir(StoreFilename);
@@ -2478,12 +2961,9 @@ bool pkgAcqArchive::QueueNext()
       {
         // Hmm, the partial file is too big, erase it
         if ((unsigned long long)Buf.st_size > Version->Size)
-           unlink(DestFile.c_str());
+           RemoveFile("pkgAcqArchive::QueueNext", DestFile);
         else
-        {
            PartialSize = Buf.st_size;
-           ChangeOwnerAndPermissionOfFile("pkgAcqArchive::QueueNext", DestFile.c_str(), "_apt", "root", 0600);
-        }
       }
 
       // Disables download of archives - useful if no real installation follows,
@@ -2510,37 +2990,14 @@ bool pkgAcqArchive::QueueNext()
 // AcqArchive::Done - Finished fetching                                        /*{{{*/
 // ---------------------------------------------------------------------
 /* */
-void pkgAcqArchive::Done(string Message,unsigned long long Size, HashStringList const &CalcHashes,
-                        pkgAcquire::MethodConfig *Cfg)
+void pkgAcqArchive::Done(string const &Message, HashStringList const &Hashes,
+                        pkgAcquire::MethodConfig const * const Cfg)
 {
-   Item::Done(Message, Size, CalcHashes, Cfg);
-   
-   // Check the size
-   if (Size != Version->Size)
-   {
-      RenameOnError(SizeMismatch);
-      return;
-   }
-
-   // FIXME: could this empty() check impose *any* sort of security issue?
-   if(ExpectedHashes.usable() && ExpectedHashes != CalcHashes)
-   {
-      RenameOnError(HashSumMismatch);
-      printHashSumComparision(DestFile, ExpectedHashes, CalcHashes);
-      return;
-   }
+   Item::Done(Message, Hashes, Cfg);
 
    // Grab the output filename
-   string FileName = LookupTag(Message,"Filename");
-   if (FileName.empty() == true)
-   {
-      Status = StatError;
-      ErrorText = "Method gave a blank filename";
-      return;
-   }
-
-   // Reference filename
-   if (FileName != DestFile)
+   std::string const FileName = LookupTag(Message,"Filename");
+   if (DestFile !=  FileName && RealFileExists(DestFile) == false)
    {
       StoreFilename = DestFile = FileName;
       Local = true;
@@ -2549,10 +3006,8 @@ void pkgAcqArchive::Done(string Message,unsigned long long Size, HashStringList
    }
 
    // Done, move it into position
-   string FinalFile = _config->FindDir("Dir::Cache::Archives");
-   FinalFile += flNotDir(StoreFilename);
+   string const FinalFile = GetFinalFilename();
    Rename(DestFile,FinalFile);
-   ChangeOwnerAndPermissionOfFile("pkgAcqArchive::Done", FinalFile.c_str(), "root", "root", 0644);
    StoreFilename = DestFile = FinalFile;
    Complete = true;
 }
@@ -2560,23 +3015,23 @@ void pkgAcqArchive::Done(string Message,unsigned long long Size, HashStringList
 // AcqArchive::Failed - Failure handler                                        /*{{{*/
 // ---------------------------------------------------------------------
 /* Here we try other sources */
-void pkgAcqArchive::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
+void pkgAcqArchive::Failed(string const &Message,pkgAcquire::MethodConfig const * const Cnf)
 {
-   ErrorText = LookupTag(Message,"Message");
-   
-   /* We don't really want to retry on failed media swaps, this prevents 
+   Item::Failed(Message,Cnf);
+
+   /* We don't really want to retry on failed media swaps, this prevents
       that. An interesting observation is that permanent failures are not
       recorded. */
-   if (Cnf->Removable == true && 
+   if (Cnf->Removable == true &&
        StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
    {
       // Vf = Version.FileList();
       while (Vf.end() == false) ++Vf;
       StoreFilename = string();
-      Item::Failed(Message,Cnf);
       return;
    }
-   
+
+   Status = StatIdle;
    if (QueueNext() == false)
    {
       // This is the retry counter
@@ -2589,23 +3044,18 @@ void pkgAcqArchive::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
         if (QueueNext() == true)
            return;
       }
-      
+
       StoreFilename = string();
-      Item::Failed(Message,Cnf);
+      Status = StatError;
    }
 }
                                                                        /*}}}*/
-// AcqArchive::IsTrusted - Determine whether this archive comes from a trusted source /*{{{*/
-// ---------------------------------------------------------------------
-APT_PURE bool pkgAcqArchive::IsTrusted() const
+APT_PURE bool pkgAcqArchive::IsTrusted() const                         /*{{{*/
 {
    return Trusted;
 }
                                                                        /*}}}*/
-// AcqArchive::Finished - Fetching has finished, tidy up               /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-void pkgAcqArchive::Finished()
+void pkgAcqArchive::Finished()                                         /*{{{*/
 {
    if (Status == pkgAcquire::Item::StatDone &&
        Complete == true)
@@ -2613,17 +3063,229 @@ void pkgAcqArchive::Finished()
    StoreFilename = string();
 }
                                                                        /*}}}*/
+std::string pkgAcqArchive::DescURI() const                             /*{{{*/
+{
+   return Desc.URI;
+}
+                                                                       /*}}}*/
+std::string pkgAcqArchive::ShortDesc() const                           /*{{{*/
+{
+   return Desc.ShortDesc;
+}
+                                                                       /*}}}*/
+pkgAcqArchive::~pkgAcqArchive() {}
+
+// AcqChangelog::pkgAcqChangelog - Constructors                                /*{{{*/
+pkgAcqChangelog::pkgAcqChangelog(pkgAcquire * const Owner, pkgCache::VerIterator const &Ver,
+      std::string const &DestDir, std::string const &DestFilename) :
+   pkgAcquire::Item(Owner), d(NULL), SrcName(Ver.SourcePkgName()), SrcVersion(Ver.SourceVerStr())
+{
+   Desc.URI = URI(Ver);
+   Init(DestDir, DestFilename);
+}
+// some parameters are char* here as they come likely from char* interfaces – which can also return NULL
+pkgAcqChangelog::pkgAcqChangelog(pkgAcquire * const Owner, pkgCache::RlsFileIterator const &RlsFile,
+      char const * const Component, char const * const SrcName, char const * const SrcVersion,
+      const string &DestDir, const string &DestFilename) :
+   pkgAcquire::Item(Owner), d(NULL), SrcName(SrcName), SrcVersion(SrcVersion)
+{
+   Desc.URI = URI(RlsFile, Component, SrcName, SrcVersion);
+   Init(DestDir, DestFilename);
+}
+pkgAcqChangelog::pkgAcqChangelog(pkgAcquire * const Owner,
+      std::string const &URI, char const * const SrcName, char const * const SrcVersion,
+      const string &DestDir, const string &DestFilename) :
+   pkgAcquire::Item(Owner), d(NULL), SrcName(SrcName), SrcVersion(SrcVersion)
+{
+   Desc.URI = URI;
+   Init(DestDir, DestFilename);
+}
+void pkgAcqChangelog::Init(std::string const &DestDir, std::string const &DestFilename)
+{
+   if (Desc.URI.empty())
+   {
+      Status = StatError;
+      // TRANSLATOR: %s=%s is sourcename=sourceversion, e.g. apt=1.1
+      strprintf(ErrorText, _("Changelog unavailable for %s=%s"), SrcName.c_str(), SrcVersion.c_str());
+      // Let the error message print something sensible rather than "Failed to fetch /"
+      if (DestFilename.empty())
+        DestFile = SrcName + ".changelog";
+      else
+        DestFile = DestFilename;
+      Desc.URI = "changelog:/" + DestFile;
+      return;
+   }
+
+   if (DestDir.empty())
+   {
+      std::string const SandboxUser = _config->Find("APT::Sandbox::User");
+      std::string const systemTemp = GetTempDir(SandboxUser);
+      char tmpname[100];
+      snprintf(tmpname, sizeof(tmpname), "%s/apt-changelog-XXXXXX", systemTemp.c_str());
+      if (NULL == mkdtemp(tmpname))
+      {
+        _error->Errno("mkdtemp", "mkdtemp failed in changelog acquire of %s %s", SrcName.c_str(), SrcVersion.c_str());
+        Status = StatError;
+        return;
+      }
+      DestFile = TemporaryDirectory = tmpname;
+
+      ChangeOwnerAndPermissionOfFile("Item::QueueURI", DestFile.c_str(),
+                                     SandboxUser.c_str(), "root", 0700);
+   }
+   else
+      DestFile = DestDir;
+
+   if (DestFilename.empty())
+      DestFile = flCombine(DestFile, SrcName + ".changelog");
+   else
+      DestFile = flCombine(DestFile, DestFilename);
+
+   Desc.ShortDesc = "Changelog";
+   strprintf(Desc.Description, "%s %s %s Changelog", URI::SiteOnly(Desc.URI).c_str(), SrcName.c_str(), SrcVersion.c_str());
+   Desc.Owner = this;
+   QueueURI(Desc);
+}
+                                                                       /*}}}*/
+std::string pkgAcqChangelog::URI(pkgCache::VerIterator const &Ver)     /*{{{*/
+{
+   char const * const SrcName = Ver.SourcePkgName();
+   char const * const SrcVersion = Ver.SourceVerStr();
+   pkgCache::PkgFileIterator PkgFile;
+   // find the first source for this version which promises a changelog
+   for (pkgCache::VerFileIterator VF = Ver.FileList(); VF.end() == false; ++VF)
+   {
+      pkgCache::PkgFileIterator const PF = VF.File();
+      if (PF.Flagged(pkgCache::Flag::NotSource) || PF->Release == 0)
+        continue;
+      PkgFile = PF;
+      pkgCache::RlsFileIterator const RF = PF.ReleaseFile();
+      std::string const uri = URI(RF, PF.Component(), SrcName, SrcVersion);
+      if (uri.empty())
+        continue;
+      return uri;
+   }
+   return "";
+}
+std::string pkgAcqChangelog::URITemplate(pkgCache::RlsFileIterator const &Rls)
+{
+   if (Rls.end() == true || (Rls->Label == 0 && Rls->Origin == 0))
+      return "";
+   std::string const serverConfig = "Acquire::Changelogs::URI";
+   std::string server;
+#define APT_EMPTY_SERVER \
+   if (server.empty() == false) \
+   { \
+      if (server != "no") \
+        return server; \
+      return ""; \
+   }
+#define APT_CHECK_SERVER(X, Y) \
+   if (Rls->X != 0) \
+   { \
+      std::string const specialServerConfig = serverConfig + "::" + Y + #X + "::" + Rls.X(); \
+      server = _config->Find(specialServerConfig); \
+      APT_EMPTY_SERVER \
+   }
+   // this way e.g. Debian-Security can fallback to Debian
+   APT_CHECK_SERVER(Label, "Override::")
+   APT_CHECK_SERVER(Origin, "Override::")
+
+   if (RealFileExists(Rls.FileName()))
+   {
+      _error->PushToStack();
+      FileFd rf;
+      /* This can be costly. A caller wanting to get millions of URIs might
+        want to do this on its own once and use Override settings.
+        We don't do this here as Origin/Label are not as unique as they
+        should be so this could produce request order-dependent anomalies */
+      if (OpenMaybeClearSignedFile(Rls.FileName(), rf) == true)
+      {
+        pkgTagFile TagFile(&rf, rf.Size());
+        pkgTagSection Section;
+        if (TagFile.Step(Section) == true)
+           server = Section.FindS("Changelogs");
+      }
+      _error->RevertToStack();
+      APT_EMPTY_SERVER
+   }
+
+   APT_CHECK_SERVER(Label, "")
+   APT_CHECK_SERVER(Origin, "")
+#undef APT_CHECK_SERVER
+#undef APT_EMPTY_SERVER
+   return "";
+}
+std::string pkgAcqChangelog::URI(pkgCache::RlsFileIterator const &Rls,
+        char const * const Component, char const * const SrcName,
+        char const * const SrcVersion)
+{
+   return URI(URITemplate(Rls), Component, SrcName, SrcVersion);
+}
+std::string pkgAcqChangelog::URI(std::string const &Template,
+        char const * const Component, char const * const SrcName,
+        char const * const SrcVersion)
+{
+   if (Template.find("@CHANGEPATH@") == std::string::npos)
+      return "";
+
+   // the path is: COMPONENT/SRC/SRCNAME/SRCNAME_SRCVER, e.g. main/a/apt/1.1 or contrib/liba/libapt/2.0
+   std::string Src = SrcName;
+   std::string path = APT::String::Startswith(SrcName, "lib") ? Src.substr(0, 4) : Src.substr(0,1);
+   path.append("/").append(Src).append("/");
+   path.append(Src).append("_").append(StripEpoch(SrcVersion));
+   // we omit component for releases without one (= flat-style repositories)
+   if (Component != NULL && strlen(Component) != 0)
+      path = std::string(Component) + "/" + path;
+
+   return SubstVar(Template, "@CHANGEPATH@", path);
+}
+                                                                       /*}}}*/
+// AcqChangelog::Failed - Failure handler                              /*{{{*/
+void pkgAcqChangelog::Failed(string const &Message, pkgAcquire::MethodConfig const * const Cnf)
+{
+   Item::Failed(Message,Cnf);
+
+   std::string errText;
+   // TRANSLATOR: %s=%s is sourcename=sourceversion, e.g. apt=1.1
+   strprintf(errText, _("Changelog unavailable for %s=%s"), SrcName.c_str(), SrcVersion.c_str());
+
+   // Error is probably something techy like 404 Not Found
+   if (ErrorText.empty())
+      ErrorText = errText;
+   else
+      ErrorText = errText + " (" + ErrorText + ")";
+   return;
+}
+                                                                       /*}}}*/
+// AcqChangelog::Done - Item downloaded OK                             /*{{{*/
+void pkgAcqChangelog::Done(string const &Message,HashStringList const &CalcHashes,
+                     pkgAcquire::MethodConfig const * const Cnf)
+{
+   Item::Done(Message,CalcHashes,Cnf);
+
+   Complete = true;
+}
+                                                                       /*}}}*/
+pkgAcqChangelog::~pkgAcqChangelog()                                    /*{{{*/
+{
+   if (TemporaryDirectory.empty() == false)
+   {
+      RemoveFile("~pkgAcqChangelog", DestFile);
+      rmdir(TemporaryDirectory.c_str());
+   }
+}
+                                                                       /*}}}*/
+
 // AcqFile::pkgAcqFile - Constructor                                   /*{{{*/
-// ---------------------------------------------------------------------
-/* The file is added to the queue */
-pkgAcqFile::pkgAcqFile(pkgAcquire *Owner,string URI, HashStringList const &Hashes,
-                      unsigned long long Size,string Dsc,string ShortDesc,
+pkgAcqFile::pkgAcqFile(pkgAcquire * const Owner,string const &URI, HashStringList const &Hashes,
+                      unsigned long long const Size,string const &Dsc,string const &ShortDesc,
                       const string &DestDir, const string &DestFilename,
-                       bool IsIndexFile) :
-                       Item(Owner, Hashes), IsIndexFile(IsIndexFile)
+                       bool const IsIndexFile) :
+                       Item(Owner), d(NULL), IsIndexFile(IsIndexFile), ExpectedHashes(Hashes)
 {
    Retries = _config->FindI("Acquire::Retries",0);
-   
+
    if(!DestFilename.empty())
       DestFile = DestFilename;
    else if(!DestDir.empty())
@@ -2638,7 +3300,7 @@ pkgAcqFile::pkgAcqFile(pkgAcquire *Owner,string URI, HashStringList const &Hashe
 
    // Set the short description to the archive component
    Desc.ShortDesc = ShortDesc;
-      
+
    // Get the transfer sizes
    FileSize = Size;
    struct stat Buf;
@@ -2646,49 +3308,29 @@ pkgAcqFile::pkgAcqFile(pkgAcquire *Owner,string URI, HashStringList const &Hashe
    {
       // Hmm, the partial file is too big, erase it
       if ((Size > 0) && (unsigned long long)Buf.st_size > Size)
-        unlink(DestFile.c_str());
+        RemoveFile("pkgAcqFile", DestFile);
       else
-      {
         PartialSize = Buf.st_size;
-        ChangeOwnerAndPermissionOfFile("pkgAcqFile", DestFile.c_str(), "_apt", "root", 0600);
-      }
    }
 
    QueueURI(Desc);
 }
                                                                        /*}}}*/
 // AcqFile::Done - Item downloaded OK                                  /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-void pkgAcqFile::Done(string Message,unsigned long long Size,HashStringList const &CalcHashes,
-                     pkgAcquire::MethodConfig *Cnf)
+void pkgAcqFile::Done(string const &Message,HashStringList const &CalcHashes,
+                     pkgAcquire::MethodConfig const * const Cnf)
 {
-   Item::Done(Message,Size,CalcHashes,Cnf);
-
-   // Check the hash
-   if(ExpectedHashes.usable() && ExpectedHashes != CalcHashes)
-   {
-      RenameOnError(HashSumMismatch);
-      printHashSumComparision(DestFile, ExpectedHashes, CalcHashes);
-      return;
-   }
-   
-   string FileName = LookupTag(Message,"Filename");
-   if (FileName.empty() == true)
-   {
-      Status = StatError;
-      ErrorText = "Method gave a blank filename";
-      return;
-   }
+   Item::Done(Message,CalcHashes,Cnf);
 
+   std::string const FileName = LookupTag(Message,"Filename");
    Complete = true;
-   
+
    // The files timestamp matches
    if (StringToBool(LookupTag(Message,"IMS-Hit"),false) == true)
       return;
-   
+
    // We have to copy it into place
-   if (FileName != DestFile)
+   if (RealFileExists(DestFile.c_str()) == false)
    {
       Local = true;
       if (_config->FindB("Acquire::Source-Symlinks",true) == false ||
@@ -2698,52 +3340,55 @@ void pkgAcqFile::Done(string Message,unsigned long long Size,HashStringList cons
         QueueURI(Desc);
         return;
       }
-      
+
       // Erase the file if it is a symlink so we can overwrite it
       struct stat St;
       if (lstat(DestFile.c_str(),&St) == 0)
       {
         if (S_ISLNK(St.st_mode) != 0)
-           unlink(DestFile.c_str());
+           RemoveFile("pkgAcqFile::Done", DestFile);
       }
-      
+
       // Symlink the file
       if (symlink(FileName.c_str(),DestFile.c_str()) != 0)
       {
-        ErrorText = "Link to " + DestFile + " failure ";
+        _error->PushToStack();
+        _error->Errno("pkgAcqFile::Done", "Symlinking file %s failed", DestFile.c_str());
+        std::stringstream msg;
+        _error->DumpErrors(msg, GlobalError::DEBUG, false);
+        _error->RevertToStack();
+        ErrorText = msg.str();
         Status = StatError;
         Complete = false;
-      }      
+      }
    }
 }
                                                                        /*}}}*/
 // AcqFile::Failed - Failure handler                                   /*{{{*/
 // ---------------------------------------------------------------------
 /* Here we try other sources */
-void pkgAcqFile::Failed(string Message,pkgAcquire::MethodConfig *Cnf)
+void pkgAcqFile::Failed(string const &Message, pkgAcquire::MethodConfig const * const Cnf)
 {
-   ErrorText = LookupTag(Message,"Message");
-   
+   Item::Failed(Message,Cnf);
+
    // This is the retry counter
    if (Retries != 0 &&
        Cnf->LocalOnly == false &&
        StringToBool(LookupTag(Message,"Transient-Failure"),false) == true)
    {
-      Retries--;
+      --Retries;
       QueueURI(Desc);
+      Status = StatIdle;
       return;
    }
-   
-   Item::Failed(Message,Cnf);
+
 }
                                                                        /*}}}*/
-// AcqIndex::Custom600Headers - Insert custom request headers          /*{{{*/
-// ---------------------------------------------------------------------
-/* The only header we use is the last-modified header. */
-string pkgAcqFile::Custom600Headers() const
+string pkgAcqFile::Custom600Headers() const                            /*{{{*/
 {
    if (IsIndexFile)
       return "\nIndex-File: true";
    return "";
 }
                                                                        /*}}}*/
+pkgAcqFile::~pkgAcqFile() {}