Commit | Line | Data |
---|---|---|
f55a958f AL |
1 | // -*- mode: cpp; mode: fold -*- |
2 | // Description /*{{{*/ | |
b3d44315 | 3 | // $Id: deblistparser.cc,v 1.29.2.5 2004/01/06 01:43:44 mdz Exp $ |
f55a958f AL |
4 | /* ###################################################################### |
5 | ||
6 | Package Cache Generator - Generator for the cache structure. | |
7 | ||
8 | This builds the cache structure from the abstract package list parser. | |
9 | ||
10 | ##################################################################### */ | |
11 | /*}}}*/ | |
12 | // Include Files /*{{{*/ | |
094a497d AL |
13 | #include <apt-pkg/deblistparser.h> |
14 | #include <apt-pkg/error.h> | |
15 | #include <apt-pkg/configuration.h> | |
45df0ad2 | 16 | #include <apt-pkg/aptconfiguration.h> |
cdcc6d34 | 17 | #include <apt-pkg/strutl.h> |
204fbdcc | 18 | #include <apt-pkg/crc-16.h> |
a52f938b | 19 | #include <apt-pkg/md5.h> |
9c14e3d6 | 20 | |
e7b470ee AL |
21 | #include <ctype.h> |
22 | ||
f55a958f AL |
23 | #include <system.h> |
24 | /*}}}*/ | |
25 | ||
b2e465d6 AL |
26 | static debListParser::WordList PrioList[] = {{"important",pkgCache::State::Important}, |
27 | {"required",pkgCache::State::Required}, | |
28 | {"standard",pkgCache::State::Standard}, | |
29 | {"optional",pkgCache::State::Optional}, | |
30 | {"extra",pkgCache::State::Extra}, | |
31 | {}}; | |
32 | ||
f55a958f AL |
33 | // ListParser::debListParser - Constructor /*{{{*/ |
34 | // --------------------------------------------------------------------- | |
35 | /* */ | |
b2e465d6 | 36 | debListParser::debListParser(FileFd *File) : Tags(File) |
f55a958f | 37 | { |
ddc1d8d0 | 38 | Arch = _config->Find("APT::architecture"); |
0149949b AL |
39 | } |
40 | /*}}}*/ | |
f55a958f AL |
41 | // ListParser::UniqFindTagWrite - Find the tag and write a unq string /*{{{*/ |
42 | // --------------------------------------------------------------------- | |
43 | /* */ | |
44 | unsigned long debListParser::UniqFindTagWrite(const char *Tag) | |
45 | { | |
46 | const char *Start; | |
47 | const char *Stop; | |
48 | if (Section.Find(Tag,Start,Stop) == false) | |
49 | return 0; | |
50 | return WriteUniqString(Start,Stop - Start); | |
51 | } | |
52 | /*}}}*/ | |
f55a958f AL |
53 | // ListParser::Package - Return the package name /*{{{*/ |
54 | // --------------------------------------------------------------------- | |
55 | /* This is to return the name of the package this section describes */ | |
56 | string debListParser::Package() | |
57 | { | |
b0b4efb9 | 58 | string Result = Section.FindS("Package"); |
f55a958f | 59 | if (Result.empty() == true) |
65a1e968 | 60 | _error->Error("Encountered a section with no Package: header"); |
f55a958f AL |
61 | return Result; |
62 | } | |
63 | /*}}}*/ | |
64 | // ListParser::Version - Return the version string /*{{{*/ | |
65 | // --------------------------------------------------------------------- | |
66 | /* This is to return the string describing the version in debian form, | |
67 | epoch:upstream-release. If this returns the blank string then the | |
68 | entry is assumed to only describe package properties */ | |
69 | string debListParser::Version() | |
70 | { | |
b0b4efb9 | 71 | return Section.FindS("Version"); |
f55a958f AL |
72 | } |
73 | /*}}}*/ | |
f55a958f AL |
74 | // ListParser::NewVersion - Fill in the version structure /*{{{*/ |
75 | // --------------------------------------------------------------------- | |
76 | /* */ | |
77 | bool debListParser::NewVersion(pkgCache::VerIterator Ver) | |
0149949b AL |
78 | { |
79 | // Parse the section | |
b35d2f5f | 80 | Ver->Section = UniqFindTagWrite("Section"); |
17caf1b1 | 81 | Ver->Arch = UniqFindTagWrite("Architecture"); |
0149949b AL |
82 | |
83 | // Archive Size | |
b0b4efb9 | 84 | Ver->Size = (unsigned)Section.FindI("Size"); |
0149949b AL |
85 | |
86 | // Unpacked Size (in K) | |
b0b4efb9 | 87 | Ver->InstalledSize = (unsigned)Section.FindI("Installed-Size"); |
0149949b AL |
88 | Ver->InstalledSize *= 1024; |
89 | ||
90 | // Priority | |
91 | const char *Start; | |
92 | const char *Stop; | |
93 | if (Section.Find("Priority",Start,Stop) == true) | |
b2e465d6 AL |
94 | { |
95 | if (GrabWord(string(Start,Stop-Start),PrioList,Ver->Priority) == false) | |
421c8d10 | 96 | Ver->Priority = pkgCache::State::Extra; |
0149949b | 97 | } |
dcb79bae | 98 | |
6c139d6e | 99 | if (ParseDepends(Ver,"Depends",pkgCache::Dep::Depends) == false) |
dcb79bae | 100 | return false; |
8efa2a3b | 101 | if (ParseDepends(Ver,"Pre-Depends",pkgCache::Dep::PreDepends) == false) |
dcb79bae | 102 | return false; |
6c139d6e | 103 | if (ParseDepends(Ver,"Suggests",pkgCache::Dep::Suggests) == false) |
dcb79bae | 104 | return false; |
6c139d6e | 105 | if (ParseDepends(Ver,"Recommends",pkgCache::Dep::Recommends) == false) |
dcb79bae | 106 | return false; |
6c139d6e | 107 | if (ParseDepends(Ver,"Conflicts",pkgCache::Dep::Conflicts) == false) |
dcb79bae | 108 | return false; |
308c7d30 IJ |
109 | if (ParseDepends(Ver,"Breaks",pkgCache::Dep::DpkgBreaks) == false) |
110 | return false; | |
f55ece0e | 111 | if (ParseDepends(Ver,"Replaces",pkgCache::Dep::Replaces) == false) |
dcb79bae | 112 | return false; |
f8ae7e8b | 113 | if (ParseDepends(Ver,"Enhances",pkgCache::Dep::Enhances) == false) |
114 | return false; | |
dcb79bae | 115 | |
b2e465d6 AL |
116 | // Obsolete. |
117 | if (ParseDepends(Ver,"Optional",pkgCache::Dep::Suggests) == false) | |
118 | return false; | |
119 | ||
dcb79bae AL |
120 | if (ParseProvides(Ver) == false) |
121 | return false; | |
0149949b | 122 | |
f55a958f AL |
123 | return true; |
124 | } | |
125 | /*}}}*/ | |
a52f938b OS |
126 | // ListParser::Description - Return the description string /*{{{*/ |
127 | // --------------------------------------------------------------------- | |
128 | /* This is to return the string describing the package in debian | |
129 | form. If this returns the blank string then the entry is assumed to | |
130 | only describe package properties */ | |
131 | string debListParser::Description() | |
132 | { | |
45df0ad2 DK |
133 | string const lang = DescriptionLanguage(); |
134 | if (lang.empty()) | |
a52f938b OS |
135 | return Section.FindS("Description"); |
136 | else | |
45df0ad2 | 137 | return Section.FindS(string("Description-").append(lang).c_str()); |
a52f938b OS |
138 | } |
139 | /*}}}*/ | |
140 | // ListParser::DescriptionLanguage - Return the description lang string /*{{{*/ | |
141 | // --------------------------------------------------------------------- | |
142 | /* This is to return the string describing the language of | |
143 | description. If this returns the blank string then the entry is | |
144 | assumed to describe original description. */ | |
145 | string debListParser::DescriptionLanguage() | |
146 | { | |
45df0ad2 DK |
147 | if (Section.FindS("Description").empty() == false) |
148 | return ""; | |
149 | ||
150 | std::vector<string> const lang = APT::Configuration::getLanguages(); | |
151 | for (std::vector<string>::const_iterator l = lang.begin(); | |
152 | l != lang.end(); l++) | |
153 | if (Section.FindS(string("Description-").append(*l).c_str()).empty() == false) | |
154 | return *l; | |
155 | ||
156 | return ""; | |
a52f938b OS |
157 | } |
158 | /*}}}*/ | |
159 | // ListParser::Description - Return the description_md5 MD5SumValue /*{{{*/ | |
160 | // --------------------------------------------------------------------- | |
770c32ec MV |
161 | /* This is to return the md5 string to allow the check if it is the right |
162 | description. If no Description-md5 is found in the section it will be | |
163 | calculated. | |
164 | */ | |
a52f938b OS |
165 | MD5SumValue debListParser::Description_md5() |
166 | { | |
167 | string value = Section.FindS("Description-md5"); | |
168 | ||
770c32ec MV |
169 | if (value.empty()) |
170 | { | |
a52f938b OS |
171 | MD5Summation md5; |
172 | md5.Add((Description() + "\n").c_str()); | |
173 | return md5.Result(); | |
174 | } else | |
175 | return MD5SumValue(value); | |
176 | } | |
177 | /*}}}*/ | |
f55a958f AL |
178 | // ListParser::UsePackage - Update a package structure /*{{{*/ |
179 | // --------------------------------------------------------------------- | |
180 | /* This is called to update the package with any new information | |
181 | that might be found in the section */ | |
182 | bool debListParser::UsePackage(pkgCache::PkgIterator Pkg, | |
183 | pkgCache::VerIterator Ver) | |
184 | { | |
185 | if (Pkg->Section == 0) | |
b35d2f5f | 186 | Pkg->Section = UniqFindTagWrite("Section"); |
b0b4efb9 | 187 | if (Section.FindFlag("Essential",Pkg->Flags,pkgCache::Flag::Essential) == false) |
f55a958f | 188 | return false; |
138d4b3d | 189 | if (Section.FindFlag("Important",Pkg->Flags,pkgCache::Flag::Important) == false) |
f55a958f | 190 | return false; |
138d4b3d AL |
191 | |
192 | if (strcmp(Pkg.Name(),"apt") == 0) | |
193 | Pkg->Flags |= pkgCache::Flag::Important; | |
194 | ||
f55a958f AL |
195 | if (ParseStatus(Pkg,Ver) == false) |
196 | return false; | |
197 | return true; | |
198 | } | |
199 | /*}}}*/ | |
204fbdcc AL |
200 | // ListParser::VersionHash - Compute a unique hash for this version /*{{{*/ |
201 | // --------------------------------------------------------------------- | |
202 | /* */ | |
203 | unsigned short debListParser::VersionHash() | |
204 | { | |
205 | const char *Sections[] ={"Installed-Size", | |
206 | "Depends", | |
207 | "Pre-Depends", | |
f78439bf AL |
208 | // "Suggests", |
209 | // "Recommends", | |
204fbdcc | 210 | "Conflicts", |
308c7d30 | 211 | "Breaks", |
204fbdcc AL |
212 | "Replaces",0}; |
213 | unsigned long Result = INIT_FCS; | |
418a471f | 214 | char S[1024]; |
204fbdcc AL |
215 | for (const char **I = Sections; *I != 0; I++) |
216 | { | |
217 | const char *Start; | |
218 | const char *End; | |
219 | if (Section.Find(*I,Start,End) == false || End - Start >= (signed)sizeof(S)) | |
220 | continue; | |
221 | ||
222 | /* Strip out any spaces from the text, this undoes dpkgs reformatting | |
421c8d10 AL |
223 | of certain fields. dpkg also has the rather interesting notion of |
224 | reformatting depends operators < -> <= */ | |
204fbdcc AL |
225 | char *I = S; |
226 | for (; Start != End; Start++) | |
421c8d10 | 227 | { |
204fbdcc | 228 | if (isspace(*Start) == 0) |
4e86942a | 229 | *I++ = tolower_ascii(*Start); |
421c8d10 AL |
230 | if (*Start == '<' && Start[1] != '<' && Start[1] != '=') |
231 | *I++ = '='; | |
232 | if (*Start == '>' && Start[1] != '>' && Start[1] != '=') | |
233 | *I++ = '='; | |
234 | } | |
418a471f | 235 | |
204fbdcc AL |
236 | Result = AddCRC16(Result,S,I - S); |
237 | } | |
238 | ||
239 | return Result; | |
240 | } | |
241 | /*}}}*/ | |
dcb79bae | 242 | // ListParser::ParseStatus - Parse the status field /*{{{*/ |
f55a958f AL |
243 | // --------------------------------------------------------------------- |
244 | /* Status lines are of the form, | |
245 | Status: want flag status | |
246 | want = unknown, install, hold, deinstall, purge | |
247 | flag = ok, reinstreq, hold, hold-reinstreq | |
a005475e | 248 | status = not-installed, unpacked, half-configured, |
f55a958f AL |
249 | half-installed, config-files, post-inst-failed, |
250 | removal-failed, installed | |
251 | ||
252 | Some of the above are obsolete (I think?) flag = hold-* and | |
253 | status = post-inst-failed, removal-failed at least. | |
254 | */ | |
255 | bool debListParser::ParseStatus(pkgCache::PkgIterator Pkg, | |
256 | pkgCache::VerIterator Ver) | |
257 | { | |
258 | const char *Start; | |
259 | const char *Stop; | |
260 | if (Section.Find("Status",Start,Stop) == false) | |
261 | return true; | |
262 | ||
263 | // Isolate the first word | |
264 | const char *I = Start; | |
265 | for(; I < Stop && *I != ' '; I++); | |
266 | if (I >= Stop || *I != ' ') | |
267 | return _error->Error("Malformed Status line"); | |
268 | ||
269 | // Process the want field | |
6c139d6e AL |
270 | WordList WantList[] = {{"unknown",pkgCache::State::Unknown}, |
271 | {"install",pkgCache::State::Install}, | |
272 | {"hold",pkgCache::State::Hold}, | |
273 | {"deinstall",pkgCache::State::DeInstall}, | |
b2e465d6 AL |
274 | {"purge",pkgCache::State::Purge}, |
275 | {}}; | |
276 | if (GrabWord(string(Start,I-Start),WantList,Pkg->SelectedState) == false) | |
f55a958f AL |
277 | return _error->Error("Malformed 1st word in the Status line"); |
278 | ||
279 | // Isloate the next word | |
280 | I++; | |
281 | Start = I; | |
282 | for(; I < Stop && *I != ' '; I++); | |
283 | if (I >= Stop || *I != ' ') | |
284 | return _error->Error("Malformed status line, no 2nd word"); | |
285 | ||
286 | // Process the flag field | |
6c139d6e AL |
287 | WordList FlagList[] = {{"ok",pkgCache::State::Ok}, |
288 | {"reinstreq",pkgCache::State::ReInstReq}, | |
289 | {"hold",pkgCache::State::HoldInst}, | |
b2e465d6 AL |
290 | {"hold-reinstreq",pkgCache::State::HoldReInstReq}, |
291 | {}}; | |
292 | if (GrabWord(string(Start,I-Start),FlagList,Pkg->InstState) == false) | |
f55a958f AL |
293 | return _error->Error("Malformed 2nd word in the Status line"); |
294 | ||
295 | // Isloate the last word | |
296 | I++; | |
297 | Start = I; | |
298 | for(; I < Stop && *I != ' '; I++); | |
299 | if (I != Stop) | |
300 | return _error->Error("Malformed Status line, no 3rd word"); | |
301 | ||
302 | // Process the flag field | |
6c139d6e AL |
303 | WordList StatusList[] = {{"not-installed",pkgCache::State::NotInstalled}, |
304 | {"unpacked",pkgCache::State::UnPacked}, | |
305 | {"half-configured",pkgCache::State::HalfConfigured}, | |
306 | {"installed",pkgCache::State::Installed}, | |
6c139d6e AL |
307 | {"half-installed",pkgCache::State::HalfInstalled}, |
308 | {"config-files",pkgCache::State::ConfigFiles}, | |
9d06bc80 MV |
309 | {"triggers-awaited",pkgCache::State::TriggersAwaited}, |
310 | {"triggers-pending",pkgCache::State::TriggersPending}, | |
6c139d6e | 311 | {"post-inst-failed",pkgCache::State::HalfConfigured}, |
b2e465d6 AL |
312 | {"removal-failed",pkgCache::State::HalfInstalled}, |
313 | {}}; | |
314 | if (GrabWord(string(Start,I-Start),StatusList,Pkg->CurrentState) == false) | |
f55a958f AL |
315 | return _error->Error("Malformed 3rd word in the Status line"); |
316 | ||
317 | /* A Status line marks the package as indicating the current | |
318 | version as well. Only if it is actually installed.. Otherwise | |
319 | the interesting dpkg handling of the status file creates bogus | |
320 | entries. */ | |
6c139d6e AL |
321 | if (!(Pkg->CurrentState == pkgCache::State::NotInstalled || |
322 | Pkg->CurrentState == pkgCache::State::ConfigFiles)) | |
f55a958f AL |
323 | { |
324 | if (Ver.end() == true) | |
325 | _error->Warning("Encountered status field in a non-version description"); | |
326 | else | |
327 | Pkg->CurrentVer = Ver.Index(); | |
328 | } | |
329 | ||
dcb79bae AL |
330 | return true; |
331 | } | |
a1826878 | 332 | |
b2e465d6 AL |
333 | const char *debListParser::ConvertRelation(const char *I,unsigned int &Op) |
334 | { | |
335 | // Determine the operator | |
336 | switch (*I) | |
337 | { | |
338 | case '<': | |
339 | I++; | |
340 | if (*I == '=') | |
341 | { | |
342 | I++; | |
343 | Op = pkgCache::Dep::LessEq; | |
344 | break; | |
345 | } | |
346 | ||
347 | if (*I == '<') | |
348 | { | |
349 | I++; | |
350 | Op = pkgCache::Dep::Less; | |
351 | break; | |
352 | } | |
353 | ||
354 | // < is the same as <= and << is really Cs < for some reason | |
355 | Op = pkgCache::Dep::LessEq; | |
356 | break; | |
357 | ||
358 | case '>': | |
359 | I++; | |
360 | if (*I == '=') | |
361 | { | |
362 | I++; | |
363 | Op = pkgCache::Dep::GreaterEq; | |
364 | break; | |
365 | } | |
366 | ||
367 | if (*I == '>') | |
368 | { | |
369 | I++; | |
370 | Op = pkgCache::Dep::Greater; | |
371 | break; | |
372 | } | |
373 | ||
374 | // > is the same as >= and >> is really Cs > for some reason | |
375 | Op = pkgCache::Dep::GreaterEq; | |
376 | break; | |
377 | ||
378 | case '=': | |
379 | Op = pkgCache::Dep::Equals; | |
380 | I++; | |
381 | break; | |
382 | ||
383 | // HACK around bad package definitions | |
384 | default: | |
385 | Op = pkgCache::Dep::Equals; | |
386 | break; | |
387 | } | |
388 | return I; | |
389 | } | |
390 | ||
a1826878 AL |
391 | /*}}}*/ |
392 | // ListParser::ParseDepends - Parse a dependency element /*{{{*/ | |
393 | // --------------------------------------------------------------------- | |
394 | /* This parses the dependency elements out of a standard string in place, | |
395 | bit by bit. */ | |
dcb79bae AL |
396 | const char *debListParser::ParseDepends(const char *Start,const char *Stop, |
397 | string &Package,string &Ver, | |
b2e465d6 | 398 | unsigned int &Op, bool ParseArchFlags) |
dcb79bae AL |
399 | { |
400 | // Strip off leading space | |
401 | for (;Start != Stop && isspace(*Start) != 0; Start++); | |
402 | ||
403 | // Parse off the package name | |
404 | const char *I = Start; | |
405 | for (;I != Stop && isspace(*I) == 0 && *I != '(' && *I != ')' && | |
406 | *I != ',' && *I != '|'; I++); | |
407 | ||
408 | // Malformed, no '(' | |
409 | if (I != Stop && *I == ')') | |
410 | return 0; | |
411 | ||
412 | if (I == Start) | |
413 | return 0; | |
414 | ||
415 | // Stash the package name | |
416 | Package.assign(Start,I - Start); | |
417 | ||
418 | // Skip white space to the '(' | |
419 | for (;I != Stop && isspace(*I) != 0 ; I++); | |
420 | ||
421 | // Parse a version | |
422 | if (I != Stop && *I == '(') | |
423 | { | |
424 | // Skip the '(' | |
425 | for (I++; I != Stop && isspace(*I) != 0 ; I++); | |
426 | if (I + 3 >= Stop) | |
427 | return 0; | |
b2e465d6 | 428 | I = ConvertRelation(I,Op); |
dcb79bae AL |
429 | |
430 | // Skip whitespace | |
431 | for (;I != Stop && isspace(*I) != 0; I++); | |
432 | Start = I; | |
433 | for (;I != Stop && *I != ')'; I++); | |
434 | if (I == Stop || Start == I) | |
435 | return 0; | |
436 | ||
02f000a9 AL |
437 | // Skip trailing whitespace |
438 | const char *End = I; | |
439 | for (; End > Start && isspace(End[-1]); End--); | |
440 | ||
171c75f1 | 441 | Ver.assign(Start,End-Start); |
dcb79bae AL |
442 | I++; |
443 | } | |
444 | else | |
445 | { | |
171c75f1 | 446 | Ver.clear(); |
6c139d6e | 447 | Op = pkgCache::Dep::NoOp; |
dcb79bae AL |
448 | } |
449 | ||
450 | // Skip whitespace | |
451 | for (;I != Stop && isspace(*I) != 0; I++); | |
b2e465d6 AL |
452 | |
453 | if (ParseArchFlags == true) | |
454 | { | |
455 | string arch = _config->Find("APT::Architecture"); | |
9e10ad8a | 456 | |
b2e465d6 AL |
457 | // Parse an architecture |
458 | if (I != Stop && *I == '[') | |
459 | { | |
460 | // malformed | |
461 | I++; | |
462 | if (I == Stop) | |
463 | return 0; | |
464 | ||
465 | const char *End = I; | |
466 | bool Found = false; | |
9e10ad8a | 467 | bool NegArch = false; |
b2e465d6 AL |
468 | while (I != Stop) |
469 | { | |
470 | // look for whitespace or ending ']' | |
471 | while (End != Stop && !isspace(*End) && *End != ']') | |
472 | End++; | |
473 | ||
474 | if (End == Stop) | |
475 | return 0; | |
9e10ad8a AL |
476 | |
477 | if (*I == '!') | |
478 | { | |
479 | NegArch = true; | |
480 | I++; | |
481 | } | |
482 | ||
3e18cc75 | 483 | if (stringcmp(arch,I,End) == 0) |
b2e465d6 AL |
484 | Found = true; |
485 | ||
486 | if (*End++ == ']') { | |
487 | I = End; | |
488 | break; | |
489 | } | |
490 | ||
491 | I = End; | |
492 | for (;I != Stop && isspace(*I) != 0; I++); | |
493 | } | |
9e10ad8a AL |
494 | |
495 | if (NegArch) | |
496 | Found = !Found; | |
b2e465d6 | 497 | |
9e10ad8a | 498 | if (Found == false) |
b2e465d6 AL |
499 | Package = ""; /* not for this arch */ |
500 | } | |
501 | ||
502 | // Skip whitespace | |
503 | for (;I != Stop && isspace(*I) != 0; I++); | |
504 | } | |
505 | ||
dcb79bae | 506 | if (I != Stop && *I == '|') |
6c139d6e | 507 | Op |= pkgCache::Dep::Or; |
dcb79bae AL |
508 | |
509 | if (I == Stop || *I == ',' || *I == '|') | |
510 | { | |
511 | if (I != Stop) | |
512 | for (I++; I != Stop && isspace(*I) != 0; I++); | |
513 | return I; | |
514 | } | |
515 | ||
516 | return 0; | |
517 | } | |
518 | /*}}}*/ | |
519 | // ListParser::ParseDepends - Parse a dependency list /*{{{*/ | |
520 | // --------------------------------------------------------------------- | |
521 | /* This is the higher level depends parser. It takes a tag and generates | |
522 | a complete depends tree for the given version. */ | |
523 | bool debListParser::ParseDepends(pkgCache::VerIterator Ver, | |
524 | const char *Tag,unsigned int Type) | |
525 | { | |
526 | const char *Start; | |
527 | const char *Stop; | |
528 | if (Section.Find(Tag,Start,Stop) == false) | |
529 | return true; | |
530 | ||
531 | string Package; | |
532 | string Version; | |
533 | unsigned int Op; | |
534 | ||
8efa2a3b | 535 | while (1) |
dcb79bae | 536 | { |
8efa2a3b | 537 | Start = ParseDepends(Start,Stop,Package,Version,Op); |
dcb79bae AL |
538 | if (Start == 0) |
539 | return _error->Error("Problem parsing dependency %s",Tag); | |
8efa2a3b | 540 | |
dcb79bae AL |
541 | if (NewDepends(Ver,Package,Version,Op,Type) == false) |
542 | return false; | |
8efa2a3b AL |
543 | if (Start == Stop) |
544 | break; | |
dcb79bae AL |
545 | } |
546 | return true; | |
547 | } | |
548 | /*}}}*/ | |
549 | // ListParser::ParseProvides - Parse the provides list /*{{{*/ | |
550 | // --------------------------------------------------------------------- | |
551 | /* */ | |
552 | bool debListParser::ParseProvides(pkgCache::VerIterator Ver) | |
553 | { | |
554 | const char *Start; | |
555 | const char *Stop; | |
556 | if (Section.Find("Provides",Start,Stop) == false) | |
557 | return true; | |
558 | ||
559 | string Package; | |
560 | string Version; | |
561 | unsigned int Op; | |
562 | ||
563 | while (1) | |
564 | { | |
565 | Start = ParseDepends(Start,Stop,Package,Version,Op); | |
566 | if (Start == 0) | |
567 | return _error->Error("Problem parsing Provides line"); | |
b63380b0 MV |
568 | if (Op != pkgCache::Dep::NoOp) { |
569 | _error->Warning("Ignoring Provides line with DepCompareOp for package %s", Package.c_str()); | |
570 | } else { | |
571 | if (NewProvides(Ver,Package,Version) == false) | |
572 | return false; | |
573 | } | |
dcb79bae AL |
574 | |
575 | if (Start == Stop) | |
576 | break; | |
577 | } | |
578 | ||
f55a958f AL |
579 | return true; |
580 | } | |
581 | /*}}}*/ | |
582 | // ListParser::GrabWord - Matches a word and returns /*{{{*/ | |
583 | // --------------------------------------------------------------------- | |
584 | /* Looks for a word in a list of words - for ParseStatus */ | |
b2e465d6 | 585 | bool debListParser::GrabWord(string Word,WordList *List,unsigned char &Out) |
f55a958f | 586 | { |
b2e465d6 | 587 | for (unsigned int C = 0; List[C].Str != 0; C++) |
f55a958f AL |
588 | { |
589 | if (strcasecmp(Word.c_str(),List[C].Str) == 0) | |
590 | { | |
591 | Out = List[C].Val; | |
592 | return true; | |
593 | } | |
594 | } | |
595 | return false; | |
596 | } | |
597 | /*}}}*/ | |
598 | // ListParser::Step - Move to the next section in the file /*{{{*/ | |
599 | // --------------------------------------------------------------------- | |
0149949b | 600 | /* This has to be carefull to only process the correct architecture */ |
f55a958f AL |
601 | bool debListParser::Step() |
602 | { | |
dcb79bae | 603 | iOffset = Tags.Offset(); |
0149949b | 604 | while (Tags.Step(Section) == true) |
ddc1d8d0 AL |
605 | { |
606 | /* See if this is the correct Architecture, if it isn't then we | |
607 | drop the whole section. A missing arch tag only happens (in theory) | |
608 | inside the Status file, so that is a positive return */ | |
0149949b AL |
609 | const char *Start; |
610 | const char *Stop; | |
611 | if (Section.Find("Architecture",Start,Stop) == false) | |
612 | return true; | |
9c14e3d6 | 613 | |
3e18cc75 | 614 | if (stringcmp(Arch,Start,Stop) == 0) |
0149949b AL |
615 | return true; |
616 | ||
9c14e3d6 | 617 | if (stringcmp(Start,Stop,"all") == 0) |
0149949b | 618 | return true; |
dcb79bae AL |
619 | |
620 | iOffset = Tags.Offset(); | |
0149949b AL |
621 | } |
622 | return false; | |
f55a958f AL |
623 | } |
624 | /*}}}*/ | |
b0b4efb9 AL |
625 | // ListParser::LoadReleaseInfo - Load the release information /*{{{*/ |
626 | // --------------------------------------------------------------------- | |
627 | /* */ | |
628 | bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator FileI, | |
f2152f03 | 629 | FileFd &File, string component) |
b0b4efb9 | 630 | { |
b3d44315 | 631 | pkgTagFile Tags(&File, File.Size() + 256); // XXX |
b0b4efb9 AL |
632 | pkgTagSection Section; |
633 | if (Tags.Step(Section) == false) | |
634 | return false; | |
635 | ||
f2152f03 MV |
636 | //mvo: I don't think we need to fill that in (it's unused since apt-0.6) |
637 | //FileI->Architecture = WriteUniqString(Arch); | |
638 | ||
639 | // apt-secure does no longer download individual (per-section) Release | |
640 | // file. to provide Component pinning we use the section name now | |
641 | FileI->Component = WriteUniqString(component); | |
642 | ||
b0b4efb9 AL |
643 | const char *Start; |
644 | const char *Stop; | |
b3d44315 | 645 | if (Section.Find("Suite",Start,Stop) == true) |
b0b4efb9 AL |
646 | FileI->Archive = WriteUniqString(Start,Stop - Start); |
647 | if (Section.Find("Component",Start,Stop) == true) | |
648 | FileI->Component = WriteUniqString(Start,Stop - Start); | |
649 | if (Section.Find("Version",Start,Stop) == true) | |
650 | FileI->Version = WriteUniqString(Start,Stop - Start); | |
651 | if (Section.Find("Origin",Start,Stop) == true) | |
652 | FileI->Origin = WriteUniqString(Start,Stop - Start); | |
efc487fb DK |
653 | if (Section.Find("Codename",Start,Stop) == true) |
654 | FileI->Codename = WriteUniqString(Start,Stop - Start); | |
b0b4efb9 AL |
655 | if (Section.Find("Label",Start,Stop) == true) |
656 | FileI->Label = WriteUniqString(Start,Stop - Start); | |
657 | if (Section.Find("Architecture",Start,Stop) == true) | |
658 | FileI->Architecture = WriteUniqString(Start,Stop - Start); | |
0dbb95d8 | 659 | |
3c124dde AL |
660 | if (Section.FindFlag("NotAutomatic",FileI->Flags, |
661 | pkgCache::Flag::NotAutomatic) == false) | |
0dbb95d8 | 662 | _error->Warning("Bad NotAutomatic flag"); |
f2152f03 | 663 | |
b0b4efb9 AL |
664 | return !_error->PendingError(); |
665 | } | |
666 | /*}}}*/ | |
b2e465d6 AL |
667 | // ListParser::GetPrio - Convert the priority from a string /*{{{*/ |
668 | // --------------------------------------------------------------------- | |
669 | /* */ | |
670 | unsigned char debListParser::GetPrio(string Str) | |
671 | { | |
672 | unsigned char Out; | |
673 | if (GrabWord(Str,PrioList,Out) == false) | |
674 | Out = pkgCache::State::Extra; | |
675 | ||
676 | return Out; | |
677 | } | |
678 | /*}}}*/ |