rework hashsum verification in the acquire system

[apt.git] / apt-pkg / indexrecords.cc

diff --git a/apt-pkg/indexrecords.cc b/apt-pkg/indexrecords.cc
index 8c1e2229b85fc6c44af151774a8abc05cc58918a..c26868cac3d22a73ca036fbbb393597344580565 100644 (file)
--- a/apt-pkg/indexrecords.cc
+++ b/apt-pkg/indexrecords.cc
@@ -58,6 +58,11 @@ APT_PURE time_t indexRecords::GetValidUntil() const
    return this->ValidUntil;
 }
 
    return this->ValidUntil;
 }
 

+APT_PURE time_t indexRecords::GetDate() const
+{
+   return this->Date;
+}
+

 APT_PURE indexRecords::checkSum *indexRecords::Lookup(const string MetaKey)
 {
    std::map<std::string, indexRecords::checkSum* >::const_iterator sum = Entries.find(MetaKey);
 APT_PURE indexRecords::checkSum *indexRecords::Lookup(const string MetaKey)
 {
    std::map<std::string, indexRecords::checkSum* >::const_iterator sum = Entries.find(MetaKey);


@@ -68,7 +73,7 @@ APT_PURE indexRecords::checkSum *indexRecords::Lookup(const string MetaKey)
 
 APT_PURE bool indexRecords::Exists(string const &MetaKey) const
 {
 
 APT_PURE bool indexRecords::Exists(string const &MetaKey) const
 {

-   return Entries.count(MetaKey) == 1;
+   return Entries.find(MetaKey) != Entries.end();

 }
 
 bool indexRecords::Load(const string Filename)                         /*{{{*/
 }
 
 bool indexRecords::Load(const string Filename)                         /*{{{*/


@@ -116,14 +121,10 @@ bool indexRecords::Load(const string Filename)                            /*{{{*/
             indexRecords::checkSum *Sum = new indexRecords::checkSum;
             Sum->MetaKeyFilename = Name;
             Sum->Size = Size;
             indexRecords::checkSum *Sum = new indexRecords::checkSum;
             Sum->MetaKeyFilename = Name;
             Sum->Size = Size;

-#if __GNUC__ >= 4
-       #pragma GCC diagnostic push
-       #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-            Sum->Hash = HashString(HashString::SupportedHashes()[i],Hash);
-#if __GNUC__ >= 4
-       #pragma GCC diagnostic pop
-#endif
+           std::string SizeStr;
+           strprintf(SizeStr, "%llu", Size);
+           Sum->Hashes.push_back(HashString("Checksum-FileSize", SizeStr));
+            APT_IGNORE_DEPRECATED(Sum->Hash = HashString(HashString::SupportedHashes()[i],Hash);)

             Entries[Name] = Sum;
          }
          Entries[Name]->Hashes.push_back(HashString(HashString::SupportedHashes()[i],Hash));
             Entries[Name] = Sum;
          }
          Entries[Name]->Hashes.push_back(HashString(HashString::SupportedHashes()[i],Hash));


@@ -137,9 +138,15 @@ bool indexRecords::Load(const string Filename)                             /*{{{*/
       return false;
    }
 
       return false;
    }
 

-   string Label = Section.FindS("Label");
-   string StrDate = Section.FindS("Date");
-   string StrValidUntil = Section.FindS("Valid-Until");
+   string const StrDate = Section.FindS("Date");
+   if (RFC1123StrToTime(StrDate.c_str(), Date) == false)
+   {
+      strprintf(ErrorText, _("Invalid 'Date' entry in Release file %s"), Filename.c_str());
+      return false;
+   }
+
+   string const Label = Section.FindS("Label");
+   string const StrValidUntil = Section.FindS("Valid-Until");

 
    // if we have a Valid-Until header in the Release file, use it as default
    if (StrValidUntil.empty() == false)
 
    // if we have a Valid-Until header in the Release file, use it as default
    if (StrValidUntil.empty() == false)


@@ -162,20 +169,13 @@ bool indexRecords::Load(const string Filename)                            /*{{{*/
       (MinAge == 0 || ValidUntil == 0)) // No user settings, use the one from the Release file
       return true;
 
       (MinAge == 0 || ValidUntil == 0)) // No user settings, use the one from the Release file
       return true;
 

-   time_t date;
-   if (RFC1123StrToTime(StrDate.c_str(), date) == false)
-   {
-      strprintf(ErrorText, _("Invalid 'Date' entry in Release file %s"), Filename.c_str());
-      return false;
-   }
-

    if (MinAge != 0 && ValidUntil != 0) {
    if (MinAge != 0 && ValidUntil != 0) {

-      time_t const min_date = date + MinAge;
+      time_t const min_date = Date + MinAge;

       if (ValidUntil < min_date)
         ValidUntil = min_date;
    }
    if (MaxAge != 0) {
       if (ValidUntil < min_date)
         ValidUntil = min_date;
    }
    if (MaxAge != 0) {

-      time_t const max_date = date + MaxAge;
+      time_t const max_date = Date + MaxAge;

       if (ValidUntil == 0 || ValidUntil > max_date)
         ValidUntil = max_date;
    }
       if (ValidUntil == 0 || ValidUntil > max_date)
         ValidUntil = max_date;
    }


@@ -253,13 +253,44 @@ bool indexRecords::parseSumData(const char *&Start, const char *End,      /*{{{*/
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

-indexRecords::indexRecords()
+
+APT_PURE bool indexRecords::IsAlwaysTrusted() const

 {
 {

+   if (Trusted == ALWAYS_TRUSTED)
+      return true;
+   return false;
+}
+APT_PURE bool indexRecords::IsNeverTrusted() const
+{
+   if (Trusted == NEVER_TRUSTED)
+      return true;
+   return false;
+}
+void indexRecords::SetTrusted(bool const Trusted)
+{
+   if (Trusted == true)
+      this->Trusted = ALWAYS_TRUSTED;
+   else
+      this->Trusted = NEVER_TRUSTED;

 }
 
 }
 

+#if APT_PKG_ABI >= 413
+indexRecords::indexRecords(const string &ExpectedDist) :
+   Trusted(CHECK_TRUST), d(NULL), ExpectedDist(ExpectedDist), ValidUntil(0),
+   SupportsAcquireByHash(false)
+{
+}
+#else
+indexRecords::indexRecords() :
+   Trusted(CHECK_TRUST), d(NULL), ExpectedDist(""), ValidUntil(0),
+   SupportsAcquireByHash(false)
+{
+}

 indexRecords::indexRecords(const string ExpectedDist) :
 indexRecords::indexRecords(const string ExpectedDist) :

-   ExpectedDist(ExpectedDist), ValidUntil(0), SupportsAcquireByHash(false)
+   Trusted(CHECK_TRUST), d(NULL), ExpectedDist(ExpectedDist), ValidUntil(0),
+   SupportsAcquireByHash(false)

 {
 }
 {
 }

+#endif

 
 indexRecords::~indexRecords() {}
 
 indexRecords::~indexRecords() {}