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    // we need to split on ": " (note the appended space) as the ':' is
 544    // part of the pkgname:arch information that dpkg sends
 545    //
 546    // A dpkg error message may contain additional ":" (like
 547    //  "failed in buffer_write(fd) (10, ret=-1): backend dpkg-deb ..."
 548    // so we need to ensure to not split too much
 549    std::vector<std::string> list = StringSplit(line, ": ", 3);
 550    if(list.size() != 3)
 551    {
 552       if (Debug == true)
 553          std::clog << "ignoring line: not enough ':'" << std::endl;
 554       return;
 555    }
 556    // dpkg does not send always send "pkgname:arch" so we add it here if needed
 557    std::string pkgname = list[1];
 558    if (pkgname.find(":") == std::string::npos)
 559    {
 560       // find the package in the group that is in a touched by dpkg
 561       // if there are multiple dpkg will send us a full pkgname:arch
 562       pkgCache::GrpIterator Grp = Cache.FindGrp(pkgname);
 563       if (Grp.end() == false)
 564       {
 565           pkgCache::PkgIterator P = Grp.PackageList();
 566           for (; P.end() != true; P = Grp.NextPkg(P))
 567           {
 568               if(Cache[P].Mode != pkgDepCache::ModeKeep)
 569               {
 570                   pkgname = P.FullName();
 571                   break;
 572               }
 573           }
 574       }
 575    }
 576    const char* const pkg = pkgname.c_str();
 577    const char* action = list[2].c_str();
 578
 579    std::string short_pkgname = StringSplit(pkgname, ":")[0];
 580
 581    // 'processing' from dpkg looks like
 582    // 'processing: action: pkg'
 583    if(strncmp(list[0].c_str(), "processing", strlen("processing")) == 0)
 584    {
 585       char s[200];
 586       const char* const pkg_or_trigger = list[2].c_str();
 587       action =  list[1].c_str();
 588       const std::pair<const char *, const char *> * const iter =
 589         std::find_if(PackageProcessingOpsBegin,
 590                      PackageProcessingOpsEnd,
 591                      MatchProcessingOp(action));
 592       if(iter == PackageProcessingOpsEnd)
 593       {
 594          if (Debug == true)
 595             std::clog << "ignoring unknown action: " << action << std::endl;
 596          return;
 597       }
 598       snprintf(s, sizeof(s), _(iter->second), pkg_or_trigger);
 599
 600       status << "pmstatus:" << pkg_or_trigger
 601              << ":"  << (PackagesDone/float(PackagesTotal)*100.0)
 602              << ":" << s
 603              << endl;
 604       if(OutStatusFd > 0)
 605          FileFd::Write(OutStatusFd, status.str().c_str(), status.str().size());
 606       if (Debug == true)
 607          std::clog << "send: '" << status.str() << "'" << endl;
 608
 609       if (strncmp(action, "disappear", strlen("disappear")) == 0)
 610          handleDisappearAction(pkg_or_trigger);
 611       return;
 612    }
 613
 614    if(strncmp(action,"error",strlen("error")) == 0)
 615    {
 616       status << "pmerror:" << list[1]
 617              << ":"  << (PackagesDone/float(PackagesTotal)*100.0)
 618              << ":" << list[3]
 619              << endl;
 620       if(OutStatusFd > 0)
 621          FileFd::Write(OutStatusFd, status.str().c_str(), status.str().size());
 622       if (Debug == true)
 623          std::clog << "send: '" << status.str() << "'" << endl;
 624       pkgFailures++;
 625       WriteApportReport(list[1].c_str(), list[3].c_str());
 626       return;
 627    }
 628    else if(strncmp(action,"conffile",strlen("conffile")) == 0)
 629    {
 630       status << "pmconffile:" << list[1]
 631              << ":"  << (PackagesDone/float(PackagesTotal)*100.0)
 632              << ":" << list[3]
 633              << endl;
 634       if(OutStatusFd > 0)
 635          FileFd::Write(OutStatusFd, status.str().c_str(), status.str().size());
 636       if (Debug == true)
 637          std::clog << "send: '" << status.str() << "'" << endl;
 638       return;
 639    }
 640
 641    vector<struct DpkgState> const &states = PackageOps[pkg];
 642    const char *next_action = NULL;
 643    if(PackageOpsDone[pkg] < states.size())
 644       next_action = states[PackageOpsDone[pkg]].state;
 645    // check if the package moved to the next dpkg state
 646    if(next_action && (strcmp(action, next_action) == 0))
 647    {
 648       // only read the translation if there is actually a next
 649       // action
 650       const char *translation = _(states[PackageOpsDone[pkg]].str);
 651       char s[200];
 652       snprintf(s, sizeof(s), translation, pkg);
 653
 654       // we moved from one dpkg state to a new one, report that
 655       PackageOpsDone[pkg]++;
 656       PackagesDone++;
 657       // build the status str
 658       status << "pmstatus:" << short_pkgname
 659              << ":"  << (PackagesDone/float(PackagesTotal)*100.0)
 660              << ":" << s
 661              << endl;
 662       if(_config->FindB("DPkgPM::Progress", false) == true)
 663          SendTerminalProgress(PackagesDone/float(PackagesTotal)*100.0);
 664
 665       if(OutStatusFd > 0)
 666          FileFd::Write(OutStatusFd, status.str().c_str(), status.str().size());
 667       if (Debug == true)
 668          std::clog << "send: '" << status.str() << "'" << endl;
 669    }
 670    if (Debug == true)
 671       std::clog << "(parsed from dpkg) pkg: " << short_pkgname
 672                 << " action: " << action << endl;
 673 }
 674                                                                         /*}}}*/
 675 // DPkgPM::handleDisappearAction                                        /*{{{*/
 676 void pkgDPkgPM::handleDisappearAction(string const &pkgname)
 677 {
 678    // record the package name for display and stuff later
 679    disappearedPkgs.insert(pkgname);
 680
 681    pkgCache::PkgIterator Pkg = Cache.FindPkg(pkgname);
 682    if (unlikely(Pkg.end() == true))
 683       return;
 684    // the disappeared package was auto-installed - nothing to do
 685    if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
 686       return;
 687    pkgCache::VerIterator PkgVer = Cache[Pkg].InstVerIter(Cache);
 688    if (unlikely(PkgVer.end() == true))
 689       return;
 690    /* search in the list of dependencies for (Pre)Depends,
 691       check if this dependency has a Replaces on our package
 692       and if so transfer the manual installed flag to it */
 693    for (pkgCache::DepIterator Dep = PkgVer.DependsList(); Dep.end() != true; ++Dep)
 694    {
 695       if (Dep->Type != pkgCache::Dep::Depends &&
 696           Dep->Type != pkgCache::Dep::PreDepends)
 697          continue;
 698       pkgCache::PkgIterator Tar = Dep.TargetPkg();
 699       if (unlikely(Tar.end() == true))
 700          continue;
 701       // the package is already marked as manual
 702       if ((Cache[Tar].Flags & pkgCache::Flag::Auto) != pkgCache::Flag::Auto)
 703          continue;
 704       pkgCache::VerIterator TarVer =  Cache[Tar].InstVerIter(Cache);
 705       if (TarVer.end() == true)
 706          continue;
 707       for (pkgCache::DepIterator Rep = TarVer.DependsList(); Rep.end() != true; ++Rep)
 708       {
 709          if (Rep->Type != pkgCache::Dep::Replaces)
 710             continue;
 711          if (Pkg != Rep.TargetPkg())
 712             continue;
 713          // okay, they are strongly connected - transfer manual-bit
 714          if (Debug == true)
 715             std::clog << "transfer manual-bit from disappeared »" << pkgname << "« to »" << Tar.FullName() << "«" << std::endl;
 716          Cache[Tar].Flags &= ~Flag::Auto;
 717          break;
 718       }
 719    }
 720 }
 721                                                                         /*}}}*/
 722 // DPkgPM::DoDpkgStatusFd                                               /*{{{*/
 723 // ---------------------------------------------------------------------
 724 /*
 725  */
 726 void pkgDPkgPM::DoDpkgStatusFd(int statusfd, int OutStatusFd)
 727 {
 728    char *p, *q;
 729    int len;
 730
 731    len=read(statusfd, &d->dpkgbuf[d->dpkgbuf_pos], sizeof(d->dpkgbuf)-d->dpkgbuf_pos);
 732    d->dpkgbuf_pos += len;
 733    if(len <= 0)
 734       return;
 735
 736    // process line by line if we have a buffer
 737    p = q = d->dpkgbuf;
 738    while((q=(char*)memchr(p, '\n', d->dpkgbuf+d->dpkgbuf_pos-p)) != NULL)
 739    {
 740       *q = 0;
 741       ProcessDpkgStatusLine(OutStatusFd, p);
 742       p=q+1; // continue with next line
 743    }
 744
 745    // now move the unprocessed bits (after the final \n that is now a 0x0)
 746    // to the start and update d->dpkgbuf_pos
 747    p = (char*)memrchr(d->dpkgbuf, 0, d->dpkgbuf_pos);
 748    if(p == NULL)
 749       return;
 750
 751    // we are interessted in the first char *after* 0x0
 752    p++;
 753
 754    // move the unprocessed tail to the start and update pos
 755    memmove(d->dpkgbuf, p, p-d->dpkgbuf);
 756    d->dpkgbuf_pos = d->dpkgbuf+d->dpkgbuf_pos-p;
 757 }
 758                                                                         /*}}}*/
 759 // DPkgPM::WriteHistoryTag                                              /*{{{*/
 760 void pkgDPkgPM::WriteHistoryTag(string const &tag, string value)
 761 {
 762    size_t const length = value.length();
 763    if (length == 0)
 764       return;
 765    // poor mans rstrip(", ")
 766    if (value[length-2] == ',' && value[length-1] == ' ')
 767       value.erase(length - 2, 2);
 768    fprintf(d->history_out, "%s: %s\n", tag.c_str(), value.c_str());
 769 }                                                                       /*}}}*/
 770 // DPkgPM::OpenLog                                                      /*{{{*/
 771 bool pkgDPkgPM::OpenLog()
 772 {
 773    string const logdir = _config->FindDir("Dir::Log");
 774    if(CreateAPTDirectoryIfNeeded(logdir, logdir) == false)
 775       // FIXME: use a better string after freeze
 776       return _error->Error(_("Directory '%s' missing"), logdir.c_str());
 777
 778    // get current time
 779    char timestr[200];
 780    time_t const t = time(NULL);
 781    struct tm const * const tmp = localtime(&t);
 782    strftime(timestr, sizeof(timestr), "%F  %T", tmp);
 783
 784    // open terminal log
 785    string const logfile_name = flCombine(logdir,
 786                                    _config->Find("Dir::Log::Terminal"));
 787    if (!logfile_name.empty())
 788    {
 789       d->term_out = fopen(logfile_name.c_str(),"a");
 790       if (d->term_out == NULL)
 791          return _error->WarningE("OpenLog", _("Could not open file '%s'"), logfile_name.c_str());
 792       setvbuf(d->term_out, NULL, _IONBF, 0);
 793       SetCloseExec(fileno(d->term_out), true);
 794       if (getuid() == 0) // if we aren't root, we can't chown a file, so don't try it
 795       {
 796          struct passwd *pw = getpwnam("root");
 797          struct group *gr = getgrnam("adm");
 798          if (pw != NULL && gr != NULL && chown(logfile_name.c_str(), pw->pw_uid, gr->gr_gid) != 0)
 799             _error->WarningE("OpenLog", "chown to root:adm of file %s failed", logfile_name.c_str());
 800       }
 801       if (chmod(logfile_name.c_str(), 0640) != 0)
 802          _error->WarningE("OpenLog", "chmod 0640 of file %s failed", logfile_name.c_str());
 803       fprintf(d->term_out, "\nLog started: %s\n", timestr);
 804    }
 805
 806    // write your history
 807    string const history_name = flCombine(logdir,
 808                                    _config->Find("Dir::Log::History"));
 809    if (!history_name.empty())
 810    {
 811       d->history_out = fopen(history_name.c_str(),"a");
 812       if (d->history_out == NULL)
 813          return _error->WarningE("OpenLog", _("Could not open file '%s'"), history_name.c_str());
 814       SetCloseExec(fileno(d->history_out), true);
 815       chmod(history_name.c_str(), 0644);
 816       fprintf(d->history_out, "\nStart-Date: %s\n", timestr);
 817       string remove, purge, install, reinstall, upgrade, downgrade;
 818       for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
 819       {
 820          enum { CANDIDATE, CANDIDATE_AUTO, CURRENT_CANDIDATE, CURRENT } infostring;
 821          string *line = NULL;
 822          #define HISTORYINFO(X, Y) { line = &X; infostring = Y; }
 823          if (Cache[I].NewInstall() == true)
 824             HISTORYINFO(install, CANDIDATE_AUTO)
 825          else if (Cache[I].ReInstall() == true)
 826             HISTORYINFO(reinstall, CANDIDATE)
 827          else if (Cache[I].Upgrade() == true)
 828             HISTORYINFO(upgrade, CURRENT_CANDIDATE)
 829          else if (Cache[I].Downgrade() == true)
 830             HISTORYINFO(downgrade, CURRENT_CANDIDATE)
 831          else if (Cache[I].Delete() == true)
 832             HISTORYINFO((Cache[I].Purge() ? purge : remove), CURRENT)
 833          else
 834             continue;
 835          #undef HISTORYINFO
 836          line->append(I.FullName(false)).append(" (");
 837          switch (infostring) {
 838          case CANDIDATE: line->append(Cache[I].CandVersion); break;
 839          case CANDIDATE_AUTO:
 840             line->append(Cache[I].CandVersion);
 841             if ((Cache[I].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
 842                line->append(", automatic");
 843             break;
 844          case CURRENT_CANDIDATE: line->append(Cache[I].CurVersion).append(", ").append(Cache[I].CandVersion); break;
 845          case CURRENT: line->append(Cache[I].CurVersion); break;
 846          }
 847          line->append("), ");
 848       }
 849       if (_config->Exists("Commandline::AsString") == true)
 850          WriteHistoryTag("Commandline", _config->Find("Commandline::AsString"));
 851       WriteHistoryTag("Install", install);
 852       WriteHistoryTag("Reinstall", reinstall);
 853       WriteHistoryTag("Upgrade", upgrade);
 854       WriteHistoryTag("Downgrade",downgrade);
 855       WriteHistoryTag("Remove",remove);
 856       WriteHistoryTag("Purge",purge);
 857       fflush(d->history_out);
 858    }
 859
 860    return true;
 861 }
 862                                                                         /*}}}*/
 863 // DPkg::CloseLog                                                       /*{{{*/
 864 bool pkgDPkgPM::CloseLog()
 865 {
 866    char timestr[200];
 867    time_t t = time(NULL);
 868    struct tm *tmp = localtime(&t);
 869    strftime(timestr, sizeof(timestr), "%F  %T", tmp);
 870
 871    if(d->term_out)
 872    {
 873       fprintf(d->term_out, "Log ended: ");
 874       fprintf(d->term_out, "%s", timestr);
 875       fprintf(d->term_out, "\n");
 876       fclose(d->term_out);
 877    }
 878    d->term_out = NULL;
 879
 880    if(d->history_out)
 881    {
 882       if (disappearedPkgs.empty() == false)
 883       {
 884          string disappear;
 885          for (std::set<std::string>::const_iterator d = disappearedPkgs.begin();
 886               d != disappearedPkgs.end(); ++d)
 887          {
 888             pkgCache::PkgIterator P = Cache.FindPkg(*d);
 889             disappear.append(*d);
 890             if (P.end() == true)
 891                disappear.append(", ");
 892             else
 893                disappear.append(" (").append(Cache[P].CurVersion).append("), ");
 894          }
 895          WriteHistoryTag("Disappeared", disappear);
 896       }
 897       if (d->dpkg_error.empty() == false)
 898          fprintf(d->history_out, "Error: %s\n", d->dpkg_error.c_str());
 899       fprintf(d->history_out, "End-Date: %s\n", timestr);
 900       fclose(d->history_out);
 901    }
 902    d->history_out = NULL;
 903
 904    return true;
 905 }
 906                                                                         /*}}}*/
 907 // DPkgPM::SendTerminalProgress                                         /*{{{*/
 908 // ---------------------------------------------------------------------
 909 /* Send progress info to the terminal
 910  */
 911 void pkgDPkgPM::SendTerminalProgress(float percentage)
 912 {
 913    int reporting_steps = _config->FindI("DpkgPM::Reporting-Steps", 1);
 914
 915    if(percentage < (d->last_reported_progress + reporting_steps))
 916       return;
 917
 918    std::string progress_str;
 919    strprintf(progress_str, "Progress: [%3i%%]", (int)percentage);
 920    if (d->fancy_progress_output)
 921    {
 922          int row = d->nr_terminal_rows;
 923
 924          static string save_cursor = "\033[s";
 925          static string restore_cursor = "\033[u";
 926
 927          static string set_bg_color = "\033[42m"; // green
 928          static string set_fg_color = "\033[30m"; // black
 929
 930          static string restore_bg =  "\033[49m";
 931          static string restore_fg = "\033[39m";
 932
 933          std::cout << save_cursor
 934             // move cursor position to last row
 935                    << "\033[" << row << ";0f"
 936                    << set_bg_color
 937                    << set_fg_color
 938                    << progress_str
 939                    << restore_cursor
 940                    << restore_bg
 941                    << restore_fg;
 942    }
 943    else
 944    {
 945          std::cout << progress_str << "\r\n";
 946    }
 947    std::flush(std::cout);
 948
 949    d->last_reported_progress = percentage;
 950 }
 951                                                                         /*}}}*/
 952 /*{{{*/
 953 // This implements a racy version of pselect for those architectures
 954 // that don't have a working implementation.
 955 // FIXME: Probably can be removed on Lenny+1
 956 static int racy_pselect(int nfds, fd_set *readfds, fd_set *writefds,
 957    fd_set *exceptfds, const struct timespec *timeout,
 958    const sigset_t *sigmask)
 959 {
 960    sigset_t origmask;
 961    struct timeval tv;
 962    int retval;
 963
 964    tv.tv_sec = timeout->tv_sec;
 965    tv.tv_usec = timeout->tv_nsec/1000;
 966
 967    sigprocmask(SIG_SETMASK, sigmask, &origmask);
 968    retval = select(nfds, readfds, writefds, exceptfds, &tv);
 969    sigprocmask(SIG_SETMASK, &origmask, 0);
 970    return retval;
 971 }
 972 /*}}}*/
 973
 974 void pkgDPkgPM::SetupTerminalScrollArea(int nr_rows)
 975 {
 976      if(!d->fancy_progress_output)
 977         return;
 978
 979      // scroll down a bit to avoid visual glitch when the screen
 980      // area shrinks by one row
 981      std::cout << "\n";
 982
 983      // save cursor
 984      std::cout << "\033[s";
 985
 986      // set scroll region (this will place the cursor in the top left)
 987      std::cout << "\033[1;" << nr_rows - 1 << "r";
 988
 989      // restore cursor but ensure its inside the scrolling area
 990      std::cout << "\033[u";
 991      static const char *move_cursor_up = "\033[1A";
 992      std::cout << move_cursor_up;
 993      std::flush(std::cout);
 994 }
 995
 996 // DPkgPM::Go - Run the sequence                                        /*{{{*/
 997 // ---------------------------------------------------------------------
 998 /* This globs the operations and calls dpkg
 999  *
1000  * If it is called with "OutStatusFd" set to a valid file descriptor
1001  * apt will report the install progress over this fd. It maps the
1002  * dpkg states a package goes through to human readable (and i10n-able)
1003  * names and calculates a percentage for each step.
1004 */
1005 bool pkgDPkgPM::Go(int OutStatusFd)
1006 {
1007    pkgPackageManager::SigINTStop = false;
1008
1009    // Generate the base argument list for dpkg
1010    std::vector<const char *> Args;
1011    unsigned long StartSize = 0;
1012    string Tmp = _config->Find("Dir::Bin::dpkg","dpkg");
1013    {
1014       string const dpkgChrootDir = _config->FindDir("DPkg::Chroot-Directory", "/");
1015       size_t dpkgChrootLen = dpkgChrootDir.length();
1016       if (dpkgChrootDir != "/" && Tmp.find(dpkgChrootDir) == 0)
1017       {
1018          if (dpkgChrootDir[dpkgChrootLen - 1] == '/')
1019             --dpkgChrootLen;
1020          Tmp = Tmp.substr(dpkgChrootLen);
1021       }
1022    }
1023    Args.push_back(Tmp.c_str());
1024    StartSize += Tmp.length();
1025
1026    // Stick in any custom dpkg options
1027    Configuration::Item const *Opts = _config->Tree("DPkg::Options");
1028    if (Opts != 0)
1029    {
1030       Opts = Opts->Child;
1031       for (; Opts != 0; Opts = Opts->Next)
1032       {
1033          if (Opts->Value.empty() == true)
1034             continue;
1035          Args.push_back(Opts->Value.c_str());
1036          StartSize += Opts->Value.length();
1037       }
1038    }
1039
1040    size_t const BaseArgs = Args.size();
1041    // we need to detect if we can qualify packages with the architecture or not
1042    Args.push_back("--assert-multi-arch");
1043    Args.push_back(NULL);
1044
1045    pid_t dpkgAssertMultiArch = ExecFork();
1046    if (dpkgAssertMultiArch == 0)
1047    {
1048       dpkgChrootDirectory();
1049       // redirect everything to the ultimate sink as we only need the exit-status
1050       int const nullfd = open("/dev/null", O_RDONLY);
1051       dup2(nullfd, STDIN_FILENO);
1052       dup2(nullfd, STDOUT_FILENO);
1053       dup2(nullfd, STDERR_FILENO);
1054       execvp(Args[0], (char**) &Args[0]);
1055       _error->WarningE("dpkgGo", "Can't detect if dpkg supports multi-arch!");
1056       _exit(2);
1057    }
1058
1059    fd_set rfds;
1060    struct timespec tv;
1061    sigset_t sigmask;
1062    sigset_t original_sigmask;
1063
1064    unsigned int const MaxArgs = _config->FindI("Dpkg::MaxArgs",8*1024);
1065    unsigned int const MaxArgBytes = _config->FindI("Dpkg::MaxArgBytes",32*1024);
1066    bool const NoTriggers = _config->FindB("DPkg::NoTriggers", false);
1067
1068    if (RunScripts("DPkg::Pre-Invoke") == false)
1069       return false;
1070
1071    if (RunScriptsWithPkgs("DPkg::Pre-Install-Pkgs") == false)
1072       return false;
1073
1074    // support subpressing of triggers processing for special
1075    // cases like d-i that runs the triggers handling manually
1076    bool const SmartConf = (_config->Find("PackageManager::Configure", "all") != "all");
1077    bool const TriggersPending = _config->FindB("DPkg::TriggersPending", false);
1078    if (_config->FindB("DPkg::ConfigurePending", SmartConf) == true)
1079       List.push_back(Item(Item::ConfigurePending, PkgIterator()));
1080
1081    // map the dpkg states to the operations that are performed
1082    // (this is sorted in the same way as Item::Ops)
1083    static const struct DpkgState DpkgStatesOpMap[][7] = {
1084       // Install operation
1085       {
1086          {"half-installed", N_("Preparing %s")},
1087          {"unpacked", N_("Unpacking %s") },
1088          {NULL, NULL}
1089       },
1090       // Configure operation
1091       {
1092          {"unpacked",N_("Preparing to configure %s") },
1093          {"half-configured", N_("Configuring %s") },
1094          { "installed", N_("Installed %s")},
1095          {NULL, NULL}
1096       },
1097       // Remove operation
1098       {
1099          {"half-configured", N_("Preparing for removal of %s")},
1100          {"half-installed", N_("Removing %s")},
1101          {"config-files",  N_("Removed %s")},
1102          {NULL, NULL}
1103       },
1104       // Purge operation
1105       {
1106          {"config-files", N_("Preparing to completely remove %s")},
1107          {"not-installed", N_("Completely removed %s")},
1108          {NULL, NULL}
1109       },
1110    };
1111
1112    // init the PackageOps map, go over the list of packages that
1113    // that will be [installed|configured|removed|purged] and add
1114    // them to the PackageOps map (the dpkg states it goes through)
1115    // and the PackageOpsTranslations (human readable strings)
1116    for (vector<Item>::const_iterator I = List.begin(); I != List.end(); ++I)
1117    {
1118       if((*I).Pkg.end() == true)
1119          continue;
1120
1121       string const name = (*I).Pkg.FullName();
1122       PackageOpsDone[name] = 0;
1123       for(int i=0; (DpkgStatesOpMap[(*I).Op][i]).state != NULL; ++i)
1124       {
1125          PackageOps[name].push_back(DpkgStatesOpMap[(*I).Op][i]);
1126          PackagesTotal++;
1127       }
1128    }
1129
1130    d->stdin_is_dev_null = false;
1131
1132    // create log
1133    OpenLog();
1134
1135    bool dpkgMultiArch = false;
1136    if (dpkgAssertMultiArch > 0)
1137    {
1138       int Status = 0;
1139       while (waitpid(dpkgAssertMultiArch, &Status, 0) != dpkgAssertMultiArch)
1140       {
1141          if (errno == EINTR)
1142             continue;
1143          _error->WarningE("dpkgGo", _("Waited for %s but it wasn't there"), "dpkg --assert-multi-arch");
1144          break;
1145       }
1146       if (WIFEXITED(Status) == true && WEXITSTATUS(Status) == 0)
1147          dpkgMultiArch = true;
1148    }
1149
1150    // this loop is runs once per operation
1151    for (vector<Item>::const_iterator I = List.begin(); I != List.end();)
1152    {
1153       // Do all actions with the same Op in one run
1154       vector<Item>::const_iterator J = I;
1155       if (TriggersPending == true)
1156          for (; J != List.end(); ++J)
1157          {
1158             if (J->Op == I->Op)
1159                continue;
1160             if (J->Op != Item::TriggersPending)
1161                break;
1162             vector<Item>::const_iterator T = J + 1;
1163             if (T != List.end() && T->Op == I->Op)
1164                continue;
1165             break;
1166          }
1167       else
1168          for (; J != List.end() && J->Op == I->Op; ++J)
1169             /* nothing */;
1170
1171       // keep track of allocated strings for multiarch package names
1172       std::vector<char *> Packages;
1173
1174       // start with the baseset of arguments
1175       unsigned long Size = StartSize;
1176       Args.erase(Args.begin() + BaseArgs, Args.end());
1177
1178       // Now check if we are within the MaxArgs limit
1179       //
1180       // this code below is problematic, because it may happen that
1181       // the argument list is split in a way that A depends on B
1182       // and they are in the same "--configure A B" run
1183       // - with the split they may now be configured in different
1184       //   runs, using Immediate-Configure-All can help prevent this.
1185       if (J - I > (signed)MaxArgs)
1186       {
1187          J = I + MaxArgs;
1188          unsigned long const size = MaxArgs + 10;
1189          Args.reserve(size);
1190          Packages.reserve(size);
1191       }
1192       else
1193       {
1194          unsigned long const size = (J - I) + 10;
1195          Args.reserve(size);
1196          Packages.reserve(size);
1197       }
1198
1199       int fd[2];
1200       if (pipe(fd) != 0)
1201          return _error->Errno("pipe","Failed to create IPC pipe to dpkg");
1202
1203 #define ADDARG(X) Args.push_back(X); Size += strlen(X)
1204 #define ADDARGC(X) Args.push_back(X); Size += sizeof(X) - 1
1205
1206       ADDARGC("--status-fd");
1207       char status_fd_buf[20];
1208       snprintf(status_fd_buf,sizeof(status_fd_buf),"%i", fd[1]);
1209       ADDARG(status_fd_buf);
1210       unsigned long const Op = I->Op;
1211
1212       switch (I->Op)
1213       {
1214          case Item::Remove:
1215          ADDARGC("--force-depends");
1216          ADDARGC("--force-remove-essential");
1217          ADDARGC("--remove");
1218          break;
1219
1220          case Item::Purge:
1221          ADDARGC("--force-depends");
1222          ADDARGC("--force-remove-essential");
1223          ADDARGC("--purge");
1224          break;
1225
1226          case Item::Configure:
1227          ADDARGC("--configure");
1228          break;
1229
1230          case Item::ConfigurePending:
1231          ADDARGC("--configure");
1232          ADDARGC("--pending");
1233          break;
1234
1235          case Item::TriggersPending:
1236          ADDARGC("--triggers-only");
1237          ADDARGC("--pending");
1238          break;
1239
1240          case Item::Install:
1241          ADDARGC("--unpack");
1242          ADDARGC("--auto-deconfigure");
1243          break;
1244       }
1245
1246       if (NoTriggers == true && I->Op != Item::TriggersPending &&
1247           I->Op != Item::ConfigurePending)
1248       {
1249          ADDARGC("--no-triggers");
1250       }
1251 #undef ADDARGC
1252
1253       // Write in the file or package names
1254       if (I->Op == Item::Install)
1255       {
1256          for (;I != J && Size < MaxArgBytes; ++I)
1257          {
1258             if (I->File[0] != '/')
1259                return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str());
1260             Args.push_back(I->File.c_str());
1261             Size += I->File.length();
1262          }
1263       }
1264       else
1265       {
1266          string const nativeArch = _config->Find("APT::Architecture");
1267          unsigned long const oldSize = I->Op == Item::Configure ? Size : 0;
1268          for (;I != J && Size < MaxArgBytes; ++I)
1269          {
1270             if((*I).Pkg.end() == true)
1271                continue;
1272             if (I->Op == Item::Configure && disappearedPkgs.find(I->Pkg.Name()) != disappearedPkgs.end())
1273                continue;
1274             // We keep this here to allow "smooth" transitions from e.g. multiarch dpkg/ubuntu to dpkg/debian
1275             if (dpkgMultiArch == false && (I->Pkg.Arch() == nativeArch ||
1276                                            strcmp(I->Pkg.Arch(), "all") == 0 ||
1277                                            strcmp(I->Pkg.Arch(), "none") == 0))
1278             {
1279                char const * const name = I->Pkg.Name();
1280                ADDARG(name);
1281             }
1282             else
1283             {
1284                pkgCache::VerIterator PkgVer;
1285                std::string name = I->Pkg.Name();
1286                if (Op == Item::Remove || Op == Item::Purge)
1287                {
1288                   PkgVer = I->Pkg.CurrentVer();
1289                   if(PkgVer.end() == true)
1290                      PkgVer = FindNowVersion(I->Pkg);
1291                }
1292                else
1293                   PkgVer = Cache[I->Pkg].InstVerIter(Cache);
1294                if (strcmp(I->Pkg.Arch(), "none") == 0)
1295                   ; // never arch-qualify a package without an arch
1296                else if (PkgVer.end() == false)
1297                   name.append(":").append(PkgVer.Arch());
1298                else
1299                   _error->Warning("Can not find PkgVer for '%s'", name.c_str());
1300                char * const fullname = strdup(name.c_str());
1301                Packages.push_back(fullname);
1302                ADDARG(fullname);
1303             }
1304          }
1305          // skip configure action if all sheduled packages disappeared
1306          if (oldSize == Size)
1307             continue;
1308       }
1309 #undef ADDARG
1310
1311       J = I;
1312
1313       if (_config->FindB("Debug::pkgDPkgPM",false) == true)
1314       {
1315          for (std::vector<const char *>::const_iterator a = Args.begin();
1316               a != Args.end(); ++a)
1317             clog << *a << ' ';
1318          clog << endl;
1319          continue;
1320       }
1321       Args.push_back(NULL);
1322
1323       cout << flush;
1324       clog << flush;
1325       cerr << flush;
1326
1327       /* Mask off sig int/quit. We do this because dpkg also does when
1328          it forks scripts. What happens is that when you hit ctrl-c it sends
1329          it to all processes in the group. Since dpkg ignores the signal
1330          it doesn't die but we do! So we must also ignore it */
1331       sighandler_t old_SIGQUIT = signal(SIGQUIT,SIG_IGN);
1332       sighandler_t old_SIGINT = signal(SIGINT,SigINT);
1333
1334       // Check here for any SIGINT
1335       if (pkgPackageManager::SigINTStop && (Op == Item::Remove || Op == Item::Purge || Op == Item::Install))
1336          break;
1337
1338
1339       // ignore SIGHUP as well (debian #463030)
1340       sighandler_t old_SIGHUP = signal(SIGHUP,SIG_IGN);
1341
1342       struct    termios tt;
1343       struct    winsize win;
1344       int       master = -1;
1345       int       slave = -1;
1346
1347       // if tcgetattr does not return zero there was a error
1348       // and we do not do any pty magic
1349       _error->PushToStack();
1350       if (tcgetattr(STDOUT_FILENO, &tt) == 0)
1351       {
1352          ioctl(1, TIOCGWINSZ, (char *)&win);
1353          d->nr_terminal_rows = win.ws_row;
1354          if (openpty(&master, &slave, NULL, &tt, &win) < 0)
1355          {
1356             _error->Errno("openpty", _("Can not write log (%s)"), _("Is /dev/pts mounted?"));
1357             master = slave = -1;
1358          }  else {
1359             struct termios rtt;
1360             rtt = tt;
1361             cfmakeraw(&rtt);
1362             rtt.c_lflag &= ~ECHO;
1363             rtt.c_lflag |= ISIG;
1364             // block SIGTTOU during tcsetattr to prevent a hang if
1365             // the process is a member of the background process group
1366             // http://www.opengroup.org/onlinepubs/000095399/functions/tcsetattr.html
1367             sigemptyset(&sigmask);
1368             sigaddset(&sigmask, SIGTTOU);
1369             sigprocmask(SIG_BLOCK,&sigmask, &original_sigmask);
1370             tcsetattr(0, TCSAFLUSH, &rtt);
1371             sigprocmask(SIG_SETMASK, &original_sigmask, 0);
1372          }
1373       }
1374       // complain only if stdout is either a terminal (but still failed) or is an invalid
1375       // descriptor otherwise we would complain about redirection to e.g. /dev/null as well.
1376       else if (isatty(STDOUT_FILENO) == 1 || errno == EBADF)
1377          _error->Errno("tcgetattr", _("Can not write log (%s)"), _("Is stdout a terminal?"));
1378
1379       if (_error->PendingError() == true)
1380          _error->DumpErrors(std::cerr);
1381       _error->RevertToStack();
1382
1383        // Fork dpkg
1384       pid_t Child;
1385       _config->Set("APT::Keep-Fds::",fd[1]);
1386       // send status information that we are about to fork dpkg
1387       if(OutStatusFd > 0) {
1388          ostringstream status;
1389          status << "pmstatus:dpkg-exec:"
1390                 << (PackagesDone/float(PackagesTotal)*100.0)
1391                 << ":" << _("Running dpkg")
1392                 << endl;
1393          FileFd::Write(OutStatusFd, status.str().c_str(), status.str().size());
1394       }
1395
1396       Child = ExecFork();
1397       // This is the child
1398       if (Child == 0)
1399       {
1400
1401          if(slave >= 0 && master >= 0)
1402          {
1403             setsid();
1404             ioctl(slave, TIOCSCTTY, 0);
1405             close(master);
1406             dup2(slave, 0);
1407             dup2(slave, 1);
1408             dup2(slave, 2);
1409             close(slave);
1410          }
1411          close(fd[0]); // close the read end of the pipe
1412
1413          dpkgChrootDirectory();
1414
1415          if (chdir(_config->FindDir("DPkg::Run-Directory","/").c_str()) != 0)
1416             _exit(100);
1417
1418          if (_config->FindB("DPkg::FlushSTDIN",true) == true && isatty(STDIN_FILENO))
1419          {
1420             int Flags,dummy;
1421             if ((Flags = fcntl(STDIN_FILENO,F_GETFL,dummy)) < 0)
1422                _exit(100);
1423
1424             // Discard everything in stdin before forking dpkg
1425             if (fcntl(STDIN_FILENO,F_SETFL,Flags | O_NONBLOCK) < 0)
1426                _exit(100);
1427
1428             while (read(STDIN_FILENO,&dummy,1) == 1);
1429
1430             if (fcntl(STDIN_FILENO,F_SETFL,Flags & (~(long)O_NONBLOCK)) < 0)
1431                _exit(100);
1432          }
1433          SetupTerminalScrollArea(d->nr_terminal_rows);
1434
1435          /* No Job Control Stop Env is a magic dpkg var that prevents it
1436             from using sigstop */
1437          putenv((char *)"DPKG_NO_TSTP=yes");
1438          execvp(Args[0], (char**) &Args[0]);
1439          cerr << "Could not exec dpkg!" << endl;
1440          _exit(100);
1441       }
1442
1443       // apply ionice
1444       if (_config->FindB("DPkg::UseIoNice", false) == true)
1445          ionice(Child);
1446
1447       // clear the Keep-Fd again
1448       _config->Clear("APT::Keep-Fds",fd[1]);
1449
1450       // Wait for dpkg
1451       int Status = 0;
1452
1453       // we read from dpkg here
1454       int const _dpkgin = fd[0];
1455       close(fd[1]);                        // close the write end of the pipe
1456
1457       if(slave > 0)
1458          close(slave);
1459
1460       // setups fds
1461       sigemptyset(&sigmask);
1462       sigprocmask(SIG_BLOCK,&sigmask,&original_sigmask);
1463
1464       /* free vectors (and therefore memory) as we don't need the included data anymore */
1465       for (std::vector<char *>::const_iterator p = Packages.begin();
1466            p != Packages.end(); ++p)
1467          free(*p);
1468       Packages.clear();
1469
1470       // the result of the waitpid call
1471       int res;
1472       int select_ret;
1473       while ((res=waitpid(Child,&Status, WNOHANG)) != Child) {
1474          if(res < 0) {
1475             // FIXME: move this to a function or something, looks ugly here
1476             // error handling, waitpid returned -1
1477             if (errno == EINTR)
1478                continue;
1479             RunScripts("DPkg::Post-Invoke");
1480
1481             // Restore sig int/quit
1482             signal(SIGQUIT,old_SIGQUIT);
1483             signal(SIGINT,old_SIGINT);
1484
1485             signal(SIGHUP,old_SIGHUP);
1486             return _error->Errno("waitpid","Couldn't wait for subprocess");
1487          }
1488
1489          // wait for input or output here
1490          FD_ZERO(&rfds);
1491          if (master >= 0 && !d->stdin_is_dev_null)
1492             FD_SET(0, &rfds);
1493          FD_SET(_dpkgin, &rfds);
1494          if(master >= 0)
1495             FD_SET(master, &rfds);
1496          tv.tv_sec = 1;
1497          tv.tv_nsec = 0;
1498          select_ret = pselect(max(master, _dpkgin)+1, &rfds, NULL, NULL,
1499                               &tv, &original_sigmask);
1500          if (select_ret < 0 && (errno == EINVAL || errno == ENOSYS))
1501             select_ret = racy_pselect(max(master, _dpkgin)+1, &rfds, NULL,
1502                                       NULL, &tv, &original_sigmask);
1503          if (select_ret == 0)
1504             continue;
1505          else if (select_ret < 0 && errno == EINTR)
1506             continue;
1507          else if (select_ret < 0)
1508          {
1509             perror("select() returned error");
1510             continue;
1511          }
1512
1513          if(master >= 0 && FD_ISSET(master, &rfds))
1514             DoTerminalPty(master);
1515          if(master >= 0 && FD_ISSET(0, &rfds))
1516             DoStdin(master);
1517          if(FD_ISSET(_dpkgin, &rfds))
1518             DoDpkgStatusFd(_dpkgin, OutStatusFd);
1519       }
1520       close(_dpkgin);
1521
1522       // Restore sig int/quit
1523       signal(SIGQUIT,old_SIGQUIT);
1524       signal(SIGINT,old_SIGINT);
1525
1526       signal(SIGHUP,old_SIGHUP);
1527
1528       // reset scroll area
1529       SetupTerminalScrollArea(d->nr_terminal_rows + 1);
1530       if(d->fancy_progress_output)
1531       {
1532          // override the progress line (sledgehammer)
1533          static const char* clear_screen_below_cursor = "\033[J";
1534          std::cout << clear_screen_below_cursor;
1535       }
1536
1537       if(master >= 0)
1538       {
1539          tcsetattr(0, TCSAFLUSH, &tt);
1540          close(master);
1541       }
1542
1543       // Check for an error code.
1544       if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
1545       {
1546          // if it was set to "keep-dpkg-runing" then we won't return
1547          // here but keep the loop going and just report it as a error
1548          // for later
1549          bool const stopOnError = _config->FindB("Dpkg::StopOnError",true);
1550
1551          if(stopOnError)
1552             RunScripts("DPkg::Post-Invoke");
1553
1554          if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV)
1555             strprintf(d->dpkg_error, "Sub-process %s received a segmentation fault.",Args[0]);
1556          else if (WIFEXITED(Status) != 0)
1557             strprintf(d->dpkg_error, "Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status));
1558          else
1559             strprintf(d->dpkg_error, "Sub-process %s exited unexpectedly",Args[0]);
1560
1561          if(d->dpkg_error.size() > 0)
1562             _error->Error("%s", d->dpkg_error.c_str());
1563
1564          if(stopOnError)
1565          {
1566             CloseLog();
1567             return false;
1568          }
1569       }
1570    }
1571    CloseLog();
1572
1573    // dpkg is done at this point
1574    if(_config->FindB("DPkgPM::Progress", false) == true)
1575       SendTerminalProgress(100);
1576
1577    if (pkgPackageManager::SigINTStop)
1578        _error->Warning(_("Operation was interrupted before it could finish"));
1579
1580    if (RunScripts("DPkg::Post-Invoke") == false)
1581       return false;
1582
1583    if (_config->FindB("Debug::pkgDPkgPM",false) == false)
1584    {
1585       std::string const oldpkgcache = _config->FindFile("Dir::cache::pkgcache");
1586       if (oldpkgcache.empty() == false && RealFileExists(oldpkgcache) == true &&
1587           unlink(oldpkgcache.c_str()) == 0)
1588       {
1589          std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
1590          if (srcpkgcache.empty() == false && RealFileExists(srcpkgcache) == true)
1591          {
1592             _error->PushToStack();
1593             pkgCacheFile CacheFile;
1594             CacheFile.BuildCaches(NULL, true);
1595             _error->RevertToStack();
1596          }
1597       }
1598    }
1599
1600    Cache.writeStateFile(NULL);
1601    return true;
1602 }
1603
1604 void SigINT(int sig) {
1605    pkgPackageManager::SigINTStop = true;
1606 }
1607                                                                         /*}}}*/
1608 // pkgDpkgPM::Reset - Dump the contents of the command list             /*{{{*/
1609 // ---------------------------------------------------------------------
1610 /* */
1611 void pkgDPkgPM::Reset()
1612 {
1613    List.erase(List.begin(),List.end());
1614 }
1615                                                                         /*}}}*/
1616 // pkgDpkgPM::WriteApportReport - write out error report pkg failure    /*{{{*/
1617 // ---------------------------------------------------------------------
1618 /* */
1619 void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
1620 {
1621    // If apport doesn't exist or isn't installed do nothing
1622    // This e.g. prevents messages in 'universes' without apport
1623    pkgCache::PkgIterator apportPkg = Cache.FindPkg("apport");
1624    if (apportPkg.end() == true || apportPkg->CurrentVer == 0)
1625       return;
1626
1627    string pkgname, reportfile, srcpkgname, pkgver, arch;
1628    string::size_type pos;
1629    FILE *report;
1630
1631    if (_config->FindB("Dpkg::ApportFailureReport", false) == false)
1632    {
1633       std::clog << "configured to not write apport reports" << std::endl;
1634       return;
1635    }
1636
1637    // only report the first errors
1638    if(pkgFailures > _config->FindI("APT::Apport::MaxReports", 3))
1639    {
1640       std::clog << _("No apport report written because MaxReports is reached already") << std::endl;
1641       return;
1642    }
1643
1644    // check if its not a follow up error
1645    const char *needle = dgettext("dpkg", "dependency problems - leaving unconfigured");
1646    if(strstr(errormsg, needle) != NULL) {
1647       std::clog << _("No apport report written because the error message indicates its a followup error from a previous failure.") << std::endl;
1648       return;
1649    }
1650
1651    // do not report disk-full failures
1652    if(strstr(errormsg, strerror(ENOSPC)) != NULL) {
1653       std::clog << _("No apport report written because the error message indicates a disk full error") << std::endl;
1654       return;
1655    }
1656
1657    // do not report out-of-memory failures
1658    if(strstr(errormsg, strerror(ENOMEM)) != NULL) {
1659       std::clog << _("No apport report written because the error message indicates a out of memory error") << std::endl;
1660       return;
1661    }
1662
1663    // do not report dpkg I/O errors
1664    // XXX - this message is localized, but this only matches the English version.  This is better than nothing.
1665    if(strstr(errormsg, "short read in buffer_copy (")) {
1666       std::clog << _("No apport report written because the error message indicates a dpkg I/O error") << std::endl;
1667       return;
1668    }
1669
1670    // get the pkgname and reportfile
1671    pkgname = flNotDir(pkgpath);
1672    pos = pkgname.find('_');
1673    if(pos != string::npos)
1674       pkgname = pkgname.substr(0, pos);
1675
1676    // find the package versin and source package name
1677    pkgCache::PkgIterator Pkg = Cache.FindPkg(pkgname);
1678    if (Pkg.end() == true)
1679       return;
1680    pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg);
1681    if (Ver.end() == true)
1682       return;
1683    pkgver = Ver.VerStr() == NULL ? "unknown" : Ver.VerStr();
1684    pkgRecords Recs(Cache);
1685    pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
1686    srcpkgname = Parse.SourcePkg();
1687    if(srcpkgname.empty())
1688       srcpkgname = pkgname;
1689
1690    // if the file exists already, we check:
1691    // - if it was reported already (touched by apport).
1692    //   If not, we do nothing, otherwise
1693    //    we overwrite it. This is the same behaviour as apport
1694    // - if we have a report with the same pkgversion already
1695    //   then we skip it
1696    reportfile = flCombine("/var/crash",pkgname+".0.crash");
1697    if(FileExists(reportfile))
1698    {
1699       struct stat buf;
1700       char strbuf[255];
1701
1702       // check atime/mtime
1703       stat(reportfile.c_str(), &buf);
1704       if(buf.st_mtime > buf.st_atime)
1705          return;
1706
1707       // check if the existing report is the same version
1708       report = fopen(reportfile.c_str(),"r");
1709       while(fgets(strbuf, sizeof(strbuf), report) != NULL)
1710       {
1711          if(strstr(strbuf,"Package:") == strbuf)
1712          {
1713             char pkgname[255], version[255];
1714             if(sscanf(strbuf, "Package: %254s %254s", pkgname, version) == 2)
1715                if(strcmp(pkgver.c_str(), version) == 0)
1716                {
1717                   fclose(report);
1718                   return;
1719                }
1720          }
1721       }
1722       fclose(report);
1723    }
1724
1725    // now write the report
1726    arch = _config->Find("APT::Architecture");
1727    report = fopen(reportfile.c_str(),"w");
1728    if(report == NULL)
1729       return;
1730    if(_config->FindB("DPkgPM::InitialReportOnly",false) == true)
1731       chmod(reportfile.c_str(), 0);
1732    else
1733       chmod(reportfile.c_str(), 0600);
1734    fprintf(report, "ProblemType: Package\n");
1735    fprintf(report, "Architecture: %s\n", arch.c_str());
1736    time_t now = time(NULL);
1737    fprintf(report, "Date: %s" , ctime(&now));
1738    fprintf(report, "Package: %s %s\n", pkgname.c_str(), pkgver.c_str());
1739    fprintf(report, "SourcePackage: %s\n", srcpkgname.c_str());
1740    fprintf(report, "ErrorMessage:\n %s\n", errormsg);
1741
1742    // ensure that the log is flushed
1743    if(d->term_out)
1744       fflush(d->term_out);
1745
1746    // attach terminal log it if we have it
1747    string logfile_name = _config->FindFile("Dir::Log::Terminal");
1748    if (!logfile_name.empty())
1749    {
1750       FILE *log = NULL;
1751
1752       fprintf(report, "DpkgTerminalLog:\n");
1753       log = fopen(logfile_name.c_str(),"r");
1754       if(log != NULL)
1755       {
1756          char buf[1024];
1757          while( fgets(buf, sizeof(buf), log) != NULL)
1758             fprintf(report, " %s", buf);
1759          fclose(log);
1760       }
1761    }
1762
1763    // log the ordering
1764    const char *ops_str[] = {"Install", "Configure","Remove","Purge"};
1765    fprintf(report, "AptOrdering:\n");
1766    for (vector<Item>::iterator I = List.begin(); I != List.end(); ++I)
1767       if ((*I).Pkg != NULL)
1768          fprintf(report, " %s: %s\n", (*I).Pkg.Name(), ops_str[(*I).Op]);
1769       else
1770          fprintf(report, " %s: %s\n", "NULL", ops_str[(*I).Op]);
1771
1772    // attach dmesg log (to learn about segfaults)
1773    if (FileExists("/bin/dmesg"))
1774    {
1775       fprintf(report, "Dmesg:\n");
1776       FILE *log = popen("/bin/dmesg","r");
1777       if(log != NULL)
1778       {
1779          char buf[1024];
1780          while( fgets(buf, sizeof(buf), log) != NULL)
1781             fprintf(report, " %s", buf);
1782          pclose(log);
1783       }
1784    }
1785
1786    // attach df -l log (to learn about filesystem status)
1787    if (FileExists("/bin/df"))
1788    {
1789
1790       fprintf(report, "Df:\n");
1791       FILE *log = popen("/bin/df -l","r");
1792       if(log != NULL)
1793       {
1794          char buf[1024];
1795          while( fgets(buf, sizeof(buf), log) != NULL)
1796             fprintf(report, " %s", buf);
1797          pclose(log);
1798       }
1799    }
1800
1801    fclose(report);
1802
1803 }
1804                                                                         /*}}}*/