]> git.saurik.com Git - apt.git/blame_incremental - apt-pkg/pkgcachegen.cc
projects / apt.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
detect and deal with indextarget duplicates
[apt.git] / apt-pkg / pkgcachegen.cc
... / ...
CommitLineData
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
44template<class T> using Dynamic = pkgCacheGenerator::Dynamic<T>; /*}}}*/
45typedef std::vector<pkgIndexFile *>::iterator FileIterator;
46template <typename Iter> std::vector<Iter*> pkgCacheGenerator::Dynamic<Iter>::toReMap;
47
48static bool IsDuplicateDescription(pkgCache::DescIterator Desc,
49 MD5SumValue const &CurMd5, std::string const &CurLang);
50
51using std::string;
52
53// CacheGenerator::pkgCacheGenerator - Constructor /*{{{*/
54// ---------------------------------------------------------------------
55/* We set the dirty flag and make sure that is written to the disk */
56pkgCacheGenerator::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 */
125pkgCacheGenerator::~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 /*}}}*/
137void 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 /*{{{*/
175map_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 /*{{{*/
185map_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 /*}}}*/
193map_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. */
205bool 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 /*{{{*/
272bool 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 /*{{{*/
292bool 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 /*{{{*/
334bool 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 /*}}}*/
467bool 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 */
498bool 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 */
530bool 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 return true;
633}
634 /*}}}*/
635// CacheGenerator::AddImplicitDepends /*{{{*/
636bool pkgCacheGenerator::AddImplicitDepends(pkgCache::GrpIterator &G,
637 pkgCache::PkgIterator &P,
638 pkgCache::VerIterator &V)
639{
640 // copy P.Arch() into a string here as a cache remap
641 // in NewDepends() later may alter the pointer location
642 string Arch = P.Arch() == NULL ? "" : P.Arch();
643 map_pointer_t *OldDepLast = NULL;
644 /* MultiArch handling introduces a lot of implicit Dependencies:
645 - MultiArch: same → Co-Installable if they have the same version
646 - All others conflict with all other group members */
647 bool const coInstall = ((V->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same);
648 pkgCache::PkgIterator D = G.PackageList();
649 Dynamic<pkgCache::PkgIterator> DynD(D);
650 map_stringitem_t const VerStrIdx = V->VerStr;
651 for (; D.end() != true; D = G.NextPkg(D))
652 {
653 if (Arch == D.Arch() || D->VersionList == 0)
654 continue;
655 /* We allow only one installed arch at the time
656 per group, therefore each group member conflicts
657 with all other group members */
658 if (coInstall == true)
659 {
660 // Replaces: ${self}:other ( << ${binary:Version})
661 NewDepends(D, V, VerStrIdx,
662 pkgCache::Dep::Less | pkgCache::Dep::MultiArchImplicit, pkgCache::Dep::Replaces,
663 OldDepLast);
664 // Breaks: ${self}:other (!= ${binary:Version})
665 NewDepends(D, V, VerStrIdx,
666 pkgCache::Dep::NotEquals | pkgCache::Dep::MultiArchImplicit, pkgCache::Dep::DpkgBreaks,
667 OldDepLast);
668 } else {
669 // Conflicts: ${self}:other
670 NewDepends(D, V, 0,
671 pkgCache::Dep::NoOp | pkgCache::Dep::MultiArchImplicit, pkgCache::Dep::Conflicts,
672 OldDepLast);
673 }
674 }
675 return true;
676}
677bool pkgCacheGenerator::AddImplicitDepends(pkgCache::VerIterator &V,
678 pkgCache::PkgIterator &D)
679{
680 /* MultiArch handling introduces a lot of implicit Dependencies:
681 - MultiArch: same → Co-Installable if they have the same version
682 - All others conflict with all other group members */
683 map_pointer_t *OldDepLast = NULL;
684 bool const coInstall = ((V->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same);
685 if (coInstall == true)
686 {
687 map_stringitem_t const VerStrIdx = V->VerStr;
688 // Replaces: ${self}:other ( << ${binary:Version})
689 NewDepends(D, V, VerStrIdx,
690 pkgCache::Dep::Less | pkgCache::Dep::MultiArchImplicit, pkgCache::Dep::Replaces,
691 OldDepLast);
692 // Breaks: ${self}:other (!= ${binary:Version})
693 NewDepends(D, V, VerStrIdx,
694 pkgCache::Dep::NotEquals | pkgCache::Dep::MultiArchImplicit, pkgCache::Dep::DpkgBreaks,
695 OldDepLast);
696 } else {
697 // Conflicts: ${self}:other
698 NewDepends(D, V, 0,
699 pkgCache::Dep::NoOp | pkgCache::Dep::MultiArchImplicit, pkgCache::Dep::Conflicts,
700 OldDepLast);
701 }
702 return true;
703}
704
705 /*}}}*/
706// CacheGenerator::NewFileVer - Create a new File<->Version association /*{{{*/
707// ---------------------------------------------------------------------
708/* */
709bool pkgCacheGenerator::NewFileVer(pkgCache::VerIterator &Ver,
710 ListParser &List)
711{
712 if (CurrentFile == 0)
713 return true;
714
715 // Get a structure
716 map_pointer_t const VerFile = AllocateInMap(sizeof(pkgCache::VerFile));
717 if (VerFile == 0)
718 return false;
719
720 pkgCache::VerFileIterator VF(Cache,Cache.VerFileP + VerFile);
721 VF->File = CurrentFile - Cache.PkgFileP;
722
723 // Link it to the end of the list
724 map_pointer_t *Last = &Ver->FileList;
725 for (pkgCache::VerFileIterator V = Ver.FileList(); V.end() == false; ++V)
726 Last = &V->NextFile;
727 VF->NextFile = *Last;
728 *Last = VF.Index();
729
730 VF->Offset = List.Offset();
731 VF->Size = List.Size();
732 if (Cache.HeaderP->MaxVerFileSize < VF->Size)
733 Cache.HeaderP->MaxVerFileSize = VF->Size;
734 Cache.HeaderP->VerFileCount++;
735
736 return true;
737}
738 /*}}}*/
739// CacheGenerator::NewVersion - Create a new Version /*{{{*/
740// ---------------------------------------------------------------------
741/* This puts a version structure in the linked list */
742map_pointer_t pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
743 const string &VerStr,
744 map_pointer_t const ParentPkg,
745 unsigned short const Hash,
746 map_pointer_t const Next)
747{
748 // Get a structure
749 map_pointer_t const Version = AllocateInMap(sizeof(pkgCache::Version));
750 if (Version == 0)
751 return 0;
752
753 // Fill it in
754 Ver = pkgCache::VerIterator(Cache,Cache.VerP + Version);
755 //Dynamic<pkgCache::VerIterator> DynV(Ver); // caller MergeListVersion already takes care of it
756 Ver->NextVer = Next;
757 Ver->ParentPkg = ParentPkg;
758 Ver->Hash = Hash;
759 Ver->ID = Cache.HeaderP->VersionCount++;
760
761 // try to find the version string in the group for reuse
762 pkgCache::PkgIterator Pkg = Ver.ParentPkg();
763 pkgCache::GrpIterator Grp = Pkg.Group();
764 if (Pkg.end() == false && Grp.end() == false)
765 {
766 for (pkgCache::PkgIterator P = Grp.PackageList(); P.end() == false; P = Grp.NextPkg(P))
767 {
768 if (Pkg == P)
769 continue;
770 for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
771 {
772 int const cmp = strcmp(V.VerStr(), VerStr.c_str());
773 if (cmp == 0)
774 {
775 Ver->VerStr = V->VerStr;
776 return Version;
777 }
778 else if (cmp < 0)
779 break;
780 }
781 }
782 }
783 // haven't found the version string, so create
784 map_stringitem_t const idxVerStr = StoreString(VERSIONNUMBER, VerStr);
785 if (unlikely(idxVerStr == 0))
786 return 0;
787 Ver->VerStr = idxVerStr;
788 return Version;
789}
790 /*}}}*/
791// CacheGenerator::NewFileDesc - Create a new File<->Desc association /*{{{*/
792// ---------------------------------------------------------------------
793/* */
794bool pkgCacheGenerator::NewFileDesc(pkgCache::DescIterator &Desc,
795 ListParser &List)
796{
797 if (CurrentFile == 0)
798 return true;
799
800 // Get a structure
801 map_pointer_t const DescFile = AllocateInMap(sizeof(pkgCache::DescFile));
802 if (DescFile == 0)
803 return false;
804
805 pkgCache::DescFileIterator DF(Cache,Cache.DescFileP + DescFile);
806 DF->File = CurrentFile - Cache.PkgFileP;
807
808 // Link it to the end of the list
809 map_pointer_t *Last = &Desc->FileList;
810 for (pkgCache::DescFileIterator D = Desc.FileList(); D.end() == false; ++D)
811 Last = &D->NextFile;
812
813 DF->NextFile = *Last;
814 *Last = DF.Index();
815
816 DF->Offset = List.Offset();
817 DF->Size = List.Size();
818 if (Cache.HeaderP->MaxDescFileSize < DF->Size)
819 Cache.HeaderP->MaxDescFileSize = DF->Size;
820 Cache.HeaderP->DescFileCount++;
821
822 return true;
823}
824 /*}}}*/
825// CacheGenerator::NewDescription - Create a new Description /*{{{*/
826// ---------------------------------------------------------------------
827/* This puts a description structure in the linked list */
828map_pointer_t pkgCacheGenerator::NewDescription(pkgCache::DescIterator &Desc,
829 const string &Lang,
830 const MD5SumValue &md5sum,
831 map_stringitem_t const idxmd5str)
832{
833 // Get a structure
834 map_pointer_t const Description = AllocateInMap(sizeof(pkgCache::Description));
835 if (Description == 0)
836 return 0;
837
838 // Fill it in
839 Desc = pkgCache::DescIterator(Cache,Cache.DescP + Description);
840 Desc->ID = Cache.HeaderP->DescriptionCount++;
841 map_stringitem_t const idxlanguage_code = StoreString(MIXED, Lang);
842 if (unlikely(idxlanguage_code == 0))
843 return 0;
844 Desc->language_code = idxlanguage_code;
845
846 if (idxmd5str != 0)
847 Desc->md5sum = idxmd5str;
848 else
849 {
850 map_stringitem_t const idxmd5sum = WriteStringInMap(md5sum.Value());
851 if (unlikely(idxmd5sum == 0))
852 return 0;
853 Desc->md5sum = idxmd5sum;
854 }
855
856 return Description;
857}
858 /*}}}*/
859// CacheGenerator::NewDepends - Create a dependency element /*{{{*/
860// ---------------------------------------------------------------------
861/* This creates a dependency element in the tree. It is linked to the
862 version and to the package that it is pointing to. */
863bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
864 pkgCache::VerIterator &Ver,
865 map_pointer_t const Version,
866 uint8_t const Op,
867 uint8_t const Type,
868 map_pointer_t* &OldDepLast)
869{
870 void const * const oldMap = Map.Data();
871 // Get a structure
872 map_pointer_t const Dependency = AllocateInMap(sizeof(pkgCache::Dependency));
873 if (unlikely(Dependency == 0))
874 return false;
875
876 bool isDuplicate = false;
877 map_pointer_t DependencyData = 0;
878 map_pointer_t PreviousData = 0;
879 if (Pkg->RevDepends != 0)
880 {
881 pkgCache::Dependency const * const L = Cache.DepP + Pkg->RevDepends;
882 DependencyData = L->DependencyData;
883 do {
884 pkgCache::DependencyData const * const D = Cache.DepDataP + DependencyData;
885 if (Version > D->Version)
886 break;
887 if (D->Version == Version && D->Type == Type && D->CompareOp == Op)
888 {
889 isDuplicate = true;
890 break;
891 }
892 PreviousData = DependencyData;
893 DependencyData = D->NextData;
894 } while (DependencyData != 0);
895 }
896
897 if (isDuplicate == false)
898 {
899 DependencyData = AllocateInMap(sizeof(pkgCache::DependencyData));
900 if (unlikely(DependencyData == 0))
901 return false;
902 }
903
904 pkgCache::Dependency * Link = Cache.DepP + Dependency;
905 Link->ParentVer = Ver.Index();
906 Link->DependencyData = DependencyData;
907 Link->ID = Cache.HeaderP->DependsCount++;
908
909 pkgCache::DepIterator Dep(Cache, Link);
910 if (isDuplicate == false)
911 {
912 Dep->Type = Type;
913 Dep->CompareOp = Op;
914 Dep->Version = Version;
915 Dep->Package = Pkg.Index();
916 ++Cache.HeaderP->DependsDataCount;
917 if (PreviousData != 0)
918 {
919 pkgCache::DependencyData * const D = Cache.DepDataP + PreviousData;
920 Dep->NextData = D->NextData;
921 D->NextData = DependencyData;
922 }
923 else if (Pkg->RevDepends != 0)
924 {
925 pkgCache::Dependency const * const D = Cache.DepP + Pkg->RevDepends;
926 Dep->NextData = D->DependencyData;
927 }
928 }
929
930 if (isDuplicate == true || PreviousData != 0)
931 {
932 pkgCache::Dependency * const L = Cache.DepP + Pkg->RevDepends;
933 Link->NextRevDepends = L->NextRevDepends;
934 L->NextRevDepends = Dependency;
935 }
936 else
937 {
938 Link->NextRevDepends = Pkg->RevDepends;
939 Pkg->RevDepends = Dependency;
940 }
941
942
943 // Do we know where to link the Dependency to?
944 if (OldDepLast == NULL)
945 {
946 OldDepLast = &Ver->DependsList;
947 for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; ++D)
948 OldDepLast = &D->NextDepends;
949 } else if (oldMap != Map.Data())
950 OldDepLast += (map_pointer_t const * const) Map.Data() - (map_pointer_t const * const) oldMap;
951
952 Dep->NextDepends = *OldDepLast;
953 *OldDepLast = Dependency;
954 OldDepLast = &Dep->NextDepends;
955 return true;
956}
957 /*}}}*/
958// ListParser::NewDepends - Create the environment for a new dependency /*{{{*/
959// ---------------------------------------------------------------------
960/* This creates a Group and the Package to link this dependency to if
961 needed and handles also the caching of the old endpoint */
962bool pkgCacheListParser::NewDepends(pkgCache::VerIterator &Ver,
963 const string &PackageName,
964 const string &Arch,
965 const string &Version,
966 uint8_t const Op,
967 uint8_t const Type)
968{
969 pkgCache::GrpIterator Grp;
970 Dynamic<pkgCache::GrpIterator> DynGrp(Grp);
971 if (unlikely(Owner->NewGroup(Grp, PackageName) == false))
972 return false;
973
974 map_stringitem_t idxVersion = 0;
975 if (Version.empty() == false)
976 {
977 int const CmpOp = Op & 0x0F;
978 // =-deps are used (79:1) for lockstep on same-source packages (e.g. data-packages)
979 if (CmpOp == pkgCache::Dep::Equals && strcmp(Version.c_str(), Ver.VerStr()) == 0)
980 idxVersion = Ver->VerStr;
981
982 if (idxVersion == 0)
983 {
984 idxVersion = StoreString(pkgCacheGenerator::VERSIONNUMBER, Version);
985 if (unlikely(idxVersion == 0))
986 return false;
987 }
988 }
989
990 bool const isNegative = (Type == pkgCache::Dep::DpkgBreaks ||
991 Type == pkgCache::Dep::Conflicts ||
992 Type == pkgCache::Dep::Replaces);
993
994 pkgCache::PkgIterator Pkg;
995 Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);
996 if (isNegative == false || (Op & pkgCache::Dep::ArchSpecific) == pkgCache::Dep::ArchSpecific || Grp->FirstPackage == 0)
997 {
998 // Locate the target package
999 Pkg = Grp.FindPkg(Arch);
1000 if (Pkg.end() == true) {
1001 if (unlikely(Owner->NewPackage(Pkg, PackageName, Arch) == false))
1002 return false;
1003 }
1004
1005 /* Caching the old end point speeds up generation substantially */
1006 if (OldDepVer != Ver) {
1007 OldDepLast = NULL;
1008 OldDepVer = Ver;
1009 }
1010
1011 return Owner->NewDepends(Pkg, Ver, idxVersion, Op, Type, OldDepLast);
1012 }
1013 else
1014 {
1015 /* Caching the old end point speeds up generation substantially */
1016 if (OldDepVer != Ver) {
1017 OldDepLast = NULL;
1018 OldDepVer = Ver;
1019 }
1020
1021 for (Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
1022 {
1023 if (Owner->NewDepends(Pkg, Ver, idxVersion, Op, Type, OldDepLast) == false)
1024 return false;
1025 }
1026 }
1027 return true;
1028}
1029 /*}}}*/
1030// ListParser::NewProvides - Create a Provides element /*{{{*/
1031bool pkgCacheListParser::NewProvides(pkgCache::VerIterator &Ver,
1032 const string &PkgName,
1033 const string &PkgArch,
1034 const string &Version,
1035 uint8_t const Flags)
1036{
1037 pkgCache const &Cache = Owner->Cache;
1038
1039 // We do not add self referencing provides
1040 if (Ver.ParentPkg().Name() == PkgName && (PkgArch == Ver.ParentPkg().Arch() ||
1041 (PkgArch == "all" && strcmp((Cache.StrP + Cache.HeaderP->Architecture), Ver.ParentPkg().Arch()) == 0)))
1042 return true;
1043
1044 // Locate the target package
1045 pkgCache::PkgIterator Pkg;
1046 Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);
1047 if (unlikely(Owner->NewPackage(Pkg,PkgName, PkgArch) == false))
1048 return false;
1049
1050 map_stringitem_t idxProvideVersion = 0;
1051 if (Version.empty() == false) {
1052 idxProvideVersion = StoreString(pkgCacheGenerator::VERSIONNUMBER, Version);
1053 if (unlikely(idxProvideVersion == 0))
1054 return false;
1055 }
1056 return Owner->NewProvides(Ver, Pkg, idxProvideVersion, Flags);
1057}
1058bool pkgCacheGenerator::NewProvides(pkgCache::VerIterator &Ver,
1059 pkgCache::PkgIterator &Pkg,
1060 map_pointer_t const ProvideVersion,
1061 uint8_t const Flags)
1062{
1063 // Get a structure
1064 map_pointer_t const Provides = AllocateInMap(sizeof(pkgCache::Provides));
1065 if (unlikely(Provides == 0))
1066 return false;
1067 ++Cache.HeaderP->ProvidesCount;
1068
1069 // Fill it in
1070 pkgCache::PrvIterator Prv(Cache,Cache.ProvideP + Provides,Cache.PkgP);
1071 Prv->Version = Ver.Index();
1072 Prv->ProvideVersion = ProvideVersion;
1073 Prv->Flags = Flags;
1074 Prv->NextPkgProv = Ver->ProvidesList;
1075 Ver->ProvidesList = Prv.Index();
1076
1077 // Link it to the package
1078 Prv->ParentPkg = Pkg.Index();
1079 Prv->NextProvides = Pkg->ProvidesList;
1080 Pkg->ProvidesList = Prv.Index();
1081 return true;
1082}
1083 /*}}}*/
1084// ListParser::NewProvidesAllArch - add provides for all architectures /*{{{*/
1085bool pkgCacheListParser::NewProvidesAllArch(pkgCache::VerIterator &Ver, string const &Package,
1086 string const &Version, uint8_t const Flags) {
1087 pkgCache &Cache = Owner->Cache;
1088 pkgCache::GrpIterator Grp = Cache.FindGrp(Package);
1089 Dynamic<pkgCache::GrpIterator> DynGrp(Grp);
1090
1091 if (Grp.end() == true)
1092 return NewProvides(Ver, Package, Cache.NativeArch(), Version, Flags);
1093 else
1094 {
1095 map_stringitem_t idxProvideVersion = 0;
1096 if (Version.empty() == false) {
1097 idxProvideVersion = StoreString(pkgCacheGenerator::VERSIONNUMBER, Version);
1098 if (unlikely(idxProvideVersion == 0))
1099 return false;
1100 }
1101
1102 bool const isImplicit = (Flags & pkgCache::Flag::MultiArchImplicit) == pkgCache::Flag::MultiArchImplicit;
1103 bool const isArchSpecific = (Flags & pkgCache::Flag::ArchSpecific) == pkgCache::Flag::ArchSpecific;
1104 pkgCache::PkgIterator OwnerPkg = Ver.ParentPkg();
1105 Dynamic<pkgCache::PkgIterator> DynOwnerPkg(OwnerPkg);
1106 pkgCache::PkgIterator Pkg;
1107 Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);
1108 for (Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
1109 {
1110 if (isImplicit && OwnerPkg == Pkg)
1111 continue;
1112 if (isArchSpecific == false && APT::Configuration::checkArchitecture(OwnerPkg.Arch()) == false)
1113 continue;
1114 if (Owner->NewProvides(Ver, Pkg, idxProvideVersion, Flags) == false)
1115 return false;
1116 }
1117 }
1118 return true;
1119}
1120 /*}}}*/
1121bool pkgCacheListParser::SameVersion(unsigned short const Hash, /*{{{*/
1122 pkgCache::VerIterator const &Ver)
1123{
1124 return Hash == Ver->Hash;
1125}
1126 /*}}}*/
1127// CacheGenerator::SelectReleaseFile - Select the current release file the indexes belong to /*{{{*/
1128bool pkgCacheGenerator::SelectReleaseFile(const string &File,const string &Site,
1129 unsigned long Flags)
1130{
1131 if (File.empty() && Site.empty())
1132 {
1133 CurrentRlsFile = NULL;
1134 return true;
1135 }
1136
1137 // Get some space for the structure
1138 map_pointer_t const idxFile = AllocateInMap(sizeof(*CurrentRlsFile));
1139 if (unlikely(idxFile == 0))
1140 return false;
1141 CurrentRlsFile = Cache.RlsFileP + idxFile;
1142
1143 // Fill it in
1144 map_stringitem_t const idxFileName = WriteStringInMap(File);
1145 map_stringitem_t const idxSite = StoreString(MIXED, Site);
1146 if (unlikely(idxFileName == 0 || idxSite == 0))
1147 return false;
1148 CurrentRlsFile->FileName = idxFileName;
1149 CurrentRlsFile->Site = idxSite;
1150 CurrentRlsFile->NextFile = Cache.HeaderP->RlsFileList;
1151 CurrentRlsFile->Flags = Flags;
1152 CurrentRlsFile->ID = Cache.HeaderP->ReleaseFileCount;
1153 RlsFileName = File;
1154 Cache.HeaderP->RlsFileList = CurrentRlsFile - Cache.RlsFileP;
1155 Cache.HeaderP->ReleaseFileCount++;
1156
1157 return true;
1158}
1159 /*}}}*/
1160// CacheGenerator::SelectFile - Select the current file being parsed /*{{{*/
1161// ---------------------------------------------------------------------
1162/* This is used to select which file is to be associated with all newly
1163 added versions. The caller is responsible for setting the IMS fields. */
1164bool pkgCacheGenerator::SelectFile(std::string const &File,
1165 pkgIndexFile const &Index,
1166 std::string const &Architecture,
1167 std::string const &Component,
1168 unsigned long const Flags)
1169{
1170 // Get some space for the structure
1171 map_pointer_t const idxFile = AllocateInMap(sizeof(*CurrentFile));
1172 if (unlikely(idxFile == 0))
1173 return false;
1174 CurrentFile = Cache.PkgFileP + idxFile;
1175
1176 // Fill it in
1177 map_stringitem_t const idxFileName = WriteStringInMap(File);
1178 if (unlikely(idxFileName == 0))
1179 return false;
1180 CurrentFile->FileName = idxFileName;
1181 CurrentFile->NextFile = Cache.HeaderP->FileList;
1182 CurrentFile->ID = Cache.HeaderP->PackageFileCount;
1183 map_stringitem_t const idxIndexType = StoreString(MIXED, Index.GetType()->Label);
1184 if (unlikely(idxIndexType == 0))
1185 return false;
1186 CurrentFile->IndexType = idxIndexType;
1187 if (Architecture.empty())
1188 CurrentFile->Architecture = 0;
1189 else
1190 {
1191 map_stringitem_t const arch = StoreString(pkgCacheGenerator::MIXED, Architecture);
1192 if (unlikely(arch == 0))
1193 return false;
1194 CurrentFile->Architecture = arch;
1195 }
1196 map_stringitem_t const component = StoreString(pkgCacheGenerator::MIXED, Component);
1197 if (unlikely(component == 0))
1198 return false;
1199 CurrentFile->Component = component;
1200 CurrentFile->Flags = Flags;
1201 if (CurrentRlsFile != NULL)
1202 CurrentFile->Release = CurrentRlsFile - Cache.RlsFileP;
1203 else
1204 CurrentFile->Release = 0;
1205 PkgFileName = File;
1206 Cache.HeaderP->FileList = CurrentFile - Cache.PkgFileP;
1207 Cache.HeaderP->PackageFileCount++;
1208
1209 if (Progress != 0)
1210 Progress->SubProgress(Index.Size());
1211 return true;
1212}
1213 /*}}}*/
1214// CacheGenerator::WriteUniqueString - Insert a unique string /*{{{*/
1215// ---------------------------------------------------------------------
1216/* This is used to create handles to strings. Given the same text it
1217 always returns the same number */
1218map_stringitem_t pkgCacheGenerator::StoreString(enum StringType const type, const char *S,
1219 unsigned int Size)
1220{
1221 std::string const key(S, Size);
1222
1223 std::map<std::string,map_stringitem_t> * strings;
1224 switch(type) {
1225 case MIXED: strings = &strMixed; break;
1226 case PKGNAME: strings = &strPkgNames; break;
1227 case VERSIONNUMBER: strings = &strVersions; break;
1228 case SECTION: strings = &strSections; break;
1229 default: _error->Fatal("Unknown enum type used for string storage of '%s'", key.c_str()); return 0;
1230 }
1231
1232 std::map<std::string,map_stringitem_t>::const_iterator const item = strings->find(key);
1233 if (item != strings->end())
1234 return item->second;
1235
1236 map_stringitem_t const idxString = WriteStringInMap(S,Size);
1237 strings->insert(std::make_pair(key, idxString));
1238 return idxString;
1239}
1240 /*}}}*/
1241// CheckValidity - Check that a cache is up-to-date /*{{{*/
1242// ---------------------------------------------------------------------
1243/* This just verifies that each file in the list of index files exists,
1244 has matching attributes with the cache and the cache does not have
1245 any extra files. */
1246static bool CheckValidity(const string &CacheFile,
1247 pkgSourceList &List,
1248 FileIterator const Start,
1249 FileIterator const End,
1250 MMap **OutMap = 0)
1251{
1252 bool const Debug = _config->FindB("Debug::pkgCacheGen", false);
1253 // No file, certainly invalid
1254 if (CacheFile.empty() == true || FileExists(CacheFile) == false)
1255 {
1256 if (Debug == true)
1257 std::clog << "CacheFile " << CacheFile << " doesn't exist" << std::endl;
1258 return false;
1259 }
1260
1261 if (List.GetLastModifiedTime() > GetModificationTime(CacheFile))
1262 {
1263 if (Debug == true)
1264 std::clog << "sources.list is newer than the cache" << std::endl;
1265 return false;
1266 }
1267
1268 // Map it
1269 FileFd CacheF(CacheFile,FileFd::ReadOnly);
1270 std::unique_ptr<MMap> Map(new MMap(CacheF,0));
1271 pkgCache Cache(Map.get());
1272 if (_error->PendingError() == true || Map->Size() == 0)
1273 {
1274 if (Debug == true)
1275 std::clog << "Errors are pending or Map is empty() for " << CacheFile << std::endl;
1276 _error->Discard();
1277 return false;
1278 }
1279
1280 std::unique_ptr<bool[]> RlsVisited(new bool[Cache.HeaderP->ReleaseFileCount]);
1281 memset(RlsVisited.get(),0,sizeof(RlsVisited[0])*Cache.HeaderP->ReleaseFileCount);
1282 std::vector<pkgIndexFile *> Files;
1283 for (pkgSourceList::const_iterator i = List.begin(); i != List.end(); ++i)
1284 {
1285 if (Debug == true)
1286 std::clog << "Checking RlsFile " << (*i)->Describe() << ": ";
1287 pkgCache::RlsFileIterator const RlsFile = (*i)->FindInCache(Cache, true);
1288 if (RlsFile.end() == true)
1289 {
1290 if (Debug == true)
1291 std::clog << "FindInCache returned end-Pointer" << std::endl;
1292 return false;
1293 }
1294
1295 RlsVisited[RlsFile->ID] = true;
1296 if (Debug == true)
1297 std::clog << "with ID " << RlsFile->ID << " is valid" << std::endl;
1298
1299 std::vector <pkgIndexFile *> const * const Indexes = (*i)->GetIndexFiles();
1300 std::copy_if(Indexes->begin(), Indexes->end(), std::back_inserter(Files),
1301 [](pkgIndexFile const * const I) { return I->HasPackages(); });
1302 }
1303 for (unsigned I = 0; I != Cache.HeaderP->ReleaseFileCount; ++I)
1304 if (RlsVisited[I] == false)
1305 {
1306 if (Debug == true)
1307 std::clog << "RlsFile with ID" << I << " wasn't visited" << std::endl;
1308 return false;
1309 }
1310
1311 std::copy(Start, End, std::back_inserter(Files));
1312
1313 /* Now we check every index file, see if it is in the cache,
1314 verify the IMS data and check that it is on the disk too.. */
1315 std::unique_ptr<bool[]> Visited(new bool[Cache.HeaderP->PackageFileCount]);
1316 memset(Visited.get(),0,sizeof(Visited[0])*Cache.HeaderP->PackageFileCount);
1317 for (std::vector<pkgIndexFile *>::const_reverse_iterator PkgFile = Files.rbegin(); PkgFile != Files.rend(); ++PkgFile)
1318 {
1319 if (Debug == true)
1320 std::clog << "Checking PkgFile " << (*PkgFile)->Describe() << ": ";
1321 if ((*PkgFile)->Exists() == false)
1322 {
1323 if (Debug == true)
1324 std::clog << "file doesn't exist" << std::endl;
1325 continue;
1326 }
1327
1328 // FindInCache is also expected to do an IMS check.
1329 pkgCache::PkgFileIterator File = (*PkgFile)->FindInCache(Cache);
1330 if (File.end() == true)
1331 {
1332 if (Debug == true)
1333 std::clog << "FindInCache returned end-Pointer" << std::endl;
1334 return false;
1335 }
1336
1337 Visited[File->ID] = true;
1338 if (Debug == true)
1339 std::clog << "with ID " << File->ID << " is valid" << std::endl;
1340 }
1341
1342 for (unsigned I = 0; I != Cache.HeaderP->PackageFileCount; I++)
1343 if (Visited[I] == false)
1344 {
1345 if (Debug == true)
1346 std::clog << "PkgFile with ID" << I << " wasn't visited" << std::endl;
1347 return false;
1348 }
1349
1350 if (_error->PendingError() == true)
1351 {
1352 if (Debug == true)
1353 {
1354 std::clog << "Validity failed because of pending errors:" << std::endl;
1355 _error->DumpErrors();
1356 }
1357 _error->Discard();
1358 return false;
1359 }
1360
1361 if (OutMap != 0)
1362 *OutMap = Map.release();
1363 return true;
1364}
1365 /*}}}*/
1366// ComputeSize - Compute the total size of a bunch of files /*{{{*/
1367// ---------------------------------------------------------------------
1368/* Size is kind of an abstract notion that is only used for the progress
1369 meter */
1370static map_filesize_t ComputeSize(pkgSourceList const * const List, FileIterator Start,FileIterator End)
1371{
1372 map_filesize_t TotalSize = 0;
1373 if (List != NULL)
1374 {
1375 for (pkgSourceList::const_iterator i = List->begin(); i != List->end(); ++i)
1376 {
1377 std::vector <pkgIndexFile *> *Indexes = (*i)->GetIndexFiles();
1378 for (std::vector<pkgIndexFile *>::const_iterator j = Indexes->begin(); j != Indexes->end(); ++j)
1379 if ((*j)->HasPackages() == true)
1380 TotalSize += (*j)->Size();
1381 }
1382 }
1383
1384 for (; Start < End; ++Start)
1385 {
1386 if ((*Start)->HasPackages() == false)
1387 continue;
1388 TotalSize += (*Start)->Size();
1389 }
1390 return TotalSize;
1391}
1392 /*}}}*/
1393// BuildCache - Merge the list of index files into the cache /*{{{*/
1394static bool BuildCache(pkgCacheGenerator &Gen,
1395 OpProgress * const Progress,
1396 map_filesize_t &CurrentSize,map_filesize_t TotalSize,
1397 pkgSourceList const * const List,
1398 FileIterator const Start, FileIterator const End)
1399{
1400 std::vector<pkgIndexFile *> Files;
1401 bool mergeFailure = false;
1402
1403 auto const indexFileMerge = [&](pkgIndexFile * const I) {
1404 if (I->HasPackages() == false || mergeFailure)
1405 return;
1406
1407 if (I->Exists() == false)
1408 return;
1409
1410 if (I->FindInCache(Gen.GetCache()).end() == false)
1411 {
1412 _error->Warning("Duplicate sources.list entry %s",
1413 I->Describe().c_str());
1414 return;
1415 }
1416
1417 map_filesize_t const Size = I->Size();
1418 if (Progress != NULL)
1419 Progress->OverallProgress(CurrentSize, TotalSize, Size, _("Reading package lists"));
1420 CurrentSize += Size;
1421
1422 if (I->Merge(Gen,Progress) == false)
1423 mergeFailure = true;
1424 };
1425
1426 if (List != NULL)
1427 {
1428 for (pkgSourceList::const_iterator i = List->begin(); i != List->end(); ++i)
1429 {
1430 if ((*i)->FindInCache(Gen.GetCache(), false).end() == false)
1431 {
1432 _error->Warning("Duplicate sources.list entry %s",
1433 (*i)->Describe().c_str());
1434 continue;
1435 }
1436
1437 if ((*i)->Merge(Gen, Progress) == false)
1438 return false;
1439
1440 std::vector <pkgIndexFile *> *Indexes = (*i)->GetIndexFiles();
1441 if (Indexes != NULL)
1442 std::for_each(Indexes->begin(), Indexes->end(), indexFileMerge);
1443 if (mergeFailure)
1444 return false;
1445 }
1446 }
1447
1448 if (Start != End)
1449 {
1450 Gen.SelectReleaseFile("", "");
1451 std::for_each(Start, End, indexFileMerge);
1452 if (mergeFailure)
1453 return false;
1454 }
1455 return true;
1456}
1457 /*}}}*/
1458// CacheGenerator::MakeStatusCache - Construct the status cache /*{{{*/
1459// ---------------------------------------------------------------------
1460/* This makes sure that the status cache (the cache that has all
1461 index files from the sources list and all local ones) is ready
1462 to be mmaped. If OutMap is not zero then a MMap object representing
1463 the cache will be stored there. This is pretty much mandetory if you
1464 are using AllowMem. AllowMem lets the function be run as non-root
1465 where it builds the cache 'fast' into a memory buffer. */
1466static DynamicMMap* CreateDynamicMMap(FileFd * const CacheF, unsigned long Flags)
1467{
1468 map_filesize_t const MapStart = _config->FindI("APT::Cache-Start", 24*1024*1024);
1469 map_filesize_t const MapGrow = _config->FindI("APT::Cache-Grow", 1*1024*1024);
1470 map_filesize_t const MapLimit = _config->FindI("APT::Cache-Limit", 0);
1471 Flags |= MMap::Moveable;
1472 if (_config->FindB("APT::Cache-Fallback", false) == true)
1473 Flags |= MMap::Fallback;
1474 if (CacheF != NULL)
1475 return new DynamicMMap(*CacheF, Flags, MapStart, MapGrow, MapLimit);
1476 else
1477 return new DynamicMMap(Flags, MapStart, MapGrow, MapLimit);
1478}
1479static bool writeBackMMapToFile(pkgCacheGenerator * const Gen, DynamicMMap * const Map,
1480 std::string const &FileName)
1481{
1482 FileFd SCacheF(FileName, FileFd::WriteAtomic);
1483 if (_error->PendingError() == true)
1484 return false;
1485
1486 fchmod(SCacheF.Fd(),0644);
1487
1488 // Write out the main data
1489 if (SCacheF.Write(Map->Data(),Map->Size()) == false)
1490 return _error->Error(_("IO Error saving source cache"));
1491 SCacheF.Sync();
1492
1493 // Write out the proper header
1494 Gen->GetCache().HeaderP->Dirty = false;
1495 if (SCacheF.Seek(0) == false ||
1496 SCacheF.Write(Map->Data(),sizeof(*Gen->GetCache().HeaderP)) == false)
1497 return _error->Error(_("IO Error saving source cache"));
1498 Gen->GetCache().HeaderP->Dirty = true;
1499 SCacheF.Sync();
1500 return true;
1501}
1502static bool loadBackMMapFromFile(std::unique_ptr<pkgCacheGenerator> &Gen,
1503 std::unique_ptr<DynamicMMap> &Map, OpProgress * const Progress, std::string const &FileName)
1504{
1505 Map.reset(CreateDynamicMMap(NULL, 0));
1506 FileFd CacheF(FileName, FileFd::ReadOnly);
1507 map_pointer_t const alloc = Map->RawAllocate(CacheF.Size());
1508 if ((alloc == 0 && _error->PendingError())
1509 || CacheF.Read((unsigned char *)Map->Data() + alloc,
1510 CacheF.Size()) == false)
1511 return false;
1512 Gen.reset(new pkgCacheGenerator(Map.get(),Progress));
1513 return true;
1514}
1515APT_DEPRECATED bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
1516 MMap **OutMap, bool AllowMem)
1517 { return pkgCacheGenerator::MakeStatusCache(List, &Progress, OutMap, AllowMem); }
1518bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress,
1519 MMap **OutMap,bool)
1520{
1521 // FIXME: deprecate the ignored AllowMem parameter
1522 bool const Debug = _config->FindB("Debug::pkgCacheGen", false);
1523
1524 std::vector<pkgIndexFile *> Files;
1525 if (_system->AddStatusFiles(Files) == false)
1526 return false;
1527
1528 // Decide if we can write to the files..
1529 string const CacheFile = _config->FindFile("Dir::Cache::pkgcache");
1530 string const SrcCacheFile = _config->FindFile("Dir::Cache::srcpkgcache");
1531
1532 // ensure the cache directory exists
1533 if (CacheFile.empty() == false || SrcCacheFile.empty() == false)
1534 {
1535 string dir = _config->FindDir("Dir::Cache");
1536 size_t const len = dir.size();
1537 if (len > 5 && dir.find("/apt/", len - 6, 5) == len - 5)
1538 dir = dir.substr(0, len - 5);
1539 if (CacheFile.empty() == false)
1540 CreateDirectory(dir, flNotFile(CacheFile));
1541 if (SrcCacheFile.empty() == false)
1542 CreateDirectory(dir, flNotFile(SrcCacheFile));
1543 }
1544
1545 if (Progress != NULL)
1546 Progress->OverallProgress(0,1,1,_("Reading package lists"));
1547
1548 bool pkgcache_fine = false;
1549 bool srcpkgcache_fine = false;
1550 bool volatile_fine = List.GetVolatileFiles().empty();
1551
1552 if (CheckValidity(CacheFile, List, Files.begin(), Files.end(), volatile_fine ? OutMap : NULL) == true)
1553 {
1554 if (Debug == true)
1555 std::clog << "pkgcache.bin is valid - no need to build any cache" << std::endl;
1556 pkgcache_fine = true;
1557 srcpkgcache_fine = true;
1558 }
1559 if (pkgcache_fine == false)
1560 {
1561 if (CheckValidity(SrcCacheFile, List, Files.end(), Files.end()) == true)
1562 {
1563 if (Debug == true)
1564 std::clog << "srcpkgcache.bin is valid - it can be reused" << std::endl;
1565 srcpkgcache_fine = true;
1566 }
1567 }
1568
1569 if (volatile_fine == true && srcpkgcache_fine == true && pkgcache_fine == true)
1570 {
1571 if (Progress != NULL)
1572 Progress->OverallProgress(1,1,1,_("Reading package lists"));
1573 return true;
1574 }
1575
1576 bool Writeable = false;
1577 if (srcpkgcache_fine == false || pkgcache_fine == false)
1578 {
1579 if (CacheFile.empty() == false)
1580 Writeable = access(flNotFile(CacheFile).c_str(),W_OK) == 0;
1581 else if (SrcCacheFile.empty() == false)
1582 Writeable = access(flNotFile(SrcCacheFile).c_str(),W_OK) == 0;
1583
1584 if (Debug == true)
1585 std::clog << "Do we have write-access to the cache files? " << (Writeable ? "YES" : "NO") << std::endl;
1586 }
1587
1588 // At this point we know we need to construct something, so get storage ready
1589 std::unique_ptr<DynamicMMap> Map(CreateDynamicMMap(NULL, 0));
1590 if (Debug == true)
1591 std::clog << "Open memory Map (not filebased)" << std::endl;
1592
1593 std::unique_ptr<pkgCacheGenerator> Gen{nullptr};
1594 map_filesize_t CurrentSize = 0;
1595 std::vector<pkgIndexFile*> VolatileFiles = List.GetVolatileFiles();
1596 map_filesize_t TotalSize = ComputeSize(NULL, VolatileFiles.begin(), VolatileFiles.end());
1597 if (srcpkgcache_fine == true && pkgcache_fine == false)
1598 {
1599 if (Debug == true)
1600 std::clog << "srcpkgcache.bin was valid - populate MMap with it" << std::endl;
1601 if (loadBackMMapFromFile(Gen, Map, Progress, SrcCacheFile) == false)
1602 return false;
1603 srcpkgcache_fine = true;
1604 TotalSize += ComputeSize(NULL, Files.begin(), Files.end());
1605 }
1606 else if (srcpkgcache_fine == false)
1607 {
1608 if (Debug == true)
1609 std::clog << "srcpkgcache.bin is NOT valid - rebuild" << std::endl;
1610 Gen.reset(new pkgCacheGenerator(Map.get(),Progress));
1611
1612 TotalSize += ComputeSize(&List, Files.begin(),Files.end());
1613 if (BuildCache(*Gen, Progress, CurrentSize, TotalSize, &List,
1614 Files.end(),Files.end()) == false)
1615 return false;
1616
1617 if (Writeable == true && SrcCacheFile.empty() == false)
1618 if (writeBackMMapToFile(Gen.get(), Map.get(), SrcCacheFile) == false)
1619 return false;
1620 }
1621
1622 if (pkgcache_fine == false)
1623 {
1624 if (Debug == true)
1625 std::clog << "Building status cache in pkgcache.bin now" << std::endl;
1626 if (BuildCache(*Gen, Progress, CurrentSize, TotalSize, NULL,
1627 Files.begin(), Files.end()) == false)
1628 return false;
1629
1630 if (Writeable == true && CacheFile.empty() == false)
1631 if (writeBackMMapToFile(Gen.get(), Map.get(), CacheFile) == false)
1632 return false;
1633 }
1634
1635 if (Debug == true)
1636 std::clog << "Caches done. Now bring in the volatile files (if any)" << std::endl;
1637
1638 if (volatile_fine == false)
1639 {
1640 if (Gen == nullptr)
1641 {
1642 if (Debug == true)
1643 std::clog << "Populate new MMap with cachefile contents" << std::endl;
1644 if (loadBackMMapFromFile(Gen, Map, Progress, CacheFile) == false)
1645 return false;
1646 }
1647
1648 Files = List.GetVolatileFiles();
1649 if (BuildCache(*Gen, Progress, CurrentSize, TotalSize, NULL,
1650 Files.begin(), Files.end()) == false)
1651 return false;
1652 }
1653
1654 if (OutMap != nullptr)
1655 *OutMap = Map.release();
1656
1657 if (Debug == true)
1658 std::clog << "Everything is ready for shipping" << std::endl;
1659 return true;
1660}
1661 /*}}}*/
1662// CacheGenerator::MakeOnlyStatusCache - Build only a status files cache/*{{{*/
1663// ---------------------------------------------------------------------
1664/* */
1665APT_DEPRECATED bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap)
1666 { return pkgCacheGenerator::MakeOnlyStatusCache(&Progress, OutMap); }
1667bool pkgCacheGenerator::MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **OutMap)
1668{
1669 std::vector<pkgIndexFile *> Files;
1670 if (_system->AddStatusFiles(Files) == false)
1671 return false;
1672
1673 std::unique_ptr<DynamicMMap> Map(CreateDynamicMMap(NULL, 0));
1674 map_filesize_t CurrentSize = 0;
1675 map_filesize_t TotalSize = 0;
1676
1677 TotalSize = ComputeSize(NULL, Files.begin(), Files.end());
1678
1679 // Build the status cache
1680 if (Progress != NULL)
1681 Progress->OverallProgress(0,1,1,_("Reading package lists"));
1682 pkgCacheGenerator Gen(Map.get(),Progress);
1683 if (_error->PendingError() == true)
1684 return false;
1685 if (BuildCache(Gen,Progress,CurrentSize,TotalSize, NULL,
1686 Files.begin(), Files.end()) == false)
1687 return false;
1688
1689 if (_error->PendingError() == true)
1690 return false;
1691 *OutMap = Map.release();
1692
1693 return true;
1694}
1695 /*}}}*/
1696// IsDuplicateDescription /*{{{*/
1697static bool IsDuplicateDescription(pkgCache::DescIterator Desc,
1698 MD5SumValue const &CurMd5, std::string const &CurLang)
1699{
1700 // Descriptions in the same link-list have all the same md5
1701 if (Desc.end() == true || MD5SumValue(Desc.md5()) != CurMd5)
1702 return false;
1703 for (; Desc.end() == false; ++Desc)
1704 if (Desc.LanguageCode() == CurLang)
1705 return true;
1706 return false;
1707}
1708 /*}}}*/
1709
1710pkgCacheListParser::pkgCacheListParser() : Owner(NULL), OldDepLast(NULL), d(NULL) {}
1711pkgCacheListParser::~pkgCacheListParser() {}
APT (for Cydia)