boost::process redirect stdin, stdout, stderr

Question

I apologise for the length of code posted here. I am trying to create a class that uses boost::process to spawn a process, feed it some data on its stdin and to capture all its stdout & stderr.

The subprocess' stdin may be lengthy as might the stdout; The target machine does not have vast amounts of memory so each of these needs to be handled in chunks.

I have read endless examples of usage of boost::process, but have found nothing that answers all these questions together. I have tried combining these examples without success. I'm obviously missing something. I would be grateful for any help.

What happens is that the child process is successfully spawned but nothing happens. The parent process halt on the line marked THUS *.

The class defined:

class CommandProcessor {
public:
    explicit CommandProcessor(const std::string &executable_path, bool slow) :
        executable_path_(executable_path), slow_(slow), in_(io_service_, ::dup(STDIN_FILENO)), out_(io_service_, ::dup(STDOUT_FILENO)), err_(io_service_, ::dup(STDERR_FILENO)) {
    }

private:
    void begin_write_stdin();
    void end_write_stdin(const boost::system::error_code &ec, std::size_t bytes_transferred);
    void begin_read_stdout();
    void end_read_stdout(const boost::system::error_code &ec, std::size_t bytes_transferred);
    void begin_read_stderr();
    void end_read_stderr(const boost::system::error_code &ec, std::size_t bytes_transferred);

public:
    void execute_command(const Command& command);

private:
    boost::filesystem::path executable_path_;bool slow_;
    boost::asio::io_service io_service_;
    boost::asio::posix::stream_descriptor in_;
    boost::asio::posix::stream_descriptor out_;
    boost::asio::posix::stream_descriptor err_;
    std::string stdout_;
    std::string stderr_;
    std::string stdin_buffer_;
    std::array<char, 4096> stdout_buffer_;
    std::array<char, 4096> stderr_buffer_;
    std::vector<std::string>::const_iterator stdin_it_;
    std::vector<std::string>::const_iterator stdin_end_;
};

The code (for brevity I include only the bits giving me trouble):

void CommandProcessor::begin_write_stdin() {
    if (stdin_buffer_.size() == 0) {
        for (; stdin_it_ != stdin_end_; stdin_it_++) {
            if (stdin_buffer_.size() + stdin_it_->size() > 4096) {
                break;
            }
            stdin_buffer_ += *stdin_it_;
        }
    }
    if (stdin_buffer_.size() == 0) {
        return;
    }
    in_.async_write_some(boost::asio::buffer(stdin_buffer_),
        boost::bind(&CommandProcessor::end_write_stdin, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}

void CommandProcessor::end_write_stdin(const boost::system::error_code &ec, std::size_t bytes_transferred __attribute__((unused))) {
    if (!ec) {
        stdin_it_++;
        if (stdin_it_ != stdin_end_) {
            begin_write_stdin();
        }
    }
    in_.close();
}

void CommandProcessor::begin_read_stdout() {
    out_.async_read_some(boost::asio::buffer(stdout_buffer_),
        boost::bind(&CommandProcessor::end_read_stdout, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}

void CommandProcessor::end_read_stdout(const boost::system::error_code &ec, std::size_t bytes_transferred __attribute__((unused))) {
    if (!ec) {
        stdout_ += stdout_buffer_.data();
        begin_read_stdout();
    }
    out_.close();
}

void CommandProcessor::begin_read_stderr() {
    err_.async_read_some(boost::asio::buffer(stderr_buffer_), boost::bind(&CommandProcessor::end_read_stderr, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}

void CommandProcessor::end_read_stderr(const boost::system::error_code &ec, std::size_t bytes_transferred __attribute__((unused))) {
    if (!ec) {
        stderr_ += stderr_buffer_.data();
        begin_read_stderr();
    }
    err_.close();
}


void CommandProcessor::execute_command(const Command& command) {
    boost::process::context ctx;
    ctx.stdin_behavior = boost::process::capture_stream();
    ctx.stdout_behavior = boost::process::capture_stream();
    ctx.stderr_behavior = boost::process::capture_stream();

    stdin_it_ = command.for_stdin_.begin();
    stdin_end_ = command.for_stdin_.end();

    boost::process::child child(boost::process::launch((executable_path_ / command.executable_name_).string(), command.executable_name_ + command.arguments_, ctx));

    boost::process::pistream &child_stdout(child.get_stdout());
    **** Halts in next statement
    in_.assign(child_stdout.handle().release());
    boost::process::pistream &child_stderr(child.get_stderr());
    err_.assign(child_stderr.handle().release());
    boost::process::postream &child_stdin = child.get_stdin();
    out_.assign(child_stdin.handle().release());

    begin_read_stdout();
    begin_read_stderr();
    begin_write_stdin();

    boost::process::status child_status(child.wait());
    if (child_status.exited()) {
        if (child_status.exit_status() == 0) {
            throw ProcessorException((boost::format("Exec status %d on %s") % child_status.exit_status() % (executable_path_ / command.executable_name_).string()).str());
        }
    } else {
        throw ProcessorException((boost::format("Exec failure on %s") % (executable_path_ / command.executable_name_).string()).str());
    }
}