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