checkpoint

34 files changed, 586 insertions, 585 deletions

diff --git a/scripts/build-all.sh b/scripts/build-all.sh
index 909db75..e24cf5b 100755
--- a/scripts/build-all.sh
+++ b/scripts/build-all.sh
@@ -42,9 +42,9 @@ PROONE_PREFIX="builds"
 PROONE_BIN="$PROONE_PREFIX/bin"
 PROONE_TOOLS="$PROONE_PREFIX/tools"
 export PROONE_BIN_PREFIX="$PROONE_BIN/proone"
-PROONE_PACKER="$PROONE_TOOLS/proone-packer"
-PROONE_UNPACKER="$PROONE_TOOLS/proone-unpacker"
-PROONE_BIN_ARCHIVE="$PROONE_PREFIX/bin-archive.zz.base64"
+PROONE_PACKER="$PROONE_TOOLS/proone-pack"
+PROONE_UNPACKER="$PROONE_TOOLS/proone-unpack"
+PROONE_BIN_ARCHIVE="$PROONE_PREFIX/bin-archive"
 
 rm -rf "$PROONE_PREFIX" && mkdir "$PROONE_PREFIX" "$PROONE_BIN" "$PROONE_TOOLS"
 if [ $? -ne 0 ] ; then
@@ -54,7 +54,7 @@ fi
 make distclean
 
 # native build for tools
-./configure &&  make -j$(nproc) && cp -a src/proone-packer "$PROONE_PACKER" && cp -a src/proone-unpacker "$PROONE_UNPACKER" && make distclean
+./configure &&  make -j$(nproc) && cp -a src/proone-pack "$PROONE_PACKER" && cp -a src/proone-unpack "$PROONE_UNPACKER" && make distclean
 if [ $? -ne 0 ]; then
     exit $?
 fi
@@ -68,7 +68,8 @@ for (( i = 0; i < ARR_SIZE; i += 1 )); do
 done
 
 # pack
-"$PROONE_PACKER" "$PROONE_BIN_PREFIX."* | pigz -z - | base64 > "$PROONE_BIN_ARCHIVE"
+echo "" > "$PROONE_BIN_ARCHIVE" # don't include the credential line
+"$PROONE_PACKER" "$PROONE_BIN_PREFIX."* | pigz -z - | base64 >> "$PROONE_BIN_ARCHIVE"
 if [ $? -ne 0 ]; then
     exit $?
 fi
diff --git a/scripts/test_bin-archive.sh b/scripts/test_bin-archive.sh
index c4e1d93..0506102 100755
--- a/scripts/test_bin-archive.sh
+++ b/scripts/test_bin-archive.sh
@@ -16,10 +16,10 @@ if [ -z "$LISTARCH" ]; then
     LISTARCH="../src/proone-list-arch"
 fi
 if [ -z "$PACKER" ]; then
-    PACKER="../src/proone-packer"
+    PACKER="../src/proone-pack"
 fi
 if [ -z "$UNPACKER" ]; then
-    UNPACKER="../src/proone-unpacker"
+    UNPACKER="../src/proone-unpack"
 fi
 ARCH_ARR=(`"$LISTARCH"`)
 
@@ -41,12 +41,12 @@ for arch in ${ARCH_ARR[@]}; do
     fi
 done
 
-"$PACKER" "$BIN_PACK_DIR/$BIN_PREFIX."* | pigz -z - | base64 > "$TEST_DIR/$BIN_ARCHIVE_PREFIX.zz.b64"
+"$PACKER" "$BIN_PACK_DIR/$BIN_PREFIX."* | pigz -z - | base64 > "$TEST_DIR/$BIN_ARCHIVE_PREFIX"
 if [ $? -ne 0 ]; then
     exit 2;
 fi
 
-"$UNPACKER" "$BIN_UNPACK_DIR/$BIN_PREFIX" < "$TEST_DIR/$BIN_ARCHIVE_PREFIX.zz.b64"
+"$UNPACKER" "$BIN_UNPACK_DIR/$BIN_PREFIX" < "$TEST_DIR/$BIN_ARCHIVE_PREFIX"
 if [ $? -ne 0 ]; then
     exit 2;
 fi
@@ -58,6 +58,6 @@ for arch in ${ARCH_ARR[@]}; do
     fi
 done
 
-echo $(du -bs "$BIN_PACK_DIR" | awk '{print $1;}') $(wc -c "$TEST_DIR/$BIN_ARCHIVE_PREFIX.zz.b64" | awk '{print $1;}') >> "$SIZE_LOG"
+echo $(du -bs "$BIN_PACK_DIR" | awk '{print $1;}') $(wc -c "$TEST_DIR/$BIN_ARCHIVE_PREFIX" | awk '{print $1;}') >> "$SIZE_LOG"
 
 exit 0
diff --git a/src/Makefile.am b/src/Makefile.am
index 910f7ba..6ebd69d 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -11,29 +11,29 @@ endif
 AM_CFLAGS = -std=c11 -pedantic -Wall -Wextra -Wno-switch -Wno-unused-parameter -D_GNU_SOURCE $(DEV_FLAGS)
 
 noinst_LIBRARIES = libproone.a
-bin_PROGRAMS = proone proone-packer proone-unpacker proone-list-arch proone-mask proone-print-all-data
+bin_PROGRAMS = proone proone-pack proone-unpack proone-list-arch proone-mask proone-print-all-data
 
 libproone_a_SOURCES =\
-	proone_protocol.c\
-	proone_pack.c\
-	proone_dvault.c\
-	proone_data.c\
-	proone_util.c\
-	proone_rnd.c
+	protocol.c\
+	pack.c\
+	dvault.c\
+	data.c\
+	util.c\
+	rnd.c
 
 proone_LDFLAGS = -static
 proone_LDADD = libproone.a $(DEP_LIBS) -lrt
 proone_SOURCES =\
-	proone_worker.c\
-	proone_heartbeat-worker.c\
+	worker.c\
+	heartbeat-worker.c\
 	proone.c
 
-proone_packer_LDADD = libproone.a
-proone_packer_SOURCES = proone-packer.c
+proone_pack_LDADD = libproone.a
+proone_pack_SOURCES = proone-pack.c
 
-proone_unpacker_LDADD = libproone.a
-proone_unpacker_LDFLAGS = $(DEP_LIBS)
-proone_unpacker_SOURCES = proone-unpacker.c
+proone_unpack_LDADD = libproone.a
+proone_unpack_LDFLAGS = $(DEP_LIBS)
+proone_unpack_SOURCES = proone-unpack.c
 
 proone_list_arch_LDADD = libproone.a
 proone_list_arch_SOURCES = proone-list-arch.c
diff --git a/src/proone_data.c b/src/data.c
index 7f1a4e7..6798175 100644
--- a/src/proone_data.c
+++ b/src/data.c
@@ -1,9 +1,9 @@
-#include "proone_data.h"
+#include "data.h"
 
 
-uint8_t *PROONE_DATA_DICT[NB_PROONE_DATA_KEY] = {
-    // PROONE_DATA_KEY_PROC_LIM_SHM: "/31e4f17c-db76-4332-af48-fd9fb8453f8f"
+uint8_t *PRNE_DATA_DICT[NB_PRNE_DATA_KEY] = {
+    // PRNE_DATA_KEY_PROC_LIM_SHM: "/31e4f17c-db76-4332-af48-fd9fb8453f8f"
     (uint8_t*)"\x00\x7F\x00\x25\x09\x24\x82\xC5\x8F\x65\xF8\x96\x35\x02\xF5\xAD\xC9\xF4\x83\x60\xD2\x33\x21\xB1\x3F\xCB\x8C\x8E\x4E\xF8\x18\xBE\x06\x33\xC5\xC4\x43\x7D\x2C\xA3\x7B",
-    // PROONE_DATA_KEY_SIGN_INIT_OK: "cd264451-2156-4e12-ae1c-89931878a54f"
+    // PRNE_DATA_KEY_SIGN_INIT_OK: "cd264451-2156-4e12-ae1c-89931878a54f"
     (uint8_t*)"\x00\x37\x00\x24\x41\xEC\xB4\xD8\xF2\x70\xFE\x92\xC1\x6B\xBD\xB8\x49\x46\x3E\x58\x96\x5C\xB2\x4B\x1E\x23\x1E\x90\xC0\x2C\x95\xCA\xE8\x06\xC2\x00\x95\x58\x9F\x8F",
 };
diff --git a/src/data.h b/src/data.h
new file mode 100644
index 0000000..740e8b4
--- /dev/null
+++ b/src/data.h
@@ -0,0 +1,13 @@
+#pragma once
+#include <stdint.h>
+
+
+typedef enum {
+    PRNE_DATA_KEY_NONE = -1,
+    PRNE_DATA_KEY_PROC_LIM_SHM,
+    PRNE_DATA_KEY_SIGN_INIT_OK,
+    NB_PRNE_DATA_KEY
+} prne_data_key_t;
+
+
+extern uint8_t *PRNE_DATA_DICT[NB_PRNE_DATA_KEY];
diff --git a/src/proone_dvault.c b/src/dvault.c
index 1da09cc..df2f0d6 100644
--- a/src/proone_dvault.c
+++ b/src/dvault.c
@@ -1,4 +1,4 @@
-#include "proone_dvault.h"
+#include "dvault.h"
 
 #include <stdint.h>
 #include <stdbool.h>
@@ -7,7 +7,7 @@
 #include <string.h>
 
 
-const uint8_t PROONE_DVAULT_MASK[] = {
+const uint8_t PRNE_DVAULT_MASK[] = {
     0xA2, 0x7A, 0x61, 0x65, 0x78, 0xBE, 0x95, 0x8A, 0xBF, 0x07, 
     0x52, 0x8F, 0x0E, 0x6F, 0x0B, 0xD8, 0x5B, 0xD4, 0x77, 0x9D, 
     0x39, 0x28, 0x72, 0xE2, 0x42, 0x5D, 0xE7, 0x92, 0xDD, 0xAF, 
@@ -40,79 +40,79 @@ static uint8_t *unmasked_buf = NULL;
 static size_t unmasked_buf_size = 0;
 
 
-static void pne_dvault_invert_entry (const proone_data_key_t key, size_t *len) {
-    const size_t entry_size = proone_dvault_get_entry_size(key);
+static void invert_entry (const prne_data_key_t key, size_t *len) {
+    const size_t entry_size = prne_dvault_get_entry_size(key);
 
     if (len != NULL) {
         *len = entry_size;
     }
-    memcpy(unmasked_buf, PROONE_DATA_DICT[key] + 4, entry_size);
-    proone_dvault_invert_mem(entry_size, unmasked_buf, proone_dvault_get_entry_salt(key));
+    memcpy(unmasked_buf, PRNE_DATA_DICT[key] + 4, entry_size);
+    prne_dvault_invert_mem(entry_size, unmasked_buf, prne_dvault_get_entry_salt(key));
 }
 
-static void pne_dvault_entry_check (const proone_data_key_t key, const proone_data_type_t type) {
-    if (!(PROONE_DATA_KEY_NONE < key && key < NB_PROONE_DATA_KEY) ||
-        !(PROONE_DATA_TYPE_NONE < type && type < NB_PROONE_DATA_TYPE) ||
-        type != proone_dvault_get_entry_data_type(key)) {
+static void entry_check (const prne_data_key_t key, const prne_data_type_t type) {
+    if (!(PRNE_DATA_KEY_NONE < key && key < NB_PRNE_DATA_KEY) ||
+        !(PRNE_DATA_TYPE_NONE < type && type < NB_PRNE_DATA_TYPE) ||
+        type != prne_dvault_get_entry_data_type(key)) {
         abort();
     }
 }
 
 
-const char *proone_data_type2str (const proone_data_type_t t) {
+const char *prne_data_type2str (const prne_data_type_t t) {
     switch (t) {
-    case PROONE_DATA_TYPE_CSTR: return "cstr";
+    case PRNE_DATA_TYPE_CSTR: return "cstr";
     }
     return NULL;
 }
 
-proone_data_type_t proone_str2data_type (const char *str) {
-    if (strcmp(str, proone_data_type2str(PROONE_DATA_TYPE_CSTR)) == 0) {
-        return PROONE_DATA_TYPE_CSTR;
+prne_data_type_t prne_str2data_type (const char *str) {
+    if (strcmp(str, prne_data_type2str(PRNE_DATA_TYPE_CSTR)) == 0) {
+        return PRNE_DATA_TYPE_CSTR;
     }
-    return PROONE_DATA_TYPE_NONE;
+    return PRNE_DATA_TYPE_NONE;
 }
 
-void proone_dvault_invert_mem (const size_t size, uint8_t *m, const uint8_t salt) {
+void prne_dvault_invert_mem (const size_t size, uint8_t *m, const uint8_t salt) {
     size_t i;
 
     for (i = 0; i < size; i += 1) {
-        m[i] ^= PROONE_DVAULT_MASK[(i + (size_t)salt) % 256];
+        m[i] ^= PRNE_DVAULT_MASK[(i + (size_t)salt) % 256];
     }
 }
 
-void proone_init_dvault_mask_result (proone_dvault_mask_result_t *r) {
-    r->result = PROONE_DVAULT_MASK_OK;
+void prne_init_dvault_mask_result (prne_dvault_mask_result_t *r) {
+    r->result = PRNE_DVAULT_MASK_OK;
     r->str = NULL;
     r->str_len = 0;
 }
 
-void proone_free_dvault_mask_result (proone_dvault_mask_result_t *r) {
+void prne_free_dvault_mask_result (prne_dvault_mask_result_t *r) {
     free(r->str);
     r->str_len = 0;
     r->str = NULL;
-    r->result = PROONE_DVAULT_MASK_OK;
+    r->result = PRNE_DVAULT_MASK_OK;
 }
 
-proone_dvault_mask_result_t proone_dvault_mask (const proone_data_type_t type, const uint8_t salt, const size_t data_size, const uint8_t *data) {
+prne_dvault_mask_result_t prne_dvault_mask (const prne_data_type_t type, const uint8_t salt, const size_t data_size, const uint8_t *data) {
     size_t i;
-    proone_dvault_mask_result_t ret;
+    prne_dvault_mask_result_t ret;
 
-    proone_init_dvault_mask_result(&ret);
+    prne_init_dvault_mask_result(&ret);
 
     if (data_size > 0x0000FFFF) {
-        ret.result = PROONE_DVAULT_MASK_TOO_LARGE;
+        ret.result = PRNE_DVAULT_MASK_TOO_LARGE;
         return ret;        
     }
-    if (!(PROONE_DATA_TYPE_NONE < type && type < NB_PROONE_DATA_TYPE)) {
-        ret.result = PROONE_DVAULT_MASK_INVALID_TYPE;
+    if (!(PRNE_DATA_TYPE_NONE < type && type < NB_PRNE_DATA_TYPE)) {
+        ret.result = PRNE_DVAULT_MASK_INVALID_TYPE;
         return ret;        
     }
 
     ret.str_len = 4 * 4 + 4 * data_size + 1;
     ret.str = malloc(ret.str_len);
     if (ret.str == NULL) {
-        ret.result = PROONE_DVAULT_MASK_MEM_ERR;
+        ret.result = PRNE_DVAULT_MASK_MEM_ERR;
         ret.str_len = 0;
         return ret;
     }
@@ -124,21 +124,21 @@ proone_dvault_mask_result_t proone_dvault_mask (const proone_data_type_t type, c
         (uint8_t)((0x000000FF & (uint32_t)data_size) >> 0));
 
     for (i = 0; i < data_size; i += 1) {
-        sprintf(ret.str + 4 * 4 + 4 * i, "\\x%02X", data[i] ^ PROONE_DVAULT_MASK[(i + (size_t)salt) % 256]);
+        sprintf(ret.str + 4 * 4 + 4 * i, "\\x%02X", data[i] ^ PRNE_DVAULT_MASK[(i + (size_t)salt) % 256]);
     }
 
     return ret;
 }
 
-void proone_init_dvault (void) {
+void prne_init_dvault (void) {
     size_t max_size = 0;
     size_t entry_size;
-    proone_data_key_t i;
+    prne_data_key_t i;
 
-    for (i = PROONE_DATA_KEY_NONE + 1; i < NB_PROONE_DATA_KEY; i += 1) {
-        entry_size = proone_dvault_get_entry_size(i);
-        switch (proone_dvault_get_entry_data_type(i)) {
-        case PROONE_DATA_TYPE_CSTR:
+    for (i = PRNE_DATA_KEY_NONE + 1; i < NB_PRNE_DATA_KEY; i += 1) {
+        entry_size = prne_dvault_get_entry_size(i);
+        switch (prne_dvault_get_entry_data_type(i)) {
+        case PRNE_DATA_TYPE_CSTR:
             entry_size += 1;
             break;
         }
@@ -158,30 +158,30 @@ void proone_init_dvault (void) {
     }
 }
 
-void proone_deinit_dvault (void) {
+void prne_deinit_dvault (void) {
     free(unmasked_buf);
     unmasked_buf = NULL;
 }
 
-proone_data_type_t proone_dvault_get_entry_data_type (const proone_data_key_t key) {
-    return (proone_data_type_t)PROONE_DATA_DICT[key][0];
+prne_data_type_t prne_dvault_get_entry_data_type (const prne_data_key_t key) {
+    return (prne_data_type_t)PRNE_DATA_DICT[key][0];
 }
 
-size_t proone_dvault_get_entry_size (const proone_data_key_t key) {
-    return (size_t)PROONE_DATA_DICT[key][2] << 8 | (size_t)PROONE_DATA_DICT[key][3];
+size_t prne_dvault_get_entry_size (const prne_data_key_t key) {
+    return (size_t)PRNE_DATA_DICT[key][2] << 8 | (size_t)PRNE_DATA_DICT[key][3];
 }
 
-uint8_t proone_dvault_get_entry_salt (const proone_data_key_t key) {
-    return PROONE_DATA_DICT[key][1];
+uint8_t prne_dvault_get_entry_salt (const prne_data_key_t key) {
+    return PRNE_DATA_DICT[key][1];
 }
 
-char *proone_dvault_unmask_entry_cstr (const proone_data_key_t key, size_t *len) {
-    proone_dvault_reset_dict();
-    pne_dvault_entry_check(key, PROONE_DATA_TYPE_CSTR);
-    pne_dvault_invert_entry(key, len);
+char *prne_dvault_unmask_entry_cstr (const prne_data_key_t key, size_t *len) {
+    prne_dvault_reset_dict();
+    entry_check(key, PRNE_DATA_TYPE_CSTR);
+    invert_entry(key, len);
     return (char*)unmasked_buf;
 }
 
-void proone_dvault_reset_dict (void) {
+void prne_dvault_reset_dict (void) {
     memset(unmasked_buf, 0, unmasked_buf_size);
 }
diff --git a/src/dvault.h b/src/dvault.h
new file mode 100644
index 0000000..71fbc5e
--- /dev/null
+++ b/src/dvault.h
@@ -0,0 +1,47 @@
+#pragma once
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "data.h"
+
+
+typedef struct prne_dvault_mask_result prne_dvault_mask_result_t;
+
+typedef enum {
+    PRNE_DATA_TYPE_NONE = -1,
+    PRNE_DATA_TYPE_CSTR,
+    NB_PRNE_DATA_TYPE
+} prne_data_type_t;
+
+typedef enum {
+    PRNE_DVAULT_MASK_OK,
+    PRNE_DVAULT_MASK_MEM_ERR,
+    PRNE_DVAULT_MASK_TOO_LARGE,
+    PRNE_DVAULT_MASK_INVALID_TYPE
+} prne_dvault_mask_result_code_t;
+
+struct prne_dvault_mask_result {
+    size_t str_len;
+    char *str;
+    prne_dvault_mask_result_code_t result;
+};
+
+
+extern const uint8_t PRNE_DVAULT_MASK[256];
+
+const char *prne_data_type2str (const prne_data_type_t t);
+prne_data_type_t prne_str2data_type (const char *str);
+void prne_dvault_invert_mem (const size_t size, uint8_t *m, const uint8_t salt);
+
+void prne_init_dvault_mask_result (prne_dvault_mask_result_t *r);
+void prne_free_dvault_mask_result (prne_dvault_mask_result_t *r);
+prne_dvault_mask_result_t prne_dvault_mask (const prne_data_type_t type, const uint8_t salt, const size_t data_size, const uint8_t *data);
+
+void prne_init_dvault (void);
+void prne_deinit_dvault (void);
+prne_data_type_t prne_dvault_get_entry_data_type (const prne_data_key_t key);
+size_t prne_dvault_get_entry_size (const prne_data_key_t key);
+uint8_t prne_dvault_get_entry_salt (const prne_data_key_t key);
+char *prne_dvault_unmask_entry_cstr (const prne_data_key_t key, size_t *len);
+void prne_dvault_reset_dict (void);
diff --git a/src/proone_heartbeat-worker.c b/src/heartbeat-worker.c
index 817021e..e3e4acd 100644
--- a/src/proone_heartbeat-worker.c
+++ b/src/heartbeat-worker.c
@@ -1,5 +1,5 @@
-#include "proone_heartbeat-worker.h"
-#include "proone_dvault.h"
+#include "heartbeat-worker.h"
+#include "dvault.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -34,7 +34,7 @@ static void heartbeat_worker_fin (void *in_ctx) {
 	ctx->finalised = true;
 }
 
-static void heartbeat_worker_work (void *in_ctx, const proone_worker_sched_info_t *sched_info, proone_worker_sched_req_t *sched_req) {
+static void heartbeat_worker_work (void *in_ctx, const prne_worker_sched_info_t *sched_info, prne_worker_sched_req_t *sched_req) {
 	DECL_CTX_PTR(in_ctx);
 
 	if (sched_req->pollfd_ready) {
@@ -42,7 +42,7 @@ static void heartbeat_worker_work (void *in_ctx, const proone_worker_sched_info_
 
 		if (revents & (POLLERR | POLLHUP | POLLNVAL)) {
 			ctx->finalised = true;
-			sched_req->flags = PROONE_WORKER_SCHED_FLAG_NONE;
+			sched_req->flags = PRNE_WORKER_SCHED_FLAG_NONE;
 			return;
 		}
 		if (revents & POLLIN) {
@@ -55,7 +55,7 @@ static void heartbeat_worker_work (void *in_ctx, const proone_worker_sched_info_
 
 				addr_len = sizeof(struct sockaddr_in);
 				if (recvfrom(ctx->fd, ctx->rcv_buf, sizeof(ctx->rcv_buf), 0, (struct sockaddr*)&remote_addr, &addr_len) == sizeof(ctx->rcv_buf)) {
-					proone_dvault_invert_mem(sizeof(ctx->rcv_buf) - 1, ctx->rcv_buf + 1, ctx->rcv_buf[0]);
+					prne_dvault_invert_mem(sizeof(ctx->rcv_buf) - 1, ctx->rcv_buf + 1, ctx->rcv_buf[0]);
 					sendto(ctx->fd, ctx->rcv_buf + 1, sizeof(ctx->rcv_buf) - 1, 0, (const struct sockaddr*)&remote_addr, addr_len);
 				}
 			}
@@ -64,14 +64,14 @@ static void heartbeat_worker_work (void *in_ctx, const proone_worker_sched_info_
 
 				addr_len = sizeof(struct sockaddr_in6);
 				if (recvfrom(ctx->fd, ctx->rcv_buf, sizeof(ctx->rcv_buf), 0, (struct sockaddr*)&remote_addr, &addr_len) == sizeof(ctx->rcv_buf)) {
-					proone_dvault_invert_mem(sizeof(ctx->rcv_buf) - 1, ctx->rcv_buf + 1, ctx->rcv_buf[0]);
+					prne_dvault_invert_mem(sizeof(ctx->rcv_buf) - 1, ctx->rcv_buf + 1, ctx->rcv_buf[0]);
 					sendto(ctx->fd, ctx->rcv_buf + 1, sizeof(ctx->rcv_buf) - 1, 0, (const struct sockaddr*)&remote_addr, addr_len);
 				}
 			}
 		}
 	}
 
-	sched_req->flags = PROONE_WORKER_SCHED_FLAG_POLL;
+	sched_req->flags = PRNE_WORKER_SCHED_FLAG_POLL;
 	sched_req->mem_func.alloc(sched_req, 1);
 	sched_req->pollfd_arr[0].fd = ctx->fd;
 	sched_req->pollfd_arr[0].events = POLLIN;
@@ -83,7 +83,7 @@ static bool heartbeat_worker_has_finalised (void *in_ctx) {
 }
 
 
-bool proone_alloc_heartbeat_worker (proone_worker_t *w) {
+bool prne_alloc_heartbeat_worker (prne_worker_t *w) {
 	bool ret = true;
 	hb_w_ctx_t *ctx = NULL;
 	
diff --git a/src/heartbeat-worker.h b/src/heartbeat-worker.h
new file mode 100644
index 0000000..7a5f060
--- /dev/null
+++ b/src/heartbeat-worker.h
@@ -0,0 +1,9 @@
+#pragma once
+#include "worker.h"
+
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+
+bool prne_alloc_heartbeat_worker (prne_worker_t *w);
diff --git a/src/proone_pack.c b/src/pack.c
index dec602e..e83d433 100644
--- a/src/proone_pack.c
+++ b/src/pack.c
@@ -1,5 +1,5 @@
-#include "proone_pack.h"
-#include "proone_util.h"
+#include "pack.h"
+#include "util.h"
 
 #include <stdint.h>
 #include <stdbool.h>
@@ -16,7 +16,7 @@
 #include <zlib.h>
 
 
-void proone_init_bin_archive (proone_bin_archive_t *a) {
+void prne_init_bin_archive (prne_bin_archive_t *a) {
     a->data_size = 0;
     a->data = NULL;
     a->nb_binaries = 0;
@@ -25,17 +25,17 @@ void proone_init_bin_archive (proone_bin_archive_t *a) {
     a->size_arr = NULL;    
 }
 
-void proone_init_unpack_bin_archive_result (proone_unpack_bin_archive_result_t *r) {
+void prne_init_unpack_bin_archive_result (prne_unpack_bin_archive_result_t *r) {
     r->data_size = 0;
     r->data = NULL;
-    r->result = PROONE_UNPACK_BIN_ARCHIVE_OK;
+    r->result = PRNE_UNPACK_BIN_ARCHIVE_OK;
     r->err = 0;
 }
 
-proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) {
+prne_unpack_bin_archive_result_t prne_unpack_bin_archive (const int fd) {
     static const size_t fd_buf_size = 77, bio_buf_size = 58, z_buf_size = 4096;
     
-    proone_unpack_bin_archive_result_t ret;
+    prne_unpack_bin_archive_result_t ret;
     BIO *b64_bio = NULL, *mem_bio = NULL;
     uint8_t *mem = NULL, *fd_buf = NULL, *bio_buf = NULL, *z_buf = NULL;
     int fd_read_size, fd_data_size, bio_write_size, bio_read_size;
@@ -45,12 +45,12 @@ proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) {
     void *ny_buf;
     bool stream_end;
 
-    proone_init_unpack_bin_archive_result(&ret);
+    prne_init_unpack_bin_archive_result(&ret);
     memset(&stream, 0, sizeof(z_stream));
 
     mem = (uint8_t*)malloc(fd_buf_size + bio_buf_size + z_buf_size);
     if (mem == NULL) {
-        ret.result = PROONE_UNPACK_BIN_ARCHIVE_MEM_ERR;
+        ret.result = PRNE_UNPACK_BIN_ARCHIVE_MEM_ERR;
         ret.err = errno;
         goto END;
     }
@@ -60,13 +60,13 @@ proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) {
 
     z_func_ret = inflateInit(&stream);
     if (z_func_ret != Z_OK) {
-        ret.result = PROONE_UNPACK_BIN_ARCHIVE_Z_ERR;
+        ret.result = PRNE_UNPACK_BIN_ARCHIVE_Z_ERR;
         ret.err = z_func_ret;
         goto END;
     }
 
     if ((mem_bio = BIO_new(BIO_s_mem())) == NULL || (b64_bio = BIO_new(BIO_f_base64())) == NULL) {
-        ret.result = PROONE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR;
+        ret.result = PRNE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR;
         ret.err = ERR_get_error();
         goto END;
     }
@@ -77,7 +77,7 @@ proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) {
     do {
         fd_read_size = read(fd, fd_buf, fd_buf_size);
         if (fd_read_size < 0) {
-            ret.result = PROONE_UNPACK_BIN_ARCHIVE_ERRNO;
+            ret.result = PRNE_UNPACK_BIN_ARCHIVE_ERRNO;
             ret.err = errno;
             goto END;
         }
@@ -86,19 +86,19 @@ proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) {
         }
 
         // remove white spaces
-        fd_data_size = proone_str_shift_spaces((char*)fd_buf, (size_t)fd_read_size);
+        fd_data_size = prne_str_shift_spaces((char*)fd_buf, (size_t)fd_read_size);
 
         if (fd_data_size > 0) {
             BIO_reset(mem_bio);
             bio_write_size = BIO_write(mem_bio, fd_buf, fd_data_size);
             if (bio_write_size != fd_data_size) {
-                ret.result = PROONE_UNPACK_BIN_ARCHIVE_MEM_ERR;
+                ret.result = PRNE_UNPACK_BIN_ARCHIVE_MEM_ERR;
                 goto END;
             }
 
             bio_read_size = BIO_read(b64_bio, bio_buf, (int)bio_buf_size);
             if (bio_read_size < 0) {
-                ret.result = PROONE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR;
+                ret.result = PRNE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR;
                 ret.err = ERR_get_error();
                 goto END;
             }
@@ -118,7 +118,7 @@ proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) {
                     case Z_BUF_ERROR:
                         break;
                     default:
-                        ret.result = PROONE_UNPACK_BIN_ARCHIVE_Z_ERR;
+                        ret.result = PRNE_UNPACK_BIN_ARCHIVE_Z_ERR;
                         ret.err = z_func_ret;
                         goto END;
                     } 
@@ -127,7 +127,7 @@ proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) {
                     if (z_out_size > 0) {
                         ny_buf = realloc(ret.data, ret.data_size + z_out_size);
                         if (ny_buf == NULL) {
-                            ret.result = PROONE_UNPACK_BIN_ARCHIVE_MEM_ERR;
+                            ret.result = PRNE_UNPACK_BIN_ARCHIVE_MEM_ERR;
                             ret.err = errno;
                             break;
                         }
@@ -143,7 +143,7 @@ proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd) {
 
 END:
     free(mem);
-    if (ret.result != PROONE_UNPACK_BIN_ARCHIVE_OK) {
+    if (ret.result != PRNE_UNPACK_BIN_ARCHIVE_OK) {
         free(ret.data);
         ret.data = NULL;
         ret.data_size = 0;
@@ -155,33 +155,33 @@ END:
     return ret;
 }
 
-proone_index_bin_archive_result_code_t proone_index_bin_archive (proone_unpack_bin_archive_result_t *in, proone_bin_archive_t *out) {
-    proone_index_bin_archive_result_code_t ret = PROONE_INDEX_BIN_ARCHIVE_OK;
-    size_t buf_pos = 0, arr_cnt = 0, offset_arr[NB_PROONE_ARCH], size_arr[NB_PROONE_ARCH];
-    proone_arch_t arch;
+prne_index_bin_archive_result_code_t prne_index_bin_archive (prne_unpack_bin_archive_result_t *in, prne_bin_archive_t *out) {
+    prne_index_bin_archive_result_code_t ret = PRNE_INDEX_BIN_ARCHIVE_OK;
+    size_t buf_pos = 0, arr_cnt = 0, offset_arr[NB_PRNE_ARCH], size_arr[NB_PRNE_ARCH];
+    prne_arch_t arch;
     uint32_t bin_size;
-    proone_arch_t arch_arr[NB_PROONE_ARCH];
-    proone_bin_archive_t archive;
+    prne_arch_t arch_arr[NB_PRNE_ARCH];
+    prne_bin_archive_t archive;
     uint8_t *out_buf;
     
-    memset(arch_arr, 0, sizeof(proone_arch_t) * NB_PROONE_ARCH);
-    memset(offset_arr, 0, sizeof(size_t) * NB_PROONE_ARCH);
-    memset(size_arr, 0, sizeof(size_t) * NB_PROONE_ARCH);
-    proone_init_bin_archive(&archive);
+    memset(arch_arr, 0, sizeof(prne_arch_t) * NB_PRNE_ARCH);
+    memset(offset_arr, 0, sizeof(size_t) * NB_PRNE_ARCH);
+    memset(size_arr, 0, sizeof(size_t) * NB_PRNE_ARCH);
+    prne_init_bin_archive(&archive);
 
     do {
-        if (buf_pos + 4 >= in->data_size || arr_cnt >= NB_PROONE_ARCH) {
-            ret = PROONE_INDEX_BIN_ARCHIVE_FMT_ERR;
+        if (buf_pos + 4 >= in->data_size || arr_cnt >= NB_PRNE_ARCH) {
+            ret = PRNE_INDEX_BIN_ARCHIVE_FMT_ERR;
             goto END;
         }
 
-        arch = (proone_arch_t)in->data[buf_pos];
+        arch = (prne_arch_t)in->data[buf_pos];
         bin_size =
             ((uint32_t)in->data[buf_pos + 1] << 16) |
             ((uint32_t)in->data[buf_pos + 2] << 8) |
             (uint32_t)in->data[buf_pos + 3];
-        if (proone_arch2str(arch) == NULL || bin_size == 0 || buf_pos + 4 + bin_size > in->data_size) {
-            ret = PROONE_INDEX_BIN_ARCHIVE_FMT_ERR;
+        if (prne_arch2str(arch) == NULL || bin_size == 0 || buf_pos + 4 + bin_size > in->data_size) {
+            ret = PRNE_INDEX_BIN_ARCHIVE_FMT_ERR;
             goto END;
         }
 
@@ -193,19 +193,19 @@ proone_index_bin_archive_result_code_t proone_index_bin_archive (proone_unpack_b
         buf_pos += 4 + bin_size;
     } while (buf_pos < in->data_size);
 
-    out_buf = (uint8_t*)malloc(sizeof(proone_arch_t) * arr_cnt + sizeof(size_t*) * arr_cnt + sizeof(size_t*) * arr_cnt);
+    out_buf = (uint8_t*)malloc(sizeof(prne_arch_t) * arr_cnt + sizeof(size_t*) * arr_cnt + sizeof(size_t*) * arr_cnt);
     if (out_buf == NULL) {
-        ret = PROONE_INDEX_BIN_ARCHIVE_MEM_ERR;
+        ret = PRNE_INDEX_BIN_ARCHIVE_MEM_ERR;
         goto END;
     }
-    archive.arch_arr = (proone_arch_t*)out_buf;
-    archive.offset_arr = (size_t*)(out_buf + sizeof(proone_arch_t) * arr_cnt);
-    archive.size_arr = (size_t*)(out_buf + sizeof(proone_arch_t) * arr_cnt + sizeof(size_t*) * arr_cnt);
+    archive.arch_arr = (prne_arch_t*)out_buf;
+    archive.offset_arr = (size_t*)(out_buf + sizeof(prne_arch_t) * arr_cnt);
+    archive.size_arr = (size_t*)(out_buf + sizeof(prne_arch_t) * arr_cnt + sizeof(size_t*) * arr_cnt);
 
     archive.data_size = in->data_size;
     archive.data = in->data;
     archive.nb_binaries = arr_cnt;
-    memcpy(archive.arch_arr, arch_arr, arr_cnt * sizeof(proone_arch_t));
+    memcpy(archive.arch_arr, arch_arr, arr_cnt * sizeof(prne_arch_t));
     memcpy(archive.offset_arr, offset_arr, arr_cnt * sizeof(size_t));
     memcpy(archive.size_arr, size_arr, arr_cnt * sizeof(size_t));
 
@@ -214,22 +214,22 @@ proone_index_bin_archive_result_code_t proone_index_bin_archive (proone_unpack_b
     *out = archive;
 
 END:
-    if (ret != PROONE_INDEX_BIN_ARCHIVE_OK) {
-        proone_free_bin_archive(&archive);
+    if (ret != PRNE_INDEX_BIN_ARCHIVE_OK) {
+        prne_free_bin_archive(&archive);
     }
 
     return ret;
 }
 
-void proone_free_unpack_bin_archive_result (proone_unpack_bin_archive_result_t *r) {
+void prne_free_unpack_bin_archive_result (prne_unpack_bin_archive_result_t *r) {
     free(r->data);
     r->data = NULL;
     r->data_size = 0;
-    r->result = PROONE_INDEX_BIN_ARCHIVE_OK;
+    r->result = PRNE_INDEX_BIN_ARCHIVE_OK;
     r->err = 0;
 }
 
-void proone_free_bin_archive (proone_bin_archive_t *a) {
+void prne_free_bin_archive (prne_bin_archive_t *a) {
     free(a->data);
     free(a->arch_arr);
     a->nb_binaries = 0;
diff --git a/src/pack.h b/src/pack.h
new file mode 100644
index 0000000..9f37cb5
--- /dev/null
+++ b/src/pack.h
@@ -0,0 +1,47 @@
+#pragma once
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "protocol.h"
+
+
+typedef struct prne_bin_archive prne_bin_archive_t;
+typedef struct prne_unpack_bin_archive_result prne_unpack_bin_archive_result_t;
+
+struct prne_bin_archive {
+    size_t data_size;
+    uint8_t *data;
+    size_t nb_binaries;
+    prne_arch_t *arch_arr;
+    size_t *offset_arr;
+    size_t *size_arr;
+};
+
+typedef enum {
+    PRNE_UNPACK_BIN_ARCHIVE_OK,
+    PRNE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR,
+    PRNE_UNPACK_BIN_ARCHIVE_Z_ERR,
+    PRNE_UNPACK_BIN_ARCHIVE_ERRNO,
+    PRNE_UNPACK_BIN_ARCHIVE_MEM_ERR
+} prne_unpack_bin_archive_result_code_t;
+
+struct prne_unpack_bin_archive_result {
+    size_t data_size;
+    uint8_t *data;
+    prne_unpack_bin_archive_result_code_t result;
+    long err;
+};
+
+typedef enum {
+    PRNE_INDEX_BIN_ARCHIVE_OK,
+    PRNE_INDEX_BIN_ARCHIVE_FMT_ERR,
+    PRNE_INDEX_BIN_ARCHIVE_MEM_ERR
+} prne_index_bin_archive_result_code_t;
+
+
+void prne_init_bin_archive (prne_bin_archive_t *a);
+void prne_init_unpack_bin_archive_result (prne_unpack_bin_archive_result_t *r);
+prne_unpack_bin_archive_result_t prne_unpack_bin_archive (const int fd);
+prne_index_bin_archive_result_code_t prne_index_bin_archive (prne_unpack_bin_archive_result_t *in, prne_bin_archive_t *out);
+void prne_free_unpack_bin_archive_result (prne_unpack_bin_archive_result_t *r);
+void prne_free_bin_archive (prne_bin_archive_t *a);
diff --git a/src/proone-list-arch.c b/src/proone-list-arch.c
index 792b9c2..e7521ae 100644
--- a/src/proone-list-arch.c
+++ b/src/proone-list-arch.c
@@ -1,13 +1,13 @@
 #include <stdio.h>
 
-#include "proone_protocol.h"
+#include "protocol.h"
 
 
 int main (void) {
-    proone_arch_t i;
+    prne_arch_t i;
 
-    for (i = PROONE_ARCH_NONE + 1; i < NB_PROONE_ARCH; i += 1) {
-        printf("%s\n", proone_arch2str(i));
+    for (i = PRNE_ARCH_NONE + 1; i < NB_PRNE_ARCH; i += 1) {
+        printf("%s\n", prne_arch2str(i));
     }
 
     return 0;
diff --git a/src/proone-mask.c b/src/proone-mask.c
index cd2bad7..9349a0f 100644
--- a/src/proone-mask.c
+++ b/src/proone-mask.c
@@ -6,7 +6,7 @@
 #include <unistd.h>
 #include <fcntl.h>
 
-#include "proone_dvault.h"
+#include "dvault.h"
 
 
 static const char *RND_DEV_PATH = "/dev/random";
@@ -17,10 +17,10 @@ int main (const int argc, const char **args) {
     ssize_t fd_read_size;
     uint8_t salt;
     size_t read_size = 0;
-    proone_dvault_mask_result_t mask_result;
-    proone_data_type_t type;
+    prne_dvault_mask_result_t mask_result;
+    prne_data_type_t type;
 
-    proone_init_dvault_mask_result(&mask_result);
+    prne_init_dvault_mask_result(&mask_result);
 
     if (argc <= 1) {
         fprintf(stderr,
@@ -54,9 +54,9 @@ int main (const int argc, const char **args) {
     close(rnd_fd);
     rnd_fd = -1;
 
-    type = proone_str2data_type(args[1]);
+    type = prne_str2data_type(args[1]);
     switch (type) {
-    case PROONE_DATA_TYPE_CSTR: {
+    case PRNE_DATA_TYPE_CSTR: {
         static const size_t buf_size = 0x0000FFFF + 1;
         uint8_t buf[buf_size];
 
@@ -83,12 +83,12 @@ int main (const int argc, const char **args) {
             goto END;
         }
 
-        mask_result = proone_dvault_mask(type, salt, read_size, buf);
-        if (mask_result.result == PROONE_DVAULT_MASK_OK) {
+        mask_result = prne_dvault_mask(type, salt, read_size, buf);
+        if (mask_result.result == PRNE_DVAULT_MASK_OK) {
             printf("(uint8_t*)\"%s\"\n", mask_result.str);
         }
         else {
-            fprintf(stderr, "Error: proone_dvault_mask() returned %d\n", (int)mask_result.result);
+            fprintf(stderr, "Error: prne_dvault_mask() returned %d\n", (int)mask_result.result);
             exit_code = 1;
             goto END;
         }
@@ -102,7 +102,7 @@ int main (const int argc, const char **args) {
 
 END:
     close(rnd_fd);
-    proone_free_dvault_mask_result(&mask_result);
+    prne_free_dvault_mask_result(&mask_result);
 
     return exit_code;
 }
diff --git a/src/proone-packer.c b/src/proone-pack.c
index 28fd525..2098f4e 100644
--- a/src/proone-packer.c
+++ b/src/proone-pack.c
@@ -11,22 +11,22 @@
 #include <sys/sendfile.h>
 #include <fcntl.h>
 
-#include "proone_protocol.h"
+#include "protocol.h"
 
 
 int main (const int argc, const char **args) {
     typedef struct {
-        proone_arch_t arch;
+        prne_arch_t arch;
         const char *path;
     } archive_tuple_t;
     size_t i;
-    const archive_tuple_t *encounter_arr[NB_PROONE_ARCH];
-    archive_tuple_t archive_arr[NB_PROONE_ARCH];
+    const archive_tuple_t *encounter_arr[NB_PRNE_ARCH];
+    archive_tuple_t archive_arr[NB_PRNE_ARCH];
     archive_tuple_t *archive;
     size_t archive_arr_cnt = 0;
     const char *path, *ext;
     bool proc_result = true;
-    proone_arch_t arch;
+    prne_arch_t arch;
     int bin_fd = -1;
     struct stat st;
     uint8_t head[4];
@@ -41,14 +41,14 @@ int main (const int argc, const char **args) {
         return 1;
     }
     // too many files
-    if (argc - 1 > NB_PROONE_ARCH) {
-        fprintf(stderr, "** Too many files given (%d > %d).\n", argc - 1, NB_PROONE_ARCH);
+    if (argc - 1 > NB_PRNE_ARCH) {
+        fprintf(stderr, "** Too many files given (%d > %d).\n", argc - 1, NB_PRNE_ARCH);
         return 1;
     }
 
     // init
-    memset(encounter_arr, 0, sizeof(archive_tuple_t*) * NB_PROONE_ARCH);
-    memset(archive_arr, 0, sizeof(archive_tuple_t) * NB_PROONE_ARCH);
+    memset(encounter_arr, 0, sizeof(archive_tuple_t*) * NB_PRNE_ARCH);
+    memset(archive_arr, 0, sizeof(archive_tuple_t) * NB_PRNE_ARCH);
 
     // Check the file names are valid
     for (i = 1; i < (size_t)argc; i += 1) {
@@ -62,8 +62,8 @@ int main (const int argc, const char **args) {
         }
         ext += 1;
 
-        arch = proone_str2arch(ext);
-        if (arch == PROONE_ARCH_NONE) {
+        arch = prne_str2arch(ext);
+        if (arch == PRNE_ARCH_NONE) {
             fprintf(stderr, "** %s: unknown arch \"%s\"\n", path, ext);
             proc_result = false;
             continue;
@@ -85,7 +85,7 @@ int main (const int argc, const char **args) {
     }
 
     // do packing
-    fprintf(stderr, archive_arr_cnt == NB_PROONE_ARCH ? "Packing %zu binaries.\n" : "* Warning: packing only %zu binaries\n", archive_arr_cnt);
+    fprintf(stderr, archive_arr_cnt == NB_PRNE_ARCH ? "Packing %zu binaries.\n" : "* Warning: packing only %zu binaries\n", archive_arr_cnt);
     for (i = 0; i < archive_arr_cnt; i += 1) {
         archive = &archive_arr[i];
         fprintf(stderr, "Packing: %s ...\n", archive->path);
diff --git a/src/proone-print-all-data.c b/src/proone-print-all-data.c
index adf5ee9..cdb19ba 100644
--- a/src/proone-print-all-data.c
+++ b/src/proone-print-all-data.c
@@ -1,28 +1,28 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "proone_dvault.h"
+#include "dvault.h"
 
 
 int main (void) {
-	proone_data_key_t i = PROONE_DATA_KEY_NONE + 1;
-	proone_data_type_t type;
+	prne_data_key_t i = PRNE_DATA_KEY_NONE + 1;
+	prne_data_type_t type;
 
-	proone_init_dvault();
+	prne_init_dvault();
 
-	for (i = PROONE_DATA_KEY_NONE + 1; i < NB_PROONE_DATA_KEY; i += 1) {
-		type = (proone_data_type_t)PROONE_DATA_DICT[i][0];
+	for (i = PRNE_DATA_KEY_NONE + 1; i < NB_PRNE_DATA_KEY; i += 1) {
+		type = (prne_data_type_t)PRNE_DATA_DICT[i][0];
 
 		switch (type) {
-		case PROONE_DATA_TYPE_CSTR:
-			printf("%10lld: %s\n", (long long)i, proone_dvault_unmask_entry_cstr(i, NULL));
+		case PRNE_DATA_TYPE_CSTR:
+			printf("%10lld: %s\n", (long long)i, prne_dvault_unmask_entry_cstr(i, NULL));
 			break;
 		default:
-			fprintf(stderr, "Error: unhandled data type (%d)'%s'\n", (int)type, proone_data_type2str(type));
+			fprintf(stderr, "Error: unhandled data type (%d)'%s'\n", (int)type, prne_data_type2str(type));
 			abort();
 		}
 	}
 
-	proone_deinit_dvault();
+	prne_deinit_dvault();
 	return 0;
 }
diff --git a/src/proone-unpacker.c b/src/proone-unpack.c
index 52fd48a..1f0e67f 100644
--- a/src/proone-unpacker.c
+++ b/src/proone-unpack.c
@@ -9,29 +9,29 @@
 #include <openssl/err.h>
 #include <zlib.h>
 
-#include "proone_pack.h"
+#include "pack.h"
 
 
-static void report_unpack_bin_archive_err (const proone_unpack_bin_archive_result_t *r) {
+static void report_unpack_bin_archive_err (const prne_unpack_bin_archive_result_t *r) {
     const char *err_str, *err_msg = NULL;
 
     switch (r->result) {
-    case PROONE_UNPACK_BIN_ARCHIVE_OK:
+    case PRNE_UNPACK_BIN_ARCHIVE_OK:
         err_str = "ok";
         break;
-    case PROONE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR:
+    case PRNE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR:
         err_str = "openssl error";
         err_msg = ERR_error_string(r->err, NULL);
         break;
-    case PROONE_UNPACK_BIN_ARCHIVE_Z_ERR:
+    case PRNE_UNPACK_BIN_ARCHIVE_Z_ERR:
         err_str = "zlib error";
         err_msg = zError((int)r->err);
         break;
-    case PROONE_UNPACK_BIN_ARCHIVE_ERRNO:
+    case PRNE_UNPACK_BIN_ARCHIVE_ERRNO:
         err_str = "errno";
         err_msg = strerror((int)r->err);
         break;
-    case PROONE_UNPACK_BIN_ARCHIVE_MEM_ERR:
+    case PRNE_UNPACK_BIN_ARCHIVE_MEM_ERR:
         err_str = "memory error";
         err_msg = strerror((int)r->err);
         break;
@@ -47,15 +47,15 @@ static void report_unpack_bin_archive_err (const proone_unpack_bin_archive_resul
     }
 }
 
-static void report_index_bin_archive_err (const proone_index_bin_archive_result_code_t c) {
+static void report_index_bin_archive_err (const prne_index_bin_archive_result_code_t c) {
     const char *msg;
 
     switch (c) {
-    case PROONE_INDEX_BIN_ARCHIVE_OK:
+    case PRNE_INDEX_BIN_ARCHIVE_OK:
         msg = "ok"; break;
-    case PROONE_INDEX_BIN_ARCHIVE_FMT_ERR:
+    case PRNE_INDEX_BIN_ARCHIVE_FMT_ERR:
         msg = "format error"; break;
-    case PROONE_INDEX_BIN_ARCHIVE_MEM_ERR:
+    case PRNE_INDEX_BIN_ARCHIVE_MEM_ERR:
         msg = "memory error"; break;
     default:
         msg = "* unknown"; break;
@@ -68,9 +68,9 @@ int main (const int argc, const char **args) {
     int exit_code = 0;
     const char *path_prefix;
     size_t path_prefix_len;
-    proone_unpack_bin_archive_result_t unpack_ret;
-    proone_bin_archive_t bin_archive;
-    proone_index_bin_archive_result_code_t index_ret;
+    prne_unpack_bin_archive_result_t unpack_ret;
+    prne_bin_archive_t bin_archive;
+    prne_index_bin_archive_result_code_t index_ret;
     size_t i;
     const char *arch_str;
     char *path = NULL;
@@ -85,25 +85,25 @@ int main (const int argc, const char **args) {
 
     path_prefix = args[1];
     path_prefix_len = strlen(path_prefix);
-    proone_init_bin_archive(&bin_archive);
+    prne_init_bin_archive(&bin_archive);
 
     do { // fake loop
-        unpack_ret = proone_unpack_bin_archive(STDIN_FILENO);
-        if (unpack_ret.result != PROONE_UNPACK_BIN_ARCHIVE_OK) {
+        unpack_ret = prne_unpack_bin_archive(STDIN_FILENO);
+        if (unpack_ret.result != PRNE_UNPACK_BIN_ARCHIVE_OK) {
             report_unpack_bin_archive_err(&unpack_ret);
             exit_code = 2;
             break;
         }
 
-        index_ret = proone_index_bin_archive(&unpack_ret, &bin_archive);
-        if (index_ret != PROONE_INDEX_BIN_ARCHIVE_OK) {
+        index_ret = prne_index_bin_archive(&unpack_ret, &bin_archive);
+        if (index_ret != PRNE_INDEX_BIN_ARCHIVE_OK) {
             report_index_bin_archive_err(index_ret);
             exit_code = 2;
             break;
         }
 
         for (i = 0; i < bin_archive.nb_binaries; i += 1) {
-            arch_str = proone_arch2str(bin_archive.arch_arr[i]);
+            arch_str = prne_arch2str(bin_archive.arch_arr[i]);
             if (arch_str == NULL) {
                 fprintf(stderr, "** unrecognised arch!");
                 exit_code = 2;
@@ -137,8 +137,8 @@ int main (const int argc, const char **args) {
 
     free(path);
     close(fd);
-    proone_free_unpack_bin_archive_result(&unpack_ret);
-    proone_free_bin_archive(&bin_archive);
+    prne_free_unpack_bin_archive_result(&unpack_ret);
+    prne_free_bin_archive(&bin_archive);
 
     return exit_code;
 }
diff --git a/src/proone.c b/src/proone.c
index 7ddaa8b..33cea92 100644
--- a/src/proone.c
+++ b/src/proone.c
@@ -16,17 +16,17 @@
 #include <sys/file.h>
 
 #include "proone.h"
-#include "proone_util.h"
-#include "proone_dvault.h"
-#include "proone_heartbeat-worker.h"
+#include "util.h"
+#include "dvault.h"
+#include "heartbeat-worker.h"
 
 
-struct proone_global pne_global;
+struct prne_global pne_g;
 
 
 typedef struct {
-    proone_worker_t worker;
-    proone_worker_sched_req_t sched_req;
+    prne_worker_t worker;
+    prne_worker_sched_req_t sched_req;
 } worker_tuple_t;
 
 typedef struct {
@@ -45,10 +45,10 @@ static bool ensure_single_instance (void) {
     int fd;
 
     fd = shm_open(
-        proone_dvault_unmask_entry_cstr(PROONE_DATA_KEY_PROC_LIM_SHM, NULL),
+        prne_dvault_unmask_entry_cstr(PRNE_DATA_KEY_PROC_LIM_SHM, NULL),
         O_RDWR | O_CREAT | O_TRUNC,
         0666);
-    proone_dvault_reset_dict();
+    prne_dvault_reset_dict();
     if (fd < 0) {
         return true;
     }
@@ -57,7 +57,7 @@ static bool ensure_single_instance (void) {
         return errno != EWOULDBLOCK;
     }
     else {
-        pne_global.has_proc_lim_lock = true;
+        pne_g.has_proc_lim_lock = true;
     }
 
     return true;
@@ -66,7 +66,7 @@ static bool ensure_single_instance (void) {
 static void init_rnd_engine (void) {
     uint32_t seed = 0;
     int fd;
-    proone_rnd_engnie_alloc_result_t ret;
+    prne_rnd_engnie_alloc_result_t ret;
 
     fd = open("/dev/urandom", O_RDONLY);
     if (fd >= 0) {
@@ -83,12 +83,12 @@ static void init_rnd_engine (void) {
             (uint32_t)(clock() % 0xFFFFFFFF);
     }
     
-    ret = proone_alloc_rnd_engine(seed == 0 ? NULL : &seed);
-    if (ret.result != PROONE_RND_ENGINE_ALLOC_OK) {
+    ret = prne_alloc_rnd_engine(seed == 0 ? NULL : &seed);
+    if (ret.result != PRNE_RND_ENGINE_ALLOC_OK) {
         abort();
     }
 
-    pne_global.rnd = ret.engine;
+    pne_g.rnd = ret.engine;
 }
 
 static void delete_myself (const char *arg0) {
@@ -130,14 +130,14 @@ static void disasble_watchdog (void) {
 }
 
 static void handle_interrupt (const int sig) {
-    if (pne_global.caught_signal == 0) {
-        pne_global.caught_signal = sig;
+    if (pne_g.caught_signal == 0) {
+        pne_g.caught_signal = sig;
     }
     signal(sig, SIG_DFL);
 }
 
 static void proc_fin_call (void) {
-    if (pne_global.caught_signal != 0) {
+    if (pne_g.caught_signal != 0) {
         size_t i;
         worker_tuple_t *wt;
 
@@ -146,7 +146,7 @@ static void proc_fin_call (void) {
             wt->worker.fin(wt->worker.ctx);
         }
 
-        proc_fin_call_ptr = proone_empty_func;
+        proc_fin_call_ptr = prne_empty_func;
         finalising = true;
     }
 }
@@ -156,15 +156,15 @@ static void print_ready_signature (void) {
     uint8_t *sig_data;
     char *plain_str, *sig_str;
     
-    plain_str = proone_dvault_unmask_entry_cstr(PROONE_DATA_KEY_SIGN_INIT_OK, &len);
+    plain_str = prne_dvault_unmask_entry_cstr(PRNE_DATA_KEY_SIGN_INIT_OK, &len);
 
     sig_data = (uint8_t*)malloc(len + 1);
-    sig_data[0] = (uint8_t)(proone_rnd_gen_int(pne_global.rnd) % 256);
+    sig_data[0] = (uint8_t)(prne_rnd_gen_int(pne_g.rnd) % 256);
     memcpy(sig_data + 1, plain_str, len);
-    proone_dvault_reset_dict();
-    proone_dvault_invert_mem(len, sig_data + 1, sig_data[0]);
+    prne_dvault_reset_dict();
+    prne_dvault_invert_mem(len, sig_data + 1, sig_data[0]);
 
-    sig_str = proone_enc_base64_mem(sig_data, len);
+    sig_str = prne_enc_base64_mem(sig_data, len);
     if (sig_str == NULL) {
         abort();
     }
@@ -192,7 +192,7 @@ static void read_host_credential (void) {
         }
     }
     if (found) {
-        proone_dec_base64_mem(buf, i, &pne_global.host_cred_data, &pne_global.host_cred_size);
+        prne_dec_base64_mem(buf, i, &pne_g.host_cred_data, &pne_g.host_cred_size);
     }
 
 END:
@@ -204,19 +204,19 @@ int main (const int argc, char **args) {
     int exit_code = 0;
     size_t i;
     worker_tuple_t *wt;
-    proone_worker_sched_info_t sched_info;
+    prne_worker_sched_info_t sched_info;
 
-    pne_global.host_cred_data = NULL;
-    pne_global.host_cred_size = 0;
-    pne_global.has_proc_lim_lock = false;
-    pne_global.bin_ready = false;
-    pne_global.caught_signal = 0;
-    pne_global.rnd = NULL;
-    proone_init_unpack_bin_archive_result(&pne_global.bin_pack);
-    proone_init_bin_archive(&pne_global.bin_archive);
+    pne_g.host_cred_data = NULL;
+    pne_g.host_cred_size = 0;
+    pne_g.has_proc_lim_lock = false;
+    pne_g.bin_ready = false;
+    pne_g.caught_signal = 0;
+    pne_g.rnd = NULL;
+    prne_init_unpack_bin_archive_result(&pne_g.bin_pack);
+    prne_init_bin_archive(&pne_g.bin_archive);
 
     /* quick prep. IN THIS ORDER! */
-    proone_init_dvault();
+    prne_init_dvault();
 #ifndef DEBUG
     delete_myself(args[0]);
     disasble_watchdog();
@@ -226,9 +226,9 @@ int main (const int argc, char **args) {
     print_ready_signature();
     read_host_credential();
     // get fed with the bin archive
-    pne_global.bin_pack = proone_unpack_bin_archive(STDIN_FILENO);
-    if (pne_global.bin_pack.result == PROONE_UNPACK_BIN_ARCHIVE_OK) {
-        pne_global.bin_ready = proone_index_bin_archive(&pne_global.bin_pack, &pne_global.bin_archive) == PROONE_INDEX_BIN_ARCHIVE_OK;
+    pne_g.bin_pack = prne_unpack_bin_archive(STDIN_FILENO);
+    if (pne_g.bin_pack.result == PRNE_UNPACK_BIN_ARCHIVE_OK) {
+        pne_g.bin_ready = prne_index_bin_archive(&pne_g.bin_pack, &pne_g.bin_archive) == PRNE_INDEX_BIN_ARCHIVE_OK;
     }
     
     // done with the terminal
@@ -251,34 +251,34 @@ int main (const int argc, char **args) {
     }
 
     // init workers
-    if (proone_alloc_heartbeat_worker(&worker_pool[worker_pool_size].worker)) {
+    if (prne_alloc_heartbeat_worker(&worker_pool[worker_pool_size].worker)) {
         worker_pool_size += 1;
     }
 
     // TODO
 
     for (i = 0; i < worker_pool_size; i += 1) {
-        proone_init_worker_sched_req(&worker_pool[i].sched_req, NULL);
+        prne_init_worker_sched_req(&worker_pool[i].sched_req, NULL);
     }
 
-    if (worker_pool_size == 0 || pne_global.caught_signal != 0) {
+    if (worker_pool_size == 0 || pne_g.caught_signal != 0) {
         goto END;
     }
 
     proc_fin_call_ptr = proc_fin_call;
 
-    proone_succeed_or_die(clock_gettime(CLOCK_MONOTONIC, &sched_info.last_tick));
+    prne_succeed_or_die(clock_gettime(CLOCK_MONOTONIC, &sched_info.last_tick));
     pollfd_pool.arr = NULL;
     pollfd_pool.size = 0;
     while (true) {
-        proone_worker_sched_flag_t all_sched_flag = PROONE_WORKER_SCHED_FLAG_NONE;
+        prne_worker_sched_flag_t all_sched_flag = PRNE_WORKER_SCHED_FLAG_NONE;
         struct timespec timeout;
         size_t total_pollfd_size = 0;
         bool worked = false;
 
-        proone_succeed_or_die(clock_gettime(CLOCK_MONOTONIC, &sched_info.this_tick));
-        sched_info.tick_diff = proone_sub_timespec(&sched_info.this_tick, &sched_info.last_tick);
-        sched_info.real_tick_diff = proone_real_timespec(&sched_info.tick_diff);
+        prne_succeed_or_die(clock_gettime(CLOCK_MONOTONIC, &sched_info.this_tick));
+        sched_info.tick_diff = prne_sub_timespec(&sched_info.this_tick, &sched_info.last_tick);
+        sched_info.real_tick_diff = prne_real_timespec(&sched_info.tick_diff);
 
         proc_fin_call_ptr();
         
@@ -292,9 +292,9 @@ int main (const int argc, char **args) {
             wt->worker.work(wt->worker.ctx, &sched_info, &wt->sched_req);
             worked |= true;
 
-            if (wt->sched_req.flags & PROONE_WORKER_SCHED_FLAG_TIMEOUT) {
-                if (all_sched_flag & PROONE_WORKER_SCHED_FLAG_TIMEOUT) {
-                    if (proone_cmp_timespec(&timeout, &wt->sched_req.timeout) > 0) {
+            if (wt->sched_req.flags & PRNE_WORKER_SCHED_FLAG_TIMEOUT) {
+                if (all_sched_flag & PRNE_WORKER_SCHED_FLAG_TIMEOUT) {
+                    if (prne_cmp_timespec(&timeout, &wt->sched_req.timeout) > 0) {
                         timeout = wt->sched_req.timeout;
                     }
                 }
@@ -302,7 +302,7 @@ int main (const int argc, char **args) {
                     timeout = wt->sched_req.timeout;
                 }
             }
-            if (wt->sched_req.flags & PROONE_WORKER_SCHED_FLAG_POLL) {
+            if (wt->sched_req.flags & PRNE_WORKER_SCHED_FLAG_POLL) {
                 total_pollfd_size += wt->sched_req.pollfd_arr_size;
             }
 
@@ -317,7 +317,7 @@ int main (const int argc, char **args) {
             }
             break;
         }
-        else if (all_sched_flag & PROONE_WORKER_SCHED_FLAG_POLL) {
+        else if (all_sched_flag & PRNE_WORKER_SCHED_FLAG_POLL) {
             void *ny_mem;
             size_t pollfd_ptr;
 
@@ -337,14 +337,14 @@ int main (const int argc, char **args) {
                         continue;
                     }
                     
-                    if (wt->sched_req.flags & PROONE_WORKER_SCHED_FLAG_POLL) {
+                    if (wt->sched_req.flags & PRNE_WORKER_SCHED_FLAG_POLL) {
                         wt->sched_req.pollfd_ready = false;
                         memcpy(pollfd_pool.arr + pollfd_ptr, wt->sched_req.pollfd_arr, wt->sched_req.pollfd_arr_size * sizeof(struct pollfd));
                         pollfd_ptr += wt->sched_req.pollfd_arr_size;
                     }
                 }
 
-                if (ppoll(pollfd_pool.arr, pollfd_pool.size, all_sched_flag & PROONE_WORKER_SCHED_FLAG_TIMEOUT ? &timeout : NULL, NULL) < 0) {
+                if (ppoll(pollfd_pool.arr, pollfd_pool.size, all_sched_flag & PRNE_WORKER_SCHED_FLAG_TIMEOUT ? &timeout : NULL, NULL) < 0) {
                     switch (errno) {
                     case EINTR:
                     case ENOMEM:
@@ -362,7 +362,7 @@ int main (const int argc, char **args) {
                             continue;
                         }
 
-                        if (wt->sched_req.flags & PROONE_WORKER_SCHED_FLAG_POLL) {
+                        if (wt->sched_req.flags & PRNE_WORKER_SCHED_FLAG_POLL) {
                             wt->sched_req.pollfd_ready = true;
                             memcpy(wt->sched_req.pollfd_arr, pollfd_pool.arr + pollfd_ptr, wt->sched_req.pollfd_arr_size);
                             pollfd_ptr += wt->sched_req.pollfd_arr_size;
@@ -371,7 +371,7 @@ int main (const int argc, char **args) {
                 }
             }
         }
-        else if (all_sched_flag & PROONE_WORKER_SCHED_FLAG_TIMEOUT) {
+        else if (all_sched_flag & PRNE_WORKER_SCHED_FLAG_TIMEOUT) {
             if (nanosleep(&timeout, NULL) < 0 && errno != EINTR) {
                 abort();
             }
@@ -389,24 +389,24 @@ END:
         wt->sched_req.mem_func.free(&wt->sched_req);
     }
 
-    free(pne_global.host_cred_data);
-    pne_global.host_cred_data = NULL;
-    pne_global.host_cred_size = 0;
+    free(pne_g.host_cred_data);
+    pne_g.host_cred_data = NULL;
+    pne_g.host_cred_size = 0;
 
-    if (pne_global.has_proc_lim_lock) {
-        shm_unlink(proone_dvault_unmask_entry_cstr(PROONE_DATA_KEY_PROC_LIM_SHM, NULL));
-        proone_dvault_reset_dict();
-        pne_global.has_proc_lim_lock = false;
+    if (pne_g.has_proc_lim_lock) {
+        shm_unlink(prne_dvault_unmask_entry_cstr(PRNE_DATA_KEY_PROC_LIM_SHM, NULL));
+        prne_dvault_reset_dict();
+        pne_g.has_proc_lim_lock = false;
     }
 
-    proone_free_bin_archive(&pne_global.bin_archive);
-    proone_free_unpack_bin_archive_result(&pne_global.bin_pack);
-    pne_global.bin_ready = false;
+    prne_free_bin_archive(&pne_g.bin_archive);
+    prne_free_unpack_bin_archive_result(&pne_g.bin_pack);
+    pne_g.bin_ready = false;
     
-    proone_free_rnd_engine(pne_global.rnd);
-    pne_global.rnd = NULL;
+    prne_free_rnd_engine(pne_g.rnd);
+    pne_g.rnd = NULL;
 
-    proone_deinit_dvault();
+    prne_deinit_dvault();
 
     return exit_code;
 }
diff --git a/src/proone.h b/src/proone.h
index 49e9d9c..5911acf 100644
--- a/src/proone.h
+++ b/src/proone.h
@@ -1,20 +1,20 @@
-#include "proone_pack.h"
-#include "proone_rnd.h"
+#include "pack.h"
+#include "rnd.h"
 
 #include <stdint.h>
 #include <stdbool.h>
 
 
-struct proone_global {
+struct prne_global {
     uint8_t *host_cred_data;
     size_t host_cred_size;
     bool has_proc_lim_lock;
     bool bin_ready;
     int caught_signal;
-    proone_rnd_engine_t *rnd;
-    proone_unpack_bin_archive_result_t bin_pack;
-    proone_bin_archive_t bin_archive;
+    prne_rnd_engine_t *rnd;
+    prne_unpack_bin_archive_result_t bin_pack;
+    prne_bin_archive_t bin_archive;
 };
 
 
-extern struct proone_global pne_global;
+extern struct prne_global pne_g;
diff --git a/src/proone_data.h b/src/proone_data.h
deleted file mode 100644
index 1248565..0000000
--- a/src/proone_data.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-#include <stdint.h>
-
-
-typedef enum {
-    PROONE_DATA_KEY_NONE = -1,
-    PROONE_DATA_KEY_PROC_LIM_SHM,
-    PROONE_DATA_KEY_SIGN_INIT_OK,
-    NB_PROONE_DATA_KEY
-} proone_data_key_t;
-
-
-extern uint8_t *PROONE_DATA_DICT[NB_PROONE_DATA_KEY];
diff --git a/src/proone_dvault.h b/src/proone_dvault.h
deleted file mode 100644
index 8dedee6..0000000
--- a/src/proone_dvault.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-#include <stddef.h>
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "proone_data.h"
-
-
-typedef struct proone_dvault_mask_result proone_dvault_mask_result_t;
-
-typedef enum {
-    PROONE_DATA_TYPE_NONE = -1,
-    PROONE_DATA_TYPE_CSTR,
-    NB_PROONE_DATA_TYPE
-} proone_data_type_t;
-
-typedef enum {
-    PROONE_DVAULT_MASK_OK,
-    PROONE_DVAULT_MASK_MEM_ERR,
-    PROONE_DVAULT_MASK_TOO_LARGE,
-    PROONE_DVAULT_MASK_INVALID_TYPE
-} proone_dvault_mask_result_code_t;
-
-struct proone_dvault_mask_result {
-    size_t str_len;
-    char *str;
-    proone_dvault_mask_result_code_t result;
-};
-
-
-extern const uint8_t PROONE_DVAULT_MASK[256];
-
-const char *proone_data_type2str (const proone_data_type_t t);
-proone_data_type_t proone_str2data_type (const char *str);
-void proone_dvault_invert_mem (const size_t size, uint8_t *m, const uint8_t salt);
-
-void proone_init_dvault_mask_result (proone_dvault_mask_result_t *r);
-void proone_free_dvault_mask_result (proone_dvault_mask_result_t *r);
-proone_dvault_mask_result_t proone_dvault_mask (const proone_data_type_t type, const uint8_t salt, const size_t data_size, const uint8_t *data);
-
-void proone_init_dvault (void);
-void proone_deinit_dvault (void);
-proone_data_type_t proone_dvault_get_entry_data_type (const proone_data_key_t key);
-size_t proone_dvault_get_entry_size (const proone_data_key_t key);
-uint8_t proone_dvault_get_entry_salt (const proone_data_key_t key);
-char *proone_dvault_unmask_entry_cstr (const proone_data_key_t key, size_t *len);
-void proone_dvault_reset_dict (void);
diff --git a/src/proone_heartbeat-worker.h b/src/proone_heartbeat-worker.h
deleted file mode 100644
index aa4c66c..0000000
--- a/src/proone_heartbeat-worker.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#pragma once
-#include "proone_worker.h"
-
-#include <stddef.h>
-#include <stdbool.h>
-#include <stdint.h>
-
-
-bool proone_alloc_heartbeat_worker (proone_worker_t *w);
diff --git a/src/proone_pack.h b/src/proone_pack.h
deleted file mode 100644
index eaa63a1..0000000
--- a/src/proone_pack.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-#include <stdint.h>
-#include <stdbool.h>
-
-#include "proone_protocol.h"
-
-
-typedef struct proone_bin_archive proone_bin_archive_t;
-typedef struct proone_unpack_bin_archive_result proone_unpack_bin_archive_result_t;
-
-struct proone_bin_archive {
-    size_t data_size;
-    uint8_t *data;
-    size_t nb_binaries;
-    proone_arch_t *arch_arr;
-    size_t *offset_arr;
-    size_t *size_arr;
-};
-
-typedef enum {
-    PROONE_UNPACK_BIN_ARCHIVE_OK,
-    PROONE_UNPACK_BIN_ARCHIVE_OPENSSL_ERR,
-    PROONE_UNPACK_BIN_ARCHIVE_Z_ERR,
-    PROONE_UNPACK_BIN_ARCHIVE_ERRNO,
-    PROONE_UNPACK_BIN_ARCHIVE_MEM_ERR
-} proone_unpack_bin_archive_result_code_t;
-
-struct proone_unpack_bin_archive_result {
-    size_t data_size;
-    uint8_t *data;
-    proone_unpack_bin_archive_result_code_t result;
-    long err;
-};
-
-typedef enum {
-    PROONE_INDEX_BIN_ARCHIVE_OK,
-    PROONE_INDEX_BIN_ARCHIVE_FMT_ERR,
-    PROONE_INDEX_BIN_ARCHIVE_MEM_ERR
-} proone_index_bin_archive_result_code_t;
-
-
-void proone_init_bin_archive (proone_bin_archive_t *a);
-void proone_init_unpack_bin_archive_result (proone_unpack_bin_archive_result_t *r);
-proone_unpack_bin_archive_result_t proone_unpack_bin_archive (const int fd);
-proone_index_bin_archive_result_code_t proone_index_bin_archive (proone_unpack_bin_archive_result_t *in, proone_bin_archive_t *out);
-void proone_free_unpack_bin_archive_result (proone_unpack_bin_archive_result_t *r);
-void proone_free_bin_archive (proone_bin_archive_t *a);
diff --git a/src/proone_protocol.h b/src/proone_protocol.h
deleted file mode 100644
index c8b7f13..0000000
--- a/src/proone_protocol.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-#include <stddef.h>
-
-
-typedef enum {
-    PROONE_ARCH_NONE = -1,
-    
-    PROONE_ARCH_ARMV4T,
-    PROONE_ARCH_ARMV7,
-    PROONE_ARCH_I586,
-    PROONE_ARCH_M68K,
-    PROONE_ARCH_MIPS,
-    PROONE_ARCH_MPSL,
-    PROONE_ARCH_PPC,
-    PROONE_ARCH_RV32,
-    PROONE_ARCH_RV64,
-    PROONE_ARCH_SH4,
-    PROONE_ARCH_SPC,
-
-    NB_PROONE_ARCH
-} proone_arch_t;
-
-
-const char *proone_arch2str (const proone_arch_t x);
-proone_arch_t proone_str2arch (const char *str);
diff --git a/src/proone_rnd.h b/src/proone_rnd.h
deleted file mode 100644
index cf46c4d..0000000
--- a/src/proone_rnd.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-
-
-struct proone_rnd_engine;
-typedef struct proone_rnd_engine proone_rnd_engine_t;
-typedef struct proone_rnd_engnie_alloc_result proone_rnd_engnie_alloc_result_t;
-
-typedef enum {
-	PROONE_RND_ENGINE_ALLOC_OK,
-	PROONE_RND_ENGINE_ALLOC_INVALID_SEED,
-	PROONE_RND_ENGINE_ALLOC_MEM_ERR
-} proone_rnd_engine_alloc_result_code_t;
-
-struct proone_rnd_engnie_alloc_result {
-	proone_rnd_engine_alloc_result_code_t result;
-	proone_rnd_engine_t *engine;
-};
-
-
-void proone_init_alloc_rnd_engine_result (proone_rnd_engnie_alloc_result_t *r);
-proone_rnd_engnie_alloc_result_t proone_alloc_rnd_engine (const uint32_t *seed);
-void proone_free_rnd_engine (proone_rnd_engine_t *engine);
-uint32_t proone_rnd_gen_int (proone_rnd_engine_t *engine);
-double proone_rnd_gen_double (proone_rnd_engine_t *engine);
diff --git a/src/proone_util.h b/src/proone_util.h
deleted file mode 100644
index 605f2a8..0000000
--- a/src/proone_util.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#pragma once
-#include "proone_rnd.h"
-
-#include <stddef.h>
-#include <time.h>
-
-
-#define proone_op_spaceship(a,b) (a==b?0:a<b?-1:1)
-
-
-#if 0
-bool proone_strendsw (const char *str, const char *w) {
-    const size_t len_str = strlen(str);
-    const size_t len_w = strlen(w);
-
-    if (len_str < len_w) {
-        return false;
-    }
-    return strcmp(str + (len_str - len_w), w) == 0;
-}
-#endif
-
-void proone_succeed_or_die (const int ret);
-void proone_empty_func ();
-
-void proone_rnd_alphanumeric_str (proone_rnd_engine_t *rnd_engine, char *str, const size_t len);
-size_t proone_str_shift_spaces (char *str, const size_t len);
-
-struct timespec proone_sub_timespec (const struct timespec *a, const struct timespec *b);
-double proone_real_timespec (const struct timespec *ts);
-int proone_cmp_timespec (const struct timespec *a, const struct timespec *b);
-
-char *proone_enc_base64_mem (const uint8_t *data, const size_t size);
-bool proone_dec_base64_mem (const char *str, const size_t str_len, uint8_t **data, size_t *size);
diff --git a/src/proone_worker.h b/src/proone_worker.h
deleted file mode 100644
index b264fc9..0000000
--- a/src/proone_worker.h
+++ /dev/null
@@ -1,64 +0,0 @@
-#pragma once
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <time.h>
-#include <poll.h>
-
-
-typedef uint8_t proone_worker_sched_flag_t;
-
-typedef struct proone_worker_sched_req proone_worker_sched_req_t;
-typedef bool(*proone_worker_sched_req_alloc_func_t)(proone_worker_sched_req_t *, const size_t);
-typedef void(*proone_worker_sched_req_free_func_t)(proone_worker_sched_req_t *);
-typedef struct proone_worker_sched_req_mem_func proone_worker_sched_req_mem_func_t;
-typedef struct proone_worker_sched_info proone_worker_sched_info_t;
-typedef struct proone_worker proone_worker_t;
-
-struct proone_worker_sched_req_mem_func {
-	proone_worker_sched_req_alloc_func_t alloc;
-	proone_worker_sched_req_free_func_t free;
-	void *ctx;
-};
-
-struct proone_worker_sched_req {
-	size_t pollfd_arr_size;
-	struct pollfd *pollfd_arr;
-	struct timespec timeout;
-	proone_worker_sched_req_mem_func_t mem_func;
-	proone_worker_sched_flag_t flags;
-	bool pollfd_ready;
-};
-
-struct proone_worker_sched_info {
-	proone_worker_sched_flag_t tick_flags;
-	struct timespec last_tick;
-	struct timespec this_tick;
-	struct timespec tick_diff;
-	double real_tick_diff;
-};
-
-struct proone_worker {
-	intptr_t id;
-	void *ctx;
-
-	void (*free)(void *ctx);
-	void (*fin)(void *ctx);
-	void (*work)(void *ctx, const proone_worker_sched_info_t *sched_info, proone_worker_sched_req_t *sched_req);
-	bool (*has_finalised)(void *ctx);
-};
-
-/* Do nothing. The worker has more work to do and is yielding cpu time to the
-* other workers.
-*/
-static const proone_worker_sched_flag_t PROONE_WORKER_SCHED_FLAG_NONE 		= 0x00;
-/* Do `poll()`. The worker has to set `shed_req` properly.
-*/
-static const proone_worker_sched_flag_t PROONE_WORKER_SCHED_FLAG_POLL 		= 0x01;
-/* Do `poll()` with timeout or just sleep. The worker has to set
-* `proone_worker_sched_req_t::timeout` properly.
-*/
-static const proone_worker_sched_flag_t PROONE_WORKER_SCHED_FLAG_TIMEOUT	= 0x02;
-
-
-bool proone_init_worker_sched_req (proone_worker_sched_req_t *wsr, proone_worker_sched_req_mem_func_t *mem_func);
diff --git a/src/proone_protocol.c b/src/protocol.c
index 3721440..93f5f7d 100644
--- a/src/proone_protocol.c
+++ b/src/protocol.c
@@ -1,69 +1,69 @@
-#include "proone_protocol.h"
+#include "protocol.h"
 #include <string.h>
 
-const char *proone_arch2str (const proone_arch_t x) {
+const char *prne_arch2str (const prne_arch_t x) {
     switch (x){
-    case PROONE_ARCH_ARMV4T:
+    case PRNE_ARCH_ARMV4T:
         return "armv4t";
-    case PROONE_ARCH_ARMV7:
+    case PRNE_ARCH_ARMV7:
         return "armv7";
-    case PROONE_ARCH_I586:
+    case PRNE_ARCH_I586:
         return "i586";
-    case PROONE_ARCH_M68K:
+    case PRNE_ARCH_M68K:
         return "m68k";
-    case PROONE_ARCH_MIPS:
+    case PRNE_ARCH_MIPS:
         return "mips";
-    case PROONE_ARCH_MPSL:
+    case PRNE_ARCH_MPSL:
         return "mpsl";
-    case PROONE_ARCH_PPC:
+    case PRNE_ARCH_PPC:
         return "ppc";
-    case PROONE_ARCH_RV32:
+    case PRNE_ARCH_RV32:
         return "rv32";
-    case PROONE_ARCH_RV64:
+    case PRNE_ARCH_RV64:
         return "rv64";
-    case PROONE_ARCH_SH4:
+    case PRNE_ARCH_SH4:
         return "sh4";
-    case PROONE_ARCH_SPC:
+    case PRNE_ARCH_SPC:
         return "spc";
     }
     
     return NULL;
 }
 
-proone_arch_t proone_str2arch (const char *str) {
+prne_arch_t prne_str2arch (const char *str) {
     if (strcmp(str, "armv4t") == 0) {
-        return PROONE_ARCH_ARMV4T;
+        return PRNE_ARCH_ARMV4T;
     }
     else if (strcmp(str, "armv7") == 0) {
-        return PROONE_ARCH_ARMV7;
+        return PRNE_ARCH_ARMV7;
     }
     else if (strcmp(str, "i586") == 0) {
-        return PROONE_ARCH_I586;
+        return PRNE_ARCH_I586;
     }
     else if (strcmp(str, "m68k") == 0) {
-        return PROONE_ARCH_M68K;
+        return PRNE_ARCH_M68K;
     }
     else if (strcmp(str, "mips") == 0) {
-        return PROONE_ARCH_MIPS;
+        return PRNE_ARCH_MIPS;
     }
     else if (strcmp(str, "mpsl") == 0) {
-        return PROONE_ARCH_MPSL;
+        return PRNE_ARCH_MPSL;
     }
     else if (strcmp(str, "ppc") == 0) {
-        return PROONE_ARCH_PPC;
+        return PRNE_ARCH_PPC;
     }
     else if (strcmp(str, "rv32") == 0) {
-        return PROONE_ARCH_RV32;
+        return PRNE_ARCH_RV32;
     }
     else if (strcmp(str, "rv64") == 0) {
-        return PROONE_ARCH_RV64;
+        return PRNE_ARCH_RV64;
     }
     else if (strcmp(str, "sh4") == 0) {
-        return PROONE_ARCH_SH4;
+        return PRNE_ARCH_SH4;
     }
     else if (strcmp(str, "spc") == 0) {
-        return PROONE_ARCH_SPC;
+        return PRNE_ARCH_SPC;
     }
 
-    return PROONE_ARCH_NONE;
+    return PRNE_ARCH_NONE;
 }
diff --git a/src/protocol.h b/src/protocol.h
new file mode 100644
index 0000000..3e57251
--- /dev/null
+++ b/src/protocol.h
@@ -0,0 +1,25 @@
+#pragma once
+#include <stddef.h>
+
+
+typedef enum {
+    PRNE_ARCH_NONE = -1,
+    
+    PRNE_ARCH_ARMV4T,
+    PRNE_ARCH_ARMV7,
+    PRNE_ARCH_I586,
+    PRNE_ARCH_M68K,
+    PRNE_ARCH_MIPS,
+    PRNE_ARCH_MPSL,
+    PRNE_ARCH_PPC,
+    PRNE_ARCH_RV32,
+    PRNE_ARCH_RV64,
+    PRNE_ARCH_SH4,
+    PRNE_ARCH_SPC,
+
+    NB_PRNE_ARCH
+} prne_arch_t;
+
+
+const char *prne_arch2str (const prne_arch_t x);
+prne_arch_t prne_str2arch (const char *str);
diff --git a/src/proone_rnd.c b/src/rnd.c
index 5ec4646..8fff675 100644
--- a/src/proone_rnd.c
+++ b/src/rnd.c
@@ -1,41 +1,41 @@
-#include "proone_rnd.h"
+#include "rnd.h"
 
 #include <stdlib.h>
 
 #define N ((size_t)624)
 
 
-struct proone_rnd_engine {
+struct prne_rnd_engine {
 	size_t mti;
 	uint32_t mt[N];
 };
 
 
-void proone_init_alloc_rnd_engine_result (proone_rnd_engnie_alloc_result_t *r) {
+void prne_init_alloc_rnd_engine_result (prne_rnd_engnie_alloc_result_t *r) {
 	r->engine = NULL;
-	r->result = PROONE_RND_ENGINE_ALLOC_OK;
+	r->result = PRNE_RND_ENGINE_ALLOC_OK;
 }
 
-proone_rnd_engnie_alloc_result_t proone_alloc_rnd_engine (const uint32_t *s) {
-	proone_rnd_engnie_alloc_result_t ret;
+prne_rnd_engnie_alloc_result_t prne_alloc_rnd_engine (const uint32_t *s) {
+	prne_rnd_engnie_alloc_result_t ret;
 	uint32_t seed;
 
-	proone_init_alloc_rnd_engine_result(&ret);
+	prne_init_alloc_rnd_engine_result(&ret);
 	
 	if (s == NULL) {
 		seed = 4357;
 	}
 	else {
 		if (*s == 0) {
-			ret.result = PROONE_RND_ENGINE_ALLOC_INVALID_SEED;
+			ret.result = PRNE_RND_ENGINE_ALLOC_INVALID_SEED;
 			return ret;
 		}
 		seed = *s;
 	}
 	
-	ret.engine = (proone_rnd_engine_t*)malloc(sizeof(proone_rnd_engine_t));
+	ret.engine = (prne_rnd_engine_t*)malloc(sizeof(prne_rnd_engine_t));
 	if (ret.engine == NULL) {
-		ret.result = PROONE_RND_ENGINE_ALLOC_MEM_ERR;
+		ret.result = PRNE_RND_ENGINE_ALLOC_MEM_ERR;
 		return ret;
 	}
 
@@ -47,11 +47,11 @@ proone_rnd_engnie_alloc_result_t proone_alloc_rnd_engine (const uint32_t *s) {
 	return ret;
 }
 
-void proone_free_rnd_engine (proone_rnd_engine_t *engine) {
+void prne_free_rnd_engine (prne_rnd_engine_t *engine) {
 	free(engine);
 }
 
-uint32_t proone_rnd_gen_int (proone_rnd_engine_t *engine) {
+uint32_t prne_rnd_gen_int (prne_rnd_engine_t *engine) {
 	static const size_t M = 397;
 	static const uint32_t
 		UPPER_MASK = 0x80000000,
@@ -88,6 +88,6 @@ uint32_t proone_rnd_gen_int (proone_rnd_engine_t *engine) {
 	return y;
 }
 
-double proone_rnd_gen_double (proone_rnd_engine_t *engine) {
-	return (double)proone_rnd_gen_int(engine) * 2.3283064370807974e-10;
+double prne_rnd_gen_double (prne_rnd_engine_t *engine) {
+	return (double)prne_rnd_gen_int(engine) * 2.3283064370807974e-10;
 }
diff --git a/src/rnd.h b/src/rnd.h
new file mode 100644
index 0000000..170a902
--- /dev/null
+++ b/src/rnd.h
@@ -0,0 +1,27 @@
+#pragma once
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+
+struct prne_rnd_engine;
+typedef struct prne_rnd_engine prne_rnd_engine_t;
+typedef struct prne_rnd_engnie_alloc_result prne_rnd_engnie_alloc_result_t;
+
+typedef enum {
+	PRNE_RND_ENGINE_ALLOC_OK,
+	PRNE_RND_ENGINE_ALLOC_INVALID_SEED,
+	PRNE_RND_ENGINE_ALLOC_MEM_ERR
+} prne_rnd_engine_alloc_result_code_t;
+
+struct prne_rnd_engnie_alloc_result {
+	prne_rnd_engine_alloc_result_code_t result;
+	prne_rnd_engine_t *engine;
+};
+
+
+void prne_init_alloc_rnd_engine_result (prne_rnd_engnie_alloc_result_t *r);
+prne_rnd_engnie_alloc_result_t prne_alloc_rnd_engine (const uint32_t *seed);
+void prne_free_rnd_engine (prne_rnd_engine_t *engine);
+uint32_t prne_rnd_gen_int (prne_rnd_engine_t *engine);
+double prne_rnd_gen_double (prne_rnd_engine_t *engine);
diff --git a/src/proone_util.c b/src/util.c
index 6017e54..37694ab 100644
--- a/src/proone_util.c
+++ b/src/util.c
@@ -1,4 +1,4 @@
-#include "proone_util.h"
+#include "util.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -10,22 +10,22 @@
 #include <openssl/evp.h>
 
 
-void proone_succeed_or_die (const int ret) {
+void prne_succeed_or_die (const int ret) {
 	if (ret < 0) {
 		abort();
 	}
 }
 
-void proone_empty_func () {}
+void prne_empty_func () {}
 
-void proone_rnd_alphanumeric_str (proone_rnd_engine_t *rnd_engine, char *str, const size_t len) {
+void prne_rnd_alphanumeric_str (prne_rnd_engine_t *rnd_engine, char *str, const size_t len) {
 	static const char SET[] = "qwertyuiopasdfghjklzxcvbnm0123456789";
 	size_t i = 0;
 	uint32_t n;
 
 	if (len >= 4) {
 		for (; i < len / 4 * 4; i += 4) {
-			n = proone_rnd_gen_int(rnd_engine);
+			n = prne_rnd_gen_int(rnd_engine);
 			str[i + 0] = SET[((uint8_t*)&n)[0] % sizeof(SET)];
 			str[i + 1] = SET[((uint8_t*)&n)[1] % sizeof(SET)];
 			str[i + 2] = SET[((uint8_t*)&n)[2] % sizeof(SET)];
@@ -33,14 +33,14 @@ void proone_rnd_alphanumeric_str (proone_rnd_engine_t *rnd_engine, char *str, co
 		}
 	}
 	if (i < len) {
-		n = proone_rnd_gen_int(rnd_engine);
+		n = prne_rnd_gen_int(rnd_engine);
 		for (; i < len; i += 1) {
 			str[i] = SET[((uint8_t*)&n)[i % 4] % sizeof(SET)];
 		}
 	}
 }
 
-size_t proone_str_shift_spaces (char *str, const size_t len) {
+size_t prne_str_shift_spaces (char *str, const size_t len) {
 	size_t i, ret = len;
 
 	for (i = 0; i < ret; ) {
@@ -62,7 +62,7 @@ size_t proone_str_shift_spaces (char *str, const size_t len) {
 }
 
 
-struct timespec proone_sub_timespec (const struct timespec *a, const struct timespec *b) {
+struct timespec prne_sub_timespec (const struct timespec *a, const struct timespec *b) {
 	struct timespec ret;
 
 	if (a->tv_nsec < b->tv_nsec) {
@@ -77,11 +77,11 @@ struct timespec proone_sub_timespec (const struct timespec *a, const struct time
 	return ret;
 }
 
-double proone_real_timespec (const struct timespec *ts) {
+double prne_real_timespec (const struct timespec *ts) {
 	return (double)ts->tv_sec + (double)ts->tv_nsec / 1000000000.0;
 }
 
-int proone_cmp_timespec (const struct timespec *a, const struct timespec *b) {
+int prne_cmp_timespec (const struct timespec *a, const struct timespec *b) {
 	if (a->tv_sec < b->tv_sec) {
 		return -1;
 	}
@@ -92,7 +92,7 @@ int proone_cmp_timespec (const struct timespec *a, const struct timespec *b) {
 	return a->tv_nsec < b->tv_nsec ? -1 : a->tv_nsec > b->tv_nsec ? 1 : 0;
 }
 
-char *proone_enc_base64_mem (const uint8_t *data, const size_t size) {
+char *prne_enc_base64_mem (const uint8_t *data, const size_t size) {
 	char *ret = NULL, *p = NULL;
 	BIO *b64_bio = NULL, *mem_bio = NULL;
 	bool ok = true;
@@ -142,7 +142,7 @@ END:
 	return ret;
 }
 
-bool proone_dec_base64_mem (const char *str, const size_t str_len, uint8_t **data, size_t *size) {
+bool prne_dec_base64_mem (const char *str, const size_t str_len, uint8_t **data, size_t *size) {
 	char *in_mem = NULL;
 	size_t in_mem_len, out_len;
 	uint8_t *out_mem = NULL;
@@ -165,7 +165,7 @@ bool proone_dec_base64_mem (const char *str, const size_t str_len, uint8_t **dat
 		goto END;
 	}
 	memcpy(in_mem, str, str_len);
-	in_mem_len = proone_str_shift_spaces(in_mem, str_len);
+	in_mem_len = prne_str_shift_spaces(in_mem, str_len);
 	if (in_mem_len == 0) {
 		ret = true;
 		goto END;
diff --git a/src/util.h b/src/util.h
new file mode 100644
index 0000000..a5e3070
--- /dev/null
+++ b/src/util.h
@@ -0,0 +1,34 @@
+#pragma once
+#include "rnd.h"
+
+#include <stddef.h>
+#include <time.h>
+
+
+#define prne_op_spaceship(a,b) (a==b?0:a<b?-1:1)
+
+
+#if 0
+bool prne_strendsw (const char *str, const char *w) {
+    const size_t len_str = strlen(str);
+    const size_t len_w = strlen(w);
+
+    if (len_str < len_w) {
+        return false;
+    }
+    return strcmp(str + (len_str - len_w), w) == 0;
+}
+#endif
+
+void prne_succeed_or_die (const int ret);
+void prne_empty_func ();
+
+void prne_rnd_alphanumeric_str (prne_rnd_engine_t *rnd_engine, char *str, const size_t len);
+size_t prne_str_shift_spaces (char *str, const size_t len);
+
+struct timespec prne_sub_timespec (const struct timespec *a, const struct timespec *b);
+double prne_real_timespec (const struct timespec *ts);
+int prne_cmp_timespec (const struct timespec *a, const struct timespec *b);
+
+char *prne_enc_base64_mem (const uint8_t *data, const size_t size);
+bool prne_dec_base64_mem (const char *str, const size_t str_len, uint8_t **data, size_t *size);
diff --git a/src/proone_worker.c b/src/worker.c
index 1af8aa1..d99884a 100644
--- a/src/proone_worker.c
+++ b/src/worker.c
@@ -1,15 +1,15 @@
-#include "proone_worker.h"
+#include "worker.h"
 
 #include <stdlib.h>
 
 
-static void def_free_func (proone_worker_sched_req_t *wsr) {
+static void def_free_func (prne_worker_sched_req_t *wsr) {
 	free(wsr->pollfd_arr);
 	wsr->pollfd_arr = NULL;
 	wsr->pollfd_arr_size = 0;
 }
 
-static bool def_alloc_func (proone_worker_sched_req_t *wsr, const size_t ny_size) {
+static bool def_alloc_func (prne_worker_sched_req_t *wsr, const size_t ny_size) {
 	if (ny_size == 0) {
 		def_free_func(wsr);
 	}
@@ -26,18 +26,18 @@ static bool def_alloc_func (proone_worker_sched_req_t *wsr, const size_t ny_size
 	return true;
 }
 
-static proone_worker_sched_req_mem_func_t def_mem_func = { def_alloc_func, def_free_func, NULL };
+static prne_worker_sched_req_mem_func_t def_mem_func = { def_alloc_func, def_free_func, NULL };
 
 
-bool proone_init_worker_sched_req (proone_worker_sched_req_t *wsr, proone_worker_sched_req_mem_func_t *in_mem_func) {
-	proone_worker_sched_req_t ret;
+bool prne_init_worker_sched_req (prne_worker_sched_req_t *wsr, prne_worker_sched_req_mem_func_t *in_mem_func) {
+	prne_worker_sched_req_t ret;
 
 	ret.pollfd_arr_size = 0;
 	ret.pollfd_arr = NULL;
 	ret.timeout.tv_sec = 0;
 	ret.timeout.tv_nsec = 0;
 	ret.mem_func = *(in_mem_func != NULL ? in_mem_func : &def_mem_func);
-	ret.flags = PROONE_WORKER_SCHED_FLAG_NONE;
+	ret.flags = PRNE_WORKER_SCHED_FLAG_NONE;
 	ret.pollfd_ready = false;
 
 	if (!ret.mem_func.alloc(&ret, 0)) {
diff --git a/src/worker.h b/src/worker.h
new file mode 100644
index 0000000..8927fb0
--- /dev/null
+++ b/src/worker.h
@@ -0,0 +1,64 @@
+#pragma once
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <time.h>
+#include <poll.h>
+
+
+typedef uint8_t prne_worker_sched_flag_t;
+
+typedef struct prne_worker_sched_req prne_worker_sched_req_t;
+typedef bool(*prne_worker_sched_req_alloc_func_t)(prne_worker_sched_req_t *, const size_t);
+typedef void(*prne_worker_sched_req_free_func_t)(prne_worker_sched_req_t *);
+typedef struct prne_worker_sched_req_mem_func prne_worker_sched_req_mem_func_t;
+typedef struct prne_worker_sched_info prne_worker_sched_info_t;
+typedef struct prne_worker prne_worker_t;
+
+struct prne_worker_sched_req_mem_func {
+	prne_worker_sched_req_alloc_func_t alloc;
+	prne_worker_sched_req_free_func_t free;
+	void *ctx;
+};
+
+struct prne_worker_sched_req {
+	size_t pollfd_arr_size;
+	struct pollfd *pollfd_arr;
+	struct timespec timeout;
+	prne_worker_sched_req_mem_func_t mem_func;
+	prne_worker_sched_flag_t flags;
+	bool pollfd_ready;
+};
+
+struct prne_worker_sched_info {
+	prne_worker_sched_flag_t tick_flags;
+	struct timespec last_tick;
+	struct timespec this_tick;
+	struct timespec tick_diff;
+	double real_tick_diff;
+};
+
+struct prne_worker {
+	intptr_t id;
+	void *ctx;
+
+	void (*free)(void *ctx);
+	void (*fin)(void *ctx);
+	void (*work)(void *ctx, const prne_worker_sched_info_t *sched_info, prne_worker_sched_req_t *sched_req);
+	bool (*has_finalised)(void *ctx);
+};
+
+/* Do nothing. The worker has more work to do and is yielding cpu time to the
+* other workers.
+*/
+static const prne_worker_sched_flag_t PRNE_WORKER_SCHED_FLAG_NONE 		= 0x00;
+/* Do `poll()`. The worker has to set `shed_req` properly.
+*/
+static const prne_worker_sched_flag_t PRNE_WORKER_SCHED_FLAG_POLL 		= 0x01;
+/* Do `poll()` with timeout or just sleep. The worker has to set
+* `prne_worker_sched_req_t::timeout` properly.
+*/
+static const prne_worker_sched_flag_t PRNE_WORKER_SCHED_FLAG_TIMEOUT	= 0x02;
+
+
+bool prne_init_worker_sched_req (prne_worker_sched_req_t *wsr, prne_worker_sched_req_mem_func_t *mem_func);