[mirror_ubuntu-artful-kernel.git] / net / ipv4 / gre.c

/*
 *	GRE over IPv4 demultiplexer driver
 *
 *	Authors: Dmitry Kozlov (xeb@mail.ru)
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License
 *	as published by the Free Software Foundation; either version
 *	2 of the License, or (at your option) any later version.
 *
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/kmod.h>
#include <linux/skbuff.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/netdevice.h>
#include <linux/spinlock.h>
#include <net/protocol.h>
#include <net/gre.h>


static const struct gre_protocol __rcu *gre_proto[GREPROTO_MAX] __read_mostly;
static DEFINE_SPINLOCK(gre_proto_lock);

int gre_add_protocol(const struct gre_protocol *proto, u8 version)
{
	if (version >= GREPROTO_MAX)
		goto err_out;

	spin_lock(&gre_proto_lock);
	if (gre_proto[version])
		goto err_out_unlock;

	RCU_INIT_POINTER(gre_proto[version], proto);
	spin_unlock(&gre_proto_lock);
	return 0;

err_out_unlock:
	spin_unlock(&gre_proto_lock);
err_out:
	return -1;
}
EXPORT_SYMBOL_GPL(gre_add_protocol);

int gre_del_protocol(const struct gre_protocol *proto, u8 version)
{
	if (version >= GREPROTO_MAX)
		goto err_out;

	spin_lock(&gre_proto_lock);
	if (rcu_dereference_protected(gre_proto[version],
			lockdep_is_held(&gre_proto_lock)) != proto)
		goto err_out_unlock;
	RCU_INIT_POINTER(gre_proto[version], NULL);
	spin_unlock(&gre_proto_lock);
	synchronize_rcu();
	return 0;

err_out_unlock:
	spin_unlock(&gre_proto_lock);
err_out:
	return -1;
}
EXPORT_SYMBOL_GPL(gre_del_protocol);

static int gre_rcv(struct sk_buff *skb)
{
	const struct gre_protocol *proto;
	u8 ver;
	int ret;

	if (!pskb_may_pull(skb, 12))
		goto drop;

	ver = skb->data[1]&0x7f;
	if (ver >= GREPROTO_MAX)
		goto drop;

	rcu_read_lock();
	proto = rcu_dereference(gre_proto[ver]);
	if (!proto || !proto->handler)
		goto drop_unlock;
	ret = proto->handler(skb);
	rcu_read_unlock();
	return ret;

drop_unlock:
	rcu_read_unlock();
drop:
	kfree_skb(skb);
	return NET_RX_DROP;
}

static void gre_err(struct sk_buff *skb, u32 info)
{
	const struct gre_protocol *proto;
	const struct iphdr *iph = (const struct iphdr *)skb->data;
	u8 ver = skb->data[(iph->ihl<<2) + 1]&0x7f;

	if (ver >= GREPROTO_MAX)
		return;

	rcu_read_lock();
	proto = rcu_dereference(gre_proto[ver]);
	if (proto && proto->err_handler)
		proto->err_handler(skb, info);
	rcu_read_unlock();
}

static const struct net_protocol net_gre_protocol = {
	.handler     = gre_rcv,
	.err_handler = gre_err,
	.netns_ok    = 1,
};

static int __init gre_init(void)
{
	pr_info("GRE over IPv4 demultiplexor driver\n");

	if (inet_add_protocol(&net_gre_protocol, IPPROTO_GRE) < 0) {
		pr_err("can't add protocol\n");
		return -EAGAIN;
	}

	return 0;
}

static void __exit gre_exit(void)
{
	inet_del_protocol(&net_gre_protocol, IPPROTO_GRE);
}

module_init(gre_init);
module_exit(gre_exit);

MODULE_DESCRIPTION("GRE over IPv4 demultiplexer driver");
MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");
MODULE_LICENSE("GPL");
Commit	Line	Data
00959ade DK	1	/*
	2	* GRE over IPv4 demultiplexer driver
	3	*
	4	* Authors: Dmitry Kozlov (xeb@mail.ru)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*
	11	*/
	12
afd46503 JP	13	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
afd46503 JP	14
00959ade DK	15	#include <linux/module.h>
	16	#include <linux/kernel.h>
	17	#include <linux/kmod.h>
	18	#include <linux/skbuff.h>
	19	#include <linux/in.h>
559fafb9	20	#include <linux/ip.h>
00959ade	21	#include <linux/netdevice.h>
00959ade DK	22	#include <linux/spinlock.h>
	23	#include <net/protocol.h>
	24	#include <net/gre.h>
	25
	26
6f0bcf15	27	static const struct gre_protocol __rcu *gre_proto[GREPROTO_MAX] __read_mostly;
00959ade DK	28	static DEFINE_SPINLOCK(gre_proto_lock);
	29
	30	int gre_add_protocol(const struct gre_protocol *proto, u8 version)
	31	{
	32	if (version >= GREPROTO_MAX)
	33	goto err_out;
	34
	35	spin_lock(&gre_proto_lock);
	36	if (gre_proto[version])
	37	goto err_out_unlock;
	38
a9b3cd7f	39	RCU_INIT_POINTER(gre_proto[version], proto);
00959ade DK	40	spin_unlock(&gre_proto_lock);
	41	return 0;
	42
	43	err_out_unlock:
	44	spin_unlock(&gre_proto_lock);
	45	err_out:
	46	return -1;
	47	}
	48	EXPORT_SYMBOL_GPL(gre_add_protocol);
	49
	50	int gre_del_protocol(const struct gre_protocol *proto, u8 version)
	51	{
	52	if (version >= GREPROTO_MAX)
	53	goto err_out;
	54
	55	spin_lock(&gre_proto_lock);
6f0bcf15 ED	56	if (rcu_dereference_protected(gre_proto[version],
6f0bcf15 ED	57	lockdep_is_held(&gre_proto_lock)) != proto)
00959ade	58	goto err_out_unlock;
a9b3cd7f	59	RCU_INIT_POINTER(gre_proto[version], NULL);
00959ade DK	60	spin_unlock(&gre_proto_lock);
	61	synchronize_rcu();
	62	return 0;
	63
	64	err_out_unlock:
	65	spin_unlock(&gre_proto_lock);
	66	err_out:
	67	return -1;
	68	}
	69	EXPORT_SYMBOL_GPL(gre_del_protocol);
	70
	71	static int gre_rcv(struct sk_buff *skb)
	72	{
	73	const struct gre_protocol *proto;
	74	u8 ver;
	75	int ret;
	76
	77	if (!pskb_may_pull(skb, 12))
	78	goto drop;
	79
	80	ver = skb->data[1]&0x7f;
	81	if (ver >= GREPROTO_MAX)
	82	goto drop;
	83
	84	rcu_read_lock();
	85	proto = rcu_dereference(gre_proto[ver]);
	86	if (!proto \|\| !proto->handler)
	87	goto drop_unlock;
	88	ret = proto->handler(skb);
	89	rcu_read_unlock();
	90	return ret;
	91
	92	drop_unlock:
	93	rcu_read_unlock();
	94	drop:
	95	kfree_skb(skb);
	96	return NET_RX_DROP;
	97	}
	98
	99	static void gre_err(struct sk_buff *skb, u32 info)
	100	{
	101	const struct gre_protocol *proto;
559fafb9	102	const struct iphdr iph = (const struct iphdr )skb->data;
559fafb9	103	u8 ver = skb->data[(iph->ihl<<2) + 1]&0x7f;
00959ade	104
00959ade	105	if (ver >= GREPROTO_MAX)
559fafb9	106	return;
00959ade DK	107
	108	rcu_read_lock();
	109	proto = rcu_dereference(gre_proto[ver]);
559fafb9	110	if (proto && proto->err_handler)
559fafb9	111	proto->err_handler(skb, info);
00959ade	112	rcu_read_unlock();
00959ade DK	113	}
	114
	115	static const struct net_protocol net_gre_protocol = {
	116	.handler = gre_rcv,
	117	.err_handler = gre_err,
	118	.netns_ok = 1,
	119	};
	120
	121	static int __init gre_init(void)
	122	{
afd46503	123	pr_info("GRE over IPv4 demultiplexor driver\n");
00959ade DK	124
00959ade DK	125	if (inet_add_protocol(&net_gre_protocol, IPPROTO_GRE) < 0) {
afd46503	126	pr_err("can't add protocol\n");
00959ade DK	127	return -EAGAIN;
	128	}
	129
	130	return 0;
	131	}
	132
	133	static void __exit gre_exit(void)
	134	{
	135	inet_del_protocol(&net_gre_protocol, IPPROTO_GRE);
	136	}
	137
	138	module_init(gre_init);
	139	module_exit(gre_exit);
	140
	141	MODULE_DESCRIPTION("GRE over IPv4 demultiplexer driver");
	142	MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");
	143	MODULE_LICENSE("GPL");
	144