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