Pileus Git - ~andy/linux/blob - 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 <linux/slab.h>
  99 #include <asm/uaccess.h>
 100 #include <linux/skbuff.h>
 101 #include <linux/netdevice.h>
 102 #include <linux/in.h>
 103 #include <linux/tcp.h>
 104 #include <linux/udp.h>
 105 #include <linux/if_arp.h>
 106 #include <linux/mroute.h>
 107 #include <linux/init.h>
 108 #include <linux/netfilter_ipv4.h>
 109 #include <linux/if_ether.h>
 110
 111 #include <net/sock.h>
 112 #include <net/ip.h>
 113 #include <net/icmp.h>
 114 #include <net/ipip.h>
 115 #include <net/inet_ecn.h>
 116 #include <net/xfrm.h>
 117 #include <net/net_namespace.h>
 118 #include <net/netns/generic.h>
 119
 120 #define HASH_SIZE  16
 121 #define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
 122
 123 static int ipip_net_id __read_mostly;
 124 struct ipip_net {
 125         struct ip_tunnel __rcu *tunnels_r_l[HASH_SIZE];
 126         struct ip_tunnel __rcu *tunnels_r[HASH_SIZE];
 127         struct ip_tunnel __rcu *tunnels_l[HASH_SIZE];
 128         struct ip_tunnel __rcu *tunnels_wc[1];
 129         struct ip_tunnel __rcu **tunnels[4];
 130
 131         struct net_device *fb_tunnel_dev;
 132 };
 133
 134 static int ipip_tunnel_init(struct net_device *dev);
 135 static void ipip_tunnel_setup(struct net_device *dev);
 136 static void ipip_dev_free(struct net_device *dev);
 137
 138 /*
 139  * Locking : hash tables are protected by RCU and RTNL
 140  */
 141
 142 #define for_each_ip_tunnel_rcu(start) \
 143         for (t = rcu_dereference(start); t; t = rcu_dereference(t->next))
 144
 145 /* often modified stats are per cpu, other are shared (netdev->stats) */
 146 struct pcpu_tstats {
 147         u64     rx_packets;
 148         u64     rx_bytes;
 149         u64     tx_packets;
 150         u64     tx_bytes;
 151         struct u64_stats_sync   syncp;
 152 };
 153
 154 static struct rtnl_link_stats64 *ipip_get_stats64(struct net_device *dev,
 155                                                   struct rtnl_link_stats64 *tot)
 156 {
 157         int i;
 158
 159         for_each_possible_cpu(i) {
 160                 const struct pcpu_tstats *tstats = per_cpu_ptr(dev->tstats, i);
 161                 u64 rx_packets, rx_bytes, tx_packets, tx_bytes;
 162                 unsigned int start;
 163
 164                 do {
 165                         start = u64_stats_fetch_begin_bh(&tstats->syncp);
 166                         rx_packets = tstats->rx_packets;
 167                         tx_packets = tstats->tx_packets;
 168                         rx_bytes = tstats->rx_bytes;
 169                         tx_bytes = tstats->tx_bytes;
 170                 } while (u64_stats_fetch_retry_bh(&tstats->syncp, start));
 171
 172                 tot->rx_packets += rx_packets;
 173                 tot->tx_packets += tx_packets;
 174                 tot->rx_bytes   += rx_bytes;
 175                 tot->tx_bytes   += tx_bytes;
 176         }
 177
 178         tot->tx_fifo_errors = dev->stats.tx_fifo_errors;
 179         tot->tx_carrier_errors = dev->stats.tx_carrier_errors;
 180         tot->tx_dropped = dev->stats.tx_dropped;
 181         tot->tx_aborted_errors = dev->stats.tx_aborted_errors;
 182         tot->tx_errors = dev->stats.tx_errors;
 183         tot->collisions = dev->stats.collisions;
 184
 185         return tot;
 186 }
 187
 188 static struct ip_tunnel *ipip_tunnel_lookup(struct net *net,
 189                 __be32 remote, __be32 local)
 190 {
 191         unsigned int h0 = HASH(remote);
 192         unsigned int h1 = HASH(local);
 193         struct ip_tunnel *t;
 194         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 195
 196         for_each_ip_tunnel_rcu(ipn->tunnels_r_l[h0 ^ h1])
 197                 if (local == t->parms.iph.saddr &&
 198                     remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
 199                         return t;
 200
 201         for_each_ip_tunnel_rcu(ipn->tunnels_r[h0])
 202                 if (remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
 203                         return t;
 204
 205         for_each_ip_tunnel_rcu(ipn->tunnels_l[h1])
 206                 if (local == t->parms.iph.saddr && (t->dev->flags&IFF_UP))
 207                         return t;
 208
 209         t = rcu_dereference(ipn->tunnels_wc[0]);
 210         if (t && (t->dev->flags&IFF_UP))
 211                 return t;
 212         return NULL;
 213 }
 214
 215 static struct ip_tunnel __rcu **__ipip_bucket(struct ipip_net *ipn,
 216                 struct ip_tunnel_parm *parms)
 217 {
 218         __be32 remote = parms->iph.daddr;
 219         __be32 local = parms->iph.saddr;
 220         unsigned int h = 0;
 221         int prio = 0;
 222
 223         if (remote) {
 224                 prio |= 2;
 225                 h ^= HASH(remote);
 226         }
 227         if (local) {
 228                 prio |= 1;
 229                 h ^= HASH(local);
 230         }
 231         return &ipn->tunnels[prio][h];
 232 }
 233
 234 static inline struct ip_tunnel __rcu **ipip_bucket(struct ipip_net *ipn,
 235                 struct ip_tunnel *t)
 236 {
 237         return __ipip_bucket(ipn, &t->parms);
 238 }
 239
 240 static void ipip_tunnel_unlink(struct ipip_net *ipn, struct ip_tunnel *t)
 241 {
 242         struct ip_tunnel __rcu **tp;
 243         struct ip_tunnel *iter;
 244
 245         for (tp = ipip_bucket(ipn, t);
 246              (iter = rtnl_dereference(*tp)) != NULL;
 247              tp = &iter->next) {
 248                 if (t == iter) {
 249                         rcu_assign_pointer(*tp, t->next);
 250                         break;
 251                 }
 252         }
 253 }
 254
 255 static void ipip_tunnel_link(struct ipip_net *ipn, struct ip_tunnel *t)
 256 {
 257         struct ip_tunnel __rcu **tp = ipip_bucket(ipn, t);
 258
 259         rcu_assign_pointer(t->next, rtnl_dereference(*tp));
 260         rcu_assign_pointer(*tp, t);
 261 }
 262
 263 static struct ip_tunnel *ipip_tunnel_locate(struct net *net,
 264                 struct ip_tunnel_parm *parms, int create)
 265 {
 266         __be32 remote = parms->iph.daddr;
 267         __be32 local = parms->iph.saddr;
 268         struct ip_tunnel *t, *nt;
 269         struct ip_tunnel __rcu **tp;
 270         struct net_device *dev;
 271         char name[IFNAMSIZ];
 272         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 273
 274         for (tp = __ipip_bucket(ipn, parms);
 275                  (t = rtnl_dereference(*tp)) != NULL;
 276                  tp = &t->next) {
 277                 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr)
 278                         return t;
 279         }
 280         if (!create)
 281                 return NULL;
 282
 283         if (parms->name[0])
 284                 strlcpy(name, parms->name, IFNAMSIZ);
 285         else
 286                 strcpy(name, "tunl%d");
 287
 288         dev = alloc_netdev(sizeof(*t), name, ipip_tunnel_setup);
 289         if (dev == NULL)
 290                 return NULL;
 291
 292         dev_net_set(dev, net);
 293
 294         nt = netdev_priv(dev);
 295         nt->parms = *parms;
 296
 297         if (ipip_tunnel_init(dev) < 0)
 298                 goto failed_free;
 299
 300         if (register_netdevice(dev) < 0)
 301                 goto failed_free;
 302
 303         strcpy(nt->parms.name, dev->name);
 304
 305         dev_hold(dev);
 306         ipip_tunnel_link(ipn, nt);
 307         return nt;
 308
 309 failed_free:
 310         ipip_dev_free(dev);
 311         return NULL;
 312 }
 313
 314 /* called with RTNL */
 315 static void ipip_tunnel_uninit(struct net_device *dev)
 316 {
 317         struct net *net = dev_net(dev);
 318         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 319
 320         if (dev == ipn->fb_tunnel_dev)
 321                 RCU_INIT_POINTER(ipn->tunnels_wc[0], NULL);
 322         else
 323                 ipip_tunnel_unlink(ipn, netdev_priv(dev));
 324         dev_put(dev);
 325 }
 326
 327 static int ipip_err(struct sk_buff *skb, u32 info)
 328 {
 329
 330 /* All the routers (except for Linux) return only
 331    8 bytes of packet payload. It means, that precise relaying of
 332    ICMP in the real Internet is absolutely infeasible.
 333  */
 334         const struct iphdr *iph = (const struct iphdr *)skb->data;
 335         const int type = icmp_hdr(skb)->type;
 336         const int code = icmp_hdr(skb)->code;
 337         struct ip_tunnel *t;
 338         int err;
 339
 340         switch (type) {
 341         default:
 342         case ICMP_PARAMETERPROB:
 343                 return 0;
 344
 345         case ICMP_DEST_UNREACH:
 346                 switch (code) {
 347                 case ICMP_SR_FAILED:
 348                 case ICMP_PORT_UNREACH:
 349                         /* Impossible event. */
 350                         return 0;
 351                 default:
 352                         /* All others are translated to HOST_UNREACH.
 353                            rfc2003 contains "deep thoughts" about NET_UNREACH,
 354                            I believe they are just ether pollution. --ANK
 355                          */
 356                         break;
 357                 }
 358                 break;
 359         case ICMP_TIME_EXCEEDED:
 360                 if (code != ICMP_EXC_TTL)
 361                         return 0;
 362                 break;
 363         case ICMP_REDIRECT:
 364                 break;
 365         }
 366
 367         err = -ENOENT;
 368
 369         rcu_read_lock();
 370         t = ipip_tunnel_lookup(dev_net(skb->dev), iph->daddr, iph->saddr);
 371         if (t == NULL)
 372                 goto out;
 373
 374         if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
 375                 ipv4_update_pmtu(skb, dev_net(skb->dev), info,
 376                                  t->dev->ifindex, 0, IPPROTO_IPIP, 0);
 377                 err = 0;
 378                 goto out;
 379         }
 380
 381         if (type == ICMP_REDIRECT) {
 382                 ipv4_redirect(skb, dev_net(skb->dev), t->dev->ifindex, 0,
 383                               IPPROTO_IPIP, 0);
 384                 err = 0;
 385                 goto out;
 386         }
 387
 388         if (t->parms.iph.daddr == 0)
 389                 goto out;
 390
 391         err = 0;
 392         if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
 393                 goto out;
 394
 395         if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
 396                 t->err_count++;
 397         else
 398                 t->err_count = 1;
 399         t->err_time = jiffies;
 400 out:
 401         rcu_read_unlock();
 402         return err;
 403 }
 404
 405 static inline void ipip_ecn_decapsulate(const struct iphdr *outer_iph,
 406                                         struct sk_buff *skb)
 407 {
 408         struct iphdr *inner_iph = ip_hdr(skb);
 409
 410         if (INET_ECN_is_ce(outer_iph->tos))
 411                 IP_ECN_set_ce(inner_iph);
 412 }
 413
 414 static int ipip_rcv(struct sk_buff *skb)
 415 {
 416         struct ip_tunnel *tunnel;
 417         const struct iphdr *iph = ip_hdr(skb);
 418
 419         rcu_read_lock();
 420         tunnel = ipip_tunnel_lookup(dev_net(skb->dev), iph->saddr, iph->daddr);
 421         if (tunnel != NULL) {
 422                 struct pcpu_tstats *tstats;
 423
 424                 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
 425                         rcu_read_unlock();
 426                         kfree_skb(skb);
 427                         return 0;
 428                 }
 429
 430                 secpath_reset(skb);
 431
 432                 skb->mac_header = skb->network_header;
 433                 skb_reset_network_header(skb);
 434                 skb->protocol = htons(ETH_P_IP);
 435                 skb->pkt_type = PACKET_HOST;
 436
 437                 tstats = this_cpu_ptr(tunnel->dev->tstats);
 438                 u64_stats_update_begin(&tstats->syncp);
 439                 tstats->rx_packets++;
 440                 tstats->rx_bytes += skb->len;
 441                 u64_stats_update_end(&tstats->syncp);
 442
 443                 __skb_tunnel_rx(skb, tunnel->dev);
 444
 445                 ipip_ecn_decapsulate(iph, skb);
 446
 447                 netif_rx(skb);
 448
 449                 rcu_read_unlock();
 450                 return 0;
 451         }
 452         rcu_read_unlock();
 453
 454         return -1;
 455 }
 456
 457 /*
 458  *      This function assumes it is being called from dev_queue_xmit()
 459  *      and that skb is filled properly by that function.
 460  */
 461
 462 static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
 463 {
 464         struct ip_tunnel *tunnel = netdev_priv(dev);
 465         struct pcpu_tstats *tstats;
 466         const struct iphdr  *tiph = &tunnel->parms.iph;
 467         u8     tos = tunnel->parms.iph.tos;
 468         __be16 df = tiph->frag_off;
 469         struct rtable *rt;                      /* Route to the other host */
 470         struct net_device *tdev;                /* Device to other host */
 471         const struct iphdr  *old_iph = ip_hdr(skb);
 472         struct iphdr  *iph;                     /* Our new IP header */
 473         unsigned int max_headroom;              /* The extra header space needed */
 474         __be32 dst = tiph->daddr;
 475         struct flowi4 fl4;
 476         int    mtu;
 477
 478         if (skb->protocol != htons(ETH_P_IP))
 479                 goto tx_error;
 480
 481         if (tos & 1)
 482                 tos = old_iph->tos;
 483
 484         if (!dst) {
 485                 /* NBMA tunnel */
 486                 if ((rt = skb_rtable(skb)) == NULL) {
 487                         dev->stats.tx_fifo_errors++;
 488                         goto tx_error;
 489                 }
 490                 dst = rt_nexthop(rt, old_iph->daddr);
 491         }
 492
 493         rt = ip_route_output_ports(dev_net(dev), &fl4, NULL,
 494                                    dst, tiph->saddr,
 495                                    0, 0,
 496                                    IPPROTO_IPIP, RT_TOS(tos),
 497                                    tunnel->parms.link);
 498         if (IS_ERR(rt)) {
 499                 dev->stats.tx_carrier_errors++;
 500                 goto tx_error_icmp;
 501         }
 502         tdev = rt->dst.dev;
 503
 504         if (tdev == dev) {
 505                 ip_rt_put(rt);
 506                 dev->stats.collisions++;
 507                 goto tx_error;
 508         }
 509
 510         df |= old_iph->frag_off & htons(IP_DF);
 511
 512         if (df) {
 513                 mtu = dst_mtu(&rt->dst) - sizeof(struct iphdr);
 514
 515                 if (mtu < 68) {
 516                         dev->stats.collisions++;
 517                         ip_rt_put(rt);
 518                         goto tx_error;
 519                 }
 520
 521                 if (skb_dst(skb))
 522                         skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
 523
 524                 if ((old_iph->frag_off & htons(IP_DF)) &&
 525                     mtu < ntohs(old_iph->tot_len)) {
 526                         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
 527                                   htonl(mtu));
 528                         ip_rt_put(rt);
 529                         goto tx_error;
 530                 }
 531         }
 532
 533         if (tunnel->err_count > 0) {
 534                 if (time_before(jiffies,
 535                                 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
 536                         tunnel->err_count--;
 537                         dst_link_failure(skb);
 538                 } else
 539                         tunnel->err_count = 0;
 540         }
 541
 542         /*
 543          * Okay, now see if we can stuff it in the buffer as-is.
 544          */
 545         max_headroom = (LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr));
 546
 547         if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
 548             (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
 549                 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
 550                 if (!new_skb) {
 551                         ip_rt_put(rt);
 552                         dev->stats.tx_dropped++;
 553                         dev_kfree_skb(skb);
 554                         return NETDEV_TX_OK;
 555                 }
 556                 if (skb->sk)
 557                         skb_set_owner_w(new_skb, skb->sk);
 558                 dev_kfree_skb(skb);
 559                 skb = new_skb;
 560                 old_iph = ip_hdr(skb);
 561         }
 562
 563         skb->transport_header = skb->network_header;
 564         skb_push(skb, sizeof(struct iphdr));
 565         skb_reset_network_header(skb);
 566         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
 567         IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
 568                               IPSKB_REROUTED);
 569         skb_dst_drop(skb);
 570         skb_dst_set(skb, &rt->dst);
 571
 572         /*
 573          *      Push down and install the IPIP header.
 574          */
 575
 576         iph                     =       ip_hdr(skb);
 577         iph->version            =       4;
 578         iph->ihl                =       sizeof(struct iphdr)>>2;
 579         iph->frag_off           =       df;
 580         iph->protocol           =       IPPROTO_IPIP;
 581         iph->tos                =       INET_ECN_encapsulate(tos, old_iph->tos);
 582         iph->daddr              =       fl4.daddr;
 583         iph->saddr              =       fl4.saddr;
 584
 585         if ((iph->ttl = tiph->ttl) == 0)
 586                 iph->ttl        =       old_iph->ttl;
 587
 588         nf_reset(skb);
 589         tstats = this_cpu_ptr(dev->tstats);
 590         __IPTUNNEL_XMIT(tstats, &dev->stats);
 591         return NETDEV_TX_OK;
 592
 593 tx_error_icmp:
 594         dst_link_failure(skb);
 595 tx_error:
 596         dev->stats.tx_errors++;
 597         dev_kfree_skb(skb);
 598         return NETDEV_TX_OK;
 599 }
 600
 601 static void ipip_tunnel_bind_dev(struct net_device *dev)
 602 {
 603         struct net_device *tdev = NULL;
 604         struct ip_tunnel *tunnel;
 605         const struct iphdr *iph;
 606
 607         tunnel = netdev_priv(dev);
 608         iph = &tunnel->parms.iph;
 609
 610         if (iph->daddr) {
 611                 struct rtable *rt;
 612                 struct flowi4 fl4;
 613
 614                 rt = ip_route_output_ports(dev_net(dev), &fl4, NULL,
 615                                            iph->daddr, iph->saddr,
 616                                            0, 0,
 617                                            IPPROTO_IPIP,
 618                                            RT_TOS(iph->tos),
 619                                            tunnel->parms.link);
 620                 if (!IS_ERR(rt)) {
 621                         tdev = rt->dst.dev;
 622                         ip_rt_put(rt);
 623                 }
 624                 dev->flags |= IFF_POINTOPOINT;
 625         }
 626
 627         if (!tdev && tunnel->parms.link)
 628                 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
 629
 630         if (tdev) {
 631                 dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
 632                 dev->mtu = tdev->mtu - sizeof(struct iphdr);
 633         }
 634         dev->iflink = tunnel->parms.link;
 635 }
 636
 637 static int
 638 ipip_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
 639 {
 640         int err = 0;
 641         struct ip_tunnel_parm p;
 642         struct ip_tunnel *t;
 643         struct net *net = dev_net(dev);
 644         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 645
 646         switch (cmd) {
 647         case SIOCGETTUNNEL:
 648                 t = NULL;
 649                 if (dev == ipn->fb_tunnel_dev) {
 650                         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
 651                                 err = -EFAULT;
 652                                 break;
 653                         }
 654                         t = ipip_tunnel_locate(net, &p, 0);
 655                 }
 656                 if (t == NULL)
 657                         t = netdev_priv(dev);
 658                 memcpy(&p, &t->parms, sizeof(p));
 659                 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
 660                         err = -EFAULT;
 661                 break;
 662
 663         case SIOCADDTUNNEL:
 664         case SIOCCHGTUNNEL:
 665                 err = -EPERM;
 666                 if (!capable(CAP_NET_ADMIN))
 667                         goto done;
 668
 669                 err = -EFAULT;
 670                 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 671                         goto done;
 672
 673                 err = -EINVAL;
 674                 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPIP ||
 675                     p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
 676                         goto done;
 677                 if (p.iph.ttl)
 678                         p.iph.frag_off |= htons(IP_DF);
 679
 680                 t = ipip_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
 681
 682                 if (dev != ipn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
 683                         if (t != NULL) {
 684                                 if (t->dev != dev) {
 685                                         err = -EEXIST;
 686                                         break;
 687                                 }
 688                         } else {
 689                                 if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
 690                                     (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
 691                                         err = -EINVAL;
 692                                         break;
 693                                 }
 694                                 t = netdev_priv(dev);
 695                                 ipip_tunnel_unlink(ipn, t);
 696                                 synchronize_net();
 697                                 t->parms.iph.saddr = p.iph.saddr;
 698                                 t->parms.iph.daddr = p.iph.daddr;
 699                                 memcpy(dev->dev_addr, &p.iph.saddr, 4);
 700                                 memcpy(dev->broadcast, &p.iph.daddr, 4);
 701                                 ipip_tunnel_link(ipn, t);
 702                                 netdev_state_change(dev);
 703                         }
 704                 }
 705
 706                 if (t) {
 707                         err = 0;
 708                         if (cmd == SIOCCHGTUNNEL) {
 709                                 t->parms.iph.ttl = p.iph.ttl;
 710                                 t->parms.iph.tos = p.iph.tos;
 711                                 t->parms.iph.frag_off = p.iph.frag_off;
 712                                 if (t->parms.link != p.link) {
 713                                         t->parms.link = p.link;
 714                                         ipip_tunnel_bind_dev(dev);
 715                                         netdev_state_change(dev);
 716                                 }
 717                         }
 718                         if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
 719                                 err = -EFAULT;
 720                 } else
 721                         err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
 722                 break;
 723
 724         case SIOCDELTUNNEL:
 725                 err = -EPERM;
 726                 if (!capable(CAP_NET_ADMIN))
 727                         goto done;
 728
 729                 if (dev == ipn->fb_tunnel_dev) {
 730                         err = -EFAULT;
 731                         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 732                                 goto done;
 733                         err = -ENOENT;
 734                         if ((t = ipip_tunnel_locate(net, &p, 0)) == NULL)
 735                                 goto done;
 736                         err = -EPERM;
 737                         if (t->dev == ipn->fb_tunnel_dev)
 738                                 goto done;
 739                         dev = t->dev;
 740                 }
 741                 unregister_netdevice(dev);
 742                 err = 0;
 743                 break;
 744
 745         default:
 746                 err = -EINVAL;
 747         }
 748
 749 done:
 750         return err;
 751 }
 752
 753 static int ipip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
 754 {
 755         if (new_mtu < 68 || new_mtu > 0xFFF8 - sizeof(struct iphdr))
 756                 return -EINVAL;
 757         dev->mtu = new_mtu;
 758         return 0;
 759 }
 760
 761 static const struct net_device_ops ipip_netdev_ops = {
 762         .ndo_uninit     = ipip_tunnel_uninit,
 763         .ndo_start_xmit = ipip_tunnel_xmit,
 764         .ndo_do_ioctl   = ipip_tunnel_ioctl,
 765         .ndo_change_mtu = ipip_tunnel_change_mtu,
 766         .ndo_get_stats64 = ipip_get_stats64,
 767 };
 768
 769 static void ipip_dev_free(struct net_device *dev)
 770 {
 771         free_percpu(dev->tstats);
 772         free_netdev(dev);
 773 }
 774
 775 static void ipip_tunnel_setup(struct net_device *dev)
 776 {
 777         dev->netdev_ops         = &ipip_netdev_ops;
 778         dev->destructor         = ipip_dev_free;
 779
 780         dev->type               = ARPHRD_TUNNEL;
 781         dev->hard_header_len    = LL_MAX_HEADER + sizeof(struct iphdr);
 782         dev->mtu                = ETH_DATA_LEN - sizeof(struct iphdr);
 783         dev->flags              = IFF_NOARP;
 784         dev->iflink             = 0;
 785         dev->addr_len           = 4;
 786         dev->features           |= NETIF_F_NETNS_LOCAL;
 787         dev->features           |= NETIF_F_LLTX;
 788         dev->priv_flags         &= ~IFF_XMIT_DST_RELEASE;
 789 }
 790
 791 static int ipip_tunnel_init(struct net_device *dev)
 792 {
 793         struct ip_tunnel *tunnel = netdev_priv(dev);
 794
 795         tunnel->dev = dev;
 796
 797         memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
 798         memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
 799
 800         ipip_tunnel_bind_dev(dev);
 801
 802         dev->tstats = alloc_percpu(struct pcpu_tstats);
 803         if (!dev->tstats)
 804                 return -ENOMEM;
 805
 806         return 0;
 807 }
 808
 809 static int __net_init ipip_fb_tunnel_init(struct net_device *dev)
 810 {
 811         struct ip_tunnel *tunnel = netdev_priv(dev);
 812         struct iphdr *iph = &tunnel->parms.iph;
 813         struct ipip_net *ipn = net_generic(dev_net(dev), ipip_net_id);
 814
 815         tunnel->dev = dev;
 816         strcpy(tunnel->parms.name, dev->name);
 817
 818         iph->version            = 4;
 819         iph->protocol           = IPPROTO_IPIP;
 820         iph->ihl                = 5;
 821
 822         dev->tstats = alloc_percpu(struct pcpu_tstats);
 823         if (!dev->tstats)
 824                 return -ENOMEM;
 825
 826         dev_hold(dev);
 827         rcu_assign_pointer(ipn->tunnels_wc[0], tunnel);
 828         return 0;
 829 }
 830
 831 static struct xfrm_tunnel ipip_handler __read_mostly = {
 832         .handler        =       ipip_rcv,
 833         .err_handler    =       ipip_err,
 834         .priority       =       1,
 835 };
 836
 837 static const char banner[] __initconst =
 838         KERN_INFO "IPv4 over IPv4 tunneling driver\n";
 839
 840 static void ipip_destroy_tunnels(struct ipip_net *ipn, struct list_head *head)
 841 {
 842         int prio;
 843
 844         for (prio = 1; prio < 4; prio++) {
 845                 int h;
 846                 for (h = 0; h < HASH_SIZE; h++) {
 847                         struct ip_tunnel *t;
 848
 849                         t = rtnl_dereference(ipn->tunnels[prio][h]);
 850                         while (t != NULL) {
 851                                 unregister_netdevice_queue(t->dev, head);
 852                                 t = rtnl_dereference(t->next);
 853                         }
 854                 }
 855         }
 856 }
 857
 858 static int __net_init ipip_init_net(struct net *net)
 859 {
 860         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 861         struct ip_tunnel *t;
 862         int err;
 863
 864         ipn->tunnels[0] = ipn->tunnels_wc;
 865         ipn->tunnels[1] = ipn->tunnels_l;
 866         ipn->tunnels[2] = ipn->tunnels_r;
 867         ipn->tunnels[3] = ipn->tunnels_r_l;
 868
 869         ipn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel),
 870                                            "tunl0",
 871                                            ipip_tunnel_setup);
 872         if (!ipn->fb_tunnel_dev) {
 873                 err = -ENOMEM;
 874                 goto err_alloc_dev;
 875         }
 876         dev_net_set(ipn->fb_tunnel_dev, net);
 877
 878         err = ipip_fb_tunnel_init(ipn->fb_tunnel_dev);
 879         if (err)
 880                 goto err_reg_dev;
 881
 882         if ((err = register_netdev(ipn->fb_tunnel_dev)))
 883                 goto err_reg_dev;
 884
 885         t = netdev_priv(ipn->fb_tunnel_dev);
 886
 887         strcpy(t->parms.name, ipn->fb_tunnel_dev->name);
 888         return 0;
 889
 890 err_reg_dev:
 891         ipip_dev_free(ipn->fb_tunnel_dev);
 892 err_alloc_dev:
 893         /* nothing */
 894         return err;
 895 }
 896
 897 static void __net_exit ipip_exit_net(struct net *net)
 898 {
 899         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 900         LIST_HEAD(list);
 901
 902         rtnl_lock();
 903         ipip_destroy_tunnels(ipn, &list);
 904         unregister_netdevice_queue(ipn->fb_tunnel_dev, &list);
 905         unregister_netdevice_many(&list);
 906         rtnl_unlock();
 907 }
 908
 909 static struct pernet_operations ipip_net_ops = {
 910         .init = ipip_init_net,
 911         .exit = ipip_exit_net,
 912         .id   = &ipip_net_id,
 913         .size = sizeof(struct ipip_net),
 914 };
 915
 916 static int __init ipip_init(void)
 917 {
 918         int err;
 919
 920         printk(banner);
 921
 922         err = register_pernet_device(&ipip_net_ops);
 923         if (err < 0)
 924                 return err;
 925         err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
 926         if (err < 0) {
 927                 unregister_pernet_device(&ipip_net_ops);
 928                 pr_info("%s: can't register tunnel\n", __func__);
 929         }
 930         return err;
 931 }
 932
 933 static void __exit ipip_fini(void)
 934 {
 935         if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
 936                 pr_info("%s: can't deregister tunnel\n", __func__);
 937
 938         unregister_pernet_device(&ipip_net_ops);
 939 }
 940
 941 module_init(ipip_init);
 942 module_exit(ipip_fini);
 943 MODULE_LICENSE("GPL");
 944 MODULE_ALIAS_NETDEV("tunl0");