]>
Commit | Line | Data |
---|---|---|
1 | // -*- mode: cpp; mode: fold -*- | |
2 | // Description /*{{{*/ | |
3 | // $Id: pkgcachegen.cc,v 1.53.2.1 2003/12/24 23:09:17 mdz Exp $ | |
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 /*{{{*/ | |
13 | #include <config.h> | |
14 | ||
15 | #include <apt-pkg/pkgcachegen.h> | |
16 | #include <apt-pkg/error.h> | |
17 | #include <apt-pkg/version.h> | |
18 | #include <apt-pkg/progress.h> | |
19 | #include <apt-pkg/sourcelist.h> | |
20 | #include <apt-pkg/configuration.h> | |
21 | #include <apt-pkg/pkgsystem.h> | |
22 | #include <apt-pkg/macros.h> | |
23 | #include <apt-pkg/metaindex.h> | |
24 | #include <apt-pkg/fileutl.h> | |
25 | #include <apt-pkg/hashsum_template.h> | |
26 | #include <apt-pkg/indexfile.h> | |
27 | #include <apt-pkg/md5.h> | |
28 | #include <apt-pkg/mmap.h> | |
29 | #include <apt-pkg/pkgcache.h> | |
30 | #include <apt-pkg/cacheiterators.h> | |
31 | ||
32 | #include <stddef.h> | |
33 | #include <string.h> | |
34 | #include <iostream> | |
35 | #include <string> | |
36 | #include <vector> | |
37 | #include <memory> | |
38 | #include <algorithm> | |
39 | #include <sys/stat.h> | |
40 | #include <unistd.h> | |
41 | ||
42 | #include <apti18n.h> | |
43 | ||
44 | template<class T> using Dynamic = pkgCacheGenerator::Dynamic<T>; /*}}}*/ | |
45 | typedef std::vector<pkgIndexFile *>::iterator FileIterator; | |
46 | template <typename Iter> std::vector<Iter*> pkgCacheGenerator::Dynamic<Iter>::toReMap; | |
47 | ||
48 | static bool IsDuplicateDescription(pkgCache::DescIterator Desc, | |
49 | MD5SumValue const &CurMd5, std::string const &CurLang); | |
50 | ||
51 | using std::string; | |
52 | ||
53 | // CacheGenerator::pkgCacheGenerator - Constructor /*{{{*/ | |
54 | // --------------------------------------------------------------------- | |
55 | /* We set the dirty flag and make sure that is written to the disk */ | |
56 | pkgCacheGenerator::pkgCacheGenerator(DynamicMMap *pMap,OpProgress *Prog) : | |
57 | Map(*pMap), Cache(pMap,false), Progress(Prog), | |
58 | CurrentRlsFile(NULL), CurrentFile(NULL), d(NULL) | |
59 | { | |
60 | if (_error->PendingError() == true) | |
61 | return; | |
62 | ||
63 | if (Map.Size() == 0) | |
64 | { | |
65 | // Setup the map interface.. | |
66 | Cache.HeaderP = (pkgCache::Header *)Map.Data(); | |
67 | if (Map.RawAllocate(sizeof(pkgCache::Header)) == 0 && _error->PendingError() == true) | |
68 | return; | |
69 | ||
70 | Map.UsePools(*Cache.HeaderP->Pools,sizeof(Cache.HeaderP->Pools)/sizeof(Cache.HeaderP->Pools[0])); | |
71 | ||
72 | // Starting header | |
73 | *Cache.HeaderP = pkgCache::Header(); | |
74 | ||
75 | // make room for the hashtables for packages and groups | |
76 | if (Map.RawAllocate(2 * (Cache.HeaderP->GetHashTableSize() * sizeof(map_pointer_t))) == 0) | |
77 | return; | |
78 | ||
79 | map_stringitem_t const idxVerSysName = WriteStringInMap(_system->VS->Label); | |
80 | if (unlikely(idxVerSysName == 0)) | |
81 | return; | |
82 | Cache.HeaderP->VerSysName = idxVerSysName; | |
83 | map_stringitem_t const idxArchitecture = StoreString(MIXED, _config->Find("APT::Architecture")); | |
84 | if (unlikely(idxArchitecture == 0)) | |
85 | return; | |
86 | Cache.HeaderP->Architecture = idxArchitecture; | |
87 | ||
88 | std::vector<std::string> archs = APT::Configuration::getArchitectures(); | |
89 | if (archs.size() > 1) | |
90 | { | |
91 | std::vector<std::string>::const_iterator a = archs.begin(); | |
92 | std::string list = *a; | |
93 | for (++a; a != archs.end(); ++a) | |
94 | list.append(",").append(*a); | |
95 | map_stringitem_t const idxArchitectures = WriteStringInMap(list); | |
96 | if (unlikely(idxArchitectures == 0)) | |
97 | return; | |
98 | Cache.HeaderP->SetArchitectures(idxArchitectures); | |
99 | } | |
100 | else | |
101 | Cache.HeaderP->SetArchitectures(idxArchitecture); | |
102 | ||
103 | Cache.ReMap(); | |
104 | } | |
105 | else | |
106 | { | |
107 | // Map directly from the existing file | |
108 | Cache.ReMap(); | |
109 | Map.UsePools(*Cache.HeaderP->Pools,sizeof(Cache.HeaderP->Pools)/sizeof(Cache.HeaderP->Pools[0])); | |
110 | if (Cache.VS != _system->VS) | |
111 | { | |
112 | _error->Error(_("Cache has an incompatible versioning system")); | |
113 | return; | |
114 | } | |
115 | } | |
116 | ||
117 | Cache.HeaderP->Dirty = true; | |
118 | Map.Sync(0,sizeof(pkgCache::Header)); | |
119 | } | |
120 | /*}}}*/ | |
121 | // CacheGenerator::~pkgCacheGenerator - Destructor /*{{{*/ | |
122 | // --------------------------------------------------------------------- | |
123 | /* We sync the data then unset the dirty flag in two steps so as to | |
124 | advoid a problem during a crash */ | |
125 | pkgCacheGenerator::~pkgCacheGenerator() | |
126 | { | |
127 | if (_error->PendingError() == true) | |
128 | return; | |
129 | if (Map.Sync() == false) | |
130 | return; | |
131 | ||
132 | Cache.HeaderP->Dirty = false; | |
133 | Cache.HeaderP->CacheFileSize = Map.Size(); | |
134 | Map.Sync(0,sizeof(pkgCache::Header)); | |
135 | } | |
136 | /*}}}*/ | |
137 | void pkgCacheGenerator::ReMap(void const * const oldMap, void const * const newMap) {/*{{{*/ | |
138 | if (oldMap == newMap) | |
139 | return; | |
140 | ||
141 | if (_config->FindB("Debug::pkgCacheGen", false)) | |
142 | std::clog << "Remaping from " << oldMap << " to " << newMap << std::endl; | |
143 | ||
144 | Cache.ReMap(false); | |
145 | ||
146 | CurrentFile += (pkgCache::PackageFile const * const) newMap - (pkgCache::PackageFile const * const) oldMap; | |
147 | CurrentRlsFile += (pkgCache::ReleaseFile const * const) newMap - (pkgCache::ReleaseFile const * const) oldMap; | |
148 | ||
149 | for (std::vector<pkgCache::GrpIterator*>::const_iterator i = Dynamic<pkgCache::GrpIterator>::toReMap.begin(); | |
150 | i != Dynamic<pkgCache::GrpIterator>::toReMap.end(); ++i) | |
151 | (*i)->ReMap(oldMap, newMap); | |
152 | for (std::vector<pkgCache::PkgIterator*>::const_iterator i = Dynamic<pkgCache::PkgIterator>::toReMap.begin(); | |
153 | i != Dynamic<pkgCache::PkgIterator>::toReMap.end(); ++i) | |
154 | (*i)->ReMap(oldMap, newMap); | |
155 | for (std::vector<pkgCache::VerIterator*>::const_iterator i = Dynamic<pkgCache::VerIterator>::toReMap.begin(); | |
156 | i != Dynamic<pkgCache::VerIterator>::toReMap.end(); ++i) | |
157 | (*i)->ReMap(oldMap, newMap); | |
158 | for (std::vector<pkgCache::DepIterator*>::const_iterator i = Dynamic<pkgCache::DepIterator>::toReMap.begin(); | |
159 | i != Dynamic<pkgCache::DepIterator>::toReMap.end(); ++i) | |
160 | (*i)->ReMap(oldMap, newMap); | |
161 | for (std::vector<pkgCache::DescIterator*>::const_iterator i = Dynamic<pkgCache::DescIterator>::toReMap.begin(); | |
162 | i != Dynamic<pkgCache::DescIterator>::toReMap.end(); ++i) | |
163 | (*i)->ReMap(oldMap, newMap); | |
164 | for (std::vector<pkgCache::PrvIterator*>::const_iterator i = Dynamic<pkgCache::PrvIterator>::toReMap.begin(); | |
165 | i != Dynamic<pkgCache::PrvIterator>::toReMap.end(); ++i) | |
166 | (*i)->ReMap(oldMap, newMap); | |
167 | for (std::vector<pkgCache::PkgFileIterator*>::const_iterator i = Dynamic<pkgCache::PkgFileIterator>::toReMap.begin(); | |
168 | i != Dynamic<pkgCache::PkgFileIterator>::toReMap.end(); ++i) | |
169 | (*i)->ReMap(oldMap, newMap); | |
170 | for (std::vector<pkgCache::RlsFileIterator*>::const_iterator i = Dynamic<pkgCache::RlsFileIterator>::toReMap.begin(); | |
171 | i != Dynamic<pkgCache::RlsFileIterator>::toReMap.end(); ++i) | |
172 | (*i)->ReMap(oldMap, newMap); | |
173 | } /*}}}*/ | |
174 | // CacheGenerator::WriteStringInMap /*{{{*/ | |
175 | map_stringitem_t pkgCacheGenerator::WriteStringInMap(const char *String, | |
176 | const unsigned long &Len) { | |
177 | void const * const oldMap = Map.Data(); | |
178 | map_stringitem_t const index = Map.WriteString(String, Len); | |
179 | if (index != 0) | |
180 | ReMap(oldMap, Map.Data()); | |
181 | return index; | |
182 | } | |
183 | /*}}}*/ | |
184 | // CacheGenerator::WriteStringInMap /*{{{*/ | |
185 | map_stringitem_t pkgCacheGenerator::WriteStringInMap(const char *String) { | |
186 | void const * const oldMap = Map.Data(); | |
187 | map_stringitem_t const index = Map.WriteString(String); | |
188 | if (index != 0) | |
189 | ReMap(oldMap, Map.Data()); | |
190 | return index; | |
191 | } | |
192 | /*}}}*/ | |
193 | map_pointer_t pkgCacheGenerator::AllocateInMap(const unsigned long &size) {/*{{{*/ | |
194 | void const * const oldMap = Map.Data(); | |
195 | map_pointer_t const index = Map.Allocate(size); | |
196 | if (index != 0) | |
197 | ReMap(oldMap, Map.Data()); | |
198 | return index; | |
199 | } | |
200 | /*}}}*/ | |
201 | // CacheGenerator::MergeList - Merge the package list /*{{{*/ | |
202 | // --------------------------------------------------------------------- | |
203 | /* This provides the generation of the entries in the cache. Each loop | |
204 | goes through a single package record from the underlying parse engine. */ | |
205 | bool pkgCacheGenerator::MergeList(ListParser &List, | |
206 | pkgCache::VerIterator *OutVer) | |
207 | { | |
208 | List.Owner = this; | |
209 | ||
210 | unsigned int Counter = 0; | |
211 | while (List.Step() == true) | |
212 | { | |
213 | string const PackageName = List.Package(); | |
214 | if (PackageName.empty() == true) | |
215 | return false; | |
216 | ||
217 | Counter++; | |
218 | if (Counter % 100 == 0 && Progress != 0) | |
219 | Progress->Progress(List.Offset()); | |
220 | ||
221 | string Arch = List.Architecture(); | |
222 | string const Version = List.Version(); | |
223 | if (Version.empty() == true && Arch.empty() == true) | |
224 | { | |
225 | // package descriptions | |
226 | if (MergeListGroup(List, PackageName) == false) | |
227 | return false; | |
228 | continue; | |
229 | } | |
230 | ||
231 | // Get a pointer to the package structure | |
232 | pkgCache::PkgIterator Pkg; | |
233 | Dynamic<pkgCache::PkgIterator> DynPkg(Pkg); | |
234 | if (NewPackage(Pkg, PackageName, Arch) == false) | |
235 | // TRANSLATOR: The first placeholder is a package name, | |
236 | // the other two should be copied verbatim as they include debug info | |
237 | return _error->Error(_("Error occurred while processing %s (%s%d)"), | |
238 | PackageName.c_str(), "NewPackage", 1); | |
239 | ||
240 | ||
241 | if (Version.empty() == true) | |
242 | { | |
243 | if (MergeListPackage(List, Pkg) == false) | |
244 | return false; | |
245 | } | |
246 | else | |
247 | { | |
248 | if (MergeListVersion(List, Pkg, Version, OutVer) == false) | |
249 | return false; | |
250 | } | |
251 | ||
252 | if (OutVer != 0) | |
253 | return true; | |
254 | } | |
255 | ||
256 | if (Cache.HeaderP->PackageCount >= std::numeric_limits<map_id_t>::max()) | |
257 | return _error->Error(_("Wow, you exceeded the number of package " | |
258 | "names this APT is capable of.")); | |
259 | if (Cache.HeaderP->VersionCount >= std::numeric_limits<map_id_t>::max()) | |
260 | return _error->Error(_("Wow, you exceeded the number of versions " | |
261 | "this APT is capable of.")); | |
262 | if (Cache.HeaderP->DescriptionCount >= std::numeric_limits<map_id_t>::max()) | |
263 | return _error->Error(_("Wow, you exceeded the number of descriptions " | |
264 | "this APT is capable of.")); | |
265 | if (Cache.HeaderP->DependsCount >= std::numeric_limits<map_id_t>::max()) | |
266 | return _error->Error(_("Wow, you exceeded the number of dependencies " | |
267 | "this APT is capable of.")); | |
268 | ||
269 | return true; | |
270 | } | |
271 | // CacheGenerator::MergeListGroup /*{{{*/ | |
272 | bool pkgCacheGenerator::MergeListGroup(ListParser &List, std::string const &GrpName) | |
273 | { | |
274 | pkgCache::GrpIterator Grp = Cache.FindGrp(GrpName); | |
275 | // a group has no data on it's own, only packages have it but these | |
276 | // stanzas like this come from Translation- files to add descriptions, | |
277 | // but without a version we don't need a description for it… | |
278 | if (Grp.end() == true) | |
279 | return true; | |
280 | Dynamic<pkgCache::GrpIterator> DynGrp(Grp); | |
281 | ||
282 | pkgCache::PkgIterator Pkg; | |
283 | Dynamic<pkgCache::PkgIterator> DynPkg(Pkg); | |
284 | for (Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg)) | |
285 | if (MergeListPackage(List, Pkg) == false) | |
286 | return false; | |
287 | ||
288 | return true; | |
289 | } | |
290 | /*}}}*/ | |
291 | // CacheGenerator::MergeListPackage /*{{{*/ | |
292 | bool pkgCacheGenerator::MergeListPackage(ListParser &List, pkgCache::PkgIterator &Pkg) | |
293 | { | |
294 | // we first process the package, then the descriptions | |
295 | // (for deb this package processing is in fact a no-op) | |
296 | pkgCache::VerIterator Ver(Cache); | |
297 | Dynamic<pkgCache::VerIterator> DynVer(Ver); | |
298 | if (List.UsePackage(Pkg, Ver) == false) | |
299 | return _error->Error(_("Error occurred while processing %s (%s%d)"), | |
300 | Pkg.Name(), "UsePackage", 1); | |
301 | ||
302 | // Find the right version to write the description | |
303 | MD5SumValue CurMd5 = List.Description_md5(); | |
304 | if (CurMd5.Value().empty() == true && List.Description("").empty() == true) | |
305 | return true; | |
306 | std::vector<std::string> availDesc = List.AvailableDescriptionLanguages(); | |
307 | for (Ver = Pkg.VersionList(); Ver.end() == false; ++Ver) | |
308 | { | |
309 | pkgCache::DescIterator VerDesc = Ver.DescriptionList(); | |
310 | ||
311 | // a version can only have one md5 describing it | |
312 | if (VerDesc.end() == true || MD5SumValue(VerDesc.md5()) != CurMd5) | |
313 | continue; | |
314 | ||
315 | map_stringitem_t md5idx = VerDesc->md5sum; | |
316 | for (std::vector<std::string>::const_iterator CurLang = availDesc.begin(); CurLang != availDesc.end(); ++CurLang) | |
317 | { | |
318 | // don't add a new description if we have one for the given | |
319 | // md5 && language | |
320 | if (IsDuplicateDescription(VerDesc, CurMd5, *CurLang) == true) | |
321 | continue; | |
322 | ||
323 | AddNewDescription(List, Ver, *CurLang, CurMd5, md5idx); | |
324 | } | |
325 | ||
326 | // we can stop here as all "same" versions will share the description | |
327 | break; | |
328 | } | |
329 | ||
330 | return true; | |
331 | } | |
332 | /*}}}*/ | |
333 | // CacheGenerator::MergeListVersion /*{{{*/ | |
334 | bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator &Pkg, | |
335 | std::string const &Version, pkgCache::VerIterator* &OutVer) | |
336 | { | |
337 | pkgCache::VerIterator Ver = Pkg.VersionList(); | |
338 | Dynamic<pkgCache::VerIterator> DynVer(Ver); | |
339 | map_pointer_t *LastVer = &Pkg->VersionList; | |
340 | void const * oldMap = Map.Data(); | |
341 | ||
342 | unsigned short const Hash = List.VersionHash(); | |
343 | if (Ver.end() == false) | |
344 | { | |
345 | /* We know the list is sorted so we use that fact in the search. | |
346 | Insertion of new versions is done with correct sorting */ | |
347 | int Res = 1; | |
348 | for (; Ver.end() == false; LastVer = &Ver->NextVer, ++Ver) | |
349 | { | |
350 | Res = Cache.VS->CmpVersion(Version,Ver.VerStr()); | |
351 | // Version is higher as current version - insert here | |
352 | if (Res > 0) | |
353 | break; | |
354 | // Versionstrings are equal - is hash also equal? | |
355 | if (Res == 0 && List.SameVersion(Hash, Ver) == true) | |
356 | break; | |
357 | // proceed with the next till we have either the right | |
358 | // or we found another version (which will be lower) | |
359 | } | |
360 | ||
361 | /* We already have a version for this item, record that we saw it */ | |
362 | if (Res == 0 && Ver.end() == false && Ver->Hash == Hash) | |
363 | { | |
364 | if (List.UsePackage(Pkg,Ver) == false) | |
365 | return _error->Error(_("Error occurred while processing %s (%s%d)"), | |
366 | Pkg.Name(), "UsePackage", 2); | |
367 | ||
368 | if (NewFileVer(Ver,List) == false) | |
369 | return _error->Error(_("Error occurred while processing %s (%s%d)"), | |
370 | Pkg.Name(), "NewFileVer", 1); | |
371 | ||
372 | // Read only a single record and return | |
373 | if (OutVer != 0) | |
374 | { | |
375 | *OutVer = Ver; | |
376 | return true; | |
377 | } | |
378 | ||
379 | return true; | |
380 | } | |
381 | } | |
382 | ||
383 | // Add a new version | |
384 | map_pointer_t const verindex = NewVersion(Ver, Version, Pkg.Index(), Hash, *LastVer); | |
385 | if (verindex == 0 && _error->PendingError()) | |
386 | return _error->Error(_("Error occurred while processing %s (%s%d)"), | |
387 | Pkg.Name(), "NewVersion", 1); | |
388 | ||
389 | if (oldMap != Map.Data()) | |
390 | LastVer += (map_pointer_t const * const) Map.Data() - (map_pointer_t const * const) oldMap; | |
391 | *LastVer = verindex; | |
392 | ||
393 | if (unlikely(List.NewVersion(Ver) == false)) | |
394 | return _error->Error(_("Error occurred while processing %s (%s%d)"), | |
395 | Pkg.Name(), "NewVersion", 2); | |
396 | ||
397 | if (unlikely(List.UsePackage(Pkg,Ver) == false)) | |
398 | return _error->Error(_("Error occurred while processing %s (%s%d)"), | |
399 | Pkg.Name(), "UsePackage", 3); | |
400 | ||
401 | if (unlikely(NewFileVer(Ver,List) == false)) | |
402 | return _error->Error(_("Error occurred while processing %s (%s%d)"), | |
403 | Pkg.Name(), "NewFileVer", 2); | |
404 | ||
405 | pkgCache::GrpIterator Grp = Pkg.Group(); | |
406 | Dynamic<pkgCache::GrpIterator> DynGrp(Grp); | |
407 | ||
408 | /* If it is the first version of this package we need to add implicit | |
409 | Multi-Arch dependencies to all other package versions in the group now - | |
410 | otherwise we just add them for this new version */ | |
411 | if (Pkg.VersionList()->NextVer == 0) | |
412 | { | |
413 | pkgCache::PkgIterator P = Grp.PackageList(); | |
414 | Dynamic<pkgCache::PkgIterator> DynP(P); | |
415 | for (; P.end() != true; P = Grp.NextPkg(P)) | |
416 | { | |
417 | if (P->ID == Pkg->ID) | |
418 | continue; | |
419 | pkgCache::VerIterator V = P.VersionList(); | |
420 | Dynamic<pkgCache::VerIterator> DynV(V); | |
421 | for (; V.end() != true; ++V) | |
422 | if (unlikely(AddImplicitDepends(V, Pkg) == false)) | |
423 | return _error->Error(_("Error occurred while processing %s (%s%d)"), | |
424 | Pkg.Name(), "AddImplicitDepends", 1); | |
425 | } | |
426 | } | |
427 | if (unlikely(AddImplicitDepends(Grp, Pkg, Ver) == false)) | |
428 | return _error->Error(_("Error occurred while processing %s (%s%d)"), | |
429 | Pkg.Name(), "AddImplicitDepends", 2); | |
430 | ||
431 | // Read only a single record and return | |
432 | if (OutVer != 0) | |
433 | { | |
434 | *OutVer = Ver; | |
435 | return true; | |
436 | } | |
437 | ||
438 | /* Record the Description(s) based on their master md5sum */ | |
439 | MD5SumValue CurMd5 = List.Description_md5(); | |
440 | if (CurMd5.Value().empty() == true && List.Description("").empty() == true) | |
441 | return true; | |
442 | ||
443 | /* Before we add a new description we first search in the group for | |
444 | a version with a description of the same MD5 - if so we reuse this | |
445 | description group instead of creating our own for this version */ | |
446 | for (pkgCache::PkgIterator P = Grp.PackageList(); | |
447 | P.end() == false; P = Grp.NextPkg(P)) | |
448 | { | |
449 | for (pkgCache::VerIterator V = P.VersionList(); | |
450 | V.end() == false; ++V) | |
451 | { | |
452 | if (V->DescriptionList == 0 || MD5SumValue(V.DescriptionList().md5()) != CurMd5) | |
453 | continue; | |
454 | Ver->DescriptionList = V->DescriptionList; | |
455 | } | |
456 | } | |
457 | ||
458 | // We haven't found reusable descriptions, so add the first description(s) | |
459 | map_stringitem_t md5idx = Ver->DescriptionList == 0 ? 0 : Ver.DescriptionList()->md5sum; | |
460 | std::vector<std::string> availDesc = List.AvailableDescriptionLanguages(); | |
461 | for (std::vector<std::string>::const_iterator CurLang = availDesc.begin(); CurLang != availDesc.end(); ++CurLang) | |
462 | if (AddNewDescription(List, Ver, *CurLang, CurMd5, md5idx) == false) | |
463 | return false; | |
464 | return true; | |
465 | } | |
466 | /*}}}*/ | |
467 | bool pkgCacheGenerator::AddNewDescription(ListParser &List, pkgCache::VerIterator &Ver, std::string const &lang, MD5SumValue const &CurMd5, map_stringitem_t &md5idx) /*{{{*/ | |
468 | { | |
469 | pkgCache::DescIterator Desc; | |
470 | Dynamic<pkgCache::DescIterator> DynDesc(Desc); | |
471 | ||
472 | map_pointer_t const descindex = NewDescription(Desc, lang, CurMd5, md5idx); | |
473 | if (unlikely(descindex == 0 && _error->PendingError())) | |
474 | return _error->Error(_("Error occurred while processing %s (%s%d)"), | |
475 | Ver.ParentPkg().Name(), "NewDescription", 1); | |
476 | ||
477 | md5idx = Desc->md5sum; | |
478 | Desc->ParentPkg = Ver.ParentPkg().Index(); | |
479 | ||
480 | // we add at the end, so that the start is constant as we need | |
481 | // that to be able to efficiently share these lists | |
482 | pkgCache::DescIterator VerDesc = Ver.DescriptionList(); // old value might be invalid after ReMap | |
483 | for (;VerDesc.end() == false && VerDesc->NextDesc != 0; ++VerDesc); | |
484 | map_pointer_t * const LastNextDesc = (VerDesc.end() == true) ? &Ver->DescriptionList : &VerDesc->NextDesc; | |
485 | *LastNextDesc = descindex; | |
486 | ||
487 | if (NewFileDesc(Desc,List) == false) | |
488 | return _error->Error(_("Error occurred while processing %s (%s%d)"), | |
489 | Ver.ParentPkg().Name(), "NewFileDesc", 1); | |
490 | ||
491 | return true; | |
492 | } | |
493 | /*}}}*/ | |
494 | /*}}}*/ | |
495 | // CacheGenerator::NewGroup - Add a new group /*{{{*/ | |
496 | // --------------------------------------------------------------------- | |
497 | /* This creates a new group structure and adds it to the hash table */ | |
498 | bool pkgCacheGenerator::NewGroup(pkgCache::GrpIterator &Grp, const string &Name) | |
499 | { | |
500 | Grp = Cache.FindGrp(Name); | |
501 | if (Grp.end() == false) | |
502 | return true; | |
503 | ||
504 | // Get a structure | |
505 | map_pointer_t const Group = AllocateInMap(sizeof(pkgCache::Group)); | |
506 | if (unlikely(Group == 0)) | |
507 | return false; | |
508 | ||
509 | Grp = pkgCache::GrpIterator(Cache, Cache.GrpP + Group); | |
510 | map_stringitem_t const idxName = StoreString(PKGNAME, Name); | |
511 | if (unlikely(idxName == 0)) | |
512 | return false; | |
513 | Grp->Name = idxName; | |
514 | ||
515 | // Insert it into the hash table | |
516 | unsigned long const Hash = Cache.Hash(Name); | |
517 | map_pointer_t *insertAt = &Cache.HeaderP->GrpHashTableP()[Hash]; | |
518 | while (*insertAt != 0 && strcasecmp(Name.c_str(), Cache.StrP + (Cache.GrpP + *insertAt)->Name) > 0) | |
519 | insertAt = &(Cache.GrpP + *insertAt)->Next; | |
520 | Grp->Next = *insertAt; | |
521 | *insertAt = Group; | |
522 | ||
523 | Grp->ID = Cache.HeaderP->GroupCount++; | |
524 | return true; | |
525 | } | |
526 | /*}}}*/ | |
527 | // CacheGenerator::NewPackage - Add a new package /*{{{*/ | |
528 | // --------------------------------------------------------------------- | |
529 | /* This creates a new package structure and adds it to the hash table */ | |
530 | bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name, | |
531 | const string &Arch) { | |
532 | pkgCache::GrpIterator Grp; | |
533 | Dynamic<pkgCache::GrpIterator> DynGrp(Grp); | |
534 | if (unlikely(NewGroup(Grp, Name) == false)) | |
535 | return false; | |
536 | ||
537 | Pkg = Grp.FindPkg(Arch); | |
538 | if (Pkg.end() == false) | |
539 | return true; | |
540 | ||
541 | // Get a structure | |
542 | map_pointer_t const Package = AllocateInMap(sizeof(pkgCache::Package)); | |
543 | if (unlikely(Package == 0)) | |
544 | return false; | |
545 | Pkg = pkgCache::PkgIterator(Cache,Cache.PkgP + Package); | |
546 | ||
547 | // Set the name, arch and the ID | |
548 | APT_IGNORE_DEPRECATED(Pkg->Name = Grp->Name;) | |
549 | Pkg->Group = Grp.Index(); | |
550 | // all is mapped to the native architecture | |
551 | map_stringitem_t const idxArch = (Arch == "all") ? Cache.HeaderP->Architecture : StoreString(MIXED, Arch); | |
552 | if (unlikely(idxArch == 0)) | |
553 | return false; | |
554 | Pkg->Arch = idxArch; | |
555 | Pkg->ID = Cache.HeaderP->PackageCount++; | |
556 | ||
557 | // Insert the package into our package list | |
558 | if (Grp->FirstPackage == 0) // the group is new | |
559 | { | |
560 | Grp->FirstPackage = Package; | |
561 | // Insert it into the hash table | |
562 | map_id_t const Hash = Cache.Hash(Name); | |
563 | map_pointer_t *insertAt = &Cache.HeaderP->PkgHashTableP()[Hash]; | |
564 | while (*insertAt != 0 && strcasecmp(Name.c_str(), Cache.StrP + (Cache.GrpP + (Cache.PkgP + *insertAt)->Group)->Name) > 0) | |
565 | insertAt = &(Cache.PkgP + *insertAt)->NextPackage; | |
566 | Pkg->NextPackage = *insertAt; | |
567 | *insertAt = Package; | |
568 | } | |
569 | else // Group the Packages together | |
570 | { | |
571 | // but first get implicit provides done | |
572 | if (APT::Configuration::checkArchitecture(Pkg.Arch()) == true) | |
573 | { | |
574 | pkgCache::PkgIterator const M = Grp.FindPreferredPkg(false); // native or any foreign pkg will do | |
575 | if (M.end() == false) { | |
576 | pkgCache::PrvIterator Prv; | |
577 | Dynamic<pkgCache::PrvIterator> DynPrv(Prv); | |
578 | for (Prv = M.ProvidesList(); Prv.end() == false; ++Prv) | |
579 | { | |
580 | if ((Prv->Flags & pkgCache::Flag::ArchSpecific) != 0) | |
581 | continue; | |
582 | pkgCache::VerIterator Ver = Prv.OwnerVer(); | |
583 | Dynamic<pkgCache::VerIterator> DynVer(Ver); | |
584 | if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed || | |
585 | ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign && | |
586 | (Prv->Flags & pkgCache::Flag::MultiArchImplicit) == 0)) | |
587 | if (NewProvides(Ver, Pkg, Prv->ProvideVersion, Prv->Flags) == false) | |
588 | return false; | |
589 | } | |
590 | } | |
591 | ||
592 | ||
593 | pkgCache::PkgIterator P; | |
594 | pkgCache::VerIterator Ver; | |
595 | Dynamic<pkgCache::PkgIterator> DynP(P); | |
596 | Dynamic<pkgCache::VerIterator> DynVer(Ver); | |
597 | ||
598 | for (P = Grp.PackageList(); P.end() == false; P = Grp.NextPkg(P)) | |
599 | for (Ver = P.VersionList(); Ver.end() == false; ++Ver) | |
600 | if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign) | |
601 | if (NewProvides(Ver, Pkg, Ver->VerStr, pkgCache::Flag::MultiArchImplicit) == false) | |
602 | return false; | |
603 | } | |
604 | // and negative dependencies, don't forget negative dependencies | |
605 | { | |
606 | pkgCache::PkgIterator const M = Grp.FindPreferredPkg(false); | |
607 | if (M.end() == false) { | |
608 | pkgCache::DepIterator Dep; | |
609 | Dynamic<pkgCache::DepIterator> DynDep(Dep); | |
610 | for (Dep = M.RevDependsList(); Dep.end() == false; ++Dep) | |
611 | { | |
612 | if ((Dep->CompareOp & (pkgCache::Dep::ArchSpecific | pkgCache::Dep::MultiArchImplicit)) != 0) | |
613 | continue; | |
614 | if (Dep->Type != pkgCache::Dep::DpkgBreaks && Dep->Type != pkgCache::Dep::Conflicts && | |
615 | Dep->Type != pkgCache::Dep::Replaces) | |
616 | continue; | |
617 | pkgCache::VerIterator Ver = Dep.ParentVer(); | |
618 | Dynamic<pkgCache::VerIterator> DynVer(Ver); | |
619 | map_pointer_t * unused = NULL; | |
620 | if (NewDepends(Pkg, Ver, Dep->Version, Dep->CompareOp, Dep->Type, unused) == false) | |
621 | return false; | |
622 | } | |
623 | } | |
624 | } | |
625 | ||
626 | // this package is the new last package | |
627 | pkgCache::PkgIterator LastPkg(Cache, Cache.PkgP + Grp->LastPackage); | |
628 | Pkg->NextPackage = LastPkg->NextPackage; | |
629 | LastPkg->NextPackage = Package; | |
630 | } | |
631 | Grp->LastPackage = Package; | |
632 | ||
633 | // lazy-create foo (of amd64) provides foo:amd64 at the time we first need it | |
634 | if (Arch == "any") | |
635 | { | |
636 | size_t const found = Name.find(':'); | |
637 | std::string const NameA = Name.substr(0, found); | |
638 | std::string const ArchA = Name.substr(found + 1); | |
639 | pkgCache::PkgIterator PkgA = Cache.FindPkg(NameA, ArchA); | |
640 | if (PkgA.end() == false) | |
641 | { | |
642 | Dynamic<pkgCache::PkgIterator> DynPkgA(PkgA); | |
643 | pkgCache::PrvIterator Prv = PkgA.ProvidesList(); | |
644 | for (; Prv.end() == false; ++Prv) | |
645 | { | |
646 | if (Prv.IsMultiArchImplicit()) | |
647 | continue; | |
648 | pkgCache::VerIterator V = Prv.OwnerVer(); | |
649 | if (ArchA != V.ParentPkg().Arch()) | |
650 | continue; | |
651 | if (NewProvides(V, Pkg, V->VerStr, pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false) | |
652 | return false; | |
653 | } | |
654 | pkgCache::VerIterator V = PkgA.VersionList(); | |
655 | Dynamic<pkgCache::VerIterator> DynV(V); | |
656 | for (; V.end() == false; ++V) | |
657 | { | |
658 | if (NewProvides(V, Pkg, V->VerStr, pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false) | |
659 | return false; | |
660 | } | |
661 | } | |
662 | } | |
663 | return true; | |
664 | } | |
665 | /*}}}*/ | |
666 | // CacheGenerator::AddImplicitDepends /*{{{*/ | |
667 | bool pkgCacheGenerator::AddImplicitDepends(pkgCache::GrpIterator &G, | |
668 | pkgCache::PkgIterator &P, | |
669 | pkgCache::VerIterator &V) | |
670 | { | |
671 | // copy P.Arch() into a string here as a cache remap | |
672 | // in NewDepends() later may alter the pointer location | |
673 | string Arch = P.Arch() == NULL ? "" : P.Arch(); | |
674 | map_pointer_t *OldDepLast = NULL; | |
675 | /* MultiArch handling introduces a lot of implicit Dependencies: | |
676 | - MultiArch: same → Co-Installable if they have the same version | |
677 | - All others conflict with all other group members */ | |
678 | bool const coInstall = ((V->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same); | |
679 | pkgCache::PkgIterator D = G.PackageList(); | |
680 | Dynamic<pkgCache::PkgIterator> DynD(D); | |
681 | map_stringitem_t const VerStrIdx = V->VerStr; | |
682 | for (; D.end() != true; D = G.NextPkg(D)) | |
683 | { | |
684 | if (Arch == D.Arch() || D->VersionList == 0) | |
685 | continue; | |
686 | /* We allow only one installed arch at the time | |
687 | per group, therefore each group member conflicts | |
688 | with all other group members */ | |
689 | if (coInstall == true) | |
690 | { | |
691 | // Replaces: ${self}:other ( << ${binary:Version}) | |
692 | NewDepends(D, V, VerStrIdx, | |
693 | pkgCache::Dep::Less | pkgCache::Dep::MultiArchImplicit, pkgCache::Dep::Replaces, | |
694 | OldDepLast); | |
695 | // Breaks: ${self}:other (!= ${binary:Version}) | |
696 | NewDepends(D, V, VerStrIdx, | |
697 | pkgCache::Dep::NotEquals | pkgCache::Dep::MultiArchImplicit, pkgCache::Dep::DpkgBreaks, | |
698 | OldDepLast); | |
699 | } else { | |
700 | // Conflicts: ${self}:other | |
701 | NewDepends(D, V, 0, | |
702 | pkgCache::Dep::NoOp | pkgCache::Dep::MultiArchImplicit, pkgCache::Dep::Conflicts, | |
703 | OldDepLast); | |
704 | } | |
705 | } | |
706 | return true; | |
707 | } | |
708 | bool pkgCacheGenerator::AddImplicitDepends(pkgCache::VerIterator &V, | |
709 | pkgCache::PkgIterator &D) | |
710 | { | |
711 | /* MultiArch handling introduces a lot of implicit Dependencies: | |
712 | - MultiArch: same → Co-Installable if they have the same version | |
713 | - All others conflict with all other group members */ | |
714 | map_pointer_t *OldDepLast = NULL; | |
715 | bool const coInstall = ((V->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same); | |
716 | if (coInstall == true) | |
717 | { | |
718 | map_stringitem_t const VerStrIdx = V->VerStr; | |
719 | // Replaces: ${self}:other ( << ${binary:Version}) | |
720 | NewDepends(D, V, VerStrIdx, | |
721 | pkgCache::Dep::Less | pkgCache::Dep::MultiArchImplicit, pkgCache::Dep::Replaces, | |
722 | OldDepLast); | |
723 | // Breaks: ${self}:other (!= ${binary:Version}) | |
724 | NewDepends(D, V, VerStrIdx, | |
725 | pkgCache::Dep::NotEquals | pkgCache::Dep::MultiArchImplicit, pkgCache::Dep::DpkgBreaks, | |
726 | OldDepLast); | |
727 | } else { | |
728 | // Conflicts: ${self}:other | |
729 | NewDepends(D, V, 0, | |
730 | pkgCache::Dep::NoOp | pkgCache::Dep::MultiArchImplicit, pkgCache::Dep::Conflicts, | |
731 | OldDepLast); | |
732 | } | |
733 | return true; | |
734 | } | |
735 | ||
736 | /*}}}*/ | |
737 | // CacheGenerator::NewFileVer - Create a new File<->Version association /*{{{*/ | |
738 | // --------------------------------------------------------------------- | |
739 | /* */ | |
740 | bool pkgCacheGenerator::NewFileVer(pkgCache::VerIterator &Ver, | |
741 | ListParser &List) | |
742 | { | |
743 | if (CurrentFile == 0) | |
744 | return true; | |
745 | ||
746 | // Get a structure | |
747 | map_pointer_t const VerFile = AllocateInMap(sizeof(pkgCache::VerFile)); | |
748 | if (VerFile == 0) | |
749 | return false; | |
750 | ||
751 | pkgCache::VerFileIterator VF(Cache,Cache.VerFileP + VerFile); | |
752 | VF->File = CurrentFile - Cache.PkgFileP; | |
753 | ||
754 | // Link it to the end of the list | |
755 | map_pointer_t *Last = &Ver->FileList; | |
756 | for (pkgCache::VerFileIterator V = Ver.FileList(); V.end() == false; ++V) | |
757 | Last = &V->NextFile; | |
758 | VF->NextFile = *Last; | |
759 | *Last = VF.Index(); | |
760 | ||
761 | VF->Offset = List.Offset(); | |
762 | VF->Size = List.Size(); | |
763 | if (Cache.HeaderP->MaxVerFileSize < VF->Size) | |
764 | Cache.HeaderP->MaxVerFileSize = VF->Size; | |
765 | Cache.HeaderP->VerFileCount++; | |
766 | ||
767 | return true; | |
768 | } | |
769 | /*}}}*/ | |
770 | // CacheGenerator::NewVersion - Create a new Version /*{{{*/ | |
771 | // --------------------------------------------------------------------- | |
772 | /* This puts a version structure in the linked list */ | |
773 | map_pointer_t pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver, | |
774 | const string &VerStr, | |
775 | map_pointer_t const ParentPkg, | |
776 | unsigned short const Hash, | |
777 | map_pointer_t const Next) | |
778 | { | |
779 | // Get a structure | |
780 | map_pointer_t const Version = AllocateInMap(sizeof(pkgCache::Version)); | |
781 | if (Version == 0) | |
782 | return 0; | |
783 | ||
784 | // Fill it in | |
785 | Ver = pkgCache::VerIterator(Cache,Cache.VerP + Version); | |
786 | //Dynamic<pkgCache::VerIterator> DynV(Ver); // caller MergeListVersion already takes care of it | |
787 | Ver->NextVer = Next; | |
788 | Ver->ParentPkg = ParentPkg; | |
789 | Ver->Hash = Hash; | |
790 | Ver->ID = Cache.HeaderP->VersionCount++; | |
791 | ||
792 | // try to find the version string in the group for reuse | |
793 | pkgCache::PkgIterator Pkg = Ver.ParentPkg(); | |
794 | pkgCache::GrpIterator Grp = Pkg.Group(); | |
795 | if (Pkg.end() == false && Grp.end() == false) | |
796 | { | |
797 | for (pkgCache::PkgIterator P = Grp.PackageList(); P.end() == false; P = Grp.NextPkg(P)) | |
798 | { | |
799 | if (Pkg == P) | |
800 | continue; | |
801 | for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V) | |
802 | { | |
803 | int const cmp = strcmp(V.VerStr(), VerStr.c_str()); | |
804 | if (cmp == 0) | |
805 | { | |
806 | Ver->VerStr = V->VerStr; | |
807 | return Version; | |
808 | } | |
809 | else if (cmp < 0) | |
810 | break; | |
811 | } | |
812 | } | |
813 | } | |
814 | // haven't found the version string, so create | |
815 | map_stringitem_t const idxVerStr = StoreString(VERSIONNUMBER, VerStr); | |
816 | if (unlikely(idxVerStr == 0)) | |
817 | return 0; | |
818 | Ver->VerStr = idxVerStr; | |
819 | return Version; | |
820 | } | |
821 | /*}}}*/ | |
822 | // CacheGenerator::NewFileDesc - Create a new File<->Desc association /*{{{*/ | |
823 | // --------------------------------------------------------------------- | |
824 | /* */ | |
825 | bool pkgCacheGenerator::NewFileDesc(pkgCache::DescIterator &Desc, | |
826 | ListParser &List) | |
827 | { | |
828 | if (CurrentFile == 0) | |
829 | return true; | |
830 | ||
831 | // Get a structure | |
832 | map_pointer_t const DescFile = AllocateInMap(sizeof(pkgCache::DescFile)); | |
833 | if (DescFile == 0) | |
834 | return false; | |
835 | ||
836 | pkgCache::DescFileIterator DF(Cache,Cache.DescFileP + DescFile); | |
837 | DF->File = CurrentFile - Cache.PkgFileP; | |
838 | ||
839 | // Link it to the end of the list | |
840 | map_pointer_t *Last = &Desc->FileList; | |
841 | for (pkgCache::DescFileIterator D = Desc.FileList(); D.end() == false; ++D) | |
842 | Last = &D->NextFile; | |
843 | ||
844 | DF->NextFile = *Last; | |
845 | *Last = DF.Index(); | |
846 | ||
847 | DF->Offset = List.Offset(); | |
848 | DF->Size = List.Size(); | |
849 | if (Cache.HeaderP->MaxDescFileSize < DF->Size) | |
850 | Cache.HeaderP->MaxDescFileSize = DF->Size; | |
851 | Cache.HeaderP->DescFileCount++; | |
852 | ||
853 | return true; | |
854 | } | |
855 | /*}}}*/ | |
856 | // CacheGenerator::NewDescription - Create a new Description /*{{{*/ | |
857 | // --------------------------------------------------------------------- | |
858 | /* This puts a description structure in the linked list */ | |
859 | map_pointer_t pkgCacheGenerator::NewDescription(pkgCache::DescIterator &Desc, | |
860 | const string &Lang, | |
861 | const MD5SumValue &md5sum, | |
862 | map_stringitem_t const idxmd5str) | |
863 | { | |
864 | // Get a structure | |
865 | map_pointer_t const Description = AllocateInMap(sizeof(pkgCache::Description)); | |
866 | if (Description == 0) | |
867 | return 0; | |
868 | ||
869 | // Fill it in | |
870 | Desc = pkgCache::DescIterator(Cache,Cache.DescP + Description); | |
871 | Desc->ID = Cache.HeaderP->DescriptionCount++; | |
872 | map_stringitem_t const idxlanguage_code = StoreString(MIXED, Lang); | |
873 | if (unlikely(idxlanguage_code == 0)) | |
874 | return 0; | |
875 | Desc->language_code = idxlanguage_code; | |
876 | ||
877 | if (idxmd5str != 0) | |
878 | Desc->md5sum = idxmd5str; | |
879 | else | |
880 | { | |
881 | map_stringitem_t const idxmd5sum = WriteStringInMap(md5sum.Value()); | |
882 | if (unlikely(idxmd5sum == 0)) | |
883 | return 0; | |
884 | Desc->md5sum = idxmd5sum; | |
885 | } | |
886 | ||
887 | return Description; | |
888 | } | |
889 | /*}}}*/ | |
890 | // CacheGenerator::NewDepends - Create a dependency element /*{{{*/ | |
891 | // --------------------------------------------------------------------- | |
892 | /* This creates a dependency element in the tree. It is linked to the | |
893 | version and to the package that it is pointing to. */ | |
894 | bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg, | |
895 | pkgCache::VerIterator &Ver, | |
896 | map_pointer_t const Version, | |
897 | uint8_t const Op, | |
898 | uint8_t const Type, | |
899 | map_pointer_t* &OldDepLast) | |
900 | { | |
901 | void const * const oldMap = Map.Data(); | |
902 | // Get a structure | |
903 | map_pointer_t const Dependency = AllocateInMap(sizeof(pkgCache::Dependency)); | |
904 | if (unlikely(Dependency == 0)) | |
905 | return false; | |
906 | ||
907 | bool isDuplicate = false; | |
908 | map_pointer_t DependencyData = 0; | |
909 | map_pointer_t PreviousData = 0; | |
910 | if (Pkg->RevDepends != 0) | |
911 | { | |
912 | pkgCache::Dependency const * const L = Cache.DepP + Pkg->RevDepends; | |
913 | DependencyData = L->DependencyData; | |
914 | do { | |
915 | pkgCache::DependencyData const * const D = Cache.DepDataP + DependencyData; | |
916 | if (Version > D->Version) | |
917 | break; | |
918 | if (D->Version == Version && D->Type == Type && D->CompareOp == Op) | |
919 | { | |
920 | isDuplicate = true; | |
921 | break; | |
922 | } | |
923 | PreviousData = DependencyData; | |
924 | DependencyData = D->NextData; | |
925 | } while (DependencyData != 0); | |
926 | } | |
927 | ||
928 | if (isDuplicate == false) | |
929 | { | |
930 | DependencyData = AllocateInMap(sizeof(pkgCache::DependencyData)); | |
931 | if (unlikely(DependencyData == 0)) | |
932 | return false; | |
933 | } | |
934 | ||
935 | pkgCache::Dependency * Link = Cache.DepP + Dependency; | |
936 | Link->ParentVer = Ver.Index(); | |
937 | Link->DependencyData = DependencyData; | |
938 | Link->ID = Cache.HeaderP->DependsCount++; | |
939 | ||
940 | pkgCache::DepIterator Dep(Cache, Link); | |
941 | if (isDuplicate == false) | |
942 | { | |
943 | Dep->Type = Type; | |
944 | Dep->CompareOp = Op; | |
945 | Dep->Version = Version; | |
946 | Dep->Package = Pkg.Index(); | |
947 | ++Cache.HeaderP->DependsDataCount; | |
948 | if (PreviousData != 0) | |
949 | { | |
950 | pkgCache::DependencyData * const D = Cache.DepDataP + PreviousData; | |
951 | Dep->NextData = D->NextData; | |
952 | D->NextData = DependencyData; | |
953 | } | |
954 | else if (Pkg->RevDepends != 0) | |
955 | { | |
956 | pkgCache::Dependency const * const D = Cache.DepP + Pkg->RevDepends; | |
957 | Dep->NextData = D->DependencyData; | |
958 | } | |
959 | } | |
960 | ||
961 | if (isDuplicate == true || PreviousData != 0) | |
962 | { | |
963 | pkgCache::Dependency * const L = Cache.DepP + Pkg->RevDepends; | |
964 | Link->NextRevDepends = L->NextRevDepends; | |
965 | L->NextRevDepends = Dependency; | |
966 | } | |
967 | else | |
968 | { | |
969 | Link->NextRevDepends = Pkg->RevDepends; | |
970 | Pkg->RevDepends = Dependency; | |
971 | } | |
972 | ||
973 | ||
974 | // Do we know where to link the Dependency to? | |
975 | if (OldDepLast == NULL) | |
976 | { | |
977 | OldDepLast = &Ver->DependsList; | |
978 | for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; ++D) | |
979 | OldDepLast = &D->NextDepends; | |
980 | } else if (oldMap != Map.Data()) | |
981 | OldDepLast += (map_pointer_t const * const) Map.Data() - (map_pointer_t const * const) oldMap; | |
982 | ||
983 | Dep->NextDepends = *OldDepLast; | |
984 | *OldDepLast = Dependency; | |
985 | OldDepLast = &Dep->NextDepends; | |
986 | return true; | |
987 | } | |
988 | /*}}}*/ | |
989 | // ListParser::NewDepends - Create the environment for a new dependency /*{{{*/ | |
990 | // --------------------------------------------------------------------- | |
991 | /* This creates a Group and the Package to link this dependency to if | |
992 | needed and handles also the caching of the old endpoint */ | |
993 | bool pkgCacheListParser::NewDepends(pkgCache::VerIterator &Ver, | |
994 | const string &PackageName, | |
995 | const string &Arch, | |
996 | const string &Version, | |
997 | uint8_t const Op, | |
998 | uint8_t const Type) | |
999 | { | |
1000 | pkgCache::GrpIterator Grp; | |
1001 | Dynamic<pkgCache::GrpIterator> DynGrp(Grp); | |
1002 | if (unlikely(Owner->NewGroup(Grp, PackageName) == false)) | |
1003 | return false; | |
1004 | ||
1005 | map_stringitem_t idxVersion = 0; | |
1006 | if (Version.empty() == false) | |
1007 | { | |
1008 | int const CmpOp = Op & 0x0F; | |
1009 | // =-deps are used (79:1) for lockstep on same-source packages (e.g. data-packages) | |
1010 | if (CmpOp == pkgCache::Dep::Equals && strcmp(Version.c_str(), Ver.VerStr()) == 0) | |
1011 | idxVersion = Ver->VerStr; | |
1012 | ||
1013 | if (idxVersion == 0) | |
1014 | { | |
1015 | idxVersion = StoreString(pkgCacheGenerator::VERSIONNUMBER, Version); | |
1016 | if (unlikely(idxVersion == 0)) | |
1017 | return false; | |
1018 | } | |
1019 | } | |
1020 | ||
1021 | bool const isNegative = (Type == pkgCache::Dep::DpkgBreaks || | |
1022 | Type == pkgCache::Dep::Conflicts || | |
1023 | Type == pkgCache::Dep::Replaces); | |
1024 | ||
1025 | pkgCache::PkgIterator Pkg; | |
1026 | Dynamic<pkgCache::PkgIterator> DynPkg(Pkg); | |
1027 | if (isNegative == false || (Op & pkgCache::Dep::ArchSpecific) == pkgCache::Dep::ArchSpecific || Grp->FirstPackage == 0) | |
1028 | { | |
1029 | // Locate the target package | |
1030 | Pkg = Grp.FindPkg(Arch); | |
1031 | if (Pkg.end() == true) { | |
1032 | if (unlikely(Owner->NewPackage(Pkg, PackageName, Arch) == false)) | |
1033 | return false; | |
1034 | } | |
1035 | ||
1036 | /* Caching the old end point speeds up generation substantially */ | |
1037 | if (OldDepVer != Ver) { | |
1038 | OldDepLast = NULL; | |
1039 | OldDepVer = Ver; | |
1040 | } | |
1041 | ||
1042 | return Owner->NewDepends(Pkg, Ver, idxVersion, Op, Type, OldDepLast); | |
1043 | } | |
1044 | else | |
1045 | { | |
1046 | /* Caching the old end point speeds up generation substantially */ | |
1047 | if (OldDepVer != Ver) { | |
1048 | OldDepLast = NULL; | |
1049 | OldDepVer = Ver; | |
1050 | } | |
1051 | ||
1052 | for (Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg)) | |
1053 | { | |
1054 | if (Owner->NewDepends(Pkg, Ver, idxVersion, Op, Type, OldDepLast) == false) | |
1055 | return false; | |
1056 | } | |
1057 | } | |
1058 | return true; | |
1059 | } | |
1060 | /*}}}*/ | |
1061 | // ListParser::NewProvides - Create a Provides element /*{{{*/ | |
1062 | bool pkgCacheListParser::NewProvides(pkgCache::VerIterator &Ver, | |
1063 | const string &PkgName, | |
1064 | const string &PkgArch, | |
1065 | const string &Version, | |
1066 | uint8_t const Flags) | |
1067 | { | |
1068 | pkgCache const &Cache = Owner->Cache; | |
1069 | ||
1070 | // We do not add self referencing provides | |
1071 | if (Ver.ParentPkg().Name() == PkgName && (PkgArch == Ver.ParentPkg().Arch() || | |
1072 | (PkgArch == "all" && strcmp((Cache.StrP + Cache.HeaderP->Architecture), Ver.ParentPkg().Arch()) == 0))) | |
1073 | return true; | |
1074 | ||
1075 | // Locate the target package | |
1076 | pkgCache::PkgIterator Pkg; | |
1077 | Dynamic<pkgCache::PkgIterator> DynPkg(Pkg); | |
1078 | if (unlikely(Owner->NewPackage(Pkg,PkgName, PkgArch) == false)) | |
1079 | return false; | |
1080 | ||
1081 | map_stringitem_t idxProvideVersion = 0; | |
1082 | if (Version.empty() == false) { | |
1083 | idxProvideVersion = StoreString(pkgCacheGenerator::VERSIONNUMBER, Version); | |
1084 | if (unlikely(idxProvideVersion == 0)) | |
1085 | return false; | |
1086 | } | |
1087 | return Owner->NewProvides(Ver, Pkg, idxProvideVersion, Flags); | |
1088 | } | |
1089 | bool pkgCacheGenerator::NewProvides(pkgCache::VerIterator &Ver, | |
1090 | pkgCache::PkgIterator &Pkg, | |
1091 | map_pointer_t const ProvideVersion, | |
1092 | uint8_t const Flags) | |
1093 | { | |
1094 | // Get a structure | |
1095 | map_pointer_t const Provides = AllocateInMap(sizeof(pkgCache::Provides)); | |
1096 | if (unlikely(Provides == 0)) | |
1097 | return false; | |
1098 | ++Cache.HeaderP->ProvidesCount; | |
1099 | ||
1100 | // Fill it in | |
1101 | pkgCache::PrvIterator Prv(Cache,Cache.ProvideP + Provides,Cache.PkgP); | |
1102 | Prv->Version = Ver.Index(); | |
1103 | Prv->ProvideVersion = ProvideVersion; | |
1104 | Prv->Flags = Flags; | |
1105 | Prv->NextPkgProv = Ver->ProvidesList; | |
1106 | Ver->ProvidesList = Prv.Index(); | |
1107 | ||
1108 | // Link it to the package | |
1109 | Prv->ParentPkg = Pkg.Index(); | |
1110 | Prv->NextProvides = Pkg->ProvidesList; | |
1111 | Pkg->ProvidesList = Prv.Index(); | |
1112 | return true; | |
1113 | } | |
1114 | /*}}}*/ | |
1115 | // ListParser::NewProvidesAllArch - add provides for all architectures /*{{{*/ | |
1116 | bool pkgCacheListParser::NewProvidesAllArch(pkgCache::VerIterator &Ver, string const &Package, | |
1117 | string const &Version, uint8_t const Flags) { | |
1118 | pkgCache &Cache = Owner->Cache; | |
1119 | pkgCache::GrpIterator Grp = Cache.FindGrp(Package); | |
1120 | Dynamic<pkgCache::GrpIterator> DynGrp(Grp); | |
1121 | ||
1122 | if (Grp.end() == true) | |
1123 | return NewProvides(Ver, Package, Cache.NativeArch(), Version, Flags); | |
1124 | else | |
1125 | { | |
1126 | map_stringitem_t idxProvideVersion = 0; | |
1127 | if (Version.empty() == false) { | |
1128 | idxProvideVersion = StoreString(pkgCacheGenerator::VERSIONNUMBER, Version); | |
1129 | if (unlikely(idxProvideVersion == 0)) | |
1130 | return false; | |
1131 | } | |
1132 | ||
1133 | bool const isImplicit = (Flags & pkgCache::Flag::MultiArchImplicit) == pkgCache::Flag::MultiArchImplicit; | |
1134 | bool const isArchSpecific = (Flags & pkgCache::Flag::ArchSpecific) == pkgCache::Flag::ArchSpecific; | |
1135 | pkgCache::PkgIterator OwnerPkg = Ver.ParentPkg(); | |
1136 | Dynamic<pkgCache::PkgIterator> DynOwnerPkg(OwnerPkg); | |
1137 | pkgCache::PkgIterator Pkg; | |
1138 | Dynamic<pkgCache::PkgIterator> DynPkg(Pkg); | |
1139 | for (Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg)) | |
1140 | { | |
1141 | if (isImplicit && OwnerPkg == Pkg) | |
1142 | continue; | |
1143 | if (isArchSpecific == false && APT::Configuration::checkArchitecture(OwnerPkg.Arch()) == false) | |
1144 | continue; | |
1145 | if (Owner->NewProvides(Ver, Pkg, idxProvideVersion, Flags) == false) | |
1146 | return false; | |
1147 | } | |
1148 | } | |
1149 | return true; | |
1150 | } | |
1151 | /*}}}*/ | |
1152 | bool pkgCacheListParser::SameVersion(unsigned short const Hash, /*{{{*/ | |
1153 | pkgCache::VerIterator const &Ver) | |
1154 | { | |
1155 | return Hash == Ver->Hash; | |
1156 | } | |
1157 | /*}}}*/ | |
1158 | // CacheGenerator::SelectReleaseFile - Select the current release file the indexes belong to /*{{{*/ | |
1159 | bool pkgCacheGenerator::SelectReleaseFile(const string &File,const string &Site, | |
1160 | unsigned long Flags) | |
1161 | { | |
1162 | if (File.empty() && Site.empty()) | |
1163 | { | |
1164 | CurrentRlsFile = NULL; | |
1165 | return true; | |
1166 | } | |
1167 | ||
1168 | // Get some space for the structure | |
1169 | map_pointer_t const idxFile = AllocateInMap(sizeof(*CurrentRlsFile)); | |
1170 | if (unlikely(idxFile == 0)) | |
1171 | return false; | |
1172 | CurrentRlsFile = Cache.RlsFileP + idxFile; | |
1173 | ||
1174 | // Fill it in | |
1175 | map_stringitem_t const idxFileName = WriteStringInMap(File); | |
1176 | map_stringitem_t const idxSite = StoreString(MIXED, Site); | |
1177 | if (unlikely(idxFileName == 0 || idxSite == 0)) | |
1178 | return false; | |
1179 | CurrentRlsFile->FileName = idxFileName; | |
1180 | CurrentRlsFile->Site = idxSite; | |
1181 | CurrentRlsFile->NextFile = Cache.HeaderP->RlsFileList; | |
1182 | CurrentRlsFile->Flags = Flags; | |
1183 | CurrentRlsFile->ID = Cache.HeaderP->ReleaseFileCount; | |
1184 | RlsFileName = File; | |
1185 | Cache.HeaderP->RlsFileList = CurrentRlsFile - Cache.RlsFileP; | |
1186 | Cache.HeaderP->ReleaseFileCount++; | |
1187 | ||
1188 | return true; | |
1189 | } | |
1190 | /*}}}*/ | |
1191 | // CacheGenerator::SelectFile - Select the current file being parsed /*{{{*/ | |
1192 | // --------------------------------------------------------------------- | |
1193 | /* This is used to select which file is to be associated with all newly | |
1194 | added versions. The caller is responsible for setting the IMS fields. */ | |
1195 | bool pkgCacheGenerator::SelectFile(std::string const &File, | |
1196 | pkgIndexFile const &Index, | |
1197 | std::string const &Architecture, | |
1198 | std::string const &Component, | |
1199 | unsigned long const Flags) | |
1200 | { | |
1201 | // Get some space for the structure | |
1202 | map_pointer_t const idxFile = AllocateInMap(sizeof(*CurrentFile)); | |
1203 | if (unlikely(idxFile == 0)) | |
1204 | return false; | |
1205 | CurrentFile = Cache.PkgFileP + idxFile; | |
1206 | ||
1207 | // Fill it in | |
1208 | map_stringitem_t const idxFileName = WriteStringInMap(File); | |
1209 | if (unlikely(idxFileName == 0)) | |
1210 | return false; | |
1211 | CurrentFile->FileName = idxFileName; | |
1212 | CurrentFile->NextFile = Cache.HeaderP->FileList; | |
1213 | CurrentFile->ID = Cache.HeaderP->PackageFileCount; | |
1214 | map_stringitem_t const idxIndexType = StoreString(MIXED, Index.GetType()->Label); | |
1215 | if (unlikely(idxIndexType == 0)) | |
1216 | return false; | |
1217 | CurrentFile->IndexType = idxIndexType; | |
1218 | if (Architecture.empty()) | |
1219 | CurrentFile->Architecture = 0; | |
1220 | else | |
1221 | { | |
1222 | map_stringitem_t const arch = StoreString(pkgCacheGenerator::MIXED, Architecture); | |
1223 | if (unlikely(arch == 0)) | |
1224 | return false; | |
1225 | CurrentFile->Architecture = arch; | |
1226 | } | |
1227 | map_stringitem_t const component = StoreString(pkgCacheGenerator::MIXED, Component); | |
1228 | if (unlikely(component == 0)) | |
1229 | return false; | |
1230 | CurrentFile->Component = component; | |
1231 | CurrentFile->Flags = Flags; | |
1232 | if (CurrentRlsFile != NULL) | |
1233 | CurrentFile->Release = CurrentRlsFile - Cache.RlsFileP; | |
1234 | else | |
1235 | CurrentFile->Release = 0; | |
1236 | PkgFileName = File; | |
1237 | Cache.HeaderP->FileList = CurrentFile - Cache.PkgFileP; | |
1238 | Cache.HeaderP->PackageFileCount++; | |
1239 | ||
1240 | if (Progress != 0) | |
1241 | Progress->SubProgress(Index.Size()); | |
1242 | return true; | |
1243 | } | |
1244 | /*}}}*/ | |
1245 | // CacheGenerator::WriteUniqueString - Insert a unique string /*{{{*/ | |
1246 | // --------------------------------------------------------------------- | |
1247 | /* This is used to create handles to strings. Given the same text it | |
1248 | always returns the same number */ | |
1249 | map_stringitem_t pkgCacheGenerator::StoreString(enum StringType const type, const char *S, | |
1250 | unsigned int Size) | |
1251 | { | |
1252 | std::string const key(S, Size); | |
1253 | ||
1254 | std::map<std::string,map_stringitem_t> * strings; | |
1255 | switch(type) { | |
1256 | case MIXED: strings = &strMixed; break; | |
1257 | case PKGNAME: strings = &strPkgNames; break; | |
1258 | case VERSIONNUMBER: strings = &strVersions; break; | |
1259 | case SECTION: strings = &strSections; break; | |
1260 | default: _error->Fatal("Unknown enum type used for string storage of '%s'", key.c_str()); return 0; | |
1261 | } | |
1262 | ||
1263 | std::map<std::string,map_stringitem_t>::const_iterator const item = strings->find(key); | |
1264 | if (item != strings->end()) | |
1265 | return item->second; | |
1266 | ||
1267 | map_stringitem_t const idxString = WriteStringInMap(S,Size); | |
1268 | strings->insert(std::make_pair(key, idxString)); | |
1269 | return idxString; | |
1270 | } | |
1271 | /*}}}*/ | |
1272 | // CheckValidity - Check that a cache is up-to-date /*{{{*/ | |
1273 | // --------------------------------------------------------------------- | |
1274 | /* This just verifies that each file in the list of index files exists, | |
1275 | has matching attributes with the cache and the cache does not have | |
1276 | any extra files. */ | |
1277 | static bool CheckValidity(const string &CacheFile, | |
1278 | pkgSourceList &List, | |
1279 | FileIterator const Start, | |
1280 | FileIterator const End, | |
1281 | MMap **OutMap = 0) | |
1282 | { | |
1283 | bool const Debug = _config->FindB("Debug::pkgCacheGen", false); | |
1284 | // No file, certainly invalid | |
1285 | if (CacheFile.empty() == true || FileExists(CacheFile) == false) | |
1286 | { | |
1287 | if (Debug == true) | |
1288 | std::clog << "CacheFile " << CacheFile << " doesn't exist" << std::endl; | |
1289 | return false; | |
1290 | } | |
1291 | ||
1292 | if (List.GetLastModifiedTime() > GetModificationTime(CacheFile)) | |
1293 | { | |
1294 | if (Debug == true) | |
1295 | std::clog << "sources.list is newer than the cache" << std::endl; | |
1296 | return false; | |
1297 | } | |
1298 | ||
1299 | // Map it | |
1300 | FileFd CacheF(CacheFile,FileFd::ReadOnly); | |
1301 | std::unique_ptr<MMap> Map(new MMap(CacheF,0)); | |
1302 | pkgCache Cache(Map.get()); | |
1303 | if (_error->PendingError() == true || Map->Size() == 0) | |
1304 | { | |
1305 | if (Debug == true) | |
1306 | std::clog << "Errors are pending or Map is empty() for " << CacheFile << std::endl; | |
1307 | _error->Discard(); | |
1308 | return false; | |
1309 | } | |
1310 | ||
1311 | std::unique_ptr<bool[]> RlsVisited(new bool[Cache.HeaderP->ReleaseFileCount]); | |
1312 | memset(RlsVisited.get(),0,sizeof(RlsVisited[0])*Cache.HeaderP->ReleaseFileCount); | |
1313 | std::vector<pkgIndexFile *> Files; | |
1314 | for (pkgSourceList::const_iterator i = List.begin(); i != List.end(); ++i) | |
1315 | { | |
1316 | if (Debug == true) | |
1317 | std::clog << "Checking RlsFile " << (*i)->Describe() << ": "; | |
1318 | pkgCache::RlsFileIterator const RlsFile = (*i)->FindInCache(Cache, true); | |
1319 | if (RlsFile.end() == true) | |
1320 | { | |
1321 | if (Debug == true) | |
1322 | std::clog << "FindInCache returned end-Pointer" << std::endl; | |
1323 | return false; | |
1324 | } | |
1325 | ||
1326 | RlsVisited[RlsFile->ID] = true; | |
1327 | if (Debug == true) | |
1328 | std::clog << "with ID " << RlsFile->ID << " is valid" << std::endl; | |
1329 | ||
1330 | std::vector <pkgIndexFile *> const * const Indexes = (*i)->GetIndexFiles(); | |
1331 | std::copy_if(Indexes->begin(), Indexes->end(), std::back_inserter(Files), | |
1332 | [](pkgIndexFile const * const I) { return I->HasPackages(); }); | |
1333 | } | |
1334 | for (unsigned I = 0; I != Cache.HeaderP->ReleaseFileCount; ++I) | |
1335 | if (RlsVisited[I] == false) | |
1336 | { | |
1337 | if (Debug == true) | |
1338 | std::clog << "RlsFile with ID" << I << " wasn't visited" << std::endl; | |
1339 | return false; | |
1340 | } | |
1341 | ||
1342 | std::copy(Start, End, std::back_inserter(Files)); | |
1343 | ||
1344 | /* Now we check every index file, see if it is in the cache, | |
1345 | verify the IMS data and check that it is on the disk too.. */ | |
1346 | std::unique_ptr<bool[]> Visited(new bool[Cache.HeaderP->PackageFileCount]); | |
1347 | memset(Visited.get(),0,sizeof(Visited[0])*Cache.HeaderP->PackageFileCount); | |
1348 | for (std::vector<pkgIndexFile *>::const_reverse_iterator PkgFile = Files.rbegin(); PkgFile != Files.rend(); ++PkgFile) | |
1349 | { | |
1350 | if (Debug == true) | |
1351 | std::clog << "Checking PkgFile " << (*PkgFile)->Describe() << ": "; | |
1352 | if ((*PkgFile)->Exists() == false) | |
1353 | { | |
1354 | if (Debug == true) | |
1355 | std::clog << "file doesn't exist" << std::endl; | |
1356 | continue; | |
1357 | } | |
1358 | ||
1359 | // FindInCache is also expected to do an IMS check. | |
1360 | pkgCache::PkgFileIterator File = (*PkgFile)->FindInCache(Cache); | |
1361 | if (File.end() == true) | |
1362 | { | |
1363 | if (Debug == true) | |
1364 | std::clog << "FindInCache returned end-Pointer" << std::endl; | |
1365 | return false; | |
1366 | } | |
1367 | ||
1368 | Visited[File->ID] = true; | |
1369 | if (Debug == true) | |
1370 | std::clog << "with ID " << File->ID << " is valid" << std::endl; | |
1371 | } | |
1372 | ||
1373 | for (unsigned I = 0; I != Cache.HeaderP->PackageFileCount; I++) | |
1374 | if (Visited[I] == false) | |
1375 | { | |
1376 | if (Debug == true) | |
1377 | std::clog << "PkgFile with ID" << I << " wasn't visited" << std::endl; | |
1378 | return false; | |
1379 | } | |
1380 | ||
1381 | if (_error->PendingError() == true) | |
1382 | { | |
1383 | if (Debug == true) | |
1384 | { | |
1385 | std::clog << "Validity failed because of pending errors:" << std::endl; | |
1386 | _error->DumpErrors(); | |
1387 | } | |
1388 | _error->Discard(); | |
1389 | return false; | |
1390 | } | |
1391 | ||
1392 | if (OutMap != 0) | |
1393 | *OutMap = Map.release(); | |
1394 | return true; | |
1395 | } | |
1396 | /*}}}*/ | |
1397 | // ComputeSize - Compute the total size of a bunch of files /*{{{*/ | |
1398 | // --------------------------------------------------------------------- | |
1399 | /* Size is kind of an abstract notion that is only used for the progress | |
1400 | meter */ | |
1401 | static map_filesize_t ComputeSize(pkgSourceList const * const List, FileIterator Start,FileIterator End) | |
1402 | { | |
1403 | map_filesize_t TotalSize = 0; | |
1404 | if (List != NULL) | |
1405 | { | |
1406 | for (pkgSourceList::const_iterator i = List->begin(); i != List->end(); ++i) | |
1407 | { | |
1408 | std::vector <pkgIndexFile *> *Indexes = (*i)->GetIndexFiles(); | |
1409 | for (std::vector<pkgIndexFile *>::const_iterator j = Indexes->begin(); j != Indexes->end(); ++j) | |
1410 | if ((*j)->HasPackages() == true) | |
1411 | TotalSize += (*j)->Size(); | |
1412 | } | |
1413 | } | |
1414 | ||
1415 | for (; Start < End; ++Start) | |
1416 | { | |
1417 | if ((*Start)->HasPackages() == false) | |
1418 | continue; | |
1419 | TotalSize += (*Start)->Size(); | |
1420 | } | |
1421 | return TotalSize; | |
1422 | } | |
1423 | /*}}}*/ | |
1424 | // BuildCache - Merge the list of index files into the cache /*{{{*/ | |
1425 | static bool BuildCache(pkgCacheGenerator &Gen, | |
1426 | OpProgress * const Progress, | |
1427 | map_filesize_t &CurrentSize,map_filesize_t TotalSize, | |
1428 | pkgSourceList const * const List, | |
1429 | FileIterator const Start, FileIterator const End) | |
1430 | { | |
1431 | std::vector<pkgIndexFile *> Files; | |
1432 | bool mergeFailure = false; | |
1433 | ||
1434 | auto const indexFileMerge = [&](pkgIndexFile * const I) { | |
1435 | if (I->HasPackages() == false || mergeFailure) | |
1436 | return; | |
1437 | ||
1438 | if (I->Exists() == false) | |
1439 | return; | |
1440 | ||
1441 | if (I->FindInCache(Gen.GetCache()).end() == false) | |
1442 | { | |
1443 | _error->Warning("Duplicate sources.list entry %s", | |
1444 | I->Describe().c_str()); | |
1445 | return; | |
1446 | } | |
1447 | ||
1448 | map_filesize_t const Size = I->Size(); | |
1449 | if (Progress != NULL) | |
1450 | Progress->OverallProgress(CurrentSize, TotalSize, Size, _("Reading package lists")); | |
1451 | CurrentSize += Size; | |
1452 | ||
1453 | if (I->Merge(Gen,Progress) == false) | |
1454 | mergeFailure = true; | |
1455 | }; | |
1456 | ||
1457 | if (List != NULL) | |
1458 | { | |
1459 | for (pkgSourceList::const_iterator i = List->begin(); i != List->end(); ++i) | |
1460 | { | |
1461 | if ((*i)->FindInCache(Gen.GetCache(), false).end() == false) | |
1462 | { | |
1463 | _error->Warning("Duplicate sources.list entry %s", | |
1464 | (*i)->Describe().c_str()); | |
1465 | continue; | |
1466 | } | |
1467 | ||
1468 | if ((*i)->Merge(Gen, Progress) == false) | |
1469 | return false; | |
1470 | ||
1471 | std::vector <pkgIndexFile *> *Indexes = (*i)->GetIndexFiles(); | |
1472 | if (Indexes != NULL) | |
1473 | std::for_each(Indexes->begin(), Indexes->end(), indexFileMerge); | |
1474 | if (mergeFailure) | |
1475 | return false; | |
1476 | } | |
1477 | } | |
1478 | ||
1479 | if (Start != End) | |
1480 | { | |
1481 | Gen.SelectReleaseFile("", ""); | |
1482 | std::for_each(Start, End, indexFileMerge); | |
1483 | if (mergeFailure) | |
1484 | return false; | |
1485 | } | |
1486 | return true; | |
1487 | } | |
1488 | /*}}}*/ | |
1489 | // CacheGenerator::MakeStatusCache - Construct the status cache /*{{{*/ | |
1490 | // --------------------------------------------------------------------- | |
1491 | /* This makes sure that the status cache (the cache that has all | |
1492 | index files from the sources list and all local ones) is ready | |
1493 | to be mmaped. If OutMap is not zero then a MMap object representing | |
1494 | the cache will be stored there. This is pretty much mandetory if you | |
1495 | are using AllowMem. AllowMem lets the function be run as non-root | |
1496 | where it builds the cache 'fast' into a memory buffer. */ | |
1497 | static DynamicMMap* CreateDynamicMMap(FileFd * const CacheF, unsigned long Flags) | |
1498 | { | |
1499 | map_filesize_t const MapStart = _config->FindI("APT::Cache-Start", 24*1024*1024); | |
1500 | map_filesize_t const MapGrow = _config->FindI("APT::Cache-Grow", 1*1024*1024); | |
1501 | map_filesize_t const MapLimit = _config->FindI("APT::Cache-Limit", 0); | |
1502 | Flags |= MMap::Moveable; | |
1503 | if (_config->FindB("APT::Cache-Fallback", false) == true) | |
1504 | Flags |= MMap::Fallback; | |
1505 | if (CacheF != NULL) | |
1506 | return new DynamicMMap(*CacheF, Flags, MapStart, MapGrow, MapLimit); | |
1507 | else | |
1508 | return new DynamicMMap(Flags, MapStart, MapGrow, MapLimit); | |
1509 | } | |
1510 | static bool writeBackMMapToFile(pkgCacheGenerator * const Gen, DynamicMMap * const Map, | |
1511 | std::string const &FileName) | |
1512 | { | |
1513 | FileFd SCacheF(FileName, FileFd::WriteAtomic); | |
1514 | if (_error->PendingError() == true) | |
1515 | return false; | |
1516 | ||
1517 | fchmod(SCacheF.Fd(),0644); | |
1518 | ||
1519 | // Write out the main data | |
1520 | if (SCacheF.Write(Map->Data(),Map->Size()) == false) | |
1521 | return _error->Error(_("IO Error saving source cache")); | |
1522 | SCacheF.Sync(); | |
1523 | ||
1524 | // Write out the proper header | |
1525 | Gen->GetCache().HeaderP->Dirty = false; | |
1526 | if (SCacheF.Seek(0) == false || | |
1527 | SCacheF.Write(Map->Data(),sizeof(*Gen->GetCache().HeaderP)) == false) | |
1528 | return _error->Error(_("IO Error saving source cache")); | |
1529 | Gen->GetCache().HeaderP->Dirty = true; | |
1530 | SCacheF.Sync(); | |
1531 | return true; | |
1532 | } | |
1533 | static bool loadBackMMapFromFile(std::unique_ptr<pkgCacheGenerator> &Gen, | |
1534 | std::unique_ptr<DynamicMMap> &Map, OpProgress * const Progress, std::string const &FileName) | |
1535 | { | |
1536 | Map.reset(CreateDynamicMMap(NULL, 0)); | |
1537 | FileFd CacheF(FileName, FileFd::ReadOnly); | |
1538 | map_pointer_t const alloc = Map->RawAllocate(CacheF.Size()); | |
1539 | if ((alloc == 0 && _error->PendingError()) | |
1540 | || CacheF.Read((unsigned char *)Map->Data() + alloc, | |
1541 | CacheF.Size()) == false) | |
1542 | return false; | |
1543 | Gen.reset(new pkgCacheGenerator(Map.get(),Progress)); | |
1544 | return true; | |
1545 | } | |
1546 | APT_DEPRECATED bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress, | |
1547 | MMap **OutMap, bool AllowMem) | |
1548 | { return pkgCacheGenerator::MakeStatusCache(List, &Progress, OutMap, AllowMem); } | |
1549 | bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress, | |
1550 | MMap **OutMap,bool) | |
1551 | { | |
1552 | // FIXME: deprecate the ignored AllowMem parameter | |
1553 | bool const Debug = _config->FindB("Debug::pkgCacheGen", false); | |
1554 | ||
1555 | std::vector<pkgIndexFile *> Files; | |
1556 | if (_system->AddStatusFiles(Files) == false) | |
1557 | return false; | |
1558 | ||
1559 | // Decide if we can write to the files.. | |
1560 | string const CacheFile = _config->FindFile("Dir::Cache::pkgcache"); | |
1561 | string const SrcCacheFile = _config->FindFile("Dir::Cache::srcpkgcache"); | |
1562 | ||
1563 | // ensure the cache directory exists | |
1564 | if (CacheFile.empty() == false || SrcCacheFile.empty() == false) | |
1565 | { | |
1566 | string dir = _config->FindDir("Dir::Cache"); | |
1567 | size_t const len = dir.size(); | |
1568 | if (len > 5 && dir.find("/apt/", len - 6, 5) == len - 5) | |
1569 | dir = dir.substr(0, len - 5); | |
1570 | if (CacheFile.empty() == false) | |
1571 | CreateDirectory(dir, flNotFile(CacheFile)); | |
1572 | if (SrcCacheFile.empty() == false) | |
1573 | CreateDirectory(dir, flNotFile(SrcCacheFile)); | |
1574 | } | |
1575 | ||
1576 | if (Progress != NULL) | |
1577 | Progress->OverallProgress(0,1,1,_("Reading package lists")); | |
1578 | ||
1579 | bool pkgcache_fine = false; | |
1580 | bool srcpkgcache_fine = false; | |
1581 | bool volatile_fine = List.GetVolatileFiles().empty(); | |
1582 | ||
1583 | if (CheckValidity(CacheFile, List, Files.begin(), Files.end(), volatile_fine ? OutMap : NULL) == true) | |
1584 | { | |
1585 | if (Debug == true) | |
1586 | std::clog << "pkgcache.bin is valid - no need to build any cache" << std::endl; | |
1587 | pkgcache_fine = true; | |
1588 | srcpkgcache_fine = true; | |
1589 | } | |
1590 | if (pkgcache_fine == false) | |
1591 | { | |
1592 | if (CheckValidity(SrcCacheFile, List, Files.end(), Files.end()) == true) | |
1593 | { | |
1594 | if (Debug == true) | |
1595 | std::clog << "srcpkgcache.bin is valid - it can be reused" << std::endl; | |
1596 | srcpkgcache_fine = true; | |
1597 | } | |
1598 | } | |
1599 | ||
1600 | if (volatile_fine == true && srcpkgcache_fine == true && pkgcache_fine == true) | |
1601 | { | |
1602 | if (Progress != NULL) | |
1603 | Progress->OverallProgress(1,1,1,_("Reading package lists")); | |
1604 | return true; | |
1605 | } | |
1606 | ||
1607 | bool Writeable = false; | |
1608 | if (srcpkgcache_fine == false || pkgcache_fine == false) | |
1609 | { | |
1610 | if (CacheFile.empty() == false) | |
1611 | Writeable = access(flNotFile(CacheFile).c_str(),W_OK) == 0; | |
1612 | else if (SrcCacheFile.empty() == false) | |
1613 | Writeable = access(flNotFile(SrcCacheFile).c_str(),W_OK) == 0; | |
1614 | ||
1615 | if (Debug == true) | |
1616 | std::clog << "Do we have write-access to the cache files? " << (Writeable ? "YES" : "NO") << std::endl; | |
1617 | } | |
1618 | ||
1619 | // At this point we know we need to construct something, so get storage ready | |
1620 | std::unique_ptr<DynamicMMap> Map(CreateDynamicMMap(NULL, 0)); | |
1621 | if (Debug == true) | |
1622 | std::clog << "Open memory Map (not filebased)" << std::endl; | |
1623 | ||
1624 | std::unique_ptr<pkgCacheGenerator> Gen{nullptr}; | |
1625 | map_filesize_t CurrentSize = 0; | |
1626 | std::vector<pkgIndexFile*> VolatileFiles = List.GetVolatileFiles(); | |
1627 | map_filesize_t TotalSize = ComputeSize(NULL, VolatileFiles.begin(), VolatileFiles.end()); | |
1628 | if (srcpkgcache_fine == true && pkgcache_fine == false) | |
1629 | { | |
1630 | if (Debug == true) | |
1631 | std::clog << "srcpkgcache.bin was valid - populate MMap with it" << std::endl; | |
1632 | if (loadBackMMapFromFile(Gen, Map, Progress, SrcCacheFile) == false) | |
1633 | return false; | |
1634 | srcpkgcache_fine = true; | |
1635 | TotalSize += ComputeSize(NULL, Files.begin(), Files.end()); | |
1636 | } | |
1637 | else if (srcpkgcache_fine == false) | |
1638 | { | |
1639 | if (Debug == true) | |
1640 | std::clog << "srcpkgcache.bin is NOT valid - rebuild" << std::endl; | |
1641 | Gen.reset(new pkgCacheGenerator(Map.get(),Progress)); | |
1642 | ||
1643 | TotalSize += ComputeSize(&List, Files.begin(),Files.end()); | |
1644 | if (BuildCache(*Gen, Progress, CurrentSize, TotalSize, &List, | |
1645 | Files.end(),Files.end()) == false) | |
1646 | return false; | |
1647 | ||
1648 | if (Writeable == true && SrcCacheFile.empty() == false) | |
1649 | if (writeBackMMapToFile(Gen.get(), Map.get(), SrcCacheFile) == false) | |
1650 | return false; | |
1651 | } | |
1652 | ||
1653 | if (pkgcache_fine == false) | |
1654 | { | |
1655 | if (Debug == true) | |
1656 | std::clog << "Building status cache in pkgcache.bin now" << std::endl; | |
1657 | if (BuildCache(*Gen, Progress, CurrentSize, TotalSize, NULL, | |
1658 | Files.begin(), Files.end()) == false) | |
1659 | return false; | |
1660 | ||
1661 | if (Writeable == true && CacheFile.empty() == false) | |
1662 | if (writeBackMMapToFile(Gen.get(), Map.get(), CacheFile) == false) | |
1663 | return false; | |
1664 | } | |
1665 | ||
1666 | if (Debug == true) | |
1667 | std::clog << "Caches done. Now bring in the volatile files (if any)" << std::endl; | |
1668 | ||
1669 | if (volatile_fine == false) | |
1670 | { | |
1671 | if (Gen == nullptr) | |
1672 | { | |
1673 | if (Debug == true) | |
1674 | std::clog << "Populate new MMap with cachefile contents" << std::endl; | |
1675 | if (loadBackMMapFromFile(Gen, Map, Progress, CacheFile) == false) | |
1676 | return false; | |
1677 | } | |
1678 | ||
1679 | Files = List.GetVolatileFiles(); | |
1680 | if (BuildCache(*Gen, Progress, CurrentSize, TotalSize, NULL, | |
1681 | Files.begin(), Files.end()) == false) | |
1682 | return false; | |
1683 | } | |
1684 | ||
1685 | if (OutMap != nullptr) | |
1686 | *OutMap = Map.release(); | |
1687 | ||
1688 | if (Debug == true) | |
1689 | std::clog << "Everything is ready for shipping" << std::endl; | |
1690 | return true; | |
1691 | } | |
1692 | /*}}}*/ | |
1693 | // CacheGenerator::MakeOnlyStatusCache - Build only a status files cache/*{{{*/ | |
1694 | // --------------------------------------------------------------------- | |
1695 | /* */ | |
1696 | APT_DEPRECATED bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap) | |
1697 | { return pkgCacheGenerator::MakeOnlyStatusCache(&Progress, OutMap); } | |
1698 | bool pkgCacheGenerator::MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **OutMap) | |
1699 | { | |
1700 | std::vector<pkgIndexFile *> Files; | |
1701 | if (_system->AddStatusFiles(Files) == false) | |
1702 | return false; | |
1703 | ||
1704 | std::unique_ptr<DynamicMMap> Map(CreateDynamicMMap(NULL, 0)); | |
1705 | map_filesize_t CurrentSize = 0; | |
1706 | map_filesize_t TotalSize = 0; | |
1707 | ||
1708 | TotalSize = ComputeSize(NULL, Files.begin(), Files.end()); | |
1709 | ||
1710 | // Build the status cache | |
1711 | if (Progress != NULL) | |
1712 | Progress->OverallProgress(0,1,1,_("Reading package lists")); | |
1713 | pkgCacheGenerator Gen(Map.get(),Progress); | |
1714 | if (_error->PendingError() == true) | |
1715 | return false; | |
1716 | if (BuildCache(Gen,Progress,CurrentSize,TotalSize, NULL, | |
1717 | Files.begin(), Files.end()) == false) | |
1718 | return false; | |
1719 | ||
1720 | if (_error->PendingError() == true) | |
1721 | return false; | |
1722 | *OutMap = Map.release(); | |
1723 | ||
1724 | return true; | |
1725 | } | |
1726 | /*}}}*/ | |
1727 | // IsDuplicateDescription /*{{{*/ | |
1728 | static bool IsDuplicateDescription(pkgCache::DescIterator Desc, | |
1729 | MD5SumValue const &CurMd5, std::string const &CurLang) | |
1730 | { | |
1731 | // Descriptions in the same link-list have all the same md5 | |
1732 | if (Desc.end() == true || MD5SumValue(Desc.md5()) != CurMd5) | |
1733 | return false; | |
1734 | for (; Desc.end() == false; ++Desc) | |
1735 | if (Desc.LanguageCode() == CurLang) | |
1736 | return true; | |
1737 | return false; | |
1738 | } | |
1739 | /*}}}*/ | |
1740 | ||
1741 | pkgCacheListParser::pkgCacheListParser() : Owner(NULL), OldDepLast(NULL), d(NULL) {} | |
1742 | pkgCacheListParser::~pkgCacheListParser() {} |