src/orphanripper.c

   1 /*
   2  * Copyright 2006-2007 Free Software Foundation, Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17  *
  18  * Reap any leftover children possibly holding file descriptors.
  19  * Children are identified by the stale file descriptor or PGID / SID.
  20  * Both can be missed but only the stale file descriptors are important for us.
  21  * PGID / SID may be set by the children on their own.
  22  * If we fine a candidate we kill it will all its process tree (grandchildren).
  23  * The child process is run with `2>&1' redirection (due to forkpty(3)).
  24  * 2007-07-10  Jan Kratochvil  <jan.kratochvil@redhat.com>
  25  */
  26
  27 /* For getpgid(2).  */
  28 #define _GNU_SOURCE 1
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <sys/types.h>
  33 #include <sys/wait.h>
  34 #include <dirent.h>
  35 #include <unistd.h>
  36 #include <errno.h>
  37 #include <ctype.h>
  38 #include <string.h>
  39 #include <limits.h>
  40 #include <fcntl.h>
  41 #include <assert.h>
  42 #include <pty.h>
  43 #include <poll.h>
  44 #include <sys/stat.h>
  45
  46 #define LENGTH(x) (sizeof (x) / sizeof (*(x)))
  47
  48 static const char *progname;
  49
  50 static volatile int signal_chld_hit = 0;
  51
  52 static void signal_chld (int signo)
  53 {
  54   signal_chld_hit = 1;
  55 }
  56
  57 static volatile int signal_alrm_hit = 0;
  58
  59 static void signal_alrm (int signo)
  60 {
  61   signal_alrm_hit = 1;
  62 }
  63
  64 static char childptyname[LINE_MAX];
  65 static pid_t child;
  66
  67 static void print_child_error (const char *reason, char **argv)
  68 {
  69   char **sp;
  70
  71   fprintf (stderr, "%s: %d %s:", progname, (int) child, reason);
  72   for (sp = argv; *sp != NULL; sp++)
  73     {
  74       fputc (' ', stderr);
  75       fputs (*sp, stderr);
  76     }
  77   fputc ('\n', stderr);
  78 }
  79
  80 static int read_out (int amaster)
  81 {
  82   char buf[LINE_MAX];
  83   ssize_t buf_got;
  84
  85   buf_got = read (amaster, buf, sizeof buf);
  86   if (buf_got == 0)
  87     return 0;
  88   /* Weird but at least after POLLHUP we get EIO instead of just EOF.  */
  89   if (buf_got == -1 && errno == EIO)
  90     return 0;
  91   if (buf_got == -1 && errno == EAGAIN)
  92     return 0;
  93   if (buf_got < 0)
  94     {
  95       perror ("read (amaster)");
  96       exit (EXIT_FAILURE);
  97     }
  98   if (write (STDOUT_FILENO, buf, buf_got) != buf_got)
  99     {
 100       perror ("write(2)");
 101       exit (EXIT_FAILURE);
 102     }
 103   return 1;
 104 }
 105
 106 static int spawn (char **argv, int timeout)
 107 {
 108   pid_t child_got;
 109   int status, amaster, i, rc;
 110   struct sigaction act;
 111   sigset_t set;
 112   struct termios termios;
 113   unsigned alarm_orig;
 114
 115   /* We do not use signal(2) to be sure we do not have SA_RESTART.  */
 116   memset (&act, 0, sizeof (act));
 117   act.sa_handler = signal_chld;
 118   i = sigemptyset (&act.sa_mask);
 119   assert (i == 0);
 120   act.sa_flags = 0;     /* !SA_RESTART */
 121   i = sigaction (SIGCHLD, &act, NULL);
 122   assert (i == 0);
 123
 124   i = sigemptyset (&set);
 125   assert (i == 0);
 126   i = sigaddset (&set, SIGCHLD);
 127   assert (i == 0);
 128   i = sigprocmask (SIG_SETMASK, &set, NULL);
 129   assert (i == 0);
 130
 131   /* With TERMP passed as NULL we get "\n" -> "\r\n".  */
 132   termios.c_iflag = IGNBRK | IGNPAR;
 133   termios.c_oflag = 0;
 134   termios.c_cflag = CS8 | CREAD | CLOCAL | HUPCL | B9600;
 135   termios.c_lflag = IEXTEN | NOFLSH;
 136   memset (termios.c_cc, _POSIX_VDISABLE, sizeof (termios.c_cc));
 137   termios.c_cc[VTIME] = 0;
 138   termios.c_cc[VMIN ] = 1;
 139   cfmakeraw (&termios);
 140 #ifdef FLUSHO
 141   /* Workaround a readline deadlock bug in _get_tty_settings().  */
 142   termios.c_lflag &= ~FLUSHO;
 143 #endif
 144   child = forkpty (&amaster, childptyname, &termios, NULL);
 145   switch (child)
 146     {
 147       case -1:
 148         perror ("forkpty(3)");
 149         exit (EXIT_FAILURE);
 150       case 0:
 151         /* Do not replace STDIN as inferiors query its termios.  */
 152 #if 0
 153         i = close (STDIN_FILENO);
 154         assert (i == 0);
 155         i = open ("/dev/null", O_RDONLY);
 156         assert (i == STDIN_FILENO);
 157 #endif
 158
 159         /* Do not setpgrp(2) in the parent process as the process-group
 160            is shared for the whole sh(1) pipeline we could be a part
 161            of.  The process-group is set according to PID of the first
 162            command in the pipeline.
 163            We would rip even vi(1) in the case of:
 164                 ./orphanripper sh -c 'sleep 1&' | vi -
 165            */
 166         /* Do not setpgrp(2) as our pty would not be ours and we would
 167            get `SIGSTOP' later, particularly after spawning gdb(1).
 168            setsid(3) was already executed by forkpty(3) and it would fail if
 169            executed again.  */
 170         if (getpid() != getpgrp ())
 171           {
 172             perror ("getpgrp(2)");
 173             exit (EXIT_FAILURE);
 174           }
 175         execvp (argv[0], argv);
 176         perror ("execvp(2)");
 177         exit (EXIT_FAILURE);
 178       default:
 179         break;
 180     }
 181   i = fcntl (amaster, F_SETFL, O_RDWR | O_NONBLOCK);
 182   if (i != 0)
 183     {
 184       perror ("fcntl (amaster, F_SETFL, O_NONBLOCK)");
 185       exit (EXIT_FAILURE);
 186     }
 187
 188   /* We do not use signal(2) to be sure we do not have SA_RESTART.  */
 189   act.sa_handler = signal_alrm;
 190   i = sigaction (SIGALRM, &act, NULL);
 191   assert (i == 0);
 192
 193   alarm_orig = alarm (timeout);
 194   assert (alarm_orig == 0);
 195
 196   i = sigemptyset (&set);
 197   assert (i == 0);
 198
 199   while (!signal_alrm_hit)
 200     {
 201       struct pollfd pollfd;
 202
 203       pollfd.fd = amaster;
 204       pollfd.events = POLLIN;
 205       i = ppoll (&pollfd, 1, NULL, &set);
 206       if (i == -1 && errno == EINTR && signal_chld_hit)
 207         break;
 208       assert (i == 1);
 209       /* Data available?  Process it first.  */
 210       if (pollfd.revents & POLLIN)
 211         {
 212           if (!read_out (amaster))
 213             {
 214               fprintf (stderr, "%s: Unexpected EOF\n", progname);
 215               exit (EXIT_FAILURE);
 216             }
 217         }
 218       if (pollfd.revents & POLLHUP)
 219         break;
 220       if ((pollfd.revents &= ~POLLIN) != 0)
 221         {
 222           fprintf (stderr, "%s: ppoll(2): revents 0x%x\n", progname,
 223                    (unsigned) pollfd.revents);
 224           exit (EXIT_FAILURE);
 225         }
 226       /* Child exited?  */
 227       if (signal_chld_hit)
 228         break;
 229     }
 230
 231   if (signal_alrm_hit)
 232     {
 233       i = kill (child, SIGKILL);
 234       assert (i == 0);
 235     }
 236   else
 237     alarm (0);
 238
 239   /* WNOHANG still could fail.  */
 240   child_got = waitpid (child, &status, 0);
 241   if (child != child_got)
 242     {
 243       fprintf (stderr, "waitpid (%d) = %d: %m\n", (int) child, (int) child_got);
 244       exit (EXIT_FAILURE);
 245     }
 246   if (signal_alrm_hit)
 247     {
 248       char *buf;
 249
 250       if (asprintf (&buf, "Timed out after %d seconds", timeout) != -1)
 251         {
 252           print_child_error (buf, argv);
 253           free (buf);
 254         }
 255       rc = 128 + SIGALRM;
 256     }
 257   else if (WIFEXITED (status))
 258     rc = WEXITSTATUS (status);
 259   else if (WIFSIGNALED (status))
 260     {
 261       print_child_error (strsignal (WTERMSIG (status)), argv);
 262       rc = 128 + WTERMSIG (status);
 263     }
 264   else if (WIFSTOPPED (status))
 265     {
 266       fprintf (stderr, "waitpid (%d): WIFSTOPPED - WSTOPSIG is %d\n",
 267                (int) child, WSTOPSIG (status));
 268       exit (EXIT_FAILURE);
 269     }
 270   else
 271     {
 272       fprintf (stderr, "waitpid (%d): !WIFEXITED (%d)\n", (int) child, status);
 273       exit (EXIT_FAILURE);
 274     }
 275
 276   /* In the POLLHUP case we may not have seen SIGCHLD so far.  */
 277   i = sigprocmask (SIG_SETMASK, &set, NULL);
 278   assert (i == 0);
 279
 280   assert (signal_chld_hit != 0);
 281
 282   /* Do not unset O_NONBLOCK as a stale child (the whole purpose of this
 283      program) having open its output pty would block us in read_out.  */
 284 #if 0
 285   i = fcntl (amaster, F_SETFL, O_RDONLY /* !O_NONBLOCK */);
 286   if (i != 0)
 287     {
 288       perror ("fcntl (amaster, F_SETFL, O_RDONLY /* !O_NONBLOCK */)");
 289       exit (EXIT_FAILURE);
 290     }
 291 #endif
 292
 293   while (read_out (amaster));
 294
 295   /* Do not close the master FD as the child would have `/dev/pts/23 (deleted)'
 296      entries which are not expected (and expecting ` (deleted)' would be
 297      a race.  */
 298 #if 0
 299   i = close (amaster);
 300   if (i != 0)
 301     {
 302       perror ("close (forkpty ()'s amaster)");
 303       exit (EXIT_FAILURE);
 304     }
 305 #endif
 306
 307   return rc;
 308 }
 309
 310 /* Detected commandline may look weird due to a race:
 311    Original command:
 312         ./orphanripper sh -c 'sleep 1&' &
 313    Correct output:
 314         [1] 29610
 315         ./orphanripper: Killed -9 orphan PID 29612 (PGID 29611): sleep 1
 316    Raced output (sh(1) child still did not update its argv[]):
 317         [1] 29613
 318         ./orphanripper: Killed -9 orphan PID 29615 (PGID 29614): sh -c sleep 1&
 319    We could delay a bit before ripping the children.  */
 320 static const char *read_cmdline (pid_t pid)
 321 {
 322   char cmdline_fname[32];
 323   static char cmdline[LINE_MAX];
 324   int fd;
 325   ssize_t got;
 326   char *s;
 327
 328   if (snprintf (cmdline_fname, sizeof cmdline_fname, "/proc/%d/cmdline",
 329       (int) pid) < 0)
 330     return NULL;
 331   fd = open (cmdline_fname, O_RDONLY);
 332   if (fd == -1)
 333     {
 334       /* It may have already exited - ENOENT.  */
 335 #if 0
 336       fprintf (stderr, "%s: open (\"%s\"): %m\n", progname, cmdline_fname);
 337 #endif
 338       return NULL;
 339     }
 340   got = read (fd, cmdline, sizeof (cmdline) - 1);
 341   if (got == -1)
 342     fprintf (stderr, "%s: read (\"%s\"): %m\n", progname,
 343        cmdline_fname);
 344   if (close (fd) != 0)
 345     fprintf (stderr, "%s: close (\"%s\"): %m\n", progname,
 346        cmdline_fname);
 347   if (got < 0)
 348     return NULL;
 349   /* Convert '\0' argument delimiters to spaces.  */
 350   for (s = cmdline; s < cmdline + got; s++)
 351     if (!*s)
 352       *s = ' ';
 353   /* Trim the trailing spaces (typically single '\0'->' ').  */
 354   while (s > cmdline && isspace (s[-1]))
 355     s--;
 356   *s = 0;
 357   return cmdline;
 358 }
 359
 360 static int dir_scan (const char *dirname,
 361                   int (*callback) (struct dirent *dirent, const char *pathname))
 362 {
 363   DIR *dir;
 364   struct dirent *dirent;
 365   int rc = 0;
 366
 367   dir = opendir (dirname);
 368   if (dir == NULL)
 369     {
 370       if (errno == EACCES || errno == ENOENT)
 371         return rc;
 372       fprintf (stderr, "%s: opendir (\"%s\"): %m\n", progname, dirname);
 373       exit (EXIT_FAILURE);
 374     }
 375   while ((errno = 0, dirent = readdir (dir)))
 376     {
 377       char pathname[LINE_MAX];
 378       int pathname_len;
 379
 380       pathname_len = snprintf (pathname, sizeof pathname, "%s/%s",
 381                                  dirname, dirent->d_name);
 382       if (pathname_len <= 0 || pathname_len >= (int) sizeof pathname)
 383         {
 384           fprintf (stderr, "entry file name too long: `%s' / `%s'\n",
 385                    dirname, dirent->d_name);
 386           continue;
 387         }
 388       /* RHEL-4.5 on s390x never fills in D_TYPE.  */
 389       if (dirent->d_type == DT_UNKNOWN)
 390         {
 391           struct stat statbuf;
 392           int i;
 393
 394           /* We are not interested in the /proc/PID/fd/ links targets.  */
 395           i = lstat (pathname, &statbuf);
 396           if (i == -1)
 397             {
 398               if (errno == EACCES || errno == ENOENT)
 399                 continue;
 400               fprintf (stderr, "%s: stat (\"%s\"): %m\n", progname, pathname);
 401               exit (EXIT_FAILURE);
 402             }
 403           if (S_ISDIR (statbuf.st_mode))
 404             dirent->d_type = DT_DIR;
 405           if (S_ISLNK (statbuf.st_mode))
 406             dirent->d_type = DT_LNK;
 407           /* No other D_TYPE types used in this code.  */
 408         }
 409       rc = (*callback) (dirent, pathname);
 410       if (rc != 0)
 411         {
 412           errno = 0;
 413           break;
 414         }
 415     }
 416   if (errno != 0)
 417     {
 418       fprintf (stderr, "%s: readdir (\"%s\"): %m\n", progname, dirname);
 419       exit (EXIT_FAILURE);
 420     }
 421   if (closedir (dir) != 0)
 422     {
 423       fprintf (stderr, "%s: closedir (\"%s\"): %m\n", progname, dirname);
 424       exit (EXIT_FAILURE);
 425     }
 426   return rc;
 427 }
 428
 429 static int fd_fs_scan (pid_t pid, int (*func) (pid_t pid, const char *link))
 430 {
 431   char dirname[64];
 432
 433   if (snprintf (dirname, sizeof dirname, "/proc/%d/fd", (int) pid) < 0)
 434     {
 435       perror ("snprintf(3)");
 436       exit (EXIT_FAILURE);
 437     }
 438
 439   int callback (struct dirent *dirent, const char *pathname)
 440   {
 441     char buf[LINE_MAX];
 442     ssize_t buf_len;
 443
 444     if ((dirent->d_type != DT_DIR && dirent->d_type != DT_LNK)
 445         || (dirent->d_type == DT_DIR && strcmp (dirent->d_name, ".") != 0
 446             && strcmp (dirent->d_name, "..") != 0)
 447         || (dirent->d_type == DT_LNK && strspn (dirent->d_name, "0123456789")
 448             != strlen (dirent->d_name)))
 449       {
 450         fprintf (stderr, "Unexpected entry \"%s\" (d_type %u)"
 451                          " on readdir (\"%s\"): %m\n",
 452                  dirent->d_name, (unsigned) dirent->d_type, dirname);
 453         return 0;
 454       }
 455     if (dirent->d_type == DT_DIR)
 456       return 0;
 457     buf_len = readlink (pathname, buf, sizeof buf - 1);
 458     if (buf_len <= 0 || buf_len >= (ssize_t) sizeof buf - 1)
 459       {
 460         if (errno != ENOENT && errno != EACCES)
 461           fprintf (stderr, "Error reading link \"%s\": %m\n", pathname);
 462         return 0;
 463       }
 464     buf[buf_len] = 0;
 465     return (*func) (pid, buf);
 466   }
 467
 468   return dir_scan (dirname, callback);
 469 }
 470
 471 static void pid_fs_scan (void (*func) (pid_t pid, void *data), void *data)
 472 {
 473   int callback (struct dirent *dirent, const char *pathname)
 474   {
 475     if (dirent->d_type != DT_DIR
 476         || strspn (dirent->d_name, "0123456789") != strlen (dirent->d_name))
 477       return 0;
 478     (*func) (atoi (dirent->d_name), data);
 479     return 0;
 480   }
 481
 482   dir_scan ("/proc", callback);
 483 }
 484
 485 static int rip_check_ptyname (pid_t pid, const char *link)
 486 {
 487   assert (pid != getpid ());
 488
 489   return strcmp (link, childptyname) == 0;
 490 }
 491
 492 struct pid
 493   {
 494     struct pid *next;
 495     pid_t pid;
 496   };
 497 static struct pid *pid_list;
 498
 499 static int pid_found (pid_t pid)
 500 {
 501   struct pid *entry;
 502
 503   for (entry = pid_list; entry != NULL; entry = entry->next)
 504     if (entry->pid == pid)
 505       return 1;
 506   return 0;
 507 }
 508
 509 /* Single pass is not enough, a (multithreaded) process was seen to survive.
 510    Repeated killing of the same process is not enough, zombies can be killed.
 511    */
 512 static int cleanup_acted;
 513
 514 static void pid_record (pid_t pid)
 515 {
 516   struct pid *entry;
 517
 518   if (pid_found (pid))
 519     return;
 520   cleanup_acted = 1;
 521
 522   entry = malloc (sizeof (*entry));
 523   if (entry == NULL)
 524     {
 525       fprintf (stderr, "%s: malloc: %m\n", progname);
 526       exit (EXIT_FAILURE);
 527     }
 528   entry->pid = pid;
 529   entry->next = pid_list;
 530   pid_list = entry;
 531 }
 532
 533 static void pid_forall (void (*func) (pid_t pid))
 534 {
 535   struct pid *entry;
 536
 537   for (entry = pid_list; entry != NULL; entry = entry->next)
 538     (*func) (entry->pid);
 539 }
 540
 541 /* Returns 0 on failure.  */
 542 static pid_t pid_get_parent (pid_t pid)
 543 {
 544   char fname[64];
 545   FILE *f;
 546   char line[LINE_MAX];
 547   pid_t retval = 0;
 548
 549   if (snprintf (fname, sizeof fname, "/proc/%d/status", (int) pid) < 0)
 550     {
 551       perror ("snprintf(3)");
 552       exit (EXIT_FAILURE);
 553     }
 554   f = fopen (fname, "r");
 555   if (f == NULL)
 556     {
 557       return 0;
 558     }
 559   while (errno = 0, fgets (line, sizeof line, f) == line)
 560     {
 561       if (strncmp (line, "PPid:\t", sizeof "PPid:\t" - 1) != 0)
 562         continue;
 563       retval = atoi (line + sizeof "PPid:\t" - 1);
 564       errno = 0;
 565       break;
 566     }
 567   if (errno != 0)
 568     {
 569       fprintf (stderr, "%s: fgets (\"%s\"): %m\n", progname, fname);
 570       exit (EXIT_FAILURE);
 571     }
 572   if (fclose (f) != 0)
 573     {
 574       fprintf (stderr, "%s: fclose (\"%s\"): %m\n", progname, fname);
 575       exit (EXIT_FAILURE);
 576     }
 577   return retval;
 578 }
 579
 580 static void killtree (pid_t pid);
 581
 582 static void killtree_pid_fs_scan (pid_t pid, void *data)
 583 {
 584   pid_t parent_pid = *(pid_t *) data;
 585
 586   /* Do not optimize it as we could miss some newly spawned processes.
 587      Always traverse all the leaves.  */
 588 #if 0
 589   /* Optimization.  */
 590   if (pid_found (pid))
 591     return;
 592 #endif
 593
 594   if (pid_get_parent (pid) != parent_pid)
 595     return;
 596
 597   killtree (pid);
 598 }
 599
 600 static void killtree (pid_t pid)
 601 {
 602   pid_record (pid);
 603   pid_fs_scan (killtree_pid_fs_scan, &pid);
 604 }
 605
 606 static void rip_pid_fs_scan (pid_t pid, void *data)
 607 {
 608   pid_t pgid;
 609
 610   /* Shouldn't happen.  */
 611   if (pid == getpid ())
 612     return;
 613
 614   /* Check both PGID and the stale file descriptors.  */
 615   pgid = getpgid (pid);
 616   if (pgid == child
 617       || fd_fs_scan (pid, rip_check_ptyname) != 0)
 618     killtree (pid);
 619 }
 620
 621 static void killproc (pid_t pid)
 622 {
 623   const char *cmdline;
 624
 625   cmdline = read_cmdline (pid);
 626   /* Avoid printing the message for already gone processes.  */
 627   if (kill (pid, 0) != 0 && errno == ESRCH)
 628     return;
 629   if (cmdline == NULL)
 630     cmdline = "<error>";
 631   fprintf (stderr, "%s: Killed -9 orphan PID %d: %s\n", progname, (int) pid, cmdline);
 632   if (kill (pid, SIGKILL) == 0)
 633     cleanup_acted = 1;
 634   else if (errno != ESRCH)
 635     fprintf (stderr, "%s: kill (%d, SIGKILL): %m\n", progname, (int) pid);
 636   /* RHEL-3 kernels cannot SIGKILL a `T (stopped)' process.  */
 637   kill (pid, SIGCONT);
 638   /* Do not waitpid(2) as it cannot be our direct descendant and it gets
 639      cleaned up by init(8).  */
 640 #if 0
 641   pid_t pid_got;
 642   pid_got = waitpid (pid, NULL, 0);
 643   if (pid != pid_got)
 644     {
 645       fprintf (stderr, "%s: waitpid (%d) != %d: %m\n", progname,
 646          (int) pid, (int) pid_got);
 647       return;
 648     }
 649 #endif
 650 }
 651
 652 static void rip (void)
 653 {
 654   cleanup_acted = 0;
 655   do
 656     {
 657       if (cleanup_acted)
 658         usleep (1000000 / 10);
 659       cleanup_acted = 0;
 660       pid_fs_scan (rip_pid_fs_scan, NULL);
 661       pid_forall (killproc);
 662     }
 663   while (cleanup_acted);
 664 }
 665
 666 int main (int argc, char **argv)
 667 {
 668   int timeout = 0;
 669   int rc;
 670
 671   progname = *argv++;
 672   argc--;
 673
 674   if (argc < 1 || strcmp (*argv, "-h") == 0
 675       || strcmp (*argv, "--help") == 0)
 676     {
 677       puts ("Syntax: orphanripper [-t <seconds>] <execvp(3) commandline>");
 678       exit (EXIT_FAILURE);
 679     }
 680   if ((*argv)[0] == '-' && (*argv)[1] == 't')
 681     {
 682       char *timeout_s = NULL;
 683
 684       if ((*argv)[2] == 0)
 685         timeout_s = *++argv;
 686       else if (isdigit ((*argv)[2]))
 687         timeout_s = (*argv) + 2;
 688       if (timeout_s != NULL)
 689         {
 690           long l;
 691           char *endptr;
 692
 693           argv++;
 694           l = strtol (timeout_s, &endptr, 0);
 695           timeout = l;
 696           if ((endptr != NULL && *endptr != 0) || timeout < 0 || timeout != l)
 697             {
 698               fprintf (stderr, "%s: Invalid timeout value: %s\n", progname,
 699                        timeout_s);
 700               exit (EXIT_FAILURE);
 701             }
 702         }
 703     }
 704
 705   rc = spawn (argv, timeout);
 706   rip ();
 707   return rc;
 708 }