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(STDIN_FILENO, 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 }
1051                                                                         /*}}}*/
1052 bool pkgDPkgPM::Go(int StatusFd)
1053 {
1054    APT::Progress::PackageManager *progress = NULL;
1055    if (StatusFd == -1)
1056       progress = APT::Progress::PackageManagerProgressFactory();
1057    else
1058       progress = new APT::Progress::PackageManagerProgressFd(StatusFd);
1059
1060    return Go(progress);
1061 }
1062
1063 void pkgDPkgPM::StartPtyMagic()
1064 {
1065    if (_config->FindB("Dpkg::Use-Pty", true) == false)
1066    {
1067       d->master = -1;
1068       if (d->slave != NULL)
1069          free(d->slave);
1070       d->slave = NULL;
1071       return;
1072    }
1073
1074    _error->PushToStack();
1075
1076    d->master = posix_openpt(O_RDWR | O_NOCTTY);
1077    if (d->master == -1)
1078       _error->Errno("posix_openpt", _("Can not write log (%s)"), _("Is /dev/pts mounted?"));
1079    else if (unlockpt(d->master) == -1)
1080       _error->Errno("unlockpt", "Unlocking the slave of master fd %d failed!", d->master);
1081    else
1082    {
1083       char const * const slave_name = ptsname(d->master);
1084       if (slave_name == NULL)
1085          _error->Errno("ptsname", "Getting name for slave of master fd %d failed!", d->master);
1086       else
1087       {
1088          d->slave = strdup(slave_name);
1089          if (d->slave == NULL)
1090             _error->Errno("strdup", "Copying name %s for slave of master fd %d failed!", slave_name, d->master);
1091          else if (grantpt(d->master) == -1)
1092             _error->Errno("grantpt", "Granting access to slave %s based on master fd %d failed!", slave_name, d->master);
1093          else if (tcgetattr(STDIN_FILENO, &d->tt) == 0)
1094          {
1095             d->tt_is_valid = true;
1096             struct termios raw_tt;
1097             // copy window size of stdout if its a 'good' terminal
1098             if (tcgetattr(STDOUT_FILENO, &raw_tt) == 0)
1099             {
1100                struct winsize win;
1101                if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) < 0)
1102                   _error->Errno("ioctl", "Getting TIOCGWINSZ from stdout failed!");
1103                if (ioctl(d->master, TIOCSWINSZ, &win) < 0)
1104                   _error->Errno("ioctl", "Setting TIOCSWINSZ for master fd %d failed!", d->master);
1105             }
1106             if (tcsetattr(d->master, TCSANOW, &d->tt) == -1)
1107                _error->Errno("tcsetattr", "Setting in Start via TCSANOW for master fd %d failed!", d->master);
1108
1109             raw_tt = d->tt;
1110             cfmakeraw(&raw_tt);
1111             raw_tt.c_lflag &= ~ECHO;
1112             raw_tt.c_lflag |= ISIG;
1113             // block SIGTTOU during tcsetattr to prevent a hang if
1114             // the process is a member of the background process group
1115             // http://www.opengroup.org/onlinepubs/000095399/functions/tcsetattr.html
1116             sigemptyset(&d->sigmask);
1117             sigaddset(&d->sigmask, SIGTTOU);
1118             sigprocmask(SIG_BLOCK,&d->sigmask, &d->original_sigmask);
1119             if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw_tt) == -1)
1120                _error->Errno("tcsetattr", "Setting in Start via TCSAFLUSH for stdin failed!");
1121             sigprocmask(SIG_SETMASK, &d->original_sigmask, NULL);
1122
1123          }
1124          if (d->slave != NULL)
1125          {
1126             /* on linux, closing (and later reopening) all references to the slave
1127                makes the slave a death end, so we open it here to have one open all
1128                the time. We could use this fd in SetupSlavePtyMagic() for linux, but
1129                on kfreebsd we get an incorrect ("step like") output then while it has
1130                no problem with closing all references… so to avoid platform specific
1131                code here we combine both and be happy once more */
1132             d->protect_slave_from_dying = open(d->slave, O_RDWR | O_CLOEXEC);
1133          }
1134       }
1135    }
1136
1137    if (_error->PendingError() == true)
1138    {
1139       if (d->master != -1)
1140       {
1141          close(d->master);
1142          d->master = -1;
1143       }
1144       if (d->slave != NULL)
1145       {
1146          free(d->slave);
1147          d->slave = NULL;
1148       }
1149       _error->DumpErrors(std::cerr);
1150    }
1151    _error->RevertToStack();
1152 }
1153 void pkgDPkgPM::SetupSlavePtyMagic()
1154 {
1155    if(d->master == -1 || d->slave == NULL)
1156       return;
1157
1158    if (close(d->master) == -1)
1159       _error->FatalE("close", "Closing master %d in child failed!", d->master);
1160    d->master = -1;
1161    if (setsid() == -1)
1162       _error->FatalE("setsid", "Starting a new session for child failed!");
1163
1164    int const slaveFd = open(d->slave, O_RDWR);
1165    if (slaveFd == -1)
1166       _error->FatalE("open", _("Can not write log (%s)"), _("Is /dev/pts mounted?"));
1167    else if (ioctl(slaveFd, TIOCSCTTY, 0) < 0)
1168       _error->FatalE("ioctl", "Setting TIOCSCTTY for slave fd %d failed!", slaveFd);
1169    else
1170    {
1171       for (unsigned short i = 0; i < 3; ++i)
1172          if (dup2(slaveFd, i) == -1)
1173             _error->FatalE("dup2", "Dupping %d to %d in child failed!", slaveFd, i);
1174
1175       if (d->tt_is_valid == true && tcsetattr(STDIN_FILENO, TCSANOW, &d->tt) < 0)
1176          _error->FatalE("tcsetattr", "Setting in Setup via TCSANOW for slave fd %d failed!", slaveFd);
1177    }
1178
1179    if (slaveFd != -1)
1180       close(slaveFd);
1181 }
1182 void pkgDPkgPM::StopPtyMagic()
1183 {
1184    if (d->slave != NULL)
1185       free(d->slave);
1186    d->slave = NULL;
1187    if (d->protect_slave_from_dying != -1)
1188    {
1189       close(d->protect_slave_from_dying);
1190       d->protect_slave_from_dying = -1;
1191    }
1192    if(d->master >= 0)
1193    {
1194       if (d->tt_is_valid == true && tcsetattr(STDIN_FILENO, TCSAFLUSH, &d->tt) == -1)
1195          _error->FatalE("tcsetattr", "Setting in Stop via TCSAFLUSH for stdin failed!");
1196       close(d->master);
1197       d->master = -1;
1198    }
1199 }
1200
1201 // DPkgPM::Go - Run the sequence                                        /*{{{*/
1202 // ---------------------------------------------------------------------
1203 /* This globs the operations and calls dpkg
1204  *
1205  * If it is called with a progress object apt will report the install
1206  * progress to this object. It maps the dpkg states a package goes
1207  * through to human readable (and i10n-able)
1208  * names and calculates a percentage for each step.
1209  */
1210 bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)
1211 {
1212    pkgPackageManager::SigINTStop = false;
1213    d->progress = progress;
1214
1215    // Generate the base argument list for dpkg
1216    unsigned long StartSize = 0;
1217    std::vector<const char *> Args;
1218    std::string DpkgExecutable = getDpkgExecutable();
1219    Args.push_back(DpkgExecutable.c_str());
1220    StartSize += DpkgExecutable.length();
1221
1222    // Stick in any custom dpkg options
1223    Configuration::Item const *Opts = _config->Tree("DPkg::Options");
1224    if (Opts != 0)
1225    {
1226       Opts = Opts->Child;
1227       for (; Opts != 0; Opts = Opts->Next)
1228       {
1229          if (Opts->Value.empty() == true)
1230             continue;
1231          Args.push_back(Opts->Value.c_str());
1232          StartSize += Opts->Value.length();
1233       }
1234    }
1235
1236    size_t const BaseArgs = Args.size();
1237    // we need to detect if we can qualify packages with the architecture or not
1238    Args.push_back("--assert-multi-arch");
1239    Args.push_back(NULL);
1240
1241    pid_t dpkgAssertMultiArch = ExecFork();
1242    if (dpkgAssertMultiArch == 0)
1243    {
1244       dpkgChrootDirectory();
1245       // redirect everything to the ultimate sink as we only need the exit-status
1246       int const nullfd = open("/dev/null", O_RDONLY);
1247       dup2(nullfd, STDIN_FILENO);
1248       dup2(nullfd, STDOUT_FILENO);
1249       dup2(nullfd, STDERR_FILENO);
1250       execvp(Args[0], (char**) &Args[0]);
1251       _error->WarningE("dpkgGo", "Can't detect if dpkg supports multi-arch!");
1252       _exit(2);
1253    }
1254
1255    fd_set rfds;
1256    struct timespec tv;
1257
1258    // FIXME: do we really need this limit when we have MaxArgBytes?
1259    unsigned int const MaxArgs = _config->FindI("Dpkg::MaxArgs",32*1024);
1260
1261    // try to figure out the max environment size
1262    int OSArgMax = sysconf(_SC_ARG_MAX);
1263    if(OSArgMax < 0)
1264       OSArgMax = 32*1024;
1265    OSArgMax -= EnvironmentSize() - 2*1024;
1266    unsigned int const MaxArgBytes = _config->FindI("Dpkg::MaxArgBytes", OSArgMax);
1267    bool const NoTriggers = _config->FindB("DPkg::NoTriggers", false);
1268
1269    if (RunScripts("DPkg::Pre-Invoke") == false)
1270       return false;
1271
1272    if (RunScriptsWithPkgs("DPkg::Pre-Install-Pkgs") == false)
1273       return false;
1274
1275    // support subpressing of triggers processing for special
1276    // cases like d-i that runs the triggers handling manually
1277    bool const SmartConf = (_config->Find("PackageManager::Configure", "all") != "all");
1278    bool const TriggersPending = _config->FindB("DPkg::TriggersPending", false);
1279    if (_config->FindB("DPkg::ConfigurePending", SmartConf) == true)
1280       List.push_back(Item(Item::ConfigurePending, PkgIterator()));
1281
1282    // for the progress
1283    BuildPackagesProgressMap();
1284
1285    d->stdin_is_dev_null = false;
1286
1287    // create log
1288    OpenLog();
1289
1290    bool dpkgMultiArch = false;
1291    if (dpkgAssertMultiArch > 0)
1292    {
1293       int Status = 0;
1294       while (waitpid(dpkgAssertMultiArch, &Status, 0) != dpkgAssertMultiArch)
1295       {
1296          if (errno == EINTR)
1297             continue;
1298          _error->WarningE("dpkgGo", _("Waited for %s but it wasn't there"), "dpkg --assert-multi-arch");
1299          break;
1300       }
1301       if (WIFEXITED(Status) == true && WEXITSTATUS(Status) == 0)
1302          dpkgMultiArch = true;
1303    }
1304
1305    // start pty magic before the loop
1306    StartPtyMagic();
1307
1308    // Tell the progress that its starting and fork dpkg
1309    d->progress->Start(d->master);
1310
1311    // this loop is runs once per dpkg operation
1312    vector<Item>::const_iterator I = List.begin();
1313    while (I != List.end())
1314    {
1315       // Do all actions with the same Op in one run
1316       vector<Item>::const_iterator J = I;
1317       if (TriggersPending == true)
1318          for (; J != List.end(); ++J)
1319          {
1320             if (J->Op == I->Op)
1321                continue;
1322             if (J->Op != Item::TriggersPending)
1323                break;
1324             vector<Item>::const_iterator T = J + 1;
1325             if (T != List.end() && T->Op == I->Op)
1326                continue;
1327             break;
1328          }
1329       else
1330          for (; J != List.end() && J->Op == I->Op; ++J)
1331             /* nothing */;
1332
1333       // keep track of allocated strings for multiarch package names
1334       std::vector<char *> Packages;
1335
1336       // start with the baseset of arguments
1337       unsigned long Size = StartSize;
1338       Args.erase(Args.begin() + BaseArgs, Args.end());
1339
1340       // Now check if we are within the MaxArgs limit
1341       //
1342       // this code below is problematic, because it may happen that
1343       // the argument list is split in a way that A depends on B
1344       // and they are in the same "--configure A B" run
1345       // - with the split they may now be configured in different
1346       //   runs, using Immediate-Configure-All can help prevent this.
1347       if (J - I > (signed)MaxArgs)
1348       {
1349          J = I + MaxArgs;
1350          unsigned long const size = MaxArgs + 10;
1351          Args.reserve(size);
1352          Packages.reserve(size);
1353       }
1354       else
1355       {
1356          unsigned long const size = (J - I) + 10;
1357          Args.reserve(size);
1358          Packages.reserve(size);
1359       }
1360
1361       int fd[2];
1362       if (pipe(fd) != 0)
1363          return _error->Errno("pipe","Failed to create IPC pipe to dpkg");
1364
1365 #define ADDARG(X) Args.push_back(X); Size += strlen(X)
1366 #define ADDARGC(X) Args.push_back(X); Size += sizeof(X) - 1
1367
1368       ADDARGC("--status-fd");
1369       char status_fd_buf[20];
1370       snprintf(status_fd_buf,sizeof(status_fd_buf),"%i", fd[1]);
1371       ADDARG(status_fd_buf);
1372       unsigned long const Op = I->Op;
1373
1374       switch (I->Op)
1375       {
1376          case Item::Remove:
1377          ADDARGC("--force-depends");
1378          ADDARGC("--force-remove-essential");
1379          ADDARGC("--remove");
1380          break;
1381
1382          case Item::Purge:
1383          ADDARGC("--force-depends");
1384          ADDARGC("--force-remove-essential");
1385          ADDARGC("--purge");
1386          break;
1387
1388          case Item::Configure:
1389          ADDARGC("--configure");
1390          break;
1391
1392          case Item::ConfigurePending:
1393          ADDARGC("--configure");
1394          ADDARGC("--pending");
1395          break;
1396
1397          case Item::TriggersPending:
1398          ADDARGC("--triggers-only");
1399          ADDARGC("--pending");
1400          break;
1401
1402          case Item::Install:
1403          ADDARGC("--unpack");
1404          ADDARGC("--auto-deconfigure");
1405          break;
1406       }
1407
1408       if (NoTriggers == true && I->Op != Item::TriggersPending &&
1409           I->Op != Item::ConfigurePending)
1410       {
1411          ADDARGC("--no-triggers");
1412       }
1413 #undef ADDARGC
1414
1415       // Write in the file or package names
1416       if (I->Op == Item::Install)
1417       {
1418          for (;I != J && Size < MaxArgBytes; ++I)
1419          {
1420             if (I->File[0] != '/')
1421                return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str());
1422             Args.push_back(I->File.c_str());
1423             Size += I->File.length();
1424          }
1425       }
1426       else
1427       {
1428          string const nativeArch = _config->Find("APT::Architecture");
1429          unsigned long const oldSize = I->Op == Item::Configure ? Size : 0;
1430          for (;I != J && Size < MaxArgBytes; ++I)
1431          {
1432             if((*I).Pkg.end() == true)
1433                continue;
1434             if (I->Op == Item::Configure && disappearedPkgs.find(I->Pkg.FullName(true)) != disappearedPkgs.end())
1435                continue;
1436             // We keep this here to allow "smooth" transitions from e.g. multiarch dpkg/ubuntu to dpkg/debian
1437             if (dpkgMultiArch == false && (I->Pkg.Arch() == nativeArch ||
1438                                            strcmp(I->Pkg.Arch(), "all") == 0 ||
1439                                            strcmp(I->Pkg.Arch(), "none") == 0))
1440             {
1441                char const * const name = I->Pkg.Name();
1442                ADDARG(name);
1443             }
1444             else
1445             {
1446                pkgCache::VerIterator PkgVer;
1447                std::string name = I->Pkg.Name();
1448                if (Op == Item::Remove || Op == Item::Purge)
1449                {
1450                   PkgVer = I->Pkg.CurrentVer();
1451                   if(PkgVer.end() == true)
1452                      PkgVer = FindNowVersion(I->Pkg);
1453                }
1454                else
1455                   PkgVer = Cache[I->Pkg].InstVerIter(Cache);
1456                if (strcmp(I->Pkg.Arch(), "none") == 0)
1457                   ; // never arch-qualify a package without an arch
1458                else if (PkgVer.end() == false)
1459                   name.append(":").append(PkgVer.Arch());
1460                else
1461                   _error->Warning("Can not find PkgVer for '%s'", name.c_str());
1462                char * const fullname = strdup(name.c_str());
1463                Packages.push_back(fullname);
1464                ADDARG(fullname);
1465             }
1466          }
1467          // skip configure action if all sheduled packages disappeared
1468          if (oldSize == Size)
1469             continue;
1470       }
1471 #undef ADDARG
1472
1473       J = I;
1474
1475       if (_config->FindB("Debug::pkgDPkgPM",false) == true)
1476       {
1477          for (std::vector<const char *>::const_iterator a = Args.begin();
1478               a != Args.end(); ++a)
1479             clog << *a << ' ';
1480          clog << endl;
1481          continue;
1482       }
1483       Args.push_back(NULL);
1484
1485       cout << flush;
1486       clog << flush;
1487       cerr << flush;
1488
1489       /* Mask off sig int/quit. We do this because dpkg also does when
1490          it forks scripts. What happens is that when you hit ctrl-c it sends
1491          it to all processes in the group. Since dpkg ignores the signal
1492          it doesn't die but we do! So we must also ignore it */
1493       sighandler_t old_SIGQUIT = signal(SIGQUIT,SIG_IGN);
1494       sighandler_t old_SIGINT = signal(SIGINT,SigINT);
1495
1496       // Check here for any SIGINT
1497       if (pkgPackageManager::SigINTStop && (Op == Item::Remove || Op == Item::Purge || Op == Item::Install))
1498          break;
1499
1500
1501       // ignore SIGHUP as well (debian #463030)
1502       sighandler_t old_SIGHUP = signal(SIGHUP,SIG_IGN);
1503
1504       // now run dpkg
1505       d->progress->StartDpkg();
1506       std::set<int> KeepFDs;
1507       KeepFDs.insert(fd[1]);
1508       MergeKeepFdsFromConfiguration(KeepFDs);
1509       pid_t Child = ExecFork(KeepFDs);
1510       if (Child == 0)
1511       {
1512          // This is the child
1513          SetupSlavePtyMagic();
1514          close(fd[0]); // close the read end of the pipe
1515
1516          dpkgChrootDirectory();
1517
1518          if (chdir(_config->FindDir("DPkg::Run-Directory","/").c_str()) != 0)
1519             _exit(100);
1520
1521          if (_config->FindB("DPkg::FlushSTDIN",true) == true && isatty(STDIN_FILENO))
1522          {
1523             int Flags;
1524             int dummy = 0;
1525             if ((Flags = fcntl(STDIN_FILENO,F_GETFL,dummy)) < 0)
1526                _exit(100);
1527
1528             // Discard everything in stdin before forking dpkg
1529             if (fcntl(STDIN_FILENO,F_SETFL,Flags | O_NONBLOCK) < 0)
1530                _exit(100);
1531
1532             while (read(STDIN_FILENO,&dummy,1) == 1);
1533
1534             if (fcntl(STDIN_FILENO,F_SETFL,Flags & (~(long)O_NONBLOCK)) < 0)
1535                _exit(100);
1536          }
1537
1538          /* No Job Control Stop Env is a magic dpkg var that prevents it
1539             from using sigstop */
1540          putenv((char *)"DPKG_NO_TSTP=yes");
1541          execvp(Args[0], (char**) &Args[0]);
1542          cerr << "Could not exec dpkg!" << endl;
1543          _exit(100);
1544       }
1545
1546       // apply ionice
1547       if (_config->FindB("DPkg::UseIoNice", false) == true)
1548          ionice(Child);
1549
1550       // Wait for dpkg
1551       int Status = 0;
1552
1553       // we read from dpkg here
1554       int const _dpkgin = fd[0];
1555       close(fd[1]);                        // close the write end of the pipe
1556
1557       // setups fds
1558       sigemptyset(&d->sigmask);
1559       sigprocmask(SIG_BLOCK,&d->sigmask,&d->original_sigmask);
1560
1561       /* free vectors (and therefore memory) as we don't need the included data anymore */
1562       for (std::vector<char *>::const_iterator p = Packages.begin();
1563            p != Packages.end(); ++p)
1564          free(*p);
1565       Packages.clear();
1566
1567       // the result of the waitpid call
1568       int res;
1569       int select_ret;
1570       while ((res=waitpid(Child,&Status, WNOHANG)) != Child) {
1571          if(res < 0) {
1572             // FIXME: move this to a function or something, looks ugly here
1573             // error handling, waitpid returned -1
1574             if (errno == EINTR)
1575                continue;
1576             RunScripts("DPkg::Post-Invoke");
1577
1578             // Restore sig int/quit
1579             signal(SIGQUIT,old_SIGQUIT);
1580             signal(SIGINT,old_SIGINT);
1581
1582             signal(SIGHUP,old_SIGHUP);
1583             return _error->Errno("waitpid","Couldn't wait for subprocess");
1584          }
1585
1586          // wait for input or output here
1587          FD_ZERO(&rfds);
1588          if (d->master >= 0 && !d->stdin_is_dev_null)
1589             FD_SET(0, &rfds);
1590          FD_SET(_dpkgin, &rfds);
1591          if(d->master >= 0)
1592             FD_SET(d->master, &rfds);
1593          tv.tv_sec = 0;
1594          tv.tv_nsec = d->progress->GetPulseInterval();
1595          select_ret = pselect(max(d->master, _dpkgin)+1, &rfds, NULL, NULL,
1596                               &tv, &d->original_sigmask);
1597          if (select_ret < 0 && (errno == EINVAL || errno == ENOSYS))
1598             select_ret = racy_pselect(max(d->master, _dpkgin)+1, &rfds, NULL,
1599                                       NULL, &tv, &d->original_sigmask);
1600          d->progress->Pulse();
1601          if (select_ret == 0)
1602             continue;
1603          else if (select_ret < 0 && errno == EINTR)
1604             continue;
1605          else if (select_ret < 0)
1606          {
1607             perror("select() returned error");
1608             continue;
1609          }
1610
1611          if(d->master >= 0 && FD_ISSET(d->master, &rfds))
1612             DoTerminalPty(d->master);
1613          if(d->master >= 0 && FD_ISSET(0, &rfds))
1614             DoStdin(d->master);
1615          if(FD_ISSET(_dpkgin, &rfds))
1616             DoDpkgStatusFd(_dpkgin);
1617       }
1618       close(_dpkgin);
1619
1620       // Restore sig int/quit
1621       signal(SIGQUIT,old_SIGQUIT);
1622       signal(SIGINT,old_SIGINT);
1623
1624       signal(SIGHUP,old_SIGHUP);
1625       // Check for an error code.
1626       if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
1627       {
1628          // if it was set to "keep-dpkg-runing" then we won't return
1629          // here but keep the loop going and just report it as a error
1630          // for later
1631          bool const stopOnError = _config->FindB("Dpkg::StopOnError",true);
1632
1633          if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV)
1634             strprintf(d->dpkg_error, "Sub-process %s received a segmentation fault.",Args[0]);
1635          else if (WIFEXITED(Status) != 0)
1636             strprintf(d->dpkg_error, "Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status));
1637          else
1638             strprintf(d->dpkg_error, "Sub-process %s exited unexpectedly",Args[0]);
1639          _error->Error("%s", d->dpkg_error.c_str());
1640
1641          if(stopOnError)
1642             break;
1643       }
1644    }
1645    // dpkg is done at this point
1646    d->progress->Stop();
1647    StopPtyMagic();
1648    CloseLog();
1649
1650    if (pkgPackageManager::SigINTStop)
1651        _error->Warning(_("Operation was interrupted before it could finish"));
1652
1653    if (RunScripts("DPkg::Post-Invoke") == false)
1654       return false;
1655
1656    if (_config->FindB("Debug::pkgDPkgPM",false) == false)
1657    {
1658       std::string const oldpkgcache = _config->FindFile("Dir::cache::pkgcache");
1659       if (oldpkgcache.empty() == false && RealFileExists(oldpkgcache) == true &&
1660           unlink(oldpkgcache.c_str()) == 0)
1661       {
1662          std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
1663          if (srcpkgcache.empty() == false && RealFileExists(srcpkgcache) == true)
1664          {
1665             _error->PushToStack();
1666             pkgCacheFile CacheFile;
1667             CacheFile.BuildCaches(NULL, true);
1668             _error->RevertToStack();
1669          }
1670       }
1671    }
1672
1673    Cache.writeStateFile(NULL);
1674    return d->dpkg_error.empty();
1675 }
1676
1677 void SigINT(int /*sig*/) {
1678    pkgPackageManager::SigINTStop = true;
1679 }
1680                                                                         /*}}}*/
1681 // pkgDpkgPM::Reset - Dump the contents of the command list             /*{{{*/
1682 // ---------------------------------------------------------------------
1683 /* */
1684 void pkgDPkgPM::Reset()
1685 {
1686    List.erase(List.begin(),List.end());
1687 }
1688                                                                         /*}}}*/
1689 // pkgDpkgPM::WriteApportReport - write out error report pkg failure    /*{{{*/
1690 // ---------------------------------------------------------------------
1691 /* */
1692 void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
1693 {
1694    // If apport doesn't exist or isn't installed do nothing
1695    // This e.g. prevents messages in 'universes' without apport
1696    pkgCache::PkgIterator apportPkg = Cache.FindPkg("apport");
1697    if (apportPkg.end() == true || apportPkg->CurrentVer == 0)
1698       return;
1699
1700    string pkgname, reportfile, pkgver, arch;
1701    string::size_type pos;
1702    FILE *report;
1703
1704    if (_config->FindB("Dpkg::ApportFailureReport", true) == false)
1705    {
1706       std::clog << "configured to not write apport reports" << std::endl;
1707       return;
1708    }
1709
1710    // only report the first errors
1711    if(pkgFailures > _config->FindI("APT::Apport::MaxReports", 3))
1712    {
1713       std::clog << _("No apport report written because MaxReports is reached already") << std::endl;
1714       return;
1715    }
1716
1717    // check if its not a follow up error
1718    const char *needle = dgettext("dpkg", "dependency problems - leaving unconfigured");
1719    if(strstr(errormsg, needle) != NULL) {
1720       std::clog << _("No apport report written because the error message indicates its a followup error from a previous failure.") << std::endl;
1721       return;
1722    }
1723
1724    // do not report disk-full failures
1725    if(strstr(errormsg, strerror(ENOSPC)) != NULL) {
1726       std::clog << _("No apport report written because the error message indicates a disk full error") << std::endl;
1727       return;
1728    }
1729
1730    // do not report out-of-memory failures
1731    if(strstr(errormsg, strerror(ENOMEM)) != NULL ||
1732       strstr(errormsg, "failed to allocate memory") != NULL) {
1733       std::clog << _("No apport report written because the error message indicates a out of memory error") << std::endl;
1734       return;
1735    }
1736
1737    // do not report bugs regarding inaccessible local files
1738    if(strstr(errormsg, strerror(ENOENT)) != NULL ||
1739       strstr(errormsg, "cannot access archive") != NULL) {
1740       std::clog << _("No apport report written because the error message indicates an issue on the local system") << std::endl;
1741       return;
1742    }
1743
1744    // do not report errors encountered when decompressing packages
1745    if(strstr(errormsg, "--fsys-tarfile returned error exit status 2") != NULL) {
1746       std::clog << _("No apport report written because the error message indicates an issue on the local system") << std::endl;
1747       return;
1748    }
1749
1750    // do not report dpkg I/O errors, this is a format string, so we compare
1751    // the prefix and the suffix of the error with the dpkg error message
1752    vector<string> io_errors;
1753    io_errors.push_back(string("failed to read"));
1754    io_errors.push_back(string("failed to write"));
1755    io_errors.push_back(string("failed to seek"));
1756    io_errors.push_back(string("unexpected end of file or stream"));
1757
1758    for (vector<string>::iterator I = io_errors.begin(); I != io_errors.end(); ++I)
1759    {
1760       vector<string> list = VectorizeString(dgettext("dpkg", (*I).c_str()), '%');
1761       if (list.size() > 1) {
1762          // we need to split %s, VectorizeString only allows char so we need
1763          // to kill the "s" manually
1764          if (list[1].size() > 1) {
1765             list[1].erase(0, 1);
1766             if(strstr(errormsg, list[0].c_str()) &&
1767                strstr(errormsg, list[1].c_str())) {
1768                std::clog << _("No apport report written because the error message indicates a dpkg I/O error") << std::endl;
1769                return;
1770             }
1771          }
1772       }
1773    }
1774
1775    // get the pkgname and reportfile
1776    pkgname = flNotDir(pkgpath);
1777    pos = pkgname.find('_');
1778    if(pos != string::npos)
1779       pkgname = pkgname.substr(0, pos);
1780
1781    // find the package versin and source package name
1782    pkgCache::PkgIterator Pkg = Cache.FindPkg(pkgname);
1783    if (Pkg.end() == true)
1784       return;
1785    pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg);
1786    if (Ver.end() == true)
1787       return;
1788    pkgver = Ver.VerStr() == NULL ? "unknown" : Ver.VerStr();
1789
1790    // if the file exists already, we check:
1791    // - if it was reported already (touched by apport).
1792    //   If not, we do nothing, otherwise
1793    //    we overwrite it. This is the same behaviour as apport
1794    // - if we have a report with the same pkgversion already
1795    //   then we skip it
1796    reportfile = flCombine("/var/crash",pkgname+".0.crash");
1797    if(FileExists(reportfile))
1798    {
1799       struct stat buf;
1800       char strbuf[255];
1801
1802       // check atime/mtime
1803       stat(reportfile.c_str(), &buf);
1804       if(buf.st_mtime > buf.st_atime)
1805          return;
1806
1807       // check if the existing report is the same version
1808       report = fopen(reportfile.c_str(),"r");
1809       while(fgets(strbuf, sizeof(strbuf), report) != NULL)
1810       {
1811          if(strstr(strbuf,"Package:") == strbuf)
1812          {
1813             char pkgname[255], version[255];
1814             if(sscanf(strbuf, "Package: %254s %254s", pkgname, version) == 2)
1815                if(strcmp(pkgver.c_str(), version) == 0)
1816                {
1817                   fclose(report);
1818                   return;
1819                }
1820          }
1821       }
1822       fclose(report);
1823    }
1824
1825    // now write the report
1826    arch = _config->Find("APT::Architecture");
1827    report = fopen(reportfile.c_str(),"w");
1828    if(report == NULL)
1829       return;
1830    if(_config->FindB("DPkgPM::InitialReportOnly",false) == true)
1831       chmod(reportfile.c_str(), 0);
1832    else
1833       chmod(reportfile.c_str(), 0600);
1834    fprintf(report, "ProblemType: Package\n");
1835    fprintf(report, "Architecture: %s\n", arch.c_str());
1836    time_t now = time(NULL);
1837    fprintf(report, "Date: %s" , ctime(&now));
1838    fprintf(report, "Package: %s %s\n", pkgname.c_str(), pkgver.c_str());
1839 #if APT_PKG_ABI >= 413
1840    fprintf(report, "SourcePackage: %s\n", Ver.SourcePkgName());
1841 #else
1842    pkgRecords Recs(Cache);
1843    pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
1844    std::string srcpkgname = Parse.SourcePkg();
1845    if(srcpkgname.empty())
1846       srcpkgname = pkgname;
1847    fprintf(report, "SourcePackage: %s\n", srcpkgname.c_str());
1848 #endif
1849    fprintf(report, "ErrorMessage:\n %s\n", errormsg);
1850
1851    // ensure that the log is flushed
1852    if(d->term_out)
1853       fflush(d->term_out);
1854
1855    // attach terminal log it if we have it
1856    string logfile_name = _config->FindFile("Dir::Log::Terminal");
1857    if (!logfile_name.empty())
1858    {
1859       FILE *log = NULL;
1860
1861       fprintf(report, "DpkgTerminalLog:\n");
1862       log = fopen(logfile_name.c_str(),"r");
1863       if(log != NULL)
1864       {
1865          char buf[1024];
1866          while( fgets(buf, sizeof(buf), log) != NULL)
1867             fprintf(report, " %s", buf);
1868          fprintf(report, " \n");
1869          fclose(log);
1870       }
1871    }
1872
1873    // attach history log it if we have it
1874    string histfile_name = _config->FindFile("Dir::Log::History");
1875    if (!histfile_name.empty())
1876    {
1877       fprintf(report, "DpkgHistoryLog:\n");
1878       FILE* log = fopen(histfile_name.c_str(),"r");
1879       if(log != NULL)
1880       {
1881          char buf[1024];
1882          while( fgets(buf, sizeof(buf), log) != NULL)
1883             fprintf(report, " %s", buf);
1884          fclose(log);
1885       }
1886    }
1887
1888    // log the ordering
1889    const char *ops_str[] = {"Install", "Configure","Remove","Purge"};
1890    fprintf(report, "AptOrdering:\n");
1891    for (vector<Item>::iterator I = List.begin(); I != List.end(); ++I)
1892       if ((*I).Pkg != NULL)
1893          fprintf(report, " %s: %s\n", (*I).Pkg.Name(), ops_str[(*I).Op]);
1894       else
1895          fprintf(report, " %s: %s\n", "NULL", ops_str[(*I).Op]);
1896
1897    // attach dmesg log (to learn about segfaults)
1898    if (FileExists("/bin/dmesg"))
1899    {
1900       fprintf(report, "Dmesg:\n");
1901       FILE *log = popen("/bin/dmesg","r");
1902       if(log != NULL)
1903       {
1904          char buf[1024];
1905          while( fgets(buf, sizeof(buf), log) != NULL)
1906             fprintf(report, " %s", buf);
1907          pclose(log);
1908       }
1909    }
1910
1911    // attach df -l log (to learn about filesystem status)
1912    if (FileExists("/bin/df"))
1913    {
1914
1915       fprintf(report, "Df:\n");
1916       FILE *log = popen("/bin/df -l","r");
1917       if(log != NULL)
1918       {
1919          char buf[1024];
1920          while( fgets(buf, sizeof(buf), log) != NULL)
1921             fprintf(report, " %s", buf);
1922          pclose(log);
1923       }
1924    }
1925
1926    fclose(report);
1927
1928 }
1929                                                                         /*}}}*/