HCoop / ntk / apt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Http download fixes
[ntk/apt.git] / apt-pkg / pkgcachegen.cc
CommitLineData
578bfd0a
AL		 1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
a9e5851b 3// $Id: pkgcachegen.cc,v 1.30 1999/02/23 06:50:36 jgg Exp $
578bfd0a
AL		 4/* ######################################################################
5
6 Package Cache Generator - Generator for the cache structure.
7
8 This builds the cache structure from the abstract package list parser.
9
10 ##################################################################### */
11 /*}}}*/
12// Include Files /*{{{*/
6c139d6e 13#ifdef __GNUG__
094a497d 14#pragma implementation "apt-pkg/pkgcachegen.h"
6c139d6e
AL		 15#endif
16
094a497d
AL		 17#include <apt-pkg/pkgcachegen.h>
18#include <apt-pkg/error.h>
19#include <apt-pkg/version.h>
b35d2f5f
AL		 20#include <apt-pkg/progress.h>
21#include <apt-pkg/sourcelist.h>
22#include <apt-pkg/configuration.h>
23#include <apt-pkg/deblistparser.h>
cdcc6d34 24#include <apt-pkg/strutl.h>
f9eec0e7 25#include <system.h>
578bfd0a
AL		 26
27#include <sys/stat.h>
28#include <unistd.h>
29 /*}}}*/
30
31// CacheGenerator::pkgCacheGenerator - Constructor /*{{{*/
32// ---------------------------------------------------------------------
33/* We set the diry flag and make sure that is written to the disk */
404ec98e
AL		 34pkgCacheGenerator::pkgCacheGenerator(DynamicMMap &Map,OpProgress &Prog) :
35 Map(Map), Cache(Map), Progress(Prog)
578bfd0a
AL		 36{
37 if (_error->PendingError() == true)
38 return;
39
40 if (Map.Size() == 0)
41 {
42 Map.RawAllocate(sizeof(pkgCache::Header));
43 *Cache.HeaderP = pkgCache::Header();
44 }
45 Cache.HeaderP->Dirty = true;
46 Map.Sync(0,sizeof(pkgCache::Header));
47 Map.UsePools(*Cache.HeaderP->Pools,sizeof(Cache.HeaderP->Pools)/sizeof(Cache.HeaderP->Pools[0]));
f9eec0e7 48 memset(UniqHash,0,sizeof(UniqHash));
578bfd0a
AL		 49}
50 /*}}}*/
51// CacheGenerator::~pkgCacheGenerator - Destructor /*{{{*/
52// ---------------------------------------------------------------------
53/* We sync the data then unset the dirty flag in two steps so as to
54 advoid a problem during a crash */
55pkgCacheGenerator::~pkgCacheGenerator()
56{
57 if (_error->PendingError() == true)
58 return;
59 if (Map.Sync() == false)
60 return;
61
62 Cache.HeaderP->Dirty = false;
63 Map.Sync(0,sizeof(pkgCache::Header));
64}
65 /*}}}*/
66// CacheGenerator::MergeList - Merge the package list /*{{{*/
67// ---------------------------------------------------------------------
68/* This provides the generation of the entries in the cache. Each loop
69 goes through a single package record from the underlying parse engine. */
70bool pkgCacheGenerator::MergeList(ListParser &List)
71{
72 List.Owner = this;
0149949b 73
f9eec0e7 74 unsigned int Counter = 0;
0149949b 75 while (List.Step() == true)
578bfd0a
AL		 76 {
77 // Get a pointer to the package structure
9ddf7030 78 string PackageName = List.Package();
65a1e968
AL		 79 if (PackageName.empty() == true)
80 return false;
81
9ddf7030 82 pkgCache::PkgIterator Pkg;
8efa2a3b 83 if (NewPackage(Pkg,PackageName) == false)
b35d2f5f 84 return _error->Error("Error occured while processing %s (NewPackage)",PackageName.c_str());
a246f2dc
AL		 85 Counter++;
86 if (Counter % 100 == 0)
87 Progress.Progress(List.Offset());
8ce4327b 88
578bfd0a
AL		 89 /* Get a pointer to the version structure. We know the list is sorted
90 so we use that fact in the search. Insertion of new versions is
91 done with correct sorting */
92 string Version = List.Version();
f55a958f
AL		 93 if (Version.empty() == true)
94 {
95 if (List.UsePackage(Pkg,pkgCache::VerIterator(Cache)) == false)
b35d2f5f 96 return _error->Error("Error occured while processing %s (UsePackage1)",PackageName.c_str());
f55a958f
AL		 97 continue;
98 }
99
578bfd0a 100 pkgCache::VerIterator Ver = Pkg.VersionList();
031aa375 101 __apt_ptrloc *Last = &Pkg->VersionList;
2246928b 102 int Res = 1;
f55a958f 103 for (; Ver.end() == false; Last = &Ver->NextVer, Ver++)
578bfd0a
AL		 104 {
105 Res = pkgVersionCompare(Version.begin(),Version.end(),Ver.VerStr(),
106 Ver.VerStr() + strlen(Ver.VerStr()));
107 if (Res >= 0)
108 break;
109 }
110
111 /* We already have a version for this item, record that we
112 saw it */
113 if (Res == 0)
114 {
f55a958f 115 if (List.UsePackage(Pkg,Ver) == false)
b35d2f5f 116 return _error->Error("Error occured while processing %s (UsePackage2)",PackageName.c_str());
f55a958f 117
578bfd0a 118 if (NewFileVer(Ver,List) == false)
b35d2f5f 119 return _error->Error("Error occured while processing %s (NewFileVer1)",PackageName.c_str());
578bfd0a
AL		 120
121 continue;
122 }
123
124 // Add a new version
f55a958f
AL		 125 *Last = NewVersion(Ver,Version,*Last);
126 Ver->ParentPkg = Pkg.Index();
578bfd0a 127 if (List.NewVersion(Ver) == false)
b35d2f5f 128 return _error->Error("Error occured while processing %s (NewVersion1)",PackageName.c_str());
0149949b 129
f55a958f 130 if (List.UsePackage(Pkg,Ver) == false)
b35d2f5f 131 return _error->Error("Error occured while processing %s (UsePackage3)",PackageName.c_str());
f55a958f 132
578bfd0a 133 if (NewFileVer(Ver,List) == false)
b35d2f5f 134 return _error->Error("Error occured while processing %s (NewVersion2)",PackageName.c_str());
578bfd0a 135 }
0149949b 136
578bfd0a
AL		 137 return true;
138}
139 /*}}}*/
140// CacheGenerator::NewPackage - Add a new package /*{{{*/
141// ---------------------------------------------------------------------
142/* This creates a new package structure and adds it to the hash table */
f55a958f 143bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,string Name)
578bfd0a 144{
8efa2a3b
AL		 145 Pkg = Cache.FindPkg(Name);
146 if (Pkg.end() == false)
147 return true;
148
578bfd0a
AL		 149 // Get a structure
150 unsigned long Package = Map.Allocate(sizeof(pkgCache::Package));
151 if (Package == 0)
152 return false;
153
f55a958f 154 Pkg = pkgCache::PkgIterator(Cache,Cache.PkgP + Package);
578bfd0a
AL		 155
156 // Insert it into the hash table
f55a958f 157 unsigned long Hash = Cache.Hash(Name);
578bfd0a
AL		 158 Pkg->NextPackage = Cache.HeaderP->HashTable[Hash];
159 Cache.HeaderP->HashTable[Hash] = Package;
160
161 // Set the name and the ID
162 Pkg->Name = Map.WriteString(Name);
163 if (Pkg->Name == 0)
164 return false;
165 Pkg->ID = Cache.HeaderP->PackageCount++;
166
167 return true;
168}
169 /*}}}*/
170// CacheGenerator::NewFileVer - Create a new File<->Version association /*{{{*/
171// ---------------------------------------------------------------------
172/* */
f55a958f 173bool pkgCacheGenerator::NewFileVer(pkgCache::VerIterator &Ver,
578bfd0a
AL		 174 ListParser &List)
175{
dcb79bae
AL		 176 // Get a structure
177 unsigned long VerFile = Map.Allocate(sizeof(pkgCache::VerFile));
178 if (VerFile == 0)
179 return 0;
180
181 pkgCache::VerFileIterator VF(Cache,Cache.VerFileP + VerFile);
182 VF->File = CurrentFile - Cache.PkgFileP;
03e39e59
AL		 183
184 // Link it to the end of the list
185 __apt_ptrloc *Last = &Ver->FileList;
186 for (pkgCache::VerFileIterator V = Ver.FileList(); V.end() == false; V++)
187 Last = &V->NextFile;
188 VF->NextFile = *Last;
189 *Last = VF.Index();
190
dcb79bae
AL		 191 VF->Offset = List.Offset();
192 VF->Size = List.Size();
ad00ae81
AL		 193 if (Cache.HeaderP->MaxVerFileSize < VF->Size)
194 Cache.HeaderP->MaxVerFileSize = VF->Size;
a7e66b17
AL		 195 Cache.HeaderP->VerFileCount++;
196
f55a958f 197 return true;
578bfd0a
AL		 198}
199 /*}}}*/
200// CacheGenerator::NewVersion - Create a new Version /*{{{*/
201// ---------------------------------------------------------------------
f55a958f 202/* This puts a version structure in the linked list */
578bfd0a 203unsigned long pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
f55a958f 204 string VerStr,
578bfd0a
AL		 205 unsigned long Next)
206{
f55a958f
AL		 207 // Get a structure
208 unsigned long Version = Map.Allocate(sizeof(pkgCache::Version));
209 if (Version == 0)
0149949b 210 return 0;
f55a958f
AL		 211
212 // Fill it in
213 Ver = pkgCache::VerIterator(Cache,Cache.VerP + Version);
f55a958f
AL		 214 Ver->NextVer = Next;
215 Ver->ID = Cache.HeaderP->VersionCount++;
216 Ver->VerStr = Map.WriteString(VerStr);
217 if (Ver->VerStr == 0)
0149949b 218 return 0;
f55a958f 219
0149949b 220 return Version;
578bfd0a
AL		 221}
222 /*}}}*/
dcb79bae
AL		 223// ListParser::NewDepends - Create a dependency element /*{{{*/
224// ---------------------------------------------------------------------
225/* This creates a dependency element in the tree. It is linked to the
226 version and to the package that it is pointing to. */
227bool pkgCacheGenerator::ListParser::NewDepends(pkgCache::VerIterator Ver,
9ddf7030
AL		 228 string PackageName,
229 string Version,
dcb79bae
AL		 230 unsigned int Op,
231 unsigned int Type)
232{
233 pkgCache &Cache = Owner->Cache;
234
235 // Get a structure
236 unsigned long Dependency = Owner->Map.Allocate(sizeof(pkgCache::Dependency));
237 if (Dependency == 0)
238 return false;
239
240 // Fill it in
241 pkgCache::DepIterator Dep(Cache,Cache.DepP + Dependency);
242 Dep->ParentVer = Ver.Index();
243 Dep->Type = Type;
244 Dep->CompareOp = Op;
245 Dep->ID = Cache.HeaderP->DependsCount++;
246
247 // Locate the target package
8efa2a3b
AL		 248 pkgCache::PkgIterator Pkg;
249 if (Owner->NewPackage(Pkg,PackageName) == false)
250 return false;
dcb79bae
AL		 251
252 // Probe the reverse dependency list for a version string that matches
253 if (Version.empty() == false)
254 {
f9eec0e7 255/* for (pkgCache::DepIterator I = Pkg.RevDependsList(); I.end() == false; I++, Hit++)
dcb79bae 256 if (I->Version != 0 && I.TargetVer() == Version)
f9eec0e7 257 Dep->Version = I->Version;*/
dcb79bae
AL		 258 if (Dep->Version == 0)
259 if ((Dep->Version = WriteString(Version)) == 0)
260 return false;
261 }
c1a22377 262
dcb79bae
AL		 263 // Link it to the package
264 Dep->Package = Pkg.Index();
265 Dep->NextRevDepends = Pkg->RevDepends;
266 Pkg->RevDepends = Dep.Index();
267
c1a22377
AL		 268 /* Link it to the version (at the end of the list)
269 Caching the old end point speeds up generation substantially */
f9eec0e7 270 if (OldDepVer != Ver)
c1a22377 271 {
f9eec0e7 272 OldDepLast = &Ver->DependsList;
c1a22377 273 for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; D++)
f9eec0e7
AL		 274 OldDepLast = &D->NextDepends;
275 OldDepVer = Ver;
c1a22377 276 }
dcb79bae 277
f9eec0e7
AL		 278 Dep->NextDepends = *OldDepLast;
279 *OldDepLast = Dep.Index();
280 OldDepLast = &Dep->NextDepends;
c1a22377 281
dcb79bae
AL		 282 return true;
283}
284 /*}}}*/
285// ListParser::NewProvides - Create a Provides element /*{{{*/
286// ---------------------------------------------------------------------
287/* */
288bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator Ver,
8efa2a3b 289 string PackageName,
9ddf7030 290 string Version)
dcb79bae
AL		 291{
292 pkgCache &Cache = Owner->Cache;
8efa2a3b
AL		 293
294 // We do not add self referencing provides
295 if (Ver.ParentPkg().Name() == PackageName)
296 return true;
dcb79bae
AL		 297
298 // Get a structure
299 unsigned long Provides = Owner->Map.Allocate(sizeof(pkgCache::Provides));
300 if (Provides == 0)
301 return false;
a7e66b17 302 Cache.HeaderP->ProvidesCount++;
dcb79bae
AL		 303
304 // Fill it in
305 pkgCache::PrvIterator Prv(Cache,Cache.ProvideP + Provides,Cache.PkgP);
306 Prv->Version = Ver.Index();
307 Prv->NextPkgProv = Ver->ProvidesList;
308 Ver->ProvidesList = Prv.Index();
309 if (Version.empty() == false && (Prv->Version = WriteString(Version)) == 0)
310 return false;
311
312 // Locate the target package
8efa2a3b
AL		 313 pkgCache::PkgIterator Pkg;
314 if (Owner->NewPackage(Pkg,PackageName) == false)
315 return false;
dcb79bae
AL		 316
317 // Link it to the package
318 Prv->ParentPkg = Pkg.Index();
319 Prv->NextProvides = Pkg->ProvidesList;
320 Pkg->ProvidesList = Prv.Index();
321
322 return true;
323}
324 /*}}}*/
578bfd0a
AL		 325// CacheGenerator::SelectFile - Select the current file being parsed /*{{{*/
326// ---------------------------------------------------------------------
327/* This is used to select which file is to be associated with all newly
328 added versions. */
329bool pkgCacheGenerator::SelectFile(string File,unsigned long Flags)
330{
331 struct stat Buf;
332 if (stat(File.c_str(),&Buf) == -1)
333 return _error->Errno("stat","Couldn't stat ",File.c_str());
334
335 // Get some space for the structure
336 CurrentFile = Cache.PkgFileP + Map.Allocate(sizeof(*CurrentFile));
337 if (CurrentFile == Cache.PkgFileP)
338 return false;
339
340 // Fill it in
341 CurrentFile->FileName = Map.WriteString(File);
342 CurrentFile->Size = Buf.st_size;
343 CurrentFile->mtime = Buf.st_mtime;
344 CurrentFile->NextFile = Cache.HeaderP->FileList;
345 CurrentFile->Flags = Flags;
e1b74f61 346 CurrentFile->ID = Cache.HeaderP->PackageFileCount;
578bfd0a 347 PkgFileName = File;
ad00ae81 348 Cache.HeaderP->FileList = CurrentFile - Cache.PkgFileP;
b35d2f5f
AL		 349 Cache.HeaderP->PackageFileCount++;
350
578bfd0a
AL		 351 if (CurrentFile->FileName == 0)
352 return false;
404ec98e 353
8ce4327b 354 Progress.SubProgress(Buf.st_size);
8efa2a3b 355 return true;
578bfd0a
AL		 356}
357 /*}}}*/
f55a958f
AL		 358// CacheGenerator::WriteUniqueString - Insert a unique string /*{{{*/
359// ---------------------------------------------------------------------
360/* This is used to create handles to strings. Given the same text it
361 always returns the same number */
362unsigned long pkgCacheGenerator::WriteUniqString(const char *S,
363 unsigned int Size)
364{
f9eec0e7
AL		 365 /* We use a very small transient hash table here, this speeds up generation
366 by a fair amount on slower machines */
367 pkgCache::StringItem *&Bucket = UniqHash[(S[0]*5 + S[1]) % _count(UniqHash)];
368 if (Bucket != 0 &&
369 stringcmp(S,S+Size,Cache.StrP + Bucket->String) == 0)
370 return Bucket->String;
371
f55a958f
AL		 372 // Search for an insertion point
373 pkgCache::StringItem *I = Cache.StringItemP + Cache.HeaderP->StringList;
374 int Res = 1;
031aa375 375 __apt_ptrloc *Last = &Cache.HeaderP->StringList;
f55a958f
AL		 376 for (; I != Cache.StringItemP; Last = &I->NextItem,
377 I = Cache.StringItemP + I->NextItem)
378 {
9c14e3d6 379 Res = stringcmp(S,S+Size,Cache.StrP + I->String);
f55a958f
AL		 380 if (Res >= 0)
381 break;
382 }
383
384 // Match
385 if (Res == 0)
f9eec0e7
AL		 386 {
387 Bucket = I;
0149949b 388 return I->String;
f9eec0e7 389 }
f55a958f
AL		 390
391 // Get a structure
392 unsigned long Item = Map.Allocate(sizeof(pkgCache::StringItem));
393 if (Item == 0)
0149949b
AL		 394 return 0;
395
f55a958f
AL		 396 // Fill in the structure
397 pkgCache::StringItem *ItemP = Cache.StringItemP + Item;
398 ItemP->NextItem = I - Cache.StringItemP;
399 *Last = Item;
400 ItemP->String = Map.WriteString(S,Size);
401 if (ItemP->String == 0)
0149949b 402 return 0;
f55a958f 403
f9eec0e7 404 Bucket = ItemP;
0149949b 405 return ItemP->String;
f55a958f
AL		 406}
407 /*}}}*/
b35d2f5f
AL		 408
409// SrcCacheCheck - Check if the source package cache is uptodate /*{{{*/
410// ---------------------------------------------------------------------
411/* The source cache is checked against the source list and the files
412 on disk, any difference results in a false. */
413bool pkgSrcCacheCheck(pkgSourceList &List)
414{
415 if (_error->PendingError() == true)
416 return false;
e1b74f61 417
3b5421b4 418 string CacheFile = _config->FindFile("Dir::Cache::srcpkgcache");
0919e3f9 419 string ListDir = _config->FindDir("Dir::State::lists");
e1b74f61
AL		 420
421 // Count the number of missing files
422 int Missing = 0;
423 for (pkgSourceList::const_iterator I = List.begin(); I != List.end(); I++)
424 {
425 string File = ListDir + URItoFileName(I->PackagesURI());
426 struct stat Buf;
427 if (stat(File.c_str(),&Buf) != 0)
428 {
429 _error->WarningE("stat","Couldn't stat source package list '%s' (%s)",
430 I->PackagesInfo().c_str(),File.c_str());
431 Missing++;
432 }
433 }
434
435 // Open the source package cache
b35d2f5f
AL		 436 if (FileExists(CacheFile) == false)
437 return false;
438
439 FileFd CacheF(CacheFile,FileFd::ReadOnly);
440 if (_error->PendingError() == true)
441 {
442 _error->Discard();
443 return false;
444 }
445
446 MMap Map(CacheF,MMap::Public | MMap::ReadOnly);
0a8e3465 447 if (_error->PendingError() == true || Map.Size() == 0)
b35d2f5f
AL		 448 {
449 _error->Discard();
450 return false;
451 }
452
453 pkgCache Cache(Map);
454 if (_error->PendingError() == true)
455 {
456 _error->Discard();
457 return false;
458 }
c5162d56 459
b35d2f5f 460 // They are certianly out of sync
c5162d56 461 if (Cache.Head().PackageFileCount != List.size() - Missing)
b35d2f5f
AL		 462 return false;
463
464 for (pkgCache::PkgFileIterator F(Cache); F.end() == false; F++)
465 {
466 // Search for a match in the source list
467 bool Bad = true;
468 for (pkgSourceList::const_iterator I = List.begin();
469 I != List.end(); I++)
470 {
471 string File = ListDir + URItoFileName(I->PackagesURI());
472 if (F.FileName() == File)
473 {
474 Bad = false;
475 break;
476 }
477 }
478
479 // Check if the file matches what was cached
480 Bad |= !F.IsOk();
481 if (Bad == true)
482 return false;
483 }
484
485 return true;
486}
487 /*}}}*/
488// PkgCacheCheck - Check if the package cache is uptodate /*{{{*/
489// ---------------------------------------------------------------------
490/* This does a simple check of all files used to compose the cache */
491bool pkgPkgCacheCheck(string CacheFile)
492{
493 if (_error->PendingError() == true)
494 return false;
495
496 // Open the source package cache
497 if (FileExists(CacheFile) == false)
498 return false;
499
500 FileFd CacheF(CacheFile,FileFd::ReadOnly);
501 if (_error->PendingError() == true)
502 {
503 _error->Discard();
504 return false;
505 }
506
507 MMap Map(CacheF,MMap::Public | MMap::ReadOnly);
0a8e3465 508 if (_error->PendingError() == true || Map.Size() == 0)
b35d2f5f
AL		 509 {
510 _error->Discard();
511 return false;
512 }
513
514 pkgCache Cache(Map);
515 if (_error->PendingError() == true)
516 {
517 _error->Discard();
518 return false;
519 }
520
0118833a
AL		 521 // Status files that must be in the cache
522 string Status[3];
3b5421b4
AL		 523 Status[0] = _config->FindFile("Dir::State::xstatus");
524 Status[1]= _config->FindFile("Dir::State::userstatus");
525 Status[2] = _config->FindFile("Dir::State::status");
0118833a 526
b35d2f5f
AL		 527 // Cheack each file
528 for (pkgCache::PkgFileIterator F(Cache); F.end() == false; F++)
0118833a 529 {
b35d2f5f
AL		 530 if (F.IsOk() == false)
531 return false;
0118833a
AL		 532
533 // See if this is one of the status files
534 for (int I = 0; I != 3; I++)
535 if (F.FileName() == Status[I])
536 Status[I] = string();
537 }
538
539 // Make sure all the status files are loaded.
540 for (int I = 0; I != 3; I++)
541 {
542 if (Status[I].empty() == false && FileExists(Status[I]) == true)
543 return false;
544 }
545
b35d2f5f
AL		 546 return true;
547}
548 /*}}}*/
549// AddSourcesSize - Add the size of the status files /*{{{*/
550// ---------------------------------------------------------------------
551/* This adds the size of all the status files to the size counter */
552static bool pkgAddSourcesSize(unsigned long &TotalSize)
553{
554 // Grab the file names
3b5421b4
AL		 555 string xstatus = _config->FindFile("Dir::State::xstatus");
556 string userstatus = _config->FindFile("Dir::State::userstatus");
557 string status = _config->FindFile("Dir::State::status");
b35d2f5f
AL		 558
559 // Grab the sizes
560 struct stat Buf;
561 if (stat(xstatus.c_str(),&Buf) == 0)
562 TotalSize += Buf.st_size;
563 if (stat(userstatus.c_str(),&Buf) == 0)
564 TotalSize += Buf.st_size;
565 if (stat(status.c_str(),&Buf) != 0)
566 return _error->Errno("stat","Couldn't stat the status file %s",status.c_str());
567 TotalSize += Buf.st_size;
568
569 return true;
570}
571 /*}}}*/
572// MergeStatus - Add the status files to the cache /*{{{*/
573// ---------------------------------------------------------------------
574/* This adds the status files to the map */
575static bool pkgMergeStatus(OpProgress &Progress,pkgCacheGenerator &Gen,
576 unsigned long &CurrentSize,unsigned long TotalSize)
577{
578 // Grab the file names
579 string Status[3];
3b5421b4
AL		 580 Status[0] = _config->FindFile("Dir::State::xstatus");
581 Status[1]= _config->FindFile("Dir::State::userstatus");
582 Status[2] = _config->FindFile("Dir::State::status");
b35d2f5f
AL		 583
584 for (int I = 0; I != 3; I++)
585 {
586 // Check if the file exists and it is not the primary status file.
587 string File = Status[I];
588 if (I != 2 && FileExists(File) == false)
589 continue;
590
591 FileFd Pkg(File,FileFd::ReadOnly);
592 debListParser Parser(Pkg);
8ce4327b 593 Progress.OverallProgress(CurrentSize,TotalSize,Pkg.Size(),"Reading Package Lists");
b35d2f5f
AL		 594 if (_error->PendingError() == true)
595 return _error->Error("Problem opening %s",File.c_str());
596 CurrentSize += Pkg.Size();
8ce4327b
AL		 597
598 Progress.SubProgress(0,"Local Package State - " + flNotDir(File));
b35d2f5f
AL		 599 if (Gen.SelectFile(File,pkgCache::Flag::NotSource) == false)
600 return _error->Error("Problem with SelectFile %s",File.c_str());
601
602 if (Gen.MergeList(Parser) == false)
603 return _error->Error("Problem with MergeList %s",File.c_str());
8ce4327b 604 Progress.Progress(Pkg.Size());
b35d2f5f
AL		 605 }
606
607 return true;
608}
609 /*}}}*/
610// MakeStatusCache - Generates a cache that includes the status files /*{{{*/
611// ---------------------------------------------------------------------
612/* This copies the package source cache and then merges the status and
613 xstatus files into it. */
614bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress)
615{
8ce4327b
AL		 616 Progress.OverallProgress(0,1,1,"Reading Package Lists");
617
3b5421b4 618 string CacheFile = _config->FindFile("Dir::Cache::pkgcache");
b35d2f5f 619 bool SrcOk = pkgSrcCacheCheck(List);
0a8e3465 620 bool PkgOk = SrcOk && pkgPkgCacheCheck(CacheFile);
b35d2f5f
AL		 621
622 // Rebuild the source and package caches
623 if (SrcOk == false)
624 {
3b5421b4 625 string SCacheFile = _config->FindFile("Dir::Cache::srcpkgcache");
0919e3f9 626 string ListDir = _config->FindDir("Dir::State::lists");
b35d2f5f
AL		 627 FileFd SCacheF(SCacheFile,FileFd::WriteEmpty);
628 FileFd CacheF(CacheFile,FileFd::WriteEmpty);
629 DynamicMMap Map(CacheF,MMap::Public);
630 if (_error->PendingError() == true)
631 return false;
632
633 pkgCacheGenerator Gen(Map,Progress);
634
635 // Prepare the progress indicator
636 unsigned long TotalSize = 0;
637 struct stat Buf;
638 for (pkgSourceList::const_iterator I = List.begin(); I != List.end(); I++)
639 {
640 string File = ListDir + URItoFileName(I->PackagesURI());
641 if (stat(File.c_str(),&Buf) != 0)
c5162d56 642 continue;
b35d2f5f
AL		 643 TotalSize += Buf.st_size;
644 }
645
646 if (pkgAddSourcesSize(TotalSize) == false)
647 return false;
648
649 // Generate the pkg source cache
650 unsigned long CurrentSize = 0;
651 for (pkgSourceList::const_iterator I = List.begin(); I != List.end(); I++)
652 {
653 string File = ListDir + URItoFileName(I->PackagesURI());
b0b4efb9
AL		 654
655 if (FileExists(File) == false)
c5162d56
AL		 656 continue;
657
b35d2f5f
AL		 658 FileFd Pkg(File,FileFd::ReadOnly);
659 debListParser Parser(Pkg);
8ce4327b 660 Progress.OverallProgress(CurrentSize,TotalSize,Pkg.Size(),"Reading Package Lists");
b35d2f5f
AL		 661 if (_error->PendingError() == true)
662 return _error->Error("Problem opening %s",File.c_str());
663 CurrentSize += Pkg.Size();
664
8ce4327b 665 Progress.SubProgress(0,I->PackagesInfo());
b35d2f5f
AL		 666 if (Gen.SelectFile(File) == false)
667 return _error->Error("Problem with SelectFile %s",File.c_str());
668
669 if (Gen.MergeList(Parser) == false)
670 return _error->Error("Problem with MergeList %s",File.c_str());
b0b4efb9
AL		 671
672 // Check the release file
673 string RFile = ListDir + URItoFileName(I->ReleaseURI());
674 if (FileExists(RFile) == true)
675 {
676 FileFd Rel(RFile,FileFd::ReadOnly);
677 if (_error->PendingError() == true)
678 return false;
679 Parser.LoadReleaseInfo(Gen.GetCurFile(),Rel);
680 }
b35d2f5f
AL		 681 }
682
683 // Write the src cache
684 Gen.GetCache().HeaderP->Dirty = false;
685 if (SCacheF.Write(Map.Data(),Map.Size()) == false)
686 return _error->Error("IO Error saving source cache");
687 Gen.GetCache().HeaderP->Dirty = true;
688
689 // Merge in the source caches
690 return pkgMergeStatus(Progress,Gen,CurrentSize,TotalSize);
691 }
692
693 if (PkgOk == true)
8ce4327b
AL		 694 {
695 Progress.OverallProgress(1,1,1,"Reading Package Lists");
b35d2f5f 696 return true;
8ce4327b 697 }
b35d2f5f
AL		 698
699 // We use the source cache to generate the package cache
3b5421b4 700 string SCacheFile = _config->FindFile("Dir::Cache::srcpkgcache");
b35d2f5f
AL		 701
702 FileFd SCacheF(SCacheFile,FileFd::ReadOnly);
703 FileFd CacheF(CacheFile,FileFd::WriteEmpty);
704 DynamicMMap Map(CacheF,MMap::Public);
705 if (_error->PendingError() == true)
706 return false;
707
708 // Preload the map with the source cache
709 if (SCacheF.Read((unsigned char *)Map.Data() + Map.RawAllocate(SCacheF.Size()),
710 SCacheF.Size()) == false)
711 return false;
712
713 pkgCacheGenerator Gen(Map,Progress);
714
715 // Compute the progress
716 unsigned long TotalSize = 0;
717 if (pkgAddSourcesSize(TotalSize) == false)
718 return false;
719
720 unsigned long CurrentSize = 0;
721 return pkgMergeStatus(Progress,Gen,CurrentSize,TotalSize);
722}
723 /*}}}*/
ntk's bugfix for apt