net/ipv4/ip_gre.c

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