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 bool log_ecn_error = true;
 124 module_param(log_ecn_error, bool, 0644);
 125 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
 126
 127 static int ipip_net_id __read_mostly;
 128 struct ipip_net {
 129         struct ip_tunnel __rcu *tunnels_r_l[HASH_SIZE];
 130         struct ip_tunnel __rcu *tunnels_r[HASH_SIZE];
 131         struct ip_tunnel __rcu *tunnels_l[HASH_SIZE];
 132         struct ip_tunnel __rcu *tunnels_wc[1];
 133         struct ip_tunnel __rcu **tunnels[4];
 134
 135         struct net_device *fb_tunnel_dev;
 136 };
 137
 138 static int ipip_tunnel_init(struct net_device *dev);
 139 static void ipip_tunnel_setup(struct net_device *dev);
 140 static void ipip_dev_free(struct net_device *dev);
 141 static struct rtnl_link_ops ipip_link_ops __read_mostly;
 142
 143 static struct rtnl_link_stats64 *ipip_get_stats64(struct net_device *dev,
 144                                                   struct rtnl_link_stats64 *tot)
 145 {
 146         int i;
 147
 148         for_each_possible_cpu(i) {
 149                 const struct pcpu_tstats *tstats = per_cpu_ptr(dev->tstats, i);
 150                 u64 rx_packets, rx_bytes, tx_packets, tx_bytes;
 151                 unsigned int start;
 152
 153                 do {
 154                         start = u64_stats_fetch_begin_bh(&tstats->syncp);
 155                         rx_packets = tstats->rx_packets;
 156                         tx_packets = tstats->tx_packets;
 157                         rx_bytes = tstats->rx_bytes;
 158                         tx_bytes = tstats->tx_bytes;
 159                 } while (u64_stats_fetch_retry_bh(&tstats->syncp, start));
 160
 161                 tot->rx_packets += rx_packets;
 162                 tot->tx_packets += tx_packets;
 163                 tot->rx_bytes   += rx_bytes;
 164                 tot->tx_bytes   += tx_bytes;
 165         }
 166
 167         tot->tx_fifo_errors = dev->stats.tx_fifo_errors;
 168         tot->tx_carrier_errors = dev->stats.tx_carrier_errors;
 169         tot->tx_dropped = dev->stats.tx_dropped;
 170         tot->tx_aborted_errors = dev->stats.tx_aborted_errors;
 171         tot->tx_errors = dev->stats.tx_errors;
 172         tot->collisions = dev->stats.collisions;
 173
 174         return tot;
 175 }
 176
 177 static struct ip_tunnel *ipip_tunnel_lookup(struct net *net,
 178                 __be32 remote, __be32 local)
 179 {
 180         unsigned int h0 = HASH(remote);
 181         unsigned int h1 = HASH(local);
 182         struct ip_tunnel *t;
 183         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 184
 185         for_each_ip_tunnel_rcu(t, ipn->tunnels_r_l[h0 ^ h1])
 186                 if (local == t->parms.iph.saddr &&
 187                     remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
 188                         return t;
 189
 190         for_each_ip_tunnel_rcu(t, ipn->tunnels_r[h0])
 191                 if (remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
 192                         return t;
 193
 194         for_each_ip_tunnel_rcu(t, ipn->tunnels_l[h1])
 195                 if (local == t->parms.iph.saddr && (t->dev->flags&IFF_UP))
 196                         return t;
 197
 198         t = rcu_dereference(ipn->tunnels_wc[0]);
 199         if (t && (t->dev->flags&IFF_UP))
 200                 return t;
 201         return NULL;
 202 }
 203
 204 static struct ip_tunnel __rcu **__ipip_bucket(struct ipip_net *ipn,
 205                 struct ip_tunnel_parm *parms)
 206 {
 207         __be32 remote = parms->iph.daddr;
 208         __be32 local = parms->iph.saddr;
 209         unsigned int h = 0;
 210         int prio = 0;
 211
 212         if (remote) {
 213                 prio |= 2;
 214                 h ^= HASH(remote);
 215         }
 216         if (local) {
 217                 prio |= 1;
 218                 h ^= HASH(local);
 219         }
 220         return &ipn->tunnels[prio][h];
 221 }
 222
 223 static inline struct ip_tunnel __rcu **ipip_bucket(struct ipip_net *ipn,
 224                 struct ip_tunnel *t)
 225 {
 226         return __ipip_bucket(ipn, &t->parms);
 227 }
 228
 229 static void ipip_tunnel_unlink(struct ipip_net *ipn, struct ip_tunnel *t)
 230 {
 231         struct ip_tunnel __rcu **tp;
 232         struct ip_tunnel *iter;
 233
 234         for (tp = ipip_bucket(ipn, t);
 235              (iter = rtnl_dereference(*tp)) != NULL;
 236              tp = &iter->next) {
 237                 if (t == iter) {
 238                         rcu_assign_pointer(*tp, t->next);
 239                         break;
 240                 }
 241         }
 242 }
 243
 244 static void ipip_tunnel_link(struct ipip_net *ipn, struct ip_tunnel *t)
 245 {
 246         struct ip_tunnel __rcu **tp = ipip_bucket(ipn, t);
 247
 248         rcu_assign_pointer(t->next, rtnl_dereference(*tp));
 249         rcu_assign_pointer(*tp, t);
 250 }
 251
 252 static int ipip_tunnel_create(struct net_device *dev)
 253 {
 254         struct ip_tunnel *t = netdev_priv(dev);
 255         struct net *net = dev_net(dev);
 256         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 257         int err;
 258
 259         err = ipip_tunnel_init(dev);
 260         if (err < 0)
 261                 goto out;
 262
 263         err = register_netdevice(dev);
 264         if (err < 0)
 265                 goto out;
 266
 267         strcpy(t->parms.name, dev->name);
 268         dev->rtnl_link_ops = &ipip_link_ops;
 269
 270         dev_hold(dev);
 271         ipip_tunnel_link(ipn, t);
 272         return 0;
 273
 274 out:
 275         return err;
 276 }
 277
 278 static struct ip_tunnel *ipip_tunnel_locate(struct net *net,
 279                 struct ip_tunnel_parm *parms, int create)
 280 {
 281         __be32 remote = parms->iph.daddr;
 282         __be32 local = parms->iph.saddr;
 283         struct ip_tunnel *t, *nt;
 284         struct ip_tunnel __rcu **tp;
 285         struct net_device *dev;
 286         char name[IFNAMSIZ];
 287         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 288
 289         for (tp = __ipip_bucket(ipn, parms);
 290                  (t = rtnl_dereference(*tp)) != NULL;
 291                  tp = &t->next) {
 292                 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr)
 293                         return t;
 294         }
 295         if (!create)
 296                 return NULL;
 297
 298         if (parms->name[0])
 299                 strlcpy(name, parms->name, IFNAMSIZ);
 300         else
 301                 strcpy(name, "tunl%d");
 302
 303         dev = alloc_netdev(sizeof(*t), name, ipip_tunnel_setup);
 304         if (dev == NULL)
 305                 return NULL;
 306
 307         dev_net_set(dev, net);
 308
 309         nt = netdev_priv(dev);
 310         nt->parms = *parms;
 311
 312         if (ipip_tunnel_create(dev) < 0)
 313                 goto failed_free;
 314
 315         return nt;
 316
 317 failed_free:
 318         ipip_dev_free(dev);
 319         return NULL;
 320 }
 321
 322 /* called with RTNL */
 323 static void ipip_tunnel_uninit(struct net_device *dev)
 324 {
 325         struct net *net = dev_net(dev);
 326         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 327
 328         if (dev == ipn->fb_tunnel_dev)
 329                 RCU_INIT_POINTER(ipn->tunnels_wc[0], NULL);
 330         else
 331                 ipip_tunnel_unlink(ipn, netdev_priv(dev));
 332         dev_put(dev);
 333 }
 334
 335 static int ipip_err(struct sk_buff *skb, u32 info)
 336 {
 337
 338 /* All the routers (except for Linux) return only
 339    8 bytes of packet payload. It means, that precise relaying of
 340    ICMP in the real Internet is absolutely infeasible.
 341  */
 342         const struct iphdr *iph = (const struct iphdr *)skb->data;
 343         const int type = icmp_hdr(skb)->type;
 344         const int code = icmp_hdr(skb)->code;
 345         struct ip_tunnel *t;
 346         int err;
 347
 348         switch (type) {
 349         default:
 350         case ICMP_PARAMETERPROB:
 351                 return 0;
 352
 353         case ICMP_DEST_UNREACH:
 354                 switch (code) {
 355                 case ICMP_SR_FAILED:
 356                 case ICMP_PORT_UNREACH:
 357                         /* Impossible event. */
 358                         return 0;
 359                 default:
 360                         /* All others are translated to HOST_UNREACH.
 361                            rfc2003 contains "deep thoughts" about NET_UNREACH,
 362                            I believe they are just ether pollution. --ANK
 363                          */
 364                         break;
 365                 }
 366                 break;
 367         case ICMP_TIME_EXCEEDED:
 368                 if (code != ICMP_EXC_TTL)
 369                         return 0;
 370                 break;
 371         case ICMP_REDIRECT:
 372                 break;
 373         }
 374
 375         err = -ENOENT;
 376         t = ipip_tunnel_lookup(dev_net(skb->dev), iph->daddr, iph->saddr);
 377         if (t == NULL)
 378                 goto out;
 379
 380         if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
 381                 ipv4_update_pmtu(skb, dev_net(skb->dev), info,
 382                                  t->dev->ifindex, 0, IPPROTO_IPIP, 0);
 383                 err = 0;
 384                 goto out;
 385         }
 386
 387         if (type == ICMP_REDIRECT) {
 388                 ipv4_redirect(skb, dev_net(skb->dev), t->dev->ifindex, 0,
 389                               IPPROTO_IPIP, 0);
 390                 err = 0;
 391                 goto out;
 392         }
 393
 394         if (t->parms.iph.daddr == 0)
 395                 goto out;
 396
 397         err = 0;
 398         if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
 399                 goto out;
 400
 401         if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
 402                 t->err_count++;
 403         else
 404                 t->err_count = 1;
 405         t->err_time = jiffies;
 406 out:
 407
 408         return err;
 409 }
 410
 411 static int ipip_rcv(struct sk_buff *skb)
 412 {
 413         struct ip_tunnel *tunnel;
 414         const struct iphdr *iph = ip_hdr(skb);
 415         int err;
 416
 417         tunnel = ipip_tunnel_lookup(dev_net(skb->dev), iph->saddr, iph->daddr);
 418         if (tunnel != NULL) {
 419                 struct pcpu_tstats *tstats;
 420
 421                 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
 422                         goto drop;
 423
 424                 secpath_reset(skb);
 425
 426                 skb->mac_header = skb->network_header;
 427                 skb_reset_network_header(skb);
 428                 skb->protocol = htons(ETH_P_IP);
 429                 skb->pkt_type = PACKET_HOST;
 430
 431                 __skb_tunnel_rx(skb, tunnel->dev);
 432
 433                 err = IP_ECN_decapsulate(iph, skb);
 434                 if (unlikely(err)) {
 435                         if (log_ecn_error)
 436                                 net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
 437                                                      &iph->saddr, iph->tos);
 438                         if (err > 1) {
 439                                 ++tunnel->dev->stats.rx_frame_errors;
 440                                 ++tunnel->dev->stats.rx_errors;
 441                                 goto drop;
 442                         }
 443                 }
 444
 445                 tstats = this_cpu_ptr(tunnel->dev->tstats);
 446                 u64_stats_update_begin(&tstats->syncp);
 447                 tstats->rx_packets++;
 448                 tstats->rx_bytes += skb->len;
 449                 u64_stats_update_end(&tstats->syncp);
 450
 451                 netif_rx(skb);
 452                 return 0;
 453         }
 454
 455         return -1;
 456
 457 drop:
 458         kfree_skb(skb);
 459         return 0;
 460 }
 461
 462 /*
 463  *      This function assumes it is being called from dev_queue_xmit()
 464  *      and that skb is filled properly by that function.
 465  */
 466
 467 static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
 468 {
 469         struct ip_tunnel *tunnel = netdev_priv(dev);
 470         const struct iphdr  *tiph = &tunnel->parms.iph;
 471         u8     tos = tunnel->parms.iph.tos;
 472         __be16 df = tiph->frag_off;
 473         struct rtable *rt;                      /* Route to the other host */
 474         struct net_device *tdev;                /* Device to other host */
 475         const struct iphdr  *old_iph;
 476         struct iphdr  *iph;                     /* Our new IP header */
 477         unsigned int max_headroom;              /* The extra header space needed */
 478         __be32 dst = tiph->daddr;
 479         struct flowi4 fl4;
 480         int    mtu;
 481
 482         if (skb->protocol != htons(ETH_P_IP))
 483                 goto tx_error;
 484
 485         if (skb->ip_summed == CHECKSUM_PARTIAL &&
 486             skb_checksum_help(skb))
 487                 goto tx_error;
 488
 489         old_iph = ip_hdr(skb);
 490
 491         if (tos & 1)
 492                 tos = old_iph->tos;
 493
 494         if (!dst) {
 495                 /* NBMA tunnel */
 496                 if ((rt = skb_rtable(skb)) == NULL) {
 497                         dev->stats.tx_fifo_errors++;
 498                         goto tx_error;
 499                 }
 500                 dst = rt_nexthop(rt, old_iph->daddr);
 501         }
 502
 503         rt = ip_route_output_ports(dev_net(dev), &fl4, NULL,
 504                                    dst, tiph->saddr,
 505                                    0, 0,
 506                                    IPPROTO_IPIP, RT_TOS(tos),
 507                                    tunnel->parms.link);
 508         if (IS_ERR(rt)) {
 509                 dev->stats.tx_carrier_errors++;
 510                 goto tx_error_icmp;
 511         }
 512         tdev = rt->dst.dev;
 513
 514         if (tdev == dev) {
 515                 ip_rt_put(rt);
 516                 dev->stats.collisions++;
 517                 goto tx_error;
 518         }
 519
 520         df |= old_iph->frag_off & htons(IP_DF);
 521
 522         if (df) {
 523                 mtu = dst_mtu(&rt->dst) - sizeof(struct iphdr);
 524
 525                 if (mtu < 68) {
 526                         dev->stats.collisions++;
 527                         ip_rt_put(rt);
 528                         goto tx_error;
 529                 }
 530
 531                 if (skb_dst(skb))
 532                         skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
 533
 534                 if ((old_iph->frag_off & htons(IP_DF)) &&
 535                     mtu < ntohs(old_iph->tot_len)) {
 536                         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
 537                                   htonl(mtu));
 538                         ip_rt_put(rt);
 539                         goto tx_error;
 540                 }
 541         }
 542
 543         if (tunnel->err_count > 0) {
 544                 if (time_before(jiffies,
 545                                 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
 546                         tunnel->err_count--;
 547                         dst_link_failure(skb);
 548                 } else
 549                         tunnel->err_count = 0;
 550         }
 551
 552         /*
 553          * Okay, now see if we can stuff it in the buffer as-is.
 554          */
 555         max_headroom = (LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr));
 556
 557         if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
 558             (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
 559                 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
 560                 if (!new_skb) {
 561                         ip_rt_put(rt);
 562                         dev->stats.tx_dropped++;
 563                         dev_kfree_skb(skb);
 564                         return NETDEV_TX_OK;
 565                 }
 566                 if (skb->sk)
 567                         skb_set_owner_w(new_skb, skb->sk);
 568                 dev_kfree_skb(skb);
 569                 skb = new_skb;
 570                 old_iph = ip_hdr(skb);
 571         }
 572
 573         skb->transport_header = skb->network_header;
 574         skb_push(skb, sizeof(struct iphdr));
 575         skb_reset_network_header(skb);
 576         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
 577         IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
 578                               IPSKB_REROUTED);
 579         skb_dst_drop(skb);
 580         skb_dst_set(skb, &rt->dst);
 581
 582         /*
 583          *      Push down and install the IPIP header.
 584          */
 585
 586         iph                     =       ip_hdr(skb);
 587         iph->version            =       4;
 588         iph->ihl                =       sizeof(struct iphdr)>>2;
 589         iph->frag_off           =       df;
 590         iph->protocol           =       IPPROTO_IPIP;
 591         iph->tos                =       INET_ECN_encapsulate(tos, old_iph->tos);
 592         iph->daddr              =       fl4.daddr;
 593         iph->saddr              =       fl4.saddr;
 594
 595         if ((iph->ttl = tiph->ttl) == 0)
 596                 iph->ttl        =       old_iph->ttl;
 597
 598         iptunnel_xmit(skb, dev);
 599         return NETDEV_TX_OK;
 600
 601 tx_error_icmp:
 602         dst_link_failure(skb);
 603 tx_error:
 604         dev->stats.tx_errors++;
 605         dev_kfree_skb(skb);
 606         return NETDEV_TX_OK;
 607 }
 608
 609 static void ipip_tunnel_bind_dev(struct net_device *dev)
 610 {
 611         struct net_device *tdev = NULL;
 612         struct ip_tunnel *tunnel;
 613         const struct iphdr *iph;
 614
 615         tunnel = netdev_priv(dev);
 616         iph = &tunnel->parms.iph;
 617
 618         if (iph->daddr) {
 619                 struct rtable *rt;
 620                 struct flowi4 fl4;
 621
 622                 rt = ip_route_output_ports(dev_net(dev), &fl4, NULL,
 623                                            iph->daddr, iph->saddr,
 624                                            0, 0,
 625                                            IPPROTO_IPIP,
 626                                            RT_TOS(iph->tos),
 627                                            tunnel->parms.link);
 628                 if (!IS_ERR(rt)) {
 629                         tdev = rt->dst.dev;
 630                         ip_rt_put(rt);
 631                 }
 632                 dev->flags |= IFF_POINTOPOINT;
 633         }
 634
 635         if (!tdev && tunnel->parms.link)
 636                 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
 637
 638         if (tdev) {
 639                 dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
 640                 dev->mtu = tdev->mtu - sizeof(struct iphdr);
 641         }
 642         dev->iflink = tunnel->parms.link;
 643 }
 644
 645 static void ipip_tunnel_update(struct ip_tunnel *t, struct ip_tunnel_parm *p)
 646 {
 647         struct net *net = dev_net(t->dev);
 648         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 649
 650         ipip_tunnel_unlink(ipn, t);
 651         synchronize_net();
 652         t->parms.iph.saddr = p->iph.saddr;
 653         t->parms.iph.daddr = p->iph.daddr;
 654         memcpy(t->dev->dev_addr, &p->iph.saddr, 4);
 655         memcpy(t->dev->broadcast, &p->iph.daddr, 4);
 656         ipip_tunnel_link(ipn, t);
 657         t->parms.iph.ttl = p->iph.ttl;
 658         t->parms.iph.tos = p->iph.tos;
 659         t->parms.iph.frag_off = p->iph.frag_off;
 660         if (t->parms.link != p->link) {
 661                 t->parms.link = p->link;
 662                 ipip_tunnel_bind_dev(t->dev);
 663         }
 664         netdev_state_change(t->dev);
 665 }
 666
 667 static int
 668 ipip_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
 669 {
 670         int err = 0;
 671         struct ip_tunnel_parm p;
 672         struct ip_tunnel *t;
 673         struct net *net = dev_net(dev);
 674         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 675
 676         switch (cmd) {
 677         case SIOCGETTUNNEL:
 678                 t = NULL;
 679                 if (dev == ipn->fb_tunnel_dev) {
 680                         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
 681                                 err = -EFAULT;
 682                                 break;
 683                         }
 684                         t = ipip_tunnel_locate(net, &p, 0);
 685                 }
 686                 if (t == NULL)
 687                         t = netdev_priv(dev);
 688                 memcpy(&p, &t->parms, sizeof(p));
 689                 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
 690                         err = -EFAULT;
 691                 break;
 692
 693         case SIOCADDTUNNEL:
 694         case SIOCCHGTUNNEL:
 695                 err = -EPERM;
 696                 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
 697                         goto done;
 698
 699                 err = -EFAULT;
 700                 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 701                         goto done;
 702
 703                 err = -EINVAL;
 704                 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPIP ||
 705                     p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
 706                         goto done;
 707                 if (p.iph.ttl)
 708                         p.iph.frag_off |= htons(IP_DF);
 709
 710                 t = ipip_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
 711
 712                 if (dev != ipn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
 713                         if (t != NULL) {
 714                                 if (t->dev != dev) {
 715                                         err = -EEXIST;
 716                                         break;
 717                                 }
 718                         } else {
 719                                 if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
 720                                     (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
 721                                         err = -EINVAL;
 722                                         break;
 723                                 }
 724                                 t = netdev_priv(dev);
 725                         }
 726
 727                         ipip_tunnel_update(t, &p);
 728                 }
 729
 730                 if (t) {
 731                         err = 0;
 732                         if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
 733                                 err = -EFAULT;
 734                 } else
 735                         err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
 736                 break;
 737
 738         case SIOCDELTUNNEL:
 739                 err = -EPERM;
 740                 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
 741                         goto done;
 742
 743                 if (dev == ipn->fb_tunnel_dev) {
 744                         err = -EFAULT;
 745                         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 746                                 goto done;
 747                         err = -ENOENT;
 748                         if ((t = ipip_tunnel_locate(net, &p, 0)) == NULL)
 749                                 goto done;
 750                         err = -EPERM;
 751                         if (t->dev == ipn->fb_tunnel_dev)
 752                                 goto done;
 753                         dev = t->dev;
 754                 }
 755                 unregister_netdevice(dev);
 756                 err = 0;
 757                 break;
 758
 759         default:
 760                 err = -EINVAL;
 761         }
 762
 763 done:
 764         return err;
 765 }
 766
 767 static int ipip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
 768 {
 769         if (new_mtu < 68 || new_mtu > 0xFFF8 - sizeof(struct iphdr))
 770                 return -EINVAL;
 771         dev->mtu = new_mtu;
 772         return 0;
 773 }
 774
 775 static const struct net_device_ops ipip_netdev_ops = {
 776         .ndo_uninit     = ipip_tunnel_uninit,
 777         .ndo_start_xmit = ipip_tunnel_xmit,
 778         .ndo_do_ioctl   = ipip_tunnel_ioctl,
 779         .ndo_change_mtu = ipip_tunnel_change_mtu,
 780         .ndo_get_stats64 = ipip_get_stats64,
 781 };
 782
 783 static void ipip_dev_free(struct net_device *dev)
 784 {
 785         free_percpu(dev->tstats);
 786         free_netdev(dev);
 787 }
 788
 789 #define IPIP_FEATURES (NETIF_F_SG |             \
 790                        NETIF_F_FRAGLIST |       \
 791                        NETIF_F_HIGHDMA |        \
 792                        NETIF_F_HW_CSUM)
 793
 794 static void ipip_tunnel_setup(struct net_device *dev)
 795 {
 796         dev->netdev_ops         = &ipip_netdev_ops;
 797         dev->destructor         = ipip_dev_free;
 798
 799         dev->type               = ARPHRD_TUNNEL;
 800         dev->hard_header_len    = LL_MAX_HEADER + sizeof(struct iphdr);
 801         dev->mtu                = ETH_DATA_LEN - sizeof(struct iphdr);
 802         dev->flags              = IFF_NOARP;
 803         dev->iflink             = 0;
 804         dev->addr_len           = 4;
 805         dev->features           |= NETIF_F_NETNS_LOCAL;
 806         dev->features           |= NETIF_F_LLTX;
 807         dev->priv_flags         &= ~IFF_XMIT_DST_RELEASE;
 808
 809         dev->features           |= IPIP_FEATURES;
 810         dev->hw_features        |= IPIP_FEATURES;
 811 }
 812
 813 static int ipip_tunnel_init(struct net_device *dev)
 814 {
 815         struct ip_tunnel *tunnel = netdev_priv(dev);
 816
 817         tunnel->dev = dev;
 818
 819         memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
 820         memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
 821
 822         ipip_tunnel_bind_dev(dev);
 823
 824         dev->tstats = alloc_percpu(struct pcpu_tstats);
 825         if (!dev->tstats)
 826                 return -ENOMEM;
 827
 828         return 0;
 829 }
 830
 831 static int __net_init ipip_fb_tunnel_init(struct net_device *dev)
 832 {
 833         struct ip_tunnel *tunnel = netdev_priv(dev);
 834         struct iphdr *iph = &tunnel->parms.iph;
 835         struct ipip_net *ipn = net_generic(dev_net(dev), ipip_net_id);
 836
 837         tunnel->dev = dev;
 838         strcpy(tunnel->parms.name, dev->name);
 839
 840         iph->version            = 4;
 841         iph->protocol           = IPPROTO_IPIP;
 842         iph->ihl                = 5;
 843
 844         dev->tstats = alloc_percpu(struct pcpu_tstats);
 845         if (!dev->tstats)
 846                 return -ENOMEM;
 847
 848         dev_hold(dev);
 849         rcu_assign_pointer(ipn->tunnels_wc[0], tunnel);
 850         return 0;
 851 }
 852
 853 static void ipip_netlink_parms(struct nlattr *data[],
 854                                struct ip_tunnel_parm *parms)
 855 {
 856         memset(parms, 0, sizeof(*parms));
 857
 858         parms->iph.version = 4;
 859         parms->iph.protocol = IPPROTO_IPIP;
 860         parms->iph.ihl = 5;
 861
 862         if (!data)
 863                 return;
 864
 865         if (data[IFLA_IPTUN_LINK])
 866                 parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
 867
 868         if (data[IFLA_IPTUN_LOCAL])
 869                 parms->iph.saddr = nla_get_be32(data[IFLA_IPTUN_LOCAL]);
 870
 871         if (data[IFLA_IPTUN_REMOTE])
 872                 parms->iph.daddr = nla_get_be32(data[IFLA_IPTUN_REMOTE]);
 873
 874         if (data[IFLA_IPTUN_TTL]) {
 875                 parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]);
 876                 if (parms->iph.ttl)
 877                         parms->iph.frag_off = htons(IP_DF);
 878         }
 879
 880         if (data[IFLA_IPTUN_TOS])
 881                 parms->iph.tos = nla_get_u8(data[IFLA_IPTUN_TOS]);
 882
 883         if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC]))
 884                 parms->iph.frag_off = htons(IP_DF);
 885 }
 886
 887 static int ipip_newlink(struct net *src_net, struct net_device *dev,
 888                         struct nlattr *tb[], struct nlattr *data[])
 889 {
 890         struct net *net = dev_net(dev);
 891         struct ip_tunnel *nt;
 892
 893         nt = netdev_priv(dev);
 894         ipip_netlink_parms(data, &nt->parms);
 895
 896         if (ipip_tunnel_locate(net, &nt->parms, 0))
 897                 return -EEXIST;
 898
 899         return ipip_tunnel_create(dev);
 900 }
 901
 902 static int ipip_changelink(struct net_device *dev, struct nlattr *tb[],
 903                            struct nlattr *data[])
 904 {
 905         struct ip_tunnel *t;
 906         struct ip_tunnel_parm p;
 907         struct net *net = dev_net(dev);
 908         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 909
 910         if (dev == ipn->fb_tunnel_dev)
 911                 return -EINVAL;
 912
 913         ipip_netlink_parms(data, &p);
 914
 915         if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
 916             (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
 917                 return -EINVAL;
 918
 919         t = ipip_tunnel_locate(net, &p, 0);
 920
 921         if (t) {
 922                 if (t->dev != dev)
 923                         return -EEXIST;
 924         } else
 925                 t = netdev_priv(dev);
 926
 927         ipip_tunnel_update(t, &p);
 928         return 0;
 929 }
 930
 931 static size_t ipip_get_size(const struct net_device *dev)
 932 {
 933         return
 934                 /* IFLA_IPTUN_LINK */
 935                 nla_total_size(4) +
 936                 /* IFLA_IPTUN_LOCAL */
 937                 nla_total_size(4) +
 938                 /* IFLA_IPTUN_REMOTE */
 939                 nla_total_size(4) +
 940                 /* IFLA_IPTUN_TTL */
 941                 nla_total_size(1) +
 942                 /* IFLA_IPTUN_TOS */
 943                 nla_total_size(1) +
 944                 /* IFLA_IPTUN_PMTUDISC */
 945                 nla_total_size(1) +
 946                 0;
 947 }
 948
 949 static int ipip_fill_info(struct sk_buff *skb, const struct net_device *dev)
 950 {
 951         struct ip_tunnel *tunnel = netdev_priv(dev);
 952         struct ip_tunnel_parm *parm = &tunnel->parms;
 953
 954         if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
 955             nla_put_be32(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) ||
 956             nla_put_be32(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) ||
 957             nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) ||
 958             nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) ||
 959             nla_put_u8(skb, IFLA_IPTUN_PMTUDISC,
 960                        !!(parm->iph.frag_off & htons(IP_DF))))
 961                 goto nla_put_failure;
 962         return 0;
 963
 964 nla_put_failure:
 965         return -EMSGSIZE;
 966 }
 967
 968 static const struct nla_policy ipip_policy[IFLA_IPTUN_MAX + 1] = {
 969         [IFLA_IPTUN_LINK]               = { .type = NLA_U32 },
 970         [IFLA_IPTUN_LOCAL]              = { .type = NLA_U32 },
 971         [IFLA_IPTUN_REMOTE]             = { .type = NLA_U32 },
 972         [IFLA_IPTUN_TTL]                = { .type = NLA_U8 },
 973         [IFLA_IPTUN_TOS]                = { .type = NLA_U8 },
 974         [IFLA_IPTUN_PMTUDISC]           = { .type = NLA_U8 },
 975 };
 976
 977 static struct rtnl_link_ops ipip_link_ops __read_mostly = {
 978         .kind           = "ipip",
 979         .maxtype        = IFLA_IPTUN_MAX,
 980         .policy         = ipip_policy,
 981         .priv_size      = sizeof(struct ip_tunnel),
 982         .setup          = ipip_tunnel_setup,
 983         .newlink        = ipip_newlink,
 984         .changelink     = ipip_changelink,
 985         .get_size       = ipip_get_size,
 986         .fill_info      = ipip_fill_info,
 987 };
 988
 989 static struct xfrm_tunnel ipip_handler __read_mostly = {
 990         .handler        =       ipip_rcv,
 991         .err_handler    =       ipip_err,
 992         .priority       =       1,
 993 };
 994
 995 static const char banner[] __initconst =
 996         KERN_INFO "IPv4 over IPv4 tunneling driver\n";
 997
 998 static void ipip_destroy_tunnels(struct ipip_net *ipn, struct list_head *head)
 999 {
1000         int prio;
1001
1002         for (prio = 1; prio < 4; prio++) {
1003                 int h;
1004                 for (h = 0; h < HASH_SIZE; h++) {
1005                         struct ip_tunnel *t;
1006
1007                         t = rtnl_dereference(ipn->tunnels[prio][h]);
1008                         while (t != NULL) {
1009                                 unregister_netdevice_queue(t->dev, head);
1010                                 t = rtnl_dereference(t->next);
1011                         }
1012                 }
1013         }
1014 }
1015
1016 static int __net_init ipip_init_net(struct net *net)
1017 {
1018         struct ipip_net *ipn = net_generic(net, ipip_net_id);
1019         struct ip_tunnel *t;
1020         int err;
1021
1022         ipn->tunnels[0] = ipn->tunnels_wc;
1023         ipn->tunnels[1] = ipn->tunnels_l;
1024         ipn->tunnels[2] = ipn->tunnels_r;
1025         ipn->tunnels[3] = ipn->tunnels_r_l;
1026
1027         ipn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel),
1028                                            "tunl0",
1029                                            ipip_tunnel_setup);
1030         if (!ipn->fb_tunnel_dev) {
1031                 err = -ENOMEM;
1032                 goto err_alloc_dev;
1033         }
1034         dev_net_set(ipn->fb_tunnel_dev, net);
1035
1036         err = ipip_fb_tunnel_init(ipn->fb_tunnel_dev);
1037         if (err)
1038                 goto err_reg_dev;
1039
1040         if ((err = register_netdev(ipn->fb_tunnel_dev)))
1041                 goto err_reg_dev;
1042
1043         t = netdev_priv(ipn->fb_tunnel_dev);
1044
1045         strcpy(t->parms.name, ipn->fb_tunnel_dev->name);
1046         return 0;
1047
1048 err_reg_dev:
1049         ipip_dev_free(ipn->fb_tunnel_dev);
1050 err_alloc_dev:
1051         /* nothing */
1052         return err;
1053 }
1054
1055 static void __net_exit ipip_exit_net(struct net *net)
1056 {
1057         struct ipip_net *ipn = net_generic(net, ipip_net_id);
1058         LIST_HEAD(list);
1059
1060         rtnl_lock();
1061         ipip_destroy_tunnels(ipn, &list);
1062         unregister_netdevice_queue(ipn->fb_tunnel_dev, &list);
1063         unregister_netdevice_many(&list);
1064         rtnl_unlock();
1065 }
1066
1067 static struct pernet_operations ipip_net_ops = {
1068         .init = ipip_init_net,
1069         .exit = ipip_exit_net,
1070         .id   = &ipip_net_id,
1071         .size = sizeof(struct ipip_net),
1072 };
1073
1074 static int __init ipip_init(void)
1075 {
1076         int err;
1077
1078         printk(banner);
1079
1080         err = register_pernet_device(&ipip_net_ops);
1081         if (err < 0)
1082                 return err;
1083         err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
1084         if (err < 0) {
1085                 pr_info("%s: can't register tunnel\n", __func__);
1086                 goto xfrm_tunnel_failed;
1087         }
1088         err = rtnl_link_register(&ipip_link_ops);
1089         if (err < 0)
1090                 goto rtnl_link_failed;
1091
1092 out:
1093         return err;
1094
1095 rtnl_link_failed:
1096         xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
1097 xfrm_tunnel_failed:
1098         unregister_pernet_device(&ipip_net_ops);
1099         goto out;
1100 }
1101
1102 static void __exit ipip_fini(void)
1103 {
1104         rtnl_link_unregister(&ipip_link_ops);
1105         if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
1106                 pr_info("%s: can't deregister tunnel\n", __func__);
1107
1108         unregister_pernet_device(&ipip_net_ops);
1109 }
1110
1111 module_init(ipip_init);
1112 module_exit(ipip_fini);
1113 MODULE_LICENSE("GPL");
1114 MODULE_ALIAS_NETDEV("tunl0");