external/gpl2/xcvs/dist/src/run.c

   1 /* run.c --- routines for executing subprocesses.
   2
   3    This file is part of GNU CVS.
   4
   5    GNU CVS is free software; you can redistribute it and/or modify it
   6    under the terms of the GNU General Public License as published by the
   7    Free Software Foundation; either version 2, or (at your option) any
   8    later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.  */
  14
  15 #include "cvs.h"
  16
  17 #ifndef HAVE_UNISTD_H
  18 extern int execvp (char *file, char **argv);
  19 #endif
  20
  21
  22
  23 /*
  24  * To exec a program under CVS, first call run_setup() to setup initial
  25  * arguments.  The argument to run_setup will be parsed into whitespace
  26  * separated words and added to the global run_argv list.
  27  *
  28  * Then, optionally call run_add_arg() for each additional argument that you'd
  29  * like to pass to the executed program.
  30  *
  31  * Finally, call run_exec() to execute the program with the specified arguments.
  32  * The execvp() syscall will be used, so that the PATH is searched correctly.
  33  * File redirections can be performed in the call to run_exec().
  34  */
  35 static char **run_argv;
  36 static int run_argc;
  37 static size_t run_arg_allocated;
  38
  39
  40
  41 void
  42 run_arg_free_p (int argc, char **argv)
  43 {
  44     int i;
  45     for (i = 0; i < argc; i++)
  46         free (argv[i]);
  47 }
  48
  49
  50
  51 /* VARARGS */
  52 void
  53 run_setup (const char *prog)
  54 {
  55     char *run_prog;
  56     char *buf, *d, *s;
  57     size_t length;
  58     size_t doff;
  59     char inquotes;
  60     int dolastarg;
  61
  62     /* clean out any malloc'ed values from run_argv */
  63     run_arg_free_p (run_argc, run_argv);
  64     run_argc = 0;
  65
  66     run_prog = xstrdup (prog);
  67
  68     s = run_prog;
  69     d = buf = NULL;
  70     length = 0;
  71     dolastarg = 1;
  72     inquotes = '\0';
  73     doff = d - buf;
  74     expand_string(&buf, &length, doff + 1);
  75     d = buf + doff;
  76     while ((*d = *s++) != '\0')
  77     {
  78         switch (*d)
  79         {
  80             case '\\':
  81                 if (*s) *d = *s++;
  82                 d++;
  83                 break;
  84             case '"':
  85             case '\'':
  86                 if (inquotes == *d) inquotes = '\0';
  87                 else inquotes = *d;
  88                 break;
  89             case ' ':
  90             case '\t':
  91                 if (inquotes) d++;
  92                 else
  93                 {
  94                     *d = '\0';
  95                     run_add_arg (buf);
  96                     d = buf;
  97                     while (isspace(*s)) s++;
  98                     if (!*s) dolastarg = 0;
  99                 }
 100                 break;
 101             default:
 102                 d++;
 103                 break;
 104         }
 105         doff = d - buf;
 106         expand_string(&buf, &length, doff + 1);
 107         d = buf + doff;
 108     }
 109     if (dolastarg) run_add_arg (buf);
 110     /* put each word into run_argv, allocating it as we go */
 111     if (buf) free (buf);
 112     free (run_prog);
 113 }
 114
 115
 116
 117 void
 118 run_add_arg_p (int *iargc, size_t *iarg_allocated, char ***iargv,
 119                const char *s)
 120 {
 121     /* allocate more argv entries if we've run out */
 122     if (*iargc >= *iarg_allocated)
 123     {
 124         *iarg_allocated += 50;
 125         *iargv = xnrealloc (*iargv, *iarg_allocated, sizeof (char **));
 126     }
 127
 128     if (s)
 129         (*iargv)[(*iargc)++] = xstrdup (s);
 130     else
 131         (*iargv)[*iargc] = NULL;        /* not post-incremented on purpose! */
 132 }
 133
 134
 135
 136 void
 137 run_add_arg (const char *s)
 138 {
 139     run_add_arg_p (&run_argc, &run_arg_allocated, &run_argv, s);
 140 }
 141
 142
 143
 144 int
 145 run_exec (const char *stin, const char *stout, const char *sterr, int flags)
 146 {
 147     int shin, shout, sherr;
 148     int mode_out, mode_err;
 149     int status;
 150     int rc = -1;
 151     int rerrno = 0;
 152     int pid, w;
 153
 154 #ifdef POSIX_SIGNALS
 155     sigset_t sigset_mask, sigset_omask;
 156     struct sigaction act, iact, qact;
 157
 158 #else
 159 #ifdef BSD_SIGNALS
 160     int mask;
 161     struct sigvec vec, ivec, qvec;
 162
 163 #else
 164     RETSIGTYPE (*istat) (), (*qstat) ();
 165 #endif
 166 #endif
 167
 168     if (trace)
 169     {
 170         cvs_outerr (
 171 #ifdef SERVER_SUPPORT
 172                     server_active ? "S" :
 173 #endif
 174                     " ", 1);
 175         cvs_outerr (" -> system (", 0);
 176         run_print (stderr);
 177         cvs_outerr (")\n", 0);
 178     }
 179     if (noexec && (flags & RUN_REALLY) == 0)
 180         return 0;
 181
 182     /* make sure that we are null terminated, since we didn't calloc */
 183     run_add_arg (NULL);
 184
 185     /* setup default file descriptor numbers */
 186     shin = 0;
 187     shout = 1;
 188     sherr = 2;
 189
 190     /* set the file modes for stdout and stderr */
 191     mode_out = mode_err = O_WRONLY | O_CREAT;
 192     mode_out |= ((flags & RUN_STDOUT_APPEND) ? O_APPEND : O_TRUNC);
 193     mode_err |= ((flags & RUN_STDERR_APPEND) ? O_APPEND : O_TRUNC);
 194
 195     if (stin && (shin = open (stin, O_RDONLY)) == -1)
 196     {
 197         rerrno = errno;
 198         error (0, errno, "cannot open %s for reading (prog %s)",
 199                stin, run_argv[0]);
 200         goto out0;
 201     }
 202     if (stout && (shout = open (stout, mode_out, 0666)) == -1)
 203     {
 204         rerrno = errno;
 205         error (0, errno, "cannot open %s for writing (prog %s)",
 206                stout, run_argv[0]);
 207         goto out1;
 208     }
 209     if (sterr && (flags & RUN_COMBINED) == 0)
 210     {
 211         if ((sherr = open (sterr, mode_err, 0666)) == -1)
 212         {
 213             rerrno = errno;
 214             error (0, errno, "cannot open %s for writing (prog %s)",
 215                    sterr, run_argv[0]);
 216             goto out2;
 217         }
 218     }
 219
 220     /* Make sure we don't flush this twice, once in the subprocess.  */
 221     cvs_flushout();
 222     cvs_flusherr();
 223
 224     /* The output files, if any, are now created.  Do the fork and dups.
 225
 226        We use vfork not so much for a performance boost (the
 227        performance boost, if any, is modest on most modern unices),
 228        but for the sake of systems without a memory management unit,
 229        which find it difficult or impossible to implement fork at all
 230        (e.g. Amiga).  The other solution is spawn (see
 231        windows-NT/run.c).  */
 232
 233 #ifdef HAVE_VFORK
 234     pid = vfork ();
 235 #else
 236     pid = fork ();
 237 #endif
 238     if (pid == 0)
 239     {
 240 #ifdef SETXID_SUPPORT
 241         if (flags & RUN_UNSETXID) {
 242             (void) setgid (getgid ());
 243             (void) setuid (getuid ());
 244         }
 245 #endif
 246
 247         if (shin != 0)
 248         {
 249             (void) dup2 (shin, 0);
 250             (void) close (shin);
 251         }
 252         if (shout != 1)
 253         {
 254             (void) dup2 (shout, 1);
 255             (void) close (shout);
 256         }
 257         if (flags & RUN_COMBINED)
 258             (void) dup2 (1, 2);
 259         else if (sherr != 2)
 260         {
 261             (void) dup2 (sherr, 2);
 262             (void) close (sherr);
 263         }
 264
 265 #ifdef SETXID_SUPPORT
 266         /*
 267         ** This prevents a user from creating a privileged shell
 268         ** from the text editor when the SETXID_SUPPORT option is selected.
 269         */
 270         if (!strcmp (run_argv[0], Editor) && setegid (getgid ()))
 271         {
 272             error (0, errno, "cannot set egid to gid");
 273             _exit (127);
 274         }
 275 #endif
 276
 277         /* dup'ing is done.  try to run it now */
 278         (void) execvp (run_argv[0], run_argv);
 279         error (0, errno, "cannot exec %s", run_argv[0]);
 280         _exit (127);
 281     }
 282     else if (pid == -1)
 283     {
 284         rerrno = errno;
 285         goto out;
 286     }
 287
 288     /* the parent.  Ignore some signals for now */
 289 #ifdef POSIX_SIGNALS
 290     if (flags & RUN_SIGIGNORE)
 291     {
 292         act.sa_handler = SIG_IGN;
 293         (void) sigemptyset (&act.sa_mask);
 294         act.sa_flags = 0;
 295         (void) sigaction (SIGINT, &act, &iact);
 296         (void) sigaction (SIGQUIT, &act, &qact);
 297     }
 298     else
 299     {
 300         (void) sigemptyset (&sigset_mask);
 301         (void) sigaddset (&sigset_mask, SIGINT);
 302         (void) sigaddset (&sigset_mask, SIGQUIT);
 303         (void) sigprocmask (SIG_SETMASK, &sigset_mask, &sigset_omask);
 304     }
 305 #else
 306 #ifdef BSD_SIGNALS
 307     if (flags & RUN_SIGIGNORE)
 308     {
 309         memset (&vec, 0, sizeof vec);
 310         vec.sv_handler = SIG_IGN;
 311         (void) sigvec (SIGINT, &vec, &ivec);
 312         (void) sigvec (SIGQUIT, &vec, &qvec);
 313     }
 314     else
 315         mask = sigblock (sigmask (SIGINT) | sigmask (SIGQUIT));
 316 #else
 317     istat = signal (SIGINT, SIG_IGN);
 318     qstat = signal (SIGQUIT, SIG_IGN);
 319 #endif
 320 #endif
 321
 322     /* wait for our process to die and munge return status */
 323 #ifdef POSIX_SIGNALS
 324     while ((w = waitpid (pid, &status, 0)) == -1 && errno == EINTR)
 325         ;
 326 #else
 327     while ((w = wait (&status)) != pid)
 328     {
 329         if (w == -1 && errno != EINTR)
 330             break;
 331     }
 332 #endif
 333
 334     if (w == -1)
 335     {
 336         rc = -1;
 337         rerrno = errno;
 338     }
 339 #ifndef VMS /* status is return status */
 340     else if (WIFEXITED (status))
 341         rc = WEXITSTATUS (status);
 342     else if (WIFSIGNALED (status))
 343     {
 344         if (WTERMSIG (status) == SIGPIPE)
 345             error (1, 0, "broken pipe");
 346         rc = 2;
 347     }
 348     else
 349         rc = 1;
 350 #else /* VMS */
 351     rc = WEXITSTATUS (status);
 352 #endif /* VMS */
 353
 354     /* restore the signals */
 355 #ifdef POSIX_SIGNALS
 356     if (flags & RUN_SIGIGNORE)
 357     {
 358         (void) sigaction (SIGINT, &iact, NULL);
 359         (void) sigaction (SIGQUIT, &qact, NULL);
 360     }
 361     else
 362         (void) sigprocmask (SIG_SETMASK, &sigset_omask, NULL);
 363 #else
 364 #ifdef BSD_SIGNALS
 365     if (flags & RUN_SIGIGNORE)
 366     {
 367         (void) sigvec (SIGINT, &ivec, NULL);
 368         (void) sigvec (SIGQUIT, &qvec, NULL);
 369     }
 370     else
 371         (void) sigsetmask (mask);
 372 #else
 373     (void) signal (SIGINT, istat);
 374     (void) signal (SIGQUIT, qstat);
 375 #endif
 376 #endif
 377
 378     /* cleanup the open file descriptors */
 379   out:
 380     if (sterr)
 381         (void) close (sherr);
 382     else
 383         /* ensure things are received by the parent in the correct order
 384          * relative to the protocol pipe
 385          */
 386         cvs_flusherr();
 387   out2:
 388     if (stout)
 389         (void) close (shout);
 390     else
 391         /* ensure things are received by the parent in the correct order
 392          * relative to the protocol pipe
 393          */
 394         cvs_flushout();
 395   out1:
 396     if (stin)
 397         (void) close (shin);
 398
 399   out0:
 400     if (rerrno)
 401         errno = rerrno;
 402     return rc;
 403 }
 404
 405
 406
 407 void
 408 run_print (FILE *fp)
 409 {
 410     int i;
 411     void (*outfn) (const char *, size_t);
 412
 413     if (fp == stderr)
 414         outfn = cvs_outerr;
 415     else if (fp == stdout)
 416         outfn = cvs_output;
 417     else
 418     {
 419         error (1, 0, "internal error: bad argument to run_print");
 420         /* Solely to placate gcc -Wall.
 421            FIXME: it'd be better to use a function named `fatal' that
 422            is known never to return.  Then kludges wouldn't be necessary.  */
 423         outfn = NULL;
 424     }
 425
 426     for (i = 0; i < run_argc; i++)
 427     {
 428         (*outfn) ("'", 1);
 429         (*outfn) (run_argv[i], 0);
 430         (*outfn) ("'", 1);
 431         if (i != run_argc - 1)
 432             (*outfn) (" ", 1);
 433     }
 434 }
 435
 436
 437
 438 /* Return value is NULL for error, or if noexec was set.  If there was an
 439    error, return NULL and I'm not sure whether errno was set (the Red Hat
 440    Linux 4.1 popen manpage was kind of vague but discouraging; and the noexec
 441    case complicates this even aside from popen behavior).  */
 442 FILE *
 443 run_popen (const char *cmd, const char *mode)
 444 {
 445     TRACE (TRACE_FUNCTION, "run_popen (%s,%s)", cmd, mode);
 446     if (noexec)
 447         return NULL;
 448
 449     return popen (cmd, mode);
 450 }
 451
 452
 453
 454 /* Work around an OpenSSH problem: it can put its standard file
 455    descriptors into nonblocking mode, which will mess us up if we
 456    share file descriptions with it.  The simplest workaround is
 457    to create an intervening process between OpenSSH and the
 458    actual stderr.  */
 459
 460 static void
 461 work_around_openssh_glitch (void)
 462 {
 463     pid_t pid;
 464     int stderr_pipe[2];
 465     struct stat sb;
 466
 467     /* Do nothing unless stderr is a file that is affected by
 468        nonblocking mode.  */
 469     if (!(fstat (STDERR_FILENO, &sb) == 0
 470           && (S_ISFIFO (sb.st_mode) || S_ISSOCK (sb.st_mode)
 471               || S_ISCHR (sb.st_mode) || S_ISBLK (sb.st_mode))))
 472        return;
 473
 474     if (pipe (stderr_pipe) < 0)
 475        error (1, errno, "cannot create pipe");
 476     pid = fork ();
 477     if (pid < 0)
 478        error (1, errno, "cannot fork");
 479     if (pid != 0)
 480     {
 481        /* Still in child of original process.  Act like "cat -u".  */
 482        char buf[1 << 13];
 483        ssize_t inbytes;
 484        pid_t w;
 485        int status;
 486
 487        if (close (stderr_pipe[1]) < 0)
 488            error (1, errno, "cannot close pipe");
 489
 490        while ((inbytes = read (stderr_pipe[0], buf, sizeof buf)) != 0)
 491        {
 492            size_t outbytes = 0;
 493
 494            if (inbytes < 0)
 495            {
 496                if (errno == EINTR)
 497                    continue;
 498                error (1, errno, "reading from pipe");
 499            }
 500
 501            do
 502            {
 503                ssize_t w = write (STDERR_FILENO,
 504                                   buf + outbytes, inbytes - outbytes);
 505                if (w < 0)
 506                {
 507                    if (errno == EINTR)
 508                      w = 0;
 509                    if (w < 0)
 510                      _exit (1);
 511                }
 512                outbytes += w;
 513            }
 514            while (inbytes != outbytes);
 515        }
 516
 517        /* Done processing output from grandchild.  Propagate
 518           its exit status back to the parent.  */
 519        while ((w = waitpid (pid, &status, 0)) == -1 && errno == EINTR)
 520            continue;
 521        if (w < 0)
 522            error (1, errno, "waiting for child");
 523        if (!WIFEXITED (status))
 524        {
 525            if (WIFSIGNALED (status))
 526                raise (WTERMSIG (status));
 527            error (1, errno, "child did not exit cleanly");
 528        }
 529        _exit (WEXITSTATUS (status));
 530     }
 531
 532     /* Grandchild of original process.  */
 533     if (close (stderr_pipe[0]) < 0)
 534        error (1, errno, "cannot close pipe");
 535
 536     if (stderr_pipe[1] != STDERR_FILENO)
 537     {
 538        if (dup2 (stderr_pipe[1], STDERR_FILENO) < 0)
 539            error (1, errno, "cannot dup2 pipe");
 540        if (close (stderr_pipe[1]) < 0)
 541            error (1, errno, "cannot close pipe");
 542     }
 543 }
 544
 545
 546
 547 int
 548 piped_child (char *const *command, int *tofdp, int *fromfdp, bool fix_stderr)
 549 {
 550     int pid;
 551     int to_child_pipe[2];
 552     int from_child_pipe[2];
 553
 554     if (pipe (to_child_pipe) < 0)
 555         error (1, errno, "cannot create pipe");
 556     if (pipe (from_child_pipe) < 0)
 557         error (1, errno, "cannot create pipe");
 558
 559 #ifdef USE_SETMODE_BINARY
 560     setmode (to_child_pipe[0], O_BINARY);
 561     setmode (to_child_pipe[1], O_BINARY);
 562     setmode (from_child_pipe[0], O_BINARY);
 563     setmode (from_child_pipe[1], O_BINARY);
 564 #endif
 565
 566     pid = fork ();
 567     if (pid < 0)
 568         error (1, errno, "cannot fork");
 569     if (pid == 0)
 570     {
 571         if (dup2 (to_child_pipe[0], STDIN_FILENO) < 0)
 572             error (1, errno, "cannot dup2 pipe");
 573         if (close (to_child_pipe[1]) < 0)
 574             error (1, errno, "cannot close pipe");
 575         if (close (from_child_pipe[0]) < 0)
 576             error (1, errno, "cannot close pipe");
 577         if (dup2 (from_child_pipe[1], STDOUT_FILENO) < 0)
 578             error (1, errno, "cannot dup2 pipe");
 579
 580         if (fix_stderr)
 581             work_around_openssh_glitch ();
 582
 583         /* Okay to cast out const below - execvp don't return nohow.  */
 584         execvp ((char *)command[0], (char **)command);
 585         error (1, errno, "cannot exec %s", command[0]);
 586     }
 587     if (close (to_child_pipe[0]) < 0)
 588         error (1, errno, "cannot close pipe");
 589     if (close (from_child_pipe[1]) < 0)
 590         error (1, errno, "cannot close pipe");
 591
 592     *tofdp = to_child_pipe[1];
 593     *fromfdp = from_child_pipe[0];
 594     return pid;
 595 }
 596
 597
 598
 599 int
 600 run_piped (int *tofdp, int *fromfdp)
 601 {
 602     run_add_arg (NULL);
 603     return piped_child (run_argv, tofdp, fromfdp, false);
 604 }
 605
 606
 607
 608 void
 609 close_on_exec (int fd)
 610 {
 611 #ifdef F_SETFD
 612     if (fcntl (fd, F_SETFD, 1) == -1)
 613         error (1, errno, "can't set close-on-exec flag on %d", fd);
 614 #endif
 615 }