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>

21 files changed, 160 insertions, 477 deletions

diff --git a/src/chain.c b/src/chain.c
index 3c73511..0c7f422 100644
--- a/src/chain.c
+++ b/src/chain.c
@@ -1,5 +1,5 @@
 /*
- * (C) 2012 by Pablo Neira Ayuso <pablo@netfilter.org>
+ * (C) 2012-2013 by Pablo Neira Ayuso <pablo@netfilter.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published
@@ -187,75 +187,34 @@ EXPORT_SYMBOL(nft_chain_attr_set_str);
 
 void *nft_chain_attr_get(struct nft_chain *c, uint16_t attr)
 {
+	if (!(c->flags & (1 << attr)))
+		return NULL;
+
 	switch(attr) {
 	case NFT_CHAIN_ATTR_NAME:
-		if (c->flags & (1 << NFT_CHAIN_ATTR_NAME))
-			return c->name;
-		else
-			return NULL;
-		break;
+		return c->name;
 	case NFT_CHAIN_ATTR_TABLE:
-		if (c->flags & (1 << NFT_CHAIN_ATTR_TABLE))
-			return c->table;
-		else
-			return NULL;
+		return c->table;
 	case NFT_CHAIN_ATTR_HOOKNUM:
-		if (c->flags & (1 << NFT_CHAIN_ATTR_HOOKNUM))
-			return &c->hooknum;
-		else
-			return NULL;
-		break;
+		return &c->hooknum;
 	case NFT_CHAIN_ATTR_PRIO:
-		if (c->flags & (1 << NFT_CHAIN_ATTR_PRIO))
-			return &c->prio;
-		else
-			return NULL;
-		break;
+		return &c->prio;
 	case NFT_CHAIN_ATTR_POLICY:
-		if (c->flags & (1 << NFT_CHAIN_ATTR_POLICY))
-			return &c->policy;
-		else
-			return NULL;
-		break;
+		return &c->policy;
 	case NFT_CHAIN_ATTR_USE:
-		if (c->flags & (1 << NFT_CHAIN_ATTR_USE))
-			return &c->use;
-		else
-			return NULL;
-		break;
+		return &c->use;
 	case NFT_CHAIN_ATTR_BYTES:
-		if (c->flags & (1 << NFT_CHAIN_ATTR_BYTES))
-			return &c->bytes;
-		else
-			return NULL;
-		break;
+		return &c->bytes;
 	case NFT_CHAIN_ATTR_PACKETS:
-		if (c->flags & (1 << NFT_CHAIN_ATTR_PACKETS))
-			return &c->packets;
-		else
-			return NULL;
-		break;
+		return &c->packets;
 	case NFT_CHAIN_ATTR_HANDLE:
-		if (c->flags & (1 << NFT_CHAIN_ATTR_HANDLE))
-			return &c->handle;
-		else
-			return NULL;
-		break;
+		return &c->handle;
 	case NFT_CHAIN_ATTR_FAMILY:
-		if (c->flags & (1 << NFT_CHAIN_ATTR_FAMILY))
-			return &c->family;
-		else
-			return NULL;
-		break;
+		return &c->family;
 	case NFT_CHAIN_ATTR_TYPE:
-		if (c->flags & (1 << NFT_CHAIN_ATTR_TYPE))
-			return c->type;
-		else
-			return NULL;
-		break;
-	default:
-		return NULL;
+		return c->type;
 	}
+	return NULL;
 }
 EXPORT_SYMBOL(nft_chain_attr_get);
 
diff --git a/src/expr.c b/src/expr.c
index 711c18e..d2d345c 100644
--- a/src/expr.c
+++ b/src/expr.c
@@ -114,6 +114,9 @@ const void *nft_rule_expr_get(const struct nft_rule_expr *expr, uint16_t type, s
 		ret = expr->ops->name;
 		break;
 	default:
+		if (!(expr->flags & (1 << type)))
+			return NULL;
+
 		ret = expr->ops->get(expr, type, data_len);
 		break;
 	}
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;
 }
diff --git a/src/rule.c b/src/rule.c
index df9d739..9a93f33 100644
--- a/src/rule.c
+++ b/src/rule.c
@@ -1,5 +1,5 @@
 /*
- * (C) 2012 by Pablo Neira Ayuso <pablo@netfilter.org>
+ * (C) 2012-2013 by Pablo Neira Ayuso <pablo@netfilter.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published
@@ -166,51 +166,26 @@ EXPORT_SYMBOL(nft_rule_attr_set_str);
 
 const void *nft_rule_attr_get(const struct nft_rule *r, uint16_t attr)
 {
+	if (!(r->flags & (1 << attr)))
+		return NULL;
+
 	switch(attr) {
 	case NFT_RULE_ATTR_FAMILY:
-		if (r->flags & (1 << NFT_RULE_ATTR_FAMILY))
-			return &r->family;
-		else
-			return NULL;
-		break;
+		return &r->family;
 	case NFT_RULE_ATTR_TABLE:
-		if (r->flags & (1 << NFT_RULE_ATTR_TABLE))
-			return r->table;
-		else
-			return NULL;
-		break;
+		return r->table;
 	case NFT_RULE_ATTR_CHAIN:
-		if (r->flags & (1 << NFT_RULE_ATTR_CHAIN))
-			return r->chain;
-		else
-			return NULL;
+		return r->chain;
 	case NFT_RULE_ATTR_HANDLE:
-		if (r->flags & (1 << NFT_RULE_ATTR_HANDLE))
-			return &r->handle;
-		else
-			return NULL;
-		break;
+		return &r->handle;
 	case NFT_RULE_ATTR_FLAGS:
-		if (r->flags & (1 << NFT_RULE_ATTR_FLAGS))
-			return &r->rule_flags;
-		else
-			return NULL;
-		break;
+		return &r->rule_flags;
 	case NFT_RULE_ATTR_COMPAT_PROTO:
-		if (r->flags & (1 << NFT_RULE_ATTR_COMPAT_PROTO))
-			return &r->compat.proto;
-		else
-			return NULL;
-		break;
+		return &r->compat.proto;
 	case NFT_RULE_ATTR_COMPAT_FLAGS:
-		if (r->flags & (1 << NFT_RULE_ATTR_COMPAT_FLAGS))
-			return &r->compat.flags;
-		else
-			return NULL;
-		break;
-	default:
-		return NULL;
+		return &r->compat.flags;
 	}
+	return NULL;
 }
 EXPORT_SYMBOL(nft_rule_attr_get);
 
diff --git a/src/set.c b/src/set.c
index 1ccfd23..bfcb0eb 100644
--- a/src/set.c
+++ b/src/set.c
@@ -148,41 +148,26 @@ EXPORT_SYMBOL(nft_set_attr_set_str);
 
 void *nft_set_attr_get(struct nft_set *s, uint16_t attr)
 {
+	if (!(s->flags & (1 << attr)))
+		return NULL;
+
 	switch(attr) {
 	case NFT_SET_ATTR_TABLE:
-		if (s->flags & (1 << NFT_SET_ATTR_TABLE))
-			return s->table;
-		break;
+		return s->table;
 	case NFT_SET_ATTR_NAME:
-		if (s->flags & (1 << NFT_SET_ATTR_NAME))
-			return s->name;
-		break;
+		return s->name;
 	case NFT_SET_ATTR_FLAGS:
-		if (s->flags & (1 << NFT_SET_ATTR_FLAGS))
-			return &s->set_flags;
-		break;
+		return &s->set_flags;
 	case NFT_SET_ATTR_KEY_TYPE:
-		if (s->flags & (1 << NFT_SET_ATTR_KEY_TYPE))
-			return &s->key_type;
-		break;
+		return &s->key_type;
 	case NFT_SET_ATTR_KEY_LEN:
-		if (s->flags & (1 << NFT_SET_ATTR_KEY_LEN))
-			return &s->key_len;
-		break;
+		return &s->key_len;
 	case NFT_SET_ATTR_DATA_TYPE:
-		if (s->flags & (1 << NFT_SET_ATTR_DATA_TYPE))
-			return &s->data_type;
-		break;
+		return &s->data_type;
 	case NFT_SET_ATTR_DATA_LEN:
-		if (s->flags & (1 << NFT_SET_ATTR_DATA_LEN))
-			return &s->data_len;
-		break;
+		return &s->data_len;
 	case NFT_SET_ATTR_FAMILY:
-		if (s->flags & (1 << NFT_SET_ATTR_FAMILY))
-			return &s->family;
-		break;
-	default:
-		break;
+		return &s->family;
 	}
 	return NULL;
 }
diff --git a/src/set_elem.c b/src/set_elem.c
index eeab726..e95a872 100644
--- a/src/set_elem.c
+++ b/src/set_elem.c
@@ -120,33 +120,22 @@ EXPORT_SYMBOL(nft_set_elem_attr_set_str);
 
 void *nft_set_elem_attr_get(struct nft_set_elem *s, uint16_t attr, size_t *data_len)
 {
+	if (!(s->flags & (1 << attr)))
+		return NULL;
+
 	switch(attr) {
 	case NFT_SET_ELEM_ATTR_FLAGS:
-		if (s->flags & (1 << NFT_SET_ELEM_ATTR_FLAGS))
-			return &s->set_elem_flags;
-		break;
+		return &s->set_elem_flags;
 	case NFT_SET_ELEM_ATTR_KEY:	/* NFTA_SET_ELEM_KEY */
-		if (s->flags & (1 << NFT_SET_ELEM_ATTR_KEY)) {
-			*data_len = s->key.len;
-			return &s->key.val;
-		}
-		break;
+		*data_len = s->key.len;
+		return &s->key.val;
 	case NFT_SET_ELEM_ATTR_VERDICT:	/* NFTA_SET_ELEM_DATA */
-		if (s->flags & (1 << NFT_SET_ELEM_ATTR_VERDICT))
-			return &s->data.verdict;
-		break;
+		return &s->data.verdict;
 	case NFT_SET_ELEM_ATTR_CHAIN:	/* NFTA_SET_ELEM_DATA */
-		if (s->flags & (1 << NFT_SET_ELEM_ATTR_CHAIN))
-			return s->data.chain;
-		break;
+		return s->data.chain;
 	case NFT_SET_ELEM_ATTR_DATA:	/* NFTA_SET_ELEM_DATA */
-		if (s->flags & (1 << NFT_SET_ELEM_ATTR_DATA)) {
-			*data_len = s->data.len;
-			return &s->data.val;
-		}
-		break;
-	default:
-		break;
+		*data_len = s->data.len;
+		return &s->data.val;
 	}
 	return NULL;
 }
diff --git a/src/table.c b/src/table.c
index bdab178..e1dbd38 100644
--- a/src/table.c
+++ b/src/table.c
@@ -1,5 +1,5 @@
 /*
- * (C) 2012 by Pablo Neira Ayuso <pablo@netfilter.org>
+ * (C) 2012-2013 by Pablo Neira Ayuso <pablo@netfilter.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published
@@ -112,23 +112,18 @@ EXPORT_SYMBOL(nft_table_attr_set_str);
 
 const void *nft_table_attr_get(struct nft_table *t, uint16_t attr)
 {
-	const void *ret = NULL;
+	if (!(t->flags & (1 << attr)))
+		return NULL;
 
 	switch(attr) {
 	case NFT_TABLE_ATTR_NAME:
-		if (t->flags & (1 << NFT_TABLE_ATTR_NAME))
-			ret = t->name;
-		break;
+		return t->name;
 	case NFT_TABLE_ATTR_FLAGS:
-		if (t->flags & (1 << NFT_TABLE_ATTR_FLAGS))
-			ret = &t->table_flags;
-		break;
+		return &t->table_flags;
 	case NFT_TABLE_ATTR_FAMILY:
-		if (t->flags & (1 << NFT_TABLE_ATTR_FAMILY))
-			ret = &t->family;
-		break;
+		return &t->family;
 	}
-	return ret;
+	return NULL;
 }
 EXPORT_SYMBOL(nft_table_attr_get);