nohup.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved	*/

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <stdio.h>
#include <stdlib.h>
#include <nl_types.h>
#include <locale.h>
#include <signal.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <libproc.h>
#include <dirent.h>
#include <ctype.h>
#include <sys/time.h>

#define	NOHUP_PERM	(S_IRUSR | S_IWUSR)

#define	NOHUP_NOEXEC	126
#define	NOHUP_ERROR	127

#ifdef XPG4
#define	OPTSTR	""
#else
#define	OPTSTR	"pFag"

static int pnohup(int, char **);

static struct ps_prochandle *g_proc;
static int g_wrfd;
static int g_rdfd;

static int g_dirty;
static volatile int g_interrupt = 0;
#endif

static int opt_p = 0;
static int opt_g = 0;
static int opt_a = 0;
static int opt_F = 0;

static char *pname;

static char nout[PATH_MAX] = "nohup.out";

static int
open_file(void)
{
	char *home;
	int fd;
	int flags = O_CREAT | O_WRONLY | O_APPEND;

	if ((fd = open(nout, flags, NOHUP_PERM)) < 0) {
		if ((home = getenv("HOME")) == NULL)
			return (-1);

		if ((snprintf(nout, sizeof (nout),
		    "%s/nohup.out", home) >= sizeof (nout)) ||
		    (fd = open(nout, flags, NOHUP_PERM)) < 0) {
			return (-1);
		}

	}

	(void) fprintf(stderr, gettext("Sending output to %s\n"), nout);

	return (fd);
}

int
main(int argc, char **argv)
{
	int fd = -1;
	int opt;
	int err;

	if ((pname = strrchr(argv[0], '/')) == NULL)
		pname = argv[0];
	else
		argv[0] = ++pname;		/* for getopt */

	(void) setlocale(LC_ALL, "");

#ifndef TEXT_DOMAIN
#define	TEXT_DOMAIN "SYS_TEST"
#endif

	(void) textdomain(TEXT_DOMAIN);

	while ((opt = getopt(argc, argv, OPTSTR)) != EOF) {
		switch (opt) {
		case 'p':
			opt_p = 1;
			break;
		case 'F':
			opt_F = 1;
			break;
		case 'a':
			opt_a = 1;
			break;
		case 'g':
			opt_g = 1;
			break;
		default:
			goto usage;
		}
	}

	argc -= optind;
	argv += optind;

	if (argc == 0)
		goto usage;			/* need at least one argument */

#ifndef XPG4
	if (opt_p && opt_g)
		goto usage;

	if (opt_p || opt_g)
		return (pnohup(argc, argv));

	if (opt_a || opt_F)
		goto usage;			/* only valid with -p or -g */
#endif

	argv[argc] = NULL;

	(void) signal(SIGHUP, SIG_IGN);		/* POSIX.2 only SIGHUP */
#ifndef XPG4
	(void) signal(SIGQUIT, SIG_IGN);	/* Solaris compatibility */
#endif

	if (isatty(STDOUT_FILENO)) {
		if ((fd = open_file()) < 0)
			goto err;

		(void) dup2(fd, STDOUT_FILENO);
	}

	if (isatty(STDERR_FILENO)) {
		if (fd < 0 && (fd = open_file()) < 0)
			goto err;

		(void) dup2(fd, STDERR_FILENO);
	}

	if (fd >= 0)
		(void) close(fd);

	(void) execvp(argv[0], argv);
	err = errno;

	(void) freopen("/dev/tty", "w", stderr);
	(void) fprintf(stderr, gettext("nohup: %s: %s\n"), argv[0],
	    strerror(err));

	return (err == ENOENT ? NOHUP_ERROR : NOHUP_NOEXEC);

err:
	(void) fprintf(stderr, gettext("nohup: cannot open/create "
	    "nohup.out: %s\n"), strerror(errno));
	return (NOHUP_ERROR);

usage:
#ifdef XPG4
	(void) fprintf(stderr,
	    gettext("usage: nohup command [argument ...]\n"));
#else
	(void) fprintf(stderr, gettext("usage:\n"
	    "\tnohup command [argument ...]\n"
	    "\tnohup -p [-Fa] pid [pid ...]\n"
	    "\tnohup -g [-Fa] pgid [pgid ...]\n"));
#endif
	return (NOHUP_ERROR);
}

#ifndef XPG4

/*
 * File descriptor iteration interface.
 */
typedef int proc_fd_iter_f(void *, int);

static int
Pfd_iter(struct ps_prochandle *P, proc_fd_iter_f *cb, void *data)
{
	char file[64];
	dirent_t *dentp;
	DIR *dirp;
	int ret = 0;

	if (Pstate(P) == PS_DEAD)
		return (-1);

	(void) sprintf(file, "/proc/%d/fd", (int)Pstatus(P)->pr_pid);
	if ((dirp = opendir(file)) == NULL)
		return (-1);

	while ((dentp = readdir(dirp)) != NULL) {
		if (dentp->d_name[0] == '.')
			continue;

		if ((ret = cb(data, atoi(dentp->d_name))) != 0)
			break;
	}

	(void) closedir(dirp);

	return (ret);
}

/*ARGSUSED*/
static int
fd_cb(void *data, int fd)
{
	struct stat64 sbuf;
	int flags;
	int *fdp;
	int oflags;
	char *file;
	int tmpfd;

	/*
	 * See if this fd refers to the controlling tty.
	 */
	if (pr_fstat64(g_proc, fd, &sbuf) == -1 ||
	    sbuf.st_rdev != Ppsinfo(g_proc)->pr_ttydev)
		return (0);

	/*
	 * tty's opened for input are usually O_RDWR so that the program
	 * can change terminal settings. We assume that if there's a
	 * controlling tty in the STDIN_FILENO file descriptor that is
	 * effectively used only for input. If standard in gets dup'ed to
	 * other file descriptors, then we're out of luck unless the
	 * program is nice enough to fcntl it to be O_RDONLY. We close the
	 * file descriptor before we call open to handle the case that
	 * there are no available file descriptors left in the victim. If
	 * our call to pr_open fails, we try to reopen the controlling tty.
	 */
	flags = pr_fcntl(g_proc, fd, F_GETFL, NULL);
	if ((flags & O_ACCMODE) == O_RDONLY || fd == STDIN_FILENO) {
		fdp = &g_rdfd;
		oflags = O_RDONLY;
		file = "/dev/null";
	} else {
		fdp = &g_wrfd;
		oflags = O_RDWR | O_APPEND;
		file = &nout[0];
	}

	if (*fdp < 0) {
		(void) pr_close(g_proc, fd);

		tmpfd = pr_open(g_proc, file, oflags, 0);

		if (tmpfd < 0) {
			(void) fprintf(stderr,
			    gettext("nohup: process %d cannot open %s: %s\n"),
			    Pstatus(g_proc)->pr_pid, file, strerror(errno));

			goto err;
		}

		if (tmpfd != fd) {
			(void) pr_fcntl(g_proc, tmpfd, F_DUP2FD,
				(void *)(uintptr_t)fd);
			(void) pr_close(g_proc, tmpfd);
		}

		*fdp = fd;
	} else {
		(void) pr_fcntl(g_proc, *fdp, F_DUP2FD, (void *)(uintptr_t)fd);
	}

	return (0);

err:
	/*
	 * The victim couldn't open nohup.out so we'll have it try to reopen
	 * its terminal. If this fails, we are left with little recourse.
	 */
	tmpfd = pr_open(g_proc, "/dev/tty", O_RDWR, 0);

	if (tmpfd != fd && tmpfd >= 0) {
		(void) pr_fcntl(g_proc, tmpfd, F_DUP2FD, (void *)(uintptr_t)fd);
		(void) pr_close(g_proc, tmpfd);
	}

	return (1);
}

static int
lwp_restartable(short syscall)
{
	switch (syscall) {
	case SYS_read:
	case SYS_readv:
	case SYS_pread:
	case SYS_pread64:
	case SYS_write:
	case SYS_writev:
	case SYS_pwrite:
	case SYS_pwrite64:
	case SYS_ioctl:
	case SYS_fcntl:
	case SYS_getmsg:
	case SYS_getpmsg:
	case SYS_putmsg:
	case SYS_putpmsg:
	case SYS_recv:
	case SYS_recvmsg:
	case SYS_recvfrom:
	case SYS_send:
	case SYS_sendmsg:
	case SYS_sendto:
		return (1);
	}

	return (0);
}

/*ARGSUSED*/
static int
lwp_abort(void *data, const lwpstatus_t *lsp)
{
	struct ps_lwphandle *L;
	int err;

	/*
	 * Continue if this lwp isn't asleep in a restartable syscall.
	 */
	if (!(lsp->pr_flags & PR_ASLEEP) || !lwp_restartable(lsp->pr_syscall))
		return (0);

	L = Lgrab(g_proc, lsp->pr_lwpid, &err);
	(void) Lsetrun(L, 0, PRSABORT);
	Lfree(L);

	/*
	 * Indicate that we have aborted a syscall.
	 */
	g_dirty = 1;

	return (0);
}

/*ARGSUSED*/
static int
lwp_restart(void *data, const lwpstatus_t *lsp)
{
	struct ps_lwphandle *L;
	int err;

	/*
	 * If any lwp is still sleeping in a restartable syscall, it means
	 * the lwp is wedged and we've screwed up.
	 */
	if (lsp->pr_flags & PR_ASLEEP) {
		if (!lwp_restartable(lsp->pr_syscall))
			return (0);
		(void) fprintf(stderr, gettext("nohup: LWP %d failed "
		    "to abort syscall (%d) in process %d\n"),
		    lsp->pr_lwpid, lsp->pr_syscall, Pstatus(g_proc)->pr_pid);
		return (1);
	}

	if (lsp->pr_why == PR_SYSEXIT && lsp->pr_errno == EINTR) {
		L = Lgrab(g_proc, lsp->pr_lwpid, &err);
		(void) Lputareg(L, R_R0, ERESTART);
		Lsync(L);
		Lfree(L);
	}

	return (0);
}

static int
do_pnohup(struct ps_prochandle *P)
{
	int sig = 0;
	struct sigaction sa;
	const pstatus_t *psp;

	psp = Pstatus(P);

	/*
	 * Make sure there's a pending procfs stop directive.
	 */
	(void) Pdstop(P);

	if (Pcreate_agent(P) != 0) {
		(void) fprintf(stderr, gettext("nohup: cannot control "
		    "process %d\n"), psp->pr_pid);
		goto err_no_agent;
	}

	/*
	 * Set the disposition of SIGHUP and SIGQUIT to SIG_IGN. If either
	 * signal is handled by the victim, only adjust the disposition if
	 * the -a flag is set.
	 */
	if (!opt_a && pr_sigaction(P, SIGHUP, NULL, &sa) != 0) {
		(void) fprintf(stderr, gettext("nohup: cannot read "
		    "disposition of SIGHUP for %d\n"), psp->pr_pid);
		goto no_sigs;
	}

	if (!opt_a && sa.sa_handler != SIG_DFL && sa.sa_handler != SIG_IGN) {
		(void) fprintf(stderr, gettext("nohup: SIGHUP already handled "
		    "by %d; use -a to force process to ignore\n"), psp->pr_pid);
		goto no_sigs;
	}

	if (!opt_a && pr_sigaction(P, SIGQUIT, NULL, &sa) != 0) {
		(void) fprintf(stderr, gettext("nohup: cannot read "
		    "disposition of SIGQUIT for %d\n"), psp->pr_pid);
		goto no_sigs;
	}

	if (!opt_a && sa.sa_handler != SIG_DFL && sa.sa_handler != SIG_IGN) {
		(void) fprintf(stderr, gettext("nohup: SIGQUIT already handled "
		    "by %d; use -a to force process to ignore\n"), psp->pr_pid);
		goto no_sigs;
	}

	sa.sa_handler = SIG_IGN;

	if (pr_sigaction(P, SIGHUP, &sa, NULL) != 0) {
		(void) fprintf(stderr, gettext("nohup: cannot set "
		    "disposition of SIGHUP for %d\n"), psp->pr_pid);
		goto no_sigs;
	}

	if (pr_sigaction(P, SIGQUIT, &sa, NULL) != 0) {
		(void) fprintf(stderr, gettext("nohup: cannot set "
		    "disposition of SIGQUIT for %d\n"), psp->pr_pid);
		goto no_sigs;
	}

no_sigs:
	Pdestroy_agent(P);

	/*
	 * We need to close and reassign some file descriptors, but we
	 * need to be careful about how we do it. If we send in the agent
	 * to close some fd and there's an lwp asleep in the kernel due to
	 * a syscall using that fd, then we have a problem. The normal
	 * sequence of events is the close syscall wakes up any threads
	 * that have the fd in question active (see kthread.t_activefd)
	 * and then waits for those threads to wake up and release the
	 * file descriptors (they then continue to user-land to return
	 * EBADF from the syscall). However, recall that if the agent lwp
	 * is present in a process, no other lwps can run, so if the agent
	 * lwp itself is making the call to close(2) (or something else
	 * like dup2 that involves a call to closeandsetf()) then we're in
	 * pretty bad shape. The solution is to abort and restart any lwp
	 * asleep in a syscall on the off chance that it may be using one
	 * of the file descriptors that we want to manipulate.
	 */

	/*
	 * We may need to chase some lwps out of the kernel briefly, so we
	 * send SIGCONT to the process if it was previously stopped due to
	 * a job control signal, and save the current signal to repost it
	 * when we detatch from the victim. A process that is stopped due
	 * to job control will start running as soon as we send SIGCONT
	 * since there is no procfs stop command pending; we use Pdstop to
	 * post a procfs stop request (above).
	 */
	if ((psp->pr_lwp.pr_flags & PR_STOPPED) &&
	    psp->pr_lwp.pr_why == PR_JOBCONTROL) {
		sig = psp->pr_lwp.pr_what;
		(void) kill(psp->pr_pid, SIGCONT);
		(void) Pwait(P, 0);
	}

	(void) Psysexit(P, 0, 1);

	/*
	 * Abort each syscall; set g_dirty if any lwp was asleep.
	 */
	g_dirty = 0;
	g_proc = P;
	(void) Plwp_iter(P, lwp_abort, NULL);

	if (g_dirty) {
		/*
		 * Block until each lwp that was asleep in a syscall has
		 * wandered back up to user-land.
		 */
		(void) Pwait(P, 0);

		/*
		 * Make sure that each lwp has successfully aborted its
		 * syscall and that the syscall gets restarted when we
		 * detach later.
		 */
		if (Plwp_iter(P, lwp_restart, NULL) != 0)
			goto err_no_agent;
	}

	(void) Psysexit(P, 0, 0);

	if (Pcreate_agent(P) != 0) {
		(void) fprintf(stderr, gettext("nohup: cannot control "
		    "process %d\n"), psp->pr_pid);
		goto err_no_agent;
	}

	/*
	 * See if the victim has access to the nohup.out file we created.
	 * If the user does something that would invalidate the result
	 * of this call from here until the call to pr_open, the process
	 * may be left in an inconsistent state -- we assume that the user
	 * is not intentionally trying to shoot himself in the foot.
	 */
	if (pr_access(P, nout, R_OK | W_OK) != 0) {
		(void) fprintf(stderr, gettext("nohup: process %d can not "
		    "access %s: %s\n"), psp->pr_pid, nout, strerror(errno));
		goto err_agent;
	}

	/*
	 * Redirect output to the controlling tty to nohup.out and tty
	 * input to read from /dev/null.
	 */

	g_wrfd = -1;
	g_rdfd = -1;

	(void) Pfd_iter(P, fd_cb, NULL);

	Pdestroy_agent(P);
	if (sig != 0)
		(void) kill(psp->pr_pid, sig);

	return (0);

err_agent:
	Pdestroy_agent(P);
err_no_agent:
	if (sig != 0)
		(void) kill(psp->pr_pid, sig);
	return (-1);
}

/*ARGSUSED*/
static void
intr(int sig)
{
	g_interrupt = 1;
}

static int
pnohup(int argc, char **argv)
{
	struct ps_prochandle *P;
	int i, j;
	int flag = 0;
	int gcode;
	int nh_fd = -1;
	char *fname;
	char *home;
	int nerrs = 0;

	/*
	 * Catch signals from the terminal.
	 */
	if (sigset(SIGHUP, SIG_IGN) == SIG_DFL)
		(void) sigset(SIGHUP, intr);
	if (sigset(SIGINT, SIG_IGN) == SIG_DFL)
		(void) sigset(SIGINT, intr);
	if (sigset(SIGQUIT, SIG_IGN) == SIG_DFL)
		(void) sigset(SIGQUIT, intr);
	(void) sigset(SIGPIPE, intr);
	(void) sigset(SIGTERM, intr);

	if (opt_F)
		flag |= PGRAB_FORCE;

	/*
	 * Set nout to be the full path name of nohup.out and fname to be
	 * the simplified path name:
	 * nout = /cwd/nohup.out	fname = nohup.out
	 * nout = $HOME/nohup.out	fname = $HOME/nohup.out
	 */
	if (getcwd(nout, sizeof (nout) - strlen("/nohup.out") - 1) != NULL) {
		fname = &nout[strlen(nout)];
		(void) strcpy(fname, "/nohup.out");
		fname++;

		nh_fd = open(nout, O_WRONLY | O_CREAT, NOHUP_PERM);
	}

	if (nh_fd == -1 && (home = getenv("HOME")) != NULL) {
		if (snprintf(nout, sizeof (nout),
		    "%s/nohup.out", home) < sizeof (nout)) {
			nh_fd = open(nout, O_WRONLY | O_CREAT, NOHUP_PERM);
			fname = &nout[0];
		}
	}

	if (nh_fd == -1) {
		(void) fprintf(stderr, gettext("nohup: cannot open/create "
		    "nohup.out: %s\n"), strerror(errno));

		return (NOHUP_ERROR);
	}

	if (opt_g) {
		pid_t *pgids;
		int npgids;
		int success;

		/*
		 * Make nohup its own process group leader so that we
		 * don't accidently send SIGSTOP to this process.
		 */
		(void) setpgid(0, 0);

		/*
		 * If a list of process group ids is specified, we want to
		 * first SIGSTOP the whole process group so that we can be
		 * sure not to miss any processes that belong to the group
		 * (it's harder to hit a moving target). We then iterate
		 * over all the processes on the system looking for
		 * members of the given process group to apply the
		 * do_pnohup function to. If the process was stopped due
		 * to our SIGSTOP, we send the process SIGCONT; if the
		 * process was already stopped, we leave it alone.
		 */
		pgids = calloc(argc, sizeof (pid_t));
		pgids[0] = getpid();
		npgids = 1;

		for (i = 0; i < argc; i++) {
			dirent_t *dent;
			DIR *dirp;
			psinfo_t psinfo;
			const pstatus_t *psp;
			pid_t pgid;
			char *end;
			hrtime_t kill_time, stop_time;

			if (isdigit(*argv[i])) {
				pgid = strtol(argv[i], &end, 10);

				/*
				 * kill(2) with pid = 0 or -1 has a special
				 * meaning, so don't let pgid be 0 or 1.
				 */
				if (*end == '\0' && pgid > 1)
					goto pgid_ok;
			}

			(void) fprintf(stderr, gettext("nohup: "
			    "bad process group %s\n"), argv[i]);
			nerrs++;
			continue;

pgid_ok:
			/*
			 * We don't want to nohup a process group twice.
			 */
			for (j = 0; j < npgids; j++) {
				if (pgids[j] == pgid)
					break;
			}

			if (j != npgids)
				continue;

			pgids[npgids++] = pgid;

			/*
			 * Have the kernel stop all members of the process
			 * group; record the time we stopped the process
			 * group so that we can tell if a member stopped
			 * because of this call to kill(2) or if it was
			 * already stopped when we got here. If the user
			 * job control stops the victim between the call
			 * to gethrtime(2) and kill(2), we may send
			 * SIGCONT when we really shouldn't -- we assume
			 * that the user is not trying to shoot himself in
			 * the foot.
			 */
			kill_time = gethrtime();
			if (kill(-pgid, SIGSTOP) == -1) {
				(void) fprintf(stderr, gettext("nohup: cannot "
				    "stop process group %d: %s\n"), pgid,
				    errno != ESRCH ? strerror(errno) :
				    gettext("No such process group"));

				nerrs++;
				continue;
			}

			dirp = opendir("/proc");
			success = 0;
			while ((dent = readdir(dirp)) != NULL && !g_interrupt) {
				if (dent->d_name[0] == '.')
					continue;

				if (proc_arg_psinfo(dent->d_name,
				    PR_ARG_PIDS, &psinfo, &gcode) == -1)
					continue;

				if (psinfo.pr_pgid != pgid)
					continue;

				/*
				 * Ignore zombies.
				 */
				if (psinfo.pr_nlwp == 0)
					continue;

				if ((P = proc_arg_grab(dent->d_name,
				    PR_ARG_PIDS, flag, &gcode)) == NULL) {
					(void) fprintf(stderr, gettext("nohup: "
					    "cannot examine %s: %s\n"),
					    dent->d_name, Pgrab_error(gcode));

					(void) kill(psinfo.pr_pid, SIGCONT);
					continue;
				}

				/*
				 * This implicitly restarts any process that
				 * was stopped via job control any time after
				 * the call to kill(2). This is the desired
				 * behavior since nohup is busy trying to
				 * disassociate a process from its controlling
				 * terminal.
				 */
				psp = Pstatus(P);
				if (psp->pr_lwp.pr_why == PR_JOBCONTROL) {
					stop_time =
					    psp->pr_lwp.pr_tstamp.tv_sec;
					stop_time *= (hrtime_t)NANOSEC;
					stop_time +=
					    psp->pr_lwp.pr_tstamp.tv_nsec;
				} else {
					stop_time = 0;
				}

				if (do_pnohup(P) == 0)
					success = 1;

				/*
				 * If the process was stopped because of
				 * our call to kill(2) (i.e. if it stopped
				 * some time after kill_time) then restart
				 * the process.
				 */
				if (kill_time <= stop_time)
					(void) kill(psinfo.pr_pid, SIGCONT);

				Prelease(P, 0);
			}

			/*
			 * If we didn't successfully nohup any member of the
			 * process group.
			 */
			if (!success)
				nerrs++;

			(void) closedir(dirp);
		}
	} else {
		for (i = 0; i < argc && !g_interrupt; i++) {
			if ((P = proc_arg_grab(argv[i], PR_ARG_PIDS, flag,
			    &gcode)) == NULL) {
				(void) fprintf(stderr,
				    gettext("nohup: cannot examine %s: %s\n"),
				    argv[i], Pgrab_error(gcode));

				nerrs++;
				continue;
			}

			if (do_pnohup(P) != 0)
				nerrs++;

			Prelease(P, 0);
		}
	}

	(void) close(nh_fd);

	if (argc == nerrs)
		return (NOHUP_ERROR);

	(void) fprintf(stderr, gettext("Sending output to %s\n"), fname);

	return (0);
}

#endif /* !XPG4 */