#include <apt-pkg/edsp.h>
#include <apt-pkg/tagfile.h>
#include <apt-pkg/strutl.h>
+#include <apt-pkg/string_view.h>
+#include <apt-pkg/pkgsystem.h>
+#include <sys/stat.h>
#include <ctype.h>
#include <stddef.h>
#include <string.h>
if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
fprintf(output, "APT-Automatic: yes\n");
}
-static bool WriteScenarioVersion(pkgDepCache &Cache, FileFd &output, pkgCache::PkgIterator const &Pkg,
+static bool WriteScenarioVersion(FileFd &output, pkgCache::PkgIterator const &Pkg,
pkgCache::VerIterator const &Ver)
{
bool Okay = WriteOkay(output, "Package: ", Pkg.Name(),
- "\nSource: ", Ver.SourcePkgName(),
"\nArchitecture: ", Ver.Arch(),
- "\nVersion: ", Ver.VerStr(),
- "\nSource-Version: ", Ver.SourceVerStr());
- if (Pkg.CurrentVer() == Ver)
- WriteOkay(Okay, output, "\nInstalled: yes");
- if (Pkg->SelectedState == pkgCache::State::Hold ||
- (Cache[Pkg].Keep() == true && Cache[Pkg].Protect() == true))
- WriteOkay(Okay, output, "\nHold: yes");
+ "\nVersion: ", Ver.VerStr());
WriteOkay(Okay, output, "\nAPT-ID: ", Ver->ID);
- if (PrioMap[Ver->Priority] != nullptr)
- WriteOkay(Okay, output, "\nPriority: ", PrioMap[Ver->Priority]);
if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
WriteOkay(Okay, output, "\nEssential: yes");
- if (Ver->Section != 0)
- WriteOkay(Okay, output, "\nSection: ", Ver.Section());
if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
WriteOkay(Okay, output, "\nMulti-Arch: allowed");
else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
WriteOkay(Okay, output, "\nMulti-Arch: foreign");
else if ((Ver->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
WriteOkay(Okay, output, "\nMulti-Arch: same");
- std::set<string> Releases;
- for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; ++I) {
- pkgCache::PkgFileIterator File = I.File();
- if (File.Flagged(pkgCache::Flag::NotSource) == false) {
- string Release = File.RelStr();
- if (!Release.empty())
- Releases.insert(Release);
- }
- }
- if (!Releases.empty()) {
- WriteOkay(Okay, output, "\nAPT-Release:");
- for (std::set<string>::iterator R = Releases.begin(); R != Releases.end(); ++R)
- WriteOkay(Okay, output, "\n ", *R);
- }
- WriteOkay(Okay, output, "\nAPT-Pin: ", Cache.GetPolicy().GetPriority(Ver));
- if (Cache.GetCandidateVersion(Pkg) == Ver)
- WriteOkay(Okay, output, "\nAPT-Candidate: yes");
- if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
- WriteOkay(Okay, output, "\nAPT-Automatic: yes");
return Okay;
}
/*}}}*/
if (provides.empty() == false)
fprintf(output, "Provides: %s\n", provides.c_str());
}
-static bool WriteScenarioDependency(FileFd &output, pkgCache::VerIterator const &Ver)
+static bool WriteScenarioDependency(FileFd &output, pkgCache::VerIterator const &Ver, bool const OnlyCritical)
{
std::array<std::string, _count(DepMap)> dependencies;
bool orGroup = false;
{
if (Dep.IsImplicit() == true)
continue;
+ if (OnlyCritical && Dep.IsCritical() == false)
+ continue;
if (orGroup == false && dependencies[Dep->Type].empty() == false)
dependencies[Dep->Type].append(", ");
dependencies[Dep->Type].append(Dep.TargetPkg().Name());
}
static bool WriteScenarioLimitedDependency(FileFd &output,
pkgCache::VerIterator const &Ver,
- std::vector<bool> const &pkgset)
+ std::vector<bool> const &pkgset,
+ bool const OnlyCritical)
{
std::array<std::string, _count(DepMap)> dependencies;
bool orGroup = false;
{
if (Dep.IsImplicit() == true)
continue;
+ if (OnlyCritical && Dep.IsCritical() == false)
+ continue;
if (orGroup == false)
{
if (pkgset[Dep.TargetPkg()->ID] == false)
return true;
}
/*}}}*/
+static bool WriteScenarioEDSPVersion(pkgDepCache &Cache, FileFd &output, pkgCache::PkgIterator const &Pkg,/*{{{*/
+ pkgCache::VerIterator const &Ver)
+{
+ bool Okay = WriteOkay(output, "\nSource: ", Ver.SourcePkgName(),
+ "\nSource-Version: ", Ver.SourceVerStr());
+ if (PrioMap[Ver->Priority] != nullptr)
+ WriteOkay(Okay, output, "\nPriority: ", PrioMap[Ver->Priority]);
+ if (Ver->Section != 0)
+ WriteOkay(Okay, output, "\nSection: ", Ver.Section());
+ if (Pkg.CurrentVer() == Ver)
+ WriteOkay(Okay, output, "\nInstalled: yes");
+ if (Pkg->SelectedState == pkgCache::State::Hold ||
+ (Cache[Pkg].Keep() == true && Cache[Pkg].Protect() == true))
+ WriteOkay(Okay, output, "\nHold: yes");
+ std::set<string> Releases;
+ for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; ++I) {
+ pkgCache::PkgFileIterator File = I.File();
+ if (File.Flagged(pkgCache::Flag::NotSource) == false) {
+ string Release = File.RelStr();
+ if (!Release.empty())
+ Releases.insert(Release);
+ }
+ }
+ if (!Releases.empty()) {
+ WriteOkay(Okay, output, "\nAPT-Release:");
+ for (std::set<string>::iterator R = Releases.begin(); R != Releases.end(); ++R)
+ WriteOkay(Okay, output, "\n ", *R);
+ }
+ WriteOkay(Okay, output, "\nAPT-Pin: ", Cache.GetPolicy().GetPriority(Ver));
+ if (Cache.GetCandidateVersion(Pkg) == Ver)
+ WriteOkay(Okay, output, "\nAPT-Candidate: yes");
+ if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
+ WriteOkay(Okay, output, "\nAPT-Automatic: yes");
+ return Okay;
+}
+ /*}}}*/
// EDSP::WriteScenario - to the given file descriptor /*{{{*/
bool EDSP::WriteScenario(pkgDepCache &Cache, FILE* output, OpProgress *Progress)
{
{
if (SkipUnavailableVersions(Cache, Pkg, Ver))
continue;
- Okay &= WriteScenarioVersion(Cache, output, Pkg, Ver);
- Okay &= WriteScenarioDependency(output, Ver);
+ Okay &= WriteScenarioVersion(output, Pkg, Ver);
+ Okay &= WriteScenarioEDSPVersion(Cache, output, Pkg, Ver);
+ Okay &= WriteScenarioDependency(output, Ver, false);
WriteOkay(Okay, output, "\n");
if (Progress != NULL && p % 100 == 0)
Progress->Progress(p);
{
if (SkipUnavailableVersions(Cache, Pkg, Ver))
continue;
- Okay &= WriteScenarioVersion(Cache, output, Pkg, Ver);
- Okay &= WriteScenarioLimitedDependency(output, Ver, pkgset);
+ Okay &= WriteScenarioVersion(output, Pkg, Ver);
+ Okay &= WriteScenarioEDSPVersion(Cache, output, Pkg, Ver);
+ Okay &= WriteScenarioLimitedDependency(output, Ver, pkgset, false);
WriteOkay(Okay, output, "\n");
if (Progress != NULL && p % 100 == 0)
Progress->Progress(p);
WriteOkay(Okay, output, "Forbid-New-Install: yes\n");
if (flags & Request::FORBID_REMOVE)
WriteOkay(Okay, output, "Forbid-Remove: yes\n");
+ auto const solver = _config->Find("APT::Solver", "internal");
+ WriteOkay(Okay, output, "Solver: ", solver, "\n");
if (_config->FindB("APT::Solver::Strict-Pinning", true) == false)
WriteOkay(Okay, output, "Strict-Pinning: no\n");
string solverpref("APT::Solver::");
- solverpref.append(_config->Find("APT::Solver", "internal")).append("::Preferences");
+ solverpref.append(solver).append("::Preferences");
if (_config->Exists(solverpref) == true)
WriteOkay(Okay, output, "Preferences: ", _config->Find(solverpref,""), "\n");
return WriteOkay(Okay, output, "\n");
}
FileFd in;
- in.OpenDescriptor(input, FileFd::ReadOnly);
+ in.OpenDescriptor(input, FileFd::ReadOnly, true);
pkgTagFile response(&in, 100);
pkgTagSection section;
// StringToBool - convert yes/no to bool /*{{{*/
// ---------------------------------------------------------------------
/* we are not as lazy as we are in the global StringToBool as we really
- only accept yes/no here - but we will ignore leading spaces */
-static bool StringToBool(char const *answer, bool const defValue) {
- for (; isspace(*answer) != 0; ++answer);
- if (strncasecmp(answer, "yes", 3) == 0)
+ only accept yes/no here */
+static bool localStringToBool(std::string answer, bool const defValue) {
+ std::transform(answer.begin(), answer.end(), answer.begin(), ::tolower);
+ if (answer == "yes")
return true;
- else if (strncasecmp(answer, "no", 2) == 0)
+ else if (answer == "no")
return false;
else
- _error->Warning("Value '%s' is not a boolean 'yes' or 'no'!", answer);
+ _error->Warning("Value '%s' is not a boolean 'yes' or 'no'!", answer.c_str());
return defValue;
}
/*}}}*/
-// EDSP::ReadRequest - first stanza from the given file descriptor /*{{{*/
-static bool ReadFlag(unsigned int &flags, std::string const &line, APT::StringView const name, unsigned int const setflag)
+static bool LineStartsWithAndStrip(std::string &line, APT::StringView const with)/*{{{*/
{
- if (line.compare(0, name.length(), name.data()) != 0)
+ if (line.compare(0, with.size(), with.data()) != 0)
return false;
- auto const l = line.c_str() + name.length() + 1;
- if (StringToBool(l, false))
+ line = APT::String::Strip(line.substr(with.length()));
+ return true;
+}
+ /*}}}*/
+static bool ReadFlag(unsigned int &flags, std::string &line, APT::StringView const name, unsigned int const setflag)/*{{{*/
+{
+ if (LineStartsWithAndStrip(line, name) == false)
+ return false;
+ if (localStringToBool(line, false))
flags |= setflag;
else
flags &= ~setflag;
return true;
}
+ /*}}}*/
+// EDSP::ReadRequest - first stanza from the given file descriptor /*{{{*/
bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
std::list<std::string> &remove, unsigned int &flags)
{
if (line.empty() == true)
continue;
// The first Tag must be a request, so search for it
- if (line.compare(0, 8, "Request:") != 0)
+ if (LineStartsWithAndStrip(line, "Request:"))
continue;
while (ReadLine(input, line) == true)
return true;
std::list<std::string> *request = NULL;
- if (line.compare(0, 8, "Install:") == 0)
- {
- line.erase(0, 8);
+ if (LineStartsWithAndStrip(line, "Install:"))
request = &install;
- }
- else if (line.compare(0, 7, "Remove:") == 0)
- {
- line.erase(0, 7);
+ else if (LineStartsWithAndStrip(line, "Remove:"))
request = &remove;
- }
else if (ReadFlag(flags, line, "Upgrade:", (Request::UPGRADE_ALL | Request::FORBID_REMOVE | Request::FORBID_NEW_INSTALL)) ||
ReadFlag(flags, line, "Dist-Upgrade:", Request::UPGRADE_ALL) ||
ReadFlag(flags, line, "Upgrade-All:", Request::UPGRADE_ALL) ||
ReadFlag(flags, line, "Forbid-Remove:", Request::FORBID_REMOVE) ||
ReadFlag(flags, line, "Autoremove:", Request::AUTOREMOVE))
;
- else if (line.compare(0, 13, "Architecture:") == 0)
- _config->Set("APT::Architecture", line.c_str() + 14);
- else if (line.compare(0, 14, "Architectures:") == 0)
- {
- std::string const archs = line.c_str() + 15;
- _config->Set("APT::Architectures", SubstVar(archs, " ", ","));
- }
- else if (line.compare(0, 7, "Solver:") == 0)
+ else if (LineStartsWithAndStrip(line, "Architecture:"))
+ _config->Set("APT::Architecture", line);
+ else if (LineStartsWithAndStrip(line, "Architectures:"))
+ _config->Set("APT::Architectures", SubstVar(line, " ", ","));
+ else if (LineStartsWithAndStrip(line, "Solver:"))
; // purely informational line
else
_error->Warning("Unknown line in EDSP Request stanza: %s", line.c_str());
if (request == NULL)
continue;
- size_t end = line.length();
- do {
- size_t begin = line.rfind(' ');
- if (begin == std::string::npos)
- {
- request->push_back(line.substr(0, end));
- break;
- }
- else if (begin < end)
- request->push_back(line.substr(begin + 1, end));
- line.erase(begin);
- end = line.find_last_not_of(' ');
- } while (end != std::string::npos);
+ auto const pkgs = VectorizeString(line, ' ');
+ std::move(pkgs.begin(), pkgs.end(), std::back_inserter(*request));
}
}
return false;
return true;
}
/*}}}*/
-// EDSP::WriteSolution - to the given file descriptor /*{{{*/
+// EDSP::WriteSolutionStanza - to the given file descriptor /*{{{*/
bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
{
bool const Debug = _config->FindB("Debug::EDSP::WriteSolution", false);
{
if (Cache[Pkg].Delete() == true)
{
- fprintf(output, "Remove: %d\n", Pkg.CurrentVer()->ID);
+ fprintf(output, "Remove: %d\n", _system->GetVersionMapping(Pkg.CurrentVer()->ID));
if (Debug == true)
fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
}
else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
{
pkgCache::VerIterator const CandVer = Cache.GetCandidateVersion(Pkg);
- fprintf(output, "Install: %d\n", CandVer->ID);
+ fprintf(output, "Install: %d\n", _system->GetVersionMapping(CandVer->ID));
if (Debug == true)
fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), CandVer.VerStr());
}
else if (Cache[Pkg].Garbage == true)
{
- fprintf(output, "Autoremove: %d\n", Pkg.CurrentVer()->ID);
+ fprintf(output, "Autoremove: %d\n", _system->GetVersionMapping(Pkg.CurrentVer()->ID));
if (Debug == true)
fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
}
return true;
}
-bool EDSP::WriteSolution(pkgDepCache &Cache, FileFd &output)
+bool EDSP::WriteSolutionStanza(FileFd &output, char const * const Type, pkgCache::VerIterator const &Ver)
{
- bool const Debug = _config->FindB("Debug::EDSP::WriteSolution", false);
bool Okay = output.Failed() == false;
- for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false && likely(Okay); ++Pkg)
- {
- std::string action;
- if (Cache[Pkg].Delete() == true)
- WriteOkay(Okay, output, "Remove: ", Pkg.CurrentVer()->ID, "\n");
- else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
- WriteOkay(Okay, output, "Install: ", Cache.GetCandidateVersion(Pkg)->ID, "\n");
- else if (Cache[Pkg].Garbage == true)
- WriteOkay(Okay, output, "Autoremove: ", Pkg.CurrentVer()->ID, "\n");
- else
- continue;
-
- if (Debug)
- {
- WriteOkay(Okay, output, "Package: ", Pkg.FullName(), "\nVersion: ");
- if (Cache[Pkg].Delete() == true || Cache[Pkg].Garbage == true)
- WriteOkay(Okay, output, Pkg.CurrentVer().VerStr(), "\n\n");
- else
- WriteOkay(Okay, output, Cache.GetCandidateVersion(Pkg).VerStr(), "\n\n");
- }
- else
- WriteOkay(Okay, output, "\n");
- }
- return Okay;
+ WriteOkay(Okay, output, Type, ": ", _system->GetVersionMapping(Ver->ID));
+ if (_config->FindB("Debug::EDSP::WriteSolution", false) == true)
+ WriteOkay(Okay, output, "\nPackage: ", Ver.ParentPkg().FullName(), "\nVersion: ", Ver.VerStr());
+ return WriteOkay(Okay, output, "\n\n");
}
/*}}}*/
// EDSP::WriteProgess - pulse to the given file descriptor /*{{{*/
"\n\n");
}
/*}}}*/
-// EDSP::ExecuteSolver - fork requested solver and setup ipc pipes {{{*/
-pid_t EDSP::ExecuteSolver(const char* const solver, int * const solver_in, int * const solver_out, bool) {
- std::vector<std::string> const solverDirs = _config->FindVector("Dir::Bin::Solvers");
- std::string file;
- for (std::vector<std::string>::const_iterator dir = solverDirs.begin();
- dir != solverDirs.end(); ++dir) {
- file = flCombine(*dir, solver);
- if (RealFileExists(file.c_str()) == true)
- break;
- file.clear();
+static std::string findExecutable(std::vector<std::string> const &dirs, char const * const binary) {/*{{{*/
+ for (auto && dir : dirs) {
+ std::string const file = flCombine(dir, binary);
+ if (RealFileExists(file) == true)
+ return file;
+ }
+ return "";
+}
+ /*}}}*/
+static pid_t ExecuteExternal(char const* const type, char const * const binary, char const * const configdir, int * const solver_in, int * const solver_out) {/*{{{*/
+ auto const solverDirs = _config->FindVector(configdir);
+ auto const file = findExecutable(solverDirs, binary);
+ std::string dumper;
+ {
+ dumper = findExecutable(solverDirs, "apt-dump-solver");
+ if (dumper.empty())
+ dumper = findExecutable(solverDirs, "dump");
}
if (file.empty() == true)
{
- _error->Error("Can't call external solver '%s' as it is not in a configured directory!", solver);
+ _error->Error("Can't call external %s '%s' as it is not in a configured directory!", type, binary);
return 0;
}
int external[4] = {-1, -1, -1, -1};
if (Solver == 0) {
dup2(external[0], STDIN_FILENO);
dup2(external[3], STDOUT_FILENO);
- const char* calling[2] = { file.c_str(), 0 };
- execv(calling[0], (char**) calling);
- std::cerr << "Failed to execute solver '" << solver << "'!" << std::endl;
+ auto const dumpfile = _config->FindFile((std::string("Dir::Log::") + type).c_str());
+ auto const dumpdir = flNotFile(dumpfile);
+ auto const runasuser = _config->Find(std::string("APT::") + type + "::" + binary + "::RunAsUser",
+ _config->Find(std::string("APT::") + type + "::RunAsUser",
+ _config->Find("APT::Sandbox::User")));
+ if (dumper.empty() || dumpfile.empty() || dumper == file || CreateAPTDirectoryIfNeeded(dumpdir, dumpdir) == false)
+ {
+ _config->Set("APT::Sandbox::User", runasuser);
+ DropPrivileges();
+ char const * const calling[] = { file.c_str(), nullptr };
+ execv(calling[0], const_cast<char**>(calling));
+ }
+ else
+ {
+ char const * const calling[] = { dumper.c_str(), "--user", runasuser.c_str(), dumpfile.c_str(), file.c_str(), nullptr };
+ execv(calling[0], const_cast<char**>(calling));
+ }
+ std::cerr << "Failed to execute " << type << " '" << binary << "'!" << std::endl;
_exit(100);
}
close(external[0]);
if (WaitFd(external[1], true, 5) == false)
{
- _error->Errno("Resolve", "Timed out while Waiting on availability of solver stdin");
+ _error->Errno("Resolve", "Timed out while Waiting on availability of %s stdin", type);
return 0;
}
*solver_in = external[1];
*solver_out = external[2];
return Solver;
+}
+ /*}}}*/
+// EDSP::ExecuteSolver - fork requested solver and setup ipc pipes {{{*/
+pid_t EDSP::ExecuteSolver(const char* const solver, int * const solver_in, int * const solver_out, bool) {
+ return ExecuteExternal("solver", solver, "Dir::Bin::Solvers", solver_in, solver_out);
}
bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_out) {
if (ExecuteSolver(solver, solver_in, solver_out, true) == 0)
// EDSP::ResolveExternal - resolve problems by asking external for help {{{*/
bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
unsigned int const flags, OpProgress *Progress) {
+ if (strcmp(solver, "internal") == 0)
+ {
+ auto const dumpfile = _config->FindFile("Dir::Log::Solver");
+ if (dumpfile.empty())
+ return false;
+ auto const dumpdir = flNotFile(dumpfile);
+ FileFd output;
+ if (CreateAPTDirectoryIfNeeded(dumpdir, dumpdir) == false ||
+ output.Open(dumpfile, FileFd::WriteOnly | FileFd::Exclusive | FileFd::Create, FileFd::Extension, 0644) == false)
+ return _error->WarningE("EDSP::Resolve", _("Could not open file '%s'"), dumpfile.c_str());
+ bool Okay = EDSP::WriteRequest(Cache, output, flags, nullptr);
+ return Okay && EDSP::WriteScenario(Cache, output, nullptr);
+ }
int solver_in, solver_out;
pid_t const solver_pid = EDSP::ExecuteSolver(solver, &solver_in, &solver_out, true);
if (solver_pid == 0)
projects / apt.git / blobdiff