apt-pkg/pkgcache.cc

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