apt-pkg/pkgcache.cc

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