Compiler Explorer

Source code

#include <iostream>
#include <csignal>
#include <sys/wait.h>
#include <unistd.h>
#include <fcntl.h>
#include <poll.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <cstring>
#include <vector>
#include <sstream>
#include <wordexp.h>

// helper for sanity
enum PIPE_ENDS {
    READ_END = 0,
    WRITE_END = 1
};

// helper for sanity
enum CHILD_PIPES_PARENT_CONTEXT {
    STDIN_WRITE = 0,
    STDOUT_READ = 1,
    STDERR_READ = 2
};

#define BUFFER_SIZE 4096

// convert a string to a char** representing our artificial argv to be consumed by execvp
char ** expand_env(const std::string& var, int flags = 0)
{
    std::vector<std::string> vars;

wordexp_t p;
    if(!wordexp(var.c_str(), &p, flags))
    {
        if(p.we_wordc)
            for(char** exp = p.we_wordv; *exp; ++exp)
                vars.push_back(exp[0]);
        wordfree(&p);
    }

char ** arr = new char*[vars.size() + 1];
    for(size_t i = 0; i < vars.size(); i++){
        arr[i] = new char[vars[i].size() + 1];
        strcpy(arr[i], vars[i].c_str());
    }
    arr[vars.size()] = (char * ) nullptr;
    return arr;
}

// this does three things:
//  - execute a dang string as a subprocess command
//  - capture child stdout/sterr to respective log files
//  - TEE child stdout/stderr to parent stdout/stderr
int execute( std::string command, std::string stdout_log_file, std::string stderr_log_file )
{
    // turn our command string into something execvp can consume
    char ** processed_command = expand_env(command );

// open file handles to the two log files we need to create for each execution
    FILE * stdout_log_fh = fopen( stdout_log_file.c_str(), "a+" );
    FILE * stderr_log_fh = fopen( stderr_log_file.c_str(), "a+" );

// create the pipes for the child process to write and read from using its stdin/stdout/stderr
    int fd_child_stdout_pipe[2];
    int fd_child_stderr_pipe[2];
    int fd_child_stdin_pipe[2];

if ( pipe(fd_child_stdout_pipe ) == -1 ) {
        perror( "child stdout pipe" );
        exit( 1 );
    }

if ( pipe( fd_child_stderr_pipe ) == -1 ) {
        perror( "child stderr pipe" );
        exit( 1 );
    }

if (pipe(fd_child_stdin_pipe ) == -1) {
        perror("child stdin pipe");
        exit(1);
    }

// using O_CLOEXEC to ensure that the child process closes the file descriptors
    if ( fcntl( fd_child_stdout_pipe[READ_END], F_SETFD, FD_CLOEXEC ) == -1 ) {
        perror("fcntl");
        exit(1);
    }

// same for stderr
    if ( fcntl( fd_child_stderr_pipe[READ_END], F_SETFD, FD_CLOEXEC ) == -1 ) {
        perror("fcntl");
        exit(1);
    }

// status result basket for the parent process to capture the child's exit status
    int status;
    pid_t pid = fork();

if ( pid == -1 ) {
        perror( "fork failure" );
        exit( 1 );
    } else if ( pid == 0 ) {
        // child process

// close the file descriptor STDOUT_FILENO if it was previously open, then (re)open it as a copy of
        // fd_child_stdout_pipe[WRITE_END]
        while ((dup2(fd_child_stdout_pipe[WRITE_END], STDOUT_FILENO) == -1) && (errno == EINTR)) {}
        // Once this has been done, fd_child_stdout_pipe[WRITE_END] can be closed
        close(fd_child_stdout_pipe[WRITE_END]);

// now do the same for stderr and stdin
        while ((dup2(fd_child_stderr_pipe[WRITE_END], STDERR_FILENO) == -1) && (errno == EINTR)) {}
        close( fd_child_stderr_pipe[WRITE_END] );

while ((dup2(fd_child_stdin_pipe[READ_END], STDIN_FILENO) == -1) && (errno == EINTR)) {}
        close( fd_child_stdin_pipe[READ_END] );

// close the write end of the stdin pipe
        close( fd_child_stdin_pipe[WRITE_END] );

// execute the dang command, print to stdout, stderr (of parent), and dump to file for each!!!!
        // (and capture exit code in parent)
        int exit_code = execvp( processed_command[0], processed_command );
        perror("failed on execvp in child");
        exit(exit_code);
    }
    else
    {
        // parent process

// The parent process has no need to access the entrance to the pipe, so fd_child_*_pipe[1|0] should be closed
        // within that process too:
        close(fd_child_stdout_pipe[WRITE_END] );
        close(fd_child_stderr_pipe[WRITE_END] );
        close(fd_child_stdin_pipe[READ_END] );

// attempt to write to stdout,stderr from child as well as to write each to file
        char buf[BUFFER_SIZE];

// begin poll() rewrite
        /*
         * int poll( struct pollfd *ufds, unsigned int nfds, int timeout );
         *
         * The first parameter, ufds, must point to an array of struct pollfd. Each element in the array specifies a
         * file descriptor that the program is interested in monitoring, and what events on that file descriptor the
         * program would like to know about.
         *
         * The next parameter, nfds, tells the kernel how many total items are in the ufds array.
         *
         * The final parameter, timeout, specifies the maximum amount of time that poll() should block waiting for an
         * event to occur. If timeout is 0, poll() will return immediately. If timeout is -1, poll() will block
         * indefinitely.
         *
         * The return value of poll() is the number of file descriptors that have events or errors associated with them.
         *
         * Building the ufds array is the most complicated part of using poll(). Each struct pollfd looks like:
         *
         * struct pollfd {
         *    int fd;         // file descriptor to poll
         *    short events;   // requested events
         *    short revents;  // returned events
         *    };
         *
         *    The fd field is the file descriptor that poll() should monitor.
         *
         *    The events field is a bit mask that specifies the types of events that the program is interested in.
         *
         *    Programs can monitor for three types of events: input readiness, output readiness, and error conditions.
         *
         *    Those are: POLLIN, POLLOUT, or PULLPRI.
         *
         *    The revents field is a bit mask that specifies the types of events that actually occurred and is populated
         *    by poll() when it returns.
         *
         *    The following are the possible values for the events and revents fields:
         *
         *    POLLIN
         *    There is data to read.
         *
         *    POLLPRI
         *    There is some exceptional condition on the file descriptor.  Possibilities include:
         *      - There is out-of-band data on a TCP socket (see tcp(7)).
         *      - A pseudoterminal master in packet mode has seen a state change on the slave (see ioctl_tty(2)).
         *      - A cgroup.events file has been modified (see cgroups(7)).
         *
         *    POLLOUT
         *    Writing is now possible, though a write larger than the available space in a socket or pipe will still
         *    block (unless O_NONBLOCK is set).
         *
         *    POLLRDHUP (since Linux 2.6.17)
         *    Stream socket peer closed connection, or shut down writing half of connection.  The _GNU_SOURCE feature
         *    test macro must be defined (before including any header files) in order to obtain this definition.
         *
         *    POLLERR
         *    Error condition (only returned in revents; ignored in events).  This bit is also set for a file descriptor
         *    referring to the write end of a pipe when the read end has been closed.
         *
         *    POLLHUP
         *    Hang up (only returned in revents; ignored in events).  Note that when reading from a channel such as a
         *    pipe or a stream socket, this event merely indicates that the peer closed its end of the channel.
         *    Subsequent reads from the channel will return 0 (end of file) only after all outstanding data in the
         *    channel has been consumed.
         *
         *    POLLNVAL
         *    Invalid request: fd not open (only returned in revents; ignored in events).
         *
         *    When compiling with _XOPEN_SOURCE defined, one also has the following, which convey no further information
         *    beyond the bits listed above:
         *
         *    POLLRDNORM
         *    Equivalent to POLLIN.
         *
         *    POLLRDBAND
         *    Priority band data can be read (generally unused on Linux).
         *
         *    POLLWRNORM
         *    Equivalent to POLLOUT.
         *
         *    POLLWRBAND
         *    Priority data may be written.
         *
         *    Linux also knows about, but does not use POLLMSG.
         *
         *    On return, poll() returns -1 if an error occurred, 0 if the timeout was reached, or the number of file
         *    descriptors that have some revents fields filled in.
         *
         */

int byte_count;
        struct pollfd pfds[ sizeof(CHILD_PIPES_PARENT_CONTEXT) -1 ];

//parent STDIN to child
        pfds[CHILD_PIPES_PARENT_CONTEXT::STDIN_WRITE].fd = fd_child_stdin_pipe[WRITE_END];
        pfds[CHILD_PIPES_PARENT_CONTEXT::STDIN_WRITE].events = POLLIN | POLLOUT;

// child STDOUT to parent
        pfds[CHILD_PIPES_PARENT_CONTEXT::STDOUT_READ].fd = fd_child_stdout_pipe[READ_END];
        pfds[CHILD_PIPES_PARENT_CONTEXT::STDOUT_READ].events = POLLIN;

// child STDERR to parent
        pfds[CHILD_PIPES_PARENT_CONTEXT::STDERR_READ].fd = fd_child_stderr_pipe[READ_END];
        pfds[CHILD_PIPES_PARENT_CONTEXT::STDERR_READ].events = POLLIN;

int poll_result;
        bool break_loop = false;

while( ! break_loop )
        {
            poll_result = poll(pfds, sizeof(pfds) / sizeof(pfds[0]), -1);
            if ( poll_result == -1 )
            {
                break_loop = false;
                break;
            }
            for (int i = 0; i < poll_result; i++) {
                if (pfds[i].revents & POLLHUP) {
                    // child process has closed the pipe
                    break_loop = true;
                    break;
                }
                if (pfds[i].revents & POLLIN) {
                    byte_count = read(pfds[i].fd, buf, BUFFER_SIZE);
                    if (byte_count == -1) {
                        perror("read");
                        exit(EXIT_FAILURE);
                    } else if (byte_count == 0) {
                        break_loop = true;
                        // end of file
                        break;
                    } else {
                        // write to stdout,stderr
                        if (i == CHILD_PIPES_PARENT_CONTEXT::STDOUT_READ) {
                            write(stdout_log_fh->_fileno, buf, byte_count);
                            write(STDOUT_FILENO, buf, byte_count);
                        } else if (i == CHILD_PIPES_PARENT_CONTEXT::STDERR_READ) {
                            write(stderr_log_fh->_fileno, buf, byte_count);
                            write(STDERR_FILENO, buf, byte_count);
                        } else if (i == CHILD_PIPES_PARENT_CONTEXT::STDIN_WRITE) {
                            // write to child stdin
                            write(fd_child_stdin_pipe[WRITE_END], buf, byte_count);
                        }
                    }
                }
            }
        }
        // wait for child to exit, capture status
        waitpid( pid, &status, 0 );

// close the log file handles
        fclose( stdout_log_fh );
        fclose( stderr_log_fh );
        return status;
    }
}

int main( int argc, char *argv[] )
{
    // execute an arbitrary command and capture its exit code, stdout/stderr to log file as well as to parent
    // stdout/stderr

// test with interactive dialogs (ncurses)
    //std::string cmd = R"(/usr/bin/dialog --title "This should be one argument" --inputbox "Enter your name:" 0 0)";

// test with non-interactive command strings
    std::string cmd = R"(/usr/bin/ls -la)";
    int x = execute( cmd, "stdout.log", "stderr.log" );

return x;
}