1043 lines
34 KiB
C++
1043 lines
34 KiB
C++
// -*- mode: cpp; mode: fold -*-
|
||
// Description /*{{{*/
|
||
/* ######################################################################
|
||
|
||
Package Cache Generator - Generator for the cache structure.
|
||
|
||
This builds the cache structure from the abstract package list parser.
|
||
|
||
##################################################################### */
|
||
/*}}}*/
|
||
// Include Files /*{{{*/
|
||
#include <config.h>
|
||
|
||
#include <apt-pkg/algorithms.h>
|
||
#include <apt-pkg/aptconfiguration.h>
|
||
#include <apt-pkg/cachefilter.h>
|
||
#include <apt-pkg/configuration.h>
|
||
#include <apt-pkg/deblistparser.h>
|
||
#include <apt-pkg/error.h>
|
||
#include <apt-pkg/hashes.h>
|
||
#include <apt-pkg/macros.h>
|
||
#include <apt-pkg/pkgcache.h>
|
||
#include <apt-pkg/strutl.h>
|
||
#include <apt-pkg/tagfile-keys.h>
|
||
#include <apt-pkg/tagfile.h>
|
||
|
||
#include <algorithm>
|
||
#include <cctype>
|
||
#include <cstddef>
|
||
#include <cstring>
|
||
#include <string>
|
||
#include <vector>
|
||
/*}}}*/
|
||
|
||
using std::string;
|
||
using std::string_view;
|
||
using namespace std::literals;
|
||
|
||
static const debListParser::WordList PrioList[] = {
|
||
{"required",pkgCache::State::Required},
|
||
{"important",pkgCache::State::Important},
|
||
{"standard",pkgCache::State::Standard},
|
||
{"optional",pkgCache::State::Optional},
|
||
{"extra",pkgCache::State::Extra},
|
||
{"", 0}};
|
||
|
||
// ListParser::debListParser - Constructor /*{{{*/
|
||
// ---------------------------------------------------------------------
|
||
/* Provide an architecture and only this one and "all" will be accepted
|
||
in Step(), if no Architecture is given we will accept every arch
|
||
we would accept in general with checkArchitecture() */
|
||
debListParser::debListParser(FileFd *File) :
|
||
pkgCacheListParser(), Tags(File)
|
||
{
|
||
// this dance allows an empty value to override the default
|
||
if (_config->Exists("pkgCacheGen::ForceEssential"))
|
||
{
|
||
forceEssential = _config->FindVector("pkgCacheGen::ForceEssential");
|
||
if (forceEssential.empty() == false && _config->Find("pkgCacheGen::ForceEssential").empty())
|
||
forceEssential.emplace_back("apt");
|
||
}
|
||
else
|
||
forceEssential.emplace_back("apt");
|
||
forceImportant = _config->FindVector("pkgCacheGen::ForceImportant");
|
||
myArch = _config->Find("APT::Architecture");
|
||
}
|
||
/*}}}*/
|
||
// ListParser::Package - Return the package name /*{{{*/
|
||
// ---------------------------------------------------------------------
|
||
/* This is to return the name of the package this section describes */
|
||
string debListParser::Package() {
|
||
string Result{Section.Find(pkgTagSection::Key::Package)};
|
||
|
||
// Normalize mixed case package names to lower case, like dpkg does
|
||
// See Bug#807012 for details.
|
||
// Only do this when the package name does not contain a / - as that
|
||
// indicates that the package name was derived from a filename given
|
||
// to install or build-dep or similar (Bug#854794)
|
||
if (likely(Result.find('/') == string::npos))
|
||
{
|
||
for (char &c: Result)
|
||
{
|
||
char l = tolower_ascii_inline(c);
|
||
if (unlikely(l != c))
|
||
c = l;
|
||
}
|
||
}
|
||
|
||
if(unlikely(Result.empty() == true))
|
||
_error->Error("Encountered a section with no Package: header");
|
||
return Result;
|
||
}
|
||
/*}}}*/
|
||
// ListParser::Architecture - Return the package arch /*{{{*/
|
||
// ---------------------------------------------------------------------
|
||
/* This will return the Architecture of the package this section describes */
|
||
std::string_view debListParser::Architecture() {
|
||
auto const Arch = Section.Find(pkgTagSection::Key::Architecture);
|
||
return Arch.empty() ? "none" : Arch;
|
||
}
|
||
/*}}}*/
|
||
// ListParser::ArchitectureAll /*{{{*/
|
||
// ---------------------------------------------------------------------
|
||
/* */
|
||
bool debListParser::ArchitectureAll() {
|
||
return Section.Find(pkgTagSection::Key::Architecture) == "all";
|
||
}
|
||
/*}}}*/
|
||
// ListParser::Version - Return the version string /*{{{*/
|
||
// ---------------------------------------------------------------------
|
||
/* This is to return the string describing the version in debian form,
|
||
epoch:upstream-release. If this returns the blank string then the
|
||
entry is assumed to only describe package properties */
|
||
std::string_view debListParser::Version()
|
||
{
|
||
return Section.Find(pkgTagSection::Key::Version);
|
||
}
|
||
/*}}}*/
|
||
unsigned char debListParser::ParseMultiArch(bool const showErrors) /*{{{*/
|
||
{
|
||
unsigned char MA;
|
||
auto const MultiArch = Section.Find(pkgTagSection::Key::Multi_Arch);
|
||
if (MultiArch.empty() == true || MultiArch == "no"sv)
|
||
MA = pkgCache::Version::No;
|
||
else if (MultiArch == "same"sv) {
|
||
if (ArchitectureAll() == true)
|
||
{
|
||
if (showErrors == true)
|
||
_error->Warning("Architecture: all package '%s' can't be Multi-Arch: same",
|
||
Package().c_str());
|
||
MA = pkgCache::Version::No;
|
||
}
|
||
else
|
||
MA = pkgCache::Version::Same;
|
||
}
|
||
else if (MultiArch == "foreign"sv)
|
||
MA = pkgCache::Version::Foreign;
|
||
else if (MultiArch == "allowed"sv)
|
||
MA = pkgCache::Version::Allowed;
|
||
else
|
||
{
|
||
if (showErrors == true)
|
||
_error->Warning("Unknown Multi-Arch type '%.*s' for package '%s'",
|
||
(int)MultiArch.size(), MultiArch.data(), Package().c_str());
|
||
MA = pkgCache::Version::No;
|
||
}
|
||
|
||
if (ArchitectureAll() == true)
|
||
MA |= pkgCache::Version::All;
|
||
|
||
return MA;
|
||
}
|
||
/*}}}*/
|
||
// ListParser::NewVersion - Fill in the version structure /*{{{*/
|
||
// ---------------------------------------------------------------------
|
||
/* */
|
||
bool debListParser::NewVersion(pkgCache::VerIterator &Ver)
|
||
{
|
||
const char *Start;
|
||
const char *Stop;
|
||
|
||
// Parse the section
|
||
if (Section.Find(pkgTagSection::Key::Section,Start,Stop) == true)
|
||
{
|
||
map_stringitem_t const idx = StoreString(pkgCacheGenerator::SECTION, Start, Stop - Start);
|
||
Ver->Section = idx;
|
||
}
|
||
// Parse the source package name
|
||
pkgCache::GrpIterator G = Ver.ParentPkg().Group();
|
||
|
||
// Setup the defaults
|
||
Ver.SourceVersion()->Group = G.MapPointer();
|
||
Ver.SourceVersion()->VerStr = Ver->VerStr;
|
||
|
||
// Parse the name and version str
|
||
if (Section.Find(pkgTagSection::Key::Source,Start,Stop) == true)
|
||
{
|
||
const char * const Space = static_cast<const char *>(memchr(Start, ' ', Stop - Start));
|
||
pkgCache::VerIterator V;
|
||
|
||
if (Space != NULL)
|
||
{
|
||
const char * const Open = static_cast<const char *>(memchr(Space, '(', Stop - Space));
|
||
if (likely(Open != NULL))
|
||
{
|
||
const char * const Close = static_cast<const char *>(memchr(Open, ')', Stop - Open));
|
||
if (likely(Close != NULL))
|
||
{
|
||
std::string_view const version(Open + 1, (Close - Open) - 1);
|
||
if (version != Ver.VerStr())
|
||
{
|
||
map_stringitem_t const idx = StoreString(pkgCacheGenerator::VERSIONNUMBER, version);
|
||
G = Ver.ParentPkg().Group();
|
||
Ver.SourceVersion()->VerStr = idx;
|
||
}
|
||
}
|
||
}
|
||
Stop = Space;
|
||
}
|
||
|
||
std::string_view const pkgname(Start, Stop - Start);
|
||
// Oh, our group is the wrong one for the source package. Make a new one.
|
||
if (pkgname != G.Name())
|
||
{
|
||
if (not NewGroup(G, pkgname))
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// Link into by source package group.
|
||
Ver.SourceVersion()->Group = G.MapPointer();
|
||
Ver->NextInSource = G->VersionsInSource;
|
||
G->VersionsInSource = Ver.MapPointer();
|
||
|
||
Ver->MultiArch = ParseMultiArch(true);
|
||
// Archive Size
|
||
Ver->Size = Section.FindULL(pkgTagSection::Key::Size);
|
||
// Unpacked Size (in K)
|
||
Ver->InstalledSize = Section.FindULL(pkgTagSection::Key::Installed_Size);
|
||
Ver->InstalledSize *= 1024;
|
||
|
||
// Priority
|
||
if (Section.Find(pkgTagSection::Key::Priority,Start,Stop) == true)
|
||
{
|
||
if (GrabWord(string_view(Start,Stop-Start),PrioList,Ver->Priority) == false)
|
||
Ver->Priority = pkgCache::State::Extra;
|
||
}
|
||
|
||
if (ParseDepends(Ver,pkgTagSection::Key::Pre_Depends,pkgCache::Dep::PreDepends) == false)
|
||
return false;
|
||
if (ParseDepends(Ver,pkgTagSection::Key::Depends,pkgCache::Dep::Depends) == false)
|
||
return false;
|
||
if (ParseDepends(Ver,pkgTagSection::Key::Conflicts,pkgCache::Dep::Conflicts) == false)
|
||
return false;
|
||
if (ParseDepends(Ver,pkgTagSection::Key::Breaks,pkgCache::Dep::DpkgBreaks) == false)
|
||
return false;
|
||
if (ParseDepends(Ver,pkgTagSection::Key::Recommends,pkgCache::Dep::Recommends) == false)
|
||
return false;
|
||
if (ParseDepends(Ver,pkgTagSection::Key::Suggests,pkgCache::Dep::Suggests) == false)
|
||
return false;
|
||
if (ParseDepends(Ver,pkgTagSection::Key::Replaces,pkgCache::Dep::Replaces) == false)
|
||
return false;
|
||
if (ParseDepends(Ver,pkgTagSection::Key::Enhances,pkgCache::Dep::Enhances) == false)
|
||
return false;
|
||
|
||
if (ParseProvides(Ver) == false)
|
||
return false;
|
||
if (not APT::KernelAutoRemoveHelper::getUname(Ver.ParentPkg().Name()).empty())
|
||
{
|
||
if (not NewProvides(Ver, "$kernel", "any", Ver.VerStr(), pkgCache::Flag::MultiArchImplicit))
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
/*}}}*/
|
||
// ListParser::AvailableDescriptionLanguages /*{{{*/
|
||
std::vector<std::string> debListParser::AvailableDescriptionLanguages()
|
||
{
|
||
std::vector<std::string> avail;
|
||
static constexpr int prefixLen = 12;
|
||
char buf[32] = "Description-";
|
||
if (Section.Exists(pkgTagSection::Key::Description))
|
||
avail.emplace_back();
|
||
for (auto const &lang : APT::Configuration::getLanguages(true))
|
||
{
|
||
if (unlikely(lang.size() > sizeof(buf) - prefixLen)) {
|
||
_error->Warning("Ignoring translated description %s", lang.c_str());
|
||
continue;
|
||
}
|
||
memcpy(buf + prefixLen, lang.c_str(), lang.size());
|
||
if (Section.Exists(string_view(buf, prefixLen + lang.size())) == true)
|
||
avail.push_back(lang);
|
||
}
|
||
return avail;
|
||
}
|
||
/*}}}*/
|
||
// ListParser::Description_md5 - Return the description_md5 MD5SumValue /*{{{*/
|
||
// ---------------------------------------------------------------------
|
||
/* This is to return the md5 string to allow the check if it is the right
|
||
description. If no Description-md5 is found in the section it will be
|
||
calculated.
|
||
*/
|
||
std::string_view debListParser::Description_md5()
|
||
{
|
||
return Section.Find(pkgTagSection::Key::Description_md5);
|
||
}
|
||
/*}}}*/
|
||
// ListParser::UsePackage - Update a package structure /*{{{*/
|
||
// ---------------------------------------------------------------------
|
||
/* This is called to update the package with any new information
|
||
that might be found in the section */
|
||
bool debListParser::UsePackage(pkgCache::PkgIterator &Pkg,
|
||
pkgCache::VerIterator &Ver)
|
||
{
|
||
string const static myArch = _config->Find("APT::Architecture");
|
||
// Possible values are: "all", "native", "installed" and "none"
|
||
// The "installed" mode is handled by ParseStatus(), See #544481 and friends.
|
||
string const static essential = _config->Find("pkgCacheGen::Essential", "all");
|
||
if (essential == "all" ||
|
||
(essential == "native" && Pkg->Arch != 0 && myArch == Pkg.Arch()))
|
||
if (Section.FindFlag(pkgTagSection::Key::Essential,Pkg->Flags,pkgCache::Flag::Essential) == false)
|
||
return false;
|
||
if (Section.FindFlag(pkgTagSection::Key::Important,Pkg->Flags,pkgCache::Flag::Important) == false)
|
||
return false;
|
||
if (Section.FindFlag(pkgTagSection::Key::Protected, Pkg->Flags, pkgCache::Flag::Important) == false)
|
||
return false;
|
||
|
||
if (std::find(forceEssential.begin(), forceEssential.end(), Pkg.Name()) != forceEssential.end())
|
||
{
|
||
if ((essential == "native" && Pkg->Arch != 0 && myArch == Pkg.Arch()) ||
|
||
essential == "all")
|
||
Pkg->Flags |= pkgCache::Flag::Essential | pkgCache::Flag::Important;
|
||
else
|
||
Pkg->Flags |= pkgCache::Flag::Important;
|
||
}
|
||
else if (std::find(forceImportant.begin(), forceImportant.end(), Pkg.Name()) != forceImportant.end())
|
||
Pkg->Flags |= pkgCache::Flag::Important;
|
||
|
||
auto phased = Section.FindULL(pkgTagSection::Key::Phased_Update_Percentage, 100);
|
||
if (phased != 100)
|
||
{
|
||
if (not Ver.PhasedUpdatePercentage(phased))
|
||
_error->Warning("Ignoring invalid Phased-Update-Percentage value");
|
||
}
|
||
|
||
if (ParseStatus(Pkg,Ver) == false)
|
||
return false;
|
||
return true;
|
||
}
|
||
/*}}}*/
|
||
// ListParser::VersionHash - Compute a unique hash for this version /*{{{*/
|
||
// ---------------------------------------------------------------------
|
||
/* */
|
||
uint32_t debListParser::VersionHash()
|
||
{
|
||
static constexpr pkgTagSection::Key Sections[] ={
|
||
pkgTagSection::Key::Installed_Size,
|
||
pkgTagSection::Key::Depends,
|
||
pkgTagSection::Key::Pre_Depends,
|
||
// pkgTagSection::Key::Suggests,
|
||
// pkgTagSection::Key::Recommends",
|
||
pkgTagSection::Key::Conflicts,
|
||
pkgTagSection::Key::Breaks,
|
||
pkgTagSection::Key::Replaces};
|
||
unsigned long Result = 5381;
|
||
for (auto I : Sections)
|
||
{
|
||
const char *Start;
|
||
const char *End;
|
||
if (Section.Find(I,Start,End) == false)
|
||
continue;
|
||
|
||
/* Strip out any spaces from the text, this undoes dpkgs reformatting
|
||
of certain fields. dpkg also has the rather interesting notion of
|
||
reformatting depends operators < -> <=, so we drop all = from the
|
||
string to make that not matter. */
|
||
for (; Start != End; ++Start)
|
||
{
|
||
// Strip away 0: epochs from input
|
||
if (*Start == '0' && Start[1] == ':') {
|
||
Start++; // Skip the :
|
||
continue; // Skip the 0
|
||
}
|
||
if (isspace_ascii(*Start) != 0 || *Start == '=')
|
||
continue;
|
||
Result = 33 * Result + tolower_ascii_unsafe(*Start);
|
||
}
|
||
|
||
|
||
}
|
||
|
||
return Result;
|
||
}
|
||
/*}}}*/
|
||
// StatusListParser::ParseStatus - Parse the status field /*{{{*/
|
||
// ---------------------------------------------------------------------
|
||
/* Status lines are of the form,
|
||
Status: want flag status
|
||
want = unknown, install, hold, deinstall, purge
|
||
flag = ok, reinstreq
|
||
status = not-installed, config-files, half-installed, unpacked,
|
||
half-configured, triggers-awaited, triggers-pending, installed
|
||
*/
|
||
bool debListParser::ParseStatus(pkgCache::PkgIterator &,
|
||
pkgCache::VerIterator &Ver)
|
||
{
|
||
// the status file has no info about the download size and
|
||
// usually this is fine as we will have picked that info up already –
|
||
// except if we have volatile sources which are parsed after the status file.
|
||
if (Ver->Size == 0)
|
||
Ver->Size = Section.FindULL(pkgTagSection::Key::Size);
|
||
return true;
|
||
}
|
||
bool debStatusListParser::ParseStatus(pkgCache::PkgIterator &Pkg,
|
||
pkgCache::VerIterator &Ver)
|
||
{
|
||
const char *Start;
|
||
const char *Stop;
|
||
if (Section.Find(pkgTagSection::Key::Status,Start,Stop) == false)
|
||
return true;
|
||
|
||
// UsePackage() is responsible for setting the flag in the default case
|
||
bool const static essential = _config->Find("pkgCacheGen::Essential", "") == "installed";
|
||
if (essential == true &&
|
||
Section.FindFlag(pkgTagSection::Key::Essential,Pkg->Flags,pkgCache::Flag::Essential) == false)
|
||
return false;
|
||
|
||
// Isolate the first word
|
||
const char *I = Start;
|
||
for(; I < Stop && *I != ' '; I++);
|
||
if (I >= Stop || *I != ' ')
|
||
return _error->Error("Malformed Status line");
|
||
|
||
// Process the want field
|
||
WordList WantList[] = {{"unknown",pkgCache::State::Unknown},
|
||
{"install",pkgCache::State::Install},
|
||
{"hold",pkgCache::State::Hold},
|
||
{"deinstall",pkgCache::State::DeInstall},
|
||
{"purge",pkgCache::State::Purge},
|
||
{"", 0}};
|
||
if (GrabWord(string_view(Start,I-Start),WantList,Pkg->SelectedState) == false)
|
||
return _error->Error("Malformed 1st word in the Status line");
|
||
|
||
// Isloate the next word
|
||
I++;
|
||
Start = I;
|
||
for(; I < Stop && *I != ' '; I++);
|
||
if (I >= Stop || *I != ' ')
|
||
return _error->Error("Malformed status line, no 2nd word");
|
||
|
||
// Process the flag field
|
||
WordList FlagList[] = {{"ok",pkgCache::State::Ok},
|
||
{"reinstreq",pkgCache::State::ReInstReq},
|
||
{"hold",pkgCache::State::HoldInst},
|
||
{"hold-reinstreq",pkgCache::State::HoldReInstReq},
|
||
{"", 0}};
|
||
if (GrabWord(string_view(Start,I-Start),FlagList,Pkg->InstState) == false)
|
||
return _error->Error("Malformed 2nd word in the Status line");
|
||
|
||
// Isloate the last word
|
||
I++;
|
||
Start = I;
|
||
for(; I < Stop && *I != ' '; I++);
|
||
if (I != Stop)
|
||
return _error->Error("Malformed Status line, no 3rd word");
|
||
|
||
// Process the flag field
|
||
WordList StatusList[] = {{"not-installed",pkgCache::State::NotInstalled},
|
||
{"config-files",pkgCache::State::ConfigFiles},
|
||
{"half-installed",pkgCache::State::HalfInstalled},
|
||
{"unpacked",pkgCache::State::UnPacked},
|
||
{"half-configured",pkgCache::State::HalfConfigured},
|
||
{"triggers-awaited",pkgCache::State::TriggersAwaited},
|
||
{"triggers-pending",pkgCache::State::TriggersPending},
|
||
{"installed",pkgCache::State::Installed},
|
||
{"", 0}};
|
||
if (GrabWord(string_view(Start,I-Start),StatusList,Pkg->CurrentState) == false)
|
||
return _error->Error("Malformed 3rd word in the Status line");
|
||
|
||
/* A Status line marks the package as indicating the current
|
||
version as well. Only if it is actually installed.. Otherwise
|
||
the interesting dpkg handling of the status file creates bogus
|
||
entries. */
|
||
if (!(Pkg->CurrentState == pkgCache::State::NotInstalled ||
|
||
Pkg->CurrentState == pkgCache::State::ConfigFiles))
|
||
{
|
||
if (Ver.end() == true)
|
||
_error->Warning("Encountered status field in a non-version description");
|
||
else
|
||
Pkg->CurrentVer = Ver.MapPointer();
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
const char *debListParser::ConvertRelation(const char *I,unsigned int &Op)
|
||
{
|
||
// Determine the operator
|
||
switch (*I)
|
||
{
|
||
case '<':
|
||
I++;
|
||
if (*I == '=')
|
||
{
|
||
I++;
|
||
Op = pkgCache::Dep::LessEq;
|
||
break;
|
||
}
|
||
|
||
if (*I == '<')
|
||
{
|
||
I++;
|
||
Op = pkgCache::Dep::Less;
|
||
break;
|
||
}
|
||
|
||
// < is the same as <= and << is really Cs < for some reason
|
||
Op = pkgCache::Dep::LessEq;
|
||
break;
|
||
|
||
case '>':
|
||
I++;
|
||
if (*I == '=')
|
||
{
|
||
I++;
|
||
Op = pkgCache::Dep::GreaterEq;
|
||
break;
|
||
}
|
||
|
||
if (*I == '>')
|
||
{
|
||
I++;
|
||
Op = pkgCache::Dep::Greater;
|
||
break;
|
||
}
|
||
|
||
// > is the same as >= and >> is really Cs > for some reason
|
||
Op = pkgCache::Dep::GreaterEq;
|
||
break;
|
||
|
||
case '=':
|
||
Op = pkgCache::Dep::Equals;
|
||
I++;
|
||
break;
|
||
|
||
// != is unsupported packaging
|
||
case '!':
|
||
if (*(I + 1) == '=')
|
||
{
|
||
I = I + 2;
|
||
Op = pkgCache::Dep::NotEquals;
|
||
break;
|
||
}
|
||
[[fallthrough]];
|
||
|
||
// HACK around bad package definitions
|
||
default:
|
||
Op = pkgCache::Dep::Equals;
|
||
break;
|
||
}
|
||
return I;
|
||
}
|
||
/*}}}*/
|
||
// ListParser::ParseDepends - Parse a dependency element /*{{{*/
|
||
// ---------------------------------------------------------------------
|
||
/* This parses the dependency elements out of a standard string in place,
|
||
bit by bit. */
|
||
const char *debListParser::ParseDepends(const char *Start,const char *Stop,
|
||
string &Package,string &Ver,
|
||
unsigned int &Op, bool const &ParseArchFlags,
|
||
bool const &StripMultiArch,
|
||
bool const &ParseRestrictionsList,
|
||
string const &Arch)
|
||
{
|
||
string_view PackageView;
|
||
string_view VerView;
|
||
|
||
auto res = ParseDepends(Start, Stop, PackageView, VerView, Op, (bool)ParseArchFlags,
|
||
(bool) StripMultiArch, (bool) ParseRestrictionsList, Arch);
|
||
Package = PackageView;
|
||
Ver = VerView;
|
||
|
||
return res;
|
||
}
|
||
|
||
const char *debListParser::ParseDepends(const char *Start, const char *Stop,
|
||
string_view &Package, string_view &Ver,
|
||
unsigned int &Op, bool ParseArchFlags,
|
||
bool StripMultiArch,
|
||
bool ParseRestrictionsList, string Arch)
|
||
{
|
||
if (Arch.empty())
|
||
Arch = _config->Find("APT::Architecture");
|
||
// Strip off leading space
|
||
for (;Start != Stop && isspace_ascii(*Start) != 0; ++Start);
|
||
|
||
// Parse off the package name
|
||
const char *I = Start;
|
||
for (;I != Stop && isspace_ascii(*I) == 0 && *I != '(' && *I != ')' &&
|
||
*I != ',' && *I != '|' && *I != '[' && *I != ']' &&
|
||
*I != '<' && *I != '>'; ++I);
|
||
|
||
// Malformed, no '('
|
||
if (I != Stop && *I == ')')
|
||
return 0;
|
||
|
||
if (I == Start)
|
||
return 0;
|
||
|
||
// Stash the package name
|
||
Package = string_view(Start, I - Start);
|
||
|
||
// We don't want to confuse library users which can't handle MultiArch
|
||
if (StripMultiArch == true) {
|
||
size_t const found = Package.rfind(':');
|
||
if (found != string_view::npos &&
|
||
(Package.substr(found) == ":any" ||
|
||
Package.substr(found) == ":native" ||
|
||
Package.substr(found +1) == Arch))
|
||
Package = Package.substr(0,found);
|
||
}
|
||
|
||
// Skip white space to the '('
|
||
for (;I != Stop && isspace_ascii(*I) != 0 ; I++);
|
||
|
||
// Parse a version
|
||
if (I != Stop && *I == '(')
|
||
{
|
||
// Skip the '('
|
||
for (I++; I != Stop && isspace_ascii(*I) != 0 ; I++);
|
||
if (I + 3 > Stop)
|
||
return 0;
|
||
I = ConvertRelation(I,Op);
|
||
|
||
// Skip whitespace
|
||
for (;I != Stop && isspace_ascii(*I) != 0; I++);
|
||
Start = I;
|
||
I = (const char*) memchr(I, ')', Stop - I);
|
||
if (I == NULL || Start == I)
|
||
return 0;
|
||
|
||
// Skip trailing whitespace
|
||
const char *End = I;
|
||
for (; End > Start && isspace_ascii(End[-1]); End--);
|
||
|
||
Ver = string_view(Start,End-Start);
|
||
I++;
|
||
}
|
||
else
|
||
{
|
||
Ver = string_view();
|
||
Op = pkgCache::Dep::NoOp;
|
||
}
|
||
|
||
// Skip whitespace
|
||
for (;I != Stop && isspace_ascii(*I) != 0; I++);
|
||
|
||
// Parse architecture restrictions
|
||
if (ParseArchFlags && I != Stop && *I == '[')
|
||
{
|
||
for (++I; I != Stop && isspace_ascii(*I) != 0 && *I != ']'; ++I);
|
||
// malformed
|
||
if (unlikely(I == Stop || *I == ']'))
|
||
return 0;
|
||
|
||
APT::CacheFilter::PackageArchitectureMatchesSpecification matchesArch(Arch, false);
|
||
|
||
bool Found = false;
|
||
bool NegArch = false;
|
||
while (I < Stop && *I != ']')
|
||
{
|
||
// look for whitespace or ending ']' to end current Arch
|
||
const char *End = I;
|
||
for (;End < Stop && isspace_ascii(*End) == 0 && *End != ']'; ++End);
|
||
|
||
if (unlikely(End >= Stop))
|
||
return 0;
|
||
|
||
bool CurNegArch = false;
|
||
if (*I == '!')
|
||
{
|
||
NegArch = true;
|
||
CurNegArch = true;
|
||
++I;
|
||
}
|
||
|
||
if (I >= End)
|
||
return 0;
|
||
std::string const arch(I, End);
|
||
if (matchesArch(arch.c_str()))
|
||
{
|
||
Found = true;
|
||
if (not CurNegArch)
|
||
NegArch = false;
|
||
// we found a match, so fast-forward to the end of the wildcards
|
||
for (; End < Stop && *End != ']'; ++End);
|
||
}
|
||
else
|
||
for (; End < Stop && isspace_ascii(*End) != 0; ++End);
|
||
|
||
I = End;
|
||
}
|
||
|
||
if (NegArch == true)
|
||
Found = not Found;
|
||
|
||
if (Found == false)
|
||
Package = ""; /* not for this arch */
|
||
|
||
// Skip whitespace
|
||
for (++I; I < Stop && isspace_ascii(*I) != 0; ++I);
|
||
}
|
||
|
||
if (unlikely(ParseRestrictionsList == true))
|
||
{
|
||
// Parse a restrictions formula which is in disjunctive normal form:
|
||
// (foo AND bar) OR (blub AND bla)
|
||
|
||
std::vector<string> const profiles = APT::Configuration::getBuildProfiles();
|
||
|
||
// if the next character is a restriction list, then by default the
|
||
// dependency does not apply and the conditions have to be checked
|
||
// if the next character is not a restriction list, then by default the
|
||
// dependency applies
|
||
bool applies1 = (*I != '<');
|
||
while (I != Stop)
|
||
{
|
||
if (*I != '<')
|
||
break;
|
||
|
||
++I;
|
||
// malformed
|
||
if (unlikely(I == Stop))
|
||
return 0;
|
||
|
||
const char *End = I;
|
||
|
||
// if of the prior restriction list is already fulfilled, then
|
||
// we can just skip to the end of the current list
|
||
if (applies1) {
|
||
for (;End != Stop && *End != '>'; ++End);
|
||
I = ++End;
|
||
// skip whitespace
|
||
for (;I != Stop && isspace_ascii(*I) != 0; I++);
|
||
} else {
|
||
bool applies2 = true;
|
||
// all the conditions inside a restriction list have to be
|
||
// met so once we find one that is not met, we can skip to
|
||
// the end of this list
|
||
while (I != Stop)
|
||
{
|
||
// look for whitespace or ending '>'
|
||
// End now points to the character after the current term
|
||
for (;End != Stop && !isspace_ascii(*End) && *End != '>'; ++End);
|
||
|
||
if (unlikely(End == Stop))
|
||
return 0;
|
||
|
||
bool NegRestriction = false;
|
||
if (*I == '!')
|
||
{
|
||
NegRestriction = true;
|
||
++I;
|
||
}
|
||
|
||
std::string const restriction(I, End);
|
||
if (restriction.empty() == false && profiles.empty() == false &&
|
||
std::find(profiles.begin(), profiles.end(), restriction) != profiles.end())
|
||
{
|
||
if (NegRestriction) {
|
||
applies2 = false;
|
||
// since one of the terms does not apply we don't have to check the others
|
||
for (; End != Stop && *End != '>'; ++End);
|
||
}
|
||
} else {
|
||
if (!NegRestriction) {
|
||
applies2 = false;
|
||
// since one of the terms does not apply we don't have to check the others
|
||
for (; End != Stop && *End != '>'; ++End);
|
||
}
|
||
}
|
||
|
||
if (*End++ == '>') {
|
||
I = End;
|
||
// skip whitespace
|
||
for (;I != Stop && isspace_ascii(*I) != 0; I++);
|
||
break;
|
||
}
|
||
|
||
I = End;
|
||
// skip whitespace
|
||
for (;I != Stop && isspace_ascii(*I) != 0; I++);
|
||
}
|
||
if (applies2) {
|
||
applies1 = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (applies1 == false) {
|
||
Package = ""; //not for this restriction
|
||
}
|
||
}
|
||
|
||
if (I != Stop && *I == '|')
|
||
Op |= pkgCache::Dep::Or;
|
||
|
||
if (I == Stop || *I == ',' || *I == '|')
|
||
{
|
||
if (I != Stop)
|
||
for (I++; I != Stop && isspace_ascii(*I) != 0; I++);
|
||
return I;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
/*}}}*/
|
||
// ListParser::ParseDepends - Parse a dependency list /*{{{*/
|
||
// ---------------------------------------------------------------------
|
||
/* This is the higher level depends parser. It takes a tag and generates
|
||
a complete depends tree for the given version. */
|
||
bool debListParser::ParseDepends(pkgCache::VerIterator &Ver,
|
||
pkgTagSection::Key Key,unsigned int Type)
|
||
{
|
||
const char *Start;
|
||
const char *Stop;
|
||
if (Section.Find(Key,Start,Stop) == false || Start == Stop)
|
||
return true;
|
||
|
||
string const pkgArch = Ver.Arch();
|
||
bool const barbarianArch = not APT::Configuration::checkArchitecture(pkgArch);
|
||
|
||
while (1)
|
||
{
|
||
string_view Package;
|
||
string_view Version;
|
||
unsigned int Op;
|
||
|
||
Start = ParseDepends(Start, Stop, Package, Version, Op, false, false, false, myArch);
|
||
if (Start == 0)
|
||
return _error->Error("Problem parsing dependency %zu of %s:%s=%s", static_cast<size_t>(Key), // TODO
|
||
Ver.ParentPkg().Name(), Ver.Arch(), Ver.VerStr());
|
||
size_t const found = Package.rfind(':');
|
||
|
||
if (found == string::npos)
|
||
{
|
||
if (NewDepends(Ver,Package,pkgArch,Version,Op,Type) == false)
|
||
return false;
|
||
}
|
||
else if (Package.substr(found) == ":any")
|
||
{
|
||
if (barbarianArch)
|
||
{
|
||
if (not NewDepends(Ver, Package, "any", Version, Op | pkgCache::Dep::Or, Type))
|
||
return false;
|
||
if (not NewDepends(Ver, Package.substr(0, found), pkgArch, Version, Op, Type))
|
||
return false;
|
||
}
|
||
else if (not NewDepends(Ver, Package, "any", Version, Op, Type))
|
||
return false;
|
||
}
|
||
else
|
||
{
|
||
// Such dependencies are not supposed to be accepted …
|
||
// … but this is probably the best thing to do anyway
|
||
if (Package.substr(found + 1) == "native")
|
||
{
|
||
std::string const Pkg = std::string{Package, 0, found}.append(":").append(Ver.Cache()->NativeArch());
|
||
if (NewDepends(Ver, Pkg, "any", Version, Op | pkgCache::Dep::ArchSpecific, Type) == false)
|
||
return false;
|
||
}
|
||
else if (NewDepends(Ver, Package, "any", Version, Op | pkgCache::Dep::ArchSpecific, Type) == false)
|
||
return false;
|
||
}
|
||
|
||
if (Start == Stop)
|
||
break;
|
||
}
|
||
return true;
|
||
}
|
||
/*}}}*/
|
||
// ListParser::ParseProvides - Parse the provides list /*{{{*/
|
||
// ---------------------------------------------------------------------
|
||
/* */
|
||
bool debListParser::ParseProvides(pkgCache::VerIterator &Ver)
|
||
{
|
||
/* it is unlikely, but while parsing dependencies, we might have already
|
||
picked up multi-arch implicit provides which we do not want to duplicate here */
|
||
bool hasProvidesAlready = false;
|
||
std::string const spzName = Ver.ParentPkg().FullName(false);
|
||
{
|
||
for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
|
||
{
|
||
if (Prv.IsMultiArchImplicit() == false || (Prv->Flags & pkgCache::Flag::ArchSpecific) == 0)
|
||
continue;
|
||
if (spzName != Prv.OwnerPkg().FullName(false))
|
||
continue;
|
||
hasProvidesAlready = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
string const Arch = Ver.Arch();
|
||
bool const barbarianArch = not APT::Configuration::checkArchitecture(Arch);
|
||
const char *Start;
|
||
const char *Stop;
|
||
if (Section.Find(pkgTagSection::Key::Provides,Start,Stop) && Start != Stop)
|
||
{
|
||
string_view Package;
|
||
string_view Version;
|
||
unsigned int Op;
|
||
|
||
do
|
||
{
|
||
Start = ParseDepends(Start,Stop,Package,Version,Op, false, false, false);
|
||
const size_t archfound = Package.rfind(':');
|
||
if (Start == 0)
|
||
return _error->Error("Problem parsing Provides line of %s:%s=%s", Ver.ParentPkg().Name(), Ver.Arch(), Ver.VerStr());
|
||
if (unlikely(Op != pkgCache::Dep::NoOp && Op != pkgCache::Dep::Equals)) {
|
||
_error->Warning("Ignoring non-equal Provides for package %.*s in %s:%s=%s", (int)Package.size(), Package.data(), Ver.ParentPkg().Name(), Ver.Arch(), Ver.VerStr());
|
||
} else if (archfound != string::npos) {
|
||
string_view spzArch = Package.substr(archfound + 1);
|
||
if (spzArch != "any")
|
||
{
|
||
if (NewProvides(Ver, Package.substr(0, archfound), spzArch, Version, pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false)
|
||
return false;
|
||
}
|
||
if (NewProvides(Ver, Package, "any", Version, pkgCache::Flag::ArchSpecific) == false)
|
||
return false;
|
||
} else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign) {
|
||
if (not barbarianArch)
|
||
{
|
||
if (NewProvidesAllArch(Ver, Package, Version, 0) == false)
|
||
return false;
|
||
}
|
||
else if (NewProvides(Ver, Package, Arch, Version, 0) == false)
|
||
return false;
|
||
} else {
|
||
if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed && not barbarianArch)
|
||
{
|
||
if (NewProvides(Ver, std::string{Package}.append(":any"), "any", Version, pkgCache::Flag::MultiArchImplicit) == false)
|
||
return false;
|
||
}
|
||
if (NewProvides(Ver, Package, Arch, Version, 0) == false)
|
||
return false;
|
||
}
|
||
if (archfound == std::string::npos)
|
||
{
|
||
string spzName{Package};
|
||
spzName.push_back(':');
|
||
spzName.append(Ver.ParentPkg().Arch());
|
||
pkgCache::PkgIterator const spzPkg = Ver.Cache()->FindPkg(spzName, "any");
|
||
if (spzPkg.end() == false)
|
||
{
|
||
if (NewProvides(Ver, spzName, "any", Version, pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false)
|
||
return false;
|
||
}
|
||
}
|
||
} while (Start != Stop);
|
||
}
|
||
|
||
if (not barbarianArch)
|
||
{
|
||
if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
|
||
{
|
||
string const Package = string(Ver.ParentPkg().Name()).append(":").append("any");
|
||
if (NewProvides(Ver, Package, "any", Ver.VerStr(), pkgCache::Flag::MultiArchImplicit) == false)
|
||
return false;
|
||
}
|
||
else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
|
||
{
|
||
if (NewProvidesAllArch(Ver, Ver.ParentPkg().Name(), Ver.VerStr(), pkgCache::Flag::MultiArchImplicit) == false)
|
||
return false;
|
||
}
|
||
}
|
||
|
||
if (hasProvidesAlready == false)
|
||
{
|
||
pkgCache::PkgIterator const spzPkg = Ver.Cache()->FindPkg(spzName, "any");
|
||
if (spzPkg.end() == false)
|
||
{
|
||
if (NewProvides(Ver, spzName, "any", Ver.VerStr(), pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific) == false)
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
/*}}}*/
|
||
// ListParser::GrabWord - Matches a word and returns /*{{{*/
|
||
// ---------------------------------------------------------------------
|
||
/* Looks for a word in a list of words - for ParseStatus */
|
||
bool debListParser::GrabWord(string_view Word, WordList const *List, unsigned char &Out)
|
||
{
|
||
for (unsigned int C = 0; List[C].Str.empty() == false; C++)
|
||
{
|
||
if (Word.length() == List[C].Str.length() &&
|
||
strncasecmp(Word.data(), List[C].Str.data(), Word.length()) == 0)
|
||
{
|
||
Out = List[C].Val;
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
/*}}}*/
|
||
// ListParser::Step - Move to the next section in the file /*{{{*/
|
||
// ---------------------------------------------------------------------
|
||
/* This has to be careful to only process the correct architecture */
|
||
bool debListParser::Step()
|
||
{
|
||
iOffset = Tags.Offset();
|
||
return Tags.Step(Section);
|
||
}
|
||
/*}}}*/
|
||
// ListParser::GetPrio - Convert the priority from a string /*{{{*/
|
||
// ---------------------------------------------------------------------
|
||
/* */
|
||
unsigned char debListParser::GetPrio(string Str)
|
||
{
|
||
unsigned char Out;
|
||
if (GrabWord(Str,PrioList,Out) == false)
|
||
Out = pkgCache::State::Extra;
|
||
|
||
return Out;
|
||
}
|
||
/*}}}*/
|
||
bool debListParser::SameVersion(uint32_t Hash, /*{{{*/
|
||
pkgCache::VerIterator const &Ver)
|
||
{
|
||
if (pkgCacheListParser::SameVersion(Hash, Ver) == false)
|
||
return false;
|
||
// status file has no (Download)Size, but all others are fair game
|
||
// status file is parsed last, so the first version we encounter is
|
||
// probably also the version we have downloaded
|
||
unsigned long long const Size = Section.FindULL(pkgTagSection::Key::Size);
|
||
if (Size != 0 && Ver->Size != 0 && Size != Ver->Size)
|
||
return false;
|
||
// available everywhere, but easier to check here than to include in VersionHash
|
||
unsigned char MultiArch = ParseMultiArch(false);
|
||
if (MultiArch != Ver->MultiArch)
|
||
return false;
|
||
// for all practical proposes (we can check): same version
|
||
return true;
|
||
}
|
||
/*}}}*/
|
||
|
||
debDebFileParser::debDebFileParser(FileFd *File, std::string const &DebFile)
|
||
: debListParser(File), DebFile(DebFile)
|
||
{
|
||
}
|
||
|
||
bool debDebFileParser::UsePackage(pkgCache::PkgIterator &Pkg,
|
||
pkgCache::VerIterator &Ver)
|
||
{
|
||
if (not debListParser::UsePackage(Pkg, Ver))
|
||
return false;
|
||
// we use the full file path as a provides so that the file is found by its name
|
||
// using the MultiArchImplicit flag for this is a bit of a stretch
|
||
return NewProvides(Ver, DebFile, Pkg.Cache()->NativeArch(), Ver.VerStr(), pkgCache::Flag::MultiArchImplicit | pkgCache::Flag::ArchSpecific);
|
||
}
|
||
|
||
debListParser::~debListParser() {}
|