apt-pkg/pkgcache.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: pkgcache.cc,v 1.3 1998/07/04 22:32:11 jgg Exp $
   4 /* ######################################################################
   5
   6    Package Cache - Accessor code for the cache
   7
   8    Please see doc/pkglib/cache.sgml for a more detailed description of
   9    this format. Also be sure to keep that file up-to-date!!
  10
  11    This is the general utility functions for cache managment. They provide
  12    a complete set of accessor functions for the cache. The cacheiterators
  13    header contains the STL-like iterators that can be used to easially
  14    navigate the cache as well as seemlessly dereference the mmap'd
  15    indexes. Use these always.
  16
  17    The main class provides for ways to get package indexes and some
  18    general lookup functions to start the iterators.
  19
  20    ##################################################################### */
  21                                                                         /*}}}*/
  22 // Include Files                                                        /*{{{*/
  23 #include <pkglib/pkgcache.h>
  24 #include <pkglib/version.h>
  25 #include <pkglib/error.h>
  26 #include <system.h>
  27
  28 #include <string>
  29 #include <sys/stat.h>
  30 #include <unistd.h>
  31                                                                         /*}}}*/
  32
  33 // Cache::Header::Header - Constructor                                  /*{{{*/
  34 // ---------------------------------------------------------------------
  35 /* Simply initialize the header */
  36 pkgCache::Header::Header()
  37 {
  38    Signature = 0x98FE76DC;
  39
  40    /* Whenever the structures change the major version should be bumped,
  41       whenever the generator changes the minor version should be bumped. */
  42    MajorVersion = 2;
  43    MinorVersion = 0;
  44    Dirty = true;
  45
  46    HeaderSz = sizeof(pkgCache::Header);
  47    PackageSz = sizeof(pkgCache::Package);
  48    PackageFileSz = sizeof(pkgCache::PackageFile);
  49    VersionSz = sizeof(pkgCache::Version);
  50    DependencySz = sizeof(pkgCache::Dependency);
  51    ProvidesSz = sizeof(pkgCache::Provides);
  52
  53    PackageCount = 0;
  54    VersionCount = 0;
  55    DependsCount = 0;
  56    PackageFileCount = 0;
  57
  58    FileList = 0;
  59    StringList = 0;
  60    memset(HashTable,0,sizeof(HashTable));
  61    memset(Pools,0,sizeof(Pools));
  62 }
  63                                                                         /*}}}*/
  64 // Cache::Header::CheckSizes - Check if the two headers have same *sz   /*{{{*/
  65 // ---------------------------------------------------------------------
  66 /* */
  67 bool pkgCache::Header::CheckSizes(Header &Against) const
  68 {
  69    if (HeaderSz == Against.HeaderSz &&
  70        PackageSz == Against.PackageSz &&
  71        PackageFileSz == Against.PackageFileSz &&
  72        VersionSz == Against.VersionSz &&
  73        DependencySz == Against.DependencySz &&
  74        ProvidesSz == Against.ProvidesSz)
  75       return true;
  76    return false;
  77 }
  78                                                                         /*}}}*/
  79
  80 // Cache::pkgCache - Constructor                                        /*{{{*/
  81 // ---------------------------------------------------------------------
  82 /* */
  83 pkgCache::pkgCache(MMap &Map) : Map(Map)
  84 {
  85    ReMap();
  86 }
  87                                                                         /*}}}*/
  88 // Cache::ReMap - Reopen the cache file                                 /*{{{*/
  89 // ---------------------------------------------------------------------
  90 /* If the file is already closed then this will open it open it. */
  91 bool pkgCache::ReMap()
  92 {
  93    // Apply the typecasts.
  94    HeaderP = (Header *)Map.Data();
  95    PkgP = (Package *)Map.Data();
  96    PkgFileP = (PackageFile *)Map.Data();
  97    VerP = (Version *)Map.Data();
  98    ProvideP = (Provides *)Map.Data();
  99    DepP = (Dependency *)Map.Data();
 100    StringItemP = (StringItem *)Map.Data();
 101    StrP = (char *)Map.Data();
 102
 103    cout << "Size is " << Map.Size() << endl;
 104    if (Map.Size() == 0)
 105       return false;
 106
 107    // Check the header
 108    Header DefHeader;
 109    if (HeaderP->Signature != DefHeader.Signature ||
 110        HeaderP->Dirty == true)
 111       return _error->Error("The package cache file is corrupted");
 112
 113    if (HeaderP->MajorVersion != DefHeader.MajorVersion ||
 114        HeaderP->MinorVersion != DefHeader.MinorVersion ||
 115        HeaderP->CheckSizes(DefHeader) == false)
 116       return _error->Error("The package cache file is an incompatible version");
 117
 118    return true;
 119 }
 120                                                                         /*}}}*/
 121 // Cache::Hash - Hash a string                                          /*{{{*/
 122 // ---------------------------------------------------------------------
 123 /* This is used to generate the hash entries for the HashTable. With my
 124    package list from bo this function gets 94% table usage on a 512 item
 125    table (480 used items) */
 126 unsigned long pkgCache::sHash(string Str)
 127 {
 128    unsigned long Hash = 0;
 129    for (const char *I = Str.begin(); I != Str.end(); I++)
 130       Hash += *I * ((Str.end() - I + 1));
 131    Header H;
 132    return Hash % _count(H.HashTable);
 133 }
 134
 135 unsigned long pkgCache::sHash(const char *Str)
 136 {
 137    unsigned long Hash = 0;
 138    const char *End = Str + strlen(Str);
 139    for (const char *I = Str; I != End; I++)
 140       Hash += *I * ((End - I + 1));
 141    Header H;
 142    return Hash % _count(H.HashTable);
 143 }
 144
 145                                                                         /*}}}*/
 146 // Cache::FindPkg - Locate a package by name                            /*{{{*/
 147 // ---------------------------------------------------------------------
 148 /* Returns 0 on error, pointer to the package otherwise */
 149 pkgCache::PkgIterator pkgCache::FindPkg(string Name)
 150 {
 151    // Look at the hash bucket
 152    Package *Pkg = PkgP + HeaderP->HashTable[Hash(Name)];
 153    for (; Pkg != PkgP; Pkg = PkgP + Pkg->NextPackage)
 154    {
 155       if (Pkg->Name != 0 && StrP + Pkg->Name == Name)
 156          return PkgIterator(*this,Pkg);
 157    }
 158    return PkgIterator(*this,0);
 159 }
 160                                                                         /*}}}*/
 161 // Cache::Priority - Convert a priority value to a string               /*{{{*/
 162 // ---------------------------------------------------------------------
 163 /* */
 164 const char *pkgCache::Priority(unsigned char Prio)
 165 {
 166    const char *Mapping[] = {0,"important","required","standard","optional","extra"};
 167    if (Prio < _count(Mapping))
 168       return Mapping[Prio];
 169    return 0;
 170 }
 171                                                                         /*}}}*/
 172
 173 // Bases for iterator classes                                           /*{{{*/
 174 void pkgCache::VerIterator::_dummy() {}
 175 void pkgCache::DepIterator::_dummy() {}
 176 void pkgCache::PrvIterator::_dummy() {}
 177                                                                         /*}}}*/
 178 // PkgIterator::operator ++ - Postfix incr                              /*{{{*/
 179 // ---------------------------------------------------------------------
 180 /* This will advance to the next logical package in the hash table. */
 181 void pkgCache::PkgIterator::operator ++(int)
 182 {
 183    // Follow the current links
 184    if (Pkg != Owner->PkgP)
 185       Pkg = Owner->PkgP + Pkg->NextPackage;
 186
 187    // Follow the hash table
 188    while (Pkg == Owner->PkgP && HashIndex < (signed)_count(Owner->HeaderP->HashTable))
 189    {
 190       HashIndex++;
 191       Pkg = Owner->PkgP + Owner->HeaderP->HashTable[HashIndex];
 192    }
 193 };
 194                                                                         /*}}}*/
 195 // PkgIterator::State - Check the State of the package                  /*{{{*/
 196 // ---------------------------------------------------------------------
 197 /* By this we mean if it is either cleanly installed or cleanly removed. */
 198 pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const
 199 {
 200    if (Pkg->CurrentState == UnPacked ||
 201        Pkg->CurrentState == HalfConfigured)
 202       return NeedsConfigure;
 203
 204    if (Pkg->CurrentState == UnInstalled ||
 205        Pkg->CurrentState == HalfInstalled ||
 206        Pkg->InstState != Ok)
 207       return NeedsUnpack;
 208
 209    return NeedsNothing;
 210 }
 211                                                                         /*}}}*/
 212 // DepIterator::IsCritical - Returns true if the dep is important       /*{{{*/
 213 // ---------------------------------------------------------------------
 214 /* Currently critical deps are defined as depends, predepends and
 215    conflicts. */
 216 bool pkgCache::DepIterator::IsCritical()
 217 {
 218    if (Dep->Type == Conflicts || Dep->Type == Depends ||
 219        Dep->Type == PreDepends)
 220       return true;
 221    return false;
 222 }
 223                                                                         /*}}}*/
 224 // DepIterator::SmartTargetPkg - Resolve dep target pointers w/provides /*{{{*/
 225 // ---------------------------------------------------------------------
 226 /* This intellegently looks at dep target packages and tries to figure
 227    out which package should be used. This is needed to nicely handle
 228    provide mapping. If the target package has no other providing packages
 229    then it returned. Otherwise the providing list is looked at to
 230    see if there is one one unique providing package if so it is returned.
 231    Otherwise true is returned and the target package is set. The return
 232    result indicates whether the node should be expandable */
 233 bool pkgCache::DepIterator::SmartTargetPkg(PkgIterator &Result)
 234 {
 235    Result = TargetPkg();
 236
 237    // No provides at all
 238    if (Result->ProvidesList == 0)
 239       return false;
 240
 241    // There is the Base package and the providing ones which is at least 2
 242    if (Result->VersionList != 0)
 243       return true;
 244
 245    /* We have to skip over indirect provisions of the package that
 246       owns the dependency. For instance, if libc5-dev depends on the
 247       virtual package libc-dev which is provided by libc5-dev and libc6-dev
 248       we must ignore libc5-dev when considering the provides list. */
 249    PrvIterator PStart = Result.ProvidesList();
 250    for (; PStart.end() != true && PStart.OwnerPkg() == ParentPkg(); PStart++);
 251
 252    // Nothing but indirect self provides
 253    if (PStart.end() == true)
 254       return false;
 255
 256    // Check for single packages in the provides list
 257    PrvIterator P = PStart;
 258    for (; P.end() != true; P++)
 259    {
 260       // Skip over self provides
 261       if (P.OwnerPkg() == ParentPkg())
 262          continue;
 263       if (PStart.OwnerPkg() != P.OwnerPkg())
 264          break;
 265    }
 266
 267    // Check for non dups
 268    if (P.end() != true)
 269       return true;
 270    Result = PStart.OwnerPkg();
 271    return false;
 272 }
 273                                                                         /*}}}*/
 274 // DepIterator::AllTargets - Returns the set of all possible targets    /*{{{*/
 275 // ---------------------------------------------------------------------
 276 /* This is a more usefull version of TargetPkg() that follows versioned
 277    provides. It includes every possible package-version that could satisfy
 278    the dependency. The last item in the list has a 0. */
 279 pkgCache::Version **pkgCache::DepIterator::AllTargets()
 280 {
 281    Version **Res = 0;
 282    unsigned long Size =0;
 283    while (1)
 284    {
 285       Version **End = Res;
 286       PkgIterator DPkg = TargetPkg();
 287
 288       // Walk along the actual package providing versions
 289       for (VerIterator I = DPkg.VersionList(); I.end() == false; I++)
 290       {
 291          if (pkgCheckDep(TargetVer(),I.VerStr(),Dep->CompareOp) == false)
 292             continue;
 293
 294          if (Dep->Type == Conflicts && ParentPkg() == I.ParentPkg())
 295             continue;
 296
 297          Size++;
 298          if (Res != 0)
 299             *End++ = I;
 300       }
 301
 302       // Follow all provides
 303       for (PrvIterator I = DPkg.ProvidesList(); I.end() == false; I++)
 304       {
 305          if (pkgCheckDep(TargetVer(),I.ProvideVersion(),Dep->CompareOp) == false)
 306             continue;
 307
 308          if (Dep->Type == Conflicts && ParentPkg() == I.OwnerPkg())
 309             continue;
 310
 311          Size++;
 312          if (Res != 0)
 313             *End++ = I.OwnerVer();
 314       }
 315
 316       // Do it again and write it into the array
 317       if (Res == 0)
 318       {
 319          Res = new Version *[Size+1];
 320          Size = 0;
 321       }
 322       else
 323       {
 324          *End = 0;
 325          break;
 326       }
 327    }
 328
 329    return Res;
 330 }
 331                                                                         /*}}}*/
 332 // VerIterator::CompareVer - Fast version compare for same pkgs         /*{{{*/
 333 // ---------------------------------------------------------------------
 334 /* This just looks over the version list to see if B is listed before A. In
 335    most cases this will return in under 4 checks, ver lists are short. */
 336 int pkgCache::VerIterator::CompareVer(const VerIterator &B) const
 337 {
 338    // Check if they are equal
 339    if (*this == B)
 340       return 0;
 341    if (end() == true)
 342       return -1;
 343    if (B.end() == true)
 344       return 1;
 345
 346    /* Start at A and look for B. If B is found then A > B otherwise
 347       B was before A so A < B */
 348    VerIterator I = *this;
 349    for (;I.end() == false; I++)
 350       if (I == B)
 351          return 1;
 352    return -1;
 353 }
 354                                                                         /*}}}*/
 355 // PkgFileIterator::IsOk - Checks if the cache is in sync with the file /*{{{*/
 356 // ---------------------------------------------------------------------
 357 /* This stats the file and compares its stats with the ones that were
 358    stored during generation. Date checks should probably also be
 359    included here. */
 360 bool pkgCache::PkgFileIterator::IsOk()
 361 {
 362    struct stat Buf;
 363    if (stat(FileName(),&Buf) != 0)
 364       return false;
 365
 366    if (Buf.st_size != (signed)File->Size || Buf.st_mtime != File->mtime)
 367       return false;
 368
 369    return true;
 370 }
 371                                                                         /*}}}*/