unix 管道通信接口

 1.接口声明参照python connection

 2.不好的地方：

　　2.1 权限设置没有linux 读写执行按位&那样优美，健壮

　　2.2 用特化实现重载send，recive，比较别扭。更自然一点是根据模版参数，决定是否声明send，recive。

　　　　尝试使用std::enable_if, std::integral_constant, std::is_name组合达到上面的目的，但是失败了。

　　　　期待找到类似"declare_if(static_bool) void fun() "的东西。

#ifndef DUMP_CONNECTION_PIPE_H
#define DUMP_CONNECTION_PIPE_H

#include <type_traits>
#include <unistd.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>


enum ConnPermission {
    CONN_READABLE = 1,
    CONN_WRITABLE = 2
};

template<ConnPermission permission>
class ConnectionPipe
{
private:
    //use for multi process atomic write one pipe
    #pragma pack(1)
    struct AtomicPipeData {
        static const size_t max_cap = 256;
        char data[max_cap];
        uint16_t size:14;
        uint16_t status:2; //1 is sending, 0 is end
        //uint64_t id; use for package join to msg
    };
    #pragma pack()
public:
    explicit ConnectionPipe(int fd) : fd_(fd){}
    ConnectionPipe(const ConnectionPipe&) = delete;
    ConnectionPipe& operator=(const ConnectionPipe&) = delete;
    ~ConnectionPipe() = default;

    void Close(){
        close(fd_);
    }

    int FileNo() const {
        return fd_;
    }

    //bool Poll();

    //int Recv();
    char* RecvBytes(size_t* msg_len);

    //int RecvBytesInto();
    //bool Send();
    bool SendBytes(const char* msg, size_t msg_len);
private:
    int fd_;
};

template<>
char* ConnectionPipe<CONN_READABLE>::RecvBytes(size_t* msg_len) {
    if (msg_len == nullptr) {
        return nullptr;
    }

    int nreaded = 0;
    AtomicPipeData buf = {0};
    size_t msg_cap = AtomicPipeData::max_cap * 16; //4096 one page
    char * msg = new char[msg_cap];
    size_t msg_offset = 0;
    auto resize_mgs = [&msg, &msg_cap, &msg_offset](){
        size_t recommended_cap = msg_cap * 2;
        char* new_msg = new char[recommended_cap];
        memset(new_msg, 0, recommended_cap);
        memcpy(new_msg, msg, msg_offset);
        delete[] msg;
        msg = new_msg;
        msg_cap = recommended_cap;
    };

    while (1) {
        int nread = read(fd_, (char*)&buf + nreaded, sizeof(buf) - nreaded);
        {
            if (nread == -1) {
                perror("read");
                exit(EXIT_FAILURE);
            }
            //child close write pipe
            if (nread == 0) break;
        }

        nreaded += nread;
        if (nreaded == sizeof(buf)) {
            if ((msg_offset + buf.size) > msg_cap) {
                resize_mgs();
            }

            memcpy(msg + msg_offset, buf.data, buf.size);
            msg_offset += buf.size;

            //use for ending package buf of one message
            if (buf.status == 0) {
                break;
            }

            //use for loop next step read
            nreaded = 0;
            memset(&buf, 0, sizeof(buf));
        }
    };

    *msg_len = msg_offset;
    return msg;
}

template<>
char* ConnectionPipe<CONN_WRITABLE>::RecvBytes(size_t* msg_len) {
    return nullptr;
}

template<>
bool ConnectionPipe<CONN_WRITABLE>::SendBytes(const char* msg, size_t msg_len) {
    if (msg == nullptr || msg_len == 0) {
        return false;
    }

    AtomicPipeData package;
    auto fill_package = [&package](const char * data, uint16_t len, uint16_t status) {
        memset(&package, 0, sizeof(package));
        memcpy(package.data, data, len);
        package.size = len;
        package.status = status;
    };

    const size_t packages_size = (msg_len + AtomicPipeData::max_cap - 1)/AtomicPipeData::max_cap;
    for (size_t i = 0; i < packages_size; ++i) {
        size_t offset = i * AtomicPipeData::max_cap;
        if (i != packages_size - 1) {
            fill_package(msg+offset, AtomicPipeData::max_cap, 1);
        }
        else {
            fill_package(msg+offset, msg_len - offset, 0);
        }

        if (write(fd_, &package, sizeof(package)) != sizeof(package)) {
            /* Nothing to do on error, this will be detected by the other side. */
        }
    }

    return true ;
}

template<>
bool ConnectionPipe<CONN_READABLE>::SendBytes(const char* msg, size_t msg_len) {
    return false;
}

static bool NewConnPair(ConnectionPipe<CONN_WRITABLE>** pp_sender, ConnectionPipe<CONN_READABLE>** pp_receiver) {
    int pipedes[2];
    if (pipe(pipedes) == -1) {
        close(pipedes[0]);
        close(pipedes[1]);
        return false;
    }

    *pp_receiver = new ConnectionPipe<CONN_READABLE>(pipedes[0]);
    *pp_sender   = new ConnectionPipe<CONN_WRITABLE>(pipedes[1]);


    printf("pipe buffer size = %ld
", fpathconf(pipedes[0], _PC_PIPE_BUF));
    return true;
}

#endif


int main()
{

   ConnectionPipe<CONN_WRITABLE>* p_sender   = nullptr;
   ConnectionPipe<CONN_READABLE>* p_receiver = nullptr;
   if (!NewConnPair(&p_sender, &p_receiver)) {
        exit(EXIT_FAILURE);
   }

   std::shared_ptr<ConnectionPipe<CONN_WRITABLE>> sender_ptr(p_sender);
   std::shared_ptr<ConnectionPipe<CONN_READABLE>> receiver_ptr(p_receiver);

   pid_t regionid_pid = fork();
   if (regionid_pid == -1) {
       perror("fork");
       exit(EXIT_FAILURE);
   }
   else if (regionid_pid == 0) {
       //sub process
       receiver_ptr->Close();
       sender_ptr->SendBytes("bufff", 5);
       sender_ptr->Close();
       _exit(EXIT_SUCCESS);
   }
   else {
       //parent mian process
       sender_ptr->Close();
       size_t msg_len = 0;
       char* msg = receiver_ptr->RecvBytes(&msg_len);
       receiver_ptr->Close();
       waitpid(regionid_pid, NULL, 0);
   }
    
    return 0
}