apt-pkg/pkgcache.cc

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