]> 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
buildsystem: deal with spaces in path to source
[apt.git] / apt-pkg / deb / deblistparser.cc
... / ...
CommitLineData
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
3// $Id: deblistparser.cc,v 1.29.2.5 2004/01/06 01:43:44 mdz Exp $
4/* ######################################################################
5
6 Package Cache Generator - Generator for the cache structure.
7
8 This builds the cache structure from the abstract package list parser.
9
10 ##################################################################### */
11 /*}}}*/
12// Include Files /*{{{*/
13#include <config.h>
14
15#include <apt-pkg/deblistparser.h>
16#include <apt-pkg/error.h>
17#include <apt-pkg/configuration.h>
18#include <apt-pkg/cachefilter.h>
19#include <apt-pkg/aptconfiguration.h>
20#include <apt-pkg/strutl.h>
21#include <apt-pkg/crc-16.h>
22#include <apt-pkg/md5.h>
23#include <apt-pkg/pkgcache.h>
24#include <apt-pkg/cacheiterators.h>
25#include <apt-pkg/tagfile.h>
26#include <apt-pkg/macros.h>
27
28#include <stddef.h>
29#include <string.h>
30#include <algorithm>
31#include <string>
32#include <vector>
33#include <ctype.h>
34 /*}}}*/
35
36using std::string;
37
38static const debListParser::WordList PrioList[] = {
39 {"required",pkgCache::State::Required},
40 {"important",pkgCache::State::Important},
41 {"standard",pkgCache::State::Standard},
42 {"optional",pkgCache::State::Optional},
43 {"extra",pkgCache::State::Extra},
44 {NULL, 0}};
45
46// ListParser::debListParser - Constructor /*{{{*/
47// ---------------------------------------------------------------------
48/* Provide an architecture and only this one and "all" will be accepted
49 in Step(), if no Architecture is given we will accept every arch
50 we would accept in general with checkArchitecture() */
51debListParser::debListParser(FileFd *File) :
52 pkgCacheListParser(), d(NULL), Tags(File)
53{
54}
55 /*}}}*/
56// ListParser::Package - Return the package name /*{{{*/
57// ---------------------------------------------------------------------
58/* This is to return the name of the package this section describes */
59string debListParser::Package() {
60 string Result = Section.FindS("Package");
61
62 // Normalize mixed case package names to lower case, like dpkg does
63 // See Bug#807012 for details
64 std::transform(Result.begin(), Result.end(), Result.begin(), tolower_ascii);
65
66 if(unlikely(Result.empty() == true))
67 _error->Error("Encountered a section with no Package: header");
68 return Result;
69}
70 /*}}}*/
71// ListParser::Architecture - Return the package arch /*{{{*/
72// ---------------------------------------------------------------------
73/* This will return the Architecture of the package this section describes */
74string debListParser::Architecture() {
75 std::string const Arch = Section.FindS("Architecture");
76 return Arch.empty() ? "none" : Arch;
77}
78 /*}}}*/
79// ListParser::ArchitectureAll /*{{{*/
80// ---------------------------------------------------------------------
81/* */
82bool debListParser::ArchitectureAll() {
83 return Section.FindS("Architecture") == "all";
84}
85 /*}}}*/
86// ListParser::Version - Return the version string /*{{{*/
87// ---------------------------------------------------------------------
88/* This is to return the string describing the version in debian form,
89 epoch:upstream-release. If this returns the blank string then the
90 entry is assumed to only describe package properties */
91string debListParser::Version()
92{
93 return Section.FindS("Version");
94}
95 /*}}}*/
96unsigned char debListParser::ParseMultiArch(bool const showErrors) /*{{{*/
97{
98 unsigned char MA;
99 string const MultiArch = Section.FindS("Multi-Arch");
100 if (MultiArch.empty() == true || MultiArch == "no")
101 MA = pkgCache::Version::No;
102 else if (MultiArch == "same") {
103 if (ArchitectureAll() == true)
104 {
105 if (showErrors == true)
106 _error->Warning("Architecture: all package '%s' can't be Multi-Arch: same",
107 Section.FindS("Package").c_str());
108 MA = pkgCache::Version::No;
109 }
110 else
111 MA = pkgCache::Version::Same;
112 }
113 else if (MultiArch == "foreign")
114 MA = pkgCache::Version::Foreign;
115 else if (MultiArch == "allowed")
116 MA = pkgCache::Version::Allowed;
117 else
118 {
119 if (showErrors == true)
120 _error->Warning("Unknown Multi-Arch type '%s' for package '%s'",
121 MultiArch.c_str(), Section.FindS("Package").c_str());
122 MA = pkgCache::Version::No;
123 }
124
125 if (ArchitectureAll() == true)
126 MA |= pkgCache::Version::All;
127
128 return MA;
129}
130 /*}}}*/
131// ListParser::NewVersion - Fill in the version structure /*{{{*/
132// ---------------------------------------------------------------------
133/* */
134bool debListParser::NewVersion(pkgCache::VerIterator &Ver)
135{
136 const char *Start;
137 const char *Stop;
138
139 // Parse the section
140 if (Section.Find("Section",Start,Stop) == true)
141 {
142 map_stringitem_t const idx = StoreString(pkgCacheGenerator::SECTION, Start, Stop - Start);
143 Ver->Section = idx;
144 }
145 // Parse the source package name
146 pkgCache::GrpIterator const G = Ver.ParentPkg().Group();
147 Ver->SourcePkgName = G->Name;
148 Ver->SourceVerStr = Ver->VerStr;
149 if (Section.Find("Source",Start,Stop) == true)
150 {
151 const char * const Space = (const char * const) memchr(Start, ' ', Stop - Start);
152 pkgCache::VerIterator V;
153
154 if (Space != NULL)
155 {
156 Stop = Space;
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 std::string const version(Open + 1, (Close - Open) - 1);
164 if (version != Ver.VerStr())
165 {
166 map_stringitem_t const idx = StoreString(pkgCacheGenerator::VERSIONNUMBER, version);
167 Ver->SourceVerStr = idx;
168 }
169 }
170 }
171 }
172
173 std::string const pkgname(Start, Stop - Start);
174 if (pkgname != G.Name())
175 {
176 for (pkgCache::PkgIterator P = G.PackageList(); P.end() == false; P = G.NextPkg(P))
177 {
178 for (V = P.VersionList(); V.end() == false; ++V)
179 {
180 if (pkgname == V.SourcePkgName())
181 {
182 Ver->SourcePkgName = V->SourcePkgName;
183 break;
184 }
185 }
186 if (V.end() == false)
187 break;
188 }
189 if (V.end() == true)
190 {
191 map_stringitem_t const idx = StoreString(pkgCacheGenerator::PKGNAME, pkgname);
192 Ver->SourcePkgName = idx;
193 }
194 }
195 }
196
197 Ver->MultiArch = ParseMultiArch(true);
198 // Archive Size
199 Ver->Size = Section.FindULL("Size");
200 // Unpacked Size (in K)
201 Ver->InstalledSize = Section.FindULL("Installed-Size");
202 Ver->InstalledSize *= 1024;
203
204 // Priority
205 if (Section.Find("Priority",Start,Stop) == true)
206 {
207 if (GrabWord(string(Start,Stop-Start),PrioList,Ver->Priority) == false)
208 Ver->Priority = pkgCache::State::Extra;
209 }
210
211 if (ParseDepends(Ver,"Pre-Depends",pkgCache::Dep::PreDepends) == false)
212 return false;
213 if (ParseDepends(Ver,"Depends",pkgCache::Dep::Depends) == false)
214 return false;
215 if (ParseDepends(Ver,"Conflicts",pkgCache::Dep::Conflicts) == false)
216 return false;
217 if (ParseDepends(Ver,"Breaks",pkgCache::Dep::DpkgBreaks) == false)
218 return false;
219 if (ParseDepends(Ver,"Recommends",pkgCache::Dep::Recommends) == false)
220 return false;
221 if (ParseDepends(Ver,"Suggests",pkgCache::Dep::Suggests) == false)
222 return false;
223 if (ParseDepends(Ver,"Replaces",pkgCache::Dep::Replaces) == false)
224 return false;
225 if (ParseDepends(Ver,"Enhances",pkgCache::Dep::Enhances) == false)
226 return false;
227 // Obsolete.
228 if (ParseDepends(Ver,"Optional",pkgCache::Dep::Suggests) == false)
229 return false;
230
231 if (ParseProvides(Ver) == false)
232 return false;
233
234 return true;
235}
236 /*}}}*/
237// ListParser::Description - Return the description string /*{{{*/
238// ---------------------------------------------------------------------
239/* This is to return the string describing the package in debian
240 form. If this returns the blank string then the entry is assumed to
241 only describe package properties */
242string debListParser::Description(std::string const &lang)
243{
244 if (lang.empty())
245 return Section.FindS("Description");
246 else
247 return Section.FindS(string("Description-").append(lang).c_str());
248}
249 /*}}}*/
250// ListParser::AvailableDescriptionLanguages /*{{{*/
251std::vector<std::string> debListParser::AvailableDescriptionLanguages()
252{
253 std::vector<std::string> const understood = APT::Configuration::getLanguages();
254 std::vector<std::string> avail;
255 if (Section.Exists("Description") == true)
256 avail.push_back("");
257 for (std::vector<std::string>::const_iterator lang = understood.begin(); lang != understood.end(); ++lang)
258 {
259 std::string const tagname = "Description-" + *lang;
260 if (Section.Exists(tagname.c_str()) == true)
261 avail.push_back(*lang);
262 }
263 return avail;
264}
265 /*}}}*/
266// ListParser::Description_md5 - Return the description_md5 MD5SumValue /*{{{*/
267// ---------------------------------------------------------------------
268/* This is to return the md5 string to allow the check if it is the right
269 description. If no Description-md5 is found in the section it will be
270 calculated.
271 */
272MD5SumValue debListParser::Description_md5()
273{
274 string const value = Section.FindS("Description-md5");
275 if (value.empty() == true)
276 {
277 std::string const desc = Description("") + "\n";
278 if (desc == "\n")
279 return MD5SumValue();
280
281 MD5Summation md5;
282 md5.Add(desc.c_str());
283 return md5.Result();
284 }
285 else if (likely(value.size() == 32))
286 {
287 if (likely(value.find_first_not_of("0123456789abcdefABCDEF") == string::npos))
288 return MD5SumValue(value);
289 _error->Error("Malformed Description-md5 line; includes invalid character '%s'", value.c_str());
290 return MD5SumValue();
291 }
292 _error->Error("Malformed Description-md5 line; doesn't have the required length (32 != %d) '%s'", (int)value.size(), value.c_str());
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 const char *Sections[] ={"Installed-Size",
334 "Depends",
335 "Pre-Depends",
336// "Suggests",
337// "Recommends",
338 "Conflicts",
339 "Breaks",
340 "Replaces",0};
341 unsigned long Result = INIT_FCS;
342 char S[1024];
343 for (const char * const *I = Sections; *I != 0; ++I)
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(*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 {NULL, 0}};
411 if (GrabWord(string(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 {NULL, 0}};
427 if (GrabWord(string(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 {NULL, 0}};
447 if (GrabWord(string(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 // Strip off leading space
546 for (;Start != Stop && isspace(*Start) != 0; ++Start);
547
548 // Parse off the package name
549 const char *I = Start;
550 for (;I != Stop && isspace(*I) == 0 && *I != '(' && *I != ')' &&
551 *I != ',' && *I != '|' && *I != '[' && *I != ']' &&
552 *I != '<' && *I != '>'; ++I);
553
554 // Malformed, no '('
555 if (I != Stop && *I == ')')
556 return 0;
557
558 if (I == Start)
559 return 0;
560
561 // Stash the package name
562 Package.assign(Start,I - Start);
563
564 // We don't want to confuse library users which can't handle MultiArch
565 string const arch = _config->Find("APT::Architecture");
566 if (StripMultiArch == true) {
567 size_t const found = Package.rfind(':');
568 if (found != string::npos &&
569 (strcmp(Package.c_str() + found, ":any") == 0 ||
570 strcmp(Package.c_str() + found, ":native") == 0 ||
571 strcmp(Package.c_str() + found + 1, arch.c_str()) == 0))
572 Package = Package.substr(0,found);
573 }
574
575 // Skip white space to the '('
576 for (;I != Stop && isspace(*I) != 0 ; I++);
577
578 // Parse a version
579 if (I != Stop && *I == '(')
580 {
581 // Skip the '('
582 for (I++; I != Stop && isspace(*I) != 0 ; I++);
583 if (I + 3 >= Stop)
584 return 0;
585 I = ConvertRelation(I,Op);
586
587 // Skip whitespace
588 for (;I != Stop && isspace(*I) != 0; I++);
589 Start = I;
590 I = (const char*) memchr(I, ')', Stop - I);
591 if (I == NULL || Start == I)
592 return 0;
593
594 // Skip trailing whitespace
595 const char *End = I;
596 for (; End > Start && isspace(End[-1]); End--);
597
598 Ver.assign(Start,End-Start);
599 I++;
600 }
601 else
602 {
603 Ver.clear();
604 Op = pkgCache::Dep::NoOp;
605 }
606
607 // Skip whitespace
608 for (;I != Stop && isspace(*I) != 0; I++);
609
610 if (ParseArchFlags == true)
611 {
612 APT::CacheFilter::PackageArchitectureMatchesSpecification matchesArch(arch, false);
613
614 // Parse an architecture
615 if (I != Stop && *I == '[')
616 {
617 ++I;
618 // malformed
619 if (unlikely(I == Stop))
620 return 0;
621
622 const char *End = I;
623 bool Found = false;
624 bool NegArch = false;
625 while (I != Stop)
626 {
627 // look for whitespace or ending ']'
628 for (;End != Stop && !isspace(*End) && *End != ']'; ++End);
629
630 if (unlikely(End == Stop))
631 return 0;
632
633 if (*I == '!')
634 {
635 NegArch = true;
636 ++I;
637 }
638
639 std::string arch(I, End);
640 if (arch.empty() == false && matchesArch(arch.c_str()) == true)
641 {
642 Found = true;
643 if (I[-1] != '!')
644 NegArch = false;
645 // we found a match, so fast-forward to the end of the wildcards
646 for (; End != Stop && *End != ']'; ++End);
647 }
648
649 if (*End++ == ']') {
650 I = End;
651 break;
652 }
653
654 I = End;
655 for (;I != Stop && isspace(*I) != 0; I++);
656 }
657
658 if (NegArch == true)
659 Found = !Found;
660
661 if (Found == false)
662 Package = ""; /* not for this arch */
663 }
664
665 // Skip whitespace
666 for (;I != Stop && isspace(*I) != 0; I++);
667 }
668
669 if (ParseRestrictionsList == true)
670 {
671 // Parse a restrictions formula which is in disjunctive normal form:
672 // (foo AND bar) OR (blub AND bla)
673
674 std::vector<string> const profiles = APT::Configuration::getBuildProfiles();
675
676 // if the next character is a restriction list, then by default the
677 // dependency does not apply and the conditions have to be checked
678 // if the next character is not a restriction list, then by default the
679 // dependency applies
680 bool applies1 = (*I != '<');
681 while (I != Stop)
682 {
683 if (*I != '<')
684 break;
685
686 ++I;
687 // malformed
688 if (unlikely(I == Stop))
689 return 0;
690
691 const char *End = I;
692
693 // if of the prior restriction list is already fulfilled, then
694 // we can just skip to the end of the current list
695 if (applies1) {
696 for (;End != Stop && *End != '>'; ++End);
697 I = ++End;
698 // skip whitespace
699 for (;I != Stop && isspace(*I) != 0; I++);
700 } else {
701 bool applies2 = true;
702 // all the conditions inside a restriction list have to be
703 // met so once we find one that is not met, we can skip to
704 // the end of this list
705 while (I != Stop)
706 {
707 // look for whitespace or ending '>'
708 // End now points to the character after the current term
709 for (;End != Stop && !isspace(*End) && *End != '>'; ++End);
710
711 if (unlikely(End == Stop))
712 return 0;
713
714 bool NegRestriction = false;
715 if (*I == '!')
716 {
717 NegRestriction = true;
718 ++I;
719 }
720
721 std::string restriction(I, End);
722
723 if (restriction.empty() == false && profiles.empty() == false &&
724 std::find(profiles.begin(), profiles.end(), restriction) != profiles.end())
725 {
726 if (NegRestriction) {
727 applies2 = false;
728 // since one of the terms does not apply we don't have to check the others
729 for (; End != Stop && *End != '>'; ++End);
730 }
731 } else {
732 if (!NegRestriction) {
733 applies2 = false;
734 // since one of the terms does not apply we don't have to check the others
735 for (; End != Stop && *End != '>'; ++End);
736 }
737 }
738
739 if (*End++ == '>') {
740 I = End;
741 // skip whitespace
742 for (;I != Stop && isspace(*I) != 0; I++);
743 break;
744 }
745
746 I = End;
747 // skip whitespace
748 for (;I != Stop && isspace(*I) != 0; I++);
749 }
750 if (applies2) {
751 applies1 = true;
752 }
753 }
754 }
755
756 if (applies1 == false) {
757 Package = ""; //not for this restriction
758 }
759 }
760
761 if (I != Stop && *I == '|')
762 Op |= pkgCache::Dep::Or;
763
764 if (I == Stop || *I == ',' || *I == '|')
765 {
766 if (I != Stop)
767 for (I++; I != Stop && isspace(*I) != 0; I++);
768 return I;
769 }
770
771 return 0;
772}
773 /*}}}*/
774// ListParser::ParseDepends - Parse a dependency list /*{{{*/
775// ---------------------------------------------------------------------
776/* This is the higher level depends parser. It takes a tag and generates
777 a complete depends tree for the given version. */
778bool debListParser::ParseDepends(pkgCache::VerIterator &Ver,
779 const char *Tag,unsigned int Type)
780{
781 const char *Start;
782 const char *Stop;
783 if (Section.Find(Tag,Start,Stop) == false)
784 return true;
785
786 string const pkgArch = Ver.Arch();
787
788 while (1)
789 {
790 string Package;
791 string Version;
792 unsigned int Op;
793
794 Start = ParseDepends(Start, Stop, Package, Version, Op, false, false, false);
795 if (Start == 0)
796 return _error->Error("Problem parsing dependency %s",Tag);
797 size_t const found = Package.rfind(':');
798
799 if (found == string::npos)
800 {
801 if (NewDepends(Ver,Package,pkgArch,Version,Op,Type) == false)
802 return false;
803 }
804 else if (strcmp(Package.c_str() + found, ":any") == 0)
805 {
806 if (NewDepends(Ver,Package,"any",Version,Op,Type) == false)
807 return false;
808 }
809 else
810 {
811 // Such dependencies are not supposed to be accepted …
812 // … but this is probably the best thing to do anyway
813 if (Package.substr(found + 1) == "native")
814 Package = Package.substr(0, found) + ':' + Ver.Cache()->NativeArch();
815
816 if (NewDepends(Ver, Package, "any", Version, Op | pkgCache::Dep::ArchSpecific, Type) == false)
817 return false;
818 }
819
820 if (Start == Stop)
821 break;
822 }
823 return true;
824}
825 /*}}}*/
826// ListParser::ParseProvides - Parse the provides list /*{{{*/
827// ---------------------------------------------------------------------
828/* */
829bool debListParser::ParseProvides(pkgCache::VerIterator &Ver)
830{
831 /* it is unlikely, but while parsing dependencies, we might have already
832 picked up multi-arch implicit provides which we do not want to duplicate here */
833 bool hasProvidesAlready = false;
834 std::string const spzName = Ver.ParentPkg().FullName(false);
835 {
836 for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
837 {
838 if (Prv.IsMultiArchImplicit() == false || (Prv->Flags & pkgCache::Flag::ArchSpecific) == 0)
839 continue;
840 if (spzName != Prv.OwnerPkg().FullName(false))
841 continue;
842 hasProvidesAlready = true;
843 break;
844 }
845 }
846
847 string const Arch = Ver.Arch();
848 const char *Start;
849 const char *Stop;
850 if (Section.Find("Provides",Start,Stop) == true)
851 {
852 string Package;
853 string Version;
854 unsigned int Op;
855
856 do
857 {
858 Start = ParseDepends(Start,Stop,Package,Version,Op, false, false, false);
859 const size_t archfound = Package.rfind(':');
860 if (Start == 0)
861 return _error->Error("Problem parsing Provides line");
862 if (Op != pkgCache::Dep::NoOp && Op != pkgCache::Dep::Equals) {
863 _error->Warning("Ignoring Provides line with non-equal DepCompareOp for package %s", Package.c_str());
864 } else if (archfound != string::npos) {
865 std::string spzArch = Package.substr(archfound + 1);
866 if (spzArch != "any")
867 {
868 if (NewProvides(Ver, Package.substr(0, archfound), spzArch, Version, pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false)
869 return false;
870 }
871 if (NewProvides(Ver, Package, "any", Version, pkgCache::Flag::ArchSpecific) == false)
872 return false;
873 } else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign) {
874 if (APT::Configuration::checkArchitecture(Arch))
875 if (NewProvidesAllArch(Ver, Package, Version, 0) == false)
876 return false;
877 } else {
878 if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
879 {
880 if (NewProvides(Ver, Package + ":any", "any", Version, pkgCache::Flag::MultiArchImplicit) == false)
881 return false;
882 }
883 if (NewProvides(Ver, Package, Arch, Version, 0) == false)
884 return false;
885 }
886 if (archfound == std::string::npos)
887 {
888 std::string const spzName = Package + ':' + Ver.ParentPkg().Arch();
889 pkgCache::PkgIterator const spzPkg = Ver.Cache()->FindPkg(spzName, "any");
890 if (spzPkg.end() == false)
891 {
892 if (NewProvides(Ver, spzName, "any", Version, pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false)
893 return false;
894 }
895 }
896 } while (Start != Stop);
897 }
898
899 if (APT::Configuration::checkArchitecture(Arch))
900 {
901 if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
902 {
903 string const Package = string(Ver.ParentPkg().Name()).append(":").append("any");
904 if (NewProvides(Ver, Package, "any", Ver.VerStr(), pkgCache::Flag::MultiArchImplicit) == false)
905 return false;
906 }
907 else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
908 {
909 if (NewProvidesAllArch(Ver, Ver.ParentPkg().Name(), Ver.VerStr(), pkgCache::Flag::MultiArchImplicit) == false)
910 return false;
911 }
912 }
913
914 if (hasProvidesAlready == false)
915 {
916 pkgCache::PkgIterator const spzPkg = Ver.Cache()->FindPkg(spzName, "any");
917 if (spzPkg.end() == false)
918 {
919 if (NewProvides(Ver, spzName, "any", Ver.VerStr(), pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false)
920 return false;
921 }
922 }
923 return true;
924}
925 /*}}}*/
926// ListParser::GrabWord - Matches a word and returns /*{{{*/
927// ---------------------------------------------------------------------
928/* Looks for a word in a list of words - for ParseStatus */
929bool debListParser::GrabWord(string Word,const WordList *List,unsigned char &Out)
930{
931 for (unsigned int C = 0; List[C].Str != 0; C++)
932 {
933 if (strcasecmp(Word.c_str(),List[C].Str) == 0)
934 {
935 Out = List[C].Val;
936 return true;
937 }
938 }
939 return false;
940}
941 /*}}}*/
942// ListParser::Step - Move to the next section in the file /*{{{*/
943// ---------------------------------------------------------------------
944/* This has to be careful to only process the correct architecture */
945bool debListParser::Step()
946{
947 iOffset = Tags.Offset();
948 return Tags.Step(Section);
949}
950 /*}}}*/
951// ListParser::GetPrio - Convert the priority from a string /*{{{*/
952// ---------------------------------------------------------------------
953/* */
954unsigned char debListParser::GetPrio(string Str)
955{
956 unsigned char Out;
957 if (GrabWord(Str,PrioList,Out) == false)
958 Out = pkgCache::State::Extra;
959
960 return Out;
961}
962 /*}}}*/
963bool debListParser::SameVersion(unsigned short const Hash, /*{{{*/
964 pkgCache::VerIterator const &Ver)
965{
966 if (pkgCacheListParser::SameVersion(Hash, Ver) == false)
967 return false;
968 // status file has no (Download)Size, but all others are fair game
969 // status file is parsed last, so the first version we encounter is
970 // probably also the version we have downloaded
971 unsigned long long const Size = Section.FindULL("Size");
972 if (Size != 0 && Size != Ver->Size)
973 return false;
974 // available everywhere, but easier to check here than to include in VersionHash
975 unsigned char MultiArch = ParseMultiArch(false);
976 if (MultiArch != Ver->MultiArch)
977 return false;
978 // for all practical proposes (we can check): same version
979 return true;
980}
981 /*}}}*/
982
983debDebFileParser::debDebFileParser(FileFd *File, std::string const &DebFile)
984 : debListParser(File), DebFile(DebFile)
985{
986}
987
988bool debDebFileParser::UsePackage(pkgCache::PkgIterator &Pkg,
989 pkgCache::VerIterator &Ver)
990{
991 bool res = debListParser::UsePackage(Pkg, Ver);
992 // we use the full file path as a provides so that the file is found
993 // by its name
994 if(NewProvides(Ver, DebFile, Pkg.Cache()->NativeArch(), Ver.VerStr(), 0) == false)
995 return false;
996 return res;
997}
998
999debListParser::~debListParser() {}
APT (for Cydia)