Adding upstream version 2.2.4.upstream/2.2.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

18 files changed, 7751 insertions, 0 deletions

diff --git a/apt-pkg/deb/debfile.cc b/apt-pkg/deb/debfile.cc
new file mode 100644
index 0000000..645a579
--- /dev/null
+++ b/apt-pkg/deb/debfile.cc
@@ -0,0 +1,274 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+
+   Debian Archive File (.deb)
+   
+   .DEB archives are AR files containing two tars and an empty marker
+   member called 'debian-binary'. The two tars contain the meta data and
+   the actual archive contents. Thus this class is a very simple wrapper
+   around ar/tar to simply extract the right tar files.
+   
+   It also uses the deb package list parser to parse the control file 
+   into the cache.
+   
+   ##################################################################### */
+									/*}}}*/
+// Include Files							/*{{{*/
+#include <config.h>
+
+#include <apt-pkg/aptconfiguration.h>
+#include <apt-pkg/arfile.h>
+#include <apt-pkg/debfile.h>
+#include <apt-pkg/dirstream.h>
+#include <apt-pkg/error.h>
+#include <apt-pkg/extracttar.h>
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/strutl.h>
+#include <apt-pkg/tagfile.h>
+
+#include <algorithm>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <string.h>
+#include <sys/stat.h>
+
+#include <apti18n.h>
+									/*}}}*/
+
+// DebFile::debDebFile - Constructor					/*{{{*/
+// ---------------------------------------------------------------------
+/* Open the AR file and check for consistency */
+debDebFile::debDebFile(FileFd &File) : File(File), AR(File)
+{
+   if (_error->PendingError() == true)
+      return;
+
+   if (!CheckMember("debian-binary")) {
+      _error->Error(_("This is not a valid DEB archive, missing '%s' member"), "debian-binary");
+      return;
+   }
+
+   if (!CheckMember("control.tar") &&
+       !CheckMember("control.tar.gz") &&
+       !CheckMember("control.tar.xz") &&
+       !CheckMember("control.tar.zst"))
+   {
+      _error->Error(_("This is not a valid DEB archive, missing '%s' member"), "control.tar");
+      return;
+   }
+
+   if (!CheckMember("data.tar") &&
+       !CheckMember("data.tar.gz") &&
+       !CheckMember("data.tar.bz2") &&
+       !CheckMember("data.tar.lzma") &&
+       !CheckMember("data.tar.xz") &&
+       !CheckMember("data.tar.zst"))
+   {
+      _error->Error(_("This is not a valid DEB archive, missing '%s' member"), "data.tar");
+      return;
+   }
+}
+									/*}}}*/
+// DebFile::CheckMember - Check if a named member is in the archive	/*{{{*/
+// ---------------------------------------------------------------------
+/* This is used to check for a correct deb and to give nicer error messages
+   for people playing around. */
+bool debDebFile::CheckMember(const char *Name)
+{
+   if (AR.FindMember(Name) == 0)
+      return false;
+   return true;
+}
+									/*}}}*/
+// DebFile::GotoMember - Jump to a Member				/*{{{*/
+// ---------------------------------------------------------------------
+/* Jump in the file to the start of a named member and return the information
+   about that member. The caller can then read from the file up to the 
+   returned size. Note, since this relies on the file position this is
+   a destructive operation, it also changes the last returned Member
+   structure - so don't nest them! */
+const ARArchive::Member *debDebFile::GotoMember(const char *Name)
+{
+   // Get the archive member and positition the file
+   const ARArchive::Member *Member = AR.FindMember(Name);
+   if (Member == 0)
+   {
+      return 0;
+   }
+   if (File.Seek(Member->Start) == false)
+      return 0;
+      
+   return Member;
+}
+									/*}}}*/
+// DebFile::ExtractTarMember - Extract the contents of a tar member	/*{{{*/
+// ---------------------------------------------------------------------
+/* Simple wrapper around tar.. */
+bool debDebFile::ExtractTarMember(pkgDirStream &Stream,const char *Name)
+{
+   std::string Compressor;
+   auto const Compressors = APT::Configuration::getCompressors();
+
+   ARArchive::Member const *Member = AR.FindMember(Name);
+   if (Member != nullptr)
+   {
+      auto const found = std::find_if(Compressors.cbegin(), Compressors.cend(), [&](auto const &c) {
+	 return not c.Extension.empty() && APT::String::Endswith(Name, c.Extension);
+      });
+      if (found != Compressors.cend())
+	 Compressor = found->Name;
+   }
+   else
+   {
+      for (auto const &c : Compressors)
+      {
+	 if (c.Extension.empty())
+	    continue;
+	 Member = AR.FindMember(std::string(Name).append(c.Extension).c_str());
+	 if (Member == nullptr)
+	    continue;
+	 Compressor = c.Name;
+	 break;
+      }
+   }
+
+   if (Member == nullptr)
+   {
+      std::ostringstream ext;
+      ext << Name << '{';
+      for (auto const &c : Compressors)
+	 if (not c.Extension.empty())
+	    ext << c.Extension << ',';
+      ext << '}';
+      return _error->Error(_("Internal error, could not locate member %s"), ext.str().c_str());
+   }
+
+   if (not File.Seek(Member->Start))
+      return false;
+
+   ExtractTar Tar(File,Member->Size,Compressor);
+   if (_error->PendingError())
+      return false;
+   return Tar.Go(Stream);
+}
+									/*}}}*/
+// DebFile::ExtractArchive - Extract the archive data itself		/*{{{*/
+// ---------------------------------------------------------------------
+/* Simple wrapper around DebFile::ExtractTarMember. */
+bool debDebFile::ExtractArchive(pkgDirStream &Stream)
+{
+   return ExtractTarMember(Stream, "data.tar");
+}
+									/*}}}*/
+
+// DebFile::ControlExtract::DoItem - Control Tar Extraction		/*{{{*/
+// ---------------------------------------------------------------------
+/* This directory stream handler for the control tar handles extracting
+   it into the temporary meta directory. It only extracts files, it does
+   not create directories, links or anything else. */
+bool debDebFile::ControlExtract::DoItem(Item &Itm,int &Fd)
+{
+   if (Itm.Type != Item::File)
+      return true;
+   
+   /* Cleanse the file name, prevent people from trying to unpack into
+      absolute paths, .., etc */
+   for (char *I = Itm.Name; *I != 0; I++)
+      if (*I == '/')
+	 *I = '_';
+
+   /* Force the ownership to be root and ensure correct permissions, 
+      go-w, the rest are left untouched */
+   Itm.UID = 0;
+   Itm.GID = 0;
+   Itm.Mode &= ~(S_IWGRP | S_IWOTH);
+   
+   return pkgDirStream::DoItem(Itm,Fd);
+}
+									/*}}}*/
+
+// MemControlExtract::DoItem - Check if it is the control file		/*{{{*/
+// ---------------------------------------------------------------------
+/* This sets up to extract the control block member file into a memory 
+   block of just the right size. All other files go into the bit bucket. */
+
+// Upper size limit for control files. Two reasons for having a limit here:
+//
+// 1. We read those files into memory and want to avoid being killed by OOM
+//
+// 2. We allocate (Itm.Size+2)-large arrays, so this can overflow if Itm.Size
+// becomes 2**64-2 or larger. This is obviously
+//
+// 64 MiB seems like a terribly large size that everyone should be happy with.
+static const unsigned long long DEB_CONTROL_SIZE_LIMIT = 64 * 1024 * 1024;
+bool debDebFile::MemControlExtract::DoItem(Item &Itm,int &Fd)
+{
+   // At the control file, allocate buffer memory.
+   if (Member == Itm.Name)
+   {
+      if (Itm.Size > DEB_CONTROL_SIZE_LIMIT)
+	 return _error->Error("Control file too large: %llu > %llu bytes", Itm.Size, DEB_CONTROL_SIZE_LIMIT);
+      delete [] Control;
+      Control = new char[Itm.Size+2];
+      IsControl = true;
+      Fd = -2; // Signal to pass to Process
+      Length = Itm.Size;
+   }   
+   else
+      IsControl = false;
+   
+   return true;
+}
+									/*}}}*/
+// MemControlExtract::Process - Process extracting the control file	/*{{{*/
+// ---------------------------------------------------------------------
+/* Just memcopy the block from the tar extractor and put it in the right
+   place in the pre-allocated memory block. */
+bool debDebFile::MemControlExtract::Process(Item &/*Itm*/,const unsigned char *Data,
+			     unsigned long long Size,unsigned long long Pos)
+{
+   memcpy(Control + Pos, Data,Size);
+   return true;
+}
+									/*}}}*/
+// MemControlExtract::Read - Read the control information from the deb	/*{{{*/
+// ---------------------------------------------------------------------
+/* This uses the internal tar extractor to fetch the control file, and then
+   it parses it into a tag section parser. */
+bool debDebFile::MemControlExtract::Read(debDebFile &Deb)
+{
+   if (Deb.ExtractTarMember(*this, "control.tar") == false)
+      return false;
+
+   if (Control == 0)
+      return true;
+   
+   Control[Length] = '\n';
+   Control[Length+1] = '\n';
+   if (Section.Scan(Control,Length+2) == false)
+      return _error->Error(_("Unparsable control file"));
+   return true;
+}
+									/*}}}*/
+// MemControlExtract::TakeControl - Parse a memory block		/*{{{*/
+// ---------------------------------------------------------------------
+/* The given memory block is loaded into the parser and parsed as a control
+   record. */
+bool debDebFile::MemControlExtract::TakeControl(const void *Data,unsigned long long Size)
+{
+   if (Size > DEB_CONTROL_SIZE_LIMIT)
+      return _error->Error("Control file too large: %llu > %llu bytes", Size, DEB_CONTROL_SIZE_LIMIT);
+
+   delete [] Control;
+   Control = new char[Size+2];
+   Length = Size;
+   memcpy(Control,Data,Size);
+   
+   Control[Length] = '\n';
+   Control[Length+1] = '\n';
+   return Section.Scan(Control,Length+2);
+}
+									/*}}}*/
+
diff --git a/apt-pkg/deb/debfile.h b/apt-pkg/deb/debfile.h
new file mode 100644
index 0000000..48a75ae
--- /dev/null
+++ b/apt-pkg/deb/debfile.h
@@ -0,0 +1,89 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+
+   Debian Archive File (.deb)
+
+   This Class handles all the operations performed directly on .deb 
+   files. It makes use of the AR and TAR classes to give the necessary
+   external interface.
+   
+   There are only two things that can be done with a raw package, 
+   extract it's control information and extract the contents itself. 
+
+   This should probably subclass an as-yet unwritten super class to
+   produce a generic archive mechanism.
+  
+   The memory control file extractor is useful to extract a single file
+   into memory from the control.tar.gz
+   
+   ##################################################################### */
+									/*}}}*/
+#ifndef PKGLIB_DEBFILE_H
+#define PKGLIB_DEBFILE_H
+
+#include <apt-pkg/arfile.h>
+#include <apt-pkg/dirstream.h>
+#include <apt-pkg/macros.h>
+#include <apt-pkg/tagfile.h>
+
+#include <string>
+
+
+class FileFd;
+
+class APT_PUBLIC debDebFile
+{
+   protected:
+   
+   FileFd &File;
+   ARArchive AR;
+   
+   bool CheckMember(const char *Name);
+   
+   public:
+   class ControlExtract;
+   class MemControlExtract;
+
+   bool ExtractTarMember(pkgDirStream &Stream, const char *Name);
+   bool ExtractArchive(pkgDirStream &Stream);
+   const ARArchive::Member *GotoMember(const char *Name);
+   inline FileFd &GetFile() {return File;};
+   
+   explicit debDebFile(FileFd &File);
+};
+
+class APT_PUBLIC debDebFile::ControlExtract : public pkgDirStream
+{
+   public:
+   
+   virtual bool DoItem(Item &Itm,int &Fd) APT_OVERRIDE;
+};
+
+class APT_PUBLIC debDebFile::MemControlExtract : public pkgDirStream
+{
+   bool IsControl;
+   
+   public:
+   
+   char *Control;
+   pkgTagSection Section;
+   unsigned long Length;
+   std::string Member;
+   
+   // Members from DirStream
+   virtual bool DoItem(Item &Itm,int &Fd) APT_OVERRIDE;
+   virtual bool Process(Item &Itm,const unsigned char *Data,
+			unsigned long long Size,unsigned long long Pos) APT_OVERRIDE;
+
+   // Helpers
+   bool Read(debDebFile &Deb);
+   bool TakeControl(const void *Data,unsigned long long Size);
+
+   MemControlExtract() : IsControl(false), Control(0), Length(0), Member("control") {};
+   explicit MemControlExtract(std::string Member) : IsControl(false), Control(0), Length(0), Member(Member) {};
+   ~MemControlExtract() {delete [] Control;};   
+};
+									/*}}}*/
+
+#endif
diff --git a/apt-pkg/deb/debindexfile.cc b/apt-pkg/deb/debindexfile.cc
new file mode 100644
index 0000000..e1698e1
--- /dev/null
+++ b/apt-pkg/deb/debindexfile.cc
@@ -0,0 +1,421 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+
+   Debian Specific sources.list types and the three sorts of Debian
+   index files.
+   
+   ##################################################################### */
+									/*}}}*/
+// Include Files							/*{{{*/
+#include <config.h>
+
+#include <apti18n.h>
+#include <apt-pkg/configuration.h>
+#include <apt-pkg/debfile.h>
+#include <apt-pkg/debindexfile.h>
+#include <apt-pkg/deblistparser.h>
+#include <apt-pkg/debrecords.h>
+#include <apt-pkg/debsrcrecords.h>
+#include <apt-pkg/error.h>
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/indexfile.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/pkgrecords.h>
+#include <apt-pkg/srcrecords.h>
+#include <apt-pkg/strutl.h>
+
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <stdio.h>
+
+#include <sys/stat.h>
+#include <unistd.h>
+									/*}}}*/
+
+// Sources Index							/*{{{*/
+debSourcesIndex::debSourcesIndex(IndexTarget const &Target,bool const Trusted) :
+     pkgDebianIndexTargetFile(Target, Trusted), d(NULL)
+{
+}
+std::string debSourcesIndex::SourceInfo(pkgSrcRecords::Parser const &Record,
+				   pkgSrcRecords::File const &File) const
+{
+   // The result looks like: http://foo/debian/ stable/main src 1.1.1 (dsc)
+   std::string Res = Target.Description;
+   Res.erase(Target.Description.rfind(' '));
+
+   Res += " ";
+   Res += Record.Package();
+   Res += " ";
+   Res += Record.Version();
+   if (File.Type.empty() == false)
+      Res += " (" + File.Type + ")";
+   return Res;
+}
+pkgSrcRecords::Parser *debSourcesIndex::CreateSrcParser() const
+{
+   std::string const SourcesURI = IndexFileName();
+   if (FileExists(SourcesURI))
+      return new debSrcRecordParser(SourcesURI, this);
+   return NULL;
+}
+bool debSourcesIndex::OpenListFile(FileFd &, std::string const &)
+{
+   return true;
+}
+pkgCacheListParser * debSourcesIndex::CreateListParser(FileFd &)
+{
+   return nullptr;
+}
+uint8_t debSourcesIndex::GetIndexFlags() const
+{
+   return 0;
+}
+									/*}}}*/
+// Packages Index							/*{{{*/
+debPackagesIndex::debPackagesIndex(IndexTarget const &Target, bool const Trusted) :
+                  pkgDebianIndexTargetFile(Target, Trusted), d(NULL)
+{
+}
+std::string debPackagesIndex::ArchiveInfo(pkgCache::VerIterator const &Ver) const
+{
+   std::string Res = Target.Description;
+   {
+      auto const space = Target.Description.rfind(' ');
+      if (space != std::string::npos)
+	 Res.erase(space);
+   }
+
+   Res += " ";
+   Res += Ver.ParentPkg().Name();
+   Res += " ";
+   std::string const Dist = Target.Option(IndexTarget::RELEASE);
+   if (Dist.empty() == false && Dist[Dist.size() - 1] != '/')
+      Res.append(Ver.Arch()).append(" ");
+   Res += Ver.VerStr();
+   return Res;
+}
+uint8_t debPackagesIndex::GetIndexFlags() const
+{
+   return 0;
+}
+									/*}}}*/
+// Translation-* Index							/*{{{*/
+debTranslationsIndex::debTranslationsIndex(IndexTarget const &Target) :
+			pkgDebianIndexTargetFile(Target, true), d(NULL)
+{}
+bool debTranslationsIndex::HasPackages() const
+{
+   return Exists();
+}
+bool debTranslationsIndex::OpenListFile(FileFd &Pkg, std::string const &FileName)
+{
+   if (FileExists(FileName))
+      return pkgDebianIndexTargetFile::OpenListFile(Pkg, FileName);
+   return true;
+}
+uint8_t debTranslationsIndex::GetIndexFlags() const
+{
+   return pkgCache::Flag::NotSource | pkgCache::Flag::NoPackages;
+}
+std::string debTranslationsIndex::GetArchitecture() const
+{
+   return std::string();
+}
+pkgCacheListParser * debTranslationsIndex::CreateListParser(FileFd &Pkg)
+{
+   if (Pkg.IsOpen() == false)
+      return nullptr;
+   _error->PushToStack();
+   std::unique_ptr<pkgCacheListParser> Parser(new debTranslationsParser(&Pkg));
+   bool const newError = _error->PendingError();
+   _error->MergeWithStack();
+   return newError ? nullptr : Parser.release();
+}
+									/*}}}*/
+// dpkg/status Index							/*{{{*/
+debStatusIndex::debStatusIndex(std::string const &File) : pkgDebianIndexRealFile(File, true), d(NULL)
+{
+}
+std::string debStatusIndex::GetArchitecture() const
+{
+   return std::string();
+}
+std::string debStatusIndex::GetComponent() const
+{
+   return "now";
+}
+uint8_t debStatusIndex::GetIndexFlags() const
+{
+   return pkgCache::Flag::NotSource;
+}
+
+pkgCacheListParser * debStatusIndex::CreateListParser(FileFd &Pkg)
+{
+   if (Pkg.IsOpen() == false)
+      return nullptr;
+   _error->PushToStack();
+   std::unique_ptr<pkgCacheListParser> Parser(new debStatusListParser(&Pkg));
+   bool const newError = _error->PendingError();
+   _error->MergeWithStack();
+   return newError ? nullptr : Parser.release();
+}
+									/*}}}*/
+// DebPkgFile Index - a single .deb file as an index			/*{{{*/
+debDebPkgFileIndex::debDebPkgFileIndex(std::string const &DebFile)
+   : pkgDebianIndexRealFile(DebFile, true), d(NULL), DebFile(DebFile)
+{
+}
+bool debDebPkgFileIndex::GetContent(std::ostream &content, std::string const &debfile)
+{
+   struct stat Buf;
+   if (stat(debfile.c_str(), &Buf) != 0)
+      return false;
+
+   FileFd debFd(debfile, FileFd::ReadOnly);
+   debDebFile deb(debFd);
+   debDebFile::MemControlExtract extractor("control");
+
+   if (not extractor.Read(deb))
+      return _error->Error(_("Could not read meta data from %s"), debfile.c_str());
+
+   // trim off newlines
+   while (extractor.Control[extractor.Length] == '\n')
+      extractor.Control[extractor.Length--] = '\0';
+   const char *Control = extractor.Control;
+   while (isspace_ascii(Control[0]))
+      Control++;
+
+   content << Control << '\n';
+   content << "Filename: " << debfile << "\n";
+   content << "Size: " << std::to_string(Buf.st_size) << "\n";
+
+   return true;
+}
+bool debDebPkgFileIndex::OpenListFile(FileFd &Pkg, std::string const &FileName)
+{
+   // write the control data to a tempfile
+   if (GetTempFile("deb-file-" + flNotDir(FileName), true, &Pkg) == NULL)
+      return false;
+   std::ostringstream content;
+   if (GetContent(content, FileName) == false)
+      return false;
+   std::string const contentstr = content.str();
+   if (contentstr.empty())
+      return true;
+   if (Pkg.Write(contentstr.c_str(), contentstr.length()) == false || Pkg.Seek(0) == false)
+      return false;
+   return true;
+}
+pkgCacheListParser * debDebPkgFileIndex::CreateListParser(FileFd &Pkg)
+{
+   if (Pkg.IsOpen() == false)
+      return nullptr;
+   _error->PushToStack();
+   std::unique_ptr<pkgCacheListParser> Parser(new debDebFileParser(&Pkg, DebFile));
+   bool const newError = _error->PendingError();
+   _error->MergeWithStack();
+   return newError ? nullptr : Parser.release();
+}
+uint8_t debDebPkgFileIndex::GetIndexFlags() const
+{
+   return pkgCache::Flag::LocalSource;
+}
+std::string debDebPkgFileIndex::GetArchitecture() const
+{
+   return std::string();
+}
+std::string debDebPkgFileIndex::GetComponent() const
+{
+   return "local-deb";
+}
+pkgCache::PkgFileIterator debDebPkgFileIndex::FindInCache(pkgCache &Cache) const
+{
+   std::string const FileName = IndexFileName();
+   pkgCache::PkgFileIterator File = Cache.FileBegin();
+   for (; File.end() == false; ++File)
+   {
+       if (File.FileName() == NULL || FileName != File.FileName())
+	 continue;
+      // we can't do size checks here as file size != content size
+      return File;
+   }
+
+   return File;
+}
+std::string debDebPkgFileIndex::ArchiveInfo(pkgCache::VerIterator const &Ver) const
+{
+   std::string Res = IndexFileName() + " ";
+   Res.append(Ver.ParentPkg().Name()).append(" ");
+   Res.append(Ver.Arch()).append(" ");
+   Res.append(Ver.VerStr());
+   return Res;
+}
+									/*}}}*/
+// DscFile Index - a single .dsc file as an index			/*{{{*/
+debDscFileIndex::debDscFileIndex(std::string const &DscFile)
+   : pkgDebianIndexRealFile(DscFile, true), d(NULL)
+{
+}
+pkgSrcRecords::Parser *debDscFileIndex::CreateSrcParser() const
+{
+   if (Exists() == false)
+      return NULL;
+   return new debDscRecordParser(File, this);
+}
+std::string debDscFileIndex::GetComponent() const
+{
+   return "local-dsc";
+}
+std::string debDscFileIndex::GetArchitecture() const
+{
+   return "source";
+}
+uint8_t debDscFileIndex::GetIndexFlags() const
+{
+   return pkgCache::Flag::LocalSource;
+}
+									/*}}}*/
+// ControlFile Index - a directory with a debian/control file		/*{{{*/
+std::string debDebianSourceDirIndex::GetComponent() const
+{
+   return "local-control";
+}
+									/*}}}*/
+// String Package Index - a string of Packages file content		/*{{{*/
+std::string debStringPackageIndex::GetArchitecture() const
+{
+   return std::string();
+}
+std::string debStringPackageIndex::GetComponent() const
+{
+   return "apt-tmp-index";
+}
+uint8_t debStringPackageIndex::GetIndexFlags() const
+{
+   return pkgCache::Flag::NotSource;
+}
+const pkgIndexFile::Type *debStringPackageIndex::GetType() const
+{
+   return pkgIndexFile::Type::GetType("Debian Package Index");
+}
+debStringPackageIndex::debStringPackageIndex(std::string const &content) :
+   pkgDebianIndexRealFile("", false), d(NULL)
+{
+   FileFd fd;
+   GetTempFile("apt-tmp-index", false, &fd);
+   fd.Write(content.data(), content.length());
+   File = fd.Name();
+}
+debStringPackageIndex::~debStringPackageIndex()
+{
+   RemoveFile("~debStringPackageIndex", File);
+}
+									/*}}}*/
+
+// Index File types for Debian						/*{{{*/
+class APT_HIDDEN debIFTypeSrc : public pkgIndexFile::Type
+{
+   public:
+   debIFTypeSrc() {Label = "Debian Source Index";};
+};
+class APT_HIDDEN debIFTypePkg : public pkgIndexFile::Type
+{
+   public:
+   virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &File) const APT_OVERRIDE
+   {
+      return new debRecordParser(File.FileName(),*File.Cache());
+   };
+   debIFTypePkg() {Label = "Debian Package Index";};
+};
+class APT_HIDDEN debIFTypeTrans : public debIFTypePkg
+{
+   public:
+   debIFTypeTrans() {Label = "Debian Translation Index";};
+};
+class APT_HIDDEN debIFTypeStatus : public pkgIndexFile::Type
+{
+   public:
+   virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &File) const APT_OVERRIDE
+   {
+      return new debRecordParser(File.FileName(),*File.Cache());
+   };
+   debIFTypeStatus() {Label = "Debian dpkg status file";};
+};
+class APT_HIDDEN debIFTypeDebPkgFile : public pkgIndexFile::Type
+{
+   public:
+   virtual pkgRecords::Parser *CreatePkgParser(pkgCache::PkgFileIterator const &File) const APT_OVERRIDE
+   {
+      return new debDebFileRecordParser(File.FileName());
+   };
+   debIFTypeDebPkgFile() {Label = "Debian deb file";};
+};
+class APT_HIDDEN debIFTypeDscFile : public pkgIndexFile::Type
+{
+   public:
+   virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string const &DscFile) const APT_OVERRIDE
+   {
+      return new debDscRecordParser(DscFile, NULL);
+   };
+   debIFTypeDscFile() {Label = "Debian dsc file";};
+};
+class APT_HIDDEN debIFTypeDebianSourceDir : public pkgIndexFile::Type
+{
+   public:
+   virtual pkgSrcRecords::Parser *CreateSrcPkgParser(std::string const &SourceDir) const APT_OVERRIDE
+   {
+      return new debDscRecordParser(SourceDir + std::string("/debian/control"), NULL);
+   };
+   debIFTypeDebianSourceDir() {Label = "Debian control file";};
+};
+
+APT_HIDDEN debIFTypeSrc _apt_Src;
+APT_HIDDEN debIFTypePkg _apt_Pkg;
+APT_HIDDEN debIFTypeTrans _apt_Trans;
+APT_HIDDEN debIFTypeStatus _apt_Status;
+APT_HIDDEN debIFTypeDebPkgFile _apt_DebPkgFile;
+// file based pseudo indexes
+APT_HIDDEN debIFTypeDscFile _apt_DscFile;
+APT_HIDDEN debIFTypeDebianSourceDir _apt_DebianSourceDir;
+
+const pkgIndexFile::Type *debSourcesIndex::GetType() const
+{
+   return &_apt_Src;
+}
+const pkgIndexFile::Type *debPackagesIndex::GetType() const
+{
+   return &_apt_Pkg;
+}
+const pkgIndexFile::Type *debTranslationsIndex::GetType() const
+{
+   return &_apt_Trans;
+}
+const pkgIndexFile::Type *debStatusIndex::GetType() const
+{
+   return &_apt_Status;
+}
+const pkgIndexFile::Type *debDebPkgFileIndex::GetType() const
+{
+   return &_apt_DebPkgFile;
+}
+const pkgIndexFile::Type *debDscFileIndex::GetType() const
+{
+   return &_apt_DscFile;
+}
+const pkgIndexFile::Type *debDebianSourceDirIndex::GetType() const
+{
+   return &_apt_DebianSourceDir;
+}
+									/*}}}*/
+
+debStatusIndex::~debStatusIndex() {}
+debPackagesIndex::~debPackagesIndex() {}
+debTranslationsIndex::~debTranslationsIndex() {}
+debSourcesIndex::~debSourcesIndex() {}
+
+debDebPkgFileIndex::~debDebPkgFileIndex() {}
+debDscFileIndex::~debDscFileIndex() {}
diff --git a/apt-pkg/deb/debindexfile.h b/apt-pkg/deb/debindexfile.h
new file mode 100644
index 0000000..57b3738
--- /dev/null
+++ b/apt-pkg/deb/debindexfile.h
@@ -0,0 +1,196 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+
+   Debian Index Files
+   
+   There are three sorts currently
+   
+   Package files that have File: tags
+   Package files that don't (/var/lib/dpkg/status)
+   Source files
+   
+   ##################################################################### */
+									/*}}}*/
+#ifndef PKGLIB_DEBINDEXFILE_H
+#define PKGLIB_DEBINDEXFILE_H
+
+#include <apt-pkg/indexfile.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/srcrecords.h>
+
+#include <string>
+
+class OpProgress;
+class pkgAcquire;
+class pkgCacheGenerator;
+
+class debStatusIndex : public pkgDebianIndexRealFile
+{
+   void * const d;
+protected:
+   virtual std::string GetArchitecture() const APT_OVERRIDE;
+   virtual std::string GetComponent() const APT_OVERRIDE;
+   virtual uint8_t GetIndexFlags() const APT_OVERRIDE;
+
+public:
+
+   virtual const Type *GetType() const APT_OVERRIDE APT_PURE;
+
+   // Interface for the Cache Generator
+   virtual bool HasPackages() const APT_OVERRIDE {return true;};
+   // Abort if the file does not exist.
+   virtual bool Exists() const APT_OVERRIDE {return true;};
+
+   virtual pkgCacheListParser * CreateListParser(FileFd &Pkg) APT_OVERRIDE;
+
+   explicit debStatusIndex(std::string const &File);
+   virtual ~debStatusIndex();
+};
+
+class debPackagesIndex : public pkgDebianIndexTargetFile
+{
+   void * const d;
+protected:
+   virtual uint8_t GetIndexFlags() const APT_OVERRIDE;
+
+public:
+   virtual const Type *GetType() const APT_OVERRIDE APT_PURE;
+
+   // Stuff for accessing files on remote items
+   virtual std::string ArchiveInfo(pkgCache::VerIterator const &Ver) const APT_OVERRIDE;
+
+   // Interface for the Cache Generator
+   virtual bool HasPackages() const APT_OVERRIDE {return true;};
+
+   debPackagesIndex(IndexTarget const &Target, bool const Trusted);
+   virtual ~debPackagesIndex();
+};
+
+class debTranslationsIndex : public pkgDebianIndexTargetFile
+{
+   void * const d;
+protected:
+   virtual std::string GetArchitecture() const APT_OVERRIDE;
+   virtual uint8_t GetIndexFlags() const APT_OVERRIDE;
+   virtual bool OpenListFile(FileFd &Pkg, std::string const &FileName) APT_OVERRIDE;
+   APT_HIDDEN virtual pkgCacheListParser * CreateListParser(FileFd &Pkg) APT_OVERRIDE;
+
+public:
+
+   virtual const Type *GetType() const APT_OVERRIDE APT_PURE;
+
+   // Interface for the Cache Generator
+   virtual bool HasPackages() const APT_OVERRIDE;
+
+   explicit debTranslationsIndex(IndexTarget const &Target);
+   virtual ~debTranslationsIndex();
+};
+
+class debSourcesIndex : public pkgDebianIndexTargetFile
+{
+   void * const d;
+   virtual uint8_t GetIndexFlags() const APT_OVERRIDE;
+   virtual bool OpenListFile(FileFd &Pkg, std::string const &FileName) APT_OVERRIDE;
+   APT_HIDDEN virtual pkgCacheListParser * CreateListParser(FileFd &Pkg) APT_OVERRIDE;
+
+   public:
+
+   virtual const Type *GetType() const APT_OVERRIDE APT_PURE;
+
+   // Stuff for accessing files on remote items
+   virtual std::string SourceInfo(pkgSrcRecords::Parser const &Record,
+			     pkgSrcRecords::File const &File) const APT_OVERRIDE;
+
+   // Interface for the record parsers
+   virtual pkgSrcRecords::Parser *CreateSrcParser() const APT_OVERRIDE;
+
+   // Interface for the Cache Generator
+   virtual bool HasPackages() const APT_OVERRIDE {return false;};
+
+   debSourcesIndex(IndexTarget const &Target, bool const Trusted);
+   virtual ~debSourcesIndex();
+};
+
+class debDebPkgFileIndex : public pkgDebianIndexRealFile
+{
+   void * const d;
+   std::string DebFile;
+
+protected:
+   virtual std::string GetComponent() const APT_OVERRIDE;
+   virtual std::string GetArchitecture() const APT_OVERRIDE;
+   virtual uint8_t GetIndexFlags() const APT_OVERRIDE;
+   virtual bool OpenListFile(FileFd &Pkg, std::string const &FileName) APT_OVERRIDE;
+   APT_HIDDEN virtual pkgCacheListParser * CreateListParser(FileFd &Pkg) APT_OVERRIDE;
+
+public:
+   virtual const Type *GetType() const APT_OVERRIDE APT_PURE;
+
+   /** get the control (file) content of the deb file
+    *
+    * @param[out] content of the control file
+    * @param debfile is the filename of the .deb-file
+    * @return \b true if successful, otherwise \b false.
+    */
+   static bool GetContent(std::ostream &content, std::string const &debfile);
+
+   // Interface for the Cache Generator
+   virtual bool HasPackages() const APT_OVERRIDE {return true;}
+   virtual pkgCache::PkgFileIterator FindInCache(pkgCache &Cache) const APT_OVERRIDE;
+
+   // Interface for acquire
+
+   explicit debDebPkgFileIndex(std::string const &DebFile);
+   virtual ~debDebPkgFileIndex();
+
+   std::string ArchiveInfo(pkgCache::VerIterator const &Ver) const override;
+};
+
+class APT_PUBLIC debDscFileIndex : public pkgDebianIndexRealFile
+{
+   void * const d;
+
+protected:
+   virtual std::string GetComponent() const APT_OVERRIDE;
+   virtual std::string GetArchitecture() const APT_OVERRIDE;
+   virtual uint8_t GetIndexFlags() const APT_OVERRIDE;
+
+public:
+   virtual const Type *GetType() const APT_OVERRIDE APT_PURE;
+   virtual pkgSrcRecords::Parser *CreateSrcParser() const APT_OVERRIDE;
+   virtual bool HasPackages() const APT_OVERRIDE {return false;};
+
+   explicit debDscFileIndex(std::string const &DscFile);
+   virtual ~debDscFileIndex();
+};
+
+class debDebianSourceDirIndex : public debDscFileIndex
+{
+protected:
+   virtual std::string GetComponent() const APT_OVERRIDE;
+
+public:
+   virtual const Type *GetType() const APT_OVERRIDE APT_PURE;
+};
+
+class APT_PUBLIC debStringPackageIndex : public pkgDebianIndexRealFile
+{
+   void * const d;
+protected:
+   virtual std::string GetArchitecture() const APT_OVERRIDE;
+   virtual std::string GetComponent() const APT_OVERRIDE;
+   virtual uint8_t GetIndexFlags() const APT_OVERRIDE;
+
+public:
+   virtual const Type *GetType() const APT_OVERRIDE APT_PURE;
+
+   // Interface for the Cache Generator
+   virtual bool HasPackages() const APT_OVERRIDE {return true;};
+   // Abort if the file does not exist.
+   virtual bool Exists() const APT_OVERRIDE {return true;};
+
+   explicit debStringPackageIndex(std::string const &content);
+   virtual ~debStringPackageIndex();
+};
+#endif
diff --git a/apt-pkg/deb/deblistparser.cc b/apt-pkg/deb/deblistparser.cc
new file mode 100644
index 0000000..d0f0838
--- /dev/null
+++ b/apt-pkg/deb/deblistparser.cc
@@ -0,0 +1,1043 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+   
+   Package Cache Generator - Generator for the cache structure.
+   
+   This builds the cache structure from the abstract package list parser. 
+   
+   ##################################################################### */
+									/*}}}*/
+// Include Files							/*{{{*/
+#include <config.h>
+
+#include <apt-pkg/algorithms.h>
+#include <apt-pkg/aptconfiguration.h>
+#include <apt-pkg/cachefilter.h>
+#include <apt-pkg/configuration.h>
+#include <apt-pkg/deblistparser.h>
+#include <apt-pkg/error.h>
+#include <apt-pkg/hashes.h>
+#include <apt-pkg/macros.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/strutl.h>
+#include <apt-pkg/tagfile-keys.h>
+#include <apt-pkg/tagfile.h>
+
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <ctype.h>
+#include <stddef.h>
+#include <string.h>
+									/*}}}*/
+
+using std::string;
+using APT::StringView;
+
+static const debListParser::WordList PrioList[] = {
+   {"required",pkgCache::State::Required},
+   {"important",pkgCache::State::Important},
+   {"standard",pkgCache::State::Standard},
+   {"optional",pkgCache::State::Optional},
+   {"extra",pkgCache::State::Extra},
+   {"", 0}};
+
+// ListParser::debListParser - Constructor				/*{{{*/
+// ---------------------------------------------------------------------
+/* Provide an architecture and only this one and "all" will be accepted
+   in Step(), if no Architecture is given we will accept every arch
+   we would accept in general with checkArchitecture() */
+debListParser::debListParser(FileFd *File) :
+   pkgCacheListParser(), Tags(File)
+{
+   // this dance allows an empty value to override the default
+   if (_config->Exists("pkgCacheGen::ForceEssential"))
+   {
+      forceEssential = _config->FindVector("pkgCacheGen::ForceEssential");
+      if (forceEssential.empty() == false && _config->Find("pkgCacheGen::ForceEssential").empty())
+	 forceEssential.emplace_back("apt");
+   }
+   else
+      forceEssential.emplace_back("apt");
+   forceImportant = _config->FindVector("pkgCacheGen::ForceImportant");
+   myArch = _config->Find("APT::Architecture");
+}
+									/*}}}*/
+// ListParser::Package - Return the package name			/*{{{*/
+// ---------------------------------------------------------------------
+/* This is to return the name of the package this section describes */
+string debListParser::Package() {
+   string Result = Section.Find(pkgTagSection::Key::Package).to_string();
+
+   // Normalize mixed case package names to lower case, like dpkg does
+   // See Bug#807012 for details.
+   // Only do this when the package name does not contain a / - as that
+   // indicates that the package name was derived from a filename given
+   // to install or build-dep or similar (Bug#854794)
+   if (likely(Result.find('/') == string::npos))
+   {
+      for (char &c: Result)
+      {
+	 char l = tolower_ascii_inline(c);
+	 if (unlikely(l != c))
+	    c = l;
+      }
+   }
+
+   if(unlikely(Result.empty() == true))
+      _error->Error("Encountered a section with no Package: header");
+   return Result;
+}
+									/*}}}*/
+// ListParser::Architecture - Return the package arch			/*{{{*/
+// ---------------------------------------------------------------------
+/* This will return the Architecture of the package this section describes */
+APT::StringView debListParser::Architecture() {
+   auto const Arch = Section.Find(pkgTagSection::Key::Architecture);
+   return Arch.empty() ? "none" : Arch;
+}
+									/*}}}*/
+// ListParser::ArchitectureAll						/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool debListParser::ArchitectureAll() {
+   return Section.Find(pkgTagSection::Key::Architecture) == "all";
+}
+									/*}}}*/
+// ListParser::Version - Return the version string			/*{{{*/
+// ---------------------------------------------------------------------
+/* This is to return the string describing the version in debian form,
+   epoch:upstream-release. If this returns the blank string then the 
+   entry is assumed to only describe package properties */
+APT::StringView debListParser::Version()
+{
+   return Section.Find(pkgTagSection::Key::Version);
+}
+									/*}}}*/
+unsigned char debListParser::ParseMultiArch(bool const showErrors)	/*{{{*/
+{
+   unsigned char MA;
+   auto const MultiArch = Section.Find(pkgTagSection::Key::Multi_Arch);
+   if (MultiArch.empty() == true || MultiArch == "no")
+      MA = pkgCache::Version::No;
+   else if (MultiArch == "same") {
+      if (ArchitectureAll() == true)
+      {
+	 if (showErrors == true)
+	    _error->Warning("Architecture: all package '%s' can't be Multi-Arch: same",
+		  Section.FindS("Package").c_str());
+	 MA = pkgCache::Version::No;
+      }
+      else
+	 MA = pkgCache::Version::Same;
+   }
+   else if (MultiArch == "foreign")
+      MA = pkgCache::Version::Foreign;
+   else if (MultiArch == "allowed")
+      MA = pkgCache::Version::Allowed;
+   else
+   {
+      if (showErrors == true)
+	 _error->Warning("Unknown Multi-Arch type '%s' for package '%s'",
+	       MultiArch.to_string().c_str(), Section.FindS("Package").c_str());
+      MA = pkgCache::Version::No;
+   }
+
+   if (ArchitectureAll() == true)
+      MA |= pkgCache::Version::All;
+
+   return MA;
+}
+									/*}}}*/
+// ListParser::NewVersion - Fill in the version structure		/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool debListParser::NewVersion(pkgCache::VerIterator &Ver)
+{
+   const char *Start;
+   const char *Stop;
+
+   // Parse the section
+   if (Section.Find(pkgTagSection::Key::Section,Start,Stop) == true)
+   {
+      map_stringitem_t const idx = StoreString(pkgCacheGenerator::SECTION, Start, Stop - Start);
+      Ver->Section = idx;
+   }
+   // Parse the source package name
+   pkgCache::GrpIterator G = Ver.ParentPkg().Group();
+
+   // Setup the defaults
+   Ver->SourcePkgName = G->Name;
+   Ver->SourceVerStr = Ver->VerStr;
+
+   // Parse the name and version str
+   if (Section.Find(pkgTagSection::Key::Source,Start,Stop) == true)
+   {
+      const char * const Space = static_cast<const char *>(memchr(Start, ' ', Stop - Start));
+      pkgCache::VerIterator V;
+
+      if (Space != NULL)
+      {
+	 const char * const Open = static_cast<const char *>(memchr(Space, '(', Stop - Space));
+	 if (likely(Open != NULL))
+	 {
+	    const char * const Close = static_cast<const char *>(memchr(Open, ')', Stop - Open));
+	    if (likely(Close != NULL))
+	    {
+	       APT::StringView const version(Open + 1, (Close - Open) - 1);
+	       if (version != Ver.VerStr())
+	       {
+		  map_stringitem_t const idx = StoreString(pkgCacheGenerator::VERSIONNUMBER, version);
+		  G = Ver.ParentPkg().Group();
+		  Ver->SourceVerStr = idx;
+	       }
+	    }
+	 }
+	 Stop = Space;
+      }
+
+      APT::StringView const pkgname(Start, Stop - Start);
+      // Oh, our group is the wrong one for the source package. Make a new one.
+      if (pkgname != G.Name())
+      {
+	 if (not NewGroup(G, pkgname))
+	    return false;
+      }
+   }
+
+   // Link into by source package group.
+   Ver->SourcePkgName = G->Name;
+   Ver->NextInSource = G->VersionsInSource;
+   G->VersionsInSource = Ver.MapPointer();
+
+   Ver->MultiArch = ParseMultiArch(true);
+   // Archive Size
+   Ver->Size = Section.FindULL(pkgTagSection::Key::Size);
+   // Unpacked Size (in K)
+   Ver->InstalledSize = Section.FindULL(pkgTagSection::Key::Installed_Size);
+   Ver->InstalledSize *= 1024;
+
+   // Priority
+   if (Section.Find(pkgTagSection::Key::Priority,Start,Stop) == true)
+   {
+      if (GrabWord(StringView(Start,Stop-Start),PrioList,Ver->Priority) == false)
+	 Ver->Priority = pkgCache::State::Extra;
+   }
+
+   if (ParseDepends(Ver,pkgTagSection::Key::Pre_Depends,pkgCache::Dep::PreDepends) == false)
+      return false;
+   if (ParseDepends(Ver,pkgTagSection::Key::Depends,pkgCache::Dep::Depends) == false)
+      return false;
+   if (ParseDepends(Ver,pkgTagSection::Key::Conflicts,pkgCache::Dep::Conflicts) == false)
+      return false;
+   if (ParseDepends(Ver,pkgTagSection::Key::Breaks,pkgCache::Dep::DpkgBreaks) == false)
+      return false;
+   if (ParseDepends(Ver,pkgTagSection::Key::Recommends,pkgCache::Dep::Recommends) == false)
+      return false;
+   if (ParseDepends(Ver,pkgTagSection::Key::Suggests,pkgCache::Dep::Suggests) == false)
+      return false;
+   if (ParseDepends(Ver,pkgTagSection::Key::Replaces,pkgCache::Dep::Replaces) == false)
+      return false;
+   if (ParseDepends(Ver,pkgTagSection::Key::Enhances,pkgCache::Dep::Enhances) == false)
+      return false;
+   // Obsolete.
+   if (ParseDepends(Ver,pkgTagSection::Key::Optional,pkgCache::Dep::Suggests) == false)
+      return false;
+   
+   if (ParseProvides(Ver) == false)
+      return false;
+   if (not APT::KernelAutoRemoveHelper::getUname(Ver.ParentPkg().Name()).empty())
+   {
+      if (not NewProvides(Ver, "$kernel", "any", Ver.VerStr(), pkgCache::Flag::MultiArchImplicit))
+	 return false;
+   }
+
+   return true;
+}
+									/*}}}*/
+// ListParser::AvailableDescriptionLanguages				/*{{{*/
+std::vector<std::string> debListParser::AvailableDescriptionLanguages()
+{
+   std::vector<std::string> const understood = APT::Configuration::getLanguages(true);
+   std::vector<std::string> avail;
+   static constexpr int prefixLen = 12;
+   char buf[32] = "Description-";
+   if (Section.Exists("Description") == true)
+      avail.push_back("");
+   for (std::vector<std::string>::const_iterator lang = understood.begin(); lang != understood.end(); ++lang)
+   {
+      if (unlikely(lang->size() > sizeof(buf) - prefixLen)) {
+	 _error->Warning("Ignoring translated description %s", lang->c_str());
+	 continue;
+      }
+      memcpy(buf + prefixLen, lang->c_str(), lang->size());
+      if (Section.Exists(StringView(buf, prefixLen + lang->size())) == true)
+	 avail.push_back(*lang);
+   }
+   return avail;
+}
+									/*}}}*/
+// ListParser::Description_md5 - Return the description_md5 MD5SumValue	/*{{{*/
+// ---------------------------------------------------------------------
+/* This is to return the md5 string to allow the check if it is the right
+   description. If no Description-md5 is found in the section it will be
+   calculated.
+ */
+APT::StringView debListParser::Description_md5()
+{
+   StringView const value = Section.Find(pkgTagSection::Key::Description_md5);
+   if (unlikely(value.empty() == true))
+   {
+      StringView const desc = Section.Find(pkgTagSection::Key::Description);
+      if (desc == "\n")
+	 return StringView();
+
+      Hashes md5(Hashes::MD5SUM);
+      md5.Add(desc.data(), desc.size());
+      md5.Add("\n");
+      MD5Buffer = md5.GetHashString(Hashes::MD5SUM).HashValue();
+      return StringView(MD5Buffer);
+   }
+   else if (likely(value.size() == 32))
+   {
+      return value;
+   }
+   _error->Error("Malformed Description-md5 line; doesn't have the required length (32 != %d) '%.*s'", (int)value.size(), (int)value.length(), value.data());
+   return StringView();
+}
+                                                                        /*}}}*/
+// ListParser::UsePackage - Update a package structure			/*{{{*/
+// ---------------------------------------------------------------------
+/* This is called to update the package with any new information 
+   that might be found in the section */
+bool debListParser::UsePackage(pkgCache::PkgIterator &Pkg,
+			       pkgCache::VerIterator &Ver)
+{
+   string const static myArch = _config->Find("APT::Architecture");
+   // Possible values are: "all", "native", "installed" and "none"
+   // The "installed" mode is handled by ParseStatus(), See #544481 and friends.
+   string const static essential = _config->Find("pkgCacheGen::Essential", "all");
+   if (essential == "all" ||
+       (essential == "native" && Pkg->Arch != 0 && myArch == Pkg.Arch()))
+      if (Section.FindFlag(pkgTagSection::Key::Essential,Pkg->Flags,pkgCache::Flag::Essential) == false)
+	 return false;
+   if (Section.FindFlag(pkgTagSection::Key::Important,Pkg->Flags,pkgCache::Flag::Important) == false)
+      return false;
+   if (Section.FindFlag(pkgTagSection::Key::Protected, Pkg->Flags, pkgCache::Flag::Important) == false)
+      return false;
+
+   if (std::find(forceEssential.begin(), forceEssential.end(), Pkg.Name()) != forceEssential.end())
+   {
+      if ((essential == "native" && Pkg->Arch != 0 && myArch == Pkg.Arch()) ||
+	  essential == "all")
+	 Pkg->Flags |= pkgCache::Flag::Essential | pkgCache::Flag::Important;
+      else
+	 Pkg->Flags |= pkgCache::Flag::Important;
+   }
+   else if (std::find(forceImportant.begin(), forceImportant.end(), Pkg.Name()) != forceImportant.end())
+      Pkg->Flags |= pkgCache::Flag::Important;
+
+   auto phased = Section.FindULL(pkgTagSection::Key::Phased_Update_Percentage, 100);
+   if (phased != 100)
+   {
+      if (not Ver.PhasedUpdatePercentage(phased))
+	 _error->Warning("Ignoring invalid Phased-Update-Percentage value");
+   }
+
+   if (ParseStatus(Pkg,Ver) == false)
+      return false;
+   return true;
+}
+									/*}}}*/
+// ListParser::VersionHash - Compute a unique hash for this version	/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+uint32_t debListParser::VersionHash()
+{
+   static constexpr pkgTagSection::Key Sections[] ={
+      pkgTagSection::Key::Installed_Size,
+      pkgTagSection::Key::Depends,
+      pkgTagSection::Key::Pre_Depends,
+//    pkgTagSection::Key::Suggests,
+//    pkgTagSection::Key::Recommends",
+      pkgTagSection::Key::Conflicts,
+      pkgTagSection::Key::Breaks,
+      pkgTagSection::Key::Replaces};
+   unsigned long Result = 5381;
+   for (auto I : Sections)
+   {
+      const char *Start;
+      const char *End;
+      if (Section.Find(I,Start,End) == false)
+	 continue;
+      
+      /* Strip out any spaces from the text, this undoes dpkgs reformatting
+         of certain fields. dpkg also has the rather interesting notion of
+         reformatting depends operators < -> <=, so we drop all = from the
+	 string to make that not matter. */
+      for (; Start != End; ++Start)
+      {
+	 // Strip away 0: epochs from input
+	 if (*Start == '0' && Start[1] == ':') {
+	    Start++;	// Skip the :
+	    continue;	// Skip the 0
+	 }
+	 if (isspace_ascii(*Start) != 0 || *Start == '=')
+	    continue;
+	 Result = 33 * Result + tolower_ascii_unsafe(*Start);
+      }
+
+
+   }
+   
+   return Result;
+}
+									/*}}}*/
+// StatusListParser::ParseStatus - Parse the status field		/*{{{*/
+// ---------------------------------------------------------------------
+/* Status lines are of the form,
+     Status: want flag status
+   want = unknown, install, hold, deinstall, purge
+   flag = ok, reinstreq
+   status = not-installed, config-files, half-installed, unpacked,
+            half-configured, triggers-awaited, triggers-pending, installed
+ */
+bool debListParser::ParseStatus(pkgCache::PkgIterator &,
+				pkgCache::VerIterator &)
+{
+   return true;
+}
+bool debStatusListParser::ParseStatus(pkgCache::PkgIterator &Pkg,
+				pkgCache::VerIterator &Ver)
+{
+   const char *Start;
+   const char *Stop;
+   if (Section.Find(pkgTagSection::Key::Status,Start,Stop) == false)
+      return true;
+
+   // UsePackage() is responsible for setting the flag in the default case
+   bool const static essential = _config->Find("pkgCacheGen::Essential", "") == "installed";
+   if (essential == true &&
+       Section.FindFlag(pkgTagSection::Key::Essential,Pkg->Flags,pkgCache::Flag::Essential) == false)
+      return false;
+
+   // Isolate the first word
+   const char *I = Start;
+   for(; I < Stop && *I != ' '; I++);
+   if (I >= Stop || *I != ' ')
+      return _error->Error("Malformed Status line");
+
+   // Process the want field
+   WordList WantList[] = {{"unknown",pkgCache::State::Unknown},
+                          {"install",pkgCache::State::Install},
+                          {"hold",pkgCache::State::Hold},
+                          {"deinstall",pkgCache::State::DeInstall},
+                          {"purge",pkgCache::State::Purge},
+                          {"", 0}};
+   if (GrabWord(StringView(Start,I-Start),WantList,Pkg->SelectedState) == false)
+      return _error->Error("Malformed 1st word in the Status line");
+
+   // Isloate the next word
+   I++;
+   Start = I;
+   for(; I < Stop && *I != ' '; I++);
+   if (I >= Stop || *I != ' ')
+      return _error->Error("Malformed status line, no 2nd word");
+
+   // Process the flag field
+   WordList FlagList[] = {{"ok",pkgCache::State::Ok},
+                          {"reinstreq",pkgCache::State::ReInstReq},
+                          {"hold",pkgCache::State::HoldInst},
+                          {"hold-reinstreq",pkgCache::State::HoldReInstReq},
+                          {"", 0}};
+   if (GrabWord(StringView(Start,I-Start),FlagList,Pkg->InstState) == false)
+      return _error->Error("Malformed 2nd word in the Status line");
+
+   // Isloate the last word
+   I++;
+   Start = I;
+   for(; I < Stop && *I != ' '; I++);
+   if (I != Stop)
+      return _error->Error("Malformed Status line, no 3rd word");
+
+   // Process the flag field
+   WordList StatusList[] = {{"not-installed",pkgCache::State::NotInstalled},
+                            {"config-files",pkgCache::State::ConfigFiles},
+                            {"half-installed",pkgCache::State::HalfInstalled},
+                            {"unpacked",pkgCache::State::UnPacked},
+                            {"half-configured",pkgCache::State::HalfConfigured},
+                            {"triggers-awaited",pkgCache::State::TriggersAwaited},
+                            {"triggers-pending",pkgCache::State::TriggersPending},
+                            {"installed",pkgCache::State::Installed},
+                            {"", 0}};
+   if (GrabWord(StringView(Start,I-Start),StatusList,Pkg->CurrentState) == false)
+      return _error->Error("Malformed 3rd word in the Status line");
+
+   /* A Status line marks the package as indicating the current
+      version as well. Only if it is actually installed.. Otherwise
+      the interesting dpkg handling of the status file creates bogus 
+      entries. */
+   if (!(Pkg->CurrentState == pkgCache::State::NotInstalled ||
+	 Pkg->CurrentState == pkgCache::State::ConfigFiles))
+   {
+      if (Ver.end() == true)
+	 _error->Warning("Encountered status field in a non-version description");
+      else
+	 Pkg->CurrentVer = Ver.MapPointer();
+   }
+   
+   return true;
+}
+
+const char *debListParser::ConvertRelation(const char *I,unsigned int &Op)
+{
+   // Determine the operator
+   switch (*I)
+   {
+      case '<':
+      I++;
+      if (*I == '=')
+      {
+	 I++;
+	 Op = pkgCache::Dep::LessEq;
+	 break;
+      }
+      
+      if (*I == '<')
+      {
+	 I++;
+	 Op = pkgCache::Dep::Less;
+	 break;
+      }
+      
+      // < is the same as <= and << is really Cs < for some reason
+      Op = pkgCache::Dep::LessEq;
+      break;
+      
+      case '>':
+      I++;
+      if (*I == '=')
+      {
+	 I++;
+	 Op = pkgCache::Dep::GreaterEq;
+	 break;
+      }
+      
+      if (*I == '>')
+      {
+	 I++;
+	 Op = pkgCache::Dep::Greater;
+	 break;
+      }
+      
+      // > is the same as >= and >> is really Cs > for some reason
+      Op = pkgCache::Dep::GreaterEq;
+      break;
+      
+      case '=':
+      Op = pkgCache::Dep::Equals;
+      I++;
+      break;
+      
+      // HACK around bad package definitions
+      default:
+      Op = pkgCache::Dep::Equals;
+      break;
+   }
+   return I;
+}
+									/*}}}*/
+// ListParser::ParseDepends - Parse a dependency element		/*{{{*/
+// ---------------------------------------------------------------------
+/* This parses the dependency elements out of a standard string in place,
+   bit by bit. */
+const char *debListParser::ParseDepends(const char *Start,const char *Stop,
+					string &Package,string &Ver,
+					unsigned int &Op, bool const &ParseArchFlags,
+					bool const &StripMultiArch,
+					bool const &ParseRestrictionsList,
+				        string const &Arch)
+{
+   StringView PackageView;
+   StringView VerView;
+
+   auto res = ParseDepends(Start, Stop, PackageView, VerView, Op, (bool)ParseArchFlags,
+   (bool) StripMultiArch, (bool) ParseRestrictionsList, Arch);
+   Package = PackageView.to_string();
+   Ver = VerView.to_string();
+
+   return res;
+}
+
+const char *debListParser::ParseDepends(const char *Start, const char *Stop,
+					StringView &Package, StringView &Ver,
+					unsigned int &Op, bool ParseArchFlags,
+					bool StripMultiArch,
+					bool ParseRestrictionsList, string Arch)
+{
+   if (Arch.empty())
+      Arch = _config->Find("APT::Architecture");
+   // Strip off leading space
+   for (;Start != Stop && isspace_ascii(*Start) != 0; ++Start);
+   
+   // Parse off the package name
+   const char *I = Start;
+   for (;I != Stop && isspace_ascii(*I) == 0 && *I != '(' && *I != ')' &&
+	*I != ',' && *I != '|' && *I != '[' && *I != ']' &&
+	*I != '<' && *I != '>'; ++I);
+   
+   // Malformed, no '('
+   if (I != Stop && *I == ')')
+      return 0;
+
+   if (I == Start)
+      return 0;
+   
+   // Stash the package name
+   Package = StringView(Start, I - Start);
+
+   // We don't want to confuse library users which can't handle MultiArch
+   if (StripMultiArch == true) {
+      size_t const found = Package.rfind(':');
+      if (found != StringView::npos &&
+	  (Package.substr(found) == ":any" ||
+	   Package.substr(found) == ":native" ||
+	   Package.substr(found +1) == Arch))
+	 Package = Package.substr(0,found);
+   }
+
+   // Skip white space to the '('
+   for (;I != Stop && isspace_ascii(*I) != 0 ; I++);
+   
+   // Parse a version
+   if (I != Stop && *I == '(')
+   {
+      // Skip the '('
+      for (I++; I != Stop && isspace_ascii(*I) != 0 ; I++);
+      if (I + 3 >= Stop)
+	 return 0;
+      I = ConvertRelation(I,Op);
+      
+      // Skip whitespace
+      for (;I != Stop && isspace_ascii(*I) != 0; I++);
+      Start = I;
+      I = (const char*) memchr(I, ')', Stop - I);
+      if (I == NULL || Start == I)
+	 return 0;
+      
+      // Skip trailing whitespace
+      const char *End = I;
+      for (; End > Start && isspace_ascii(End[-1]); End--);
+      
+      Ver = StringView(Start,End-Start);
+      I++;
+   }
+   else
+   {
+      Ver = StringView();
+      Op = pkgCache::Dep::NoOp;
+   }
+   
+   // Skip whitespace
+   for (;I != Stop && isspace_ascii(*I) != 0; I++);
+
+   if (unlikely(ParseArchFlags == true))
+   {
+      APT::CacheFilter::PackageArchitectureMatchesSpecification matchesArch(Arch, false);
+
+      // Parse an architecture
+      if (I != Stop && *I == '[')
+      {
+	 ++I;
+	 // malformed
+	 if (unlikely(I == Stop))
+	    return 0;
+
+	 const char *End = I;
+	 bool Found = false;
+	 bool NegArch = false;
+	 while (I != Stop)
+	 {
+	    // look for whitespace or ending ']'
+	    for (;End != Stop && !isspace_ascii(*End) && *End != ']'; ++End);
+
+	    if (unlikely(End == Stop))
+	       return 0;
+
+	    if (*I == '!')
+	    {
+	       NegArch = true;
+	       ++I;
+	    }
+
+	    std::string const arch(I, End);
+	    if (arch.empty() == false && matchesArch(arch.c_str()) == true)
+	    {
+	       Found = true;
+	       if (I[-1] != '!')
+		  NegArch = false;
+	       // we found a match, so fast-forward to the end of the wildcards
+	       for (; End != Stop && *End != ']'; ++End);
+	    }
+
+	    if (*End++ == ']') {
+	       I = End;
+	       break;
+	    }
+
+	    I = End;
+	    for (;I != Stop && isspace_ascii(*I) != 0; I++);
+	 }
+
+	 if (NegArch == true)
+	    Found = !Found;
+
+	 if (Found == false)
+	    Package = ""; /* not for this arch */
+      }
+
+      // Skip whitespace
+      for (;I != Stop && isspace_ascii(*I) != 0; I++);
+   }
+
+   if (unlikely(ParseRestrictionsList == true))
+   {
+      // Parse a restrictions formula which is in disjunctive normal form:
+      // (foo AND bar) OR (blub AND bla)
+
+      std::vector<string> const profiles = APT::Configuration::getBuildProfiles();
+
+      // if the next character is a restriction list, then by default the
+      // dependency does not apply and the conditions have to be checked
+      // if the next character is not a restriction list, then by default the
+      // dependency applies
+      bool applies1 = (*I != '<');
+      while (I != Stop)
+      {
+	 if (*I != '<')
+	     break;
+
+	 ++I;
+	 // malformed
+	 if (unlikely(I == Stop))
+	    return 0;
+
+	 const char *End = I;
+
+	 // if of the prior restriction list is already fulfilled, then
+	 // we can just skip to the end of the current list
+	 if (applies1) {
+	    for (;End != Stop && *End != '>'; ++End);
+	    I = ++End;
+	    // skip whitespace
+	    for (;I != Stop && isspace_ascii(*I) != 0; I++);
+	 } else {
+	    bool applies2 = true;
+	    // all the conditions inside a restriction list have to be
+	    // met so once we find one that is not met, we can skip to
+	    // the end of this list
+	    while (I != Stop)
+	    {
+	       // look for whitespace or ending '>'
+	       // End now points to the character after the current term
+	       for (;End != Stop && !isspace_ascii(*End) && *End != '>'; ++End);
+
+	       if (unlikely(End == Stop))
+		  return 0;
+
+	       bool NegRestriction = false;
+	       if (*I == '!')
+	       {
+		  NegRestriction = true;
+		  ++I;
+	       }
+
+	       std::string const restriction(I, End);
+	       if (restriction.empty() == false && profiles.empty() == false &&
+		  std::find(profiles.begin(), profiles.end(), restriction) != profiles.end())
+	       {
+		  if (NegRestriction) {
+		     applies2 = false;
+		     // since one of the terms does not apply we don't have to check the others
+		     for (; End != Stop && *End != '>'; ++End);
+		  }
+	       } else {
+		  if (!NegRestriction) {
+		     applies2 = false;
+		     // since one of the terms does not apply we don't have to check the others
+		     for (; End != Stop && *End != '>'; ++End);
+		  }
+	       }
+
+	       if (*End++ == '>') {
+		  I = End;
+		  // skip whitespace
+		  for (;I != Stop && isspace_ascii(*I) != 0; I++);
+		  break;
+	       }
+
+	       I = End;
+	       // skip whitespace
+	       for (;I != Stop && isspace_ascii(*I) != 0; I++);
+	    }
+	    if (applies2) {
+	       applies1 = true;
+	    }
+	 }
+      }
+
+      if (applies1 == false) {
+	 Package = ""; //not for this restriction
+      }
+   }
+
+   if (I != Stop && *I == '|')
+      Op |= pkgCache::Dep::Or;
+   
+   if (I == Stop || *I == ',' || *I == '|')
+   {
+      if (I != Stop)
+	 for (I++; I != Stop && isspace_ascii(*I) != 0; I++);
+      return I;
+   }
+   
+   return 0;
+}
+									/*}}}*/
+// ListParser::ParseDepends - Parse a dependency list			/*{{{*/
+// ---------------------------------------------------------------------
+/* This is the higher level depends parser. It takes a tag and generates
+   a complete depends tree for the given version. */
+bool debListParser::ParseDepends(pkgCache::VerIterator &Ver,
+				 pkgTagSection::Key Key,unsigned int Type)
+{
+   const char *Start;
+   const char *Stop;
+   if (Section.Find(Key,Start,Stop) == false || Start == Stop)
+      return true;
+
+   string const pkgArch = Ver.Arch();
+
+   while (1)
+   {
+      StringView Package;
+      StringView Version;
+      unsigned int Op;
+
+      Start = ParseDepends(Start, Stop, Package, Version, Op, false, false, false, myArch);
+      if (Start == 0)
+	 return _error->Error("Problem parsing dependency %zu of %s:%s=%s", static_cast<size_t>(Key), // TODO
+			      Ver.ParentPkg().Name(), Ver.Arch(), Ver.VerStr());
+      size_t const found = Package.rfind(':');
+
+      if (found == string::npos)
+      {
+	 if (NewDepends(Ver,Package,pkgArch,Version,Op,Type) == false)
+	    return false;
+      }
+      else if (Package.substr(found) == ":any")
+      {
+	 if (NewDepends(Ver,Package,"any",Version,Op,Type) == false)
+	    return false;
+      }
+      else
+      {
+	 // Such dependencies are not supposed to be accepted …
+	 // … but this is probably the best thing to do anyway
+	 if (Package.substr(found + 1) == "native")
+	 {
+	    std::string const Pkg = Package.substr(0, found).to_string() + ':' + Ver.Cache()->NativeArch();
+	    if (NewDepends(Ver, Pkg, "any", Version, Op | pkgCache::Dep::ArchSpecific, Type) == false)
+	       return false;
+	 }
+	 else if (NewDepends(Ver, Package, "any", Version, Op | pkgCache::Dep::ArchSpecific, Type) == false)
+	    return false;
+      }
+
+      if (Start == Stop)
+	 break;
+   }
+   return true;
+}
+									/*}}}*/
+// ListParser::ParseProvides - Parse the provides list			/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool debListParser::ParseProvides(pkgCache::VerIterator &Ver)
+{
+   /* it is unlikely, but while parsing dependencies, we might have already
+      picked up multi-arch implicit provides which we do not want to duplicate here */
+   bool hasProvidesAlready = false;
+   std::string const spzName = Ver.ParentPkg().FullName(false);
+   {
+      for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
+      {
+	 if (Prv.IsMultiArchImplicit() == false || (Prv->Flags & pkgCache::Flag::ArchSpecific) == 0)
+	    continue;
+	 if (spzName != Prv.OwnerPkg().FullName(false))
+	    continue;
+	 hasProvidesAlready = true;
+	 break;
+      }
+   }
+
+   string const Arch = Ver.Arch();
+   const char *Start;
+   const char *Stop;
+   if (Section.Find(pkgTagSection::Key::Provides,Start,Stop) == true)
+   {
+      StringView Package;
+      StringView Version;
+      unsigned int Op;
+
+      do
+      {
+	 Start = ParseDepends(Start,Stop,Package,Version,Op, false, false, false);
+	 const size_t archfound = Package.rfind(':');
+	 if (Start == 0)
+	    return _error->Error("Problem parsing Provides line of %s:%s=%s", Ver.ParentPkg().Name(), Ver.Arch(), Ver.VerStr());
+	 if (unlikely(Op != pkgCache::Dep::NoOp && Op != pkgCache::Dep::Equals)) {
+	    _error->Warning("Ignoring non-equal Provides for package %s in %s:%s=%s", Package.to_string().c_str(), Ver.ParentPkg().Name(), Ver.Arch(), Ver.VerStr());
+	 } else if (archfound != string::npos) {
+	    StringView spzArch = Package.substr(archfound + 1);
+	    if (spzArch != "any")
+	    {
+	       if (NewProvides(Ver, Package.substr(0, archfound), spzArch, Version, pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false)
+		  return false;
+	    }
+	    if (NewProvides(Ver, Package, "any", Version, pkgCache::Flag::ArchSpecific) == false)
+	       return false;
+	 } else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign) {
+	    if (APT::Configuration::checkArchitecture(Arch))
+	    {
+	       if (NewProvidesAllArch(Ver, Package, Version, 0) == false)
+		  return false;
+	    }
+	    else if (NewProvides(Ver, Package, Arch, Version, 0) == false)
+	       return false;
+	 } else {
+	    if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
+	    {
+	       if (NewProvides(Ver, Package.to_string().append(":any"), "any", Version, pkgCache::Flag::MultiArchImplicit) == false)
+		  return false;
+	    }
+	    if (NewProvides(Ver, Package, Arch, Version, 0) == false)
+	       return false;
+	 }
+	 if (archfound == std::string::npos)
+	 {
+	    string spzName = Package.to_string();
+	    spzName.push_back(':');
+	    spzName.append(Ver.ParentPkg().Arch());
+	    pkgCache::PkgIterator const spzPkg = Ver.Cache()->FindPkg(spzName, "any");
+	    if (spzPkg.end() == false)
+	    {
+	       if (NewProvides(Ver, spzName, "any", Version, pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false)
+		  return false;
+	    }
+	 }
+      } while (Start != Stop);
+   }
+
+   if (APT::Configuration::checkArchitecture(Arch))
+   {
+      if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
+      {
+	 string const Package = string(Ver.ParentPkg().Name()).append(":").append("any");
+	 if (NewProvides(Ver, Package, "any", Ver.VerStr(), pkgCache::Flag::MultiArchImplicit) == false)
+	    return false;
+      }
+      else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
+      {
+	 if (NewProvidesAllArch(Ver, Ver.ParentPkg().Name(), Ver.VerStr(), pkgCache::Flag::MultiArchImplicit) == false)
+	    return false;
+      }
+   }
+
+   if (hasProvidesAlready == false)
+   {
+      pkgCache::PkgIterator const spzPkg = Ver.Cache()->FindPkg(spzName, "any");
+      if (spzPkg.end() == false)
+      {
+	 if (NewProvides(Ver, spzName, "any", Ver.VerStr(), pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false)
+	    return false;
+      }
+   }
+   return true;
+}
+									/*}}}*/
+// ListParser::GrabWord - Matches a word and returns			/*{{{*/
+// ---------------------------------------------------------------------
+/* Looks for a word in a list of words - for ParseStatus */
+bool debListParser::GrabWord(StringView Word, WordList const *List, unsigned char &Out)
+{
+   for (unsigned int C = 0; List[C].Str.empty() == false; C++)
+   {
+      if (Word.length() == List[C].Str.length() &&
+	  strncasecmp(Word.data(), List[C].Str.data(), Word.length()) == 0)
+      {
+	 Out = List[C].Val;
+	 return true;
+      }
+   }
+   return false;
+}
+									/*}}}*/
+// ListParser::Step - Move to the next section in the file		/*{{{*/
+// ---------------------------------------------------------------------
+/* This has to be careful to only process the correct architecture */
+bool debListParser::Step()
+{
+   iOffset = Tags.Offset();
+   return Tags.Step(Section);
+}
+									/*}}}*/
+// ListParser::GetPrio - Convert the priority from a string		/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+unsigned char debListParser::GetPrio(string Str)
+{
+   unsigned char Out;
+   if (GrabWord(Str,PrioList,Out) == false)
+      Out = pkgCache::State::Extra;
+   
+   return Out;
+}
+									/*}}}*/
+bool debListParser::SameVersion(uint32_t Hash,		/*{{{*/
+      pkgCache::VerIterator const &Ver)
+{
+   if (pkgCacheListParser::SameVersion(Hash, Ver) == false)
+      return false;
+   // status file has no (Download)Size, but all others are fair game
+   // status file is parsed last, so the first version we encounter is
+   // probably also the version we have downloaded
+   unsigned long long const Size = Section.FindULL(pkgTagSection::Key::Size);
+   if (Size != 0 && Ver->Size != 0 && Size != Ver->Size)
+      return false;
+   // available everywhere, but easier to check here than to include in VersionHash
+   unsigned char MultiArch = ParseMultiArch(false);
+   if (MultiArch != Ver->MultiArch)
+      return false;
+   // for all practical proposes (we can check): same version
+   return true;
+}
+									/*}}}*/
+
+debDebFileParser::debDebFileParser(FileFd *File, std::string const &DebFile)
+   : debListParser(File), DebFile(DebFile)
+{
+}
+
+bool debDebFileParser::UsePackage(pkgCache::PkgIterator &Pkg,
+                                  pkgCache::VerIterator &Ver)
+{
+   if (not debListParser::UsePackage(Pkg, Ver))
+      return false;
+   // we use the full file path as a provides so that the file is found by its name
+   // using the MultiArchImplicit flag for this is a bit of a stretch
+   return NewProvides(Ver, DebFile, Pkg.Cache()->NativeArch(), Ver.VerStr(), pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific);
+}
+
+debListParser::~debListParser() {}
diff --git a/apt-pkg/deb/deblistparser.h b/apt-pkg/deb/deblistparser.h
new file mode 100644
index 0000000..eefce2a
--- /dev/null
+++ b/apt-pkg/deb/deblistparser.h
@@ -0,0 +1,124 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+   
+   Debian Package List Parser - This implements the abstract parser 
+   interface for Debian package files
+   
+   ##################################################################### */
+									/*}}}*/
+#ifndef PKGLIB_DEBLISTPARSER_H
+#define PKGLIB_DEBLISTPARSER_H
+
+#include <apt-pkg/macros.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/pkgcachegen.h>
+#include <apt-pkg/tagfile.h>
+
+#include <string>
+#include <vector>
+#include <apt-pkg/string_view.h>
+
+
+class FileFd;
+
+class APT_HIDDEN debListParser : public pkgCacheListParser
+{
+   public:
+
+   // Parser Helper
+   struct WordList
+   {
+      APT::StringView Str;
+      unsigned char Val;
+   };
+
+   private:
+   std::vector<std::string> forceEssential;
+   std::vector<std::string> forceImportant;
+   std::string MD5Buffer;
+   std::string myArch;
+
+   protected:
+   pkgTagFile Tags;
+   pkgTagSection Section;
+   map_filesize_t iOffset;
+
+   virtual bool ParseStatus(pkgCache::PkgIterator &Pkg,pkgCache::VerIterator &Ver);
+   bool ParseDepends(pkgCache::VerIterator &Ver, pkgTagSection::Key Key,
+		     unsigned int Type);
+   bool ParseProvides(pkgCache::VerIterator &Ver);
+
+   APT_HIDDEN static bool GrabWord(APT::StringView Word,const WordList *List,unsigned char &Out);
+   APT_HIDDEN unsigned char ParseMultiArch(bool const showErrors);
+
+   public:
+
+   APT_PUBLIC static unsigned char GetPrio(std::string Str);
+      
+   // These all operate against the current section
+   virtual std::string Package() APT_OVERRIDE;
+   virtual bool ArchitectureAll() APT_OVERRIDE;
+   virtual APT::StringView Architecture() APT_OVERRIDE;
+   virtual APT::StringView Version() APT_OVERRIDE;
+   virtual bool NewVersion(pkgCache::VerIterator &Ver) APT_OVERRIDE;
+   virtual std::vector<std::string> AvailableDescriptionLanguages() APT_OVERRIDE;
+   virtual APT::StringView Description_md5() APT_OVERRIDE;
+   virtual uint32_t VersionHash() APT_OVERRIDE;
+   virtual bool SameVersion(uint32_t Hash, pkgCache::VerIterator const &Ver) APT_OVERRIDE;
+   virtual bool UsePackage(pkgCache::PkgIterator &Pkg,
+			   pkgCache::VerIterator &Ver) APT_OVERRIDE;
+   virtual map_filesize_t Offset() APT_OVERRIDE {return iOffset;};
+   virtual map_filesize_t Size() APT_OVERRIDE {return Section.size();};
+
+   virtual bool Step() APT_OVERRIDE;
+
+   APT_PUBLIC static const char *ParseDepends(const char *Start, const char *Stop,
+					      std::string &Package, std::string &Ver, unsigned int &Op,
+					      bool const &ParseArchFlags = false, bool const &StripMultiArch = true,
+					      bool const &ParseRestrictionsList = false,
+					      std::string const &Arch = "");
+
+   APT_PUBLIC static const char *ParseDepends(const char *Start, const char *Stop,
+					      APT::StringView &Package,
+					      APT::StringView &Ver, unsigned int &Op,
+					      bool const ParseArchFlags = false, bool StripMultiArch = true,
+					      bool const ParseRestrictionsList = false,
+					      std::string Arch = "");
+
+   APT_PUBLIC static const char *ConvertRelation(const char *I,unsigned int &Op);
+
+   explicit debListParser(FileFd *File);
+   virtual ~debListParser();
+};
+
+class APT_HIDDEN debDebFileParser : public debListParser
+{
+ private:
+   std::string DebFile;
+
+ public:
+   debDebFileParser(FileFd *File, std::string const &DebFile);
+   virtual bool UsePackage(pkgCache::PkgIterator &Pkg,
+			   pkgCache::VerIterator &Ver) APT_OVERRIDE;
+};
+
+class APT_HIDDEN debTranslationsParser : public debListParser
+{
+ public:
+   // a translation can never be a real package
+   virtual APT::StringView Architecture() APT_OVERRIDE { return ""; }
+   virtual APT::StringView Version() APT_OVERRIDE { return ""; }
+
+   explicit debTranslationsParser(FileFd *File)
+      : debListParser(File) {};
+};
+
+class APT_HIDDEN debStatusListParser : public debListParser
+{
+ public:
+   virtual bool ParseStatus(pkgCache::PkgIterator &Pkg,pkgCache::VerIterator &Ver) APT_OVERRIDE;
+   explicit debStatusListParser(FileFd *File)
+      : debListParser(File) {};
+};
+#endif
diff --git a/apt-pkg/deb/debmetaindex.cc b/apt-pkg/deb/debmetaindex.cc
new file mode 100644
index 0000000..f24a5e7
--- /dev/null
+++ b/apt-pkg/deb/debmetaindex.cc
@@ -0,0 +1,1319 @@
+#include <config.h>
+
+#include <apt-pkg/acquire-item.h>
+#include <apt-pkg/aptconfiguration.h>
+#include <apt-pkg/configuration.h>
+#include <apt-pkg/debindexfile.h>
+#include <apt-pkg/debmetaindex.h>
+#include <apt-pkg/error.h>
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/gpgv.h>
+#include <apt-pkg/hashes.h>
+#include <apt-pkg/macros.h>
+#include <apt-pkg/metaindex.h>
+#include <apt-pkg/pkgcachegen.h>
+#include <apt-pkg/sourcelist.h>
+#include <apt-pkg/strutl.h>
+#include <apt-pkg/tagfile.h>
+
+#include <algorithm>
+#include <map>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <string.h>
+#include <sys/stat.h>
+
+#include <apti18n.h>
+
+static std::string transformFingergrpints(std::string finger) /*{{{*/
+{
+   std::transform(finger.begin(), finger.end(), finger.begin(), ::toupper);
+   if (finger.length() == 40)
+   {
+      if (finger.find_first_not_of("0123456789ABCDEF") == std::string::npos)
+	 return finger;
+   }
+   else if (finger.length() == 41)
+   {
+      auto bang = finger.find_first_not_of("0123456789ABCDEF");
+      if (bang == 40 && finger[bang] == '!')
+	 return finger;
+   }
+   return "";
+}
+									/*}}}*/
+static std::string transformFingergrpintsWithFilenames(std::string const &finger) /*{{{*/
+{
+   // no check for existence as we could be chrooting later or such things
+   if (finger.empty() == false && finger[0] == '/')
+      return finger;
+   return transformFingergrpints(finger);
+}
+									/*}}}*/
+static std::string NormalizeSignedBy(std::string SignedBy, bool const SupportFilenames) /*{{{*/
+{
+   // we could go all fancy and allow short/long/string matches as gpgv/apt-key does,
+   // but fingerprints are harder to fake than the others and this option is set once,
+   // not interactively all the time so easy to type is not really a concern.
+   std::transform(SignedBy.begin(), SignedBy.end(), SignedBy.begin(), [](char const c) {
+      return (isspace_ascii(c) == 0) ? c : ',';
+   });
+   auto fingers = VectorizeString(SignedBy, ',');
+   auto const isAnEmptyString = [](std::string const &s) { return s.empty(); };
+   fingers.erase(std::remove_if(fingers.begin(), fingers.end(), isAnEmptyString), fingers.end());
+   if (unlikely(fingers.empty()))
+      return "";
+   if (SupportFilenames)
+      std::transform(fingers.begin(), fingers.end(), fingers.begin(), transformFingergrpintsWithFilenames);
+   else
+      std::transform(fingers.begin(), fingers.end(), fingers.begin(), transformFingergrpints);
+   if (std::any_of(fingers.begin(), fingers.end(), isAnEmptyString))
+      return "";
+   std::stringstream os;
+   std::copy(fingers.begin(), fingers.end() - 1, std::ostream_iterator<std::string>(os, ","));
+   os << *fingers.rbegin();
+   return os.str();
+}
+									/*}}}*/
+
+class APT_HIDDEN debReleaseIndexPrivate					/*{{{*/
+{
+   public:
+   struct APT_HIDDEN debSectionEntry
+   {
+      std::string const sourcesEntry;
+      std::string const Name;
+      std::vector<std::string> const Targets;
+      std::vector<std::string> const Architectures;
+      std::vector<std::string> const Languages;
+      bool const UsePDiffs;
+      std::string const UseByHash;
+   };
+
+   std::vector<debSectionEntry> DebEntries;
+   std::vector<debSectionEntry> DebSrcEntries;
+
+   metaIndex::TriState CheckValidUntil;
+   time_t ValidUntilMin;
+   time_t ValidUntilMax;
+
+   metaIndex::TriState CheckDate;
+   time_t DateMaxFuture;
+   time_t NotBefore;
+
+   std::vector<std::string> Architectures;
+   std::vector<std::string> NoSupportForAll;
+   std::vector<std::string> SupportedComponents;
+   std::map<std::string, std::string> const ReleaseOptions;
+
+   explicit debReleaseIndexPrivate(std::map<std::string, std::string> const &Options) : CheckValidUntil(metaIndex::TRI_UNSET), ValidUntilMin(0), ValidUntilMax(0), CheckDate(metaIndex::TRI_UNSET), DateMaxFuture(0), NotBefore(0), ReleaseOptions(Options) {}
+};
+									/*}}}*/
+// ReleaseIndex::MetaIndex* - display helpers				/*{{{*/
+std::string debReleaseIndex::MetaIndexInfo(const char *Type) const
+{
+   std::string Info = ::URI::ArchiveOnly(URI) + ' ';
+   if (Dist[Dist.size() - 1] == '/')
+   {
+      if (Dist != "/")
+	 Info += Dist;
+   }
+   else
+      Info += Dist;
+   Info += " ";
+   Info += Type;
+   return Info;
+}
+std::string debReleaseIndex::Describe() const
+{
+   return MetaIndexInfo("Release");
+}
+
+std::string debReleaseIndex::MetaIndexFile(const char *Type) const
+{
+   return _config->FindDir("Dir::State::lists") +
+      URItoFileName(MetaIndexURI(Type));
+}
+static std::string constructMetaIndexURI(std::string URI, std::string const &Dist, char const * const Type)
+{
+   if (Dist == "/")
+      ;
+   else if (Dist[Dist.size()-1] == '/')
+      URI += pkgAcquire::URIEncode(Dist);
+   else
+      URI += "dists/" + pkgAcquire::URIEncode(Dist) + "/";
+   return URI + pkgAcquire::URIEncode(Type);
+}
+std::string debReleaseIndex::MetaIndexURI(const char *Type) const
+{
+   return constructMetaIndexURI(URI, Dist, Type);
+}
+									/*}}}*/
+// ReleaseIndex Con- and Destructors					/*{{{*/
+debReleaseIndex::debReleaseIndex(std::string const &URI, std::string const &Dist, std::map<std::string, std::string> const &Options) :
+					metaIndex(URI, Dist, "deb"), d(new debReleaseIndexPrivate(Options))
+{}
+debReleaseIndex::debReleaseIndex(std::string const &URI, std::string const &Dist, bool const pTrusted, std::map<std::string, std::string> const &Options) :
+					metaIndex(URI, Dist, "deb"), d(new debReleaseIndexPrivate(Options))
+{
+   Trusted = pTrusted ? TRI_YES : TRI_NO;
+}
+debReleaseIndex::~debReleaseIndex() {
+   if (d != NULL)
+      delete d;
+}
+									/*}}}*/
+// ReleaseIndex::GetIndexTargets					/*{{{*/
+static void GetIndexTargetsFor(char const * const Type, std::string const &URI, std::string const &Dist,
+      std::vector<debReleaseIndexPrivate::debSectionEntry> const &entries,
+      std::vector<IndexTarget> &IndexTargets, std::map<std::string, std::string> const &ReleaseOptions)
+{
+   bool const flatArchive = (Dist[Dist.length() - 1] == '/');
+   std::string const baseURI = constructMetaIndexURI(URI, Dist, "");
+
+   std::string DefCompressionTypes;
+   {
+      std::vector<std::string> types = APT::Configuration::getCompressionTypes();
+      if (types.empty() == false)
+      {
+	 std::ostringstream os;
+	 std::copy(types.begin(), types.end()-1, std::ostream_iterator<std::string>(os, " "));
+	 os << *types.rbegin();
+	 DefCompressionTypes = os.str();
+      }
+   }
+   std::string DefKeepCompressedAs;
+   {
+      std::vector<APT::Configuration::Compressor> comps = APT::Configuration::getCompressors();
+      if (comps.empty() == false)
+      {
+	 std::sort(comps.begin(), comps.end(),
+	       [](APT::Configuration::Compressor const &a, APT::Configuration::Compressor const &b) { return a.Cost < b.Cost; });
+	 std::ostringstream os;
+	 for (auto const &c : comps)
+	    if (c.Cost != 0)
+	       os << c.Extension.substr(1) << ' ';
+	 DefKeepCompressedAs = os.str();
+      }
+      DefKeepCompressedAs += "uncompressed";
+   }
+
+   std::vector<std::string> const NativeArchs = { _config->Find("APT::Architecture"), "implicit:all" };
+   bool const GzipIndex = _config->FindB("Acquire::GzipIndexes", false);
+   for (std::vector<debReleaseIndexPrivate::debSectionEntry>::const_iterator E = entries.begin(); E != entries.end(); ++E)
+   {
+      for (std::vector<std::string>::const_iterator T = E->Targets.begin(); T != E->Targets.end(); ++T)
+      {
+#define APT_T_CONFIG_STR(X, Y) _config->Find(std::string("Acquire::IndexTargets::") + Type  + "::" + *T + "::" + (X), (Y))
+#define APT_T_CONFIG_BOOL(X, Y) _config->FindB(std::string("Acquire::IndexTargets::") + Type  + "::" + *T + "::" + (X), (Y))
+	 std::string const tplMetaKey = APT_T_CONFIG_STR(flatArchive ? "flatMetaKey" : "MetaKey", "");
+	 std::string const tplShortDesc = APT_T_CONFIG_STR("ShortDescription", "");
+	 std::string const tplLongDesc = "$(SITE) " + APT_T_CONFIG_STR(flatArchive ? "flatDescription" : "Description", "");
+	 std::string const tplIdentifier = APT_T_CONFIG_STR("Identifier", *T);
+	 bool const IsOptional = APT_T_CONFIG_BOOL("Optional", true);
+	 bool const KeepCompressed = APT_T_CONFIG_BOOL("KeepCompressed", GzipIndex);
+	 bool const DefaultEnabled = APT_T_CONFIG_BOOL("DefaultEnabled", true);
+	 bool const UsePDiffs = APT_T_CONFIG_BOOL("PDiffs", E->UsePDiffs);
+	 std::string const UseByHash = APT_T_CONFIG_STR("By-Hash", E->UseByHash);
+	 std::string const CompressionTypes = APT_T_CONFIG_STR("CompressionTypes", DefCompressionTypes);
+	 std::string KeepCompressedAs = APT_T_CONFIG_STR("KeepCompressedAs", "");
+	 std::string const FallbackOf = APT_T_CONFIG_STR("Fallback-Of", "");
+#undef APT_T_CONFIG_BOOL
+#undef APT_T_CONFIG_STR
+	 if (tplMetaKey.empty())
+	    continue;
+
+	 if (KeepCompressedAs.empty())
+	    KeepCompressedAs = DefKeepCompressedAs;
+	 else
+	 {
+	    std::vector<std::string> const defKeep = VectorizeString(DefKeepCompressedAs, ' ');
+	    std::vector<std::string> const valKeep = VectorizeString(KeepCompressedAs, ' ');
+	    std::vector<std::string> keep;
+	    for (auto const &val : valKeep)
+	    {
+	       if (val.empty())
+		  continue;
+	       if (std::find(defKeep.begin(), defKeep.end(), val) == defKeep.end())
+		  continue;
+	       keep.push_back(val);
+	    }
+	    if (std::find(keep.begin(), keep.end(), "uncompressed") == keep.end())
+	       keep.push_back("uncompressed");
+	    std::ostringstream os;
+	    std::copy(keep.begin(), keep.end()-1, std::ostream_iterator<std::string>(os, " "));
+	    os << *keep.rbegin();
+	    KeepCompressedAs = os.str();
+	 }
+
+	 for (std::vector<std::string>::const_iterator L = E->Languages.begin(); L != E->Languages.end(); ++L)
+	 {
+	    if (*L == "none" && tplMetaKey.find("$(LANGUAGE)") != std::string::npos)
+	       continue;
+
+	    for (std::vector<std::string>::const_iterator A = E->Architectures.begin(); A != E->Architectures.end(); ++A)
+	    {
+	       for (auto const &NativeArch: NativeArchs)
+	       {
+		  constexpr static auto BreakPoint = "$(NATIVE_ARCHITECTURE)";
+		  // available in templates
+		  std::map<std::string, std::string> Options;
+		  Options.insert(ReleaseOptions.begin(), ReleaseOptions.end());
+		  if (tplMetaKey.find("$(COMPONENT)") != std::string::npos)
+		     Options.emplace("COMPONENT", E->Name);
+		  if (tplMetaKey.find("$(LANGUAGE)") != std::string::npos)
+		     Options.emplace("LANGUAGE", *L);
+		  if (tplMetaKey.find("$(ARCHITECTURE)") != std::string::npos)
+		     Options.emplace("ARCHITECTURE", (*A == "implicit:all") ? "all" : *A);
+		  else if (tplMetaKey.find("$(NATIVE_ARCHITECTURE)") != std::string::npos)
+		     Options.emplace("ARCHITECTURE", (NativeArch == "implicit:all") ? "all" : NativeArch);
+		  if (tplMetaKey.find("$(NATIVE_ARCHITECTURE)") != std::string::npos)
+		     Options.emplace("NATIVE_ARCHITECTURE", (NativeArch == "implicit:all") ? "all" : NativeArch);
+
+		  std::string MetaKey = tplMetaKey;
+		  std::string ShortDesc = tplShortDesc;
+		  std::string LongDesc = tplLongDesc;
+		  std::string Identifier = tplIdentifier;
+		  for (std::map<std::string, std::string>::const_iterator O = Options.begin(); O != Options.end(); ++O)
+		  {
+		     std::string const varname = "$(" + O->first + ")";
+		     MetaKey = SubstVar(MetaKey, varname, O->second);
+		     ShortDesc = SubstVar(ShortDesc, varname, O->second);
+		     LongDesc = SubstVar(LongDesc, varname, O->second);
+		     Identifier = SubstVar(Identifier, varname, O->second);
+		  }
+
+		  {
+		     auto const dup = std::find_if(IndexTargets.begin(), IndexTargets.end(), [&](IndexTarget const &IT) {
+			return MetaKey == IT.MetaKey && baseURI == IT.Option(IndexTarget::BASE_URI) &&
+			   E->sourcesEntry == IT.Option(IndexTarget::SOURCESENTRY) && *T == IT.Option(IndexTarget::CREATED_BY);
+		     });
+		     if (dup != IndexTargets.end())
+		     {
+			if (tplMetaKey.find(BreakPoint) == std::string::npos)
+			   break;
+			continue;
+		     }
+		  }
+
+		  {
+		     auto const dup = std::find_if(IndexTargets.begin(), IndexTargets.end(), [&](IndexTarget const &IT) {
+			return MetaKey == IT.MetaKey && baseURI == IT.Option(IndexTarget::BASE_URI) &&
+			   E->sourcesEntry == IT.Option(IndexTarget::SOURCESENTRY) && *T != IT.Option(IndexTarget::CREATED_BY);
+			});
+		     if (dup != IndexTargets.end())
+		     {
+			std::string const dupT = dup->Option(IndexTarget::CREATED_BY);
+			std::string const dupEntry = dup->Option(IndexTarget::SOURCESENTRY);
+			//TRANSLATOR: an identifier like Packages; Releasefile key indicating
+			// a file like main/binary-amd64/Packages; another identifier like Contents;
+			// filename and linenumber of the sources.list entry currently parsed
+			_error->Warning(_("Target %s wants to acquire the same file (%s) as %s from source %s"),
+			      T->c_str(), MetaKey.c_str(), dupT.c_str(), dupEntry.c_str());
+			if (tplMetaKey.find(BreakPoint) == std::string::npos)
+			   break;
+			continue;
+		     }
+		  }
+
+		  {
+		     auto const dup = std::find_if(IndexTargets.begin(), IndexTargets.end(), [&](IndexTarget const &T) {
+			return MetaKey == T.MetaKey && baseURI == T.Option(IndexTarget::BASE_URI) &&
+			   E->sourcesEntry != T.Option(IndexTarget::SOURCESENTRY);
+		     });
+		     if (dup != IndexTargets.end())
+		     {
+			std::string const dupEntry = dup->Option(IndexTarget::SOURCESENTRY);
+			if (T->find("legacy") == std::string::npos)
+			{
+			   //TRANSLATOR: an identifier like Packages; Releasefile key indicating
+			   // a file like main/binary-amd64/Packages; filename and linenumber of
+			   // two sources.list entries
+			   _error->Warning(_("Target %s (%s) is configured multiple times in %s and %s"),
+					   T->c_str(), MetaKey.c_str(), dupEntry.c_str(), E->sourcesEntry.c_str());
+			}
+			if (tplMetaKey.find(BreakPoint) == std::string::npos)
+			   break;
+			continue;
+		     }
+		  }
+
+		  // not available in templates, but in the indextarget
+		  Options.insert(std::make_pair("IDENTIFIER", Identifier));
+		  Options.insert(std::make_pair("TARGET_OF", Type));
+		  Options.insert(std::make_pair("CREATED_BY", *T));
+		  Options.insert(std::make_pair("FALLBACK_OF", FallbackOf));
+		  Options.insert(std::make_pair("PDIFFS", UsePDiffs ? "yes" : "no"));
+		  Options.insert(std::make_pair("BY_HASH", UseByHash));
+		  Options.insert(std::make_pair("DEFAULTENABLED", DefaultEnabled ? "yes" : "no"));
+		  Options.insert(std::make_pair("COMPRESSIONTYPES", CompressionTypes));
+		  Options.insert(std::make_pair("KEEPCOMPRESSEDAS", KeepCompressedAs));
+		  Options.insert(std::make_pair("SOURCESENTRY", E->sourcesEntry));
+
+		  bool IsOpt = IsOptional;
+		  {
+		     auto const arch = Options.find("ARCHITECTURE");
+		     if (arch != Options.end() && arch->second == "all")
+		     {
+			// one of them must be implicit:all then
+			if (*A != "all" && NativeArch != "all")
+			   IsOpt = true;
+			else // user used arch=all explicitly
+			   Options.emplace("Force-Support-For-All", "yes");
+		     }
+		  }
+
+		  IndexTarget Target(
+			MetaKey,
+			ShortDesc,
+			LongDesc,
+			baseURI + MetaKey,
+			IsOpt,
+			KeepCompressed,
+			Options
+			);
+		  IndexTargets.push_back(Target);
+
+		  if (tplMetaKey.find(BreakPoint) == std::string::npos)
+		     break;
+	       }
+
+	       if (tplMetaKey.find("$(ARCHITECTURE)") == std::string::npos)
+		  break;
+
+	    }
+
+	    if (tplMetaKey.find("$(LANGUAGE)") == std::string::npos)
+	       break;
+
+	 }
+
+      }
+   }
+}
+std::vector<IndexTarget> debReleaseIndex::GetIndexTargets() const
+{
+   std::vector<IndexTarget> IndexTargets;
+   GetIndexTargetsFor("deb-src", URI, Dist, d->DebSrcEntries, IndexTargets, d->ReleaseOptions);
+   GetIndexTargetsFor("deb", URI, Dist, d->DebEntries, IndexTargets, d->ReleaseOptions);
+   return IndexTargets;
+}
+									/*}}}*/
+void debReleaseIndex::AddComponent(std::string const &sourcesEntry,	/*{{{*/
+	 bool const isSrc, std::string const &Name,
+	 std::vector<std::string> const &Targets,
+	 std::vector<std::string> const &Architectures,
+	 std::vector<std::string> Languages,
+	 bool const usePDiffs, std::string const &useByHash)
+{
+   if (Languages.empty() == true)
+      Languages.push_back("none");
+   debReleaseIndexPrivate::debSectionEntry const entry = {
+      sourcesEntry, Name, Targets, Architectures, Languages, usePDiffs, useByHash
+   };
+   if (isSrc)
+      d->DebSrcEntries.push_back(entry);
+   else
+      d->DebEntries.push_back(entry);
+}
+									/*}}}*/
+std::string debReleaseIndex::ArchiveURI(std::string const &File) const	/*{{{*/
+{
+   if (File.empty())
+      return URI;
+   return URI + pkgAcquire::URIEncode(File);
+}
+									/*}}}*/
+
+bool debReleaseIndex::Load(std::string const &Filename, std::string * const ErrorText)/*{{{*/
+{
+   LoadedSuccessfully = TRI_NO;
+   FileFd Fd;
+   if (OpenMaybeClearSignedFile(Filename, Fd) == false)
+      return false;
+
+   pkgTagFile TagFile(&Fd, Fd.Size());
+   if (Fd.IsOpen() == false || Fd.Failed())
+   {
+      if (ErrorText != NULL)
+	 strprintf(*ErrorText, _("Unable to parse Release file %s"),Filename.c_str());
+      return false;
+   }
+
+   pkgTagSection Section;
+   const char *Start, *End;
+   if (TagFile.Step(Section) == false)
+   {
+      if (ErrorText != NULL)
+	 strprintf(*ErrorText, _("No sections in Release file %s"), Filename.c_str());
+      return false;
+   }
+   // FIXME: find better tag name
+   SupportsAcquireByHash = Section.FindB("Acquire-By-Hash", false);
+
+   Origin = Section.FindS("Origin");
+   Label = Section.FindS("Label");
+   Version = Section.FindS("Version");
+   Suite = Section.FindS("Suite");
+   Codename = Section.FindS("Codename");
+   ReleaseNotes = Section.FindS("Release-Notes");
+   {
+      std::string const archs = Section.FindS("Architectures");
+      if (archs.empty() == false)
+	 d->Architectures = VectorizeString(archs, ' ');
+   }
+   {
+      std::string const targets = Section.FindS("No-Support-for-Architecture-all");
+      if (targets.empty() == false)
+	 d->NoSupportForAll = VectorizeString(targets, ' ');
+   }
+   for (auto const &comp: VectorizeString(Section.FindS("Components"), ' '))
+   {
+      if (comp.empty())
+	 continue;
+      auto const pos = comp.find_last_of('/');
+      if (pos != std::string::npos) // e.g. security.debian.org uses this style
+	 d->SupportedComponents.push_back(comp.substr(pos + 1));
+      d->SupportedComponents.push_back(std::move(comp));
+   }
+   {
+      decltype(pkgCache::ReleaseFile::Flags) flags = 0;
+      Section.FindFlag("NotAutomatic", flags, pkgCache::Flag::NotAutomatic);
+      signed short defaultpin = 500;
+      if ((flags & pkgCache::Flag::NotAutomatic) == pkgCache::Flag::NotAutomatic)
+      {
+	 Section.FindFlag("ButAutomaticUpgrades", flags, pkgCache::Flag::ButAutomaticUpgrades);
+	 if ((flags & pkgCache::Flag::ButAutomaticUpgrades) == pkgCache::Flag::ButAutomaticUpgrades)
+	    defaultpin = 100;
+	 else
+	    defaultpin = 1;
+      }
+      DefaultPin = defaultpin;
+   }
+
+   bool FoundHashSum = false;
+   bool FoundStrongHashSum = false;
+   auto const SupportedHashes = HashString::SupportedHashes();
+   for (int i=0; SupportedHashes[i] != NULL; i++)
+   {
+      if (!Section.Find(SupportedHashes[i], Start, End))
+	 continue;
+
+      std::string Name;
+      std::string Hash;
+      unsigned long long Size;
+      while (Start < End)
+      {
+	 if (!parseSumData(Start, End, Name, Hash, Size))
+	    return false;
+
+	 HashString const hs(SupportedHashes[i], Hash);
+         if (Entries.find(Name) == Entries.end())
+         {
+            metaIndex::checkSum *Sum = new metaIndex::checkSum;
+            Sum->MetaKeyFilename = Name;
+            Sum->Size = Size;
+	    Sum->Hashes.FileSize(Size);
+	    Entries[Name] = Sum;
+         }
+         Entries[Name]->Hashes.push_back(hs);
+         FoundHashSum = true;
+	 if (FoundStrongHashSum == false && hs.usable() == true)
+	    FoundStrongHashSum = true;
+      }
+   }
+
+   bool AuthPossible = false;
+   if(FoundHashSum == false)
+      _error->Warning(_("No Hash entry in Release file %s"), Filename.c_str());
+   else if(FoundStrongHashSum == false)
+      _error->Warning(_("No Hash entry in Release file %s which is considered strong enough for security purposes"), Filename.c_str());
+   else
+      AuthPossible = true;
+
+   std::string const StrDate = Section.FindS("Date");
+   if (RFC1123StrToTime(StrDate, Date) == false)
+   {
+      _error->Warning( _("Invalid '%s' entry in Release file %s"), "Date", Filename.c_str());
+      Date = 0;
+   }
+
+   bool CheckDate = _config->FindB("Acquire::Check-Date", true);
+   if (d->CheckDate == metaIndex::TRI_NO)
+      CheckDate = false;
+   else if (d->CheckDate == metaIndex::TRI_YES)
+      CheckDate = true;
+
+   if (CheckDate)
+   {
+      auto const Label = GetLabel();
+      // get the user settings for this archive
+      time_t MaxFuture = d->DateMaxFuture;
+      if (MaxFuture == 0)
+      {
+	 MaxFuture = _config->FindI("Acquire::Max-FutureTime", 10);
+	 if (Label.empty() == false)
+	    MaxFuture = _config->FindI(("Acquire::Max-FutureTime::" + Label).c_str(), MaxFuture);
+      }
+
+      d->NotBefore = Date - MaxFuture;
+
+      bool CheckValidUntil = _config->FindB("Acquire::Check-Valid-Until", true);
+      if (d->CheckValidUntil == metaIndex::TRI_NO)
+	 CheckValidUntil = false;
+      else if (d->CheckValidUntil == metaIndex::TRI_YES)
+	 CheckValidUntil = true;
+
+      if (CheckValidUntil == true)
+      {
+	 std::string const StrValidUntil = Section.FindS("Valid-Until");
+
+	 // if we have a Valid-Until header in the Release file, use it as default
+	 if (StrValidUntil.empty() == false)
+	 {
+	    if (RFC1123StrToTime(StrValidUntil, ValidUntil) == false)
+	    {
+	       if (ErrorText != NULL)
+		  strprintf(*ErrorText, _("Invalid '%s' entry in Release file %s"), "Valid-Until", Filename.c_str());
+	       return false;
+	    }
+	 }
+	 auto const Label = GetLabel();
+	 // get the user settings for this archive and use what expires earlier
+	 time_t MaxAge = d->ValidUntilMax;
+	 if (MaxAge == 0)
+	 {
+	    MaxAge = _config->FindI("Acquire::Max-ValidTime", 0);
+	    if (Label.empty() == false)
+	       MaxAge = _config->FindI(("Acquire::Max-ValidTime::" + Label).c_str(), MaxAge);
+	 }
+	 time_t MinAge = d->ValidUntilMin;
+	 if (MinAge == 0)
+	 {
+	    MinAge = _config->FindI("Acquire::Min-ValidTime", 0);
+	    if (Label.empty() == false)
+	       MinAge = _config->FindI(("Acquire::Min-ValidTime::" + Label).c_str(), MinAge);
+	 }
+
+	 if (MinAge != 0 || ValidUntil != 0 || MaxAge != 0)
+	 {
+	    if (MinAge != 0 && ValidUntil != 0)
+	    {
+	       time_t const min_date = Date + MinAge;
+	       if (ValidUntil < min_date)
+		  ValidUntil = min_date;
+	    }
+	    if (MaxAge != 0 && Date != 0)
+	    {
+	       time_t const max_date = Date + MaxAge;
+	       if (ValidUntil == 0 || ValidUntil > max_date)
+		  ValidUntil = max_date;
+	    }
+	 }
+      }
+   }
+
+   /* as the Release file is parsed only after it was verified, the Signed-By field
+      does not effect the current, but the "next" Release file */
+   auto Sign = Section.FindS("Signed-By");
+   if (Sign.empty() == false)
+   {
+      SignedBy = NormalizeSignedBy(Sign, false);
+      if (SignedBy.empty() && ErrorText != NULL)
+	 strprintf(*ErrorText, _("Invalid '%s' entry in Release file %s"), "Signed-By", Filename.c_str());
+   }
+
+   if (AuthPossible)
+      LoadedSuccessfully = TRI_YES;
+   return AuthPossible;
+}
+									/*}}}*/
+time_t debReleaseIndex::GetNotBefore() const /*{{{*/
+{
+   return d->NotBefore;
+}
+									/*}}}*/
+metaIndex * debReleaseIndex::UnloadedClone() const			/*{{{*/
+{
+   if (Trusted == TRI_NO)
+      return new debReleaseIndex(URI, Dist, false, d->ReleaseOptions);
+   else if (Trusted == TRI_YES)
+      return new debReleaseIndex(URI, Dist, true, d->ReleaseOptions);
+   else
+      return new debReleaseIndex(URI, Dist, d->ReleaseOptions);
+}
+									/*}}}*/
+bool debReleaseIndex::parseSumData(const char *&Start, const char *End,	/*{{{*/
+				   std::string &Name, std::string &Hash, unsigned long long &Size)
+{
+   Name = "";
+   Hash = "";
+   Size = 0;
+   /* Skip over the first blank */
+   while ((*Start == '\t' || *Start == ' ' || *Start == '\n' || *Start == '\r')
+	  && Start < End)
+      Start++;
+   if (Start >= End)
+      return false;
+
+   /* Move EntryEnd to the end of the first entry (the hash) */
+   const char *EntryEnd = Start;
+   while ((*EntryEnd != '\t' && *EntryEnd != ' ')
+	  && EntryEnd < End)
+      EntryEnd++;
+   if (EntryEnd == End)
+      return false;
+
+   Hash.append(Start, EntryEnd-Start);
+
+   /* Skip over intermediate blanks */
+   Start = EntryEnd;
+   while (*Start == '\t' || *Start == ' ')
+      Start++;
+   if (Start >= End)
+      return false;
+   
+   EntryEnd = Start;
+   /* Find the end of the second entry (the size) */
+   while ((*EntryEnd != '\t' && *EntryEnd != ' ' )
+	  && EntryEnd < End)
+      EntryEnd++;
+   if (EntryEnd == End)
+      return false;
+   
+   Size = strtoull (Start, NULL, 10);
+      
+   /* Skip over intermediate blanks */
+   Start = EntryEnd;
+   while (*Start == '\t' || *Start == ' ')
+      Start++;
+   if (Start >= End)
+      return false;
+   
+   EntryEnd = Start;
+   /* Find the end of the third entry (the filename) */
+   while ((*EntryEnd != '\t' && *EntryEnd != ' ' && 
+           *EntryEnd != '\n' && *EntryEnd != '\r')
+	  && EntryEnd < End)
+      EntryEnd++;
+
+   Name.append(Start, EntryEnd-Start);
+   Start = EntryEnd; //prepare for the next round
+   return true;
+}
+									/*}}}*/
+
+bool debReleaseIndex::GetIndexes(pkgAcquire *Owner, bool const &GetAll)/*{{{*/
+{
+#define APT_TARGET(X) IndexTarget("", X, MetaIndexInfo(X), MetaIndexURI(X), false, false, d->ReleaseOptions)
+   pkgAcqMetaClearSig * const TransactionManager = new pkgAcqMetaClearSig(Owner,
+	 APT_TARGET("InRelease"), APT_TARGET("Release"), APT_TARGET("Release.gpg"), this);
+#undef APT_TARGET
+   // special case for --print-uris
+   if (GetAll)
+      for (auto const &Target: GetIndexTargets())
+	 if (Target.Option(IndexTarget::FALLBACK_OF).empty())
+	    new pkgAcqIndex(Owner, TransactionManager, Target);
+
+   return true;
+}
+									/*}}}*/
+// ReleaseIndex::Set* TriState options					/*{{{*/
+bool debReleaseIndex::SetTrusted(TriState const pTrusted)
+{
+   if (Trusted == TRI_UNSET)
+      Trusted = pTrusted;
+   else if (Trusted != pTrusted)
+      // TRANSLATOR: The first is an option name from sources.list manpage, the other two URI and Suite
+      return _error->Error(_("Conflicting values set for option %s regarding source %s %s"), "Trusted", URI.c_str(), Dist.c_str());
+   return true;
+}
+bool debReleaseIndex::SetCheckValidUntil(TriState const pCheckValidUntil)
+{
+   if (d->CheckValidUntil == TRI_UNSET)
+      d->CheckValidUntil = pCheckValidUntil;
+   else if (d->CheckValidUntil != pCheckValidUntil)
+      return _error->Error(_("Conflicting values set for option %s regarding source %s %s"), "Check-Valid-Until", URI.c_str(), Dist.c_str());
+   return true;
+}
+bool debReleaseIndex::SetValidUntilMin(time_t const Valid)
+{
+   if (d->ValidUntilMin == 0)
+      d->ValidUntilMin = Valid;
+   else if (d->ValidUntilMin != Valid)
+      return _error->Error(_("Conflicting values set for option %s regarding source %s %s"), "Min-ValidTime", URI.c_str(), Dist.c_str());
+   return true;
+}
+bool debReleaseIndex::SetValidUntilMax(time_t const Valid)
+{
+   if (d->ValidUntilMax == 0)
+      d->ValidUntilMax = Valid;
+   else if (d->ValidUntilMax != Valid)
+      return _error->Error(_("Conflicting values set for option %s regarding source %s %s"), "Max-ValidTime", URI.c_str(), Dist.c_str());
+   return true;
+}
+bool debReleaseIndex::SetCheckDate(TriState const pCheckDate)
+{
+   if (d->CheckDate == TRI_UNSET)
+      d->CheckDate = pCheckDate;
+   else if (d->CheckDate != pCheckDate)
+      return _error->Error(_("Conflicting values set for option %s regarding source %s %s"), "Check-Date", URI.c_str(), Dist.c_str());
+   return true;
+}
+bool debReleaseIndex::SetDateMaxFuture(time_t const DateMaxFuture)
+{
+   if (d->DateMaxFuture == 0)
+      d->DateMaxFuture = DateMaxFuture;
+   else if (d->DateMaxFuture != DateMaxFuture)
+      return _error->Error(_("Conflicting values set for option %s regarding source %s %s"), "Date-Max-Future", URI.c_str(), Dist.c_str());
+   return true;
+}
+bool debReleaseIndex::SetSignedBy(std::string const &pSignedBy)
+{
+   if (SignedBy.empty() == true && pSignedBy.empty() == false)
+   {
+      SignedBy = NormalizeSignedBy(pSignedBy, true);
+      if (SignedBy.empty())
+	 _error->Error(_("Invalid value set for option %s regarding source %s %s (%s)"), "Signed-By", URI.c_str(), Dist.c_str(), "not a fingerprint");
+   }
+   else
+   {
+      auto const normalSignedBy = NormalizeSignedBy(pSignedBy, true);
+      if (normalSignedBy != SignedBy)
+	 return _error->Error(_("Conflicting values set for option %s regarding source %s %s: %s != %s"), "Signed-By", URI.c_str(), Dist.c_str(), SignedBy.c_str(), normalSignedBy.c_str());
+   }
+   return true;
+}
+									/*}}}*/
+// ReleaseIndex::IsTrusted						/*{{{*/
+bool debReleaseIndex::IsTrusted() const
+{
+   if (Trusted == TRI_YES)
+      return true;
+   else if (Trusted == TRI_NO)
+      return false;
+
+
+   if(_config->FindB("APT::Authentication::TrustCDROM", false))
+      if(URI.substr(0,strlen("cdrom:")) == "cdrom:")
+	 return true;
+
+   if (FileExists(MetaIndexFile("Release.gpg")))
+      return true;
+
+   return FileExists(MetaIndexFile("InRelease"));
+}
+									/*}}}*/
+bool debReleaseIndex::IsArchitectureSupported(std::string const &arch) const/*{{{*/
+{
+   if (d->Architectures.empty())
+      return true;
+   return std::find(d->Architectures.begin(), d->Architectures.end(), arch) != d->Architectures.end();
+}
+									/*}}}*/
+bool debReleaseIndex::IsArchitectureAllSupportedFor(IndexTarget const &target) const/*{{{*/
+{
+   if (target.Options.find("Force-Support-For-All") != target.Options.end())
+      return true;
+   if (IsArchitectureSupported("all") == false)
+      return false;
+   if (d->NoSupportForAll.empty())
+      return true;
+   return std::find(d->NoSupportForAll.begin(), d->NoSupportForAll.end(), target.Option(IndexTarget::CREATED_BY)) == d->NoSupportForAll.end();
+}
+									/*}}}*/
+bool debReleaseIndex::HasSupportForComponent(std::string const &component) const/*{{{*/
+{
+   if (d->SupportedComponents.empty())
+      return true;
+   return std::find(d->SupportedComponents.begin(), d->SupportedComponents.end(), component) != d->SupportedComponents.end();
+}
+									/*}}}*/
+std::vector <pkgIndexFile *> *debReleaseIndex::GetIndexFiles()		/*{{{*/
+{
+   if (Indexes != NULL)
+      return Indexes;
+
+   Indexes = new std::vector<pkgIndexFile*>();
+   bool const istrusted = IsTrusted();
+   for (auto const &T: GetIndexTargets())
+   {
+      std::string const TargetName = T.Option(IndexTarget::CREATED_BY);
+      if (TargetName == "Packages")
+	 Indexes->push_back(new debPackagesIndex(T, istrusted));
+      else if (TargetName == "Sources")
+	 Indexes->push_back(new debSourcesIndex(T, istrusted));
+      else if (TargetName == "Translations")
+	 Indexes->push_back(new debTranslationsIndex(T));
+   }
+   return Indexes;
+}
+									/*}}}*/
+std::map<std::string, std::string> debReleaseIndex::GetReleaseOptions()
+{
+   return d->ReleaseOptions;
+}
+
+static bool ReleaseFileName(debReleaseIndex const * const That, std::string &ReleaseFile)/*{{{*/
+{
+   ReleaseFile = That->MetaIndexFile("InRelease");
+   bool releaseExists = false;
+   if (FileExists(ReleaseFile) == true)
+      releaseExists = true;
+   else
+   {
+      ReleaseFile = That->MetaIndexFile("Release");
+      if (FileExists(ReleaseFile))
+	 releaseExists = true;
+   }
+   return releaseExists;
+}
+									/*}}}*/
+bool debReleaseIndex::Merge(pkgCacheGenerator &Gen,OpProgress * /*Prog*/) const/*{{{*/
+{
+   std::string ReleaseFile;
+   bool const releaseExists = ReleaseFileName(this, ReleaseFile);
+
+   ::URI Tmp(URI);
+   if (Gen.SelectReleaseFile(ReleaseFile, Tmp.Host) == false)
+      return _error->Error("Problem with SelectReleaseFile %s", ReleaseFile.c_str());
+
+   if (releaseExists == false)
+      return true;
+
+   FileFd Rel;
+   // Beware: The 'Release' file might be clearsigned in case the
+   // signature for an 'InRelease' file couldn't be checked
+   if (OpenMaybeClearSignedFile(ReleaseFile, Rel) == false)
+      return false;
+
+   // Store the IMS information
+   pkgCache::RlsFileIterator File = Gen.GetCurRlsFile();
+   pkgCacheGenerator::Dynamic<pkgCache::RlsFileIterator> DynFile(File);
+   // Rel can't be used as this is potentially a temporary file
+   struct stat Buf;
+   if (stat(ReleaseFile.c_str(), &Buf) != 0)
+      return _error->Errno("fstat", "Unable to stat file %s", ReleaseFile.c_str());
+   File->Size = Buf.st_size;
+   File->mtime = Buf.st_mtime;
+
+   pkgTagFile TagFile(&Rel, Rel.Size());
+   pkgTagSection Section;
+   if (Rel.IsOpen() == false || Rel.Failed() || TagFile.Step(Section) == false)
+      return false;
+
+   std::string data;
+   #define APT_INRELEASE(TYPE, TAG, STORE) \
+   data = Section.FindS(TAG); \
+   if (data.empty() == false) \
+   { \
+      map_stringitem_t const storage = Gen.StoreString(pkgCacheGenerator::TYPE, data); \
+      if (storage == 0) return false; \
+      STORE = storage; \
+   }
+   APT_INRELEASE(MIXED, "Suite", File->Archive)
+   APT_INRELEASE(VERSIONNUMBER, "Version", File->Version)
+   APT_INRELEASE(MIXED, "Origin", File->Origin)
+   APT_INRELEASE(MIXED, "Codename", File->Codename)
+   APT_INRELEASE(MIXED, "Label", File->Label)
+   #undef APT_INRELEASE
+   Section.FindFlag("NotAutomatic", File->Flags, pkgCache::Flag::NotAutomatic);
+   Section.FindFlag("ButAutomaticUpgrades", File->Flags, pkgCache::Flag::ButAutomaticUpgrades);
+
+   return true;
+}
+									/*}}}*/
+// ReleaseIndex::FindInCache - Find this index				/*{{{*/
+pkgCache::RlsFileIterator debReleaseIndex::FindInCache(pkgCache &Cache, bool const ModifyCheck) const
+{
+   std::string ReleaseFile;
+   bool const releaseExists = ReleaseFileName(this, ReleaseFile);
+
+   pkgCache::RlsFileIterator File = Cache.RlsFileBegin();
+   for (; File.end() == false; ++File)
+   {
+       if (File->FileName == 0 || ReleaseFile != File.FileName())
+	 continue;
+
+       // empty means the file does not exist by "design"
+       if (ModifyCheck == false || (releaseExists == false && File->Size == 0))
+	  return File;
+
+      struct stat St;
+      if (stat(File.FileName(),&St) != 0)
+      {
+         if (_config->FindB("Debug::pkgCacheGen", false))
+	    std::clog << "ReleaseIndex::FindInCache - stat failed on " << File.FileName() << std::endl;
+	 return pkgCache::RlsFileIterator(Cache);
+      }
+      if ((unsigned)St.st_size != File->Size || St.st_mtime != File->mtime)
+      {
+         if (_config->FindB("Debug::pkgCacheGen", false))
+	    std::clog << "ReleaseIndex::FindInCache - size (" << St.st_size << " <> " << File->Size
+			<< ") or mtime (" << St.st_mtime << " <> " << File->mtime
+			<< ") doesn't match for " << File.FileName() << std::endl;
+	 return pkgCache::RlsFileIterator(Cache);
+      }
+      return File;
+   }
+
+   return File;
+}
+									/*}}}*/
+
+class APT_HIDDEN debSLTypeDebian : public pkgSourceList::Type		/*{{{*/
+{
+   static std::vector<std::string> getDefaultSetOf(std::string const &Name,
+	 std::map<std::string, std::string> const &Options, std::vector<std::string> const &defaultValues)
+   {
+      auto const val = Options.find(Name);
+      if (val != Options.end())
+	 return VectorizeString(val->second, ',');
+      return defaultValues;
+   }
+   static std::vector<std::string> applyPlusMinusOptions(std::string const &Name,
+	 std::map<std::string, std::string> const &Options, std::vector<std::string> &&Values)
+   {
+      auto val = Options.find(Name + "+");
+      if (val != Options.end())
+      {
+	 std::vector<std::string> const plus = VectorizeString(val->second, ',');
+	 std::copy_if(plus.begin(), plus.end(), std::back_inserter(Values), [&Values](std::string const &v) {
+	       return std::find(Values.begin(), Values.end(), v) == Values.end();
+	       });
+      }
+      if ((val = Options.find(Name + "-")) != Options.end())
+      {
+	 std::vector<std::string> const minus = VectorizeString(val->second, ',');
+	 Values.erase(std::remove_if(Values.begin(), Values.end(), [&minus](std::string const &v) {
+		  return std::find(minus.begin(), minus.end(), v) != minus.end();
+		  }), Values.end());
+      }
+      return std::move(Values);
+   }
+   static std::vector<std::string> parsePlusMinusOptions(std::string const &Name,
+	 std::map<std::string, std::string> const &Options, std::vector<std::string> const &defaultValues)
+   {
+      return applyPlusMinusOptions(Name, Options, getDefaultSetOf(Name, Options, defaultValues));
+   }
+   static std::vector<std::string> parsePlusMinusArchOptions(std::string const &Name,
+	 std::map<std::string, std::string> const &Options)
+   {
+      auto Values = getDefaultSetOf(Name, Options, APT::Configuration::getArchitectures());
+      // all is a very special architecture users shouldn't be concerned with explicitly
+      // but if the user does, do not override the choice
+      auto const val = Options.find(Name + "-");
+      if (val != Options.end())
+      {
+	 std::vector<std::string> const minus = VectorizeString(val->second, ',');
+	 if (std::find(minus.begin(), minus.end(), "all") != minus.end())
+	    return applyPlusMinusOptions(Name, Options, std::move(Values));
+      }
+      Values = applyPlusMinusOptions(Name, Options, std::move(Values));
+      if (std::find(Values.begin(), Values.end(), "all") == Values.end())
+	 Values.push_back("implicit:all");
+      return Values;
+   }
+   static std::vector<std::string> parsePlusMinusTargetOptions(char const * const Name,
+	 std::map<std::string, std::string> const &Options)
+   {
+      std::vector<std::string> const alltargets = _config->FindVector(std::string("Acquire::IndexTargets::") + Name, "", true);
+      std::vector<std::string> deftargets;
+      deftargets.reserve(alltargets.size());
+      std::copy_if(alltargets.begin(), alltargets.end(), std::back_inserter(deftargets), [&](std::string const &t) {
+	 std::string c = "Acquire::IndexTargets::";
+	 c.append(Name).append("::").append(t).append("::DefaultEnabled");
+	 return _config->FindB(c, true);
+      });
+      std::vector<std::string> mytargets = parsePlusMinusOptions("target", Options, deftargets);
+      for (auto const &target : alltargets)
+      {
+	 std::map<std::string, std::string>::const_iterator const opt = Options.find(target);
+	 if (opt == Options.end())
+	    continue;
+	 auto const idMatch = [&](std::string const &t) {
+	    return target == _config->Find(std::string("Acquire::IndexTargets::") + Name + "::" + t + "::Identifier", t);
+	 };
+	 if (StringToBool(opt->second))
+	    std::copy_if(alltargets.begin(), alltargets.end(), std::back_inserter(mytargets), idMatch);
+	 else
+	    mytargets.erase(std::remove_if(mytargets.begin(), mytargets.end(), idMatch), mytargets.end());
+      }
+      // if we can't order it in a 1000 steps we give up… probably a cycle
+      for (auto i = 0; i < 1000; ++i)
+      {
+	 bool Changed = false;
+	 for (auto t = mytargets.begin(); t != mytargets.end(); ++t)
+	 {
+	    std::string const fallback = _config->Find(std::string("Acquire::IndexTargets::") + Name + "::" + *t + "::Fallback-Of");
+	    if (fallback.empty())
+	       continue;
+	    auto const faller = std::find(mytargets.begin(), mytargets.end(), fallback);
+	    if (faller == mytargets.end() || faller < t)
+	       continue;
+	    Changed = true;
+	    auto const tv = *t;
+	    mytargets.erase(t);
+	    mytargets.emplace_back(tv);
+	    break;
+	 }
+	 if (Changed == false)
+	    break;
+      }
+      // remove duplicates without changing the order (in first appearance)
+      {
+	 std::set<std::string> seenOnce;
+	 mytargets.erase(std::remove_if(mytargets.begin(), mytargets.end(), [&](std::string const &t) {
+	    return seenOnce.insert(t).second == false;
+	 }), mytargets.end());
+      }
+      return mytargets;
+   }
+
+   metaIndex::TriState GetTriStateOption(std::map<std::string, std::string>const &Options, char const * const name) const
+   {
+      std::map<std::string, std::string>::const_iterator const opt = Options.find(name);
+      if (opt != Options.end())
+	 return StringToBool(opt->second, false) ? metaIndex::TRI_YES : metaIndex::TRI_NO;
+      return metaIndex::TRI_DONTCARE;
+   }
+
+   static time_t GetTimeOption(std::map<std::string, std::string>const &Options, char const * const name)
+   {
+      std::map<std::string, std::string>::const_iterator const opt = Options.find(name);
+      if (opt == Options.end())
+	 return 0;
+      return strtoull(opt->second.c_str(), NULL, 10);
+   }
+
+   static bool GetBoolOption(std::map<std::string, std::string> const &Options, char const * const name, bool const defVal)
+   {
+      std::map<std::string, std::string>::const_iterator const opt = Options.find(name);
+      if (opt == Options.end())
+	 return defVal;
+      return StringToBool(opt->second, defVal);
+   }
+
+   static std::vector<std::string> GetMapKeys(std::map<std::string, std::string> const &Options)
+   {
+      std::vector<std::string> ret;
+      ret.reserve(Options.size());
+      std::transform(Options.begin(), Options.end(), std::back_inserter(ret),
+		     [](auto &&O) { return O.first; });
+      std::sort(ret.begin(), ret.end());
+      return ret;
+   }
+
+   static bool MapsAreEqual(std::map<std::string, std::string> const &OptionsA,
+	 std::map<std::string, std::string> const &OptionsB,
+	 std::string const &URI, std::string const &Dist)
+   {
+      auto const KeysA = GetMapKeys(OptionsA);
+      auto const KeysB = GetMapKeys(OptionsB);
+      auto const m = std::mismatch(KeysA.begin(), KeysA.end(), KeysB.begin());
+      if (m.first != KeysA.end())
+      {
+	 if (std::find(KeysB.begin(), KeysB.end(), *m.first) == KeysB.end())
+	    return _error->Error(_("Conflicting values set for option %s regarding source %s %s"), m.first->c_str(), "<set>", "<unset>");
+	 else
+	    return _error->Error(_("Conflicting values set for option %s regarding source %s %s"), m.second->c_str(), "<set>", "<unset>");
+      }
+      if (m.second != KeysB.end())
+      {
+	 if (std::find(KeysA.begin(), KeysA.end(), *m.second) == KeysA.end())
+	    return _error->Error(_("Conflicting values set for option %s regarding source %s %s"), m.first->c_str(), "<set>", "<unset>");
+	 else
+	    return _error->Error(_("Conflicting values set for option %s regarding source %s %s"), m.second->c_str(), "<set>", "<unset>");
+      }
+      for (auto&& key: KeysA)
+      {
+	 if (key == "BASE_URI" || key == "REPO_URI" || key == "SITE" || key == "RELEASE")
+	    continue;
+	 auto const a = OptionsA.find(key);
+	 auto const b = OptionsB.find(key);
+	 if (unlikely(a == OptionsA.end() || b == OptionsB.end()) || a->second != b->second)
+	    return _error->Error(_("Conflicting values set for option %s regarding source %s %s"), key.c_str(), URI.c_str(), Dist.c_str());
+      }
+      return true;
+   }
+
+   static debReleaseIndex * GetDebReleaseIndexBy(std::vector<metaIndex *> &List, std::string const &URI,
+			   std::string const &Dist, std::map<std::string, std::string> const &Options)
+   {
+      std::map<std::string, std::string> ReleaseOptions{{
+	 {"BASE_URI", constructMetaIndexURI(URI, Dist, "")},
+	 {"REPO_URI", URI},
+	 {"SITE", ::URI::ArchiveOnly(URI)},
+	 {"RELEASE", (Dist == "/") ? "" : Dist},
+      }};
+      if (GetBoolOption(Options, "allow-insecure", _config->FindB("Acquire::AllowInsecureRepositories")))
+	 ReleaseOptions.emplace("ALLOW_INSECURE", "true");
+      if (GetBoolOption(Options, "allow-weak", _config->FindB("Acquire::AllowWeakRepositories")))
+	 ReleaseOptions.emplace("ALLOW_WEAK", "true");
+      if (GetBoolOption(Options, "allow-downgrade-to-insecure", _config->FindB("Acquire::AllowDowngradeToInsecureRepositories")))
+	 ReleaseOptions.emplace("ALLOW_DOWNGRADE_TO_INSECURE", "true");
+
+      auto InReleasePath = Options.find("inrelease-path");
+      if (InReleasePath != Options.end())
+	 ReleaseOptions.emplace("INRELEASE_PATH", InReleasePath->second);
+
+      debReleaseIndex * Deb = nullptr;
+      std::string const FileName = URItoFileName(constructMetaIndexURI(URI, Dist, "Release"));
+      for (auto const &I: List)
+      {
+	 // We only worry about debian entries here
+	 if (strcmp(I->GetType(), "deb") != 0)
+	    continue;
+
+	 auto const D = dynamic_cast<debReleaseIndex*>(I);
+	 if (unlikely(D == nullptr))
+	    continue;
+
+	 /* This check ensures that there will be only one Release file
+	    queued for all the Packages files and Sources files it
+	    corresponds to. */
+	 if (URItoFileName(D->MetaIndexURI("Release")) == FileName)
+	 {
+	    if (MapsAreEqual(ReleaseOptions, D->GetReleaseOptions(), URI, Dist) == false)
+	       return nullptr;
+	    Deb = D;
+	    break;
+	 }
+      }
+
+      // No currently created Release file indexes this entry, so we create a new one.
+      if (Deb == nullptr)
+      {
+	 Deb = new debReleaseIndex(URI, Dist, ReleaseOptions);
+	 List.push_back(Deb);
+      }
+      return Deb;
+   }
+
+   protected:
+
+   bool CreateItemInternal(std::vector<metaIndex *> &List, std::string const &URI,
+			   std::string const &Dist, std::string const &Section,
+			   bool const &IsSrc, std::map<std::string, std::string> const &Options) const
+   {
+      auto const Deb = GetDebReleaseIndexBy(List, URI, Dist, Options);
+      if (Deb == nullptr)
+	 return false;
+
+      bool const UsePDiffs = GetBoolOption(Options, "pdiffs", _config->FindB("Acquire::PDiffs", true));
+
+      std::string UseByHash = _config->Find("APT::Acquire::By-Hash", "yes");
+      UseByHash = _config->Find("Acquire::By-Hash", UseByHash);
+      {
+	 std::string const host = ::URI(URI).Host;
+	 if (host.empty() == false)
+	 {
+	    UseByHash = _config->Find("APT::Acquire::" + host + "::By-Hash", UseByHash);
+	    UseByHash = _config->Find("Acquire::" + host + "::By-Hash", UseByHash);
+	 }
+	 std::map<std::string, std::string>::const_iterator const opt = Options.find("by-hash");
+	 if (opt != Options.end())
+	    UseByHash = opt->second;
+      }
+
+      auto const entry = Options.find("sourceslist-entry");
+      Deb->AddComponent(
+	    entry->second,
+	    IsSrc,
+	    Section,
+	    parsePlusMinusTargetOptions(Name, Options),
+	    parsePlusMinusArchOptions("arch", Options),
+	    parsePlusMinusOptions("lang", Options, APT::Configuration::getLanguages(true)),
+	    UsePDiffs,
+	    UseByHash
+	    );
+
+      if (Deb->SetTrusted(GetTriStateOption(Options, "trusted")) == false ||
+	  Deb->SetCheckValidUntil(GetTriStateOption(Options, "check-valid-until")) == false ||
+	  Deb->SetValidUntilMax(GetTimeOption(Options, "valid-until-max")) == false ||
+	  Deb->SetValidUntilMin(GetTimeOption(Options, "valid-until-min")) == false ||
+	  Deb->SetCheckDate(GetTriStateOption(Options, "check-date")) == false ||
+	  Deb->SetDateMaxFuture(GetTimeOption(Options, "date-max-future")) == false)
+	 return false;
+
+      std::map<std::string, std::string>::const_iterator const signedby = Options.find("signed-by");
+      if (signedby == Options.end())
+      {
+	 bool alreadySet = false;
+	 std::string filename;
+	 if (ReleaseFileName(Deb, filename))
+	 {
+	    auto OldDeb = Deb->UnloadedClone();
+	    _error->PushToStack();
+	    OldDeb->Load(filename, nullptr);
+	    bool const goodLoad = _error->PendingError() == false;
+	    _error->RevertToStack();
+	    if (goodLoad)
+	    {
+	       if (OldDeb->GetValidUntil() > 0)
+	       {
+		  time_t const invalid_since = time(NULL) - OldDeb->GetValidUntil();
+		  if (invalid_since <= 0)
+		  {
+		     Deb->SetSignedBy(OldDeb->GetSignedBy());
+		     alreadySet = true;
+		  }
+	       }
+	    }
+	    delete OldDeb;
+	 }
+	 if (alreadySet == false && Deb->SetSignedBy("") == false)
+	    return false;
+      }
+      else
+      {
+	 if (Deb->SetSignedBy(signedby->second) == false)
+	    return false;
+      }
+
+      return true;
+   }
+
+   debSLTypeDebian(char const * const Name, char const * const Label) : Type(Name, Label)
+   {
+   }
+};
+									/*}}}*/
+class APT_HIDDEN debSLTypeDeb : public debSLTypeDebian			/*{{{*/
+{
+   public:
+
+   bool CreateItem(std::vector<metaIndex *> &List, std::string const &URI,
+		   std::string const &Dist, std::string const &Section,
+		   std::map<std::string, std::string> const &Options) const APT_OVERRIDE
+   {
+      return CreateItemInternal(List, URI, Dist, Section, false, Options);
+   }
+
+   debSLTypeDeb() : debSLTypeDebian("deb", "Debian binary tree")
+   {
+   }
+};
+									/*}}}*/
+class APT_HIDDEN debSLTypeDebSrc : public debSLTypeDebian		/*{{{*/
+{
+   public:
+
+   bool CreateItem(std::vector<metaIndex *> &List, std::string const &URI,
+		   std::string const &Dist, std::string const &Section,
+		   std::map<std::string, std::string> const &Options) const APT_OVERRIDE
+   {
+      return CreateItemInternal(List, URI, Dist, Section, true, Options);
+   }
+
+   debSLTypeDebSrc() : debSLTypeDebian("deb-src", "Debian source tree")
+   {
+   }
+};
+									/*}}}*/
+
+APT_HIDDEN debSLTypeDeb _apt_DebType;
+APT_HIDDEN debSLTypeDebSrc _apt_DebSrcType;
diff --git a/apt-pkg/deb/debmetaindex.h b/apt-pkg/deb/debmetaindex.h
new file mode 100644
index 0000000..717f08e
--- /dev/null
+++ b/apt-pkg/deb/debmetaindex.h
@@ -0,0 +1,72 @@
+#ifndef PKGLIB_DEBMETAINDEX_H
+#define PKGLIB_DEBMETAINDEX_H
+
+#include <apt-pkg/macros.h>
+#include <apt-pkg/metaindex.h>
+
+#include <map>
+#include <string>
+#include <vector>
+
+
+class pkgAcquire;
+class pkgIndexFile;
+class IndexTarget;
+class pkgCacheGenerator;
+class OpProgress;
+class debReleaseIndexPrivate;
+
+class APT_HIDDEN debReleaseIndex : public metaIndex
+{
+   debReleaseIndexPrivate * const d;
+
+   APT_HIDDEN bool parseSumData(const char *&Start, const char *End, std::string &Name,
+		     std::string &Hash, unsigned long long &Size);
+   public:
+
+   APT_HIDDEN std::string MetaIndexInfo(const char *Type) const;
+   APT_HIDDEN std::string MetaIndexFile(const char *Types) const;
+   APT_HIDDEN std::string MetaIndexURI(const char *Type) const;
+
+   debReleaseIndex(std::string const &URI, std::string const &Dist, std::map<std::string,std::string> const &Options);
+   debReleaseIndex(std::string const &URI, std::string const &Dist, bool const Trusted, std::map<std::string,std::string> const &Options);
+   virtual ~debReleaseIndex();
+
+   virtual std::string ArchiveURI(std::string const &File) const APT_OVERRIDE;
+   virtual bool GetIndexes(pkgAcquire *Owner, bool const &GetAll=false) APT_OVERRIDE;
+   virtual std::vector<IndexTarget> GetIndexTargets() const APT_OVERRIDE;
+
+   virtual std::string Describe() const APT_OVERRIDE;
+   virtual pkgCache::RlsFileIterator FindInCache(pkgCache &Cache, bool const ModifyCheck) const APT_OVERRIDE;
+   virtual bool Merge(pkgCacheGenerator &Gen,OpProgress *Prog) const APT_OVERRIDE;
+
+   virtual bool Load(std::string const &Filename, std::string * const ErrorText) APT_OVERRIDE;
+   virtual metaIndex * UnloadedClone() const APT_OVERRIDE;
+
+   virtual std::vector <pkgIndexFile *> *GetIndexFiles() APT_OVERRIDE;
+
+   bool SetTrusted(TriState const Trusted);
+   bool SetCheckValidUntil(TriState const Trusted);
+   bool SetValidUntilMin(time_t const Valid);
+   bool SetValidUntilMax(time_t const Valid);
+   bool SetCheckDate(TriState const CheckDate);
+   bool SetDateMaxFuture(time_t const DateMaxFuture);
+   bool SetSignedBy(std::string const &SignedBy);
+   std::map<std::string, std::string> GetReleaseOptions();
+
+   virtual bool IsTrusted() const APT_OVERRIDE;
+   bool IsArchitectureSupported(std::string const &arch) const override;
+   bool IsArchitectureAllSupportedFor(IndexTarget const &target) const override;
+   bool HasSupportForComponent(std::string const &component) const override;
+
+   APT_PURE time_t GetNotBefore() const override;
+
+   void AddComponent(std::string const &sourcesEntry,
+	 bool const isSrc, std::string const &Name,
+	 std::vector<std::string> const &Targets,
+	 std::vector<std::string> const &Architectures,
+	 std::vector<std::string> Languages,
+	 bool const usePDiffs, std::string const &useByHash);
+};
+
+#endif
diff --git a/apt-pkg/deb/debrecords.cc b/apt-pkg/deb/debrecords.cc
new file mode 100644
index 0000000..22ac219
--- /dev/null
+++ b/apt-pkg/deb/debrecords.cc
@@ -0,0 +1,227 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+   
+   Debian Package Records - Parser for debian package records
+     
+   ##################################################################### */
+									/*}}}*/
+// Include Files							/*{{{*/
+#include <config.h>
+
+#include <apt-pkg/aptconfiguration.h>
+#include <apt-pkg/debindexfile.h>
+#include <apt-pkg/debrecords.h>
+#include <apt-pkg/error.h>
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/strutl.h>
+#include <apt-pkg/tagfile.h>
+
+#include <algorithm>
+#include <sstream>
+#include <string>
+#include <vector>
+#include <langinfo.h>
+#include <string.h>
+
+#include <apti18n.h>
+									/*}}}*/
+
+using std::string;
+
+// RecordParser::debRecordParser - Constructor				/*{{{*/
+debRecordParser::debRecordParser(string FileName,pkgCache &Cache) :
+   debRecordParserBase(), d(NULL), File(FileName, FileFd::ReadOnly, FileFd::Extension),
+   Tags(&File, std::max(Cache.Head().MaxVerFileSize, Cache.Head().MaxDescFileSize) + 200)
+{
+}
+									/*}}}*/
+// RecordParser::Jump - Jump to a specific record			/*{{{*/
+bool debRecordParser::Jump(pkgCache::VerFileIterator const &Ver)
+{
+   if (Ver.end() == true)
+      return false;
+   return Tags.Jump(Section,Ver->Offset);
+}
+bool debRecordParser::Jump(pkgCache::DescFileIterator const &Desc)
+{
+   if (Desc.end() == true)
+      return false;
+   return Tags.Jump(Section,Desc->Offset);
+}
+									/*}}}*/
+debRecordParser::~debRecordParser() {}
+
+debRecordParserBase::debRecordParserBase() : Parser(), d(NULL) {}
+// RecordParserBase::FileName - Return the archive filename on the site	/*{{{*/
+string debRecordParserBase::FileName()
+{
+   return Section.FindS("Filename");
+}
+									/*}}}*/
+// RecordParserBase::Name - Return the package name			/*{{{*/
+string debRecordParserBase::Name()
+{
+   string Result = Section.FindS("Package");
+
+   // Normalize mixed case package names to lower case, like dpkg does
+   // See Bug#807012 for details
+   std::transform(Result.begin(), Result.end(), Result.begin(), tolower_ascii);
+
+   return Result;
+}
+									/*}}}*/
+// RecordParserBase::Homepage - Return the package homepage		/*{{{*/
+string debRecordParserBase::Homepage()
+{
+   return Section.FindS("Homepage");
+}
+									/*}}}*/
+// RecordParserBase::Hashes - return the available archive hashes	/*{{{*/
+HashStringList debRecordParserBase::Hashes() const
+{
+   HashStringList hashes;
+   for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
+   {
+      std::string const hash = Section.FindS(*type);
+      if (hash.empty() == false)
+	 hashes.push_back(HashString(*type, hash));
+   }
+   auto const size = Section.FindULL("Size", 0);
+   if (size != 0)
+      hashes.FileSize(size);
+   return hashes;
+}
+									/*}}}*/
+// RecordParserBase::Maintainer - Return the maintainer email		/*{{{*/
+string debRecordParserBase::Maintainer()
+{
+   return Section.FindS("Maintainer");
+}
+									/*}}}*/
+// RecordParserBase::RecordField - Return the value of an arbitrary field	/*{{*/
+string debRecordParserBase::RecordField(const char *fieldName)
+{
+   return Section.FindS(fieldName);
+}
+									/*}}}*/
+// RecordParserBase::ShortDesc - Return a 1 line description		/*{{{*/
+string debRecordParserBase::ShortDesc(std::string const &lang)
+{
+   string const Res = LongDesc(lang);
+   if (Res.empty() == true)
+      return "";
+   string::size_type const Pos = Res.find('\n');
+   if (Pos == string::npos)
+      return Res;
+   return string(Res,0,Pos);
+}
+									/*}}}*/
+// RecordParserBase::LongDesc - Return a longer description		/*{{{*/
+string debRecordParserBase::LongDesc(std::string const &lang)
+{
+   string orig;
+   if (lang.empty() == true)
+   {
+      std::vector<string> const lang = APT::Configuration::getLanguages();
+      for (std::vector<string>::const_iterator l = lang.begin();
+	    l != lang.end(); ++l)
+      {
+	 std::string const tagname = "Description-" + *l;
+	 orig = Section.FindS(tagname.c_str());
+	 if (orig.empty() == false)
+	    break;
+	 else if (*l == "en")
+	 {
+	    orig = Section.FindS("Description");
+	    if (orig.empty() == false)
+	       break;
+	 }
+      }
+      if (orig.empty() == true)
+	 orig = Section.FindS("Description");
+   }
+   else
+   {
+      std::string const tagname = "Description-" + lang;
+      orig = Section.FindS(tagname.c_str());
+      if (orig.empty() == true && lang == "en")
+	 orig = Section.FindS("Description");
+   }
+
+   char const * const codeset = nl_langinfo(CODESET);
+   if (strcmp(codeset,"UTF-8") != 0) {
+      string dest;
+      UTF8ToCodeset(codeset, orig, &dest);
+      return dest;
+   }
+
+   return orig;
+}
+									/*}}}*/
+
+static const char * const SourceVerSeparators = " ()";
+// RecordParserBase::SourcePkg - Return the source package name if any	/*{{{*/
+string debRecordParserBase::SourcePkg()
+{
+   string Res = Section.FindS("Source");
+   string::size_type Pos = Res.find_first_of(SourceVerSeparators);
+   if (Pos == string::npos)
+      return Res;
+   return string(Res,0,Pos);
+}
+									/*}}}*/
+// RecordParserBase::SourceVer - Return the source version number if present	/*{{{*/
+string debRecordParserBase::SourceVer()
+{
+   string Pkg = Section.FindS("Source");
+   string::size_type Pos = Pkg.find_first_of(SourceVerSeparators);
+   if (Pos == string::npos)
+      return "";
+
+   string::size_type VerStart = Pkg.find_first_not_of(SourceVerSeparators, Pos);
+   if(VerStart == string::npos)
+     return "";
+
+   string::size_type VerEnd = Pkg.find_first_of(SourceVerSeparators, VerStart);
+   if(VerEnd == string::npos)
+     // Corresponds to the case of, e.g., "foo (1.2" without a closing
+     // paren.  Be liberal and guess what it means.
+     return string(Pkg, VerStart);
+   else
+     return string(Pkg, VerStart, VerEnd - VerStart);
+}
+									/*}}}*/
+// RecordParserBase::GetRec - Return the whole record			/*{{{*/
+void debRecordParserBase::GetRec(const char *&Start,const char *&Stop)
+{
+   Section.GetSection(Start,Stop);
+}
+									/*}}}*/
+debRecordParserBase::~debRecordParserBase() {}
+
+bool debDebFileRecordParser::LoadContent()
+{
+   // load content only once
+   if (controlContent.empty() == false)
+      return true;
+
+   std::ostringstream content;
+   if (debDebPkgFileIndex::GetContent(content, debFileName) == false)
+      return false;
+   // add two newlines to make sure the scanner finds the section,
+   // which is usually done by pkgTagFile automatically if needed.
+   content << "\n\n";
+
+   controlContent = content.str();
+   if (Section.Scan(controlContent.c_str(), controlContent.length()) == false)
+      return _error->Error(_("Unable to parse package file %s (%d)"), debFileName.c_str(), 3);
+   return true;
+}
+bool debDebFileRecordParser::Jump(pkgCache::VerFileIterator const &) { return LoadContent(); }
+bool debDebFileRecordParser::Jump(pkgCache::DescFileIterator const &) { return LoadContent(); }
+std::string debDebFileRecordParser::FileName() { return debFileName; }
+
+debDebFileRecordParser::debDebFileRecordParser(std::string FileName) : debRecordParserBase(), d(NULL), debFileName(FileName) {}
+debDebFileRecordParser::~debDebFileRecordParser() {}
diff --git a/apt-pkg/deb/debrecords.h b/apt-pkg/deb/debrecords.h
new file mode 100644
index 0000000..10ef917
--- /dev/null
+++ b/apt-pkg/deb/debrecords.h
@@ -0,0 +1,89 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+   
+   Debian Package Records - Parser for debian package records
+   
+   This provides display-type parsing for the Packages file. This is
+   different than the list parser which provides cache generation
+   services. There should be no overlap between these two.
+   
+   ##################################################################### */
+									/*}}}*/
+#ifndef PKGLIB_DEBRECORDS_H
+#define PKGLIB_DEBRECORDS_H
+
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/pkgrecords.h>
+#include <apt-pkg/tagfile.h>
+
+#include <string>
+
+
+class APT_HIDDEN debRecordParserBase : public pkgRecords::Parser
+{
+   void * const d;
+ protected:
+   pkgTagSection Section;
+
+ public:
+   // These refer to the archive file for the Version
+   virtual std::string FileName() APT_OVERRIDE;
+   virtual std::string SourcePkg() APT_OVERRIDE;
+   virtual std::string SourceVer() APT_OVERRIDE;
+
+   virtual HashStringList Hashes() const APT_OVERRIDE;
+
+   // These are some general stats about the package
+   virtual std::string Maintainer() APT_OVERRIDE;
+   virtual std::string ShortDesc(std::string const &lang) APT_OVERRIDE;
+   virtual std::string LongDesc(std::string const &lang) APT_OVERRIDE;
+   virtual std::string Name() APT_OVERRIDE;
+   virtual std::string Homepage() APT_OVERRIDE;
+
+   // An arbitrary custom field
+   virtual std::string RecordField(const char *fieldName) APT_OVERRIDE;
+
+   virtual void GetRec(const char *&Start,const char *&Stop) APT_OVERRIDE;
+
+   debRecordParserBase();
+   virtual ~debRecordParserBase();
+};
+
+class APT_HIDDEN debRecordParser : public debRecordParserBase
+{
+   void * const d;
+ protected:
+   FileFd File;
+   pkgTagFile Tags;
+
+   virtual bool Jump(pkgCache::VerFileIterator const &Ver) APT_OVERRIDE;
+   virtual bool Jump(pkgCache::DescFileIterator const &Desc) APT_OVERRIDE;
+
+ public:
+   debRecordParser(std::string FileName,pkgCache &Cache);
+   virtual ~debRecordParser();
+};
+
+// custom record parser that reads deb files directly
+class APT_HIDDEN debDebFileRecordParser : public debRecordParserBase
+{
+   void * const d;
+   std::string debFileName;
+   std::string controlContent;
+
+   APT_HIDDEN bool LoadContent();
+ protected:
+   // single file files, so no jumping whatsoever
+   bool Jump(pkgCache::VerFileIterator const &) APT_OVERRIDE;
+   bool Jump(pkgCache::DescFileIterator const &) APT_OVERRIDE;
+
+ public:
+   virtual std::string FileName() APT_OVERRIDE;
+
+   explicit debDebFileRecordParser(std::string FileName);
+   virtual ~debDebFileRecordParser();
+};
+
+#endif
diff --git a/apt-pkg/deb/debsrcrecords.cc b/apt-pkg/deb/debsrcrecords.cc
new file mode 100644
index 0000000..0b6cf1f
--- /dev/null
+++ b/apt-pkg/deb/debsrcrecords.cc
@@ -0,0 +1,289 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+   
+   Debian Source Package Records - Parser implementation for Debian style
+                                   source indexes
+      
+   ##################################################################### */
+									/*}}}*/
+// Include Files							/*{{{*/
+#include <config.h>
+
+#include <apt-pkg/aptconfiguration.h>
+#include <apt-pkg/deblistparser.h>
+#include <apt-pkg/debsrcrecords.h>
+#include <apt-pkg/error.h>
+#include <apt-pkg/gpgv.h>
+#include <apt-pkg/hashes.h>
+#include <apt-pkg/srcrecords.h>
+#include <apt-pkg/strutl.h>
+#include <apt-pkg/tagfile-keys.h>
+#include <apt-pkg/tagfile.h>
+
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+									/*}}}*/
+
+using std::max;
+using std::string;
+
+debSrcRecordParser::debSrcRecordParser(std::string const &File,pkgIndexFile const *Index)
+   : Parser(Index), d(NULL), Tags(&Fd), iOffset(0), Buffer(NULL)
+{
+   if (File.empty() == false)
+   {
+      if (Fd.Open(File, FileFd::ReadOnly, FileFd::Extension))
+	 Tags.Init(&Fd, 102400);
+   }
+}
+std::string debSrcRecordParser::Package() const				/*{{{*/
+{
+   auto const name = Sect.Find(pkgTagSection::Key::Package);
+   if (iIndex != nullptr || name.empty() == false)
+      return name.to_string();
+   return Sect.Find(pkgTagSection::Key::Source).to_string();
+}
+									/*}}}*/
+// SrcRecordParser::Binaries - Return the binaries field		/*{{{*/
+// ---------------------------------------------------------------------
+/* This member parses the binaries field into a pair of class arrays and
+   returns a list of strings representing all of the components of the
+   binaries field. The returned array need not be freed and will be
+   reused by the next Binaries function call. This function is commonly
+   used during scanning to find the right package */
+const char **debSrcRecordParser::Binaries()
+{
+   const char *Start, *End;
+   if (Sect.Find(pkgTagSection::Key::Binary, Start, End) == false)
+      return NULL;
+   for (; isspace_ascii(*Start) != 0; ++Start);
+   if (Start >= End)
+      return NULL;
+
+   StaticBinList.clear();
+   free(Buffer);
+   Buffer = strndup(Start, End - Start);
+
+   char* bin = Buffer;
+   do {
+      char* binStartNext = strchrnul(bin, ',');
+      // Found a comma, clean up any space before it
+      if (binStartNext > Buffer) {
+	 char* binEnd = binStartNext - 1;
+	 for (; binEnd > Buffer && isspace_ascii(*binEnd) != 0; --binEnd)
+	    *binEnd = 0;
+      }
+      StaticBinList.push_back(bin);
+      if (*binStartNext != ',')
+	 break;
+      *binStartNext = '\0';
+      for (bin = binStartNext + 1; isspace_ascii(*bin) != 0; ++bin)
+         ;
+   } while (*bin != '\0');
+   StaticBinList.push_back(NULL);
+
+   return &StaticBinList[0];
+}
+									/*}}}*/
+// SrcRecordParser::BuildDepends - Return the Build-Depends information	/*{{{*/
+// ---------------------------------------------------------------------
+/* This member parses the build-depends information and returns a list of 
+   package/version records representing the build dependency. The returned 
+   array need not be freed and will be reused by the next call to this 
+   function */
+bool debSrcRecordParser::BuildDepends(std::vector<pkgSrcRecords::Parser::BuildDepRec> &BuildDeps,
+					bool const &ArchOnly, bool const &StripMultiArch)
+{
+   BuildDeps.clear();
+
+   pkgTagSection::Key const fields[] = {
+      pkgTagSection::Key::Build_Depends,
+      pkgTagSection::Key::Build_Depends_Indep,
+      pkgTagSection::Key::Build_Conflicts,
+      pkgTagSection::Key::Build_Conflicts_Indep,
+      pkgTagSection::Key::Build_Depends_Arch,
+      pkgTagSection::Key::Build_Conflicts_Arch,
+   };
+   for (unsigned short I = 0; I < sizeof(fields) / sizeof(fields[0]); ++I)
+   {
+      if (ArchOnly && (fields[I] == pkgTagSection::Key::Build_Depends_Indep || fields[I] == pkgTagSection::Key::Build_Conflicts_Indep))
+	 continue;
+
+      const char *Start, *Stop;
+      if (Sect.Find(fields[I], Start, Stop) == false)
+         continue;
+
+      if (Start == Stop)
+	 continue;
+
+      while (1)
+      {
+	 BuildDepRec rec;
+	 Start = debListParser::ParseDepends(Start, Stop,
+					     rec.Package, rec.Version, rec.Op, true, StripMultiArch, true);
+
+	 if (Start == 0)
+	    return _error->Error("Problem parsing dependency: %s", BuildDepType(I));
+	 rec.Type = I;
+
+	 // We parsed a package that was ignored (wrong architecture restriction
+	 // or something).
+	 if (rec.Package.empty())
+	 {
+	    // If we are in an OR group, we need to set the "Or" flag of the
+	    // previous entry to our value.
+	    if (BuildDeps.empty() == false && (BuildDeps[BuildDeps.size() - 1].Op & pkgCache::Dep::Or) == pkgCache::Dep::Or)
+	    {
+	       BuildDeps[BuildDeps.size() - 1].Op &= ~pkgCache::Dep::Or;
+	       BuildDeps[BuildDeps.size() - 1].Op |= (rec.Op & pkgCache::Dep::Or);
+	    }
+	 } else {
+	    BuildDeps.emplace_back(std::move(rec));
+	 }
+
+	 if (Start == Stop)
+	    break;
+      }
+   }
+
+   return true;
+}
+									/*}}}*/
+// SrcRecordParser::Files - Return a list of files for this source	/*{{{*/
+// ---------------------------------------------------------------------
+/* This parses the list of files and returns it, each file is required to have
+   a complete source package */
+bool debSrcRecordParser::Files(std::vector<pkgSrcRecords::File> &List)
+{
+   List.clear();
+
+   // Stash the / terminated directory prefix
+   std::string Base = Sect.Find(pkgTagSection::Key::Directory).to_string();
+   if (Base.empty() == false && Base[Base.length()-1] != '/')
+      Base += '/';
+
+   std::vector<std::string> const compExts = APT::Configuration::getCompressorExtensions();
+
+   for (char const * const * type = HashString::SupportedHashes(); *type != NULL; ++type)
+   {
+      // derive field from checksum type
+      std::string checksumField("Checksums-");
+      if (strcmp(*type, "MD5Sum") == 0)
+	 checksumField = "Files"; // historic name for MD5 checksums
+      else
+	 checksumField.append(*type);
+
+      string const Files = Sect.FindS(checksumField.c_str());
+      if (Files.empty() == true)
+	 continue;
+
+      // Iterate over the entire list grabbing each triplet
+      const char *C = Files.c_str();
+      while (*C != 0)
+      {
+	 string hash, size, path;
+
+	 // Parse each of the elements
+	 if (ParseQuoteWord(C, hash) == false ||
+	       ParseQuoteWord(C, size) == false ||
+	       ParseQuoteWord(C, path) == false)
+	    return _error->Error("Error parsing file record in %s of source package %s", checksumField.c_str(), Package().c_str());
+
+	 if (iIndex == nullptr && checksumField == "Files")
+	 {
+	    // the Files field has a different format than the rest in deb-changes files
+	    std::string ignore;
+	    if (ParseQuoteWord(C, ignore) == false ||
+		  ParseQuoteWord(C, path) == false)
+	       return _error->Error("Error parsing file record in %s of source package %s", checksumField.c_str(), Package().c_str());
+	 }
+
+	 HashString const hashString(*type, hash);
+	 if (Base.empty() == false)
+	    path = Base + path;
+
+	 // look if we have a record for this file already
+	 std::vector<pkgSrcRecords::File>::iterator file = List.begin();
+	 for (; file != List.end(); ++file)
+	    if (file->Path == path)
+	       break;
+
+	 // we have it already, store the new hash and be done
+	 if (file != List.end())
+	 {
+	    // an error here indicates that we have two different hashes for the same file
+	    if (file->Hashes.push_back(hashString) == false)
+	       return _error->Error("Error parsing checksum in %s of source package %s", checksumField.c_str(), Package().c_str());
+	    continue;
+	 }
+
+	 // we haven't seen this file yet
+	 pkgSrcRecords::File F;
+	 F.Path = path;
+	 F.FileSize = strtoull(size.c_str(), NULL, 10);
+	 F.Hashes.push_back(hashString);
+	 F.Hashes.FileSize(F.FileSize);
+
+	 // Try to guess what sort of file it is we are getting.
+	 string::size_type Pos = F.Path.length()-1;
+	 while (1)
+	 {
+	    string::size_type Tmp = F.Path.rfind('.',Pos);
+	    if (Tmp == string::npos)
+	       break;
+	    if (F.Type == "tar") {
+	       // source v3 has extension 'debian.tar.*' instead of 'diff.*'
+	       if (string(F.Path, Tmp+1, Pos-Tmp) == "debian")
+		  F.Type = "diff";
+	       break;
+	    }
+	    F.Type = string(F.Path,Tmp+1,Pos-Tmp);
+
+	    if (std::find(compExts.begin(), compExts.end(), std::string(".").append(F.Type)) != compExts.end() ||
+		  F.Type == "tar")
+	    {
+	       Pos = Tmp-1;
+	       continue;
+	    }
+
+	    break;
+	 }
+	 List.push_back(F);
+      }
+   }
+
+   return true;
+}
+									/*}}}*/
+// SrcRecordParser::~SrcRecordParser - Destructor			/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+debSrcRecordParser::~debSrcRecordParser()
+{
+   // was allocated via strndup()
+   free(Buffer);
+}
+									/*}}}*/
+
+
+debDscRecordParser::debDscRecordParser(std::string const &DscFile, pkgIndexFile const *Index)
+   : debSrcRecordParser("", Index)
+{
+   // support clear signed files
+   if (OpenMaybeClearSignedFile(DscFile, Fd) == false)
+   {
+      _error->Error("Failed to open %s", DscFile.c_str());
+      return;
+   }
+
+   // re-init to ensure the updated Fd is used
+   Tags.Init(&Fd, pkgTagFile::SUPPORT_COMMENTS);
+   // read the first (and only) record
+   Step();
+
+}
diff --git a/apt-pkg/deb/debsrcrecords.h b/apt-pkg/deb/debsrcrecords.h
new file mode 100644
index 0000000..b572d34
--- /dev/null
+++ b/apt-pkg/deb/debsrcrecords.h
@@ -0,0 +1,67 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+   
+   Debian Source Package Records - Parser implementation for Debian style
+                                   source indexes
+   
+   ##################################################################### */
+									/*}}}*/
+#ifndef PKGLIB_DEBSRCRECORDS_H
+#define PKGLIB_DEBSRCRECORDS_H
+
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/srcrecords.h>
+#include <apt-pkg/tagfile.h>
+
+#include <string>
+#include <vector>
+#include <stddef.h>
+
+class pkgIndexFile;
+
+class APT_HIDDEN debSrcRecordParser : public pkgSrcRecords::Parser
+{
+   /** \brief dpointer placeholder (for later in case we need it) */
+   void * const d;
+
+ protected:
+   FileFd Fd;
+   pkgTagFile Tags;
+   pkgTagSection Sect;
+   std::vector<const char*> StaticBinList;
+   unsigned long iOffset;
+   char *Buffer;
+   
+   public:
+
+   virtual bool Restart() APT_OVERRIDE {return Jump(0);};
+   virtual bool Step() APT_OVERRIDE {iOffset = Tags.Offset(); return Tags.Step(Sect);};
+   virtual bool Jump(unsigned long const &Off) APT_OVERRIDE {iOffset = Off; return Tags.Jump(Sect,Off);};
+
+   virtual std::string Package() const APT_OVERRIDE;
+   virtual std::string Version() const APT_OVERRIDE {return Sect.FindS("Version");};
+   virtual std::string Maintainer() const APT_OVERRIDE {return Sect.FindS("Maintainer");};
+   virtual std::string Section() const APT_OVERRIDE {return Sect.FindS("Section");};
+   virtual const char **Binaries() APT_OVERRIDE;
+   virtual bool BuildDepends(std::vector<BuildDepRec> &BuildDeps, bool const &ArchOnly, bool const &StripMultiArch = true) APT_OVERRIDE;
+   virtual unsigned long Offset() APT_OVERRIDE {return iOffset;};
+   virtual std::string AsStr() APT_OVERRIDE 
+   {
+      const char *Start=0,*Stop=0;
+      Sect.GetSection(Start,Stop);
+      return std::string(Start,Stop);
+   };
+   virtual bool Files(std::vector<pkgSrcRecords::File> &F) APT_OVERRIDE;
+
+   debSrcRecordParser(std::string const &File,pkgIndexFile const *Index);
+   virtual ~debSrcRecordParser();
+};
+
+class APT_HIDDEN debDscRecordParser : public debSrcRecordParser
+{
+ public:
+   debDscRecordParser(std::string const &DscFile, pkgIndexFile const *Index);
+};
+
+#endif
diff --git a/apt-pkg/deb/debsystem.cc b/apt-pkg/deb/debsystem.cc
new file mode 100644
index 0000000..a020030
--- /dev/null
+++ b/apt-pkg/deb/debsystem.cc
@@ -0,0 +1,535 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+
+   System - Abstraction for running on different systems.
+
+   Basic general structure..
+   
+   ##################################################################### */
+									/*}}}*/
+// Include Files							/*{{{*/
+#include <config.h>
+
+#include <apt-pkg/configuration.h>
+#include <apt-pkg/debindexfile.h>
+#include <apt-pkg/debsystem.h>
+#include <apt-pkg/debversion.h>
+#include <apt-pkg/dpkgpm.h>
+#include <apt-pkg/error.h>
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/progress.h>
+
+#include <algorithm>
+#include <sstream>
+
+#include <string>
+#include <vector>
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include <apti18n.h>
+									/*}}}*/
+
+using std::string;
+
+debSystem debSys;
+
+class APT_HIDDEN debSystemPrivate {
+public:
+   debSystemPrivate() : FrontendLockFD(-1), LockFD(-1), LockCount(0), StatusFile(0)
+   {
+   }
+   // For locking support
+   int FrontendLockFD;
+   int LockFD;
+   unsigned LockCount;
+   
+   debStatusIndex *StatusFile;
+};
+
+// System::debSystem - Constructor					/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+debSystem::debSystem() : pkgSystem("Debian dpkg interface", &debVS), d(new debSystemPrivate())
+{
+}
+									/*}}}*/
+// System::~debSystem - Destructor					/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+debSystem::~debSystem()
+{
+   delete d->StatusFile;
+   delete d;
+}
+									/*}}}*/
+// System::Lock - Get the lock						/*{{{*/
+// ---------------------------------------------------------------------
+/* This mirrors the operations dpkg does when it starts up. Note the
+   checking of the updates directory. */
+static int GetLockMaybeWait(std::string const &file, OpProgress *Progress, int &timeoutSec)
+{
+   struct ScopedAbsoluteProgress
+   {
+      ScopedAbsoluteProgress() { _config->Set("APT::Internal::OpProgress::Absolute", true); }
+      ~ScopedAbsoluteProgress() { _config->Set("APT::Internal::OpProgress::Absolute", false); }
+   } _scopedAbsoluteProgress;
+   int fd = -1;
+   if (timeoutSec == 0 || Progress == nullptr)
+      return GetLock(file);
+
+   if (_config->FindB("Debug::Locking", false))
+      std::cerr << "Lock: " << file << " wait " << timeoutSec << std::endl;
+
+   for (int i = 0; timeoutSec < 0 || i < timeoutSec; i++)
+   {
+      _error->PushToStack();
+      fd = GetLock(file);
+      if (fd != -1 || errno == EPERM)
+      {
+	 if (timeoutSec > 0)
+	    timeoutSec -= i;
+	 _error->MergeWithStack();
+	 return fd;
+      }
+      std::string poppedError;
+      std::string completeError;
+      _error->PopMessage(poppedError);
+      _error->RevertToStack();
+
+      strprintf(completeError, _("Waiting for cache lock: %s"), poppedError.c_str());
+      sleep(1);
+      Progress->OverallProgress(i, timeoutSec, 0, completeError);
+   }
+
+   if (timeoutSec > 0)
+      timeoutSec = 1;
+   return fd;
+}
+
+bool debSystem::Lock(OpProgress *const Progress)
+{
+   // Disable file locking
+   if (_config->FindB("Debug::NoLocking",false) == true || d->LockCount > 0)
+   {
+      d->LockCount++;
+      return true;
+   }
+
+   // This will count downwards.
+   int lockTimeOutSec = _config->FindI("DPkg::Lock::Timeout", 0);
+   // Create the lockfile
+   string AdminDir = flNotFile(_config->FindFile("Dir::State::status"));
+   string FrontendLockFile = AdminDir + "lock-frontend";
+   d->FrontendLockFD = GetLockMaybeWait(FrontendLockFile, Progress, lockTimeOutSec);
+   if (d->FrontendLockFD == -1)
+   {
+      if (errno == EACCES || errno == EAGAIN)
+	 return _error->Error(_("Unable to acquire the dpkg frontend lock (%s), "
+	                        "is another process using it?"),FrontendLockFile.c_str());
+      else
+	 return _error->Error(_("Unable to acquire the dpkg frontend lock (%s), "
+	                        "are you root?"),FrontendLockFile.c_str());
+   }
+   if (LockInner(Progress, lockTimeOutSec) == false)
+   {
+      close(d->FrontendLockFD);
+      return false;
+   }
+   
+   // See if we need to abort with a dirty journal
+   if (CheckUpdates() == true)
+   {
+      close(d->LockFD);
+      close(d->FrontendLockFD);
+      d->FrontendLockFD = -1;
+      d->LockFD = -1;
+      const char *cmd;
+      if (getenv("SUDO_USER") != NULL)
+	 cmd = "sudo dpkg --configure -a";
+      else
+	 cmd = "dpkg --configure -a";
+      // TRANSLATORS: the %s contains the recovery command, usually
+      //              dpkg --configure -a
+      return _error->Error(_("dpkg was interrupted, you must manually "
+                             "run '%s' to correct the problem. "), cmd);
+   }
+
+	 d->LockCount++;
+      
+   return true;
+}
+
+bool debSystem::LockInner(OpProgress *const Progress, int timeOutSec)
+{
+   string AdminDir = flNotFile(_config->FindFile("Dir::State::status"));
+   d->LockFD = GetLockMaybeWait(AdminDir + "lock", Progress, timeOutSec);
+   if (d->LockFD == -1)
+   {
+      if (errno == EACCES || errno == EAGAIN)
+	 return _error->Error(_("Unable to lock the administration directory (%s), "
+	                        "is another process using it?"),AdminDir.c_str());
+      else
+	 return _error->Error(_("Unable to lock the administration directory (%s), "
+	                        "are you root?"),AdminDir.c_str());
+   }
+   return true;
+}
+									/*}}}*/
+// System::UnLock - Drop a lock						/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool debSystem::UnLock(bool NoErrors)
+{
+   if (d->LockCount == 0 && NoErrors == true)
+      return false;
+   
+   if (d->LockCount < 1)
+      return _error->Error(_("Not locked"));
+   if (--d->LockCount == 0)
+   {
+      close(d->LockFD);
+      close(d->FrontendLockFD);
+      d->LockCount = 0;
+   }
+   
+   return true;
+}
+bool debSystem::UnLockInner(bool NoErrors) {
+   (void) NoErrors;
+   close(d->LockFD);
+   return true;
+}
+									/*}}}*/
+// System::IsLocked - Check if system is locked						/*{{{*/
+// ---------------------------------------------------------------------
+/* This checks if the frontend lock is hold. The inner lock might be
+ * released. */
+bool debSystem::IsLocked()
+{
+   return d->LockCount > 0;
+}
+									/*}}}*/
+// System::CheckUpdates - Check if the updates dir is dirty		/*{{{*/
+// ---------------------------------------------------------------------
+/* This does a check of the updates directory (dpkg journal) to see if it has 
+   any entries in it. */
+bool debSystem::CheckUpdates()
+{
+   // Check for updates.. (dirty)
+   string File = flNotFile(_config->FindFile("Dir::State::status")) + "updates/";
+   DIR *DirP = opendir(File.c_str());
+   if (DirP == 0)
+      return false;
+   
+   /* We ignore any files that are not all digits, this skips .,.. and 
+      some tmp files dpkg will leave behind.. */
+   bool Damaged = false;
+   for (struct dirent *Ent = readdir(DirP); Ent != 0; Ent = readdir(DirP))
+   {
+      Damaged = true;
+      for (unsigned int I = 0; Ent->d_name[I] != 0; I++)
+      {
+	 // Check if its not a digit..
+	 if (isdigit(Ent->d_name[I]) == 0)
+	 {
+	    Damaged = false;
+	    break;
+	 }
+      }
+      if (Damaged == true)
+	 break;
+   }
+   closedir(DirP);
+
+   return Damaged;
+}
+									/*}}}*/
+// System::CreatePM - Create the underlying package manager		/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+pkgPackageManager *debSystem::CreatePM(pkgDepCache *Cache) const
+{
+   return new pkgDPkgPM(Cache);
+}
+									/*}}}*/
+// System::Initialize - Setup the configuration space..			/*{{{*/
+// ---------------------------------------------------------------------
+/* These are the Debian specific configuration variables.. */
+static std::string getDpkgStatusLocation(Configuration const &Cnf) {
+   Configuration PathCnf;
+   PathCnf.Set("Dir", Cnf.Find("Dir", "/"));
+   PathCnf.Set("Dir::State::status", "status");
+   auto const cnfstatedir = Cnf.Find("Dir::State", &STATE_DIR[1]);
+   // if the state dir ends in apt, replace it with dpkg -
+   // for the default this gives us the same as the fallback below.
+   // This can't be a ../dpkg as that would play bad with symlinks
+   std::string statedir;
+   if (APT::String::Endswith(cnfstatedir, "/apt/"))
+      statedir.assign(cnfstatedir, 0, cnfstatedir.length() - 5);
+   else if (APT::String::Endswith(cnfstatedir, "/apt"))
+      statedir.assign(cnfstatedir, 0, cnfstatedir.length() - 4);
+   if (statedir.empty())
+      PathCnf.Set("Dir::State", "var/lib/dpkg");
+   else
+      PathCnf.Set("Dir::State", flCombine(statedir, "dpkg"));
+   return PathCnf.FindFile("Dir::State::status");
+}
+bool debSystem::Initialize(Configuration &Cnf)
+{
+   /* These really should be jammed into a generic 'Local Database' engine
+      which is yet to be determined. The functions in pkgcachegen should
+      be the only users of these */
+   Cnf.CndSet("Dir::State::extended_states", "extended_states");
+   if (Cnf.Exists("Dir::State::status") == false)
+      Cnf.Set("Dir::State::status", getDpkgStatusLocation(Cnf));
+   Cnf.CndSet("Dir::Bin::dpkg",BIN_DIR"/dpkg");
+
+   if (d->StatusFile) {
+     delete d->StatusFile;
+     d->StatusFile = 0;
+   }
+
+   return true;
+}
+									/*}}}*/
+// System::ArchiveSupported - Is a file format supported		/*{{{*/
+// ---------------------------------------------------------------------
+/* The standard name for a deb is 'deb'.. There are no separate versions
+   of .deb to worry about.. */
+APT_PURE bool debSystem::ArchiveSupported(const char *Type)
+{
+   if (strcmp(Type,"deb") == 0)
+      return true;
+   return false;
+}
+									/*}}}*/
+// System::Score - Determine how 'Debiany' this sys is..		/*{{{*/
+// ---------------------------------------------------------------------
+/* We check some files that are sure tell signs of this being a Debian
+   System.. */
+signed debSystem::Score(Configuration const &Cnf)
+{
+   signed Score = 0;
+   if (FileExists(Cnf.FindFile("Dir::State::status",getDpkgStatusLocation(Cnf).c_str())) == true)
+       Score += 10;
+   if (FileExists(Cnf.Find("Dir::Bin::dpkg",BIN_DIR"/dpkg")) == true)
+      Score += 10;
+   if (FileExists("/etc/debian_version") == true)
+      Score += 10;
+   return Score;
+}
+									/*}}}*/
+// System::AddStatusFiles - Register the status files			/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool debSystem::AddStatusFiles(std::vector<pkgIndexFile *> &List)
+{
+   if (d->StatusFile == 0)
+      d->StatusFile = new debStatusIndex(_config->FindFile("Dir::State::status"));
+   List.push_back(d->StatusFile);
+   return true;
+}
+									/*}}}*/
+// System::FindIndex - Get an index file for status files		/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool debSystem::FindIndex(pkgCache::PkgFileIterator File,
+			  pkgIndexFile *&Found) const
+{
+   if (d->StatusFile == 0)
+      return false;
+   if (d->StatusFile->FindInCache(*File.Cache()) == File)
+   {
+      Found = d->StatusFile;
+      return true;
+   }
+   
+   return false;
+}
+									/*}}}*/
+
+std::string debSystem::GetDpkgExecutable()				/*{{{*/
+{
+   string Tmp = _config->Find("Dir::Bin::dpkg","dpkg");
+   string const dpkgChrootDir = _config->FindDir("DPkg::Chroot-Directory", "/");
+   size_t dpkgChrootLen = dpkgChrootDir.length();
+   if (dpkgChrootDir != "/" && Tmp.find(dpkgChrootDir) == 0)
+   {
+      if (dpkgChrootDir[dpkgChrootLen - 1] == '/')
+         --dpkgChrootLen;
+      Tmp = Tmp.substr(dpkgChrootLen);
+   }
+   return Tmp;
+}
+									/*}}}*/
+std::vector<std::string> debSystem::GetDpkgBaseCommand()		/*{{{*/
+{
+   // Generate the base argument list for dpkg
+   std::vector<std::string> Args = { GetDpkgExecutable() };
+   // Stick in any custom dpkg options
+   Configuration::Item const *Opts = _config->Tree("DPkg::Options");
+   if (Opts != 0)
+   {
+      Opts = Opts->Child;
+      for (; Opts != 0; Opts = Opts->Next)
+      {
+	 if (Opts->Value.empty() == true)
+	    continue;
+	 Args.push_back(Opts->Value);
+      }
+   }
+   return Args;
+}
+									/*}}}*/
+void debSystem::DpkgChrootDirectory()					/*{{{*/
+{
+   std::string const chrootDir = _config->FindDir("DPkg::Chroot-Directory");
+   if (chrootDir == "/")
+      return;
+   std::cerr << "Chrooting into " << chrootDir << std::endl;
+   if (chroot(chrootDir.c_str()) != 0)
+      _exit(100);
+   if (chdir("/") != 0)
+      _exit(100);
+}
+									/*}}}*/
+pid_t debSystem::ExecDpkg(std::vector<std::string> const &sArgs, int * const inputFd, int * const outputFd, bool const DiscardOutput)/*{{{*/
+{
+   std::vector<const char *> Args(sArgs.size(), NULL);
+   std::transform(sArgs.begin(), sArgs.end(), Args.begin(), [](std::string const &s) { return s.c_str(); });
+   Args.push_back(NULL);
+
+   int external[2] = {-1, -1};
+   if (inputFd != nullptr || outputFd != nullptr)
+      if (pipe(external) != 0)
+      {
+	 _error->WarningE("dpkg", "Can't create IPC pipe for dpkg call");
+	 return -1;
+      }
+
+   pid_t const dpkg = ExecFork();
+   if (dpkg == 0) {
+      int const nullfd = open("/dev/null", O_RDWR);
+      if (inputFd == nullptr)
+	 dup2(nullfd, STDIN_FILENO);
+      else
+      {
+	 close(external[1]);
+	 dup2(external[0], STDIN_FILENO);
+      }
+      if (outputFd == nullptr)
+	 dup2(nullfd, STDOUT_FILENO);
+      else
+      {
+	 close(external[0]);
+	 dup2(external[1], STDOUT_FILENO);
+      }
+      if (DiscardOutput == true)
+	 dup2(nullfd, STDERR_FILENO);
+      debSystem::DpkgChrootDirectory();
+
+      if (_system != nullptr && _system->IsLocked() == true)
+      {
+	 setenv("DPKG_FRONTEND_LOCKED", "true", 1);
+      }
+
+      if (_config->Find("DPkg::Path", "").empty() == false)
+	 setenv("PATH", _config->Find("DPkg::Path", "").c_str(), 1);
+
+      execvp(Args[0], (char**) &Args[0]);
+      _error->WarningE("dpkg", "Can't execute dpkg!");
+      _exit(100);
+   }
+   if (outputFd != nullptr)
+   {
+      close(external[1]);
+      *outputFd = external[0];
+   }
+   else if (inputFd != nullptr)
+   {
+      close(external[0]);
+      *inputFd = external[1];
+   }
+   return dpkg;
+}
+									/*}}}*/
+bool debSystem::MultiArchSupported() const					/*{{{*/
+{
+   return AssertFeature("multi-arch");
+}
+									/*}}}*/
+bool debSystem::AssertFeature(std::string const &feature) /*{{{*/
+{
+   std::vector<std::string> Args = GetDpkgBaseCommand();
+   Args.push_back("--assert-" + feature);
+   pid_t const dpkgAssertMultiArch = ExecDpkg(Args, nullptr, nullptr, true);
+   if (dpkgAssertMultiArch > 0)
+   {
+      int Status = 0;
+      while (waitpid(dpkgAssertMultiArch, &Status, 0) != dpkgAssertMultiArch)
+      {
+	 if (errno == EINTR)
+	    continue;
+	 _error->WarningE("dpkgGo", _("Waited for %s but it wasn't there"), "dpkg --assert-multi-arch");
+	 break;
+      }
+      if (WIFEXITED(Status) == true && WEXITSTATUS(Status) == 0)
+	 return true;
+   }
+   return false;
+}
+									/*}}}*/
+std::vector<std::string> debSystem::ArchitecturesSupported() const		/*{{{*/
+{
+   std::vector<std::string> archs;
+   {
+      string const arch = _config->Find("APT::Architecture");
+      if (arch.empty() == false)
+	 archs.push_back(std::move(arch));
+   }
+
+   std::vector<std::string> sArgs = GetDpkgBaseCommand();
+   sArgs.push_back("--print-foreign-architectures");
+   int outputFd = -1;
+   pid_t const dpkgMultiArch = ExecDpkg(sArgs, nullptr, &outputFd, true);
+   if (dpkgMultiArch == -1)
+      return archs;
+
+   FILE *dpkg = fdopen(outputFd, "r");
+   if(dpkg != NULL) {
+      char* buf = NULL;
+      size_t bufsize = 0;
+      while (getline(&buf, &bufsize, dpkg) != -1)
+      {
+	 char* tok_saveptr;
+	 char* arch = strtok_r(buf, " ", &tok_saveptr);
+	 while (arch != NULL) {
+	    for (; isspace_ascii(*arch) != 0; ++arch);
+	    if (arch[0] != '\0') {
+	       char const* archend = arch;
+	       for (; isspace_ascii(*archend) == 0 && *archend != '\0'; ++archend);
+	       string a(arch, (archend - arch));
+	       if (std::find(archs.begin(), archs.end(), a) == archs.end())
+		  archs.push_back(a);
+	    }
+	    arch = strtok_r(NULL, " ", &tok_saveptr);
+	 }
+      }
+      free(buf);
+      fclose(dpkg);
+   }
+   ExecWait(dpkgMultiArch, "dpkg --print-foreign-architectures", true);
+   return archs;
+}
+									/*}}}*/
diff --git a/apt-pkg/deb/debsystem.h b/apt-pkg/deb/debsystem.h
new file mode 100644
index 0000000..b3d2415
--- /dev/null
+++ b/apt-pkg/deb/debsystem.h
@@ -0,0 +1,58 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+
+   System - Debian version of the  System Class
+
+   ##################################################################### */
+									/*}}}*/
+#ifndef PKGLIB_DEBSYSTEM_H
+#define PKGLIB_DEBSYSTEM_H
+
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/pkgsystem.h>
+
+#include <vector>
+class Configuration;
+class pkgIndexFile;
+class pkgPackageManager;
+class debSystemPrivate;
+class pkgDepCache;
+
+
+class debSystem : public pkgSystem
+{
+   // private d-pointer
+   debSystemPrivate * const d;
+   APT_HIDDEN bool CheckUpdates();
+
+   public:
+   virtual bool Lock(OpProgress *const Progress) APT_OVERRIDE;
+   virtual bool UnLock(bool NoErrors = false) APT_OVERRIDE;
+   virtual pkgPackageManager *CreatePM(pkgDepCache *Cache) const APT_OVERRIDE;
+   virtual bool Initialize(Configuration &Cnf) APT_OVERRIDE;
+   virtual bool ArchiveSupported(const char *Type) APT_OVERRIDE;
+   virtual signed Score(Configuration const &Cnf) APT_OVERRIDE;
+   virtual bool AddStatusFiles(std::vector<pkgIndexFile *> &List) APT_OVERRIDE;
+   virtual bool FindIndex(pkgCache::PkgFileIterator File,
+			  pkgIndexFile *&Found) const APT_OVERRIDE;
+
+   debSystem();
+   virtual ~debSystem();
+
+   APT_HIDDEN static std::string GetDpkgExecutable();
+   APT_HIDDEN static std::vector<std::string> GetDpkgBaseCommand();
+   APT_HIDDEN static void DpkgChrootDirectory();
+   APT_HIDDEN static pid_t ExecDpkg(std::vector<std::string> const &sArgs, int * const inputFd, int * const outputFd, bool const DiscardOutput);
+   bool MultiArchSupported() const override;
+   static bool AssertFeature(std::string const &Feature);
+   std::vector<std::string> ArchitecturesSupported() const override;
+
+   bool LockInner(OpProgress *const Progress, int timeoutSec) override;
+   bool UnLockInner(bool NoErrors=false) override;
+   bool IsLocked() override;
+};
+
+extern debSystem debSys;
+
+#endif
diff --git a/apt-pkg/deb/debversion.cc b/apt-pkg/deb/debversion.cc
new file mode 100644
index 0000000..d2ebd28
--- /dev/null
+++ b/apt-pkg/deb/debversion.cc
@@ -0,0 +1,279 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+
+   Debian Version - Versioning system for Debian
+
+   This implements the standard Debian versioning system.
+   
+   ##################################################################### */
+									/*}}}*/
+// Include Files							/*{{{*/
+#include <config.h>
+
+#include <apt-pkg/debversion.h>
+#include <apt-pkg/pkgcache.h>
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+									/*}}}*/
+
+debVersioningSystem debVS;
+
+// debVS::debVersioningSystem - Constructor				/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+debVersioningSystem::debVersioningSystem()
+{
+   Label = "Standard .deb";
+}
+									/*}}}*/
+
+// debVS::CmpFragment - Compare versions			        /*{{{*/
+// ---------------------------------------------------------------------
+/* This compares a fragment of the version. This is a slightly adapted
+   version of what dpkg uses in dpkg/lib/dpkg/version.c.
+   In particular, the a | b = NULL check is removed as we check this in the
+   caller, we use an explicit end for a | b strings and we check ~ explicit. */
+static int order(char c)
+{
+   if (isdigit(c))
+      return 0;
+   else if (isalpha(c))
+      return c;
+   else if (c == '~')
+      return -1;
+   else if (c)
+      return c + 256;
+   else
+      return 0;
+}
+int debVersioningSystem::CmpFragment(const char *A,const char *AEnd,
+				     const char *B,const char *BEnd)
+{
+   /* Iterate over the whole string
+      What this does is to split the whole string into groups of
+      numeric and non numeric portions. For instance:
+         a67bhgs89
+      Has 4 portions 'a', '67', 'bhgs', '89'. A more normal:
+         2.7.2-linux-1
+      Has '2', '.', '7', '.' ,'-linux-','1' */
+   const char *lhs = A;
+   const char *rhs = B;
+   while (lhs != AEnd && rhs != BEnd)
+   {
+      int first_diff = 0;
+
+      while (lhs != AEnd && rhs != BEnd &&
+	     (!isdigit(*lhs) || !isdigit(*rhs)))
+      {
+	 int vc = order(*lhs);
+	 int rc = order(*rhs);
+	 if (vc != rc)
+	    return vc - rc;
+	 ++lhs; ++rhs;
+      }
+
+      while (*lhs == '0')
+	 ++lhs;
+      while (*rhs == '0')
+	 ++rhs;
+      while (isdigit(*lhs) && isdigit(*rhs))
+      {
+	 if (!first_diff)
+	    first_diff = *lhs - *rhs;
+	 ++lhs;
+	 ++rhs;
+      }
+
+      if (isdigit(*lhs))
+	 return 1;
+      if (isdigit(*rhs))
+	 return -1;
+      if (first_diff)
+	 return first_diff;
+   }
+
+   // The strings must be equal
+   if (lhs == AEnd && rhs == BEnd)
+      return 0;
+
+   // lhs is shorter
+   if (lhs == AEnd)
+   {
+      if (*rhs == '~') return 1;
+      return -1;
+   }
+
+   // rhs is shorter
+   if (rhs == BEnd)
+   {
+      if (*lhs == '~') return -1;
+      return 1;
+   }
+
+   // Shouldn't happen
+   return 1;
+}
+									/*}}}*/
+// debVS::CmpVersion - Comparison for versions				/*{{{*/
+// ---------------------------------------------------------------------
+/* This fragments the version into E:V-R triples and compares each 
+   portion separately. */
+int debVersioningSystem::DoCmpVersion(const char *A,const char *AEnd,
+				      const char *B,const char *BEnd)
+{
+   // Strip off the epoch and compare it
+   const char *lhs = (const char*) memchr(A, ':', AEnd - A);
+   const char *rhs = (const char*) memchr(B, ':', BEnd - B);
+   if (lhs == NULL)
+      lhs = A;
+   if (rhs == NULL)
+      rhs = B;
+   
+   // Special case: a zero epoch is the same as no epoch,
+   // so remove it.
+   if (lhs != A)
+   {
+      for (; *A == '0'; ++A);
+      if (A == lhs)
+      {
+	 ++A;
+	 ++lhs;
+      }
+   }
+   if (rhs != B)
+   {
+      for (; *B == '0'; ++B);
+      if (B == rhs)
+      {
+	 ++B;
+	 ++rhs;
+      }
+   }
+
+   // Compare the epoch
+   int Res = CmpFragment(A,lhs,B,rhs);
+   if (Res != 0)
+      return Res;
+
+   // Skip the :
+   if (lhs != A)
+      lhs++;
+   if (rhs != B)
+      rhs++;
+   
+   // Find the last -
+   const char *dlhs = (const char*) memrchr(lhs, '-', AEnd - lhs);
+   const char *drhs = (const char*) memrchr(rhs, '-', BEnd - rhs);
+   if (dlhs == NULL)
+      dlhs = AEnd;
+   if (drhs == NULL)
+      drhs = BEnd;
+   
+   // Compare the main version
+   Res = CmpFragment(lhs,dlhs,rhs,drhs);
+   if (Res != 0)
+      return Res;
+   
+   // Skip the -
+   if (dlhs != lhs)
+      dlhs++;
+   if (drhs != rhs)
+      drhs++;
+
+   // no debian revision need to be treated like -0
+   if (*(dlhs-1) == '-' && *(drhs-1) == '-')
+      return CmpFragment(dlhs,AEnd,drhs,BEnd);
+   else if (*(dlhs-1) == '-')
+   {
+      const char* null = "0";
+      return CmpFragment(dlhs,AEnd,null, null+1);
+   }
+   else if (*(drhs-1) == '-')
+   {
+      const char* null = "0";
+      return CmpFragment(null, null+1, drhs, BEnd);
+   }
+   else
+      return 0;
+}
+									/*}}}*/
+// debVS::CheckDep - Check a single dependency				/*{{{*/
+// ---------------------------------------------------------------------
+/* This simply performs the version comparison and switch based on 
+   operator. If DepVer is 0 then we are comparing against a provides
+   with no version. */
+bool debVersioningSystem::CheckDep(const char *PkgVer,
+				   int Op,const char *DepVer)
+{
+   if (DepVer == 0 || DepVer[0] == 0)
+      return true;
+   if (PkgVer == 0 || PkgVer[0] == 0)
+      return false;
+   Op &= 0x0F;
+
+   // fast track for (equal) strings [by location] which are by definition equal versions
+   if (PkgVer == DepVer)
+      return Op == pkgCache::Dep::Equals || Op == pkgCache::Dep::LessEq || Op == pkgCache::Dep::GreaterEq;
+
+   // Perform the actual comparison.
+   int const Res = CmpVersion(PkgVer, DepVer);
+   switch (Op)
+   {
+      case pkgCache::Dep::LessEq:
+      if (Res <= 0)
+	 return true;
+      break;
+      
+      case pkgCache::Dep::GreaterEq:
+      if (Res >= 0)
+	 return true;
+      break;
+      
+      case pkgCache::Dep::Less:
+      if (Res < 0)
+	 return true;
+      break;
+      
+      case pkgCache::Dep::Greater:
+      if (Res > 0)
+	 return true;
+      break;
+      
+      case pkgCache::Dep::Equals:
+      if (Res == 0)
+	 return true;
+      break;
+      
+      case pkgCache::Dep::NotEquals:
+      if (Res != 0)
+	 return true;
+      break;
+   }
+
+   return false;
+}
+									/*}}}*/
+// debVS::UpstreamVersion - Return the upstream version string		/*{{{*/
+// ---------------------------------------------------------------------
+/* This strips all the debian specific information from the version number */
+std::string debVersioningSystem::UpstreamVersion(const char *Ver)
+{
+   // Strip off the bit before the first colon
+   const char *I = Ver;
+   for (; *I != 0 && *I != ':'; I++);
+   if (*I == ':')
+      Ver = I + 1;
+   
+   // Chop off the trailing -
+   I = Ver;
+   unsigned Last = strlen(Ver);
+   for (; *I != 0; I++)
+      if (*I == '-')
+	 Last = I - Ver;
+   
+   return std::string(Ver,Last);
+}
+									/*}}}*/
diff --git a/apt-pkg/deb/debversion.h b/apt-pkg/deb/debversion.h
new file mode 100644
index 0000000..5c328a9
--- /dev/null
+++ b/apt-pkg/deb/debversion.h
@@ -0,0 +1,41 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+
+   Debian Version - Versioning system for Debian
+
+   This implements the standard Debian versioning system.
+   
+   ##################################################################### */
+									/*}}}*/
+#ifndef PKGLIB_DEBVERSION_H
+#define PKGLIB_DEBVERSION_H
+
+#include <apt-pkg/version.h>
+
+#include <string>
+
+class APT_PUBLIC debVersioningSystem : public pkgVersioningSystem
+{
+   public:
+
+   static int CmpFragment(const char *A, const char *AEnd, const char *B,
+			  const char *BEnd) APT_PURE;
+
+   // Compare versions..
+   virtual int DoCmpVersion(const char *A,const char *Aend,
+			  const char *B,const char *Bend) APT_OVERRIDE APT_PURE;
+   virtual bool CheckDep(const char *PkgVer,int Op,const char *DepVer) APT_OVERRIDE APT_PURE;
+   virtual APT_PURE int DoCmpReleaseVer(const char *A,const char *Aend,
+			     const char *B,const char *Bend) APT_OVERRIDE
+   {
+      return DoCmpVersion(A,Aend,B,Bend);
+   }
+   virtual std::string UpstreamVersion(const char *A) APT_OVERRIDE;
+
+   debVersioningSystem();
+};
+
+extern APT_PUBLIC debVersioningSystem debVS;
+
+#endif
diff --git a/apt-pkg/deb/dpkgpm.cc b/apt-pkg/deb/dpkgpm.cc
new file mode 100644
index 0000000..46a6dee
--- /dev/null
+++ b/apt-pkg/deb/dpkgpm.cc
@@ -0,0 +1,2493 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+
+   DPKG Package Manager - Provide an interface to dpkg
+
+   ##################################################################### */
+									/*}}}*/
+// Includes								/*{{{*/
+#include <config.h>
+
+#include <apt-pkg/cachefile.h>
+#include <apt-pkg/configuration.h>
+#include <apt-pkg/debsystem.h>
+#include <apt-pkg/depcache.h>
+#include <apt-pkg/dpkgpm.h>
+#include <apt-pkg/error.h>
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/install-progress.h>
+#include <apt-pkg/macros.h>
+#include <apt-pkg/packagemanager.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/statechanges.h>
+#include <apt-pkg/strutl.h>
+#include <apt-pkg/version.h>
+
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <grp.h>
+#include <pwd.h>
+#include <signal.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <sys/select.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <termios.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include <iostream>
+#include <map>
+#include <numeric>
+#include <set>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include <apti18n.h>
+									/*}}}*/
+
+extern char **environ;
+
+using namespace std;
+
+APT_PURE static string AptHistoryRequestingUser()			/*{{{*/
+{
+   const char* EnvKeys[]{"SUDO_UID", "PKEXEC_UID", "PACKAGEKIT_CALLER_UID"};
+
+   for (const auto &Key: EnvKeys)
+   {
+      if (getenv(Key) != nullptr)
+      {
+         int uid = atoi(getenv(Key));
+         if (uid > 0) {
+            struct passwd pwd;
+            struct passwd *result;
+            char buf[255];
+            if (getpwuid_r(uid, &pwd, buf, sizeof(buf), &result) == 0 && result != NULL) {
+               std::string res;
+               strprintf(res, "%s (%d)", pwd.pw_name, uid);
+               return res;
+            }
+         }
+      }
+   }
+   return "";
+}
+									/*}}}*/
+APT_PURE static unsigned int EnvironmentSize()				/*{{{*/
+{
+  unsigned int size = 0;
+  char **envp = environ;
+
+  while (*envp != NULL)
+    size += strlen (*envp++) + 1;
+
+  return size;
+}
+									/*}}}*/
+class pkgDPkgPMPrivate							/*{{{*/
+{
+public:
+   pkgDPkgPMPrivate() : stdin_is_dev_null(false), status_fd_reached_end_of_file(false),
+			dpkgbuf_pos(0), term_out(NULL), history_out(NULL),
+			progress(NULL), tt_is_valid(false), master(-1),
+			slave(NULL), protect_slave_from_dying(-1),
+			direct_stdin(false)
+   {
+      dpkgbuf[0] = '\0';
+   }
+   ~pkgDPkgPMPrivate()
+   {
+   }
+   bool stdin_is_dev_null;
+   bool status_fd_reached_end_of_file;
+   // the buffer we use for the dpkg status-fd reading
+   char dpkgbuf[1024];
+   size_t dpkgbuf_pos;
+   FILE *term_out;
+   FILE *history_out;
+   string dpkg_error;
+   APT::Progress::PackageManager *progress;
+
+   // pty stuff
+   struct termios tt;
+   bool tt_is_valid;
+   int master;
+   char * slave;
+   int protect_slave_from_dying;
+
+   // signals
+   sigset_t sigmask;
+   sigset_t original_sigmask;
+
+   bool direct_stdin;
+};
+									/*}}}*/
+namespace
+{
+  // Maps the dpkg "processing" info to human readable names.  Entry 0
+  // of each array is the key, entry 1 is the value.
+  const std::pair<const char *, const char *> PackageProcessingOps[] = {
+    std::make_pair("install",   N_("Preparing %s")),
+    // we don't care for the difference
+    std::make_pair("upgrade",   N_("Preparing %s")),
+    std::make_pair("configure", N_("Preparing to configure %s")),
+    std::make_pair("remove",    N_("Preparing for removal of %s")),
+    std::make_pair("purge",     N_("Preparing to completely remove %s")),
+    std::make_pair("disappear", N_("Noting disappearance of %s")),
+    std::make_pair("trigproc",  N_("Running post-installation trigger %s"))
+  };
+
+  const std::pair<const char *, const char *> * const PackageProcessingOpsBegin = PackageProcessingOps;
+  const std::pair<const char *, const char *> * const PackageProcessingOpsEnd   = PackageProcessingOps + sizeof(PackageProcessingOps) / sizeof(PackageProcessingOps[0]);
+
+  // Predicate to test whether an entry in the PackageProcessingOps
+  // array matches a string.
+  class MatchProcessingOp
+  {
+    const char *target;
+
+  public:
+    explicit MatchProcessingOp(const char *the_target)
+      : target(the_target)
+    {
+    }
+
+    bool operator()(const std::pair<const char *, const char *> &pair) const
+    {
+      return strcmp(pair.first, target) == 0;
+    }
+  };
+}
+
+// ionice - helper function to ionice the given PID			/*{{{*/
+/* there is no C header for ionice yet - just the syscall interface
+   so we use the binary from util-linux */
+static bool ionice(int PID)
+{
+   if (!FileExists("/usr/bin/ionice"))
+      return false;
+   pid_t Process = ExecFork();
+   if (Process == 0)
+   {
+      char buf[32];
+      snprintf(buf, sizeof(buf), "-p%d", PID);
+      const char *Args[4];
+      Args[0] = "/usr/bin/ionice";
+      Args[1] = "-c3";
+      Args[2] = buf;
+      Args[3] = 0;
+      execv(Args[0], (char **)Args);
+   }
+   return ExecWait(Process, "ionice");
+}
+									/*}}}*/
+// FindNowVersion - Helper to find a Version in "now" state	/*{{{*/
+// ---------------------------------------------------------------------
+/* This is helpful when a package is no longer installed but has residual
+ * config files
+ */
+static
+pkgCache::VerIterator FindNowVersion(const pkgCache::PkgIterator &Pkg)
+{
+   pkgCache::VerIterator Ver;
+   for (Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
+      for (pkgCache::VerFileIterator Vf = Ver.FileList(); Vf.end() == false; ++Vf)
+	 for (pkgCache::PkgFileIterator F = Vf.File(); F.end() == false; ++F)
+	 {
+	    if (F.Archive() != 0 && strcmp(F.Archive(), "now") == 0)
+	       return Ver;
+	 }
+   return Ver;
+}
+									/*}}}*/
+static pkgCache::VerIterator FindToBeRemovedVersion(pkgCache::PkgIterator const &Pkg)/*{{{*/
+{
+   auto const PV = Pkg.CurrentVer();
+   if (PV.end() == false)
+      return PV;
+   return FindNowVersion(Pkg);
+}
+									/*}}}*/
+
+// DPkgPM::pkgDPkgPM - Constructor					/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+pkgDPkgPM::pkgDPkgPM(pkgDepCache *Cache)
+   : pkgPackageManager(Cache),d(new pkgDPkgPMPrivate()), pkgFailures(0), PackagesDone(0), PackagesTotal(0)
+{
+}
+									/*}}}*/
+// DPkgPM::pkgDPkgPM - Destructor					/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+pkgDPkgPM::~pkgDPkgPM()
+{
+   delete d;
+}
+									/*}}}*/
+// DPkgPM::Install - Install a package					/*{{{*/
+// ---------------------------------------------------------------------
+/* Add an install operation to the sequence list */
+bool pkgDPkgPM::Install(PkgIterator Pkg,string File)
+{
+   if (File.empty() == true || Pkg.end() == true)
+      return _error->Error("Internal Error, No file name for %s",Pkg.FullName().c_str());
+
+   // If the filename string begins with DPkg::Chroot-Directory, return the
+   // substr that is within the chroot so dpkg can access it.
+   string const chrootdir = _config->FindDir("DPkg::Chroot-Directory","/");
+   if (chrootdir != "/" && File.find(chrootdir) == 0)
+   {
+      size_t len = chrootdir.length();
+      if (chrootdir.at(len - 1) == '/')
+        len--;
+      List.push_back(Item(Item::Install,Pkg,File.substr(len)));
+   }
+   else
+      List.push_back(Item(Item::Install,Pkg,File));
+
+   return true;
+}
+									/*}}}*/
+// DPkgPM::Configure - Configure a package				/*{{{*/
+// ---------------------------------------------------------------------
+/* Add a configure operation to the sequence list */
+bool pkgDPkgPM::Configure(PkgIterator Pkg)
+{
+   if (Pkg.end() == true)
+      return false;
+
+   List.push_back(Item(Item::Configure, Pkg));
+
+   // Use triggers for config calls if we configure "smart"
+   // as otherwise Pre-Depends will not be satisfied, see #526774
+   if (_config->FindB("DPkg::TriggersPending", false) == true)
+      List.push_back(Item(Item::TriggersPending, PkgIterator()));
+
+   return true;
+}
+									/*}}}*/
+// DPkgPM::Remove - Remove a package					/*{{{*/
+// ---------------------------------------------------------------------
+/* Add a remove operation to the sequence list */
+bool pkgDPkgPM::Remove(PkgIterator Pkg,bool Purge)
+{
+   if (Pkg.end() == true)
+      return false;
+
+   if (Purge == true)
+      List.push_back(Item(Item::Purge,Pkg));
+   else
+      List.push_back(Item(Item::Remove,Pkg));
+   return true;
+}
+									/*}}}*/
+// DPkgPM::SendPkgInfo - Send info for install-pkgs hook		/*{{{*/
+// ---------------------------------------------------------------------
+/* This is part of the helper script communication interface, it sends
+   very complete information down to the other end of the pipe.*/
+bool pkgDPkgPM::SendPkgsInfo(FILE * const F, unsigned int const &Version)
+{
+   // This version of APT supports only v3, so don't sent higher versions
+   if (Version <= 3)
+      fprintf(F,"VERSION %u\n", Version);
+   else
+      fprintf(F,"VERSION 3\n");
+
+   /* Write out all of the configuration directives by walking the
+      configuration tree */
+   const Configuration::Item *Top = _config->Tree(0);
+   for (; Top != 0;)
+   {
+      if (Top->Value.empty() == false)
+      {
+	 fprintf(F,"%s=%s\n",
+		 QuoteString(Top->FullTag(),"=\"\n").c_str(),
+		 QuoteString(Top->Value,"\n").c_str());
+      }
+
+      if (Top->Child != 0)
+      {
+	 Top = Top->Child;
+	 continue;
+      }
+
+      while (Top != 0 && Top->Next == 0)
+	 Top = Top->Parent;
+      if (Top != 0)
+	 Top = Top->Next;
+   }
+   fprintf(F,"\n");
+
+   // Write out the package actions in order.
+   for (vector<Item>::iterator I = List.begin(); I != List.end(); ++I)
+   {
+      if(I->Pkg.end() == true)
+	 continue;
+
+      pkgDepCache::StateCache &S = Cache[I->Pkg];
+
+      fprintf(F,"%s ",I->Pkg.Name());
+
+      // Current version which we are going to replace
+      pkgCache::VerIterator CurVer = I->Pkg.CurrentVer();
+      if (CurVer.end() == true && (I->Op == Item::Remove || I->Op == Item::Purge))
+	 CurVer = FindNowVersion(I->Pkg);
+
+      if (CurVer.end() == true)
+      {
+	 if (Version <= 2)
+	    fprintf(F, "- ");
+	 else
+	    fprintf(F, "- - none ");
+      }
+      else
+      {
+	 fprintf(F, "%s ", CurVer.VerStr());
+	 if (Version >= 3)
+	    fprintf(F, "%s %s ", CurVer.Arch(), CurVer.MultiArchType());
+      }
+
+      // Show the compare operator between current and install version
+      if (S.InstallVer != 0)
+      {
+	 pkgCache::VerIterator const InstVer = S.InstVerIter(Cache);
+	 int Comp = 2;
+	 if (CurVer.end() == false)
+	    Comp = InstVer.CompareVer(CurVer);
+	 if (Comp < 0)
+	    fprintf(F,"> ");
+	 else if (Comp == 0)
+	    fprintf(F,"= ");
+	 else if (Comp > 0)
+	    fprintf(F,"< ");
+	 fprintf(F, "%s ", InstVer.VerStr());
+	 if (Version >= 3)
+	    fprintf(F, "%s %s ", InstVer.Arch(), InstVer.MultiArchType());
+      }
+      else
+      {
+	 if (Version <= 2)
+	    fprintf(F, "> - ");
+	 else
+	    fprintf(F, "> - - none ");
+      }
+
+      // Show the filename/operation
+      if (I->Op == Item::Install)
+      {
+	 // No errors here..
+	 if (I->File[0] != '/')
+	    fprintf(F,"**ERROR**\n");
+	 else
+	    fprintf(F,"%s\n",I->File.c_str());
+      }
+      else if (I->Op == Item::Configure)
+	 fprintf(F,"**CONFIGURE**\n");
+      else if (I->Op == Item::Remove ||
+	  I->Op == Item::Purge)
+	 fprintf(F,"**REMOVE**\n");
+
+      if (ferror(F) != 0)
+	 return false;
+   }
+   return true;
+}
+									/*}}}*/
+// DPkgPM::RunScriptsWithPkgs - Run scripts with package names on stdin /*{{{*/
+// ---------------------------------------------------------------------
+/* This looks for a list of scripts to run from the configuration file
+   each one is run and is fed on standard input a list of all .deb files
+   that are due to be installed. */
+bool pkgDPkgPM::RunScriptsWithPkgs(const char *Cnf)
+{
+   bool result = true;
+
+   Configuration::Item const *Opts = _config->Tree(Cnf);
+   if (Opts == 0 || Opts->Child == 0)
+      return true;
+   Opts = Opts->Child;
+
+   sighandler_t old_sigpipe = signal(SIGPIPE, SIG_IGN);
+   sighandler_t old_sigint = signal(SIGINT, SIG_IGN);
+   sighandler_t old_sigquit = signal(SIGQUIT, SIG_IGN);
+
+   unsigned int Count = 1;
+   for (; Opts != 0; Opts = Opts->Next, Count++)
+   {
+      if (Opts->Value.empty() == true)
+         continue;
+
+      if(_config->FindB("Debug::RunScripts", false) == true)
+         std::clog << "Running external script with list of all .deb file: '"
+                   << Opts->Value << "'" << std::endl;
+
+      // Determine the protocol version
+      string OptSec = Opts->Value;
+      string::size_type Pos;
+      if ((Pos = OptSec.find(' ')) == string::npos || Pos == 0)
+	 Pos = OptSec.length();
+      OptSec = "DPkg::Tools::Options::" + string(Opts->Value.c_str(),Pos);
+
+      unsigned int Version = _config->FindI(OptSec+"::Version",1);
+      unsigned int InfoFD = _config->FindI(OptSec + "::InfoFD", STDIN_FILENO);
+
+      // Create the pipes
+      std::set<int> KeepFDs;
+      MergeKeepFdsFromConfiguration(KeepFDs);
+      int Pipes[2];
+      if (pipe(Pipes) != 0) {
+         result = _error->Errno("pipe","Failed to create IPC pipe to subprocess");
+         break;
+      }
+      if (InfoFD != (unsigned)Pipes[0])
+	 SetCloseExec(Pipes[0],true);
+      else
+         KeepFDs.insert(Pipes[0]);
+
+
+      SetCloseExec(Pipes[1],true);
+
+      // Purified Fork for running the script
+      pid_t Process = ExecFork(KeepFDs);
+      if (Process == 0)
+      {
+	 // Setup the FDs
+	 dup2(Pipes[0], InfoFD);
+	 SetCloseExec(STDOUT_FILENO,false);
+	 SetCloseExec(STDIN_FILENO,false);
+	 SetCloseExec(STDERR_FILENO,false);
+
+	 string hookfd;
+	 strprintf(hookfd, "%d", InfoFD);
+	 setenv("APT_HOOK_INFO_FD", hookfd.c_str(), 1);
+
+	 if (_system != nullptr && _system->IsLocked() == true && stringcasecmp(Cnf, "DPkg::Pre-Install-Pkgs") == 0)
+	    setenv("DPKG_FRONTEND_LOCKED", "true", 1);
+
+	 debSystem::DpkgChrootDirectory();
+	 const char *Args[4];
+	 Args[0] = "/bin/sh";
+	 Args[1] = "-c";
+	 Args[2] = Opts->Value.c_str();
+	 Args[3] = 0;
+	 execv(Args[0],(char **)Args);
+	 _exit(100);
+      }
+      close(Pipes[0]);
+      FILE *F = fdopen(Pipes[1],"w");
+      if (F == 0) {
+         result = _error->Errno("fdopen","Failed to open new FD");
+         break;
+      }
+
+      // Feed it the filenames.
+      if (Version <= 1)
+      {
+	 for (vector<Item>::iterator I = List.begin(); I != List.end(); ++I)
+	 {
+	    // Only deal with packages to be installed from .deb
+	    if (I->Op != Item::Install)
+	       continue;
+
+	    // No errors here..
+	    if (I->File[0] != '/')
+	       continue;
+
+	    /* Feed the filename of each package that is pending install
+	       into the pipe. */
+	    fprintf(F,"%s\n",I->File.c_str());
+	    if (ferror(F) != 0)
+	       break;
+	 }
+      }
+      else
+	 SendPkgsInfo(F, Version);
+
+      fclose(F);
+
+      // Clean up the sub process
+      if (ExecWait(Process,Opts->Value.c_str()) == false) {
+	 result = _error->Error("Failure running script %s",Opts->Value.c_str());
+         break;
+      }
+   }
+   signal(SIGINT, old_sigint);
+   signal(SIGPIPE, old_sigpipe);
+   signal(SIGQUIT, old_sigquit);
+
+   return result;
+}
+									/*}}}*/
+// DPkgPM::DoStdin - Read stdin and pass to master pty			/*{{{*/
+// ---------------------------------------------------------------------
+/*
+*/
+void pkgDPkgPM::DoStdin(int master)
+{
+   unsigned char input_buf[256] = {0,}; 
+   ssize_t len = read(STDIN_FILENO, input_buf, sizeof(input_buf));
+   if (len)
+      FileFd::Write(master, input_buf, len);
+   else
+      d->stdin_is_dev_null = true;
+}
+									/*}}}*/
+// DPkgPM::DoTerminalPty - Read the terminal pty and write log		/*{{{*/
+// ---------------------------------------------------------------------
+/*
+ * read the terminal pty and write log
+ */
+void pkgDPkgPM::DoTerminalPty(int master)
+{
+   unsigned char term_buf[1024] = {0,0, };
+
+   ssize_t len=read(master, term_buf, sizeof(term_buf));
+   if(len == -1 && errno == EIO)
+   {
+      // this happens when the child is about to exit, we
+      // give it time to actually exit, otherwise we run
+      // into a race so we sleep for half a second.
+      struct timespec sleepfor = { 0, 500000000 };
+      nanosleep(&sleepfor, NULL);
+      return;
+   }
+   if(len <= 0)
+      return;
+   FileFd::Write(1, term_buf, len);
+   if(d->term_out)
+      fwrite(term_buf, len, sizeof(char), d->term_out);
+}
+									/*}}}*/
+// DPkgPM::ProcessDpkgStatusBuf						/*{{{*/
+void pkgDPkgPM::ProcessDpkgStatusLine(char *line)
+{
+   bool const Debug = _config->FindB("Debug::pkgDPkgProgressReporting",false);
+   if (Debug == true)
+      std::clog << "got from dpkg '" << line << "'" << std::endl;
+
+   /* dpkg sends strings like this:
+      'status:   <pkg>: <pkg  qstate>'
+      'status:   <pkg>:<arch>: <pkg  qstate>'
+
+      'processing: {install,upgrade,configure,remove,purge,disappear,trigproc}: pkg'
+      'processing: {install,upgrade,configure,remove,purge,disappear,trigproc}: trigger'
+   */
+
+   // we need to split on ": " (note the appended space) as the ':' is
+   // part of the pkgname:arch information that dpkg sends
+   //
+   // A dpkg error message may contain additional ":" (like
+   //  "failed in buffer_write(fd) (10, ret=-1): backend dpkg-deb ..."
+   // so we need to ensure to not split too much
+   std::vector<std::string> list = StringSplit(line, ": ", 4);
+   if(list.size() < 3)
+   {
+      if (Debug == true)
+	 std::clog << "ignoring line: not enough ':'" << std::endl;
+      return;
+   }
+
+   // build the (prefix, pkgname, action) tuple, position of this
+   // is different for "processing" or "status" messages
+   std::string prefix = APT::String::Strip(list[0]);
+   std::string pkgname;
+   std::string action;
+
+   // "processing" has the form "processing: action: pkg or trigger"
+   // with action = ["install", "upgrade", "configure", "remove", "purge",
+   //                "disappear", "trigproc"]
+   if (prefix == "processing")
+   {
+      pkgname = APT::String::Strip(list[2]);
+      action = APT::String::Strip(list[1]);
+   }
+   // "status" has the form: "status: pkg: state"
+   // with state in ["half-installed", "unpacked", "half-configured",
+   //                "installed", "config-files", "not-installed"]
+   else if (prefix == "status")
+   {
+      pkgname = APT::String::Strip(list[1]);
+      action = APT::String::Strip(list[2]);
+
+      /* handle the special cases first:
+
+	 errors look like this:
+	 'status: /var/cache/apt/archives/krecipes_0.8.1-0ubuntu1_i386.deb : error : trying to overwrite `/usr/share/doc/kde/HTML/en/krecipes/krectip.png', which is also in package krecipes-data
+	 and conffile-prompt like this
+	 'status:/etc/compiz.conf/compiz.conf :  conffile-prompt: 'current-conffile' 'new-conffile' useredited distedited
+	 */
+      if(action == "error")
+      {
+         d->progress->Error(pkgname, PackagesDone, PackagesTotal, list[3]);
+         ++pkgFailures;
+         WriteApportReport(pkgname.c_str(), list[3].c_str());
+         return;
+      }
+      else if(action == "conffile-prompt")
+      {
+         d->progress->ConffilePrompt(pkgname, PackagesDone, PackagesTotal, list[3]);
+         return;
+      }
+   } else {
+      if (Debug == true)
+	 std::clog << "unknown prefix '" << prefix << "'" << std::endl;
+      return;
+   }
+
+   // At this point we have a pkgname, but it might not be arch-qualified !
+   if (pkgname.find(":") == std::string::npos)
+   {
+      pkgCache::GrpIterator const Grp = Cache.FindGrp(pkgname);
+      if (unlikely(Grp.end()== true))
+      {
+	 if (Debug == true)
+	    std::clog << "unable to figure out which package is dpkg referring to with '" << pkgname << "'! (0)" << std::endl;
+	 return;
+      }
+      /* No arch means that dpkg believes there can only be one package
+         this can refer to so lets see what could be candidates here: */
+      std::vector<pkgCache::PkgIterator> candset;
+      for (auto P = Grp.PackageList(); P.end() != true; P = Grp.NextPkg(P))
+      {
+	 if (PackageOps.find(P.FullName()) != PackageOps.end())
+	    candset.push_back(P);
+	 // packages can disappear without them having any interaction itself
+	 // so we have to consider these as candidates, too
+	 else if (P->CurrentVer != 0 && action == "disappear")
+	    candset.push_back(P);
+      }
+      if (unlikely(candset.empty()))
+      {
+	 if (Debug == true)
+	    std::clog << "unable to figure out which package is dpkg referring to with '" << pkgname << "'! (1)" << std::endl;
+	 return;
+      }
+      else if (candset.size() == 1) // we are lucky
+	 pkgname = candset.cbegin()->FullName();
+      else
+      {
+	 /* here be dragons^Wassumptions about dpkg:
+	    - an M-A:same version is always arch-qualified
+	    - a package from a foreign arch is (in newer versions) */
+	 size_t installedInstances = 0, wannabeInstances = 0;
+	 for (auto const &P: candset)
+	 {
+	    if (P->CurrentVer != 0)
+	    {
+	       ++installedInstances;
+	       if (Cache[P].Delete() == false)
+		  ++wannabeInstances;
+	    }
+	    else if (Cache[P].Install())
+	       ++wannabeInstances;
+	 }
+	 // the package becomes M-A:same, so we are still talking about current
+	 if (installedInstances == 1 && wannabeInstances >= 2)
+	 {
+	    for (auto const &P: candset)
+	    {
+	       if (P->CurrentVer == 0)
+		  continue;
+	       pkgname = P.FullName();
+	       break;
+	    }
+	 }
+	 // the package was M-A:same, it isn't now, so we can only talk about that
+	 else if (installedInstances >= 2 && wannabeInstances == 1)
+	 {
+	    for (auto const &P: candset)
+	    {
+	       auto const IV = Cache[P].InstVerIter(Cache);
+	       if (IV.end())
+		  continue;
+	       pkgname = P.FullName();
+	       break;
+	    }
+	 }
+	 // that is a crossgrade
+	 else if (installedInstances == 1 && wannabeInstances == 1 && candset.size() == 2)
+	 {
+	    auto const PkgHasCurrentVersion = [](pkgCache::PkgIterator const &P) { return P->CurrentVer != 0; };
+	    auto const P = std::find_if(candset.begin(), candset.end(), PkgHasCurrentVersion);
+	    if (unlikely(P == candset.end()))
+	    {
+	       if (Debug == true)
+		  std::clog << "situation for '" << pkgname << "' looked like a crossgrade, but no current version?!" << std::endl;
+	       return;
+	    }
+	    auto fullname = P->FullName();
+	    if (PackageOps[fullname].size() != PackageOpsDone[fullname])
+	       pkgname = std::move(fullname);
+	    else
+	    {
+	       auto const pkgi = std::find_if_not(candset.begin(), candset.end(), PkgHasCurrentVersion);
+	       if (unlikely(pkgi == candset.end()))
+	       {
+		  if (Debug == true)
+		     std::clog << "situation for '" << pkgname << "' looked like a crossgrade, but all are installed?!" << std::endl;
+		  return;
+	       }
+	       pkgname = pkgi->FullName();
+	    }
+	 }
+	 // we are desperate: so "just" take the native one, but that might change mid-air,
+	 // so we have to ask dpkg what it believes native is at the moment… all the time
+	 else
+	 {
+	    std::vector<std::string> sArgs = debSystem::GetDpkgBaseCommand();
+	    sArgs.push_back("--print-architecture");
+	    int outputFd = -1;
+	    pid_t const dpkgNativeArch = debSystem::ExecDpkg(sArgs, nullptr, &outputFd, true);
+	    if (unlikely(dpkgNativeArch == -1))
+	    {
+	       if (Debug == true)
+		  std::clog << "calling dpkg failed to ask it for its current native architecture to expand '" << pkgname << "'!" << std::endl;
+	       return;
+	    }
+	    FILE *dpkg = fdopen(outputFd, "r");
+	    if(dpkg != NULL)
+	    {
+	       char* buf = NULL;
+	       size_t bufsize = 0;
+	       if (getline(&buf, &bufsize, dpkg) != -1)
+		  pkgname += ':' + bufsize;
+	       free(buf);
+	       fclose(dpkg);
+	    }
+	    ExecWait(dpkgNativeArch, "dpkg --print-architecture", true);
+	    if (pkgname.find(':') != std::string::npos)
+	    {
+	       if (Debug == true)
+		  std::clog << "unable to figure out which package is dpkg referring to with '" << pkgname << "'! (2)" << std::endl;
+	       return;
+	    }
+	 }
+      }
+   }
+
+   std::string arch = "";
+   if (pkgname.find(":") != string::npos)
+      arch = StringSplit(pkgname, ":")[1];
+   std::string i18n_pkgname = pkgname;
+   if (arch.size() != 0)
+      strprintf(i18n_pkgname, "%s (%s)", StringSplit(pkgname, ":")[0].c_str(), arch.c_str());
+
+   // 'processing' from dpkg looks like
+   // 'processing: action: pkg'
+   if(prefix == "processing")
+   {
+      auto const iter = std::find_if(PackageProcessingOpsBegin, PackageProcessingOpsEnd, MatchProcessingOp(action.c_str()));
+      if(iter == PackageProcessingOpsEnd)
+      {
+	 if (Debug == true)
+	    std::clog << "ignoring unknown action: " << action << std::endl;
+	 return;
+      }
+      std::string msg;
+      strprintf(msg, _(iter->second), i18n_pkgname.c_str());
+      d->progress->StatusChanged(pkgname, PackagesDone, PackagesTotal, msg);
+
+      // FIXME: this needs a muliarch testcase
+      // FIXME2: is "pkgname" here reliable with dpkg only sending us
+      //         short pkgnames?
+      if (action == "disappear")
+	 handleDisappearAction(pkgname);
+      else if (action == "upgrade")
+	 handleCrossUpgradeAction(pkgname);
+      return;
+   }
+
+   if (prefix == "status")
+   {
+      std::vector<struct DpkgState> &states = PackageOps[pkgname];
+      if(PackageOpsDone[pkgname] < states.size())
+      {
+	 char const * next_action = states[PackageOpsDone[pkgname]].state;
+	 if (next_action)
+	 {
+	    /*
+	    if (action == "half-installed" && strcmp("half-configured", next_action) == 0 &&
+		  PackageOpsDone[pkg] + 2 < states.size() && action == states[PackageOpsDone[pkg] + 2].state)
+	    {
+	       if (Debug == true)
+		  std::clog << "(parsed from dpkg) pkg: " << short_pkgname << " action: " << action
+		     << " pending trigger defused by unpack" << std::endl;
+	       // unpacking a package defuses the pending trigger
+	       PackageOpsDone[pkg] += 2;
+	       PackagesDone += 2;
+	       next_action = states[PackageOpsDone[pkg]].state;
+	    }
+	    */
+	    if (Debug == true)
+	       std::clog << "(parsed from dpkg) pkg: " << pkgname
+		  << " action: " << action << " (expected: '" << next_action << "' "
+		  << PackageOpsDone[pkgname] << " of " << states.size() << ")" << endl;
+
+	    // check if the package moved to the next dpkg state
+	    if(action == next_action)
+	    {
+	       // only read the translation if there is actually a next action
+	       char const * const translation = _(states[PackageOpsDone[pkgname]].str);
+
+	       // we moved from one dpkg state to a new one, report that
+	       ++PackageOpsDone[pkgname];
+	       ++PackagesDone;
+
+	       std::string msg;
+	       strprintf(msg, translation, i18n_pkgname.c_str());
+	       d->progress->StatusChanged(pkgname, PackagesDone, PackagesTotal, msg);
+	    }
+	 }
+      }
+      else if (action == "triggers-pending")
+      {
+	 if (Debug == true)
+	    std::clog << "(parsed from dpkg) pkg: " << pkgname
+	       << " action: " << action << " (prefix 2 to "
+	       << PackageOpsDone[pkgname] << " of " << states.size() << ")" << endl;
+
+	 states.insert(states.begin(), {"installed", N_("Installed %s")});
+	 states.insert(states.begin(), {"half-configured", N_("Configuring %s")});
+	 PackagesTotal += 2;
+      }
+   }
+}
+									/*}}}*/
+// DPkgPM::handleDisappearAction					/*{{{*/
+void pkgDPkgPM::handleDisappearAction(string const &pkgname)
+{
+   pkgCache::PkgIterator Pkg = Cache.FindPkg(pkgname);
+   if (unlikely(Pkg.end() == true))
+      return;
+
+   // a disappeared package has no further actions
+   auto const ROps = PackageOps[Pkg.FullName()].size();
+   auto && ROpsDone = PackageOpsDone[Pkg.FullName()];
+   PackagesDone += ROps - ROpsDone;
+   ROpsDone = ROps;
+
+   // record the package name for display and stuff later
+   disappearedPkgs.insert(Pkg.FullName(true));
+
+   // the disappeared package was auto-installed - nothing to do
+   if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
+      return;
+   pkgCache::VerIterator PkgVer = Cache[Pkg].InstVerIter(Cache);
+   if (unlikely(PkgVer.end() == true))
+      return;
+   /* search in the list of dependencies for (Pre)Depends,
+      check if this dependency has a Replaces on our package
+      and if so transfer the manual installed flag to it */
+   for (pkgCache::DepIterator Dep = PkgVer.DependsList(); Dep.end() != true; ++Dep)
+   {
+      if (Dep->Type != pkgCache::Dep::Depends &&
+	  Dep->Type != pkgCache::Dep::PreDepends)
+	 continue;
+      pkgCache::PkgIterator Tar = Dep.TargetPkg();
+      if (unlikely(Tar.end() == true))
+	 continue;
+      // the package is already marked as manual
+      if ((Cache[Tar].Flags & pkgCache::Flag::Auto) != pkgCache::Flag::Auto)
+	 continue;
+      pkgCache::VerIterator TarVer =  Cache[Tar].InstVerIter(Cache);
+      if (TarVer.end() == true)
+	 continue;
+      for (pkgCache::DepIterator Rep = TarVer.DependsList(); Rep.end() != true; ++Rep)
+      {
+	 if (Rep->Type != pkgCache::Dep::Replaces)
+	    continue;
+	 if (Pkg != Rep.TargetPkg())
+	    continue;
+	 // okay, they are strongly connected - transfer manual-bit
+	 if (Debug == true)
+	    std::clog << "transfer manual-bit from disappeared »" << pkgname << "« to »" << Tar.FullName() << "«" << std::endl;
+	 Cache[Tar].Flags &= ~Flag::Auto;
+	 break;
+      }
+   }
+}
+									/*}}}*/
+void pkgDPkgPM::handleCrossUpgradeAction(string const &pkgname)		/*{{{*/
+{
+   // in a crossgrade what looked like a remove first is really an unpack over it
+   auto const Pkg = Cache.FindPkg(pkgname);
+   if (likely(Pkg.end() == false) && Cache[Pkg].Delete())
+   {
+      auto const Grp = Pkg.Group();
+      if (likely(Grp.end() == false))
+      {
+	 for (auto P = Grp.PackageList(); P.end() != true; P = Grp.NextPkg(P))
+	    if(Cache[P].Install())
+	    {
+	       auto && Ops = PackageOps[P.FullName()];
+	       auto const unpackOp = std::find_if(Ops.cbegin(), Ops.cend(), [](DpkgState const &s) { return strcmp(s.state, "unpacked") == 0; });
+	       if (unpackOp != Ops.cend())
+	       {
+		  // skip ahead in the crossgraded packages
+		  auto const skipped = std::distance(Ops.cbegin(), unpackOp);
+		  PackagesDone += skipped;
+		  PackageOpsDone[P.FullName()] += skipped;
+		  // finish the crossremoved package
+		  auto const ROps = PackageOps[Pkg.FullName()].size();
+		  auto && ROpsDone = PackageOpsDone[Pkg.FullName()];
+		  PackagesDone += ROps - ROpsDone;
+		  ROpsDone = ROps;
+		  break;
+	       }
+	    }
+      }
+   }
+}
+									/*}}}*/
+// DPkgPM::DoDpkgStatusFd						/*{{{*/
+void pkgDPkgPM::DoDpkgStatusFd(int statusfd)
+{
+   auto const remainingBuffer = (sizeof(d->dpkgbuf) / sizeof(d->dpkgbuf[0])) - d->dpkgbuf_pos;
+   if (likely(remainingBuffer > 0) && d->status_fd_reached_end_of_file == false)
+   {
+      auto const len = read(statusfd, &d->dpkgbuf[d->dpkgbuf_pos], remainingBuffer);
+      if (len < 0)
+	 return;
+      else if (len == 0 && d->dpkgbuf_pos == 0)
+      {
+	 d->status_fd_reached_end_of_file = true;
+	 return;
+      }
+      d->dpkgbuf_pos += (len / sizeof(d->dpkgbuf[0]));
+   }
+
+   // process line by line from the buffer
+   char *p = d->dpkgbuf, *q = nullptr;
+   while((q=(char*)memchr(p, '\n', (d->dpkgbuf + d->dpkgbuf_pos) - p)) != nullptr)
+   {
+      *q = '\0';
+      ProcessDpkgStatusLine(p);
+      p = q + 1; // continue with next line
+   }
+
+   // check if we stripped the buffer clean
+   if (p > (d->dpkgbuf + d->dpkgbuf_pos))
+   {
+      d->dpkgbuf_pos = 0;
+      return;
+   }
+
+   // otherwise move the unprocessed tail to the start and update pos
+   memmove(d->dpkgbuf, p, (p - d->dpkgbuf));
+   d->dpkgbuf_pos = (d->dpkgbuf + d->dpkgbuf_pos) - p;
+}
+									/*}}}*/
+// DPkgPM::WriteHistoryTag						/*{{{*/
+void pkgDPkgPM::WriteHistoryTag(string const &tag, string value)
+{
+   size_t const length = value.length();
+   if (length == 0)
+      return;
+   // poor mans rstrip(", ")
+   if (value[length-2] == ',' && value[length-1] == ' ')
+      value.erase(length - 2, 2);
+   fprintf(d->history_out, "%s: %s\n", tag.c_str(), value.c_str());
+}									/*}}}*/
+// DPkgPM::OpenLog							/*{{{*/
+bool pkgDPkgPM::OpenLog()
+{
+   string const logfile_name =  _config->FindFile("Dir::Log::Terminal", "/dev/null");
+   string logdir = flNotFile(logfile_name);
+   if(CreateAPTDirectoryIfNeeded(logdir, logdir) == false)
+      // FIXME: use a better string after freeze
+      return _error->Error(_("Directory '%s' missing"), logdir.c_str());
+
+   // get current time
+   char timestr[200];
+   time_t const t = time(NULL);
+   struct tm tm_buf;
+   struct tm const * const tmp = localtime_r(&t, &tm_buf);
+   strftime(timestr, sizeof(timestr), "%F  %T", tmp);
+
+   // open terminal log
+   if (logfile_name != "/dev/null")
+   {
+      d->term_out = fopen(logfile_name.c_str(),"a");
+      if (d->term_out == NULL)
+	 return _error->WarningE("OpenLog", _("Could not open file '%s'"), logfile_name.c_str());
+      setvbuf(d->term_out, NULL, _IONBF, 0);
+      SetCloseExec(fileno(d->term_out), true);
+      if (getuid() == 0) // if we aren't root, we can't chown a file, so don't try it
+      {
+	 struct passwd *pw = getpwnam("root");
+	 struct group *gr = getgrnam("adm");
+	 if (pw != NULL && gr != NULL && chown(logfile_name.c_str(), pw->pw_uid, gr->gr_gid) != 0)
+	    _error->WarningE("OpenLog", "chown to root:adm of file %s failed", logfile_name.c_str());
+      }
+      if (chmod(logfile_name.c_str(), 0640) != 0)
+	 _error->WarningE("OpenLog", "chmod 0640 of file %s failed", logfile_name.c_str());
+      fprintf(d->term_out, "\nLog started: %s\n", timestr);
+   }
+
+   // write your history
+   string const history_name = _config->FindFile("Dir::Log::History", "/dev/null");
+   string logdir2 = flNotFile(logfile_name);
+   if(logdir != logdir2 && CreateAPTDirectoryIfNeeded(logdir2, logdir2) == false)
+      return _error->Error(_("Directory '%s' missing"), logdir.c_str());
+   if (history_name != "/dev/null")
+   {
+      d->history_out = fopen(history_name.c_str(),"a");
+      if (d->history_out == NULL)
+	 return _error->WarningE("OpenLog", _("Could not open file '%s'"), history_name.c_str());
+      SetCloseExec(fileno(d->history_out), true);
+      chmod(history_name.c_str(), 0644);
+      fprintf(d->history_out, "\nStart-Date: %s\n", timestr);
+      string remove, purge, install, reinstall, upgrade, downgrade;
+      for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
+      {
+	 enum { CANDIDATE, CANDIDATE_AUTO, CURRENT_CANDIDATE, CURRENT } infostring;
+	 string *line = NULL;
+	 #define HISTORYINFO(X, Y) { line = &X; infostring = Y; }
+	 if (Cache[I].NewInstall() == true)
+	    HISTORYINFO(install, CANDIDATE_AUTO)
+	 else if (Cache[I].ReInstall() == true)
+	    HISTORYINFO(reinstall, CANDIDATE)
+	 else if (Cache[I].Upgrade() == true)
+	    HISTORYINFO(upgrade, CURRENT_CANDIDATE)
+	 else if (Cache[I].Downgrade() == true)
+	    HISTORYINFO(downgrade, CURRENT_CANDIDATE)
+	 else if (Cache[I].Delete() == true)
+	    HISTORYINFO((Cache[I].Purge() ? purge : remove), CURRENT)
+	 else
+	    continue;
+	 #undef HISTORYINFO
+	 line->append(I.FullName(false)).append(" (");
+	 switch (infostring) {
+	 case CANDIDATE: line->append(Cache[I].CandVersion); break;
+	 case CANDIDATE_AUTO:
+	    line->append(Cache[I].CandVersion);
+	    if ((Cache[I].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
+	       line->append(", automatic");
+	    break;
+	 case CURRENT_CANDIDATE: line->append(Cache[I].CurVersion).append(", ").append(Cache[I].CandVersion); break;
+	 case CURRENT: line->append(Cache[I].CurVersion); break;
+	 }
+	 line->append("), ");
+      }
+      if (_config->Exists("Commandline::AsString") == true)
+	 WriteHistoryTag("Commandline", _config->Find("Commandline::AsString"));
+      std::string RequestingUser = AptHistoryRequestingUser();
+      if (RequestingUser != "")
+         WriteHistoryTag("Requested-By", RequestingUser);
+      WriteHistoryTag("Install", install);
+      WriteHistoryTag("Reinstall", reinstall);
+      WriteHistoryTag("Upgrade", upgrade);
+      WriteHistoryTag("Downgrade",downgrade);
+      WriteHistoryTag("Remove",remove);
+      WriteHistoryTag("Purge",purge);
+      fflush(d->history_out);
+   }
+
+   return true;
+}
+									/*}}}*/
+// DPkg::CloseLog							/*{{{*/
+bool pkgDPkgPM::CloseLog()
+{
+   char timestr[200];
+   time_t t = time(NULL);
+   struct tm tm_buf;
+   struct tm *tmp = localtime_r(&t, &tm_buf);
+   strftime(timestr, sizeof(timestr), "%F  %T", tmp);
+
+   if(d->term_out)
+   {
+      fprintf(d->term_out, "Log ended: ");
+      fprintf(d->term_out, "%s", timestr);
+      fprintf(d->term_out, "\n");
+      fclose(d->term_out);
+   }
+   d->term_out = NULL;
+
+   if(d->history_out)
+   {
+      if (disappearedPkgs.empty() == false)
+      {
+	 string disappear;
+	 for (std::set<std::string>::const_iterator d = disappearedPkgs.begin();
+	      d != disappearedPkgs.end(); ++d)
+	 {
+	    pkgCache::PkgIterator P = Cache.FindPkg(*d);
+	    disappear.append(*d);
+	    if (P.end() == true)
+	       disappear.append(", ");
+	    else
+	       disappear.append(" (").append(Cache[P].CurVersion).append("), ");
+	 }
+	 WriteHistoryTag("Disappeared", disappear);
+      }
+      if (d->dpkg_error.empty() == false)
+	 fprintf(d->history_out, "Error: %s\n", d->dpkg_error.c_str());
+      fprintf(d->history_out, "End-Date: %s\n", timestr);
+      fclose(d->history_out);
+   }
+   d->history_out = NULL;
+
+   return true;
+}
+									/*}}}*/
+
+// DPkgPM::BuildPackagesProgressMap					/*{{{*/
+void pkgDPkgPM::BuildPackagesProgressMap()
+{
+   // map the dpkg states to the operations that are performed
+   // (this is sorted in the same way as Item::Ops)
+   static const std::array<std::array<DpkgState, 2>, 4> DpkgStatesOpMap = {{
+      // Install operation
+      {{
+	 {"half-installed", N_("Unpacking %s")},
+	 {"unpacked", N_("Installing %s") },
+      }},
+      // Configure operation
+      {{
+	 {"half-configured", N_("Configuring %s") },
+	 { "installed", N_("Installed %s")},
+      }},
+      // Remove operation
+      {{
+	 {"half-configured", N_("Removing %s")},
+	 {"half-installed", N_("Removing %s")},
+      }},
+      // Purge operation
+      {{
+	 {"config-files", N_("Completely removing %s")},
+	 {"not-installed", N_("Completely removed %s")},
+      }},
+   }};
+   static_assert(Item::Purge == 3, "Enum item has unexpected index for mapping array");
+
+   // init the PackageOps map, go over the list of packages that
+   // that will be [installed|configured|removed|purged] and add
+   // them to the PackageOps map (the dpkg states it goes through)
+   // and the PackageOpsTranslations (human readable strings)
+   for (auto &&I : List)
+   {
+      if(I.Pkg.end() == true)
+	 continue;
+
+      string const name = I.Pkg.FullName();
+      PackageOpsDone[name] = 0;
+      auto AddToPackageOps = [&](decltype(I.Op) const Op) {
+	 auto const DpkgOps = DpkgStatesOpMap[Op];
+	 std::copy(DpkgOps.begin(), DpkgOps.end(), std::back_inserter(PackageOps[name]));
+	 PackagesTotal += DpkgOps.size();
+      };
+      // purging a package which is installed first passes through remove states
+      if (I.Op == Item::Purge && I.Pkg->CurrentVer != 0)
+	 AddToPackageOps(Item::Remove);
+      AddToPackageOps(I.Op);
+
+      if ((I.Op == Item::Remove || I.Op == Item::Purge) && I.Pkg->CurrentVer != 0)
+      {
+	 if (I.Pkg->CurrentState == pkgCache::State::UnPacked ||
+	       I.Pkg->CurrentState == pkgCache::State::HalfInstalled)
+	 {
+	    if (likely(strcmp(PackageOps[name][0].state, "half-configured") == 0))
+	    {
+	       ++PackageOpsDone[name];
+	       --PackagesTotal;
+	    }
+	 }
+      }
+   }
+   /* one extra: We don't want the progress bar to reach 100%, especially not
+      if we call dpkg --configure --pending and process a bunch of triggers
+      while showing 100%. Also, spindown takes a while, so never reaching 100%
+      is way more correct than reaching 100% while still doing stuff even if
+      doing it this way is slightly bending the rules */
+   ++PackagesTotal;
+}
+                                                                        /*}}}*/
+void pkgDPkgPM::StartPtyMagic()						/*{{{*/
+{
+   if (_config->FindB("Dpkg::Use-Pty", true) == false)
+   {
+      d->master = -1;
+      if (d->slave != NULL)
+	 free(d->slave);
+      d->slave = NULL;
+      return;
+   }
+
+   if (isatty(STDIN_FILENO) == 0)
+      d->direct_stdin = true;
+
+   _error->PushToStack();
+
+   d->master = posix_openpt(O_RDWR | O_NOCTTY);
+   if (d->master == -1)
+      _error->Errno("posix_openpt", _("Can not write log (%s)"), _("Is /dev/pts mounted?"));
+   else if (unlockpt(d->master) == -1)
+      _error->Errno("unlockpt", "Unlocking the slave of master fd %d failed!", d->master);
+   else
+   {
+#ifdef HAVE_PTSNAME_R
+      char slave_name[64];	// 64 is used by bionic
+      if (ptsname_r(d->master, slave_name, sizeof(slave_name)) != 0)
+#else
+      char const * const slave_name = ptsname(d->master);
+      if (slave_name == NULL)
+#endif
+	 _error->Errno("ptsname", "Getting name for slave of master fd %d failed!", d->master);
+      else
+      {
+	 d->slave = strdup(slave_name);
+	 if (d->slave == NULL)
+	    _error->Errno("strdup", "Copying name %s for slave of master fd %d failed!", slave_name, d->master);
+	 else if (grantpt(d->master) == -1)
+	    _error->Errno("grantpt", "Granting access to slave %s based on master fd %d failed!", slave_name, d->master);
+	 else if (tcgetattr(STDIN_FILENO, &d->tt) == 0)
+	 {
+	    d->tt_is_valid = true;
+	    struct termios raw_tt;
+	    // copy window size of stdout if its a 'good' terminal
+	    if (tcgetattr(STDOUT_FILENO, &raw_tt) == 0)
+	    {
+	       struct winsize win;
+	       if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) < 0)
+		  _error->Errno("ioctl", "Getting TIOCGWINSZ from stdout failed!");
+	       if (ioctl(d->master, TIOCSWINSZ, &win) < 0)
+		  _error->Errno("ioctl", "Setting TIOCSWINSZ for master fd %d failed!", d->master);
+	    }
+	    if (tcsetattr(d->master, TCSANOW, &d->tt) == -1)
+	       _error->Errno("tcsetattr", "Setting in Start via TCSANOW for master fd %d failed!", d->master);
+
+	    raw_tt = d->tt;
+	    cfmakeraw(&raw_tt);
+	    raw_tt.c_lflag &= ~ECHO;
+	    raw_tt.c_lflag |= ISIG;
+	    // block SIGTTOU during tcsetattr to prevent a hang if
+	    // the process is a member of the background process group
+	    // http://www.opengroup.org/onlinepubs/000095399/functions/tcsetattr.html
+	    sigemptyset(&d->sigmask);
+	    sigaddset(&d->sigmask, SIGTTOU);
+	    sigprocmask(SIG_BLOCK,&d->sigmask, &d->original_sigmask);
+	    if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw_tt) == -1)
+	       _error->Errno("tcsetattr", "Setting in Start via TCSAFLUSH for stdin failed!");
+	    sigprocmask(SIG_SETMASK, &d->original_sigmask, NULL);
+
+	 }
+	 if (d->slave != NULL)
+	 {
+	    /* on linux, closing (and later reopening) all references to the slave
+	       makes the slave a death end, so we open it here to have one open all
+	       the time. We could use this fd in SetupSlavePtyMagic() for linux, but
+	       on kfreebsd we get an incorrect ("step like") output then while it has
+	       no problem with closing all references… so to avoid platform specific
+	       code here we combine both and be happy once more */
+	    d->protect_slave_from_dying = open(d->slave, O_RDWR | O_CLOEXEC | O_NOCTTY);
+	 }
+      }
+   }
+
+   if (_error->PendingError() == true)
+   {
+      if (d->master != -1)
+      {
+	 close(d->master);
+	 d->master = -1;
+      }
+      if (d->slave != NULL)
+      {
+	 free(d->slave);
+	 d->slave = NULL;
+      }
+      _error->DumpErrors(std::cerr, GlobalError::DEBUG, false);
+   }
+   _error->RevertToStack();
+}
+									/*}}}*/
+void pkgDPkgPM::SetupSlavePtyMagic()					/*{{{*/
+{
+   if(d->master == -1 || d->slave == NULL)
+      return;
+
+   if (close(d->master) == -1)
+      _error->FatalE("close", "Closing master %d in child failed!", d->master);
+   d->master = -1;
+   if (setsid() == -1)
+      _error->FatalE("setsid", "Starting a new session for child failed!");
+
+   int const slaveFd = open(d->slave, O_RDWR | O_NOCTTY);
+   if (slaveFd == -1)
+      _error->FatalE("open", _("Can not write log (%s)"), _("Is /dev/pts mounted?"));
+   else if (ioctl(slaveFd, TIOCSCTTY, 0) < 0)
+      _error->FatalE("ioctl", "Setting TIOCSCTTY for slave fd %d failed!", slaveFd);
+   else
+   {
+      unsigned short i = 0;
+      if (d->direct_stdin == true)
+	 ++i;
+      for (; i < 3; ++i)
+	 if (dup2(slaveFd, i) == -1)
+	    _error->FatalE("dup2", "Dupping %d to %d in child failed!", slaveFd, i);
+
+      if (d->tt_is_valid == true && tcsetattr(STDIN_FILENO, TCSANOW, &d->tt) < 0)
+	 _error->FatalE("tcsetattr", "Setting in Setup via TCSANOW for slave fd %d failed!", slaveFd);
+   }
+
+   if (slaveFd != -1)
+      close(slaveFd);
+}
+									/*}}}*/
+void pkgDPkgPM::StopPtyMagic()						/*{{{*/
+{
+   if (d->slave != NULL)
+      free(d->slave);
+   d->slave = NULL;
+   if (d->protect_slave_from_dying != -1)
+   {
+      close(d->protect_slave_from_dying);
+      d->protect_slave_from_dying = -1;
+   }
+   if(d->master >= 0)
+   {
+      if (d->tt_is_valid == true && tcsetattr(STDIN_FILENO, TCSAFLUSH, &d->tt) == -1)
+	 _error->FatalE("tcsetattr", "Setting in Stop via TCSAFLUSH for stdin failed!");
+      close(d->master);
+      d->master = -1;
+   }
+}
+									/*}}}*/
+static void cleanUpTmpDir(char * const tmpdir)				/*{{{*/
+{
+   if (tmpdir == nullptr)
+      return;
+   DIR * const D = opendir(tmpdir);
+   if (D == nullptr)
+      _error->Errno("opendir", _("Unable to read %s"), tmpdir);
+   else
+   {
+      auto const dfd = dirfd(D);
+      for (struct dirent *Ent = readdir(D); Ent != nullptr; Ent = readdir(D))
+      {
+	 if (Ent->d_name[0] == '.')
+	    continue;
+#ifdef _DIRENT_HAVE_D_TYPE
+	 if (unlikely(Ent->d_type != DT_LNK && Ent->d_type != DT_UNKNOWN))
+	    continue;
+#endif
+	 if (unlikely(unlinkat(dfd, Ent->d_name, 0) != 0))
+	    break;
+      }
+      closedir(D);
+      rmdir(tmpdir);
+   }
+   free(tmpdir);
+}
+									/*}}}*/
+
+// DPkgPM::Go - Run the sequence					/*{{{*/
+// ---------------------------------------------------------------------
+/* This globs the operations and calls dpkg
+ *
+ * If it is called with a progress object apt will report the install
+ * progress to this object. It maps the dpkg states a package goes
+ * through to human readable (and i10n-able)
+ * names and calculates a percentage for each step.
+ */
+static bool ItemIsEssential(pkgDPkgPM::Item const &I)
+{
+   static auto const cachegen = _config->Find("pkgCacheGen::Essential");
+   if (cachegen == "none" || cachegen == "native")
+      return true;
+   if (unlikely(I.Pkg.end()))
+      return true;
+   return (I.Pkg->Flags & pkgCache::Flag::Essential) != 0;
+}
+static bool ItemIsProtected(pkgDPkgPM::Item const &I)
+{
+   static auto const cachegen = _config->Find("pkgCacheGen::Protected");
+   if (cachegen == "none" || cachegen == "native")
+      return true;
+   if (unlikely(I.Pkg.end()))
+      return true;
+   return (I.Pkg->Flags & pkgCache::Flag::Important) != 0;
+}
+bool pkgDPkgPM::ExpandPendingCalls(std::vector<Item> &List, pkgDepCache &Cache)
+{
+   {
+      std::unordered_set<decltype(pkgCache::Package::ID)> alreadyRemoved;
+      for (auto && I : List)
+	 if (I.Op == Item::Remove || I.Op == Item::Purge)
+	    alreadyRemoved.insert(I.Pkg->ID);
+      std::remove_reference<decltype(List)>::type AppendList;
+      for (auto Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
+	 if (Cache[Pkg].Delete() && alreadyRemoved.insert(Pkg->ID).second == true)
+	    AppendList.emplace_back(Cache[Pkg].Purge() ? Item::Purge : Item::Remove, Pkg);
+      std::move(AppendList.begin(), AppendList.end(), std::back_inserter(List));
+   }
+   {
+      std::unordered_set<decltype(pkgCache::Package::ID)> alreadyConfigured;
+      for (auto && I : List)
+	 if (I.Op == Item::Configure)
+	    alreadyConfigured.insert(I.Pkg->ID);
+      std::remove_reference<decltype(List)>::type AppendList;
+      for (auto && I : List)
+	 if (I.Op == Item::Install && alreadyConfigured.insert(I.Pkg->ID).second == true)
+	    AppendList.emplace_back(Item::Configure, I.Pkg);
+      for (auto Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
+	 if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
+	       Cache[Pkg].Delete() == false && alreadyConfigured.insert(Pkg->ID).second == true)
+	    AppendList.emplace_back(Item::Configure, Pkg);
+      std::move(AppendList.begin(), AppendList.end(), std::back_inserter(List));
+   }
+   return true;
+}
+bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)
+{
+   struct Inhibitor
+   {
+      int Fd = -1;
+      Inhibitor()
+      {
+	 if (_config->FindB("DPkg::Inhibit-Shutdown", true))
+	    Fd = Inhibit("shutdown", "APT", "APT is installing or removing packages", "block");
+      }
+      ~Inhibitor()
+      {
+	 if (Fd > 0)
+	    close(Fd);
+      }
+   } inhibitor;
+
+   // explicitly remove&configure everything for hookscripts and progress building
+   // we need them only temporarily through, so keep the length and erase afterwards
+   decltype(List)::const_iterator::difference_type explicitIdx =
+      std::distance(List.cbegin(), List.cend());
+   ExpandPendingCalls(List, Cache);
+
+   /* if dpkg told us that it has already done everything to the package we wanted it to do,
+      we shouldn't ask it for "more" later. That can e.g. happen if packages without conffiles
+      are purged as they will have pass through the purge states on remove already */
+   auto const StripAlreadyDoneFrom = [&](APT::VersionVector & Pending) {
+      Pending.erase(std::remove_if(Pending.begin(), Pending.end(), [&](pkgCache::VerIterator const &Ver) {
+	    auto const PN = Ver.ParentPkg().FullName();
+	    auto const POD = PackageOpsDone.find(PN);
+	    if (POD == PackageOpsDone.end())
+	       return false;
+	    return PackageOps[PN].size() <= POD->second;
+	 }), Pending.end());
+   };
+
+   pkgPackageManager::SigINTStop = false;
+   d->progress = progress;
+
+   // Generate the base argument list for dpkg
+   std::vector<std::string> const sArgs = debSystem::GetDpkgBaseCommand();
+   std::vector<const char *> Args(sArgs.size(), NULL);
+   std::transform(sArgs.begin(), sArgs.end(), Args.begin(),
+	 [](std::string const &s) { return s.c_str(); });
+   unsigned long long const StartSize = std::accumulate(sArgs.begin(), sArgs.end(), 0llu,
+	 [](unsigned long long const i, std::string const &s) { return i + s.length(); });
+   size_t const BaseArgs = Args.size();
+
+   fd_set rfds;
+   struct timespec tv;
+
+   // try to figure out the max environment size
+   int OSArgMax = sysconf(_SC_ARG_MAX);
+   if(OSArgMax < 0)
+      OSArgMax = 32*1024;
+   OSArgMax -= EnvironmentSize() - 2*1024;
+   unsigned int const MaxArgBytes = _config->FindI("Dpkg::MaxArgBytes", OSArgMax);
+   bool const NoTriggers = _config->FindB("DPkg::NoTriggers", true);
+
+   if (RunScripts("DPkg::Pre-Invoke") == false)
+      return false;
+
+   if (RunScriptsWithPkgs("DPkg::Pre-Install-Pkgs") == false)
+      return false;
+
+   auto const noopDPkgInvocation = _config->FindB("Debug::pkgDPkgPM",false);
+   // store auto-bits as they are supposed to be after dpkg is run
+   if (noopDPkgInvocation == false)
+      Cache.writeStateFile(NULL);
+
+   bool dpkg_recursive_install = _config->FindB("dpkg::install::recursive", false);
+   if (_config->FindB("dpkg::install::recursive::force", false) == false)
+   {
+      // dpkg uses a sorted treewalk since that version which enables the workaround to work
+      auto const dpkgpkg = Cache.FindPkg("dpkg");
+      if (likely(dpkgpkg.end() == false && dpkgpkg->CurrentVer != 0))
+	 dpkg_recursive_install = Cache.VS().CmpVersion("1.18.5", dpkgpkg.CurrentVer().VerStr()) <= 0;
+   }
+   // no point in doing this dance for a handful of packages only
+   unsigned int const dpkg_recursive_install_min = _config->FindI("dpkg::install::recursive::minimum", 5);
+   // FIXME: workaround for dpkg bug, see our ./test-bug-740843-versioned-up-down-breaks test
+   bool const dpkg_recursive_install_numbered = _config->FindB("dpkg::install::recursive::numbered", true);
+
+   // for the progress
+   BuildPackagesProgressMap();
+
+   APT::StateChanges approvedStates;
+   if (_config->FindB("dpkg::selection::remove::approved", true))
+   {
+      for (auto && I : List)
+	 if (I.Op == Item::Purge)
+	    approvedStates.Purge(FindToBeRemovedVersion(I.Pkg));
+	 else if (I.Op == Item::Remove)
+	    approvedStates.Remove(FindToBeRemovedVersion(I.Pkg));
+   }
+
+   // Skip removes if we install another architecture of this package soon (crossgrade)
+   // We can't just skip them all the time as it could be an ordering requirement [of another package]
+   if ((approvedStates.Remove().empty() == false || approvedStates.Purge().empty() == false) &&
+	 _config->FindB("dpkg::remove::crossgrade::implicit", true) == true)
+   {
+      std::unordered_set<decltype(pkgCache::Package::ID)> crossgraded;
+      std::vector<std::pair<Item*, std::string>> toCrossgrade;
+      auto const PlanedEnd = std::next(List.begin(), explicitIdx);
+      for (auto I = List.begin(); I != PlanedEnd; ++I)
+      {
+	 if (I->Op != Item::Remove && I->Op != Item::Purge)
+	    continue;
+
+	 auto const Grp = I->Pkg.Group();
+	 size_t installedInstances = 0, wannabeInstances = 0;
+	 bool multiArchInstances = false;
+	 for (auto Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
+	 {
+	    if (Pkg->CurrentVer != 0)
+	    {
+	       ++installedInstances;
+	       if (Cache[Pkg].Delete() == false)
+		  ++wannabeInstances;
+	    }
+	    else if (PackageOps.find(Pkg.FullName()) != PackageOps.end())
+	       ++wannabeInstances;
+	    if (multiArchInstances == false)
+	    {
+	       auto const V = Cache[Pkg].InstVerIter(Cache);
+	       if (V.end() == false && (Pkg->CurrentVer == 0 || V != Pkg.CurrentVer()))
+		  multiArchInstances = ((V->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same);
+	    }
+	 }
+	 /* theoretically the installed check would be enough as some wannabe will
+	    be first and hence be the crossgrade we were looking for, but #844300
+	    prevents this so we keep these situations explicit removes.
+	    It is also the reason why neither of them can be a M-A:same package */
+	 if (installedInstances == 1 && wannabeInstances == 1 && multiArchInstances == false)
+	 {
+	    auto const FirstInstall = std::find_if_not(I, List.end(),
+		  [](Item const &i) { return i.Op == Item::Remove || i.Op == Item::Purge; });
+	    auto const LastInstall = std::find_if_not(FirstInstall, List.end(),
+		  [](Item const &i) { return i.Op == Item::Install; });
+	    auto const crosser = std::find_if(FirstInstall, LastInstall,
+		  [&I](Item const &i) { return i.Pkg->Group == I->Pkg->Group; });
+	    if (crosser != LastInstall)
+	    {
+	       crossgraded.insert(I->Pkg->ID);
+	       toCrossgrade.emplace_back(&(*I), crosser->Pkg.FullName());
+	    }
+	 }
+      }
+      for (auto I = PlanedEnd; I != List.end(); ++I)
+      {
+	 if (I->Op != Item::Remove && I->Op != Item::Purge)
+	    continue;
+
+	 auto const Grp = I->Pkg.Group();
+	 for (auto Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
+	 {
+	    if (Pkg == I->Pkg || Cache[Pkg].Install() == false)
+	       continue;
+	    toCrossgrade.emplace_back(&(*I), Pkg.FullName());
+	    break;
+	 }
+      }
+      for (auto C : toCrossgrade)
+      {
+	 // we never do purges on packages which are crossgraded, even if "requested"
+	 if (C.first->Op == Item::Purge)
+	 {
+	    C.first->Op = Item::Remove; // crossgrades should never be purged
+	    auto && Purges = approvedStates.Purge();
+	    auto const Ver = std::find_if(
+#if __GNUC__ >= 5 || (__GNUC_MINOR__ >= 9 && __GNUC__ >= 4)
+	       Purges.cbegin(), Purges.cend(),
+#else
+	       Purges.begin(), Purges.end(),
+#endif
+	       [&C](pkgCache::VerIterator const &V) { return V.ParentPkg() == C.first->Pkg; });
+	    approvedStates.Remove(*Ver);
+	    Purges.erase(Ver);
+	    auto && RemOp = PackageOps[C.first->Pkg.FullName()];
+	    if (RemOp.size() == 4)
+	    {
+	       RemOp.erase(std::next(RemOp.begin(), 2), RemOp.end());
+	       PackagesTotal -= 2;
+	    }
+	    else
+	    _error->Warning("Unexpected amount of planned ops for package %s: %lu", C.first->Pkg.FullName().c_str(), RemOp.size());
+	 }
+      }
+      if (crossgraded.empty() == false)
+      {
+	 auto const oldsize = List.size();
+	 List.erase(std::remove_if(List.begin(), PlanedEnd,
+	       [&crossgraded](Item const &i){
+		  return (i.Op == Item::Remove || i.Op == Item::Purge) &&
+		     crossgraded.find(i.Pkg->ID) != crossgraded.end();
+	       }), PlanedEnd);
+	 explicitIdx -= (oldsize - List.size());
+      }
+   }
+
+   APT::StateChanges currentStates;
+   if (_config->FindB("dpkg::selection::current::saveandrestore", true))
+   {
+      for (auto Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
+	 if (Pkg->CurrentVer == 0)
+	    continue;
+	 else if (Pkg->SelectedState == pkgCache::State::Purge)
+	    currentStates.Purge(FindToBeRemovedVersion(Pkg));
+	 else if (Pkg->SelectedState == pkgCache::State::DeInstall)
+	    currentStates.Remove(FindToBeRemovedVersion(Pkg));
+      if (currentStates.empty() == false)
+      {
+	 APT::StateChanges cleanStates;
+	 for (auto && P: currentStates.Remove())
+	    cleanStates.Install(P);
+	 for (auto && P: currentStates.Purge())
+	    cleanStates.Install(P);
+	 if (cleanStates.Save(false) == false)
+	    return _error->Error("Couldn't clean the currently selected dpkg states");
+      }
+   }
+
+   if (_config->FindB("dpkg::selection::remove::approved", true))
+   {
+      if (approvedStates.Save(false) == false)
+      {
+	 _error->Error("Couldn't record the approved state changes as dpkg selection states");
+	 if (currentStates.Save(false) == false)
+	    _error->Error("Couldn't restore dpkg selection states which were present before this interaction!");
+	 return false;
+      }
+
+      List.erase(std::next(List.begin(), explicitIdx), List.end());
+
+      std::vector<bool> toBeRemoved(Cache.Head().PackageCount, false);
+      for (auto && I: approvedStates.Remove())
+	 toBeRemoved[I.ParentPkg()->ID] = true;
+      for (auto && I: approvedStates.Purge())
+	 toBeRemoved[I.ParentPkg()->ID] = true;
+
+      for (auto && I: List)
+	 if (I.Op == Item::Remove || I.Op == Item::Purge)
+	    toBeRemoved[I.Pkg->ID] = false;
+
+      bool const RemovePending = std::find(toBeRemoved.begin(), toBeRemoved.end(), true) != toBeRemoved.end();
+      bool const PurgePending = approvedStates.Purge().empty() == false;
+      if (RemovePending != false || PurgePending != false)
+	 List.emplace_back(Item::ConfigurePending, pkgCache::PkgIterator());
+      if (RemovePending)
+	 List.emplace_back(Item::RemovePending, pkgCache::PkgIterator());
+      if (PurgePending)
+	 List.emplace_back(Item::PurgePending, pkgCache::PkgIterator());
+
+      // support subpressing of triggers processing for special
+      // cases like d-i that runs the triggers handling manually
+      if (_config->FindB("DPkg::ConfigurePending", true))
+	 List.emplace_back(Item::ConfigurePending, pkgCache::PkgIterator());
+   }
+   bool const TriggersPending = _config->FindB("DPkg::TriggersPending", false);
+
+   d->stdin_is_dev_null = false;
+
+   // create log
+   OpenLog();
+
+   bool dpkgMultiArch = _system->MultiArchSupported();
+   bool dpkgProtectedField = debSystem::AssertFeature("protected-field");
+
+   // start pty magic before the loop
+   StartPtyMagic();
+
+   // Tell the progress that its starting and fork dpkg
+   d->progress->Start(d->master);
+
+   // this loop is runs once per dpkg operation
+   vector<Item>::const_iterator I = List.cbegin();
+   while (I != List.end())
+   {
+      // Do all actions with the same Op in one run
+      vector<Item>::const_iterator J = I;
+      if (TriggersPending == true)
+	 for (; J != List.end(); ++J)
+	 {
+	    if (J->Op == I->Op)
+	       continue;
+	    if (J->Op != Item::TriggersPending)
+	       break;
+	    vector<Item>::const_iterator T = J + 1;
+	    if (T != List.end() && T->Op == I->Op)
+	       continue;
+	    break;
+	 }
+      else if (J->Op == Item::Remove || J->Op == Item::Purge)
+	 J = std::find_if(J, List.cend(), [](Item const &I) { return I.Op != Item::Remove && I.Op != Item::Purge; });
+      else
+	 J = std::find_if(J, List.cend(), [&J](Item const &I) { return I.Op != J->Op; });
+
+      auto const size = (J - I) + 10;
+
+      // start with the baseset of arguments
+      auto Size = StartSize;
+      Args.erase(Args.begin() + BaseArgs, Args.end());
+      Args.reserve(size);
+      // keep track of allocated strings for multiarch package names
+      std::vector<char *> Packages(size, nullptr);
+
+      int fd[2];
+      if (pipe(fd) != 0)
+	 return _error->Errno("pipe","Failed to create IPC pipe to dpkg");
+
+#define ADDARG(X) do { const char *arg = (X); Args.push_back(arg); Size += strlen(arg); } while (0)
+#define ADDARGC(X) ADDARG(X)
+
+      ADDARGC("--status-fd");
+      char status_fd_buf[20];
+      snprintf(status_fd_buf,sizeof(status_fd_buf),"%i", fd[1]);
+      ADDARG(status_fd_buf);
+      unsigned long const Op = I->Op;
+
+      if (NoTriggers == true && I->Op != Item::TriggersPending &&
+	  (I->Op != Item::ConfigurePending || std::next(I) != List.end()))
+      {
+	 ADDARGC("--no-triggers");
+      }
+
+      switch (I->Op)
+      {
+	 case Item::Remove:
+	 case Item::Purge:
+	 ADDARGC("--force-depends");
+	 ADDARGC("--abort-after=1");
+	 if (std::any_of(I, J, ItemIsEssential))
+	 {
+	    ADDARGC("--force-remove-essential");
+	 }
+	 if (dpkgProtectedField && std::any_of(I, J, ItemIsProtected))
+	 {
+	    ADDARGC("--force-remove-protected");
+	 }
+	 ADDARGC("--remove");
+	 break;
+
+	 case Item::Configure:
+	 ADDARGC("--configure");
+	 break;
+
+	 case Item::ConfigurePending:
+	 ADDARGC("--configure");
+	 ADDARGC("--pending");
+	 break;
+
+	 case Item::TriggersPending:
+	 ADDARGC("--triggers-only");
+	 ADDARGC("--pending");
+	 break;
+
+	 case Item::RemovePending:
+	 ADDARGC("--remove");
+	 ADDARGC("--pending");
+	 break;
+
+	 case Item::PurgePending:
+	 ADDARGC("--purge");
+	 ADDARGC("--pending");
+	 break;
+
+	 case Item::Install:
+	 ADDARGC("--unpack");
+	 ADDARGC("--auto-deconfigure");
+	 // dpkg < 1.20.8 needs --force-remove-protected to deconfigure protected packages
+	 if (dpkgProtectedField)
+	    ADDARGC("--force-remove-protected");
+	 break;
+      }
+
+      char * tmpdir_to_free = nullptr;
+
+      // Write in the file or package names
+      if (I->Op == Item::Install)
+      {
+	 auto const installsToDo = J - I;
+	 if (dpkg_recursive_install == true && dpkg_recursive_install_min < installsToDo)
+	 {
+	    std::string tmpdir;
+	    strprintf(tmpdir, "%s/apt-dpkg-install-XXXXXX", GetTempDir().c_str());
+	    tmpdir_to_free = strndup(tmpdir.data(), tmpdir.length());
+	    if (mkdtemp(tmpdir_to_free) == nullptr)
+	       return _error->Errno("DPkg::Go", "mkdtemp of %s failed in preparation of calling dpkg unpack", tmpdir_to_free);
+
+	    char p = 1;
+	    for (auto c = installsToDo - 1; (c = c/10) != 0; ++p);
+	    for (unsigned long n = 0; I != J; ++n, ++I)
+	    {
+	       if (I->File[0] != '/')
+		  return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str());
+	       auto file = flNotDir(I->File);
+	       if (flExtension(file) != "deb")
+		  file.append(".deb");
+	       std::string linkpath;
+	       if (dpkg_recursive_install_numbered)
+		  strprintf(linkpath, "%s/%.*lu-%s", tmpdir_to_free, p, n, file.c_str());
+	       else
+		  strprintf(linkpath, "%s/%s", tmpdir_to_free, file.c_str());
+	       if (symlink(I->File.c_str(), linkpath.c_str()) != 0)
+		  return _error->Errno("DPkg::Go", "Symlinking %s to %s failed!", I->File.c_str(), linkpath.c_str());
+	    }
+	    ADDARGC("--recursive");
+	    ADDARG(tmpdir_to_free);
+	 }
+	 else
+	 {
+	    for (;I != J && Size < MaxArgBytes; ++I)
+	    {
+	       if (I->File[0] != '/')
+		  return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str());
+	       Args.push_back(I->File.c_str());
+	       Size += I->File.length();
+	    }
+	 }
+      }
+      else if (I->Op == Item::RemovePending)
+      {
+	 ++I;
+	 StripAlreadyDoneFrom(approvedStates.Remove());
+	 if (approvedStates.Remove().empty())
+	    continue;
+      }
+      else if (I->Op == Item::PurgePending)
+      {
+	 ++I;
+	 // explicit removes of packages without conffiles passthrough the purge states instantly, too.
+	 // Setting these non-installed packages up for purging generates 'unknown pkg' warnings from dpkg
+	 StripAlreadyDoneFrom(approvedStates.Purge());
+	 if (approvedStates.Purge().empty())
+	    continue;
+	 std::remove_reference<decltype(approvedStates.Remove())>::type approvedRemoves;
+	 std::swap(approvedRemoves, approvedStates.Remove());
+	 // we apply it again here as an explicit remove in the ordering will have cleared the purge state
+	 if (approvedStates.Save(false) == false)
+	 {
+	    _error->Error("Couldn't record the approved purges as dpkg selection states");
+	    if (currentStates.Save(false) == false)
+	       _error->Error("Couldn't restore dpkg selection states which were present before this interaction!");
+	    return false;
+	 }
+	 std::swap(approvedRemoves, approvedStates.Remove());
+      }
+      else
+      {
+	 string const nativeArch = _config->Find("APT::Architecture");
+	 unsigned long const oldSize = I->Pkg.end() == false ? Size : 0;
+	 for (;I != J && Size < MaxArgBytes; ++I)
+	 {
+	    if((*I).Pkg.end() == true)
+	       continue;
+	    if (I->Op == Item::Configure && disappearedPkgs.find(I->Pkg.FullName(true)) != disappearedPkgs.end())
+	       continue;
+	    // We keep this here to allow "smooth" transitions from e.g. multiarch dpkg/ubuntu to dpkg/debian
+	    if (dpkgMultiArch == false && (I->Pkg.Arch() == nativeArch ||
+					   strcmp(I->Pkg.Arch(), "all") == 0 ||
+					   strcmp(I->Pkg.Arch(), "none") == 0))
+	    {
+	       char const * const name = I->Pkg.Name();
+	       ADDARG(name);
+	    }
+	    else
+	    {
+	       pkgCache::VerIterator PkgVer;
+	       std::string name = I->Pkg.Name();
+	       if (Op == Item::Remove)
+		  PkgVer = I->Pkg.CurrentVer();
+	       else if (Op == Item::Purge)
+	       {
+		  // we purge later with --purge --pending, so if it isn't installed (aka rc-only), skip it here
+		  PkgVer = I->Pkg.CurrentVer();
+		  if (PkgVer.end() == true)
+		     continue;
+	       }
+	       else
+		  PkgVer = Cache[I->Pkg].InstVerIter(Cache);
+	       if (strcmp(I->Pkg.Arch(), "none") == 0)
+		  ; // never arch-qualify a package without an arch
+	       else if (PkgVer.end() == false)
+                  name.append(":").append(PkgVer.Arch());
+               else
+                  _error->Warning("Can not find PkgVer for '%s'", name.c_str());
+	       char * const fullname = strdup(name.c_str());
+	       Packages.push_back(fullname);
+	       ADDARG(fullname);
+	    }
+	 }
+	 // skip configure action if all scheduled packages disappeared
+	 if (oldSize == Size)
+	    continue;
+      }
+#undef ADDARGC
+#undef ADDARG
+
+      J = I;
+
+      if (noopDPkgInvocation == true)
+      {
+	 for (std::vector<const char *>::const_iterator a = Args.begin();
+	      a != Args.end(); ++a)
+	    clog << *a << ' ';
+	 clog << endl;
+	 for (std::vector<char *>::const_iterator p = Packages.begin();
+	       p != Packages.end(); ++p)
+	    free(*p);
+	 Packages.clear();
+	 close(fd[0]);
+	 close(fd[1]);
+	 cleanUpTmpDir(tmpdir_to_free);
+	 continue;
+      }
+      Args.push_back(NULL);
+
+      cout << flush;
+      clog << flush;
+      cerr << flush;
+
+      /* Mask off sig int/quit. We do this because dpkg also does when
+         it forks scripts. What happens is that when you hit ctrl-c it sends
+	 it to all processes in the group. Since dpkg ignores the signal
+	 it doesn't die but we do! So we must also ignore it */
+      sighandler_t old_SIGQUIT = signal(SIGQUIT,SIG_IGN);
+      sighandler_t old_SIGINT = signal(SIGINT,SigINT);
+
+      // Check here for any SIGINT
+      if (pkgPackageManager::SigINTStop && (Op == Item::Remove || Op == Item::Purge || Op == Item::Install))
+         break;
+
+      // ignore SIGHUP as well (debian #463030)
+      sighandler_t old_SIGHUP = signal(SIGHUP,SIG_IGN);
+
+      // now run dpkg
+      d->progress->StartDpkg();
+      std::set<int> KeepFDs;
+      KeepFDs.insert(fd[1]);
+      MergeKeepFdsFromConfiguration(KeepFDs);
+      pid_t Child = ExecFork(KeepFDs);
+      if (Child == 0)
+      {
+	 // This is the child
+	 SetupSlavePtyMagic();
+	 close(fd[0]); // close the read end of the pipe
+
+	 debSystem::DpkgChrootDirectory();
+
+	 if (chdir(_config->FindDir("DPkg::Run-Directory","/").c_str()) != 0)
+	    _exit(100);
+
+	 if (_config->FindB("DPkg::FlushSTDIN",true) == true && isatty(STDIN_FILENO))
+	 {
+	    int Flags;
+            int dummy = 0;
+	    if ((Flags = fcntl(STDIN_FILENO,F_GETFL,dummy)) < 0)
+	       _exit(100);
+
+	    // Discard everything in stdin before forking dpkg
+	    if (fcntl(STDIN_FILENO,F_SETFL,Flags | O_NONBLOCK) < 0)
+	       _exit(100);
+
+	    while (read(STDIN_FILENO,&dummy,1) == 1);
+
+	    if (fcntl(STDIN_FILENO,F_SETFL,Flags & (~(long)O_NONBLOCK)) < 0)
+	       _exit(100);
+	 }
+
+	 // if color support isn't enabled/disabled explicitly tell
+	 // dpkg to use the same state apt is using for its color support
+	 if (_config->FindB("APT::Color", false) == true)
+	    setenv("DPKG_COLORS", "always", 0);
+	 else
+	    setenv("DPKG_COLORS", "never", 0);
+
+	 if (_system->IsLocked() == true) {
+	    setenv("DPKG_FRONTEND_LOCKED", "true", 1);
+	 }
+	 if (_config->Find("DPkg::Path", "").empty() == false)
+	    setenv("PATH", _config->Find("DPkg::Path", "").c_str(), 1);
+
+	 execvp(Args[0], (char**) &Args[0]);
+	 cerr << "Could not exec dpkg!" << endl;
+	 _exit(100);
+      }
+
+      // we read from dpkg here
+      int const _dpkgin = fd[0];
+      close(fd[1]);                        // close the write end of the pipe
+      d->status_fd_reached_end_of_file = false;
+
+      // apply ionice
+      if (_config->FindB("DPkg::UseIoNice", false) == true)
+	 ionice(Child);
+
+      // setups fds
+      sigemptyset(&d->sigmask);
+      sigprocmask(SIG_BLOCK,&d->sigmask,&d->original_sigmask);
+
+      /* free vectors (and therefore memory) as we don't need the included data anymore */
+      for (std::vector<char *>::const_iterator p = Packages.begin();
+	   p != Packages.end(); ++p)
+	 free(*p);
+      Packages.clear();
+
+      // the result of the waitpid call
+      int Status = 0;
+      int res;
+      bool waitpid_failure = false;
+      bool dpkg_finished = false;
+      do
+      {
+	 if (dpkg_finished == false)
+	 {
+	    if ((res = waitpid(Child, &Status, WNOHANG)) == Child)
+	       dpkg_finished = true;
+	    else if (res < 0)
+	    {
+	       // error handling, waitpid returned -1
+	       if (errno == EINTR)
+		  continue;
+	       waitpid_failure = true;
+	       break;
+	    }
+	 }
+	 if (dpkg_finished && d->status_fd_reached_end_of_file)
+	    break;
+
+	 // wait for input or output here
+	 FD_ZERO(&rfds);
+	 if (d->master >= 0 && d->direct_stdin == false && d->stdin_is_dev_null == false)
+	    FD_SET(STDIN_FILENO, &rfds);
+	 FD_SET(_dpkgin, &rfds);
+	 if(d->master >= 0)
+	    FD_SET(d->master, &rfds);
+         tv.tv_sec = 0;
+         tv.tv_nsec = d->progress->GetPulseInterval();
+	 auto const select_ret = pselect(max(d->master, _dpkgin)+1, &rfds, NULL, NULL,
+			      &tv, &d->original_sigmask);
+         d->progress->Pulse();
+	 if (select_ret == 0)
+	    continue;
+	 else if (select_ret < 0 && errno == EINTR)
+	    continue;
+	 else if (select_ret < 0)
+	 {
+	    perror("select() returned error");
+	    continue;
+	 }
+
+	 if(d->master >= 0 && FD_ISSET(d->master, &rfds))
+	    DoTerminalPty(d->master);
+	 if(d->master >= 0 && FD_ISSET(0, &rfds))
+	    DoStdin(d->master);
+	 if(FD_ISSET(_dpkgin, &rfds))
+	    DoDpkgStatusFd(_dpkgin);
+
+      } while (true);
+      close(_dpkgin);
+
+      // Restore sig int/quit
+      signal(SIGQUIT,old_SIGQUIT);
+      signal(SIGINT,old_SIGINT);
+      signal(SIGHUP,old_SIGHUP);
+
+      cleanUpTmpDir(tmpdir_to_free);
+
+      if (waitpid_failure == true)
+      {
+	 strprintf(d->dpkg_error, "Sub-process %s couldn't be waited for.",Args[0]);
+	 _error->Error("%s", d->dpkg_error.c_str());
+	 break;
+      }
+
+      // Check for an error code.
+      if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
+      {
+	 // if it was set to "keep-dpkg-running" then we won't return
+	 // here but keep the loop going and just report it as a error
+	 // for later
+	 bool const stopOnError = _config->FindB("Dpkg::StopOnError",true);
+
+	 if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV)
+	    strprintf(d->dpkg_error, "Sub-process %s received a segmentation fault.",Args[0]);
+	 else if (WIFEXITED(Status) != 0)
+	    strprintf(d->dpkg_error, "Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status));
+	 else
+	    strprintf(d->dpkg_error, "Sub-process %s exited unexpectedly",Args[0]);
+	 _error->Error("%s", d->dpkg_error.c_str());
+
+	 if(stopOnError)
+	    break;
+      }
+   }
+   // dpkg is done at this point
+   StopPtyMagic();
+   CloseLog();
+
+   if (d->dpkg_error.empty() == false)
+   {
+      // no point in resetting packages we already completed removal for
+      StripAlreadyDoneFrom(approvedStates.Remove());
+      StripAlreadyDoneFrom(approvedStates.Purge());
+      APT::StateChanges undo;
+      auto && undoRem = approvedStates.Remove();
+      std::move(undoRem.begin(), undoRem.end(), std::back_inserter(undo.Install()));
+      auto && undoPur = approvedStates.Purge();
+      std::move(undoPur.begin(), undoPur.end(), std::back_inserter(undo.Install()));
+      approvedStates.clear();
+      if (undo.Save(false) == false)
+	 _error->Error("Couldn't revert dpkg selection for approved remove/purge after an error was encountered!");
+   }
+
+   StripAlreadyDoneFrom(currentStates.Remove());
+   StripAlreadyDoneFrom(currentStates.Purge());
+   if (currentStates.Save(false) == false)
+      _error->Error("Couldn't restore dpkg selection states which were present before this interaction!");
+
+   if (pkgPackageManager::SigINTStop)
+       _error->Warning(_("Operation was interrupted before it could finish"));
+
+   if (noopDPkgInvocation == false)
+   {
+      if (d->dpkg_error.empty() && (PackagesDone + 1) != PackagesTotal)
+      {
+	 std::string pkglist;
+	 for (auto const &PO: PackageOps)
+	    if (PO.second.size() != PackageOpsDone[PO.first])
+	    {
+	       if (pkglist.empty() == false)
+		  pkglist.append(" ");
+	       pkglist.append(PO.first);
+	    }
+	 /* who cares about correct progress? As we depend on it for skipping actions
+	    our parsing should be correct. People will no doubt be confused if they see
+	    this message, but the dpkg warning about unknown packages isn't much better
+	    from a user POV and combined we might have a chance to figure out what is wrong */
+	 _error->Warning("APT had planned for dpkg to do more than it reported back (%u vs %u).\n"
+	       "Affected packages: %s", PackagesDone, PackagesTotal, pkglist.c_str());
+      }
+
+      std::string const oldpkgcache = _config->FindFile("Dir::cache::pkgcache");
+      if (oldpkgcache.empty() == false && RealFileExists(oldpkgcache) == true &&
+	  RemoveFile("pkgDPkgPM::Go", oldpkgcache))
+      {
+	 std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
+	 if (srcpkgcache.empty() == false && RealFileExists(srcpkgcache) == true)
+	 {
+	    _error->PushToStack();
+	    pkgCacheFile CacheFile;
+	    CacheFile.BuildCaches(NULL, true);
+	    _error->RevertToStack();
+	 }
+      }
+   }
+
+   // disappearing packages can forward their auto-bit
+   if (disappearedPkgs.empty() == false)
+      Cache.writeStateFile(NULL);
+
+   d->progress->Stop();
+
+   if (RunScripts("DPkg::Post-Invoke") == false)
+      return false;
+
+   return d->dpkg_error.empty();
+}
+
+void SigINT(int /*sig*/) {
+   pkgPackageManager::SigINTStop = true;
+}
+									/*}}}*/
+// pkgDpkgPM::Reset - Dump the contents of the command list		/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+void pkgDPkgPM::Reset()
+{
+   List.erase(List.begin(),List.end());
+}
+									/*}}}*/
+// pkgDpkgPM::WriteApportReport - write out error report pkg failure	/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
+{
+   // If apport doesn't exist or isn't installed do nothing
+   // This e.g. prevents messages in 'universes' without apport
+   pkgCache::PkgIterator apportPkg = Cache.FindPkg("apport");
+   if (apportPkg.end() == true || apportPkg->CurrentVer == 0)
+      return;
+
+   string pkgname, reportfile, pkgver, arch;
+   string::size_type pos;
+   FILE *report;
+
+   if (_config->FindB("Dpkg::ApportFailureReport", true) == false)
+   {
+      std::clog << "configured to not write apport reports" << std::endl;
+      return;
+   }
+
+   // only report the first errors
+   if(pkgFailures > _config->FindI("APT::Apport::MaxReports", 3))
+   {
+      std::clog << _("No apport report written because MaxReports is reached already") << std::endl;
+      return;
+   }
+
+   // check if its not a follow up error
+   const char *needle = dgettext("dpkg", "dependency problems - leaving unconfigured");
+   if(strstr(errormsg, needle) != NULL) {
+      std::clog << _("No apport report written because the error message indicates its a followup error from a previous failure.") << std::endl;
+      return;
+   }
+
+   // do not report disk-full failures
+   if(strstr(errormsg, strerror(ENOSPC)) != NULL) {
+      std::clog << _("No apport report written because the error message indicates a disk full error") << std::endl;
+      return;
+   }
+
+   // do not report out-of-memory failures
+   if(strstr(errormsg, strerror(ENOMEM)) != NULL ||
+      strstr(errormsg, "failed to allocate memory") != NULL) {
+      std::clog << _("No apport report written because the error message indicates a out of memory error") << std::endl;
+      return;
+   }
+
+   // do not report bugs regarding inaccessible local files
+   if(strstr(errormsg, strerror(ENOENT)) != NULL ||
+      strstr(errormsg, "cannot access archive") != NULL) {
+      std::clog << _("No apport report written because the error message indicates an issue on the local system") << std::endl;
+      return;
+   }
+
+   // do not report errors encountered when decompressing packages
+   if(strstr(errormsg, "--fsys-tarfile returned error exit status 2") != NULL) {
+      std::clog << _("No apport report written because the error message indicates an issue on the local system") << std::endl;
+      return;
+   }
+
+   // do not report dpkg I/O errors, this is a format string, so we compare
+   // the prefix and the suffix of the error with the dpkg error message
+   vector<string> io_errors;
+   io_errors.push_back(string("failed to read"));
+   io_errors.push_back(string("failed to write"));
+   io_errors.push_back(string("failed to seek"));
+   io_errors.push_back(string("unexpected end of file or stream"));
+
+   for (vector<string>::iterator I = io_errors.begin(); I != io_errors.end(); ++I)
+   {
+      vector<string> list = VectorizeString(dgettext("dpkg", (*I).c_str()), '%');
+      if (list.size() > 1) {
+         // we need to split %s, VectorizeString only allows char so we need
+         // to kill the "s" manually
+         if (list[1].size() > 1) {
+            list[1].erase(0, 1);
+            if(strstr(errormsg, list[0].c_str()) &&
+               strstr(errormsg, list[1].c_str())) {
+               std::clog << _("No apport report written because the error message indicates a dpkg I/O error") << std::endl;
+               return;
+            }
+         }
+      }
+   }
+
+   // get the pkgname and reportfile
+   pkgname = flNotDir(pkgpath);
+   pos = pkgname.find('_');
+   if(pos != string::npos)
+      pkgname = pkgname.substr(0, pos);
+
+   // find the package version and source package name
+   pkgCache::PkgIterator Pkg = Cache.FindPkg(pkgname);
+   if (Pkg.end() == true)
+   {
+      if (pos == std::string::npos || _config->FindB("dpkg::install::recursive::numbered", true) == false)
+	 return;
+      auto const dash = pkgname.find_first_not_of("0123456789");
+      if (dash == std::string::npos || pkgname[dash] != '-')
+	 return;
+      pkgname.erase(0, dash + 1);
+      Pkg = Cache.FindPkg(pkgname);
+      if (Pkg.end() == true)
+	 return;
+   }
+   pkgCache::VerIterator Ver = Cache.GetCandidateVersion(Pkg);
+   if (Ver.end() == true)
+      return;
+   pkgver = Ver.VerStr() == NULL ? "unknown" : Ver.VerStr();
+
+   // if the file exists already, we check:
+   // - if it was reported already (touched by apport). 
+   //   If not, we do nothing, otherwise
+   //    we overwrite it. This is the same behaviour as apport
+   // - if we have a report with the same pkgversion already
+   //   then we skip it
+   _config->CndSet("Dir::Apport", "var/crash");
+   reportfile = flCombine(_config->FindDir("Dir::Apport", "var/crash"), pkgname+".0.crash");
+   if(FileExists(reportfile))
+   {
+      struct stat buf;
+      char strbuf[255];
+
+      // check atime/mtime
+      stat(reportfile.c_str(), &buf);
+      if(buf.st_mtime > buf.st_atime)
+	 return;
+
+      // check if the existing report is the same version
+      report = fopen(reportfile.c_str(),"r");
+      while(fgets(strbuf, sizeof(strbuf), report) != NULL)
+      {
+	 if(strstr(strbuf,"Package:") == strbuf)
+	 {
+	    char pkgname[255], version[255];
+	    if(sscanf(strbuf, "Package: %254s %254s", pkgname, version) == 2)
+	       if(strcmp(pkgver.c_str(), version) == 0)
+	       {
+		  fclose(report);
+		  return;
+	       }
+	 }
+      }
+      fclose(report);
+   }
+
+   // now write the report
+   arch = _config->Find("APT::Architecture");
+   report = fopen(reportfile.c_str(),"w");
+   if(report == NULL)
+      return;
+   if(_config->FindB("DPkgPM::InitialReportOnly",false) == true)
+      chmod(reportfile.c_str(), 0);
+   else
+      chmod(reportfile.c_str(), 0600);
+   fprintf(report, "ProblemType: Package\n");
+   fprintf(report, "Architecture: %s\n", arch.c_str());
+   time_t now = time(NULL);
+   char ctime_buf[26];	// need at least 26 bytes according to ctime(3)
+   fprintf(report, "Date: %s" , ctime_r(&now, ctime_buf));
+   fprintf(report, "Package: %s %s\n", pkgname.c_str(), pkgver.c_str());
+   fprintf(report, "SourcePackage: %s\n", Ver.SourcePkgName());
+   fprintf(report, "ErrorMessage:\n %s\n", errormsg);
+
+   // ensure that the log is flushed
+   if(d->term_out)
+      fflush(d->term_out);
+
+   // attach terminal log it if we have it
+   string logfile_name = _config->FindFile("Dir::Log::Terminal", "/dev/null");
+   if (logfile_name != "/dev/null")
+   {
+      FILE *log = NULL;
+
+      fprintf(report, "DpkgTerminalLog:\n");
+      log = fopen(logfile_name.c_str(),"r");
+      if(log != NULL)
+      {
+	 char buf[1024];
+	 while( fgets(buf, sizeof(buf), log) != NULL)
+	    fprintf(report, " %s", buf);
+         fprintf(report, " \n");
+	 fclose(log);
+      }
+   }
+
+   // attach history log it if we have it
+   string histfile_name = _config->FindFile("Dir::Log::History", "/dev/null");
+   if (histfile_name != "/dev/null")
+   {
+      fprintf(report, "DpkgHistoryLog:\n");
+      FILE* log = fopen(histfile_name.c_str(),"r");
+      if(log != NULL)
+      {
+	 char buf[1024];
+	 while( fgets(buf, sizeof(buf), log) != NULL)
+	    fprintf(report, " %s", buf);
+	 fclose(log);
+      }
+   }
+
+   // log the ordering, see dpkgpm.h and the "Ops" enum there
+   fprintf(report, "AptOrdering:\n");
+   for (auto && I : List)
+   {
+      char const * opstr = nullptr;
+      switch (I.Op)
+      {
+	 case Item::Install: opstr = "Install"; break;
+	 case Item::Configure: opstr = "Configure"; break;
+	 case Item::Remove: opstr = "Remove"; break;
+	 case Item::Purge: opstr = "Purge"; break;
+	 case Item::ConfigurePending: opstr = "ConfigurePending"; break;
+	 case Item::TriggersPending: opstr = "TriggersPending"; break;
+	 case Item::RemovePending: opstr = "RemovePending"; break;
+	 case Item::PurgePending: opstr = "PurgePending"; break;
+      }
+      auto const pkgname = I.Pkg.end() ? "NULL" : I.Pkg.FullName();
+      fprintf(report, " %s: %s\n", pkgname.c_str(), opstr);
+   }
+
+   // attach dmesg log (to learn about segfaults)
+   if (FileExists("/bin/dmesg"))
+   {
+      fprintf(report, "Dmesg:\n");
+      FILE *log = popen("/bin/dmesg","r");
+      if(log != NULL)
+      {
+	 char buf[1024];
+	 while( fgets(buf, sizeof(buf), log) != NULL)
+	    fprintf(report, " %s", buf);
+	 pclose(log);
+      }
+   }
+
+   // attach df -l log (to learn about filesystem status)
+   if (FileExists("/bin/df"))
+   {
+
+      fprintf(report, "Df:\n");
+      FILE *log = popen("/bin/df -l -x squashfs","r");
+      if(log != NULL)
+      {
+	 char buf[1024];
+	 while( fgets(buf, sizeof(buf), log) != NULL)
+	    fprintf(report, " %s", buf);
+	 pclose(log);
+      }
+   }
+
+   fclose(report);
+
+}
+									/*}}}*/
diff --git a/apt-pkg/deb/dpkgpm.h b/apt-pkg/deb/dpkgpm.h
new file mode 100644
index 0000000..caf7d35
--- /dev/null
+++ b/apt-pkg/deb/dpkgpm.h
@@ -0,0 +1,135 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+
+   DPKG Package Manager - Provide an interface to dpkg
+   
+   ##################################################################### */
+									/*}}}*/
+#ifndef PKGLIB_DPKGPM_H
+#define PKGLIB_DPKGPM_H
+
+#include <apt-pkg/macros.h>
+#include <apt-pkg/packagemanager.h>
+#include <apt-pkg/pkgcache.h>
+
+#include <map>
+#include <string>
+#include <vector>
+#include <stdio.h>
+
+
+class pkgDepCache;
+namespace APT { namespace Progress { class PackageManager; } }
+
+
+class pkgDPkgPMPrivate;
+
+
+class APT_PUBLIC pkgDPkgPM : public pkgPackageManager
+{
+   private:
+   pkgDPkgPMPrivate * const d;
+
+   /** \brief record the disappear action and handle accordingly
+
+      dpkg let packages disappear then they have no files any longer and
+      nothing depends on them. We need to collect this as dpkg as well as
+      APT doesn't know beforehand that the package will disappear, so the
+      only possible option is to tell the user afterwards about it.
+      To enhance the experience we also try to forward the auto-install
+      flag so the disappear-causer(s) are not autoremoved next time -
+      for the transfer to happen the disappeared version needs to depend
+      on the package the flag should be forwarded to and this package
+      needs to declare a Replaces on the disappeared package.
+      \param pkgname Name of the package that disappeared
+   */
+   APT_HIDDEN void handleDisappearAction(std::string const &pkgname);
+   APT_HIDDEN void handleCrossUpgradeAction(std::string const &pkgname);
+
+   protected:
+   int pkgFailures;
+
+   // progress reporting
+   struct DpkgState 
+   {
+      const char *state;     // the dpkg state (e.g. "unpack")
+      const char *str;       // the human readable translation of the state
+   };
+
+   // the dpkg states that the pkg will run through, the string is 
+   // the package, the vector contains the dpkg states that the package
+   // will go through
+   std::map<std::string,std::vector<struct DpkgState> > PackageOps;
+   // the dpkg states that are already done; the string is the package
+   // the int is the state that is already done (e.g. a package that is
+   // going to be install is already in state "half-installed")
+   std::map<std::string,unsigned int> PackageOpsDone;
+
+   // progress reporting
+   unsigned int PackagesDone;
+   unsigned int PackagesTotal;
+
+   public:
+   struct Item
+   {
+      enum Ops {Install, Configure, Remove, Purge, ConfigurePending, TriggersPending,
+         RemovePending, PurgePending } Op;
+      std::string File;
+      PkgIterator Pkg;
+      Item(Ops Op,PkgIterator Pkg,std::string File = "") : Op(Op),
+            File(File), Pkg(Pkg) {};
+      Item() {};
+   };
+   protected:
+   std::vector<Item> List;
+
+   // Helpers
+   bool RunScriptsWithPkgs(const char *Cnf);
+   bool SendPkgsInfo(FILE * const F, unsigned int const &Version);
+   void WriteHistoryTag(std::string const &tag, std::string value);
+   std::string ExpandShortPackageName(pkgDepCache &Cache,
+                                      const std::string &short_pkgname);
+
+   // Terminal progress 
+   void SendTerminalProgress(float percentage);
+
+   // apport integration
+   void WriteApportReport(const char *pkgpath, const char *errormsg);
+
+   // dpkg log
+   bool OpenLog();
+   bool CloseLog();
+
+   // helper
+   void BuildPackagesProgressMap();
+   void StartPtyMagic();
+   void SetupSlavePtyMagic();
+   void StopPtyMagic();
+   
+   // input processing
+   void DoStdin(int master);
+   void DoTerminalPty(int master);
+   void DoDpkgStatusFd(int statusfd);
+   void ProcessDpkgStatusLine(char *line);
+
+   // The Actual installation implementation
+   virtual bool Install(PkgIterator Pkg,std::string File) APT_OVERRIDE;
+   virtual bool Configure(PkgIterator Pkg) APT_OVERRIDE;
+   virtual bool Remove(PkgIterator Pkg,bool Purge = false) APT_OVERRIDE;
+
+   virtual bool Go(APT::Progress::PackageManager *progress) APT_OVERRIDE;
+
+   virtual void Reset() APT_OVERRIDE;
+   
+   public:
+
+   explicit pkgDPkgPM(pkgDepCache *Cache);
+   virtual ~pkgDPkgPM();
+
+   APT_HIDDEN static bool ExpandPendingCalls(std::vector<Item> &List, pkgDepCache &Cache);
+};
+
+void SigINT(int sig);
+
+#endif