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
))
176 return iptunnel_pull_header(skb
, hdr_len
, tpi
->proto
);
179 static int gre_cisco_rcv(struct sk_buff
*skb
)
181 struct tnl_ptk_info tpi
;
183 bool csum_err
= false;
185 if (parse_gre_header(skb
, &tpi
, &csum_err
) < 0)
189 for (i
= 0; i
< GRE_IP_PROTO_MAX
; i
++) {
190 struct gre_cisco_protocol
*proto
;
193 proto
= rcu_dereference(gre_cisco_proto_list
[i
]);
196 ret
= proto
->handler(skb
, &tpi
);
197 if (ret
== PACKET_RCVD
) {
204 icmp_send(skb
, ICMP_DEST_UNREACH
, ICMP_PORT_UNREACH
, 0);
210 static void gre_cisco_err(struct sk_buff
*skb
, u32 info
)
212 /* All the routers (except for Linux) return only
213 * 8 bytes of packet payload. It means, that precise relaying of
214 * ICMP in the real Internet is absolutely infeasible.
216 * Moreover, Cisco "wise men" put GRE key to the third word
217 * in GRE header. It makes impossible maintaining even soft
219 * GRE tunnels with enabled checksum. Tell them "thank you".
221 * Well, I wonder, rfc1812 was written by Cisco employee,
222 * what the hell these idiots break standards established
226 const int type
= icmp_hdr(skb
)->type
;
227 const int code
= icmp_hdr(skb
)->code
;
228 struct tnl_ptk_info tpi
;
229 bool csum_err
= false;
232 if (parse_gre_header(skb
, &tpi
, &csum_err
)) {
233 if (!csum_err
) /* ignore csum errors. */
237 if (type
== ICMP_DEST_UNREACH
&& code
== ICMP_FRAG_NEEDED
) {
238 ipv4_update_pmtu(skb
, dev_net(skb
->dev
), info
,
239 skb
->dev
->ifindex
, 0, IPPROTO_GRE
, 0);
242 if (type
== ICMP_REDIRECT
) {
243 ipv4_redirect(skb
, dev_net(skb
->dev
), skb
->dev
->ifindex
, 0,
249 for (i
= 0; i
< GRE_IP_PROTO_MAX
; i
++) {
250 struct gre_cisco_protocol
*proto
;
252 proto
= rcu_dereference(gre_cisco_proto_list
[i
]);
256 if (proto
->err_handler(skb
, info
, &tpi
) == PACKET_RCVD
)
264 static int gre_rcv(struct sk_buff
*skb
)
266 const struct gre_protocol
*proto
;
270 if (!pskb_may_pull(skb
, 12))
273 ver
= skb
->data
[1]&0x7f;
274 if (ver
>= GREPROTO_MAX
)
278 proto
= rcu_dereference(gre_proto
[ver
]);
279 if (!proto
|| !proto
->handler
)
281 ret
= proto
->handler(skb
);
292 static void gre_err(struct sk_buff
*skb
, u32 info
)
294 const struct gre_protocol
*proto
;
295 const struct iphdr
*iph
= (const struct iphdr
*)skb
->data
;
296 u8 ver
= skb
->data
[(iph
->ihl
<<2) + 1]&0x7f;
298 if (ver
>= GREPROTO_MAX
)
302 proto
= rcu_dereference(gre_proto
[ver
]);
303 if (proto
&& proto
->err_handler
)
304 proto
->err_handler(skb
, info
);
308 static const struct net_protocol net_gre_protocol
= {
310 .err_handler
= gre_err
,
314 static const struct gre_protocol ipgre_protocol
= {
315 .handler
= gre_cisco_rcv
,
316 .err_handler
= gre_cisco_err
,
319 int gre_cisco_register(struct gre_cisco_protocol
*newp
)
321 struct gre_cisco_protocol
**proto
= (struct gre_cisco_protocol
**)
322 &gre_cisco_proto_list
[newp
->priority
];
324 return (cmpxchg(proto
, NULL
, newp
) == NULL
) ? 0 : -EBUSY
;
326 EXPORT_SYMBOL_GPL(gre_cisco_register
);
328 int gre_cisco_unregister(struct gre_cisco_protocol
*del_proto
)
330 struct gre_cisco_protocol
**proto
= (struct gre_cisco_protocol
**)
331 &gre_cisco_proto_list
[del_proto
->priority
];
334 ret
= (cmpxchg(proto
, del_proto
, NULL
) == del_proto
) ? 0 : -EINVAL
;
342 EXPORT_SYMBOL_GPL(gre_cisco_unregister
);
344 static int __init
gre_init(void)
346 pr_info("GRE over IPv4 demultiplexor driver\n");
348 if (inet_add_protocol(&net_gre_protocol
, IPPROTO_GRE
) < 0) {
349 pr_err("can't add protocol\n");
353 if (gre_add_protocol(&ipgre_protocol
, GREPROTO_CISCO
) < 0) {
354 pr_info("%s: can't add ipgre handler\n", __func__
);
360 inet_del_protocol(&net_gre_protocol
, IPPROTO_GRE
);
365 static void __exit
gre_exit(void)
367 gre_del_protocol(&ipgre_protocol
, GREPROTO_CISCO
);
368 inet_del_protocol(&net_gre_protocol
, IPPROTO_GRE
);
371 module_init(gre_init
);
372 module_exit(gre_exit
);
374 MODULE_DESCRIPTION("GRE over IPv4 demultiplexer driver");
375 MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");
376 MODULE_LICENSE("GPL");