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