blob: 9981dcd68f11e76dc5213832ac20323a6b6dd3d1 [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/config.h>
15#include <linux/module.h>
16#include <linux/types.h>
17#include <linux/sched.h>
18#include <linux/kernel.h>
19#include <asm/uaccess.h>
20#include <linux/skbuff.h>
21#include <linux/netdevice.h>
22#include <linux/in.h>
23#include <linux/tcp.h>
24#include <linux/udp.h>
25#include <linux/if_arp.h>
26#include <linux/mroute.h>
27#include <linux/init.h>
28#include <linux/in6.h>
29#include <linux/inetdevice.h>
30#include <linux/igmp.h>
31#include <linux/netfilter_ipv4.h>
Kris Katterjohn46f25df2006-01-05 16:35:42 -080032#include <linux/if_ether.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
34#include <net/sock.h>
35#include <net/ip.h>
36#include <net/icmp.h>
37#include <net/protocol.h>
38#include <net/ipip.h>
39#include <net/arp.h>
40#include <net/checksum.h>
41#include <net/dsfield.h>
42#include <net/inet_ecn.h>
43#include <net/xfrm.h>
44
45#ifdef CONFIG_IPV6
46#include <net/ipv6.h>
47#include <net/ip6_fib.h>
48#include <net/ip6_route.h>
49#endif
50
51/*
52 Problems & solutions
53 --------------------
54
55 1. The most important issue is detecting local dead loops.
56 They would cause complete host lockup in transmit, which
57 would be "resolved" by stack overflow or, if queueing is enabled,
58 with infinite looping in net_bh.
59
60 We cannot track such dead loops during route installation,
61 it is infeasible task. The most general solutions would be
62 to keep skb->encapsulation counter (sort of local ttl),
63 and silently drop packet when it expires. It is the best
64 solution, but it supposes maintaing new variable in ALL
65 skb, even if no tunneling is used.
66
67 Current solution: t->recursion lock breaks dead loops. It looks
68 like dev->tbusy flag, but I preferred new variable, because
69 the semantics is different. One day, when hard_start_xmit
70 will be multithreaded we will have to use skb->encapsulation.
71
72
73
74 2. Networking dead loops would not kill routers, but would really
75 kill network. IP hop limit plays role of "t->recursion" in this case,
76 if we copy it from packet being encapsulated to upper header.
77 It is very good solution, but it introduces two problems:
78
79 - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
80 do not work over tunnels.
81 - traceroute does not work. I planned to relay ICMP from tunnel,
82 so that this problem would be solved and traceroute output
83 would even more informative. This idea appeared to be wrong:
84 only Linux complies to rfc1812 now (yes, guys, Linux is the only
85 true router now :-)), all routers (at least, in neighbourhood of mine)
86 return only 8 bytes of payload. It is the end.
87
88 Hence, if we want that OSPF worked or traceroute said something reasonable,
89 we should search for another solution.
90
91 One of them is to parse packet trying to detect inner encapsulation
92 made by our node. It is difficult or even impossible, especially,
93 taking into account fragmentation. TO be short, tt is not solution at all.
94
95 Current solution: The solution was UNEXPECTEDLY SIMPLE.
96 We force DF flag on tunnels with preconfigured hop limit,
97 that is ALL. :-) Well, it does not remove the problem completely,
98 but exponential growth of network traffic is changed to linear
99 (branches, that exceed pmtu are pruned) and tunnel mtu
100 fastly degrades to value <68, where looping stops.
101 Yes, it is not good if there exists a router in the loop,
102 which does not force DF, even when encapsulating packets have DF set.
103 But it is not our problem! Nobody could accuse us, we made
104 all that we could make. Even if it is your gated who injected
105 fatal route to network, even if it were you who configured
106 fatal static route: you are innocent. :-)
107
108
109
110 3. Really, ipv4/ipip.c, ipv4/ip_gre.c and ipv6/sit.c contain
111 practically identical code. It would be good to glue them
112 together, but it is not very evident, how to make them modular.
113 sit is integral part of IPv6, ipip and gre are naturally modular.
114 We could extract common parts (hash table, ioctl etc)
115 to a separate module (ip_tunnel.c).
116
117 Alexey Kuznetsov.
118 */
119
120static int ipgre_tunnel_init(struct net_device *dev);
121static void ipgre_tunnel_setup(struct net_device *dev);
122
123/* Fallback tunnel: no source, no destination, no key, no options */
124
125static int ipgre_fb_tunnel_init(struct net_device *dev);
126
127static struct net_device *ipgre_fb_tunnel_dev;
128
129/* Tunnel hash table */
130
131/*
132 4 hash tables:
133
134 3: (remote,local)
135 2: (remote,*)
136 1: (*,local)
137 0: (*,*)
138
139 We require exact key match i.e. if a key is present in packet
140 it will match only tunnel with the same key; if it is not present,
141 it will match only keyless tunnel.
142
143 All keysless packets, if not matched configured keyless tunnels
144 will match fallback tunnel.
145 */
146
147#define HASH_SIZE 16
148#define HASH(addr) ((addr^(addr>>4))&0xF)
149
150static struct ip_tunnel *tunnels[4][HASH_SIZE];
151
152#define tunnels_r_l (tunnels[3])
153#define tunnels_r (tunnels[2])
154#define tunnels_l (tunnels[1])
155#define tunnels_wc (tunnels[0])
156
157static DEFINE_RWLOCK(ipgre_lock);
158
159/* Given src, dst and key, find appropriate for input tunnel. */
160
161static struct ip_tunnel * ipgre_tunnel_lookup(u32 remote, u32 local, u32 key)
162{
163 unsigned h0 = HASH(remote);
164 unsigned h1 = HASH(key);
165 struct ip_tunnel *t;
166
167 for (t = tunnels_r_l[h0^h1]; t; t = t->next) {
168 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr) {
169 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
170 return t;
171 }
172 }
173 for (t = tunnels_r[h0^h1]; t; t = t->next) {
174 if (remote == t->parms.iph.daddr) {
175 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
176 return t;
177 }
178 }
179 for (t = tunnels_l[h1]; t; t = t->next) {
180 if (local == t->parms.iph.saddr ||
181 (local == t->parms.iph.daddr && MULTICAST(local))) {
182 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
183 return t;
184 }
185 }
186 for (t = tunnels_wc[h1]; t; t = t->next) {
187 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
188 return t;
189 }
190
191 if (ipgre_fb_tunnel_dev->flags&IFF_UP)
Patrick McHardy2941a482006-01-08 22:05:26 -0800192 return netdev_priv(ipgre_fb_tunnel_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 return NULL;
194}
195
196static struct ip_tunnel **ipgre_bucket(struct ip_tunnel *t)
197{
198 u32 remote = t->parms.iph.daddr;
199 u32 local = t->parms.iph.saddr;
200 u32 key = t->parms.i_key;
201 unsigned h = HASH(key);
202 int prio = 0;
203
204 if (local)
205 prio |= 1;
206 if (remote && !MULTICAST(remote)) {
207 prio |= 2;
208 h ^= HASH(remote);
209 }
210
211 return &tunnels[prio][h];
212}
213
214static void ipgre_tunnel_link(struct ip_tunnel *t)
215{
216 struct ip_tunnel **tp = ipgre_bucket(t);
217
218 t->next = *tp;
219 write_lock_bh(&ipgre_lock);
220 *tp = t;
221 write_unlock_bh(&ipgre_lock);
222}
223
224static void ipgre_tunnel_unlink(struct ip_tunnel *t)
225{
226 struct ip_tunnel **tp;
227
228 for (tp = ipgre_bucket(t); *tp; tp = &(*tp)->next) {
229 if (t == *tp) {
230 write_lock_bh(&ipgre_lock);
231 *tp = t->next;
232 write_unlock_bh(&ipgre_lock);
233 break;
234 }
235 }
236}
237
238static struct ip_tunnel * ipgre_tunnel_locate(struct ip_tunnel_parm *parms, int create)
239{
240 u32 remote = parms->iph.daddr;
241 u32 local = parms->iph.saddr;
242 u32 key = parms->i_key;
243 struct ip_tunnel *t, **tp, *nt;
244 struct net_device *dev;
245 unsigned h = HASH(key);
246 int prio = 0;
247 char name[IFNAMSIZ];
248
249 if (local)
250 prio |= 1;
251 if (remote && !MULTICAST(remote)) {
252 prio |= 2;
253 h ^= HASH(remote);
254 }
255 for (tp = &tunnels[prio][h]; (t = *tp) != NULL; tp = &t->next) {
256 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr) {
257 if (key == t->parms.i_key)
258 return t;
259 }
260 }
261 if (!create)
262 return NULL;
263
264 if (parms->name[0])
265 strlcpy(name, parms->name, IFNAMSIZ);
266 else {
267 int i;
268 for (i=1; i<100; i++) {
269 sprintf(name, "gre%d", i);
270 if (__dev_get_by_name(name) == NULL)
271 break;
272 }
273 if (i==100)
274 goto failed;
275 }
276
277 dev = alloc_netdev(sizeof(*t), name, ipgre_tunnel_setup);
278 if (!dev)
279 return NULL;
280
281 dev->init = ipgre_tunnel_init;
Patrick McHardy2941a482006-01-08 22:05:26 -0800282 nt = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 nt->parms = *parms;
284
285 if (register_netdevice(dev) < 0) {
286 free_netdev(dev);
287 goto failed;
288 }
289
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 dev_hold(dev);
291 ipgre_tunnel_link(nt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 return nt;
293
294failed:
295 return NULL;
296}
297
298static void ipgre_tunnel_uninit(struct net_device *dev)
299{
Patrick McHardy2941a482006-01-08 22:05:26 -0800300 ipgre_tunnel_unlink(netdev_priv(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 dev_put(dev);
302}
303
304
305static void ipgre_err(struct sk_buff *skb, u32 info)
306{
307#ifndef I_WISH_WORLD_WERE_PERFECT
308
309/* It is not :-( All the routers (except for Linux) return only
310 8 bytes of packet payload. It means, that precise relaying of
311 ICMP in the real Internet is absolutely infeasible.
312
313 Moreover, Cisco "wise men" put GRE key to the third word
314 in GRE header. It makes impossible maintaining even soft state for keyed
315 GRE tunnels with enabled checksum. Tell them "thank you".
316
317 Well, I wonder, rfc1812 was written by Cisco employee,
318 what the hell these idiots break standrads established
319 by themself???
320 */
321
322 struct iphdr *iph = (struct iphdr*)skb->data;
323 u16 *p = (u16*)(skb->data+(iph->ihl<<2));
324 int grehlen = (iph->ihl<<2) + 4;
325 int type = skb->h.icmph->type;
326 int code = skb->h.icmph->code;
327 struct ip_tunnel *t;
328 u16 flags;
329
330 flags = p[0];
331 if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
332 if (flags&(GRE_VERSION|GRE_ROUTING))
333 return;
334 if (flags&GRE_KEY) {
335 grehlen += 4;
336 if (flags&GRE_CSUM)
337 grehlen += 4;
338 }
339 }
340
341 /* If only 8 bytes returned, keyed message will be dropped here */
342 if (skb_headlen(skb) < grehlen)
343 return;
344
345 switch (type) {
346 default:
347 case ICMP_PARAMETERPROB:
348 return;
349
350 case ICMP_DEST_UNREACH:
351 switch (code) {
352 case ICMP_SR_FAILED:
353 case ICMP_PORT_UNREACH:
354 /* Impossible event. */
355 return;
356 case ICMP_FRAG_NEEDED:
357 /* Soft state for pmtu is maintained by IP core. */
358 return;
359 default:
360 /* All others are translated to HOST_UNREACH.
361 rfc2003 contains "deep thoughts" about NET_UNREACH,
362 I believe they are just ether pollution. --ANK
363 */
364 break;
365 }
366 break;
367 case ICMP_TIME_EXCEEDED:
368 if (code != ICMP_EXC_TTL)
369 return;
370 break;
371 }
372
373 read_lock(&ipgre_lock);
374 t = ipgre_tunnel_lookup(iph->daddr, iph->saddr, (flags&GRE_KEY) ? *(((u32*)p) + (grehlen>>2) - 1) : 0);
375 if (t == NULL || t->parms.iph.daddr == 0 || MULTICAST(t->parms.iph.daddr))
376 goto out;
377
378 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
379 goto out;
380
381 if (jiffies - t->err_time < IPTUNNEL_ERR_TIMEO)
382 t->err_count++;
383 else
384 t->err_count = 1;
385 t->err_time = jiffies;
386out:
387 read_unlock(&ipgre_lock);
388 return;
389#else
390 struct iphdr *iph = (struct iphdr*)dp;
391 struct iphdr *eiph;
392 u16 *p = (u16*)(dp+(iph->ihl<<2));
393 int type = skb->h.icmph->type;
394 int code = skb->h.icmph->code;
395 int rel_type = 0;
396 int rel_code = 0;
397 int rel_info = 0;
398 u16 flags;
399 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:
426 if (skb->h.icmph->un.gateway < (iph->ihl<<2))
427 return;
428
429 /* So... This guy found something strange INSIDE encapsulated
430 packet. Well, he is fool, but what can we do ?
431 */
432 rel_type = ICMP_PARAMETERPROB;
433 rel_info = skb->h.icmph->un.gateway - grehlen;
434 break;
435
436 case ICMP_DEST_UNREACH:
437 switch (code) {
438 case ICMP_SR_FAILED:
439 case ICMP_PORT_UNREACH:
440 /* Impossible event. */
441 return;
442 case ICMP_FRAG_NEEDED:
443 /* And it is the only really necessary thing :-) */
444 rel_info = ntohs(skb->h.icmph->un.frag.mtu);
445 if (rel_info < grehlen+68)
446 return;
447 rel_info -= grehlen;
448 /* BSD 4.2 MORE DOES NOT EXIST IN NATURE. */
449 if (rel_info > ntohs(eiph->tot_len))
450 return;
451 break;
452 default:
453 /* All others are translated to HOST_UNREACH.
454 rfc2003 contains "deep thoughts" about NET_UNREACH,
455 I believe, it is just ether pollution. --ANK
456 */
457 rel_type = ICMP_DEST_UNREACH;
458 rel_code = ICMP_HOST_UNREACH;
459 break;
460 }
461 break;
462 case ICMP_TIME_EXCEEDED:
463 if (code != ICMP_EXC_TTL)
464 return;
465 break;
466 }
467
468 /* Prepare fake skb to feed it to icmp_send */
469 skb2 = skb_clone(skb, GFP_ATOMIC);
470 if (skb2 == NULL)
471 return;
472 dst_release(skb2->dst);
473 skb2->dst = NULL;
474 skb_pull(skb2, skb->data - (u8*)eiph);
475 skb2->nh.raw = skb2->data;
476
477 /* Try to guess incoming interface */
478 memset(&fl, 0, sizeof(fl));
479 fl.fl4_dst = eiph->saddr;
480 fl.fl4_tos = RT_TOS(eiph->tos);
481 fl.proto = IPPROTO_GRE;
482 if (ip_route_output_key(&rt, &fl)) {
483 kfree_skb(skb2);
484 return;
485 }
486 skb2->dev = rt->u.dst.dev;
487
488 /* route "incoming" packet */
489 if (rt->rt_flags&RTCF_LOCAL) {
490 ip_rt_put(rt);
491 rt = NULL;
492 fl.fl4_dst = eiph->daddr;
493 fl.fl4_src = eiph->saddr;
494 fl.fl4_tos = eiph->tos;
495 if (ip_route_output_key(&rt, &fl) ||
496 rt->u.dst.dev->type != ARPHRD_IPGRE) {
497 ip_rt_put(rt);
498 kfree_skb(skb2);
499 return;
500 }
501 } else {
502 ip_rt_put(rt);
503 if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos, skb2->dev) ||
504 skb2->dst->dev->type != ARPHRD_IPGRE) {
505 kfree_skb(skb2);
506 return;
507 }
508 }
509
510 /* change mtu on this route */
511 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
512 if (rel_info > dst_mtu(skb2->dst)) {
513 kfree_skb(skb2);
514 return;
515 }
516 skb2->dst->ops->update_pmtu(skb2->dst, rel_info);
517 rel_info = htonl(rel_info);
518 } else if (type == ICMP_TIME_EXCEEDED) {
Patrick McHardy2941a482006-01-08 22:05:26 -0800519 struct ip_tunnel *t = netdev_priv(skb2->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 if (t->parms.iph.ttl) {
521 rel_type = ICMP_DEST_UNREACH;
522 rel_code = ICMP_HOST_UNREACH;
523 }
524 }
525
526 icmp_send(skb2, rel_type, rel_code, rel_info);
527 kfree_skb(skb2);
528#endif
529}
530
531static inline void ipgre_ecn_decapsulate(struct iphdr *iph, struct sk_buff *skb)
532{
533 if (INET_ECN_is_ce(iph->tos)) {
534 if (skb->protocol == htons(ETH_P_IP)) {
535 IP_ECN_set_ce(skb->nh.iph);
536 } else if (skb->protocol == htons(ETH_P_IPV6)) {
537 IP6_ECN_set_ce(skb->nh.ipv6h);
538 }
539 }
540}
541
542static inline u8
543ipgre_ecn_encapsulate(u8 tos, struct iphdr *old_iph, struct sk_buff *skb)
544{
545 u8 inner = 0;
546 if (skb->protocol == htons(ETH_P_IP))
547 inner = old_iph->tos;
548 else if (skb->protocol == htons(ETH_P_IPV6))
549 inner = ipv6_get_dsfield((struct ipv6hdr *)old_iph);
550 return INET_ECN_encapsulate(tos, inner);
551}
552
553static int ipgre_rcv(struct sk_buff *skb)
554{
555 struct iphdr *iph;
556 u8 *h;
557 u16 flags;
558 u16 csum = 0;
559 u32 key = 0;
560 u32 seqno = 0;
561 struct ip_tunnel *tunnel;
562 int offset = 4;
563
564 if (!pskb_may_pull(skb, 16))
565 goto drop_nolock;
566
567 iph = skb->nh.iph;
568 h = skb->data;
569 flags = *(u16*)h;
570
571 if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {
572 /* - Version must be 0.
573 - We do not support routing headers.
574 */
575 if (flags&(GRE_VERSION|GRE_ROUTING))
576 goto drop_nolock;
577
578 if (flags&GRE_CSUM) {
Herbert Xufb286bb2005-11-10 13:01:24 -0800579 switch (skb->ip_summed) {
580 case CHECKSUM_HW:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 csum = (u16)csum_fold(skb->csum);
Herbert Xufb286bb2005-11-10 13:01:24 -0800582 if (!csum)
583 break;
584 /* fall through */
585 case CHECKSUM_NONE:
586 skb->csum = 0;
587 csum = __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 skb->ip_summed = CHECKSUM_HW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 }
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);
Herbert Xu15422722005-12-14 12:55:24 -0800620 skb_postpull_rcsum(skb, skb->h.raw, offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 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{
Patrick McHardy2941a482006-01-08 22:05:26 -0800670 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 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));
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
842 iph = skb->nh.iph;
843 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
862 ((u16*)(iph+1))[0] = tunnel->parms.o_flags;
863 ((u16*)(iph+1))[1] = skb->protocol;
864
865 if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
866 u32 *ptr = (u32*)(((u8*)iph) + tunnel->hlen - 4);
867
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;
879 *(__u16*)ptr = ip_compute_csum((void*)(iph+1), skb->len - sizeof(struct iphdr));
880 }
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 }
1010 err = unregister_netdevice(dev);
1011 break;
1012
1013 default:
1014 err = -EINVAL;
1015 }
1016
1017done:
1018 return err;
1019}
1020
1021static struct net_device_stats *ipgre_tunnel_get_stats(struct net_device *dev)
1022{
Patrick McHardy2941a482006-01-08 22:05:26 -08001023 return &(((struct ip_tunnel*)netdev_priv(dev))->stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024}
1025
1026static int ipgre_tunnel_change_mtu(struct net_device *dev, int new_mtu)
1027{
Patrick McHardy2941a482006-01-08 22:05:26 -08001028 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 if (new_mtu < 68 || new_mtu > 0xFFF8 - tunnel->hlen)
1030 return -EINVAL;
1031 dev->mtu = new_mtu;
1032 return 0;
1033}
1034
1035#ifdef CONFIG_NET_IPGRE_BROADCAST
1036/* 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).
1045
1046 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
1065static int ipgre_header(struct sk_buff *skb, struct net_device *dev, unsigned short type,
1066 void *daddr, void *saddr, unsigned len)
1067{
Patrick McHardy2941a482006-01-08 22:05:26 -08001068 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 struct iphdr *iph = (struct iphdr *)skb_push(skb, t->hlen);
1070 u16 *p = (u16*)(iph+1);
1071
1072 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
1073 p[0] = t->parms.o_flags;
1074 p[1] = htons(type);
1075
1076 /*
1077 * Set the source hardware address.
1078 */
1079
1080 if (saddr)
1081 memcpy(&iph->saddr, saddr, 4);
1082
1083 if (daddr) {
1084 memcpy(&iph->daddr, daddr, 4);
1085 return t->hlen;
1086 }
1087 if (iph->daddr && !MULTICAST(iph->daddr))
1088 return t->hlen;
1089
1090 return -t->hlen;
1091}
1092
1093static int ipgre_open(struct net_device *dev)
1094{
Patrick McHardy2941a482006-01-08 22:05:26 -08001095 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096
1097 if (MULTICAST(t->parms.iph.daddr)) {
1098 struct flowi fl = { .oif = t->parms.link,
1099 .nl_u = { .ip4_u =
1100 { .daddr = t->parms.iph.daddr,
1101 .saddr = t->parms.iph.saddr,
1102 .tos = RT_TOS(t->parms.iph.tos) } },
1103 .proto = IPPROTO_GRE };
1104 struct rtable *rt;
1105 if (ip_route_output_key(&rt, &fl))
1106 return -EADDRNOTAVAIL;
1107 dev = rt->u.dst.dev;
1108 ip_rt_put(rt);
Herbert Xue5ed6392005-10-03 14:35:55 -07001109 if (__in_dev_get_rtnl(dev) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 return -EADDRNOTAVAIL;
1111 t->mlink = dev->ifindex;
Herbert Xue5ed6392005-10-03 14:35:55 -07001112 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 }
1114 return 0;
1115}
1116
1117static int ipgre_close(struct net_device *dev)
1118{
Patrick McHardy2941a482006-01-08 22:05:26 -08001119 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 if (MULTICAST(t->parms.iph.daddr) && t->mlink) {
1121 struct in_device *in_dev = inetdev_by_index(t->mlink);
1122 if (in_dev) {
1123 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
1124 in_dev_put(in_dev);
1125 }
1126 }
1127 return 0;
1128}
1129
1130#endif
1131
1132static void ipgre_tunnel_setup(struct net_device *dev)
1133{
1134 SET_MODULE_OWNER(dev);
1135 dev->uninit = ipgre_tunnel_uninit;
1136 dev->destructor = free_netdev;
1137 dev->hard_start_xmit = ipgre_tunnel_xmit;
1138 dev->get_stats = ipgre_tunnel_get_stats;
1139 dev->do_ioctl = ipgre_tunnel_ioctl;
1140 dev->change_mtu = ipgre_tunnel_change_mtu;
1141
1142 dev->type = ARPHRD_IPGRE;
1143 dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
Kris Katterjohn46f25df2006-01-05 16:35:42 -08001144 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 dev->flags = IFF_NOARP;
1146 dev->iflink = 0;
1147 dev->addr_len = 4;
1148}
1149
1150static int ipgre_tunnel_init(struct net_device *dev)
1151{
1152 struct net_device *tdev = NULL;
1153 struct ip_tunnel *tunnel;
1154 struct iphdr *iph;
1155 int hlen = LL_MAX_HEADER;
Kris Katterjohn46f25df2006-01-05 16:35:42 -08001156 int mtu = ETH_DATA_LEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 int addend = sizeof(struct iphdr) + 4;
1158
Patrick McHardy2941a482006-01-08 22:05:26 -08001159 tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 iph = &tunnel->parms.iph;
1161
1162 tunnel->dev = dev;
1163 strcpy(tunnel->parms.name, dev->name);
1164
1165 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1166 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1167
1168 /* Guess output device to choose reasonable mtu and hard_header_len */
1169
1170 if (iph->daddr) {
1171 struct flowi fl = { .oif = tunnel->parms.link,
1172 .nl_u = { .ip4_u =
1173 { .daddr = iph->daddr,
1174 .saddr = iph->saddr,
1175 .tos = RT_TOS(iph->tos) } },
1176 .proto = IPPROTO_GRE };
1177 struct rtable *rt;
1178 if (!ip_route_output_key(&rt, &fl)) {
1179 tdev = rt->u.dst.dev;
1180 ip_rt_put(rt);
1181 }
1182
1183 dev->flags |= IFF_POINTOPOINT;
1184
1185#ifdef CONFIG_NET_IPGRE_BROADCAST
1186 if (MULTICAST(iph->daddr)) {
1187 if (!iph->saddr)
1188 return -EINVAL;
1189 dev->flags = IFF_BROADCAST;
1190 dev->hard_header = ipgre_header;
1191 dev->open = ipgre_open;
1192 dev->stop = ipgre_close;
1193 }
1194#endif
1195 }
1196
1197 if (!tdev && tunnel->parms.link)
1198 tdev = __dev_get_by_index(tunnel->parms.link);
1199
1200 if (tdev) {
1201 hlen = tdev->hard_header_len;
1202 mtu = tdev->mtu;
1203 }
1204 dev->iflink = tunnel->parms.link;
1205
1206 /* Precalculate GRE options length */
1207 if (tunnel->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {
1208 if (tunnel->parms.o_flags&GRE_CSUM)
1209 addend += 4;
1210 if (tunnel->parms.o_flags&GRE_KEY)
1211 addend += 4;
1212 if (tunnel->parms.o_flags&GRE_SEQ)
1213 addend += 4;
1214 }
1215 dev->hard_header_len = hlen + addend;
1216 dev->mtu = mtu - addend;
1217 tunnel->hlen = addend;
1218 return 0;
1219}
1220
Adrian Bunk4b30b1c2005-11-29 16:27:20 -08001221static int __init ipgre_fb_tunnel_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222{
Patrick McHardy2941a482006-01-08 22:05:26 -08001223 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 struct iphdr *iph = &tunnel->parms.iph;
1225
1226 tunnel->dev = dev;
1227 strcpy(tunnel->parms.name, dev->name);
1228
1229 iph->version = 4;
1230 iph->protocol = IPPROTO_GRE;
1231 iph->ihl = 5;
1232 tunnel->hlen = sizeof(struct iphdr) + 4;
1233
1234 dev_hold(dev);
1235 tunnels_wc[0] = tunnel;
1236 return 0;
1237}
1238
1239
1240static struct net_protocol ipgre_protocol = {
1241 .handler = ipgre_rcv,
1242 .err_handler = ipgre_err,
1243};
1244
1245
1246/*
1247 * And now the modules code and kernel interface.
1248 */
1249
1250static int __init ipgre_init(void)
1251{
1252 int err;
1253
1254 printk(KERN_INFO "GRE over IPv4 tunneling driver\n");
1255
1256 if (inet_add_protocol(&ipgre_protocol, IPPROTO_GRE) < 0) {
1257 printk(KERN_INFO "ipgre init: can't add protocol\n");
1258 return -EAGAIN;
1259 }
1260
1261 ipgre_fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "gre0",
1262 ipgre_tunnel_setup);
1263 if (!ipgre_fb_tunnel_dev) {
1264 err = -ENOMEM;
1265 goto err1;
1266 }
1267
1268 ipgre_fb_tunnel_dev->init = ipgre_fb_tunnel_init;
1269
1270 if ((err = register_netdev(ipgre_fb_tunnel_dev)))
1271 goto err2;
1272out:
1273 return err;
1274err2:
1275 free_netdev(ipgre_fb_tunnel_dev);
1276err1:
1277 inet_del_protocol(&ipgre_protocol, IPPROTO_GRE);
1278 goto out;
1279}
1280
Alexey Kuznetsovdb445752005-07-30 17:46:44 -07001281static void __exit ipgre_destroy_tunnels(void)
1282{
1283 int prio;
1284
1285 for (prio = 0; prio < 4; prio++) {
1286 int h;
1287 for (h = 0; h < HASH_SIZE; h++) {
1288 struct ip_tunnel *t;
1289 while ((t = tunnels[prio][h]) != NULL)
1290 unregister_netdevice(t->dev);
1291 }
1292 }
1293}
1294
1295static void __exit ipgre_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296{
1297 if (inet_del_protocol(&ipgre_protocol, IPPROTO_GRE) < 0)
1298 printk(KERN_INFO "ipgre close: can't remove protocol\n");
1299
Alexey Kuznetsovdb445752005-07-30 17:46:44 -07001300 rtnl_lock();
1301 ipgre_destroy_tunnels();
1302 rtnl_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303}
1304
1305module_init(ipgre_init);
1306module_exit(ipgre_fini);
1307MODULE_LICENSE("GPL");