Release 4.8 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 <asm/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) < 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[CRYPTO_MAX_ALG_NAME - 1] = '\0';
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
david s. miller david s. miller 76 78.35% 1 16.67%
herbert xu herbert xu 10 10.31% 1 16.67%
thomas graf thomas graf 10 10.31% 3 50.00%
eric dumazet eric dumazet 1 1.03% 1 16.67%
Total 97 100.00% 6 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) < xfrm_alg_auth_len(algp))
		return -EINVAL;

	algp->alg_name[CRYPTO_MAX_ALG_NAME - 1] = '\0';
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
martin willi martin willi 72 100.00% 1 100.00%
Total 72 100.00% 1 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) < aead_len(algp))
		return -EINVAL;

	algp->alg_name[CRYPTO_MAX_ALG_NAME - 1] = '\0';
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
herbert xu herbert xu 72 100.00% 1 100.00%
Total 72 100.00% 1 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 masahide nakamura 38 84.44% 1 25.00%
thomas graf 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 trent jaeger 55 80.88% 1 25.00%
thomas graf 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) < 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 steffen klassert 79 49.38% 3 60.00%
mathias krause mathias krause 68 42.50% 1 20.00%
fan du fan du 13 8.12% 1 20.00%
Total 160 100.00% 5 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 david s. miller 210 44.21% 2 12.50%
martin willi martin willi 77 16.21% 2 12.50%
herbert xu herbert xu 63 13.26% 1 6.25%
masahide nakamura masahide nakamura 46 9.68% 2 12.50%
thomas graf thomas graf 21 4.42% 2 12.50%
steffen klassert steffen klassert 16 3.37% 1 6.25%
kunihiro ishiguro kunihiro ishiguro 13 2.74% 1 6.25%
tobias brunner tobias brunner 13 2.74% 1 6.25%
trent jaeger trent jaeger 8 1.68% 1 6.25%
noriaki takamiya noriaki takamiya 3 0.63% 1 6.25%
diego beltrami diego beltrami 3 0.63% 1 6.25%
eric dumazet 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 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 martin willi 170 98.84% 1 50.00%
david s. miller 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 martin willi 52 33.12% 1 11.11%
herbert xu herbert xu 48 30.57% 4 44.44%
david s. miller david s. miller 48 30.57% 1 11.11%
thomas graf thomas graf 6 3.82% 2 22.22%
arnaldo carvalho de melo 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 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;
	int ulen;

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

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

	if (nla_len(rp) < ulen || xfrm_replay_state_esn_len(replay_esn) != ulen)
		return -EINVAL;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
steffen klassert steffen klassert 55 75.34% 1 50.00%
mathias krause mathias krause 18 24.66% 1 50.00%
Total 73 100.00% 2 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;
	int klen, ulen;

	if (!rta)
		return 0;

	up = nla_data(rta);
	klen = xfrm_replay_state_esn_len(up);
	ulen = nla_len(rta) >= 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 steffen klassert 104 68.42% 1 50.00%
mathias krause mathias krause 48 31.58% 1 50.00%
Total 152 100.00% 2 100.00%



static inline int xfrm_user_sec_ctx_size(struct xfrm_sec_ctx *xfrm_ctx)
{
	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 trent jaeger 38 95.00% 1 50.00%
joy latten joy latten 2 5.00% 1 50.00%
Total 40 100.00% 2 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 david s. miller 136 73.91% 3 33.33%
herbert xu herbert xu 27 14.67% 3 33.33%
steffen klassert steffen klassert 9 4.89% 1 11.11%
fan du fan du 9 4.89% 1 11.11%
patrick mchardy 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 jamal hadi salim 176 69.29% 1 16.67%
steffen klassert steffen klassert 56 22.05% 1 16.67%
thomas graf thomas graf 15 5.91% 3 50.00%
mathias krause 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);

	err = __xfrm_init_state(x, false);
	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);

	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 david s. miller 154 30.80% 2 8.33%
thomas graf thomas graf 79 15.80% 3 12.50%
martin willi martin willi 59 11.80% 2 8.33%
jamal hadi salim jamal hadi salim 46 9.20% 2 8.33%
steffen klassert steffen klassert 41 8.20% 2 8.33%
herbert xu herbert xu 38 7.60% 3 12.50%
nicolas dichtel nicolas dichtel 21 4.20% 1 4.17%
alexey dobriyan alexey dobriyan 18 3.60% 3 12.50%
trent jaeger trent jaeger 13 2.60% 1 4.17%
noriaki takamiya noriaki takamiya 13 2.60% 1 4.17%
mathias krause mathias krause 11 2.20% 2 8.33%
krishna kumar krishna kumar 4 0.80% 1 4.17%
wei yongjun wei yongjun 3 0.60% 1 4.17%
Total 500 100.00% 24 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_state_put(x);
		goto out;
	}

	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 david s. miller 82 40.80% 1 5.88%
jamal hadi salim jamal hadi salim 42 20.90% 1 5.88%
herbert xu herbert xu 35 17.41% 4 23.53%
alexey dobriyan alexey dobriyan 14 6.97% 1 5.88%
joy latten joy latten 12 5.97% 2 11.76%
patrick mchardy patrick mchardy 5 2.49% 1 5.88%
thomas graf thomas graf 5 2.49% 3 17.65%
kunihiro ishiguro kunihiro ishiguro 3 1.49% 1 5.88%
christoph hellwig christoph hellwig 1 0.50% 1 5.88%
eric w. biederman eric w. biederman 1 0.50% 1 5.88%
tetsuo handa tetsuo handa 1 0.50% 1 5.88%
Total 201 100.00% 17 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 masahide nakamura 144 81.36% 2 25.00%
jamal hadi salim jamal hadi salim 19 10.73% 2 25.00%
alexey dobriyan alexey dobriyan 11 6.21% 2 25.00%
thomas graf 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 david s. miller 56 30.11% 2 11.76%
jamal hadi salim jamal hadi salim 50 26.88% 1 5.88%
catherine zhang catherine zhang 22 11.83% 1 5.88%
alexey dobriyan alexey dobriyan 14 7.53% 1 5.88%
james morris james morris 12 6.45% 1 5.88%
joy latten joy latten 9 4.84% 1 5.88%
masahide nakamura masahide nakamura 7 3.76% 1 5.88%
thomas graf thomas graf 4 2.15% 3 17.65%
herbert xu herbert xu 3 1.61% 1 5.88%
eric paris eric paris 3 1.61% 1 5.88%
kunihiro ishiguro kunihiro ishiguro 3 1.61% 1 5.88%
eric w. biederman eric w. biederman 1 0.54% 1 5.88%
christoph hellwig christoph hellwig 1 0.54% 1 5.88%
tetsuo handa tetsuo handa 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 david s. miller 175 73.22% 3 42.86%
sowmini varadhan sowmini varadhan 32 13.39% 1 14.29%
herbert xu herbert xu 19 7.95% 2 28.57%
mathias krause 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 thomas graf 109 90.08% 1 50.00%
herbert xu herbert xu 12 9.92% 1 50.00%
Total 121 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 martin willi 109 93.16% 1 50.00%
mathias krause 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->security)
		ret = copy_sec_ctx(x->security, skb);
out:
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
david s. miller david s. miller 256 56.89% 4 23.53%
herbert xu herbert xu 66 14.67% 3 17.65%
nicolas dichtel nicolas dichtel 35 7.78% 2 11.76%
martin willi martin willi 22 4.89% 2 11.76%
ding zhi ding zhi 22 4.89% 1 5.88%
steffen klassert steffen klassert 21 4.67% 1 5.88%
jamal hadi salim jamal hadi salim 14 3.11% 1 5.88%
trent jaeger trent jaeger 11 2.44% 1 5.88%
thomas graf thomas graf 2 0.44% 1 5.88%
eric dumazet eric dumazet 1 0.22% 1 5.88%
Total 450 100.00% 17 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 herbert xu 116 82.86% 1 16.67%
david s. miller david s. miller 18 12.86% 2 33.33%
thomas graf thomas graf 3 2.14% 1 16.67%
arnaldo carvalho de melo arnaldo carvalho de melo 2 1.43% 1 16.67%
eric w. biederman eric w. biederman 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 teras timo teras 37 53.62% 1 33.33%
fan du fan du 23 33.33% 1 33.33%
vegard nossum 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);
		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 nicolas dichtel 102 38.64% 2 22.22%
david s. miller david s. miller 65 24.62% 1 11.11%
timo teras timo teras 61 23.11% 1 11.11%
alexey dobriyan alexey dobriyan 14 5.30% 2 22.22%
vegard nossum vegard nossum 9 3.41% 1 11.11%
andrzej hajda andrzej hajda 9 3.41% 1 11.11%
harald welte harald welte 4 1.52% 1 11.11%
Total 264 100.00% 9 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 david s. miller 91 82.73% 1 25.00%
mathias krause mathias krause 13 11.82% 1 25.00%
harald welte harald welte 4 3.64% 1 25.00%
thomas graf 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 kubecek michal kubecek 61 100.00% 1 100.00%
Total 61 100.00% 1 100.00%



static inline size_t 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 thomas graf 33 64.71% 1 50.00%
christophe gouault christophe gouault 18 35.29% 1 50.00%
Total 51 100.00% 2 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 jamal hadi salim 189 51.92% 2 22.22%
christophe gouault christophe gouault 135 37.09% 1 11.11%
david s. miller david s. miller 27 7.42% 2 22.22%
alexey dobriyan alexey dobriyan 7 1.92% 1 11.11%
johannes berg johannes berg 3 0.82% 1 11.11%
eric w. biederman eric w. biederman 2 0.55% 1 11.11%
lucas de marchi 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 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;

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

	if (build_spdinfo(r_skb, net, sportid, seq, *flags) < 0)
		BUG();

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

Contributors
Person Tokens Prop Commits CommitProp
jamal hadi salim jamal hadi salim 91 75.83% 1 12.50%
alexey dobriyan alexey dobriyan 19 15.83% 2 25.00%
thomas graf thomas graf 6 5.00% 4 50.00%
eric w. biederman eric w. biederman 4 3.33% 1 12.50%
Total 120 100.00% 8 100.00%



static inline size_t 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 thomas graf 30 100.00% 1 100.00%
Total 30 100.00% 1 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 jamal hadi salim 133 76.88% 2 25.00%
david s. miller david s. miller 27 15.61% 2 25.00%
alexey dobriyan alexey dobriyan 7 4.05% 1 12.50%
johannes berg johannes berg 3 1.73% 1 12.50%
eric w. biederman eric w. biederman 2 1.16% 1 12.50%
lucas de marchi 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;

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

	if (build_sadinfo(r_skb, net, sportid, seq, *flags) < 0)
		BUG();

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

Contributors
Person Tokens Prop Commits CommitProp
jamal hadi salim jamal hadi salim 91 75.83% 1 12.50%
alexey dobriyan alexey dobriyan 19 15.83% 2 25.00%
thomas graf thomas graf 6 5.00% 4 50.00%
eric w. biederman eric w. biederman 4 3.33% 1 12.50%
Total 120 100.00% 8 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 david s. miller 112 77.24% 1 9.09%
alexey dobriyan alexey dobriyan 19 13.10% 2 18.18%
masahide nakamura masahide nakamura 6 4.14% 1 9.09%
thomas graf thomas graf 5 3.45% 4 36.36%
christoph hellwig christoph hellwig 1 0.69% 1 9.09%
eric w. biederman eric w. biederman 1 0.69% 1 9.09%
kunihiro ishiguro kunihiro ishiguro 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 david s. miller 176 52.23% 2 10.00%
herbert xu herbert xu 90 26.71% 3 15.00%
jamal hadi salim jamal hadi salim 22 6.53% 2 10.00%
alexey dobriyan alexey dobriyan 21 6.23% 3 15.00%
fan du fan du 15 4.45% 1 5.00%
thomas graf thomas graf 4 1.19% 4 20.00%
hideaki yoshifuji hideaki yoshifuji 4 1.19% 2 10.00%
kunihiro ishiguro kunihiro ishiguro 3 0.89% 1 5.00%
christoph hellwig christoph hellwig 1 0.30% 1 5.00%
eric w. biederman eric w. biederman 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 david s. miller 32 96.97% 1 50.00%
jamal hadi salim 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 masahide nakamura 34 97.14% 1 50.00%
jamal hadi salim 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 david s. miller 64 45.71% 1 20.00%
fan du fan du 39 27.86% 1 20.00%
james morris james morris 34 24.29% 1 20.00%
herbert xu herbert xu 2 1.43% 1 20.00%
eric dumazet 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 trent jaeger 50 83.33% 1 20.00%
thomas graf thomas graf 5 8.33% 2 40.00%
paul moore paul moore 3 5.00% 1 20.00%
nikolay aleksandrov 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 david s. miller 152 83.98% 1 33.33%
herbert xu herbert xu 21 11.60% 1 33.33%
miika komu 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)
{
	int i;

	if (nr > XFRM_MAX_DEPTH)
		return -EINVAL;

	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;

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

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
david s. miller david s. miller 99 99.00% 1 50.00%
eric dumazet eric dumazet 1 1.00% 1 50.00%
Total 100 100.00% 2 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 david s. miller 94 92.16% 2 40.00%
thomas graf thomas graf 7 6.86% 2 40.00%
herbert xu 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 masahide nakamura 74 92.50% 1 25.00%
thomas graf thomas graf 5 6.25% 2 50.00%
jamal hadi salim 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 david s. miller 97 97.98% 2 66.67%
herbert xu 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 david s. miller 132 89.80% 2 50.00%
mathias krause mathias krause 13 8.84% 1 25.00%
herbert xu 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 david s. miller 79 52.32% 1 8.33%
masahide nakamura masahide nakamura 27 17.88% 1 8.33%
trent jaeger trent jaeger 13 8.61% 1 8.33%
jamal hadi salim jamal hadi salim 10 6.62% 1 8.33%
alexey dobriyan alexey dobriyan 7 4.64% 2 16.67%
hideaki yoshifuji hideaki yoshifuji 6 3.97% 1 8.33%
thomas graf thomas graf 5 3.31% 2 16.67%
herbert xu herbert xu 3 1.99% 2 16.67%
americo wang americo 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 david s. miller 100 47.85% 1 5.88%
jamal hadi salim jamal hadi salim 36 17.22% 1 5.88%
trent jaeger trent jaeger 24 11.48% 2 11.76%
alexey dobriyan alexey dobriyan 14 6.70% 1 5.88%
herbert xu herbert xu 12 5.74% 2 11.76%
joy latten joy latten 12 5.74% 2 11.76%
thomas graf thomas graf 5 2.39% 3 17.65%
paul moore paul moore 2 0.96% 1 5.88%
christoph hellwig christoph hellwig 1 0.48% 1 5.88%
eric w. biederman eric w. biederman 1 0.48% 1 5.88%
tetsuo handa tetsuo handa 1 0.48% 1 5.88%
lucas de marchi lucas de marchi 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 david s. miller 113 52.56% 1 14.29%
thomas graf thomas graf 43 20.00% 1 14.29%
trent jaeger trent jaeger 25 11.63% 1 14.29%
herbert xu herbert xu 13 6.05% 1 14.29%
mathias krause mathias krause 13 6.05% 1 14.29%
john williams floroiu john williams floroiu 6 2.79% 1 14.29%
miika komu 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 hallyn serge 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 hallyn serge hallyn 36 100.00% 1 100.00%
Total 36 100.00% 1 100.00%



static inline size_t 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 thomas graf 29 100.00% 1 100.00%
Total 29 100.00% 1 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 masahide nakamura 33 80.49% 1 25.00%
thomas graf thomas graf 6 14.63% 1 25.00%
jamal hadi salim 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 masahide nakamura 16 88.89% 1 33.33%
jamal hadi salim 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 herbert xu 100 50.76% 1 8.33%
david s. miller david s. miller 45 22.84% 2 16.67%
thomas graf thomas graf 19 9.64% 3 25.00%
jamal hadi salim jamal hadi salim 14 7.11% 2 16.67%
trent jaeger trent jaeger 8 4.06% 1 8.33%
masahide nakamura masahide nakamura 8 4.06% 1 8.33%
arnaldo carvalho de melo arnaldo carvalho de melo 2 1.02% 1 8.33%
eric w. biederman eric w. biederman 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[1];
	struct net *net = sock_net(cb->skb->sk);

	xfrm_policy_walk_done(walk, net);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
timo teras timo teras 37 69.81% 1 50.00%
fan du fan du 16 30.19% 1 50.00%
Total 53 100.00% 2 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[1];
	struct xfrm_dump_info info;

	BUILD_BUG_ON(sizeof(struct xfrm_policy_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]) {
		cb->args[0] = 1;
		xfrm_policy_walk_init(walk, XFRM_POLICY_TYPE_ANY);
	}

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

	return skb->len;
}

Contributors
Person Tokens Prop Commits CommitProp
david s. miller david s. miller 65 42.21% 1 14.29%
timo teras timo teras 61 39.61% 1 14.29%
alexey dobriyan alexey dobriyan 14 9.09% 2 28.57%
masahide nakamura masahide nakamura 9 5.84% 1 14.29%
harald welte harald welte 4 2.60% 1 14.29%
thomas walpuski thomas walpuski 1 0.65% 1 14.29%
Total 154 100.00% 7 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 david s. miller 96 83.48% 1 25.00%
mathias krause mathias krause 13 11.30% 1 25.00%
harald welte harald welte 4 3.48% 1 25.00%
thomas graf 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);
	if (delete && err == 0)
		xfrm_garbage_collect(net);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
david s. miller david s. miller 127 29.74% 3 10.00%
herbert xu herbert xu 75 17.56% 4 13.33%
jamal hadi salim jamal hadi salim 59 13.82% 4 13.33%
trent jaeger trent jaeger 58 13.58% 1 3.33%
masahide nakamura masahide nakamura 24 5.62% 1 3.33%
paul moore paul moore 23 5.39% 2 6.67%
alexey dobriyan alexey dobriyan 21 4.92% 3 10.00%
joy latten joy latten 9 2.11% 1 3.33%
thomas graf thomas graf 9 2.11% 4 13.33%
eric paris eric paris 8 1.87% 1 3.33%
catherine zhang catherine zhang 4 0.94% 1 3.33%
denis v. lunev denis v. lunev 4 0.94% 1 3.33%
eric w. biederman eric w. biederman 2 0.47% 1 3.33%
nikolay aleksandrov nikolay aleksandrov 2 0.47% 1 3.33%
christoph hellwig christoph hellwig 1 0.23% 1 3.33%
tetsuo handa tetsuo handa 1 0.23% 1 3.33%
Total 427 100.00% 30 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 jamal hadi salim 65 48.15% 3 18.75%
herbert xu herbert xu 31 22.96% 1 6.25%
alexey dobriyan alexey dobriyan 20 14.81% 3 18.75%
joy latten joy latten 12 8.89% 2 12.50%
thomas graf thomas graf 3 2.22% 3 18.75%
david s. miller david s. miller 1 0.74% 1 6.25%
eric w. biederman eric w. biederman 1 0.74% 1 6.25%
christoph hellwig christoph hellwig 1 0.74% 1 6.25%
tetsuo handa tetsuo handa 1 0.74% 1 6.25%
Total 135 100.00% 16 100.00%



static inline size_t xfrm_aevent_msgsize(struct xfrm_state *x)
{
	size_t 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 thomas graf 42 54.55% 1 25.00%
steffen klassert steffen klassert 25 32.47% 1 25.00%
jamal hadi salim jamal hadi salim 9 11.69% 1 25.00%
nicolas dichtel nicolas dichtel 1 1.30% 1 25.00%
Total 77 100.00% 4 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);
	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 jamal hadi salim 245 64.99% 3 20.00%
david s. miller david s. miller 70 18.57% 3 20.00%
thomas graf thomas graf 30 7.96% 4 26.67%
steffen klassert steffen klassert 23 6.10% 1 6.67%
johannes berg johannes berg 3 0.80% 1 6.67%
nicolas dichtel nicolas dichtel 3 0.80% 1 6.67%
arnaldo carvalho de melo arnaldo carvalho de melo 2 0.53% 1 6.67%
eric w. biederman eric w. biederman 1 0.27% 1 6.67%
Total 377 100.00% 15 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;

	if (build_aevent(r_skb, x, &c) < 0)
		BUG();
	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 jamal hadi salim 189 78.42% 3 23.08%
steffen klassert steffen klassert 25 10.37% 1 7.69%
alexey dobriyan alexey dobriyan 20 8.30% 3 23.08%
thomas graf thomas graf 4 1.66% 4 30.77%
eric w. biederman eric w. biederman 2 0.83% 1 7.69%
christoph hellwig christoph hellwig 1 0.41% 1 7.69%
Total 241 100.00% 13 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 jamal hadi salim 225 70.98% 4 22.22%
steffen klassert steffen klassert 31 9.78% 3 16.67%
michael rossberg michael rossberg 26 8.20% 1 5.56%
alexey dobriyan alexey dobriyan 15 4.73% 2 11.11%
herbert xu herbert xu 8 2.52% 2 11.11%
thomas graf thomas graf 8 2.52% 3 16.67%
mathias krause mathias krause 2 0.63% 1 5.56%
eric w. biederman eric w. biederman 1 0.32% 1 5.56%
christoph hellwig christoph hellwig 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 jamal hadi salim 48 33.10% 3 17.65%
masahide nakamura masahide nakamura 34 23.45% 1 5.88%
herbert xu herbert xu 27 18.62% 2 11.76%
alexey dobriyan alexey dobriyan 20 13.79% 3 17.65%
joy latten joy latten 9 6.21% 2 11.76%
thomas graf thomas graf 3 2.07% 2 11.76%
david s. miller david s. miller 1 0.69% 1 5.88%
tetsuo handa tetsuo handa 1 0.69% 1 5.88%
christoph hellwig christoph hellwig 1 0.69% 1 5.88%
eric w. biederman eric w. biederman 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 jamal hadi salim 227 68.37% 4 18.18%
masahide nakamura masahide nakamura 24 7.23% 1 4.55%
timo teras timo teras 19 5.72% 2 9.09%
alexey dobriyan alexey dobriyan 16 4.82% 2 9.09%
paul moore paul moore 10 3.01% 1 4.55%
thomas graf thomas graf 8 2.41% 3 13.64%
joy latten joy latten 8 2.41% 2 9.09%
eric paris eric paris 8 2.41% 1 4.55%
denis v. lunev denis v. lunev 4 1.20% 1 4.55%
herbert xu herbert xu 2 0.60% 1 4.55%
eric w. biederman eric w. biederman 2 0.60% 1 4.55%
nikolay aleksandrov nikolay aleksandrov 2 0.60% 1 4.55%
christoph hellwig christoph hellwig 1 0.30% 1 4.55%
tetsuo handa tetsuo handa 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 jamal hadi salim 165 80.10% 3 21.43%
alexey dobriyan alexey dobriyan 15 7.28% 2 14.29%
joy latten joy latten 10 4.85% 2 14.29%
david s. miller david s. miller 9 4.37% 1 7.14%
thomas graf thomas graf 3 1.46% 3 21.43%
eric w. biederman eric w. biederman 2 0.97% 1 7.14%
tetsuo handa tetsuo handa 1 0.49% 1 7.14%
christoph hellwig 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 jamal hadi salim 323 82.61% 2 16.67%
thomas graf thomas graf 22 5.63% 4 33.33%
ilpo jarvinen ilpo jarvinen 20 5.12% 1 8.33%
alexey dobriyan alexey dobriyan 17 4.35% 2 16.67%
shinta sugimoto shinta sugimoto 7 1.79% 1 8.33%
christoph hellwig christoph hellwig 1 0.26% 1 8.33%
vegard nossum 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 shinta sugimoto 218 70.78% 1 25.00%
arnaud ebalard arnaud ebalard 84 27.27% 1 25.00%
thomas graf 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);

	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;

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

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
shinta sugimoto shinta sugimoto 120 70.59% 1 14.29%
arnaud ebalard arnaud ebalard 23 13.53% 1 14.29%
fan du fan du 14 8.24% 1 14.29%
thomas graf thomas graf 13 7.65% 4 57.14%
Total 170 100.00% 7 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 shinta sugimoto 24 92.31% 1 33.33%
thomas graf 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 shinta sugimoto 167 98.24% 1 33.33%
thomas graf thomas graf 2 1.18% 1 33.33%
david s. miller 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 arnaud ebalard 105 99.06% 2 66.67%
david s. miller david s. miller 1 0.94% 1 33.33%
Total 106 100.00% 3 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
thomas graf thomas graf 30 57.69% 1 33.33%
arnaud ebalard arnaud ebalard 18 34.62% 1 33.33%
shinta sugimoto shinta sugimoto 4 7.69% 1 33.33%
Total 52 100.00% 3 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, 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;
	}
	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 shinta sugimoto 144 61.54% 1 10.00%
thomas graf thomas graf 36 15.38% 4 40.00%
david s. miller david s. miller 32 13.68% 2 20.00%
arnaud ebalard arnaud ebalard 17 7.26% 1 10.00%
johannes berg johannes berg 3 1.28% 1 10.00%
arnaldo carvalho de melo arnaldo carvalho de melo 2 0.85% 1 10.00%
Total 234 100.00% 10 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)
{
	struct net *net = &init_net;
	struct sk_buff *skb;

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

	/* build migrate */
	if (build_migrate(skb, m, num_migrate, k, sel, dir, type) < 0)
		BUG();

	return xfrm_nlmsg_multicast(net, skb, 0, XFRMNLGRP_MIGRATE);
}
Contributors
Person Tokens Prop Commits CommitProp
shinta sugimoto shinta sugimoto 82 75.23% 1 16.67%
arnaud ebalard arnaud ebalard 11 10.09% 1 16.67%
alexey dobriyan alexey dobriyan 9 8.26% 1 16.67%
thomas graf thomas graf 3 2.75% 1 16.67%
david s. miller david s. miller 3 2.75% 1 16.67%
michal kubecek michal kubecek 1 0.92% 1 16.67%
Total 109 100.00% 6 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)
{
	return -ENOPROTOOPT;
}
Contributors
Person Tokens Prop Commits CommitProp
shinta sugimoto shinta sugimoto 29 78.38% 1 33.33%
arnaud ebalard arnaud ebalard 5 13.51% 1 33.33%
david s. miller david s. miller 3 8.11% 1 33.33%
Total 37 100.00% 3 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) },
};


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 (*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,
						   .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 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 -ENOTSUPP;
#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 = {
				.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);
	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 david s. miller 124 50.00% 1 5.56%
thomas graf thomas graf 47 18.95% 6 33.33%
pablo neira ayuso pablo neira ayuso 24 9.68% 1 5.56%
alexey dobriyan alexey dobriyan 17 6.85% 1 5.56%
fan du fan du 13 5.24% 1 5.56%
christophe gouault christophe gouault 10 4.03% 1 5.56%
thomas walpuski thomas walpuski 6 2.42% 1 5.56%
eric w. biederman eric w. biederman 3 1.21% 2 11.11%
darrel goeddel darrel goeddel 1 0.40% 1 5.56%
andy lutomirski andy lutomirski 1 0.40% 1 5.56%
eric paris eric paris 1 0.40% 1 5.56%
mathias krause mathias krause 1 0.40% 1 5.56%
Total 248 100.00% 18 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
fan du fan du 20 39.22% 1 16.67%
david s. miller david s. miller 20 39.22% 1 16.67%
arjan van de ven arjan van de ven 4 7.84% 1 16.67%
denis v. lunev denis v. lunev 4 7.84% 1 16.67%
thomas graf thomas graf 2 3.92% 1 16.67%
herbert xu herbert xu 1 1.96% 1 16.67%
Total 51 100.00% 6 100.00%



static inline size_t 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 thomas graf 19 67.86% 1 50.00%
jamal hadi salim jamal hadi salim 9 32.14% 1 50.00%
Total 28 100.00% 2 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;

	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 david s. miller 89 67.42% 3 27.27%
jamal hadi salim jamal hadi salim 20 15.15% 2 18.18%
thomas graf thomas graf 17 12.88% 3 27.27%
johannes berg johannes berg 3 2.27% 1 9.09%
arnaldo carvalho de melo arnaldo carvalho de melo 2 1.52% 1 9.09%
eric w. biederman eric w. biederman 1 0.76% 1 9.09%
Total 132 100.00% 11 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 david s. miller 53 60.23% 3 25.00%
jamal hadi salim jamal hadi salim 18 20.45% 3 25.00%
alexey dobriyan alexey dobriyan 11 12.50% 2 16.67%
thomas graf thomas graf 3 3.41% 1 8.33%
herbert xu herbert xu 1 1.14% 1 8.33%
michal kubecek michal kubecek 1 1.14% 1 8.33%
patrick mchardy patrick mchardy 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;

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

	if (build_aevent(skb, x, c) < 0)
		BUG();

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

Contributors
Person Tokens Prop Commits CommitProp
jamal hadi salim jamal hadi salim 64 78.05% 1 14.29%
alexey dobriyan alexey dobriyan 11 13.41% 2 28.57%
steffen klassert steffen klassert 3 3.66% 1 14.29%
thomas graf thomas graf 2 2.44% 1 14.29%
michal kubecek michal kubecek 1 1.22% 1 14.29%
david s. miller david s. miller 1 1.22% 1 14.29%
Total 82 100.00% 7 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 jamal hadi salim 56 38.62% 1 7.14%
david s. miller david s. miller 42 28.97% 2 14.29%
thomas graf thomas graf 26 17.93% 4 28.57%
alexey dobriyan alexey dobriyan 10 6.90% 2 14.29%
herbert xu herbert xu 8 5.52% 2 14.29%
eric w. biederman eric w. biederman 1 0.69% 1 7.14%
michal kubecek michal kubecek 1 0.69% 1 7.14%
patrick mchardy patrick mchardy 1 0.69% 1 7.14%
Total 145 100.00% 14 100.00%



static inline size_t xfrm_sa_len(struct xfrm_state *x)
{
	size_t 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));

	/* 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 jamal hadi salim 74 28.46% 1 6.67%
herbert xu herbert xu 72 27.69% 5 33.33%
martin willi martin willi 44 16.92% 2 13.33%
nicolas dichtel nicolas dichtel 23 8.85% 2 13.33%
steffen klassert steffen klassert 18 6.92% 1 6.67%
ding zhi ding zhi 12 4.62% 1 6.67%
david s. miller david s. miller 10 3.85% 1 6.67%
thomas graf thomas graf 6 2.31% 1 6.67%
eric dumazet eric dumazet 1 0.38% 1 6.67%
Total 260 100.00% 15 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;
	int len = xfrm_sa_len(x);
	int headlen, 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);
		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 herbert xu 136 41.09% 3 17.65%
jamal hadi salim jamal hadi salim 116 35.05% 2 11.76%
thomas graf thomas graf 41 12.39% 5 29.41%
david s. miller david s. miller 24 7.25% 2 11.76%
alexey dobriyan alexey dobriyan 11 3.32% 2 11.76%
eric w. biederman eric w. biederman 1 0.30% 1 5.88%
michal kubecek michal kubecek 1 0.30% 1 5.88%
patrick mchardy patrick mchardy 1 0.30% 1 5.88%
Total 331 100.00% 17 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 jamal hadi salim 81 92.05% 2 40.00%
herbert xu herbert xu 5 5.68% 1 20.00%
david s. miller david s. miller 1 1.14% 1 20.00%
stephen hemminger stephen hemminger 1 1.14% 1 20.00%
Total 88 100.00% 5 100.00%



static inline size_t 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 thomas graf 53 85.48% 1 50.00%
jamal hadi salim jamal hadi salim 9 14.52% 1 50.00%
Total 62 100.00% 2 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 jamal hadi salim 197 71.64% 3 23.08%
david s. miller david s. miller 39 14.18% 1 7.69%
thomas graf thomas graf 17 6.18% 3 23.08%
masahide nakamura masahide nakamura 8 2.91% 1 7.69%
trent jaeger trent jaeger 6 2.18% 1 7.69%
johannes berg johannes berg 3 1.09% 1 7.69%
arnaldo carvalho de melo arnaldo carvalho de melo 2 0.73% 1 7.69%
serge hallyn serge hallyn 2 0.73% 1 7.69%
fan du 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;

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

	if (build_acquire(skb, x, xt, xp) < 0)
		BUG();

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

Contributors
Person Tokens Prop Commits CommitProp
david s. miller david s. miller 42 46.67% 2 22.22%
jamal hadi salim jamal hadi salim 27 30.00% 1 11.11%
alexey dobriyan alexey dobriyan 11 12.22% 1 11.11%
thomas graf thomas graf 5 5.56% 1 11.11%
trent jaeger trent jaeger 2 2.22% 1 11.11%
patrick mchardy patrick mchardy 1 1.11% 1 11.11%
joy latten joy latten 1 1.11% 1 11.11%
michal kubecek michal kubecek 1 1.11% 1 11.11%
Total 90 100.00% 9 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 jamal hadi salim 121 44.49% 1 7.69%
david s. miller david s. miller 83 30.51% 2 15.38%
tom lendacky tom lendacky 28 10.29% 1 7.69%
alexey dobriyan alexey dobriyan 12 4.41% 2 15.38%
herbert xu herbert xu 12 4.41% 2 15.38%
venkat yekkirala venkat yekkirala 7 2.57% 1 7.69%
masahide nakamura masahide nakamura 6 2.21% 1 7.69%
james morris james morris 1 0.37% 1 7.69%
eric dumazet eric dumazet 1 0.37% 1 7.69%
adrian bunk adrian bunk 1 0.37% 1 7.69%
Total 272 100.00% 13 100.00%



static inline size_t 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 thomas graf 48 84.21% 1 50.00%
jamal hadi salim jamal hadi salim 9 15.79% 1 50.00%
Total 57 100.00% 2 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 jamal hadi salim 103 54.50% 4 25.00%
david s. miller david s. miller 46 24.34% 3 18.75%
thomas graf thomas graf 17 8.99% 3 18.75%
trent jaeger trent jaeger 8 4.23% 1 6.25%
masahide nakamura masahide nakamura 8 4.23% 1 6.25%
johannes berg johannes berg 3 1.59% 1 6.25%
arnaldo carvalho de melo arnaldo carvalho de melo 2 1.06% 1 6.25%
tom lendacky tom lendacky 1 0.53% 1 6.25%
eric w. biederman eric w. biederman 1 0.53% 1 6.25%
Total 189 100.00% 16 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;

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

	if (build_polexpire(skb, xp, dir, c) < 0)
		BUG();

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

Contributors
Person Tokens Prop Commits CommitProp
jamal hadi salim jamal hadi salim 48 55.17% 1 12.50%
david s. miller david s. miller 23 26.44% 2 25.00%
alexey dobriyan alexey dobriyan 11 12.64% 2 25.00%
thomas graf thomas graf 3 3.45% 1 12.50%
patrick mchardy patrick mchardy 1 1.15% 1 12.50%
michal kubecek michal kubecek 1 1.15% 1 12.50%
Total 87 100.00% 8 100.00%



static int xfrm_notify_policy(struct xfrm_policy *xp, int dir, const struct km_event *c)
{
	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;
	int headlen, 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 herbert xu 191 48.85% 3 14.29%
jamal hadi salim jamal hadi salim 82 20.97% 4 19.05%
david s. miller david s. miller 52 13.30% 2 9.52%
thomas graf thomas graf 44 11.25% 6 28.57%
alexey dobriyan alexey dobriyan 11 2.81% 2 9.52%
masahide nakamura masahide nakamura 8 2.05% 1 4.76%
patrick mchardy patrick mchardy 1 0.26% 1 4.76%
eric w. biederman eric w. biederman 1 0.26% 1 4.76%
michal kubecek michal kubecek 1 0.26% 1 4.76%
Total 391 100.00% 21 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 herbert xu 46 33.33% 1 7.14%
jamal hadi salim jamal hadi salim 34 24.64% 2 14.29%
david s. miller david s. miller 19 13.77% 2 14.29%
thomas graf thomas graf 18 13.04% 3 21.43%
alexey dobriyan alexey dobriyan 10 7.25% 2 14.29%
masahide nakamura masahide nakamura 8 5.80% 1 7.14%
patrick mchardy patrick mchardy 1 0.72% 1 7.14%
michal kubecek michal kubecek 1 0.72% 1 7.14%
eric w. biederman eric w. biederman 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 jamal hadi salim 75 90.36% 1 20.00%
herbert xu herbert xu 6 7.23% 2 40.00%
stephen hemminger stephen hemminger 1 1.20% 1 20.00%
david s. miller david s. miller 1 1.20% 1 20.00%
Total 83 100.00% 5 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
thomas graf thomas graf 19 100.00% 1 100.00%
Total 19 100.00% 1 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 masahide nakamura 103 71.53% 1 12.50%
david s. miller david s. miller 19 13.19% 2 25.00%
thomas graf thomas graf 17 11.81% 3 37.50%
johannes berg johannes berg 3 2.08% 1 12.50%
arnaldo carvalho de melo 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;

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

	if (build_report(skb, proto, sel, addr) < 0)
		BUG();

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

Contributors
Person Tokens Prop Commits CommitProp
masahide nakamura masahide nakamura 68 87.18% 1 20.00%
alexey dobriyan alexey dobriyan 6 7.69% 2 40.00%
thomas graf thomas graf 3 3.85% 1 20.00%
michal kubecek michal kubecek 1 1.28% 1 20.00%
Total 78 100.00% 5 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
martin willi martin willi 19 100.00% 1 100.00%
Total 19 100.00% 1 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 martin willi 205 98.56% 1 50.00%
johannes berg 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;

	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;

	if (build_mapping(skb, x, ipaddr, sport) < 0)
		BUG();

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

Contributors
Person Tokens Prop Commits CommitProp
martin willi martin willi 96 88.89% 1 33.33%
alexey dobriyan alexey dobriyan 11 10.19% 1 33.33%
michal kubecek michal kubecek 1 0.93% 1 33.33%
Total 108 100.00% 3 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 geanta horia geanta 23 100.00% 1 100.00%
Total 23 100.00% 1 100.00%


static struct xfrm_mgr netlink_mgr = {
	.id		= "netlink",
	.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 david s. miller 21 26.92% 1 12.50%
pablo neira ayuso pablo neira ayuso 18 23.08% 1 12.50%
alexey dobriyan alexey dobriyan 12 15.38% 1 12.50%
patrick mchardy patrick mchardy 12 15.38% 1 12.50%
eric w. biederman eric w. biederman 10 12.82% 2 25.00%
herbert xu herbert xu 4 5.13% 1 12.50%
eric dumazet 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. biederman eric w. biederman 25 44.64% 1 14.29%
alexey dobriyan alexey dobriyan 10 17.86% 1 14.29%
patrick mchardy patrick mchardy 10 17.86% 1 14.29%
david s. miller david s. miller 9 16.07% 2 28.57%
denis v. lunev denis v. lunev 1 1.79% 1 14.29%
stephen hemminger 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 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 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 david s. miller 4085 22.80% 19 8.26%
jamal hadi salim jamal hadi salim 3867 21.59% 23 10.00%
herbert xu herbert xu 1713 9.56% 37 16.09%
thomas graf thomas graf 1508 8.42% 17 7.39%
martin willi martin willi 1075 6.00% 3 1.30%
shinta sugimoto shinta sugimoto 835 4.66% 1 0.43%
masahide nakamura masahide nakamura 766 4.28% 6 2.61%
alexey dobriyan alexey dobriyan 600 3.35% 15 6.52%
steffen klassert steffen klassert 521 2.91% 7 3.04%
christophe gouault christophe gouault 520 2.90% 1 0.43%
trent jaeger trent jaeger 320 1.79% 2 0.87%
arnaud ebalard arnaud ebalard 278 1.55% 2 0.87%
nicolas dichtel nicolas dichtel 236 1.32% 5 2.17%
timo teras timo teras 236 1.32% 3 1.30%
mathias krause mathias krause 229 1.28% 10 4.35%
fan du fan du 163 0.91% 8 3.48%
joy latten joy latten 84 0.47% 4 1.74%
serge hallyn serge hallyn 76 0.42% 1 0.43%
eric w. biederman eric w. biederman 76 0.42% 6 2.61%
michal kubecek michal kubecek 73 0.41% 1 0.43%
james morris james morris 50 0.28% 3 1.30%
pablo neira ayuso pablo neira ayuso 42 0.23% 2 0.87%
paul moore paul moore 38 0.21% 2 0.87%
patrick mchardy patrick mchardy 37 0.21% 4 1.74%
sowmini varadhan sowmini varadhan 35 0.20% 1 0.43%
ding zhi ding zhi 34 0.19% 1 0.43%
tom lendacky tom lendacky 29 0.16% 1 0.43%
horia geanta horia geanta 28 0.16% 1 0.43%
johannes berg johannes berg 27 0.15% 1 0.43%
michael rossberg michael rossberg 26 0.15% 1 0.43%
catherine zhang catherine zhang 26 0.15% 1 0.43%
harald welte harald welte 26 0.15% 2 0.87%
kunihiro ishiguro kunihiro ishiguro 23 0.13% 1 0.43%
eric paris eric paris 20 0.11% 3 1.30%
ilpo jarvinen ilpo jarvinen 20 0.11% 1 0.43%
arnaldo carvalho de melo arnaldo carvalho de melo 19 0.11% 2 0.87%
vegard nossum vegard nossum 19 0.11% 2 0.87%
noriaki takamiya noriaki takamiya 16 0.09% 1 0.43%
christoph hellwig christoph hellwig 14 0.08% 1 0.43%
denis v. lunev denis v. lunev 13 0.07% 3 1.30%
tobias brunner tobias brunner 13 0.07% 1 0.43%
eric dumazet eric dumazet 10 0.06% 3 1.30%
hideaki yoshifuji hideaki yoshifuji 10 0.06% 3 1.30%
miika komu miika komu 10 0.06% 1 0.43%
andrzej hajda andrzej hajda 9 0.05% 1 0.43%
tetsuo handa tetsuo handa 8 0.04% 1 0.43%
thomas walpuski thomas walpuski 7 0.04% 1 0.43%
venkat yekkirala venkat yekkirala 7 0.04% 1 0.43%
nikolay aleksandrov nikolay aleksandrov 6 0.03% 1 0.43%
john williams floroiu john williams floroiu 6 0.03% 1 0.43%
krishna kumar krishna kumar 4 0.02% 1 0.43%
arjan van de ven arjan van de ven 4 0.02% 1 0.43%
lucas de marchi lucas de marchi 3 0.02% 1 0.43%
wei yongjun wei yongjun 3 0.02% 1 0.43%
stephen hemminger stephen hemminger 3 0.02% 2 0.87%
diego beltrami diego beltrami 3 0.02% 1 0.43%
darrel goeddel darrel goeddel 1 0.01% 1 0.43%
andy lutomirski andy lutomirski 1 0.01% 1 0.43%
adrian bunk adrian bunk 1 0.01% 1 0.43%
americo wang americo wang 1 0.01% 1 0.43%
Total 17913 100.00% 230 100.00%
  Directory: net/xfrm

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
david s. miller	david s. miller	76	78.35%	1	16.67%
herbert xu	herbert xu	10	10.31%	1	16.67%
thomas graf	thomas graf	10	10.31%	3	50.00%
eric dumazet	eric dumazet	1	1.03%	1	16.67%
	Total	97	100.00%	6	100.00%
cregit-Linux how code gets into the kernel

Release 4.8 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
