]>
Commit | Line | Data |
---|---|---|
578bfd0a AL |
1 | // -*- mode: cpp; mode: fold -*- |
2 | // Description /*{{{*/ | |
dcb79bae | 3 | // $Id: pkgcache.cc,v 1.4 1998/07/05 05:33:53 jgg Exp $ |
578bfd0a AL |
4 | /* ###################################################################### |
5 | ||
6 | Package Cache - Accessor code for the cache | |
7 | ||
8 | Please see doc/pkglib/cache.sgml for a more detailed description of | |
9 | this format. Also be sure to keep that file up-to-date!! | |
10 | ||
11 | This is the general utility functions for cache managment. They provide | |
12 | a complete set of accessor functions for the cache. The cacheiterators | |
13 | header contains the STL-like iterators that can be used to easially | |
14 | navigate the cache as well as seemlessly dereference the mmap'd | |
15 | indexes. Use these always. | |
16 | ||
17 | The main class provides for ways to get package indexes and some | |
18 | general lookup functions to start the iterators. | |
19 | ||
20 | ##################################################################### */ | |
21 | /*}}}*/ | |
22 | // Include Files /*{{{*/ | |
23 | #include <pkglib/pkgcache.h> | |
24 | #include <pkglib/version.h> | |
25 | #include <pkglib/error.h> | |
26 | #include <system.h> | |
27 | ||
28 | #include <string> | |
29 | #include <sys/stat.h> | |
30 | #include <unistd.h> | |
31 | /*}}}*/ | |
32 | ||
33 | // Cache::Header::Header - Constructor /*{{{*/ | |
34 | // --------------------------------------------------------------------- | |
35 | /* Simply initialize the header */ | |
36 | pkgCache::Header::Header() | |
37 | { | |
38 | Signature = 0x98FE76DC; | |
39 | ||
40 | /* Whenever the structures change the major version should be bumped, | |
41 | whenever the generator changes the minor version should be bumped. */ | |
42 | MajorVersion = 2; | |
43 | MinorVersion = 0; | |
44 | Dirty = true; | |
45 | ||
46 | HeaderSz = sizeof(pkgCache::Header); | |
47 | PackageSz = sizeof(pkgCache::Package); | |
48 | PackageFileSz = sizeof(pkgCache::PackageFile); | |
49 | VersionSz = sizeof(pkgCache::Version); | |
50 | DependencySz = sizeof(pkgCache::Dependency); | |
51 | ProvidesSz = sizeof(pkgCache::Provides); | |
dcb79bae AL |
52 | VerFileSz = sizeof(pkgCache::VerFile); |
53 | ||
578bfd0a AL |
54 | PackageCount = 0; |
55 | VersionCount = 0; | |
56 | DependsCount = 0; | |
57 | PackageFileCount = 0; | |
58 | ||
59 | FileList = 0; | |
60 | StringList = 0; | |
61 | memset(HashTable,0,sizeof(HashTable)); | |
62 | memset(Pools,0,sizeof(Pools)); | |
63 | } | |
64 | /*}}}*/ | |
65 | // Cache::Header::CheckSizes - Check if the two headers have same *sz /*{{{*/ | |
66 | // --------------------------------------------------------------------- | |
67 | /* */ | |
68 | bool pkgCache::Header::CheckSizes(Header &Against) const | |
69 | { | |
70 | if (HeaderSz == Against.HeaderSz && | |
71 | PackageSz == Against.PackageSz && | |
72 | PackageFileSz == Against.PackageFileSz && | |
73 | VersionSz == Against.VersionSz && | |
dcb79bae AL |
74 | DependencySz == Against.DependencySz && |
75 | VerFileSz == Against.VerFileSz && | |
578bfd0a AL |
76 | ProvidesSz == Against.ProvidesSz) |
77 | return true; | |
78 | return false; | |
79 | } | |
80 | /*}}}*/ | |
81 | ||
82 | // Cache::pkgCache - Constructor /*{{{*/ | |
83 | // --------------------------------------------------------------------- | |
84 | /* */ | |
85 | pkgCache::pkgCache(MMap &Map) : Map(Map) | |
86 | { | |
87 | ReMap(); | |
88 | } | |
89 | /*}}}*/ | |
90 | // Cache::ReMap - Reopen the cache file /*{{{*/ | |
91 | // --------------------------------------------------------------------- | |
92 | /* If the file is already closed then this will open it open it. */ | |
93 | bool pkgCache::ReMap() | |
94 | { | |
95 | // Apply the typecasts. | |
96 | HeaderP = (Header *)Map.Data(); | |
97 | PkgP = (Package *)Map.Data(); | |
dcb79bae | 98 | VerFileP = (VerFile *)Map.Data(); |
578bfd0a AL |
99 | PkgFileP = (PackageFile *)Map.Data(); |
100 | VerP = (Version *)Map.Data(); | |
101 | ProvideP = (Provides *)Map.Data(); | |
102 | DepP = (Dependency *)Map.Data(); | |
103 | StringItemP = (StringItem *)Map.Data(); | |
104 | StrP = (char *)Map.Data(); | |
105 | ||
578bfd0a AL |
106 | if (Map.Size() == 0) |
107 | return false; | |
108 | ||
109 | // Check the header | |
110 | Header DefHeader; | |
111 | if (HeaderP->Signature != DefHeader.Signature || | |
112 | HeaderP->Dirty == true) | |
113 | return _error->Error("The package cache file is corrupted"); | |
114 | ||
115 | if (HeaderP->MajorVersion != DefHeader.MajorVersion || | |
116 | HeaderP->MinorVersion != DefHeader.MinorVersion || | |
117 | HeaderP->CheckSizes(DefHeader) == false) | |
118 | return _error->Error("The package cache file is an incompatible version"); | |
119 | ||
120 | return true; | |
121 | } | |
122 | /*}}}*/ | |
123 | // Cache::Hash - Hash a string /*{{{*/ | |
124 | // --------------------------------------------------------------------- | |
125 | /* This is used to generate the hash entries for the HashTable. With my | |
126 | package list from bo this function gets 94% table usage on a 512 item | |
127 | table (480 used items) */ | |
128 | unsigned long pkgCache::sHash(string Str) | |
129 | { | |
130 | unsigned long Hash = 0; | |
131 | for (const char *I = Str.begin(); I != Str.end(); I++) | |
132 | Hash += *I * ((Str.end() - I + 1)); | |
133 | Header H; | |
134 | return Hash % _count(H.HashTable); | |
135 | } | |
136 | ||
137 | unsigned long pkgCache::sHash(const char *Str) | |
138 | { | |
139 | unsigned long Hash = 0; | |
140 | const char *End = Str + strlen(Str); | |
141 | for (const char *I = Str; I != End; I++) | |
142 | Hash += *I * ((End - I + 1)); | |
143 | Header H; | |
144 | return Hash % _count(H.HashTable); | |
145 | } | |
146 | ||
147 | /*}}}*/ | |
148 | // Cache::FindPkg - Locate a package by name /*{{{*/ | |
149 | // --------------------------------------------------------------------- | |
150 | /* Returns 0 on error, pointer to the package otherwise */ | |
151 | pkgCache::PkgIterator pkgCache::FindPkg(string Name) | |
152 | { | |
153 | // Look at the hash bucket | |
154 | Package *Pkg = PkgP + HeaderP->HashTable[Hash(Name)]; | |
155 | for (; Pkg != PkgP; Pkg = PkgP + Pkg->NextPackage) | |
156 | { | |
157 | if (Pkg->Name != 0 && StrP + Pkg->Name == Name) | |
158 | return PkgIterator(*this,Pkg); | |
159 | } | |
160 | return PkgIterator(*this,0); | |
161 | } | |
162 | /*}}}*/ | |
0149949b AL |
163 | // Cache::Priority - Convert a priority value to a string /*{{{*/ |
164 | // --------------------------------------------------------------------- | |
165 | /* */ | |
166 | const char *pkgCache::Priority(unsigned char Prio) | |
167 | { | |
168 | const char *Mapping[] = {0,"important","required","standard","optional","extra"}; | |
169 | if (Prio < _count(Mapping)) | |
170 | return Mapping[Prio]; | |
171 | return 0; | |
172 | } | |
173 | /*}}}*/ | |
578bfd0a | 174 | |
f55a958f AL |
175 | // Bases for iterator classes /*{{{*/ |
176 | void pkgCache::VerIterator::_dummy() {} | |
177 | void pkgCache::DepIterator::_dummy() {} | |
178 | void pkgCache::PrvIterator::_dummy() {} | |
179 | /*}}}*/ | |
180 | // PkgIterator::operator ++ - Postfix incr /*{{{*/ | |
578bfd0a AL |
181 | // --------------------------------------------------------------------- |
182 | /* This will advance to the next logical package in the hash table. */ | |
183 | void pkgCache::PkgIterator::operator ++(int) | |
184 | { | |
185 | // Follow the current links | |
186 | if (Pkg != Owner->PkgP) | |
187 | Pkg = Owner->PkgP + Pkg->NextPackage; | |
188 | ||
189 | // Follow the hash table | |
190 | while (Pkg == Owner->PkgP && HashIndex < (signed)_count(Owner->HeaderP->HashTable)) | |
191 | { | |
192 | HashIndex++; | |
193 | Pkg = Owner->PkgP + Owner->HeaderP->HashTable[HashIndex]; | |
194 | } | |
195 | }; | |
196 | /*}}}*/ | |
578bfd0a AL |
197 | // PkgIterator::State - Check the State of the package /*{{{*/ |
198 | // --------------------------------------------------------------------- | |
199 | /* By this we mean if it is either cleanly installed or cleanly removed. */ | |
200 | pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const | |
201 | { | |
f55a958f AL |
202 | if (Pkg->CurrentState == UnPacked || |
203 | Pkg->CurrentState == HalfConfigured) | |
578bfd0a AL |
204 | return NeedsConfigure; |
205 | ||
f55a958f AL |
206 | if (Pkg->CurrentState == UnInstalled || |
207 | Pkg->CurrentState == HalfInstalled || | |
208 | Pkg->InstState != Ok) | |
578bfd0a AL |
209 | return NeedsUnpack; |
210 | ||
211 | return NeedsNothing; | |
212 | } | |
213 | /*}}}*/ | |
214 | // DepIterator::IsCritical - Returns true if the dep is important /*{{{*/ | |
215 | // --------------------------------------------------------------------- | |
216 | /* Currently critical deps are defined as depends, predepends and | |
217 | conflicts. */ | |
218 | bool pkgCache::DepIterator::IsCritical() | |
219 | { | |
f55a958f AL |
220 | if (Dep->Type == Conflicts || Dep->Type == Depends || |
221 | Dep->Type == PreDepends) | |
578bfd0a AL |
222 | return true; |
223 | return false; | |
224 | } | |
225 | /*}}}*/ | |
226 | // DepIterator::SmartTargetPkg - Resolve dep target pointers w/provides /*{{{*/ | |
227 | // --------------------------------------------------------------------- | |
228 | /* This intellegently looks at dep target packages and tries to figure | |
229 | out which package should be used. This is needed to nicely handle | |
230 | provide mapping. If the target package has no other providing packages | |
231 | then it returned. Otherwise the providing list is looked at to | |
232 | see if there is one one unique providing package if so it is returned. | |
233 | Otherwise true is returned and the target package is set. The return | |
234 | result indicates whether the node should be expandable */ | |
235 | bool pkgCache::DepIterator::SmartTargetPkg(PkgIterator &Result) | |
236 | { | |
237 | Result = TargetPkg(); | |
238 | ||
239 | // No provides at all | |
240 | if (Result->ProvidesList == 0) | |
241 | return false; | |
242 | ||
243 | // There is the Base package and the providing ones which is at least 2 | |
244 | if (Result->VersionList != 0) | |
245 | return true; | |
246 | ||
247 | /* We have to skip over indirect provisions of the package that | |
248 | owns the dependency. For instance, if libc5-dev depends on the | |
249 | virtual package libc-dev which is provided by libc5-dev and libc6-dev | |
250 | we must ignore libc5-dev when considering the provides list. */ | |
251 | PrvIterator PStart = Result.ProvidesList(); | |
252 | for (; PStart.end() != true && PStart.OwnerPkg() == ParentPkg(); PStart++); | |
253 | ||
254 | // Nothing but indirect self provides | |
255 | if (PStart.end() == true) | |
256 | return false; | |
257 | ||
258 | // Check for single packages in the provides list | |
259 | PrvIterator P = PStart; | |
260 | for (; P.end() != true; P++) | |
261 | { | |
262 | // Skip over self provides | |
263 | if (P.OwnerPkg() == ParentPkg()) | |
264 | continue; | |
265 | if (PStart.OwnerPkg() != P.OwnerPkg()) | |
266 | break; | |
267 | } | |
268 | ||
269 | // Check for non dups | |
270 | if (P.end() != true) | |
271 | return true; | |
272 | Result = PStart.OwnerPkg(); | |
273 | return false; | |
274 | } | |
275 | /*}}}*/ | |
276 | // DepIterator::AllTargets - Returns the set of all possible targets /*{{{*/ | |
277 | // --------------------------------------------------------------------- | |
278 | /* This is a more usefull version of TargetPkg() that follows versioned | |
279 | provides. It includes every possible package-version that could satisfy | |
280 | the dependency. The last item in the list has a 0. */ | |
281 | pkgCache::Version **pkgCache::DepIterator::AllTargets() | |
282 | { | |
283 | Version **Res = 0; | |
284 | unsigned long Size =0; | |
285 | while (1) | |
286 | { | |
287 | Version **End = Res; | |
288 | PkgIterator DPkg = TargetPkg(); | |
289 | ||
290 | // Walk along the actual package providing versions | |
291 | for (VerIterator I = DPkg.VersionList(); I.end() == false; I++) | |
292 | { | |
293 | if (pkgCheckDep(TargetVer(),I.VerStr(),Dep->CompareOp) == false) | |
294 | continue; | |
295 | ||
f55a958f | 296 | if (Dep->Type == Conflicts && ParentPkg() == I.ParentPkg()) |
578bfd0a AL |
297 | continue; |
298 | ||
299 | Size++; | |
300 | if (Res != 0) | |
301 | *End++ = I; | |
302 | } | |
303 | ||
304 | // Follow all provides | |
305 | for (PrvIterator I = DPkg.ProvidesList(); I.end() == false; I++) | |
306 | { | |
307 | if (pkgCheckDep(TargetVer(),I.ProvideVersion(),Dep->CompareOp) == false) | |
308 | continue; | |
309 | ||
f55a958f | 310 | if (Dep->Type == Conflicts && ParentPkg() == I.OwnerPkg()) |
578bfd0a AL |
311 | continue; |
312 | ||
313 | Size++; | |
314 | if (Res != 0) | |
315 | *End++ = I.OwnerVer(); | |
316 | } | |
317 | ||
318 | // Do it again and write it into the array | |
319 | if (Res == 0) | |
320 | { | |
321 | Res = new Version *[Size+1]; | |
322 | Size = 0; | |
323 | } | |
324 | else | |
325 | { | |
326 | *End = 0; | |
327 | break; | |
328 | } | |
329 | } | |
330 | ||
331 | return Res; | |
332 | } | |
333 | /*}}}*/ | |
334 | // VerIterator::CompareVer - Fast version compare for same pkgs /*{{{*/ | |
335 | // --------------------------------------------------------------------- | |
336 | /* This just looks over the version list to see if B is listed before A. In | |
337 | most cases this will return in under 4 checks, ver lists are short. */ | |
338 | int pkgCache::VerIterator::CompareVer(const VerIterator &B) const | |
339 | { | |
340 | // Check if they are equal | |
341 | if (*this == B) | |
342 | return 0; | |
343 | if (end() == true) | |
344 | return -1; | |
345 | if (B.end() == true) | |
346 | return 1; | |
347 | ||
348 | /* Start at A and look for B. If B is found then A > B otherwise | |
349 | B was before A so A < B */ | |
350 | VerIterator I = *this; | |
351 | for (;I.end() == false; I++) | |
352 | if (I == B) | |
353 | return 1; | |
354 | return -1; | |
355 | } | |
356 | /*}}}*/ | |
357 | // PkgFileIterator::IsOk - Checks if the cache is in sync with the file /*{{{*/ | |
358 | // --------------------------------------------------------------------- | |
359 | /* This stats the file and compares its stats with the ones that were | |
360 | stored during generation. Date checks should probably also be | |
361 | included here. */ | |
362 | bool pkgCache::PkgFileIterator::IsOk() | |
363 | { | |
364 | struct stat Buf; | |
365 | if (stat(FileName(),&Buf) != 0) | |
366 | return false; | |
367 | ||
368 | if (Buf.st_size != (signed)File->Size || Buf.st_mtime != File->mtime) | |
369 | return false; | |
370 | ||
371 | return true; | |
372 | } | |
373 | /*}}}*/ |