blob: 4b93f32de10dc5213232a936d064b4fdefd49f06 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002 * Linux NET3: GRE over IP protocol decoder.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
5 *
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.
10 *
11 */
12
Randy Dunlap4fc268d2006-01-11 12:17:47 -080013#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/module.h>
15#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/kernel.h>
17#include <asm/uaccess.h>
18#include <linux/skbuff.h>
19#include <linux/netdevice.h>
20#include <linux/in.h>
21#include <linux/tcp.h>
22#include <linux/udp.h>
23#include <linux/if_arp.h>
24#include <linux/mroute.h>
25#include <linux/init.h>
26#include <linux/in6.h>
27#include <linux/inetdevice.h>
28#include <linux/igmp.h>
29#include <linux/netfilter_ipv4.h>
Kris Katterjohn46f25df2006-01-05 16:35:42 -080030#include <linux/if_ether.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32#include <net/sock.h>
33#include <net/ip.h>
34#include <net/icmp.h>
35#include <net/protocol.h>
36#include <net/ipip.h>
37#include <net/arp.h>
38#include <net/checksum.h>
39#include <net/dsfield.h>
40#include <net/inet_ecn.h>
41#include <net/xfrm.h>
42
43#ifdef CONFIG_IPV6
44#include <net/ipv6.h>
45#include <net/ip6_fib.h>
46#include <net/ip6_route.h>
47#endif
48
49/*
50 Problems & solutions
51 --------------------
52
53 1. The most important issue is detecting local dead loops.
54 They would cause complete host lockup in transmit, which
55 would be "resolved" by stack overflow or, if queueing is enabled,
56 with infinite looping in net_bh.
57
58 We cannot track such dead loops during route installation,
59 it is infeasible task. The most general solutions would be
60 to keep skb->encapsulation counter (sort of local ttl),
61 and silently drop packet when it expires. It is the best
62 solution, but it supposes maintaing new variable in ALL
63 skb, even if no tunneling is used.
64
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090065 Current solution: t->recursion lock breaks dead loops. It looks
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 like dev->tbusy flag, but I preferred new variable, because
67 the semantics is different. One day, when hard_start_xmit
68 will be multithreaded we will have to use skb->encapsulation.
69
70
71
72 2. Networking dead loops would not kill routers, but would really
73 kill network. IP hop limit plays role of "t->recursion" in this case,
74 if we copy it from packet being encapsulated to upper header.
75 It is very good solution, but it introduces two problems:
76
77 - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
78 do not work over tunnels.
79 - traceroute does not work. I planned to relay ICMP from tunnel,
80 so that this problem would be solved and traceroute output
81 would even more informative. This idea appeared to be wrong:
82 only Linux complies to rfc1812 now (yes, guys, Linux is the only
83 true router now :-)), all routers (at least, in neighbourhood of mine)
84 return only 8 bytes of payload. It is the end.
85
86 Hence, if we want that OSPF worked or traceroute said something reasonable,
87 we should search for another solution.
88
89 One of them is to parse packet trying to detect inner encapsulation
90 made by our node. It is difficult or even impossible, especially,
91 taking into account fragmentation. TO be short, tt is not solution at all.
92
93 Current solution: The solution was UNEXPECTEDLY SIMPLE.
94 We force DF flag on tunnels with preconfigured hop limit,
95 that is ALL. :-) Well, it does not remove the problem completely,
96 but exponential growth of network traffic is changed to linear
97 (branches, that exceed pmtu are pruned) and tunnel mtu
98 fastly degrades to value <68, where looping stops.
99 Yes, it is not good if there exists a router in the loop,
100 which does not force DF, even when encapsulating packets have DF set.
101 But it is not our problem! Nobody could accuse us, we made
102 all that we could make. Even if it is your gated who injected
103 fatal route to network, even if it were you who configured
104 fatal static route: you are innocent. :-)
105
106
107
108 3. Really, ipv4/ipip.c, ipv4/ip_gre.c and ipv6/sit.c contain
109 practically identical code. It would be good to glue them
110 together, but it is not very evident, how to make them modular.
111 sit is integral part of IPv6, ipip and gre are naturally modular.
112 We could extract common parts (hash table, ioctl etc)
113 to a separate module (ip_tunnel.c).
114
115 Alexey Kuznetsov.
116 */
117
118static int ipgre_tunnel_init(struct net_device *dev);
119static void ipgre_tunnel_setup(struct net_device *dev);
120
121/* Fallback tunnel: no source, no destination, no key, no options */
122
123static int ipgre_fb_tunnel_init(struct net_device *dev);
124
125static struct net_device *ipgre_fb_tunnel_dev;
126
127/* Tunnel hash table */
128
129/*
130 4 hash tables:
131
132 3: (remote,local)
133 2: (remote,*)
134 1: (*,local)
135 0: (*,*)
136
137 We require exact key match i.e. if a key is present in packet
138 it will match only tunnel with the same key; if it is not present,
139 it will match only keyless tunnel.
140
141 All keysless packets, if not matched configured keyless tunnels
142 will match fallback tunnel.
143 */
144
145#define HASH_SIZE 16
Al Virod5a0a1e2006-11-08 00:23:14 -0800146#define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
148static struct ip_tunnel *tunnels[4][HASH_SIZE];
149
150#define tunnels_r_l (tunnels[3])
151#define tunnels_r (tunnels[2])
152#define tunnels_l (tunnels[1])
153#define tunnels_wc (tunnels[0])
154
155static DEFINE_RWLOCK(ipgre_lock);
156
157/* Given src, dst and key, find appropriate for input tunnel. */
158
Al Virod5a0a1e2006-11-08 00:23:14 -0800159static struct ip_tunnel * ipgre_tunnel_lookup(__be32 remote, __be32 local, __be32 key)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160{
161 unsigned h0 = HASH(remote);
162 unsigned h1 = HASH(key);
163 struct ip_tunnel *t;
164
165 for (t = tunnels_r_l[h0^h1]; t; t = t->next) {
166 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr) {
167 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
168 return t;
169 }
170 }
171 for (t = tunnels_r[h0^h1]; t; t = t->next) {
172 if (remote == t->parms.iph.daddr) {
173 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
174 return t;
175 }
176 }
177 for (t = tunnels_l[h1]; t; t = t->next) {
178 if (local == t->parms.iph.saddr ||
179 (local == t->parms.iph.daddr && MULTICAST(local))) {
180 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
181 return t;
182 }
183 }
184 for (t = tunnels_wc[h1]; t; t = t->next) {
185 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
186 return t;
187 }
188
189 if (ipgre_fb_tunnel_dev->flags&IFF_UP)
Patrick McHardy2941a482006-01-08 22:05:26 -0800190 return netdev_priv(ipgre_fb_tunnel_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 return NULL;
192}
193
YOSHIFUJI Hideaki5056a1e2007-04-24 20:44:48 +0900194static struct ip_tunnel **__ipgre_bucket(struct ip_tunnel_parm *parms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195{
YOSHIFUJI Hideaki5056a1e2007-04-24 20:44:48 +0900196 __be32 remote = parms->iph.daddr;
197 __be32 local = parms->iph.saddr;
198 __be32 key = parms->i_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 unsigned h = HASH(key);
200 int prio = 0;
201
202 if (local)
203 prio |= 1;
204 if (remote && !MULTICAST(remote)) {
205 prio |= 2;
206 h ^= HASH(remote);
207 }
208
209 return &tunnels[prio][h];
210}
211
YOSHIFUJI Hideaki5056a1e2007-04-24 20:44:48 +0900212static inline struct ip_tunnel **ipgre_bucket(struct ip_tunnel *t)
213{
214 return __ipgre_bucket(&t->parms);
215}
216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217static void ipgre_tunnel_link(struct ip_tunnel *t)
218{
219 struct ip_tunnel **tp = ipgre_bucket(t);
220
221 t->next = *tp;
222 write_lock_bh(&ipgre_lock);
223 *tp = t;
224 write_unlock_bh(&ipgre_lock);
225}
226
227static void ipgre_tunnel_unlink(struct ip_tunnel *t)
228{
229 struct ip_tunnel **tp;
230
231 for (tp = ipgre_bucket(t); *tp; tp = &(*tp)->next) {
232 if (t == *tp) {
233 write_lock_bh(&ipgre_lock);
234 *tp = t->next;
235 write_unlock_bh(&ipgre_lock);
236 break;
237 }
238 }
239}
240
241static struct ip_tunnel * ipgre_tunnel_locate(struct ip_tunnel_parm *parms, int create)
242{
Al Virod5a0a1e2006-11-08 00:23:14 -0800243 __be32 remote = parms->iph.daddr;
244 __be32 local = parms->iph.saddr;
245 __be32 key = parms->i_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 struct ip_tunnel *t, **tp, *nt;
247 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 char name[IFNAMSIZ];
249
YOSHIFUJI Hideaki5056a1e2007-04-24 20:44:48 +0900250 for (tp = __ipgre_bucket(parms); (t = *tp) != NULL; tp = &t->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr) {
252 if (key == t->parms.i_key)
253 return t;
254 }
255 }
256 if (!create)
257 return NULL;
258
259 if (parms->name[0])
260 strlcpy(name, parms->name, IFNAMSIZ);
261 else {
262 int i;
263 for (i=1; i<100; i++) {
264 sprintf(name, "gre%d", i);
Eric W. Biederman881d9662007-09-17 11:56:21 -0700265 if (__dev_get_by_name(&init_net, name) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 break;
267 }
268 if (i==100)
269 goto failed;
270 }
271
272 dev = alloc_netdev(sizeof(*t), name, ipgre_tunnel_setup);
273 if (!dev)
274 return NULL;
275
276 dev->init = ipgre_tunnel_init;
Patrick McHardy2941a482006-01-08 22:05:26 -0800277 nt = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 nt->parms = *parms;
279
280 if (register_netdevice(dev) < 0) {
281 free_netdev(dev);
282 goto failed;
283 }
284
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 dev_hold(dev);
286 ipgre_tunnel_link(nt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 return nt;
288
289failed:
290 return NULL;
291}
292
293static void ipgre_tunnel_uninit(struct net_device *dev)
294{
Patrick McHardy2941a482006-01-08 22:05:26 -0800295 ipgre_tunnel_unlink(netdev_priv(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 dev_put(dev);
297}
298
299
300static void ipgre_err(struct sk_buff *skb, u32 info)
301{
302#ifndef I_WISH_WORLD_WERE_PERFECT
303
304/* It is not :-( All the routers (except for Linux) return only
305 8 bytes of packet payload. It means, that precise relaying of
306 ICMP in the real Internet is absolutely infeasible.
307
308 Moreover, Cisco "wise men" put GRE key to the third word
309 in GRE header. It makes impossible maintaining even soft state for keyed
310 GRE tunnels with enabled checksum. Tell them "thank you".
311
312 Well, I wonder, rfc1812 was written by Cisco employee,
313 what the hell these idiots break standrads established
314 by themself???
315 */
316
317 struct iphdr *iph = (struct iphdr*)skb->data;
Al Virod5a0a1e2006-11-08 00:23:14 -0800318 __be16 *p = (__be16*)(skb->data+(iph->ihl<<2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 int grehlen = (iph->ihl<<2) + 4;
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300320 const int type = icmp_hdr(skb)->type;
321 const int code = icmp_hdr(skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 struct ip_tunnel *t;
Al Virod5a0a1e2006-11-08 00:23:14 -0800323 __be16 flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324
325 flags = p[0];
326 if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
327 if (flags&(GRE_VERSION|GRE_ROUTING))
328 return;
329 if (flags&GRE_KEY) {
330 grehlen += 4;
331 if (flags&GRE_CSUM)
332 grehlen += 4;
333 }
334 }
335
336 /* If only 8 bytes returned, keyed message will be dropped here */
337 if (skb_headlen(skb) < grehlen)
338 return;
339
340 switch (type) {
341 default:
342 case ICMP_PARAMETERPROB:
343 return;
344
345 case ICMP_DEST_UNREACH:
346 switch (code) {
347 case ICMP_SR_FAILED:
348 case ICMP_PORT_UNREACH:
349 /* Impossible event. */
350 return;
351 case ICMP_FRAG_NEEDED:
352 /* Soft state for pmtu is maintained by IP core. */
353 return;
354 default:
355 /* All others are translated to HOST_UNREACH.
356 rfc2003 contains "deep thoughts" about NET_UNREACH,
357 I believe they are just ether pollution. --ANK
358 */
359 break;
360 }
361 break;
362 case ICMP_TIME_EXCEEDED:
363 if (code != ICMP_EXC_TTL)
364 return;
365 break;
366 }
367
368 read_lock(&ipgre_lock);
Al Virod5a0a1e2006-11-08 00:23:14 -0800369 t = ipgre_tunnel_lookup(iph->daddr, iph->saddr, (flags&GRE_KEY) ? *(((__be32*)p) + (grehlen>>2) - 1) : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 if (t == NULL || t->parms.iph.daddr == 0 || MULTICAST(t->parms.iph.daddr))
371 goto out;
372
373 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
374 goto out;
375
376 if (jiffies - t->err_time < IPTUNNEL_ERR_TIMEO)
377 t->err_count++;
378 else
379 t->err_count = 1;
380 t->err_time = jiffies;
381out:
382 read_unlock(&ipgre_lock);
383 return;
384#else
385 struct iphdr *iph = (struct iphdr*)dp;
386 struct iphdr *eiph;
Al Virod5a0a1e2006-11-08 00:23:14 -0800387 __be16 *p = (__be16*)(dp+(iph->ihl<<2));
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300388 const int type = icmp_hdr(skb)->type;
389 const int code = icmp_hdr(skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 int rel_type = 0;
391 int rel_code = 0;
Al Viroc55e2f42006-09-19 13:23:19 -0700392 __be32 rel_info = 0;
393 __u32 n = 0;
Al Virod5a0a1e2006-11-08 00:23:14 -0800394 __be16 flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 int grehlen = (iph->ihl<<2) + 4;
396 struct sk_buff *skb2;
397 struct flowi fl;
398 struct rtable *rt;
399
400 if (p[1] != htons(ETH_P_IP))
401 return;
402
403 flags = p[0];
404 if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
405 if (flags&(GRE_VERSION|GRE_ROUTING))
406 return;
407 if (flags&GRE_CSUM)
408 grehlen += 4;
409 if (flags&GRE_KEY)
410 grehlen += 4;
411 if (flags&GRE_SEQ)
412 grehlen += 4;
413 }
414 if (len < grehlen + sizeof(struct iphdr))
415 return;
416 eiph = (struct iphdr*)(dp + grehlen);
417
418 switch (type) {
419 default:
420 return;
421 case ICMP_PARAMETERPROB:
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300422 n = ntohl(icmp_hdr(skb)->un.gateway) >> 24;
Al Viroc55e2f42006-09-19 13:23:19 -0700423 if (n < (iph->ihl<<2))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 return;
425
426 /* So... This guy found something strange INSIDE encapsulated
427 packet. Well, he is fool, but what can we do ?
428 */
429 rel_type = ICMP_PARAMETERPROB;
Al Viroc55e2f42006-09-19 13:23:19 -0700430 n -= grehlen;
431 rel_info = htonl(n << 24);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 break;
433
434 case ICMP_DEST_UNREACH:
435 switch (code) {
436 case ICMP_SR_FAILED:
437 case ICMP_PORT_UNREACH:
438 /* Impossible event. */
439 return;
440 case ICMP_FRAG_NEEDED:
441 /* And it is the only really necessary thing :-) */
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300442 n = ntohs(icmp_hdr(skb)->un.frag.mtu);
Al Viroc55e2f42006-09-19 13:23:19 -0700443 if (n < grehlen+68)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 return;
Al Viroc55e2f42006-09-19 13:23:19 -0700445 n -= grehlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 /* BSD 4.2 MORE DOES NOT EXIST IN NATURE. */
Al Viroc55e2f42006-09-19 13:23:19 -0700447 if (n > ntohs(eiph->tot_len))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 return;
Al Viroc55e2f42006-09-19 13:23:19 -0700449 rel_info = htonl(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 break;
451 default:
452 /* All others are translated to HOST_UNREACH.
453 rfc2003 contains "deep thoughts" about NET_UNREACH,
454 I believe, it is just ether pollution. --ANK
455 */
456 rel_type = ICMP_DEST_UNREACH;
457 rel_code = ICMP_HOST_UNREACH;
458 break;
459 }
460 break;
461 case ICMP_TIME_EXCEEDED:
462 if (code != ICMP_EXC_TTL)
463 return;
464 break;
465 }
466
467 /* Prepare fake skb to feed it to icmp_send */
468 skb2 = skb_clone(skb, GFP_ATOMIC);
469 if (skb2 == NULL)
470 return;
471 dst_release(skb2->dst);
472 skb2->dst = NULL;
473 skb_pull(skb2, skb->data - (u8*)eiph);
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -0700474 skb_reset_network_header(skb2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475
476 /* Try to guess incoming interface */
477 memset(&fl, 0, sizeof(fl));
478 fl.fl4_dst = eiph->saddr;
479 fl.fl4_tos = RT_TOS(eiph->tos);
480 fl.proto = IPPROTO_GRE;
481 if (ip_route_output_key(&rt, &fl)) {
482 kfree_skb(skb2);
483 return;
484 }
485 skb2->dev = rt->u.dst.dev;
486
487 /* route "incoming" packet */
488 if (rt->rt_flags&RTCF_LOCAL) {
489 ip_rt_put(rt);
490 rt = NULL;
491 fl.fl4_dst = eiph->daddr;
492 fl.fl4_src = eiph->saddr;
493 fl.fl4_tos = eiph->tos;
494 if (ip_route_output_key(&rt, &fl) ||
495 rt->u.dst.dev->type != ARPHRD_IPGRE) {
496 ip_rt_put(rt);
497 kfree_skb(skb2);
498 return;
499 }
500 } else {
501 ip_rt_put(rt);
502 if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos, skb2->dev) ||
503 skb2->dst->dev->type != ARPHRD_IPGRE) {
504 kfree_skb(skb2);
505 return;
506 }
507 }
508
509 /* change mtu on this route */
510 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
Al Viroc55e2f42006-09-19 13:23:19 -0700511 if (n > dst_mtu(skb2->dst)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 kfree_skb(skb2);
513 return;
514 }
Al Viroc55e2f42006-09-19 13:23:19 -0700515 skb2->dst->ops->update_pmtu(skb2->dst, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 } else if (type == ICMP_TIME_EXCEEDED) {
Patrick McHardy2941a482006-01-08 22:05:26 -0800517 struct ip_tunnel *t = netdev_priv(skb2->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 if (t->parms.iph.ttl) {
519 rel_type = ICMP_DEST_UNREACH;
520 rel_code = ICMP_HOST_UNREACH;
521 }
522 }
523
524 icmp_send(skb2, rel_type, rel_code, rel_info);
525 kfree_skb(skb2);
526#endif
527}
528
529static inline void ipgre_ecn_decapsulate(struct iphdr *iph, struct sk_buff *skb)
530{
531 if (INET_ECN_is_ce(iph->tos)) {
532 if (skb->protocol == htons(ETH_P_IP)) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700533 IP_ECN_set_ce(ip_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 } else if (skb->protocol == htons(ETH_P_IPV6)) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700535 IP6_ECN_set_ce(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 }
537 }
538}
539
540static inline u8
541ipgre_ecn_encapsulate(u8 tos, struct iphdr *old_iph, struct sk_buff *skb)
542{
543 u8 inner = 0;
544 if (skb->protocol == htons(ETH_P_IP))
545 inner = old_iph->tos;
546 else if (skb->protocol == htons(ETH_P_IPV6))
547 inner = ipv6_get_dsfield((struct ipv6hdr *)old_iph);
548 return INET_ECN_encapsulate(tos, inner);
549}
550
551static int ipgre_rcv(struct sk_buff *skb)
552{
553 struct iphdr *iph;
554 u8 *h;
Al Virod5a0a1e2006-11-08 00:23:14 -0800555 __be16 flags;
Al Virod3bc23e2006-11-14 21:24:49 -0800556 __sum16 csum = 0;
Al Virod5a0a1e2006-11-08 00:23:14 -0800557 __be32 key = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 u32 seqno = 0;
559 struct ip_tunnel *tunnel;
560 int offset = 4;
561
562 if (!pskb_may_pull(skb, 16))
563 goto drop_nolock;
564
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700565 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 h = skb->data;
Al Virod5a0a1e2006-11-08 00:23:14 -0800567 flags = *(__be16*)h;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
569 if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {
570 /* - Version must be 0.
571 - We do not support routing headers.
572 */
573 if (flags&(GRE_VERSION|GRE_ROUTING))
574 goto drop_nolock;
575
576 if (flags&GRE_CSUM) {
Herbert Xufb286bb2005-11-10 13:01:24 -0800577 switch (skb->ip_summed) {
Patrick McHardy84fa7932006-08-29 16:44:56 -0700578 case CHECKSUM_COMPLETE:
Al Virod3bc23e2006-11-14 21:24:49 -0800579 csum = csum_fold(skb->csum);
Herbert Xufb286bb2005-11-10 13:01:24 -0800580 if (!csum)
581 break;
582 /* fall through */
583 case CHECKSUM_NONE:
584 skb->csum = 0;
585 csum = __skb_checksum_complete(skb);
Patrick McHardy84fa7932006-08-29 16:44:56 -0700586 skb->ip_summed = CHECKSUM_COMPLETE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 }
588 offset += 4;
589 }
590 if (flags&GRE_KEY) {
Al Virod5a0a1e2006-11-08 00:23:14 -0800591 key = *(__be32*)(h + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 offset += 4;
593 }
594 if (flags&GRE_SEQ) {
Al Virod5a0a1e2006-11-08 00:23:14 -0800595 seqno = ntohl(*(__be32*)(h + offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 offset += 4;
597 }
598 }
599
600 read_lock(&ipgre_lock);
601 if ((tunnel = ipgre_tunnel_lookup(iph->saddr, iph->daddr, key)) != NULL) {
602 secpath_reset(skb);
603
Al Virod5a0a1e2006-11-08 00:23:14 -0800604 skb->protocol = *(__be16*)(h + 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 /* WCCP version 1 and 2 protocol decoding.
606 * - Change protocol to IP
607 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
608 */
609 if (flags == 0 &&
YOSHIFUJI Hideaki496c98d2006-10-10 19:41:21 -0700610 skb->protocol == htons(ETH_P_WCCP)) {
611 skb->protocol = htons(ETH_P_IP);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900612 if ((*(h + offset) & 0xF0) != 0x40)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 offset += 4;
614 }
615
Timo Teras1d069162007-12-20 00:10:33 -0800616 skb->mac_header = skb->network_header;
Arnaldo Carvalho de Melo4209fb62007-03-10 18:42:03 -0300617 __pskb_pull(skb, offset);
618 skb_reset_network_header(skb);
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700619 skb_postpull_rcsum(skb, skb_transport_header(skb), offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 skb->pkt_type = PACKET_HOST;
621#ifdef CONFIG_NET_IPGRE_BROADCAST
622 if (MULTICAST(iph->daddr)) {
623 /* Looped back packet, drop it! */
624 if (((struct rtable*)skb->dst)->fl.iif == 0)
625 goto drop;
626 tunnel->stat.multicast++;
627 skb->pkt_type = PACKET_BROADCAST;
628 }
629#endif
630
631 if (((flags&GRE_CSUM) && csum) ||
632 (!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {
633 tunnel->stat.rx_crc_errors++;
634 tunnel->stat.rx_errors++;
635 goto drop;
636 }
637 if (tunnel->parms.i_flags&GRE_SEQ) {
638 if (!(flags&GRE_SEQ) ||
639 (tunnel->i_seqno && (s32)(seqno - tunnel->i_seqno) < 0)) {
640 tunnel->stat.rx_fifo_errors++;
641 tunnel->stat.rx_errors++;
642 goto drop;
643 }
644 tunnel->i_seqno = seqno + 1;
645 }
646 tunnel->stat.rx_packets++;
647 tunnel->stat.rx_bytes += skb->len;
648 skb->dev = tunnel->dev;
649 dst_release(skb->dst);
650 skb->dst = NULL;
651 nf_reset(skb);
652 ipgre_ecn_decapsulate(iph, skb);
653 netif_rx(skb);
654 read_unlock(&ipgre_lock);
655 return(0);
656 }
Herbert Xu45af08b2006-04-05 22:31:19 -0700657 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
659drop:
660 read_unlock(&ipgre_lock);
661drop_nolock:
662 kfree_skb(skb);
663 return(0);
664}
665
666static int ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
667{
Patrick McHardy2941a482006-01-08 22:05:26 -0800668 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 struct net_device_stats *stats = &tunnel->stat;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700670 struct iphdr *old_iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 struct iphdr *tiph;
672 u8 tos;
Al Virod5a0a1e2006-11-08 00:23:14 -0800673 __be16 df;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 struct rtable *rt; /* Route to the other host */
675 struct net_device *tdev; /* Device to other host */
676 struct iphdr *iph; /* Our new IP header */
Chuck Leverc2636b42007-10-23 21:07:32 -0700677 unsigned int max_headroom; /* The extra header space needed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 int gre_hlen;
Al Virod5a0a1e2006-11-08 00:23:14 -0800679 __be32 dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 int mtu;
681
682 if (tunnel->recursion++) {
683 tunnel->stat.collisions++;
684 goto tx_error;
685 }
686
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700687 if (dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 gre_hlen = 0;
689 tiph = (struct iphdr*)skb->data;
690 } else {
691 gre_hlen = tunnel->hlen;
692 tiph = &tunnel->parms.iph;
693 }
694
695 if ((dst = tiph->daddr) == 0) {
696 /* NBMA tunnel */
697
698 if (skb->dst == NULL) {
699 tunnel->stat.tx_fifo_errors++;
700 goto tx_error;
701 }
702
703 if (skb->protocol == htons(ETH_P_IP)) {
704 rt = (struct rtable*)skb->dst;
705 if ((dst = rt->rt_gateway) == 0)
706 goto tx_error_icmp;
707 }
708#ifdef CONFIG_IPV6
709 else if (skb->protocol == htons(ETH_P_IPV6)) {
710 struct in6_addr *addr6;
711 int addr_type;
712 struct neighbour *neigh = skb->dst->neighbour;
713
714 if (neigh == NULL)
715 goto tx_error;
716
717 addr6 = (struct in6_addr*)&neigh->primary_key;
718 addr_type = ipv6_addr_type(addr6);
719
720 if (addr_type == IPV6_ADDR_ANY) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700721 addr6 = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 addr_type = ipv6_addr_type(addr6);
723 }
724
725 if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
726 goto tx_error_icmp;
727
728 dst = addr6->s6_addr32[3];
729 }
730#endif
731 else
732 goto tx_error;
733 }
734
735 tos = tiph->tos;
736 if (tos&1) {
737 if (skb->protocol == htons(ETH_P_IP))
738 tos = old_iph->tos;
739 tos &= ~1;
740 }
741
742 {
743 struct flowi fl = { .oif = tunnel->parms.link,
744 .nl_u = { .ip4_u =
745 { .daddr = dst,
746 .saddr = tiph->saddr,
747 .tos = RT_TOS(tos) } },
748 .proto = IPPROTO_GRE };
749 if (ip_route_output_key(&rt, &fl)) {
750 tunnel->stat.tx_carrier_errors++;
751 goto tx_error;
752 }
753 }
754 tdev = rt->u.dst.dev;
755
756 if (tdev == dev) {
757 ip_rt_put(rt);
758 tunnel->stat.collisions++;
759 goto tx_error;
760 }
761
762 df = tiph->frag_off;
763 if (df)
764 mtu = dst_mtu(&rt->u.dst) - tunnel->hlen;
765 else
766 mtu = skb->dst ? dst_mtu(skb->dst) : dev->mtu;
767
768 if (skb->dst)
769 skb->dst->ops->update_pmtu(skb->dst, mtu);
770
771 if (skb->protocol == htons(ETH_P_IP)) {
772 df |= (old_iph->frag_off&htons(IP_DF));
773
774 if ((old_iph->frag_off&htons(IP_DF)) &&
775 mtu < ntohs(old_iph->tot_len)) {
776 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
777 ip_rt_put(rt);
778 goto tx_error;
779 }
780 }
781#ifdef CONFIG_IPV6
782 else if (skb->protocol == htons(ETH_P_IPV6)) {
783 struct rt6_info *rt6 = (struct rt6_info*)skb->dst;
784
785 if (rt6 && mtu < dst_mtu(skb->dst) && mtu >= IPV6_MIN_MTU) {
786 if ((tunnel->parms.iph.daddr && !MULTICAST(tunnel->parms.iph.daddr)) ||
787 rt6->rt6i_dst.plen == 128) {
788 rt6->rt6i_flags |= RTF_MODIFIED;
789 skb->dst->metrics[RTAX_MTU-1] = mtu;
790 }
791 }
792
793 if (mtu >= IPV6_MIN_MTU && mtu < skb->len - tunnel->hlen + gre_hlen) {
794 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, dev);
795 ip_rt_put(rt);
796 goto tx_error;
797 }
798 }
799#endif
800
801 if (tunnel->err_count > 0) {
802 if (jiffies - tunnel->err_time < IPTUNNEL_ERR_TIMEO) {
803 tunnel->err_count--;
804
805 dst_link_failure(skb);
806 } else
807 tunnel->err_count = 0;
808 }
809
810 max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen;
811
Patrick McHardycfbba492007-07-09 15:33:40 -0700812 if (skb_headroom(skb) < max_headroom || skb_shared(skb)||
813 (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
815 if (!new_skb) {
816 ip_rt_put(rt);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900817 stats->tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 dev_kfree_skb(skb);
819 tunnel->recursion--;
820 return 0;
821 }
822 if (skb->sk)
823 skb_set_owner_w(new_skb, skb->sk);
824 dev_kfree_skb(skb);
825 skb = new_skb;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700826 old_iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 }
828
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700829 skb->transport_header = skb->network_header;
Arnaldo Carvalho de Meloe2d1bca2007-04-10 20:46:21 -0700830 skb_push(skb, gre_hlen);
831 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
Patrick McHardy48d5cad2006-02-15 15:10:22 -0800833 IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
834 IPSKB_REROUTED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 dst_release(skb->dst);
836 skb->dst = &rt->u.dst;
837
838 /*
839 * Push down and install the IPIP header.
840 */
841
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700842 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 iph->version = 4;
844 iph->ihl = sizeof(struct iphdr) >> 2;
845 iph->frag_off = df;
846 iph->protocol = IPPROTO_GRE;
847 iph->tos = ipgre_ecn_encapsulate(tos, old_iph, skb);
848 iph->daddr = rt->rt_dst;
849 iph->saddr = rt->rt_src;
850
851 if ((iph->ttl = tiph->ttl) == 0) {
852 if (skb->protocol == htons(ETH_P_IP))
853 iph->ttl = old_iph->ttl;
854#ifdef CONFIG_IPV6
855 else if (skb->protocol == htons(ETH_P_IPV6))
856 iph->ttl = ((struct ipv6hdr*)old_iph)->hop_limit;
857#endif
858 else
859 iph->ttl = dst_metric(&rt->u.dst, RTAX_HOPLIMIT);
860 }
861
Al Virod5a0a1e2006-11-08 00:23:14 -0800862 ((__be16*)(iph+1))[0] = tunnel->parms.o_flags;
863 ((__be16*)(iph+1))[1] = skb->protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864
865 if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
Al Virod5a0a1e2006-11-08 00:23:14 -0800866 __be32 *ptr = (__be32*)(((u8*)iph) + tunnel->hlen - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867
868 if (tunnel->parms.o_flags&GRE_SEQ) {
869 ++tunnel->o_seqno;
870 *ptr = htonl(tunnel->o_seqno);
871 ptr--;
872 }
873 if (tunnel->parms.o_flags&GRE_KEY) {
874 *ptr = tunnel->parms.o_key;
875 ptr--;
876 }
877 if (tunnel->parms.o_flags&GRE_CSUM) {
878 *ptr = 0;
Al Viro5f92a732006-11-14 21:36:54 -0800879 *(__sum16*)ptr = ip_compute_csum((void*)(iph+1), skb->len - sizeof(struct iphdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 }
881 }
882
883 nf_reset(skb);
884
885 IPTUNNEL_XMIT();
886 tunnel->recursion--;
887 return 0;
888
889tx_error_icmp:
890 dst_link_failure(skb);
891
892tx_error:
893 stats->tx_errors++;
894 dev_kfree_skb(skb);
895 tunnel->recursion--;
896 return 0;
897}
898
899static int
900ipgre_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
901{
902 int err = 0;
903 struct ip_tunnel_parm p;
904 struct ip_tunnel *t;
905
906 switch (cmd) {
907 case SIOCGETTUNNEL:
908 t = NULL;
909 if (dev == ipgre_fb_tunnel_dev) {
910 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
911 err = -EFAULT;
912 break;
913 }
914 t = ipgre_tunnel_locate(&p, 0);
915 }
916 if (t == NULL)
Patrick McHardy2941a482006-01-08 22:05:26 -0800917 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 memcpy(&p, &t->parms, sizeof(p));
919 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
920 err = -EFAULT;
921 break;
922
923 case SIOCADDTUNNEL:
924 case SIOCCHGTUNNEL:
925 err = -EPERM;
926 if (!capable(CAP_NET_ADMIN))
927 goto done;
928
929 err = -EFAULT;
930 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
931 goto done;
932
933 err = -EINVAL;
934 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
935 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
936 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
937 goto done;
938 if (p.iph.ttl)
939 p.iph.frag_off |= htons(IP_DF);
940
941 if (!(p.i_flags&GRE_KEY))
942 p.i_key = 0;
943 if (!(p.o_flags&GRE_KEY))
944 p.o_key = 0;
945
946 t = ipgre_tunnel_locate(&p, cmd == SIOCADDTUNNEL);
947
948 if (dev != ipgre_fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
949 if (t != NULL) {
950 if (t->dev != dev) {
951 err = -EEXIST;
952 break;
953 }
954 } else {
955 unsigned nflags=0;
956
Patrick McHardy2941a482006-01-08 22:05:26 -0800957 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958
959 if (MULTICAST(p.iph.daddr))
960 nflags = IFF_BROADCAST;
961 else if (p.iph.daddr)
962 nflags = IFF_POINTOPOINT;
963
964 if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
965 err = -EINVAL;
966 break;
967 }
968 ipgre_tunnel_unlink(t);
969 t->parms.iph.saddr = p.iph.saddr;
970 t->parms.iph.daddr = p.iph.daddr;
971 t->parms.i_key = p.i_key;
972 t->parms.o_key = p.o_key;
973 memcpy(dev->dev_addr, &p.iph.saddr, 4);
974 memcpy(dev->broadcast, &p.iph.daddr, 4);
975 ipgre_tunnel_link(t);
976 netdev_state_change(dev);
977 }
978 }
979
980 if (t) {
981 err = 0;
982 if (cmd == SIOCCHGTUNNEL) {
983 t->parms.iph.ttl = p.iph.ttl;
984 t->parms.iph.tos = p.iph.tos;
985 t->parms.iph.frag_off = p.iph.frag_off;
986 }
987 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
988 err = -EFAULT;
989 } else
990 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
991 break;
992
993 case SIOCDELTUNNEL:
994 err = -EPERM;
995 if (!capable(CAP_NET_ADMIN))
996 goto done;
997
998 if (dev == ipgre_fb_tunnel_dev) {
999 err = -EFAULT;
1000 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1001 goto done;
1002 err = -ENOENT;
1003 if ((t = ipgre_tunnel_locate(&p, 0)) == NULL)
1004 goto done;
1005 err = -EPERM;
Patrick McHardy2941a482006-01-08 22:05:26 -08001006 if (t == netdev_priv(ipgre_fb_tunnel_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 goto done;
1008 dev = t->dev;
1009 }
Stephen Hemminger22f8cde2007-02-07 00:09:58 -08001010 unregister_netdevice(dev);
1011 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 break;
1013
1014 default:
1015 err = -EINVAL;
1016 }
1017
1018done:
1019 return err;
1020}
1021
1022static struct net_device_stats *ipgre_tunnel_get_stats(struct net_device *dev)
1023{
Patrick McHardy2941a482006-01-08 22:05:26 -08001024 return &(((struct ip_tunnel*)netdev_priv(dev))->stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025}
1026
1027static int ipgre_tunnel_change_mtu(struct net_device *dev, int new_mtu)
1028{
Patrick McHardy2941a482006-01-08 22:05:26 -08001029 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 if (new_mtu < 68 || new_mtu > 0xFFF8 - tunnel->hlen)
1031 return -EINVAL;
1032 dev->mtu = new_mtu;
1033 return 0;
1034}
1035
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036/* Nice toy. Unfortunately, useless in real life :-)
1037 It allows to construct virtual multiprotocol broadcast "LAN"
1038 over the Internet, provided multicast routing is tuned.
1039
1040
1041 I have no idea was this bicycle invented before me,
1042 so that I had to set ARPHRD_IPGRE to a random value.
1043 I have an impression, that Cisco could make something similar,
1044 but this feature is apparently missing in IOS<=11.2(8).
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001045
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
1047 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
1048
1049 ping -t 255 224.66.66.66
1050
1051 If nobody answers, mbone does not work.
1052
1053 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
1054 ip addr add 10.66.66.<somewhat>/24 dev Universe
1055 ifconfig Universe up
1056 ifconfig Universe add fe80::<Your_real_addr>/10
1057 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
1058 ftp 10.66.66.66
1059 ...
1060 ftp fec0:6666:6666::193.233.7.65
1061 ...
1062
1063 */
1064
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001065static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
1066 unsigned short type,
1067 const void *daddr, const void *saddr, unsigned len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068{
Patrick McHardy2941a482006-01-08 22:05:26 -08001069 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 struct iphdr *iph = (struct iphdr *)skb_push(skb, t->hlen);
Al Virod5a0a1e2006-11-08 00:23:14 -08001071 __be16 *p = (__be16*)(iph+1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072
1073 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
1074 p[0] = t->parms.o_flags;
1075 p[1] = htons(type);
1076
1077 /*
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001078 * Set the source hardware address.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001080
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 if (saddr)
1082 memcpy(&iph->saddr, saddr, 4);
1083
1084 if (daddr) {
1085 memcpy(&iph->daddr, daddr, 4);
1086 return t->hlen;
1087 }
1088 if (iph->daddr && !MULTICAST(iph->daddr))
1089 return t->hlen;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001090
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 return -t->hlen;
1092}
1093
Timo Teras6a5f44d2007-10-23 20:31:53 -07001094static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
1095{
1096 struct iphdr *iph = (struct iphdr*) skb_mac_header(skb);
1097 memcpy(haddr, &iph->saddr, 4);
1098 return 4;
1099}
1100
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001101static const struct header_ops ipgre_header_ops = {
1102 .create = ipgre_header,
Timo Teras6a5f44d2007-10-23 20:31:53 -07001103 .parse = ipgre_header_parse,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001104};
1105
Timo Teras6a5f44d2007-10-23 20:31:53 -07001106#ifdef CONFIG_NET_IPGRE_BROADCAST
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107static int ipgre_open(struct net_device *dev)
1108{
Patrick McHardy2941a482006-01-08 22:05:26 -08001109 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110
1111 if (MULTICAST(t->parms.iph.daddr)) {
1112 struct flowi fl = { .oif = t->parms.link,
1113 .nl_u = { .ip4_u =
1114 { .daddr = t->parms.iph.daddr,
1115 .saddr = t->parms.iph.saddr,
1116 .tos = RT_TOS(t->parms.iph.tos) } },
1117 .proto = IPPROTO_GRE };
1118 struct rtable *rt;
1119 if (ip_route_output_key(&rt, &fl))
1120 return -EADDRNOTAVAIL;
1121 dev = rt->u.dst.dev;
1122 ip_rt_put(rt);
Herbert Xue5ed6392005-10-03 14:35:55 -07001123 if (__in_dev_get_rtnl(dev) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 return -EADDRNOTAVAIL;
1125 t->mlink = dev->ifindex;
Herbert Xue5ed6392005-10-03 14:35:55 -07001126 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 }
1128 return 0;
1129}
1130
1131static int ipgre_close(struct net_device *dev)
1132{
Patrick McHardy2941a482006-01-08 22:05:26 -08001133 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 if (MULTICAST(t->parms.iph.daddr) && t->mlink) {
1135 struct in_device *in_dev = inetdev_by_index(t->mlink);
1136 if (in_dev) {
1137 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
1138 in_dev_put(in_dev);
1139 }
1140 }
1141 return 0;
1142}
1143
1144#endif
1145
1146static void ipgre_tunnel_setup(struct net_device *dev)
1147{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 dev->uninit = ipgre_tunnel_uninit;
1149 dev->destructor = free_netdev;
1150 dev->hard_start_xmit = ipgre_tunnel_xmit;
1151 dev->get_stats = ipgre_tunnel_get_stats;
1152 dev->do_ioctl = ipgre_tunnel_ioctl;
1153 dev->change_mtu = ipgre_tunnel_change_mtu;
1154
1155 dev->type = ARPHRD_IPGRE;
1156 dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
Kris Katterjohn46f25df2006-01-05 16:35:42 -08001157 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 dev->flags = IFF_NOARP;
1159 dev->iflink = 0;
1160 dev->addr_len = 4;
1161}
1162
1163static int ipgre_tunnel_init(struct net_device *dev)
1164{
1165 struct net_device *tdev = NULL;
1166 struct ip_tunnel *tunnel;
1167 struct iphdr *iph;
1168 int hlen = LL_MAX_HEADER;
Kris Katterjohn46f25df2006-01-05 16:35:42 -08001169 int mtu = ETH_DATA_LEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 int addend = sizeof(struct iphdr) + 4;
1171
Patrick McHardy2941a482006-01-08 22:05:26 -08001172 tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 iph = &tunnel->parms.iph;
1174
1175 tunnel->dev = dev;
1176 strcpy(tunnel->parms.name, dev->name);
1177
1178 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1179 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1180
1181 /* Guess output device to choose reasonable mtu and hard_header_len */
1182
1183 if (iph->daddr) {
1184 struct flowi fl = { .oif = tunnel->parms.link,
1185 .nl_u = { .ip4_u =
1186 { .daddr = iph->daddr,
1187 .saddr = iph->saddr,
1188 .tos = RT_TOS(iph->tos) } },
1189 .proto = IPPROTO_GRE };
1190 struct rtable *rt;
1191 if (!ip_route_output_key(&rt, &fl)) {
1192 tdev = rt->u.dst.dev;
1193 ip_rt_put(rt);
1194 }
1195
1196 dev->flags |= IFF_POINTOPOINT;
1197
1198#ifdef CONFIG_NET_IPGRE_BROADCAST
1199 if (MULTICAST(iph->daddr)) {
1200 if (!iph->saddr)
1201 return -EINVAL;
1202 dev->flags = IFF_BROADCAST;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001203 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 dev->open = ipgre_open;
1205 dev->stop = ipgre_close;
1206 }
1207#endif
Timo Teras6a5f44d2007-10-23 20:31:53 -07001208 } else {
1209 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 }
1211
1212 if (!tdev && tunnel->parms.link)
Eric W. Biederman881d9662007-09-17 11:56:21 -07001213 tdev = __dev_get_by_index(&init_net, tunnel->parms.link);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214
1215 if (tdev) {
1216 hlen = tdev->hard_header_len;
1217 mtu = tdev->mtu;
1218 }
1219 dev->iflink = tunnel->parms.link;
1220
1221 /* Precalculate GRE options length */
1222 if (tunnel->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {
1223 if (tunnel->parms.o_flags&GRE_CSUM)
1224 addend += 4;
1225 if (tunnel->parms.o_flags&GRE_KEY)
1226 addend += 4;
1227 if (tunnel->parms.o_flags&GRE_SEQ)
1228 addend += 4;
1229 }
1230 dev->hard_header_len = hlen + addend;
1231 dev->mtu = mtu - addend;
1232 tunnel->hlen = addend;
1233 return 0;
1234}
1235
Adrian Bunk4b30b1c2005-11-29 16:27:20 -08001236static int __init ipgre_fb_tunnel_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237{
Patrick McHardy2941a482006-01-08 22:05:26 -08001238 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 struct iphdr *iph = &tunnel->parms.iph;
1240
1241 tunnel->dev = dev;
1242 strcpy(tunnel->parms.name, dev->name);
1243
1244 iph->version = 4;
1245 iph->protocol = IPPROTO_GRE;
1246 iph->ihl = 5;
1247 tunnel->hlen = sizeof(struct iphdr) + 4;
1248
1249 dev_hold(dev);
1250 tunnels_wc[0] = tunnel;
1251 return 0;
1252}
1253
1254
1255static struct net_protocol ipgre_protocol = {
1256 .handler = ipgre_rcv,
1257 .err_handler = ipgre_err,
1258};
1259
1260
1261/*
1262 * And now the modules code and kernel interface.
1263 */
1264
1265static int __init ipgre_init(void)
1266{
1267 int err;
1268
1269 printk(KERN_INFO "GRE over IPv4 tunneling driver\n");
1270
1271 if (inet_add_protocol(&ipgre_protocol, IPPROTO_GRE) < 0) {
1272 printk(KERN_INFO "ipgre init: can't add protocol\n");
1273 return -EAGAIN;
1274 }
1275
1276 ipgre_fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "gre0",
1277 ipgre_tunnel_setup);
1278 if (!ipgre_fb_tunnel_dev) {
1279 err = -ENOMEM;
1280 goto err1;
1281 }
1282
1283 ipgre_fb_tunnel_dev->init = ipgre_fb_tunnel_init;
1284
1285 if ((err = register_netdev(ipgre_fb_tunnel_dev)))
1286 goto err2;
1287out:
1288 return err;
1289err2:
1290 free_netdev(ipgre_fb_tunnel_dev);
1291err1:
1292 inet_del_protocol(&ipgre_protocol, IPPROTO_GRE);
1293 goto out;
1294}
1295
Alexey Kuznetsovdb445752005-07-30 17:46:44 -07001296static void __exit ipgre_destroy_tunnels(void)
1297{
1298 int prio;
1299
1300 for (prio = 0; prio < 4; prio++) {
1301 int h;
1302 for (h = 0; h < HASH_SIZE; h++) {
1303 struct ip_tunnel *t;
1304 while ((t = tunnels[prio][h]) != NULL)
1305 unregister_netdevice(t->dev);
1306 }
1307 }
1308}
1309
1310static void __exit ipgre_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311{
1312 if (inet_del_protocol(&ipgre_protocol, IPPROTO_GRE) < 0)
1313 printk(KERN_INFO "ipgre close: can't remove protocol\n");
1314
Alexey Kuznetsovdb445752005-07-30 17:46:44 -07001315 rtnl_lock();
1316 ipgre_destroy_tunnels();
1317 rtnl_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318}
1319
1320module_init(ipgre_init);
1321module_exit(ipgre_fini);
1322MODULE_LICENSE("GPL");