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