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