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 #ifdef CONFIG_NET_IPGRE_BROADCAST
186 if (ipv4_is_multicast(ip_hdr(skb
)->daddr
)) {
187 /* Looped back packet, drop it! */
188 if (rt_is_output_route(skb_rtable(skb
)))
193 if (parse_gre_header(skb
, &tpi
, &csum_err
) < 0)
197 for (i
= 0; i
< GRE_IP_PROTO_MAX
; i
++) {
198 struct gre_cisco_protocol
*proto
;
201 proto
= rcu_dereference(gre_cisco_proto_list
[i
]);
204 ret
= proto
->handler(skb
, &tpi
);
205 if (ret
== PACKET_RCVD
) {
212 icmp_send(skb
, ICMP_DEST_UNREACH
, ICMP_PORT_UNREACH
, 0);
218 static void gre_cisco_err(struct sk_buff
*skb
, u32 info
)
220 /* All the routers (except for Linux) return only
221 * 8 bytes of packet payload. It means, that precise relaying of
222 * ICMP in the real Internet is absolutely infeasible.
224 * Moreover, Cisco "wise men" put GRE key to the third word
225 * in GRE header. It makes impossible maintaining even soft
227 * GRE tunnels with enabled checksum. Tell them "thank you".
229 * Well, I wonder, rfc1812 was written by Cisco employee,
230 * what the hell these idiots break standards established
234 const int type
= icmp_hdr(skb
)->type
;
235 const int code
= icmp_hdr(skb
)->code
;
236 struct tnl_ptk_info tpi
;
237 bool csum_err
= false;
240 if (parse_gre_header(skb
, &tpi
, &csum_err
)) {
241 if (!csum_err
) /* ignore csum errors. */
245 if (type
== ICMP_DEST_UNREACH
&& code
== ICMP_FRAG_NEEDED
) {
246 ipv4_update_pmtu(skb
, dev_net(skb
->dev
), info
,
247 skb
->dev
->ifindex
, 0, IPPROTO_GRE
, 0);
250 if (type
== ICMP_REDIRECT
) {
251 ipv4_redirect(skb
, dev_net(skb
->dev
), skb
->dev
->ifindex
, 0,
257 for (i
= 0; i
< GRE_IP_PROTO_MAX
; i
++) {
258 struct gre_cisco_protocol
*proto
;
260 proto
= rcu_dereference(gre_cisco_proto_list
[i
]);
264 if (proto
->err_handler(skb
, info
, &tpi
) == PACKET_RCVD
)
272 static int gre_rcv(struct sk_buff
*skb
)
274 const struct gre_protocol
*proto
;
278 if (!pskb_may_pull(skb
, 12))
281 ver
= skb
->data
[1]&0x7f;
282 if (ver
>= GREPROTO_MAX
)
286 proto
= rcu_dereference(gre_proto
[ver
]);
287 if (!proto
|| !proto
->handler
)
289 ret
= proto
->handler(skb
);
300 static void gre_err(struct sk_buff
*skb
, u32 info
)
302 const struct gre_protocol
*proto
;
303 const struct iphdr
*iph
= (const struct iphdr
*)skb
->data
;
304 u8 ver
= skb
->data
[(iph
->ihl
<<2) + 1]&0x7f;
306 if (ver
>= GREPROTO_MAX
)
310 proto
= rcu_dereference(gre_proto
[ver
]);
311 if (proto
&& proto
->err_handler
)
312 proto
->err_handler(skb
, info
);
316 static const struct net_protocol net_gre_protocol
= {
318 .err_handler
= gre_err
,
322 static const struct gre_protocol ipgre_protocol
= {
323 .handler
= gre_cisco_rcv
,
324 .err_handler
= gre_cisco_err
,
327 int gre_cisco_register(struct gre_cisco_protocol
*newp
)
329 struct gre_cisco_protocol
**proto
= (struct gre_cisco_protocol
**)
330 &gre_cisco_proto_list
[newp
->priority
];
332 return (cmpxchg(proto
, NULL
, newp
) == NULL
) ? 0 : -EBUSY
;
334 EXPORT_SYMBOL_GPL(gre_cisco_register
);
336 int gre_cisco_unregister(struct gre_cisco_protocol
*del_proto
)
338 struct gre_cisco_protocol
**proto
= (struct gre_cisco_protocol
**)
339 &gre_cisco_proto_list
[del_proto
->priority
];
342 ret
= (cmpxchg(proto
, del_proto
, NULL
) == del_proto
) ? 0 : -EINVAL
;
350 EXPORT_SYMBOL_GPL(gre_cisco_unregister
);
352 static int __init
gre_init(void)
354 pr_info("GRE over IPv4 demultiplexor driver\n");
356 if (inet_add_protocol(&net_gre_protocol
, IPPROTO_GRE
) < 0) {
357 pr_err("can't add protocol\n");
361 if (gre_add_protocol(&ipgre_protocol
, GREPROTO_CISCO
) < 0) {
362 pr_info("%s: can't add ipgre handler\n", __func__
);
368 inet_del_protocol(&net_gre_protocol
, IPPROTO_GRE
);
373 static void __exit
gre_exit(void)
375 gre_del_protocol(&ipgre_protocol
, GREPROTO_CISCO
);
376 inet_del_protocol(&net_gre_protocol
, IPPROTO_GRE
);
379 module_init(gre_init
);
380 module_exit(gre_exit
);
382 MODULE_DESCRIPTION("GRE over IPv4 demultiplexer driver");
383 MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");
384 MODULE_LICENSE("GPL");