Adding upstream version 0.8.0.upstream/0.8.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

10 files changed, 3089 insertions, 0 deletions

diff --git a/rtrlib/rtr/packets.c b/rtrlib/rtr/packets.c
new file mode 100644
index 0000000..ec00779
--- /dev/null
+++ b/rtrlib/rtr/packets.c
@@ -0,0 +1,1517 @@
+/*
+ * This file is part of RTRlib.
+ *
+ * This file is subject to the terms and conditions of the MIT license.
+ * See the file LICENSE in the top level directory for more details.
+ *
+ * Website: http://rtrlib.realmv6.org/
+ */
+
+#include "packets_private.h"
+
+#include "rtrlib/lib/alloc_utils_private.h"
+#include "rtrlib/lib/convert_byte_order_private.h"
+#include "rtrlib/lib/log_private.h"
+#include "rtrlib/lib/utils_private.h"
+#include "rtrlib/pfx/pfx_private.h"
+#include "rtrlib/rtr/rtr_private.h"
+#include "rtrlib/spki/hashtable/ht-spkitable_private.h"
+#include "rtrlib/transport/transport_private.h"
+
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MGR_DBG1(a) lrtr_dbg("RTR_MGR: " a)
+#define TEMPORARY_PDU_STORE_INCREMENT_VALUE 100
+#define MAX_SUPPORTED_PDU_TYPE 10
+
+enum pdu_error_type {
+	CORRUPT_DATA = 0,
+	INTERNAL_ERROR = 1,
+	NO_DATA_AVAIL = 2,
+	INVALID_REQUEST = 3,
+	UNSUPPORTED_PROTOCOL_VER = 4,
+	UNSUPPORTED_PDU_TYPE = 5,
+	WITHDRAWAL_OF_UNKNOWN_RECORD = 6,
+	DUPLICATE_ANNOUNCEMENT = 7,
+	UNEXPECTED_PROTOCOL_VERSION = 8,
+	PDU_TOO_BIG = 32
+};
+
+enum pdu_type {
+	SERIAL_NOTIFY = 0,
+	SERIAL_QUERY = 1,
+	RESET_QUERY = 2,
+	CACHE_RESPONSE = 3,
+	IPV4_PREFIX = 4,
+	RESERVED = 5,
+	IPV6_PREFIX = 6,
+	EOD = 7,
+	CACHE_RESET = 8,
+	ROUTER_KEY = 9,
+	ERROR = 10
+};
+
+struct pdu_header {
+	uint8_t ver;
+	uint8_t type;
+	uint16_t reserved;
+	uint32_t len;
+};
+
+struct pdu_cache_response {
+	uint8_t ver;
+	uint8_t type;
+	uint16_t session_id;
+	uint32_t len;
+};
+
+struct pdu_serial_notify {
+	uint8_t ver;
+	uint8_t type;
+	uint16_t session_id;
+	uint32_t len;
+	uint32_t sn;
+};
+
+struct pdu_serial_query {
+	uint8_t ver;
+	uint8_t type;
+	uint16_t session_id;
+	uint32_t len;
+	uint32_t sn;
+};
+
+struct pdu_ipv4 {
+	uint8_t ver;
+	uint8_t type;
+	uint16_t reserved;
+	uint32_t len;
+	uint8_t flags;
+	uint8_t prefix_len;
+	uint8_t max_prefix_len;
+	uint8_t zero;
+	uint32_t prefix;
+	uint32_t asn;
+};
+
+struct pdu_ipv6 {
+	uint8_t ver;
+	uint8_t type;
+	uint16_t reserved;
+	uint32_t len;
+	uint8_t flags;
+	uint8_t prefix_len;
+	uint8_t max_prefix_len;
+	uint8_t zero;
+	uint32_t prefix[4];
+	uint32_t asn;
+};
+
+struct pdu_error {
+	uint8_t ver;
+	uint8_t type;
+	uint16_t error_code;
+	uint32_t len;
+	uint32_t len_enc_pdu;
+	uint8_t rest[];
+};
+
+struct pdu_router_key {
+	uint8_t ver;
+	uint8_t type;
+	uint8_t flags;
+	uint8_t zero;
+	uint32_t len;
+	uint8_t ski[SKI_SIZE];
+	uint32_t asn;
+	uint8_t spki[SPKI_SIZE];
+} __attribute__((packed));
+
+/*
+ * 0          8          16         24        31
+ * .-------------------------------------------.
+ * | Protocol |   PDU    |                     |
+ * | Version  |   Type   |    reserved = zero  |
+ * |    0     |    2     |                     |
+ * +-------------------------------------------+
+ * |                                           |
+ * |                 Length=8                  |
+ * |                                           |
+ * `-------------------------------------------'
+ */
+struct pdu_reset_query {
+	uint8_t ver;
+	uint8_t type;
+	uint16_t flags;
+	uint32_t len;
+};
+
+struct pdu_end_of_data_v0 {
+	uint8_t ver;
+	uint8_t type;
+	uint16_t session_id;
+	uint32_t len;
+	uint32_t sn;
+};
+
+struct pdu_end_of_data_v1 {
+	uint8_t ver;
+	uint8_t type;
+	uint16_t session_id;
+	uint32_t len;
+	uint32_t sn;
+	uint32_t refresh_interval;
+	uint32_t retry_interval;
+	uint32_t expire_interval;
+};
+
+struct recv_loop_cleanup_args {
+	struct pdu_ipv4 *ipv4_pdus;
+	struct pdu_ipv6 *ipv6_pdus;
+	struct pdu_router_key *router_key_pdus;
+};
+
+static void recv_loop_cleanup(void *p);
+
+static int rtr_send_error_pdu_from_network(const struct rtr_socket *rtr_socket, const void *erroneous_pdu,
+					   const uint32_t erroneous_pdu_len, const enum pdu_error_type error,
+					   const char *err_text, const uint32_t err_text_len);
+
+static int rtr_send_error_pdu_from_host(const struct rtr_socket *rtr_socket, const void *erroneous_pdu,
+					const uint32_t erroneous_pdu_len, const enum pdu_error_type error,
+					const char *err_text, const uint32_t err_text_len);
+
+static int interval_send_error_pdu(struct rtr_socket *rtr_socket, void *pdu, uint32_t interval, uint16_t minimum,
+				   uint32_t maximum);
+
+static inline enum pdu_type rtr_get_pdu_type(const void *pdu)
+{
+	return *((char *)pdu + 1);
+}
+
+static int rtr_set_last_update(struct rtr_socket *rtr_socket)
+{
+	if (lrtr_get_monotonic_time(&(rtr_socket->last_update)) == -1) {
+		RTR_DBG1("get_monotonic_time(..) failed ");
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+		return RTR_ERROR;
+	}
+	return RTR_SUCCESS;
+}
+
+int rtr_check_interval_range(uint32_t interval, uint32_t minimum, uint32_t maximum)
+{
+	if (interval < minimum)
+		return RTR_BELOW_INTERVAL_RANGE;
+	else if (interval > maximum)
+		return RTR_ABOVE_INTERVAL_RANGE;
+
+	return RTR_INSIDE_INTERVAL_RANGE;
+}
+
+void apply_interval_value(struct rtr_socket *rtr_socket, uint32_t interval, enum rtr_interval_type type)
+{
+	if (type == RTR_INTERVAL_TYPE_EXPIRATION)
+		rtr_socket->expire_interval = interval;
+	else if (type == RTR_INTERVAL_TYPE_REFRESH)
+		rtr_socket->refresh_interval = interval;
+	else if (type == RTR_INTERVAL_TYPE_RETRY)
+		rtr_socket->retry_interval = interval;
+}
+
+int rtr_check_interval_option(struct rtr_socket *rtr_socket, int interval_mode, uint32_t interval,
+			      enum rtr_interval_type type)
+{
+	uint16_t minimum;
+	uint32_t maximum;
+
+	int interv_retval;
+
+	switch (type) {
+	case RTR_INTERVAL_TYPE_EXPIRATION:
+		minimum = RTR_EXPIRATION_MIN;
+		maximum = RTR_EXPIRATION_MAX;
+		interv_retval = rtr_check_interval_range(interval, minimum, maximum);
+		break;
+	case RTR_INTERVAL_TYPE_REFRESH:
+		minimum = RTR_REFRESH_MIN;
+		maximum = RTR_REFRESH_MAX;
+		interv_retval = rtr_check_interval_range(interval, minimum, maximum);
+		break;
+	case RTR_INTERVAL_TYPE_RETRY:
+		minimum = RTR_RETRY_MIN;
+		maximum = RTR_RETRY_MAX;
+		interv_retval = rtr_check_interval_range(interval, minimum, maximum);
+		break;
+	default:
+		RTR_DBG("Invalid interval type: %u.", type);
+		return RTR_ERROR;
+	}
+
+	if (interv_retval == RTR_INSIDE_INTERVAL_RANGE || interval_mode == RTR_INTERVAL_MODE_ACCEPT_ANY) {
+		apply_interval_value(rtr_socket, interval, type);
+	} else if (interval_mode == RTR_INTERVAL_MODE_DEFAULT_MIN_MAX) {
+		if (interv_retval == RTR_BELOW_INTERVAL_RANGE)
+			apply_interval_value(rtr_socket, minimum, type);
+		else
+			apply_interval_value(rtr_socket, maximum, type);
+	} else {
+		RTR_DBG("Received expiration value out of range. Was %u. It will be ignored.",
+			interval);
+	}
+
+	return RTR_SUCCESS;
+}
+
+void rtr_change_socket_state(struct rtr_socket *rtr_socket, const enum rtr_socket_state new_state)
+{
+	if (rtr_socket->state == new_state)
+		return;
+
+	// RTR_SHUTDOWN state is final,struct rtr_socket will be shutdowned can't be switched to any other state
+	if (rtr_socket->state == RTR_SHUTDOWN)
+		return;
+
+	rtr_socket->state = new_state;
+	if (new_state == RTR_SHUTDOWN)
+		MGR_DBG1("Calling rtr_mgr_cb with RTR_SHUTDOWN");
+
+	if (rtr_socket->connection_state_fp)
+		rtr_socket->connection_state_fp(rtr_socket, new_state, rtr_socket->connection_state_fp_param_config,
+						rtr_socket->connection_state_fp_param_group);
+}
+
+static void rtr_pdu_convert_header_byte_order(void *pdu, const enum target_byte_order target_byte_order)
+{
+	struct pdu_header *header = pdu;
+
+	// The ROUTER_KEY PDU has two 1 Byte fields instead of the 2 Byte reserved field.
+	if (header->type != ROUTER_KEY)
+		header->reserved = lrtr_convert_short(target_byte_order, header->reserved);
+
+	header->len = lrtr_convert_long(target_byte_order, header->len);
+}
+
+static void rtr_pdu_convert_footer_byte_order(void *pdu, const enum target_byte_order target_byte_order)
+{
+	struct pdu_error *err_pdu;
+	struct pdu_header *header = pdu;
+	uint32_t addr6[4];
+	const enum pdu_type type = rtr_get_pdu_type(pdu);
+
+	switch (type) {
+	case SERIAL_QUERY:
+		((struct pdu_serial_query *)pdu)->sn =
+			lrtr_convert_long(target_byte_order, ((struct pdu_serial_query *)pdu)->sn);
+		break;
+
+	case ERROR:
+		err_pdu = (struct pdu_error *)pdu;
+		if (target_byte_order == TO_NETWORK_BYTE_ORDER) {
+			*((uint32_t *)(err_pdu->rest + err_pdu->len_enc_pdu)) = lrtr_convert_long(
+				target_byte_order, *((uint32_t *)(err_pdu->rest + err_pdu->len_enc_pdu)));
+			err_pdu->len_enc_pdu = lrtr_convert_long(target_byte_order, err_pdu->len_enc_pdu);
+		} else {
+			err_pdu->len_enc_pdu = lrtr_convert_long(target_byte_order, err_pdu->len_enc_pdu);
+			*((uint32_t *)(err_pdu->rest + err_pdu->len_enc_pdu)) = lrtr_convert_long(
+				target_byte_order, *((uint32_t *)(err_pdu->rest + err_pdu->len_enc_pdu)));
+		}
+		break;
+
+	case SERIAL_NOTIFY:
+		((struct pdu_serial_notify *)pdu)->sn =
+			lrtr_convert_long(target_byte_order, ((struct pdu_serial_notify *)pdu)->sn);
+		break;
+
+	case EOD:
+		if (header->ver == RTR_PROTOCOL_VERSION_1) {
+			((struct pdu_end_of_data_v1 *)pdu)->expire_interval = lrtr_convert_long(
+				target_byte_order, ((struct pdu_end_of_data_v1 *)pdu)->expire_interval);
+
+			((struct pdu_end_of_data_v1 *)pdu)->refresh_interval = lrtr_convert_long(
+				target_byte_order, ((struct pdu_end_of_data_v1 *)pdu)->refresh_interval);
+
+			((struct pdu_end_of_data_v1 *)pdu)->retry_interval = lrtr_convert_long(
+				target_byte_order, ((struct pdu_end_of_data_v1 *)pdu)->retry_interval);
+
+			((struct pdu_end_of_data_v1 *)pdu)->sn =
+				lrtr_convert_long(target_byte_order, ((struct pdu_end_of_data_v1 *)pdu)->sn);
+		} else {
+			((struct pdu_end_of_data_v0 *)pdu)->sn =
+				lrtr_convert_long(target_byte_order, ((struct pdu_end_of_data_v0 *)pdu)->sn);
+		}
+		break;
+
+	case IPV4_PREFIX:
+		lrtr_ipv4_addr_convert_byte_order(((struct pdu_ipv4 *)pdu)->prefix, &((struct pdu_ipv4 *)pdu)->prefix,
+						  target_byte_order);
+		((struct pdu_ipv4 *)pdu)->asn = lrtr_convert_long(target_byte_order, ((struct pdu_ipv4 *)pdu)->asn);
+		break;
+
+	case IPV6_PREFIX:
+		lrtr_ipv6_addr_convert_byte_order(((struct pdu_ipv6 *)pdu)->prefix, addr6, target_byte_order);
+		memcpy(((struct pdu_ipv6 *)pdu)->prefix, addr6, sizeof(addr6));
+		((struct pdu_ipv6 *)pdu)->asn = lrtr_convert_long(target_byte_order, ((struct pdu_ipv6 *)pdu)->asn);
+		break;
+
+	case ROUTER_KEY:
+		((struct pdu_router_key *)pdu)->asn =
+			lrtr_convert_long(target_byte_order, ((struct pdu_router_key *)pdu)->asn);
+		break;
+
+	default:
+		break;
+	}
+}
+
+static void rtr_pdu_header_to_network_byte_order(void *pdu)
+{
+	rtr_pdu_convert_header_byte_order(pdu, TO_NETWORK_BYTE_ORDER);
+}
+
+static void rtr_pdu_footer_to_network_byte_order(void *pdu)
+{
+	rtr_pdu_convert_footer_byte_order(pdu, TO_NETWORK_BYTE_ORDER);
+}
+
+static void rtr_pdu_to_network_byte_order(void *pdu)
+{
+	rtr_pdu_footer_to_network_byte_order(pdu);
+	rtr_pdu_header_to_network_byte_order(pdu);
+}
+
+static void rtr_pdu_footer_to_host_byte_order(void *pdu)
+{
+	rtr_pdu_convert_footer_byte_order(pdu, TO_HOST_HOST_BYTE_ORDER);
+}
+
+static void rtr_pdu_header_to_host_byte_order(void *pdu)
+{
+	rtr_pdu_convert_header_byte_order(pdu, TO_HOST_HOST_BYTE_ORDER);
+}
+
+/*
+ * Check if the PDU is big enough for the PDU type it
+ * pretend to be.
+ * @param pdu A pointer to a PDU that is at least pdu->len byte large.
+ * @return False if the check fails, else true
+ */
+static bool rtr_pdu_check_size(const struct pdu_header *pdu)
+{
+	const enum pdu_type type = rtr_get_pdu_type(pdu);
+	const struct pdu_error *err_pdu = NULL;
+	bool retval = false;
+	uint64_t min_size = 0;
+
+	switch (type) {
+	case SERIAL_NOTIFY:
+		if (sizeof(struct pdu_serial_notify) == pdu->len)
+			retval = true;
+		break;
+	case CACHE_RESPONSE:
+		if (sizeof(struct pdu_cache_response) == pdu->len)
+			retval = true;
+		break;
+	case IPV4_PREFIX:
+		if (sizeof(struct pdu_ipv4) == pdu->len)
+			retval = true;
+		break;
+	case IPV6_PREFIX:
+		if (sizeof(struct pdu_ipv6) == pdu->len)
+			retval = true;
+		break;
+	case EOD:
+		if ((pdu->ver == RTR_PROTOCOL_VERSION_0 && (sizeof(struct pdu_end_of_data_v0) == pdu->len)) ||
+		    (pdu->ver == RTR_PROTOCOL_VERSION_1 && (sizeof(struct pdu_end_of_data_v1) == pdu->len))) {
+			retval = true;
+		}
+		break;
+	case CACHE_RESET:
+		if (sizeof(struct pdu_header) == pdu->len)
+			retval = true;
+		break;
+	case ROUTER_KEY:
+		if (sizeof(struct pdu_router_key) == pdu->len)
+			retval = true;
+		break;
+	case ERROR:
+		err_pdu = (const struct pdu_error *)pdu;
+		// +4 because of the "Length of Error Text" field
+		min_size = 4 + sizeof(struct pdu_error);
+		if (err_pdu->len < min_size) {
+			RTR_DBG1("PDU is too small to contain \"Length of Error Text\" field!");
+			break;
+		}
+
+		// Check if the PDU really contains the error PDU
+		uint32_t enc_pdu_len = ntohl(err_pdu->len_enc_pdu);
+
+		RTR_DBG("enc_pdu_len: %u", enc_pdu_len);
+		min_size += enc_pdu_len;
+		if (err_pdu->len < min_size) {
+			RTR_DBG1("PDU is too small to contain erroneous PDU!");
+			break;
+		}
+
+		// Check if the the PDU really contains the error msg
+		uint32_t err_msg_len = ntohl(*((uint32_t *)(err_pdu->rest + enc_pdu_len)));
+
+		RTR_DBG("err_msg_len: %u", err_msg_len);
+		min_size += err_msg_len;
+		if (err_pdu->len != min_size) {
+			RTR_DBG1("PDU is too small to contain error_msg!");
+			break;
+		}
+
+		retval = true;
+		break;
+	case SERIAL_QUERY:
+		if (sizeof(struct pdu_serial_query) == pdu->len)
+			retval = true;
+		break;
+	case RESET_QUERY:
+		if (sizeof(struct pdu_reset_query) == pdu->len)
+			retval = true;
+		break;
+	case RESERVED:
+	default:
+		RTR_DBG1("PDU type is unknown or reserved!");
+		retval = false;
+		break;
+	}
+
+#ifndef NDEBUG
+	if (!retval)
+		RTR_DBG1("Received malformed PDU!");
+#endif
+
+	return retval;
+}
+
+static int rtr_send_pdu(const struct rtr_socket *rtr_socket, const void *pdu, const unsigned int len)
+{
+	char pdu_converted[len];
+
+	memcpy(pdu_converted, pdu, len);
+	rtr_pdu_to_network_byte_order(pdu_converted);
+	if (rtr_socket->state == RTR_SHUTDOWN)
+		return RTR_ERROR;
+	const int rtval = tr_send_all(rtr_socket->tr_socket, pdu_converted, len, RTR_SEND_TIMEOUT);
+
+	if (rtval > 0)
+		return RTR_SUCCESS;
+	if (rtval == TR_WOULDBLOCK) {
+		RTR_DBG1("send would block");
+		return RTR_ERROR;
+	}
+
+	RTR_DBG1("Error sending PDU");
+	return RTR_ERROR;
+}
+
+/*
+ * if RTR_ERROR was returned a error PDU was sent, and the socket state changed
+ * @param pdu_len must >= RTR_MAX_PDU_LEN Bytes
+ * @return RTR_SUCCESS
+ * @return RTR_ERROR, error pdu was sent and socket_state changed
+ * @return TR_WOULDBLOCK
+ * \post
+ * If RTR_SUCCESS is returned PDU points to a well formed PDU that has
+ * the appropriate size for the PDU type it pretend to be. Thus, casting it to
+ * the PDU type struct and using it is save. Furthermore all PDU field are
+ * in host-byte-order.
+ */
+static int rtr_receive_pdu(struct rtr_socket *rtr_socket, void *pdu, const size_t pdu_len, const time_t timeout)
+{
+	int error = RTR_SUCCESS;
+
+	assert(pdu_len >= RTR_MAX_PDU_LEN);
+
+	if (rtr_socket->state == RTR_SHUTDOWN)
+		return RTR_ERROR;
+	// receive packet header
+	error = tr_recv_all(rtr_socket->tr_socket, pdu, sizeof(struct pdu_header), timeout);
+	if (error < 0)
+		goto error;
+	else
+		error = RTR_SUCCESS;
+
+	// header in hostbyte order, retain original received pdu, in case we need to detach it to an error pdu
+	struct pdu_header header;
+
+	memcpy(&header, pdu, sizeof(header));
+	rtr_pdu_header_to_host_byte_order(&header);
+
+	// if header->len is < packet_header = corrupt data received
+	if (header.len < sizeof(header)) {
+		error = CORRUPT_DATA;
+		goto error;
+	} else if (header.len > RTR_MAX_PDU_LEN) { // PDU too big, > than MAX_PDU_LEN Bytes
+		error = PDU_TOO_BIG;
+		goto error;
+	}
+
+	// Handle live downgrading
+	if (!rtr_socket->has_received_pdus) {
+		if (rtr_socket->version == RTR_PROTOCOL_VERSION_1 && header.ver == RTR_PROTOCOL_VERSION_0 &&
+		    header.type != ERROR) {
+			RTR_DBG("First received PDU is a version 0 PDU, downgrading to %u", RTR_PROTOCOL_VERSION_0);
+			rtr_socket->version = RTR_PROTOCOL_VERSION_0;
+		}
+		rtr_socket->has_received_pdus = true;
+	}
+
+	// Handle wrong protocol version
+	// If it is a error PDU, it will be handled by rtr_handle_error_pdu
+	if (header.ver != rtr_socket->version && header.type != ERROR) {
+		error = UNEXPECTED_PROTOCOL_VERSION;
+		goto error;
+	}
+
+	// receive packet payload
+	const unsigned int remaining_len = header.len - sizeof(header);
+
+	if (remaining_len > 0) {
+		if (rtr_socket->state == RTR_SHUTDOWN)
+			return RTR_ERROR;
+		error = tr_recv_all(rtr_socket->tr_socket, (((char *)pdu) + sizeof(header)), remaining_len,
+				    RTR_RECV_TIMEOUT);
+		if (error < 0)
+			goto error;
+		else
+			error = RTR_SUCCESS;
+	}
+	// copy header in host_byte_order to pdu
+	memcpy(pdu, &header, sizeof(header));
+
+	// Check if the header len value is valid
+	if (rtr_pdu_check_size(pdu) == false) {
+		// TODO Restore byteorder for sending error PDU
+		error = CORRUPT_DATA;
+		goto error;
+	}
+	// At this point it is save to cast and use the PDU
+
+	rtr_pdu_footer_to_host_byte_order(pdu);
+
+	// Here we should handle error PDUs instead of doing it in
+	// several other places...
+
+	if (header.type == IPV4_PREFIX || header.type == IPV6_PREFIX) {
+		if (((struct pdu_ipv4 *)pdu)->zero != 0)
+			RTR_DBG1("Warning: Zero field of received Prefix PDU doesn't contain 0");
+	}
+	if (header.type == ROUTER_KEY && ((struct pdu_router_key *)pdu)->zero != 0)
+		RTR_DBG1("Warning: ROUTER_KEY_PDU zero field is != 0");
+
+	return RTR_SUCCESS;
+
+error:
+	// send error msg to server, including unmodified pdu header(pdu variable instead header)
+	if (error == -1) {
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_TRANSPORT);
+		return RTR_ERROR;
+	} else if (error == TR_WOULDBLOCK) {
+		RTR_DBG1("receive timeout expired");
+		return TR_WOULDBLOCK;
+	} else if (error == TR_INTR) {
+		RTR_DBG1("receive call interrupted");
+		return TR_INTR;
+	} else if (error == CORRUPT_DATA) {
+		RTR_DBG1("corrupt PDU received");
+		const char txt[] = "corrupt data received, length value in PDU is too small";
+
+		rtr_send_error_pdu_from_network(rtr_socket, pdu, sizeof(header), CORRUPT_DATA, txt, sizeof(txt));
+	} else if (error == PDU_TOO_BIG) {
+		RTR_DBG1("PDU too big");
+		char txt[42];
+
+		snprintf(txt, sizeof(txt), "PDU too big, max. PDU size is: %u bytes", RTR_MAX_PDU_LEN);
+		RTR_DBG("%s", txt);
+		rtr_send_error_pdu_from_network(rtr_socket, pdu, sizeof(header), CORRUPT_DATA, txt, sizeof(txt));
+	} else if (error == UNSUPPORTED_PDU_TYPE) {
+		RTR_DBG("Unsupported PDU type (%u) received", header.type);
+		rtr_send_error_pdu_from_network(rtr_socket, pdu, sizeof(header), UNSUPPORTED_PDU_TYPE, NULL, 0);
+	} else if (error == UNSUPPORTED_PROTOCOL_VER) {
+		RTR_DBG("PDU with unsupported Protocol version (%u) received", header.ver);
+		rtr_send_error_pdu_from_network(rtr_socket, pdu, sizeof(header), UNSUPPORTED_PROTOCOL_VER, NULL, 0);
+		return RTR_ERROR;
+	} else if (error == UNEXPECTED_PROTOCOL_VERSION) {
+		RTR_DBG("PDU with unexpected Protocol version (%u) received", header.ver);
+		rtr_send_error_pdu_from_network(rtr_socket, pdu, sizeof(header), UNEXPECTED_PROTOCOL_VERSION, NULL, 0);
+		return RTR_ERROR;
+	}
+
+	rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+	return RTR_ERROR;
+}
+
+static int rtr_handle_error_pdu(struct rtr_socket *rtr_socket, const void *buf)
+{
+	RTR_DBG1("Error PDU received"); // TODO: append server ip & port
+	const struct pdu_error *pdu = buf;
+
+	switch (pdu->error_code) {
+	case CORRUPT_DATA:
+		RTR_DBG1("Corrupt data received");
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+		break;
+	case INTERNAL_ERROR:
+		RTR_DBG1("Internal error on server-side");
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+		break;
+	case NO_DATA_AVAIL:
+		RTR_DBG1("No data available");
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_NO_DATA_AVAIL);
+		break;
+	case INVALID_REQUEST:
+		RTR_DBG1("Invalid request from client");
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+		break;
+	case UNSUPPORTED_PROTOCOL_VER:
+		RTR_DBG1("Client uses unsupported protocol version");
+		if (pdu->ver <= RTR_PROTOCOL_MAX_SUPPORTED_VERSION && pdu->ver >= RTR_PROTOCOL_MIN_SUPPORTED_VERSION &&
+		    pdu->ver < rtr_socket->version) {
+			RTR_DBG("Downgrading from %i to version %i", rtr_socket->version, pdu->ver);
+			rtr_socket->version = pdu->ver;
+			rtr_change_socket_state(rtr_socket, RTR_FAST_RECONNECT);
+		} else {
+			RTR_DBG("Got UNSUPPORTED_PROTOCOL_VER error PDU with invalid values, current version:%i, PDU version:%i",
+				rtr_socket->version, pdu->ver);
+			rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+		}
+		break;
+	case UNSUPPORTED_PDU_TYPE:
+		RTR_DBG1("Client set unsupported PDU type");
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+		break;
+	default:
+		RTR_DBG("error unknown, server sent unsupported error code %u", pdu->error_code);
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+		break;
+	}
+
+	const uint32_t len_err_txt = *((uint32_t *)(pdu->rest + pdu->len_enc_pdu));
+
+	if (len_err_txt > 0) {
+		if ((sizeof(pdu->ver) + sizeof(pdu->type) + sizeof(pdu->error_code) + sizeof(pdu->len) +
+		     sizeof(pdu->len_enc_pdu) + pdu->len_enc_pdu + 4 + len_err_txt) != pdu->len) {
+			RTR_DBG1("error: Length of error text contains an incorrect value");
+		} else {
+			char *pdu_txt = (char *)pdu->rest + pdu->len_enc_pdu + sizeof(len_err_txt);
+
+			RTR_DBG("Error PDU included the following error msg: \'%.*s\'", len_err_txt, pdu_txt);
+		}
+	}
+
+	return RTR_SUCCESS;
+}
+
+static int rtr_handle_cache_response_pdu(struct rtr_socket *rtr_socket, char *pdu)
+{
+	RTR_DBG1("Cache Response PDU received");
+	struct pdu_cache_response *cr_pdu = (struct pdu_cache_response *)pdu;
+	// set connection session_id
+	if (rtr_socket->request_session_id) {
+		if (rtr_socket->last_update != 0) {
+			RTR_DBG1("Resetting Socket.");
+
+			rtr_socket->last_update = 0;
+			rtr_socket->is_resetting = true;
+		}
+		rtr_socket->session_id = cr_pdu->session_id;
+	} else {
+		if (rtr_socket->session_id != cr_pdu->session_id) {
+			const char txt[] =
+				"Wrong session_id in Cache Response PDU"; //TODO: Appendrtr_socket->session_id to string
+			rtr_send_error_pdu_from_host(rtr_socket, NULL, 0, CORRUPT_DATA, txt, sizeof(txt));
+			rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+			return RTR_ERROR;
+		}
+	}
+	return RTR_SUCCESS;
+}
+
+static void rtr_key_pdu_2_spki_record(const struct rtr_socket *rtr_socket, const struct pdu_router_key *pdu,
+				      struct spki_record *entry, const enum pdu_type type)
+{
+	assert(type == ROUTER_KEY);
+	entry->asn = pdu->asn;
+	memcpy(entry->ski, pdu->ski, SKI_SIZE);
+	memcpy(entry->spki, pdu->spki, SPKI_SIZE);
+	entry->socket = rtr_socket;
+}
+
+static void rtr_prefix_pdu_2_pfx_record(const struct rtr_socket *rtr_socket, const void *pdu, struct pfx_record *pfxr,
+					const enum pdu_type type)
+{
+	assert(type == IPV4_PREFIX || type == IPV6_PREFIX);
+	if (type == IPV4_PREFIX) {
+		const struct pdu_ipv4 *ipv4 = pdu;
+
+		pfxr->prefix.u.addr4.addr = ipv4->prefix;
+		pfxr->asn = ipv4->asn;
+		pfxr->prefix.ver = LRTR_IPV4;
+		pfxr->min_len = ipv4->prefix_len;
+		pfxr->max_len = ipv4->max_prefix_len;
+		pfxr->socket = rtr_socket;
+	} else if (type == IPV6_PREFIX) {
+		const struct pdu_ipv6 *ipv6 = pdu;
+
+		pfxr->asn = ipv6->asn;
+		pfxr->prefix.ver = LRTR_IPV6;
+		memcpy(pfxr->prefix.u.addr6.addr, ipv6->prefix, sizeof(pfxr->prefix.u.addr6.addr));
+		pfxr->min_len = ipv6->prefix_len;
+		pfxr->max_len = ipv6->max_prefix_len;
+		pfxr->socket = rtr_socket;
+	}
+}
+
+/*
+ * @brief Removes all Prefix from the pfx_table with flag field == ADD, ADDs all Prefix PDU to the pfx_table with flag
+ * field == REMOVE.
+ */
+static int rtr_undo_update_pfx_table(struct rtr_socket *rtr_socket, struct pfx_table *pfx_table, void *pdu)
+{
+	const enum pdu_type type = rtr_get_pdu_type(pdu);
+
+	assert(type == IPV4_PREFIX || type == IPV6_PREFIX);
+
+	struct pfx_record pfxr;
+
+	rtr_prefix_pdu_2_pfx_record(rtr_socket, pdu, &pfxr, type);
+
+	int rtval = RTR_ERROR;
+	// invert add/remove operation
+	if (((struct pdu_ipv4 *)pdu)->flags == 1)
+		rtval = pfx_table_remove(pfx_table, &pfxr);
+	else if (((struct pdu_ipv4 *)pdu)->flags == 0)
+		rtval = pfx_table_add(pfx_table, &pfxr);
+	return rtval;
+}
+
+/*
+ * @brief Removes router_key from the spki_table with flag field == ADD, ADDs router_key PDU to the spki_table with flag
+ * field == REMOVE.
+ */
+static int rtr_undo_update_spki_table(struct rtr_socket *rtr_socket, struct spki_table *spki_table, void *pdu)
+{
+	const enum pdu_type type = rtr_get_pdu_type(pdu);
+
+	assert(type == ROUTER_KEY);
+
+	struct spki_record entry;
+
+	rtr_key_pdu_2_spki_record(rtr_socket, pdu, &entry, type);
+
+	int rtval = RTR_ERROR;
+	// invert add/remove operation
+	if (((struct pdu_router_key *)pdu)->flags == 1)
+		rtval = spki_table_remove_entry(spki_table, &entry);
+	else if (((struct pdu_router_key *)pdu)->flags == 0)
+		rtval = spki_table_add_entry(spki_table, &entry);
+	return rtval;
+}
+
+/*
+ * @brief Appends the Prefix PDU pdu to ary.
+ *
+ * @return RTR_SUCCESS On success
+ * @return RTR_ERROR On realloc failure
+ * @attention ary is not freed in this case, because it might contain data that is still needed
+ */
+static int rtr_store_prefix_pdu(struct rtr_socket *rtr_socket, const void *pdu, const unsigned int pdu_size, void **ary,
+				unsigned int *ind, unsigned int *size)
+{
+	const enum pdu_type type = rtr_get_pdu_type(pdu);
+
+	assert(type == IPV4_PREFIX || type == IPV6_PREFIX);
+	if ((*ind) >= *size) {
+		*size += TEMPORARY_PDU_STORE_INCREMENT_VALUE;
+		void *tmp = lrtr_realloc(*ary, *size * pdu_size);
+
+		if (!tmp) {
+			const char txt[] = "Realloc failed";
+
+			RTR_DBG("%s", txt);
+			rtr_send_error_pdu_from_host(rtr_socket, NULL, 0, INTERNAL_ERROR, txt, sizeof(txt));
+			rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+			return RTR_ERROR;
+		}
+		*ary = tmp;
+	}
+	if (type == IPV4_PREFIX) {
+		struct pdu_ipv4 *ary_ipv4 = *ary;
+
+		memcpy(ary_ipv4 + *ind, pdu, pdu_size);
+	} else if (type == IPV6_PREFIX) {
+		struct pdu_ipv6 *ary_ipv6 = *ary;
+
+		memcpy(ary_ipv6 + *ind, pdu, pdu_size);
+	}
+	(*ind)++;
+	return RTR_SUCCESS;
+}
+
+/*
+ * @brief Appends the router key to ary.
+ *
+ * @return RTR_SUCCESS On success
+ * @return RTR_ERROR On realloc failure
+ * @attention ary is not freed in this case, because it might contain data that is still needed
+ */
+static int rtr_store_router_key_pdu(struct rtr_socket *rtr_socket, const void *pdu, const unsigned int pdu_size,
+				    struct pdu_router_key **ary, unsigned int *ind, unsigned int *size)
+{
+	assert(rtr_get_pdu_type(pdu) == ROUTER_KEY);
+
+	if ((*ind) >= *size) {
+		*size += TEMPORARY_PDU_STORE_INCREMENT_VALUE;
+		void *tmp = lrtr_realloc(*ary, *size * pdu_size);
+
+		if (!tmp) {
+			const char txt[] = "Realloc failed";
+
+			RTR_DBG("%s", txt);
+			rtr_send_error_pdu_from_host(rtr_socket, NULL, 0, INTERNAL_ERROR, txt, sizeof(txt));
+			rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+			return RTR_ERROR;
+		}
+		*ary = tmp;
+	}
+
+	memcpy((struct pdu_router_key *)*ary + *ind, pdu, pdu_size);
+	(*ind)++;
+	return RTR_SUCCESS;
+}
+
+static int rtr_update_pfx_table(struct rtr_socket *rtr_socket, struct pfx_table *pfx_table, const void *pdu)
+{
+	const enum pdu_type type = rtr_get_pdu_type(pdu);
+
+	assert(type == IPV4_PREFIX || type == IPV6_PREFIX);
+
+	struct pfx_record pfxr;
+	size_t pdu_size = (type == IPV4_PREFIX ? sizeof(struct pdu_ipv4) : sizeof(struct pdu_ipv6));
+
+	rtr_prefix_pdu_2_pfx_record(rtr_socket, pdu, &pfxr, type);
+
+	int rtval;
+
+	if (((struct pdu_ipv4 *)pdu)->flags == 1) {
+		rtval = pfx_table_add(pfx_table, &pfxr);
+	} else if (((struct pdu_ipv4 *)pdu)->flags == 0) {
+		rtval = pfx_table_remove(pfx_table, &pfxr);
+	} else {
+		const char txt[] = "Prefix PDU with invalid flags value received";
+
+		RTR_DBG("%s", txt);
+		rtr_send_error_pdu_from_host(rtr_socket, pdu, pdu_size, CORRUPT_DATA, txt, sizeof(txt));
+		return RTR_ERROR;
+	}
+
+	if (rtval == PFX_DUPLICATE_RECORD) {
+		char ip[INET6_ADDRSTRLEN];
+
+		lrtr_ip_addr_to_str(&(pfxr.prefix), ip, INET6_ADDRSTRLEN);
+		RTR_DBG("Duplicate Announcement for record: %s/%u-%u, ASN: %u, received", ip, pfxr.min_len,
+			pfxr.max_len, pfxr.asn);
+		rtr_send_error_pdu_from_host(rtr_socket, pdu, pdu_size, DUPLICATE_ANNOUNCEMENT, NULL, 0);
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+		return RTR_ERROR;
+	} else if (rtval == PFX_RECORD_NOT_FOUND) {
+		RTR_DBG1("Withdrawal of unknown record");
+		rtr_send_error_pdu_from_host(rtr_socket, pdu, pdu_size, WITHDRAWAL_OF_UNKNOWN_RECORD, NULL, 0);
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+		return RTR_ERROR;
+	} else if (rtval == PFX_ERROR) {
+		const char txt[] = "PFX_TABLE Error";
+
+		RTR_DBG("%s", txt);
+		rtr_send_error_pdu_from_host(rtr_socket, NULL, 0, INTERNAL_ERROR, txt, sizeof(txt));
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+		return RTR_ERROR;
+	}
+
+	return RTR_SUCCESS;
+}
+
+static int rtr_update_spki_table(struct rtr_socket *rtr_socket, struct spki_table *spki_table, const void *pdu)
+{
+	const enum pdu_type type = rtr_get_pdu_type(pdu);
+
+	assert(type == ROUTER_KEY);
+
+	struct spki_record entry;
+
+	size_t pdu_size = sizeof(struct pdu_router_key);
+
+	rtr_key_pdu_2_spki_record(rtr_socket, pdu, &entry, type);
+
+	int rtval;
+
+	if (((struct pdu_router_key *)pdu)->flags == 1) {
+		rtval = spki_table_add_entry(spki_table, &entry);
+
+	} else if (((struct pdu_router_key *)pdu)->flags == 0) {
+		rtval = spki_table_remove_entry(spki_table, &entry);
+
+	} else {
+		const char txt[] = "Router Key PDU with invalid flags value received";
+
+		RTR_DBG("%s", txt);
+		rtr_send_error_pdu_from_host(rtr_socket, pdu, pdu_size, CORRUPT_DATA, txt, sizeof(txt));
+		return RTR_ERROR;
+	}
+
+	if (rtval == SPKI_DUPLICATE_RECORD) {
+		// TODO: This debug message isn't working yet, how to display SKI/SPKI without %x?
+		RTR_DBG("Duplicate Announcement for router key: ASN: %u received", entry.asn);
+		rtr_send_error_pdu_from_host(rtr_socket, pdu, pdu_size, DUPLICATE_ANNOUNCEMENT, NULL, 0);
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+		return RTR_ERROR;
+	} else if (rtval == SPKI_RECORD_NOT_FOUND) {
+		RTR_DBG1("Withdrawal of unknown router key");
+		rtr_send_error_pdu_from_host(rtr_socket, pdu, pdu_size, WITHDRAWAL_OF_UNKNOWN_RECORD, NULL, 0);
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+		return RTR_ERROR;
+	} else if (rtval == SPKI_ERROR) {
+		const char txt[] = "spki_table Error";
+
+		RTR_DBG("%s", txt);
+		rtr_send_error_pdu_from_host(rtr_socket, NULL, 0, INTERNAL_ERROR, txt, sizeof(txt));
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+		return RTR_ERROR;
+	}
+
+	return RTR_SUCCESS;
+}
+
+void recv_loop_cleanup(void *p)
+{
+	struct recv_loop_cleanup_args *args = p;
+
+	lrtr_free(args->ipv4_pdus);
+	lrtr_free(args->ipv6_pdus);
+	lrtr_free(args->router_key_pdus);
+}
+
+/* WARNING: This Function has cancelable sections*/
+static int rtr_sync_receive_and_store_pdus(struct rtr_socket *rtr_socket)
+{
+	char pdu[RTR_MAX_PDU_LEN];
+	enum pdu_type type;
+	int retval = RTR_SUCCESS;
+
+	struct pdu_ipv6 *ipv6_pdus = NULL;
+	unsigned int ipv6_pdus_nindex = 0; // next free index in ipv6_pdus
+	unsigned int ipv6_pdus_size = 0;
+
+	struct pdu_ipv4 *ipv4_pdus = NULL;
+	unsigned int ipv4_pdus_size = 0;
+	unsigned int ipv4_pdus_nindex = 0; // next free index in ipv4_pdus
+
+	struct pdu_router_key *router_key_pdus = NULL;
+	unsigned int router_key_pdus_size = 0;
+	unsigned int router_key_pdus_nindex = 0;
+
+	struct pfx_table *pfx_shadow_table = NULL;
+	struct spki_table *spki_shadow_table = NULL;
+
+	int oldcancelstate;
+	struct recv_loop_cleanup_args cleanup_args = {
+		.ipv4_pdus = ipv4_pdus, .ipv6_pdus = ipv6_pdus, .router_key_pdus = router_key_pdus};
+
+	// receive LRTR_IPV4/IPV6 PDUs till EOD
+	do {
+		pthread_cleanup_push(recv_loop_cleanup, &cleanup_args);
+		pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldcancelstate);
+		retval = rtr_receive_pdu(rtr_socket, pdu, RTR_MAX_PDU_LEN, RTR_RECV_TIMEOUT);
+		pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldcancelstate);
+		pthread_cleanup_pop(0);
+
+		if (retval == TR_WOULDBLOCK) {
+			rtr_change_socket_state(rtr_socket, RTR_ERROR_TRANSPORT);
+			retval = RTR_ERROR;
+			goto cleanup;
+		} else if (retval < 0) {
+			retval = RTR_ERROR;
+			goto cleanup;
+		}
+
+		type = rtr_get_pdu_type(pdu);
+		if (type == IPV4_PREFIX) {
+			if (rtr_store_prefix_pdu(rtr_socket, pdu, sizeof(*ipv4_pdus), (void **)&ipv4_pdus,
+						 &ipv4_pdus_nindex, &ipv4_pdus_size) == RTR_ERROR) {
+				rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+				retval = RTR_ERROR;
+				goto cleanup;
+			}
+		} else if (type == IPV6_PREFIX) {
+			if (rtr_store_prefix_pdu(rtr_socket, pdu, sizeof(*ipv6_pdus), (void **)&ipv6_pdus,
+						 &ipv6_pdus_nindex, &ipv6_pdus_size) == RTR_ERROR) {
+				rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+				retval = RTR_ERROR;
+				goto cleanup;
+			}
+		} else if (type == ROUTER_KEY) {
+			if (rtr_store_router_key_pdu(rtr_socket, pdu, sizeof(*router_key_pdus), &router_key_pdus,
+						     &router_key_pdus_nindex, &router_key_pdus_size) == RTR_ERROR) {
+				rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+				retval = RTR_ERROR;
+				goto cleanup;
+			}
+		} else if (type == EOD) {
+			RTR_DBG1("EOD PDU received.");
+			struct pdu_end_of_data_v0 *eod_pdu = (struct pdu_end_of_data_v0 *)pdu;
+
+			if (eod_pdu->session_id != rtr_socket->session_id) {
+				char txt[67];
+
+				snprintf(txt, sizeof(txt),
+					 "Expected session_id: %u, received session_id. %u in EOD PDU",
+					 rtr_socket->session_id, eod_pdu->session_id);
+				rtr_send_error_pdu_from_host(rtr_socket, pdu, RTR_MAX_PDU_LEN, CORRUPT_DATA, txt,
+							     strlen(txt) + 1);
+				rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+				retval = RTR_ERROR;
+				goto cleanup;
+			}
+
+			if (eod_pdu->ver == RTR_PROTOCOL_VERSION_1 &&
+			    rtr_socket->iv_mode != RTR_INTERVAL_MODE_IGNORE_ANY) {
+				int interv_retval;
+
+				interv_retval =
+					rtr_check_interval_option(rtr_socket, rtr_socket->iv_mode,
+								  ((struct pdu_end_of_data_v1 *)pdu)->expire_interval,
+								  RTR_INTERVAL_TYPE_EXPIRATION);
+
+				if (interv_retval == RTR_ERROR) {
+					interval_send_error_pdu(rtr_socket, pdu,
+								((struct pdu_end_of_data_v1 *)pdu)->expire_interval,
+								RTR_EXPIRATION_MIN, RTR_EXPIRATION_MAX);
+					retval = RTR_ERROR;
+					goto cleanup;
+				}
+
+				interv_retval =
+					rtr_check_interval_option(rtr_socket, rtr_socket->iv_mode,
+								  ((struct pdu_end_of_data_v1 *)pdu)->refresh_interval,
+								  RTR_INTERVAL_TYPE_REFRESH);
+
+				if (interv_retval == RTR_ERROR) {
+					interval_send_error_pdu(rtr_socket, pdu,
+								((struct pdu_end_of_data_v1 *)pdu)->refresh_interval,
+								RTR_REFRESH_MIN, RTR_REFRESH_MAX);
+					retval = RTR_ERROR;
+					goto cleanup;
+				}
+
+				interv_retval = rtr_check_interval_option(
+					rtr_socket, rtr_socket->iv_mode,
+					((struct pdu_end_of_data_v1 *)pdu)->retry_interval, RTR_INTERVAL_TYPE_RETRY);
+
+				if (interv_retval == RTR_ERROR) {
+					interval_send_error_pdu(rtr_socket, pdu,
+								((struct pdu_end_of_data_v1 *)pdu)->retry_interval,
+								RTR_RETRY_MIN, RTR_RETRY_MAX);
+					retval = RTR_ERROR;
+					goto cleanup;
+				}
+
+				RTR_DBG("New interval values: expire_interval:%u, refresh_interval:%u, retry_interval:%u",
+					rtr_socket->expire_interval, rtr_socket->refresh_interval,
+					rtr_socket->retry_interval);
+			}
+
+			struct pfx_table *pfx_update_table;
+			struct spki_table *spki_update_table;
+
+			if (rtr_socket->is_resetting) {
+				RTR_DBG1("Reset in progress creating shadow table for atomic reset");
+				pfx_shadow_table = lrtr_malloc(sizeof(struct pfx_table));
+				if (!pfx_shadow_table) {
+					RTR_DBG1("Memory allocation for pfx shadow table failed");
+					retval = RTR_ERROR;
+					goto cleanup;
+				}
+
+				pfx_table_init(pfx_shadow_table, NULL);
+				pfx_update_table = pfx_shadow_table;
+				if (pfx_table_copy_except_socket(rtr_socket->pfx_table, pfx_update_table, rtr_socket)) {
+					RTR_DBG1("Creation of pfx shadow table failed");
+					rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+					retval = RTR_ERROR;
+					goto cleanup;
+				}
+
+				spki_shadow_table = lrtr_malloc(sizeof(struct spki_table));
+				if (!spki_shadow_table) {
+					RTR_DBG1("Memory allocation for spki shadow table failed");
+					retval = RTR_ERROR;
+					goto cleanup;
+				}
+				spki_table_init(spki_shadow_table, NULL);
+				spki_update_table = spki_shadow_table;
+				if (spki_table_copy_except_socket(rtr_socket->spki_table, spki_update_table,
+								  rtr_socket) != SPKI_SUCCESS) {
+					RTR_DBG1("Creation of spki shadow table failed");
+					rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+					retval = RTR_ERROR;
+					goto cleanup;
+				}
+
+				RTR_DBG1("Shadow table created");
+			} else {
+				pfx_update_table = rtr_socket->pfx_table;
+				spki_update_table = rtr_socket->spki_table;
+			}
+
+			retval = PFX_SUCCESS;
+			// add all IPv4 prefix pdu to the pfx_table
+			for (unsigned int i = 0; i < ipv4_pdus_nindex; i++) {
+				if (rtr_update_pfx_table(rtr_socket, pfx_update_table, &(ipv4_pdus[i])) == PFX_ERROR) {
+					// undo all record updates, except the last which produced the error
+					RTR_DBG("Error during data synchronisation, recovering Serial Nr. %u state",
+						rtr_socket->serial_number);
+					for (unsigned int j = 0; j < i && retval == PFX_SUCCESS; j++)
+						retval = rtr_undo_update_pfx_table(rtr_socket, pfx_update_table,
+										   &(ipv4_pdus[j]));
+					if (retval == RTR_ERROR) {
+						RTR_DBG1(
+							"Couldn't undo all update operations from failed data synchronisation: Purging all records");
+						pfx_table_src_remove(rtr_socket->pfx_table, rtr_socket);
+						rtr_socket->request_session_id = true;
+					}
+					rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+					retval = RTR_ERROR;
+					goto cleanup;
+				}
+			}
+			RTR_DBG1("v4 prefixes added");
+			// add all IPv6 prefix pdu to the pfx_table
+			for (unsigned int i = 0; i < ipv6_pdus_nindex; i++) {
+				if (rtr_update_pfx_table(rtr_socket, pfx_update_table, &(ipv6_pdus[i])) == PFX_ERROR) {
+					// undo all record updates if error occurred
+					RTR_DBG("Error during data synchronisation, recovering Serial Nr. %u state",
+						rtr_socket->serial_number);
+					for (unsigned int j = 0; j < ipv4_pdus_nindex && retval == PFX_SUCCESS; j++)
+						retval = rtr_undo_update_pfx_table(rtr_socket, pfx_update_table,
+										   &(ipv4_pdus[j]));
+					for (unsigned int j = 0; j < i && retval == PFX_SUCCESS; j++)
+						retval = rtr_undo_update_pfx_table(rtr_socket, pfx_update_table,
+										   &(ipv6_pdus[j]));
+					if (retval == PFX_ERROR) {
+						RTR_DBG1(
+							"Couldn't undo all update operations from failed data synchronisation: Purging all records");
+						pfx_table_src_remove(rtr_socket->pfx_table, rtr_socket);
+						rtr_socket->request_session_id = true;
+					}
+					rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+					retval = RTR_ERROR;
+					goto cleanup;
+				}
+			}
+
+			RTR_DBG1("v6 prefixes added");
+			// add all router key pdu to the spki_table
+			for (unsigned int i = 0; i < router_key_pdus_nindex; i++) {
+				if (rtr_update_spki_table(rtr_socket, spki_update_table, &(router_key_pdus[i])) ==
+				    SPKI_ERROR) {
+					RTR_DBG("Error during router key data synchronisation, recovering Serial Nr. %u state",
+						rtr_socket->serial_number);
+					for (unsigned int j = 0; j < ipv4_pdus_nindex && retval == PFX_SUCCESS; j++)
+						retval = rtr_undo_update_pfx_table(rtr_socket, pfx_update_table,
+										   &(ipv4_pdus[j]));
+					for (unsigned int j = 0; j < ipv6_pdus_nindex && retval == PFX_SUCCESS; j++)
+						retval = rtr_undo_update_pfx_table(rtr_socket, pfx_update_table,
+										   &(ipv6_pdus[j]));
+					for (unsigned int j = 0;
+					// cppcheck-suppress duplicateExpression
+					     j < i && (retval == PFX_SUCCESS || retval == SPKI_SUCCESS); j++)
+						retval = rtr_undo_update_spki_table(rtr_socket, spki_update_table,
+										    &(router_key_pdus[j]));
+					// cppcheck-suppress duplicateExpression
+					if (retval == RTR_ERROR || retval == SPKI_ERROR) {
+						RTR_DBG1(
+							"Couldn't undo all update operations from failed data synchronisation: Purging all key entries");
+						spki_table_src_remove(spki_update_table, rtr_socket);
+						rtr_socket->request_session_id = true;
+					}
+					rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+					retval = RTR_ERROR;
+					goto cleanup;
+				}
+			}
+			RTR_DBG1("spki data added");
+			if (rtr_socket->is_resetting) {
+				RTR_DBG1("Reset finished. Swapping new table in.");
+				pfx_table_swap(rtr_socket->pfx_table, pfx_shadow_table);
+				spki_table_swap(rtr_socket->spki_table, spki_shadow_table);
+
+				if (rtr_socket->pfx_table->update_fp) {
+					RTR_DBG1("Calculating and notifying pfx diff");
+					pfx_table_notify_diff(rtr_socket->pfx_table, pfx_shadow_table, rtr_socket);
+				} else {
+					RTR_DBG1("No pfx update callback. Skipping diff");
+				}
+
+				if (rtr_socket->spki_table->update_fp) {
+					RTR_DBG1("Calculating and notifying spki diff");
+					spki_table_notify_diff(rtr_socket->spki_table, spki_shadow_table, rtr_socket);
+				} else {
+					RTR_DBG1("No spki update callback. Skipping diff");
+				}
+			}
+
+			rtr_socket->serial_number = eod_pdu->sn;
+			RTR_DBG("Sync successful, received %u Prefix PDUs, %u Router Key PDUs, session_id: %u, SN: %u",
+				(ipv4_pdus_nindex + ipv6_pdus_nindex), router_key_pdus_nindex, rtr_socket->session_id,
+				rtr_socket->serial_number);
+			goto cleanup;
+		} else if (type == ERROR) {
+			rtr_handle_error_pdu(rtr_socket, pdu);
+			retval = RTR_ERROR;
+			goto cleanup;
+		} else if (type == SERIAL_NOTIFY) {
+			RTR_DBG1("Ignoring Serial Notify");
+		} else {
+			RTR_DBG("Received unexpected PDU (Type: %u)", ((struct pdu_header *)pdu)->type);
+			const char txt[] = "Unexpected PDU received during data synchronisation";
+
+			rtr_send_error_pdu_from_host(rtr_socket, pdu, sizeof(struct pdu_header), CORRUPT_DATA, txt,
+						     sizeof(txt));
+			retval = RTR_ERROR;
+			goto cleanup;
+		}
+	} while (type != EOD);
+
+cleanup:
+
+	if (rtr_socket->is_resetting) {
+		RTR_DBG1("Freeing shadow tables.");
+		if (pfx_shadow_table) {
+			pfx_table_free_without_notify(pfx_shadow_table);
+			lrtr_free(pfx_shadow_table);
+		}
+
+		if (spki_shadow_table) {
+			spki_table_free_without_notify(spki_shadow_table);
+			lrtr_free(spki_shadow_table);
+		}
+		rtr_socket->is_resetting = false;
+	}
+
+	lrtr_free(router_key_pdus);
+	lrtr_free(ipv6_pdus);
+	lrtr_free(ipv4_pdus);
+	return retval;
+}
+
+/* WARNING: This Function has cancelable sections */
+int rtr_sync(struct rtr_socket *rtr_socket)
+{
+	char pdu[RTR_MAX_PDU_LEN];
+	enum pdu_type type;
+
+	int oldcancelstate;
+
+	do {
+		pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldcancelstate);
+		int rtval = rtr_receive_pdu(rtr_socket, pdu, RTR_MAX_PDU_LEN, RTR_RECV_TIMEOUT);
+
+		pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldcancelstate);
+		// If the cache has closed the connection and we don't have a
+		// session_id (no packages where exchanged) we should downgrade.
+		if (rtval == TR_CLOSED && rtr_socket->request_session_id) {
+			RTR_DBG1("The cache server closed the connection and we have no session_id!");
+			if (rtr_socket->version > RTR_PROTOCOL_MIN_SUPPORTED_VERSION) {
+				RTR_DBG("Downgrading from %i to version %i", rtr_socket->version,
+					rtr_socket->version - 1);
+				rtr_socket->version = rtr_socket->version - 1;
+				rtr_change_socket_state(rtr_socket, RTR_FAST_RECONNECT);
+				return RTR_ERROR;
+			}
+		}
+
+		if (rtval == TR_WOULDBLOCK) {
+			rtr_change_socket_state(rtr_socket, RTR_ERROR_TRANSPORT);
+			return RTR_ERROR;
+		} else if (rtval < 0) {
+			return RTR_ERROR;
+		}
+
+		type = rtr_get_pdu_type(pdu);
+		if (type == SERIAL_NOTIFY)
+			RTR_DBG1("Ignoring Serial Notify");
+
+	} while (type == SERIAL_NOTIFY);
+
+	switch (type) {
+	case ERROR:
+		rtr_handle_error_pdu(rtr_socket, pdu);
+		return RTR_ERROR;
+	case CACHE_RESET:
+		RTR_DBG1("Cache Reset PDU received");
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_NO_INCR_UPDATE_AVAIL);
+		return RTR_ERROR;
+	case CACHE_RESPONSE:
+		rtr_handle_cache_response_pdu(rtr_socket, pdu);
+		break;
+	default:
+		RTR_DBG("Expected Cache Response PDU but received PDU Type (Type: %u)",
+			((struct pdu_header *)pdu)->type);
+		const char txt[] = "Unexpected PDU received in data synchronisation";
+
+		rtr_send_error_pdu_from_host(rtr_socket, pdu, sizeof(struct pdu_header), CORRUPT_DATA, txt,
+					     sizeof(txt));
+		return RTR_ERROR;
+	}
+
+	// Receive all PDUs until EOD PDU
+	if (rtr_sync_receive_and_store_pdus(rtr_socket) == RTR_ERROR)
+		return RTR_ERROR;
+
+	rtr_socket->request_session_id = false;
+	if (rtr_set_last_update(rtr_socket) == RTR_ERROR)
+		return RTR_ERROR;
+
+	return RTR_SUCCESS;
+}
+
+int rtr_wait_for_sync(struct rtr_socket *rtr_socket)
+{
+	char pdu[RTR_MAX_PDU_LEN];
+
+	time_t cur_time;
+
+	lrtr_get_monotonic_time(&cur_time);
+	time_t wait = (rtr_socket->last_update + rtr_socket->refresh_interval) - cur_time;
+
+	if (wait < 0)
+		wait = 0;
+
+	RTR_DBG("waiting %jd sec. till next sync", (intmax_t)wait);
+	const int rtval = rtr_receive_pdu(rtr_socket, pdu, sizeof(pdu), wait);
+
+	if (rtval >= 0) {
+		enum pdu_type type = rtr_get_pdu_type(pdu);
+
+		if (type == SERIAL_NOTIFY) {
+			RTR_DBG("Serial Notify received (%u)", ((struct pdu_serial_notify *)pdu)->sn);
+			return RTR_SUCCESS;
+		}
+	} else if (rtval == TR_WOULDBLOCK) {
+		RTR_DBG1("Refresh interval expired");
+		return RTR_SUCCESS;
+	}
+	return RTR_ERROR;
+}
+
+static int rtr_send_error_pdu(const struct rtr_socket *rtr_socket, const void *erroneous_pdu,
+			      const uint32_t erroneous_pdu_len, const enum pdu_error_type error, const char *err_text,
+			      const uint32_t err_text_len)
+{
+	struct pdu_error *err_pdu;
+	unsigned int msg_size = sizeof(struct pdu_error) + 4 + erroneous_pdu_len + err_text_len;
+	uint8_t msg[msg_size];
+
+	// don't send errors for erroneous error PDUs
+	if (erroneous_pdu_len >= 2) {
+		if (rtr_get_pdu_type(erroneous_pdu) == ERROR) {
+			RTR_DBG1("Don't send errors for erroneous error PDUs");
+			return RTR_SUCCESS;
+		}
+	}
+
+	err_pdu = (struct pdu_error *)msg;
+	err_pdu->ver = rtr_socket->version;
+	err_pdu->type = ERROR;
+	err_pdu->error_code = error;
+	err_pdu->len = msg_size;
+
+	err_pdu->len_enc_pdu = erroneous_pdu_len;
+	if (erroneous_pdu_len > 0)
+		memcpy(err_pdu->rest, erroneous_pdu, erroneous_pdu_len);
+
+	*((uint32_t *)(err_pdu->rest + erroneous_pdu_len)) = err_text_len;
+	if (err_text_len > 0)
+		memcpy(err_pdu->rest + erroneous_pdu_len + 4, err_text, err_text_len);
+
+	return rtr_send_pdu(rtr_socket, msg, msg_size);
+}
+
+static int interval_send_error_pdu(struct rtr_socket *rtr_socket, void *pdu, uint32_t interval, uint16_t minimum,
+				   uint32_t maximum)
+{
+	RTR_DBG("Received expiration value out of range. Was %u, must be between %u and %u.", interval, minimum,
+		maximum);
+	const char txt[] = "Interval value out of range";
+
+	return rtr_send_error_pdu(rtr_socket, pdu, RTR_MAX_PDU_LEN, CORRUPT_DATA, txt, strlen(txt) + 1);
+}
+
+static int rtr_send_error_pdu_from_network(const struct rtr_socket *rtr_socket, const void *erroneous_pdu,
+					   const uint32_t erroneous_pdu_len, const enum pdu_error_type error,
+					   const char *err_text, const uint32_t err_text_len)
+{
+	return rtr_send_error_pdu(rtr_socket, erroneous_pdu, erroneous_pdu_len, error, err_text, err_text_len);
+}
+
+static int rtr_send_error_pdu_from_host(const struct rtr_socket *rtr_socket, const void *erroneous_pdu,
+					const uint32_t erroneous_pdu_len, const enum pdu_error_type error,
+					const char *err_text, const uint32_t err_text_len)
+{
+	char pdu[erroneous_pdu_len];
+
+	memcpy(&pdu, erroneous_pdu, erroneous_pdu_len);
+
+	if (erroneous_pdu_len == sizeof(struct pdu_header))
+		rtr_pdu_header_to_network_byte_order(&pdu);
+	else if (erroneous_pdu_len > sizeof(struct pdu_header))
+		rtr_pdu_to_network_byte_order(&pdu);
+	else
+		return RTR_ERROR;
+
+	return rtr_send_error_pdu(rtr_socket, &pdu, erroneous_pdu_len, error, err_text, err_text_len);
+}
+
+int rtr_send_serial_query(struct rtr_socket *rtr_socket)
+{
+	struct pdu_serial_query pdu;
+
+	pdu.ver = rtr_socket->version;
+	pdu.type = SERIAL_QUERY;
+	pdu.session_id = rtr_socket->session_id;
+	pdu.len = sizeof(pdu);
+	pdu.sn = rtr_socket->serial_number;
+
+	RTR_DBG("sending serial query, SN: %u", rtr_socket->serial_number);
+	if (rtr_send_pdu(rtr_socket, &pdu, sizeof(pdu)) != RTR_SUCCESS) {
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_TRANSPORT);
+		return RTR_ERROR;
+	}
+	return RTR_SUCCESS;
+}
+
+int rtr_send_reset_query(struct rtr_socket *rtr_socket)
+{
+	RTR_DBG1("Sending reset query");
+	struct pdu_reset_query pdu;
+
+	pdu.ver = rtr_socket->version;
+	pdu.type = 2;
+	pdu.flags = 0;
+	pdu.len = 8;
+
+	if (rtr_send_pdu(rtr_socket, &pdu, sizeof(pdu)) != RTR_SUCCESS) {
+		rtr_change_socket_state(rtr_socket, RTR_ERROR_TRANSPORT);
+		return RTR_ERROR;
+	}
+	return RTR_SUCCESS;
+}
diff --git a/rtrlib/rtr/packets_private.h b/rtrlib/rtr/packets_private.h
new file mode 100644
index 0000000..c8d5093
--- /dev/null
+++ b/rtrlib/rtr/packets_private.h
@@ -0,0 +1,32 @@
+/*
+ * This file is part of RTRlib.
+ *
+ * This file is subject to the terms and conditions of the MIT license.
+ * See the file LICENSE in the top level directory for more details.
+ *
+ * Website: http://rtrlib.realmv6.org/
+ */
+
+#ifndef RTR_PACKETS_PRIVATE_H
+#define RTR_PACKETS_PRIVATE_H
+
+#include "rtrlib/rtr/rtr_private.h"
+
+#include <arpa/inet.h>
+
+// error pdu: header(8) + len(4) + ipv6_pdu(32) + len(4) + 400*8 (400 char text)
+static const unsigned int RTR_MAX_PDU_LEN = 3248;
+static const unsigned int RTR_RECV_TIMEOUT = 60;
+static const unsigned int RTR_SEND_TIMEOUT = 60;
+
+void __attribute__((weak))
+rtr_change_socket_state(struct rtr_socket *rtr_socket, const enum rtr_socket_state new_state);
+int rtr_sync(struct rtr_socket *rtr_socket);
+int rtr_wait_for_sync(struct rtr_socket *rtr_socket);
+int rtr_send_serial_query(struct rtr_socket *rtr_socket);
+int rtr_send_reset_query(struct rtr_socket *rtr_socket);
+int rtr_check_interval_range(uint32_t interval, uint32_t minimum, uint32_t maximum);
+void apply_interval_value(struct rtr_socket *rtr_socket, uint32_t interval, enum rtr_interval_type type);
+int rtr_check_interval_option(struct rtr_socket *rtr_socket, int interval_mode, uint32_t interval,
+			      enum rtr_interval_type type);
+#endif
diff --git a/rtrlib/rtr/rtr.c b/rtrlib/rtr/rtr.c
new file mode 100644
index 0000000..086c953
--- /dev/null
+++ b/rtrlib/rtr/rtr.c
@@ -0,0 +1,272 @@
+/*
+ * This file is part of RTRlib.
+ *
+ * This file is subject to the terms and conditions of the MIT license.
+ * See the file LICENSE in the top level directory for more details.
+ *
+ * Website: http://rtrlib.realmv6.org/
+ */
+
+#include "rtr_private.h"
+
+#include "rtrlib/lib/log_private.h"
+#include "rtrlib/lib/utils_private.h"
+#include "rtrlib/pfx/pfx_private.h"
+#include "rtrlib/rtr/packets_private.h"
+#include "rtrlib/rtrlib_export_private.h"
+#include "rtrlib/spki/hashtable/ht-spkitable_private.h"
+#include "rtrlib/transport/transport_private.h"
+
+#include <assert.h>
+#include <pthread.h>
+#include <signal.h>
+#include <unistd.h>
+
+static void rtr_purge_outdated_records(struct rtr_socket *rtr_socket);
+static void *rtr_fsm_start(struct rtr_socket *rtr_socket);
+
+static const char *socket_str_states[] = {[RTR_CONNECTING] = "RTR_CONNECTING",
+					  [RTR_ESTABLISHED] = "RTR_ESTABLISHED",
+					  [RTR_RESET] = "RTR_RESET",
+					  [RTR_SYNC] = "RTR_SYNC",
+					  [RTR_FAST_RECONNECT] = "RTR_FAST_RECONNECT",
+					  [RTR_ERROR_NO_DATA_AVAIL] = "RTR_ERROR_NO_DATA_AVAIL",
+					  [RTR_ERROR_NO_INCR_UPDATE_AVAIL] = "RTR_ERROR_NO_INCR_UPDATE_AVAIL",
+					  [RTR_ERROR_FATAL] = "RTR_ERROR_FATAL",
+					  [RTR_ERROR_TRANSPORT] = "RTR_ERROR_TRANSPORT",
+					  [RTR_SHUTDOWN] = "RTR_SHUTDOWN"};
+
+int rtr_init(struct rtr_socket *rtr_socket, struct tr_socket *tr, struct pfx_table *pfx_table,
+	     struct spki_table *spki_table, const unsigned int refresh_interval, const unsigned int expire_interval,
+	     const unsigned int retry_interval, enum rtr_interval_mode iv_mode, rtr_connection_state_fp fp,
+	     void *fp_param_config, void *fp_param_group)
+{
+	if (tr)
+		rtr_socket->tr_socket = tr;
+
+	// Check if one of the intervals is not in range of the predefined values.
+	if (rtr_check_interval_range(refresh_interval, RTR_REFRESH_MIN, RTR_REFRESH_MAX) != RTR_INSIDE_INTERVAL_RANGE ||
+	    rtr_check_interval_range(expire_interval, RTR_EXPIRATION_MIN, RTR_EXPIRATION_MAX) !=
+		    RTR_INSIDE_INTERVAL_RANGE ||
+	    rtr_check_interval_range(retry_interval, RTR_RETRY_MIN, RTR_RETRY_MAX) != RTR_INSIDE_INTERVAL_RANGE) {
+		RTR_DBG("Interval value not in range.");
+		return RTR_INVALID_PARAM;
+	}
+	rtr_socket->refresh_interval = refresh_interval;
+	rtr_socket->expire_interval = expire_interval;
+	rtr_socket->retry_interval = retry_interval;
+	rtr_socket->iv_mode = iv_mode;
+
+	rtr_socket->state = RTR_CLOSED;
+	rtr_socket->request_session_id = true;
+	rtr_socket->serial_number = 0;
+	rtr_socket->last_update = 0;
+	rtr_socket->pfx_table = pfx_table;
+	rtr_socket->spki_table = spki_table;
+	rtr_socket->connection_state_fp = fp;
+	rtr_socket->connection_state_fp_param_config = fp_param_config;
+	rtr_socket->connection_state_fp_param_group = fp_param_group;
+	rtr_socket->thread_id = 0;
+	rtr_socket->version = RTR_PROTOCOL_MAX_SUPPORTED_VERSION;
+	rtr_socket->has_received_pdus = false;
+	rtr_socket->is_resetting = false;
+	return RTR_SUCCESS;
+}
+
+int rtr_start(struct rtr_socket *rtr_socket)
+{
+	if (rtr_socket->thread_id)
+		return RTR_ERROR;
+
+	int rtval = pthread_create(&(rtr_socket->thread_id), NULL, (void *(*)(void *)) &rtr_fsm_start, rtr_socket);
+
+	if (rtval == 0)
+		return RTR_SUCCESS;
+	return RTR_ERROR;
+}
+
+void rtr_purge_outdated_records(struct rtr_socket *rtr_socket)
+{
+	if (rtr_socket->last_update == 0)
+		return;
+	time_t cur_time;
+	int rtval = lrtr_get_monotonic_time(&cur_time);
+
+	if (rtval == -1 || (rtr_socket->last_update + rtr_socket->expire_interval) < cur_time) {
+		if (rtval == -1)
+			RTR_DBG1("get_monotic_time(..) failed");
+		pfx_table_src_remove(rtr_socket->pfx_table, rtr_socket);
+		RTR_DBG1("Removed outdated records from pfx_table");
+		spki_table_src_remove(rtr_socket->spki_table, rtr_socket);
+		RTR_DBG1("Removed outdated router keys from spki_table");
+		rtr_socket->request_session_id = true;
+		rtr_socket->serial_number = 0;
+		rtr_socket->last_update = 0;
+		rtr_socket->is_resetting = true;
+	}
+}
+
+/* WARNING: This Function has cancelable sections*/
+void *rtr_fsm_start(struct rtr_socket *rtr_socket)
+{
+	if (rtr_socket->state == RTR_SHUTDOWN)
+		return NULL;
+
+	// We don't care about the old state, but POSIX demands a non null value for setcancelstate
+	int oldcancelstate;
+
+	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldcancelstate);
+
+	rtr_socket->state = RTR_CONNECTING;
+	while (1) {
+		if (rtr_socket->state == RTR_CONNECTING) {
+			RTR_DBG1("State: RTR_CONNECTING");
+			rtr_socket->has_received_pdus = false;
+
+			// old pfx_record could exists in the pfx_table, check if they are too old and must be removed
+			// old key_entry could exists in the spki_table, check if they are too old and must be removed
+			rtr_purge_outdated_records(rtr_socket);
+
+			if (tr_open(rtr_socket->tr_socket) == TR_ERROR) {
+				rtr_change_socket_state(rtr_socket, RTR_ERROR_TRANSPORT);
+			} else if (rtr_socket->request_session_id) {
+				// change to state RESET, if socket doesn't have a session_id
+				rtr_change_socket_state(rtr_socket, RTR_RESET);
+			} else {
+				// if we already have a session_id, send a serial query and start to sync
+				if (rtr_send_serial_query(rtr_socket) == RTR_SUCCESS)
+					rtr_change_socket_state(rtr_socket, RTR_SYNC);
+				else
+					rtr_change_socket_state(rtr_socket, RTR_ERROR_FATAL);
+			}
+		}
+
+		else if (rtr_socket->state == RTR_RESET) {
+			RTR_DBG1("State: RTR_RESET");
+			if (rtr_send_reset_query(rtr_socket) == RTR_SUCCESS) {
+				RTR_DBG1("rtr_start: reset pdu sent");
+				rtr_change_socket_state(rtr_socket,
+							RTR_SYNC); // start to sync after connection is established
+			}
+		}
+
+		else if (rtr_socket->state == RTR_SYNC) {
+			RTR_DBG1("State: RTR_SYNC");
+			if (rtr_sync(rtr_socket) == RTR_SUCCESS)
+				rtr_change_socket_state(
+					rtr_socket,
+					RTR_ESTABLISHED); // wait for next sync after first successful sync
+		}
+
+		else if (rtr_socket->state == RTR_ESTABLISHED) {
+			RTR_DBG1("State: RTR_ESTABLISHED");
+
+			// Allow thread cancellation for recv code path only.
+			// This should be enough since we spend most of the time blocking on recv
+			pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldcancelstate);
+			int ret = rtr_wait_for_sync(
+				rtr_socket); // blocks till expire_interval is expired or PDU was received
+			pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldcancelstate);
+
+			if (ret == RTR_SUCCESS) { // send serial query
+				if (rtr_send_serial_query(rtr_socket) == RTR_SUCCESS)
+					rtr_change_socket_state(rtr_socket, RTR_SYNC);
+			}
+		}
+
+		else if (rtr_socket->state == RTR_FAST_RECONNECT) {
+			RTR_DBG1("State: RTR_FAST_RECONNECT");
+			tr_close(rtr_socket->tr_socket);
+			rtr_change_socket_state(rtr_socket, RTR_CONNECTING);
+		}
+
+		else if (rtr_socket->state == RTR_ERROR_NO_DATA_AVAIL) {
+			RTR_DBG1("State: RTR_ERROR_NO_DATA_AVAIL");
+			rtr_socket->request_session_id = true;
+			rtr_socket->serial_number = 0;
+			rtr_change_socket_state(rtr_socket, RTR_RESET);
+			sleep(rtr_socket->retry_interval);
+			rtr_purge_outdated_records(rtr_socket);
+		}
+
+		else if (rtr_socket->state == RTR_ERROR_NO_INCR_UPDATE_AVAIL) {
+			RTR_DBG1("State: RTR_ERROR_NO_INCR_UPDATE_AVAIL");
+			rtr_socket->request_session_id = true;
+			rtr_socket->serial_number = 0;
+			rtr_change_socket_state(rtr_socket, RTR_RESET);
+			rtr_purge_outdated_records(rtr_socket);
+		}
+
+		else if (rtr_socket->state == RTR_ERROR_TRANSPORT) {
+			RTR_DBG1("State: RTR_ERROR_TRANSPORT");
+			tr_close(rtr_socket->tr_socket);
+			rtr_change_socket_state(rtr_socket, RTR_CONNECTING);
+			RTR_DBG("Waiting %u", rtr_socket->retry_interval);
+			pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldcancelstate);
+			sleep(rtr_socket->retry_interval);
+			pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldcancelstate);
+		}
+
+		else if (rtr_socket->state == RTR_ERROR_FATAL) {
+			RTR_DBG1("State: RTR_ERROR_FATAL");
+			tr_close(rtr_socket->tr_socket);
+			rtr_change_socket_state(rtr_socket, RTR_CONNECTING);
+			RTR_DBG("Waiting %u", rtr_socket->retry_interval);
+			pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldcancelstate);
+			sleep(rtr_socket->retry_interval);
+			pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldcancelstate);
+		}
+
+		else if (rtr_socket->state == RTR_SHUTDOWN) {
+			RTR_DBG1("State: RTR_SHUTDOWN");
+			pthread_exit(NULL);
+		}
+	}
+}
+
+void rtr_stop(struct rtr_socket *rtr_socket)
+{
+	RTR_DBG("%s()", __func__);
+	rtr_change_socket_state(rtr_socket, RTR_SHUTDOWN);
+	if (rtr_socket->thread_id != 0) {
+		RTR_DBG1("pthread_cancel()");
+		pthread_cancel(rtr_socket->thread_id);
+		RTR_DBG1("pthread_join()");
+		pthread_join(rtr_socket->thread_id, NULL);
+
+		tr_close(rtr_socket->tr_socket);
+		rtr_socket->request_session_id = true;
+		rtr_socket->serial_number = 0;
+		rtr_socket->last_update = 0;
+		pfx_table_src_remove(rtr_socket->pfx_table, rtr_socket);
+		spki_table_src_remove(rtr_socket->spki_table, rtr_socket);
+		rtr_socket->thread_id = 0;
+	}
+	RTR_DBG1("Socket shut down");
+}
+
+RTRLIB_EXPORT const char *rtr_state_to_str(enum rtr_socket_state state)
+{
+	return socket_str_states[state];
+}
+
+/* cppcheck-suppress unusedFunction */
+RTRLIB_EXPORT enum rtr_interval_mode rtr_get_interval_mode(struct rtr_socket *rtr_socket)
+{
+	return rtr_socket->iv_mode;
+}
+
+/* cppcheck-suppress unusedFunction */
+RTRLIB_EXPORT void rtr_set_interval_mode(struct rtr_socket *rtr_socket, enum rtr_interval_mode option)
+{
+	switch (option) {
+	case RTR_INTERVAL_MODE_IGNORE_ANY:
+	case RTR_INTERVAL_MODE_ACCEPT_ANY:
+	case RTR_INTERVAL_MODE_DEFAULT_MIN_MAX:
+	case RTR_INTERVAL_MODE_IGNORE_ON_FAILURE:
+		rtr_socket->iv_mode = option;
+		break;
+	default:
+		RTR_DBG1("Invalid interval mode. Mode remains unchanged.");
+	}
+}
diff --git a/rtrlib/rtr/rtr.h b/rtrlib/rtr/rtr.h
new file mode 100644
index 0000000..162dadc
--- /dev/null
+++ b/rtrlib/rtr/rtr.h
@@ -0,0 +1,161 @@
+/*
+ * This file is part of RTRlib.
+ *
+ * This file is subject to the terms and conditions of the MIT license.
+ * See the file LICENSE in the top level directory for more details.
+ *
+ * Website: http://rtrlib.realmv6.org/
+ */
+
+/**
+ * @defgroup mod_rtr_h RTR socket
+ * @brief An RTR socket implements the RPKI-RTR protocol scheme.
+ * @details One rtr_socket communicates with a single RPKI-RTR server.
+ * @{
+ */
+
+#ifndef RTR_H
+#define RTR_H
+#include <pthread.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+enum rtr_rtvals { RTR_SUCCESS = 0, RTR_ERROR = -1, RTR_INVALID_PARAM = -2 };
+
+/**
+ * @brief These modes let the user configure how received intervals should be handled.
+ */
+enum rtr_interval_mode {
+	/** Ignore appliance of interval values at all. */
+	RTR_INTERVAL_MODE_IGNORE_ANY,
+
+	/** Accept any interval values, even if outside of range. */
+	RTR_INTERVAL_MODE_ACCEPT_ANY,
+
+	/** If interval value is outside of range, apply min (if below range) or max (if above range). */
+	RTR_INTERVAL_MODE_DEFAULT_MIN_MAX,
+
+	/** Ignore any interval values that are outside of range. */
+	RTR_INTERVAL_MODE_IGNORE_ON_FAILURE
+};
+
+/**
+ * @brief States of the RTR socket.
+ */
+enum rtr_socket_state {
+	/** Socket is establishing the transport connection. */
+	RTR_CONNECTING,
+
+	/** Connection is established,
+	 * socket is waiting for a Serial Notify or expiration of the refresh_interval timer
+	 */
+	RTR_ESTABLISHED,
+
+	/** Resetting RTR connection. */
+	RTR_RESET,
+
+	/** Receiving validation records from the RTR server.  */
+	RTR_SYNC,
+
+	/** Reconnect without any waiting period */
+	RTR_FAST_RECONNECT,
+
+	/** No validation records are available on the RTR server. */
+	RTR_ERROR_NO_DATA_AVAIL,
+
+	/** Server was unable to answer the last serial or reset query. */
+	RTR_ERROR_NO_INCR_UPDATE_AVAIL,
+
+	/** Fatal protocol error occurred. */
+	RTR_ERROR_FATAL,
+
+	/** Error on the transport socket occurred. */
+	RTR_ERROR_TRANSPORT,
+
+	/** RTR Socket was started, but now has shut down. */
+	RTR_SHUTDOWN,
+
+	/** RTR Socket has not been started yet. Initial state after rtr_init */
+	RTR_CLOSED,
+};
+
+struct rtr_socket;
+
+/**
+ * @brief A function pointer that is called if the state of the rtr socket has changed.
+ */
+typedef void (*rtr_connection_state_fp)(const struct rtr_socket *rtr_socket, const enum rtr_socket_state state,
+					void *connection_state_fp_param_config, void *connection_state_fp_param_group);
+
+/**
+ * @brief A RTR socket.
+ * @param tr_socket Pointer to an initialized tr_socket that will be used to communicate with the RTR server.
+ * @param refresh_interval Time period in seconds. Tells the router how long to wait before next attempting
+ * to poll the cache, using a Serial Query or Reset Query PDU.
+ * @param last_update Timestamp of the last validation record update. Is 0 if the pfx_table doesn't store any
+ * validation records from this rtr_socket.
+ * @param expire_interval Time period in seconds. Received records are deleted if the client was unable to refresh data
+ * for this time period.  If 0 is specified, the expire_interval is twice the refresh_interval.
+ * @param retry_interval Time period in seconds between a failed query and the next attempt.
+ * @param iv_mode Defines handling of incoming intervals.
+ * @param state Current state of the socket.
+ * @param session_id session_id of the RTR session.
+ * @param request_session_id True, if the rtr_client have to request a new none from the server.
+ * @param serial_number Last serial number of the obtained validation records.
+ * @param pfx_table pfx_table that stores the validation records obtained from the connected rtr server.
+ * @param thread_id Handle of the thread this socket is running in.
+ * @param connection_state_fp A callback function that is executed when the state of the socket changes.
+ * @param connection_state_fp_param_config Parameter that is passed to the connection_state_fp callback.
+ * Expects a pointer to a rtr_mgr_config struct.
+ * @param connection_state_fp_param_group Parameter that is passed to the connection_state_fp callback.
+ * Expects a pointer to the rtr_mgr_group this socket belongs to.
+ * @param version Protocol version used by this socket
+ * @param has_received_pdus True, if this socket has already received PDUs
+ * @param spki_table spki_table that stores the router keys obtained from the connected rtr server
+ */
+struct rtr_socket {
+	struct tr_socket *tr_socket;
+	unsigned int refresh_interval;
+	time_t last_update;
+	unsigned int expire_interval;
+	unsigned int retry_interval;
+	enum rtr_interval_mode iv_mode;
+	enum rtr_socket_state state;
+	uint32_t session_id;
+	bool request_session_id;
+	uint32_t serial_number;
+	struct pfx_table *pfx_table;
+	pthread_t thread_id;
+	rtr_connection_state_fp connection_state_fp;
+	void *connection_state_fp_param_config;
+	void *connection_state_fp_param_group;
+	unsigned int version;
+	bool has_received_pdus;
+	struct spki_table *spki_table;
+	bool is_resetting;
+};
+
+/**
+ * @brief Converts a rtr_socket_state to a String.
+ * @param[in] state state to convert to a string
+ * @return NULL If state isn't a valid rtr_socket_state
+ * @return !=NULL The rtr_socket_state as String.
+ */
+const char *rtr_state_to_str(enum rtr_socket_state state);
+
+/**
+ * @brief Set the interval option to the desired one. It's either RTR_INTERVAL_MODE_IGNORE_ANY,
+ * RTR_INTERVAL_MODE_APPLY_ANY, RTR_INTERVAL_MODE_DEFAULT_MIN_MAX or RTR_INTERVAL_MODE_IGNORE_ON_FAILURE.
+ * @param[in] rtr_socket The target socket.
+ * @param[in] option The new interval option that should be applied.
+ */
+void rtr_set_interval_mode(struct rtr_socket *rtr_socket, enum rtr_interval_mode option);
+
+/**
+ * @brief Get the current interval mode.
+ * @param[in] rtr_socket The target socket.
+ * @return The value of the interval_option variable.
+ */
+enum rtr_interval_mode rtr_get_interval_mode(struct rtr_socket *rtr_socket);
+#endif
+/** @} */
diff --git a/rtrlib/rtr/rtr_private.h b/rtrlib/rtr/rtr_private.h
new file mode 100644
index 0000000..3e49215
--- /dev/null
+++ b/rtrlib/rtr/rtr_private.h
@@ -0,0 +1,88 @@
+/*
+ * This file is part of RTRlib.
+ *
+ * This file is subject to the terms and conditions of the MIT license.
+ * See the file LICENSE in the top level directory for more details.
+ *
+ * Website: http://rtrlib.realmv6.org/
+ */
+
+#ifndef RTR_PRIVATE_H
+#define RTR_PRIVATE_H
+#include "rtrlib/rtr/rtr.h"
+
+#include <pthread.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#define RTR_DBG(fmt, ...) lrtr_dbg("RTR Socket: " fmt, ##__VA_ARGS__)
+#define RTR_DBG1(a) lrtr_dbg("RTR Socket: " a)
+
+static const uint32_t RTR_EXPIRATION_MIN = 600; // ten minutes
+static const uint32_t RTR_EXPIRATION_MAX = 172800; // two days
+static const uint32_t RTR_EXPIRATION_DEFAULT = 7200; // two hours
+
+static const uint32_t RTR_REFRESH_MIN = 1; // one second
+static const uint32_t RTR_REFRESH_MAX = 86400; // one day
+static const uint32_t RTR_REFRESH_DEFAULT = 3600; // one hour
+
+static const uint32_t RTR_RETRY_MIN = 1; // one second
+static const uint32_t RTR_RETRY_MAX = 7200; // two hours
+static const uint32_t RTR_RETRY_DEFAULT = 600; // ten minutes
+
+static const uint8_t RTR_PROTOCOL_VERSION_0; // = 0
+static const uint8_t RTR_PROTOCOL_VERSION_1 = 1;
+
+static const uint8_t RTR_PROTOCOL_MIN_SUPPORTED_VERSION; // = 0
+static const uint8_t RTR_PROTOCOL_MAX_SUPPORTED_VERSION = 1;
+
+enum rtr_interval_range { RTR_BELOW_INTERVAL_RANGE = -1, RTR_INSIDE_INTERVAL_RANGE = 0, RTR_ABOVE_INTERVAL_RANGE = 1 };
+
+enum rtr_interval_type { RTR_INTERVAL_TYPE_EXPIRATION, RTR_INTERVAL_TYPE_REFRESH, RTR_INTERVAL_TYPE_RETRY };
+
+/**
+ * @brief Initializes a rtr_socket.
+ * @param[out] rtr_socket Pointer to the allocated rtr_socket that will be initialized.
+ * @param[in] tr_socket Pointer to a tr_socket that will be used for the transport connection.
+ * If NULL the tr_socket element of the rtr_socket won't be changed.
+ * @param[in] pfx_table pfx_table that stores the validation records obtained from the connected rtr server.
+ * @param[in] spki_table spki_table that stores the router keys obtained from the connected rtr server.
+ * @param[in] refresh_interval Interval in seconds between serial queries that are sent to the server.
+ * Must be >= 1 and <= 86400 (one day), recommended default is 3600s (one hour).
+ * @param[in] expire_interval Stored validation records will be deleted
+ * if cache was unable to refresh data for this period.
+ * The value should be twice the refresh_interval. The value must be >= 600 (ten minutes) and <= 172800 (two days).
+ * The recommended default is 7200s (two hours).
+ * @param[in] retry_interval This parameter tells the router how long to wait (in seconds) before retrying
+ * a failed Serial Query or Reset Query. The value must be >= 1s and <= 7200s (two hours).
+ * The recommended default is 600 seconds (ten minutes).
+ * @param[in] iv_mode The interval mode that controls how new interval values are applied.
+ * @param[in] fp A callback function that is executed when the state of the socket changes.
+ * @param[in] fp_data_config Parameter that is passed to the connection_state_fp callback.
+ * Expects rtr_mgr_config.
+ * @param[in] fp_data_group Parameter that is passed to the connection_state_fp callback.
+ * Expects rtr_mgr_group.
+ * @return RTR_INVALID_PARAM If the refresh_interval or the expire_interval is not valid.
+ * @return RTR_SUCCESS On success.
+ */
+int rtr_init(struct rtr_socket *rtr_socket, struct tr_socket *tr_socket, struct pfx_table *pfx_table,
+	     struct spki_table *spki_table, const unsigned int refresh_interval, const unsigned int expire_interval,
+	     const unsigned int retry_interval, enum rtr_interval_mode iv_mode, rtr_connection_state_fp fp,
+	     void *fp_data_config, void *fp_data_group);
+
+/**
+ * @brief Starts the RTR protocol state machine in a pthread. Connection to the rtr_server will be established and the
+ * pfx_records will be synced.
+ * @param[in] rtr_socket rtr_socket that will be used.
+ * @return RTR_ERROR On error.
+ * @return RTR_SUCCESS On success.
+ */
+int rtr_start(struct rtr_socket *rtr_socket);
+
+/**
+ * @brief Stops the RTR connection and terminate the transport connection.
+ * @param[in] rtr_socket rtr_socket that will be used.
+ */
+void rtr_stop(struct rtr_socket *rtr_socket);
+
+#endif
diff --git a/rtrlib/rtr_mgr.c b/rtrlib/rtr_mgr.c
new file mode 100644
index 0000000..cfd1de6
--- /dev/null
+++ b/rtrlib/rtr_mgr.c
@@ -0,0 +1,675 @@
+/*
+ * This file is part of RTRlib.
+ *
+ * This file is subject to the terms and conditions of the MIT license.
+ * See the file LICENSE in the top level directory for more details.
+ *
+ * Website: http://rtrlib.realmv6.org/
+ */
+
+#include "rtr_mgr_private.h"
+
+#include "rtrlib/lib/alloc_utils_private.h"
+#include "rtrlib/lib/log_private.h"
+#include "rtrlib/pfx/pfx_private.h"
+#include "rtrlib/rtr/rtr_private.h"
+#include "rtrlib/rtrlib_export_private.h"
+#include "rtrlib/spki/hashtable/ht-spkitable_private.h"
+#include "rtrlib/transport/transport_private.h"
+
+#include <arpa/inet.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MGR_DBG(fmt, ...) lrtr_dbg("RTR_MGR: " fmt, ##__VA_ARGS__)
+#define MGR_DBG1(a) lrtr_dbg("RTR_MGR: " a)
+
+static const char *const mgr_str_status[] = {
+	[RTR_MGR_CLOSED] = "RTR_MGR_CLOSED",
+	[RTR_MGR_CONNECTING] = "RTR_MGR_CONNECTING",
+	[RTR_MGR_ESTABLISHED] = "RTR_MGR_ESTABLISHED",
+	[RTR_MGR_ERROR] = "RTR_MGR_ERROR",
+};
+
+static int rtr_mgr_config_cmp(const void *a, const void *b);
+static int rtr_mgr_config_cmp_tommy(const void *a, const void *b);
+static bool rtr_mgr_config_status_is_synced(const struct rtr_mgr_group *group);
+static void rtr_mgr_cb(const struct rtr_socket *sock, const enum rtr_socket_state state, void *data_config,
+		       void *data_group);
+
+static void set_status(const struct rtr_mgr_config *conf, struct rtr_mgr_group *group, enum rtr_mgr_status mgr_status,
+		       const struct rtr_socket *rtr_sock)
+{
+	MGR_DBG("Group(%u) status changed to: %s", group->preference, rtr_mgr_status_to_str(mgr_status));
+
+	group->status = mgr_status;
+	if (conf->status_fp)
+		conf->status_fp(group, mgr_status, rtr_sock, conf->status_fp_data);
+}
+
+static int rtr_mgr_start_sockets(struct rtr_mgr_group *group)
+{
+	for (unsigned int i = 0; i < group->sockets_len; i++) {
+		if (rtr_start(group->sockets[i]) != 0) {
+			MGR_DBG1("rtr_mgr: Error starting rtr_socket pthread");
+			return RTR_ERROR;
+		}
+	}
+	group->status = RTR_MGR_CONNECTING;
+	return RTR_SUCCESS;
+}
+
+static int rtr_mgr_init_sockets(struct rtr_mgr_group *group, struct rtr_mgr_config *config,
+				const unsigned int refresh_interval, const unsigned int expire_interval,
+				const unsigned int retry_interval, enum rtr_interval_mode iv_mode)
+{
+	for (unsigned int i = 0; i < group->sockets_len; i++) {
+		enum rtr_rtvals err_code = rtr_init(group->sockets[i], NULL, config->pfx_table, config->spki_table,
+						    refresh_interval, expire_interval, retry_interval, iv_mode,
+						    rtr_mgr_cb, config, group);
+		if (err_code)
+			return err_code;
+	}
+	return RTR_SUCCESS;
+}
+
+bool rtr_mgr_config_status_is_synced(const struct rtr_mgr_group *group)
+{
+	for (unsigned int i = 0; i < group->sockets_len; i++) {
+		enum rtr_socket_state state = group->sockets[i]->state;
+
+		if ((group->sockets[i]->last_update == 0) ||
+		    ((state != RTR_ESTABLISHED) && (state != RTR_RESET) && (state != RTR_SYNC)))
+			return false;
+	}
+	return true;
+}
+
+static void rtr_mgr_close_less_preferable_groups(const struct rtr_socket *sock, struct rtr_mgr_config *config,
+						 struct rtr_mgr_group *group)
+{
+	pthread_mutex_lock(&config->mutex);
+	tommy_node *node = tommy_list_head(&config->groups->list);
+
+	while (node) {
+		struct rtr_mgr_group_node *group_node = node->data;
+		struct rtr_mgr_group *current_group = group_node->group;
+
+		if ((current_group->status != RTR_MGR_CLOSED) && (current_group != group) &&
+		    (current_group->preference > group->preference)) {
+			for (unsigned int j = 0; j < current_group->sockets_len; j++)
+				rtr_stop(current_group->sockets[j]);
+			set_status(config, current_group, RTR_MGR_CLOSED, sock);
+		}
+		node = node->next;
+	}
+	pthread_mutex_unlock(&config->mutex);
+}
+
+static struct rtr_mgr_group *get_best_inactive_rtr_mgr_group(struct rtr_mgr_config *config, struct rtr_mgr_group *group)
+{
+	pthread_mutex_lock(&config->mutex);
+	tommy_node *node = tommy_list_head(&config->groups->list);
+
+	while (node) {
+		struct rtr_mgr_group_node *group_node = node->data;
+		struct rtr_mgr_group *current_group = group_node->group;
+
+		if ((current_group != group) && (current_group->status == RTR_MGR_CLOSED)) {
+			pthread_mutex_unlock(&config->mutex);
+			return current_group;
+		}
+		node = node->next;
+	}
+	pthread_mutex_unlock(&config->mutex);
+	return NULL;
+}
+
+static bool is_some_rtr_mgr_group_established(struct rtr_mgr_config *config)
+{
+	pthread_mutex_lock(&config->mutex);
+	tommy_node *node = tommy_list_head(&config->groups->list);
+
+	while (node) {
+		struct rtr_mgr_group_node *group_node = node->data;
+
+		if (group_node->group->status == RTR_MGR_ESTABLISHED) {
+			pthread_mutex_unlock(&config->mutex);
+			return true;
+		}
+		node = node->next;
+	}
+	pthread_mutex_unlock(&config->mutex);
+	return false;
+}
+
+static inline void _rtr_mgr_cb_state_shutdown(const struct rtr_socket *sock, struct rtr_mgr_config *config,
+					      struct rtr_mgr_group *group)
+{
+	bool all_down = true;
+
+	for (unsigned int i = 0; i < group->sockets_len; i++) {
+		if (group->sockets[i]->state != RTR_SHUTDOWN) {
+			all_down = false;
+			break;
+		}
+	}
+	if (all_down)
+		set_status(config, group, RTR_MGR_CLOSED, sock);
+	else
+		set_status(config, group, group->status, sock);
+}
+
+static inline void _rtr_mgr_cb_state_established(const struct rtr_socket *sock, struct rtr_mgr_config *config,
+						 struct rtr_mgr_group *group)
+{
+	/* socket established a connection to the rtr_server */
+	if (group->status == RTR_MGR_CONNECTING) {
+		/*
+		 * if previous state was CONNECTING, check if all
+		 * other sockets in the group also have a established
+		 * connection, if yes change group state to ESTABLISHED
+		 */
+		if (rtr_mgr_config_status_is_synced(group)) {
+			set_status(config, group, RTR_MGR_ESTABLISHED, sock);
+			rtr_mgr_close_less_preferable_groups(sock, config, group);
+		} else {
+			set_status(config, group, RTR_MGR_CONNECTING, sock);
+		}
+	} else if (group->status == RTR_MGR_ERROR) {
+		/* if previous state was ERROR, only change state to
+		 * ESTABLISHED if all other more preferable socket
+		 * groups are also in ERROR or SHUTDOWN state
+		 */
+		bool all_error = true;
+
+		pthread_mutex_lock(&config->mutex);
+		tommy_node *node = tommy_list_head(&config->groups->list);
+
+		while (node) {
+			struct rtr_mgr_group_node *group_node = node->data;
+			struct rtr_mgr_group *current_group = group_node->group;
+
+			if ((current_group != group) && (current_group->status != RTR_MGR_ERROR) &&
+			    (current_group->status != RTR_MGR_CLOSED) &&
+			    (current_group->preference < group->preference)) {
+				all_error = false;
+			}
+			node = node->next;
+		}
+		pthread_mutex_unlock(&config->mutex);
+
+		if (all_error && rtr_mgr_config_status_is_synced(group)) {
+			set_status(config, group, RTR_MGR_ESTABLISHED, sock);
+			rtr_mgr_close_less_preferable_groups(sock, config, group);
+		} else {
+			set_status(config, group, RTR_MGR_ERROR, sock);
+		}
+	}
+}
+
+static inline void _rtr_mgr_cb_state_connecting(const struct rtr_socket *sock, struct rtr_mgr_config *config,
+						struct rtr_mgr_group *group)
+{
+	if (group->status == RTR_MGR_ERROR)
+		set_status(config, group, RTR_MGR_ERROR, sock);
+	else
+		set_status(config, group, RTR_MGR_CONNECTING, sock);
+}
+
+static inline void _rtr_mgr_cb_state_error(const struct rtr_socket *sock, struct rtr_mgr_config *config,
+					   struct rtr_mgr_group *group)
+{
+	set_status(config, group, RTR_MGR_ERROR, sock);
+
+	if (!is_some_rtr_mgr_group_established(config)) {
+		struct rtr_mgr_group *next_group = get_best_inactive_rtr_mgr_group(config, group);
+
+		if (next_group)
+			rtr_mgr_start_sockets(next_group);
+		else
+			MGR_DBG1("No other inactive groups found");
+	}
+}
+
+static void rtr_mgr_cb(const struct rtr_socket *sock, const enum rtr_socket_state state, void *data_config,
+		       void *data_group)
+{
+	if (state == RTR_SHUTDOWN)
+		MGR_DBG1("Received RTR_SHUTDOWN callback");
+
+	struct rtr_mgr_config *config = data_config;
+	struct rtr_mgr_group *group = data_group;
+
+	if (!group) {
+		MGR_DBG1("ERROR: Socket has no group");
+		return;
+	}
+
+	switch (state) {
+	case RTR_SHUTDOWN:
+		_rtr_mgr_cb_state_shutdown(sock, config, group);
+		break;
+	case RTR_ESTABLISHED:
+		_rtr_mgr_cb_state_established(sock, config, group);
+		break;
+	case RTR_CONNECTING:
+		_rtr_mgr_cb_state_connecting(sock, config, group);
+		break;
+	case RTR_ERROR_FATAL:
+	case RTR_ERROR_TRANSPORT:
+	case RTR_ERROR_NO_DATA_AVAIL:
+		_rtr_mgr_cb_state_error(sock, config, group);
+		break;
+	default:
+		set_status(config, group, group->status, sock);
+	}
+}
+
+int rtr_mgr_config_cmp(const void *a, const void *b)
+{
+	const struct rtr_mgr_group *ar = a;
+	const struct rtr_mgr_group *br = b;
+
+	if (ar->preference > br->preference)
+		return 1;
+	else if (ar->preference < br->preference)
+		return -1;
+	return 0;
+}
+
+int rtr_mgr_config_cmp_tommy(const void *a, const void *b)
+{
+	const struct rtr_mgr_group_node *ar = a;
+	const struct rtr_mgr_group_node *br = b;
+
+	return rtr_mgr_config_cmp(ar->group, br->group);
+}
+
+RTRLIB_EXPORT int rtr_mgr_init(struct rtr_mgr_config **config_out, struct rtr_mgr_group groups[],
+			       const unsigned int groups_len, const unsigned int refresh_interval,
+			       const unsigned int expire_interval, const unsigned int retry_interval,
+			       const pfx_update_fp update_fp, const spki_update_fp spki_update_fp,
+			       const rtr_mgr_status_fp status_fp, void *status_fp_data)
+{
+	enum rtr_rtvals err_code = RTR_ERROR;
+	enum rtr_interval_mode iv_mode = RTR_INTERVAL_MODE_DEFAULT_MIN_MAX;
+	struct pfx_table *pfxt = NULL;
+	struct spki_table *spki_table = NULL;
+	struct rtr_mgr_config *config = NULL;
+	struct rtr_mgr_group *cg = NULL;
+	struct rtr_mgr_group_node *group_node;
+	uint8_t last_preference = UINT8_MAX;
+
+	*config_out = NULL;
+
+	if (groups_len == 0) {
+		MGR_DBG1("Error Empty rtr_mgr_group array");
+		return RTR_ERROR;
+	}
+
+	*config_out = config = lrtr_malloc(sizeof(*config));
+	if (!config)
+		return RTR_ERROR;
+
+	config->len = groups_len;
+
+	if (pthread_mutex_init(&config->mutex, NULL) != 0) {
+		MGR_DBG1("Mutex initialization failed");
+		goto err;
+	}
+	/* sort array in asc order, so we can check for dupl. pref */
+	qsort(groups, groups_len, sizeof(struct rtr_mgr_group), &rtr_mgr_config_cmp);
+
+	/* Check that the groups have unique pref and at least one socket */
+	for (unsigned int i = 0; i < config->len; i++) {
+		if ((i > 0) && (groups[i].preference == last_preference)) {
+			MGR_DBG1("Error Same preference for 2 socket groups!");
+			goto err;
+		}
+		if (groups[i].sockets_len == 0) {
+			MGR_DBG1("Error Empty sockets array in socket group!");
+			goto err;
+		}
+
+		last_preference = groups[i].preference;
+	}
+
+	/* Init data structures that we need to pass to the sockets */
+	pfxt = lrtr_malloc(sizeof(*pfxt));
+	if (!pfxt)
+		goto err;
+	pfx_table_init(pfxt, update_fp);
+
+	spki_table = lrtr_malloc(sizeof(*spki_table));
+	if (!spki_table)
+		goto err;
+	spki_table_init(spki_table, spki_update_fp);
+
+	config->pfx_table = pfxt;
+	config->spki_table = spki_table;
+
+	/* Copy the groups from the array into linked list config->groups */
+	config->len = groups_len;
+	config->groups = lrtr_malloc(sizeof(*config->groups));
+	if (!config->groups)
+		goto err;
+	config->groups->list = NULL;
+
+	for (unsigned int i = 0; i < groups_len; i++) {
+		cg = lrtr_malloc(sizeof(struct rtr_mgr_group));
+		if (!cg)
+			goto err;
+
+		memcpy(cg, &groups[i], sizeof(struct rtr_mgr_group));
+
+		cg->status = RTR_MGR_CLOSED;
+		err_code = rtr_mgr_init_sockets(cg, config, refresh_interval, expire_interval, retry_interval, iv_mode);
+		if (err_code)
+			goto err;
+
+		group_node = lrtr_malloc(sizeof(struct rtr_mgr_group_node));
+		if (!group_node)
+			goto err;
+
+		group_node->group = cg;
+		tommy_list_insert_tail(&config->groups->list, &group_node->node, group_node);
+	}
+	/* Our linked list should be sorted already, since the groups array was
+	 * sorted. However, for safety reasons we sort again.
+	 */
+	tommy_list_sort(&config->groups->list, &rtr_mgr_config_cmp_tommy);
+
+	config->status_fp_data = status_fp_data;
+	config->status_fp = status_fp;
+	return RTR_SUCCESS;
+
+err:
+	if (spki_table)
+		spki_table_free(spki_table);
+	if (pfxt)
+		pfx_table_free(pfxt);
+	lrtr_free(pfxt);
+	lrtr_free(spki_table);
+
+	lrtr_free(cg);
+
+	lrtr_free(config->groups);
+	lrtr_free(config);
+	config = NULL;
+	*config_out = NULL;
+
+	return err_code;
+}
+
+RTRLIB_EXPORT struct rtr_mgr_group *rtr_mgr_get_first_group(struct rtr_mgr_config *config)
+{
+	tommy_node *head = tommy_list_head(&config->groups->list);
+	struct rtr_mgr_group_node *group_node = head->data;
+
+	return group_node->group;
+}
+
+RTRLIB_EXPORT int rtr_mgr_start(struct rtr_mgr_config *config)
+{
+	MGR_DBG("%s()", __func__);
+	struct rtr_mgr_group *best_group = rtr_mgr_get_first_group(config);
+
+	return rtr_mgr_start_sockets(best_group);
+}
+
+RTRLIB_EXPORT bool rtr_mgr_conf_in_sync(struct rtr_mgr_config *config)
+{
+	pthread_mutex_lock(&config->mutex);
+	tommy_node *node = tommy_list_head(&config->groups->list);
+
+	while (node) {
+		bool all_sync = true;
+		struct rtr_mgr_group_node *group_node = node->data;
+
+		for (unsigned int j = 0; all_sync && (j < group_node->group->sockets_len); j++) {
+			if (group_node->group->sockets[j]->last_update == 0)
+				all_sync = false;
+		}
+		if (all_sync) {
+			pthread_mutex_unlock(&config->mutex);
+			return true;
+		}
+		node = node->next;
+	}
+	pthread_mutex_unlock(&config->mutex);
+	return false;
+}
+
+RTRLIB_EXPORT void rtr_mgr_free(struct rtr_mgr_config *config)
+{
+	MGR_DBG("%s()", __func__);
+	pthread_mutex_lock(&config->mutex);
+
+	pfx_table_free(config->pfx_table);
+	spki_table_free(config->spki_table);
+	lrtr_free(config->spki_table);
+	lrtr_free(config->pfx_table);
+
+	/* Free linked list */
+	tommy_node *head = tommy_list_head(&config->groups->list);
+
+	while (head) {
+		tommy_node *tmp = head;
+		struct rtr_mgr_group_node *group_node = tmp->data;
+
+		head = head->next;
+		for (unsigned int j = 0; j < group_node->group->sockets_len; j++)
+			tr_free(group_node->group->sockets[j]->tr_socket);
+
+		lrtr_free(group_node->group);
+		lrtr_free(group_node);
+	}
+
+	lrtr_free(config->groups);
+
+	pthread_mutex_unlock(&config->mutex);
+	pthread_mutex_destroy(&config->mutex);
+	lrtr_free(config);
+}
+
+/* cppcheck-suppress unusedFunction */
+RTRLIB_EXPORT inline int rtr_mgr_validate(struct rtr_mgr_config *config, const uint32_t asn,
+					  const struct lrtr_ip_addr *prefix, const uint8_t mask_len,
+					  enum pfxv_state *result)
+{
+	return pfx_table_validate(config->pfx_table, asn, prefix, mask_len, result);
+}
+
+/* cppcheck-suppress unusedFunction */
+RTRLIB_EXPORT inline int rtr_mgr_get_spki(struct rtr_mgr_config *config, const uint32_t asn, uint8_t *ski,
+					  struct spki_record **result, unsigned int *result_count)
+{
+	return spki_table_get_all(config->spki_table, asn, ski, result, result_count);
+}
+
+RTRLIB_EXPORT void rtr_mgr_stop(struct rtr_mgr_config *config)
+{
+	pthread_mutex_lock(&config->mutex);
+	tommy_node *node = tommy_list_head(&config->groups->list);
+
+	MGR_DBG("%s()", __func__);
+	while (node) {
+		struct rtr_mgr_group_node *group_node = node->data;
+
+		for (unsigned int j = 0; j < group_node->group->sockets_len; j++)
+			rtr_stop(group_node->group->sockets[j]);
+		node = node->next;
+	}
+	pthread_mutex_unlock(&config->mutex);
+}
+
+/* cppcheck-suppress unusedFunction */
+RTRLIB_EXPORT int rtr_mgr_add_group(struct rtr_mgr_config *config, const struct rtr_mgr_group *group)
+{
+	unsigned int refresh_iv = 3600;
+	unsigned int retry_iv = 600;
+	unsigned int expire_iv = 7200;
+	enum rtr_interval_mode iv_mode = RTR_INTERVAL_MODE_DEFAULT_MIN_MAX;
+	enum rtr_rtvals err_code = RTR_ERROR;
+	struct rtr_mgr_group_node *new_group_node = NULL;
+	struct rtr_mgr_group *new_group = NULL;
+	struct rtr_mgr_group_node *gnode;
+
+	pthread_mutex_lock(&config->mutex);
+
+	tommy_node *node = tommy_list_head(&config->groups->list);
+
+	while (node) {
+		gnode = node->data;
+		if (gnode->group->preference == group->preference) {
+			MGR_DBG1("Group with preference value already exists!");
+			err_code = RTR_INVALID_PARAM;
+			goto err;
+		}
+
+		// TODO This is not pretty. It wants to get the same intervals
+		// that are being used by other groups. Maybe intervals should
+		// be store globally/per-group/per-socket?
+		if (gnode->group->sockets[0]->refresh_interval)
+			refresh_iv = gnode->group->sockets[0]->refresh_interval;
+		if (gnode->group->sockets[0]->retry_interval)
+			retry_iv = gnode->group->sockets[0]->retry_interval;
+		if (gnode->group->sockets[0]->expire_interval)
+			expire_iv = gnode->group->sockets[0]->expire_interval;
+		node = node->next;
+	}
+	new_group = lrtr_malloc(sizeof(struct rtr_mgr_group));
+
+	if (!new_group)
+		goto err;
+
+	memcpy(new_group, group, sizeof(struct rtr_mgr_group));
+	new_group->status = RTR_MGR_CLOSED;
+
+	err_code = rtr_mgr_init_sockets(new_group, config, refresh_iv, expire_iv, retry_iv, iv_mode);
+	if (err_code)
+		goto err;
+
+	new_group_node = lrtr_malloc(sizeof(struct rtr_mgr_group_node));
+	if (!new_group_node)
+		goto err;
+
+	new_group_node->group = new_group;
+	tommy_list_insert_tail(&config->groups->list, &new_group_node->node, new_group_node);
+	config->len++;
+
+	MGR_DBG("Group with preference %d successfully added!", new_group->preference);
+
+	tommy_list_sort(&config->groups->list, &rtr_mgr_config_cmp_tommy);
+
+	struct rtr_mgr_group *best_group = rtr_mgr_get_first_group(config);
+
+	if (best_group->status == RTR_MGR_CLOSED)
+		rtr_mgr_start_sockets(best_group);
+
+	pthread_mutex_unlock(&config->mutex);
+	return RTR_SUCCESS;
+
+err:
+	pthread_mutex_unlock(&config->mutex);
+
+	if (new_group)
+		lrtr_free(new_group);
+
+	return err_code;
+}
+
+/* cppcheck-suppress unusedFunction */
+RTRLIB_EXPORT int rtr_mgr_remove_group(struct rtr_mgr_config *config, unsigned int preference)
+{
+	pthread_mutex_lock(&config->mutex);
+	tommy_node *remove_node = NULL;
+	tommy_node *node = tommy_list_head(&config->groups->list);
+	struct rtr_mgr_group_node *group_node;
+	struct rtr_mgr_group *remove_group;
+
+	if (config->len == 1) {
+		MGR_DBG1("Cannot remove last remaining group!");
+		pthread_mutex_unlock(&config->mutex);
+		return RTR_ERROR;
+	}
+
+	// Find the node of the group we want to remove
+	while (node && !remove_node) {
+		group_node = node->data;
+		if (group_node->group->preference == preference)
+			remove_node = node;
+		node = node->next;
+	}
+
+	if (!remove_node) {
+		MGR_DBG1("The group that should be removed does not exist!");
+		pthread_mutex_unlock(&config->mutex);
+		return RTR_ERROR;
+	}
+
+	group_node = remove_node->data;
+	remove_group = group_node->group;
+	tommy_list_remove_existing(&config->groups->list, remove_node);
+	config->len--;
+	MGR_DBG("Group with preference %d successfully removed!", preference);
+	// tommy_list_sort(&config->groups->list, &rtr_mgr_config_cmp);
+	pthread_mutex_unlock(&config->mutex);
+
+	// If group isn't closed, make it so!
+	if (remove_group->status != RTR_MGR_CLOSED) {
+		for (unsigned int j = 0; j < remove_group->sockets_len; j++) {
+			rtr_stop(remove_group->sockets[j]);
+			tr_free(remove_group->sockets[j]->tr_socket);
+		}
+		set_status(config, remove_group, RTR_MGR_CLOSED, NULL);
+	}
+
+	struct rtr_mgr_group *best_group = rtr_mgr_get_first_group(config);
+
+	if (best_group->status == RTR_MGR_CLOSED)
+		rtr_mgr_start_sockets(best_group);
+
+	lrtr_free(group_node->group);
+	lrtr_free(group_node);
+	return RTR_SUCCESS;
+}
+
+// TODO: write test for this function.
+/* cppcheck-suppress unusedFunction */
+RTRLIB_EXPORT int rtr_mgr_for_each_group(struct rtr_mgr_config *config,
+					 void(fp)(const struct rtr_mgr_group *group, void *data), void *data)
+{
+	tommy_node *node = tommy_list_head(&config->groups->list);
+
+	while (node) {
+		struct rtr_mgr_group_node *group_node = node->data;
+
+		fp(group_node->group, data);
+		node = node->next;
+	}
+
+	return RTR_SUCCESS;
+}
+
+RTRLIB_EXPORT const char *rtr_mgr_status_to_str(enum rtr_mgr_status status)
+{
+	return mgr_str_status[status];
+}
+
+/* cppcheck-suppress unusedFunction */
+RTRLIB_EXPORT inline void rtr_mgr_for_each_ipv4_record(struct rtr_mgr_config *config,
+						       void(fp)(const struct pfx_record *, void *data), void *data)
+{
+	pfx_table_for_each_ipv4_record(config->pfx_table, fp, data);
+}
+
+/* cppcheck-suppress unusedFunction */
+RTRLIB_EXPORT inline void rtr_mgr_for_each_ipv6_record(struct rtr_mgr_config *config,
+						       void(fp)(const struct pfx_record *, void *data), void *data)
+{
+	pfx_table_for_each_ipv6_record(config->pfx_table, fp, data);
+}
diff --git a/rtrlib/rtr_mgr.h b/rtrlib/rtr_mgr.h
new file mode 100644
index 0000000..b267723
--- /dev/null
+++ b/rtrlib/rtr_mgr.h
@@ -0,0 +1,261 @@
+/*
+ * This file is part of RTRlib.
+ *
+ * This file is subject to the terms and conditions of the MIT license.
+ * See the file LICENSE in the top level directory for more details.
+ *
+ * Website: http://rtrlib.realmv6.org/
+ */
+
+/**
+ * @defgroup mod_rtr_mgr_h RTR connection manager
+ * @brief The RTR connection manager maintains multiple groups of @ref
+ * rtr_socket "RTR sockets".
+ * @details The RTR connection manager is initialized with one or multiple
+ * groups of rtr_sockets. Each group is configured with a preference
+ * value and contains a set of rtr_socket RTR sockets. It connects to all
+ * sockets of the group with the lowest preference value.\n
+ * In case of failures, the connection manager establishes connections to
+ * RTR servers of another group with the next lowest preference value (see
+ * <a href="https://tools.ietf.org/html/rfc6810">IETF
+ * RFC 6810</a> for details about error handling).\n
+ * RTRlib also supports a Retry Interval (see
+ * <a href="https://tools.ietf.org/html/draft-ietf-sidr-rpki-rtr-rfc6810-bis">
+ * draft-ietf-sidr-rpki-rtr-rfc6810-bis</a>).
+ * If a more preferred group is online again, the RTR connection manager
+ * will switch back and close connections to the caches of the less
+ * preferred group.
+ *
+ * @{
+ * @example rtr_mgr.c
+ * Usage example of the RTR connection manager.
+ */
+#ifndef RTR_MGR
+#define RTR_MGR
+
+#include "rtrlib/pfx/pfx.h"
+#include "rtrlib/spki/spkitable.h"
+
+#include <pthread.h>
+#include <stdint.h>
+
+/**
+ * @brief Status of a rtr_mgr_group.
+ */
+enum rtr_mgr_status {
+	/** RTR sockets are disconnected */
+	RTR_MGR_CLOSED,
+	/** RTR sockets trying to establish a connection. */
+	RTR_MGR_CONNECTING,
+	/** All RTR sockets of the group are synchronized with rtr servers. */
+	RTR_MGR_ESTABLISHED,
+	/** Error occurred on at least one RTR socket. */
+	RTR_MGR_ERROR,
+};
+
+/**
+ * @brief A set of RTR sockets.
+ * @param sockets Array of rtr_socket pointer. The tr_socket element of
+ *		the rtr_socket must be associated with an initialized #
+ *		transport socket.
+ * @param sockets_len Number of elements in the sockets array.
+ * @param preference The preference value of this group.
+ *		   Groups with lower preference values are preferred.
+ * @param status Status of the group.
+ */
+struct rtr_mgr_group {
+	struct rtr_socket **sockets;
+	unsigned int sockets_len;
+	uint8_t preference;
+	enum rtr_mgr_status status;
+};
+
+typedef void (*rtr_mgr_status_fp)(const struct rtr_mgr_group *, enum rtr_mgr_status, const struct rtr_socket *, void *);
+
+struct tommy_list_wrapper;
+
+// TODO Add refresh, expire, and retry intervals to config for easier access.
+struct rtr_mgr_config {
+	struct tommy_list_wrapper *groups;
+	unsigned int len;
+	pthread_mutex_t mutex;
+	rtr_mgr_status_fp status_fp;
+	void *status_fp_data;
+	struct pfx_table *pfx_table;
+	struct spki_table *spki_table;
+};
+
+/**
+ * @brief Initializes a rtr_mgr_config.
+ * @param[out] config_out The rtr_mgr_config that will be initialized by this
+ *			function. On error, *config_out will be NULL!
+ * @param[in] groups Linked list of rtr_mgr_group. Every RTR socket in an
+ *		     rtr_mgr_group must be assoziated with an initialized
+ *		     transport socket. A Transport socket is only allowed to be
+ *		     associated with one rtr socket. The preference values must
+ *		     be unique in the linked list. More than one rtr_mgr_group
+ *		     with the same preference value isn't allowed.
+ * @param[in] groups_len Number of elements in the groups array. Must be >= 1.
+ * @param[in] refresh_interval Interval in seconds between serial queries that
+ *			     are sent to the server. Must be >= 1 and <=
+ *			     86400s (1d), recommended default is 3600s (1h).
+ * @param[in] expire_interval Stored validation records will be deleted if
+ *			    cache was unable to refresh data for this period.
+ *			    The value should be twice the refresh_interval
+ *			    and must be >= 600s (10min) and <= 172800s (2d).
+ *			    The recommended default is 7200s (2h).
+ * @param[in] retry_interval This parameter tells the router how long to wait
+ *			   (in seconds) before retrying a failed Serial Query
+ *			   or Reset Query.
+ *			   The value must be >= 1s and <= 7200s (2h).
+ *			   The recommended default is 600s (10min).
+ * @param[in] update_fp Pointer to pfx_update_fp callback, that is executed for
+			every added and removed pfx_record.
+ * @param[in] spki_update_fp Pointer to spki_update_fp callback, that is
+			     executed for every added and removed spki_record.
+ * @param[in] status_fp Pointer to a function that is called if the connection
+ *			status from one of the socket groups is changed.
+ * @param[in] status_fp_data Pointer to a memory area that is passed to the
+ *			     status_fp function. Memory area can be freely used
+ *			     to pass user-defined data to the status_fp
+ *			     callback.
+ * @return RTR_ERROR If an error occurred
+ * @return RTR_INVALID_PARAM If refresh_interval or expire_interval is invalid.
+ * @return RTR_SUCCESS On success.
+ */
+int rtr_mgr_init(struct rtr_mgr_config **config_out, struct rtr_mgr_group groups[], const unsigned int groups_len,
+		 const unsigned int refresh_interval, const unsigned int expire_interval,
+		 const unsigned int retry_interval, const pfx_update_fp update_fp, const spki_update_fp spki_update_fp,
+		 const rtr_mgr_status_fp status_fp, void *status_fp_data);
+
+/**
+ * @brief Adds a new rtr_mgr_group to the linked list of a initialized config.
+ * @details A new group must have at least one rtr_socket associated
+ *          with it. This socket must have at least one initialized
+ *          transport socket associated with it. The new group must
+ *          have a preference value that is none of the already present
+ *          groups have. More than one rtr_mgr_group with the same
+ *          preference is not allowed.
+ * @param config A rtr_mgr_config struct that has been initialized
+ *           previously with rtr_mgr_init
+ * @param group A rtr_mgr_group with at least one rtr_socket and a
+ *           preference value that no existing group has.
+ * @return RTR_INVALID_PARAM If a group with the same preference value already
+ *           exists.
+ * @return RTR_ERROR If an error occurred while adding the group.
+ * @return RTR_SUCCESS If the group was successfully added.
+ *
+ */
+int rtr_mgr_add_group(struct rtr_mgr_config *config, const struct rtr_mgr_group *group);
+/**
+ * @brief Removes an existing rtr_mgr_group from the linked list of config.
+ * @details The group to be removed is identified by its preference value.
+ *          Should the group to be removed be currently active, it will be
+ *          shut down and the next best group will be spun up.
+ * @param config A rtr_mgr_config struct that has been initialized previously
+ *          with rtr_mgr_init
+ * @param preference The preference value of the group to be removed.
+ * @return RTR_ERROR If no group with this preference value exists.
+ * @return RTR_SUCCESS If group was successfully removed.
+ *
+ */
+int rtr_mgr_remove_group(struct rtr_mgr_config *config, unsigned int preference);
+/**
+ * @brief Frees all resources that were allocated from the rtr_mgr.
+ * @details rtr_mgr_stop must be called before, to shutdown all rtr_sockets.
+ * @param[in] config rtr_mgr_config.
+ */
+void rtr_mgr_free(struct rtr_mgr_config *config);
+
+/**
+ * @brief Establishes rtr_socket connections
+ * @details Establishes the connection with the rtr_sockets of the group
+ * with the lowest preference value and handles errors as defined in the
+ * RPKI-RTR protocol.
+ * @param[in] config Pointer to an initialized rtr_mgr_config.
+ * @return RTR_SUCCESS On success
+ * @return RTR_ERROR On error
+ */
+int rtr_mgr_start(struct rtr_mgr_config *config);
+
+/**
+ * @brief Terminates rtr_socket connections
+ * @details Terminates all rtr_socket connections defined in the config.
+ * All pfx_records received from these sockets will be purged.
+ * @param[in] config The rtr_mgr_config struct
+ */
+void rtr_mgr_stop(struct rtr_mgr_config *config);
+
+/**
+ * @brief Check if rtr_mgr_group is fully synchronized with at least one group.
+ * @param[in] config The rtr_mgr_config.
+ * @return true If pfx_table stores non-outdated pfx_records
+ * @return false If pfx_table isn't fully synchronized with at least one group.
+ */
+bool rtr_mgr_conf_in_sync(struct rtr_mgr_config *config);
+
+/**
+ * @brief Validates the origin of a BGP-Route.
+ * @param[in] config The rtr_mgr_config
+ * @param[in] asn Autonomous system number of the Origin-AS of the prefix
+ * @param[in] prefix Announced network prefix
+ * @param[in] mask_len Length of the network mask of the announced prefix
+ * @param[out] result Outcome of the validation
+ * @return PFX_SUCCESS On success.
+ * @return PFX_ERROR If an error occurred.
+ */
+int rtr_mgr_validate(struct rtr_mgr_config *config, const uint32_t asn, const struct lrtr_ip_addr *prefix,
+		     const uint8_t mask_len, enum pfxv_state *result);
+
+/**
+ * @brief Returns all SPKI records which match the given ASN and SKI.
+ * @param[in] config
+ * @param[in] asn Autonomous system number of the Origin-AS
+ * @param[in] ski the SKI to search for
+ * @param[out] result a array of all matching spki_records
+ * @param[out] result_count number of returned spki_records
+ * @return SPKI_SUCCESS On success
+ * @return SPKI_ERROR If an error occurred
+ */
+int rtr_mgr_get_spki(struct rtr_mgr_config *config, const uint32_t asn, uint8_t *ski, struct spki_record **result,
+		     unsigned int *result_count);
+
+/**
+ * @brief Converts a rtr_mgr_status to a String.
+ * @param[in] status state to convert to a string.
+ * @return NULL If status isn't a valid rtr_mgr_status.
+ * @return !=NULL The rtr_rtr_mgr_status as String.
+ */
+const char *rtr_mgr_status_to_str(enum rtr_mgr_status status);
+
+/**
+ * @brief Iterates over all IPv4 records in the pfx_table.
+ * @details For every pfx_record the function fp is called. The pfx_record and
+ * the data pointer is passed to the fp.
+ * @param[in] config rtr_mgr_config
+ * @param[in] fp Pointer to callback function with signature \c pfx_for_each_fp.
+ * @param[in] data This parameter is forwarded to the callback function.
+ */
+void rtr_mgr_for_each_ipv4_record(struct rtr_mgr_config *config, pfx_for_each_fp fp, void *data);
+
+/**
+ * @brief Iterates over all IPv6 records in the pfx_table.
+ * @details For every pfx_record the function fp is called. The pfx_record and
+ * the data pointer is passed to the fp.
+ * @param[in] config rtr_mgr_config
+ * @param[in] fp Pointer to callback function with signature \c pfx_for_each_fp.
+ * @param[in] data This parameter is forwarded to the callback function.
+ */
+void rtr_mgr_for_each_ipv6_record(struct rtr_mgr_config *config, pfx_for_each_fp fp, void *data);
+
+/**
+ * @brief Returns the first, thus active group.
+ * @param[in] config The rtr_mgr_config
+ * @return rtr_mgr_group The head of the linked list.
+ */
+struct rtr_mgr_group *rtr_mgr_get_first_group(struct rtr_mgr_config *config);
+
+int rtr_mgr_for_each_group(struct rtr_mgr_config *config, void (*fp)(const struct rtr_mgr_group *group, void *data),
+			   void *data);
+#endif
+/** @} */
diff --git a/rtrlib/rtr_mgr_private.h b/rtrlib/rtr_mgr_private.h
new file mode 100644
index 0000000..d654820
--- /dev/null
+++ b/rtrlib/rtr_mgr_private.h
@@ -0,0 +1,27 @@
+/*
+ * This file is part of RTRlib.
+ *
+ * This file is subject to the terms and conditions of the MIT license.
+ * See the file LICENSE in the top level directory for more details.
+ *
+ * Website: http://rtrlib.realmv6.org/
+ */
+
+#ifndef RTR_MGR_PRIVATE
+#define RTR_MGR_PRIVATE
+
+#include "rtrlib/rtr_mgr.h"
+
+#include "third-party/tommyds/tommylist.h"
+
+struct tommy_list_wrapper {
+	tommy_list list;
+};
+
+// TODO Find a nicer way todo a linked list (without writing our own)
+struct rtr_mgr_group_node {
+	tommy_node node;
+	struct rtr_mgr_group *group;
+};
+
+#endif
diff --git a/rtrlib/rtrlib.h.cmake b/rtrlib/rtrlib.h.cmake
new file mode 100644
index 0000000..de8f612
--- /dev/null
+++ b/rtrlib/rtrlib.h.cmake
@@ -0,0 +1,40 @@
+/*
+ * This file is part of RTRlib.
+ *
+ * This file is subject to the terms and conditions of the MIT license.
+ * See the file LICENSE in the top level directory for more details.
+ *
+ * Website: http://rtrlib.realmv6.org/
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef RTRLIB_H
+#define RTRLIB_H
+
+#cmakedefine RTRLIB_HAVE_LIBSSH
+#define RTRLIB_VERSION_MAJOR @RTRLIB_VERSION_MAJOR@
+#define RTRLIB_VERSION_MINOR @RTRLIB_VERSION_MINOR@
+#define RTRLIB_VERSION_PATCH @RTRLIB_VERSION_PATCH@
+
+#include "lib/alloc_utils.h"
+#include "lib/ip.h"
+#include "lib/ipv4.h"
+#include "lib/ipv6.h"
+#include "pfx/pfx.h"
+#include "rtr/rtr.h"
+#include "rtr_mgr.h"
+#include "spki/spkitable.h"
+#include "transport/tcp/tcp_transport.h"
+#include "transport/transport.h"
+#ifdef RTRLIB_HAVE_LIBSSH
+#include "rtrlib/transport/ssh/ssh_transport.h"
+#endif
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/rtrlib/rtrlib_export_private.h b/rtrlib/rtrlib_export_private.h
new file mode 100644
index 0000000..c5ed4b3
--- /dev/null
+++ b/rtrlib/rtrlib_export_private.h
@@ -0,0 +1,16 @@
+
+/*
+ * This file is part of RTRlib.
+ *
+ * This file is subject to the terms and conditions of the MIT license.
+ * See the file LICENSE in the top level directory for more details.
+ *
+ * Website: http://rtrlib.realmv6.org/
+ */
+
+#ifndef RTRLIB_EXPORT_H
+#define RTRLIB_EXPORT_H
+
+#define RTRLIB_EXPORT __attribute__((visibility("default")))
+
+#endif