apt-pkg/pkgcachegen.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: pkgcachegen.cc,v 1.2 1998/07/04 05:57:37 jgg Exp $
   4 /* ######################################################################
   5
   6    Package Cache Generator - Generator for the cache structure.
   7
   8    This builds the cache structure from the abstract package list parser.
   9
  10    ##################################################################### */
  11                                                                         /*}}}*/
  12 // Include Files                                                        /*{{{*/
  13 #include <pkglib/pkgcachegen.h>
  14 #include <pkglib/error.h>
  15 #include <pkglib/version.h>
  16
  17 #include <sys/stat.h>
  18 #include <unistd.h>
  19                                                                         /*}}}*/
  20
  21 // CacheGenerator::pkgCacheGenerator - Constructor                      /*{{{*/
  22 // ---------------------------------------------------------------------
  23 /* We set the diry flag and make sure that is written to the disk */
  24 pkgCacheGenerator::pkgCacheGenerator(DynamicMMap &Map) : Map(Map), Cache(Map)
  25 {
  26    if (_error->PendingError() == true)
  27       return;
  28
  29    if (Map.Size() == 0)
  30    {
  31       Map.RawAllocate(sizeof(pkgCache::Header));
  32       *Cache.HeaderP = pkgCache::Header();
  33    }
  34    Cache.HeaderP->Dirty = true;
  35    Map.Sync(0,sizeof(pkgCache::Header));
  36    Map.UsePools(*Cache.HeaderP->Pools,sizeof(Cache.HeaderP->Pools)/sizeof(Cache.HeaderP->Pools[0]));
  37 }
  38                                                                         /*}}}*/
  39 // CacheGenerator::~pkgCacheGenerator - Destructor                      /*{{{*/
  40 // ---------------------------------------------------------------------
  41 /* We sync the data then unset the dirty flag in two steps so as to
  42    advoid a problem during a crash */
  43 pkgCacheGenerator::~pkgCacheGenerator()
  44 {
  45    if (_error->PendingError() == true)
  46       return;
  47    if (Map.Sync() == false)
  48       return;
  49
  50    Cache.HeaderP->Dirty = false;
  51    Map.Sync(0,sizeof(pkgCache::Header));
  52 }
  53                                                                         /*}}}*/
  54 // CacheGenerator::MergeList - Merge the package list                   /*{{{*/
  55 // ---------------------------------------------------------------------
  56 /* This provides the generation of the entries in the cache. Each loop
  57    goes through a single package record from the underlying parse engine. */
  58 bool pkgCacheGenerator::MergeList(ListParser &List)
  59 {
  60    List.Owner = this;
  61    do
  62    {
  63       // Get a pointer to the package structure
  64       string Package = List.Package();
  65       pkgCache::PkgIterator Pkg = Cache.FindPkg(Package);
  66       if (Pkg.end() == true)
  67       {
  68          if (NewPackage(Pkg,Package) == false)
  69             return false;
  70
  71          if (List.NewPackage(Pkg) == false)
  72             return false;
  73       }
  74
  75       /* Get a pointer to the version structure. We know the list is sorted
  76          so we use that fact in the search. Insertion of new versions is
  77          done with correct sorting */
  78       string Version = List.Version();
  79       if (Version.empty() == true)
  80       {
  81          if (List.UsePackage(Pkg,pkgCache::VerIterator(Cache)) == false)
  82             return false;
  83          continue;
  84       }
  85
  86       pkgCache::VerIterator Ver = Pkg.VersionList();
  87       unsigned long *Last = &Pkg->VersionList;
  88       int Res;
  89       for (; Ver.end() == false; Last = &Ver->NextVer, Ver++)
  90       {
  91          Res = pkgVersionCompare(Version.begin(),Version.end(),Ver.VerStr(),
  92                                  Ver.VerStr() + strlen(Ver.VerStr()));
  93          if (Res >= 0)
  94             break;
  95       }
  96
  97       /* We already have a version for this item, record that we
  98          saw it */
  99       if (Res == 0)
 100       {
 101          if (List.UsePackage(Pkg,Ver) == false)
 102             return false;
 103
 104          if (NewFileVer(Ver,List) == false)
 105             return false;
 106
 107          continue;
 108       }
 109
 110       // Add a new version
 111       *Last = NewVersion(Ver,Version,*Last);
 112       Ver->ParentPkg = Pkg.Index();
 113       if (List.NewVersion(Ver) == false)
 114          return false;
 115
 116       if (List.UsePackage(Pkg,Ver) == false)
 117          return false;
 118
 119       if (NewFileVer(Ver,List) == false)
 120          return false;
 121    }
 122    while (List.Step() == true);
 123
 124    return true;
 125 }
 126                                                                         /*}}}*/
 127 // CacheGenerator::NewPackage - Add a new package                       /*{{{*/
 128 // ---------------------------------------------------------------------
 129 /* This creates a new package structure and adds it to the hash table */
 130 bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,string Name)
 131 {
 132    // Get a structure
 133    unsigned long Package = Map.Allocate(sizeof(pkgCache::Package));
 134    if (Package == 0)
 135       return false;
 136
 137    Pkg = pkgCache::PkgIterator(Cache,Cache.PkgP + Package);
 138
 139    // Insert it into the hash table
 140    unsigned long Hash = Cache.Hash(Name);
 141    Pkg->NextPackage = Cache.HeaderP->HashTable[Hash];
 142    Cache.HeaderP->HashTable[Hash] = Package;
 143
 144    // Set the name and the ID
 145    Pkg->Name = Map.WriteString(Name);
 146    if (Pkg->Name == 0)
 147       return false;
 148    Pkg->ID = Cache.HeaderP->PackageCount++;
 149
 150    return true;
 151 }
 152                                                                         /*}}}*/
 153 // CacheGenerator::NewFileVer - Create a new File<->Version association /*{{{*/
 154 // ---------------------------------------------------------------------
 155 /* */
 156 bool pkgCacheGenerator::NewFileVer(pkgCache::VerIterator &Ver,
 157                                    ListParser &List)
 158 {
 159    return true;
 160 }
 161                                                                         /*}}}*/
 162 // CacheGenerator::NewVersion - Create a new Version                    /*{{{*/
 163 // ---------------------------------------------------------------------
 164 /* This puts a version structure in the linked list */
 165 unsigned long pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
 166                                             string VerStr,
 167                                             unsigned long Next)
 168 {
 169    // Get a structure
 170    unsigned long Version = Map.Allocate(sizeof(pkgCache::Version));
 171    if (Version == 0)
 172       return false;
 173
 174    // Fill it in
 175    Ver = pkgCache::VerIterator(Cache,Cache.VerP + Version);
 176    Ver->File = CurrentFile - Cache.PkgFileP;
 177    Ver->NextVer = Next;
 178    Ver->ID = Cache.HeaderP->VersionCount++;
 179    Ver->VerStr = Map.WriteString(VerStr);
 180    if (Ver->VerStr == 0)
 181       return false;
 182
 183    return true;
 184 }
 185                                                                         /*}}}*/
 186 // CacheGenerator::SelectFile - Select the current file being parsed    /*{{{*/
 187 // ---------------------------------------------------------------------
 188 /* This is used to select which file is to be associated with all newly
 189    added versions. */
 190 bool pkgCacheGenerator::SelectFile(string File,unsigned long Flags)
 191 {
 192    struct stat Buf;
 193    if (stat(File.c_str(),&Buf) == -1)
 194       return _error->Errno("stat","Couldn't stat ",File.c_str());
 195
 196    // Get some space for the structure
 197    CurrentFile = Cache.PkgFileP + Map.Allocate(sizeof(*CurrentFile));
 198    if (CurrentFile == Cache.PkgFileP)
 199       return false;
 200
 201    // Fill it in
 202    CurrentFile->FileName = Map.WriteString(File);
 203    CurrentFile->Size = Buf.st_size;
 204    CurrentFile->mtime = Buf.st_mtime;
 205    CurrentFile->NextFile = Cache.HeaderP->FileList;
 206    CurrentFile->Flags = Flags;
 207    PkgFileName = File;
 208
 209    if (CurrentFile->FileName == 0)
 210       return false;
 211 }
 212                                                                         /*}}}*/
 213 // CacheGenerator::WriteUniqueString - Insert a unique string           /*{{{*/
 214 // ---------------------------------------------------------------------
 215 /* This is used to create handles to strings. Given the same text it
 216    always returns the same number */
 217 unsigned long pkgCacheGenerator::WriteUniqString(const char *S,
 218                                                  unsigned int Size)
 219 {
 220    // Search for an insertion point
 221    pkgCache::StringItem *I = Cache.StringItemP + Cache.HeaderP->StringList;
 222    int Res = 1;
 223    unsigned long *Last = &Cache.HeaderP->StringList;
 224    for (; I != Cache.StringItemP; Last = &I->NextItem,
 225         I = Cache.StringItemP + I->NextItem)
 226    {
 227       Res = strncmp(Cache.StrP + I->String,S,Size);
 228       if (Res == 0 && *(Cache.StrP + I->String + Size) != 0)
 229          Res = 1;
 230       if (Res >= 0)
 231          break;
 232    }
 233
 234    // Match
 235    if (Res == 0)
 236       return I - Cache.StringItemP;
 237
 238    // Get a structure
 239    unsigned long Item = Map.Allocate(sizeof(pkgCache::StringItem));
 240    if (Item == 0)
 241       return false;
 242
 243    // Fill in the structure
 244    pkgCache::StringItem *ItemP = Cache.StringItemP + Item;
 245    ItemP->NextItem = I - Cache.StringItemP;
 246    *Last = Item;
 247    ItemP->String = Map.WriteString(S,Size);
 248    if (ItemP->String == 0)
 249       return false;
 250
 251    return true;
 252 }
 253                                                                         /*}}}*/