netfilter: nftables: add nft_parse_register_store() and use it

This new function combines the netlink register attribute parser
and the store validation function.

This update requires to replace:

        enum nft_registers      dreg:8;

in many of the expression private areas otherwise compiler complains
with:

        error: cannot take address of bit-field ‘dreg’

when passing the register field as reference.

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

diff --git a/include/net/netfilter/nf_tables.h b/include/net/netfilter/nf_tables.h
index 033b31aa38ccf31e866e9baf9de3724c05d3e1a7..78d174517749ad4ed1832230117a47ba5ffde59d 100644 (file)
--- a/include/net/netfilter/nf_tables.h
+++ b/include/net/netfilter/nf_tables.h
@@ -204,10 +204,10 @@ unsigned int nft_parse_register(const struct nlattr *attr);
 int nft_dump_register(struct sk_buff *skb, unsigned int attr, unsigned int reg);
 
 int nft_parse_register_load(const struct nlattr *attr, u8 *sreg, u32 len);
-int nft_validate_register_store(const struct nft_ctx *ctx,
-                               enum nft_registers reg,
-                               const struct nft_data *data,
-                               enum nft_data_types type, unsigned int len);
+int nft_parse_register_store(const struct nft_ctx *ctx,
+                            const struct nlattr *attr, u8 *dreg,
+                            const struct nft_data *data,
+                            enum nft_data_types type, unsigned int len);
 
 /**
  *     struct nft_userdata - user defined data associated with an object

diff --git a/include/net/netfilter/nf_tables_core.h b/include/net/netfilter/nf_tables_core.h
index b7aff03a3f0f9630f2ec7ca76a2479a49ebac6cd..fd10a7862fdc6db444ad617bb91120812c40cd95 100644 (file)
--- a/include/net/netfilter/nf_tables_core.h
+++ b/include/net/netfilter/nf_tables_core.h
@@ -27,7 +27,7 @@ struct nft_bitwise_fast_expr {
        u32                     mask;
        u32                     xor;
        u8                      sreg;
-       enum nft_registers      dreg:8;
+       u8                      dreg;
 };
 
 struct nft_cmp_fast_expr {
@@ -40,7 +40,7 @@ struct nft_cmp_fast_expr {
 
 struct nft_immediate_expr {
        struct nft_data         data;
-       enum nft_registers      dreg:8;
+       u8                      dreg;
        u8                      dlen;
 };
 
@@ -60,7 +60,7 @@ struct nft_payload {
        enum nft_payload_bases  base:8;
        u8                      offset;
        u8                      len;
-       enum nft_registers      dreg:8;
+       u8                      dreg;
 };
 
 struct nft_payload_set {

diff --git a/include/net/netfilter/nft_fib.h b/include/net/netfilter/nft_fib.h
index 628b6fa579cd889c681a1d68255d1ac106b17349..237f3757637e15c9d903855d902f57a214d1931c 100644 (file)
--- a/include/net/netfilter/nft_fib.h
+++ b/include/net/netfilter/nft_fib.h
@@ -5,7 +5,7 @@
 #include <net/netfilter/nf_tables.h>
 
 struct nft_fib {
-       enum nft_registers      dreg:8;
+       u8                      dreg;
        u8                      result;
        u32                     flags;
 };

diff --git a/include/net/netfilter/nft_meta.h b/include/net/netfilter/nft_meta.h
index 946fa8c83798ed3902155077d8a39c7ee51c8887..2dce55c736f400ede2bb121e739be1718787b85d 100644 (file)
--- a/include/net/netfilter/nft_meta.h
+++ b/include/net/netfilter/nft_meta.h
@@ -7,7 +7,7 @@
 struct nft_meta {
        enum nft_meta_keys      key:8;
        union {
-               enum nft_registers      dreg:8;
+               u8              dreg;
                u8              sreg;
        };
 };

diff --git a/net/bridge/netfilter/nft_meta_bridge.c b/net/bridge/netfilter/nft_meta_bridge.c
index 8e8ffac037cd4805e36e982e7b1cac2d16ddf3ac..97805ec424c1996f8e0286a096f3205b644bd8a5 100644 (file)
--- a/net/bridge/netfilter/nft_meta_bridge.c
+++ b/net/bridge/netfilter/nft_meta_bridge.c
@@ -87,9 +87,8 @@ static int nft_meta_bridge_get_init(const struct nft_ctx *ctx,
                return nft_meta_get_init(ctx, expr, tb);
        }
 
-       priv->dreg = nft_parse_register(tb[NFTA_META_DREG]);
-       return nft_validate_register_store(ctx, priv->dreg, NULL,
-                                          NFT_DATA_VALUE, len);
+       return nft_parse_register_store(ctx, tb[NFTA_META_DREG], &priv->dreg,
+                                       NULL, NFT_DATA_VALUE, len);
 }
 
 static struct nft_expr_type nft_meta_bridge_type;

diff --git a/net/netfilter/nf_tables_api.c b/net/netfilter/nf_tables_api.c
index 1e82ebba230dc10e06767d2a5b9c2aa55f0c133e..c23163ffb5a1f751cc273ed807f715e6e00d1ca7 100644 (file)
--- a/net/netfilter/nf_tables_api.c
+++ b/net/netfilter/nf_tables_api.c
@@ -4438,6 +4438,12 @@ static int nf_tables_delset(struct net *net, struct sock *nlsk,
        return nft_delset(&ctx, set);
 }
 
+static int nft_validate_register_store(const struct nft_ctx *ctx,
+                                      enum nft_registers reg,
+                                      const struct nft_data *data,
+                                      enum nft_data_types type,
+                                      unsigned int len);
+
 static int nf_tables_bind_check_setelem(const struct nft_ctx *ctx,
                                        struct nft_set *set,
                                        const struct nft_set_iter *iter,
@@ -8675,10 +8681,11 @@ EXPORT_SYMBOL_GPL(nft_parse_register_load);
  *     A value of NULL for the data means that its runtime gathered
  *     data.
  */
-int nft_validate_register_store(const struct nft_ctx *ctx,
-                               enum nft_registers reg,
-                               const struct nft_data *data,
-                               enum nft_data_types type, unsigned int len)
+static int nft_validate_register_store(const struct nft_ctx *ctx,
+                                      enum nft_registers reg,
+                                      const struct nft_data *data,
+                                      enum nft_data_types type,
+                                      unsigned int len)
 {
        int err;
 
@@ -8710,7 +8717,24 @@ int nft_validate_register_store(const struct nft_ctx *ctx,
                return 0;
        }
 }
-EXPORT_SYMBOL_GPL(nft_validate_register_store);
+
+int nft_parse_register_store(const struct nft_ctx *ctx,
+                            const struct nlattr *attr, u8 *dreg,
+                            const struct nft_data *data,
+                            enum nft_data_types type, unsigned int len)
+{
+       int err;
+       u32 reg;
+
+       reg = nft_parse_register(attr);
+       err = nft_validate_register_store(ctx, reg, data, type, len);
+       if (err < 0)
+               return err;
+
+       *dreg = reg;
+       return 0;
+}
+EXPORT_SYMBOL_GPL(nft_parse_register_store);
 
 static const struct nla_policy nft_verdict_policy[NFTA_VERDICT_MAX + 1] = {
        [NFTA_VERDICT_CODE]     = { .type = NLA_U32 },

diff --git a/net/netfilter/nft_bitwise.c b/net/netfilter/nft_bitwise.c
index 2157970b3cd37b17d976671c74ecb3e76d2cc46c..47b0dba95054f0877037a392503e89ced02201a8 100644 (file)
--- a/net/netfilter/nft_bitwise.c
+++ b/net/netfilter/nft_bitwise.c
@@ -17,7 +17,7 @@
 
 struct nft_bitwise {
        u8                      sreg;
-       enum nft_registers      dreg:8;
+       u8                      dreg;
        enum nft_bitwise_ops    op:8;
        u8                      len;
        struct nft_data         mask;
@@ -174,9 +174,9 @@ static int nft_bitwise_init(const struct nft_ctx *ctx,
        if (err < 0)
                return err;
 
-       priv->dreg = nft_parse_register(tb[NFTA_BITWISE_DREG]);
-       err = nft_validate_register_store(ctx, priv->dreg, NULL,
-                                         NFT_DATA_VALUE, priv->len);
+       err = nft_parse_register_store(ctx, tb[NFTA_BITWISE_DREG],
+                                      &priv->dreg, NULL, NFT_DATA_VALUE,
+                                      priv->len);
        if (err < 0)
                return err;
 
@@ -320,9 +320,8 @@ static int nft_bitwise_fast_init(const struct nft_ctx *ctx,
        if (err < 0)
                return err;
 
-       priv->dreg = nft_parse_register(tb[NFTA_BITWISE_DREG]);
-       err = nft_validate_register_store(ctx, priv->dreg, NULL,
-                                         NFT_DATA_VALUE, sizeof(u32));
+       err = nft_parse_register_store(ctx, tb[NFTA_BITWISE_DREG], &priv->dreg,
+                                      NULL, NFT_DATA_VALUE, sizeof(u32));
        if (err < 0)
                return err;
 

diff --git a/net/netfilter/nft_byteorder.c b/net/netfilter/nft_byteorder.c
index 0960563cd5a19f873dbac184a3116ba8c259e8ba..9d5947ab8d4ef33531dd82fa42057d24273f1260 100644 (file)
--- a/net/netfilter/nft_byteorder.c
+++ b/net/netfilter/nft_byteorder.c
@@ -17,7 +17,7 @@
 
 struct nft_byteorder {
        u8                      sreg;
-       enum nft_registers      dreg:8;
+       u8                      dreg;
        enum nft_byteorder_ops  op:8;
        u8                      len;
        u8                      size;
@@ -142,9 +142,9 @@ static int nft_byteorder_init(const struct nft_ctx *ctx,
        if (err < 0)
                return err;
 
-       priv->dreg = nft_parse_register(tb[NFTA_BYTEORDER_DREG]);
-       return nft_validate_register_store(ctx, priv->dreg, NULL,
-                                          NFT_DATA_VALUE, priv->len);
+       return nft_parse_register_store(ctx, tb[NFTA_BYTEORDER_DREG],
+                                       &priv->dreg, NULL, NFT_DATA_VALUE,
+                                       priv->len);
 }
 
 static int nft_byteorder_dump(struct sk_buff *skb, const struct nft_expr *expr)

diff --git a/net/netfilter/nft_ct.c b/net/netfilter/nft_ct.c
index c1d7a3c615d8e19274c31ede02b58b9218ab90aa..882fe8648653deaf84b4334f39afd7f1d39028a4 100644 (file)
--- a/net/netfilter/nft_ct.c
+++ b/net/netfilter/nft_ct.c
@@ -27,7 +27,7 @@ struct nft_ct {
        enum nft_ct_keys        key:8;
        enum ip_conntrack_dir   dir:8;
        union {
-               enum nft_registers      dreg:8;
+               u8              dreg;
                u8              sreg;
        };
 };
@@ -498,9 +498,8 @@ static int nft_ct_get_init(const struct nft_ctx *ctx,
                }
        }
 
-       priv->dreg = nft_parse_register(tb[NFTA_CT_DREG]);
-       err = nft_validate_register_store(ctx, priv->dreg, NULL,
-                                         NFT_DATA_VALUE, len);
+       err = nft_parse_register_store(ctx, tb[NFTA_CT_DREG], &priv->dreg, NULL,
+                                      NFT_DATA_VALUE, len);
        if (err < 0)
                return err;
 

diff --git a/net/netfilter/nft_exthdr.c b/net/netfilter/nft_exthdr.c
index 9c2b3bde1ac9a2248206b4a8ed57c243067a5fd2..f64f0017e9a530bca0e4f100e2f6a6f27349074c 100644 (file)
--- a/net/netfilter/nft_exthdr.c
+++ b/net/netfilter/nft_exthdr.c
@@ -19,7 +19,7 @@ struct nft_exthdr {
        u8                      offset;
        u8                      len;
        u8                      op;
-       enum nft_registers      dreg:8;
+       u8                      dreg;
        u8                      sreg;
        u8                      flags;
 };
@@ -350,12 +350,12 @@ static int nft_exthdr_init(const struct nft_ctx *ctx,
        priv->type   = nla_get_u8(tb[NFTA_EXTHDR_TYPE]);
        priv->offset = offset;
        priv->len    = len;
-       priv->dreg   = nft_parse_register(tb[NFTA_EXTHDR_DREG]);
        priv->flags  = flags;
        priv->op     = op;
 
-       return nft_validate_register_store(ctx, priv->dreg, NULL,
-                                          NFT_DATA_VALUE, priv->len);
+       return nft_parse_register_store(ctx, tb[NFTA_EXTHDR_DREG],
+                                       &priv->dreg, NULL, NFT_DATA_VALUE,
+                                       priv->len);
 }
 
 static int nft_exthdr_tcp_set_init(const struct nft_ctx *ctx,

diff --git a/net/netfilter/nft_fib.c b/net/netfilter/nft_fib.c
index 4dfdaeaf09a5bf7cc4a70910398bc5dce7a1580e..b10ce732b337c66e75fe51d75a56cae4b5b6f142 100644 (file)
--- a/net/netfilter/nft_fib.c
+++ b/net/netfilter/nft_fib.c
@@ -86,7 +86,6 @@ int nft_fib_init(const struct nft_ctx *ctx, const struct nft_expr *expr,
                return -EINVAL;
 
        priv->result = ntohl(nla_get_be32(tb[NFTA_FIB_RESULT]));
-       priv->dreg = nft_parse_register(tb[NFTA_FIB_DREG]);
 
        switch (priv->result) {
        case NFT_FIB_RESULT_OIF:
@@ -106,8 +105,8 @@ int nft_fib_init(const struct nft_ctx *ctx, const struct nft_expr *expr,
                return -EINVAL;
        }
 
-       err = nft_validate_register_store(ctx, priv->dreg, NULL,
-                                         NFT_DATA_VALUE, len);
+       err = nft_parse_register_store(ctx, tb[NFTA_FIB_DREG], &priv->dreg,
+                                      NULL, NFT_DATA_VALUE, len);
        if (err < 0)
                return err;
 

diff --git a/net/netfilter/nft_hash.c b/net/netfilter/nft_hash.c
index 7ee6c6da50ae9463bd4bf06326d4d81fc968eafd..f829f5289e162358faf9e15d2de1aa1ae6fd0a0e 100644 (file)
--- a/net/netfilter/nft_hash.c
+++ b/net/netfilter/nft_hash.c
@@ -15,7 +15,7 @@
 
 struct nft_jhash {
        u8                      sreg;
-       enum nft_registers      dreg:8;
+       u8                      dreg;
        u8                      len;
        bool                    autogen_seed:1;
        u32                     modulus;
@@ -38,7 +38,7 @@ static void nft_jhash_eval(const struct nft_expr *expr,
 }
 
 struct nft_symhash {
-       enum nft_registers      dreg:8;
+       u8                      dreg;
        u32                     modulus;
        u32                     offset;
 };
@@ -83,8 +83,6 @@ static int nft_jhash_init(const struct nft_ctx *ctx,
        if (tb[NFTA_HASH_OFFSET])
                priv->offset = ntohl(nla_get_be32(tb[NFTA_HASH_OFFSET]));
 
-       priv->dreg = nft_parse_register(tb[NFTA_HASH_DREG]);
-
        err = nft_parse_u32_check(tb[NFTA_HASH_LEN], U8_MAX, &len);
        if (err < 0)
                return err;
@@ -111,8 +109,8 @@ static int nft_jhash_init(const struct nft_ctx *ctx,
                get_random_bytes(&priv->seed, sizeof(priv->seed));
        }
 
-       return nft_validate_register_store(ctx, priv->dreg, NULL,
-                                          NFT_DATA_VALUE, sizeof(u32));
+       return nft_parse_register_store(ctx, tb[NFTA_HASH_DREG], &priv->dreg,
+                                       NULL, NFT_DATA_VALUE, sizeof(u32));
 }
 
 static int nft_symhash_init(const struct nft_ctx *ctx,
@@ -128,8 +126,6 @@ static int nft_symhash_init(const struct nft_ctx *ctx,
        if (tb[NFTA_HASH_OFFSET])
                priv->offset = ntohl(nla_get_be32(tb[NFTA_HASH_OFFSET]));
 
-       priv->dreg = nft_parse_register(tb[NFTA_HASH_DREG]);
-
        priv->modulus = ntohl(nla_get_be32(tb[NFTA_HASH_MODULUS]));
        if (priv->modulus < 1)
                return -ERANGE;
@@ -137,8 +133,9 @@ static int nft_symhash_init(const struct nft_ctx *ctx,
        if (priv->offset + priv->modulus - 1 < priv->offset)
                return -EOVERFLOW;
 
-       return nft_validate_register_store(ctx, priv->dreg, NULL,
-                                          NFT_DATA_VALUE, sizeof(u32));
+       return nft_parse_register_store(ctx, tb[NFTA_HASH_DREG],
+                                       &priv->dreg, NULL, NFT_DATA_VALUE,
+                                       sizeof(u32));
 }
 
 static int nft_jhash_dump(struct sk_buff *skb,

diff --git a/net/netfilter/nft_immediate.c b/net/netfilter/nft_immediate.c
index c63eb3b171784bcf82ea32ed676a657bd9177472..90c64d27ae53228a1c0fe3acbd40aa5ba288a7b6 100644 (file)
--- a/net/netfilter/nft_immediate.c
+++ b/net/netfilter/nft_immediate.c
@@ -48,9 +48,9 @@ static int nft_immediate_init(const struct nft_ctx *ctx,
 
        priv->dlen = desc.len;
 
-       priv->dreg = nft_parse_register(tb[NFTA_IMMEDIATE_DREG]);
-       err = nft_validate_register_store(ctx, priv->dreg, &priv->data,
-                                         desc.type, desc.len);
+       err = nft_parse_register_store(ctx, tb[NFTA_IMMEDIATE_DREG],
+                                      &priv->dreg, &priv->data, desc.type,
+                                      desc.len);
        if (err < 0)
                goto err1;
 

diff --git a/net/netfilter/nft_lookup.c b/net/netfilter/nft_lookup.c
index 9e87b6d39f517cb023b58a33767f73153dc2037f..b0f558b4fea5410184d639501c8cea9578bcc862 100644 (file)
--- a/net/netfilter/nft_lookup.c
+++ b/net/netfilter/nft_lookup.c
@@ -18,7 +18,7 @@
 struct nft_lookup {
        struct nft_set                  *set;
        u8                              sreg;
-       enum nft_registers              dreg:8;
+       u8                              dreg;
        bool                            invert;
        struct nft_set_binding          binding;
 };
@@ -100,9 +100,9 @@ static int nft_lookup_init(const struct nft_ctx *ctx,
                if (!(set->flags & NFT_SET_MAP))
                        return -EINVAL;
 
-               priv->dreg = nft_parse_register(tb[NFTA_LOOKUP_DREG]);
-               err = nft_validate_register_store(ctx, priv->dreg, NULL,
-                                                 set->dtype, set->dlen);
+               err = nft_parse_register_store(ctx, tb[NFTA_LOOKUP_DREG],
+                                              &priv->dreg, NULL, set->dtype,
+                                              set->dlen);
                if (err < 0)
                        return err;
        } else if (set->flags & NFT_SET_MAP)

diff --git a/net/netfilter/nft_meta.c b/net/netfilter/nft_meta.c
index 65e231ec1884e962fd772843d1699c5f104032a8..a7e01e9952f17132140892f84799cd2effc2c48f 100644 (file)
--- a/net/netfilter/nft_meta.c
+++ b/net/netfilter/nft_meta.c
@@ -535,9 +535,8 @@ int nft_meta_get_init(const struct nft_ctx *ctx,
                return -EOPNOTSUPP;
        }
 
-       priv->dreg = nft_parse_register(tb[NFTA_META_DREG]);
-       return nft_validate_register_store(ctx, priv->dreg, NULL,
-                                          NFT_DATA_VALUE, len);
+       return nft_parse_register_store(ctx, tb[NFTA_META_DREG], &priv->dreg,
+                                       NULL, NFT_DATA_VALUE, len);
 }
 EXPORT_SYMBOL_GPL(nft_meta_get_init);
 

diff --git a/net/netfilter/nft_numgen.c b/net/netfilter/nft_numgen.c
index f1fc824f973704f045b9a73e51869af10b6de131..722cac1e90e0e39a0f17ab653644ce89463ed2c7 100644 (file)
--- a/net/netfilter/nft_numgen.c
+++ b/net/netfilter/nft_numgen.c
@@ -16,7 +16,7 @@
 static DEFINE_PER_CPU(struct rnd_state, nft_numgen_prandom_state);
 
 struct nft_ng_inc {
-       enum nft_registers      dreg:8;
+       u8                      dreg;
        u32                     modulus;
        atomic_t                counter;
        u32                     offset;
@@ -66,11 +66,10 @@ static int nft_ng_inc_init(const struct nft_ctx *ctx,
        if (priv->offset + priv->modulus - 1 < priv->offset)
                return -EOVERFLOW;
 
-       priv->dreg = nft_parse_register(tb[NFTA_NG_DREG]);
        atomic_set(&priv->counter, priv->modulus - 1);
 
-       return nft_validate_register_store(ctx, priv->dreg, NULL,
-                                          NFT_DATA_VALUE, sizeof(u32));
+       return nft_parse_register_store(ctx, tb[NFTA_NG_DREG], &priv->dreg,
+                                       NULL, NFT_DATA_VALUE, sizeof(u32));
 }
 
 static int nft_ng_dump(struct sk_buff *skb, enum nft_registers dreg,
@@ -100,7 +99,7 @@ static int nft_ng_inc_dump(struct sk_buff *skb, const struct nft_expr *expr)
 }
 
 struct nft_ng_random {
-       enum nft_registers      dreg:8;
+       u8                      dreg;
        u32                     modulus;
        u32                     offset;
 };
@@ -140,10 +139,8 @@ static int nft_ng_random_init(const struct nft_ctx *ctx,
 
        prandom_init_once(&nft_numgen_prandom_state);
 
-       priv->dreg = nft_parse_register(tb[NFTA_NG_DREG]);
-
-       return nft_validate_register_store(ctx, priv->dreg, NULL,
-                                          NFT_DATA_VALUE, sizeof(u32));
+       return nft_parse_register_store(ctx, tb[NFTA_NG_DREG], &priv->dreg,
+                                       NULL, NFT_DATA_VALUE, sizeof(u32));
 }
 
 static int nft_ng_random_dump(struct sk_buff *skb, const struct nft_expr *expr)

diff --git a/net/netfilter/nft_osf.c b/net/netfilter/nft_osf.c
index c261d57a666ab6b70ff87246a4ce0b6b53433e67..ac61f708b82d23986683130ad2346a148e982d60 100644 (file)
--- a/net/netfilter/nft_osf.c
+++ b/net/netfilter/nft_osf.c
@@ -6,7 +6,7 @@
 #include <linux/netfilter/nfnetlink_osf.h>
 
 struct nft_osf {
-       enum nft_registers      dreg:8;
+       u8                      dreg;
        u8                      ttl;
        u32                     flags;
 };
@@ -78,9 +78,9 @@ static int nft_osf_init(const struct nft_ctx *ctx,
                priv->flags = flags;
        }
 
-       priv->dreg = nft_parse_register(tb[NFTA_OSF_DREG]);
-       err = nft_validate_register_store(ctx, priv->dreg, NULL,
-                                         NFT_DATA_VALUE, NFT_OSF_MAXGENRELEN);
+       err = nft_parse_register_store(ctx, tb[NFTA_OSF_DREG], &priv->dreg,
+                                      NULL, NFT_DATA_VALUE,
+                                      NFT_OSF_MAXGENRELEN);
        if (err < 0)
                return err;
 

diff --git a/net/netfilter/nft_payload.c b/net/netfilter/nft_payload.c
index d4e88db4116df9381ed21eb7465b4ab231152733..cb1c8c2318803297aa50f9ed187a0a57dfb10e73 100644 (file)
--- a/net/netfilter/nft_payload.c
+++ b/net/netfilter/nft_payload.c
@@ -144,10 +144,10 @@ static int nft_payload_init(const struct nft_ctx *ctx,
        priv->base   = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_BASE]));
        priv->offset = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_OFFSET]));
        priv->len    = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_LEN]));
-       priv->dreg   = nft_parse_register(tb[NFTA_PAYLOAD_DREG]);
 
-       return nft_validate_register_store(ctx, priv->dreg, NULL,
-                                          NFT_DATA_VALUE, priv->len);
+       return nft_parse_register_store(ctx, tb[NFTA_PAYLOAD_DREG],
+                                       &priv->dreg, NULL, NFT_DATA_VALUE,
+                                       priv->len);
 }
 
 static int nft_payload_dump(struct sk_buff *skb, const struct nft_expr *expr)

diff --git a/net/netfilter/nft_rt.c b/net/netfilter/nft_rt.c
index 7cfcb0e2f7ee1a5e3a72f930653f038e51d59a6f..bcd01a63e38f1bdb423cc9be816d3612beb533e6 100644 (file)
--- a/net/netfilter/nft_rt.c
+++ b/net/netfilter/nft_rt.c
@@ -15,7 +15,7 @@
 
 struct nft_rt {
        enum nft_rt_keys        key:8;
-       enum nft_registers      dreg:8;
+       u8                      dreg;
 };
 
 static u16 get_tcpmss(const struct nft_pktinfo *pkt, const struct dst_entry *skbdst)
@@ -141,9 +141,8 @@ static int nft_rt_get_init(const struct nft_ctx *ctx,
                return -EOPNOTSUPP;
        }
 
-       priv->dreg = nft_parse_register(tb[NFTA_RT_DREG]);
-       return nft_validate_register_store(ctx, priv->dreg, NULL,
-                                          NFT_DATA_VALUE, len);
+       return nft_parse_register_store(ctx, tb[NFTA_RT_DREG], &priv->dreg,
+                                       NULL, NFT_DATA_VALUE, len);
 }
 
 static int nft_rt_get_dump(struct sk_buff *skb,

diff --git a/net/netfilter/nft_socket.c b/net/netfilter/nft_socket.c
index a28aca5124cefb8dd7779ed031039814f94fce28..c9b8a2b03b71325b04d2f3d6b62eb4adf8311812 100644 (file)
--- a/net/netfilter/nft_socket.c
+++ b/net/netfilter/nft_socket.c
@@ -10,7 +10,7 @@
 struct nft_socket {
        enum nft_socket_keys            key:8;
        union {
-               enum nft_registers      dreg:8;
+               u8                      dreg;
        };
 };
 
@@ -133,9 +133,8 @@ static int nft_socket_init(const struct nft_ctx *ctx,
                return -EOPNOTSUPP;
        }
 
-       priv->dreg = nft_parse_register(tb[NFTA_SOCKET_DREG]);
-       return nft_validate_register_store(ctx, priv->dreg, NULL,
-                                          NFT_DATA_VALUE, len);
+       return nft_parse_register_store(ctx, tb[NFTA_SOCKET_DREG], &priv->dreg,
+                                       NULL, NFT_DATA_VALUE, len);
 }
 
 static int nft_socket_dump(struct sk_buff *skb,

diff --git a/net/netfilter/nft_tunnel.c b/net/netfilter/nft_tunnel.c
index d3eb953d0333b93e04a203a963406eff1cc2dbb9..3b27926d5382c3247911eb08bef4eb59ee826048 100644 (file)
--- a/net/netfilter/nft_tunnel.c
+++ b/net/netfilter/nft_tunnel.c
@@ -15,7 +15,7 @@
 
 struct nft_tunnel {
        enum nft_tunnel_keys    key:8;
-       enum nft_registers      dreg:8;
+       u8                      dreg;
        enum nft_tunnel_mode    mode:8;
 };
 
@@ -93,8 +93,6 @@ static int nft_tunnel_get_init(const struct nft_ctx *ctx,
                return -EOPNOTSUPP;
        }
 
-       priv->dreg = nft_parse_register(tb[NFTA_TUNNEL_DREG]);
-
        if (tb[NFTA_TUNNEL_MODE]) {
                priv->mode = ntohl(nla_get_be32(tb[NFTA_TUNNEL_MODE]));
                if (priv->mode > NFT_TUNNEL_MODE_MAX)
@@ -103,8 +101,8 @@ static int nft_tunnel_get_init(const struct nft_ctx *ctx,
                priv->mode = NFT_TUNNEL_MODE_NONE;
        }
 
-       return nft_validate_register_store(ctx, priv->dreg, NULL,
-                                          NFT_DATA_VALUE, len);
+       return nft_parse_register_store(ctx, tb[NFTA_TUNNEL_DREG], &priv->dreg,
+                                       NULL, NFT_DATA_VALUE, len);
 }
 
 static int nft_tunnel_get_dump(struct sk_buff *skb,

diff --git a/net/netfilter/nft_xfrm.c b/net/netfilter/nft_xfrm.c
index 06d5cabf1d7c4f3adbbe6a8d5a76d597277e1af4..cbbbc4ecad3aed11b584db94f6bc6543ce09fe34 100644 (file)
--- a/net/netfilter/nft_xfrm.c
+++ b/net/netfilter/nft_xfrm.c
@@ -24,7 +24,7 @@ static const struct nla_policy nft_xfrm_policy[NFTA_XFRM_MAX + 1] = {
 
 struct nft_xfrm {
        enum nft_xfrm_keys      key:8;
-       enum nft_registers      dreg:8;
+       u8                      dreg;
        u8                      dir;
        u8                      spnum;
 };
@@ -86,9 +86,8 @@ static int nft_xfrm_get_init(const struct nft_ctx *ctx,
 
        priv->spnum = spnum;
 
-       priv->dreg = nft_parse_register(tb[NFTA_XFRM_DREG]);
-       return nft_validate_register_store(ctx, priv->dreg, NULL,
-                                          NFT_DATA_VALUE, len);
+       return nft_parse_register_store(ctx, tb[NFTA_XFRM_DREG], &priv->dreg,
+                                       NULL, NFT_DATA_VALUE, len);
 }
 
 /* Return true if key asks for daddr/saddr and current