Release 4.14 net/netfilter/nf_conntrack_helper.c

Directory: net/netfilter
/* Helper handling for netfilter. */

/* (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>
 * (C) 2006-2012 Patrick McHardy <kaber@trash.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/types.h>
#include <linux/netfilter.h>
#include <linux/module.h>
#include <linux/skbuff.h>
#include <linux/vmalloc.h>
#include <linux/stddef.h>
#include <linux/random.h>
#include <linux/err.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/rculist.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_helper.h>
#include <net/netfilter/nf_conntrack_core.h>
#include <net/netfilter/nf_conntrack_extend.h>
#include <net/netfilter/nf_log.h>

static DEFINE_MUTEX(nf_ct_helper_mutex);

struct hlist_head *nf_ct_helper_hash __read_mostly;

EXPORT_SYMBOL_GPL(nf_ct_helper_hash);

unsigned int nf_ct_helper_hsize __read_mostly;

EXPORT_SYMBOL_GPL(nf_ct_helper_hsize);

static unsigned int nf_ct_helper_count __read_mostly;


static bool nf_ct_auto_assign_helper __read_mostly = false;
module_param_named(nf_conntrack_helper, nf_ct_auto_assign_helper, bool, 0644);
MODULE_PARM_DESC(nf_conntrack_helper,
		 "Enable automatic conntrack helper assignment (default 0)");

#ifdef CONFIG_SYSCTL

static struct ctl_table helper_sysctl_table[] = {
	{
		.procname	= "nf_conntrack_helper",
		.data		= &init_net.ct.sysctl_auto_assign_helper,
		.maxlen		= sizeof(unsigned int),
		.mode		= 0644,
		.proc_handler	= proc_dointvec,
        },
	{}
};



static int nf_conntrack_helper_init_sysctl(struct net *net)
{
	struct ctl_table *table;

	table = kmemdup(helper_sysctl_table, sizeof(helper_sysctl_table),
			GFP_KERNEL);
	if (!table)
		goto out;

	table[0].data = &net->ct.sysctl_auto_assign_helper;

	/* Don't export sysctls to unprivileged users */
	if (net->user_ns != &init_user_ns)
		table[0].procname = NULL;

	net->ct.helper_sysctl_header =
		register_net_sysctl(net, "net/netfilter", table);

	if (!net->ct.helper_sysctl_header) {
		pr_err("nf_conntrack_helper: can't register to sysctl.\n");
		goto out_register;
	}
	return 0;

out_register:
	kfree(table);
out:
	return -ENOMEM;
}

Contributors
Person Tokens Prop Commits CommitProp
Eric Leblond 102 84.30% 1 50.00%
Eric W. Biedermann 19 15.70% 1 50.00%
Total 121 100.00% 2 100.00%



static void nf_conntrack_helper_fini_sysctl(struct net *net)
{
	struct ctl_table *table;

	table = net->ct.helper_sysctl_header->ctl_table_arg;
	unregister_net_sysctl_table(net->ct.helper_sysctl_header);
	kfree(table);
}
Contributors
Person Tokens Prop Commits CommitProp
Eric Leblond 40 100.00% 1 100.00%
Total 40 100.00% 1 100.00%

#else


static int nf_conntrack_helper_init_sysctl(struct net *net)
{
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Eric Leblond 14 100.00% 1 100.00%
Total 14 100.00% 1 100.00%



static void nf_conntrack_helper_fini_sysctl(struct net *net)
{
}
Contributors
Person Tokens Prop Commits CommitProp
Eric Leblond 10 100.00% 1 100.00%
Total 10 100.00% 1 100.00%

#endif /* CONFIG_SYSCTL */

/* Stupid hash, but collision free for the default registrations of the
 * helpers currently in the kernel. */


static unsigned int helper_hash(const struct nf_conntrack_tuple *tuple)
{
	return (((tuple->src.l3num << 8) | tuple->dst.protonum) ^
		(__force __u16)tuple->src.u.all) % nf_ct_helper_hsize;
}

Contributors
Person Tokens Prop Commits CommitProp
Patrick McHardy 42 87.50% 1 33.33%
Al Viro 4 8.33% 1 33.33%
Martin Josefsson 2 4.17% 1 33.33%
Total 48 100.00% 3 100.00%


static struct nf_conntrack_helper *

__nf_ct_helper_find(const struct nf_conntrack_tuple *tuple)
{
	struct nf_conntrack_helper *helper;
	struct nf_conntrack_tuple_mask mask = { .src.u.all = htons(0xFFFF) };
	unsigned int h;

	if (!nf_ct_helper_count)
		return NULL;

	h = helper_hash(tuple);
	hlist_for_each_entry_rcu(helper, &nf_ct_helper_hash[h], hnode) {
		if (nf_ct_tuple_src_mask_cmp(tuple, &helper->tuple, &mask))
			return helper;
	}
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Patrick McHardy 46 52.87% 3 60.00%
Martin Josefsson 40 45.98% 1 20.00%
Pablo Neira Ayuso 1 1.15% 1 20.00%
Total 87 100.00% 5 100.00%


struct nf_conntrack_helper *

__nf_conntrack_helper_find(const char *name, u16 l3num, u8 protonum)
{
	struct nf_conntrack_helper *h;
	unsigned int i;

	for (i = 0; i < nf_ct_helper_hsize; i++) {
		hlist_for_each_entry_rcu(h, &nf_ct_helper_hash[i], hnode) {
			if (strcmp(h->name, name))
				continue;

			if (h->tuple.src.l3num != NFPROTO_UNSPEC &&
			    h->tuple.src.l3num != l3num)
				continue;

			if (h->tuple.dst.protonum == protonum)
				return h;
		}
	}
	return NULL;
}
Contributors
Person Tokens Prop Commits CommitProp
Patrick McHardy 47 44.76% 3 60.00%
Martin Josefsson 40 38.10% 1 20.00%
Florian Westphal 18 17.14% 1 20.00%
Total 105 100.00% 5 100.00%


EXPORT_SYMBOL_GPL(__nf_conntrack_helper_find);


struct nf_conntrack_helper *

nf_conntrack_helper_try_module_get(const char *name, u16 l3num, u8 protonum)
{
	struct nf_conntrack_helper *h;

	rcu_read_lock();

	h = __nf_conntrack_helper_find(name, l3num, protonum);
#ifdef CONFIG_MODULES
	if (h == NULL) {
		rcu_read_unlock();
		if (request_module("nfct-helper-%s", name) == 0) {
			rcu_read_lock();
			h = __nf_conntrack_helper_find(name, l3num, protonum);
		} else {
			return h;
		}
	}
#endif
	if (h != NULL && !try_module_get(h->me))
		h = NULL;
	if (h != NULL && !refcount_inc_not_zero(&h->refcnt)) {
		module_put(h->me);
		h = NULL;
	}

	rcu_read_unlock();

	return h;
}
Contributors
Person Tokens Prop Commits CommitProp
Patrick McHardy 90 65.22% 1 33.33%
Liping Zhang 28 20.29% 1 33.33%
Gao Feng 20 14.49% 1 33.33%
Total 138 100.00% 3 100.00%


EXPORT_SYMBOL_GPL(nf_conntrack_helper_try_module_get);



void nf_conntrack_helper_put(struct nf_conntrack_helper *helper)
{
	refcount_dec(&helper->refcnt);
	module_put(helper->me);
}
Contributors
Person Tokens Prop Commits CommitProp
Liping Zhang 25 100.00% 2 100.00%
Total 25 100.00% 2 100.00%


EXPORT_SYMBOL_GPL(nf_conntrack_helper_put);


struct nf_conn_help *

nf_ct_helper_ext_add(struct nf_conn *ct,
		     struct nf_conntrack_helper *helper, gfp_t gfp)
{
	struct nf_conn_help *help;

	help = nf_ct_ext_add(ct, NF_CT_EXT_HELPER, gfp);
	if (help)
		INIT_HLIST_HEAD(&help->expectations);
	else
		pr_debug("failed to add helper extension area");
	return help;
}
Contributors
Person Tokens Prop Commits CommitProp
Patrick McHardy 51 89.47% 1 33.33%
Pablo Neira Ayuso 5 8.77% 1 33.33%
Florian Westphal 1 1.75% 1 33.33%
Total 57 100.00% 3 100.00%


EXPORT_SYMBOL_GPL(nf_ct_helper_ext_add);


static struct nf_conntrack_helper *

nf_ct_lookup_helper(struct nf_conn *ct, struct net *net)
{
	if (!net->ct.sysctl_auto_assign_helper) {
		if (net->ct.auto_assign_helper_warned)
			return NULL;
		if (!__nf_ct_helper_find(&ct->tuplehash[IP_CT_DIR_REPLY].tuple))
			return NULL;
		pr_info("nf_conntrack: default automatic helper assignment "
			"has been turned off for security reasons and CT-based "
			" firewall rule not found. Use the iptables CT target "
			"to attach helpers instead.\n");
		net->ct.auto_assign_helper_warned = 1;
		return NULL;
	}

	return __nf_ct_helper_find(&ct->tuplehash[IP_CT_DIR_REPLY].tuple);
}


Contributors
Person Tokens Prop Commits CommitProp
Jiri Kosina 92 100.00% 1 100.00%
Total 92 100.00% 1 100.00%



int __nf_ct_try_assign_helper(struct nf_conn *ct, struct nf_conn *tmpl,
			      gfp_t flags)
{
	struct nf_conntrack_helper *helper = NULL;
	struct nf_conn_help *help;
	struct net *net = nf_ct_net(ct);

	/* We already got a helper explicitly attached. The function
         * nf_conntrack_alter_reply - in case NAT is in use - asks for looking
         * the helper up again. Since now the user is in full control of
         * making consistent helper configurations, skip this automatic
         * re-lookup, otherwise we'll lose the helper.
         */
	if (test_bit(IPS_HELPER_BIT, &ct->status))
		return 0;

	if (tmpl != NULL) {
		help = nfct_help(tmpl);
		if (help != NULL) {
			helper = help->helper;
			set_bit(IPS_HELPER_BIT, &ct->status);
		}
	}

	help = nfct_help(ct);

	if (helper == NULL) {
		helper = nf_ct_lookup_helper(ct, net);
		if (helper == NULL) {
			if (help)
				RCU_INIT_POINTER(help->helper, NULL);
			return 0;
		}
	}

	if (help == NULL) {
		help = nf_ct_helper_ext_add(ct, helper, flags);
		if (help == NULL)
			return -ENOMEM;
	} else {
		/* We only allow helper re-assignment of the same sort since
                 * we cannot reallocate the helper extension area.
                 */
		struct nf_conntrack_helper *tmp = rcu_dereference(help->helper);

		if (tmp && tmp->help != helper->help) {
			RCU_INIT_POINTER(help->helper, NULL);
			return 0;
		}
	}

	rcu_assign_pointer(help->helper, helper);

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Pablo Neira Ayuso 143 63.27% 5 45.45%
Patrick McHardy 44 19.47% 1 9.09%
Florian Westphal 18 7.96% 1 9.09%
Eric Leblond 16 7.08% 1 9.09%
Jiri Kosina 3 1.33% 1 9.09%
Stephen Hemminger 1 0.44% 1 9.09%
Eric Dumazet 1 0.44% 1 9.09%
Total 226 100.00% 11 100.00%


EXPORT_SYMBOL_GPL(__nf_ct_try_assign_helper);

/* appropriate ct lock protecting must be taken by caller */


static int unhelp(struct nf_conn *ct, void *me)
{
	struct nf_conn_help *help = nfct_help(ct);

	if (help && rcu_dereference_raw(help->helper) == me) {
		nf_conntrack_event(IPCT_HELPER, ct);
		RCU_INIT_POINTER(help->helper, NULL);
	}

	/* We are not intended to delete this conntrack. */
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Martin Josefsson 49 81.67% 1 16.67%
Liping Zhang 4 6.67% 1 16.67%
Patrick McHardy 3 5.00% 1 16.67%
Eric Dumazet 2 3.33% 1 16.67%
Stephen Hemminger 1 1.67% 1 16.67%
Jesper Dangaard Brouer 1 1.67% 1 16.67%
Total 60 100.00% 6 100.00%



void nf_ct_helper_destroy(struct nf_conn *ct)
{
	struct nf_conn_help *help = nfct_help(ct);
	struct nf_conntrack_helper *helper;

	if (help) {
		rcu_read_lock();
		helper = rcu_dereference(help->helper);
		if (helper && helper->destroy)
			helper->destroy(ct);
		rcu_read_unlock();
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Pablo Neira Ayuso 61 100.00% 1 100.00%
Total 61 100.00% 1 100.00%

static LIST_HEAD(nf_ct_helper_expectfn_list);



void nf_ct_helper_expectfn_register(struct nf_ct_helper_expectfn *n)
{
	spin_lock_bh(&nf_conntrack_expect_lock);
	list_add_rcu(&n->head, &nf_ct_helper_expectfn_list);
	spin_unlock_bh(&nf_conntrack_expect_lock);
}
Contributors
Person Tokens Prop Commits CommitProp
Pablo Neira Ayuso 31 93.94% 1 50.00%
Jesper Dangaard Brouer 2 6.06% 1 50.00%
Total 33 100.00% 2 100.00%


EXPORT_SYMBOL_GPL(nf_ct_helper_expectfn_register);



void nf_ct_helper_expectfn_unregister(struct nf_ct_helper_expectfn *n)
{
	spin_lock_bh(&nf_conntrack_expect_lock);
	list_del_rcu(&n->head);
	spin_unlock_bh(&nf_conntrack_expect_lock);
}
Contributors
Person Tokens Prop Commits CommitProp
Pablo Neira Ayuso 28 93.33% 1 50.00%
Jesper Dangaard Brouer 2 6.67% 1 50.00%
Total 30 100.00% 2 100.00%


EXPORT_SYMBOL_GPL(nf_ct_helper_expectfn_unregister);

/* Caller should hold the rcu lock */

struct nf_ct_helper_expectfn *

nf_ct_helper_expectfn_find_by_name(const char *name)
{
	struct nf_ct_helper_expectfn *cur;
	bool found = false;

	list_for_each_entry_rcu(cur, &nf_ct_helper_expectfn_list, head) {
		if (!strcmp(cur->name, name)) {
			found = true;
			break;
		}
	}
	return found ? cur : NULL;
}
Contributors
Person Tokens Prop Commits CommitProp
Pablo Neira Ayuso 58 100.00% 1 100.00%
Total 58 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(nf_ct_helper_expectfn_find_by_name);

/* Caller should hold the rcu lock */

struct nf_ct_helper_expectfn *

nf_ct_helper_expectfn_find_by_symbol(const void *symbol)
{
	struct nf_ct_helper_expectfn *cur;
	bool found = false;

	list_for_each_entry_rcu(cur, &nf_ct_helper_expectfn_list, head) {
		if (cur->expectfn == symbol) {
			found = true;
			break;
		}
	}
	return found ? cur : NULL;
}
Contributors
Person Tokens Prop Commits CommitProp
Pablo Neira Ayuso 54 100.00% 1 100.00%
Total 54 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(nf_ct_helper_expectfn_find_by_symbol);

__printf(3, 4)


void nf_ct_helper_log(struct sk_buff *skb, const struct nf_conn *ct,
		      const char *fmt, ...)
{
	const struct nf_conn_help *help;
	const struct nf_conntrack_helper *helper;
	struct va_format vaf;
	va_list args;

	va_start(args, fmt);

	vaf.fmt = fmt;
	vaf.va = &args;

	/* Called from the helper function, this call never fails */
	help = nfct_help(ct);

	/* rcu_read_lock()ed by nf_hook_thresh */
	helper = rcu_dereference(help->helper);

	nf_log_packet(nf_ct_net(ct), nf_ct_l3num(ct), 0, skb, NULL, NULL, NULL,
		      "nf_ct_%s: dropping packet: %pV ", helper->name, &vaf);

	va_end(args);
}
Contributors
Person Tokens Prop Commits CommitProp
Pablo Neira Ayuso 76 64.96% 1 25.00%
Joe Perches 35 29.91% 1 25.00%
Gao Feng 5 4.27% 1 25.00%
Aaron Conole 1 0.85% 1 25.00%
Total 117 100.00% 4 100.00%


EXPORT_SYMBOL_GPL(nf_ct_helper_log);



int nf_conntrack_helper_register(struct nf_conntrack_helper *me)
{
	struct nf_conntrack_tuple_mask mask = { .src.u.all = htons(0xFFFF) };
	unsigned int h = helper_hash(&me->tuple);
	struct nf_conntrack_helper *cur;
	int ret = 0, i;

	BUG_ON(me->expect_policy == NULL);
	BUG_ON(me->expect_class_max >= NF_CT_MAX_EXPECT_CLASSES);
	BUG_ON(strlen(me->name) > NF_CT_HELPER_NAME_LEN - 1);

	if (me->expect_policy->max_expected > NF_CT_EXPECT_MAX_CNT)
		return -EINVAL;

	mutex_lock(&nf_ct_helper_mutex);
	for (i = 0; i < nf_ct_helper_hsize; i++) {
		hlist_for_each_entry(cur, &nf_ct_helper_hash[i], hnode) {
			if (!strcmp(cur->name, me->name) &&
			    (cur->tuple.src.l3num == NFPROTO_UNSPEC ||
			     cur->tuple.src.l3num == me->tuple.src.l3num) &&
			    cur->tuple.dst.protonum == me->tuple.dst.protonum) {
				ret = -EEXIST;
				goto out;
			}
		}
	}

	/* avoid unpredictable behaviour for auto_assign_helper */
	if (!(me->flags & NF_CT_HELPER_F_USERSPACE)) {
		hlist_for_each_entry(cur, &nf_ct_helper_hash[h], hnode) {
			if (nf_ct_tuple_src_mask_cmp(&cur->tuple, &me->tuple,
						     &mask)) {
				ret = -EEXIST;
				goto out;
			}
		}
	}
	refcount_set(&me->refcnt, 1);
	hlist_add_head_rcu(&me->hnode, &nf_ct_helper_hash[h]);
	nf_ct_helper_count++;
out:
	mutex_unlock(&nf_ct_helper_mutex);
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
Liping Zhang 119 41.46% 2 20.00%
Pablo Neira Ayuso 69 24.04% 2 20.00%
Patrick McHardy 36 12.54% 3 30.00%
Martin Josefsson 35 12.20% 1 10.00%
Holger Eitzenberger 14 4.88% 1 10.00%
Gao Feng 14 4.88% 1 10.00%
Total 287 100.00% 10 100.00%


EXPORT_SYMBOL_GPL(nf_conntrack_helper_register);



static bool expect_iter_me(struct nf_conntrack_expect *exp, void *data)
{
	struct nf_conn_help *help = nfct_help(exp->master);
	const struct nf_conntrack_helper *me = data;
	const struct nf_conntrack_helper *this;

	if (exp->helper == me)
		return true;

	this = rcu_dereference_protected(help->helper,
					 lockdep_is_held(&nf_conntrack_expect_lock));
	return this == me;
}

Contributors
Person Tokens Prop Commits CommitProp
Florian Westphal 64 88.89% 2 33.33%
Patrick McHardy 4 5.56% 2 33.33%
Martin Josefsson 3 4.17% 1 16.67%
Jan Engelhardt 1 1.39% 1 16.67%
Total 72 100.00% 6 100.00%



void nf_conntrack_helper_unregister(struct nf_conntrack_helper *me)
{
	mutex_lock(&nf_ct_helper_mutex);
	hlist_del_rcu(&me->hnode);
	nf_ct_helper_count--;
	mutex_unlock(&nf_ct_helper_mutex);

	/* Make sure every nothing is still using the helper unless its a
         * connection in the hash.
         */
	synchronize_rcu();

	nf_ct_expect_iterate_destroy(expect_iter_me, NULL);
	nf_ct_iterate_destroy(unhelp, me);
}
Contributors
Person Tokens Prop Commits CommitProp
Florian Westphal 39 76.47% 2 28.57%
Martin Josefsson 6 11.76% 1 14.29%
Jesper Dangaard Brouer 3 5.88% 2 28.57%
Eric Dumazet 2 3.92% 1 14.29%
Liping Zhang 1 1.96% 1 14.29%
Total 51 100.00% 7 100.00%


EXPORT_SYMBOL_GPL(nf_conntrack_helper_unregister);



void nf_ct_helper_init(struct nf_conntrack_helper *helper,
		       u16 l3num, u16 protonum, const char *name,
		       u16 default_port, u16 spec_port, u32 id,
		       const struct nf_conntrack_expect_policy *exp_pol,
		       u32 expect_class_max,
		       int (*help)(struct sk_buff *skb, unsigned int protoff,
				   struct nf_conn *ct,
				   enum ip_conntrack_info ctinfo),
		       int (*from_nlattr)(struct nlattr *attr,
					  struct nf_conn *ct),
		       struct module *module)
{
	helper->tuple.src.l3num = l3num;
	helper->tuple.dst.protonum = protonum;
	helper->tuple.src.u.all = htons(spec_port);
	helper->expect_policy = exp_pol;
	helper->expect_class_max = expect_class_max;
	helper->help = help;
	helper->from_nlattr = from_nlattr;
	helper->me = module;

	if (spec_port == default_port)
		snprintf(helper->name, sizeof(helper->name), "%s", name);
	else
		snprintf(helper->name, sizeof(helper->name), "%s-%u", name, id);
}
Contributors
Person Tokens Prop Commits CommitProp
Gao Feng 196 100.00% 1 100.00%
Total 196 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(nf_ct_helper_init);



int nf_conntrack_helpers_register(struct nf_conntrack_helper *helper,
				  unsigned int n)
{
	unsigned int i;
	int err = 0;

	for (i = 0; i < n; i++) {
		err = nf_conntrack_helper_register(&helper[i]);
		if (err < 0)
			goto err;
	}

	return err;
err:
	if (i > 0)
		nf_conntrack_helpers_unregister(helper, i);
	return err;
}
Contributors
Person Tokens Prop Commits CommitProp
Gao Feng 79 100.00% 1 100.00%
Total 79 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(nf_conntrack_helpers_register);



void nf_conntrack_helpers_unregister(struct nf_conntrack_helper *helper,
				unsigned int n)
{
	while (n-- > 0)
		nf_conntrack_helper_unregister(&helper[n]);
}
Contributors
Person Tokens Prop Commits CommitProp
Gao Feng 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(nf_conntrack_helpers_unregister);


static const struct nf_ct_ext_type helper_extend = {
	.len	= sizeof(struct nf_conn_help),
	.align	= __alignof__(struct nf_conn_help),
	.id	= NF_CT_EXT_HELPER,
};



int nf_conntrack_helper_pernet_init(struct net *net)
{
	net->ct.auto_assign_helper_warned = false;
	net->ct.sysctl_auto_assign_helper = nf_ct_auto_assign_helper;
	return nf_conntrack_helper_init_sysctl(net);
}

Contributors
Person Tokens Prop Commits CommitProp
Eric Leblond 23 71.88% 1 25.00%
Gao Feng 5 15.62% 1 25.00%
Al Viro 2 6.25% 1 25.00%
Yasuyuki Kozakai 2 6.25% 1 25.00%
Total 32 100.00% 4 100.00%



void nf_conntrack_helper_pernet_fini(struct net *net)
{
	nf_conntrack_helper_fini_sysctl(net);
}

Contributors
Person Tokens Prop Commits CommitProp
Gao Feng 14 93.33% 1 50.00%
Eric Leblond 1 6.67% 1 50.00%
Total 15 100.00% 2 100.00%



int nf_conntrack_helper_init(void)
{
	int ret;
	nf_ct_helper_hsize = 1; /* gets rounded up to use one page */
	nf_ct_helper_hash =
		nf_ct_alloc_hashtable(&nf_ct_helper_hsize, 0);
	if (!nf_ct_helper_hash)
		return -ENOMEM;

	ret = nf_ct_extend_register(&helper_extend);
	if (ret < 0) {
		pr_err("nf_ct_helper: Unable to register helper extension.\n");
		goto out_extend;
	}

	return 0;
out_extend:
	nf_ct_free_hashtable(nf_ct_helper_hash, nf_ct_helper_hsize);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Patrick McHardy 41 56.16% 1 20.00%
Gao Feng 18 24.66% 1 20.00%
Yasuyuki Kozakai 8 10.96% 1 20.00%
Eric Leblond 5 6.85% 1 20.00%
Eric Dumazet 1 1.37% 1 20.00%
Total 73 100.00% 5 100.00%



void nf_conntrack_helper_fini(void)
{
	nf_ct_extend_unregister(&helper_extend);
	nf_ct_free_hashtable(nf_ct_helper_hash, nf_ct_helper_hsize);
}
Contributors
Person Tokens Prop Commits CommitProp
Yasuyuki Kozakai 10 50.00% 1 25.00%
Patrick McHardy 7 35.00% 1 25.00%
Al Viro 2 10.00% 1 25.00%
Gao Feng 1 5.00% 1 25.00%
Total 20 100.00% 4 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
Pablo Neira Ayuso 583 23.10% 11 17.74%
Patrick McHardy 461 18.26% 14 22.58%
Gao Feng 399 15.81% 5 8.06%
Eric Leblond 288 11.41% 1 1.61%
Martin Josefsson 222 8.80% 3 4.84%
Liping Zhang 182 7.21% 4 6.45%
Florian Westphal 141 5.59% 6 9.68%
Jiri Kosina 95 3.76% 1 1.61%
Yasuyuki Kozakai 52 2.06% 1 1.61%
Joe Perches 35 1.39% 1 1.61%
Eric W. Biedermann 19 0.75% 1 1.61%
Holger Eitzenberger 14 0.55% 1 1.61%
Al Viro 8 0.32% 2 3.23%
Jesper Dangaard Brouer 8 0.32% 2 3.23%
Eric Dumazet 6 0.24% 3 4.84%
Ingo Molnar 3 0.12% 1 1.61%
Stephen Hemminger 3 0.12% 2 3.23%
Alexey Dobriyan 3 0.12% 1 1.61%
Aaron Conole 1 0.04% 1 1.61%
Jan Engelhardt 1 0.04% 1 1.61%
Total 2524 100.00% 62 100.00%
Directory: net/netfilter

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Eric Leblond	102	84.30%	1	50.00%
Eric W. Biedermann	19	15.70%	1	50.00%
Total	121	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.14 net/netfilter/nf_conntrack_helper.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
