apt-pkg/deb/dpkgpm.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: dpkgpm.cc,v 1.22 2001/05/27 04:40:57 jgg 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                                                                         /*}}}*/
 149 // DPkgPM::SendV2Pkgs - Send version 2 package info                     /*{{{*/
 150 // ---------------------------------------------------------------------
 151 /* This is part of the helper script communication interface, it sends
 152    very complete information down to the other end of the pipe.*/
 153 bool pkgDPkgPM::SendV2Pkgs(FILE *F)
 154 {
 155    fprintf(F,"VERSION 2\n");
 156
 157    /* Write out all of the configuration directives by walking the
 158       configuration tree */
 159    const Configuration::Item *Top = _config->Tree(0);
 160    for (; Top != 0;)
 161    {
 162       if (Top->Value.empty() == false)
 163       {
 164          fprintf(F,"%s=%s\n",
 165                  QuoteString(Top->FullTag(),"=\"\n").c_str(),
 166                  QuoteString(Top->Value,"\n").c_str());
 167       }
 168
 169       if (Top->Child != 0)
 170       {
 171          Top = Top->Child;
 172          continue;
 173       }
 174
 175       while (Top != 0 && Top->Next == 0)
 176          Top = Top->Parent;
 177       if (Top != 0)
 178          Top = Top->Next;
 179    }
 180    fprintf(F,"\n");
 181
 182    // Write out the package actions in order.
 183    for (vector<Item>::iterator I = List.begin(); I != List.end(); I++)
 184    {
 185       pkgDepCache::StateCache &S = Cache[I->Pkg];
 186
 187       fprintf(F,"%s ",I->Pkg.Name());
 188       // Current version
 189       if (I->Pkg->CurrentVer == 0)
 190          fprintf(F,"- ");
 191       else
 192          fprintf(F,"%s ",I->Pkg.CurrentVer().VerStr());
 193
 194       // Show the compare operator
 195       // Target version
 196       if (S.InstallVer != 0)
 197       {
 198          int Comp = 2;
 199          if (I->Pkg->CurrentVer != 0)
 200             Comp = S.InstVerIter(Cache).CompareVer(I->Pkg.CurrentVer());
 201          if (Comp < 0)
 202             fprintf(F,"> ");
 203          if (Comp == 0)
 204             fprintf(F,"= ");
 205          if (Comp > 0)
 206             fprintf(F,"< ");
 207          fprintf(F,"%s ",S.InstVerIter(Cache).VerStr());
 208       }
 209       else
 210          fprintf(F,"> - ");
 211
 212       // Show the filename/operation
 213       if (I->Op == Item::Install)
 214       {
 215          // No errors here..
 216          if (I->File[0] != '/')
 217             fprintf(F,"**ERROR**\n");
 218          else
 219             fprintf(F,"%s\n",I->File.c_str());
 220       }
 221       if (I->Op == Item::Configure)
 222          fprintf(F,"**CONFIGURE**\n");
 223       if (I->Op == Item::Remove ||
 224           I->Op == Item::Purge)
 225          fprintf(F,"**REMOVE**\n");
 226
 227       if (ferror(F) != 0)
 228          return false;
 229    }
 230    return true;
 231 }
 232                                                                         /*}}}*/
 233 // DPkgPM::RunScriptsWithPkgs - Run scripts with package names on stdin /*{{{*/
 234 // ---------------------------------------------------------------------
 235 /* This looks for a list of scripts to run from the configuration file
 236    each one is run and is fed on standard input a list of all .deb files
 237    that are due to be installed. */
 238 bool pkgDPkgPM::RunScriptsWithPkgs(const char *Cnf)
 239 {
 240    Configuration::Item const *Opts = _config->Tree(Cnf);
 241    if (Opts == 0 || Opts->Child == 0)
 242       return true;
 243    Opts = Opts->Child;
 244
 245    unsigned int Count = 1;
 246    for (; Opts != 0; Opts = Opts->Next, Count++)
 247    {
 248       if (Opts->Value.empty() == true)
 249          continue;
 250
 251       // Determine the protocol version
 252       string OptSec = Opts->Value;
 253       string::size_type Pos;
 254       if ((Pos = OptSec.find(' ')) == string::npos || Pos == 0)
 255          Pos = OptSec.length();
 256       OptSec = "DPkg::Tools::Options::" + string(Opts->Value.c_str(),Pos);
 257
 258       unsigned int Version = _config->FindI(OptSec+"::Version",1);
 259
 260       // Create the pipes
 261       int Pipes[2];
 262       if (pipe(Pipes) != 0)
 263          return _error->Errno("pipe","Failed to create IPC pipe to subprocess");
 264       SetCloseExec(Pipes[0],true);
 265       SetCloseExec(Pipes[1],true);
 266
 267       // Purified Fork for running the script
 268       pid_t Process = ExecFork();
 269       if (Process == 0)
 270       {
 271          // Setup the FDs
 272          dup2(Pipes[0],STDIN_FILENO);
 273          SetCloseExec(STDOUT_FILENO,false);
 274          SetCloseExec(STDIN_FILENO,false);
 275          SetCloseExec(STDERR_FILENO,false);
 276
 277          const char *Args[4];
 278          Args[0] = "/bin/sh";
 279          Args[1] = "-c";
 280          Args[2] = Opts->Value.c_str();
 281          Args[3] = 0;
 282          execv(Args[0],(char **)Args);
 283          _exit(100);
 284       }
 285       close(Pipes[0]);
 286       FILE *F = fdopen(Pipes[1],"w");
 287       if (F == 0)
 288          return _error->Errno("fdopen","Faild to open new FD");
 289
 290       // Feed it the filenames.
 291       bool Die = false;
 292       if (Version <= 1)
 293       {
 294          for (vector<Item>::iterator I = List.begin(); I != List.end(); I++)
 295          {
 296             // Only deal with packages to be installed from .deb
 297             if (I->Op != Item::Install)
 298                continue;
 299
 300             // No errors here..
 301             if (I->File[0] != '/')
 302                continue;
 303
 304             /* Feed the filename of each package that is pending install
 305                into the pipe. */
 306             fprintf(F,"%s\n",I->File.c_str());
 307             if (ferror(F) != 0)
 308             {
 309                Die = true;
 310                break;
 311             }
 312          }
 313       }
 314       else
 315          Die = !SendV2Pkgs(F);
 316
 317       fclose(F);
 318       if (Die == true)
 319       {
 320          kill(Process,SIGINT);
 321          ExecWait(Process,Opts->Value.c_str(),true);
 322          return _error->Error("Failure running script %s",Opts->Value.c_str());
 323       }
 324
 325       // Clean up the sub process
 326       if (ExecWait(Process,Opts->Value.c_str()) == false)
 327          return _error->Error("Failure running script %s",Opts->Value.c_str());
 328    }
 329
 330    return true;
 331 }
 332
 333                                                                         /*}}}*/
 334 // DPkgPM::Go - Run the sequence                                        /*{{{*/
 335 // ---------------------------------------------------------------------
 336 /* This globs the operations and calls dpkg */
 337 bool pkgDPkgPM::Go()
 338 {
 339    if (RunScripts("DPkg::Pre-Invoke") == false)
 340       return false;
 341
 342    if (RunScriptsWithPkgs("DPkg::Pre-Install-Pkgs") == false)
 343       return false;
 344
 345    for (vector<Item>::iterator I = List.begin(); I != List.end();)
 346    {
 347       vector<Item>::iterator J = I;
 348       for (; J != List.end() && J->Op == I->Op; J++);
 349
 350       // Generate the argument list
 351       const char *Args[400];
 352       if (J - I > 350)
 353          J = I + 350;
 354
 355       unsigned int n = 0;
 356       unsigned long Size = 0;
 357       string Tmp = _config->Find("Dir::Bin::dpkg","dpkg").c_str();
 358       Args[n++] = Tmp.c_str();
 359       Size += strlen(Args[n-1]);
 360
 361       // Stick in any custom dpkg options
 362       Configuration::Item const *Opts = _config->Tree("DPkg::Options");
 363       if (Opts != 0)
 364       {
 365          Opts = Opts->Child;
 366          for (; Opts != 0; Opts = Opts->Next)
 367          {
 368             if (Opts->Value.empty() == true)
 369                continue;
 370             Args[n++] = Opts->Value.c_str();
 371             Size += Opts->Value.length();
 372          }
 373       }
 374
 375       switch (I->Op)
 376       {
 377          case Item::Remove:
 378          Args[n++] = "--force-depends";
 379          Size += strlen(Args[n-1]);
 380          Args[n++] = "--force-remove-essential";
 381          Size += strlen(Args[n-1]);
 382          Args[n++] = "--remove";
 383          Size += strlen(Args[n-1]);
 384          break;
 385
 386          case Item::Purge:
 387          Args[n++] = "--force-depends";
 388          Size += strlen(Args[n-1]);
 389          Args[n++] = "--force-remove-essential";
 390          Size += strlen(Args[n-1]);
 391          Args[n++] = "--purge";
 392          Size += strlen(Args[n-1]);
 393          break;
 394
 395          case Item::Configure:
 396          Args[n++] = "--configure";
 397          Size += strlen(Args[n-1]);
 398          break;
 399
 400          case Item::Install:
 401          Args[n++] = "--unpack";
 402          Size += strlen(Args[n-1]);
 403          break;
 404       }
 405
 406       // Write in the file or package names
 407       if (I->Op == Item::Install)
 408       {
 409          for (;I != J && Size < 1024; I++)
 410          {
 411             if (I->File[0] != '/')
 412                return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str());
 413             Args[n++] = I->File.c_str();
 414             Size += strlen(Args[n-1]);
 415          }
 416       }
 417       else
 418       {
 419          for (;I != J && Size < 1024; I++)
 420          {
 421             Args[n++] = I->Pkg.Name();
 422             Size += strlen(Args[n-1]);
 423          }
 424       }
 425       Args[n] = 0;
 426       J = I;
 427
 428       if (_config->FindB("Debug::pkgDPkgPM",false) == true)
 429       {
 430          for (unsigned int k = 0; k != n; k++)
 431             clog << Args[k] << ' ';
 432          clog << endl;
 433          continue;
 434       }
 435
 436       cout << flush;
 437       clog << flush;
 438       cerr << flush;
 439
 440       /* Mask off sig int/quit. We do this because dpkg also does when
 441          it forks scripts. What happens is that when you hit ctrl-c it sends
 442          it to all processes in the group. Since dpkg ignores the signal
 443          it doesn't die but we do! So we must also ignore it */
 444       signal(SIGQUIT,SIG_IGN);
 445       signal(SIGINT,SIG_IGN);
 446
 447       // Fork dpkg
 448       pid_t Child = ExecFork();
 449
 450       // This is the child
 451       if (Child == 0)
 452       {
 453          if (chdir(_config->FindDir("DPkg::Run-Directory","/").c_str()) != 0)
 454             _exit(100);
 455
 456          if (_config->FindB("DPkg::FlushSTDIN",true) == true)
 457          {
 458             int Flags,dummy;
 459             if ((Flags = fcntl(STDIN_FILENO,F_GETFL,dummy)) < 0)
 460                _exit(100);
 461
 462             // Discard everything in stdin before forking dpkg
 463             if (fcntl(STDIN_FILENO,F_SETFL,Flags | O_NONBLOCK) < 0)
 464                _exit(100);
 465
 466             while (read(STDIN_FILENO,&dummy,1) == 1);
 467
 468             if (fcntl(STDIN_FILENO,F_SETFL,Flags & (~(long)O_NONBLOCK)) < 0)
 469                _exit(100);
 470          }
 471
 472          /* No Job Control Stop Env is a magic dpkg var that prevents it
 473             from using sigstop */
 474          putenv("DPKG_NO_TSTP=yes");
 475          execvp(Args[0],(char **)Args);
 476          cerr << "Could not exec dpkg!" << endl;
 477          _exit(100);
 478       }
 479
 480       // Wait for dpkg
 481       int Status = 0;
 482       while (waitpid(Child,&Status,0) != Child)
 483       {
 484          if (errno == EINTR)
 485             continue;
 486          RunScripts("DPkg::Post-Invoke");
 487          return _error->Errno("waitpid","Couldn't wait for subprocess");
 488       }
 489
 490       // Restore sig int/quit
 491       signal(SIGQUIT,SIG_DFL);
 492       signal(SIGINT,SIG_DFL);
 493
 494       // Check for an error code.
 495       if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
 496       {
 497          RunScripts("DPkg::Post-Invoke");
 498          if (WIFSIGNALED(Status) != 0 && WTERMSIG(Status) == SIGSEGV)
 499             return _error->Error("Sub-process %s received a segmentation fault.",Args[0]);
 500
 501          if (WIFEXITED(Status) != 0)
 502             return _error->Error("Sub-process %s returned an error code (%u)",Args[0],WEXITSTATUS(Status));
 503
 504          return _error->Error("Sub-process %s exited unexpectedly",Args[0]);
 505       }
 506    }
 507
 508    if (RunScripts("DPkg::Post-Invoke") == false)
 509       return false;
 510    return true;
 511 }
 512                                                                         /*}}}*/
 513 // pkgDpkgPM::Reset - Dump the contents of the command list             /*{{{*/
 514 // ---------------------------------------------------------------------
 515 /* */
 516 void pkgDPkgPM::Reset()
 517 {
 518    List.erase(List.begin(),List.end());
 519 }
 520                                                                         /*}}}*/