add wrapper around dpkg to be able to use it easily in the tests

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

diff --git a/apt-pkg/deb/dpkgpm.cc b/apt-pkg/deb/dpkgpm.cc
index 500d4a260b1e1f24f87befdc701325c539e7ffc3..5530ef12975862f9b24e0aa5d06e7b588689c671 100644 (file)
--- a/apt-pkg/deb/dpkgpm.cc
+++ b/apt-pkg/deb/dpkgpm.cc
@@ -21,6 +21,7 @@
 #include <stdlib.h>
 #include <fcntl.h>
 #include <sys/select.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 <sys/types.h>
 #include <sys/wait.h>
 #include <signal.h>


@@ -51,6 +52,8 @@ 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("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"))
   };
 
     std::make_pair("trigproc",  N_("Running post-installation trigger %s"))
   };
 


@@ -106,7 +109,7 @@ ionice(int PID)
 /* */
 pkgDPkgPM::pkgDPkgPM(pkgDepCache *Cache) 
    : pkgPackageManager(Cache), dpkgbuf_pos(0),
 /* */
 pkgDPkgPM::pkgDPkgPM(pkgDepCache *Cache) 
    : pkgPackageManager(Cache), dpkgbuf_pos(0),

-     term_out(NULL), PackagesDone(0), PackagesTotal(0), pkgFailures(0)
+     term_out(NULL), history_out(NULL), PackagesDone(0), PackagesTotal(0)

 {
 }
                                                                        /*}}}*/
 {
 }
                                                                        /*}}}*/


@@ -125,7 +128,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;
 }
                                                                        /*}}}*/


@@ -407,7 +422,8 @@ void pkgDPkgPM::ProcessDpkgStatusLine(int OutStatusFd, char *line)
       'processing: install: pkg'
       'processing: configure: pkg'
       'processing: remove: pkg'
       'processing: install: pkg'
       'processing: configure: pkg'
       'processing: remove: pkg'

-      'processing: purge: pkg' - but for apt is it a ignored "unknown" action
+      'processing: purge: pkg'
+      'processing: disappear: pkg'

       'processing: trigproc: trigger'
            
    */
       'processing: trigproc: trigger'
            
    */


@@ -454,6 +470,9 @@ void pkgDPkgPM::ProcessDpkgStatusLine(int OutStatusFd, char *line)
         write(OutStatusFd, status.str().c_str(), status.str().size());
       if (Debug == true)
         std::clog << "send: '" << status.str() << "'" << endl;
         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;
    }
 
       return;
    }
 


@@ -523,6 +542,53 @@ void pkgDPkgPM::ProcessDpkgStatusLine(int OutStatusFd, char *line)
                << " action: " << action << endl;
 }
                                                                        /*}}}*/
                << " action: " << action << endl;
 }
                                                                        /*}}}*/

+// DPkgPM::handleDisappearAction                                       /*{{{*/
+void pkgDPkgPM::handleDisappearAction(string const &pkgname)
+{
+   // record the package name for display and stuff later
+   disappearedPkgs.insert(pkgname);
+
+   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                                              /*{{{*/
 // ---------------------------------------------------------------------
 /*
 // DPkgPM::DoDpkgStatusFd                                              /*{{{*/
 // ---------------------------------------------------------------------
 /*


@@ -560,45 +626,129 @@ void pkgDPkgPM::DoDpkgStatusFd(int statusfd, int OutStatusFd)
    dpkgbuf_pos = dpkgbuf+dpkgbuf_pos-p;
 }
                                                                        /*}}}*/
    dpkgbuf_pos = dpkgbuf+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(history_out, "%s: %s\n", tag.c_str(), value.c_str());
+}                                                                      /*}}}*/

 // DPkgPM::OpenLog                                                     /*{{{*/
 bool pkgDPkgPM::OpenLog()
 {
 // DPkgPM::OpenLog                                                     /*{{{*/
 bool pkgDPkgPM::OpenLog()
 {

-   string logdir = _config->FindDir("Dir::Log");
+   string const logdir = _config->FindDir("Dir::Log");

    if(not FileExists(logdir))
       return _error->Error(_("Directory '%s' missing"), logdir.c_str());
    if(not FileExists(logdir))
       return _error->Error(_("Directory '%s' missing"), logdir.c_str());

-   string logfile_name = flCombine(logdir,
+
+   // 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())
    {
       term_out = fopen(logfile_name.c_str(),"a");
                                   _config->Find("Dir::Log::Terminal"));
    if (!logfile_name.empty())
    {
       term_out = fopen(logfile_name.c_str(),"a");

+      if (term_out == NULL)
+        return _error->WarningE("OpenLog", _("Could not open file '%s'"), logfile_name.c_str());
+      setvbuf(term_out, NULL, _IONBF, 0);

       chmod(logfile_name.c_str(), 0600);
       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 your history
+   string const history_name = flCombine(logdir,
+                                  _config->Find("Dir::Log::History"));
+   if (!history_name.empty())
+   {
+      history_out = fopen(history_name.c_str(),"a");
+      if (history_out == NULL)
+        return _error->WarningE("OpenLog", _("Could not open file '%s'"), history_name.c_str());
+      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.FullName(false) + string(" (") + Cache[I].CandVersion;
+           if (Cache[I].Flags & pkgCache::Flag::Auto)
+              install+= ", automatic";
+           install += string("), ");
+        }
+        else if (Cache[I].Upgrade())
+           upgrade += I.FullName(false) + string(" (") + Cache[I].CurVersion + string(", ") + Cache[I].CandVersion + string("), ");
+        else if (Cache[I].Downgrade())
+           downgrade += I.FullName(false) + string(" (") + Cache[I].CurVersion + string(", ") + Cache[I].CandVersion + string("), ");
+        else if (Cache[I].Delete())
+        {
+           if ((Cache[I].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge)
+              purge += I.FullName(false) + string(" (") + Cache[I].CurVersion + string("), ");     
+           else
+              remove += I.FullName(false) + string(" (") + Cache[I].CurVersion + string("), ");            
+        }
+      }
+      if (_config->Exists("Commandline::AsString") == true)
+        WriteHistoryTag("Commandline", _config->Find("Commandline::AsString"));
+      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()
 {
    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)
    {
    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, "Log ended: ");

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

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

+
+   if(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 (dpkg_error.empty() == false)
+        fprintf(history_out, "Error: %s\n", dpkg_error.c_str());
+      fprintf(history_out, "End-Date: %s\n", timestr);
+      fclose(history_out);
+   }
+   history_out = NULL;
+

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


@@ -652,6 +802,7 @@ bool pkgDPkgPM::Go(int OutStatusFd)
    // 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");
    // 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()));
 
    if (_config->FindB("DPkg::ConfigurePending", SmartConf) == true)
       List.push_back(Item(Item::ConfigurePending, PkgIterator()));
 


@@ -712,9 +863,23 @@ bool pkgDPkgPM::Go(int OutStatusFd)
    // this loop is runs once per operation
    for (vector<Item>::const_iterator I = List.begin(); I != List.end();)
    {
    // 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;
       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];
 
       // Generate the argument list
       const char *Args[MaxArgs + 50];


@@ -830,6 +995,8 @@ bool pkgDPkgPM::Go(int OutStatusFd)
         {
            if((*I).Pkg.end() == true)
               continue;
         {
            if((*I).Pkg.end() == true)
               continue;

+           if (I->Op == Item::Configure && disappearedPkgs.find(I->Pkg.Name()) != disappearedPkgs.end())
+              continue;

            Args[n++] = I->Pkg.Name();
            Size += strlen(Args[n-1]);
         }       
            Args[n++] = I->Pkg.Name();
            Size += strlen(Args[n-1]);
         }       


@@ -874,13 +1041,15 @@ bool pkgDPkgPM::Go(int OutStatusFd)
            const char *s = _("Can not write log, openpty() "
                              "failed (/dev/pts not mounted?)\n");
            fprintf(stderr, "%s",s);
            const char *s = _("Can not write log, openpty() "
                              "failed (/dev/pts not mounted?)\n");
            fprintf(stderr, "%s",s);

-           fprintf(term_out, "%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;
            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
            // 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


@@ -995,9 +1164,10 @@ bool pkgDPkgPM::Go(int OutStatusFd)
            signal(SIGHUP,old_SIGHUP);
            return _error->Errno("waitpid","Couldn't wait for subprocess");
         }
            signal(SIGHUP,old_SIGHUP);
            return _error->Errno("waitpid","Couldn't wait for subprocess");
         }

+

         // wait for input or output here
         FD_ZERO(&rfds);
         // wait for input or output here
         FD_ZERO(&rfds);

-        if (!stdin_is_dev_null)
+        if (master >= 0 && !stdin_is_dev_null)

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


@@ -1051,11 +1221,14 @@ bool pkgDPkgPM::Go(int OutStatusFd)
            RunScripts("DPkg::Post-Invoke");
 
         if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV) 
            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)
         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 
         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) 
         {
 
         if(stopOnError) 
         {


@@ -1090,7 +1263,7 @@ 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;
    {
       std::clog << "configured to not write apport reports" << std::endl;
       return;