"support" unsigned Release files without hashes again

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

diff --git a/apt-pkg/deb/debmetaindex.cc b/apt-pkg/deb/debmetaindex.cc
index b381f5f85bad2e22c2078b520bf1998c650872c4..a43ec706fd012eab7f3279b6cd43a3811932875f 100644 (file)
--- a/apt-pkg/deb/debmetaindex.cc
+++ b/apt-pkg/deb/debmetaindex.cc
@@ -39,6 +39,7 @@ class APT_HIDDEN debReleaseIndexPrivate                                       /*{{{*/
       std::vector<std::string> Architectures;
       std::vector<std::string> Languages;
       bool UsePDiffs;
+      std::string UseByHash;
    };
 
    std::vector<debSectionEntry> DebEntries;
@@ -48,6 +49,8 @@ class APT_HIDDEN debReleaseIndexPrivate                                       /*{{{*/
    time_t ValidUntilMin;
    time_t ValidUntilMax;
 
+   std::vector<std::string> Architectures;
+
    debReleaseIndexPrivate() : CheckValidUntil(metaIndex::TRI_UNSET), ValidUntilMin(0), ValidUntilMax(0) {}
 };
                                                                        /*}}}*/
@@ -149,6 +152,7 @@ static void GetIndexTargetsFor(char const * const Type, std::string const &URI,
         bool const KeepCompressed = APT_T_CONFIG_BOOL("KeepCompressed", GzipIndex);
         bool const DefaultEnabled = APT_T_CONFIG_BOOL("DefaultEnabled", true);
         bool const UsePDiffs = APT_T_CONFIG_BOOL("PDiffs", E->UsePDiffs);
+        std::string const UseByHash = APT_T_CONFIG_STR("By-Hash", E->UseByHash);
         std::string const CompressionTypes = APT_T_CONFIG_STR("CompressionTypes", DefCompressionTypes);
 #undef APT_T_CONFIG_BOOL
 #undef APT_T_CONFIG_STR
@@ -245,16 +249,25 @@ static void GetIndexTargetsFor(char const * const Type, std::string const &URI,
               Options.insert(std::make_pair("TARGET_OF", Type));
               Options.insert(std::make_pair("CREATED_BY", *T));
               Options.insert(std::make_pair("PDIFFS", UsePDiffs ? "yes" : "no"));
+              Options.insert(std::make_pair("BY_HASH", UseByHash));
               Options.insert(std::make_pair("DEFAULTENABLED", DefaultEnabled ? "yes" : "no"));
               Options.insert(std::make_pair("COMPRESSIONTYPES", CompressionTypes));
               Options.insert(std::make_pair("SOURCESENTRY", E->sourcesEntry));
 
+              bool IsOpt = IsOptional;
+              if (IsOpt == false)
+              {
+                 auto const arch = Options.find("ARCHITECTURE");
+                 if (arch != Options.end() && arch->second == "all")
+                    IsOpt = true;
+              }
+
               IndexTarget Target(
                     MetaKey,
                     ShortDesc,
                     LongDesc,
                     Options.find("BASE_URI")->second + MetaKey,
-                    IsOptional,
+                    IsOpt,
                     KeepCompressed,
                     Options
                     );
@@ -286,12 +299,12 @@ void debReleaseIndex::AddComponent(std::string const &sourcesEntry,       /*{{{*/
         std::vector<std::string> const &Targets,
         std::vector<std::string> const &Architectures,
         std::vector<std::string> Languages,
-        bool const usePDiffs)
+        bool const usePDiffs, std::string const &useByHash)
 {
    if (Languages.empty() == true)
       Languages.push_back("none");
    debReleaseIndexPrivate::debSectionEntry const entry = {
-      sourcesEntry, Name, Targets, Architectures, Languages, usePDiffs
+      sourcesEntry, Name, Targets, Architectures, Languages, usePDiffs, useByHash
    };
    if (isSrc)
       d->DebSrcEntries.push_back(entry);
@@ -308,7 +321,7 @@ bool debReleaseIndex::Load(std::string const &Filename, std::string * const Erro
       return false;
 
    pkgTagFile TagFile(&Fd, Fd.Size());
-   if (_error->PendingError() == true)
+   if (Fd.IsOpen() == false || Fd.Failed())
    {
       if (ErrorText != NULL)
         strprintf(*ErrorText, _("Unable to parse Release file %s"),Filename.c_str());
@@ -328,6 +341,11 @@ bool debReleaseIndex::Load(std::string const &Filename, std::string * const Erro
 
    Suite = Section.FindS("Suite");
    Codename = Section.FindS("Codename");
+   {
+      std::string const archs = Section.FindS("Architectures");
+      if (archs.empty() == false)
+        d->Architectures = VectorizeString(archs, ' ');
+   }
 
    bool FoundHashSum = false;
    for (int i=0;HashString::SupportedHashes()[i] != NULL; i++)
@@ -588,6 +606,13 @@ bool debReleaseIndex::IsTrusted() const
    return FileExists(MetaIndexFile("InRelease"));
 }
                                                                        /*}}}*/
+bool debReleaseIndex::IsArchitectureSupported(std::string const &arch) const/*{{{*/
+{
+   if (d->Architectures.empty())
+      return true;
+   return std::find(d->Architectures.begin(), d->Architectures.end(), arch) != d->Architectures.end();
+}
+                                                                       /*}}}*/
 std::vector <pkgIndexFile *> *debReleaseIndex::GetIndexFiles()         /*{{{*/
 {
    if (Indexes != NULL)
@@ -641,8 +666,6 @@ bool debReleaseIndex::Merge(pkgCacheGenerator &Gen,OpProgress * /*Prog*/) const/
    // signature for an 'InRelease' file couldn't be checked
    if (OpenMaybeClearSignedFile(ReleaseFile, Rel) == false)
       return false;
-   if (_error->PendingError() == true)
-      return false;
 
    // Store the IMS information
    pkgCache::RlsFileIterator File = Gen.GetCurRlsFile();
@@ -656,7 +679,7 @@ bool debReleaseIndex::Merge(pkgCacheGenerator &Gen,OpProgress * /*Prog*/) const/
 
    pkgTagFile TagFile(&Rel, Rel.Size());
    pkgTagSection Section;
-   if (_error->PendingError() == true || TagFile.Step(Section) == false)
+   if (Rel.IsOpen() == false || Rel.Failed() || TagFile.Step(Section) == false)
       return false;
 
    std::string data;
@@ -665,6 +688,7 @@ bool debReleaseIndex::Merge(pkgCacheGenerator &Gen,OpProgress * /*Prog*/) const/
    if (data.empty() == false) \
    { \
       map_stringitem_t const storage = Gen.StoreString(pkgCacheGenerator::TYPE, data); \
+      if (storage == 0) return false; \
       STORE = storage; \
    }
    APT_INRELEASE(MIXED, "Suite", File->Archive)
@@ -676,7 +700,7 @@ bool debReleaseIndex::Merge(pkgCacheGenerator &Gen,OpProgress * /*Prog*/) const/
    Section.FindFlag("NotAutomatic", File->Flags, pkgCache::Flag::NotAutomatic);
    Section.FindFlag("ButAutomaticUpgrades", File->Flags, pkgCache::Flag::ButAutomaticUpgrades);
 
-   return !_error->PendingError();
+   return true;
 }
                                                                        /*}}}*/
 // ReleaseIndex::FindInCache - Find this index                         /*{{{*/
@@ -727,6 +751,10 @@ static std::vector<std::string> parsePlusMinusOptions(std::string const &Name, /
    else
       Values = defaultValues;
 
+   // all is a very special architecture users shouldn't be concerned with explicitly
+   if (Name == "arch" && std::find(Values.begin(), Values.end(), "all") == Values.end())
+      Values.push_back("all");
+
    if ((val = Options.find(Name + "+")) != Options.end())
    {
       std::vector<std::string> const plus = VectorizeString(val->second, ',');
@@ -823,6 +851,17 @@ class APT_HIDDEN debSLTypeDebian : public pkgSourceList::Type              /*{{{*/
            UsePDiffs = StringToBool(opt->second);
       }
 
+      std::string UseByHash = _config->Find("APT::Acquire::By-Hash", "yes");
+      UseByHash = _config->Find("Acquire::By-Hash", UseByHash);
+      {
+        std::string const host = ::URI(URI).Host;
+        UseByHash = _config->Find("APT::Acquire::" + host + "::By-Hash", UseByHash);
+        UseByHash = _config->Find("Acquire::" + host + "::By-Hash", UseByHash);
+        std::map<std::string, std::string>::const_iterator const opt = Options.find("by-hash");
+        if (opt != Options.end())
+           UseByHash = opt->second;
+      }
+
       auto const entry = Options.find("sourceslist-entry");
       Deb->AddComponent(
            entry->second,
@@ -831,7 +870,8 @@ class APT_HIDDEN debSLTypeDebian : public pkgSourceList::Type               /*{{{*/
            mytargets,
            parsePlusMinusOptions("arch", Options, APT::Configuration::getArchitectures()),
            parsePlusMinusOptions("lang", Options, APT::Configuration::getLanguages(true)),
-           UsePDiffs
+           UsePDiffs,
+           UseByHash
            );
 
       if (Deb->SetTrusted(GetTriStateOption(Options, "trusted")) == false ||