2 * GRE over IPv4 demultiplexer driver
4 * Authors: Dmitry Kozlov (xeb@mail.ru)
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.
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 #include <linux/module.h>
17 #include <linux/icmp.h>
18 #include <linux/kernel.h>
19 #include <linux/kmod.h>
20 #include <linux/skbuff.h>
23 #include <linux/netdevice.h>
24 #include <linux/if_tunnel.h>
25 #include <linux/spinlock.h>
26 #include <net/protocol.h>
30 #include <net/route.h>
33 static const struct gre_protocol __rcu *gre_proto[GREPROTO_MAX] __read_mostly;
34 static struct gre_cisco_protocol __rcu *gre_cisco_proto_list[GRE_IP_PROTO_MAX];
36 int gre_add_protocol(const struct gre_protocol *proto, u8 version)
38 if (version >= GREPROTO_MAX)
41 return (cmpxchg((const struct gre_protocol **)&gre_proto[version], NULL, proto) == NULL) ?
44 EXPORT_SYMBOL_GPL(gre_add_protocol);
46 int gre_del_protocol(const struct gre_protocol *proto, u8 version)
50 if (version >= GREPROTO_MAX)
53 ret = (cmpxchg((const struct gre_protocol **)&gre_proto[version], proto, NULL) == proto) ?
62 EXPORT_SYMBOL_GPL(gre_del_protocol);
64 void gre_build_header(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
67 struct gre_base_hdr *greh;
69 skb_push(skb, hdr_len);
71 greh = (struct gre_base_hdr *)skb->data;
72 greh->flags = tnl_flags_to_gre_flags(tpi->flags);
73 greh->protocol = tpi->proto;
75 if (tpi->flags&(TUNNEL_KEY|TUNNEL_CSUM|TUNNEL_SEQ)) {
76 __be32 *ptr = (__be32 *)(((u8 *)greh) + hdr_len - 4);
78 if (tpi->flags&TUNNEL_SEQ) {
82 if (tpi->flags&TUNNEL_KEY) {
86 if (tpi->flags&TUNNEL_CSUM &&
87 !(skb_shinfo(skb)->gso_type & SKB_GSO_GRE)) {
89 *(__sum16 *)ptr = csum_fold(skb_checksum(skb, 0,
94 EXPORT_SYMBOL_GPL(gre_build_header);
96 static __sum16 check_checksum(struct sk_buff *skb)
100 switch (skb->ip_summed) {
101 case CHECKSUM_COMPLETE:
102 csum = csum_fold(skb->csum);
110 csum = __skb_checksum_complete(skb);
111 skb->ip_summed = CHECKSUM_COMPLETE;
118 static int parse_gre_header(struct sk_buff *skb, struct tnl_ptk_info *tpi,
121 unsigned int ip_hlen = ip_hdrlen(skb);
122 const struct gre_base_hdr *greh;
126 if (unlikely(!pskb_may_pull(skb, sizeof(struct gre_base_hdr))))
129 greh = (struct gre_base_hdr *)(skb_network_header(skb) + ip_hlen);
130 if (unlikely(greh->flags & (GRE_VERSION | GRE_ROUTING)))
133 tpi->flags = gre_flags_to_tnl_flags(greh->flags);
134 hdr_len = ip_gre_calc_hlen(tpi->flags);
136 if (!pskb_may_pull(skb, hdr_len))
139 greh = (struct gre_base_hdr *)(skb_network_header(skb) + ip_hlen);
140 tpi->proto = greh->protocol;
142 options = (__be32 *)(greh + 1);
143 if (greh->flags & GRE_CSUM) {
144 if (check_checksum(skb)) {
151 if (greh->flags & GRE_KEY) {
157 if (unlikely(greh->flags & GRE_SEQ)) {
163 /* WCCP version 1 and 2 protocol decoding.
164 * - Change protocol to IP
165 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
167 if (greh->flags == 0 && tpi->proto == htons(ETH_P_WCCP)) {
168 tpi->proto = htons(ETH_P_IP);
169 if ((*(u8 *)options & 0xF0) != 0x40) {
171 if (!pskb_may_pull(skb, hdr_len))
178 static int gre_cisco_rcv(struct sk_buff *skb)
180 struct tnl_ptk_info tpi;
182 bool csum_err = false;
184 if (parse_gre_header(skb, &tpi, &csum_err) < 0)
188 for (i = 0; i < GRE_IP_PROTO_MAX; i++) {
189 struct gre_cisco_protocol *proto;
192 proto = rcu_dereference(gre_cisco_proto_list[i]);
195 ret = proto->handler(skb, &tpi);
196 if (ret == PACKET_RCVD) {
203 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
209 static void gre_cisco_err(struct sk_buff *skb, u32 info)
211 /* All the routers (except for Linux) return only
212 * 8 bytes of packet payload. It means, that precise relaying of
213 * ICMP in the real Internet is absolutely infeasible.
215 * Moreover, Cisco "wise men" put GRE key to the third word
216 * in GRE header. It makes impossible maintaining even soft
218 * GRE tunnels with enabled checksum. Tell them "thank you".
220 * Well, I wonder, rfc1812 was written by Cisco employee,
221 * what the hell these idiots break standards established
225 const int type = icmp_hdr(skb)->type;
226 const int code = icmp_hdr(skb)->code;
227 struct tnl_ptk_info tpi;
228 bool csum_err = false;
231 if (parse_gre_header(skb, &tpi, &csum_err)) {
232 if (!csum_err) /* ignore csum errors. */
236 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
237 ipv4_update_pmtu(skb, dev_net(skb->dev), info,
238 skb->dev->ifindex, 0, IPPROTO_GRE, 0);
241 if (type == ICMP_REDIRECT) {
242 ipv4_redirect(skb, dev_net(skb->dev), skb->dev->ifindex, 0,
248 for (i = 0; i < GRE_IP_PROTO_MAX; i++) {
249 struct gre_cisco_protocol *proto;
251 proto = rcu_dereference(gre_cisco_proto_list[i]);
255 if (proto->err_handler(skb, info, &tpi) == PACKET_RCVD)
263 static int gre_rcv(struct sk_buff *skb)
265 const struct gre_protocol *proto;
269 if (!pskb_may_pull(skb, 12))
272 ver = skb->data[1]&0x7f;
273 if (ver >= GREPROTO_MAX)
277 proto = rcu_dereference(gre_proto[ver]);
278 if (!proto || !proto->handler)
280 ret = proto->handler(skb);
291 static void gre_err(struct sk_buff *skb, u32 info)
293 const struct gre_protocol *proto;
294 const struct iphdr *iph = (const struct iphdr *)skb->data;
295 u8 ver = skb->data[(iph->ihl<<2) + 1]&0x7f;
297 if (ver >= GREPROTO_MAX)
301 proto = rcu_dereference(gre_proto[ver]);
302 if (proto && proto->err_handler)
303 proto->err_handler(skb, info);
307 static struct sk_buff *gre_gso_segment(struct sk_buff *skb,
308 netdev_features_t features)
310 struct sk_buff *segs = ERR_PTR(-EINVAL);
311 netdev_features_t enc_features;
312 int ghl = GRE_HEADER_SECTION;
313 struct gre_base_hdr *greh;
314 int mac_len = skb->mac_len;
315 __be16 protocol = skb->protocol;
319 if (unlikely(skb_shinfo(skb)->gso_type &
328 if (unlikely(!pskb_may_pull(skb, sizeof(*greh))))
331 greh = (struct gre_base_hdr *)skb_transport_header(skb);
333 if (greh->flags & GRE_KEY)
334 ghl += GRE_HEADER_SECTION;
335 if (greh->flags & GRE_SEQ)
336 ghl += GRE_HEADER_SECTION;
337 if (greh->flags & GRE_CSUM) {
338 ghl += GRE_HEADER_SECTION;
343 /* setup inner skb. */
344 skb->protocol = greh->protocol;
345 skb->encapsulation = 0;
347 if (unlikely(!pskb_may_pull(skb, ghl)))
349 __skb_pull(skb, ghl);
350 skb_reset_mac_header(skb);
351 skb_set_network_header(skb, skb_inner_network_offset(skb));
352 skb->mac_len = skb_inner_network_offset(skb);
354 /* segment inner packet. */
355 enc_features = skb->dev->hw_enc_features & netif_skb_features(skb);
356 segs = skb_mac_gso_segment(skb, enc_features);
357 if (!segs || IS_ERR(segs))
361 tnl_hlen = skb_tnl_header_len(skb);
363 __skb_push(skb, ghl);
367 if (skb_has_shared_frag(skb)) {
370 err = __skb_linearize(skb);
378 greh = (struct gre_base_hdr *)(skb->data);
379 pcsum = (__be32 *)(greh + 1);
381 *(__sum16 *)pcsum = csum_fold(skb_checksum(skb, 0, skb->len, 0));
383 __skb_push(skb, tnl_hlen - ghl);
385 skb_reset_mac_header(skb);
386 skb_set_network_header(skb, mac_len);
387 skb->mac_len = mac_len;
388 skb->protocol = protocol;
389 } while ((skb = skb->next));
394 static int gre_gso_send_check(struct sk_buff *skb)
396 if (!skb->encapsulation)
401 static const struct net_protocol net_gre_protocol = {
403 .err_handler = gre_err,
407 static const struct net_offload gre_offload = {
409 .gso_send_check = gre_gso_send_check,
410 .gso_segment = gre_gso_segment,
414 static const struct gre_protocol ipgre_protocol = {
415 .handler = gre_cisco_rcv,
416 .err_handler = gre_cisco_err,
419 int gre_cisco_register(struct gre_cisco_protocol *newp)
421 struct gre_cisco_protocol **proto = (struct gre_cisco_protocol **)
422 &gre_cisco_proto_list[newp->priority];
424 return (cmpxchg(proto, NULL, newp) == NULL) ? 0 : -EBUSY;
426 EXPORT_SYMBOL_GPL(gre_cisco_register);
428 int gre_cisco_unregister(struct gre_cisco_protocol *del_proto)
430 struct gre_cisco_protocol **proto = (struct gre_cisco_protocol **)
431 &gre_cisco_proto_list[del_proto->priority];
434 ret = (cmpxchg(proto, del_proto, NULL) == del_proto) ? 0 : -EINVAL;
442 EXPORT_SYMBOL_GPL(gre_cisco_unregister);
444 static int __init gre_init(void)
446 pr_info("GRE over IPv4 demultiplexor driver\n");
448 if (inet_add_protocol(&net_gre_protocol, IPPROTO_GRE) < 0) {
449 pr_err("can't add protocol\n");
453 if (gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO) < 0) {
454 pr_info("%s: can't add ipgre handler\n", __func__);
458 if (inet_add_offload(&gre_offload, IPPROTO_GRE)) {
459 pr_err("can't add protocol offload\n");
465 gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
467 inet_del_protocol(&net_gre_protocol, IPPROTO_GRE);
472 static void __exit gre_exit(void)
474 inet_del_offload(&gre_offload, IPPROTO_GRE);
475 gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
476 inet_del_protocol(&net_gre_protocol, IPPROTO_GRE);
479 module_init(gre_init);
480 module_exit(gre_exit);
482 MODULE_DESCRIPTION("GRE over IPv4 demultiplexer driver");
483 MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");
484 MODULE_LICENSE("GPL");