Merge branch 'debian/sid' into debian/experimental

[apt.git] / apt-pkg / deb / deblistparser.cc

diff --git a/apt-pkg/deb/deblistparser.cc b/apt-pkg/deb/deblistparser.cc
index a4795f15d95923ec722185da230a7c35efc38316..616d8296d932b6ea5053df897abae979c9c511e5 100644 (file)
--- a/apt-pkg/deb/deblistparser.cc
+++ b/apt-pkg/deb/deblistparser.cc
@@ -21,8 +21,17 @@
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/crc-16.h>
 #include <apt-pkg/md5.h>
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/crc-16.h>
 #include <apt-pkg/md5.h>

+#include <apt-pkg/mmap.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/cacheiterators.h>
+#include <apt-pkg/tagfile.h>

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

+#include <stddef.h>
+#include <string.h>
+#include <algorithm>
+#include <string>
+#include <vector>

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


@@ -34,7 +43,7 @@ static debListParser::WordList PrioList[] = {
    {"standard",pkgCache::State::Standard},
    {"optional",pkgCache::State::Optional},
    {"extra",pkgCache::State::Extra},
    {"standard",pkgCache::State::Standard},
    {"optional",pkgCache::State::Optional},
    {"extra",pkgCache::State::Extra},

-   {}};
+   {NULL, 0}};

 
 // ListParser::debListParser - Constructor                             /*{{{*/
 // ---------------------------------------------------------------------
 
 // ListParser::debListParser - Constructor                             /*{{{*/
 // ---------------------------------------------------------------------


@@ -49,18 +58,6 @@ debListParser::debListParser(FileFd *File, string const &Arch) : Tags(File),
    MultiArchEnabled = Architectures.size() > 1;
 }
                                                                        /*}}}*/
    MultiArchEnabled = Architectures.size() > 1;
 }
                                                                        /*}}}*/

-// ListParser::UniqFindTagWrite - Find the tag and write a unq string  /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-unsigned long debListParser::UniqFindTagWrite(const char *Tag)
-{
-   const char *Start;
-   const char *Stop;
-   if (Section.Find(Tag,Start,Stop) == false)
-      return 0;
-   return WriteUniqString(Start,Stop - Start);
-}
-                                                                       /*}}}*/

 // ListParser::Package - Return the package name                       /*{{{*/
 // ---------------------------------------------------------------------
 /* This is to return the name of the package this section describes */
 // ListParser::Package - Return the package name                       /*{{{*/
 // ---------------------------------------------------------------------
 /* This is to return the name of the package this section describes */


@@ -95,44 +92,108 @@ string debListParser::Version()
    return Section.FindS("Version");
 }
                                                                        /*}}}*/
    return Section.FindS("Version");
 }
                                                                        /*}}}*/

-// ListParser::NewVersion - Fill in the version structure              /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-bool debListParser::NewVersion(pkgCache::VerIterator &Ver)
+unsigned char debListParser::ParseMultiArch(bool const showErrors)     /*{{{*/

 {
 {

-   // Parse the section
-   Ver->Section = UniqFindTagWrite("Section");
-
-   // Parse multi-arch
+   unsigned char MA;

    string const MultiArch = Section.FindS("Multi-Arch");
    string const MultiArch = Section.FindS("Multi-Arch");

-   if (MultiArch.empty() == true)
-      Ver->MultiArch = pkgCache::Version::None;
+   if (MultiArch.empty() == true || MultiArch == "no")
+      MA = pkgCache::Version::None;

    else if (MultiArch == "same") {
    else if (MultiArch == "same") {

-      // Parse multi-arch

       if (ArchitectureAll() == true)
       {
       if (ArchitectureAll() == true)
       {

-        /* Arch all packages can't be Multi-Arch: same */
-        _error->Warning("Architecture: all package '%s' can't be Multi-Arch: same",
-                       Section.FindS("Package").c_str());
-        Ver->MultiArch = pkgCache::Version::None;
+        if (showErrors == true)
+           _error->Warning("Architecture: all package '%s' can't be Multi-Arch: same",
+                 Section.FindS("Package").c_str());
+        MA = pkgCache::Version::None;

       }
       else
       }
       else

-        Ver->MultiArch = pkgCache::Version::Same;
+        MA = pkgCache::Version::Same;

    }
    else if (MultiArch == "foreign")
    }
    else if (MultiArch == "foreign")

-      Ver->MultiArch = pkgCache::Version::Foreign;
+      MA = pkgCache::Version::Foreign;

    else if (MultiArch == "allowed")
    else if (MultiArch == "allowed")

-      Ver->MultiArch = pkgCache::Version::Allowed;
+      MA = pkgCache::Version::Allowed;

    else
    {
    else
    {

-      _error->Warning("Unknown Multi-Arch type '%s' for package '%s'",
-                       MultiArch.c_str(), Section.FindS("Package").c_str());
-      Ver->MultiArch = pkgCache::Version::None;
+      if (showErrors == true)
+        _error->Warning("Unknown Multi-Arch type '%s' for package '%s'",
+              MultiArch.c_str(), Section.FindS("Package").c_str());
+      MA = pkgCache::Version::None;

    }
 
    if (ArchitectureAll() == true)
    }
 
    if (ArchitectureAll() == true)

-      Ver->MultiArch |= pkgCache::Version::All;
+      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("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 const G = Ver.ParentPkg().Group();
+   Ver->SourcePkgName = G->Name;
+   Ver->SourceVerStr = Ver->VerStr;
+   if (Section.Find("Source",Start,Stop) == true)
+   {
+      const char * const Space = (const char * const) memchr(Start, ' ', Stop - Start);
+      pkgCache::VerIterator V;
+
+      if (Space != NULL)
+      {
+        Stop = Space;
+        const char * const Open = (const char * const) memchr(Space, '(', Stop - Space);
+        if (likely(Open != NULL))
+        {
+           const char * const Close = (const char * const) memchr(Open, ')', Stop - Open);
+           if (likely(Close != NULL))
+           {
+              std::string const version(Open + 1, (Close - Open) - 1);
+              if (version != Ver.VerStr())
+              {
+                 map_stringitem_t const idx = StoreString(pkgCacheGenerator::VERSIONNUMBER, version);
+                 Ver->SourceVerStr = idx;
+              }
+           }
+        }
+      }

 
 

+      std::string const pkgname(Start, Stop - Start);
+      if (pkgname != G.Name())
+      {
+        for (pkgCache::PkgIterator P = G.PackageList(); P.end() == false; P = G.NextPkg(P))
+        {
+           for (V = P.VersionList(); V.end() == false; ++V)
+           {
+              if (pkgname == V.SourcePkgName())
+              {
+                 Ver->SourcePkgName = V->SourcePkgName;
+                 break;
+              }
+           }
+           if (V.end() == false)
+              break;
+        }
+        if (V.end() == true)
+        {
+           map_stringitem_t const idx = StoreString(pkgCacheGenerator::PKGNAME, pkgname);
+           Ver->SourcePkgName = idx;
+        }
+      }
+   }
+
+   Ver->MultiArch = ParseMultiArch(true);

    // Archive Size
    Ver->Size = Section.FindULL("Size");
    // Unpacked Size (in K)
    // Archive Size
    Ver->Size = Section.FindULL("Size");
    // Unpacked Size (in K)


@@ -140,10 +201,8 @@ bool debListParser::NewVersion(pkgCache::VerIterator &Ver)
    Ver->InstalledSize *= 1024;
 
    // Priority
    Ver->InstalledSize *= 1024;
 
    // Priority

-   const char *Start;
-   const char *Stop;

    if (Section.Find("Priority",Start,Stop) == true)
    if (Section.Find("Priority",Start,Stop) == true)

-   {      
+   {

       if (GrabWord(string(Start,Stop-Start),PrioList,Ver->Priority) == false)
         Ver->Priority = pkgCache::State::Extra;
    }
       if (GrabWord(string(Start,Stop-Start),PrioList,Ver->Priority) == false)
         Ver->Priority = pkgCache::State::Extra;
    }


@@ -180,35 +239,31 @@ bool debListParser::NewVersion(pkgCache::VerIterator &Ver)
 /* This is to return the string describing the package in debian
    form. If this returns the blank string then the entry is assumed to
    only describe package properties */
 /* This is to return the string describing the package in debian
    form. If this returns the blank string then the entry is assumed to
    only describe package properties */

-string debListParser::Description()
+string debListParser::Description(std::string const &lang)

 {
 {

-   string const lang = DescriptionLanguage();

    if (lang.empty())
       return Section.FindS("Description");
    else
       return Section.FindS(string("Description-").append(lang).c_str());
 }
    if (lang.empty())
       return Section.FindS("Description");
    else
       return Section.FindS(string("Description-").append(lang).c_str());
 }

-                                                                        /*}}}*/
-// ListParser::DescriptionLanguage - Return the description lang string        /*{{{*/
-// ---------------------------------------------------------------------
-/* This is to return the string describing the language of
-   description. If this returns the blank string then the entry is
-   assumed to describe original description. */
-string debListParser::DescriptionLanguage()
+                                                                       /*}}}*/
+// ListParser::AvailableDescriptionLanguages                           /*{{{*/
+std::vector<std::string> debListParser::AvailableDescriptionLanguages()

 {
 {

-   if (Section.FindS("Description").empty() == false)
-      return "";
-
-   std::vector<string> const lang = APT::Configuration::getLanguages(true);
-   for (std::vector<string>::const_iterator l = lang.begin();
-       l != lang.end(); ++l)
-      if (Section.FindS(string("Description-").append(*l).c_str()).empty() == false)
-        return *l;
-
-   return "";
+   std::vector<std::string> const understood = APT::Configuration::getLanguages();
+   std::vector<std::string> avail;
+   if (Section.Exists("Description") == true)
+      avail.push_back("");
+   for (std::vector<std::string>::const_iterator lang = understood.begin(); lang != understood.end(); ++lang)
+   {
+      std::string const tagname = "Description-" + *lang;
+      if (Section.Exists(tagname.c_str()) == true)
+        avail.push_back(*lang);
+   }
+   return avail;

 }
 }

-                                                                        /*}}}*/
-// ListParser::Description - Return the description_md5 MD5SumValue    /*{{{*/
+                                                                       /*}}}*/
+// 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
 // ---------------------------------------------------------------------
 /* 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


@@ -219,7 +274,7 @@ MD5SumValue debListParser::Description_md5()
    string const value = Section.FindS("Description-md5");
    if (value.empty() == true)
    {
    string const value = Section.FindS("Description-md5");
    if (value.empty() == true)
    {

-      std::string const desc = Description() + "\n";
+      std::string const desc = Description("") + "\n";

       if (desc == "\n")
         return MD5SumValue();
 
       if (desc == "\n")
         return MD5SumValue();
 


@@ -245,9 +300,6 @@ MD5SumValue debListParser::Description_md5()
 bool debListParser::UsePackage(pkgCache::PkgIterator &Pkg,
                               pkgCache::VerIterator &Ver)
 {
 bool debListParser::UsePackage(pkgCache::PkgIterator &Pkg,
                               pkgCache::VerIterator &Ver)
 {

-   if (Pkg->Section == 0)
-      Pkg->Section = UniqFindTagWrite("Section");
-

    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 myArch = _config->Find("APT::Architecture");
    // Possible values are: "all", "native", "installed" and "none"
    // The "installed" mode is handled by ParseStatus(), See #544481 and friends.


@@ -320,13 +372,9 @@ unsigned short debListParser::VersionHash()
 /* Status lines are of the form,
      Status: want flag status
    want = unknown, install, hold, deinstall, purge
 /* Status lines are of the form,
      Status: want flag status
    want = unknown, install, hold, deinstall, purge

-   flag = ok, reinstreq, hold, hold-reinstreq
-   status = not-installed, unpacked, half-configured,
-            half-installed, config-files, post-inst-failed, 
-            removal-failed, installed
-   
-   Some of the above are obsolete (I think?) flag = hold-* and 
-   status = post-inst-failed, removal-failed at least.
+   flag = ok, reinstreq
+   status = not-installed, config-files, half-installed, unpacked,
+            half-configured, triggers-awaited, triggers-pending, installed

  */
 bool debListParser::ParseStatus(pkgCache::PkgIterator &Pkg,
                                pkgCache::VerIterator &Ver)
  */
 bool debListParser::ParseStatus(pkgCache::PkgIterator &Pkg,
                                pkgCache::VerIterator &Ver)


@@ -354,7 +402,7 @@ bool debListParser::ParseStatus(pkgCache::PkgIterator &Pkg,
                           {"hold",pkgCache::State::Hold},
                           {"deinstall",pkgCache::State::DeInstall},
                           {"purge",pkgCache::State::Purge},
                           {"hold",pkgCache::State::Hold},
                           {"deinstall",pkgCache::State::DeInstall},
                           {"purge",pkgCache::State::Purge},

-                          {}};
+                          {NULL, 0}};

    if (GrabWord(string(Start,I-Start),WantList,Pkg->SelectedState) == false)
       return _error->Error("Malformed 1st word in the Status line");
 
    if (GrabWord(string(Start,I-Start),WantList,Pkg->SelectedState) == false)
       return _error->Error("Malformed 1st word in the Status line");
 


@@ -370,7 +418,7 @@ bool debListParser::ParseStatus(pkgCache::PkgIterator &Pkg,
                           {"reinstreq",pkgCache::State::ReInstReq},
                           {"hold",pkgCache::State::HoldInst},
                           {"hold-reinstreq",pkgCache::State::HoldReInstReq},
                           {"reinstreq",pkgCache::State::ReInstReq},
                           {"hold",pkgCache::State::HoldInst},
                           {"hold-reinstreq",pkgCache::State::HoldReInstReq},

-                          {}};
+                          {NULL, 0}};

    if (GrabWord(string(Start,I-Start),FlagList,Pkg->InstState) == false)
       return _error->Error("Malformed 2nd word in the Status line");
 
    if (GrabWord(string(Start,I-Start),FlagList,Pkg->InstState) == false)
       return _error->Error("Malformed 2nd word in the Status line");
 


@@ -383,16 +431,14 @@ bool debListParser::ParseStatus(pkgCache::PkgIterator &Pkg,
 
    // Process the flag field
    WordList StatusList[] = {{"not-installed",pkgCache::State::NotInstalled},
 
    // 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},
                             {"unpacked",pkgCache::State::UnPacked},
                             {"half-configured",pkgCache::State::HalfConfigured},

-                            {"installed",pkgCache::State::Installed},
-                            {"half-installed",pkgCache::State::HalfInstalled},
-                            {"config-files",pkgCache::State::ConfigFiles},

                             {"triggers-awaited",pkgCache::State::TriggersAwaited},
                             {"triggers-pending",pkgCache::State::TriggersPending},
                             {"triggers-awaited",pkgCache::State::TriggersAwaited},
                             {"triggers-pending",pkgCache::State::TriggersPending},

-                            {"post-inst-failed",pkgCache::State::HalfConfigured},
-                            {"removal-failed",pkgCache::State::HalfInstalled},
-                            {}};
+                            {"installed",pkgCache::State::Installed},
+                            {NULL, 0}};

    if (GrabWord(string(Start,I-Start),StatusList,Pkg->CurrentState) == false)
       return _error->Error("Malformed 3rd word in the Status line");
 
    if (GrabWord(string(Start,I-Start),StatusList,Pkg->CurrentState) == false)
       return _error->Error("Malformed 3rd word in the Status line");
 


@@ -617,72 +663,94 @@ const char *debListParser::ParseDepends(const char *Start,const char *Stop,
 
    if (ParseRestrictionsList == true)
    {
 
    if (ParseRestrictionsList == true)
    {

-      // Parse a restrictions list
-      if (I != Stop && *I == '<')
+      // 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;
 
         ++I;
         // malformed
         if (unlikely(I == Stop))
            return 0;
 

-        std::vector<string> const profiles = _config->FindVector("APT::Build-Profiles");
-

         const char *End = I;
         const char *End = I;

-        bool Found = false;
-        bool NegRestriction = false;
-        while (I != Stop)
-        {
-           // look for whitespace or ending '>'
-           for (;End != Stop && !isspace(*End) && *End != '>'; ++End);
-
-           if (unlikely(End == Stop))
-              return 0;

 
 

-           if (*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(*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)

            {
            {

-              NegRestriction = true;
-              ++I;
-           }
+              // look for whitespace or ending '>'
+              // End now points to the character after the current term
+              for (;End != Stop && !isspace(*End) && *End != '>'; ++End);

 
 

-           std::string restriction(I, End);
+              if (unlikely(End == Stop))
+                 return 0;

 
 

-           std::string prefix = "profile.";
-           // only support for "profile" prefix, ignore others
-           if (restriction.size() > prefix.size() &&
-                 restriction.substr(0, prefix.size()) == prefix)
-           {
-              // get the name of the profile
-              restriction = restriction.substr(prefix.size());
+              bool NegRestriction = false;
+              if (*I == '!')
+              {
+                 NegRestriction = true;
+                 ++I;
+              }
+
+              std::string restriction(I, End);

 
               if (restriction.empty() == false && profiles.empty() == false &&
 
               if (restriction.empty() == false && profiles.empty() == false &&

-                    std::find(profiles.begin(), profiles.end(), restriction) != profiles.end())
+                 std::find(profiles.begin(), profiles.end(), restriction) != profiles.end())

               {
               {

-                 Found = true;
-                 if (I[-1] != '!')
-                    NegRestriction = false;
-                 // we found a match, so fast-forward to the end of the wildcards
-                 for (; End != Stop && *End != '>'; ++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(*I) != 0; I++);
+                 break;

               }
               }

-           }

 
 

-           if (*End++ == '>') {

               I = End;
               I = End;

-              break;
+              // skip whitespace
+              for (;I != Stop && isspace(*I) != 0; I++);
+           }
+           if (applies2) {
+              applies1 = true;

            }
            }

-
-           I = End;
-           for (;I != Stop && isspace(*I) != 0; I++);

         }
         }

-
-        if (NegRestriction == true)
-           Found = !Found;
-
-        if (Found == false)
-           Package = ""; /* not for this restriction */

       }
 
       }
 

-      // Skip whitespace
-      for (;I != Stop && isspace(*I) != 0; I++);
+      if (applies1 == false) {
+        Package = ""; //not for this restriction
+      }

    }
 
    if (I != Stop && *I == '|')
    }
 
    if (I != Stop && *I == '|')


@@ -785,8 +853,8 @@ bool debListParser::ParseProvides(pkgCache::VerIterator &Ver)
         Start = ParseDepends(Start,Stop,Package,Version,Op);
         if (Start == 0)
            return _error->Error("Problem parsing Provides line");
         Start = ParseDepends(Start,Stop,Package,Version,Op);
         if (Start == 0)
            return _error->Error("Problem parsing Provides line");

-        if (Op != pkgCache::Dep::NoOp) {
-           _error->Warning("Ignoring Provides line with DepCompareOp for package %s", Package.c_str());
+        if (Op != pkgCache::Dep::NoOp && Op != pkgCache::Dep::Equals) {
+           _error->Warning("Ignoring Provides line with non-equal DepCompareOp for package %s", Package.c_str());

         } else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign) {
            if (NewProvidesAllArch(Ver, Package, Version) == false)
               return false;
         } else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign) {
            if (NewProvidesAllArch(Ver, Package, Version) == false)
               return false;


@@ -883,7 +951,7 @@ bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator &FileI,
 {
    // apt-secure does no longer download individual (per-section) Release
    // file. to provide Component pinning we use the section name now
 {
    // apt-secure does no longer download individual (per-section) Release
    // file. to provide Component pinning we use the section name now

-   map_ptrloc const storage = WriteUniqString(component);
+   map_stringitem_t const storage = StoreString(pkgCacheGenerator::MIXED, component);

    FileI->Component = storage;
 
    pkgTagFile TagFile(&File, File.Size());
    FileI->Component = storage;
 
    pkgTagFile TagFile(&File, File.Size());


@@ -892,19 +960,19 @@ bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator &FileI,
       return false;
 
    std::string data;
       return false;
 
    std::string data;

-   #define APT_INRELEASE(TAG, STORE) \
+   #define APT_INRELEASE(TYPE, TAG, STORE) \

    data = Section.FindS(TAG); \
    if (data.empty() == false) \
    { \
    data = Section.FindS(TAG); \
    if (data.empty() == false) \
    { \

-      map_ptrloc const storage = WriteUniqString(data); \
+      map_stringitem_t const storage = StoreString(pkgCacheGenerator::TYPE, data); \

       STORE = storage; \
    }
       STORE = storage; \
    }

-   APT_INRELEASE("Suite", FileI->Archive)
-   APT_INRELEASE("Component", FileI->Component)
-   APT_INRELEASE("Version", FileI->Version)
-   APT_INRELEASE("Origin", FileI->Origin)
-   APT_INRELEASE("Codename", FileI->Codename)
-   APT_INRELEASE("Label", FileI->Label)
+   APT_INRELEASE(MIXED, "Suite", FileI->Archive)
+   APT_INRELEASE(MIXED, "Component", FileI->Component)
+   APT_INRELEASE(VERSIONNUMBER, "Version", FileI->Version)
+   APT_INRELEASE(MIXED, "Origin", FileI->Origin)
+   APT_INRELEASE(MIXED, "Codename", FileI->Codename)
+   APT_INRELEASE(MIXED, "Label", FileI->Label)

    #undef APT_INRELEASE
    Section.FindFlag("NotAutomatic", FileI->Flags, pkgCache::Flag::NotAutomatic);
    Section.FindFlag("ButAutomaticUpgrades", FileI->Flags, pkgCache::Flag::ButAutomaticUpgrades);
    #undef APT_INRELEASE
    Section.FindFlag("NotAutomatic", FileI->Flags, pkgCache::Flag::NotAutomatic);
    Section.FindFlag("ButAutomaticUpgrades", FileI->Flags, pkgCache::Flag::ButAutomaticUpgrades);


@@ -924,3 +992,43 @@ unsigned char debListParser::GetPrio(string Str)
    return Out;
 }
                                                                        /*}}}*/
    return Out;
 }
                                                                        /*}}}*/

+#if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13)
+bool debListParser::SameVersion(unsigned short const Hash,             /*{{{*/
+      pkgCache::VerIterator const &Ver)
+{
+   if (pkgCacheGenerator::ListParser::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("Size");
+   if (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;
+}
+                                                                       /*}}}*/
+#endif
+
+
+debDebFileParser::debDebFileParser(FileFd *File, std::string const &DebFile)
+   : debListParser(File, ""), DebFile(DebFile)
+{
+}
+
+bool debDebFileParser::UsePackage(pkgCache::PkgIterator &Pkg,
+                                  pkgCache::VerIterator &Ver)
+{
+   bool res = debListParser::UsePackage(Pkg, Ver);
+   // we use the full file path as a provides so that the file is found
+   // by its name
+   if(NewProvidesAllArch(Ver, DebFile, Ver.VerStr()) == false)
+      return false;
+   return res;
+}
+
+debListParser::~debListParser() {}