apt-pkg/deb/dpkgpm.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: dpkgpm.cc,v 1.6 1999/01/31 08:49:39 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
  18 #include <unistd.h>
  19 #include <stdlib.h>
  20 #include <fcntl.h>
  21 #include <sys/types.h>
  22 #include <sys/wait.h>
  23 #include <signal.h>
  24 #include <errno.h>
  25                                                                         /*}}}*/
  26
  27 // DPkgPM::pkgDPkgPM - Constructor                                      /*{{{*/
  28 // ---------------------------------------------------------------------
  29 /* */
  30 pkgDPkgPM::pkgDPkgPM(pkgDepCache &Cache) : pkgPackageManager(Cache)
  31 {
  32 }
  33                                                                         /*}}}*/
  34 // DPkgPM::pkgDPkgPM - Destructor                                       /*{{{*/
  35 // ---------------------------------------------------------------------
  36 /* */
  37 pkgDPkgPM::~pkgDPkgPM()
  38 {
  39 }
  40                                                                         /*}}}*/
  41 // DPkgPM::Install - Install a package                                  /*{{{*/
  42 // ---------------------------------------------------------------------
  43 /* Add an install operation to the sequence list */
  44 bool pkgDPkgPM::Install(PkgIterator Pkg,string File)
  45 {
  46    if (File.empty() == true || Pkg.end() == true)
  47       return _error->Error("Internal Error, No file name for %s",Pkg.Name());
  48
  49    List.push_back(Item(Item::Install,Pkg,File));
  50    return true;
  51 }
  52                                                                         /*}}}*/
  53 // DPkgPM::Configure - Configure a package                              /*{{{*/
  54 // ---------------------------------------------------------------------
  55 /* Add a configure operation to the sequence list */
  56 bool pkgDPkgPM::Configure(PkgIterator Pkg)
  57 {
  58    if (Pkg.end() == true)
  59       return false;
  60
  61    List.push_back(Item(Item::Configure,Pkg));
  62    return true;
  63 }
  64                                                                         /*}}}*/
  65 // DPkgPM::Remove - Remove a package                                    /*{{{*/
  66 // ---------------------------------------------------------------------
  67 /* Add a remove operation to the sequence list */
  68 bool pkgDPkgPM::Remove(PkgIterator Pkg)
  69 {
  70    if (Pkg.end() == true)
  71       return false;
  72
  73    List.push_back(Item(Item::Remove,Pkg));
  74    return true;
  75 }
  76                                                                         /*}}}*/
  77 // DPkgPM::RunScripts - Run a set of scripts                            /*{{{*/
  78 // ---------------------------------------------------------------------
  79 /* This looks for a list of script sto run from the configuration file,
  80    each one is run with system from a forked child. */
  81 bool pkgDPkgPM::RunScripts(const char *Cnf)
  82 {
  83    Configuration::Item const *Opts = _config->Tree(Cnf);
  84    if (Opts == 0 || Opts->Child == 0)
  85       return true;
  86    Opts = Opts->Child;
  87
  88    // Fork for running the system calls
  89    pid_t Child = fork();
  90    if (Child < 0)
  91       return _error->Errno("fork","Could't fork");
  92
  93    // This is the child
  94    if (Child == 0)
  95    {
  96       signal(SIGPIPE,SIG_DFL);
  97       signal(SIGQUIT,SIG_DFL);
  98       signal(SIGINT,SIG_DFL);
  99       signal(SIGWINCH,SIG_DFL);
 100       signal(SIGCONT,SIG_DFL);
 101       signal(SIGTSTP,SIG_DFL);
 102
 103       if (chdir("/tmp/") != 0)
 104          _exit(100);
 105
 106       // Close all of our FDs - just in case
 107       for (int K = 3; K != 40; K++)
 108          fcntl(K,F_SETFD,FD_CLOEXEC);
 109
 110       unsigned int Count = 1;
 111       for (; Opts != 0; Opts = Opts->Next, Count++)
 112       {
 113          if (Opts->Value.empty() == true)
 114             continue;
 115
 116          if (system(Opts->Value.c_str()) != 0)
 117             _exit(100+Count);
 118       }
 119       _exit(0);
 120    }
 121
 122    // Wait for the child
 123    int Status = 0;
 124    while (waitpid(Child,&Status,0) != Child)
 125    {
 126       if (errno == EINTR)
 127          continue;
 128       return _error->Errno("waitpid","Couldn't wait for subprocess");
 129    }
 130
 131    // Restore sig int/quit
 132    signal(SIGQUIT,SIG_DFL);
 133    signal(SIGINT,SIG_DFL);
 134
 135    // Check for an error code.
 136    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
 137    {
 138       unsigned int Count = WEXITSTATUS(Status);
 139       if (Count > 100)
 140       {
 141          Count -= 100;
 142          for (; Opts != 0 && Count != 1; Opts = Opts->Next, Count--);
 143          _error->Error("Probablem executing scripts %s '%s'",Cnf,Opts->Value.c_str());
 144       }
 145
 146       return _error->Error("Sub-process returned an error code");
 147    }
 148
 149    return true;
 150 }
 151                                                                         /*}}}*/
 152 // DPkgPM::Go - Run the sequence                                        /*{{{*/
 153 // ---------------------------------------------------------------------
 154 /* This globs the operations and calls dpkg */
 155 bool pkgDPkgPM::Go()
 156 {
 157    if (RunScripts("DPkg::Pre-Invoke") == false)
 158       return false;
 159
 160    for (vector<Item>::iterator I = List.begin(); I != List.end();)
 161    {
 162       vector<Item>::iterator J = I;
 163       for (; J != List.end() && J->Op == I->Op; J++);
 164
 165       // Generate the argument list
 166       const char *Args[400];
 167       if (J - I > 350)
 168          J = I + 350;
 169
 170       unsigned int n = 0;
 171       unsigned long Size = 0;
 172       Args[n++] = _config->Find("Dir::Bin::dpkg","dpkg").c_str();
 173       Size += strlen(Args[n-1]);
 174
 175       // Stick in any custom dpkg options
 176       Configuration::Item const *Opts = _config->Tree("DPkg::Options");
 177       if (Opts != 0)
 178       {
 179          Opts = Opts->Child;
 180          for (; Opts != 0; Opts = Opts->Next)
 181          {
 182             if (Opts->Value.empty() == true)
 183                continue;
 184             Args[n++] = Opts->Value.c_str();
 185             Size += Opts->Value.length();
 186          }
 187       }
 188
 189       switch (I->Op)
 190       {
 191          case Item::Remove:
 192          Args[n++] = "--force-depends";
 193          Size += strlen(Args[n-1]);
 194          Args[n++] = "--force-remove-essential";
 195          Size += strlen(Args[n-1]);
 196          Args[n++] = "--remove";
 197          Size += strlen(Args[n-1]);
 198          break;
 199
 200          case Item::Configure:
 201          Args[n++] = "--configure";
 202          Size += strlen(Args[n-1]);
 203          break;
 204
 205          case Item::Install:
 206          Args[n++] = "--unpack";
 207          Size += strlen(Args[n-1]);
 208          break;
 209       }
 210
 211       // Write in the file or package names
 212       if (I->Op == Item::Install)
 213       {
 214          for (;I != J && Size < 1024; I++)
 215          {
 216             Args[n++] = I->File.c_str();
 217             Size += strlen(Args[n-1]);
 218          }
 219       }
 220       else
 221       {
 222          for (;I != J && Size < 1024; I++)
 223          {
 224             Args[n++] = I->Pkg.Name();
 225             Size += strlen(Args[n-1]);
 226          }
 227       }
 228       Args[n] = 0;
 229       J = I;
 230
 231       if (_config->FindB("Debug::pkgDPkgPM",false) == true)
 232       {
 233          for (unsigned int k = 0; k != n; k++)
 234             clog << Args[k] << ' ';
 235          clog << endl;
 236          continue;
 237       }
 238
 239       cout << flush;
 240       clog << flush;
 241       cerr << flush;
 242
 243       /* Mask off sig int/quit. We do this because dpkg also does when
 244          it forks scripts. What happens is that when you hit ctrl-c it sends
 245          it to all processes in the group. Since dpkg ignores the signal
 246          it doesn't die but we do! So we must also ignore it */
 247       signal(SIGQUIT,SIG_IGN);
 248       signal(SIGINT,SIG_IGN);
 249
 250       // Fork dpkg
 251       pid_t Child = fork();
 252       if (Child < 0)
 253          return _error->Errno("fork","Could't fork");
 254
 255       // This is the child
 256       if (Child == 0)
 257       {
 258          signal(SIGPIPE,SIG_DFL);
 259          signal(SIGQUIT,SIG_DFL);
 260          signal(SIGINT,SIG_DFL);
 261          signal(SIGWINCH,SIG_DFL);
 262          signal(SIGCONT,SIG_DFL);
 263          signal(SIGTSTP,SIG_DFL);
 264
 265          if (chdir(_config->FindDir("Dir::Cache::Archives").c_str()) != 0)
 266             _exit(100);
 267
 268          // Close all of our FDs - just in case
 269          for (int K = 3; K != 40; K++)
 270             fcntl(K,F_SETFD,FD_CLOEXEC);
 271
 272          int Flags,dummy;
 273          if ((Flags = fcntl(STDIN_FILENO,F_GETFL,dummy)) < 0)
 274             _exit(100);
 275
 276          // Discard everything in stdin before forking dpkg
 277          if (fcntl(STDIN_FILENO,F_SETFL,Flags | O_NONBLOCK) < 0)
 278             _exit(100);
 279
 280          while (read(STDIN_FILENO,&dummy,1) == 1);
 281
 282          if (fcntl(STDIN_FILENO,F_SETFL,Flags & (~(long)O_NONBLOCK)) < 0)
 283             _exit(100);
 284
 285          /* No Job Control Stop Env is a magic dpkg var that prevents it
 286             from using sigstop */
 287          setenv("DPKG_NO_TSTP","yes",1);
 288          execvp(Args[0],(char **)Args);
 289          cerr << "Could not exec dpkg!" << endl;
 290          _exit(100);
 291       }
 292
 293       // Wait for dpkg
 294       int Status = 0;
 295       while (waitpid(Child,&Status,0) != Child)
 296       {
 297          if (errno == EINTR)
 298             continue;
 299          RunScripts("DPkg::Post-Invoke");
 300          return _error->Errno("waitpid","Couldn't wait for subprocess");
 301       }
 302
 303       // Restore sig int/quit
 304       signal(SIGQUIT,SIG_DFL);
 305       signal(SIGINT,SIG_DFL);
 306
 307       // Check for an error code.
 308       if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
 309       {
 310          RunScripts("DPkg::Post-Invoke");
 311          return _error->Error("Sub-process returned an error code");
 312       }
 313    }
 314
 315    if (RunScripts("DPkg::Post-Invoke") == false)
 316       return false;
 317    return true;
 318 }
 319                                                                         /*}}}*/