apt-pkg/pkgcache.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: pkgcache.cc,v 1.37 2003/02/10 01:40:58 doogie 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 management. 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<config.h>
  24
  25 #include <apt-pkg/pkgcache.h>
  26 #include <apt-pkg/policy.h>
  27 #include <apt-pkg/version.h>
  28 #include <apt-pkg/error.h>
  29 #include <apt-pkg/strutl.h>
  30 #include <apt-pkg/configuration.h>
  31 #include <apt-pkg/aptconfiguration.h>
  32 #include <apt-pkg/mmap.h>
  33 #include <apt-pkg/macros.h>
  34
  35 #include <stddef.h>
  36 #include <string.h>
  37 #include <ostream>
  38 #include <vector>
  39 #include <string>
  40 #include <sys/stat.h>
  41
  42 #include <apti18n.h>
  43                                                                         /*}}}*/
  44
  45 using std::string;
  46
  47
  48 // Cache::Header::Header - Constructor                                  /*{{{*/
  49 // ---------------------------------------------------------------------
  50 /* Simply initialize the header */
  51 pkgCache::Header::Header()
  52 {
  53    Signature = 0x98FE76DC;
  54
  55    /* Whenever the structures change the major version should be bumped,
  56       whenever the generator changes the minor version should be bumped. */
  57    MajorVersion = 8;
  58 #if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13)
  59    MinorVersion = 2;
  60 #else
  61    MinorVersion = 1;
  62 #endif
  63    Dirty = false;
  64
  65    HeaderSz = sizeof(pkgCache::Header);
  66    GroupSz = sizeof(pkgCache::Group);
  67    PackageSz = sizeof(pkgCache::Package);
  68    PackageFileSz = sizeof(pkgCache::PackageFile);
  69    VersionSz = sizeof(pkgCache::Version);
  70    DescriptionSz = sizeof(pkgCache::Description);
  71    DependencySz = sizeof(pkgCache::Dependency);
  72    ProvidesSz = sizeof(pkgCache::Provides);
  73    VerFileSz = sizeof(pkgCache::VerFile);
  74    DescFileSz = sizeof(pkgCache::DescFile);
  75
  76    GroupCount = 0;
  77    PackageCount = 0;
  78    VersionCount = 0;
  79    DescriptionCount = 0;
  80    DependsCount = 0;
  81    PackageFileCount = 0;
  82    VerFileCount = 0;
  83    DescFileCount = 0;
  84    ProvidesCount = 0;
  85    MaxVerFileSize = 0;
  86    MaxDescFileSize = 0;
  87
  88    FileList = 0;
  89    StringList = 0;
  90    VerSysName = 0;
  91    Architecture = 0;
  92    memset(PkgHashTable,0,sizeof(PkgHashTable));
  93    memset(GrpHashTable,0,sizeof(GrpHashTable));
  94    memset(Pools,0,sizeof(Pools));
  95
  96    CacheFileSize = 0;
  97 }
  98                                                                         /*}}}*/
  99 // Cache::Header::CheckSizes - Check if the two headers have same *sz   /*{{{*/
 100 // ---------------------------------------------------------------------
 101 /* */
 102 bool pkgCache::Header::CheckSizes(Header &Against) const
 103 {
 104    if (HeaderSz == Against.HeaderSz &&
 105        GroupSz == Against.GroupSz &&
 106        PackageSz == Against.PackageSz &&
 107        PackageFileSz == Against.PackageFileSz &&
 108        VersionSz == Against.VersionSz &&
 109        DescriptionSz == Against.DescriptionSz &&
 110        DependencySz == Against.DependencySz &&
 111        VerFileSz == Against.VerFileSz &&
 112        DescFileSz == Against.DescFileSz &&
 113        ProvidesSz == Against.ProvidesSz)
 114       return true;
 115    return false;
 116 }
 117                                                                         /*}}}*/
 118
 119 // Cache::pkgCache - Constructor                                        /*{{{*/
 120 // ---------------------------------------------------------------------
 121 /* */
 122 pkgCache::pkgCache(MMap *Map, bool DoMap) : Map(*Map)
 123 {
 124    // call getArchitectures() with cached=false to ensure that the
 125    // architectures cache is re-evaulated. this is needed in cases
 126    // when the APT::Architecture field changes between two cache creations
 127    MultiArchEnabled = APT::Configuration::getArchitectures(false).size() > 1;
 128    if (DoMap == true)
 129       ReMap();
 130 }
 131                                                                         /*}}}*/
 132 // Cache::ReMap - Reopen the cache file                                 /*{{{*/
 133 // ---------------------------------------------------------------------
 134 /* If the file is already closed then this will open it open it. */
 135 bool pkgCache::ReMap(bool const &Errorchecks)
 136 {
 137    // Apply the typecasts.
 138    HeaderP = (Header *)Map.Data();
 139    GrpP = (Group *)Map.Data();
 140    PkgP = (Package *)Map.Data();
 141    VerFileP = (VerFile *)Map.Data();
 142    DescFileP = (DescFile *)Map.Data();
 143    PkgFileP = (PackageFile *)Map.Data();
 144    VerP = (Version *)Map.Data();
 145    DescP = (Description *)Map.Data();
 146    ProvideP = (Provides *)Map.Data();
 147    DepP = (Dependency *)Map.Data();
 148    StringItemP = (StringItem *)Map.Data();
 149    StrP = (char *)Map.Data();
 150
 151    if (Errorchecks == false)
 152       return true;
 153
 154    if (Map.Size() == 0 || HeaderP == 0)
 155       return _error->Error(_("Empty package cache"));
 156
 157    // Check the header
 158    Header DefHeader;
 159    if (HeaderP->Signature != DefHeader.Signature ||
 160        HeaderP->Dirty == true)
 161       return _error->Error(_("The package cache file is corrupted"));
 162
 163    if (HeaderP->MajorVersion != DefHeader.MajorVersion ||
 164        HeaderP->MinorVersion != DefHeader.MinorVersion ||
 165        HeaderP->CheckSizes(DefHeader) == false)
 166       return _error->Error(_("The package cache file is an incompatible version"));
 167
 168    if (Map.Size() < HeaderP->CacheFileSize)
 169       return _error->Error(_("The package cache file is corrupted, it is too small"));
 170
 171    // Locate our VS..
 172    if (HeaderP->VerSysName == 0 ||
 173        (VS = pkgVersioningSystem::GetVS(StrP + HeaderP->VerSysName)) == 0)
 174       return _error->Error(_("This APT does not support the versioning system '%s'"),StrP + HeaderP->VerSysName);
 175
 176    // Chcek the arhcitecture
 177    if (HeaderP->Architecture == 0 ||
 178        _config->Find("APT::Architecture") != StrP + HeaderP->Architecture)
 179       return _error->Error(_("The package cache was built for a different architecture"));
 180    return true;
 181 }
 182                                                                         /*}}}*/
 183 // Cache::Hash - Hash a string                                          /*{{{*/
 184 // ---------------------------------------------------------------------
 185 /* This is used to generate the hash entries for the HashTable. With my
 186    package list from bo this function gets 94% table usage on a 512 item
 187    table (480 used items) */
 188 unsigned long pkgCache::sHash(const string &Str) const
 189 {
 190    unsigned long Hash = 0;
 191    for (string::const_iterator I = Str.begin(); I != Str.end(); ++I)
 192       Hash = 41 * Hash + tolower_ascii(*I);
 193    return Hash % _count(HeaderP->PkgHashTable);
 194 }
 195
 196 unsigned long pkgCache::sHash(const char *Str) const
 197 {
 198    unsigned long Hash = tolower_ascii(*Str);
 199    for (const char *I = Str + 1; *I != 0; ++I)
 200       Hash = 41 * Hash + tolower_ascii(*I);
 201    return Hash % _count(HeaderP->PkgHashTable);
 202 }
 203                                                                         /*}}}*/
 204 // Cache::SingleArchFindPkg - Locate a package by name                  /*{{{*/
 205 // ---------------------------------------------------------------------
 206 /* Returns 0 on error, pointer to the package otherwise
 207    The multiArch enabled methods will fallback to this one as it is (a bit)
 208    faster for single arch environments and realworld is mostly singlearch… */
 209 pkgCache::PkgIterator pkgCache::SingleArchFindPkg(const string &Name)
 210 {
 211    // Look at the hash bucket
 212    Package *Pkg = PkgP + HeaderP->PkgHashTable[Hash(Name)];
 213    for (; Pkg != PkgP; Pkg = PkgP + Pkg->NextPackage)
 214    {
 215       if (unlikely(Pkg->Name == 0))
 216          continue;
 217
 218       int const cmp = strcasecmp(Name.c_str(), StrP + Pkg->Name);
 219       if (cmp == 0)
 220          return PkgIterator(*this, Pkg);
 221       else if (cmp < 0)
 222          break;
 223    }
 224    return PkgIterator(*this,0);
 225 }
 226                                                                         /*}}}*/
 227 // Cache::FindPkg - Locate a package by name                            /*{{{*/
 228 // ---------------------------------------------------------------------
 229 /* Returns 0 on error, pointer to the package otherwise */
 230 pkgCache::PkgIterator pkgCache::FindPkg(const string &Name) {
 231         size_t const found = Name.find(':');
 232         if (found == string::npos)
 233            return FindPkg(Name, "native");
 234         string const Arch = Name.substr(found+1);
 235         /* Beware: This is specialcased to handle pkg:any in dependencies as
 236            these are linked to virtual pkg:any named packages with all archs.
 237            If you want any arch from a given pkg, use FindPkg(pkg,arch) */
 238         if (Arch == "any")
 239                 return FindPkg(Name, "any");
 240         return FindPkg(Name.substr(0, found), Arch);
 241 }
 242                                                                         /*}}}*/
 243 // Cache::FindPkg - Locate a package by name                            /*{{{*/
 244 // ---------------------------------------------------------------------
 245 /* Returns 0 on error, pointer to the package otherwise */
 246 pkgCache::PkgIterator pkgCache::FindPkg(const string &Name, string const &Arch) {
 247         /* We make a detour via the GrpIterator here as
 248            on a multi-arch environment a group is easier to
 249            find than a package (less entries in the buckets) */
 250         pkgCache::GrpIterator Grp = FindGrp(Name);
 251         if (Grp.end() == true)
 252                 return PkgIterator(*this,0);
 253
 254         return Grp.FindPkg(Arch);
 255 }
 256                                                                         /*}}}*/
 257 // Cache::FindGrp - Locate a group by name                              /*{{{*/
 258 // ---------------------------------------------------------------------
 259 /* Returns End-Pointer on error, pointer to the group otherwise */
 260 pkgCache::GrpIterator pkgCache::FindGrp(const string &Name) {
 261         if (unlikely(Name.empty() == true))
 262                 return GrpIterator(*this,0);
 263
 264         // Look at the hash bucket for the group
 265         Group *Grp = GrpP + HeaderP->GrpHashTable[sHash(Name)];
 266         for (; Grp != GrpP; Grp = GrpP + Grp->Next) {
 267                 if (unlikely(Grp->Name == 0))
 268                    continue;
 269
 270                 int const cmp = strcasecmp(Name.c_str(), StrP + Grp->Name);
 271                 if (cmp == 0)
 272                         return GrpIterator(*this, Grp);
 273                 else if (cmp < 0)
 274                         break;
 275         }
 276
 277         return GrpIterator(*this,0);
 278 }
 279                                                                         /*}}}*/
 280 // Cache::CompTypeDeb - Return a string describing the compare type     /*{{{*/
 281 // ---------------------------------------------------------------------
 282 /* This returns a string representation of the dependency compare
 283    type in the weird debian style.. */
 284 const char *pkgCache::CompTypeDeb(unsigned char Comp)
 285 {
 286    const char * const Ops[] = {"","<=",">=","<<",">>","=","!="};
 287    if (unlikely((unsigned)(Comp & 0xF) >= sizeof(Ops)/sizeof(Ops[0])))
 288       return "";
 289    return Ops[Comp & 0xF];
 290 }
 291                                                                         /*}}}*/
 292 // Cache::CompType - Return a string describing the compare type        /*{{{*/
 293 // ---------------------------------------------------------------------
 294 /* This returns a string representation of the dependency compare
 295    type */
 296 const char *pkgCache::CompType(unsigned char Comp)
 297 {
 298    const char * const Ops[] = {"","<=",">=","<",">","=","!="};
 299    if (unlikely((unsigned)(Comp & 0xF) >= sizeof(Ops)/sizeof(Ops[0])))
 300       return "";
 301    return Ops[Comp & 0xF];
 302 }
 303                                                                         /*}}}*/
 304 // Cache::DepType - Return a string describing the dep type             /*{{{*/
 305 // ---------------------------------------------------------------------
 306 /* */
 307 const char *pkgCache::DepType(unsigned char Type)
 308 {
 309    const char *Types[] = {"",_("Depends"),_("PreDepends"),_("Suggests"),
 310                           _("Recommends"),_("Conflicts"),_("Replaces"),
 311                           _("Obsoletes"),_("Breaks"), _("Enhances")};
 312    if (Type < sizeof(Types)/sizeof(*Types))
 313       return Types[Type];
 314    return "";
 315 }
 316                                                                         /*}}}*/
 317 // Cache::Priority - Convert a priority value to a string               /*{{{*/
 318 // ---------------------------------------------------------------------
 319 /* */
 320 const char *pkgCache::Priority(unsigned char Prio)
 321 {
 322    const char *Mapping[] = {0,_("important"),_("required"),_("standard"),
 323                             _("optional"),_("extra")};
 324    if (Prio < _count(Mapping))
 325       return Mapping[Prio];
 326    return 0;
 327 }
 328                                                                         /*}}}*/
 329 // GrpIterator::FindPkg - Locate a package by arch                      /*{{{*/
 330 // ---------------------------------------------------------------------
 331 /* Returns an End-Pointer on error, pointer to the package otherwise */
 332 pkgCache::PkgIterator pkgCache::GrpIterator::FindPkg(string Arch) const {
 333         if (unlikely(IsGood() == false || S->FirstPackage == 0))
 334                 return PkgIterator(*Owner, 0);
 335
 336         /* If we accept any package we simply return the "first"
 337            package in this group (the last one added). */
 338         if (Arch == "any")
 339                 return PkgIterator(*Owner, Owner->PkgP + S->FirstPackage);
 340
 341         char const* const myArch = Owner->NativeArch();
 342         /* Most of the time the package for our native architecture is
 343            the one we add at first to the cache, but this would be the
 344            last one we check, so we do it now. */
 345         if (Arch == "native" || Arch == myArch || Arch == "all") {
 346                 pkgCache::Package *Pkg = Owner->PkgP + S->LastPackage;
 347                 if (strcasecmp(myArch, Owner->StrP + Pkg->Arch) == 0)
 348                         return PkgIterator(*Owner, Pkg);
 349                 Arch = myArch;
 350         }
 351
 352         /* Iterate over the list to find the matching arch
 353            unfortunately this list includes "package noise"
 354            (= different packages with same calculated hash),
 355            so we need to check the name also */
 356         for (pkgCache::Package *Pkg = PackageList(); Pkg != Owner->PkgP;
 357              Pkg = Owner->PkgP + Pkg->NextPackage) {
 358                 if (S->Name == Pkg->Name &&
 359                     stringcasecmp(Arch, Owner->StrP + Pkg->Arch) == 0)
 360                         return PkgIterator(*Owner, Pkg);
 361                 if ((Owner->PkgP + S->LastPackage) == Pkg)
 362                         break;
 363         }
 364
 365         return PkgIterator(*Owner, 0);
 366 }
 367                                                                         /*}}}*/
 368 // GrpIterator::FindPreferredPkg - Locate the "best" package            /*{{{*/
 369 // ---------------------------------------------------------------------
 370 /* Returns an End-Pointer on error, pointer to the package otherwise */
 371 pkgCache::PkgIterator pkgCache::GrpIterator::FindPreferredPkg(bool const &PreferNonVirtual) const {
 372         pkgCache::PkgIterator Pkg = FindPkg("native");
 373         if (Pkg.end() == false && (PreferNonVirtual == false || Pkg->VersionList != 0))
 374                 return Pkg;
 375
 376         std::vector<std::string> const archs = APT::Configuration::getArchitectures();
 377         for (std::vector<std::string>::const_iterator a = archs.begin();
 378              a != archs.end(); ++a) {
 379                 Pkg = FindPkg(*a);
 380                 if (Pkg.end() == false && (PreferNonVirtual == false || Pkg->VersionList != 0))
 381                         return Pkg;
 382         }
 383         // packages without an architecture
 384         Pkg = FindPkg("none");
 385         if (Pkg.end() == false && (PreferNonVirtual == false || Pkg->VersionList != 0))
 386                 return Pkg;
 387
 388         if (PreferNonVirtual == true)
 389                 return FindPreferredPkg(false);
 390         return PkgIterator(*Owner, 0);
 391 }
 392                                                                         /*}}}*/
 393 // GrpIterator::NextPkg - Locate the next package in the group          /*{{{*/
 394 // ---------------------------------------------------------------------
 395 /* Returns an End-Pointer on error, pointer to the package otherwise.
 396    We can't simply ++ to the next as the next package of the last will
 397    be from a different group (with the same hash value) */
 398 pkgCache::PkgIterator pkgCache::GrpIterator::NextPkg(pkgCache::PkgIterator const &LastPkg) const {
 399         if (unlikely(IsGood() == false || S->FirstPackage == 0 ||
 400             LastPkg.end() == true))
 401                 return PkgIterator(*Owner, 0);
 402
 403         if (S->LastPackage == LastPkg.Index())
 404                 return PkgIterator(*Owner, 0);
 405
 406         return PkgIterator(*Owner, Owner->PkgP + LastPkg->NextPackage);
 407 }
 408                                                                         /*}}}*/
 409 // GrpIterator::operator ++ - Postfix incr                              /*{{{*/
 410 // ---------------------------------------------------------------------
 411 /* This will advance to the next logical group in the hash table. */
 412 void pkgCache::GrpIterator::operator ++(int)
 413 {
 414    // Follow the current links
 415    if (S != Owner->GrpP)
 416       S = Owner->GrpP + S->Next;
 417
 418    // Follow the hash table
 419    while (S == Owner->GrpP && (HashIndex+1) < (signed)_count(Owner->HeaderP->GrpHashTable))
 420    {
 421       HashIndex++;
 422       S = Owner->GrpP + Owner->HeaderP->GrpHashTable[HashIndex];
 423    }
 424 }
 425                                                                         /*}}}*/
 426 // PkgIterator::operator ++ - Postfix incr                              /*{{{*/
 427 // ---------------------------------------------------------------------
 428 /* This will advance to the next logical package in the hash table. */
 429 void pkgCache::PkgIterator::operator ++(int)
 430 {
 431    // Follow the current links
 432    if (S != Owner->PkgP)
 433       S = Owner->PkgP + S->NextPackage;
 434
 435    // Follow the hash table
 436    while (S == Owner->PkgP && (HashIndex+1) < (signed)_count(Owner->HeaderP->PkgHashTable))
 437    {
 438       HashIndex++;
 439       S = Owner->PkgP + Owner->HeaderP->PkgHashTable[HashIndex];
 440    }
 441 }
 442                                                                         /*}}}*/
 443 // PkgIterator::State - Check the State of the package                  /*{{{*/
 444 // ---------------------------------------------------------------------
 445 /* By this we mean if it is either cleanly installed or cleanly removed. */
 446 pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const
 447 {
 448    if (S->InstState == pkgCache::State::ReInstReq ||
 449        S->InstState == pkgCache::State::HoldReInstReq)
 450       return NeedsUnpack;
 451
 452    if (S->CurrentState == pkgCache::State::UnPacked ||
 453        S->CurrentState == pkgCache::State::HalfConfigured)
 454       // we leave triggers alone complettely. dpkg deals with
 455       // them in a hard-to-predict manner and if they get
 456       // resolved by dpkg before apt run dpkg --configure on
 457       // the TriggersPending package dpkg returns a error
 458       //Pkg->CurrentState == pkgCache::State::TriggersAwaited
 459       //Pkg->CurrentState == pkgCache::State::TriggersPending)
 460       return NeedsConfigure;
 461
 462    if (S->CurrentState == pkgCache::State::HalfInstalled ||
 463        S->InstState != pkgCache::State::Ok)
 464       return NeedsUnpack;
 465
 466    return NeedsNothing;
 467 }
 468                                                                         /*}}}*/
 469 // PkgIterator::CandVersion - Returns the candidate version string      /*{{{*/
 470 // ---------------------------------------------------------------------
 471 /* Return string representing of the candidate version. */
 472 const char *
 473 pkgCache::PkgIterator::CandVersion() const
 474 {
 475   //TargetVer is empty, so don't use it.
 476   VerIterator version = pkgPolicy(Owner).GetCandidateVer(*this);
 477   if (version.IsGood())
 478     return version.VerStr();
 479   return 0;
 480 }
 481                                                                         /*}}}*/
 482 // PkgIterator::CurVersion - Returns the current version string         /*{{{*/
 483 // ---------------------------------------------------------------------
 484 /* Return string representing of the current version. */
 485 const char *
 486 pkgCache::PkgIterator::CurVersion() const
 487 {
 488   VerIterator version = CurrentVer();
 489   if (version.IsGood())
 490     return CurrentVer().VerStr();
 491   return 0;
 492 }
 493                                                                         /*}}}*/
 494 // ostream operator to handle string representation of a package        /*{{{*/
 495 // ---------------------------------------------------------------------
 496 /* Output name < cur.rent.version -> candid.ate.version | new.est.version > (section)
 497    Note that the characters <|>() are all literal above. Versions will be omitted
 498    if they provide no new information (e.g. there is no newer version than candidate)
 499    If no version and/or section can be found "none" is used. */
 500 std::ostream&
 501 operator<<(std::ostream& out, pkgCache::PkgIterator Pkg)
 502 {
 503    if (Pkg.end() == true)
 504       return out << "invalid package";
 505
 506    string current = string(Pkg.CurVersion() == 0 ? "none" : Pkg.CurVersion());
 507    string candidate = string(Pkg.CandVersion() == 0 ? "none" : Pkg.CandVersion());
 508    string newest = string(Pkg.VersionList().end() ? "none" : Pkg.VersionList().VerStr());
 509
 510    out << Pkg.Name() << " [ " << Pkg.Arch() << " ] < " << current;
 511    if (current != candidate)
 512       out << " -> " << candidate;
 513    if ( newest != "none" && candidate != newest)
 514       out << " | " << newest;
 515    if (Pkg->VersionList == 0)
 516       out << " > ( none )";
 517    else
 518       out << " > ( " << string(Pkg.VersionList().Section()==0?"unknown":Pkg.VersionList().Section()) << " )";
 519    return out;
 520 }
 521                                                                         /*}}}*/
 522 // PkgIterator::FullName - Returns Name and (maybe) Architecture        /*{{{*/
 523 // ---------------------------------------------------------------------
 524 /* Returns a name:arch string */
 525 std::string pkgCache::PkgIterator::FullName(bool const &Pretty) const
 526 {
 527    string fullname = Name();
 528    if (Pretty == false ||
 529        (strcmp(Arch(), "all") != 0 &&
 530         strcmp(Owner->NativeArch(), Arch()) != 0))
 531       return fullname.append(":").append(Arch());
 532    return fullname;
 533 }
 534                                                                         /*}}}*/
 535 // DepIterator::IsCritical - Returns true if the dep is important       /*{{{*/
 536 // ---------------------------------------------------------------------
 537 /* Currently critical deps are defined as depends, predepends and
 538    conflicts (including dpkg's Breaks fields). */
 539 bool pkgCache::DepIterator::IsCritical() const
 540 {
 541    if (IsNegative() == true ||
 542        S->Type == pkgCache::Dep::Depends ||
 543        S->Type == pkgCache::Dep::PreDepends)
 544       return true;
 545    return false;
 546 }
 547                                                                         /*}}}*/
 548 // DepIterator::IsNegative - Returns true if the dep is a negative one  /*{{{*/
 549 // ---------------------------------------------------------------------
 550 /* Some dependencies are positive like Depends and Recommends, others
 551    are negative like Conflicts which can and should be handled differently */
 552 bool pkgCache::DepIterator::IsNegative() const
 553 {
 554    return S->Type == Dep::DpkgBreaks ||
 555           S->Type == Dep::Conflicts ||
 556           S->Type == Dep::Obsoletes;
 557 }
 558                                                                         /*}}}*/
 559 // DepIterator::SmartTargetPkg - Resolve dep target pointers w/provides /*{{{*/
 560 // ---------------------------------------------------------------------
 561 /* This intellegently looks at dep target packages and tries to figure
 562    out which package should be used. This is needed to nicely handle
 563    provide mapping. If the target package has no other providing packages
 564    then it returned. Otherwise the providing list is looked at to
 565    see if there is one one unique providing package if so it is returned.
 566    Otherwise true is returned and the target package is set. The return
 567    result indicates whether the node should be expandable
 568
 569    In Conjunction with the DepCache the value of Result may not be
 570    super-good since the policy may have made it uninstallable. Using
 571    AllTargets is better in this case. */
 572 bool pkgCache::DepIterator::SmartTargetPkg(PkgIterator &Result) const
 573 {
 574    Result = TargetPkg();
 575
 576    // No provides at all
 577    if (Result->ProvidesList == 0)
 578       return false;
 579
 580    // There is the Base package and the providing ones which is at least 2
 581    if (Result->VersionList != 0)
 582       return true;
 583
 584    /* We have to skip over indirect provisions of the package that
 585       owns the dependency. For instance, if libc5-dev depends on the
 586       virtual package libc-dev which is provided by libc5-dev and libc6-dev
 587       we must ignore libc5-dev when considering the provides list. */
 588    PrvIterator PStart = Result.ProvidesList();
 589    for (; PStart.end() != true && PStart.OwnerPkg() == ParentPkg(); ++PStart);
 590
 591    // Nothing but indirect self provides
 592    if (PStart.end() == true)
 593       return false;
 594
 595    // Check for single packages in the provides list
 596    PrvIterator P = PStart;
 597    for (; P.end() != true; ++P)
 598    {
 599       // Skip over self provides
 600       if (P.OwnerPkg() == ParentPkg())
 601          continue;
 602       if (PStart.OwnerPkg() != P.OwnerPkg())
 603          break;
 604    }
 605
 606    Result = PStart.OwnerPkg();
 607
 608    // Check for non dups
 609    if (P.end() != true)
 610       return true;
 611
 612    return false;
 613 }
 614                                                                         /*}}}*/
 615 // DepIterator::AllTargets - Returns the set of all possible targets    /*{{{*/
 616 // ---------------------------------------------------------------------
 617 /* This is a more useful version of TargetPkg() that follows versioned
 618    provides. It includes every possible package-version that could satisfy
 619    the dependency. The last item in the list has a 0. The resulting pointer
 620    must be delete [] 'd */
 621 pkgCache::Version **pkgCache::DepIterator::AllTargets() const
 622 {
 623    Version **Res = 0;
 624    unsigned long Size =0;
 625    while (1)
 626    {
 627       Version **End = Res;
 628       PkgIterator DPkg = TargetPkg();
 629
 630       // Walk along the actual package providing versions
 631       for (VerIterator I = DPkg.VersionList(); I.end() == false; ++I)
 632       {
 633          if (IsIgnorable(I.ParentPkg()) == true)
 634             continue;
 635          if (IsSatisfied(I) == false)
 636             continue;
 637
 638          Size++;
 639          if (Res != 0)
 640             *End++ = I;
 641       }
 642
 643       // Follow all provides
 644       for (PrvIterator I = DPkg.ProvidesList(); I.end() == false; ++I)
 645       {
 646          if (IsIgnorable(I) == true)
 647             continue;
 648          if (IsSatisfied(I) == false)
 649             continue;
 650
 651          Size++;
 652          if (Res != 0)
 653             *End++ = I.OwnerVer();
 654       }
 655
 656       // Do it again and write it into the array
 657       if (Res == 0)
 658       {
 659          Res = new Version *[Size+1];
 660          Size = 0;
 661       }
 662       else
 663       {
 664          *End = 0;
 665          break;
 666       }
 667    }
 668
 669    return Res;
 670 }
 671                                                                         /*}}}*/
 672 // DepIterator::GlobOr - Compute an OR group                            /*{{{*/
 673 // ---------------------------------------------------------------------
 674 /* This Takes an iterator, iterates past the current dependency grouping
 675    and returns Start and End so that so End is the final element
 676    in the group, if End == Start then D is End++ and End is the
 677    dependency D was pointing to. Use in loops to iterate sensibly. */
 678 void pkgCache::DepIterator::GlobOr(DepIterator &Start,DepIterator &End)
 679 {
 680    // Compute a single dependency element (glob or)
 681    Start = *this;
 682    End = *this;
 683    for (bool LastOR = true; end() == false && LastOR == true;)
 684    {
 685       LastOR = (S->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
 686       (*this)++;
 687       if (LastOR == true)
 688          End = (*this);
 689    }
 690 }
 691                                                                         /*}}}*/
 692 // DepIterator::IsIgnorable - should this packag/providr be ignored?    /*{{{*/
 693 // ---------------------------------------------------------------------
 694 /* Deps like self-conflicts should be ignored as well as implicit conflicts
 695    on virtual packages. */
 696 bool pkgCache::DepIterator::IsIgnorable(PkgIterator const &/*Pkg*/) const
 697 {
 698    if (IsNegative() == false)
 699       return false;
 700
 701    pkgCache::PkgIterator PP = ParentPkg();
 702    pkgCache::PkgIterator PT = TargetPkg();
 703    if (PP->Group != PT->Group)
 704       return false;
 705    // self-conflict
 706    if (PP == PT)
 707       return true;
 708    pkgCache::VerIterator PV = ParentVer();
 709    // ignore group-conflict on a M-A:same package - but not our implicit dependencies
 710    // so that we can have M-A:same packages conflicting with their own real name
 711    if ((PV->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
 712    {
 713       // Replaces: ${self}:other ( << ${binary:Version})
 714       if (S->Type == pkgCache::Dep::Replaces && S->CompareOp == pkgCache::Dep::Less && strcmp(PV.VerStr(), TargetVer()) == 0)
 715          return false;
 716       // Breaks: ${self}:other (!= ${binary:Version})
 717       if (S->Type == pkgCache::Dep::DpkgBreaks && S->CompareOp == pkgCache::Dep::NotEquals && strcmp(PV.VerStr(), TargetVer()) == 0)
 718          return false;
 719       return true;
 720    }
 721
 722    return false;
 723 }
 724 bool pkgCache::DepIterator::IsIgnorable(PrvIterator const &Prv) const
 725 {
 726    if (IsNegative() == false)
 727       return false;
 728
 729    PkgIterator const Pkg = ParentPkg();
 730    /* Provides may never be applied against the same package (or group)
 731       if it is a conflicts. See the comment above. */
 732    if (Prv.OwnerPkg()->Group == Pkg->Group)
 733       return true;
 734    // Implicit group-conflicts should not be applied on providers of other groups
 735    if (Pkg->Group == TargetPkg()->Group && Prv.OwnerPkg()->Group != Pkg->Group)
 736       return true;
 737
 738    return false;
 739 }
 740                                                                         /*}}}*/
 741 // DepIterator::IsMultiArchImplicit - added by the cache generation     /*{{{*/
 742 // ---------------------------------------------------------------------
 743 /* MultiArch can be translated to SingleArch for an resolver and we did so,
 744    by adding dependencies to help the resolver understand the problem, but
 745    sometimes it is needed to identify these to ignore them… */
 746 bool pkgCache::DepIterator::IsMultiArchImplicit() const
 747 {
 748    if (ParentPkg()->Arch != TargetPkg()->Arch &&
 749        (S->Type == pkgCache::Dep::Replaces ||
 750         S->Type == pkgCache::Dep::DpkgBreaks ||
 751         S->Type == pkgCache::Dep::Conflicts))
 752       return true;
 753    return false;
 754 }
 755                                                                         /*}}}*/
 756 // DepIterator::IsSatisfied - check if a version satisfied the dependency /*{{{*/
 757 bool pkgCache::DepIterator::IsSatisfied(VerIterator const &Ver) const
 758 {
 759    return Owner->VS->CheckDep(Ver.VerStr(),S->CompareOp,TargetVer());
 760 }
 761 bool pkgCache::DepIterator::IsSatisfied(PrvIterator const &Prv) const
 762 {
 763    return Owner->VS->CheckDep(Prv.ProvideVersion(),S->CompareOp,TargetVer());
 764 }
 765                                                                         /*}}}*/
 766 // ostream operator to handle string representation of a dependecy      /*{{{*/
 767 // ---------------------------------------------------------------------
 768 /* */
 769 std::ostream& operator<<(std::ostream& out, pkgCache::DepIterator D)
 770 {
 771    if (D.end() == true)
 772       return out << "invalid dependency";
 773
 774    pkgCache::PkgIterator P = D.ParentPkg();
 775    pkgCache::PkgIterator T = D.TargetPkg();
 776
 777    out << (P.end() ? "invalid pkg" : P.FullName(false)) << " " << D.DepType()
 778         << " on ";
 779    if (T.end() == true)
 780       out << "invalid pkg";
 781    else
 782       out << T;
 783
 784    if (D->Version != 0)
 785       out << " (" << D.CompType() << " " << D.TargetVer() << ")";
 786
 787    return out;
 788 }
 789                                                                         /*}}}*/
 790 // VerIterator::CompareVer - Fast version compare for same pkgs         /*{{{*/
 791 // ---------------------------------------------------------------------
 792 /* This just looks over the version list to see if B is listed before A. In
 793    most cases this will return in under 4 checks, ver lists are short. */
 794 int pkgCache::VerIterator::CompareVer(const VerIterator &B) const
 795 {
 796    // Check if they are equal
 797    if (*this == B)
 798       return 0;
 799    if (end() == true)
 800       return -1;
 801    if (B.end() == true)
 802       return 1;
 803
 804    /* Start at A and look for B. If B is found then A > B otherwise
 805       B was before A so A < B */
 806    VerIterator I = *this;
 807    for (;I.end() == false; ++I)
 808       if (I == B)
 809          return 1;
 810    return -1;
 811 }
 812                                                                         /*}}}*/
 813 // VerIterator::Downloadable - Checks if the version is downloadable    /*{{{*/
 814 // ---------------------------------------------------------------------
 815 /* */
 816 APT_PURE bool pkgCache::VerIterator::Downloadable() const
 817 {
 818    VerFileIterator Files = FileList();
 819    for (; Files.end() == false; ++Files)
 820       if ((Files.File()->Flags & pkgCache::Flag::NotSource) != pkgCache::Flag::NotSource)
 821          return true;
 822    return false;
 823 }
 824                                                                         /*}}}*/
 825 // VerIterator::Automatic - Check if this version is 'automatic'        /*{{{*/
 826 // ---------------------------------------------------------------------
 827 /* This checks to see if any of the versions files are not NotAutomatic.
 828    True if this version is selectable for automatic installation. */
 829 APT_PURE bool pkgCache::VerIterator::Automatic() const
 830 {
 831    VerFileIterator Files = FileList();
 832    for (; Files.end() == false; ++Files)
 833       // Do not check ButAutomaticUpgrades here as it is kind of automatic…
 834       if ((Files.File()->Flags & pkgCache::Flag::NotAutomatic) != pkgCache::Flag::NotAutomatic)
 835          return true;
 836    return false;
 837 }
 838                                                                         /*}}}*/
 839 // VerIterator::NewestFile - Return the newest file version relation    /*{{{*/
 840 // ---------------------------------------------------------------------
 841 /* This looks at the version numbers associated with all of the sources
 842    this version is in and returns the highest.*/
 843 pkgCache::VerFileIterator pkgCache::VerIterator::NewestFile() const
 844 {
 845    VerFileIterator Files = FileList();
 846    VerFileIterator Highest = Files;
 847    for (; Files.end() == false; ++Files)
 848    {
 849       if (Owner->VS->CmpReleaseVer(Files.File().Version(),Highest.File().Version()) > 0)
 850          Highest = Files;
 851    }
 852
 853    return Highest;
 854 }
 855                                                                         /*}}}*/
 856 // VerIterator::RelStr - Release description string                     /*{{{*/
 857 // ---------------------------------------------------------------------
 858 /* This describes the version from a release-centric manner. The output is a
 859    list of Label:Version/Archive */
 860 string pkgCache::VerIterator::RelStr() const
 861 {
 862    bool First = true;
 863    string Res;
 864    for (pkgCache::VerFileIterator I = this->FileList(); I.end() == false; ++I)
 865    {
 866       // Do not print 'not source' entries'
 867       pkgCache::PkgFileIterator File = I.File();
 868       if ((File->Flags & pkgCache::Flag::NotSource) == pkgCache::Flag::NotSource)
 869          continue;
 870
 871       // See if we have already printed this out..
 872       bool Seen = false;
 873       for (pkgCache::VerFileIterator J = this->FileList(); I != J; ++J)
 874       {
 875          pkgCache::PkgFileIterator File2 = J.File();
 876          if (File2->Label == 0 || File->Label == 0)
 877             continue;
 878
 879          if (strcmp(File.Label(),File2.Label()) != 0)
 880             continue;
 881
 882          if (File2->Version == File->Version)
 883          {
 884             Seen = true;
 885             break;
 886          }
 887          if (File2->Version == 0 || File->Version == 0)
 888             break;
 889          if (strcmp(File.Version(),File2.Version()) == 0)
 890             Seen = true;
 891       }
 892
 893       if (Seen == true)
 894          continue;
 895
 896       if (First == false)
 897          Res += ", ";
 898       else
 899          First = false;
 900
 901       if (File->Label != 0)
 902          Res = Res + File.Label() + ':';
 903
 904       if (File->Archive != 0)
 905       {
 906          if (File->Version == 0)
 907             Res += File.Archive();
 908          else
 909             Res = Res + File.Version() + '/' +  File.Archive();
 910       }
 911       else
 912       {
 913          // No release file, print the host name that this came from
 914          if (File->Site == 0 || File.Site()[0] == 0)
 915             Res += "localhost";
 916          else
 917             Res += File.Site();
 918       }
 919    }
 920    if (S->ParentPkg != 0)
 921       Res.append(" [").append(Arch()).append("]");
 922    return Res;
 923 }
 924                                                                         /*}}}*/
 925 // VerIterator::MultiArchType - string representing MultiArch flag      /*{{{*/
 926 const char * pkgCache::VerIterator::MultiArchType() const
 927 {
 928    if ((S->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
 929       return "same";
 930    else if ((S->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
 931       return "foreign";
 932    else if ((S->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
 933       return "allowed";
 934    return "none";
 935 }
 936                                                                         /*}}}*/
 937 // PkgFileIterator::IsOk - Checks if the cache is in sync with the file /*{{{*/
 938 // ---------------------------------------------------------------------
 939 /* This stats the file and compares its stats with the ones that were
 940    stored during generation. Date checks should probably also be
 941    included here. */
 942 bool pkgCache::PkgFileIterator::IsOk()
 943 {
 944    struct stat Buf;
 945    if (stat(FileName(),&Buf) != 0)
 946       return false;
 947
 948    if (Buf.st_size != (signed)S->Size || Buf.st_mtime != S->mtime)
 949       return false;
 950
 951    return true;
 952 }
 953                                                                         /*}}}*/
 954 // PkgFileIterator::RelStr - Return the release string                  /*{{{*/
 955 // ---------------------------------------------------------------------
 956 /* */
 957 string pkgCache::PkgFileIterator::RelStr()
 958 {
 959    string Res;
 960    if (Version() != 0)
 961       Res = Res + (Res.empty() == true?"v=":",v=") + Version();
 962    if (Origin() != 0)
 963       Res = Res + (Res.empty() == true?"o=":",o=")  + Origin();
 964    if (Archive() != 0)
 965       Res = Res + (Res.empty() == true?"a=":",a=")  + Archive();
 966    if (Codename() != 0)
 967       Res = Res + (Res.empty() == true?"n=":",n=")  + Codename();
 968    if (Label() != 0)
 969       Res = Res + (Res.empty() == true?"l=":",l=")  + Label();
 970    if (Component() != 0)
 971       Res = Res + (Res.empty() == true?"c=":",c=")  + Component();
 972    if (Architecture() != 0)
 973       Res = Res + (Res.empty() == true?"b=":",b=")  + Architecture();
 974    return Res;
 975 }
 976                                                                         /*}}}*/
 977 // VerIterator::TranslatedDescription - Return the a DescIter for locale/*{{{*/
 978 // ---------------------------------------------------------------------
 979 /* return a DescIter for the current locale or the default if none is
 980  * found
 981  */
 982 pkgCache::DescIterator pkgCache::VerIterator::TranslatedDescription() const
 983 {
 984    std::vector<string> const lang = APT::Configuration::getLanguages();
 985    for (std::vector<string>::const_iterator l = lang.begin();
 986         l != lang.end(); ++l)
 987    {
 988       pkgCache::DescIterator Desc = DescriptionList();
 989       for (; Desc.end() == false; ++Desc)
 990          if (*l == Desc.LanguageCode())
 991             break;
 992       if (Desc.end() == true)
 993       {
 994          if (*l == "en")
 995          {
 996             Desc = DescriptionList();
 997             for (; Desc.end() == false; ++Desc)
 998                if (strcmp(Desc.LanguageCode(), "") == 0)
 999                   break;
1000             if (Desc.end() == true)
1001                continue;
1002          }
1003          else
1004             continue;
1005       }
1006       return Desc;
1007    }
1008    for (pkgCache::DescIterator Desc = DescriptionList();
1009         Desc.end() == false; ++Desc)
1010       if (strcmp(Desc.LanguageCode(), "") == 0)
1011          return Desc;
1012    return DescriptionList();
1013 }
1014
1015                                                                         /*}}}*/
1016 // PrvIterator::IsMultiArchImplicit - added by the cache generation     /*{{{*/
1017 // ---------------------------------------------------------------------
1018 /* MultiArch can be translated to SingleArch for an resolver and we did so,
1019    by adding provides to help the resolver understand the problem, but
1020    sometimes it is needed to identify these to ignore them… */
1021 bool pkgCache::PrvIterator::IsMultiArchImplicit() const
1022 {
1023    pkgCache::PkgIterator const Owner = OwnerPkg();
1024    pkgCache::PkgIterator const Parent = ParentPkg();
1025    if (strcmp(Owner.Arch(), Parent.Arch()) != 0 || Owner->Name == Parent->Name)
1026       return true;
1027    return false;
1028 }
1029                                                                         /*}}}*/