apt-pkg/deb/dpkgpm.cc

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