[mirror_ubuntu-artful-kernel.git] / net / xfrm / xfrm_input.c

/*
 * xfrm_input.c
 *
 * Changes:
 * 	YOSHIFUJI Hideaki @USAGI
 * 		Split up af-specific portion
 *
 */

#include <linux/slab.h>
#include <linux/module.h>
#include <net/ip.h>
#include <net/xfrm.h>

static struct kmem_cache *secpath_cachep __read_mostly;

void __secpath_destroy(struct sec_path *sp)
{
	int i;
	for (i = 0; i < sp->len; i++)
		xfrm_state_put(sp->xvec[i]);
	kmem_cache_free(secpath_cachep, sp);
}
EXPORT_SYMBOL(__secpath_destroy);

struct sec_path *secpath_dup(struct sec_path *src)
{
	struct sec_path *sp;

	sp = kmem_cache_alloc(secpath_cachep, GFP_ATOMIC);
	if (!sp)
		return NULL;

	sp->len = 0;
	if (src) {
		int i;

		memcpy(sp, src, sizeof(*sp));
		for (i = 0; i < sp->len; i++)
			xfrm_state_hold(sp->xvec[i]);
	}
	atomic_set(&sp->refcnt, 1);
	return sp;
}
EXPORT_SYMBOL(secpath_dup);

/* Fetch spi and seq from ipsec header */

int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq)
{
	int offset, offset_seq;
	int hlen;

	switch (nexthdr) {
	case IPPROTO_AH:
		hlen = sizeof(struct ip_auth_hdr);
		offset = offsetof(struct ip_auth_hdr, spi);
		offset_seq = offsetof(struct ip_auth_hdr, seq_no);
		break;
	case IPPROTO_ESP:
		hlen = sizeof(struct ip_esp_hdr);
		offset = offsetof(struct ip_esp_hdr, spi);
		offset_seq = offsetof(struct ip_esp_hdr, seq_no);
		break;
	case IPPROTO_COMP:
		if (!pskb_may_pull(skb, sizeof(struct ip_comp_hdr)))
			return -EINVAL;
		*spi = htonl(ntohs(*(__be16*)(skb_transport_header(skb) + 2)));
		*seq = 0;
		return 0;
	default:
		return 1;
	}

	if (!pskb_may_pull(skb, hlen))
		return -EINVAL;

	*spi = *(__be32*)(skb_transport_header(skb) + offset);
	*seq = *(__be32*)(skb_transport_header(skb) + offset_seq);
	return 0;
}
EXPORT_SYMBOL(xfrm_parse_spi);

int xfrm_prepare_input(struct xfrm_state *x, struct sk_buff *skb)
{
	int err;

	err = x->outer_mode->afinfo->extract_input(x, skb);
	if (err)
		return err;

	skb->protocol = x->inner_mode->afinfo->eth_proto;
	return x->inner_mode->input2(x, skb);
}
EXPORT_SYMBOL(xfrm_prepare_input);

void __init xfrm_input_init(void)
{
	secpath_cachep = kmem_cache_create("secpath_cache",
					   sizeof(struct sec_path),
					   0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
					   NULL);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* xfrm_input.c
	3	*
	4	* Changes:
	5	* YOSHIFUJI Hideaki @USAGI
	6	* Split up af-specific portion
a716c119	7	*
1da177e4 LT	8	*/
	9
	10	#include <linux/slab.h>
	11	#include <linux/module.h>
	12	#include <net/ip.h>
	13	#include <net/xfrm.h>
	14
e18b890b	15	static struct kmem_cache *secpath_cachep __read_mostly;
1da177e4 LT	16
	17	void __secpath_destroy(struct sec_path *sp)
	18	{
	19	int i;
	20	for (i = 0; i < sp->len; i++)
dbe5b4aa	21	xfrm_state_put(sp->xvec[i]);
1da177e4 LT	22	kmem_cache_free(secpath_cachep, sp);
	23	}
	24	EXPORT_SYMBOL(__secpath_destroy);
	25
	26	struct sec_path secpath_dup(struct sec_path src)
	27	{
	28	struct sec_path *sp;
	29
54e6ecb2	30	sp = kmem_cache_alloc(secpath_cachep, GFP_ATOMIC);
1da177e4 LT	31	if (!sp)
	32	return NULL;
	33
	34	sp->len = 0;
	35	if (src) {
	36	int i;
	37
	38	memcpy(sp, src, sizeof(*sp));
	39	for (i = 0; i < sp->len; i++)
dbe5b4aa	40	xfrm_state_hold(sp->xvec[i]);
1da177e4 LT	41	}
	42	atomic_set(&sp->refcnt, 1);
	43	return sp;
	44	}
	45	EXPORT_SYMBOL(secpath_dup);
	46
	47	/* Fetch spi and seq from ipsec header */
	48
6067b2ba	49	int xfrm_parse_spi(struct sk_buff skb, u8 nexthdr, __be32 spi, __be32 *seq)
1da177e4 LT	50	{
1da177e4 LT	51	int offset, offset_seq;
44072500	52	int hlen;
1da177e4 LT	53
	54	switch (nexthdr) {
	55	case IPPROTO_AH:
44072500	56	hlen = sizeof(struct ip_auth_hdr);
1da177e4 LT	57	offset = offsetof(struct ip_auth_hdr, spi);
	58	offset_seq = offsetof(struct ip_auth_hdr, seq_no);
	59	break;
	60	case IPPROTO_ESP:
44072500	61	hlen = sizeof(struct ip_esp_hdr);
1da177e4 LT	62	offset = offsetof(struct ip_esp_hdr, spi);
	63	offset_seq = offsetof(struct ip_esp_hdr, seq_no);
	64	break;
	65	case IPPROTO_COMP:
	66	if (!pskb_may_pull(skb, sizeof(struct ip_comp_hdr)))
	67	return -EINVAL;
9c70220b	68	spi = htonl(ntohs((__be16*)(skb_transport_header(skb) + 2)));
1da177e4 LT	69	*seq = 0;
	70	return 0;
	71	default:
	72	return 1;
	73	}
	74
44072500	75	if (!pskb_may_pull(skb, hlen))
1da177e4 LT	76	return -EINVAL;
1da177e4 LT	77
9c70220b ACM	78	spi = (__be32*)(skb_transport_header(skb) + offset);
9c70220b ACM	79	seq = (__be32*)(skb_transport_header(skb) + offset_seq);
1da177e4 LT	80	return 0;
	81	}
	82	EXPORT_SYMBOL(xfrm_parse_spi);
	83
227620e2 HX	84	int xfrm_prepare_input(struct xfrm_state x, struct sk_buff skb)
	85	{
	86	int err;
	87
	88	err = x->outer_mode->afinfo->extract_input(x, skb);
	89	if (err)
	90	return err;
	91
	92	skb->protocol = x->inner_mode->afinfo->eth_proto;
	93	return x->inner_mode->input2(x, skb);
	94	}
	95	EXPORT_SYMBOL(xfrm_prepare_input);
	96
1da177e4 LT	97	void __init xfrm_input_init(void)
	98	{
	99	secpath_cachep = kmem_cache_create("secpath_cache",
	100	sizeof(struct sec_path),
e5d679f3	101	0, SLAB_HWCACHE_ALIGN\|SLAB_PANIC,
20c2df83	102	NULL);
1da177e4	103	}