cmd/nohup/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 */