ipc-util.hpp

#pragma once

#include <cstdint>
#include <string>
#include <memory>
#include <stdexcept>

// extern "C" {
// #include <i3/ipc.h>
// }

namespace i3ipc {

// extern "C" {

struct header_t {
    /* 6 = strlen(I3_IPC_MAGIC) */
    char magic[6]; 
    uint32_t size; 
    uint32_t type; 
}  __attribute__ ((packed));


class ipc_error : public std::runtime_error { using std::runtime_error::runtime_error; };

class invalid_header_error : public ipc_error { using ipc_error::ipc_error; };

class eof_error : public ipc_error { using ipc_error::ipc_error; };

class invalid_reply_payload_error : public ipc_error { using ipc_error::ipc_error; };

class errno_error : public ipc_error {
public:
    errno_error();
    errno_error(const std::string&  msg);
};


enum class ClientMessageType : uint32_t {
    COMMAND = 0,
    GET_WORKSPACES = 1,
    SUBSCRIBE = 2,
    GET_OUTPUTS = 3,
    GET_TREE = 4,
    GET_MARKS = 5,
    GET_BAR_CONFIG = 6,
    GET_VERSION = 7,
};


enum class ReplyType : uint32_t {
    COMMAND = 0,
    WORKSPACES = 1,
    SUBSCRIBE = 2,
    OUTPUTS = 3,
    TREE = 4,
    MARKS = 5,
    BAR_CONFIG = 6,
    VERSION = 7,
};


struct buf_t {
    uint32_t  size; 
    uint8_t*  data; 

    header_t*  header;

    char*  payload;

    buf_t(uint32_t  payload_size);
    ~buf_t();

    void  realloc_payload_to_header();
};

int32_t  i3_connect(const std::string&  socket_path);

void  i3_disconnect(const int32_t  sockfd);

void   i3_send(const int32_t  sockfd, const buf_t&  buff);

std::shared_ptr<buf_t>   i3_recv(const int32_t  sockfd) throw (invalid_header_error, eof_error);

std::shared_ptr<buf_t>  i3_pack(const ClientMessageType  type, const std::string&  payload);

std::shared_ptr<buf_t>  i3_msg(const int32_t  sockfd, const ClientMessageType  type, const std::string&  payload = std::string()) throw (invalid_header_error, eof_error);

}