apt-pkg/pkgcache.cc

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