SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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/config.h>
  14 #include <linux/module.h>
  15 #include <linux/types.h>
  16 #include <linux/sched.h>
  17 #include <linux/kernel.h>
  18 #include <asm/uaccess.h>
  19 #include <linux/skbuff.h>
  20 #include <linux/netdevice.h>
  21 #include <linux/in.h>
  22 #include <linux/tcp.h>
  23 #include <linux/udp.h>
  24 #include <linux/if_arp.h>
  25 #include <linux/mroute.h>
  26 #include <linux/init.h>
  27 #include <linux/in6.h>
  28 #include <linux/inetdevice.h>
  29 #include <linux/igmp.h>
  30 #include <linux/netfilter_ipv4.h>
  31 #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) ((addr^(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(u32 remote, u32 local, u32 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 ipgre_fb_tunnel_dev->priv;
 192         return NULL;
 193 }
 194
 195 static struct ip_tunnel **ipgre_bucket(struct ip_tunnel *t)
 196 {
 197         u32 remote = t->parms.iph.daddr;
 198         u32 local = t->parms.iph.saddr;
 199         u32 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         u32 remote = parms->iph.daddr;
 240         u32 local = parms->iph.saddr;
 241         u32 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 = dev->priv;
 282         nt->parms = *parms;
 283
 284         if (register_netdevice(dev) < 0) {
 285                 free_netdev(dev);
 286                 goto failed;
 287         }
 288
 289         nt = dev->priv;
 290         nt->parms = *parms;
 291
 292         dev_hold(dev);
 293         ipgre_tunnel_link(nt);
 294         return nt;
 295
 296 failed:
 297         return NULL;
 298 }
 299
 300 static void ipgre_tunnel_uninit(struct net_device *dev)
 301 {
 302         ipgre_tunnel_unlink((struct ip_tunnel*)dev->priv);
 303         dev_put(dev);
 304 }
 305
 306
 307 static void ipgre_err(struct sk_buff *skb, u32 info)
 308 {
 309 #ifndef I_WISH_WORLD_WERE_PERFECT
 310
 311 /* It is not :-( All the routers (except for Linux) return only
 312    8 bytes of packet payload. It means, that precise relaying of
 313    ICMP in the real Internet is absolutely infeasible.
 314
 315    Moreover, Cisco "wise men" put GRE key to the third word
 316    in GRE header. It makes impossible maintaining even soft state for keyed
 317    GRE tunnels with enabled checksum. Tell them "thank you".
 318
 319    Well, I wonder, rfc1812 was written by Cisco employee,
 320    what the hell these idiots break standrads established
 321    by themself???
 322  */
 323
 324         struct iphdr *iph = (struct iphdr*)skb->data;
 325         u16          *p = (u16*)(skb->data+(iph->ihl<<2));
 326         int grehlen = (iph->ihl<<2) + 4;
 327         int type = skb->h.icmph->type;
 328         int code = skb->h.icmph->code;
 329         struct ip_tunnel *t;
 330         u16 flags;
 331
 332         flags = p[0];
 333         if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
 334                 if (flags&(GRE_VERSION|GRE_ROUTING))
 335                         return;
 336                 if (flags&GRE_KEY) {
 337                         grehlen += 4;
 338                         if (flags&GRE_CSUM)
 339                                 grehlen += 4;
 340                 }
 341         }
 342
 343         /* If only 8 bytes returned, keyed message will be dropped here */
 344         if (skb_headlen(skb) < grehlen)
 345                 return;
 346
 347         switch (type) {
 348         default:
 349         case ICMP_PARAMETERPROB:
 350                 return;
 351
 352         case ICMP_DEST_UNREACH:
 353                 switch (code) {
 354                 case ICMP_SR_FAILED:
 355                 case ICMP_PORT_UNREACH:
 356                         /* Impossible event. */
 357                         return;
 358                 case ICMP_FRAG_NEEDED:
 359                         /* Soft state for pmtu is maintained by IP core. */
 360                         return;
 361                 default:
 362                         /* All others are translated to HOST_UNREACH.
 363                            rfc2003 contains "deep thoughts" about NET_UNREACH,
 364                            I believe they are just ether pollution. --ANK
 365                          */
 366                         break;
 367                 }
 368                 break;
 369         case ICMP_TIME_EXCEEDED:
 370                 if (code != ICMP_EXC_TTL)
 371                         return;
 372                 break;
 373         }
 374
 375         read_lock(&ipgre_lock);
 376         t = ipgre_tunnel_lookup(iph->daddr, iph->saddr, (flags&GRE_KEY) ? *(((u32*)p) + (grehlen>>2) - 1) : 0);
 377         if (t == NULL || t->parms.iph.daddr == 0 || MULTICAST(t->parms.iph.daddr))
 378                 goto out;
 379
 380         if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
 381                 goto out;
 382
 383         if (jiffies - t->err_time < IPTUNNEL_ERR_TIMEO)
 384                 t->err_count++;
 385         else
 386                 t->err_count = 1;
 387         t->err_time = jiffies;
 388 out:
 389         read_unlock(&ipgre_lock);
 390         return;
 391 #else
 392         struct iphdr *iph = (struct iphdr*)dp;
 393         struct iphdr *eiph;
 394         u16          *p = (u16*)(dp+(iph->ihl<<2));
 395         int type = skb->h.icmph->type;
 396         int code = skb->h.icmph->code;
 397         int rel_type = 0;
 398         int rel_code = 0;
 399         int rel_info = 0;
 400         u16 flags;
 401         int grehlen = (iph->ihl<<2) + 4;
 402         struct sk_buff *skb2;
 403         struct flowi fl;
 404         struct rtable *rt;
 405
 406         if (p[1] != htons(ETH_P_IP))
 407                 return;
 408
 409         flags = p[0];
 410         if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
 411                 if (flags&(GRE_VERSION|GRE_ROUTING))
 412                         return;
 413                 if (flags&GRE_CSUM)
 414                         grehlen += 4;
 415                 if (flags&GRE_KEY)
 416                         grehlen += 4;
 417                 if (flags&GRE_SEQ)
 418                         grehlen += 4;
 419         }
 420         if (len < grehlen + sizeof(struct iphdr))
 421                 return;
 422         eiph = (struct iphdr*)(dp + grehlen);
 423
 424         switch (type) {
 425         default:
 426                 return;
 427         case ICMP_PARAMETERPROB:
 428                 if (skb->h.icmph->un.gateway < (iph->ihl<<2))
 429                         return;
 430
 431                 /* So... This guy found something strange INSIDE encapsulated
 432                    packet. Well, he is fool, but what can we do ?
 433                  */
 434                 rel_type = ICMP_PARAMETERPROB;
 435                 rel_info = skb->h.icmph->un.gateway - grehlen;
 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                         rel_info = ntohs(skb->h.icmph->un.frag.mtu);
 447                         if (rel_info < grehlen+68)
 448                                 return;
 449                         rel_info -= grehlen;
 450                         /* BSD 4.2 MORE DOES NOT EXIST IN NATURE. */
 451                         if (rel_info > ntohs(eiph->tot_len))
 452                                 return;
 453                         break;
 454                 default:
 455                         /* All others are translated to HOST_UNREACH.
 456                            rfc2003 contains "deep thoughts" about NET_UNREACH,
 457                            I believe, it is just ether pollution. --ANK
 458                          */
 459                         rel_type = ICMP_DEST_UNREACH;
 460                         rel_code = ICMP_HOST_UNREACH;
 461                         break;
 462                 }
 463                 break;
 464         case ICMP_TIME_EXCEEDED:
 465                 if (code != ICMP_EXC_TTL)
 466                         return;
 467                 break;
 468         }
 469
 470         /* Prepare fake skb to feed it to icmp_send */
 471         skb2 = skb_clone(skb, GFP_ATOMIC);
 472         if (skb2 == NULL)
 473                 return;
 474         dst_release(skb2->dst);
 475         skb2->dst = NULL;
 476         skb_pull(skb2, skb->data - (u8*)eiph);
 477         skb2->nh.raw = skb2->data;
 478
 479         /* Try to guess incoming interface */
 480         memset(&fl, 0, sizeof(fl));
 481         fl.fl4_dst = eiph->saddr;
 482         fl.fl4_tos = RT_TOS(eiph->tos);
 483         fl.proto = IPPROTO_GRE;
 484         if (ip_route_output_key(&rt, &fl)) {
 485                 kfree_skb(skb2);
 486                 return;
 487         }
 488         skb2->dev = rt->u.dst.dev;
 489
 490         /* route "incoming" packet */
 491         if (rt->rt_flags&RTCF_LOCAL) {
 492                 ip_rt_put(rt);
 493                 rt = NULL;
 494                 fl.fl4_dst = eiph->daddr;
 495                 fl.fl4_src = eiph->saddr;
 496                 fl.fl4_tos = eiph->tos;
 497                 if (ip_route_output_key(&rt, &fl) ||
 498                     rt->u.dst.dev->type != ARPHRD_IPGRE) {
 499                         ip_rt_put(rt);
 500                         kfree_skb(skb2);
 501                         return;
 502                 }
 503         } else {
 504                 ip_rt_put(rt);
 505                 if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos, skb2->dev) ||
 506                     skb2->dst->dev->type != ARPHRD_IPGRE) {
 507                         kfree_skb(skb2);
 508                         return;
 509                 }
 510         }
 511
 512         /* change mtu on this route */
 513         if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
 514                 if (rel_info > dst_mtu(skb2->dst)) {
 515                         kfree_skb(skb2);
 516                         return;
 517                 }
 518                 skb2->dst->ops->update_pmtu(skb2->dst, rel_info);
 519                 rel_info = htonl(rel_info);
 520         } else if (type == ICMP_TIME_EXCEEDED) {
 521                 struct ip_tunnel *t = (struct ip_tunnel*)skb2->dev->priv;
 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         u16    flags;
 560         u16    csum = 0;
 561         u32    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 = *(u16*)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_HW:
 583                                 csum = (u16)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_HW;
 591                         }
 592                         offset += 4;
 593                 }
 594                 if (flags&GRE_KEY) {
 595                         key = *(u32*)(h + offset);
 596                         offset += 4;
 597                 }
 598                 if (flags&GRE_SEQ) {
 599                         seqno = ntohl(*(u32*)(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 = *(u16*)(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 == __constant_htons(ETH_P_WCCP)) {
 615                         skb->protocol = __constant_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                 memset(&(IPCB(skb)->opt), 0, sizeof(struct ip_options));
 624                 skb->pkt_type = PACKET_HOST;
 625 #ifdef CONFIG_NET_IPGRE_BROADCAST
 626                 if (MULTICAST(iph->daddr)) {
 627                         /* Looped back packet, drop it! */
 628                         if (((struct rtable*)skb->dst)->fl.iif == 0)
 629                                 goto drop;
 630                         tunnel->stat.multicast++;
 631                         skb->pkt_type = PACKET_BROADCAST;
 632                 }
 633 #endif
 634
 635                 if (((flags&GRE_CSUM) && csum) ||
 636                     (!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {
 637                         tunnel->stat.rx_crc_errors++;
 638                         tunnel->stat.rx_errors++;
 639                         goto drop;
 640                 }
 641                 if (tunnel->parms.i_flags&GRE_SEQ) {
 642                         if (!(flags&GRE_SEQ) ||
 643                             (tunnel->i_seqno && (s32)(seqno - tunnel->i_seqno) < 0)) {
 644                                 tunnel->stat.rx_fifo_errors++;
 645                                 tunnel->stat.rx_errors++;
 646                                 goto drop;
 647                         }
 648                         tunnel->i_seqno = seqno + 1;
 649                 }
 650                 tunnel->stat.rx_packets++;
 651                 tunnel->stat.rx_bytes += skb->len;
 652                 skb->dev = tunnel->dev;
 653                 dst_release(skb->dst);
 654                 skb->dst = NULL;
 655                 nf_reset(skb);
 656                 ipgre_ecn_decapsulate(iph, skb);
 657                 netif_rx(skb);
 658                 read_unlock(&ipgre_lock);
 659                 return(0);
 660         }
 661         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, 0);
 662
 663 drop:
 664         read_unlock(&ipgre_lock);
 665 drop_nolock:
 666         kfree_skb(skb);
 667         return(0);
 668 }
 669
 670 static int ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
 671 {
 672         struct ip_tunnel *tunnel = (struct ip_tunnel*)dev->priv;
 673         struct net_device_stats *stats = &tunnel->stat;
 674         struct iphdr  *old_iph = skb->nh.iph;
 675         struct iphdr  *tiph;
 676         u8     tos;
 677         u16    df;
 678         struct rtable *rt;                      /* Route to the other host */
 679         struct net_device *tdev;                        /* Device to other host */
 680         struct iphdr  *iph;                     /* Our new IP header */
 681         int    max_headroom;                    /* The extra header space needed */
 682         int    gre_hlen;
 683         u32    dst;
 684         int    mtu;
 685
 686         if (tunnel->recursion++) {
 687                 tunnel->stat.collisions++;
 688                 goto tx_error;
 689         }
 690
 691         if (dev->hard_header) {
 692                 gre_hlen = 0;
 693                 tiph = (struct iphdr*)skb->data;
 694         } else {
 695                 gre_hlen = tunnel->hlen;
 696                 tiph = &tunnel->parms.iph;
 697         }
 698
 699         if ((dst = tiph->daddr) == 0) {
 700                 /* NBMA tunnel */
 701
 702                 if (skb->dst == NULL) {
 703                         tunnel->stat.tx_fifo_errors++;
 704                         goto tx_error;
 705                 }
 706
 707                 if (skb->protocol == htons(ETH_P_IP)) {
 708                         rt = (struct rtable*)skb->dst;
 709                         if ((dst = rt->rt_gateway) == 0)
 710                                 goto tx_error_icmp;
 711                 }
 712 #ifdef CONFIG_IPV6
 713                 else if (skb->protocol == htons(ETH_P_IPV6)) {
 714                         struct in6_addr *addr6;
 715                         int addr_type;
 716                         struct neighbour *neigh = skb->dst->neighbour;
 717
 718                         if (neigh == NULL)
 719                                 goto tx_error;
 720
 721                         addr6 = (struct in6_addr*)&neigh->primary_key;
 722                         addr_type = ipv6_addr_type(addr6);
 723
 724                         if (addr_type == IPV6_ADDR_ANY) {
 725                                 addr6 = &skb->nh.ipv6h->daddr;
 726                                 addr_type = ipv6_addr_type(addr6);
 727                         }
 728
 729                         if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
 730                                 goto tx_error_icmp;
 731
 732                         dst = addr6->s6_addr32[3];
 733                 }
 734 #endif
 735                 else
 736                         goto tx_error;
 737         }
 738
 739         tos = tiph->tos;
 740         if (tos&1) {
 741                 if (skb->protocol == htons(ETH_P_IP))
 742                         tos = old_iph->tos;
 743                 tos &= ~1;
 744         }
 745
 746         {
 747                 struct flowi fl = { .oif = tunnel->parms.link,
 748                                     .nl_u = { .ip4_u =
 749                                               { .daddr = dst,
 750                                                 .saddr = tiph->saddr,
 751                                                 .tos = RT_TOS(tos) } },
 752                                     .proto = IPPROTO_GRE };
 753                 if (ip_route_output_key(&rt, &fl)) {
 754                         tunnel->stat.tx_carrier_errors++;
 755                         goto tx_error;
 756                 }
 757         }
 758         tdev = rt->u.dst.dev;
 759
 760         if (tdev == dev) {
 761                 ip_rt_put(rt);
 762                 tunnel->stat.collisions++;
 763                 goto tx_error;
 764         }
 765
 766         df = tiph->frag_off;
 767         if (df)
 768                 mtu = dst_mtu(&rt->u.dst) - tunnel->hlen;
 769         else
 770                 mtu = skb->dst ? dst_mtu(skb->dst) : dev->mtu;
 771
 772         if (skb->dst)
 773                 skb->dst->ops->update_pmtu(skb->dst, mtu);
 774
 775         if (skb->protocol == htons(ETH_P_IP)) {
 776                 df |= (old_iph->frag_off&htons(IP_DF));
 777
 778                 if ((old_iph->frag_off&htons(IP_DF)) &&
 779                     mtu < ntohs(old_iph->tot_len)) {
 780                         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
 781                         ip_rt_put(rt);
 782                         goto tx_error;
 783                 }
 784         }
 785 #ifdef CONFIG_IPV6
 786         else if (skb->protocol == htons(ETH_P_IPV6)) {
 787                 struct rt6_info *rt6 = (struct rt6_info*)skb->dst;
 788
 789                 if (rt6 && mtu < dst_mtu(skb->dst) && mtu >= IPV6_MIN_MTU) {
 790                         if ((tunnel->parms.iph.daddr && !MULTICAST(tunnel->parms.iph.daddr)) ||
 791                             rt6->rt6i_dst.plen == 128) {
 792                                 rt6->rt6i_flags |= RTF_MODIFIED;
 793                                 skb->dst->metrics[RTAX_MTU-1] = mtu;
 794                         }
 795                 }
 796
 797                 if (mtu >= IPV6_MIN_MTU && mtu < skb->len - tunnel->hlen + gre_hlen) {
 798                         icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, dev);
 799                         ip_rt_put(rt);
 800                         goto tx_error;
 801                 }
 802         }
 803 #endif
 804
 805         if (tunnel->err_count > 0) {
 806                 if (jiffies - tunnel->err_time < IPTUNNEL_ERR_TIMEO) {
 807                         tunnel->err_count--;
 808
 809                         dst_link_failure(skb);
 810                 } else
 811                         tunnel->err_count = 0;
 812         }
 813
 814         max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen;
 815
 816         if (skb_headroom(skb) < max_headroom || skb_cloned(skb) || skb_shared(skb)) {
 817                 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
 818                 if (!new_skb) {
 819                         ip_rt_put(rt);
 820                         stats->tx_dropped++;
 821                         dev_kfree_skb(skb);
 822                         tunnel->recursion--;
 823                         return 0;
 824                 }
 825                 if (skb->sk)
 826                         skb_set_owner_w(new_skb, skb->sk);
 827                 dev_kfree_skb(skb);
 828                 skb = new_skb;
 829                 old_iph = skb->nh.iph;
 830         }
 831
 832         skb->h.raw = skb->nh.raw;
 833         skb->nh.raw = skb_push(skb, gre_hlen);
 834         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
 835         IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE|IPSKB_XFRM_TRANSFORMED);
 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         ((u16*)(iph+1))[0] = tunnel->parms.o_flags;
 864         ((u16*)(iph+1))[1] = skb->protocol;
 865
 866         if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
 867                 u32 *ptr = (u32*)(((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                         *(__u16*)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 = (struct ip_tunnel*)dev->priv;
 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 = (struct ip_tunnel*)dev->priv;
 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 == ipgre_fb_tunnel_dev->priv)
1008                                 goto done;
1009                         dev = t->dev;
1010                 }
1011                 err = unregister_netdevice(dev);
1012                 break;
1013
1014         default:
1015                 err = -EINVAL;
1016         }
1017
1018 done:
1019         return err;
1020 }
1021
1022 static struct net_device_stats *ipgre_tunnel_get_stats(struct net_device *dev)
1023 {
1024         return &(((struct ip_tunnel*)dev->priv)->stat);
1025 }
1026
1027 static int ipgre_tunnel_change_mtu(struct net_device *dev, int new_mtu)
1028 {
1029         struct ip_tunnel *tunnel = (struct ip_tunnel*)dev->priv;
1030         if (new_mtu < 68 || new_mtu > 0xFFF8 - tunnel->hlen)
1031                 return -EINVAL;
1032         dev->mtu = new_mtu;
1033         return 0;
1034 }
1035
1036 #ifdef CONFIG_NET_IPGRE_BROADCAST
1037 /* Nice toy. Unfortunately, useless in real life :-)
1038    It allows to construct virtual multiprotocol broadcast "LAN"
1039    over the Internet, provided multicast routing is tuned.
1040
1041
1042    I have no idea was this bicycle invented before me,
1043    so that I had to set ARPHRD_IPGRE to a random value.
1044    I have an impression, that Cisco could make something similar,
1045    but this feature is apparently missing in IOS<=11.2(8).
1046
1047    I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
1048    with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
1049
1050    ping -t 255 224.66.66.66
1051
1052    If nobody answers, mbone does not work.
1053
1054    ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
1055    ip addr add 10.66.66.<somewhat>/24 dev Universe
1056    ifconfig Universe up
1057    ifconfig Universe add fe80::<Your_real_addr>/10
1058    ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
1059    ftp 10.66.66.66
1060    ...
1061    ftp fec0:6666:6666::193.233.7.65
1062    ...
1063
1064  */
1065
1066 static int ipgre_header(struct sk_buff *skb, struct net_device *dev, unsigned short type,
1067                         void *daddr, void *saddr, unsigned len)
1068 {
1069         struct ip_tunnel *t = (struct ip_tunnel*)dev->priv;
1070         struct iphdr *iph = (struct iphdr *)skb_push(skb, t->hlen);
1071         u16 *p = (u16*)(iph+1);
1072
1073         memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
1074         p[0]            = t->parms.o_flags;
1075         p[1]            = htons(type);
1076
1077         /*
1078          *      Set the source hardware address.
1079          */
1080
1081         if (saddr)
1082                 memcpy(&iph->saddr, saddr, 4);
1083
1084         if (daddr) {
1085                 memcpy(&iph->daddr, daddr, 4);
1086                 return t->hlen;
1087         }
1088         if (iph->daddr && !MULTICAST(iph->daddr))
1089                 return t->hlen;
1090
1091         return -t->hlen;
1092 }
1093
1094 static int ipgre_open(struct net_device *dev)
1095 {
1096         struct ip_tunnel *t = (struct ip_tunnel*)dev->priv;
1097
1098         if (MULTICAST(t->parms.iph.daddr)) {
1099                 struct flowi fl = { .oif = t->parms.link,
1100                                     .nl_u = { .ip4_u =
1101                                               { .daddr = t->parms.iph.daddr,
1102                                                 .saddr = t->parms.iph.saddr,
1103                                                 .tos = RT_TOS(t->parms.iph.tos) } },
1104                                     .proto = IPPROTO_GRE };
1105                 struct rtable *rt;
1106                 if (ip_route_output_key(&rt, &fl))
1107                         return -EADDRNOTAVAIL;
1108                 dev = rt->u.dst.dev;
1109                 ip_rt_put(rt);
1110                 if (__in_dev_get_rtnl(dev) == NULL)
1111                         return -EADDRNOTAVAIL;
1112                 t->mlink = dev->ifindex;
1113                 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
1114         }
1115         return 0;
1116 }
1117
1118 static int ipgre_close(struct net_device *dev)
1119 {
1120         struct ip_tunnel *t = (struct ip_tunnel*)dev->priv;
1121         if (MULTICAST(t->parms.iph.daddr) && t->mlink) {
1122                 struct in_device *in_dev = inetdev_by_index(t->mlink);
1123                 if (in_dev) {
1124                         ip_mc_dec_group(in_dev, t->parms.iph.daddr);
1125                         in_dev_put(in_dev);
1126                 }
1127         }
1128         return 0;
1129 }
1130
1131 #endif
1132
1133 static void ipgre_tunnel_setup(struct net_device *dev)
1134 {
1135         SET_MODULE_OWNER(dev);
1136         dev->uninit             = ipgre_tunnel_uninit;
1137         dev->destructor         = free_netdev;
1138         dev->hard_start_xmit    = ipgre_tunnel_xmit;
1139         dev->get_stats          = ipgre_tunnel_get_stats;
1140         dev->do_ioctl           = ipgre_tunnel_ioctl;
1141         dev->change_mtu         = ipgre_tunnel_change_mtu;
1142
1143         dev->type               = ARPHRD_IPGRE;
1144         dev->hard_header_len    = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
1145         dev->mtu                = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
1146         dev->flags              = IFF_NOARP;
1147         dev->iflink             = 0;
1148         dev->addr_len           = 4;
1149 }
1150
1151 static int ipgre_tunnel_init(struct net_device *dev)
1152 {
1153         struct net_device *tdev = NULL;
1154         struct ip_tunnel *tunnel;
1155         struct iphdr *iph;
1156         int hlen = LL_MAX_HEADER;
1157         int mtu = ETH_DATA_LEN;
1158         int addend = sizeof(struct iphdr) + 4;
1159
1160         tunnel = (struct ip_tunnel*)dev->priv;
1161         iph = &tunnel->parms.iph;
1162
1163         tunnel->dev = dev;
1164         strcpy(tunnel->parms.name, dev->name);
1165
1166         memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1167         memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1168
1169         /* Guess output device to choose reasonable mtu and hard_header_len */
1170
1171         if (iph->daddr) {
1172                 struct flowi fl = { .oif = tunnel->parms.link,
1173                                     .nl_u = { .ip4_u =
1174                                               { .daddr = iph->daddr,
1175                                                 .saddr = iph->saddr,
1176                                                 .tos = RT_TOS(iph->tos) } },
1177                                     .proto = IPPROTO_GRE };
1178                 struct rtable *rt;
1179                 if (!ip_route_output_key(&rt, &fl)) {
1180                         tdev = rt->u.dst.dev;
1181                         ip_rt_put(rt);
1182                 }
1183
1184                 dev->flags |= IFF_POINTOPOINT;
1185
1186 #ifdef CONFIG_NET_IPGRE_BROADCAST
1187                 if (MULTICAST(iph->daddr)) {
1188                         if (!iph->saddr)
1189                                 return -EINVAL;
1190                         dev->flags = IFF_BROADCAST;
1191                         dev->hard_header = ipgre_header;
1192                         dev->open = ipgre_open;
1193                         dev->stop = ipgre_close;
1194                 }
1195 #endif
1196         }
1197
1198         if (!tdev && tunnel->parms.link)
1199                 tdev = __dev_get_by_index(tunnel->parms.link);
1200
1201         if (tdev) {
1202                 hlen = tdev->hard_header_len;
1203                 mtu = tdev->mtu;
1204         }
1205         dev->iflink = tunnel->parms.link;
1206
1207         /* Precalculate GRE options length */
1208         if (tunnel->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {
1209                 if (tunnel->parms.o_flags&GRE_CSUM)
1210                         addend += 4;
1211                 if (tunnel->parms.o_flags&GRE_KEY)
1212                         addend += 4;
1213                 if (tunnel->parms.o_flags&GRE_SEQ)
1214                         addend += 4;
1215         }
1216         dev->hard_header_len = hlen + addend;
1217         dev->mtu = mtu - addend;
1218         tunnel->hlen = addend;
1219         return 0;
1220 }
1221
1222 static int __init ipgre_fb_tunnel_init(struct net_device *dev)
1223 {
1224         struct ip_tunnel *tunnel = (struct ip_tunnel*)dev->priv;
1225         struct iphdr *iph = &tunnel->parms.iph;
1226
1227         tunnel->dev = dev;
1228         strcpy(tunnel->parms.name, dev->name);
1229
1230         iph->version            = 4;
1231         iph->protocol           = IPPROTO_GRE;
1232         iph->ihl                = 5;
1233         tunnel->hlen            = sizeof(struct iphdr) + 4;
1234
1235         dev_hold(dev);
1236         tunnels_wc[0]           = tunnel;
1237         return 0;
1238 }
1239
1240
1241 static struct net_protocol ipgre_protocol = {
1242         .handler        =       ipgre_rcv,
1243         .err_handler    =       ipgre_err,
1244 };
1245
1246
1247 /*
1248  *      And now the modules code and kernel interface.
1249  */
1250
1251 static int __init ipgre_init(void)
1252 {
1253         int err;
1254
1255         printk(KERN_INFO "GRE over IPv4 tunneling driver\n");
1256
1257         if (inet_add_protocol(&ipgre_protocol, IPPROTO_GRE) < 0) {
1258                 printk(KERN_INFO "ipgre init: can't add protocol\n");
1259                 return -EAGAIN;
1260         }
1261
1262         ipgre_fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "gre0",
1263                                            ipgre_tunnel_setup);
1264         if (!ipgre_fb_tunnel_dev) {
1265                 err = -ENOMEM;
1266                 goto err1;
1267         }
1268
1269         ipgre_fb_tunnel_dev->init = ipgre_fb_tunnel_init;
1270
1271         if ((err = register_netdev(ipgre_fb_tunnel_dev)))
1272                 goto err2;
1273 out:
1274         return err;
1275 err2:
1276         free_netdev(ipgre_fb_tunnel_dev);
1277 err1:
1278         inet_del_protocol(&ipgre_protocol, IPPROTO_GRE);
1279         goto out;
1280 }
1281
1282 static void __exit ipgre_destroy_tunnels(void)
1283 {
1284         int prio;
1285
1286         for (prio = 0; prio < 4; prio++) {
1287                 int h;
1288                 for (h = 0; h < HASH_SIZE; h++) {
1289                         struct ip_tunnel *t;
1290                         while ((t = tunnels[prio][h]) != NULL)
1291                                 unregister_netdevice(t->dev);
1292                 }
1293         }
1294 }
1295
1296 static void __exit ipgre_fini(void)
1297 {
1298         if (inet_del_protocol(&ipgre_protocol, IPPROTO_GRE) < 0)
1299                 printk(KERN_INFO "ipgre close: can't remove protocol\n");
1300
1301         rtnl_lock();
1302         ipgre_destroy_tunnels();
1303         rtnl_unlock();
1304 }
1305
1306 module_init(ipgre_init);
1307 module_exit(ipgre_fini);
1308 MODULE_LICENSE("GPL");