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