[linux-block.git] / net / netfilter / xt_MASQUERADE.c

// SPDX-License-Identifier: GPL-2.0-only
/* Masquerade.  Simple mapping which alters range to a local IP address
   (depending on route). */

/* (C) 1999-2001 Paul `Rusty' Russell
 * (C) 2002-2006 Netfilter Core Team <coreteam@netfilter.org>
 */
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/module.h>
#include <linux/netfilter/x_tables.h>
#include <net/netfilter/nf_nat.h>
#include <net/netfilter/nf_nat_masquerade.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Netfilter Core Team <coreteam@netfilter.org>");
MODULE_DESCRIPTION("Xtables: automatic-address SNAT");

/* FIXME: Multiple targets. --RR */
static int masquerade_tg_check(const struct xt_tgchk_param *par)
{
	const struct nf_nat_ipv4_multi_range_compat *mr = par->targinfo;

	if (mr->range[0].flags & NF_NAT_RANGE_MAP_IPS) {
		pr_debug("bad MAP_IPS.\n");
		return -EINVAL;
	}
	if (mr->rangesize != 1) {
		pr_debug("bad rangesize %u\n", mr->rangesize);
		return -EINVAL;
	}
	return nf_ct_netns_get(par->net, par->family);
}

static unsigned int
masquerade_tg(struct sk_buff *skb, const struct xt_action_param *par)
{
	struct nf_nat_range2 range;
	const struct nf_nat_ipv4_multi_range_compat *mr;

	mr = par->targinfo;
	range.flags = mr->range[0].flags;
	range.min_proto = mr->range[0].min;
	range.max_proto = mr->range[0].max;

	return nf_nat_masquerade_ipv4(skb, xt_hooknum(par), &range,
				      xt_out(par));
}

static void masquerade_tg_destroy(const struct xt_tgdtor_param *par)
{
	nf_ct_netns_put(par->net, par->family);
}

#if IS_ENABLED(CONFIG_IPV6)
static unsigned int
masquerade_tg6(struct sk_buff *skb, const struct xt_action_param *par)
{
	return nf_nat_masquerade_ipv6(skb, par->targinfo, xt_out(par));
}

static int masquerade_tg6_checkentry(const struct xt_tgchk_param *par)
{
	const struct nf_nat_range2 *range = par->targinfo;

	if (range->flags & NF_NAT_RANGE_MAP_IPS)
		return -EINVAL;

	return nf_ct_netns_get(par->net, par->family);
}
#endif

static struct xt_target masquerade_tg_reg[] __read_mostly = {
	{
#if IS_ENABLED(CONFIG_IPV6)
		.name		= "MASQUERADE",
		.family		= NFPROTO_IPV6,
		.target		= masquerade_tg6,
		.targetsize	= sizeof(struct nf_nat_range),
		.table		= "nat",
		.hooks		= 1 << NF_INET_POST_ROUTING,
		.checkentry	= masquerade_tg6_checkentry,
		.destroy	= masquerade_tg_destroy,
		.me		= THIS_MODULE,
	}, {
#endif
		.name		= "MASQUERADE",
		.family		= NFPROTO_IPV4,
		.target		= masquerade_tg,
		.targetsize	= sizeof(struct nf_nat_ipv4_multi_range_compat),
		.table		= "nat",
		.hooks		= 1 << NF_INET_POST_ROUTING,
		.checkentry	= masquerade_tg_check,
		.destroy	= masquerade_tg_destroy,
		.me		= THIS_MODULE,
	}
};

static int __init masquerade_tg_init(void)
{
	int ret;

	ret = xt_register_targets(masquerade_tg_reg,
				  ARRAY_SIZE(masquerade_tg_reg));
	if (ret)
		return ret;

	ret = nf_nat_masquerade_inet_register_notifiers();
	if (ret) {
		xt_unregister_targets(masquerade_tg_reg,
				      ARRAY_SIZE(masquerade_tg_reg));
		return ret;
	}

	return ret;
}

static void __exit masquerade_tg_exit(void)
{
	xt_unregister_targets(masquerade_tg_reg, ARRAY_SIZE(masquerade_tg_reg));
	nf_nat_masquerade_inet_unregister_notifiers();
}

module_init(masquerade_tg_init);
module_exit(masquerade_tg_exit);
#if IS_ENABLED(CONFIG_IPV6)
MODULE_ALIAS("ip6t_MASQUERADE");
#endif
MODULE_ALIAS("ipt_MASQUERADE");
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
1da177e4 LT	2	/* Masquerade. Simple mapping which alters range to a local IP address
	3	(depending on route). */
	4
	5	/* (C) 1999-2001 Paul `Rusty' Russell
5b1158e9	6	* (C) 2002-2006 Netfilter Core Team <coreteam@netfilter.org>
1da177e4	7	*/
ff67e4e4	8	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
1da177e4	9	#include <linux/module.h>
6709dbbb	10	#include <linux/netfilter/x_tables.h>
c7232c99	11	#include <net/netfilter/nf_nat.h>
bf8981a2	12	#include <net/netfilter/nf_nat_masquerade.h>
1da177e4 LT	13
	14	MODULE_LICENSE("GPL");
	15	MODULE_AUTHOR("Netfilter Core Team <coreteam@netfilter.org>");
2ae15b64	16	MODULE_DESCRIPTION("Xtables: automatic-address SNAT");
1da177e4	17
1da177e4	18	/* FIXME: Multiple targets. --RR */
135367b8	19	static int masquerade_tg_check(const struct xt_tgchk_param *par)
1da177e4	20	{
cbc9f2f4	21	const struct nf_nat_ipv4_multi_range_compat *mr = par->targinfo;
1da177e4	22
cbc9f2f4	23	if (mr->range[0].flags & NF_NAT_RANGE_MAP_IPS) {
ff67e4e4	24	pr_debug("bad MAP_IPS.\n");
d6b00a53	25	return -EINVAL;
1da177e4 LT	26	}
1da177e4 LT	27	if (mr->rangesize != 1) {
ff67e4e4	28	pr_debug("bad rangesize %u\n", mr->rangesize);
d6b00a53	29	return -EINVAL;
1da177e4	30	}
a357b3f8	31	return nf_ct_netns_get(par->net, par->family);
1da177e4 LT	32	}
	33
	34	static unsigned int
4b560b44	35	masquerade_tg(struct sk_buff skb, const struct xt_action_param par)
1da177e4	36	{
2eb0f624	37	struct nf_nat_range2 range;
cbc9f2f4	38	const struct nf_nat_ipv4_multi_range_compat *mr;
adcb5ad1	39
7eb35586	40	mr = par->targinfo;
8dd33cc9 AB	41	range.flags = mr->range[0].flags;
	42	range.min_proto = mr->range[0].min;
	43	range.max_proto = mr->range[0].max;
1da177e4	44
613dbd95 PNA	45	return nf_nat_masquerade_ipv4(skb, xt_hooknum(par), &range,
613dbd95 PNA	46	xt_out(par));
1da177e4 LT	47	}
1da177e4 LT	48
a357b3f8 FW	49	static void masquerade_tg_destroy(const struct xt_tgdtor_param *par)
	50	{
	51	nf_ct_netns_put(par->net, par->family);
	52	}
	53
adf82acc FW	54	#if IS_ENABLED(CONFIG_IPV6)
	55	static unsigned int
	56	masquerade_tg6(struct sk_buff skb, const struct xt_action_param par)
	57	{
	58	return nf_nat_masquerade_ipv6(skb, par->targinfo, xt_out(par));
	59	}
	60
	61	static int masquerade_tg6_checkentry(const struct xt_tgchk_param *par)
	62	{
	63	const struct nf_nat_range2 *range = par->targinfo;
	64
	65	if (range->flags & NF_NAT_RANGE_MAP_IPS)
	66	return -EINVAL;
	67
	68	return nf_ct_netns_get(par->net, par->family);
	69	}
	70	#endif
	71
	72	static struct xt_target masquerade_tg_reg[] __read_mostly = {
	73	{
	74	#if IS_ENABLED(CONFIG_IPV6)
	75	.name = "MASQUERADE",
	76	.family = NFPROTO_IPV6,
	77	.target = masquerade_tg6,
	78	.targetsize = sizeof(struct nf_nat_range),
	79	.table = "nat",
	80	.hooks = 1 << NF_INET_POST_ROUTING,
	81	.checkentry = masquerade_tg6_checkentry,
	82	.destroy = masquerade_tg_destroy,
	83	.me = THIS_MODULE,
	84	}, {
	85	#endif
	86	.name = "MASQUERADE",
	87	.family = NFPROTO_IPV4,
	88	.target = masquerade_tg,
	89	.targetsize = sizeof(struct nf_nat_ipv4_multi_range_compat),
	90	.table = "nat",
	91	.hooks = 1 << NF_INET_POST_ROUTING,
	92	.checkentry = masquerade_tg_check,
	93	.destroy = masquerade_tg_destroy,
	94	.me = THIS_MODULE,
	95	}
1da177e4 LT	96	};
1da177e4 LT	97
d3c5ee6d	98	static int __init masquerade_tg_init(void)
1da177e4 LT	99	{
	100	int ret;
	101
adf82acc FW	102	ret = xt_register_targets(masquerade_tg_reg,
adf82acc FW	103	ARRAY_SIZE(masquerade_tg_reg));
584eab29 TY	104	if (ret)
584eab29 TY	105	return ret;
1da177e4	106
610a4314	107	ret = nf_nat_masquerade_inet_register_notifiers();
adf82acc FW	108	if (ret) {
	109	xt_unregister_targets(masquerade_tg_reg,
	110	ARRAY_SIZE(masquerade_tg_reg));
	111	return ret;
	112	}
1da177e4 LT	113
	114	return ret;
	115	}
	116
d3c5ee6d	117	static void __exit masquerade_tg_exit(void)
1da177e4	118	{
adf82acc	119	xt_unregister_targets(masquerade_tg_reg, ARRAY_SIZE(masquerade_tg_reg));
610a4314	120	nf_nat_masquerade_inet_unregister_notifiers();
1da177e4 LT	121	}
1da177e4 LT	122
d3c5ee6d JE	123	module_init(masquerade_tg_init);
d3c5ee6d JE	124	module_exit(masquerade_tg_exit);
adf82acc FW	125	#if IS_ENABLED(CONFIG_IPV6)
	126	MODULE_ALIAS("ip6t_MASQUERADE");
	127	#endif
	128	MODULE_ALIAS("ipt_MASQUERADE");