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

/* Copyright (C) 2000-2002 Joakim Axelsson <gozem@linux.nu>
 *                         Patrick Schaaf <bof@bof.de>
 *                         Martin Josefsson <gandalf@wlug.westbo.se>
 * Copyright (C) 2003-2013 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
 *
 * 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.
 */

/* Kernel module which implements the set match and SET target
 * for netfilter/iptables. */

#include <linux/module.h>
#include <linux/skbuff.h>

#include <linux/netfilter/x_tables.h>
#include <linux/netfilter/xt_set.h>
#include <linux/netfilter/ipset/ip_set_timeout.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
MODULE_DESCRIPTION("Xtables: IP set match and target module");
MODULE_ALIAS("xt_SET");
MODULE_ALIAS("ipt_set");
MODULE_ALIAS("ip6t_set");
MODULE_ALIAS("ipt_SET");
MODULE_ALIAS("ip6t_SET");

static inline int
match_set(ip_set_id_t index, const struct sk_buff *skb,
	  const struct xt_action_param *par,
	  struct ip_set_adt_opt *opt, int inv)
{
	if (ip_set_test(index, skb, par, opt))
		inv = !inv;
	return inv;
}

#define ADT_OPT(n, f, d, fs, cfs, t)	\
struct ip_set_adt_opt n = {		\
	.family	= f,			\
	.dim = d,			\
	.flags = fs,			\
	.cmdflags = cfs,		\
	.ext.timeout = t,		\
}

/* Revision 0 interface: backward compatible with netfilter/iptables */

static bool
set_match_v0(const struct sk_buff *skb, struct xt_action_param *par)
{
	const struct xt_set_info_match_v0 *info = par->matchinfo;
	ADT_OPT(opt, par->family, info->match_set.u.compat.dim,
		info->match_set.u.compat.flags, 0, UINT_MAX);

	return match_set(info->match_set.index, skb, par, &opt,
			 info->match_set.u.compat.flags & IPSET_INV_MATCH);
}

static void
compat_flags(struct xt_set_info_v0 *info)
{
	u_int8_t i;

	/* Fill out compatibility data according to enum ip_set_kopt */
	info->u.compat.dim = IPSET_DIM_ZERO;
	if (info->u.flags[0] & IPSET_MATCH_INV)
		info->u.compat.flags |= IPSET_INV_MATCH;
	for (i = 0; i < IPSET_DIM_MAX-1 && info->u.flags[i]; i++) {
		info->u.compat.dim++;
		if (info->u.flags[i] & IPSET_SRC)
			info->u.compat.flags |= (1<<info->u.compat.dim);
	}
}

static int
set_match_v0_checkentry(const struct xt_mtchk_param *par)
{
	struct xt_set_info_match_v0 *info = par->matchinfo;
	ip_set_id_t index;

	index = ip_set_nfnl_get_byindex(par->net, info->match_set.index);

	if (index == IPSET_INVALID_ID) {
		pr_warn("Cannot find set identified by id %u to match\n",
			info->match_set.index);
		return -ENOENT;
	}
	if (info->match_set.u.flags[IPSET_DIM_MAX-1] != 0) {
		pr_warn("Protocol error: set match dimension is over the limit!\n");
		ip_set_nfnl_put(par->net, info->match_set.index);
		return -ERANGE;
	}

	/* Fill out compatibility data */
	compat_flags(&info->match_set);

	return 0;
}

static void
set_match_v0_destroy(const struct xt_mtdtor_param *par)
{
	struct xt_set_info_match_v0 *info = par->matchinfo;

	ip_set_nfnl_put(par->net, info->match_set.index);
}

/* Revision 1 match */

static bool
set_match_v1(const struct sk_buff *skb, struct xt_action_param *par)
{
	const struct xt_set_info_match_v1 *info = par->matchinfo;
	ADT_OPT(opt, par->family, info->match_set.dim,
		info->match_set.flags, 0, UINT_MAX);

	if (opt.flags & IPSET_RETURN_NOMATCH)
		opt.cmdflags |= IPSET_FLAG_RETURN_NOMATCH;

	return match_set(info->match_set.index, skb, par, &opt,
			 info->match_set.flags & IPSET_INV_MATCH);
}

static int
set_match_v1_checkentry(const struct xt_mtchk_param *par)
{
	struct xt_set_info_match_v1 *info = par->matchinfo;
	ip_set_id_t index;

	index = ip_set_nfnl_get_byindex(par->net, info->match_set.index);

	if (index == IPSET_INVALID_ID) {
		pr_warn("Cannot find set identified by id %u to match\n",
			info->match_set.index);
		return -ENOENT;
	}
	if (info->match_set.dim > IPSET_DIM_MAX) {
		pr_warn("Protocol error: set match dimension is over the limit!\n");
		ip_set_nfnl_put(par->net, info->match_set.index);
		return -ERANGE;
	}

	return 0;
}

static void
set_match_v1_destroy(const struct xt_mtdtor_param *par)
{
	struct xt_set_info_match_v1 *info = par->matchinfo;

	ip_set_nfnl_put(par->net, info->match_set.index);
}

/* Revision 3 match */

static bool
match_counter(u64 counter, const struct ip_set_counter_match *info)
{
	switch (info->op) {
	case IPSET_COUNTER_NONE:
		return true;
	case IPSET_COUNTER_EQ:
		return counter == info->value;
	case IPSET_COUNTER_NE:
		return counter != info->value;
	case IPSET_COUNTER_LT:
		return counter < info->value;
	case IPSET_COUNTER_GT:
		return counter > info->value;
	}
	return false;
}

static bool
set_match_v3(const struct sk_buff *skb, struct xt_action_param *par)
{
	const struct xt_set_info_match_v3 *info = par->matchinfo;
	ADT_OPT(opt, par->family, info->match_set.dim,
		info->match_set.flags, info->flags, UINT_MAX);
	int ret;

	if (info->packets.op != IPSET_COUNTER_NONE ||
	    info->bytes.op != IPSET_COUNTER_NONE)
		opt.cmdflags |= IPSET_FLAG_MATCH_COUNTERS;

	ret = match_set(info->match_set.index, skb, par, &opt,
			info->match_set.flags & IPSET_INV_MATCH);

	if (!(ret && opt.cmdflags & IPSET_FLAG_MATCH_COUNTERS))
		return ret;

	if (!match_counter(opt.ext.packets, &info->packets))
		return 0;
	return match_counter(opt.ext.bytes, &info->bytes);
}

#define set_match_v3_checkentry	set_match_v1_checkentry
#define set_match_v3_destroy	set_match_v1_destroy

/* Revision 0 interface: backward compatible with netfilter/iptables */

static unsigned int
set_target_v0(struct sk_buff *skb, const struct xt_action_param *par)
{
	const struct xt_set_info_target_v0 *info = par->targinfo;
	ADT_OPT(add_opt, par->family, info->add_set.u.compat.dim,
		info->add_set.u.compat.flags, 0, UINT_MAX);
	ADT_OPT(del_opt, par->family, info->del_set.u.compat.dim,
		info->del_set.u.compat.flags, 0, UINT_MAX);

	if (info->add_set.index != IPSET_INVALID_ID)
		ip_set_add(info->add_set.index, skb, par, &add_opt);
	if (info->del_set.index != IPSET_INVALID_ID)
		ip_set_del(info->del_set.index, skb, par, &del_opt);

	return XT_CONTINUE;
}

static int
set_target_v0_checkentry(const struct xt_tgchk_param *par)
{
	struct xt_set_info_target_v0 *info = par->targinfo;
	ip_set_id_t index;

	if (info->add_set.index != IPSET_INVALID_ID) {
		index = ip_set_nfnl_get_byindex(par->net, info->add_set.index);
		if (index == IPSET_INVALID_ID) {
			pr_warn("Cannot find add_set index %u as target\n",
				info->add_set.index);
			return -ENOENT;
		}
	}

	if (info->del_set.index != IPSET_INVALID_ID) {
		index = ip_set_nfnl_get_byindex(par->net, info->del_set.index);
		if (index == IPSET_INVALID_ID) {
			pr_warn("Cannot find del_set index %u as target\n",
				info->del_set.index);
			if (info->add_set.index != IPSET_INVALID_ID)
				ip_set_nfnl_put(par->net, info->add_set.index);
			return -ENOENT;
		}
	}
	if (info->add_set.u.flags[IPSET_DIM_MAX-1] != 0 ||
	    info->del_set.u.flags[IPSET_DIM_MAX-1] != 0) {
		pr_warn("Protocol error: SET target dimension is over the limit!\n");
		if (info->add_set.index != IPSET_INVALID_ID)
			ip_set_nfnl_put(par->net, info->add_set.index);
		if (info->del_set.index != IPSET_INVALID_ID)
			ip_set_nfnl_put(par->net, info->del_set.index);
		return -ERANGE;
	}

	/* Fill out compatibility data */
	compat_flags(&info->add_set);
	compat_flags(&info->del_set);

	return 0;
}

static void
set_target_v0_destroy(const struct xt_tgdtor_param *par)
{
	const struct xt_set_info_target_v0 *info = par->targinfo;

	if (info->add_set.index != IPSET_INVALID_ID)
		ip_set_nfnl_put(par->net, info->add_set.index);
	if (info->del_set.index != IPSET_INVALID_ID)
		ip_set_nfnl_put(par->net, info->del_set.index);
}

/* Revision 1 target */

static unsigned int
set_target_v1(struct sk_buff *skb, const struct xt_action_param *par)
{
	const struct xt_set_info_target_v1 *info = par->targinfo;
	ADT_OPT(add_opt, par->family, info->add_set.dim,
		info->add_set.flags, 0, UINT_MAX);
	ADT_OPT(del_opt, par->family, info->del_set.dim,
		info->del_set.flags, 0, UINT_MAX);

	if (info->add_set.index != IPSET_INVALID_ID)
		ip_set_add(info->add_set.index, skb, par, &add_opt);
	if (info->del_set.index != IPSET_INVALID_ID)
		ip_set_del(info->del_set.index, skb, par, &del_opt);

	return XT_CONTINUE;
}

static int
set_target_v1_checkentry(const struct xt_tgchk_param *par)
{
	const struct xt_set_info_target_v1 *info = par->targinfo;
	ip_set_id_t index;

	if (info->add_set.index != IPSET_INVALID_ID) {
		index = ip_set_nfnl_get_byindex(par->net, info->add_set.index);
		if (index == IPSET_INVALID_ID) {
			pr_warn("Cannot find add_set index %u as target\n",
				info->add_set.index);
			return -ENOENT;
		}
	}

	if (info->del_set.index != IPSET_INVALID_ID) {
		index = ip_set_nfnl_get_byindex(par->net, info->del_set.index);
		if (index == IPSET_INVALID_ID) {
			pr_warn("Cannot find del_set index %u as target\n",
				info->del_set.index);
			if (info->add_set.index != IPSET_INVALID_ID)
				ip_set_nfnl_put(par->net, info->add_set.index);
			return -ENOENT;
		}
	}
	if (info->add_set.dim > IPSET_DIM_MAX ||
	    info->del_set.dim > IPSET_DIM_MAX) {
		pr_warn("Protocol error: SET target dimension is over the limit!\n");
		if (info->add_set.index != IPSET_INVALID_ID)
			ip_set_nfnl_put(par->net, info->add_set.index);
		if (info->del_set.index != IPSET_INVALID_ID)
			ip_set_nfnl_put(par->net, info->del_set.index);
		return -ERANGE;
	}

	return 0;
}

static void
set_target_v1_destroy(const struct xt_tgdtor_param *par)
{
	const struct xt_set_info_target_v1 *info = par->targinfo;

	if (info->add_set.index != IPSET_INVALID_ID)
		ip_set_nfnl_put(par->net, info->add_set.index);
	if (info->del_set.index != IPSET_INVALID_ID)
		ip_set_nfnl_put(par->net, info->del_set.index);
}

/* Revision 2 target */

static unsigned int
set_target_v2(struct sk_buff *skb, const struct xt_action_param *par)
{
	const struct xt_set_info_target_v2 *info = par->targinfo;
	ADT_OPT(add_opt, par->family, info->add_set.dim,
		info->add_set.flags, info->flags, info->timeout);
	ADT_OPT(del_opt, par->family, info->del_set.dim,
		info->del_set.flags, 0, UINT_MAX);

	/* Normalize to fit into jiffies */
	if (add_opt.ext.timeout != IPSET_NO_TIMEOUT &&
	    add_opt.ext.timeout > UINT_MAX/MSEC_PER_SEC)
		add_opt.ext.timeout = UINT_MAX/MSEC_PER_SEC;
	if (info->add_set.index != IPSET_INVALID_ID)
		ip_set_add(info->add_set.index, skb, par, &add_opt);
	if (info->del_set.index != IPSET_INVALID_ID)
		ip_set_del(info->del_set.index, skb, par, &del_opt);

	return XT_CONTINUE;
}

#define set_target_v2_checkentry	set_target_v1_checkentry
#define set_target_v2_destroy		set_target_v1_destroy

static struct xt_match set_matches[] __read_mostly = {
	{
		.name		= "set",
		.family		= NFPROTO_IPV4,
		.revision	= 0,
		.match		= set_match_v0,
		.matchsize	= sizeof(struct xt_set_info_match_v0),
		.checkentry	= set_match_v0_checkentry,
		.destroy	= set_match_v0_destroy,
		.me		= THIS_MODULE
	},
	{
		.name		= "set",
		.family		= NFPROTO_IPV4,
		.revision	= 1,
		.match		= set_match_v1,
		.matchsize	= sizeof(struct xt_set_info_match_v1),
		.checkentry	= set_match_v1_checkentry,
		.destroy	= set_match_v1_destroy,
		.me		= THIS_MODULE
	},
	{
		.name		= "set",
		.family		= NFPROTO_IPV6,
		.revision	= 1,
		.match		= set_match_v1,
		.matchsize	= sizeof(struct xt_set_info_match_v1),
		.checkentry	= set_match_v1_checkentry,
		.destroy	= set_match_v1_destroy,
		.me		= THIS_MODULE
	},
	/* --return-nomatch flag support */
	{
		.name		= "set",
		.family		= NFPROTO_IPV4,
		.revision	= 2,
		.match		= set_match_v1,
		.matchsize	= sizeof(struct xt_set_info_match_v1),
		.checkentry	= set_match_v1_checkentry,
		.destroy	= set_match_v1_destroy,
		.me		= THIS_MODULE
	},
	{
		.name		= "set",
		.family		= NFPROTO_IPV6,
		.revision	= 2,
		.match		= set_match_v1,
		.matchsize	= sizeof(struct xt_set_info_match_v1),
		.checkentry	= set_match_v1_checkentry,
		.destroy	= set_match_v1_destroy,
		.me		= THIS_MODULE
	},
	/* counters support: update, match */
	{
		.name		= "set",
		.family		= NFPROTO_IPV4,
		.revision	= 3,
		.match		= set_match_v3,
		.matchsize	= sizeof(struct xt_set_info_match_v3),
		.checkentry	= set_match_v3_checkentry,
		.destroy	= set_match_v3_destroy,
		.me		= THIS_MODULE
	},
	{
		.name		= "set",
		.family		= NFPROTO_IPV6,
		.revision	= 3,
		.match		= set_match_v3,
		.matchsize	= sizeof(struct xt_set_info_match_v3),
		.checkentry	= set_match_v3_checkentry,
		.destroy	= set_match_v3_destroy,
		.me		= THIS_MODULE
	},
};

static struct xt_target set_targets[] __read_mostly = {
	{
		.name		= "SET",
		.revision	= 0,
		.family		= NFPROTO_IPV4,
		.target		= set_target_v0,
		.targetsize	= sizeof(struct xt_set_info_target_v0),
		.checkentry	= set_target_v0_checkentry,
		.destroy	= set_target_v0_destroy,
		.me		= THIS_MODULE
	},
	{
		.name		= "SET",
		.revision	= 1,
		.family		= NFPROTO_IPV4,
		.target		= set_target_v1,
		.targetsize	= sizeof(struct xt_set_info_target_v1),
		.checkentry	= set_target_v1_checkentry,
		.destroy	= set_target_v1_destroy,
		.me		= THIS_MODULE
	},
	{
		.name		= "SET",
		.revision	= 1,
		.family		= NFPROTO_IPV6,
		.target		= set_target_v1,
		.targetsize	= sizeof(struct xt_set_info_target_v1),
		.checkentry	= set_target_v1_checkentry,
		.destroy	= set_target_v1_destroy,
		.me		= THIS_MODULE
	},
	/* --timeout and --exist flags support */
	{
		.name		= "SET",
		.revision	= 2,
		.family		= NFPROTO_IPV4,
		.target		= set_target_v2,
		.targetsize	= sizeof(struct xt_set_info_target_v2),
		.checkentry	= set_target_v2_checkentry,
		.destroy	= set_target_v2_destroy,
		.me		= THIS_MODULE
	},
	{
		.name		= "SET",
		.revision	= 2,
		.family		= NFPROTO_IPV6,
		.target		= set_target_v2,
		.targetsize	= sizeof(struct xt_set_info_target_v2),
		.checkentry	= set_target_v2_checkentry,
		.destroy	= set_target_v2_destroy,
		.me		= THIS_MODULE
	},
};

static int __init xt_set_init(void)
{
	int ret = xt_register_matches(set_matches, ARRAY_SIZE(set_matches));

	if (!ret) {
		ret = xt_register_targets(set_targets,
					  ARRAY_SIZE(set_targets));
		if (ret)
			xt_unregister_matches(set_matches,
					      ARRAY_SIZE(set_matches));
	}
	return ret;
}

static void __exit xt_set_fini(void)
{
	xt_unregister_matches(set_matches, ARRAY_SIZE(set_matches));
	xt_unregister_targets(set_targets, ARRAY_SIZE(set_targets));
}

module_init(xt_set_init);
module_exit(xt_set_fini);
Commit	Line	Data
d956798d JK	1	/* Copyright (C) 2000-2002 Joakim Axelsson <gozem@linux.nu>
	2	* Patrick Schaaf <bof@bof.de>
	3	* Martin Josefsson <gandalf@wlug.westbo.se>
075e64c0	4	* Copyright (C) 2003-2013 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
d956798d JK	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*/
	10
	11	/* Kernel module which implements the set match and SET target
	12	* for netfilter/iptables. */
	13
	14	#include <linux/module.h>
	15	#include <linux/skbuff.h>
d956798d JK	16
	17	#include <linux/netfilter/x_tables.h>
	18	#include <linux/netfilter/xt_set.h>
a73f89a6	19	#include <linux/netfilter/ipset/ip_set_timeout.h>
d956798d JK	20
	21	MODULE_LICENSE("GPL");
	22	MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
	23	MODULE_DESCRIPTION("Xtables: IP set match and target module");
	24	MODULE_ALIAS("xt_SET");
	25	MODULE_ALIAS("ipt_set");
	26	MODULE_ALIAS("ip6t_set");
	27	MODULE_ALIAS("ipt_SET");
	28	MODULE_ALIAS("ip6t_SET");
	29
	30	static inline int
	31	match_set(ip_set_id_t index, const struct sk_buff *skb,
b66554cf	32	const struct xt_action_param *par,
075e64c0	33	struct ip_set_adt_opt *opt, int inv)
d956798d	34	{
b66554cf	35	if (ip_set_test(index, skb, par, opt))
d956798d JK	36	inv = !inv;
	37	return inv;
	38	}
	39
15b4d93f	40	#define ADT_OPT(n, f, d, fs, cfs, t) \
127f5591 JK	41	struct ip_set_adt_opt n = { \
	42	.family = f, \
	43	.dim = d, \
	44	.flags = fs, \
	45	.cmdflags = cfs, \
075e64c0	46	.ext.timeout = t, \
127f5591	47	}
ac8cc925	48
d956798d JK	49	/* Revision 0 interface: backward compatible with netfilter/iptables */
	50
	51	static bool
	52	set_match_v0(const struct sk_buff skb, struct xt_action_param par)
	53	{
	54	const struct xt_set_info_match_v0 *info = par->matchinfo;
ac8cc925 JK	55	ADT_OPT(opt, par->family, info->match_set.u.compat.dim,
ac8cc925 JK	56	info->match_set.u.compat.flags, 0, UINT_MAX);
d956798d	57
b66554cf	58	return match_set(info->match_set.index, skb, par, &opt,
d956798d JK	59	info->match_set.u.compat.flags & IPSET_INV_MATCH);
	60	}
	61
	62	static void
	63	compat_flags(struct xt_set_info_v0 *info)
	64	{
	65	u_int8_t i;
	66
	67	/* Fill out compatibility data according to enum ip_set_kopt */
	68	info->u.compat.dim = IPSET_DIM_ZERO;
	69	if (info->u.flags[0] & IPSET_MATCH_INV)
	70	info->u.compat.flags \|= IPSET_INV_MATCH;
	71	for (i = 0; i < IPSET_DIM_MAX-1 && info->u.flags[i]; i++) {
	72	info->u.compat.dim++;
	73	if (info->u.flags[i] & IPSET_SRC)
	74	info->u.compat.flags \|= (1<<info->u.compat.dim);
	75	}
	76	}
	77
	78	static int
	79	set_match_v0_checkentry(const struct xt_mtchk_param *par)
	80	{
	81	struct xt_set_info_match_v0 *info = par->matchinfo;
	82	ip_set_id_t index;
	83
1785e8f4	84	index = ip_set_nfnl_get_byindex(par->net, info->match_set.index);
d956798d JK	85
d956798d JK	86	if (index == IPSET_INVALID_ID) {
b167a37c JP	87	pr_warn("Cannot find set identified by id %u to match\n",
b167a37c JP	88	info->match_set.index);
d956798d JK	89	return -ENOENT;
	90	}
	91	if (info->match_set.u.flags[IPSET_DIM_MAX-1] != 0) {
b167a37c	92	pr_warn("Protocol error: set match dimension is over the limit!\n");
1785e8f4	93	ip_set_nfnl_put(par->net, info->match_set.index);
d956798d JK	94	return -ERANGE;
	95	}
	96
	97	/* Fill out compatibility data */
	98	compat_flags(&info->match_set);
	99
	100	return 0;
	101	}
	102
	103	static void
	104	set_match_v0_destroy(const struct xt_mtdtor_param *par)
	105	{
	106	struct xt_set_info_match_v0 *info = par->matchinfo;
	107
1785e8f4	108	ip_set_nfnl_put(par->net, info->match_set.index);
d956798d JK	109	}
d956798d JK	110
bd3129fc JK	111	/* Revision 1 match */
	112
	113	static bool
	114	set_match_v1(const struct sk_buff skb, struct xt_action_param par)
	115	{
	116	const struct xt_set_info_match_v1 *info = par->matchinfo;
	117	ADT_OPT(opt, par->family, info->match_set.dim,
	118	info->match_set.flags, 0, UINT_MAX);
	119
	120	if (opt.flags & IPSET_RETURN_NOMATCH)
	121	opt.cmdflags \|= IPSET_FLAG_RETURN_NOMATCH;
	122
	123	return match_set(info->match_set.index, skb, par, &opt,
	124	info->match_set.flags & IPSET_INV_MATCH);
	125	}
	126
	127	static int
	128	set_match_v1_checkentry(const struct xt_mtchk_param *par)
	129	{
	130	struct xt_set_info_match_v1 *info = par->matchinfo;
	131	ip_set_id_t index;
	132
1785e8f4	133	index = ip_set_nfnl_get_byindex(par->net, info->match_set.index);
bd3129fc JK	134
bd3129fc JK	135	if (index == IPSET_INVALID_ID) {
b167a37c JP	136	pr_warn("Cannot find set identified by id %u to match\n",
b167a37c JP	137	info->match_set.index);
bd3129fc JK	138	return -ENOENT;
	139	}
	140	if (info->match_set.dim > IPSET_DIM_MAX) {
b167a37c	141	pr_warn("Protocol error: set match dimension is over the limit!\n");
1785e8f4	142	ip_set_nfnl_put(par->net, info->match_set.index);
bd3129fc JK	143	return -ERANGE;
	144	}
	145
	146	return 0;
	147	}
	148
	149	static void
	150	set_match_v1_destroy(const struct xt_mtdtor_param *par)
	151	{
	152	struct xt_set_info_match_v1 *info = par->matchinfo;
	153
1785e8f4	154	ip_set_nfnl_put(par->net, info->match_set.index);
bd3129fc JK	155	}
	156
	157	/* Revision 3 match */
	158
	159	static bool
	160	match_counter(u64 counter, const struct ip_set_counter_match *info)
	161	{
	162	switch (info->op) {
	163	case IPSET_COUNTER_NONE:
	164	return true;
	165	case IPSET_COUNTER_EQ:
	166	return counter == info->value;
	167	case IPSET_COUNTER_NE:
	168	return counter != info->value;
	169	case IPSET_COUNTER_LT:
	170	return counter < info->value;
	171	case IPSET_COUNTER_GT:
	172	return counter > info->value;
	173	}
	174	return false;
	175	}
	176
	177	static bool
	178	set_match_v3(const struct sk_buff skb, struct xt_action_param par)
	179	{
	180	const struct xt_set_info_match_v3 *info = par->matchinfo;
	181	ADT_OPT(opt, par->family, info->match_set.dim,
	182	info->match_set.flags, info->flags, UINT_MAX);
	183	int ret;
	184
	185	if (info->packets.op != IPSET_COUNTER_NONE \|\|
	186	info->bytes.op != IPSET_COUNTER_NONE)
	187	opt.cmdflags \|= IPSET_FLAG_MATCH_COUNTERS;
	188
	189	ret = match_set(info->match_set.index, skb, par, &opt,
	190	info->match_set.flags & IPSET_INV_MATCH);
	191
	192	if (!(ret && opt.cmdflags & IPSET_FLAG_MATCH_COUNTERS))
	193	return ret;
	194
	195	if (!match_counter(opt.ext.packets, &info->packets))
	196	return 0;
	197	return match_counter(opt.ext.bytes, &info->bytes);
	198	}
	199
	200	#define set_match_v3_checkentry set_match_v1_checkentry
	201	#define set_match_v3_destroy set_match_v1_destroy
	202
	203	/* Revision 0 interface: backward compatible with netfilter/iptables */
	204
d956798d JK	205	static unsigned int
	206	set_target_v0(struct sk_buff skb, const struct xt_action_param par)
	207	{
	208	const struct xt_set_info_target_v0 *info = par->targinfo;
ac8cc925 JK	209	ADT_OPT(add_opt, par->family, info->add_set.u.compat.dim,
	210	info->add_set.u.compat.flags, 0, UINT_MAX);
	211	ADT_OPT(del_opt, par->family, info->del_set.u.compat.dim,
	212	info->del_set.u.compat.flags, 0, UINT_MAX);
d956798d JK	213
d956798d JK	214	if (info->add_set.index != IPSET_INVALID_ID)
b66554cf	215	ip_set_add(info->add_set.index, skb, par, &add_opt);
d956798d	216	if (info->del_set.index != IPSET_INVALID_ID)
b66554cf	217	ip_set_del(info->del_set.index, skb, par, &del_opt);
d956798d JK	218
	219	return XT_CONTINUE;
	220	}
	221
	222	static int
	223	set_target_v0_checkentry(const struct xt_tgchk_param *par)
	224	{
	225	struct xt_set_info_target_v0 *info = par->targinfo;
	226	ip_set_id_t index;
	227
	228	if (info->add_set.index != IPSET_INVALID_ID) {
1785e8f4	229	index = ip_set_nfnl_get_byindex(par->net, info->add_set.index);
d956798d	230	if (index == IPSET_INVALID_ID) {
b167a37c JP	231	pr_warn("Cannot find add_set index %u as target\n",
b167a37c JP	232	info->add_set.index);
d956798d JK	233	return -ENOENT;
	234	}
	235	}
	236
	237	if (info->del_set.index != IPSET_INVALID_ID) {
1785e8f4	238	index = ip_set_nfnl_get_byindex(par->net, info->del_set.index);
d956798d	239	if (index == IPSET_INVALID_ID) {
b167a37c JP	240	pr_warn("Cannot find del_set index %u as target\n",
b167a37c JP	241	info->del_set.index);
eafbd3fd	242	if (info->add_set.index != IPSET_INVALID_ID)
1785e8f4	243	ip_set_nfnl_put(par->net, info->add_set.index);
d956798d JK	244	return -ENOENT;
	245	}
	246	}
	247	if (info->add_set.u.flags[IPSET_DIM_MAX-1] != 0 \|\|
	248	info->del_set.u.flags[IPSET_DIM_MAX-1] != 0) {
b167a37c	249	pr_warn("Protocol error: SET target dimension is over the limit!\n");
eafbd3fd	250	if (info->add_set.index != IPSET_INVALID_ID)
1785e8f4	251	ip_set_nfnl_put(par->net, info->add_set.index);
eafbd3fd	252	if (info->del_set.index != IPSET_INVALID_ID)
1785e8f4	253	ip_set_nfnl_put(par->net, info->del_set.index);
d956798d JK	254	return -ERANGE;
	255	}
	256
	257	/* Fill out compatibility data */
	258	compat_flags(&info->add_set);
	259	compat_flags(&info->del_set);
	260
	261	return 0;
	262	}
	263
	264	static void
	265	set_target_v0_destroy(const struct xt_tgdtor_param *par)
	266	{
	267	const struct xt_set_info_target_v0 *info = par->targinfo;
	268
	269	if (info->add_set.index != IPSET_INVALID_ID)
1785e8f4	270	ip_set_nfnl_put(par->net, info->add_set.index);
d956798d	271	if (info->del_set.index != IPSET_INVALID_ID)
1785e8f4	272	ip_set_nfnl_put(par->net, info->del_set.index);
d956798d JK	273	}
d956798d JK	274
bd3129fc	275	/* Revision 1 target */
d956798d JK	276
d956798d JK	277	static unsigned int
ac8cc925	278	set_target_v1(struct sk_buff skb, const struct xt_action_param par)
d956798d	279	{
ac8cc925 JK	280	const struct xt_set_info_target_v1 *info = par->targinfo;
	281	ADT_OPT(add_opt, par->family, info->add_set.dim,
	282	info->add_set.flags, 0, UINT_MAX);
	283	ADT_OPT(del_opt, par->family, info->del_set.dim,
	284	info->del_set.flags, 0, UINT_MAX);
d956798d JK	285
d956798d JK	286	if (info->add_set.index != IPSET_INVALID_ID)
b66554cf	287	ip_set_add(info->add_set.index, skb, par, &add_opt);
d956798d	288	if (info->del_set.index != IPSET_INVALID_ID)
b66554cf	289	ip_set_del(info->del_set.index, skb, par, &del_opt);
d956798d JK	290
	291	return XT_CONTINUE;
	292	}
	293
	294	static int
ac8cc925	295	set_target_v1_checkentry(const struct xt_tgchk_param *par)
d956798d	296	{
ac8cc925	297	const struct xt_set_info_target_v1 *info = par->targinfo;
d956798d JK	298	ip_set_id_t index;
	299
	300	if (info->add_set.index != IPSET_INVALID_ID) {
1785e8f4	301	index = ip_set_nfnl_get_byindex(par->net, info->add_set.index);
d956798d	302	if (index == IPSET_INVALID_ID) {
b167a37c JP	303	pr_warn("Cannot find add_set index %u as target\n",
b167a37c JP	304	info->add_set.index);
d956798d JK	305	return -ENOENT;
	306	}
	307	}
	308
	309	if (info->del_set.index != IPSET_INVALID_ID) {
1785e8f4	310	index = ip_set_nfnl_get_byindex(par->net, info->del_set.index);
d956798d	311	if (index == IPSET_INVALID_ID) {
b167a37c JP	312	pr_warn("Cannot find del_set index %u as target\n",
b167a37c JP	313	info->del_set.index);
eafbd3fd	314	if (info->add_set.index != IPSET_INVALID_ID)
1785e8f4	315	ip_set_nfnl_put(par->net, info->add_set.index);
d956798d JK	316	return -ENOENT;
	317	}
	318	}
	319	if (info->add_set.dim > IPSET_DIM_MAX \|\|
eafbd3fd	320	info->del_set.dim > IPSET_DIM_MAX) {
b167a37c	321	pr_warn("Protocol error: SET target dimension is over the limit!\n");
eafbd3fd	322	if (info->add_set.index != IPSET_INVALID_ID)
1785e8f4	323	ip_set_nfnl_put(par->net, info->add_set.index);
eafbd3fd	324	if (info->del_set.index != IPSET_INVALID_ID)
1785e8f4	325	ip_set_nfnl_put(par->net, info->del_set.index);
d956798d JK	326	return -ERANGE;
	327	}
	328
	329	return 0;
	330	}
	331
	332	static void
ac8cc925	333	set_target_v1_destroy(const struct xt_tgdtor_param *par)
d956798d	334	{
ac8cc925	335	const struct xt_set_info_target_v1 *info = par->targinfo;
d956798d JK	336
d956798d JK	337	if (info->add_set.index != IPSET_INVALID_ID)
1785e8f4	338	ip_set_nfnl_put(par->net, info->add_set.index);
d956798d	339	if (info->del_set.index != IPSET_INVALID_ID)
1785e8f4	340	ip_set_nfnl_put(par->net, info->del_set.index);
d956798d JK	341	}
d956798d JK	342
ac8cc925 JK	343	/* Revision 2 target */
	344
	345	static unsigned int
	346	set_target_v2(struct sk_buff skb, const struct xt_action_param par)
	347	{
	348	const struct xt_set_info_target_v2 *info = par->targinfo;
075e64c0 JK	349	ADT_OPT(add_opt, par->family, info->add_set.dim,
075e64c0 JK	350	info->add_set.flags, info->flags, info->timeout);
ac8cc925 JK	351	ADT_OPT(del_opt, par->family, info->del_set.dim,
	352	info->del_set.flags, 0, UINT_MAX);
	353
127f5591	354	/* Normalize to fit into jiffies */
075e64c0 JK	355	if (add_opt.ext.timeout != IPSET_NO_TIMEOUT &&
	356	add_opt.ext.timeout > UINT_MAX/MSEC_PER_SEC)
	357	add_opt.ext.timeout = UINT_MAX/MSEC_PER_SEC;
ac8cc925	358	if (info->add_set.index != IPSET_INVALID_ID)
b66554cf	359	ip_set_add(info->add_set.index, skb, par, &add_opt);
ac8cc925	360	if (info->del_set.index != IPSET_INVALID_ID)
b66554cf	361	ip_set_del(info->del_set.index, skb, par, &del_opt);
ac8cc925 JK	362
	363	return XT_CONTINUE;
	364	}
	365
	366	#define set_target_v2_checkentry set_target_v1_checkentry
	367	#define set_target_v2_destroy set_target_v1_destroy
	368
d956798d JK	369	static struct xt_match set_matches[] __read_mostly = {
	370	{
	371	.name = "set",
	372	.family = NFPROTO_IPV4,
	373	.revision = 0,
	374	.match = set_match_v0,
	375	.matchsize = sizeof(struct xt_set_info_match_v0),
	376	.checkentry = set_match_v0_checkentry,
	377	.destroy = set_match_v0_destroy,
	378	.me = THIS_MODULE
	379	},
	380	{
	381	.name = "set",
	382	.family = NFPROTO_IPV4,
	383	.revision = 1,
ac8cc925 JK	384	.match = set_match_v1,
	385	.matchsize = sizeof(struct xt_set_info_match_v1),
	386	.checkentry = set_match_v1_checkentry,
	387	.destroy = set_match_v1_destroy,
d956798d JK	388	.me = THIS_MODULE
	389	},
	390	{
	391	.name = "set",
	392	.family = NFPROTO_IPV6,
	393	.revision = 1,
ac8cc925 JK	394	.match = set_match_v1,
	395	.matchsize = sizeof(struct xt_set_info_match_v1),
	396	.checkentry = set_match_v1_checkentry,
	397	.destroy = set_match_v1_destroy,
d956798d JK	398	.me = THIS_MODULE
d956798d JK	399	},
3e0304a5 JK	400	/* --return-nomatch flag support */
	401	{
	402	.name = "set",
	403	.family = NFPROTO_IPV4,
	404	.revision = 2,
	405	.match = set_match_v1,
	406	.matchsize = sizeof(struct xt_set_info_match_v1),
	407	.checkentry = set_match_v1_checkentry,
	408	.destroy = set_match_v1_destroy,
	409	.me = THIS_MODULE
	410	},
	411	{
	412	.name = "set",
	413	.family = NFPROTO_IPV6,
	414	.revision = 2,
	415	.match = set_match_v1,
	416	.matchsize = sizeof(struct xt_set_info_match_v1),
	417	.checkentry = set_match_v1_checkentry,
	418	.destroy = set_match_v1_destroy,
	419	.me = THIS_MODULE
	420	},
6e01781d JK	421	/* counters support: update, match */
	422	{
	423	.name = "set",
	424	.family = NFPROTO_IPV4,
	425	.revision = 3,
	426	.match = set_match_v3,
	427	.matchsize = sizeof(struct xt_set_info_match_v3),
	428	.checkentry = set_match_v3_checkentry,
	429	.destroy = set_match_v3_destroy,
	430	.me = THIS_MODULE
	431	},
	432	{
	433	.name = "set",
	434	.family = NFPROTO_IPV6,
	435	.revision = 3,
	436	.match = set_match_v3,
	437	.matchsize = sizeof(struct xt_set_info_match_v3),
	438	.checkentry = set_match_v3_checkentry,
	439	.destroy = set_match_v3_destroy,
	440	.me = THIS_MODULE
	441	},
d956798d JK	442	};
	443
	444	static struct xt_target set_targets[] __read_mostly = {
	445	{
	446	.name = "SET",
	447	.revision = 0,
	448	.family = NFPROTO_IPV4,
	449	.target = set_target_v0,
	450	.targetsize = sizeof(struct xt_set_info_target_v0),
	451	.checkentry = set_target_v0_checkentry,
	452	.destroy = set_target_v0_destroy,
	453	.me = THIS_MODULE
	454	},
	455	{
	456	.name = "SET",
	457	.revision = 1,
	458	.family = NFPROTO_IPV4,
ac8cc925 JK	459	.target = set_target_v1,
	460	.targetsize = sizeof(struct xt_set_info_target_v1),
	461	.checkentry = set_target_v1_checkentry,
	462	.destroy = set_target_v1_destroy,
d956798d JK	463	.me = THIS_MODULE
	464	},
	465	{
	466	.name = "SET",
	467	.revision = 1,
	468	.family = NFPROTO_IPV6,
ac8cc925 JK	469	.target = set_target_v1,
	470	.targetsize = sizeof(struct xt_set_info_target_v1),
	471	.checkentry = set_target_v1_checkentry,
	472	.destroy = set_target_v1_destroy,
	473	.me = THIS_MODULE
	474	},
3e0304a5	475	/* --timeout and --exist flags support */
ac8cc925 JK	476	{
	477	.name = "SET",
	478	.revision = 2,
	479	.family = NFPROTO_IPV4,
	480	.target = set_target_v2,
	481	.targetsize = sizeof(struct xt_set_info_target_v2),
	482	.checkentry = set_target_v2_checkentry,
	483	.destroy = set_target_v2_destroy,
	484	.me = THIS_MODULE
	485	},
	486	{
	487	.name = "SET",
	488	.revision = 2,
	489	.family = NFPROTO_IPV6,
	490	.target = set_target_v2,
	491	.targetsize = sizeof(struct xt_set_info_target_v2),
	492	.checkentry = set_target_v2_checkentry,
	493	.destroy = set_target_v2_destroy,
d956798d JK	494	.me = THIS_MODULE
	495	},
	496	};
	497
	498	static int __init xt_set_init(void)
	499	{
	500	int ret = xt_register_matches(set_matches, ARRAY_SIZE(set_matches));
	501
	502	if (!ret) {
	503	ret = xt_register_targets(set_targets,
	504	ARRAY_SIZE(set_targets));
	505	if (ret)
	506	xt_unregister_matches(set_matches,
	507	ARRAY_SIZE(set_matches));
	508	}
	509	return ret;
	510	}
	511
	512	static void __exit xt_set_fini(void)
	513	{
	514	xt_unregister_matches(set_matches, ARRAY_SIZE(set_matches));
	515	xt_unregister_targets(set_targets, ARRAY_SIZE(set_targets));
	516	}
	517
	518	module_init(xt_set_init);
	519	module_exit(xt_set_fini);