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(string const &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 time_t indexRecords::GetDate() const
  62 {
  63    return this->Date;
  64 }
  65
  66 APT_PURE indexRecords::checkSum *indexRecords::Lookup(string const &MetaKey)
  67 {
  68    std::map<std::string, indexRecords::checkSum* >::const_iterator sum = Entries.find(MetaKey);
  69    if (sum == Entries.end())
  70       return NULL;
  71    return sum->second;
  72 }
  73
  74 APT_PURE bool indexRecords::Exists(string const &MetaKey) const
  75 {
  76    return Entries.find(MetaKey) != Entries.end();
  77 }
  78
  79 bool indexRecords::Load(string const &Filename)                         /*{{{*/
  80 {
  81    FileFd Fd;
  82    if (OpenMaybeClearSignedFile(Filename, Fd) == false)
  83       return false;
  84
  85    pkgTagFile TagFile(&Fd, Fd.Size());
  86    if (_error->PendingError() == true)
  87    {
  88       strprintf(ErrorText, _("Unable to parse Release file %s"),Filename.c_str());
  89       return false;
  90    }
  91
  92    pkgTagSection Section;
  93    const char *Start, *End;
  94    if (TagFile.Step(Section) == false)
  95    {
  96       strprintf(ErrorText, _("No sections in Release file %s"), Filename.c_str());
  97       return false;
  98    }
  99    // FIXME: find better tag name
 100    SupportsAcquireByHash = Section.FindB("Acquire-By-Hash", false);
 101
 102    Suite = Section.FindS("Suite");
 103    Dist = Section.FindS("Codename");
 104
 105    bool FoundHashSum = false;
 106    for (int i=0;HashString::SupportedHashes()[i] != NULL; i++)
 107    {
 108       if (!Section.Find(HashString::SupportedHashes()[i], Start, End))
 109          continue;
 110
 111       string Name;
 112       string Hash;
 113       unsigned long long Size;
 114       while (Start < End)
 115       {
 116          if (!parseSumData(Start, End, Name, Hash, Size))
 117             return false;
 118
 119          if (Entries.find(Name) == Entries.end())
 120          {
 121             indexRecords::checkSum *Sum = new indexRecords::checkSum;
 122             Sum->MetaKeyFilename = Name;
 123             Sum->Size = Size;
 124             Sum->Hashes.FileSize(Size);
 125             APT_IGNORE_DEPRECATED(Sum->Hash = HashString(HashString::SupportedHashes()[i],Hash);)
 126             Entries[Name] = Sum;
 127          }
 128          Entries[Name]->Hashes.push_back(HashString(HashString::SupportedHashes()[i],Hash));
 129          FoundHashSum = true;
 130       }
 131    }
 132
 133    if(FoundHashSum == false)
 134    {
 135       strprintf(ErrorText, _("No Hash entry in Release file %s"), Filename.c_str());
 136       return false;
 137    }
 138
 139    string const StrDate = Section.FindS("Date");
 140    if (RFC1123StrToTime(StrDate.c_str(), Date) == false)
 141    {
 142       strprintf(ErrorText, _("Invalid 'Date' entry in Release file %s"), Filename.c_str());
 143       return false;
 144    }
 145
 146    string const Label = Section.FindS("Label");
 147    string const StrValidUntil = Section.FindS("Valid-Until");
 148
 149    // if we have a Valid-Until header in the Release file, use it as default
 150    if (StrValidUntil.empty() == false)
 151    {
 152       if(RFC1123StrToTime(StrValidUntil.c_str(), ValidUntil) == false)
 153       {
 154          strprintf(ErrorText, _("Invalid 'Valid-Until' entry in Release file %s"), Filename.c_str());
 155          return false;
 156       }
 157    }
 158    // get the user settings for this archive and use what expires earlier
 159    int MaxAge = _config->FindI("Acquire::Max-ValidTime", 0);
 160    if (Label.empty() == false)
 161       MaxAge = _config->FindI(("Acquire::Max-ValidTime::" + Label).c_str(), MaxAge);
 162    int MinAge = _config->FindI("Acquire::Min-ValidTime", 0);
 163    if (Label.empty() == false)
 164       MinAge = _config->FindI(("Acquire::Min-ValidTime::" + Label).c_str(), MinAge);
 165
 166    if(MaxAge == 0 &&
 167       (MinAge == 0 || ValidUntil == 0)) // No user settings, use the one from the Release file
 168       return true;
 169
 170    if (MinAge != 0 && ValidUntil != 0) {
 171       time_t const min_date = Date + MinAge;
 172       if (ValidUntil < min_date)
 173          ValidUntil = min_date;
 174    }
 175    if (MaxAge != 0) {
 176       time_t const max_date = Date + MaxAge;
 177       if (ValidUntil == 0 || ValidUntil > max_date)
 178          ValidUntil = max_date;
 179    }
 180
 181    return true;
 182 }
 183                                                                         /*}}}*/
 184 std::vector<string> indexRecords::MetaKeys()                            /*{{{*/
 185 {
 186    std::vector<std::string> keys;
 187    std::map<string,checkSum *>::iterator I = Entries.begin();
 188    while(I != Entries.end()) {
 189       keys.push_back((*I).first);
 190       ++I;
 191    }
 192    return keys;
 193 }
 194                                                                         /*}}}*/
 195 bool indexRecords::parseSumData(const char *&Start, const char *End,    /*{{{*/
 196                                    string &Name, string &Hash, unsigned long long &Size)
 197 {
 198    Name = "";
 199    Hash = "";
 200    Size = 0;
 201    /* Skip over the first blank */
 202    while ((*Start == '\t' || *Start == ' ' || *Start == '\n' || *Start == '\r')
 203           && Start < End)
 204       Start++;
 205    if (Start >= End)
 206       return false;
 207
 208    /* Move EntryEnd to the end of the first entry (the hash) */
 209    const char *EntryEnd = Start;
 210    while ((*EntryEnd != '\t' && *EntryEnd != ' ')
 211           && EntryEnd < End)
 212       EntryEnd++;
 213    if (EntryEnd == End)
 214       return false;
 215
 216    Hash.append(Start, EntryEnd-Start);
 217
 218    /* Skip over intermediate blanks */
 219    Start = EntryEnd;
 220    while (*Start == '\t' || *Start == ' ')
 221       Start++;
 222    if (Start >= End)
 223       return false;
 224
 225    EntryEnd = Start;
 226    /* Find the end of the second entry (the size) */
 227    while ((*EntryEnd != '\t' && *EntryEnd != ' ' )
 228           && EntryEnd < End)
 229       EntryEnd++;
 230    if (EntryEnd == End)
 231       return false;
 232
 233    Size = strtoull (Start, NULL, 10);
 234
 235    /* Skip over intermediate blanks */
 236    Start = EntryEnd;
 237    while (*Start == '\t' || *Start == ' ')
 238       Start++;
 239    if (Start >= End)
 240       return false;
 241
 242    EntryEnd = Start;
 243    /* Find the end of the third entry (the filename) */
 244    while ((*EntryEnd != '\t' && *EntryEnd != ' ' &&
 245            *EntryEnd != '\n' && *EntryEnd != '\r')
 246           && EntryEnd < End)
 247       EntryEnd++;
 248
 249    Name.append(Start, EntryEnd-Start);
 250    Start = EntryEnd; //prepare for the next round
 251    return true;
 252 }
 253                                                                         /*}}}*/
 254
 255 APT_PURE bool indexRecords::IsAlwaysTrusted() const
 256 {
 257    if (Trusted == ALWAYS_TRUSTED)
 258       return true;
 259    return false;
 260 }
 261 APT_PURE bool indexRecords::IsNeverTrusted() const
 262 {
 263    if (Trusted == NEVER_TRUSTED)
 264       return true;
 265    return false;
 266 }
 267 void indexRecords::SetTrusted(bool const Trusted)
 268 {
 269    if (Trusted == true)
 270       this->Trusted = ALWAYS_TRUSTED;
 271    else
 272       this->Trusted = NEVER_TRUSTED;
 273 }
 274
 275 indexRecords::indexRecords(const string &ExpectedDist) :
 276    Trusted(CHECK_TRUST), d(NULL), ExpectedDist(ExpectedDist), ValidUntil(0),
 277    SupportsAcquireByHash(false)
 278 {
 279 }
 280
 281 indexRecords::~indexRecords() {}