[mirror_ubuntu-zesty-kernel.git] / net / netfilter / nft_meta.c

/*
 * Copyright (c) 2008-2009 Patrick McHardy <kaber@trash.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Development of this code funded by Astaro AG (http://www.astaro.com/)
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/netlink.h>
#include <linux/netfilter.h>
#include <linux/netfilter/nf_tables.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/ipv6.h>
#include <linux/smp.h>
#include <linux/static_key.h>
#include <net/dst.h>
#include <net/sock.h>
#include <net/tcp_states.h> /* for TCP_TIME_WAIT */
#include <net/netfilter/nf_tables.h>
#include <net/netfilter/nf_tables_core.h>
#include <net/netfilter/nft_meta.h>

#include <uapi/linux/netfilter_bridge.h> /* NF_BR_PRE_ROUTING */

static DEFINE_PER_CPU(struct rnd_state, nft_prandom_state);

void nft_meta_get_eval(const struct nft_expr *expr,
		       struct nft_regs *regs,
		       const struct nft_pktinfo *pkt)
{
	const struct nft_meta *priv = nft_expr_priv(expr);
	const struct sk_buff *skb = pkt->skb;
	const struct net_device *in = nft_in(pkt), *out = nft_out(pkt);
	struct sock *sk;
	u32 *dest = &regs->data[priv->dreg];

	switch (priv->key) {
	case NFT_META_LEN:
		*dest = skb->len;
		break;
	case NFT_META_PROTOCOL:
		*dest = 0;
		*(__be16 *)dest = skb->protocol;
		break;
	case NFT_META_NFPROTO:
		*dest = nft_pf(pkt);
		break;
	case NFT_META_L4PROTO:
		if (!pkt->tprot_set)
			goto err;
		*dest = pkt->tprot;
		break;
	case NFT_META_PRIORITY:
		*dest = skb->priority;
		break;
	case NFT_META_MARK:
		*dest = skb->mark;
		break;
	case NFT_META_IIF:
		if (in == NULL)
			goto err;
		*dest = in->ifindex;
		break;
	case NFT_META_OIF:
		if (out == NULL)
			goto err;
		*dest = out->ifindex;
		break;
	case NFT_META_IIFNAME:
		if (in == NULL)
			goto err;
		strncpy((char *)dest, in->name, IFNAMSIZ);
		break;
	case NFT_META_OIFNAME:
		if (out == NULL)
			goto err;
		strncpy((char *)dest, out->name, IFNAMSIZ);
		break;
	case NFT_META_IIFTYPE:
		if (in == NULL)
			goto err;
		*dest = 0;
		*(u16 *)dest = in->type;
		break;
	case NFT_META_OIFTYPE:
		if (out == NULL)
			goto err;
		*dest = 0;
		*(u16 *)dest = out->type;
		break;
	case NFT_META_SKUID:
		sk = skb_to_full_sk(skb);
		if (!sk || !sk_fullsock(sk))
			goto err;

		read_lock_bh(&sk->sk_callback_lock);
		if (sk->sk_socket == NULL ||
		    sk->sk_socket->file == NULL) {
			read_unlock_bh(&sk->sk_callback_lock);
			goto err;
		}

		*dest =	from_kuid_munged(&init_user_ns,
				sk->sk_socket->file->f_cred->fsuid);
		read_unlock_bh(&sk->sk_callback_lock);
		break;
	case NFT_META_SKGID:
		sk = skb_to_full_sk(skb);
		if (!sk || !sk_fullsock(sk))
			goto err;

		read_lock_bh(&sk->sk_callback_lock);
		if (sk->sk_socket == NULL ||
		    sk->sk_socket->file == NULL) {
			read_unlock_bh(&sk->sk_callback_lock);
			goto err;
		}
		*dest =	from_kgid_munged(&init_user_ns,
				 sk->sk_socket->file->f_cred->fsgid);
		read_unlock_bh(&sk->sk_callback_lock);
		break;
#ifdef CONFIG_IP_ROUTE_CLASSID
	case NFT_META_RTCLASSID: {
		const struct dst_entry *dst = skb_dst(skb);

		if (dst == NULL)
			goto err;
		*dest = dst->tclassid;
		break;
	}
#endif
#ifdef CONFIG_NETWORK_SECMARK
	case NFT_META_SECMARK:
		*dest = skb->secmark;
		break;
#endif
	case NFT_META_PKTTYPE:
		if (skb->pkt_type != PACKET_LOOPBACK) {
			*dest = skb->pkt_type;
			break;
		}

		switch (nft_pf(pkt)) {
		case NFPROTO_IPV4:
			if (ipv4_is_multicast(ip_hdr(skb)->daddr))
				*dest = PACKET_MULTICAST;
			else
				*dest = PACKET_BROADCAST;
			break;
		case NFPROTO_IPV6:
			if (ipv6_hdr(skb)->daddr.s6_addr[0] == 0xFF)
				*dest = PACKET_MULTICAST;
			else
				*dest = PACKET_BROADCAST;
			break;
		default:
			WARN_ON(1);
			goto err;
		}
		break;
	case NFT_META_CPU:
		*dest = raw_smp_processor_id();
		break;
	case NFT_META_IIFGROUP:
		if (in == NULL)
			goto err;
		*dest = in->group;
		break;
	case NFT_META_OIFGROUP:
		if (out == NULL)
			goto err;
		*dest = out->group;
		break;
#ifdef CONFIG_CGROUP_NET_CLASSID
	case NFT_META_CGROUP:
		sk = skb_to_full_sk(skb);
		if (!sk || !sk_fullsock(sk))
			goto err;
		*dest = sock_cgroup_classid(&sk->sk_cgrp_data);
		break;
#endif
	case NFT_META_PRANDOM: {
		struct rnd_state *state = this_cpu_ptr(&nft_prandom_state);
		*dest = prandom_u32_state(state);
		break;
	}
	default:
		WARN_ON(1);
		goto err;
	}
	return;

err:
	regs->verdict.code = NFT_BREAK;
}
EXPORT_SYMBOL_GPL(nft_meta_get_eval);

void nft_meta_set_eval(const struct nft_expr *expr,
		       struct nft_regs *regs,
		       const struct nft_pktinfo *pkt)
{
	const struct nft_meta *meta = nft_expr_priv(expr);
	struct sk_buff *skb = pkt->skb;
	u32 value = regs->data[meta->sreg];

	switch (meta->key) {
	case NFT_META_MARK:
		skb->mark = value;
		break;
	case NFT_META_PRIORITY:
		skb->priority = value;
		break;
	case NFT_META_PKTTYPE:
		if (skb->pkt_type != value &&
		    skb_pkt_type_ok(value) && skb_pkt_type_ok(skb->pkt_type))
			skb->pkt_type = value;
		break;
	case NFT_META_NFTRACE:
		skb->nf_trace = !!value;
		break;
	default:
		WARN_ON(1);
	}
}
EXPORT_SYMBOL_GPL(nft_meta_set_eval);

const struct nla_policy nft_meta_policy[NFTA_META_MAX + 1] = {
	[NFTA_META_DREG]	= { .type = NLA_U32 },
	[NFTA_META_KEY]		= { .type = NLA_U32 },
	[NFTA_META_SREG]	= { .type = NLA_U32 },
};
EXPORT_SYMBOL_GPL(nft_meta_policy);

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

	priv->key = ntohl(nla_get_be32(tb[NFTA_META_KEY]));
	switch (priv->key) {
	case NFT_META_PROTOCOL:
	case NFT_META_IIFTYPE:
	case NFT_META_OIFTYPE:
		len = sizeof(u16);
		break;
	case NFT_META_NFPROTO:
	case NFT_META_L4PROTO:
	case NFT_META_LEN:
	case NFT_META_PRIORITY:
	case NFT_META_MARK:
	case NFT_META_IIF:
	case NFT_META_OIF:
	case NFT_META_SKUID:
	case NFT_META_SKGID:
#ifdef CONFIG_IP_ROUTE_CLASSID
	case NFT_META_RTCLASSID:
#endif
#ifdef CONFIG_NETWORK_SECMARK
	case NFT_META_SECMARK:
#endif
	case NFT_META_PKTTYPE:
	case NFT_META_CPU:
	case NFT_META_IIFGROUP:
	case NFT_META_OIFGROUP:
#ifdef CONFIG_CGROUP_NET_CLASSID
	case NFT_META_CGROUP:
#endif
		len = sizeof(u32);
		break;
	case NFT_META_IIFNAME:
	case NFT_META_OIFNAME:
		len = IFNAMSIZ;
		break;
	case NFT_META_PRANDOM:
		prandom_init_once(&nft_prandom_state);
		len = sizeof(u32);
		break;
	default:
		return -EOPNOTSUPP;
	}

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

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

	if (priv->key != NFT_META_PKTTYPE)
		return 0;

	switch (ctx->afi->family) {
	case NFPROTO_BRIDGE:
		hooks = 1 << NF_BR_PRE_ROUTING;
		break;
	case NFPROTO_NETDEV:
		hooks = 1 << NF_NETDEV_INGRESS;
		break;
	case NFPROTO_IPV4:
	case NFPROTO_IPV6:
	case NFPROTO_INET:
		hooks = 1 << NF_INET_PRE_ROUTING;
		break;
	default:
		return -EOPNOTSUPP;
	}

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

int nft_meta_set_init(const struct nft_ctx *ctx,
		      const struct nft_expr *expr,
		      const struct nlattr * const tb[])
{
	struct nft_meta *priv = nft_expr_priv(expr);
	unsigned int len;
	int err;

	priv->key = ntohl(nla_get_be32(tb[NFTA_META_KEY]));
	switch (priv->key) {
	case NFT_META_MARK:
	case NFT_META_PRIORITY:
		len = sizeof(u32);
		break;
	case NFT_META_NFTRACE:
		len = sizeof(u8);
		break;
	case NFT_META_PKTTYPE:
		len = sizeof(u8);
		break;
	default:
		return -EOPNOTSUPP;
	}

	err = nft_meta_set_validate(ctx, expr, NULL);
	if (err < 0)
		return err;

	priv->sreg = nft_parse_register(tb[NFTA_META_SREG]);
	err = nft_validate_register_load(priv->sreg, len);
	if (err < 0)
		return err;

	if (priv->key == NFT_META_NFTRACE)
		static_branch_inc(&nft_trace_enabled);

	return 0;
}
EXPORT_SYMBOL_GPL(nft_meta_set_init);

int nft_meta_get_dump(struct sk_buff *skb,
		      const struct nft_expr *expr)
{
	const struct nft_meta *priv = nft_expr_priv(expr);

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

nla_put_failure:
	return -1;
}
EXPORT_SYMBOL_GPL(nft_meta_get_dump);

int nft_meta_set_dump(struct sk_buff *skb,
		      const struct nft_expr *expr)
{
	const struct nft_meta *priv = nft_expr_priv(expr);

	if (nla_put_be32(skb, NFTA_META_KEY, htonl(priv->key)))
		goto nla_put_failure;
	if (nft_dump_register(skb, NFTA_META_SREG, priv->sreg))
		goto nla_put_failure;

	return 0;

nla_put_failure:
	return -1;
}
EXPORT_SYMBOL_GPL(nft_meta_set_dump);

void nft_meta_set_destroy(const struct nft_ctx *ctx,
			  const struct nft_expr *expr)
{
	const struct nft_meta *priv = nft_expr_priv(expr);

	if (priv->key == NFT_META_NFTRACE)
		static_branch_dec(&nft_trace_enabled);
}
EXPORT_SYMBOL_GPL(nft_meta_set_destroy);

static struct nft_expr_type nft_meta_type;
static const struct nft_expr_ops nft_meta_get_ops = {
	.type		= &nft_meta_type,
	.size		= NFT_EXPR_SIZE(sizeof(struct nft_meta)),
	.eval		= nft_meta_get_eval,
	.init		= nft_meta_get_init,
	.dump		= nft_meta_get_dump,
};

static const struct nft_expr_ops nft_meta_set_ops = {
	.type		= &nft_meta_type,
	.size		= NFT_EXPR_SIZE(sizeof(struct nft_meta)),
	.eval		= nft_meta_set_eval,
	.init		= nft_meta_set_init,
	.destroy	= nft_meta_set_destroy,
	.dump		= nft_meta_set_dump,
	.validate	= nft_meta_set_validate,
};

static const struct nft_expr_ops *
nft_meta_select_ops(const struct nft_ctx *ctx,
		    const struct nlattr * const tb[])
{
	if (tb[NFTA_META_KEY] == NULL)
		return ERR_PTR(-EINVAL);

	if (tb[NFTA_META_DREG] && tb[NFTA_META_SREG])
		return ERR_PTR(-EINVAL);

	if (tb[NFTA_META_DREG])
		return &nft_meta_get_ops;

	if (tb[NFTA_META_SREG])
		return &nft_meta_set_ops;

	return ERR_PTR(-EINVAL);
}

static struct nft_expr_type nft_meta_type __read_mostly = {
	.name		= "meta",
	.select_ops	= &nft_meta_select_ops,
	.policy		= nft_meta_policy,
	.maxattr	= NFTA_META_MAX,
	.owner		= THIS_MODULE,
};

static int __init nft_meta_module_init(void)
{
	return nft_register_expr(&nft_meta_type);
}

static void __exit nft_meta_module_exit(void)
{
	nft_unregister_expr(&nft_meta_type);
}

module_init(nft_meta_module_init);
module_exit(nft_meta_module_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
MODULE_ALIAS_NFT_EXPR("meta");
Commit	Line	Data
96518518	1	/*
ef1f7df9	2	* Copyright (c) 2008-2009 Patrick McHardy <kaber@trash.net>
96518518 PM	3	*
	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.
	7	*
	8	* Development of this code funded by Astaro AG (http://www.astaro.com/)
	9	*/
	10
	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>
e2a093ff AR	17	#include <linux/in.h>
	18	#include <linux/ip.h>
	19	#include <linux/ipv6.h>
afc5be30	20	#include <linux/smp.h>
e639f7ab	21	#include <linux/static_key.h>
96518518 PM	22	#include <net/dst.h>
	23	#include <net/sock.h>
	24	#include <net/tcp_states.h> /* for TCP_TIME_WAIT */
	25	#include <net/netfilter/nf_tables.h>
e639f7ab	26	#include <net/netfilter/nf_tables_core.h>
aa45660c	27	#include <net/netfilter/nft_meta.h>
96518518	28
b4aae759 FW	29	#include <uapi/linux/netfilter_bridge.h> /* NF_BR_PRE_ROUTING */
b4aae759 FW	30
b07edbe1 FW	31	static DEFINE_PER_CPU(struct rnd_state, nft_prandom_state);
b07edbe1 FW	32
aa45660c	33	void nft_meta_get_eval(const struct nft_expr *expr,
a55e22e9	34	struct nft_regs *regs,
aa45660c	35	const struct nft_pktinfo *pkt)
96518518 PM	36	{
	37	const struct nft_meta *priv = nft_expr_priv(expr);
	38	const struct sk_buff *skb = pkt->skb;
0e5a1c7e	39	const struct net_device in = nft_in(pkt), out = nft_out(pkt);
3aed8225	40	struct sock *sk;
49499c3e	41	u32 *dest = &regs->data[priv->dreg];
96518518 PM	42
	43	switch (priv->key) {
	44	case NFT_META_LEN:
fad136ea	45	*dest = skb->len;
96518518 PM	46	break;
96518518 PM	47	case NFT_META_PROTOCOL:
49499c3e	48	*dest = 0;
fad136ea	49	(__be16 )dest = skb->protocol;
96518518	50	break;
124edfa9	51	case NFT_META_NFPROTO:
0e5a1c7e	52	*dest = nft_pf(pkt);
124edfa9	53	break;
4566bf27	54	case NFT_META_L4PROTO:
beac5afa PNA	55	if (!pkt->tprot_set)
beac5afa PNA	56	goto err;
fad136ea	57	*dest = pkt->tprot;
4566bf27	58	break;
96518518	59	case NFT_META_PRIORITY:
fad136ea	60	*dest = skb->priority;
96518518 PM	61	break;
96518518 PM	62	case NFT_META_MARK:
fad136ea	63	*dest = skb->mark;
96518518 PM	64	break;
	65	case NFT_META_IIF:
	66	if (in == NULL)
	67	goto err;
fad136ea	68	*dest = in->ifindex;
96518518 PM	69	break;
	70	case NFT_META_OIF:
	71	if (out == NULL)
	72	goto err;
fad136ea	73	*dest = out->ifindex;
96518518 PM	74	break;
	75	case NFT_META_IIFNAME:
	76	if (in == NULL)
	77	goto err;
fad136ea	78	strncpy((char *)dest, in->name, IFNAMSIZ);
96518518 PM	79	break;
	80	case NFT_META_OIFNAME:
	81	if (out == NULL)
	82	goto err;
fad136ea	83	strncpy((char *)dest, out->name, IFNAMSIZ);
96518518 PM	84	break;
	85	case NFT_META_IIFTYPE:
	86	if (in == NULL)
	87	goto err;
49499c3e	88	*dest = 0;
fad136ea	89	(u16 )dest = in->type;
96518518 PM	90	break;
	91	case NFT_META_OIFTYPE:
	92	if (out == NULL)
	93	goto err;
49499c3e	94	*dest = 0;
fad136ea	95	(u16 )dest = out->type;
96518518 PM	96	break;
96518518 PM	97	case NFT_META_SKUID:
3aed8225 ED	98	sk = skb_to_full_sk(skb);
3aed8225 ED	99	if (!sk \|\| !sk_fullsock(sk))
96518518 PM	100	goto err;
96518518 PM	101
3aed8225 ED	102	read_lock_bh(&sk->sk_callback_lock);
	103	if (sk->sk_socket == NULL \|\|
	104	sk->sk_socket->file == NULL) {
	105	read_unlock_bh(&sk->sk_callback_lock);
96518518 PM	106	goto err;
	107	}
	108
fad136ea	109	*dest = from_kuid_munged(&init_user_ns,
3aed8225 ED	110	sk->sk_socket->file->f_cred->fsuid);
3aed8225 ED	111	read_unlock_bh(&sk->sk_callback_lock);
96518518 PM	112	break;
96518518 PM	113	case NFT_META_SKGID:
3aed8225 ED	114	sk = skb_to_full_sk(skb);
3aed8225 ED	115	if (!sk \|\| !sk_fullsock(sk))
96518518 PM	116	goto err;
96518518 PM	117
3aed8225 ED	118	read_lock_bh(&sk->sk_callback_lock);
	119	if (sk->sk_socket == NULL \|\|
	120	sk->sk_socket->file == NULL) {
	121	read_unlock_bh(&sk->sk_callback_lock);
96518518 PM	122	goto err;
96518518 PM	123	}
fad136ea	124	*dest = from_kgid_munged(&init_user_ns,
3aed8225 ED	125	sk->sk_socket->file->f_cred->fsgid);
3aed8225 ED	126	read_unlock_bh(&sk->sk_callback_lock);
96518518	127	break;
06efbd6d	128	#ifdef CONFIG_IP_ROUTE_CLASSID
96518518 PM	129	case NFT_META_RTCLASSID: {
	130	const struct dst_entry *dst = skb_dst(skb);
	131
	132	if (dst == NULL)
	133	goto err;
fad136ea	134	*dest = dst->tclassid;
96518518 PM	135	break;
	136	}
	137	#endif
	138	#ifdef CONFIG_NETWORK_SECMARK
	139	case NFT_META_SECMARK:
fad136ea	140	*dest = skb->secmark;
96518518 PM	141	break;
96518518 PM	142	#endif
e2a093ff AR	143	case NFT_META_PKTTYPE:
e2a093ff AR	144	if (skb->pkt_type != PACKET_LOOPBACK) {
fad136ea	145	*dest = skb->pkt_type;
e2a093ff AR	146	break;
	147	}
	148
0e5a1c7e	149	switch (nft_pf(pkt)) {
e2a093ff AR	150	case NFPROTO_IPV4:
e2a093ff AR	151	if (ipv4_is_multicast(ip_hdr(skb)->daddr))
fad136ea	152	*dest = PACKET_MULTICAST;
e2a093ff	153	else
fad136ea	154	*dest = PACKET_BROADCAST;
e2a093ff AR	155	break;
	156	case NFPROTO_IPV6:
	157	if (ipv6_hdr(skb)->daddr.s6_addr[0] == 0xFF)
fad136ea	158	*dest = PACKET_MULTICAST;
e2a093ff	159	else
fad136ea	160	*dest = PACKET_BROADCAST;
e2a093ff AR	161	break;
	162	default:
	163	WARN_ON(1);
	164	goto err;
	165	}
	166	break;
afc5be30	167	case NFT_META_CPU:
fad136ea	168	*dest = raw_smp_processor_id();
afc5be30	169	break;
3045d760 AR	170	case NFT_META_IIFGROUP:
	171	if (in == NULL)
	172	goto err;
fad136ea	173	*dest = in->group;
3045d760 AR	174	break;
	175	case NFT_META_OIFGROUP:
	176	if (out == NULL)
	177	goto err;
fad136ea	178	*dest = out->group;
3045d760	179	break;
e181a543	180	#ifdef CONFIG_CGROUP_NET_CLASSID
ce674173	181	case NFT_META_CGROUP:
3aed8225 ED	182	sk = skb_to_full_sk(skb);
3aed8225 ED	183	if (!sk \|\| !sk_fullsock(sk))
c5035c77	184	goto err;
2a56a1fe	185	*dest = sock_cgroup_classid(&sk->sk_cgrp_data);
ce674173	186	break;
e181a543	187	#endif
b07edbe1 FW	188	case NFT_META_PRANDOM: {
	189	struct rnd_state *state = this_cpu_ptr(&nft_prandom_state);
	190	*dest = prandom_u32_state(state);
	191	break;
	192	}
96518518 PM	193	default:
	194	WARN_ON(1);
	195	goto err;
	196	}
	197	return;
	198
	199	err:
a55e22e9	200	regs->verdict.code = NFT_BREAK;
96518518	201	}
aa45660c	202	EXPORT_SYMBOL_GPL(nft_meta_get_eval);
96518518	203
aa45660c	204	void nft_meta_set_eval(const struct nft_expr *expr,
a55e22e9	205	struct nft_regs *regs,
aa45660c	206	const struct nft_pktinfo *pkt)
e035b77a ABG	207	{
	208	const struct nft_meta *meta = nft_expr_priv(expr);
	209	struct sk_buff *skb = pkt->skb;
49499c3e	210	u32 value = regs->data[meta->sreg];
e035b77a ABG	211
	212	switch (meta->key) {
	213	case NFT_META_MARK:
	214	skb->mark = value;
	215	break;
	216	case NFT_META_PRIORITY:
	217	skb->priority = value;
	218	break;
b4aae759 FW	219	case NFT_META_PKTTYPE:
b4aae759 FW	220	if (skb->pkt_type != value &&
8b10cab6	221	skb_pkt_type_ok(value) && skb_pkt_type_ok(skb->pkt_type))
b4aae759 FW	222	skb->pkt_type = value;
b4aae759 FW	223	break;
e035b77a	224	case NFT_META_NFTRACE:
62131e5d	225	skb->nf_trace = !!value;
e035b77a ABG	226	break;
	227	default:
	228	WARN_ON(1);
	229	}
	230	}
aa45660c	231	EXPORT_SYMBOL_GPL(nft_meta_set_eval);
e035b77a	232
aa45660c	233	const struct nla_policy nft_meta_policy[NFTA_META_MAX + 1] = {
96518518 PM	234	[NFTA_META_DREG] = { .type = NLA_U32 },
96518518 PM	235	[NFTA_META_KEY] = { .type = NLA_U32 },
e035b77a	236	[NFTA_META_SREG] = { .type = NLA_U32 },
96518518	237	};
aa45660c	238	EXPORT_SYMBOL_GPL(nft_meta_policy);
96518518	239
aa45660c TB	240	int nft_meta_get_init(const struct nft_ctx *ctx,
	241	const struct nft_expr *expr,
	242	const struct nlattr * const tb[])
96518518	243	{
d2caa696	244	struct nft_meta *priv = nft_expr_priv(expr);
45d9bcda	245	unsigned int len;
96518518	246
d2caa696 PM	247	priv->key = ntohl(nla_get_be32(tb[NFTA_META_KEY]));
d2caa696 PM	248	switch (priv->key) {
96518518	249	case NFT_META_PROTOCOL:
45d9bcda PM	250	case NFT_META_IIFTYPE:
	251	case NFT_META_OIFTYPE:
	252	len = sizeof(u16);
	253	break;
124edfa9	254	case NFT_META_NFPROTO:
4566bf27	255	case NFT_META_L4PROTO:
45d9bcda	256	case NFT_META_LEN:
96518518 PM	257	case NFT_META_PRIORITY:
	258	case NFT_META_MARK:
	259	case NFT_META_IIF:
	260	case NFT_META_OIF:
96518518 PM	261	case NFT_META_SKUID:
96518518 PM	262	case NFT_META_SKGID:
06efbd6d	263	#ifdef CONFIG_IP_ROUTE_CLASSID
96518518 PM	264	case NFT_META_RTCLASSID:
	265	#endif
	266	#ifdef CONFIG_NETWORK_SECMARK
	267	case NFT_META_SECMARK:
	268	#endif
e2a093ff	269	case NFT_META_PKTTYPE:
afc5be30	270	case NFT_META_CPU:
3045d760 AR	271	case NFT_META_IIFGROUP:
3045d760 AR	272	case NFT_META_OIFGROUP:
e181a543	273	#ifdef CONFIG_CGROUP_NET_CLASSID
ce674173	274	case NFT_META_CGROUP:
e181a543	275	#endif
45d9bcda PM	276	len = sizeof(u32);
	277	break;
	278	case NFT_META_IIFNAME:
	279	case NFT_META_OIFNAME:
	280	len = IFNAMSIZ;
d2caa696	281	break;
b07edbe1 FW	282	case NFT_META_PRANDOM:
	283	prandom_init_once(&nft_prandom_state);
	284	len = sizeof(u32);
	285	break;
96518518 PM	286	default:
	287	return -EOPNOTSUPP;
	288	}
	289
b1c96ed3	290	priv->dreg = nft_parse_register(tb[NFTA_META_DREG]);
27e6d201 PM	291	return nft_validate_register_store(ctx, priv->dreg, NULL,
27e6d201 PM	292	NFT_DATA_VALUE, len);
e035b77a	293	}
aa45660c	294	EXPORT_SYMBOL_GPL(nft_meta_get_init);
e035b77a	295
960fa72f LZ	296	int nft_meta_set_validate(const struct nft_ctx *ctx,
	297	const struct nft_expr *expr,
	298	const struct nft_data **data)
b4aae759	299	{
960fa72f	300	struct nft_meta *priv = nft_expr_priv(expr);
b4aae759 FW	301	unsigned int hooks;
b4aae759 FW	302
960fa72f LZ	303	if (priv->key != NFT_META_PKTTYPE)
	304	return 0;
	305
b4aae759 FW	306	switch (ctx->afi->family) {
	307	case NFPROTO_BRIDGE:
	308	hooks = 1 << NF_BR_PRE_ROUTING;
	309	break;
	310	case NFPROTO_NETDEV:
	311	hooks = 1 << NF_NETDEV_INGRESS;
	312	break;
96d9f2a7 LZ	313	case NFPROTO_IPV4:
	314	case NFPROTO_IPV6:
	315	case NFPROTO_INET:
	316	hooks = 1 << NF_INET_PRE_ROUTING;
	317	break;
b4aae759 FW	318	default:
	319	return -EOPNOTSUPP;
	320	}
	321
	322	return nft_chain_validate_hooks(ctx->chain, hooks);
	323	}
960fa72f	324	EXPORT_SYMBOL_GPL(nft_meta_set_validate);
b4aae759	325
aa45660c TB	326	int nft_meta_set_init(const struct nft_ctx *ctx,
	327	const struct nft_expr *expr,
	328	const struct nlattr * const tb[])
e035b77a ABG	329	{
e035b77a ABG	330	struct nft_meta *priv = nft_expr_priv(expr);
d07db988	331	unsigned int len;
e035b77a ABG	332	int err;
	333
	334	priv->key = ntohl(nla_get_be32(tb[NFTA_META_KEY]));
d2caa696 PM	335	switch (priv->key) {
	336	case NFT_META_MARK:
	337	case NFT_META_PRIORITY:
d07db988 PM	338	len = sizeof(u32);
d07db988 PM	339	break;
d2caa696	340	case NFT_META_NFTRACE:
d07db988	341	len = sizeof(u8);
d2caa696	342	break;
b4aae759	343	case NFT_META_PKTTYPE:
b4aae759 FW	344	len = sizeof(u8);
b4aae759 FW	345	break;
d2caa696 PM	346	default:
d2caa696 PM	347	return -EOPNOTSUPP;
e035b77a ABG	348	}
e035b77a ABG	349
960fa72f LZ	350	err = nft_meta_set_validate(ctx, expr, NULL);
	351	if (err < 0)
	352	return err;
	353
b1c96ed3	354	priv->sreg = nft_parse_register(tb[NFTA_META_SREG]);
d07db988	355	err = nft_validate_register_load(priv->sreg, len);
b38895c5 PNA	356	if (err < 0)
b38895c5 PNA	357	return err;
e035b77a	358
e639f7ab FW	359	if (priv->key == NFT_META_NFTRACE)
	360	static_branch_inc(&nft_trace_enabled);
	361
e035b77a	362	return 0;
96518518	363	}
aa45660c	364	EXPORT_SYMBOL_GPL(nft_meta_set_init);
96518518	365
aa45660c TB	366	int nft_meta_get_dump(struct sk_buff *skb,
aa45660c TB	367	const struct nft_expr *expr)
96518518 PM	368	{
	369	const struct nft_meta *priv = nft_expr_priv(expr);
	370
e035b77a ABG	371	if (nla_put_be32(skb, NFTA_META_KEY, htonl(priv->key)))
e035b77a ABG	372	goto nla_put_failure;
b1c96ed3	373	if (nft_dump_register(skb, NFTA_META_DREG, priv->dreg))
96518518	374	goto nla_put_failure;
e035b77a ABG	375	return 0;
	376
	377	nla_put_failure:
	378	return -1;
	379	}
aa45660c	380	EXPORT_SYMBOL_GPL(nft_meta_get_dump);
e035b77a	381
aa45660c TB	382	int nft_meta_set_dump(struct sk_buff *skb,
aa45660c TB	383	const struct nft_expr *expr)
e035b77a ABG	384	{
	385	const struct nft_meta *priv = nft_expr_priv(expr);
	386
96518518 PM	387	if (nla_put_be32(skb, NFTA_META_KEY, htonl(priv->key)))
96518518 PM	388	goto nla_put_failure;
b1c96ed3	389	if (nft_dump_register(skb, NFTA_META_SREG, priv->sreg))
e035b77a ABG	390	goto nla_put_failure;
e035b77a ABG	391
96518518 PM	392	return 0;
	393
	394	nla_put_failure:
	395	return -1;
	396	}
aa45660c	397	EXPORT_SYMBOL_GPL(nft_meta_set_dump);
96518518	398
e639f7ab FW	399	void nft_meta_set_destroy(const struct nft_ctx *ctx,
	400	const struct nft_expr *expr)
	401	{
	402	const struct nft_meta *priv = nft_expr_priv(expr);
	403
	404	if (priv->key == NFT_META_NFTRACE)
	405	static_branch_dec(&nft_trace_enabled);
	406	}
	407	EXPORT_SYMBOL_GPL(nft_meta_set_destroy);
	408
ef1f7df9	409	static struct nft_expr_type nft_meta_type;
e035b77a	410	static const struct nft_expr_ops nft_meta_get_ops = {
ef1f7df9	411	.type = &nft_meta_type,
96518518	412	.size = NFT_EXPR_SIZE(sizeof(struct nft_meta)),
e035b77a	413	.eval = nft_meta_get_eval,
d2caa696	414	.init = nft_meta_get_init,
e035b77a	415	.dump = nft_meta_get_dump,
ef1f7df9 PM	416	};
ef1f7df9 PM	417
e035b77a ABG	418	static const struct nft_expr_ops nft_meta_set_ops = {
	419	.type = &nft_meta_type,
	420	.size = NFT_EXPR_SIZE(sizeof(struct nft_meta)),
	421	.eval = nft_meta_set_eval,
d2caa696	422	.init = nft_meta_set_init,
e639f7ab	423	.destroy = nft_meta_set_destroy,
e035b77a	424	.dump = nft_meta_set_dump,
960fa72f	425	.validate = nft_meta_set_validate,
e035b77a ABG	426	};
	427
	428	static const struct nft_expr_ops *
	429	nft_meta_select_ops(const struct nft_ctx *ctx,
	430	const struct nlattr * const tb[])
	431	{
	432	if (tb[NFTA_META_KEY] == NULL)
	433	return ERR_PTR(-EINVAL);
	434
	435	if (tb[NFTA_META_DREG] && tb[NFTA_META_SREG])
	436	return ERR_PTR(-EINVAL);
	437
	438	if (tb[NFTA_META_DREG])
	439	return &nft_meta_get_ops;
	440
	441	if (tb[NFTA_META_SREG])
	442	return &nft_meta_set_ops;
	443
	444	return ERR_PTR(-EINVAL);
	445	}
	446
ef1f7df9 PM	447	static struct nft_expr_type nft_meta_type __read_mostly = {
ef1f7df9 PM	448	.name = "meta",
e035b77a	449	.select_ops = &nft_meta_select_ops,
96518518 PM	450	.policy = nft_meta_policy,
96518518 PM	451	.maxattr = NFTA_META_MAX,
ef1f7df9	452	.owner = THIS_MODULE,
96518518 PM	453	};
	454
	455	static int __init nft_meta_module_init(void)
	456	{
ef1f7df9	457	return nft_register_expr(&nft_meta_type);
96518518 PM	458	}
	459
	460	static void __exit nft_meta_module_exit(void)
	461	{
ef1f7df9	462	nft_unregister_expr(&nft_meta_type);
96518518 PM	463	}
	464
	465	module_init(nft_meta_module_init);
	466	module_exit(nft_meta_module_exit);
	467
	468	MODULE_LICENSE("GPL");
	469	MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
	470	MODULE_ALIAS_NFT_EXPR("meta");