61 files changed, 2345 insertions, 2009 deletions

diff --git a/src/ipcpd/unicast/CMakeLists.txt b/src/ipcpd/unicast/CMakeLists.txt
index c0c55519..ca742871 100644
--- a/src/ipcpd/unicast/CMakeLists.txt
+++ b/src/ipcpd/unicast/CMakeLists.txt
@@ -13,8 +13,10 @@ include_directories(${CMAKE_SOURCE_DIR}/include)
 include_directories(${CMAKE_BINARY_DIR}/include)
 
 set(IPCP_UNICAST_TARGET ipcpd-unicast CACHE INTERNAL "")
+set(IPCP_UNICAST_MPL 60 CACHE STRING
+    "Default maximum packet lifetime for the unicast IPCP, in seconds")
 
-protobuf_generate_c(KAD_PROTO_SRCS KAD_PROTO_HDRS kademlia.proto)
+protobuf_generate_c(DHT_PROTO_SRCS DHT_PROTO_HDRS dir/dht.proto)
 
 math(EXPR PFT_EXPR "1 << 12")
 set(PFT_SIZE ${PFT_EXPR} CACHE STRING
@@ -29,32 +31,33 @@ if (HAVE_FUSE)
     endif ()
 endif ()
 
-
 set(SOURCE_FILES
   # Add source files here
-  addr_auth.c
+  addr-auth.c
+  ca.c
   connmgr.c
-  dht.c
   dir.c
   dt.c
-  enroll.c
   fa.c
   main.c
   pff.c
   routing.c
   psched.c
   # Add policies last
-  pol/pft.c
-  pol/flat.c
-  pol/link_state.c
-  pol/graph.c
-  pol/simple_pff.c
-  pol/alternate_pff.c
-  pol/multipath_pff.c
+  addr-auth/flat.c
+  ca/mb-ecn.c
+  ca/nop.c
+  dir/dht.c
+  pff/simple.c
+  pff/alternate.c
+  pff/multipath.c
+  pff/pft.c
+  routing/link-state.c
+  routing/graph.c
   )
 
-add_executable(ipcpd-unicast ${SOURCE_FILES} ${IPCP_SOURCES}
-  ${KAD_PROTO_SRCS} ${LAYER_CONFIG_PROTO_SRCS})
+add_executable(ipcpd-unicast ${SOURCE_FILES} ${IPCP_SOURCES} ${COMMON_SOURCES}
+  ${DHT_PROTO_SRCS} ${LAYER_CONFIG_PROTO_SRCS})
 target_link_libraries(ipcpd-unicast LINK_PUBLIC ouroboros-dev)
 
 include(AddCompileFlags)
@@ -64,8 +67,9 @@ endif ()
 
 install(TARGETS ipcpd-unicast RUNTIME DESTINATION ${CMAKE_INSTALL_SBINDIR})
 
-add_subdirectory(pol/tests)
+add_subdirectory(pff/tests)
+add_subdirectory(routing/tests)
 
 if (NOT GNU)
-  add_subdirectory(tests)
+  add_subdirectory(dir/tests)
 endif ()
diff --git a/src/ipcpd/unicast/addr_auth.c b/src/ipcpd/unicast/addr-auth.c
index e82ea254..908a4aa1 100644
--- a/src/ipcpd/unicast/addr_auth.c
+++ b/src/ipcpd/unicast/addr-auth.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Address authority
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -24,13 +24,12 @@
 
 #include <ouroboros/logs.h>
 
-#include "addr_auth.h"
-#include "pol-addr-auth-ops.h"
-#include "pol/flat.h"
+#include "addr-auth.h"
+#include "addr-auth/pol.h"
 
 #include <stdlib.h>
 
-struct pol_addr_auth_ops * ops;
+struct addr_auth_ops * ops;
 
 int addr_auth_init(enum pol_addr_auth type,
                    const void *       info)
diff --git a/src/ipcpd/unicast/addr_auth.h b/src/ipcpd/unicast/addr-auth.h
index 6bedf420..e119dff3 100644
--- a/src/ipcpd/unicast/addr_auth.h
+++ b/src/ipcpd/unicast/addr-auth.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Address authority
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
diff --git a/src/ipcpd/unicast/pol/flat.c b/src/ipcpd/unicast/addr-auth/flat.c
index 6e5c96ab..c4562935 100644
--- a/src/ipcpd/unicast/pol/flat.c
+++ b/src/ipcpd/unicast/addr-auth/flat.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Policy for flat addresses in a distributed way
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -29,19 +29,11 @@
 #define OUROBOROS_PREFIX "flat-addr-auth"
 
 #include <ouroboros/logs.h>
-#include <ouroboros/errno.h>
-#include <ouroboros/time_utils.h>
-#include <ouroboros/utils.h>
+#include <ouroboros/random.h>
 
 #include "ipcp.h"
 #include "flat.h"
 
-#include <time.h>
-#include <stdlib.h>
-#include <math.h>
-#include <string.h>
-#include <assert.h>
-
 #define NAME_LEN 8
 
 struct {
@@ -50,7 +42,7 @@ struct {
 
 #define INVALID_ADDRESS 0
 
-struct pol_addr_auth_ops flat_ops = {
+struct addr_auth_ops flat_ops = {
         .init    = flat_init,
         .fini    = flat_fini,
         .address = flat_address
@@ -75,13 +67,13 @@ int flat_fini(void)
 
 uint64_t flat_address(void)
 {
-        struct timespec t;
-        uint32_t        addr;
-
-        clock_gettime(CLOCK_REALTIME, &t);
-        srand(t.tv_nsec);
-
-        addr = (rand() % (RAND_MAX - 1) + 1) & 0xFFFFFFFF;
+        uint32_t addr = INVALID_ADDRESS;
 
+#if defined (CONFIG_OUROBOROS_DEBUG) && defined (IPCP_DEBUG_LOCAL)
+        addr = getpid();
+#else
+        while (addr == INVALID_ADDRESS)
+                random_buffer(&addr,sizeof(addr));
+#endif
         return addr;
 }
diff --git a/src/ipcpd/unicast/pol/flat.h b/src/ipcpd/unicast/addr-auth/flat.h
index 54460bb3..d4b672c7 100644
--- a/src/ipcpd/unicast/pol/flat.h
+++ b/src/ipcpd/unicast/addr-auth/flat.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Policy for flat addresses in a distributed way
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -23,7 +23,7 @@
 #ifndef OUROBOROS_IPCPD_UNICAST_FLAT_H
 #define OUROBOROS_IPCPD_UNICAST_FLAT_H
 
-#include "pol-addr-auth-ops.h"
+#include "ops.h"
 
 int      flat_init(const void * info);
 
@@ -31,6 +31,6 @@ int      flat_fini(void);
 
 uint64_t flat_address(void);
 
-struct pol_addr_auth_ops flat_ops;
+extern struct addr_auth_ops flat_ops;
 
 #endif /* OUROBOROS_IPCPD_UNICAST_FLAT_H */
diff --git a/src/ipcpd/unicast/pol-addr-auth-ops.h b/src/ipcpd/unicast/addr-auth/ops.h
index 1096eecb..06b24cec 100644
--- a/src/ipcpd/unicast/pol-addr-auth-ops.h
+++ b/src/ipcpd/unicast/addr-auth/ops.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Address authority policy ops
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -20,10 +20,10 @@
  * Foundation, Inc., http://www.fsf.org/about/contact/.
  */
 
-#ifndef OUROBOROS_IPCPD_UNICAST_POL_ADDR_AUTH_OPS_H
-#define OUROBOROS_IPCPD_UNICAST_POL_ADDR_AUTH_OPS_H
+#ifndef OUROBOROS_IPCPD_UNICAST_ADDR_AUTH_OPS_H
+#define OUROBOROS_IPCPD_UNICAST_ADDR_AUTH_OPS_H
 
-struct pol_addr_auth_ops {
+struct addr_auth_ops {
         int      (* init)(const void * info);
 
         int      (* fini)(void);
@@ -31,4 +31,4 @@ struct pol_addr_auth_ops {
         uint64_t (* address)(void);
 };
 
-#endif /* OUROBOROS_IPCPD_UNICAST_POL_ADDR_AUTH_OPS_H */
+#endif /* OUROBOROS_IPCPD_UNICAST_ADDR_AUTH_OPS_H */
diff --git a/src/ipcpd/unicast/addr-auth/pol.h b/src/ipcpd/unicast/addr-auth/pol.h
new file mode 100644
index 00000000..844308c6
--- /dev/null
+++ b/src/ipcpd/unicast/addr-auth/pol.h
@@ -0,0 +1,23 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2024
+ *
+ * Address Authority policies
+ *
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
+ *
+ * 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/.
+ */
+
+#include "flat.h"
diff --git a/src/ipcpd/unicast/ca.c b/src/ipcpd/unicast/ca.c
new file mode 100644
index 00000000..287eaf41
--- /dev/null
+++ b/src/ipcpd/unicast/ca.c
@@ -0,0 +1,109 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2024
+ *
+ * Congestion Avoidance
+ *
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
+ *
+ * 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 OUROBOROS_PREFIX "ca"
+
+#include <ouroboros/logs.h>
+
+#include "ca.h"
+#include "ca/pol.h"
+
+struct {
+        struct ca_ops * ops;
+} ca;
+
+int ca_init(enum pol_cong_avoid pol)
+{
+        switch(pol) {
+        case CA_NONE:
+                log_dbg("Disabling congestion control.");
+                ca.ops = &nop_ca_ops;
+                break;
+        case CA_MB_ECN:
+                log_dbg("Using multi-bit ECN.");
+                ca.ops = &mb_ecn_ca_ops;
+                break;
+        default:
+                return -1;
+        }
+
+        return 0;
+}
+
+
+void ca_fini(void)
+{
+        ca.ops = NULL;
+}
+
+void * ca_ctx_create(void)
+{
+        return ca.ops->ctx_create();
+}
+
+void ca_ctx_destroy(void * ctx)
+{
+        return ca.ops->ctx_destroy(ctx);
+}
+
+ca_wnd_t ca_ctx_update_snd(void * ctx,
+                           size_t len)
+{
+        return ca.ops->ctx_update_snd(ctx, len);
+}
+
+bool ca_ctx_update_rcv(void *     ctx,
+                       size_t     len,
+                       uint8_t    ecn,
+                       uint16_t * ece)
+{
+        return ca.ops->ctx_update_rcv(ctx, len, ecn, ece);
+}
+
+void ca_ctx_update_ece(void *   ctx,
+                       uint16_t ece)
+{
+        return ca.ops->ctx_update_ece(ctx, ece);
+}
+
+void ca_wnd_wait(ca_wnd_t wnd)
+{
+        return ca.ops->wnd_wait(wnd);
+}
+
+int  ca_calc_ecn(int       fd,
+                 uint8_t * ecn,
+                 qoscube_t qc,
+                 size_t    len)
+{
+        return ca.ops->calc_ecn(fd, ecn, qc, len);
+}
+
+ssize_t ca_print_stats(void * ctx,
+                       char * buf,
+                       size_t len)
+{
+        if (ca.ops->print_stats == NULL)
+                return 0;
+
+        return ca.ops->print_stats(ctx, buf, len);
+}
diff --git a/src/ipcpd/unicast/ca.h b/src/ipcpd/unicast/ca.h
new file mode 100644
index 00000000..ea803e17
--- /dev/null
+++ b/src/ipcpd/unicast/ca.h
@@ -0,0 +1,68 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2024
+ *
+ * Congestion avoidance
+ *
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
+ *
+ * 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/.
+ */
+
+#ifndef OUROBOROS_IPCPD_UNICAST_CA_H
+#define OUROBOROS_IPCPD_UNICAST_CA_H
+
+#include <ouroboros/ipcp.h>
+#include <ouroboros/qoscube.h>
+
+#include <stdbool.h>
+#include <sys/types.h>
+
+typedef union {
+        time_t wait;
+} ca_wnd_t;
+
+int      ca_init(enum pol_cong_avoid ca);
+
+void     ca_fini(void);
+
+
+/* OPS */
+void *   ca_ctx_create(void);
+
+void     ca_ctx_destroy(void * ctx);
+
+ca_wnd_t ca_ctx_update_snd(void * ctx,
+                           size_t len);
+
+bool     ca_ctx_update_rcv(void *     ctx,
+                           size_t     len,
+                           uint8_t    ecn,
+                           uint16_t * ece);
+
+void     ca_ctx_update_ece(void *   ctx,
+                           uint16_t ece);
+
+void     ca_wnd_wait(ca_wnd_t wnd);
+
+int      ca_calc_ecn(int       fd,
+                     uint8_t * ecn,
+                     qoscube_t qc,
+                     size_t    len);
+
+ssize_t  ca_print_stats(void * ctx,
+                        char * buf,
+                        size_t len);
+
+#endif /* OUROBOROS_IPCPD_UNICAST_CA_H */
diff --git a/src/ipcpd/unicast/ca/mb-ecn.c b/src/ipcpd/unicast/ca/mb-ecn.c
new file mode 100644
index 00000000..d9a204b0
--- /dev/null
+++ b/src/ipcpd/unicast/ca/mb-ecn.c
@@ -0,0 +1,296 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2024
+ *
+ * Multi-bit ECN Congestion Avoidance
+ *
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
+ *
+ * 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/.
+ */
+
+#if defined(__linux__) || defined(__CYGWIN__)
+#define _DEFAULT_SOURCE
+#else
+#define _POSIX_C_SOURCE 200809L
+#endif
+
+#include "config.h"
+
+#include <ouroboros/ipcp-dev.h>
+#include <ouroboros/time.h>
+
+#include "mb-ecn.h"
+
+#include <inttypes.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/* congestion avoidance constants */
+#define CA_SHFT      5                    /* Average over 32 pkts   */
+#define CA_WND       (1 << CA_SHFT)       /* 32 pkts receiver wnd   */
+#define CA_UPD       (1 << (CA_SHFT - 2)) /* Update snd every 8 pkt */
+#define CA_SLOT      24                   /* Initial slot = 16 ms   */
+#define CA_INC       1UL << 16            /* ~4MiB/s^2 additive inc */
+#define CA_IWL       1UL << 16            /* Initial limit ~4MiB/s  */
+#define CA_MINPS     8                    /* Mimimum pkts / slot    */
+#define CA_MAXPS     64                   /* Maximum pkts / slot    */
+#define ECN_Q_SHFT   4
+#define ts_to_ns(ts) ((size_t) ts.tv_sec * BILLION + ts.tv_nsec)
+
+struct mb_ecn_ctx {
+        uint16_t        rx_ece; /* Level of congestion (upstream)   */
+        size_t          rx_ctr; /* Receiver side packet counter     */
+
+        uint16_t        tx_ece; /* Level of congestion (downstream) */
+        size_t          tx_ctr; /* Sender side packet counter       */
+        size_t          tx_wbc; /* Window byte count                */
+        size_t          tx_wpc; /* Window packet count              */
+        size_t          tx_wbl; /* Window byte limit                */
+        bool            tx_cav; /* Congestion avoidance             */
+        size_t          tx_mul; /* Slot size multiplier             */
+        size_t          tx_inc; /* Additive increase                */
+        size_t          tx_slot;
+};
+
+struct ca_ops mb_ecn_ca_ops = {
+        .ctx_create     = mb_ecn_ctx_create,
+        .ctx_destroy    = mb_ecn_ctx_destroy,
+        .ctx_update_snd = mb_ecn_ctx_update_snd,
+        .ctx_update_rcv = mb_ecn_ctx_update_rcv,
+        .ctx_update_ece = mb_ecn_ctx_update_ece,
+        .wnd_wait       = mb_ecn_wnd_wait,
+        .calc_ecn       = mb_ecn_calc_ecn,
+        .print_stats    = mb_ecn_print_stats
+};
+
+void * mb_ecn_ctx_create(void)
+{
+        struct timespec     now;
+        struct mb_ecn_ctx * ctx;
+
+        ctx = malloc(sizeof(*ctx));
+        if (ctx == NULL)
+                return NULL;
+
+        clock_gettime(PTHREAD_COND_CLOCK, &now);
+
+        memset(ctx, 0, sizeof(*ctx));
+
+        ctx->tx_mul  = CA_SLOT;
+        ctx->tx_wbl  = CA_IWL;
+        ctx->tx_inc  = CA_INC;
+        ctx->tx_slot = ts_to_ns(now) >> ctx->tx_mul;
+
+        return (void *) ctx;
+}
+
+void mb_ecn_ctx_destroy(void * ctx)
+{
+        free(ctx);
+}
+
+#define _slot_after(new, old) ((int64_t) (old - new) < 0)
+
+ca_wnd_t mb_ecn_ctx_update_snd(void * _ctx,
+                               size_t len)
+{
+        struct timespec     now;
+        size_t              slot;
+        ca_wnd_t            wnd;
+        struct mb_ecn_ctx * ctx = _ctx;
+
+        clock_gettime(PTHREAD_COND_CLOCK, &now);
+
+        slot = ts_to_ns(now) >> ctx->tx_mul;
+
+        ctx->tx_ctr++;
+        ctx->tx_wpc++;
+        ctx->tx_wbc += len;
+
+        if (ctx->tx_ctr > CA_WND)
+                ctx->tx_ece = 0;
+
+        if (_slot_after(slot, ctx->tx_slot)) {
+                bool carry = false; /* may carry over if window increases */
+
+                ctx->tx_slot = slot;
+
+                if (!ctx->tx_cav) { /* Slow start */
+                        if (ctx->tx_wbc > ctx->tx_wbl)
+                                ctx->tx_wbl <<= 1;
+                } else {
+                        if (ctx->tx_ece) /* Mult. Decrease */
+                                ctx->tx_wbl -= (ctx->tx_wbl * ctx->tx_ece)
+                                        >> (CA_SHFT + 8);
+                        else /* Add. Increase */
+                                ctx->tx_wbl = ctx->tx_wbc + ctx->tx_inc;
+                }
+
+                /* Window scaling */
+                if (ctx->tx_wpc < CA_MINPS) {
+                        size_t fact = 0; /* factor to scale the window up */
+                        size_t pkts = ctx->tx_wpc;
+                        while (pkts < CA_MINPS) {
+                                pkts <<= 1;
+                                fact++;
+                        }
+                        ctx->tx_mul += fact;
+                        ctx->tx_slot >>= fact;
+                        if ((ctx->tx_slot & ((1 << fact)  - 1)) == 0) {
+                                carry = true;
+                                ctx->tx_slot += 1;
+                        }
+                        ctx->tx_wbl <<= fact;
+                        ctx->tx_inc <<= fact;
+                } else if (ctx->tx_wpc > CA_MAXPS) {
+                        size_t fact = 0; /* factor to scale the window down */
+                        size_t pkts = ctx->tx_wpc;
+                        while (pkts > CA_MAXPS) {
+                                pkts >>= 1;
+                                fact++;
+                        }
+                        ctx->tx_mul -= fact;
+                        ctx->tx_slot <<= fact;
+                        ctx->tx_wbl >>= fact;
+                        ctx->tx_inc >>= fact;
+                } else {
+                        ctx->tx_slot = slot;
+                }
+
+                if (!carry) {
+                        ctx->tx_wbc = 0;
+                        ctx->tx_wpc = 0;
+                }
+        }
+
+        if (ctx->tx_wbc > ctx->tx_wbl)
+                wnd.wait = ((ctx->tx_slot + 1) << ctx->tx_mul) - ts_to_ns(now);
+        else
+                wnd.wait = 0;
+
+        return wnd;
+}
+
+void mb_ecn_wnd_wait(ca_wnd_t wnd)
+{
+        if (wnd.wait > 0) {
+                struct timespec s = TIMESPEC_INIT_S(0);
+                if (wnd.wait > BILLION) /* Don't care throttling < 1s */
+                        s.tv_sec = 1;
+                else
+                        s.tv_nsec = wnd.wait;
+
+                nanosleep(&s, NULL);
+        }
+}
+
+bool mb_ecn_ctx_update_rcv(void *     _ctx,
+                           size_t     len,
+                           uint8_t    ecn,
+                           uint16_t * ece)
+{
+        struct mb_ecn_ctx* ctx = _ctx;
+        bool               update;
+
+        (void) len;
+
+        if ((ctx->rx_ece | ecn) == 0)
+                return false;
+
+        if (ecn == 0) { /* End of congestion */
+                ctx->rx_ece >>= 2;
+                update = ctx->rx_ece == 0;
+        } else {
+                if (ctx->rx_ece == 0) { /* Start of congestion */
+                        ctx->rx_ece = ecn;
+                        ctx->rx_ctr = 0;
+                        update = true;
+                } else { /* Congestion update */
+                        ctx->rx_ece -= ctx->rx_ece >> CA_SHFT;
+                        ctx->rx_ece += ecn;
+                        update = (ctx->rx_ctr++ & (CA_UPD - 1)) == true;
+                }
+        }
+
+        *ece = ctx->rx_ece;
+
+        return update;
+}
+
+
+void mb_ecn_ctx_update_ece(void *   _ctx,
+                           uint16_t ece)
+{
+        struct mb_ecn_ctx* ctx = _ctx;
+
+        ctx->tx_ece = ece;
+        ctx->tx_ctr = 0;
+        ctx->tx_cav = true;
+}
+
+int  mb_ecn_calc_ecn(int       fd,
+                     uint8_t * ecn,
+                     qoscube_t qc,
+                     size_t    len)
+{
+        size_t q;
+
+        (void) len;
+        (void) qc;
+
+        q = ipcp_flow_queued(fd);
+
+        *ecn |= (uint8_t) (q >> ECN_Q_SHFT);
+
+        return 0;
+}
+
+ssize_t  mb_ecn_print_stats(void * _ctx,
+                            char * buf,
+                            size_t len)
+{
+        struct mb_ecn_ctx* ctx = _ctx;
+        char *             regime;
+
+        if (len < 1024)
+                return 0;
+
+        if (!ctx->tx_cav)
+                regime = "Slow start";
+        else if (ctx->tx_ece)
+                regime = "Multiplicative dec";
+        else
+                regime = "Additive inc";
+
+        sprintf(buf,
+                "Congestion avoidance algorithm:  %20s\n"
+                "Upstream congestion level:       %20u\n"
+                "Upstream packet counter:         %20zu\n"
+                "Downstream congestion level:     %20u\n"
+                "Downstream packet counter:       %20zu\n"
+                "Congestion window size (ns):     %20" PRIu64 "\n"
+                "Packets in this window:          %20zu\n"
+                "Bytes in this window:            %20zu\n"
+                "Max bytes in this window:        %20zu\n"
+                "Current congestion regime:       %20s\n",
+                "Multi-bit ECN",
+                ctx->tx_ece, ctx->tx_ctr,
+                ctx->rx_ece, ctx->rx_ctr, (uint64_t) (1ULL << ctx->tx_mul),
+                ctx->tx_wpc, ctx->tx_wbc, ctx->tx_wbl,
+                regime);
+
+        return strlen(buf);
+}
diff --git a/src/ipcpd/unicast/ca/mb-ecn.h b/src/ipcpd/unicast/ca/mb-ecn.h
new file mode 100644
index 00000000..9a2c8b49
--- /dev/null
+++ b/src/ipcpd/unicast/ca/mb-ecn.h
@@ -0,0 +1,56 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2024
+ *
+ * Multi-bit ECN Congestion Avoidance
+ *
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
+ *
+ * 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/.
+ */
+
+#ifndef OUROBOROS_IPCPD_UNICAST_CA_MB_ECN_H
+#define OUROBOROS_IPCPD_UNICAST_CA_MB_ECN_H
+
+#include "ops.h"
+
+void *   mb_ecn_ctx_create(void);
+
+void     mb_ecn_ctx_destroy(void * ctx);
+
+ca_wnd_t mb_ecn_ctx_update_snd(void * ctx,
+                               size_t len);
+
+bool     mb_ecn_ctx_update_rcv(void *     ctx,
+                               size_t     len,
+                               uint8_t    ecn,
+                               uint16_t * ece);
+
+void     mb_ecn_ctx_update_ece(void *   ctx,
+                               uint16_t ece);
+
+void     mb_ecn_wnd_wait(ca_wnd_t wnd);
+
+int      mb_ecn_calc_ecn(int       fd,
+                         uint8_t * ecn,
+                         qoscube_t qc,
+                         size_t    len);
+
+ssize_t  mb_ecn_print_stats(void * ctx,
+                            char * buf,
+                            size_t len);
+
+extern struct ca_ops mb_ecn_ca_ops;
+
+#endif /* OUROBOROS_IPCPD_UNICAST_CA_MB_ECN_H */
diff --git a/src/ipcpd/unicast/ca/nop.c b/src/ipcpd/unicast/ca/nop.c
new file mode 100644
index 00000000..617fc15b
--- /dev/null
+++ b/src/ipcpd/unicast/ca/nop.c
@@ -0,0 +1,98 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2024
+ *
+ * Dummy Congestion Avoidance
+ *
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
+ *
+ * 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/.
+ */
+
+#include "nop.h"
+
+#include <string.h>
+
+struct ca_ops nop_ca_ops = {
+        .ctx_create     = nop_ctx_create,
+        .ctx_destroy    = nop_ctx_destroy,
+        .ctx_update_snd = nop_ctx_update_snd,
+        .ctx_update_rcv = nop_ctx_update_rcv,
+        .ctx_update_ece = nop_ctx_update_ece,
+        .wnd_wait       = nop_wnd_wait,
+        .calc_ecn       = nop_calc_ecn,
+        .print_stats    = NULL
+};
+
+void * nop_ctx_create(void)
+{
+        return (void *) 1;
+}
+
+void nop_ctx_destroy(void * ctx)
+{
+        (void) ctx;
+}
+
+ca_wnd_t nop_ctx_update_snd(void * ctx,
+                            size_t len)
+{
+        ca_wnd_t wnd;
+
+        (void) ctx;
+        (void) len;
+
+        memset(&wnd, 0, sizeof(wnd));
+
+        return wnd;
+}
+
+void nop_wnd_wait(ca_wnd_t wnd)
+{
+        (void) wnd;
+}
+
+bool nop_ctx_update_rcv(void *     ctx,
+                        size_t     len,
+                        uint8_t    ecn,
+                        uint16_t * ece)
+{
+        (void) ctx;
+        (void) len;
+        (void) ecn;
+        (void) ece;
+
+        return false;
+}
+
+void nop_ctx_update_ece(void *   ctx,
+                        uint16_t ece)
+{
+        (void) ctx;
+        (void) ece;
+}
+
+
+int nop_calc_ecn(int       fd,
+                 uint8_t * ecn,
+                 qoscube_t qc,
+                 size_t    len)
+{
+        (void) fd;
+        (void) len;
+        (void) ecn;
+        (void) qc;
+
+        return 0;
+}
diff --git a/src/ipcpd/unicast/ca/nop.h b/src/ipcpd/unicast/ca/nop.h
new file mode 100644
index 00000000..248b198d
--- /dev/null
+++ b/src/ipcpd/unicast/ca/nop.h
@@ -0,0 +1,52 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2024
+ *
+ * Dummy Congestion Avoidance
+ *
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
+ *
+ * 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/.
+ */
+
+#ifndef OUROBOROS_IPCPD_UNICAST_CA_NOP_H
+#define OUROBOROS_IPCPD_UNICAST_CA_NOP_H
+
+#include "ops.h"
+
+void *   nop_ctx_create(void);
+
+void     nop_ctx_destroy(void * ctx);
+
+ca_wnd_t nop_ctx_update_snd(void * ctx,
+                            size_t len);
+
+bool     nop_ctx_update_rcv(void *     ctx,
+                            size_t     len,
+                            uint8_t    ecn,
+                            uint16_t * ece);
+
+void     nop_ctx_update_ece(void *   ctx,
+                            uint16_t ece);
+
+void     nop_wnd_wait(ca_wnd_t wnd);
+
+int      nop_calc_ecn(int       fd,
+                      uint8_t * ecn,
+                      qoscube_t qc,
+                      size_t    len);
+
+extern struct ca_ops nop_ca_ops;
+
+#endif /* OUROBOROS_IPCPD_UNICAST_CA_NOP_H */
diff --git a/src/ipcpd/unicast/ca/ops.h b/src/ipcpd/unicast/ca/ops.h
new file mode 100644
index 00000000..3a7b7248
--- /dev/null
+++ b/src/ipcpd/unicast/ca/ops.h
@@ -0,0 +1,58 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2024
+ *
+ * Congestion avoidance policy ops
+ *
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
+ *
+ * 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/.
+ */
+
+#ifndef OUROBOROS_IPCPD_UNICAST_CA_OPS_H
+#define OUROBOROS_IPCPD_UNICAST_CA_OPS_H
+
+#include "ca.h"
+
+struct ca_ops {
+        void *   (* ctx_create)(void);
+
+        void     (* ctx_destroy)(void * ctx);
+
+        ca_wnd_t (* ctx_update_snd)(void * ctx,
+                                    size_t len);
+
+        bool     (* ctx_update_rcv)(void *     ctx,
+                                    size_t     len,
+                                    uint8_t    ecn,
+                                    uint16_t * ece);
+
+        void     (* ctx_update_ece)(void *   ctx,
+                                    uint16_t ece);
+
+        void     (* wnd_wait)(ca_wnd_t wnd);
+
+        int      (* calc_ecn)(int       fd,
+                              uint8_t * ecn,
+                              qoscube_t qc,
+                              size_t    len);
+
+        /* Optional, can be NULL */
+        ssize_t  (* print_stats)(void * ctx,
+                                 char * buf,
+                                 size_t len);
+
+};
+
+#endif /* OUROBOROS_IPCPD_UNICAST_CA_OPS_H */
diff --git a/src/ipcpd/unicast/ca/pol.h b/src/ipcpd/unicast/ca/pol.h
new file mode 100644
index 00000000..db0a1a11
--- /dev/null
+++ b/src/ipcpd/unicast/ca/pol.h
@@ -0,0 +1,24 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2024
+ *
+ * Congestion avoidance policies
+ *
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
+ *
+ * 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/.
+ */
+
+#include "mb-ecn.h"
+#include "nop.h"
diff --git a/src/ipcpd/unicast/comp.h b/src/ipcpd/unicast/comp.h
deleted file mode 100644
index 42367833..00000000
--- a/src/ipcpd/unicast/comp.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Ouroboros - Copyright (C) 2016 - 2020
- *
- * Components for the unicast IPC process
- *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
- *
- * 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/.
- */
-
-#ifndef OUROBOROS_IPCPD_UNICAST_COMP_H
-#define OUROBOROS_IPCPD_UNICAST_COMP_H
-
-#include <ouroboros/cacep.h>
-
-#include "dt.h"
-
-#define DST_MAX_STRLEN 64
-
-enum comp_id {
-        COMPID_DT = 0,
-        COMPID_ENROLL,
-        COMPID_MGMT,
-        COMPID_MAX
-};
-
-struct conn {
-        struct conn_info conn_info;
-        struct {
-                char      dst[DST_MAX_STRLEN + 1];
-                int       fd;
-                qosspec_t qs;
-        } flow_info;
-};
-
-#endif /* OUROBOROS_IPCPD_UNICAST_COMP_H */
diff --git a/src/ipcpd/unicast/connmgr.c b/src/ipcpd/unicast/connmgr.c
index 3ebef7f9..11c5d5b6 100644
--- a/src/ipcpd/unicast/connmgr.c
+++ b/src/ipcpd/unicast/connmgr.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Handles connections between components
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -20,506 +20,20 @@
  * Foundation, Inc., http://www.fsf.org/about/contact/.
  */
 
+#include "config.h"
+
 #if defined(__linux__) || defined(__CYGWIN__)
 #define _DEFAULT_SOURCE
 #else
 #define _POSIX_C_SOURCE 200112L
 #endif
 
-#define OUROBOROS_PREFIX "connection-manager"
-
-#include <ouroboros/dev.h>
-#include <ouroboros/cacep.h>
-#include <ouroboros/errno.h>
-#include <ouroboros/list.h>
-#include <ouroboros/logs.h>
-#include <ouroboros/notifier.h>
-
-#include "comp.h"
-#include "connmgr.h"
-#include "dir.h"
-#include "enroll.h"
-#include "ipcp.h"
-
-#include <pthread.h>
-#include <string.h>
-#include <stdlib.h>
-#include <assert.h>
-
-enum connmgr_state {
-        CONNMGR_NULL = 0,
-        CONNMGR_INIT,
-        CONNMGR_RUNNING
-};
-
-struct conn_el {
-        struct list_head next;
-        struct conn      conn;
-};
-
-struct comp {
-        struct conn_info info;
-
-        struct list_head conns;
-        struct list_head pending;
-
-        pthread_cond_t   cond;
-        pthread_mutex_t  lock;
-};
-
-struct {
-        struct comp        comps[COMPID_MAX];
-        enum connmgr_state state;
-
-        pthread_t          acceptor;
-} connmgr;
-
-static int get_id_by_name(const char * name)
-{
-        enum comp_id i;
-
-        for (i = 0; i < COMPID_MAX; ++i)
-                if (strcmp(name, connmgr.comps[i].info.comp_name) == 0)
-                        return i;
-
-        return -1;
-}
-
-static int get_conn_by_fd(int           fd,
-                          enum comp_id  id,
-                          struct conn * conn)
-{
-        struct list_head * p;
-
-        pthread_mutex_lock(&connmgr.comps[id].lock);
-
-        list_for_each(p, &connmgr.comps[id].conns) {
-                struct conn_el * c =
-                        list_entry(p, struct conn_el, next);
-                if (c->conn.flow_info.fd == fd) {
-                        *conn = c->conn;
-                        pthread_mutex_unlock(&connmgr.comps[id].lock);
-                        return 0;
-                }
-        }
-
-        pthread_mutex_unlock(&connmgr.comps[id].lock);
-
-        return -1;
-}
-
-static int add_comp_conn(enum comp_id       id,
-                         int                fd,
-                         qosspec_t          qs,
-                         struct conn_info * rcv_info)
-{
-        struct conn_el * el;
-
-        el = malloc(sizeof(*el));
-        if (el == NULL) {
-                log_err("Not enough memory.");
-                return -1;
-        }
-
-        el->conn.conn_info    = *rcv_info;
-        el->conn.flow_info.fd = fd;
-        el->conn.flow_info.qs = qs;
-
-        pthread_mutex_lock(&connmgr.comps[id].lock);
-
-        list_add(&el->next, &connmgr.comps[id].pending);
-        pthread_cond_signal(&connmgr.comps[id].cond);
-
-        pthread_mutex_unlock(&connmgr.comps[id].lock);
-
-        return 0;
-}
-
-static void * flow_acceptor(void * o)
-{
-        int               fd;
-        qosspec_t         qs;
-        struct conn_info  rcv_info;
-        struct conn_info  fail_info;
-
-        (void) o;
-
-        memset(&fail_info, 0, sizeof(fail_info));
-
-        while (true) {
-                int id;
-
-                fd = flow_accept(&qs, NULL);
-                if (fd < 0) {
-                        if (fd != -EIRMD)
-                                log_warn("Flow accept failed: %d", fd);
-                        continue;
-                }
-
-                if (cacep_rcv(fd, &rcv_info)) {
-                        log_dbg("Error establishing application connection.");
-                        flow_dealloc(fd);
-                        continue;
-                }
-
-                id = get_id_by_name(rcv_info.comp_name);
-                if (id < 0) {
-                        log_dbg("Connection request for unknown component %s.",
-                                rcv_info.comp_name);
-                        cacep_snd(fd, &fail_info);
-                        flow_dealloc(fd);
-                        continue;
-                }
-
-                assert(id < COMPID_MAX);
-
-                if (cacep_snd(fd, &connmgr.comps[id].info)) {
-                        log_dbg("Failed to respond to request.");
-                        flow_dealloc(fd);
-                        continue;
-                }
-
-                if (add_comp_conn(id, fd, qs, &rcv_info)) {
-                        log_dbg("Failed to add new connection.");
-                        flow_dealloc(fd);
-                        continue;
-                }
-        }
-
-        return (void *) 0;
-}
-
-static void handle_event(void *       self,
-                         int          event,
-                         const void * o)
-{
-        struct conn conn;
-
-        (void) self;
-
-        if (!(event == NOTIFY_DT_FLOW_UP ||
-              event == NOTIFY_DT_FLOW_DOWN ||
-              event == NOTIFY_DT_FLOW_DEALLOC))
-                return;
-
-        if (get_conn_by_fd(*((int *) o), COMPID_DT, &conn))
-                return;
-
-        switch (event) {
-        case NOTIFY_DT_FLOW_UP:
-                notifier_event(NOTIFY_DT_CONN_UP, &conn);
-                break;
-        case NOTIFY_DT_FLOW_DOWN:
-                notifier_event(NOTIFY_DT_CONN_DOWN, &conn);
-                break;
-        case NOTIFY_DT_FLOW_DEALLOC:
-                notifier_event(NOTIFY_DT_CONN_DEL, &conn);
-                break;
-        default:
-                break;
-        }
-}
-
-int connmgr_init(void)
-{
-        connmgr.state = CONNMGR_INIT;
-
-        if (notifier_reg(handle_event, NULL))
-                return -1;
-
-        return 0;
-}
-
-void connmgr_fini(void)
-{
-        int i;
-
-        notifier_unreg(handle_event);
-
-        if (connmgr.state == CONNMGR_RUNNING)
-                pthread_join(connmgr.acceptor, NULL);
-
-        for (i = 0; i < COMPID_MAX; ++i)
-                connmgr_comp_fini(i);
-}
-
-int connmgr_start(void)
-{
-        if (pthread_create(&connmgr.acceptor, NULL, flow_acceptor, NULL))
-                return -1;
-
-        connmgr.state = CONNMGR_RUNNING;
-
-        return 0;
-}
-
-void connmgr_stop(void)
-{
-        if (connmgr.state == CONNMGR_RUNNING)
-                pthread_cancel(connmgr.acceptor);
-}
-
-int connmgr_comp_init(enum comp_id             id,
-                      const struct conn_info * info)
-{
-        struct comp * comp;
-
-        assert(id >= 0 && id < COMPID_MAX);
-
-        comp = connmgr.comps + id;
+#include <ouroboros/ipcp.h>
 
-        if (pthread_mutex_init(&comp->lock, NULL))
-                return -1;
+#define BUILD_IPCP_UNICAST
 
-        if (pthread_cond_init(&comp->cond, NULL)) {
-                pthread_mutex_destroy(&comp->lock);
-                return -1;
-        }
-
-        list_head_init(&comp->conns);
-        list_head_init(&comp->pending);
-
-        memcpy(&connmgr.comps[id].info, info, sizeof(connmgr.comps[id].info));
-
-        return 0;
-}
-
-void connmgr_comp_fini(enum comp_id id)
-{
-        struct list_head * p;
-        struct list_head * h;
-        struct comp *      comp;
-
-        assert(id >= 0 && id < COMPID_MAX);
-
-        if (strlen(connmgr.comps[id].info.comp_name) == 0)
-                return;
-
-        comp = connmgr.comps + id;
-
-        pthread_mutex_lock(&comp->lock);
-
-        list_for_each_safe(p, h, &comp->conns) {
-                struct conn_el * e = list_entry(p, struct conn_el, next);
-                list_del(&e->next);
-                free(e);
-        }
-
-        list_for_each_safe(p, h, &comp->pending) {
-                struct conn_el * e = list_entry(p, struct conn_el, next);
-                list_del(&e->next);
-                free(e);
-        }
-
-        pthread_mutex_unlock(&comp->lock);
-
-        pthread_cond_destroy(&comp->cond);
-        pthread_mutex_destroy(&comp->lock);
-
-        memset(&connmgr.comps[id].info, 0, sizeof(connmgr.comps[id].info));
-}
-
-int connmgr_ipcp_connect(const char * dst,
-                         const char * component,
-                         qosspec_t    qs)
-{
-        struct conn_el * ce;
-        int              id;
-
-        assert(dst);
-        assert(component);
-
-        ce = malloc(sizeof(*ce));
-        if (ce == NULL) {
-                log_dbg("Out of memory.");
-                return -1;
-        }
-
-        id = get_id_by_name(component);
-        if (id < 0) {
-                log_dbg("No such component: %s", component);
-                free(ce);
-                return -1;
-        }
-
-        if (connmgr_alloc(id, dst, &qs, &ce->conn)) {
-                free(ce);
-                return -1;
-        }
-
-        if (strlen(dst) > DST_MAX_STRLEN) {
-                log_warn("Truncating dst length for connection.");
-                memcpy(ce->conn.flow_info.dst, dst, DST_MAX_STRLEN);
-                ce->conn.flow_info.dst[DST_MAX_STRLEN] = '\0';
-        } else {
-                strcpy(ce->conn.flow_info.dst, dst);
-        }
-
-        pthread_mutex_lock(&connmgr.comps[id].lock);
-
-        list_add(&ce->next, &connmgr.comps[id].conns);
-
-        pthread_mutex_unlock(&connmgr.comps[id].lock);
-
-        return 0;
-}
-
-int connmgr_ipcp_disconnect(const char * dst,
-                            const char * component)
-{
-        struct list_head * p;
-        struct list_head * h;
-        int                id;
-
-        assert(dst);
-        assert(component);
-
-        id = get_id_by_name(component);
-        if (id < 0)
-                return -1;
-
-        pthread_mutex_lock(&connmgr.comps[id].lock);
-
-        list_for_each_safe(p,h, &connmgr.comps[id].conns) {
-                struct conn_el * el = list_entry(p, struct conn_el, next);
-                if (strcmp(el->conn.flow_info.dst, dst) == 0) {
-                        int ret;
-                        pthread_mutex_unlock(&connmgr.comps[id].lock);
-                        list_del(&el->next);
-                        ret = connmgr_dealloc(id, &el->conn);
-                        free(el);
-                        return ret;
-                }
-        }
-
-        pthread_mutex_unlock(&connmgr.comps[id].lock);
-
-        return 0;
-}
-
-int connmgr_alloc(enum comp_id  id,
-                  const char *  dst,
-                  qosspec_t *   qs,
-                  struct conn * conn)
-{
-        assert(id >= 0 && id < COMPID_MAX);
-        assert(dst);
-
-        conn->flow_info.fd = flow_alloc(dst, qs, NULL);
-        if (conn->flow_info.fd < 0) {
-                log_dbg("Failed to allocate flow to %s.", dst);
-                return -1;
-        }
-
-        if (qs != NULL)
-                conn->flow_info.qs = *qs;
-        else
-                memset(&conn->flow_info.qs, 0, sizeof(conn->flow_info.qs));
-
-        log_dbg("Sending cacep info for protocol %s to fd %d.",
-                connmgr.comps[id].info.protocol, conn->flow_info.fd);
-
-        if (cacep_snd(conn->flow_info.fd, &connmgr.comps[id].info)) {
-                log_dbg("Failed to create application connection.");
-                flow_dealloc(conn->flow_info.fd);
-                return -1;
-        }
-
-        if (cacep_rcv(conn->flow_info.fd, &conn->conn_info)) {
-                log_dbg("Failed to connect to application.");
-                flow_dealloc(conn->flow_info.fd);
-                return -1;
-        }
-
-        if (strcmp(connmgr.comps[id].info.protocol, conn->conn_info.protocol)) {
-                log_dbg("Unknown protocol (requested %s, got %s).",
-                        connmgr.comps[id].info.protocol,
-                        conn->conn_info.protocol);
-                flow_dealloc(conn->flow_info.fd);
-                return -1;
-        }
-
-        if (connmgr.comps[id].info.pref_version !=
-            conn->conn_info.pref_version) {
-                log_dbg("Unknown protocol version.");
-                flow_dealloc(conn->flow_info.fd);
-                return -1;
-        }
-
-        if (connmgr.comps[id].info.pref_syntax != conn->conn_info.pref_syntax) {
-                log_dbg("Unknown protocol syntax.");
-                flow_dealloc(conn->flow_info.fd);
-                return -1;
-        }
-
-        switch (id) {
-        case COMPID_DT:
-                notifier_event(NOTIFY_DT_CONN_ADD, conn);
 #ifdef IPCP_CONN_WAIT_DIR
-                dir_wait_running();
+ #include "dir.h"
 #endif
-                break;
-        case COMPID_MGMT:
-                notifier_event(NOTIFY_MGMT_CONN_ADD, conn);
-                break;
-        default:
-                break;
-        }
-
-        return 0;
-}
-
-int connmgr_dealloc(enum comp_id  id,
-                    struct conn * conn)
-{
-        switch (id) {
-        case COMPID_DT:
-                notifier_event(NOTIFY_DT_CONN_DEL, conn);
-                break;
-        case COMPID_MGMT:
-                notifier_event(NOTIFY_MGMT_CONN_DEL, conn);
-                break;
-        default:
-                break;
-        }
-
-        return flow_dealloc(conn->flow_info.fd);
-}
-
-
-int connmgr_wait(enum comp_id  id,
-                 struct conn * conn)
-{
-        struct conn_el * el;
-        struct comp *    comp;
-
-        assert(id >= 0 && id < COMPID_MAX);
-        assert(conn);
-
-        comp = connmgr.comps + id;
-
-        pthread_mutex_lock(&comp->lock);
-
-        pthread_cleanup_push((void(*)(void *))pthread_mutex_unlock,
-                             (void *) &comp->lock);
-
-        while (list_is_empty(&comp->pending))
-                pthread_cond_wait(&comp->cond, &comp->lock);
-
-        pthread_cleanup_pop(false);
-
-        el = list_first_entry((&comp->pending), struct conn_el, next);
-        if (el == NULL) {
-                pthread_mutex_unlock(&comp->lock);
-                return -1;
-        }
-
-        *conn = el->conn;
-
-        list_del(&el->next);
-        list_add(&el->next, &connmgr.comps[id].conns);
-
-        pthread_mutex_unlock(&comp->lock);
 
-        return 0;
-}
+#include "common/connmgr.c"
diff --git a/src/ipcpd/unicast/connmgr.h b/src/ipcpd/unicast/connmgr.h
deleted file mode 100644
index 17f78245..00000000
--- a/src/ipcpd/unicast/connmgr.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Ouroboros - Copyright (C) 2016 - 2020
- *
- * Handles the different AP connections
- *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
- *
- * 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/.
- */
-
-#ifndef OUROBOROS_IPCPD_UNICAST_CONNMGR_H
-#define OUROBOROS_IPCPD_UNICAST_CONNMGR_H
-
-#include <ouroboros/cacep.h>
-#include <ouroboros/qos.h>
-
-#include "comp.h"
-
-#define NOTIFY_DT_CONN_ADD     0x00D0
-#define NOTIFY_DT_CONN_DEL     0x00D1
-#define NOTIFY_DT_CONN_QOS     0x00D2
-#define NOTIFY_DT_CONN_UP      0x00D3
-#define NOTIFY_DT_CONN_DOWN    0x00D4
-#define NOTIFY_DT_FLOW_UP      0x00D5
-#define NOTIFY_DT_FLOW_DOWN    0x00D6
-#define NOTIFY_DT_FLOW_DEALLOC 0x00D7
-
-#define NOTIFY_MGMT_CONN_ADD   0x00F0
-#define NOTIFY_MGMT_CONN_DEL   0x00F1
-
-int         connmgr_init(void);
-
-void        connmgr_fini(void);
-
-int         connmgr_start(void);
-
-void        connmgr_stop(void);
-
-int         connmgr_comp_init(enum comp_id             id,
-                              const struct conn_info * info);
-
-void        connmgr_comp_fini(enum comp_id id);
-
-int         connmgr_ipcp_connect(const char * dst,
-                                 const char * component,
-                                 qosspec_t    qs);
-
-int         connmgr_ipcp_disconnect(const char * dst,
-                                    const char * component);
-
-int         connmgr_alloc(enum comp_id  id,
-                          const char *  dst,
-                          qosspec_t *   qs,
-                          struct conn * conn);
-
-int         connmgr_dealloc(enum comp_id  id,
-                            struct conn * conn);
-
-int         connmgr_wait(enum comp_id  id,
-                         struct conn * conn);
-
-#endif /* OUROBOROS_IPCPD_UNICAST_CONNMGR_H */
diff --git a/src/ipcpd/unicast/dht.h b/src/ipcpd/unicast/dht.h
deleted file mode 100644
index 39dfc07e..00000000
--- a/src/ipcpd/unicast/dht.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Ouroboros - Copyright (C) 2016 - 2020
- *
- * Distributed Hash Table based on Kademlia
- *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
- *
- * 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/.
- */
-
-#ifndef OUROBOROS_IPCPD_UNICAST_DHT_H
-#define OUROBOROS_IPCPD_UNICAST_DHT_H
-
-#include <ouroboros/ipcp-dev.h>
-
-#include <stdint.h>
-#include <sys/types.h>
-
-struct dht;
-
-struct dht * dht_create(uint64_t addr);
-
-int          dht_bootstrap(struct dht * dht,
-                           size_t       b,
-                           time_t       t_expire);
-
-void         dht_destroy(struct dht * dht);
-
-int          dht_reg(struct dht *    dht,
-                     const uint8_t * key);
-
-int          dht_unreg(struct dht *    dht,
-                       const uint8_t * key);
-
-uint64_t     dht_query(struct dht *    dht,
-                       const uint8_t * key);
-
-int          dht_wait_running(struct dht * dht);
-
-#endif /* OUROBOROS_IPCPD_UNICAST_DHT_H */
diff --git a/src/ipcpd/unicast/dir.c b/src/ipcpd/unicast/dir.c
index 43ee94f0..e0cb09fc 100644
--- a/src/ipcpd/unicast/dir.c
+++ b/src/ipcpd/unicast/dir.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
- * Directory
+ * Directory Management
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -34,8 +34,7 @@
 #include <ouroboros/utils.h>
 
 #include "dir.h"
-#include "dht.h"
-#include "ipcp.h"
+#include "dir/pol.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -43,59 +42,52 @@
 #include <inttypes.h>
 #include <limits.h>
 
-#define KAD_B (hash_len(ipcpi.dir_hash_algo) * CHAR_BIT)
-
-struct dht * dht;
+struct {
+        struct dir_ops * ops;
+        void *           dir;
+} dirmgr;
 
 int dir_init(void)
 {
-        dht = dht_create(ipcpi.dt_addr);
-        if (dht == NULL)
+        dirmgr.ops = &dht_dir_ops;
+
+        dirmgr.dir = dirmgr.ops->create();
+        if (dirmgr.dir == NULL) {
+                dirmgr.ops = NULL;
                 return -ENOMEM;
+        }
 
         return 0;
 }
 
 void dir_fini(void)
 {
-        dht_destroy(dht);
+        dirmgr.ops->destroy(dirmgr.dir);
+        dirmgr.ops = NULL;
+        dirmgr.dir = NULL;
 }
 
-int dir_bootstrap(void) {
-        log_dbg("Bootstrapping directory.");
-
-        /* TODO: get parameters for bootstrap from IRM tool. */
-        if (dht_bootstrap(dht, KAD_B, 86400)) {
-                dht_destroy(dht);
-                return -ENOMEM;
-        }
-
-        log_info("Directory bootstrapped.");
-
-        return 0;
+int dir_bootstrap(void)
+{
+        return dirmgr.ops->bootstrap(dirmgr.dir);
 }
 
 int dir_reg(const uint8_t * hash)
 {
-        return dht_reg(dht, hash);
+        return dirmgr.ops->reg(dirmgr.dir, hash);
 }
 
 int dir_unreg(const uint8_t * hash)
 {
-        return dht_unreg(dht, hash);
+        return dirmgr.ops->unreg(dirmgr.dir, hash);
 }
 
 uint64_t dir_query(const uint8_t * hash)
 {
-        return dht_query(dht, hash);
+        return dirmgr.ops->query(dirmgr.dir, hash);
 }
 
 int dir_wait_running(void)
 {
-        if (dht_wait_running(dht)) {
-                log_warn("Directory did not bootstrap.");
-                return -1;
-        }
-
-        return 0;
+        return dirmgr.ops->wait_running(dirmgr.dir);
 }
diff --git a/src/ipcpd/unicast/dir.h b/src/ipcpd/unicast/dir.h
index 1b67a08c..b261ea2c 100644
--- a/src/ipcpd/unicast/dir.h
+++ b/src/ipcpd/unicast/dir.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Directory
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -23,6 +23,8 @@
 #ifndef OUROBOROS_IPCPD_UNICAST_DIR_H
 #define OUROBOROS_IPCPD_UNICAST_DIR_H
 
+#include <inttypes.h>
+
 int      dir_init(void);
 
 void     dir_fini(void);
diff --git a/src/ipcpd/unicast/dht.c b/src/ipcpd/unicast/dir/dht.c
index 8555312e..08a5a5a9 100644
--- a/src/ipcpd/unicast/dht.c
+++ b/src/ipcpd/unicast/dir/dht.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Distributed Hash Table based on Kademlia
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
@@ -31,6 +31,7 @@
 #define DHT              "dht"
 #define OUROBOROS_PREFIX DHT
 
+#include <ouroboros/endian.h>
 #include <ouroboros/hash.h>
 #include <ouroboros/ipcp-dev.h>
 #include <ouroboros/bitmap.h>
@@ -39,24 +40,26 @@
 #include <ouroboros/list.h>
 #include <ouroboros/notifier.h>
 #include <ouroboros/random.h>
-#include <ouroboros/time_utils.h>
+#include <ouroboros/time.h>
 #include <ouroboros/tpm.h>
 #include <ouroboros/utils.h>
+#include <ouroboros/pthread.h>
 
-#include "connmgr.h"
+#include "common/connmgr.h"
 #include "dht.h"
 #include "dt.h"
+#include "ipcp.h"
+#include "ops.h"
 
-#include <pthread.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include <inttypes.h>
 #include <limits.h>
 
-#include "kademlia.pb-c.h"
-typedef KadMsg kad_msg_t;
-typedef KadContactMsg kad_contact_msg_t;
+#include "dht.pb-c.h"
+typedef DhtMsg dht_msg_t;
+typedef DhtContactMsg dht_contact_msg_t;
 
 #ifndef CLOCK_REALTIME_COARSE
 #define CLOCK_REALTIME_COARSE CLOCK_REALTIME
@@ -208,6 +211,16 @@ struct cmd {
         struct shm_du_buff * sdb;
 };
 
+struct dir_ops dht_dir_ops = {
+        .create       = dht_create,
+        .destroy      = dht_destroy,
+        .bootstrap    = dht_bootstrap,
+        .reg          = dht_reg,
+        .unreg        = dht_unreg,
+        .query        = dht_query,
+        .wait_running = dht_wait_running
+};
+
 struct dht {
         size_t           alpha;
         size_t           b;
@@ -239,7 +252,7 @@ struct dht {
 
         pthread_rwlock_t lock;
 
-        int              fd;
+        uint64_t         eid;
 
         struct tpm *     tpm;
 
@@ -302,14 +315,16 @@ static int dht_set_state(struct dht *   dht,
         return 0;
 }
 
-int dht_wait_running(struct dht * dht)
+int dht_wait_running(void * dir)
 {
-        int ret = 0;
+        struct dht * dht;
+        int          ret = 0;
+
+        dht = (struct dht *) dir;
 
         pthread_mutex_lock(&dht->mtx);
 
-        pthread_cleanup_push((void *)(void *) pthread_mutex_unlock,
-                             &dht->mtx);
+        pthread_cleanup_push(__cleanup_mutex_unlock, &dht->mtx);
 
         while (dht->state == DHT_JOINING)
                 pthread_cond_wait(&dht->cond, &dht->mtx);
@@ -339,7 +354,7 @@ static uint8_t * create_id(size_t len)
 }
 
 static void kad_req_create(struct dht * dht,
-                           kad_msg_t *  msg,
+                           dht_msg_t *  msg,
                            uint64_t     addr)
 {
         struct kad_req *   req;
@@ -347,14 +362,14 @@ static void kad_req_create(struct dht * dht,
         struct timespec    t;
         size_t             b;
 
+        clock_gettime(CLOCK_REALTIME_COARSE, &t);
+
         req = malloc(sizeof(*req));
         if (req == NULL)
-                return;
+                goto fail_malloc;
 
         list_head_init(&req->next);
 
-        clock_gettime(CLOCK_REALTIME_COARSE, &t);
-
         req->t_exp  = t.tv_sec + KAD_T_RESP;
         req->addr   = addr;
         req->state  = REQ_INIT;
@@ -368,30 +383,22 @@ static void kad_req_create(struct dht * dht,
 
         if (msg->has_key) {
                 req->key = dht_dup_key(msg->key.data, b);
-                if (req->key == NULL) {
-                        free(req);
-                        return;
-                }
+                if (req->key == NULL)
+                        goto fail_dup_key;
         }
 
-        if (pthread_mutex_init(&req->lock, NULL)) {
-                free(req->key);
-                free(req);
-                return;
-        }
+        if (pthread_mutex_init(&req->lock, NULL))
+                goto fail_mutex;
 
-        pthread_condattr_init(&cattr);
+
+        if (pthread_condattr_init(&cattr))
+                goto fail_condattr;
 #ifndef __APPLE__
         pthread_condattr_setclock(&cattr, PTHREAD_COND_CLOCK);
 #endif
 
-        if (pthread_cond_init(&req->cond, &cattr)) {
-                pthread_condattr_destroy(&cattr);
-                pthread_mutex_destroy(&req->lock);
-                free(req->key);
-                free(req);
-                return;
-        }
+        if (pthread_cond_init(&req->cond, &cattr))
+                goto fail_cond_init;
 
         pthread_condattr_destroy(&cattr);
 
@@ -400,6 +407,19 @@ static void kad_req_create(struct dht * dht,
         list_add(&req->next, &dht->requests);
 
         pthread_rwlock_unlock(&dht->lock);
+
+        return;
+
+ fail_cond_init:
+        pthread_condattr_destroy(&cattr);
+ fail_condattr:
+        pthread_mutex_destroy(&req->lock);
+ fail_mutex:
+        free(req->key);
+ fail_dup_key:
+        free(req);
+ fail_malloc:
+        return;
 }
 
 static void cancel_req_destroy(void * o)
@@ -429,7 +449,7 @@ static void kad_req_destroy(struct kad_req * req)
                 return;
         case REQ_PENDING:
                 req->state = REQ_DESTROY;
-                pthread_cond_signal(&req->cond);
+                pthread_cond_broadcast(&req->cond);
                 break;
         case REQ_INIT:
         case REQ_DONE:
@@ -452,12 +472,14 @@ static void kad_req_destroy(struct kad_req * req)
 static int kad_req_wait(struct kad_req * req,
                         time_t           t)
 {
-        struct timespec timeo = {t, 0};
+        struct timespec timeo = TIMESPEC_INIT_S(0);
         struct timespec abs;
         int ret = 0;
 
         assert(req);
 
+        timeo.tv_sec = t;
+
         clock_gettime(PTHREAD_COND_CLOCK, &abs);
 
         ts_add(&abs, &timeo, &abs);
@@ -466,8 +488,7 @@ static int kad_req_wait(struct kad_req * req,
 
         req->state = REQ_PENDING;
 
-        pthread_cleanup_push((void *)(void *) pthread_mutex_unlock,
-                             &req->lock);
+        pthread_cleanup_push(__cleanup_mutex_unlock, &req->lock);
 
         while (req->state == REQ_PENDING && ret != -ETIMEDOUT)
                 ret = -pthread_cond_timedwait(&req->cond, &req->lock, &abs);
@@ -774,7 +795,7 @@ static void lookup_destroy(struct lookup * lu)
 
 static void lookup_update(struct dht *    dht,
                           struct lookup * lu,
-                          kad_msg_t *     msg)
+                          dht_msg_t *     msg)
 {
         struct list_head * p = NULL;
         struct list_head * h;
@@ -819,8 +840,7 @@ static void lookup_update(struct dht *    dht,
                 return;
         }
 
-        pthread_cleanup_push((void *)(void *) pthread_mutex_unlock,
-                             &lu->lock);
+        pthread_cleanup_push(__cleanup_mutex_unlock, &lu->lock);
 
         while (lu->state == LU_INIT) {
                 pthread_rwlock_unlock(&dht->lock);
@@ -967,7 +987,7 @@ static void lookup_set_state(struct lookup *   lu,
         pthread_mutex_unlock(&lu->lock);
 }
 
-static void cleanup_wait(void * o)
+static void cancel_lookup_wait(void * o)
 {
         struct lookup * lu = (struct lookup *) o;
         lu->state = LU_NULL;
@@ -977,7 +997,7 @@ static void cleanup_wait(void * o)
 
 static enum lookup_state lookup_wait(struct lookup * lu)
 {
-        struct timespec   timeo = {KAD_T_RESP, 0};
+        struct timespec   timeo = TIMESPEC_INIT_S(KAD_T_RESP);
         struct timespec   abs;
         enum lookup_state state;
         int               ret = 0;
@@ -991,7 +1011,7 @@ static enum lookup_state lookup_wait(struct lookup * lu)
         if (lu->state == LU_INIT || lu->state == LU_UPDATE)
                 lu->state = LU_PENDING;
 
-        pthread_cleanup_push(cleanup_wait, lu);
+        pthread_cleanup_push(cancel_lookup_wait, lu);
 
         while (lu->state == LU_PENDING && ret != -ETIMEDOUT)
                 ret = -pthread_cond_timedwait(&lu->cond, &lu->lock, &abs);
@@ -1009,7 +1029,7 @@ static enum lookup_state lookup_wait(struct lookup * lu)
 }
 
 static struct kad_req * dht_find_request(struct dht * dht,
-                                         kad_msg_t *  msg)
+                                         dht_msg_t *  msg)
 {
         struct list_head * p;
 
@@ -1257,7 +1277,7 @@ static void bucket_refresh(struct dht *       dht,
                 struct contact * d;
                 c = list_first_entry(&b->contacts, struct contact, next);
                 d = contact_create(c->id, dht->b, c->addr);
-                if (c != NULL)
+                if (d != NULL)
                         list_add(&d->next, r);
                 return;
         }
@@ -1446,7 +1466,7 @@ static int dht_update_bucket(struct dht *    dht,
 }
 
 static int send_msg(struct dht * dht,
-                    kad_msg_t *  msg,
+                    dht_msg_t *  msg,
                     uint64_t     addr)
 {
 #ifndef __DHT_TEST__
@@ -1479,7 +1499,7 @@ static int send_msg(struct dht * dht,
         pthread_rwlock_unlock(&dht->lock);
 
 #ifndef __DHT_TEST__
-        len = kad_msg__get_packed_size(msg);
+        len = dht_msg__get_packed_size(msg);
         if (len == 0)
                 goto fail_msg;
 
@@ -1487,9 +1507,9 @@ static int send_msg(struct dht * dht,
                 if (ipcp_sdb_reserve(&sdb, len))
                         goto fail_msg;
 
-                kad_msg__pack(msg, shm_du_buff_head(sdb));
+                dht_msg__pack(msg, shm_du_buff_head(sdb));
 
-                if (dt_write_packet(addr, QOS_CUBE_BE, dht->fd, sdb) == 0)
+                if (dt_write_packet(addr, QOS_CUBE_BE, dht->eid, sdb) == 0)
                         break;
 
                 ipcp_sdb_release(sdb);
@@ -1534,7 +1554,7 @@ static struct dht_entry * dht_find_entry(struct dht *    dht,
 }
 
 static int kad_add(struct dht *              dht,
-                   const kad_contact_msg_t * contacts,
+                   const dht_contact_msg_t * contacts,
                    ssize_t                   n,
                    time_t                    exp)
 {
@@ -1573,7 +1593,7 @@ static int kad_add(struct dht *              dht,
 }
 
 static int wait_resp(struct dht * dht,
-                     kad_msg_t *  msg,
+                     dht_msg_t *  msg,
                      time_t       timeo)
 {
         struct kad_req * req;
@@ -1600,9 +1620,9 @@ static int kad_store(struct dht *    dht,
                      uint64_t        r_addr,
                      time_t          ttl)
 {
-        kad_msg_t msg = KAD_MSG__INIT;
-        kad_contact_msg_t cmsg = KAD_CONTACT_MSG__INIT;
-        kad_contact_msg_t * cmsgp[1];
+        dht_msg_t msg = DHT_MSG__INIT;
+        dht_contact_msg_t cmsg = DHT_CONTACT_MSG__INIT;
+        dht_contact_msg_t * cmsgp[1];
 
         cmsg.id.data = (uint8_t *) key;
         cmsg.addr    = addr;
@@ -1632,7 +1652,7 @@ static ssize_t kad_find(struct dht *     dht,
                         const uint64_t * addrs,
                         enum kad_code    code)
 {
-        kad_msg_t msg  = KAD_MSG__INIT;
+        dht_msg_t msg  = DHT_MSG__INIT;
         ssize_t   sent = 0;
 
         assert(dht);
@@ -1729,7 +1749,7 @@ static struct lookup * kad_lookup(struct dht *    dht,
                 }
         }
 
-        assert(state = LU_COMPLETE);
+        assert(state == LU_COMPLETE);
 
         lookup_detach(dht, lu);
 
@@ -1772,7 +1792,7 @@ static void kad_publish(struct dht *    dht,
 
         while (n-- > 0) {
                 if (addrs[n] == dht->addr) {
-                        kad_contact_msg_t msg = KAD_CONTACT_MSG__INIT;
+                        dht_contact_msg_t msg = DHT_CONTACT_MSG__INIT;
                         msg.id.data = (uint8_t *) key;
                         msg.id.len  = dht->b;
                         msg.addr    = addr;
@@ -1791,7 +1811,7 @@ static void kad_publish(struct dht *    dht,
 static int kad_join(struct dht * dht,
                     uint64_t     addr)
 {
-        kad_msg_t       msg = KAD_MSG__INIT;
+        dht_msg_t       msg = DHT_MSG__INIT;
 
         msg.code = KAD_JOIN;
 
@@ -1871,18 +1891,13 @@ static int dht_del(struct dht *    dht,
 {
         struct dht_entry * e;
 
-        pthread_rwlock_wrlock(&dht->lock);
-
         e = dht_find_entry(dht, key);
         if (e == NULL) {
-                pthread_rwlock_unlock(&dht->lock);
                 return -EPERM;
         }
 
         dht_entry_del_addr(e, addr);
 
-        pthread_rwlock_unlock(&dht->lock);
-
         return 0;
 }
 
@@ -1924,14 +1939,14 @@ static buffer_t dht_retrieve(struct dht *    dht,
 
  fail:
         pthread_rwlock_unlock(&dht->lock);
-        buf.len = 0;
-
+        buf.len  = 0;
+        buf.data = NULL;
         return buf;
 }
 
 static ssize_t dht_get_contacts(struct dht *          dht,
                                 const uint8_t *       key,
-                                kad_contact_msg_t *** msgs)
+                                dht_contact_msg_t *** msgs)
 {
         struct list_head   l;
         struct list_head * p;
@@ -1946,6 +1961,7 @@ static ssize_t dht_get_contacts(struct dht *          dht,
         len = dht_contact_list(dht, &l, key);
         if (len == 0) {
                 pthread_rwlock_unlock(&dht->lock);
+                *msgs = NULL;
                 return 0;
         }
 
@@ -1963,10 +1979,11 @@ static ssize_t dht_get_contacts(struct dht *          dht,
                         while (i > 0)
                                 free(*msgs[--i]);
                         free(*msgs);
+                        *msgs = NULL;
                         return 0;
                 }
 
-                kad_contact_msg__init((*msgs)[i]);
+                dht_contact_msg__init((*msgs)[i]);
 
                 (*msgs)[i]->id.data = c->id;
                 (*msgs)[i]->id.len  = dht->b;
@@ -2103,7 +2120,7 @@ static void * work(void * o)
 
 static int kad_handle_join_resp(struct dht *     dht,
                                 struct kad_req * req,
-                                kad_msg_t *      msg)
+                                dht_msg_t *      msg)
 {
         assert(dht);
         assert(req);
@@ -2163,7 +2180,7 @@ static int kad_handle_join_resp(struct dht *     dht,
 
 static int kad_handle_find_resp(struct dht *     dht,
                                 struct kad_req * req,
-                                kad_msg_t *      msg)
+                                dht_msg_t *      msg)
 {
         struct lookup * lu;
 
@@ -2187,7 +2204,7 @@ static int kad_handle_find_resp(struct dht *     dht,
 }
 
 static void kad_handle_response(struct dht * dht,
-                                kad_msg_t *  msg)
+                                dht_msg_t *  msg)
 {
         struct kad_req * req;
 
@@ -2225,15 +2242,23 @@ static void kad_handle_response(struct dht * dht,
         kad_req_destroy(req);
 }
 
-int dht_bootstrap(struct dht * dht,
-                  size_t       b,
-                  time_t       t_expire)
+int dht_bootstrap(void * dir)
 {
+        struct dht * dht;
+
+        dht = (struct dht *) dir;
+
         assert(dht);
 
         pthread_rwlock_wrlock(&dht->lock);
 
-        dht->id = create_id(b);
+#ifndef __DHT_TEST__
+        dht->b        = hash_len(ipcpi.dir_hash_algo);
+#else
+        dht->b        = DHT_TEST_KEY_LEN;
+#endif
+
+        dht->id = create_id(dht->b);
         if (dht->id == NULL)
                 goto fail_id;
 
@@ -2244,9 +2269,8 @@ int dht_bootstrap(struct dht * dht,
         dht->buckets->depth = 0;
         dht->buckets->mask  = 0;
 
-        dht->b        = b / CHAR_BIT;
-        dht->t_expire = MAX(2, t_expire);
-        dht->t_repub  = MAX(1, t_expire - 10);
+        dht->t_expire = 86400; /* 1 day */
+        dht->t_repub  = dht->t_expire - 10;
         dht->k        = KAD_K;
 
         if (pthread_create(&dht->worker, NULL, work, dht))
@@ -2285,13 +2309,16 @@ static struct ref_entry * ref_entry_get(struct dht *    dht,
         return NULL;
 }
 
-int dht_reg(struct dht *    dht,
+int dht_reg(void *          dir,
             const uint8_t * key)
 {
+        struct dht *       dht;
         struct ref_entry * e;
         uint64_t           addr;
         time_t             t_expire;
 
+        dht = (struct dht *) dir;
+
         assert(dht);
         assert(key);
         assert(dht->addr != 0);
@@ -2325,12 +2352,15 @@ int dht_reg(struct dht *    dht,
         return 0;
 }
 
-int dht_unreg(struct dht *    dht,
+int dht_unreg(void *          dir,
               const uint8_t * key)
 {
+        struct dht *       dht;
         struct list_head * p;
         struct list_head * h;
 
+        dht = (struct dht *) dir;
+
         assert(dht);
         assert(key);
 
@@ -2354,14 +2384,19 @@ int dht_unreg(struct dht *    dht,
         return 0;
 }
 
-uint64_t dht_query(struct dht *    dht,
+uint64_t dht_query(void *          dir,
                    const uint8_t * key)
 {
+        struct dht *       dht;
         struct dht_entry * e;
         struct lookup *    lu;
         uint64_t           addrs[KAD_K];
         size_t             n;
 
+        dht = (struct dht *) dir;
+
+        assert(dht);
+
         addrs[0] = 0;
 
         if (dht_wait_running(dht))
@@ -2407,9 +2442,9 @@ static void * dht_handle_packet(void * o)
         assert(dht);
 
         while (true) {
-                kad_msg_t *          msg;
-                kad_contact_msg_t ** cmsgs;
-                kad_msg_t            resp_msg = KAD_MSG__INIT;
+                dht_msg_t *          msg;
+                dht_contact_msg_t ** cmsgs;
+                dht_msg_t            resp_msg = DHT_MSG__INIT;
                 uint64_t             addr;
                 buffer_t             buf;
                 size_t               i;
@@ -2419,8 +2454,7 @@ static void * dht_handle_packet(void * o)
 
                 pthread_mutex_lock(&dht->mtx);
 
-                pthread_cleanup_push((void *)(void *) pthread_mutex_unlock,
-                                     &dht->mtx);
+                pthread_cleanup_push(__cleanup_mutex_unlock, &dht->mtx);
 
                 while (list_is_empty(&dht->cmds))
                         pthread_cond_wait(&dht->cond, &dht->mtx);
@@ -2430,9 +2464,9 @@ static void * dht_handle_packet(void * o)
 
                 pthread_cleanup_pop(true);
 
-                i = shm_du_buff_tail(cmd->sdb) - shm_du_buff_head(cmd->sdb);
+                i = shm_du_buff_len(cmd->sdb);
 
-                msg = kad_msg__unpack(NULL, i, shm_du_buff_head(cmd->sdb));
+                msg = dht_msg__unpack(NULL, i, shm_du_buff_head(cmd->sdb));
 #ifndef __DHT_TEST__
                 ipcp_sdb_release(cmd->sdb);
 #endif
@@ -2444,7 +2478,7 @@ static void * dht_handle_packet(void * o)
                 }
 
                 if (msg->code != KAD_RESPONSE && dht_wait_running(dht)) {
-                        kad_msg__free_unpacked(msg, NULL);
+                        dht_msg__free_unpacked(msg, NULL);
                         log_dbg("Got a request message when not running.");
                         continue;
                 }
@@ -2457,13 +2491,13 @@ static void * dht_handle_packet(void * o)
                 pthread_rwlock_unlock(&dht->lock);
 
                 if (msg->has_key && msg->key.len != b) {
-                        kad_msg__free_unpacked(msg, NULL);
+                        dht_msg__free_unpacked(msg, NULL);
                         log_warn("Bad key in message.");
                         continue;
                 }
 
                 if (msg->has_s_id && !msg->has_b && msg->s_id.len != b) {
-                        kad_msg__free_unpacked(msg, NULL);
+                        dht_msg__free_unpacked(msg, NULL);
                         log_warn("Bad source ID in message of type %d.",
                                  msg->code);
                         continue;
@@ -2552,7 +2586,7 @@ static void * dht_handle_packet(void * o)
                         if (dht_get_state(dht) == DHT_JOINING &&
                             dht->buckets == NULL) {
                                 pthread_rwlock_unlock(&dht->lock);
-                                break;
+                                goto finish;
                         }
 
                         if (dht_update_bucket(dht, msg->s_id.data, addr))
@@ -2563,7 +2597,8 @@ static void * dht_handle_packet(void * o)
                 if (msg->code < KAD_STORE && send_msg(dht, &resp_msg, addr) < 0)
                                 log_warn("Failed to send response.");
 
-                kad_msg__free_unpacked(msg, NULL);
+ finish:
+                dht_msg__free_unpacked(msg, NULL);
 
                 if (resp_msg.n_addrs > 0)
                         free(resp_msg.addrs);
@@ -2574,7 +2609,7 @@ static void * dht_handle_packet(void * o)
                 }
 
                 for (i = 0; i < resp_msg.n_contacts; ++i)
-                        kad_contact_msg__free_unpacked(resp_msg.contacts[i],
+                        dht_contact_msg__free_unpacked(resp_msg.contacts[i],
                                                        NULL);
                 free(resp_msg.contacts);
 
@@ -2614,11 +2649,13 @@ static void dht_post_packet(void *               comp,
         pthread_mutex_unlock(&dht->mtx);
 }
 
-void dht_destroy(struct dht * dht)
+void dht_destroy(void * dir)
 {
+        struct dht *       dht;
         struct list_head * p;
         struct list_head * h;
 
+        dht = (struct dht *) dir;
         if (dht == NULL)
                 return;
 
@@ -2729,7 +2766,7 @@ static void handle_event(void *       self,
                 pthread_t          thr;
                 struct join_info * inf;
                 struct conn *      c     = (struct conn *) o;
-                struct timespec    slack = {0, DHT_ENROLL_SLACK * MILLION};
+                struct timespec    slack = TIMESPEC_INIT_MS(DHT_ENROLL_SLACK);
 
                 /* Give the pff some time to update for the new link. */
                 nanosleep(&slack, NULL);
@@ -2771,7 +2808,7 @@ static void handle_event(void *       self,
         }
 }
 
-struct dht * dht_create(uint64_t addr)
+void * dht_create(void)
 {
         struct dht * dht;
 
@@ -2801,9 +2838,9 @@ struct dht * dht_create(uint64_t addr)
                 goto fail_bmp;
 
         dht->b    = 0;
-        dht->addr = addr;
         dht->id   = NULL;
 #ifndef __DHT_TEST__
+        dht->addr = ipcpi.dt_addr;
         dht->tpm = tpm_create(2, 1, dht_handle_packet, dht);
         if (dht->tpm == NULL)
                 goto fail_tpm_create;
@@ -2811,8 +2848,12 @@ struct dht * dht_create(uint64_t addr)
         if (tpm_start(dht->tpm))
                 goto fail_tpm_start;
 
-        dht->fd   = dt_reg_comp(dht, &dht_post_packet, DHT);
-        notifier_reg(handle_event, dht);
+        dht->eid   = dt_reg_comp(dht, &dht_post_packet, DHT);
+        if ((int) dht->eid < 0)
+                goto fail_tpm_start;
+
+        if (notifier_reg(handle_event, dht))
+                goto fail_notifier_reg;
 #else
         (void) handle_event;
         (void) dht_handle_packet;
@@ -2820,8 +2861,10 @@ struct dht * dht_create(uint64_t addr)
 #endif
         dht->state = DHT_INIT;
 
-        return dht;
+        return (void *) dht;
 #ifndef __DHT_TEST__
+ fail_notifier_reg:
+        tpm_stop(dht->tpm);
  fail_tpm_start:
         tpm_destroy(dht->tpm);
  fail_tpm_create:
diff --git a/src/ipcpd/unicast/dir/dht.h b/src/ipcpd/unicast/dir/dht.h
new file mode 100644
index 00000000..311c6b23
--- /dev/null
+++ b/src/ipcpd/unicast/dir/dht.h
@@ -0,0 +1,52 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2024
+ *
+ * Distributed Hash Table based on Kademlia
+ *
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
+ *
+ * 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/.
+ */
+
+#ifndef OUROBOROS_IPCPD_UNICAST_DIR_DHT_H
+#define OUROBOROS_IPCPD_UNICAST_DIR_DHT_H
+
+#include <ouroboros/ipcp-dev.h>
+
+#include "ops.h"
+
+#include <stdint.h>
+#include <sys/types.h>
+
+void *   dht_create(void);
+
+void     dht_destroy(void * dir);
+
+int      dht_bootstrap(void * dir);
+
+int      dht_reg(void *          dir,
+                 const uint8_t * key);
+
+int      dht_unreg(void *          dir,
+                   const uint8_t * key);
+
+uint64_t dht_query(void *          dir,
+                   const uint8_t * key);
+
+int      dht_wait_running(void * dir);
+
+extern struct dir_ops dht_dir_ops;
+
+#endif /* OUROBOROS_IPCPD_UNICAST_DIR_DHT_H */
diff --git a/src/ipcpd/unicast/kademlia.proto b/src/ipcpd/unicast/dir/dht.proto
index 4f807fd3..4c5b06db 100644
--- a/src/ipcpd/unicast/kademlia.proto
+++ b/src/ipcpd/unicast/dir/dht.proto
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
- * KAD protocol
+ * DHT protocol, based on Kademlia
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
@@ -22,19 +22,19 @@
 
 syntax = "proto2";
 
-message kad_contact_msg {
+message dht_contact_msg {
         required bytes  id   = 1;
         required uint64 addr = 2;
-};
+}
 
-message kad_msg {
+message dht_msg {
         required uint32 code              =  1;
         required uint32 cookie            =  2;
         required uint64 s_addr            =  3;
         optional bytes  s_id              =  4;
         optional bytes  key               =  5;
         repeated uint64 addrs             =  6;
-        repeated kad_contact_msg contacts =  7;
+        repeated dht_contact_msg contacts =  7;
         // enrolment parameters
         optional uint32 alpha             =  8;
         optional uint32 b                 =  9;
@@ -42,4 +42,4 @@ message kad_msg {
         optional uint32 t_expire          = 11;
         optional uint32 t_refresh         = 12;
         optional uint32 t_replicate       = 13;
-};
\ No newline at end of file
+}
diff --git a/src/ipcpd/unicast/dir/ops.h b/src/ipcpd/unicast/dir/ops.h
new file mode 100644
index 00000000..6ff61ce6
--- /dev/null
+++ b/src/ipcpd/unicast/dir/ops.h
@@ -0,0 +1,46 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2024
+ *
+ * Directory policy ops
+ *
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
+ *
+ * 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/.
+ */
+
+#ifndef OUROBOROS_IPCPD_UNICAST_DIR_OPS_H
+#define OUROBOROS_IPCPD_UNICAST_DIR_OPS_H
+
+
+struct dir_ops {
+        void *   (* create)(void);
+
+        void     (* destroy)(void * dir);
+
+        int      (* bootstrap)(void * dir);
+
+        int      (* reg)(void * dir,
+                         const uint8_t * hash);
+
+        int      (* unreg)(void * dir,
+                           const uint8_t * hash);
+
+        uint64_t (* query)(void * dir,
+                           const uint8_t * hash);
+
+        int      (* wait_running)(void * dir);
+};
+
+#endif /* OUROBOROS_IPCPD_UNICAST_DIR_OPS_H */
diff --git a/src/ipcpd/unicast/dir/pol.h b/src/ipcpd/unicast/dir/pol.h
new file mode 100644
index 00000000..eae4b2e7
--- /dev/null
+++ b/src/ipcpd/unicast/dir/pol.h
@@ -0,0 +1,23 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2024
+ *
+ * Directory policies
+ *
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
+ *
+ * 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/.
+ */
+
+#include "dht.h"
diff --git a/src/ipcpd/unicast/dir/tests/CMakeLists.txt b/src/ipcpd/unicast/dir/tests/CMakeLists.txt
new file mode 100644
index 00000000..f62ed993
--- /dev/null
+++ b/src/ipcpd/unicast/dir/tests/CMakeLists.txt
@@ -0,0 +1,40 @@
+get_filename_component(CURRENT_SOURCE_PARENT_DIR
+  ${CMAKE_CURRENT_SOURCE_DIR} DIRECTORY)
+get_filename_component(CURRENT_BINARY_PARENT_DIR
+  ${CMAKE_CURRENT_BINARY_DIR} DIRECTORY)
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+include_directories(${CURRENT_SOURCE_PARENT_DIR})
+include_directories(${CURRENT_BINARY_PARENT_DIR})
+
+include_directories(${CMAKE_SOURCE_DIR}/include)
+include_directories(${CMAKE_BINARY_DIR}/include)
+
+get_filename_component(PARENT_PATH ${CMAKE_CURRENT_SOURCE_DIR} DIRECTORY)
+get_filename_component(PARENT_DIR ${PARENT_PATH} NAME)
+
+create_test_sourcelist(${PARENT_DIR}_tests test_suite.c
+  # Add new tests here
+  dht_test.c
+  )
+
+protobuf_generate_c(DHT_PROTO_SRCS KAD_PROTO_HDRS ../dht.proto)
+add_executable(${PARENT_DIR}_test EXCLUDE_FROM_ALL ${${PARENT_DIR}_tests}
+  ${DHT_PROTO_SRCS})
+target_link_libraries(${PARENT_DIR}_test ouroboros-common)
+
+add_dependencies(check ${PARENT_DIR}_test)
+
+set(tests_to_run ${${PARENT_DIR}_tests})
+if(CMAKE_VERSION VERSION_LESS "3.29.0")
+  remove(tests_to_run test_suite.c)
+else ()
+  list(POP_FRONT tests_to_run)
+endif()
+
+foreach (test ${tests_to_run})
+  get_filename_component(test_name ${test} NAME_WE)
+  add_test(${test_name} ${C_TEST_PATH}/${PARENT_DIR}_test ${test_name})
+endforeach (test)
diff --git a/src/ipcpd/unicast/tests/dht_test.c b/src/ipcpd/unicast/dir/tests/dht_test.c
index 21ecd564..bea2c3e7 100644
--- a/src/ipcpd/unicast/tests/dht_test.c
+++ b/src/ipcpd/unicast/dir/tests/dht_test.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Unit tests of the DHT
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -21,6 +21,7 @@
  */
 
 #define __DHT_TEST__
+#define DHT_TEST_KEY_LEN  32
 
 #include "dht.c"
 
@@ -29,23 +30,19 @@
 #include <stdlib.h>
 #include <stdio.h>
 
-#define KEY_LEN  32
-
-#define EXP      86400
-#define CONTACTS 1000
+#define CONTACTS          1000
 
 int dht_test(int     argc,
              char ** argv)
 {
         struct dht * dht;
-        uint64_t     addr = 0x0D1F;
-        uint8_t      key[KEY_LEN];
+        uint8_t      key[DHT_TEST_KEY_LEN];
         size_t       i;
 
         (void) argc;
         (void) argv;
 
-        dht = dht_create(addr);
+        dht = dht_create();
         if (dht == NULL) {
                 printf("Failed to create dht.\n");
                 return -1;
@@ -53,13 +50,13 @@ int dht_test(int     argc,
 
         dht_destroy(dht);
 
-        dht = dht_create(addr);
+        dht = dht_create();
         if (dht == NULL) {
                 printf("Failed to re-create dht.\n");
                 return -1;
         }
 
-        if (dht_bootstrap(dht, KEY_LEN, EXP)) {
+        if (dht_bootstrap(dht)) {
                 printf("Failed to bootstrap dht.\n");
                 dht_destroy(dht);
                 return -1;
@@ -67,13 +64,13 @@ int dht_test(int     argc,
 
         dht_destroy(dht);
 
-        dht = dht_create(addr);
+        dht = dht_create();
         if (dht == NULL) {
                 printf("Failed to re-create dht.\n");
                 return -1;
         }
 
-        if (dht_bootstrap(dht, KEY_LEN, EXP)) {
+        if (dht_bootstrap(dht)) {
                 printf("Failed to bootstrap dht.\n");
                 dht_destroy(dht);
                 return -1;
@@ -82,7 +79,7 @@ int dht_test(int     argc,
         for (i = 0; i < CONTACTS; ++i) {
                 uint64_t addr;
                 random_buffer(&addr, sizeof(addr));
-                random_buffer(key, KEY_LEN);
+                random_buffer(key, DHT_TEST_KEY_LEN);
                 pthread_rwlock_wrlock(&dht->lock);
                 if (dht_update_bucket(dht, key, addr)) {
                         pthread_rwlock_unlock(&dht->lock);
diff --git a/src/ipcpd/unicast/dt.c b/src/ipcpd/unicast/dt.c
index d6a3ddc9..2bb5ed2f 100644
--- a/src/ipcpd/unicast/dt.c
+++ b/src/ipcpd/unicast/dt.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Data Transfer Component
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -41,13 +41,14 @@
 #include <ouroboros/fccntl.h>
 #endif
 
-#include "connmgr.h"
+#include "common/comp.h"
+#include "common/connmgr.h"
+#include "ca.h"
 #include "ipcp.h"
 #include "dt.h"
 #include "pff.h"
 #include "routing.h"
 #include "psched.h"
-#include "comp.h"
 #include "fa.h"
 
 #include <stdlib.h>
@@ -57,8 +58,9 @@
 #include <inttypes.h>
 #include <assert.h>
 
-#define QOS_BLOCK_LEN 672
-#define STAT_FILE_LEN (189 + QOS_BLOCK_LEN * QOS_CUBE_MAX)
+#define QOS_BLOCK_LEN   672
+#define RIB_FILE_STRLEN (189 + QOS_BLOCK_LEN * QOS_CUBE_MAX)
+#define RIB_NAME_STRLEN 256
 
 #ifndef CLOCK_REALTIME_COARSE
 #define CLOCK_REALTIME_COARSE CLOCK_REALTIME
@@ -80,7 +82,7 @@ struct dt_pci {
         qoscube_t qc;
         uint8_t   ttl;
         uint8_t   ecn;
-        uint32_t  eid;
+        uint64_t  eid;
 };
 
 struct {
@@ -98,39 +100,29 @@ struct {
         uint8_t         max_ttl;
 } dt_pci_info;
 
-static int dt_pci_ser(struct shm_du_buff * sdb,
-                      struct dt_pci *      dt_pci)
+static void dt_pci_ser(uint8_t *       head,
+                       struct dt_pci * dt_pci)
 {
-        uint8_t * head;
-        uint8_t   ttl = dt_pci_info.max_ttl;
+        uint8_t ttl = dt_pci_info.max_ttl;
 
-        assert(sdb);
+        assert(head);
         assert(dt_pci);
 
-        head = shm_du_buff_head_alloc(sdb, dt_pci_info.head_size);
-        if (head == NULL)
-                return -EPERM;
-
         /* FIXME: Add check and operations for Big Endian machines. */
         memcpy(head, &dt_pci->dst_addr, dt_pci_info.addr_size);
         memcpy(head + dt_pci_info.qc_o, &dt_pci->qc, QOS_LEN);
         memcpy(head + dt_pci_info.ttl_o, &ttl, TTL_LEN);
-        memcpy(head + dt_pci_info.ecn_o,  &dt_pci->ecn, ECN_LEN);
+        memcpy(head + dt_pci_info.ecn_o, &dt_pci->ecn, ECN_LEN);
         memcpy(head + dt_pci_info.eid_o, &dt_pci->eid, dt_pci_info.eid_size);
 
-        return 0;
 }
 
-static void dt_pci_des(struct shm_du_buff * sdb,
-                       struct dt_pci *      dt_pci)
+static void dt_pci_des(uint8_t *       head,
+                       struct dt_pci * dt_pci)
 {
-        uint8_t * head;
-
-        assert(sdb);
+        assert(head);
         assert(dt_pci);
 
-        head = shm_du_buff_head(sdb);
-
         /* Decrease TTL */
         --*(head + dt_pci_info.ttl_o);
 
@@ -184,24 +176,28 @@ struct {
         pthread_t          listener;
 } dt;
 
-static int dt_stat_read(const char * path,
-                        char *       buf,
-                        size_t       len)
+static int dt_rib_read(const char * path,
+                       char *       buf,
+                       size_t       len)
 {
 #ifdef IPCP_FLOW_STATS
         int         fd;
         int         i;
         char        str[QOS_BLOCK_LEN + 1];
         char        addrstr[20];
+        char *      entry;
         char        tmstr[20];
         size_t      rxqlen = 0;
         size_t      txqlen = 0;
         struct tm * tm;
 
         /* NOTE: we may need stronger checks. */
-        fd = atoi(path);
+        entry = strstr(path, RIB_SEPARATOR) + 1;
+        assert(entry);
+
+        fd = atoi(entry);
 
-        if (len < STAT_FILE_LEN)
+        if (len < RIB_FILE_STRLEN)
                 return 0;
 
         buf[0] = '\0';
@@ -232,7 +228,6 @@ static int dt_stat_read(const char * path,
                 "Queued packets (rx):      %20zu\n"
                 "Queued packets (tx):      %20zu\n\n",
                 tmstr, addrstr, rxqlen, txqlen);
-
         for (i = 0; i < QOS_CUBE_MAX; ++i) {
                 sprintf(str,
                         "Qos cube %3d:\n"
@@ -271,7 +266,7 @@ static int dt_stat_read(const char * path,
 
         pthread_mutex_unlock(&dt.stat[fd].lock);
 
-        return STAT_FILE_LEN;
+        return RIB_FILE_STRLEN;
 #else
         (void) path;
         (void) buf;
@@ -280,7 +275,7 @@ static int dt_stat_read(const char * path,
 #endif
 }
 
-static int dt_stat_readdir(char *** buf)
+static int dt_rib_readdir(char *** buf)
 {
 #ifdef IPCP_FLOW_STATS
         char   entry[RIB_PATH_LEN + 1];
@@ -317,7 +312,7 @@ static int dt_stat_readdir(char *** buf)
                 if ((*buf)[idx] == NULL) {
                         while (idx-- > 0)
                                 free((*buf)[idx]);
-                        free(buf);
+                        free(*buf);
                         pthread_mutex_unlock(&dt.stat[i].lock);
                         pthread_rwlock_unlock(&dt.lock);
                         return -ENOMEM;
@@ -327,11 +322,10 @@ static int dt_stat_readdir(char *** buf)
 
                 pthread_mutex_unlock(&dt.stat[i].lock);
         }
+        assert((size_t) idx == dt.n_flows);
 
         pthread_rwlock_unlock(&dt.lock);
 
-        assert((size_t) idx == dt.n_flows);
-
         return idx;
 #else
         (void) buf;
@@ -339,45 +333,43 @@ static int dt_stat_readdir(char *** buf)
 #endif
 }
 
-static int dt_stat_getattr(const char *  path,
-                           struct stat * st)
+static int dt_rib_getattr(const char *      path,
+                          struct rib_attr * attr)
 {
 #ifdef IPCP_FLOW_STATS
-        int fd;
+        int    fd;
+        char * entry;
 
-        fd = atoi(path);
+        entry = strstr(path, RIB_SEPARATOR) + 1;
+        assert(entry);
 
-        st->st_mode  = S_IFREG | 0755;
-        st->st_nlink = 1;
-        st->st_uid   = getuid();
-        st->st_gid   = getgid();
+        fd = atoi(entry);
 
         pthread_mutex_lock(&dt.stat[fd].lock);
 
         if (dt.stat[fd].stamp != -1) {
-                st->st_size  = STAT_FILE_LEN;
-                st->st_mtime = dt.stat[fd].stamp;
+                attr->size  = RIB_FILE_STRLEN;
+                attr->mtime = dt.stat[fd].stamp;
         } else {
-                st->st_size  = 0;
-                st->st_mtime = 0;
+                attr->size  = 0;
+                attr->mtime = 0;
         }
 
         pthread_mutex_unlock(&dt.stat[fd].lock);
 #else
         (void) path;
-        (void) st;
+        (void) attr;
 #endif
         return 0;
 }
 
 static struct rib_ops r_ops = {
-        .read    = dt_stat_read,
-        .readdir = dt_stat_readdir,
-        .getattr = dt_stat_getattr
+        .read    = dt_rib_read,
+        .readdir = dt_rib_readdir,
+        .getattr = dt_rib_getattr
 };
 
 #ifdef IPCP_FLOW_STATS
-
 static void stat_used(int      fd,
                       uint64_t addr)
 {
@@ -407,6 +399,7 @@ static void handle_event(void *       self,
                          const void * o)
 {
         struct conn * c;
+        int           fd;
 
         (void) self;
 
@@ -414,19 +407,20 @@ static void handle_event(void *       self,
 
         switch (event) {
         case NOTIFY_DT_CONN_ADD:
+                fd = c->flow_info.fd;
 #ifdef IPCP_FLOW_STATS
-                stat_used(c->flow_info.fd, c->conn_info.addr);
+                stat_used(fd, c->conn_info.addr);
 #endif
-                psched_add(dt.psched, c->flow_info.fd);
-                log_dbg("Added fd %d to packet scheduler.", c->flow_info.fd);
+                psched_add(dt.psched, fd);
+                log_dbg("Added fd %d to packet scheduler.", fd);
                 break;
         case NOTIFY_DT_CONN_DEL:
+                fd = c->flow_info.fd;
 #ifdef IPCP_FLOW_STATS
-                stat_used(c->flow_info.fd, INVALID_ADDR);
+                stat_used(fd, INVALID_ADDR);
 #endif
-                psched_del(dt.psched, c->flow_info.fd);
-                log_dbg("Removed fd %d from "
-                        "packet scheduler.", c->flow_info.fd);
+                psched_del(dt.psched, fd);
+                log_dbg("Removed fd %d from packet scheduler.", fd);
                 break;
         default:
                 break;
@@ -440,17 +434,26 @@ static void packet_handler(int                  fd,
         struct dt_pci dt_pci;
         int           ret;
         int           ofd;
-#ifdef IPCP_FLOW_STATS
+        uint8_t *     head;
         size_t        len;
-#else
+
+        len = shm_du_buff_len(sdb);
+
+#ifndef IPCP_FLOW_STATS
         (void)        fd;
-#endif
+#else
+        pthread_mutex_lock(&dt.stat[fd].lock);
 
-#ifdef IPCP_FLOW_STATS
-        len = shm_du_buff_tail(sdb) - shm_du_buff_head(sdb);
+        ++dt.stat[fd].rcv_pkt[qc];
+        dt.stat[fd].rcv_bytes[qc] += len;
+
+        pthread_mutex_unlock(&dt.stat[fd].lock);
 #endif
         memset(&dt_pci, 0, sizeof(dt_pci));
-        dt_pci_des(sdb, &dt_pci);
+
+        head = shm_du_buff_head(sdb);
+
+        dt_pci_des(head, &dt_pci);
         if (dt_pci.dst_addr != ipcpi.dt_addr) {
                 if (dt_pci.ttl == 0) {
                         log_dbg("TTL was zero.");
@@ -458,8 +461,6 @@ static void packet_handler(int                  fd,
 #ifdef IPCP_FLOW_STATS
                         pthread_mutex_lock(&dt.stat[fd].lock);
 
-                        ++dt.stat[fd].rcv_pkt[qc];
-                        dt.stat[fd].rcv_bytes[qc] += len;
                         ++dt.stat[fd].r_drp_pkt[qc];
                         dt.stat[fd].r_drp_bytes[qc] += len;
 
@@ -471,13 +472,12 @@ static void packet_handler(int                  fd,
                 /* FIXME: Use qoscube from PCI instead of incoming flow. */
                 ofd = pff_nhop(dt.pff[qc], dt_pci.dst_addr);
                 if (ofd < 0) {
-                        log_dbg("No next hop for %" PRIu64, dt_pci.dst_addr);
+                        log_dbg("No next hop for %" PRIu64 ".",
+                                dt_pci.dst_addr);
                         ipcp_sdb_release(sdb);
 #ifdef IPCP_FLOW_STATS
                         pthread_mutex_lock(&dt.stat[fd].lock);
 
-                        ++dt.stat[fd].rcv_pkt[qc];
-                        dt.stat[fd].rcv_bytes[qc] += len;
                         ++dt.stat[fd].f_nhp_pkt[qc];
                         dt.stat[fd].f_nhp_bytes[qc] += len;
 
@@ -486,6 +486,8 @@ static void packet_handler(int                  fd,
                         return;
                 }
 
+                (void) ca_calc_ecn(ofd, head + dt_pci_info.ecn_o, qc, len);
+
                 ret = ipcp_flow_write(ofd, sdb);
                 if (ret < 0) {
                         log_dbg("Failed to write packet to fd %d.", ofd);
@@ -493,12 +495,6 @@ static void packet_handler(int                  fd,
                                 notifier_event(NOTIFY_DT_FLOW_DOWN, &ofd);
                         ipcp_sdb_release(sdb);
 #ifdef IPCP_FLOW_STATS
-                        pthread_mutex_lock(&dt.stat[fd].lock);
-
-                        ++dt.stat[fd].rcv_pkt[qc];
-                        dt.stat[fd].rcv_bytes[qc] += len;
-
-                        pthread_mutex_unlock(&dt.stat[fd].lock);
                         pthread_mutex_lock(&dt.stat[ofd].lock);
 
                         ++dt.stat[ofd].w_drp_pkt[qc];
@@ -509,12 +505,6 @@ static void packet_handler(int                  fd,
                         return;
                 }
 #ifdef IPCP_FLOW_STATS
-                pthread_mutex_lock(&dt.stat[fd].lock);
-
-                ++dt.stat[fd].rcv_pkt[qc];
-                dt.stat[fd].rcv_bytes[qc] += len;
-
-                pthread_mutex_unlock(&dt.stat[fd].lock);
                 pthread_mutex_lock(&dt.stat[ofd].lock);
 
                 ++dt.stat[ofd].snd_pkt[qc];
@@ -525,65 +515,20 @@ static void packet_handler(int                  fd,
         } else {
                 dt_pci_shrink(sdb);
                 if (dt_pci.eid >= PROG_RES_FDS) {
-                        if (ipcp_flow_write(dt_pci.eid, sdb)) {
-                                ipcp_sdb_release(sdb);
-#ifdef IPCP_FLOW_STATS
-                                pthread_mutex_lock(&dt.stat[fd].lock);
-                                ++dt.stat[fd].rcv_pkt[qc];
-                                dt.stat[fd].rcv_bytes[qc] += len;
-                                pthread_mutex_unlock(&dt.stat[fd].lock);
-
-                                pthread_mutex_lock(&dt.stat[dt_pci.eid].lock);
-                                ++dt.stat[dt_pci.eid].w_drp_pkt[qc];
-                                dt.stat[dt_pci.eid].w_drp_bytes[qc] += len;
-                                pthread_mutex_unlock(&dt.stat[dt_pci.eid].lock);
-#endif
-
-                        }
-#ifdef IPCP_FLOW_STATS
-                        pthread_mutex_lock(&dt.stat[fd].lock);
-
-                        ++dt.stat[fd].rcv_pkt[qc];
-                        dt.stat[fd].rcv_bytes[qc] += len;
-
-                        pthread_mutex_unlock(&dt.stat[fd].lock);
-                        pthread_mutex_lock(&dt.stat[dt_pci.eid].lock);
-
-                        ++dt.stat[dt_pci.eid].rcv_pkt[qc];
-                        dt.stat[dt_pci.eid].rcv_bytes[qc] += len;
-                        ++dt.stat[dt_pci.eid].lcl_r_pkt[qc];
-                        dt.stat[dt_pci.eid].lcl_r_bytes[qc] += len;
-
-                        pthread_mutex_unlock(&dt.stat[dt_pci.eid].lock);
-#endif
+                        uint8_t ecn = *(head + dt_pci_info.ecn_o);
+                        fa_np1_rcv(dt_pci.eid, ecn, sdb);
                         return;
                 }
 
                 if (dt.comps[dt_pci.eid].post_packet == NULL) {
-                        log_err("No registered component on eid %d.",
+                        log_err("No registered component on eid %" PRIu64 ".",
                                 dt_pci.eid);
                         ipcp_sdb_release(sdb);
-#ifdef IPCP_FLOW_STATS
-                        pthread_mutex_lock(&dt.stat[fd].lock);
-
-                        ++dt.stat[fd].rcv_pkt[qc];
-                        dt.stat[fd].rcv_bytes[qc] += len;
-
-                        pthread_mutex_unlock(&dt.stat[fd].lock);
-                        pthread_mutex_lock(&dt.stat[dt_pci.eid].lock);
-
-                        ++dt.stat[dt_pci.eid].w_drp_pkt[qc];
-                        dt.stat[dt_pci.eid].w_drp_bytes[qc] += len;
-
-                        pthread_mutex_unlock(&dt.stat[dt_pci.eid].lock);
-#endif
                         return;
                 }
 #ifdef IPCP_FLOW_STATS
                 pthread_mutex_lock(&dt.stat[fd].lock);
 
-                ++dt.stat[fd].rcv_pkt[qc];
-                dt.stat[fd].rcv_bytes[qc] += len;
                 ++dt.stat[fd].lcl_r_pkt[qc];
                 dt.stat[fd].lcl_r_bytes[qc] += len;
 
@@ -620,14 +565,11 @@ static void * dt_conn_handle(void * o)
         return 0;
 }
 
-int dt_init(enum pol_routing pr,
-            uint8_t          addr_size,
-            uint8_t          eid_size,
-            uint8_t          max_ttl)
+int dt_init(struct dt_config cfg)
 {
         int              i;
         int              j;
-        char             dtstr[256];
+        char             dtstr[RIB_NAME_STRLEN + 1];
         int              pp;
         struct conn_info info;
 
@@ -639,9 +581,14 @@ int dt_init(enum pol_routing pr,
         info.pref_syntax  = PROTO_FIXED;
         info.addr         = ipcpi.dt_addr;
 
-        dt_pci_info.addr_size = addr_size;
-        dt_pci_info.eid_size  = eid_size;
-        dt_pci_info.max_ttl   = max_ttl;
+        if (cfg.eid_size != 8) { /* only support 64 bits from now */
+                log_warn("Invalid EID size. Only 64 bit is supported.");
+                cfg.eid_size = 8;
+        }
+
+        dt_pci_info.addr_size = cfg.addr_size;
+        dt_pci_info.eid_size  = cfg.eid_size;
+        dt_pci_info.max_ttl   = cfg.max_ttl;
 
         dt_pci_info.qc_o      = dt_pci_info.addr_size;
         dt_pci_info.ttl_o     = dt_pci_info.qc_o + QOS_LEN;
@@ -649,17 +596,12 @@ int dt_init(enum pol_routing pr,
         dt_pci_info.eid_o     = dt_pci_info.ecn_o + ECN_LEN;
         dt_pci_info.head_size = dt_pci_info.eid_o + dt_pci_info.eid_size;
 
-        if (notifier_reg(handle_event, NULL)) {
-                log_err("Failed to register with notifier.");
-                goto fail_notifier_reg;
-        }
-
         if (connmgr_comp_init(COMPID_DT, &info)) {
                 log_err("Failed to register with connmgr.");
                 goto fail_connmgr_comp_init;
         }
 
-        pp = routing_init(pr);
+        pp = routing_init(cfg.routing_type);
         if (pp < 0) {
                 log_err("Failed to init routing.");
                 goto fail_routing;
@@ -697,6 +639,7 @@ int dt_init(enum pol_routing pr,
 
         for (i = 0; i < PROG_MAX_FLOWS; ++i)
                 if (pthread_mutex_init(&dt.stat[i].lock, NULL)) {
+                        log_err("Failed to init mutex for flow %d.", i);
                         for (j = 0; j < i; ++j)
                                 pthread_mutex_destroy(&dt.stat[j].lock);
                         goto fail_stat_lock;
@@ -705,8 +648,10 @@ int dt_init(enum pol_routing pr,
         dt.n_flows = 0;
 #endif
         sprintf(dtstr, "%s.%" PRIu64, DT, ipcpi.dt_addr);
-        if (rib_reg(dtstr, &r_ops))
+        if (rib_reg(dtstr, &r_ops)) {
+                log_err("Failed to register RIB.");
                 goto fail_rib_reg;
+        }
 
         return 0;
 
@@ -730,16 +675,16 @@ int dt_init(enum pol_routing pr,
  fail_routing:
         connmgr_comp_fini(COMPID_DT);
  fail_connmgr_comp_init:
-        notifier_unreg(&handle_event);
- fail_notifier_reg:
         return -1;
 }
 
 void dt_fini(void)
 {
+        char dtstr[RIB_NAME_STRLEN + 1];
         int i;
 
-        rib_unreg(DT);
+        sprintf(dtstr, "%s.%" PRIu64, DT, ipcpi.dt_addr);
+        rib_unreg(dtstr);
 #ifdef IPCP_FLOW_STATS
         for (i = 0; i < PROG_MAX_FLOWS; ++i)
                 pthread_mutex_destroy(&dt.stat[i].lock);
@@ -757,16 +702,19 @@ void dt_fini(void)
         routing_fini();
 
         connmgr_comp_fini(COMPID_DT);
-
-        notifier_unreg(&handle_event);
 }
 
 int dt_start(void)
 {
-        dt.psched = psched_create(packet_handler);
+        dt.psched = psched_create(packet_handler, ipcp_flow_read);
         if (dt.psched == NULL) {
                 log_err("Failed to create N-1 packet scheduler.");
-                return -1;
+                goto fail_psched;
+        }
+
+        if (notifier_reg(handle_event, NULL)) {
+                log_err("Failed to register with notifier.");
+                goto fail_notifier_reg;
         }
 
         if (pthread_create(&dt.listener, NULL, dt_conn_handle, NULL)) {
@@ -776,12 +724,21 @@ int dt_start(void)
         }
 
         return 0;
+
+ fail_notifier_reg:
+        psched_destroy(dt.psched);
+ fail_psched:
+        return -1;
+
 }
 
 void dt_stop(void)
 {
         pthread_cancel(dt.listener);
         pthread_join(dt.listener, NULL);
+
+        notifier_unreg(&handle_event);
+
         psched_destroy(dt.psched);
 }
 
@@ -789,81 +746,93 @@ int dt_reg_comp(void * comp,
                 void (* func)(void * func, struct shm_du_buff *),
                 char * name)
 {
-        int res_fd;
+        int eid;
 
         assert(func);
 
         pthread_rwlock_wrlock(&dt.lock);
 
-        res_fd = bmp_allocate(dt.res_fds);
-        if (!bmp_is_id_valid(dt.res_fds, res_fd)) {
-                log_warn("Reserved fds depleted.");
+        eid = bmp_allocate(dt.res_fds);
+        if (!bmp_is_id_valid(dt.res_fds, eid)) {
+                log_err("Cannot allocate EID.");
                 pthread_rwlock_unlock(&dt.lock);
                 return -EBADF;
         }
 
-        assert(dt.comps[res_fd].post_packet == NULL);
-        assert(dt.comps[res_fd].comp == NULL);
-        assert(dt.comps[res_fd].name == NULL);
+        assert(dt.comps[eid].post_packet == NULL);
+        assert(dt.comps[eid].comp == NULL);
+        assert(dt.comps[eid].name == NULL);
 
-        dt.comps[res_fd].post_packet = func;
-        dt.comps[res_fd].comp     = comp;
-        dt.comps[res_fd].name     = name;
+        dt.comps[eid].post_packet = func;
+        dt.comps[eid].comp        = comp;
+        dt.comps[eid].name        = name;
 
         pthread_rwlock_unlock(&dt.lock);
 #ifdef IPCP_FLOW_STATS
-        stat_used(res_fd, ipcpi.dt_addr);
+        stat_used(eid, ipcpi.dt_addr);
 #endif
-        return res_fd;
+        return eid;
 }
 
 int dt_write_packet(uint64_t             dst_addr,
                     qoscube_t            qc,
-                    int                  np1_fd,
+                    uint64_t             eid,
                     struct shm_du_buff * sdb)
 {
-        int           fd;
         struct dt_pci dt_pci;
+        int           fd;
         int           ret;
-#ifdef IPCP_FLOW_STATS
+        uint8_t *     head;
         size_t        len;
-#endif
+
         assert(sdb);
         assert(dst_addr != ipcpi.dt_addr);
 
+        len = shm_du_buff_len(sdb);
+
+#ifdef IPCP_FLOW_STATS
+        if (eid < PROG_RES_FDS) {
+                pthread_mutex_lock(&dt.stat[eid].lock);
+
+                ++dt.stat[eid].lcl_r_pkt[qc];
+                dt.stat[eid].lcl_r_bytes[qc] += len;
+
+                pthread_mutex_unlock(&dt.stat[eid].lock);
+        }
+#endif
         fd = pff_nhop(dt.pff[qc], dst_addr);
         if (fd < 0) {
                 log_dbg("Could not get nhop for addr %" PRIu64 ".", dst_addr);
 #ifdef IPCP_FLOW_STATS
-                len = shm_du_buff_tail(sdb) - shm_du_buff_head(sdb);
-
-                pthread_mutex_lock(&dt.stat[np1_fd].lock);
+                if (eid < PROG_RES_FDS) {
+                        pthread_mutex_lock(&dt.stat[eid].lock);
 
-                ++dt.stat[np1_fd].lcl_r_pkt[qc];
-                dt.stat[np1_fd].lcl_r_bytes[qc] += len;
-                ++dt.stat[np1_fd].f_nhp_pkt[qc];
-                dt.stat[np1_fd].f_nhp_bytes[qc] += len;
+                        ++dt.stat[eid].lcl_r_pkt[qc];
+                        dt.stat[eid].lcl_r_bytes[qc] += len;
 
-                pthread_mutex_unlock(&dt.stat[np1_fd].lock);
+                        pthread_mutex_unlock(&dt.stat[eid].lock);
+                }
 #endif
-                return -1;
+                return -EPERM;
+        }
+
+        head = shm_du_buff_head_alloc(sdb, dt_pci_info.head_size);
+        if (head == NULL) {
+                log_dbg("Failed to allocate DT header.");
+                goto fail_write;
         }
 
+        len = shm_du_buff_len(sdb);
+
         dt_pci.dst_addr = dst_addr;
         dt_pci.qc       = qc;
-        dt_pci.eid      = np1_fd;
+        dt_pci.eid      = eid;
         dt_pci.ecn      = 0;
 
-        if (dt_pci_ser(sdb, &dt_pci)) {
-                log_dbg("Failed to serialize PDU.");
-#ifdef IPCP_FLOW_STATS
-                len = shm_du_buff_tail(sdb) - shm_du_buff_head(sdb);
-#endif
-                goto fail_write;
-        }
-#ifdef IPCP_FLOW_STATS
-        len = shm_du_buff_tail(sdb) - shm_du_buff_head(sdb);
-#endif
+        (void) ca_calc_ecn(fd, &dt_pci.ecn, qc, len);
+
+        dt_pci_ser(head, &dt_pci);
+
         ret = ipcp_flow_write(fd, sdb);
         if (ret < 0) {
                 log_dbg("Failed to write packet to fd %d.", fd);
@@ -872,12 +841,6 @@ int dt_write_packet(uint64_t             dst_addr,
                 goto fail_write;
         }
 #ifdef IPCP_FLOW_STATS
-        pthread_mutex_lock(&dt.stat[np1_fd].lock);
-
-        ++dt.stat[np1_fd].lcl_r_pkt[qc];
-        dt.stat[np1_fd].lcl_r_bytes[qc] += len;
-
-        pthread_mutex_unlock(&dt.stat[np1_fd].lock);
         pthread_mutex_lock(&dt.stat[fd].lock);
 
         if (dt_pci.eid < PROG_RES_FDS) {
@@ -893,15 +856,9 @@ int dt_write_packet(uint64_t             dst_addr,
 
  fail_write:
 #ifdef IPCP_FLOW_STATS
-        pthread_mutex_lock(&dt.stat[np1_fd].lock);
-
-        ++dt.stat[np1_fd].lcl_w_pkt[qc];
-        dt.stat[np1_fd].lcl_w_bytes[qc] += len;
-
-        pthread_mutex_unlock(&dt.stat[np1_fd].lock);
         pthread_mutex_lock(&dt.stat[fd].lock);
 
-        if (dt_pci.eid < PROG_RES_FDS) {
+        if (eid < PROG_RES_FDS) {
                 ++dt.stat[fd].lcl_w_pkt[qc];
                 dt.stat[fd].lcl_w_bytes[qc] += len;
         }
diff --git a/src/ipcpd/unicast/dt.h b/src/ipcpd/unicast/dt.h
index 73b71a92..7198a013 100644
--- a/src/ipcpd/unicast/dt.h
+++ b/src/ipcpd/unicast/dt.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Data Transfer component
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -31,11 +31,7 @@
 #define DT_PROTO     "dtp"
 #define INVALID_ADDR 0
 
-int  dt_init(enum pol_routing pr,
-             uint8_t          addr_size,
-             uint8_t          eid_size,
-             uint8_t          max_ttl
-);
+int  dt_init(struct dt_config cfg);
 
 void dt_fini(void);
 
@@ -49,7 +45,7 @@ int  dt_reg_comp(void * comp,
 
 int  dt_write_packet(uint64_t             dst_addr,
                      qoscube_t            qc,
-                     int                  res_fd,
+                     uint64_t             eid,
                      struct shm_du_buff * sdb);
 
 #endif /* OUROBOROS_IPCPD_UNICAST_DT_H */
diff --git a/src/ipcpd/unicast/enroll.c b/src/ipcpd/unicast/enroll.c
deleted file mode 100644
index 3b4a5a89..00000000
--- a/src/ipcpd/unicast/enroll.c
+++ /dev/null
@@ -1,379 +0,0 @@
-/*
- * Ouroboros - Copyright (C) 2016 - 2020
- *
- * Enrollment Task
- *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
- *
- * 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/.
- */
-
-#if defined(__linux__) || defined(__CYGWIN__)
-#define _DEFAULT_SOURCE
-#else
-#define _POSIX_C_SOURCE 199309L
-#endif
-
-#define OUROBOROS_PREFIX "enrollment"
-
-#include <ouroboros/endian.h>
-#include <ouroboros/errno.h>
-#include <ouroboros/time_utils.h>
-#include <ouroboros/dev.h>
-#include <ouroboros/logs.h>
-#include <ouroboros/errno.h>
-#include <ouroboros/sockets.h>
-
-#include "connmgr.h"
-#include "enroll.h"
-#include "ipcp.h"
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include <pthread.h>
-
-#include "ipcp_config.pb-c.h"
-typedef EnrollMsg enroll_msg_t;
-
-#define ENROLL_COMP             "Enrollment"
-#define ENROLL_PROTO            "OEP" /* Ouroboros enrollment protocol */
-#define ENROLL_WARN_TIME_OFFSET 20
-#define ENROLL_BUF_LEN          1024
-
-enum enroll_state {
-        ENROLL_NULL = 0,
-        ENROLL_INIT,
-        ENROLL_RUNNING
-};
-
-struct {
-        struct ipcp_config conf;
-        enum enroll_state  state;
-        pthread_t          listener;
-} enroll;
-
-static int send_rcv_enroll_msg(int fd)
-{
-        enroll_msg_t    req = ENROLL_MSG__INIT;
-        enroll_msg_t *  reply;
-        uint8_t         buf[ENROLL_BUF_LEN];
-        ssize_t         len;
-        ssize_t         delta_t;
-        struct timespec t0;
-        struct timespec rtt;
-
-        req.code = ENROLL_CODE__ENROLL_REQ;
-
-        len = enroll_msg__get_packed_size(&req);
-        if (len < 0) {
-                log_dbg("Failed pack request message.");
-                return -1;
-        }
-
-        enroll_msg__pack(&req, buf);
-
-        clock_gettime(CLOCK_REALTIME, &t0);
-
-        if (flow_write(fd, buf, len) < 0) {
-                log_dbg("Failed to send request message.");
-                return -1;
-        }
-
-        len = flow_read(fd, buf, ENROLL_BUF_LEN);
-        if (len < 0) {
-                log_dbg("No enrollment reply received.");
-                return -1;
-        }
-
-        log_dbg("Received enrollment info (%zd bytes).", len);
-
-        reply = enroll_msg__unpack(NULL, len, buf);
-        if (reply == NULL) {
-                log_dbg("No enrollment response.");
-                return -1;
-        }
-
-        if (reply->code != ENROLL_CODE__ENROLL_BOOT) {
-                log_dbg("Failed to unpack enrollment response.");
-                enroll_msg__free_unpacked(reply, NULL);
-                return -1;
-        }
-
-        if (!(reply->has_t_sec && reply->has_t_nsec)) {
-                log_dbg("No time in response message.");
-                enroll_msg__free_unpacked(reply, NULL);
-                return -1;
-        }
-
-        clock_gettime(CLOCK_REALTIME, &rtt);
-
-        delta_t = ts_diff_ms(&t0, &rtt);
-
-        rtt.tv_sec  = reply->t_sec;
-        rtt.tv_nsec = reply->t_nsec;
-
-        if (labs(ts_diff_ms(&t0, &rtt)) - delta_t > ENROLL_WARN_TIME_OFFSET)
-                log_warn("Clock offset above threshold.");
-
-        strcpy(enroll.conf.layer_info.layer_name,
-               reply->conf->layer_info->layer_name);
-        enroll.conf.type           = reply->conf->ipcp_type;
-        enroll.conf.addr_size      = reply->conf->addr_size;
-        enroll.conf.eid_size       = reply->conf->eid_size;
-        enroll.conf.max_ttl        = reply->conf->max_ttl;
-        enroll.conf.addr_auth_type = reply->conf->addr_auth_type;
-        enroll.conf.routing_type   = reply->conf->routing_type;
-        enroll.conf.layer_info.dir_hash_algo
-                = reply->conf->layer_info->dir_hash_algo;
-
-        enroll_msg__free_unpacked(reply, NULL);
-
-        return 0;
-}
-
-static ssize_t enroll_pack(uint8_t ** buf)
-{
-        enroll_msg_t      msg        = ENROLL_MSG__INIT;
-        ipcp_config_msg_t config     = IPCP_CONFIG_MSG__INIT;
-        layer_info_msg_t  layer_info = LAYER_INFO_MSG__INIT;
-        struct timespec   now;
-        ssize_t           len;
-
-        clock_gettime(CLOCK_REALTIME, &now);
-
-        msg.code       = ENROLL_CODE__ENROLL_BOOT;
-        msg.has_t_sec  = true;
-        msg.t_sec      = now.tv_sec;
-        msg.has_t_nsec = true;
-        msg.t_nsec     = now.tv_nsec;
-        msg.conf       = &config;
-
-        config.ipcp_type          = enroll.conf.type;
-        config.has_addr_size      = true;
-        config.addr_size          = enroll.conf.addr_size;
-        config.has_eid_size       = true;
-        config.eid_size           = enroll.conf.eid_size;
-        config.has_max_ttl        = true;
-        config.max_ttl            = enroll.conf.max_ttl;
-        config.has_addr_auth_type = true;
-        config.addr_auth_type     = enroll.conf.addr_auth_type;
-        config.has_routing_type   = true;
-        config.routing_type       = enroll.conf.routing_type;
-        config.layer_info         = &layer_info;
-
-        layer_info.layer_name     = (char *) enroll.conf.layer_info.layer_name;
-        layer_info.dir_hash_algo  = enroll.conf.layer_info.dir_hash_algo;
-
-        len = enroll_msg__get_packed_size(&msg);
-
-        *buf = malloc(len);
-        if (*buf == NULL)
-                return -1;
-
-        enroll_msg__pack(&msg, *buf);
-
-        return len;
-}
-
-static void * enroll_handle(void * o)
-{
-        struct conn    conn;
-        uint8_t        buf[ENROLL_BUF_LEN];
-        uint8_t *      reply;
-        ssize_t        len;
-        enroll_msg_t * msg;
-
-        (void) o;
-
-        while (true) {
-                if (connmgr_wait(COMPID_ENROLL, &conn)) {
-                        log_err("Failed to get next connection.");
-                        continue;
-                }
-
-                len = flow_read(conn.flow_info.fd, buf, ENROLL_BUF_LEN);
-                if (len < 0) {
-                        log_err("Failed to read from flow.");
-                        connmgr_dealloc(COMPID_ENROLL, &conn);
-                        continue;
-                }
-
-                msg = enroll_msg__unpack(NULL, len, buf);
-                if (msg == NULL) {
-                        log_err("Failed to unpack message.");
-                        connmgr_dealloc(COMPID_ENROLL, &conn);
-                        continue;
-                }
-
-                if (msg->code != ENROLL_CODE__ENROLL_REQ) {
-                        log_err("Wrong message type.");
-                        connmgr_dealloc(COMPID_ENROLL, &conn);
-                        enroll_msg__free_unpacked(msg, NULL);
-                        continue;
-                }
-
-                log_dbg("Enrolling a new neighbor.");
-
-                enroll_msg__free_unpacked(msg, NULL);
-
-                len = enroll_pack(&reply);
-                if (reply == NULL) {
-                        log_err("Failed to pack enrollment message.");
-                        connmgr_dealloc(COMPID_ENROLL, &conn);
-                        continue;
-                }
-
-                log_dbg("Sending enrollment info (%zd bytes).", len);
-
-                if (flow_write(conn.flow_info.fd, reply, len) < 0) {
-                        log_err("Failed respond to enrollment request.");
-                        connmgr_dealloc(COMPID_ENROLL, &conn);
-                        free(reply);
-                        continue;
-                }
-
-                free(reply);
-
-                len = flow_read(conn.flow_info.fd, buf, ENROLL_BUF_LEN);
-                if (len < 0) {
-                        log_err("Failed to read from flow.");
-                        connmgr_dealloc(COMPID_ENROLL, &conn);
-                        continue;
-                }
-
-                msg = enroll_msg__unpack(NULL, len, buf);
-                if (msg == NULL) {
-                        log_err("Failed to unpack message.");
-                        connmgr_dealloc(COMPID_ENROLL, &conn);
-                        continue;
-                }
-
-                if (msg->code != ENROLL_CODE__ENROLL_DONE || !msg->has_result) {
-                        log_err("Wrong message type.");
-                        enroll_msg__free_unpacked(msg, NULL);
-                        connmgr_dealloc(COMPID_ENROLL, &conn);
-                        continue;
-                }
-
-                if (msg->result == 0)
-                        log_dbg("Neighbor enrollment successful.");
-                else
-                        log_dbg("Neigbor reported failed enrollment.");
-
-                enroll_msg__free_unpacked(msg, NULL);
-
-                connmgr_dealloc(COMPID_ENROLL, &conn);
-        }
-
-        return 0;
-}
-
-int enroll_boot(struct conn * conn)
-{
-        log_dbg("Getting boot information.");
-
-        if (send_rcv_enroll_msg(conn->flow_info.fd)) {
-                log_err("Failed to enroll.");
-                return -1;
-        }
-
-        return 0;
-}
-
-int enroll_done(struct conn * conn,
-                int           result)
-{
-        enroll_msg_t msg = ENROLL_MSG__INIT;
-        uint8_t      buf[ENROLL_BUF_LEN];
-        ssize_t       len;
-
-        msg.code       = ENROLL_CODE__ENROLL_DONE;
-        msg.has_result = true;
-        msg.result     = result;
-
-        len = enroll_msg__get_packed_size(&msg);
-        if (len < 0) {
-                log_dbg("Failed pack request message.");
-                return -1;
-        }
-
-        enroll_msg__pack(&msg, buf);
-
-        if (flow_write(conn->flow_info.fd, buf, len) < 0) {
-                log_dbg("Failed to send acknowledgment.");
-                return -1;
-        }
-
-        return 0;
-}
-
-void enroll_bootstrap(const struct ipcp_config * conf)
-{
-        assert(conf);
-
-        memcpy(&enroll.conf, conf, sizeof(enroll.conf));
-}
-
-struct ipcp_config * enroll_get_conf(void)
-{
-        return &enroll.conf;
-}
-
-int enroll_init(void)
-{
-        struct conn_info info;
-
-        memset(&info, 0, sizeof(info));
-
-        strcpy(info.comp_name, ENROLL_COMP);
-        strcpy(info.protocol, ENROLL_PROTO);
-        info.pref_version = 1;
-        info.pref_syntax  = PROTO_GPB;
-        info.addr         = 0;
-
-        if (connmgr_comp_init(COMPID_ENROLL, &info)) {
-                log_err("Failed to register with connmgr.");
-                return -1;
-        }
-
-        enroll.state = ENROLL_INIT;
-
-        return 0;
-}
-
-void enroll_fini(void)
-{
-        if (enroll.state == ENROLL_RUNNING)
-                pthread_join(enroll.listener, NULL);
-
-        connmgr_comp_fini(COMPID_ENROLL);
-}
-
-int enroll_start(void)
-{
-        if (pthread_create(&enroll.listener, NULL, enroll_handle, NULL))
-                return -1;
-
-        enroll.state = ENROLL_RUNNING;
-
-        return 0;
-}
-
-void enroll_stop(void)
-{
-        if (enroll.state == ENROLL_RUNNING)
-                pthread_cancel(enroll.listener);
-}
diff --git a/src/ipcpd/unicast/enroll.h b/src/ipcpd/unicast/enroll.h
deleted file mode 100644
index 804f5d5b..00000000
--- a/src/ipcpd/unicast/enroll.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Ouroboros - Copyright (C) 2016 - 2020
- *
- * Enrollment Task
- *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
- *
- * 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/.
- */
-
-#ifndef OUROBOROS_IPCPD_UNICAST_ENROLL_H
-#define OUROBOROS_IPCPD_UNICAST_ENROLL_H
-
-#include <ouroboros/ipcp.h>
-
-#include "comp.h"
-
-int                  enroll_init(void);
-
-void                 enroll_fini(void);
-
-int                  enroll_start(void);
-
-void                 enroll_stop(void);
-
-void                 enroll_bootstrap(const struct ipcp_config * conf);
-
-int                  enroll_boot(struct conn * conn);
-
-int                  enroll_done(struct conn * conn,
-                                 int           result);
-
-struct ipcp_config * enroll_get_conf(void);
-
-#endif /* OUROBOROS_IPCPD_UNICAST_ENROLL_H */
diff --git a/src/ipcpd/unicast/fa.c b/src/ipcpd/unicast/fa.c
index e0727e85..3631fd7b 100644
--- a/src/ipcpd/unicast/fa.c
+++ b/src/ipcpd/unicast/fa.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Flow allocator of the IPC Process
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -31,43 +31,57 @@
 #define FA               "flow-allocator"
 #define OUROBOROS_PREFIX FA
 
+#include <ouroboros/endian.h>
 #include <ouroboros/logs.h>
 #include <ouroboros/fqueue.h>
 #include <ouroboros/errno.h>
 #include <ouroboros/dev.h>
 #include <ouroboros/ipcp-dev.h>
+#include <ouroboros/rib.h>
+#include <ouroboros/random.h>
+#include <ouroboros/pthread.h>
 
 #include "dir.h"
 #include "fa.h"
 #include "psched.h"
 #include "ipcp.h"
 #include "dt.h"
+#include "ca.h"
 
-#include <pthread.h>
+#include <inttypes.h>
 #include <stdlib.h>
 #include <string.h>
 
-#define TIMEOUT 10000 /* nanoseconds */
+#if defined (IPCP_FLOW_STATS) && !defined(CLOCK_REALTIME_COARSE)
+#define CLOCK_REALTIME_COARSE CLOCK_REALTIME
+#endif
+
+#define TIMEOUT 10 * MILLION /* nanoseconds */
+
+#define FLOW_REQ    0
+#define FLOW_REPLY  1
+#define FLOW_UPDATE 2
+#define MSGBUFSZ    2048
 
-#define FLOW_REQ   0
-#define FLOW_REPLY 1
-#define MSGBUFSZ   2048
+#define STAT_FILE_LEN 0
 
 struct fa_msg {
         uint64_t s_addr;
-        uint32_t r_eid;
-        uint32_t s_eid;
+        uint64_t r_eid;
+        uint64_t s_eid;
         uint8_t  code;
         int8_t   response;
+        uint16_t ece;
         /* QoS parameters from spec, aligned */
-        uint8_t  availability;
-        uint8_t  in_order;
         uint32_t delay;
         uint64_t bandwidth;
         uint32_t loss;
         uint32_t ber;
         uint32_t max_gap;
+        uint32_t timeout;
         uint16_t cypher_s;
+        uint8_t  availability;
+        uint8_t  in_order;
 } __attribute__((packed));
 
 struct cmd {
@@ -75,11 +89,33 @@ struct cmd {
         struct shm_du_buff * sdb;
 };
 
+struct fa_flow {
+#ifdef IPCP_FLOW_STATS
+        time_t   stamp;    /* Flow creation                  */
+        size_t   p_snd;    /* Packets sent                   */
+        size_t   p_snd_f;  /* Packets sent fail              */
+        size_t   b_snd;    /* Bytes sent                     */
+        size_t   b_snd_f;  /* Bytes sent fail                */
+        size_t   p_rcv;    /* Packets received               */
+        size_t   p_rcv_f;  /* Packets received fail          */
+        size_t   b_rcv;    /* Bytes received                 */
+        size_t   b_rcv_f;  /* Bytes received fail            */
+        size_t   u_snd;    /* Flow updates sent              */
+        size_t   u_rcv;    /* Flow updates received          */
+#endif
+        uint64_t s_eid;  /* Local endpoint id                */
+        uint64_t r_eid;  /* Remote endpoint id               */
+        uint64_t r_addr; /* Remote address                   */
+        void *   ctx;    /* Congestion avoidance context     */
+};
+
 struct {
         pthread_rwlock_t flows_lock;
-        int              r_eid[PROG_MAX_FLOWS];
-        uint64_t         r_addr[PROG_MAX_FLOWS];
-        int              fd;
+        struct fa_flow   flows[PROG_MAX_FLOWS];
+#ifdef IPCP_FLOW_STATS
+        size_t           n_flows;
+#endif
+        uint32_t         eid;
 
         struct list_head cmds;
         pthread_cond_t   cond;
@@ -89,26 +125,289 @@ struct {
         struct psched *  psched;
 } fa;
 
+static int fa_rib_read(const char * path,
+                       char *       buf,
+                       size_t       len)
+{
+#ifdef IPCP_FLOW_STATS
+        struct fa_flow * flow;
+        int              fd;
+        char             r_addrstr[21];
+        char             s_eidstr[21];
+        char             r_eidstr[21];
+        char             tmstr[20];
+        char             castr[1024];
+        char *           entry;
+        struct tm *      tm;
+
+        entry = strstr(path, RIB_SEPARATOR) + 1;
+        assert(entry);
+
+        fd = atoi(entry);
+
+        if (fd < 0 || fd >= PROG_MAX_FLOWS)
+                return -1;
+
+        if (len < 1536)
+                return 0;
+
+        flow = &fa.flows[fd];
+
+        buf[0] = '\0';
+
+        pthread_rwlock_rdlock(&fa.flows_lock);
+
+        if (flow->stamp ==0) {
+                pthread_rwlock_unlock(&fa.flows_lock);
+                return 0;
+        }
+
+        sprintf(r_addrstr, "%" PRIu64, flow->r_addr);
+        sprintf(s_eidstr, "%" PRIu64, flow->s_eid);
+        sprintf(r_eidstr, "%" PRIu64, flow->r_eid);
+
+        tm = localtime(&flow->stamp);
+        strftime(tmstr, sizeof(tmstr), "%F %T", tm);
+
+        ca_print_stats(flow->ctx, castr, 1024);
+
+        sprintf(buf,
+                "Flow established at:             %20s\n"
+                "Remote address:                  %20s\n"
+                "Local endpoint ID:               %20s\n"
+                "Remote endpoint ID:              %20s\n"
+                "Sent (packets):                  %20zu\n"
+                "Sent (bytes):                    %20zu\n"
+                "Send failed (packets):           %20zu\n"
+                "Send failed (bytes):             %20zu\n"
+                "Received (packets):              %20zu\n"
+                "Received (bytes):                %20zu\n"
+                "Receive failed (packets):        %20zu\n"
+                "Receive failed (bytes):          %20zu\n"
+                "Sent flow updates (packets):     %20zu\n"
+                "Received flow updates (packets): %20zu\n"
+                "%s",
+                tmstr, r_addrstr,
+                s_eidstr, r_eidstr,
+                flow->p_snd, flow->b_snd,
+                flow->p_snd_f, flow->b_snd_f,
+                flow->p_rcv, flow->b_rcv,
+                flow->b_rcv_f, flow->b_rcv_f,
+                flow->u_snd, flow->u_rcv,
+                castr);
+
+        pthread_rwlock_unlock(&fa.flows_lock);
+
+        return strlen(buf);
+#else
+        (void) path;
+        (void) buf;
+        (void) len;
+        return 0;
+#endif
+}
+
+static int fa_rib_readdir(char *** buf)
+{
+#ifdef IPCP_FLOW_STATS
+        char   entry[RIB_PATH_LEN + 1];
+        size_t i;
+        int    idx = 0;
+
+        pthread_rwlock_rdlock(&fa.flows_lock);
+
+        if (fa.n_flows < 1) {
+                pthread_rwlock_unlock(&fa.flows_lock);
+                return 0;
+        }
+
+        *buf = malloc(sizeof(**buf) * fa.n_flows);
+        if (*buf == NULL) {
+                pthread_rwlock_unlock(&fa.flows_lock);
+                return -ENOMEM;
+        }
+
+        for (i = 0; i < PROG_MAX_FLOWS; ++i) {
+                struct fa_flow * flow;
+
+                flow = &fa.flows[i];
+                if (flow->stamp == 0)
+                        continue;
+
+                sprintf(entry, "%zu", i);
+
+                (*buf)[idx] = malloc(strlen(entry) + 1);
+                if ((*buf)[idx] == NULL) {
+                        while (idx-- > 0)
+                                free((*buf)[idx]);
+                        free(*buf);
+                        pthread_rwlock_unlock(&fa.flows_lock);
+                        return -ENOMEM;
+                }
+
+                strcpy((*buf)[idx++], entry);
+        }
+
+        assert((size_t) idx == fa.n_flows);
+
+        pthread_rwlock_unlock(&fa.flows_lock);
+
+        return idx;
+#else
+        (void) buf;
+        return 0;
+#endif
+}
+
+static int fa_rib_getattr(const char *      path,
+                          struct rib_attr * attr)
+{
+#ifdef IPCP_FLOW_STATS
+        int              fd;
+        char *           entry;
+        struct fa_flow * flow;
+
+        entry = strstr(path, RIB_SEPARATOR) + 1;
+        assert(entry);
+
+        fd = atoi(entry);
+
+        flow = &fa.flows[fd];
+
+        pthread_rwlock_rdlock(&fa.flows_lock);
+
+        if (flow->stamp != 0) {
+                attr->size  = 1536;
+                attr->mtime = flow->stamp;
+        } else {
+                attr->size  = 0;
+                attr->mtime = 0;
+        }
+
+        pthread_rwlock_unlock(&fa.flows_lock);
+#else
+        (void) path;
+        (void) attr;
+#endif
+        return 0;
+}
+
+static struct rib_ops r_ops = {
+        .read    = fa_rib_read,
+        .readdir = fa_rib_readdir,
+        .getattr = fa_rib_getattr
+};
+
+static int eid_to_fd(uint64_t eid)
+{
+        struct fa_flow * flow;
+        int              fd;
+
+        fd = eid & 0xFFFFFFFF;
+
+        if (fd < 0 || fd >= PROG_MAX_FLOWS)
+                return -1;
+
+        flow = &fa.flows[fd];
+
+        if (flow->s_eid == eid)
+                return fd;
+
+        return -1;
+}
+
+static uint64_t gen_eid(int fd)
+{
+        uint32_t rnd;
+
+        if (random_buffer(&rnd, sizeof(rnd)) < 0)
+                return fa.eid; /* INVALID */
+
+        fd &= 0xFFFFFFFF;
+
+        return ((uint64_t) rnd << 32) + fd;
+}
+
 static void packet_handler(int                  fd,
                            qoscube_t            qc,
                            struct shm_du_buff * sdb)
 {
-        pthread_rwlock_rdlock(&fa.flows_lock);
+        struct fa_flow * flow;
+        uint64_t         r_addr;
+        uint64_t         r_eid;
+        ca_wnd_t         wnd;
+        size_t           len;
 
-        if (dt_write_packet(fa.r_addr[fd], qc, fa.r_eid[fd], sdb)) {
-                pthread_rwlock_unlock(&fa.flows_lock);
+        flow = &fa.flows[fd];
+
+        pthread_rwlock_wrlock(&fa.flows_lock);
+
+        len = shm_du_buff_len(sdb);
+
+#ifdef IPCP_FLOW_STATS
+        ++flow->p_snd;
+        flow->b_snd += len;
+#endif
+        wnd = ca_ctx_update_snd(flow->ctx, len);
+
+        r_addr = flow->r_addr;
+        r_eid  = flow->r_eid;
+
+        pthread_rwlock_unlock(&fa.flows_lock);
+
+        ca_wnd_wait(wnd);
+
+        if (dt_write_packet(r_addr, qc, r_eid, sdb)) {
                 ipcp_sdb_release(sdb);
-                log_warn("Failed to forward packet.");
+                log_dbg("Failed to forward packet.");
+#ifdef IPCP_FLOW_STATS
+                pthread_rwlock_wrlock(&fa.flows_lock);
+                ++flow->p_snd_f;
+                flow->b_snd_f += len;
+                pthread_rwlock_unlock(&fa.flows_lock);
+#endif
                 return;
         }
+}
 
-        pthread_rwlock_unlock(&fa.flows_lock);
+static int fa_flow_init(struct fa_flow * flow)
+{
+#ifdef IPCP_FLOW_STATS
+        struct timespec now;
+#endif
+        memset(flow, 0, sizeof(*flow));
+
+        flow->r_eid  = -1;
+        flow->s_eid  = -1;
+        flow->r_addr = INVALID_ADDR;
+
+        flow->ctx = ca_ctx_create();
+        if (flow->ctx == NULL)
+                return -1;
+
+#ifdef IPCP_FLOW_STATS
+        clock_gettime(CLOCK_REALTIME_COARSE, &now);
+
+        flow->stamp = now.tv_sec;
+
+        ++fa.n_flows;
+#endif
+        return 0;
 }
 
-static void destroy_conn(int fd)
+static void fa_flow_fini(struct fa_flow * flow)
 {
-        fa.r_eid[fd]  = -1;
-        fa.r_addr[fd] = INVALID_ADDR;
+        ca_ctx_destroy(flow->ctx);
+
+        memset(flow, 0, sizeof(*flow));
+
+        flow->r_eid  = -1;
+        flow->s_eid  = -1;
+        flow->r_addr = INVALID_ADDR;
+
+#ifdef IPCP_FLOW_STATS
+        --fa.n_flows;
+#endif
 }
 
 static void fa_post_packet(void *               comp,
@@ -138,146 +437,200 @@ static void fa_post_packet(void *               comp,
         pthread_mutex_unlock(&fa.mtx);
 }
 
-static void * fa_handle_packet(void * o)
+static size_t fa_wait_for_fa_msg(struct fa_msg * msg)
 {
-        struct timespec ts  = {0, TIMEOUT * 1000};
+        struct cmd * cmd;
+        size_t       len;
 
-        (void) o;
+        pthread_mutex_lock(&fa.mtx);
 
-        while (true) {
-                struct timespec abstime;
-                int             fd;
-                uint8_t         buf[MSGBUFSZ];
-                struct fa_msg * msg;
-                qosspec_t       qs;
-                struct cmd *    cmd;
-                size_t          len;
-                size_t          msg_len;
+        pthread_cleanup_push(__cleanup_mutex_unlock, &fa.mtx);
 
-                pthread_mutex_lock(&fa.mtx);
+        while (list_is_empty(&fa.cmds))
+                pthread_cond_wait(&fa.cond, &fa.mtx);
 
-                pthread_cleanup_push((void (*)(void *)) pthread_mutex_unlock,
-                                     &fa.mtx);
+        cmd = list_last_entry(&fa.cmds, struct cmd, next);
+        list_del(&cmd->next);
 
-                while (list_is_empty(&fa.cmds))
-                        pthread_cond_wait(&fa.cond, &fa.mtx);
+        pthread_cleanup_pop(true);
 
-                cmd = list_last_entry(&fa.cmds, struct cmd, next);
-                list_del(&cmd->next);
+        len = shm_du_buff_len(cmd->sdb);
+        if (len > MSGBUFSZ || len < sizeof(*msg)) {
+                log_warn("Invalid flow allocation message (len: %zd).", len);
+                free(cmd);
+                return 0; /* No valid message */
+        }
 
-                pthread_cleanup_pop(true);
+        memcpy(msg, shm_du_buff_head(cmd->sdb), len);
 
-                len = shm_du_buff_tail(cmd->sdb) - shm_du_buff_head(cmd->sdb);
+        ipcp_sdb_release(cmd->sdb);
 
-                if (len > MSGBUFSZ) {
-                        log_err("Message over buffer size.");
-                        free(cmd);
-                        continue;
-                }
+        free(cmd);
 
-                msg = (struct fa_msg *) buf;
+        return len;
+}
 
-                /* Depending on the message call the function in ipcp-dev.h */
+static int fa_handle_flow_req(struct fa_msg * msg,
+                              size_t          len)
+{
+        size_t           msg_len;
+        int              fd;
+        qosspec_t        qs;
+        struct fa_flow * flow;
+        uint8_t *        dst;
+        buffer_t         data;  /* Piggbacked data on flow alloc request. */
+
+        msg_len = sizeof(*msg) + ipcp_dir_hash_len();
+        if (len < msg_len) {
+                log_err("Invalid flow allocation request");
+                return -EPERM;
+        }
 
-                memcpy(msg, shm_du_buff_head(cmd->sdb), len);
+        dst       = (uint8_t *)(msg + 1);
+        data.data = (uint8_t *) msg + msg_len;
+        data.len  = len - msg_len;
 
-                ipcp_sdb_release(cmd->sdb);
+        qs.delay        = ntoh32(msg->delay);
+        qs.bandwidth    = ntoh64(msg->bandwidth);
+        qs.availability = msg->availability;
+        qs.loss         = ntoh32(msg->loss);
+        qs.ber          = ntoh32(msg->ber);
+        qs.in_order     = msg->in_order;
+        qs.max_gap      = ntoh32(msg->max_gap);
+        qs.cypher_s     = ntoh16(msg->cypher_s);
+        qs.timeout      = ntoh32(msg->timeout);
 
-                free(cmd);
+        fd = ipcp_wait_flow_req_arr(dst, qs, IPCP_UNICAST_MPL, &data);
+        if (fd < 0)
+                return fd;
 
-                switch (msg->code) {
-                case FLOW_REQ:
-                        msg_len = sizeof(*msg) + ipcp_dir_hash_len();
-
-                        assert(len >= msg_len);
-
-                        clock_gettime(PTHREAD_COND_CLOCK, &abstime);
-
-                        pthread_mutex_lock(&ipcpi.alloc_lock);
-
-                        while (ipcpi.alloc_id != -1 &&
-                               ipcp_get_state() == IPCP_OPERATIONAL) {
-                                ts_add(&abstime, &ts, &abstime);
-                                pthread_cond_timedwait(&ipcpi.alloc_cond,
-                                                       &ipcpi.alloc_lock,
-                                                       &abstime);
-                        }
-
-                        if (ipcp_get_state() != IPCP_OPERATIONAL) {
-                                pthread_mutex_unlock(&ipcpi.alloc_lock);
-                                log_dbg("Won't allocate over non-operational"
-                                        "IPCP.");
-                                continue;
-                        }
-
-                        assert(ipcpi.alloc_id == -1);
-
-                        qs.delay        = ntoh32(msg->delay);
-                        qs.bandwidth    = ntoh64(msg->bandwidth);
-                        qs.availability = msg->availability;
-                        qs.loss         = ntoh32(msg->loss);
-                        qs.ber          = ntoh32(msg->ber);
-                        qs.in_order     = msg->in_order;
-                        qs.max_gap      = ntoh32(msg->max_gap);
-                        qs.cypher_s     = ntoh16(msg->cypher_s);
-
-                        fd = ipcp_flow_req_arr((uint8_t *) (msg + 1),
-                                               ipcp_dir_hash_len(),
-                                               qs,
-                                               buf + msg_len,
-                                               len - msg_len);
-                        if (fd < 0) {
-                                pthread_mutex_unlock(&ipcpi.alloc_lock);
-                                log_err("Failed to get fd for flow.");
-                                continue;
-                        }
-
-                        pthread_rwlock_wrlock(&fa.flows_lock);
-
-                        fa.r_eid[fd]  = ntoh32(msg->s_eid);
-                        fa.r_addr[fd] = ntoh64(msg->s_addr);
+        flow = &fa.flows[fd];
 
-                        pthread_rwlock_unlock(&fa.flows_lock);
+        pthread_rwlock_wrlock(&fa.flows_lock);
 
-                        ipcpi.alloc_id = fd;
-                        pthread_cond_broadcast(&ipcpi.alloc_cond);
+        fa_flow_init(flow);
 
-                        pthread_mutex_unlock(&ipcpi.alloc_lock);
+        flow->s_eid  = gen_eid(fd);
+        flow->r_eid  = ntoh64(msg->s_eid);
+        flow->r_addr = ntoh64(msg->s_addr);
 
-                        break;
-                case FLOW_REPLY:
-                        assert(len >= sizeof(*msg));
+        pthread_rwlock_unlock(&fa.flows_lock);
 
-                        pthread_rwlock_wrlock(&fa.flows_lock);
+        return fd;
+}
 
-                        fa.r_eid[ntoh32(msg->r_eid)] = ntoh32(msg->s_eid);
+static int fa_handle_flow_reply(struct fa_msg * msg,
+                                size_t          len)
+{
+        int              fd;
+        struct fa_flow * flow;
+        buffer_t         data;  /* Piggbacked data on flow alloc request. */
+        time_t           mpl = IPCP_UNICAST_MPL;
 
-                        ipcp_flow_alloc_reply(ntoh32(msg->r_eid),
-                                              msg->response,
-                                              buf + sizeof(*msg),
-                                              len - sizeof(*msg));
+        assert(len >= sizeof(*msg));
 
-                        if (msg->response < 0)
-                                destroy_conn(ntoh32(msg->r_eid));
-                        else
-                                psched_add(fa.psched, ntoh32(msg->r_eid));
+        data.data = (uint8_t *) msg + sizeof(*msg);
+        data.len  = len - sizeof(*msg);
 
-                        pthread_rwlock_unlock(&fa.flows_lock);
+        pthread_rwlock_wrlock(&fa.flows_lock);
+
+        fd = eid_to_fd(ntoh64(msg->r_eid));
+        if (fd < 0) {
+                pthread_rwlock_unlock(&fa.flows_lock);
+                log_err("Flow reply for unknown EID %" PRIu64 ".",
+                        ntoh64(msg->r_eid));
+                return -ENOTALLOC;
+        }
+
+        flow = &fa.flows[fd];
+
+        flow->r_eid = ntoh64(msg->s_eid);
+
+        if (msg->response < 0)
+                fa_flow_fini(flow);
+        else
+                psched_add(fa.psched, fd);
+
+        pthread_rwlock_unlock(&fa.flows_lock);
+
+        if (ipcp_flow_alloc_reply(fd, msg->response, mpl, &data) < 0) {
+                log_err("Failed to reply for flow allocation on fd %d.", fd);
+                return -EIRMD;
+        }
+
+        return 0;
+}
+
+static int fa_handle_flow_update(struct fa_msg * msg,
+                                 size_t          len)
+{
+        struct fa_flow * flow;
+        int              fd;
+
+        (void) len;
+        assert(len >= sizeof(*msg));
+
+        pthread_rwlock_wrlock(&fa.flows_lock);
+
+        fd = eid_to_fd(ntoh64(msg->r_eid));
+        if (fd < 0) {
+                pthread_rwlock_unlock(&fa.flows_lock);
+                log_err("Flow update for unknown EID %" PRIu64 ".",
+                        ntoh64(msg->r_eid));
+                return -EPERM;
+        }
+
+        flow = &fa.flows[fd];
+#ifdef IPCP_FLOW_STATS
+        flow->u_rcv++;
+#endif
+        ca_ctx_update_ece(flow->ctx, ntoh16(msg->ece));
+
+        pthread_rwlock_unlock(&fa.flows_lock);
+
+        return 0;
+}
+
+static void * fa_handle_packet(void * o)
+{
+        (void) o;
+
+        while (true) {
+                uint8_t          buf[MSGBUFSZ];
+                struct fa_msg *  msg;
+                size_t           len;
+
+                msg = (struct fa_msg *) buf;
+
+                len = fa_wait_for_fa_msg(msg);
+                if (len == 0)
+                        continue;
 
+                switch (msg->code) {
+                case FLOW_REQ:
+                        if (fa_handle_flow_req(msg, len) < 0)
+                                log_err("Error handling flow alloc request.");
+                        break;
+                case FLOW_REPLY:
+                        if (fa_handle_flow_reply(msg, len) < 0)
+                                log_err("Error handling flow reply.");
+                        break;
+                case FLOW_UPDATE:
+                        if (fa_handle_flow_update(msg, len) < 0)
+                                log_err("Error handling flow update.");
                         break;
                 default:
-                        log_err("Got an unknown flow allocation message.");
+                        log_warn("Recieved unknown flow allocation message.");
                         break;
                 }
         }
+
+        return (void *) 0;
 }
 
 int fa_init(void)
 {
-        int i;
-
-        for (i = 0; i < PROG_MAX_FLOWS; ++i)
-                destroy_conn(i);
+        pthread_condattr_t cattr;
 
         if (pthread_rwlock_init(&fa.flows_lock, NULL))
                 goto fail_rwlock;
@@ -285,26 +638,45 @@ int fa_init(void)
         if (pthread_mutex_init(&fa.mtx, NULL))
                 goto fail_mtx;
 
-        if (pthread_cond_init(&fa.cond, NULL))
+        if (pthread_condattr_init(&cattr))
+                goto fail_cattr;
+
+#ifndef __APPLE__
+        pthread_condattr_setclock(&cattr, PTHREAD_COND_CLOCK);
+#endif
+        if (pthread_cond_init(&fa.cond, &cattr))
                 goto fail_cond;
 
+        pthread_condattr_destroy(&cattr);
+
         list_head_init(&fa.cmds);
 
-        fa.fd = dt_reg_comp(&fa, &fa_post_packet, FA);
+        if (rib_reg(FA, &r_ops))
+                goto fail_rib_reg;
+
+        fa.eid = dt_reg_comp(&fa, &fa_post_packet, FA);
+        if ((int) fa.eid < 0)
+                goto fail_rib_reg;
 
         return 0;
 
+ fail_rib_reg:
+        pthread_cond_destroy(&fa.cond);
  fail_cond:
+        pthread_condattr_destroy(&cattr);
+ fail_cattr:
         pthread_mutex_destroy(&fa.mtx);
  fail_mtx:
         pthread_rwlock_destroy(&fa.flows_lock);
  fail_rwlock:
-        log_err("Failed to initialize flow allocator.");
+
         return -1;
 }
 
 void fa_fini(void)
 {
+        rib_unreg(FA);
+
         pthread_cond_destroy(&fa.cond);;
         pthread_mutex_destroy(&fa.mtx);
         pthread_rwlock_destroy(&fa.flows_lock);
@@ -316,7 +688,7 @@ int fa_start(void)
         int                 pol;
         int                 max;
 
-        fa.psched = psched_create(packet_handler);
+        fa.psched = psched_create(packet_handler, np1_flow_read);
         if (fa.psched == NULL) {
                 log_err("Failed to start packet scheduler.");
                 goto fail_psched;
@@ -353,7 +725,6 @@ int fa_start(void)
  fail_thread:
         psched_destroy(fa.psched);
  fail_psched:
-        log_err("Failed to start flow allocator.");
         return -1;
 }
 
@@ -365,17 +736,18 @@ void fa_stop(void)
         psched_destroy(fa.psched);
 }
 
-int fa_alloc(int             fd,
-             const uint8_t * dst,
-             qosspec_t       qs,
-             const void *    data,
-             size_t          dlen)
+int fa_alloc(int              fd,
+             const uint8_t *  dst,
+             qosspec_t        qs,
+             const buffer_t * data)
 {
         struct fa_msg *      msg;
-        uint64_t             addr;
         struct shm_du_buff * sdb;
-        qoscube_t            qc;
+        struct fa_flow *     flow;
+        uint64_t             addr;
+        qoscube_t            qc = QOS_CUBE_BE;
         size_t               len;
+        uint64_t             eid;
 
         addr = dir_query(dst);
         if (addr == 0)
@@ -383,12 +755,16 @@ int fa_alloc(int             fd,
 
         len = sizeof(*msg) + ipcp_dir_hash_len();
 
-        if (ipcp_sdb_reserve(&sdb, len + dlen))
+        if (ipcp_sdb_reserve(&sdb, len + data->len))
                 return -1;
 
-        msg               = (struct fa_msg *) shm_du_buff_head(sdb);
+        msg = (struct fa_msg *) shm_du_buff_head(sdb);
+        memset(msg, 0, sizeof(*msg));
+
+        eid = gen_eid(fd);
+
         msg->code         = FLOW_REQ;
-        msg->s_eid        = hton32(fd);
+        msg->s_eid        = hton64(eid);
         msg->s_addr       = hton64(ipcpi.dt_addr);
         msg->delay        = hton32(qs.delay);
         msg->bandwidth    = hton64(qs.bandwidth);
@@ -398,111 +774,196 @@ int fa_alloc(int             fd,
         msg->in_order     = qs.in_order;
         msg->max_gap      = hton32(qs.max_gap);
         msg->cypher_s     = hton16(qs.cypher_s);
+        msg->timeout      = hton32(qs.timeout);
 
         memcpy(msg + 1, dst, ipcp_dir_hash_len());
-        memcpy(shm_du_buff_head(sdb) + len, data, dlen);
-
-        qc = qos_spec_to_cube(qs);
+        if (data->len > 0)
+                memcpy(shm_du_buff_head(sdb) + len, data->data, data->len);
 
-        if (dt_write_packet(addr, qc, fa.fd, sdb)) {
+        if (dt_write_packet(addr, qc, fa.eid, sdb)) {
+                log_err("Failed to send flow allocation request packet.");
                 ipcp_sdb_release(sdb);
                 return -1;
         }
 
+        flow = &fa.flows[fd];
+
         pthread_rwlock_wrlock(&fa.flows_lock);
 
-        assert(fa.r_eid[fd] == -1);
-        fa.r_addr[fd] = addr;
+        fa_flow_init(flow);
+        flow->r_addr = addr;
+        flow->s_eid  = eid;
 
         pthread_rwlock_unlock(&fa.flows_lock);
 
         return 0;
 }
 
-int fa_alloc_resp(int          fd,
-                  int          response,
-                  const void * data,
-                  size_t       len)
+int fa_alloc_resp(int              fd,
+                  int              response,
+                  const buffer_t * data)
 {
-        struct timespec      ts = {0, TIMEOUT * 1000};
-        struct timespec      abstime;
         struct fa_msg *      msg;
         struct shm_du_buff * sdb;
-        qoscube_t            qc;
-
-        clock_gettime(PTHREAD_COND_CLOCK, &abstime);
+        struct fa_flow *     flow;
+        qoscube_t            qc = QOS_CUBE_BE;
 
-        pthread_mutex_lock(&ipcpi.alloc_lock);
+        flow = &fa.flows[fd];
 
-        while (ipcpi.alloc_id != fd && ipcp_get_state() == IPCP_OPERATIONAL) {
-                ts_add(&abstime, &ts, &abstime);
-                pthread_cond_timedwait(&ipcpi.alloc_cond,
-                                       &ipcpi.alloc_lock,
-                                       &abstime);
+        if (ipcp_wait_flow_resp(fd) < 0) {
+                log_err("Failed to wait for flow response.");
+                goto fail_alloc_resp;
         }
 
-        if (ipcp_get_state() != IPCP_OPERATIONAL) {
-                pthread_mutex_unlock(&ipcpi.alloc_lock);
-                return -1;
+        if (ipcp_sdb_reserve(&sdb, sizeof(*msg) + data->len)) {
+                log_err("Failed to reserve sdb (%zu  bytes).",
+                        sizeof(*msg) + data->len);
+                goto fail_reserve;
         }
 
-        ipcpi.alloc_id = -1;
-        pthread_cond_broadcast(&ipcpi.alloc_cond);
+        msg = (struct fa_msg *) shm_du_buff_head(sdb);
+        memset(msg, 0, sizeof(*msg));
 
-        pthread_mutex_unlock(&ipcpi.alloc_lock);
+        msg->code     = FLOW_REPLY;
+        msg->response = response;
+        if (data->len > 0)
+                memcpy(msg + 1, data->data, data->len);
 
-        if (ipcp_sdb_reserve(&sdb, sizeof(*msg) + len)) {
-                destroy_conn(fd);
-                return -1;
-        }
+        pthread_rwlock_rdlock(&fa.flows_lock);
 
-        pthread_rwlock_wrlock(&fa.flows_lock);
+        msg->r_eid    = hton64(flow->r_eid);
+        msg->s_eid    = hton64(flow->s_eid);
 
-        msg           = (struct fa_msg *) shm_du_buff_head(sdb);
-        msg->code     = FLOW_REPLY;
-        msg->r_eid    = hton32(fa.r_eid[fd]);
-        msg->s_eid    = hton32(fd);
-        msg->response = response;
+        pthread_rwlock_unlock(&fa.flows_lock);
 
-        memcpy(msg + 1, data, len);
+        if (dt_write_packet(flow->r_addr, qc, fa.eid, sdb)) {
+                log_err("Failed to send flow allocation response packet.");
+                goto fail_packet;
+        }
 
         if (response < 0) {
-                destroy_conn(fd);
-                ipcp_sdb_release(sdb);
+                pthread_rwlock_rdlock(&fa.flows_lock);
+                fa_flow_fini(flow);
+                pthread_rwlock_unlock(&fa.flows_lock);
         } else {
                 psched_add(fa.psched, fd);
         }
 
-        ipcp_flow_get_qoscube(fd, &qc);
+        return 0;
+
+ fail_packet:
+        ipcp_sdb_release(sdb);
+ fail_reserve:
+        pthread_rwlock_wrlock(&fa.flows_lock);
+        fa_flow_fini(flow);
+        pthread_rwlock_unlock(&fa.flows_lock);
+ fail_alloc_resp:
+        return -1;
+}
+
+int fa_dealloc(int fd)
+{
+        if (ipcp_flow_fini(fd) < 0)
+                return 0;
+
+        psched_del(fa.psched, fd);
 
-        assert(qc >= 0 && qc < QOS_CUBE_MAX);
+        pthread_rwlock_wrlock(&fa.flows_lock);
 
-        if (dt_write_packet(fa.r_addr[fd], qc, fa.fd, sdb)) {
-                destroy_conn(fd);
-                pthread_rwlock_unlock(&fa.flows_lock);
-                ipcp_sdb_release(sdb);
+        fa_flow_fini(&fa.flows[fd]);
+
+        pthread_rwlock_unlock(&fa.flows_lock);
+
+        ipcp_flow_dealloc(fd);
+
+        return 0;
+}
+
+static int fa_update_remote(int      fd,
+                            uint16_t ece)
+{
+        struct fa_msg *      msg;
+        struct shm_du_buff * sdb;
+        qoscube_t            qc = QOS_CUBE_BE;
+        struct fa_flow *     flow;
+        uint64_t             r_addr;
+
+        if (ipcp_sdb_reserve(&sdb, sizeof(*msg))) {
+                log_err("Failed to reserve sdb (%zu  bytes).", sizeof(*msg));
                 return -1;
         }
 
+        msg = (struct fa_msg *) shm_du_buff_head(sdb);
+
+        memset(msg, 0, sizeof(*msg));
+
+        flow = &fa.flows[fd];
+
+        pthread_rwlock_wrlock(&fa.flows_lock);
+
+        msg->code  = FLOW_UPDATE;
+        msg->r_eid = hton64(flow->r_eid);
+        msg->ece   = hton16(ece);
+
+        r_addr = flow->r_addr;
+#ifdef IPCP_FLOW_STATS
+        flow->u_snd++;
+#endif
         pthread_rwlock_unlock(&fa.flows_lock);
 
+
+        if (dt_write_packet(r_addr, qc, fa.eid, sdb)) {
+                log_err("Failed to send flow update packet.");
+                ipcp_sdb_release(sdb);
+                return -1;
+        }
+
         return 0;
 }
 
-int fa_dealloc(int fd)
+void  fa_np1_rcv(uint64_t             eid,
+                 uint8_t              ecn,
+                 struct shm_du_buff * sdb)
 {
-        if (ipcp_flow_fini(fd) < 0)
-                return 0;
+        struct fa_flow * flow;
+        bool             update;
+        uint16_t         ece;
+        int              fd;
+        size_t           len;
+
+        len = shm_du_buff_len(sdb);
 
         pthread_rwlock_wrlock(&fa.flows_lock);
 
-        psched_del(fa.psched, fd);
+        fd = eid_to_fd(eid);
+        if (fd < 0) {
+                pthread_rwlock_unlock(&fa.flows_lock);
+                log_dbg("Received packet for unknown EID %" PRIu64 ".", eid);
+                ipcp_sdb_release(sdb);
+                return;
+        }
+
+        flow = &fa.flows[fd];
 
-        destroy_conn(fd);
+#ifdef IPCP_FLOW_STATS
+        ++flow->p_rcv;
+        flow->b_rcv += len;
+#endif
+        update = ca_ctx_update_rcv(flow->ctx, len, ecn, &ece);
 
         pthread_rwlock_unlock(&fa.flows_lock);
 
-        flow_dealloc(fd);
+        if (ipcp_flow_write(fd, sdb) < 0) {
+                log_dbg("Failed to write to flow %d.", fd);
+                ipcp_sdb_release(sdb);
+#ifdef IPCP_FLOW_STATS
+                pthread_rwlock_wrlock(&fa.flows_lock);
+                ++flow->p_rcv_f;
+                flow->b_rcv_f += len;
+                pthread_rwlock_unlock(&fa.flows_lock);
+#endif
+        }
 
-        return 0;
+        if (update)
+                fa_update_remote(eid, ece);
 }
diff --git a/src/ipcpd/unicast/fa.h b/src/ipcpd/unicast/fa.h
index 12a10a0c..1e716966 100644
--- a/src/ipcpd/unicast/fa.h
+++ b/src/ipcpd/unicast/fa.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Flow allocator of the IPC Process
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -34,17 +34,19 @@ int  fa_start(void);
 
 void fa_stop(void);
 
-int  fa_alloc(int             fd,
-              const uint8_t * dst,
-              qosspec_t       qs,
-              const void *    data,
-              size_t          len);
+int  fa_alloc(int              fd,
+              const uint8_t *  dst,
+              qosspec_t        qs,
+              const buffer_t * data);
 
-int  fa_alloc_resp(int          fd,
-                   int          response,
-                   const void * data,
-                   size_t       len);
+int  fa_alloc_resp(int              fd,
+                   int              response,
+                   const buffer_t * data);
 
 int  fa_dealloc(int fd);
 
+void fa_np1_rcv(uint64_t             eid,
+                uint8_t              ecn,
+                struct shm_du_buff * sdb);
+
 #endif /* OUROBOROS_IPCPD_UNICAST_FA_H */
diff --git a/src/ipcpd/unicast/main.c b/src/ipcpd/unicast/main.c
index 43052209..e6cb2994 100644
--- a/src/ipcpd/unicast/main.c
+++ b/src/ipcpd/unicast/main.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Unicast IPC Process
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -29,20 +29,22 @@
 #include "config.h"
 
 #define OUROBOROS_PREFIX "unicast-ipcp"
+#define THIS_TYPE IPCP_UNICAST
 
 #include <ouroboros/errno.h>
-#include <ouroboros/hash.h>
 #include <ouroboros/ipcp-dev.h>
 #include <ouroboros/logs.h>
 #include <ouroboros/notifier.h>
+#include <ouroboros/random.h>
 #include <ouroboros/rib.h>
-#include <ouroboros/time_utils.h>
+#include <ouroboros/time.h>
 
-#include "addr_auth.h"
-#include "connmgr.h"
+#include "common/connmgr.h"
+#include "common/enroll.h"
+#include "addr-auth.h"
+#include "ca.h"
 #include "dir.h"
 #include "dt.h"
-#include "enroll.h"
 #include "fa.h"
 #include "ipcp.h"
 
@@ -53,22 +55,17 @@
 #include <assert.h>
 #include <inttypes.h>
 
-#define THIS_TYPE IPCP_UNICAST
+struct ipcp ipcpi;
 
 static int initialize_components(const struct ipcp_config * conf)
 {
-        ipcpi.layer_name = strdup(conf->layer_info.layer_name);
-        if (ipcpi.layer_name == NULL) {
-                log_err("Failed to set layer name.");
-                goto fail_layer_name;
-        }
-
-        ipcpi.dir_hash_algo = conf->layer_info.dir_hash_algo;
+        strcpy(ipcpi.layer_name, conf->layer_info.name);
+        ipcpi.dir_hash_algo = (enum hash_algo) conf->layer_info.dir_hash_algo;
 
         assert(ipcp_dir_hash_len() != 0);
 
-        if (addr_auth_init(conf->addr_auth_type,
-                           &conf->addr_size)) {
+        if (addr_auth_init(conf->unicast.addr_auth_type,
+                           &conf->unicast.dt.addr_size)) {
                 log_err("Failed to init address authority.");
                 goto fail_addr_auth;
         }
@@ -79,12 +76,14 @@ static int initialize_components(const struct ipcp_config * conf)
                 goto fail_addr_auth;
         }
 
-        log_dbg("IPCP got address %" PRIu64 ".", ipcpi.dt_addr);
+        log_info("IPCP got address %" PRIu64 ".", ipcpi.dt_addr);
+
+        if (ca_init(conf->unicast.cong_avoid)) {
+                log_err("Failed to initialize congestion avoidance.");
+                goto fail_ca;
+        }
 
-        if (dt_init(conf->routing_type,
-                    conf->addr_size,
-                    conf->eid_size,
-                    conf->max_ttl)) {
+        if (dt_init(conf->unicast.dt)) {
                 log_err("Failed to initialize data transfer component.");
                 goto fail_dt;
         }
@@ -108,10 +107,10 @@ static int initialize_components(const struct ipcp_config * conf)
  fail_fa:
         dt_fini();
  fail_dt:
+        ca_fini();
+ fail_ca:
         addr_auth_fini();
  fail_addr_auth:
-        free(ipcpi.layer_name);
- fail_layer_name:
         return -1;
 }
 
@@ -123,28 +122,29 @@ static void finalize_components(void)
 
         dt_fini();
 
-        addr_auth_fini();
+        ca_fini();
 
-        free(ipcpi.layer_name);
+        addr_auth_fini();
 }
 
 static int start_components(void)
 {
-        assert(ipcp_get_state() == IPCP_INIT);
-
-        ipcp_set_state(IPCP_OPERATIONAL);
+        if (dt_start() < 0) {
+                log_err("Failed to start data transfer.");
+                goto fail_dt_start;
+        }
 
-        if (fa_start()) {
+        if (fa_start() < 0) {
                 log_err("Failed to start flow allocator.");
                 goto fail_fa_start;
         }
 
-        if (enroll_start()) {
+        if (enroll_start() < 0) {
                 log_err("Failed to start enrollment.");
                 goto fail_enroll_start;
         }
 
-        if (connmgr_start()) {
+        if (connmgr_start() < 0) {
                 log_err("Failed to start AP connection manager.");
                 goto fail_connmgr_start;
         }
@@ -156,21 +156,22 @@ static int start_components(void)
  fail_enroll_start:
         fa_stop();
  fail_fa_start:
+        dt_stop();
+ fail_dt_start:
         ipcp_set_state(IPCP_INIT);
         return -1;
 }
 
 static void stop_components(void)
 {
-        assert(ipcp_get_state() == IPCP_OPERATIONAL ||
-               ipcp_get_state() == IPCP_SHUTDOWN);
-
         connmgr_stop();
 
         enroll_stop();
 
         fa_stop();
 
+        dt_stop();
+
         ipcp_set_state(IPCP_INIT);
 }
 
@@ -178,7 +179,6 @@ static int bootstrap_components(void)
 {
         if (dir_bootstrap()) {
                 log_err("Failed to bootstrap directory.");
-                dt_stop();
                 return -1;
         }
 
@@ -189,53 +189,54 @@ static int unicast_ipcp_enroll(const char *        dst,
                                struct layer_info * info)
 {
         struct conn conn;
+        uint8_t     id[ENROLL_ID_LEN];
 
-        if (connmgr_alloc(COMPID_ENROLL, dst, NULL, &conn)) {
-                log_err("Failed to get connection.");
-                goto fail_er_flow;
+        if (random_buffer(id, ENROLL_ID_LEN) < 0) {
+                log_err("Failed to generate enrollment ID.");
+                goto fail_id;
         }
 
-        /* Get boot state from peer. */
-        if (enroll_boot(&conn)) {
-                log_err("Failed to get boot information.");
-                goto fail_enroll_boot;
+        log_info_id(id, "Requesting enrollment.");
+
+        if (connmgr_alloc(COMPID_ENROLL, dst, NULL, &conn) < 0) {
+                log_err_id(id, "Failed to get connection.");
+                goto fail_id;
         }
 
-        if (initialize_components(enroll_get_conf())) {
-                log_err("Failed to initialize IPCP components.");
+        /* Get boot state from peer. */
+        if (enroll_boot(&conn, id) < 0) {
+                log_err_id(id, "Failed to get boot information.");
                 goto fail_enroll_boot;
         }
 
-        if (dt_start()) {
-                log_err("Failed to initialize IPCP components.");
-                goto fail_dt_start;
+        if (initialize_components(enroll_get_conf()) < 0) {
+                log_err_id(id, "Failed to initialize components.");
+                goto fail_enroll_boot;
         }
 
-        if (start_components()) {
-                log_err("Failed to start components.");
+        if (start_components() < 0) {
+                log_err_id(id, "Failed to start components.");
                 goto fail_start_comp;
         }
 
-        if (enroll_done(&conn, 0))
-                log_warn("Failed to confirm enrollment with peer.");
+        if (enroll_ack(&conn, id, 0) < 0)
+                log_err_id(id, "Failed to confirm enrollment.");
 
-        if (connmgr_dealloc(COMPID_ENROLL, &conn))
-                log_warn("Failed to deallocate enrollment flow.");
+        if (connmgr_dealloc(COMPID_ENROLL, &conn) < 0)
+                log_warn_id(id, "Failed to dealloc enrollment flow.");
 
-        log_info("Enrolled with %s.", dst);
+        log_info_id(id, "Enrolled with %s.", dst);
 
-        info->dir_hash_algo = ipcpi.dir_hash_algo;
-        strcpy(info->layer_name, ipcpi.layer_name);
+        info->dir_hash_algo = (enum pol_dir_hash) ipcpi.dir_hash_algo;
+        strcpy(info->name, ipcpi.layer_name);
 
         return 0;
 
  fail_start_comp:
-        dt_stop();
- fail_dt_start:
         finalize_components();
  fail_enroll_boot:
         connmgr_dealloc(COMPID_ENROLL, &conn);
- fail_er_flow:
+ fail_id:
         return -1;
 }
 
@@ -246,35 +247,26 @@ static int unicast_ipcp_bootstrap(const struct ipcp_config * conf)
 
         enroll_bootstrap(conf);
 
-        if (initialize_components(conf)) {
+        if (initialize_components(conf) < 0) {
                 log_err("Failed to init IPCP components.");
                 goto fail_init;
         }
 
-        if (dt_start()) {
-                log_err("Failed to initialize IPCP components.");
-                goto fail_dt_start;
-        };
-
-        if (start_components()) {
+        if (start_components() < 0) {
                 log_err("Failed to init IPCP components.");
                 goto fail_start;
         }
 
-        if (bootstrap_components()) {
+        if (bootstrap_components() < 0) {
                 log_err("Failed to bootstrap IPCP components.");
                 goto fail_bootstrap;
         }
 
-        log_dbg("Bootstrapped in layer %s.", conf->layer_info.layer_name);
-
         return 0;
 
  fail_bootstrap:
         stop_components();
  fail_start:
-        dt_stop();
- fail_dt_start:
         finalize_components();
  fail_init:
         return -1;
@@ -302,76 +294,58 @@ static struct ipcp_ops unicast_ops = {
 int main(int    argc,
          char * argv[])
 {
-        if (ipcp_init(argc, argv, &unicast_ops) < 0) {
+        if (ipcp_init(argc, argv, &unicast_ops, THIS_TYPE) < 0) {
                 log_err("Failed to init IPCP.");
                 goto fail_init;
         }
 
-        /* These components must be init at creation. */
-        if (rib_init(ipcpi.name)) {
-                log_err("Failed to initialize RIB.");
-                goto fail_rib_init;
-        }
-
-        if (notifier_init()) {
+        if (notifier_init() < 0) {
                 log_err("Failed to initialize notifier component.");
                 goto fail_notifier_init;
         }
 
-        if (connmgr_init()) {
+        if (connmgr_init() < 0) {
                 log_err("Failed to initialize connection manager.");
                 goto fail_connmgr_init;
         }
 
-        if (enroll_init()) {
+        if (enroll_init() < 0) {
                 log_err("Failed to initialize enrollment component.");
                 goto fail_enroll_init;
         }
 
-        if (ipcp_boot() < 0) {
-                log_err("Failed to boot IPCP.");
-                goto fail_boot;
-        }
-
-        if (ipcp_create_r(0)) {
-                log_err("Failed to notify IRMd we are initialized.");
-                ipcp_set_state(IPCP_NULL);
-                goto fail_create_r;
+        if (ipcp_start() < 0) {
+                log_err("Failed to start IPCP.");
+                goto fail_start;
         }
 
-        ipcp_shutdown();
+        ipcp_sigwait();
 
         if (ipcp_get_state() == IPCP_SHUTDOWN) {
-                dt_stop();
                 stop_components();
                 finalize_components();
         }
 
+        ipcp_stop();
+
         enroll_fini();
 
         connmgr_fini();
 
         notifier_fini();
 
-        rib_fini();
-
         ipcp_fini();
 
         exit(EXIT_SUCCESS);
 
- fail_create_r:
-        ipcp_shutdown();
- fail_boot:
+ fail_start:
         enroll_fini();
  fail_enroll_init:
         connmgr_fini();
  fail_connmgr_init:
         notifier_fini();
  fail_notifier_init:
-        rib_fini();
- fail_rib_init:
-       ipcp_fini();
+        ipcp_fini();
  fail_init:
-        ipcp_create_r(-1);
         exit(EXIT_FAILURE);
 }
diff --git a/src/ipcpd/unicast/pff.c b/src/ipcpd/unicast/pff.c
index 19432972..9b2aa2b4 100644
--- a/src/ipcpd/unicast/pff.c
+++ b/src/ipcpd/unicast/pff.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * PDU Forwarding Function
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -26,14 +26,11 @@
 #include <ouroboros/logs.h>
 
 #include "pff.h"
-#include "pol-pff-ops.h"
-#include "pol/alternate_pff.h"
-#include "pol/multipath_pff.h"
-#include "pol/simple_pff.h"
+#include "pff/pol.h"
 
 struct pff {
-        struct pol_pff_ops * ops;
-        struct pff_i *       pff_i;
+        struct pff_ops * ops;
+        struct pff_i *   pff_i;
 };
 
 struct pff * pff_create(enum pol_pff pol)
@@ -62,8 +59,10 @@ struct pff * pff_create(enum pol_pff pol)
         }
 
         pff->pff_i = pff->ops->create();
-        if (pff->pff_i == NULL)
+        if (pff->pff_i == NULL) {
+                log_err("Failed to create PFF instance.");
                 goto err;
+        }
 
         return pff;
  err:
diff --git a/src/ipcpd/unicast/pff.h b/src/ipcpd/unicast/pff.h
index 962ae594..f44e5531 100644
--- a/src/ipcpd/unicast/pff.h
+++ b/src/ipcpd/unicast/pff.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * PDU Forwarding Function
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
diff --git a/src/ipcpd/unicast/pol/alternate_pff.c b/src/ipcpd/unicast/pff/alternate.c
index f26bb047..85e85914 100644
--- a/src/ipcpd/unicast/pol/alternate_pff.c
+++ b/src/ipcpd/unicast/pff/alternate.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Policy for PFF with alternate next hops
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -28,7 +28,7 @@
 #include <ouroboros/list.h>
 
 #include "pft.h"
-#include "alternate_pff.h"
+#include "alternate.h"
 
 #include <string.h>
 #include <assert.h>
@@ -54,7 +54,7 @@ struct pff_i {
         pthread_rwlock_t lock;
 };
 
-struct pol_pff_ops alternate_pff_ops = {
+struct pff_ops alternate_pff_ops = {
         .create            = alternate_pff_create,
         .destroy           = alternate_pff_destroy,
         .lock              = alternate_pff_lock,
diff --git a/src/ipcpd/unicast/pol/alternate_pff.h b/src/ipcpd/unicast/pff/alternate.h
index 5e5fca3d..96207e74 100644
--- a/src/ipcpd/unicast/pol/alternate_pff.h
+++ b/src/ipcpd/unicast/pff/alternate.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Policy for PFF with alternate next hops
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -23,7 +23,7 @@
 #ifndef OUROBOROS_IPCPD_UNICAST_ALTERNATE_PFF_H
 #define OUROBOROS_IPCPD_UNICAST_ALTERNATE_PFF_H
 
-#include "pol-pff-ops.h"
+#include "ops.h"
 
 struct pff_i * alternate_pff_create(void);
 
@@ -56,6 +56,6 @@ int            alternate_flow_state_change(struct pff_i * pff_i,
                                            int            fd,
                                            bool           up);
 
-struct pol_pff_ops alternate_pff_ops;
+extern struct pff_ops alternate_pff_ops;
 
 #endif /* OUROBOROS_IPCPD_UNICAST_ALTERNATE_PFF_H */
diff --git a/src/ipcpd/unicast/pol/multipath_pff.c b/src/ipcpd/unicast/pff/multipath.c
index 0fe101bc..cbab0f5f 100644
--- a/src/ipcpd/unicast/pol/multipath_pff.c
+++ b/src/ipcpd/unicast/pff/multipath.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Policy for PFF supporting multipath routing
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *    Nick Aerts        <nick.aerts@ugent.be>
  *
  * This program is free software; you can redistribute it and/or modify
@@ -28,7 +28,7 @@
 #include <ouroboros/errno.h>
 
 #include "pft.h"
-#include "multipath_pff.h"
+#include "multipath.h"
 
 #include <string.h>
 #include <assert.h>
@@ -39,7 +39,7 @@ struct pff_i {
         pthread_rwlock_t lock;
 };
 
-struct pol_pff_ops multipath_pff_ops = {
+struct pff_ops multipath_pff_ops = {
         .create            = multipath_pff_create,
         .destroy           = multipath_pff_destroy,
         .lock              = multipath_pff_lock,
@@ -58,21 +58,23 @@ struct pff_i * multipath_pff_create(void)
 
         tmp = malloc(sizeof(*tmp));
         if (tmp == NULL)
-                return NULL;
+                goto fail_malloc;
 
-        if (pthread_rwlock_init(&tmp->lock, NULL)) {
-                free(tmp);
-                return NULL;
-        }
+        if (pthread_rwlock_init(&tmp->lock, NULL))
+                goto fail_rwlock;
 
         tmp->pft = pft_create(PFT_SIZE, false);
-        if (tmp->pft == NULL) {
-                pthread_rwlock_destroy(&tmp->lock);
-                free(tmp);
-                return NULL;
-        }
+        if (tmp->pft == NULL)
+                goto fail_pft;
 
         return tmp;
+
+ fail_pft:
+        pthread_rwlock_destroy(&tmp->lock);
+ fail_rwlock:
+        free(tmp);
+ fail_malloc:
+        return NULL;
 }
 
 void multipath_pff_destroy(struct pff_i * pff_i)
@@ -80,8 +82,8 @@ void multipath_pff_destroy(struct pff_i * pff_i)
         assert(pff_i);
 
         pft_destroy(pff_i->pft);
-
         pthread_rwlock_destroy(&pff_i->lock);
+
         free(pff_i);
 }
 
@@ -177,7 +179,7 @@ int multipath_pff_nhop(struct pff_i * pff_i,
 
         assert(pff_i);
 
-        pthread_rwlock_rdlock(&pff_i->lock);
+        pthread_rwlock_wrlock(&pff_i->lock);
 
         if (pft_lookup(pff_i->pft, addr, &fds, &len)) {
                 pthread_rwlock_unlock(&pff_i->lock);
@@ -189,7 +191,7 @@ int multipath_pff_nhop(struct pff_i * pff_i,
         assert(len > 0);
 
         /* Rotate fds left. */
-        memcpy(fds, fds + 1, (len - 1) * sizeof(*fds));
+        memmove(fds, fds + 1, (len - 1) * sizeof(*fds));
         fds[len - 1] = fd;
 
         pthread_rwlock_unlock(&pff_i->lock);
diff --git a/src/ipcpd/unicast/pol/multipath_pff.h b/src/ipcpd/unicast/pff/multipath.h
index a8ee088f..0eb03476 100644
--- a/src/ipcpd/unicast/pol/multipath_pff.h
+++ b/src/ipcpd/unicast/pff/multipath.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Policy for PFF supporting multipath routing
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *    Nick Aerts        <nick.aerts@ugent.be>
  *
  * This program is free software; you can redistribute it and/or modify
@@ -24,7 +24,7 @@
 #ifndef OUROBOROS_IPCPD_UNICAST_MULTIPATH_PFF_H
 #define OUROBOROS_IPCPD_UNICAST_MULTIPATH_PFF_H
 
-#include "pol-pff-ops.h"
+#include "ops.h"
 
 struct pff_i * multipath_pff_create(void);
 
@@ -53,6 +53,6 @@ void multipath_pff_flush(struct pff_i * pff_i);
 int            multipath_pff_nhop(struct pff_i * pff_i,
                                   uint64_t       addr);
 
-struct pol_pff_ops multipath_pff_ops;
+extern struct pff_ops multipath_pff_ops;
 
 #endif /* OUROBOROS_IPCPD_UNICAST_MULTIPATH_PFF_H */
diff --git a/src/ipcpd/unicast/pol-pff-ops.h b/src/ipcpd/unicast/pff/ops.h
index 9e126cb5..16a31273 100644
--- a/src/ipcpd/unicast/pol-pff-ops.h
+++ b/src/ipcpd/unicast/pff/ops.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Pff policy ops
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -20,14 +20,14 @@
  * Foundation, Inc., http://www.fsf.org/about/contact/.
  */
 
-#ifndef OUROBOROS_IPCPD_UNICAST_POL_PFF_OPS_H
-#define OUROBOROS_IPCPD_UNICAST_POL_PFF_OPS_H
+#ifndef OUROBOROS_IPCPD_UNICAST_PFF_OPS_H
+#define OUROBOROS_IPCPD_UNICAST_PFF_OPS_H
 
 #include <stdbool.h>
 
 struct pff_i;
 
-struct pol_pff_ops {
+struct pff_ops {
         struct pff_i * (* create)(void);
 
         void           (* destroy)(struct pff_i * pff_i);
@@ -60,4 +60,4 @@ struct pol_pff_ops {
                                              bool           up);
 };
 
-#endif /* OUROBOROS_IPCPD_UNICAST_POL_PFF_OPS_H */
+#endif /* OUROBOROS_IPCPD_UNICAST_PFF_OPS_H */
diff --git a/src/ipcpd/unicast/pol/pft.c b/src/ipcpd/unicast/pff/pft.c
index 53acc08e..8c436113 100644
--- a/src/ipcpd/unicast/pol/pft.c
+++ b/src/ipcpd/unicast/pff/pft.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Packet forwarding table (PFT) with chaining on collisions
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -115,19 +115,11 @@ void pft_flush(struct pft * pft)
 
 static uint64_t hash(uint64_t key)
 {
-        void *   res;
-        uint64_t ret;
-        uint8_t  keys[4];
+        uint64_t res[2];
 
-        memcpy(keys, &key, 4);
+        mem_hash(HASH_MD5, res, (uint8_t *) &key, sizeof(key));
 
-        mem_hash(HASH_MD5, &res, keys, 4);
-
-        ret = (* (uint64_t *) res);
-
-        free(res);
-
-        return ret;
+        return res[0];
 }
 
 static uint64_t calc_key(struct pft * pft,
diff --git a/src/ipcpd/unicast/pol/pft.h b/src/ipcpd/unicast/pff/pft.h
index aed4dba8..711dabcb 100644
--- a/src/ipcpd/unicast/pol/pft.h
+++ b/src/ipcpd/unicast/pff/pft.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Packet forwarding table (PFT) with chaining on collisions
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
diff --git a/src/ipcpd/unicast/pff/pol.h b/src/ipcpd/unicast/pff/pol.h
new file mode 100644
index 00000000..245b03c4
--- /dev/null
+++ b/src/ipcpd/unicast/pff/pol.h
@@ -0,0 +1,25 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2024
+ *
+ * PDU Forwarding Function policies
+ *
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
+ *
+ * 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/.
+ */
+
+#include "alternate.h"
+#include "multipath.h"
+#include "simple.h"
diff --git a/src/ipcpd/unicast/pol/simple_pff.c b/src/ipcpd/unicast/pff/simple.c
index 5bd73d8a..5f95e3ce 100644
--- a/src/ipcpd/unicast/pol/simple_pff.c
+++ b/src/ipcpd/unicast/pff/simple.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Simple PDU Forwarding Function
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -27,7 +27,7 @@
 #include <ouroboros/errno.h>
 
 #include "pft.h"
-#include "simple_pff.h"
+#include "simple.h"
 
 #include <assert.h>
 #include <pthread.h>
@@ -37,7 +37,7 @@ struct pff_i {
         pthread_rwlock_t lock;
 };
 
-struct pol_pff_ops simple_pff_ops = {
+struct pff_ops simple_pff_ops = {
         .create            = simple_pff_create,
         .destroy           = simple_pff_destroy,
         .lock              = simple_pff_lock,
diff --git a/src/ipcpd/unicast/pol/simple_pff.h b/src/ipcpd/unicast/pff/simple.h
index 2dfce45c..0966a186 100644
--- a/src/ipcpd/unicast/pol/simple_pff.h
+++ b/src/ipcpd/unicast/pff/simple.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Simple policy for PFF
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -23,7 +23,7 @@
 #ifndef OUROBOROS_IPCPD_UNICAST_SIMPLE_PFF_H
 #define OUROBOROS_IPCPD_UNICAST_SIMPLE_PFF_H
 
-#include "pol-pff-ops.h"
+#include "ops.h"
 
 struct pff_i * simple_pff_create(void);
 
@@ -52,6 +52,6 @@ void           simple_pff_flush(struct pff_i * pff_i);
 int            simple_pff_nhop(struct pff_i * pff_i,
                                uint64_t       addr);
 
-struct pol_pff_ops simple_pff_ops;
+extern struct pff_ops simple_pff_ops;
 
 #endif /* OUROBOROS_IPCPD_UNICAST_SIMPLE_PFF_H */
diff --git a/src/ipcpd/unicast/tests/CMakeLists.txt b/src/ipcpd/unicast/pff/tests/CMakeLists.txt
index 482711d5..65705714 100644
--- a/src/ipcpd/unicast/tests/CMakeLists.txt
+++ b/src/ipcpd/unicast/pff/tests/CMakeLists.txt
@@ -17,19 +17,20 @@ get_filename_component(PARENT_DIR ${PARENT_PATH} NAME)
 
 create_test_sourcelist(${PARENT_DIR}_tests test_suite.c
   # Add new tests here
-  dht_test.c
+  pft_test.c
   )
 
-protobuf_generate_c(KAD_PROTO_SRCS KAD_PROTO_HDRS ../kademlia.proto)
-
-add_executable(${PARENT_DIR}_test EXCLUDE_FROM_ALL ${${PARENT_DIR}_tests}
-  ${KAD_PROTO_SRCS})
+add_executable(${PARENT_DIR}_test EXCLUDE_FROM_ALL ${${PARENT_DIR}_tests})
 target_link_libraries(${PARENT_DIR}_test ouroboros-common)
 
 add_dependencies(check ${PARENT_DIR}_test)
 
 set(tests_to_run ${${PARENT_DIR}_tests})
-remove(tests_to_run test_suite.c)
+if(CMAKE_VERSION VERSION_LESS "3.29.0")
+  remove(tests_to_run test_suite.c)
+else ()
+  list(POP_FRONT tests_to_run)
+endif()
 
 foreach (test ${tests_to_run})
   get_filename_component(test_name ${test} NAME_WE)
diff --git a/src/ipcpd/unicast/pol/tests/pft_test.c b/src/ipcpd/unicast/pff/tests/pft_test.c
index 4e23898b..18287fb8 100644
--- a/src/ipcpd/unicast/pol/tests/pft_test.c
+++ b/src/ipcpd/unicast/pff/tests/pft_test.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Test of the hash table
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
diff --git a/src/ipcpd/unicast/psched.c b/src/ipcpd/unicast/psched.c
index 1ac3fc12..7e12148b 100644
--- a/src/ipcpd/unicast/psched.c
+++ b/src/ipcpd/unicast/psched.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Packet scheduler component
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -31,9 +31,9 @@
 #include <ouroboros/errno.h>
 #include <ouroboros/notifier.h>
 
+#include "common/connmgr.h"
 #include "ipcp.h"
 #include "psched.h"
-#include "connmgr.h"
 
 #include <assert.h>
 #include <sched.h>
@@ -50,6 +50,7 @@ static int qos_prio [] = {
 struct psched {
         fset_t *         set[QOS_CUBE_MAX];
         next_packet_fn_t callback;
+        read_fn_t        read;
         pthread_t        readers[QOS_CUBE_MAX * IPCP_SCHED_THR_MUL];
 };
 
@@ -101,7 +102,7 @@ static void * packet_reader(void * o)
                                 notifier_event(NOTIFY_DT_FLOW_UP, &fd);
                                 break;
                         case FLOW_PKT:
-                                if (ipcp_flow_read(fd, &sdb))
+                                if (sched->read(fd, &sdb) < 0)
                                         continue;
 
                                 sched->callback(fd, qc, sdb);
@@ -117,7 +118,8 @@ static void * packet_reader(void * o)
         return (void *) 0;
 }
 
-struct psched * psched_create(next_packet_fn_t callback)
+struct psched * psched_create(next_packet_fn_t callback,
+                              read_fn_t        read)
 {
         struct psched *       psched;
         struct sched_info *   infos[QOS_CUBE_MAX * IPCP_SCHED_THR_MUL];
@@ -131,6 +133,7 @@ struct psched * psched_create(next_packet_fn_t callback)
                 goto fail_malloc;
 
         psched->callback = callback;
+        psched->read     = read;
 
         for (i = 0; i < QOS_CUBE_MAX; ++i) {
                 psched->set[i] = fset_create();
@@ -160,7 +163,7 @@ struct psched * psched_create(next_packet_fn_t callback)
                         for (j = 0; j < i; ++j)
                                 pthread_join(psched->readers[j], NULL);
                         for (j = i; j < QOS_CUBE_MAX * IPCP_SCHED_THR_MUL; ++j)
-                                free(infos[i]);
+                                free(infos[j]);
                         goto fail_infos;
                 }
         }
diff --git a/src/ipcpd/unicast/psched.h b/src/ipcpd/unicast/psched.h
index 85f32b9a..831f8084 100644
--- a/src/ipcpd/unicast/psched.h
+++ b/src/ipcpd/unicast/psched.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Packet scheduler component
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -30,7 +30,11 @@ typedef void (* next_packet_fn_t)(int                  fd,
                                   qoscube_t            qc,
                                   struct shm_du_buff * sdb);
 
-struct psched * psched_create(next_packet_fn_t callback);
+typedef int (* read_fn_t)(int                   fd,
+                          struct shm_du_buff ** sdb);
+
+struct psched * psched_create(next_packet_fn_t callback,
+                              read_fn_t        read);
 
 void            psched_destroy(struct psched * psched);
 
diff --git a/src/ipcpd/unicast/routing.c b/src/ipcpd/unicast/routing.c
index 0ac43f9f..f5417c24 100644
--- a/src/ipcpd/unicast/routing.c
+++ b/src/ipcpd/unicast/routing.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Routing component of the IPCP
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -26,9 +26,9 @@
 
 #include "pff.h"
 #include "routing.h"
-#include "pol/link_state.h"
+#include "routing/pol.h"
 
-struct pol_routing_ops * r_ops;
+struct routing_ops * r_ops;
 
 int routing_init(enum pol_routing pr)
 {
diff --git a/src/ipcpd/unicast/routing.h b/src/ipcpd/unicast/routing.h
index 38e875e7..d5d833ae 100644
--- a/src/ipcpd/unicast/routing.h
+++ b/src/ipcpd/unicast/routing.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Routing component of the IPCP
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
diff --git a/src/ipcpd/unicast/pol/graph.c b/src/ipcpd/unicast/routing/graph.c
index ba2ce553..32f3e6fb 100644
--- a/src/ipcpd/unicast/pol/graph.c
+++ b/src/ipcpd/unicast/routing/graph.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Undirected graph structure
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *    Nick Aerts        <nick.aerts@ugent.be>
  *
  * This program is free software; you can redistribute it and/or modify
@@ -834,7 +834,7 @@ int graph_routing_table(struct graph *     graph,
                 break;
         default:
                 log_err("Unsupported algorithm.");
-                goto fail_algo;
+                goto fail_table;
         }
 
         pthread_mutex_unlock(&graph->lock);
@@ -843,8 +843,6 @@ int graph_routing_table(struct graph *     graph,
 
         return 0;
 
- fail_algo:
-        free(s_dist);
  fail_table:
         pthread_mutex_unlock(&graph->lock);
         return -1;
diff --git a/src/ipcpd/unicast/pol/graph.h b/src/ipcpd/unicast/routing/graph.h
index 473a5163..8190cc6c 100644
--- a/src/ipcpd/unicast/pol/graph.h
+++ b/src/ipcpd/unicast/routing/graph.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Undirected graph structure
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
diff --git a/src/ipcpd/unicast/pol/link_state.c b/src/ipcpd/unicast/routing/link-state.c
index d9482876..57c0c7cb 100644
--- a/src/ipcpd/unicast/pol/link_state.c
+++ b/src/ipcpd/unicast/routing/link-state.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Link state routing policy
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -38,21 +38,21 @@
 #include <ouroboros/list.h>
 #include <ouroboros/logs.h>
 #include <ouroboros/notifier.h>
+#include <ouroboros/pthread.h>
 #include <ouroboros/rib.h>
 #include <ouroboros/utils.h>
 
-#include "comp.h"
-#include "connmgr.h"
+#include "common/comp.h"
+#include "common/connmgr.h"
 #include "graph.h"
 #include "ipcp.h"
-#include "link_state.h"
+#include "link-state.h"
 #include "pff.h"
 
 #include <assert.h>
 #include <stdlib.h>
 #include <inttypes.h>
 #include <string.h>
-#include <pthread.h>
 
 #define RECALC_TIME    4
 #define LS_UPDATE_TIME 15
@@ -127,7 +127,7 @@ struct {
         enum routing_algo routing_algo;
 } ls;
 
-struct pol_routing_ops link_state_ops = {
+struct routing_ops link_state_ops = {
         .init              = link_state_init,
         .fini              = link_state_fini,
         .routing_i_create  = link_state_routing_i_create,
@@ -179,53 +179,56 @@ static struct adjacency * get_adj(const char * path)
         return NULL;
 }
 
-static int lsdb_getattr(const char *  path,
-                        struct stat * st)
+static int lsdb_rib_getattr(const char *      path,
+                            struct rib_attr * attr)
 {
         struct adjacency * adj;
         struct timespec    now;
+        char *             entry;
 
         assert(path);
-        assert(st);
+        assert(attr);
+
+        entry = strstr(path, RIB_SEPARATOR) + 1;
+        assert(entry);
 
         clock_gettime(CLOCK_REALTIME_COARSE, &now);
 
         pthread_rwlock_rdlock(&ls.db_lock);
 
-        adj = get_adj(path);
+        adj = get_adj(entry);
         if (adj != NULL) {
-                st->st_mtime = adj->stamp;
-                st->st_size  = LS_ENTRY_SIZE;
+                attr->mtime = adj->stamp;
+                attr->size  = LS_ENTRY_SIZE;
         } else {
-                st->st_mtime = now.tv_sec;
-                st->st_size  = 0;
+                attr->mtime = now.tv_sec;
+                attr->size  = 0;
         }
 
-        st->st_mode  = S_IFREG | 0755;
-        st->st_nlink = 1;
-        st->st_uid   = getuid();
-        st->st_gid   = getgid();
-
         pthread_rwlock_unlock(&ls.db_lock);
 
         return 0;
 }
 
-static int lsdb_read(const char * path,
-                     char *       buf,
-                     size_t       len)
+static int lsdb_rib_read(const char * path,
+                         char *       buf,
+                         size_t       len)
 {
         struct adjacency * a;
+        char *             entry;
         int                size;
 
         assert(path);
 
+        entry = strstr(path, RIB_SEPARATOR) + 1;
+        assert(entry);
+
         pthread_rwlock_rdlock(&ls.db_lock);
 
         if (ls.db_len + ls.nbs_len == 0)
                 goto fail;
 
-        a = get_adj(path);
+        a = get_adj(entry);
         if (a == NULL)
                 goto fail;
 
@@ -241,7 +244,7 @@ static int lsdb_read(const char * path,
         return -1;
 }
 
-static int lsdb_readdir(char *** buf)
+static int lsdb_rib_readdir(char *** buf)
 {
         struct list_head * p;
         char               entry[RIB_PATH_LEN + 1];
@@ -270,7 +273,7 @@ static int lsdb_readdir(char *** buf)
                 if ((*buf)[idx] == NULL) {
                         while (idx-- > 0)
                                 free((*buf)[idx]);
-                        free(buf);
+                        free(*buf);
                         pthread_rwlock_unlock(&ls.db_lock);
                         return -ENOMEM;
                 }
@@ -304,9 +307,9 @@ static int lsdb_readdir(char *** buf)
 }
 
 static struct rib_ops r_ops = {
-        .read    = lsdb_read,
-        .readdir = lsdb_readdir,
-        .getattr = lsdb_getattr
+        .read    = lsdb_rib_read,
+        .readdir = lsdb_rib_readdir,
+        .getattr = lsdb_rib_getattr
 };
 
 static int lsdb_add_nb(uint64_t     addr,
@@ -648,8 +651,7 @@ static void * lsupdate(void * o)
 
                 pthread_rwlock_wrlock(&ls.db_lock);
 
-                pthread_cleanup_push((void (*) (void *)) pthread_rwlock_unlock,
-                                     (void *) &ls.db_lock);
+                pthread_cleanup_push(__cleanup_rwlock_unlock, &ls.db_lock);
 
                 list_for_each_safe(p, h, &ls.db) {
                         struct adjacency * adj;
@@ -709,8 +711,7 @@ static void forward_lsm(uint8_t * buf,
 
         pthread_rwlock_rdlock(&ls.db_lock);
 
-        pthread_cleanup_push((void (*))(void *) pthread_rwlock_unlock,
-                             &ls.db_lock);
+        pthread_cleanup_push(__cleanup_rwlock_unlock, &ls.db_lock);
 
         list_for_each(p, &ls.nbs) {
                 struct nb * nb = list_entry(p, struct nb, next);
@@ -721,6 +722,11 @@ static void forward_lsm(uint8_t * buf,
         pthread_cleanup_pop(true);
 }
 
+static void cleanup_fqueue(void * fq)
+{
+        fqueue_destroy((fqueue_t *) fq);
+}
+
 static void * lsreader(void * o)
 {
         fqueue_t *   fq;
@@ -739,8 +745,7 @@ static void * lsreader(void * o)
         if (fq == NULL)
                 return (void *) -1;
 
-        pthread_cleanup_push((void (*) (void *)) fqueue_destroy,
-                             (void *) fq);
+        pthread_cleanup_push(cleanup_fqueue, fq);
 
         while (true) {
                 ret = fevent(ls.mgmt_set, fq, NULL);
@@ -812,8 +817,11 @@ static void handle_event(void *       self,
         switch (event) {
         case NOTIFY_DT_CONN_ADD:
                 pthread_rwlock_rdlock(&ls.db_lock);
+
+                pthread_cleanup_push(__cleanup_rwlock_unlock, &ls.db_lock);
+
                 send_lsm(ipcpi.dt_addr, c->conn_info.addr, 0);
-                pthread_rwlock_unlock(&ls.db_lock);
+                pthread_cleanup_pop(true);
 
                 if (lsdb_add_nb(c->conn_info.addr, c->flow_info.fd, NB_DT))
                         log_dbg("Failed to add neighbor to LSDB.");
diff --git a/src/ipcpd/unicast/pol/link_state.h b/src/ipcpd/unicast/routing/link-state.h
index 9d4858e1..d77d72df 100644
--- a/src/ipcpd/unicast/pol/link_state.h
+++ b/src/ipcpd/unicast/routing/link-state.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Link state routing policy
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -26,7 +26,7 @@
 #define LS_COMP  "Management"
 #define LS_PROTO "LSP"
 
-#include "pol-routing-ops.h"
+#include "ops.h"
 
 int                link_state_init(enum pol_routing pr);
 
@@ -36,6 +36,6 @@ struct routing_i * link_state_routing_i_create(struct pff * pff);
 
 void               link_state_routing_i_destroy(struct routing_i * instance);
 
-struct pol_routing_ops link_state_ops;
+extern struct routing_ops link_state_ops;
 
 #endif /* OUROBOROS_IPCPD_UNICAST_POL_LINK_STATE_H */
diff --git a/src/ipcpd/unicast/pol-routing-ops.h b/src/ipcpd/unicast/routing/ops.h
index 3fa1d573..8a79b7ec 100644
--- a/src/ipcpd/unicast/pol-routing-ops.h
+++ b/src/ipcpd/unicast/routing/ops.h
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Routing policy ops
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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
@@ -20,12 +20,12 @@
  * Foundation, Inc., http://www.fsf.org/about/contact/.
  */
 
-#ifndef OUROBOROS_IPCPD_UNICAST_POL_ROUTING_OPS_H
-#define OUROBOROS_IPCPD_UNICAST_POL_ROUTING_OPS_H
+#ifndef OUROBOROS_IPCPD_UNICAST_ROUTING_OPS_H
+#define OUROBOROS_IPCPD_UNICAST_ROUTING_OPS_H
 
 #include "pff.h"
 
-struct pol_routing_ops {
+struct routing_ops {
         int                (* init)(enum pol_routing pr);
 
         void               (* fini)(void);
@@ -35,4 +35,4 @@ struct pol_routing_ops {
         void               (* routing_i_destroy)(struct routing_i * instance);
 };
 
-#endif /* OUROBOROS_IPCPD_UNICAST_POL_ROUTING_OPS_H */
+#endif /* OUROBOROS_IPCPD_UNICAST_ROUTING_OPS_H */
diff --git a/src/ipcpd/unicast/routing/pol.h b/src/ipcpd/unicast/routing/pol.h
new file mode 100644
index 00000000..b6a6f150
--- /dev/null
+++ b/src/ipcpd/unicast/routing/pol.h
@@ -0,0 +1,23 @@
+/*
+ * Ouroboros - Copyright (C) 2016 - 2024
+ *
+ * Routing policies
+ *
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
+ *
+ * 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/.
+ */
+
+#include "link-state.h"
diff --git a/src/ipcpd/unicast/pol/tests/CMakeLists.txt b/src/ipcpd/unicast/routing/tests/CMakeLists.txt
index 34d80e8d..9d24bf03 100644
--- a/src/ipcpd/unicast/pol/tests/CMakeLists.txt
+++ b/src/ipcpd/unicast/routing/tests/CMakeLists.txt
@@ -18,7 +18,6 @@ get_filename_component(PARENT_DIR ${PARENT_PATH} NAME)
 create_test_sourcelist(${PARENT_DIR}_tests test_suite.c
   # Add new tests here
   graph_test.c
-  pft_test.c
   )
 
 add_executable(${PARENT_DIR}_test EXCLUDE_FROM_ALL ${${PARENT_DIR}_tests})
@@ -27,7 +26,11 @@ target_link_libraries(${PARENT_DIR}_test ouroboros-common)
 add_dependencies(check ${PARENT_DIR}_test)
 
 set(tests_to_run ${${PARENT_DIR}_tests})
-remove(tests_to_run test_suite.c)
+if(CMAKE_VERSION VERSION_LESS "3.29.0")
+  remove(tests_to_run test_suite.c)
+else ()
+  list(POP_FRONT tests_to_run)
+endif()
 
 foreach (test ${tests_to_run})
   get_filename_component(test_name ${test} NAME_WE)
diff --git a/src/ipcpd/unicast/pol/tests/graph_test.c b/src/ipcpd/unicast/routing/tests/graph_test.c
index ea4c0e59..d805640c 100644
--- a/src/ipcpd/unicast/pol/tests/graph_test.c
+++ b/src/ipcpd/unicast/routing/tests/graph_test.c
@@ -1,10 +1,10 @@
 /*
- * Ouroboros - Copyright (C) 2016 - 2020
+ * Ouroboros - Copyright (C) 2016 - 2024
  *
  * Test of the graph structure
  *
- *    Dimitri Staessens <dimitri.staessens@ugent.be>
- *    Sander Vrijders   <sander.vrijders@ugent.be>
+ *    Dimitri Staessens <dimitri@ouroboros.rocks>
+ *    Sander Vrijders   <sander@ouroboros.rocks>
  *
  * 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