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