Quelle  pty.c   Sprache: C

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

#include "pty.h"

#define NEED_CHILD_INFO_BEFORE_REAP 0

const char* progname;
static int got_sigchld = 0;
static int allocated_pty_fd = -1;
static struct tms start_tms;
static struct tms end_tms;
static clock_t start = 0;
static clock_t end;

// Local functions declarations 

#if NEED_CHILD_INFO_BEFORE_REAP
static void sigchld(int sig, siginfo_t* info, void* uap);
#endif //NEED_CHILD_INFO_BEFORE_REAP

static void sigcont(int sig);
static void modify_term(int slavefd, int echooff, int fixerase);
static void do_report(const char* fname, int status, struct rusage* rusage /*prusage_t* usage,*/ /*psinfo_t* psinfo,*/);

int main(int argc, char** argv) {
    int nopt;
    options_t params;

    // Get program name - this is used in error.c, for example
    progname = basename(argv[0]);

    // Parse options
    nopt = readopts(argc, argv, ¶ms);

    // If dumpenv was requested just do it and we are done
    if (nopt == argc && params.envfile != NULL) {
        return dumpenv(params.envfile);
    }

    pid_t pid;

    // Bootstrap env
    if (params.envfile != NULL) {
        pid_t p = fork();

        if (p < 0) {
            err_sys("fork error");
        }

        if (p == 0) {
            char** env = readenv(params.envfile);
            execve(argv[0], argv, env);
            err_sys("execve failed");
        }

        int status, w;
        w = waitpid(p, &status, WUNTRACED | WCONTINUED);

        if (w != -1 && WIFEXITED(status)) {
            exit(WEXITSTATUS(status));
        }

        exit(EXIT_FAILURE);
    }

    argv += nopt;
    argc -= nopt;
    /* now argv points to the executable */

    if (argc == 0) {
        //  -e          turned echoing off
        //  -w          wait until signaled (SIGCONT) before executing a process
        //  -p          define pts_name to use instead of opening a new one
        //  --env       passes additional environment variable to a program
        //              in NAME=VALUE form. For multiple variables multiple
        //              --env options should be used.
        //  --no-pty    do not allocate pseudo-terminal - just execute a program
        //              if --no-pty is used, -p/-w has no effect
        //  --readenv   start a new process in an environment. recorded in a
        //              specified file.
        //  --dumpenv   record current environment in a specified file
        //  --report    record process' and exit status information into 
        //              specified file

        err_quit("\n\n"
                "usage: %s [-e] [--no-pty] [-w] [-p pts_name] [--set-erase-key]\n"
                "\t\t[--readenv env_file] [[--env NAME=VALUE] ...] [--dir dir]\n"
                "\t\t[--redirect-error] [--report report_file] program [ arg ... ]\n\n"
                "\t-e\t\t turn echoing off\n"
                "\t-w\t\t wait SIGCONT after reporting PID/TTY/.. but before executing the program\n"
                "\t-p\t\t define pts_name to attach process's I/O instead of opening a new one\n"
                "\t--readenv\t read environment to start process in from a file\n"
                "\t--env\t\t pass (additional) environment variable to the process\n"
                "\t--dir\t\t change working directory for starting process\n"
                "\t--redirect-error redirect stderror to stdout for starting process (makes sense if --no-pty only)\n"
                "\t--report\t record process' and exit status information into specified file\n\n"
                "usage: %s --dumpenv env_file\n"
                "\t--dumpenv\t dump environment to a file\n"
                , progname, progname);
        exit(-1);
    }

    // Set SIGCONT handler for both parent and child
    // This is to avoid a race condition
    signal(SIGCONT, sigcont);

    if (params.redirect_error) {
        close(STDERR_FILENO);
        dup2(STDOUT_FILENO, STDERR_FILENO);
    }

    if (params.nopty == 0) {
        if (params.pty != NULL) {
            pid = pty_fork1(params.pty);
        } else {
            pid = pty_fork(&allocated_pty_fd);
        }
    } else {
        pid = fork();
        // We call setsid for a child to make it a session leader -
        // this allows us later send signals to the whole session
        // But we don't want to do this in a single case - when --no-pty is 
        // used but we do have terminal (because in this case the connection 
        // with existent terminal will be lost and it will not be a controlling 
        // terminal for the process anymore.
        if (!isatty(STDOUT_FILENO)) {
            setsid();
        }
    }

    if (pid < 0) {
        err_sys("fork error");
    }

    if (pid == 0) {
        /* child */

        /*
         * get a name of a terminal we have
         */
        if (isatty(STDOUT_FILENO)) {
            params.pty = ttyname(STDOUT_FILENO);
        }

        // MAGIC variable to be used to find all children of this process
        char magic[20];
        snprintf(magic, 20, "NBMAGIC=%ld", (long) getppid());

        printf("PID=%d\n", getpid());
        printf("TTY=%s\n", params.pty == NULL ? "null" : params.pty);
        printf("PSID=%d\n", getsid(0));
        if (params.reportfile != NULL) {
            printf("REPORT=%s.%ld\n", params.reportfile, (long) getppid());
        }
        printf("%s\n", magic);
        printf("\n"); // empty line means that we printed everything we needed
        fflush(stdout);

        modify_term(STDIN_FILENO, params.noecho, params.set_erase_key);

        // Set passed environment variables
        for (int i = 0; i < params.envnum; i++) {
            putenv(params.envvars[i]);
        }

        // The last variable we set is NBMAGIC
        putenv(magic);

        if (params.waitSignal) {
            /*
             * Waiting for a SIGCONT, blocking (queuing) all other signals.
             * (but let SIGINT to pass...)
             */
            sigset_t sigset;
            sigfillset(&sigset);
            sigdelset(&sigset, SIGCONT);
            sigdelset(&sigset, SIGINT);
            sigsuspend(&sigset);
        } else {
            // Reset SIGCONT handler to default
            signal(SIGCONT, SIG_DFL);
        }

        // Just before doing execvp - notify the parent process so that
        // it can take a start time snapshot
        // Parent doesn't explicitly wait for this signal, but guarantees that
        // it is not blocked
        kill(getppid(), SIGCONT);


        if (params.wdir != NULL) {
            if (chdir(params.wdir) == -1) {
                err_sys2(errno == ENOENT ? 127 : 1, "failed to change directory: %s", params.wdir);
            }
        }

        // setvbuf is not retained across an exec, (as buffering is a property 
        // of a FILE, not fd - so need to do un-buffering in the execd process.
        // Use LD_PRELOAD for this..
        // This is controlled by java code for now, at least

        if (execvp(argv[0], argv) < 0) {
            err_sys2(errno == ENOENT ? 127 : 1, "failed to start %s", argv[0]);
        }

    }

    /* parent */

    /*
     * We will ignore SIGINT and SIGQUIT signals generated by a terminal to
     * have a chance to get user's program exit status...
     */
    signal(SIGINT, SIG_IGN);
    signal(SIGQUIT, SIG_IGN);

    if (params.envvars != NULL) {
        free(params.envvars);
    }

#if NEED_CHILD_INFO_BEFORE_REAP
    /*
     * We want to get a statistics of the child we just forked.
     * This statistics will be collected differently on different systems, 
     * but this should be done at the very end of the process execution - 
     * (just after it is done, but before reaping it's exit status).
     * The approach is to set a signal handler for SIGCHLD and wait for it.
     * SIGCHLD is send when child has finished it's execution (!!! actually, 
     * when it changes it's state - so it is send when it goes to 
     * foreground/background or when it is stoped/continued !!!)
     * Once signal is received - will read process's /proc and will get/reap it's 
     * status with waitpid.
     */

    struct sigaction sig_action;
    sig_action.sa_sigaction = sigchld;
    sigemptyset(&sig_action.sa_mask);
    sig_action.sa_flags = SA_SIGINFO | SA_RESETHAND | SA_NODEFER | SA_NOCLDSTOP;
    sigaction(SIGCHLD, &sig_action, NULL);
#endif // NEED_CHILD_INFO_BEFORE_REAP

    /*
     * If we have a newly allocated terminal - start a loop that re-directs 
     * process's I/O to a terminal.
     */
    if (allocated_pty_fd > 0) {
        // At least on Windows, when gdb is started through this pty process
        // and calling process is killed (i.e. stdin gets broken)
        // and even when we close master_fd, gdb continues to work... 
        // ??? will kill the process (gdb) in this case...
        int loop_result = loop(allocated_pty_fd); /* copies stdin -> ptym, ptym -> stdout */

        if (loop_result != 0) {
            int attempt = 2;
            while (attempt-- >= 0 && kill(pid, 0) == 0) {
                kill(pid, SIGTERM);
                sleep(1);
            }

            if (kill(pid, 0) == 0) {
                kill(pid, SIGKILL);
            }
        }
    }

#if NEED_CHILD_INFO_BEFORE_REAP

    /*
     * There is a race here !!
     * I bet it could be that got_sigchld is 0, but signal is already send
     * ?? What is we send SIGKILL to the child (the code above)? - seems that in 
     * this case signal is sent as well...
     * 
     * Will hung on a SIGCHLD if signal was not already received only
     */
    while (!got_sigchld) {
        sigset_t sigset;
        sigfillset(&sigset);
        sigdelset(&sigset, SIGCHLD);
        // Do not block SIGCONT as this is a way for child to notify the parent 
        // about user process starting moment
        sigdelset(&sigset, SIGCONT);
        sigsuspend(&sigset);
    }

    //prusage_t usage;
    //psinfo_t psinfo;

    if (params.reportfile != NULL) {
        //        int pfd;
        //        char fname[PATH_MAX];
        //        int r = getrusage(RUSAGE_CHILDREN, &rusage);
        //        printf("r==%d\n", r);

        //        snprintf(fname, PATH_MAX, "/proc/%ld/usage", (long) pid);
        //        pfd = open(fname, O_RDONLY);
        //        read(pfd, &usage, sizeof (prusage_t));
        //        close(pfd);
        //        snprintf(fname, PATH_MAX, "/proc/%ld/psinfo", (long)pid);
        //        pfd = open(fname, O_RDONLY);
        //        read(pfd, &psinfo, sizeof (psinfo_t));
        //        close(pfd);
    }
#endif //NEED_CHILD_INFO_BEFORE_REAP

    // Reap the process once it's /proc is read...
    int status, w;
    while ((w = wait(&status)) != pid);

#if !NEED_CHILD_INFO_BEFORE_REAP 
    end = times(&end_tms);
#endif 

    struct rusage rusage;
    struct rusage* prusage = &rusage;

    if (params.reportfile) {
        if (getrusage(RUSAGE_CHILDREN, prusage) == -1) {
            prusage = NULL;
        }
    } else {
        prusage = NULL;
    }

    if (allocated_pty_fd > 0) {
        tcdrain(allocated_pty_fd);
    }

    if (w != -1) {
        if (params.reportfile != NULL) {
            int sz = strlen(params.reportfile) + 10;
            char reportfile[sz];
            snprintf(reportfile, sz, "%s.%ld", params.reportfile, (long) getpid());
            do_report(reportfile, status, prusage /*&usage, &psinfo,*/);
        }
        if (WIFEXITED(status)) {
            exit(WEXITSTATUS(status));
        }
    }

    exit(EXIT_FAILURE);
}

void do_report(const char* fname, int status, struct rusage* rusage /*prusage_t* usage, *psinfo_t* psinfo,*/) {
    int fd = open(fname, O_TRUNC | O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);

    if (fd > 0) {
        char info[100];

        sprintf(info, "RC: %d\n", WIFEXITED(status) ? WEXITSTATUS(status) : 1);
        writen(fd, info, strlen(info));
        sprintf(info, "SIG: %s\n", WIFSIGNALED(status) ? strsignal(WTERMSIG(status)) : "-");
        writen(fd, info, strlen(info));
        sprintf(info, "CORE: %d\n", WCOREDUMP(status) ? 1 : 0);
        writen(fd, info, strlen(info));

        double tps = (double) sysconf(_SC_CLK_TCK);
        sprintf(info, "RTIME: %ld\n", start == 0 ? 0 : (long) ((1000 * (end - start)) / tps));
        writen(fd, info, strlen(info));
        if (end_tms.tms_cutime > 0) {
            sprintf(info, "UTIME: %ld\n", (long) ((1000 * (end_tms.tms_cutime - start_tms.tms_cutime)) / tps));
            writen(fd, info, strlen(info));
            sprintf(info, "STIME: %ld\n", (long) ((1000 * (end_tms.tms_cstime - start_tms.tms_cstime)) / tps));
            writen(fd, info, strlen(info));
        }

        if (rusage != NULL) {
            if (end_tms.tms_cutime == 0) {
                sprintf(info, "UTIME: %ld\n", (long) (rusage->ru_utime.tv_sec + rusage->ru_utime.tv_usec / 1000000.0));
                writen(fd, info, strlen(info));
                sprintf(info, "STIME: %ld\n", (long) (rusage->ru_stime.tv_sec + rusage->ru_stime.tv_usec / 1000000.0));
                writen(fd, info, strlen(info));
            }

            sprintf(info, "MAXRSS: %ld\n", rusage->ru_maxrss);
            writen(fd, info, strlen(info));
        }

        //        if (psinfo != NULL) {
        //            sprintf(info, "RSS_KB: %lu\n", psinfo == NULL ? 0 : psinfo->pr_rssize);
        //            writen(fd, info, strlen(info));
        //        }

        close(fd);
    } else {
        warn_sys("Failed to write status to %s", fname);
    }
}

/**
 * turn echo off (for slave pty)
 * set erase to ^H
 */
static void modify_term(int fd, int echooff, int fixerase) {
    if (echooff == 0 && fixerase == 0) {
        return;
    }

    struct termios stermios;

    if (tcgetattr(fd, &stermios) < 0) {
        err_sys("tcgetattr error");
    }

    if (echooff) {
        stermios.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);

        /*
         * Also turn off NL to CR/NL mapping on output.
         */

        stermios.c_oflag &= ~(ONLCR);
    }

    if (fixerase) {
        stermios.c_cc[VERASE] = (cc_t) '\b';
    }

    if (tcsetattr(fd, TCSANOW, &stermios) < 0) {
        err_sys("tcsetattr error");
    }
}

static void sigcont(int sig) {
    start = times(&start_tms);
}

#if NEED_CHILD_INFO_BEFORE_REAP

static void sigchld(int sig, siginfo_t* info, void* uap) {
    end = times(&end_tms);
    got_sigchld = 1;
}
#endif //NEED_CHILD_INFO_BEFORE_REAP