apt-pkg/pkgcache.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: pkgcache.cc,v 1.37 2003/02/10 01:40:58 doogie Exp $
   4 /* ######################################################################
   5
   6    Package Cache - Accessor code for the cache
   7
   8    Please see doc/apt-pkg/cache.sgml for a more detailed description of
   9    this format. Also be sure to keep that file up-to-date!!
  10
  11    This is the general utility functions for cache managment. They provide
  12    a complete set of accessor functions for the cache. The cacheiterators
  13    header contains the STL-like iterators that can be used to easially
  14    navigate the cache as well as seemlessly dereference the mmap'd
  15    indexes. Use these always.
  16
  17    The main class provides for ways to get package indexes and some
  18    general lookup functions to start the iterators.
  19
  20    ##################################################################### */
  21                                                                         /*}}}*/
  22 // Include Files                                                        /*{{{*/
  23 #include<config.h>
  24
  25 #include <apt-pkg/pkgcache.h>
  26 #include <apt-pkg/policy.h>
  27 #include <apt-pkg/version.h>
  28 #include <apt-pkg/error.h>
  29 #include <apt-pkg/strutl.h>
  30 #include <apt-pkg/configuration.h>
  31 #include <apt-pkg/aptconfiguration.h>
  32 #include <apt-pkg/macros.h>
  33
  34 #include <string>
  35 #include <sys/stat.h>
  36 #include <unistd.h>
  37 #include <ctype.h>
  38
  39 #include <apti18n.h>
  40                                                                         /*}}}*/
  41
  42 using std::string;
  43
  44
  45 // Cache::Header::Header - Constructor                                  /*{{{*/
  46 // ---------------------------------------------------------------------
  47 /* Simply initialize the header */
  48 pkgCache::Header::Header()
  49 {
  50    Signature = 0x98FE76DC;
  51
  52    /* Whenever the structures change the major version should be bumped,
  53       whenever the generator changes the minor version should be bumped. */
  54    MajorVersion = 8;
  55    MinorVersion = 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) {
 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
 380         if (PreferNonVirtual == true)
 381                 return FindPreferredPkg(false);
 382         return PkgIterator(*Owner, 0);
 383 }
 384                                                                         /*}}}*/
 385 // GrpIterator::NextPkg - Locate the next package in the group          /*{{{*/
 386 // ---------------------------------------------------------------------
 387 /* Returns an End-Pointer on error, pointer to the package otherwise.
 388    We can't simply ++ to the next as the next package of the last will
 389    be from a different group (with the same hash value) */
 390 pkgCache::PkgIterator pkgCache::GrpIterator::NextPkg(pkgCache::PkgIterator const &LastPkg) const {
 391         if (unlikely(IsGood() == false || S->FirstPackage == 0 ||
 392             LastPkg.end() == true))
 393                 return PkgIterator(*Owner, 0);
 394
 395         if (S->LastPackage == LastPkg.Index())
 396                 return PkgIterator(*Owner, 0);
 397
 398         return PkgIterator(*Owner, Owner->PkgP + LastPkg->NextPackage);
 399 }
 400                                                                         /*}}}*/
 401 // GrpIterator::operator ++ - Postfix incr                              /*{{{*/
 402 // ---------------------------------------------------------------------
 403 /* This will advance to the next logical group in the hash table. */
 404 void pkgCache::GrpIterator::operator ++(int)
 405 {
 406    // Follow the current links
 407    if (S != Owner->GrpP)
 408       S = Owner->GrpP + S->Next;
 409
 410    // Follow the hash table
 411    while (S == Owner->GrpP && (HashIndex+1) < (signed)_count(Owner->HeaderP->GrpHashTable))
 412    {
 413       HashIndex++;
 414       S = Owner->GrpP + Owner->HeaderP->GrpHashTable[HashIndex];
 415    }
 416 };
 417                                                                         /*}}}*/
 418 // PkgIterator::operator ++ - Postfix incr                              /*{{{*/
 419 // ---------------------------------------------------------------------
 420 /* This will advance to the next logical package in the hash table. */
 421 void pkgCache::PkgIterator::operator ++(int)
 422 {
 423    // Follow the current links
 424    if (S != Owner->PkgP)
 425       S = Owner->PkgP + S->NextPackage;
 426
 427    // Follow the hash table
 428    while (S == Owner->PkgP && (HashIndex+1) < (signed)_count(Owner->HeaderP->PkgHashTable))
 429    {
 430       HashIndex++;
 431       S = Owner->PkgP + Owner->HeaderP->PkgHashTable[HashIndex];
 432    }
 433 };
 434                                                                         /*}}}*/
 435 // PkgIterator::State - Check the State of the package                  /*{{{*/
 436 // ---------------------------------------------------------------------
 437 /* By this we mean if it is either cleanly installed or cleanly removed. */
 438 pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const
 439 {
 440    if (S->InstState == pkgCache::State::ReInstReq ||
 441        S->InstState == pkgCache::State::HoldReInstReq)
 442       return NeedsUnpack;
 443
 444    if (S->CurrentState == pkgCache::State::UnPacked ||
 445        S->CurrentState == pkgCache::State::HalfConfigured)
 446       // we leave triggers alone complettely. dpkg deals with
 447       // them in a hard-to-predict manner and if they get
 448       // resolved by dpkg before apt run dpkg --configure on
 449       // the TriggersPending package dpkg returns a error
 450       //Pkg->CurrentState == pkgCache::State::TriggersAwaited
 451       //Pkg->CurrentState == pkgCache::State::TriggersPending)
 452       return NeedsConfigure;
 453
 454    if (S->CurrentState == pkgCache::State::HalfInstalled ||
 455        S->InstState != pkgCache::State::Ok)
 456       return NeedsUnpack;
 457
 458    return NeedsNothing;
 459 }
 460                                                                         /*}}}*/
 461 // PkgIterator::CandVersion - Returns the candidate version string      /*{{{*/
 462 // ---------------------------------------------------------------------
 463 /* Return string representing of the candidate version. */
 464 const char *
 465 pkgCache::PkgIterator::CandVersion() const
 466 {
 467   //TargetVer is empty, so don't use it.
 468   VerIterator version = pkgPolicy(Owner).GetCandidateVer(*this);
 469   if (version.IsGood())
 470     return version.VerStr();
 471   return 0;
 472 };
 473                                                                         /*}}}*/
 474 // PkgIterator::CurVersion - Returns the current version string         /*{{{*/
 475 // ---------------------------------------------------------------------
 476 /* Return string representing of the current version. */
 477 const char *
 478 pkgCache::PkgIterator::CurVersion() const
 479 {
 480   VerIterator version = CurrentVer();
 481   if (version.IsGood())
 482     return CurrentVer().VerStr();
 483   return 0;
 484 };
 485                                                                         /*}}}*/
 486 // ostream operator to handle string representation of a package        /*{{{*/
 487 // ---------------------------------------------------------------------
 488 /* Output name < cur.rent.version -> candid.ate.version | new.est.version > (section)
 489    Note that the characters <|>() are all literal above. Versions will be ommited
 490    if they provide no new information (e.g. there is no newer version than candidate)
 491    If no version and/or section can be found "none" is used. */
 492 std::ostream&
 493 operator<<(std::ostream& out, pkgCache::PkgIterator Pkg)
 494 {
 495    if (Pkg.end() == true)
 496       return out << "invalid package";
 497
 498    string current = string(Pkg.CurVersion() == 0 ? "none" : Pkg.CurVersion());
 499    string candidate = string(Pkg.CandVersion() == 0 ? "none" : Pkg.CandVersion());
 500    string newest = string(Pkg.VersionList().end() ? "none" : Pkg.VersionList().VerStr());
 501
 502    out << Pkg.Name() << " [ " << Pkg.Arch() << " ] < " << current;
 503    if (current != candidate)
 504       out << " -> " << candidate;
 505    if ( newest != "none" && candidate != newest)
 506       out << " | " << newest;
 507    out << " > ( " << string(Pkg.Section()==0?"none":Pkg.Section()) << " )";
 508    return out;
 509 }
 510                                                                         /*}}}*/
 511 // PkgIterator::FullName - Returns Name and (maybe) Architecture        /*{{{*/
 512 // ---------------------------------------------------------------------
 513 /* Returns a name:arch string */
 514 std::string pkgCache::PkgIterator::FullName(bool const &Pretty) const
 515 {
 516    string fullname = Name();
 517    if (Pretty == false ||
 518        (strcmp(Arch(), "all") != 0 &&
 519         strcmp(Owner->NativeArch(), Arch()) != 0))
 520       return fullname.append(":").append(Arch());
 521    return fullname;
 522 }
 523                                                                         /*}}}*/
 524 // DepIterator::IsCritical - Returns true if the dep is important       /*{{{*/
 525 // ---------------------------------------------------------------------
 526 /* Currently critical deps are defined as depends, predepends and
 527    conflicts (including dpkg's Breaks fields). */
 528 bool pkgCache::DepIterator::IsCritical() const
 529 {
 530    if (IsNegative() == true ||
 531        S->Type == pkgCache::Dep::Depends ||
 532        S->Type == pkgCache::Dep::PreDepends)
 533       return true;
 534    return false;
 535 }
 536                                                                         /*}}}*/
 537 // DepIterator::IsNegative - Returns true if the dep is a negative one  /*{{{*/
 538 // ---------------------------------------------------------------------
 539 /* Some dependencies are positive like Depends and Recommends, others
 540    are negative like Conflicts which can and should be handled differently */
 541 bool pkgCache::DepIterator::IsNegative() const
 542 {
 543    return S->Type == Dep::DpkgBreaks ||
 544           S->Type == Dep::Conflicts ||
 545           S->Type == Dep::Obsoletes;
 546 }
 547                                                                         /*}}}*/
 548 // DepIterator::SmartTargetPkg - Resolve dep target pointers w/provides /*{{{*/
 549 // ---------------------------------------------------------------------
 550 /* This intellegently looks at dep target packages and tries to figure
 551    out which package should be used. This is needed to nicely handle
 552    provide mapping. If the target package has no other providing packages
 553    then it returned. Otherwise the providing list is looked at to
 554    see if there is one one unique providing package if so it is returned.
 555    Otherwise true is returned and the target package is set. The return
 556    result indicates whether the node should be expandable
 557
 558    In Conjunction with the DepCache the value of Result may not be
 559    super-good since the policy may have made it uninstallable. Using
 560    AllTargets is better in this case. */
 561 bool pkgCache::DepIterator::SmartTargetPkg(PkgIterator &Result) const
 562 {
 563    Result = TargetPkg();
 564
 565    // No provides at all
 566    if (Result->ProvidesList == 0)
 567       return false;
 568
 569    // There is the Base package and the providing ones which is at least 2
 570    if (Result->VersionList != 0)
 571       return true;
 572
 573    /* We have to skip over indirect provisions of the package that
 574       owns the dependency. For instance, if libc5-dev depends on the
 575       virtual package libc-dev which is provided by libc5-dev and libc6-dev
 576       we must ignore libc5-dev when considering the provides list. */
 577    PrvIterator PStart = Result.ProvidesList();
 578    for (; PStart.end() != true && PStart.OwnerPkg() == ParentPkg(); ++PStart);
 579
 580    // Nothing but indirect self provides
 581    if (PStart.end() == true)
 582       return false;
 583
 584    // Check for single packages in the provides list
 585    PrvIterator P = PStart;
 586    for (; P.end() != true; ++P)
 587    {
 588       // Skip over self provides
 589       if (P.OwnerPkg() == ParentPkg())
 590          continue;
 591       if (PStart.OwnerPkg() != P.OwnerPkg())
 592          break;
 593    }
 594
 595    Result = PStart.OwnerPkg();
 596
 597    // Check for non dups
 598    if (P.end() != true)
 599       return true;
 600
 601    return false;
 602 }
 603                                                                         /*}}}*/
 604 // DepIterator::AllTargets - Returns the set of all possible targets    /*{{{*/
 605 // ---------------------------------------------------------------------
 606 /* This is a more useful version of TargetPkg() that follows versioned
 607    provides. It includes every possible package-version that could satisfy
 608    the dependency. The last item in the list has a 0. The resulting pointer
 609    must be delete [] 'd */
 610 pkgCache::Version **pkgCache::DepIterator::AllTargets() const
 611 {
 612    Version **Res = 0;
 613    unsigned long Size =0;
 614    while (1)
 615    {
 616       Version **End = Res;
 617       PkgIterator DPkg = TargetPkg();
 618
 619       // Walk along the actual package providing versions
 620       for (VerIterator I = DPkg.VersionList(); I.end() == false; ++I)
 621       {
 622          if (IsIgnorable(I.ParentPkg()) == true)
 623             continue;
 624
 625          if (Owner->VS->CheckDep(I.VerStr(),S->CompareOp,TargetVer()) == false)
 626             continue;
 627
 628          Size++;
 629          if (Res != 0)
 630             *End++ = I;
 631       }
 632
 633       // Follow all provides
 634       for (PrvIterator I = DPkg.ProvidesList(); I.end() == false; ++I)
 635       {
 636          if (IsIgnorable(I) == true)
 637             continue;
 638
 639          if (Owner->VS->CheckDep(I.ProvideVersion(),S->CompareOp,TargetVer()) == false)
 640             continue;
 641
 642          Size++;
 643          if (Res != 0)
 644             *End++ = I.OwnerVer();
 645       }
 646
 647       // Do it again and write it into the array
 648       if (Res == 0)
 649       {
 650          Res = new Version *[Size+1];
 651          Size = 0;
 652       }
 653       else
 654       {
 655          *End = 0;
 656          break;
 657       }
 658    }
 659
 660    return Res;
 661 }
 662                                                                         /*}}}*/
 663 // DepIterator::GlobOr - Compute an OR group                            /*{{{*/
 664 // ---------------------------------------------------------------------
 665 /* This Takes an iterator, iterates past the current dependency grouping
 666    and returns Start and End so that so End is the final element
 667    in the group, if End == Start then D is End++ and End is the
 668    dependency D was pointing to. Use in loops to iterate sensibly. */
 669 void pkgCache::DepIterator::GlobOr(DepIterator &Start,DepIterator &End)
 670 {
 671    // Compute a single dependency element (glob or)
 672    Start = *this;
 673    End = *this;
 674    for (bool LastOR = true; end() == false && LastOR == true;)
 675    {
 676       LastOR = (S->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
 677       (*this)++;
 678       if (LastOR == true)
 679          End = (*this);
 680    }
 681 }
 682                                                                         /*}}}*/
 683 // DepIterator::IsIgnorable - should this packag/providr be ignored?    /*{{{*/
 684 // ---------------------------------------------------------------------
 685 /* Deps like self-conflicts should be ignored as well as implicit conflicts
 686    on virtual packages. */
 687 bool pkgCache::DepIterator::IsIgnorable(PkgIterator const &Pkg) const
 688 {
 689    if (ParentPkg() == TargetPkg())
 690       return IsNegative();
 691
 692    return false;
 693 }
 694 bool pkgCache::DepIterator::IsIgnorable(PrvIterator const &Prv) const
 695 {
 696    if (IsNegative() == false)
 697       return false;
 698
 699    PkgIterator const Pkg = ParentPkg();
 700    /* Provides may never be applied against the same package (or group)
 701       if it is a conflicts. See the comment above. */
 702    if (Prv.OwnerPkg()->Group == Pkg->Group)
 703       return true;
 704    // Implicit group-conflicts should not be applied on providers of other groups
 705    if (Pkg->Group == TargetPkg()->Group && Prv.OwnerPkg()->Group != Pkg->Group)
 706       return true;
 707
 708    return false;
 709 }
 710                                                                         /*}}}*/
 711 // ostream operator to handle string representation of a dependecy      /*{{{*/
 712 // ---------------------------------------------------------------------
 713 /* */
 714 std::ostream& operator<<(std::ostream& out, pkgCache::DepIterator D)
 715 {
 716    if (D.end() == true)
 717       return out << "invalid dependency";
 718
 719    pkgCache::PkgIterator P = D.ParentPkg();
 720    pkgCache::PkgIterator T = D.TargetPkg();
 721
 722    out << (P.end() ? "invalid pkg" : P.FullName(false)) << " " << D.DepType()
 723         << " on ";
 724    if (T.end() == true)
 725       out << "invalid pkg";
 726    else
 727       out << T;
 728
 729    if (D->Version != 0)
 730       out << " (" << D.CompType() << " " << D.TargetVer() << ")";
 731
 732    return out;
 733 }
 734                                                                         /*}}}*/
 735 // VerIterator::CompareVer - Fast version compare for same pkgs         /*{{{*/
 736 // ---------------------------------------------------------------------
 737 /* This just looks over the version list to see if B is listed before A. In
 738    most cases this will return in under 4 checks, ver lists are short. */
 739 int pkgCache::VerIterator::CompareVer(const VerIterator &B) const
 740 {
 741    // Check if they are equal
 742    if (*this == B)
 743       return 0;
 744    if (end() == true)
 745       return -1;
 746    if (B.end() == true)
 747       return 1;
 748
 749    /* Start at A and look for B. If B is found then A > B otherwise
 750       B was before A so A < B */
 751    VerIterator I = *this;
 752    for (;I.end() == false; ++I)
 753       if (I == B)
 754          return 1;
 755    return -1;
 756 }
 757                                                                         /*}}}*/
 758 // VerIterator::Downloadable - Checks if the version is downloadable    /*{{{*/
 759 // ---------------------------------------------------------------------
 760 /* */
 761 bool pkgCache::VerIterator::Downloadable() const
 762 {
 763    VerFileIterator Files = FileList();
 764    for (; Files.end() == false; ++Files)
 765       if ((Files.File()->Flags & pkgCache::Flag::NotSource) != pkgCache::Flag::NotSource)
 766          return true;
 767    return false;
 768 }
 769                                                                         /*}}}*/
 770 // VerIterator::Automatic - Check if this version is 'automatic'        /*{{{*/
 771 // ---------------------------------------------------------------------
 772 /* This checks to see if any of the versions files are not NotAutomatic.
 773    True if this version is selectable for automatic installation. */
 774 bool pkgCache::VerIterator::Automatic() const
 775 {
 776    VerFileIterator Files = FileList();
 777    for (; Files.end() == false; ++Files)
 778       // Do not check ButAutomaticUpgrades here as it is kind of automatic…
 779       if ((Files.File()->Flags & pkgCache::Flag::NotAutomatic) != pkgCache::Flag::NotAutomatic)
 780          return true;
 781    return false;
 782 }
 783                                                                         /*}}}*/
 784 // VerIterator::NewestFile - Return the newest file version relation    /*{{{*/
 785 // ---------------------------------------------------------------------
 786 /* This looks at the version numbers associated with all of the sources
 787    this version is in and returns the highest.*/
 788 pkgCache::VerFileIterator pkgCache::VerIterator::NewestFile() const
 789 {
 790    VerFileIterator Files = FileList();
 791    VerFileIterator Highest = Files;
 792    for (; Files.end() == false; ++Files)
 793    {
 794       if (Owner->VS->CmpReleaseVer(Files.File().Version(),Highest.File().Version()) > 0)
 795          Highest = Files;
 796    }
 797
 798    return Highest;
 799 }
 800                                                                         /*}}}*/
 801 // VerIterator::RelStr - Release description string                     /*{{{*/
 802 // ---------------------------------------------------------------------
 803 /* This describes the version from a release-centric manner. The output is a
 804    list of Label:Version/Archive */
 805 string pkgCache::VerIterator::RelStr() const
 806 {
 807    bool First = true;
 808    string Res;
 809    for (pkgCache::VerFileIterator I = this->FileList(); I.end() == false; ++I)
 810    {
 811       // Do not print 'not source' entries'
 812       pkgCache::PkgFileIterator File = I.File();
 813       if ((File->Flags & pkgCache::Flag::NotSource) == pkgCache::Flag::NotSource)
 814          continue;
 815
 816       // See if we have already printed this out..
 817       bool Seen = false;
 818       for (pkgCache::VerFileIterator J = this->FileList(); I != J; ++J)
 819       {
 820          pkgCache::PkgFileIterator File2 = J.File();
 821          if (File2->Label == 0 || File->Label == 0)
 822             continue;
 823
 824          if (strcmp(File.Label(),File2.Label()) != 0)
 825             continue;
 826
 827          if (File2->Version == File->Version)
 828          {
 829             Seen = true;
 830             break;
 831          }
 832          if (File2->Version == 0 || File->Version == 0)
 833             break;
 834          if (strcmp(File.Version(),File2.Version()) == 0)
 835             Seen = true;
 836       }
 837
 838       if (Seen == true)
 839          continue;
 840
 841       if (First == false)
 842          Res += ", ";
 843       else
 844          First = false;
 845
 846       if (File->Label != 0)
 847          Res = Res + File.Label() + ':';
 848
 849       if (File->Archive != 0)
 850       {
 851          if (File->Version == 0)
 852             Res += File.Archive();
 853          else
 854             Res = Res + File.Version() + '/' +  File.Archive();
 855       }
 856       else
 857       {
 858          // No release file, print the host name that this came from
 859          if (File->Site == 0 || File.Site()[0] == 0)
 860             Res += "localhost";
 861          else
 862             Res += File.Site();
 863       }
 864    }
 865    if (S->ParentPkg != 0)
 866       Res.append(" [").append(Arch()).append("]");
 867    return Res;
 868 }
 869                                                                         /*}}}*/
 870 // PkgFileIterator::IsOk - Checks if the cache is in sync with the file /*{{{*/
 871 // ---------------------------------------------------------------------
 872 /* This stats the file and compares its stats with the ones that were
 873    stored during generation. Date checks should probably also be
 874    included here. */
 875 bool pkgCache::PkgFileIterator::IsOk()
 876 {
 877    struct stat Buf;
 878    if (stat(FileName(),&Buf) != 0)
 879       return false;
 880
 881    if (Buf.st_size != (signed)S->Size || Buf.st_mtime != S->mtime)
 882       return false;
 883
 884    return true;
 885 }
 886                                                                         /*}}}*/
 887 // PkgFileIterator::RelStr - Return the release string                  /*{{{*/
 888 // ---------------------------------------------------------------------
 889 /* */
 890 string pkgCache::PkgFileIterator::RelStr()
 891 {
 892    string Res;
 893    if (Version() != 0)
 894       Res = Res + (Res.empty() == true?"v=":",v=") + Version();
 895    if (Origin() != 0)
 896       Res = Res + (Res.empty() == true?"o=":",o=")  + Origin();
 897    if (Archive() != 0)
 898       Res = Res + (Res.empty() == true?"a=":",a=")  + Archive();
 899    if (Codename() != 0)
 900       Res = Res + (Res.empty() == true?"n=":",n=")  + Codename();
 901    if (Label() != 0)
 902       Res = Res + (Res.empty() == true?"l=":",l=")  + Label();
 903    if (Component() != 0)
 904       Res = Res + (Res.empty() == true?"c=":",c=")  + Component();
 905    if (Architecture() != 0)
 906       Res = Res + (Res.empty() == true?"b=":",b=")  + Architecture();
 907    return Res;
 908 }
 909                                                                         /*}}}*/
 910 // VerIterator::TranslatedDescription - Return the a DescIter for locale/*{{{*/
 911 // ---------------------------------------------------------------------
 912 /* return a DescIter for the current locale or the default if none is
 913  * found
 914  */
 915 pkgCache::DescIterator pkgCache::VerIterator::TranslatedDescription() const
 916 {
 917    std::vector<string> const lang = APT::Configuration::getLanguages();
 918    for (std::vector<string>::const_iterator l = lang.begin();
 919         l != lang.end(); ++l)
 920    {
 921       pkgCache::DescIterator Desc = DescriptionList();
 922       for (; Desc.end() == false; ++Desc)
 923          if (*l == Desc.LanguageCode())
 924             break;
 925       if (Desc.end() == true)
 926       {
 927          if (*l == "en")
 928          {
 929             Desc = DescriptionList();
 930             for (; Desc.end() == false; ++Desc)
 931                if (strcmp(Desc.LanguageCode(), "") == 0)
 932                   break;
 933             if (Desc.end() == true)
 934                continue;
 935          }
 936          else
 937             continue;
 938       }
 939       return Desc;
 940    }
 941    for (pkgCache::DescIterator Desc = DescriptionList();
 942         Desc.end() == false; ++Desc)
 943       if (strcmp(Desc.LanguageCode(), "") == 0)
 944          return Desc;
 945    return DescriptionList();
 946 };
 947
 948                                                                         /*}}}*/