diff --git a/osd-target/list-entry.c b/osd-target/list-entry.c
index db26611..613f63e 100644
--- a/osd-target/list-entry.c
+++ b/osd-target/list-entry.c
@@ -36,6 +36,7 @@ int le_pack_attr(void *buf, uint32_t buflen, uint32_t page, uint32_t number,
 		 uint16_t valen, const void *val)
 {
 	uint8_t pad = 0;
+	struct list_entry *list_entry = buf;
 	uint8_t *cp = buf;
 	uint32_t len = buflen;
 
@@ -50,11 +51,12 @@ int le_pack_attr(void *buf, uint32_t buflen, uint32_t page, uint32_t number,
 	if (buflen < LE_MIN_ITEM_LEN)
 		return -EOVERFLOW;
 
-	set_htonl_le(&cp[LE_PAGE_OFF], page);
-	set_htonl_le(&cp[LE_NUMBER_OFF], number);
+	set_htonl(&list_entry->page, page);
+	set_htonl(&list_entry->number, number);
 
 	/* length field is not modified to reflect truncation, sec 5.2.2.2 */
-	set_htons_le(&cp[LE_LEN_OFF], valen);
+	set_htons(&list_entry->len, valen);
+	memset(list_entry->reserved, 0, sizeof(list_entry->reserved));
 
 	if (val != NULL) {
 		buflen -= LE_VAL_OFF;
@@ -70,8 +72,8 @@ int le_pack_attr(void *buf, uint32_t buflen, uint32_t page, uint32_t number,
 	pad = roundup8(len) - len;
 	cp += len; 
 	len += pad;
-	while (pad--)
-		*cp = 0, cp++;
+	if (pad)
+		memset(cp, 0, pad);
 	return len;
 }
 
@@ -93,7 +95,7 @@ int le_multiobj_pack_attr(void *buf, uint32_t buflen, uint64_t oid,
 	if (buflen < MLE_MIN_ITEM_LEN)
 		return -EOVERFLOW;
 
-	set_htonll_le(cp, oid);
+	set_htonll(cp, oid);
 
 	/* 
 	 * test if layout of struct multiobj_list_entry is similar to 
diff --git a/osd-target/osd.c b/osd-target/osd.c
index 2044897..5b2472f 100644
--- a/osd-target/osd.c
+++ b/osd-target/osd.c
@@ -295,13 +295,13 @@ static int get_ccap(struct osd_device *osd, void *outbuf, uint64_t outlen,
 	}
 
 	memset(cp, 0, CCAP_TOTAL_LEN);
-	set_htonl_le(&cp[0], CUR_CMD_ATTR_PG);
-	set_htonl_le(&cp[4], CCAP_TOTAL_LEN - 8);
+	set_htonl(&cp[0], CUR_CMD_ATTR_PG);
+	set_htonl(&cp[4], CCAP_TOTAL_LEN - 8);
 	memcpy(&cp[CCAP_RICV_OFF], osd->ccap.ricv, sizeof(osd->ccap.ricv));
 	cp[CCAP_OBJT_OFF] = osd->ccap.obj_type;
-	set_htonll_le(&cp[CCAP_PID_OFF], osd->ccap.pid);
-	set_htonll_le(&cp[CCAP_OID_OFF], osd->ccap.oid);
-	set_htonll_le(&cp[CCAP_APPADDR_OFF], osd->ccap.append_off);
+	set_htonll(&cp[CCAP_PID_OFF], osd->ccap.pid);
+	set_htonll(&cp[CCAP_OID_OFF], osd->ccap.oid);
+	set_htonll(&cp[CCAP_APPADDR_OFF], osd->ccap.append_off);
 	*used_outlen = CCAP_TOTAL_LEN;
 
 out:
@@ -418,8 +418,8 @@ static int get_utsap(struct osd_device *osd, uint64_t pid, uint64_t oid,
 	}
 
 	memset(cp, 0, UTSAP_TOTAL_LEN);
-	set_htonl_le(&cp[0], USER_TMSTMP_PG);
-	set_htonl_le(&cp[4], UTSAP_TOTAL_LEN - 8);
+	set_htonl(&cp[0], USER_TMSTMP_PG);
+	set_htonl(&cp[4], UTSAP_TOTAL_LEN - 8);
 
 	get_dfile_name(path, osd->root, pid, oid);
 	memset(&dsb, 0, sizeof(dsb));
diff --git a/osd-target/tests/cdb-test.c b/osd-target/tests/cdb-test.c
index 9d657c5..225464b 100644
--- a/osd-target/tests/cdb-test.c
+++ b/osd-target/tests/cdb-test.c
@@ -330,7 +330,7 @@ static void set_one_attr_int(struct osd_device *osd, uint64_t pid, uint64_t oid,
 		.val = &attrval,
 	};
 
-	set_htonll((uint8_t *) &attrval, val);
+	set_htonll(&attrval, val);
 	ret = osd_command_set_set_attributes(&cmd, pid, oid);
 	assert(ret == 0);
 	ret = osd_command_attr_build(&cmd, &attr, 1);
@@ -439,7 +439,7 @@ static void set_attr_int(struct osd_device *osd, uint64_t pid, uint64_t oid,
 		.val = &attrval,
 	};
 
-	set_htonll((uint8_t *) &attrval, val);
+	set_htonll(&attrval, val);
 	ret = osd_command_set_set_attributes(&cmd, pid, oid);
 	assert(ret == 0);
 	ret = osd_command_attr_build(&cmd, &attr, 1);
@@ -557,7 +557,7 @@ void test_query(struct osd_device *osd)
 			.len = 8,
 			.val = &attrval,
 		};
-		set_htonll((uint8_t *) &attrval, cid);
+		set_htonll(&attrval, cid);
 		ret = osd_command_set_create(&cmd, pid, oid + i, 1);
 		assert(ret == 0);
 		if (!(i == 2 || i == 8)) {
@@ -647,8 +647,8 @@ void test_query(struct osd_device *osd)
 	uint64_t min, max;
 	qll = 0;
 	min = 40, max= 80;
-	set_htonll((uint8_t *)&min, min);
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&min, min);
+	set_htonll(&max, max);
 	memset(buf, 0, 1024);
 	cp = buf;
 	cp[0] = 0x0;
@@ -676,8 +676,8 @@ void test_query(struct osd_device *osd)
 
 	/* first query */
 	min = 100, max = 180;
-	set_htonll((uint8_t *)&min, min);
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&min, min);
+	set_htonll(&max, max);
 	memset(buf, 0, 1024);
 	cp = buf;
 	cp[0] = 0x0; /* UNION */
@@ -687,8 +687,8 @@ void test_query(struct osd_device *osd)
 
 	/* second query */
 	min = 200, max = 323;
-	set_htonll((uint8_t *)&min, min);
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&min, min);
+	set_htonll(&max, max);
 	set_qce(cp, page, 1, sizeof(min), &min, sizeof(max), &max);
 	qll += (4+4+4+2+sizeof(min)+2+sizeof(max));
 	cp += (4+4+4+2+sizeof(min)+2+sizeof(max));
@@ -712,8 +712,8 @@ void test_query(struct osd_device *osd)
 
 	/* first query */
 	min = 4, max = 100;
-	set_htonll((uint8_t *)&min, min);
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&min, min);
+	set_htonll(&max, max);
 	memset(buf, 0, 1024);
 	cp = buf;
 	cp[0] = 0x1; /* INTERSECTION */
@@ -723,8 +723,8 @@ void test_query(struct osd_device *osd)
 
 	/* second query */
 	min = 10, max = 400;
-	set_htonll((uint8_t *)&min, min);
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&min, min);
+	set_htonll(&max, max);
 	set_qce(cp, page, 2, sizeof(min), &min, sizeof(max), &max);
 	qll += (4+4+4+2+sizeof(min)+2+sizeof(max));
 	cp += (4+4+4+2+sizeof(min)+2+sizeof(max));
@@ -748,8 +748,8 @@ void test_query(struct osd_device *osd)
 
 	/* first query */
 	min = 130, max = 130;
-	set_htonll((uint8_t *)&min, min);
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&min, min);
+	set_htonll(&max, max);
 	memset(buf, 0, 1024);
 	cp = buf;
 	cp[0] = 0x0; /* UNION */
@@ -759,14 +759,14 @@ void test_query(struct osd_device *osd)
 
 	/* second query */
 	min = 150;
-	set_htonll((uint8_t *)&min, min);
+	set_htonll(&min, min);
 	set_qce(cp, page, 1, sizeof(min), &min, 0, NULL);
 	qll += (4+4+4+2+sizeof(min)+2+0);
 	cp += (4+4+4+2+sizeof(min)+2+0);
 
 	/* third query */
 	max = 10;
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&max, max);
 	set_qce(cp, page, 1, 0, NULL, sizeof(max), &max);
 	qll += (4+4+4+2+0+2+sizeof(max));
 	cp += (4+4+4+2+0+2+sizeof(max));
@@ -808,8 +808,8 @@ void test_query(struct osd_device *osd)
 
 	/* first query */
 	min = 41, max = 169;
-	set_htonll((uint8_t *)&min, min);
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&min, min);
+	set_htonll(&max, max);
 	memset(buf, 0, 1024);
 	cp = buf;
 	cp[0] = 0x0; /* UNION */
@@ -852,7 +852,7 @@ void test_query(struct osd_device *osd)
 
 	/* second query */
 	min = 140;
-	set_htonll((uint8_t *)&min, min);
+	set_htonll(&min, min);
 	set_qce(cp, page, 1, sizeof(min), &min, 0, NULL);
 	qll += (4+4+4+2+sizeof(min)+2+0);
 	cp += (4+4+4+2+sizeof(min)+2+0);
@@ -888,8 +888,8 @@ void test_query(struct osd_device *osd)
 	/* second query */
 	min = 50;
 	max = 80;
-	set_htonll((uint8_t *)&min, min);
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&min, min);
+	set_htonll(&max, max);
 	set_qce(cp, page, 1, sizeof(min), &min, sizeof(max), &max);
 	qll += (4+4+4+2+sizeof(min)+2+sizeof(max));
 	cp += (4+4+4+2+sizeof(min)+2+sizeof(max));
@@ -1293,7 +1293,7 @@ static void test_attr_vals(uint8_t *cp, struct attribute_list *attrs,
 
 			assert(len == attrs[i].len);
 			if (len == 8) {
-				assert(get_ntohll((uint8_t *)attrs[i].val) == 
+				assert(get_ntohll(attrs[i].val) ==
 				       get_ntohll(cp));
 			} else if (len != 0) {
 				assert(memcmp(attrs[i].val, cp, len) == 0);
@@ -1363,7 +1363,7 @@ void test_set_member_attributes(struct osd_device *osd)
 			.len = sizeof(attrval),
 			.val = &attrval,
 		};
-		set_htonll((uint8_t *) &attrval, cid);
+		set_htonll(&attrval, cid);
 		ret = osd_command_set_set_attributes(&cmd, pid, oid + i);
 		assert(ret == 0);
 		ret = osd_command_attr_build(&cmd, &attr, 1);
@@ -1378,9 +1378,9 @@ void test_set_member_attributes(struct osd_device *osd)
 	/* set attr on collection members */
 	uint64_t val1 = 123454321, val2 = 987654, val3 = 59999999;
 	char str1[MAXNAMELEN], str2[MAXNAMELEN], str3[MAXNAMELEN];
-	set_htonll((uint8_t *) &val1, val1);
-	set_htonll((uint8_t *) &val2, val2);
-	set_htonll((uint8_t *) &val3, val3);
+	set_htonll(&val1, val1);
+	set_htonll(&val2, val2);
+	set_htonll(&val3, val3);
 	sprintf(str1, "GoMtI");
 	sprintf(str2, "DeViL");
 	sprintf(str3, "homeopath");
diff --git a/osd-target/tests/db-test.c b/osd-target/tests/db-test.c
index 617d24b..82fee27 100644
--- a/osd-target/tests/db-test.c
+++ b/osd-target/tests/db-test.c
@@ -77,9 +77,9 @@ static void test_attr(struct osd_device *osd)
 #ifndef NDEBUG
 	/* ifdef to avoid unused warning */
 	struct list_entry *ent = (struct list_entry *)val;
-	assert(get_ntohl((uint8_t *)&ent->page) == 2);
-	assert(get_ntohl((uint8_t *)&ent->number) == 12);
-	assert(get_ntohs((uint8_t *)&ent->len) == strlen(attr)+1);
+	assert(get_ntohl(&ent->page) == 2);
+	assert(get_ntohl(&ent->number) == 12);
+	assert(get_ntohs(&ent->len) == strlen(attr)+1);
 	assert(strcmp((char *)ent + LE_VAL_OFF, attr) == 0); 
 #endif
 
@@ -307,16 +307,16 @@ static void test_coll(struct osd_device *osd)
 	assert(usedlen == 4*8);
 	assert(addlen == 4*8);
 	assert(cont_id == 0);
-	assert(get_ntohll((uint8_t *)&oids[0]) == 0x2222);
-	assert(get_ntohll((uint8_t *)&oids[1]) == 0x3333333333333333);
-	assert(get_ntohll((uint8_t *)&oids[2]) == 0x7888888888888888);
-	assert(get_ntohll((uint8_t *)&oids[3]) == 0x7AAAAAAAAAAAAAAA);
+	assert(get_ntohll(&oids[0]) == 0x2222);
+	assert(get_ntohll(&oids[1]) == 0x3333333333333333);
+	assert(get_ntohll(&oids[2]) == 0x7888888888888888);
+	assert(get_ntohll(&oids[3]) == 0x7AAAAAAAAAAAAAAA);
 
 	/* 
 	 * XXX: following is sqlite bug. sqlite converts uint64_t to double
 	 * and looses precision 
 	 */
-	assert(get_ntohll((uint8_t *)&oids[4]) != 0xFFFFFFFFFFFFFFFF); 
+	assert(get_ntohll(&oids[4]) != 0xFFFFFFFFFFFFFFFF); 
 
 	/* test empty cid */
 	ret = coll_isempty_cid(osd->dbc, 0x20, 0x1, &isempty);
@@ -377,8 +377,8 @@ static void test_copy_coll(struct osd_device *osd)
 	assert(usedlen == 2*8);
 	assert(addlen == 2*8);
 	assert(cont_id == 0);
-	assert(get_ntohll((uint8_t *)&oids[0]) == 0x111);
-	assert(get_ntohll((uint8_t *)&oids[1]) == 0x1111111111111111);
+	assert(get_ntohll(&oids[0]) == 0x111);
+	assert(get_ntohll(&oids[1]) == 0x1111111111111111);
 }
 
 int main()
diff --git a/osd-target/tests/osd-test.c b/osd-target/tests/osd-test.c
index ad3f6a2..23122fc 100644
--- a/osd-target/tests/osd-test.c
+++ b/osd-target/tests/osd-test.c
@@ -547,7 +547,7 @@ static void test_osd_get_ccap(struct osd_device *osd)
 
 static inline time_t ntoh_time(void *buf)
 {
-	time_t t = get_ntohll((uint8_t *)buf) & ~0xFFFFULL;
+	time_t t = get_ntohll(buf) & ~0xFFFFULL;
 	return (t >> 16);
 }
 
@@ -645,9 +645,9 @@ static void test_osd_get_attributes(struct osd_device *osd)
 			       RTRVD_SET_ATTR_LIST, &used_len, cdb_cont_len, sense);
 	assert(ret == 0);
 	le = val;
-	assert(get_ntohl((uint8_t *)&le->page) == USEROBJECT_PG + LUN_PG_LB);
-	assert(get_ntohl((uint8_t *)&le->number) == 1);
-	assert(get_ntohs((uint8_t *)&le->len) == strlen("Madhuri Dixit")+1);
+	assert(get_ntohl(&le->page) == USEROBJECT_PG + LUN_PG_LB);
+	assert(get_ntohl(&le->number) == 1);
+	assert(get_ntohs(&le->len) == strlen("Madhuri Dixit")+1);
 	assert(strcmp((char *)le +  LE_VAL_OFF, "Madhuri Dixit") == 0);
 	len = LE_VAL_OFF + strlen("Madhuri Dixit")+1;
 	len += (0x8 - (len & 0x7)) & 0x7;
@@ -665,10 +665,10 @@ static void test_osd_get_attributes(struct osd_device *osd)
 			       TRUE, RTRVD_SET_ATTR_LIST, &used_len, cdb_cont_len, sense);
 	assert(ret == 0);
 	le = getval;
-	assert(get_ntohl((uint8_t *)&le->page) == USER_INFO_PG);
-	assert(get_ntohl((uint8_t *)&le->number) == UIAP_LOGICAL_LEN);
-	assert(get_ntohs((uint8_t *)&le->len) == UIAP_LOGICAL_LEN_LEN);
-	assert(get_ntohll((uint8_t *)le + LE_VAL_OFF) == strlen(val)+1);
+	assert(get_ntohl(&le->page) == USER_INFO_PG);
+	assert(get_ntohl(&le->number) == UIAP_LOGICAL_LEN);
+	assert(get_ntohs(&le->len) == UIAP_LOGICAL_LEN_LEN);
+	assert(get_ntohll(le + LE_VAL_OFF) == strlen(val)+1);
 	len = LE_VAL_OFF + UIAP_LOGICAL_LEN_LEN;
 	len += (0x8 - (len & 0x7)) & 0x7;
 	assert(used_len == len);
@@ -685,10 +685,10 @@ static void test_osd_get_attributes(struct osd_device *osd)
 			       TRUE, RTRVD_SET_ATTR_LIST, &used_len, cdb_cont_len, sense);
 	assert(ret == 0);
 	le = getval;
-	assert(get_ntohl((uint8_t *)&le->page) == USER_INFO_PG);
-	assert(get_ntohl((uint8_t *)&le->number) == UIAP_LOGICAL_LEN);
-	assert(get_ntohs((uint8_t *)&le->len) == UIAP_LOGICAL_LEN_LEN);
-	assert(get_ntohll((uint8_t *)le + LE_VAL_OFF) == 0);
+	assert(get_ntohl(&le->page) == USER_INFO_PG);
+	assert(get_ntohl(&le->number) == UIAP_LOGICAL_LEN);
+	assert(get_ntohs(&le->len) == UIAP_LOGICAL_LEN_LEN);
+	assert(get_ntohll(le + LE_VAL_OFF) == 0);
 	len = LE_VAL_OFF + UIAP_LOGICAL_LEN_LEN;
 	len += (0x8 - (len & 0x7)) & 0x7;
 	assert(used_len == len);
@@ -1016,11 +1016,10 @@ static inline void set_attr_int(struct osd_device *osd, uint64_t oid,
 				uint8_t *sense)
 {
 	int ret = 0;
-	uint8_t *cp = (uint8_t *)&val;
 	uint64_t pid = PARTITION_PID_LB;
 	uint32_t cdb_cont_len = 0;
 
-	set_htonll(cp, val);
+	set_htonll(&val, val);
 	ret = osd_set_attributes(osd, pid, oid, page, number, &val,
 				 sizeof(val), 1, cdb_cont_len, sense);
 	assert(ret == 0);
@@ -1183,8 +1182,8 @@ static void test_osd_query(struct osd_device *osd)
 	/* 3: run one query with criteria */
 	qll = 0;
 	min = 40, max= 80;
-	set_htonll((uint8_t *)&min, min);
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&min, min);
+	set_htonll(&max, max);
 	memset(buf, 0, 1024);
 	cp = buf;
 	cp[0] = 0x0;
@@ -1208,8 +1207,8 @@ static void test_osd_query(struct osd_device *osd)
 	/* first query */
 	page = USEROBJECT_PG+LUN_PG_LB;
 	min = 100, max = 180;
-	set_htonll((uint8_t *)&min, min);
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&min, min);
+	set_htonll(&max, max);
 	memset(buf, 0, 1024);
 	cp = buf;
 	cp[0] = 0x0; /* UNION */
@@ -1219,8 +1218,8 @@ static void test_osd_query(struct osd_device *osd)
 
 	/* second query */
 	min = 200, max = 323;
-	set_htonll((uint8_t *)&min, min);
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&min, min);
+	set_htonll(&max, max);
 	set_qce(cp, page, 1, sizeof(min), &min, sizeof(max), &max);
 	qll += (4+4+4+2+sizeof(min)+2+sizeof(max));
 	cp += (4+4+4+2+sizeof(min)+2+sizeof(max));
@@ -1238,8 +1237,8 @@ static void test_osd_query(struct osd_device *osd)
 	/* first query */
 	page = USEROBJECT_PG+LUN_PG_LB;
 	min = 4, max = 100;
-	set_htonll((uint8_t *)&min, min);
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&min, min);
+	set_htonll(&max, max);
 	memset(buf, 0, 1024);
 	cp = buf;
 	cp[0] = 0x1; /* INTERSECTION */
@@ -1249,8 +1248,8 @@ static void test_osd_query(struct osd_device *osd)
 
 	/* second query */
 	min = 10, max = 400;
-	set_htonll((uint8_t *)&min, min);
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&min, min);
+	set_htonll(&max, max);
 	set_qce(cp, page, 2, sizeof(min), &min, sizeof(max), &max);
 	qll += (4+4+4+2+sizeof(min)+2+sizeof(max));
 	cp += (4+4+4+2+sizeof(min)+2+sizeof(max));
@@ -1268,8 +1267,8 @@ static void test_osd_query(struct osd_device *osd)
 
 	/* first query */
 	min = 130, max = 130;
-	set_htonll((uint8_t *)&min, min);
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&min, min);
+	set_htonll(&max, max);
 	memset(buf, 0, 1024);
 	cp = buf;
 	cp[0] = 0x0; /* UNION */
@@ -1280,14 +1279,14 @@ static void test_osd_query(struct osd_device *osd)
 
 	/* second query */
 	min = 150;
-	set_htonll((uint8_t *)&min, min);
+	set_htonll(&min, min);
 	set_qce(cp, page, 1, sizeof(min), &min, 0, NULL);
 	qll += (4+4+4+2+sizeof(min)+2+0);
 	cp += (4+4+4+2+sizeof(min)+2+0);
 
 	/* third query */
 	max = 10;
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&max, max);
 	set_qce(cp, page, 1, 0, NULL, sizeof(max), &max);
 	qll += (4+4+4+2+0+2+sizeof(max));
 	cp += (4+4+4+2+0+2+sizeof(max));
@@ -1324,8 +1323,8 @@ static void test_osd_query(struct osd_device *osd)
 
 	/* first query */
 	min = 41, max = 169;
-	set_htonll((uint8_t *)&min, min);
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&min, min);
+	set_htonll(&max, max);
 	memset(buf, 0, 1024);
 	cp = buf;
 	cp[0] = 0x0; /* UNION */
@@ -1364,7 +1363,7 @@ static void test_osd_query(struct osd_device *osd)
 
 	/* second query */
 	min = 140;
-	set_htonll((uint8_t *)&min, min);
+	set_htonll(&min, min);
 	set_qce(cp, page, 1, sizeof(min), &min, 0, NULL);
 	qll += (4+4+4+2+sizeof(min)+2+0);
 	cp += (4+4+4+2+sizeof(min)+2+0);
@@ -1395,8 +1394,8 @@ static void test_osd_query(struct osd_device *osd)
 	/* second query */
 	min = 50;
 	max = 80;
-	set_htonll((uint8_t *)&min, min);
-	set_htonll((uint8_t *)&max, max);
+	set_htonll(&min, min);
+	set_htonll(&max, max);
 	set_qce(cp, page, 1, sizeof(min), &min, sizeof(max), &max);
 	qll += (4+4+4+2+sizeof(min)+2+sizeof(max));
 	cp += (4+4+4+2+sizeof(min)+2+sizeof(max));
diff --git a/osd-util/osd-util.c b/osd-util/osd-util.c
index 2f91864..de9187e 100644
--- a/osd-util/osd-util.c
+++ b/osd-util/osd-util.c
@@ -274,10 +274,10 @@ static uint32_t swab32(uint32_t d)
  * Things are not aligned in the current osd2r00, but they probably
  * will be soon.  Assume 4-byte alignment though.
  */
-uint64_t get_ntohll_le(const uint8_t *d)
+uint64_t get_ntohll_le(const void *d)
 {
 	uint32_t d0 = swab32(*(const uint32_t *) d);
-	uint32_t d1 = swab32(*(const uint32_t *) (d+4));
+	uint32_t d1 = swab32(*(const uint32_t *) ((long)d + 4));
 
 	return (uint64_t) d0 << 32 | d1;
 }
@@ -286,22 +286,22 @@ uint64_t get_ntohll_le(const uint8_t *d)
  * Doing these without memcpy for alignment now.  If anyone actually runs
  * on a BE machine, perhaps they'll tell us if alignment is needed.
  */
-uint64_t get_ntohll_be(const uint8_t *d)
+uint64_t get_ntohll_be(const void *d)
 {
 	return *(const uint64_t *) d;
 }
 
-uint32_t get_ntohl_le(const uint8_t *d)
+uint32_t get_ntohl_le(const void *d)
 {
 	return swab32(*(const uint32_t *) d);
 }
 
-uint32_t get_ntohl_be(const uint8_t *d)
+uint32_t get_ntohl_be(const void *d)
 {
 	return *(const uint32_t *) d;
 }
 
-uint16_t get_ntohs_le(const uint8_t *d)
+uint16_t get_ntohs_le(const void *d)
 {
 	uint16_t x = *(const uint16_t *) d;
 
@@ -309,12 +309,12 @@ uint16_t get_ntohs_le(const uint8_t *d)
 		(x & (uint16_t) 0xff00U) >> 8;
 }
 
-uint16_t get_ntohs_be(const uint8_t *d)
+uint16_t get_ntohs_be(const void *d)
 {
 	return *(const uint16_t *) d;
 }
 
-void set_htonll_le(uint8_t *x, uint64_t val)
+void set_htonll_le(void *x, uint64_t val)
 {
 	uint32_t *xw = (uint32_t *) x;
 
@@ -322,24 +322,24 @@ void set_htonll_le(uint8_t *x, uint64_t val)
 	xw[1] = swab32((val & (uint64_t) 0x00000000ffffffffULL));
 }
 
-void set_htonll_be(uint8_t *x, uint64_t val)
+void set_htonll_be(void *x, uint64_t val)
 {
 	*(uint64_t *) x = val;
 }
 
-void set_htonl_le(uint8_t *x, uint32_t val)
+void set_htonl_le(void *x, uint32_t val)
 {
 	uint32_t *xw = (uint32_t *) x;
 
 	*xw = swab32(val);
 }
 
-void set_htonl_be(uint8_t *x, uint32_t val)
+void set_htonl_be(void *x, uint32_t val)
 {
 	*(uint32_t *) x = val;
 }
 
-void set_htons_le(uint8_t *x, uint16_t val)
+void set_htons_le(void *x, uint16_t val)
 {
 	uint16_t *xh = (uint16_t *) x;
 
@@ -347,7 +347,7 @@ void set_htons_le(uint8_t *x, uint16_t val)
 		(val & (uint16_t) 0xff00U) >> 8;
 }
 
-void set_htons_be(uint8_t *x, uint16_t val)
+void set_htons_be(void *x, uint16_t val)
 {
 	*(uint16_t *) x = val;
 }
@@ -360,7 +360,7 @@ void set_htons_be(uint8_t *x, uint16_t val)
  *	int	 exponent : 04;
  * d points to 32bit __be32 osd_offset value
  */
-uint64_t get_ntohoffset(const uint8_t *d)
+uint64_t get_ntohoffset(const void *d)
 {
 	const uint32_t mask = 0xf0000000UL;
 	uint32_t base;
@@ -383,7 +383,7 @@ uint64_t get_ntohoffset(const uint8_t *d)
  * it converts, effectively truncating.  These generally try to use
  * the smallest possible exponent to accommodate the value.
  */
-void set_htonoffset(uint8_t *x, uint64_t val)
+void set_htonoffset(void *x, uint64_t val)
 {
 	const uint64_t max_mantissa = 0x0fffffffULL;
 	uint64_t start = val;
@@ -483,7 +483,7 @@ int main(void)
  * Return time in ms since 1970, given a six-byte big-endian as encoded
  * in OSD.
  */
-uint64_t get_ntohtime_le(const uint8_t *d)
+uint64_t get_ntohtime_le(const void *d)
 {
 	uint8_t s[8];
 
@@ -493,7 +493,7 @@ uint64_t get_ntohtime_le(const uint8_t *d)
 	return get_ntohll_le(s);
 }
 
-uint64_t get_ntohtime_be(const uint8_t *d)
+uint64_t get_ntohtime_be(const void *d)
 {
 	union {
 		uint8_t s[8];
@@ -509,7 +509,7 @@ uint64_t get_ntohtime_be(const uint8_t *d)
 /*
  * Ignore biggest two bytes, encode other six as big endian.
  */
-void set_htontime_le(uint8_t *x, uint64_t val)
+void set_htontime_le(void *x, uint64_t val)
 {
 	uint8_t s[8];
 
@@ -517,7 +517,7 @@ void set_htontime_le(uint8_t *x, uint64_t val)
 	memcpy(x, s+2, 6);
 }
 
-void set_htontime_be(uint8_t *x, uint64_t val)
+void set_htontime_be(void *x, uint64_t val)
 {
 	union {
 		uint8_t s[8];
diff --git a/osd-util/osd-util.h b/osd-util/osd-util.h
index 2fbb5a4..b6f629f 100644
--- a/osd-util/osd-util.h
+++ b/osd-util/osd-util.h
@@ -77,25 +77,25 @@ uint32_t jenkins_one_at_a_time_hash(uint8_t *key, size_t key_len);
 #endif
 
 /* endian covertors */
-uint16_t get_ntohs_le(const uint8_t *d);
-uint16_t get_ntohs_be(const uint8_t *d);
-uint32_t get_ntohl_le(const uint8_t *d);
-uint32_t get_ntohl_be(const uint8_t *d);
-uint64_t get_ntohll_le(const uint8_t *d);
-uint64_t get_ntohll_be(const uint8_t *d);
-uint64_t get_ntohtime_le(const uint8_t *d);
-uint64_t get_ntohtime_be(const uint8_t *d);
-void set_htons_le(uint8_t *x, uint16_t val);
-void set_htons_be(uint8_t *x, uint16_t val);
-void set_htonl_le(uint8_t *x, uint32_t val);
-void set_htonl_be(uint8_t *x, uint32_t val);
-void set_htonll_le(uint8_t *x, uint64_t val);
-void set_htonll_be(uint8_t *x, uint64_t val);
-void set_htontime_le(uint8_t *x, uint64_t val);
-void set_htontime_be(uint8_t *x, uint64_t val);
+uint16_t get_ntohs_le(const void *d);
+uint16_t get_ntohs_be(const void *d);
+uint32_t get_ntohl_le(const void *d);
+uint32_t get_ntohl_be(const void *d);
+uint64_t get_ntohll_le(const void *d);
+uint64_t get_ntohll_be(const void *d);
+uint64_t get_ntohtime_le(const void *d);
+uint64_t get_ntohtime_be(const void *d);
+void set_htons_le(void *x, uint16_t val);
+void set_htons_be(void *x, uint16_t val);
+void set_htonl_le(void *x, uint32_t val);
+void set_htonl_be(void *x, uint32_t val);
+void set_htonll_le(void *x, uint64_t val);
+void set_htonll_be(void *x, uint64_t val);
+void set_htontime_le(void *x, uint64_t val);
+void set_htontime_be(void *x, uint64_t val);
 
-uint64_t get_ntohoffset(const uint8_t *d);
-void set_htonoffset(uint8_t *x, uint64_t val);
+uint64_t get_ntohoffset(const void *d);
+void set_htonoffset(void *x, uint64_t val);
 uint64_t next_offset(uint64_t start);
 
 /* remove netdb.h declarations */