apt-pkg/pkgcache.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: pkgcache.cc,v 1.13 1998/11/06 02:52:22 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->InstState == pkgCache::State::ReInstReq ||
 208        Pkg->InstState == pkgCache::State::HoldReInstReq)
 209       return NeedsUnpack;
 210
 211    if (Pkg->CurrentState == pkgCache::State::UnPacked ||
 212        Pkg->CurrentState == pkgCache::State::HalfConfigured)
 213       return NeedsConfigure;
 214
 215    if (Pkg->CurrentState == pkgCache::State::UnInstalled ||
 216        Pkg->CurrentState == pkgCache::State::HalfInstalled ||
 217        Pkg->InstState != pkgCache::State::Ok)
 218       return NeedsUnpack;
 219
 220    return NeedsNothing;
 221 }
 222                                                                         /*}}}*/
 223 // DepIterator::IsCritical - Returns true if the dep is important       /*{{{*/
 224 // ---------------------------------------------------------------------
 225 /* Currently critical deps are defined as depends, predepends and
 226    conflicts. */
 227 bool pkgCache::DepIterator::IsCritical()
 228 {
 229    if (Dep->Type == pkgCache::Dep::Conflicts ||
 230        Dep->Type == pkgCache::Dep::Depends ||
 231        Dep->Type == pkgCache::Dep::PreDepends)
 232       return true;
 233    return false;
 234 }
 235                                                                         /*}}}*/
 236 // DepIterator::SmartTargetPkg - Resolve dep target pointers w/provides /*{{{*/
 237 // ---------------------------------------------------------------------
 238 /* This intellegently looks at dep target packages and tries to figure
 239    out which package should be used. This is needed to nicely handle
 240    provide mapping. If the target package has no other providing packages
 241    then it returned. Otherwise the providing list is looked at to
 242    see if there is one one unique providing package if so it is returned.
 243    Otherwise true is returned and the target package is set. The return
 244    result indicates whether the node should be expandable */
 245 bool pkgCache::DepIterator::SmartTargetPkg(PkgIterator &Result)
 246 {
 247    Result = TargetPkg();
 248
 249    // No provides at all
 250    if (Result->ProvidesList == 0)
 251       return false;
 252
 253    // There is the Base package and the providing ones which is at least 2
 254    if (Result->VersionList != 0)
 255       return true;
 256
 257    /* We have to skip over indirect provisions of the package that
 258       owns the dependency. For instance, if libc5-dev depends on the
 259       virtual package libc-dev which is provided by libc5-dev and libc6-dev
 260       we must ignore libc5-dev when considering the provides list. */
 261    PrvIterator PStart = Result.ProvidesList();
 262    for (; PStart.end() != true && PStart.OwnerPkg() == ParentPkg(); PStart++);
 263
 264    // Nothing but indirect self provides
 265    if (PStart.end() == true)
 266       return false;
 267
 268    // Check for single packages in the provides list
 269    PrvIterator P = PStart;
 270    for (; P.end() != true; P++)
 271    {
 272       // Skip over self provides
 273       if (P.OwnerPkg() == ParentPkg())
 274          continue;
 275       if (PStart.OwnerPkg() != P.OwnerPkg())
 276          break;
 277    }
 278
 279    // Check for non dups
 280    if (P.end() != true)
 281       return true;
 282    Result = PStart.OwnerPkg();
 283    return false;
 284 }
 285                                                                         /*}}}*/
 286 // DepIterator::AllTargets - Returns the set of all possible targets    /*{{{*/
 287 // ---------------------------------------------------------------------
 288 /* This is a more usefull version of TargetPkg() that follows versioned
 289    provides. It includes every possible package-version that could satisfy
 290    the dependency. The last item in the list has a 0. */
 291 pkgCache::Version **pkgCache::DepIterator::AllTargets()
 292 {
 293    Version **Res = 0;
 294    unsigned long Size =0;
 295    while (1)
 296    {
 297       Version **End = Res;
 298       PkgIterator DPkg = TargetPkg();
 299
 300       // Walk along the actual package providing versions
 301       for (VerIterator I = DPkg.VersionList(); I.end() == false; I++)
 302       {
 303          if (pkgCheckDep(TargetVer(),I.VerStr(),Dep->CompareOp) == false)
 304             continue;
 305
 306          if (Dep->Type == pkgCache::Dep::Conflicts &&
 307              ParentPkg() == I.ParentPkg())
 308             continue;
 309
 310          Size++;
 311          if (Res != 0)
 312             *End++ = I;
 313       }
 314
 315       // Follow all provides
 316       for (PrvIterator I = DPkg.ProvidesList(); I.end() == false; I++)
 317       {
 318          if (pkgCheckDep(TargetVer(),I.ProvideVersion(),Dep->CompareOp) == false)
 319             continue;
 320
 321          if (Dep->Type == pkgCache::Dep::Conflicts &&
 322              ParentPkg() == I.OwnerPkg())
 323             continue;
 324
 325          Size++;
 326          if (Res != 0)
 327             *End++ = I.OwnerVer();
 328       }
 329
 330       // Do it again and write it into the array
 331       if (Res == 0)
 332       {
 333          Res = new Version *[Size+1];
 334          Size = 0;
 335       }
 336       else
 337       {
 338          *End = 0;
 339          break;
 340       }
 341    }
 342
 343    return Res;
 344 }
 345                                                                         /*}}}*/
 346 // DepIterator::CompType - Return a string describing the compare type  /*{{{*/
 347 // ---------------------------------------------------------------------
 348 /* This returns a string representation of the dependency compare
 349    type */
 350 const char *pkgCache::DepIterator::CompType()
 351 {
 352    const char *Ops[] = {"","<=",">=","<",">","=","!="};
 353    if ((unsigned)(Dep->CompareOp & 0xF) < sizeof(Ops))
 354       return Ops[Dep->CompareOp & 0xF];
 355    return "";
 356 }
 357                                                                         /*}}}*/
 358 // VerIterator::CompareVer - Fast version compare for same pkgs         /*{{{*/
 359 // ---------------------------------------------------------------------
 360 /* This just looks over the version list to see if B is listed before A. In
 361    most cases this will return in under 4 checks, ver lists are short. */
 362 int pkgCache::VerIterator::CompareVer(const VerIterator &B) const
 363 {
 364    // Check if they are equal
 365    if (*this == B)
 366       return 0;
 367    if (end() == true)
 368       return -1;
 369    if (B.end() == true)
 370       return 1;
 371
 372    /* Start at A and look for B. If B is found then A > B otherwise
 373       B was before A so A < B */
 374    VerIterator I = *this;
 375    for (;I.end() == false; I++)
 376       if (I == B)
 377          return 1;
 378    return -1;
 379 }
 380                                                                         /*}}}*/
 381 // VerIterator::Downloadable - Checks if the version is downloadable    /*{{{*/
 382 // ---------------------------------------------------------------------
 383 /* */
 384 bool pkgCache::VerIterator::Downloadable() const
 385 {
 386    VerFileIterator Files = FileList();
 387    for (; Files.end() == false; Files++)
 388       if ((Files.File()->Flags & pkgCache::Flag::NotSource) != pkgCache::Flag::NotSource)
 389          return true;
 390    return false;
 391 }
 392                                                                         /*}}}*/
 393 // PkgFileIterator::IsOk - Checks if the cache is in sync with the file /*{{{*/
 394 // ---------------------------------------------------------------------
 395 /* This stats the file and compares its stats with the ones that were
 396    stored during generation. Date checks should probably also be
 397    included here. */
 398 bool pkgCache::PkgFileIterator::IsOk()
 399 {
 400    struct stat Buf;
 401    if (stat(FileName(),&Buf) != 0)
 402       return false;
 403
 404    if (Buf.st_size != (signed)File->Size || Buf.st_mtime != File->mtime)
 405       return false;
 406
 407    return true;
 408 }
 409                                                                         /*}}}*/