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