root/forkopen/forkopen.c

/* $Id$ */
/* $URL$ */

#define _XOPEN_SOURCE

#include "forkopen.h"

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
#include <time.h>

static int REDIRECT_STDERR = 0;
int forkopen_stderr(int truth) {
    int old = REDIRECT_STDERR;
    REDIRECT_STDERR = truth;
    return old;
}

enum {DUPREAD = 0, DUPWRITE = 1, DUPSZ = 2};

static int dodup(int filedes[DUPSZ]) {
    int d;
    if ((d = dup2(filedes[DUPWRITE], STDOUT_FILENO)) == -1) {
        perror("dup failed");
        return 0;
    }
    if (REDIRECT_STDERR)
        dup2(filedes[DUPWRITE], STDERR_FILENO);
    //fprintf(stderr, "dup worked: %d now points to %d\n", d, filedes[DUPWRITE]);
    return 1;
}

static int forkopen_gen(const char *prog, const char *arg, pid_t *ochild,
                        char *const argv[], int searchpath) {
    int filedes[DUPSZ];
    pid_t child;
    if (pipe(filedes) == -1) {
        perror("pipe");
        return -1;
    }
    child = fork();
    if (child == 0) {
        int err;
        close(filedes[DUPREAD]); //close unused read end
        if (dodup(filedes)) {
            if (argv && searchpath) {
                err = execvp(prog, argv);
            } else if (argv) {
                err = execv(prog, argv);
            } else if (searchpath) {
                err = execlp(prog, prog, arg, (char*)0);
            } else {
                err = execl(prog, prog, arg, (char*)0);
            }
            if (err < 0) {
                perror("exec? failed");
            } //else never reached.
        }
        close(filedes[DUPWRITE]);
        return -1;
    } else if (child < 0) {
        fprintf(stderr, "Critical -- couldn't fork()\n");
        close(filedes[DUPREAD]);
        close(filedes[DUPWRITE]);
        return -1;
    } else { //we are the parent
        close(filedes[DUPWRITE]); //close unused write end
        if (ochild)
            *ochild = child;
        return filedes[DUPREAD];
    }
}

int forkopen(const char *prog, const char *arg, pid_t *ochild) {
    return forkopen_gen(prog, arg, ochild, 0, 0);
}
int forkopenp(const char *prog, const char *arg, pid_t *ochild) {
    return forkopen_gen(prog, arg, ochild, 0, 1);
}
int forkopenv(const char *prog, char *const argv[], pid_t *ochild) {
    return forkopen_gen(prog, 0, ochild, argv, 0);
}
int forkopenvp(const char *prog, char *const argv[], pid_t *ochild) {
    return forkopen_gen(prog, 0, ochild, argv, 1);
}

static int fcreadfd(char* buf, size_t sz, int *ostatus,
                    int fd, pid_t *ichild) {
    int status;
    ssize_t nread;
    pid_t child = *ichild;

    if (fd < 0)
        return fd;

    nread = read(fd, buf, sz-1);

    switch (nread) {
    case -1:
        perror("read error");
        close(fd);
        /* waitpid?? */
        return -1;
    case 0:
        //perror("nothing read");
        /* fall through */
    default:
        buf[nread] = '\0';
    }

    close(fd);
    waitpid(child, &status, 0);

    if (ostatus && WIFEXITED(status))
        *ostatus = WEXITSTATUS(status);
    else if (ostatus)
        *ostatus = status;

    return nread;
}

int fork_cstr_read(char* buf, size_t sz, const char* prog, const char* arg, int *ostatus) {
    pid_t child;
    return fcreadfd(buf, sz, ostatus, forkopen(prog, arg, &child), &child);
}
int fork_cstr_readp(char* buf, size_t sz, const char* prog, const char* arg, int *ostatus) {
    pid_t child;
    return fcreadfd(buf, sz, ostatus, forkopenp(prog, arg, &child), &child);
}
int fork_cstr_readv(char* buf, size_t sz, const char* prog, char *const argv[], int *ostatus) {
    pid_t child;
    return fcreadfd(buf, sz, ostatus, forkopenv(prog, argv, &child), &child);
}
int fork_cstr_readvp(char* buf, size_t sz, const char* prog, char *const argv[], int *ostatus) {
    pid_t child;
    return fcreadfd(buf, sz, ostatus, forkopenvp(prog, argv, &child), &child);
}

#if 0

static const char* NONBLANKED = "non-blanked since ";

static int ignored_main() {
    char buf[1024];
    char *p;
    if (fork_cstr_read(buf, 1024, "/usr/bin/xscreensaver-command", "-time", 0) == -1) {
        return -1;
    }
    if ((p = strstr(buf, NONBLANKED))) {
        struct tm when;
        fprintf(stderr, p);
        if (strptime(p+strlen(NONBLANKED), "%c", &when)) {
            fprintf(stderr, "%d:%d\n", when.tm_hour, when.tm_min);
        }
    } else {
        /* ... */
    }
    return 0;
}
#endif