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