1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 *	GRE over IPv4 demultiplexer driver
  4 *
  5 *	Authors: Dmitry Kozlov (xeb@mail.ru)
  6 */
  7
  8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  9
 10#include <linux/module.h>
 11#include <linux/if.h>
 12#include <linux/icmp.h>
 13#include <linux/kernel.h>
 14#include <linux/kmod.h>
 15#include <linux/skbuff.h>
 16#include <linux/in.h>
 17#include <linux/ip.h>
 18#include <linux/netdevice.h>
 19#include <linux/if_tunnel.h>
 20#include <linux/spinlock.h>
 21#include <net/protocol.h>
 22#include <net/gre.h>
 23#include <net/erspan.h>
 24
 25#include <net/icmp.h>
 26#include <net/route.h>
 27#include <net/xfrm.h>
 28
 29static const struct gre_protocol __rcu *gre_proto[GREPROTO_MAX] __read_mostly;
 30
 31int gre_add_protocol(const struct gre_protocol *proto, u8 version)
 32{
 33	if (version >= GREPROTO_MAX)
 34		return -EINVAL;
 35
 36	return (cmpxchg((const struct gre_protocol **)&gre_proto[version], NULL, proto) == NULL) ?
 37		0 : -EBUSY;
 38}
 39EXPORT_SYMBOL_GPL(gre_add_protocol);
 40
 41int gre_del_protocol(const struct gre_protocol *proto, u8 version)
 42{
 43	int ret;
 44
 45	if (version >= GREPROTO_MAX)
 46		return -EINVAL;
 47
 48	ret = (cmpxchg((const struct gre_protocol **)&gre_proto[version], proto, NULL) == proto) ?
 49		0 : -EBUSY;
 50
 51	if (ret)
 52		return ret;
 53
 54	synchronize_rcu();
 55	return 0;
 56}
 57EXPORT_SYMBOL_GPL(gre_del_protocol);
 58
 59/* Fills in tpi and returns header length to be pulled. */
 60int gre_parse_header(struct sk_buff *skb, struct tnl_ptk_info *tpi,
 61		     bool *csum_err, __be16 proto, int nhs)
 62{
 63	const struct gre_base_hdr *greh;
 64	__be32 *options;
 65	int hdr_len;
 66
 67	if (unlikely(!pskb_may_pull(skb, nhs + sizeof(struct gre_base_hdr))))
 68		return -EINVAL;
 69
 70	greh = (struct gre_base_hdr *)(skb->data + nhs);
 71	if (unlikely(greh->flags & (GRE_VERSION | GRE_ROUTING)))
 72		return -EINVAL;
 73
 74	tpi->flags = gre_flags_to_tnl_flags(greh->flags);
 75	hdr_len = gre_calc_hlen(tpi->flags);
 76
 77	if (!pskb_may_pull(skb, nhs + hdr_len))
 78		return -EINVAL;
 79
 80	greh = (struct gre_base_hdr *)(skb->data + nhs);
 81	tpi->proto = greh->protocol;
 82
 83	options = (__be32 *)(greh + 1);
 84	if (greh->flags & GRE_CSUM) {
 85		if (!skb_checksum_simple_validate(skb)) {
 86			skb_checksum_try_convert(skb, IPPROTO_GRE,
 87						 null_compute_pseudo);
 88		} else if (csum_err) {
 89			*csum_err = true;
 90			return -EINVAL;
 91		}
 92
 93		options++;
 94	}
 95
 96	if (greh->flags & GRE_KEY) {
 97		tpi->key = *options;
 98		options++;
 99	} else {
100		tpi->key = 0;
101	}
102	if (unlikely(greh->flags & GRE_SEQ)) {
103		tpi->seq = *options;
104		options++;
105	} else {
106		tpi->seq = 0;
107	}
108	/* WCCP version 1 and 2 protocol decoding.
109	 * - Change protocol to IPv4/IPv6
110	 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
111	 */
112	if (greh->flags == 0 && tpi->proto == htons(ETH_P_WCCP)) {
113		tpi->proto = proto;
114		if ((*(u8 *)options & 0xF0) != 0x40)
115			hdr_len += 4;
116	}
117	tpi->hdr_len = hdr_len;
118
119	/* ERSPAN ver 1 and 2 protocol sets GRE key field
120	 * to 0 and sets the configured key in the
121	 * inner erspan header field
122	 */
123	if (greh->protocol == htons(ETH_P_ERSPAN) ||
124	    greh->protocol == htons(ETH_P_ERSPAN2)) {
125		struct erspan_base_hdr *ershdr;
126
127		if (!pskb_may_pull(skb, nhs + hdr_len + sizeof(*ershdr)))
128			return -EINVAL;
129
130		ershdr = (struct erspan_base_hdr *)options;
131		tpi->key = cpu_to_be32(get_session_id(ershdr));
132	}
133
134	return hdr_len;
135}
136EXPORT_SYMBOL(gre_parse_header);
137
138static int gre_rcv(struct sk_buff *skb)
139{
140	const struct gre_protocol *proto;
141	u8 ver;
142	int ret;
143
144	if (!pskb_may_pull(skb, 12))
145		goto drop;
146
147	ver = skb->data[1]&0x7f;
148	if (ver >= GREPROTO_MAX)
149		goto drop;
150
151	rcu_read_lock();
152	proto = rcu_dereference(gre_proto[ver]);
153	if (!proto || !proto->handler)
154		goto drop_unlock;
155	ret = proto->handler(skb);
156	rcu_read_unlock();
157	return ret;
158
159drop_unlock:
160	rcu_read_unlock();
161drop:
162	kfree_skb(skb);
163	return NET_RX_DROP;
164}
165
166static int gre_err(struct sk_buff *skb, u32 info)
167{
168	const struct gre_protocol *proto;
169	const struct iphdr *iph = (const struct iphdr *)skb->data;
170	u8 ver = skb->data[(iph->ihl<<2) + 1]&0x7f;
171	int err = 0;
172
173	if (ver >= GREPROTO_MAX)
174		return -EINVAL;
175
176	rcu_read_lock();
177	proto = rcu_dereference(gre_proto[ver]);
178	if (proto && proto->err_handler)
179		proto->err_handler(skb, info);
180	else
181		err = -EPROTONOSUPPORT;
182	rcu_read_unlock();
183
184	return err;
185}
186
187static const struct net_protocol net_gre_protocol = {
188	.handler     = gre_rcv,
189	.err_handler = gre_err,
190	.netns_ok    = 1,
191};
192
193static int __init gre_init(void)
194{
195	pr_info("GRE over IPv4 demultiplexor driver\n");
196
197	if (inet_add_protocol(&net_gre_protocol, IPPROTO_GRE) < 0) {
198		pr_err("can't add protocol\n");
199		return -EAGAIN;
200	}
201	return 0;
202}
203
204static void __exit gre_exit(void)
205{
206	inet_del_protocol(&net_gre_protocol, IPPROTO_GRE);
207}
208
209module_init(gre_init);
210module_exit(gre_exit);
211
212MODULE_DESCRIPTION("GRE over IPv4 demultiplexer driver");
213MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");
214MODULE_LICENSE("GPL");