Release 4.15 net/xfrm/xfrm_user.c

Directory: net/xfrm
/* xfrm_user.c: User interface to configure xfrm engine.
 *
 * Copyright (C) 2002 David S. Miller (davem@redhat.com)
 *
 * Changes:
 *      Mitsuru KANDA @USAGI
 *      Kazunori MIYAZAWA @USAGI
 *      Kunihiro Ishiguro <kunihiro@ipinfusion.com>
 *              IPv6 support
 *
 */

#include <linux/crypto.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/socket.h>
#include <linux/string.h>
#include <linux/net.h>
#include <linux/skbuff.h>
#include <linux/pfkeyv2.h>
#include <linux/ipsec.h>
#include <linux/init.h>
#include <linux/security.h>
#include <net/sock.h>
#include <net/xfrm.h>
#include <net/netlink.h>
#include <net/ah.h>
#include <linux/uaccess.h>
#if IS_ENABLED(CONFIG_IPV6)
#include <linux/in6.h>
#endif
#include <asm/unaligned.h>



static int verify_one_alg(struct nlattr **attrs, enum xfrm_attr_type_t type)
{
	struct nlattr *rt = attrs[type];
	struct xfrm_algo *algp;

	if (!rt)
		return 0;

	algp = nla_data(rt);
	if (nla_len(rt) < (int)xfrm_alg_len(algp))
		return -EINVAL;

	switch (type) {
	case XFRMA_ALG_AUTH:
	case XFRMA_ALG_CRYPT:
	case XFRMA_ALG_COMP:
		break;

	default:
		return -EINVAL;
	}

	algp->alg_name[sizeof(algp->alg_name) - 1] = '\0';
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 75 71.43% 1 12.50%
Herbert Xu 16 15.24% 2 25.00%
Thomas Graf 10 9.52% 3 37.50%
Alexey Dobriyan 3 2.86% 1 12.50%
Eric Dumazet 1 0.95% 1 12.50%
Total 105 100.00% 8 100.00%



static int verify_auth_trunc(struct nlattr **attrs)
{
	struct nlattr *rt = attrs[XFRMA_ALG_AUTH_TRUNC];
	struct xfrm_algo_auth *algp;

	if (!rt)
		return 0;

	algp = nla_data(rt);
	if (nla_len(rt) < (int)xfrm_alg_auth_len(algp))
		return -EINVAL;

	algp->alg_name[sizeof(algp->alg_name) - 1] = '\0';
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Martin Willi 71 88.75% 1 33.33%
Herbert Xu 6 7.50% 1 33.33%
Alexey Dobriyan 3 3.75% 1 33.33%
Total 80 100.00% 3 100.00%



static int verify_aead(struct nlattr **attrs)
{
	struct nlattr *rt = attrs[XFRMA_ALG_AEAD];
	struct xfrm_algo_aead *algp;

	if (!rt)
		return 0;

	algp = nla_data(rt);
	if (nla_len(rt) < (int)aead_len(algp))
		return -EINVAL;

	algp->alg_name[sizeof(algp->alg_name) - 1] = '\0';
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 77 96.25% 2 66.67%
Alexey Dobriyan 3 3.75% 1 33.33%
Total 80 100.00% 3 100.00%



static void verify_one_addr(struct nlattr **attrs, enum xfrm_attr_type_t type,
			   xfrm_address_t **addrp)
{
	struct nlattr *rt = attrs[type];

	if (rt && addrp)
		*addrp = nla_data(rt);
}

Contributors
Person Tokens Prop Commits CommitProp
Masahide Nakamura 38 84.44% 1 25.00%
Thomas Graf 7 15.56% 3 75.00%
Total 45 100.00% 4 100.00%



static inline int verify_sec_ctx_len(struct nlattr **attrs)
{
	struct nlattr *rt = attrs[XFRMA_SEC_CTX];
	struct xfrm_user_sec_ctx *uctx;

	if (!rt)
		return 0;

	uctx = nla_data(rt);
	if (uctx->len != (sizeof(struct xfrm_user_sec_ctx) + uctx->ctx_len))
		return -EINVAL;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Trent Jaeger 55 80.88% 1 25.00%
Thomas Graf 13 19.12% 3 75.00%
Total 68 100.00% 4 100.00%



static inline int verify_replay(struct xfrm_usersa_info *p,
				struct nlattr **attrs)
{
	struct nlattr *rt = attrs[XFRMA_REPLAY_ESN_VAL];
	struct xfrm_replay_state_esn *rs;

	if (p->flags & XFRM_STATE_ESN) {
		if (!rt)
			return -EINVAL;

		rs = nla_data(rt);

		if (rs->bmp_len > XFRMA_REPLAY_ESN_MAX / sizeof(rs->bmp[0]) / 8)
			return -EINVAL;

		if (nla_len(rt) < (int)xfrm_replay_state_esn_len(rs) &&
		    nla_len(rt) != sizeof(*rs))
			return -EINVAL;
	}

	if (!rt)
		return 0;

	/* As only ESP and AH support ESN feature. */
	if ((p->id.proto != IPPROTO_ESP) && (p->id.proto != IPPROTO_AH))
		return -EINVAL;

	if (p->replay_window != 0)
		return -EINVAL;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Steffen Klassert 79 48.47% 3 50.00%
Mathias Krause 68 41.72% 1 16.67%
Fan Du 13 7.98% 1 16.67%
Alexey Dobriyan 3 1.84% 1 16.67%
Total 163 100.00% 6 100.00%



static int verify_newsa_info(struct xfrm_usersa_info *p,
			     struct nlattr **attrs)
{
	int err;

	err = -EINVAL;
	switch (p->family) {
	case AF_INET:
		break;

	case AF_INET6:
#if IS_ENABLED(CONFIG_IPV6)
		break;
#else
		err = -EAFNOSUPPORT;
		goto out;
#endif

	default:
		goto out;
	}

	err = -EINVAL;
	switch (p->id.proto) {
	case IPPROTO_AH:
		if ((!attrs[XFRMA_ALG_AUTH]	&&
		     !attrs[XFRMA_ALG_AUTH_TRUNC]) ||
		    attrs[XFRMA_ALG_AEAD]	||
		    attrs[XFRMA_ALG_CRYPT]	||
		    attrs[XFRMA_ALG_COMP]	||
		    attrs[XFRMA_TFCPAD])
			goto out;
		break;

	case IPPROTO_ESP:
		if (attrs[XFRMA_ALG_COMP])
			goto out;
		if (!attrs[XFRMA_ALG_AUTH] &&
		    !attrs[XFRMA_ALG_AUTH_TRUNC] &&
		    !attrs[XFRMA_ALG_CRYPT] &&
		    !attrs[XFRMA_ALG_AEAD])
			goto out;
		if ((attrs[XFRMA_ALG_AUTH] ||
		     attrs[XFRMA_ALG_AUTH_TRUNC] ||
		     attrs[XFRMA_ALG_CRYPT]) &&
		    attrs[XFRMA_ALG_AEAD])
			goto out;
		if (attrs[XFRMA_TFCPAD] &&
		    p->mode != XFRM_MODE_TUNNEL)
			goto out;
		break;

	case IPPROTO_COMP:
		if (!attrs[XFRMA_ALG_COMP]	||
		    attrs[XFRMA_ALG_AEAD]	||
		    attrs[XFRMA_ALG_AUTH]	||
		    attrs[XFRMA_ALG_AUTH_TRUNC]	||
		    attrs[XFRMA_ALG_CRYPT]	||
		    attrs[XFRMA_TFCPAD]		||
		    (ntohl(p->id.spi) >= 0x10000))
			goto out;
		break;

#if IS_ENABLED(CONFIG_IPV6)
	case IPPROTO_DSTOPTS:
	case IPPROTO_ROUTING:
		if (attrs[XFRMA_ALG_COMP]	||
		    attrs[XFRMA_ALG_AUTH]	||
		    attrs[XFRMA_ALG_AUTH_TRUNC]	||
		    attrs[XFRMA_ALG_AEAD]	||
		    attrs[XFRMA_ALG_CRYPT]	||
		    attrs[XFRMA_ENCAP]		||
		    attrs[XFRMA_SEC_CTX]	||
		    attrs[XFRMA_TFCPAD]		||
		    !attrs[XFRMA_COADDR])
			goto out;
		break;
#endif

	default:
		goto out;
	}

	if ((err = verify_aead(attrs)))
		goto out;
	if ((err = verify_auth_trunc(attrs)))
		goto out;
	if ((err = verify_one_alg(attrs, XFRMA_ALG_AUTH)))
		goto out;
	if ((err = verify_one_alg(attrs, XFRMA_ALG_CRYPT)))
		goto out;
	if ((err = verify_one_alg(attrs, XFRMA_ALG_COMP)))
		goto out;
	if ((err = verify_sec_ctx_len(attrs)))
		goto out;
	if ((err = verify_replay(p, attrs)))
		goto out;

	err = -EINVAL;
	switch (p->mode) {
	case XFRM_MODE_TRANSPORT:
	case XFRM_MODE_TUNNEL:
	case XFRM_MODE_ROUTEOPTIMIZATION:
	case XFRM_MODE_BEET:
		break;

	default:
		goto out;
	}

	err = 0;

out:
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 210 44.21% 2 12.50%
Martin Willi 77 16.21% 2 12.50%
Herbert Xu 63 13.26% 1 6.25%
Masahide Nakamura 46 9.68% 2 12.50%
Thomas Graf 21 4.42% 2 12.50%
Steffen Klassert 16 3.37% 1 6.25%
Tobias Brunner 13 2.74% 1 6.25%
Kunihiro Ishiguro 13 2.74% 1 6.25%
Trent Jaeger 8 1.68% 1 6.25%
Diego Beltrami 3 0.63% 1 6.25%
Noriaki Takamiya 3 0.63% 1 6.25%
Eric Dumazet 2 0.42% 1 6.25%
Total 475 100.00% 16 100.00%


static int attach_one_algo(struct xfrm_algo **algpp, u8 *props,
			   struct xfrm_algo_desc *(*get_byname)(const char *, int),
			   struct nlattr *rta)
{
	struct xfrm_algo *p, *ualg;
	struct xfrm_algo_desc *algo;

	if (!rta)
		return 0;

	ualg = nla_data(rta);

	algo = get_byname(ualg->alg_name, 1);
	if (!algo)
		return -ENOSYS;
	*props = algo->desc.sadb_alg_id;

	p = kmemdup(ualg, xfrm_alg_len(ualg), GFP_KERNEL);
	if (!p)
		return -ENOMEM;

	strcpy(p->alg_name, algo->name);
	*algpp = p;
	return 0;
}



static int attach_crypt(struct xfrm_state *x, struct nlattr *rta)
{
	struct xfrm_algo *p, *ualg;
	struct xfrm_algo_desc *algo;

	if (!rta)
		return 0;

	ualg = nla_data(rta);

	algo = xfrm_ealg_get_byname(ualg->alg_name, 1);
	if (!algo)
		return -ENOSYS;
	x->props.ealgo = algo->desc.sadb_alg_id;

	p = kmemdup(ualg, xfrm_alg_len(ualg), GFP_KERNEL);
	if (!p)
		return -ENOMEM;

	strcpy(p->alg_name, algo->name);
	x->ealg = p;
	x->geniv = algo->uinfo.encr.geniv;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 131 100.00% 1 100.00%
Total 131 100.00% 1 100.00%



static int attach_auth(struct xfrm_algo_auth **algpp, u8 *props,
		       struct nlattr *rta)
{
	struct xfrm_algo *ualg;
	struct xfrm_algo_auth *p;
	struct xfrm_algo_desc *algo;

	if (!rta)
		return 0;

	ualg = nla_data(rta);

	algo = xfrm_aalg_get_byname(ualg->alg_name, 1);
	if (!algo)
		return -ENOSYS;
	*props = algo->desc.sadb_alg_id;

	p = kmalloc(sizeof(*p) + (ualg->alg_key_len + 7) / 8, GFP_KERNEL);
	if (!p)
		return -ENOMEM;

	strcpy(p->alg_name, algo->name);
	p->alg_key_len = ualg->alg_key_len;
	p->alg_trunc_len = algo->uinfo.auth.icv_truncbits;
	memcpy(p->alg_key, ualg->alg_key, (ualg->alg_key_len + 7) / 8);

	*algpp = p;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Martin Willi 170 98.84% 1 50.00%
David S. Miller 2 1.16% 1 50.00%
Total 172 100.00% 2 100.00%



static int attach_auth_trunc(struct xfrm_algo_auth **algpp, u8 *props,
			     struct nlattr *rta)
{
	struct xfrm_algo_auth *p, *ualg;
	struct xfrm_algo_desc *algo;

	if (!rta)
		return 0;

	ualg = nla_data(rta);

	algo = xfrm_aalg_get_byname(ualg->alg_name, 1);
	if (!algo)
		return -ENOSYS;
	if (ualg->alg_trunc_len > algo->uinfo.auth.icv_fullbits)
		return -EINVAL;
	*props = algo->desc.sadb_alg_id;

	p = kmemdup(ualg, xfrm_alg_auth_len(ualg), GFP_KERNEL);
	if (!p)
		return -ENOMEM;

	strcpy(p->alg_name, algo->name);
	if (!p->alg_trunc_len)
		p->alg_trunc_len = algo->uinfo.auth.icv_truncbits;

	*algpp = p;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Martin Willi 52 33.12% 1 11.11%
Herbert Xu 48 30.57% 4 44.44%
David S. Miller 48 30.57% 1 11.11%
Thomas Graf 6 3.82% 2 22.22%
Arnaldo Carvalho de Melo 3 1.91% 1 11.11%
Total 157 100.00% 9 100.00%



static int attach_aead(struct xfrm_state *x, struct nlattr *rta)
{
	struct xfrm_algo_aead *p, *ualg;
	struct xfrm_algo_desc *algo;

	if (!rta)
		return 0;

	ualg = nla_data(rta);

	algo = xfrm_aead_get_byname(ualg->alg_name, ualg->alg_icv_len, 1);
	if (!algo)
		return -ENOSYS;
	x->props.ealgo = algo->desc.sadb_alg_id;

	p = kmemdup(ualg, aead_len(ualg), GFP_KERNEL);
	if (!p)
		return -ENOMEM;

	strcpy(p->alg_name, algo->name);
	x->aead = p;
	x->geniv = algo->uinfo.aead.geniv;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 135 100.00% 2 100.00%
Total 135 100.00% 2 100.00%



static inline int xfrm_replay_verify_len(struct xfrm_replay_state_esn *replay_esn,
					 struct nlattr *rp)
{
	struct xfrm_replay_state_esn *up;
	unsigned int ulen;

	if (!replay_esn || !rp)
		return 0;

	up = nla_data(rp);
	ulen = xfrm_replay_state_esn_len(up);

	/* Check the overall length and the internal bitmap length to avoid
         * potential overflow. */
	if (nla_len(rp) < (int)ulen ||
	    xfrm_replay_state_esn_len(replay_esn) != ulen ||
	    replay_esn->bmp_len != up->bmp_len)
		return -EINVAL;

	if (up->replay_window > up->bmp_len * sizeof(__u32) * 8)
		return -EINVAL;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Steffen Klassert 55 51.40% 1 20.00%
Andy Whitcroft 30 28.04% 2 40.00%
Mathias Krause 18 16.82% 1 20.00%
Alexey Dobriyan 4 3.74% 1 20.00%
Total 107 100.00% 5 100.00%



static int xfrm_alloc_replay_state_esn(struct xfrm_replay_state_esn **replay_esn,
				       struct xfrm_replay_state_esn **preplay_esn,
				       struct nlattr *rta)
{
	struct xfrm_replay_state_esn *p, *pp, *up;
	unsigned int klen, ulen;

	if (!rta)
		return 0;

	up = nla_data(rta);
	klen = xfrm_replay_state_esn_len(up);
	ulen = nla_len(rta) >= (int)klen ? klen : sizeof(*up);

	p = kzalloc(klen, GFP_KERNEL);
	if (!p)
		return -ENOMEM;

	pp = kzalloc(klen, GFP_KERNEL);
	if (!pp) {
		kfree(p);
		return -ENOMEM;
	}

	memcpy(p, up, ulen);
	memcpy(pp, up, ulen);

	*replay_esn = p;
	*preplay_esn = pp;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Steffen Klassert 104 66.67% 1 33.33%
Mathias Krause 48 30.77% 1 33.33%
Alexey Dobriyan 4 2.56% 1 33.33%
Total 156 100.00% 3 100.00%



static inline unsigned int xfrm_user_sec_ctx_size(struct xfrm_sec_ctx *xfrm_ctx)
{
	unsigned int len = 0;

	if (xfrm_ctx) {
		len += sizeof(struct xfrm_user_sec_ctx);
		len += xfrm_ctx->ctx_len;
	}
	return len;
}

Contributors
Person Tokens Prop Commits CommitProp
Trent Jaeger 38 90.48% 1 33.33%
Joy Latten 2 4.76% 1 33.33%
Alexey Dobriyan 2 4.76% 1 33.33%
Total 42 100.00% 3 100.00%



static void copy_from_user_state(struct xfrm_state *x, struct xfrm_usersa_info *p)
{
	memcpy(&x->id, &p->id, sizeof(x->id));
	memcpy(&x->sel, &p->sel, sizeof(x->sel));
	memcpy(&x->lft, &p->lft, sizeof(x->lft));
	x->props.mode = p->mode;
	x->props.replay_window = min_t(unsigned int, p->replay_window,
					sizeof(x->replay.bitmap) * 8);
	x->props.reqid = p->reqid;
	x->props.family = p->family;
	memcpy(&x->props.saddr, &p->saddr, sizeof(x->props.saddr));
	x->props.flags = p->flags;

	if (!x->sel.family && !(p->flags & XFRM_STATE_AF_UNSPEC))
		x->sel.family = p->family;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 136 73.91% 3 33.33%
Herbert Xu 27 14.67% 3 33.33%
Steffen Klassert 9 4.89% 1 11.11%
Fan Du 9 4.89% 1 11.11%
Patrick McHardy 3 1.63% 1 11.11%
Total 184 100.00% 9 100.00%

/*
 * someday when pfkey also has support, we could have the code
 * somehow made shareable and move it to xfrm_state.c - JHS
 *
*/


static void xfrm_update_ae_params(struct xfrm_state *x, struct nlattr **attrs,
				  int update_esn)
{
	struct nlattr *rp = attrs[XFRMA_REPLAY_VAL];
	struct nlattr *re = update_esn ? attrs[XFRMA_REPLAY_ESN_VAL] : NULL;
	struct nlattr *lt = attrs[XFRMA_LTIME_VAL];
	struct nlattr *et = attrs[XFRMA_ETIMER_THRESH];
	struct nlattr *rt = attrs[XFRMA_REPLAY_THRESH];

	if (re) {
		struct xfrm_replay_state_esn *replay_esn;
		replay_esn = nla_data(re);
		memcpy(x->replay_esn, replay_esn,
		       xfrm_replay_state_esn_len(replay_esn));
		memcpy(x->preplay_esn, replay_esn,
		       xfrm_replay_state_esn_len(replay_esn));
	}

	if (rp) {
		struct xfrm_replay_state *replay;
		replay = nla_data(rp);
		memcpy(&x->replay, replay, sizeof(*replay));
		memcpy(&x->preplay, replay, sizeof(*replay));
	}

	if (lt) {
		struct xfrm_lifetime_cur *ltime;
		ltime = nla_data(lt);
		x->curlft.bytes = ltime->bytes;
		x->curlft.packets = ltime->packets;
		x->curlft.add_time = ltime->add_time;
		x->curlft.use_time = ltime->use_time;
	}

	if (et)
		x->replay_maxage = nla_get_u32(et);

	if (rt)
		x->replay_maxdiff = nla_get_u32(rt);
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 176 69.29% 1 16.67%
Steffen Klassert 56 22.05% 1 16.67%
Thomas Graf 15 5.91% 3 50.00%
Mathias Krause 7 2.76% 1 16.67%
Total 254 100.00% 6 100.00%



static struct xfrm_state *xfrm_state_construct(struct net *net,
					       struct xfrm_usersa_info *p,
					       struct nlattr **attrs,
					       int *errp)
{
	struct xfrm_state *x = xfrm_state_alloc(net);
	int err = -ENOMEM;

	if (!x)
		goto error_no_put;

	copy_from_user_state(x, p);

	if (attrs[XFRMA_SA_EXTRA_FLAGS])
		x->props.extra_flags = nla_get_u32(attrs[XFRMA_SA_EXTRA_FLAGS]);

	if ((err = attach_aead(x, attrs[XFRMA_ALG_AEAD])))
		goto error;
	if ((err = attach_auth_trunc(&x->aalg, &x->props.aalgo,
				     attrs[XFRMA_ALG_AUTH_TRUNC])))
		goto error;
	if (!x->props.aalgo) {
		if ((err = attach_auth(&x->aalg, &x->props.aalgo,
				       attrs[XFRMA_ALG_AUTH])))
			goto error;
	}
	if ((err = attach_crypt(x, attrs[XFRMA_ALG_CRYPT])))
		goto error;
	if ((err = attach_one_algo(&x->calg, &x->props.calgo,
				   xfrm_calg_get_byname,
				   attrs[XFRMA_ALG_COMP])))
		goto error;

	if (attrs[XFRMA_ENCAP]) {
		x->encap = kmemdup(nla_data(attrs[XFRMA_ENCAP]),
				   sizeof(*x->encap), GFP_KERNEL);
		if (x->encap == NULL)
			goto error;
	}

	if (attrs[XFRMA_TFCPAD])
		x->tfcpad = nla_get_u32(attrs[XFRMA_TFCPAD]);

	if (attrs[XFRMA_COADDR]) {
		x->coaddr = kmemdup(nla_data(attrs[XFRMA_COADDR]),
				    sizeof(*x->coaddr), GFP_KERNEL);
		if (x->coaddr == NULL)
			goto error;
	}

	xfrm_mark_get(attrs, &x->mark);

	if (attrs[XFRMA_OUTPUT_MARK])
		x->props.output_mark = nla_get_u32(attrs[XFRMA_OUTPUT_MARK]);

	err = __xfrm_init_state(x, false, attrs[XFRMA_OFFLOAD_DEV]);
	if (err)
		goto error;

	if (attrs[XFRMA_SEC_CTX]) {
		err = security_xfrm_state_alloc(x,
						nla_data(attrs[XFRMA_SEC_CTX]));
		if (err)
			goto error;
	}

	if ((err = xfrm_alloc_replay_state_esn(&x->replay_esn, &x->preplay_esn,
					       attrs[XFRMA_REPLAY_ESN_VAL])))
		goto error;

	x->km.seq = p->seq;
	x->replay_maxdiff = net->xfrm.sysctl_aevent_rseqth;
	/* sysctl_xfrm_aevent_etime is in 100ms units */
	x->replay_maxage = (net->xfrm.sysctl_aevent_etime*HZ)/XFRM_AE_ETH_M;

	if ((err = xfrm_init_replay(x)))
		goto error;

	/* override default values from above */
	xfrm_update_ae_params(x, attrs, 0);

	/* configure the hardware if offload is requested */
	if (attrs[XFRMA_OFFLOAD_DEV]) {
		err = xfrm_dev_state_add(net, x,
					 nla_data(attrs[XFRMA_OFFLOAD_DEV]));
		if (err)
			goto error;
	}

	return x;

error:
	x->km.state = XFRM_STATE_DEAD;
	xfrm_state_put(x);
error_no_put:
	*errp = err;
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 156 27.86% 2 7.41%
Thomas Graf 79 14.11% 3 11.11%
Martin Willi 59 10.54% 2 7.41%
Jamal Hadi Salim 44 7.86% 2 7.41%
Steffen Klassert 41 7.32% 2 7.41%
Herbert Xu 38 6.79% 3 11.11%
Yossi Kuperman 34 6.07% 1 3.70%
Nicolas Dichtel 21 3.75% 1 3.70%
Lorenzo Colitti 21 3.75% 1 3.70%
Alexey Dobriyan 18 3.21% 3 11.11%
Trent Jaeger 13 2.32% 1 3.70%
Noriaki Takamiya 13 2.32% 1 3.70%
Mathias Krause 11 1.96% 2 7.41%
Ilan Tayari 5 0.89% 1 3.70%
Krishna Kumar 4 0.71% 1 3.70%
Wei Yongjun 3 0.54% 1 3.70%
Total 560 100.00% 27 100.00%



static int xfrm_add_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct xfrm_usersa_info *p = nlmsg_data(nlh);
	struct xfrm_state *x;
	int err;
	struct km_event c;

	err = verify_newsa_info(p, attrs);
	if (err)
		return err;

	x = xfrm_state_construct(net, p, attrs, &err);
	if (!x)
		return err;

	xfrm_state_hold(x);
	if (nlh->nlmsg_type == XFRM_MSG_NEWSA)
		err = xfrm_state_add(x);
	else
		err = xfrm_state_update(x);

	xfrm_audit_state_add(x, err ? 0 : 1, true);

	if (err < 0) {
		x->km.state = XFRM_STATE_DEAD;
		xfrm_dev_state_delete(x);
		__xfrm_state_put(x);
		goto out;
	}

	if (x->km.state == XFRM_STATE_VOID)
		x->km.state = XFRM_STATE_VALID;

	c.seq = nlh->nlmsg_seq;
	c.portid = nlh->nlmsg_pid;
	c.event = nlh->nlmsg_type;

	km_state_notify(x, &c);
out:
	xfrm_state_put(x);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 82 36.61% 1 5.26%
Jamal Hadi Salim 42 18.75% 1 5.26%
Herbert Xu 35 15.62% 4 21.05%
Yossi Kuperman 18 8.04% 1 5.26%
Alexey Dobriyan 14 6.25% 1 5.26%
Joy Latten 12 5.36% 2 10.53%
Thomas Graf 5 2.23% 3 15.79%
Patrick McHardy 5 2.23% 1 5.26%
Steffen Klassert 5 2.23% 1 5.26%
Kunihiro Ishiguro 3 1.34% 1 5.26%
Christoph Hellwig 1 0.45% 1 5.26%
Tetsuo Handa 1 0.45% 1 5.26%
Eric W. Biedermann 1 0.45% 1 5.26%
Total 224 100.00% 19 100.00%



static struct xfrm_state *xfrm_user_state_lookup(struct net *net,
						 struct xfrm_usersa_id *p,
						 struct nlattr **attrs,
						 int *errp)
{
	struct xfrm_state *x = NULL;
	struct xfrm_mark m;
	int err;
	u32 mark = xfrm_mark_get(attrs, &m);

	if (xfrm_id_proto_match(p->proto, IPSEC_PROTO_ANY)) {
		err = -ESRCH;
		x = xfrm_state_lookup(net, mark, &p->daddr, p->spi, p->proto, p->family);
	} else {
		xfrm_address_t *saddr = NULL;

		verify_one_addr(attrs, XFRMA_SRCADDR, &saddr);
		if (!saddr) {
			err = -EINVAL;
			goto out;
		}

		err = -ESRCH;
		x = xfrm_state_lookup_byaddr(net, mark,
					     &p->daddr, saddr,
					     p->proto, p->family);
	}

 out:
	if (!x && errp)
		*errp = err;
	return x;
}

Contributors
Person Tokens Prop Commits CommitProp
Masahide Nakamura 144 81.36% 2 25.00%
Jamal Hadi Salim 19 10.73% 2 25.00%
Alexey Dobriyan 11 6.21% 2 25.00%
Thomas Graf 3 1.69% 2 25.00%
Total 177 100.00% 8 100.00%



static int xfrm_del_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct xfrm_state *x;
	int err = -ESRCH;
	struct km_event c;
	struct xfrm_usersa_id *p = nlmsg_data(nlh);

	x = xfrm_user_state_lookup(net, p, attrs, &err);
	if (x == NULL)
		return err;

	if ((err = security_xfrm_state_delete(x)) != 0)
		goto out;

	if (xfrm_state_kern(x)) {
		err = -EPERM;
		goto out;
	}

	err = xfrm_state_delete(x);

	if (err < 0)
		goto out;

	c.seq = nlh->nlmsg_seq;
	c.portid = nlh->nlmsg_pid;
	c.event = nlh->nlmsg_type;
	km_state_notify(x, &c);

out:
	xfrm_audit_state_delete(x, err ? 0 : 1, true);
	xfrm_state_put(x);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 56 30.11% 2 11.76%
Jamal Hadi Salim 50 26.88% 1 5.88%
Catherine Zhang 22 11.83% 1 5.88%
Alexey Dobriyan 14 7.53% 1 5.88%
James Morris 12 6.45% 1 5.88%
Joy Latten 9 4.84% 1 5.88%
Masahide Nakamura 7 3.76% 1 5.88%
Thomas Graf 4 2.15% 3 17.65%
Eric Paris 3 1.61% 1 5.88%
Kunihiro Ishiguro 3 1.61% 1 5.88%
Herbert Xu 3 1.61% 1 5.88%
Christoph Hellwig 1 0.54% 1 5.88%
Tetsuo Handa 1 0.54% 1 5.88%
Eric W. Biedermann 1 0.54% 1 5.88%
Total 186 100.00% 17 100.00%



static void copy_to_user_state(struct xfrm_state *x, struct xfrm_usersa_info *p)
{
	memset(p, 0, sizeof(*p));
	memcpy(&p->id, &x->id, sizeof(p->id));
	memcpy(&p->sel, &x->sel, sizeof(p->sel));
	memcpy(&p->lft, &x->lft, sizeof(p->lft));
	memcpy(&p->curlft, &x->curlft, sizeof(p->curlft));
	put_unaligned(x->stats.replay_window, &p->stats.replay_window);
	put_unaligned(x->stats.replay, &p->stats.replay);
	put_unaligned(x->stats.integrity_failed, &p->stats.integrity_failed);
	memcpy(&p->saddr, &x->props.saddr, sizeof(p->saddr));
	p->mode = x->props.mode;
	p->replay_window = x->props.replay_window;
	p->reqid = x->props.reqid;
	p->family = x->props.family;
	p->flags = x->props.flags;
	p->seq = x->km.seq;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 175 73.22% 3 42.86%
Sowmini Varadhan 32 13.39% 1 14.29%
Herbert Xu 19 7.95% 2 28.57%
Mathias Krause 13 5.44% 1 14.29%
Total 239 100.00% 7 100.00%


struct xfrm_dump_info {
	
struct sk_buff *in_skb;
	
struct sk_buff *out_skb;
	
u32 nlmsg_seq;
	
u16 nlmsg_flags;
};



static int copy_sec_ctx(struct xfrm_sec_ctx *s, struct sk_buff *skb)
{
	struct xfrm_user_sec_ctx *uctx;
	struct nlattr *attr;
	int ctx_size = sizeof(*uctx) + s->ctx_len;

	attr = nla_reserve(skb, XFRMA_SEC_CTX, ctx_size);
	if (attr == NULL)
		return -EMSGSIZE;

	uctx = nla_data(attr);
	uctx->exttype = XFRMA_SEC_CTX;
	uctx->len = ctx_size;
	uctx->ctx_doi = s->ctx_doi;
	uctx->ctx_alg = s->ctx_alg;
	uctx->ctx_len = s->ctx_len;
	memcpy(uctx + 1, s->ctx_str, s->ctx_len);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Graf 109 90.08% 1 50.00%
Herbert Xu 12 9.92% 1 50.00%
Total 121 100.00% 2 100.00%



static int copy_user_offload(struct xfrm_state_offload *xso, struct sk_buff *skb)
{
	struct xfrm_user_offload *xuo;
	struct nlattr *attr;

	attr = nla_reserve(skb, XFRMA_OFFLOAD_DEV, sizeof(*xuo));
	if (attr == NULL)
		return -EMSGSIZE;

	xuo = nla_data(attr);
	memset(xuo, 0, sizeof(*xuo));
	xuo->ifindex = xso->dev->ifindex;
	xuo->flags = xso->flags;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Steffen Klassert 79 85.87% 1 50.00%
Mathias Krause 13 14.13% 1 50.00%
Total 92 100.00% 2 100.00%



static int copy_to_user_auth(struct xfrm_algo_auth *auth, struct sk_buff *skb)
{
	struct xfrm_algo *algo;
	struct nlattr *nla;

	nla = nla_reserve(skb, XFRMA_ALG_AUTH,
			  sizeof(*algo) + (auth->alg_key_len + 7) / 8);
	if (!nla)
		return -EMSGSIZE;

	algo = nla_data(nla);
	strncpy(algo->alg_name, auth->alg_name, sizeof(algo->alg_name));
	memcpy(algo->alg_key, auth->alg_key, (auth->alg_key_len + 7) / 8);
	algo->alg_key_len = auth->alg_key_len;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Martin Willi 109 93.16% 1 50.00%
Mathias Krause 8 6.84% 1 50.00%
Total 117 100.00% 2 100.00%

/* Don't change this without updating xfrm_sa_len! */


static int copy_to_user_state_extra(struct xfrm_state *x,
				    struct xfrm_usersa_info *p,
				    struct sk_buff *skb)
{
	int ret = 0;

	copy_to_user_state(x, p);

	if (x->props.extra_flags) {
		ret = nla_put_u32(skb, XFRMA_SA_EXTRA_FLAGS,
				  x->props.extra_flags);
		if (ret)
			goto out;
	}

	if (x->coaddr) {
		ret = nla_put(skb, XFRMA_COADDR, sizeof(*x->coaddr), x->coaddr);
		if (ret)
			goto out;
	}
	if (x->lastused) {
		ret = nla_put_u64_64bit(skb, XFRMA_LASTUSED, x->lastused,
					XFRMA_PAD);
		if (ret)
			goto out;
	}
	if (x->aead) {
		ret = nla_put(skb, XFRMA_ALG_AEAD, aead_len(x->aead), x->aead);
		if (ret)
			goto out;
	}
	if (x->aalg) {
		ret = copy_to_user_auth(x->aalg, skb);
		if (!ret)
			ret = nla_put(skb, XFRMA_ALG_AUTH_TRUNC,
				      xfrm_alg_auth_len(x->aalg), x->aalg);
		if (ret)
			goto out;
	}
	if (x->ealg) {
		ret = nla_put(skb, XFRMA_ALG_CRYPT, xfrm_alg_len(x->ealg), x->ealg);
		if (ret)
			goto out;
	}
	if (x->calg) {
		ret = nla_put(skb, XFRMA_ALG_COMP, sizeof(*(x->calg)), x->calg);
		if (ret)
			goto out;
	}
	if (x->encap) {
		ret = nla_put(skb, XFRMA_ENCAP, sizeof(*x->encap), x->encap);
		if (ret)
			goto out;
	}
	if (x->tfcpad) {
		ret = nla_put_u32(skb, XFRMA_TFCPAD, x->tfcpad);
		if (ret)
			goto out;
	}
	ret = xfrm_mark_put(skb, &x->mark);
	if (ret)
		goto out;
	if (x->replay_esn)
		ret = nla_put(skb, XFRMA_REPLAY_ESN_VAL,
			      xfrm_replay_state_esn_len(x->replay_esn),
			      x->replay_esn);
	else
		ret = nla_put(skb, XFRMA_REPLAY_VAL, sizeof(x->replay),
			      &x->replay);
	if (ret)
		goto out;
	if(x->xso.dev)
		ret = copy_user_offload(&x->xso, skb);
	if (ret)
		goto out;
	if (x->props.output_mark) {
		ret = nla_put_u32(skb, XFRMA_OUTPUT_MARK, x->props.output_mark);
		if (ret)
			goto out;
	}
	if (x->security)
		ret = copy_sec_ctx(x->security, skb);
out:
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 252 49.51% 4 21.05%
Herbert Xu 66 12.97% 3 15.79%
Steffen Klassert 65 12.77% 3 15.79%
Nicolas Dichtel 35 6.88% 2 10.53%
Lorenzo Colitti 28 5.50% 1 5.26%
Martin Willi 22 4.32% 2 10.53%
Ding Zhi 22 4.32% 1 5.26%
Jamal Hadi Salim 14 2.75% 1 5.26%
Trent Jaeger 4 0.79% 1 5.26%
Eric Dumazet 1 0.20% 1 5.26%
Total 509 100.00% 19 100.00%



static int dump_one_state(struct xfrm_state *x, int count, void *ptr)
{
	struct xfrm_dump_info *sp = ptr;
	struct sk_buff *in_skb = sp->in_skb;
	struct sk_buff *skb = sp->out_skb;
	struct xfrm_usersa_info *p;
	struct nlmsghdr *nlh;
	int err;

	nlh = nlmsg_put(skb, NETLINK_CB(in_skb).portid, sp->nlmsg_seq,
			XFRM_MSG_NEWSA, sizeof(*p), sp->nlmsg_flags);
	if (nlh == NULL)
		return -EMSGSIZE;

	p = nlmsg_data(nlh);

	err = copy_to_user_state_extra(x, p, skb);
	if (err) {
		nlmsg_cancel(skb, nlh);
		return err;
	}
	nlmsg_end(skb, nlh);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 116 82.86% 1 16.67%
David S. Miller 18 12.86% 2 33.33%
Thomas Graf 3 2.14% 1 16.67%
Arnaldo Carvalho de Melo 2 1.43% 1 16.67%
Eric W. Biedermann 1 0.71% 1 16.67%
Total 140 100.00% 6 100.00%



static int xfrm_dump_sa_done(struct netlink_callback *cb)
{
	struct xfrm_state_walk *walk = (struct xfrm_state_walk *) &cb->args[1];
	struct sock *sk = cb->skb->sk;
	struct net *net = sock_net(sk);

	if (cb->args[0])
		xfrm_state_walk_done(walk, net);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Timo Teräs 37 53.62% 1 33.33%
Fan Du 23 33.33% 1 33.33%
Vegard Nossum 9 13.04% 1 33.33%
Total 69 100.00% 3 100.00%


static const struct nla_policy xfrma_policy[XFRMA_MAX+1];


static int xfrm_dump_sa(struct sk_buff *skb, struct netlink_callback *cb)
{
	struct net *net = sock_net(skb->sk);
	struct xfrm_state_walk *walk = (struct xfrm_state_walk *) &cb->args[1];
	struct xfrm_dump_info info;

	BUILD_BUG_ON(sizeof(struct xfrm_state_walk) >
		     sizeof(cb->args) - sizeof(cb->args[0]));

	info.in_skb = cb->skb;
	info.out_skb = skb;
	info.nlmsg_seq = cb->nlh->nlmsg_seq;
	info.nlmsg_flags = NLM_F_MULTI;

	if (!cb->args[0]) {
		struct nlattr *attrs[XFRMA_MAX+1];
		struct xfrm_address_filter *filter = NULL;
		u8 proto = 0;
		int err;

		err = nlmsg_parse(cb->nlh, 0, attrs, XFRMA_MAX, xfrma_policy,
				  NULL);
		if (err < 0)
			return err;

		if (attrs[XFRMA_ADDRESS_FILTER]) {
			filter = kmemdup(nla_data(attrs[XFRMA_ADDRESS_FILTER]),
					 sizeof(*filter), GFP_KERNEL);
			if (filter == NULL)
				return -ENOMEM;
		}

		if (attrs[XFRMA_PROTO])
			proto = nla_get_u8(attrs[XFRMA_PROTO]);

		xfrm_state_walk_init(walk, proto, filter);
		cb->args[0] = 1;
	}

	(void) xfrm_state_walk(net, walk, dump_one_state, &info);

	return skb->len;
}

Contributors
Person Tokens Prop Commits CommitProp
Nicolas Dichtel 102 38.35% 2 20.00%
David S. Miller 65 24.44% 1 10.00%
Timo Teräs 61 22.93% 1 10.00%
Alexey Dobriyan 14 5.26% 2 20.00%
Andrzej Hajda 9 3.38% 1 10.00%
Vegard Nossum 9 3.38% 1 10.00%
Harald Welte 4 1.50% 1 10.00%
Johannes Berg 2 0.75% 1 10.00%
Total 266 100.00% 10 100.00%



static struct sk_buff *xfrm_state_netlink(struct sk_buff *in_skb,
					  struct xfrm_state *x, u32 seq)
{
	struct xfrm_dump_info info;
	struct sk_buff *skb;
	int err;

	skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
	if (!skb)
		return ERR_PTR(-ENOMEM);

	info.in_skb = in_skb;
	info.out_skb = skb;
	info.nlmsg_seq = seq;
	info.nlmsg_flags = 0;

	err = dump_one_state(x, 0, &info);
	if (err) {
		kfree_skb(skb);
		return ERR_PTR(err);
	}

	return skb;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 91 82.73% 1 25.00%
Mathias Krause 13 11.82% 1 25.00%
Harald Welte 4 3.64% 1 25.00%
Thomas Graf 2 1.82% 1 25.00%
Total 110 100.00% 4 100.00%

/* A wrapper for nlmsg_multicast() checking that nlsk is still available.
 * Must be called with RCU read lock.
 */


static inline int xfrm_nlmsg_multicast(struct net *net, struct sk_buff *skb,
				       u32 pid, unsigned int group)
{
	struct sock *nlsk = rcu_dereference(net->xfrm.nlsk);

	if (nlsk)
		return nlmsg_multicast(nlsk, skb, pid, group, GFP_ATOMIC);
	else
		return -1;
}

Contributors
Person Tokens Prop Commits CommitProp
Michal Kubeček 61 100.00% 1 100.00%
Total 61 100.00% 1 100.00%



static inline unsigned int xfrm_spdinfo_msgsize(void)
{
	return NLMSG_ALIGN(4)
	       + nla_total_size(sizeof(struct xfrmu_spdinfo))
	       + nla_total_size(sizeof(struct xfrmu_spdhinfo))
	       + nla_total_size(sizeof(struct xfrmu_spdhthresh))
	       + nla_total_size(sizeof(struct xfrmu_spdhthresh));
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Graf 32 61.54% 1 33.33%
Christophe Gouault 18 34.62% 1 33.33%
Alexey Dobriyan 2 3.85% 1 33.33%
Total 52 100.00% 3 100.00%



static int build_spdinfo(struct sk_buff *skb, struct net *net,
			 u32 portid, u32 seq, u32 flags)
{
	struct xfrmk_spdinfo si;
	struct xfrmu_spdinfo spc;
	struct xfrmu_spdhinfo sph;
	struct xfrmu_spdhthresh spt4, spt6;
	struct nlmsghdr *nlh;
	int err;
	u32 *f;
	unsigned lseq;

	nlh = nlmsg_put(skb, portid, seq, XFRM_MSG_NEWSPDINFO, sizeof(u32), 0);
	if (nlh == NULL) /* shouldn't really happen ... */
		return -EMSGSIZE;

	f = nlmsg_data(nlh);
	*f = flags;
	xfrm_spd_getinfo(net, &si);
	spc.incnt = si.incnt;
	spc.outcnt = si.outcnt;
	spc.fwdcnt = si.fwdcnt;
	spc.inscnt = si.inscnt;
	spc.outscnt = si.outscnt;
	spc.fwdscnt = si.fwdscnt;
	sph.spdhcnt = si.spdhcnt;
	sph.spdhmcnt = si.spdhmcnt;

	do {
		lseq = read_seqbegin(&net->xfrm.policy_hthresh.lock);

		spt4.lbits = net->xfrm.policy_hthresh.lbits4;
		spt4.rbits = net->xfrm.policy_hthresh.rbits4;
		spt6.lbits = net->xfrm.policy_hthresh.lbits6;
		spt6.rbits = net->xfrm.policy_hthresh.rbits6;
	} while (read_seqretry(&net->xfrm.policy_hthresh.lock, lseq));

	err = nla_put(skb, XFRMA_SPD_INFO, sizeof(spc), &spc);
	if (!err)
		err = nla_put(skb, XFRMA_SPD_HINFO, sizeof(sph), &sph);
	if (!err)
		err = nla_put(skb, XFRMA_SPD_IPV4_HTHRESH, sizeof(spt4), &spt4);
	if (!err)
		err = nla_put(skb, XFRMA_SPD_IPV6_HTHRESH, sizeof(spt6), &spt6);
	if (err) {
		nlmsg_cancel(skb, nlh);
		return err;
	}

	nlmsg_end(skb, nlh);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 189 51.92% 2 22.22%
Christophe Gouault 135 37.09% 1 11.11%
David S. Miller 27 7.42% 2 22.22%
Alexey Dobriyan 7 1.92% 1 11.11%
Johannes Berg 3 0.82% 1 11.11%
Eric W. Biedermann 2 0.55% 1 11.11%
Lucas De Marchi 1 0.27% 1 11.11%
Total 364 100.00% 9 100.00%



static int xfrm_set_spdinfo(struct sk_buff *skb, struct nlmsghdr *nlh,
			    struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct xfrmu_spdhthresh *thresh4 = NULL;
	struct xfrmu_spdhthresh *thresh6 = NULL;

	/* selector prefixlen thresholds to hash policies */
	if (attrs[XFRMA_SPD_IPV4_HTHRESH]) {
		struct nlattr *rta = attrs[XFRMA_SPD_IPV4_HTHRESH];

		if (nla_len(rta) < sizeof(*thresh4))
			return -EINVAL;
		thresh4 = nla_data(rta);
		if (thresh4->lbits > 32 || thresh4->rbits > 32)
			return -EINVAL;
	}
	if (attrs[XFRMA_SPD_IPV6_HTHRESH]) {
		struct nlattr *rta = attrs[XFRMA_SPD_IPV6_HTHRESH];

		if (nla_len(rta) < sizeof(*thresh6))
			return -EINVAL;
		thresh6 = nla_data(rta);
		if (thresh6->lbits > 128 || thresh6->rbits > 128)
			return -EINVAL;
	}

	if (thresh4 || thresh6) {
		write_seqlock(&net->xfrm.policy_hthresh.lock);
		if (thresh4) {
			net->xfrm.policy_hthresh.lbits4 = thresh4->lbits;
			net->xfrm.policy_hthresh.rbits4 = thresh4->rbits;
		}
		if (thresh6) {
			net->xfrm.policy_hthresh.lbits6 = thresh6->lbits;
			net->xfrm.policy_hthresh.rbits6 = thresh6->rbits;
		}
		write_sequnlock(&net->xfrm.policy_hthresh.lock);

		xfrm_policy_hash_rebuild(net);
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Christophe Gouault 271 100.00% 1 100.00%
Total 271 100.00% 1 100.00%



static int xfrm_get_spdinfo(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct sk_buff *r_skb;
	u32 *flags = nlmsg_data(nlh);
	u32 sportid = NETLINK_CB(skb).portid;
	u32 seq = nlh->nlmsg_seq;
	int err;

	r_skb = nlmsg_new(xfrm_spdinfo_msgsize(), GFP_ATOMIC);
	if (r_skb == NULL)
		return -ENOMEM;

	err = build_spdinfo(r_skb, net, sportid, seq, *flags);
	BUG_ON(err < 0);

	return nlmsg_unicast(net->xfrm.nlsk, r_skb, sportid);
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 86 68.80% 1 11.11%
Alexey Dobriyan 19 15.20% 2 22.22%
Gustavo A. R. Silva 10 8.00% 1 11.11%
Thomas Graf 6 4.80% 4 44.44%
Eric W. Biedermann 4 3.20% 1 11.11%
Total 125 100.00% 9 100.00%



static inline unsigned int xfrm_sadinfo_msgsize(void)
{
	return NLMSG_ALIGN(4)
	       + nla_total_size(sizeof(struct xfrmu_sadhinfo))
	       + nla_total_size(4); /* XFRMA_SAD_CNT */
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Graf 29 93.55% 1 50.00%
Alexey Dobriyan 2 6.45% 1 50.00%
Total 31 100.00% 2 100.00%



static int build_sadinfo(struct sk_buff *skb, struct net *net,
			 u32 portid, u32 seq, u32 flags)
{
	struct xfrmk_sadinfo si;
	struct xfrmu_sadhinfo sh;
	struct nlmsghdr *nlh;
	int err;
	u32 *f;

	nlh = nlmsg_put(skb, portid, seq, XFRM_MSG_NEWSADINFO, sizeof(u32), 0);
	if (nlh == NULL) /* shouldn't really happen ... */
		return -EMSGSIZE;

	f = nlmsg_data(nlh);
	*f = flags;
	xfrm_sad_getinfo(net, &si);

	sh.sadhmcnt = si.sadhmcnt;
	sh.sadhcnt = si.sadhcnt;

	err = nla_put_u32(skb, XFRMA_SAD_CNT, si.sadcnt);
	if (!err)
		err = nla_put(skb, XFRMA_SAD_HINFO, sizeof(sh), &sh);
	if (err) {
		nlmsg_cancel(skb, nlh);
		return err;
	}

	nlmsg_end(skb, nlh);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 133 76.88% 2 25.00%
David S. Miller 27 15.61% 2 25.00%
Alexey Dobriyan 7 4.05% 1 12.50%
Johannes Berg 3 1.73% 1 12.50%
Eric W. Biedermann 2 1.16% 1 12.50%
Lucas De Marchi 1 0.58% 1 12.50%
Total 173 100.00% 8 100.00%



static int xfrm_get_sadinfo(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct sk_buff *r_skb;
	u32 *flags = nlmsg_data(nlh);
	u32 sportid = NETLINK_CB(skb).portid;
	u32 seq = nlh->nlmsg_seq;
	int err;

	r_skb = nlmsg_new(xfrm_sadinfo_msgsize(), GFP_ATOMIC);
	if (r_skb == NULL)
		return -ENOMEM;

	err = build_sadinfo(r_skb, net, sportid, seq, *flags);
	BUG_ON(err < 0);

	return nlmsg_unicast(net->xfrm.nlsk, r_skb, sportid);
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 86 68.80% 1 11.11%
Alexey Dobriyan 19 15.20% 2 22.22%
Gustavo A. R. Silva 10 8.00% 1 11.11%
Thomas Graf 6 4.80% 4 44.44%
Eric W. Biedermann 4 3.20% 1 11.11%
Total 125 100.00% 9 100.00%



static int xfrm_get_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct xfrm_usersa_id *p = nlmsg_data(nlh);
	struct xfrm_state *x;
	struct sk_buff *resp_skb;
	int err = -ESRCH;

	x = xfrm_user_state_lookup(net, p, attrs, &err);
	if (x == NULL)
		goto out_noput;

	resp_skb = xfrm_state_netlink(skb, x, nlh->nlmsg_seq);
	if (IS_ERR(resp_skb)) {
		err = PTR_ERR(resp_skb);
	} else {
		err = nlmsg_unicast(net->xfrm.nlsk, resp_skb, NETLINK_CB(skb).portid);
	}
	xfrm_state_put(x);
out_noput:
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 112 77.24% 1 9.09%
Alexey Dobriyan 19 13.10% 2 18.18%
Masahide Nakamura 6 4.14% 1 9.09%
Thomas Graf 5 3.45% 4 36.36%
Christoph Hellwig 1 0.69% 1 9.09%
Kunihiro Ishiguro 1 0.69% 1 9.09%
Eric W. Biedermann 1 0.69% 1 9.09%
Total 145 100.00% 11 100.00%



static int xfrm_alloc_userspi(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct xfrm_state *x;
	struct xfrm_userspi_info *p;
	struct sk_buff *resp_skb;
	xfrm_address_t *daddr;
	int family;
	int err;
	u32 mark;
	struct xfrm_mark m;

	p = nlmsg_data(nlh);
	err = verify_spi_info(p->info.id.proto, p->min, p->max);
	if (err)
		goto out_noput;

	family = p->info.family;
	daddr = &p->info.id.daddr;

	x = NULL;

	mark = xfrm_mark_get(attrs, &m);
	if (p->info.seq) {
		x = xfrm_find_acq_byseq(net, mark, p->info.seq);
		if (x && !xfrm_addr_equal(&x->id.daddr, daddr, family)) {
			xfrm_state_put(x);
			x = NULL;
		}
	}

	if (!x)
		x = xfrm_find_acq(net, &m, p->info.mode, p->info.reqid,
				  p->info.id.proto, daddr,
				  &p->info.saddr, 1,
				  family);
	err = -ENOENT;
	if (x == NULL)
		goto out_noput;

	err = xfrm_alloc_spi(x, p->min, p->max);
	if (err)
		goto out;

	resp_skb = xfrm_state_netlink(skb, x, nlh->nlmsg_seq);
	if (IS_ERR(resp_skb)) {
		err = PTR_ERR(resp_skb);
		goto out;
	}

	err = nlmsg_unicast(net->xfrm.nlsk, resp_skb, NETLINK_CB(skb).portid);

out:
	xfrm_state_put(x);
out_noput:
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 176 52.23% 2 10.00%
Herbert Xu 90 26.71% 3 15.00%
Jamal Hadi Salim 22 6.53% 2 10.00%
Alexey Dobriyan 21 6.23% 3 15.00%
Fan Du 15 4.45% 1 5.00%
Thomas Graf 4 1.19% 4 20.00%
Hideaki Yoshifuji / 吉藤英明 4 1.19% 2 10.00%
Kunihiro Ishiguro 3 0.89% 1 5.00%
Christoph Hellwig 1 0.30% 1 5.00%
Eric W. Biedermann 1 0.30% 1 5.00%
Total 337 100.00% 20 100.00%



static int verify_policy_dir(u8 dir)
{
	switch (dir) {
	case XFRM_POLICY_IN:
	case XFRM_POLICY_OUT:
	case XFRM_POLICY_FWD:
		break;

	default:
		return -EINVAL;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 32 96.97% 1 50.00%
Jamal Hadi Salim 1 3.03% 1 50.00%
Total 33 100.00% 2 100.00%



static int verify_policy_type(u8 type)
{
	switch (type) {
	case XFRM_POLICY_TYPE_MAIN:
#ifdef CONFIG_XFRM_SUB_POLICY
	case XFRM_POLICY_TYPE_SUB:
#endif
		break;

	default:
		return -EINVAL;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Masahide Nakamura 34 97.14% 1 50.00%
Jamal Hadi Salim 1 2.86% 1 50.00%
Total 35 100.00% 2 100.00%



static int verify_newpolicy_info(struct xfrm_userpolicy_info *p)
{
	int ret;

	switch (p->share) {
	case XFRM_SHARE_ANY:
	case XFRM_SHARE_SESSION:
	case XFRM_SHARE_USER:
	case XFRM_SHARE_UNIQUE:
		break;

	default:
		return -EINVAL;
	}

	switch (p->action) {
	case XFRM_POLICY_ALLOW:
	case XFRM_POLICY_BLOCK:
		break;

	default:
		return -EINVAL;
	}

	switch (p->sel.family) {
	case AF_INET:
		break;

	case AF_INET6:
#if IS_ENABLED(CONFIG_IPV6)
		break;
#else
		return  -EAFNOSUPPORT;
#endif

	default:
		return -EINVAL;
	}

	ret = verify_policy_dir(p->dir);
	if (ret)
		return ret;
	if (p->index && ((p->index & XFRM_POLICY_MAX) != p->dir))
		return -EINVAL;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 64 45.71% 1 20.00%
Fan Du 39 27.86% 1 20.00%
James Morris 34 24.29% 1 20.00%
Herbert Xu 2 1.43% 1 20.00%
Eric Dumazet 1 0.71% 1 20.00%
Total 140 100.00% 5 100.00%



static int copy_from_user_sec_ctx(struct xfrm_policy *pol, struct nlattr **attrs)
{
	struct nlattr *rt = attrs[XFRMA_SEC_CTX];
	struct xfrm_user_sec_ctx *uctx;

	if (!rt)
		return 0;

	uctx = nla_data(rt);
	return security_xfrm_policy_alloc(&pol->security, uctx, GFP_KERNEL);
}

Contributors
Person Tokens Prop Commits CommitProp
Trent Jaeger 50 83.33% 1 20.00%
Thomas Graf 5 8.33% 2 40.00%
Paul Moore 3 5.00% 1 20.00%
Nikolay Aleksandrov 2 3.33% 1 20.00%
Total 60 100.00% 5 100.00%



static void copy_templates(struct xfrm_policy *xp, struct xfrm_user_tmpl *ut,
			   int nr)
{
	int i;

	xp->xfrm_nr = nr;
	for (i = 0; i < nr; i++, ut++) {
		struct xfrm_tmpl *t = &xp->xfrm_vec[i];

		memcpy(&t->id, &ut->id, sizeof(struct xfrm_id));
		memcpy(&t->saddr, &ut->saddr,
		       sizeof(xfrm_address_t));
		t->reqid = ut->reqid;
		t->mode = ut->mode;
		t->share = ut->share;
		t->optional = ut->optional;
		t->aalgos = ut->aalgos;
		t->ealgos = ut->ealgos;
		t->calgos = ut->calgos;
		/* If all masks are ~0, then we allow all algorithms. */
		t->allalgs = !~(t->aalgos & t->ealgos & t->calgos);
		t->encap_family = ut->family;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 152 83.98% 1 33.33%
Herbert Xu 21 11.60% 1 33.33%
Miika Komu 8 4.42% 1 33.33%
Total 181 100.00% 3 100.00%



static int validate_tmpl(int nr, struct xfrm_user_tmpl *ut, u16 family)
{
	u16 prev_family;
	int i;

	if (nr > XFRM_MAX_DEPTH)
		return -EINVAL;

	prev_family = family;

	for (i = 0; i < nr; i++) {
		/* We never validated the ut->family value, so many
                 * applications simply leave it at zero.  The check was
                 * never made and ut->family was ignored because all
                 * templates could be assumed to have the same family as
                 * the policy itself.  Now that we will have ipv4-in-ipv6
                 * and ipv6-in-ipv4 tunnels, this is no longer true.
                 */
		if (!ut[i].family)
			ut[i].family = family;

		if ((ut[i].mode == XFRM_MODE_TRANSPORT) &&
		    (ut[i].family != prev_family))
			return -EINVAL;

		prev_family = ut[i].family;

		switch (ut[i].family) {
		case AF_INET:
			break;
#if IS_ENABLED(CONFIG_IPV6)
		case AF_INET6:
			break;
#endif
		default:
			return -EINVAL;
		}

		switch (ut[i].id.proto) {
		case IPPROTO_AH:
		case IPPROTO_ESP:
		case IPPROTO_COMP:
#if IS_ENABLED(CONFIG_IPV6)
		case IPPROTO_ROUTING:
		case IPPROTO_DSTOPTS:
#endif
		case IPSEC_PROTO_ANY:
			break;
		default:
			return -EINVAL;
		}

	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 99 52.38% 1 25.00%
Américo Wang 45 23.81% 1 25.00%
Steffen Klassert 44 23.28% 1 25.00%
Eric Dumazet 1 0.53% 1 25.00%
Total 189 100.00% 4 100.00%



static int copy_from_user_tmpl(struct xfrm_policy *pol, struct nlattr **attrs)
{
	struct nlattr *rt = attrs[XFRMA_TMPL];

	if (!rt) {
		pol->xfrm_nr = 0;
	} else {
		struct xfrm_user_tmpl *utmpl = nla_data(rt);
		int nr = nla_len(rt) / sizeof(*utmpl);
		int err;

		err = validate_tmpl(nr, utmpl, pol->family);
		if (err)
			return err;

		copy_templates(pol, utmpl, nr);
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 94 92.16% 2 40.00%
Thomas Graf 7 6.86% 2 40.00%
Herbert Xu 1 0.98% 1 20.00%
Total 102 100.00% 5 100.00%



static int copy_from_user_policy_type(u8 *tp, struct nlattr **attrs)
{
	struct nlattr *rt = attrs[XFRMA_POLICY_TYPE];
	struct xfrm_userpolicy_type *upt;
	u8 type = XFRM_POLICY_TYPE_MAIN;
	int err;

	if (rt) {
		upt = nla_data(rt);
		type = upt->type;
	}

	err = verify_policy_type(type);
	if (err)
		return err;

	*tp = type;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Masahide Nakamura 74 92.50% 1 25.00%
Thomas Graf 5 6.25% 2 50.00%
Jamal Hadi Salim 1 1.25% 1 25.00%
Total 80 100.00% 4 100.00%



static void copy_from_user_policy(struct xfrm_policy *xp, struct xfrm_userpolicy_info *p)
{
	xp->priority = p->priority;
	xp->index = p->index;
	memcpy(&xp->selector, &p->sel, sizeof(xp->selector));
	memcpy(&xp->lft, &p->lft, sizeof(xp->lft));
	xp->action = p->action;
	xp->flags = p->flags;
	xp->family = p->sel.family;
	/* XXX xp->share = p->share; */
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 97 97.98% 2 66.67%
Herbert Xu 2 2.02% 1 33.33%
Total 99 100.00% 3 100.00%



static void copy_to_user_policy(struct xfrm_policy *xp, struct xfrm_userpolicy_info *p, int dir)
{
	memset(p, 0, sizeof(*p));
	memcpy(&p->sel, &xp->selector, sizeof(p->sel));
	memcpy(&p->lft, &xp->lft, sizeof(p->lft));
	memcpy(&p->curlft, &xp->curlft, sizeof(p->curlft));
	p->priority = xp->priority;
	p->index = xp->index;
	p->sel.family = xp->family;
	p->dir = dir;
	p->action = xp->action;
	p->flags = xp->flags;
	p->share = XFRM_SHARE_ANY; /* XXX xp->share */
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 132 89.80% 2 50.00%
Mathias Krause 13 8.84% 1 25.00%
Herbert Xu 2 1.36% 1 25.00%
Total 147 100.00% 4 100.00%



static struct xfrm_policy *xfrm_policy_construct(struct net *net, struct xfrm_userpolicy_info *p, struct nlattr **attrs, int *errp)
{
	struct xfrm_policy *xp = xfrm_policy_alloc(net, GFP_KERNEL);
	int err;

	if (!xp) {
		*errp = -ENOMEM;
		return NULL;
	}

	copy_from_user_policy(xp, p);

	err = copy_from_user_policy_type(&xp->type, attrs);
	if (err)
		goto error;

	if (!(err = copy_from_user_tmpl(xp, attrs)))
		err = copy_from_user_sec_ctx(xp, attrs);
	if (err)
		goto error;

	xfrm_mark_get(attrs, &xp->mark);

	return xp;
 error:
	*errp = err;
	xp->walk.dead = 1;
	xfrm_policy_destroy(xp);
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 79 52.32% 1 8.33%
Masahide Nakamura 27 17.88% 1 8.33%
Trent Jaeger 13 8.61% 1 8.33%
Jamal Hadi Salim 10 6.62% 1 8.33%
Alexey Dobriyan 7 4.64% 2 16.67%
Hideaki Yoshifuji / 吉藤英明 6 3.97% 1 8.33%
Thomas Graf 5 3.31% 2 16.67%
Herbert Xu 3 1.99% 2 16.67%
Américo Wang 1 0.66% 1 8.33%
Total 151 100.00% 12 100.00%



static int xfrm_add_policy(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct xfrm_userpolicy_info *p = nlmsg_data(nlh);
	struct xfrm_policy *xp;
	struct km_event c;
	int err;
	int excl;

	err = verify_newpolicy_info(p);
	if (err)
		return err;
	err = verify_sec_ctx_len(attrs);
	if (err)
		return err;

	xp = xfrm_policy_construct(net, p, attrs, &err);
	if (!xp)
		return err;

	/* shouldn't excl be based on nlh flags??
         * Aha! this is anti-netlink really i.e  more pfkey derived
         * in netlink excl is a flag and you wouldnt need
         * a type XFRM_MSG_UPDPOLICY - JHS */
	excl = nlh->nlmsg_type == XFRM_MSG_NEWPOLICY;
	err = xfrm_policy_insert(p->dir, xp, excl);
	xfrm_audit_policy_add(xp, err ? 0 : 1, true);

	if (err) {
		security_xfrm_policy_free(xp->security);
		kfree(xp);
		return err;
	}

	c.event = nlh->nlmsg_type;
	c.seq = nlh->nlmsg_seq;
	c.portid = nlh->nlmsg_pid;
	km_policy_notify(xp, p->dir, &c);

	xfrm_pol_put(xp);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 100 47.85% 1 5.88%
Jamal Hadi Salim 36 17.22% 1 5.88%
Trent Jaeger 24 11.48% 2 11.76%
Alexey Dobriyan 14 6.70% 1 5.88%
Herbert Xu 12 5.74% 2 11.76%
Joy Latten 12 5.74% 2 11.76%
Thomas Graf 5 2.39% 3 17.65%
Paul Moore 2 0.96% 1 5.88%
Lucas De Marchi 1 0.48% 1 5.88%
Eric W. Biedermann 1 0.48% 1 5.88%
Tetsuo Handa 1 0.48% 1 5.88%
Christoph Hellwig 1 0.48% 1 5.88%
Total 209 100.00% 17 100.00%



static int copy_to_user_tmpl(struct xfrm_policy *xp, struct sk_buff *skb)
{
	struct xfrm_user_tmpl vec[XFRM_MAX_DEPTH];
	int i;

	if (xp->xfrm_nr == 0)
		return 0;

	for (i = 0; i < xp->xfrm_nr; i++) {
		struct xfrm_user_tmpl *up = &vec[i];
		struct xfrm_tmpl *kp = &xp->xfrm_vec[i];

		memset(up, 0, sizeof(*up));
		memcpy(&up->id, &kp->id, sizeof(up->id));
		up->family = kp->encap_family;
		memcpy(&up->saddr, &kp->saddr, sizeof(up->saddr));
		up->reqid = kp->reqid;
		up->mode = kp->mode;
		up->share = kp->share;
		up->optional = kp->optional;
		up->aalgos = kp->aalgos;
		up->ealgos = kp->ealgos;
		up->calgos = kp->calgos;
	}

	return nla_put(skb, XFRMA_TMPL,
		       sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr, vec);
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 113 52.56% 1 14.29%
Thomas Graf 43 20.00% 1 14.29%
Trent Jaeger 25 11.63% 1 14.29%
Mathias Krause 13 6.05% 1 14.29%
Herbert Xu 13 6.05% 1 14.29%
John Williams Floroiu 6 2.79% 1 14.29%
Miika Komu 2 0.93% 1 14.29%
Total 215 100.00% 7 100.00%



static inline int copy_to_user_state_sec_ctx(struct xfrm_state *x, struct sk_buff *skb)
{
	if (x->security) {
		return copy_sec_ctx(x->security, skb);
	}
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Serge E. Hallyn 38 100.00% 1 100.00%
Total 38 100.00% 1 100.00%



static inline int copy_to_user_sec_ctx(struct xfrm_policy *xp, struct sk_buff *skb)
{
	if (xp->security)
		return copy_sec_ctx(xp->security, skb);
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Serge E. Hallyn 36 100.00% 1 100.00%
Total 36 100.00% 1 100.00%



static inline unsigned int userpolicy_type_attrsize(void)
{
#ifdef CONFIG_XFRM_SUB_POLICY
	return nla_total_size(sizeof(struct xfrm_userpolicy_type));
#else
	return 0;
#endif
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Graf 28 93.33% 1 50.00%
Alexey Dobriyan 2 6.67% 1 50.00%
Total 30 100.00% 2 100.00%

#ifdef CONFIG_XFRM_SUB_POLICY


static int copy_to_user_policy_type(u8 type, struct sk_buff *skb)
{
	struct xfrm_userpolicy_type upt = {
		.type = type,
        };

	return nla_put(skb, XFRMA_POLICY_TYPE, sizeof(upt), &upt);
}

Contributors
Person Tokens Prop Commits CommitProp
Masahide Nakamura 33 80.49% 1 25.00%
Thomas Graf 6 14.63% 1 25.00%
Jamal Hadi Salim 2 4.88% 2 50.00%
Total 41 100.00% 4 100.00%

#else


static inline int copy_to_user_policy_type(u8 type, struct sk_buff *skb)
{
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Masahide Nakamura 16 88.89% 1 33.33%
Jamal Hadi Salim 2 11.11% 2 66.67%
Total 18 100.00% 3 100.00%

#endif



static int dump_one_policy(struct xfrm_policy *xp, int dir, int count, void *ptr)
{
	struct xfrm_dump_info *sp = ptr;
	struct xfrm_userpolicy_info *p;
	struct sk_buff *in_skb = sp->in_skb;
	struct sk_buff *skb = sp->out_skb;
	struct nlmsghdr *nlh;
	int err;

	nlh = nlmsg_put(skb, NETLINK_CB(in_skb).portid, sp->nlmsg_seq,
			XFRM_MSG_NEWPOLICY, sizeof(*p), sp->nlmsg_flags);
	if (nlh == NULL)
		return -EMSGSIZE;

	p = nlmsg_data(nlh);
	copy_to_user_policy(xp, p, dir);
	err = copy_to_user_tmpl(xp, skb);
	if (!err)
		err = copy_to_user_sec_ctx(xp, skb);
	if (!err)
		err = copy_to_user_policy_type(xp->type, skb);
	if (!err)
		err = xfrm_mark_put(skb, &xp->mark);
	if (err) {
		nlmsg_cancel(skb, nlh);
		return err;
	}
	nlmsg_end(skb, nlh);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 100 50.76% 1 8.33%
David S. Miller 45 22.84% 2 16.67%
Thomas Graf 19 9.64% 3 25.00%
Jamal Hadi Salim 14 7.11% 2 16.67%
Trent Jaeger 8 4.06% 1 8.33%
Masahide Nakamura 8 4.06% 1 8.33%
Arnaldo Carvalho de Melo 2 1.02% 1 8.33%
Eric W. Biedermann 1 0.51% 1 8.33%
Total 197 100.00% 12 100.00%



static int xfrm_dump_policy_done(struct netlink_callback *cb)
{
	struct xfrm_policy_walk *walk = (struct xfrm_policy_walk *)cb->args;
	struct net *net = sock_net(cb->skb->sk);

	xfrm_policy_walk_done(walk, net);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Timo Teräs 33 67.35% 1 50.00%
Fan Du 16 32.65% 1 50.00%
Total 49 100.00% 2 100.00%



static int xfrm_dump_policy_start(struct netlink_callback *cb)
{
	struct xfrm_policy_walk *walk = (struct xfrm_policy_walk *)cb->args;

	BUILD_BUG_ON(sizeof(*walk) > sizeof(cb->args));

	xfrm_policy_walk_init(walk, XFRM_POLICY_TYPE_ANY);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 51 100.00% 1 100.00%
Total 51 100.00% 1 100.00%



static int xfrm_dump_policy(struct sk_buff *skb, struct netlink_callback *cb)
{
	struct net *net = sock_net(skb->sk);
	struct xfrm_policy_walk *walk = (struct xfrm_policy_walk *)cb->args;
	struct xfrm_dump_info info;

	info.in_skb = cb->skb;
	info.out_skb = skb;
	info.nlmsg_seq = cb->nlh->nlmsg_seq;
	info.nlmsg_flags = NLM_F_MULTI;

	(void) xfrm_policy_walk(net, walk, dump_one_policy, &info);

	return skb->len;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 51 53.12% 1 16.67%
Timo Teräs 15 15.62% 1 16.67%
Alexey Dobriyan 14 14.58% 2 33.33%
Masahide Nakamura 12 12.50% 1 16.67%
Harald Welte 4 4.17% 1 16.67%
Total 96 100.00% 6 100.00%



static struct sk_buff *xfrm_policy_netlink(struct sk_buff *in_skb,
					  struct xfrm_policy *xp,
					  int dir, u32 seq)
{
	struct xfrm_dump_info info;
	struct sk_buff *skb;
	int err;

	skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
	if (!skb)
		return ERR_PTR(-ENOMEM);

	info.in_skb = in_skb;
	info.out_skb = skb;
	info.nlmsg_seq = seq;
	info.nlmsg_flags = 0;

	err = dump_one_policy(xp, dir, 0, &info);
	if (err) {
		kfree_skb(skb);
		return ERR_PTR(err);
	}

	return skb;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 96 83.48% 1 25.00%
Mathias Krause 13 11.30% 1 25.00%
Harald Welte 4 3.48% 1 25.00%
Thomas Graf 2 1.74% 1 25.00%
Total 115 100.00% 4 100.00%



static int xfrm_get_policy(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct xfrm_policy *xp;
	struct xfrm_userpolicy_id *p;
	u8 type = XFRM_POLICY_TYPE_MAIN;
	int err;
	struct km_event c;
	int delete;
	struct xfrm_mark m;
	u32 mark = xfrm_mark_get(attrs, &m);

	p = nlmsg_data(nlh);
	delete = nlh->nlmsg_type == XFRM_MSG_DELPOLICY;

	err = copy_from_user_policy_type(&type, attrs);
	if (err)
		return err;

	err = verify_policy_dir(p->dir);
	if (err)
		return err;

	if (p->index)
		xp = xfrm_policy_byid(net, mark, type, p->dir, p->index, delete, &err);
	else {
		struct nlattr *rt = attrs[XFRMA_SEC_CTX];
		struct xfrm_sec_ctx *ctx;

		err = verify_sec_ctx_len(attrs);
		if (err)
			return err;

		ctx = NULL;
		if (rt) {
			struct xfrm_user_sec_ctx *uctx = nla_data(rt);

			err = security_xfrm_policy_alloc(&ctx, uctx, GFP_KERNEL);
			if (err)
				return err;
		}
		xp = xfrm_policy_bysel_ctx(net, mark, type, p->dir, &p->sel,
					   ctx, delete, &err);
		security_xfrm_policy_free(ctx);
	}
	if (xp == NULL)
		return -ENOENT;

	if (!delete) {
		struct sk_buff *resp_skb;

		resp_skb = xfrm_policy_netlink(skb, xp, p->dir, nlh->nlmsg_seq);
		if (IS_ERR(resp_skb)) {
			err = PTR_ERR(resp_skb);
		} else {
			err = nlmsg_unicast(net->xfrm.nlsk, resp_skb,
					    NETLINK_CB(skb).portid);
		}
	} else {
		xfrm_audit_policy_delete(xp, err ? 0 : 1, true);

		if (err != 0)
			goto out;

		c.data.byid = p->index;
		c.event = nlh->nlmsg_type;
		c.seq = nlh->nlmsg_seq;
		c.portid = nlh->nlmsg_pid;
		km_policy_notify(xp, p->dir, &c);
	}

out:
	xfrm_pol_put(xp);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 127 30.68% 3 10.34%
Herbert Xu 75 18.12% 4 13.79%
Jamal Hadi Salim 59 14.25% 4 13.79%
Trent Jaeger 58 14.01% 1 3.45%
Masahide Nakamura 24 5.80% 1 3.45%
Alexey Dobriyan 21 5.07% 3 10.34%
Paul Moore 10 2.42% 1 3.45%
Joy Latten 9 2.17% 1 3.45%
Thomas Graf 9 2.17% 4 13.79%
Eric Paris 8 1.93% 1 3.45%
Catherine Zhang 4 0.97% 1 3.45%
Denis V. Lunev 4 0.97% 1 3.45%
Eric W. Biedermann 2 0.48% 1 3.45%
Nikolay Aleksandrov 2 0.48% 1 3.45%
Christoph Hellwig 1 0.24% 1 3.45%
Tetsuo Handa 1 0.24% 1 3.45%
Total 414 100.00% 29 100.00%



static int xfrm_flush_sa(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct km_event c;
	struct xfrm_usersa_flush *p = nlmsg_data(nlh);
	int err;

	err = xfrm_state_flush(net, p->proto, true);
	if (err) {
		if (err == -ESRCH) /* empty table */
			return 0;
		return err;
	}
	c.data.proto = p->proto;
	c.event = nlh->nlmsg_type;
	c.seq = nlh->nlmsg_seq;
	c.portid = nlh->nlmsg_pid;
	c.net = net;
	km_state_notify(NULL, &c);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 65 48.15% 3 18.75%
Herbert Xu 31 22.96% 1 6.25%
Alexey Dobriyan 20 14.81% 3 18.75%
Joy Latten 12 8.89% 2 12.50%
Thomas Graf 3 2.22% 3 18.75%
Tetsuo Handa 1 0.74% 1 6.25%
Christoph Hellwig 1 0.74% 1 6.25%
David S. Miller 1 0.74% 1 6.25%
Eric W. Biedermann 1 0.74% 1 6.25%
Total 135 100.00% 16 100.00%



static inline unsigned int xfrm_aevent_msgsize(struct xfrm_state *x)
{
	unsigned int replay_size = x->replay_esn ?
			      xfrm_replay_state_esn_len(x->replay_esn) :
			      sizeof(struct xfrm_replay_state);

	return NLMSG_ALIGN(sizeof(struct xfrm_aevent_id))
	       + nla_total_size(replay_size)
	       + nla_total_size_64bit(sizeof(struct xfrm_lifetime_cur))
	       + nla_total_size(sizeof(struct xfrm_mark))
	       + nla_total_size(4) /* XFRM_AE_RTHR */
	       + nla_total_size(4); /* XFRM_AE_ETHR */
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Graf 41 51.90% 1 20.00%
Steffen Klassert 24 30.38% 1 20.00%
Jamal Hadi Salim 9 11.39% 1 20.00%
Alexey Dobriyan 4 5.06% 1 20.00%
Nicolas Dichtel 1 1.27% 1 20.00%
Total 79 100.00% 5 100.00%



static int build_aevent(struct sk_buff *skb, struct xfrm_state *x, const struct km_event *c)
{
	struct xfrm_aevent_id *id;
	struct nlmsghdr *nlh;
	int err;

	nlh = nlmsg_put(skb, c->portid, c->seq, XFRM_MSG_NEWAE, sizeof(*id), 0);
	if (nlh == NULL)
		return -EMSGSIZE;

	id = nlmsg_data(nlh);
	memset(&id->sa_id, 0, sizeof(id->sa_id));
	memcpy(&id->sa_id.daddr, &x->id.daddr, sizeof(x->id.daddr));
	id->sa_id.spi = x->id.spi;
	id->sa_id.family = x->props.family;
	id->sa_id.proto = x->id.proto;
	memcpy(&id->saddr, &x->props.saddr, sizeof(x->props.saddr));
	id->reqid = x->props.reqid;
	id->flags = c->data.aevent;

	if (x->replay_esn) {
		err = nla_put(skb, XFRMA_REPLAY_ESN_VAL,
			      xfrm_replay_state_esn_len(x->replay_esn),
			      x->replay_esn);
	} else {
		err = nla_put(skb, XFRMA_REPLAY_VAL, sizeof(x->replay),
			      &x->replay);
	}
	if (err)
		goto out_cancel;
	err = nla_put_64bit(skb, XFRMA_LTIME_VAL, sizeof(x->curlft), &x->curlft,
			    XFRMA_PAD);
	if (err)
		goto out_cancel;

	if (id->flags & XFRM_AE_RTHR) {
		err = nla_put_u32(skb, XFRMA_REPLAY_THRESH, x->replay_maxdiff);
		if (err)
			goto out_cancel;
	}
	if (id->flags & XFRM_AE_ETHR) {
		err = nla_put_u32(skb, XFRMA_ETIMER_THRESH,
				  x->replay_maxage * 10 / HZ);
		if (err)
			goto out_cancel;
	}
	err = xfrm_mark_put(skb, &x->mark);
	if (err)
		goto out_cancel;

	nlmsg_end(skb, nlh);
	return 0;

out_cancel:
	nlmsg_cancel(skb, nlh);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 245 62.18% 3 18.75%
David S. Miller 70 17.77% 3 18.75%
Thomas Graf 30 7.61% 4 25.00%
Steffen Klassert 23 5.84% 1 6.25%
Mathias Krause 17 4.31% 1 6.25%
Nicolas Dichtel 3 0.76% 1 6.25%
Johannes Berg 3 0.76% 1 6.25%
Arnaldo Carvalho de Melo 2 0.51% 1 6.25%
Eric W. Biedermann 1 0.25% 1 6.25%
Total 394 100.00% 16 100.00%



static int xfrm_get_ae(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct xfrm_state *x;
	struct sk_buff *r_skb;
	int err;
	struct km_event c;
	u32 mark;
	struct xfrm_mark m;
	struct xfrm_aevent_id *p = nlmsg_data(nlh);
	struct xfrm_usersa_id *id = &p->sa_id;

	mark = xfrm_mark_get(attrs, &m);

	x = xfrm_state_lookup(net, mark, &id->daddr, id->spi, id->proto, id->family);
	if (x == NULL)
		return -ESRCH;

	r_skb = nlmsg_new(xfrm_aevent_msgsize(x), GFP_ATOMIC);
	if (r_skb == NULL) {
		xfrm_state_put(x);
		return -ENOMEM;
	}

	/*
         * XXX: is this lock really needed - none of the other
         * gets lock (the concern is things getting updated
         * while we are still reading) - jhs
        */
	spin_lock_bh(&x->lock);
	c.data.aevent = p->flags;
	c.seq = nlh->nlmsg_seq;
	c.portid = nlh->nlmsg_pid;

	err = build_aevent(r_skb, x, &c);
	BUG_ON(err < 0);

	err = nlmsg_unicast(net->xfrm.nlsk, r_skb, NETLINK_CB(skb).portid);
	spin_unlock_bh(&x->lock);
	xfrm_state_put(x);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 184 75.72% 3 21.43%
Steffen Klassert 25 10.29% 1 7.14%
Alexey Dobriyan 20 8.23% 3 21.43%
Gustavo A. R. Silva 7 2.88% 1 7.14%
Thomas Graf 4 1.65% 4 28.57%
Eric W. Biedermann 2 0.82% 1 7.14%
Christoph Hellwig 1 0.41% 1 7.14%
Total 243 100.00% 14 100.00%



static int xfrm_new_ae(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct xfrm_state *x;
	struct km_event c;
	int err = -EINVAL;
	u32 mark = 0;
	struct xfrm_mark m;
	struct xfrm_aevent_id *p = nlmsg_data(nlh);
	struct nlattr *rp = attrs[XFRMA_REPLAY_VAL];
	struct nlattr *re = attrs[XFRMA_REPLAY_ESN_VAL];
	struct nlattr *lt = attrs[XFRMA_LTIME_VAL];
	struct nlattr *et = attrs[XFRMA_ETIMER_THRESH];
	struct nlattr *rt = attrs[XFRMA_REPLAY_THRESH];

	if (!lt && !rp && !re && !et && !rt)
		return err;

	/* pedantic mode - thou shalt sayeth replaceth */
	if (!(nlh->nlmsg_flags&NLM_F_REPLACE))
		return err;

	mark = xfrm_mark_get(attrs, &m);

	x = xfrm_state_lookup(net, mark, &p->sa_id.daddr, p->sa_id.spi, p->sa_id.proto, p->sa_id.family);
	if (x == NULL)
		return -ESRCH;

	if (x->km.state != XFRM_STATE_VALID)
		goto out;

	err = xfrm_replay_verify_len(x->replay_esn, re);
	if (err)
		goto out;

	spin_lock_bh(&x->lock);
	xfrm_update_ae_params(x, attrs, 1);
	spin_unlock_bh(&x->lock);

	c.event = nlh->nlmsg_type;
	c.seq = nlh->nlmsg_seq;
	c.portid = nlh->nlmsg_pid;
	c.data.aevent = XFRM_AE_CU;
	km_state_notify(x, &c);
	err = 0;
out:
	xfrm_state_put(x);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 225 70.98% 4 22.22%
Steffen Klassert 31 9.78% 3 16.67%
Michael Rossberg 26 8.20% 1 5.56%
Alexey Dobriyan 15 4.73% 2 11.11%
Thomas Graf 8 2.52% 3 16.67%
Herbert Xu 8 2.52% 2 11.11%
Mathias Krause 2 0.63% 1 5.56%
Christoph Hellwig 1 0.32% 1 5.56%
Eric W. Biedermann 1 0.32% 1 5.56%
Total 317 100.00% 18 100.00%



static int xfrm_flush_policy(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct km_event c;
	u8 type = XFRM_POLICY_TYPE_MAIN;
	int err;

	err = copy_from_user_policy_type(&type, attrs);
	if (err)
		return err;

	err = xfrm_policy_flush(net, type, true);
	if (err) {
		if (err == -ESRCH) /* empty table */
			return 0;
		return err;
	}

	c.data.type = type;
	c.event = nlh->nlmsg_type;
	c.seq = nlh->nlmsg_seq;
	c.portid = nlh->nlmsg_pid;
	c.net = net;
	km_policy_notify(NULL, 0, &c);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 48 33.10% 3 17.65%
Masahide Nakamura 34 23.45% 1 5.88%
Herbert Xu 27 18.62% 2 11.76%
Alexey Dobriyan 20 13.79% 3 17.65%
Joy Latten 9 6.21% 2 11.76%
Thomas Graf 3 2.07% 2 11.76%
Christoph Hellwig 1 0.69% 1 5.88%
Tetsuo Handa 1 0.69% 1 5.88%
Eric W. Biedermann 1 0.69% 1 5.88%
David S. Miller 1 0.69% 1 5.88%
Total 145 100.00% 17 100.00%



static int xfrm_add_pol_expire(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct xfrm_policy *xp;
	struct xfrm_user_polexpire *up = nlmsg_data(nlh);
	struct xfrm_userpolicy_info *p = &up->pol;
	u8 type = XFRM_POLICY_TYPE_MAIN;
	int err = -ENOENT;
	struct xfrm_mark m;
	u32 mark = xfrm_mark_get(attrs, &m);

	err = copy_from_user_policy_type(&type, attrs);
	if (err)
		return err;

	err = verify_policy_dir(p->dir);
	if (err)
		return err;

	if (p->index)
		xp = xfrm_policy_byid(net, mark, type, p->dir, p->index, 0, &err);
	else {
		struct nlattr *rt = attrs[XFRMA_SEC_CTX];
		struct xfrm_sec_ctx *ctx;

		err = verify_sec_ctx_len(attrs);
		if (err)
			return err;

		ctx = NULL;
		if (rt) {
			struct xfrm_user_sec_ctx *uctx = nla_data(rt);

			err = security_xfrm_policy_alloc(&ctx, uctx, GFP_KERNEL);
			if (err)
				return err;
		}
		xp = xfrm_policy_bysel_ctx(net, mark, type, p->dir,
					   &p->sel, ctx, 0, &err);
		security_xfrm_policy_free(ctx);
	}
	if (xp == NULL)
		return -ENOENT;

	if (unlikely(xp->walk.dead))
		goto out;

	err = 0;
	if (up->hard) {
		xfrm_policy_delete(xp, p->dir);
		xfrm_audit_policy_delete(xp, 1, true);
	}
	km_policy_expired(xp, p->dir, up->hard, nlh->nlmsg_pid);

out:
	xfrm_pol_put(xp);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 227 68.37% 4 18.18%
Masahide Nakamura 24 7.23% 1 4.55%
Timo Teräs 19 5.72% 2 9.09%
Alexey Dobriyan 16 4.82% 2 9.09%
Paul Moore 10 3.01% 1 4.55%
Joy Latten 8 2.41% 2 9.09%
Thomas Graf 8 2.41% 3 13.64%
Eric Paris 8 2.41% 1 4.55%
Denis V. Lunev 4 1.20% 1 4.55%
Herbert Xu 2 0.60% 1 4.55%
Eric W. Biedermann 2 0.60% 1 4.55%
Nikolay Aleksandrov 2 0.60% 1 4.55%
Tetsuo Handa 1 0.30% 1 4.55%
Christoph Hellwig 1 0.30% 1 4.55%
Total 332 100.00% 22 100.00%



static int xfrm_add_sa_expire(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct xfrm_state *x;
	int err;
	struct xfrm_user_expire *ue = nlmsg_data(nlh);
	struct xfrm_usersa_info *p = &ue->state;
	struct xfrm_mark m;
	u32 mark = xfrm_mark_get(attrs, &m);

	x = xfrm_state_lookup(net, mark, &p->id.daddr, p->id.spi, p->id.proto, p->family);

	err = -ENOENT;
	if (x == NULL)
		return err;

	spin_lock_bh(&x->lock);
	err = -EINVAL;
	if (x->km.state != XFRM_STATE_VALID)
		goto out;
	km_state_expired(x, ue->hard, nlh->nlmsg_pid);

	if (ue->hard) {
		__xfrm_state_delete(x);
		xfrm_audit_state_delete(x, 1, true);
	}
	err = 0;
out:
	spin_unlock_bh(&x->lock);
	xfrm_state_put(x);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 165 80.10% 3 21.43%
Alexey Dobriyan 15 7.28% 2 14.29%
Joy Latten 10 4.85% 2 14.29%
David S. Miller 9 4.37% 1 7.14%
Thomas Graf 3 1.46% 3 21.43%
Eric W. Biedermann 2 0.97% 1 7.14%
Tetsuo Handa 1 0.49% 1 7.14%
Christoph Hellwig 1 0.49% 1 7.14%
Total 206 100.00% 14 100.00%



static int xfrm_add_acquire(struct sk_buff *skb, struct nlmsghdr *nlh,
		struct nlattr **attrs)
{
	struct net *net = sock_net(skb->sk);
	struct xfrm_policy *xp;
	struct xfrm_user_tmpl *ut;
	int i;
	struct nlattr *rt = attrs[XFRMA_TMPL];
	struct xfrm_mark mark;

	struct xfrm_user_acquire *ua = nlmsg_data(nlh);
	struct xfrm_state *x = xfrm_state_alloc(net);
	int err = -ENOMEM;

	if (!x)
		goto nomem;

	xfrm_mark_get(attrs, &mark);

	err = verify_newpolicy_info(&ua->policy);
	if (err)
		goto free_state;

	/*   build an XP */
	xp = xfrm_policy_construct(net, &ua->policy, attrs, &err);
	if (!xp)
		goto free_state;

	memcpy(&x->id, &ua->id, sizeof(ua->id));
	memcpy(&x->props.saddr, &ua->saddr, sizeof(ua->saddr));
	memcpy(&x->sel, &ua->sel, sizeof(ua->sel));
	xp->mark.m = x->mark.m = mark.m;
	xp->mark.v = x->mark.v = mark.v;
	ut = nla_data(rt);
	/* extract the templates and for each call km_key */
	for (i = 0; i < xp->xfrm_nr; i++, ut++) {
		struct xfrm_tmpl *t = &xp->xfrm_vec[i];
		memcpy(&x->id, &t->id, sizeof(x->id));
		x->props.mode = t->mode;
		x->props.reqid = t->reqid;
		x->props.family = ut->family;
		t->aalgos = ua->aalgos;
		t->ealgos = ua->ealgos;
		t->calgos = ua->calgos;
		err = km_query(x, t, xp);

	}

	kfree(x);
	kfree(xp);

	return 0;

free_state:
	kfree(x);
nomem:
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 324 82.86% 2 16.67%
Thomas Graf 20 5.12% 4 33.33%
Ilpo Järvinen 20 5.12% 1 8.33%
Alexey Dobriyan 17 4.35% 2 16.67%
Shinta Sugimoto 8 2.05% 1 8.33%
Christoph Hellwig 1 0.26% 1 8.33%
Vegard Nossum 1 0.26% 1 8.33%
Total 391 100.00% 12 100.00%

#ifdef CONFIG_XFRM_MIGRATE


static int copy_from_user_migrate(struct xfrm_migrate *ma,
				  struct xfrm_kmaddress *k,
				  struct nlattr **attrs, int *num)
{
	struct nlattr *rt = attrs[XFRMA_MIGRATE];
	struct xfrm_user_migrate *um;
	int i, num_migrate;

	if (k != NULL) {
		struct xfrm_user_kmaddress *uk;

		uk = nla_data(attrs[XFRMA_KMADDRESS]);
		memcpy(&k->local, &uk->local, sizeof(k->local));
		memcpy(&k->remote, &uk->remote, sizeof(k->remote));
		k->family = uk->family;
		k->reserved = uk->reserved;
	}

	um = nla_data(rt);
	num_migrate = nla_len(rt) / sizeof(*um);

	if (num_migrate <= 0 || num_migrate > XFRM_MAX_DEPTH)
		return -EINVAL;

	for (i = 0; i < num_migrate; i++, um++, ma++) {
		memcpy(&ma->old_daddr, &um->old_daddr, sizeof(ma->old_daddr));
		memcpy(&ma->old_saddr, &um->old_saddr, sizeof(ma->old_saddr));
		memcpy(&ma->new_daddr, &um->new_daddr, sizeof(ma->new_daddr));
		memcpy(&ma->new_saddr, &um->new_saddr, sizeof(ma->new_saddr));

		ma->proto = um->proto;
		ma->mode = um->mode;
		ma->reqid = um->reqid;

		ma->old_family = um->old_family;
		ma->new_family = um->new_family;
	}

	*num = i;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Shinta Sugimoto 218 70.78% 1 25.00%
Arnaud Ebalard 84 27.27% 1 25.00%
Thomas Graf 6 1.95% 2 50.00%
Total 308 100.00% 4 100.00%



static int xfrm_do_migrate(struct sk_buff *skb, struct nlmsghdr *nlh,
			   struct nlattr **attrs)
{
	struct xfrm_userpolicy_id *pi = nlmsg_data(nlh);
	struct xfrm_migrate m[XFRM_MAX_DEPTH];
	struct xfrm_kmaddress km, *kmp;
	u8 type;
	int err;
	int n = 0;
	struct net *net = sock_net(skb->sk);
	struct xfrm_encap_tmpl  *encap = NULL;

	if (attrs[XFRMA_MIGRATE] == NULL)
		return -EINVAL;

	kmp = attrs[XFRMA_KMADDRESS] ? &km : NULL;

	err = copy_from_user_policy_type(&type, attrs);
	if (err)
		return err;

	err = copy_from_user_migrate((struct xfrm_migrate *)m, kmp, attrs, &n);
	if (err)
		return err;

	if (!n)
		return 0;

	if (attrs[XFRMA_ENCAP]) {
		encap = kmemdup(nla_data(attrs[XFRMA_ENCAP]),
				sizeof(*encap), GFP_KERNEL);
		if (!encap)
			return 0;
	}

	err = xfrm_migrate(&pi->sel, pi->dir, type, m, n, kmp, net, encap);

	kfree(encap);

	return err;
}
Contributors
Person Tokens Prop Commits CommitProp
Shinta Sugimoto 119 53.12% 1 12.50%
Antony Antony 55 24.55% 1 12.50%
Arnaud Ebalard 23 10.27% 1 12.50%
Fan Du 14 6.25% 1 12.50%
Thomas Graf 13 5.80% 4 50.00%
Total 224 100.00% 8 100.00%

#else


static int xfrm_do_migrate(struct sk_buff *skb, struct nlmsghdr *nlh,
			   struct nlattr **attrs)
{
	return -ENOPROTOOPT;
}
Contributors
Person Tokens Prop Commits CommitProp
Shinta Sugimoto 24 92.31% 1 33.33%
Thomas Graf 2 7.69% 2 66.67%
Total 26 100.00% 3 100.00%

#endif

#ifdef CONFIG_XFRM_MIGRATE


static int copy_to_user_migrate(const struct xfrm_migrate *m, struct sk_buff *skb)
{
	struct xfrm_user_migrate um;

	memset(&um, 0, sizeof(um));
	um.proto = m->proto;
	um.mode = m->mode;
	um.reqid = m->reqid;
	um.old_family = m->old_family;
	memcpy(&um.old_daddr, &m->old_daddr, sizeof(um.old_daddr));
	memcpy(&um.old_saddr, &m->old_saddr, sizeof(um.old_saddr));
	um.new_family = m->new_family;
	memcpy(&um.new_daddr, &m->new_daddr, sizeof(um.new_daddr));
	memcpy(&um.new_saddr, &m->new_saddr, sizeof(um.new_saddr));

	return nla_put(skb, XFRMA_MIGRATE, sizeof(um), &um);
}

Contributors
Person Tokens Prop Commits CommitProp
Shinta Sugimoto 167 98.24% 1 33.33%
Thomas Graf 2 1.18% 1 33.33%
David S. Miller 1 0.59% 1 33.33%
Total 170 100.00% 3 100.00%



static int copy_to_user_kmaddress(const struct xfrm_kmaddress *k, struct sk_buff *skb)
{
	struct xfrm_user_kmaddress uk;

	memset(&uk, 0, sizeof(uk));
	uk.family = k->family;
	uk.reserved = k->reserved;
	memcpy(&uk.local, &k->local, sizeof(uk.local));
	memcpy(&uk.remote, &k->remote, sizeof(uk.remote));

	return nla_put(skb, XFRMA_KMADDRESS, sizeof(uk), &uk);
}

Contributors
Person Tokens Prop Commits CommitProp
Arnaud Ebalard 105 99.06% 2 66.67%
David S. Miller 1 0.94% 1 33.33%
Total 106 100.00% 3 100.00%



static inline unsigned int xfrm_migrate_msgsize(int num_migrate, int with_kma,
						int with_encp)
{
	return NLMSG_ALIGN(sizeof(struct xfrm_userpolicy_id))
	      + (with_kma ? nla_total_size(sizeof(struct xfrm_kmaddress)) : 0)
	      + (with_encp ? nla_total_size(sizeof(struct xfrm_encap_tmpl)) : 0)
	      + nla_total_size(sizeof(struct xfrm_user_migrate) * num_migrate)
	      + userpolicy_type_attrsize();
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Graf 31 43.66% 1 20.00%
Antony Antony 18 25.35% 1 20.00%
Arnaud Ebalard 18 25.35% 1 20.00%
Alexey Dobriyan 2 2.82% 1 20.00%
Shinta Sugimoto 2 2.82% 1 20.00%
Total 71 100.00% 5 100.00%



static int build_migrate(struct sk_buff *skb, const struct xfrm_migrate *m,
			 int num_migrate, const struct xfrm_kmaddress *k,
			 const struct xfrm_selector *sel,
			 const struct xfrm_encap_tmpl *encap, u8 dir, u8 type)
{
	const struct xfrm_migrate *mp;
	struct xfrm_userpolicy_id *pol_id;
	struct nlmsghdr *nlh;
	int i, err;

	nlh = nlmsg_put(skb, 0, 0, XFRM_MSG_MIGRATE, sizeof(*pol_id), 0);
	if (nlh == NULL)
		return -EMSGSIZE;

	pol_id = nlmsg_data(nlh);
	/* copy data from selector, dir, and type to the pol_id */
	memset(pol_id, 0, sizeof(*pol_id));
	memcpy(&pol_id->sel, sel, sizeof(pol_id->sel));
	pol_id->dir = dir;

	if (k != NULL) {
		err = copy_to_user_kmaddress(k, skb);
		if (err)
			goto out_cancel;
	}
	if (encap) {
		err = nla_put(skb, XFRMA_ENCAP, sizeof(*encap), encap);
		if (err)
			goto out_cancel;
	}
	err = copy_to_user_policy_type(type, skb);
	if (err)
		goto out_cancel;
	for (i = 0, mp = m ; i < num_migrate; i++, mp++) {
		err = copy_to_user_migrate(mp, skb);
		if (err)
			goto out_cancel;
	}

	nlmsg_end(skb, nlh);
	return 0;

out_cancel:
	nlmsg_cancel(skb, nlh);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Shinta Sugimoto 149 55.19% 1 9.09%
Antony Antony 36 13.33% 1 9.09%
David S. Miller 32 11.85% 2 18.18%
Thomas Graf 31 11.48% 4 36.36%
Arnaud Ebalard 17 6.30% 1 9.09%
Johannes Berg 3 1.11% 1 9.09%
Arnaldo Carvalho de Melo 2 0.74% 1 9.09%
Total 270 100.00% 11 100.00%



static int xfrm_send_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
			     const struct xfrm_migrate *m, int num_migrate,
			     const struct xfrm_kmaddress *k,
			     const struct xfrm_encap_tmpl *encap)
{
	struct net *net = &init_net;
	struct sk_buff *skb;
	int err;

	skb = nlmsg_new(xfrm_migrate_msgsize(num_migrate, !!k, !!encap),
			GFP_ATOMIC);
	if (skb == NULL)
		return -ENOMEM;

	/* build migrate */
	err = build_migrate(skb, m, num_migrate, k, sel, encap, dir, type);
	BUG_ON(err < 0);

	return xfrm_nlmsg_multicast(net, skb, 0, XFRMNLGRP_MIGRATE);
}
Contributors
Person Tokens Prop Commits CommitProp
Shinta Sugimoto 77 61.11% 1 12.50%
Antony Antony 12 9.52% 1 12.50%
Arnaud Ebalard 11 8.73% 1 12.50%
Gustavo A. R. Silva 10 7.94% 1 12.50%
Alexey Dobriyan 9 7.14% 1 12.50%
David S. Miller 3 2.38% 1 12.50%
Thomas Graf 3 2.38% 1 12.50%
Michal Kubeček 1 0.79% 1 12.50%
Total 126 100.00% 8 100.00%

#else


static int xfrm_send_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
			     const struct xfrm_migrate *m, int num_migrate,
			     const struct xfrm_kmaddress *k,
			     const struct xfrm_encap_tmpl *encap)
{
	return -ENOPROTOOPT;
}
Contributors
Person Tokens Prop Commits CommitProp
Shinta Sugimoto 29 67.44% 1 25.00%
Antony Antony 6 13.95% 1 25.00%
Arnaud Ebalard 5 11.63% 1 25.00%
David S. Miller 3 6.98% 1 25.00%
Total 43 100.00% 4 100.00%

#endif


#define XMSGSIZE(type) sizeof(struct type)


static const int xfrm_msg_min[XFRM_NR_MSGTYPES] = {
	[XFRM_MSG_NEWSA       - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_info),
	[XFRM_MSG_DELSA       - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_id),
	[XFRM_MSG_GETSA       - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_id),
	[XFRM_MSG_NEWPOLICY   - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_info),
	[XFRM_MSG_DELPOLICY   - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_id),
	[XFRM_MSG_GETPOLICY   - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_id),
	[XFRM_MSG_ALLOCSPI    - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userspi_info),
	[XFRM_MSG_ACQUIRE     - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_acquire),
	[XFRM_MSG_EXPIRE      - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_expire),
	[XFRM_MSG_UPDPOLICY   - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_info),
	[XFRM_MSG_UPDSA       - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_info),
	[XFRM_MSG_POLEXPIRE   - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_polexpire),
	[XFRM_MSG_FLUSHSA     - XFRM_MSG_BASE] = XMSGSIZE(xfrm_usersa_flush),
	[XFRM_MSG_FLUSHPOLICY - XFRM_MSG_BASE] = 0,
	[XFRM_MSG_NEWAE       - XFRM_MSG_BASE] = XMSGSIZE(xfrm_aevent_id),
	[XFRM_MSG_GETAE       - XFRM_MSG_BASE] = XMSGSIZE(xfrm_aevent_id),
	[XFRM_MSG_REPORT      - XFRM_MSG_BASE] = XMSGSIZE(xfrm_user_report),
	[XFRM_MSG_MIGRATE     - XFRM_MSG_BASE] = XMSGSIZE(xfrm_userpolicy_id),
	[XFRM_MSG_GETSADINFO  - XFRM_MSG_BASE] = sizeof(u32),
	[XFRM_MSG_NEWSPDINFO  - XFRM_MSG_BASE] = sizeof(u32),
	[XFRM_MSG_GETSPDINFO  - XFRM_MSG_BASE] = sizeof(u32),
};


#undef XMSGSIZE


static const struct nla_policy xfrma_policy[XFRMA_MAX+1] = {
	[XFRMA_SA]		= { .len = sizeof(struct xfrm_usersa_info)},
	[XFRMA_POLICY]		= { .len = sizeof(struct xfrm_userpolicy_info)},
	[XFRMA_LASTUSED]	= { .type = NLA_U64},
	[XFRMA_ALG_AUTH_TRUNC]	= { .len = sizeof(struct xfrm_algo_auth)},
	[XFRMA_ALG_AEAD]	= { .len = sizeof(struct xfrm_algo_aead) },
	[XFRMA_ALG_AUTH]	= { .len = sizeof(struct xfrm_algo) },
	[XFRMA_ALG_CRYPT]	= { .len = sizeof(struct xfrm_algo) },
	[XFRMA_ALG_COMP]	= { .len = sizeof(struct xfrm_algo) },
	[XFRMA_ENCAP]		= { .len = sizeof(struct xfrm_encap_tmpl) },
	[XFRMA_TMPL]		= { .len = sizeof(struct xfrm_user_tmpl) },
	[XFRMA_SEC_CTX]		= { .len = sizeof(struct xfrm_sec_ctx) },
	[XFRMA_LTIME_VAL]	= { .len = sizeof(struct xfrm_lifetime_cur) },
	[XFRMA_REPLAY_VAL]	= { .len = sizeof(struct xfrm_replay_state) },
	[XFRMA_REPLAY_THRESH]	= { .type = NLA_U32 },
	[XFRMA_ETIMER_THRESH]	= { .type = NLA_U32 },
	[XFRMA_SRCADDR]		= { .len = sizeof(xfrm_address_t) },
	[XFRMA_COADDR]		= { .len = sizeof(xfrm_address_t) },
	[XFRMA_POLICY_TYPE]	= { .len = sizeof(struct xfrm_userpolicy_type)},
	[XFRMA_MIGRATE]		= { .len = sizeof(struct xfrm_user_migrate) },
	[XFRMA_KMADDRESS]	= { .len = sizeof(struct xfrm_user_kmaddress) },
	[XFRMA_MARK]		= { .len = sizeof(struct xfrm_mark) },
	[XFRMA_TFCPAD]		= { .type = NLA_U32 },
	[XFRMA_REPLAY_ESN_VAL]	= { .len = sizeof(struct xfrm_replay_state_esn) },
	[XFRMA_SA_EXTRA_FLAGS]	= { .type = NLA_U32 },
	[XFRMA_PROTO]		= { .type = NLA_U8 },
	[XFRMA_ADDRESS_FILTER]	= { .len = sizeof(struct xfrm_address_filter) },
	[XFRMA_OFFLOAD_DEV]	= { .len = sizeof(struct xfrm_user_offload) },
	[XFRMA_OUTPUT_MARK]	= { .type = NLA_U32 },
};


static const struct nla_policy xfrma_spd_policy[XFRMA_SPD_MAX+1] = {
	[XFRMA_SPD_IPV4_HTHRESH] = { .len = sizeof(struct xfrmu_spdhthresh) },
	[XFRMA_SPD_IPV6_HTHRESH] = { .len = sizeof(struct xfrmu_spdhthresh) },
};


static const struct xfrm_link {
	
int (*doit)(struct sk_buff *, struct nlmsghdr *, struct nlattr **);
	
int (*start)(struct netlink_callback *);
	
int (*dump)(struct sk_buff *, struct netlink_callback *);
	
int (*done)(struct netlink_callback *);
	
const struct nla_policy *nla_pol;
	
int nla_max;

} xfrm_dispatch[XFRM_NR_MSGTYPES] = {
	[XFRM_MSG_NEWSA       - XFRM_MSG_BASE] = { .doit = xfrm_add_sa        },
	[XFRM_MSG_DELSA       - XFRM_MSG_BASE] = { .doit = xfrm_del_sa        },
	[XFRM_MSG_GETSA       - XFRM_MSG_BASE] = { .doit = xfrm_get_sa,
						   .dump = xfrm_dump_sa,
						   .done = xfrm_dump_sa_done  },
	[XFRM_MSG_NEWPOLICY   - XFRM_MSG_BASE] = { .doit = xfrm_add_policy    },
	[XFRM_MSG_DELPOLICY   - XFRM_MSG_BASE] = { .doit = xfrm_get_policy    },
	[XFRM_MSG_GETPOLICY   - XFRM_MSG_BASE] = { .doit = xfrm_get_policy,
						   .start = xfrm_dump_policy_start,
						   .dump = xfrm_dump_policy,
						   .done = xfrm_dump_policy_done },
	[XFRM_MSG_ALLOCSPI    - XFRM_MSG_BASE] = { .doit = xfrm_alloc_userspi },
	[XFRM_MSG_ACQUIRE     - XFRM_MSG_BASE] = { .doit = xfrm_add_acquire   },
	[XFRM_MSG_EXPIRE      - XFRM_MSG_BASE] = { .doit = xfrm_add_sa_expire },
	[XFRM_MSG_UPDPOLICY   - XFRM_MSG_BASE] = { .doit = xfrm_add_policy    },
	[XFRM_MSG_UPDSA       - XFRM_MSG_BASE] = { .doit = xfrm_add_sa        },
	[XFRM_MSG_POLEXPIRE   - XFRM_MSG_BASE] = { .doit = xfrm_add_pol_expire},
	[XFRM_MSG_FLUSHSA     - XFRM_MSG_BASE] = { .doit = xfrm_flush_sa      },
	[XFRM_MSG_FLUSHPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_flush_policy  },
	[XFRM_MSG_NEWAE       - XFRM_MSG_BASE] = { .doit = xfrm_new_ae  },
	[XFRM_MSG_GETAE       - XFRM_MSG_BASE] = { .doit = xfrm_get_ae  },
	[XFRM_MSG_MIGRATE     - XFRM_MSG_BASE] = { .doit = xfrm_do_migrate    },
	[XFRM_MSG_GETSADINFO  - XFRM_MSG_BASE] = { .doit = xfrm_get_sadinfo   },
	[XFRM_MSG_NEWSPDINFO  - XFRM_MSG_BASE] = { .doit = xfrm_set_spdinfo,
						   .nla_pol = xfrma_spd_policy,
						   .nla_max = XFRMA_SPD_MAX },
	[XFRM_MSG_GETSPDINFO  - XFRM_MSG_BASE] = { .doit = xfrm_get_spdinfo   },
};



static int xfrm_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
			     struct netlink_ext_ack *extack)
{
	struct net *net = sock_net(skb->sk);
	struct nlattr *attrs[XFRMA_MAX+1];
	const struct xfrm_link *link;
	int type, err;

#ifdef CONFIG_COMPAT
	if (in_compat_syscall())
		return -EOPNOTSUPP;
#endif

	type = nlh->nlmsg_type;
	if (type > XFRM_MSG_MAX)
		return -EINVAL;

	type -= XFRM_MSG_BASE;
	link = &xfrm_dispatch[type];

	/* All operations require privileges, even GET */
	if (!netlink_net_capable(skb, CAP_NET_ADMIN))
		return -EPERM;

	if ((type == (XFRM_MSG_GETSA - XFRM_MSG_BASE) ||
	     type == (XFRM_MSG_GETPOLICY - XFRM_MSG_BASE)) &&
	    (nlh->nlmsg_flags & NLM_F_DUMP)) {
		if (link->dump == NULL)
			return -EINVAL;

		{
			struct netlink_dump_control c = {
				.start = link->start,
				.dump = link->dump,
				.done = link->done,
                        };
			return netlink_dump_start(net->xfrm.nlsk, skb, nlh, &c);
		}
	}

	err = nlmsg_parse(nlh, xfrm_msg_min[type], attrs,
			  link->nla_max ? : XFRMA_MAX,
			  link->nla_pol ? : xfrma_policy, extack);
	if (err < 0)
		return err;

	if (link->doit == NULL)
		return -EINVAL;

	return link->doit(skb, nlh, attrs);
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 124 47.33% 1 4.35%
Thomas Graf 47 17.94% 6 26.09%
Pablo Neira Ayuso 24 9.16% 1 4.35%
Alexey Dobriyan 17 6.49% 1 4.35%
Fan Du 12 4.58% 1 4.35%
Christophe Gouault 10 3.82% 1 4.35%
Johannes Berg 7 2.67% 3 13.04%
Herbert Xu 7 2.67% 1 4.35%
Thomas Walpuski 6 2.29% 1 4.35%
Eric W. Biedermann 3 1.15% 2 8.70%
Mathias Krause 1 0.38% 1 4.35%
Eric Paris 1 0.38% 1 4.35%
Yi Zhao 1 0.38% 1 4.35%
Darrel Goeddel 1 0.38% 1 4.35%
Andrew Lutomirski 1 0.38% 1 4.35%
Total 262 100.00% 23 100.00%



static void xfrm_netlink_rcv(struct sk_buff *skb)
{
	struct net *net = sock_net(skb->sk);

	mutex_lock(&net->xfrm.xfrm_cfg_mutex);
	netlink_rcv_skb(skb, &xfrm_user_rcv_msg);
	mutex_unlock(&net->xfrm.xfrm_cfg_mutex);
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 20 39.22% 1 16.67%
Fan Du 20 39.22% 1 16.67%
Denis V. Lunev 4 7.84% 1 16.67%
Arjan van de Ven 4 7.84% 1 16.67%
Thomas Graf 2 3.92% 1 16.67%
Herbert Xu 1 1.96% 1 16.67%
Total 51 100.00% 6 100.00%



static inline unsigned int xfrm_expire_msgsize(void)
{
	return NLMSG_ALIGN(sizeof(struct xfrm_user_expire))
	       + nla_total_size(sizeof(struct xfrm_mark));
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Graf 18 62.07% 1 33.33%
Jamal Hadi Salim 9 31.03% 1 33.33%
Alexey Dobriyan 2 6.90% 1 33.33%
Total 29 100.00% 3 100.00%



static int build_expire(struct sk_buff *skb, struct xfrm_state *x, const struct km_event *c)
{
	struct xfrm_user_expire *ue;
	struct nlmsghdr *nlh;
	int err;

	nlh = nlmsg_put(skb, c->portid, 0, XFRM_MSG_EXPIRE, sizeof(*ue), 0);
	if (nlh == NULL)
		return -EMSGSIZE;

	ue = nlmsg_data(nlh);
	copy_to_user_state(x, &ue->state);
	ue->hard = (c->data.hard != 0) ? 1 : 0;
	/* clear the padding bytes */
	memset(&ue->hard + 1, 0, sizeof(*ue) - offsetofend(typeof(*ue), hard));

	err = xfrm_mark_put(skb, &x->mark);
	if (err)
		return err;

	nlmsg_end(skb, nlh);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 89 54.94% 3 25.00%
Mathias Krause 30 18.52% 1 8.33%
Jamal Hadi Salim 20 12.35% 2 16.67%
Thomas Graf 17 10.49% 3 25.00%
Johannes Berg 3 1.85% 1 8.33%
Arnaldo Carvalho de Melo 2 1.23% 1 8.33%
Eric W. Biedermann 1 0.62% 1 8.33%
Total 162 100.00% 12 100.00%



static int xfrm_exp_state_notify(struct xfrm_state *x, const struct km_event *c)
{
	struct net *net = xs_net(x);
	struct sk_buff *skb;

	skb = nlmsg_new(xfrm_expire_msgsize(), GFP_ATOMIC);
	if (skb == NULL)
		return -ENOMEM;

	if (build_expire(skb, x, c) < 0) {
		kfree_skb(skb);
		return -EMSGSIZE;
	}

	return xfrm_nlmsg_multicast(net, skb, 0, XFRMNLGRP_EXPIRE);
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 53 60.23% 3 25.00%
Jamal Hadi Salim 18 20.45% 3 25.00%
Alexey Dobriyan 11 12.50% 2 16.67%
Thomas Graf 3 3.41% 1 8.33%
Michal Kubeček 1 1.14% 1 8.33%
Patrick McHardy 1 1.14% 1 8.33%
Herbert Xu 1 1.14% 1 8.33%
Total 88 100.00% 12 100.00%



static int xfrm_aevent_state_notify(struct xfrm_state *x, const struct km_event *c)
{
	struct net *net = xs_net(x);
	struct sk_buff *skb;
	int err;

	skb = nlmsg_new(xfrm_aevent_msgsize(x), GFP_ATOMIC);
	if (skb == NULL)
		return -ENOMEM;

	err = build_aevent(skb, x, c);
	BUG_ON(err < 0);

	return xfrm_nlmsg_multicast(net, skb, 0, XFRMNLGRP_AEVENTS);
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 59 67.82% 1 12.50%
Alexey Dobriyan 11 12.64% 2 25.00%
Gustavo A. R. Silva 10 11.49% 1 12.50%
Steffen Klassert 3 3.45% 1 12.50%
Thomas Graf 2 2.30% 1 12.50%
David S. Miller 1 1.15% 1 12.50%
Michal Kubeček 1 1.15% 1 12.50%
Total 87 100.00% 8 100.00%



static int xfrm_notify_sa_flush(const struct km_event *c)
{
	struct net *net = c->net;
	struct xfrm_usersa_flush *p;
	struct nlmsghdr *nlh;
	struct sk_buff *skb;
	int len = NLMSG_ALIGN(sizeof(struct xfrm_usersa_flush));

	skb = nlmsg_new(len, GFP_ATOMIC);
	if (skb == NULL)
		return -ENOMEM;

	nlh = nlmsg_put(skb, c->portid, c->seq, XFRM_MSG_FLUSHSA, sizeof(*p), 0);
	if (nlh == NULL) {
		kfree_skb(skb);
		return -EMSGSIZE;
	}

	p = nlmsg_data(nlh);
	p->proto = c->data.proto;

	nlmsg_end(skb, nlh);

	return xfrm_nlmsg_multicast(net, skb, 0, XFRMNLGRP_SA);
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 56 38.62% 1 7.14%
David S. Miller 42 28.97% 2 14.29%
Thomas Graf 26 17.93% 4 28.57%
Alexey Dobriyan 10 6.90% 2 14.29%
Herbert Xu 8 5.52% 2 14.29%
Michal Kubeček 1 0.69% 1 7.14%
Eric W. Biedermann 1 0.69% 1 7.14%
Patrick McHardy 1 0.69% 1 7.14%
Total 145 100.00% 14 100.00%



static inline unsigned int xfrm_sa_len(struct xfrm_state *x)
{
	unsigned int l = 0;
	if (x->aead)
		l += nla_total_size(aead_len(x->aead));
	if (x->aalg) {
		l += nla_total_size(sizeof(struct xfrm_algo) +
				    (x->aalg->alg_key_len + 7) / 8);
		l += nla_total_size(xfrm_alg_auth_len(x->aalg));
	}
	if (x->ealg)
		l += nla_total_size(xfrm_alg_len(x->ealg));
	if (x->calg)
		l += nla_total_size(sizeof(*x->calg));
	if (x->encap)
		l += nla_total_size(sizeof(*x->encap));
	if (x->tfcpad)
		l += nla_total_size(sizeof(x->tfcpad));
	if (x->replay_esn)
		l += nla_total_size(xfrm_replay_state_esn_len(x->replay_esn));
	else
		l += nla_total_size(sizeof(struct xfrm_replay_state));
	if (x->security)
		l += nla_total_size(sizeof(struct xfrm_user_sec_ctx) +
				    x->security->ctx_len);
	if (x->coaddr)
		l += nla_total_size(sizeof(*x->coaddr));
	if (x->props.extra_flags)
		l += nla_total_size(sizeof(x->props.extra_flags));
	if (x->xso.dev)
		 l += nla_total_size(sizeof(x->xso));
	if (x->props.output_mark)
		l += nla_total_size(sizeof(x->props.output_mark));

	/* Must count x->lastused as it may become non-zero behind our back. */
	l += nla_total_size_64bit(sizeof(u64));

	return l;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 74 24.34% 1 5.56%
Herbert Xu 72 23.68% 5 27.78%
Martin Willi 44 14.47% 2 11.11%
Steffen Klassert 38 12.50% 2 11.11%
Nicolas Dichtel 23 7.57% 2 11.11%
Lorenzo Colitti 22 7.24% 1 5.56%
Ding Zhi 12 3.95% 1 5.56%
David S. Miller 10 3.29% 1 5.56%
Alexey Dobriyan 4 1.32% 1 5.56%
Thomas Graf 4 1.32% 1 5.56%
Eric Dumazet 1 0.33% 1 5.56%
Total 304 100.00% 18 100.00%



static int xfrm_notify_sa(struct xfrm_state *x, const struct km_event *c)
{
	struct net *net = xs_net(x);
	struct xfrm_usersa_info *p;
	struct xfrm_usersa_id *id;
	struct nlmsghdr *nlh;
	struct sk_buff *skb;
	unsigned int len = xfrm_sa_len(x);
	unsigned int headlen;
	int err;

	headlen = sizeof(*p);
	if (c->event == XFRM_MSG_DELSA) {
		len += nla_total_size(headlen);
		headlen = sizeof(*id);
		len += nla_total_size(sizeof(struct xfrm_mark));
	}
	len += NLMSG_ALIGN(headlen);

	skb = nlmsg_new(len, GFP_ATOMIC);
	if (skb == NULL)
		return -ENOMEM;

	nlh = nlmsg_put(skb, c->portid, c->seq, c->event, headlen, 0);
	err = -EMSGSIZE;
	if (nlh == NULL)
		goto out_free_skb;

	p = nlmsg_data(nlh);
	if (c->event == XFRM_MSG_DELSA) {
		struct nlattr *attr;

		id = nlmsg_data(nlh);
		memset(id, 0, sizeof(*id));
		memcpy(&id->daddr, &x->id.daddr, sizeof(id->daddr));
		id->spi = x->id.spi;
		id->family = x->props.family;
		id->proto = x->id.proto;

		attr = nla_reserve(skb, XFRMA_SA, sizeof(*p));
		err = -EMSGSIZE;
		if (attr == NULL)
			goto out_free_skb;

		p = nla_data(attr);
	}
	err = copy_to_user_state_extra(x, p, skb);
	if (err)
		goto out_free_skb;

	nlmsg_end(skb, nlh);

	return xfrm_nlmsg_multicast(net, skb, 0, XFRMNLGRP_SA);

out_free_skb:
	kfree_skb(skb);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 136 39.19% 3 15.79%
Jamal Hadi Salim 116 33.43% 2 10.53%
Thomas Graf 41 11.82% 5 26.32%
David S. Miller 23 6.63% 2 10.53%
Alexey Dobriyan 15 4.32% 3 15.79%
Mathias Krause 13 3.75% 1 5.26%
Eric W. Biedermann 1 0.29% 1 5.26%
Patrick McHardy 1 0.29% 1 5.26%
Michal Kubeček 1 0.29% 1 5.26%
Total 347 100.00% 19 100.00%



static int xfrm_send_state_notify(struct xfrm_state *x, const struct km_event *c)
{

	switch (c->event) {
	case XFRM_MSG_EXPIRE:
		return xfrm_exp_state_notify(x, c);
	case XFRM_MSG_NEWAE:
		return xfrm_aevent_state_notify(x, c);
	case XFRM_MSG_DELSA:
	case XFRM_MSG_UPDSA:
	case XFRM_MSG_NEWSA:
		return xfrm_notify_sa(x, c);
	case XFRM_MSG_FLUSHSA:
		return xfrm_notify_sa_flush(c);
	default:
		printk(KERN_NOTICE "xfrm_user: Unknown SA event %d\n",
		       c->event);
		break;
	}

	return 0;

}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 81 92.05% 2 40.00%
Herbert Xu 5 5.68% 1 20.00%
David S. Miller 1 1.14% 1 20.00%
Stephen Hemminger 1 1.14% 1 20.00%
Total 88 100.00% 5 100.00%



static inline unsigned int xfrm_acquire_msgsize(struct xfrm_state *x,
						struct xfrm_policy *xp)
{
	return NLMSG_ALIGN(sizeof(struct xfrm_user_acquire))
	       + nla_total_size(sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr)
	       + nla_total_size(sizeof(struct xfrm_mark))
	       + nla_total_size(xfrm_user_sec_ctx_size(x->security))
	       + userpolicy_type_attrsize();
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Graf 52 82.54% 1 33.33%
Jamal Hadi Salim 9 14.29% 1 33.33%
Alexey Dobriyan 2 3.17% 1 33.33%
Total 63 100.00% 3 100.00%



static int build_acquire(struct sk_buff *skb, struct xfrm_state *x,
			 struct xfrm_tmpl *xt, struct xfrm_policy *xp)
{
	__u32 seq = xfrm_get_acqseq();
	struct xfrm_user_acquire *ua;
	struct nlmsghdr *nlh;
	int err;

	nlh = nlmsg_put(skb, 0, 0, XFRM_MSG_ACQUIRE, sizeof(*ua), 0);
	if (nlh == NULL)
		return -EMSGSIZE;

	ua = nlmsg_data(nlh);
	memcpy(&ua->id, &x->id, sizeof(ua->id));
	memcpy(&ua->saddr, &x->props.saddr, sizeof(ua->saddr));
	memcpy(&ua->sel, &x->sel, sizeof(ua->sel));
	copy_to_user_policy(xp, &ua->policy, XFRM_POLICY_OUT);
	ua->aalgos = xt->aalgos;
	ua->ealgos = xt->ealgos;
	ua->calgos = xt->calgos;
	ua->seq = x->km.seq = seq;

	err = copy_to_user_tmpl(xp, skb);
	if (!err)
		err = copy_to_user_state_sec_ctx(x, skb);
	if (!err)
		err = copy_to_user_policy_type(xp->type, skb);
	if (!err)
		err = xfrm_mark_put(skb, &xp->mark);
	if (err) {
		nlmsg_cancel(skb, nlh);
		return err;
	}

	nlmsg_end(skb, nlh);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 197 71.64% 3 23.08%
David S. Miller 39 14.18% 1 7.69%
Thomas Graf 17 6.18% 3 23.08%
Masahide Nakamura 8 2.91% 1 7.69%
Trent Jaeger 6 2.18% 1 7.69%
Johannes Berg 3 1.09% 1 7.69%
Serge E. Hallyn 2 0.73% 1 7.69%
Arnaldo Carvalho de Melo 2 0.73% 1 7.69%
Fan Du 1 0.36% 1 7.69%
Total 275 100.00% 13 100.00%



static int xfrm_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *xt,
			     struct xfrm_policy *xp)
{
	struct net *net = xs_net(x);
	struct sk_buff *skb;
	int err;

	skb = nlmsg_new(xfrm_acquire_msgsize(x, xp), GFP_ATOMIC);
	if (skb == NULL)
		return -ENOMEM;

	err = build_acquire(skb, x, xt, xp);
	BUG_ON(err < 0);

	return xfrm_nlmsg_multicast(net, skb, 0, XFRMNLGRP_ACQUIRE);
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 37 38.95% 2 20.00%
Jamal Hadi Salim 27 28.42% 1 10.00%
Alexey Dobriyan 11 11.58% 1 10.00%
Gustavo A. R. Silva 10 10.53% 1 10.00%
Thomas Graf 5 5.26% 1 10.00%
Trent Jaeger 2 2.11% 1 10.00%
Patrick McHardy 1 1.05% 1 10.00%
Michal Kubeček 1 1.05% 1 10.00%
Joy Latten 1 1.05% 1 10.00%
Total 95 100.00% 10 100.00%

/* User gives us xfrm_user_policy_info followed by an array of 0
 * or more templates.
 */


static struct xfrm_policy *xfrm_compile_policy(struct sock *sk, int opt,
					       u8 *data, int len, int *dir)
{
	struct net *net = sock_net(sk);
	struct xfrm_userpolicy_info *p = (struct xfrm_userpolicy_info *)data;
	struct xfrm_user_tmpl *ut = (struct xfrm_user_tmpl *) (p + 1);
	struct xfrm_policy *xp;
	int nr;

	switch (sk->sk_family) {
	case AF_INET:
		if (opt != IP_XFRM_POLICY) {
			*dir = -EOPNOTSUPP;
			return NULL;
		}
		break;
#if IS_ENABLED(CONFIG_IPV6)
	case AF_INET6:
		if (opt != IPV6_XFRM_POLICY) {
			*dir = -EOPNOTSUPP;
			return NULL;
		}
		break;
#endif
	default:
		*dir = -EINVAL;
		return NULL;
	}

	*dir = -EINVAL;

	if (len < sizeof(*p) ||
	    verify_newpolicy_info(p))
		return NULL;

	nr = ((len - sizeof(*p)) / sizeof(*ut));
	if (validate_tmpl(nr, ut, p->sel.family))
		return NULL;

	if (p->dir > XFRM_POLICY_OUT)
		return NULL;

	xp = xfrm_policy_alloc(net, GFP_ATOMIC);
	if (xp == NULL) {
		*dir = -ENOBUFS;
		return NULL;
	}

	copy_from_user_policy(xp, p);
	xp->type = XFRM_POLICY_TYPE_MAIN;
	copy_templates(xp, ut, nr);

	*dir = p->dir;

	return xp;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 121 44.49% 1 7.69%
David S. Miller 84 30.88% 2 15.38%
Tom Lendacky 27 9.93% 1 7.69%
Alexey Dobriyan 12 4.41% 2 15.38%
Herbert Xu 12 4.41% 2 15.38%
Venkat Yekkirala 7 2.57% 1 7.69%
Masahide Nakamura 6 2.21% 1 7.69%
Adrian Bunk 1 0.37% 1 7.69%
Eric Dumazet 1 0.37% 1 7.69%
James Morris 1 0.37% 1 7.69%
Total 272 100.00% 13 100.00%



static inline unsigned int xfrm_polexpire_msgsize(struct xfrm_policy *xp)
{
	return NLMSG_ALIGN(sizeof(struct xfrm_user_polexpire))
	       + nla_total_size(sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr)
	       + nla_total_size(xfrm_user_sec_ctx_size(xp->security))
	       + nla_total_size(sizeof(struct xfrm_mark))
	       + userpolicy_type_attrsize();
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Graf 47 81.03% 1 33.33%
Jamal Hadi Salim 9 15.52% 1 33.33%
Alexey Dobriyan 2 3.45% 1 33.33%
Total 58 100.00% 3 100.00%



static int build_polexpire(struct sk_buff *skb, struct xfrm_policy *xp,
			   int dir, const struct km_event *c)
{
	struct xfrm_user_polexpire *upe;
	int hard = c->data.hard;
	struct nlmsghdr *nlh;
	int err;

	nlh = nlmsg_put(skb, c->portid, 0, XFRM_MSG_POLEXPIRE, sizeof(*upe), 0);
	if (nlh == NULL)
		return -EMSGSIZE;

	upe = nlmsg_data(nlh);
	copy_to_user_policy(xp, &upe->pol, dir);
	err = copy_to_user_tmpl(xp, skb);
	if (!err)
		err = copy_to_user_sec_ctx(xp, skb);
	if (!err)
		err = copy_to_user_policy_type(xp->type, skb);
	if (!err)
		err = xfrm_mark_put(skb, &xp->mark);
	if (err) {
		nlmsg_cancel(skb, nlh);
		return err;
	}
	upe->hard = !!hard;

	nlmsg_end(skb, nlh);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 103 54.50% 4 26.67%
David S. Miller 45 23.81% 2 13.33%
Thomas Graf 17 8.99% 3 20.00%
Trent Jaeger 8 4.23% 1 6.67%
Masahide Nakamura 8 4.23% 1 6.67%
Johannes Berg 3 1.59% 1 6.67%
Tom Lendacky 2 1.06% 1 6.67%
Arnaldo Carvalho de Melo 2 1.06% 1 6.67%
Eric W. Biedermann 1 0.53% 1 6.67%
Total 189 100.00% 15 100.00%



static int xfrm_exp_policy_notify(struct xfrm_policy *xp, int dir, const struct km_event *c)
{
	struct net *net = xp_net(xp);
	struct sk_buff *skb;
	int err;

	skb = nlmsg_new(xfrm_polexpire_msgsize(xp), GFP_ATOMIC);
	if (skb == NULL)
		return -ENOMEM;

	err = build_polexpire(skb, xp, dir, c);
	BUG_ON(err < 0);

	return xfrm_nlmsg_multicast(net, skb, 0, XFRMNLGRP_EXPIRE);
}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 41 44.57% 1 10.00%
David S. Miller 21 22.83% 2 20.00%
Alexey Dobriyan 11 11.96% 2 20.00%
Gustavo A. R. Silva 10 10.87% 1 10.00%
Trent Jaeger 4 4.35% 1 10.00%
Thomas Graf 3 3.26% 1 10.00%
Patrick McHardy 1 1.09% 1 10.00%
Michal Kubeček 1 1.09% 1 10.00%
Total 92 100.00% 10 100.00%



static int xfrm_notify_policy(struct xfrm_policy *xp, int dir, const struct km_event *c)
{
	unsigned int len = nla_total_size(sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr);
	struct net *net = xp_net(xp);
	struct xfrm_userpolicy_info *p;
	struct xfrm_userpolicy_id *id;
	struct nlmsghdr *nlh;
	struct sk_buff *skb;
	unsigned int headlen;
	int err;

	headlen = sizeof(*p);
	if (c->event == XFRM_MSG_DELPOLICY) {
		len += nla_total_size(headlen);
		headlen = sizeof(*id);
	}
	len += userpolicy_type_attrsize();
	len += nla_total_size(sizeof(struct xfrm_mark));
	len += NLMSG_ALIGN(headlen);

	skb = nlmsg_new(len, GFP_ATOMIC);
	if (skb == NULL)
		return -ENOMEM;

	nlh = nlmsg_put(skb, c->portid, c->seq, c->event, headlen, 0);
	err = -EMSGSIZE;
	if (nlh == NULL)
		goto out_free_skb;

	p = nlmsg_data(nlh);
	if (c->event == XFRM_MSG_DELPOLICY) {
		struct nlattr *attr;

		id = nlmsg_data(nlh);
		memset(id, 0, sizeof(*id));
		id->dir = dir;
		if (c->data.byid)
			id->index = xp->index;
		else
			memcpy(&id->sel, &xp->selector, sizeof(id->sel));

		attr = nla_reserve(skb, XFRMA_POLICY, sizeof(*p));
		err = -EMSGSIZE;
		if (attr == NULL)
			goto out_free_skb;

		p = nla_data(attr);
	}

	copy_to_user_policy(xp, p, dir);
	err = copy_to_user_tmpl(xp, skb);
	if (!err)
		err = copy_to_user_policy_type(xp->type, skb);
	if (!err)
		err = xfrm_mark_put(skb, &xp->mark);
	if (err)
		goto out_free_skb;

	nlmsg_end(skb, nlh);

	return xfrm_nlmsg_multicast(net, skb, 0, XFRMNLGRP_POLICY);

out_free_skb:
	kfree_skb(skb);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 191 48.48% 3 13.64%
Jamal Hadi Salim 82 20.81% 4 18.18%
David S. Miller 51 12.94% 2 9.09%
Thomas Graf 44 11.17% 6 27.27%
Alexey Dobriyan 15 3.81% 3 13.64%
Masahide Nakamura 8 2.03% 1 4.55%
Michal Kubeček 1 0.25% 1 4.55%
Eric W. Biedermann 1 0.25% 1 4.55%
Patrick McHardy 1 0.25% 1 4.55%
Total 394 100.00% 22 100.00%



static int xfrm_notify_policy_flush(const struct km_event *c)
{
	struct net *net = c->net;
	struct nlmsghdr *nlh;
	struct sk_buff *skb;
	int err;

	skb = nlmsg_new(userpolicy_type_attrsize(), GFP_ATOMIC);
	if (skb == NULL)
		return -ENOMEM;

	nlh = nlmsg_put(skb, c->portid, c->seq, XFRM_MSG_FLUSHPOLICY, 0, 0);
	err = -EMSGSIZE;
	if (nlh == NULL)
		goto out_free_skb;
	err = copy_to_user_policy_type(c->data.type, skb);
	if (err)
		goto out_free_skb;

	nlmsg_end(skb, nlh);

	return xfrm_nlmsg_multicast(net, skb, 0, XFRMNLGRP_POLICY);

out_free_skb:
	kfree_skb(skb);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
Herbert Xu 46 33.33% 1 7.14%
Jamal Hadi Salim 34 24.64% 2 14.29%
David S. Miller 19 13.77% 2 14.29%
Thomas Graf 18 13.04% 3 21.43%
Alexey Dobriyan 10 7.25% 2 14.29%
Masahide Nakamura 8 5.80% 1 7.14%
Michal Kubeček 1 0.72% 1 7.14%
Eric W. Biedermann 1 0.72% 1 7.14%
Patrick McHardy 1 0.72% 1 7.14%
Total 138 100.00% 14 100.00%



static int xfrm_send_policy_notify(struct xfrm_policy *xp, int dir, const struct km_event *c)
{

	switch (c->event) {
	case XFRM_MSG_NEWPOLICY:
	case XFRM_MSG_UPDPOLICY:
	case XFRM_MSG_DELPOLICY:
		return xfrm_notify_policy(xp, dir, c);
	case XFRM_MSG_FLUSHPOLICY:
		return xfrm_notify_policy_flush(c);
	case XFRM_MSG_POLEXPIRE:
		return xfrm_exp_policy_notify(xp, dir, c);
	default:
		printk(KERN_NOTICE "xfrm_user: Unknown Policy event %d\n",
		       c->event);
	}

	return 0;

}

Contributors
Person Tokens Prop Commits CommitProp
Jamal Hadi Salim 75 90.36% 1 20.00%
Herbert Xu 6 7.23% 2 40.00%
David S. Miller 1 1.20% 1 20.00%
Stephen Hemminger 1 1.20% 1 20.00%
Total 83 100.00% 5 100.00%



static inline unsigned int xfrm_report_msgsize(void)
{
	return NLMSG_ALIGN(sizeof(struct xfrm_user_report));
}

Contributors
Person Tokens Prop Commits CommitProp
Thomas Graf 18 90.00% 1 50.00%
Alexey Dobriyan 2 10.00% 1 50.00%
Total 20 100.00% 2 100.00%



static int build_report(struct sk_buff *skb, u8 proto,
			struct xfrm_selector *sel, xfrm_address_t *addr)
{
	struct xfrm_user_report *ur;
	struct nlmsghdr *nlh;

	nlh = nlmsg_put(skb, 0, 0, XFRM_MSG_REPORT, sizeof(*ur), 0);
	if (nlh == NULL)
		return -EMSGSIZE;

	ur = nlmsg_data(nlh);
	ur->proto = proto;
	memcpy(&ur->sel, sel, sizeof(ur->sel));

	if (addr) {
		int err = nla_put(skb, XFRMA_COADDR, sizeof(*addr), addr);
		if (err) {
			nlmsg_cancel(skb, nlh);
			return err;
		}
	}
	nlmsg_end(skb, nlh);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Masahide Nakamura 103 71.53% 1 12.50%
David S. Miller 19 13.19% 2 25.00%
Thomas Graf 17 11.81% 3 37.50%
Johannes Berg 3 2.08% 1 12.50%
Arnaldo Carvalho de Melo 2 1.39% 1 12.50%
Total 144 100.00% 8 100.00%



static int xfrm_send_report(struct net *net, u8 proto,
			    struct xfrm_selector *sel, xfrm_address_t *addr)
{
	struct sk_buff *skb;
	int err;

	skb = nlmsg_new(xfrm_report_msgsize(), GFP_ATOMIC);
	if (skb == NULL)
		return -ENOMEM;

	err = build_report(skb, proto, sel, addr);
	BUG_ON(err < 0);

	return xfrm_nlmsg_multicast(net, skb, 0, XFRMNLGRP_REPORT);
}

Contributors
Person Tokens Prop Commits CommitProp
Masahide Nakamura 63 75.90% 1 16.67%
Gustavo A. R. Silva 10 12.05% 1 16.67%
Alexey Dobriyan 6 7.23% 2 33.33%
Thomas Graf 3 3.61% 1 16.67%
Michal Kubeček 1 1.20% 1 16.67%
Total 83 100.00% 6 100.00%



static inline unsigned int xfrm_mapping_msgsize(void)
{
	return NLMSG_ALIGN(sizeof(struct xfrm_user_mapping));
}

Contributors
Person Tokens Prop Commits CommitProp
Martin Willi 18 90.00% 1 50.00%
Alexey Dobriyan 2 10.00% 1 50.00%
Total 20 100.00% 2 100.00%



static int build_mapping(struct sk_buff *skb, struct xfrm_state *x,
			 xfrm_address_t *new_saddr, __be16 new_sport)
{
	struct xfrm_user_mapping *um;
	struct nlmsghdr *nlh;

	nlh = nlmsg_put(skb, 0, 0, XFRM_MSG_MAPPING, sizeof(*um), 0);
	if (nlh == NULL)
		return -EMSGSIZE;

	um = nlmsg_data(nlh);

	memcpy(&um->id.daddr, &x->id.daddr, sizeof(um->id.daddr));
	um->id.spi = x->id.spi;
	um->id.family = x->props.family;
	um->id.proto = x->id.proto;
	memcpy(&um->new_saddr, new_saddr, sizeof(um->new_saddr));
	memcpy(&um->old_saddr, &x->props.saddr, sizeof(um->old_saddr));
	um->new_sport = new_sport;
	um->old_sport = x->encap->encap_sport;
	um->reqid = x->props.reqid;

	nlmsg_end(skb, nlh);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Martin Willi 205 98.56% 1 50.00%
Johannes Berg 3 1.44% 1 50.00%
Total 208 100.00% 2 100.00%



static int xfrm_send_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr,
			     __be16 sport)
{
	struct net *net = xs_net(x);
	struct sk_buff *skb;
	int err;

	if (x->id.proto != IPPROTO_ESP)
		return -EINVAL;

	if (!x->encap)
		return -EINVAL;

	skb = nlmsg_new(xfrm_mapping_msgsize(), GFP_ATOMIC);
	if (skb == NULL)
		return -ENOMEM;

	err = build_mapping(skb, x, ipaddr, sport);
	BUG_ON(err < 0);

	return xfrm_nlmsg_multicast(net, skb, 0, XFRMNLGRP_MAPPING);
}

Contributors
Person Tokens Prop Commits CommitProp
Martin Willi 91 80.53% 1 25.00%
Alexey Dobriyan 11 9.73% 1 25.00%
Gustavo A. R. Silva 10 8.85% 1 25.00%
Michal Kubeček 1 0.88% 1 25.00%
Total 113 100.00% 4 100.00%



static bool xfrm_is_alive(const struct km_event *c)
{
	return (bool)xfrm_acquire_is_on(c->net);
}

Contributors
Person Tokens Prop Commits CommitProp
Horia Geantă 23 100.00% 1 100.00%
Total 23 100.00% 1 100.00%


static struct xfrm_mgr netlink_mgr = {
	.notify		= xfrm_send_state_notify,
	.acquire	= xfrm_send_acquire,
	.compile_policy	= xfrm_compile_policy,
	.notify_policy	= xfrm_send_policy_notify,
	.report		= xfrm_send_report,
	.migrate	= xfrm_send_migrate,
	.new_mapping	= xfrm_send_mapping,
	.is_alive	= xfrm_is_alive,
};



static int __net_init xfrm_user_net_init(struct net *net)
{
	struct sock *nlsk;
	struct netlink_kernel_cfg cfg = {
		.groups	= XFRMNLGRP_MAX,
		.input	= xfrm_netlink_rcv,
        };

	nlsk = netlink_kernel_create(net, NETLINK_XFRM, &cfg);
	if (nlsk == NULL)
		return -ENOMEM;
	net->xfrm.nlsk_stash = nlsk; /* Don't set to NULL */
	rcu_assign_pointer(net->xfrm.nlsk, nlsk);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 21 26.92% 1 12.50%
Pablo Neira Ayuso 18 23.08% 1 12.50%
Patrick McHardy 12 15.38% 1 12.50%
Alexey Dobriyan 12 15.38% 1 12.50%
Eric W. Biedermann 10 12.82% 2 25.00%
Herbert Xu 4 5.13% 1 12.50%
Eric Dumazet 1 1.28% 1 12.50%
Total 78 100.00% 8 100.00%



static void __net_exit xfrm_user_net_exit(struct list_head *net_exit_list)
{
	struct net *net;
	list_for_each_entry(net, net_exit_list, exit_list)
		RCU_INIT_POINTER(net->xfrm.nlsk, NULL);
	synchronize_net();
	list_for_each_entry(net, net_exit_list, exit_list)
		netlink_kernel_release(net->xfrm.nlsk_stash);
}

Contributors
Person Tokens Prop Commits CommitProp
Eric W. Biedermann 25 44.64% 1 14.29%
Alexey Dobriyan 10 17.86% 1 14.29%
Patrick McHardy 10 17.86% 1 14.29%
David S. Miller 9 16.07% 2 28.57%
Denis V. Lunev 1 1.79% 1 14.29%
Stephen Hemminger 1 1.79% 1 14.29%
Total 56 100.00% 7 100.00%


static struct pernet_operations xfrm_user_net_ops = {
	.init	    = xfrm_user_net_init,
	.exit_batch = xfrm_user_net_exit,
};



static int __init xfrm_user_init(void)
{
	int rv;

	printk(KERN_INFO "Initializing XFRM netlink socket\n");

	rv = register_pernet_subsys(&xfrm_user_net_ops);
	if (rv < 0)
		return rv;
	rv = xfrm_register_km(&netlink_mgr);
	if (rv < 0)
		unregister_pernet_subsys(&xfrm_user_net_ops);
	return rv;
}

Contributors
Person Tokens Prop Commits CommitProp
Alexey Dobriyan 58 100.00% 1 100.00%
Total 58 100.00% 1 100.00%



static void __exit xfrm_user_exit(void)
{
	xfrm_unregister_km(&netlink_mgr);
	unregister_pernet_subsys(&xfrm_user_net_ops);
}

Contributors
Person Tokens Prop Commits CommitProp
Alexey Dobriyan 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%


module_init(xfrm_user_init);

module_exit(xfrm_user_exit);
MODULE_LICENSE("GPL");
MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_XFRM);

Overall Contributors
Person Tokens Prop Commits CommitProp
David S. Miller 4053 21.77% 19 7.34%
Jamal Hadi Salim 3839 20.62% 23 8.88%
Herbert Xu 1804 9.69% 39 15.06%
Thomas Graf 1490 8.00% 17 6.56%
Martin Willi 1068 5.74% 3 1.16%
Shinta Sugimoto 833 4.47% 1 0.39%
Masahide Nakamura 764 4.10% 6 2.32%
Steffen Klassert 727 3.90% 11 4.25%
Alexey Dobriyan 656 3.52% 20 7.72%
Christophe Gouault 520 2.79% 1 0.39%
Trent Jaeger 317 1.70% 2 0.77%
Mathias Krause 302 1.62% 14 5.41%
Arnaud Ebalard 278 1.49% 2 0.77%
Nicolas Dichtel 236 1.27% 5 1.93%
Timo Teräs 186 1.00% 3 1.16%
Fan Du 162 0.87% 8 3.09%
Antony Antony 127 0.68% 2 0.77%
Gustavo A. R. Silva 87 0.47% 1 0.39%
Joy Latten 84 0.45% 4 1.54%
Lorenzo Colitti 81 0.43% 1 0.39%
Serge E. Hallyn 76 0.41% 1 0.39%
Eric W. Biedermann 76 0.41% 6 2.32%
Michal Kubeček 74 0.40% 2 0.77%
Yossi Kuperman 52 0.28% 1 0.39%
James Morris 50 0.27% 3 1.16%
Américo Wang 46 0.25% 2 0.77%
Pablo Neira Ayuso 42 0.23% 2 0.77%
Patrick McHardy 37 0.20% 4 1.54%
Johannes Berg 36 0.19% 4 1.54%
Sowmini Varadhan 35 0.19% 1 0.39%
Ding Zhi 34 0.18% 1 0.39%
Andy Whitcroft 30 0.16% 2 0.77%
Tom Lendacky 29 0.16% 1 0.39%
Horia Geantă 28 0.15% 1 0.39%
Catherine Zhang 26 0.14% 1 0.39%
Michael Rossberg 26 0.14% 1 0.39%
Harald Welte 26 0.14% 2 0.77%
Paul Moore 25 0.13% 1 0.39%
Kunihiro Ishiguro 23 0.12% 1 0.39%
Ilpo Järvinen 20 0.11% 1 0.39%
Eric Paris 20 0.11% 3 1.16%
Vegard Nossum 19 0.10% 2 0.77%
Arnaldo Carvalho de Melo 19 0.10% 2 0.77%
Noriaki Takamiya 16 0.09% 1 0.39%
Christoph Hellwig 14 0.08% 1 0.39%
Denis V. Lunev 13 0.07% 3 1.16%
Tobias Brunner 13 0.07% 1 0.39%
Hideaki Yoshifuji / 吉藤英明 10 0.05% 3 1.16%
Miika Komu 10 0.05% 1 0.39%
Eric Dumazet 10 0.05% 3 1.16%
Andrzej Hajda 9 0.05% 1 0.39%
Tetsuo Handa 8 0.04% 1 0.39%
Venkat Yekkirala 7 0.04% 1 0.39%
Thomas Walpuski 6 0.03% 1 0.39%
John Williams Floroiu 6 0.03% 1 0.39%
Nikolay Aleksandrov 6 0.03% 1 0.39%
Ilan Tayari 5 0.03% 1 0.39%
Krishna Kumar 4 0.02% 1 0.39%
Arjan van de Ven 4 0.02% 1 0.39%
Lucas De Marchi 3 0.02% 1 0.39%
Wei Yongjun 3 0.02% 1 0.39%
Diego Beltrami 3 0.02% 1 0.39%
Stephen Hemminger 3 0.02% 2 0.77%
Darrel Goeddel 1 0.01% 1 0.39%
Adrian Bunk 1 0.01% 1 0.39%
Linus Torvalds 1 0.01% 1 0.39%
Andrew Lutomirski 1 0.01% 1 0.39%
Yi Zhao 1 0.01% 1 0.39%
Total 18621 100.00% 259 100.00%
Directory: net/xfrm

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
David S. Miller	75	71.43%	1	12.50%
Herbert Xu	16	15.24%	2	25.00%
Thomas Graf	10	9.52%	3	37.50%
Alexey Dobriyan	3	2.86%	1	12.50%
Eric Dumazet	1	0.95%	1	12.50%
Total	105	100.00%	8	100.00%
cregit-Linux how code gets into the kernel

Release 4.15 net/xfrm/xfrm_user.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

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

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors
