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>

diff --git a/src/chain.c b/src/chain.c
index 3c73511c0698ccf2682f186451ae3b1c6160a60a..0c7f422cec1453045c21ba7262555aa3acabacb6 100644 (file)
--- 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 711c18ec8fcae177c9a5f552f9e137b17811c9dd..d2d345ca05238334a999c4e6aa947b218d862d90 100644 (file)
--- 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 bfb31639ed3bfedf149812997235ea2a797548b8..84de249d13a3d47be1c31d645f467ab096fa0684 100644 (file)
--- 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 2326961b5202dcbd42d216ede167ccffce9183da..e3b9a5ec726ba9cedd43b4b1a2f58fa6807acf33 100644 (file)
--- 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 2fa9bf52192ddc4e939cdb615259e2d7eb449d56..cbc08ecb4eafd5cbe6956f0b398d6d941da74ce1 100644 (file)
--- 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 8521a226bce556cbcb3986c3c3562d3a2c62f62b..8b2542dcce207c9f80077a42d49b8da63133f09c 100644 (file)
--- 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 fedb1f2ee7473093f440c0dd19cafa8c8ce85ee5..f3992198a1d438c7983fdf71178a20b8ea51533c 100644 (file)
--- 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 5fd25500e2809a336be81784c0f4ffd9560b71b7..51e784e0394b2cf8954defa2cd216f3734d84f27 100644 (file)
--- 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 81777661fde7accf3a03bee89584b590364bc9d4..48e9d1ea5d0ae9c9eb2037167d0c934b0d030d9b 100644 (file)
--- 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 3a0d5a016736806be9f9fedfd0184ec63566b031..2ecf7cb57e9910e3ef181b358435187a15a75b79 100644 (file)
--- 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 b2c39c1601adde546ac24cd4b5dbc5c7d24f7a79..1ffd1d9589ceb94d8e47870d13a44c6bfa2c9512 100644 (file)
--- 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 027f1b54f411b643786adec355798d1e95bef0b5..b9a803ebd2e2233dcadc542f524072f43de2a457 100644 (file)
--- 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 ee894a1f414047f66cf5ee2dc3b4fce863ca764b..d7d9c5b2736d16794da08dfbfdcf459b34df51d5 100644 (file)
--- 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 6b19764bf4d70d720a27194b05826e6a46cc4bde..4a7a83ae95d4b94da38892b15bb1bd081f003efc 100644 (file)
--- 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 78184c48354fe8c0bdf10d6be2bb80810352444e..ce8d5e26c33e71ec06f55a44c5b9dd9c69053316 100644 (file)
--- 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 d856f2ea3b25f28a9ac7fc63d1ed9816d214e56c..98536080f2c761728febc9ed2e14771c1de73251 100644 (file)
--- 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 d9d9daf2823b33708164c2349b42d676abef96f1..6365a4644e589e199feee6267dc08e77d4fc4ed9 100644 (file)
--- 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 df9d739cb3c861f18b40c7d7c26efa6dd0a88d47..9a93f335898abfd155cac58a9c087aca551f8765 100644 (file)
--- 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 1ccfd2335cc11e7ab66ac60e7068caf131eec0ae..bfcb0eb54c9286903bafa45e38c3e7b38811b0a5 100644 (file)
--- 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 eeab726a28d12fb7720d22380541fa1c83d6d58d..e95a872a17721a118df59f315f4d6f126fe2b577 100644 (file)
--- 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 bdab178c868ec9fd40dd2da8349e70a8b69fb767..e1dbd381a2b4b493c45f978581550e9a1400bf68 100644 (file)
--- 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);