]> bbs.cooldavid.org Git - net-next-2.6.git/blame - net/ipv4/ip_gre.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[IPV6]: Fix leak added by udp connect dst caching fix.
[net-next-2.6.git] / net / ipv4 / ip_gre.c
CommitLineData
1da177e4
LT		 1/*
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
13#include <linux/config.h>
14#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>
31
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
65 Current solution: t->recursion lock breaks dead loops. It looks
66 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
146#define HASH(addr) ((addr^(addr>>4))&0xF)
147
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
159static struct ip_tunnel * ipgre_tunnel_lookup(u32 remote, u32 local, u32 key)
160{
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)
190 return ipgre_fb_tunnel_dev->priv;
191 return NULL;
192}
193
194static struct ip_tunnel **ipgre_bucket(struct ip_tunnel *t)
195{
196 u32 remote = t->parms.iph.daddr;
197 u32 local = t->parms.iph.saddr;
198 u32 key = t->parms.i_key;
199 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
212static void ipgre_tunnel_link(struct ip_tunnel *t)
213{
214 struct ip_tunnel **tp = ipgre_bucket(t);
215
216 t->next = *tp;
217 write_lock_bh(&ipgre_lock);
218 *tp = t;
219 write_unlock_bh(&ipgre_lock);
220}
221
222static void ipgre_tunnel_unlink(struct ip_tunnel *t)
223{
224 struct ip_tunnel **tp;
225
226 for (tp = ipgre_bucket(t); *tp; tp = &(*tp)->next) {
227 if (t == *tp) {
228 write_lock_bh(&ipgre_lock);
229 *tp = t->next;
230 write_unlock_bh(&ipgre_lock);
231 break;
232 }
233 }
234}
235
236static struct ip_tunnel * ipgre_tunnel_locate(struct ip_tunnel_parm *parms, int create)
237{
238 u32 remote = parms->iph.daddr;
239 u32 local = parms->iph.saddr;
240 u32 key = parms->i_key;
241 struct ip_tunnel *t, **tp, *nt;
242 struct net_device *dev;
243 unsigned h = HASH(key);
244 int prio = 0;
245 char name[IFNAMSIZ];
246
247 if (local)
248 prio |= 1;
249 if (remote && !MULTICAST(remote)) {
250 prio |= 2;
251 h ^= HASH(remote);
252 }
253 for (tp = &tunnels[prio][h]; (t = *tp) != NULL; tp = &t->next) {
254 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr) {
255 if (key == t->parms.i_key)
256 return t;
257 }
258 }
259 if (!create)
260 return NULL;
261
262 if (parms->name[0])
263 strlcpy(name, parms->name, IFNAMSIZ);
264 else {
265 int i;
266 for (i=1; i<100; i++) {
267 sprintf(name, "gre%d", i);
268 if (__dev_get_by_name(name) == NULL)
269 break;
270 }
271 if (i==100)
272 goto failed;
273 }
274
275 dev = alloc_netdev(sizeof(*t), name, ipgre_tunnel_setup);
276 if (!dev)
277 return NULL;
278
279 dev->init = ipgre_tunnel_init;
280 nt = dev->priv;
281 nt->parms = *parms;
282
283 if (register_netdevice(dev) < 0) {
284 free_netdev(dev);
285 goto failed;
286 }
287
288 nt = dev->priv;
289 nt->parms = *parms;
290
291 dev_hold(dev);
292 ipgre_tunnel_link(nt);
1da177e4
LT		 293 return nt;
294
295failed:
296 return NULL;
297}
298
299static void ipgre_tunnel_uninit(struct net_device *dev)
300{
301 ipgre_tunnel_unlink((struct ip_tunnel*)dev->priv);
302 dev_put(dev);
303}
304
305
306static void ipgre_err(struct sk_buff *skb, u32 info)
307{
308#ifndef I_WISH_WORLD_WERE_PERFECT
309
310/* It is not :-( All the routers (except for Linux) return only
311 8 bytes of packet payload. It means, that precise relaying of
312 ICMP in the real Internet is absolutely infeasible.
313
314 Moreover, Cisco "wise men" put GRE key to the third word
315 in GRE header. It makes impossible maintaining even soft state for keyed
316 GRE tunnels with enabled checksum. Tell them "thank you".
317
318 Well, I wonder, rfc1812 was written by Cisco employee,
319 what the hell these idiots break standrads established
320 by themself???
321 */
322
323 struct iphdr *iph = (struct iphdr*)skb->data;
324 u16 *p = (u16*)(skb->data+(iph->ihl<<2));
325 int grehlen = (iph->ihl<<2) + 4;
326 int type = skb->h.icmph->type;
327 int code = skb->h.icmph->code;
328 struct ip_tunnel *t;
329 u16 flags;
330
331 flags = p[0];
332 if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
333 if (flags&(GRE_VERSION|GRE_ROUTING))
334 return;
335 if (flags&GRE_KEY) {
336 grehlen += 4;
337 if (flags&GRE_CSUM)
338 grehlen += 4;
339 }
340 }
341
342 /* If only 8 bytes returned, keyed message will be dropped here */
343 if (skb_headlen(skb) < grehlen)
344 return;
345
346 switch (type) {
347 default:
348 case ICMP_PARAMETERPROB:
349 return;
350
351 case ICMP_DEST_UNREACH:
352 switch (code) {
353 case ICMP_SR_FAILED:
354 case ICMP_PORT_UNREACH:
355 /* Impossible event. */
356 return;
357 case ICMP_FRAG_NEEDED:
358 /* Soft state for pmtu is maintained by IP core. */
359 return;
360 default:
361 /* All others are translated to HOST_UNREACH.
362 rfc2003 contains "deep thoughts" about NET_UNREACH,
363 I believe they are just ether pollution. --ANK
364 */
365 break;
366 }
367 break;
368 case ICMP_TIME_EXCEEDED:
369 if (code != ICMP_EXC_TTL)
370 return;
371 break;
372 }
373
374 read_lock(&ipgre_lock);
375 t = ipgre_tunnel_lookup(iph->daddr, iph->saddr, (flags&GRE_KEY) ? *(((u32*)p) + (grehlen>>2) - 1) : 0);
376 if (t == NULL || t->parms.iph.daddr == 0 || MULTICAST(t->parms.iph.daddr))
377 goto out;
378
379 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
380 goto out;
381
382 if (jiffies - t->err_time < IPTUNNEL_ERR_TIMEO)
383 t->err_count++;
384 else
385 t->err_count = 1;
386 t->err_time = jiffies;
387out:
388 read_unlock(&ipgre_lock);
389 return;
390#else
391 struct iphdr *iph = (struct iphdr*)dp;
392 struct iphdr *eiph;
393 u16 *p = (u16*)(dp+(iph->ihl<<2));
394 int type = skb->h.icmph->type;
395 int code = skb->h.icmph->code;
396 int rel_type = 0;
397 int rel_code = 0;
398 int rel_info = 0;
399 u16 flags;
400 int grehlen = (iph->ihl<<2) + 4;
401 struct sk_buff *skb2;
402 struct flowi fl;
403 struct rtable *rt;
404
405 if (p[1] != htons(ETH_P_IP))
406 return;
407
408 flags = p[0];
409 if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
410 if (flags&(GRE_VERSION|GRE_ROUTING))
411 return;
412 if (flags&GRE_CSUM)
413 grehlen += 4;
414 if (flags&GRE_KEY)
415 grehlen += 4;
416 if (flags&GRE_SEQ)
417 grehlen += 4;
418 }
419 if (len < grehlen + sizeof(struct iphdr))
420 return;
421 eiph = (struct iphdr*)(dp + grehlen);
422
423 switch (type) {
424 default:
425 return;
426 case ICMP_PARAMETERPROB:
427 if (skb->h.icmph->un.gateway < (iph->ihl<<2))
428 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;
434 rel_info = skb->h.icmph->un.gateway - grehlen;
435 break;
436
437 case ICMP_DEST_UNREACH:
438 switch (code) {
439 case ICMP_SR_FAILED:
440 case ICMP_PORT_UNREACH:
441 /* Impossible event. */
442 return;
443 case ICMP_FRAG_NEEDED:
444 /* And it is the only really necessary thing :-) */
445 rel_info = ntohs(skb->h.icmph->un.frag.mtu);
446 if (rel_info < grehlen+68)
447 return;
448 rel_info -= grehlen;
449 /* BSD 4.2 MORE DOES NOT EXIST IN NATURE. */
450 if (rel_info > ntohs(eiph->tot_len))
451 return;
452 break;
453 default:
454 /* All others are translated to HOST_UNREACH.
455 rfc2003 contains "deep thoughts" about NET_UNREACH,
456 I believe, it is just ether pollution. --ANK
457 */
458 rel_type = ICMP_DEST_UNREACH;
459 rel_code = ICMP_HOST_UNREACH;
460 break;
461 }
462 break;
463 case ICMP_TIME_EXCEEDED:
464 if (code != ICMP_EXC_TTL)
465 return;
466 break;
467 }
468
469 /* Prepare fake skb to feed it to icmp_send */
470 skb2 = skb_clone(skb, GFP_ATOMIC);
471 if (skb2 == NULL)
472 return;
473 dst_release(skb2->dst);
474 skb2->dst = NULL;
475 skb_pull(skb2, skb->data - (u8*)eiph);
476 skb2->nh.raw = skb2->data;
477
478 /* Try to guess incoming interface */
479 memset(&fl, 0, sizeof(fl));
480 fl.fl4_dst = eiph->saddr;
481 fl.fl4_tos = RT_TOS(eiph->tos);
482 fl.proto = IPPROTO_GRE;
483 if (ip_route_output_key(&rt, &fl)) {
484 kfree_skb(skb2);
485 return;
486 }
487 skb2->dev = rt->u.dst.dev;
488
489 /* route "incoming" packet */
490 if (rt->rt_flags&RTCF_LOCAL) {
491 ip_rt_put(rt);
492 rt = NULL;
493 fl.fl4_dst = eiph->daddr;
494 fl.fl4_src = eiph->saddr;
495 fl.fl4_tos = eiph->tos;
496 if (ip_route_output_key(&rt, &fl) ||
497 rt->u.dst.dev->type != ARPHRD_IPGRE) {
498 ip_rt_put(rt);
499 kfree_skb(skb2);
500 return;
501 }
502 } else {
503 ip_rt_put(rt);
504 if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos, skb2->dev) ||
505 skb2->dst->dev->type != ARPHRD_IPGRE) {
506 kfree_skb(skb2);
507 return;
508 }
509 }
510
511 /* change mtu on this route */
512 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
513 if (rel_info > dst_mtu(skb2->dst)) {
514 kfree_skb(skb2);
515 return;
516 }
517 skb2->dst->ops->update_pmtu(skb2->dst, rel_info);
518 rel_info = htonl(rel_info);
519 } else if (type == ICMP_TIME_EXCEEDED) {
520 struct ip_tunnel *t = (struct ip_tunnel*)skb2->dev->priv;
521 if (t->parms.iph.ttl) {
522 rel_type = ICMP_DEST_UNREACH;
523 rel_code = ICMP_HOST_UNREACH;
524 }
525 }
526
527 icmp_send(skb2, rel_type, rel_code, rel_info);
528 kfree_skb(skb2);
529#endif
530}
531
532static inline void ipgre_ecn_decapsulate(struct iphdr *iph, struct sk_buff *skb)
533{
534 if (INET_ECN_is_ce(iph->tos)) {
535 if (skb->protocol == htons(ETH_P_IP)) {
536 IP_ECN_set_ce(skb->nh.iph);
537 } else if (skb->protocol == htons(ETH_P_IPV6)) {
538 IP6_ECN_set_ce(skb->nh.ipv6h);
539 }
540 }
541}
542
543static inline u8
544ipgre_ecn_encapsulate(u8 tos, struct iphdr *old_iph, struct sk_buff *skb)
545{
546 u8 inner = 0;
547 if (skb->protocol == htons(ETH_P_IP))
548 inner = old_iph->tos;
549 else if (skb->protocol == htons(ETH_P_IPV6))
550 inner = ipv6_get_dsfield((struct ipv6hdr *)old_iph);
551 return INET_ECN_encapsulate(tos, inner);
552}
553
554static int ipgre_rcv(struct sk_buff *skb)
555{
556 struct iphdr *iph;
557 u8 *h;
558 u16 flags;
559 u16 csum = 0;
560 u32 key = 0;
561 u32 seqno = 0;
562 struct ip_tunnel *tunnel;
563 int offset = 4;
564
565 if (!pskb_may_pull(skb, 16))
566 goto drop_nolock;
567
568 iph = skb->nh.iph;
569 h = skb->data;
570 flags = *(u16*)h;
571
572 if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {
573 /* - Version must be 0.
574 - We do not support routing headers.
575 */
576 if (flags&(GRE_VERSION|GRE_ROUTING))
577 goto drop_nolock;
578
579 if (flags&GRE_CSUM) {
580 if (skb->ip_summed == CHECKSUM_HW) {
581 csum = (u16)csum_fold(skb->csum);
582 if (csum)
583 skb->ip_summed = CHECKSUM_NONE;
584 }
585 if (skb->ip_summed == CHECKSUM_NONE) {
586 skb->csum = skb_checksum(skb, 0, skb->len, 0);
587 skb->ip_summed = CHECKSUM_HW;
588 csum = (u16)csum_fold(skb->csum);
589 }
590 offset += 4;
591 }
592 if (flags&GRE_KEY) {
593 key = *(u32*)(h + offset);
594 offset += 4;
595 }
596 if (flags&GRE_SEQ) {
597 seqno = ntohl(*(u32*)(h + offset));
598 offset += 4;
599 }
600 }
601
602 read_lock(&ipgre_lock);
603 if ((tunnel = ipgre_tunnel_lookup(iph->saddr, iph->daddr, key)) != NULL) {
604 secpath_reset(skb);
605
606 skb->protocol = *(u16*)(h + 2);
607 /* WCCP version 1 and 2 protocol decoding.
608 * - Change protocol to IP
609 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
610 */
611 if (flags == 0 &&
612 skb->protocol == __constant_htons(ETH_P_WCCP)) {
613 skb->protocol = __constant_htons(ETH_P_IP);
614 if ((*(h + offset) & 0xF0) != 0x40)
615 offset += 4;
616 }
617
618 skb->mac.raw = skb->nh.raw;
619 skb->nh.raw = __pskb_pull(skb, offset);
620 skb_postpull_rcsum(skb, skb->mac.raw, offset);
621 memset(&(IPCB(skb)->opt), 0, sizeof(struct ip_options));
622 skb->pkt_type = PACKET_HOST;
623#ifdef CONFIG_NET_IPGRE_BROADCAST
624 if (MULTICAST(iph->daddr)) {
625 /* Looped back packet, drop it! */
626 if (((struct rtable*)skb->dst)->fl.iif == 0)
627 goto drop;
628 tunnel->stat.multicast++;
629 skb->pkt_type = PACKET_BROADCAST;
630 }
631#endif
632
633 if (((flags&GRE_CSUM) && csum) ||
634 (!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {
635 tunnel->stat.rx_crc_errors++;
636 tunnel->stat.rx_errors++;
637 goto drop;
638 }
639 if (tunnel->parms.i_flags&GRE_SEQ) {
640 if (!(flags&GRE_SEQ) ||
641 (tunnel->i_seqno && (s32)(seqno - tunnel->i_seqno) < 0)) {
642 tunnel->stat.rx_fifo_errors++;
643 tunnel->stat.rx_errors++;
644 goto drop;
645 }
646 tunnel->i_seqno = seqno + 1;
647 }
648 tunnel->stat.rx_packets++;
649 tunnel->stat.rx_bytes += skb->len;
650 skb->dev = tunnel->dev;
651 dst_release(skb->dst);
652 skb->dst = NULL;
653 nf_reset(skb);
654 ipgre_ecn_decapsulate(iph, skb);
655 netif_rx(skb);
656 read_unlock(&ipgre_lock);
657 return(0);
658 }
659 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, 0);
660
661drop:
662 read_unlock(&ipgre_lock);
663drop_nolock:
664 kfree_skb(skb);
665 return(0);
666}
667
668static int ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
669{
670 struct ip_tunnel *tunnel = (struct ip_tunnel*)dev->priv;
671 struct net_device_stats *stats = &tunnel->stat;
672 struct iphdr *old_iph = skb->nh.iph;
673 struct iphdr *tiph;
674 u8 tos;
675 u16 df;
676 struct rtable *rt; /* Route to the other host */
677 struct net_device *tdev; /* Device to other host */
678 struct iphdr *iph; /* Our new IP header */
679 int max_headroom; /* The extra header space needed */
680 int gre_hlen;
681 u32 dst;
682 int mtu;
683
684 if (tunnel->recursion++) {
685 tunnel->stat.collisions++;
686 goto tx_error;
687 }
688
689 if (dev->hard_header) {
690 gre_hlen = 0;
691 tiph = (struct iphdr*)skb->data;
692 } else {
693 gre_hlen = tunnel->hlen;
694 tiph = &tunnel->parms.iph;
695 }
696
697 if ((dst = tiph->daddr) == 0) {
698 /* NBMA tunnel */
699
700 if (skb->dst == NULL) {
701 tunnel->stat.tx_fifo_errors++;
702 goto tx_error;
703 }
704
705 if (skb->protocol == htons(ETH_P_IP)) {
706 rt = (struct rtable*)skb->dst;
707 if ((dst = rt->rt_gateway) == 0)
708 goto tx_error_icmp;
709 }
710#ifdef CONFIG_IPV6
711 else if (skb->protocol == htons(ETH_P_IPV6)) {
712 struct in6_addr *addr6;
713 int addr_type;
714 struct neighbour *neigh = skb->dst->neighbour;
715
716 if (neigh == NULL)
717 goto tx_error;
718
719 addr6 = (struct in6_addr*)&neigh->primary_key;
720 addr_type = ipv6_addr_type(addr6);
721
722 if (addr_type == IPV6_ADDR_ANY) {
723 addr6 = &skb->nh.ipv6h->daddr;
724 addr_type = ipv6_addr_type(addr6);
725 }
726
727 if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
728 goto tx_error_icmp;
729
730 dst = addr6->s6_addr32[3];
731 }
732#endif
733 else
734 goto tx_error;
735 }
736
737 tos = tiph->tos;
738 if (tos&1) {
739 if (skb->protocol == htons(ETH_P_IP))
740 tos = old_iph->tos;
741 tos &= ~1;
742 }
743
744 {
745 struct flowi fl = { .oif = tunnel->parms.link,
746 .nl_u = { .ip4_u =
747 { .daddr = dst,
748 .saddr = tiph->saddr,
749 .tos = RT_TOS(tos) } },
750 .proto = IPPROTO_GRE };
751 if (ip_route_output_key(&rt, &fl)) {
752 tunnel->stat.tx_carrier_errors++;
753 goto tx_error;
754 }
755 }
756 tdev = rt->u.dst.dev;
757
758 if (tdev == dev) {
759 ip_rt_put(rt);
760 tunnel->stat.collisions++;
761 goto tx_error;
762 }
763
764 df = tiph->frag_off;
765 if (df)
766 mtu = dst_mtu(&rt->u.dst) - tunnel->hlen;
767 else
768 mtu = skb->dst ? dst_mtu(skb->dst) : dev->mtu;
769
770 if (skb->dst)
771 skb->dst->ops->update_pmtu(skb->dst, mtu);
772
773 if (skb->protocol == htons(ETH_P_IP)) {
774 df |= (old_iph->frag_off&htons(IP_DF));
775
776 if ((old_iph->frag_off&htons(IP_DF)) &&
777 mtu < ntohs(old_iph->tot_len)) {
778 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
779 ip_rt_put(rt);
780 goto tx_error;
781 }
782 }
783#ifdef CONFIG_IPV6
784 else if (skb->protocol == htons(ETH_P_IPV6)) {
785 struct rt6_info *rt6 = (struct rt6_info*)skb->dst;
786
787 if (rt6 && mtu < dst_mtu(skb->dst) && mtu >= IPV6_MIN_MTU) {
788 if ((tunnel->parms.iph.daddr && !MULTICAST(tunnel->parms.iph.daddr)) ||
789 rt6->rt6i_dst.plen == 128) {
790 rt6->rt6i_flags |= RTF_MODIFIED;
791 skb->dst->metrics[RTAX_MTU-1] = mtu;
792 }
793 }
794
795 if (mtu >= IPV6_MIN_MTU && mtu < skb->len - tunnel->hlen + gre_hlen) {
796 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, dev);
797 ip_rt_put(rt);
798 goto tx_error;
799 }
800 }
801#endif
802
803 if (tunnel->err_count > 0) {
804 if (jiffies - tunnel->err_time < IPTUNNEL_ERR_TIMEO) {
805 tunnel->err_count--;
806
807 dst_link_failure(skb);
808 } else
809 tunnel->err_count = 0;
810 }
811
812 max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen;
813
814 if (skb_headroom(skb) < max_headroom || skb_cloned(skb) || skb_shared(skb)) {
815 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
816 if (!new_skb) {
817 ip_rt_put(rt);
818 stats->tx_dropped++;
819 dev_kfree_skb(skb);
820 tunnel->recursion--;
821 return 0;
822 }
823 if (skb->sk)
824 skb_set_owner_w(new_skb, skb->sk);
825 dev_kfree_skb(skb);
826 skb = new_skb;
827 old_iph = skb->nh.iph;
828 }
829
830 skb->h.raw = skb->nh.raw;
831 skb->nh.raw = skb_push(skb, gre_hlen);
832 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
833 dst_release(skb->dst);
834 skb->dst = &rt->u.dst;
835
836 /*
837 * Push down and install the IPIP header.
838 */
839
840 iph = skb->nh.iph;
841 iph->version = 4;
842 iph->ihl = sizeof(struct iphdr) >> 2;
843 iph->frag_off = df;
844 iph->protocol = IPPROTO_GRE;
845 iph->tos = ipgre_ecn_encapsulate(tos, old_iph, skb);
846 iph->daddr = rt->rt_dst;
847 iph->saddr = rt->rt_src;
848
849 if ((iph->ttl = tiph->ttl) == 0) {
850 if (skb->protocol == htons(ETH_P_IP))
851 iph->ttl = old_iph->ttl;
852#ifdef CONFIG_IPV6
853 else if (skb->protocol == htons(ETH_P_IPV6))
854 iph->ttl = ((struct ipv6hdr*)old_iph)->hop_limit;
855#endif
856 else
857 iph->ttl = dst_metric(&rt->u.dst, RTAX_HOPLIMIT);
858 }
859
860 ((u16*)(iph+1))[0] = tunnel->parms.o_flags;
861 ((u16*)(iph+1))[1] = skb->protocol;
862
863 if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
864 u32 *ptr = (u32*)(((u8*)iph) + tunnel->hlen - 4);
865
866 if (tunnel->parms.o_flags&GRE_SEQ) {
867 ++tunnel->o_seqno;
868 *ptr = htonl(tunnel->o_seqno);
869 ptr--;
870 }
871 if (tunnel->parms.o_flags&GRE_KEY) {
872 *ptr = tunnel->parms.o_key;
873 ptr--;
874 }
875 if (tunnel->parms.o_flags&GRE_CSUM) {
876 *ptr = 0;
877 *(__u16*)ptr = ip_compute_csum((void*)(iph+1), skb->len - sizeof(struct iphdr));
878 }
879 }
880
881 nf_reset(skb);
882
883 IPTUNNEL_XMIT();
884 tunnel->recursion--;
885 return 0;
886
887tx_error_icmp:
888 dst_link_failure(skb);
889
890tx_error:
891 stats->tx_errors++;
892 dev_kfree_skb(skb);
893 tunnel->recursion--;
894 return 0;
895}
896
897static int
898ipgre_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
899{
900 int err = 0;
901 struct ip_tunnel_parm p;
902 struct ip_tunnel *t;
903
904 switch (cmd) {
905 case SIOCGETTUNNEL:
906 t = NULL;
907 if (dev == ipgre_fb_tunnel_dev) {
908 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
909 err = -EFAULT;
910 break;
911 }
912 t = ipgre_tunnel_locate(&p, 0);
913 }
914 if (t == NULL)
915 t = (struct ip_tunnel*)dev->priv;
916 memcpy(&p, &t->parms, sizeof(p));
917 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
918 err = -EFAULT;
919 break;
920
921 case SIOCADDTUNNEL:
922 case SIOCCHGTUNNEL:
923 err = -EPERM;
924 if (!capable(CAP_NET_ADMIN))
925 goto done;
926
927 err = -EFAULT;
928 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
929 goto done;
930
931 err = -EINVAL;
932 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
933 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
934 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
935 goto done;
936 if (p.iph.ttl)
937 p.iph.frag_off |= htons(IP_DF);
938
939 if (!(p.i_flags&GRE_KEY))
940 p.i_key = 0;
941 if (!(p.o_flags&GRE_KEY))
942 p.o_key = 0;
943
944 t = ipgre_tunnel_locate(&p, cmd == SIOCADDTUNNEL);
945
946 if (dev != ipgre_fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
947 if (t != NULL) {
948 if (t->dev != dev) {
949 err = -EEXIST;
950 break;
951 }
952 } else {
953 unsigned nflags=0;
954
955 t = (struct ip_tunnel*)dev->priv;
956
957 if (MULTICAST(p.iph.daddr))
958 nflags = IFF_BROADCAST;
959 else if (p.iph.daddr)
960 nflags = IFF_POINTOPOINT;
961
962 if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
963 err = -EINVAL;
964 break;
965 }
966 ipgre_tunnel_unlink(t);
967 t->parms.iph.saddr = p.iph.saddr;
968 t->parms.iph.daddr = p.iph.daddr;
969 t->parms.i_key = p.i_key;
970 t->parms.o_key = p.o_key;
971 memcpy(dev->dev_addr, &p.iph.saddr, 4);
972 memcpy(dev->broadcast, &p.iph.daddr, 4);
973 ipgre_tunnel_link(t);
974 netdev_state_change(dev);
975 }
976 }
977
978 if (t) {
979 err = 0;
980 if (cmd == SIOCCHGTUNNEL) {
981 t->parms.iph.ttl = p.iph.ttl;
982 t->parms.iph.tos = p.iph.tos;
983 t->parms.iph.frag_off = p.iph.frag_off;
984 }
985 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
986 err = -EFAULT;
987 } else
988 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
989 break;
990
991 case SIOCDELTUNNEL:
992 err = -EPERM;
993 if (!capable(CAP_NET_ADMIN))
994 goto done;
995
996 if (dev == ipgre_fb_tunnel_dev) {
997 err = -EFAULT;
998 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
999 goto done;
1000 err = -ENOENT;
1001 if ((t = ipgre_tunnel_locate(&p, 0)) == NULL)
1002 goto done;
1003 err = -EPERM;
1004 if (t == ipgre_fb_tunnel_dev->priv)
1005 goto done;
1006 dev = t->dev;
1007 }
1008 err = unregister_netdevice(dev);
1009 break;
1010
1011 default:
1012 err = -EINVAL;
1013 }
1014
1015done:
1016 return err;
1017}
1018
1019static struct net_device_stats *ipgre_tunnel_get_stats(struct net_device *dev)
1020{
1021 return &(((struct ip_tunnel*)dev->priv)->stat);
1022}
1023
1024static int ipgre_tunnel_change_mtu(struct net_device *dev, int new_mtu)
1025{
1026 struct ip_tunnel *tunnel = (struct ip_tunnel*)dev->priv;
1027 if (new_mtu < 68 || new_mtu > 0xFFF8 - tunnel->hlen)
1028 return -EINVAL;
1029 dev->mtu = new_mtu;
1030 return 0;
1031}
1032
1033#ifdef CONFIG_NET_IPGRE_BROADCAST
1034/* Nice toy. Unfortunately, useless in real life :-)
1035 It allows to construct virtual multiprotocol broadcast "LAN"
1036 over the Internet, provided multicast routing is tuned.
1037
1038
1039 I have no idea was this bicycle invented before me,
1040 so that I had to set ARPHRD_IPGRE to a random value.
1041 I have an impression, that Cisco could make something similar,
1042 but this feature is apparently missing in IOS<=11.2(8).
1043
1044 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
1045 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
1046
1047 ping -t 255 224.66.66.66
1048
1049 If nobody answers, mbone does not work.
1050
1051 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
1052 ip addr add 10.66.66.<somewhat>/24 dev Universe
1053 ifconfig Universe up
1054 ifconfig Universe add fe80::<Your_real_addr>/10
1055 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
1056 ftp 10.66.66.66
1057 ...
1058 ftp fec0:6666:6666::193.233.7.65
1059 ...
1060
1061 */
1062
1063static int ipgre_header(struct sk_buff *skb, struct net_device *dev, unsigned short type,
1064 void *daddr, void *saddr, unsigned len)
1065{
1066 struct ip_tunnel *t = (struct ip_tunnel*)dev->priv;
1067 struct iphdr *iph = (struct iphdr *)skb_push(skb, t->hlen);
1068 u16 *p = (u16*)(iph+1);
1069
1070 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
1071 p[0] = t->parms.o_flags;
1072 p[1] = htons(type);
1073
1074 /*
1075 * Set the source hardware address.
1076 */
1077
1078 if (saddr)
1079 memcpy(&iph->saddr, saddr, 4);
1080
1081 if (daddr) {
1082 memcpy(&iph->daddr, daddr, 4);
1083 return t->hlen;
1084 }
1085 if (iph->daddr && !MULTICAST(iph->daddr))
1086 return t->hlen;
1087
1088 return -t->hlen;
1089}
1090
1091static int ipgre_open(struct net_device *dev)
1092{
1093 struct ip_tunnel *t = (struct ip_tunnel*)dev->priv;
1094
1095 if (MULTICAST(t->parms.iph.daddr)) {
1096 struct flowi fl = { .oif = t->parms.link,
1097 .nl_u = { .ip4_u =
1098 { .daddr = t->parms.iph.daddr,
1099 .saddr = t->parms.iph.saddr,
1100 .tos = RT_TOS(t->parms.iph.tos) } },
1101 .proto = IPPROTO_GRE };
1102 struct rtable *rt;
1103 if (ip_route_output_key(&rt, &fl))
1104 return -EADDRNOTAVAIL;
1105 dev = rt->u.dst.dev;
1106 ip_rt_put(rt);
1107 if (__in_dev_get(dev) == NULL)
1108 return -EADDRNOTAVAIL;
1109 t->mlink = dev->ifindex;
1110 ip_mc_inc_group(__in_dev_get(dev), t->parms.iph.daddr);
1111 }
1112 return 0;
1113}
1114
1115static int ipgre_close(struct net_device *dev)
1116{
1117 struct ip_tunnel *t = (struct ip_tunnel*)dev->priv;
1118 if (MULTICAST(t->parms.iph.daddr) && t->mlink) {
1119 struct in_device *in_dev = inetdev_by_index(t->mlink);
1120 if (in_dev) {
1121 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
1122 in_dev_put(in_dev);
1123 }
1124 }
1125 return 0;
1126}
1127
1128#endif
1129
1130static void ipgre_tunnel_setup(struct net_device *dev)
1131{
1132 SET_MODULE_OWNER(dev);
1133 dev->uninit = ipgre_tunnel_uninit;
1134 dev->destructor = free_netdev;
1135 dev->hard_start_xmit = ipgre_tunnel_xmit;
1136 dev->get_stats = ipgre_tunnel_get_stats;
1137 dev->do_ioctl = ipgre_tunnel_ioctl;
1138 dev->change_mtu = ipgre_tunnel_change_mtu;
1139
1140 dev->type = ARPHRD_IPGRE;
1141 dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
1142 dev->mtu = 1500 - sizeof(struct iphdr) - 4;
1143 dev->flags = IFF_NOARP;
1144 dev->iflink = 0;
1145 dev->addr_len = 4;
1146}
1147
1148static int ipgre_tunnel_init(struct net_device *dev)
1149{
1150 struct net_device *tdev = NULL;
1151 struct ip_tunnel *tunnel;
1152 struct iphdr *iph;
1153 int hlen = LL_MAX_HEADER;
1154 int mtu = 1500;
1155 int addend = sizeof(struct iphdr) + 4;
1156
1157 tunnel = (struct ip_tunnel*)dev->priv;
1158 iph = &tunnel->parms.iph;
1159
1160 tunnel->dev = dev;
1161 strcpy(tunnel->parms.name, dev->name);
1162
1163 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1164 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1165
1166 /* Guess output device to choose reasonable mtu and hard_header_len */
1167
1168 if (iph->daddr) {
1169 struct flowi fl = { .oif = tunnel->parms.link,
1170 .nl_u = { .ip4_u =
1171 { .daddr = iph->daddr,
1172 .saddr = iph->saddr,
1173 .tos = RT_TOS(iph->tos) } },
1174 .proto = IPPROTO_GRE };
1175 struct rtable *rt;
1176 if (!ip_route_output_key(&rt, &fl)) {
1177 tdev = rt->u.dst.dev;
1178 ip_rt_put(rt);
1179 }
1180
1181 dev->flags |= IFF_POINTOPOINT;
1182
1183#ifdef CONFIG_NET_IPGRE_BROADCAST
1184 if (MULTICAST(iph->daddr)) {
1185 if (!iph->saddr)
1186 return -EINVAL;
1187 dev->flags = IFF_BROADCAST;
1188 dev->hard_header = ipgre_header;
1189 dev->open = ipgre_open;
1190 dev->stop = ipgre_close;
1191 }
1192#endif
1193 }
1194
1195 if (!tdev && tunnel->parms.link)
1196 tdev = __dev_get_by_index(tunnel->parms.link);
1197
1198 if (tdev) {
1199 hlen = tdev->hard_header_len;
1200 mtu = tdev->mtu;
1201 }
1202 dev->iflink = tunnel->parms.link;
1203
1204 /* Precalculate GRE options length */
1205 if (tunnel->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {
1206 if (tunnel->parms.o_flags&GRE_CSUM)
1207 addend += 4;
1208 if (tunnel->parms.o_flags&GRE_KEY)
1209 addend += 4;
1210 if (tunnel->parms.o_flags&GRE_SEQ)
1211 addend += 4;
1212 }
1213 dev->hard_header_len = hlen + addend;
1214 dev->mtu = mtu - addend;
1215 tunnel->hlen = addend;
1216 return 0;
1217}
1218
1219int __init ipgre_fb_tunnel_init(struct net_device *dev)
1220{
1221 struct ip_tunnel *tunnel = (struct ip_tunnel*)dev->priv;
1222 struct iphdr *iph = &tunnel->parms.iph;
1223
1224 tunnel->dev = dev;
1225 strcpy(tunnel->parms.name, dev->name);
1226
1227 iph->version = 4;
1228 iph->protocol = IPPROTO_GRE;
1229 iph->ihl = 5;
1230 tunnel->hlen = sizeof(struct iphdr) + 4;
1231
1232 dev_hold(dev);
1233 tunnels_wc[0] = tunnel;
1234 return 0;
1235}
1236
1237
1238static struct net_protocol ipgre_protocol = {
1239 .handler = ipgre_rcv,
1240 .err_handler = ipgre_err,
1241};
1242
1243
1244/*
1245 * And now the modules code and kernel interface.
1246 */
1247
1248static int __init ipgre_init(void)
1249{
1250 int err;
1251
1252 printk(KERN_INFO "GRE over IPv4 tunneling driver\n");
1253
1254 if (inet_add_protocol(&ipgre_protocol, IPPROTO_GRE) < 0) {
1255 printk(KERN_INFO "ipgre init: can't add protocol\n");
1256 return -EAGAIN;
1257 }
1258
1259 ipgre_fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "gre0",
1260 ipgre_tunnel_setup);
1261 if (!ipgre_fb_tunnel_dev) {
1262 err = -ENOMEM;
1263 goto err1;
1264 }
1265
1266 ipgre_fb_tunnel_dev->init = ipgre_fb_tunnel_init;
1267
1268 if ((err = register_netdev(ipgre_fb_tunnel_dev)))
1269 goto err2;
1270out:
1271 return err;
1272err2:
1273 free_netdev(ipgre_fb_tunnel_dev);
1274err1:
1275 inet_del_protocol(&ipgre_protocol, IPPROTO_GRE);
1276 goto out;
1277}
1278
db44575f
AK		 1279static void __exit ipgre_destroy_tunnels(void)
1280{
1281 int prio;
1282
1283 for (prio = 0; prio < 4; prio++) {
1284 int h;
1285 for (h = 0; h < HASH_SIZE; h++) {
1286 struct ip_tunnel *t;
1287 while ((t = tunnels[prio][h]) != NULL)
1288 unregister_netdevice(t->dev);
1289 }
1290 }
1291}
1292
1293static void __exit ipgre_fini(void)
1da177e4
LT		 1294{
1295 if (inet_del_protocol(&ipgre_protocol, IPPROTO_GRE) < 0)
1296 printk(KERN_INFO "ipgre close: can't remove protocol\n");
1297
db44575f
AK		 1298 rtnl_lock();
1299 ipgre_destroy_tunnels();
1300 rtnl_unlock();
1da177e4
LT		 1301}
1302
1303module_init(ipgre_init);
1304module_exit(ipgre_fini);
1305MODULE_LICENSE("GPL");
Clone of davem's net-next-2.6 tree