]> git.saurik.com Git - apt.git/blobdiff - apt-pkg/deb/dpkgpm.cc
* apt-pkg/deb/dpkgpm.cc:
[apt.git] / apt-pkg / deb / dpkgpm.cc
index b4a2abcb50ccfc1db8c5a1531e5cae5b0aeacfd4..8abe3f5c612c1e5f8330a4c0dcea5a4497e3b87b 100644 (file)
@@ -49,6 +49,7 @@ namespace
     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("trigproc",  N_("Running post-installation trigger %s"))
   };
 
@@ -134,8 +135,14 @@ bool pkgDPkgPM::Configure(PkgIterator Pkg)
 {
    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;
 }
                                                                        /*}}}*/
@@ -190,6 +197,9 @@ bool pkgDPkgPM::SendV2Pkgs(FILE *F)
    // 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());
@@ -540,45 +550,104 @@ void pkgDPkgPM::DoDpkgStatusFd(int statusfd, int OutStatusFd)
    dpkgbuf_pos = dpkgbuf+dpkgbuf_pos-p;
 }
                                                                        /*}}}*/
+// DPkgPM::WriteHistoryTag                                             /*{{{*/
+void pkgDPkgPM::WriteHistoryTag(string tag, string value)
+{
+   if (value.size() > 0)
+   {
+      // poor mans rstrip(", ")
+      if (value[value.size()-2] == ',' && value[value.size()-1] == ' ')
+        value.erase(value.size() - 2, 2);
+      fprintf(history_out, "%s: %s\n", tag.c_str(), value.c_str());
+   }
+}                                                                      /*}}}*/
 // DPkgPM::OpenLog                                                     /*{{{*/
 bool pkgDPkgPM::OpenLog()
 {
    string logdir = _config->FindDir("Dir::Log");
    if(not FileExists(logdir))
       return _error->Error(_("Directory '%s' missing"), logdir.c_str());
+
+   // get current time
+   char timestr[200];
+   time_t t = time(NULL);
+   struct tm *tmp = localtime(&t);
+   strftime(timestr, sizeof(timestr), "%F  %T", tmp);
+
+   // open terminal log
    string logfile_name = flCombine(logdir,
                                   _config->Find("Dir::Log::Terminal"));
    if (!logfile_name.empty())
    {
       term_out = fopen(logfile_name.c_str(),"a");
+      if (term_out == NULL)
+        return _error->WarningE(_("Could not open file '%s'"), logfile_name.c_str());
+
       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, "%s", outstr);
-      fprintf(term_out, "\n");
+      fprintf(term_out, "\nLog started: %s\n", timestr);
+   }
+
+   // write 
+   string history_name = flCombine(logdir,
+                                  _config->Find("Dir::Log::History"));
+   if (!history_name.empty())
+   {
+      history_out = fopen(history_name.c_str(),"a");
+      chmod(history_name.c_str(), 0644);
+      fprintf(history_out, "\nStart-Date: %s\n", timestr);
+      string remove, purge, install, upgrade, downgrade;
+      for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
+      {
+        if (Cache[I].NewInstall())
+           install += I.Name() + string(" (") + Cache[I].CandVersion + string("), ");
+        else if (Cache[I].Upgrade())
+           upgrade += I.Name() + string(" (") + Cache[I].CurVersion + string(", ") + Cache[I].CandVersion + string("), ");
+        else if (Cache[I].Downgrade())
+           downgrade += I.Name() + string(" (") + Cache[I].CurVersion + string(", ") + Cache[I].CandVersion + string("), ");
+        else if (Cache[I].Delete())
+        {
+           if ((Cache[I].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge)
+              purge += I.Name() + string(" (") + Cache[I].CurVersion + string("), ");      
+           else
+              remove += I.Name() + string(" (") + Cache[I].CurVersion + string("), ");     
+        }
+      }
+      WriteHistoryTag("Install", install);
+      WriteHistoryTag("Upgrade", upgrade);
+      WriteHistoryTag("Downgrade",downgrade);
+      WriteHistoryTag("Remove",remove);
+      WriteHistoryTag("Purge",purge);
+      fflush(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(term_out)
    {
-      char outstr[200];
-      time_t t = time(NULL);
-      struct tm *tmp = localtime(&t);
-      strftime(outstr, sizeof(outstr), "%F  %T", tmp);
       fprintf(term_out, "Log ended: ");
-      fprintf(term_out, "%s", outstr);
+      fprintf(term_out, "%s", timestr);
       fprintf(term_out, "\n");
       fclose(term_out);
    }
    term_out = NULL;
+
+   if(history_out)
+   {
+      if (dpkg_error.size() > 0)
+        fprintf(history_out, "Error: %s\n", dpkg_error.c_str());
+      fprintf(history_out, "End-Date: %s\n", timestr);
+      fclose(history_out);
+   }
+
    return true;
 }
                                                                        /*}}}*/
@@ -621,7 +690,7 @@ bool pkgDPkgPM::Go(int OutStatusFd)
 
    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);
+   bool const NoTriggers = _config->FindB("DPkg::NoTriggers", false);
 
    if (RunScripts("DPkg::Pre-Invoke") == false)
       return false;
@@ -629,6 +698,13 @@ bool pkgDPkgPM::Go(int OutStatusFd)
    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)
    static const struct DpkgState DpkgStatesOpMap[][7] = {
@@ -666,6 +742,9 @@ bool pkgDPkgPM::Go(int OutStatusFd)
    // and the PackageOpsTranslations (human readable strings)
    for (vector<Item>::const_iterator I = List.begin(); I != List.end();I++)
    {
+      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++) 
@@ -683,9 +762,23 @@ bool pkgDPkgPM::Go(int OutStatusFd)
    // this loop is runs once per operation
    for (vector<Item>::const_iterator I = List.begin(); I != List.end();)
    {
+      // Do all actions with the same Op in one run
       vector<Item>::const_iterator J = I;
-      for (; J != List.end() && J->Op == I->Op; J++)
-        /* nothing */;
+      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];
@@ -752,11 +845,23 @@ bool pkgDPkgPM::Go(int OutStatusFd)
         
         case Item::Configure:
         Args[n++] = "--configure";
-        if (NoTriggers == true)
-           Args[n++] = "--no-triggers";
         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]);
@@ -764,7 +869,14 @@ bool pkgDPkgPM::Go(int OutStatusFd)
         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)
       {
@@ -780,6 +892,8 @@ bool pkgDPkgPM::Go(int OutStatusFd)
       {
         for (;I != J && Size < MaxArgBytes; I++)
         {
+           if((*I).Pkg.end() == true)
+              continue;
            Args[n++] = I->Pkg.Name();
            Size += strlen(Args[n-1]);
         }       
@@ -811,32 +925,37 @@ bool pkgDPkgPM::Go(int OutStatusFd)
 
       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)
       {
-        const char *s = _("Can not write log, openpty() "
-                          "failed (/dev/pts not mounted?)\n");
-        fprintf(stderr, "%s",s);
-        fprintf(term_out, "%s",s);
-        master = slave = -1;
-      }  else {
-        struct termios rtt;
-        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);
-        sigprocmask(SIG_SETMASK, &original_sigmask, 0);
+        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(term_out)
+              fprintf(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);
+        }
       }
 
        // Fork dpkg
@@ -999,11 +1118,14 @@ bool pkgDPkgPM::Go(int OutStatusFd)
            RunScripts("DPkg::Post-Invoke");
 
         if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV) 
-           _error->Error("Sub-process %s received a segmentation fault.",Args[0]);
+           strprintf(dpkg_error, "Sub-process %s received a segmentation fault.",Args[0]);
         else if (WIFEXITED(Status) != 0)
-           _error->Error("Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status));
+           strprintf(dpkg_error, "Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status));
         else 
-           _error->Error("Sub-process %s exited unexpectedly",Args[0]);
+           strprintf(dpkg_error, "Sub-process %s exited unexpectedly",Args[0]);
+
+        if(dpkg_error.size() > 0)
+           _error->Error(dpkg_error.c_str());
 
         if(stopOnError) 
         {