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 <linux/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/init.h>
 107 #include <linux/netfilter_ipv4.h>
 108 #include <linux/if_ether.h>
 109
 110 #include <net/sock.h>
 111 #include <net/ip.h>
 112 #include <net/icmp.h>
 113 #include <net/ip_tunnels.h>
 114 #include <net/inet_ecn.h>
 115 #include <net/xfrm.h>
 116 #include <net/net_namespace.h>
 117 #include <net/netns/generic.h>
 118 #include <net/dst_metadata.h>
 119
 120 static bool log_ecn_error = true;
 121 module_param(log_ecn_error, bool, 0644);
 122 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
 123
 124 static unsigned int ipip_net_id __read_mostly;
 125
 126 static int ipip_tunnel_init(struct net_device *dev);
 127 static struct rtnl_link_ops ipip_link_ops __read_mostly;
 128
 129 static int ipip_err(struct sk_buff *skb, u32 info)
 130 {
 131         /* All the routers (except for Linux) return only
 132          * 8 bytes of packet payload. It means, that precise relaying of
 133          * ICMP in the real Internet is absolutely infeasible.
 134          */
 135         struct net *net = dev_net(skb->dev);
 136         struct ip_tunnel_net *itn = net_generic(net, ipip_net_id);
 137         const struct iphdr *iph = (const struct iphdr *)skb->data;
 138         const int type = icmp_hdr(skb)->type;
 139         const int code = icmp_hdr(skb)->code;
 140         struct ip_tunnel *t;
 141         int err = 0;
 142
 143         switch (type) {
 144         case ICMP_DEST_UNREACH:
 145                 switch (code) {
 146                 case ICMP_SR_FAILED:
 147                         /* Impossible event. */
 148                         goto out;
 149                 default:
 150                         /* All others are translated to HOST_UNREACH.
 151                          * rfc2003 contains "deep thoughts" about NET_UNREACH,
 152                          * I believe they are just ether pollution. --ANK
 153                          */
 154                         break;
 155                 }
 156                 break;
 157
 158         case ICMP_TIME_EXCEEDED:
 159                 if (code != ICMP_EXC_TTL)
 160                         goto out;
 161                 break;
 162
 163         case ICMP_REDIRECT:
 164                 break;
 165
 166         default:
 167                 goto out;
 168         }
 169
 170         t = ip_tunnel_lookup(itn, skb->dev->ifindex, TUNNEL_NO_KEY,
 171                              iph->daddr, iph->saddr, 0);
 172         if (!t) {
 173                 err = -ENOENT;
 174                 goto out;
 175         }
 176
 177         if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
 178                 ipv4_update_pmtu(skb, net, info, t->parms.link, 0,
 179                                  iph->protocol, 0);
 180                 goto out;
 181         }
 182
 183         if (type == ICMP_REDIRECT) {
 184                 ipv4_redirect(skb, net, t->parms.link, 0, iph->protocol, 0);
 185                 goto out;
 186         }
 187
 188         if (t->parms.iph.daddr == 0) {
 189                 err = -ENOENT;
 190                 goto out;
 191         }
 192
 193         if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
 194                 goto out;
 195
 196         if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
 197                 t->err_count++;
 198         else
 199                 t->err_count = 1;
 200         t->err_time = jiffies;
 201
 202 out:
 203         return err;
 204 }
 205
 206 static const struct tnl_ptk_info ipip_tpi = {
 207         /* no tunnel info required for ipip. */
 208         .proto = htons(ETH_P_IP),
 209 };
 210
 211 #if IS_ENABLED(CONFIG_MPLS)
 212 static const struct tnl_ptk_info mplsip_tpi = {
 213         /* no tunnel info required for mplsip. */
 214         .proto = htons(ETH_P_MPLS_UC),
 215 };
 216 #endif
 217
 218 static int ipip_tunnel_rcv(struct sk_buff *skb, u8 ipproto)
 219 {
 220         struct net *net = dev_net(skb->dev);
 221         struct ip_tunnel_net *itn = net_generic(net, ipip_net_id);
 222         struct metadata_dst *tun_dst = NULL;
 223         struct ip_tunnel *tunnel;
 224         const struct iphdr *iph;
 225
 226         iph = ip_hdr(skb);
 227         tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, TUNNEL_NO_KEY,
 228                         iph->saddr, iph->daddr, 0);
 229         if (tunnel) {
 230                 const struct tnl_ptk_info *tpi;
 231
 232                 if (tunnel->parms.iph.protocol != ipproto &&
 233                     tunnel->parms.iph.protocol != 0)
 234                         goto drop;
 235
 236                 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
 237                         goto drop;
 238 #if IS_ENABLED(CONFIG_MPLS)
 239                 if (ipproto == IPPROTO_MPLS)
 240                         tpi = &mplsip_tpi;
 241                 else
 242 #endif
 243                         tpi = &ipip_tpi;
 244                 if (iptunnel_pull_header(skb, 0, tpi->proto, false))
 245                         goto drop;
 246                 if (tunnel->collect_md) {
 247                         tun_dst = ip_tun_rx_dst(skb, 0, 0, 0);
 248                         if (!tun_dst)
 249                                 return 0;
 250                 }
 251                 return ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error);
 252         }
 253
 254         return -1;
 255
 256 drop:
 257         kfree_skb(skb);
 258         return 0;
 259 }
 260
 261 static int ipip_rcv(struct sk_buff *skb)
 262 {
 263         return ipip_tunnel_rcv(skb, IPPROTO_IPIP);
 264 }
 265
 266 #if IS_ENABLED(CONFIG_MPLS)
 267 static int mplsip_rcv(struct sk_buff *skb)
 268 {
 269         return ipip_tunnel_rcv(skb, IPPROTO_MPLS);
 270 }
 271 #endif
 272
 273 /*
 274  *      This function assumes it is being called from dev_queue_xmit()
 275  *      and that skb is filled properly by that function.
 276  */
 277 static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb,
 278                                     struct net_device *dev)
 279 {
 280         struct ip_tunnel *tunnel = netdev_priv(dev);
 281         const struct iphdr  *tiph = &tunnel->parms.iph;
 282         u8 ipproto;
 283
 284         if (!pskb_inet_may_pull(skb))
 285                 goto tx_error;
 286
 287         switch (skb->protocol) {
 288         case htons(ETH_P_IP):
 289                 ipproto = IPPROTO_IPIP;
 290                 break;
 291 #if IS_ENABLED(CONFIG_MPLS)
 292         case htons(ETH_P_MPLS_UC):
 293                 ipproto = IPPROTO_MPLS;
 294                 break;
 295 #endif
 296         default:
 297                 goto tx_error;
 298         }
 299
 300         if (tiph->protocol != ipproto && tiph->protocol != 0)
 301                 goto tx_error;
 302
 303         if (iptunnel_handle_offloads(skb, SKB_GSO_IPXIP4))
 304                 goto tx_error;
 305
 306         skb_set_inner_ipproto(skb, ipproto);
 307
 308         if (tunnel->collect_md)
 309                 ip_md_tunnel_xmit(skb, dev, ipproto);
 310         else
 311                 ip_tunnel_xmit(skb, dev, tiph, ipproto);
 312         return NETDEV_TX_OK;
 313
 314 tx_error:
 315         kfree_skb(skb);
 316
 317         dev->stats.tx_errors++;
 318         return NETDEV_TX_OK;
 319 }
 320
 321 static bool ipip_tunnel_ioctl_verify_protocol(u8 ipproto)
 322 {
 323         switch (ipproto) {
 324         case 0:
 325         case IPPROTO_IPIP:
 326 #if IS_ENABLED(CONFIG_MPLS)
 327         case IPPROTO_MPLS:
 328 #endif
 329                 return true;
 330         }
 331
 332         return false;
 333 }
 334
 335 static int
 336 ipip_tunnel_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 337 {
 338         int err = 0;
 339         struct ip_tunnel_parm p;
 340
 341         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 342                 return -EFAULT;
 343
 344         if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
 345                 if (p.iph.version != 4 ||
 346                     !ipip_tunnel_ioctl_verify_protocol(p.iph.protocol) ||
 347                     p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
 348                         return -EINVAL;
 349         }
 350
 351         p.i_key = p.o_key = 0;
 352         p.i_flags = p.o_flags = 0;
 353         err = ip_tunnel_ioctl(dev, &p, cmd);
 354         if (err)
 355                 return err;
 356
 357         if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
 358                 return -EFAULT;
 359
 360         return 0;
 361 }
 362
 363 static const struct net_device_ops ipip_netdev_ops = {
 364         .ndo_init       = ipip_tunnel_init,
 365         .ndo_uninit     = ip_tunnel_uninit,
 366         .ndo_start_xmit = ipip_tunnel_xmit,
 367         .ndo_do_ioctl   = ipip_tunnel_ioctl,
 368         .ndo_change_mtu = ip_tunnel_change_mtu,
 369         .ndo_get_stats64 = ip_tunnel_get_stats64,
 370         .ndo_get_iflink = ip_tunnel_get_iflink,
 371 };
 372
 373 #define IPIP_FEATURES (NETIF_F_SG |             \
 374                        NETIF_F_FRAGLIST |       \
 375                        NETIF_F_HIGHDMA |        \
 376                        NETIF_F_GSO_SOFTWARE |   \
 377                        NETIF_F_HW_CSUM)
 378
 379 static void ipip_tunnel_setup(struct net_device *dev)
 380 {
 381         dev->netdev_ops         = &ipip_netdev_ops;
 382
 383         dev->type               = ARPHRD_TUNNEL;
 384         dev->flags              = IFF_NOARP;
 385         dev->addr_len           = 4;
 386         dev->features           |= NETIF_F_LLTX;
 387         netif_keep_dst(dev);
 388
 389         dev->features           |= IPIP_FEATURES;
 390         dev->hw_features        |= IPIP_FEATURES;
 391         ip_tunnel_setup(dev, ipip_net_id);
 392 }
 393
 394 static int ipip_tunnel_init(struct net_device *dev)
 395 {
 396         struct ip_tunnel *tunnel = netdev_priv(dev);
 397
 398         memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
 399         memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
 400
 401         tunnel->tun_hlen = 0;
 402         tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
 403         return ip_tunnel_init(dev);
 404 }
 405
 406 static int ipip_tunnel_validate(struct nlattr *tb[], struct nlattr *data[],
 407                                 struct netlink_ext_ack *extack)
 408 {
 409         u8 proto;
 410
 411         if (!data || !data[IFLA_IPTUN_PROTO])
 412                 return 0;
 413
 414         proto = nla_get_u8(data[IFLA_IPTUN_PROTO]);
 415         if (proto != IPPROTO_IPIP && proto != IPPROTO_MPLS && proto != 0)
 416                 return -EINVAL;
 417
 418         return 0;
 419 }
 420
 421 static void ipip_netlink_parms(struct nlattr *data[],
 422                                struct ip_tunnel_parm *parms, bool *collect_md,
 423                                __u32 *fwmark)
 424 {
 425         memset(parms, 0, sizeof(*parms));
 426
 427         parms->iph.version = 4;
 428         parms->iph.protocol = IPPROTO_IPIP;
 429         parms->iph.ihl = 5;
 430         *collect_md = false;
 431
 432         if (!data)
 433                 return;
 434
 435         if (data[IFLA_IPTUN_LINK])
 436                 parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
 437
 438         if (data[IFLA_IPTUN_LOCAL])
 439                 parms->iph.saddr = nla_get_in_addr(data[IFLA_IPTUN_LOCAL]);
 440
 441         if (data[IFLA_IPTUN_REMOTE])
 442                 parms->iph.daddr = nla_get_in_addr(data[IFLA_IPTUN_REMOTE]);
 443
 444         if (data[IFLA_IPTUN_TTL]) {
 445                 parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]);
 446                 if (parms->iph.ttl)
 447                         parms->iph.frag_off = htons(IP_DF);
 448         }
 449
 450         if (data[IFLA_IPTUN_TOS])
 451                 parms->iph.tos = nla_get_u8(data[IFLA_IPTUN_TOS]);
 452
 453         if (data[IFLA_IPTUN_PROTO])
 454                 parms->iph.protocol = nla_get_u8(data[IFLA_IPTUN_PROTO]);
 455
 456         if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC]))
 457                 parms->iph.frag_off = htons(IP_DF);
 458
 459         if (data[IFLA_IPTUN_COLLECT_METADATA])
 460                 *collect_md = true;
 461
 462         if (data[IFLA_IPTUN_FWMARK])
 463                 *fwmark = nla_get_u32(data[IFLA_IPTUN_FWMARK]);
 464 }
 465
 466 /* This function returns true when ENCAP attributes are present in the nl msg */
 467 static bool ipip_netlink_encap_parms(struct nlattr *data[],
 468                                      struct ip_tunnel_encap *ipencap)
 469 {
 470         bool ret = false;
 471
 472         memset(ipencap, 0, sizeof(*ipencap));
 473
 474         if (!data)
 475                 return ret;
 476
 477         if (data[IFLA_IPTUN_ENCAP_TYPE]) {
 478                 ret = true;
 479                 ipencap->type = nla_get_u16(data[IFLA_IPTUN_ENCAP_TYPE]);
 480         }
 481
 482         if (data[IFLA_IPTUN_ENCAP_FLAGS]) {
 483                 ret = true;
 484                 ipencap->flags = nla_get_u16(data[IFLA_IPTUN_ENCAP_FLAGS]);
 485         }
 486
 487         if (data[IFLA_IPTUN_ENCAP_SPORT]) {
 488                 ret = true;
 489                 ipencap->sport = nla_get_be16(data[IFLA_IPTUN_ENCAP_SPORT]);
 490         }
 491
 492         if (data[IFLA_IPTUN_ENCAP_DPORT]) {
 493                 ret = true;
 494                 ipencap->dport = nla_get_be16(data[IFLA_IPTUN_ENCAP_DPORT]);
 495         }
 496
 497         return ret;
 498 }
 499
 500 static int ipip_newlink(struct net *src_net, struct net_device *dev,
 501                         struct nlattr *tb[], struct nlattr *data[],
 502                         struct netlink_ext_ack *extack)
 503 {
 504         struct ip_tunnel *t = netdev_priv(dev);
 505         struct ip_tunnel_parm p;
 506         struct ip_tunnel_encap ipencap;
 507         __u32 fwmark = 0;
 508
 509         if (ipip_netlink_encap_parms(data, &ipencap)) {
 510                 int err = ip_tunnel_encap_setup(t, &ipencap);
 511
 512                 if (err < 0)
 513                         return err;
 514         }
 515
 516         ipip_netlink_parms(data, &p, &t->collect_md, &fwmark);
 517         return ip_tunnel_newlink(dev, tb, &p, fwmark);
 518 }
 519
 520 static int ipip_changelink(struct net_device *dev, struct nlattr *tb[],
 521                            struct nlattr *data[],
 522                            struct netlink_ext_ack *extack)
 523 {
 524         struct ip_tunnel *t = netdev_priv(dev);
 525         struct ip_tunnel_parm p;
 526         struct ip_tunnel_encap ipencap;
 527         bool collect_md;
 528         __u32 fwmark = t->fwmark;
 529
 530         if (ipip_netlink_encap_parms(data, &ipencap)) {
 531                 int err = ip_tunnel_encap_setup(t, &ipencap);
 532
 533                 if (err < 0)
 534                         return err;
 535         }
 536
 537         ipip_netlink_parms(data, &p, &collect_md, &fwmark);
 538         if (collect_md)
 539                 return -EINVAL;
 540
 541         if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
 542             (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
 543                 return -EINVAL;
 544
 545         return ip_tunnel_changelink(dev, tb, &p, fwmark);
 546 }
 547
 548 static size_t ipip_get_size(const struct net_device *dev)
 549 {
 550         return
 551                 /* IFLA_IPTUN_LINK */
 552                 nla_total_size(4) +
 553                 /* IFLA_IPTUN_LOCAL */
 554                 nla_total_size(4) +
 555                 /* IFLA_IPTUN_REMOTE */
 556                 nla_total_size(4) +
 557                 /* IFLA_IPTUN_TTL */
 558                 nla_total_size(1) +
 559                 /* IFLA_IPTUN_TOS */
 560                 nla_total_size(1) +
 561                 /* IFLA_IPTUN_PROTO */
 562                 nla_total_size(1) +
 563                 /* IFLA_IPTUN_PMTUDISC */
 564                 nla_total_size(1) +
 565                 /* IFLA_IPTUN_ENCAP_TYPE */
 566                 nla_total_size(2) +
 567                 /* IFLA_IPTUN_ENCAP_FLAGS */
 568                 nla_total_size(2) +
 569                 /* IFLA_IPTUN_ENCAP_SPORT */
 570                 nla_total_size(2) +
 571                 /* IFLA_IPTUN_ENCAP_DPORT */
 572                 nla_total_size(2) +
 573                 /* IFLA_IPTUN_COLLECT_METADATA */
 574                 nla_total_size(0) +
 575                 /* IFLA_IPTUN_FWMARK */
 576                 nla_total_size(4) +
 577                 0;
 578 }
 579
 580 static int ipip_fill_info(struct sk_buff *skb, const struct net_device *dev)
 581 {
 582         struct ip_tunnel *tunnel = netdev_priv(dev);
 583         struct ip_tunnel_parm *parm = &tunnel->parms;
 584
 585         if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
 586             nla_put_in_addr(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) ||
 587             nla_put_in_addr(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) ||
 588             nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) ||
 589             nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) ||
 590             nla_put_u8(skb, IFLA_IPTUN_PROTO, parm->iph.protocol) ||
 591             nla_put_u8(skb, IFLA_IPTUN_PMTUDISC,
 592                        !!(parm->iph.frag_off & htons(IP_DF))) ||
 593             nla_put_u32(skb, IFLA_IPTUN_FWMARK, tunnel->fwmark))
 594                 goto nla_put_failure;
 595
 596         if (nla_put_u16(skb, IFLA_IPTUN_ENCAP_TYPE,
 597                         tunnel->encap.type) ||
 598             nla_put_be16(skb, IFLA_IPTUN_ENCAP_SPORT,
 599                          tunnel->encap.sport) ||
 600             nla_put_be16(skb, IFLA_IPTUN_ENCAP_DPORT,
 601                          tunnel->encap.dport) ||
 602             nla_put_u16(skb, IFLA_IPTUN_ENCAP_FLAGS,
 603                         tunnel->encap.flags))
 604                 goto nla_put_failure;
 605
 606         if (tunnel->collect_md)
 607                 if (nla_put_flag(skb, IFLA_IPTUN_COLLECT_METADATA))
 608                         goto nla_put_failure;
 609         return 0;
 610
 611 nla_put_failure:
 612         return -EMSGSIZE;
 613 }
 614
 615 static const struct nla_policy ipip_policy[IFLA_IPTUN_MAX + 1] = {
 616         [IFLA_IPTUN_LINK]               = { .type = NLA_U32 },
 617         [IFLA_IPTUN_LOCAL]              = { .type = NLA_U32 },
 618         [IFLA_IPTUN_REMOTE]             = { .type = NLA_U32 },
 619         [IFLA_IPTUN_TTL]                = { .type = NLA_U8 },
 620         [IFLA_IPTUN_TOS]                = { .type = NLA_U8 },
 621         [IFLA_IPTUN_PROTO]              = { .type = NLA_U8 },
 622         [IFLA_IPTUN_PMTUDISC]           = { .type = NLA_U8 },
 623         [IFLA_IPTUN_ENCAP_TYPE]         = { .type = NLA_U16 },
 624         [IFLA_IPTUN_ENCAP_FLAGS]        = { .type = NLA_U16 },
 625         [IFLA_IPTUN_ENCAP_SPORT]        = { .type = NLA_U16 },
 626         [IFLA_IPTUN_ENCAP_DPORT]        = { .type = NLA_U16 },
 627         [IFLA_IPTUN_COLLECT_METADATA]   = { .type = NLA_FLAG },
 628         [IFLA_IPTUN_FWMARK]             = { .type = NLA_U32 },
 629 };
 630
 631 static struct rtnl_link_ops ipip_link_ops __read_mostly = {
 632         .kind           = "ipip",
 633         .maxtype        = IFLA_IPTUN_MAX,
 634         .policy         = ipip_policy,
 635         .priv_size      = sizeof(struct ip_tunnel),
 636         .setup          = ipip_tunnel_setup,
 637         .validate       = ipip_tunnel_validate,
 638         .newlink        = ipip_newlink,
 639         .changelink     = ipip_changelink,
 640         .dellink        = ip_tunnel_dellink,
 641         .get_size       = ipip_get_size,
 642         .fill_info      = ipip_fill_info,
 643         .get_link_net   = ip_tunnel_get_link_net,
 644 };
 645
 646 static struct xfrm_tunnel ipip_handler __read_mostly = {
 647         .handler        =       ipip_rcv,
 648         .err_handler    =       ipip_err,
 649         .priority       =       1,
 650 };
 651
 652 #if IS_ENABLED(CONFIG_MPLS)
 653 static struct xfrm_tunnel mplsip_handler __read_mostly = {
 654         .handler        =       mplsip_rcv,
 655         .err_handler    =       ipip_err,
 656         .priority       =       1,
 657 };
 658 #endif
 659
 660 static int __net_init ipip_init_net(struct net *net)
 661 {
 662         return ip_tunnel_init_net(net, ipip_net_id, &ipip_link_ops, "tunl0");
 663 }
 664
 665 static void __net_exit ipip_exit_batch_net(struct list_head *list_net)
 666 {
 667         ip_tunnel_delete_nets(list_net, ipip_net_id, &ipip_link_ops);
 668 }
 669
 670 static struct pernet_operations ipip_net_ops = {
 671         .init = ipip_init_net,
 672         .exit_batch = ipip_exit_batch_net,
 673         .id   = &ipip_net_id,
 674         .size = sizeof(struct ip_tunnel_net),
 675 };
 676
 677 static int __init ipip_init(void)
 678 {
 679         int err;
 680
 681         pr_info("ipip: IPv4 and MPLS over IPv4 tunneling driver\n");
 682
 683         err = register_pernet_device(&ipip_net_ops);
 684         if (err < 0)
 685                 return err;
 686         err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
 687         if (err < 0) {
 688                 pr_info("%s: can't register tunnel\n", __func__);
 689                 goto xfrm_tunnel_ipip_failed;
 690         }
 691 #if IS_ENABLED(CONFIG_MPLS)
 692         err = xfrm4_tunnel_register(&mplsip_handler, AF_MPLS);
 693         if (err < 0) {
 694                 pr_info("%s: can't register tunnel\n", __func__);
 695                 goto xfrm_tunnel_mplsip_failed;
 696         }
 697 #endif
 698         err = rtnl_link_register(&ipip_link_ops);
 699         if (err < 0)
 700                 goto rtnl_link_failed;
 701
 702 out:
 703         return err;
 704
 705 rtnl_link_failed:
 706 #if IS_ENABLED(CONFIG_MPLS)
 707         xfrm4_tunnel_deregister(&mplsip_handler, AF_MPLS);
 708 xfrm_tunnel_mplsip_failed:
 709
 710 #endif
 711         xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
 712 xfrm_tunnel_ipip_failed:
 713         unregister_pernet_device(&ipip_net_ops);
 714         goto out;
 715 }
 716
 717 static void __exit ipip_fini(void)
 718 {
 719         rtnl_link_unregister(&ipip_link_ops);
 720         if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
 721                 pr_info("%s: can't deregister tunnel\n", __func__);
 722 #if IS_ENABLED(CONFIG_MPLS)
 723         if (xfrm4_tunnel_deregister(&mplsip_handler, AF_MPLS))
 724                 pr_info("%s: can't deregister tunnel\n", __func__);
 725 #endif
 726         unregister_pernet_device(&ipip_net_ops);
 727 }
 728
 729 module_init(ipip_init);
 730 module_exit(ipip_fini);
 731 MODULE_LICENSE("GPL");
 732 MODULE_ALIAS_RTNL_LINK("ipip");
 733 MODULE_ALIAS_NETDEV("tunl0");