[linux-2.6-block.git] / net / netfilter / nft_rt.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2016 Anders K. Pedersen <akp@cohaesio.com>
 */

#include <linux/kernel.h>
#include <linux/netlink.h>
#include <linux/netfilter.h>
#include <linux/netfilter/nf_tables.h>
#include <net/dst.h>
#include <net/ip6_route.h>
#include <net/route.h>
#include <net/netfilter/nf_tables.h>
#include <net/netfilter/nf_tables_core.h>

struct nft_rt {
	enum nft_rt_keys	key:8;
	enum nft_registers	dreg:8;
};

static u16 get_tcpmss(const struct nft_pktinfo *pkt, const struct dst_entry *skbdst)
{
	u32 minlen = sizeof(struct ipv6hdr), mtu = dst_mtu(skbdst);
	const struct sk_buff *skb = pkt->skb;
	struct dst_entry *dst = NULL;
	struct flowi fl;

	memset(&fl, 0, sizeof(fl));

	switch (nft_pf(pkt)) {
	case NFPROTO_IPV4:
		fl.u.ip4.daddr = ip_hdr(skb)->saddr;
		minlen = sizeof(struct iphdr) + sizeof(struct tcphdr);
		break;
	case NFPROTO_IPV6:
		fl.u.ip6.daddr = ipv6_hdr(skb)->saddr;
		minlen = sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
		break;
	}

	nf_route(nft_net(pkt), &dst, &fl, false, nft_pf(pkt));
	if (dst) {
		mtu = min(mtu, dst_mtu(dst));
		dst_release(dst);
	}

	if (mtu <= minlen || mtu > 0xffff)
		return TCP_MSS_DEFAULT;

	return mtu - minlen;
}

void nft_rt_get_eval(const struct nft_expr *expr,
		     struct nft_regs *regs,
		     const struct nft_pktinfo *pkt)
{
	const struct nft_rt *priv = nft_expr_priv(expr);
	const struct sk_buff *skb = pkt->skb;
	u32 *dest = &regs->data[priv->dreg];
	const struct dst_entry *dst;

	dst = skb_dst(skb);
	if (!dst)
		goto err;

	switch (priv->key) {
#ifdef CONFIG_IP_ROUTE_CLASSID
	case NFT_RT_CLASSID:
		*dest = dst->tclassid;
		break;
#endif
	case NFT_RT_NEXTHOP4:
		if (nft_pf(pkt) != NFPROTO_IPV4)
			goto err;

		*dest = (__force u32)rt_nexthop((const struct rtable *)dst,
						ip_hdr(skb)->daddr);
		break;
	case NFT_RT_NEXTHOP6:
		if (nft_pf(pkt) != NFPROTO_IPV6)
			goto err;

		memcpy(dest, rt6_nexthop((struct rt6_info *)dst,
					 &ipv6_hdr(skb)->daddr),
		       sizeof(struct in6_addr));
		break;
	case NFT_RT_TCPMSS:
		nft_reg_store16(dest, get_tcpmss(pkt, dst));
		break;
#ifdef CONFIG_XFRM
	case NFT_RT_XFRM:
		nft_reg_store8(dest, !!dst->xfrm);
		break;
#endif
	default:
		WARN_ON(1);
		goto err;
	}
	return;

err:
	regs->verdict.code = NFT_BREAK;
}

static const struct nla_policy nft_rt_policy[NFTA_RT_MAX + 1] = {
	[NFTA_RT_DREG]		= { .type = NLA_U32 },
	[NFTA_RT_KEY]		= { .type = NLA_U32 },
};

static int nft_rt_get_init(const struct nft_ctx *ctx,
			   const struct nft_expr *expr,
			   const struct nlattr * const tb[])
{
	struct nft_rt *priv = nft_expr_priv(expr);
	unsigned int len;

	if (tb[NFTA_RT_KEY] == NULL ||
	    tb[NFTA_RT_DREG] == NULL)
		return -EINVAL;

	priv->key = ntohl(nla_get_be32(tb[NFTA_RT_KEY]));
	switch (priv->key) {
#ifdef CONFIG_IP_ROUTE_CLASSID
	case NFT_RT_CLASSID:
#endif
	case NFT_RT_NEXTHOP4:
		len = sizeof(u32);
		break;
	case NFT_RT_NEXTHOP6:
		len = sizeof(struct in6_addr);
		break;
	case NFT_RT_TCPMSS:
		len = sizeof(u16);
		break;
#ifdef CONFIG_XFRM
	case NFT_RT_XFRM:
		len = sizeof(u8);
		break;
#endif
	default:
		return -EOPNOTSUPP;
	}

	priv->dreg = nft_parse_register(tb[NFTA_RT_DREG]);
	return nft_validate_register_store(ctx, priv->dreg, NULL,
					   NFT_DATA_VALUE, len);
}

static int nft_rt_get_dump(struct sk_buff *skb,
			   const struct nft_expr *expr)
{
	const struct nft_rt *priv = nft_expr_priv(expr);

	if (nla_put_be32(skb, NFTA_RT_KEY, htonl(priv->key)))
		goto nla_put_failure;
	if (nft_dump_register(skb, NFTA_RT_DREG, priv->dreg))
		goto nla_put_failure;
	return 0;

nla_put_failure:
	return -1;
}

static int nft_rt_validate(const struct nft_ctx *ctx, const struct nft_expr *expr,
			   const struct nft_data **data)
{
	const struct nft_rt *priv = nft_expr_priv(expr);
	unsigned int hooks;

	switch (priv->key) {
	case NFT_RT_NEXTHOP4:
	case NFT_RT_NEXTHOP6:
	case NFT_RT_CLASSID:
	case NFT_RT_XFRM:
		return 0;
	case NFT_RT_TCPMSS:
		hooks = (1 << NF_INET_FORWARD) |
			(1 << NF_INET_LOCAL_OUT) |
			(1 << NF_INET_POST_ROUTING);
		break;
	default:
		return -EINVAL;
	}

	return nft_chain_validate_hooks(ctx->chain, hooks);
}

static const struct nft_expr_ops nft_rt_get_ops = {
	.type		= &nft_rt_type,
	.size		= NFT_EXPR_SIZE(sizeof(struct nft_rt)),
	.eval		= nft_rt_get_eval,
	.init		= nft_rt_get_init,
	.dump		= nft_rt_get_dump,
	.validate	= nft_rt_validate,
};

struct nft_expr_type nft_rt_type __read_mostly = {
	.name		= "rt",
	.ops		= &nft_rt_get_ops,
	.policy		= nft_rt_policy,
	.maxattr	= NFTA_RT_MAX,
	.owner		= THIS_MODULE,
};
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
2fa84193 AP	2	/*
2fa84193 AP	3	* Copyright (c) 2016 Anders K. Pedersen <akp@cohaesio.com>
2fa84193 AP	4	*/
	5
	6	#include <linux/kernel.h>
2fa84193 AP	7	#include <linux/netlink.h>
	8	#include <linux/netfilter.h>
	9	#include <linux/netfilter/nf_tables.h>
	10	#include <net/dst.h>
	11	#include <net/ip6_route.h>
	12	#include <net/route.h>
	13	#include <net/netfilter/nf_tables.h>
	14	#include <net/netfilter/nf_tables_core.h>
	15
	16	struct nft_rt {
	17	enum nft_rt_keys key:8;
	18	enum nft_registers dreg:8;
	19	};
	20
6b5dc98e FW	21	static u16 get_tcpmss(const struct nft_pktinfo pkt, const struct dst_entry skbdst)
	22	{
	23	u32 minlen = sizeof(struct ipv6hdr), mtu = dst_mtu(skbdst);
	24	const struct sk_buff *skb = pkt->skb;
3f87c08c	25	struct dst_entry *dst = NULL;
6b5dc98e FW	26	struct flowi fl;
	27
	28	memset(&fl, 0, sizeof(fl));
	29
	30	switch (nft_pf(pkt)) {
	31	case NFPROTO_IPV4:
	32	fl.u.ip4.daddr = ip_hdr(skb)->saddr;
1aff6471	33	minlen = sizeof(struct iphdr) + sizeof(struct tcphdr);
6b5dc98e FW	34	break;
	35	case NFPROTO_IPV6:
	36	fl.u.ip6.daddr = ipv6_hdr(skb)->saddr;
1aff6471	37	minlen = sizeof(struct ipv6hdr) + sizeof(struct tcphdr);
6b5dc98e FW	38	break;
	39	}
	40
3f87c08c PNA	41	nf_route(nft_net(pkt), &dst, &fl, false, nft_pf(pkt));
	42	if (dst) {
	43	mtu = min(mtu, dst_mtu(dst));
	44	dst_release(dst);
6b5dc98e FW	45	}
	46
	47	if (mtu <= minlen \|\| mtu > 0xffff)
	48	return TCP_MSS_DEFAULT;
	49
	50	return mtu - minlen;
	51	}
	52
10870dd8 FW	53	void nft_rt_get_eval(const struct nft_expr *expr,
	54	struct nft_regs *regs,
	55	const struct nft_pktinfo *pkt)
2fa84193 AP	56	{
	57	const struct nft_rt *priv = nft_expr_priv(expr);
	58	const struct sk_buff *skb = pkt->skb;
	59	u32 *dest = &regs->data[priv->dreg];
	60	const struct dst_entry *dst;
	61
	62	dst = skb_dst(skb);
	63	if (!dst)
	64	goto err;
	65
	66	switch (priv->key) {
	67	#ifdef CONFIG_IP_ROUTE_CLASSID
	68	case NFT_RT_CLASSID:
	69	*dest = dst->tclassid;
	70	break;
	71	#endif
	72	case NFT_RT_NEXTHOP4:
0e5a1c7e	73	if (nft_pf(pkt) != NFPROTO_IPV4)
2fa84193 AP	74	goto err;
2fa84193 AP	75
5fd02ebe FW	76	dest = (__force u32)rt_nexthop((const struct rtable )dst,
5fd02ebe FW	77	ip_hdr(skb)->daddr);
2fa84193 AP	78	break;
2fa84193 AP	79	case NFT_RT_NEXTHOP6:
0e5a1c7e	80	if (nft_pf(pkt) != NFPROTO_IPV6)
2fa84193 AP	81	goto err;
	82
	83	memcpy(dest, rt6_nexthop((struct rt6_info *)dst,
	84	&ipv6_hdr(skb)->daddr),
	85	sizeof(struct in6_addr));
	86	break;
6b5dc98e FW	87	case NFT_RT_TCPMSS:
	88	nft_reg_store16(dest, get_tcpmss(pkt, dst));
	89	break;
02b408fa FW	90	#ifdef CONFIG_XFRM
	91	case NFT_RT_XFRM:
	92	nft_reg_store8(dest, !!dst->xfrm);
	93	break;
	94	#endif
2fa84193 AP	95	default:
	96	WARN_ON(1);
	97	goto err;
	98	}
	99	return;
	100
	101	err:
	102	regs->verdict.code = NFT_BREAK;
	103	}
	104
5fd02ebe	105	static const struct nla_policy nft_rt_policy[NFTA_RT_MAX + 1] = {
2fa84193 AP	106	[NFTA_RT_DREG] = { .type = NLA_U32 },
	107	[NFTA_RT_KEY] = { .type = NLA_U32 },
	108	};
	109
cad43944	110	static int nft_rt_get_init(const struct nft_ctx *ctx,
	111	const struct nft_expr *expr,
	112	const struct nlattr * const tb[])
2fa84193 AP	113	{
	114	struct nft_rt *priv = nft_expr_priv(expr);
	115	unsigned int len;
	116
	117	if (tb[NFTA_RT_KEY] == NULL \|\|
	118	tb[NFTA_RT_DREG] == NULL)
	119	return -EINVAL;
	120
	121	priv->key = ntohl(nla_get_be32(tb[NFTA_RT_KEY]));
	122	switch (priv->key) {
	123	#ifdef CONFIG_IP_ROUTE_CLASSID
	124	case NFT_RT_CLASSID:
	125	#endif
	126	case NFT_RT_NEXTHOP4:
	127	len = sizeof(u32);
	128	break;
	129	case NFT_RT_NEXTHOP6:
	130	len = sizeof(struct in6_addr);
	131	break;
6b5dc98e FW	132	case NFT_RT_TCPMSS:
	133	len = sizeof(u16);
	134	break;
02b408fa FW	135	#ifdef CONFIG_XFRM
	136	case NFT_RT_XFRM:
	137	len = sizeof(u8);
	138	break;
	139	#endif
2fa84193 AP	140	default:
	141	return -EOPNOTSUPP;
	142	}
	143
	144	priv->dreg = nft_parse_register(tb[NFTA_RT_DREG]);
	145	return nft_validate_register_store(ctx, priv->dreg, NULL,
	146	NFT_DATA_VALUE, len);
	147	}
	148
cad43944	149	static int nft_rt_get_dump(struct sk_buff *skb,
cad43944	150	const struct nft_expr *expr)
2fa84193 AP	151	{
	152	const struct nft_rt *priv = nft_expr_priv(expr);
	153
	154	if (nla_put_be32(skb, NFTA_RT_KEY, htonl(priv->key)))
	155	goto nla_put_failure;
	156	if (nft_dump_register(skb, NFTA_RT_DREG, priv->dreg))
	157	goto nla_put_failure;
	158	return 0;
	159
	160	nla_put_failure:
	161	return -1;
	162	}
	163
6b5dc98e FW	164	static int nft_rt_validate(const struct nft_ctx ctx, const struct nft_expr expr,
	165	const struct nft_data **data)
	166	{
	167	const struct nft_rt *priv = nft_expr_priv(expr);
	168	unsigned int hooks;
	169
	170	switch (priv->key) {
	171	case NFT_RT_NEXTHOP4:
	172	case NFT_RT_NEXTHOP6:
	173	case NFT_RT_CLASSID:
02b408fa	174	case NFT_RT_XFRM:
6b5dc98e FW	175	return 0;
	176	case NFT_RT_TCPMSS:
	177	hooks = (1 << NF_INET_FORWARD) \|
	178	(1 << NF_INET_LOCAL_OUT) \|
	179	(1 << NF_INET_POST_ROUTING);
	180	break;
	181	default:
	182	return -EINVAL;
	183	}
	184
	185	return nft_chain_validate_hooks(ctx->chain, hooks);
	186	}
	187
2fa84193 AP	188	static const struct nft_expr_ops nft_rt_get_ops = {
	189	.type = &nft_rt_type,
	190	.size = NFT_EXPR_SIZE(sizeof(struct nft_rt)),
	191	.eval = nft_rt_get_eval,
	192	.init = nft_rt_get_init,
	193	.dump = nft_rt_get_dump,
6b5dc98e	194	.validate = nft_rt_validate,
2fa84193 AP	195	};
2fa84193 AP	196
ae1bc6a9	197	struct nft_expr_type nft_rt_type __read_mostly = {
2fa84193 AP	198	.name = "rt",
	199	.ops = &nft_rt_get_ops,
	200	.policy = nft_rt_policy,
	201	.maxattr = NFTA_RT_MAX,
	202	.owner = THIS_MODULE,
	203	};