* apt-pkg/pkgcache.cc:

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

diff --git a/apt-pkg/deb/dpkgpm.cc b/apt-pkg/deb/dpkgpm.cc
index 8222be75ed5b5e184b6da99c3b204bb74bc0d809..f787f365e6ddb97a24fe99f1d8b83ae8d6f8dda6 100644 (file)
--- a/apt-pkg/deb/dpkgpm.cc
+++ b/apt-pkg/deb/dpkgpm.cc
@@ -25,6 +25,8 @@
 #include <signal.h>
 #include <errno.h>
 #include <stdio.h>
 #include <signal.h>
 #include <errno.h>
 #include <stdio.h>

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

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


@@ -39,7 +41,63 @@
 
 using namespace std;
 
 
 using namespace std;
 

+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("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                                     /*{{{*/
 // ---------------------------------------------------------------------
 
 // DPkgPM::pkgDPkgPM - Constructor                                     /*{{{*/
 // ---------------------------------------------------------------------


@@ -362,17 +420,19 @@ void pkgDPkgPM::ProcessDpkgStatusLine(int OutStatusFd, char *line)
    if(strncmp(list[0], "processing", strlen("processing")) == 0)
    {
       char s[200];
    if(strncmp(list[0], "processing", strlen("processing")) == 0)
    {
       char s[200];

-      map<string,string>::iterator iter;

       char *pkg_or_trigger = _strstrip(list[2]);
       action =_strstrip( list[1]);
       char *pkg_or_trigger = _strstrip(list[2]);
       action =_strstrip( list[1]);

-      iter = PackageProcessingOps.find(action);
-      if(iter == PackageProcessingOps.end())
+      const std::pair<const char *, const char *> * const iter =
+       std::find_if(PackageProcessingOpsBegin,
+                    PackageProcessingOpsEnd,
+                    MatchProcessingOp(action));
+      if(iter == PackageProcessingOpsEnd)

       {
         if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true)
            std::clog << "ignoring unknwon action: " << action << std::endl;
         return;
       }
       {
         if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true)
            std::clog << "ignoring unknwon action: " << action << std::endl;
         return;
       }

-      snprintf(s, sizeof(s), _(iter->second.c_str()), pkg_or_trigger);
+      snprintf(s, sizeof(s), _(iter->second), pkg_or_trigger);

 
       status << "pmstatus:" << pkg_or_trigger
             << ":"  << (PackagesDone/float(PackagesTotal)*100.0) 
 
       status << "pmstatus:" << pkg_or_trigger
             << ":"  << (PackagesDone/float(PackagesTotal)*100.0) 


@@ -496,7 +556,7 @@ bool pkgDPkgPM::OpenLog()
       struct tm *tmp = localtime(&t);
       strftime(outstr, sizeof(outstr), "%F  %T", tmp);
       fprintf(term_out, "\nLog started: ");
       struct tm *tmp = localtime(&t);
       strftime(outstr, sizeof(outstr), "%F  %T", tmp);
       fprintf(term_out, "\nLog started: ");

-      fprintf(term_out, outstr);
+      fprintf(term_out, "%s", outstr);

       fprintf(term_out, "\n");
    }
    return true;
       fprintf(term_out, "\n");
    }
    return true;


@@ -511,7 +571,7 @@ bool pkgDPkgPM::CloseLog()
       struct tm *tmp = localtime(&t);
       strftime(outstr, sizeof(outstr), "%F  %T", tmp);
       fprintf(term_out, "Log ended: ");
       struct tm *tmp = localtime(&t);
       strftime(outstr, sizeof(outstr), "%F  %T", tmp);
       fprintf(term_out, "Log ended: ");

-      fprintf(term_out, outstr);
+      fprintf(term_out, "%s", outstr);

       fprintf(term_out, "\n");
       fclose(term_out);
    }
       fprintf(term_out, "\n");
       fclose(term_out);
    }


@@ -552,8 +612,14 @@ static int racy_pselect(int nfds, fd_set *readfds, fd_set *writefds,
 */
 bool pkgDPkgPM::Go(int OutStatusFd)
 {
 */
 bool pkgDPkgPM::Go(int OutStatusFd)
 {

+   fd_set rfds;
+   struct timespec tv;
+   sigset_t sigmask;
+   sigset_t original_sigmask;
+

    unsigned int MaxArgs = _config->FindI("Dpkg::MaxArgs",8*1024);   
    unsigned int MaxArgBytes = _config->FindI("Dpkg::MaxArgBytes",32*1024);
    unsigned int MaxArgs = _config->FindI("Dpkg::MaxArgs",8*1024);   
    unsigned int MaxArgBytes = _config->FindI("Dpkg::MaxArgBytes",32*1024);

+   bool NoTriggers = _config->FindB("DPkg::NoTriggers",false);

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


@@ -574,20 +640,12 @@ bool pkgDPkgPM::Go(int OutStatusFd)
       { 
         {"unpacked",N_("Preparing to configure %s") },
         {"half-configured", N_("Configuring %s") },
       { 
         {"unpacked",N_("Preparing to configure %s") },
         {"half-configured", N_("Configuring %s") },

-#if 0
-        {"triggers-awaited", N_("Processing triggers for %s") },
-        {"triggers-pending", N_("Processing triggers for %s") },
-#endif

         { "installed", N_("Installed %s")},
         {NULL, NULL}
       },
       // Remove operation
       { 
         {"half-configured", N_("Preparing for removal of %s")},
         { "installed", N_("Installed %s")},
         {NULL, NULL}
       },
       // Remove operation
       { 
         {"half-configured", N_("Preparing for removal of %s")},

-#if 0
-        {"triggers-awaited", N_("Preparing for removal of %s")},
-        {"triggers-pending", N_("Preparing for removal of %s")},
-#endif

         {"half-installed", N_("Removing %s")},
         {"config-files",  N_("Removed %s")},
         {NULL, NULL}
         {"half-installed", N_("Removing %s")},
         {"config-files",  N_("Removed %s")},
         {NULL, NULL}


@@ -600,12 +658,6 @@ bool pkgDPkgPM::Go(int OutStatusFd)
       },
    };
 
       },
    };
 

-   // populate the "processing" map
-   PackageProcessingOps.insert( make_pair("install",N_("Installing %s")) );
-   PackageProcessingOps.insert( make_pair("configure",N_("Configuring %s")) );
-   PackageProcessingOps.insert( make_pair("remove",N_("Removing %s")) );
-   PackageProcessingOps.insert( make_pair("trigproc",N_("Triggering %s")) );
-   

    // init the PackageOps map, go over the list of packages that
    // that will be [installed|configured|removed|purged] and add
    // them to the PackageOps map (the dpkg states it goes through)
    // init the PackageOps map, go over the list of packages that
    // that will be [installed|configured|removed|purged] and add
    // them to the PackageOps map (the dpkg states it goes through)


@@ -630,10 +682,19 @@ bool pkgDPkgPM::Go(int OutStatusFd)
    for (vector<Item>::iterator I = List.begin(); I != List.end();)
    {
       vector<Item>::iterator J = I;
    for (vector<Item>::iterator I = List.begin(); I != List.end();)
    {
       vector<Item>::iterator J = I;

-      for (; J != List.end() && J->Op == I->Op; J++);
+      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];

+      
+      // 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;
       
       if (J - I > (signed)MaxArgs)
         J = I + MaxArgs;
       


@@ -689,6 +750,8 @@ bool pkgDPkgPM::Go(int OutStatusFd)
         
         case Item::Configure:
         Args[n++] = "--configure";
         
         case Item::Configure:
         Args[n++] = "--configure";

+        if (NoTriggers)
+           Args[n++] = "--no-triggers";

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


@@ -741,17 +804,18 @@ 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   termios tt;

-      struct   termios tt_out;

       struct   winsize win;
       int      master;
       int      slave;
 
       // FIXME: setup sensible signal handling (*ick*)
       tcgetattr(0, &tt);
       struct   winsize win;
       int      master;
       int      slave;
 
       // FIXME: setup sensible signal handling (*ick*)
       tcgetattr(0, &tt);

-      tcgetattr(1, &tt_out);

       ioctl(0, TIOCGWINSZ, (char *)&win);
       ioctl(0, TIOCGWINSZ, (char *)&win);

-      if (openpty(&master, &slave, NULL, &tt_out, &win) < 0) 
+      if (openpty(&master, &slave, NULL, &tt, &win) < 0) 

       {
         const char *s = _("Can not write log, openpty() "
                           "failed (/dev/pts not mounted?)\n");
       {
         const char *s = _("Can not write log, openpty() "
                           "failed (/dev/pts not mounted?)\n");


@@ -763,12 +827,28 @@ bool pkgDPkgPM::Go(int OutStatusFd)
         rtt = tt;
         cfmakeraw(&rtt);
         rtt.c_lflag &= ~ECHO;
         rtt = tt;
         cfmakeraw(&rtt);
         rtt.c_lflag &= ~ECHO;

+        // 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);
         tcsetattr(0, TCSAFLUSH, &rtt);

+        sigprocmask(SIG_SETMASK, &original_sigmask, 0);

       }
 
        // 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
       Child = ExecFork();
             
       // This is the child


@@ -786,6 +866,15 @@ bool pkgDPkgPM::Go(int OutStatusFd)
         }
         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);
         


@@ -805,7 +894,6 @@ 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 */
         putenv((char *)"DPKG_NO_TSTP=yes");
         /* No Job Control Stop Env is a magic dpkg var that prevents it
            from using sigstop */
         putenv((char *)"DPKG_NO_TSTP=yes");


@@ -814,6 +902,10 @@ bool pkgDPkgPM::Go(int OutStatusFd)
         _exit(100);
       }      
 
         _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]);
 


@@ -830,10 +922,6 @@ bool pkgDPkgPM::Go(int OutStatusFd)
         close(slave);
 
       // setups fds
         close(slave);
 
       // setups fds

-      fd_set rfds;
-      struct timespec tv;
-      sigset_t sigmask;
-      sigset_t original_sigmask;

       sigemptyset(&sigmask);
       sigprocmask(SIG_BLOCK,&sigmask,&original_sigmask);
 
       sigemptyset(&sigmask);
       sigprocmask(SIG_BLOCK,&sigmask,&original_sigmask);
 


@@ -849,6 +937,7 @@ 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");
         }
 
            return _error->Errno("waitpid","Couldn't wait for subprocess");
         }
 


@@ -888,6 +977,7 @@ 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);

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


@@ -924,6 +1014,8 @@ bool pkgDPkgPM::Go(int OutStatusFd)
 
    if (RunScripts("DPkg::Post-Invoke") == false)
       return false;
 
    if (RunScripts("DPkg::Post-Invoke") == false)
       return false;

+
+   Cache.writeStateFile(NULL);

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