xref: /openbmc/linux/net/ipv4/ip_gre.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
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/capability.h>
14 #include <linux/module.h>
15 #include <linux/types.h>
16 #include <linux/kernel.h>
17 #include <asm/uaccess.h>
18 #include <linux/skbuff.h>
19 #include <linux/netdevice.h>
20 #include <linux/in.h>
21 #include <linux/tcp.h>
22 #include <linux/udp.h>
23 #include <linux/if_arp.h>
24 #include <linux/mroute.h>
25 #include <linux/init.h>
26 #include <linux/in6.h>
27 #include <linux/inetdevice.h>
28 #include <linux/igmp.h>
29 #include <linux/netfilter_ipv4.h>
30 #include <linux/if_ether.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 
118 static int ipgre_tunnel_init(struct net_device *dev);
119 static void ipgre_tunnel_setup(struct net_device *dev);
120 
121 /* Fallback tunnel: no source, no destination, no key, no options */
122 
123 static int ipgre_fb_tunnel_init(struct net_device *dev);
124 
125 static 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) (((__force u32)addr^((__force u32)addr>>4))&0xF)
147 
148 static 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 
155 static DEFINE_RWLOCK(ipgre_lock);
156 
157 /* Given src, dst and key, find appropriate for input tunnel. */
158 
159 static struct ip_tunnel * ipgre_tunnel_lookup(__be32 remote, __be32 local, __be32 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 netdev_priv(ipgre_fb_tunnel_dev);
191 	return NULL;
192 }
193 
194 static struct ip_tunnel **__ipgre_bucket(struct ip_tunnel_parm *parms)
195 {
196 	__be32 remote = parms->iph.daddr;
197 	__be32 local = parms->iph.saddr;
198 	__be32 key = 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 
212 static inline struct ip_tunnel **ipgre_bucket(struct ip_tunnel *t)
213 {
214 	return __ipgre_bucket(&t->parms);
215 }
216 
217 static void ipgre_tunnel_link(struct ip_tunnel *t)
218 {
219 	struct ip_tunnel **tp = ipgre_bucket(t);
220 
221 	t->next = *tp;
222 	write_lock_bh(&ipgre_lock);
223 	*tp = t;
224 	write_unlock_bh(&ipgre_lock);
225 }
226 
227 static void ipgre_tunnel_unlink(struct ip_tunnel *t)
228 {
229 	struct ip_tunnel **tp;
230 
231 	for (tp = ipgre_bucket(t); *tp; tp = &(*tp)->next) {
232 		if (t == *tp) {
233 			write_lock_bh(&ipgre_lock);
234 			*tp = t->next;
235 			write_unlock_bh(&ipgre_lock);
236 			break;
237 		}
238 	}
239 }
240 
241 static struct ip_tunnel * ipgre_tunnel_locate(struct ip_tunnel_parm *parms, int create)
242 {
243 	__be32 remote = parms->iph.daddr;
244 	__be32 local = parms->iph.saddr;
245 	__be32 key = parms->i_key;
246 	struct ip_tunnel *t, **tp, *nt;
247 	struct net_device *dev;
248 	char name[IFNAMSIZ];
249 
250 	for (tp = __ipgre_bucket(parms); (t = *tp) != NULL; tp = &t->next) {
251 		if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr) {
252 			if (key == t->parms.i_key)
253 				return t;
254 		}
255 	}
256 	if (!create)
257 		return NULL;
258 
259 	if (parms->name[0])
260 		strlcpy(name, parms->name, IFNAMSIZ);
261 	else {
262 		int i;
263 		for (i=1; i<100; i++) {
264 			sprintf(name, "gre%d", i);
265 			if (__dev_get_by_name(name) == NULL)
266 				break;
267 		}
268 		if (i==100)
269 			goto failed;
270 	}
271 
272 	dev = alloc_netdev(sizeof(*t), name, ipgre_tunnel_setup);
273 	if (!dev)
274 	  return NULL;
275 
276 	dev->init = ipgre_tunnel_init;
277 	nt = netdev_priv(dev);
278 	nt->parms = *parms;
279 
280 	if (register_netdevice(dev) < 0) {
281 		free_netdev(dev);
282 		goto failed;
283 	}
284 
285 	dev_hold(dev);
286 	ipgre_tunnel_link(nt);
287 	return nt;
288 
289 failed:
290 	return NULL;
291 }
292 
293 static void ipgre_tunnel_uninit(struct net_device *dev)
294 {
295 	ipgre_tunnel_unlink(netdev_priv(dev));
296 	dev_put(dev);
297 }
298 
299 
300 static void ipgre_err(struct sk_buff *skb, u32 info)
301 {
302 #ifndef I_WISH_WORLD_WERE_PERFECT
303 
304 /* It is not :-( All the routers (except for Linux) return only
305    8 bytes of packet payload. It means, that precise relaying of
306    ICMP in the real Internet is absolutely infeasible.
307 
308    Moreover, Cisco "wise men" put GRE key to the third word
309    in GRE header. It makes impossible maintaining even soft state for keyed
310    GRE tunnels with enabled checksum. Tell them "thank you".
311 
312    Well, I wonder, rfc1812 was written by Cisco employee,
313    what the hell these idiots break standrads established
314    by themself???
315  */
316 
317 	struct iphdr *iph = (struct iphdr*)skb->data;
318 	__be16	     *p = (__be16*)(skb->data+(iph->ihl<<2));
319 	int grehlen = (iph->ihl<<2) + 4;
320 	const int type = icmp_hdr(skb)->type;
321 	const int code = icmp_hdr(skb)->code;
322 	struct ip_tunnel *t;
323 	__be16 flags;
324 
325 	flags = p[0];
326 	if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
327 		if (flags&(GRE_VERSION|GRE_ROUTING))
328 			return;
329 		if (flags&GRE_KEY) {
330 			grehlen += 4;
331 			if (flags&GRE_CSUM)
332 				grehlen += 4;
333 		}
334 	}
335 
336 	/* If only 8 bytes returned, keyed message will be dropped here */
337 	if (skb_headlen(skb) < grehlen)
338 		return;
339 
340 	switch (type) {
341 	default:
342 	case ICMP_PARAMETERPROB:
343 		return;
344 
345 	case ICMP_DEST_UNREACH:
346 		switch (code) {
347 		case ICMP_SR_FAILED:
348 		case ICMP_PORT_UNREACH:
349 			/* Impossible event. */
350 			return;
351 		case ICMP_FRAG_NEEDED:
352 			/* Soft state for pmtu is maintained by IP core. */
353 			return;
354 		default:
355 			/* All others are translated to HOST_UNREACH.
356 			   rfc2003 contains "deep thoughts" about NET_UNREACH,
357 			   I believe they are just ether pollution. --ANK
358 			 */
359 			break;
360 		}
361 		break;
362 	case ICMP_TIME_EXCEEDED:
363 		if (code != ICMP_EXC_TTL)
364 			return;
365 		break;
366 	}
367 
368 	read_lock(&ipgre_lock);
369 	t = ipgre_tunnel_lookup(iph->daddr, iph->saddr, (flags&GRE_KEY) ? *(((__be32*)p) + (grehlen>>2) - 1) : 0);
370 	if (t == NULL || t->parms.iph.daddr == 0 || MULTICAST(t->parms.iph.daddr))
371 		goto out;
372 
373 	if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
374 		goto out;
375 
376 	if (jiffies - t->err_time < IPTUNNEL_ERR_TIMEO)
377 		t->err_count++;
378 	else
379 		t->err_count = 1;
380 	t->err_time = jiffies;
381 out:
382 	read_unlock(&ipgre_lock);
383 	return;
384 #else
385 	struct iphdr *iph = (struct iphdr*)dp;
386 	struct iphdr *eiph;
387 	__be16	     *p = (__be16*)(dp+(iph->ihl<<2));
388 	const int type = icmp_hdr(skb)->type;
389 	const int code = icmp_hdr(skb)->code;
390 	int rel_type = 0;
391 	int rel_code = 0;
392 	__be32 rel_info = 0;
393 	__u32 n = 0;
394 	__be16 flags;
395 	int grehlen = (iph->ihl<<2) + 4;
396 	struct sk_buff *skb2;
397 	struct flowi fl;
398 	struct rtable *rt;
399 
400 	if (p[1] != htons(ETH_P_IP))
401 		return;
402 
403 	flags = p[0];
404 	if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
405 		if (flags&(GRE_VERSION|GRE_ROUTING))
406 			return;
407 		if (flags&GRE_CSUM)
408 			grehlen += 4;
409 		if (flags&GRE_KEY)
410 			grehlen += 4;
411 		if (flags&GRE_SEQ)
412 			grehlen += 4;
413 	}
414 	if (len < grehlen + sizeof(struct iphdr))
415 		return;
416 	eiph = (struct iphdr*)(dp + grehlen);
417 
418 	switch (type) {
419 	default:
420 		return;
421 	case ICMP_PARAMETERPROB:
422 		n = ntohl(icmp_hdr(skb)->un.gateway) >> 24;
423 		if (n < (iph->ihl<<2))
424 			return;
425 
426 		/* So... This guy found something strange INSIDE encapsulated
427 		   packet. Well, he is fool, but what can we do ?
428 		 */
429 		rel_type = ICMP_PARAMETERPROB;
430 		n -= grehlen;
431 		rel_info = htonl(n << 24);
432 		break;
433 
434 	case ICMP_DEST_UNREACH:
435 		switch (code) {
436 		case ICMP_SR_FAILED:
437 		case ICMP_PORT_UNREACH:
438 			/* Impossible event. */
439 			return;
440 		case ICMP_FRAG_NEEDED:
441 			/* And it is the only really necessary thing :-) */
442 			n = ntohs(icmp_hdr(skb)->un.frag.mtu);
443 			if (n < grehlen+68)
444 				return;
445 			n -= grehlen;
446 			/* BSD 4.2 MORE DOES NOT EXIST IN NATURE. */
447 			if (n > ntohs(eiph->tot_len))
448 				return;
449 			rel_info = htonl(n);
450 			break;
451 		default:
452 			/* All others are translated to HOST_UNREACH.
453 			   rfc2003 contains "deep thoughts" about NET_UNREACH,
454 			   I believe, it is just ether pollution. --ANK
455 			 */
456 			rel_type = ICMP_DEST_UNREACH;
457 			rel_code = ICMP_HOST_UNREACH;
458 			break;
459 		}
460 		break;
461 	case ICMP_TIME_EXCEEDED:
462 		if (code != ICMP_EXC_TTL)
463 			return;
464 		break;
465 	}
466 
467 	/* Prepare fake skb to feed it to icmp_send */
468 	skb2 = skb_clone(skb, GFP_ATOMIC);
469 	if (skb2 == NULL)
470 		return;
471 	dst_release(skb2->dst);
472 	skb2->dst = NULL;
473 	skb_pull(skb2, skb->data - (u8*)eiph);
474 	skb_reset_network_header(skb2);
475 
476 	/* Try to guess incoming interface */
477 	memset(&fl, 0, sizeof(fl));
478 	fl.fl4_dst = eiph->saddr;
479 	fl.fl4_tos = RT_TOS(eiph->tos);
480 	fl.proto = IPPROTO_GRE;
481 	if (ip_route_output_key(&rt, &fl)) {
482 		kfree_skb(skb2);
483 		return;
484 	}
485 	skb2->dev = rt->u.dst.dev;
486 
487 	/* route "incoming" packet */
488 	if (rt->rt_flags&RTCF_LOCAL) {
489 		ip_rt_put(rt);
490 		rt = NULL;
491 		fl.fl4_dst = eiph->daddr;
492 		fl.fl4_src = eiph->saddr;
493 		fl.fl4_tos = eiph->tos;
494 		if (ip_route_output_key(&rt, &fl) ||
495 		    rt->u.dst.dev->type != ARPHRD_IPGRE) {
496 			ip_rt_put(rt);
497 			kfree_skb(skb2);
498 			return;
499 		}
500 	} else {
501 		ip_rt_put(rt);
502 		if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos, skb2->dev) ||
503 		    skb2->dst->dev->type != ARPHRD_IPGRE) {
504 			kfree_skb(skb2);
505 			return;
506 		}
507 	}
508 
509 	/* change mtu on this route */
510 	if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
511 		if (n > dst_mtu(skb2->dst)) {
512 			kfree_skb(skb2);
513 			return;
514 		}
515 		skb2->dst->ops->update_pmtu(skb2->dst, n);
516 	} else if (type == ICMP_TIME_EXCEEDED) {
517 		struct ip_tunnel *t = netdev_priv(skb2->dev);
518 		if (t->parms.iph.ttl) {
519 			rel_type = ICMP_DEST_UNREACH;
520 			rel_code = ICMP_HOST_UNREACH;
521 		}
522 	}
523 
524 	icmp_send(skb2, rel_type, rel_code, rel_info);
525 	kfree_skb(skb2);
526 #endif
527 }
528 
529 static inline void ipgre_ecn_decapsulate(struct iphdr *iph, struct sk_buff *skb)
530 {
531 	if (INET_ECN_is_ce(iph->tos)) {
532 		if (skb->protocol == htons(ETH_P_IP)) {
533 			IP_ECN_set_ce(ip_hdr(skb));
534 		} else if (skb->protocol == htons(ETH_P_IPV6)) {
535 			IP6_ECN_set_ce(ipv6_hdr(skb));
536 		}
537 	}
538 }
539 
540 static inline u8
541 ipgre_ecn_encapsulate(u8 tos, struct iphdr *old_iph, struct sk_buff *skb)
542 {
543 	u8 inner = 0;
544 	if (skb->protocol == htons(ETH_P_IP))
545 		inner = old_iph->tos;
546 	else if (skb->protocol == htons(ETH_P_IPV6))
547 		inner = ipv6_get_dsfield((struct ipv6hdr *)old_iph);
548 	return INET_ECN_encapsulate(tos, inner);
549 }
550 
551 static int ipgre_rcv(struct sk_buff *skb)
552 {
553 	struct iphdr *iph;
554 	u8     *h;
555 	__be16    flags;
556 	__sum16   csum = 0;
557 	__be32 key = 0;
558 	u32    seqno = 0;
559 	struct ip_tunnel *tunnel;
560 	int    offset = 4;
561 
562 	if (!pskb_may_pull(skb, 16))
563 		goto drop_nolock;
564 
565 	iph = ip_hdr(skb);
566 	h = skb->data;
567 	flags = *(__be16*)h;
568 
569 	if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {
570 		/* - Version must be 0.
571 		   - We do not support routing headers.
572 		 */
573 		if (flags&(GRE_VERSION|GRE_ROUTING))
574 			goto drop_nolock;
575 
576 		if (flags&GRE_CSUM) {
577 			switch (skb->ip_summed) {
578 			case CHECKSUM_COMPLETE:
579 				csum = csum_fold(skb->csum);
580 				if (!csum)
581 					break;
582 				/* fall through */
583 			case CHECKSUM_NONE:
584 				skb->csum = 0;
585 				csum = __skb_checksum_complete(skb);
586 				skb->ip_summed = CHECKSUM_COMPLETE;
587 			}
588 			offset += 4;
589 		}
590 		if (flags&GRE_KEY) {
591 			key = *(__be32*)(h + offset);
592 			offset += 4;
593 		}
594 		if (flags&GRE_SEQ) {
595 			seqno = ntohl(*(__be32*)(h + offset));
596 			offset += 4;
597 		}
598 	}
599 
600 	read_lock(&ipgre_lock);
601 	if ((tunnel = ipgre_tunnel_lookup(iph->saddr, iph->daddr, key)) != NULL) {
602 		secpath_reset(skb);
603 
604 		skb->protocol = *(__be16*)(h + 2);
605 		/* WCCP version 1 and 2 protocol decoding.
606 		 * - Change protocol to IP
607 		 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
608 		 */
609 		if (flags == 0 &&
610 		    skb->protocol == htons(ETH_P_WCCP)) {
611 			skb->protocol = htons(ETH_P_IP);
612 			if ((*(h + offset) & 0xF0) != 0x40)
613 				offset += 4;
614 		}
615 
616 		skb_reset_mac_header(skb);
617 		__pskb_pull(skb, offset);
618 		skb_reset_network_header(skb);
619 		skb_postpull_rcsum(skb, skb_transport_header(skb), offset);
620 		skb->pkt_type = PACKET_HOST;
621 #ifdef CONFIG_NET_IPGRE_BROADCAST
622 		if (MULTICAST(iph->daddr)) {
623 			/* Looped back packet, drop it! */
624 			if (((struct rtable*)skb->dst)->fl.iif == 0)
625 				goto drop;
626 			tunnel->stat.multicast++;
627 			skb->pkt_type = PACKET_BROADCAST;
628 		}
629 #endif
630 
631 		if (((flags&GRE_CSUM) && csum) ||
632 		    (!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {
633 			tunnel->stat.rx_crc_errors++;
634 			tunnel->stat.rx_errors++;
635 			goto drop;
636 		}
637 		if (tunnel->parms.i_flags&GRE_SEQ) {
638 			if (!(flags&GRE_SEQ) ||
639 			    (tunnel->i_seqno && (s32)(seqno - tunnel->i_seqno) < 0)) {
640 				tunnel->stat.rx_fifo_errors++;
641 				tunnel->stat.rx_errors++;
642 				goto drop;
643 			}
644 			tunnel->i_seqno = seqno + 1;
645 		}
646 		tunnel->stat.rx_packets++;
647 		tunnel->stat.rx_bytes += skb->len;
648 		skb->dev = tunnel->dev;
649 		dst_release(skb->dst);
650 		skb->dst = NULL;
651 		nf_reset(skb);
652 		ipgre_ecn_decapsulate(iph, skb);
653 		netif_rx(skb);
654 		read_unlock(&ipgre_lock);
655 		return(0);
656 	}
657 	icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
658 
659 drop:
660 	read_unlock(&ipgre_lock);
661 drop_nolock:
662 	kfree_skb(skb);
663 	return(0);
664 }
665 
666 static int ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
667 {
668 	struct ip_tunnel *tunnel = netdev_priv(dev);
669 	struct net_device_stats *stats = &tunnel->stat;
670 	struct iphdr  *old_iph = ip_hdr(skb);
671 	struct iphdr  *tiph;
672 	u8     tos;
673 	__be16 df;
674 	struct rtable *rt;     			/* Route to the other host */
675 	struct net_device *tdev;			/* Device to other host */
676 	struct iphdr  *iph;			/* Our new IP header */
677 	int    max_headroom;			/* The extra header space needed */
678 	int    gre_hlen;
679 	__be32 dst;
680 	int    mtu;
681 
682 	if (tunnel->recursion++) {
683 		tunnel->stat.collisions++;
684 		goto tx_error;
685 	}
686 
687 	if (dev->hard_header) {
688 		gre_hlen = 0;
689 		tiph = (struct iphdr*)skb->data;
690 	} else {
691 		gre_hlen = tunnel->hlen;
692 		tiph = &tunnel->parms.iph;
693 	}
694 
695 	if ((dst = tiph->daddr) == 0) {
696 		/* NBMA tunnel */
697 
698 		if (skb->dst == NULL) {
699 			tunnel->stat.tx_fifo_errors++;
700 			goto tx_error;
701 		}
702 
703 		if (skb->protocol == htons(ETH_P_IP)) {
704 			rt = (struct rtable*)skb->dst;
705 			if ((dst = rt->rt_gateway) == 0)
706 				goto tx_error_icmp;
707 		}
708 #ifdef CONFIG_IPV6
709 		else if (skb->protocol == htons(ETH_P_IPV6)) {
710 			struct in6_addr *addr6;
711 			int addr_type;
712 			struct neighbour *neigh = skb->dst->neighbour;
713 
714 			if (neigh == NULL)
715 				goto tx_error;
716 
717 			addr6 = (struct in6_addr*)&neigh->primary_key;
718 			addr_type = ipv6_addr_type(addr6);
719 
720 			if (addr_type == IPV6_ADDR_ANY) {
721 				addr6 = &ipv6_hdr(skb)->daddr;
722 				addr_type = ipv6_addr_type(addr6);
723 			}
724 
725 			if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
726 				goto tx_error_icmp;
727 
728 			dst = addr6->s6_addr32[3];
729 		}
730 #endif
731 		else
732 			goto tx_error;
733 	}
734 
735 	tos = tiph->tos;
736 	if (tos&1) {
737 		if (skb->protocol == htons(ETH_P_IP))
738 			tos = old_iph->tos;
739 		tos &= ~1;
740 	}
741 
742 	{
743 		struct flowi fl = { .oif = tunnel->parms.link,
744 				    .nl_u = { .ip4_u =
745 					      { .daddr = dst,
746 						.saddr = tiph->saddr,
747 						.tos = RT_TOS(tos) } },
748 				    .proto = IPPROTO_GRE };
749 		if (ip_route_output_key(&rt, &fl)) {
750 			tunnel->stat.tx_carrier_errors++;
751 			goto tx_error;
752 		}
753 	}
754 	tdev = rt->u.dst.dev;
755 
756 	if (tdev == dev) {
757 		ip_rt_put(rt);
758 		tunnel->stat.collisions++;
759 		goto tx_error;
760 	}
761 
762 	df = tiph->frag_off;
763 	if (df)
764 		mtu = dst_mtu(&rt->u.dst) - tunnel->hlen;
765 	else
766 		mtu = skb->dst ? dst_mtu(skb->dst) : dev->mtu;
767 
768 	if (skb->dst)
769 		skb->dst->ops->update_pmtu(skb->dst, mtu);
770 
771 	if (skb->protocol == htons(ETH_P_IP)) {
772 		df |= (old_iph->frag_off&htons(IP_DF));
773 
774 		if ((old_iph->frag_off&htons(IP_DF)) &&
775 		    mtu < ntohs(old_iph->tot_len)) {
776 			icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
777 			ip_rt_put(rt);
778 			goto tx_error;
779 		}
780 	}
781 #ifdef CONFIG_IPV6
782 	else if (skb->protocol == htons(ETH_P_IPV6)) {
783 		struct rt6_info *rt6 = (struct rt6_info*)skb->dst;
784 
785 		if (rt6 && mtu < dst_mtu(skb->dst) && mtu >= IPV6_MIN_MTU) {
786 			if ((tunnel->parms.iph.daddr && !MULTICAST(tunnel->parms.iph.daddr)) ||
787 			    rt6->rt6i_dst.plen == 128) {
788 				rt6->rt6i_flags |= RTF_MODIFIED;
789 				skb->dst->metrics[RTAX_MTU-1] = mtu;
790 			}
791 		}
792 
793 		if (mtu >= IPV6_MIN_MTU && mtu < skb->len - tunnel->hlen + gre_hlen) {
794 			icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, dev);
795 			ip_rt_put(rt);
796 			goto tx_error;
797 		}
798 	}
799 #endif
800 
801 	if (tunnel->err_count > 0) {
802 		if (jiffies - tunnel->err_time < IPTUNNEL_ERR_TIMEO) {
803 			tunnel->err_count--;
804 
805 			dst_link_failure(skb);
806 		} else
807 			tunnel->err_count = 0;
808 	}
809 
810 	max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen;
811 
812 	if (skb_headroom(skb) < max_headroom || skb_cloned(skb) || skb_shared(skb)) {
813 		struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
814 		if (!new_skb) {
815 			ip_rt_put(rt);
816 			stats->tx_dropped++;
817 			dev_kfree_skb(skb);
818 			tunnel->recursion--;
819 			return 0;
820 		}
821 		if (skb->sk)
822 			skb_set_owner_w(new_skb, skb->sk);
823 		dev_kfree_skb(skb);
824 		skb = new_skb;
825 		old_iph = ip_hdr(skb);
826 	}
827 
828 	skb->transport_header = skb->network_header;
829 	skb_push(skb, gre_hlen);
830 	skb_reset_network_header(skb);
831 	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
832 	IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
833 			      IPSKB_REROUTED);
834 	dst_release(skb->dst);
835 	skb->dst = &rt->u.dst;
836 
837 	/*
838 	 *	Push down and install the IPIP header.
839 	 */
840 
841 	iph 			=	ip_hdr(skb);
842 	iph->version		=	4;
843 	iph->ihl		=	sizeof(struct iphdr) >> 2;
844 	iph->frag_off		=	df;
845 	iph->protocol		=	IPPROTO_GRE;
846 	iph->tos		=	ipgre_ecn_encapsulate(tos, old_iph, skb);
847 	iph->daddr		=	rt->rt_dst;
848 	iph->saddr		=	rt->rt_src;
849 
850 	if ((iph->ttl = tiph->ttl) == 0) {
851 		if (skb->protocol == htons(ETH_P_IP))
852 			iph->ttl = old_iph->ttl;
853 #ifdef CONFIG_IPV6
854 		else if (skb->protocol == htons(ETH_P_IPV6))
855 			iph->ttl = ((struct ipv6hdr*)old_iph)->hop_limit;
856 #endif
857 		else
858 			iph->ttl = dst_metric(&rt->u.dst, RTAX_HOPLIMIT);
859 	}
860 
861 	((__be16*)(iph+1))[0] = tunnel->parms.o_flags;
862 	((__be16*)(iph+1))[1] = skb->protocol;
863 
864 	if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
865 		__be32 *ptr = (__be32*)(((u8*)iph) + tunnel->hlen - 4);
866 
867 		if (tunnel->parms.o_flags&GRE_SEQ) {
868 			++tunnel->o_seqno;
869 			*ptr = htonl(tunnel->o_seqno);
870 			ptr--;
871 		}
872 		if (tunnel->parms.o_flags&GRE_KEY) {
873 			*ptr = tunnel->parms.o_key;
874 			ptr--;
875 		}
876 		if (tunnel->parms.o_flags&GRE_CSUM) {
877 			*ptr = 0;
878 			*(__sum16*)ptr = ip_compute_csum((void*)(iph+1), skb->len - sizeof(struct iphdr));
879 		}
880 	}
881 
882 	nf_reset(skb);
883 
884 	IPTUNNEL_XMIT();
885 	tunnel->recursion--;
886 	return 0;
887 
888 tx_error_icmp:
889 	dst_link_failure(skb);
890 
891 tx_error:
892 	stats->tx_errors++;
893 	dev_kfree_skb(skb);
894 	tunnel->recursion--;
895 	return 0;
896 }
897 
898 static int
899 ipgre_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
900 {
901 	int err = 0;
902 	struct ip_tunnel_parm p;
903 	struct ip_tunnel *t;
904 
905 	switch (cmd) {
906 	case SIOCGETTUNNEL:
907 		t = NULL;
908 		if (dev == ipgre_fb_tunnel_dev) {
909 			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
910 				err = -EFAULT;
911 				break;
912 			}
913 			t = ipgre_tunnel_locate(&p, 0);
914 		}
915 		if (t == NULL)
916 			t = netdev_priv(dev);
917 		memcpy(&p, &t->parms, sizeof(p));
918 		if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
919 			err = -EFAULT;
920 		break;
921 
922 	case SIOCADDTUNNEL:
923 	case SIOCCHGTUNNEL:
924 		err = -EPERM;
925 		if (!capable(CAP_NET_ADMIN))
926 			goto done;
927 
928 		err = -EFAULT;
929 		if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
930 			goto done;
931 
932 		err = -EINVAL;
933 		if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
934 		    p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
935 		    ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
936 			goto done;
937 		if (p.iph.ttl)
938 			p.iph.frag_off |= htons(IP_DF);
939 
940 		if (!(p.i_flags&GRE_KEY))
941 			p.i_key = 0;
942 		if (!(p.o_flags&GRE_KEY))
943 			p.o_key = 0;
944 
945 		t = ipgre_tunnel_locate(&p, cmd == SIOCADDTUNNEL);
946 
947 		if (dev != ipgre_fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
948 			if (t != NULL) {
949 				if (t->dev != dev) {
950 					err = -EEXIST;
951 					break;
952 				}
953 			} else {
954 				unsigned nflags=0;
955 
956 				t = netdev_priv(dev);
957 
958 				if (MULTICAST(p.iph.daddr))
959 					nflags = IFF_BROADCAST;
960 				else if (p.iph.daddr)
961 					nflags = IFF_POINTOPOINT;
962 
963 				if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
964 					err = -EINVAL;
965 					break;
966 				}
967 				ipgre_tunnel_unlink(t);
968 				t->parms.iph.saddr = p.iph.saddr;
969 				t->parms.iph.daddr = p.iph.daddr;
970 				t->parms.i_key = p.i_key;
971 				t->parms.o_key = p.o_key;
972 				memcpy(dev->dev_addr, &p.iph.saddr, 4);
973 				memcpy(dev->broadcast, &p.iph.daddr, 4);
974 				ipgre_tunnel_link(t);
975 				netdev_state_change(dev);
976 			}
977 		}
978 
979 		if (t) {
980 			err = 0;
981 			if (cmd == SIOCCHGTUNNEL) {
982 				t->parms.iph.ttl = p.iph.ttl;
983 				t->parms.iph.tos = p.iph.tos;
984 				t->parms.iph.frag_off = p.iph.frag_off;
985 			}
986 			if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
987 				err = -EFAULT;
988 		} else
989 			err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
990 		break;
991 
992 	case SIOCDELTUNNEL:
993 		err = -EPERM;
994 		if (!capable(CAP_NET_ADMIN))
995 			goto done;
996 
997 		if (dev == ipgre_fb_tunnel_dev) {
998 			err = -EFAULT;
999 			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1000 				goto done;
1001 			err = -ENOENT;
1002 			if ((t = ipgre_tunnel_locate(&p, 0)) == NULL)
1003 				goto done;
1004 			err = -EPERM;
1005 			if (t == netdev_priv(ipgre_fb_tunnel_dev))
1006 				goto done;
1007 			dev = t->dev;
1008 		}
1009 		unregister_netdevice(dev);
1010 		err = 0;
1011 		break;
1012 
1013 	default:
1014 		err = -EINVAL;
1015 	}
1016 
1017 done:
1018 	return err;
1019 }
1020 
1021 static struct net_device_stats *ipgre_tunnel_get_stats(struct net_device *dev)
1022 {
1023 	return &(((struct ip_tunnel*)netdev_priv(dev))->stat);
1024 }
1025 
1026 static int ipgre_tunnel_change_mtu(struct net_device *dev, int new_mtu)
1027 {
1028 	struct ip_tunnel *tunnel = netdev_priv(dev);
1029 	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 
1065 static int ipgre_header(struct sk_buff *skb, struct net_device *dev, unsigned short type,
1066 			void *daddr, void *saddr, unsigned len)
1067 {
1068 	struct ip_tunnel *t = netdev_priv(dev);
1069 	struct iphdr *iph = (struct iphdr *)skb_push(skb, t->hlen);
1070 	__be16 *p = (__be16*)(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 
1093 static int ipgre_open(struct net_device *dev)
1094 {
1095 	struct ip_tunnel *t = netdev_priv(dev);
1096 
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);
1109 		if (__in_dev_get_rtnl(dev) == NULL)
1110 			return -EADDRNOTAVAIL;
1111 		t->mlink = dev->ifindex;
1112 		ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
1113 	}
1114 	return 0;
1115 }
1116 
1117 static int ipgre_close(struct net_device *dev)
1118 {
1119 	struct ip_tunnel *t = netdev_priv(dev);
1120 	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 
1132 static 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;
1144 	dev->mtu		= ETH_DATA_LEN - sizeof(struct iphdr) - 4;
1145 	dev->flags		= IFF_NOARP;
1146 	dev->iflink		= 0;
1147 	dev->addr_len		= 4;
1148 }
1149 
1150 static 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;
1156 	int mtu = ETH_DATA_LEN;
1157 	int addend = sizeof(struct iphdr) + 4;
1158 
1159 	tunnel = netdev_priv(dev);
1160 	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 
1221 static int __init ipgre_fb_tunnel_init(struct net_device *dev)
1222 {
1223 	struct ip_tunnel *tunnel = netdev_priv(dev);
1224 	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 
1240 static 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 
1250 static 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;
1272 out:
1273 	return err;
1274 err2:
1275 	free_netdev(ipgre_fb_tunnel_dev);
1276 err1:
1277 	inet_del_protocol(&ipgre_protocol, IPPROTO_GRE);
1278 	goto out;
1279 }
1280 
1281 static 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 
1295 static void __exit ipgre_fini(void)
1296 {
1297 	if (inet_del_protocol(&ipgre_protocol, IPPROTO_GRE) < 0)
1298 		printk(KERN_INFO "ipgre close: can't remove protocol\n");
1299 
1300 	rtnl_lock();
1301 	ipgre_destroy_tunnels();
1302 	rtnl_unlock();
1303 }
1304 
1305 module_init(ipgre_init);
1306 module_exit(ipgre_fini);
1307 MODULE_LICENSE("GPL");
1308