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 #ifdef __GNUG__
  12 #pragma implementation "apt-pkg/dpkgpm.h"
  13 #endif
  14 #include <apt-pkg/dpkgpm.h>
  15 #include <apt-pkg/error.h>
  16 #include <apt-pkg/configuration.h>
  17 #include <apt-pkg/depcache.h>
  18 #include <apt-pkg/strutl.h>
  19
  20 #include <unistd.h>
  21 #include <stdlib.h>
  22 #include <fcntl.h>
  23 #include <sys/types.h>
  24 #include <sys/wait.h>
  25 #include <signal.h>
  26 #include <errno.h>
  27 #include <stdio.h>
  28 #include <iostream>
  29                                                                         /*}}}*/
  30
  31 using namespace std;
  32
  33 // DPkgPM::pkgDPkgPM - Constructor                                      /*{{{*/
  34 // ---------------------------------------------------------------------
  35 /* */
  36 pkgDPkgPM::pkgDPkgPM(pkgDepCache *Cache) : pkgPackageManager(Cache)
  37 {
  38 }
  39                                                                         /*}}}*/
  40 // DPkgPM::pkgDPkgPM - Destructor                                       /*{{{*/
  41 // ---------------------------------------------------------------------
  42 /* */
  43 pkgDPkgPM::~pkgDPkgPM()
  44 {
  45 }
  46                                                                         /*}}}*/
  47 // DPkgPM::Install - Install a package                                  /*{{{*/
  48 // ---------------------------------------------------------------------
  49 /* Add an install operation to the sequence list */
  50 bool pkgDPkgPM::Install(PkgIterator Pkg,string File)
  51 {
  52    if (File.empty() == true || Pkg.end() == true)
  53       return _error->Error("Internal Error, No file name for %s",Pkg.Name());
  54
  55    List.push_back(Item(Item::Install,Pkg,File));
  56    return true;
  57 }
  58                                                                         /*}}}*/
  59 // DPkgPM::Configure - Configure a package                              /*{{{*/
  60 // ---------------------------------------------------------------------
  61 /* Add a configure operation to the sequence list */
  62 bool pkgDPkgPM::Configure(PkgIterator Pkg)
  63 {
  64    if (Pkg.end() == true)
  65       return false;
  66
  67    List.push_back(Item(Item::Configure,Pkg));
  68    return true;
  69 }
  70                                                                         /*}}}*/
  71 // DPkgPM::Remove - Remove a package                                    /*{{{*/
  72 // ---------------------------------------------------------------------
  73 /* Add a remove operation to the sequence list */
  74 bool pkgDPkgPM::Remove(PkgIterator Pkg,bool Purge)
  75 {
  76    if (Pkg.end() == true)
  77       return false;
  78
  79    if (Purge == true)
  80       List.push_back(Item(Item::Purge,Pkg));
  81    else
  82       List.push_back(Item(Item::Remove,Pkg));
  83    return true;
  84 }
  85                                                                         /*}}}*/
  86 // DPkgPM::RunScripts - Run a set of scripts                            /*{{{*/
  87 // ---------------------------------------------------------------------
  88 /* This looks for a list of script sto run from the configuration file,
  89    each one is run with system from a forked child. */
  90 bool pkgDPkgPM::RunScripts(const char *Cnf)
  91 {
  92    Configuration::Item const *Opts = _config->Tree(Cnf);
  93    if (Opts == 0 || Opts->Child == 0)
  94       return true;
  95    Opts = Opts->Child;
  96
  97    // Fork for running the system calls
  98    pid_t Child = ExecFork();
  99
 100    // This is the child
 101    if (Child == 0)
 102    {
 103       if (chdir("/tmp/") != 0)
 104          _exit(100);
 105
 106       unsigned int Count = 1;
 107       for (; Opts != 0; Opts = Opts->Next, Count++)
 108       {
 109          if (Opts->Value.empty() == true)
 110             continue;
 111
 112          if (system(Opts->Value.c_str()) != 0)
 113             _exit(100+Count);
 114       }
 115       _exit(0);
 116    }
 117
 118    // Wait for the child
 119    int Status = 0;
 120    while (waitpid(Child,&Status,0) != Child)
 121    {
 122       if (errno == EINTR)
 123          continue;
 124       return _error->Errno("waitpid","Couldn't wait for subprocess");
 125    }
 126
 127    // Restore sig int/quit
 128    signal(SIGQUIT,SIG_DFL);
 129    signal(SIGINT,SIG_DFL);
 130
 131    // Check for an error code.
 132    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
 133    {
 134       unsigned int Count = WEXITSTATUS(Status);
 135       if (Count > 100)
 136       {
 137          Count -= 100;
 138          for (; Opts != 0 && Count != 1; Opts = Opts->Next, Count--);
 139          _error->Error("Problem executing scripts %s '%s'",Cnf,Opts->Value.c_str());
 140       }
 141
 142       return _error->Error("Sub-process returned an error code");
 143    }
 144
 145    return true;
 146 }
 147                                                                         /*}}}*/
 148 // DPkgPM::SendV2Pkgs - Send version 2 package info                     /*{{{*/
 149 // ---------------------------------------------------------------------
 150 /* This is part of the helper script communication interface, it sends
 151    very complete information down to the other end of the pipe.*/
 152 bool pkgDPkgPM::SendV2Pkgs(FILE *F)
 153 {
 154    fprintf(F,"VERSION 2\n");
 155
 156    /* Write out all of the configuration directives by walking the
 157       configuration tree */
 158    const Configuration::Item *Top = _config->Tree(0);
 159    for (; Top != 0;)
 160    {
 161       if (Top->Value.empty() == false)
 162       {
 163          fprintf(F,"%s=%s\n",
 164                  QuoteString(Top->FullTag(),"=\"\n").c_str(),
 165                  QuoteString(Top->Value,"\n").c_str());
 166       }
 167
 168       if (Top->Child != 0)
 169       {
 170          Top = Top->Child;
 171          continue;
 172       }
 173
 174       while (Top != 0 && Top->Next == 0)
 175          Top = Top->Parent;
 176       if (Top != 0)
 177          Top = Top->Next;
 178    }
 179    fprintf(F,"\n");
 180
 181    // Write out the package actions in order.
 182    for (vector<Item>::iterator I = List.begin(); I != List.end(); I++)
 183    {
 184       pkgDepCache::StateCache &S = Cache[I->Pkg];
 185
 186       fprintf(F,"%s ",I->Pkg.Name());
 187       // Current version
 188       if (I->Pkg->CurrentVer == 0)
 189          fprintf(F,"- ");
 190       else
 191          fprintf(F,"%s ",I->Pkg.CurrentVer().VerStr());
 192
 193       // Show the compare operator
 194       // Target version
 195       if (S.InstallVer != 0)
 196       {
 197          int Comp = 2;
 198          if (I->Pkg->CurrentVer != 0)
 199             Comp = S.InstVerIter(Cache).CompareVer(I->Pkg.CurrentVer());
 200          if (Comp < 0)
 201             fprintf(F,"> ");
 202          if (Comp == 0)
 203             fprintf(F,"= ");
 204          if (Comp > 0)
 205             fprintf(F,"< ");
 206          fprintf(F,"%s ",S.InstVerIter(Cache).VerStr());
 207       }
 208       else
 209          fprintf(F,"> - ");
 210
 211       // Show the filename/operation
 212       if (I->Op == Item::Install)
 213       {
 214          // No errors here..
 215          if (I->File[0] != '/')
 216             fprintf(F,"**ERROR**\n");
 217          else
 218             fprintf(F,"%s\n",I->File.c_str());
 219       }
 220       if (I->Op == Item::Configure)
 221          fprintf(F,"**CONFIGURE**\n");
 222       if (I->Op == Item::Remove ||
 223           I->Op == Item::Purge)
 224          fprintf(F,"**REMOVE**\n");
 225
 226       if (ferror(F) != 0)
 227          return false;
 228    }
 229    return true;
 230 }
 231                                                                         /*}}}*/
 232 // DPkgPM::RunScriptsWithPkgs - Run scripts with package names on stdin /*{{{*/
 233 // ---------------------------------------------------------------------
 234 /* This looks for a list of scripts to run from the configuration file
 235    each one is run and is fed on standard input a list of all .deb files
 236    that are due to be installed. */
 237 bool pkgDPkgPM::RunScriptsWithPkgs(const char *Cnf)
 238 {
 239    Configuration::Item const *Opts = _config->Tree(Cnf);
 240    if (Opts == 0 || Opts->Child == 0)
 241       return true;
 242    Opts = Opts->Child;
 243
 244    unsigned int Count = 1;
 245    for (; Opts != 0; Opts = Opts->Next, Count++)
 246    {
 247       if (Opts->Value.empty() == true)
 248          continue;
 249
 250       // Determine the protocol version
 251       string OptSec = Opts->Value;
 252       string::size_type Pos;
 253       if ((Pos = OptSec.find(' ')) == string::npos || Pos == 0)
 254          Pos = OptSec.length();
 255       OptSec = "DPkg::Tools::Options::" + string(Opts->Value.c_str(),Pos);
 256
 257       unsigned int Version = _config->FindI(OptSec+"::Version",1);
 258
 259       // Create the pipes
 260       int Pipes[2];
 261       if (pipe(Pipes) != 0)
 262          return _error->Errno("pipe","Failed to create IPC pipe to subprocess");
 263       SetCloseExec(Pipes[0],true);
 264       SetCloseExec(Pipes[1],true);
 265
 266       // Purified Fork for running the script
 267       pid_t Process = ExecFork();
 268       if (Process == 0)
 269       {
 270          // Setup the FDs
 271          dup2(Pipes[0],STDIN_FILENO);
 272          SetCloseExec(STDOUT_FILENO,false);
 273          SetCloseExec(STDIN_FILENO,false);
 274          SetCloseExec(STDERR_FILENO,false);
 275
 276          const char *Args[4];
 277          Args[0] = "/bin/sh";
 278          Args[1] = "-c";
 279          Args[2] = Opts->Value.c_str();
 280          Args[3] = 0;
 281          execv(Args[0],(char **)Args);
 282          _exit(100);
 283       }
 284       close(Pipes[0]);
 285       FILE *F = fdopen(Pipes[1],"w");
 286       if (F == 0)
 287          return _error->Errno("fdopen","Faild to open new FD");
 288
 289       // Feed it the filenames.
 290       bool Die = false;
 291       if (Version <= 1)
 292       {
 293          for (vector<Item>::iterator I = List.begin(); I != List.end(); I++)
 294          {
 295             // Only deal with packages to be installed from .deb
 296             if (I->Op != Item::Install)
 297                continue;
 298
 299             // No errors here..
 300             if (I->File[0] != '/')
 301                continue;
 302
 303             /* Feed the filename of each package that is pending install
 304                into the pipe. */
 305             fprintf(F,"%s\n",I->File.c_str());
 306             if (ferror(F) != 0)
 307             {
 308                Die = true;
 309                break;
 310             }
 311          }
 312       }
 313       else
 314          Die = !SendV2Pkgs(F);
 315
 316       fclose(F);
 317
 318       // Clean up the sub process
 319       if (ExecWait(Process,Opts->Value.c_str()) == false)
 320          return _error->Error("Failure running script %s",Opts->Value.c_str());
 321    }
 322
 323    return true;
 324 }
 325                                                                         /*}}}*/
 326 // DPkgPM::Go - Run the sequence                                        /*{{{*/
 327 // ---------------------------------------------------------------------
 328 /* This globs the operations and calls dpkg */
 329 bool pkgDPkgPM::Go()
 330 {
 331    unsigned int MaxArgs = _config->FindI("Dpkg::MaxArgs",8*1024);
 332    unsigned int MaxArgBytes = _config->FindI("Dpkg::MaxArgBytes",32*1024);
 333
 334    if (RunScripts("DPkg::Pre-Invoke") == false)
 335       return false;
 336
 337    if (RunScriptsWithPkgs("DPkg::Pre-Install-Pkgs") == false)
 338       return false;
 339
 340    for (vector<Item>::iterator I = List.begin(); I != List.end();)
 341    {
 342       vector<Item>::iterator J = I;
 343       for (; J != List.end() && J->Op == I->Op; J++);
 344
 345       // Generate the argument list
 346       const char *Args[MaxArgs + 50];
 347       if (J - I > (signed)MaxArgs)
 348          J = I + MaxArgs;
 349
 350       unsigned int n = 0;
 351       unsigned long Size = 0;
 352       string Tmp = _config->Find("Dir::Bin::dpkg","dpkg");
 353       Args[n++] = Tmp.c_str();
 354       Size += strlen(Args[n-1]);
 355
 356       // Stick in any custom dpkg options
 357       Configuration::Item const *Opts = _config->Tree("DPkg::Options");
 358       if (Opts != 0)
 359       {
 360          Opts = Opts->Child;
 361          for (; Opts != 0; Opts = Opts->Next)
 362          {
 363             if (Opts->Value.empty() == true)
 364                continue;
 365             Args[n++] = Opts->Value.c_str();
 366             Size += Opts->Value.length();
 367          }
 368       }
 369
 370       switch (I->Op)
 371       {
 372          case Item::Remove:
 373          Args[n++] = "--force-depends";
 374          Size += strlen(Args[n-1]);
 375          Args[n++] = "--force-remove-essential";
 376          Size += strlen(Args[n-1]);
 377          Args[n++] = "--remove";
 378          Size += strlen(Args[n-1]);
 379          break;
 380
 381          case Item::Purge:
 382          Args[n++] = "--force-depends";
 383          Size += strlen(Args[n-1]);
 384          Args[n++] = "--force-remove-essential";
 385          Size += strlen(Args[n-1]);
 386          Args[n++] = "--purge";
 387          Size += strlen(Args[n-1]);
 388          break;
 389
 390          case Item::Configure:
 391          Args[n++] = "--configure";
 392          Size += strlen(Args[n-1]);
 393          break;
 394
 395          case Item::Install:
 396          Args[n++] = "--unpack";
 397          Size += strlen(Args[n-1]);
 398          break;
 399       }
 400
 401       // Write in the file or package names
 402       if (I->Op == Item::Install)
 403       {
 404          for (;I != J && Size < MaxArgBytes; I++)
 405          {
 406             if (I->File[0] != '/')
 407                return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str());
 408             Args[n++] = I->File.c_str();
 409             Size += strlen(Args[n-1]);
 410          }
 411       }
 412       else
 413       {
 414          for (;I != J && Size < MaxArgBytes; I++)
 415          {
 416             Args[n++] = I->Pkg.Name();
 417             Size += strlen(Args[n-1]);
 418          }
 419       }
 420       Args[n] = 0;
 421       J = I;
 422
 423       if (_config->FindB("Debug::pkgDPkgPM",false) == true)
 424       {
 425          for (unsigned int k = 0; k != n; k++)
 426             clog << Args[k] << ' ';
 427          clog << endl;
 428          continue;
 429       }
 430
 431       cout << flush;
 432       clog << flush;
 433       cerr << flush;
 434
 435       /* Mask off sig int/quit. We do this because dpkg also does when
 436          it forks scripts. What happens is that when you hit ctrl-c it sends
 437          it to all processes in the group. Since dpkg ignores the signal
 438          it doesn't die but we do! So we must also ignore it */
 439       sighandler_t old_SIGQUIT = signal(SIGQUIT,SIG_IGN);
 440       sighandler_t old_SIGINT = signal(SIGINT,SIG_IGN);
 441
 442       // Fork dpkg
 443       pid_t Child = ExecFork();
 444
 445       // This is the child
 446       if (Child == 0)
 447       {
 448          if (chdir(_config->FindDir("DPkg::Run-Directory","/").c_str()) != 0)
 449             _exit(100);
 450
 451          if (_config->FindB("DPkg::FlushSTDIN",true) == true && isatty(STDIN_FILENO))
 452          {
 453             int Flags,dummy;
 454             if ((Flags = fcntl(STDIN_FILENO,F_GETFL,dummy)) < 0)
 455                _exit(100);
 456
 457             // Discard everything in stdin before forking dpkg
 458             if (fcntl(STDIN_FILENO,F_SETFL,Flags | O_NONBLOCK) < 0)
 459                _exit(100);
 460
 461             while (read(STDIN_FILENO,&dummy,1) == 1);
 462
 463             if (fcntl(STDIN_FILENO,F_SETFL,Flags & (~(long)O_NONBLOCK)) < 0)
 464                _exit(100);
 465          }
 466
 467          /* No Job Control Stop Env is a magic dpkg var that prevents it
 468             from using sigstop */
 469          putenv("DPKG_NO_TSTP=yes");
 470          execvp(Args[0],(char **)Args);
 471          cerr << "Could not exec dpkg!" << endl;
 472          _exit(100);
 473       }
 474
 475       // Wait for dpkg
 476       int Status = 0;
 477       while (waitpid(Child,&Status,0) != Child)
 478       {
 479          if (errno == EINTR)
 480             continue;
 481          RunScripts("DPkg::Post-Invoke");
 482
 483          // Restore sig int/quit
 484          signal(SIGQUIT,old_SIGQUIT);
 485          signal(SIGINT,old_SIGINT);
 486          return _error->Errno("waitpid","Couldn't wait for subprocess");
 487       }
 488
 489       // Restore sig int/quit
 490       signal(SIGQUIT,old_SIGQUIT);
 491       signal(SIGINT,old_SIGINT);
 492
 493       // Check for an error code.
 494       if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
 495       {
 496          RunScripts("DPkg::Post-Invoke");
 497          if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV)
 498             return _error->Error("Sub-process %s received a segmentation fault.",Args[0]);
 499
 500          if (WIFEXITED(Status) != 0)
 501             return _error->Error("Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status));
 502
 503          return _error->Error("Sub-process %s exited unexpectedly",Args[0]);
 504       }
 505    }
 506
 507    if (RunScripts("DPkg::Post-Invoke") == false)
 508       return false;
 509    return true;
 510 }
 511                                                                         /*}}}*/
 512 // pkgDpkgPM::Reset - Dump the contents of the command list             /*{{{*/
 513 // ---------------------------------------------------------------------
 514 /* */
 515 void pkgDPkgPM::Reset()
 516 {
 517    List.erase(List.begin(),List.end());
 518 }
 519                                                                         /*}}}*/