net/ipv4/ipip.c

   1 /*
   2  *      Linux NET3:     IP/IP protocol decoder.
   3  *
   4  *      Authors:
   5  *              Sam Lantinga ([email protected])  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   ([email protected])  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       ([email protected]) 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   ([email protected]) 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         old_iph = ip_hdr(skb);
 485
 486         if (tos & 1)
 487                 tos = old_iph->tos;
 488
 489         if (!dst) {
 490                 /* NBMA tunnel */
 491                 if ((rt = skb_rtable(skb)) == NULL) {
 492                         dev->stats.tx_fifo_errors++;
 493                         goto tx_error;
 494                 }
 495                 dst = rt_nexthop(rt, old_iph->daddr);
 496         }
 497
 498         rt = ip_route_output_ports(dev_net(dev), &fl4, NULL,
 499                                    dst, tiph->saddr,
 500                                    0, 0,
 501                                    IPPROTO_IPIP, RT_TOS(tos),
 502                                    tunnel->parms.link);
 503         if (IS_ERR(rt)) {
 504                 dev->stats.tx_carrier_errors++;
 505                 goto tx_error_icmp;
 506         }
 507         tdev = rt->dst.dev;
 508
 509         if (tdev == dev) {
 510                 ip_rt_put(rt);
 511                 dev->stats.collisions++;
 512                 goto tx_error;
 513         }
 514
 515         df |= old_iph->frag_off & htons(IP_DF);
 516
 517         if (df) {
 518                 mtu = dst_mtu(&rt->dst) - sizeof(struct iphdr);
 519
 520                 if (mtu < 68) {
 521                         dev->stats.collisions++;
 522                         ip_rt_put(rt);
 523                         goto tx_error;
 524                 }
 525
 526                 if (skb_dst(skb))
 527                         skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
 528
 529                 if ((old_iph->frag_off & htons(IP_DF)) &&
 530                     mtu < ntohs(old_iph->tot_len)) {
 531                         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
 532                                   htonl(mtu));
 533                         ip_rt_put(rt);
 534                         goto tx_error;
 535                 }
 536         }
 537
 538         if (tunnel->err_count > 0) {
 539                 if (time_before(jiffies,
 540                                 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
 541                         tunnel->err_count--;
 542                         dst_link_failure(skb);
 543                 } else
 544                         tunnel->err_count = 0;
 545         }
 546
 547         /*
 548          * Okay, now see if we can stuff it in the buffer as-is.
 549          */
 550         max_headroom = (LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr));
 551
 552         if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
 553             (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
 554                 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
 555                 if (!new_skb) {
 556                         ip_rt_put(rt);
 557                         dev->stats.tx_dropped++;
 558                         dev_kfree_skb(skb);
 559                         return NETDEV_TX_OK;
 560                 }
 561                 if (skb->sk)
 562                         skb_set_owner_w(new_skb, skb->sk);
 563                 dev_kfree_skb(skb);
 564                 skb = new_skb;
 565                 old_iph = ip_hdr(skb);
 566         }
 567
 568         if (!skb->encapsulation) {
 569                 skb_reset_inner_headers(skb);
 570                 skb->encapsulation = 1;
 571         }
 572         if (skb->ip_summed != CHECKSUM_PARTIAL)
 573                 skb->ip_summed = CHECKSUM_NONE;
 574
 575         skb->transport_header = skb->network_header;
 576         skb_push(skb, sizeof(struct iphdr));
 577         skb_reset_network_header(skb);
 578         memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
 579         IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
 580                               IPSKB_REROUTED);
 581         skb_dst_drop(skb);
 582         skb_dst_set(skb, &rt->dst);
 583
 584         /*
 585          *      Push down and install the IPIP header.
 586          */
 587
 588         iph                     =       ip_hdr(skb);
 589         iph->version            =       4;
 590         iph->ihl                =       sizeof(struct iphdr)>>2;
 591         iph->frag_off           =       df;
 592         iph->protocol           =       IPPROTO_IPIP;
 593         iph->tos                =       INET_ECN_encapsulate(tos, old_iph->tos);
 594         iph->daddr              =       fl4.daddr;
 595         iph->saddr              =       fl4.saddr;
 596         tunnel_ip_select_ident(skb, old_iph, &rt->dst);
 597
 598         if ((iph->ttl = tiph->ttl) == 0)
 599                 iph->ttl        =       old_iph->ttl;
 600
 601         iptunnel_xmit(skb, dev);
 602
 603         return NETDEV_TX_OK;
 604
 605 tx_error_icmp:
 606         dst_link_failure(skb);
 607 tx_error:
 608         dev->stats.tx_errors++;
 609         dev_kfree_skb(skb);
 610         return NETDEV_TX_OK;
 611 }
 612
 613 static void ipip_tunnel_bind_dev(struct net_device *dev)
 614 {
 615         struct net_device *tdev = NULL;
 616         struct ip_tunnel *tunnel;
 617         const struct iphdr *iph;
 618
 619         tunnel = netdev_priv(dev);
 620         iph = &tunnel->parms.iph;
 621
 622         if (iph->daddr) {
 623                 struct rtable *rt;
 624                 struct flowi4 fl4;
 625
 626                 rt = ip_route_output_ports(dev_net(dev), &fl4, NULL,
 627                                            iph->daddr, iph->saddr,
 628                                            0, 0,
 629                                            IPPROTO_IPIP,
 630                                            RT_TOS(iph->tos),
 631                                            tunnel->parms.link);
 632                 if (!IS_ERR(rt)) {
 633                         tdev = rt->dst.dev;
 634                         ip_rt_put(rt);
 635                 }
 636                 dev->flags |= IFF_POINTOPOINT;
 637         }
 638
 639         if (!tdev && tunnel->parms.link)
 640                 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
 641
 642         if (tdev) {
 643                 dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
 644                 dev->mtu = tdev->mtu - sizeof(struct iphdr);
 645         }
 646         dev->iflink = tunnel->parms.link;
 647 }
 648
 649 static void ipip_tunnel_update(struct ip_tunnel *t, struct ip_tunnel_parm *p)
 650 {
 651         struct net *net = dev_net(t->dev);
 652         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 653
 654         ipip_tunnel_unlink(ipn, t);
 655         synchronize_net();
 656         t->parms.iph.saddr = p->iph.saddr;
 657         t->parms.iph.daddr = p->iph.daddr;
 658         memcpy(t->dev->dev_addr, &p->iph.saddr, 4);
 659         memcpy(t->dev->broadcast, &p->iph.daddr, 4);
 660         ipip_tunnel_link(ipn, t);
 661         t->parms.iph.ttl = p->iph.ttl;
 662         t->parms.iph.tos = p->iph.tos;
 663         t->parms.iph.frag_off = p->iph.frag_off;
 664         if (t->parms.link != p->link) {
 665                 t->parms.link = p->link;
 666                 ipip_tunnel_bind_dev(t->dev);
 667         }
 668         netdev_state_change(t->dev);
 669 }
 670
 671 static int
 672 ipip_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
 673 {
 674         int err = 0;
 675         struct ip_tunnel_parm p;
 676         struct ip_tunnel *t;
 677         struct net *net = dev_net(dev);
 678         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 679
 680         switch (cmd) {
 681         case SIOCGETTUNNEL:
 682                 t = NULL;
 683                 if (dev == ipn->fb_tunnel_dev) {
 684                         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
 685                                 err = -EFAULT;
 686                                 break;
 687                         }
 688                         t = ipip_tunnel_locate(net, &p, 0);
 689                 }
 690                 if (t == NULL)
 691                         t = netdev_priv(dev);
 692                 memcpy(&p, &t->parms, sizeof(p));
 693                 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
 694                         err = -EFAULT;
 695                 break;
 696
 697         case SIOCADDTUNNEL:
 698         case SIOCCHGTUNNEL:
 699                 err = -EPERM;
 700                 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
 701                         goto done;
 702
 703                 err = -EFAULT;
 704                 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 705                         goto done;
 706
 707                 err = -EINVAL;
 708                 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPIP ||
 709                     p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
 710                         goto done;
 711                 if (p.iph.ttl)
 712                         p.iph.frag_off |= htons(IP_DF);
 713
 714                 t = ipip_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
 715
 716                 if (dev != ipn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
 717                         if (t != NULL) {
 718                                 if (t->dev != dev) {
 719                                         err = -EEXIST;
 720                                         break;
 721                                 }
 722                         } else {
 723                                 if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
 724                                     (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
 725                                         err = -EINVAL;
 726                                         break;
 727                                 }
 728                                 t = netdev_priv(dev);
 729                         }
 730
 731                         ipip_tunnel_update(t, &p);
 732                 }
 733
 734                 if (t) {
 735                         err = 0;
 736                         if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
 737                                 err = -EFAULT;
 738                 } else
 739                         err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
 740                 break;
 741
 742         case SIOCDELTUNNEL:
 743                 err = -EPERM;
 744                 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
 745                         goto done;
 746
 747                 if (dev == ipn->fb_tunnel_dev) {
 748                         err = -EFAULT;
 749                         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 750                                 goto done;
 751                         err = -ENOENT;
 752                         if ((t = ipip_tunnel_locate(net, &p, 0)) == NULL)
 753                                 goto done;
 754                         err = -EPERM;
 755                         if (t->dev == ipn->fb_tunnel_dev)
 756                                 goto done;
 757                         dev = t->dev;
 758                 }
 759                 unregister_netdevice(dev);
 760                 err = 0;
 761                 break;
 762
 763         default:
 764                 err = -EINVAL;
 765         }
 766
 767 done:
 768         return err;
 769 }
 770
 771 static int ipip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
 772 {
 773         if (new_mtu < 68 || new_mtu > 0xFFF8 - sizeof(struct iphdr))
 774                 return -EINVAL;
 775         dev->mtu = new_mtu;
 776         return 0;
 777 }
 778
 779 static const struct net_device_ops ipip_netdev_ops = {
 780         .ndo_uninit     = ipip_tunnel_uninit,
 781         .ndo_start_xmit = ipip_tunnel_xmit,
 782         .ndo_do_ioctl   = ipip_tunnel_ioctl,
 783         .ndo_change_mtu = ipip_tunnel_change_mtu,
 784         .ndo_get_stats64 = ipip_get_stats64,
 785 };
 786
 787 static void ipip_dev_free(struct net_device *dev)
 788 {
 789         free_percpu(dev->tstats);
 790         free_netdev(dev);
 791 }
 792
 793 #define IPIP_FEATURES (NETIF_F_SG |             \
 794                        NETIF_F_FRAGLIST |       \
 795                        NETIF_F_HIGHDMA |        \
 796                        NETIF_F_HW_CSUM)
 797
 798 static void ipip_tunnel_setup(struct net_device *dev)
 799 {
 800         dev->netdev_ops         = &ipip_netdev_ops;
 801         dev->destructor         = ipip_dev_free;
 802
 803         dev->type               = ARPHRD_TUNNEL;
 804         dev->hard_header_len    = LL_MAX_HEADER + sizeof(struct iphdr);
 805         dev->mtu                = ETH_DATA_LEN - sizeof(struct iphdr);
 806         dev->flags              = IFF_NOARP;
 807         dev->iflink             = 0;
 808         dev->addr_len           = 4;
 809         dev->features           |= NETIF_F_NETNS_LOCAL;
 810         dev->features           |= NETIF_F_LLTX;
 811         dev->priv_flags         &= ~IFF_XMIT_DST_RELEASE;
 812
 813         dev->features           |= IPIP_FEATURES;
 814         dev->hw_features        |= IPIP_FEATURES;
 815 }
 816
 817 static int ipip_tunnel_init(struct net_device *dev)
 818 {
 819         struct ip_tunnel *tunnel = netdev_priv(dev);
 820
 821         tunnel->dev = dev;
 822
 823         memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
 824         memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
 825
 826         ipip_tunnel_bind_dev(dev);
 827
 828         dev->tstats = alloc_percpu(struct pcpu_tstats);
 829         if (!dev->tstats)
 830                 return -ENOMEM;
 831
 832         return 0;
 833 }
 834
 835 static int __net_init ipip_fb_tunnel_init(struct net_device *dev)
 836 {
 837         struct ip_tunnel *tunnel = netdev_priv(dev);
 838         struct iphdr *iph = &tunnel->parms.iph;
 839         struct ipip_net *ipn = net_generic(dev_net(dev), ipip_net_id);
 840
 841         tunnel->dev = dev;
 842         strcpy(tunnel->parms.name, dev->name);
 843
 844         iph->version            = 4;
 845         iph->protocol           = IPPROTO_IPIP;
 846         iph->ihl                = 5;
 847
 848         dev->tstats = alloc_percpu(struct pcpu_tstats);
 849         if (!dev->tstats)
 850                 return -ENOMEM;
 851
 852         dev_hold(dev);
 853         rcu_assign_pointer(ipn->tunnels_wc[0], tunnel);
 854         return 0;
 855 }
 856
 857 static void ipip_netlink_parms(struct nlattr *data[],
 858                                struct ip_tunnel_parm *parms)
 859 {
 860         memset(parms, 0, sizeof(*parms));
 861
 862         parms->iph.version = 4;
 863         parms->iph.protocol = IPPROTO_IPIP;
 864         parms->iph.ihl = 5;
 865
 866         if (!data)
 867                 return;
 868
 869         if (data[IFLA_IPTUN_LINK])
 870                 parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
 871
 872         if (data[IFLA_IPTUN_LOCAL])
 873                 parms->iph.saddr = nla_get_be32(data[IFLA_IPTUN_LOCAL]);
 874
 875         if (data[IFLA_IPTUN_REMOTE])
 876                 parms->iph.daddr = nla_get_be32(data[IFLA_IPTUN_REMOTE]);
 877
 878         if (data[IFLA_IPTUN_TTL]) {
 879                 parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]);
 880                 if (parms->iph.ttl)
 881                         parms->iph.frag_off = htons(IP_DF);
 882         }
 883
 884         if (data[IFLA_IPTUN_TOS])
 885                 parms->iph.tos = nla_get_u8(data[IFLA_IPTUN_TOS]);
 886
 887         if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC]))
 888                 parms->iph.frag_off = htons(IP_DF);
 889 }
 890
 891 static int ipip_newlink(struct net *src_net, struct net_device *dev,
 892                         struct nlattr *tb[], struct nlattr *data[])
 893 {
 894         struct net *net = dev_net(dev);
 895         struct ip_tunnel *nt;
 896
 897         nt = netdev_priv(dev);
 898         ipip_netlink_parms(data, &nt->parms);
 899
 900         if (ipip_tunnel_locate(net, &nt->parms, 0))
 901                 return -EEXIST;
 902
 903         return ipip_tunnel_create(dev);
 904 }
 905
 906 static int ipip_changelink(struct net_device *dev, struct nlattr *tb[],
 907                            struct nlattr *data[])
 908 {
 909         struct ip_tunnel *t;
 910         struct ip_tunnel_parm p;
 911         struct net *net = dev_net(dev);
 912         struct ipip_net *ipn = net_generic(net, ipip_net_id);
 913
 914         if (dev == ipn->fb_tunnel_dev)
 915                 return -EINVAL;
 916
 917         ipip_netlink_parms(data, &p);
 918
 919         if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
 920             (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
 921                 return -EINVAL;
 922
 923         t = ipip_tunnel_locate(net, &p, 0);
 924
 925         if (t) {
 926                 if (t->dev != dev)
 927                         return -EEXIST;
 928         } else
 929                 t = netdev_priv(dev);
 930
 931         ipip_tunnel_update(t, &p);
 932         return 0;
 933 }
 934
 935 static size_t ipip_get_size(const struct net_device *dev)
 936 {
 937         return
 938                 /* IFLA_IPTUN_LINK */
 939                 nla_total_size(4) +
 940                 /* IFLA_IPTUN_LOCAL */
 941                 nla_total_size(4) +
 942                 /* IFLA_IPTUN_REMOTE */
 943                 nla_total_size(4) +
 944                 /* IFLA_IPTUN_TTL */
 945                 nla_total_size(1) +
 946                 /* IFLA_IPTUN_TOS */
 947                 nla_total_size(1) +
 948                 /* IFLA_IPTUN_PMTUDISC */
 949                 nla_total_size(1) +
 950                 0;
 951 }
 952
 953 static int ipip_fill_info(struct sk_buff *skb, const struct net_device *dev)
 954 {
 955         struct ip_tunnel *tunnel = netdev_priv(dev);
 956         struct ip_tunnel_parm *parm = &tunnel->parms;
 957
 958         if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
 959             nla_put_be32(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) ||
 960             nla_put_be32(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) ||
 961             nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) ||
 962             nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) ||
 963             nla_put_u8(skb, IFLA_IPTUN_PMTUDISC,
 964                        !!(parm->iph.frag_off & htons(IP_DF))))
 965                 goto nla_put_failure;
 966         return 0;
 967
 968 nla_put_failure:
 969         return -EMSGSIZE;
 970 }
 971
 972 static const struct nla_policy ipip_policy[IFLA_IPTUN_MAX + 1] = {
 973         [IFLA_IPTUN_LINK]               = { .type = NLA_U32 },
 974         [IFLA_IPTUN_LOCAL]              = { .type = NLA_U32 },
 975         [IFLA_IPTUN_REMOTE]             = { .type = NLA_U32 },
 976         [IFLA_IPTUN_TTL]                = { .type = NLA_U8 },
 977         [IFLA_IPTUN_TOS]                = { .type = NLA_U8 },
 978         [IFLA_IPTUN_PMTUDISC]           = { .type = NLA_U8 },
 979 };
 980
 981 static struct rtnl_link_ops ipip_link_ops __read_mostly = {
 982         .kind           = "ipip",
 983         .maxtype        = IFLA_IPTUN_MAX,
 984         .policy         = ipip_policy,
 985         .priv_size      = sizeof(struct ip_tunnel),
 986         .setup          = ipip_tunnel_setup,
 987         .newlink        = ipip_newlink,
 988         .changelink     = ipip_changelink,
 989         .get_size       = ipip_get_size,
 990         .fill_info      = ipip_fill_info,
 991 };
 992
 993 static struct xfrm_tunnel ipip_handler __read_mostly = {
 994         .handler        =       ipip_rcv,
 995         .err_handler    =       ipip_err,
 996         .priority       =       1,
 997 };
 998
 999 static const char banner[] __initconst =
1000         KERN_INFO "IPv4 over IPv4 tunneling driver\n";
1001
1002 static void ipip_destroy_tunnels(struct ipip_net *ipn, struct list_head *head)
1003 {
1004         int prio;
1005
1006         for (prio = 1; prio < 4; prio++) {
1007                 int h;
1008                 for (h = 0; h < HASH_SIZE; h++) {
1009                         struct ip_tunnel *t;
1010
1011                         t = rtnl_dereference(ipn->tunnels[prio][h]);
1012                         while (t != NULL) {
1013                                 unregister_netdevice_queue(t->dev, head);
1014                                 t = rtnl_dereference(t->next);
1015                         }
1016                 }
1017         }
1018 }
1019
1020 static int __net_init ipip_init_net(struct net *net)
1021 {
1022         struct ipip_net *ipn = net_generic(net, ipip_net_id);
1023         struct ip_tunnel *t;
1024         int err;
1025
1026         ipn->tunnels[0] = ipn->tunnels_wc;
1027         ipn->tunnels[1] = ipn->tunnels_l;
1028         ipn->tunnels[2] = ipn->tunnels_r;
1029         ipn->tunnels[3] = ipn->tunnels_r_l;
1030
1031         ipn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel),
1032                                            "tunl0",
1033                                            ipip_tunnel_setup);
1034         if (!ipn->fb_tunnel_dev) {
1035                 err = -ENOMEM;
1036                 goto err_alloc_dev;
1037         }
1038         dev_net_set(ipn->fb_tunnel_dev, net);
1039
1040         err = ipip_fb_tunnel_init(ipn->fb_tunnel_dev);
1041         if (err)
1042                 goto err_reg_dev;
1043
1044         if ((err = register_netdev(ipn->fb_tunnel_dev)))
1045                 goto err_reg_dev;
1046
1047         t = netdev_priv(ipn->fb_tunnel_dev);
1048
1049         strcpy(t->parms.name, ipn->fb_tunnel_dev->name);
1050         return 0;
1051
1052 err_reg_dev:
1053         ipip_dev_free(ipn->fb_tunnel_dev);
1054 err_alloc_dev:
1055         /* nothing */
1056         return err;
1057 }
1058
1059 static void __net_exit ipip_exit_net(struct net *net)
1060 {
1061         struct ipip_net *ipn = net_generic(net, ipip_net_id);
1062         LIST_HEAD(list);
1063
1064         rtnl_lock();
1065         ipip_destroy_tunnels(ipn, &list);
1066         unregister_netdevice_queue(ipn->fb_tunnel_dev, &list);
1067         unregister_netdevice_many(&list);
1068         rtnl_unlock();
1069 }
1070
1071 static struct pernet_operations ipip_net_ops = {
1072         .init = ipip_init_net,
1073         .exit = ipip_exit_net,
1074         .id   = &ipip_net_id,
1075         .size = sizeof(struct ipip_net),
1076 };
1077
1078 static int __init ipip_init(void)
1079 {
1080         int err;
1081
1082         printk(banner);
1083
1084         err = register_pernet_device(&ipip_net_ops);
1085         if (err < 0)
1086                 return err;
1087         err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
1088         if (err < 0) {
1089                 pr_info("%s: can't register tunnel\n", __func__);
1090                 goto xfrm_tunnel_failed;
1091         }
1092         err = rtnl_link_register(&ipip_link_ops);
1093         if (err < 0)
1094                 goto rtnl_link_failed;
1095
1096 out:
1097         return err;
1098
1099 rtnl_link_failed:
1100         xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
1101 xfrm_tunnel_failed:
1102         unregister_pernet_device(&ipip_net_ops);
1103         goto out;
1104 }
1105
1106 static void __exit ipip_fini(void)
1107 {
1108         rtnl_link_unregister(&ipip_link_ops);
1109         if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
1110                 pr_info("%s: can't deregister tunnel\n", __func__);
1111
1112         unregister_pernet_device(&ipip_net_ops);
1113 }
1114
1115 module_init(ipip_init);
1116 module_exit(ipip_fini);
1117 MODULE_LICENSE("GPL");
1118 MODULE_ALIAS_NETDEV("tunl0");