blob: 476cb6084c75047026980d44d7ba43b4da39a0cd [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Linux NET3: GRE over IP protocol decoder.
3 *
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>
16#include <linux/sched.h>
17#include <linux/kernel.h>
18#include <asm/uaccess.h>
19#include <linux/skbuff.h>
20#include <linux/netdevice.h>
21#include <linux/in.h>
22#include <linux/tcp.h>
23#include <linux/udp.h>
24#include <linux/if_arp.h>
25#include <linux/mroute.h>
26#include <linux/init.h>
27#include <linux/in6.h>
28#include <linux/inetdevice.h>
29#include <linux/igmp.h>
30#include <linux/netfilter_ipv4.h>
Kris Katterjohn46f25df2006-01-05 16:35:42 -080031#include <linux/if_ether.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
33#include <net/sock.h>
34#include <net/ip.h>
35#include <net/icmp.h>
36#include <net/protocol.h>
37#include <net/ipip.h>
38#include <net/arp.h>
39#include <net/checksum.h>
40#include <net/dsfield.h>
41#include <net/inet_ecn.h>
42#include <net/xfrm.h>
43
44#ifdef CONFIG_IPV6
45#include <net/ipv6.h>
46#include <net/ip6_fib.h>
47#include <net/ip6_route.h>
48#endif
49
50/*
51 Problems & solutions
52 --------------------
53
54 1. The most important issue is detecting local dead loops.
55 They would cause complete host lockup in transmit, which
56 would be "resolved" by stack overflow or, if queueing is enabled,
57 with infinite looping in net_bh.
58
59 We cannot track such dead loops during route installation,
60 it is infeasible task. The most general solutions would be
61 to keep skb->encapsulation counter (sort of local ttl),
62 and silently drop packet when it expires. It is the best
63 solution, but it supposes maintaing new variable in ALL
64 skb, even if no tunneling is used.
65
66 Current solution: t->recursion lock breaks dead loops. It looks
67 like dev->tbusy flag, but I preferred new variable, because
68 the semantics is different. One day, when hard_start_xmit
69 will be multithreaded we will have to use skb->encapsulation.
70
71
72
73 2. Networking dead loops would not kill routers, but would really
74 kill network. IP hop limit plays role of "t->recursion" in this case,
75 if we copy it from packet being encapsulated to upper header.
76 It is very good solution, but it introduces two problems:
77
78 - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
79 do not work over tunnels.
80 - traceroute does not work. I planned to relay ICMP from tunnel,
81 so that this problem would be solved and traceroute output
82 would even more informative. This idea appeared to be wrong:
83 only Linux complies to rfc1812 now (yes, guys, Linux is the only
84 true router now :-)), all routers (at least, in neighbourhood of mine)
85 return only 8 bytes of payload. It is the end.
86
87 Hence, if we want that OSPF worked or traceroute said something reasonable,
88 we should search for another solution.
89
90 One of them is to parse packet trying to detect inner encapsulation
91 made by our node. It is difficult or even impossible, especially,
92 taking into account fragmentation. TO be short, tt is not solution at all.
93
94 Current solution: The solution was UNEXPECTEDLY SIMPLE.
95 We force DF flag on tunnels with preconfigured hop limit,
96 that is ALL. :-) Well, it does not remove the problem completely,
97 but exponential growth of network traffic is changed to linear
98 (branches, that exceed pmtu are pruned) and tunnel mtu
99 fastly degrades to value <68, where looping stops.
100 Yes, it is not good if there exists a router in the loop,
101 which does not force DF, even when encapsulating packets have DF set.
102 But it is not our problem! Nobody could accuse us, we made
103 all that we could make. Even if it is your gated who injected
104 fatal route to network, even if it were you who configured
105 fatal static route: you are innocent. :-)
106
107
108
109 3. Really, ipv4/ipip.c, ipv4/ip_gre.c and ipv6/sit.c contain
110 practically identical code. It would be good to glue them
111 together, but it is not very evident, how to make them modular.
112 sit is integral part of IPv6, ipip and gre are naturally modular.
113 We could extract common parts (hash table, ioctl etc)
114 to a separate module (ip_tunnel.c).
115
116 Alexey Kuznetsov.
117 */
118
119static int ipgre_tunnel_init(struct net_device *dev);
120static void ipgre_tunnel_setup(struct net_device *dev);
121
122/* Fallback tunnel: no source, no destination, no key, no options */
123
124static int ipgre_fb_tunnel_init(struct net_device *dev);
125
126static struct net_device *ipgre_fb_tunnel_dev;
127
128/* Tunnel hash table */
129
130/*
131 4 hash tables:
132
133 3: (remote,local)
134 2: (remote,*)
135 1: (*,local)
136 0: (*,*)
137
138 We require exact key match i.e. if a key is present in packet
139 it will match only tunnel with the same key; if it is not present,
140 it will match only keyless tunnel.
141
142 All keysless packets, if not matched configured keyless tunnels
143 will match fallback tunnel.
144 */
145
146#define HASH_SIZE 16
Al Virod5a0a1e2006-11-08 00:23:14 -0800147#define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
149static struct ip_tunnel *tunnels[4][HASH_SIZE];
150
151#define tunnels_r_l (tunnels[3])
152#define tunnels_r (tunnels[2])
153#define tunnels_l (tunnels[1])
154#define tunnels_wc (tunnels[0])
155
156static DEFINE_RWLOCK(ipgre_lock);
157
158/* Given src, dst and key, find appropriate for input tunnel. */
159
Al Virod5a0a1e2006-11-08 00:23:14 -0800160static struct ip_tunnel * ipgre_tunnel_lookup(__be32 remote, __be32 local, __be32 key)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161{
162 unsigned h0 = HASH(remote);
163 unsigned h1 = HASH(key);
164 struct ip_tunnel *t;
165
166 for (t = tunnels_r_l[h0^h1]; t; t = t->next) {
167 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr) {
168 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
169 return t;
170 }
171 }
172 for (t = tunnels_r[h0^h1]; t; t = t->next) {
173 if (remote == t->parms.iph.daddr) {
174 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
175 return t;
176 }
177 }
178 for (t = tunnels_l[h1]; t; t = t->next) {
179 if (local == t->parms.iph.saddr ||
180 (local == t->parms.iph.daddr && MULTICAST(local))) {
181 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
182 return t;
183 }
184 }
185 for (t = tunnels_wc[h1]; t; t = t->next) {
186 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
187 return t;
188 }
189
190 if (ipgre_fb_tunnel_dev->flags&IFF_UP)
Patrick McHardy2941a482006-01-08 22:05:26 -0800191 return netdev_priv(ipgre_fb_tunnel_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 return NULL;
193}
194
195static struct ip_tunnel **ipgre_bucket(struct ip_tunnel *t)
196{
Al Virod5a0a1e2006-11-08 00:23:14 -0800197 __be32 remote = t->parms.iph.daddr;
198 __be32 local = t->parms.iph.saddr;
199 __be32 key = t->parms.i_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 unsigned h = HASH(key);
201 int prio = 0;
202
203 if (local)
204 prio |= 1;
205 if (remote && !MULTICAST(remote)) {
206 prio |= 2;
207 h ^= HASH(remote);
208 }
209
210 return &tunnels[prio][h];
211}
212
213static void ipgre_tunnel_link(struct ip_tunnel *t)
214{
215 struct ip_tunnel **tp = ipgre_bucket(t);
216
217 t->next = *tp;
218 write_lock_bh(&ipgre_lock);
219 *tp = t;
220 write_unlock_bh(&ipgre_lock);
221}
222
223static void ipgre_tunnel_unlink(struct ip_tunnel *t)
224{
225 struct ip_tunnel **tp;
226
227 for (tp = ipgre_bucket(t); *tp; tp = &(*tp)->next) {
228 if (t == *tp) {
229 write_lock_bh(&ipgre_lock);
230 *tp = t->next;
231 write_unlock_bh(&ipgre_lock);
232 break;
233 }
234 }
235}
236
237static struct ip_tunnel * ipgre_tunnel_locate(struct ip_tunnel_parm *parms, int create)
238{
Al Virod5a0a1e2006-11-08 00:23:14 -0800239 __be32 remote = parms->iph.daddr;
240 __be32 local = parms->iph.saddr;
241 __be32 key = parms->i_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 struct ip_tunnel *t, **tp, *nt;
243 struct net_device *dev;
244 unsigned h = HASH(key);
245 int prio = 0;
246 char name[IFNAMSIZ];
247
248 if (local)
249 prio |= 1;
250 if (remote && !MULTICAST(remote)) {
251 prio |= 2;
252 h ^= HASH(remote);
253 }
254 for (tp = &tunnels[prio][h]; (t = *tp) != NULL; tp = &t->next) {
255 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr) {
256 if (key == t->parms.i_key)
257 return t;
258 }
259 }
260 if (!create)
261 return NULL;
262
263 if (parms->name[0])
264 strlcpy(name, parms->name, IFNAMSIZ);
265 else {
266 int i;
267 for (i=1; i<100; i++) {
268 sprintf(name, "gre%d", i);
269 if (__dev_get_by_name(name) == NULL)
270 break;
271 }
272 if (i==100)
273 goto failed;
274 }
275
276 dev = alloc_netdev(sizeof(*t), name, ipgre_tunnel_setup);
277 if (!dev)
278 return NULL;
279
280 dev->init = ipgre_tunnel_init;
Patrick McHardy2941a482006-01-08 22:05:26 -0800281 nt = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 nt->parms = *parms;
283
284 if (register_netdevice(dev) < 0) {
285 free_netdev(dev);
286 goto failed;
287 }
288
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 dev_hold(dev);
290 ipgre_tunnel_link(nt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 return nt;
292
293failed:
294 return NULL;
295}
296
297static void ipgre_tunnel_uninit(struct net_device *dev)
298{
Patrick McHardy2941a482006-01-08 22:05:26 -0800299 ipgre_tunnel_unlink(netdev_priv(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 dev_put(dev);
301}
302
303
304static void ipgre_err(struct sk_buff *skb, u32 info)
305{
306#ifndef I_WISH_WORLD_WERE_PERFECT
307
308/* It is not :-( All the routers (except for Linux) return only
309 8 bytes of packet payload. It means, that precise relaying of
310 ICMP in the real Internet is absolutely infeasible.
311
312 Moreover, Cisco "wise men" put GRE key to the third word
313 in GRE header. It makes impossible maintaining even soft state for keyed
314 GRE tunnels with enabled checksum. Tell them "thank you".
315
316 Well, I wonder, rfc1812 was written by Cisco employee,
317 what the hell these idiots break standrads established
318 by themself???
319 */
320
321 struct iphdr *iph = (struct iphdr*)skb->data;
Al Virod5a0a1e2006-11-08 00:23:14 -0800322 __be16 *p = (__be16*)(skb->data+(iph->ihl<<2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 int grehlen = (iph->ihl<<2) + 4;
324 int type = skb->h.icmph->type;
325 int code = skb->h.icmph->code;
326 struct ip_tunnel *t;
Al Virod5a0a1e2006-11-08 00:23:14 -0800327 __be16 flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328
329 flags = p[0];
330 if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
331 if (flags&(GRE_VERSION|GRE_ROUTING))
332 return;
333 if (flags&GRE_KEY) {
334 grehlen += 4;
335 if (flags&GRE_CSUM)
336 grehlen += 4;
337 }
338 }
339
340 /* If only 8 bytes returned, keyed message will be dropped here */
341 if (skb_headlen(skb) < grehlen)
342 return;
343
344 switch (type) {
345 default:
346 case ICMP_PARAMETERPROB:
347 return;
348
349 case ICMP_DEST_UNREACH:
350 switch (code) {
351 case ICMP_SR_FAILED:
352 case ICMP_PORT_UNREACH:
353 /* Impossible event. */
354 return;
355 case ICMP_FRAG_NEEDED:
356 /* Soft state for pmtu is maintained by IP core. */
357 return;
358 default:
359 /* All others are translated to HOST_UNREACH.
360 rfc2003 contains "deep thoughts" about NET_UNREACH,
361 I believe they are just ether pollution. --ANK
362 */
363 break;
364 }
365 break;
366 case ICMP_TIME_EXCEEDED:
367 if (code != ICMP_EXC_TTL)
368 return;
369 break;
370 }
371
372 read_lock(&ipgre_lock);
Al Virod5a0a1e2006-11-08 00:23:14 -0800373 t = ipgre_tunnel_lookup(iph->daddr, iph->saddr, (flags&GRE_KEY) ? *(((__be32*)p) + (grehlen>>2) - 1) : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 if (t == NULL || t->parms.iph.daddr == 0 || MULTICAST(t->parms.iph.daddr))
375 goto out;
376
377 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
378 goto out;
379
380 if (jiffies - t->err_time < IPTUNNEL_ERR_TIMEO)
381 t->err_count++;
382 else
383 t->err_count = 1;
384 t->err_time = jiffies;
385out:
386 read_unlock(&ipgre_lock);
387 return;
388#else
389 struct iphdr *iph = (struct iphdr*)dp;
390 struct iphdr *eiph;
Al Virod5a0a1e2006-11-08 00:23:14 -0800391 __be16 *p = (__be16*)(dp+(iph->ihl<<2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 int type = skb->h.icmph->type;
393 int code = skb->h.icmph->code;
394 int rel_type = 0;
395 int rel_code = 0;
Al Viroc55e2f42006-09-19 13:23:19 -0700396 __be32 rel_info = 0;
397 __u32 n = 0;
Al Virod5a0a1e2006-11-08 00:23:14 -0800398 __be16 flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 int grehlen = (iph->ihl<<2) + 4;
400 struct sk_buff *skb2;
401 struct flowi fl;
402 struct rtable *rt;
403
404 if (p[1] != htons(ETH_P_IP))
405 return;
406
407 flags = p[0];
408 if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
409 if (flags&(GRE_VERSION|GRE_ROUTING))
410 return;
411 if (flags&GRE_CSUM)
412 grehlen += 4;
413 if (flags&GRE_KEY)
414 grehlen += 4;
415 if (flags&GRE_SEQ)
416 grehlen += 4;
417 }
418 if (len < grehlen + sizeof(struct iphdr))
419 return;
420 eiph = (struct iphdr*)(dp + grehlen);
421
422 switch (type) {
423 default:
424 return;
425 case ICMP_PARAMETERPROB:
Al Viroc55e2f42006-09-19 13:23:19 -0700426 n = ntohl(skb->h.icmph->un.gateway) >> 24;
427 if (n < (iph->ihl<<2))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 return;
429
430 /* So... This guy found something strange INSIDE encapsulated
431 packet. Well, he is fool, but what can we do ?
432 */
433 rel_type = ICMP_PARAMETERPROB;
Al Viroc55e2f42006-09-19 13:23:19 -0700434 n -= grehlen;
435 rel_info = htonl(n << 24);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 break;
437
438 case ICMP_DEST_UNREACH:
439 switch (code) {
440 case ICMP_SR_FAILED:
441 case ICMP_PORT_UNREACH:
442 /* Impossible event. */
443 return;
444 case ICMP_FRAG_NEEDED:
445 /* And it is the only really necessary thing :-) */
Al Viroc55e2f42006-09-19 13:23:19 -0700446 n = ntohs(skb->h.icmph->un.frag.mtu);
447 if (n < grehlen+68)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 return;
Al Viroc55e2f42006-09-19 13:23:19 -0700449 n -= grehlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 /* BSD 4.2 MORE DOES NOT EXIST IN NATURE. */
Al Viroc55e2f42006-09-19 13:23:19 -0700451 if (n > ntohs(eiph->tot_len))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 return;
Al Viroc55e2f42006-09-19 13:23:19 -0700453 rel_info = htonl(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 break;
455 default:
456 /* All others are translated to HOST_UNREACH.
457 rfc2003 contains "deep thoughts" about NET_UNREACH,
458 I believe, it is just ether pollution. --ANK
459 */
460 rel_type = ICMP_DEST_UNREACH;
461 rel_code = ICMP_HOST_UNREACH;
462 break;
463 }
464 break;
465 case ICMP_TIME_EXCEEDED:
466 if (code != ICMP_EXC_TTL)
467 return;
468 break;
469 }
470
471 /* Prepare fake skb to feed it to icmp_send */
472 skb2 = skb_clone(skb, GFP_ATOMIC);
473 if (skb2 == NULL)
474 return;
475 dst_release(skb2->dst);
476 skb2->dst = NULL;
477 skb_pull(skb2, skb->data - (u8*)eiph);
478 skb2->nh.raw = skb2->data;
479
480 /* Try to guess incoming interface */
481 memset(&fl, 0, sizeof(fl));
482 fl.fl4_dst = eiph->saddr;
483 fl.fl4_tos = RT_TOS(eiph->tos);
484 fl.proto = IPPROTO_GRE;
485 if (ip_route_output_key(&rt, &fl)) {
486 kfree_skb(skb2);
487 return;
488 }
489 skb2->dev = rt->u.dst.dev;
490
491 /* route "incoming" packet */
492 if (rt->rt_flags&RTCF_LOCAL) {
493 ip_rt_put(rt);
494 rt = NULL;
495 fl.fl4_dst = eiph->daddr;
496 fl.fl4_src = eiph->saddr;
497 fl.fl4_tos = eiph->tos;
498 if (ip_route_output_key(&rt, &fl) ||
499 rt->u.dst.dev->type != ARPHRD_IPGRE) {
500 ip_rt_put(rt);
501 kfree_skb(skb2);
502 return;
503 }
504 } else {
505 ip_rt_put(rt);
506 if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos, skb2->dev) ||
507 skb2->dst->dev->type != ARPHRD_IPGRE) {
508 kfree_skb(skb2);
509 return;
510 }
511 }
512
513 /* change mtu on this route */
514 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
Al Viroc55e2f42006-09-19 13:23:19 -0700515 if (n > dst_mtu(skb2->dst)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 kfree_skb(skb2);
517 return;
518 }
Al Viroc55e2f42006-09-19 13:23:19 -0700519 skb2->dst->ops->update_pmtu(skb2->dst, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 } else if (type == ICMP_TIME_EXCEEDED) {
Patrick McHardy2941a482006-01-08 22:05:26 -0800521 struct ip_tunnel *t = netdev_priv(skb2->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 if (t->parms.iph.ttl) {
523 rel_type = ICMP_DEST_UNREACH;
524 rel_code = ICMP_HOST_UNREACH;
525 }
526 }
527
528 icmp_send(skb2, rel_type, rel_code, rel_info);
529 kfree_skb(skb2);
530#endif
531}
532
533static inline void ipgre_ecn_decapsulate(struct iphdr *iph, struct sk_buff *skb)
534{
535 if (INET_ECN_is_ce(iph->tos)) {
536 if (skb->protocol == htons(ETH_P_IP)) {
537 IP_ECN_set_ce(skb->nh.iph);
538 } else if (skb->protocol == htons(ETH_P_IPV6)) {
539 IP6_ECN_set_ce(skb->nh.ipv6h);
540 }
541 }
542}
543
544static inline u8
545ipgre_ecn_encapsulate(u8 tos, struct iphdr *old_iph, struct sk_buff *skb)
546{
547 u8 inner = 0;
548 if (skb->protocol == htons(ETH_P_IP))
549 inner = old_iph->tos;
550 else if (skb->protocol == htons(ETH_P_IPV6))
551 inner = ipv6_get_dsfield((struct ipv6hdr *)old_iph);
552 return INET_ECN_encapsulate(tos, inner);
553}
554
555static int ipgre_rcv(struct sk_buff *skb)
556{
557 struct iphdr *iph;
558 u8 *h;
Al Virod5a0a1e2006-11-08 00:23:14 -0800559 __be16 flags;
Al Virod3bc23e2006-11-14 21:24:49 -0800560 __sum16 csum = 0;
Al Virod5a0a1e2006-11-08 00:23:14 -0800561 __be32 key = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 u32 seqno = 0;
563 struct ip_tunnel *tunnel;
564 int offset = 4;
565
566 if (!pskb_may_pull(skb, 16))
567 goto drop_nolock;
568
569 iph = skb->nh.iph;
570 h = skb->data;
Al Virod5a0a1e2006-11-08 00:23:14 -0800571 flags = *(__be16*)h;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
573 if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {
574 /* - Version must be 0.
575 - We do not support routing headers.
576 */
577 if (flags&(GRE_VERSION|GRE_ROUTING))
578 goto drop_nolock;
579
580 if (flags&GRE_CSUM) {
Herbert Xufb286bb2005-11-10 13:01:24 -0800581 switch (skb->ip_summed) {
Patrick McHardy84fa7932006-08-29 16:44:56 -0700582 case CHECKSUM_COMPLETE:
Al Virod3bc23e2006-11-14 21:24:49 -0800583 csum = csum_fold(skb->csum);
Herbert Xufb286bb2005-11-10 13:01:24 -0800584 if (!csum)
585 break;
586 /* fall through */
587 case CHECKSUM_NONE:
588 skb->csum = 0;
589 csum = __skb_checksum_complete(skb);
Patrick McHardy84fa7932006-08-29 16:44:56 -0700590 skb->ip_summed = CHECKSUM_COMPLETE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 }
592 offset += 4;
593 }
594 if (flags&GRE_KEY) {
Al Virod5a0a1e2006-11-08 00:23:14 -0800595 key = *(__be32*)(h + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 offset += 4;
597 }
598 if (flags&GRE_SEQ) {
Al Virod5a0a1e2006-11-08 00:23:14 -0800599 seqno = ntohl(*(__be32*)(h + offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 offset += 4;
601 }
602 }
603
604 read_lock(&ipgre_lock);
605 if ((tunnel = ipgre_tunnel_lookup(iph->saddr, iph->daddr, key)) != NULL) {
606 secpath_reset(skb);
607
Al Virod5a0a1e2006-11-08 00:23:14 -0800608 skb->protocol = *(__be16*)(h + 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 /* WCCP version 1 and 2 protocol decoding.
610 * - Change protocol to IP
611 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
612 */
613 if (flags == 0 &&
YOSHIFUJI Hideaki496c98d2006-10-10 19:41:21 -0700614 skb->protocol == htons(ETH_P_WCCP)) {
615 skb->protocol = htons(ETH_P_IP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 if ((*(h + offset) & 0xF0) != 0x40)
617 offset += 4;
618 }
619
620 skb->mac.raw = skb->nh.raw;
621 skb->nh.raw = __pskb_pull(skb, offset);
Herbert Xu15422722005-12-14 12:55:24 -0800622 skb_postpull_rcsum(skb, skb->h.raw, offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 skb->pkt_type = PACKET_HOST;
624#ifdef CONFIG_NET_IPGRE_BROADCAST
625 if (MULTICAST(iph->daddr)) {
626 /* Looped back packet, drop it! */
627 if (((struct rtable*)skb->dst)->fl.iif == 0)
628 goto drop;
629 tunnel->stat.multicast++;
630 skb->pkt_type = PACKET_BROADCAST;
631 }
632#endif
633
634 if (((flags&GRE_CSUM) && csum) ||
635 (!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {
636 tunnel->stat.rx_crc_errors++;
637 tunnel->stat.rx_errors++;
638 goto drop;
639 }
640 if (tunnel->parms.i_flags&GRE_SEQ) {
641 if (!(flags&GRE_SEQ) ||
642 (tunnel->i_seqno && (s32)(seqno - tunnel->i_seqno) < 0)) {
643 tunnel->stat.rx_fifo_errors++;
644 tunnel->stat.rx_errors++;
645 goto drop;
646 }
647 tunnel->i_seqno = seqno + 1;
648 }
649 tunnel->stat.rx_packets++;
650 tunnel->stat.rx_bytes += skb->len;
651 skb->dev = tunnel->dev;
652 dst_release(skb->dst);
653 skb->dst = NULL;
654 nf_reset(skb);
655 ipgre_ecn_decapsulate(iph, skb);
656 netif_rx(skb);
657 read_unlock(&ipgre_lock);
658 return(0);
659 }
Herbert Xu45af08b2006-04-05 22:31:19 -0700660 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
662drop:
663 read_unlock(&ipgre_lock);
664drop_nolock:
665 kfree_skb(skb);
666 return(0);
667}
668
669static int ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
670{
Patrick McHardy2941a482006-01-08 22:05:26 -0800671 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 struct net_device_stats *stats = &tunnel->stat;
673 struct iphdr *old_iph = skb->nh.iph;
674 struct iphdr *tiph;
675 u8 tos;
Al Virod5a0a1e2006-11-08 00:23:14 -0800676 __be16 df;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 struct rtable *rt; /* Route to the other host */
678 struct net_device *tdev; /* Device to other host */
679 struct iphdr *iph; /* Our new IP header */
680 int max_headroom; /* The extra header space needed */
681 int gre_hlen;
Al Virod5a0a1e2006-11-08 00:23:14 -0800682 __be32 dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 int mtu;
684
685 if (tunnel->recursion++) {
686 tunnel->stat.collisions++;
687 goto tx_error;
688 }
689
690 if (dev->hard_header) {
691 gre_hlen = 0;
692 tiph = (struct iphdr*)skb->data;
693 } else {
694 gre_hlen = tunnel->hlen;
695 tiph = &tunnel->parms.iph;
696 }
697
698 if ((dst = tiph->daddr) == 0) {
699 /* NBMA tunnel */
700
701 if (skb->dst == NULL) {
702 tunnel->stat.tx_fifo_errors++;
703 goto tx_error;
704 }
705
706 if (skb->protocol == htons(ETH_P_IP)) {
707 rt = (struct rtable*)skb->dst;
708 if ((dst = rt->rt_gateway) == 0)
709 goto tx_error_icmp;
710 }
711#ifdef CONFIG_IPV6
712 else if (skb->protocol == htons(ETH_P_IPV6)) {
713 struct in6_addr *addr6;
714 int addr_type;
715 struct neighbour *neigh = skb->dst->neighbour;
716
717 if (neigh == NULL)
718 goto tx_error;
719
720 addr6 = (struct in6_addr*)&neigh->primary_key;
721 addr_type = ipv6_addr_type(addr6);
722
723 if (addr_type == IPV6_ADDR_ANY) {
724 addr6 = &skb->nh.ipv6h->daddr;
725 addr_type = ipv6_addr_type(addr6);
726 }
727
728 if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
729 goto tx_error_icmp;
730
731 dst = addr6->s6_addr32[3];
732 }
733#endif
734 else
735 goto tx_error;
736 }
737
738 tos = tiph->tos;
739 if (tos&1) {
740 if (skb->protocol == htons(ETH_P_IP))
741 tos = old_iph->tos;
742 tos &= ~1;
743 }
744
745 {
746 struct flowi fl = { .oif = tunnel->parms.link,
747 .nl_u = { .ip4_u =
748 { .daddr = dst,
749 .saddr = tiph->saddr,
750 .tos = RT_TOS(tos) } },
751 .proto = IPPROTO_GRE };
752 if (ip_route_output_key(&rt, &fl)) {
753 tunnel->stat.tx_carrier_errors++;
754 goto tx_error;
755 }
756 }
757 tdev = rt->u.dst.dev;
758
759 if (tdev == dev) {
760 ip_rt_put(rt);
761 tunnel->stat.collisions++;
762 goto tx_error;
763 }
764
765 df = tiph->frag_off;
766 if (df)
767 mtu = dst_mtu(&rt->u.dst) - tunnel->hlen;
768 else
769 mtu = skb->dst ? dst_mtu(skb->dst) : dev->mtu;
770
771 if (skb->dst)
772 skb->dst->ops->update_pmtu(skb->dst, mtu);
773
774 if (skb->protocol == htons(ETH_P_IP)) {
775 df |= (old_iph->frag_off&htons(IP_DF));
776
777 if ((old_iph->frag_off&htons(IP_DF)) &&
778 mtu < ntohs(old_iph->tot_len)) {
779 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
780 ip_rt_put(rt);
781 goto tx_error;
782 }
783 }
784#ifdef CONFIG_IPV6
785 else if (skb->protocol == htons(ETH_P_IPV6)) {
786 struct rt6_info *rt6 = (struct rt6_info*)skb->dst;
787
788 if (rt6 && mtu < dst_mtu(skb->dst) && mtu >= IPV6_MIN_MTU) {
789 if ((tunnel->parms.iph.daddr && !MULTICAST(tunnel->parms.iph.daddr)) ||
790 rt6->rt6i_dst.plen == 128) {
791 rt6->rt6i_flags |= RTF_MODIFIED;
792 skb->dst->metrics[RTAX_MTU-1] = mtu;
793 }
794 }
795
796 if (mtu >= IPV6_MIN_MTU && mtu < skb->len - tunnel->hlen + gre_hlen) {
797 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, dev);
798 ip_rt_put(rt);
799 goto tx_error;
800 }
801 }
802#endif
803
804 if (tunnel->err_count > 0) {
805 if (jiffies - tunnel->err_time < IPTUNNEL_ERR_TIMEO) {
806 tunnel->err_count--;
807
808 dst_link_failure(skb);
809 } else
810 tunnel->err_count = 0;
811 }
812
813 max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen;
814
815 if (skb_headroom(skb) < max_headroom || skb_cloned(skb) || skb_shared(skb)) {
816 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
817 if (!new_skb) {
818 ip_rt_put(rt);
819 stats->tx_dropped++;
820 dev_kfree_skb(skb);
821 tunnel->recursion--;
822 return 0;
823 }
824 if (skb->sk)
825 skb_set_owner_w(new_skb, skb->sk);
826 dev_kfree_skb(skb);
827 skb = new_skb;
828 old_iph = skb->nh.iph;
829 }
830
831 skb->h.raw = skb->nh.raw;
832 skb->nh.raw = skb_push(skb, gre_hlen);
833 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
Patrick McHardy48d5cad2006-02-15 15:10:22 -0800834 IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
835 IPSKB_REROUTED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 dst_release(skb->dst);
837 skb->dst = &rt->u.dst;
838
839 /*
840 * Push down and install the IPIP header.
841 */
842
843 iph = skb->nh.iph;
844 iph->version = 4;
845 iph->ihl = sizeof(struct iphdr) >> 2;
846 iph->frag_off = df;
847 iph->protocol = IPPROTO_GRE;
848 iph->tos = ipgre_ecn_encapsulate(tos, old_iph, skb);
849 iph->daddr = rt->rt_dst;
850 iph->saddr = rt->rt_src;
851
852 if ((iph->ttl = tiph->ttl) == 0) {
853 if (skb->protocol == htons(ETH_P_IP))
854 iph->ttl = old_iph->ttl;
855#ifdef CONFIG_IPV6
856 else if (skb->protocol == htons(ETH_P_IPV6))
857 iph->ttl = ((struct ipv6hdr*)old_iph)->hop_limit;
858#endif
859 else
860 iph->ttl = dst_metric(&rt->u.dst, RTAX_HOPLIMIT);
861 }
862
Al Virod5a0a1e2006-11-08 00:23:14 -0800863 ((__be16*)(iph+1))[0] = tunnel->parms.o_flags;
864 ((__be16*)(iph+1))[1] = skb->protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865
866 if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
Al Virod5a0a1e2006-11-08 00:23:14 -0800867 __be32 *ptr = (__be32*)(((u8*)iph) + tunnel->hlen - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868
869 if (tunnel->parms.o_flags&GRE_SEQ) {
870 ++tunnel->o_seqno;
871 *ptr = htonl(tunnel->o_seqno);
872 ptr--;
873 }
874 if (tunnel->parms.o_flags&GRE_KEY) {
875 *ptr = tunnel->parms.o_key;
876 ptr--;
877 }
878 if (tunnel->parms.o_flags&GRE_CSUM) {
879 *ptr = 0;
Al Viro5f92a732006-11-14 21:36:54 -0800880 *(__sum16*)ptr = ip_compute_csum((void*)(iph+1), skb->len - sizeof(struct iphdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 }
882 }
883
884 nf_reset(skb);
885
886 IPTUNNEL_XMIT();
887 tunnel->recursion--;
888 return 0;
889
890tx_error_icmp:
891 dst_link_failure(skb);
892
893tx_error:
894 stats->tx_errors++;
895 dev_kfree_skb(skb);
896 tunnel->recursion--;
897 return 0;
898}
899
900static int
901ipgre_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
902{
903 int err = 0;
904 struct ip_tunnel_parm p;
905 struct ip_tunnel *t;
906
907 switch (cmd) {
908 case SIOCGETTUNNEL:
909 t = NULL;
910 if (dev == ipgre_fb_tunnel_dev) {
911 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
912 err = -EFAULT;
913 break;
914 }
915 t = ipgre_tunnel_locate(&p, 0);
916 }
917 if (t == NULL)
Patrick McHardy2941a482006-01-08 22:05:26 -0800918 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 memcpy(&p, &t->parms, sizeof(p));
920 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
921 err = -EFAULT;
922 break;
923
924 case SIOCADDTUNNEL:
925 case SIOCCHGTUNNEL:
926 err = -EPERM;
927 if (!capable(CAP_NET_ADMIN))
928 goto done;
929
930 err = -EFAULT;
931 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
932 goto done;
933
934 err = -EINVAL;
935 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
936 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
937 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
938 goto done;
939 if (p.iph.ttl)
940 p.iph.frag_off |= htons(IP_DF);
941
942 if (!(p.i_flags&GRE_KEY))
943 p.i_key = 0;
944 if (!(p.o_flags&GRE_KEY))
945 p.o_key = 0;
946
947 t = ipgre_tunnel_locate(&p, cmd == SIOCADDTUNNEL);
948
949 if (dev != ipgre_fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
950 if (t != NULL) {
951 if (t->dev != dev) {
952 err = -EEXIST;
953 break;
954 }
955 } else {
956 unsigned nflags=0;
957
Patrick McHardy2941a482006-01-08 22:05:26 -0800958 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959
960 if (MULTICAST(p.iph.daddr))
961 nflags = IFF_BROADCAST;
962 else if (p.iph.daddr)
963 nflags = IFF_POINTOPOINT;
964
965 if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
966 err = -EINVAL;
967 break;
968 }
969 ipgre_tunnel_unlink(t);
970 t->parms.iph.saddr = p.iph.saddr;
971 t->parms.iph.daddr = p.iph.daddr;
972 t->parms.i_key = p.i_key;
973 t->parms.o_key = p.o_key;
974 memcpy(dev->dev_addr, &p.iph.saddr, 4);
975 memcpy(dev->broadcast, &p.iph.daddr, 4);
976 ipgre_tunnel_link(t);
977 netdev_state_change(dev);
978 }
979 }
980
981 if (t) {
982 err = 0;
983 if (cmd == SIOCCHGTUNNEL) {
984 t->parms.iph.ttl = p.iph.ttl;
985 t->parms.iph.tos = p.iph.tos;
986 t->parms.iph.frag_off = p.iph.frag_off;
987 }
988 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
989 err = -EFAULT;
990 } else
991 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
992 break;
993
994 case SIOCDELTUNNEL:
995 err = -EPERM;
996 if (!capable(CAP_NET_ADMIN))
997 goto done;
998
999 if (dev == ipgre_fb_tunnel_dev) {
1000 err = -EFAULT;
1001 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1002 goto done;
1003 err = -ENOENT;
1004 if ((t = ipgre_tunnel_locate(&p, 0)) == NULL)
1005 goto done;
1006 err = -EPERM;
Patrick McHardy2941a482006-01-08 22:05:26 -08001007 if (t == netdev_priv(ipgre_fb_tunnel_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 goto done;
1009 dev = t->dev;
1010 }
1011 err = unregister_netdevice(dev);
1012 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
1036#ifdef CONFIG_NET_IPGRE_BROADCAST
1037/* Nice toy. Unfortunately, useless in real life :-)
1038 It allows to construct virtual multiprotocol broadcast "LAN"
1039 over the Internet, provided multicast routing is tuned.
1040
1041
1042 I have no idea was this bicycle invented before me,
1043 so that I had to set ARPHRD_IPGRE to a random value.
1044 I have an impression, that Cisco could make something similar,
1045 but this feature is apparently missing in IOS<=11.2(8).
1046
1047 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
1048 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
1049
1050 ping -t 255 224.66.66.66
1051
1052 If nobody answers, mbone does not work.
1053
1054 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
1055 ip addr add 10.66.66.<somewhat>/24 dev Universe
1056 ifconfig Universe up
1057 ifconfig Universe add fe80::<Your_real_addr>/10
1058 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
1059 ftp 10.66.66.66
1060 ...
1061 ftp fec0:6666:6666::193.233.7.65
1062 ...
1063
1064 */
1065
1066static int ipgre_header(struct sk_buff *skb, struct net_device *dev, unsigned short type,
1067 void *daddr, void *saddr, unsigned len)
1068{
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 /*
1078 * Set the source hardware address.
1079 */
1080
1081 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;
1090
1091 return -t->hlen;
1092}
1093
1094static int ipgre_open(struct net_device *dev)
1095{
Patrick McHardy2941a482006-01-08 22:05:26 -08001096 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097
1098 if (MULTICAST(t->parms.iph.daddr)) {
1099 struct flowi fl = { .oif = t->parms.link,
1100 .nl_u = { .ip4_u =
1101 { .daddr = t->parms.iph.daddr,
1102 .saddr = t->parms.iph.saddr,
1103 .tos = RT_TOS(t->parms.iph.tos) } },
1104 .proto = IPPROTO_GRE };
1105 struct rtable *rt;
1106 if (ip_route_output_key(&rt, &fl))
1107 return -EADDRNOTAVAIL;
1108 dev = rt->u.dst.dev;
1109 ip_rt_put(rt);
Herbert Xue5ed6392005-10-03 14:35:55 -07001110 if (__in_dev_get_rtnl(dev) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 return -EADDRNOTAVAIL;
1112 t->mlink = dev->ifindex;
Herbert Xue5ed6392005-10-03 14:35:55 -07001113 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 }
1115 return 0;
1116}
1117
1118static int ipgre_close(struct net_device *dev)
1119{
Patrick McHardy2941a482006-01-08 22:05:26 -08001120 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 if (MULTICAST(t->parms.iph.daddr) && t->mlink) {
1122 struct in_device *in_dev = inetdev_by_index(t->mlink);
1123 if (in_dev) {
1124 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
1125 in_dev_put(in_dev);
1126 }
1127 }
1128 return 0;
1129}
1130
1131#endif
1132
1133static void ipgre_tunnel_setup(struct net_device *dev)
1134{
1135 SET_MODULE_OWNER(dev);
1136 dev->uninit = ipgre_tunnel_uninit;
1137 dev->destructor = free_netdev;
1138 dev->hard_start_xmit = ipgre_tunnel_xmit;
1139 dev->get_stats = ipgre_tunnel_get_stats;
1140 dev->do_ioctl = ipgre_tunnel_ioctl;
1141 dev->change_mtu = ipgre_tunnel_change_mtu;
1142
1143 dev->type = ARPHRD_IPGRE;
1144 dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
Kris Katterjohn46f25df2006-01-05 16:35:42 -08001145 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 dev->flags = IFF_NOARP;
1147 dev->iflink = 0;
1148 dev->addr_len = 4;
1149}
1150
1151static int ipgre_tunnel_init(struct net_device *dev)
1152{
1153 struct net_device *tdev = NULL;
1154 struct ip_tunnel *tunnel;
1155 struct iphdr *iph;
1156 int hlen = LL_MAX_HEADER;
Kris Katterjohn46f25df2006-01-05 16:35:42 -08001157 int mtu = ETH_DATA_LEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 int addend = sizeof(struct iphdr) + 4;
1159
Patrick McHardy2941a482006-01-08 22:05:26 -08001160 tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 iph = &tunnel->parms.iph;
1162
1163 tunnel->dev = dev;
1164 strcpy(tunnel->parms.name, dev->name);
1165
1166 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1167 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1168
1169 /* Guess output device to choose reasonable mtu and hard_header_len */
1170
1171 if (iph->daddr) {
1172 struct flowi fl = { .oif = tunnel->parms.link,
1173 .nl_u = { .ip4_u =
1174 { .daddr = iph->daddr,
1175 .saddr = iph->saddr,
1176 .tos = RT_TOS(iph->tos) } },
1177 .proto = IPPROTO_GRE };
1178 struct rtable *rt;
1179 if (!ip_route_output_key(&rt, &fl)) {
1180 tdev = rt->u.dst.dev;
1181 ip_rt_put(rt);
1182 }
1183
1184 dev->flags |= IFF_POINTOPOINT;
1185
1186#ifdef CONFIG_NET_IPGRE_BROADCAST
1187 if (MULTICAST(iph->daddr)) {
1188 if (!iph->saddr)
1189 return -EINVAL;
1190 dev->flags = IFF_BROADCAST;
1191 dev->hard_header = ipgre_header;
1192 dev->open = ipgre_open;
1193 dev->stop = ipgre_close;
1194 }
1195#endif
1196 }
1197
1198 if (!tdev && tunnel->parms.link)
1199 tdev = __dev_get_by_index(tunnel->parms.link);
1200
1201 if (tdev) {
1202 hlen = tdev->hard_header_len;
1203 mtu = tdev->mtu;
1204 }
1205 dev->iflink = tunnel->parms.link;
1206
1207 /* Precalculate GRE options length */
1208 if (tunnel->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {
1209 if (tunnel->parms.o_flags&GRE_CSUM)
1210 addend += 4;
1211 if (tunnel->parms.o_flags&GRE_KEY)
1212 addend += 4;
1213 if (tunnel->parms.o_flags&GRE_SEQ)
1214 addend += 4;
1215 }
1216 dev->hard_header_len = hlen + addend;
1217 dev->mtu = mtu - addend;
1218 tunnel->hlen = addend;
1219 return 0;
1220}
1221
Adrian Bunk4b30b1c2005-11-29 16:27:20 -08001222static int __init ipgre_fb_tunnel_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223{
Patrick McHardy2941a482006-01-08 22:05:26 -08001224 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 struct iphdr *iph = &tunnel->parms.iph;
1226
1227 tunnel->dev = dev;
1228 strcpy(tunnel->parms.name, dev->name);
1229
1230 iph->version = 4;
1231 iph->protocol = IPPROTO_GRE;
1232 iph->ihl = 5;
1233 tunnel->hlen = sizeof(struct iphdr) + 4;
1234
1235 dev_hold(dev);
1236 tunnels_wc[0] = tunnel;
1237 return 0;
1238}
1239
1240
1241static struct net_protocol ipgre_protocol = {
1242 .handler = ipgre_rcv,
1243 .err_handler = ipgre_err,
1244};
1245
1246
1247/*
1248 * And now the modules code and kernel interface.
1249 */
1250
1251static int __init ipgre_init(void)
1252{
1253 int err;
1254
1255 printk(KERN_INFO "GRE over IPv4 tunneling driver\n");
1256
1257 if (inet_add_protocol(&ipgre_protocol, IPPROTO_GRE) < 0) {
1258 printk(KERN_INFO "ipgre init: can't add protocol\n");
1259 return -EAGAIN;
1260 }
1261
1262 ipgre_fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "gre0",
1263 ipgre_tunnel_setup);
1264 if (!ipgre_fb_tunnel_dev) {
1265 err = -ENOMEM;
1266 goto err1;
1267 }
1268
1269 ipgre_fb_tunnel_dev->init = ipgre_fb_tunnel_init;
1270
1271 if ((err = register_netdev(ipgre_fb_tunnel_dev)))
1272 goto err2;
1273out:
1274 return err;
1275err2:
1276 free_netdev(ipgre_fb_tunnel_dev);
1277err1:
1278 inet_del_protocol(&ipgre_protocol, IPPROTO_GRE);
1279 goto out;
1280}
1281
Alexey Kuznetsovdb445752005-07-30 17:46:44 -07001282static void __exit ipgre_destroy_tunnels(void)
1283{
1284 int prio;
1285
1286 for (prio = 0; prio < 4; prio++) {
1287 int h;
1288 for (h = 0; h < HASH_SIZE; h++) {
1289 struct ip_tunnel *t;
1290 while ((t = tunnels[prio][h]) != NULL)
1291 unregister_netdevice(t->dev);
1292 }
1293 }
1294}
1295
1296static void __exit ipgre_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297{
1298 if (inet_del_protocol(&ipgre_protocol, IPPROTO_GRE) < 0)
1299 printk(KERN_INFO "ipgre close: can't remove protocol\n");
1300
Alexey Kuznetsovdb445752005-07-30 17:46:44 -07001301 rtnl_lock();
1302 ipgre_destroy_tunnels();
1303 rtnl_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304}
1305
1306module_init(ipgre_init);
1307module_exit(ipgre_fini);
1308MODULE_LICENSE("GPL");