]> 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
lintian: don't show the typofix as a typo
[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 <config.h>
14
15#include <apt-pkg/deblistparser.h>
16#include <apt-pkg/error.h>
17#include <apt-pkg/configuration.h>
18#include <apt-pkg/cachefilter.h>
19#include <apt-pkg/aptconfiguration.h>
20#include <apt-pkg/strutl.h>
21#include <apt-pkg/crc-16.h>
22#include <apt-pkg/md5.h>
23#include <apt-pkg/pkgcache.h>
24#include <apt-pkg/cacheiterators.h>
25#include <apt-pkg/tagfile.h>
26#include <apt-pkg/macros.h>
27
28#include <stddef.h>
29#include <string.h>
30#include <algorithm>
31#include <string>
32#include <vector>
33#include <ctype.h>
34 /*}}}*/
35
36using std::string;
37
38static debListParser::WordList PrioList[] = {
39 {"required",pkgCache::State::Required},
40 {"important",pkgCache::State::Important},
41 {"standard",pkgCache::State::Standard},
42 {"optional",pkgCache::State::Optional},
43 {"extra",pkgCache::State::Extra},
44 {NULL, 0}};
45
46// ListParser::debListParser - Constructor /*{{{*/
47// ---------------------------------------------------------------------
48/* Provide an architecture and only this one and "all" will be accepted
49 in Step(), if no Architecture is given we will accept every arch
50 we would accept in general with checkArchitecture() */
51debListParser::debListParser(FileFd *File) :
52 pkgCacheListParser(), d(NULL), Tags(File)
53{
54}
55 /*}}}*/
56// ListParser::Package - Return the package name /*{{{*/
57// ---------------------------------------------------------------------
58/* This is to return the name of the package this section describes */
59string debListParser::Package() {
60 string const Result = Section.FindS("Package");
61 if(unlikely(Result.empty() == true))
62 _error->Error("Encountered a section with no Package: header");
63 return Result;
64}
65 /*}}}*/
66// ListParser::Architecture - Return the package arch /*{{{*/
67// ---------------------------------------------------------------------
68/* This will return the Architecture of the package this section describes */
69string debListParser::Architecture() {
70 std::string const Arch = Section.FindS("Architecture");
71 return Arch.empty() ? "none" : Arch;
72}
73 /*}}}*/
74// ListParser::ArchitectureAll /*{{{*/
75// ---------------------------------------------------------------------
76/* */
77bool debListParser::ArchitectureAll() {
78 return Section.FindS("Architecture") == "all";
79}
80 /*}}}*/
81// ListParser::Version - Return the version string /*{{{*/
82// ---------------------------------------------------------------------
83/* This is to return the string describing the version in debian form,
84 epoch:upstream-release. If this returns the blank string then the
85 entry is assumed to only describe package properties */
86string debListParser::Version()
87{
88 return Section.FindS("Version");
89}
90 /*}}}*/
91unsigned char debListParser::ParseMultiArch(bool const showErrors) /*{{{*/
92{
93 unsigned char MA;
94 string const MultiArch = Section.FindS("Multi-Arch");
95 if (MultiArch.empty() == true || MultiArch == "no")
96 MA = pkgCache::Version::No;
97 else if (MultiArch == "same") {
98 if (ArchitectureAll() == true)
99 {
100 if (showErrors == true)
101 _error->Warning("Architecture: all package '%s' can't be Multi-Arch: same",
102 Section.FindS("Package").c_str());
103 MA = pkgCache::Version::No;
104 }
105 else
106 MA = pkgCache::Version::Same;
107 }
108 else if (MultiArch == "foreign")
109 MA = pkgCache::Version::Foreign;
110 else if (MultiArch == "allowed")
111 MA = pkgCache::Version::Allowed;
112 else
113 {
114 if (showErrors == true)
115 _error->Warning("Unknown Multi-Arch type '%s' for package '%s'",
116 MultiArch.c_str(), Section.FindS("Package").c_str());
117 MA = pkgCache::Version::No;
118 }
119
120 if (ArchitectureAll() == true)
121 MA |= pkgCache::Version::All;
122
123 return MA;
124}
125 /*}}}*/
126// ListParser::NewVersion - Fill in the version structure /*{{{*/
127// ---------------------------------------------------------------------
128/* */
129bool debListParser::NewVersion(pkgCache::VerIterator &Ver)
130{
131 const char *Start;
132 const char *Stop;
133
134 // Parse the section
135 if (Section.Find("Section",Start,Stop) == true)
136 {
137 map_stringitem_t const idx = StoreString(pkgCacheGenerator::SECTION, Start, Stop - Start);
138 Ver->Section = idx;
139 }
140 // Parse the source package name
141 pkgCache::GrpIterator const G = Ver.ParentPkg().Group();
142 Ver->SourcePkgName = G->Name;
143 Ver->SourceVerStr = Ver->VerStr;
144 if (Section.Find("Source",Start,Stop) == true)
145 {
146 const char * const Space = (const char * const) memchr(Start, ' ', Stop - Start);
147 pkgCache::VerIterator V;
148
149 if (Space != NULL)
150 {
151 Stop = Space;
152 const char * const Open = (const char * const) memchr(Space, '(', Stop - Space);
153 if (likely(Open != NULL))
154 {
155 const char * const Close = (const char * const) memchr(Open, ')', Stop - Open);
156 if (likely(Close != NULL))
157 {
158 std::string const version(Open + 1, (Close - Open) - 1);
159 if (version != Ver.VerStr())
160 {
161 map_stringitem_t const idx = StoreString(pkgCacheGenerator::VERSIONNUMBER, version);
162 Ver->SourceVerStr = idx;
163 }
164 }
165 }
166 }
167
168 std::string const pkgname(Start, Stop - Start);
169 if (pkgname != G.Name())
170 {
171 for (pkgCache::PkgIterator P = G.PackageList(); P.end() == false; P = G.NextPkg(P))
172 {
173 for (V = P.VersionList(); V.end() == false; ++V)
174 {
175 if (pkgname == V.SourcePkgName())
176 {
177 Ver->SourcePkgName = V->SourcePkgName;
178 break;
179 }
180 }
181 if (V.end() == false)
182 break;
183 }
184 if (V.end() == true)
185 {
186 map_stringitem_t const idx = StoreString(pkgCacheGenerator::PKGNAME, pkgname);
187 Ver->SourcePkgName = idx;
188 }
189 }
190 }
191
192 Ver->MultiArch = ParseMultiArch(true);
193 // Archive Size
194 Ver->Size = Section.FindULL("Size");
195 // Unpacked Size (in K)
196 Ver->InstalledSize = Section.FindULL("Installed-Size");
197 Ver->InstalledSize *= 1024;
198
199 // Priority
200 if (Section.Find("Priority",Start,Stop) == true)
201 {
202 if (GrabWord(string(Start,Stop-Start),PrioList,Ver->Priority) == false)
203 Ver->Priority = pkgCache::State::Extra;
204 }
205
206 if (ParseDepends(Ver,"Pre-Depends",pkgCache::Dep::PreDepends) == false)
207 return false;
208 if (ParseDepends(Ver,"Depends",pkgCache::Dep::Depends) == false)
209 return false;
210 if (ParseDepends(Ver,"Conflicts",pkgCache::Dep::Conflicts) == false)
211 return false;
212 if (ParseDepends(Ver,"Breaks",pkgCache::Dep::DpkgBreaks) == false)
213 return false;
214 if (ParseDepends(Ver,"Recommends",pkgCache::Dep::Recommends) == false)
215 return false;
216 if (ParseDepends(Ver,"Suggests",pkgCache::Dep::Suggests) == false)
217 return false;
218 if (ParseDepends(Ver,"Replaces",pkgCache::Dep::Replaces) == false)
219 return false;
220 if (ParseDepends(Ver,"Enhances",pkgCache::Dep::Enhances) == false)
221 return false;
222 // Obsolete.
223 if (ParseDepends(Ver,"Optional",pkgCache::Dep::Suggests) == false)
224 return false;
225
226 if (ParseProvides(Ver) == false)
227 return false;
228
229 return true;
230}
231 /*}}}*/
232// ListParser::Description - Return the description string /*{{{*/
233// ---------------------------------------------------------------------
234/* This is to return the string describing the package in debian
235 form. If this returns the blank string then the entry is assumed to
236 only describe package properties */
237string debListParser::Description(std::string const &lang)
238{
239 if (lang.empty())
240 return Section.FindS("Description");
241 else
242 return Section.FindS(string("Description-").append(lang).c_str());
243}
244 /*}}}*/
245// ListParser::AvailableDescriptionLanguages /*{{{*/
246std::vector<std::string> debListParser::AvailableDescriptionLanguages()
247{
248 std::vector<std::string> const understood = APT::Configuration::getLanguages();
249 std::vector<std::string> avail;
250 if (Section.Exists("Description") == true)
251 avail.push_back("");
252 for (std::vector<std::string>::const_iterator lang = understood.begin(); lang != understood.end(); ++lang)
253 {
254 std::string const tagname = "Description-" + *lang;
255 if (Section.Exists(tagname.c_str()) == true)
256 avail.push_back(*lang);
257 }
258 return avail;
259}
260 /*}}}*/
261// ListParser::Description_md5 - Return the description_md5 MD5SumValue /*{{{*/
262// ---------------------------------------------------------------------
263/* This is to return the md5 string to allow the check if it is the right
264 description. If no Description-md5 is found in the section it will be
265 calculated.
266 */
267MD5SumValue debListParser::Description_md5()
268{
269 string const value = Section.FindS("Description-md5");
270 if (value.empty() == true)
271 {
272 std::string const desc = Description("") + "\n";
273 if (desc == "\n")
274 return MD5SumValue();
275
276 MD5Summation md5;
277 md5.Add(desc.c_str());
278 return md5.Result();
279 }
280 else if (likely(value.size() == 32))
281 {
282 if (likely(value.find_first_not_of("0123456789abcdefABCDEF") == string::npos))
283 return MD5SumValue(value);
284 _error->Error("Malformed Description-md5 line; includes invalid character '%s'", value.c_str());
285 return MD5SumValue();
286 }
287 _error->Error("Malformed Description-md5 line; doesn't have the required length (32 != %d) '%s'", (int)value.size(), value.c_str());
288 return MD5SumValue();
289}
290 /*}}}*/
291// ListParser::UsePackage - Update a package structure /*{{{*/
292// ---------------------------------------------------------------------
293/* This is called to update the package with any new information
294 that might be found in the section */
295bool debListParser::UsePackage(pkgCache::PkgIterator &Pkg,
296 pkgCache::VerIterator &Ver)
297{
298 string const static myArch = _config->Find("APT::Architecture");
299 // Possible values are: "all", "native", "installed" and "none"
300 // The "installed" mode is handled by ParseStatus(), See #544481 and friends.
301 string const static essential = _config->Find("pkgCacheGen::Essential", "all");
302 if (essential == "all" ||
303 (essential == "native" && Pkg->Arch != 0 && myArch == Pkg.Arch()))
304 if (Section.FindFlag("Essential",Pkg->Flags,pkgCache::Flag::Essential) == false)
305 return false;
306 if (Section.FindFlag("Important",Pkg->Flags,pkgCache::Flag::Important) == false)
307 return false;
308
309 if (strcmp(Pkg.Name(),"apt") == 0)
310 {
311 if ((essential == "native" && Pkg->Arch != 0 && myArch == Pkg.Arch()) ||
312 essential == "all")
313 Pkg->Flags |= pkgCache::Flag::Essential | pkgCache::Flag::Important;
314 else
315 Pkg->Flags |= pkgCache::Flag::Important;
316 }
317
318 if (ParseStatus(Pkg,Ver) == false)
319 return false;
320 return true;
321}
322 /*}}}*/
323// ListParser::VersionHash - Compute a unique hash for this version /*{{{*/
324// ---------------------------------------------------------------------
325/* */
326unsigned short debListParser::VersionHash()
327{
328 const char *Sections[] ={"Installed-Size",
329 "Depends",
330 "Pre-Depends",
331// "Suggests",
332// "Recommends",
333 "Conflicts",
334 "Breaks",
335 "Replaces",0};
336 unsigned long Result = INIT_FCS;
337 char S[1024];
338 for (const char * const *I = Sections; *I != 0; ++I)
339 {
340 const char *Start;
341 const char *End;
342 if (Section.Find(*I,Start,End) == false || End - Start >= (signed)sizeof(S))
343 continue;
344
345 /* Strip out any spaces from the text, this undoes dpkgs reformatting
346 of certain fields. dpkg also has the rather interesting notion of
347 reformatting depends operators < -> <= */
348 char *J = S;
349 for (; Start != End; ++Start)
350 {
351 if (isspace(*Start) != 0)
352 continue;
353 *J++ = tolower_ascii(*Start);
354
355 if ((*Start == '<' || *Start == '>') && Start[1] != *Start && Start[1] != '=')
356 *J++ = '=';
357 }
358
359 Result = AddCRC16(Result,S,J - S);
360 }
361
362 return Result;
363}
364 /*}}}*/
365// ListParser::ParseStatus - Parse the status field /*{{{*/
366// ---------------------------------------------------------------------
367/* Status lines are of the form,
368 Status: want flag status
369 want = unknown, install, hold, deinstall, purge
370 flag = ok, reinstreq
371 status = not-installed, config-files, half-installed, unpacked,
372 half-configured, triggers-awaited, triggers-pending, installed
373 */
374bool debListParser::ParseStatus(pkgCache::PkgIterator &Pkg,
375 pkgCache::VerIterator &Ver)
376{
377 const char *Start;
378 const char *Stop;
379 if (Section.Find("Status",Start,Stop) == false)
380 return true;
381
382 // UsePackage() is responsible for setting the flag in the default case
383 bool const static essential = _config->Find("pkgCacheGen::Essential", "") == "installed";
384 if (essential == true &&
385 Section.FindFlag("Essential",Pkg->Flags,pkgCache::Flag::Essential) == false)
386 return false;
387
388 // Isolate the first word
389 const char *I = Start;
390 for(; I < Stop && *I != ' '; I++);
391 if (I >= Stop || *I != ' ')
392 return _error->Error("Malformed Status line");
393
394 // Process the want field
395 WordList WantList[] = {{"unknown",pkgCache::State::Unknown},
396 {"install",pkgCache::State::Install},
397 {"hold",pkgCache::State::Hold},
398 {"deinstall",pkgCache::State::DeInstall},
399 {"purge",pkgCache::State::Purge},
400 {NULL, 0}};
401 if (GrabWord(string(Start,I-Start),WantList,Pkg->SelectedState) == false)
402 return _error->Error("Malformed 1st word in the Status line");
403
404 // Isloate the next word
405 I++;
406 Start = I;
407 for(; I < Stop && *I != ' '; I++);
408 if (I >= Stop || *I != ' ')
409 return _error->Error("Malformed status line, no 2nd word");
410
411 // Process the flag field
412 WordList FlagList[] = {{"ok",pkgCache::State::Ok},
413 {"reinstreq",pkgCache::State::ReInstReq},
414 {"hold",pkgCache::State::HoldInst},
415 {"hold-reinstreq",pkgCache::State::HoldReInstReq},
416 {NULL, 0}};
417 if (GrabWord(string(Start,I-Start),FlagList,Pkg->InstState) == false)
418 return _error->Error("Malformed 2nd word in the Status line");
419
420 // Isloate the last word
421 I++;
422 Start = I;
423 for(; I < Stop && *I != ' '; I++);
424 if (I != Stop)
425 return _error->Error("Malformed Status line, no 3rd word");
426
427 // Process the flag field
428 WordList StatusList[] = {{"not-installed",pkgCache::State::NotInstalled},
429 {"config-files",pkgCache::State::ConfigFiles},
430 {"half-installed",pkgCache::State::HalfInstalled},
431 {"unpacked",pkgCache::State::UnPacked},
432 {"half-configured",pkgCache::State::HalfConfigured},
433 {"triggers-awaited",pkgCache::State::TriggersAwaited},
434 {"triggers-pending",pkgCache::State::TriggersPending},
435 {"installed",pkgCache::State::Installed},
436 {NULL, 0}};
437 if (GrabWord(string(Start,I-Start),StatusList,Pkg->CurrentState) == false)
438 return _error->Error("Malformed 3rd word in the Status line");
439
440 /* A Status line marks the package as indicating the current
441 version as well. Only if it is actually installed.. Otherwise
442 the interesting dpkg handling of the status file creates bogus
443 entries. */
444 if (!(Pkg->CurrentState == pkgCache::State::NotInstalled ||
445 Pkg->CurrentState == pkgCache::State::ConfigFiles))
446 {
447 if (Ver.end() == true)
448 _error->Warning("Encountered status field in a non-version description");
449 else
450 Pkg->CurrentVer = Ver.Index();
451 }
452
453 return true;
454}
455
456const char *debListParser::ConvertRelation(const char *I,unsigned int &Op)
457{
458 // Determine the operator
459 switch (*I)
460 {
461 case '<':
462 I++;
463 if (*I == '=')
464 {
465 I++;
466 Op = pkgCache::Dep::LessEq;
467 break;
468 }
469
470 if (*I == '<')
471 {
472 I++;
473 Op = pkgCache::Dep::Less;
474 break;
475 }
476
477 // < is the same as <= and << is really Cs < for some reason
478 Op = pkgCache::Dep::LessEq;
479 break;
480
481 case '>':
482 I++;
483 if (*I == '=')
484 {
485 I++;
486 Op = pkgCache::Dep::GreaterEq;
487 break;
488 }
489
490 if (*I == '>')
491 {
492 I++;
493 Op = pkgCache::Dep::Greater;
494 break;
495 }
496
497 // > is the same as >= and >> is really Cs > for some reason
498 Op = pkgCache::Dep::GreaterEq;
499 break;
500
501 case '=':
502 Op = pkgCache::Dep::Equals;
503 I++;
504 break;
505
506 // HACK around bad package definitions
507 default:
508 Op = pkgCache::Dep::Equals;
509 break;
510 }
511 return I;
512}
513 /*}}}*/
514// ListParser::ParseDepends - Parse a dependency element /*{{{*/
515// ---------------------------------------------------------------------
516/* This parses the dependency elements out of a standard string in place,
517 bit by bit. */
518const char *debListParser::ParseDepends(const char *Start,const char *Stop,
519 std::string &Package,std::string &Ver,unsigned int &Op)
520 { return ParseDepends(Start, Stop, Package, Ver, Op, false, true, false); }
521const char *debListParser::ParseDepends(const char *Start,const char *Stop,
522 std::string &Package,std::string &Ver,unsigned int &Op,
523 bool const &ParseArchFlags)
524 { return ParseDepends(Start, Stop, Package, Ver, Op, ParseArchFlags, true, false); }
525const char *debListParser::ParseDepends(const char *Start,const char *Stop,
526 std::string &Package,std::string &Ver,unsigned int &Op,
527 bool const &ParseArchFlags, bool const &StripMultiArch)
528 { return ParseDepends(Start, Stop, Package, Ver, Op, ParseArchFlags, StripMultiArch, false); }
529const char *debListParser::ParseDepends(const char *Start,const char *Stop,
530 string &Package,string &Ver,
531 unsigned int &Op, bool const &ParseArchFlags,
532 bool const &StripMultiArch,
533 bool const &ParseRestrictionsList)
534{
535 // Strip off leading space
536 for (;Start != Stop && isspace(*Start) != 0; ++Start);
537
538 // Parse off the package name
539 const char *I = Start;
540 for (;I != Stop && isspace(*I) == 0 && *I != '(' && *I != ')' &&
541 *I != ',' && *I != '|' && *I != '[' && *I != ']' &&
542 *I != '<' && *I != '>'; ++I);
543
544 // Malformed, no '('
545 if (I != Stop && *I == ')')
546 return 0;
547
548 if (I == Start)
549 return 0;
550
551 // Stash the package name
552 Package.assign(Start,I - Start);
553
554 // We don't want to confuse library users which can't handle MultiArch
555 string const arch = _config->Find("APT::Architecture");
556 if (StripMultiArch == true) {
557 size_t const found = Package.rfind(':');
558 if (found != string::npos &&
559 (strcmp(Package.c_str() + found, ":any") == 0 ||
560 strcmp(Package.c_str() + found, ":native") == 0 ||
561 strcmp(Package.c_str() + found + 1, arch.c_str()) == 0))
562 Package = Package.substr(0,found);
563 }
564
565 // Skip white space to the '('
566 for (;I != Stop && isspace(*I) != 0 ; I++);
567
568 // Parse a version
569 if (I != Stop && *I == '(')
570 {
571 // Skip the '('
572 for (I++; I != Stop && isspace(*I) != 0 ; I++);
573 if (I + 3 >= Stop)
574 return 0;
575 I = ConvertRelation(I,Op);
576
577 // Skip whitespace
578 for (;I != Stop && isspace(*I) != 0; I++);
579 Start = I;
580 I = (const char*) memchr(I, ')', Stop - I);
581 if (I == NULL || Start == I)
582 return 0;
583
584 // Skip trailing whitespace
585 const char *End = I;
586 for (; End > Start && isspace(End[-1]); End--);
587
588 Ver.assign(Start,End-Start);
589 I++;
590 }
591 else
592 {
593 Ver.clear();
594 Op = pkgCache::Dep::NoOp;
595 }
596
597 // Skip whitespace
598 for (;I != Stop && isspace(*I) != 0; I++);
599
600 if (ParseArchFlags == true)
601 {
602 APT::CacheFilter::PackageArchitectureMatchesSpecification matchesArch(arch, false);
603
604 // Parse an architecture
605 if (I != Stop && *I == '[')
606 {
607 ++I;
608 // malformed
609 if (unlikely(I == Stop))
610 return 0;
611
612 const char *End = I;
613 bool Found = false;
614 bool NegArch = false;
615 while (I != Stop)
616 {
617 // look for whitespace or ending ']'
618 for (;End != Stop && !isspace(*End) && *End != ']'; ++End);
619
620 if (unlikely(End == Stop))
621 return 0;
622
623 if (*I == '!')
624 {
625 NegArch = true;
626 ++I;
627 }
628
629 std::string arch(I, End);
630 if (arch.empty() == false && matchesArch(arch.c_str()) == true)
631 {
632 Found = true;
633 if (I[-1] != '!')
634 NegArch = false;
635 // we found a match, so fast-forward to the end of the wildcards
636 for (; End != Stop && *End != ']'; ++End);
637 }
638
639 if (*End++ == ']') {
640 I = End;
641 break;
642 }
643
644 I = End;
645 for (;I != Stop && isspace(*I) != 0; I++);
646 }
647
648 if (NegArch == true)
649 Found = !Found;
650
651 if (Found == false)
652 Package = ""; /* not for this arch */
653 }
654
655 // Skip whitespace
656 for (;I != Stop && isspace(*I) != 0; I++);
657 }
658
659 if (ParseRestrictionsList == true)
660 {
661 // Parse a restrictions formula which is in disjunctive normal form:
662 // (foo AND bar) OR (blub AND bla)
663
664 std::vector<string> const profiles = APT::Configuration::getBuildProfiles();
665
666 // if the next character is a restriction list, then by default the
667 // dependency does not apply and the conditions have to be checked
668 // if the next character is not a restriction list, then by default the
669 // dependency applies
670 bool applies1 = (*I != '<');
671 while (I != Stop)
672 {
673 if (*I != '<')
674 break;
675
676 ++I;
677 // malformed
678 if (unlikely(I == Stop))
679 return 0;
680
681 const char *End = I;
682
683 // if of the prior restriction list is already fulfilled, then
684 // we can just skip to the end of the current list
685 if (applies1) {
686 for (;End != Stop && *End != '>'; ++End);
687 I = ++End;
688 // skip whitespace
689 for (;I != Stop && isspace(*I) != 0; I++);
690 } else {
691 bool applies2 = true;
692 // all the conditions inside a restriction list have to be
693 // met so once we find one that is not met, we can skip to
694 // the end of this list
695 while (I != Stop)
696 {
697 // look for whitespace or ending '>'
698 // End now points to the character after the current term
699 for (;End != Stop && !isspace(*End) && *End != '>'; ++End);
700
701 if (unlikely(End == Stop))
702 return 0;
703
704 bool NegRestriction = false;
705 if (*I == '!')
706 {
707 NegRestriction = true;
708 ++I;
709 }
710
711 std::string restriction(I, End);
712
713 if (restriction.empty() == false && profiles.empty() == false &&
714 std::find(profiles.begin(), profiles.end(), restriction) != profiles.end())
715 {
716 if (NegRestriction) {
717 applies2 = false;
718 // since one of the terms does not apply we don't have to check the others
719 for (; End != Stop && *End != '>'; ++End);
720 }
721 } else {
722 if (!NegRestriction) {
723 applies2 = false;
724 // since one of the terms does not apply we don't have to check the others
725 for (; End != Stop && *End != '>'; ++End);
726 }
727 }
728
729 if (*End++ == '>') {
730 I = End;
731 // skip whitespace
732 for (;I != Stop && isspace(*I) != 0; I++);
733 break;
734 }
735
736 I = End;
737 // skip whitespace
738 for (;I != Stop && isspace(*I) != 0; I++);
739 }
740 if (applies2) {
741 applies1 = true;
742 }
743 }
744 }
745
746 if (applies1 == false) {
747 Package = ""; //not for this restriction
748 }
749 }
750
751 if (I != Stop && *I == '|')
752 Op |= pkgCache::Dep::Or;
753
754 if (I == Stop || *I == ',' || *I == '|')
755 {
756 if (I != Stop)
757 for (I++; I != Stop && isspace(*I) != 0; I++);
758 return I;
759 }
760
761 return 0;
762}
763 /*}}}*/
764// ListParser::ParseDepends - Parse a dependency list /*{{{*/
765// ---------------------------------------------------------------------
766/* This is the higher level depends parser. It takes a tag and generates
767 a complete depends tree for the given version. */
768bool debListParser::ParseDepends(pkgCache::VerIterator &Ver,
769 const char *Tag,unsigned int Type)
770{
771 const char *Start;
772 const char *Stop;
773 if (Section.Find(Tag,Start,Stop) == false)
774 return true;
775
776 string const pkgArch = Ver.Arch();
777
778 while (1)
779 {
780 string Package;
781 string Version;
782 unsigned int Op;
783
784 Start = ParseDepends(Start, Stop, Package, Version, Op, false, false, false);
785 if (Start == 0)
786 return _error->Error("Problem parsing dependency %s",Tag);
787 size_t const found = Package.rfind(':');
788
789 if (found == string::npos || strcmp(Package.c_str() + found, ":any") == 0)
790 {
791 if (NewDepends(Ver,Package,pkgArch,Version,Op,Type) == false)
792 return false;
793 }
794 else
795 {
796 string Arch = Package.substr(found+1, string::npos);
797 Package = Package.substr(0, found);
798 // Such dependencies are not supposed to be accepted …
799 // … but this is probably the best thing to do anyway
800 if (Arch == "native")
801 Arch = _config->Find("APT::Architecture");
802 if (NewDepends(Ver,Package,Arch,Version,Op | pkgCache::Dep::ArchSpecific,Type) == false)
803 return false;
804 }
805
806 if (Start == Stop)
807 break;
808 }
809 return true;
810}
811 /*}}}*/
812// ListParser::ParseProvides - Parse the provides list /*{{{*/
813// ---------------------------------------------------------------------
814/* */
815bool debListParser::ParseProvides(pkgCache::VerIterator &Ver)
816{
817 const char *Start;
818 const char *Stop;
819 if (Section.Find("Provides",Start,Stop) == true)
820 {
821 string Package;
822 string Version;
823 string const Arch = Ver.Arch();
824 unsigned int Op;
825
826 while (1)
827 {
828 Start = ParseDepends(Start,Stop,Package,Version,Op);
829 const size_t archfound = Package.rfind(':');
830 if (Start == 0)
831 return _error->Error("Problem parsing Provides line");
832 if (Op != pkgCache::Dep::NoOp && Op != pkgCache::Dep::Equals) {
833 _error->Warning("Ignoring Provides line with non-equal DepCompareOp for package %s", Package.c_str());
834 } else if (archfound != string::npos) {
835 string OtherArch = Package.substr(archfound+1, string::npos);
836 Package = Package.substr(0, archfound);
837 if (NewProvides(Ver, Package, OtherArch, Version, pkgCache::Flag::ArchSpecific) == false)
838 return false;
839 } else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign) {
840 if (NewProvidesAllArch(Ver, Package, Version, 0) == false)
841 return false;
842 } else {
843 if (NewProvides(Ver, Package, Arch, Version, 0) == false)
844 return false;
845 }
846
847 if (Start == Stop)
848 break;
849 }
850 }
851
852 if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
853 {
854 string const Package = string(Ver.ParentPkg().Name()).append(":").append("any");
855 return NewProvidesAllArch(Ver, Package, Ver.VerStr(), pkgCache::Flag::MultiArchImplicit);
856 }
857 else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
858 return NewProvidesAllArch(Ver, Ver.ParentPkg().Name(), Ver.VerStr(), pkgCache::Flag::MultiArchImplicit);
859
860 return true;
861}
862 /*}}}*/
863// ListParser::GrabWord - Matches a word and returns /*{{{*/
864// ---------------------------------------------------------------------
865/* Looks for a word in a list of words - for ParseStatus */
866bool debListParser::GrabWord(string Word,WordList *List,unsigned char &Out)
867{
868 for (unsigned int C = 0; List[C].Str != 0; C++)
869 {
870 if (strcasecmp(Word.c_str(),List[C].Str) == 0)
871 {
872 Out = List[C].Val;
873 return true;
874 }
875 }
876 return false;
877}
878 /*}}}*/
879// ListParser::Step - Move to the next section in the file /*{{{*/
880// ---------------------------------------------------------------------
881/* This has to be careful to only process the correct architecture */
882bool debListParser::Step()
883{
884 iOffset = Tags.Offset();
885 return Tags.Step(Section);
886}
887 /*}}}*/
888// ListParser::GetPrio - Convert the priority from a string /*{{{*/
889// ---------------------------------------------------------------------
890/* */
891unsigned char debListParser::GetPrio(string Str)
892{
893 unsigned char Out;
894 if (GrabWord(Str,PrioList,Out) == false)
895 Out = pkgCache::State::Extra;
896
897 return Out;
898}
899 /*}}}*/
900bool debListParser::SameVersion(unsigned short const Hash, /*{{{*/
901 pkgCache::VerIterator const &Ver)
902{
903 if (pkgCacheListParser::SameVersion(Hash, Ver) == false)
904 return false;
905 // status file has no (Download)Size, but all others are fair game
906 // status file is parsed last, so the first version we encounter is
907 // probably also the version we have downloaded
908 unsigned long long const Size = Section.FindULL("Size");
909 if (Size != 0 && Size != Ver->Size)
910 return false;
911 // available everywhere, but easier to check here than to include in VersionHash
912 unsigned char MultiArch = ParseMultiArch(false);
913 if (MultiArch != Ver->MultiArch)
914 return false;
915 // for all practical proposes (we can check): same version
916 return true;
917}
918 /*}}}*/
919
920debDebFileParser::debDebFileParser(FileFd *File, std::string const &DebFile)
921 : debListParser(File), DebFile(DebFile)
922{
923}
924
925bool debDebFileParser::UsePackage(pkgCache::PkgIterator &Pkg,
926 pkgCache::VerIterator &Ver)
927{
928 bool res = debListParser::UsePackage(Pkg, Ver);
929 // we use the full file path as a provides so that the file is found
930 // by its name
931 if(NewProvides(Ver, DebFile, Pkg.Cache()->NativeArch(), Ver.VerStr(), 0) == false)
932 return false;
933 return res;
934}
935
936debListParser::~debListParser() {}
APT (for Cydia)