2 * Copyright (c) 2008-2009 Patrick McHardy <kaber@trash.net>
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.
8 * Development of this code funded by Astaro AG (http://www.astaro.com/)
11 #include <linux/kernel.h>
12 #include <linux/init.h>
13 #include <linux/module.h>
14 #include <linux/netlink.h>
15 #include <linux/netfilter.h>
16 #include <linux/netfilter/nf_tables.h>
17 #include <net/netfilter/nf_tables.h>
18 #include <net/netfilter/nf_conntrack.h>
19 #include <net/netfilter/nf_conntrack_tuple.h>
20 #include <net/netfilter/nf_conntrack_helper.h>
21 #include <net/netfilter/nf_conntrack_ecache.h>
22 #include <net/netfilter/nf_conntrack_labels.h>
25 enum nft_ct_keys key:8;
26 enum ip_conntrack_dir dir:8;
28 enum nft_registers dreg:8;
29 enum nft_registers sreg:8;
33 static void nft_ct_get_eval(const struct nft_expr *expr,
34 struct nft_data data[NFT_REG_MAX + 1],
35 const struct nft_pktinfo *pkt)
37 const struct nft_ct *priv = nft_expr_priv(expr);
38 struct nft_data *dest = &data[priv->dreg];
39 enum ip_conntrack_info ctinfo;
40 const struct nf_conn *ct;
41 const struct nf_conn_help *help;
42 const struct nf_conntrack_tuple *tuple;
43 const struct nf_conntrack_helper *helper;
47 ct = nf_ct_get(pkt->skb, &ctinfo);
52 state = NF_CT_STATE_INVALID_BIT;
53 else if (nf_ct_is_untracked(ct))
54 state = NF_CT_STATE_UNTRACKED_BIT;
56 state = NF_CT_STATE_BIT(ctinfo);
57 dest->data[0] = state;
65 case NFT_CT_DIRECTION:
66 dest->data[0] = CTINFO2DIR(ctinfo);
69 dest->data[0] = ct->status;
71 #ifdef CONFIG_NF_CONNTRACK_MARK
73 dest->data[0] = ct->mark;
76 #ifdef CONFIG_NF_CONNTRACK_SECMARK
78 dest->data[0] = ct->secmark;
81 case NFT_CT_EXPIRATION:
82 diff = (long)jiffies - (long)ct->timeout.expires;
85 dest->data[0] = jiffies_to_msecs(diff);
88 if (ct->master == NULL)
90 help = nfct_help(ct->master);
93 helper = rcu_dereference(help->helper);
96 if (strlen(helper->name) >= sizeof(dest->data))
98 strncpy((char *)dest->data, helper->name, sizeof(dest->data));
100 #ifdef CONFIG_NF_CONNTRACK_LABELS
101 case NFT_CT_LABELS: {
102 struct nf_conn_labels *labels = nf_ct_labels_find(ct);
106 memset(dest->data, 0, sizeof(dest->data));
110 BUILD_BUG_ON(NF_CT_LABELS_MAX_SIZE > sizeof(dest->data));
111 size = labels->words * sizeof(long);
113 memcpy(dest->data, labels->bits, size);
114 if (size < sizeof(dest->data))
115 memset(((char *) dest->data) + size, 0,
116 sizeof(dest->data) - size);
122 tuple = &ct->tuplehash[priv->dir].tuple;
124 case NFT_CT_L3PROTOCOL:
125 dest->data[0] = nf_ct_l3num(ct);
128 memcpy(dest->data, tuple->src.u3.all,
129 nf_ct_l3num(ct) == NFPROTO_IPV4 ? 4 : 16);
132 memcpy(dest->data, tuple->dst.u3.all,
133 nf_ct_l3num(ct) == NFPROTO_IPV4 ? 4 : 16);
135 case NFT_CT_PROTOCOL:
136 dest->data[0] = nf_ct_protonum(ct);
138 case NFT_CT_PROTO_SRC:
139 dest->data[0] = (__force __u16)tuple->src.u.all;
141 case NFT_CT_PROTO_DST:
142 dest->data[0] = (__force __u16)tuple->dst.u.all;
147 data[NFT_REG_VERDICT].verdict = NFT_BREAK;
150 static void nft_ct_set_eval(const struct nft_expr *expr,
151 struct nft_data data[NFT_REG_MAX + 1],
152 const struct nft_pktinfo *pkt)
154 const struct nft_ct *priv = nft_expr_priv(expr);
155 struct sk_buff *skb = pkt->skb;
156 #ifdef CONFIG_NF_CONNTRACK_MARK
157 u32 value = data[priv->sreg].data[0];
159 enum ip_conntrack_info ctinfo;
162 ct = nf_ct_get(skb, &ctinfo);
167 #ifdef CONFIG_NF_CONNTRACK_MARK
169 if (ct->mark != value) {
171 nf_conntrack_event_cache(IPCT_MARK, ct);
178 static const struct nla_policy nft_ct_policy[NFTA_CT_MAX + 1] = {
179 [NFTA_CT_DREG] = { .type = NLA_U32 },
180 [NFTA_CT_KEY] = { .type = NLA_U32 },
181 [NFTA_CT_DIRECTION] = { .type = NLA_U8 },
182 [NFTA_CT_SREG] = { .type = NLA_U32 },
185 static int nft_ct_l3proto_try_module_get(uint8_t family)
189 if (family == NFPROTO_INET) {
190 err = nf_ct_l3proto_try_module_get(NFPROTO_IPV4);
193 err = nf_ct_l3proto_try_module_get(NFPROTO_IPV6);
197 err = nf_ct_l3proto_try_module_get(family);
204 nf_ct_l3proto_module_put(NFPROTO_IPV4);
209 static void nft_ct_l3proto_module_put(uint8_t family)
211 if (family == NFPROTO_INET) {
212 nf_ct_l3proto_module_put(NFPROTO_IPV4);
213 nf_ct_l3proto_module_put(NFPROTO_IPV6);
215 nf_ct_l3proto_module_put(family);
218 static int nft_ct_init_validate_get(const struct nft_expr *expr,
219 const struct nlattr * const tb[])
221 struct nft_ct *priv = nft_expr_priv(expr);
223 if (tb[NFTA_CT_DIRECTION] != NULL) {
224 priv->dir = nla_get_u8(tb[NFTA_CT_DIRECTION]);
226 case IP_CT_DIR_ORIGINAL:
227 case IP_CT_DIR_REPLY:
236 case NFT_CT_DIRECTION:
238 #ifdef CONFIG_NF_CONNTRACK_MARK
241 #ifdef CONFIG_NF_CONNTRACK_SECMARK
244 #ifdef CONFIG_NF_CONNTRACK_LABELS
247 case NFT_CT_EXPIRATION:
249 if (tb[NFTA_CT_DIRECTION] != NULL)
252 case NFT_CT_L3PROTOCOL:
253 case NFT_CT_PROTOCOL:
256 case NFT_CT_PROTO_SRC:
257 case NFT_CT_PROTO_DST:
258 if (tb[NFTA_CT_DIRECTION] == NULL)
268 static int nft_ct_init_validate_set(uint32_t key)
280 static int nft_ct_init(const struct nft_ctx *ctx,
281 const struct nft_expr *expr,
282 const struct nlattr * const tb[])
284 struct nft_ct *priv = nft_expr_priv(expr);
287 priv->key = ntohl(nla_get_be32(tb[NFTA_CT_KEY]));
289 if (tb[NFTA_CT_DREG]) {
290 err = nft_ct_init_validate_get(expr, tb);
294 priv->dreg = ntohl(nla_get_be32(tb[NFTA_CT_DREG]));
295 err = nft_validate_output_register(priv->dreg);
299 err = nft_validate_data_load(ctx, priv->dreg, NULL,
304 err = nft_ct_init_validate_set(priv->key);
308 priv->sreg = ntohl(nla_get_be32(tb[NFTA_CT_SREG]));
309 err = nft_validate_input_register(priv->sreg);
314 err = nft_ct_l3proto_try_module_get(ctx->afi->family);
321 static void nft_ct_destroy(const struct nft_ctx *ctx,
322 const struct nft_expr *expr)
324 nft_ct_l3proto_module_put(ctx->afi->family);
327 static int nft_ct_get_dump(struct sk_buff *skb, const struct nft_expr *expr)
329 const struct nft_ct *priv = nft_expr_priv(expr);
331 if (nla_put_be32(skb, NFTA_CT_DREG, htonl(priv->dreg)))
332 goto nla_put_failure;
333 if (nla_put_be32(skb, NFTA_CT_KEY, htonl(priv->key)))
334 goto nla_put_failure;
337 case NFT_CT_PROTOCOL:
340 case NFT_CT_PROTO_SRC:
341 case NFT_CT_PROTO_DST:
342 if (nla_put_u8(skb, NFTA_CT_DIRECTION, priv->dir))
343 goto nla_put_failure;
354 static int nft_ct_set_dump(struct sk_buff *skb, const struct nft_expr *expr)
356 const struct nft_ct *priv = nft_expr_priv(expr);
358 if (nla_put_be32(skb, NFTA_CT_SREG, htonl(priv->sreg)))
359 goto nla_put_failure;
360 if (nla_put_be32(skb, NFTA_CT_KEY, htonl(priv->key)))
361 goto nla_put_failure;
368 static struct nft_expr_type nft_ct_type;
369 static const struct nft_expr_ops nft_ct_get_ops = {
370 .type = &nft_ct_type,
371 .size = NFT_EXPR_SIZE(sizeof(struct nft_ct)),
372 .eval = nft_ct_get_eval,
374 .destroy = nft_ct_destroy,
375 .dump = nft_ct_get_dump,
378 static const struct nft_expr_ops nft_ct_set_ops = {
379 .type = &nft_ct_type,
380 .size = NFT_EXPR_SIZE(sizeof(struct nft_ct)),
381 .eval = nft_ct_set_eval,
383 .destroy = nft_ct_destroy,
384 .dump = nft_ct_set_dump,
387 static const struct nft_expr_ops *
388 nft_ct_select_ops(const struct nft_ctx *ctx,
389 const struct nlattr * const tb[])
391 if (tb[NFTA_CT_KEY] == NULL)
392 return ERR_PTR(-EINVAL);
394 if (tb[NFTA_CT_DREG] && tb[NFTA_CT_SREG])
395 return ERR_PTR(-EINVAL);
397 if (tb[NFTA_CT_DREG])
398 return &nft_ct_get_ops;
400 if (tb[NFTA_CT_SREG])
401 return &nft_ct_set_ops;
403 return ERR_PTR(-EINVAL);
406 static struct nft_expr_type nft_ct_type __read_mostly = {
408 .select_ops = &nft_ct_select_ops,
409 .policy = nft_ct_policy,
410 .maxattr = NFTA_CT_MAX,
411 .owner = THIS_MODULE,
414 static int __init nft_ct_module_init(void)
416 return nft_register_expr(&nft_ct_type);
419 static void __exit nft_ct_module_exit(void)
421 nft_unregister_expr(&nft_ct_type);
424 module_init(nft_ct_module_init);
425 module_exit(nft_ct_module_exit);
427 MODULE_LICENSE("GPL");
428 MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
429 MODULE_ALIAS_NFT_EXPR("ct");