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