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
&
88 (SKB_GSO_GRE
|SKB_GSO_GRE_CSUM
))) {
90 *(__sum16
*)ptr
= csum_fold(skb_checksum(skb
, 0,
95 EXPORT_SYMBOL_GPL(gre_build_header
);
97 static int parse_gre_header(struct sk_buff
*skb
, struct tnl_ptk_info
*tpi
,
100 unsigned int ip_hlen
= ip_hdrlen(skb
);
101 const struct gre_base_hdr
*greh
;
105 if (unlikely(!pskb_may_pull(skb
, sizeof(struct gre_base_hdr
))))
108 greh
= (struct gre_base_hdr
*)(skb_network_header(skb
) + ip_hlen
);
109 if (unlikely(greh
->flags
& (GRE_VERSION
| GRE_ROUTING
)))
112 tpi
->flags
= gre_flags_to_tnl_flags(greh
->flags
);
113 hdr_len
= ip_gre_calc_hlen(tpi
->flags
);
115 if (!pskb_may_pull(skb
, hdr_len
))
118 greh
= (struct gre_base_hdr
*)(skb_network_header(skb
) + ip_hlen
);
119 tpi
->proto
= greh
->protocol
;
121 options
= (__be32
*)(greh
+ 1);
122 if (greh
->flags
& GRE_CSUM
) {
123 if (skb_checksum_simple_validate(skb
)) {
130 if (greh
->flags
& GRE_KEY
) {
136 if (unlikely(greh
->flags
& GRE_SEQ
)) {
142 /* WCCP version 1 and 2 protocol decoding.
143 * - Change protocol to IP
144 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
146 if (greh
->flags
== 0 && tpi
->proto
== htons(ETH_P_WCCP
)) {
147 tpi
->proto
= htons(ETH_P_IP
);
148 if ((*(u8
*)options
& 0xF0) != 0x40) {
150 if (!pskb_may_pull(skb
, hdr_len
))
155 return iptunnel_pull_header(skb
, hdr_len
, tpi
->proto
);
158 static int gre_cisco_rcv(struct sk_buff
*skb
)
160 struct tnl_ptk_info tpi
;
162 bool csum_err
= false;
164 #ifdef CONFIG_NET_IPGRE_BROADCAST
165 if (ipv4_is_multicast(ip_hdr(skb
)->daddr
)) {
166 /* Looped back packet, drop it! */
167 if (rt_is_output_route(skb_rtable(skb
)))
172 if (parse_gre_header(skb
, &tpi
, &csum_err
) < 0)
176 for (i
= 0; i
< GRE_IP_PROTO_MAX
; i
++) {
177 struct gre_cisco_protocol
*proto
;
180 proto
= rcu_dereference(gre_cisco_proto_list
[i
]);
183 ret
= proto
->handler(skb
, &tpi
);
184 if (ret
== PACKET_RCVD
) {
191 icmp_send(skb
, ICMP_DEST_UNREACH
, ICMP_PORT_UNREACH
, 0);
197 static void gre_cisco_err(struct sk_buff
*skb
, u32 info
)
199 /* All the routers (except for Linux) return only
200 * 8 bytes of packet payload. It means, that precise relaying of
201 * ICMP in the real Internet is absolutely infeasible.
203 * Moreover, Cisco "wise men" put GRE key to the third word
204 * in GRE header. It makes impossible maintaining even soft
206 * GRE tunnels with enabled checksum. Tell them "thank you".
208 * Well, I wonder, rfc1812 was written by Cisco employee,
209 * what the hell these idiots break standards established
213 const int type
= icmp_hdr(skb
)->type
;
214 const int code
= icmp_hdr(skb
)->code
;
215 struct tnl_ptk_info tpi
;
216 bool csum_err
= false;
219 if (parse_gre_header(skb
, &tpi
, &csum_err
)) {
220 if (!csum_err
) /* ignore csum errors. */
224 if (type
== ICMP_DEST_UNREACH
&& code
== ICMP_FRAG_NEEDED
) {
225 ipv4_update_pmtu(skb
, dev_net(skb
->dev
), info
,
226 skb
->dev
->ifindex
, 0, IPPROTO_GRE
, 0);
229 if (type
== ICMP_REDIRECT
) {
230 ipv4_redirect(skb
, dev_net(skb
->dev
), skb
->dev
->ifindex
, 0,
236 for (i
= 0; i
< GRE_IP_PROTO_MAX
; i
++) {
237 struct gre_cisco_protocol
*proto
;
239 proto
= rcu_dereference(gre_cisco_proto_list
[i
]);
243 if (proto
->err_handler(skb
, info
, &tpi
) == PACKET_RCVD
)
251 static int gre_rcv(struct sk_buff
*skb
)
253 const struct gre_protocol
*proto
;
257 if (!pskb_may_pull(skb
, 12))
260 ver
= skb
->data
[1]&0x7f;
261 if (ver
>= GREPROTO_MAX
)
265 proto
= rcu_dereference(gre_proto
[ver
]);
266 if (!proto
|| !proto
->handler
)
268 ret
= proto
->handler(skb
);
279 static void gre_err(struct sk_buff
*skb
, u32 info
)
281 const struct gre_protocol
*proto
;
282 const struct iphdr
*iph
= (const struct iphdr
*)skb
->data
;
283 u8 ver
= skb
->data
[(iph
->ihl
<<2) + 1]&0x7f;
285 if (ver
>= GREPROTO_MAX
)
289 proto
= rcu_dereference(gre_proto
[ver
]);
290 if (proto
&& proto
->err_handler
)
291 proto
->err_handler(skb
, info
);
295 static const struct net_protocol net_gre_protocol
= {
297 .err_handler
= gre_err
,
301 static const struct gre_protocol ipgre_protocol
= {
302 .handler
= gre_cisco_rcv
,
303 .err_handler
= gre_cisco_err
,
306 int gre_cisco_register(struct gre_cisco_protocol
*newp
)
308 struct gre_cisco_protocol
**proto
= (struct gre_cisco_protocol
**)
309 &gre_cisco_proto_list
[newp
->priority
];
311 return (cmpxchg(proto
, NULL
, newp
) == NULL
) ? 0 : -EBUSY
;
313 EXPORT_SYMBOL_GPL(gre_cisco_register
);
315 int gre_cisco_unregister(struct gre_cisco_protocol
*del_proto
)
317 struct gre_cisco_protocol
**proto
= (struct gre_cisco_protocol
**)
318 &gre_cisco_proto_list
[del_proto
->priority
];
321 ret
= (cmpxchg(proto
, del_proto
, NULL
) == del_proto
) ? 0 : -EINVAL
;
329 EXPORT_SYMBOL_GPL(gre_cisco_unregister
);
331 static int __init
gre_init(void)
333 pr_info("GRE over IPv4 demultiplexor driver\n");
335 if (inet_add_protocol(&net_gre_protocol
, IPPROTO_GRE
) < 0) {
336 pr_err("can't add protocol\n");
340 if (gre_add_protocol(&ipgre_protocol
, GREPROTO_CISCO
) < 0) {
341 pr_info("%s: can't add ipgre handler\n", __func__
);
347 inet_del_protocol(&net_gre_protocol
, IPPROTO_GRE
);
352 static void __exit
gre_exit(void)
354 gre_del_protocol(&ipgre_protocol
, GREPROTO_CISCO
);
355 inet_del_protocol(&net_gre_protocol
, IPPROTO_GRE
);
358 module_init(gre_init
);
359 module_exit(gre_exit
);
361 MODULE_DESCRIPTION("GRE over IPv4 demultiplexer driver");
362 MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");
363 MODULE_LICENSE("GPL");