* apt-pkg/deb/dpkgpm.cc:

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

diff --git a/apt-pkg/deb/dpkgpm.cc b/apt-pkg/deb/dpkgpm.cc
index f220e2bce936d4b8e2811a8b8393c226b950a44c..b6c92fc23344c050a6b22728b2582e1b4226ee04 100644 (file)
--- a/apt-pkg/deb/dpkgpm.cc
+++ b/apt-pkg/deb/dpkgpm.cc
@@ -14,13 +14,14 @@
 #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 <apti18n.h>

 #include <apt-pkg/fileutl.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 <sys/types.h>
 #include <sys/wait.h>
 #include <signal.h>


@@ -31,6 +32,8 @@
 #include <algorithm>
 #include <sstream>
 #include <map>
 #include <algorithm>
 #include <sstream>
 #include <map>

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

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


@@ -52,6 +55,7 @@ namespace
     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("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"))
   };
 


@@ -107,7 +111,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)

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


@@ -126,7 +130,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;
 }
                                                                        /*}}}*/


@@ -197,7 +213,7 @@ bool pkgDPkgPM::SendV2Pkgs(FILE *F)
    fprintf(F,"\n");
  
    // Write out the package actions in order.
    fprintf(F,"\n");
  
    // Write out the package actions in order.

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

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


@@ -294,6 +310,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";


@@ -308,10 +333,9 @@ 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)
       {
       if (Version <= 1)
       {

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

         {
            // Only deal with packages to be installed from .deb
            if (I->Op != Item::Install)
         {
            // Only deal with packages to be installed from .deb
            if (I->Op != Item::Install)


@@ -325,14 +349,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);
       


@@ -372,8 +393,9 @@ void pkgDPkgPM::DoTerminalPty(int master)
    {
       // this happens when the child is about to exit, we
       // give it time to actually exit, otherwise we run
    {
       // this happens when the child is about to exit, we
       // give it time to actually exit, otherwise we run

-      // into a race
-      usleep(500000);
+      // into a race so we sleep for half a second.
+      struct timespec sleepfor = { 0, 500000000 };
+      nanosleep(&sleepfor, NULL);

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


@@ -408,7 +430,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'
            
    */


@@ -455,6 +478,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;
    }
 


@@ -524,6 +550,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                                              /*{{{*/
 // ---------------------------------------------------------------------
 /*


@@ -562,73 +635,101 @@ void pkgDPkgPM::DoDpkgStatusFd(int statusfd, int OutStatusFd)
 }
                                                                        /*}}}*/
 // DPkgPM::WriteHistoryTag                                             /*{{{*/
 }
                                                                        /*}}}*/
 // DPkgPM::WriteHistoryTag                                             /*{{{*/

-void pkgDPkgPM::WriteHistoryTag(FILE *history_out, string tag, string value)
+void pkgDPkgPM::WriteHistoryTag(string const &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());
-   }
+   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");
-   if(not FileExists(logdir))
+   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];
       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);
+   time_t const t = time(NULL);
+   struct tm const * const tmp = localtime(&t);

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

-   string logfile_name = flCombine(logdir,
+   string const 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)
                                   _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);
+        return _error->WarningE("OpenLog", _("Could not open file '%s'"), logfile_name.c_str());
+      setvbuf(term_out, NULL, _IONBF, 0);
+      SetCloseExec(fileno(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(term_out, "\nLog started: %s\n", timestr);
    }
 
       fprintf(term_out, "\nLog started: %s\n", timestr);
    }
 

-   // write 
-   string history_name = flCombine(logdir,
+   // write your history
+   string const history_name = flCombine(logdir,

                                   _config->Find("Dir::Log::History"));
    if (!history_name.empty())
    {
                                   _config->Find("Dir::Log::History"));
    if (!history_name.empty())
    {

-      FILE *history_out = fopen(history_name.c_str(),"a");
+      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);
       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++)
+      string remove, purge, install, reinstall, 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("), ");     
+        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("), ");

       }
       }

-      WriteHistoryTag(history_out, "Install", install);
-      WriteHistoryTag(history_out, "Upgrade", upgrade);
-      WriteHistoryTag(history_out, "Downgrade",downgrade);
-      WriteHistoryTag(history_out, "Remove",remove);
-      WriteHistoryTag(history_out, "Purge",purge);
-      fclose(history_out);
+      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(history_out);

    }
    
    return true;
    }
    
    return true;


@@ -651,14 +752,29 @@ bool pkgDPkgPM::CloseLog()
    }
    term_out = NULL;
 
    }
    term_out = NULL;
 

-   string history_name = flCombine(_config->FindDir("Dir::Log"),
-                                  _config->Find("Dir::Log::History"));
-   if (!history_name.empty())
+   if(history_out)

    {
    {

-      FILE *history_out = fopen(history_name.c_str(),"a");
+      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);
    }
       fprintf(history_out, "End-Date: %s\n", timestr);
       fclose(history_out);
    }

+   history_out = NULL;

 
    return true;
 }
 
    return true;
 }


@@ -752,14 +868,14 @@ 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>::const_iterator I = List.begin(); I != List.end();I++)
+   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;
    {
       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++) 
+      for(int i=0; (DpkgStatesOpMap[(*I).Op][i]).state != NULL; ++i)

       {
         PackageOps[name].push_back(DpkgStatesOpMap[(*I).Op][i]);
         PackagesTotal++;
       {
         PackageOps[name].push_back(DpkgStatesOpMap[(*I).Op][i]);
         PackagesTotal++;


@@ -771,13 +887,35 @@ bool pkgDPkgPM::Go(int OutStatusFd)
    // create log
    OpenLog();
 
    // create log
    OpenLog();
 

+   // Generate the base argument list for dpkg
+   std::vector<const char *> Args;
+   unsigned long StartSize = 0;
+   string const Tmp = _config->Find("Dir::Bin::dpkg","dpkg");
+   Args.push_back(Tmp.c_str());
+   StartSize += Tmp.length();
+
+   // Stick in any custom dpkg options
+   Configuration::Item const *Opts = _config->Tree("DPkg::Options");
+   if (Opts != 0)
+   {
+      Opts = Opts->Child;
+      for (; Opts != 0; Opts = Opts->Next)
+      {
+        if (Opts->Value.empty() == true)
+           continue;
+        Args.push_back(Opts->Value.c_str());
+        StartSize += Opts->Value.length();
+      }
+   }
+   size_t const BaseArgs = Args.size();
+

    // 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;
       if (TriggersPending == true)
    // 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;
       if (TriggersPending == true)

-        for (; J != List.end(); J++)
+        for (; J != List.end(); ++J)

         {
            if (J->Op == I->Op)
               continue;
         {
            if (J->Op == I->Op)
               continue;


@@ -789,12 +927,16 @@ bool pkgDPkgPM::Go(int OutStatusFd)
            break;
         }
       else
            break;
         }
       else

-        for (; J != List.end() && J->Op == I->Op; J++)
+        for (; J != List.end() && J->Op == I->Op; ++J)

            /* nothing */;
 
            /* nothing */;
 

-      // Generate the argument list
-      const char *Args[MaxArgs + 50];
-      
+      // keep track of allocated strings for multiarch package names
+      std::vector<char *> Packages;
+
+      // start with the baseset of arguments
+      unsigned long Size = StartSize;
+      Args.erase(Args.begin() + BaseArgs, Args.end());
+

       // Now check if we are within the MaxArgs limit
       //
       // this code below is problematic, because it may happen that
       // Now check if we are within the MaxArgs limit
       //
       // this code below is problematic, because it may happen that


@@ -803,124 +945,119 @@ bool pkgDPkgPM::Go(int OutStatusFd)
       // - with the split they may now be configured in different
       //   runs 
       if (J - I > (signed)MaxArgs)
       // - with the split they may now be configured in different
       //   runs 
       if (J - I > (signed)MaxArgs)

+      {

         J = I + MaxArgs;
         J = I + MaxArgs;

-      
-      unsigned int n = 0;
-      unsigned long Size = 0;
-      string const Tmp = _config->Find("Dir::Bin::dpkg","dpkg");
-      Args[n++] = Tmp.c_str();
-      Size += strlen(Args[n-1]);
-      
-      // Stick in any custom dpkg options
-      Configuration::Item const *Opts = _config->Tree("DPkg::Options");
-      if (Opts != 0)
+        Args.reserve(MaxArgs + 10);
+      }
+      else

       {
       {

-        Opts = Opts->Child;
-        for (; Opts != 0; Opts = Opts->Next)
-        {
-           if (Opts->Value.empty() == true)
-              continue;
-           Args[n++] = Opts->Value.c_str();
-           Size += Opts->Value.length();
-        }       
+        Args.reserve((J - I) + 10);

       }
       }

+

       
       

-      char status_fd_buf[20];

       int fd[2];
       pipe(fd);
       int fd[2];
       pipe(fd);

-      
-      Args[n++] = "--status-fd";
-      Size += strlen(Args[n-1]);
+
+#define ADDARG(X) Args.push_back(X); Size += strlen(X)
+#define ADDARGC(X) Args.push_back(X); Size += sizeof(X) - 1
+
+      ADDARGC("--status-fd");
+      char status_fd_buf[20];

       snprintf(status_fd_buf,sizeof(status_fd_buf),"%i", fd[1]);
       snprintf(status_fd_buf,sizeof(status_fd_buf),"%i", fd[1]);

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

 
       switch (I->Op)
       {
         case Item::Remove:
 
       switch (I->Op)
       {
         case Item::Remove:

-        Args[n++] = "--force-depends";
-        Size += strlen(Args[n-1]);
-        Args[n++] = "--force-remove-essential";
-        Size += strlen(Args[n-1]);
-        Args[n++] = "--remove";
-        Size += strlen(Args[n-1]);
+        ADDARGC("--force-depends");
+        ADDARGC("--force-remove-essential");
+        ADDARGC("--remove");

         break;
         
         case Item::Purge:
         break;
         
         case Item::Purge:

-        Args[n++] = "--force-depends";
-        Size += strlen(Args[n-1]);
-        Args[n++] = "--force-remove-essential";
-        Size += strlen(Args[n-1]);
-        Args[n++] = "--purge";
-        Size += strlen(Args[n-1]);
+        ADDARGC("--force-depends");
+        ADDARGC("--force-remove-essential");
+        ADDARGC("--purge");

         break;
         
         case Item::Configure:
         break;
         
         case Item::Configure:

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

         break;
 
         case Item::ConfigurePending:
         break;
 
         case Item::ConfigurePending:

-        Args[n++] = "--configure";
-        Size += strlen(Args[n-1]);
-        Args[n++] = "--pending";
-        Size += strlen(Args[n-1]);
+        ADDARGC("--configure");
+        ADDARGC("--pending");

         break;
 
         case Item::TriggersPending:
         break;
 
         case Item::TriggersPending:

-        Args[n++] = "--triggers-only";
-        Size += strlen(Args[n-1]);
-        Args[n++] = "--pending";
-        Size += strlen(Args[n-1]);
+        ADDARGC("--triggers-only");
+        ADDARGC("--pending");

         break;
 
         case Item::Install:
         break;
 
         case Item::Install:

-        Args[n++] = "--unpack";
-        Size += strlen(Args[n-1]);
-        Args[n++] = "--auto-deconfigure";
-        Size += strlen(Args[n-1]);
+        ADDARGC("--unpack");
+        ADDARGC("--auto-deconfigure");

         break;
       }
 
       if (NoTriggers == true && I->Op != Item::TriggersPending &&
          I->Op != Item::ConfigurePending)
       {
         break;
       }
 
       if (NoTriggers == true && I->Op != Item::TriggersPending &&
          I->Op != Item::ConfigurePending)
       {

-        Args[n++] = "--no-triggers";
-        Size += strlen(Args[n-1]);
+        ADDARGC("--no-triggers");

       }
       }

+#undef ADDARGC

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

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

         {
            if (I->File[0] != '/')
               return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str());
         {
            if (I->File[0] != '/')
               return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str());

-           Args[n++] = I->File.c_str();
-           Size += strlen(Args[n-1]);
+           Args.push_back(I->File.c_str());
+           Size += I->File.length();

         }
         }

-      }      
+      }

       else
       {
       else
       {

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

         {
            if((*I).Pkg.end() == true)
               continue;
         {
            if((*I).Pkg.end() == true)
               continue;

-           Args[n++] = I->Pkg.Name();
-           Size += strlen(Args[n-1]);
-        }       
-      }      
-      Args[n] = 0;
+           if (I->Op == Item::Configure && disappearedPkgs.find(I->Pkg.Name()) != disappearedPkgs.end())
+              continue;
+           if (I->Pkg.Arch() == nativeArch || !strcmp(I->Pkg.Arch(), "all"))
+           {
+              char const * const name = I->Pkg.Name();
+              ADDARG(name);
+           }
+           else
+           {
+              char * const fullname = strdup(I->Pkg.FullName(false).c_str());
+              Packages.push_back(fullname);
+              ADDARG(fullname);
+           }
+        }
+        // skip configure action if all sheduled packages disappeared
+        if (oldSize == Size)
+           continue;
+      }
+#undef ADDARG
+

       J = I;
       
       if (_config->FindB("Debug::pkgDPkgPM",false) == true)
       {
       J = I;
       
       if (_config->FindB("Debug::pkgDPkgPM",false) == true)
       {

-        for (unsigned int k = 0; k != n; k++)
-           clog << Args[k] << ' ';
+        for (std::vector<const char *>::const_iterator a = Args.begin();
+             a != Args.end(); ++a)
+           clog << *a << ' ';

         clog << endl;
         continue;
       }
         clog << endl;
         continue;
       }

-      
+      Args.push_back(NULL);
+

       cout << flush;
       clog << flush;
       cerr << flush;
       cout << flush;
       clog << flush;
       cerr << flush;


@@ -958,6 +1095,7 @@ bool pkgDPkgPM::Go(int OutStatusFd)
            rtt = tt;
            cfmakeraw(&rtt);
            rtt.c_lflag &= ~ECHO;
            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


@@ -1029,7 +1167,7 @@ bool pkgDPkgPM::Go(int OutStatusFd)
         /* 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");

-        execvp(Args[0],(char **)Args);
+        execvp(Args[0], (char**) &Args[0]);

         cerr << "Could not exec dpkg!" << endl;
         _exit(100);
       }      
         cerr << "Could not exec dpkg!" << endl;
         _exit(100);
       }      


@@ -1055,6 +1193,12 @@ bool pkgDPkgPM::Go(int OutStatusFd)
       sigemptyset(&sigmask);
       sigprocmask(SIG_BLOCK,&sigmask,&original_sigmask);
 
       sigemptyset(&sigmask);
       sigprocmask(SIG_BLOCK,&sigmask,&original_sigmask);
 

+      /* free vectors (and therefore memory) as we don't need the included data anymore */
+      for (std::vector<char *>::const_iterator p = Packages.begin();
+          p != Packages.end(); ++p)
+        free(*p);
+      Packages.clear();
+

       // the result of the waitpid call
       int res;
       int select_ret;
       // the result of the waitpid call
       int res;
       int select_ret;


@@ -1072,9 +1216,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)


@@ -1127,7 +1272,6 @@ bool pkgDPkgPM::Go(int OutStatusFd)
         if(stopOnError)
            RunScripts("DPkg::Post-Invoke");
 
         if(stopOnError)
            RunScripts("DPkg::Post-Invoke");
 

-        string dpkg_error;

         if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV) 
            strprintf(dpkg_error, "Sub-process %s received a segmentation fault.",Args[0]);
         else if (WIFEXITED(Status) != 0)
         if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV) 
            strprintf(dpkg_error, "Sub-process %s received a segmentation fault.",Args[0]);
         else if (WIFEXITED(Status) != 0)


@@ -1136,17 +1280,7 @@ bool pkgDPkgPM::Go(int OutStatusFd)
            strprintf(dpkg_error, "Sub-process %s exited unexpectedly",Args[0]);
 
         if(dpkg_error.size() > 0)
            strprintf(dpkg_error, "Sub-process %s exited unexpectedly",Args[0]);
 
         if(dpkg_error.size() > 0)

-        {
-           _error->Error(dpkg_error.c_str());
-           string history_name = flCombine(_config->FindDir("Dir::Log"),
-                                           _config->Find("Dir::Log::History"));
-           if (!history_name.empty())
-           {
-              FILE *history_out = fopen(history_name.c_str(),"a");
-              fprintf(history_out, "Error: %s\n", dpkg_error.c_str());
-              fclose(history_out);
-           }
-        }
+           _error->Error("%s", dpkg_error.c_str());

 
         if(stopOnError) 
         {
 
         if(stopOnError) 
         {


@@ -1160,6 +1294,23 @@ bool pkgDPkgPM::Go(int OutStatusFd)
    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;
 }
    Cache.writeStateFile(NULL);
    return true;
 }


@@ -1181,7 +1332,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;


@@ -1316,7 +1467,7 @@ void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
    // log the ordering 
    const char *ops_str[] = {"Install", "Configure","Remove","Purge"};
    fprintf(report, "AptOrdering:\n");
    // 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++)
+   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)
       fprintf(report, " %s: %s\n", (*I).Pkg.Name(), ops_str[(*I).Op]);
 
    // attach dmesg log (to learn about segfaults)


@@ -1331,7 +1482,7 @@ void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
       {
         while( fgets(buf, sizeof(buf), log) != NULL)
            fprintf(report, " %s", buf);
       {
         while( fgets(buf, sizeof(buf), log) != NULL)
            fprintf(report, " %s", buf);

-        fclose(log);
+        pclose(log);

       }
    }
 
       }
    }
 


@@ -1347,7 +1498,7 @@ void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
       {
         while( fgets(buf, sizeof(buf), log) != NULL)
            fprintf(report, " %s", buf);
       {
         while( fgets(buf, sizeof(buf), log) != NULL)
            fprintf(report, " %s", buf);

-        fclose(log);
+        pclose(log);

       }
    }
 
       }
    }