apt-pkg/deb/dpkgpm.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: dpkgpm.cc,v 1.28 2004/01/27 02:25:01 mdz Exp $
   4 /* ######################################################################
   5
   6    DPKG Package Manager - Provide an interface to dpkg
   7
   8    ##################################################################### */
   9                                                                         /*}}}*/
  10 // Includes                                                             /*{{{*/
  11 #include <config.h>
  12
  13 #include <apt-pkg/cachefile.h>
  14 #include <apt-pkg/configuration.h>
  15 #include <apt-pkg/depcache.h>
  16 #include <apt-pkg/dpkgpm.h>
  17 #include <apt-pkg/error.h>
  18 #include <apt-pkg/fileutl.h>
  19 #include <apt-pkg/install-progress.h>
  20 #include <apt-pkg/packagemanager.h>
  21 #include <apt-pkg/pkgrecords.h>
  22 #include <apt-pkg/strutl.h>
  23 #include <apt-pkg/cacheiterators.h>
  24 #include <apt-pkg/macros.h>
  25 #include <apt-pkg/pkgcache.h>
  26
  27 #include <errno.h>
  28 #include <fcntl.h>
  29 #include <grp.h>
  30 #include <pty.h>
  31 #include <pwd.h>
  32 #include <signal.h>
  33 #include <stddef.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <sys/ioctl.h>
  37 #include <sys/select.h>
  38 #include <sys/stat.h>
  39 #include <sys/time.h>
  40 #include <sys/wait.h>
  41 #include <termios.h>
  42 #include <time.h>
  43 #include <unistd.h>
  44 #include <algorithm>
  45 #include <cstring>
  46 #include <iostream>
  47 #include <map>
  48 #include <set>
  49 #include <string>
  50 #include <utility>
  51 #include <vector>
  52
  53 #include <apti18n.h>
  54                                                                         /*}}}*/
  55
  56 using namespace std;
  57
  58 APT_PURE static unsigned int
  59 EnvironmentSize()
  60 {
  61   unsigned int size = 0;
  62   char **envp = environ;
  63
  64   while (*envp != NULL)
  65     size += strlen (*envp++) + 1;
  66
  67   return size;
  68 }
  69
  70 class pkgDPkgPMPrivate
  71 {
  72 public:
  73    pkgDPkgPMPrivate() : stdin_is_dev_null(false), dpkgbuf_pos(0),
  74                         term_out(NULL), history_out(NULL),
  75                         progress(NULL), tt_is_valid(false), master(-1),
  76                         slave(NULL), protect_slave_from_dying(-1)
  77    {
  78       dpkgbuf[0] = '\0';
  79    }
  80    ~pkgDPkgPMPrivate()
  81    {
  82    }
  83    bool stdin_is_dev_null;
  84    // the buffer we use for the dpkg status-fd reading
  85    char dpkgbuf[1024];
  86    int dpkgbuf_pos;
  87    FILE *term_out;
  88    FILE *history_out;
  89    string dpkg_error;
  90    APT::Progress::PackageManager *progress;
  91
  92    // pty stuff
  93    struct termios tt;
  94    bool tt_is_valid;
  95    int master;
  96    char * slave;
  97    int protect_slave_from_dying;
  98
  99    // signals
 100    sigset_t sigmask;
 101    sigset_t original_sigmask;
 102
 103 };
 104
 105 namespace
 106 {
 107   // Maps the dpkg "processing" info to human readable names.  Entry 0
 108   // of each array is the key, entry 1 is the value.
 109   const std::pair<const char *, const char *> PackageProcessingOps[] = {
 110     std::make_pair("install",   N_("Installing %s")),
 111     std::make_pair("configure", N_("Configuring %s")),
 112     std::make_pair("remove",    N_("Removing %s")),
 113     std::make_pair("purge",    N_("Completely removing %s")),
 114     std::make_pair("disappear", N_("Noting disappearance of %s")),
 115     std::make_pair("trigproc",  N_("Running post-installation trigger %s"))
 116   };
 117
 118   const std::pair<const char *, const char *> * const PackageProcessingOpsBegin = PackageProcessingOps;
 119   const std::pair<const char *, const char *> * const PackageProcessingOpsEnd   = PackageProcessingOps + sizeof(PackageProcessingOps) / sizeof(PackageProcessingOps[0]);
 120
 121   // Predicate to test whether an entry in the PackageProcessingOps
 122   // array matches a string.
 123   class MatchProcessingOp
 124   {
 125     const char *target;
 126
 127   public:
 128     MatchProcessingOp(const char *the_target)
 129       : target(the_target)
 130     {
 131     }
 132
 133     bool operator()(const std::pair<const char *, const char *> &pair) const
 134     {
 135       return strcmp(pair.first, target) == 0;
 136     }
 137   };
 138 }
 139
 140 /* helper function to ionice the given PID
 141
 142  there is no C header for ionice yet - just the syscall interface
 143  so we use the binary from util-linux
 144 */
 145 static bool
 146 ionice(int PID)
 147 {
 148    if (!FileExists("/usr/bin/ionice"))
 149       return false;
 150    pid_t Process = ExecFork();
 151    if (Process == 0)
 152    {
 153       char buf[32];
 154       snprintf(buf, sizeof(buf), "-p%d", PID);
 155       const char *Args[4];
 156       Args[0] = "/usr/bin/ionice";
 157       Args[1] = "-c3";
 158       Args[2] = buf;
 159       Args[3] = 0;
 160       execv(Args[0], (char **)Args);
 161    }
 162    return ExecWait(Process, "ionice");
 163 }
 164
 165 static std::string getDpkgExecutable()
 166 {
 167    string Tmp = _config->Find("Dir::Bin::dpkg","dpkg");
 168    string const dpkgChrootDir = _config->FindDir("DPkg::Chroot-Directory", "/");
 169    size_t dpkgChrootLen = dpkgChrootDir.length();
 170    if (dpkgChrootDir != "/" && Tmp.find(dpkgChrootDir) == 0)
 171    {
 172       if (dpkgChrootDir[dpkgChrootLen - 1] == '/')
 173          --dpkgChrootLen;
 174       Tmp = Tmp.substr(dpkgChrootLen);
 175    }
 176    return Tmp;
 177 }
 178
 179 // dpkgChrootDirectory - chrooting for dpkg if needed                   /*{{{*/
 180 static void dpkgChrootDirectory()
 181 {
 182    std::string const chrootDir = _config->FindDir("DPkg::Chroot-Directory");
 183    if (chrootDir == "/")
 184       return;
 185    std::cerr << "Chrooting into " << chrootDir << std::endl;
 186    if (chroot(chrootDir.c_str()) != 0)
 187       _exit(100);
 188    if (chdir("/") != 0)
 189       _exit(100);
 190 }
 191                                                                         /*}}}*/
 192
 193
 194 // FindNowVersion - Helper to find a Version in "now" state     /*{{{*/
 195 // ---------------------------------------------------------------------
 196 /* This is helpful when a package is no longer installed but has residual
 197  * config files
 198  */
 199 static
 200 pkgCache::VerIterator FindNowVersion(const pkgCache::PkgIterator &Pkg)
 201 {
 202    pkgCache::VerIterator Ver;
 203    for (Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
 204    {
 205       pkgCache::VerFileIterator Vf = Ver.FileList();
 206       pkgCache::PkgFileIterator F = Vf.File();
 207       for (F = Vf.File(); F.end() == false; ++F)
 208       {
 209          if (F && F.Archive())
 210          {
 211             if (strcmp(F.Archive(), "now"))
 212                return Ver;
 213          }
 214       }
 215    }
 216    return Ver;
 217 }
 218                                                                         /*}}}*/
 219
 220 // DPkgPM::pkgDPkgPM - Constructor                                      /*{{{*/
 221 // ---------------------------------------------------------------------
 222 /* */
 223 pkgDPkgPM::pkgDPkgPM(pkgDepCache *Cache)
 224    : pkgPackageManager(Cache), pkgFailures(0), PackagesDone(0), PackagesTotal(0)
 225 {
 226    d = new pkgDPkgPMPrivate();
 227 }
 228                                                                         /*}}}*/
 229 // DPkgPM::pkgDPkgPM - Destructor                                       /*{{{*/
 230 // ---------------------------------------------------------------------
 231 /* */
 232 pkgDPkgPM::~pkgDPkgPM()
 233 {
 234    delete d;
 235 }
 236                                                                         /*}}}*/
 237 // DPkgPM::Install - Install a package                                  /*{{{*/
 238 // ---------------------------------------------------------------------
 239 /* Add an install operation to the sequence list */
 240 bool pkgDPkgPM::Install(PkgIterator Pkg,string File)
 241 {
 242    if (File.empty() == true || Pkg.end() == true)
 243       return _error->Error("Internal Error, No file name for %s",Pkg.FullName().c_str());
 244
 245    // If the filename string begins with DPkg::Chroot-Directory, return the
 246    // substr that is within the chroot so dpkg can access it.
 247    string const chrootdir = _config->FindDir("DPkg::Chroot-Directory","/");
 248    if (chrootdir != "/" && File.find(chrootdir) == 0)
 249    {
 250       size_t len = chrootdir.length();
 251       if (chrootdir.at(len - 1) == '/')
 252         len--;
 253       List.push_back(Item(Item::Install,Pkg,File.substr(len)));
 254    }
 255    else
 256       List.push_back(Item(Item::Install,Pkg,File));
 257
 258    return true;
 259 }
 260                                                                         /*}}}*/
 261 // DPkgPM::Configure - Configure a package                              /*{{{*/
 262 // ---------------------------------------------------------------------
 263 /* Add a configure operation to the sequence list */
 264 bool pkgDPkgPM::Configure(PkgIterator Pkg)
 265 {
 266    if (Pkg.end() == true)
 267       return false;
 268
 269    List.push_back(Item(Item::Configure, Pkg));
 270
 271    // Use triggers for config calls if we configure "smart"
 272    // as otherwise Pre-Depends will not be satisfied, see #526774
 273    if (_config->FindB("DPkg::TriggersPending", false) == true)
 274       List.push_back(Item(Item::TriggersPending, PkgIterator()));
 275
 276    return true;
 277 }
 278                                                                         /*}}}*/
 279 // DPkgPM::Remove - Remove a package                                    /*{{{*/
 280 // ---------------------------------------------------------------------
 281 /* Add a remove operation to the sequence list */
 282 bool pkgDPkgPM::Remove(PkgIterator Pkg,bool Purge)
 283 {
 284    if (Pkg.end() == true)
 285       return false;
 286
 287    if (Purge == true)
 288       List.push_back(Item(Item::Purge,Pkg));
 289    else
 290       List.push_back(Item(Item::Remove,Pkg));
 291    return true;
 292 }
 293                                                                         /*}}}*/
 294 // DPkgPM::SendPkgInfo - Send info for install-pkgs hook                /*{{{*/
 295 // ---------------------------------------------------------------------
 296 /* This is part of the helper script communication interface, it sends
 297    very complete information down to the other end of the pipe.*/
 298 bool pkgDPkgPM::SendV2Pkgs(FILE *F)
 299 {
 300    return SendPkgsInfo(F, 2);
 301 }
 302 bool pkgDPkgPM::SendPkgsInfo(FILE * const F, unsigned int const &Version)
 303 {
 304    // This version of APT supports only v3, so don't sent higher versions
 305    if (Version <= 3)
 306       fprintf(F,"VERSION %u\n", Version);
 307    else
 308       fprintf(F,"VERSION 3\n");
 309
 310    /* Write out all of the configuration directives by walking the
 311       configuration tree */
 312    const Configuration::Item *Top = _config->Tree(0);
 313    for (; Top != 0;)
 314    {
 315       if (Top->Value.empty() == false)
 316       {
 317          fprintf(F,"%s=%s\n",
 318                  QuoteString(Top->FullTag(),"=\"\n").c_str(),
 319                  QuoteString(Top->Value,"\n").c_str());
 320       }
 321
 322       if (Top->Child != 0)
 323       {
 324          Top = Top->Child;
 325          continue;
 326       }
 327
 328       while (Top != 0 && Top->Next == 0)
 329          Top = Top->Parent;
 330       if (Top != 0)
 331          Top = Top->Next;
 332    }
 333    fprintf(F,"\n");
 334
 335    // Write out the package actions in order.
 336    for (vector<Item>::iterator I = List.begin(); I != List.end(); ++I)
 337    {
 338       if(I->Pkg.end() == true)
 339          continue;
 340
 341       pkgDepCache::StateCache &S = Cache[I->Pkg];
 342
 343       fprintf(F,"%s ",I->Pkg.Name());
 344
 345       // Current version which we are going to replace
 346       pkgCache::VerIterator CurVer = I->Pkg.CurrentVer();
 347       if (CurVer.end() == true && (I->Op == Item::Remove || I->Op == Item::Purge))
 348          CurVer = FindNowVersion(I->Pkg);
 349
 350       if (CurVer.end() == true)
 351       {
 352          if (Version <= 2)
 353             fprintf(F, "- ");
 354          else
 355             fprintf(F, "- - none ");
 356       }
 357       else
 358       {
 359          fprintf(F, "%s ", CurVer.VerStr());
 360          if (Version >= 3)
 361             fprintf(F, "%s %s ", CurVer.Arch(), CurVer.MultiArchType());
 362       }
 363
 364       // Show the compare operator between current and install version
 365       if (S.InstallVer != 0)
 366       {
 367          pkgCache::VerIterator const InstVer = S.InstVerIter(Cache);
 368          int Comp = 2;
 369          if (CurVer.end() == false)
 370             Comp = InstVer.CompareVer(CurVer);
 371          if (Comp < 0)
 372             fprintf(F,"> ");
 373          else if (Comp == 0)
 374             fprintf(F,"= ");
 375          else if (Comp > 0)
 376             fprintf(F,"< ");
 377          fprintf(F, "%s ", InstVer.VerStr());
 378          if (Version >= 3)
 379             fprintf(F, "%s %s ", InstVer.Arch(), InstVer.MultiArchType());
 380       }
 381       else
 382       {
 383          if (Version <= 2)
 384             fprintf(F, "> - ");
 385          else
 386             fprintf(F, "> - - none ");
 387       }
 388
 389       // Show the filename/operation
 390       if (I->Op == Item::Install)
 391       {
 392          // No errors here..
 393          if (I->File[0] != '/')
 394             fprintf(F,"**ERROR**\n");
 395          else
 396             fprintf(F,"%s\n",I->File.c_str());
 397       }
 398       else if (I->Op == Item::Configure)
 399          fprintf(F,"**CONFIGURE**\n");
 400       else if (I->Op == Item::Remove ||
 401           I->Op == Item::Purge)
 402          fprintf(F,"**REMOVE**\n");
 403
 404       if (ferror(F) != 0)
 405          return false;
 406    }
 407    return true;
 408 }
 409                                                                         /*}}}*/
 410 // DPkgPM::RunScriptsWithPkgs - Run scripts with package names on stdin /*{{{*/
 411 // ---------------------------------------------------------------------
 412 /* This looks for a list of scripts to run from the configuration file
 413    each one is run and is fed on standard input a list of all .deb files
 414    that are due to be installed. */
 415 bool pkgDPkgPM::RunScriptsWithPkgs(const char *Cnf)
 416 {
 417    bool result = true;
 418
 419    Configuration::Item const *Opts = _config->Tree(Cnf);
 420    if (Opts == 0 || Opts->Child == 0)
 421       return true;
 422    Opts = Opts->Child;
 423
 424    sighandler_t old_sigpipe = signal(SIGPIPE, SIG_IGN);
 425
 426    unsigned int Count = 1;
 427    for (; Opts != 0; Opts = Opts->Next, Count++)
 428    {
 429       if (Opts->Value.empty() == true)
 430          continue;
 431
 432       if(_config->FindB("Debug::RunScripts", false) == true)
 433          std::clog << "Running external script with list of all .deb file: '"
 434                    << Opts->Value << "'" << std::endl;
 435
 436       // Determine the protocol version
 437       string OptSec = Opts->Value;
 438       string::size_type Pos;
 439       if ((Pos = OptSec.find(' ')) == string::npos || Pos == 0)
 440          Pos = OptSec.length();
 441       OptSec = "DPkg::Tools::Options::" + string(Opts->Value.c_str(),Pos);
 442
 443       unsigned int Version = _config->FindI(OptSec+"::Version",1);
 444       unsigned int InfoFD = _config->FindI(OptSec + "::InfoFD", STDIN_FILENO);
 445
 446       // Create the pipes
 447       std::set<int> KeepFDs;
 448       MergeKeepFdsFromConfiguration(KeepFDs);
 449       int Pipes[2];
 450       if (pipe(Pipes) != 0) {
 451          result = _error->Errno("pipe","Failed to create IPC pipe to subprocess");
 452          break;
 453       }
 454       if (InfoFD != (unsigned)Pipes[0])
 455          SetCloseExec(Pipes[0],true);
 456       else
 457          KeepFDs.insert(Pipes[0]);
 458
 459
 460       SetCloseExec(Pipes[1],true);
 461
 462       // Purified Fork for running the script
 463       pid_t Process = ExecFork(KeepFDs);
 464       if (Process == 0)
 465       {
 466          // Setup the FDs
 467          dup2(Pipes[0], InfoFD);
 468          SetCloseExec(STDOUT_FILENO,false);
 469          SetCloseExec(STDIN_FILENO,false);
 470          SetCloseExec(STDERR_FILENO,false);
 471
 472          string hookfd;
 473          strprintf(hookfd, "%d", InfoFD);
 474          setenv("APT_HOOK_INFO_FD", hookfd.c_str(), 1);
 475
 476          dpkgChrootDirectory();
 477          const char *Args[4];
 478          Args[0] = "/bin/sh";
 479          Args[1] = "-c";
 480          Args[2] = Opts->Value.c_str();
 481          Args[3] = 0;
 482          execv(Args[0],(char **)Args);
 483          _exit(100);
 484       }
 485       close(Pipes[0]);
 486       FILE *F = fdopen(Pipes[1],"w");
 487       if (F == 0) {
 488          result = _error->Errno("fdopen","Faild to open new FD");
 489          break;
 490       }
 491
 492       // Feed it the filenames.
 493       if (Version <= 1)
 494       {
 495          for (vector<Item>::iterator I = List.begin(); I != List.end(); ++I)
 496          {
 497             // Only deal with packages to be installed from .deb
 498             if (I->Op != Item::Install)
 499                continue;
 500
 501             // No errors here..
 502             if (I->File[0] != '/')
 503                continue;
 504
 505             /* Feed the filename of each package that is pending install
 506                into the pipe. */
 507             fprintf(F,"%s\n",I->File.c_str());
 508             if (ferror(F) != 0)
 509                break;
 510          }
 511       }
 512       else
 513          SendPkgsInfo(F, Version);
 514
 515       fclose(F);
 516
 517       // Clean up the sub process
 518       if (ExecWait(Process,Opts->Value.c_str()) == false) {
 519          result = _error->Error("Failure running script %s",Opts->Value.c_str());
 520          break;
 521       }
 522    }
 523    signal(SIGPIPE, old_sigpipe);
 524
 525    return result;
 526 }
 527                                                                         /*}}}*/
 528 // DPkgPM::DoStdin - Read stdin and pass to master pty                  /*{{{*/
 529 // ---------------------------------------------------------------------
 530 /*
 531 */
 532 void pkgDPkgPM::DoStdin(int master)
 533 {
 534    unsigned char input_buf[256] = {0,};
 535    ssize_t len = read(0, input_buf, sizeof(input_buf));
 536    if (len)
 537       FileFd::Write(master, input_buf, len);
 538    else
 539       d->stdin_is_dev_null = true;
 540 }
 541                                                                         /*}}}*/
 542 // DPkgPM::DoTerminalPty - Read the terminal pty and write log          /*{{{*/
 543 // ---------------------------------------------------------------------
 544 /*
 545  * read the terminal pty and write log
 546  */
 547 void pkgDPkgPM::DoTerminalPty(int master)
 548 {
 549    unsigned char term_buf[1024] = {0,0, };
 550
 551    ssize_t len=read(master, term_buf, sizeof(term_buf));
 552    if(len == -1 && errno == EIO)
 553    {
 554       // this happens when the child is about to exit, we
 555       // give it time to actually exit, otherwise we run
 556       // into a race so we sleep for half a second.
 557       struct timespec sleepfor = { 0, 500000000 };
 558       nanosleep(&sleepfor, NULL);
 559       return;
 560    }
 561    if(len <= 0)
 562       return;
 563    FileFd::Write(1, term_buf, len);
 564    if(d->term_out)
 565       fwrite(term_buf, len, sizeof(char), d->term_out);
 566 }
 567                                                                         /*}}}*/
 568 // DPkgPM::ProcessDpkgStatusBuf                                         /*{{{*/
 569 // ---------------------------------------------------------------------
 570 /*
 571  */
 572 void pkgDPkgPM::ProcessDpkgStatusLine(char *line)
 573 {
 574    bool const Debug = _config->FindB("Debug::pkgDPkgProgressReporting",false);
 575    if (Debug == true)
 576       std::clog << "got from dpkg '" << line << "'" << std::endl;
 577
 578    /* dpkg sends strings like this:
 579       'status:   <pkg>: <pkg  qstate>'
 580       'status:   <pkg>:<arch>: <pkg  qstate>'
 581
 582       'processing: {install,upgrade,configure,remove,purge,disappear,trigproc}: pkg'
 583       'processing: {install,upgrade,configure,remove,purge,disappear,trigproc}: trigger'
 584    */
 585
 586    // we need to split on ": " (note the appended space) as the ':' is
 587    // part of the pkgname:arch information that dpkg sends
 588    //
 589    // A dpkg error message may contain additional ":" (like
 590    //  "failed in buffer_write(fd) (10, ret=-1): backend dpkg-deb ..."
 591    // so we need to ensure to not split too much
 592    std::vector<std::string> list = StringSplit(line, ": ", 4);
 593    if(list.size() < 3)
 594    {
 595       if (Debug == true)
 596          std::clog << "ignoring line: not enough ':'" << std::endl;
 597       return;
 598    }
 599
 600    // build the (prefix, pkgname, action) tuple, position of this
 601    // is different for "processing" or "status" messages
 602    std::string prefix = APT::String::Strip(list[0]);
 603    std::string pkgname;
 604    std::string action;
 605
 606    // "processing" has the form "processing: action: pkg or trigger"
 607    // with action = ["install", "upgrade", "configure", "remove", "purge",
 608    //                "disappear", "trigproc"]
 609    if (prefix == "processing")
 610    {
 611       pkgname = APT::String::Strip(list[2]);
 612       action = APT::String::Strip(list[1]);
 613       // we don't care for the difference (as dpkg doesn't really either)
 614       if (action == "upgrade")
 615          action = "install";
 616    }
 617    // "status" has the form: "status: pkg: state"
 618    // with state in ["half-installed", "unpacked", "half-configured",
 619    //                "installed", "config-files", "not-installed"]
 620    else if (prefix == "status")
 621    {
 622       pkgname = APT::String::Strip(list[1]);
 623       action = APT::String::Strip(list[2]);
 624    } else {
 625       if (Debug == true)
 626          std::clog << "unknown prefix '" << prefix << "'" << std::endl;
 627       return;
 628    }
 629
 630
 631    /* handle the special cases first:
 632
 633       errors look like this:
 634       '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
 635       and conffile-prompt like this
 636       'status:/etc/compiz.conf/compiz.conf :  conffile-prompt: 'current-conffile' 'new-conffile' useredited distedited
 637    */
 638    if (prefix == "status")
 639    {
 640       if(action == "error")
 641       {
 642          d->progress->Error(pkgname, PackagesDone, PackagesTotal,
 643                             list[3]);
 644          pkgFailures++;
 645          WriteApportReport(pkgname.c_str(), list[3].c_str());
 646          return;
 647       }
 648       else if(action == "conffile-prompt")
 649       {
 650          d->progress->ConffilePrompt(pkgname, PackagesDone, PackagesTotal,
 651                                      list[3]);
 652          return;
 653       }
 654    }
 655
 656    // at this point we know that we should have a valid pkgname, so build all
 657    // the info from it
 658
 659    // dpkg does not always send "pkgname:arch" so we add it here if needed
 660    if (pkgname.find(":") == std::string::npos)
 661    {
 662       // find the package in the group that is touched by dpkg
 663       // if there are multiple pkgs dpkg would send us a full pkgname:arch
 664       pkgCache::GrpIterator Grp = Cache.FindGrp(pkgname);
 665       if (Grp.end() == false)
 666       {
 667          pkgCache::PkgIterator P = Grp.PackageList();
 668          for (; P.end() != true; P = Grp.NextPkg(P))
 669          {
 670             if(Cache[P].Keep() == false || Cache[P].ReInstall() == true)
 671             {
 672                pkgname = P.FullName();
 673                break;
 674             }
 675          }
 676       }
 677    }
 678
 679    const char* const pkg = pkgname.c_str();
 680    std::string short_pkgname = StringSplit(pkgname, ":")[0];
 681    std::string arch = "";
 682    if (pkgname.find(":") != string::npos)
 683       arch = StringSplit(pkgname, ":")[1];
 684    std::string i18n_pkgname = pkgname;
 685    if (arch.size() != 0)
 686       strprintf(i18n_pkgname, "%s (%s)", short_pkgname.c_str(), arch.c_str());
 687
 688    // 'processing' from dpkg looks like
 689    // 'processing: action: pkg'
 690    if(prefix == "processing")
 691    {
 692       const std::pair<const char *, const char *> * const iter =
 693         std::find_if(PackageProcessingOpsBegin,
 694                      PackageProcessingOpsEnd,
 695                      MatchProcessingOp(action.c_str()));
 696       if(iter == PackageProcessingOpsEnd)
 697       {
 698          if (Debug == true)
 699             std::clog << "ignoring unknown action: " << action << std::endl;
 700          return;
 701       }
 702       std::string msg;
 703       strprintf(msg, _(iter->second), i18n_pkgname.c_str());
 704       d->progress->StatusChanged(pkgname, PackagesDone, PackagesTotal, msg);
 705
 706       // FIXME: this needs a muliarch testcase
 707       // FIXME2: is "pkgname" here reliable with dpkg only sending us
 708       //         short pkgnames?
 709       if (action == "disappear")
 710          handleDisappearAction(pkgname);
 711       return;
 712    }
 713
 714    if (prefix == "status")
 715    {
 716       vector<struct DpkgState> const &states = PackageOps[pkg];
 717       if(PackageOpsDone[pkg] < states.size())
 718       {
 719          char const * const next_action = states[PackageOpsDone[pkg]].state;
 720          if (next_action && Debug == true)
 721             std::clog << "(parsed from dpkg) pkg: " << short_pkgname
 722                << " action: " << action << " (expected: '" << next_action << "' "
 723                << PackageOpsDone[pkg] << " of " << states.size() << ")" << endl;
 724
 725          // check if the package moved to the next dpkg state
 726          if(next_action && (action == next_action))
 727          {
 728             // only read the translation if there is actually a next action
 729             char const * const translation = _(states[PackageOpsDone[pkg]].str);
 730
 731             // we moved from one dpkg state to a new one, report that
 732             ++PackageOpsDone[pkg];
 733             ++PackagesDone;
 734
 735             std::string msg;
 736             strprintf(msg, translation, i18n_pkgname.c_str());
 737             d->progress->StatusChanged(pkgname, PackagesDone, PackagesTotal, msg);
 738          }
 739       }
 740    }
 741 }
 742                                                                         /*}}}*/
 743 // DPkgPM::handleDisappearAction                                        /*{{{*/
 744 void pkgDPkgPM::handleDisappearAction(string const &pkgname)
 745 {
 746    pkgCache::PkgIterator Pkg = Cache.FindPkg(pkgname);
 747    if (unlikely(Pkg.end() == true))
 748       return;
 749
 750    // record the package name for display and stuff later
 751    disappearedPkgs.insert(Pkg.FullName(true));
 752
 753    // the disappeared package was auto-installed - nothing to do
 754    if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
 755       return;
 756    pkgCache::VerIterator PkgVer = Cache[Pkg].InstVerIter(Cache);
 757    if (unlikely(PkgVer.end() == true))
 758       return;
 759    /* search in the list of dependencies for (Pre)Depends,
 760       check if this dependency has a Replaces on our package
 761       and if so transfer the manual installed flag to it */
 762    for (pkgCache::DepIterator Dep = PkgVer.DependsList(); Dep.end() != true; ++Dep)
 763    {
 764       if (Dep->Type != pkgCache::Dep::Depends &&
 765           Dep->Type != pkgCache::Dep::PreDepends)
 766          continue;
 767       pkgCache::PkgIterator Tar = Dep.TargetPkg();
 768       if (unlikely(Tar.end() == true))
 769          continue;
 770       // the package is already marked as manual
 771       if ((Cache[Tar].Flags & pkgCache::Flag::Auto) != pkgCache::Flag::Auto)
 772          continue;
 773       pkgCache::VerIterator TarVer =  Cache[Tar].InstVerIter(Cache);
 774       if (TarVer.end() == true)
 775          continue;
 776       for (pkgCache::DepIterator Rep = TarVer.DependsList(); Rep.end() != true; ++Rep)
 777       {
 778          if (Rep->Type != pkgCache::Dep::Replaces)
 779             continue;
 780          if (Pkg != Rep.TargetPkg())
 781             continue;
 782          // okay, they are strongly connected - transfer manual-bit
 783          if (Debug == true)
 784             std::clog << "transfer manual-bit from disappeared »" << pkgname << "« to »" << Tar.FullName() << "«" << std::endl;
 785          Cache[Tar].Flags &= ~Flag::Auto;
 786          break;
 787       }
 788    }
 789 }
 790                                                                         /*}}}*/
 791 // DPkgPM::DoDpkgStatusFd                                               /*{{{*/
 792 // ---------------------------------------------------------------------
 793 /*
 794  */
 795 void pkgDPkgPM::DoDpkgStatusFd(int statusfd)
 796 {
 797    char *p, *q;
 798    int len;
 799
 800    len=read(statusfd, &d->dpkgbuf[d->dpkgbuf_pos], sizeof(d->dpkgbuf)-d->dpkgbuf_pos);
 801    d->dpkgbuf_pos += len;
 802    if(len <= 0)
 803       return;
 804
 805    // process line by line if we have a buffer
 806    p = q = d->dpkgbuf;
 807    while((q=(char*)memchr(p, '\n', d->dpkgbuf+d->dpkgbuf_pos-p)) != NULL)
 808    {
 809       *q = 0;
 810       ProcessDpkgStatusLine(p);
 811       p=q+1; // continue with next line
 812    }
 813
 814    // now move the unprocessed bits (after the final \n that is now a 0x0)
 815    // to the start and update d->dpkgbuf_pos
 816    p = (char*)memrchr(d->dpkgbuf, 0, d->dpkgbuf_pos);
 817    if(p == NULL)
 818       return;
 819
 820    // we are interessted in the first char *after* 0x0
 821    p++;
 822
 823    // move the unprocessed tail to the start and update pos
 824    memmove(d->dpkgbuf, p, p-d->dpkgbuf);
 825    d->dpkgbuf_pos = d->dpkgbuf+d->dpkgbuf_pos-p;
 826 }
 827                                                                         /*}}}*/
 828 // DPkgPM::WriteHistoryTag                                              /*{{{*/
 829 void pkgDPkgPM::WriteHistoryTag(string const &tag, string value)
 830 {
 831    size_t const length = value.length();
 832    if (length == 0)
 833       return;
 834    // poor mans rstrip(", ")
 835    if (value[length-2] == ',' && value[length-1] == ' ')
 836       value.erase(length - 2, 2);
 837    fprintf(d->history_out, "%s: %s\n", tag.c_str(), value.c_str());
 838 }                                                                       /*}}}*/
 839 // DPkgPM::OpenLog                                                      /*{{{*/
 840 bool pkgDPkgPM::OpenLog()
 841 {
 842    string const logdir = _config->FindDir("Dir::Log");
 843    if(CreateAPTDirectoryIfNeeded(logdir, logdir) == false)
 844       // FIXME: use a better string after freeze
 845       return _error->Error(_("Directory '%s' missing"), logdir.c_str());
 846
 847    // get current time
 848    char timestr[200];
 849    time_t const t = time(NULL);
 850    struct tm const * const tmp = localtime(&t);
 851    strftime(timestr, sizeof(timestr), "%F  %T", tmp);
 852
 853    // open terminal log
 854    string const logfile_name = flCombine(logdir,
 855                                    _config->Find("Dir::Log::Terminal"));
 856    if (!logfile_name.empty())
 857    {
 858       d->term_out = fopen(logfile_name.c_str(),"a");
 859       if (d->term_out == NULL)
 860          return _error->WarningE("OpenLog", _("Could not open file '%s'"), logfile_name.c_str());
 861       setvbuf(d->term_out, NULL, _IONBF, 0);
 862       SetCloseExec(fileno(d->term_out), true);
 863       if (getuid() == 0) // if we aren't root, we can't chown a file, so don't try it
 864       {
 865          struct passwd *pw = getpwnam("root");
 866          struct group *gr = getgrnam("adm");
 867          if (pw != NULL && gr != NULL && chown(logfile_name.c_str(), pw->pw_uid, gr->gr_gid) != 0)
 868             _error->WarningE("OpenLog", "chown to root:adm of file %s failed", logfile_name.c_str());
 869       }
 870       if (chmod(logfile_name.c_str(), 0640) != 0)
 871          _error->WarningE("OpenLog", "chmod 0640 of file %s failed", logfile_name.c_str());
 872       fprintf(d->term_out, "\nLog started: %s\n", timestr);
 873    }
 874
 875    // write your history
 876    string const history_name = flCombine(logdir,
 877                                    _config->Find("Dir::Log::History"));
 878    if (!history_name.empty())
 879    {
 880       d->history_out = fopen(history_name.c_str(),"a");
 881       if (d->history_out == NULL)
 882          return _error->WarningE("OpenLog", _("Could not open file '%s'"), history_name.c_str());
 883       SetCloseExec(fileno(d->history_out), true);
 884       chmod(history_name.c_str(), 0644);
 885       fprintf(d->history_out, "\nStart-Date: %s\n", timestr);
 886       string remove, purge, install, reinstall, upgrade, downgrade;
 887       for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
 888       {
 889          enum { CANDIDATE, CANDIDATE_AUTO, CURRENT_CANDIDATE, CURRENT } infostring;
 890          string *line = NULL;
 891          #define HISTORYINFO(X, Y) { line = &X; infostring = Y; }
 892          if (Cache[I].NewInstall() == true)
 893             HISTORYINFO(install, CANDIDATE_AUTO)
 894          else if (Cache[I].ReInstall() == true)
 895             HISTORYINFO(reinstall, CANDIDATE)
 896          else if (Cache[I].Upgrade() == true)
 897             HISTORYINFO(upgrade, CURRENT_CANDIDATE)
 898          else if (Cache[I].Downgrade() == true)
 899             HISTORYINFO(downgrade, CURRENT_CANDIDATE)
 900          else if (Cache[I].Delete() == true)
 901             HISTORYINFO((Cache[I].Purge() ? purge : remove), CURRENT)
 902          else
 903             continue;
 904          #undef HISTORYINFO
 905          line->append(I.FullName(false)).append(" (");
 906          switch (infostring) {
 907          case CANDIDATE: line->append(Cache[I].CandVersion); break;
 908          case CANDIDATE_AUTO:
 909             line->append(Cache[I].CandVersion);
 910             if ((Cache[I].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
 911                line->append(", automatic");
 912             break;
 913          case CURRENT_CANDIDATE: line->append(Cache[I].CurVersion).append(", ").append(Cache[I].CandVersion); break;
 914          case CURRENT: line->append(Cache[I].CurVersion); break;
 915          }
 916          line->append("), ");
 917       }
 918       if (_config->Exists("Commandline::AsString") == true)
 919          WriteHistoryTag("Commandline", _config->Find("Commandline::AsString"));
 920       WriteHistoryTag("Install", install);
 921       WriteHistoryTag("Reinstall", reinstall);
 922       WriteHistoryTag("Upgrade", upgrade);
 923       WriteHistoryTag("Downgrade",downgrade);
 924       WriteHistoryTag("Remove",remove);
 925       WriteHistoryTag("Purge",purge);
 926       fflush(d->history_out);
 927    }
 928
 929    return true;
 930 }
 931                                                                         /*}}}*/
 932 // DPkg::CloseLog                                                       /*{{{*/
 933 bool pkgDPkgPM::CloseLog()
 934 {
 935    char timestr[200];
 936    time_t t = time(NULL);
 937    struct tm *tmp = localtime(&t);
 938    strftime(timestr, sizeof(timestr), "%F  %T", tmp);
 939
 940    if(d->term_out)
 941    {
 942       fprintf(d->term_out, "Log ended: ");
 943       fprintf(d->term_out, "%s", timestr);
 944       fprintf(d->term_out, "\n");
 945       fclose(d->term_out);
 946    }
 947    d->term_out = NULL;
 948
 949    if(d->history_out)
 950    {
 951       if (disappearedPkgs.empty() == false)
 952       {
 953          string disappear;
 954          for (std::set<std::string>::const_iterator d = disappearedPkgs.begin();
 955               d != disappearedPkgs.end(); ++d)
 956          {
 957             pkgCache::PkgIterator P = Cache.FindPkg(*d);
 958             disappear.append(*d);
 959             if (P.end() == true)
 960                disappear.append(", ");
 961             else
 962                disappear.append(" (").append(Cache[P].CurVersion).append("), ");
 963          }
 964          WriteHistoryTag("Disappeared", disappear);
 965       }
 966       if (d->dpkg_error.empty() == false)
 967          fprintf(d->history_out, "Error: %s\n", d->dpkg_error.c_str());
 968       fprintf(d->history_out, "End-Date: %s\n", timestr);
 969       fclose(d->history_out);
 970    }
 971    d->history_out = NULL;
 972
 973    return true;
 974 }
 975                                                                         /*}}}*/
 976                                                                         /*}}}*/
 977 /*{{{*/
 978 // This implements a racy version of pselect for those architectures
 979 // that don't have a working implementation.
 980 // FIXME: Probably can be removed on Lenny+1
 981 static int racy_pselect(int nfds, fd_set *readfds, fd_set *writefds,
 982    fd_set *exceptfds, const struct timespec *timeout,
 983    const sigset_t *sigmask)
 984 {
 985    sigset_t origmask;
 986    struct timeval tv;
 987    int retval;
 988
 989    tv.tv_sec = timeout->tv_sec;
 990    tv.tv_usec = timeout->tv_nsec/1000;
 991
 992    sigprocmask(SIG_SETMASK, sigmask, &origmask);
 993    retval = select(nfds, readfds, writefds, exceptfds, &tv);
 994    sigprocmask(SIG_SETMASK, &origmask, 0);
 995    return retval;
 996 }
 997                                                                         /*}}}*/
 998
 999 // DPkgPM::BuildPackagesProgressMap                                     /*{{{*/
1000 void pkgDPkgPM::BuildPackagesProgressMap()
1001 {
1002    // map the dpkg states to the operations that are performed
1003    // (this is sorted in the same way as Item::Ops)
1004    static const struct DpkgState DpkgStatesOpMap[][7] = {
1005       // Install operation
1006       {
1007          {"half-installed", N_("Preparing %s")},
1008          {"unpacked", N_("Unpacking %s") },
1009          {NULL, NULL}
1010       },
1011       // Configure operation
1012       {
1013          {"unpacked",N_("Preparing to configure %s") },
1014          {"half-configured", N_("Configuring %s") },
1015          { "installed", N_("Installed %s")},
1016          {NULL, NULL}
1017       },
1018       // Remove operation
1019       {
1020          {"half-configured", N_("Preparing for removal of %s")},
1021          {"half-installed", N_("Removing %s")},
1022          {"config-files",  N_("Removed %s")},
1023          {NULL, NULL}
1024       },
1025       // Purge operation
1026       {
1027          {"config-files", N_("Preparing to completely remove %s")},
1028          {"not-installed", N_("Completely removed %s")},
1029          {NULL, NULL}
1030       },
1031    };
1032
1033    // init the PackageOps map, go over the list of packages that
1034    // that will be [installed|configured|removed|purged] and add
1035    // them to the PackageOps map (the dpkg states it goes through)
1036    // and the PackageOpsTranslations (human readable strings)
1037    for (vector<Item>::const_iterator I = List.begin(); I != List.end(); ++I)
1038    {
1039       if((*I).Pkg.end() == true)
1040          continue;
1041
1042       string const name = (*I).Pkg.FullName();
1043       PackageOpsDone[name] = 0;
1044       for(int i=0; (DpkgStatesOpMap[(*I).Op][i]).state != NULL; ++i)
1045       {
1046          PackageOps[name].push_back(DpkgStatesOpMap[(*I).Op][i]);
1047          PackagesTotal++;
1048       }
1049    }
1050    /* one extra: We don't want the progress bar to reach 100%, especially not
1051       if we call dpkg --configure --pending and process a bunch of triggers
1052       while showing 100%. Also, spindown takes a while, so never reaching 100%
1053       is way more correct than reaching 100% while still doing stuff even if
1054       doing it this way is slightly bending the rules */
1055    ++PackagesTotal;
1056 }
1057                                                                         /*}}}*/
1058 #if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR < 13)
1059 bool pkgDPkgPM::Go(int StatusFd)
1060 {
1061    APT::Progress::PackageManager *progress = NULL;
1062    if (StatusFd == -1)
1063       progress = APT::Progress::PackageManagerProgressFactory();
1064    else
1065       progress = new APT::Progress::PackageManagerProgressFd(StatusFd);
1066
1067    return GoNoABIBreak(progress);
1068 }
1069 #endif
1070
1071 void pkgDPkgPM::StartPtyMagic()
1072 {
1073    if (_config->FindB("Dpkg::Use-Pty", true) == false)
1074    {
1075       d->master = -1;
1076       if (d->slave != NULL)
1077          free(d->slave);
1078       d->slave = NULL;
1079       return;
1080    }
1081
1082    _error->PushToStack();
1083
1084    d->master = posix_openpt(O_RDWR | O_NOCTTY);
1085    if (d->master == -1)
1086       _error->Errno("posix_openpt", _("Can not write log (%s)"), _("Is /dev/pts mounted?"));
1087    else if (unlockpt(d->master) == -1)
1088       _error->Errno("unlockpt", "Unlocking the slave of master fd %d failed!", d->master);
1089    else
1090    {
1091       char const * const slave_name = ptsname(d->master);
1092       if (slave_name == NULL)
1093          _error->Errno("ptsname", "Getting name for slave of master fd %d failed!", d->master);
1094       else
1095       {
1096          d->slave = strdup(slave_name);
1097          if (d->slave == NULL)
1098             _error->Errno("strdup", "Copying name %s for slave of master fd %d failed!", slave_name, d->master);
1099          else if (grantpt(d->master) == -1)
1100             _error->Errno("grantpt", "Granting access to slave %s based on master fd %d failed!", slave_name, d->master);
1101          else if (tcgetattr(STDIN_FILENO, &d->tt) == 0)
1102          {
1103             d->tt_is_valid = true;
1104             struct termios raw_tt;
1105             // copy window size of stdout if its a 'good' terminal
1106             if (tcgetattr(STDOUT_FILENO, &raw_tt) == 0)
1107             {
1108                struct winsize win;
1109                if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) < 0)
1110                   _error->Errno("ioctl", "Getting TIOCGWINSZ from stdout failed!");
1111                if (ioctl(d->master, TIOCSWINSZ, &win) < 0)
1112                   _error->Errno("ioctl", "Setting TIOCSWINSZ for master fd %d failed!", d->master);
1113             }
1114             if (tcsetattr(d->master, TCSANOW, &d->tt) == -1)
1115                _error->Errno("tcsetattr", "Setting in Start via TCSANOW for master fd %d failed!", d->master);
1116
1117             raw_tt = d->tt;
1118             cfmakeraw(&raw_tt);
1119             raw_tt.c_lflag &= ~ECHO;
1120             raw_tt.c_lflag |= ISIG;
1121             // block SIGTTOU during tcsetattr to prevent a hang if
1122             // the process is a member of the background process group
1123             // http://www.opengroup.org/onlinepubs/000095399/functions/tcsetattr.html
1124             sigemptyset(&d->sigmask);
1125             sigaddset(&d->sigmask, SIGTTOU);
1126             sigprocmask(SIG_BLOCK,&d->sigmask, &d->original_sigmask);
1127             if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw_tt) == -1)
1128                _error->Errno("tcsetattr", "Setting in Start via TCSAFLUSH for stdin failed!");
1129             sigprocmask(SIG_SETMASK, &d->original_sigmask, NULL);
1130
1131          }
1132          if (d->slave != NULL)
1133          {
1134             /* on linux, closing (and later reopening) all references to the slave
1135                makes the slave a death end, so we open it here to have one open all
1136                the time. We could use this fd in SetupSlavePtyMagic() for linux, but
1137                on kfreebsd we get an incorrect ("step like") output then while it has
1138                no problem with closing all references… so to avoid platform specific
1139                code here we combine both and be happy once more */
1140             d->protect_slave_from_dying = open(d->slave, O_RDWR | O_CLOEXEC | O_NOCTTY);
1141          }
1142       }
1143    }
1144
1145    if (_error->PendingError() == true)
1146    {
1147       if (d->master != -1)
1148       {
1149          close(d->master);
1150          d->master = -1;
1151       }
1152       if (d->slave != NULL)
1153       {
1154          free(d->slave);
1155          d->slave = NULL;
1156       }
1157       _error->DumpErrors(std::cerr);
1158    }
1159    _error->RevertToStack();
1160 }
1161 void pkgDPkgPM::SetupSlavePtyMagic()
1162 {
1163    if(d->master == -1 || d->slave == NULL)
1164       return;
1165
1166    if (close(d->master) == -1)
1167       _error->FatalE("close", "Closing master %d in child failed!", d->master);
1168    d->master = -1;
1169    if (setsid() == -1)
1170       _error->FatalE("setsid", "Starting a new session for child failed!");
1171
1172    int const slaveFd = open(d->slave, O_RDWR | O_NOCTTY);
1173    if (slaveFd == -1)
1174       _error->FatalE("open", _("Can not write log (%s)"), _("Is /dev/pts mounted?"));
1175    else if (ioctl(slaveFd, TIOCSCTTY, 0) < 0)
1176       _error->FatalE("ioctl", "Setting TIOCSCTTY for slave fd %d failed!", slaveFd);
1177    else
1178    {
1179       for (unsigned short i = 0; i < 3; ++i)
1180          if (dup2(slaveFd, i) == -1)
1181             _error->FatalE("dup2", "Dupping %d to %d in child failed!", slaveFd, i);
1182
1183       if (d->tt_is_valid == true && tcsetattr(STDIN_FILENO, TCSANOW, &d->tt) < 0)
1184          _error->FatalE("tcsetattr", "Setting in Setup via TCSANOW for slave fd %d failed!", slaveFd);
1185    }
1186
1187    if (slaveFd != -1)
1188       close(slaveFd);
1189 }
1190 void pkgDPkgPM::StopPtyMagic()
1191 {
1192    if (d->slave != NULL)
1193       free(d->slave);
1194    d->slave = NULL;
1195    if (d->protect_slave_from_dying != -1)
1196    {
1197       close(d->protect_slave_from_dying);
1198       d->protect_slave_from_dying = -1;
1199    }
1200    if(d->master >= 0)
1201    {
1202       if (d->tt_is_valid == true && tcsetattr(STDIN_FILENO, TCSAFLUSH, &d->tt) == -1)
1203          _error->FatalE("tcsetattr", "Setting in Stop via TCSAFLUSH for stdin failed!");
1204       close(d->master);
1205       d->master = -1;
1206    }
1207 }
1208
1209 // DPkgPM::Go - Run the sequence                                        /*{{{*/
1210 // ---------------------------------------------------------------------
1211 /* This globs the operations and calls dpkg
1212  *
1213  * If it is called with a progress object apt will report the install
1214  * progress to this object. It maps the dpkg states a package goes
1215  * through to human readable (and i10n-able)
1216  * names and calculates a percentage for each step.
1217  */
1218 #if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13)
1219 bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)
1220 #else
1221 bool pkgDPkgPM::GoNoABIBreak(APT::Progress::PackageManager *progress)
1222 #endif
1223 {
1224    pkgPackageManager::SigINTStop = false;
1225    d->progress = progress;
1226
1227    // Generate the base argument list for dpkg
1228    unsigned long StartSize = 0;
1229    std::vector<const char *> Args;
1230    std::string DpkgExecutable = getDpkgExecutable();
1231    Args.push_back(DpkgExecutable.c_str());
1232    StartSize += DpkgExecutable.length();
1233
1234    // Stick in any custom dpkg options
1235    Configuration::Item const *Opts = _config->Tree("DPkg::Options");
1236    if (Opts != 0)
1237    {
1238       Opts = Opts->Child;
1239       for (; Opts != 0; Opts = Opts->Next)
1240       {
1241          if (Opts->Value.empty() == true)
1242             continue;
1243          Args.push_back(Opts->Value.c_str());
1244          StartSize += Opts->Value.length();
1245       }
1246    }
1247
1248    size_t const BaseArgs = Args.size();
1249    // we need to detect if we can qualify packages with the architecture or not
1250    Args.push_back("--assert-multi-arch");
1251    Args.push_back(NULL);
1252
1253    pid_t dpkgAssertMultiArch = ExecFork();
1254    if (dpkgAssertMultiArch == 0)
1255    {
1256       dpkgChrootDirectory();
1257       // redirect everything to the ultimate sink as we only need the exit-status
1258       int const nullfd = open("/dev/null", O_RDONLY);
1259       dup2(nullfd, STDIN_FILENO);
1260       dup2(nullfd, STDOUT_FILENO);
1261       dup2(nullfd, STDERR_FILENO);
1262       execvp(Args[0], (char**) &Args[0]);
1263       _error->WarningE("dpkgGo", "Can't detect if dpkg supports multi-arch!");
1264       _exit(2);
1265    }
1266
1267    fd_set rfds;
1268    struct timespec tv;
1269
1270    // FIXME: do we really need this limit when we have MaxArgBytes?
1271    unsigned int const MaxArgs = _config->FindI("Dpkg::MaxArgs",32*1024);
1272
1273    // try to figure out the max environment size
1274    int OSArgMax = sysconf(_SC_ARG_MAX);
1275    if(OSArgMax < 0)
1276       OSArgMax = 32*1024;
1277    OSArgMax -= EnvironmentSize() - 2*1024;
1278    unsigned int const MaxArgBytes = _config->FindI("Dpkg::MaxArgBytes", OSArgMax);
1279    bool const NoTriggers = _config->FindB("DPkg::NoTriggers", false);
1280
1281    if (RunScripts("DPkg::Pre-Invoke") == false)
1282       return false;
1283
1284    if (RunScriptsWithPkgs("DPkg::Pre-Install-Pkgs") == false)
1285       return false;
1286
1287    // support subpressing of triggers processing for special
1288    // cases like d-i that runs the triggers handling manually
1289    bool const TriggersPending = _config->FindB("DPkg::TriggersPending", false);
1290    if (_config->FindB("DPkg::ConfigurePending", true) == true)
1291       List.push_back(Item(Item::ConfigurePending, PkgIterator()));
1292
1293    // for the progress
1294    BuildPackagesProgressMap();
1295
1296    d->stdin_is_dev_null = false;
1297
1298    // create log
1299    OpenLog();
1300
1301    bool dpkgMultiArch = false;
1302    if (dpkgAssertMultiArch > 0)
1303    {
1304       int Status = 0;
1305       while (waitpid(dpkgAssertMultiArch, &Status, 0) != dpkgAssertMultiArch)
1306       {
1307          if (errno == EINTR)
1308             continue;
1309          _error->WarningE("dpkgGo", _("Waited for %s but it wasn't there"), "dpkg --assert-multi-arch");
1310          break;
1311       }
1312       if (WIFEXITED(Status) == true && WEXITSTATUS(Status) == 0)
1313          dpkgMultiArch = true;
1314    }
1315
1316    // start pty magic before the loop
1317    StartPtyMagic();
1318
1319    // Tell the progress that its starting and fork dpkg
1320    d->progress->Start(d->master);
1321
1322    // this loop is runs once per dpkg operation
1323    vector<Item>::const_iterator I = List.begin();
1324    while (I != List.end())
1325    {
1326       // Do all actions with the same Op in one run
1327       vector<Item>::const_iterator J = I;
1328       if (TriggersPending == true)
1329          for (; J != List.end(); ++J)
1330          {
1331             if (J->Op == I->Op)
1332                continue;
1333             if (J->Op != Item::TriggersPending)
1334                break;
1335             vector<Item>::const_iterator T = J + 1;
1336             if (T != List.end() && T->Op == I->Op)
1337                continue;
1338             break;
1339          }
1340       else
1341          for (; J != List.end() && J->Op == I->Op; ++J)
1342             /* nothing */;
1343
1344       // keep track of allocated strings for multiarch package names
1345       std::vector<char *> Packages;
1346
1347       // start with the baseset of arguments
1348       unsigned long Size = StartSize;
1349       Args.erase(Args.begin() + BaseArgs, Args.end());
1350
1351       // Now check if we are within the MaxArgs limit
1352       //
1353       // this code below is problematic, because it may happen that
1354       // the argument list is split in a way that A depends on B
1355       // and they are in the same "--configure A B" run
1356       // - with the split they may now be configured in different
1357       //   runs, using Immediate-Configure-All can help prevent this.
1358       if (J - I > (signed)MaxArgs)
1359       {
1360          J = I + MaxArgs;
1361          unsigned long const size = MaxArgs + 10;
1362          Args.reserve(size);
1363          Packages.reserve(size);
1364       }
1365       else
1366       {
1367          unsigned long const size = (J - I) + 10;
1368          Args.reserve(size);
1369          Packages.reserve(size);
1370       }
1371
1372       int fd[2];
1373       if (pipe(fd) != 0)
1374          return _error->Errno("pipe","Failed to create IPC pipe to dpkg");
1375
1376 #define ADDARG(X) Args.push_back(X); Size += strlen(X)
1377 #define ADDARGC(X) Args.push_back(X); Size += sizeof(X) - 1
1378
1379       ADDARGC("--status-fd");
1380       char status_fd_buf[20];
1381       snprintf(status_fd_buf,sizeof(status_fd_buf),"%i", fd[1]);
1382       ADDARG(status_fd_buf);
1383       unsigned long const Op = I->Op;
1384
1385       switch (I->Op)
1386       {
1387          case Item::Remove:
1388          ADDARGC("--force-depends");
1389          ADDARGC("--force-remove-essential");
1390          ADDARGC("--remove");
1391          break;
1392
1393          case Item::Purge:
1394          ADDARGC("--force-depends");
1395          ADDARGC("--force-remove-essential");
1396          ADDARGC("--purge");
1397          break;
1398
1399          case Item::Configure:
1400          ADDARGC("--configure");
1401          break;
1402
1403          case Item::ConfigurePending:
1404          ADDARGC("--configure");
1405          ADDARGC("--pending");
1406          break;
1407
1408          case Item::TriggersPending:
1409          ADDARGC("--triggers-only");
1410          ADDARGC("--pending");
1411          break;
1412
1413          case Item::Install:
1414          ADDARGC("--unpack");
1415          ADDARGC("--auto-deconfigure");
1416          break;
1417       }
1418
1419       if (NoTriggers == true && I->Op != Item::TriggersPending &&
1420           I->Op != Item::ConfigurePending)
1421       {
1422          ADDARGC("--no-triggers");
1423       }
1424 #undef ADDARGC
1425
1426       // Write in the file or package names
1427       if (I->Op == Item::Install)
1428       {
1429          for (;I != J && Size < MaxArgBytes; ++I)
1430          {
1431             if (I->File[0] != '/')
1432                return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str());
1433             Args.push_back(I->File.c_str());
1434             Size += I->File.length();
1435          }
1436       }
1437       else
1438       {
1439          string const nativeArch = _config->Find("APT::Architecture");
1440          unsigned long const oldSize = I->Op == Item::Configure ? Size : 0;
1441          for (;I != J && Size < MaxArgBytes; ++I)
1442          {
1443             if((*I).Pkg.end() == true)
1444                continue;
1445             if (I->Op == Item::Configure && disappearedPkgs.find(I->Pkg.FullName(true)) != disappearedPkgs.end())
1446                continue;
1447             // We keep this here to allow "smooth" transitions from e.g. multiarch dpkg/ubuntu to dpkg/debian
1448             if (dpkgMultiArch == false && (I->Pkg.Arch() == nativeArch ||
1449                                            strcmp(I->Pkg.Arch(), "all") == 0 ||
1450                                            strcmp(I->Pkg.Arch(), "none") == 0))
1451             {
1452                char const * const name = I->Pkg.Name();
1453                ADDARG(name);
1454             }
1455             else
1456             {
1457                pkgCache::VerIterator PkgVer;
1458                std::string name = I->Pkg.Name();
1459                if (Op == Item::Remove || Op == Item::Purge)
1460                {
1461                   PkgVer = I->Pkg.CurrentVer();
1462                   if(PkgVer.end() == true)
1463                      PkgVer = FindNowVersion(I->Pkg);
1464                }
1465                else
1466                   PkgVer = Cache[I->Pkg].InstVerIter(Cache);
1467                if (strcmp(I->Pkg.Arch(), "none") == 0)
1468                   ; // never arch-qualify a package without an arch
1469                else if (PkgVer.end() == false)
1470                   name.append(":").append(PkgVer.Arch());
1471                else
1472                   _error->Warning("Can not find PkgVer for '%s'", name.c_str());
1473                char * const fullname = strdup(name.c_str());
1474                Packages.push_back(fullname);
1475                ADDARG(fullname);
1476             }
1477          }
1478          // skip configure action if all sheduled packages disappeared
1479          if (oldSize == Size)
1480             continue;
1481       }
1482 #undef ADDARG
1483
1484       J = I;
1485
1486       if (_config->FindB("Debug::pkgDPkgPM",false) == true)
1487       {
1488          for (std::vector<const char *>::const_iterator a = Args.begin();
1489               a != Args.end(); ++a)
1490             clog << *a << ' ';
1491          clog << endl;
1492          continue;
1493       }
1494       Args.push_back(NULL);
1495
1496       cout << flush;
1497       clog << flush;
1498       cerr << flush;
1499
1500       /* Mask off sig int/quit. We do this because dpkg also does when
1501          it forks scripts. What happens is that when you hit ctrl-c it sends
1502          it to all processes in the group. Since dpkg ignores the signal
1503          it doesn't die but we do! So we must also ignore it */
1504       sighandler_t old_SIGQUIT = signal(SIGQUIT,SIG_IGN);
1505       sighandler_t old_SIGINT = signal(SIGINT,SigINT);
1506
1507       // Check here for any SIGINT
1508       if (pkgPackageManager::SigINTStop && (Op == Item::Remove || Op == Item::Purge || Op == Item::Install))
1509          break;
1510
1511
1512       // ignore SIGHUP as well (debian #463030)
1513       sighandler_t old_SIGHUP = signal(SIGHUP,SIG_IGN);
1514
1515       // now run dpkg
1516       d->progress->StartDpkg();
1517       std::set<int> KeepFDs;
1518       KeepFDs.insert(fd[1]);
1519       MergeKeepFdsFromConfiguration(KeepFDs);
1520       pid_t Child = ExecFork(KeepFDs);
1521       if (Child == 0)
1522       {
1523          // This is the child
1524          SetupSlavePtyMagic();
1525          close(fd[0]); // close the read end of the pipe
1526
1527          dpkgChrootDirectory();
1528
1529          if (chdir(_config->FindDir("DPkg::Run-Directory","/").c_str()) != 0)
1530             _exit(100);
1531
1532          if (_config->FindB("DPkg::FlushSTDIN",true) == true && isatty(STDIN_FILENO))
1533          {
1534             int Flags;
1535             int dummy = 0;
1536             if ((Flags = fcntl(STDIN_FILENO,F_GETFL,dummy)) < 0)
1537                _exit(100);
1538
1539             // Discard everything in stdin before forking dpkg
1540             if (fcntl(STDIN_FILENO,F_SETFL,Flags | O_NONBLOCK) < 0)
1541                _exit(100);
1542
1543             while (read(STDIN_FILENO,&dummy,1) == 1);
1544
1545             if (fcntl(STDIN_FILENO,F_SETFL,Flags & (~(long)O_NONBLOCK)) < 0)
1546                _exit(100);
1547          }
1548
1549          /* No Job Control Stop Env is a magic dpkg var that prevents it
1550             from using sigstop */
1551          putenv((char *)"DPKG_NO_TSTP=yes");
1552          execvp(Args[0], (char**) &Args[0]);
1553          cerr << "Could not exec dpkg!" << endl;
1554          _exit(100);
1555       }
1556
1557       // apply ionice
1558       if (_config->FindB("DPkg::UseIoNice", false) == true)
1559          ionice(Child);
1560
1561       // Wait for dpkg
1562       int Status = 0;
1563
1564       // we read from dpkg here
1565       int const _dpkgin = fd[0];
1566       close(fd[1]);                        // close the write end of the pipe
1567
1568       // setups fds
1569       sigemptyset(&d->sigmask);
1570       sigprocmask(SIG_BLOCK,&d->sigmask,&d->original_sigmask);
1571
1572       /* free vectors (and therefore memory) as we don't need the included data anymore */
1573       for (std::vector<char *>::const_iterator p = Packages.begin();
1574            p != Packages.end(); ++p)
1575          free(*p);
1576       Packages.clear();
1577
1578       // the result of the waitpid call
1579       int res;
1580       int select_ret;
1581       while ((res=waitpid(Child,&Status, WNOHANG)) != Child) {
1582          if(res < 0) {
1583             // FIXME: move this to a function or something, looks ugly here
1584             // error handling, waitpid returned -1
1585             if (errno == EINTR)
1586                continue;
1587             RunScripts("DPkg::Post-Invoke");
1588
1589             // Restore sig int/quit
1590             signal(SIGQUIT,old_SIGQUIT);
1591             signal(SIGINT,old_SIGINT);
1592
1593             signal(SIGHUP,old_SIGHUP);
1594             return _error->Errno("waitpid","Couldn't wait for subprocess");
1595          }
1596
1597          // wait for input or output here
1598          FD_ZERO(&rfds);
1599          if (d->master >= 0 && !d->stdin_is_dev_null)
1600             FD_SET(0, &rfds);
1601          FD_SET(_dpkgin, &rfds);
1602          if(d->master >= 0)
1603             FD_SET(d->master, &rfds);
1604          tv.tv_sec = 0;
1605          tv.tv_nsec = d->progress->GetPulseInterval();
1606          select_ret = pselect(max(d->master, _dpkgin)+1, &rfds, NULL, NULL,
1607                               &tv, &d->original_sigmask);
1608          if (select_ret < 0 && (errno == EINVAL || errno == ENOSYS))
1609             select_ret = racy_pselect(max(d->master, _dpkgin)+1, &rfds, NULL,
1610                                       NULL, &tv, &d->original_sigmask);
1611          d->progress->Pulse();
1612          if (select_ret == 0)
1613             continue;
1614          else if (select_ret < 0 && errno == EINTR)
1615             continue;
1616          else if (select_ret < 0)
1617          {
1618             perror("select() returned error");
1619             continue;
1620          }
1621
1622          if(d->master >= 0 && FD_ISSET(d->master, &rfds))
1623             DoTerminalPty(d->master);
1624          if(d->master >= 0 && FD_ISSET(0, &rfds))
1625             DoStdin(d->master);
1626          if(FD_ISSET(_dpkgin, &rfds))
1627             DoDpkgStatusFd(_dpkgin);
1628       }
1629       close(_dpkgin);
1630
1631       // Restore sig int/quit
1632       signal(SIGQUIT,old_SIGQUIT);
1633       signal(SIGINT,old_SIGINT);
1634
1635       signal(SIGHUP,old_SIGHUP);
1636       // Check for an error code.
1637       if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
1638       {
1639          // if it was set to "keep-dpkg-runing" then we won't return
1640          // here but keep the loop going and just report it as a error
1641          // for later
1642          bool const stopOnError = _config->FindB("Dpkg::StopOnError",true);
1643
1644          if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV)
1645             strprintf(d->dpkg_error, "Sub-process %s received a segmentation fault.",Args[0]);
1646          else if (WIFEXITED(Status) != 0)
1647             strprintf(d->dpkg_error, "Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status));
1648          else
1649             strprintf(d->dpkg_error, "Sub-process %s exited unexpectedly",Args[0]);
1650          _error->Error("%s", d->dpkg_error.c_str());
1651
1652          if(stopOnError)
1653             break;
1654       }
1655    }
1656    // dpkg is done at this point
1657    d->progress->Stop();
1658    StopPtyMagic();
1659    CloseLog();
1660
1661    if (pkgPackageManager::SigINTStop)
1662        _error->Warning(_("Operation was interrupted before it could finish"));
1663
1664    if (RunScripts("DPkg::Post-Invoke") == false)
1665       return false;
1666
1667    if (_config->FindB("Debug::pkgDPkgPM",false) == false)
1668    {
1669       std::string const oldpkgcache = _config->FindFile("Dir::cache::pkgcache");
1670       if (oldpkgcache.empty() == false && RealFileExists(oldpkgcache) == true &&
1671           unlink(oldpkgcache.c_str()) == 0)
1672       {
1673          std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
1674          if (srcpkgcache.empty() == false && RealFileExists(srcpkgcache) == true)
1675          {
1676             _error->PushToStack();
1677             pkgCacheFile CacheFile;
1678             CacheFile.BuildCaches(NULL, true);
1679             _error->RevertToStack();
1680          }
1681       }
1682    }
1683
1684    Cache.writeStateFile(NULL);
1685    return d->dpkg_error.empty();
1686 }
1687
1688 void SigINT(int /*sig*/) {
1689    pkgPackageManager::SigINTStop = true;
1690 }
1691                                                                         /*}}}*/
1692 // pkgDpkgPM::Reset - Dump the contents of the command list             /*{{{*/
1693 // ---------------------------------------------------------------------
1694 /* */
1695 void pkgDPkgPM::Reset()
1696 {
1697    List.erase(List.begin(),List.end());
1698 }
1699                                                                         /*}}}*/
1700 // pkgDpkgPM::WriteApportReport - write out error report pkg failure    /*{{{*/
1701 // ---------------------------------------------------------------------
1702 /* */
1703 void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
1704 {
1705    // If apport doesn't exist or isn't installed do nothing
1706    // This e.g. prevents messages in 'universes' without apport
1707    pkgCache::PkgIterator apportPkg = Cache.FindPkg("apport");
1708    if (apportPkg.end() == true || apportPkg->CurrentVer == 0)
1709       return;
1710
1711    string pkgname, reportfile, srcpkgname, pkgver, arch;
1712    string::size_type pos;
1713    FILE *report;
1714
1715    if (_config->FindB("Dpkg::ApportFailureReport", true) == false)
1716    {
1717       std::clog << "configured to not write apport reports" << std::endl;
1718       return;
1719    }
1720
1721    // only report the first errors
1722    if(pkgFailures > _config->FindI("APT::Apport::MaxReports", 3))
1723    {
1724       std::clog << _("No apport report written because MaxReports is reached already") << std::endl;
1725       return;
1726    }
1727
1728    // check if its not a follow up error
1729    const char *needle = dgettext("dpkg", "dependency problems - leaving unconfigured");
1730    if(strstr(errormsg, needle) != NULL) {
1731       std::clog << _("No apport report written because the error message indicates its a followup error from a previous failure.") << std::endl;
1732       return;
1733    }
1734
1735    // do not report disk-full failures
1736    if(strstr(errormsg, strerror(ENOSPC)) != NULL) {
1737       std::clog << _("No apport report written because the error message indicates a disk full error") << std::endl;
1738       return;
1739    }
1740
1741    // do not report out-of-memory failures
1742    if(strstr(errormsg, strerror(ENOMEM)) != NULL ||
1743       strstr(errormsg, "failed to allocate memory") != NULL) {
1744       std::clog << _("No apport report written because the error message indicates a out of memory error") << std::endl;
1745       return;
1746    }
1747
1748    // do not report bugs regarding inaccessible local files
1749    if(strstr(errormsg, strerror(ENOENT)) != NULL ||
1750       strstr(errormsg, "cannot access archive") != NULL) {
1751       std::clog << _("No apport report written because the error message indicates an issue on the local system") << std::endl;
1752       return;
1753    }
1754
1755    // do not report errors encountered when decompressing packages
1756    if(strstr(errormsg, "--fsys-tarfile returned error exit status 2") != NULL) {
1757       std::clog << _("No apport report written because the error message indicates an issue on the local system") << std::endl;
1758       return;
1759    }
1760
1761    // do not report dpkg I/O errors, this is a format string, so we compare
1762    // the prefix and the suffix of the error with the dpkg error message
1763    vector<string> io_errors;
1764    io_errors.push_back(string("failed to read"));
1765    io_errors.push_back(string("failed to write"));
1766    io_errors.push_back(string("failed to seek"));
1767    io_errors.push_back(string("unexpected end of file or stream"));
1768
1769    for (vector<string>::iterator I = io_errors.begin(); I != io_errors.end(); ++I)
1770    {
1771       vector<string> list = VectorizeString(dgettext("dpkg", (*I).c_str()), '%');
1772       if (list.size() > 1) {
1773          // we need to split %s, VectorizeString only allows char so we need
1774          // to kill the "s" manually
1775          if (list[1].size() > 1) {
1776             list[1].erase(0, 1);
1777             if(strstr(errormsg, list[0].c_str()) &&
1778                strstr(errormsg, list[1].c_str())) {
1779                std::clog << _("No apport report written because the error message indicates a dpkg I/O error") << std::endl;
1780                return;
1781             }
1782          }
1783       }
1784    }
1785
1786    // get the pkgname and reportfile
1787    pkgname = flNotDir(pkgpath);
1788    pos = pkgname.find('_');
1789    if(pos != string::npos)
1790       pkgname = pkgname.substr(0, pos);
1791
1792    // find the package versin and source package name
1793    pkgCache::PkgIterator Pkg = Cache.FindPkg(pkgname);
1794    if (Pkg.end() == true)
1795       return;
1796    pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg);
1797    if (Ver.end() == true)
1798       return;
1799    pkgver = Ver.VerStr() == NULL ? "unknown" : Ver.VerStr();
1800    pkgRecords Recs(Cache);
1801    pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
1802    srcpkgname = Parse.SourcePkg();
1803    if(srcpkgname.empty())
1804       srcpkgname = pkgname;
1805
1806    // if the file exists already, we check:
1807    // - if it was reported already (touched by apport).
1808    //   If not, we do nothing, otherwise
1809    //    we overwrite it. This is the same behaviour as apport
1810    // - if we have a report with the same pkgversion already
1811    //   then we skip it
1812    reportfile = flCombine("/var/crash",pkgname+".0.crash");
1813    if(FileExists(reportfile))
1814    {
1815       struct stat buf;
1816       char strbuf[255];
1817
1818       // check atime/mtime
1819       stat(reportfile.c_str(), &buf);
1820       if(buf.st_mtime > buf.st_atime)
1821          return;
1822
1823       // check if the existing report is the same version
1824       report = fopen(reportfile.c_str(),"r");
1825       while(fgets(strbuf, sizeof(strbuf), report) != NULL)
1826       {
1827          if(strstr(strbuf,"Package:") == strbuf)
1828          {
1829             char pkgname[255], version[255];
1830             if(sscanf(strbuf, "Package: %254s %254s", pkgname, version) == 2)
1831                if(strcmp(pkgver.c_str(), version) == 0)
1832                {
1833                   fclose(report);
1834                   return;
1835                }
1836          }
1837       }
1838       fclose(report);
1839    }
1840
1841    // now write the report
1842    arch = _config->Find("APT::Architecture");
1843    report = fopen(reportfile.c_str(),"w");
1844    if(report == NULL)
1845       return;
1846    if(_config->FindB("DPkgPM::InitialReportOnly",false) == true)
1847       chmod(reportfile.c_str(), 0);
1848    else
1849       chmod(reportfile.c_str(), 0600);
1850    fprintf(report, "ProblemType: Package\n");
1851    fprintf(report, "Architecture: %s\n", arch.c_str());
1852    time_t now = time(NULL);
1853    fprintf(report, "Date: %s" , ctime(&now));
1854    fprintf(report, "Package: %s %s\n", pkgname.c_str(), pkgver.c_str());
1855    fprintf(report, "SourcePackage: %s\n", srcpkgname.c_str());
1856    fprintf(report, "ErrorMessage:\n %s\n", errormsg);
1857
1858    // ensure that the log is flushed
1859    if(d->term_out)
1860       fflush(d->term_out);
1861
1862    // attach terminal log it if we have it
1863    string logfile_name = _config->FindFile("Dir::Log::Terminal");
1864    if (!logfile_name.empty())
1865    {
1866       FILE *log = NULL;
1867
1868       fprintf(report, "DpkgTerminalLog:\n");
1869       log = fopen(logfile_name.c_str(),"r");
1870       if(log != NULL)
1871       {
1872          char buf[1024];
1873          while( fgets(buf, sizeof(buf), log) != NULL)
1874             fprintf(report, " %s", buf);
1875          fprintf(report, " \n");
1876          fclose(log);
1877       }
1878    }
1879
1880    // attach history log it if we have it
1881    string histfile_name = _config->FindFile("Dir::Log::History");
1882    if (!histfile_name.empty())
1883    {
1884       fprintf(report, "DpkgHistoryLog:\n");
1885       FILE* log = fopen(histfile_name.c_str(),"r");
1886       if(log != NULL)
1887       {
1888          char buf[1024];
1889          while( fgets(buf, sizeof(buf), log) != NULL)
1890             fprintf(report, " %s", buf);
1891          fclose(log);
1892       }
1893    }
1894
1895    // log the ordering
1896    const char *ops_str[] = {"Install", "Configure","Remove","Purge"};
1897    fprintf(report, "AptOrdering:\n");
1898    for (vector<Item>::iterator I = List.begin(); I != List.end(); ++I)
1899       if ((*I).Pkg != NULL)
1900          fprintf(report, " %s: %s\n", (*I).Pkg.Name(), ops_str[(*I).Op]);
1901       else
1902          fprintf(report, " %s: %s\n", "NULL", ops_str[(*I).Op]);
1903
1904    // attach dmesg log (to learn about segfaults)
1905    if (FileExists("/bin/dmesg"))
1906    {
1907       fprintf(report, "Dmesg:\n");
1908       FILE *log = popen("/bin/dmesg","r");
1909       if(log != NULL)
1910       {
1911          char buf[1024];
1912          while( fgets(buf, sizeof(buf), log) != NULL)
1913             fprintf(report, " %s", buf);
1914          pclose(log);
1915       }
1916    }
1917
1918    // attach df -l log (to learn about filesystem status)
1919    if (FileExists("/bin/df"))
1920    {
1921
1922       fprintf(report, "Df:\n");
1923       FILE *log = popen("/bin/df -l","r");
1924       if(log != NULL)
1925       {
1926          char buf[1024];
1927          while( fgets(buf, sizeof(buf), log) != NULL)
1928             fprintf(report, " %s", buf);
1929          pclose(log);
1930       }
1931    }
1932
1933    fclose(report);
1934
1935 }
1936                                                                         /*}}}*/