net/ipv4/ipip.c

   1 /*
   2  *      Linux NET3:     IP/IP protocol decoder.
   3  *
   4  *      Authors:
   5  *              Sam Lantinga (slouken@cs.ucdavis.edu)  02/01/95
   6  *
   7  *      Fixes:
   8  *              Alan Cox        :       Merged and made usable non modular (its so tiny its silly as
   9  *                                      a module taking up 2 pages).
  10  *              Alan Cox        :       Fixed bug with 1.3.18 and IPIP not working (now needs to set skb->h.iph)
  11  *                                      to keep ip_forward happy.
  12  *              Alan Cox        :       More fixes for 1.3.21, and firewall fix. Maybe this will work soon 8).
  13  *              Kai Schulte     :       Fixed #defines for IP_FIREWALL->FIREWALL
  14  *              David Woodhouse :       Perform some basic ICMP handling.
  15  *                                      IPIP Routing without decapsulation.
  16  *              Carlos Picoto   :       GRE over IP support
  17  *              Alexey Kuznetsov:       Reworked. Really, now it is truncated version of ipv4/ip_gre.c.
  18  *                                      I do not want to merge them together.
  19  *
  20  *      This program is free software; you can redistribute it and/or
  21  *      modify it under the terms of the GNU General Public License
  22  *      as published by the Free Software Foundation; either version
  23  *      2 of the License, or (at your option) any later version.
  24  *
  25  */
  26
  27 /* tunnel.c: an IP tunnel driver
  28
  29         The purpose of this driver is to provide an IP tunnel through
  30         which you can tunnel network traffic transparently across subnets.
  31
  32         This was written by looking at Nick Holloway's dummy driver
  33         Thanks for the great code!
  34
  35                 -Sam Lantinga   (slouken@cs.ucdavis.edu)  02/01/95
  36
  37         Minor tweaks:
  38                 Cleaned up the code a little and added some pre-1.3.0 tweaks.
  39                 dev->hard_header/hard_header_len changed to use no headers.
  40                 Comments/bracketing tweaked.
  41                 Made the tunnels use dev->name not tunnel: when error reporting.
  42                 Added tx_dropped stat
  43
  44                 -Alan Cox       (alan@lxorguk.ukuu.org.uk) 21 March 95
  45
  46         Reworked:
  47                 Changed to tunnel to destination gateway in addition to the
  48                         tunnel's pointopoint address
  49                 Almost completely rewritten
  50                 Note:  There is currently no firewall or ICMP handling done.
  51
  52                 -Sam Lantinga   (slouken@cs.ucdavis.edu) 02/13/96
  53
  54 */
  55
  56 /* Things I wish I had known when writing the tunnel driver:
  57
  58         When the tunnel_xmit() function is called, the skb contains the
  59         packet to be sent (plus a great deal of extra info), and dev
  60         contains the tunnel device that _we_ are.
  61
  62         When we are passed a packet, we are expected to fill in the
  63         source address with our source IP address.
  64
  65         What is the proper way to allocate, copy and free a buffer?
  66         After you allocate it, it is a "0 length" chunk of memory
  67         starting at zero.  If you want to add headers to the buffer
  68         later, you'll have to call "skb_reserve(skb, amount)" with
  69         the amount of memory you want reserved.  Then, you call
  70         "skb_put(skb, amount)" with the amount of space you want in
  71         the buffer.  skb_put() returns a pointer to the top (#0) of
  72         that buffer.  skb->len is set to the amount of space you have
  73         "allocated" with skb_put().  You can then write up to skb->len
  74         bytes to that buffer.  If you need more, you can call skb_put()
  75         again with the additional amount of space you need.  You can
  76         find out how much more space you can allocate by calling
  77         "skb_tailroom(skb)".
  78         Now, to add header space, call "skb_push(skb, header_len)".
  79         This creates space at the beginning of the buffer and returns
  80         a pointer to this new space.  If later you need to strip a
  81         header from a buffer, call "skb_pull(skb, header_len)".
  82         skb_headroom() will return how much space is left at the top
  83         of the buffer (before the main data).  Remember, this headroom
  84         space must be reserved before the skb_put() function is called.
  85         */
  86
  87 /*
  88    This version of net/ipv4/ipip.c is cloned of net/ipv4/ip_gre.c
  89
  90    For comments look at net/ipv4/ip_gre.c --ANK
  91  */
  92
  93
  94 #include <linux/capability.h>
  95 #include <linux/module.h>
  96 #include <linux/types.h>
  97 #include <linux/kernel.h>
  98 #include <asm/uaccess.h>
  99 #include <linux/skbuff.h>
 100 #include <linux/netdevice.h>
 101 #include <linux/in.h>
 102 #include <linux/tcp.h>
 103 #include <linux/udp.h>
 104 #include <linux/if_arp.h>
 105 #include <linux/mroute.h>
 106 #include <linux/init.h>
 107 #include <linux/netfilter_ipv4.h>
 108 #include <linux/if_ether.h>
 109
 110 #include <net/sock.h>
 111 #include <net/ip.h>
 112 #include <net/icmp.h>
 113 #include <net/ipip.h>
 114 #include <net/inet_ecn.h>
 115 #include <net/xfrm.h>
 116 #include <net/net_namespace.h>
 117 #include <net/netns/generic.h>
 118
 119 #define HASH_SIZE  16
 120 #define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
 121
 122 static int ipip_net_id;
 123 struct ipip_net {
 124         struct ip_tunnel *tunnels_r_l[HASH_SIZE];
 125         struct ip_tunnel *tunnels_r[HASH_SIZE];
 126         struct ip_tunnel *tunnels_l[HASH_SIZE];
 127         struct ip_tunnel *tunnels_wc[1];
 128         struct ip_tunnel **tunnels[4];
 129
 130         struct net_device *fb_tunnel_dev;
 131 };
 132
 133 static void ipip_fb_tunnel_init(struct net_device *dev);
 134 static void ipip_tunnel_init(struct net_device *dev);
 135 static void ipip_tunnel_setup(struct net_device *dev);
 136
 137 static DEFINE_RWLOCK(ipip_lock);
 138
 139 static struct ip_tunnel * ipip_tunnel_lookup(struct net *net,
 140                 __be32 remote, __be32 local)
 141 {
 142         unsigned h0 = HASH(remote);
 143         unsigned h1 = HASH(local);
 144         struct ip_tunnel *t;
 145         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 146
 147         for (t = ipn->tunnels_r_l[h0^h1]; t; t = t->next) {
 148                 if (local == t->parms.iph.saddr &&
 149                     remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
 150                         return t;
 151         }
 152         for (t = ipn->tunnels_r[h0]; t; t = t->next) {
 153                 if (remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
 154                         return t;
 155         }
 156         for (t = ipn->tunnels_l[h1]; t; t = t->next) {
 157                 if (local == t->parms.iph.saddr && (t->dev->flags&IFF_UP))
 158                         return t;
 159         }
 160         if ((t = ipn->tunnels_wc[0]) != NULL && (t->dev->flags&IFF_UP))
 161                 return t;
 162         return NULL;
 163 }
 164
 165 static struct ip_tunnel **__ipip_bucket(struct ipip_net *ipn,
 166                 struct ip_tunnel_parm *parms)
 167 {
 168         __be32 remote = parms->iph.daddr;
 169         __be32 local = parms->iph.saddr;
 170         unsigned h = 0;
 171         int prio = 0;
 172
 173         if (remote) {
 174                 prio |= 2;
 175                 h ^= HASH(remote);
 176         }
 177         if (local) {
 178                 prio |= 1;
 179                 h ^= HASH(local);
 180         }
 181         return &ipn->tunnels[prio][h];
 182 }
 183
 184 static inline struct ip_tunnel **ipip_bucket(struct ipip_net *ipn,
 185                 struct ip_tunnel *t)
 186 {
 187         return __ipip_bucket(ipn, &t->parms);
 188 }
 189
 190 static void ipip_tunnel_unlink(struct ipip_net *ipn, struct ip_tunnel *t)
 191 {
 192         struct ip_tunnel **tp;
 193
 194         for (tp = ipip_bucket(ipn, t); *tp; tp = &(*tp)->next) {
 195                 if (t == *tp) {
 196                         write_lock_bh(&ipip_lock);
 197                         *tp = t->next;
 198                         write_unlock_bh(&ipip_lock);
 199                         break;
 200                 }
 201         }
 202 }
 203
 204 static void ipip_tunnel_link(struct ipip_net *ipn, struct ip_tunnel *t)
 205 {
 206         struct ip_tunnel **tp = ipip_bucket(ipn, t);
 207
 208         t->next = *tp;
 209         write_lock_bh(&ipip_lock);
 210         *tp = t;
 211         write_unlock_bh(&ipip_lock);
 212 }
 213
 214 static struct ip_tunnel * ipip_tunnel_locate(struct net *net,
 215                 struct ip_tunnel_parm *parms, int create)
 216 {
 217         __be32 remote = parms->iph.daddr;
 218         __be32 local = parms->iph.saddr;
 219         struct ip_tunnel *t, **tp, *nt;
 220         struct net_device *dev;
 221         char name[IFNAMSIZ];
 222         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 223
 224         for (tp = __ipip_bucket(ipn, parms); (t = *tp) != NULL; tp = &t->next) {
 225                 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr)
 226                         return t;
 227         }
 228         if (!create)
 229                 return NULL;
 230
 231         if (parms->name[0])
 232                 strlcpy(name, parms->name, IFNAMSIZ);
 233         else
 234                 sprintf(name, "tunl%%d");
 235
 236         dev = alloc_netdev(sizeof(*t), name, ipip_tunnel_setup);
 237         if (dev == NULL)
 238                 return NULL;
 239
 240         dev_net_set(dev, net);
 241
 242         if (strchr(name, '%')) {
 243                 if (dev_alloc_name(dev, name) < 0)
 244                         goto failed_free;
 245         }
 246
 247         nt = netdev_priv(dev);
 248         nt->parms = *parms;
 249
 250         ipip_tunnel_init(dev);
 251
 252         if (register_netdevice(dev) < 0)
 253                 goto failed_free;
 254
 255         dev_hold(dev);
 256         ipip_tunnel_link(ipn, nt);
 257         return nt;
 258
 259 failed_free:
 260         free_netdev(dev);
 261         return NULL;
 262 }
 263
 264 static void ipip_tunnel_uninit(struct net_device *dev)
 265 {
 266         struct net *net = dev_net(dev);
 267         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 268
 269         if (dev == ipn->fb_tunnel_dev) {
 270                 write_lock_bh(&ipip_lock);
 271                 ipn->tunnels_wc[0] = NULL;
 272                 write_unlock_bh(&ipip_lock);
 273         } else
 274                 ipip_tunnel_unlink(ipn, netdev_priv(dev));
 275         dev_put(dev);
 276 }
 277
 278 static int ipip_err(struct sk_buff *skb, u32 info)
 279 {
 280
 281 /* All the routers (except for Linux) return only
 282    8 bytes of packet payload. It means, that precise relaying of
 283    ICMP in the real Internet is absolutely infeasible.
 284  */
 285         struct iphdr *iph = (struct iphdr *)skb->data;
 286         const int type = icmp_hdr(skb)->type;
 287         const int code = icmp_hdr(skb)->code;
 288         struct ip_tunnel *t;
 289         int err;
 290
 291         switch (type) {
 292         default:
 293         case ICMP_PARAMETERPROB:
 294                 return 0;
 295
 296         case ICMP_DEST_UNREACH:
 297                 switch (code) {
 298                 case ICMP_SR_FAILED:
 299                 case ICMP_PORT_UNREACH:
 300                         /* Impossible event. */
 301                         return 0;
 302                 case ICMP_FRAG_NEEDED:
 303                         /* Soft state for pmtu is maintained by IP core. */
 304                         return 0;
 305                 default:
 306                         /* All others are translated to HOST_UNREACH.
 307                            rfc2003 contains "deep thoughts" about NET_UNREACH,
 308                            I believe they are just ether pollution. --ANK
 309                          */
 310                         break;
 311                 }
 312                 break;
 313         case ICMP_TIME_EXCEEDED:
 314                 if (code != ICMP_EXC_TTL)
 315                         return 0;
 316                 break;
 317         }
 318
 319         err = -ENOENT;
 320
 321         read_lock(&ipip_lock);
 322         t = ipip_tunnel_lookup(dev_net(skb->dev), iph->daddr, iph->saddr);
 323         if (t == NULL || t->parms.iph.daddr == 0)
 324                 goto out;
 325
 326         err = 0;
 327         if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
 328                 goto out;
 329
 330         if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
 331                 t->err_count++;
 332         else
 333                 t->err_count = 1;
 334         t->err_time = jiffies;
 335 out:
 336         read_unlock(&ipip_lock);
 337         return err;
 338 }
 339
 340 static inline void ipip_ecn_decapsulate(const struct iphdr *outer_iph,
 341                                         struct sk_buff *skb)
 342 {
 343         struct iphdr *inner_iph = ip_hdr(skb);
 344
 345         if (INET_ECN_is_ce(outer_iph->tos))
 346                 IP_ECN_set_ce(inner_iph);
 347 }
 348
 349 static int ipip_rcv(struct sk_buff *skb)
 350 {
 351         struct ip_tunnel *tunnel;
 352         const struct iphdr *iph = ip_hdr(skb);
 353
 354         read_lock(&ipip_lock);
 355         if ((tunnel = ipip_tunnel_lookup(dev_net(skb->dev),
 356                                         iph->saddr, iph->daddr)) != NULL) {
 357                 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
 358                         read_unlock(&ipip_lock);
 359                         kfree_skb(skb);
 360                         return 0;
 361                 }
 362
 363                 secpath_reset(skb);
 364
 365                 skb->mac_header = skb->network_header;
 366                 skb_reset_network_header(skb);
 367                 skb->protocol = htons(ETH_P_IP);
 368                 skb->pkt_type = PACKET_HOST;
 369
 370                 tunnel->dev->stats.rx_packets++;
 371                 tunnel->dev->stats.rx_bytes += skb->len;
 372                 skb->dev = tunnel->dev;
 373                 skb_dst_drop(skb);
 374                 nf_reset(skb);
 375                 ipip_ecn_decapsulate(iph, skb);
 376                 netif_rx(skb);
 377                 read_unlock(&ipip_lock);
 378                 return 0;
 379         }
 380         read_unlock(&ipip_lock);
 381
 382         return -1;
 383 }
 384
 385 /*
 386  *      This function assumes it is being called from dev_queue_xmit()
 387  *      and that skb is filled properly by that function.
 388  */
 389
 390 static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
 391 {
 392         struct ip_tunnel *tunnel = netdev_priv(dev);
 393         struct net_device_stats *stats = &tunnel->dev->stats;
 394         struct iphdr  *tiph = &tunnel->parms.iph;
 395         u8     tos = tunnel->parms.iph.tos;
 396         __be16 df = tiph->frag_off;
 397         struct rtable *rt;                      /* Route to the other host */
 398         struct net_device *tdev;                        /* Device to other host */
 399         struct iphdr  *old_iph = ip_hdr(skb);
 400         struct iphdr  *iph;                     /* Our new IP header */
 401         unsigned int max_headroom;              /* The extra header space needed */
 402         __be32 dst = tiph->daddr;
 403         int    mtu;
 404
 405         if (skb->protocol != htons(ETH_P_IP))
 406                 goto tx_error;
 407
 408         if (tos&1)
 409                 tos = old_iph->tos;
 410
 411         if (!dst) {
 412                 /* NBMA tunnel */
 413                 if ((rt = skb_rtable(skb)) == NULL) {
 414                         stats->tx_fifo_errors++;
 415                         goto tx_error;
 416                 }
 417                 if ((dst = rt->rt_gateway) == 0)
 418                         goto tx_error_icmp;
 419         }
 420
 421         {
 422                 struct flowi fl = { .oif = tunnel->parms.link,
 423                                     .nl_u = { .ip4_u =
 424                                               { .daddr = dst,
 425                                                 .saddr = tiph->saddr,
 426                                                 .tos = RT_TOS(tos) } },
 427                                     .proto = IPPROTO_IPIP };
 428                 if (ip_route_output_key(dev_net(dev), &rt, &fl)) {
 429                         stats->tx_carrier_errors++;
 430                         goto tx_error_icmp;
 431                 }
 432         }
 433         tdev = rt->u.dst.dev;
 434
 435         if (tdev == dev) {
 436                 ip_rt_put(rt);
 437                 stats->collisions++;
 438                 goto tx_error;
 439         }
 440
 441         if (tiph->frag_off)
 442                 mtu = dst_mtu(&rt->u.dst) - sizeof(struct iphdr);
 443         else
 444                 mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
 445
 446         if (mtu < 68) {
 447                 stats->collisions++;
 448                 ip_rt_put(rt);
 449                 goto tx_error;
 450         }
 451         if (skb_dst(skb))
 452                 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu);
 453
 454         df |= (old_iph->frag_off&htons(IP_DF));
 455
 456         if ((old_iph->frag_off&htons(IP_DF)) && mtu < ntohs(old_iph->tot_len)) {
 457                 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
 458                 ip_rt_put(rt);
 459                 goto tx_error;
 460         }
 461
 462         if (tunnel->err_count > 0) {
 463                 if (time_before(jiffies,
 464                                 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
 465                         tunnel->err_count--;
 466                         dst_link_failure(skb);
 467                 } else
 468                         tunnel->err_count = 0;
 469         }
 470
 471         /*
 472          * Okay, now see if we can stuff it in the buffer as-is.
 473          */
 474         max_headroom = (LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr));
 475
 476         if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
 477             (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
 478                 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
 479                 if (!new_skb) {
 480                         ip_rt_put(rt);
 481                         stats->tx_dropped++;
 482                         dev_kfree_skb(skb);
 483                         return NETDEV_TX_OK;
 484                 }
 485                 if (skb->sk)
 486                         skb_set_owner_w(new_skb, skb->sk);
 487                 dev_kfree_skb(skb);
 488                 skb = new_skb;
 489                 old_iph = ip_hdr(skb);
 490         }
 491
 492         skb->transport_header = skb->network_header;
 493         skb_push(skb, sizeof(struct iphdr));
 494         skb_reset_network_header(skb);
 495         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
 496         IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
 497                               IPSKB_REROUTED);
 498         skb_dst_drop(skb);
 499         skb_dst_set(skb, &rt->u.dst);
 500
 501         /*
 502          *      Push down and install the IPIP header.
 503          */
 504
 505         iph                     =       ip_hdr(skb);
 506         iph->version            =       4;
 507         iph->ihl                =       sizeof(struct iphdr)>>2;
 508         iph->frag_off           =       df;
 509         iph->protocol           =       IPPROTO_IPIP;
 510         iph->tos                =       INET_ECN_encapsulate(tos, old_iph->tos);
 511         iph->daddr              =       rt->rt_dst;
 512         iph->saddr              =       rt->rt_src;
 513
 514         if ((iph->ttl = tiph->ttl) == 0)
 515                 iph->ttl        =       old_iph->ttl;
 516
 517         nf_reset(skb);
 518
 519         IPTUNNEL_XMIT();
 520         return NETDEV_TX_OK;
 521
 522 tx_error_icmp:
 523         dst_link_failure(skb);
 524 tx_error:
 525         stats->tx_errors++;
 526         dev_kfree_skb(skb);
 527         return NETDEV_TX_OK;
 528 }
 529
 530 static void ipip_tunnel_bind_dev(struct net_device *dev)
 531 {
 532         struct net_device *tdev = NULL;
 533         struct ip_tunnel *tunnel;
 534         struct iphdr *iph;
 535
 536         tunnel = netdev_priv(dev);
 537         iph = &tunnel->parms.iph;
 538
 539         if (iph->daddr) {
 540                 struct flowi fl = { .oif = tunnel->parms.link,
 541                                     .nl_u = { .ip4_u =
 542                                               { .daddr = iph->daddr,
 543                                                 .saddr = iph->saddr,
 544                                                 .tos = RT_TOS(iph->tos) } },
 545                                     .proto = IPPROTO_IPIP };
 546                 struct rtable *rt;
 547                 if (!ip_route_output_key(dev_net(dev), &rt, &fl)) {
 548                         tdev = rt->u.dst.dev;
 549                         ip_rt_put(rt);
 550                 }
 551                 dev->flags |= IFF_POINTOPOINT;
 552         }
 553
 554         if (!tdev && tunnel->parms.link)
 555                 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
 556
 557         if (tdev) {
 558                 dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
 559                 dev->mtu = tdev->mtu - sizeof(struct iphdr);
 560         }
 561         dev->iflink = tunnel->parms.link;
 562 }
 563
 564 static int
 565 ipip_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
 566 {
 567         int err = 0;
 568         struct ip_tunnel_parm p;
 569         struct ip_tunnel *t;
 570         struct net *net = dev_net(dev);
 571         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 572
 573         switch (cmd) {
 574         case SIOCGETTUNNEL:
 575                 t = NULL;
 576                 if (dev == ipn->fb_tunnel_dev) {
 577                         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
 578                                 err = -EFAULT;
 579                                 break;
 580                         }
 581                         t = ipip_tunnel_locate(net, &p, 0);
 582                 }
 583                 if (t == NULL)
 584                         t = netdev_priv(dev);
 585                 memcpy(&p, &t->parms, sizeof(p));
 586                 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
 587                         err = -EFAULT;
 588                 break;
 589
 590         case SIOCADDTUNNEL:
 591         case SIOCCHGTUNNEL:
 592                 err = -EPERM;
 593                 if (!capable(CAP_NET_ADMIN))
 594                         goto done;
 595
 596                 err = -EFAULT;
 597                 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 598                         goto done;
 599
 600                 err = -EINVAL;
 601                 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPIP ||
 602                     p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
 603                         goto done;
 604                 if (p.iph.ttl)
 605                         p.iph.frag_off |= htons(IP_DF);
 606
 607                 t = ipip_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
 608
 609                 if (dev != ipn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
 610                         if (t != NULL) {
 611                                 if (t->dev != dev) {
 612                                         err = -EEXIST;
 613                                         break;
 614                                 }
 615                         } else {
 616                                 if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
 617                                     (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
 618                                         err = -EINVAL;
 619                                         break;
 620                                 }
 621                                 t = netdev_priv(dev);
 622                                 ipip_tunnel_unlink(ipn, t);
 623                                 t->parms.iph.saddr = p.iph.saddr;
 624                                 t->parms.iph.daddr = p.iph.daddr;
 625                                 memcpy(dev->dev_addr, &p.iph.saddr, 4);
 626                                 memcpy(dev->broadcast, &p.iph.daddr, 4);
 627                                 ipip_tunnel_link(ipn, t);
 628                                 netdev_state_change(dev);
 629                         }
 630                 }
 631
 632                 if (t) {
 633                         err = 0;
 634                         if (cmd == SIOCCHGTUNNEL) {
 635                                 t->parms.iph.ttl = p.iph.ttl;
 636                                 t->parms.iph.tos = p.iph.tos;
 637                                 t->parms.iph.frag_off = p.iph.frag_off;
 638                                 if (t->parms.link != p.link) {
 639                                         t->parms.link = p.link;
 640                                         ipip_tunnel_bind_dev(dev);
 641                                         netdev_state_change(dev);
 642                                 }
 643                         }
 644                         if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
 645                                 err = -EFAULT;
 646                 } else
 647                         err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
 648                 break;
 649
 650         case SIOCDELTUNNEL:
 651                 err = -EPERM;
 652                 if (!capable(CAP_NET_ADMIN))
 653                         goto done;
 654
 655                 if (dev == ipn->fb_tunnel_dev) {
 656                         err = -EFAULT;
 657                         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 658                                 goto done;
 659                         err = -ENOENT;
 660                         if ((t = ipip_tunnel_locate(net, &p, 0)) == NULL)
 661                                 goto done;
 662                         err = -EPERM;
 663                         if (t->dev == ipn->fb_tunnel_dev)
 664                                 goto done;
 665                         dev = t->dev;
 666                 }
 667                 unregister_netdevice(dev);
 668                 err = 0;
 669                 break;
 670
 671         default:
 672                 err = -EINVAL;
 673         }
 674
 675 done:
 676         return err;
 677 }
 678
 679 static int ipip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
 680 {
 681         if (new_mtu < 68 || new_mtu > 0xFFF8 - sizeof(struct iphdr))
 682                 return -EINVAL;
 683         dev->mtu = new_mtu;
 684         return 0;
 685 }
 686
 687 static const struct net_device_ops ipip_netdev_ops = {
 688         .ndo_uninit     = ipip_tunnel_uninit,
 689         .ndo_start_xmit = ipip_tunnel_xmit,
 690         .ndo_do_ioctl   = ipip_tunnel_ioctl,
 691         .ndo_change_mtu = ipip_tunnel_change_mtu,
 692
 693 };
 694
 695 static void ipip_tunnel_setup(struct net_device *dev)
 696 {
 697         dev->netdev_ops         = &ipip_netdev_ops;
 698         dev->destructor         = free_netdev;
 699
 700         dev->type               = ARPHRD_TUNNEL;
 701         dev->hard_header_len    = LL_MAX_HEADER + sizeof(struct iphdr);
 702         dev->mtu                = ETH_DATA_LEN - sizeof(struct iphdr);
 703         dev->flags              = IFF_NOARP;
 704         dev->iflink             = 0;
 705         dev->addr_len           = 4;
 706         dev->features           |= NETIF_F_NETNS_LOCAL;
 707         dev->priv_flags         &= ~IFF_XMIT_DST_RELEASE;
 708 }
 709
 710 static void ipip_tunnel_init(struct net_device *dev)
 711 {
 712         struct ip_tunnel *tunnel = netdev_priv(dev);
 713
 714         tunnel->dev = dev;
 715         strcpy(tunnel->parms.name, dev->name);
 716
 717         memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
 718         memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
 719
 720         ipip_tunnel_bind_dev(dev);
 721 }
 722
 723 static void ipip_fb_tunnel_init(struct net_device *dev)
 724 {
 725         struct ip_tunnel *tunnel = netdev_priv(dev);
 726         struct iphdr *iph = &tunnel->parms.iph;
 727         struct ipip_net *ipn = net_generic(dev_net(dev), ipip_net_id);
 728
 729         tunnel->dev = dev;
 730         strcpy(tunnel->parms.name, dev->name);
 731
 732         iph->version            = 4;
 733         iph->protocol           = IPPROTO_IPIP;
 734         iph->ihl                = 5;
 735
 736         dev_hold(dev);
 737         ipn->tunnels_wc[0]      = tunnel;
 738 }
 739
 740 static struct xfrm_tunnel ipip_handler = {
 741         .handler        =       ipip_rcv,
 742         .err_handler    =       ipip_err,
 743         .priority       =       1,
 744 };
 745
 746 static const char banner[] __initconst =
 747         KERN_INFO "IPv4 over IPv4 tunneling driver\n";
 748
 749 static void ipip_destroy_tunnels(struct ipip_net *ipn)
 750 {
 751         int prio;
 752
 753         for (prio = 1; prio < 4; prio++) {
 754                 int h;
 755                 for (h = 0; h < HASH_SIZE; h++) {
 756                         struct ip_tunnel *t;
 757                         while ((t = ipn->tunnels[prio][h]) != NULL)
 758                                 unregister_netdevice(t->dev);
 759                 }
 760         }
 761 }
 762
 763 static int ipip_init_net(struct net *net)
 764 {
 765         int err;
 766         struct ipip_net *ipn;
 767
 768         err = -ENOMEM;
 769         ipn = kzalloc(sizeof(struct ipip_net), GFP_KERNEL);
 770         if (ipn == NULL)
 771                 goto err_alloc;
 772
 773         err = net_assign_generic(net, ipip_net_id, ipn);
 774         if (err < 0)
 775                 goto err_assign;
 776
 777         ipn->tunnels[0] = ipn->tunnels_wc;
 778         ipn->tunnels[1] = ipn->tunnels_l;
 779         ipn->tunnels[2] = ipn->tunnels_r;
 780         ipn->tunnels[3] = ipn->tunnels_r_l;
 781
 782         ipn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel),
 783                                            "tunl0",
 784                                            ipip_tunnel_setup);
 785         if (!ipn->fb_tunnel_dev) {
 786                 err = -ENOMEM;
 787                 goto err_alloc_dev;
 788         }
 789         dev_net_set(ipn->fb_tunnel_dev, net);
 790
 791         ipip_fb_tunnel_init(ipn->fb_tunnel_dev);
 792
 793         if ((err = register_netdev(ipn->fb_tunnel_dev)))
 794                 goto err_reg_dev;
 795
 796         return 0;
 797
 798 err_reg_dev:
 799         free_netdev(ipn->fb_tunnel_dev);
 800 err_alloc_dev:
 801         /* nothing */
 802 err_assign:
 803         kfree(ipn);
 804 err_alloc:
 805         return err;
 806 }
 807
 808 static void ipip_exit_net(struct net *net)
 809 {
 810         struct ipip_net *ipn;
 811
 812         ipn = net_generic(net, ipip_net_id);
 813         rtnl_lock();
 814         ipip_destroy_tunnels(ipn);
 815         unregister_netdevice(ipn->fb_tunnel_dev);
 816         rtnl_unlock();
 817         kfree(ipn);
 818 }
 819
 820 static struct pernet_operations ipip_net_ops = {
 821         .init = ipip_init_net,
 822         .exit = ipip_exit_net,
 823 };
 824
 825 static int __init ipip_init(void)
 826 {
 827         int err;
 828
 829         printk(banner);
 830
 831         if (xfrm4_tunnel_register(&ipip_handler, AF_INET)) {
 832                 printk(KERN_INFO "ipip init: can't register tunnel\n");
 833                 return -EAGAIN;
 834         }
 835
 836         err = register_pernet_gen_device(&ipip_net_id, &ipip_net_ops);
 837         if (err)
 838                 xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
 839
 840         return err;
 841 }
 842
 843 static void __exit ipip_fini(void)
 844 {
 845         if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
 846                 printk(KERN_INFO "ipip close: can't deregister tunnel\n");
 847
 848         unregister_pernet_gen_device(ipip_net_id, &ipip_net_ops);
 849 }
 850
 851 module_init(ipip_init);
 852 module_exit(ipip_fini);
 853 MODULE_LICENSE("GPL");