implement dpkgs vision of interpreting pkg:<arch> dependencies

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

diff --git a/apt-pkg/deb/deblistparser.cc b/apt-pkg/deb/deblistparser.cc
index 616d8296d932b6ea5053df897abae979c9c511e5..b51ee815e363f11e7d79effd54f10f57da6b4d6c 100644 (file)
--- a/apt-pkg/deb/deblistparser.cc
+++ b/apt-pkg/deb/deblistparser.cc
@@ -18,10 +18,8 @@
 #include <apt-pkg/cachefilter.h>
 #include <apt-pkg/aptconfiguration.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/cachefilter.h>
 #include <apt-pkg/aptconfiguration.h>
 #include <apt-pkg/strutl.h>

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

 #include <apt-pkg/crc-16.h>
 #include <apt-pkg/md5.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/pkgcache.h>
 #include <apt-pkg/cacheiterators.h>
 #include <apt-pkg/tagfile.h>


@@ -50,12 +48,9 @@ static debListParser::WordList PrioList[] = {
 /* 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() */
 /* 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, string const &Arch) : Tags(File),
-                               Arch(Arch) {
-   if (Arch == "native")
-      this->Arch = _config->Find("APT::Architecture");
-   Architectures = APT::Configuration::getArchitectures();
-   MultiArchEnabled = Architectures.size() > 1;
+debListParser::debListParser(FileFd *File) :
+   pkgCacheListParser(), d(NULL), Tags(File)
+{

 }
                                                                        /*}}}*/
 // ListParser::Package - Return the package name                       /*{{{*/
 }
                                                                        /*}}}*/
 // ListParser::Package - Return the package name                       /*{{{*/


@@ -72,7 +67,8 @@ string debListParser::Package() {
 // ---------------------------------------------------------------------
 /* This will return the Architecture of the package this section describes */
 string debListParser::Architecture() {
 // ---------------------------------------------------------------------
 /* This will return the Architecture of the package this section describes */
 string debListParser::Architecture() {

-   return Section.FindS("Architecture");
+   std::string const Arch = Section.FindS("Architecture");
+   return Arch.empty() ? "none" : Arch;

 }
                                                                        /*}}}*/
 // ListParser::ArchitectureAll                                         /*{{{*/
 }
                                                                        /*}}}*/
 // ListParser::ArchitectureAll                                         /*{{{*/


@@ -97,14 +93,14 @@ unsigned char debListParser::ParseMultiArch(bool const showErrors)  /*{{{*/
    unsigned char MA;
    string const MultiArch = Section.FindS("Multi-Arch");
    if (MultiArch.empty() == true || MultiArch == "no")
    unsigned char MA;
    string const MultiArch = Section.FindS("Multi-Arch");
    if (MultiArch.empty() == true || MultiArch == "no")

-      MA = pkgCache::Version::None;
+      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());
    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::None;
+        MA = pkgCache::Version::No;

       }
       else
         MA = pkgCache::Version::Same;
       }
       else
         MA = pkgCache::Version::Same;


@@ -118,7 +114,7 @@ unsigned char debListParser::ParseMultiArch(bool const showErrors)  /*{{{*/
       if (showErrors == true)
         _error->Warning("Unknown Multi-Arch type '%s' for package '%s'",
               MultiArch.c_str(), Section.FindS("Package").c_str());
       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;
+      MA = pkgCache::Version::No;

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


@@ -207,23 +203,22 @@ bool debListParser::NewVersion(pkgCache::VerIterator &Ver)
         Ver->Priority = pkgCache::State::Extra;
    }
 
         Ver->Priority = pkgCache::State::Extra;
    }
 

-   if (ParseDepends(Ver,"Depends",pkgCache::Dep::Depends) == false)
-      return false;

    if (ParseDepends(Ver,"Pre-Depends",pkgCache::Dep::PreDepends) == false)
       return false;
    if (ParseDepends(Ver,"Pre-Depends",pkgCache::Dep::PreDepends) == false)
       return false;

-   if (ParseDepends(Ver,"Suggests",pkgCache::Dep::Suggests) == false)
-      return false;
-   if (ParseDepends(Ver,"Recommends",pkgCache::Dep::Recommends) == false)
+   if (ParseDepends(Ver,"Depends",pkgCache::Dep::Depends) == false)

       return false;
    if (ParseDepends(Ver,"Conflicts",pkgCache::Dep::Conflicts) == false)
       return false;
    if (ParseDepends(Ver,"Breaks",pkgCache::Dep::DpkgBreaks) == false)
       return false;
       return false;
    if (ParseDepends(Ver,"Conflicts",pkgCache::Dep::Conflicts) == false)
       return false;
    if (ParseDepends(Ver,"Breaks",pkgCache::Dep::DpkgBreaks) == false)
       return false;

+   if (ParseDepends(Ver,"Recommends",pkgCache::Dep::Recommends) == false)
+      return false;
+   if (ParseDepends(Ver,"Suggests",pkgCache::Dep::Suggests) == false)
+      return false;

    if (ParseDepends(Ver,"Replaces",pkgCache::Dep::Replaces) == false)
       return false;
    if (ParseDepends(Ver,"Enhances",pkgCache::Dep::Enhances) == false)
       return false;
    if (ParseDepends(Ver,"Replaces",pkgCache::Dep::Replaces) == false)
       return false;
    if (ParseDepends(Ver,"Enhances",pkgCache::Dep::Enhances) == false)
       return false;

-

    // Obsolete.
    if (ParseDepends(Ver,"Optional",pkgCache::Dep::Suggests) == false)
       return false;
    // Obsolete.
    if (ParseDepends(Ver,"Optional",pkgCache::Dep::Suggests) == false)
       return false;


@@ -367,7 +362,7 @@ unsigned short debListParser::VersionHash()
    return Result;
 }
                                                                        /*}}}*/
    return Result;
 }
                                                                        /*}}}*/

-// ListParser::ParseStatus - Parse the status field                    /*{{{*/
+// StatusListParser::ParseStatus - Parse the status field              /*{{{*/

 // ---------------------------------------------------------------------
 /* Status lines are of the form,
      Status: want flag status
 // ---------------------------------------------------------------------
 /* Status lines are of the form,
      Status: want flag status


@@ -376,7 +371,12 @@ unsigned short debListParser::VersionHash()
    status = not-installed, config-files, half-installed, unpacked,
             half-configured, triggers-awaited, triggers-pending, installed
  */
    status = not-installed, config-files, half-installed, unpacked,
             half-configured, triggers-awaited, triggers-pending, installed
  */

-bool debListParser::ParseStatus(pkgCache::PkgIterator &Pkg,
+bool debListParser::ParseStatus(pkgCache::PkgIterator &,
+                               pkgCache::VerIterator &)
+{
+   return true;
+}
+bool debStatusListParser::ParseStatus(pkgCache::PkgIterator &Pkg,

                                pkgCache::VerIterator &Ver)
 {
    const char *Start;
                                pkgCache::VerIterator &Ver)
 {
    const char *Start;


@@ -791,43 +791,27 @@ bool debListParser::ParseDepends(pkgCache::VerIterator &Ver,
         return _error->Error("Problem parsing dependency %s",Tag);
       size_t const found = Package.rfind(':');
 
         return _error->Error("Problem parsing dependency %s",Tag);
       size_t const found = Package.rfind(':');
 

-      // If negative is unspecific it needs to apply on all architectures
-      if (MultiArchEnabled == true && found == string::npos &&
-         (Type == pkgCache::Dep::Conflicts ||
-          Type == pkgCache::Dep::DpkgBreaks ||
-          Type == pkgCache::Dep::Replaces))
+      if (found == string::npos)

       {
       {

-        for (std::vector<std::string>::const_iterator a = Architectures.begin();
-             a != Architectures.end(); ++a)
-           if (NewDepends(Ver,Package,*a,Version,Op,Type) == false)
-              return false;
-        if (NewDepends(Ver,Package,"none",Version,Op,Type) == false)
+        if (NewDepends(Ver,Package,pkgArch,Version,Op,Type) == false)

            return false;
       }
            return false;
       }

-      else if (MultiArchEnabled == true && found != string::npos &&
-              strcmp(Package.c_str() + found, ":any") != 0)
+      else if (strcmp(Package.c_str() + found, ":any") == 0)

       {
       {

-        string Arch = Package.substr(found+1, string::npos);
-        Package = Package.substr(0, found);
-        // Such dependencies are not supposed to be accepted …
-        // … but this is probably the best thing to do.
-        if (Arch == "native")
-           Arch = _config->Find("APT::Architecture");
-        if (NewDepends(Ver,Package,Arch,Version,Op,Type) == false)
+        if (NewDepends(Ver,Package,"any",Version,Op,Type) == false)

            return false;
       }
       else
       {
            return false;
       }
       else
       {

-        if (NewDepends(Ver,Package,pkgArch,Version,Op,Type) == false)
-           return false;
-        if ((Type == pkgCache::Dep::Conflicts ||
-             Type == pkgCache::Dep::DpkgBreaks ||
-             Type == pkgCache::Dep::Replaces) &&
-            NewDepends(Ver, Package,
-                       (pkgArch != "none") ? "none" : _config->Find("APT::Architecture"),
-                       Version,Op,Type) == false)
+        // Such dependencies are not supposed to be accepted …
+        // … but this is probably the best thing to do anyway
+        if (Package.substr(found + 1) == "native")
+           Package = Package.substr(0, found) + ':' + Ver.Cache()->NativeArch();
+
+        if (NewDepends(Ver, Package, "any", Version, Op | pkgCache::Dep::ArchSpecific, Type) == false)

            return false;
       }
            return false;
       }

+

       if (Start == Stop)
         break;
    }
       if (Start == Stop)
         break;
    }


@@ -839,54 +823,97 @@ bool debListParser::ParseDepends(pkgCache::VerIterator &Ver,
 /* */
 bool debListParser::ParseProvides(pkgCache::VerIterator &Ver)
 {
 /* */
 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("Provides",Start,Stop) == true)
    {
       string Package;
       string Version;
    const char *Start;
    const char *Stop;
    if (Section.Find("Provides",Start,Stop) == true)
    {
       string Package;
       string Version;

-      string const Arch = Ver.Arch();

       unsigned int Op;
 
       unsigned int Op;
 

-      while (1)
+      do

       {
       {

-        Start = ParseDepends(Start,Stop,Package,Version,Op);
+        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");
         if (Op != pkgCache::Dep::NoOp && Op != pkgCache::Dep::Equals) {
            _error->Warning("Ignoring Provides line with non-equal DepCompareOp for package %s", Package.c_str());
         if (Start == 0)
            return _error->Error("Problem parsing Provides line");
         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)
+        } else if (archfound != string::npos) {
+           std::string 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;
               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 {
         } else {

-           if (NewProvides(Ver, Package, Arch, Version) == false)
+           if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
+           {
+              if (NewProvides(Ver, Package + ":any", "any", Version, pkgCache::Flag::MultiArchImplicit) == false)
+                 return false;
+           }
+           if (NewProvides(Ver, Package, Arch, Version, 0) == false)

               return false;
         }
               return false;
         }

-
-        if (Start == Stop)
-           break;
-      }
+        if (archfound == std::string::npos)
+        {
+           std::string const spzName = Package + ':' + 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 ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
+   if (APT::Configuration::checkArchitecture(Arch))

    {
    {

-      string const Package = string(Ver.ParentPkg().Name()).append(":").append("any");
-      return NewProvidesAllArch(Ver, Package, Ver.VerStr());
+      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;
+      }

    }
    }

-   else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
-      return NewProvidesAllArch(Ver, Ver.ParentPkg().Name(), Ver.VerStr());

 
 

-   return true;
-}
-                                                                       /*}}}*/
-// ListParser::NewProvides - add provides for all architectures                /*{{{*/
-bool debListParser::NewProvidesAllArch(pkgCache::VerIterator &Ver, string const &Package,
-                               string const &Version) {
-   for (std::vector<string>::const_iterator a = Architectures.begin();
-       a != Architectures.end(); ++a)
+   if (hasProvidesAlready == false)

    {
    {

-      if (NewProvides(Ver, Package, *a, Version) == false)
-        return 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;
 }
    }
    return true;
 }


@@ -913,71 +940,7 @@ bool debListParser::GrabWord(string Word,WordList *List,unsigned char &Out)
 bool debListParser::Step()
 {
    iOffset = Tags.Offset();
 bool debListParser::Step()
 {
    iOffset = Tags.Offset();

-   while (Tags.Step(Section) == true)
-   {      
-      /* See if this is the correct Architecture, if it isn't then we
-         drop the whole section. A missing arch tag only happens (in theory)
-         inside the Status file, so that is a positive return */
-      string const Architecture = Section.FindS("Architecture");
-
-      if (Arch.empty() == true || Arch == "any" || MultiArchEnabled == false)
-      {
-        if (APT::Configuration::checkArchitecture(Architecture) == true)
-           return true;
-        /* parse version stanzas without an architecture only in the status file
-           (and as misfortune bycatch flat-archives) */
-        if ((Arch.empty() == true || Arch == "any") && Architecture.empty() == true)
-           return true;
-      }
-      else
-      {
-        if (Architecture == Arch)
-           return true;
-
-        if (Architecture == "all" && Arch == _config->Find("APT::Architecture"))
-           return true;
-      }
-
-      iOffset = Tags.Offset();
-   }   
-   return false;
-}
-                                                                       /*}}}*/
-// ListParser::LoadReleaseInfo - Load the release information          /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator &FileI,
-                                   FileFd &File, string component)
-{
-   // apt-secure does no longer download individual (per-section) Release
-   // file. to provide Component pinning we use the section name now
-   map_stringitem_t const storage = StoreString(pkgCacheGenerator::MIXED, component);
-   FileI->Component = storage;
-
-   pkgTagFile TagFile(&File, File.Size());
-   pkgTagSection Section;
-   if (_error->PendingError() == true || 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 = StoreString(pkgCacheGenerator::TYPE, data); \
-      STORE = storage; \
-   }
-   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);
-
-   return !_error->PendingError();
+   return Tags.Step(Section);

 }
                                                                        /*}}}*/
 // ListParser::GetPrio - Convert the priority from a string            /*{{{*/
 }
                                                                        /*}}}*/
 // ListParser::GetPrio - Convert the priority from a string            /*{{{*/


@@ -992,11 +955,10 @@ 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)
 {
 bool debListParser::SameVersion(unsigned short const Hash,             /*{{{*/
       pkgCache::VerIterator const &Ver)
 {

-   if (pkgCacheGenerator::ListParser::SameVersion(Hash, Ver) == false)
+   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
       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


@@ -1012,11 +974,9 @@ bool debListParser::SameVersion(unsigned short const Hash,                /*{{{*/
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

-#endif
-

 
 debDebFileParser::debDebFileParser(FileFd *File, std::string const &DebFile)
 
 debDebFileParser::debDebFileParser(FileFd *File, std::string const &DebFile)

-   : debListParser(File, ""), DebFile(DebFile)
+   : debListParser(File), DebFile(DebFile)

 {
 }
 
 {
 }
 


@@ -1026,7 +986,7 @@ bool debDebFileParser::UsePackage(pkgCache::PkgIterator &Pkg,
    bool res = debListParser::UsePackage(Pkg, Ver);
    // we use the full file path as a provides so that the file is found
    // by its name
    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)
+   if(NewProvides(Ver, DebFile, Pkg.Cache()->NativeArch(), Ver.VerStr(), 0) == false)

       return false;
    return res;
 }
       return false;
    return res;
 }