src: Use memcpy() to handle potentially unaligned data

Rolf Eike Beer <eike@sf-mail.de> reported that nft-expr_quota-test fails
with a SIGBUS on SPARC due to unaligned accesses. This patch resolves
that and fixes additional sources of unaligned accesses matching the
same pattern. Both nft-expr_quota-test and nft-expr_objref-test
generated unaligned accesses on DEC Alpha.

Bug: https://bugs.gentoo.org/666448
Signed-off-by: Matt Turner <mattst88@gmail.com>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

35 files changed, 122 insertions, 122 deletions

diff --git a/src/expr/bitwise.c b/src/expr/bitwise.c
index ebfbcd0..79d6a51 100644
--- a/src/expr/bitwise.c
+++ b/src/expr/bitwise.c
@@ -37,13 +37,13 @@ nftnl_expr_bitwise_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_BITWISE_SREG:
-		bitwise->sreg = *((uint32_t *)data);
+		memcpy(&bitwise->sreg, data, sizeof(bitwise->sreg));
 		break;
 	case NFTNL_EXPR_BITWISE_DREG:
-		bitwise->dreg = *((uint32_t *)data);
+		memcpy(&bitwise->dreg, data, sizeof(bitwise->dreg));
 		break;
 	case NFTNL_EXPR_BITWISE_LEN:
-		bitwise->len = *((unsigned int *)data);
+		memcpy(&bitwise->len, data, sizeof(bitwise->len));
 		break;
 	case NFTNL_EXPR_BITWISE_MASK:
 		memcpy(&bitwise->mask.val, data, data_len);
diff --git a/src/expr/byteorder.c b/src/expr/byteorder.c
index 4cddd4a..35c1450 100644
--- a/src/expr/byteorder.c
+++ b/src/expr/byteorder.c
@@ -37,19 +37,19 @@ nftnl_expr_byteorder_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_BYTEORDER_SREG:
-		byteorder->sreg = *((uint32_t *)data);
+		memcpy(&byteorder->sreg, data, sizeof(byteorder->sreg));
 		break;
 	case NFTNL_EXPR_BYTEORDER_DREG:
-		byteorder->dreg = *((uint32_t *)data);
+		memcpy(&byteorder->dreg, data, sizeof(byteorder->dreg));
 		break;
 	case NFTNL_EXPR_BYTEORDER_OP:
-		byteorder->op = *((uint32_t *)data);
+		memcpy(&byteorder->op, data, sizeof(byteorder->op));
 		break;
 	case NFTNL_EXPR_BYTEORDER_LEN:
-		byteorder->len = *((unsigned int *)data);
+		memcpy(&byteorder->len, data, sizeof(byteorder->len));
 		break;
 	case NFTNL_EXPR_BYTEORDER_SIZE:
-		byteorder->size = *((unsigned int *)data);
+		memcpy(&byteorder->size, data, sizeof(byteorder->size));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/cmp.c b/src/expr/cmp.c
index 86708a4..e39a943 100644
--- a/src/expr/cmp.c
+++ b/src/expr/cmp.c
@@ -36,10 +36,10 @@ nftnl_expr_cmp_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_CMP_SREG:
-		cmp->sreg = *((uint32_t *)data);
+		memcpy(&cmp->sreg, data, sizeof(cmp->sreg));
 		break;
 	case NFTNL_EXPR_CMP_OP:
-		cmp->op = *((uint32_t *)data);
+		memcpy(&cmp->op, data, sizeof(cmp->op));
 		break;
 	case NFTNL_EXPR_CMP_DATA:
 		memcpy(&cmp->data.val, data, data_len);
diff --git a/src/expr/connlimit.c b/src/expr/connlimit.c
index 61fd299..9fa0a7b 100644
--- a/src/expr/connlimit.c
+++ b/src/expr/connlimit.c
@@ -33,10 +33,10 @@ nftnl_expr_connlimit_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_CONNLIMIT_COUNT:
-		connlimit->count = *((uint32_t *)data);
+		memcpy(&connlimit->count, data, sizeof(connlimit->count));
 		break;
 	case NFTNL_EXPR_CONNLIMIT_FLAGS:
-		connlimit->flags = *((uint32_t *)data);
+		memcpy(&connlimit->flags, data, sizeof(connlimit->flags));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/counter.c b/src/expr/counter.c
index 2036cb0..a1f6574 100644
--- a/src/expr/counter.c
+++ b/src/expr/counter.c
@@ -35,10 +35,10 @@ nftnl_expr_counter_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_CTR_BYTES:
-		ctr->bytes = *((uint64_t *)data);
+		memcpy(&ctr->bytes, data, sizeof(ctr->bytes));
 		break;
 	case NFTNL_EXPR_CTR_PACKETS:
-		ctr->pkts = *((uint64_t *)data);
+		memcpy(&ctr->pkts, data, sizeof(ctr->pkts));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/ct.c b/src/expr/ct.c
index bb7fe8a..e8a8c6c 100644
--- a/src/expr/ct.c
+++ b/src/expr/ct.c
@@ -39,16 +39,16 @@ nftnl_expr_ct_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_CT_KEY:
-		ct->key = *((uint32_t *)data);
+		memcpy(&ct->key, data, sizeof(ct->key));
 		break;
 	case NFTNL_EXPR_CT_DIR:
-		ct->dir = *((uint8_t *)data);
+		memcpy(&ct->dir, data, sizeof(ct->dir));
 		break;
 	case NFTNL_EXPR_CT_DREG:
-		ct->dreg = *((uint32_t *)data);
+		memcpy(&ct->dreg, data, sizeof(ct->dreg));
 		break;
 	case NFTNL_EXPR_CT_SREG:
-		ct->sreg = *((uint32_t *)data);
+		memcpy(&ct->sreg, data, sizeof(ct->sreg));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/dup.c b/src/expr/dup.c
index 6fa6598..c08ccd2 100644
--- a/src/expr/dup.c
+++ b/src/expr/dup.c
@@ -33,10 +33,10 @@ static int nftnl_expr_dup_set(struct nftnl_expr *e, uint16_t type,
 
 	switch (type) {
 	case NFTNL_EXPR_DUP_SREG_ADDR:
-		dup->sreg_addr = *((uint32_t *)data);
+		memcpy(&dup->sreg_addr, data, sizeof(dup->sreg_addr));
 		break;
 	case NFTNL_EXPR_DUP_SREG_DEV:
-		dup->sreg_dev= *((uint32_t *)data);
+		memcpy(&dup->sreg_dev, data, sizeof(dup->sreg_dev));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/dynset.c b/src/expr/dynset.c
index 3d24ef8..f009ec4 100644
--- a/src/expr/dynset.c
+++ b/src/expr/dynset.c
@@ -40,16 +40,16 @@ nftnl_expr_dynset_set(struct nftnl_expr *e, uint16_t type,
 
 	switch (type) {
 	case NFTNL_EXPR_DYNSET_SREG_KEY:
-		dynset->sreg_key = *((uint32_t *)data);
+		memcpy(&dynset->sreg_key, data, sizeof(dynset->sreg_key));
 		break;
 	case NFTNL_EXPR_DYNSET_SREG_DATA:
-		dynset->sreg_data = *((uint32_t *)data);
+		memcpy(&dynset->sreg_data, data, sizeof(dynset->sreg_data));
 		break;
 	case NFTNL_EXPR_DYNSET_OP:
-		dynset->op = *((uint32_t *)data);
+		memcpy(&dynset->op, data, sizeof(dynset->op));
 		break;
 	case NFTNL_EXPR_DYNSET_TIMEOUT:
-		dynset->timeout = *((uint64_t *)data);
+		memcpy(&dynset->timeout, data, sizeof(dynset->timeout));
 		break;
 	case NFTNL_EXPR_DYNSET_SET_NAME:
 		dynset->set_name = strdup((const char *)data);
@@ -57,7 +57,7 @@ nftnl_expr_dynset_set(struct nftnl_expr *e, uint16_t type,
 			return -1;
 		break;
 	case NFTNL_EXPR_DYNSET_SET_ID:
-		dynset->set_id = *((uint32_t *)data);
+		memcpy(&dynset->set_id, data, sizeof(dynset->set_id));
 		break;
 	case NFTNL_EXPR_DYNSET_EXPR:
 		dynset->expr = (void *)data;
diff --git a/src/expr/exthdr.c b/src/expr/exthdr.c
index ec6a855..0e09814 100644
--- a/src/expr/exthdr.c
+++ b/src/expr/exthdr.c
@@ -46,25 +46,25 @@ nftnl_expr_exthdr_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_EXTHDR_DREG:
-		exthdr->dreg = *((uint32_t *)data);
+		memcpy(&exthdr->dreg, data, sizeof(exthdr->dreg));
 		break;
 	case NFTNL_EXPR_EXTHDR_TYPE:
-		exthdr->type = *((uint8_t *)data);
+		memcpy(&exthdr->type, data, sizeof(exthdr->type));
 		break;
 	case NFTNL_EXPR_EXTHDR_OFFSET:
-		exthdr->offset = *((uint32_t *)data);
+		memcpy(&exthdr->offset, data, sizeof(exthdr->offset));
 		break;
 	case NFTNL_EXPR_EXTHDR_LEN:
-		exthdr->len = *((uint32_t *)data);
+		memcpy(&exthdr->len, data, sizeof(exthdr->len));
 		break;
 	case NFTNL_EXPR_EXTHDR_OP:
-		exthdr->op = *((uint32_t *)data);
+		memcpy(&exthdr->op, data, sizeof(exthdr->op));
 		break;
 	case NFTNL_EXPR_EXTHDR_FLAGS:
-		exthdr->flags = *((uint32_t *)data);
+		memcpy(&exthdr->flags, data, sizeof(exthdr->flags));
 		break;
 	case NFTNL_EXPR_EXTHDR_SREG:
-		exthdr->sreg = *((uint32_t *)data);
+		memcpy(&exthdr->sreg, data, sizeof(exthdr->sreg));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/fib.c b/src/expr/fib.c
index f1eec73..2f2d219 100644
--- a/src/expr/fib.c
+++ b/src/expr/fib.c
@@ -35,13 +35,13 @@ nftnl_expr_fib_set(struct nftnl_expr *e, uint16_t result,
 
 	switch (result) {
 	case NFTNL_EXPR_FIB_RESULT:
-		fib->result = *((uint32_t *)data);
+		memcpy(&fib->result, data, sizeof(fib->result));
 		break;
 	case NFTNL_EXPR_FIB_DREG:
-		fib->dreg = *((uint32_t *)data);
+		memcpy(&fib->dreg, data, sizeof(fib->dreg));
 		break;
 	case NFTNL_EXPR_FIB_FLAGS:
-		fib->flags = *((uint32_t *)data);
+		memcpy(&fib->flags, data, sizeof(fib->flags));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/fwd.c b/src/expr/fwd.c
index 9890e9a..9cb0aca 100644
--- a/src/expr/fwd.c
+++ b/src/expr/fwd.c
@@ -34,13 +34,13 @@ static int nftnl_expr_fwd_set(struct nftnl_expr *e, uint16_t type,
 
 	switch (type) {
 	case NFTNL_EXPR_FWD_SREG_DEV:
-		fwd->sreg_dev = *((uint32_t *)data);
+		memcpy(&fwd->sreg_dev, data, sizeof(fwd->sreg_dev));
 		break;
 	case NFTNL_EXPR_FWD_SREG_ADDR:
-		fwd->sreg_addr = *((uint32_t *)data);
+		memcpy(&fwd->sreg_addr, data, sizeof(fwd->sreg_addr));
 		break;
 	case NFTNL_EXPR_FWD_NFPROTO:
-		fwd->nfproto = *((uint32_t *)data);
+		memcpy(&fwd->nfproto, data, sizeof(fwd->nfproto));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/hash.c b/src/expr/hash.c
index 280ea0c..46b7901 100644
--- a/src/expr/hash.c
+++ b/src/expr/hash.c
@@ -41,25 +41,25 @@ nftnl_expr_hash_set(struct nftnl_expr *e, uint16_t type,
 	struct nftnl_expr_hash *hash = nftnl_expr_data(e);
 	switch (type) {
 	case NFTNL_EXPR_HASH_SREG:
-		hash->sreg = *((uint32_t *)data);
+		memcpy(&hash->sreg, data, sizeof(hash->sreg));
 		break;
 	case NFTNL_EXPR_HASH_DREG:
-		hash->dreg = *((uint32_t *)data);
+		memcpy(&hash->dreg, data, sizeof(hash->dreg));
 		break;
 	case NFTNL_EXPR_HASH_LEN:
-		hash->len = *((uint32_t *)data);
+		memcpy(&hash->len, data, sizeof(hash->len));
 		break;
 	case NFTNL_EXPR_HASH_MODULUS:
-		hash->modulus = *((uint32_t *)data);
+		memcpy(&hash->modulus, data, sizeof(hash->modulus));
 		break;
 	case NFTNL_EXPR_HASH_SEED:
-		hash->seed = *((uint32_t *)data);
+		memcpy(&hash->seed, data, sizeof(hash->seed));
 		break;
 	case NFTNL_EXPR_HASH_OFFSET:
-		hash->offset = *((uint32_t *)data);
+		memcpy(&hash->offset, data, sizeof(hash->offset));
 		break;
 	case NFTNL_EXPR_HASH_TYPE:
-		hash->type = *((uint32_t *)data);
+		memcpy(&hash->type, data, sizeof(hash->type));
 		break;
 	case NFTNL_EXPR_HASH_SET_NAME:
 		hash->map.name = strdup(data);
@@ -67,7 +67,7 @@ nftnl_expr_hash_set(struct nftnl_expr *e, uint16_t type,
 			return -1;
 		break;
 	case NFTNL_EXPR_HASH_SET_ID:
-		hash->map.id = *((uint32_t *)data);
+		memcpy(&hash->map.id, data, sizeof(hash->map.id));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/immediate.c b/src/expr/immediate.c
index 22edbc8..d5a7e86 100644
--- a/src/expr/immediate.c
+++ b/src/expr/immediate.c
@@ -33,14 +33,14 @@ nftnl_expr_immediate_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_IMM_DREG:
-		imm->dreg = *((uint32_t *)data);
+		memcpy(&imm->dreg, data, sizeof(imm->dreg));
 		break;
 	case NFTNL_EXPR_IMM_DATA:
 		memcpy(&imm->data.val, data, data_len);
 		imm->data.len = data_len;
 		break;
 	case NFTNL_EXPR_IMM_VERDICT:
-		imm->data.verdict = *((uint32_t *)data);
+		memcpy(&imm->data.verdict, data, sizeof(imm->data.verdict));
 		break;
 	case NFTNL_EXPR_IMM_CHAIN:
 		if (e->flags & (1 << NFTNL_EXPR_IMM_CHAIN))
diff --git a/src/expr/limit.c b/src/expr/limit.c
index 4831abd..2a0adba 100644
--- a/src/expr/limit.c
+++ b/src/expr/limit.c
@@ -38,19 +38,19 @@ nftnl_expr_limit_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_LIMIT_RATE:
-		limit->rate = *((uint64_t *)data);
+		memcpy(&limit->rate, data, sizeof(limit->rate));
 		break;
 	case NFTNL_EXPR_LIMIT_UNIT:
-		limit->unit = *((uint64_t *)data);
+		memcpy(&limit->unit, data, sizeof(limit->unit));
 		break;
 	case NFTNL_EXPR_LIMIT_BURST:
-		limit->burst = *((uint32_t *)data);
+		memcpy(&limit->burst, data, sizeof(limit->burst));
 		break;
 	case NFTNL_EXPR_LIMIT_TYPE:
-		limit->type = *((uint32_t *)data);
+		memcpy(&limit->type, data, sizeof(limit->type));
 		break;
 	case NFTNL_EXPR_LIMIT_FLAGS:
-		limit->flags = *((uint32_t *)data);
+		memcpy(&limit->flags, data, sizeof(limit->flags));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/log.c b/src/expr/log.c
index e4bf051..1119c53 100644
--- a/src/expr/log.c
+++ b/src/expr/log.c
@@ -46,19 +46,19 @@ static int nftnl_expr_log_set(struct nftnl_expr *e, uint16_t type,
 			return -1;
 		break;
 	case NFTNL_EXPR_LOG_GROUP:
-		log->group = *((uint16_t *)data);
+		memcpy(&log->group, data, sizeof(log->group));
 		break;
 	case NFTNL_EXPR_LOG_SNAPLEN:
-		log->snaplen = *((uint32_t *)data);
+		memcpy(&log->snaplen, data, sizeof(log->snaplen));
 		break;
 	case NFTNL_EXPR_LOG_QTHRESHOLD:
-		log->qthreshold = *((uint16_t *)data);
+		memcpy(&log->qthreshold, data, sizeof(log->qthreshold));
 		break;
 	case NFTNL_EXPR_LOG_LEVEL:
-		log->level = *((uint32_t *)data);
+		memcpy(&log->level, data, sizeof(log->level));
 		break;
 	case NFTNL_EXPR_LOG_FLAGS:
-		log->flags = *((uint32_t *)data);
+		memcpy(&log->flags, data, sizeof(log->flags));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/lookup.c b/src/expr/lookup.c
index 132dc4e..a502e2a 100644
--- a/src/expr/lookup.c
+++ b/src/expr/lookup.c
@@ -37,10 +37,10 @@ nftnl_expr_lookup_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_LOOKUP_SREG:
-		lookup->sreg = *((uint32_t *)data);
+		memcpy(&lookup->sreg, data, sizeof(lookup->sreg));
 		break;
 	case NFTNL_EXPR_LOOKUP_DREG:
-		lookup->dreg = *((uint32_t *)data);
+		memcpy(&lookup->dreg, data, sizeof(lookup->dreg));
 		break;
 	case NFTNL_EXPR_LOOKUP_SET:
 		lookup->set_name = strdup((const char *)data);
@@ -48,10 +48,10 @@ nftnl_expr_lookup_set(struct nftnl_expr *e, uint16_t type,
 			return -1;
 		break;
 	case NFTNL_EXPR_LOOKUP_SET_ID:
-		lookup->set_id = *((uint32_t *)data);
+		memcpy(&lookup->set_id, data, sizeof(lookup->set_id));
 		break;
 	case NFTNL_EXPR_LOOKUP_FLAGS:
-		lookup->flags = *((uint32_t *)data);
+		memcpy(&lookup->flags, data, sizeof(lookup->flags));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/masq.c b/src/expr/masq.c
index 78dd76b..fe017f7 100644
--- a/src/expr/masq.c
+++ b/src/expr/masq.c
@@ -34,13 +34,13 @@ nftnl_expr_masq_set(struct nftnl_expr *e, uint16_t type,
 
 	switch (type) {
 	case NFTNL_EXPR_MASQ_FLAGS:
-		masq->flags = *((uint32_t *)data);
+		memcpy(&masq->flags, data, sizeof(masq->flags));
 		break;
 	case NFTNL_EXPR_MASQ_REG_PROTO_MIN:
-		masq->sreg_proto_min = *((uint32_t *)data);
+		memcpy(&masq->sreg_proto_min, data, sizeof(masq->sreg_proto_min));
 		break;
 	case NFTNL_EXPR_MASQ_REG_PROTO_MAX:
-		masq->sreg_proto_max = *((uint32_t *)data);
+		memcpy(&masq->sreg_proto_max, data, sizeof(masq->sreg_proto_max));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/match.c b/src/expr/match.c
index 85dd79c..2b3321d 100644
--- a/src/expr/match.c
+++ b/src/expr/match.c
@@ -46,7 +46,7 @@ nftnl_expr_match_set(struct nftnl_expr *e, uint16_t type,
 			 (const char *)data);
 		break;
 	case NFTNL_EXPR_MT_REV:
-		mt->rev = *((uint32_t *)data);
+		memcpy(&mt->rev, data, sizeof(mt->rev));
 		break;
 	case NFTNL_EXPR_MT_INFO:
 		if (e->flags & (1 << NFTNL_EXPR_MT_INFO))
diff --git a/src/expr/meta.c b/src/expr/meta.c
index b66b9b7..3654837 100644
--- a/src/expr/meta.c
+++ b/src/expr/meta.c
@@ -39,13 +39,13 @@ nftnl_expr_meta_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_META_KEY:
-		meta->key = *((uint32_t *)data);
+		memcpy(&meta->key, data, sizeof(meta->key));
 		break;
 	case NFTNL_EXPR_META_DREG:
-		meta->dreg = *((uint32_t *)data);
+		memcpy(&meta->dreg, data, sizeof(meta->dreg));
 		break;
 	case NFTNL_EXPR_META_SREG:
-		meta->sreg = *((uint32_t *)data);
+		memcpy(&meta->sreg, data, sizeof(meta->sreg));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/nat.c b/src/expr/nat.c
index 9be78f3..38fccb0 100644
--- a/src/expr/nat.c
+++ b/src/expr/nat.c
@@ -42,25 +42,25 @@ nftnl_expr_nat_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_NAT_TYPE:
-		nat->type = *((uint32_t *)data);
+		memcpy(&nat->type, data, sizeof(nat->type));
 		break;
 	case NFTNL_EXPR_NAT_FAMILY:
-		nat->family = *((uint32_t *)data);
+		memcpy(&nat->family, data, sizeof(nat->family));
 		break;
 	case NFTNL_EXPR_NAT_REG_ADDR_MIN:
-		nat->sreg_addr_min = *((uint32_t *)data);
+		memcpy(&nat->sreg_addr_min, data, sizeof(nat->sreg_addr_min));
 		break;
 	case NFTNL_EXPR_NAT_REG_ADDR_MAX:
-		nat->sreg_addr_max = *((uint32_t *)data);
+		memcpy(&nat->sreg_addr_max, data, sizeof(nat->sreg_addr_max));
 		break;
 	case NFTNL_EXPR_NAT_REG_PROTO_MIN:
-		nat->sreg_proto_min = *((uint32_t *)data);
+		memcpy(&nat->sreg_proto_min, data, sizeof(nat->sreg_proto_min));
 		break;
 	case NFTNL_EXPR_NAT_REG_PROTO_MAX:
-		nat->sreg_proto_max = *((uint32_t *)data);
+		memcpy(&nat->sreg_proto_max, data, sizeof(nat->sreg_proto_max));
 		break;
 	case NFTNL_EXPR_NAT_FLAGS:
-		nat->flags = *((uint32_t *)data);
+		memcpy(&nat->flags, data, sizeof(nat->flags));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/numgen.c b/src/expr/numgen.c
index d46cf94..f940081 100644
--- a/src/expr/numgen.c
+++ b/src/expr/numgen.c
@@ -39,16 +39,16 @@ nftnl_expr_ng_set(struct nftnl_expr *e, uint16_t type,
 
 	switch (type) {
 	case NFTNL_EXPR_NG_DREG:
-		ng->dreg = *((uint32_t *)data);
+		memcpy(&ng->dreg, data, sizeof(ng->dreg));
 		break;
 	case NFTNL_EXPR_NG_MODULUS:
-		ng->modulus = *((uint32_t *)data);
+		memcpy(&ng->modulus, data, sizeof(ng->modulus));
 		break;
 	case NFTNL_EXPR_NG_TYPE:
-		ng->type = *((uint32_t *)data);
+		memcpy(&ng->type, data, sizeof(ng->type));
 		break;
 	case NFTNL_EXPR_NG_OFFSET:
-		ng->offset = *((uint32_t *)data);
+		memcpy(&ng->offset, data, sizeof(ng->offset));
 		break;
 	case NFTNL_EXPR_NG_SET_NAME:
 		ng->map.name = strdup(data);
@@ -56,7 +56,7 @@ nftnl_expr_ng_set(struct nftnl_expr *e, uint16_t type,
 			return -1;
 		break;
 	case NFTNL_EXPR_NG_SET_ID:
-		ng->map.id = *((uint32_t *)data);
+		memcpy(&ng->map.id, data, sizeof(ng->map.id));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/objref.c b/src/expr/objref.c
index 67fd74b..3b815f5 100644
--- a/src/expr/objref.c
+++ b/src/expr/objref.c
@@ -39,7 +39,7 @@ static int nftnl_expr_objref_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_OBJREF_IMM_TYPE:
-		objref->imm.type = *((uint32_t *)data);
+		memcpy(&objref->imm.type, data, sizeof(objref->imm.type));
 		break;
 	case NFTNL_EXPR_OBJREF_IMM_NAME:
 		objref->imm.name = strdup(data);
@@ -47,7 +47,7 @@ static int nftnl_expr_objref_set(struct nftnl_expr *e, uint16_t type,
 			return -1;
 		break;
 	case NFTNL_EXPR_OBJREF_SET_SREG:
-		objref->set.sreg = *((uint32_t *)data);
+		memcpy(&objref->set.sreg, data, sizeof(objref->set.sreg));
 		break;
 	case NFTNL_EXPR_OBJREF_SET_NAME:
 		objref->set.name = strdup(data);
@@ -55,7 +55,7 @@ static int nftnl_expr_objref_set(struct nftnl_expr *e, uint16_t type,
 			return -1;
 		break;
 	case NFTNL_EXPR_OBJREF_SET_ID:
-		objref->set.id = *((uint32_t *)data);
+		memcpy(&objref->set.id, data, sizeof(objref->set.id));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/osf.c b/src/expr/osf.c
index a90620d..0860328 100644
--- a/src/expr/osf.c
+++ b/src/expr/osf.c
@@ -24,10 +24,10 @@ static int nftnl_expr_osf_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_OSF_DREG:
-		osf->dreg = *((uint32_t *)data);
+		memcpy(&osf->dreg, data, sizeof(osf->dreg));
 		break;
 	case NFTNL_EXPR_OSF_TTL:
-		osf->ttl = *((uint8_t *)data);
+		memcpy(&osf->ttl, data, sizeof(osf->ttl));
 		break;
 	}
 	return 0;
diff --git a/src/expr/payload.c b/src/expr/payload.c
index 4b2f322..680da4a 100644
--- a/src/expr/payload.c
+++ b/src/expr/payload.c
@@ -43,28 +43,28 @@ nftnl_expr_payload_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_PAYLOAD_SREG:
-		payload->sreg = *((uint32_t *)data);
+		memcpy(&payload->sreg, data, sizeof(payload->sreg));
 		break;
 	case NFTNL_EXPR_PAYLOAD_DREG:
-		payload->dreg = *((uint32_t *)data);
+		memcpy(&payload->dreg, data, sizeof(payload->dreg));
 		break;
 	case NFTNL_EXPR_PAYLOAD_BASE:
-		payload->base = *((uint32_t *)data);
+		memcpy(&payload->base, data, sizeof(payload->base));
 		break;
 	case NFTNL_EXPR_PAYLOAD_OFFSET:
-		payload->offset = *((unsigned int *)data);
+		memcpy(&payload->offset, data, sizeof(payload->offset));
 		break;
 	case NFTNL_EXPR_PAYLOAD_LEN:
-		payload->len = *((unsigned int *)data);
+		memcpy(&payload->len, data, sizeof(payload->len));
 		break;
 	case NFTNL_EXPR_PAYLOAD_CSUM_TYPE:
-		payload->csum_type = *((uint32_t *)data);
+		memcpy(&payload->csum_type, data, sizeof(payload->csum_type));
 		break;
 	case NFTNL_EXPR_PAYLOAD_CSUM_OFFSET:
-		payload->csum_offset = *((uint32_t *)data);
+		memcpy(&payload->csum_offset, data, sizeof(payload->csum_offset));
 		break;
 	case NFTNL_EXPR_PAYLOAD_FLAGS:
-		payload->csum_flags = *((uint32_t *)data);
+		memcpy(&payload->csum_flags, data, sizeof(payload->csum_flags));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/queue.c b/src/expr/queue.c
index e71df7d..f9d8313 100644
--- a/src/expr/queue.c
+++ b/src/expr/queue.c
@@ -34,16 +34,16 @@ static int nftnl_expr_queue_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_QUEUE_NUM:
-		queue->queuenum = *((uint16_t *)data);
+		memcpy(&queue->queuenum, data, sizeof(queue->queuenum));
 		break;
 	case NFTNL_EXPR_QUEUE_TOTAL:
-		queue->queues_total = *((uint16_t *)data);
+		memcpy(&queue->queues_total, data, sizeof(queue->queues_total));
 		break;
 	case NFTNL_EXPR_QUEUE_FLAGS:
-		queue->flags = *((uint16_t *)data);
+		memcpy(&queue->flags, data, sizeof(queue->flags));
 		break;
 	case NFTNL_EXPR_QUEUE_SREG_QNUM:
-		queue->sreg_qnum = *((uint32_t *)data);
+		memcpy(&queue->sreg_qnum, data, sizeof(queue->sreg_qnum));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/quota.c b/src/expr/quota.c
index b280852..39a92e6 100644
--- a/src/expr/quota.c
+++ b/src/expr/quota.c
@@ -33,13 +33,13 @@ static int nftnl_expr_quota_set(struct nftnl_expr *e, uint16_t type,
 
 	switch (type) {
 	case NFTNL_EXPR_QUOTA_BYTES:
-		quota->bytes = *((uint64_t *)data);
+		memcpy(&quota->bytes, data, sizeof(quota->bytes));
 		break;
 	case NFTNL_EXPR_QUOTA_CONSUMED:
-		quota->consumed = *((uint64_t *)data);
+		memcpy(&quota->consumed, data, sizeof(quota->consumed));
 		break;
 	case NFTNL_EXPR_QUOTA_FLAGS:
-		quota->flags = *((uint32_t *)data);
+		memcpy(&quota->flags, data, sizeof(quota->flags));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/range.c b/src/expr/range.c
index f5a41ac..d1d5083 100644
--- a/src/expr/range.c
+++ b/src/expr/range.c
@@ -34,10 +34,10 @@ static int nftnl_expr_range_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_RANGE_SREG:
-		range->sreg = *((uint32_t *)data);
+		memcpy(&range->sreg, data, sizeof(range->sreg));
 		break;
 	case NFTNL_EXPR_RANGE_OP:
-		range->op = *((uint32_t *)data);
+		memcpy(&range->op, data, sizeof(range->op));
 		break;
 	case NFTNL_EXPR_RANGE_FROM_DATA:
 		memcpy(&range->data_from.val, data, data_len);
diff --git a/src/expr/redir.c b/src/expr/redir.c
index 1ed4896..36c2e2b 100644
--- a/src/expr/redir.c
+++ b/src/expr/redir.c
@@ -34,13 +34,13 @@ nftnl_expr_redir_set(struct nftnl_expr *e, uint16_t type,
 
 	switch (type) {
 	case NFTNL_EXPR_REDIR_REG_PROTO_MIN:
-		redir->sreg_proto_min = *((uint32_t *)data);
+		memcpy(&redir->sreg_proto_min, data, sizeof(redir->sreg_proto_min));
 		break;
 	case NFTNL_EXPR_REDIR_REG_PROTO_MAX:
-		redir->sreg_proto_max = *((uint32_t *)data);
+		memcpy(&redir->sreg_proto_max, data, sizeof(redir->sreg_proto_max));
 		break;
 	case NFTNL_EXPR_REDIR_FLAGS:
-		redir->flags = *((uint32_t *)data);
+		memcpy(&redir->flags, data, sizeof(redir->flags));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/reject.c b/src/expr/reject.c
index b26b0cc..3e49076 100644
--- a/src/expr/reject.c
+++ b/src/expr/reject.c
@@ -33,10 +33,10 @@ static int nftnl_expr_reject_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_REJECT_TYPE:
-		reject->type = *((uint32_t *)data);
+		memcpy(&reject->type, data, sizeof(reject->type));
 		break;
 	case NFTNL_EXPR_REJECT_CODE:
-		reject->icmp_code = *((uint8_t *)data);
+		memcpy(&reject->icmp_code, data, sizeof(reject->icmp_code));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/rt.c b/src/expr/rt.c
index 2c0c1cf..a112270 100644
--- a/src/expr/rt.c
+++ b/src/expr/rt.c
@@ -32,10 +32,10 @@ nftnl_expr_rt_set(struct nftnl_expr *e, uint16_t type,
 
 	switch (type) {
 	case NFTNL_EXPR_RT_KEY:
-		rt->key = *((uint32_t *)data);
+		memcpy(&rt->key, data, sizeof(rt->key));
 		break;
 	case NFTNL_EXPR_RT_DREG:
-		rt->dreg = *((uint32_t *)data);
+		memcpy(&rt->dreg, data, sizeof(rt->dreg));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/socket.c b/src/expr/socket.c
index 704b1d9..ebafa2f 100644
--- a/src/expr/socket.c
+++ b/src/expr/socket.c
@@ -32,10 +32,10 @@ nftnl_expr_socket_set(struct nftnl_expr *e, uint16_t type,
 
 	switch (type) {
 	case NFTNL_EXPR_SOCKET_KEY:
-		socket->key = *((uint32_t *)data);
+		memcpy(&socket->key, data, sizeof(socket->key));
 		break;
 	case NFTNL_EXPR_SOCKET_DREG:
-		socket->dreg = *((uint32_t *)data);
+		memcpy(&socket->dreg, data, sizeof(socket->dreg));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/target.c b/src/expr/target.c
index 6ae6c81..bf2ba77 100644
--- a/src/expr/target.c
+++ b/src/expr/target.c
@@ -46,7 +46,7 @@ nftnl_expr_target_set(struct nftnl_expr *e, uint16_t type,
 			 (const char *) data);
 		break;
 	case NFTNL_EXPR_TG_REV:
-		tg->rev = *((uint32_t *)data);
+		memcpy(&tg->rev, data, sizeof(tg->rev));
 		break;
 	case NFTNL_EXPR_TG_INFO:
 		if (e->flags & (1 << NFTNL_EXPR_TG_INFO))
diff --git a/src/expr/tproxy.c b/src/expr/tproxy.c
index 6fae172..d75abbc 100644
--- a/src/expr/tproxy.c
+++ b/src/expr/tproxy.c
@@ -34,13 +34,13 @@ nftnl_expr_tproxy_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_TPROXY_FAMILY:
-		tproxy->family = *((uint32_t *)data);
+		memcpy(&tproxy->family, data, sizeof(tproxy->family));
 		break;
 	case NFTNL_EXPR_TPROXY_REG_ADDR:
-		tproxy->sreg_addr = *((uint32_t *)data);
+		memcpy(&tproxy->sreg_addr, data, sizeof(tproxy->sreg_addr));
 		break;
 	case NFTNL_EXPR_TPROXY_REG_PORT:
-		tproxy->sreg_port = *((uint32_t *)data);
+		memcpy(&tproxy->sreg_port, data, sizeof(tproxy->sreg_port));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/tunnel.c b/src/expr/tunnel.c
index 677e968..b2b8d72 100644
--- a/src/expr/tunnel.c
+++ b/src/expr/tunnel.c
@@ -31,10 +31,10 @@ static int nftnl_expr_tunnel_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_TUNNEL_KEY:
-		tunnel->key = *((uint32_t *)data);
+		memcpy(&tunnel->key, data, sizeof(tunnel->key));
 		break;
 	case NFTNL_EXPR_TUNNEL_DREG:
-		tunnel->dreg = *((uint32_t *)data);
+		memcpy(&tunnel->dreg, data, sizeof(tunnel->dreg));
 		break;
 	default:
 		return -1;
diff --git a/src/expr/xfrm.c b/src/expr/xfrm.c
index dd3062c..7c6f98e 100644
--- a/src/expr/xfrm.c
+++ b/src/expr/xfrm.c
@@ -33,16 +33,16 @@ nftnl_expr_xfrm_set(struct nftnl_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFTNL_EXPR_XFRM_KEY:
-		x->key = *((uint32_t *)data);
+		memcpy(&x->key, data, sizeof(x->key));
 		break;
 	case NFTNL_EXPR_XFRM_DIR:
-		x->dir = *((uint8_t *)data);
+		memcpy(&x->dir, data, sizeof(x->dir));
 		break;
 	case NFTNL_EXPR_XFRM_SPNUM:
-		x->spnum = *((uint32_t *)data);
+		memcpy(&x->spnum, data, sizeof(x->spnum));
 		break;
 	case NFTNL_EXPR_XFRM_DREG:
-		x->dreg = *((uint32_t *)data);
+		memcpy(&x->dreg, data, sizeof(x->dreg));
 		break;
 	default:
 		return -1;