diff --git a/0005-Use-the-un-marshalling-functions-scsi_get-set_uint16.patch b/0005-Use-the-un-marshalling-functions-scsi_get-set_uint16.patch
new file mode 100644
index 0000000..274e159
--- /dev/null
+++ b/0005-Use-the-un-marshalling-functions-scsi_get-set_uint16.patch
@@ -0,0 +1,1034 @@
+diff --git a/include/scsi-lowlevel.h b/include/scsi-lowlevel.h
+index 9d25b47..cfb1b03 100644
+--- a/include/scsi-lowlevel.h
++++ b/include/scsi-lowlevel.h
+@@ -833,6 +846,11 @@ EXTERN struct scsi_task *scsi_cdb_report_supported_opcodes(int report_timeouts,
+ 
+ void *scsi_malloc(struct scsi_task *task, size_t size);
+ 
++inline uint32_t scsi_get_uint32(const unsigned char *c);
++inline uint16_t scsi_get_uint16(const unsigned char *c);
++inline void scsi_set_uint32(unsigned char *c, uint32_t val);
++inline void scsi_set_uint16(unsigned char *c, uint16_t val);
++
+ #ifdef __cplusplus
+ }
+ #endif
+diff --git a/lib/login.c b/lib/login.c
+index 5da4d21..8d0c86e 100644
+--- a/lib/login.c
++++ b/lib/login.c
+@@ -30,6 +30,7 @@
+ #include <string.h>
+ #include "iscsi.h"
+ #include "iscsi-private.h"
++#include "scsi-lowlevel.h"
+ #include "md5.h"
+ #ifdef HAVE_LIBGCRYPT
+ #include <gcrypt.h>
+@@ -974,11 +975,11 @@ iscsi_process_login_reply(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
+ 	char *ptr = (char *)in->data;
+ 	int size = in->data_pos;
+ 
+-	status = ntohs(*(uint16_t *)&in->hdr[36]);
++	status = scsi_get_uint16(&in->hdr[36]);
+ 
+-	iscsi->statsn = ntohs(*(uint16_t *)&in->hdr[24]);
++	iscsi->statsn = scsi_get_uint16(&in->hdr[24]);
+ 
+-	maxcmdsn = ntohl(*(uint32_t *)&in->hdr[32]);
++	maxcmdsn = scsi_get_uint32(&in->hdr[32]);
+ 	if (maxcmdsn > iscsi->maxcmdsn) {
+ 		iscsi->maxcmdsn = maxcmdsn;
+ 	}
+@@ -1163,7 +1164,7 @@ struct iscsi_in_pdu *in)
+ {
+ 	uint32_t maxcmdsn;
+ 
+-	maxcmdsn = ntohl(*(uint32_t *)&in->hdr[32]);
++	maxcmdsn = scsi_get_uint32(&in->hdr[32]);
+ 	if (maxcmdsn > iscsi->maxcmdsn) {
+ 		iscsi->maxcmdsn = maxcmdsn;
+ 	}
+diff --git a/lib/pdu.c b/lib/pdu.c
+index f9cbf80..454d780 100644
+--- a/lib/pdu.c
++++ b/lib/pdu.c
+@@ -166,8 +166,8 @@ iscsi_pdu_add_data(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
+ 	}
+ 
+ 	/* update data segment length */
+-	*(uint32_t *)&pdu->outdata.data[4] = htonl(pdu->outdata.size
+-						   - ISCSI_HEADER_SIZE);
++	scsi_set_uint32(&pdu->outdata.data[4], pdu->outdata.size
++					       - ISCSI_HEADER_SIZE);
+ 
+ 	return 0;
+ }
+@@ -177,8 +177,8 @@ iscsi_get_pdu_data_size(const unsigned char *hdr)
+ {
+ 	int size;
+ 
+-	size = (ntohl(*(uint32_t *)&hdr[4])&0x00ffffff);
+-	size = (size+3)&0xfffffffc;
++	size = scsi_get_uint32(&hdr[4]) & 0x00ffffff;
++	size = (size+3) & 0xfffffffc;
+ 
+ 	return size;
+ }
+@@ -236,9 +236,9 @@ int iscsi_process_target_nop_in(struct iscsi_context *iscsi,
+ 	uint32_t ttt;
+ 	uint32_t statsn;
+ 
+-	ttt = ntohl(*(uint32_t *)&in->hdr[20]);
++	ttt = scsi_get_uint32(&in->hdr[20]);
+ 
+-	statsn = ntohl(*(uint32_t *)&in->hdr[24]);
++	statsn = scsi_get_uint32(&in->hdr[24]);
+ 	if (statsn > iscsi->statsn) {
+ 		iscsi->statsn = statsn;
+ 	}
+@@ -268,7 +268,7 @@ int iscsi_process_reject(struct iscsi_context *iscsi,
+ 		return -1;
+ 	}
+ 
+-	itt = ntohl(*(uint32_t *)&in->data[16]);
++	itt = scsi_get_uint32(&in->data[16]);
+ 
+ 	for (pdu = iscsi->waitpdu; pdu; pdu = pdu->next) {
+ 		if (pdu->itt == itt) {
+@@ -302,7 +302,7 @@ iscsi_process_pdu(struct iscsi_context *iscsi, struct iscsi_in_pdu *in)
+ 
+ 	opcode = in->hdr[0] & 0x3f;
+ 	ahslen = in->hdr[4];
+-	itt = ntohl(*(uint32_t *)&in->hdr[16]);
++	itt = scsi_get_uint32(&in->hdr[16]);
+ 
+ 	if (ahslen != 0) {
+ 		iscsi_set_error(iscsi, "cant handle expanded headers yet");
+@@ -449,13 +449,13 @@ iscsi_process_pdu(struct iscsi_context *iscsi, struct iscsi_in_pdu *in)
+ void
+ iscsi_pdu_set_itt(struct iscsi_pdu *pdu, uint32_t itt)
+ {
+-	*(uint32_t *)&pdu->outdata.data[16] = htonl(itt);
++	scsi_set_uint32(&pdu->outdata.data[16], itt);
+ }
+ 
+ void
+ iscsi_pdu_set_ritt(struct iscsi_pdu *pdu, uint32_t ritt)
+ {
+-	*(uint32_t *)&pdu->outdata.data[20] = htonl(ritt);
++	scsi_set_uint32(&pdu->outdata.data[20], ritt);
+ }
+ 
+ void
+@@ -473,43 +473,43 @@ iscsi_pdu_set_immediate(struct iscsi_pdu *pdu)
+ void
+ iscsi_pdu_set_ttt(struct iscsi_pdu *pdu, uint32_t ttt)
+ {
+-	*(uint32_t *)&pdu->outdata.data[20] = htonl(ttt);
++	scsi_set_uint32(&pdu->outdata.data[20], ttt);
+ }
+ 
+ void
+ iscsi_pdu_set_cmdsn(struct iscsi_pdu *pdu, uint32_t cmdsn)
+ {
+-	*(uint32_t *)&pdu->outdata.data[24] = htonl(cmdsn);
++	scsi_set_uint32(&pdu->outdata.data[24], cmdsn);
+ }
+ 
+ void
+ iscsi_pdu_set_rcmdsn(struct iscsi_pdu *pdu, uint32_t rcmdsn)
+ {
+-	*(uint32_t *)&pdu->outdata.data[32] = htonl(rcmdsn);
++	scsi_set_uint32(&pdu->outdata.data[32], rcmdsn);
+ }
+ 
+ void
+ iscsi_pdu_set_datasn(struct iscsi_pdu *pdu, uint32_t datasn)
+ {
+-	*(uint32_t *)&pdu->outdata.data[36] = htonl(datasn);
++	scsi_set_uint32(&pdu->outdata.data[36], datasn);
+ }
+ 
+ void
+ iscsi_pdu_set_expstatsn(struct iscsi_pdu *pdu, uint32_t expstatsnsn)
+ {
+-	*(uint32_t *)&pdu->outdata.data[28] = htonl(expstatsnsn);
++	scsi_set_uint32(&pdu->outdata.data[28], expstatsnsn);
+ }
+ 
+ void
+ iscsi_pdu_set_bufferoffset(struct iscsi_pdu *pdu, uint32_t bufferoffset)
+ {
+-	*(uint32_t *)&pdu->outdata.data[40] = htonl(bufferoffset);
++	scsi_set_uint32(&pdu->outdata.data[40], bufferoffset);
+ }
+ 
+ void
+ iscsi_pdu_set_cdb(struct iscsi_pdu *pdu, struct scsi_task *task)
+ {
+-  memset(&pdu->outdata.data[32], 0, 16);
++	memset(&pdu->outdata.data[32], 0, 16);
+ 	memcpy(&pdu->outdata.data[32], task->cdb, task->cdb_size);
+ }
+ 
+@@ -523,5 +523,5 @@ iscsi_pdu_set_lun(struct iscsi_pdu *pdu, uint32_t lun)
+ void
+ iscsi_pdu_set_expxferlen(struct iscsi_pdu *pdu, uint32_t expxferlen)
+ {
+-	*(uint32_t *)&pdu->outdata.data[20] = htonl(expxferlen);
++	scsi_set_uint32(&pdu->outdata.data[20], expxferlen);
+ }
+diff --git a/lib/scsi-command.c b/lib/scsi-command.c
+index f6d8d0f..7f1e1c0 100644
+--- a/lib/scsi-command.c
++++ b/lib/scsi-command.c
+@@ -328,12 +328,12 @@ iscsi_process_scsi_reply(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
+ 	struct iscsi_scsi_cbdata *scsi_cbdata = pdu->scsi_cbdata;
+ 	struct scsi_task *task = scsi_cbdata->task;
+ 
+-	statsn = ntohl(*(uint32_t *)&in->hdr[24]);
++	statsn = scsi_get_uint32(&in->hdr[24]);
+ 	if (statsn > iscsi->statsn) {
+ 		iscsi->statsn = statsn;
+ 	}
+ 
+-	maxcmdsn = ntohl(*(uint32_t *)&in->hdr[32]);
++	maxcmdsn = scsi_get_uint32(&in->hdr[32]);
+ 	if (maxcmdsn > iscsi->maxcmdsn) {
+ 		iscsi->maxcmdsn = maxcmdsn;
+ 	}
+@@ -368,7 +368,7 @@ iscsi_process_scsi_reply(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
+ 		 * These flags should only be set if the S flag is also set
+ 		 */
+ 		if (flags & (ISCSI_PDU_DATA_RESIDUAL_OVERFLOW|ISCSI_PDU_DATA_RESIDUAL_UNDERFLOW)) {
+-			task->residual = ntohl(*((uint32_t *)&in->hdr[44]));
++			task->residual = scsi_get_uint32(&in->hdr[44]);
+ 			if (flags & ISCSI_PDU_DATA_RESIDUAL_UNDERFLOW) {
+ 				task->residual_status = SCSI_RESIDUAL_UNDERFLOW;
+ 			} else {
+@@ -392,10 +392,20 @@ iscsi_process_scsi_reply(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
+ 		memcpy(task->datain.data, in->data, task->datain.size);
+ 
+ 		task->sense.error_type = task->datain.data[2] & 0x7f;
+-		task->sense.key        = task->datain.data[4] & 0x0f;
+-		task->sense.ascq       = ntohs(*(uint16_t *)
+-					       &(task->datain.data[14]));
+-
++		switch (task->sense.error_type) {
++		case 0x70:
++		case 0x71:
++		  task->sense.key        = task->datain.data[4] & 0x0f;
++		  task->sense.ascq       = scsi_get_uint16(
++						&(task->datain.data[14]));
++		  break;
++		case 0x72:
++		case 0x73:
++		  task->sense.key        = task->datain.data[3] & 0x0f;
++		  task->sense.ascq       = scsi_get_uint16(
++						&(task->datain.data[4]));
++		  break;
++		}
+ 		iscsi_set_error(iscsi, "SENSE KEY:%s(%d) ASCQ:%s(0x%04x)",
+ 				scsi_sense_key_str(task->sense.key),
+ 				task->sense.key,
+@@ -429,12 +439,12 @@ iscsi_process_scsi_data_in(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
+ 	struct scsi_task *task = scsi_cbdata->task;
+ 	int dsl;
+ 
+-	statsn = ntohl(*(uint32_t *)&in->hdr[24]);
++	statsn = scsi_get_uint32(&in->hdr[24]);
+ 	if (statsn > iscsi->statsn) {
+ 		iscsi->statsn = statsn;
+ 	}
+ 
+-	maxcmdsn = ntohl(*(uint32_t *)&in->hdr[32]);
++	maxcmdsn = scsi_get_uint32(&in->hdr[32]);
+ 	if (maxcmdsn > iscsi->maxcmdsn) {
+ 		iscsi->maxcmdsn = maxcmdsn;
+ 	}
+@@ -447,7 +457,7 @@ iscsi_process_scsi_data_in(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
+ 			      pdu->private_data);
+ 		return -1;
+ 	}
+-	dsl = ntohl(*(uint32_t *)&in->hdr[4])&0x00ffffff;
++	dsl = scsi_get_uint32(&in->hdr[4]) & 0x00ffffff;
+ 
+ 	/* Dont add to reassembly buffer if we already have a user buffer */
+ 	if (scsi_task_get_data_in_buffer(task, 0, NULL) == NULL) {
+@@ -479,7 +489,7 @@ iscsi_process_scsi_data_in(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
+ 	 * These flags should only be set if the S flag is also set
+ 	 */
+ 	if (flags & (ISCSI_PDU_DATA_RESIDUAL_OVERFLOW|ISCSI_PDU_DATA_RESIDUAL_UNDERFLOW)) {
+-		task->residual = ntohl(*((uint32_t *)&in->hdr[44]));
++		task->residual = scsi_get_uint32(&in->hdr[44]);
+ 		if (flags & ISCSI_PDU_DATA_RESIDUAL_UNDERFLOW) {
+ 			task->residual_status = SCSI_RESIDUAL_UNDERFLOW;
+ 		} else {
+@@ -509,11 +519,11 @@ iscsi_process_r2t(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
+ {
+ 	uint32_t ttt, offset, len, maxcmdsn;
+ 
+-	ttt    = ntohl(*(uint32_t *)&in->hdr[20]);
+-	offset = ntohl(*(uint32_t *)&in->hdr[40]);
+-	len    = ntohl(*(uint32_t *)&in->hdr[44]);
++	ttt    = scsi_get_uint32(&in->hdr[20]);
++	offset = scsi_get_uint32(&in->hdr[40]);
++	len    = scsi_get_uint32(&in->hdr[44]);
+ 
+-	maxcmdsn = ntohl(*(uint32_t *)&in->hdr[32]);
++	maxcmdsn = scsi_get_uint32(&in->hdr[32]);
+ 	if (maxcmdsn > iscsi->maxcmdsn) {
+ 		iscsi->maxcmdsn = maxcmdsn;
+ 	}
+@@ -1431,12 +1441,12 @@ iscsi_unmap_task(struct iscsi_context *iscsi, int lun, int anchor, int group,
+ 		scsi_free_scsi_task(task);
+ 		return NULL;
+ 	}
+-	*((uint16_t *)&data[0]) = htons(xferlen - 2);
+-	*((uint16_t *)&data[2]) = htons(xferlen - 8);
++	scsi_set_uint16(&data[0], xferlen - 2);
++	scsi_set_uint16(&data[2], xferlen - 8);
+ 	for (i = 0; i < list_len; i++) {
+-		*((uint32_t *)&data[8 + 16 * i])     = htonl(list[0].lba >> 32);
+-		*((uint32_t *)&data[8 + 16 * i + 4]) = htonl(list[0].lba & 0xffffffff);
+-		*((uint32_t *)&data[8 + 16 * i + 8]) = htonl(list[0].num);
++		scsi_set_uint32(&data[8 + 16 * i], list[0].lba >> 32);
++		scsi_set_uint32(&data[8 + 16 * i + 4], list[0].lba & 0xffffffff);
++		scsi_set_uint32(&data[8 + 16 * i + 8], list[0].num);
+ 	}
+ 
+ 	outdata.data = data;
+@@ -1462,9 +1472,9 @@ iscsi_get_user_in_buffer(struct iscsi_context *iscsi, struct iscsi_in_pdu *in, u
+ 		return NULL;
+ 	}
+ 
+-	offset = ntohl(*(uint32_t *)&in->hdr[40]);
++	offset = scsi_get_uint32(&in->hdr[40]);
+ 
+-	itt = ntohl(*(uint32_t *)&in->hdr[16]);
++	itt = scsi_get_uint32(&in->hdr[16]);
+ 	for (pdu = iscsi->waitpdu; pdu; pdu = pdu->next) {
+ 		if (pdu->itt == itt) {
+ 			break;
+diff --git a/lib/scsi-lowlevel.c b/lib/scsi-lowlevel.c
+index 3787072..a67144b 100644
+--- a/lib/scsi-lowlevel.c
++++ b/lib/scsi-lowlevel.c
+@@ -15,8 +15,8 @@
+    along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+ /*
+- * would be nice if this could grow into a full blown library for scsi to
+- * 1, build a CDB
++ * would be nice if this could grow into a full blown library to
++ * 1, build and unmarshall a CDB
+  * 2, check how big a complete data-in structure needs to be
+  * 3, unmarshall data-in into a real structure
+  * 4, marshall a real structure into a data-out blob
+@@ -165,6 +165,91 @@ scsi_sense_ascq_str(int ascq)
+ 	return value_string_find(ascqs, ascq);
+ }
+ 
++inline uint64_t
++scsi_get_uint64(const unsigned char *c)
++{
++	uint64_t val;
++
++	val = scsi_get_uint32(c);
++	val <<= 32;
++	c += 4;
++	val |= scsi_get_uint32(c);
++
++	return val;
++}
++
++inline uint32_t
++scsi_get_uint32(const unsigned char *c)
++{
++	uint32_t val;
++	val = c[0];
++	val = (val << 8) | c[1];
++	val = (val << 8) | c[2];
++	val = (val << 8) | c[3];
++	return val;
++}
++
++inline uint16_t
++scsi_get_uint16(const unsigned char *c)
++{
++	uint16_t val;
++	val = c[0];
++	val = (val << 8) | c[1];
++	return val;
++}
++
++static inline uint64_t
++task_get_uint64(struct scsi_task *task, int offset)
++{
++	if (offset <= task->datain.size - 8) {
++		const unsigned char *c = &task->datain.data[offset];
++
++		return scsi_get_uint64(c);
++	} else {
++		return 0;
++	}
++}
++
++static inline uint32_t
++task_get_uint32(struct scsi_task *task, int offset)
++{
++	if (offset <= task->datain.size - 4) {
++		const unsigned char *c = &task->datain.data[offset];
++
++		return scsi_get_uint32(c);
++	} else {
++		return 0;
++	}
++}
++
++static inline uint16_t
++task_get_uint16(struct scsi_task *task, int offset)
++{
++	if (offset <= task->datain.size - 2) {
++		const unsigned char *c = &task->datain.data[offset];
++
++		return scsi_get_uint16(c);
++	} else {
++		return 0;
++	}
++}
++
++inline void
++scsi_set_uint32(unsigned char *c, uint32_t val)
++{
++	c[0] = val >> 24;
++	c[1] = val >> 16;
++	c[2] = val >> 8;
++	c[3] = val;
++}
++
++inline void
++scsi_set_uint16(unsigned char *c, uint16_t val)
++{
++	c[0] = val >> 8;
++	c[1] = val;
++}
++
+ /*
+  * TESTUNITREADY
+  */
+@@ -205,7 +290,7 @@ scsi_reportluns_cdb(int report_type, int alloc_len)
+ 	memset(task, 0, sizeof(struct scsi_task));
+ 	task->cdb[0]   = SCSI_OPCODE_REPORTLUNS;
+ 	task->cdb[2]   = report_type;
+-	*(uint32_t *)&task->cdb[6] = htonl(alloc_len);
++	scsi_set_uint32(&task->cdb[6], alloc_len);
+ 
+ 	task->cdb_size = 12;
+ 	if (alloc_len != 0) {
+@@ -229,7 +314,7 @@ scsi_reportluns_datain_getfullsize(struct scsi_task *task)
+ {
+ 	uint32_t list_size;
+ 
+-	list_size = htonl(*(uint32_t *)&(task->datain.data[0])) + 8;
++	list_size = task_get_uint32(task, 0) + 8;
+ 
+ 	return list_size;
+ }
+@@ -248,7 +333,7 @@ scsi_reportluns_datain_unmarshall(struct scsi_task *task)
+ 		return NULL;
+ 	}
+ 
+-	list_size = htonl(*(uint32_t *)&(task->datain.data[0])) + 8;
++	list_size = task_get_uint32(task, 0) + 8;
+ 	if (list_size < task->datain.size) {
+ 		return NULL;
+ 	}
+@@ -262,8 +347,7 @@ scsi_reportluns_datain_unmarshall(struct scsi_task *task)
+ 
+ 	list->num = num_luns;
+ 	for (i = 0; i < num_luns; i++) {
+-		list->luns[i] = htons(*(uint16_t *)
+-				      &(task->datain.data[i*8+8]));
++		list->luns[i] = task_get_uint16(task, i * 8 + 8);
+ 	}
+ 
+ 	return list;
+@@ -286,7 +370,7 @@ scsi_cdb_readcapacity10(int lba, int pmi)
+ 	memset(task, 0, sizeof(struct scsi_task));
+ 	task->cdb[0]   = SCSI_OPCODE_READCAPACITY10;
+ 
+-	*(uint32_t *)&task->cdb[2] = htonl(lba);
++	scsi_set_uint32(&task->cdb[2], lba);
+ 
+ 	if (pmi) {
+ 		task->cdb[8] |= 0x01;
+@@ -335,7 +419,7 @@ scsi_cdb_readtoc(int msf, int format, int track_session, uint16_t alloc_len)
+ 		task->cdb[6] = 0xff & track_session;
+ 	}
+ 
+-	*(uint16_t *)&task->cdb[7] = htons(alloc_len);
++	scsi_set_uint16(&task->cdb[7], alloc_len);
+ 
+ 	task->cdb_size = 10;
+ 	if (alloc_len != 0) {
+@@ -361,7 +445,7 @@ scsi_readtoc_datain_getfullsize(struct scsi_task *task)
+ {
+ 	uint16_t toc_data_len;
+ 
+-	toc_data_len = ntohs(*((uint16_t *)&task->datain.data[0])) + 2;
++	toc_data_len = task_get_uint16(task, 0) + 2;
+ 
+ 	return toc_data_len;
+ }
+@@ -377,8 +461,8 @@ scsi_readtoc_desc_unmarshall(struct scsi_task *task, struct scsi_readtoc_list *l
+ 			= task->datain.data[4+8*i+1] & 0x0f;
+ 		list->desc[i].desc.toc.track 
+ 			= task->datain.data[4+8*i+2];
+-		list->desc[i].desc.toc.lba 
+-			= ntohl(*(uint32_t *)&task->datain.data[4+8*i+4]);
++		list->desc[i].desc.toc.lba
++			= task_get_uint32(task, 4 + 8 * i + 4);
+ 		break;
+ 	case SCSI_READ_SESSION_INFO:
+ 		list->desc[i].desc.ses.adr 
+@@ -387,8 +471,8 @@ scsi_readtoc_desc_unmarshall(struct scsi_task *task, struct scsi_readtoc_list *l
+ 			= task->datain.data[4+8*i+1] & 0x0f;
+ 		list->desc[i].desc.ses.first_in_last 
+ 			= task->datain.data[4+8*i+2];
+-		list->desc[i].desc.ses.lba 
+-			= ntohl(*(uint32_t *)&task->datain.data[4+8*i+4]);
++		list->desc[i].desc.ses.lba
++			= task_get_uint32(task, 4 + 8 * i + 4);
+ 		break;
+ 	case SCSI_READ_FULL_TOC:
+ 		list->desc[i].desc.full.session 
+@@ -509,8 +593,6 @@ static void *
+ scsi_serviceactionin_datain_unmarshall(struct scsi_task *task)
+ {
+ 	struct scsi_readcapacity16 *rc16;
+-	struct scsi_get_lba_status *gls;
+-	int32_t len;
+ 	int i;
+ 
+ 	switch (task->params.serviceactionin.sa) {
+@@ -519,28 +601,32 @@ scsi_serviceactionin_datain_unmarshall(struct scsi_task *task)
+ 		if (rc16 == NULL) {
+ 			return NULL;
+ 		}
+-		rc16->returned_lba = ntohl(*(uint32_t *)&(task->datain.data[0]));
+-		rc16->returned_lba = (rc16->returned_lba << 32) | ntohl(*(uint32_t *)&(task->datain.data[4]));
+-		rc16->block_length = ntohl(*(uint32_t *)&(task->datain.data[8]));
++		rc16->returned_lba = task_get_uint32(task, 0);
++		rc16->returned_lba = (rc16->returned_lba << 32) | task_get_uint32(task, 4);
++		rc16->block_length = task_get_uint32(task, 8);
+ 		rc16->p_type       = (task->datain.data[12] >> 1) & 0x07;
+ 		rc16->prot_en      = task->datain.data[12] & 0x01;
+ 		rc16->p_i_exp      = (task->datain.data[13] >> 4) & 0x0f;
+ 		rc16->lbppbe       = task->datain.data[13] & 0x0f;
+ 		rc16->lbpme        = !!(task->datain.data[14] & 0x80);
+ 		rc16->lbprz        = !!(task->datain.data[14] & 0x40);
+-		rc16->lalba        = ntohs(*(uint16_t *)&(task->datain.data[14])) & 0x3fff;
++		rc16->lalba        = task_get_uint16(task, 14) & 0x3fff;
+ 		return rc16;
+-	case SCSI_GET_LBA_STATUS:
+-		len = ntohl(*(uint32_t *)&(task->datain.data[0]));
++	case SCSI_GET_LBA_STATUS: {
++		struct scsi_get_lba_status *gls = scsi_malloc(task,
++							      sizeof(*gls));
++		int32_t len = task_get_uint32(task, 0);
++		int i;
++
++		if (gls == NULL) {
++			return NULL;
++		}
++
+ 		if (len > task->datain.size - 4) {
+ 			len = task->datain.size - 4;
+ 		}
+ 		len = len / 16;
+ 
+-		gls = scsi_malloc(task, sizeof(struct scsi_get_lba_status));
+-		if (gls == NULL) {
+-			return NULL;
+-		}
+ 		gls->num_descriptors = len;
+ 		gls->descriptors = scsi_malloc(task, sizeof(struct scsi_lba_status_descriptor) * gls->num_descriptors);
+ 		if (gls->descriptors == NULL) {
+@@ -548,11 +635,11 @@ scsi_serviceactionin_datain_unmarshall(struct scsi_task *task)
+ 		}
+ 
+ 		for (i = 0; i < (int)gls->num_descriptors; i++) {
+-			gls->descriptors[i].lba  = ntohl(*(uint32_t *)&(task->datain.data[8 + i * sizeof(struct scsi_lba_status_descriptor) + 0]));
++			gls->descriptors[i].lba  = task_get_uint32(task, 8 + i * sizeof(struct scsi_lba_status_descriptor) + 0);
+ 			gls->descriptors[i].lba <<= 32;
+- 			gls->descriptors[i].lba |= ntohl(*(uint32_t *)&(task->datain.data[8 + i * sizeof(struct scsi_lba_status_descriptor) + 4]));
++ 			gls->descriptors[i].lba |= task_get_uint32(task, 8 + i * sizeof(struct scsi_lba_status_descriptor) + 4);
+ 
+-			gls->descriptors[i].num_blocks = ntohl(*(uint32_t *)&(task->datain.data[8 + i * sizeof(struct scsi_lba_status_descriptor) + 8]));
++			gls->descriptors[i].num_blocks = task_get_uint32(task, 8 + i * sizeof(struct scsi_lba_status_descriptor) + 8);
+ 
+ 			gls->descriptors[i].provisioning = task->datain.data[8 + i * sizeof(struct scsi_lba_status_descriptor) + 12] & 0x0f;
+ 		}
+@@ -558,6 +645,7 @@ scsi_serviceactionin_datain_unmarshall(struct scsi_task *task)
+ 
+ 		return gls;
+ 	}
++	}
+ 
+ 	return NULL;
+ }
+@@ -573,8 +660,8 @@ scsi_maintenancein_datain_getfullsize(struct scsi_task *task)
+ {
+ 
+ 	switch (task->params.maintenancein.sa) {
+-	case SCSI_REPORT_SUPPORTED_OP_CODES:	
+-		return ntohl(*(uint32_t *)&(task->datain.data[0])) + 4;
++	case SCSI_REPORT_SUPPORTED_OP_CODES:
++		return task_get_uint32(task, 0) + 4;
+ 	default:
+ 		return -1;
+ 	}
+@@ -599,7 +686,7 @@ scsi_maintenancein_datain_unmarshall(struct scsi_task *task)
+ 			return NULL;
+ 		}
+ 
+-		len = ntohl(*(uint32_t *)&(task->datain.data[0]));
++		len = task_get_uint32(task, 0);
+ 		rsoc = scsi_malloc(task, sizeof(struct scsi_report_supported_op_codes) + len);
+ 		if (rsoc == NULL) {
+ 			return NULL;
+@@ -661,7 +748,7 @@ scsi_cdb_report_supported_opcodes(int return_timeouts, uint32_t alloc_len)
+ 		task->cdb[2] |= 0x80;
+ 	}
+ 
+-	*(uint32_t *)&task->cdb[6] = htonl(alloc_len);
++	scsi_set_uint32(&task->cdb[6], alloc_len);
+ 
+ 	task->cdb_size = 12;
+ 	if (alloc_len != 0) {
+@@ -703,8 +790,8 @@ scsi_readcapacity10_datain_unmarshall(struct scsi_task *task)
+ 		return NULL;
+ 	}
+ 
+-	rc10->lba        = htonl(*(uint32_t *)&(task->datain.data[0]));
+-	rc10->block_size = htonl(*(uint32_t *)&(task->datain.data[4]));
++	rc10->lba        = task_get_uint32(task, 0);
++	rc10->block_size = task_get_uint32(task, 4);
+ 
+ 	return rc10;
+ }
+@@ -735,7 +822,7 @@ scsi_cdb_inquiry(int evpd, int page_code, int alloc_len)
+ 
+ 	task->cdb[2] = page_code;
+ 
+-	*(uint16_t *)&task->cdb[3] = htons(alloc_len);
++	scsi_set_uint16(&task->cdb[3], alloc_len);
+ 
+ 	task->cdb_size = 6;
+ 	if (alloc_len != 0) {
+@@ -770,7 +857,7 @@ scsi_inquiry_datain_getfullsize(struct scsi_task *task)
+ 	case SCSI_INQUIRY_PAGECODE_DEVICE_IDENTIFICATION:
+ 	case SCSI_INQUIRY_PAGECODE_BLOCK_LIMITS:
+ 	case SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING:
+-		return ntohs(*(uint16_t *)&task->datain.data[2]) + 4;
++		return task_get_uint16(task, 2) + 4;
+ 	default:
+ 		return -1;
+ 	}
+@@ -871,7 +958,7 @@ scsi_inquiry_datain_unmarshall(struct scsi_task *task)
+ 	} else if (task->params.inquiry.page_code
+ 		   == SCSI_INQUIRY_PAGECODE_DEVICE_IDENTIFICATION) {
+ 		struct scsi_inquiry_device_identification *inq;
+-		int remaining = ntohs(*(uint16_t *)&task->datain.data[2]);
++		int remaining = task_get_uint16(task, 2);
+ 		unsigned char *dptr;
+ 
+ 		inq = scsi_malloc(task,
+@@ -933,17 +1020,16 @@ scsi_inquiry_datain_unmarshall(struct scsi_task *task)
+ 
+ 		inq->wsnz                  = task->datain.data[4] & 0x01;
+ 		inq->max_cmp               = task->datain.data[5];
+-		inq->opt_gran              = ntohs(*(uint16_t *)&task->datain.data[6]);
+-		inq->max_xfer_len          = ntohl(*(uint32_t *)&task->datain.data[8]);
+-		inq->opt_xfer_len          = ntohl(*(uint32_t *)&task->datain.data[12]);
+-		inq->max_prefetch          = ntohl(*(uint32_t *)&task->datain.data[16]);
+-		inq->max_unmap             = ntohl(*(uint32_t *)&task->datain.data[20]);
+-		inq->max_unmap_bdc         = ntohl(*(uint32_t *)&task->datain.data[24]);
+-		inq->opt_unmap_gran        = ntohl(*(uint32_t *)&task->datain.data[28]);
++		inq->opt_gran              = task_get_uint16(task, 6);
++		inq->max_xfer_len          = task_get_uint32(task, 8);
++		inq->opt_xfer_len          = task_get_uint32(task, 12);
++		inq->max_prefetch          = task_get_uint32(task, 16);
++		inq->max_unmap             = task_get_uint32(task, 20);
++		inq->max_unmap_bdc         = task_get_uint32(task, 24);
++		inq->opt_unmap_gran        = task_get_uint32(task, 28);
+ 		inq->ugavalid              = !!(task->datain.data[32]&0x80);
+-		inq->unmap_gran_align      = ntohl(*(uint32_t *)&task->datain.data[32]) & 0x7fffffff;
+-		inq->max_ws_len            = ntohl(*(uint32_t *)&task->datain.data[36]);
+-		inq->max_ws_len            = (inq->max_ws_len << 32) | ntohl(*(uint32_t *)&task->datain.data[40]);
++		inq->unmap_gran_align      = task_get_uint32(task, 32) & 0x7fffffff;
++		inq->max_ws_len            = task_get_uint64(task, 36);
+ 
+ 		return inq;
+ 	} else if (task->params.inquiry.page_code
+@@ -959,7 +1045,7 @@ scsi_inquiry_datain_unmarshall(struct scsi_task *task)
+ 		inq->device_type           = task->datain.data[0]&0x1f;
+ 		inq->pagecode              = task->datain.data[1];
+ 
+-		inq->medium_rotation_rate  = ntohs(*(uint16_t *)&task->datain.data[4]);
++		inq->medium_rotation_rate  = task_get_uint16(task, 4);
+ 		return inq;
+ 	} else if (task->params.inquiry.page_code
+ 		   == SCSI_INQUIRY_PAGECODE_LOGICAL_BLOCK_PROVISIONING) {
+@@ -1064,8 +1150,8 @@ scsi_cdb_read10(uint32_t lba, uint32_t xferlen, int blocksize, int rdprotect, in
+ 		task->cdb[1] |= 0x02;
+ 	}
+ 
+-	*(uint32_t *)&task->cdb[2] = htonl(lba);
+-	*(uint16_t *)&task->cdb[7] = htons(xferlen/blocksize);
++	scsi_set_uint32(&task->cdb[2], lba);
++	scsi_set_uint16(&task->cdb[7], xferlen/blocksize);
+ 
+ 	task->cdb[6] |= (group_number & 0x1f);
+ 
+@@ -1110,8 +1196,8 @@ scsi_cdb_read12(uint32_t lba, uint32_t xferlen, int blocksize, int rdprotect, in
+ 		task->cdb[1] |= 0x02;
+ 	}
+ 
+-	*(uint32_t *)&task->cdb[2] = htonl(lba);
+-	*(uint32_t *)&task->cdb[6] = htonl(xferlen/blocksize);
++	scsi_set_uint32(&task->cdb[2], lba);
++	scsi_set_uint32(&task->cdb[6], xferlen/blocksize);
+ 
+ 	task->cdb[10] |= (group_number & 0x1f);
+ 
+@@ -1156,9 +1242,9 @@ scsi_cdb_read16(uint64_t lba, uint32_t xferlen, int blocksize, int rdprotect, in
+ 		task->cdb[1] |= 0x02;
+ 	}
+ 
+-	*(uint32_t *)&task->cdb[2] = htonl(lba >> 32);
+-	*(uint32_t *)&task->cdb[6] = htonl(lba & 0xffffffff);
+-	*(uint32_t *)&task->cdb[10] = htonl(xferlen/blocksize);
++	scsi_set_uint32(&task->cdb[2], lba >> 32);
++	scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
++	scsi_set_uint32(&task->cdb[10], xferlen/blocksize);
+ 
+ 	task->cdb[14] |= (group_number & 0x1f);
+ 
+@@ -1203,8 +1289,8 @@ scsi_cdb_write10(uint32_t lba, uint32_t xferlen, int blocksize, int wrprotect, i
+ 		task->cdb[1] |= 0x02;
+ 	}
+ 
+-	*(uint32_t *)&task->cdb[2] = htonl(lba);
+-	*(uint16_t *)&task->cdb[7] = htons(xferlen/blocksize);
++	scsi_set_uint32(&task->cdb[2], lba);
++	scsi_set_uint16(&task->cdb[7], xferlen/blocksize);
+ 
+ 	task->cdb[6] |= (group_number & 0x1f);
+ 
+@@ -1249,8 +1335,8 @@ scsi_cdb_write12(uint32_t lba, uint32_t xferlen, int blocksize, int wrprotect, i
+ 		task->cdb[1] |= 0x02;
+ 	}
+ 
+-	*(uint32_t *)&task->cdb[2] = htonl(lba);
+-	*(uint32_t *)&task->cdb[6] = htonl(xferlen/blocksize);
++	scsi_set_uint32(&task->cdb[2], lba);
++	scsi_set_uint32(&task->cdb[6], xferlen/blocksize);
+ 
+ 	task->cdb[10] |= (group_number & 0x1f);
+ 
+@@ -1295,9 +1381,9 @@ scsi_cdb_write16(uint64_t lba, uint32_t xferlen, int blocksize, int wrprotect, i
+ 		task->cdb[1] |= 0x02;
+ 	}
+ 
+-	*(uint32_t *)&task->cdb[2] = htonl(lba >> 32);
+-	*(uint32_t *)&task->cdb[6] = htonl(lba & 0xffffffff);
+-	*(uint32_t *)&task->cdb[10] = htonl(xferlen/blocksize);
++	scsi_set_uint32(&task->cdb[2], lba >> 32);
++	scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
++	scsi_set_uint32(&task->cdb[10], xferlen/blocksize);
+ 
+ 	task->cdb[14] |= (group_number & 0x1f);
+ 
+@@ -1342,9 +1428,9 @@ scsi_cdb_orwrite(uint64_t lba, uint32_t xferlen, int blocksize, int wrprotect, i
+ 		task->cdb[1] |= 0x02;
+ 	}
+ 
+-	*(uint32_t *)&task->cdb[2] = htonl(lba >> 32);
+-	*(uint32_t *)&task->cdb[6] = htonl(lba & 0xffffffff);
+-	*(uint32_t *)&task->cdb[10] = htonl(xferlen/blocksize);
++	scsi_set_uint32(&task->cdb[2], lba >> 32);
++	scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
++	scsi_set_uint32(&task->cdb[10], xferlen/blocksize);
+ 
+ 	task->cdb[14] |= (group_number & 0x1f);
+ 
+@@ -1389,8 +1475,8 @@ scsi_cdb_compareandwrite(uint64_t lba, uint32_t xferlen, int blocksize, int wrpr
+ 		task->cdb[1] |= 0x02;
+ 	}
+ 
+-	*(uint32_t *)&task->cdb[2] = htonl(lba >> 32);
+-	*(uint32_t *)&task->cdb[6] = htonl(lba & 0xffffffff);
++	scsi_set_uint32(&task->cdb[2], lba >> 32);
++	scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
+ 	task->cdb[13] = xferlen/blocksize;
+ 
+ 	task->cdb[14] |= (group_number & 0x1f);
+@@ -1434,8 +1520,8 @@ scsi_cdb_verify10(uint32_t lba, uint32_t xferlen, int vprotect, int dpo, int byt
+ 		task->cdb[1] |= 0x02;
+ 	}
+ 
+-	*(uint32_t *)&task->cdb[2] = htonl(lba);
+-	*(uint16_t *)&task->cdb[7] = htons(xferlen/blocksize);
++	scsi_set_uint32(&task->cdb[2], lba);
++	scsi_set_uint16(&task->cdb[7], xferlen/blocksize);
+ 
+ 	task->cdb_size = 10;
+ 	if (xferlen != 0) {
+@@ -1480,8 +1566,8 @@ scsi_cdb_verify12(uint32_t lba, uint32_t xferlen, int vprotect, int dpo, int byt
+ 		task->cdb[1] |= 0x02;
+ 	}
+ 
+-	*(uint32_t *)&task->cdb[2] = htonl(lba);
+-	*(uint32_t *)&task->cdb[6] = htonl(xferlen/blocksize);
++	scsi_set_uint32(&task->cdb[2], lba);
++	scsi_set_uint32(&task->cdb[6], xferlen/blocksize);
+ 
+ 	task->cdb_size = 12;
+ 	if (xferlen != 0) {
+@@ -1526,9 +1612,9 @@ scsi_cdb_verify16(uint64_t lba, uint32_t xferlen, int vprotect, int dpo, int byt
+ 		task->cdb[1] |= 0x02;
+ 	}
+ 
+-	*(uint32_t *)&task->cdb[2] = htonl(lba >> 32);
+-	*(uint32_t *)&task->cdb[6] = htonl(lba & 0xffffffff);
+-	*(uint32_t *)&task->cdb[10] = htonl(xferlen/blocksize);
++	scsi_set_uint32(&task->cdb[2], lba >> 32);
++	scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
++	scsi_set_uint32(&task->cdb[10], xferlen/blocksize);
+ 
+ 	task->cdb_size = 16;
+ 	if (xferlen != 0) {
+@@ -1568,7 +1654,7 @@ scsi_cdb_unmap(int anchor, int group, uint16_t xferlen)
+ 	}
+ 	task->cdb[6] |= group & 0x1f;
+ 
+-	*(uint16_t *)&task->cdb[7] = htons(xferlen);
++	scsi_set_uint16(&task->cdb[7], xferlen);
+ 
+ 	task->cdb_size = 10;
+ 	if (xferlen != 0) {
+@@ -1612,11 +1698,11 @@ scsi_cdb_writesame10(int wrprotect, int anchor, int unmap, int pbdata, int lbdat
+ 	if (lbdata) {
+ 		task->cdb[1] |= 0x02;
+ 	}
+-	*(uint32_t *)&task->cdb[2] = htonl(lba);
++	scsi_set_uint32(&task->cdb[2], lba);
+ 	if (group) {
+ 		task->cdb[6] |= (group & 0x1f);
+ 	}
+-	*(uint16_t *)&task->cdb[7] = htons(num_blocks);
++	scsi_set_uint16(&task->cdb[7], num_blocks);
+ 
+ 	task->cdb_size = 10;
+ 	task->xfer_dir = SCSI_XFER_WRITE;
+@@ -1656,9 +1742,9 @@ scsi_cdb_writesame16(int wrprotect, int anchor, int unmap, int pbdata, int lbdat
+ 	if (lbdata) {
+ 		task->cdb[1] |= 0x02;
+ 	}
+-	*(uint32_t *)&task->cdb[2]  = htonl(lba >> 32);
+-	*(uint32_t *)&task->cdb[6]  = htonl(lba & 0xffffffff);
+-	*(uint32_t *)&task->cdb[10] = htonl(num_blocks);
++	scsi_set_uint32(&task->cdb[2], lba >> 32);
++	scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
++	scsi_set_uint32(&task->cdb[10], num_blocks);
+ 	if (group) {
+ 		task->cdb[14] |= (group & 0x1f);
+ 	}
+@@ -1740,10 +1826,10 @@ scsi_parse_mode_caching(struct scsi_task *task, int pos, struct scsi_mode_page *
+ 	mp->caching.demand_read_retention_priority = (task->datain.data[pos+1] >> 4) & 0x0f;
+ 	mp->caching.write_retention_priority       = task->datain.data[pos+1] & 0x0f;
+ 
+-	mp->caching.disable_prefetch_transfer_length = htons(*(uint16_t *)&(task->datain.data[pos+2]));
+-	mp->caching.minimum_prefetch = htons(*(uint16_t *)&(task->datain.data[pos+4]));
+-	mp->caching.maximum_prefetch = htons(*(uint16_t *)&(task->datain.data[pos+6]));
+-	mp->caching.maximum_prefetch_ceiling = htons(*(uint16_t *)&(task->datain.data[pos+8]));
++	mp->caching.disable_prefetch_transfer_length = task_get_uint16(task, pos + 2);
++	mp->caching.minimum_prefetch = task_get_uint16(task, pos + 4);
++	mp->caching.maximum_prefetch = task_get_uint16(task, pos + 6);
++	mp->caching.maximum_prefetch_ceiling = task_get_uint16(task, pos + 8);
+ 
+ 	mp->caching.fsw    = task->datain.data[pos+10] & 0x80;
+ 	mp->caching.lbcss  = task->datain.data[pos+10] & 0x40;
+@@ -1751,7 +1837,7 @@ scsi_parse_mode_caching(struct scsi_task *task, int pos, struct scsi_mode_page *
+ 	mp->caching.nv_dis = task->datain.data[pos+10] & 0x01;
+ 
+ 	mp->caching.number_of_cache_segments = task->datain.data[pos+11];
+-	mp->caching.cache_segment_size = htons(*(uint16_t *)&(task->datain.data[pos+12]));
++	mp->caching.cache_segment_size = task_get_uint16(task, pos + 12);
+ }
+ 
+ static void
+@@ -1759,15 +1845,15 @@ scsi_parse_mode_disconnect_reconnect(struct scsi_task *task, int pos, struct scs
+ {
+ 	mp->disconnect_reconnect.buffer_full_ratio = task->datain.data[pos];
+ 	mp->disconnect_reconnect.buffer_empty_ratio = task->datain.data[pos+1];
+-	mp->disconnect_reconnect.bus_inactivity_limit = htons(*(uint16_t *)&(task->datain.data[pos+2]));
+-	mp->disconnect_reconnect.disconnect_time_limit = htons(*(uint16_t *)&(task->datain.data[pos+4]));
+-	mp->disconnect_reconnect.connect_time_limit = htons(*(uint16_t *)&(task->datain.data[pos+6]));
+-	mp->disconnect_reconnect.maximum_burst_size = htons(*(uint16_t *)&(task->datain.data[pos+8]));
++	mp->disconnect_reconnect.bus_inactivity_limit = task_get_uint16(task, pos + 2);
++	mp->disconnect_reconnect.disconnect_time_limit = task_get_uint16(task, pos + 4);
++	mp->disconnect_reconnect.connect_time_limit = task_get_uint16(task, pos + 6);
++	mp->disconnect_reconnect.maximum_burst_size = task_get_uint16(task, pos + 8);
+ 	mp->disconnect_reconnect.emdp = task->datain.data[pos+10] & 0x80;
+ 	mp->disconnect_reconnect.fair_arbitration = (task->datain.data[pos+10]>>4) & 0x0f;
+ 	mp->disconnect_reconnect.dimm = task->datain.data[pos+10] & 0x08;
+ 	mp->disconnect_reconnect.dtdc = task->datain.data[pos+10] & 0x07;
+-	mp->disconnect_reconnect.first_burst_size = htons(*(uint16_t *)&(task->datain.data[pos+12]));
++	mp->disconnect_reconnect.first_burst_size = task_get_uint16(task, pos + 12);
+ }
+ 
+ static void
+@@ -1781,8 +1867,8 @@ scsi_parse_mode_informational_exceptions_control(struct scsi_task *task, int pos
+ 	mp->iec.ebackerr       = task->datain.data[pos] & 0x02;
+ 	mp->iec.logerr         = task->datain.data[pos] & 0x01;
+ 	mp->iec.mrie           = task->datain.data[pos+1] & 0x0f;
+-	mp->iec.interval_timer = htonl(*(uint32_t *)&(task->datain.data[pos+2]));
+-	mp->iec.report_count   = htonl(*(uint32_t *)&(task->datain.data[pos+6]));
++	mp->iec.interval_timer = task_get_uint32(task, pos + 2);
++	mp->iec.report_count   = task_get_uint32(task, pos + 6);
+ }
+ 
+ 
+@@ -1829,7 +1915,7 @@ scsi_modesense_datain_unmarshall(struct scsi_task *task)
+ 
+ 		if (mp->spf) {
+ 			mp->subpage_code = task->datain.data[pos++];
+-			mp->len = ntohs(*(uint16_t *)&task->datain.data[pos]);
++			mp->len = task_get_uint16(task, pos);
+ 			pos += 2;
+ 		} else {
+ 			mp->subpage_code = 0;
+@@ -1956,8 +2042,8 @@ scsi_cdb_synchronizecache10(int lba, int num_blocks, int syncnv, int immed)
+ 	if (immed) {
+ 		task->cdb[1] |= 0x02;
+ 	}
+-	*(uint32_t *)&task->cdb[2] = htonl(lba);
+-	*(uint16_t *)&task->cdb[7] = htons(num_blocks);
++	scsi_set_uint32(&task->cdb[2], lba);
++	scsi_set_uint16(&task->cdb[7], num_blocks);
+ 
+ 	task->cdb_size   = 10;
+ 	task->xfer_dir   = SCSI_XFER_NONE;
+@@ -1988,9 +2074,9 @@ scsi_cdb_synchronizecache16(uint64_t lba, uint32_t num_blocks, int syncnv, int i
+ 	if (immed) {
+ 		task->cdb[1] |= 0x02;
+ 	}
+-	*(uint32_t *)&task->cdb[2]  = htonl(lba >> 32);
+-	*(uint32_t *)&task->cdb[6]  = htonl(lba & 0xffffffff);
+-	*(uint32_t *)&task->cdb[10] = htonl(num_blocks);
++	scsi_set_uint32(&task->cdb[2], lba >> 32);
++	scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
++	scsi_set_uint32(&task->cdb[10], num_blocks);
+ 
+ 	task->cdb_size   = 16;
+ 	task->xfer_dir   = SCSI_XFER_NONE;
+@@ -2018,9 +2104,9 @@ scsi_cdb_prefetch10(uint32_t lba, int num_blocks, int immed, int group)
+ 	if (immed) {
+ 		task->cdb[1] |= 0x02;
+ 	}
+-	*(uint32_t *)&task->cdb[2] = htonl(lba);
++	scsi_set_uint32(&task->cdb[2], lba);
+ 	task->cdb[6] |= group & 0x1f;
+-	*(uint16_t *)&task->cdb[7] = htons(num_blocks);
++	scsi_set_uint16(&task->cdb[7], num_blocks);
+ 
+ 	task->cdb_size   = 10;
+ 	task->xfer_dir   = SCSI_XFER_NONE;
+@@ -2048,9 +2134,9 @@ scsi_cdb_prefetch16(uint64_t lba, int num_blocks, int immed, int group)
+ 	if (immed) {
+ 		task->cdb[1] |= 0x02;
+ 	}
+-	*(uint32_t *)&task->cdb[2]  = htonl(lba >> 32);
+-	*(uint32_t *)&task->cdb[6]  = htonl(lba & 0xffffffff);
+-	*(uint32_t *)&task->cdb[10] = htonl(num_blocks);
++	scsi_set_uint32(&task->cdb[2], lba >> 32);
++	scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
++	scsi_set_uint32(&task->cdb[10], num_blocks);
+ 
+ 	task->cdb[14] |= group & 0x1f;
+ 
+@@ -2079,7 +2165,7 @@ scsi_cdb_serviceactionin16(enum scsi_service_action_in sa, uint32_t xferlen)
+ 
+ 	task->cdb[1] = sa;
+ 
+-	*(uint32_t *)&task->cdb[10] = htonl(xferlen);
++	scsi_set_uint32(&task->cdb[10], xferlen);
+ 
+ 	task->cdb_size   = 16;
+ 	if (xferlen != 0) {
+@@ -2121,9 +2207,9 @@ scsi_cdb_get_lba_status(uint64_t starting_lba, uint32_t alloc_len)
+ 
+ 	task->cdb[1] = SCSI_GET_LBA_STATUS;
+ 
+-	*(uint32_t *)&task->cdb[2] = htonl(starting_lba >> 32);
+-	*(uint32_t *)&task->cdb[6] = htonl(starting_lba & 0xffffffff);
+-	*(uint32_t *)&task->cdb[10] = htonl(alloc_len);
++	scsi_set_uint32(&task->cdb[2], starting_lba >> 32);
++	scsi_set_uint32(&task->cdb[6], starting_lba & 0xffffffff);
++	scsi_set_uint32(&task->cdb[10], alloc_len);
+ 
+ 	task->cdb_size   = 16;
+ 	if (alloc_len != 0) {
+@@ -2162,8 +2248,8 @@ scsi_cdb_writeverify10(uint32_t lba, uint32_t xferlen, int blocksize, int wrprot
+ 		task->cdb[1] |= 0x02;
+ 	}
+ 
+-	*(uint32_t *)&task->cdb[2] = htonl(lba);
+-	*(uint16_t *)&task->cdb[7] = htons(xferlen/blocksize);
++	scsi_set_uint32(&task->cdb[2], lba);
++	scsi_set_uint16(&task->cdb[7], xferlen/blocksize);
+ 
+ 	task->cdb[6] |= (group_number & 0x1f);
+ 
+@@ -2205,8 +2291,8 @@ scsi_cdb_writeverify12(uint32_t lba, uint32_t xferlen, int blocksize, int wrprot
+ 		task->cdb[1] |= 0x02;
+ 	}
+ 
+-	*(uint32_t *)&task->cdb[2] = htonl(lba);
+-	*(uint32_t *)&task->cdb[6] = htonl(xferlen/blocksize);
++	scsi_set_uint32(&task->cdb[2], lba);
++	scsi_set_uint32(&task->cdb[6], xferlen/blocksize);
+ 
+ 	task->cdb[10] |= (group_number & 0x1f);
+ 
+@@ -2248,9 +2334,9 @@ scsi_cdb_writeverify16(uint64_t lba, uint32_t xferlen, int blocksize, int wrprot
+ 		task->cdb[1] |= 0x02;
+ 	}
+ 
+-	*(uint32_t *)&task->cdb[2] = htonl(lba >> 32);
+-	*(uint32_t *)&task->cdb[6] = htonl(lba & 0xffffffff);
+-	*(uint32_t *)&task->cdb[10] = htonl(xferlen/blocksize);
++	scsi_set_uint32(&task->cdb[2], lba >> 32);
++	scsi_set_uint32(&task->cdb[6], lba & 0xffffffff);
++	scsi_set_uint32(&task->cdb[10], xferlen/blocksize);
+ 
+ 	task->cdb[14] |= (group_number & 0x1f);
+ 
+diff --git a/lib/task_mgmt.c b/lib/task_mgmt.c
+index 286072d..50dc3f1 100644
+--- a/lib/task_mgmt.c
++++ b/lib/task_mgmt.c
+@@ -87,7 +87,7 @@ iscsi_process_task_mgmt_reply(struct iscsi_context *iscsi, struct iscsi_pdu *pdu
+ 
+ 	response = in->hdr[2];
+ 
+-	maxcmdsn = ntohl(*(uint32_t *)&in->hdr[32]);
++	maxcmdsn = scsi_get_uint32(&in->hdr[32]);
+ 	if (maxcmdsn > iscsi->maxcmdsn) {
+ 		iscsi->maxcmdsn = maxcmdsn;
+ 	}
diff --git a/libiscsi.spec b/libiscsi.spec
index 9b81a5f..9808704 100644
--- a/libiscsi.spec
+++ b/libiscsi.spec
@@ -11,6 +11,7 @@ Patch1: 0001-distribute-pkgconfig-file.patch
 Patch2: 0002-use-libgcrypt-for-MD5.patch
 Patch3: 0003-fix-crash-in-iscsi-tools.patch
 Patch4: 0004-install-iscsi-test.patch
+Patch5: 0005-Use-the-un-marshalling-functions-scsi_get-set_uint16.patch
 
 BuildRequires: autoconf
 BuildRequires: automake
@@ -36,6 +37,7 @@ a network.
 %patch2 -p1
 %patch3 -p1
 %patch4 -p1
+%patch5 -p1
 
 %build
 ## always run autogen.sh
@@ -98,6 +100,9 @@ The libiscsi-devel package includes the header files for libiscsi.
 %{_libdir}/pkgconfig/libiscsi.pc
 
 %changelog
+* Mon Jul 1 2013 Paolo Bonzini <pbonzini@redhat.com> - 1.7.0-6
+- Add patch 5 to silence strict aliasing warnings
+
 * Wed Jun 26 2013 Andy Grover <agrover@redhat.com> - 1.7.0-5
 - Add patch 4 to enable installing of iscsi-test binary