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 struct sk_buff
*gre_handle_offloads(struct sk_buff
*skb
, bool gre_csum
)
100 if (likely(!skb
->encapsulation
)) {
101 skb_reset_inner_headers(skb
);
102 skb
->encapsulation
= 1;
105 if (skb_is_gso(skb
)) {
106 err
= skb_unclone(skb
, GFP_ATOMIC
);
109 skb_shinfo(skb
)->gso_type
|= SKB_GSO_GRE
;
111 } else if (skb
->ip_summed
== CHECKSUM_PARTIAL
&& gre_csum
) {
112 err
= skb_checksum_help(skb
);
115 } else if (skb
->ip_summed
!= CHECKSUM_PARTIAL
)
116 skb
->ip_summed
= CHECKSUM_NONE
;
123 EXPORT_SYMBOL_GPL(gre_handle_offloads
);
125 static __sum16
check_checksum(struct sk_buff
*skb
)
129 switch (skb
->ip_summed
) {
130 case CHECKSUM_COMPLETE
:
131 csum
= csum_fold(skb
->csum
);
139 csum
= __skb_checksum_complete(skb
);
140 skb
->ip_summed
= CHECKSUM_COMPLETE
;
147 static int parse_gre_header(struct sk_buff
*skb
, struct tnl_ptk_info
*tpi
,
150 unsigned int ip_hlen
= ip_hdrlen(skb
);
151 const struct gre_base_hdr
*greh
;
155 if (unlikely(!pskb_may_pull(skb
, sizeof(struct gre_base_hdr
))))
158 greh
= (struct gre_base_hdr
*)(skb_network_header(skb
) + ip_hlen
);
159 if (unlikely(greh
->flags
& (GRE_VERSION
| GRE_ROUTING
)))
162 tpi
->flags
= gre_flags_to_tnl_flags(greh
->flags
);
163 hdr_len
= ip_gre_calc_hlen(tpi
->flags
);
165 if (!pskb_may_pull(skb
, hdr_len
))
168 greh
= (struct gre_base_hdr
*)(skb_network_header(skb
) + ip_hlen
);
169 tpi
->proto
= greh
->protocol
;
171 options
= (__be32
*)(greh
+ 1);
172 if (greh
->flags
& GRE_CSUM
) {
173 if (check_checksum(skb
)) {
180 if (greh
->flags
& GRE_KEY
) {
186 if (unlikely(greh
->flags
& GRE_SEQ
)) {
192 /* WCCP version 1 and 2 protocol decoding.
193 * - Change protocol to IP
194 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
196 if (greh
->flags
== 0 && tpi
->proto
== htons(ETH_P_WCCP
)) {
197 tpi
->proto
= htons(ETH_P_IP
);
198 if ((*(u8
*)options
& 0xF0) != 0x40) {
200 if (!pskb_may_pull(skb
, hdr_len
))
205 return iptunnel_pull_header(skb
, hdr_len
, tpi
->proto
);
208 static int gre_cisco_rcv(struct sk_buff
*skb
)
210 struct tnl_ptk_info tpi
;
212 bool csum_err
= false;
214 if (parse_gre_header(skb
, &tpi
, &csum_err
) < 0)
218 for (i
= 0; i
< GRE_IP_PROTO_MAX
; i
++) {
219 struct gre_cisco_protocol
*proto
;
222 proto
= rcu_dereference(gre_cisco_proto_list
[i
]);
225 ret
= proto
->handler(skb
, &tpi
);
226 if (ret
== PACKET_RCVD
) {
233 icmp_send(skb
, ICMP_DEST_UNREACH
, ICMP_PORT_UNREACH
, 0);
239 static void gre_cisco_err(struct sk_buff
*skb
, u32 info
)
241 /* All the routers (except for Linux) return only
242 * 8 bytes of packet payload. It means, that precise relaying of
243 * ICMP in the real Internet is absolutely infeasible.
245 * Moreover, Cisco "wise men" put GRE key to the third word
246 * in GRE header. It makes impossible maintaining even soft
248 * GRE tunnels with enabled checksum. Tell them "thank you".
250 * Well, I wonder, rfc1812 was written by Cisco employee,
251 * what the hell these idiots break standards established
255 const int type
= icmp_hdr(skb
)->type
;
256 const int code
= icmp_hdr(skb
)->code
;
257 struct tnl_ptk_info tpi
;
258 bool csum_err
= false;
261 if (parse_gre_header(skb
, &tpi
, &csum_err
)) {
262 if (!csum_err
) /* ignore csum errors. */
266 if (type
== ICMP_DEST_UNREACH
&& code
== ICMP_FRAG_NEEDED
) {
267 ipv4_update_pmtu(skb
, dev_net(skb
->dev
), info
,
268 skb
->dev
->ifindex
, 0, IPPROTO_GRE
, 0);
271 if (type
== ICMP_REDIRECT
) {
272 ipv4_redirect(skb
, dev_net(skb
->dev
), skb
->dev
->ifindex
, 0,
278 for (i
= 0; i
< GRE_IP_PROTO_MAX
; i
++) {
279 struct gre_cisco_protocol
*proto
;
281 proto
= rcu_dereference(gre_cisco_proto_list
[i
]);
285 if (proto
->err_handler(skb
, info
, &tpi
) == PACKET_RCVD
)
293 static int gre_rcv(struct sk_buff
*skb
)
295 const struct gre_protocol
*proto
;
299 if (!pskb_may_pull(skb
, 12))
302 ver
= skb
->data
[1]&0x7f;
303 if (ver
>= GREPROTO_MAX
)
307 proto
= rcu_dereference(gre_proto
[ver
]);
308 if (!proto
|| !proto
->handler
)
310 ret
= proto
->handler(skb
);
321 static void gre_err(struct sk_buff
*skb
, u32 info
)
323 const struct gre_protocol
*proto
;
324 const struct iphdr
*iph
= (const struct iphdr
*)skb
->data
;
325 u8 ver
= skb
->data
[(iph
->ihl
<<2) + 1]&0x7f;
327 if (ver
>= GREPROTO_MAX
)
331 proto
= rcu_dereference(gre_proto
[ver
]);
332 if (proto
&& proto
->err_handler
)
333 proto
->err_handler(skb
, info
);
337 static const struct net_protocol net_gre_protocol
= {
339 .err_handler
= gre_err
,
343 static const struct gre_protocol ipgre_protocol
= {
344 .handler
= gre_cisco_rcv
,
345 .err_handler
= gre_cisco_err
,
348 int gre_cisco_register(struct gre_cisco_protocol
*newp
)
350 struct gre_cisco_protocol
**proto
= (struct gre_cisco_protocol
**)
351 &gre_cisco_proto_list
[newp
->priority
];
353 return (cmpxchg(proto
, NULL
, newp
) == NULL
) ? 0 : -EBUSY
;
355 EXPORT_SYMBOL_GPL(gre_cisco_register
);
357 int gre_cisco_unregister(struct gre_cisco_protocol
*del_proto
)
359 struct gre_cisco_protocol
**proto
= (struct gre_cisco_protocol
**)
360 &gre_cisco_proto_list
[del_proto
->priority
];
363 ret
= (cmpxchg(proto
, del_proto
, NULL
) == del_proto
) ? 0 : -EINVAL
;
371 EXPORT_SYMBOL_GPL(gre_cisco_unregister
);
373 static int __init
gre_init(void)
375 pr_info("GRE over IPv4 demultiplexor driver\n");
377 if (inet_add_protocol(&net_gre_protocol
, IPPROTO_GRE
) < 0) {
378 pr_err("can't add protocol\n");
382 if (gre_add_protocol(&ipgre_protocol
, GREPROTO_CISCO
) < 0) {
383 pr_info("%s: can't add ipgre handler\n", __func__
);
387 if (gre_offload_init()) {
388 pr_err("can't add protocol offload\n");
394 gre_del_protocol(&ipgre_protocol
, GREPROTO_CISCO
);
396 inet_del_protocol(&net_gre_protocol
, IPPROTO_GRE
);
401 static void __exit
gre_exit(void)
405 gre_del_protocol(&ipgre_protocol
, GREPROTO_CISCO
);
406 inet_del_protocol(&net_gre_protocol
, IPPROTO_GRE
);
409 module_init(gre_init
);
410 module_exit(gre_exit
);
412 MODULE_DESCRIPTION("GRE over IPv4 demultiplexer driver");
413 MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");
414 MODULE_LICENSE("GPL");