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 <apt-pkg/dpkgpm.h>
  12 #include <apt-pkg/error.h>
  13 #include <apt-pkg/configuration.h>
  14 #include <apt-pkg/depcache.h>
  15 #include <apt-pkg/strutl.h>
  16
  17 #include <unistd.h>
  18 #include <stdlib.h>
  19 #include <fcntl.h>
  20 #include <sys/select.h>
  21 #include <sys/types.h>
  22 #include <sys/wait.h>
  23 #include <signal.h>
  24 #include <errno.h>
  25 #include <stdio.h>
  26 #include <sstream>
  27 #include <map>
  28
  29 #include <termios.h>
  30 #include <unistd.h>
  31 #include <sys/ioctl.h>
  32 #include <pty.h>
  33
  34 #include <config.h>
  35 #include <apti18n.h>
  36                                                                         /*}}}*/
  37
  38 using namespace std;
  39
  40
  41
  42 // DPkgPM::pkgDPkgPM - Constructor                                      /*{{{*/
  43 // ---------------------------------------------------------------------
  44 /* */
  45 pkgDPkgPM::pkgDPkgPM(pkgDepCache *Cache)
  46    : pkgPackageManager(Cache), dpkgbuf_pos(0), PackagesTotal(0), PackagesDone(0)
  47 {
  48 }
  49                                                                         /*}}}*/
  50 // DPkgPM::pkgDPkgPM - Destructor                                       /*{{{*/
  51 // ---------------------------------------------------------------------
  52 /* */
  53 pkgDPkgPM::~pkgDPkgPM()
  54 {
  55 }
  56                                                                         /*}}}*/
  57 // DPkgPM::Install - Install a package                                  /*{{{*/
  58 // ---------------------------------------------------------------------
  59 /* Add an install operation to the sequence list */
  60 bool pkgDPkgPM::Install(PkgIterator Pkg,string File)
  61 {
  62    if (File.empty() == true || Pkg.end() == true)
  63       return _error->Error("Internal Error, No file name for %s",Pkg.Name());
  64
  65    List.push_back(Item(Item::Install,Pkg,File));
  66    return true;
  67 }
  68                                                                         /*}}}*/
  69 // DPkgPM::Configure - Configure a package                              /*{{{*/
  70 // ---------------------------------------------------------------------
  71 /* Add a configure operation to the sequence list */
  72 bool pkgDPkgPM::Configure(PkgIterator Pkg)
  73 {
  74    if (Pkg.end() == true)
  75       return false;
  76
  77    List.push_back(Item(Item::Configure,Pkg));
  78    return true;
  79 }
  80                                                                         /*}}}*/
  81 // DPkgPM::Remove - Remove a package                                    /*{{{*/
  82 // ---------------------------------------------------------------------
  83 /* Add a remove operation to the sequence list */
  84 bool pkgDPkgPM::Remove(PkgIterator Pkg,bool Purge)
  85 {
  86    if (Pkg.end() == true)
  87       return false;
  88
  89    if (Purge == true)
  90       List.push_back(Item(Item::Purge,Pkg));
  91    else
  92       List.push_back(Item(Item::Remove,Pkg));
  93    return true;
  94 }
  95                                                                         /*}}}*/
  96 // DPkgPM::RunScripts - Run a set of scripts                            /*{{{*/
  97 // ---------------------------------------------------------------------
  98 /* This looks for a list of script sto run from the configuration file,
  99    each one is run with system from a forked child. */
 100 bool pkgDPkgPM::RunScripts(const char *Cnf)
 101 {
 102    Configuration::Item const *Opts = _config->Tree(Cnf);
 103    if (Opts == 0 || Opts->Child == 0)
 104       return true;
 105    Opts = Opts->Child;
 106
 107    // Fork for running the system calls
 108    pid_t Child = ExecFork();
 109
 110    // This is the child
 111    if (Child == 0)
 112    {
 113       if (chdir("/tmp/") != 0)
 114          _exit(100);
 115
 116       unsigned int Count = 1;
 117       for (; Opts != 0; Opts = Opts->Next, Count++)
 118       {
 119          if (Opts->Value.empty() == true)
 120             continue;
 121
 122          if (system(Opts->Value.c_str()) != 0)
 123             _exit(100+Count);
 124       }
 125       _exit(0);
 126    }
 127
 128    // Wait for the child
 129    int Status = 0;
 130    while (waitpid(Child,&Status,0) != Child)
 131    {
 132       if (errno == EINTR)
 133          continue;
 134       return _error->Errno("waitpid","Couldn't wait for subprocess");
 135    }
 136
 137    // Restore sig int/quit
 138    signal(SIGQUIT,SIG_DFL);
 139    signal(SIGINT,SIG_DFL);
 140
 141    // Check for an error code.
 142    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
 143    {
 144       unsigned int Count = WEXITSTATUS(Status);
 145       if (Count > 100)
 146       {
 147          Count -= 100;
 148          for (; Opts != 0 && Count != 1; Opts = Opts->Next, Count--);
 149          _error->Error("Problem executing scripts %s '%s'",Cnf,Opts->Value.c_str());
 150       }
 151
 152       return _error->Error("Sub-process returned an error code");
 153    }
 154
 155    return true;
 156 }
 157                                                                         /*}}}*/
 158 // DPkgPM::SendV2Pkgs - Send version 2 package info                     /*{{{*/
 159 // ---------------------------------------------------------------------
 160 /* This is part of the helper script communication interface, it sends
 161    very complete information down to the other end of the pipe.*/
 162 bool pkgDPkgPM::SendV2Pkgs(FILE *F)
 163 {
 164    fprintf(F,"VERSION 2\n");
 165
 166    /* Write out all of the configuration directives by walking the
 167       configuration tree */
 168    const Configuration::Item *Top = _config->Tree(0);
 169    for (; Top != 0;)
 170    {
 171       if (Top->Value.empty() == false)
 172       {
 173          fprintf(F,"%s=%s\n",
 174                  QuoteString(Top->FullTag(),"=\"\n").c_str(),
 175                  QuoteString(Top->Value,"\n").c_str());
 176       }
 177
 178       if (Top->Child != 0)
 179       {
 180          Top = Top->Child;
 181          continue;
 182       }
 183
 184       while (Top != 0 && Top->Next == 0)
 185          Top = Top->Parent;
 186       if (Top != 0)
 187          Top = Top->Next;
 188    }
 189    fprintf(F,"\n");
 190
 191    // Write out the package actions in order.
 192    for (vector<Item>::iterator I = List.begin(); I != List.end(); I++)
 193    {
 194       pkgDepCache::StateCache &S = Cache[I->Pkg];
 195
 196       fprintf(F,"%s ",I->Pkg.Name());
 197       // Current version
 198       if (I->Pkg->CurrentVer == 0)
 199          fprintf(F,"- ");
 200       else
 201          fprintf(F,"%s ",I->Pkg.CurrentVer().VerStr());
 202
 203       // Show the compare operator
 204       // Target version
 205       if (S.InstallVer != 0)
 206       {
 207          int Comp = 2;
 208          if (I->Pkg->CurrentVer != 0)
 209             Comp = S.InstVerIter(Cache).CompareVer(I->Pkg.CurrentVer());
 210          if (Comp < 0)
 211             fprintf(F,"> ");
 212          if (Comp == 0)
 213             fprintf(F,"= ");
 214          if (Comp > 0)
 215             fprintf(F,"< ");
 216          fprintf(F,"%s ",S.InstVerIter(Cache).VerStr());
 217       }
 218       else
 219          fprintf(F,"> - ");
 220
 221       // Show the filename/operation
 222       if (I->Op == Item::Install)
 223       {
 224          // No errors here..
 225          if (I->File[0] != '/')
 226             fprintf(F,"**ERROR**\n");
 227          else
 228             fprintf(F,"%s\n",I->File.c_str());
 229       }
 230       if (I->Op == Item::Configure)
 231          fprintf(F,"**CONFIGURE**\n");
 232       if (I->Op == Item::Remove ||
 233           I->Op == Item::Purge)
 234          fprintf(F,"**REMOVE**\n");
 235
 236       if (ferror(F) != 0)
 237          return false;
 238    }
 239    return true;
 240 }
 241                                                                         /*}}}*/
 242 // DPkgPM::RunScriptsWithPkgs - Run scripts with package names on stdin /*{{{*/
 243 // ---------------------------------------------------------------------
 244 /* This looks for a list of scripts to run from the configuration file
 245    each one is run and is fed on standard input a list of all .deb files
 246    that are due to be installed. */
 247 bool pkgDPkgPM::RunScriptsWithPkgs(const char *Cnf)
 248 {
 249    Configuration::Item const *Opts = _config->Tree(Cnf);
 250    if (Opts == 0 || Opts->Child == 0)
 251       return true;
 252    Opts = Opts->Child;
 253
 254    unsigned int Count = 1;
 255    for (; Opts != 0; Opts = Opts->Next, Count++)
 256    {
 257       if (Opts->Value.empty() == true)
 258          continue;
 259
 260       // Determine the protocol version
 261       string OptSec = Opts->Value;
 262       string::size_type Pos;
 263       if ((Pos = OptSec.find(' ')) == string::npos || Pos == 0)
 264          Pos = OptSec.length();
 265       OptSec = "DPkg::Tools::Options::" + string(Opts->Value.c_str(),Pos);
 266
 267       unsigned int Version = _config->FindI(OptSec+"::Version",1);
 268
 269       // Create the pipes
 270       int Pipes[2];
 271       if (pipe(Pipes) != 0)
 272          return _error->Errno("pipe","Failed to create IPC pipe to subprocess");
 273       SetCloseExec(Pipes[0],true);
 274       SetCloseExec(Pipes[1],true);
 275
 276       // Purified Fork for running the script
 277       pid_t Process = ExecFork();
 278       if (Process == 0)
 279       {
 280          // Setup the FDs
 281          dup2(Pipes[0],STDIN_FILENO);
 282          SetCloseExec(STDOUT_FILENO,false);
 283          SetCloseExec(STDIN_FILENO,false);
 284          SetCloseExec(STDERR_FILENO,false);
 285
 286          const char *Args[4];
 287          Args[0] = "/bin/sh";
 288          Args[1] = "-c";
 289          Args[2] = Opts->Value.c_str();
 290          Args[3] = 0;
 291          execv(Args[0],(char **)Args);
 292          _exit(100);
 293       }
 294       close(Pipes[0]);
 295       FILE *F = fdopen(Pipes[1],"w");
 296       if (F == 0)
 297          return _error->Errno("fdopen","Faild to open new FD");
 298
 299       // Feed it the filenames.
 300       bool Die = false;
 301       if (Version <= 1)
 302       {
 303          for (vector<Item>::iterator I = List.begin(); I != List.end(); I++)
 304          {
 305             // Only deal with packages to be installed from .deb
 306             if (I->Op != Item::Install)
 307                continue;
 308
 309             // No errors here..
 310             if (I->File[0] != '/')
 311                continue;
 312
 313             /* Feed the filename of each package that is pending install
 314                into the pipe. */
 315             fprintf(F,"%s\n",I->File.c_str());
 316             if (ferror(F) != 0)
 317             {
 318                Die = true;
 319                break;
 320             }
 321          }
 322       }
 323       else
 324          Die = !SendV2Pkgs(F);
 325
 326       fclose(F);
 327
 328       // Clean up the sub process
 329       if (ExecWait(Process,Opts->Value.c_str()) == false)
 330          return _error->Error("Failure running script %s",Opts->Value.c_str());
 331    }
 332
 333    return true;
 334 }
 335
 336                                                                         /*}}}*/
 337 // DPkgPM::DoStdin - Read stdin and pass to slave pty                   /*{{{*/
 338 // ---------------------------------------------------------------------
 339 /*
 340 */
 341 void pkgDPkgPM::DoStdin(int master)
 342 {
 343    char input_buf[256] = {0,};
 344    int len = read(0, input_buf, sizeof(input_buf));
 345    write(master, input_buf, len);
 346 }
 347                                                                         /*}}}*/
 348 // DPkgPM::DoTerminalPty - Read the terminal pty and write log          /*{{{*/
 349 // ---------------------------------------------------------------------
 350 /*
 351  * read the terminal pty and write log
 352  */
 353 void pkgDPkgPM::DoTerminalPty(int master, FILE *term_out)
 354 {
 355    char term_buf[1024] = {0,};
 356
 357    int len=read(master, term_buf, sizeof(term_buf));
 358    if(len <= 0)
 359       return;
 360    write(1, term_buf, len);
 361    if(term_out)
 362       fwrite(term_buf, len, sizeof(char), term_out);
 363 }
 364                                                                         /*}}}*/
 365 // DPkgPM::ProcessDpkgStatusBuf                                         /*{{{*/
 366 // ---------------------------------------------------------------------
 367 /*
 368  */
 369 void pkgDPkgPM::ProcessDpkgStatusLine(int OutStatusFd, char *line)
 370 {
 371    // the status we output
 372    ostringstream status;
 373
 374    if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true)
 375       std::clog << "got from dpkg '" << line << "'" << std::endl;
 376
 377
 378    /* dpkg sends strings like this:
 379       'status:   <pkg>:  <pkg  qstate>'
 380       errors look like this:
 381       '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
 382       and conffile-prompt like this
 383       'status: conffile-prompt: conffile : 'current-conffile' 'new-conffile' useredited distedited
 384
 385    */
 386    char* list[5];
 387    //        dpkg sends multiline error messages sometimes (see
 388    //        #374195 for a example. we should support this by
 389    //        either patching dpkg to not send multiline over the
 390    //        statusfd or by rewriting the code here to deal with
 391    //        it. for now we just ignore it and not crash
 392    TokSplitString(':', line, list, sizeof(list)/sizeof(list[0]));
 393    char *pkg = list[1];
 394    char *action = _strstrip(list[2]);
 395    if( pkg == NULL || action == NULL)
 396    {
 397       if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true)
 398          std::clog << "ignoring line: not enough ':'" << std::endl;
 399       return;
 400    }
 401
 402    if(strncmp(action,"error",strlen("error")) == 0)
 403    {
 404       status << "pmerror:" << list[1]
 405              << ":"  << (PackagesDone/float(PackagesTotal)*100.0)
 406              << ":" << list[3]
 407              << endl;
 408       if(OutStatusFd > 0)
 409          write(OutStatusFd, status.str().c_str(), status.str().size());
 410       if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true)
 411          std::clog << "send: '" << status.str() << "'" << endl;
 412       return;
 413    }
 414    if(strncmp(action,"conffile",strlen("conffile")) == 0)
 415    {
 416       status << "pmconffile:" << list[1]
 417              << ":"  << (PackagesDone/float(PackagesTotal)*100.0)
 418              << ":" << list[3]
 419              << endl;
 420       if(OutStatusFd > 0)
 421          write(OutStatusFd, status.str().c_str(), status.str().size());
 422       if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true)
 423          std::clog << "send: '" << status.str() << "'" << endl;
 424       return;
 425    }
 426
 427    vector<struct DpkgState> &states = PackageOps[pkg];
 428    const char *next_action = NULL;
 429    if(PackageOpsDone[pkg] < states.size())
 430       next_action = states[PackageOpsDone[pkg]].state;
 431    // check if the package moved to the next dpkg state
 432    if(next_action && (strcmp(action, next_action) == 0))
 433    {
 434       // only read the translation if there is actually a next
 435       // action
 436       const char *translation = _(states[PackageOpsDone[pkg]].str);
 437       char s[200];
 438       snprintf(s, sizeof(s), translation, pkg);
 439
 440       // we moved from one dpkg state to a new one, report that
 441       PackageOpsDone[pkg]++;
 442       PackagesDone++;
 443       // build the status str
 444       status << "pmstatus:" << pkg
 445              << ":"  << (PackagesDone/float(PackagesTotal)*100.0)
 446              << ":" << s
 447              << endl;
 448       if(OutStatusFd > 0)
 449          write(OutStatusFd, status.str().c_str(), status.str().size());
 450       if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true)
 451          std::clog << "send: '" << status.str() << "'" << endl;
 452    }
 453    if (_config->FindB("Debug::pkgDPkgProgressReporting",false) == true)
 454       std::clog << "(parsed from dpkg) pkg: " << pkg
 455                 << " action: " << action << endl;
 456 }
 457
 458 // DPkgPM::DoDpkgStatusFd                                               /*{{{*/
 459 // ---------------------------------------------------------------------
 460 /*
 461  */
 462 void pkgDPkgPM::DoDpkgStatusFd(int statusfd, int OutStatusFd)
 463 {
 464    char *p, *q;
 465    int len;
 466
 467    len=read(statusfd, &dpkgbuf[dpkgbuf_pos], sizeof(dpkgbuf)-dpkgbuf_pos);
 468    dpkgbuf_pos += len;
 469    if(len <= 0)
 470       return;
 471
 472    // process line by line if we have a buffer
 473    p = q = dpkgbuf;
 474    while((q=(char*)memchr(p, '\n', dpkgbuf+dpkgbuf_pos-p)) != NULL)
 475    {
 476       *q = 0;
 477       ProcessDpkgStatusLine(OutStatusFd, p);
 478       p=q+1; // continue with next line
 479    }
 480
 481    // now move the unprocessed bits (after the final \n that is now a 0x0)
 482    // to the start and update dpkgbuf_pos
 483    p = (char*)memrchr(dpkgbuf, 0, dpkgbuf_pos);
 484    if(p == NULL)
 485       return;
 486
 487    // we are interessted in the first char *after* 0x0
 488    p++;
 489
 490    // move the unprocessed tail to the start and update pos
 491    memmove(dpkgbuf, p, p-dpkgbuf);
 492    dpkgbuf_pos = dpkgbuf+dpkgbuf_pos-p;
 493 }
 494                                                                         /*}}}*/
 495
 496
 497 // DPkgPM::Go - Run the sequence                                        /*{{{*/
 498 // ---------------------------------------------------------------------
 499 /* This globs the operations and calls dpkg
 500  *
 501  * If it is called with "OutStatusFd" set to a valid file descriptor
 502  * apt will report the install progress over this fd. It maps the
 503  * dpkg states a package goes through to human readable (and i10n-able)
 504  * names and calculates a percentage for each step.
 505 */
 506 bool pkgDPkgPM::Go(int OutStatusFd)
 507 {
 508    unsigned int MaxArgs = _config->FindI("Dpkg::MaxArgs",8*1024);
 509    unsigned int MaxArgBytes = _config->FindI("Dpkg::MaxArgBytes",32*1024);
 510
 511    if (RunScripts("DPkg::Pre-Invoke") == false)
 512       return false;
 513
 514    if (RunScriptsWithPkgs("DPkg::Pre-Install-Pkgs") == false)
 515       return false;
 516
 517    // map the dpkg states to the operations that are performed
 518    // (this is sorted in the same way as Item::Ops)
 519    static const struct DpkgState DpkgStatesOpMap[][5] = {
 520       // Install operation
 521       {
 522          {"half-installed", N_("Preparing %s")},
 523          {"unpacked", N_("Unpacking %s") },
 524          {NULL, NULL}
 525       },
 526       // Configure operation
 527       {
 528          {"unpacked",N_("Preparing to configure %s") },
 529          {"half-configured", N_("Configuring %s") },
 530          { "installed", N_("Installed %s")},
 531          {NULL, NULL}
 532       },
 533       // Remove operation
 534       {
 535          {"half-configured", N_("Preparing for removal of %s")},
 536          {"half-installed", N_("Removing %s")},
 537          {"config-files",  N_("Removed %s")},
 538          {NULL, NULL}
 539       },
 540       // Purge operation
 541       {
 542          {"config-files", N_("Preparing to completely remove %s")},
 543          {"not-installed", N_("Completely removed %s")},
 544          {NULL, NULL}
 545       },
 546    };
 547
 548    // init the PackageOps map, go over the list of packages that
 549    // that will be [installed|configured|removed|purged] and add
 550    // them to the PackageOps map (the dpkg states it goes through)
 551    // and the PackageOpsTranslations (human readable strings)
 552    for (vector<Item>::iterator I = List.begin(); I != List.end();I++)
 553    {
 554       string name = (*I).Pkg.Name();
 555       PackageOpsDone[name] = 0;
 556       for(int i=0; (DpkgStatesOpMap[(*I).Op][i]).state != NULL;  i++)
 557       {
 558          PackageOps[name].push_back(DpkgStatesOpMap[(*I).Op][i]);
 559          PackagesTotal++;
 560       }
 561    }
 562
 563    // create log
 564    string logdir = _config->FindDir("Dir::Log");
 565    if(not FileExists(logdir))
 566       return _error->Error(_("Directory '%s' missing"), logdir.c_str());
 567    string logfile_name = flCombine(logdir,
 568                                    _config->Find("Dir::Log::Terminal"));
 569    FILE *term_out = NULL;
 570    if (!logfile_name.empty())
 571    {
 572       term_out = fopen(logfile_name.c_str(),"a");
 573       chmod(logfile_name.c_str(), 0600);
 574       // output current time
 575       char outstr[200];
 576       time_t t = time(NULL);
 577       struct tm *tmp = localtime(&t);
 578       strftime(outstr, sizeof(outstr), "%F  %T", tmp);
 579       fprintf(term_out, "\nLog started: ");
 580       fprintf(term_out, outstr);
 581       fprintf(term_out, "\n");
 582    }
 583
 584    // this loop is runs once per operation
 585    for (vector<Item>::iterator I = List.begin(); I != List.end();)
 586    {
 587       vector<Item>::iterator J = I;
 588       for (; J != List.end() && J->Op == I->Op; J++);
 589
 590       // Generate the argument list
 591       const char *Args[MaxArgs + 50];
 592       if (J - I > (signed)MaxArgs)
 593          J = I + MaxArgs;
 594
 595       unsigned int n = 0;
 596       unsigned long Size = 0;
 597       string Tmp = _config->Find("Dir::Bin::dpkg","dpkg");
 598       Args[n++] = Tmp.c_str();
 599       Size += strlen(Args[n-1]);
 600
 601       // Stick in any custom dpkg options
 602       Configuration::Item const *Opts = _config->Tree("DPkg::Options");
 603       if (Opts != 0)
 604       {
 605          Opts = Opts->Child;
 606          for (; Opts != 0; Opts = Opts->Next)
 607          {
 608             if (Opts->Value.empty() == true)
 609                continue;
 610             Args[n++] = Opts->Value.c_str();
 611             Size += Opts->Value.length();
 612          }
 613       }
 614
 615       char status_fd_buf[20];
 616       int fd[2];
 617       pipe(fd);
 618
 619       Args[n++] = "--status-fd";
 620       Size += strlen(Args[n-1]);
 621       snprintf(status_fd_buf,sizeof(status_fd_buf),"%i", fd[1]);
 622       Args[n++] = status_fd_buf;
 623       Size += strlen(Args[n-1]);
 624
 625       switch (I->Op)
 626       {
 627          case Item::Remove:
 628          Args[n++] = "--force-depends";
 629          Size += strlen(Args[n-1]);
 630          Args[n++] = "--force-remove-essential";
 631          Size += strlen(Args[n-1]);
 632          Args[n++] = "--remove";
 633          Size += strlen(Args[n-1]);
 634          break;
 635
 636          case Item::Purge:
 637          Args[n++] = "--force-depends";
 638          Size += strlen(Args[n-1]);
 639          Args[n++] = "--force-remove-essential";
 640          Size += strlen(Args[n-1]);
 641          Args[n++] = "--purge";
 642          Size += strlen(Args[n-1]);
 643          break;
 644
 645          case Item::Configure:
 646          Args[n++] = "--configure";
 647          Size += strlen(Args[n-1]);
 648          break;
 649
 650          case Item::Install:
 651          Args[n++] = "--unpack";
 652          Size += strlen(Args[n-1]);
 653          Args[n++] = "--auto-deconfigure";
 654          Size += strlen(Args[n-1]);
 655          break;
 656       }
 657
 658       // Write in the file or package names
 659       if (I->Op == Item::Install)
 660       {
 661          for (;I != J && Size < MaxArgBytes; I++)
 662          {
 663             if (I->File[0] != '/')
 664                return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str());
 665             Args[n++] = I->File.c_str();
 666             Size += strlen(Args[n-1]);
 667          }
 668       }
 669       else
 670       {
 671          for (;I != J && Size < MaxArgBytes; I++)
 672          {
 673             Args[n++] = I->Pkg.Name();
 674             Size += strlen(Args[n-1]);
 675          }
 676       }
 677       Args[n] = 0;
 678       J = I;
 679
 680       if (_config->FindB("Debug::pkgDPkgPM",false) == true)
 681       {
 682          for (unsigned int k = 0; k != n; k++)
 683             clog << Args[k] << ' ';
 684          clog << endl;
 685          continue;
 686       }
 687
 688       cout << flush;
 689       clog << flush;
 690       cerr << flush;
 691
 692       /* Mask off sig int/quit. We do this because dpkg also does when
 693          it forks scripts. What happens is that when you hit ctrl-c it sends
 694          it to all processes in the group. Since dpkg ignores the signal
 695          it doesn't die but we do! So we must also ignore it */
 696       sighandler_t old_SIGQUIT = signal(SIGQUIT,SIG_IGN);
 697       sighandler_t old_SIGINT = signal(SIGINT,SIG_IGN);
 698
 699       struct    termios tt;
 700       struct    winsize win;
 701       int       master;
 702       int       slave;
 703
 704       // FIXME: setup sensible signal handling (*ick*)
 705       tcgetattr(0, &tt);
 706       ioctl(0, TIOCGWINSZ, (char *)&win);
 707       if (openpty(&master, &slave, NULL, &tt, &win) < 0)
 708       {
 709          fprintf(stderr, _("openpty failed\n"));
 710       }
 711
 712       struct termios rtt;
 713       rtt = tt;
 714       cfmakeraw(&rtt);
 715       rtt.c_lflag &= ~ECHO;
 716       tcsetattr(0, TCSAFLUSH, &rtt);
 717
 718        // Fork dpkg
 719       pid_t Child;
 720       _config->Set("APT::Keep-Fds::",fd[1]);
 721       Child = ExecFork();
 722
 723       // This is the child
 724       if (Child == 0)
 725       {
 726          setsid();
 727          ioctl(slave, TIOCSCTTY, 0);
 728          close(master);
 729          dup2(slave, 0);
 730          dup2(slave, 1);
 731          dup2(slave, 2);
 732          close(slave);
 733          close(fd[0]); // close the read end of the pipe
 734
 735          if (chdir(_config->FindDir("DPkg::Run-Directory","/").c_str()) != 0)
 736             _exit(100);
 737
 738          if (_config->FindB("DPkg::FlushSTDIN",true) == true && isatty(STDIN_FILENO))
 739          {
 740             int Flags,dummy;
 741             if ((Flags = fcntl(STDIN_FILENO,F_GETFL,dummy)) < 0)
 742                _exit(100);
 743
 744             // Discard everything in stdin before forking dpkg
 745             if (fcntl(STDIN_FILENO,F_SETFL,Flags | O_NONBLOCK) < 0)
 746                _exit(100);
 747
 748             while (read(STDIN_FILENO,&dummy,1) == 1);
 749
 750             if (fcntl(STDIN_FILENO,F_SETFL,Flags & (~(long)O_NONBLOCK)) < 0)
 751                _exit(100);
 752          }
 753
 754
 755          /* No Job Control Stop Env is a magic dpkg var that prevents it
 756             from using sigstop */
 757          putenv("DPKG_NO_TSTP=yes");
 758          execvp(Args[0],(char **)Args);
 759          cerr << "Could not exec dpkg!" << endl;
 760          _exit(100);
 761       }
 762
 763       // clear the Keep-Fd again
 764       _config->Clear("APT::Keep-Fds",fd[1]);
 765
 766       // Wait for dpkg
 767       int Status = 0;
 768
 769       // we read from dpkg here
 770       int _dpkgin = fd[0];
 771       close(fd[1]);                        // close the write end of the pipe
 772
 773       // the read buffers for the communication with dpkg
 774       char buf[2] = {0,0};
 775
 776       // the result of the waitpid call
 777       int res;
 778       close(slave);
 779
 780       // setups fds
 781       fd_set rfds;
 782       struct timeval tv;
 783       int select_ret;
 784       while ((res=waitpid(Child,&Status, WNOHANG)) != Child) {
 785          if(res < 0) {
 786             // FIXME: move this to a function or something, looks ugly here
 787             // error handling, waitpid returned -1
 788             if (errno == EINTR)
 789                continue;
 790             RunScripts("DPkg::Post-Invoke");
 791
 792             // Restore sig int/quit
 793             signal(SIGQUIT,old_SIGQUIT);
 794             signal(SIGINT,old_SIGINT);
 795             return _error->Errno("waitpid","Couldn't wait for subprocess");
 796          }
 797
 798          // wait for input or output here
 799          FD_ZERO(&rfds);
 800          FD_SET(0, &rfds);
 801          FD_SET(_dpkgin, &rfds);
 802          FD_SET(master, &rfds);
 803          tv.tv_sec = 1;
 804          tv.tv_usec = 0;
 805          select_ret = select(max(master, _dpkgin)+1, &rfds, NULL, NULL, &tv);
 806          if (select_ret < 0)
 807             std::cerr << "Error in select()" << std::endl;
 808          else if (select_ret == 0)
 809             continue;
 810
 811          if(FD_ISSET(master, &rfds))
 812             DoTerminalPty(master, term_out);
 813          if(FD_ISSET(0, &rfds))
 814             DoStdin(master);
 815          if(FD_ISSET(_dpkgin, &rfds))
 816             DoDpkgStatusFd(_dpkgin, OutStatusFd);
 817       }
 818       close(_dpkgin);
 819
 820       // Restore sig int/quit
 821       signal(SIGQUIT,old_SIGQUIT);
 822       signal(SIGINT,old_SIGINT);
 823
 824       tcsetattr(0, TCSAFLUSH, &tt);
 825
 826       // Check for an error code.
 827       if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
 828       {
 829          // if it was set to "keep-dpkg-runing" then we won't return
 830          // here but keep the loop going and just report it as a error
 831          // for later
 832          bool stopOnError = _config->FindB("Dpkg::StopOnError",true);
 833
 834          if(stopOnError)
 835             RunScripts("DPkg::Post-Invoke");
 836
 837          if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV)
 838             _error->Error("Sub-process %s received a segmentation fault.",Args[0]);
 839          else if (WIFEXITED(Status) != 0)
 840             _error->Error("Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status));
 841          else
 842             _error->Error("Sub-process %s exited unexpectedly",Args[0]);
 843
 844          if(stopOnError)
 845          {
 846             fclose(term_out);
 847             return false;
 848          }
 849       }
 850    }
 851    fclose(term_out);
 852
 853    if (RunScripts("DPkg::Post-Invoke") == false)
 854       return false;
 855    return true;
 856 }
 857                                                                         /*}}}*/
 858 // pkgDpkgPM::Reset - Dump the contents of the command list             /*{{{*/
 859 // ---------------------------------------------------------------------
 860 /* */
 861 void pkgDPkgPM::Reset()
 862 {
 863    List.erase(List.begin(),List.end());
 864 }
 865                                                                         /*}}}*/