remove racy_pselect fallback

[apt.git] / apt-pkg / edsp.cc

diff --git a/apt-pkg/edsp.cc b/apt-pkg/edsp.cc
index 94cac4eb1564564431fc95e3f51033d1e2f78a42..890252ba430e9c99829e0187a4b53164bdf12206 100644 (file)
--- a/apt-pkg/edsp.cc
+++ b/apt-pkg/edsp.cc
@@ -20,6 +20,7 @@
 #include <apt-pkg/string_view.h>
 #include <apt-pkg/pkgsystem.h>
 
+#include <sys/stat.h>
 #include <ctype.h>
 #include <stddef.h>
 #include <string.h>
@@ -597,10 +598,12 @@ bool EDSP::WriteRequest(pkgDepCache &Cache, FileFd &output,
       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");
@@ -926,15 +929,23 @@ bool EDSP::WriteError(char const * const uuid, std::string const &message, FileF
              "\n\n");
 }
                                                                        /*}}}*/
+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) {/*{{{*/
-       std::vector<std::string> const solverDirs = _config->FindVector(configdir);
-       std::string file;
-       for (std::vector<std::string>::const_iterator dir = solverDirs.begin();
-            dir != solverDirs.end(); ++dir) {
-               file = flCombine(*dir, binary);
-               if (RealFileExists(file.c_str()) == true)
-                       break;
-               file.clear();
+       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)
@@ -955,8 +966,23 @@ static pid_t ExecuteExternal(char const* const type, char const * const binary,
        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);
+               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);
        }
@@ -987,6 +1013,19 @@ bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_o
 // 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)