2 * Linux NET3: GRE over IP protocol decoder.
4 * Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
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.
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>
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>
35 #include <net/protocol.h>
38 #include <net/checksum.h>
39 #include <net/inet_ecn.h>
44 #include <net/ip6_fib.h>
45 #include <net/ip6_route.h>
52 1. The most important issue is detecting local dead loops.
53 They would cause complete host lockup in transmit, which
54 would be "resolved" by stack overflow or, if queueing is enabled,
55 with infinite looping in net_bh.
57 We cannot track such dead loops during route installation,
58 it is infeasible task. The most general solutions would be
59 to keep skb->encapsulation counter (sort of local ttl),
60 and silently drop packet when it expires. It is the best
61 solution, but it supposes maintaing new variable in ALL
62 skb, even if no tunneling is used.
64 Current solution: t->recursion lock breaks dead loops. It looks
65 like dev->tbusy flag, but I preferred new variable, because
66 the semantics is different. One day, when hard_start_xmit
67 will be multithreaded we will have to use skb->encapsulation.
71 2. Networking dead loops would not kill routers, but would really
72 kill network. IP hop limit plays role of "t->recursion" in this case,
73 if we copy it from packet being encapsulated to upper header.
74 It is very good solution, but it introduces two problems:
76 - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
77 do not work over tunnels.
78 - traceroute does not work. I planned to relay ICMP from tunnel,
79 so that this problem would be solved and traceroute output
80 would even more informative. This idea appeared to be wrong:
81 only Linux complies to rfc1812 now (yes, guys, Linux is the only
82 true router now :-)), all routers (at least, in neighbourhood of mine)
83 return only 8 bytes of payload. It is the end.
85 Hence, if we want that OSPF worked or traceroute said something reasonable,
86 we should search for another solution.
88 One of them is to parse packet trying to detect inner encapsulation
89 made by our node. It is difficult or even impossible, especially,
90 taking into account fragmentation. TO be short, tt is not solution at all.
92 Current solution: The solution was UNEXPECTEDLY SIMPLE.
93 We force DF flag on tunnels with preconfigured hop limit,
94 that is ALL. :-) Well, it does not remove the problem completely,
95 but exponential growth of network traffic is changed to linear
96 (branches, that exceed pmtu are pruned) and tunnel mtu
97 fastly degrades to value <68, where looping stops.
98 Yes, it is not good if there exists a router in the loop,
99 which does not force DF, even when encapsulating packets have DF set.
100 But it is not our problem! Nobody could accuse us, we made
101 all that we could make. Even if it is your gated who injected
102 fatal route to network, even if it were you who configured
103 fatal static route: you are innocent. :-)
107 3. Really, ipv4/ipip.c, ipv4/ip_gre.c and ipv6/sit.c contain
108 practically identical code. It would be good to glue them
109 together, but it is not very evident, how to make them modular.
110 sit is integral part of IPv6, ipip and gre are naturally modular.
111 We could extract common parts (hash table, ioctl etc)
112 to a separate module (ip_tunnel.c).
117 static int ipgre_tunnel_init(struct net_device *dev);
118 static void ipgre_tunnel_setup(struct net_device *dev);
120 /* Fallback tunnel: no source, no destination, no key, no options */
122 static int ipgre_fb_tunnel_init(struct net_device *dev);
124 static struct net_device *ipgre_fb_tunnel_dev;
126 /* Tunnel hash table */
136 We require exact key match i.e. if a key is present in packet
137 it will match only tunnel with the same key; if it is not present,
138 it will match only keyless tunnel.
140 All keysless packets, if not matched configured keyless tunnels
141 will match fallback tunnel.
145 #define HASH(addr) ((addr^(addr>>4))&0xF)
147 static struct ip_tunnel *tunnels[4][HASH_SIZE];
149 #define tunnels_r_l (tunnels[3])
150 #define tunnels_r (tunnels[2])
151 #define tunnels_l (tunnels[1])
152 #define tunnels_wc (tunnels[0])
154 static rwlock_t ipgre_lock = RW_LOCK_UNLOCKED;
156 /* Given src, dst and key, find appropriate for input tunnel. */
158 static struct ip_tunnel * ipgre_tunnel_lookup(u32 remote, u32 local, u32 key)
160 unsigned h0 = HASH(remote);
161 unsigned h1 = HASH(key);
164 for (t = tunnels_r_l[h0^h1]; t; t = t->next) {
165 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr) {
166 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
170 for (t = tunnels_r[h0^h1]; t; t = t->next) {
171 if (remote == t->parms.iph.daddr) {
172 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
176 for (t = tunnels_l[h1]; t; t = t->next) {
177 if (local == t->parms.iph.saddr ||
178 (local == t->parms.iph.daddr && MULTICAST(local))) {
179 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
183 for (t = tunnels_wc[h1]; t; t = t->next) {
184 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
188 if (ipgre_fb_tunnel_dev->flags&IFF_UP)
189 return ipgre_fb_tunnel_dev->priv;
193 static struct ip_tunnel **ipgre_bucket(struct ip_tunnel *t)
195 u32 remote = t->parms.iph.daddr;
196 u32 local = t->parms.iph.saddr;
197 u32 key = t->parms.i_key;
198 unsigned h = HASH(key);
203 if (remote && !MULTICAST(remote)) {
208 return &tunnels[prio][h];
211 static void ipgre_tunnel_link(struct ip_tunnel *t)
213 struct ip_tunnel **tp = ipgre_bucket(t);
216 write_lock_bh(&ipgre_lock);
218 write_unlock_bh(&ipgre_lock);
221 static void ipgre_tunnel_unlink(struct ip_tunnel *t)
223 struct ip_tunnel **tp;
225 for (tp = ipgre_bucket(t); *tp; tp = &(*tp)->next) {
227 write_lock_bh(&ipgre_lock);
229 write_unlock_bh(&ipgre_lock);
235 static struct ip_tunnel * ipgre_tunnel_locate(struct ip_tunnel_parm *parms, int create)
237 u32 remote = parms->iph.daddr;
238 u32 local = parms->iph.saddr;
239 u32 key = parms->i_key;
240 struct ip_tunnel *t, **tp, *nt;
241 struct net_device *dev;
242 unsigned h = HASH(key);
248 if (remote && !MULTICAST(remote)) {
252 for (tp = &tunnels[prio][h]; (t = *tp) != NULL; tp = &t->next) {
253 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr) {
254 if (key == t->parms.i_key)
262 strlcpy(name, parms->name, IFNAMSIZ);
265 for (i=1; i<100; i++) {
266 sprintf(name, "gre%d", i);
267 if (__dev_get_by_name(name) == NULL)
274 dev = alloc_netdev(sizeof(*t), name, ipgre_tunnel_setup);
278 dev->init = ipgre_tunnel_init;
282 if (register_netdevice(dev) < 0) {
291 ipgre_tunnel_link(nt);
292 /* Do not decrement MOD_USE_COUNT here. */
299 static void ipgre_tunnel_uninit(struct net_device *dev)
301 ipgre_tunnel_unlink((struct ip_tunnel*)dev->priv);
306 void ipgre_err(struct sk_buff *skb, u32 info)
308 #ifndef I_WISH_WORLD_WERE_PERFECT
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.
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".
318 Well, I wonder, rfc1812 was written by Cisco employee,
319 what the hell these idiots break standrads established
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;
332 if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
333 if (flags&(GRE_VERSION|GRE_ROUTING))
342 /* If only 8 bytes returned, keyed message will be dropped here */
343 if (skb_headlen(skb) < grehlen)
348 case ICMP_PARAMETERPROB:
351 case ICMP_DEST_UNREACH:
354 case ICMP_PORT_UNREACH:
355 /* Impossible event. */
357 case ICMP_FRAG_NEEDED:
358 /* Soft state for pmtu is maintained by IP core. */
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
368 case ICMP_TIME_EXCEEDED:
369 if (code != ICMP_EXC_TTL)
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))
379 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
382 if (jiffies - t->err_time < IPTUNNEL_ERR_TIMEO)
386 t->err_time = jiffies;
388 read_unlock(&ipgre_lock);
391 struct iphdr *iph = (struct iphdr*)dp;
393 u16 *p = (u16*)(dp+(iph->ihl<<2));
394 int type = skb->h.icmph->type;
395 int code = skb->h.icmph->code;
400 int grehlen = (iph->ihl<<2) + 4;
401 struct sk_buff *skb2;
405 if (p[1] != htons(ETH_P_IP))
409 if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
410 if (flags&(GRE_VERSION|GRE_ROUTING))
419 if (len < grehlen + sizeof(struct iphdr))
421 eiph = (struct iphdr*)(dp + grehlen);
426 case ICMP_PARAMETERPROB:
427 if (skb->h.icmph->un.gateway < (iph->ihl<<2))
430 /* So... This guy found something strange INSIDE encapsulated
431 packet. Well, he is fool, but what can we do ?
433 rel_type = ICMP_PARAMETERPROB;
434 rel_info = skb->h.icmph->un.gateway - grehlen;
437 case ICMP_DEST_UNREACH:
440 case ICMP_PORT_UNREACH:
441 /* Impossible event. */
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)
449 /* BSD 4.2 MORE DOES NOT EXIST IN NATURE. */
450 if (rel_info > ntohs(eiph->tot_len))
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
458 rel_type = ICMP_DEST_UNREACH;
459 rel_code = ICMP_HOST_UNREACH;
463 case ICMP_TIME_EXCEEDED:
464 if (code != ICMP_EXC_TTL)
469 /* Prepare fake skb to feed it to icmp_send */
470 skb2 = skb_clone(skb, GFP_ATOMIC);
473 dst_release(skb2->dst);
475 skb_pull(skb2, skb->data - (u8*)eiph);
476 skb2->nh.raw = skb2->data;
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)) {
487 skb2->dev = rt->u.dst.dev;
489 /* route "incoming" packet */
490 if (rt->rt_flags&RTCF_LOCAL) {
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) {
504 if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos, skb2->dev) ||
505 skb2->dst->dev->type != ARPHRD_IPGRE) {
511 /* change mtu on this route */
512 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
513 if (rel_info > dst_pmtu(skb2->dst)) {
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;
527 icmp_send(skb2, rel_type, rel_code, rel_info);
532 static inline void ipgre_ecn_decapsulate(struct iphdr *iph, struct sk_buff *skb)
534 if (INET_ECN_is_ce(iph->tos)) {
535 if (skb->protocol == htons(ETH_P_IP)) {
536 if (INET_ECN_is_not_ce(skb->nh.iph->tos))
537 IP_ECN_set_ce(skb->nh.iph);
538 } else if (skb->protocol == htons(ETH_P_IPV6)) {
539 if (INET_ECN_is_not_ce(ip6_get_dsfield(skb->nh.ipv6h)))
540 IP6_ECN_set_ce(skb->nh.ipv6h);
546 ipgre_ecn_encapsulate(u8 tos, struct iphdr *old_iph, struct sk_buff *skb)
549 if (skb->protocol == htons(ETH_P_IP))
550 inner = old_iph->tos;
551 else if (skb->protocol == htons(ETH_P_IPV6))
552 inner = ip6_get_dsfield((struct ipv6hdr*)old_iph);
553 return INET_ECN_encapsulate(tos, inner);
556 int ipgre_rcv(struct sk_buff *skb)
564 struct ip_tunnel *tunnel;
567 if (!pskb_may_pull(skb, 16))
574 if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {
575 /* - Version must be 0.
576 - We do not support routing headers.
578 if (flags&(GRE_VERSION|GRE_ROUTING))
581 if (flags&GRE_CSUM) {
582 if (skb->ip_summed == CHECKSUM_HW) {
583 csum = (u16)csum_fold(skb->csum);
585 skb->ip_summed = CHECKSUM_NONE;
587 if (skb->ip_summed == CHECKSUM_NONE) {
588 skb->csum = skb_checksum(skb, 0, skb->len, 0);
589 skb->ip_summed = CHECKSUM_HW;
590 csum = (u16)csum_fold(skb->csum);
595 key = *(u32*)(h + offset);
599 seqno = ntohl(*(u32*)(h + offset));
604 read_lock(&ipgre_lock);
605 if ((tunnel = ipgre_tunnel_lookup(iph->saddr, iph->daddr, key)) != NULL) {
608 skb->mac.raw = skb->nh.raw;
609 skb->nh.raw = __pskb_pull(skb, offset);
610 memset(&(IPCB(skb)->opt), 0, sizeof(struct ip_options));
611 if (skb->ip_summed == CHECKSUM_HW)
612 skb->csum = csum_sub(skb->csum,
613 csum_partial(skb->mac.raw, skb->nh.raw-skb->mac.raw, 0));
614 skb->protocol = *(u16*)(h + 2);
615 skb->pkt_type = PACKET_HOST;
616 #ifdef CONFIG_NET_IPGRE_BROADCAST
617 if (MULTICAST(iph->daddr)) {
618 /* Looped back packet, drop it! */
619 if (((struct rtable*)skb->dst)->fl.iif == 0)
621 tunnel->stat.multicast++;
622 skb->pkt_type = PACKET_BROADCAST;
626 if (((flags&GRE_CSUM) && csum) ||
627 (!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {
628 tunnel->stat.rx_crc_errors++;
629 tunnel->stat.rx_errors++;
632 if (tunnel->parms.i_flags&GRE_SEQ) {
633 if (!(flags&GRE_SEQ) ||
634 (tunnel->i_seqno && (s32)(seqno - tunnel->i_seqno) < 0)) {
635 tunnel->stat.rx_fifo_errors++;
636 tunnel->stat.rx_errors++;
639 tunnel->i_seqno = seqno + 1;
641 tunnel->stat.rx_packets++;
642 tunnel->stat.rx_bytes += skb->len;
643 skb->dev = tunnel->dev;
644 dst_release(skb->dst);
646 #ifdef CONFIG_NETFILTER
647 nf_conntrack_put(skb->nfct);
649 #ifdef CONFIG_NETFILTER_DEBUG
653 ipgre_ecn_decapsulate(iph, skb);
655 read_unlock(&ipgre_lock);
658 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, 0);
661 read_unlock(&ipgre_lock);
667 static int ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
669 struct ip_tunnel *tunnel = (struct ip_tunnel*)dev->priv;
670 struct net_device_stats *stats = &tunnel->stat;
671 struct iphdr *old_iph = skb->nh.iph;
675 struct rtable *rt; /* Route to the other host */
676 struct net_device *tdev; /* Device to other host */
677 struct iphdr *iph; /* Our new IP header */
678 int max_headroom; /* The extra header space needed */
683 if (tunnel->recursion++) {
684 tunnel->stat.collisions++;
688 if (dev->hard_header) {
690 tiph = (struct iphdr*)skb->data;
692 gre_hlen = tunnel->hlen;
693 tiph = &tunnel->parms.iph;
696 if ((dst = tiph->daddr) == 0) {
699 if (skb->dst == NULL) {
700 tunnel->stat.tx_fifo_errors++;
704 if (skb->protocol == htons(ETH_P_IP)) {
705 rt = (struct rtable*)skb->dst;
706 if ((dst = rt->rt_gateway) == 0)
710 else if (skb->protocol == htons(ETH_P_IPV6)) {
711 struct in6_addr *addr6;
713 struct neighbour *neigh = skb->dst->neighbour;
718 addr6 = (struct in6_addr*)&neigh->primary_key;
719 addr_type = ipv6_addr_type(addr6);
721 if (addr_type == IPV6_ADDR_ANY) {
722 addr6 = &skb->nh.ipv6h->daddr;
723 addr_type = ipv6_addr_type(addr6);
726 if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
729 dst = addr6->s6_addr32[3];
738 if (skb->protocol == htons(ETH_P_IP))
744 struct flowi fl = { .oif = tunnel->parms.link,
747 .saddr = tiph->saddr,
748 .tos = RT_TOS(tos) } },
749 .proto = IPPROTO_GRE };
750 if (ip_route_output_key(&rt, &fl)) {
751 tunnel->stat.tx_carrier_errors++;
755 tdev = rt->u.dst.dev;
759 tunnel->stat.collisions++;
765 mtu = dst_pmtu(&rt->u.dst) - tunnel->hlen;
767 mtu = skb->dst ? dst_pmtu(skb->dst) : dev->mtu;
770 skb->dst->ops->update_pmtu(skb->dst, mtu);
772 if (skb->protocol == htons(ETH_P_IP)) {
773 df |= (old_iph->frag_off&htons(IP_DF));
775 if ((old_iph->frag_off&htons(IP_DF)) &&
776 mtu < ntohs(old_iph->tot_len)) {
777 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
783 else if (skb->protocol == htons(ETH_P_IPV6)) {
784 struct rt6_info *rt6 = (struct rt6_info*)skb->dst;
786 if (rt6 && mtu < dst_pmtu(skb->dst) && mtu >= IPV6_MIN_MTU) {
787 if ((tunnel->parms.iph.daddr && !MULTICAST(tunnel->parms.iph.daddr)) ||
788 rt6->rt6i_dst.plen == 128) {
789 rt6->rt6i_flags |= RTF_MODIFIED;
790 skb->dst->metrics[RTAX_MTU-1] = mtu;
794 if (mtu >= IPV6_MIN_MTU && mtu < skb->len - tunnel->hlen + gre_hlen) {
795 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, dev);
802 if (tunnel->err_count > 0) {
803 if (jiffies - tunnel->err_time < IPTUNNEL_ERR_TIMEO) {
806 dst_link_failure(skb);
808 tunnel->err_count = 0;
811 max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen;
813 if (skb_headroom(skb) < max_headroom || skb_cloned(skb) || skb_shared(skb)) {
814 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
823 skb_set_owner_w(new_skb, skb->sk);
826 old_iph = skb->nh.iph;
829 skb->h.raw = skb->nh.raw;
830 skb->nh.raw = skb_push(skb, gre_hlen);
831 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
832 dst_release(skb->dst);
833 skb->dst = &rt->u.dst;
836 * Push down and install the IPIP header.
841 iph->ihl = sizeof(struct iphdr) >> 2;
843 iph->protocol = IPPROTO_GRE;
844 iph->tos = ipgre_ecn_encapsulate(tos, old_iph, skb);
845 iph->daddr = rt->rt_dst;
846 iph->saddr = rt->rt_src;
848 if ((iph->ttl = tiph->ttl) == 0) {
849 if (skb->protocol == htons(ETH_P_IP))
850 iph->ttl = old_iph->ttl;
852 else if (skb->protocol == htons(ETH_P_IPV6))
853 iph->ttl = ((struct ipv6hdr*)old_iph)->hop_limit;
856 iph->ttl = dst_metric(&rt->u.dst, RTAX_HOPLIMIT);
859 ((u16*)(iph+1))[0] = tunnel->parms.o_flags;
860 ((u16*)(iph+1))[1] = skb->protocol;
862 if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
863 u32 *ptr = (u32*)(((u8*)iph) + tunnel->hlen - 4);
865 if (tunnel->parms.o_flags&GRE_SEQ) {
867 *ptr = htonl(tunnel->o_seqno);
870 if (tunnel->parms.o_flags&GRE_KEY) {
871 *ptr = tunnel->parms.o_key;
874 if (tunnel->parms.o_flags&GRE_CSUM) {
876 *(__u16*)ptr = ip_compute_csum((void*)(iph+1), skb->len - sizeof(struct iphdr));
880 #ifdef CONFIG_NETFILTER
881 nf_conntrack_put(skb->nfct);
883 #ifdef CONFIG_NETFILTER_DEBUG
893 dst_link_failure(skb);
903 ipgre_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
906 struct ip_tunnel_parm p;
912 if (dev == ipgre_fb_tunnel_dev) {
913 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
917 t = ipgre_tunnel_locate(&p, 0);
920 t = (struct ip_tunnel*)dev->priv;
921 memcpy(&p, &t->parms, sizeof(p));
922 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
929 if (!capable(CAP_NET_ADMIN))
933 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
937 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
938 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
939 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
942 p.iph.frag_off |= htons(IP_DF);
944 if (!(p.i_flags&GRE_KEY))
946 if (!(p.o_flags&GRE_KEY))
949 t = ipgre_tunnel_locate(&p, cmd == SIOCADDTUNNEL);
951 if (dev != ipgre_fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
960 t = (struct ip_tunnel*)dev->priv;
962 if (MULTICAST(p.iph.daddr))
963 nflags = IFF_BROADCAST;
964 else if (p.iph.daddr)
965 nflags = IFF_POINTOPOINT;
967 if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
971 ipgre_tunnel_unlink(t);
972 t->parms.iph.saddr = p.iph.saddr;
973 t->parms.iph.daddr = p.iph.daddr;
974 t->parms.i_key = p.i_key;
975 t->parms.o_key = p.o_key;
976 memcpy(dev->dev_addr, &p.iph.saddr, 4);
977 memcpy(dev->broadcast, &p.iph.daddr, 4);
978 ipgre_tunnel_link(t);
979 netdev_state_change(dev);
985 if (cmd == SIOCCHGTUNNEL) {
986 t->parms.iph.ttl = p.iph.ttl;
987 t->parms.iph.tos = p.iph.tos;
988 t->parms.iph.frag_off = p.iph.frag_off;
990 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
993 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
998 if (!capable(CAP_NET_ADMIN))
1001 if (dev == ipgre_fb_tunnel_dev) {
1003 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1006 if ((t = ipgre_tunnel_locate(&p, 0)) == NULL)
1009 if (t == ipgre_fb_tunnel_dev->priv)
1013 err = unregister_netdevice(dev);
1024 static struct net_device_stats *ipgre_tunnel_get_stats(struct net_device *dev)
1026 return &(((struct ip_tunnel*)dev->priv)->stat);
1029 static int ipgre_tunnel_change_mtu(struct net_device *dev, int new_mtu)
1031 struct ip_tunnel *tunnel = (struct ip_tunnel*)dev->priv;
1032 if (new_mtu < 68 || new_mtu > 0xFFF8 - tunnel->hlen)
1038 #ifdef CONFIG_NET_IPGRE_BROADCAST
1039 /* Nice toy. Unfortunately, useless in real life :-)
1040 It allows to construct virtual multiprotocol broadcast "LAN"
1041 over the Internet, provided multicast routing is tuned.
1044 I have no idea was this bicycle invented before me,
1045 so that I had to set ARPHRD_IPGRE to a random value.
1046 I have an impression, that Cisco could make something similar,
1047 but this feature is apparently missing in IOS<=11.2(8).
1049 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
1050 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
1052 ping -t 255 224.66.66.66
1054 If nobody answers, mbone does not work.
1056 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
1057 ip addr add 10.66.66.<somewhat>/24 dev Universe
1058 ifconfig Universe up
1059 ifconfig Universe add fe80::<Your_real_addr>/10
1060 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
1063 ftp fec0:6666:6666::193.233.7.65
1068 static int ipgre_header(struct sk_buff *skb, struct net_device *dev, unsigned short type,
1069 void *daddr, void *saddr, unsigned len)
1071 struct ip_tunnel *t = (struct ip_tunnel*)dev->priv;
1072 struct iphdr *iph = (struct iphdr *)skb_push(skb, t->hlen);
1073 u16 *p = (u16*)(iph+1);
1075 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
1076 p[0] = t->parms.o_flags;
1080 * Set the source hardware address.
1084 memcpy(&iph->saddr, saddr, 4);
1087 memcpy(&iph->daddr, daddr, 4);
1090 if (iph->daddr && !MULTICAST(iph->daddr))
1096 static int ipgre_open(struct net_device *dev)
1098 struct ip_tunnel *t = (struct ip_tunnel*)dev->priv;
1100 if (MULTICAST(t->parms.iph.daddr)) {
1101 struct flowi fl = { .oif = t->parms.link,
1103 { .daddr = t->parms.iph.daddr,
1104 .saddr = t->parms.iph.saddr,
1105 .tos = RT_TOS(t->parms.iph.tos) } },
1106 .proto = IPPROTO_GRE };
1108 if (ip_route_output_key(&rt, &fl))
1109 return -EADDRNOTAVAIL;
1110 dev = rt->u.dst.dev;
1112 if (__in_dev_get(dev) == NULL)
1113 return -EADDRNOTAVAIL;
1114 t->mlink = dev->ifindex;
1115 ip_mc_inc_group(__in_dev_get(dev), t->parms.iph.daddr);
1120 static int ipgre_close(struct net_device *dev)
1122 struct ip_tunnel *t = (struct ip_tunnel*)dev->priv;
1123 if (MULTICAST(t->parms.iph.daddr) && t->mlink) {
1124 struct in_device *in_dev = inetdev_by_index(t->mlink);
1126 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
1135 static void ipgre_tunnel_setup(struct net_device *dev)
1137 SET_MODULE_OWNER(dev);
1138 dev->uninit = ipgre_tunnel_uninit;
1139 dev->destructor = free_netdev;
1140 dev->hard_start_xmit = ipgre_tunnel_xmit;
1141 dev->get_stats = ipgre_tunnel_get_stats;
1142 dev->do_ioctl = ipgre_tunnel_ioctl;
1143 dev->change_mtu = ipgre_tunnel_change_mtu;
1145 dev->type = ARPHRD_IPGRE;
1146 dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
1147 dev->mtu = 1500 - sizeof(struct iphdr) - 4;
1148 dev->flags = IFF_NOARP;
1153 static int ipgre_tunnel_init(struct net_device *dev)
1155 struct net_device *tdev = NULL;
1156 struct ip_tunnel *tunnel;
1158 int hlen = LL_MAX_HEADER;
1160 int addend = sizeof(struct iphdr) + 4;
1162 tunnel = (struct ip_tunnel*)dev->priv;
1163 iph = &tunnel->parms.iph;
1166 strcpy(tunnel->parms.name, dev->name);
1168 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1169 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1171 /* Guess output device to choose reasonable mtu and hard_header_len */
1174 struct flowi fl = { .oif = tunnel->parms.link,
1176 { .daddr = iph->daddr,
1177 .saddr = iph->saddr,
1178 .tos = RT_TOS(iph->tos) } },
1179 .proto = IPPROTO_GRE };
1181 if (!ip_route_output_key(&rt, &fl)) {
1182 tdev = rt->u.dst.dev;
1186 dev->flags |= IFF_POINTOPOINT;
1188 #ifdef CONFIG_NET_IPGRE_BROADCAST
1189 if (MULTICAST(iph->daddr)) {
1192 dev->flags = IFF_BROADCAST;
1193 dev->hard_header = ipgre_header;
1194 dev->open = ipgre_open;
1195 dev->stop = ipgre_close;
1200 if (!tdev && tunnel->parms.link)
1201 tdev = __dev_get_by_index(tunnel->parms.link);
1204 hlen = tdev->hard_header_len;
1207 dev->iflink = tunnel->parms.link;
1209 /* Precalculate GRE options length */
1210 if (tunnel->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {
1211 if (tunnel->parms.o_flags&GRE_CSUM)
1213 if (tunnel->parms.o_flags&GRE_KEY)
1215 if (tunnel->parms.o_flags&GRE_SEQ)
1218 dev->hard_header_len = hlen + addend;
1219 dev->mtu = mtu - addend;
1220 tunnel->hlen = addend;
1224 int __init ipgre_fb_tunnel_init(struct net_device *dev)
1226 struct ip_tunnel *tunnel = (struct ip_tunnel*)dev->priv;
1227 struct iphdr *iph = &tunnel->parms.iph;
1230 strcpy(tunnel->parms.name, dev->name);
1233 iph->protocol = IPPROTO_GRE;
1235 tunnel->hlen = sizeof(struct iphdr) + 4;
1238 tunnels_wc[0] = tunnel;
1243 static struct inet_protocol ipgre_protocol = {
1244 .handler = ipgre_rcv,
1245 .err_handler = ipgre_err,
1250 * And now the modules code and kernel interface.
1253 static int __init ipgre_init(void)
1257 printk(KERN_INFO "GRE over IPv4 tunneling driver\n");
1259 if (inet_add_protocol(&ipgre_protocol, IPPROTO_GRE) < 0) {
1260 printk(KERN_INFO "ipgre init: can't add protocol\n");
1264 ipgre_fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "gre0",
1265 ipgre_tunnel_setup);
1266 if (!ipgre_fb_tunnel_dev) {
1271 ipgre_fb_tunnel_dev->init = ipgre_fb_tunnel_init;
1273 if ((err = register_netdev(ipgre_fb_tunnel_dev)))
1278 inet_del_protocol(&ipgre_protocol, IPPROTO_GRE);
1279 free_netdev(ipgre_fb_tunnel_dev);
1283 void ipgre_fini(void)
1285 if (inet_del_protocol(&ipgre_protocol, IPPROTO_GRE) < 0)
1286 printk(KERN_INFO "ipgre close: can't remove protocol\n");
1288 unregister_netdev(ipgre_fb_tunnel_dev);
1291 module_init(ipgre_init);
1292 module_exit(ipgre_fini);
1293 MODULE_LICENSE("GPL");