[deliverable/linux.git] / net / netfilter / nft_lookup.c

/*
 * Copyright (c) 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/list.h>
#include <linux/rbtree.h>
#include <linux/netlink.h>
#include <linux/netfilter.h>
#include <linux/netfilter/nf_tables.h>
#include <net/netfilter/nf_tables.h>
#include <net/netfilter/nf_tables_core.h>

struct nft_lookup {
	struct nft_set			*set;
	enum nft_registers		sreg:8;
	enum nft_registers		dreg:8;
	struct nft_set_binding		binding;
};

static void nft_lookup_eval(const struct nft_expr *expr,
			    struct nft_data data[NFT_REG_MAX + 1],
			    const struct nft_pktinfo *pkt)
{
	const struct nft_lookup *priv = nft_expr_priv(expr);
	const struct nft_set *set = priv->set;
	const struct nft_set_ext *ext;

	if (set->ops->lookup(set, &data[priv->sreg], &ext)) {
		if (set->flags & NFT_SET_MAP)
			nft_data_copy(&data[priv->dreg], nft_set_ext_data(ext));
		return;
	}
	data[NFT_REG_VERDICT].verdict = NFT_BREAK;
}

static const struct nla_policy nft_lookup_policy[NFTA_LOOKUP_MAX + 1] = {
	[NFTA_LOOKUP_SET]	= { .type = NLA_STRING },
	[NFTA_LOOKUP_SET_ID]	= { .type = NLA_U32 },
	[NFTA_LOOKUP_SREG]	= { .type = NLA_U32 },
	[NFTA_LOOKUP_DREG]	= { .type = NLA_U32 },
};

static int nft_lookup_init(const struct nft_ctx *ctx,
			   const struct nft_expr *expr,
			   const struct nlattr * const tb[])
{
	struct nft_lookup *priv = nft_expr_priv(expr);
	struct nft_set *set;
	int err;

	if (tb[NFTA_LOOKUP_SET] == NULL ||
	    tb[NFTA_LOOKUP_SREG] == NULL)
		return -EINVAL;

	set = nf_tables_set_lookup(ctx->table, tb[NFTA_LOOKUP_SET]);
	if (IS_ERR(set)) {
		if (tb[NFTA_LOOKUP_SET_ID]) {
			set = nf_tables_set_lookup_byid(ctx->net,
							tb[NFTA_LOOKUP_SET_ID]);
		}
		if (IS_ERR(set))
			return PTR_ERR(set);
	}

	priv->sreg = ntohl(nla_get_be32(tb[NFTA_LOOKUP_SREG]));
	err = nft_validate_input_register(priv->sreg);
	if (err < 0)
		return err;

	if (tb[NFTA_LOOKUP_DREG] != NULL) {
		if (!(set->flags & NFT_SET_MAP))
			return -EINVAL;

		priv->dreg = ntohl(nla_get_be32(tb[NFTA_LOOKUP_DREG]));
		err = nft_validate_output_register(priv->dreg);
		if (err < 0)
			return err;

		if (priv->dreg == NFT_REG_VERDICT) {
			if (set->dtype != NFT_DATA_VERDICT)
				return -EINVAL;
		} else if (set->dtype == NFT_DATA_VERDICT)
			return -EINVAL;
	} else if (set->flags & NFT_SET_MAP)
		return -EINVAL;

	err = nf_tables_bind_set(ctx, set, &priv->binding);
	if (err < 0)
		return err;

	priv->set = set;
	return 0;
}

static void nft_lookup_destroy(const struct nft_ctx *ctx,
			       const struct nft_expr *expr)
{
	struct nft_lookup *priv = nft_expr_priv(expr);

	nf_tables_unbind_set(ctx, priv->set, &priv->binding);
}

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

	if (nla_put_string(skb, NFTA_LOOKUP_SET, priv->set->name))
		goto nla_put_failure;
	if (nla_put_be32(skb, NFTA_LOOKUP_SREG, htonl(priv->sreg)))
		goto nla_put_failure;
	if (priv->set->flags & NFT_SET_MAP)
		if (nla_put_be32(skb, NFTA_LOOKUP_DREG, htonl(priv->dreg)))
			goto nla_put_failure;
	return 0;

nla_put_failure:
	return -1;
}

static struct nft_expr_type nft_lookup_type;
static const struct nft_expr_ops nft_lookup_ops = {
	.type		= &nft_lookup_type,
	.size		= NFT_EXPR_SIZE(sizeof(struct nft_lookup)),
	.eval		= nft_lookup_eval,
	.init		= nft_lookup_init,
	.destroy	= nft_lookup_destroy,
	.dump		= nft_lookup_dump,
};

static struct nft_expr_type nft_lookup_type __read_mostly = {
	.name		= "lookup",
	.ops		= &nft_lookup_ops,
	.policy		= nft_lookup_policy,
	.maxattr	= NFTA_LOOKUP_MAX,
	.owner		= THIS_MODULE,
};

int __init nft_lookup_module_init(void)
{
	return nft_register_expr(&nft_lookup_type);
}

void nft_lookup_module_exit(void)
{
	nft_unregister_expr(&nft_lookup_type);
}
Commit	Line	Data
20a69341 PM	1	/*
	2	* Copyright (c) 2009 Patrick McHardy <kaber@trash.net>
	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/list.h>
	14	#include <linux/rbtree.h>
	15	#include <linux/netlink.h>
	16	#include <linux/netfilter.h>
	17	#include <linux/netfilter/nf_tables.h>
	18	#include <net/netfilter/nf_tables.h>
bd76ed36	19	#include <net/netfilter/nf_tables_core.h>
20a69341 PM	20
	21	struct nft_lookup {
	22	struct nft_set *set;
	23	enum nft_registers sreg:8;
	24	enum nft_registers dreg:8;
	25	struct nft_set_binding binding;
	26	};
	27
	28	static void nft_lookup_eval(const struct nft_expr *expr,
	29	struct nft_data data[NFT_REG_MAX + 1],
	30	const struct nft_pktinfo *pkt)
	31	{
	32	const struct nft_lookup *priv = nft_expr_priv(expr);
	33	const struct nft_set *set = priv->set;
b2832dd6	34	const struct nft_set_ext *ext;
20a69341	35
b2832dd6 PM	36	if (set->ops->lookup(set, &data[priv->sreg], &ext)) {
	37	if (set->flags & NFT_SET_MAP)
	38	nft_data_copy(&data[priv->dreg], nft_set_ext_data(ext));
20a69341	39	return;
b2832dd6	40	}
20a69341 PM	41	data[NFT_REG_VERDICT].verdict = NFT_BREAK;
	42	}
	43
	44	static const struct nla_policy nft_lookup_policy[NFTA_LOOKUP_MAX + 1] = {
	45	[NFTA_LOOKUP_SET] = { .type = NLA_STRING },
4c1017aa	46	[NFTA_LOOKUP_SET_ID] = { .type = NLA_U32 },
20a69341 PM	47	[NFTA_LOOKUP_SREG] = { .type = NLA_U32 },
	48	[NFTA_LOOKUP_DREG] = { .type = NLA_U32 },
	49	};
	50
	51	static int nft_lookup_init(const struct nft_ctx *ctx,
	52	const struct nft_expr *expr,
	53	const struct nlattr * const tb[])
	54	{
	55	struct nft_lookup *priv = nft_expr_priv(expr);
	56	struct nft_set *set;
	57	int err;
	58
	59	if (tb[NFTA_LOOKUP_SET] == NULL \|\|
	60	tb[NFTA_LOOKUP_SREG] == NULL)
	61	return -EINVAL;
	62
	63	set = nf_tables_set_lookup(ctx->table, tb[NFTA_LOOKUP_SET]);
958bee14 PNA	64	if (IS_ERR(set)) {
	65	if (tb[NFTA_LOOKUP_SET_ID]) {
	66	set = nf_tables_set_lookup_byid(ctx->net,
	67	tb[NFTA_LOOKUP_SET_ID]);
	68	}
	69	if (IS_ERR(set))
	70	return PTR_ERR(set);
	71	}
20a69341 PM	72
	73	priv->sreg = ntohl(nla_get_be32(tb[NFTA_LOOKUP_SREG]));
	74	err = nft_validate_input_register(priv->sreg);
	75	if (err < 0)
	76	return err;
	77
	78	if (tb[NFTA_LOOKUP_DREG] != NULL) {
	79	if (!(set->flags & NFT_SET_MAP))
	80	return -EINVAL;
	81
	82	priv->dreg = ntohl(nla_get_be32(tb[NFTA_LOOKUP_DREG]));
	83	err = nft_validate_output_register(priv->dreg);
	84	if (err < 0)
	85	return err;
	86
	87	if (priv->dreg == NFT_REG_VERDICT) {
	88	if (set->dtype != NFT_DATA_VERDICT)
	89	return -EINVAL;
	90	} else if (set->dtype == NFT_DATA_VERDICT)
	91	return -EINVAL;
	92	} else if (set->flags & NFT_SET_MAP)
	93	return -EINVAL;
	94
	95	err = nf_tables_bind_set(ctx, set, &priv->binding);
	96	if (err < 0)
	97	return err;
	98
	99	priv->set = set;
	100	return 0;
	101	}
	102
62472bce PM	103	static void nft_lookup_destroy(const struct nft_ctx *ctx,
62472bce PM	104	const struct nft_expr *expr)
20a69341 PM	105	{
	106	struct nft_lookup *priv = nft_expr_priv(expr);
	107
ab9da5c1	108	nf_tables_unbind_set(ctx, priv->set, &priv->binding);
20a69341 PM	109	}
	110
	111	static int nft_lookup_dump(struct sk_buff skb, const struct nft_expr expr)
	112	{
	113	const struct nft_lookup *priv = nft_expr_priv(expr);
	114
	115	if (nla_put_string(skb, NFTA_LOOKUP_SET, priv->set->name))
	116	goto nla_put_failure;
	117	if (nla_put_be32(skb, NFTA_LOOKUP_SREG, htonl(priv->sreg)))
	118	goto nla_put_failure;
	119	if (priv->set->flags & NFT_SET_MAP)
	120	if (nla_put_be32(skb, NFTA_LOOKUP_DREG, htonl(priv->dreg)))
	121	goto nla_put_failure;
	122	return 0;
	123
	124	nla_put_failure:
	125	return -1;
	126	}
	127
ef1f7df9 PM	128	static struct nft_expr_type nft_lookup_type;
	129	static const struct nft_expr_ops nft_lookup_ops = {
	130	.type = &nft_lookup_type,
20a69341	131	.size = NFT_EXPR_SIZE(sizeof(struct nft_lookup)),
20a69341 PM	132	.eval = nft_lookup_eval,
	133	.init = nft_lookup_init,
	134	.destroy = nft_lookup_destroy,
	135	.dump = nft_lookup_dump,
ef1f7df9 PM	136	};
	137
	138	static struct nft_expr_type nft_lookup_type __read_mostly = {
	139	.name = "lookup",
	140	.ops = &nft_lookup_ops,
20a69341 PM	141	.policy = nft_lookup_policy,
20a69341 PM	142	.maxattr = NFTA_LOOKUP_MAX,
ef1f7df9	143	.owner = THIS_MODULE,
20a69341 PM	144	};
	145
	146	int __init nft_lookup_module_init(void)
	147	{
ef1f7df9	148	return nft_register_expr(&nft_lookup_type);
20a69341 PM	149	}
	150
	151	void nft_lookup_module_exit(void)
	152	{
ef1f7df9	153	nft_unregister_expr(&nft_lookup_type);
20a69341	154	}