[linux.git] / net / netfilter / nfnetlink_cttimeout.c

/*
 * (C) 2012 by Pablo Neira Ayuso <[email protected]>
 * (C) 2012 by Vyatta Inc. <http://www.vyatta.com>
 *
 * 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 (or any later at your option).
 */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/rculist.h>
#include <linux/rculist_nulls.h>
#include <linux/types.h>
#include <linux/timer.h>
#include <linux/security.h>
#include <linux/skbuff.h>
#include <linux/errno.h>
#include <linux/netlink.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <linux/slab.h>

#include <linux/netfilter.h>
#include <net/netlink.h>
#include <net/sock.h>
#include <net/netfilter/nf_conntrack.h>
#include <net/netfilter/nf_conntrack_core.h>
#include <net/netfilter/nf_conntrack_l4proto.h>
#include <net/netfilter/nf_conntrack_tuple.h>
#include <net/netfilter/nf_conntrack_timeout.h>

#include <linux/netfilter/nfnetlink.h>
#include <linux/netfilter/nfnetlink_cttimeout.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Pablo Neira Ayuso <[email protected]>");
MODULE_DESCRIPTION("cttimeout: Extended Netfilter Connection Tracking timeout tuning");

static const struct nla_policy cttimeout_nla_policy[CTA_TIMEOUT_MAX+1] = {
	[CTA_TIMEOUT_NAME]	= { .type = NLA_NUL_STRING,
				    .len  = CTNL_TIMEOUT_NAME_MAX - 1},
	[CTA_TIMEOUT_L3PROTO]	= { .type = NLA_U16 },
	[CTA_TIMEOUT_L4PROTO]	= { .type = NLA_U8 },
	[CTA_TIMEOUT_DATA]	= { .type = NLA_NESTED },
};

static int
ctnl_timeout_parse_policy(void *timeout,
			  const struct nf_conntrack_l4proto *l4proto,
			  struct net *net, const struct nlattr *attr)
{
	struct nlattr **tb;
	int ret = 0;

	tb = kcalloc(l4proto->ctnl_timeout.nlattr_max + 1, sizeof(*tb),
		     GFP_KERNEL);

	if (!tb)
		return -ENOMEM;

	ret = nla_parse_nested(tb, l4proto->ctnl_timeout.nlattr_max, attr,
			       l4proto->ctnl_timeout.nla_policy, NULL);
	if (ret < 0)
		goto err;

	ret = l4proto->ctnl_timeout.nlattr_to_obj(tb, net, timeout);

err:
	kfree(tb);
	return ret;
}

static int cttimeout_new_timeout(struct net *net, struct sock *ctnl,
				 struct sk_buff *skb,
				 const struct nlmsghdr *nlh,
				 const struct nlattr * const cda[],
				 struct netlink_ext_ack *extack)
{
	__u16 l3num;
	__u8 l4num;
	const struct nf_conntrack_l4proto *l4proto;
	struct ctnl_timeout *timeout, *matching = NULL;
	char *name;
	int ret;

	if (!cda[CTA_TIMEOUT_NAME] ||
	    !cda[CTA_TIMEOUT_L3PROTO] ||
	    !cda[CTA_TIMEOUT_L4PROTO] ||
	    !cda[CTA_TIMEOUT_DATA])
		return -EINVAL;

	name = nla_data(cda[CTA_TIMEOUT_NAME]);
	l3num = ntohs(nla_get_be16(cda[CTA_TIMEOUT_L3PROTO]));
	l4num = nla_get_u8(cda[CTA_TIMEOUT_L4PROTO]);

	list_for_each_entry(timeout, &net->nfct_timeout_list, head) {
		if (strncmp(timeout->name, name, CTNL_TIMEOUT_NAME_MAX) != 0)
			continue;

		if (nlh->nlmsg_flags & NLM_F_EXCL)
			return -EEXIST;

		matching = timeout;
		break;
	}

	if (matching) {
		if (nlh->nlmsg_flags & NLM_F_REPLACE) {
			/* You cannot replace one timeout policy by another of
			 * different kind, sorry.
			 */
			if (matching->timeout.l3num != l3num ||
			    matching->timeout.l4proto->l4proto != l4num)
				return -EINVAL;

			return ctnl_timeout_parse_policy(&matching->timeout.data,
							 matching->timeout.l4proto,
							 net, cda[CTA_TIMEOUT_DATA]);
		}

		return -EBUSY;
	}

	l4proto = nf_ct_l4proto_find_get(l4num);

	/* This protocol is not supportted, skip. */
	if (l4proto->l4proto != l4num) {
		ret = -EOPNOTSUPP;
		goto err_proto_put;
	}

	timeout = kzalloc(sizeof(struct ctnl_timeout) +
			  l4proto->ctnl_timeout.obj_size, GFP_KERNEL);
	if (timeout == NULL) {
		ret = -ENOMEM;
		goto err_proto_put;
	}

	ret = ctnl_timeout_parse_policy(&timeout->timeout.data, l4proto, net,
					cda[CTA_TIMEOUT_DATA]);
	if (ret < 0)
		goto err;

	strcpy(timeout->name, nla_data(cda[CTA_TIMEOUT_NAME]));
	timeout->timeout.l3num = l3num;
	timeout->timeout.l4proto = l4proto;
	refcount_set(&timeout->refcnt, 1);
	list_add_tail_rcu(&timeout->head, &net->nfct_timeout_list);

	return 0;
err:
	kfree(timeout);
err_proto_put:
	nf_ct_l4proto_put(l4proto);
	return ret;
}

static int
ctnl_timeout_fill_info(struct sk_buff *skb, u32 portid, u32 seq, u32 type,
		       int event, struct ctnl_timeout *timeout)
{
	struct nlmsghdr *nlh;
	struct nfgenmsg *nfmsg;
	unsigned int flags = portid ? NLM_F_MULTI : 0;
	const struct nf_conntrack_l4proto *l4proto = timeout->timeout.l4proto;
	struct nlattr *nest_parms;
	int ret;

	event = nfnl_msg_type(NFNL_SUBSYS_CTNETLINK_TIMEOUT, event);
	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*nfmsg), flags);
	if (nlh == NULL)
		goto nlmsg_failure;

	nfmsg = nlmsg_data(nlh);
	nfmsg->nfgen_family = AF_UNSPEC;
	nfmsg->version = NFNETLINK_V0;
	nfmsg->res_id = 0;

	if (nla_put_string(skb, CTA_TIMEOUT_NAME, timeout->name) ||
	    nla_put_be16(skb, CTA_TIMEOUT_L3PROTO,
			 htons(timeout->timeout.l3num)) ||
	    nla_put_u8(skb, CTA_TIMEOUT_L4PROTO, l4proto->l4proto) ||
	    nla_put_be32(skb, CTA_TIMEOUT_USE,
			 htonl(refcount_read(&timeout->refcnt))))
		goto nla_put_failure;

	nest_parms = nla_nest_start(skb, CTA_TIMEOUT_DATA | NLA_F_NESTED);
	if (!nest_parms)
		goto nla_put_failure;

	ret = l4proto->ctnl_timeout.obj_to_nlattr(skb, &timeout->timeout.data);
	if (ret < 0)
		goto nla_put_failure;

	nla_nest_end(skb, nest_parms);

	nlmsg_end(skb, nlh);
	return skb->len;

nlmsg_failure:
nla_put_failure:
	nlmsg_cancel(skb, nlh);
	return -1;
}

static int
ctnl_timeout_dump(struct sk_buff *skb, struct netlink_callback *cb)
{
	struct net *net = sock_net(skb->sk);
	struct ctnl_timeout *cur, *last;

	if (cb->args[2])
		return 0;

	last = (struct ctnl_timeout *)cb->args[1];
	if (cb->args[1])
		cb->args[1] = 0;

	rcu_read_lock();
	list_for_each_entry_rcu(cur, &net->nfct_timeout_list, head) {
		if (last) {
			if (cur != last)
				continue;

			last = NULL;
		}
		if (ctnl_timeout_fill_info(skb, NETLINK_CB(cb->skb).portid,
					   cb->nlh->nlmsg_seq,
					   NFNL_MSG_TYPE(cb->nlh->nlmsg_type),
					   IPCTNL_MSG_TIMEOUT_NEW, cur) < 0) {
			cb->args[1] = (unsigned long)cur;
			break;
		}
	}
	if (!cb->args[1])
		cb->args[2] = 1;
	rcu_read_unlock();
	return skb->len;
}

static int cttimeout_get_timeout(struct net *net, struct sock *ctnl,
				 struct sk_buff *skb,
				 const struct nlmsghdr *nlh,
				 const struct nlattr * const cda[],
				 struct netlink_ext_ack *extack)
{
	int ret = -ENOENT;
	char *name;
	struct ctnl_timeout *cur;

	if (nlh->nlmsg_flags & NLM_F_DUMP) {
		struct netlink_dump_control c = {
			.dump = ctnl_timeout_dump,
		};
		return netlink_dump_start(ctnl, skb, nlh, &c);
	}

	if (!cda[CTA_TIMEOUT_NAME])
		return -EINVAL;
	name = nla_data(cda[CTA_TIMEOUT_NAME]);

	list_for_each_entry(cur, &net->nfct_timeout_list, head) {
		struct sk_buff *skb2;

		if (strncmp(cur->name, name, CTNL_TIMEOUT_NAME_MAX) != 0)
			continue;

		skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
		if (skb2 == NULL) {
			ret = -ENOMEM;
			break;
		}

		ret = ctnl_timeout_fill_info(skb2, NETLINK_CB(skb).portid,
					     nlh->nlmsg_seq,
					     NFNL_MSG_TYPE(nlh->nlmsg_type),
					     IPCTNL_MSG_TIMEOUT_NEW, cur);
		if (ret <= 0) {
			kfree_skb(skb2);
			break;
		}
		ret = netlink_unicast(ctnl, skb2, NETLINK_CB(skb).portid,
					MSG_DONTWAIT);
		if (ret > 0)
			ret = 0;

		/* this avoids a loop in nfnetlink. */
		return ret == -EAGAIN ? -ENOBUFS : ret;
	}
	return ret;
}

/* try to delete object, fail if it is still in use. */
static int ctnl_timeout_try_del(struct net *net, struct ctnl_timeout *timeout)
{
	int ret = 0;

	/* We want to avoid races with ctnl_timeout_put. So only when the
	 * current refcnt is 1, we decrease it to 0.
	 */
	if (refcount_dec_if_one(&timeout->refcnt)) {
		/* We are protected by nfnl mutex. */
		list_del_rcu(&timeout->head);
		nf_ct_l4proto_put(timeout->timeout.l4proto);
		nf_ct_untimeout(net, &timeout->timeout);
		kfree_rcu(timeout, rcu_head);
	} else {
		ret = -EBUSY;
	}
	return ret;
}

static int cttimeout_del_timeout(struct net *net, struct sock *ctnl,
				 struct sk_buff *skb,
				 const struct nlmsghdr *nlh,
				 const struct nlattr * const cda[],
				 struct netlink_ext_ack *extack)
{
	struct ctnl_timeout *cur, *tmp;
	int ret = -ENOENT;
	char *name;

	if (!cda[CTA_TIMEOUT_NAME]) {
		list_for_each_entry_safe(cur, tmp, &net->nfct_timeout_list,
					 head)
			ctnl_timeout_try_del(net, cur);

		return 0;
	}
	name = nla_data(cda[CTA_TIMEOUT_NAME]);

	list_for_each_entry(cur, &net->nfct_timeout_list, head) {
		if (strncmp(cur->name, name, CTNL_TIMEOUT_NAME_MAX) != 0)
			continue;

		ret = ctnl_timeout_try_del(net, cur);
		if (ret < 0)
			return ret;

		break;
	}
	return ret;
}

static int cttimeout_default_set(struct net *net, struct sock *ctnl,
				 struct sk_buff *skb,
				 const struct nlmsghdr *nlh,
				 const struct nlattr * const cda[],
				 struct netlink_ext_ack *extack)
{
	const struct nf_conntrack_l4proto *l4proto;
	__u8 l4num;
	int ret;

	if (!cda[CTA_TIMEOUT_L3PROTO] ||
	    !cda[CTA_TIMEOUT_L4PROTO] ||
	    !cda[CTA_TIMEOUT_DATA])
		return -EINVAL;

	l4num = nla_get_u8(cda[CTA_TIMEOUT_L4PROTO]);
	l4proto = nf_ct_l4proto_find_get(l4num);

	/* This protocol is not supported, skip. */
	if (l4proto->l4proto != l4num) {
		ret = -EOPNOTSUPP;
		goto err;
	}

	ret = ctnl_timeout_parse_policy(NULL, l4proto, net,
					cda[CTA_TIMEOUT_DATA]);
	if (ret < 0)
		goto err;

	nf_ct_l4proto_put(l4proto);
	return 0;
err:
	nf_ct_l4proto_put(l4proto);
	return ret;
}

static int
cttimeout_default_fill_info(struct net *net, struct sk_buff *skb, u32 portid,
			    u32 seq, u32 type, int event, u16 l3num,
			    const struct nf_conntrack_l4proto *l4proto,
			    const unsigned int *timeouts)
{
	struct nlmsghdr *nlh;
	struct nfgenmsg *nfmsg;
	unsigned int flags = portid ? NLM_F_MULTI : 0;
	struct nlattr *nest_parms;
	int ret;

	event = nfnl_msg_type(NFNL_SUBSYS_CTNETLINK_TIMEOUT, event);
	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*nfmsg), flags);
	if (nlh == NULL)
		goto nlmsg_failure;

	nfmsg = nlmsg_data(nlh);
	nfmsg->nfgen_family = AF_UNSPEC;
	nfmsg->version = NFNETLINK_V0;
	nfmsg->res_id = 0;

	if (nla_put_be16(skb, CTA_TIMEOUT_L3PROTO, htons(l3num)) ||
	    nla_put_u8(skb, CTA_TIMEOUT_L4PROTO, l4proto->l4proto))
		goto nla_put_failure;

	nest_parms = nla_nest_start(skb, CTA_TIMEOUT_DATA | NLA_F_NESTED);
	if (!nest_parms)
		goto nla_put_failure;

	ret = l4proto->ctnl_timeout.obj_to_nlattr(skb, timeouts);
	if (ret < 0)
		goto nla_put_failure;

	nla_nest_end(skb, nest_parms);

	nlmsg_end(skb, nlh);
	return skb->len;

nlmsg_failure:
nla_put_failure:
	nlmsg_cancel(skb, nlh);
	return -1;
}

static int cttimeout_default_get(struct net *net, struct sock *ctnl,
				 struct sk_buff *skb,
				 const struct nlmsghdr *nlh,
				 const struct nlattr * const cda[],
				 struct netlink_ext_ack *extack)
{
	const struct nf_conntrack_l4proto *l4proto;
	unsigned int *timeouts = NULL;
	struct sk_buff *skb2;
	int ret, err;
	__u16 l3num;
	__u8 l4num;

	if (!cda[CTA_TIMEOUT_L3PROTO] || !cda[CTA_TIMEOUT_L4PROTO])
		return -EINVAL;

	l3num = ntohs(nla_get_be16(cda[CTA_TIMEOUT_L3PROTO]));
	l4num = nla_get_u8(cda[CTA_TIMEOUT_L4PROTO]);
	l4proto = nf_ct_l4proto_find_get(l4num);

	err = -EOPNOTSUPP;
	if (l4proto->l4proto != l4num)
		goto err;

	switch (l4proto->l4proto) {
	case IPPROTO_ICMP:
		timeouts = &nf_icmp_pernet(net)->timeout;
		break;
	case IPPROTO_TCP:
		timeouts = nf_tcp_pernet(net)->timeouts;
		break;
	case IPPROTO_UDP: /* fallthrough */
	case IPPROTO_UDPLITE:
		timeouts = nf_udp_pernet(net)->timeouts;
		break;
	case IPPROTO_DCCP:
#ifdef CONFIG_NF_CT_PROTO_DCCP
		timeouts = nf_dccp_pernet(net)->dccp_timeout;
#endif
		break;
	case IPPROTO_ICMPV6:
		timeouts = &nf_icmpv6_pernet(net)->timeout;
		break;
	case IPPROTO_SCTP:
#ifdef CONFIG_NF_CT_PROTO_SCTP
		timeouts = nf_sctp_pernet(net)->timeouts;
#endif
		break;
	case IPPROTO_GRE:
#ifdef CONFIG_NF_CT_PROTO_GRE
		if (l4proto->net_id) {
			struct netns_proto_gre *net_gre;

			net_gre = net_generic(net, *l4proto->net_id);
			timeouts = net_gre->gre_timeouts;
		}
#endif
		break;
	case 255:
		timeouts = &nf_generic_pernet(net)->timeout;
		break;
	default:
		WARN_ONCE(1, "Missing timeouts for proto %d", l4proto->l4proto);
		break;
	}

	if (!timeouts)
		goto err;

	skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
	if (skb2 == NULL) {
		err = -ENOMEM;
		goto err;
	}

	ret = cttimeout_default_fill_info(net, skb2, NETLINK_CB(skb).portid,
					  nlh->nlmsg_seq,
					  NFNL_MSG_TYPE(nlh->nlmsg_type),
					  IPCTNL_MSG_TIMEOUT_DEFAULT_SET,
					  l3num, l4proto, timeouts);
	if (ret <= 0) {
		kfree_skb(skb2);
		err = -ENOMEM;
		goto err;
	}
	ret = netlink_unicast(ctnl, skb2, NETLINK_CB(skb).portid, MSG_DONTWAIT);
	if (ret > 0)
		ret = 0;

	/* this avoids a loop in nfnetlink. */
	return ret == -EAGAIN ? -ENOBUFS : ret;
err:
	nf_ct_l4proto_put(l4proto);
	return err;
}

static struct nf_ct_timeout *ctnl_timeout_find_get(struct net *net,
						   const char *name)
{
	struct ctnl_timeout *timeout, *matching = NULL;

	list_for_each_entry_rcu(timeout, &net->nfct_timeout_list, head) {
		if (strncmp(timeout->name, name, CTNL_TIMEOUT_NAME_MAX) != 0)
			continue;

		if (!try_module_get(THIS_MODULE))
			goto err;

		if (!refcount_inc_not_zero(&timeout->refcnt)) {
			module_put(THIS_MODULE);
			goto err;
		}
		matching = timeout;
		break;
	}
err:
	return matching ? &matching->timeout : NULL;
}

static void ctnl_timeout_put(struct nf_ct_timeout *t)
{
	struct ctnl_timeout *timeout =
		container_of(t, struct ctnl_timeout, timeout);

	if (refcount_dec_and_test(&timeout->refcnt))
		kfree_rcu(timeout, rcu_head);

	module_put(THIS_MODULE);
}

static const struct nfnl_callback cttimeout_cb[IPCTNL_MSG_TIMEOUT_MAX] = {
	[IPCTNL_MSG_TIMEOUT_NEW]	= { .call = cttimeout_new_timeout,
					    .attr_count = CTA_TIMEOUT_MAX,
					    .policy = cttimeout_nla_policy },
	[IPCTNL_MSG_TIMEOUT_GET]	= { .call = cttimeout_get_timeout,
					    .attr_count = CTA_TIMEOUT_MAX,
					    .policy = cttimeout_nla_policy },
	[IPCTNL_MSG_TIMEOUT_DELETE]	= { .call = cttimeout_del_timeout,
					    .attr_count = CTA_TIMEOUT_MAX,
					    .policy = cttimeout_nla_policy },
	[IPCTNL_MSG_TIMEOUT_DEFAULT_SET]= { .call = cttimeout_default_set,
					    .attr_count = CTA_TIMEOUT_MAX,
					    .policy = cttimeout_nla_policy },
	[IPCTNL_MSG_TIMEOUT_DEFAULT_GET]= { .call = cttimeout_default_get,
					    .attr_count = CTA_TIMEOUT_MAX,
					    .policy = cttimeout_nla_policy },
};

static const struct nfnetlink_subsystem cttimeout_subsys = {
	.name				= "conntrack_timeout",
	.subsys_id			= NFNL_SUBSYS_CTNETLINK_TIMEOUT,
	.cb_count			= IPCTNL_MSG_TIMEOUT_MAX,
	.cb				= cttimeout_cb,
};

MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_CTNETLINK_TIMEOUT);

static int __net_init cttimeout_net_init(struct net *net)
{
	INIT_LIST_HEAD(&net->nfct_timeout_list);

	return 0;
}

static void __net_exit cttimeout_net_exit(struct net *net)
{
	struct ctnl_timeout *cur, *tmp;

	nf_ct_unconfirmed_destroy(net);
	nf_ct_untimeout(net, NULL);

	list_for_each_entry_safe(cur, tmp, &net->nfct_timeout_list, head) {
		list_del_rcu(&cur->head);
		nf_ct_l4proto_put(cur->timeout.l4proto);

		if (refcount_dec_and_test(&cur->refcnt))
			kfree_rcu(cur, rcu_head);
	}
}

static struct pernet_operations cttimeout_ops = {
	.init	= cttimeout_net_init,
	.exit	= cttimeout_net_exit,
};

static int __init cttimeout_init(void)
{
	int ret;

	ret = register_pernet_subsys(&cttimeout_ops);
	if (ret < 0)
		return ret;

	ret = nfnetlink_subsys_register(&cttimeout_subsys);
	if (ret < 0) {
		pr_err("cttimeout_init: cannot register cttimeout with "
			"nfnetlink.\n");
		goto err_out;
	}
	RCU_INIT_POINTER(nf_ct_timeout_find_get_hook, ctnl_timeout_find_get);
	RCU_INIT_POINTER(nf_ct_timeout_put_hook, ctnl_timeout_put);
	return 0;

err_out:
	unregister_pernet_subsys(&cttimeout_ops);
	return ret;
}

static void __exit cttimeout_exit(void)
{
	nfnetlink_subsys_unregister(&cttimeout_subsys);

	unregister_pernet_subsys(&cttimeout_ops);
	RCU_INIT_POINTER(nf_ct_timeout_find_get_hook, NULL);
	RCU_INIT_POINTER(nf_ct_timeout_put_hook, NULL);
	synchronize_rcu();
}

module_init(cttimeout_init);
module_exit(cttimeout_exit);
Commit	Line	Data
50978462 PNA	1	/*
	2	* (C) 2012 by Pablo Neira Ayuso <[email protected]>
	3	* (C) 2012 by Vyatta Inc. <http://www.vyatta.com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License version 2 as
	7	* published by the Free Software Foundation (or any later at your option).
	8	*/
	9	#include <linux/init.h>
	10	#include <linux/module.h>
	11	#include <linux/kernel.h>
	12	#include <linux/rculist.h>
	13	#include <linux/rculist_nulls.h>
	14	#include <linux/types.h>
	15	#include <linux/timer.h>
	16	#include <linux/security.h>
	17	#include <linux/skbuff.h>
	18	#include <linux/errno.h>
	19	#include <linux/netlink.h>
	20	#include <linux/spinlock.h>
	21	#include <linux/interrupt.h>
	22	#include <linux/slab.h>
	23
	24	#include <linux/netfilter.h>
	25	#include <net/netlink.h>
	26	#include <net/sock.h>
	27	#include <net/netfilter/nf_conntrack.h>
	28	#include <net/netfilter/nf_conntrack_core.h>
50978462 PNA	29	#include <net/netfilter/nf_conntrack_l4proto.h>
50978462 PNA	30	#include <net/netfilter/nf_conntrack_tuple.h>
24de58f4	31	#include <net/netfilter/nf_conntrack_timeout.h>
50978462 PNA	32
	33	#include <linux/netfilter/nfnetlink.h>
	34	#include <linux/netfilter/nfnetlink_cttimeout.h>
	35
	36	MODULE_LICENSE("GPL");
	37	MODULE_AUTHOR("Pablo Neira Ayuso <[email protected]>");
	38	MODULE_DESCRIPTION("cttimeout: Extended Netfilter Connection Tracking timeout tuning");
	39
50978462	40	static const struct nla_policy cttimeout_nla_policy[CTA_TIMEOUT_MAX+1] = {
e93b5f9f FW	41	[CTA_TIMEOUT_NAME] = { .type = NLA_NUL_STRING,
e93b5f9f FW	42	.len = CTNL_TIMEOUT_NAME_MAX - 1},
50978462 PNA	43	[CTA_TIMEOUT_L3PROTO] = { .type = NLA_U16 },
	44	[CTA_TIMEOUT_L4PROTO] = { .type = NLA_U8 },
	45	[CTA_TIMEOUT_DATA] = { .type = NLA_NESTED },
	46	};
	47
	48	static int
c779e849	49	ctnl_timeout_parse_policy(void *timeout,
2a04aabf	50	const struct nf_conntrack_l4proto *l4proto,
91cb498e	51	struct net net, const struct nlattr attr)
50978462	52	{
8039ab43	53	struct nlattr **tb;
50978462 PNA	54	int ret = 0;
50978462 PNA	55
8039ab43 GS	56	tb = kcalloc(l4proto->ctnl_timeout.nlattr_max + 1, sizeof(*tb),
8039ab43 GS	57	GFP_KERNEL);
50978462	58
8039ab43 GS	59	if (!tb)
	60	return -ENOMEM;
	61
	62	ret = nla_parse_nested(tb, l4proto->ctnl_timeout.nlattr_max, attr,
	63	l4proto->ctnl_timeout.nla_policy, NULL);
	64	if (ret < 0)
	65	goto err;
	66
c779e849	67	ret = l4proto->ctnl_timeout.nlattr_to_obj(tb, net, timeout);
8039ab43 GS	68
	69	err:
	70	kfree(tb);
50978462 PNA	71	return ret;
	72	}
	73
7b8002a1 PNA	74	static int cttimeout_new_timeout(struct net net, struct sock ctnl,
	75	struct sk_buff *skb,
	76	const struct nlmsghdr *nlh,
04ba724b PNA	77	const struct nlattr * const cda[],
04ba724b PNA	78	struct netlink_ext_ack *extack)
50978462 PNA	79	{
	80	__u16 l3num;
	81	__u8 l4num;
b3480fe0	82	const struct nf_conntrack_l4proto *l4proto;
50978462 PNA	83	struct ctnl_timeout timeout, matching = NULL;
	84	char *name;
	85	int ret;
	86
	87	if (!cda[CTA_TIMEOUT_NAME] \|\|
	88	!cda[CTA_TIMEOUT_L3PROTO] \|\|
	89	!cda[CTA_TIMEOUT_L4PROTO] \|\|
	90	!cda[CTA_TIMEOUT_DATA])
	91	return -EINVAL;
	92
	93	name = nla_data(cda[CTA_TIMEOUT_NAME]);
	94	l3num = ntohs(nla_get_be16(cda[CTA_TIMEOUT_L3PROTO]));
	95	l4num = nla_get_u8(cda[CTA_TIMEOUT_L4PROTO]);
	96
19576c94	97	list_for_each_entry(timeout, &net->nfct_timeout_list, head) {
50978462 PNA	98	if (strncmp(timeout->name, name, CTNL_TIMEOUT_NAME_MAX) != 0)
	99	continue;
	100
	101	if (nlh->nlmsg_flags & NLM_F_EXCL)
	102	return -EEXIST;
	103
	104	matching = timeout;
	105	break;
	106	}
	107
50978462 PNA	108	if (matching) {
	109	if (nlh->nlmsg_flags & NLM_F_REPLACE) {
	110	/* You cannot replace one timeout policy by another of
	111	* different kind, sorry.
	112	*/
6c1fd7dc PNA	113	if (matching->timeout.l3num != l3num \|\|
6c1fd7dc PNA	114	matching->timeout.l4proto->l4proto != l4num)
23aaba5a LZ	115	return -EINVAL;
23aaba5a LZ	116
6c1fd7dc PNA	117	return ctnl_timeout_parse_policy(&matching->timeout.data,
	118	matching->timeout.l4proto,
	119	net, cda[CTA_TIMEOUT_DATA]);
50978462	120	}
23aaba5a LZ	121
	122	return -EBUSY;
	123	}
	124
dd2934a9	125	l4proto = nf_ct_l4proto_find_get(l4num);
23aaba5a LZ	126
	127	/* This protocol is not supportted, skip. */
	128	if (l4proto->l4proto != l4num) {
	129	ret = -EOPNOTSUPP;
c1ebd7df	130	goto err_proto_put;
50978462 PNA	131	}
	132
	133	timeout = kzalloc(sizeof(struct ctnl_timeout) +
	134	l4proto->ctnl_timeout.obj_size, GFP_KERNEL);
c1ebd7df PNA	135	if (timeout == NULL) {
	136	ret = -ENOMEM;
	137	goto err_proto_put;
	138	}
50978462	139
6c1fd7dc	140	ret = ctnl_timeout_parse_policy(&timeout->timeout.data, l4proto, net,
50978462 PNA	141	cda[CTA_TIMEOUT_DATA]);
	142	if (ret < 0)
	143	goto err;
	144
	145	strcpy(timeout->name, nla_data(cda[CTA_TIMEOUT_NAME]));
6c1fd7dc PNA	146	timeout->timeout.l3num = l3num;
6c1fd7dc PNA	147	timeout->timeout.l4proto = l4proto;
b54ab92b	148	refcount_set(&timeout->refcnt, 1);
19576c94	149	list_add_tail_rcu(&timeout->head, &net->nfct_timeout_list);
50978462 PNA	150
	151	return 0;
	152	err:
	153	kfree(timeout);
c1ebd7df PNA	154	err_proto_put:
c1ebd7df PNA	155	nf_ct_l4proto_put(l4proto);
50978462 PNA	156	return ret;
	157	}
	158
	159	static int
15e47304	160	ctnl_timeout_fill_info(struct sk_buff *skb, u32 portid, u32 seq, u32 type,
50978462 PNA	161	int event, struct ctnl_timeout *timeout)
	162	{
	163	struct nlmsghdr *nlh;
	164	struct nfgenmsg *nfmsg;
15e47304	165	unsigned int flags = portid ? NLM_F_MULTI : 0;
6c1fd7dc	166	const struct nf_conntrack_l4proto *l4proto = timeout->timeout.l4proto;
4430b897 PNA	167	struct nlattr *nest_parms;
4430b897 PNA	168	int ret;
50978462	169
dedb67c4	170	event = nfnl_msg_type(NFNL_SUBSYS_CTNETLINK_TIMEOUT, event);
15e47304	171	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*nfmsg), flags);
50978462 PNA	172	if (nlh == NULL)
	173	goto nlmsg_failure;
	174
	175	nfmsg = nlmsg_data(nlh);
	176	nfmsg->nfgen_family = AF_UNSPEC;
	177	nfmsg->version = NFNETLINK_V0;
	178	nfmsg->res_id = 0;
	179
48f03bda	180	if (nla_put_string(skb, CTA_TIMEOUT_NAME, timeout->name) \|\|
6c1fd7dc PNA	181	nla_put_be16(skb, CTA_TIMEOUT_L3PROTO,
	182	htons(timeout->timeout.l3num)) \|\|
	183	nla_put_u8(skb, CTA_TIMEOUT_L4PROTO, l4proto->l4proto) \|\|
48f03bda	184	nla_put_be32(skb, CTA_TIMEOUT_USE,
b54ab92b	185	htonl(refcount_read(&timeout->refcnt))))
48f03bda	186	goto nla_put_failure;
50978462	187
4430b897 PNA	188	nest_parms = nla_nest_start(skb, CTA_TIMEOUT_DATA \| NLA_F_NESTED);
	189	if (!nest_parms)
	190	goto nla_put_failure;
50978462	191
4430b897 PNA	192	ret = l4proto->ctnl_timeout.obj_to_nlattr(skb, &timeout->timeout.data);
	193	if (ret < 0)
	194	goto nla_put_failure;
50978462	195
4430b897	196	nla_nest_end(skb, nest_parms);
c1ebd7df	197
50978462 PNA	198	nlmsg_end(skb, nlh);
	199	return skb->len;
	200
	201	nlmsg_failure:
	202	nla_put_failure:
	203	nlmsg_cancel(skb, nlh);
	204	return -1;
	205	}
	206
	207	static int
	208	ctnl_timeout_dump(struct sk_buff skb, struct netlink_callback cb)
	209	{
19576c94	210	struct net *net = sock_net(skb->sk);
50978462 PNA	211	struct ctnl_timeout cur, last;
	212
	213	if (cb->args[2])
	214	return 0;
	215
	216	last = (struct ctnl_timeout *)cb->args[1];
	217	if (cb->args[1])
	218	cb->args[1] = 0;
	219
	220	rcu_read_lock();
19576c94	221	list_for_each_entry_rcu(cur, &net->nfct_timeout_list, head) {
37bc4f8d PNA	222	if (last) {
	223	if (cur != last)
	224	continue;
50978462	225
37bc4f8d PNA	226	last = NULL;
37bc4f8d PNA	227	}
15e47304	228	if (ctnl_timeout_fill_info(skb, NETLINK_CB(cb->skb).portid,
50978462 PNA	229	cb->nlh->nlmsg_seq,
	230	NFNL_MSG_TYPE(cb->nlh->nlmsg_type),
	231	IPCTNL_MSG_TIMEOUT_NEW, cur) < 0) {
	232	cb->args[1] = (unsigned long)cur;
	233	break;
	234	}
	235	}
	236	if (!cb->args[1])
	237	cb->args[2] = 1;
	238	rcu_read_unlock();
	239	return skb->len;
	240	}
	241
7b8002a1 PNA	242	static int cttimeout_get_timeout(struct net net, struct sock ctnl,
	243	struct sk_buff *skb,
	244	const struct nlmsghdr *nlh,
04ba724b PNA	245	const struct nlattr * const cda[],
04ba724b PNA	246	struct netlink_ext_ack *extack)
50978462 PNA	247	{
	248	int ret = -ENOENT;
	249	char *name;
	250	struct ctnl_timeout *cur;
	251
	252	if (nlh->nlmsg_flags & NLM_F_DUMP) {
	253	struct netlink_dump_control c = {
	254	.dump = ctnl_timeout_dump,
	255	};
	256	return netlink_dump_start(ctnl, skb, nlh, &c);
	257	}
	258
	259	if (!cda[CTA_TIMEOUT_NAME])
	260	return -EINVAL;
	261	name = nla_data(cda[CTA_TIMEOUT_NAME]);
	262
19576c94	263	list_for_each_entry(cur, &net->nfct_timeout_list, head) {
50978462 PNA	264	struct sk_buff *skb2;
	265
	266	if (strncmp(cur->name, name, CTNL_TIMEOUT_NAME_MAX) != 0)
	267	continue;
	268
	269	skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
	270	if (skb2 == NULL) {
	271	ret = -ENOMEM;
	272	break;
	273	}
	274
15e47304	275	ret = ctnl_timeout_fill_info(skb2, NETLINK_CB(skb).portid,
50978462 PNA	276	nlh->nlmsg_seq,
	277	NFNL_MSG_TYPE(nlh->nlmsg_type),
	278	IPCTNL_MSG_TIMEOUT_NEW, cur);
	279	if (ret <= 0) {
	280	kfree_skb(skb2);
	281	break;
	282	}
15e47304	283	ret = netlink_unicast(ctnl, skb2, NETLINK_CB(skb).portid,
50978462 PNA	284	MSG_DONTWAIT);
	285	if (ret > 0)
	286	ret = 0;
	287
	288	/* this avoids a loop in nfnetlink. */
	289	return ret == -EAGAIN ? -ENOBUFS : ret;
	290	}
	291	return ret;
	292	}
	293
	294	/* try to delete object, fail if it is still in use. */
19576c94	295	static int ctnl_timeout_try_del(struct net net, struct ctnl_timeout timeout)
50978462 PNA	296	{
	297	int ret = 0;
	298
b75911b6 LZ	299	/* We want to avoid races with ctnl_timeout_put. So only when the
	300	* current refcnt is 1, we decrease it to 0.
	301	*/
b54ab92b	302	if (refcount_dec_if_one(&timeout->refcnt)) {
50978462 PNA	303	/* We are protected by nfnl mutex. */
50978462 PNA	304	list_del_rcu(&timeout->head);
6c1fd7dc PNA	305	nf_ct_l4proto_put(timeout->timeout.l4proto);
6c1fd7dc PNA	306	nf_ct_untimeout(net, &timeout->timeout);
50978462 PNA	307	kfree_rcu(timeout, rcu_head);
50978462 PNA	308	} else {
50978462 PNA	309	ret = -EBUSY;
	310	}
	311	return ret;
	312	}
	313
7b8002a1 PNA	314	static int cttimeout_del_timeout(struct net net, struct sock ctnl,
	315	struct sk_buff *skb,
	316	const struct nlmsghdr *nlh,
04ba724b PNA	317	const struct nlattr * const cda[],
04ba724b PNA	318	struct netlink_ext_ack *extack)
50978462	319	{
93fac10b	320	struct ctnl_timeout cur, tmp;
50978462	321	int ret = -ENOENT;
7b8002a1	322	char *name;
50978462 PNA	323
50978462 PNA	324	if (!cda[CTA_TIMEOUT_NAME]) {
93fac10b LZ	325	list_for_each_entry_safe(cur, tmp, &net->nfct_timeout_list,
93fac10b LZ	326	head)
19576c94	327	ctnl_timeout_try_del(net, cur);
50978462 PNA	328
	329	return 0;
	330	}
	331	name = nla_data(cda[CTA_TIMEOUT_NAME]);
	332
19576c94	333	list_for_each_entry(cur, &net->nfct_timeout_list, head) {
50978462 PNA	334	if (strncmp(cur->name, name, CTNL_TIMEOUT_NAME_MAX) != 0)
	335	continue;
	336
19576c94	337	ret = ctnl_timeout_try_del(net, cur);
50978462 PNA	338	if (ret < 0)
	339	return ret;
	340
	341	break;
	342	}
	343	return ret;
	344	}
	345
7b8002a1 PNA	346	static int cttimeout_default_set(struct net net, struct sock ctnl,
	347	struct sk_buff *skb,
	348	const struct nlmsghdr *nlh,
04ba724b PNA	349	const struct nlattr * const cda[],
04ba724b PNA	350	struct netlink_ext_ack *extack)
91cb498e	351	{
b3480fe0	352	const struct nf_conntrack_l4proto *l4proto;
91cb498e	353	__u8 l4num;
91cb498e PNA	354	int ret;
	355
	356	if (!cda[CTA_TIMEOUT_L3PROTO] \|\|
	357	!cda[CTA_TIMEOUT_L4PROTO] \|\|
	358	!cda[CTA_TIMEOUT_DATA])
	359	return -EINVAL;
	360
91cb498e	361	l4num = nla_get_u8(cda[CTA_TIMEOUT_L4PROTO]);
dd2934a9	362	l4proto = nf_ct_l4proto_find_get(l4num);
91cb498e PNA	363
	364	/* This protocol is not supported, skip. */
	365	if (l4proto->l4proto != l4num) {
	366	ret = -EOPNOTSUPP;
	367	goto err;
	368	}
	369
c779e849	370	ret = ctnl_timeout_parse_policy(NULL, l4proto, net,
91cb498e PNA	371	cda[CTA_TIMEOUT_DATA]);
	372	if (ret < 0)
	373	goto err;
	374
	375	nf_ct_l4proto_put(l4proto);
	376	return 0;
	377	err:
	378	nf_ct_l4proto_put(l4proto);
	379	return ret;
	380	}
	381
	382	static int
	383	cttimeout_default_fill_info(struct net net, struct sk_buff skb, u32 portid,
dd2934a9	384	u32 seq, u32 type, int event, u16 l3num,
8866df92 PNA	385	const struct nf_conntrack_l4proto *l4proto,
8866df92 PNA	386	const unsigned int *timeouts)
91cb498e PNA	387	{
	388	struct nlmsghdr *nlh;
	389	struct nfgenmsg *nfmsg;
	390	unsigned int flags = portid ? NLM_F_MULTI : 0;
4430b897 PNA	391	struct nlattr *nest_parms;
4430b897 PNA	392	int ret;
91cb498e	393
dedb67c4	394	event = nfnl_msg_type(NFNL_SUBSYS_CTNETLINK_TIMEOUT, event);
91cb498e PNA	395	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*nfmsg), flags);
	396	if (nlh == NULL)
	397	goto nlmsg_failure;
	398
	399	nfmsg = nlmsg_data(nlh);
	400	nfmsg->nfgen_family = AF_UNSPEC;
	401	nfmsg->version = NFNETLINK_V0;
	402	nfmsg->res_id = 0;
	403
dd2934a9	404	if (nla_put_be16(skb, CTA_TIMEOUT_L3PROTO, htons(l3num)) \|\|
91cb498e PNA	405	nla_put_u8(skb, CTA_TIMEOUT_L4PROTO, l4proto->l4proto))
	406	goto nla_put_failure;
	407
4430b897 PNA	408	nest_parms = nla_nest_start(skb, CTA_TIMEOUT_DATA \| NLA_F_NESTED);
	409	if (!nest_parms)
	410	goto nla_put_failure;
91cb498e	411
8866df92	412	ret = l4proto->ctnl_timeout.obj_to_nlattr(skb, timeouts);
4430b897 PNA	413	if (ret < 0)
4430b897 PNA	414	goto nla_put_failure;
91cb498e	415
4430b897	416	nla_nest_end(skb, nest_parms);
91cb498e PNA	417
	418	nlmsg_end(skb, nlh);
	419	return skb->len;
	420
	421	nlmsg_failure:
	422	nla_put_failure:
	423	nlmsg_cancel(skb, nlh);
	424	return -1;
	425	}
	426
7b8002a1 PNA	427	static int cttimeout_default_get(struct net net, struct sock ctnl,
7b8002a1 PNA	428	struct sk_buff *skb,
91cb498e	429	const struct nlmsghdr *nlh,
04ba724b PNA	430	const struct nlattr * const cda[],
04ba724b PNA	431	struct netlink_ext_ack *extack)
91cb498e	432	{
b3480fe0	433	const struct nf_conntrack_l4proto *l4proto;
8866df92	434	unsigned int *timeouts = NULL;
91cb498e PNA	435	struct sk_buff *skb2;
91cb498e PNA	436	int ret, err;
b3480fe0 FW	437	__u16 l3num;
b3480fe0 FW	438	__u8 l4num;
91cb498e PNA	439
	440	if (!cda[CTA_TIMEOUT_L3PROTO] \|\| !cda[CTA_TIMEOUT_L4PROTO])
	441	return -EINVAL;
	442
	443	l3num = ntohs(nla_get_be16(cda[CTA_TIMEOUT_L3PROTO]));
	444	l4num = nla_get_u8(cda[CTA_TIMEOUT_L4PROTO]);
dd2934a9	445	l4proto = nf_ct_l4proto_find_get(l4num);
91cb498e	446
8866df92 PNA	447	err = -EOPNOTSUPP;
8866df92 PNA	448	if (l4proto->l4proto != l4num)
91cb498e	449	goto err;
8866df92 PNA	450
	451	switch (l4proto->l4proto) {
	452	case IPPROTO_ICMP:
	453	timeouts = &nf_icmp_pernet(net)->timeout;
	454	break;
	455	case IPPROTO_TCP:
	456	timeouts = nf_tcp_pernet(net)->timeouts;
	457	break;
89259088 FW	458	case IPPROTO_UDP: /* fallthrough */
89259088 FW	459	case IPPROTO_UDPLITE:
8866df92 PNA	460	timeouts = nf_udp_pernet(net)->timeouts;
	461	break;
	462	case IPPROTO_DCCP:
	463	#ifdef CONFIG_NF_CT_PROTO_DCCP
	464	timeouts = nf_dccp_pernet(net)->dccp_timeout;
	465	#endif
	466	break;
	467	case IPPROTO_ICMPV6:
	468	timeouts = &nf_icmpv6_pernet(net)->timeout;
	469	break;
	470	case IPPROTO_SCTP:
	471	#ifdef CONFIG_NF_CT_PROTO_SCTP
	472	timeouts = nf_sctp_pernet(net)->timeouts;
89259088 FW	473	#endif
	474	break;
	475	case IPPROTO_GRE:
	476	#ifdef CONFIG_NF_CT_PROTO_GRE
	477	if (l4proto->net_id) {
	478	struct netns_proto_gre *net_gre;
	479
	480	net_gre = net_generic(net, *l4proto->net_id);
	481	timeouts = net_gre->gre_timeouts;
	482	}
8866df92 PNA	483	#endif
	484	break;
	485	case 255:
	486	timeouts = &nf_generic_pernet(net)->timeout;
	487	break;
	488	default:
89259088	489	WARN_ONCE(1, "Missing timeouts for proto %d", l4proto->l4proto);
8866df92	490	break;
91cb498e PNA	491	}
91cb498e PNA	492
8866df92 PNA	493	if (!timeouts)
	494	goto err;
	495
91cb498e PNA	496	skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
	497	if (skb2 == NULL) {
	498	err = -ENOMEM;
	499	goto err;
	500	}
	501
	502	ret = cttimeout_default_fill_info(net, skb2, NETLINK_CB(skb).portid,
	503	nlh->nlmsg_seq,
	504	NFNL_MSG_TYPE(nlh->nlmsg_type),
	505	IPCTNL_MSG_TIMEOUT_DEFAULT_SET,
8866df92	506	l3num, l4proto, timeouts);
91cb498e PNA	507	if (ret <= 0) {
	508	kfree_skb(skb2);
	509	err = -ENOMEM;
	510	goto err;
	511	}
	512	ret = netlink_unicast(ctnl, skb2, NETLINK_CB(skb).portid, MSG_DONTWAIT);
	513	if (ret > 0)
	514	ret = 0;
	515
	516	/* this avoids a loop in nfnetlink. */
	517	return ret == -EAGAIN ? -ENOBUFS : ret;
	518	err:
	519	nf_ct_l4proto_put(l4proto);
	520	return err;
	521	}
	522
99e25d07 PNA	523	static struct nf_ct_timeout ctnl_timeout_find_get(struct net net,
99e25d07 PNA	524	const char *name)
24de58f4 PNA	525	{
	526	struct ctnl_timeout timeout, matching = NULL;
	527
19576c94	528	list_for_each_entry_rcu(timeout, &net->nfct_timeout_list, head) {
24de58f4 PNA	529	if (strncmp(timeout->name, name, CTNL_TIMEOUT_NAME_MAX) != 0)
	530	continue;
	531
	532	if (!try_module_get(THIS_MODULE))
	533	goto err;
	534
b54ab92b	535	if (!refcount_inc_not_zero(&timeout->refcnt)) {
24de58f4 PNA	536	module_put(THIS_MODULE);
	537	goto err;
	538	}
	539	matching = timeout;
	540	break;
	541	}
	542	err:
99e25d07	543	return matching ? &matching->timeout : NULL;
24de58f4 PNA	544	}
24de58f4 PNA	545
6c1fd7dc	546	static void ctnl_timeout_put(struct nf_ct_timeout *t)
24de58f4	547	{
6c1fd7dc PNA	548	struct ctnl_timeout *timeout =
	549	container_of(t, struct ctnl_timeout, timeout);
	550
b54ab92b	551	if (refcount_dec_and_test(&timeout->refcnt))
b75911b6 LZ	552	kfree_rcu(timeout, rcu_head);
b75911b6 LZ	553
24de58f4 PNA	554	module_put(THIS_MODULE);
24de58f4 PNA	555	}
24de58f4	556
50978462 PNA	557	static const struct nfnl_callback cttimeout_cb[IPCTNL_MSG_TIMEOUT_MAX] = {
	558	[IPCTNL_MSG_TIMEOUT_NEW] = { .call = cttimeout_new_timeout,
	559	.attr_count = CTA_TIMEOUT_MAX,
	560	.policy = cttimeout_nla_policy },
	561	[IPCTNL_MSG_TIMEOUT_GET] = { .call = cttimeout_get_timeout,
	562	.attr_count = CTA_TIMEOUT_MAX,
	563	.policy = cttimeout_nla_policy },
	564	[IPCTNL_MSG_TIMEOUT_DELETE] = { .call = cttimeout_del_timeout,
	565	.attr_count = CTA_TIMEOUT_MAX,
	566	.policy = cttimeout_nla_policy },
91cb498e PNA	567	[IPCTNL_MSG_TIMEOUT_DEFAULT_SET]= { .call = cttimeout_default_set,
	568	.attr_count = CTA_TIMEOUT_MAX,
	569	.policy = cttimeout_nla_policy },
	570	[IPCTNL_MSG_TIMEOUT_DEFAULT_GET]= { .call = cttimeout_default_get,
	571	.attr_count = CTA_TIMEOUT_MAX,
	572	.policy = cttimeout_nla_policy },
50978462 PNA	573	};
	574
	575	static const struct nfnetlink_subsystem cttimeout_subsys = {
	576	.name = "conntrack_timeout",
	577	.subsys_id = NFNL_SUBSYS_CTNETLINK_TIMEOUT,
	578	.cb_count = IPCTNL_MSG_TIMEOUT_MAX,
	579	.cb = cttimeout_cb,
	580	};
	581
	582	MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_CTNETLINK_TIMEOUT);
	583
19576c94 PN	584	static int __net_init cttimeout_net_init(struct net *net)
	585	{
	586	INIT_LIST_HEAD(&net->nfct_timeout_list);
	587
	588	return 0;
	589	}
	590
	591	static void __net_exit cttimeout_net_exit(struct net *net)
	592	{
	593	struct ctnl_timeout cur, tmp;
	594
84657984	595	nf_ct_unconfirmed_destroy(net);
4e665afb	596	nf_ct_untimeout(net, NULL);
19576c94 PN	597
	598	list_for_each_entry_safe(cur, tmp, &net->nfct_timeout_list, head) {
	599	list_del_rcu(&cur->head);
6c1fd7dc	600	nf_ct_l4proto_put(cur->timeout.l4proto);
b75911b6	601
b54ab92b	602	if (refcount_dec_and_test(&cur->refcnt))
b75911b6	603	kfree_rcu(cur, rcu_head);
19576c94 PN	604	}
	605	}
	606
	607	static struct pernet_operations cttimeout_ops = {
	608	.init = cttimeout_net_init,
	609	.exit = cttimeout_net_exit,
	610	};
	611
50978462 PNA	612	static int __init cttimeout_init(void)
	613	{
	614	int ret;
	615
19576c94 PN	616	ret = register_pernet_subsys(&cttimeout_ops);
	617	if (ret < 0)
	618	return ret;
	619
50978462 PNA	620	ret = nfnetlink_subsys_register(&cttimeout_subsys);
	621	if (ret < 0) {
	622	pr_err("cttimeout_init: cannot register cttimeout with "
	623	"nfnetlink.\n");
	624	goto err_out;
	625	}
24de58f4 PNA	626	RCU_INIT_POINTER(nf_ct_timeout_find_get_hook, ctnl_timeout_find_get);
24de58f4 PNA	627	RCU_INIT_POINTER(nf_ct_timeout_put_hook, ctnl_timeout_put);
50978462 PNA	628	return 0;
	629
	630	err_out:
19576c94	631	unregister_pernet_subsys(&cttimeout_ops);
50978462 PNA	632	return ret;
	633	}
	634
	635	static void __exit cttimeout_exit(void)
	636	{
50978462	637	nfnetlink_subsys_unregister(&cttimeout_subsys);
ae2d708e	638
19576c94	639	unregister_pernet_subsys(&cttimeout_ops);
24de58f4 PNA	640	RCU_INIT_POINTER(nf_ct_timeout_find_get_hook, NULL);
24de58f4 PNA	641	RCU_INIT_POINTER(nf_ct_timeout_put_hook, NULL);
3b7dabf0	642	synchronize_rcu();
50978462 PNA	643	}
	644
	645	module_init(cttimeout_init);
	646	module_exit(cttimeout_exit);