move implementation of checksums around by abstracting even more

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

diff --git a/apt-pkg/deb/dpkgpm.cc b/apt-pkg/deb/dpkgpm.cc
index 08c95b7a4f9d9c7f5780639aa71126c69efa8334..019b72bb83e01d7af5066599cae5122518923af5 100644 (file)
--- a/apt-pkg/deb/dpkgpm.cc
+++ b/apt-pkg/deb/dpkgpm.cc
@@ -14,18 +14,26 @@
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/pkgrecords.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/pkgrecords.h>
 #include <apt-pkg/strutl.h>

+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/cachefile.h>

 
 #include <unistd.h>
 #include <stdlib.h>
 #include <fcntl.h>
 #include <sys/select.h>
 
 #include <unistd.h>
 #include <stdlib.h>
 #include <fcntl.h>
 #include <sys/select.h>

+#include <sys/stat.h>

 #include <sys/types.h>
 #include <sys/wait.h>
 #include <signal.h>
 #include <errno.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <signal.h>
 #include <errno.h>

+#include <string.h>

 #include <stdio.h>
 #include <stdio.h>

+#include <string.h>
+#include <algorithm>

 #include <sstream>
 #include <map>
 #include <sstream>
 #include <map>

+#include <pwd.h>
+#include <grp.h>

 
 #include <termios.h>
 #include <unistd.h>
 
 #include <termios.h>
 #include <unistd.h>


@@ -38,14 +46,88 @@
 
 using namespace std;
 
 
 using namespace std;
 

+class pkgDPkgPMPrivate 
+{
+public:
+   pkgDPkgPMPrivate() : dpkgbuf_pos(0), term_out(NULL), history_out(NULL)
+   {
+   }
+   bool stdin_is_dev_null;
+   // the buffer we use for the dpkg status-fd reading
+   char dpkgbuf[1024];
+   int dpkgbuf_pos;
+   FILE *term_out;
+   FILE *history_out;
+   string dpkg_error;
+};
+
+namespace
+{
+  // Maps the dpkg "processing" info to human readable names.  Entry 0
+  // of each array is the key, entry 1 is the value.
+  const std::pair<const char *, const char *> PackageProcessingOps[] = {
+    std::make_pair("install",   N_("Installing %s")),
+    std::make_pair("configure", N_("Configuring %s")),
+    std::make_pair("remove",    N_("Removing %s")),
+    std::make_pair("purge",    N_("Completely removing %s")),
+    std::make_pair("disappear", N_("Noting disappearance of %s")),
+    std::make_pair("trigproc",  N_("Running post-installation trigger %s"))
+  };
+
+  const std::pair<const char *, const char *> * const PackageProcessingOpsBegin = PackageProcessingOps;
+  const std::pair<const char *, const char *> * const PackageProcessingOpsEnd   = PackageProcessingOps + sizeof(PackageProcessingOps) / sizeof(PackageProcessingOps[0]);
+
+  // Predicate to test whether an entry in the PackageProcessingOps
+  // array matches a string.
+  class MatchProcessingOp
+  {
+    const char *target;
+
+  public:
+    MatchProcessingOp(const char *the_target)
+      : target(the_target)
+    {
+    }
+
+    bool operator()(const std::pair<const char *, const char *> &pair) const
+    {
+      return strcmp(pair.first, target) == 0;
+    }
+  };
+}

 
 

+/* helper function to ionice the given PID 
+
+ there is no C header for ionice yet - just the syscall interface
+ so we use the binary from util-linux
+*/
+static bool
+ionice(int PID)
+{
+   if (!FileExists("/usr/bin/ionice"))
+      return false;
+   pid_t Process = ExecFork();      
+   if (Process == 0)
+   {
+      char buf[32];
+      snprintf(buf, sizeof(buf), "-p%d", PID);
+      const char *Args[4];
+      Args[0] = "/usr/bin/ionice";
+      Args[1] = "-c3";
+      Args[2] = buf;
+      Args[3] = 0;
+      execv(Args[0], (char **)Args);
+   }
+   return ExecWait(Process, "ionice");
+}

 
 // DPkgPM::pkgDPkgPM - Constructor                                     /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 pkgDPkgPM::pkgDPkgPM(pkgDepCache *Cache) 
 
 // DPkgPM::pkgDPkgPM - Constructor                                     /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 pkgDPkgPM::pkgDPkgPM(pkgDepCache *Cache) 

-   : pkgPackageManager(Cache), dpkgbuf_pos(0), PackagesTotal(0), PackagesDone(0)
+   : pkgPackageManager(Cache), PackagesDone(0), PackagesTotal(0)

 {
 {

+   d = new pkgDPkgPMPrivate();

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


@@ -53,6 +135,7 @@ pkgDPkgPM::pkgDPkgPM(pkgDepCache *Cache)
 /* */
 pkgDPkgPM::~pkgDPkgPM()
 {
 /* */
 pkgDPkgPM::~pkgDPkgPM()
 {

+   delete d;

 }
                                                                        /*}}}*/
 // DPkgPM::Install - Install a package                                 /*{{{*/
 }
                                                                        /*}}}*/
 // DPkgPM::Install - Install a package                                 /*{{{*/


@@ -63,7 +146,19 @@ bool pkgDPkgPM::Install(PkgIterator Pkg,string File)
    if (File.empty() == true || Pkg.end() == true)
       return _error->Error("Internal Error, No file name for %s",Pkg.Name());
 
    if (File.empty() == true || Pkg.end() == true)
       return _error->Error("Internal Error, No file name for %s",Pkg.Name());
 

-   List.push_back(Item(Item::Install,Pkg,File));
+   // If the filename string begins with DPkg::Chroot-Directory, return the
+   // substr that is within the chroot so dpkg can access it.
+   string const chrootdir = _config->FindDir("DPkg::Chroot-Directory","/");
+   if (chrootdir != "/" && File.find(chrootdir) == 0)
+   {
+      size_t len = chrootdir.length();
+      if (chrootdir.at(len - 1) == '/')
+        len--;
+      List.push_back(Item(Item::Install,Pkg,File.substr(len)));
+   }
+   else
+      List.push_back(Item(Item::Install,Pkg,File));
+

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/


@@ -74,8 +169,14 @@ bool pkgDPkgPM::Configure(PkgIterator Pkg)
 {
    if (Pkg.end() == true)
       return false;
 {
    if (Pkg.end() == true)
       return false;

-   
-   List.push_back(Item(Item::Configure,Pkg));
+
+   List.push_back(Item(Item::Configure, Pkg));
+
+   // Use triggers for config calls if we configure "smart"
+   // as otherwise Pre-Depends will not be satisfied, see #526774
+   if (_config->FindB("DPkg::TriggersPending", false) == true)
+      List.push_back(Item(Item::TriggersPending, PkgIterator()));
+

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/


@@ -94,68 +195,6 @@ bool pkgDPkgPM::Remove(PkgIterator Pkg,bool Purge)
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

-// DPkgPM::RunScripts - Run a set of scripts                           /*{{{*/
-// ---------------------------------------------------------------------
-/* This looks for a list of script sto run from the configuration file,
-   each one is run with system from a forked child. */
-bool pkgDPkgPM::RunScripts(const char *Cnf)
-{
-   Configuration::Item const *Opts = _config->Tree(Cnf);
-   if (Opts == 0 || Opts->Child == 0)
-      return true;
-   Opts = Opts->Child;
-
-   // Fork for running the system calls
-   pid_t Child = ExecFork();
-   
-   // This is the child
-   if (Child == 0)
-   {
-      if (chdir("/tmp/") != 0)
-        _exit(100);
-        
-      unsigned int Count = 1;
-      for (; Opts != 0; Opts = Opts->Next, Count++)
-      {
-        if (Opts->Value.empty() == true)
-           continue;
-        
-        if (system(Opts->Value.c_str()) != 0)
-           _exit(100+Count);
-      }
-      _exit(0);
-   }      
-
-   // Wait for the child
-   int Status = 0;
-   while (waitpid(Child,&Status,0) != Child)
-   {
-      if (errno == EINTR)
-        continue;
-      return _error->Errno("waitpid","Couldn't wait for subprocess");
-   }
-
-   // Restore sig int/quit
-   signal(SIGQUIT,SIG_DFL);
-   signal(SIGINT,SIG_DFL);   
-
-   // Check for an error code.
-   if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
-   {
-      unsigned int Count = WEXITSTATUS(Status);
-      if (Count > 100)
-      {
-        Count -= 100;
-        for (; Opts != 0 && Count != 1; Opts = Opts->Next, Count--);
-        _error->Error("Problem executing scripts %s '%s'",Cnf,Opts->Value.c_str());
-      }
-      
-      return _error->Error("Sub-process returned an error code");
-   }
-   
-   return true;
-}
-                                                                        /*}}}*/

 // DPkgPM::SendV2Pkgs - Send version 2 package info                    /*{{{*/
 // ---------------------------------------------------------------------
 /* This is part of the helper script communication interface, it sends
 // DPkgPM::SendV2Pkgs - Send version 2 package info                    /*{{{*/
 // ---------------------------------------------------------------------
 /* This is part of the helper script communication interface, it sends


@@ -192,6 +231,9 @@ bool pkgDPkgPM::SendV2Pkgs(FILE *F)
    // Write out the package actions in order.
    for (vector<Item>::iterator I = List.begin(); I != List.end(); I++)
    {
    // Write out the package actions in order.
    for (vector<Item>::iterator I = List.begin(); I != List.end(); I++)
    {

+      if(I->Pkg.end() == true)
+        continue;
+

       pkgDepCache::StateCache &S = Cache[I->Pkg];
       
       fprintf(F,"%s ",I->Pkg.Name());
       pkgDepCache::StateCache &S = Cache[I->Pkg];
       
       fprintf(F,"%s ",I->Pkg.Name());


@@ -284,6 +326,15 @@ bool pkgDPkgPM::RunScriptsWithPkgs(const char *Cnf)
         SetCloseExec(STDIN_FILENO,false);      
         SetCloseExec(STDERR_FILENO,false);
 
         SetCloseExec(STDIN_FILENO,false);      
         SetCloseExec(STDERR_FILENO,false);
 

+        if (_config->FindDir("DPkg::Chroot-Directory","/") != "/") 
+        {
+           std::cerr << "Chrooting into " 
+                     << _config->FindDir("DPkg::Chroot-Directory") 
+                     << std::endl;
+           if (chroot(_config->FindDir("DPkg::Chroot-Directory","/").c_str()) != 0)
+              _exit(100);
+        }
+

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


@@ -298,7 +349,6 @@ bool pkgDPkgPM::RunScriptsWithPkgs(const char *Cnf)
         return _error->Errno("fdopen","Faild to open new FD");
       
       // Feed it the filenames.
         return _error->Errno("fdopen","Faild to open new FD");
       
       // Feed it the filenames.

-      bool Die = false;

       if (Version <= 1)
       {
         for (vector<Item>::iterator I = List.begin(); I != List.end(); I++)
       if (Version <= 1)
       {
         for (vector<Item>::iterator I = List.begin(); I != List.end(); I++)


@@ -315,14 +365,11 @@ bool pkgDPkgPM::RunScriptsWithPkgs(const char *Cnf)
               into the pipe. */
            fprintf(F,"%s\n",I->File.c_str());
            if (ferror(F) != 0)
               into the pipe. */
            fprintf(F,"%s\n",I->File.c_str());
            if (ferror(F) != 0)

-           {
-              Die = true;

               break;
               break;

-           }

         }
       }
       else
         }
       }
       else

-        Die = !SendV2Pkgs(F);
+        SendV2Pkgs(F);

 
       fclose(F);
       
 
       fclose(F);
       


@@ -333,7 +380,6 @@ bool pkgDPkgPM::RunScriptsWithPkgs(const char *Cnf)
 
    return true;
 }
 
    return true;
 }

-

                                                                        /*}}}*/
 // DPkgPM::DoStdin - Read stdin and pass to slave pty                  /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // DPkgPM::DoStdin - Read stdin and pass to slave pty                  /*{{{*/
 // ---------------------------------------------------------------------


@@ -341,9 +387,12 @@ bool pkgDPkgPM::RunScriptsWithPkgs(const char *Cnf)
 */
 void pkgDPkgPM::DoStdin(int master)
 {
 */
 void pkgDPkgPM::DoStdin(int master)
 {

-   char input_buf[256] = {0,}; 
-   int len = read(0, input_buf, sizeof(input_buf));
-   write(master, input_buf, len);
+   unsigned char input_buf[256] = {0,}; 
+   ssize_t len = read(0, input_buf, sizeof(input_buf));
+   if (len)
+      write(master, input_buf, len);
+   else
+      d->stdin_is_dev_null = true;

 }
                                                                        /*}}}*/
 // DPkgPM::DoTerminalPty - Read the terminal pty and write log         /*{{{*/
 }
                                                                        /*}}}*/
 // DPkgPM::DoTerminalPty - Read the terminal pty and write log         /*{{{*/


@@ -351,16 +400,25 @@ void pkgDPkgPM::DoStdin(int master)
 /*
  * read the terminal pty and write log
  */
 /*
  * read the terminal pty and write log
  */

-void pkgDPkgPM::DoTerminalPty(int master, FILE *term_out)
+void pkgDPkgPM::DoTerminalPty(int master)

 {
 {

-   char term_buf[1024] = {0,};
+   unsigned char term_buf[1024] = {0,0, };

 
 

-   int len=read(master, term_buf, sizeof(term_buf));
-   if(len <= 0)
+   ssize_t len=read(master, term_buf, sizeof(term_buf));
+   if(len == -1 && errno == EIO)
+   {
+      // this happens when the child is about to exit, we
+      // give it time to actually exit, otherwise we run
+      // into a race so we sleep for half a second.
+      struct timespec sleepfor = { 0, 500000000 };
+      nanosleep(&sleepfor, NULL);
+      return;
+   }  
+   if(len <= 0) 

       return;
    write(1, term_buf, len);
       return;
    write(1, term_buf, len);

-   if(term_out)
-      fwrite(term_buf, len, sizeof(char), term_out);
+   if(d->term_out)
+      fwrite(term_buf, len, sizeof(char), d->term_out);

 }
                                                                        /*}}}*/
 // DPkgPM::ProcessDpkgStatusBuf                                                /*{{{*/
 }
                                                                        /*}}}*/
 // DPkgPM::ProcessDpkgStatusBuf                                                /*{{{*/


@@ -369,10 +427,11 @@ void pkgDPkgPM::DoTerminalPty(int master, FILE *term_out)
  */
 void pkgDPkgPM::ProcessDpkgStatusLine(int OutStatusFd, char *line)
 {
  */
 void pkgDPkgPM::ProcessDpkgStatusLine(int OutStatusFd, char *line)
 {

+   bool const Debug = _config->FindB("Debug::pkgDPkgProgressReporting",false);

    // the status we output
    ostringstream status;
 
    // the status we output
    ostringstream status;
 

-   if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true)
+   if (Debug == true)

       std::clog << "got from dpkg '" << line << "'" << std::endl;
 
 
       std::clog << "got from dpkg '" << line << "'" << std::endl;
 
 


@@ -382,39 +441,88 @@ void pkgDPkgPM::ProcessDpkgStatusLine(int OutStatusFd, char *line)
       'status: /var/cache/apt/archives/krecipes_0.8.1-0ubuntu1_i386.deb : error : trying to overwrite `/usr/share/doc/kde/HTML/en/krecipes/krectip.png', which is also in package krecipes-data 
       and conffile-prompt like this
       'status: conffile-prompt: conffile : 'current-conffile' 'new-conffile' useredited distedited
       'status: /var/cache/apt/archives/krecipes_0.8.1-0ubuntu1_i386.deb : error : trying to overwrite `/usr/share/doc/kde/HTML/en/krecipes/krectip.png', which is also in package krecipes-data 
       and conffile-prompt like this
       'status: conffile-prompt: conffile : 'current-conffile' 'new-conffile' useredited distedited

+      
+      Newer versions of dpkg sent also:
+      'processing: install: pkg'
+      'processing: configure: pkg'
+      'processing: remove: pkg'
+      'processing: purge: pkg'
+      'processing: disappear: pkg'
+      'processing: trigproc: trigger'

            
    */
            
    */

-   char* list[5];
+   char* list[6];

    //        dpkg sends multiline error messages sometimes (see
    //        #374195 for a example. we should support this by
    //        either patching dpkg to not send multiline over the
    //        statusfd or by rewriting the code here to deal with
    //        it. for now we just ignore it and not crash
    TokSplitString(':', line, list, sizeof(list)/sizeof(list[0]));
    //        dpkg sends multiline error messages sometimes (see
    //        #374195 for a example. we should support this by
    //        either patching dpkg to not send multiline over the
    //        statusfd or by rewriting the code here to deal with
    //        it. for now we just ignore it and not crash
    TokSplitString(':', line, list, sizeof(list)/sizeof(list[0]));

-   char *pkg = list[1];
-   char *action = _strstrip(list[2]);
-   if( pkg == NULL || action == NULL) 
+   if( list[0] == NULL || list[1] == NULL || list[2] == NULL) 

    {
    {

-      if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true)
+      if (Debug == true)

         std::clog << "ignoring line: not enough ':'" << std::endl;
       return;
    }
         std::clog << "ignoring line: not enough ':'" << std::endl;
       return;
    }

+   const char* const pkg = list[1];
+   const char* action = _strstrip(list[2]);
+
+   // 'processing' from dpkg looks like
+   // 'processing: action: pkg'
+   if(strncmp(list[0], "processing", strlen("processing")) == 0)
+   {
+      char s[200];
+      const char* const pkg_or_trigger = _strstrip(list[2]);
+      action = _strstrip( list[1]);
+      const std::pair<const char *, const char *> * const iter =
+       std::find_if(PackageProcessingOpsBegin,
+                    PackageProcessingOpsEnd,
+                    MatchProcessingOp(action));
+      if(iter == PackageProcessingOpsEnd)
+      {
+        if (Debug == true)
+           std::clog << "ignoring unknown action: " << action << std::endl;
+        return;
+      }
+      snprintf(s, sizeof(s), _(iter->second), pkg_or_trigger);
+
+      status << "pmstatus:" << pkg_or_trigger
+            << ":"  << (PackagesDone/float(PackagesTotal)*100.0) 
+            << ":" << s
+            << endl;
+      if(OutStatusFd > 0)
+        write(OutStatusFd, status.str().c_str(), status.str().size());
+      if (Debug == true)
+        std::clog << "send: '" << status.str() << "'" << endl;
+
+      if (strncmp(action, "disappear", strlen("disappear")) == 0)
+        handleDisappearAction(pkg_or_trigger);
+      return;
+   }

 
    if(strncmp(action,"error",strlen("error")) == 0)
    {
 
    if(strncmp(action,"error",strlen("error")) == 0)
    {

+      // urgs, sometime has ":" in its error string so that we
+      // end up with the error message split between list[3]
+      // and list[4], e.g. the message: 
+      // "failed in buffer_write(fd) (10, ret=-1): backend dpkg-deb ..."
+      // concat them again
+      if( list[4] != NULL )
+        list[3][strlen(list[3])] = ':';
+

       status << "pmerror:" << list[1]
             << ":"  << (PackagesDone/float(PackagesTotal)*100.0) 
             << ":" << list[3]
             << endl;
       if(OutStatusFd > 0)
         write(OutStatusFd, status.str().c_str(), status.str().size());
       status << "pmerror:" << list[1]
             << ":"  << (PackagesDone/float(PackagesTotal)*100.0) 
             << ":" << list[3]
             << endl;
       if(OutStatusFd > 0)
         write(OutStatusFd, status.str().c_str(), status.str().size());

-      if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true)
+      if (Debug == true)

         std::clog << "send: '" << status.str() << "'" << endl;
       pkgFailures++;
       WriteApportReport(list[1], list[3]);
       return;
    }
         std::clog << "send: '" << status.str() << "'" << endl;
       pkgFailures++;
       WriteApportReport(list[1], list[3]);
       return;
    }

-   if(strncmp(action,"conffile",strlen("conffile")) == 0)
+   else if(strncmp(action,"conffile",strlen("conffile")) == 0)

    {
       status << "pmconffile:" << list[1]
             << ":"  << (PackagesDone/float(PackagesTotal)*100.0) 
    {
       status << "pmconffile:" << list[1]
             << ":"  << (PackagesDone/float(PackagesTotal)*100.0) 


@@ -422,12 +530,12 @@ void pkgDPkgPM::ProcessDpkgStatusLine(int OutStatusFd, char *line)
             << endl;
       if(OutStatusFd > 0)
         write(OutStatusFd, status.str().c_str(), status.str().size());
             << endl;
       if(OutStatusFd > 0)
         write(OutStatusFd, status.str().c_str(), status.str().size());

-      if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true)
+      if (Debug == true)

         std::clog << "send: '" << status.str() << "'" << endl;
       return;
    }
 
         std::clog << "send: '" << status.str() << "'" << endl;
       return;
    }
 

-   vector<struct DpkgState> &states = PackageOps[pkg];
+   vector<struct DpkgState> const &states = PackageOps[pkg];

    const char *next_action = NULL;
    if(PackageOpsDone[pkg] < states.size())
       next_action = states[PackageOpsDone[pkg]].state;
    const char *next_action = NULL;
    if(PackageOpsDone[pkg] < states.size())
       next_action = states[PackageOpsDone[pkg]].state;


@@ -450,15 +558,62 @@ void pkgDPkgPM::ProcessDpkgStatusLine(int OutStatusFd, char *line)
             << endl;
       if(OutStatusFd > 0)
         write(OutStatusFd, status.str().c_str(), status.str().size());
             << endl;
       if(OutStatusFd > 0)
         write(OutStatusFd, status.str().c_str(), status.str().size());

-      if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true)
+      if (Debug == true)

         std::clog << "send: '" << status.str() << "'" << endl;
    }
         std::clog << "send: '" << status.str() << "'" << endl;
    }

-   if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true) 
+   if (Debug == true) 

       std::clog << "(parsed from dpkg) pkg: " << pkg 
                << " action: " << action << endl;
 }
       std::clog << "(parsed from dpkg) pkg: " << pkg 
                << " action: " << action << endl;
 }

+                                                                       /*}}}*/
+// DPkgPM::handleDisappearAction                                       /*{{{*/
+void pkgDPkgPM::handleDisappearAction(string const &pkgname)
+{
+   // record the package name for display and stuff later
+   disappearedPkgs.insert(pkgname);

 
 

-// DPkgPM::DoDpkgStatusFd                                              /*{{{*/
+   pkgCache::PkgIterator Pkg = Cache.FindPkg(pkgname);
+   if (unlikely(Pkg.end() == true))
+      return;
+   // the disappeared package was auto-installed - nothing to do
+   if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
+      return;
+   pkgCache::VerIterator PkgVer = Cache[Pkg].InstVerIter(Cache);
+   if (unlikely(PkgVer.end() == true))
+      return;
+   /* search in the list of dependencies for (Pre)Depends,
+      check if this dependency has a Replaces on our package
+      and if so transfer the manual installed flag to it */
+   for (pkgCache::DepIterator Dep = PkgVer.DependsList(); Dep.end() != true; ++Dep)
+   {
+      if (Dep->Type != pkgCache::Dep::Depends &&
+         Dep->Type != pkgCache::Dep::PreDepends)
+        continue;
+      pkgCache::PkgIterator Tar = Dep.TargetPkg();
+      if (unlikely(Tar.end() == true))
+        continue;
+      // the package is already marked as manual
+      if ((Cache[Tar].Flags & pkgCache::Flag::Auto) != pkgCache::Flag::Auto)
+        continue;
+      pkgCache::VerIterator TarVer =  Cache[Tar].InstVerIter(Cache);
+      if (TarVer.end() == true)
+        continue;
+      for (pkgCache::DepIterator Rep = TarVer.DependsList(); Rep.end() != true; ++Rep)
+      {
+        if (Rep->Type != pkgCache::Dep::Replaces)
+           continue;
+        if (Pkg != Rep.TargetPkg())
+           continue;
+        // okay, they are strongly connected - transfer manual-bit
+        if (Debug == true)
+           std::clog << "transfer manual-bit from disappeared »" << pkgname << "« to »" << Tar.FullName() << "«" << std::endl;
+        Cache[Tar].Flags &= ~Flag::Auto;
+        break;
+      }
+   }
+}
+                                                                       /*}}}*/
+// DPkgPM::DoDpkgStatusFd                                              /*{{{*/

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


@@ -467,14 +622,14 @@ void pkgDPkgPM::DoDpkgStatusFd(int statusfd, int OutStatusFd)
    char *p, *q;
    int len;
 
    char *p, *q;
    int len;
 

-   len=read(statusfd, &dpkgbuf[dpkgbuf_pos], sizeof(dpkgbuf)-dpkgbuf_pos);
-   dpkgbuf_pos += len;
+   len=read(statusfd, &d->dpkgbuf[d->dpkgbuf_pos], sizeof(d->dpkgbuf)-d->dpkgbuf_pos);
+   d->dpkgbuf_pos += len;

    if(len <= 0)
       return;
 
    // process line by line if we have a buffer
    if(len <= 0)
       return;
 
    // process line by line if we have a buffer

-   p = q = dpkgbuf;
-   while((q=(char*)memchr(p, '\n', dpkgbuf+dpkgbuf_pos-p)) != NULL)
+   p = q = d->dpkgbuf;
+   while((q=(char*)memchr(p, '\n', d->dpkgbuf+d->dpkgbuf_pos-p)) != NULL)

    {
       *q = 0;
       ProcessDpkgStatusLine(OutStatusFd, p);
    {
       *q = 0;
       ProcessDpkgStatusLine(OutStatusFd, p);


@@ -482,8 +637,8 @@ void pkgDPkgPM::DoDpkgStatusFd(int statusfd, int OutStatusFd)
    }
 
    // now move the unprocessed bits (after the final \n that is now a 0x0) 
    }
 
    // now move the unprocessed bits (after the final \n that is now a 0x0) 

-   // to the start and update dpkgbuf_pos
-   p = (char*)memrchr(dpkgbuf, 0, dpkgbuf_pos);
+   // to the start and update d->dpkgbuf_pos
+   p = (char*)memrchr(d->dpkgbuf, 0, d->dpkgbuf_pos);

    if(p == NULL)
       return;
 
    if(p == NULL)
       return;
 


@@ -491,12 +646,176 @@ void pkgDPkgPM::DoDpkgStatusFd(int statusfd, int OutStatusFd)
    p++;
 
    // move the unprocessed tail to the start and update pos
    p++;
 
    // move the unprocessed tail to the start and update pos

-   memmove(dpkgbuf, p, p-dpkgbuf);
-   dpkgbuf_pos = dpkgbuf+dpkgbuf_pos-p;
+   memmove(d->dpkgbuf, p, p-d->dpkgbuf);
+   d->dpkgbuf_pos = d->dpkgbuf+d->dpkgbuf_pos-p;

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

+// DPkgPM::WriteHistoryTag                                             /*{{{*/
+void pkgDPkgPM::WriteHistoryTag(string const &tag, string value)
+{
+   size_t const length = value.length();
+   if (length == 0)
+      return;
+   // poor mans rstrip(", ")
+   if (value[length-2] == ',' && value[length-1] == ' ')
+      value.erase(length - 2, 2);
+   fprintf(d->history_out, "%s: %s\n", tag.c_str(), value.c_str());
+}                                                                      /*}}}*/
+// DPkgPM::OpenLog                                                     /*{{{*/
+bool pkgDPkgPM::OpenLog()
+{
+   string const logdir = _config->FindDir("Dir::Log");
+   if(CreateAPTDirectoryIfNeeded(logdir, logdir) == false)
+      // FIXME: use a better string after freeze
+      return _error->Error(_("Directory '%s' missing"), logdir.c_str());
+
+   // get current time
+   char timestr[200];
+   time_t const t = time(NULL);
+   struct tm const * const tmp = localtime(&t);
+   strftime(timestr, sizeof(timestr), "%F  %T", tmp);

 
 

+   // open terminal log
+   string const logfile_name = flCombine(logdir,
+                                  _config->Find("Dir::Log::Terminal"));
+   if (!logfile_name.empty())
+   {
+      d->term_out = fopen(logfile_name.c_str(),"a");
+      if (d->term_out == NULL)
+        return _error->WarningE("OpenLog", _("Could not open file '%s'"), logfile_name.c_str());
+      setvbuf(d->term_out, NULL, _IONBF, 0);
+      SetCloseExec(fileno(d->term_out), true);
+      struct passwd *pw;
+      struct group *gr;
+      pw = getpwnam("root");
+      gr = getgrnam("adm");
+      if (pw != NULL && gr != NULL)
+         chown(logfile_name.c_str(), pw->pw_uid, gr->gr_gid);
+      chmod(logfile_name.c_str(), 0644);
+      fprintf(d->term_out, "\nLog started: %s\n", timestr);
+   }

 
 

+   // write your history
+   string const history_name = flCombine(logdir,
+                                  _config->Find("Dir::Log::History"));
+   if (!history_name.empty())
+   {
+      d->history_out = fopen(history_name.c_str(),"a");
+      if (d->history_out == NULL)
+        return _error->WarningE("OpenLog", _("Could not open file '%s'"), history_name.c_str());
+      chmod(history_name.c_str(), 0644);
+      fprintf(d->history_out, "\nStart-Date: %s\n", timestr);
+      string remove, purge, install, reinstall, upgrade, downgrade;
+      for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
+      {
+        enum { CANDIDATE, CANDIDATE_AUTO, CURRENT_CANDIDATE, CURRENT } infostring;
+        string *line = NULL;
+        #define HISTORYINFO(X, Y) { line = &X; infostring = Y; }
+        if (Cache[I].NewInstall() == true)
+           HISTORYINFO(install, CANDIDATE_AUTO)
+        else if (Cache[I].ReInstall() == true)
+           HISTORYINFO(reinstall, CANDIDATE)
+        else if (Cache[I].Upgrade() == true)
+           HISTORYINFO(upgrade, CURRENT_CANDIDATE)
+        else if (Cache[I].Downgrade() == true)
+           HISTORYINFO(downgrade, CURRENT_CANDIDATE)
+        else if (Cache[I].Delete() == true)
+           HISTORYINFO((Cache[I].Purge() ? purge : remove), CURRENT)
+        else
+           continue;
+        #undef HISTORYINFO
+        line->append(I.FullName(false)).append(" (");
+        switch (infostring) {
+        case CANDIDATE: line->append(Cache[I].CandVersion); break;
+        case CANDIDATE_AUTO:
+           line->append(Cache[I].CandVersion);
+           if ((Cache[I].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
+              line->append(", automatic");
+           break;
+        case CURRENT_CANDIDATE: line->append(Cache[I].CurVersion).append(", ").append(Cache[I].CandVersion); break;
+        case CURRENT: line->append(Cache[I].CurVersion); break;
+        }
+        line->append("), ");
+      }
+      if (_config->Exists("Commandline::AsString") == true)
+        WriteHistoryTag("Commandline", _config->Find("Commandline::AsString"));
+      WriteHistoryTag("Install", install);
+      WriteHistoryTag("Reinstall", reinstall);
+      WriteHistoryTag("Upgrade", upgrade);
+      WriteHistoryTag("Downgrade",downgrade);
+      WriteHistoryTag("Remove",remove);
+      WriteHistoryTag("Purge",purge);
+      fflush(d->history_out);
+   }
+   
+   return true;
+}
+                                                                       /*}}}*/
+// DPkg::CloseLog                                                      /*{{{*/
+bool pkgDPkgPM::CloseLog()
+{
+   char timestr[200];
+   time_t t = time(NULL);
+   struct tm *tmp = localtime(&t);
+   strftime(timestr, sizeof(timestr), "%F  %T", tmp);
+
+   if(d->term_out)
+   {
+      fprintf(d->term_out, "Log ended: ");
+      fprintf(d->term_out, "%s", timestr);
+      fprintf(d->term_out, "\n");
+      fclose(d->term_out);
+   }
+   d->term_out = NULL;
+
+   if(d->history_out)
+   {
+      if (disappearedPkgs.empty() == false)
+      {
+        string disappear;
+        for (std::set<std::string>::const_iterator d = disappearedPkgs.begin();
+             d != disappearedPkgs.end(); ++d)
+        {
+           pkgCache::PkgIterator P = Cache.FindPkg(*d);
+           disappear.append(*d);
+           if (P.end() == true)
+              disappear.append(", ");
+           else
+              disappear.append(" (").append(Cache[P].CurVersion).append("), ");
+        }
+        WriteHistoryTag("Disappeared", disappear);
+      }
+      if (d->dpkg_error.empty() == false)
+        fprintf(d->history_out, "Error: %s\n", d->dpkg_error.c_str());
+      fprintf(d->history_out, "End-Date: %s\n", timestr);
+      fclose(d->history_out);
+   }
+   d->history_out = NULL;
+
+   return true;
+}
+                                                                       /*}}}*/
+/*{{{*/
+// This implements a racy version of pselect for those architectures
+// that don't have a working implementation.
+// FIXME: Probably can be removed on Lenny+1
+static int racy_pselect(int nfds, fd_set *readfds, fd_set *writefds,
+   fd_set *exceptfds, const struct timespec *timeout,
+   const sigset_t *sigmask)
+{
+   sigset_t origmask;
+   struct timeval tv;
+   int retval;
+
+   tv.tv_sec = timeout->tv_sec;
+   tv.tv_usec = timeout->tv_nsec/1000;
+
+   sigprocmask(SIG_SETMASK, sigmask, &origmask);
+   retval = select(nfds, readfds, writefds, exceptfds, &tv);
+   sigprocmask(SIG_SETMASK, &origmask, 0);
+   return retval;
+}
+/*}}}*/

 // DPkgPM::Go - Run the sequence                                       /*{{{*/
 // ---------------------------------------------------------------------
 /* This globs the operations and calls dpkg 
 // DPkgPM::Go - Run the sequence                                       /*{{{*/
 // ---------------------------------------------------------------------
 /* This globs the operations and calls dpkg 


@@ -508,18 +827,31 @@ void pkgDPkgPM::DoDpkgStatusFd(int statusfd, int OutStatusFd)
 */
 bool pkgDPkgPM::Go(int OutStatusFd)
 {
 */
 bool pkgDPkgPM::Go(int OutStatusFd)
 {

-   unsigned int MaxArgs = _config->FindI("Dpkg::MaxArgs",8*1024);   
-   unsigned int MaxArgBytes = _config->FindI("Dpkg::MaxArgBytes",32*1024);
+   fd_set rfds;
+   struct timespec tv;
+   sigset_t sigmask;
+   sigset_t original_sigmask;
+
+   unsigned int const MaxArgs = _config->FindI("Dpkg::MaxArgs",8*1024);
+   unsigned int const MaxArgBytes = _config->FindI("Dpkg::MaxArgBytes",32*1024);
+   bool const NoTriggers = _config->FindB("DPkg::NoTriggers", false);

 
    if (RunScripts("DPkg::Pre-Invoke") == false)
       return false;
 
    if (RunScriptsWithPkgs("DPkg::Pre-Install-Pkgs") == false)
       return false;
 
    if (RunScripts("DPkg::Pre-Invoke") == false)
       return false;
 
    if (RunScriptsWithPkgs("DPkg::Pre-Install-Pkgs") == false)
       return false;

-   
+
+   // 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);
+   if (_config->FindB("DPkg::ConfigurePending", SmartConf) == true)
+      List.push_back(Item(Item::ConfigurePending, PkgIterator()));
+

    // map the dpkg states to the operations that are performed
    // (this is sorted in the same way as Item::Ops)
    // map the dpkg states to the operations that are performed
    // (this is sorted in the same way as Item::Ops)

-   static const struct DpkgState DpkgStatesOpMap[][5] = {
+   static const struct DpkgState DpkgStatesOpMap[][7] = {

       // Install operation
       { 
         {"half-installed", N_("Preparing %s")}, 
       // Install operation
       { 
         {"half-installed", N_("Preparing %s")}, 


@@ -552,52 +884,65 @@ bool pkgDPkgPM::Go(int OutStatusFd)
    // that will be [installed|configured|removed|purged] and add
    // them to the PackageOps map (the dpkg states it goes through)
    // and the PackageOpsTranslations (human readable strings)
    // that will be [installed|configured|removed|purged] and add
    // them to the PackageOps map (the dpkg states it goes through)
    // and the PackageOpsTranslations (human readable strings)

-   for (vector<Item>::iterator I = List.begin(); I != List.end();I++)
+   for (vector<Item>::const_iterator I = List.begin(); I != List.end();I++)

    {
    {

-      string name = (*I).Pkg.Name();
+      if((*I).Pkg.end() == true)
+        continue;
+
+      string const name = (*I).Pkg.Name();

       PackageOpsDone[name] = 0;
       for(int i=0; (DpkgStatesOpMap[(*I).Op][i]).state != NULL;  i++) 
       {
         PackageOps[name].push_back(DpkgStatesOpMap[(*I).Op][i]);
         PackagesTotal++;
       }
       PackageOpsDone[name] = 0;
       for(int i=0; (DpkgStatesOpMap[(*I).Op][i]).state != NULL;  i++) 
       {
         PackageOps[name].push_back(DpkgStatesOpMap[(*I).Op][i]);
         PackagesTotal++;
       }

-   }   
+   }
+
+   d->stdin_is_dev_null = false;

 
    // create log
 
    // create log

-   string logdir = _config->FindDir("Dir::Log");
-   if(not FileExists(logdir))
-      return _error->Error(_("Directory '%s' missing"), logdir.c_str());
-   string logfile_name = flCombine(logdir,
-                                  _config->Find("Dir::Log::Terminal"));
-   FILE *term_out = NULL;
-   if (!logfile_name.empty())
-   {
-      term_out = fopen(logfile_name.c_str(),"a");
-      chmod(logfile_name.c_str(), 0600);
-      // output current time
-      char outstr[200];
-      time_t t = time(NULL);
-      struct tm *tmp = localtime(&t);
-      strftime(outstr, sizeof(outstr), "%F  %T", tmp);
-      fprintf(term_out, "\nLog started: ");
-      fprintf(term_out, outstr);
-      fprintf(term_out, "\n");
-   }
+   OpenLog();

 
    // this loop is runs once per operation
 
    // this loop is runs once per operation

-   for (vector<Item>::iterator I = List.begin(); I != List.end();)
+   for (vector<Item>::const_iterator I = List.begin(); I != List.end();)

    {
    {

-      vector<Item>::iterator J = I;
-      for (; J != List.end() && J->Op == I->Op; J++);
+      // Do all actions with the same Op in one run
+      vector<Item>::const_iterator J = I;
+      if (TriggersPending == true)
+        for (; J != List.end(); J++)
+        {
+           if (J->Op == I->Op)
+              continue;
+           if (J->Op != Item::TriggersPending)
+              break;
+           vector<Item>::const_iterator T = J + 1;
+           if (T != List.end() && T->Op == I->Op)
+              continue;
+           break;
+        }
+      else
+        for (; J != List.end() && J->Op == I->Op; J++)
+           /* nothing */;

 
       // Generate the argument list
       const char *Args[MaxArgs + 50];
 
       // Generate the argument list
       const char *Args[MaxArgs + 50];

+      // keep track of allocated strings for multiarch package names
+      char *Packages[MaxArgs + 50];
+      unsigned int pkgcount = 0;
+
+      // Now check if we are within the MaxArgs limit
+      //
+      // this code below is problematic, because it may happen that
+      // the argument list is split in a way that A depends on B
+      // and they are in the same "--configure A B" run
+      // - with the split they may now be configured in different
+      //   runs 

       if (J - I > (signed)MaxArgs)
         J = I + MaxArgs;
       
       unsigned int n = 0;
       unsigned long Size = 0;
       if (J - I > (signed)MaxArgs)
         J = I + MaxArgs;
       
       unsigned int n = 0;
       unsigned long Size = 0;

-      string Tmp = _config->Find("Dir::Bin::dpkg","dpkg");
+      string const Tmp = _config->Find("Dir::Bin::dpkg","dpkg");

       Args[n++] = Tmp.c_str();
       Size += strlen(Args[n-1]);
       
       Args[n++] = Tmp.c_str();
       Size += strlen(Args[n-1]);
       


@@ -649,7 +994,21 @@ bool pkgDPkgPM::Go(int OutStatusFd)
         Args[n++] = "--configure";
         Size += strlen(Args[n-1]);
         break;
         Args[n++] = "--configure";
         Size += strlen(Args[n-1]);
         break;

-        
+
+        case Item::ConfigurePending:
+        Args[n++] = "--configure";
+        Size += strlen(Args[n-1]);
+        Args[n++] = "--pending";
+        Size += strlen(Args[n-1]);
+        break;
+
+        case Item::TriggersPending:
+        Args[n++] = "--triggers-only";
+        Size += strlen(Args[n-1]);
+        Args[n++] = "--pending";
+        Size += strlen(Args[n-1]);
+        break;
+

         case Item::Install:
         Args[n++] = "--unpack";
         Size += strlen(Args[n-1]);
         case Item::Install:
         Args[n++] = "--unpack";
         Size += strlen(Args[n-1]);


@@ -657,7 +1016,14 @@ bool pkgDPkgPM::Go(int OutStatusFd)
         Size += strlen(Args[n-1]);
         break;
       }
         Size += strlen(Args[n-1]);
         break;
       }

-      
+
+      if (NoTriggers == true && I->Op != Item::TriggersPending &&
+         I->Op != Item::ConfigurePending)
+      {
+        Args[n++] = "--no-triggers";
+        Size += strlen(Args[n-1]);
+      }
+

       // Write in the file or package names
       if (I->Op == Item::Install)
       {
       // Write in the file or package names
       if (I->Op == Item::Install)
       {


@@ -671,12 +1037,27 @@ bool pkgDPkgPM::Go(int OutStatusFd)
       }      
       else
       {
       }      
       else
       {

+        string const nativeArch = _config->Find("APT::Architecture");
+        unsigned long const oldSize = I->Op == Item::Configure ? Size : 0;

         for (;I != J && Size < MaxArgBytes; I++)
         {
         for (;I != J && Size < MaxArgBytes; I++)
         {

-           Args[n++] = I->Pkg.Name();
+           if((*I).Pkg.end() == true)
+              continue;
+           if (I->Op == Item::Configure && disappearedPkgs.find(I->Pkg.Name()) != disappearedPkgs.end())
+              continue;
+           if (I->Pkg.Arch() == nativeArch || !strcmp(I->Pkg.Arch(), "all"))
+              Args[n++] = I->Pkg.Name();
+           else
+           {
+              Packages[pkgcount] = strdup(I->Pkg.FullName(false).c_str());
+              Args[n++] = Packages[pkgcount++];
+           }

            Size += strlen(Args[n-1]);
            Size += strlen(Args[n-1]);

-        }       
-      }      
+        }
+        // skip configure action if all sheduled packages disappeared
+        if (oldSize == Size)
+           continue;
+      }

       Args[n] = 0;
       J = I;
       
       Args[n] = 0;
       J = I;
       


@@ -699,42 +1080,82 @@ bool pkgDPkgPM::Go(int OutStatusFd)
       sighandler_t old_SIGQUIT = signal(SIGQUIT,SIG_IGN);
       sighandler_t old_SIGINT = signal(SIGINT,SIG_IGN);
 
       sighandler_t old_SIGQUIT = signal(SIGQUIT,SIG_IGN);
       sighandler_t old_SIGINT = signal(SIGINT,SIG_IGN);
 

+      // ignore SIGHUP as well (debian #463030)
+      sighandler_t old_SIGHUP = signal(SIGHUP,SIG_IGN);
+

       struct   termios tt;
       struct   winsize win;
       struct   termios tt;
       struct   winsize win;

-      int      master;
-      int      slave;
+      int      master = -1;
+      int      slave = -1;

 
 

-      // FIXME: setup sensible signal handling (*ick*)
-      tcgetattr(0, &tt);
-      ioctl(0, TIOCGWINSZ, (char *)&win);
-      if (openpty(&master, &slave, NULL, &tt, &win) < 0) 
+      // if tcgetattr does not return zero there was a error
+      // and we do not do any pty magic
+      if (tcgetattr(0, &tt) == 0)

       {
       {

-        fprintf(stderr, _("openpty failed\n"));
+        ioctl(0, TIOCGWINSZ, (char *)&win);
+        if (openpty(&master, &slave, NULL, &tt, &win) < 0) 
+        {
+           const char *s = _("Can not write log, openpty() "
+                             "failed (/dev/pts not mounted?)\n");
+           fprintf(stderr, "%s",s);
+            if(d->term_out)
+              fprintf(d->term_out, "%s",s);
+           master = slave = -1;
+        }  else {
+           struct termios rtt;
+           rtt = tt;
+           cfmakeraw(&rtt);
+           rtt.c_lflag &= ~ECHO;
+           rtt.c_lflag |= ISIG;
+           // block SIGTTOU during tcsetattr to prevent a hang if
+           // the process is a member of the background process group
+           // http://www.opengroup.org/onlinepubs/000095399/functions/tcsetattr.html
+           sigemptyset(&sigmask);
+           sigaddset(&sigmask, SIGTTOU);
+           sigprocmask(SIG_BLOCK,&sigmask, &original_sigmask);
+           tcsetattr(0, TCSAFLUSH, &rtt);
+           sigprocmask(SIG_SETMASK, &original_sigmask, 0);
+        }

       }
 
       }
 

-      struct termios rtt;
-      rtt = tt;
-      cfmakeraw(&rtt);
-      rtt.c_lflag &= ~ECHO;
-      tcsetattr(0, TCSAFLUSH, &rtt);
-

        // Fork dpkg
       pid_t Child;
       _config->Set("APT::Keep-Fds::",fd[1]);
        // Fork dpkg
       pid_t Child;
       _config->Set("APT::Keep-Fds::",fd[1]);

+      // send status information that we are about to fork dpkg
+      if(OutStatusFd > 0) {
+        ostringstream status;
+        status << "pmstatus:dpkg-exec:" 
+               << (PackagesDone/float(PackagesTotal)*100.0) 
+               << ":" << _("Running dpkg")
+               << endl;
+        write(OutStatusFd, status.str().c_str(), status.str().size());
+      }

       Child = ExecFork();
             
       // This is the child
       if (Child == 0)
       {
       Child = ExecFork();
             
       // This is the child
       if (Child == 0)
       {

-        setsid();
-        ioctl(slave, TIOCSCTTY, 0);
-        close(master);
-        dup2(slave, 0);
-        dup2(slave, 1);
-        dup2(slave, 2);
-        close(slave);
+        if(slave >= 0 && master >= 0) 
+        {
+           setsid();
+           ioctl(slave, TIOCSCTTY, 0);
+           close(master);
+           dup2(slave, 0);
+           dup2(slave, 1);
+           dup2(slave, 2);
+           close(slave);
+        }

         close(fd[0]); // close the read end of the pipe
 
         close(fd[0]); // close the read end of the pipe
 

+        if (_config->FindDir("DPkg::Chroot-Directory","/") != "/") 
+        {
+           std::cerr << "Chrooting into " 
+                     << _config->FindDir("DPkg::Chroot-Directory") 
+                     << std::endl;
+           if (chroot(_config->FindDir("DPkg::Chroot-Directory","/").c_str()) != 0)
+              _exit(100);
+        }
+

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


@@ -754,15 +1175,18 @@ bool pkgDPkgPM::Go(int OutStatusFd)
               _exit(100);
         }
 
               _exit(100);
         }
 

-

         /* No Job Control Stop Env is a magic dpkg var that prevents it
            from using sigstop */
         /* No Job Control Stop Env is a magic dpkg var that prevents it
            from using sigstop */

-        putenv("DPKG_NO_TSTP=yes");
+        putenv((char *)"DPKG_NO_TSTP=yes");

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

+      // apply ionice
+      if (_config->FindB("DPkg::UseIoNice", false) == true)
+        ionice(Child);
+

       // clear the Keep-Fd again
       _config->Clear("APT::Keep-Fds",fd[1]);
 
       // clear the Keep-Fd again
       _config->Clear("APT::Keep-Fds",fd[1]);
 


@@ -770,19 +1194,23 @@ bool pkgDPkgPM::Go(int OutStatusFd)
       int Status = 0;
 
       // we read from dpkg here
       int Status = 0;
 
       // we read from dpkg here

-      int _dpkgin = fd[0];
+      int const _dpkgin = fd[0];

       close(fd[1]);                        // close the write end of the pipe
 
       close(fd[1]);                        // close the write end of the pipe
 

-      // the read buffers for the communication with dpkg
-      char buf[2] = {0,0};
-      
-      // the result of the waitpid call
-      int res;
-      close(slave);
+      if(slave > 0)
+        close(slave);

 
       // setups fds
 
       // setups fds

-      fd_set rfds;
-      struct timeval tv;
+      sigemptyset(&sigmask);
+      sigprocmask(SIG_BLOCK,&sigmask,&original_sigmask);
+
+      /* clean up the temporary allocation for multiarch package names in
+         the parent, so we don't leak memory when we return. */
+      for (unsigned int i = 0; i < pkgcount; i++)
+        free(Packages[i]);
+
+      // the result of the waitpid call
+      int res;

       int select_ret;
       while ((res=waitpid(Child,&Status, WNOHANG)) != Child) {
         if(res < 0) {
       int select_ret;
       while ((res=waitpid(Child,&Status, WNOHANG)) != Child) {
         if(res < 0) {


@@ -795,25 +1223,37 @@ bool pkgDPkgPM::Go(int OutStatusFd)
            // Restore sig int/quit
            signal(SIGQUIT,old_SIGQUIT);
            signal(SIGINT,old_SIGINT);
            // Restore sig int/quit
            signal(SIGQUIT,old_SIGQUIT);
            signal(SIGINT,old_SIGINT);

+           signal(SIGHUP,old_SIGHUP);

            return _error->Errno("waitpid","Couldn't wait for subprocess");
         }
 
         // wait for input or output here
         FD_ZERO(&rfds);
            return _error->Errno("waitpid","Couldn't wait for subprocess");
         }
 
         // wait for input or output here
         FD_ZERO(&rfds);

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

         FD_SET(_dpkgin, &rfds);
         FD_SET(_dpkgin, &rfds);

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

         tv.tv_sec = 1;
         tv.tv_sec = 1;

-        tv.tv_usec = 0;
-        select_ret = select(max(master, _dpkgin)+1, &rfds, NULL, NULL, &tv);
-        if (select_ret < 0)
-           std::cerr << "Error in select()" << std::endl;
-        else if (select_ret == 0)
-           continue;
-
-        if(FD_ISSET(master, &rfds))
-           DoTerminalPty(master, term_out);
-        if(FD_ISSET(0, &rfds))
+        tv.tv_nsec = 0;
+        select_ret = pselect(max(master, _dpkgin)+1, &rfds, NULL, NULL, 
+                             &tv, &original_sigmask);
+        if (select_ret < 0 && (errno == EINVAL || errno == ENOSYS))
+           select_ret = racy_pselect(max(master, _dpkgin)+1, &rfds, NULL,
+                                     NULL, &tv, &original_sigmask);
+        if (select_ret == 0) 
+           continue;
+        else if (select_ret < 0 && errno == EINTR)
+           continue;
+        else if (select_ret < 0) 
+        {
+           perror("select() returned error");
+           continue;
+        } 
+        
+        if(master >= 0 && FD_ISSET(master, &rfds))
+           DoTerminalPty(master);
+        if(master >= 0 && FD_ISSET(0, &rfds))

            DoStdin(master);
         if(FD_ISSET(_dpkgin, &rfds))
            DoDpkgStatusFd(_dpkgin, OutStatusFd);
            DoStdin(master);
         if(FD_ISSET(_dpkgin, &rfds))
            DoDpkgStatusFd(_dpkgin, OutStatusFd);


@@ -823,8 +1263,13 @@ bool pkgDPkgPM::Go(int OutStatusFd)
       // Restore sig int/quit
       signal(SIGQUIT,old_SIGQUIT);
       signal(SIGINT,old_SIGINT);
       // Restore sig int/quit
       signal(SIGQUIT,old_SIGQUIT);
       signal(SIGINT,old_SIGINT);

+      signal(SIGHUP,old_SIGHUP);

 
 

-      tcsetattr(0, TCSAFLUSH, &tt);
+      if(master >= 0) 
+      {
+        tcsetattr(0, TCSAFLUSH, &tt);
+        close(master);
+      }

        
       // Check for an error code.
       if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
        
       // Check for an error code.
       if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)


@@ -832,31 +1277,51 @@ bool pkgDPkgPM::Go(int OutStatusFd)
         // if it was set to "keep-dpkg-runing" then we won't return
         // here but keep the loop going and just report it as a error
         // for later
         // if it was set to "keep-dpkg-runing" then we won't return
         // here but keep the loop going and just report it as a error
         // for later

-        bool stopOnError = _config->FindB("Dpkg::StopOnError",true);
+        bool const stopOnError = _config->FindB("Dpkg::StopOnError",true);

         
         if(stopOnError)
            RunScripts("DPkg::Post-Invoke");
 
         if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV) 
         
         if(stopOnError)
            RunScripts("DPkg::Post-Invoke");
 
         if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV) 

-           _error->Error("Sub-process %s received a segmentation fault.",Args[0]);
+           strprintf(d->dpkg_error, "Sub-process %s received a segmentation fault.",Args[0]);

         else if (WIFEXITED(Status) != 0)
         else if (WIFEXITED(Status) != 0)

-           _error->Error("Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status));
+           strprintf(d->dpkg_error, "Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status));

         else 
         else 

-           _error->Error("Sub-process %s exited unexpectedly",Args[0]);
+           strprintf(d->dpkg_error, "Sub-process %s exited unexpectedly",Args[0]);
+
+        if(d->dpkg_error.size() > 0)
+           _error->Error("%s", d->dpkg_error.c_str());

 
         if(stopOnError) 
         {
 
         if(stopOnError) 
         {

-           if(term_out)
-              fclose(term_out);
+           CloseLog();

            return false;
         }
       }      
    }
            return false;
         }
       }      
    }

-   if(term_out)
-      fclose(term_out);
+   CloseLog();

 
    if (RunScripts("DPkg::Post-Invoke") == false)
       return false;
 
    if (RunScripts("DPkg::Post-Invoke") == false)
       return false;

+
+   if (_config->FindB("Debug::pkgDPkgPM",false) == false)
+   {
+      std::string const oldpkgcache = _config->FindFile("Dir::cache::pkgcache");
+      if (oldpkgcache.empty() == false && RealFileExists(oldpkgcache) == true &&
+         unlink(oldpkgcache.c_str()) == 0)
+      {
+        std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
+        if (srcpkgcache.empty() == false && RealFileExists(srcpkgcache) == true)
+        {
+           _error->PushToStack();
+           pkgCacheFile CacheFile;
+           CacheFile.BuildCaches(NULL, true);
+           _error->RevertToStack();
+        }
+      }
+   }
+
+   Cache.writeStateFile(NULL);

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/


@@ -877,28 +1342,59 @@ void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
    string::size_type pos;
    FILE *report;
 
    string::size_type pos;
    FILE *report;
 

-   if (_config->FindB("Dpkg::ApportFailureReport",true) == false)
+   if (_config->FindB("Dpkg::ApportFailureReport", false) == false)
+   {
+      std::clog << "configured to not write apport reports" << std::endl;
+      return;
+   }
+
+   // only report the first errors
+   if(pkgFailures > _config->FindI("APT::Apport::MaxReports", 3))
+   {
+      std::clog << _("No apport report written because MaxReports is reached already") << std::endl;

       return;
       return;

+   }

 
 

-   // only report the first error if we are in StopOnError=false mode
-   // to prevent bogus reports
-   if((_config->FindB("Dpkg::StopOnError",true) == false) && pkgFailures > 1)
+   // check if its not a follow up error 
+   const char *needle = dgettext("dpkg", "dependency problems - leaving unconfigured");
+   if(strstr(errormsg, needle) != NULL) {
+      std::clog << _("No apport report written because the error message indicates its a followup error from a previous failure.") << std::endl;

       return;
       return;

+   }
+
+   // do not report disk-full failures 
+   if(strstr(errormsg, strerror(ENOSPC)) != NULL) {
+      std::clog << _("No apport report written because the error message indicates a disk full error") << std::endl;
+      return;
+   }
+
+   // do not report out-of-memory failures 
+   if(strstr(errormsg, strerror(ENOMEM)) != NULL) {
+      std::clog << _("No apport report written because the error message indicates a out of memory error") << std::endl;
+      return;
+   }
+
+   // do not report dpkg I/O errors
+   // XXX - this message is localized, but this only matches the English version.  This is better than nothing.
+   if(strstr(errormsg, "short read in buffer_copy (")) {
+      std::clog << _("No apport report written because the error message indicates a dpkg I/O error") << std::endl;
+      return;
+   }

 
    // get the pkgname and reportfile
    pkgname = flNotDir(pkgpath);
 
    // get the pkgname and reportfile
    pkgname = flNotDir(pkgpath);

-   pos = pkgname.rfind('_');
+   pos = pkgname.find('_');

    if(pos != string::npos)
    if(pos != string::npos)

-      pkgname = string(pkgname, 0, pos);
+      pkgname = pkgname.substr(0, pos);

 
    // find the package versin and source package name
    pkgCache::PkgIterator Pkg = Cache.FindPkg(pkgname);
    if (Pkg.end() == true)
       return;
    pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg);
 
    // find the package versin and source package name
    pkgCache::PkgIterator Pkg = Cache.FindPkg(pkgname);
    if (Pkg.end() == true)
       return;
    pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg);

-   pkgver = Ver.VerStr();

    if (Ver.end() == true)
       return;
    if (Ver.end() == true)
       return;

+   pkgver = Ver.VerStr() == NULL ? "unknown" : Ver.VerStr();

    pkgRecords Recs(Cache);
    pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
    srcpkgname = Parse.SourcePkg();
    pkgRecords Recs(Cache);
    pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
    srcpkgname = Parse.SourcePkg();


@@ -956,6 +1452,67 @@ void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
    fprintf(report, "Package: %s %s\n", pkgname.c_str(), pkgver.c_str());
    fprintf(report, "SourcePackage: %s\n", srcpkgname.c_str());
    fprintf(report, "ErrorMessage:\n %s\n", errormsg);
    fprintf(report, "Package: %s %s\n", pkgname.c_str(), pkgver.c_str());
    fprintf(report, "SourcePackage: %s\n", srcpkgname.c_str());
    fprintf(report, "ErrorMessage:\n %s\n", errormsg);

+
+   // ensure that the log is flushed
+   if(d->term_out)
+      fflush(d->term_out);
+
+   // attach terminal log it if we have it
+   string logfile_name = _config->FindFile("Dir::Log::Terminal");
+   if (!logfile_name.empty())
+   {
+      FILE *log = NULL;
+      char buf[1024];
+
+      fprintf(report, "DpkgTerminalLog:\n");
+      log = fopen(logfile_name.c_str(),"r");
+      if(log != NULL)
+      {
+        while( fgets(buf, sizeof(buf), log) != NULL)
+           fprintf(report, " %s", buf);
+        fclose(log);
+      }
+   }
+
+   // log the ordering 
+   const char *ops_str[] = {"Install", "Configure","Remove","Purge"};
+   fprintf(report, "AptOrdering:\n");
+   for (vector<Item>::iterator I = List.begin(); I != List.end(); I++)
+      fprintf(report, " %s: %s\n", (*I).Pkg.Name(), ops_str[(*I).Op]);
+
+   // attach dmesg log (to learn about segfaults)
+   if (FileExists("/bin/dmesg"))
+   {
+      FILE *log = NULL;
+      char buf[1024];
+
+      fprintf(report, "Dmesg:\n");
+      log = popen("/bin/dmesg","r");
+      if(log != NULL)
+      {
+        while( fgets(buf, sizeof(buf), log) != NULL)
+           fprintf(report, " %s", buf);
+        pclose(log);
+      }
+   }
+
+   // attach df -l log (to learn about filesystem status)
+   if (FileExists("/bin/df"))
+   {
+      FILE *log = NULL;
+      char buf[1024];
+
+      fprintf(report, "Df:\n");
+      log = popen("/bin/df -l","r");
+      if(log != NULL)
+      {
+        while( fgets(buf, sizeof(buf), log) != NULL)
+           fprintf(report, " %s", buf);
+        pclose(log);
+      }
+   }
+

    fclose(report);
    fclose(report);

+

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