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