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

/* L3/L4 protocol support for nf_conntrack. */

/* (C) 1999-2001 Paul `Rusty' Russell
 * (C) 2002-2006 Netfilter Core Team <coreteam@netfilter.org>
 * (C) 2003,2004 USAGI/WIDE Project <http://www.linux-ipv6.org>
 *
 * 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.
 */

#include <linux/types.h>
#include <linux/netfilter.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/skbuff.h>
#include <linux/vmalloc.h>
#include <linux/stddef.h>
#include <linux/err.h>
#include <linux/percpu.h>
#include <linux/moduleparam.h>
#include <linux/notifier.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/rtnetlink.h>

#include <net/netfilter/nf_conntrack.h>
#include <net/netfilter/nf_conntrack_l3proto.h>
#include <net/netfilter/nf_conntrack_l4proto.h>
#include <net/netfilter/nf_conntrack_core.h>

static struct nf_conntrack_l4proto **nf_ct_protos[PF_MAX] __read_mostly;
struct nf_conntrack_l3proto *nf_ct_l3protos[AF_MAX] __read_mostly;
EXPORT_SYMBOL_GPL(nf_ct_l3protos);

static DEFINE_MUTEX(nf_ct_proto_mutex);

#ifdef CONFIG_SYSCTL
static int
nf_ct_register_sysctl(struct ctl_table_header **header, struct ctl_path *path,
		      struct ctl_table *table, unsigned int *users)
{
	if (*header == NULL) {
		*header = register_sysctl_paths(path, table);
		if (*header == NULL)
			return -ENOMEM;
	}
	if (users != NULL)
		(*users)++;
	return 0;
}

static void
nf_ct_unregister_sysctl(struct ctl_table_header **header,
			struct ctl_table *table, unsigned int *users)
{
	if (users != NULL && --*users > 0)
		return;

	unregister_sysctl_table(*header);
	*header = NULL;
}
#endif

struct nf_conntrack_l4proto *
__nf_ct_l4proto_find(u_int16_t l3proto, u_int8_t l4proto)
{
	if (unlikely(l3proto >= AF_MAX || nf_ct_protos[l3proto] == NULL))
		return &nf_conntrack_l4proto_generic;

	return rcu_dereference(nf_ct_protos[l3proto][l4proto]);
}
EXPORT_SYMBOL_GPL(__nf_ct_l4proto_find);

/* this is guaranteed to always return a valid protocol helper, since
 * it falls back to generic_protocol */
struct nf_conntrack_l3proto *
nf_ct_l3proto_find_get(u_int16_t l3proto)
{
	struct nf_conntrack_l3proto *p;

	rcu_read_lock();
	p = __nf_ct_l3proto_find(l3proto);
	if (!try_module_get(p->me))
		p = &nf_conntrack_l3proto_generic;
	rcu_read_unlock();

	return p;
}
EXPORT_SYMBOL_GPL(nf_ct_l3proto_find_get);

void nf_ct_l3proto_put(struct nf_conntrack_l3proto *p)
{
	module_put(p->me);
}
EXPORT_SYMBOL_GPL(nf_ct_l3proto_put);

int
nf_ct_l3proto_try_module_get(unsigned short l3proto)
{
	int ret;
	struct nf_conntrack_l3proto *p;

retry:	p = nf_ct_l3proto_find_get(l3proto);
	if (p == &nf_conntrack_l3proto_generic) {
		ret = request_module("nf_conntrack-%d", l3proto);
		if (!ret)
			goto retry;

		return -EPROTOTYPE;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(nf_ct_l3proto_try_module_get);

void nf_ct_l3proto_module_put(unsigned short l3proto)
{
	struct nf_conntrack_l3proto *p;

	/* rcu_read_lock not necessary since the caller holds a reference */
	p = __nf_ct_l3proto_find(l3proto);
	module_put(p->me);
}
EXPORT_SYMBOL_GPL(nf_ct_l3proto_module_put);

static int kill_l3proto(struct nf_conn *i, void *data)
{
	return nf_ct_l3num(i) == ((struct nf_conntrack_l3proto *)data)->l3proto;
}

static int kill_l4proto(struct nf_conn *i, void *data)
{
	struct nf_conntrack_l4proto *l4proto;
	l4proto = (struct nf_conntrack_l4proto *)data;
	return nf_ct_protonum(i) == l4proto->l4proto &&
	       nf_ct_l3num(i) == l4proto->l3proto;
}

static int nf_ct_l3proto_register_sysctl(struct nf_conntrack_l3proto *l3proto)
{
	int err = 0;

#ifdef CONFIG_SYSCTL
	if (l3proto->ctl_table != NULL) {
		err = nf_ct_register_sysctl(&l3proto->ctl_table_header,
					    l3proto->ctl_table_path,
					    l3proto->ctl_table, NULL);
	}
#endif
	return err;
}

static void nf_ct_l3proto_unregister_sysctl(struct nf_conntrack_l3proto *l3proto)
{
#ifdef CONFIG_SYSCTL
	if (l3proto->ctl_table_header != NULL)
		nf_ct_unregister_sysctl(&l3proto->ctl_table_header,
					l3proto->ctl_table, NULL);
#endif
}

int nf_conntrack_l3proto_register(struct nf_conntrack_l3proto *proto)
{
	int ret = 0;

	if (proto->l3proto >= AF_MAX)
		return -EBUSY;

	mutex_lock(&nf_ct_proto_mutex);
	if (nf_ct_l3protos[proto->l3proto] != &nf_conntrack_l3proto_generic) {
		ret = -EBUSY;
		goto out_unlock;
	}

	ret = nf_ct_l3proto_register_sysctl(proto);
	if (ret < 0)
		goto out_unlock;

	rcu_assign_pointer(nf_ct_l3protos[proto->l3proto], proto);

out_unlock:
	mutex_unlock(&nf_ct_proto_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(nf_conntrack_l3proto_register);

void nf_conntrack_l3proto_unregister(struct nf_conntrack_l3proto *proto)
{
	struct net *net;

	BUG_ON(proto->l3proto >= AF_MAX);

	mutex_lock(&nf_ct_proto_mutex);
	BUG_ON(nf_ct_l3protos[proto->l3proto] != proto);
	rcu_assign_pointer(nf_ct_l3protos[proto->l3proto],
			   &nf_conntrack_l3proto_generic);
	nf_ct_l3proto_unregister_sysctl(proto);
	mutex_unlock(&nf_ct_proto_mutex);

	synchronize_rcu();

	/* Remove all contrack entries for this protocol */
	rtnl_lock();
	for_each_net(net)
		nf_ct_iterate_cleanup(net, kill_l3proto, proto);
	rtnl_unlock();
}
EXPORT_SYMBOL_GPL(nf_conntrack_l3proto_unregister);

static int nf_ct_l4proto_register_sysctl(struct nf_conntrack_l4proto *l4proto)
{
	int err = 0;

#ifdef CONFIG_SYSCTL
	if (l4proto->ctl_table != NULL) {
		err = nf_ct_register_sysctl(l4proto->ctl_table_header,
					    nf_net_netfilter_sysctl_path,
					    l4proto->ctl_table,
					    l4proto->ctl_table_users);
		if (err < 0)
			goto out;
	}
#ifdef CONFIG_NF_CONNTRACK_PROC_COMPAT
	if (l4proto->ctl_compat_table != NULL) {
		err = nf_ct_register_sysctl(&l4proto->ctl_compat_table_header,
					    nf_net_ipv4_netfilter_sysctl_path,
					    l4proto->ctl_compat_table, NULL);
		if (err == 0)
			goto out;
		nf_ct_unregister_sysctl(l4proto->ctl_table_header,
					l4proto->ctl_table,
					l4proto->ctl_table_users);
	}
#endif /* CONFIG_NF_CONNTRACK_PROC_COMPAT */
out:
#endif /* CONFIG_SYSCTL */
	return err;
}

static void nf_ct_l4proto_unregister_sysctl(struct nf_conntrack_l4proto *l4proto)
{
#ifdef CONFIG_SYSCTL
	if (l4proto->ctl_table_header != NULL &&
	    *l4proto->ctl_table_header != NULL)
		nf_ct_unregister_sysctl(l4proto->ctl_table_header,
					l4proto->ctl_table,
					l4proto->ctl_table_users);
#ifdef CONFIG_NF_CONNTRACK_PROC_COMPAT
	if (l4proto->ctl_compat_table_header != NULL)
		nf_ct_unregister_sysctl(&l4proto->ctl_compat_table_header,
					l4proto->ctl_compat_table, NULL);
#endif /* CONFIG_NF_CONNTRACK_PROC_COMPAT */
#endif /* CONFIG_SYSCTL */
}

/* FIXME: Allow NULL functions and sub in pointers to generic for
   them. --RR */
int nf_conntrack_l4proto_register(struct nf_conntrack_l4proto *l4proto)
{
	int ret = 0;

	if (l4proto->l3proto >= PF_MAX)
		return -EBUSY;

	mutex_lock(&nf_ct_proto_mutex);
	if (!nf_ct_protos[l4proto->l3proto]) {
		/* l3proto may be loaded latter. */
		struct nf_conntrack_l4proto **proto_array;
		int i;

		proto_array = kmalloc(MAX_NF_CT_PROTO *
				      sizeof(struct nf_conntrack_l4proto *),
				      GFP_KERNEL);
		if (proto_array == NULL) {
			ret = -ENOMEM;
			goto out_unlock;
		}

		for (i = 0; i < MAX_NF_CT_PROTO; i++)
			proto_array[i] = &nf_conntrack_l4proto_generic;
		nf_ct_protos[l4proto->l3proto] = proto_array;
	} else if (nf_ct_protos[l4proto->l3proto][l4proto->l4proto] !=
					&nf_conntrack_l4proto_generic) {
		ret = -EBUSY;
		goto out_unlock;
	}

	ret = nf_ct_l4proto_register_sysctl(l4proto);
	if (ret < 0)
		goto out_unlock;

	rcu_assign_pointer(nf_ct_protos[l4proto->l3proto][l4proto->l4proto],
			   l4proto);

out_unlock:
	mutex_unlock(&nf_ct_proto_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(nf_conntrack_l4proto_register);

void nf_conntrack_l4proto_unregister(struct nf_conntrack_l4proto *l4proto)
{
	struct net *net;

	BUG_ON(l4proto->l3proto >= PF_MAX);

	mutex_lock(&nf_ct_proto_mutex);
	BUG_ON(nf_ct_protos[l4proto->l3proto][l4proto->l4proto] != l4proto);
	rcu_assign_pointer(nf_ct_protos[l4proto->l3proto][l4proto->l4proto],
			   &nf_conntrack_l4proto_generic);
	nf_ct_l4proto_unregister_sysctl(l4proto);
	mutex_unlock(&nf_ct_proto_mutex);

	synchronize_rcu();

	/* Remove all contrack entries for this protocol */
	rtnl_lock();
	for_each_net(net)
		nf_ct_iterate_cleanup(net, kill_l4proto, l4proto);
	rtnl_unlock();
}
EXPORT_SYMBOL_GPL(nf_conntrack_l4proto_unregister);

int nf_conntrack_proto_init(void)
{
	unsigned int i;
	int err;

	err = nf_ct_l4proto_register_sysctl(&nf_conntrack_l4proto_generic);
	if (err < 0)
		return err;

	for (i = 0; i < AF_MAX; i++)
		rcu_assign_pointer(nf_ct_l3protos[i],
				   &nf_conntrack_l3proto_generic);
	return 0;
}

void nf_conntrack_proto_fini(void)
{
	unsigned int i;

	nf_ct_l4proto_unregister_sysctl(&nf_conntrack_l4proto_generic);

	/* free l3proto protocol tables */
	for (i = 0; i < PF_MAX; i++)
		kfree(nf_ct_protos[i]);
}
Commit	Line	Data
8f03dea5 MJ	1	/* L3/L4 protocol support for nf_conntrack. */
	2
	3	/* (C) 1999-2001 Paul `Rusty' Russell
	4	* (C) 2002-2006 Netfilter Core Team <coreteam@netfilter.org>
	5	* (C) 2003,2004 USAGI/WIDE Project <http://www.linux-ipv6.org>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
	12	#include <linux/types.h>
	13	#include <linux/netfilter.h>
	14	#include <linux/module.h>
d62f9ed4	15	#include <linux/mutex.h>
8f03dea5 MJ	16	#include <linux/skbuff.h>
	17	#include <linux/vmalloc.h>
	18	#include <linux/stddef.h>
	19	#include <linux/err.h>
	20	#include <linux/percpu.h>
	21	#include <linux/moduleparam.h>
	22	#include <linux/notifier.h>
	23	#include <linux/kernel.h>
	24	#include <linux/netdevice.h>
efb9a8c2	25	#include <linux/rtnetlink.h>
8f03dea5 MJ	26
	27	#include <net/netfilter/nf_conntrack.h>
	28	#include <net/netfilter/nf_conntrack_l3proto.h>
605dcad6	29	#include <net/netfilter/nf_conntrack_l4proto.h>
8f03dea5 MJ	30	#include <net/netfilter/nf_conntrack_core.h>
8f03dea5 MJ	31
42bad1da	32	static struct nf_conntrack_l4proto **nf_ct_protos[PF_MAX] __read_mostly;
ae5718fb	33	struct nf_conntrack_l3proto *nf_ct_l3protos[AF_MAX] __read_mostly;
13b18339	34	EXPORT_SYMBOL_GPL(nf_ct_l3protos);
8f03dea5	35
b19caa0c	36	static DEFINE_MUTEX(nf_ct_proto_mutex);
d62f9ed4	37
b19caa0c	38	#ifdef CONFIG_SYSCTL
d62f9ed4	39	static int
b3fd3ffe	40	nf_ct_register_sysctl(struct ctl_table_header *header, struct ctl_path path,
d62f9ed4 PM	41	struct ctl_table table, unsigned int users)
	42	{
	43	if (*header == NULL) {
b3fd3ffe	44	*header = register_sysctl_paths(path, table);
d62f9ed4 PM	45	if (*header == NULL)
	46	return -ENOMEM;
	47	}
	48	if (users != NULL)
	49	(*users)++;
	50	return 0;
	51	}
	52
	53	static void
	54	nf_ct_unregister_sysctl(struct ctl_table_header **header,
	55	struct ctl_table table, unsigned int users)
	56	{
	57	if (users != NULL && --*users > 0)
	58	return;
b3fd3ffe PE	59
b3fd3ffe PE	60	unregister_sysctl_table(*header);
d62f9ed4 PM	61	*header = NULL;
	62	}
	63	#endif
	64
605dcad6 MJ	65	struct nf_conntrack_l4proto *
605dcad6 MJ	66	__nf_ct_l4proto_find(u_int16_t l3proto, u_int8_t l4proto)
8f03dea5 MJ	67	{
8f03dea5 MJ	68	if (unlikely(l3proto >= AF_MAX \|\| nf_ct_protos[l3proto] == NULL))
605dcad6	69	return &nf_conntrack_l4proto_generic;
8f03dea5	70
923f4902	71	return rcu_dereference(nf_ct_protos[l3proto][l4proto]);
8f03dea5	72	}
13b18339	73	EXPORT_SYMBOL_GPL(__nf_ct_l4proto_find);
8f03dea5 MJ	74
	75	/* this is guaranteed to always return a valid protocol helper, since
	76	* it falls back to generic_protocol */
8f03dea5 MJ	77	struct nf_conntrack_l3proto *
	78	nf_ct_l3proto_find_get(u_int16_t l3proto)
	79	{
	80	struct nf_conntrack_l3proto *p;
	81
923f4902	82	rcu_read_lock();
8f03dea5 MJ	83	p = __nf_ct_l3proto_find(l3proto);
8f03dea5 MJ	84	if (!try_module_get(p->me))
605dcad6	85	p = &nf_conntrack_l3proto_generic;
923f4902	86	rcu_read_unlock();
8f03dea5 MJ	87
	88	return p;
	89	}
13b18339	90	EXPORT_SYMBOL_GPL(nf_ct_l3proto_find_get);
8f03dea5 MJ	91
	92	void nf_ct_l3proto_put(struct nf_conntrack_l3proto *p)
	93	{
	94	module_put(p->me);
	95	}
13b18339	96	EXPORT_SYMBOL_GPL(nf_ct_l3proto_put);
8f03dea5 MJ	97
	98	int
	99	nf_ct_l3proto_try_module_get(unsigned short l3proto)
	100	{
	101	int ret;
	102	struct nf_conntrack_l3proto *p;
	103
	104	retry: p = nf_ct_l3proto_find_get(l3proto);
605dcad6	105	if (p == &nf_conntrack_l3proto_generic) {
8f03dea5 MJ	106	ret = request_module("nf_conntrack-%d", l3proto);
	107	if (!ret)
	108	goto retry;
	109
	110	return -EPROTOTYPE;
	111	}
	112
	113	return 0;
	114	}
13b18339	115	EXPORT_SYMBOL_GPL(nf_ct_l3proto_try_module_get);
8f03dea5 MJ	116
	117	void nf_ct_l3proto_module_put(unsigned short l3proto)
	118	{
	119	struct nf_conntrack_l3proto *p;
	120
923f4902	121	/* rcu_read_lock not necessary since the caller holds a reference */
8f03dea5	122	p = __nf_ct_l3proto_find(l3proto);
8f03dea5 MJ	123	module_put(p->me);
8f03dea5 MJ	124	}
13b18339	125	EXPORT_SYMBOL_GPL(nf_ct_l3proto_module_put);
8f03dea5 MJ	126
	127	static int kill_l3proto(struct nf_conn i, void data)
	128	{
5e8fbe2a	129	return nf_ct_l3num(i) == ((struct nf_conntrack_l3proto *)data)->l3proto;
8f03dea5 MJ	130	}
8f03dea5 MJ	131
605dcad6	132	static int kill_l4proto(struct nf_conn i, void data)
8f03dea5	133	{
605dcad6 MJ	134	struct nf_conntrack_l4proto *l4proto;
605dcad6 MJ	135	l4proto = (struct nf_conntrack_l4proto *)data;
5e8fbe2a PM	136	return nf_ct_protonum(i) == l4proto->l4proto &&
5e8fbe2a PM	137	nf_ct_l3num(i) == l4proto->l3proto;
8f03dea5 MJ	138	}
8f03dea5 MJ	139
d62f9ed4 PM	140	static int nf_ct_l3proto_register_sysctl(struct nf_conntrack_l3proto *l3proto)
	141	{
	142	int err = 0;
	143
	144	#ifdef CONFIG_SYSCTL
d62f9ed4 PM	145	if (l3proto->ctl_table != NULL) {
	146	err = nf_ct_register_sysctl(&l3proto->ctl_table_header,
	147	l3proto->ctl_table_path,
	148	l3proto->ctl_table, NULL);
	149	}
d62f9ed4 PM	150	#endif
	151	return err;
	152	}
	153
	154	static void nf_ct_l3proto_unregister_sysctl(struct nf_conntrack_l3proto *l3proto)
	155	{
	156	#ifdef CONFIG_SYSCTL
d62f9ed4 PM	157	if (l3proto->ctl_table_header != NULL)
	158	nf_ct_unregister_sysctl(&l3proto->ctl_table_header,
	159	l3proto->ctl_table, NULL);
d62f9ed4 PM	160	#endif
	161	}
	162
8f03dea5 MJ	163	int nf_conntrack_l3proto_register(struct nf_conntrack_l3proto *proto)
	164	{
	165	int ret = 0;
	166
0661cca9 PM	167	if (proto->l3proto >= AF_MAX)
0661cca9 PM	168	return -EBUSY;
ae5718fb	169
b19caa0c	170	mutex_lock(&nf_ct_proto_mutex);
605dcad6	171	if (nf_ct_l3protos[proto->l3proto] != &nf_conntrack_l3proto_generic) {
8f03dea5	172	ret = -EBUSY;
ae5718fb	173	goto out_unlock;
8f03dea5	174	}
d62f9ed4 PM	175
	176	ret = nf_ct_l3proto_register_sysctl(proto);
	177	if (ret < 0)
0661cca9 PM	178	goto out_unlock;
	179
	180	rcu_assign_pointer(nf_ct_l3protos[proto->l3proto], proto);
8f03dea5	181
ae5718fb	182	out_unlock:
b19caa0c	183	mutex_unlock(&nf_ct_proto_mutex);
8f03dea5 MJ	184	return ret;
8f03dea5 MJ	185	}
13b18339	186	EXPORT_SYMBOL_GPL(nf_conntrack_l3proto_register);
8f03dea5	187
fe3eb20c	188	void nf_conntrack_l3proto_unregister(struct nf_conntrack_l3proto *proto)
8f03dea5	189	{
678d6675 AD	190	struct net *net;
678d6675 AD	191
fe3eb20c	192	BUG_ON(proto->l3proto >= AF_MAX);
ae5718fb	193
b19caa0c	194	mutex_lock(&nf_ct_proto_mutex);
fe3eb20c	195	BUG_ON(nf_ct_l3protos[proto->l3proto] != proto);
923f4902 PM	196	rcu_assign_pointer(nf_ct_l3protos[proto->l3proto],
923f4902 PM	197	&nf_conntrack_l3proto_generic);
0661cca9	198	nf_ct_l3proto_unregister_sysctl(proto);
b19caa0c	199	mutex_unlock(&nf_ct_proto_mutex);
8f03dea5	200
0661cca9	201	synchronize_rcu();
d62f9ed4	202
8f03dea5	203	/* Remove all contrack entries for this protocol */
efb9a8c2	204	rtnl_lock();
678d6675 AD	205	for_each_net(net)
678d6675 AD	206	nf_ct_iterate_cleanup(net, kill_l3proto, proto);
efb9a8c2	207	rtnl_unlock();
8f03dea5	208	}
13b18339	209	EXPORT_SYMBOL_GPL(nf_conntrack_l3proto_unregister);
8f03dea5	210
d62f9ed4 PM	211	static int nf_ct_l4proto_register_sysctl(struct nf_conntrack_l4proto *l4proto)
	212	{
	213	int err = 0;
	214
	215	#ifdef CONFIG_SYSCTL
d62f9ed4 PM	216	if (l4proto->ctl_table != NULL) {
	217	err = nf_ct_register_sysctl(l4proto->ctl_table_header,
	218	nf_net_netfilter_sysctl_path,
	219	l4proto->ctl_table,
	220	l4proto->ctl_table_users);
a999e683 PM	221	if (err < 0)
a999e683 PM	222	goto out;
d62f9ed4	223	}
a999e683 PM	224	#ifdef CONFIG_NF_CONNTRACK_PROC_COMPAT
	225	if (l4proto->ctl_compat_table != NULL) {
	226	err = nf_ct_register_sysctl(&l4proto->ctl_compat_table_header,
	227	nf_net_ipv4_netfilter_sysctl_path,
	228	l4proto->ctl_compat_table, NULL);
	229	if (err == 0)
	230	goto out;
	231	nf_ct_unregister_sysctl(l4proto->ctl_table_header,
	232	l4proto->ctl_table,
	233	l4proto->ctl_table_users);
	234	}
	235	#endif /* CONFIG_NF_CONNTRACK_PROC_COMPAT */
	236	out:
933a41e7	237	#endif /* CONFIG_SYSCTL */
d62f9ed4 PM	238	return err;
	239	}
	240
	241	static void nf_ct_l4proto_unregister_sysctl(struct nf_conntrack_l4proto *l4proto)
	242	{
	243	#ifdef CONFIG_SYSCTL
d62f9ed4 PM	244	if (l4proto->ctl_table_header != NULL &&
	245	*l4proto->ctl_table_header != NULL)
	246	nf_ct_unregister_sysctl(l4proto->ctl_table_header,
	247	l4proto->ctl_table,
	248	l4proto->ctl_table_users);
a999e683 PM	249	#ifdef CONFIG_NF_CONNTRACK_PROC_COMPAT
	250	if (l4proto->ctl_compat_table_header != NULL)
	251	nf_ct_unregister_sysctl(&l4proto->ctl_compat_table_header,
	252	l4proto->ctl_compat_table, NULL);
	253	#endif /* CONFIG_NF_CONNTRACK_PROC_COMPAT */
933a41e7	254	#endif /* CONFIG_SYSCTL */
d62f9ed4 PM	255	}
d62f9ed4 PM	256
8f03dea5 MJ	257	/* FIXME: Allow NULL functions and sub in pointers to generic for
8f03dea5 MJ	258	them. --RR */
605dcad6	259	int nf_conntrack_l4proto_register(struct nf_conntrack_l4proto *l4proto)
8f03dea5 MJ	260	{
	261	int ret = 0;
	262
0661cca9 PM	263	if (l4proto->l3proto >= PF_MAX)
0661cca9 PM	264	return -EBUSY;
ae5718fb	265
b19caa0c	266	mutex_lock(&nf_ct_proto_mutex);
c6a1e615	267	if (!nf_ct_protos[l4proto->l3proto]) {
8f03dea5	268	/* l3proto may be loaded latter. */
605dcad6	269	struct nf_conntrack_l4proto **proto_array;
8f03dea5 MJ	270	int i;
8f03dea5 MJ	271
c6a1e615 PM	272	proto_array = kmalloc(MAX_NF_CT_PROTO *
	273	sizeof(struct nf_conntrack_l4proto *),
	274	GFP_KERNEL);
8f03dea5 MJ	275	if (proto_array == NULL) {
8f03dea5 MJ	276	ret = -ENOMEM;
b19caa0c	277	goto out_unlock;
8f03dea5	278	}
c6a1e615	279
8f03dea5	280	for (i = 0; i < MAX_NF_CT_PROTO; i++)
605dcad6	281	proto_array[i] = &nf_conntrack_l4proto_generic;
c6a1e615 PM	282	nf_ct_protos[l4proto->l3proto] = proto_array;
	283	} else if (nf_ct_protos[l4proto->l3proto][l4proto->l4proto] !=
	284	&nf_conntrack_l4proto_generic) {
	285	ret = -EBUSY;
	286	goto out_unlock;
8f03dea5 MJ	287	}
8f03dea5 MJ	288
d62f9ed4 PM	289	ret = nf_ct_l4proto_register_sysctl(l4proto);
d62f9ed4 PM	290	if (ret < 0)
0661cca9 PM	291	goto out_unlock;
0661cca9 PM	292
c6a1e615 PM	293	rcu_assign_pointer(nf_ct_protos[l4proto->l3proto][l4proto->l4proto],
c6a1e615 PM	294	l4proto);
8f03dea5 MJ	295
8f03dea5 MJ	296	out_unlock:
b19caa0c	297	mutex_unlock(&nf_ct_proto_mutex);
8f03dea5 MJ	298	return ret;
8f03dea5 MJ	299	}
13b18339	300	EXPORT_SYMBOL_GPL(nf_conntrack_l4proto_register);
8f03dea5	301
fe3eb20c	302	void nf_conntrack_l4proto_unregister(struct nf_conntrack_l4proto *l4proto)
8f03dea5	303	{
678d6675 AD	304	struct net *net;
678d6675 AD	305
fe3eb20c	306	BUG_ON(l4proto->l3proto >= PF_MAX);
ae5718fb	307
b19caa0c	308	mutex_lock(&nf_ct_proto_mutex);
fe3eb20c	309	BUG_ON(nf_ct_protos[l4proto->l3proto][l4proto->l4proto] != l4proto);
923f4902 PM	310	rcu_assign_pointer(nf_ct_protos[l4proto->l3proto][l4proto->l4proto],
923f4902 PM	311	&nf_conntrack_l4proto_generic);
0661cca9	312	nf_ct_l4proto_unregister_sysctl(l4proto);
b19caa0c	313	mutex_unlock(&nf_ct_proto_mutex);
8f03dea5	314
0661cca9	315	synchronize_rcu();
d62f9ed4	316
8f03dea5	317	/* Remove all contrack entries for this protocol */
efb9a8c2	318	rtnl_lock();
678d6675 AD	319	for_each_net(net)
678d6675 AD	320	nf_ct_iterate_cleanup(net, kill_l4proto, l4proto);
efb9a8c2	321	rtnl_unlock();
8f03dea5	322	}
13b18339	323	EXPORT_SYMBOL_GPL(nf_conntrack_l4proto_unregister);
ac5357eb PM	324
	325	int nf_conntrack_proto_init(void)
	326	{
	327	unsigned int i;
	328	int err;
	329
	330	err = nf_ct_l4proto_register_sysctl(&nf_conntrack_l4proto_generic);
	331	if (err < 0)
	332	return err;
	333
	334	for (i = 0; i < AF_MAX; i++)
	335	rcu_assign_pointer(nf_ct_l3protos[i],
	336	&nf_conntrack_l3proto_generic);
	337	return 0;
	338	}
	339
	340	void nf_conntrack_proto_fini(void)
	341	{
	342	unsigned int i;
	343
	344	nf_ct_l4proto_unregister_sysctl(&nf_conntrack_l4proto_generic);
	345
	346	/* free l3proto protocol tables */
	347	for (i = 0; i < PF_MAX; i++)
	348	kfree(nf_ct_protos[i]);
	349	}