Usando los resultados de esta pregunta Lectura y escritura simultáneas al stdio del niño usando boost.process, Estoy tratando de modificar el código para que se lea un archivo, se canalice a través de gzip, la salida de gzip se canalice a través de bzip2 y, finalmente, la salida de bzip2 se escriba en un archivo.

Mi primer intento fue

/*
 * ProcessPipe.cpp
 *
 *  Created on: Apr 17, 2018
 *      Author: dbetz
 */

//#define BOOST_ASIO_ENABLE_HANDLER_TRACKING 1

#include <boost/asio.hpp>
#include <boost/asio/high_resolution_timer.hpp>
#include <boost/process.hpp>
#include <boost/process/async.hpp>
#include <iostream>
#include <fstream>
#include <functional>

namespace bp = boost::process;
using boost::system::error_code;
using namespace std::chrono_literals;

using Loop = std::function<void()>;
using Buffer = std::array<char, 500>;

int main() {
    boost::asio::io_service svc;    
    auto gzip_exit = [](int code, std::error_code ec) {
            std::cout << "gzip exited " << code << " (" << ec.message() << ")\n";
        };

    auto bzip2_exit = [](int code, std::error_code ec) {
            std::cout << "bzip2 exited " << code << " (" << ec.message() << ")\n";
        };

    bp::async_pipe file_to_gzip_pipe{svc}, gzip_to_bzip_pipe{svc}, bzip_to_file_pipe{svc};
    bp::child process_gzip("/usr/bin/gzip", "-c", bp::std_in < file_to_gzip_pipe, bp::std_out > gzip_to_bzip_pipe, svc, bp::on_exit(gzip_exit));
    bp::child process_bzip2("/usr/bin/bzip2", "-c", bp::std_in < gzip_to_bzip_pipe, bp::std_out > bzip_to_file_pipe, svc, bp::on_exit(bzip2_exit));

    std::ifstream ifs("src/ProcessPipe2.cpp");

    Buffer file_to_gzip_buffer;
    Loop file_to_gzip_loop;
    file_to_gzip_loop = [&] {
        if (!ifs.good())
        {
            error_code ec;
            file_to_gzip_pipe.close(ec);
            std::cout << "Read file, write gzip: closed stdin (" << ec.message() << ")\n";
            return;
        }

        ifs.read(file_to_gzip_buffer.data(), file_to_gzip_buffer.size());

        boost::asio::async_write(file_to_gzip_pipe, boost::asio::buffer(file_to_gzip_buffer.data(), ifs.gcount()),
            [&](error_code ec, size_t transferred) {
                std::cout << "Read file, write gzip: " << ec.message() << " sent " << transferred << " bytes\n";
                if (!ec) {
                    file_to_gzip_loop(); // continue writing
                }
            });
    };

    Buffer gzip_to_bzip_buffer;
    Loop gzip_to_bzip_loop;

    gzip_to_bzip_loop=[&] {
    gzip_to_bzip_pipe.async_read_some(boost::asio::buffer(gzip_to_bzip_buffer),
            [&](error_code ec, size_t transferred){
                // duplicate buffer
                std::cout << "Read gzip, write bzip: " << ec.message() << " got " << transferred  << " bytes\n";
                if (!ec)
                    gzip_to_bzip_loop();
                else
                    gzip_to_bzip_pipe.close();
            }
        );
    };


    std::ofstream ofs("src/ProcessPipe2.gz");

    Buffer bzip_to_file_buffer;
    Loop bzip_to_file_loop;
    bzip_to_file_loop = [&] {
    bzip_to_file_pipe.async_read_some(boost::asio::buffer(bzip_to_file_buffer),
            [&](error_code ec, size_t transferred) {
                std::cout << "Read bzip, write file: " << ec.message() << " got " << transferred << " bytes\n";
                ofs << std::string(bzip_to_file_buffer.data(),transferred);
                if (!ec)
                    bzip_to_file_loop(); // continue reading
            });
    };

    file_to_gzip_loop(); // async
    gzip_to_bzip_loop();
    bzip_to_file_loop(); // async

    svc.run(); // Await all async operations
}

pero esto da un error:

Lea gzip, escriba bzip: el descriptor de archivo incorrecto tiene 0 bytes

El problema parece ser que gzip_to_bzip_pipe está abierto para escribir con gzip y para leer con bzip. ¿Algunas ideas