From 6cdc49ffbe0a672c27f4fffe831563b12a8e2e61 Mon Sep 17 00:00:00 2001 From: Pablo Neira Ayuso Date: Thu, 18 Jul 2013 20:01:27 +0200 Subject: 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 --- src/chain.c | 73 ++++++++++++---------------------------------------- src/expr.c | 3 +++ src/expr/bitwise.c | 37 +++++++------------------- src/expr/byteorder.c | 37 +++++++------------------- src/expr/cmp.c | 26 +++++-------------- src/expr/counter.c | 18 +++---------- src/expr/ct.c | 26 +++++-------------- src/expr/exthdr.c | 34 ++++++------------------ src/expr/immediate.c | 34 ++++++------------------ src/expr/limit.c | 18 +++---------- src/expr/log.c | 26 +++---------------- src/expr/lookup.c | 20 ++++---------- src/expr/match.c | 26 +++++-------------- src/expr/meta.c | 18 +++---------- src/expr/nat.c | 45 +++++++++----------------------- src/expr/payload.c | 34 ++++++------------------ src/expr/target.c | 26 +++++-------------- src/rule.c | 49 +++++++++-------------------------- src/set.c | 37 ++++++++------------------ src/set_elem.c | 31 +++++++--------------- src/table.c | 19 +++++--------- 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 + * (C) 2012-2013 by Pablo Neira Ayuso * * 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 + * (C) 2012-2013 by Pablo Neira Ayuso * * 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 + * (C) 2012-2013 by Pablo Neira Ayuso * * 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); -- cgit v1.2.3