tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

netfilter: nf_tables: pass context structure to nft_parse_register_load

Mechanical transformation, no logical changes intended.

Signed-off-by: Florian Westphal <fw@strlen.de>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

authored by

Florian Westphal and committed by
Pablo Neira Ayuso 7ea0522e d5283b47

+40 -38
+2 -1
include/net/netfilter/nf_tables.h
··· 254 254 int nft_parse_u32_check(const struct nlattr *attr, int max, u32 *dest); 255 255 int nft_dump_register(struct sk_buff *skb, unsigned int attr, unsigned int reg); 256 256 257 - int nft_parse_register_load(const struct nlattr *attr, u8 *sreg, u32 len); 257 + int nft_parse_register_load(const struct nft_ctx *ctx, 258 + const struct nlattr *attr, u8 *sreg, u32 len); 258 259 int nft_parse_register_store(const struct nft_ctx *ctx, 259 260 const struct nlattr *attr, u8 *dreg, 260 261 const struct nft_data *data,
+1 -1
net/bridge/netfilter/nft_meta_bridge.c
··· 142 142 } 143 143 144 144 priv->len = len; 145 - err = nft_parse_register_load(tb[NFTA_META_SREG], &priv->sreg, len); 145 + err = nft_parse_register_load(ctx, tb[NFTA_META_SREG], &priv->sreg, len); 146 146 if (err < 0) 147 147 return err; 148 148
+2 -2
net/ipv4/netfilter/nft_dup_ipv4.c
··· 40 40 if (tb[NFTA_DUP_SREG_ADDR] == NULL) 41 41 return -EINVAL; 42 42 43 - err = nft_parse_register_load(tb[NFTA_DUP_SREG_ADDR], &priv->sreg_addr, 43 + err = nft_parse_register_load(ctx, tb[NFTA_DUP_SREG_ADDR], &priv->sreg_addr, 44 44 sizeof(struct in_addr)); 45 45 if (err < 0) 46 46 return err; 47 47 48 48 if (tb[NFTA_DUP_SREG_DEV]) 49 - err = nft_parse_register_load(tb[NFTA_DUP_SREG_DEV], 49 + err = nft_parse_register_load(ctx, tb[NFTA_DUP_SREG_DEV], 50 50 &priv->sreg_dev, sizeof(int)); 51 51 52 52 return err;
+2 -2
net/ipv6/netfilter/nft_dup_ipv6.c
··· 38 38 if (tb[NFTA_DUP_SREG_ADDR] == NULL) 39 39 return -EINVAL; 40 40 41 - err = nft_parse_register_load(tb[NFTA_DUP_SREG_ADDR], &priv->sreg_addr, 41 + err = nft_parse_register_load(ctx, tb[NFTA_DUP_SREG_ADDR], &priv->sreg_addr, 42 42 sizeof(struct in6_addr)); 43 43 if (err < 0) 44 44 return err; 45 45 46 46 if (tb[NFTA_DUP_SREG_DEV]) 47 - err = nft_parse_register_load(tb[NFTA_DUP_SREG_DEV], 47 + err = nft_parse_register_load(ctx, tb[NFTA_DUP_SREG_DEV], 48 48 &priv->sreg_dev, sizeof(int)); 49 49 50 50 return err;
+2 -1
net/netfilter/nf_tables_api.c
··· 11038 11038 return 0; 11039 11039 } 11040 11040 11041 - int nft_parse_register_load(const struct nlattr *attr, u8 *sreg, u32 len) 11041 + int nft_parse_register_load(const struct nft_ctx *ctx, 11042 + const struct nlattr *attr, u8 *sreg, u32 len) 11042 11043 { 11043 11044 u32 reg; 11044 11045 int err;
+2 -2
net/netfilter/nft_bitwise.c
··· 171 171 172 172 priv->len = len; 173 173 174 - err = nft_parse_register_load(tb[NFTA_BITWISE_SREG], &priv->sreg, 174 + err = nft_parse_register_load(ctx, tb[NFTA_BITWISE_SREG], &priv->sreg, 175 175 priv->len); 176 176 if (err < 0) 177 177 return err; ··· 365 365 struct nft_bitwise_fast_expr *priv = nft_expr_priv(expr); 366 366 int err; 367 367 368 - err = nft_parse_register_load(tb[NFTA_BITWISE_SREG], &priv->sreg, 368 + err = nft_parse_register_load(ctx, tb[NFTA_BITWISE_SREG], &priv->sreg, 369 369 sizeof(u32)); 370 370 if (err < 0) 371 371 return err;
+1 -1
net/netfilter/nft_byteorder.c
··· 139 139 140 140 priv->len = len; 141 141 142 - err = nft_parse_register_load(tb[NFTA_BYTEORDER_SREG], &priv->sreg, 142 + err = nft_parse_register_load(ctx, tb[NFTA_BYTEORDER_SREG], &priv->sreg, 143 143 priv->len); 144 144 if (err < 0) 145 145 return err;
+3 -3
net/netfilter/nft_cmp.c
··· 83 83 if (err < 0) 84 84 return err; 85 85 86 - err = nft_parse_register_load(tb[NFTA_CMP_SREG], &priv->sreg, desc.len); 86 + err = nft_parse_register_load(ctx, tb[NFTA_CMP_SREG], &priv->sreg, desc.len); 87 87 if (err < 0) 88 88 return err; 89 89 ··· 222 222 if (err < 0) 223 223 return err; 224 224 225 - err = nft_parse_register_load(tb[NFTA_CMP_SREG], &priv->sreg, desc.len); 225 + err = nft_parse_register_load(ctx, tb[NFTA_CMP_SREG], &priv->sreg, desc.len); 226 226 if (err < 0) 227 227 return err; 228 228 ··· 323 323 if (err < 0) 324 324 return err; 325 325 326 - err = nft_parse_register_load(tb[NFTA_CMP_SREG], &priv->sreg, desc.len); 326 + err = nft_parse_register_load(ctx, tb[NFTA_CMP_SREG], &priv->sreg, desc.len); 327 327 if (err < 0) 328 328 return err; 329 329
+1 -1
net/netfilter/nft_ct.c
··· 606 606 } 607 607 608 608 priv->len = len; 609 - err = nft_parse_register_load(tb[NFTA_CT_SREG], &priv->sreg, len); 609 + err = nft_parse_register_load(ctx, tb[NFTA_CT_SREG], &priv->sreg, len); 610 610 if (err < 0) 611 611 goto err1; 612 612
+1 -1
net/netfilter/nft_dup_netdev.c
··· 40 40 if (tb[NFTA_DUP_SREG_DEV] == NULL) 41 41 return -EINVAL; 42 42 43 - return nft_parse_register_load(tb[NFTA_DUP_SREG_DEV], &priv->sreg_dev, 43 + return nft_parse_register_load(ctx, tb[NFTA_DUP_SREG_DEV], &priv->sreg_dev, 44 44 sizeof(int)); 45 45 } 46 46
+2 -2
net/netfilter/nft_dynset.c
··· 215 215 return err; 216 216 } 217 217 218 - err = nft_parse_register_load(tb[NFTA_DYNSET_SREG_KEY], &priv->sreg_key, 218 + err = nft_parse_register_load(ctx, tb[NFTA_DYNSET_SREG_KEY], &priv->sreg_key, 219 219 set->klen); 220 220 if (err < 0) 221 221 return err; ··· 226 226 if (set->dtype == NFT_DATA_VERDICT) 227 227 return -EOPNOTSUPP; 228 228 229 - err = nft_parse_register_load(tb[NFTA_DYNSET_SREG_DATA], 229 + err = nft_parse_register_load(ctx, tb[NFTA_DYNSET_SREG_DATA], 230 230 &priv->sreg_data, set->dlen); 231 231 if (err < 0) 232 232 return err;
+1 -1
net/netfilter/nft_exthdr.c
··· 588 588 priv->flags = flags; 589 589 priv->op = op; 590 590 591 - return nft_parse_register_load(tb[NFTA_EXTHDR_SREG], &priv->sreg, 591 + return nft_parse_register_load(ctx, tb[NFTA_EXTHDR_SREG], &priv->sreg, 592 592 priv->len); 593 593 } 594 594
+3 -3
net/netfilter/nft_fwd_netdev.c
··· 52 52 if (tb[NFTA_FWD_SREG_DEV] == NULL) 53 53 return -EINVAL; 54 54 55 - return nft_parse_register_load(tb[NFTA_FWD_SREG_DEV], &priv->sreg_dev, 55 + return nft_parse_register_load(ctx, tb[NFTA_FWD_SREG_DEV], &priv->sreg_dev, 56 56 sizeof(int)); 57 57 } 58 58 ··· 178 178 return -EOPNOTSUPP; 179 179 } 180 180 181 - err = nft_parse_register_load(tb[NFTA_FWD_SREG_DEV], &priv->sreg_dev, 181 + err = nft_parse_register_load(ctx, tb[NFTA_FWD_SREG_DEV], &priv->sreg_dev, 182 182 sizeof(int)); 183 183 if (err < 0) 184 184 return err; 185 185 186 - return nft_parse_register_load(tb[NFTA_FWD_SREG_ADDR], &priv->sreg_addr, 186 + return nft_parse_register_load(ctx, tb[NFTA_FWD_SREG_ADDR], &priv->sreg_addr, 187 187 addr_len); 188 188 } 189 189
+1 -1
net/netfilter/nft_hash.c
··· 92 92 93 93 priv->len = len; 94 94 95 - err = nft_parse_register_load(tb[NFTA_HASH_SREG], &priv->sreg, len); 95 + err = nft_parse_register_load(ctx, tb[NFTA_HASH_SREG], &priv->sreg, len); 96 96 if (err < 0) 97 97 return err; 98 98
+1 -1
net/netfilter/nft_lookup.c
··· 113 113 if (IS_ERR(set)) 114 114 return PTR_ERR(set); 115 115 116 - err = nft_parse_register_load(tb[NFTA_LOOKUP_SREG], &priv->sreg, 116 + err = nft_parse_register_load(ctx, tb[NFTA_LOOKUP_SREG], &priv->sreg, 117 117 set->klen); 118 118 if (err < 0) 119 119 return err;
+2 -2
net/netfilter/nft_masq.c
··· 52 52 priv->flags = ntohl(nla_get_be32(tb[NFTA_MASQ_FLAGS])); 53 53 54 54 if (tb[NFTA_MASQ_REG_PROTO_MIN]) { 55 - err = nft_parse_register_load(tb[NFTA_MASQ_REG_PROTO_MIN], 55 + err = nft_parse_register_load(ctx, tb[NFTA_MASQ_REG_PROTO_MIN], 56 56 &priv->sreg_proto_min, plen); 57 57 if (err < 0) 58 58 return err; 59 59 60 60 if (tb[NFTA_MASQ_REG_PROTO_MAX]) { 61 - err = nft_parse_register_load(tb[NFTA_MASQ_REG_PROTO_MAX], 61 + err = nft_parse_register_load(ctx, tb[NFTA_MASQ_REG_PROTO_MAX], 62 62 &priv->sreg_proto_max, 63 63 plen); 64 64 if (err < 0)
+1 -1
net/netfilter/nft_meta.c
··· 657 657 } 658 658 659 659 priv->len = len; 660 - err = nft_parse_register_load(tb[NFTA_META_SREG], &priv->sreg, len); 660 + err = nft_parse_register_load(ctx, tb[NFTA_META_SREG], &priv->sreg, len); 661 661 if (err < 0) 662 662 return err; 663 663
+4 -4
net/netfilter/nft_nat.c
··· 214 214 priv->family = family; 215 215 216 216 if (tb[NFTA_NAT_REG_ADDR_MIN]) { 217 - err = nft_parse_register_load(tb[NFTA_NAT_REG_ADDR_MIN], 217 + err = nft_parse_register_load(ctx, tb[NFTA_NAT_REG_ADDR_MIN], 218 218 &priv->sreg_addr_min, alen); 219 219 if (err < 0) 220 220 return err; 221 221 222 222 if (tb[NFTA_NAT_REG_ADDR_MAX]) { 223 - err = nft_parse_register_load(tb[NFTA_NAT_REG_ADDR_MAX], 223 + err = nft_parse_register_load(ctx, tb[NFTA_NAT_REG_ADDR_MAX], 224 224 &priv->sreg_addr_max, 225 225 alen); 226 226 if (err < 0) ··· 234 234 235 235 plen = sizeof_field(struct nf_nat_range, min_proto.all); 236 236 if (tb[NFTA_NAT_REG_PROTO_MIN]) { 237 - err = nft_parse_register_load(tb[NFTA_NAT_REG_PROTO_MIN], 237 + err = nft_parse_register_load(ctx, tb[NFTA_NAT_REG_PROTO_MIN], 238 238 &priv->sreg_proto_min, plen); 239 239 if (err < 0) 240 240 return err; 241 241 242 242 if (tb[NFTA_NAT_REG_PROTO_MAX]) { 243 - err = nft_parse_register_load(tb[NFTA_NAT_REG_PROTO_MAX], 243 + err = nft_parse_register_load(ctx, tb[NFTA_NAT_REG_PROTO_MAX], 244 244 &priv->sreg_proto_max, 245 245 plen); 246 246 if (err < 0)
+1 -1
net/netfilter/nft_objref.c
··· 143 143 if (!(set->flags & NFT_SET_OBJECT)) 144 144 return -EINVAL; 145 145 146 - err = nft_parse_register_load(tb[NFTA_OBJREF_SET_SREG], &priv->sreg, 146 + err = nft_parse_register_load(ctx, tb[NFTA_OBJREF_SET_SREG], &priv->sreg, 147 147 set->klen); 148 148 if (err < 0) 149 149 return err;
+1 -1
net/netfilter/nft_payload.c
··· 981 981 } 982 982 priv->csum_type = csum_type; 983 983 984 - return nft_parse_register_load(tb[NFTA_PAYLOAD_SREG], &priv->sreg, 984 + return nft_parse_register_load(ctx, tb[NFTA_PAYLOAD_SREG], &priv->sreg, 985 985 priv->len); 986 986 } 987 987
+1 -1
net/netfilter/nft_queue.c
··· 136 136 struct nft_queue *priv = nft_expr_priv(expr); 137 137 int err; 138 138 139 - err = nft_parse_register_load(tb[NFTA_QUEUE_SREG_QNUM], 139 + err = nft_parse_register_load(ctx, tb[NFTA_QUEUE_SREG_QNUM], 140 140 &priv->sreg_qnum, sizeof(u32)); 141 141 if (err < 0) 142 142 return err;
+1 -1
net/netfilter/nft_range.c
··· 83 83 goto err2; 84 84 } 85 85 86 - err = nft_parse_register_load(tb[NFTA_RANGE_SREG], &priv->sreg, 86 + err = nft_parse_register_load(ctx, tb[NFTA_RANGE_SREG], &priv->sreg, 87 87 desc_from.len); 88 88 if (err < 0) 89 89 goto err2;
+2 -2
net/netfilter/nft_redir.c
··· 51 51 52 52 plen = sizeof_field(struct nf_nat_range, min_proto.all); 53 53 if (tb[NFTA_REDIR_REG_PROTO_MIN]) { 54 - err = nft_parse_register_load(tb[NFTA_REDIR_REG_PROTO_MIN], 54 + err = nft_parse_register_load(ctx, tb[NFTA_REDIR_REG_PROTO_MIN], 55 55 &priv->sreg_proto_min, plen); 56 56 if (err < 0) 57 57 return err; 58 58 59 59 if (tb[NFTA_REDIR_REG_PROTO_MAX]) { 60 - err = nft_parse_register_load(tb[NFTA_REDIR_REG_PROTO_MAX], 60 + err = nft_parse_register_load(ctx, tb[NFTA_REDIR_REG_PROTO_MAX], 61 61 &priv->sreg_proto_max, 62 62 plen); 63 63 if (err < 0)
+2 -2
net/netfilter/nft_tproxy.c
··· 254 254 } 255 255 256 256 if (tb[NFTA_TPROXY_REG_ADDR]) { 257 - err = nft_parse_register_load(tb[NFTA_TPROXY_REG_ADDR], 257 + err = nft_parse_register_load(ctx, tb[NFTA_TPROXY_REG_ADDR], 258 258 &priv->sreg_addr, alen); 259 259 if (err < 0) 260 260 return err; 261 261 } 262 262 263 263 if (tb[NFTA_TPROXY_REG_PORT]) { 264 - err = nft_parse_register_load(tb[NFTA_TPROXY_REG_PORT], 264 + err = nft_parse_register_load(ctx, tb[NFTA_TPROXY_REG_PORT], 265 265 &priv->sreg_port, sizeof(u16)); 266 266 if (err < 0) 267 267 return err;