child_reader.h

Go to the documentation of this file.

#ifndef CHILD_READER_H
#define CHILD_READER_H

#include <sys/types.h>

#include <vector>
#include <string>

/*
 * FIXME: code review is needed:
 *  - check the getline()/get_data()/block_read() interface.
 *  the expected behavior is:
 *  caller can call getline until nothing is available from the stdout of the
 * child. in this case child stderr is acumulated in buf2 and can be read
 * through get_data(). get_data() is blocking until the child close stderr /
 * stdout (even if the child die by a signal ?). The following corner case must
 * work but I'm unsure if the code reflect this behavior: the last line of the
 * child stdout have not necessarilly a LF terminator. the child can output any
 * size of data in stderr.
 */
class child_reader {
public:
    child_reader(std::string const & cmd,
        std::vector<std::string> const & args);

    ~child_reader();

    bool getline(std::string & result);

    bool get_data(std::ostream & out, std::ostream & err);

    int terminate_process();

    int error() const { return first_error; }

    std::string error_str() const;

private:
    // ctor helper: create the child process.
    void exec_command(std::string const & cmd,
              std::vector<std::string> const & args);
    // return false when eof condition is reached on fd1. fd2 can have
    // already input in the pipe buffer or in buf2.
    bool block_read();

    int fd1;
    int fd2;
    ssize_t pos1;
    ssize_t end1;
    ssize_t pos2;
    ssize_t end2;
    pid_t pid;
    int first_error;
    // child stderr is handled especially, we need to retain data even
    // if caller read only stdout of the child.
    char * buf2;
    ssize_t sz_buf2;
    char * buf1;
    std::string process_name;
    bool is_terminated;
    bool terminate_on_exception;
    bool forked;
};

#endif // CHILD_READER_H