]> git.saurik.com Git - apt.git/blame_incremental - apt-pkg/deb/deblistparser.cc
projects / apt.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
* apt-pkg/deb/debmetaindex.cc:
[apt.git] / apt-pkg / deb / deblistparser.cc
... / ...
CommitLineData
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
3// $Id: deblistparser.cc,v 1.29.2.5 2004/01/06 01:43:44 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 <apt-pkg/deblistparser.h>
14#include <apt-pkg/error.h>
15#include <apt-pkg/configuration.h>
16#include <apt-pkg/aptconfiguration.h>
17#include <apt-pkg/strutl.h>
18#include <apt-pkg/crc-16.h>
19#include <apt-pkg/md5.h>
20#include <apt-pkg/macros.h>
21
22#include <fnmatch.h>
23#include <ctype.h>
24 /*}}}*/
25
26static 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
33// ListParser::debListParser - Constructor /*{{{*/
34// ---------------------------------------------------------------------
35/* Provide an architecture and only this one and "all" will be accepted
36 in Step(), if no Architecture is given we will accept every arch
37 we would accept in general with checkArchitecture() */
38debListParser::debListParser(FileFd *File, string const &Arch) : Tags(File),
39 Arch(Arch) {
40 if (Arch == "native")
41 this->Arch = _config->Find("APT::Architecture");
42 Architectures = APT::Configuration::getArchitectures();
43 MultiArchEnabled = Architectures.size() > 1;
44}
45 /*}}}*/
46// ListParser::UniqFindTagWrite - Find the tag and write a unq string /*{{{*/
47// ---------------------------------------------------------------------
48/* */
49unsigned long debListParser::UniqFindTagWrite(const char *Tag)
50{
51 const char *Start;
52 const char *Stop;
53 if (Section.Find(Tag,Start,Stop) == false)
54 return 0;
55 return WriteUniqString(Start,Stop - Start);
56}
57 /*}}}*/
58// ListParser::Package - Return the package name /*{{{*/
59// ---------------------------------------------------------------------
60/* This is to return the name of the package this section describes */
61string debListParser::Package() {
62 string const Result = Section.FindS("Package");
63 if(unlikely(Result.empty() == true))
64 _error->Error("Encountered a section with no Package: header");
65 return Result;
66}
67 /*}}}*/
68// ListParser::Architecture - Return the package arch /*{{{*/
69// ---------------------------------------------------------------------
70/* This will return the Architecture of the package this section describes */
71string debListParser::Architecture() {
72 std::string const Arch = Section.FindS("Architecture");
73 if (Arch.empty() == true)
74 return _config->Find("APT::Architecture");
75 return Arch;
76}
77 /*}}}*/
78// ListParser::ArchitectureAll /*{{{*/
79// ---------------------------------------------------------------------
80/* */
81bool debListParser::ArchitectureAll() {
82 return Section.FindS("Architecture") == "all";
83}
84 /*}}}*/
85// ListParser::Version - Return the version string /*{{{*/
86// ---------------------------------------------------------------------
87/* This is to return the string describing the version in debian form,
88 epoch:upstream-release. If this returns the blank string then the
89 entry is assumed to only describe package properties */
90string debListParser::Version()
91{
92 return Section.FindS("Version");
93}
94 /*}}}*/
95// ListParser::NewVersion - Fill in the version structure /*{{{*/
96// ---------------------------------------------------------------------
97/* */
98bool debListParser::NewVersion(pkgCache::VerIterator &Ver)
99{
100 // Parse the section
101 Ver->Section = UniqFindTagWrite("Section");
102
103 // Parse multi-arch
104 string const MultiArch = Section.FindS("Multi-Arch");
105 if (MultiArch.empty() == true)
106 Ver->MultiArch = pkgCache::Version::None;
107 else if (MultiArch == "same") {
108 // Parse multi-arch
109 if (ArchitectureAll() == true)
110 {
111 /* Arch all packages can't be Multi-Arch: same */
112 _error->Warning("Architecture: all package '%s' can't be Multi-Arch: same",
113 Section.FindS("Package").c_str());
114 Ver->MultiArch = pkgCache::Version::None;
115 }
116 else
117 Ver->MultiArch = pkgCache::Version::Same;
118 }
119 else if (MultiArch == "foreign")
120 Ver->MultiArch = pkgCache::Version::Foreign;
121 else if (MultiArch == "allowed")
122 Ver->MultiArch = pkgCache::Version::Allowed;
123 else
124 {
125 _error->Warning("Unknown Multi-Arch type '%s' for package '%s'",
126 MultiArch.c_str(), Section.FindS("Package").c_str());
127 Ver->MultiArch = pkgCache::Version::None;
128 }
129
130 if (ArchitectureAll() == true)
131 Ver->MultiArch |= pkgCache::Version::All;
132
133 // Archive Size
134 Ver->Size = Section.FindULL("Size");
135 // Unpacked Size (in K)
136 Ver->InstalledSize = Section.FindULL("Installed-Size");
137 Ver->InstalledSize *= 1024;
138
139 // Priority
140 const char *Start;
141 const char *Stop;
142 if (Section.Find("Priority",Start,Stop) == true)
143 {
144 if (GrabWord(string(Start,Stop-Start),PrioList,Ver->Priority) == false)
145 Ver->Priority = pkgCache::State::Extra;
146 }
147
148 if (ParseDepends(Ver,"Depends",pkgCache::Dep::Depends) == false)
149 return false;
150 if (ParseDepends(Ver,"Pre-Depends",pkgCache::Dep::PreDepends) == false)
151 return false;
152 if (ParseDepends(Ver,"Suggests",pkgCache::Dep::Suggests) == false)
153 return false;
154 if (ParseDepends(Ver,"Recommends",pkgCache::Dep::Recommends) == false)
155 return false;
156 if (ParseDepends(Ver,"Conflicts",pkgCache::Dep::Conflicts) == false)
157 return false;
158 if (ParseDepends(Ver,"Breaks",pkgCache::Dep::DpkgBreaks) == false)
159 return false;
160 if (ParseDepends(Ver,"Replaces",pkgCache::Dep::Replaces) == false)
161 return false;
162 if (ParseDepends(Ver,"Enhances",pkgCache::Dep::Enhances) == false)
163 return false;
164
165 // Obsolete.
166 if (ParseDepends(Ver,"Optional",pkgCache::Dep::Suggests) == false)
167 return false;
168
169 if (ParseProvides(Ver) == false)
170 return false;
171
172 return true;
173}
174 /*}}}*/
175// ListParser::Description - Return the description string /*{{{*/
176// ---------------------------------------------------------------------
177/* This is to return the string describing the package in debian
178 form. If this returns the blank string then the entry is assumed to
179 only describe package properties */
180string debListParser::Description()
181{
182 string const lang = DescriptionLanguage();
183 if (lang.empty())
184 return Section.FindS("Description");
185 else
186 return Section.FindS(string("Description-").append(lang).c_str());
187}
188 /*}}}*/
189// ListParser::DescriptionLanguage - Return the description lang string /*{{{*/
190// ---------------------------------------------------------------------
191/* This is to return the string describing the language of
192 description. If this returns the blank string then the entry is
193 assumed to describe original description. */
194string debListParser::DescriptionLanguage()
195{
196 if (Section.FindS("Description").empty() == false)
197 return "";
198
199 std::vector<string> const lang = APT::Configuration::getLanguages(true);
200 for (std::vector<string>::const_iterator l = lang.begin();
201 l != lang.end(); l++)
202 if (Section.FindS(string("Description-").append(*l).c_str()).empty() == false)
203 return *l;
204
205 return "";
206}
207 /*}}}*/
208// ListParser::Description - Return the description_md5 MD5SumValue /*{{{*/
209// ---------------------------------------------------------------------
210/* This is to return the md5 string to allow the check if it is the right
211 description. If no Description-md5 is found in the section it will be
212 calculated.
213 */
214MD5SumValue debListParser::Description_md5()
215{
216 string value = Section.FindS("Description-md5");
217
218 if (value.empty())
219 {
220 MD5Summation md5;
221 md5.Add((Description() + "\n").c_str());
222 return md5.Result();
223 } else
224 return MD5SumValue(value);
225}
226 /*}}}*/
227// ListParser::UsePackage - Update a package structure /*{{{*/
228// ---------------------------------------------------------------------
229/* This is called to update the package with any new information
230 that might be found in the section */
231bool debListParser::UsePackage(pkgCache::PkgIterator &Pkg,
232 pkgCache::VerIterator &Ver)
233{
234 if (Pkg->Section == 0)
235 Pkg->Section = UniqFindTagWrite("Section");
236
237 // Packages which are not from the "native" arch doesn't get the essential flag
238 // in the default "native" mode - it is also possible to mark "all" or "none".
239 // The "installed" mode is handled by ParseStatus(), See #544481 and friends.
240 string const static myArch = _config->Find("APT::Architecture");
241 string const static essential = _config->Find("pkgCacheGen::Essential", "native");
242 if ((essential == "native" && Pkg->Arch != 0 && myArch == Pkg.Arch()) ||
243 essential == "all")
244 if (Section.FindFlag("Essential",Pkg->Flags,pkgCache::Flag::Essential) == false)
245 return false;
246 if (Section.FindFlag("Important",Pkg->Flags,pkgCache::Flag::Important) == false)
247 return false;
248
249 if (strcmp(Pkg.Name(),"apt") == 0)
250 Pkg->Flags |= pkgCache::Flag::Important;
251
252 if (ParseStatus(Pkg,Ver) == false)
253 return false;
254 return true;
255}
256 /*}}}*/
257// ListParser::VersionHash - Compute a unique hash for this version /*{{{*/
258// ---------------------------------------------------------------------
259/* */
260unsigned short debListParser::VersionHash()
261{
262 const char *Sections[] ={"Installed-Size",
263 "Depends",
264 "Pre-Depends",
265// "Suggests",
266// "Recommends",
267 "Conflicts",
268 "Breaks",
269 "Replaces",0};
270 unsigned long Result = INIT_FCS;
271 char S[1024];
272 for (const char **I = Sections; *I != 0; I++)
273 {
274 const char *Start;
275 const char *End;
276 if (Section.Find(*I,Start,End) == false || End - Start >= (signed)sizeof(S))
277 continue;
278
279 /* Strip out any spaces from the text, this undoes dpkgs reformatting
280 of certain fields. dpkg also has the rather interesting notion of
281 reformatting depends operators < -> <= */
282 char *J = S;
283 for (; Start != End; Start++)
284 {
285 if (isspace(*Start) == 0)
286 *J++ = tolower_ascii(*Start);
287 if (*Start == '<' && Start[1] != '<' && Start[1] != '=')
288 *J++ = '=';
289 if (*Start == '>' && Start[1] != '>' && Start[1] != '=')
290 *J++ = '=';
291 }
292
293 Result = AddCRC16(Result,S,J - S);
294 }
295
296 return Result;
297}
298 /*}}}*/
299// ListParser::ParseStatus - Parse the status field /*{{{*/
300// ---------------------------------------------------------------------
301/* Status lines are of the form,
302 Status: want flag status
303 want = unknown, install, hold, deinstall, purge
304 flag = ok, reinstreq, hold, hold-reinstreq
305 status = not-installed, unpacked, half-configured,
306 half-installed, config-files, post-inst-failed,
307 removal-failed, installed
308
309 Some of the above are obsolete (I think?) flag = hold-* and
310 status = post-inst-failed, removal-failed at least.
311 */
312bool debListParser::ParseStatus(pkgCache::PkgIterator &Pkg,
313 pkgCache::VerIterator &Ver)
314{
315 const char *Start;
316 const char *Stop;
317 if (Section.Find("Status",Start,Stop) == false)
318 return true;
319
320 // UsePackage() is responsible for setting the flag in the default case
321 bool const static essential = _config->Find("pkgCacheGen::Essential", "") == "installed";
322 if (essential == true &&
323 Section.FindFlag("Essential",Pkg->Flags,pkgCache::Flag::Essential) == false)
324 return false;
325
326 // Isolate the first word
327 const char *I = Start;
328 for(; I < Stop && *I != ' '; I++);
329 if (I >= Stop || *I != ' ')
330 return _error->Error("Malformed Status line");
331
332 // Process the want field
333 WordList WantList[] = {{"unknown",pkgCache::State::Unknown},
334 {"install",pkgCache::State::Install},
335 {"hold",pkgCache::State::Hold},
336 {"deinstall",pkgCache::State::DeInstall},
337 {"purge",pkgCache::State::Purge},
338 {}};
339 if (GrabWord(string(Start,I-Start),WantList,Pkg->SelectedState) == false)
340 return _error->Error("Malformed 1st word in the Status line");
341
342 // Isloate the next word
343 I++;
344 Start = I;
345 for(; I < Stop && *I != ' '; I++);
346 if (I >= Stop || *I != ' ')
347 return _error->Error("Malformed status line, no 2nd word");
348
349 // Process the flag field
350 WordList FlagList[] = {{"ok",pkgCache::State::Ok},
351 {"reinstreq",pkgCache::State::ReInstReq},
352 {"hold",pkgCache::State::HoldInst},
353 {"hold-reinstreq",pkgCache::State::HoldReInstReq},
354 {}};
355 if (GrabWord(string(Start,I-Start),FlagList,Pkg->InstState) == false)
356 return _error->Error("Malformed 2nd word in the Status line");
357
358 // Isloate the last word
359 I++;
360 Start = I;
361 for(; I < Stop && *I != ' '; I++);
362 if (I != Stop)
363 return _error->Error("Malformed Status line, no 3rd word");
364
365 // Process the flag field
366 WordList StatusList[] = {{"not-installed",pkgCache::State::NotInstalled},
367 {"unpacked",pkgCache::State::UnPacked},
368 {"half-configured",pkgCache::State::HalfConfigured},
369 {"installed",pkgCache::State::Installed},
370 {"half-installed",pkgCache::State::HalfInstalled},
371 {"config-files",pkgCache::State::ConfigFiles},
372 {"triggers-awaited",pkgCache::State::TriggersAwaited},
373 {"triggers-pending",pkgCache::State::TriggersPending},
374 {"post-inst-failed",pkgCache::State::HalfConfigured},
375 {"removal-failed",pkgCache::State::HalfInstalled},
376 {}};
377 if (GrabWord(string(Start,I-Start),StatusList,Pkg->CurrentState) == false)
378 return _error->Error("Malformed 3rd word in the Status line");
379
380 /* A Status line marks the package as indicating the current
381 version as well. Only if it is actually installed.. Otherwise
382 the interesting dpkg handling of the status file creates bogus
383 entries. */
384 if (!(Pkg->CurrentState == pkgCache::State::NotInstalled ||
385 Pkg->CurrentState == pkgCache::State::ConfigFiles))
386 {
387 if (Ver.end() == true)
388 _error->Warning("Encountered status field in a non-version description");
389 else
390 Pkg->CurrentVer = Ver.Index();
391 }
392
393 return true;
394}
395
396const char *debListParser::ConvertRelation(const char *I,unsigned int &Op)
397{
398 // Determine the operator
399 switch (*I)
400 {
401 case '<':
402 I++;
403 if (*I == '=')
404 {
405 I++;
406 Op = pkgCache::Dep::LessEq;
407 break;
408 }
409
410 if (*I == '<')
411 {
412 I++;
413 Op = pkgCache::Dep::Less;
414 break;
415 }
416
417 // < is the same as <= and << is really Cs < for some reason
418 Op = pkgCache::Dep::LessEq;
419 break;
420
421 case '>':
422 I++;
423 if (*I == '=')
424 {
425 I++;
426 Op = pkgCache::Dep::GreaterEq;
427 break;
428 }
429
430 if (*I == '>')
431 {
432 I++;
433 Op = pkgCache::Dep::Greater;
434 break;
435 }
436
437 // > is the same as >= and >> is really Cs > for some reason
438 Op = pkgCache::Dep::GreaterEq;
439 break;
440
441 case '=':
442 Op = pkgCache::Dep::Equals;
443 I++;
444 break;
445
446 // HACK around bad package definitions
447 default:
448 Op = pkgCache::Dep::Equals;
449 break;
450 }
451 return I;
452}
453
454/*
455 * CompleteArch:
456 *
457 * The complete architecture, consisting of <kernel>-<cpu>.
458 */
459static string CompleteArch(std::string& arch) {
460 if (arch == "armel") return "linux-arm";
461 if (arch == "armhf") return "linux-arm";
462 if (arch == "lpia") return "linux-i386";
463 if (arch == "powerpcspe") return "linux-powerpc";
464 if (arch == "uclibc-linux-armel") return "linux-arm";
465 if (arch == "uclinux-armel") return "uclinux-arm";
466
467 return (arch.find("-") != string::npos) ? arch : "linux-" + arch;
468}
469 /*}}}*/
470// ListParser::ParseDepends - Parse a dependency element /*{{{*/
471// ---------------------------------------------------------------------
472/* This parses the dependency elements out of a standard string in place,
473 bit by bit. */
474const char *debListParser::ParseDepends(const char *Start,const char *Stop,
475 string &Package,string &Ver,
476 unsigned int &Op, bool const &ParseArchFlags,
477 bool const &StripMultiArch)
478{
479 // Strip off leading space
480 for (;Start != Stop && isspace(*Start) != 0; Start++);
481
482 // Parse off the package name
483 const char *I = Start;
484 for (;I != Stop && isspace(*I) == 0 && *I != '(' && *I != ')' &&
485 *I != ',' && *I != '|' && *I != '[' && *I != ']'; I++);
486
487 // Malformed, no '('
488 if (I != Stop && *I == ')')
489 return 0;
490
491 if (I == Start)
492 return 0;
493
494 // Stash the package name
495 Package.assign(Start,I - Start);
496
497 // We don't want to confuse library users which can't handle MultiArch
498 if (StripMultiArch == true) {
499 size_t const found = Package.rfind(':');
500 if (found != string::npos)
501 Package = Package.substr(0,found);
502 }
503
504 // Skip white space to the '('
505 for (;I != Stop && isspace(*I) != 0 ; I++);
506
507 // Parse a version
508 if (I != Stop && *I == '(')
509 {
510 // Skip the '('
511 for (I++; I != Stop && isspace(*I) != 0 ; I++);
512 if (I + 3 >= Stop)
513 return 0;
514 I = ConvertRelation(I,Op);
515
516 // Skip whitespace
517 for (;I != Stop && isspace(*I) != 0; I++);
518 Start = I;
519 for (;I != Stop && *I != ')'; I++);
520 if (I == Stop || Start == I)
521 return 0;
522
523 // Skip trailing whitespace
524 const char *End = I;
525 for (; End > Start && isspace(End[-1]); End--);
526
527 Ver.assign(Start,End-Start);
528 I++;
529 }
530 else
531 {
532 Ver.clear();
533 Op = pkgCache::Dep::NoOp;
534 }
535
536 // Skip whitespace
537 for (;I != Stop && isspace(*I) != 0; I++);
538
539 if (ParseArchFlags == true)
540 {
541 string arch = _config->Find("APT::Architecture");
542 string completeArch = CompleteArch(arch);
543
544 // Parse an architecture
545 if (I != Stop && *I == '[')
546 {
547 // malformed
548 I++;
549 if (I == Stop)
550 return 0;
551
552 const char *End = I;
553 bool Found = false;
554 bool NegArch = false;
555 while (I != Stop)
556 {
557 // look for whitespace or ending ']'
558 while (End != Stop && !isspace(*End) && *End != ']')
559 End++;
560
561 if (End == Stop)
562 return 0;
563
564 if (*I == '!')
565 {
566 NegArch = true;
567 I++;
568 }
569
570 if (stringcmp(arch,I,End) == 0) {
571 Found = true;
572 } else {
573 std::string wildcard = SubstVar(string(I, End), "any", "*");
574 if (fnmatch(wildcard.c_str(), completeArch.c_str(), 0) == 0)
575 Found = true;
576 }
577
578 if (*End++ == ']') {
579 I = End;
580 break;
581 }
582
583 I = End;
584 for (;I != Stop && isspace(*I) != 0; I++);
585 }
586
587 if (NegArch)
588 Found = !Found;
589
590 if (Found == false)
591 Package = ""; /* not for this arch */
592 }
593
594 // Skip whitespace
595 for (;I != Stop && isspace(*I) != 0; I++);
596 }
597
598 if (I != Stop && *I == '|')
599 Op |= pkgCache::Dep::Or;
600
601 if (I == Stop || *I == ',' || *I == '|')
602 {
603 if (I != Stop)
604 for (I++; I != Stop && isspace(*I) != 0; I++);
605 return I;
606 }
607
608 return 0;
609}
610 /*}}}*/
611// ListParser::ParseDepends - Parse a dependency list /*{{{*/
612// ---------------------------------------------------------------------
613/* This is the higher level depends parser. It takes a tag and generates
614 a complete depends tree for the given version. */
615bool debListParser::ParseDepends(pkgCache::VerIterator &Ver,
616 const char *Tag,unsigned int Type)
617{
618 const char *Start;
619 const char *Stop;
620 if (Section.Find(Tag,Start,Stop) == false)
621 return true;
622
623 string Package;
624 string const pkgArch = Ver.Arch();
625 string Version;
626 unsigned int Op;
627
628 while (1)
629 {
630 Start = ParseDepends(Start,Stop,Package,Version,Op,false,!MultiArchEnabled);
631 if (Start == 0)
632 return _error->Error("Problem parsing dependency %s",Tag);
633
634 if (MultiArchEnabled == true &&
635 (Type == pkgCache::Dep::Conflicts ||
636 Type == pkgCache::Dep::DpkgBreaks ||
637 Type == pkgCache::Dep::Replaces))
638 {
639 for (std::vector<std::string>::const_iterator a = Architectures.begin();
640 a != Architectures.end(); ++a)
641 if (NewDepends(Ver,Package,*a,Version,Op,Type) == false)
642 return false;
643 }
644 else if (NewDepends(Ver,Package,pkgArch,Version,Op,Type) == false)
645 return false;
646 if (Start == Stop)
647 break;
648 }
649 return true;
650}
651 /*}}}*/
652// ListParser::ParseProvides - Parse the provides list /*{{{*/
653// ---------------------------------------------------------------------
654/* */
655bool debListParser::ParseProvides(pkgCache::VerIterator &Ver)
656{
657 const char *Start;
658 const char *Stop;
659 if (Section.Find("Provides",Start,Stop) == true)
660 {
661 string Package;
662 string Version;
663 string const Arch = Ver.Arch();
664 unsigned int Op;
665
666 while (1)
667 {
668 Start = ParseDepends(Start,Stop,Package,Version,Op);
669 if (Start == 0)
670 return _error->Error("Problem parsing Provides line");
671 if (Op != pkgCache::Dep::NoOp) {
672 _error->Warning("Ignoring Provides line with DepCompareOp for package %s", Package.c_str());
673 } else {
674 if (NewProvides(Ver, Package, Arch, Version) == false)
675 return false;
676 }
677
678 if (Start == Stop)
679 break;
680 }
681 }
682
683 if (MultiArchEnabled == false)
684 return true;
685 else if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
686 {
687 string const Package = string(Ver.ParentPkg().Name()).append(":").append("any");
688 return NewProvidesAllArch(Ver, Package, Ver.VerStr());
689 }
690 else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
691 return NewProvidesAllArch(Ver, Ver.ParentPkg().Name(), Ver.VerStr());
692
693 return true;
694}
695 /*}}}*/
696// ListParser::NewProvides - add provides for all architectures /*{{{*/
697bool debListParser::NewProvidesAllArch(pkgCache::VerIterator &Ver, string const &Package,
698 string const &Version) {
699 for (std::vector<string>::const_iterator a = Architectures.begin();
700 a != Architectures.end(); ++a)
701 {
702 if (NewProvides(Ver, Package, *a, Version) == false)
703 return false;
704 }
705 return true;
706}
707 /*}}}*/
708// ListParser::GrabWord - Matches a word and returns /*{{{*/
709// ---------------------------------------------------------------------
710/* Looks for a word in a list of words - for ParseStatus */
711bool debListParser::GrabWord(string Word,WordList *List,unsigned char &Out)
712{
713 for (unsigned int C = 0; List[C].Str != 0; C++)
714 {
715 if (strcasecmp(Word.c_str(),List[C].Str) == 0)
716 {
717 Out = List[C].Val;
718 return true;
719 }
720 }
721 return false;
722}
723 /*}}}*/
724// ListParser::Step - Move to the next section in the file /*{{{*/
725// ---------------------------------------------------------------------
726/* This has to be carefull to only process the correct architecture */
727bool debListParser::Step()
728{
729 iOffset = Tags.Offset();
730 while (Tags.Step(Section) == true)
731 {
732 /* See if this is the correct Architecture, if it isn't then we
733 drop the whole section. A missing arch tag only happens (in theory)
734 inside the Status file, so that is a positive return */
735 string const Architecture = Section.FindS("Architecture");
736 if (Architecture.empty() == true)
737 return true;
738
739 if (Arch.empty() == true || Arch == "any" || MultiArchEnabled == false)
740 {
741 if (APT::Configuration::checkArchitecture(Architecture) == true)
742 return true;
743 }
744 else
745 {
746 if (Architecture == Arch)
747 return true;
748
749 if (Architecture == "all" && Arch == _config->Find("APT::Architecture"))
750 return true;
751 }
752
753 iOffset = Tags.Offset();
754 }
755 return false;
756}
757 /*}}}*/
758// ListParser::LoadReleaseInfo - Load the release information /*{{{*/
759// ---------------------------------------------------------------------
760/* */
761bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator &FileI,
762 FileFd &File, string component)
763{
764 // apt-secure does no longer download individual (per-section) Release
765 // file. to provide Component pinning we use the section name now
766 FileI->Component = WriteUniqString(component);
767
768 FILE* release = fdopen(dup(File.Fd()), "r");
769 if (release == NULL)
770 return false;
771
772 char buffer[101];
773 bool gpgClose = false;
774 while (fgets(buffer, sizeof(buffer), release) != NULL)
775 {
776 size_t len = 0;
777
778 // Skip empty lines
779 for (; buffer[len] == '\r' && buffer[len] == '\n'; ++len);
780 if (buffer[len] == '\0')
781 continue;
782
783 // only evalute the first GPG section
784 if (strncmp("-----", buffer, 5) == 0)
785 {
786 if (gpgClose == true)
787 break;
788 gpgClose = true;
789 continue;
790 }
791
792 // seperate the tag from the data
793 for (; buffer[len] != ':' && buffer[len] != '\0'; ++len);
794 if (buffer[len] == '\0')
795 continue;
796 char* dataStart = buffer + len;
797 for (++dataStart; *dataStart == ' '; ++dataStart);
798 char* dataEnd = dataStart;
799 for (++dataEnd; *dataEnd != '\0'; ++dataEnd);
800
801 // which datastorage need to be updated
802 map_ptrloc* writeTo = NULL;
803 if (buffer[0] == ' ')
804 ;
805 #define APT_PARSER_WRITETO(X, Y) else if (strncmp(Y, buffer, len) == 0) writeTo = &X;
806 APT_PARSER_WRITETO(FileI->Archive, "Suite")
807 APT_PARSER_WRITETO(FileI->Component, "Component")
808 APT_PARSER_WRITETO(FileI->Version, "Version")
809 APT_PARSER_WRITETO(FileI->Origin, "Origin")
810 APT_PARSER_WRITETO(FileI->Codename, "Codename")
811 APT_PARSER_WRITETO(FileI->Label, "Label")
812 #undef APT_PARSER_WRITETO
813 #define APT_PARSER_FLAGIT(X) else if (strncmp(#X, buffer, len) == 0) \
814 pkgTagSection::FindFlag(FileI->Flags, pkgCache::Flag:: X, dataStart, dataEnd-1);
815 APT_PARSER_FLAGIT(NotAutomatic)
816 APT_PARSER_FLAGIT(ButAutomaticUpgrades)
817 #undef APT_PARSER_FLAGIT
818
819 // load all data from the line and save it
820 string data;
821 if (writeTo != NULL)
822 data.append(dataStart, dataEnd);
823 if (sizeof(buffer) - 1 == (dataEnd - buffer))
824 {
825 while (fgets(buffer, sizeof(buffer), release) != NULL)
826 {
827 if (writeTo != NULL)
828 data.append(buffer);
829 if (strlen(buffer) != sizeof(buffer) - 1)
830 break;
831 }
832 }
833 if (writeTo != NULL)
834 {
835 // remove spaces and stuff from the end of the data line
836 for (std::string::reverse_iterator s = data.rbegin();
837 s != data.rend(); ++s)
838 {
839 if (*s != '\r' && *s != '\n' && *s != ' ')
840 break;
841 *s = '\0';
842 }
843 *writeTo = WriteUniqString(data);
844 }
845 }
846 fclose(release);
847
848 return !_error->PendingError();
849}
850 /*}}}*/
851// ListParser::GetPrio - Convert the priority from a string /*{{{*/
852// ---------------------------------------------------------------------
853/* */
854unsigned char debListParser::GetPrio(string Str)
855{
856 unsigned char Out;
857 if (GrabWord(Str,PrioList,Out) == false)
858 Out = pkgCache::State::Extra;
859
860 return Out;
861}
862 /*}}}*/
APT (for Cydia)