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