Allow override of Proxy-Auto-Detect by the users configuration

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

diff --git a/apt-pkg/deb/deblistparser.cc b/apt-pkg/deb/deblistparser.cc
index c2707d0a505fd35d71b13d96a334ee19967bddf0..7d4fd52cf9e9a8866ca508fd924f9dc3b3246385 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                             /*{{{*/
 // ---------------------------------------------------------------------


@@ -95,44 +104,50 @@ 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)
+{
+   // Parse the section
+   unsigned long const idxSection = UniqFindTagWrite("Section");
+   Ver->Section = idxSection;
+   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)


@@ -246,7 +261,10 @@ bool debListParser::UsePackage(pkgCache::PkgIterator &Pkg,
                               pkgCache::VerIterator &Ver)
 {
    if (Pkg->Section == 0)
                               pkgCache::VerIterator &Ver)
 {
    if (Pkg->Section == 0)

-      Pkg->Section = UniqFindTagWrite("Section");
+   {
+      unsigned long const idxSection = UniqFindTagWrite("Section");
+      Pkg->Section = idxSection;
+   }

 
    string const static myArch = _config->Find("APT::Architecture");
    // Possible values are: "all", "native", "installed" and "none"
 
    string const static myArch = _config->Find("APT::Architecture");
    // Possible values are: "all", "native", "installed" and "none"


@@ -354,7 +372,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 +388,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");
 


@@ -392,7 +410,7 @@ bool debListParser::ParseStatus(pkgCache::PkgIterator &Pkg,
                             {"triggers-pending",pkgCache::State::TriggersPending},
                             {"post-inst-failed",pkgCache::State::HalfConfigured},
                             {"removal-failed",pkgCache::State::HalfInstalled},
                             {"triggers-pending",pkgCache::State::TriggersPending},
                             {"post-inst-failed",pkgCache::State::HalfConfigured},
                             {"removal-failed",pkgCache::State::HalfInstalled},

-                            {}};
+                            {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");
 


@@ -474,18 +492,31 @@ const char *debListParser::ConvertRelation(const char *I,unsigned int &Op)
 // ---------------------------------------------------------------------
 /* This parses the dependency elements out of a standard string in place,
    bit by bit. */
 // ---------------------------------------------------------------------
 /* 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,
+               std::string &Package,std::string &Ver,unsigned int &Op)
+   { return ParseDepends(Start, Stop, Package, Ver, Op, false, true, false); }
+const char *debListParser::ParseDepends(const char *Start,const char *Stop,
+               std::string &Package,std::string &Ver,unsigned int &Op,
+               bool const &ParseArchFlags)
+   { return ParseDepends(Start, Stop, Package, Ver, Op, ParseArchFlags, true, false); }
+const char *debListParser::ParseDepends(const char *Start,const char *Stop,
+               std::string &Package,std::string &Ver,unsigned int &Op,
+               bool const &ParseArchFlags, bool const &StripMultiArch)
+   { return ParseDepends(Start, Stop, Package, Ver, Op, ParseArchFlags, StripMultiArch, false); }

 const char *debListParser::ParseDepends(const char *Start,const char *Stop,
                                        string &Package,string &Ver,
                                        unsigned int &Op, bool const &ParseArchFlags,
 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 &StripMultiArch,
+                                       bool const &ParseRestrictionsList)

 {
    // Strip off leading space
 {
    // Strip off leading space

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

    
    // Parse off the package name
    const char *I = Start;
    for (;I != Stop && isspace(*I) == 0 && *I != '(' && *I != ')' &&
    
    // Parse off the package name
    const char *I = Start;
    for (;I != Stop && isspace(*I) == 0 && *I != '(' && *I != ')' &&

-       *I != ',' && *I != '|' && *I != '[' && *I != ']'; I++);
+       *I != ',' && *I != '|' && *I != '[' && *I != ']' &&
+       *I != '<' && *I != '>'; ++I);

    
    // Malformed, no '('
    if (I != Stop && *I == ')')
    
    // Malformed, no '('
    if (I != Stop && *I == ')')


@@ -602,6 +633,76 @@ const char *debListParser::ParseDepends(const char *Start,const char *Stop,
       for (;I != Stop && isspace(*I) != 0; I++);
    }
 
       for (;I != Stop && isspace(*I) != 0; I++);
    }
 

+   if (ParseRestrictionsList == true)
+   {
+      // Parse a restrictions list
+      if (I != Stop && *I == '<')
+      {
+        ++I;
+        // malformed
+        if (unlikely(I == Stop))
+           return 0;
+
+        std::vector<string> const profiles = APT::Configuration::getBuildProfiles();
+
+        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 == '!')
+           {
+              NegRestriction = true;
+              ++I;
+           }
+
+           std::string restriction(I, End);
+
+           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());
+
+              if (restriction.empty() == false && profiles.empty() == false &&
+                    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 (*End++ == '>') {
+              I = End;
+              break;
+           }
+
+           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 (I != Stop && *I == '|')
       Op |= pkgCache::Dep::Or;
    
    if (I != Stop && *I == '|')
       Op |= pkgCache::Dep::Or;
    


@@ -635,7 +736,7 @@ bool debListParser::ParseDepends(pkgCache::VerIterator &Ver,
       string Version;
       unsigned int Op;
 
       string Version;
       unsigned int Op;
 

-      Start = ParseDepends(Start,Stop,Package,Version,Op,false,!MultiArchEnabled);
+      Start = ParseDepends(Start, Stop, Package, Version, Op, false, false, false);

       if (Start == 0)
         return _error->Error("Problem parsing dependency %s",Tag);
       size_t const found = Package.rfind(':');
       if (Start == 0)
         return _error->Error("Problem parsing dependency %s",Tag);
       size_t const found = Package.rfind(':');


@@ -702,8 +803,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;


@@ -717,9 +818,7 @@ bool debListParser::ParseProvides(pkgCache::VerIterator &Ver)
       }
    }
 
       }
    }
 

-   if (MultiArchEnabled == false)
-      return true;
-   else if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
+   if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)

    {
       string const Package = string(Ver.ParentPkg().Name()).append(":").append("any");
       return NewProvidesAllArch(Ver, Package, Ver.VerStr());
    {
       string const Package = string(Ver.ParentPkg().Name()).append(":").append("any");
       return NewProvidesAllArch(Ver, Package, Ver.VerStr());


@@ -760,7 +859,7 @@ bool debListParser::GrabWord(string Word,WordList *List,unsigned char &Out)
                                                                        /*}}}*/
 // ListParser::Step - Move to the next section in the file             /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // ListParser::Step - Move to the next section in the file             /*{{{*/
 // ---------------------------------------------------------------------

-/* This has to be carefull to only process the correct architecture */
+/* This has to be careful to only process the correct architecture */

 bool debListParser::Step()
 {
    iOffset = Tags.Offset();
 bool debListParser::Step()
 {
    iOffset = Tags.Offset();


@@ -805,7 +904,7 @@ bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator &FileI,
    map_ptrloc const storage = WriteUniqString(component);
    FileI->Component = storage;
 
    map_ptrloc const storage = WriteUniqString(component);
    FileI->Component = storage;
 

-   pkgTagFile TagFile(&File);
+   pkgTagFile TagFile(&File, File.Size());

    pkgTagSection Section;
    if (_error->PendingError() == true || TagFile.Step(Section) == false)
       return false;
    pkgTagSection Section;
    if (_error->PendingError() == true || TagFile.Step(Section) == false)
       return false;


@@ -843,3 +942,24 @@ 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