Adding upstream version 1.8.2.3.upstream/1.8.2.3upstream

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

1 files changed, 1108 insertions, 0 deletions

diff --git a/apt-pkg/pkgcache.cc b/apt-pkg/pkgcache.cc
new file mode 100644
index 0000000..80dd1d1
--- /dev/null
+++ b/apt-pkg/pkgcache.cc
@@ -0,0 +1,1108 @@
+// -*- mode: cpp; mode: fold -*-
+// Description								/*{{{*/
+/* ######################################################################
+   
+   Package Cache - Accessor code for the cache
+   
+   Please see doc/apt-pkg/cache.sgml for a more detailed description of 
+   this format. Also be sure to keep that file up-to-date!!
+   
+   This is the general utility functions for cache management. They provide
+   a complete set of accessor functions for the cache. The cacheiterators
+   header contains the STL-like iterators that can be used to easially
+   navigate the cache as well as seamlessly dereference the mmap'd
+   indexes. Use these always.
+   
+   The main class provides for ways to get package indexes and some
+   general lookup functions to start the iterators.
+
+   ##################################################################### */
+									/*}}}*/
+// Include Files							/*{{{*/
+#include <config.h>
+
+#include <apt-pkg/aptconfiguration.h>
+#include <apt-pkg/configuration.h>
+#include <apt-pkg/error.h>
+#include <apt-pkg/macros.h>
+#include <apt-pkg/mmap.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/policy.h>
+#include <apt-pkg/strutl.h>
+#include <apt-pkg/version.h>
+
+#include <zlib.h>
+#include <algorithm>
+#include <sstream>
+#include <string>
+#include <vector>
+#include <stddef.h>
+#include <string.h>
+#include <sys/stat.h>
+
+#include <apti18n.h>
+									/*}}}*/
+
+using std::string;
+using APT::StringView;
+
+
+// Cache::Header::Header - Constructor					/*{{{*/
+// ---------------------------------------------------------------------
+/* Simply initialize the header */
+pkgCache::Header::Header()
+{
+#define APT_HEADER_SET(X,Y) X = Y; static_assert(std::numeric_limits<decltype(X)>::max() > Y, "Size violation detected in pkgCache::Header")
+   APT_HEADER_SET(Signature, 0x98FE76DC);
+
+   /* Whenever the structures change the major version should be bumped,
+      whenever the generator changes the minor version should be bumped. */
+   APT_HEADER_SET(MajorVersion, 13);
+   APT_HEADER_SET(MinorVersion, 0);
+   APT_HEADER_SET(Dirty, false);
+
+   APT_HEADER_SET(HeaderSz, sizeof(pkgCache::Header));
+   APT_HEADER_SET(GroupSz, sizeof(pkgCache::Group));
+   APT_HEADER_SET(PackageSz, sizeof(pkgCache::Package));
+   APT_HEADER_SET(ReleaseFileSz, sizeof(pkgCache::ReleaseFile));
+   APT_HEADER_SET(PackageFileSz, sizeof(pkgCache::PackageFile));
+   APT_HEADER_SET(VersionSz, sizeof(pkgCache::Version));
+   APT_HEADER_SET(DescriptionSz, sizeof(pkgCache::Description));
+   APT_HEADER_SET(DependencySz, sizeof(pkgCache::Dependency));
+   APT_HEADER_SET(DependencyDataSz, sizeof(pkgCache::DependencyData));
+   APT_HEADER_SET(ProvidesSz, sizeof(pkgCache::Provides));
+   APT_HEADER_SET(VerFileSz, sizeof(pkgCache::VerFile));
+   APT_HEADER_SET(DescFileSz, sizeof(pkgCache::DescFile));
+#undef APT_HEADER_SET
+
+   GroupCount = 0;
+   PackageCount = 0;
+   VersionCount = 0;
+   DescriptionCount = 0;
+   DependsCount = 0;
+   DependsDataCount = 0;
+   ReleaseFileCount = 0;
+   PackageFileCount = 0;
+   VerFileCount = 0;
+   DescFileCount = 0;
+   ProvidesCount = 0;
+   MaxVerFileSize = 0;
+   MaxDescFileSize = 0;
+
+   FileList = 0;
+   RlsFileList = 0;
+   VerSysName = 0;
+   Architecture = 0;
+   SetArchitectures(0);
+   SetHashTableSize(_config->FindI("APT::Cache-HashTableSize", 50503));
+   memset(Pools,0,sizeof(Pools));
+
+   CacheFileSize = 0;
+}
+									/*}}}*/
+// Cache::Header::CheckSizes - Check if the two headers have same *sz	/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool pkgCache::Header::CheckSizes(Header &Against) const
+{
+   if (HeaderSz == Against.HeaderSz &&
+       GroupSz == Against.GroupSz &&
+       PackageSz == Against.PackageSz &&
+       ReleaseFileSz == Against.ReleaseFileSz &&
+       PackageFileSz == Against.PackageFileSz &&
+       VersionSz == Against.VersionSz &&
+       DescriptionSz == Against.DescriptionSz &&
+       DependencySz == Against.DependencySz &&
+       DependencyDataSz == Against.DependencyDataSz &&
+       VerFileSz == Against.VerFileSz &&
+       DescFileSz == Against.DescFileSz &&
+       ProvidesSz == Against.ProvidesSz)
+      return true;
+   return false;
+}
+									/*}}}*/
+
+// Cache::pkgCache - Constructor					/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+APT_IGNORE_DEPRECATED_PUSH
+pkgCache::pkgCache(MMap *Map, bool DoMap) : Map(*Map), VS(nullptr), d(NULL)
+{
+   // call getArchitectures() with cached=false to ensure that the 
+   // architectures cache is re-evaulated. this is needed in cases
+   // when the APT::Architecture field changes between two cache creations
+   MultiArchEnabled = APT::Configuration::getArchitectures(false).size() > 1;
+   if (DoMap == true)
+      ReMap();
+}
+APT_IGNORE_DEPRECATED_POP
+									/*}}}*/
+// Cache::ReMap - Reopen the cache file					/*{{{*/
+// ---------------------------------------------------------------------
+/* If the file is already closed then this will open it open it. */
+bool pkgCache::ReMap(bool const &Errorchecks)
+{
+   // Apply the typecasts.
+   HeaderP = (Header *)Map.Data();
+   GrpP = (Group *)Map.Data();
+   PkgP = (Package *)Map.Data();
+   VerFileP = (VerFile *)Map.Data();
+   DescFileP = (DescFile *)Map.Data();
+   RlsFileP = (ReleaseFile *)Map.Data();
+   PkgFileP = (PackageFile *)Map.Data();
+   VerP = (Version *)Map.Data();
+   DescP = (Description *)Map.Data();
+   ProvideP = (Provides *)Map.Data();
+   DepP = (Dependency *)Map.Data();
+   DepDataP = (DependencyData *)Map.Data();
+   StrP = (char *)Map.Data();
+
+   if (Errorchecks == false)
+      return true;
+
+   if (Map.Size() == 0 || HeaderP == 0)
+      return _error->Error(_("Empty package cache"));
+   
+   // Check the header
+   Header DefHeader;
+   if (HeaderP->Signature != DefHeader.Signature ||
+       HeaderP->Dirty == true)
+      return _error->Error(_("The package cache file is corrupted"));
+   
+   if (HeaderP->MajorVersion != DefHeader.MajorVersion ||
+       HeaderP->MinorVersion != DefHeader.MinorVersion ||
+       HeaderP->CheckSizes(DefHeader) == false)
+      return _error->Error(_("The package cache file is an incompatible version"));
+
+   if (HeaderP->VerSysName == 0 || HeaderP->Architecture == 0 || HeaderP->GetArchitectures() == 0)
+      return _error->Error(_("The package cache file is corrupted"));
+
+   // Locate our VS..
+   if ((VS = pkgVersioningSystem::GetVS(StrP + HeaderP->VerSysName)) == 0)
+      return _error->Error(_("This APT does not support the versioning system '%s'"),StrP + HeaderP->VerSysName);
+
+   // Check the architecture
+   std::vector<std::string> archs = APT::Configuration::getArchitectures();
+   std::string list = "";
+   for (auto const & arch : archs) {
+      if (!list.empty())
+         list.append(",");
+      list.append(arch);
+   }
+   if (_config->Find("APT::Architecture") != StrP + HeaderP->Architecture ||
+	 list != StrP + HeaderP->GetArchitectures())
+      return _error->Error(_("The package cache was built for different architectures: %s vs %s"), StrP + HeaderP->GetArchitectures(), list.c_str());
+
+
+   auto hash = CacheHash();
+   if (_config->FindB("Debug::pkgCacheGen", false))
+      std::clog << "Opened cache with hash " << hash << ", expecting " <<  HeaderP->CacheFileSize << "\n";
+   if (hash != HeaderP->CacheFileSize)
+      return _error->Error(_("The package cache file is corrupted, it has the wrong hash"));
+
+   return true;
+}
+									/*}}}*/
+// Cache::Hash - Hash a string						/*{{{*/
+// ---------------------------------------------------------------------
+/* This is used to generate the hash entries for the HashTable. With my
+   package list from bo this function gets 94% table usage on a 512 item
+   table (480 used items) */
+map_id_t pkgCache::sHash(StringView Str) const
+{
+   uint32_t Hash = 5381;
+   for (auto I = Str.begin(); I != Str.end(); ++I)
+      Hash = 33 * Hash + tolower_ascii_unsafe(*I);
+   return Hash % HeaderP->GetHashTableSize();
+}
+map_id_t pkgCache::sHash(const string &Str) const
+{
+   uint32_t Hash = 5381;
+   for (string::const_iterator I = Str.begin(); I != Str.end(); ++I)
+      Hash = 33 * Hash + tolower_ascii_unsafe((signed char)*I);
+   return Hash % HeaderP->GetHashTableSize();
+}
+
+map_id_t pkgCache::sHash(const char *Str) const
+{
+   uint32_t Hash = 5381;
+   for (const char *I = Str; *I != 0; ++I)
+      Hash = 33 * Hash + tolower_ascii_unsafe((signed char)*I);
+   return Hash % HeaderP->GetHashTableSize();
+}
+
+#if defined(HAVE_FMV_SSE42_AND_CRC32)
+
+#ifdef HAVE_FMV_SSE42_AND_CRC32
+__attribute__((target("sse4.2"))) static uint32_t hash32(uint32_t crc32, const unsigned char *input, size_t size)
+{
+   if (input == nullptr)
+      return 0;
+
+   crc32 ^= 0xffffffffU;
+#ifdef HAVE_FMV_SSE42_AND_CRC32DI
+   while (size >= 8) {
+      crc32 = __builtin_ia32_crc32di(crc32, *(uint64_t *)input);
+      input += 8;
+      size -= 8;
+   }
+
+   if (size >= 4) {
+#else
+   while (size >= 4) {
+#endif
+      crc32 = __builtin_ia32_crc32si(crc32, *(uint32_t *)input);
+      input += 4;
+      size -= 4;
+   }
+
+   if (size >= 2) {
+      crc32 = __builtin_ia32_crc32hi(crc32, *(uint16_t *)input);
+      input += 2;
+      size -= 2;
+   }
+
+   if (size >= 1) {
+      crc32 = __builtin_ia32_crc32qi(crc32, *(uint8_t *)input);
+      input += 1;
+      size -= 1;
+   }
+   crc32 ^= 0xffffffffU;
+   return crc32;
+}
+#endif
+
+__attribute__((target("default")))
+#endif
+static uint32_t hash32(uint32_t crc32, const unsigned char *input, size_t size)
+{
+   return adler32(crc32, input, size);
+}
+
+uint32_t pkgCache::CacheHash()
+{
+   pkgCache::Header header = {};
+   uLong adler = hash32(0L, Z_NULL, 0);
+
+   if (Map.Size() < sizeof(header))
+      return adler;
+   memcpy(&header, GetMap().Data(), sizeof(header));
+
+   header.Dirty = false;
+   header.CacheFileSize = 0;
+
+   adler = hash32(adler,
+		  reinterpret_cast<const unsigned char *>(&header),
+		  sizeof(header));
+
+   if (Map.Size() > sizeof(header)) {
+      adler = hash32(adler,
+		     static_cast<const unsigned char *>(GetMap().Data()) + sizeof(header),
+		     GetMap().Size() - sizeof(header));
+   }
+
+   return adler;
+}
+									/*}}}*/
+// Cache::FindPkg - Locate a package by name				/*{{{*/
+// ---------------------------------------------------------------------
+/* Returns 0 on error, pointer to the package otherwise */
+pkgCache::PkgIterator pkgCache::FindPkg(const string &Name) {
+   return FindPkg(StringView(Name));
+}
+
+pkgCache::PkgIterator pkgCache::FindPkg(StringView Name) {
+	auto const found = Name.rfind(':');
+	if (found == string::npos)
+	   return FindPkg(Name, "native");
+	auto const Arch = Name.substr(found+1);
+	/* Beware: This is specialcased to handle pkg:any in dependencies
+	   as these are linked to virtual pkg:any named packages.
+	   If you want any arch from a pkg, use FindPkg(pkg,"any") */
+	if (Arch == "any")
+		return FindPkg(Name, "any");
+	return FindPkg(Name.substr(0, found), Arch);
+}
+									/*}}}*/
+// Cache::FindPkg - Locate a package by name				/*{{{*/
+// ---------------------------------------------------------------------
+/* Returns 0 on error, pointer to the package otherwise */
+pkgCache::PkgIterator pkgCache::FindPkg(const string &Name, string const &Arch) {
+   return FindPkg(StringView(Name), StringView(Arch));
+}
+
+pkgCache::PkgIterator pkgCache::FindPkg(StringView Name, StringView Arch) {
+	/* We make a detour via the GrpIterator here as
+	   on a multi-arch environment a group is easier to
+	   find than a package (less entries in the buckets) */
+	pkgCache::GrpIterator Grp = FindGrp(Name);
+	if (Grp.end() == true)
+		return PkgIterator(*this,0);
+
+	return Grp.FindPkg(Arch);
+}
+									/*}}}*/
+// Cache::FindGrp - Locate a group by name				/*{{{*/
+// ---------------------------------------------------------------------
+/* Returns End-Pointer on error, pointer to the group otherwise */
+pkgCache::GrpIterator pkgCache::FindGrp(const string &Name) {
+   return FindGrp(StringView(Name));
+}
+
+pkgCache::GrpIterator pkgCache::FindGrp(StringView Name) {
+	if (unlikely(Name.empty() == true))
+		return GrpIterator(*this,0);
+
+	// Look at the hash bucket for the group
+	Group *Grp = GrpP + HeaderP->GrpHashTableP()[sHash(Name)];
+	for (; Grp != GrpP; Grp = GrpP + Grp->Next) {
+		int const cmp = StringViewCompareFast(Name, ViewString(Grp->Name));
+		if (cmp == 0)
+			return GrpIterator(*this, Grp);
+		else if (cmp < 0)
+			break;
+	}
+
+	return GrpIterator(*this,0);
+}
+									/*}}}*/
+// Cache::CompTypeDeb - Return a string describing the compare type	/*{{{*/
+// ---------------------------------------------------------------------
+/* This returns a string representation of the dependency compare 
+   type in the weird debian style.. */
+const char *pkgCache::CompTypeDeb(unsigned char Comp)
+{
+   const char * const Ops[] = {"","<=",">=","<<",">>","=","!="};
+   if (unlikely((unsigned)(Comp & 0xF) >= sizeof(Ops)/sizeof(Ops[0])))
+      return "";
+   return Ops[Comp & 0xF];
+}
+									/*}}}*/
+// Cache::CompType - Return a string describing the compare type	/*{{{*/
+// ---------------------------------------------------------------------
+/* This returns a string representation of the dependency compare
+   type */
+const char *pkgCache::CompType(unsigned char Comp)
+{
+   const char * const Ops[] = {"","<=",">=","<",">","=","!="};
+   if (unlikely((unsigned)(Comp & 0xF) >= sizeof(Ops)/sizeof(Ops[0])))
+      return "";
+   return Ops[Comp & 0xF];
+}
+									/*}}}*/
+// Cache::DepType - Return a string describing the dep type		/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+const char *pkgCache::DepType(unsigned char Type)
+{
+   const char *Types[] = {"",_("Depends"),_("PreDepends"),_("Suggests"),
+                          _("Recommends"),_("Conflicts"),_("Replaces"),
+                          _("Obsoletes"),_("Breaks"), _("Enhances")};
+   if (Type < sizeof(Types)/sizeof(*Types))
+      return Types[Type];
+   return "";
+}
+									/*}}}*/
+// Cache::Priority - Convert a priority value to a string		/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+const char *pkgCache::Priority(unsigned char Prio)
+{
+   const char *Mapping[] = {0,_("required"),_("important"),_("standard"),
+                            _("optional"),_("extra")};
+   if (Prio < _count(Mapping))
+      return Mapping[Prio];
+   return 0;
+}
+									/*}}}*/
+// GrpIterator::FindPkg - Locate a package by arch			/*{{{*/
+// ---------------------------------------------------------------------
+/* Returns an End-Pointer on error, pointer to the package otherwise */
+pkgCache::PkgIterator pkgCache::GrpIterator::FindPkg(string Arch) const {
+   return FindPkg(StringView(Arch));
+}
+pkgCache::PkgIterator pkgCache::GrpIterator::FindPkg(const char *Arch) const {
+   return FindPkg(StringView(Arch));
+}
+pkgCache::PkgIterator pkgCache::GrpIterator::FindPkg(StringView Arch) const {
+	if (unlikely(IsGood() == false || S->FirstPackage == 0))
+		return PkgIterator(*Owner, 0);
+
+	/* If we accept any package we simply return the "first"
+	   package in this group */
+	if (Arch == "any")
+		return PkgIterator(*Owner, Owner->PkgP + S->FirstPackage);
+	if (Arch == "native" || Arch == "all")
+               Arch = Owner->NativeArch();
+
+	// Iterate over the list to find the matching arch
+	for (pkgCache::Package *Pkg = PackageList(); Pkg != Owner->PkgP;
+	     Pkg = Owner->PkgP + Pkg->NextPackage) {
+		if (Arch == Owner->ViewString(Pkg->Arch))
+			return PkgIterator(*Owner, Pkg);
+		if ((Owner->PkgP + S->LastPackage) == Pkg)
+			break;
+	}
+
+	return PkgIterator(*Owner, 0);
+}
+									/*}}}*/
+// GrpIterator::FindPreferredPkg - Locate the "best" package		/*{{{*/
+// ---------------------------------------------------------------------
+/* Returns an End-Pointer on error, pointer to the package otherwise */
+pkgCache::PkgIterator pkgCache::GrpIterator::FindPreferredPkg(bool const &PreferNonVirtual) const {
+	pkgCache::PkgIterator Pkg = FindPkg(StringView("native", 6));
+	if (Pkg.end() == false && (PreferNonVirtual == false || Pkg->VersionList != 0))
+		return Pkg;
+
+	std::vector<std::string> const archs = APT::Configuration::getArchitectures();
+	for (std::vector<std::string>::const_iterator a = archs.begin();
+	     a != archs.end(); ++a) {
+		Pkg = FindPkg(*a);
+		if (Pkg.end() == false && (PreferNonVirtual == false || Pkg->VersionList != 0))
+			return Pkg;
+	}
+	// packages without an architecture
+	Pkg = FindPkg(StringView("none", 4));
+	if (Pkg.end() == false && (PreferNonVirtual == false || Pkg->VersionList != 0))
+		return Pkg;
+
+	if (PreferNonVirtual == true)
+		return FindPreferredPkg(false);
+	return PkgIterator(*Owner, 0);
+}
+									/*}}}*/
+// GrpIterator::NextPkg - Locate the next package in the group		/*{{{*/
+// ---------------------------------------------------------------------
+/* Returns an End-Pointer on error, pointer to the package otherwise.
+   We can't simply ++ to the next as the next package of the last will
+   be from a different group (with the same hash value) */
+pkgCache::PkgIterator pkgCache::GrpIterator::NextPkg(pkgCache::PkgIterator const &LastPkg) const {
+	if (unlikely(IsGood() == false || S->FirstPackage == 0 ||
+	    LastPkg.end() == true))
+		return PkgIterator(*Owner, 0);
+
+	if (S->LastPackage == LastPkg.Index())
+		return PkgIterator(*Owner, 0);
+
+	return PkgIterator(*Owner, Owner->PkgP + LastPkg->NextPackage);
+}
+									/*}}}*/
+// GrpIterator::operator++ - Prefix incr				/*{{{*/
+// ---------------------------------------------------------------------
+/* This will advance to the next logical group in the hash table. */
+pkgCache::GrpIterator& pkgCache::GrpIterator::operator++()
+{
+   // Follow the current links
+   if (S != Owner->GrpP)
+      S = Owner->GrpP + S->Next;
+
+   // Follow the hash table
+   while (S == Owner->GrpP && (HashIndex+1) < (signed)Owner->HeaderP->GetHashTableSize())
+   {
+      ++HashIndex;
+      S = Owner->GrpP + Owner->HeaderP->GrpHashTableP()[HashIndex];
+   }
+   return *this;
+}
+									/*}}}*/
+// PkgIterator::operator++ - Prefix incr				/*{{{*/
+// ---------------------------------------------------------------------
+/* This will advance to the next logical package in the hash table. */
+pkgCache::PkgIterator& pkgCache::PkgIterator::operator++()
+{
+   // Follow the current links
+   if (S != Owner->PkgP)
+      S = Owner->PkgP + S->NextPackage;
+
+   // Follow the hash table
+   while (S == Owner->PkgP && (HashIndex+1) < (signed)Owner->HeaderP->GetHashTableSize())
+   {
+      ++HashIndex;
+      S = Owner->PkgP + Owner->HeaderP->PkgHashTableP()[HashIndex];
+   }
+   return *this;
+}
+									/*}}}*/
+pkgCache::DepIterator& pkgCache::DepIterator::operator++()		/*{{{*/
+{
+   if (S == Owner->DepP)
+      return *this;
+   S = Owner->DepP + (Type == DepVer ? S->NextDepends : S->NextRevDepends);
+   if (S == Owner->DepP)
+      S2 = Owner->DepDataP;
+   else
+      S2 = Owner->DepDataP + S->DependencyData;
+   return *this;
+}
+									/*}}}*/
+// PkgIterator::State - Check the State of the package			/*{{{*/
+// ---------------------------------------------------------------------
+/* By this we mean if it is either cleanly installed or cleanly removed. */
+pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const
+{  
+   if (S->InstState == pkgCache::State::ReInstReq ||
+       S->InstState == pkgCache::State::HoldReInstReq)
+      return NeedsUnpack;
+   
+   if (S->CurrentState == pkgCache::State::UnPacked ||
+       S->CurrentState == pkgCache::State::HalfConfigured)
+      // we leave triggers alone completely. dpkg deals with
+      // them in a hard-to-predict manner and if they get 
+      // resolved by dpkg before apt run dpkg --configure on 
+      // the TriggersPending package dpkg returns a error
+      //Pkg->CurrentState == pkgCache::State::TriggersAwaited
+      //Pkg->CurrentState == pkgCache::State::TriggersPending)
+      return NeedsConfigure;
+   
+   if (S->CurrentState == pkgCache::State::HalfInstalled ||
+       S->InstState != pkgCache::State::Ok)
+      return NeedsUnpack;
+      
+   return NeedsNothing;
+}
+									/*}}}*/
+// PkgIterator::CandVersion - Returns the candidate version string	/*{{{*/
+// ---------------------------------------------------------------------
+/* Return string representing of the candidate version. */
+const char *
+pkgCache::PkgIterator::CandVersion() const
+{
+  //TargetVer is empty, so don't use it.
+  VerIterator version = pkgPolicy(Owner).GetCandidateVer(*this);
+  if (version.IsGood())
+    return version.VerStr();
+  return 0;
+}
+									/*}}}*/
+// PkgIterator::CurVersion - Returns the current version string		/*{{{*/
+// ---------------------------------------------------------------------
+/* Return string representing of the current version. */
+const char *
+pkgCache::PkgIterator::CurVersion() const
+{
+  VerIterator version = CurrentVer();
+  if (version.IsGood())
+    return CurrentVer().VerStr();
+  return 0;
+}
+									/*}}}*/
+// ostream operator to handle string representation of a package	/*{{{*/
+// ---------------------------------------------------------------------
+/* Output name < cur.rent.version -> candid.ate.version | new.est.version > (section)
+   Note that the characters <|>() are all literal above. Versions will be omitted
+   if they provide no new information (e.g. there is no newer version than candidate)
+   If no version and/or section can be found "none" is used. */
+std::ostream& 
+operator<<(std::ostream& out, pkgCache::PkgIterator Pkg) 
+{
+   if (Pkg.end() == true)
+      return out << "invalid package";
+
+   string current = string(Pkg.CurVersion() == 0 ? "none" : Pkg.CurVersion());
+APT_IGNORE_DEPRECATED_PUSH
+   string candidate = string(Pkg.CandVersion() == 0 ? "none" : Pkg.CandVersion());
+APT_IGNORE_DEPRECATED_POP
+   string newest = string(Pkg.VersionList().end() ? "none" : Pkg.VersionList().VerStr());
+
+   out << Pkg.Name() << " [ " << Pkg.Arch() << " ] < " << current;
+   if (current != candidate)
+      out << " -> " << candidate;
+   if ( newest != "none" && candidate != newest)
+      out << " | " << newest;
+   if (Pkg->VersionList == 0)
+      out << " > ( none )";
+   else
+      out << " > ( " << string(Pkg.VersionList().Section()==0?"unknown":Pkg.VersionList().Section()) << " )";
+   return out;
+}
+									/*}}}*/
+// PkgIterator::FullName - Returns Name and (maybe) Architecture	/*{{{*/
+// ---------------------------------------------------------------------
+/* Returns a name:arch string */
+std::string pkgCache::PkgIterator::FullName(bool const &Pretty) const
+{
+   string fullname = Name();
+   if (Pretty == false ||
+       (strcmp(Arch(), "all") != 0 && strcmp(Arch(), "any") != 0 &&
+	strcmp(Owner->NativeArch(), Arch()) != 0))
+      return fullname.append(":").append(Arch());
+   return fullname;
+}
+									/*}}}*/
+// DepIterator::IsCritical - Returns true if the dep is important	/*{{{*/
+// ---------------------------------------------------------------------
+/* Currently critical deps are defined as depends, predepends and
+   conflicts (including dpkg's Breaks fields). */
+bool pkgCache::DepIterator::IsCritical() const
+{
+   if (IsNegative() == true ||
+       S2->Type == pkgCache::Dep::Depends ||
+       S2->Type == pkgCache::Dep::PreDepends)
+      return true;
+   return false;
+}
+									/*}}}*/
+// DepIterator::IsNegative - Returns true if the dep is a negative one	/*{{{*/
+// ---------------------------------------------------------------------
+/* Some dependencies are positive like Depends and Recommends, others
+   are negative like Conflicts which can and should be handled differently */
+bool pkgCache::DepIterator::IsNegative() const
+{
+   return S2->Type == Dep::DpkgBreaks ||
+	  S2->Type == Dep::Conflicts ||
+	  S2->Type == Dep::Obsoletes;
+}
+									/*}}}*/
+// DepIterator::SmartTargetPkg - Resolve dep target pointers w/provides	/*{{{*/
+// ---------------------------------------------------------------------
+/* This intellegently looks at dep target packages and tries to figure
+   out which package should be used. This is needed to nicely handle
+   provide mapping. If the target package has no other providing packages
+   then it returned. Otherwise the providing list is looked at to
+   see if there is one unique providing package if so it is returned.
+   Otherwise true is returned and the target package is set. The return
+   result indicates whether the node should be expandable 
+ 
+   In Conjunction with the DepCache the value of Result may not be 
+   super-good since the policy may have made it uninstallable. Using
+   AllTargets is better in this case. */
+bool pkgCache::DepIterator::SmartTargetPkg(PkgIterator &Result) const
+{
+   Result = TargetPkg();
+   
+   // No provides at all
+   if (Result->ProvidesList == 0)
+      return false;
+   
+   // There is the Base package and the providing ones which is at least 2
+   if (Result->VersionList != 0)
+      return true;
+      
+   /* We have to skip over indirect provisions of the package that
+      owns the dependency. For instance, if libc5-dev depends on the
+      virtual package libc-dev which is provided by libc5-dev and libc6-dev
+      we must ignore libc5-dev when considering the provides list. */ 
+   PrvIterator PStart = Result.ProvidesList();
+   for (; PStart.end() != true && PStart.OwnerPkg() == ParentPkg(); ++PStart);
+
+   // Nothing but indirect self provides
+   if (PStart.end() == true)
+      return false;
+   
+   // Check for single packages in the provides list
+   PrvIterator P = PStart;
+   for (; P.end() != true; ++P)
+   {
+      // Skip over self provides
+      if (P.OwnerPkg() == ParentPkg())
+	 continue;
+      if (PStart.OwnerPkg() != P.OwnerPkg())
+	 break;
+   }
+
+   Result = PStart.OwnerPkg();
+   
+   // Check for non dups
+   if (P.end() != true)
+      return true;
+   
+   return false;
+}
+									/*}}}*/
+// DepIterator::AllTargets - Returns the set of all possible targets	/*{{{*/
+// ---------------------------------------------------------------------
+/* This is a more useful version of TargetPkg() that follows versioned
+   provides. It includes every possible package-version that could satisfy
+   the dependency. The last item in the list has a 0. The resulting pointer
+   must be delete [] 'd */
+pkgCache::Version **pkgCache::DepIterator::AllTargets() const
+{
+   Version **Res = 0;
+   unsigned long Size =0;
+   while (1)
+   {
+      Version **End = Res;
+      PkgIterator DPkg = TargetPkg();
+
+      // Walk along the actual package providing versions
+      for (VerIterator I = DPkg.VersionList(); I.end() == false; ++I)
+      {
+	 if (IsIgnorable(I.ParentPkg()) == true)
+	    continue;
+	 if (IsSatisfied(I) == false)
+	    continue;
+
+	 Size++;
+	 if (Res != 0)
+	    *End++ = I;
+      }
+      
+      // Follow all provides
+      for (PrvIterator I = DPkg.ProvidesList(); I.end() == false; ++I)
+      {
+	 if (IsIgnorable(I) == true)
+	    continue;
+	 if (IsSatisfied(I) == false)
+	    continue;
+
+	 Size++;
+	 if (Res != 0)
+	    *End++ = I.OwnerVer();
+      }
+      
+      // Do it again and write it into the array
+      if (Res == 0)
+      {
+	 Res = new Version *[Size+1];
+	 Size = 0;
+      }
+      else
+      {
+	 *End = 0;
+	 break;
+      }      
+   }
+   
+   return Res;
+}
+									/*}}}*/
+// DepIterator::GlobOr - Compute an OR group				/*{{{*/
+// ---------------------------------------------------------------------
+/* This Takes an iterator, iterates past the current dependency grouping
+   and returns Start and End so that so End is the final element
+   in the group, if End == Start then D is End++ and End is the
+   dependency D was pointing to. Use in loops to iterate sensibly. */
+void pkgCache::DepIterator::GlobOr(DepIterator &Start,DepIterator &End)
+{
+   // Compute a single dependency element (glob or)
+   Start = *this;
+   End = *this;
+   for (bool LastOR = true; end() == false && LastOR == true;)
+   {
+      LastOR = (S2->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
+      ++(*this);
+      if (LastOR == true)
+	 End = (*this);
+   }
+}
+									/*}}}*/
+// DepIterator::IsIgnorable - should this packag/providr be ignored?	/*{{{*/
+// ---------------------------------------------------------------------
+/* Deps like self-conflicts should be ignored as well as implicit conflicts
+   on virtual packages. */
+bool pkgCache::DepIterator::IsIgnorable(PkgIterator const &PT) const
+{
+   if (IsNegative() == false)
+      return false;
+
+   pkgCache::PkgIterator const PP = ParentPkg();
+   if (PP->Group != PT->Group)
+      return false;
+   // self-conflict
+   if (PP == PT)
+      return true;
+   pkgCache::VerIterator const PV = ParentVer();
+   // ignore group-conflict on a M-A:same package - but not our implicit dependencies
+   // so that we can have M-A:same packages conflicting with their own real name
+   if ((PV->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
+      return IsMultiArchImplicit() == false;
+
+   return false;
+}
+bool pkgCache::DepIterator::IsIgnorable(PrvIterator const &Prv) const
+{
+   if (IsNegative() == false)
+      return false;
+
+   PkgIterator const Pkg = ParentPkg();
+   /* Provides may never be applied against the same package (or group)
+      if it is a conflicts. See the comment above. */
+   if (Prv.OwnerPkg()->Group == Pkg->Group)
+      return true;
+   // Implicit group-conflicts should not be applied on providers of other groups
+   if (IsMultiArchImplicit() && Prv.OwnerPkg()->Group != Pkg->Group)
+      return true;
+
+   return false;
+}
+									/*}}}*/
+// DepIterator::IsSatisfied - check if a version satisfied the dependency /*{{{*/
+bool pkgCache::DepIterator::IsSatisfied(VerIterator const &Ver) const
+{
+   return Owner->VS->CheckDep(Ver.VerStr(),S2->CompareOp,TargetVer());
+}
+bool pkgCache::DepIterator::IsSatisfied(PrvIterator const &Prv) const
+{
+   return Owner->VS->CheckDep(Prv.ProvideVersion(),S2->CompareOp,TargetVer());
+}
+									/*}}}*/
+// DepIterator::IsImplicit - added by the cache generation		/*{{{*/
+bool pkgCache::DepIterator::IsImplicit() const
+{
+   if (IsMultiArchImplicit() == true)
+      return true;
+   if (IsNegative() || S2->Type == pkgCache::Dep::Replaces)
+   {
+      if ((S2->CompareOp & pkgCache::Dep::ArchSpecific) != pkgCache::Dep::ArchSpecific &&
+	    strcmp(ParentPkg().Arch(), TargetPkg().Arch()) != 0)
+	 return true;
+   }
+   return false;
+}
+									/*}}}*/
+// ostream operator to handle string representation of a dependency	/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+std::ostream& operator<<(std::ostream& out, pkgCache::DepIterator D)
+{
+   if (D.end() == true)
+      return out << "invalid dependency";
+
+   pkgCache::PkgIterator P = D.ParentPkg();
+   pkgCache::PkgIterator T = D.TargetPkg();
+
+   out << (P.end() ? "invalid pkg" : P.FullName(false)) << " " << D.DepType()
+	<< " on ";
+APT_IGNORE_DEPRECATED_PUSH
+   if (T.end() == true)
+      out << "invalid pkg";
+   else
+      out << T;
+APT_IGNORE_DEPRECATED_POP
+
+   if (D->Version != 0)
+      out << " (" << D.CompType() << " " << D.TargetVer() << ")";
+
+   return out;
+}
+									/*}}}*/
+// VerIterator::CompareVer - Fast version compare for same pkgs		/*{{{*/
+// ---------------------------------------------------------------------
+/* This just looks over the version list to see if B is listed before A. In
+   most cases this will return in under 4 checks, ver lists are short. */
+int pkgCache::VerIterator::CompareVer(const VerIterator &B) const
+{
+   // Check if they are equal
+   if (*this == B)
+      return 0;
+   if (end() == true)
+      return -1;
+   if (B.end() == true)
+      return 1;
+       
+   /* Start at A and look for B. If B is found then A > B otherwise
+      B was before A so A < B */
+   VerIterator I = *this;
+   for (;I.end() == false; ++I)
+      if (I == B)
+	 return 1;
+   return -1;
+}
+									/*}}}*/
+// VerIterator::Downloadable - Checks if the version is downloadable	/*{{{*/
+// ---------------------------------------------------------------------
+/* */
+APT_PURE bool pkgCache::VerIterator::Downloadable() const
+{
+   VerFileIterator Files = FileList();
+   for (; Files.end() == false; ++Files)
+      if (Files.File().Flagged(pkgCache::Flag::NotSource) == false)
+	 return true;
+   return false;
+}
+									/*}}}*/
+// VerIterator::Automatic - Check if this version is 'automatic'	/*{{{*/
+// ---------------------------------------------------------------------
+/* This checks to see if any of the versions files are not NotAutomatic. 
+   True if this version is selectable for automatic installation. */
+APT_PURE bool pkgCache::VerIterator::Automatic() const
+{
+   VerFileIterator Files = FileList();
+   for (; Files.end() == false; ++Files)
+      // Do not check ButAutomaticUpgrades here as it is kind of automatic…
+      if (Files.File().Flagged(pkgCache::Flag::NotAutomatic) == false)
+	 return true;
+   return false;
+}
+									/*}}}*/
+// VerIterator::NewestFile - Return the newest file version relation	/*{{{*/
+// ---------------------------------------------------------------------
+/* This looks at the version numbers associated with all of the sources
+   this version is in and returns the highest.*/
+pkgCache::VerFileIterator pkgCache::VerIterator::NewestFile() const
+{
+   VerFileIterator Files = FileList();
+   VerFileIterator Highest = Files;
+   for (; Files.end() == false; ++Files)
+   {
+      if (Owner->VS->CmpReleaseVer(Files.File().Version(),Highest.File().Version()) > 0)
+	 Highest = Files;
+   }
+   
+   return Highest;
+}
+									/*}}}*/
+// VerIterator::RelStr - Release description string			/*{{{*/
+// ---------------------------------------------------------------------
+/* This describes the version from a release-centric manner. The output is a 
+   list of Label:Version/Archive */
+static std::string PkgFileIteratorToRelString(pkgCache::PkgFileIterator const &File)
+{
+   std::string Res;
+   if (File.Label() != 0)
+      Res = Res + File.Label() + ':';
+
+   if (File.Archive() != 0)
+   {
+      if (File.Version() == 0)
+	 Res += File.Archive();
+      else
+	 Res = Res + File.Version() + '/' +  File.Archive();
+   }
+   else
+   {
+      // No release file, print the host name that this came from
+      if (File.Site() == 0 || File.Site()[0] == 0)
+	 Res += "localhost";
+      else
+	 Res += File.Site();
+   }
+   return Res;
+}
+string pkgCache::VerIterator::RelStr() const
+{
+   std::vector<std::string> RelStrs;
+   for (pkgCache::VerFileIterator I = this->FileList(); I.end() == false; ++I)
+   {
+      // Do not print 'not source' entries'
+      pkgCache::PkgFileIterator const File = I.File();
+      if (File.Flagged(pkgCache::Flag::NotSource))
+	 continue;
+
+      std::string const RS = PkgFileIteratorToRelString(File);
+      if (std::find(RelStrs.begin(), RelStrs.end(), RS) != RelStrs.end())
+	 continue;
+
+      RelStrs.push_back(RS);
+   }
+   std::ostringstream os;
+   if (likely(RelStrs.empty() == false))
+   {
+      std::copy(RelStrs.begin(), RelStrs.end()-1, std::ostream_iterator<std::string>(os, ", "));
+      os << *RelStrs.rbegin();
+   }
+   if (S->ParentPkg != 0)
+      os << " [" << Arch() << "]";
+   return os.str();
+}
+									/*}}}*/
+// VerIterator::MultiArchType - string representing MultiArch flag	/*{{{*/
+const char * pkgCache::VerIterator::MultiArchType() const
+{
+   if ((S->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
+      return "same";
+   else if ((S->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
+      return "foreign";
+   else if ((S->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
+      return "allowed";
+   return "none";
+}
+									/*}}}*/
+// RlsFileIterator::IsOk - Checks if the cache is in sync with the file	/*{{{*/
+// ---------------------------------------------------------------------
+/* This stats the file and compares its stats with the ones that were
+   stored during generation. Date checks should probably also be
+   included here. */
+bool pkgCache::RlsFileIterator::IsOk()
+{
+   return true;
+}
+									/*}}}*/
+// RlsFileIterator::RelStr - Return the release string			/*{{{*/
+string pkgCache::RlsFileIterator::RelStr()
+{
+   string Res;
+   if (Version() != 0)
+      Res = Res + (Res.empty() == true?"v=":",v=") + Version();
+   if (Origin() != 0)
+      Res = Res + (Res.empty() == true?"o=":",o=")  + Origin();
+   if (Archive() != 0)
+      Res = Res + (Res.empty() == true?"a=":",a=")  + Archive();
+   if (Codename() != 0)
+      Res = Res + (Res.empty() == true?"n=":",n=")  + Codename();
+   if (Label() != 0)
+      Res = Res + (Res.empty() == true?"l=":",l=")  + Label();
+   return Res;
+}
+									/*}}}*/
+// PkgFileIterator::IsOk - Checks if the cache is in sync with the file	/*{{{*/
+// ---------------------------------------------------------------------
+/* This stats the file and compares its stats with the ones that were
+   stored during generation. Date checks should probably also be
+   included here. */
+bool pkgCache::PkgFileIterator::IsOk()
+{
+   return true;
+}
+									/*}}}*/
+string pkgCache::PkgFileIterator::RelStr()				/*{{{*/
+{
+   std::string Res;
+   if (ReleaseFile() == 0)
+   {
+      if (Component() != 0)
+	 Res = Res + (Res.empty() == true?"a=":",a=")  + Component();
+   }
+   else
+   {
+      Res = ReleaseFile().RelStr();
+      if (Component() != 0)
+	 Res = Res + (Res.empty() == true?"c=":",c=")  + Component();
+   }
+   if (Architecture() != 0)
+      Res = Res + (Res.empty() == true?"b=":",b=")  + Architecture();
+   return Res;
+}
+									/*}}}*/
+// VerIterator::TranslatedDescription - Return the a DescIter for locale/*{{{*/
+// ---------------------------------------------------------------------
+/* return a DescIter for the current locale or the default if none is
+ * found
+ */
+pkgCache::DescIterator pkgCache::VerIterator::TranslatedDescription() const
+{
+   std::vector<string> const lang = APT::Configuration::getLanguages();
+   for (std::vector<string>::const_iterator l = lang.begin();
+	l != lang.end(); ++l)
+   {
+      pkgCache::DescIterator Desc = DescriptionList();
+      for (; Desc.end() == false; ++Desc)
+	 if (*l == Desc.LanguageCode())
+	    break;
+      if (Desc.end() == true)
+      {
+	 if (*l == "en")
+	 {
+	    Desc = DescriptionList();
+	    for (; Desc.end() == false; ++Desc)
+	       if (strcmp(Desc.LanguageCode(), "") == 0)
+		  break;
+	    if (Desc.end() == true)
+	       continue;
+	 }
+	 else
+	    continue;
+      }
+      return Desc;
+   }
+   for (pkgCache::DescIterator Desc = DescriptionList();
+	Desc.end() == false; ++Desc)
+      if (strcmp(Desc.LanguageCode(), "") == 0)
+	 return Desc;
+   return DescriptionList();
+}
+
+									/*}}}*/
+
+pkgCache::~pkgCache() {}