apt-pkg/indexrecords.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: indexrecords.cc,v 1.1.2.4 2003/12/30 02:11:43 mdz Exp $
   4                                                                         /*}}}*/
   5 // Include Files                                                        /*{{{*/
   6 #include<config.h>
   7
   8 #include <apt-pkg/indexrecords.h>
   9 #include <apt-pkg/tagfile.h>
  10 #include <apt-pkg/error.h>
  11 #include <apt-pkg/strutl.h>
  12 #include <apt-pkg/configuration.h>
  13 #include <apt-pkg/fileutl.h>
  14 #include <apt-pkg/hashes.h>
  15 #include <apt-pkg/gpgv.h>
  16
  17 #include <stdlib.h>
  18 #include <time.h>
  19 #include <clocale>
  20 #include <map>
  21 #include <string>
  22 #include <utility>
  23 #include <vector>
  24
  25 #include <apti18n.h>
  26                                                                         /*}}}*/
  27
  28 using std::string;
  29
  30 APT_PURE string indexRecords::GetDist() const
  31 {
  32    return this->Dist;
  33 }
  34
  35 APT_PURE string indexRecords::GetSuite() const
  36 {
  37    return this->Suite;
  38 }
  39
  40 APT_PURE bool indexRecords::GetSupportsAcquireByHash() const
  41 {
  42    return this->SupportsAcquireByHash;
  43 }
  44
  45 APT_PURE bool indexRecords::CheckDist(const string MaybeDist) const
  46 {
  47    return (this->Dist == MaybeDist
  48            || this->Suite == MaybeDist);
  49 }
  50
  51 APT_PURE string indexRecords::GetExpectedDist() const
  52 {
  53    return this->ExpectedDist;
  54 }
  55
  56 APT_PURE time_t indexRecords::GetValidUntil() const
  57 {
  58    return this->ValidUntil;
  59 }
  60
  61 APT_PURE indexRecords::checkSum *indexRecords::Lookup(const string MetaKey)
  62 {
  63    std::map<std::string, indexRecords::checkSum* >::const_iterator sum = Entries.find(MetaKey);
  64    if (sum == Entries.end())
  65       return NULL;
  66    return sum->second;
  67 }
  68
  69 APT_PURE bool indexRecords::Exists(string const &MetaKey) const
  70 {
  71    return Entries.count(MetaKey) == 1;
  72 }
  73
  74 bool indexRecords::Load(const string Filename)                          /*{{{*/
  75 {
  76    FileFd Fd;
  77    if (OpenMaybeClearSignedFile(Filename, Fd) == false)
  78       return false;
  79
  80    pkgTagFile TagFile(&Fd, Fd.Size());
  81    if (_error->PendingError() == true)
  82    {
  83       strprintf(ErrorText, _("Unable to parse Release file %s"),Filename.c_str());
  84       return false;
  85    }
  86
  87    pkgTagSection Section;
  88    const char *Start, *End;
  89    if (TagFile.Step(Section) == false)
  90    {
  91       strprintf(ErrorText, _("No sections in Release file %s"), Filename.c_str());
  92       return false;
  93    }
  94    // FIXME: find better tag name
  95    SupportsAcquireByHash = Section.FindB("Acquire-By-Hash", false);
  96
  97    Suite = Section.FindS("Suite");
  98    Dist = Section.FindS("Codename");
  99
 100    bool FoundHashSum = false;
 101    for (int i=0;HashString::SupportedHashes()[i] != NULL; i++)
 102    {
 103       if (!Section.Find(HashString::SupportedHashes()[i], Start, End))
 104          continue;
 105
 106       string Name;
 107       string Hash;
 108       unsigned long long Size;
 109       while (Start < End)
 110       {
 111          if (!parseSumData(Start, End, Name, Hash, Size))
 112             return false;
 113
 114          if (Entries.find(Name) == Entries.end())
 115          {
 116             indexRecords::checkSum *Sum = new indexRecords::checkSum;
 117             Sum->MetaKeyFilename = Name;
 118             Sum->Size = Size;
 119             std::string SizeStr;
 120             strprintf(SizeStr, "%llu", Size);
 121             Sum->Hashes.push_back(HashString("Checksum-FileSize", SizeStr));
 122             APT_IGNORE_DEPRECATED(Sum->Hash = HashString(HashString::SupportedHashes()[i],Hash);)
 123             Entries[Name] = Sum;
 124          }
 125          Entries[Name]->Hashes.push_back(HashString(HashString::SupportedHashes()[i],Hash));
 126          FoundHashSum = true;
 127       }
 128    }
 129
 130    if(FoundHashSum == false)
 131    {
 132       strprintf(ErrorText, _("No Hash entry in Release file %s"), Filename.c_str());
 133       return false;
 134    }
 135
 136    string Label = Section.FindS("Label");
 137    string StrDate = Section.FindS("Date");
 138    string StrValidUntil = Section.FindS("Valid-Until");
 139
 140    // if we have a Valid-Until header in the Release file, use it as default
 141    if (StrValidUntil.empty() == false)
 142    {
 143       if(RFC1123StrToTime(StrValidUntil.c_str(), ValidUntil) == false)
 144       {
 145          strprintf(ErrorText, _("Invalid 'Valid-Until' entry in Release file %s"), Filename.c_str());
 146          return false;
 147       }
 148    }
 149    // get the user settings for this archive and use what expires earlier
 150    int MaxAge = _config->FindI("Acquire::Max-ValidTime", 0);
 151    if (Label.empty() == false)
 152       MaxAge = _config->FindI(("Acquire::Max-ValidTime::" + Label).c_str(), MaxAge);
 153    int MinAge = _config->FindI("Acquire::Min-ValidTime", 0);
 154    if (Label.empty() == false)
 155       MinAge = _config->FindI(("Acquire::Min-ValidTime::" + Label).c_str(), MinAge);
 156
 157    if(MaxAge == 0 &&
 158       (MinAge == 0 || ValidUntil == 0)) // No user settings, use the one from the Release file
 159       return true;
 160
 161    time_t date;
 162    if (RFC1123StrToTime(StrDate.c_str(), date) == false)
 163    {
 164       strprintf(ErrorText, _("Invalid 'Date' entry in Release file %s"), Filename.c_str());
 165       return false;
 166    }
 167
 168    if (MinAge != 0 && ValidUntil != 0) {
 169       time_t const min_date = date + MinAge;
 170       if (ValidUntil < min_date)
 171          ValidUntil = min_date;
 172    }
 173    if (MaxAge != 0) {
 174       time_t const max_date = date + MaxAge;
 175       if (ValidUntil == 0 || ValidUntil > max_date)
 176          ValidUntil = max_date;
 177    }
 178
 179    return true;
 180 }
 181                                                                         /*}}}*/
 182 std::vector<string> indexRecords::MetaKeys()                            /*{{{*/
 183 {
 184    std::vector<std::string> keys;
 185    std::map<string,checkSum *>::iterator I = Entries.begin();
 186    while(I != Entries.end()) {
 187       keys.push_back((*I).first);
 188       ++I;
 189    }
 190    return keys;
 191 }
 192                                                                         /*}}}*/
 193 bool indexRecords::parseSumData(const char *&Start, const char *End,    /*{{{*/
 194                                    string &Name, string &Hash, unsigned long long &Size)
 195 {
 196    Name = "";
 197    Hash = "";
 198    Size = 0;
 199    /* Skip over the first blank */
 200    while ((*Start == '\t' || *Start == ' ' || *Start == '\n' || *Start == '\r')
 201           && Start < End)
 202       Start++;
 203    if (Start >= End)
 204       return false;
 205
 206    /* Move EntryEnd to the end of the first entry (the hash) */
 207    const char *EntryEnd = Start;
 208    while ((*EntryEnd != '\t' && *EntryEnd != ' ')
 209           && EntryEnd < End)
 210       EntryEnd++;
 211    if (EntryEnd == End)
 212       return false;
 213
 214    Hash.append(Start, EntryEnd-Start);
 215
 216    /* Skip over intermediate blanks */
 217    Start = EntryEnd;
 218    while (*Start == '\t' || *Start == ' ')
 219       Start++;
 220    if (Start >= End)
 221       return false;
 222
 223    EntryEnd = Start;
 224    /* Find the end of the second entry (the size) */
 225    while ((*EntryEnd != '\t' && *EntryEnd != ' ' )
 226           && EntryEnd < End)
 227       EntryEnd++;
 228    if (EntryEnd == End)
 229       return false;
 230
 231    Size = strtoull (Start, NULL, 10);
 232
 233    /* Skip over intermediate blanks */
 234    Start = EntryEnd;
 235    while (*Start == '\t' || *Start == ' ')
 236       Start++;
 237    if (Start >= End)
 238       return false;
 239
 240    EntryEnd = Start;
 241    /* Find the end of the third entry (the filename) */
 242    while ((*EntryEnd != '\t' && *EntryEnd != ' ' &&
 243            *EntryEnd != '\n' && *EntryEnd != '\r')
 244           && EntryEnd < End)
 245       EntryEnd++;
 246
 247    Name.append(Start, EntryEnd-Start);
 248    Start = EntryEnd; //prepare for the next round
 249    return true;
 250 }
 251                                                                         /*}}}*/
 252
 253 APT_PURE bool indexRecords::IsAlwaysTrusted() const
 254 {
 255    if (Trusted == ALWAYS_TRUSTED)
 256       return true;
 257    return false;
 258 }
 259 APT_PURE bool indexRecords::IsNeverTrusted() const
 260 {
 261    if (Trusted == NEVER_TRUSTED)
 262       return true;
 263    return false;
 264 }
 265 void indexRecords::SetTrusted(bool const Trusted)
 266 {
 267    if (Trusted == true)
 268       this->Trusted = ALWAYS_TRUSTED;
 269    else
 270       this->Trusted = NEVER_TRUSTED;
 271 }
 272
 273 #if APT_PKG_ABI >= 413
 274 indexRecords::indexRecords(const string &ExpectedDist) :
 275    Trusted(CHECK_TRUST), d(NULL), ExpectedDist(ExpectedDist), ValidUntil(0),
 276    SupportsAcquireByHash(false)
 277 {
 278 }
 279 #else
 280 indexRecords::indexRecords() :
 281    Trusted(CHECK_TRUST), d(NULL), ExpectedDist(""), ValidUntil(0),
 282    SupportsAcquireByHash(false)
 283 {
 284 }
 285 indexRecords::indexRecords(const string ExpectedDist) :
 286    Trusted(CHECK_TRUST), d(NULL), ExpectedDist(ExpectedDist), ValidUntil(0),
 287    SupportsAcquireByHash(false)
 288 {
 289 }
 290 #endif
 291
 292 indexRecords::~indexRecords() {}