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