irmd: Add configuration file support

This adds initial support for configuration files using the C99 TOML
parser (to be installed separately from https://github.com/cktan/tomlc99).

The default location for the IRMd configuration file is
/etc/ouroboros/irmd.conf. This is configurable at build time.
An example file will be installed in the configuration directory with
the name irmd.conf.example.

Config file support can be disabled using the DISABLE_CONFIGFILE build
option.

There were some refactors and changes to the configuration messages
and protobuf files. This works towards consolidation of protobuf C as
an option for more generic handling of serialization/deserialization
of various messages.

Signed-off-by: Dimitri Staessens <[email protected]>
Signed-off-by: Sander Vrijders <[email protected]>

10 files changed, 673 insertions, 126 deletions

diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt
index 74fbb707..1a585249 100644
--- a/src/lib/CMakeLists.txt
+++ b/src/lib/CMakeLists.txt
@@ -4,13 +4,18 @@ include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_SOURCE_DIR}/include)
 include_directories(${CMAKE_BINARY_DIR}/include)
 
-protobuf_generate_c(IRM_PROTO_SRCS IRM_PROTO_HDRS irmd_messages.proto)
-protobuf_generate_c(IPCP_PROTO_SRCS IPCP_PROTO_HDRS ipcpd_messages.proto)
 protobuf_generate_c(QOSSPEC_PROTO_SRCS QOSSPEC_PROTO_HDRS
   qosspec.proto)
-protobuf_generate_c(LAYER_CONFIG_PROTO_SRCS LAYER_CONFIG_PROTO_HDRS
+protobuf_generate_c(IPCP_CONFIG_PROTO_SRCS IPCP_CONFIG_PROTO_HDRS
   ipcp_config.proto)
-protobuf_generate_c(CACEP_PROTO_SRCS CACEP_PROTO_HDRS cacep.proto)
+protobuf_generate_c(ENROLL_PROTO_SRCS ENROLL_PROTO_HDRS
+  enroll.proto)
+protobuf_generate_c(CACEP_PROTO_SRCS CACEP_PROTO_HDRS
+  cacep.proto)
+protobuf_generate_c(IRM_PROTO_SRCS IRM_PROTO_HDRS
+  irmd_messages.proto)
+protobuf_generate_c(IPCP_PROTO_SRCS IPCP_PROTO_HDRS
+  ipcpd_messages.proto)
 
 if (NOT APPLE)
   find_library(LIBRT_LIBRARIES rt)
@@ -253,9 +258,11 @@ set(SOURCE_FILES_COMMON
   logs.c
   md5.c
   notifier.c
+  protobuf.c
   qoscube.c
   random.c
   rib.c
+  serdes-oep.c
   sha3.c
   shm_flow_set.c
   shm_rbuff.c
@@ -269,7 +276,8 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/config.h.in"
   "${CMAKE_CURRENT_BINARY_DIR}/config.h" @ONLY)
 
 add_library(ouroboros-common SHARED ${SOURCE_FILES_COMMON} ${IRM_PROTO_SRCS}
-  ${IPCP_PROTO_SRCS} ${LAYER_CONFIG_PROTO_SRCS} ${QOSSPEC_PROTO_SRCS})
+  ${IPCP_PROTO_SRCS} ${IPCP_CONFIG_PROTO_SRCS} ${QOSSPEC_PROTO_SRCS}
+  ${ENROLL_PROTO_SRCS})
 
 add_library(ouroboros-dev SHARED ${SOURCE_FILES_DEV} ${CACEP_PROTO_SRCS})
 
diff --git a/src/lib/dev.c b/src/lib/dev.c
index c46bbdd7..e84efe55 100644
--- a/src/lib/dev.c
+++ b/src/lib/dev.c
@@ -39,6 +39,7 @@
 #include <ouroboros/fccntl.h>
 #include <ouroboros/bitmap.h>
 #include <ouroboros/np1_flow.h>
+#include <ouroboros/protobuf.h>
 #include <ouroboros/pthread.h>
 #include <ouroboros/random.h>
 #include <ouroboros/shm_flow_set.h>
@@ -795,7 +796,7 @@ int flow_accept(qosspec_t *             qs,
         crypt_dh_pkp_destroy(pkp);
 
         fd = flow_init(recv_msg->flow_id, recv_msg->pid,
-                       msg_to_spec(recv_msg->qosspec), s,
+                       qos_spec_msg_to_s(recv_msg->qosspec), s,
                        recv_msg->mpl);
 
         irm_msg__free_unpacked(recv_msg, NULL);
@@ -827,7 +828,6 @@ static int __flow_alloc(const char *            dst,
                         bool join)
 {
         irm_msg_t     msg    = IRM_MSG__INIT;
-        qosspec_msg_t qs_msg = QOSSPEC_MSG__INIT;
         irm_msg_t *   recv_msg;
         int           fd;
         void *        pkp = NULL;     /* public key pair     */
@@ -846,8 +846,7 @@ static int __flow_alloc(const char *            dst,
         msg.dst     = (char *) dst;
         msg.has_pid = true;
         msg.pid     = getpid();
-        qs_msg      = spec_to_msg(qs);
-        msg.qosspec = &qs_msg;
+        msg.qosspec = qos_spec_s_to_msg(qs);
 
         if (timeo != NULL) {
                 msg.has_timeo_sec = true;
@@ -871,6 +870,8 @@ static int __flow_alloc(const char *            dst,
         }
 
         recv_msg = send_recv_irm_msg(&msg);
+        qosspec_msg__free_unpacked(msg.qosspec, NULL);
+
         if (recv_msg == NULL)
                 goto fail_send;
 
@@ -1832,7 +1833,6 @@ int ipcp_flow_req_arr(const uint8_t * dst,
 {
         irm_msg_t     msg = IRM_MSG__INIT;
         irm_msg_t *   recv_msg;
-        qosspec_msg_t qs_msg;
         int           fd;
 
         assert(dst != NULL);
@@ -1843,8 +1843,7 @@ int ipcp_flow_req_arr(const uint8_t * dst,
         msg.has_hash  = true;
         msg.hash.len  = len;
         msg.hash.data = (uint8_t *) dst;
-        qs_msg        = spec_to_msg(&qs);
-        msg.qosspec   = &qs_msg;
+        msg.qosspec   = qos_spec_s_to_msg(&qs);
         msg.has_mpl   = true;
         msg.mpl       = mpl;
         msg.has_pk    = true;
@@ -1852,6 +1851,8 @@ int ipcp_flow_req_arr(const uint8_t * dst,
         msg.pk.len    = dlen;
 
         recv_msg = send_recv_irm_msg(&msg);
+        qosspec_msg__free_unpacked(msg.qosspec, NULL);
+
         if (recv_msg == NULL)
                 return -EIRMD;
 
diff --git a/src/lib/enroll.proto b/src/lib/enroll.proto
new file mode 100644
index 00000000..34ca1847
--- /dev/null
+++ b/src/lib/enroll.proto
@@ -0,0 +1,40 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2023
+ *
+ * Enrollment protocol
+ *
+ *    Dimitri Staessens <[email protected]>
+ *    Sander Vrijders   <[email protected]>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * version 2.1 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., http://www.fsf.org/about/contact/.
+ */
+
+syntax = "proto2";
+import "ipcp_config.proto";
+
+message enroll_req_msg {
+        /* TODO authentication */
+        required uint32 magic = 1;
+}
+
+message enroll_resp_msg {
+        required int64           t_sec    = 1;
+        required int32           t_nsec   = 2;
+        required int32           response = 3;
+        optional ipcp_config_msg conf     = 4;
+}
+
+message enroll_ack_msg {
+        required int32 response = 1;
+}
diff --git a/src/lib/ipcp_config.proto b/src/lib/ipcp_config.proto
index c6481b09..1ff304f1 100644
--- a/src/lib/ipcp_config.proto
+++ b/src/lib/ipcp_config.proto
@@ -42,7 +42,7 @@ message uni_config_msg {
 
 message eth_config_msg {
         required string dev       = 1;
-        optional uint32 ethertype = 2;
+        required uint32 ethertype = 2;
 }
 
 message udp_config_msg {
@@ -53,22 +53,8 @@ message udp_config_msg {
 
 message ipcp_config_msg {
         required layer_info_msg layer_info =  1;
-        required int32 ipcp_type           =  2;
+        required uint32 ipcp_type          =  2;
         optional uni_config_msg unicast    =  3;
         optional udp_config_msg udp        =  4;
         optional eth_config_msg eth        =  5;
 }
-
-enum enroll_code {
-        ENROLL_REQ  = 1;
-        ENROLL_BOOT = 2;
-        ENROLL_DONE = 4;
-};
-
-message enroll_msg {
-        required enroll_code     code   = 1;
-        optional ipcp_config_msg conf   = 2;
-        optional int64           t_sec  = 3;
-        optional uint32          t_nsec = 4;
-        optional int32           result = 5;
-};
\ No newline at end of file
diff --git a/src/lib/ipcpd_messages.proto b/src/lib/ipcpd_messages.proto
index c9853677..05831fa0 100644
--- a/src/lib/ipcpd_messages.proto
+++ b/src/lib/ipcpd_messages.proto
@@ -1,7 +1,7 @@
 /*
  * Ouroboros - Copyright (C) 2016 - 2023
  *
- * IPCPd message
+ * Messages sent to IPCPds
  *
  *    Dimitri Staessens <[email protected]>
  *    Sander Vrijders   <[email protected]>
diff --git a/src/lib/irm.c b/src/lib/irm.c
index 2a8aa05c..75071260 100644
--- a/src/lib/irm.c
+++ b/src/lib/irm.c
@@ -31,6 +31,7 @@
 #include <ouroboros/irm.h>
 #include <ouroboros/utils.h>
 #include <ouroboros/sockets.h>
+#include <ouroboros/protobuf.h>
 
 #include <stdbool.h>
 #include <string.h>
@@ -98,15 +99,9 @@ int irm_destroy_ipcp(pid_t pid)
 int irm_bootstrap_ipcp(pid_t                      pid,
                        const struct ipcp_config * conf)
 {
-        irm_msg_t         msg            = IRM_MSG__INIT;
-        ipcp_config_msg_t cfg_msg        = IPCP_CONFIG_MSG__INIT;
-        layer_info_msg_t  layer_info_msg = LAYER_INFO_MSG__INIT;
-        dt_config_msg_t   dt_cfg_msg     = DT_CONFIG_MSG__INIT;
-        uni_config_msg_t  uni_cfg_msg    = UNI_CONFIG_MSG__INIT;
-        eth_config_msg_t  eth_cfg_msg    = ETH_CONFIG_MSG__INIT;
-        udp_config_msg_t  udp_cfg_msg    = UDP_CONFIG_MSG__INIT;
-        irm_msg_t *       recv_msg       = NULL;
-        int               ret            = -1;
+        irm_msg_t   msg = IRM_MSG__INIT;
+        irm_msg_t * recv_msg;
+        int         ret;
 
         if (pid == -1 || conf == NULL)
                 return -EINVAL;
@@ -114,48 +109,10 @@ int irm_bootstrap_ipcp(pid_t                      pid,
         msg.code    = IRM_MSG_CODE__IRM_BOOTSTRAP_IPCP;
         msg.has_pid = true;
         msg.pid     = pid;
-
-        cfg_msg.ipcp_type = conf->type;
-        layer_info_msg.layer_name = (char *) conf->layer_info.layer_name;
-        layer_info_msg.dir_hash_algo  = conf->layer_info.dir_hash_algo;
-
-        switch (conf->type) {
-        case IPCP_UNICAST:
-                dt_cfg_msg.addr_size       = conf->unicast.dt.addr_size;
-                dt_cfg_msg.eid_size        = conf->unicast.dt.eid_size;
-                dt_cfg_msg.max_ttl         = conf->unicast.dt.max_ttl;
-                dt_cfg_msg.routing_type    = conf->unicast.dt.routing_type;
-                uni_cfg_msg.dt             = &dt_cfg_msg;
-                uni_cfg_msg.addr_auth_type = conf->unicast.addr_auth_type;
-                uni_cfg_msg.cong_avoid     = conf->unicast.cong_avoid;
-                cfg_msg.unicast            = &uni_cfg_msg;
-                break;
-        case IPCP_UDP:
-                udp_cfg_msg.ip_addr  = conf->udp.ip_addr;
-                udp_cfg_msg.dns_addr = conf->udp.dns_addr;
-                udp_cfg_msg.port     = conf->udp.port;
-                cfg_msg.udp          = &udp_cfg_msg;
-                break;
-        case IPCP_LOCAL:
-                /* FALLTHRU */
-        case IPCP_BROADCAST:
-                break;
-        case IPCP_ETH_DIX:
-                eth_cfg_msg.has_ethertype = true;
-                eth_cfg_msg.ethertype     = conf->eth.ethertype;
-                /* FALLTHRU */
-        case IPCP_ETH_LLC:
-                eth_cfg_msg.dev = conf->eth.dev;
-                cfg_msg.eth = &eth_cfg_msg;
-                break;
-        default:
-                return -EIPCPTYPE;
-        }
-
-        cfg_msg.layer_info = &layer_info_msg;
-        msg.conf           = &cfg_msg;
+        msg.conf    = ipcp_config_s_to_msg(conf);
 
         recv_msg = send_recv_irm_msg(&msg);
+        ipcp_config_msg__free_unpacked(msg.conf, NULL);
         if (recv_msg == NULL)
                 return -EIRMD;
 
@@ -175,8 +132,7 @@ int irm_connect_ipcp(pid_t        pid,
                      const char * component,
                      qosspec_t    qs)
 {
-        irm_msg_t     msg    = IRM_MSG__INIT;
-        qosspec_msg_t qs_msg = QOSSPEC_MSG__INIT;
+        irm_msg_t     msg = IRM_MSG__INIT;
         irm_msg_t *   recv_msg;
         int           ret;
 
@@ -186,10 +142,11 @@ int irm_connect_ipcp(pid_t        pid,
         msg.comp      = (char *) component;
         msg.has_pid   = true;
         msg.pid       = pid;
-        qs_msg        = spec_to_msg(&qs);
-        msg.qosspec   = &qs_msg;
+        msg.qosspec   = qos_spec_s_to_msg(&qs);
 
         recv_msg = send_recv_irm_msg(&msg);
+        qosspec_msg__free_unpacked(msg.qosspec, NULL);
+
         if (recv_msg == NULL)
                 return -EIRMD;
 
diff --git a/src/lib/irmd_messages.proto b/src/lib/irmd_messages.proto
index 8c8c4ca8..8cf5da9e 100644
--- a/src/lib/irmd_messages.proto
+++ b/src/lib/irmd_messages.proto
@@ -1,7 +1,7 @@
 /*
  * Ouroboros - Copyright (C) 2016 - 2023
  *
- * IRMd message
+ * Messages sent to IRMd
  *
  *    Dimitri Staessens <[email protected]>
  *    Sander Vrijders   <[email protected]>
diff --git a/src/lib/protobuf.c b/src/lib/protobuf.c
new file mode 100644
index 00000000..0855305f
--- /dev/null
+++ b/src/lib/protobuf.c
@@ -0,0 +1,438 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2023
+ *
+ * Protobuf syntax conversion
+ *
+ *    Dimitri Staessens <[email protected]>
+ *    Sander Vrijders   <[email protected]>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * version 2.1 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., http://www.fsf.org/about/contact/.
+ */
+
+#define _DEFAULT_SOURCE
+
+#include <ouroboros/protobuf.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+layer_info_msg_t * layer_info_s_to_msg(const struct layer_info * s)
+{
+        layer_info_msg_t * msg;
+
+        assert(s != NULL);
+
+        msg = malloc(sizeof(*msg));
+        if (msg == NULL)
+                goto fail_malloc;
+
+        layer_info_msg__init(msg);
+
+        msg->layer_name = strdup(s->layer_name);
+        if (msg->layer_name == NULL)
+                goto fail_msg;
+
+        msg->dir_hash_algo  = s->dir_hash_algo;
+
+        return msg;
+
+ fail_msg:
+        layer_info_msg__free_unpacked(msg, NULL);
+ fail_malloc:
+        return NULL;
+}
+
+struct layer_info layer_info_msg_to_s(const layer_info_msg_t * msg)
+{
+        struct layer_info s;
+
+        assert(msg != NULL);
+        assert(strlen(msg->layer_name) <= LAYER_NAME_SIZE);
+
+        s.dir_hash_algo = msg->dir_hash_algo;
+        strcpy(s.layer_name, msg->layer_name);
+
+        return s;
+}
+
+dt_config_msg_t * dt_config_s_to_msg(const struct dt_config * s)
+{
+        dt_config_msg_t * msg;
+
+        assert(s != NULL);
+
+        msg = malloc(sizeof(*msg));
+        if (msg == NULL)
+                return NULL;
+
+        dt_config_msg__init(msg);
+
+        msg->addr_size    = s->addr_size;
+        msg->eid_size     = s->eid_size;
+        msg->max_ttl      = s->max_ttl;
+        msg->routing_type = s->routing_type;
+
+        return msg;
+}
+
+struct dt_config dt_config_msg_to_s(const dt_config_msg_t * msg)
+{
+        struct dt_config s;
+
+        assert(msg != NULL);
+
+        s.addr_size    = msg->addr_size;
+        s.eid_size     = msg->eid_size;
+        s.max_ttl      = msg->max_ttl;
+        s.routing_type = msg->routing_type;
+
+        return s;
+}
+
+uni_config_msg_t * uni_config_s_to_msg(const struct uni_config * s)
+{
+        uni_config_msg_t * msg;
+
+        assert(s != NULL);
+
+        msg = malloc(sizeof(*msg));
+        if (msg == NULL)
+                goto fail_malloc;
+
+        uni_config_msg__init(msg);
+
+        msg->dt = dt_config_s_to_msg(&s->dt);
+        if (msg->dt == NULL)
+                goto fail_msg;
+
+        msg->addr_auth_type = s->addr_auth_type;
+        msg->cong_avoid     = s->cong_avoid;
+
+        return msg;
+
+ fail_msg:
+        uni_config_msg__free_unpacked(msg, NULL);
+ fail_malloc:
+        return NULL;
+}
+
+struct uni_config uni_config_msg_to_s(const uni_config_msg_t * msg)
+{
+        struct uni_config s;
+
+        s.dt = dt_config_msg_to_s(msg->dt);
+
+        s.addr_auth_type  = msg->addr_auth_type;
+        s.cong_avoid      = msg->cong_avoid;
+
+        return s;
+}
+
+udp_config_msg_t * udp_config_s_to_msg(const struct udp_config * s)
+{
+        udp_config_msg_t * msg;
+
+        assert(s != NULL);
+
+        msg = malloc(sizeof(*msg));
+        if (msg == NULL)
+                return NULL;
+
+        udp_config_msg__init(msg);
+
+        msg->ip_addr  = s->ip_addr;
+        msg->dns_addr = s->dns_addr;
+        msg->port     = s->port;
+
+        return msg;
+}
+
+struct udp_config udp_config_msg_to_s(const udp_config_msg_t * msg)
+{
+        struct udp_config s;
+
+        assert(msg != NULL);
+
+        s.ip_addr  = msg->ip_addr;
+        s.dns_addr = msg->dns_addr;
+        s.port     = msg->port;
+
+        return s;
+}
+
+eth_config_msg_t * eth_config_s_to_msg(const struct eth_config * s)
+{
+        eth_config_msg_t * msg;
+
+        assert(s != NULL);
+
+        msg = malloc(sizeof(*msg));
+        if (msg == NULL)
+                goto fail_malloc;
+
+        eth_config_msg__init(msg);
+
+        msg->dev = strdup(s->dev);
+        if (msg->dev == NULL)
+                goto fail_msg;
+
+        msg->ethertype = s->ethertype;
+
+        return msg;
+
+ fail_msg:
+        eth_config_msg__free_unpacked(msg, NULL);
+ fail_malloc:
+        return NULL;
+}
+
+struct eth_config eth_config_msg_to_s(const eth_config_msg_t * msg)
+{
+        struct eth_config s;
+
+        assert(msg != NULL);
+        assert(strlen(msg->dev) <= DEV_NAME_SIZE);
+
+        strcpy(s.dev, msg->dev);
+        s.ethertype = msg->ethertype;
+
+        return s;
+}
+
+
+ipcp_config_msg_t * ipcp_config_s_to_msg(const struct ipcp_config * s)
+{
+        ipcp_config_msg_t * msg;
+
+        assert(s != NULL);
+
+        msg = malloc(sizeof(*msg));
+        if (msg == NULL)
+                goto fail_malloc;
+
+        ipcp_config_msg__init(msg);
+
+        switch (s->type) {
+        case IPCP_LOCAL:
+                break;
+        case IPCP_UNICAST:
+                msg->unicast = uni_config_s_to_msg(&s->unicast);
+                if (msg->unicast == NULL)
+                        goto fail_msg;
+                break;
+        case IPCP_BROADCAST:
+                break;
+        case IPCP_ETH_LLC:
+                /* FALLTHRU */
+        case IPCP_ETH_DIX:
+                msg->eth = eth_config_s_to_msg(&s->eth);
+                if (msg->eth == NULL)
+                        goto fail_msg;
+                break;
+        case IPCP_UDP:
+                msg->udp = udp_config_s_to_msg(&s->udp);
+                if (msg->udp == NULL)
+                        goto fail_msg;
+                break;
+        default:
+                /* No checks here */
+                break;
+        }
+
+        msg->ipcp_type = s->type;
+
+        msg->layer_info = layer_info_s_to_msg(&s->layer_info);
+        if (msg->layer_info == NULL)
+                goto fail_msg;
+
+        return msg;
+
+ fail_msg:
+        ipcp_config_msg__free_unpacked(msg, NULL);
+ fail_malloc:
+        return NULL;
+}
+
+struct ipcp_config ipcp_config_msg_to_s(const ipcp_config_msg_t * msg)
+{
+        struct ipcp_config s;
+
+        assert(msg != NULL);
+
+        s.type = msg->ipcp_type;
+
+        s.layer_info = layer_info_msg_to_s(msg->layer_info);
+
+        switch(msg->ipcp_type) {
+        case IPCP_LOCAL:
+                break;
+        case IPCP_UNICAST:
+                s.unicast = uni_config_msg_to_s(msg->unicast);
+                break;
+        case IPCP_ETH_LLC:
+                /* FALLTHRU */
+        case IPCP_ETH_DIX:
+                s.eth = eth_config_msg_to_s(msg->eth);
+                break;
+        case IPCP_UDP:
+                s.udp = udp_config_msg_to_s(msg->udp);
+                break;
+        case IPCP_BROADCAST:
+                break;
+        default:
+                /* No checks here */
+                break;
+        }
+
+        return s;
+}
+
+qosspec_msg_t * qos_spec_s_to_msg(const struct qos_spec * s)
+{
+        struct qos_spec spec;
+        qosspec_msg_t  * msg;
+
+        msg = malloc(sizeof(*msg));
+        if (msg == NULL)
+                return NULL;
+
+        qosspec_msg__init(msg);
+
+        spec = (s == NULL ? qos_raw : *s);
+
+        msg->delay        = spec.delay;
+        msg->bandwidth    = spec.bandwidth;
+        msg->availability = spec.availability;
+        msg->loss         = spec.loss;
+        msg->ber          = spec.ber;
+        msg->in_order     = spec.in_order;
+        msg->max_gap      = spec.max_gap;
+        msg->cypher_s     = spec.cypher_s;
+        msg->timeout      = spec.timeout;
+
+        return msg;
+}
+
+struct qos_spec qos_spec_msg_to_s(const qosspec_msg_t * msg)
+{
+        struct qos_spec s;
+
+        assert(msg != NULL);
+
+        s.delay        = msg->delay;
+        s.bandwidth    = msg->bandwidth;
+        s.availability = msg->availability;
+        s.loss         = msg->loss;
+        s.ber          = msg->ber;
+        s.in_order     = msg->in_order;
+        s.max_gap      = msg->max_gap;
+        s.cypher_s     = msg->cypher_s;
+        s.timeout      = msg->timeout;
+
+        return s;
+}
+
+enroll_req_msg_t * enroll_req_s_to_msg(void)
+{
+        enroll_req_msg_t * msg;
+
+        msg = malloc(sizeof(*msg));
+        if (msg == NULL)
+                return NULL;
+
+        enroll_req_msg__init(msg);
+
+        msg->magic = 0xC0FFEE;
+
+        return msg;
+}
+
+int enroll_req_msg_to_s(const enroll_req_msg_t * msg)
+{
+        (void) msg;
+
+        assert(msg != NULL);
+
+        return 0;
+}
+
+enroll_resp_msg_t * enroll_resp_s_to_msg(const struct enroll_resp * s)
+{
+        enroll_resp_msg_t * msg;
+
+        assert(s != NULL);
+
+        msg = malloc(sizeof(*msg));
+        if (msg == NULL)
+                goto fail_malloc;
+
+        enroll_resp_msg__init(msg);
+
+        msg->t_sec    = s->t.tv_sec;
+        msg->t_nsec   = s->t.tv_nsec;
+        msg->response = s->response;
+
+        if (msg->response < 0)
+                return msg;
+
+        msg->conf = ipcp_config_s_to_msg(&s->conf);
+        if (msg->conf == NULL)
+                goto fail_conf;
+
+        return msg;
+
+ fail_conf:
+        enroll_resp_msg__free_unpacked(msg, NULL);
+ fail_malloc:
+        return NULL;
+}
+
+struct enroll_resp enroll_resp_msg_to_s(enroll_resp_msg_t * msg)
+{
+        struct enroll_resp s;
+
+        assert (msg != NULL);
+
+        s.response = msg->response;
+        if (s.response >= 0)
+                s.conf = ipcp_config_msg_to_s(msg->conf);
+
+        s.t.tv_sec  = msg->t_sec;
+        s.t.tv_nsec = msg->t_nsec;
+
+        return s;
+}
+
+enroll_ack_msg_t * enroll_ack_s_to_msg(int response)
+{
+        enroll_ack_msg_t * msg;
+
+        msg = malloc(sizeof(*msg));
+        if (msg == NULL)
+                return NULL;
+
+        enroll_ack_msg__init(msg);
+
+        msg->response = response;
+
+        return msg;
+}
+
+int enroll_ack_msg_to_s(const enroll_ack_msg_t * msg)
+{
+        assert(msg != NULL);
+
+        return msg->response;
+}
diff --git a/src/lib/serdes-oep.c b/src/lib/serdes-oep.c
new file mode 100644
index 00000000..cae5c598
--- /dev/null
+++ b/src/lib/serdes-oep.c
@@ -0,0 +1,155 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2023
+ *
+ * Ouroboros Enrollment Protocol - serialization/deserialization
+ *
+ *    Dimitri Staessens <[email protected]>
+ *    Sander Vrijders   <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., http://www.fsf.org/about/contact/.
+ */
+
+#define _POSIX_C_SOURCE 200112L
+
+#include <ouroboros/protobuf.h>
+#include <ouroboros/serdes-oep.h>
+
+
+ssize_t enroll_req_ser(buffer_t buf)
+{
+        enroll_req_msg_t * msg;
+        ssize_t            sz;
+
+        msg = enroll_req_s_to_msg();
+        if (msg == NULL)
+                goto fail_msg;
+
+        sz = enroll_req_msg__get_packed_size(msg);
+        if (sz < 0 || (size_t) sz > buf.len)
+                goto fail_pack;
+
+        enroll_req_msg__pack(msg, buf.data);
+
+        enroll_req_msg__free_unpacked(msg, NULL);
+
+        return sz;
+
+ fail_pack:
+    enroll_req_msg__free_unpacked(msg, NULL);
+ fail_msg:
+    return -1;
+}
+
+int enroll_req_des(const buffer_t buf)
+{
+        enroll_req_msg_t * msg;
+
+        msg = enroll_req_msg__unpack(NULL, buf.len, buf.data);
+        if (msg == NULL)
+                return -1;
+
+        /* Nothing in request yet, if it unpacks, it's good. */
+
+        enroll_req_msg__free_unpacked(msg, NULL);
+
+        return 0;
+}
+
+ssize_t enroll_resp_ser(const struct enroll_resp * resp,
+                        buffer_t                   buf)
+{
+        enroll_resp_msg_t * msg;
+        ssize_t             sz;
+
+        msg = enroll_resp_s_to_msg(resp);
+        if (msg == NULL)
+                goto fail_msg;
+
+        sz = enroll_resp_msg__get_packed_size(msg);
+        if (sz < 0 || (size_t) sz > buf.len)
+                goto fail_pack;
+
+        msg->t_sec = resp->t.tv_sec;
+        msg->t_nsec = resp->t.tv_nsec;
+
+        enroll_resp_msg__pack(msg, buf.data);
+
+        enroll_resp_msg__free_unpacked(msg, NULL);
+
+        return sz;
+
+ fail_pack:
+        enroll_resp_msg__free_unpacked(msg, NULL);
+ fail_msg:
+        return -1;
+}
+
+int enroll_resp_des(struct enroll_resp * resp,
+                    const buffer_t       buf)
+{
+        enroll_resp_msg_t * msg;
+
+        msg = enroll_resp_msg__unpack(NULL, buf.len, buf.data);
+        if (msg == NULL)
+                return -1;
+
+        *resp = enroll_resp_msg_to_s(msg);
+
+        enroll_resp_msg__free_unpacked(msg, NULL);
+
+        return 0;
+}
+
+ssize_t enroll_ack_ser(const int response,
+                       buffer_t  buf)
+{
+        enroll_ack_msg_t * msg;
+        ssize_t            sz;
+
+        msg = enroll_ack_s_to_msg(response);
+        if (msg == NULL)
+                goto fail_msg;
+
+        sz = enroll_ack_msg__get_packed_size(msg);
+        if (sz < 0 || (size_t) sz > buf.len)
+                goto fail_pack;
+
+        enroll_ack_msg__pack(msg, buf.data);
+
+        enroll_ack_msg__free_unpacked(msg, NULL);
+
+        return sz;
+
+ fail_pack:
+        enroll_ack_msg__free_unpacked(msg, NULL);
+ fail_msg:
+        return -1;
+
+}
+
+int enroll_ack_des(int *          response,
+                   const buffer_t buf)
+{
+        enroll_ack_msg_t * msg;
+
+        msg = enroll_ack_msg__unpack(NULL, buf.len, buf.data);
+        if (msg == NULL)
+                return -1;
+
+        *response = enroll_ack_msg_to_s(msg);
+
+        enroll_ack_msg__free_unpacked(msg, NULL);
+
+        return 0;
+}
\ No newline at end of file
diff --git a/src/lib/sockets.c b/src/lib/sockets.c
index c82d622f..bb594115 100644
--- a/src/lib/sockets.c
+++ b/src/lib/sockets.c
@@ -100,6 +100,7 @@ int server_socket_open(char * file_name)
         return sockfd;
 }
 
+__attribute__((no_sanitize_address))
 irm_msg_t * send_recv_irm_msg(irm_msg_t * msg)
 {
         int         sockfd;
@@ -117,18 +118,18 @@ irm_msg_t * send_recv_irm_msg(irm_msg_t * msg)
                 return NULL;
         }
 
-        pthread_cleanup_push(__cleanup_close_ptr, &sockfd);
-
         irm_msg__pack(msg, buf);
 
+        pthread_cleanup_push(__cleanup_close_ptr, &sockfd);
+
         if (write(sockfd, buf, len) != -1)
                 len = read(sockfd, buf, SOCK_BUF_SIZE);
 
+        pthread_cleanup_pop(true);
+
         if (len > 0)
                 recv_msg = irm_msg__unpack(NULL, len, buf);
 
-        pthread_cleanup_pop(true);
-
         return recv_msg;
 }
 
@@ -165,42 +166,3 @@ char * ipcp_sock_path(pid_t pid)
 
         return full_name;
 }
-
-qosspec_msg_t spec_to_msg(const qosspec_t * qs)
-{
-        qosspec_t     spec;
-        qosspec_msg_t msg = QOSSPEC_MSG__INIT;
-
-        spec = (qs == NULL ? qos_raw : *qs);
-
-        msg.delay        = spec.delay;
-        msg.bandwidth    = spec.bandwidth;
-        msg.availability = spec.availability;
-        msg.loss         = spec.loss;
-        msg.ber          = spec.ber;
-        msg.in_order     = spec.in_order;
-        msg.max_gap      = spec.max_gap;
-        msg.cypher_s     = spec.cypher_s;
-        msg.timeout      = spec.timeout;
-
-        return msg;
-}
-
-qosspec_t msg_to_spec(const qosspec_msg_t * msg)
-{
-        qosspec_t     spec;
-
-        assert(msg);
-
-        spec.delay        = msg->delay;
-        spec.bandwidth    = msg->bandwidth;
-        spec.availability = msg->availability;
-        spec.loss         = msg->loss;
-        spec.ber          = msg->ber;
-        spec.in_order     = msg->in_order;
-        spec.max_gap      = msg->max_gap;
-        spec.cypher_s     = msg->cypher_s;
-        spec.timeout      = msg->timeout;
-
-        return spec;
-}