more explicit MarkRequired algorithm code

[apt.git] / cmdline / apt-dump-solver.cc

diff --git a/cmdline/apt-dump-solver.cc b/cmdline/apt-dump-solver.cc
index 04e13bde902decdb722e6f7826853fd1c38e3ed5..e94021fcf1a827bcc567abab42a15119ba746b98 100644 (file)
--- a/cmdline/apt-dump-solver.cc
+++ b/cmdline/apt-dump-solver.cc
@@ -7,47 +7,179 @@
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/

+#include <config.h>
+
+#include <apt-pkg/cmndline.h>
+#include <apt-pkg/configuration.h>

 #include <apt-pkg/edsp.h>
 #include <apt-pkg/edsp.h>

+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/strutl.h>
+
+#include <apt-private/private-cmndline.h>

 
 

-#include <string.h>
-#include <unistd.h>

 #include <cstdio>
 #include <iostream>
 #include <cstdio>
 #include <iostream>

+#include <memory>
+#include <sstream>

 
 

-#include <config.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include <string.h>
+#include <unistd.h>
+
+#include <apti18n.h>

                                                                        /*}}}*/
 
                                                                        /*}}}*/
 

-// ShowHelp - Show a help screen                                       /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-static bool ShowHelp() {
-
-       std::cout <<
-               PACKAGE " " PACKAGE_VERSION " for " COMMON_ARCH " compiled on " __DATE__ " " __TIME__ << std::endl <<
-               "Usage: apt-dump-resolver\n"
-               "\n"
-               "apt-dump-resolver is a dummy solver who just dumps its input to the\n"
-               "file /tmp/dump.edsp and exists with a proper EDSP error.\n"
-               "\n"
-               "                       This dump has lost Super Cow Powers.\n";
-       return true;
+static bool ShowHelp(CommandLine &)                                    /*{{{*/
+{
+   std::cout <<
+      _("Usage: apt-dump-solver\n"
+           "\n"
+           "apt-dump-solver is an interface to store an EDSP scenario in\n"
+           "a file and optionally forwards it to another solver.\n");
+   return true;
+}
+                                                                       /*}}}*/
+static std::vector<aptDispatchWithHelp> GetCommands()                  /*{{{*/
+{
+   return {};
+}
+                                                                       /*}}}*/
+static int WriteError(char const * const uid, std::ostringstream &out, FileFd &stdoutfd, pid_t const &Solver)/*{{{*/
+{
+   _error->DumpErrors(out);
+   // ensure the solver isn't printing into "our" error message, too
+   if (Solver != 0)
+      ExecWait(Solver, "dump", true);
+   EDSP::WriteError(uid, out.str(), stdoutfd);
+   return 0;

 }
                                                                        /*}}}*/
 int main(int argc,const char *argv[])                                  /*{{{*/
 {
 }
                                                                        /*}}}*/
 int main(int argc,const char *argv[])                                  /*{{{*/
 {

-       if (argc > 1 && (strcmp(argv[1], "--help") == 0 || strcmp(argv[1],"-h") == 0 ||
-           strcmp(argv[1],"-v") == 0 || strcmp(argv[1],"--version") == 0)) {
-               ShowHelp();
-               return 0;
-       }
-
-       FILE* input = fdopen(STDIN_FILENO, "r");
-       FILE* output = fopen("/tmp/dump.edsp", "w");
-       char buffer[400];
-       while (fgets(buffer, sizeof(buffer), input) != NULL)
-               fputs(buffer, output);
-       fclose(output);
-       fclose(input);
-
-       EDSP::WriteError("ERR_JUST_DUMPING", "I am too dumb, i can just dump!\nPlease use one of my friends instead!", stdout);
+   CommandLine CmdL;
+   ParseCommandLine(CmdL, APT_CMD::APT_DUMP_SOLVER, &_config, nullptr, argc, argv, &ShowHelp, &GetCommands);
+   _config->Clear("Dir::Log");
+
+   bool const is_forwarding_dumper = (CmdL.FileSize() != 0);
+
+   FileFd stdoutfd;
+   if (stdoutfd.OpenDescriptor(STDOUT_FILENO, FileFd::WriteOnly | FileFd::BufferedWrite, true) == false)
+      return 252;
+
+   FileFd dump;
+   char const * const filename = is_forwarding_dumper ? CmdL.FileList[0] : getenv("APT_EDSP_DUMP_FILENAME");
+   if (filename == nullptr || strlen(filename) == 0)
+   {
+      if (is_forwarding_dumper == false)
+      {
+        EDSP::WriteError("ERR_NO_FILENAME", "You have to set the environment variable APT_EDSP_DUMP_FILENAME\n"
+              "to a valid filename to store the dump of EDSP solver input in.\n"
+              "For example with: export APT_EDSP_DUMP_FILENAME=/tmp/dump.edsp", stdoutfd);
+        return 0;
+      }
+   }
+   else
+   {
+      // ignore errors here as logging isn't really critical
+      _error->PushToStack();
+      if (dump.Open(filename, FileFd::WriteOnly | FileFd::Exclusive | FileFd::Create, FileFd::Extension, 0644) == false &&
+           is_forwarding_dumper == false)
+      {
+        _error->MergeWithStack();
+        std::ostringstream out;
+        out << "Writing EDSP solver input to file '" << filename << "' failed as it couldn't be created!\n";
+        return WriteError("ERR_CREATE_FILE", out, stdoutfd, 0);
+      }
+      _error->RevertToStack();
+   }
+
+   pid_t Solver = 0;
+   FileFd forward;
+   if (is_forwarding_dumper)
+   {
+      int external[] = {-1, -1};
+      if (pipe(external) != 0)
+        return 250;
+      for (int i = 0; i < 2; ++i)
+        SetCloseExec(external[i], true);
+
+      Solver = ExecFork();
+      if (Solver == 0) {
+        _config->Set("APT::Sandbox::User", _config->Find("APT::Solver::RunAsUser", _config->Find("APT::Sandbox::User")));
+        DropPrivileges();
+        dup2(external[0], STDIN_FILENO);
+        execv(CmdL.FileList[1], const_cast<char**>(CmdL.FileList + 1));
+        std::cerr << "Failed to execute  '" << CmdL.FileList[1] << "'!" << std::endl;
+        _exit(100);
+      }
+      close(external[0]);
+
+      if (WaitFd(external[1], true, 5) == false)
+        return 251;
+
+      if (forward.OpenDescriptor(external[1], FileFd::WriteOnly | FileFd::BufferedWrite, true) == false)
+        return 252;
+   }
+
+   DropPrivileges();
+
+   FileFd input;
+   if (input.OpenDescriptor(STDIN_FILENO, FileFd::ReadOnly) == false)
+   {
+      std::ostringstream out;
+      out << "Writing EDSP solver input to file '" << filename << "' failed as stdin couldn't be opened!\n";
+      return WriteError("ERR_READ_ERROR", out, stdoutfd, Solver);
+   }
+
+   constexpr size_t BufSize = 64 * 1024;
+   std::unique_ptr<char[]> Buf(new char[BufSize]);
+   unsigned long long ToRead = 0;
+   do {
+      if (input.Read(Buf.get(),BufSize, &ToRead) == false)
+      {
+        std::ostringstream out;
+        out << "Writing EDSP solver input to file '" << filename << "' failed as reading from stdin failed!\n";
+        return WriteError("ERR_READ_ERROR", out, stdoutfd, Solver);
+      }
+      if (ToRead == 0)
+        break;
+      if (forward.IsOpen() && forward.Failed() == false && forward.Write(Buf.get(),ToRead) == false)
+        forward.Close();
+      if (dump.IsOpen() && dump.Failed() == false && dump.Write(Buf.get(),ToRead) == false)
+        dump.Close();
+   } while (true);
+   input.Close();
+   forward.Close();
+   dump.Close();
+
+   if (_error->PendingError())
+   {
+      std::ostringstream out;
+      out << "Writing EDSP solver input to file '" << filename << "' failed due to write errors!\n";
+      return WriteError("ERR_WRITE_ERROR", out, stdoutfd, Solver);
+   }
+
+   if (is_forwarding_dumper)
+   {
+      // Wait and collect the error code
+      int Status;
+      while (waitpid(Solver, &Status, 0) != Solver)
+      {
+        if (errno == EINTR)
+           continue;
+
+        std::ostringstream out;
+        ioprintf(out, _("Waited for %s but it wasn't there"), CmdL.FileList[1]);
+        return WriteError("ERR_FORWARD", out, stdoutfd, 0);
+      }
+      if (WIFEXITED(Status))
+        return WEXITSTATUS(Status);
+      else
+        return 255;
+   }
+   else
+      EDSP::WriteError("ERR_JUST_DUMPING", "I am too dumb, i can just dump!\nPlease use one of my friends instead!", stdoutfd);
+   return 0;

 }
 }