2 * Copyright (c) 2016 Laura Garcia <nevola@gmail.com>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
10 #include <linux/kernel.h>
11 #include <linux/init.h>
12 #include <linux/module.h>
13 #include <linux/netlink.h>
14 #include <linux/netfilter.h>
15 #include <linux/netfilter/nf_tables.h>
16 #include <net/netfilter/nf_tables.h>
17 #include <net/netfilter/nf_tables_core.h>
18 #include <linux/jhash.h>
21 enum nft_registers sreg:8;
22 enum nft_registers dreg:8;
29 static void nft_hash_eval(const struct nft_expr *expr,
30 struct nft_regs *regs,
31 const struct nft_pktinfo *pkt)
33 struct nft_hash *priv = nft_expr_priv(expr);
34 const void *data = ®s->data[priv->sreg];
37 h = reciprocal_scale(jhash(data, priv->len, priv->seed), priv->modulus);
38 regs->data[priv->dreg] = h + priv->offset;
41 static const struct nla_policy nft_hash_policy[NFTA_HASH_MAX + 1] = {
42 [NFTA_HASH_SREG] = { .type = NLA_U32 },
43 [NFTA_HASH_DREG] = { .type = NLA_U32 },
44 [NFTA_HASH_LEN] = { .type = NLA_U32 },
45 [NFTA_HASH_MODULUS] = { .type = NLA_U32 },
46 [NFTA_HASH_SEED] = { .type = NLA_U32 },
49 static int nft_hash_init(const struct nft_ctx *ctx,
50 const struct nft_expr *expr,
51 const struct nlattr * const tb[])
53 struct nft_hash *priv = nft_expr_priv(expr);
56 if (!tb[NFTA_HASH_SREG] ||
57 !tb[NFTA_HASH_DREG] ||
59 !tb[NFTA_HASH_SEED] ||
60 !tb[NFTA_HASH_MODULUS])
63 if (tb[NFTA_HASH_OFFSET])
64 priv->offset = ntohl(nla_get_be32(tb[NFTA_HASH_OFFSET]));
66 priv->sreg = nft_parse_register(tb[NFTA_HASH_SREG]);
67 priv->dreg = nft_parse_register(tb[NFTA_HASH_DREG]);
69 len = ntohl(nla_get_be32(tb[NFTA_HASH_LEN]));
70 if (len == 0 || len > U8_MAX)
75 priv->modulus = ntohl(nla_get_be32(tb[NFTA_HASH_MODULUS]));
76 if (priv->modulus <= 1)
79 if (priv->offset + priv->modulus - 1 < priv->offset)
82 priv->seed = ntohl(nla_get_be32(tb[NFTA_HASH_SEED]));
84 return nft_validate_register_load(priv->sreg, len) &&
85 nft_validate_register_store(ctx, priv->dreg, NULL,
86 NFT_DATA_VALUE, sizeof(u32));
89 static int nft_hash_dump(struct sk_buff *skb,
90 const struct nft_expr *expr)
92 const struct nft_hash *priv = nft_expr_priv(expr);
94 if (nft_dump_register(skb, NFTA_HASH_SREG, priv->sreg))
96 if (nft_dump_register(skb, NFTA_HASH_DREG, priv->dreg))
98 if (nla_put_be32(skb, NFTA_HASH_LEN, htonl(priv->len)))
100 if (nla_put_be32(skb, NFTA_HASH_MODULUS, htonl(priv->modulus)))
101 goto nla_put_failure;
102 if (nla_put_be32(skb, NFTA_HASH_SEED, htonl(priv->seed)))
103 goto nla_put_failure;
104 if (priv->offset != 0)
105 if (nla_put_be32(skb, NFTA_HASH_OFFSET, htonl(priv->offset)))
106 goto nla_put_failure;
113 static struct nft_expr_type nft_hash_type;
114 static const struct nft_expr_ops nft_hash_ops = {
115 .type = &nft_hash_type,
116 .size = NFT_EXPR_SIZE(sizeof(struct nft_hash)),
117 .eval = nft_hash_eval,
118 .init = nft_hash_init,
119 .dump = nft_hash_dump,
122 static struct nft_expr_type nft_hash_type __read_mostly = {
124 .ops = &nft_hash_ops,
125 .policy = nft_hash_policy,
126 .maxattr = NFTA_HASH_MAX,
127 .owner = THIS_MODULE,
130 static int __init nft_hash_module_init(void)
132 return nft_register_expr(&nft_hash_type);
135 static void __exit nft_hash_module_exit(void)
137 nft_unregister_expr(&nft_hash_type);
140 module_init(nft_hash_module_init);
141 module_exit(nft_hash_module_exit);
143 MODULE_LICENSE("GPL");
144 MODULE_AUTHOR("Laura Garcia <nevola@gmail.com>");
145 MODULE_ALIAS_NFT_EXPR("hash");