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 <sys/stat.h>
  18 #include <clocale>
  19
  20 #include <apti18n.h>
  21                                                                         /*}}}*/
  22
  23 using std::string;
  24
  25 string indexRecords::GetDist() const
  26 {
  27    return this->Dist;
  28 }
  29
  30 string indexRecords::GetSuite() const
  31 {
  32    return this->Suite;
  33 }
  34
  35 bool indexRecords::CheckDist(const string MaybeDist) const
  36 {
  37    return (this->Dist == MaybeDist
  38            || this->Suite == MaybeDist);
  39 }
  40
  41 string indexRecords::GetExpectedDist() const
  42 {
  43    return this->ExpectedDist;
  44 }
  45
  46 time_t indexRecords::GetValidUntil() const
  47 {
  48    return this->ValidUntil;
  49 }
  50
  51 const indexRecords::checkSum *indexRecords::Lookup(const string MetaKey)
  52 {
  53    std::map<std::string, indexRecords::checkSum* >::const_iterator sum = Entries.find(MetaKey);
  54    if (sum == Entries.end())
  55       return NULL;
  56    return sum->second;
  57 }
  58
  59 bool indexRecords::Exists(string const &MetaKey) const
  60 {
  61    return Entries.count(MetaKey) == 1;
  62 }
  63
  64 bool indexRecords::Load(const string Filename)                          /*{{{*/
  65 {
  66    FileFd Fd;
  67    if (OpenMaybeClearSignedFile(Filename, Fd) == false)
  68       return false;
  69
  70    pkgTagFile TagFile(&Fd, Fd.Size());
  71    if (_error->PendingError() == true)
  72    {
  73       strprintf(ErrorText, _("Unable to parse Release file %s"),Filename.c_str());
  74       return false;
  75    }
  76
  77    pkgTagSection Section;
  78    const char *Start, *End;
  79    if (TagFile.Step(Section) == false)
  80    {
  81       strprintf(ErrorText, _("No sections in Release file %s"), Filename.c_str());
  82       return false;
  83    }
  84
  85    Suite = Section.FindS("Suite");
  86    Dist = Section.FindS("Codename");
  87
  88    int i;
  89    for (i=0;HashString::SupportedHashes()[i] != NULL; i++)
  90    {
  91       if (!Section.Find(HashString::SupportedHashes()[i], Start, End))
  92          continue;
  93
  94       string Name;
  95       string Hash;
  96       unsigned long long Size;
  97       while (Start < End)
  98       {
  99          if (!parseSumData(Start, End, Name, Hash, Size))
 100             return false;
 101          indexRecords::checkSum *Sum = new indexRecords::checkSum;
 102          Sum->MetaKeyFilename = Name;
 103          Sum->Hash = HashString(HashString::SupportedHashes()[i],Hash);
 104          Sum->Size = Size;
 105          Entries[Name] = Sum;
 106       }
 107       break;
 108    }
 109
 110    if(HashString::SupportedHashes()[i] == NULL)
 111    {
 112       strprintf(ErrorText, _("No Hash entry in Release file %s"), Filename.c_str());
 113       return false;
 114    }
 115
 116    string Label = Section.FindS("Label");
 117    string StrDate = Section.FindS("Date");
 118    string StrValidUntil = Section.FindS("Valid-Until");
 119
 120    // if we have a Valid-Until header in the Release file, use it as default
 121    if (StrValidUntil.empty() == false)
 122    {
 123       if(RFC1123StrToTime(StrValidUntil.c_str(), ValidUntil) == false)
 124       {
 125          strprintf(ErrorText, _("Invalid 'Valid-Until' entry in Release file %s"), Filename.c_str());
 126          return false;
 127       }
 128    }
 129    // get the user settings for this archive and use what expires earlier
 130    int MaxAge = _config->FindI("Acquire::Max-ValidTime", 0);
 131    if (Label.empty() == false)
 132       MaxAge = _config->FindI(string("Acquire::Max-ValidTime::" + Label).c_str(), MaxAge);
 133    int MinAge = _config->FindI("Acquire::Min-ValidTime", 0);
 134    if (Label.empty() == false)
 135       MinAge = _config->FindI(string("Acquire::Min-ValidTime::" + Label).c_str(), MinAge);
 136
 137    if(MaxAge == 0 &&
 138       (MinAge == 0 || ValidUntil == 0)) // No user settings, use the one from the Release file
 139       return true;
 140
 141    time_t date;
 142    if (RFC1123StrToTime(StrDate.c_str(), date) == false)
 143    {
 144       strprintf(ErrorText, _("Invalid 'Date' entry in Release file %s"), Filename.c_str());
 145       return false;
 146    }
 147
 148    if (MinAge != 0 && ValidUntil != 0) {
 149       time_t const min_date = date + MinAge;
 150       if (ValidUntil < min_date)
 151          ValidUntil = min_date;
 152    }
 153    if (MaxAge != 0) {
 154       time_t const max_date = date + MaxAge;
 155       if (ValidUntil == 0 || ValidUntil > max_date)
 156          ValidUntil = max_date;
 157    }
 158
 159    return true;
 160 }
 161                                                                         /*}}}*/
 162 std::vector<string> indexRecords::MetaKeys()                            /*{{{*/
 163 {
 164    std::vector<std::string> keys;
 165    std::map<string,checkSum *>::iterator I = Entries.begin();
 166    while(I != Entries.end()) {
 167       keys.push_back((*I).first);
 168       ++I;
 169    }
 170    return keys;
 171 }
 172                                                                         /*}}}*/
 173 bool indexRecords::parseSumData(const char *&Start, const char *End,    /*{{{*/
 174                                    string &Name, string &Hash, unsigned long long &Size)
 175 {
 176    Name = "";
 177    Hash = "";
 178    Size = 0;
 179    /* Skip over the first blank */
 180    while ((*Start == '\t' || *Start == ' ' || *Start == '\n' || *Start == '\r')
 181           && Start < End)
 182       Start++;
 183    if (Start >= End)
 184       return false;
 185
 186    /* Move EntryEnd to the end of the first entry (the hash) */
 187    const char *EntryEnd = Start;
 188    while ((*EntryEnd != '\t' && *EntryEnd != ' ')
 189           && EntryEnd < End)
 190       EntryEnd++;
 191    if (EntryEnd == End)
 192       return false;
 193
 194    Hash.append(Start, EntryEnd-Start);
 195
 196    /* Skip over intermediate blanks */
 197    Start = EntryEnd;
 198    while (*Start == '\t' || *Start == ' ')
 199       Start++;
 200    if (Start >= End)
 201       return false;
 202
 203    EntryEnd = Start;
 204    /* Find the end of the second entry (the size) */
 205    while ((*EntryEnd != '\t' && *EntryEnd != ' ' )
 206           && EntryEnd < End)
 207       EntryEnd++;
 208    if (EntryEnd == End)
 209       return false;
 210
 211    Size = strtoull (Start, NULL, 10);
 212
 213    /* Skip over intermediate blanks */
 214    Start = EntryEnd;
 215    while (*Start == '\t' || *Start == ' ')
 216       Start++;
 217    if (Start >= End)
 218       return false;
 219
 220    EntryEnd = Start;
 221    /* Find the end of the third entry (the filename) */
 222    while ((*EntryEnd != '\t' && *EntryEnd != ' ' &&
 223            *EntryEnd != '\n' && *EntryEnd != '\r')
 224           && EntryEnd < End)
 225       EntryEnd++;
 226
 227    Name.append(Start, EntryEnd-Start);
 228    Start = EntryEnd; //prepare for the next round
 229    return true;
 230 }
 231                                                                         /*}}}*/
 232 indexRecords::indexRecords()
 233 {
 234 }
 235
 236 indexRecords::indexRecords(const string ExpectedDist) :
 237    ExpectedDist(ExpectedDist), ValidUntil(0)
 238 {
 239 }