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>

diff --git a/src/chain.c b/src/chain.c
index 06252b66a0183fe216007b097f5929a3ab940192..01d62c84f140e213eb4e45b57e015a7c7bb4d4de 100644 (file)
--- a/src/chain.c
+++ b/src/chain.c
@@ -190,22 +190,22 @@ int nftnl_chain_set_data(struct nftnl_chain *c, uint16_t attr,
                memcpy(&c->prio, data, sizeof(c->prio));
                break;
        case NFTNL_CHAIN_POLICY:
-               c->policy = *((uint32_t *)data);
+               memcpy(&c->policy, data, sizeof(c->policy));
                break;
        case NFTNL_CHAIN_USE:
-               c->use = *((uint32_t *)data);
+               memcpy(&c->use, data, sizeof(c->use));
                break;
        case NFTNL_CHAIN_BYTES:
-               c->bytes = *((uint64_t *)data);
+               memcpy(&c->bytes, data, sizeof(c->bytes));
                break;
        case NFTNL_CHAIN_PACKETS:
-               c->packets = *((uint64_t *)data);
+               memcpy(&c->packets, data, sizeof(c->packets));
                break;
        case NFTNL_CHAIN_HANDLE:
-               c->handle = *((uint64_t *)data);
+               memcpy(&c->handle, data, sizeof(c->handle));
                break;
        case NFTNL_CHAIN_FAMILY:
-               c->family = *((uint32_t *)data);
+               memcpy(&c->family, data, sizeof(c->family));
                break;
        case NFTNL_CHAIN_TYPE:
                if (c->flags & (1 << NFTNL_CHAIN_TYPE))

diff --git a/src/expr/bitwise.c b/src/expr/bitwise.c
index ebfbcd0772370a80aa0df0e7e7a74cc7794b4c8e..79d6a518794351d939a4a565e44aad73474c7a36 100644 (file)
--- 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 4cddd4a052c2ab862d8415d16e66dd01d86d0059..35c145034150e76f0fd6362e2d83c1205a4210df 100644 (file)
--- 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 86708a48410f9bf53b76a3daa3fe3cee36a31c52..e39a943d58f5f8138d06fda5bd4005198c41c0d4 100644 (file)
--- 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 61fd299e6e31a902a9da52ccdf21d4f58a285d96..9fa0a7b7263fd6ee0416ddbe2367bcb49d72ad77 100644 (file)
--- 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 2036cb0c1502c3d142888d07801cb60043afe76c..a1f6574cb134f1e6041d8d89efa89db5789af959 100644 (file)
--- 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 bb7fe8a4bac2e636a6423ec7e311b24a4585020c..e8a8c6c92293c6b555e9bc5d9a34e9f58c734407 100644 (file)
--- 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 6fa65988c835f6359ab733a168227b3cd00392ab..c08ccd2750916656e4798e1386fc6fb8ae3a1b14 100644 (file)
--- 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 3d24ef8da0f8fb61d8399252f6dc4e3f3417a3fb..f009ec4c7a5d1998a69b694b9d42f66280ddb46e 100644 (file)
--- 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 ec6a855b3f8e1b7f3b095c80ded3e3f0a26c2fdb..0e098148ba25e6eb59d7c9a00f2d9fc3aaa196e0 100644 (file)
--- 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 f1eec73a2927a732c744b2def5c3ecc0391c931f..2f2d219037aa53b7972a18cc3b3227bfe03221d5 100644 (file)
--- 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 9890e9aca5465e1cd278adc88e7b54254e8a83cd..9cb0aca6ade6c79310cc48b3f95305aab83099fc 100644 (file)
--- 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 280ea0c41e75e4f1ee80d21f01c2d278b30c1aa4..46b79015f705c4e5a978859a48270822700dc74c 100644 (file)
--- 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 22edbc80b7f430f56f1dd86233ba03a9809d5795..d5a7e86e2a0d39f7301e080c4f9ed18c972d3ee5 100644 (file)
--- 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 4831abd4bdfc210ba6c91ad0fd80a1071804ea70..2a0adba8f6e4619e06f8bf7adaf8d69231946667 100644 (file)
--- 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 e4bf0516e966f6458d686cd7ae439b7f8a6835dd..1119c53898a3d56357e72cc4ecc54a785a012113 100644 (file)
--- 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 132dc4e66dc64d852fec4ccd8acee07d94bca92d..a502e2a5bca5829382c5b154c22d7f6e3e133630 100644 (file)
--- 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 78dd76b1a3b3dfd60441aeafcc5e23a4f0759b84..fe017f7277971b1d532ec59c3f2028146eb78640 100644 (file)
--- 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 85dd79c6a63d9d4fe866051467b33aadd8ba301b..2b3321d14aa3ec068feb4c12128b2e854b895482 100644 (file)
--- 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 b66b9b702ca2bf0fdbdabb04def46995cac2bdc0..3654837b9bb47f14184da59e992e1fb7749570a0 100644 (file)
--- 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 9be78f39c31d54140b75f42405dfdbb27b07661f..38fccb0fdb3e87918d9d3e7e5b0af052368dc0ce 100644 (file)
--- 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 d46cf947464de834d8a6a5447f601b6876c2736c..f940081c41a23b46df2ee7b5cf06d52f839fad21 100644 (file)
--- 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 67fd74bd8992658eae14942c63b16e02d3c36a69..3b815f5c1db70d3310482595294e70aed6835eb3 100644 (file)
--- 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 a90620de18b058edb7b45d941cddd3c0cd67f56a..08603286b34a2cf0ae4f470d7009b3e24a9d77a4 100644 (file)
--- 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 4b2f32213c292fcc38391f5d9144d41e9c2f70b4..680da4a827b05cd4871f7fc182cf3cd9164cdc5b 100644 (file)
--- 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 e71df7dafd03cb02697721695352aea5d22a5d3a..f9d83139ce3c8fac1c3314ecc9029a696365c268 100644 (file)
--- 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 b2808529442adb47ecc4e485984531892647197e..39a92e6ed6969a9315487d89fa6d5ff84b7efad6 100644 (file)
--- 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 f5a41acd12e052b03ad1d2b0f6708310b374f0cb..d1d50832a4503b7fe8ccc927efcfdb24bd036396 100644 (file)
--- 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 1ed48969b15401a118747e087ddd1f177c9575e8..36c2e2b1354f4c55d3f8bd281ebb4e2658ceb0a0 100644 (file)
--- 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 b26b0cc5711abf288b553fcc6f295b764b4cc038..3e49076f069cf832817a57a906e3020b9e3da078 100644 (file)
--- 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 2c0c1cf00b56212195f7c8b85b406872223a2f9d..a112270c92a5b331d78d7a8502169e64de41345b 100644 (file)
--- 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 704b1d943d2426a3352177f8b44f355d04611d0e..ebafa2f172e37026bf7436d2b08a616ba17451bf 100644 (file)
--- 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 6ae6c819d2f4dd1ad7ffe3d7b91af46d1edddf5d..bf2ba77ba3a87921b4655f8162ea7dc2d480ae08 100644 (file)
--- 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 6fae17279e7d87a5072ca8403aac09f92a480a35..d75abbc941dc361ecf15e9b0ba46c2aeae1270ae 100644 (file)
--- 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 677e9685b8ad19ec4f2607a0cfb96871f83e1a29..b2b8d7243a26c776bb465662191e83c9cd485130 100644 (file)
--- 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 dd3062c43a7457d9fc77614a8209a6ddb56878cd..7c6f98ee34d25d09a0299630f26d995d6824957d 100644 (file)
--- 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;

diff --git a/src/gen.c b/src/gen.c
index 8e1a37a3097f621433ac1c1a4d16981833205d23..1fc909930d869b106e988e71a317d8749cc468d7 100644 (file)
--- a/src/gen.c
+++ b/src/gen.c
@@ -73,7 +73,7 @@ int nftnl_gen_set_data(struct nftnl_gen *gen, uint16_t attr,
 
        switch (attr) {
        case NFTNL_GEN_ID:
-               gen->id = *((uint32_t *)data);
+               memcpy(&gen->id, data, sizeof(gen->id));
                break;
        }
        gen->flags |= (1 << attr);

diff --git a/src/obj/counter.c b/src/obj/counter.c
index 23b60c56638ad571912fbdf51cb0a3f73eb20e6e..1baba4e149414e5331c3184fb4aef33e7bf49ec6 100644 (file)
--- a/src/obj/counter.c
+++ b/src/obj/counter.c
@@ -29,10 +29,10 @@ nftnl_obj_counter_set(struct nftnl_obj *e, uint16_t type,
 
        switch(type) {
        case NFTNL_OBJ_CTR_BYTES:
-               ctr->bytes = *((uint64_t *)data);
+               memcpy(&ctr->bytes, data, sizeof(ctr->bytes));
                break;
        case NFTNL_OBJ_CTR_PKTS:
-               ctr->pkts = *((uint64_t *)data);
+               memcpy(&ctr->pkts, data, sizeof(ctr->pkts));
                break;
        default:
                return -1;

diff --git a/src/obj/ct_helper.c b/src/obj/ct_helper.c
index 5a689b1405d8ba6ee38755312e51c75dc7cdceed..d91f636d4c64cc20c52bafdaf7dbfb6aa7a5bf60 100644 (file)
--- a/src/obj/ct_helper.c
+++ b/src/obj/ct_helper.c
@@ -32,10 +32,10 @@ static int nftnl_obj_ct_helper_set(struct nftnl_obj *e, uint16_t type,
                snprintf(helper->name, sizeof(helper->name), "%s", (const char *)data);
                break;
        case NFTNL_OBJ_CT_HELPER_L3PROTO:
-               helper->l3proto = *((uint16_t *)data);
+               memcpy(&helper->l3proto, data, sizeof(helper->l3proto));
                break;
        case NFTNL_OBJ_CT_HELPER_L4PROTO:
-               helper->l4proto = *((uint8_t *)data);
+               memcpy(&helper->l4proto, data, sizeof(helper->l4proto));
                break;
        default:
                return -1;

diff --git a/src/obj/ct_timeout.c b/src/obj/ct_timeout.c
index 12c8f5f9b4dfd876ba92ab331df4299344920ae1..e2e99917de7aed8df2ad4cfe64be8f0a7b12f97e 100644 (file)
--- a/src/obj/ct_timeout.c
+++ b/src/obj/ct_timeout.c
@@ -148,10 +148,10 @@ static int nftnl_obj_ct_timeout_set(struct nftnl_obj *e, uint16_t type,
 
        switch (type) {
        case NFTNL_OBJ_CT_TIMEOUT_L3PROTO:
-               timeout->l3proto = *((uint16_t *)data);
+               memcpy(&timeout->l3proto, data, sizeof(timeout->l3proto));
                break;
        case NFTNL_OBJ_CT_TIMEOUT_L4PROTO:
-               timeout->l4proto = *((uint8_t *)data);
+               memcpy(&timeout->l4proto, data, sizeof(timeout->l4proto));
                break;
        case NFTNL_OBJ_CT_TIMEOUT_ARRAY:
                memcpy(timeout->timeout, data,

diff --git a/src/obj/limit.c b/src/obj/limit.c
index b0ed4c8b84b2cc88b337d486dead178e17380597..60b01592e4c5079f126cd01fc16946bd8bcd31bd 100644 (file)
--- a/src/obj/limit.c
+++ b/src/obj/limit.c
@@ -28,19 +28,19 @@ static int nftnl_obj_limit_set(struct nftnl_obj *e, uint16_t type,
 
        switch (type) {
        case NFTNL_OBJ_LIMIT_RATE:
-               limit->rate = *((uint64_t *)data);
+               memcpy(&limit->rate, data, sizeof(limit->rate));
                break;
        case NFTNL_OBJ_LIMIT_UNIT:
-               limit->unit = *((uint64_t *)data);
+               memcpy(&limit->unit, data, sizeof(limit->unit));
                break;
        case NFTNL_OBJ_LIMIT_BURST:
-               limit->burst = *((uint32_t *)data);
+               memcpy(&limit->burst, data, sizeof(limit->burst));
                break;
        case NFTNL_OBJ_LIMIT_TYPE:
-               limit->type = *((uint32_t *)data);
+               memcpy(&limit->type, data, sizeof(limit->type));
                break;
        case NFTNL_OBJ_LIMIT_FLAGS:
-               limit->flags = *((uint32_t *)data);
+               memcpy(&limit->flags, data, sizeof(limit->flags));
                break;
        default:
                return -1;

diff --git a/src/obj/quota.c b/src/obj/quota.c
index b1a3f7e4b7545e7a63aaf582bf50bad9a6d5f79f..1914037d3f70d490e4c20fdcffddd9d1a714d876 100644 (file)
--- a/src/obj/quota.c
+++ b/src/obj/quota.c
@@ -28,13 +28,13 @@ static int nftnl_obj_quota_set(struct nftnl_obj *e, uint16_t type,
 
        switch (type) {
        case NFTNL_OBJ_QUOTA_BYTES:
-               quota->bytes = *((uint64_t *)data);
+               memcpy(&quota->bytes, data, sizeof(quota->bytes));
                break;
        case NFTNL_OBJ_QUOTA_CONSUMED:
-               quota->consumed = *((uint64_t *)data);
+               memcpy(&quota->consumed, data, sizeof(quota->consumed));
                break;
        case NFTNL_OBJ_QUOTA_FLAGS:
-               quota->flags = *((uint32_t *)data);
+               memcpy(&quota->flags, data, sizeof(quota->flags));
                break;
        default:
                return -1;

diff --git a/src/obj/tunnel.c b/src/obj/tunnel.c
index 5b2d9de74438789ebf1f83bab27413fd684aace3..7ffade8c46ae7d5478a329cdda7a24d8e3963764 100644 (file)
--- a/src/obj/tunnel.c
+++ b/src/obj/tunnel.c
@@ -29,13 +29,13 @@ nftnl_obj_tunnel_set(struct nftnl_obj *e, uint16_t type,
 
        switch (type) {
        case NFTNL_OBJ_TUNNEL_ID:
-               tun->id = *((uint32_t *)data);
+               memcpy(&tun->id, data, sizeof(tun->id));
                break;
        case NFTNL_OBJ_TUNNEL_IPV4_SRC:
-               tun->src_v4 = *((uint32_t *)data);
+               memcpy(&tun->src_v4, data, sizeof(tun->src_v4));
                break;
        case NFTNL_OBJ_TUNNEL_IPV4_DST:
-               tun->dst_v4 = *((uint32_t *)data);
+               memcpy(&tun->dst_v4, data, sizeof(tun->dst_v4));
                break;
        case NFTNL_OBJ_TUNNEL_IPV6_SRC:
                memcpy(&tun->src_v6, data, sizeof(struct in6_addr));
@@ -44,37 +44,37 @@ nftnl_obj_tunnel_set(struct nftnl_obj *e, uint16_t type,
                memcpy(&tun->dst_v6, data, sizeof(struct in6_addr));
                break;
        case NFTNL_OBJ_TUNNEL_IPV6_FLOWLABEL:
-               tun->flowlabel = (*(uint32_t *)data);
+               memcpy(&tun->flowlabel, data, sizeof(tun->flowlabel));
                break;
        case NFTNL_OBJ_TUNNEL_SPORT:
-               tun->sport = (*(uint16_t *)data);
+               memcpy(&tun->sport, data, sizeof(tun->sport));
                break;
        case NFTNL_OBJ_TUNNEL_DPORT:
-               tun->dport = (*(uint16_t *)data);
+               memcpy(&tun->dport, data, sizeof(tun->dport));
                break;
        case NFTNL_OBJ_TUNNEL_FLAGS:
-               tun->tun_flags = (*(uint32_t *)data);
+               memcpy(&tun->tun_flags, data, sizeof(tun->tun_flags));
                break;
        case NFTNL_OBJ_TUNNEL_TOS:
-               tun->tun_tos = (*(uint8_t *)data);
+               memcpy(&tun->tun_tos, data, sizeof(tun->tun_tos));
                break;
        case NFTNL_OBJ_TUNNEL_TTL:
-               tun->tun_ttl = (*(uint8_t *)data);
+               memcpy(&tun->tun_ttl, data, sizeof(tun->tun_ttl));
                break;
        case NFTNL_OBJ_TUNNEL_VXLAN_GBP:
-               tun->u.tun_vxlan.gbp = (*(uint32_t *)data);
+               memcpy(&tun->u.tun_vxlan.gbp, data, sizeof(tun->u.tun_vxlan.gbp));
                break;
        case NFTNL_OBJ_TUNNEL_ERSPAN_VERSION:
-               tun->u.tun_erspan.version = (*(uint32_t *)data);
+               memcpy(&tun->u.tun_erspan.version, data, sizeof(tun->u.tun_erspan.version));
                break;
        case NFTNL_OBJ_TUNNEL_ERSPAN_V1_INDEX:
-               tun->u.tun_erspan.u.v1_index = (*(uint32_t *)data);
+               memcpy(&tun->u.tun_erspan.u.v1_index, data, sizeof(tun->u.tun_erspan.u.v1_index));
                break;
        case NFTNL_OBJ_TUNNEL_ERSPAN_V2_HWID:
-               tun->u.tun_erspan.u.v2.hwid = (*(uint8_t *)data);
+               memcpy(&tun->u.tun_erspan.u.v2.hwid, data, sizeof(tun->u.tun_erspan.u.v2.hwid));
                break;
        case NFTNL_OBJ_TUNNEL_ERSPAN_V2_DIR:
-               tun->u.tun_erspan.u.v2.dir = (*(uint8_t *)data);
+               memcpy(&tun->u.tun_erspan.u.v2.dir, data, sizeof(tun->u.tun_erspan.u.v2.dir));
                break;
        default:
                return -1;

diff --git a/src/object.c b/src/object.c
index a1a553f07660a49c4be99d7c61f01d6f8a8f5533..e88203a82441eced1a41905528438c7fa19ccbf9 100644 (file)
--- a/src/object.c
+++ b/src/object.c
@@ -94,13 +94,13 @@ void nftnl_obj_set_data(struct nftnl_obj *obj, uint16_t attr,
                        return;
                break;
        case NFTNL_OBJ_FAMILY:
-               obj->family = *((uint32_t *)data);
+               memcpy(&obj->family, data, sizeof(obj->family));
                break;
        case NFTNL_OBJ_USE:
-               obj->use = *((uint32_t *)data);
+               memcpy(&obj->use, data, sizeof(obj->use));
                break;
        case NFTNL_OBJ_HANDLE:
-               obj->handle = *((uint64_t *)data);
+               memcpy(&obj->handle, data, sizeof(obj->handle));
                break;
        default:
                if (obj->ops)

diff --git a/src/rule.c b/src/rule.c
index a42d087c95c58b8dc542ff7ed4244dba78cbae2d..c3c8a8ba5813afa4fc0a7aaf2272221a85f5f1c0 100644 (file)
--- a/src/rule.c
+++ b/src/rule.c
@@ -152,19 +152,19 @@ int nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
                        return -1;
                break;
        case NFTNL_RULE_HANDLE:
-               r->handle = *((uint64_t *)data);
+               memcpy(&r->handle, data, sizeof(r->handle));
                break;
        case NFTNL_RULE_COMPAT_PROTO:
-               r->compat.proto = *((uint32_t *)data);
+               memcpy(&r->compat.proto, data, sizeof(r->compat.proto));
                break;
        case NFTNL_RULE_COMPAT_FLAGS:
-               r->compat.flags = *((uint32_t *)data);
+               memcpy(&r->compat.flags, data, sizeof(r->compat.flags));
                break;
        case NFTNL_RULE_FAMILY:
-               r->family = *((uint32_t *)data);
+               memcpy(&r->family, data, sizeof(r->family));
                break;
        case NFTNL_RULE_POSITION:
-               r->position = *((uint64_t *)data);
+               memcpy(&r->position, data, sizeof(r->position));
                break;
        case NFTNL_RULE_USERDATA:
                if (r->flags & (1 << NFTNL_RULE_USERDATA))
@@ -178,7 +178,7 @@ int nftnl_rule_set_data(struct nftnl_rule *r, uint16_t attr,
                r->user.len = data_len;
                break;
        case NFTNL_RULE_ID:
-               r->id = *((uint32_t *)data);
+               memcpy(&r->id, data, sizeof(r->id));
                break;
        }
        r->flags |= (1 << attr);

diff --git a/src/set.c b/src/set.c
index 74724224b683d35c3b2751278367998300c24e5b..d1bdb165ab4b17eb4b6fdd360d28a026531d9c81 100644 (file)
--- a/src/set.c
+++ b/src/set.c
@@ -142,43 +142,43 @@ int nftnl_set_set_data(struct nftnl_set *s, uint16_t attr, const void *data,
                        return -1;
                break;
        case NFTNL_SET_HANDLE:
-               s->handle = *((uint64_t *)data);
+               memcpy(&s->handle, data, sizeof(s->handle));
                break;
        case NFTNL_SET_FLAGS:
-               s->set_flags = *((uint32_t *)data);
+               memcpy(&s->set_flags, data, sizeof(s->set_flags));
                break;
        case NFTNL_SET_KEY_TYPE:
-               s->key_type = *((uint32_t *)data);
+               memcpy(&s->key_type, data, sizeof(s->key_type));
                break;
        case NFTNL_SET_KEY_LEN:
-               s->key_len = *((uint32_t *)data);
+               memcpy(&s->key_len, data, sizeof(s->key_len));
                break;
        case NFTNL_SET_DATA_TYPE:
-               s->data_type = *((uint32_t *)data);
+               memcpy(&s->data_type, data, sizeof(s->data_type));
                break;
        case NFTNL_SET_DATA_LEN:
-               s->data_len = *((uint32_t *)data);
+               memcpy(&s->data_len, data, sizeof(s->data_len));
                break;
        case NFTNL_SET_OBJ_TYPE:
-               s->obj_type = *((uint32_t *)data);
+               memcpy(&s->obj_type, data, sizeof(s->obj_type));
                break;
        case NFTNL_SET_FAMILY:
-               s->family = *((uint32_t *)data);
+               memcpy(&s->family, data, sizeof(s->family));
                break;
        case NFTNL_SET_ID:
-               s->id = *((uint32_t *)data);
+               memcpy(&s->id, data, sizeof(s->id));
                break;
        case NFTNL_SET_POLICY:
-               s->policy = *((uint32_t *)data);
+               memcpy(&s->policy, data, sizeof(s->policy));
                break;
        case NFTNL_SET_DESC_SIZE:
-               s->desc.size = *((uint32_t *)data);
+               memcpy(&s->desc.size, data, sizeof(s->desc.size));
                break;
        case NFTNL_SET_TIMEOUT:
-               s->timeout = *((uint64_t *)data);
+               memcpy(&s->timeout, data, sizeof(s->timeout));
                break;
        case NFTNL_SET_GC_INTERVAL:
-               s->gc_interval = *((uint32_t *)data);
+               memcpy(&s->gc_interval, data, sizeof(s->gc_interval));
                break;
        case NFTNL_SET_USERDATA:
                if (s->flags & (1 << NFTNL_SET_USERDATA))

diff --git a/src/set_elem.c b/src/set_elem.c
index bb8d0464087b6eda2852375734f02b4fb6a53698..ff983a67d62a7bd04f268b7beb1e9a21de93d4a1 100644 (file)
--- a/src/set_elem.c
+++ b/src/set_elem.c
@@ -102,14 +102,14 @@ int nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr,
 {
        switch(attr) {
        case NFTNL_SET_ELEM_FLAGS:
-               s->set_elem_flags = *((uint32_t *)data);
+               memcpy(&s->set_elem_flags, data, sizeof(s->set_elem_flags));
                break;
        case NFTNL_SET_ELEM_KEY:        /* NFTA_SET_ELEM_KEY */
                memcpy(&s->key.val, data, data_len);
                s->key.len = data_len;
                break;
        case NFTNL_SET_ELEM_VERDICT:    /* NFTA_SET_ELEM_DATA */
-               s->data.verdict = *((uint32_t *)data);
+               memcpy(&s->data.verdict, data, sizeof(s->data.verdict));
                break;
        case NFTNL_SET_ELEM_CHAIN:      /* NFTA_SET_ELEM_DATA */
                if (s->flags & (1 << NFTNL_SET_ELEM_CHAIN))
@@ -124,7 +124,7 @@ int nftnl_set_elem_set(struct nftnl_set_elem *s, uint16_t attr,
                s->data.len = data_len;
                break;
        case NFTNL_SET_ELEM_TIMEOUT:    /* NFTA_SET_ELEM_TIMEOUT */
-               s->timeout = *((uint64_t *)data);
+               memcpy(&s->timeout, data, sizeof(s->timeout));
                break;
        case NFTNL_SET_ELEM_USERDATA: /* NFTA_SET_ELEM_USERDATA */
                if (s->flags & (1 << NFTNL_SET_ELEM_USERDATA))
@@ -218,8 +218,10 @@ const char *nftnl_set_elem_get_str(struct nftnl_set_elem *s, uint16_t attr)
 EXPORT_SYMBOL(nftnl_set_elem_get_u32);
 uint32_t nftnl_set_elem_get_u32(struct nftnl_set_elem *s, uint16_t attr)
 {
-       uint32_t size;
-       uint32_t val = *((uint32_t *)nftnl_set_elem_get(s, attr, &size));
+       uint32_t size, val;
+
+       memcpy(&val, nftnl_set_elem_get(s, attr, &size), sizeof(val));
+
        return val;
 }
 
@@ -227,7 +229,10 @@ EXPORT_SYMBOL(nftnl_set_elem_get_u64);
 uint64_t nftnl_set_elem_get_u64(struct nftnl_set_elem *s, uint16_t attr)
 {
        uint32_t size;
-       uint64_t val = *((uint64_t *)nftnl_set_elem_get(s, attr, &size));
+       uint64_t val;
+
+       memcpy(&val, nftnl_set_elem_get(s, attr, &size), sizeof(val));
+
        return val;
 }
 

diff --git a/src/table.c b/src/table.c
index c987c5e7552ad3a8f5522a71b18a9b3915b7368a..54259eec7d0678912e368ae7cd79ce59fff91c4f 100644 (file)
--- a/src/table.c
+++ b/src/table.c
@@ -101,16 +101,16 @@ int nftnl_table_set_data(struct nftnl_table *t, uint16_t attr,
                        return -1;
                break;
        case NFTNL_TABLE_HANDLE:
-               t->handle = *((uint64_t *)data);
+               memcpy(&t->handle, data, sizeof(t->handle));
                break;
        case NFTNL_TABLE_FLAGS:
-               t->table_flags = *((uint32_t *)data);
+               memcpy(&t->table_flags, data, sizeof(t->table_flags));
                break;
        case NFTNL_TABLE_FAMILY:
-               t->family = *((uint32_t *)data);
+               memcpy(&t->family, data, sizeof(t->family));
                break;
        case NFTNL_TABLE_USE:
-               t->use = *((uint32_t *)data);
+               memcpy(&t->use, data, sizeof(t->use));
                break;
        }
        t->flags |= (1 << attr);

diff --git a/src/utils.c b/src/utils.c
index 4d9ee782b56b39e15ff7b4103a982667926a5b18..f641bf93ec680416958d7dedd797e6300c484669 100644 (file)
--- a/src/utils.c
+++ b/src/utils.c
@@ -89,7 +89,7 @@ int nftnl_get_value(enum nftnl_type type, void *val, void *out)
        case NFTNL_TYPE_U16:
        case NFTNL_TYPE_U32:
        case NFTNL_TYPE_U64:
-               uval = *((uint64_t *)val);
+               memcpy(&uval, val, sizeof(uval));
                if (uval > basetype[type].max) {
                        errno = ERANGE;
                        return -1;
@@ -99,7 +99,7 @@ int nftnl_get_value(enum nftnl_type type, void *val, void *out)
        case NFTNL_TYPE_S16:
        case NFTNL_TYPE_S32:
        case NFTNL_TYPE_S64:
-               sval = *((int64_t *)val);
+               memcpy(&sval, val, sizeof(sval));
                if (sval < basetype[type].min ||
                    sval > (int64_t)basetype[type].max) {
                        errno = ERANGE;