netfilter: nftables: add nft_parse_register_load() and use it

[ 4f16d25c68ec844299a4df6ecbb0234eaf88a935 ]

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

This update requires to replace:

	enum nft_registers      sreg:8;

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

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

when passing the register field as reference.

Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/include/net/netfilter/nf_tables.h b/include/net/netfilter/nf_tables.h
index 78f5f0426e6b6d5bd7208a8de21d8ae1b190285b..e7b1e241f6f6ed5a0337292655f30a366e73e429 100644 (file)
--- a/include/net/netfilter/nf_tables.h
+++ b/include/net/netfilter/nf_tables.h
@@ -194,7 +194,7 @@ int nft_parse_u32_check(const struct nlattr *attr, int max, u32 *dest);
 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_validate_register_load(enum nft_registers reg, unsigned int len);
+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,

diff --git a/include/net/netfilter/nf_tables_core.h b/include/net/netfilter/nf_tables_core.h
index 8da837d2aaf997d5d642b081154c1bf9d2b3b26b..c81c12a825de476a42c8e13d533145e2354e38a4 100644 (file)
--- a/include/net/netfilter/nf_tables_core.h
+++ b/include/net/netfilter/nf_tables_core.h
@@ -21,7 +21,8 @@ void nf_tables_core_module_exit(void);
 
 struct nft_cmp_fast_expr {
        u32                     data;
-       enum nft_registers      sreg:8;
+       u32                     mask;
+       u8                      sreg;
        u8                      len;
 };
 
@@ -54,7 +55,7 @@ struct nft_payload_set {
        enum nft_payload_bases  base:8;
        u8                      offset;
        u8                      len;
-       enum nft_registers      sreg:8;
+       u8                      sreg;
        u8                      csum_type;
        u8                      csum_offset;
        u8                      csum_flags;

diff --git a/include/net/netfilter/nft_masq.h b/include/net/netfilter/nft_masq.h
index e51ab3815797bef3d1c9377403959cded803e851..e69a8277b70b3005b854d7417d6a232c3a14d0cd 100644 (file)
--- a/include/net/netfilter/nft_masq.h
+++ b/include/net/netfilter/nft_masq.h
@@ -4,8 +4,8 @@
 
 struct nft_masq {
        u32                     flags;
-       enum nft_registers      sreg_proto_min:8;
-       enum nft_registers      sreg_proto_max:8;
+       u8                      sreg_proto_min;
+       u8                      sreg_proto_max;
 };
 
 extern const struct nla_policy nft_masq_policy[];

diff --git a/include/net/netfilter/nft_redir.h b/include/net/netfilter/nft_redir.h
index 4a970737c03c832fcbe20376cd0b8399dd9a81ff..2b4036c94cb3ee6a35bdcae1ff9cd5d39e688057 100644 (file)
--- a/include/net/netfilter/nft_redir.h
+++ b/include/net/netfilter/nft_redir.h
@@ -3,8 +3,8 @@
 #define _NFT_REDIR_H_
 
 struct nft_redir {
-       enum nft_registers      sreg_proto_min:8;
-       enum nft_registers      sreg_proto_max:8;
+       u8                      sreg_proto_min;
+       u8                      sreg_proto_max;
        u16                     flags;
 };
 

diff --git a/net/ipv4/netfilter/nft_dup_ipv4.c b/net/ipv4/netfilter/nft_dup_ipv4.c
index 0af3d8df70dd713bbe30d469987bab33c295cf99..157bca240edcedf352c55d792dcaa5217a8f5be2 100644 (file)
--- a/net/ipv4/netfilter/nft_dup_ipv4.c
+++ b/net/ipv4/netfilter/nft_dup_ipv4.c
@@ -16,8 +16,8 @@
 #include <net/netfilter/ipv4/nf_dup_ipv4.h>
 
 struct nft_dup_ipv4 {
-       enum nft_registers      sreg_addr:8;
-       enum nft_registers      sreg_dev:8;
+       u8      sreg_addr;
+       u8      sreg_dev;
 };
 
 static void nft_dup_ipv4_eval(const struct nft_expr *expr,
@@ -43,16 +43,16 @@ static int nft_dup_ipv4_init(const struct nft_ctx *ctx,
        if (tb[NFTA_DUP_SREG_ADDR] == NULL)
                return -EINVAL;
 
-       priv->sreg_addr = nft_parse_register(tb[NFTA_DUP_SREG_ADDR]);
-       err = nft_validate_register_load(priv->sreg_addr, sizeof(struct in_addr));
+       err = nft_parse_register_load(tb[NFTA_DUP_SREG_ADDR], &priv->sreg_addr,
+                                     sizeof(struct in_addr));
        if (err < 0)
                return err;
 
-       if (tb[NFTA_DUP_SREG_DEV] != NULL) {
-               priv->sreg_dev = nft_parse_register(tb[NFTA_DUP_SREG_DEV]);
-               return nft_validate_register_load(priv->sreg_dev, sizeof(int));
-       }
-       return 0;
+       if (tb[NFTA_DUP_SREG_DEV])
+               err = nft_parse_register_load(tb[NFTA_DUP_SREG_DEV],
+                                             &priv->sreg_dev, sizeof(int));
+
+       return err;
 }
 
 static int nft_dup_ipv4_dump(struct sk_buff *skb, const struct nft_expr *expr)

diff --git a/net/ipv6/netfilter/nft_dup_ipv6.c b/net/ipv6/netfilter/nft_dup_ipv6.c
index d8b5b60b7d5310d0bff6e16f9964b5a91c38a64f..d8bb7c85287cb69c5e19c2abb5a1baf1d9160784 100644 (file)
--- a/net/ipv6/netfilter/nft_dup_ipv6.c
+++ b/net/ipv6/netfilter/nft_dup_ipv6.c
@@ -16,8 +16,8 @@
 #include <net/netfilter/ipv6/nf_dup_ipv6.h>
 
 struct nft_dup_ipv6 {
-       enum nft_registers      sreg_addr:8;
-       enum nft_registers      sreg_dev:8;
+       u8      sreg_addr;
+       u8      sreg_dev;
 };
 
 static void nft_dup_ipv6_eval(const struct nft_expr *expr,
@@ -41,16 +41,16 @@ static int nft_dup_ipv6_init(const struct nft_ctx *ctx,
        if (tb[NFTA_DUP_SREG_ADDR] == NULL)
                return -EINVAL;
 
-       priv->sreg_addr = nft_parse_register(tb[NFTA_DUP_SREG_ADDR]);
-       err = nft_validate_register_load(priv->sreg_addr, sizeof(struct in6_addr));
+       err = nft_parse_register_load(tb[NFTA_DUP_SREG_ADDR], &priv->sreg_addr,
+                                     sizeof(struct in6_addr));
        if (err < 0)
                return err;
 
-       if (tb[NFTA_DUP_SREG_DEV] != NULL) {
-               priv->sreg_dev = nft_parse_register(tb[NFTA_DUP_SREG_DEV]);
-               return nft_validate_register_load(priv->sreg_dev, sizeof(int));
-       }
-       return 0;
+       if (tb[NFTA_DUP_SREG_DEV])
+               err = nft_parse_register_load(tb[NFTA_DUP_SREG_DEV],
+                                             &priv->sreg_dev, sizeof(int));
+
+       return err;
 }
 
 static int nft_dup_ipv6_dump(struct sk_buff *skb, const struct nft_expr *expr)

diff --git a/net/netfilter/nf_tables_api.c b/net/netfilter/nf_tables_api.c
index e20bde9cc7b1259ed89b3d07f3d630c0367a50ec..3b4cb6a9e85d58c9493a4812eab1c2608bdf4da8 100644 (file)
--- a/net/netfilter/nf_tables_api.c
+++ b/net/netfilter/nf_tables_api.c
@@ -7026,7 +7026,7 @@ EXPORT_SYMBOL_GPL(nft_dump_register);
  *     Validate that the input register is one of the general purpose
  *     registers and that the length of the load is within the bounds.
  */
-int nft_validate_register_load(enum nft_registers reg, unsigned int len)
+static int nft_validate_register_load(enum nft_registers reg, unsigned int len)
 {
        if (reg < NFT_REG_1 * NFT_REG_SIZE / NFT_REG32_SIZE)
                return -EINVAL;
@@ -7037,7 +7037,21 @@ int nft_validate_register_load(enum nft_registers reg, unsigned int len)
 
        return 0;
 }
-EXPORT_SYMBOL_GPL(nft_validate_register_load);
+
+int nft_parse_register_load(const struct nlattr *attr, u8 *sreg, u32 len)
+{
+       u32 reg;
+       int err;
+
+       reg = nft_parse_register(attr);
+       err = nft_validate_register_load(reg, len);
+       if (err < 0)
+               return err;
+
+       *sreg = reg;
+       return 0;
+}
+EXPORT_SYMBOL_GPL(nft_parse_register_load);
 
 /**
  *     nft_validate_register_store - validate an expressions' register store

diff --git a/net/netfilter/nft_bitwise.c b/net/netfilter/nft_bitwise.c
index 058ee84ea531bddc3b6049a964ea76da33a4f6a7..23a8a9d119876f744d04c21522f44df6e771da70 100644 (file)
--- a/net/netfilter/nft_bitwise.c
+++ b/net/netfilter/nft_bitwise.c
@@ -18,7 +18,7 @@
 #include <net/netfilter/nf_tables.h>
 
 struct nft_bitwise {
-       enum nft_registers      sreg:8;
+       u8                      sreg;
        enum nft_registers      dreg:8;
        u8                      len;
        struct nft_data         mask;
@@ -68,8 +68,8 @@ static int nft_bitwise_init(const struct nft_ctx *ctx,
 
        priv->len = len;
 
-       priv->sreg = nft_parse_register(tb[NFTA_BITWISE_SREG]);
-       err = nft_validate_register_load(priv->sreg, priv->len);
+       err = nft_parse_register_load(tb[NFTA_BITWISE_SREG], &priv->sreg,
+                                     priv->len);
        if (err < 0)
                return err;
 

diff --git a/net/netfilter/nft_byteorder.c b/net/netfilter/nft_byteorder.c
index 13d4e421a6b33ccc44ff3c70ab6bb9c38d256822..c81d618137ce8b8e2f8c98d451fb5784b560e6cd 100644 (file)
--- a/net/netfilter/nft_byteorder.c
+++ b/net/netfilter/nft_byteorder.c
@@ -19,7 +19,7 @@
 #include <net/netfilter/nf_tables.h>
 
 struct nft_byteorder {
-       enum nft_registers      sreg:8;
+       u8                      sreg;
        enum nft_registers      dreg:8;
        enum nft_byteorder_ops  op:8;
        u8                      len;
@@ -133,14 +133,14 @@ static int nft_byteorder_init(const struct nft_ctx *ctx,
                return -EINVAL;
        }
 
-       priv->sreg = nft_parse_register(tb[NFTA_BYTEORDER_SREG]);
        err = nft_parse_u32_check(tb[NFTA_BYTEORDER_LEN], U8_MAX, &len);
        if (err < 0)
                return err;
 
        priv->len = len;
 
-       err = nft_validate_register_load(priv->sreg, priv->len);
+       err = nft_parse_register_load(tb[NFTA_BYTEORDER_SREG], &priv->sreg,
+                                     priv->len);
        if (err < 0)
                return err;
 

diff --git a/net/netfilter/nft_cmp.c b/net/netfilter/nft_cmp.c
index 7007045c08498d887d761add943033d8d26c0672..36bf64ebc89262b9b180fc87f3815ab23e515f01 100644 (file)
--- a/net/netfilter/nft_cmp.c
+++ b/net/netfilter/nft_cmp.c
@@ -19,7 +19,7 @@
 
 struct nft_cmp_expr {
        struct nft_data         data;
-       enum nft_registers      sreg:8;
+       u8                      sreg;
        u8                      len;
        enum nft_cmp_ops        op:8;
 };
@@ -88,8 +88,7 @@ static int nft_cmp_init(const struct nft_ctx *ctx, const struct nft_expr *expr,
                return err;
        }
 
-       priv->sreg = nft_parse_register(tb[NFTA_CMP_SREG]);
-       err = nft_validate_register_load(priv->sreg, desc.len);
+       err = nft_parse_register_load(tb[NFTA_CMP_SREG], &priv->sreg, desc.len);
        if (err < 0)
                return err;
 
@@ -139,8 +138,7 @@ static int nft_cmp_fast_init(const struct nft_ctx *ctx,
        if (err < 0)
                return err;
 
-       priv->sreg = nft_parse_register(tb[NFTA_CMP_SREG]);
-       err = nft_validate_register_load(priv->sreg, desc.len);
+       err = nft_parse_register_load(tb[NFTA_CMP_SREG], &priv->sreg, desc.len);
        if (err < 0)
                return err;
 

diff --git a/net/netfilter/nft_ct.c b/net/netfilter/nft_ct.c
index 5dd87748afa8a9185de95c439881f72d3f96e798..045e350ba03ea68f18989dfdc123644e82715a8e 100644 (file)
--- a/net/netfilter/nft_ct.c
+++ b/net/netfilter/nft_ct.c
@@ -30,7 +30,7 @@ struct nft_ct {
        enum ip_conntrack_dir   dir:8;
        union {
                enum nft_registers      dreg:8;
-               enum nft_registers      sreg:8;
+               u8              sreg;
        };
 };
 
@@ -581,8 +581,7 @@ static int nft_ct_set_init(const struct nft_ctx *ctx,
                }
        }
 
-       priv->sreg = nft_parse_register(tb[NFTA_CT_SREG]);
-       err = nft_validate_register_load(priv->sreg, len);
+       err = nft_parse_register_load(tb[NFTA_CT_SREG], &priv->sreg, len);
        if (err < 0)
                goto err1;
 

diff --git a/net/netfilter/nft_dup_netdev.c b/net/netfilter/nft_dup_netdev.c
index 2cc1e0ef56e88f0ac960cc4ae891bda7e93da8c8..e862f916efa096a54cee05ea8351fa1c971637bf 100644 (file)
--- a/net/netfilter/nft_dup_netdev.c
+++ b/net/netfilter/nft_dup_netdev.c
@@ -16,7 +16,7 @@
 #include <net/netfilter/nf_dup_netdev.h>
 
 struct nft_dup_netdev {
-       enum nft_registers      sreg_dev:8;
+       u8      sreg_dev;
 };
 
 static void nft_dup_netdev_eval(const struct nft_expr *expr,
@@ -42,8 +42,8 @@ static int nft_dup_netdev_init(const struct nft_ctx *ctx,
        if (tb[NFTA_DUP_SREG_DEV] == NULL)
                return -EINVAL;
 
-       priv->sreg_dev = nft_parse_register(tb[NFTA_DUP_SREG_DEV]);
-       return nft_validate_register_load(priv->sreg_dev, sizeof(int));
+       return nft_parse_register_load(tb[NFTA_DUP_SREG_DEV], &priv->sreg_dev,
+                                      sizeof(int));
 }
 
 static const struct nft_expr_ops nft_dup_netdev_ingress_ops;

diff --git a/net/netfilter/nft_dynset.c b/net/netfilter/nft_dynset.c
index ea73130427eb816f49dffc317315a15ca73333df..c5d42e704f0435919c517445eb73add4f3b27afe 100644 (file)
--- a/net/netfilter/nft_dynset.c
+++ b/net/netfilter/nft_dynset.c
@@ -20,8 +20,8 @@ struct nft_dynset {
        struct nft_set                  *set;
        struct nft_set_ext_tmpl         tmpl;
        enum nft_dynset_ops             op:8;
-       enum nft_registers              sreg_key:8;
-       enum nft_registers              sreg_data:8;
+       u8                              sreg_key;
+       u8                              sreg_data;
        bool                            invert;
        u64                             timeout;
        struct nft_expr                 *expr;
@@ -166,8 +166,8 @@ static int nft_dynset_init(const struct nft_ctx *ctx,
                                                tb[NFTA_DYNSET_TIMEOUT])));
        }
 
-       priv->sreg_key = nft_parse_register(tb[NFTA_DYNSET_SREG_KEY]);
-       err = nft_validate_register_load(priv->sreg_key, set->klen);
+       err = nft_parse_register_load(tb[NFTA_DYNSET_SREG_KEY], &priv->sreg_key,
+                                     set->klen);
        if (err < 0)
                return err;
 
@@ -177,8 +177,8 @@ static int nft_dynset_init(const struct nft_ctx *ctx,
                if (set->dtype == NFT_DATA_VERDICT)
                        return -EOPNOTSUPP;
 
-               priv->sreg_data = nft_parse_register(tb[NFTA_DYNSET_SREG_DATA]);
-               err = nft_validate_register_load(priv->sreg_data, set->dlen);
+               err = nft_parse_register_load(tb[NFTA_DYNSET_SREG_DATA],
+                                             &priv->sreg_data, set->dlen);
                if (err < 0)
                        return err;
        } else if (set->flags & NFT_SET_MAP)

diff --git a/net/netfilter/nft_exthdr.c b/net/netfilter/nft_exthdr.c
index 93fee410601924ebcd48c92587bd03f3166f8b67..340520f10b686e255e0ed70f35f3b4c632d73486 100644 (file)
--- a/net/netfilter/nft_exthdr.c
+++ b/net/netfilter/nft_exthdr.c
@@ -23,7 +23,7 @@ struct nft_exthdr {
        u8                      len;
        u8                      op;
        enum nft_registers      dreg:8;
-       enum nft_registers      sreg:8;
+       u8                      sreg;
        u8                      flags;
 };
 
@@ -308,11 +308,11 @@ static int nft_exthdr_tcp_set_init(const struct nft_ctx *ctx,
        priv->type   = nla_get_u8(tb[NFTA_EXTHDR_TYPE]);
        priv->offset = offset;
        priv->len    = len;
-       priv->sreg   = nft_parse_register(tb[NFTA_EXTHDR_SREG]);
        priv->flags  = flags;
        priv->op     = op;
 
-       return nft_validate_register_load(priv->sreg, priv->len);
+       return nft_parse_register_load(tb[NFTA_EXTHDR_SREG], &priv->sreg,
+                                      priv->len);
 }
 
 static int nft_exthdr_dump_common(struct sk_buff *skb, const struct nft_exthdr *priv)

diff --git a/net/netfilter/nft_fwd_netdev.c b/net/netfilter/nft_fwd_netdev.c
index 10a12e0949299aac433531370d67eb8748c63fee..2efbe78de3b223aa4e65ec4e728528a0d7f4b9a4 100644 (file)
--- a/net/netfilter/nft_fwd_netdev.c
+++ b/net/netfilter/nft_fwd_netdev.c
@@ -20,7 +20,7 @@
 #include <net/ip.h>
 
 struct nft_fwd_netdev {
-       enum nft_registers      sreg_dev:8;
+       u8      sreg_dev;
 };
 
 static void nft_fwd_netdev_eval(const struct nft_expr *expr,
@@ -49,8 +49,8 @@ static int nft_fwd_netdev_init(const struct nft_ctx *ctx,
        if (tb[NFTA_FWD_SREG_DEV] == NULL)
                return -EINVAL;
 
-       priv->sreg_dev = nft_parse_register(tb[NFTA_FWD_SREG_DEV]);
-       return nft_validate_register_load(priv->sreg_dev, sizeof(int));
+       return nft_parse_register_load(tb[NFTA_FWD_SREG_DEV], &priv->sreg_dev,
+                                      sizeof(int));
 }
 
 static const struct nft_expr_ops nft_fwd_netdev_ingress_ops;
@@ -69,8 +69,8 @@ static int nft_fwd_netdev_dump(struct sk_buff *skb, const struct nft_expr *expr)
 }
 
 struct nft_fwd_neigh {
-       enum nft_registers      sreg_dev:8;
-       enum nft_registers      sreg_addr:8;
+       u8                      sreg_dev;
+       u8                      sreg_addr;
        u8                      nfproto;
 };
 
@@ -148,8 +148,6 @@ static int nft_fwd_neigh_init(const struct nft_ctx *ctx,
            !tb[NFTA_FWD_NFPROTO])
                return -EINVAL;
 
-       priv->sreg_dev = nft_parse_register(tb[NFTA_FWD_SREG_DEV]);
-       priv->sreg_addr = nft_parse_register(tb[NFTA_FWD_SREG_ADDR]);
        priv->nfproto = ntohl(nla_get_be32(tb[NFTA_FWD_NFPROTO]));
 
        switch (priv->nfproto) {
@@ -163,11 +161,13 @@ static int nft_fwd_neigh_init(const struct nft_ctx *ctx,
                return -EOPNOTSUPP;
        }
 
-       err = nft_validate_register_load(priv->sreg_dev, sizeof(int));
+       err = nft_parse_register_load(tb[NFTA_FWD_SREG_DEV], &priv->sreg_dev,
+                                     sizeof(int));
        if (err < 0)
                return err;
 
-       return nft_validate_register_load(priv->sreg_addr, addr_len);
+       return nft_parse_register_load(tb[NFTA_FWD_SREG_ADDR], &priv->sreg_addr,
+                                      addr_len);
 }
 
 static const struct nft_expr_ops nft_fwd_netdev_ingress_ops;

diff --git a/net/netfilter/nft_hash.c b/net/netfilter/nft_hash.c
index b8f23f75aea6cbe96bf627c030d39e50539596ad..d08a14cfe56b7ce83f545efcbeac0aec9d4a32ec 100644 (file)
--- a/net/netfilter/nft_hash.c
+++ b/net/netfilter/nft_hash.c
@@ -18,7 +18,7 @@
 #include <linux/jhash.h>
 
 struct nft_jhash {
-       enum nft_registers      sreg:8;
+       u8                      sreg;
        enum nft_registers      dreg:8;
        u8                      len;
        bool                    autogen_seed:1;
@@ -136,7 +136,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->sreg = nft_parse_register(tb[NFTA_HASH_SREG]);
        priv->dreg = nft_parse_register(tb[NFTA_HASH_DREG]);
 
        err = nft_parse_u32_check(tb[NFTA_HASH_LEN], U8_MAX, &len);
@@ -147,6 +146,10 @@ static int nft_jhash_init(const struct nft_ctx *ctx,
 
        priv->len = len;
 
+       err = nft_parse_register_load(tb[NFTA_HASH_SREG], &priv->sreg, len);
+       if (err < 0)
+               return err;
+
        priv->modulus = ntohl(nla_get_be32(tb[NFTA_HASH_MODULUS]));
        if (priv->modulus < 1)
                return -ERANGE;
@@ -161,8 +164,7 @@ static int nft_jhash_init(const struct nft_ctx *ctx,
                get_random_bytes(&priv->seed, sizeof(priv->seed));
        }
 
-       return nft_validate_register_load(priv->sreg, len) &&
-              nft_validate_register_store(ctx, priv->dreg, NULL,
+       return nft_validate_register_store(ctx, priv->dreg, NULL,
                                           NFT_DATA_VALUE, sizeof(u32));
 }
 

diff --git a/net/netfilter/nft_lookup.c b/net/netfilter/nft_lookup.c
index cb9e937a5ce0256f050c9c6e66ab7e4071c51ea1..671f124d56b34161c902f986035db0db611299eb 100644 (file)
--- a/net/netfilter/nft_lookup.c
+++ b/net/netfilter/nft_lookup.c
@@ -20,7 +20,7 @@
 
 struct nft_lookup {
        struct nft_set                  *set;
-       enum nft_registers              sreg:8;
+       u8                              sreg;
        enum nft_registers              dreg:8;
        bool                            invert;
        struct nft_set_binding          binding;
@@ -76,8 +76,8 @@ static int nft_lookup_init(const struct nft_ctx *ctx,
        if (IS_ERR(set))
                return PTR_ERR(set);
 
-       priv->sreg = nft_parse_register(tb[NFTA_LOOKUP_SREG]);
-       err = nft_validate_register_load(priv->sreg, set->klen);
+       err = nft_parse_register_load(tb[NFTA_LOOKUP_SREG], &priv->sreg,
+                                     set->klen);
        if (err < 0)
                return err;
 

diff --git a/net/netfilter/nft_masq.c b/net/netfilter/nft_masq.c
index 9d8655bc1bea6cde7c029477b4a974499dba4d82..4ecfebc2fdc4a808c829025e798e37da5b54ac40 100644 (file)
--- a/net/netfilter/nft_masq.c
+++ b/net/netfilter/nft_masq.c
@@ -53,19 +53,15 @@ int nft_masq_init(const struct nft_ctx *ctx,
        }
 
        if (tb[NFTA_MASQ_REG_PROTO_MIN]) {
-               priv->sreg_proto_min =
-                       nft_parse_register(tb[NFTA_MASQ_REG_PROTO_MIN]);
-
-               err = nft_validate_register_load(priv->sreg_proto_min, plen);
+               err = nft_parse_register_load(tb[NFTA_MASQ_REG_PROTO_MIN],
+                                             &priv->sreg_proto_min, plen);
                if (err < 0)
                        return err;
 
                if (tb[NFTA_MASQ_REG_PROTO_MAX]) {
-                       priv->sreg_proto_max =
-                               nft_parse_register(tb[NFTA_MASQ_REG_PROTO_MAX]);
-
-                       err = nft_validate_register_load(priv->sreg_proto_max,
-                                                        plen);
+                       err = nft_parse_register_load(tb[NFTA_MASQ_REG_PROTO_MAX],
+                                                     &priv->sreg_proto_max,
+                                                     plen);
                        if (err < 0)
                                return err;
                } else {

diff --git a/net/netfilter/nft_meta.c b/net/netfilter/nft_meta.c
index 297fe7d97c182ffbcbfb15c94f10bdec633f1149..7af90ed22111384661c464b30aacdc73d6149d0f 100644 (file)
--- a/net/netfilter/nft_meta.c
+++ b/net/netfilter/nft_meta.c
@@ -31,7 +31,7 @@ struct nft_meta {
        enum nft_meta_keys      key:8;
        union {
                enum nft_registers      dreg:8;
-               enum nft_registers      sreg:8;
+               u8              sreg;
        };
 };
 
@@ -448,8 +448,7 @@ static int nft_meta_set_init(const struct nft_ctx *ctx,
                return -EOPNOTSUPP;
        }
 
-       priv->sreg = nft_parse_register(tb[NFTA_META_SREG]);
-       err = nft_validate_register_load(priv->sreg, len);
+       err = nft_parse_register_load(tb[NFTA_META_SREG], &priv->sreg, len);
        if (err < 0)
                return err;
 

diff --git a/net/netfilter/nft_nat.c b/net/netfilter/nft_nat.c
index 2c3d7ff6f58a73dd897efebd0cbf60362384a131..aa6149cc8c87c383513912fcb76893bf14daaf15 100644 (file)
--- a/net/netfilter/nft_nat.c
+++ b/net/netfilter/nft_nat.c
@@ -27,10 +27,10 @@
 #include <net/ip.h>
 
 struct nft_nat {
-       enum nft_registers      sreg_addr_min:8;
-       enum nft_registers      sreg_addr_max:8;
-       enum nft_registers      sreg_proto_min:8;
-       enum nft_registers      sreg_proto_max:8;
+       u8                      sreg_addr_min;
+       u8                      sreg_addr_max;
+       u8                      sreg_proto_min;
+       u8                      sreg_proto_max;
        enum nf_nat_manip_type  type:8;
        u8                      family;
        u16                     flags;
@@ -160,18 +160,15 @@ static int nft_nat_init(const struct nft_ctx *ctx, const struct nft_expr *expr,
        priv->family = family;
 
        if (tb[NFTA_NAT_REG_ADDR_MIN]) {
-               priv->sreg_addr_min =
-                       nft_parse_register(tb[NFTA_NAT_REG_ADDR_MIN]);
-               err = nft_validate_register_load(priv->sreg_addr_min, alen);
+               err = nft_parse_register_load(tb[NFTA_NAT_REG_ADDR_MIN],
+                                             &priv->sreg_addr_min, alen);
                if (err < 0)
                        return err;
 
                if (tb[NFTA_NAT_REG_ADDR_MAX]) {
-                       priv->sreg_addr_max =
-                               nft_parse_register(tb[NFTA_NAT_REG_ADDR_MAX]);
-
-                       err = nft_validate_register_load(priv->sreg_addr_max,
-                                                        alen);
+                       err = nft_parse_register_load(tb[NFTA_NAT_REG_ADDR_MAX],
+                                                     &priv->sreg_addr_max,
+                                                     alen);
                        if (err < 0)
                                return err;
                } else {
@@ -181,19 +178,15 @@ static int nft_nat_init(const struct nft_ctx *ctx, const struct nft_expr *expr,
 
        plen = FIELD_SIZEOF(struct nf_nat_range, min_addr.all);
        if (tb[NFTA_NAT_REG_PROTO_MIN]) {
-               priv->sreg_proto_min =
-                       nft_parse_register(tb[NFTA_NAT_REG_PROTO_MIN]);
-
-               err = nft_validate_register_load(priv->sreg_proto_min, plen);
+               err = nft_parse_register_load(tb[NFTA_NAT_REG_PROTO_MIN],
+                                             &priv->sreg_proto_min, plen);
                if (err < 0)
                        return err;
 
                if (tb[NFTA_NAT_REG_PROTO_MAX]) {
-                       priv->sreg_proto_max =
-                               nft_parse_register(tb[NFTA_NAT_REG_PROTO_MAX]);
-
-                       err = nft_validate_register_load(priv->sreg_proto_max,
-                                                        plen);
+                       err = nft_parse_register_load(tb[NFTA_NAT_REG_PROTO_MAX],
+                                                     &priv->sreg_proto_max,
+                                                     plen);
                        if (err < 0)
                                return err;
                } else {

diff --git a/net/netfilter/nft_objref.c b/net/netfilter/nft_objref.c
index eff2173db7e4b52e6dcef6d17fcf4cfbbde25345..615f0fcf711c60e2fd820236d13cf76897b60517 100644 (file)
--- a/net/netfilter/nft_objref.c
+++ b/net/netfilter/nft_objref.c
@@ -97,7 +97,7 @@ static const struct nft_expr_ops nft_objref_ops = {
 
 struct nft_objref_map {
        struct nft_set          *set;
-       enum nft_registers      sreg:8;
+       u8                      sreg;
        struct nft_set_binding  binding;
 };
 
@@ -139,8 +139,8 @@ static int nft_objref_map_init(const struct nft_ctx *ctx,
        if (!(set->flags & NFT_SET_OBJECT))
                return -EINVAL;
 
-       priv->sreg = nft_parse_register(tb[NFTA_OBJREF_SET_SREG]);
-       err = nft_validate_register_load(priv->sreg, set->klen);
+       err = nft_parse_register_load(tb[NFTA_OBJREF_SET_SREG], &priv->sreg,
+                                     set->klen);
        if (err < 0)
                return err;
 

diff --git a/net/netfilter/nft_payload.c b/net/netfilter/nft_payload.c
index 5732b32ab9320075f3dd92a223eed537c9d02074..6c5312fecac5c5e864f87bbe667a77deb71fb891 100644 (file)
--- a/net/netfilter/nft_payload.c
+++ b/net/netfilter/nft_payload.c
@@ -338,7 +338,6 @@ static int nft_payload_set_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->sreg        = nft_parse_register(tb[NFTA_PAYLOAD_SREG]);
 
        if (tb[NFTA_PAYLOAD_CSUM_TYPE])
                csum_type = ntohl(nla_get_be32(tb[NFTA_PAYLOAD_CSUM_TYPE]));
@@ -369,7 +368,8 @@ static int nft_payload_set_init(const struct nft_ctx *ctx,
        }
        priv->csum_type = csum_type;
 
-       return nft_validate_register_load(priv->sreg, priv->len);
+       return nft_parse_register_load(tb[NFTA_PAYLOAD_SREG], &priv->sreg,
+                                      priv->len);
 }
 
 static int nft_payload_set_dump(struct sk_buff *skb, const struct nft_expr *expr)

diff --git a/net/netfilter/nft_queue.c b/net/netfilter/nft_queue.c
index 98613658d4ac5ce359e946efca4c93d9df216817..de5f1bda9d6f1dd60e3303e055418bdc6d30c72f 100644 (file)
--- a/net/netfilter/nft_queue.c
+++ b/net/netfilter/nft_queue.c
@@ -22,10 +22,10 @@
 static u32 jhash_initval __read_mostly;
 
 struct nft_queue {
-       enum nft_registers      sreg_qnum:8;
-       u16                     queuenum;
-       u16                     queues_total;
-       u16                     flags;
+       u8      sreg_qnum;
+       u16     queuenum;
+       u16     queues_total;
+       u16     flags;
 };
 
 static void nft_queue_eval(const struct nft_expr *expr,
@@ -114,8 +114,8 @@ static int nft_queue_sreg_init(const struct nft_ctx *ctx,
        struct nft_queue *priv = nft_expr_priv(expr);
        int err;
 
-       priv->sreg_qnum = nft_parse_register(tb[NFTA_QUEUE_SREG_QNUM]);
-       err = nft_validate_register_load(priv->sreg_qnum, sizeof(u32));
+       err = nft_parse_register_load(tb[NFTA_QUEUE_SREG_QNUM],
+                                     &priv->sreg_qnum, sizeof(u32));
        if (err < 0)
                return err;
 

diff --git a/net/netfilter/nft_range.c b/net/netfilter/nft_range.c
index 2e1d2ec2f52a486c392c714bd24c4ab0e1b8f5b9..a5f74e5b8184f1935ad009f94c5c42f3fd374f4e 100644 (file)
--- a/net/netfilter/nft_range.c
+++ b/net/netfilter/nft_range.c
@@ -18,7 +18,7 @@
 struct nft_range_expr {
        struct nft_data         data_from;
        struct nft_data         data_to;
-       enum nft_registers      sreg:8;
+       u8                      sreg;
        u8                      len;
        enum nft_range_ops      op:8;
 };
@@ -90,8 +90,8 @@ static int nft_range_init(const struct nft_ctx *ctx, const struct nft_expr *expr
                goto err2;
        }
 
-       priv->sreg = nft_parse_register(tb[NFTA_RANGE_SREG]);
-       err = nft_validate_register_load(priv->sreg, desc_from.len);
+       err = nft_parse_register_load(tb[NFTA_RANGE_SREG], &priv->sreg,
+                                     desc_from.len);
        if (err < 0)
                goto err2;
 

diff --git a/net/netfilter/nft_redir.c b/net/netfilter/nft_redir.c
index c64cbe78dee7bcb5b0036c6cd8fe66aceb3e004a..08a05bd1e817822f91d5e502114b7794170907f6 100644 (file)
--- a/net/netfilter/nft_redir.c
+++ b/net/netfilter/nft_redir.c
@@ -49,19 +49,15 @@ int nft_redir_init(const struct nft_ctx *ctx,
 
        plen = FIELD_SIZEOF(struct nf_nat_range, min_addr.all);
        if (tb[NFTA_REDIR_REG_PROTO_MIN]) {
-               priv->sreg_proto_min =
-                       nft_parse_register(tb[NFTA_REDIR_REG_PROTO_MIN]);
-
-               err = nft_validate_register_load(priv->sreg_proto_min, plen);
+               err = nft_parse_register_load(tb[NFTA_REDIR_REG_PROTO_MIN],
+                                             &priv->sreg_proto_min, plen);
                if (err < 0)
                        return err;
 
                if (tb[NFTA_REDIR_REG_PROTO_MAX]) {
-                       priv->sreg_proto_max =
-                               nft_parse_register(tb[NFTA_REDIR_REG_PROTO_MAX]);
-
-                       err = nft_validate_register_load(priv->sreg_proto_max,
-                                                        plen);
+                       err = nft_parse_register_load(tb[NFTA_REDIR_REG_PROTO_MAX],
+                                                     &priv->sreg_proto_max,
+                                                     plen);
                        if (err < 0)
                                return err;
                } else {

diff --git a/net/netfilter/nft_tproxy.c b/net/netfilter/nft_tproxy.c
index a0e30bf4a845c0dc0eb9795dfd02987a61a7df5d..db780b5985abc9b5c75c1fff342f7e059b074e61 100644 (file)
--- a/net/netfilter/nft_tproxy.c
+++ b/net/netfilter/nft_tproxy.c
@@ -13,9 +13,9 @@
 #endif
 
 struct nft_tproxy {
-       enum nft_registers      sreg_addr:8;
-       enum nft_registers      sreg_port:8;
-       u8                      family;
+       u8      sreg_addr;
+       u8      sreg_port;
+       u8      family;
 };
 
 static void nft_tproxy_eval_v4(const struct nft_expr *expr,
@@ -254,15 +254,15 @@ static int nft_tproxy_init(const struct nft_ctx *ctx,
        }
 
        if (tb[NFTA_TPROXY_REG_ADDR]) {
-               priv->sreg_addr = nft_parse_register(tb[NFTA_TPROXY_REG_ADDR]);
-               err = nft_validate_register_load(priv->sreg_addr, alen);
+               err = nft_parse_register_load(tb[NFTA_TPROXY_REG_ADDR],
+                                             &priv->sreg_addr, alen);
                if (err < 0)
                        return err;
        }
 
        if (tb[NFTA_TPROXY_REG_PORT]) {
-               priv->sreg_port = nft_parse_register(tb[NFTA_TPROXY_REG_PORT]);
-               err = nft_validate_register_load(priv->sreg_port, sizeof(u16));
+               err = nft_parse_register_load(tb[NFTA_TPROXY_REG_PORT],
+                                             &priv->sreg_port, sizeof(u16));
                if (err < 0)
                        return err;
        }