Log calling SUDO_USER or PKEXEC_UID in history.log

[apt.git] / apt-pkg / deb / dpkgpm.cc

diff --git a/apt-pkg/deb/dpkgpm.cc b/apt-pkg/deb/dpkgpm.cc
index 0cded32e1f9e5bd93c73657eb589b5d6f98b4301..e94a8cfdc3be40e3dcd5aab63887dc3f32715af5 100644 (file)
--- a/apt-pkg/deb/dpkgpm.cc
+++ b/apt-pkg/deb/dpkgpm.cc
@@ -14,11 +14,11 @@
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/dpkgpm.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/dpkgpm.h>

+#include <apt-pkg/debsystem.h>

 #include <apt-pkg/error.h>
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/install-progress.h>
 #include <apt-pkg/packagemanager.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/install-progress.h>
 #include <apt-pkg/packagemanager.h>

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

 #include <apt-pkg/strutl.h>
 #include <apt-pkg/cacheiterators.h>
 #include <apt-pkg/macros.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/cacheiterators.h>
 #include <apt-pkg/macros.h>


@@ -27,7 +27,6 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <grp.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <grp.h>

-#include <pty.h>

 #include <pwd.h>
 #include <signal.h>
 #include <stddef.h>
 #include <pwd.h>
 #include <signal.h>
 #include <stddef.h>


@@ -49,12 +48,28 @@
 #include <string>
 #include <utility>
 #include <vector>
 #include <string>
 #include <utility>
 #include <vector>

+#include <sstream>

 
 #include <apti18n.h>
                                                                        /*}}}*/
 
 using namespace std;
 
 
 #include <apti18n.h>
                                                                        /*}}}*/
 
 using namespace std;
 

+APT_PURE static string
+AptHistoryUser()
+{
+   stringstream out;
+   const char* env[]{"SUDO_USER", "PKEXEC_UID", nullptr};
+   for (int i=0; env[i] != nullptr; i++)
+   {
+      if (getenv(env[i]) != nullptr)
+      {
+         out << env[i] << "=" << getenv(env[i]) << " ";
+      }
+   }
+   return out.str();
+}
+

 APT_PURE static unsigned int
 EnvironmentSize()
 {
 APT_PURE static unsigned int
 EnvironmentSize()
 {


@@ -72,7 +87,9 @@ class pkgDPkgPMPrivate
 public:
    pkgDPkgPMPrivate() : stdin_is_dev_null(false), dpkgbuf_pos(0),
                        term_out(NULL), history_out(NULL),
 public:
    pkgDPkgPMPrivate() : stdin_is_dev_null(false), dpkgbuf_pos(0),
                        term_out(NULL), history_out(NULL),

-                        progress(NULL), master(-1), slave(NULL)
+                       progress(NULL), tt_is_valid(false), master(-1),
+                       slave(NULL), protect_slave_from_dying(-1),
+                       direct_stdin(false)

    {
       dpkgbuf[0] = '\0';
    }
    {
       dpkgbuf[0] = '\0';
    }


@@ -82,7 +99,7 @@ public:
    bool stdin_is_dev_null;
    // the buffer we use for the dpkg status-fd reading
    char dpkgbuf[1024];
    bool stdin_is_dev_null;
    // the buffer we use for the dpkg status-fd reading
    char dpkgbuf[1024];

-   int dpkgbuf_pos;
+   size_t dpkgbuf_pos;

    FILE *term_out;
    FILE *history_out;
    string dpkg_error;
    FILE *term_out;
    FILE *history_out;
    string dpkg_error;


@@ -90,13 +107,16 @@ public:
 
    // pty stuff
    struct termios tt;
 
    // pty stuff
    struct termios tt;

+   bool tt_is_valid;

    int master;
    char * slave;
    int master;
    char * slave;

+   int protect_slave_from_dying;

 
    // signals
    sigset_t sigmask;
    sigset_t original_sigmask;
 
 
    // signals
    sigset_t sigmask;
    sigset_t original_sigmask;
 

+   bool direct_stdin;

 };
 
 namespace
 };
 
 namespace


@@ -122,7 +142,7 @@ namespace
     const char *target;
 
   public:
     const char *target;
 
   public:

-    MatchProcessingOp(const char *the_target)
+    explicit MatchProcessingOp(const char *the_target)

       : target(the_target)
     {
     }
       : target(the_target)
     {
     }


@@ -159,35 +179,6 @@ ionice(int PID)
    return ExecWait(Process, "ionice");
 }
 
    return ExecWait(Process, "ionice");
 }
 

-static std::string getDpkgExecutable()
-{
-   string Tmp = _config->Find("Dir::Bin::dpkg","dpkg");
-   string const dpkgChrootDir = _config->FindDir("DPkg::Chroot-Directory", "/");
-   size_t dpkgChrootLen = dpkgChrootDir.length();
-   if (dpkgChrootDir != "/" && Tmp.find(dpkgChrootDir) == 0)
-   {
-      if (dpkgChrootDir[dpkgChrootLen - 1] == '/')
-         --dpkgChrootLen;
-      Tmp = Tmp.substr(dpkgChrootLen);
-   }
-   return Tmp;
-}
-
-// dpkgChrootDirectory - chrooting for dpkg if needed                  /*{{{*/
-static void dpkgChrootDirectory()
-{
-   std::string const chrootDir = _config->FindDir("DPkg::Chroot-Directory");
-   if (chrootDir == "/")
-      return;
-   std::cerr << "Chrooting into " << chrootDir << std::endl;
-   if (chroot(chrootDir.c_str()) != 0)
-      _exit(100);
-   if (chdir("/") != 0)
-      _exit(100);
-}
-                                                                       /*}}}*/
-
-

 // FindNowVersion - Helper to find a Version in "now" state    /*{{{*/
 // ---------------------------------------------------------------------
 /* This is helpful when a package is no longer installed but has residual 
 // FindNowVersion - Helper to find a Version in "now" state    /*{{{*/
 // ---------------------------------------------------------------------
 /* This is helpful when a package is no longer installed but has residual 


@@ -198,18 +189,12 @@ pkgCache::VerIterator FindNowVersion(const pkgCache::PkgIterator &Pkg)
 {
    pkgCache::VerIterator Ver;
    for (Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
 {
    pkgCache::VerIterator Ver;
    for (Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)

-   {
-      pkgCache::VerFileIterator Vf = Ver.FileList();
-      pkgCache::PkgFileIterator F = Vf.File();
-      for (F = Vf.File(); F.end() == false; ++F)
-      {
-         if (F && F.Archive())
-         {
-            if (strcmp(F.Archive(), "now")) 
-               return Ver;
-         }
-      }
-   }
+      for (pkgCache::VerFileIterator Vf = Ver.FileList(); Vf.end() == false; ++Vf)
+        for (pkgCache::PkgFileIterator F = Vf.File(); F.end() == false; ++F)
+        {
+           if (F.Archive() != 0 && strcmp(F.Archive(), "now") == 0)
+              return Ver;
+        }

    return Ver;
 }
                                                                        /*}}}*/
    return Ver;
 }
                                                                        /*}}}*/


@@ -217,10 +202,9 @@ pkgCache::VerIterator FindNowVersion(const pkgCache::PkgIterator &Pkg)
 // DPkgPM::pkgDPkgPM - Constructor                                     /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // DPkgPM::pkgDPkgPM - Constructor                                     /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-pkgDPkgPM::pkgDPkgPM(pkgDepCache *Cache) 
-   : pkgPackageManager(Cache), pkgFailures(0), PackagesDone(0), PackagesTotal(0)
+pkgDPkgPM::pkgDPkgPM(pkgDepCache *Cache)
+   : pkgPackageManager(Cache),d(new pkgDPkgPMPrivate()), pkgFailures(0), PackagesDone(0), PackagesTotal(0)

 {
 {

-   d = new pkgDPkgPMPrivate();

 }
                                                                        /*}}}*/
 // DPkgPM::pkgDPkgPM - Destructor                                      /*{{{*/
 }
                                                                        /*}}}*/
 // DPkgPM::pkgDPkgPM - Destructor                                      /*{{{*/


@@ -470,7 +454,7 @@ bool pkgDPkgPM::RunScriptsWithPkgs(const char *Cnf)
         strprintf(hookfd, "%d", InfoFD);
         setenv("APT_HOOK_INFO_FD", hookfd.c_str(), 1);
 
         strprintf(hookfd, "%d", InfoFD);
         setenv("APT_HOOK_INFO_FD", hookfd.c_str(), 1);
 

-        dpkgChrootDirectory();
+        debSystem::DpkgChrootDirectory();

         const char *Args[4];
         Args[0] = "/bin/sh";
         Args[1] = "-c";
         const char *Args[4];
         Args[0] = "/bin/sh";
         Args[1] = "-c";


@@ -786,40 +770,33 @@ void pkgDPkgPM::handleDisappearAction(string const &pkgname)
 }
                                                                        /*}}}*/
 // DPkgPM::DoDpkgStatusFd                                              /*{{{*/
 }
                                                                        /*}}}*/
 // DPkgPM::DoDpkgStatusFd                                              /*{{{*/

-// ---------------------------------------------------------------------
-/*
- */

 void pkgDPkgPM::DoDpkgStatusFd(int statusfd)
 {
 void pkgDPkgPM::DoDpkgStatusFd(int statusfd)
 {

-   char *p, *q;
-   int len;
-
-   len=read(statusfd, &d->dpkgbuf[d->dpkgbuf_pos], sizeof(d->dpkgbuf)-d->dpkgbuf_pos);
-   d->dpkgbuf_pos += len;
+   ssize_t const len = read(statusfd, &d->dpkgbuf[d->dpkgbuf_pos],
+        (sizeof(d->dpkgbuf)/sizeof(d->dpkgbuf[0])) - d->dpkgbuf_pos);

    if(len <= 0)
       return;
    if(len <= 0)
       return;

+   d->dpkgbuf_pos += (len / sizeof(d->dpkgbuf[0]));

 
 

-   // process line by line if we have a buffer
-   p = q = d->dpkgbuf;
-   while((q=(char*)memchr(p, '\n', d->dpkgbuf+d->dpkgbuf_pos-p)) != NULL)
+   // process line by line from the buffer
+   char *p = d->dpkgbuf, *q = nullptr;
+   while((q=(char*)memchr(p, '\n', (d->dpkgbuf + d->dpkgbuf_pos) - p)) != nullptr)

    {
    {

-      *q = 0;
+      *q = '\0';

       ProcessDpkgStatusLine(p);
       ProcessDpkgStatusLine(p);

-      p=q+1; // continue with next line
+      p = q + 1; // continue with next line

    }
 
    }
 

-   // now move the unprocessed bits (after the final \n that is now a 0x0) 
-   // to the start and update d->dpkgbuf_pos
-   p = (char*)memrchr(d->dpkgbuf, 0, d->dpkgbuf_pos);
-   if(p == NULL)
+   // check if we stripped the buffer clean
+   if (p > (d->dpkgbuf + d->dpkgbuf_pos))
+   {
+      d->dpkgbuf_pos = 0;

       return;
       return;

+   }

 
 

-   // we are interessted in the first char *after* 0x0
-   p++;
-
-   // move the unprocessed tail to the start and update pos
-   memmove(d->dpkgbuf, p, p-d->dpkgbuf);
-   d->dpkgbuf_pos = d->dpkgbuf+d->dpkgbuf_pos-p;
+   // otherwise move the unprocessed tail to the start and update pos
+   memmove(d->dpkgbuf, p, (p - d->dpkgbuf));
+   d->dpkgbuf_pos = (d->dpkgbuf + d->dpkgbuf_pos) - p;

 }
                                                                        /*}}}*/
 // DPkgPM::WriteHistoryTag                                             /*{{{*/
 }
                                                                        /*}}}*/
 // DPkgPM::WriteHistoryTag                                             /*{{{*/


@@ -844,7 +821,8 @@ bool pkgDPkgPM::OpenLog()
    // get current time
    char timestr[200];
    time_t const t = time(NULL);
    // get current time
    char timestr[200];
    time_t const t = time(NULL);

-   struct tm const * const tmp = localtime(&t);
+   struct tm tm_buf;
+   struct tm const * const tmp = localtime_r(&t, &tm_buf);

    strftime(timestr, sizeof(timestr), "%F  %T", tmp);
 
    // open terminal log
    strftime(timestr, sizeof(timestr), "%F  %T", tmp);
 
    // open terminal log


@@ -914,6 +892,8 @@ bool pkgDPkgPM::OpenLog()
       }
       if (_config->Exists("Commandline::AsString") == true)
         WriteHistoryTag("Commandline", _config->Find("Commandline::AsString"));
       }
       if (_config->Exists("Commandline::AsString") == true)
         WriteHistoryTag("Commandline", _config->Find("Commandline::AsString"));

+      if (AptHistoryUser() != "")
+         WriteHistoryTag("Requested-By", AptHistoryUser());

       WriteHistoryTag("Install", install);
       WriteHistoryTag("Reinstall", reinstall);
       WriteHistoryTag("Upgrade", upgrade);
       WriteHistoryTag("Install", install);
       WriteHistoryTag("Reinstall", reinstall);
       WriteHistoryTag("Upgrade", upgrade);


@@ -931,7 +911,8 @@ bool pkgDPkgPM::CloseLog()
 {
    char timestr[200];
    time_t t = time(NULL);
 {
    char timestr[200];
    time_t t = time(NULL);

-   struct tm *tmp = localtime(&t);
+   struct tm tm_buf;
+   struct tm *tmp = localtime_r(&t, &tm_buf);

    strftime(timestr, sizeof(timestr), "%F  %T", tmp);
 
    if(d->term_out)
    strftime(timestr, sizeof(timestr), "%F  %T", tmp);
 
    if(d->term_out)


@@ -1044,6 +1025,12 @@ void pkgDPkgPM::BuildPackagesProgressMap()
         PackagesTotal++;
       }
    }
         PackagesTotal++;
       }
    }

+   /* one extra: We don't want the progress bar to reach 100%, especially not
+      if we call dpkg --configure --pending and process a bunch of triggers
+      while showing 100%. Also, spindown takes a while, so never reaching 100%
+      is way more correct than reaching 100% while still doing stuff even if
+      doing it this way is slightly bending the rules */
+   ++PackagesTotal;

 }
                                                                         /*}}}*/
 bool pkgDPkgPM::Go(int StatusFd)
 }
                                                                         /*}}}*/
 bool pkgDPkgPM::Go(int StatusFd)


@@ -1068,48 +1055,49 @@ void pkgDPkgPM::StartPtyMagic()
       return;
    }
 
       return;
    }
 

+   if (isatty(STDIN_FILENO) == 0)
+      d->direct_stdin = true;
+

    _error->PushToStack();
    _error->PushToStack();

-   // if tcgetattr for both stdin/stdout returns 0 (no error)
-   // we do the pty magic
-   if (tcgetattr(STDOUT_FILENO, &d->tt) == 0 &&
-        tcgetattr(STDIN_FILENO, &d->tt) == 0)
+
+   d->master = posix_openpt(O_RDWR | O_NOCTTY);
+   if (d->master == -1)
+      _error->Errno("posix_openpt", _("Can not write log (%s)"), _("Is /dev/pts mounted?"));
+   else if (unlockpt(d->master) == -1)
+      _error->Errno("unlockpt", "Unlocking the slave of master fd %d failed!", d->master);
+   else

    {
    {

-      d->master = posix_openpt(O_RDWR | O_NOCTTY);
-      if (d->master == -1)
-        _error->Errno("posix_openpt", _("Can not write log (%s)"), _("Is /dev/pts mounted?"));
-      else if (unlockpt(d->master) == -1)
-      {
-        _error->Errno("unlockpt", "Unlocking the slave of master fd %d failed!", d->master);
-        close(d->master);
-        d->master = -1;
-      }
+#ifdef HAVE_PTS_NAME_R
+      char slave_name[64];     // 64 is used by bionic
+      if (ptsname_r(d->master, slave_name, sizeof(slave_name)) != 0)
+#else
+      char const * const slave_name = ptsname(d->master);
+      if (slave_name == NULL)
+#endif
+        _error->Errno("ptsname", "Getting name for slave of master fd %d failed!", d->master);

       else
       {
       else
       {

-        char const * const slave_name = ptsname(d->master);
-        if (slave_name == NULL)
+        d->slave = strdup(slave_name);
+        if (d->slave == NULL)
+           _error->Errno("strdup", "Copying name %s for slave of master fd %d failed!", slave_name, d->master);
+        else if (grantpt(d->master) == -1)
+           _error->Errno("grantpt", "Granting access to slave %s based on master fd %d failed!", slave_name, d->master);
+        else if (tcgetattr(STDIN_FILENO, &d->tt) == 0)

         {
         {

-           _error->Errno("unlockpt", "Getting name for slave of master fd %d failed!", d->master);
-           close(d->master);
-           d->master = -1;
-        }
-        else
-        {
-           d->slave = strdup(slave_name);
-           if (d->slave == NULL)
+           d->tt_is_valid = true;
+           struct termios raw_tt;
+           // copy window size of stdout if its a 'good' terminal
+           if (tcgetattr(STDOUT_FILENO, &raw_tt) == 0)

            {
            {

-              _error->Errno("strdup", "Copying name %s for slave of master fd %d failed!", slave_name, d->master);
-              close(d->master);
-              d->master = -1;
+              struct winsize win;
+              if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) < 0)
+                 _error->Errno("ioctl", "Getting TIOCGWINSZ from stdout failed!");
+              if (ioctl(d->master, TIOCSWINSZ, &win) < 0)
+                 _error->Errno("ioctl", "Setting TIOCSWINSZ for master fd %d failed!", d->master);

            }
            }

-           struct winsize win;
-           if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) < 0)
-              _error->Errno("ioctl", "Getting TIOCGWINSZ from stdout failed!");
-           if (ioctl(d->master, TIOCSWINSZ, &win) < 0)
-              _error->Errno("ioctl", "Setting TIOCSWINSZ for master fd %d failed!", d->master);

            if (tcsetattr(d->master, TCSANOW, &d->tt) == -1)
               _error->Errno("tcsetattr", "Setting in Start via TCSANOW for master fd %d failed!", d->master);
 
            if (tcsetattr(d->master, TCSANOW, &d->tt) == -1)
               _error->Errno("tcsetattr", "Setting in Start via TCSANOW for master fd %d failed!", d->master);
 

-           struct termios raw_tt;

            raw_tt = d->tt;
            cfmakeraw(&raw_tt);
            raw_tt.c_lflag &= ~ECHO;
            raw_tt = d->tt;
            cfmakeraw(&raw_tt);
            raw_tt.c_lflag &= ~ECHO;


@@ -1121,18 +1109,22 @@ void pkgDPkgPM::StartPtyMagic()
            sigaddset(&d->sigmask, SIGTTOU);
            sigprocmask(SIG_BLOCK,&d->sigmask, &d->original_sigmask);
            if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw_tt) == -1)
            sigaddset(&d->sigmask, SIGTTOU);
            sigprocmask(SIG_BLOCK,&d->sigmask, &d->original_sigmask);
            if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw_tt) == -1)

-              _error->Errno("tcsetattr", "Setting in Start via TCSAFLUSH for stdout failed!");
+              _error->Errno("tcsetattr", "Setting in Start via TCSAFLUSH for stdin failed!");

            sigprocmask(SIG_SETMASK, &d->original_sigmask, NULL);
            sigprocmask(SIG_SETMASK, &d->original_sigmask, NULL);

+
+        }
+        if (d->slave != NULL)
+        {
+           /* on linux, closing (and later reopening) all references to the slave
+              makes the slave a death end, so we open it here to have one open all
+              the time. We could use this fd in SetupSlavePtyMagic() for linux, but
+              on kfreebsd we get an incorrect ("step like") output then while it has
+              no problem with closing all references… so to avoid platform specific
+              code here we combine both and be happy once more */
+           d->protect_slave_from_dying = open(d->slave, O_RDWR | O_CLOEXEC | O_NOCTTY);

         }
       }
    }
         }
       }
    }

-   else
-   {
-      // complain only if stdout is either a terminal (but still failed) or is an invalid
-      // descriptor otherwise we would complain about redirection to e.g. /dev/null as well.
-      if (isatty(STDOUT_FILENO) == 1 || errno == EBADF)
-        _error->Errno("tcgetattr", _("Can not write log (%s)"), _("Is stdout a terminal?"));
-   }

 
    if (_error->PendingError() == true)
    {
 
    if (_error->PendingError() == true)
    {


@@ -1141,44 +1133,60 @@ void pkgDPkgPM::StartPtyMagic()
         close(d->master);
         d->master = -1;
       }
         close(d->master);
         d->master = -1;
       }

-      _error->DumpErrors(std::cerr);
+      if (d->slave != NULL)
+      {
+        free(d->slave);
+        d->slave = NULL;
+      }
+      _error->DumpErrors(std::cerr, GlobalError::DEBUG, false);

    }
    _error->RevertToStack();
 }
 void pkgDPkgPM::SetupSlavePtyMagic()
 {
    }
    _error->RevertToStack();
 }
 void pkgDPkgPM::SetupSlavePtyMagic()
 {

-   if(d->master == -1)
+   if(d->master == -1 || d->slave == NULL)

       return;
 
    if (close(d->master) == -1)
       _error->FatalE("close", "Closing master %d in child failed!", d->master);
       return;
 
    if (close(d->master) == -1)
       _error->FatalE("close", "Closing master %d in child failed!", d->master);

+   d->master = -1;

    if (setsid() == -1)
       _error->FatalE("setsid", "Starting a new session for child failed!");
 
    if (setsid() == -1)
       _error->FatalE("setsid", "Starting a new session for child failed!");
 

-   int const slaveFd = open(d->slave, O_RDWR);
+   int const slaveFd = open(d->slave, O_RDWR | O_NOCTTY);

    if (slaveFd == -1)
       _error->FatalE("open", _("Can not write log (%s)"), _("Is /dev/pts mounted?"));
    if (slaveFd == -1)
       _error->FatalE("open", _("Can not write log (%s)"), _("Is /dev/pts mounted?"));

-
-   if (ioctl(slaveFd, TIOCSCTTY, 0) < 0)
+   else if (ioctl(slaveFd, TIOCSCTTY, 0) < 0)

       _error->FatalE("ioctl", "Setting TIOCSCTTY for slave fd %d failed!", slaveFd);
    else
    {
       _error->FatalE("ioctl", "Setting TIOCSCTTY for slave fd %d failed!", slaveFd);
    else
    {

-      for (unsigned short i = 0; i < 3; ++i)
+      unsigned short i = 0;
+      if (d->direct_stdin == true)
+        ++i;
+      for (; i < 3; ++i)

         if (dup2(slaveFd, i) == -1)
            _error->FatalE("dup2", "Dupping %d to %d in child failed!", slaveFd, i);
 
         if (dup2(slaveFd, i) == -1)
            _error->FatalE("dup2", "Dupping %d to %d in child failed!", slaveFd, i);
 

-      if (tcsetattr(0, TCSANOW, &d->tt) < 0)
+      if (d->tt_is_valid == true && tcsetattr(STDIN_FILENO, TCSANOW, &d->tt) < 0)

         _error->FatalE("tcsetattr", "Setting in Setup via TCSANOW for slave fd %d failed!", slaveFd);
    }
         _error->FatalE("tcsetattr", "Setting in Setup via TCSANOW for slave fd %d failed!", slaveFd);
    }

+
+   if (slaveFd != -1)
+      close(slaveFd);

 }
 void pkgDPkgPM::StopPtyMagic()
 {
    if (d->slave != NULL)
       free(d->slave);
    d->slave = NULL;
 }
 void pkgDPkgPM::StopPtyMagic()
 {
    if (d->slave != NULL)
       free(d->slave);
    d->slave = NULL;

+   if (d->protect_slave_from_dying != -1)
+   {
+      close(d->protect_slave_from_dying);
+      d->protect_slave_from_dying = -1;
+   }

    if(d->master >= 0) 
    {
    if(d->master >= 0) 
    {

-      if (tcsetattr(0, TCSAFLUSH, &d->tt) == -1)
+      if (d->tt_is_valid == true && tcsetattr(STDIN_FILENO, TCSAFLUSH, &d->tt) == -1)

         _error->FatalE("tcsetattr", "Setting in Stop via TCSAFLUSH for stdin failed!");
       close(d->master);
       d->master = -1;
         _error->FatalE("tcsetattr", "Setting in Stop via TCSAFLUSH for stdin failed!");
       close(d->master);
       d->master = -1;


@@ -1200,44 +1208,13 @@ bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)
    d->progress = progress;
 
    // Generate the base argument list for dpkg
    d->progress = progress;
 
    // Generate the base argument list for dpkg

-   unsigned long StartSize = 0;
-   std::vector<const char *> Args;
-   std::string DpkgExecutable = getDpkgExecutable();
-   Args.push_back(DpkgExecutable.c_str());
-   StartSize += DpkgExecutable.length();
-
-   // Stick in any custom dpkg options
-   Configuration::Item const *Opts = _config->Tree("DPkg::Options");
-   if (Opts != 0)
-   {
-      Opts = Opts->Child;
-      for (; Opts != 0; Opts = Opts->Next)
-      {
-        if (Opts->Value.empty() == true)
-           continue;
-        Args.push_back(Opts->Value.c_str());
-        StartSize += Opts->Value.length();
-      }
-   }
-
+   std::vector<std::string> const sArgs = debSystem::GetDpkgBaseCommand();
+   std::vector<const char *> Args(sArgs.size(), NULL);
+   std::transform(sArgs.begin(), sArgs.end(), Args.begin(),
+        [](std::string const &s) { return s.c_str(); });
+   unsigned long long const StartSize = std::accumulate(sArgs.begin(), sArgs.end(), 0llu,
+        [](unsigned long long const i, std::string const &s) { return i + s.length(); });

    size_t const BaseArgs = Args.size();
    size_t const BaseArgs = Args.size();

-   // we need to detect if we can qualify packages with the architecture or not
-   Args.push_back("--assert-multi-arch");
-   Args.push_back(NULL);
-
-   pid_t dpkgAssertMultiArch = ExecFork();
-   if (dpkgAssertMultiArch == 0)
-   {
-      dpkgChrootDirectory();
-      // redirect everything to the ultimate sink as we only need the exit-status
-      int const nullfd = open("/dev/null", O_RDONLY);
-      dup2(nullfd, STDIN_FILENO);
-      dup2(nullfd, STDOUT_FILENO);
-      dup2(nullfd, STDERR_FILENO);
-      execvp(Args[0], (char**) &Args[0]);
-      _error->WarningE("dpkgGo", "Can't detect if dpkg supports multi-arch!");
-      _exit(2);
-   }

 
    fd_set rfds;
    struct timespec tv;
 
    fd_set rfds;
    struct timespec tv;


@@ -1261,9 +1238,8 @@ bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)
 
    // support subpressing of triggers processing for special
    // cases like d-i that runs the triggers handling manually
 
    // support subpressing of triggers processing for special
    // cases like d-i that runs the triggers handling manually

-   bool const SmartConf = (_config->Find("PackageManager::Configure", "all") != "all");

    bool const TriggersPending = _config->FindB("DPkg::TriggersPending", false);
    bool const TriggersPending = _config->FindB("DPkg::TriggersPending", false);

-   if (_config->FindB("DPkg::ConfigurePending", SmartConf) == true)
+   if (_config->FindB("DPkg::ConfigurePending", true) == true)

       List.push_back(Item(Item::ConfigurePending, PkgIterator()));
 
    // for the progress
       List.push_back(Item(Item::ConfigurePending, PkgIterator()));
 
    // for the progress


@@ -1274,20 +1250,7 @@ bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)
    // create log
    OpenLog();
 
    // create log
    OpenLog();
 

-   bool dpkgMultiArch = false;
-   if (dpkgAssertMultiArch > 0)
-   {
-      int Status = 0;
-      while (waitpid(dpkgAssertMultiArch, &Status, 0) != dpkgAssertMultiArch)
-      {
-        if (errno == EINTR)
-           continue;
-        _error->WarningE("dpkgGo", _("Waited for %s but it wasn't there"), "dpkg --assert-multi-arch");
-        break;
-      }
-      if (WIFEXITED(Status) == true && WEXITSTATUS(Status) == 0)
-        dpkgMultiArch = true;
-   }
+   bool dpkgMultiArch = debSystem::SupportsMultiArch();

 
    // start pty magic before the loop
    StartPtyMagic();
 
    // start pty magic before the loop
    StartPtyMagic();


@@ -1465,6 +1428,10 @@ bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)
              a != Args.end(); ++a)
            clog << *a << ' ';
         clog << endl;
              a != Args.end(); ++a)
            clog << *a << ' ';
         clog << endl;

+        for (std::vector<char *>::const_iterator p = Packages.begin();
+              p != Packages.end(); ++p)
+           free(*p);
+        Packages.clear();

         continue;
       }
       Args.push_back(NULL);
         continue;
       }
       Args.push_back(NULL);


@@ -1500,7 +1467,7 @@ bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)
         SetupSlavePtyMagic();
         close(fd[0]); // close the read end of the pipe
 
         SetupSlavePtyMagic();
         close(fd[0]); // close the read end of the pipe
 

-        dpkgChrootDirectory();
+        debSystem::DpkgChrootDirectory();

 
         if (chdir(_config->FindDir("DPkg::Run-Directory","/").c_str()) != 0)
            _exit(100);
 
         if (chdir(_config->FindDir("DPkg::Run-Directory","/").c_str()) != 0)
            _exit(100);


@@ -1522,9 +1489,6 @@ bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)
               _exit(100);
         }
 
               _exit(100);
         }
 

-        /* No Job Control Stop Env is a magic dpkg var that prevents it
-           from using sigstop */
-        putenv((char *)"DPKG_NO_TSTP=yes");

         execvp(Args[0], (char**) &Args[0]);
         cerr << "Could not exec dpkg!" << endl;
         _exit(100);
         execvp(Args[0], (char**) &Args[0]);
         cerr << "Could not exec dpkg!" << endl;
         _exit(100);


@@ -1572,8 +1536,8 @@ bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)
 
         // wait for input or output here
         FD_ZERO(&rfds);
 
         // wait for input or output here
         FD_ZERO(&rfds);

-        if (d->master >= 0 && !d->stdin_is_dev_null)
-           FD_SET(0, &rfds); 
+        if (d->master >= 0 && d->direct_stdin == false && d->stdin_is_dev_null == false)
+           FD_SET(STDIN_FILENO, &rfds);

         FD_SET(_dpkgin, &rfds);
         if(d->master >= 0)
            FD_SET(d->master, &rfds);
         FD_SET(_dpkgin, &rfds);
         if(d->master >= 0)
            FD_SET(d->master, &rfds);


@@ -1644,7 +1608,7 @@ bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)
    {
       std::string const oldpkgcache = _config->FindFile("Dir::cache::pkgcache");
       if (oldpkgcache.empty() == false && RealFileExists(oldpkgcache) == true &&
    {
       std::string const oldpkgcache = _config->FindFile("Dir::cache::pkgcache");
       if (oldpkgcache.empty() == false && RealFileExists(oldpkgcache) == true &&

-         unlink(oldpkgcache.c_str()) == 0)
+         RemoveFile("pkgDPkgPM::Go", oldpkgcache))

       {
         std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
         if (srcpkgcache.empty() == false && RealFileExists(srcpkgcache) == true)
       {
         std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
         if (srcpkgcache.empty() == false && RealFileExists(srcpkgcache) == true)


@@ -1684,7 +1648,7 @@ void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
    if (apportPkg.end() == true || apportPkg->CurrentVer == 0)
       return;
 
    if (apportPkg.end() == true || apportPkg->CurrentVer == 0)
       return;
 

-   string pkgname, reportfile, srcpkgname, pkgver, arch;
+   string pkgname, reportfile, pkgver, arch;

    string::size_type pos;
    FILE *report;
 
    string::size_type pos;
    FILE *report;
 


@@ -1765,11 +1729,11 @@ void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
    if(pos != string::npos)
       pkgname = pkgname.substr(0, pos);
 
    if(pos != string::npos)
       pkgname = pkgname.substr(0, pos);
 

-   // find the package versin and source package name
+   // find the package version and source package name

    pkgCache::PkgIterator Pkg = Cache.FindPkg(pkgname);
    if (Pkg.end() == true)
       return;
    pkgCache::PkgIterator Pkg = Cache.FindPkg(pkgname);
    if (Pkg.end() == true)
       return;

-   pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg);
+   pkgCache::VerIterator Ver = Cache.GetCandidateVersion(Pkg);

    if (Ver.end() == true)
       return;
    pkgver = Ver.VerStr() == NULL ? "unknown" : Ver.VerStr();
    if (Ver.end() == true)
       return;
    pkgver = Ver.VerStr() == NULL ? "unknown" : Ver.VerStr();


@@ -1821,7 +1785,8 @@ void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
    fprintf(report, "ProblemType: Package\n");
    fprintf(report, "Architecture: %s\n", arch.c_str());
    time_t now = time(NULL);
    fprintf(report, "ProblemType: Package\n");
    fprintf(report, "Architecture: %s\n", arch.c_str());
    time_t now = time(NULL);

-   fprintf(report, "Date: %s" , ctime(&now));
+   char ctime_buf[26]; // need at least 26 bytes according to ctime(3)
+   fprintf(report, "Date: %s" , ctime_r(&now, ctime_buf));

    fprintf(report, "Package: %s %s\n", pkgname.c_str(), pkgver.c_str());
    fprintf(report, "SourcePackage: %s\n", Ver.SourcePkgName());
    fprintf(report, "ErrorMessage:\n %s\n", errormsg);
    fprintf(report, "Package: %s %s\n", pkgname.c_str(), pkgver.c_str());
    fprintf(report, "SourcePackage: %s\n", Ver.SourcePkgName());
    fprintf(report, "ErrorMessage:\n %s\n", errormsg);


@@ -1863,8 +1828,15 @@ void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
       }
    }
 
       }
    }
 

-   // log the ordering 
-   const char *ops_str[] = {"Install", "Configure","Remove","Purge"};
+   // log the ordering, see dpkgpm.h and the "Ops" enum there
+   const char *ops_str[] = {
+      "Install",
+      "Configure",
+      "Remove",
+      "Purge",
+      "ConfigurePending",
+      "TriggersPending",
+   };

    fprintf(report, "AptOrdering:\n");
    for (vector<Item>::iterator I = List.begin(); I != List.end(); ++I)
       if ((*I).Pkg != NULL)
    fprintf(report, "AptOrdering:\n");
    for (vector<Item>::iterator I = List.begin(); I != List.end(); ++I)
       if ((*I).Pkg != NULL)