src/nohup.c

   1 /* nohup -- run a command immune to hangups, with output to a non-tty
   2    Copyright (C) 2003, 2004, 2005, 2007-2009 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 3 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, see <http://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Jim Meyering  */
  18
  19 #include <config.h>
  20 #include <getopt.h>
  21 #include <stdio.h>
  22 #include <sys/types.h>
  23 #include <signal.h>
  24
  25 #include "system.h"
  26
  27 #include "cloexec.h"
  28 #include "error.h"
  29 #include "filenamecat.h"
  30 #include "fd-reopen.h"
  31 #include "long-options.h"
  32 #include "quote.h"
  33 #include "unistd--.h"
  34
  35 #define PROGRAM_NAME "nohup"
  36
  37 #define AUTHORS proper_name ("Jim Meyering")
  38
  39 /* Exit statuses.  */
  40 enum
  41   {
  42     /* `nohup' itself failed.  */
  43     POSIX_NOHUP_FAILURE = 127
  44   };
  45
  46 void
  47 usage (int status)
  48 {
  49   if (status != EXIT_SUCCESS)
  50     fprintf (stderr, _("Try `%s --help' for more information.\n"),
  51              program_name);
  52   else
  53     {
  54       printf (_("\
  55 Usage: %s COMMAND [ARG]...\n\
  56   or:  %s OPTION\n\
  57 "),
  58               program_name, program_name);
  59
  60       fputs (_("\
  61 Run COMMAND, ignoring hangup signals.\n\
  62 \n\
  63 "), stdout);
  64       fputs (HELP_OPTION_DESCRIPTION, stdout);
  65       fputs (VERSION_OPTION_DESCRIPTION, stdout);
  66       printf (_("\n\
  67 If standard input is a terminal, redirect it from /dev/null.\n\
  68 If standard output is a terminal, append output to `nohup.out' if possible,\n\
  69 `$HOME/nohup.out' otherwise.\n\
  70 If standard error is a terminal, redirect it to standard output.\n\
  71 To save output to FILE, use `%s COMMAND > FILE'.\n"),
  72               program_name);
  73       printf (USAGE_BUILTIN_WARNING, PROGRAM_NAME);
  74       emit_ancillary_info ();
  75     }
  76   exit (status);
  77 }
  78
  79 int
  80 main (int argc, char **argv)
  81 {
  82   int out_fd = STDOUT_FILENO;
  83   int saved_stderr_fd = STDERR_FILENO;
  84   bool ignoring_input;
  85   bool redirecting_stdout;
  86   bool stdout_is_closed;
  87   bool redirecting_stderr;
  88   int exit_internal_failure;
  89
  90   initialize_main (&argc, &argv);
  91   set_program_name (argv[0]);
  92   setlocale (LC_ALL, "");
  93   bindtextdomain (PACKAGE, LOCALEDIR);
  94   textdomain (PACKAGE);
  95
  96   /* POSIX 2008 requires that internal failure give status 127; unlike
  97      for env, exec, nice, time, and xargs where it requires internal
  98      failure give something in the range 1-125.  For consistency with
  99      other tools, fail with EXIT_CANCELED unless POSIXLY_CORRECT.  */
 100   exit_internal_failure = (getenv ("POSIXLY_CORRECT")
 101                            ? POSIX_NOHUP_FAILURE : EXIT_CANCELED);
 102   initialize_exit_failure (exit_internal_failure);
 103   atexit (close_stdout);
 104
 105   parse_long_options (argc, argv, PROGRAM_NAME, PACKAGE_NAME, Version,
 106                       usage, AUTHORS, (char const *) NULL);
 107   if (getopt_long (argc, argv, "+", NULL, NULL) != -1)
 108     usage (exit_internal_failure);
 109
 110   if (argc <= optind)
 111     {
 112       error (0, 0, _("missing operand"));
 113       usage (exit_internal_failure);
 114     }
 115
 116   ignoring_input = isatty (STDIN_FILENO);
 117   redirecting_stdout = isatty (STDOUT_FILENO);
 118   stdout_is_closed = (!redirecting_stdout && errno == EBADF);
 119   redirecting_stderr = isatty (STDERR_FILENO);
 120
 121   /* If standard input is a tty, replace it with /dev/null if possible.
 122      Note that it is deliberately opened for *writing*,
 123      to ensure any read evokes an error.  */
 124   if (ignoring_input)
 125     {
 126       fd_reopen (STDIN_FILENO, "/dev/null", O_WRONLY, 0);
 127       if (!redirecting_stdout && !redirecting_stderr)
 128         error (0, 0, _("ignoring input"));
 129     }
 130
 131   /* If standard output is a tty, redirect it (appending) to a file.
 132      First try nohup.out, then $HOME/nohup.out.  If standard error is
 133      a tty and standard output is closed, open nohup.out or
 134      $HOME/nohup.out without redirecting anything.  */
 135   if (redirecting_stdout || (redirecting_stderr && stdout_is_closed))
 136     {
 137       char *in_home = NULL;
 138       char const *file = "nohup.out";
 139       int flags = O_CREAT | O_WRONLY | O_APPEND;
 140       mode_t mode = S_IRUSR | S_IWUSR;
 141       mode_t umask_value = umask (~mode);
 142       out_fd = (redirecting_stdout
 143                 ? fd_reopen (STDOUT_FILENO, file, flags, mode)
 144                 : open (file, flags, mode));
 145
 146       if (out_fd < 0)
 147         {
 148           int saved_errno = errno;
 149           char const *home = getenv ("HOME");
 150           if (home)
 151             {
 152               in_home = file_name_concat (home, file, NULL);
 153               out_fd = (redirecting_stdout
 154                         ? fd_reopen (STDOUT_FILENO, in_home, flags, mode)
 155                         : open (in_home, flags, mode));
 156             }
 157           if (out_fd < 0)
 158             {
 159               int saved_errno2 = errno;
 160               error (0, saved_errno, _("failed to open %s"), quote (file));
 161               if (in_home)
 162                 error (0, saved_errno2, _("failed to open %s"),
 163                        quote (in_home));
 164               exit (exit_internal_failure);
 165             }
 166           file = in_home;
 167         }
 168
 169       umask (umask_value);
 170       error (0, 0,
 171              _(ignoring_input
 172                ? N_("ignoring input and appending output to %s")
 173                : N_("appending output to %s")),
 174              quote (file));
 175       free (in_home);
 176     }
 177
 178   /* If standard error is a tty, redirect it.  */
 179   if (redirecting_stderr)
 180     {
 181       /* Save a copy of stderr before redirecting, so we can use the original
 182          if execve fails.  It's no big deal if this dup fails.  It might
 183          not change anything, and at worst, it'll lead to suppression of
 184          the post-failed-execve diagnostic.  */
 185       saved_stderr_fd = dup (STDERR_FILENO);
 186
 187       if (0 <= saved_stderr_fd
 188           && set_cloexec_flag (saved_stderr_fd, true) != 0)
 189         error (exit_internal_failure, errno,
 190                _("failed to set the copy of stderr to close on exec"));
 191
 192       if (!redirecting_stdout)
 193         error (0, 0,
 194                _(ignoring_input
 195                  ? N_("ignoring input and redirecting stderr to stdout")
 196                  : N_("redirecting stderr to stdout")));
 197
 198       if (dup2 (out_fd, STDERR_FILENO) < 0)
 199         error (exit_internal_failure, errno,
 200                _("failed to redirect standard error"));
 201
 202       if (stdout_is_closed)
 203         close (out_fd);
 204     }
 205
 206   /* error() flushes stderr, but does not check for write failure.
 207      Normally, we would catch this via our atexit() hook of
 208      close_stdout, but execvp() gets in the way.  If stderr
 209      encountered a write failure, there is no need to try calling
 210      error() again, particularly since we may have just changed the
 211      underlying fd out from under stderr.  */
 212   if (ferror (stderr))
 213     exit (exit_internal_failure);
 214
 215   signal (SIGHUP, SIG_IGN);
 216
 217   {
 218     int exit_status;
 219     int saved_errno;
 220     char **cmd = argv + optind;
 221
 222     execvp (*cmd, cmd);
 223     exit_status = (errno == ENOENT ? EXIT_ENOENT : EXIT_CANNOT_INVOKE);
 224     saved_errno = errno;
 225
 226     /* The execve failed.  Output a diagnostic to stderr only if:
 227        - stderr was initially redirected to a non-tty, or
 228        - stderr was initially directed to a tty, and we
 229          can dup2 it to point back to that same tty.
 230        In other words, output the diagnostic if possible, but only if
 231        it will go to the original stderr.  */
 232     if (dup2 (saved_stderr_fd, STDERR_FILENO) == STDERR_FILENO)
 233       error (0, saved_errno, _("failed to run command %s"), quote (*cmd));
 234
 235     exit (exit_status);
 236   }
 237 }