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