Commit | Line | Data |
---|---|---|
578bfd0a AL |
1 | // -*- mode: cpp; mode: fold -*- |
2 | // Description /*{{{*/ | |
6f86c974 | 3 | // $Id: pkgcachegen.cc,v 1.32 1999/03/06 02:13:48 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 |
34 | pkgCacheGenerator::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 */ | |
55 | pkgCacheGenerator::~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. */ | |
70 | bool 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 | 143 | bool 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 | 173 | bool 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 | 203 | unsigned 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. */ | |
227 | bool 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 | /* */ | |
288 | bool 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. */ | |
329 | bool 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 */ | |
362 | unsigned 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. */ | |
413 | bool 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 | { | |
be8922fd AL |
425 | // Only cache deb source types. |
426 | if (I->Type != pkgSourceList::Item::Deb) | |
6f86c974 AL |
427 | { |
428 | Missing++; | |
be8922fd | 429 | continue; |
6f86c974 | 430 | } |
be8922fd | 431 | |
e1b74f61 AL |
432 | string File = ListDir + URItoFileName(I->PackagesURI()); |
433 | struct stat Buf; | |
434 | if (stat(File.c_str(),&Buf) != 0) | |
435 | { | |
436 | _error->WarningE("stat","Couldn't stat source package list '%s' (%s)", | |
437 | I->PackagesInfo().c_str(),File.c_str()); | |
438 | Missing++; | |
439 | } | |
440 | } | |
441 | ||
442 | // Open the source package cache | |
b35d2f5f AL |
443 | if (FileExists(CacheFile) == false) |
444 | return false; | |
445 | ||
446 | FileFd CacheF(CacheFile,FileFd::ReadOnly); | |
447 | if (_error->PendingError() == true) | |
448 | { | |
449 | _error->Discard(); | |
450 | return false; | |
451 | } | |
452 | ||
453 | MMap Map(CacheF,MMap::Public | MMap::ReadOnly); | |
0a8e3465 | 454 | if (_error->PendingError() == true || Map.Size() == 0) |
b35d2f5f AL |
455 | { |
456 | _error->Discard(); | |
457 | return false; | |
458 | } | |
459 | ||
460 | pkgCache Cache(Map); | |
461 | if (_error->PendingError() == true) | |
462 | { | |
463 | _error->Discard(); | |
464 | return false; | |
465 | } | |
c5162d56 | 466 | |
b35d2f5f | 467 | // They are certianly out of sync |
c5162d56 | 468 | if (Cache.Head().PackageFileCount != List.size() - Missing) |
b35d2f5f AL |
469 | return false; |
470 | ||
471 | for (pkgCache::PkgFileIterator F(Cache); F.end() == false; F++) | |
472 | { | |
473 | // Search for a match in the source list | |
474 | bool Bad = true; | |
475 | for (pkgSourceList::const_iterator I = List.begin(); | |
476 | I != List.end(); I++) | |
477 | { | |
478 | string File = ListDir + URItoFileName(I->PackagesURI()); | |
479 | if (F.FileName() == File) | |
480 | { | |
481 | Bad = false; | |
482 | break; | |
483 | } | |
484 | } | |
485 | ||
486 | // Check if the file matches what was cached | |
487 | Bad |= !F.IsOk(); | |
488 | if (Bad == true) | |
489 | return false; | |
490 | } | |
491 | ||
492 | return true; | |
493 | } | |
494 | /*}}}*/ | |
495 | // PkgCacheCheck - Check if the package cache is uptodate /*{{{*/ | |
496 | // --------------------------------------------------------------------- | |
497 | /* This does a simple check of all files used to compose the cache */ | |
498 | bool pkgPkgCacheCheck(string CacheFile) | |
499 | { | |
500 | if (_error->PendingError() == true) | |
501 | return false; | |
502 | ||
503 | // Open the source package cache | |
504 | if (FileExists(CacheFile) == false) | |
505 | return false; | |
506 | ||
507 | FileFd CacheF(CacheFile,FileFd::ReadOnly); | |
508 | if (_error->PendingError() == true) | |
509 | { | |
510 | _error->Discard(); | |
511 | return false; | |
512 | } | |
513 | ||
514 | MMap Map(CacheF,MMap::Public | MMap::ReadOnly); | |
0a8e3465 | 515 | if (_error->PendingError() == true || Map.Size() == 0) |
b35d2f5f AL |
516 | { |
517 | _error->Discard(); | |
518 | return false; | |
519 | } | |
520 | ||
521 | pkgCache Cache(Map); | |
522 | if (_error->PendingError() == true) | |
523 | { | |
524 | _error->Discard(); | |
525 | return false; | |
526 | } | |
527 | ||
0118833a AL |
528 | // Status files that must be in the cache |
529 | string Status[3]; | |
3b5421b4 AL |
530 | Status[0] = _config->FindFile("Dir::State::xstatus"); |
531 | Status[1]= _config->FindFile("Dir::State::userstatus"); | |
532 | Status[2] = _config->FindFile("Dir::State::status"); | |
0118833a | 533 | |
b35d2f5f AL |
534 | // Cheack each file |
535 | for (pkgCache::PkgFileIterator F(Cache); F.end() == false; F++) | |
0118833a | 536 | { |
b35d2f5f AL |
537 | if (F.IsOk() == false) |
538 | return false; | |
0118833a AL |
539 | |
540 | // See if this is one of the status files | |
541 | for (int I = 0; I != 3; I++) | |
542 | if (F.FileName() == Status[I]) | |
543 | Status[I] = string(); | |
544 | } | |
545 | ||
546 | // Make sure all the status files are loaded. | |
547 | for (int I = 0; I != 3; I++) | |
548 | { | |
549 | if (Status[I].empty() == false && FileExists(Status[I]) == true) | |
550 | return false; | |
551 | } | |
552 | ||
b35d2f5f AL |
553 | return true; |
554 | } | |
555 | /*}}}*/ | |
556 | // AddSourcesSize - Add the size of the status files /*{{{*/ | |
557 | // --------------------------------------------------------------------- | |
558 | /* This adds the size of all the status files to the size counter */ | |
559 | static bool pkgAddSourcesSize(unsigned long &TotalSize) | |
560 | { | |
561 | // Grab the file names | |
3b5421b4 AL |
562 | string xstatus = _config->FindFile("Dir::State::xstatus"); |
563 | string userstatus = _config->FindFile("Dir::State::userstatus"); | |
564 | string status = _config->FindFile("Dir::State::status"); | |
b35d2f5f AL |
565 | |
566 | // Grab the sizes | |
567 | struct stat Buf; | |
568 | if (stat(xstatus.c_str(),&Buf) == 0) | |
569 | TotalSize += Buf.st_size; | |
570 | if (stat(userstatus.c_str(),&Buf) == 0) | |
571 | TotalSize += Buf.st_size; | |
572 | if (stat(status.c_str(),&Buf) != 0) | |
573 | return _error->Errno("stat","Couldn't stat the status file %s",status.c_str()); | |
574 | TotalSize += Buf.st_size; | |
575 | ||
576 | return true; | |
577 | } | |
578 | /*}}}*/ | |
579 | // MergeStatus - Add the status files to the cache /*{{{*/ | |
580 | // --------------------------------------------------------------------- | |
581 | /* This adds the status files to the map */ | |
582 | static bool pkgMergeStatus(OpProgress &Progress,pkgCacheGenerator &Gen, | |
583 | unsigned long &CurrentSize,unsigned long TotalSize) | |
584 | { | |
585 | // Grab the file names | |
586 | string Status[3]; | |
3b5421b4 AL |
587 | Status[0] = _config->FindFile("Dir::State::xstatus"); |
588 | Status[1]= _config->FindFile("Dir::State::userstatus"); | |
589 | Status[2] = _config->FindFile("Dir::State::status"); | |
b35d2f5f AL |
590 | |
591 | for (int I = 0; I != 3; I++) | |
592 | { | |
593 | // Check if the file exists and it is not the primary status file. | |
594 | string File = Status[I]; | |
595 | if (I != 2 && FileExists(File) == false) | |
596 | continue; | |
597 | ||
598 | FileFd Pkg(File,FileFd::ReadOnly); | |
599 | debListParser Parser(Pkg); | |
8ce4327b | 600 | Progress.OverallProgress(CurrentSize,TotalSize,Pkg.Size(),"Reading Package Lists"); |
b35d2f5f AL |
601 | if (_error->PendingError() == true) |
602 | return _error->Error("Problem opening %s",File.c_str()); | |
603 | CurrentSize += Pkg.Size(); | |
8ce4327b AL |
604 | |
605 | Progress.SubProgress(0,"Local Package State - " + flNotDir(File)); | |
b35d2f5f AL |
606 | if (Gen.SelectFile(File,pkgCache::Flag::NotSource) == false) |
607 | return _error->Error("Problem with SelectFile %s",File.c_str()); | |
608 | ||
609 | if (Gen.MergeList(Parser) == false) | |
610 | return _error->Error("Problem with MergeList %s",File.c_str()); | |
8ce4327b | 611 | Progress.Progress(Pkg.Size()); |
b35d2f5f AL |
612 | } |
613 | ||
614 | return true; | |
615 | } | |
616 | /*}}}*/ | |
617 | // MakeStatusCache - Generates a cache that includes the status files /*{{{*/ | |
618 | // --------------------------------------------------------------------- | |
619 | /* This copies the package source cache and then merges the status and | |
620 | xstatus files into it. */ | |
621 | bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress) | |
622 | { | |
8ce4327b AL |
623 | Progress.OverallProgress(0,1,1,"Reading Package Lists"); |
624 | ||
3b5421b4 | 625 | string CacheFile = _config->FindFile("Dir::Cache::pkgcache"); |
b35d2f5f | 626 | bool SrcOk = pkgSrcCacheCheck(List); |
0a8e3465 | 627 | bool PkgOk = SrcOk && pkgPkgCacheCheck(CacheFile); |
b35d2f5f AL |
628 | |
629 | // Rebuild the source and package caches | |
630 | if (SrcOk == false) | |
631 | { | |
3b5421b4 | 632 | string SCacheFile = _config->FindFile("Dir::Cache::srcpkgcache"); |
0919e3f9 | 633 | string ListDir = _config->FindDir("Dir::State::lists"); |
b35d2f5f AL |
634 | FileFd SCacheF(SCacheFile,FileFd::WriteEmpty); |
635 | FileFd CacheF(CacheFile,FileFd::WriteEmpty); | |
636 | DynamicMMap Map(CacheF,MMap::Public); | |
637 | if (_error->PendingError() == true) | |
638 | return false; | |
639 | ||
640 | pkgCacheGenerator Gen(Map,Progress); | |
641 | ||
642 | // Prepare the progress indicator | |
643 | unsigned long TotalSize = 0; | |
644 | struct stat Buf; | |
645 | for (pkgSourceList::const_iterator I = List.begin(); I != List.end(); I++) | |
646 | { | |
647 | string File = ListDir + URItoFileName(I->PackagesURI()); | |
648 | if (stat(File.c_str(),&Buf) != 0) | |
c5162d56 | 649 | continue; |
b35d2f5f AL |
650 | TotalSize += Buf.st_size; |
651 | } | |
652 | ||
653 | if (pkgAddSourcesSize(TotalSize) == false) | |
654 | return false; | |
655 | ||
656 | // Generate the pkg source cache | |
657 | unsigned long CurrentSize = 0; | |
658 | for (pkgSourceList::const_iterator I = List.begin(); I != List.end(); I++) | |
659 | { | |
660 | string File = ListDir + URItoFileName(I->PackagesURI()); | |
b0b4efb9 AL |
661 | |
662 | if (FileExists(File) == false) | |
c5162d56 AL |
663 | continue; |
664 | ||
b35d2f5f AL |
665 | FileFd Pkg(File,FileFd::ReadOnly); |
666 | debListParser Parser(Pkg); | |
8ce4327b | 667 | Progress.OverallProgress(CurrentSize,TotalSize,Pkg.Size(),"Reading Package Lists"); |
b35d2f5f AL |
668 | if (_error->PendingError() == true) |
669 | return _error->Error("Problem opening %s",File.c_str()); | |
670 | CurrentSize += Pkg.Size(); | |
671 | ||
8ce4327b | 672 | Progress.SubProgress(0,I->PackagesInfo()); |
b35d2f5f AL |
673 | if (Gen.SelectFile(File) == false) |
674 | return _error->Error("Problem with SelectFile %s",File.c_str()); | |
675 | ||
676 | if (Gen.MergeList(Parser) == false) | |
677 | return _error->Error("Problem with MergeList %s",File.c_str()); | |
b0b4efb9 AL |
678 | |
679 | // Check the release file | |
680 | string RFile = ListDir + URItoFileName(I->ReleaseURI()); | |
681 | if (FileExists(RFile) == true) | |
682 | { | |
683 | FileFd Rel(RFile,FileFd::ReadOnly); | |
684 | if (_error->PendingError() == true) | |
685 | return false; | |
686 | Parser.LoadReleaseInfo(Gen.GetCurFile(),Rel); | |
687 | } | |
b35d2f5f AL |
688 | } |
689 | ||
690 | // Write the src cache | |
691 | Gen.GetCache().HeaderP->Dirty = false; | |
692 | if (SCacheF.Write(Map.Data(),Map.Size()) == false) | |
693 | return _error->Error("IO Error saving source cache"); | |
694 | Gen.GetCache().HeaderP->Dirty = true; | |
695 | ||
696 | // Merge in the source caches | |
697 | return pkgMergeStatus(Progress,Gen,CurrentSize,TotalSize); | |
698 | } | |
699 | ||
700 | if (PkgOk == true) | |
8ce4327b AL |
701 | { |
702 | Progress.OverallProgress(1,1,1,"Reading Package Lists"); | |
b35d2f5f | 703 | return true; |
8ce4327b | 704 | } |
b35d2f5f AL |
705 | |
706 | // We use the source cache to generate the package cache | |
3b5421b4 | 707 | string SCacheFile = _config->FindFile("Dir::Cache::srcpkgcache"); |
b35d2f5f AL |
708 | |
709 | FileFd SCacheF(SCacheFile,FileFd::ReadOnly); | |
710 | FileFd CacheF(CacheFile,FileFd::WriteEmpty); | |
711 | DynamicMMap Map(CacheF,MMap::Public); | |
712 | if (_error->PendingError() == true) | |
713 | return false; | |
714 | ||
715 | // Preload the map with the source cache | |
716 | if (SCacheF.Read((unsigned char *)Map.Data() + Map.RawAllocate(SCacheF.Size()), | |
717 | SCacheF.Size()) == false) | |
718 | return false; | |
719 | ||
720 | pkgCacheGenerator Gen(Map,Progress); | |
721 | ||
722 | // Compute the progress | |
723 | unsigned long TotalSize = 0; | |
724 | if (pkgAddSourcesSize(TotalSize) == false) | |
725 | return false; | |
726 | ||
727 | unsigned long CurrentSize = 0; | |
728 | return pkgMergeStatus(Progress,Gen,CurrentSize,TotalSize); | |
729 | } | |
730 | /*}}}*/ |