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