src: simplify getter logic

This patch refactors the getter code to simplify it. The default
cases have been removed so gcc will spot a warning if an attribute
is not handled appropriately.

Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

15 files changed, 101 insertions, 324 deletions

diff --git a/src/expr/bitwise.c b/src/expr/bitwise.c
index bfb3163..84de249 100644
--- a/src/expr/bitwise.c
+++ b/src/expr/bitwise.c
@@ -69,37 +69,20 @@ nft_rule_expr_bitwise_get(const struct nft_rule_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFT_EXPR_BITWISE_SREG:
-		if (e->flags & (1 << NFT_EXPR_BITWISE_SREG)) {
-			*data_len = sizeof(bitwise->sreg);
-			return &bitwise->sreg;
-		}
-		break;
+		*data_len = sizeof(bitwise->sreg);
+		return &bitwise->sreg;
 	case NFT_EXPR_BITWISE_DREG:
-		if (e->flags & (1 << NFT_EXPR_BITWISE_DREG)) {
-			*data_len = sizeof(bitwise->dreg);
-			return &bitwise->dreg;
-		}
-		break;
+		*data_len = sizeof(bitwise->dreg);
+		return &bitwise->dreg;
 	case NFT_EXPR_BITWISE_LEN:
-		if (e->flags & (1 << NFT_EXPR_BITWISE_LEN)) {
-			*data_len = sizeof(bitwise->len);
-			return &bitwise->len;
-		}
-		break;
+		*data_len = sizeof(bitwise->len);
+		return &bitwise->len;
 	case NFT_EXPR_BITWISE_MASK:
-		if (e->flags & (1 << NFT_EXPR_BITWISE_MASK)) {
-			*data_len = bitwise->mask.len;
-			return &bitwise->mask.val;
-		}
-		break;
+		*data_len = bitwise->mask.len;
+		return &bitwise->mask.val;
 	case NFT_EXPR_BITWISE_XOR:
-		if (e->flags & (1 << NFT_EXPR_BITWISE_XOR)) {
-			*data_len = bitwise->xor.len;
-			return &bitwise->xor.val;
-		}
-		break;
-	default:
-		break;
+		*data_len = bitwise->xor.len;
+		return &bitwise->xor.val;
 	}
 	return NULL;
 }
diff --git a/src/expr/byteorder.c b/src/expr/byteorder.c
index 2326961..e3b9a5e 100644
--- a/src/expr/byteorder.c
+++ b/src/expr/byteorder.c
@@ -67,37 +67,20 @@ nft_rule_expr_byteorder_get(const struct nft_rule_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFT_EXPR_BYTEORDER_SREG:
-		if (e->flags & (1 << NFT_EXPR_BYTEORDER_SREG)) {
-			*data_len = sizeof(byteorder->sreg);
-			return &byteorder->sreg;
-		}
-		break;
+		*data_len = sizeof(byteorder->sreg);
+		return &byteorder->sreg;
 	case NFT_EXPR_BYTEORDER_DREG:
-		if (e->flags & (1 << NFT_EXPR_BYTEORDER_DREG)) {
-			*data_len = sizeof(byteorder->dreg);
-			return &byteorder->dreg;
-		}
-		break;
+		*data_len = sizeof(byteorder->dreg);
+		return &byteorder->dreg;
 	case NFT_EXPR_BYTEORDER_OP:
-		if (e->flags & (1 << NFT_EXPR_BYTEORDER_OP)) {
-			*data_len = sizeof(byteorder->op);
-			return &byteorder->op;
-		}
-		break;
+		*data_len = sizeof(byteorder->op);
+		return &byteorder->op;
 	case NFT_EXPR_BYTEORDER_LEN:
-		if (e->flags & (1 << NFT_EXPR_BYTEORDER_LEN)) {
-			*data_len = sizeof(byteorder->len);
-			return &byteorder->len;
-		}
-		break;
+		*data_len = sizeof(byteorder->len);
+		return &byteorder->len;
 	case NFT_EXPR_BYTEORDER_SIZE:
-		if (e->flags & (1 << NFT_EXPR_BYTEORDER_SIZE)) {
-			*data_len = sizeof(byteorder->size);
-			return &byteorder->size;
-		}
-		break;
-	default:
-		break;
+		*data_len = sizeof(byteorder->size);
+		return &byteorder->size;
 	}
 	return NULL;
 }
diff --git a/src/expr/cmp.c b/src/expr/cmp.c
index 2fa9bf5..cbc08ec 100644
--- a/src/expr/cmp.c
+++ b/src/expr/cmp.c
@@ -61,28 +61,14 @@ nft_rule_expr_cmp_get(const struct nft_rule_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFT_EXPR_CMP_SREG:
-		if (e->flags & (1 << NFT_EXPR_CMP_SREG)) {
-			*data_len = sizeof(cmp->sreg);
-			return &cmp->sreg;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(cmp->sreg);
+		return &cmp->sreg;
 	case NFT_EXPR_CMP_OP:
-		if (e->flags & (1 << NFT_EXPR_CMP_OP)) {
-			*data_len = sizeof(cmp->op);
-			return &cmp->op;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(cmp->op);
+		return &cmp->op;
 	case NFT_EXPR_CMP_DATA:
-		if (e->flags & (1 << NFT_EXPR_CMP_DATA)) {
-			*data_len = cmp->data.len;
-			return &cmp->data.val;
-		} else
-			return NULL;
-		break;
-	default:
-		break;
+		*data_len = cmp->data.len;
+		return &cmp->data.val;
 	}
 	return NULL;
 }
diff --git a/src/expr/counter.c b/src/expr/counter.c
index 8521a22..8b2542d 100644
--- a/src/expr/counter.c
+++ b/src/expr/counter.c
@@ -55,21 +55,11 @@ nft_rule_expr_counter_get(const struct nft_rule_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFT_EXPR_CTR_BYTES:
-		if (e->flags & (1 << NFT_EXPR_CTR_BYTES)) {
-			*data_len = sizeof(ctr->bytes);
-			return &ctr->bytes;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(ctr->bytes);
+		return &ctr->bytes;
 	case NFT_EXPR_CTR_PACKETS:
-		if (e->flags & (1 << NFT_EXPR_CTR_PACKETS)) {
-			*data_len = sizeof(ctr->pkts);
-			return &ctr->pkts;
-		} else
-			return NULL;
-		break;
-	default:
-		break;
+		*data_len = sizeof(ctr->pkts);
+		return &ctr->pkts;
 	}
 	return NULL;
 }
diff --git a/src/expr/ct.c b/src/expr/ct.c
index fedb1f2..f399219 100644
--- a/src/expr/ct.c
+++ b/src/expr/ct.c
@@ -65,28 +65,14 @@ nft_rule_expr_ct_get(const struct nft_rule_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFT_EXPR_CT_KEY:
-		if (e->flags & (1 << NFT_EXPR_CT_KEY)) {
-			*data_len = sizeof(ct->key);
-			return &ct->key;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(ct->key);
+		return &ct->key;
 	case NFT_EXPR_CT_DIR:
-		if (e->flags & (1 << NFT_EXPR_CT_DIR)) {
-			*data_len = sizeof(ct->dir);
-			return &ct->dir;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(ct->dir);
+		return &ct->dir;
 	case NFT_EXPR_CT_DREG:
-		if (e->flags & (1 << NFT_EXPR_CT_DREG)) {
-			*data_len = sizeof(ct->dreg);
-			return &ct->dreg;
-		} else
-			return NULL;
-		break;
-	default:
-		break;
+		*data_len = sizeof(ct->dreg);
+		return &ct->dreg;
 	}
 	return NULL;
 }
diff --git a/src/expr/exthdr.c b/src/expr/exthdr.c
index 5fd2550..51e784e 100644
--- a/src/expr/exthdr.c
+++ b/src/expr/exthdr.c
@@ -70,35 +70,17 @@ nft_rule_expr_exthdr_get(const struct nft_rule_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFT_EXPR_EXTHDR_DREG:
-		if (e->flags & (1 << NFT_EXPR_EXTHDR_DREG)) {
-			*data_len = sizeof(exthdr->dreg);
-			return &exthdr->dreg;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(exthdr->dreg);
+		return &exthdr->dreg;
 	case NFT_EXPR_EXTHDR_TYPE:
-		if (e->flags & (1 << NFT_EXPR_EXTHDR_TYPE)) {
-			*data_len = sizeof(exthdr->type);
-			return &exthdr->type;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(exthdr->type);
+		return &exthdr->type;
 	case NFT_EXPR_EXTHDR_OFFSET:
-		if (e->flags & (1 << NFT_EXPR_EXTHDR_OFFSET)) {
-			*data_len = sizeof(exthdr->offset);
-			return &exthdr->offset;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(exthdr->offset);
+		return &exthdr->offset;
 	case NFT_EXPR_EXTHDR_LEN:
-		if (e->flags & (1 << NFT_EXPR_EXTHDR_LEN)) {
-			*data_len = sizeof(exthdr->len);
-			return &exthdr->len;
-		} else
-			return NULL;
-		break;
-	default:
-		break;
+		*data_len = sizeof(exthdr->len);
+		return &exthdr->len;
 	}
 	return NULL;
 }
diff --git a/src/expr/immediate.c b/src/expr/immediate.c
index 8177766..48e9d1e 100644
--- a/src/expr/immediate.c
+++ b/src/expr/immediate.c
@@ -64,35 +64,17 @@ nft_rule_expr_immediate_get(const struct nft_rule_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFT_EXPR_IMM_DREG:
-		if (e->flags & (1 << NFT_EXPR_IMM_DREG)) {
-			*data_len = sizeof(imm->dreg);
-			return &imm->dreg;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(imm->dreg);
+		return &imm->dreg;
 	case NFT_EXPR_IMM_DATA:
-		if (e->flags & (1 << NFT_EXPR_IMM_DATA)) {
-			*data_len = imm->data.len;
-			return &imm->data.val;
-		} else
-			return NULL;
-		break;
+		*data_len = imm->data.len;
+		return &imm->data.val;
 	case NFT_EXPR_IMM_VERDICT:
-		if (e->flags & (1 << NFT_EXPR_IMM_VERDICT)) {
-			*data_len = sizeof(imm->data.verdict);
-			return &imm->data.verdict;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(imm->data.verdict);
+		return &imm->data.verdict;
 	case NFT_EXPR_IMM_CHAIN:
-		if (e->flags & (1 << NFT_EXPR_IMM_CHAIN)) {
-			*data_len = strlen(imm->data.chain)+1;
-			return imm->data.chain;
-		} else
-			return NULL;
-		break;
-	default:
-		break;
+		*data_len = strlen(imm->data.chain)+1;
+		return imm->data.chain;
 	}
 	return NULL;
 }
diff --git a/src/expr/limit.c b/src/expr/limit.c
index 3a0d5a0..2ecf7cb 100644
--- a/src/expr/limit.c
+++ b/src/expr/limit.c
@@ -55,21 +55,11 @@ nft_rule_expr_limit_get(const struct nft_rule_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFT_EXPR_LIMIT_RATE:
-		if (e->flags & (1 << NFT_EXPR_LIMIT_RATE)) {
-			*data_len = sizeof(uint64_t);
-			return &limit->rate;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(uint64_t);
+		return &limit->rate;
 	case NFT_EXPR_LIMIT_DEPTH:
-		if (e->flags & (1 << NFT_EXPR_LIMIT_DEPTH)) {
-			*data_len = sizeof(uint64_t);
-			return &limit->depth;
-		} else
-			return NULL;
-		break;
-	default:
-		break;
+		*data_len = sizeof(uint64_t);
+		return &limit->depth;
 	}
 	return NULL;
 }
diff --git a/src/expr/log.c b/src/expr/log.c
index b2c39c1..1ffd1d9 100644
--- a/src/expr/log.c
+++ b/src/expr/log.c
@@ -65,31 +65,13 @@ nft_rule_expr_log_get(const struct nft_rule_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFT_EXPR_LOG_PREFIX:
-		if (e->flags & (1 << NFT_EXPR_LOG_PREFIX))
-			return log->prefix;
-		else
-			return NULL;
-		break;
+		return log->prefix;
 	case NFT_EXPR_LOG_GROUP:
-		if (e->flags & (1 << NFT_EXPR_LOG_GROUP))
-			return &log->group;
-		else
-			return NULL;
-		break;
+		return &log->group;
 	case NFT_EXPR_LOG_SNAPLEN:
-		if (e->flags & (1 << NFT_EXPR_LOG_SNAPLEN))
-			return &log->snaplen;
-		else
-			return NULL;
-		break;
+		return &log->snaplen;
 	case NFT_EXPR_LOG_QTHRESHOLD:
-		if (e->flags & (1 << NFT_EXPR_LOG_QTHRESHOLD))
-			return &log->qthreshold;
-		else
-			return NULL;
-		break;
-	default:
-		break;
+		return &log->qthreshold;
 	}
 	return NULL;
 }
diff --git a/src/expr/lookup.c b/src/expr/lookup.c
index 027f1b5..b9a803e 100644
--- a/src/expr/lookup.c
+++ b/src/expr/lookup.c
@@ -64,23 +64,13 @@ nft_rule_expr_lookup_get(const struct nft_rule_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFT_EXPR_LOOKUP_SREG:
-		if (e->flags & (1 << NFT_EXPR_LOOKUP_SREG)) {
-			*data_len = sizeof(lookup->sreg);
-			return &lookup->sreg;
-		}
-		break;
+		*data_len = sizeof(lookup->sreg);
+		return &lookup->sreg;
 	case NFT_EXPR_LOOKUP_DREG:
-		if (e->flags & (1 << NFT_EXPR_LOOKUP_DREG)) {
-			*data_len = sizeof(lookup->dreg);
-			return &lookup->dreg;
-		}
-		break;
+		*data_len = sizeof(lookup->dreg);
+		return &lookup->dreg;
 	case NFT_EXPR_LOOKUP_SET:
-		if (e->flags & (1 << NFT_EXPR_LOOKUP_SET))
-			return lookup->set_name;
-		break;
-	default:
-		break;
+		return lookup->set_name;
 	}
 	return NULL;
 }
diff --git a/src/expr/match.c b/src/expr/match.c
index ee894a1..d7d9c5b 100644
--- a/src/expr/match.c
+++ b/src/expr/match.c
@@ -69,28 +69,14 @@ nft_rule_expr_match_get(const struct nft_rule_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFT_EXPR_MT_NAME:
-		if (e->flags & (1 << NFT_EXPR_MT_NAME)) {
-			*data_len = sizeof(mt->name);
-			return mt->name;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(mt->name);
+		return mt->name;
 	case NFT_EXPR_MT_REV:
-		if (e->flags & (1 << NFT_EXPR_MT_REV)) {
-			*data_len = sizeof(mt->rev);
-			return &mt->rev;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(mt->rev);
+		return &mt->rev;
 	case NFT_EXPR_MT_INFO:
-		if (e->flags & (1 << NFT_EXPR_MT_INFO)) {
-			*data_len = mt->data_len;
-			return mt->data;
-		} else
-			return NULL;
-		break;
-	default:
-		break;
+		*data_len = mt->data_len;
+		return mt->data;
 	}
 	return NULL;
 }
diff --git a/src/expr/meta.c b/src/expr/meta.c
index 6b19764..4a7a83a 100644
--- a/src/expr/meta.c
+++ b/src/expr/meta.c
@@ -58,21 +58,11 @@ nft_rule_expr_meta_get(const struct nft_rule_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFT_EXPR_META_KEY:
-		if (e->flags & (1 << NFT_EXPR_META_KEY)) {
-			*data_len = sizeof(meta->key);
-			return &meta->key;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(meta->key);
+		return &meta->key;
 	case NFT_EXPR_META_DREG:
-		if (e->flags & (1 << NFT_EXPR_META_DREG)) {
-			*data_len = sizeof(meta->dreg);
-			return &meta->dreg;
-		} else
-			return NULL;
-		break;
-	default:
-		break;
+		*data_len = sizeof(meta->dreg);
+		return &meta->dreg;
 	}
 	return NULL;
 }
diff --git a/src/expr/nat.c b/src/expr/nat.c
index 78184c4..ce8d5e2 100644
--- a/src/expr/nat.c
+++ b/src/expr/nat.c
@@ -72,45 +72,24 @@ nft_rule_expr_nat_get(const struct nft_rule_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFT_EXPR_NAT_TYPE:
-		if (e->flags & (1 << NFT_EXPR_NAT_TYPE)) {
-			*data_len = sizeof(nat->type);
-			return &nat->type;
-		}
-		break;
+		*data_len = sizeof(nat->type);
+		return &nat->type;
 	case NFT_EXPR_NAT_FAMILY:
-		if (e->flags & (1 << NFT_EXPR_NAT_FAMILY)) {
-			*data_len = sizeof(nat->family);
-			return &nat->family;
-		}
-		break;
+		*data_len = sizeof(nat->family);
+		return &nat->family;
 	case NFT_EXPR_NAT_REG_ADDR_MIN:
-		if (e->flags & (1 << NFT_EXPR_NAT_REG_ADDR_MIN)) {
-			*data_len = sizeof(nat->sreg_addr_min);
-			return &nat->sreg_addr_min;
-		}
-		break;
+		*data_len = sizeof(nat->sreg_addr_min);
+		return &nat->sreg_addr_min;
 	case NFT_EXPR_NAT_REG_ADDR_MAX:
-		if (e->flags & (1 << NFT_EXPR_NAT_REG_ADDR_MAX)) {
-			*data_len = sizeof(nat->sreg_addr_max);
-			return &nat->sreg_addr_max;
-		}
-		break;
+		*data_len = sizeof(nat->sreg_addr_max);
+		return &nat->sreg_addr_max;
 	case NFT_EXPR_NAT_REG_PROTO_MIN:
-		if (e->flags & (1 << NFT_EXPR_NAT_REG_PROTO_MIN)) {
-			*data_len = sizeof(nat->sreg_proto_min);
-			return &nat->sreg_proto_min;
-		}
-		break;
+		*data_len = sizeof(nat->sreg_proto_min);
+		return &nat->sreg_proto_min;
 	case NFT_EXPR_NAT_REG_PROTO_MAX:
-		if (e->flags & (1 << NFT_EXPR_NAT_REG_PROTO_MAX)) {
-			*data_len = sizeof(nat->sreg_proto_max);
-			return &nat->sreg_proto_max;
-		}
-		break;
-	default:
-		break;
+		*data_len = sizeof(nat->sreg_proto_max);
+		return &nat->sreg_proto_max;
 	}
-
 	return NULL;
 }
 
diff --git a/src/expr/payload.c b/src/expr/payload.c
index d856f2e..9853608 100644
--- a/src/expr/payload.c
+++ b/src/expr/payload.c
@@ -65,35 +65,17 @@ nft_rule_expr_payload_get(const struct nft_rule_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFT_EXPR_PAYLOAD_DREG:
-		if (e->flags & (1 << NFT_EXPR_PAYLOAD_DREG)) {
-			*data_len = sizeof(payload->dreg);
-			return &payload->dreg;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(payload->dreg);
+		return &payload->dreg;
 	case NFT_EXPR_PAYLOAD_BASE:
-		if (e->flags & (1 << NFT_EXPR_PAYLOAD_BASE)) {
-			*data_len = sizeof(payload->base);
-			return &payload->base;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(payload->base);
+		return &payload->base;
 	case NFT_EXPR_PAYLOAD_OFFSET:
-		if (e->flags & (1 << NFT_EXPR_PAYLOAD_OFFSET)) {
-			*data_len = sizeof(payload->offset);
-			return &payload->offset;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(payload->offset);
+		return &payload->offset;
 	case NFT_EXPR_PAYLOAD_LEN:
-		if (e->flags & (1 << NFT_EXPR_PAYLOAD_LEN)) {
-			*data_len = sizeof(payload->len);
-			return &payload->len;
-		} else
-			return NULL;
-		break;
-	default:
-		break;
+		*data_len = sizeof(payload->len);
+		return &payload->len;
 	}
 	return NULL;
 }
diff --git a/src/expr/target.c b/src/expr/target.c
index d9d9daf..6365a46 100644
--- a/src/expr/target.c
+++ b/src/expr/target.c
@@ -69,28 +69,14 @@ nft_rule_expr_target_get(const struct nft_rule_expr *e, uint16_t type,
 
 	switch(type) {
 	case NFT_EXPR_TG_NAME:
-		if (e->flags & (1 << NFT_EXPR_TG_NAME)) {
-			*data_len = sizeof(tg->name);
-			return tg->name;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(tg->name);
+		return tg->name;
 	case NFT_EXPR_TG_REV:
-		if (e->flags & (1 << NFT_EXPR_TG_REV)) {
-			*data_len = sizeof(tg->rev);
-			return &tg->rev;
-		} else
-			return NULL;
-		break;
+		*data_len = sizeof(tg->rev);
+		return &tg->rev;
 	case NFT_EXPR_TG_INFO:
-		if (e->flags & (1 << NFT_EXPR_TG_INFO)) {
-			*data_len = tg->data_len;
-			return tg->data;
-		} else
-			return NULL;
-		break;
-	default:
-		break;
+		*data_len = tg->data_len;
+		return tg->data;
 	}
 	return NULL;
 }