net/ipv4/ip_gre.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *      Linux NET3:     GRE over IP protocol decoder.
   4  *
   5  *      Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
   6  */
   7
   8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9
  10 #include <linux/capability.h>
  11 #include <linux/module.h>
  12 #include <linux/types.h>
  13 #include <linux/kernel.h>
  14 #include <linux/slab.h>
  15 #include <linux/uaccess.h>
  16 #include <linux/skbuff.h>
  17 #include <linux/netdevice.h>
  18 #include <linux/in.h>
  19 #include <linux/tcp.h>
  20 #include <linux/udp.h>
  21 #include <linux/if_arp.h>
  22 #include <linux/if_vlan.h>
  23 #include <linux/init.h>
  24 #include <linux/in6.h>
  25 #include <linux/inetdevice.h>
  26 #include <linux/igmp.h>
  27 #include <linux/netfilter_ipv4.h>
  28 #include <linux/etherdevice.h>
  29 #include <linux/if_ether.h>
  30
  31 #include <net/sock.h>
  32 #include <net/ip.h>
  33 #include <net/icmp.h>
  34 #include <net/protocol.h>
  35 #include <net/ip_tunnels.h>
  36 #include <net/arp.h>
  37 #include <net/checksum.h>
  38 #include <net/dsfield.h>
  39 #include <net/inet_ecn.h>
  40 #include <net/xfrm.h>
  41 #include <net/net_namespace.h>
  42 #include <net/netns/generic.h>
  43 #include <net/rtnetlink.h>
  44 #include <net/gre.h>
  45 #include <net/dst_metadata.h>
  46 #include <net/erspan.h>
  47
  48 /*
  49    Problems & solutions
  50    --------------------
  51
  52    1. The most important issue is detecting local dead loops.
  53    They would cause complete host lockup in transmit, which
  54    would be "resolved" by stack overflow or, if queueing is enabled,
  55    with infinite looping in net_bh.
  56
  57    We cannot track such dead loops during route installation,
  58    it is infeasible task. The most general solutions would be
  59    to keep skb->encapsulation counter (sort of local ttl),
  60    and silently drop packet when it expires. It is a good
  61    solution, but it supposes maintaining new variable in ALL
  62    skb, even if no tunneling is used.
  63
  64    Current solution: xmit_recursion breaks dead loops. This is a percpu
  65    counter, since when we enter the first ndo_xmit(), cpu migration is
  66    forbidden. We force an exit if this counter reaches RECURSION_LIMIT
  67
  68    2. Networking dead loops would not kill routers, but would really
  69    kill network. IP hop limit plays role of "t->recursion" in this case,
  70    if we copy it from packet being encapsulated to upper header.
  71    It is very good solution, but it introduces two problems:
  72
  73    - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
  74      do not work over tunnels.
  75    - traceroute does not work. I planned to relay ICMP from tunnel,
  76      so that this problem would be solved and traceroute output
  77      would even more informative. This idea appeared to be wrong:
  78      only Linux complies to rfc1812 now (yes, guys, Linux is the only
  79      true router now :-)), all routers (at least, in neighbourhood of mine)
  80      return only 8 bytes of payload. It is the end.
  81
  82    Hence, if we want that OSPF worked or traceroute said something reasonable,
  83    we should search for another solution.
  84
  85    One of them is to parse packet trying to detect inner encapsulation
  86    made by our node. It is difficult or even impossible, especially,
  87    taking into account fragmentation. TO be short, ttl is not solution at all.
  88
  89    Current solution: The solution was UNEXPECTEDLY SIMPLE.
  90    We force DF flag on tunnels with preconfigured hop limit,
  91    that is ALL. :-) Well, it does not remove the problem completely,
  92    but exponential growth of network traffic is changed to linear
  93    (branches, that exceed pmtu are pruned) and tunnel mtu
  94    rapidly degrades to value <68, where looping stops.
  95    Yes, it is not good if there exists a router in the loop,
  96    which does not force DF, even when encapsulating packets have DF set.
  97    But it is not our problem! Nobody could accuse us, we made
  98    all that we could make. Even if it is your gated who injected
  99    fatal route to network, even if it were you who configured
 100    fatal static route: you are innocent. :-)
 101
 102    Alexey Kuznetsov.
 103  */
 104
 105 static bool log_ecn_error = true;
 106 module_param(log_ecn_error, bool, 0644);
 107 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
 108
 109 static struct rtnl_link_ops ipgre_link_ops __read_mostly;
 110 static int ipgre_tunnel_init(struct net_device *dev);
 111 static void erspan_build_header(struct sk_buff *skb,
 112                                 u32 id, u32 index,
 113                                 bool truncate, bool is_ipv4);
 114
 115 static unsigned int ipgre_net_id __read_mostly;
 116 static unsigned int gre_tap_net_id __read_mostly;
 117 static unsigned int erspan_net_id __read_mostly;
 118
 119 static int ipgre_err(struct sk_buff *skb, u32 info,
 120                      const struct tnl_ptk_info *tpi)
 121 {
 122
 123         /* All the routers (except for Linux) return only
 124            8 bytes of packet payload. It means, that precise relaying of
 125            ICMP in the real Internet is absolutely infeasible.
 126
 127            Moreover, Cisco "wise men" put GRE key to the third word
 128            in GRE header. It makes impossible maintaining even soft
 129            state for keyed GRE tunnels with enabled checksum. Tell
 130            them "thank you".
 131
 132            Well, I wonder, rfc1812 was written by Cisco employee,
 133            what the hell these idiots break standards established
 134            by themselves???
 135            */
 136         struct net *net = dev_net(skb->dev);
 137         struct ip_tunnel_net *itn;
 138         const struct iphdr *iph;
 139         const int type = icmp_hdr(skb)->type;
 140         const int code = icmp_hdr(skb)->code;
 141         unsigned int data_len = 0;
 142         struct ip_tunnel *t;
 143
 144         if (tpi->proto == htons(ETH_P_TEB))
 145                 itn = net_generic(net, gre_tap_net_id);
 146         else if (tpi->proto == htons(ETH_P_ERSPAN) ||
 147                  tpi->proto == htons(ETH_P_ERSPAN2))
 148                 itn = net_generic(net, erspan_net_id);
 149         else
 150                 itn = net_generic(net, ipgre_net_id);
 151
 152         iph = (const struct iphdr *)(icmp_hdr(skb) + 1);
 153         t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
 154                              iph->daddr, iph->saddr, tpi->key);
 155
 156         if (!t)
 157                 return -ENOENT;
 158
 159         switch (type) {
 160         default:
 161         case ICMP_PARAMETERPROB:
 162                 return 0;
 163
 164         case ICMP_DEST_UNREACH:
 165                 switch (code) {
 166                 case ICMP_SR_FAILED:
 167                 case ICMP_PORT_UNREACH:
 168                         /* Impossible event. */
 169                         return 0;
 170                 default:
 171                         /* All others are translated to HOST_UNREACH.
 172                            rfc2003 contains "deep thoughts" about NET_UNREACH,
 173                            I believe they are just ether pollution. --ANK
 174                          */
 175                         break;
 176                 }
 177                 break;
 178
 179         case ICMP_TIME_EXCEEDED:
 180                 if (code != ICMP_EXC_TTL)
 181                         return 0;
 182                 data_len = icmp_hdr(skb)->un.reserved[1] * 4; /* RFC 4884 4.1 */
 183                 break;
 184
 185         case ICMP_REDIRECT:
 186                 break;
 187         }
 188
 189 #if IS_ENABLED(CONFIG_IPV6)
 190        if (tpi->proto == htons(ETH_P_IPV6) &&
 191            !ip6_err_gen_icmpv6_unreach(skb, iph->ihl * 4 + tpi->hdr_len,
 192                                        type, data_len))
 193                return 0;
 194 #endif
 195
 196         if (t->parms.iph.daddr == 0 ||
 197             ipv4_is_multicast(t->parms.iph.daddr))
 198                 return 0;
 199
 200         if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
 201                 return 0;
 202
 203         if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
 204                 t->err_count++;
 205         else
 206                 t->err_count = 1;
 207         t->err_time = jiffies;
 208
 209         return 0;
 210 }
 211
 212 static void gre_err(struct sk_buff *skb, u32 info)
 213 {
 214         /* All the routers (except for Linux) return only
 215          * 8 bytes of packet payload. It means, that precise relaying of
 216          * ICMP in the real Internet is absolutely infeasible.
 217          *
 218          * Moreover, Cisco "wise men" put GRE key to the third word
 219          * in GRE header. It makes impossible maintaining even soft
 220          * state for keyed
 221          * GRE tunnels with enabled checksum. Tell them "thank you".
 222          *
 223          * Well, I wonder, rfc1812 was written by Cisco employee,
 224          * what the hell these idiots break standards established
 225          * by themselves???
 226          */
 227
 228         const struct iphdr *iph = (struct iphdr *)skb->data;
 229         const int type = icmp_hdr(skb)->type;
 230         const int code = icmp_hdr(skb)->code;
 231         struct tnl_ptk_info tpi;
 232
 233         if (gre_parse_header(skb, &tpi, NULL, htons(ETH_P_IP),
 234                              iph->ihl * 4) < 0)
 235                 return;
 236
 237         if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
 238                 ipv4_update_pmtu(skb, dev_net(skb->dev), info,
 239                                  skb->dev->ifindex, IPPROTO_GRE);
 240                 return;
 241         }
 242         if (type == ICMP_REDIRECT) {
 243                 ipv4_redirect(skb, dev_net(skb->dev), skb->dev->ifindex,
 244                               IPPROTO_GRE);
 245                 return;
 246         }
 247
 248         ipgre_err(skb, info, &tpi);
 249 }
 250
 251 static int erspan_rcv(struct sk_buff *skb, struct tnl_ptk_info *tpi,
 252                       int gre_hdr_len)
 253 {
 254         struct net *net = dev_net(skb->dev);
 255         struct metadata_dst *tun_dst = NULL;
 256         struct erspan_base_hdr *ershdr;
 257         struct ip_tunnel_net *itn;
 258         struct ip_tunnel *tunnel;
 259         const struct iphdr *iph;
 260         struct erspan_md2 *md2;
 261         int ver;
 262         int len;
 263
 264         itn = net_generic(net, erspan_net_id);
 265
 266         iph = ip_hdr(skb);
 267         ershdr = (struct erspan_base_hdr *)(skb->data + gre_hdr_len);
 268         ver = ershdr->ver;
 269
 270         tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex,
 271                                   tpi->flags | TUNNEL_KEY,
 272                                   iph->saddr, iph->daddr, tpi->key);
 273
 274         if (tunnel) {
 275                 len = gre_hdr_len + erspan_hdr_len(ver);
 276                 if (unlikely(!pskb_may_pull(skb, len)))
 277                         return PACKET_REJECT;
 278
 279                 if (__iptunnel_pull_header(skb,
 280                                            len,
 281                                            htons(ETH_P_TEB),
 282                                            false, false) < 0)
 283                         goto drop;
 284
 285                 if (tunnel->collect_md) {
 286                         struct erspan_metadata *pkt_md, *md;
 287                         struct ip_tunnel_info *info;
 288                         unsigned char *gh;
 289                         __be64 tun_id;
 290                         __be16 flags;
 291
 292                         tpi->flags |= TUNNEL_KEY;
 293                         flags = tpi->flags;
 294                         tun_id = key32_to_tunnel_id(tpi->key);
 295
 296                         tun_dst = ip_tun_rx_dst(skb, flags,
 297                                                 tun_id, sizeof(*md));
 298                         if (!tun_dst)
 299                                 return PACKET_REJECT;
 300
 301                         /* skb can be uncloned in __iptunnel_pull_header, so
 302                          * old pkt_md is no longer valid and we need to reset
 303                          * it
 304                          */
 305                         gh = skb_network_header(skb) +
 306                              skb_network_header_len(skb);
 307                         pkt_md = (struct erspan_metadata *)(gh + gre_hdr_len +
 308                                                             sizeof(*ershdr));
 309                         md = ip_tunnel_info_opts(&tun_dst->u.tun_info);
 310                         md->version = ver;
 311                         md2 = &md->u.md2;
 312                         memcpy(md2, pkt_md, ver == 1 ? ERSPAN_V1_MDSIZE :
 313                                                        ERSPAN_V2_MDSIZE);
 314
 315                         info = &tun_dst->u.tun_info;
 316                         info->key.tun_flags |= TUNNEL_ERSPAN_OPT;
 317                         info->options_len = sizeof(*md);
 318                 }
 319
 320                 skb_reset_mac_header(skb);
 321                 ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error);
 322                 return PACKET_RCVD;
 323         }
 324         return PACKET_REJECT;
 325
 326 drop:
 327         kfree_skb(skb);
 328         return PACKET_RCVD;
 329 }
 330
 331 static int __ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
 332                        struct ip_tunnel_net *itn, int hdr_len, bool raw_proto)
 333 {
 334         struct metadata_dst *tun_dst = NULL;
 335         const struct iphdr *iph;
 336         struct ip_tunnel *tunnel;
 337
 338         iph = ip_hdr(skb);
 339         tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
 340                                   iph->saddr, iph->daddr, tpi->key);
 341
 342         if (tunnel) {
 343                 if (__iptunnel_pull_header(skb, hdr_len, tpi->proto,
 344                                            raw_proto, false) < 0)
 345                         goto drop;
 346
 347                 if (tunnel->dev->type != ARPHRD_NONE)
 348                         skb_pop_mac_header(skb);
 349                 else
 350                         skb_reset_mac_header(skb);
 351                 if (tunnel->collect_md) {
 352                         __be16 flags;
 353                         __be64 tun_id;
 354
 355                         flags = tpi->flags & (TUNNEL_CSUM | TUNNEL_KEY);
 356                         tun_id = key32_to_tunnel_id(tpi->key);
 357                         tun_dst = ip_tun_rx_dst(skb, flags, tun_id, 0);
 358                         if (!tun_dst)
 359                                 return PACKET_REJECT;
 360                 }
 361
 362                 ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error);
 363                 return PACKET_RCVD;
 364         }
 365         return PACKET_NEXT;
 366
 367 drop:
 368         kfree_skb(skb);
 369         return PACKET_RCVD;
 370 }
 371
 372 static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
 373                      int hdr_len)
 374 {
 375         struct net *net = dev_net(skb->dev);
 376         struct ip_tunnel_net *itn;
 377         int res;
 378
 379         if (tpi->proto == htons(ETH_P_TEB))
 380                 itn = net_generic(net, gre_tap_net_id);
 381         else
 382                 itn = net_generic(net, ipgre_net_id);
 383
 384         res = __ipgre_rcv(skb, tpi, itn, hdr_len, false);
 385         if (res == PACKET_NEXT && tpi->proto == htons(ETH_P_TEB)) {
 386                 /* ipgre tunnels in collect metadata mode should receive
 387                  * also ETH_P_TEB traffic.
 388                  */
 389                 itn = net_generic(net, ipgre_net_id);
 390                 res = __ipgre_rcv(skb, tpi, itn, hdr_len, true);
 391         }
 392         return res;
 393 }
 394
 395 static int gre_rcv(struct sk_buff *skb)
 396 {
 397         struct tnl_ptk_info tpi;
 398         bool csum_err = false;
 399         int hdr_len;
 400
 401 #ifdef CONFIG_NET_IPGRE_BROADCAST
 402         if (ipv4_is_multicast(ip_hdr(skb)->daddr)) {
 403                 /* Looped back packet, drop it! */
 404                 if (rt_is_output_route(skb_rtable(skb)))
 405                         goto drop;
 406         }
 407 #endif
 408
 409         hdr_len = gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP), 0);
 410         if (hdr_len < 0)
 411                 goto drop;
 412
 413         if (unlikely(tpi.proto == htons(ETH_P_ERSPAN) ||
 414                      tpi.proto == htons(ETH_P_ERSPAN2))) {
 415                 if (erspan_rcv(skb, &tpi, hdr_len) == PACKET_RCVD)
 416                         return 0;
 417                 goto out;
 418         }
 419
 420         if (ipgre_rcv(skb, &tpi, hdr_len) == PACKET_RCVD)
 421                 return 0;
 422
 423 out:
 424         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
 425 drop:
 426         kfree_skb(skb);
 427         return 0;
 428 }
 429
 430 static void __gre_xmit(struct sk_buff *skb, struct net_device *dev,
 431                        const struct iphdr *tnl_params,
 432                        __be16 proto)
 433 {
 434         struct ip_tunnel *tunnel = netdev_priv(dev);
 435         __be16 flags = tunnel->parms.o_flags;
 436
 437         /* Push GRE header. */
 438         gre_build_header(skb, tunnel->tun_hlen,
 439                          flags, proto, tunnel->parms.o_key,
 440                          (flags & TUNNEL_SEQ) ? htonl(atomic_fetch_inc(&tunnel->o_seqno)) : 0);
 441
 442         ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol);
 443 }
 444
 445 static int gre_handle_offloads(struct sk_buff *skb, bool csum)
 446 {
 447         return iptunnel_handle_offloads(skb, csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE);
 448 }
 449
 450 static void gre_fb_xmit(struct sk_buff *skb, struct net_device *dev,
 451                         __be16 proto)
 452 {
 453         struct ip_tunnel *tunnel = netdev_priv(dev);
 454         struct ip_tunnel_info *tun_info;
 455         const struct ip_tunnel_key *key;
 456         int tunnel_hlen;
 457         __be16 flags;
 458
 459         tun_info = skb_tunnel_info(skb);
 460         if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
 461                      ip_tunnel_info_af(tun_info) != AF_INET))
 462                 goto err_free_skb;
 463
 464         key = &tun_info->key;
 465         tunnel_hlen = gre_calc_hlen(key->tun_flags);
 466
 467         if (skb_cow_head(skb, dev->needed_headroom))
 468                 goto err_free_skb;
 469
 470         /* Push Tunnel header. */
 471         if (gre_handle_offloads(skb, !!(tun_info->key.tun_flags & TUNNEL_CSUM)))
 472                 goto err_free_skb;
 473
 474         flags = tun_info->key.tun_flags &
 475                 (TUNNEL_CSUM | TUNNEL_KEY | TUNNEL_SEQ);
 476         gre_build_header(skb, tunnel_hlen, flags, proto,
 477                          tunnel_id_to_key32(tun_info->key.tun_id),
 478                          (flags & TUNNEL_SEQ) ? htonl(atomic_fetch_inc(&tunnel->o_seqno)) : 0);
 479
 480         ip_md_tunnel_xmit(skb, dev, IPPROTO_GRE, tunnel_hlen);
 481
 482         return;
 483
 484 err_free_skb:
 485         kfree_skb(skb);
 486         dev->stats.tx_dropped++;
 487 }
 488
 489 static void erspan_fb_xmit(struct sk_buff *skb, struct net_device *dev)
 490 {
 491         struct ip_tunnel *tunnel = netdev_priv(dev);
 492         struct ip_tunnel_info *tun_info;
 493         const struct ip_tunnel_key *key;
 494         struct erspan_metadata *md;
 495         bool truncate = false;
 496         __be16 proto;
 497         int tunnel_hlen;
 498         int version;
 499         int nhoff;
 500
 501         tun_info = skb_tunnel_info(skb);
 502         if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
 503                      ip_tunnel_info_af(tun_info) != AF_INET))
 504                 goto err_free_skb;
 505
 506         key = &tun_info->key;
 507         if (!(tun_info->key.tun_flags & TUNNEL_ERSPAN_OPT))
 508                 goto err_free_skb;
 509         if (tun_info->options_len < sizeof(*md))
 510                 goto err_free_skb;
 511         md = ip_tunnel_info_opts(tun_info);
 512
 513         /* ERSPAN has fixed 8 byte GRE header */
 514         version = md->version;
 515         tunnel_hlen = 8 + erspan_hdr_len(version);
 516
 517         if (skb_cow_head(skb, dev->needed_headroom))
 518                 goto err_free_skb;
 519
 520         if (gre_handle_offloads(skb, false))
 521                 goto err_free_skb;
 522
 523         if (skb->len > dev->mtu + dev->hard_header_len) {
 524                 pskb_trim(skb, dev->mtu + dev->hard_header_len);
 525                 truncate = true;
 526         }
 527
 528         nhoff = skb_network_offset(skb);
 529         if (skb->protocol == htons(ETH_P_IP) &&
 530             (ntohs(ip_hdr(skb)->tot_len) > skb->len - nhoff))
 531                 truncate = true;
 532
 533         if (skb->protocol == htons(ETH_P_IPV6)) {
 534                 int thoff;
 535
 536                 if (skb_transport_header_was_set(skb))
 537                         thoff = skb_transport_offset(skb);
 538                 else
 539                         thoff = nhoff + sizeof(struct ipv6hdr);
 540                 if (ntohs(ipv6_hdr(skb)->payload_len) > skb->len - thoff)
 541                         truncate = true;
 542         }
 543
 544         if (version == 1) {
 545                 erspan_build_header(skb, ntohl(tunnel_id_to_key32(key->tun_id)),
 546                                     ntohl(md->u.index), truncate, true);
 547                 proto = htons(ETH_P_ERSPAN);
 548         } else if (version == 2) {
 549                 erspan_build_header_v2(skb,
 550                                        ntohl(tunnel_id_to_key32(key->tun_id)),
 551                                        md->u.md2.dir,
 552                                        get_hwid(&md->u.md2),
 553                                        truncate, true);
 554                 proto = htons(ETH_P_ERSPAN2);
 555         } else {
 556                 goto err_free_skb;
 557         }
 558
 559         gre_build_header(skb, 8, TUNNEL_SEQ,
 560                          proto, 0, htonl(atomic_fetch_inc(&tunnel->o_seqno)));
 561
 562         ip_md_tunnel_xmit(skb, dev, IPPROTO_GRE, tunnel_hlen);
 563
 564         return;
 565
 566 err_free_skb:
 567         kfree_skb(skb);
 568         dev->stats.tx_dropped++;
 569 }
 570
 571 static int gre_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
 572 {
 573         struct ip_tunnel_info *info = skb_tunnel_info(skb);
 574         const struct ip_tunnel_key *key;
 575         struct rtable *rt;
 576         struct flowi4 fl4;
 577
 578         if (ip_tunnel_info_af(info) != AF_INET)
 579                 return -EINVAL;
 580
 581         key = &info->key;
 582         ip_tunnel_init_flow(&fl4, IPPROTO_GRE, key->u.ipv4.dst, key->u.ipv4.src,
 583                             tunnel_id_to_key32(key->tun_id),
 584                             key->tos & ~INET_ECN_MASK, 0, skb->mark,
 585                             skb_get_hash(skb));
 586         rt = ip_route_output_key(dev_net(dev), &fl4);
 587         if (IS_ERR(rt))
 588                 return PTR_ERR(rt);
 589
 590         ip_rt_put(rt);
 591         info->key.u.ipv4.src = fl4.saddr;
 592         return 0;
 593 }
 594
 595 static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
 596                               struct net_device *dev)
 597 {
 598         struct ip_tunnel *tunnel = netdev_priv(dev);
 599         const struct iphdr *tnl_params;
 600
 601         if (!pskb_inet_may_pull(skb))
 602                 goto free_skb;
 603
 604         if (tunnel->collect_md) {
 605                 gre_fb_xmit(skb, dev, skb->protocol);
 606                 return NETDEV_TX_OK;
 607         }
 608
 609         if (dev->header_ops) {
 610                 if (skb_cow_head(skb, 0))
 611                         goto free_skb;
 612
 613                 tnl_params = (const struct iphdr *)skb->data;
 614
 615                 /* Pull skb since ip_tunnel_xmit() needs skb->data pointing
 616                  * to gre header.
 617                  */
 618                 skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
 619                 skb_reset_mac_header(skb);
 620
 621                 if (skb->ip_summed == CHECKSUM_PARTIAL &&
 622                     skb_checksum_start(skb) < skb->data)
 623                         goto free_skb;
 624         } else {
 625                 if (skb_cow_head(skb, dev->needed_headroom))
 626                         goto free_skb;
 627
 628                 tnl_params = &tunnel->parms.iph;
 629         }
 630
 631         if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
 632                 goto free_skb;
 633
 634         __gre_xmit(skb, dev, tnl_params, skb->protocol);
 635         return NETDEV_TX_OK;
 636
 637 free_skb:
 638         kfree_skb(skb);
 639         dev->stats.tx_dropped++;
 640         return NETDEV_TX_OK;
 641 }
 642
 643 static netdev_tx_t erspan_xmit(struct sk_buff *skb,
 644                                struct net_device *dev)
 645 {
 646         struct ip_tunnel *tunnel = netdev_priv(dev);
 647         bool truncate = false;
 648         __be16 proto;
 649
 650         if (!pskb_inet_may_pull(skb))
 651                 goto free_skb;
 652
 653         if (tunnel->collect_md) {
 654                 erspan_fb_xmit(skb, dev);
 655                 return NETDEV_TX_OK;
 656         }
 657
 658         if (gre_handle_offloads(skb, false))
 659                 goto free_skb;
 660
 661         if (skb_cow_head(skb, dev->needed_headroom))
 662                 goto free_skb;
 663
 664         if (skb->len > dev->mtu + dev->hard_header_len) {
 665                 pskb_trim(skb, dev->mtu + dev->hard_header_len);
 666                 truncate = true;
 667         }
 668
 669         /* Push ERSPAN header */
 670         if (tunnel->erspan_ver == 1) {
 671                 erspan_build_header(skb, ntohl(tunnel->parms.o_key),
 672                                     tunnel->index,
 673                                     truncate, true);
 674                 proto = htons(ETH_P_ERSPAN);
 675         } else if (tunnel->erspan_ver == 2) {
 676                 erspan_build_header_v2(skb, ntohl(tunnel->parms.o_key),
 677                                        tunnel->dir, tunnel->hwid,
 678                                        truncate, true);
 679                 proto = htons(ETH_P_ERSPAN2);
 680         } else {
 681                 goto free_skb;
 682         }
 683
 684         tunnel->parms.o_flags &= ~TUNNEL_KEY;
 685         __gre_xmit(skb, dev, &tunnel->parms.iph, proto);
 686         return NETDEV_TX_OK;
 687
 688 free_skb:
 689         kfree_skb(skb);
 690         dev->stats.tx_dropped++;
 691         return NETDEV_TX_OK;
 692 }
 693
 694 static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
 695                                 struct net_device *dev)
 696 {
 697         struct ip_tunnel *tunnel = netdev_priv(dev);
 698
 699         if (!pskb_inet_may_pull(skb))
 700                 goto free_skb;
 701
 702         if (tunnel->collect_md) {
 703                 gre_fb_xmit(skb, dev, htons(ETH_P_TEB));
 704                 return NETDEV_TX_OK;
 705         }
 706
 707         if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
 708                 goto free_skb;
 709
 710         if (skb_cow_head(skb, dev->needed_headroom))
 711                 goto free_skb;
 712
 713         __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
 714         return NETDEV_TX_OK;
 715
 716 free_skb:
 717         kfree_skb(skb);
 718         dev->stats.tx_dropped++;
 719         return NETDEV_TX_OK;
 720 }
 721
 722 static void ipgre_link_update(struct net_device *dev, bool set_mtu)
 723 {
 724         struct ip_tunnel *tunnel = netdev_priv(dev);
 725         int len;
 726
 727         len = tunnel->tun_hlen;
 728         tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
 729         len = tunnel->tun_hlen - len;
 730         tunnel->hlen = tunnel->hlen + len;
 731
 732         if (dev->header_ops)
 733                 dev->hard_header_len += len;
 734         else
 735                 dev->needed_headroom += len;
 736
 737         if (set_mtu)
 738                 dev->mtu = max_t(int, dev->mtu - len, 68);
 739
 740         if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
 741                 if (!(tunnel->parms.o_flags & TUNNEL_CSUM) ||
 742                     tunnel->encap.type == TUNNEL_ENCAP_NONE) {
 743                         dev->features |= NETIF_F_GSO_SOFTWARE;
 744                         dev->hw_features |= NETIF_F_GSO_SOFTWARE;
 745                 } else {
 746                         dev->features &= ~NETIF_F_GSO_SOFTWARE;
 747                         dev->hw_features &= ~NETIF_F_GSO_SOFTWARE;
 748                 }
 749                 dev->features |= NETIF_F_LLTX;
 750         } else {
 751                 dev->hw_features &= ~NETIF_F_GSO_SOFTWARE;
 752                 dev->features &= ~(NETIF_F_LLTX | NETIF_F_GSO_SOFTWARE);
 753         }
 754 }
 755
 756 static int ipgre_tunnel_ioctl(struct net_device *dev,
 757                               struct ifreq *ifr, int cmd)
 758 {
 759         struct ip_tunnel_parm p;
 760         int err;
 761
 762         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 763                 return -EFAULT;
 764
 765         if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
 766                 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
 767                     p.iph.ihl != 5 || (p.iph.frag_off & htons(~IP_DF)) ||
 768                     ((p.i_flags | p.o_flags) & (GRE_VERSION | GRE_ROUTING)))
 769                         return -EINVAL;
 770         }
 771
 772         p.i_flags = gre_flags_to_tnl_flags(p.i_flags);
 773         p.o_flags = gre_flags_to_tnl_flags(p.o_flags);
 774
 775         err = ip_tunnel_ioctl(dev, &p, cmd);
 776         if (err)
 777                 return err;
 778
 779         if (cmd == SIOCCHGTUNNEL) {
 780                 struct ip_tunnel *t = netdev_priv(dev);
 781
 782                 t->parms.i_flags = p.i_flags;
 783                 t->parms.o_flags = p.o_flags;
 784
 785                 if (strcmp(dev->rtnl_link_ops->kind, "erspan"))
 786                         ipgre_link_update(dev, true);
 787         }
 788
 789         p.i_flags = gre_tnl_flags_to_gre_flags(p.i_flags);
 790         p.o_flags = gre_tnl_flags_to_gre_flags(p.o_flags);
 791
 792         if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
 793                 return -EFAULT;
 794
 795         return 0;
 796 }
 797
 798 /* Nice toy. Unfortunately, useless in real life :-)
 799    It allows to construct virtual multiprotocol broadcast "LAN"
 800    over the Internet, provided multicast routing is tuned.
 801
 802
 803    I have no idea was this bicycle invented before me,
 804    so that I had to set ARPHRD_IPGRE to a random value.
 805    I have an impression, that Cisco could make something similar,
 806    but this feature is apparently missing in IOS<=11.2(8).
 807
 808    I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
 809    with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
 810
 811    ping -t 255 224.66.66.66
 812
 813    If nobody answers, mbone does not work.
 814
 815    ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
 816    ip addr add 10.66.66.<somewhat>/24 dev Universe
 817    ifconfig Universe up
 818    ifconfig Universe add fe80::<Your_real_addr>/10
 819    ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
 820    ftp 10.66.66.66
 821    ...
 822    ftp fec0:6666:6666::193.233.7.65
 823    ...
 824  */
 825 static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
 826                         unsigned short type,
 827                         const void *daddr, const void *saddr, unsigned int len)
 828 {
 829         struct ip_tunnel *t = netdev_priv(dev);
 830         struct iphdr *iph;
 831         struct gre_base_hdr *greh;
 832
 833         iph = skb_push(skb, t->hlen + sizeof(*iph));
 834         greh = (struct gre_base_hdr *)(iph+1);
 835         greh->flags = gre_tnl_flags_to_gre_flags(t->parms.o_flags);
 836         greh->protocol = htons(type);
 837
 838         memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
 839
 840         /* Set the source hardware address. */
 841         if (saddr)
 842                 memcpy(&iph->saddr, saddr, 4);
 843         if (daddr)
 844                 memcpy(&iph->daddr, daddr, 4);
 845         if (iph->daddr)
 846                 return t->hlen + sizeof(*iph);
 847
 848         return -(t->hlen + sizeof(*iph));
 849 }
 850
 851 static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
 852 {
 853         const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
 854         memcpy(haddr, &iph->saddr, 4);
 855         return 4;
 856 }
 857
 858 static const struct header_ops ipgre_header_ops = {
 859         .create = ipgre_header,
 860         .parse  = ipgre_header_parse,
 861 };
 862
 863 #ifdef CONFIG_NET_IPGRE_BROADCAST
 864 static int ipgre_open(struct net_device *dev)
 865 {
 866         struct ip_tunnel *t = netdev_priv(dev);
 867
 868         if (ipv4_is_multicast(t->parms.iph.daddr)) {
 869                 struct flowi4 fl4;
 870                 struct rtable *rt;
 871
 872                 rt = ip_route_output_gre(t->net, &fl4,
 873                                          t->parms.iph.daddr,
 874                                          t->parms.iph.saddr,
 875                                          t->parms.o_key,
 876                                          RT_TOS(t->parms.iph.tos),
 877                                          t->parms.link);
 878                 if (IS_ERR(rt))
 879                         return -EADDRNOTAVAIL;
 880                 dev = rt->dst.dev;
 881                 ip_rt_put(rt);
 882                 if (!__in_dev_get_rtnl(dev))
 883                         return -EADDRNOTAVAIL;
 884                 t->mlink = dev->ifindex;
 885                 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
 886         }
 887         return 0;
 888 }
 889
 890 static int ipgre_close(struct net_device *dev)
 891 {
 892         struct ip_tunnel *t = netdev_priv(dev);
 893
 894         if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
 895                 struct in_device *in_dev;
 896                 in_dev = inetdev_by_index(t->net, t->mlink);
 897                 if (in_dev)
 898                         ip_mc_dec_group(in_dev, t->parms.iph.daddr);
 899         }
 900         return 0;
 901 }
 902 #endif
 903
 904 static const struct net_device_ops ipgre_netdev_ops = {
 905         .ndo_init               = ipgre_tunnel_init,
 906         .ndo_uninit             = ip_tunnel_uninit,
 907 #ifdef CONFIG_NET_IPGRE_BROADCAST
 908         .ndo_open               = ipgre_open,
 909         .ndo_stop               = ipgre_close,
 910 #endif
 911         .ndo_start_xmit         = ipgre_xmit,
 912         .ndo_do_ioctl           = ipgre_tunnel_ioctl,
 913         .ndo_change_mtu         = ip_tunnel_change_mtu,
 914         .ndo_get_stats64        = ip_tunnel_get_stats64,
 915         .ndo_get_iflink         = ip_tunnel_get_iflink,
 916 };
 917
 918 #define GRE_FEATURES (NETIF_F_SG |              \
 919                       NETIF_F_FRAGLIST |        \
 920                       NETIF_F_HIGHDMA |         \
 921                       NETIF_F_HW_CSUM)
 922
 923 static void ipgre_tunnel_setup(struct net_device *dev)
 924 {
 925         dev->netdev_ops         = &ipgre_netdev_ops;
 926         dev->type               = ARPHRD_IPGRE;
 927         ip_tunnel_setup(dev, ipgre_net_id);
 928 }
 929
 930 static void __gre_tunnel_init(struct net_device *dev)
 931 {
 932         struct ip_tunnel *tunnel;
 933
 934         tunnel = netdev_priv(dev);
 935         tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
 936         tunnel->parms.iph.protocol = IPPROTO_GRE;
 937
 938         tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
 939         dev->needed_headroom = tunnel->hlen + sizeof(tunnel->parms.iph);
 940
 941         dev->features           |= GRE_FEATURES;
 942         dev->hw_features        |= GRE_FEATURES;
 943
 944         if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
 945                 /* TCP offload with GRE SEQ is not supported, nor
 946                  * can we support 2 levels of outer headers requiring
 947                  * an update.
 948                  */
 949                 if (!(tunnel->parms.o_flags & TUNNEL_CSUM) ||
 950                     (tunnel->encap.type == TUNNEL_ENCAP_NONE)) {
 951                         dev->features    |= NETIF_F_GSO_SOFTWARE;
 952                         dev->hw_features |= NETIF_F_GSO_SOFTWARE;
 953                 }
 954
 955                 /* Can use a lockless transmit, unless we generate
 956                  * output sequences
 957                  */
 958                 dev->features |= NETIF_F_LLTX;
 959         }
 960 }
 961
 962 static int ipgre_tunnel_init(struct net_device *dev)
 963 {
 964         struct ip_tunnel *tunnel = netdev_priv(dev);
 965         struct iphdr *iph = &tunnel->parms.iph;
 966
 967         __gre_tunnel_init(dev);
 968
 969         memcpy(dev->dev_addr, &iph->saddr, 4);
 970         memcpy(dev->broadcast, &iph->daddr, 4);
 971
 972         dev->flags              = IFF_NOARP;
 973         netif_keep_dst(dev);
 974         dev->addr_len           = 4;
 975
 976         if (iph->daddr && !tunnel->collect_md) {
 977 #ifdef CONFIG_NET_IPGRE_BROADCAST
 978                 if (ipv4_is_multicast(iph->daddr)) {
 979                         if (!iph->saddr)
 980                                 return -EINVAL;
 981                         dev->flags = IFF_BROADCAST;
 982                         dev->header_ops = &ipgre_header_ops;
 983                         dev->hard_header_len = tunnel->hlen + sizeof(*iph);
 984                         dev->needed_headroom = 0;
 985                 }
 986 #endif
 987         } else if (!tunnel->collect_md) {
 988                 dev->header_ops = &ipgre_header_ops;
 989                 dev->hard_header_len = tunnel->hlen + sizeof(*iph);
 990                 dev->needed_headroom = 0;
 991         }
 992
 993         return ip_tunnel_init(dev);
 994 }
 995
 996 static const struct gre_protocol ipgre_protocol = {
 997         .handler     = gre_rcv,
 998         .err_handler = gre_err,
 999 };
1000
1001 static int __net_init ipgre_init_net(struct net *net)
1002 {
1003         return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
1004 }
1005
1006 static void __net_exit ipgre_exit_batch_net(struct list_head *list_net)
1007 {
1008         ip_tunnel_delete_nets(list_net, ipgre_net_id, &ipgre_link_ops);
1009 }
1010
1011 static struct pernet_operations ipgre_net_ops = {
1012         .init = ipgre_init_net,
1013         .exit_batch = ipgre_exit_batch_net,
1014         .id   = &ipgre_net_id,
1015         .size = sizeof(struct ip_tunnel_net),
1016 };
1017
1018 static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[],
1019                                  struct netlink_ext_ack *extack)
1020 {
1021         __be16 flags;
1022
1023         if (!data)
1024                 return 0;
1025
1026         flags = 0;
1027         if (data[IFLA_GRE_IFLAGS])
1028                 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1029         if (data[IFLA_GRE_OFLAGS])
1030                 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1031         if (flags & (GRE_VERSION|GRE_ROUTING))
1032                 return -EINVAL;
1033
1034         if (data[IFLA_GRE_COLLECT_METADATA] &&
1035             data[IFLA_GRE_ENCAP_TYPE] &&
1036             nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]) != TUNNEL_ENCAP_NONE)
1037                 return -EINVAL;
1038
1039         return 0;
1040 }
1041
1042 static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[],
1043                               struct netlink_ext_ack *extack)
1044 {
1045         __be32 daddr;
1046
1047         if (tb[IFLA_ADDRESS]) {
1048                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1049                         return -EINVAL;
1050                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1051                         return -EADDRNOTAVAIL;
1052         }
1053
1054         if (!data)
1055                 goto out;
1056
1057         if (data[IFLA_GRE_REMOTE]) {
1058                 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
1059                 if (!daddr)
1060                         return -EINVAL;
1061         }
1062
1063 out:
1064         return ipgre_tunnel_validate(tb, data, extack);
1065 }
1066
1067 static int erspan_validate(struct nlattr *tb[], struct nlattr *data[],
1068                            struct netlink_ext_ack *extack)
1069 {
1070         __be16 flags = 0;
1071         int ret;
1072
1073         if (!data)
1074                 return 0;
1075
1076         ret = ipgre_tap_validate(tb, data, extack);
1077         if (ret)
1078                 return ret;
1079
1080         /* ERSPAN should only have GRE sequence and key flag */
1081         if (data[IFLA_GRE_OFLAGS])
1082                 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1083         if (data[IFLA_GRE_IFLAGS])
1084                 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1085         if (!data[IFLA_GRE_COLLECT_METADATA] &&
1086             flags != (GRE_SEQ | GRE_KEY))
1087                 return -EINVAL;
1088
1089         /* ERSPAN Session ID only has 10-bit. Since we reuse
1090          * 32-bit key field as ID, check it's range.
1091          */
1092         if (data[IFLA_GRE_IKEY] &&
1093             (ntohl(nla_get_be32(data[IFLA_GRE_IKEY])) & ~ID_MASK))
1094                 return -EINVAL;
1095
1096         if (data[IFLA_GRE_OKEY] &&
1097             (ntohl(nla_get_be32(data[IFLA_GRE_OKEY])) & ~ID_MASK))
1098                 return -EINVAL;
1099
1100         return 0;
1101 }
1102
1103 static int ipgre_netlink_parms(struct net_device *dev,
1104                                 struct nlattr *data[],
1105                                 struct nlattr *tb[],
1106                                 struct ip_tunnel_parm *parms,
1107                                 __u32 *fwmark)
1108 {
1109         struct ip_tunnel *t = netdev_priv(dev);
1110
1111         memset(parms, 0, sizeof(*parms));
1112
1113         parms->iph.protocol = IPPROTO_GRE;
1114
1115         if (!data)
1116                 return 0;
1117
1118         if (data[IFLA_GRE_LINK])
1119                 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
1120
1121         if (data[IFLA_GRE_IFLAGS])
1122                 parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
1123
1124         if (data[IFLA_GRE_OFLAGS])
1125                 parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
1126
1127         if (data[IFLA_GRE_IKEY])
1128                 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
1129
1130         if (data[IFLA_GRE_OKEY])
1131                 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
1132
1133         if (data[IFLA_GRE_LOCAL])
1134                 parms->iph.saddr = nla_get_in_addr(data[IFLA_GRE_LOCAL]);
1135
1136         if (data[IFLA_GRE_REMOTE])
1137                 parms->iph.daddr = nla_get_in_addr(data[IFLA_GRE_REMOTE]);
1138
1139         if (data[IFLA_GRE_TTL])
1140                 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
1141
1142         if (data[IFLA_GRE_TOS])
1143                 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
1144
1145         if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC])) {
1146                 if (t->ignore_df)
1147                         return -EINVAL;
1148                 parms->iph.frag_off = htons(IP_DF);
1149         }
1150
1151         if (data[IFLA_GRE_COLLECT_METADATA]) {
1152                 t->collect_md = true;
1153                 if (dev->type == ARPHRD_IPGRE)
1154                         dev->type = ARPHRD_NONE;
1155         }
1156
1157         if (data[IFLA_GRE_IGNORE_DF]) {
1158                 if (nla_get_u8(data[IFLA_GRE_IGNORE_DF])
1159                   && (parms->iph.frag_off & htons(IP_DF)))
1160                         return -EINVAL;
1161                 t->ignore_df = !!nla_get_u8(data[IFLA_GRE_IGNORE_DF]);
1162         }
1163
1164         if (data[IFLA_GRE_FWMARK])
1165                 *fwmark = nla_get_u32(data[IFLA_GRE_FWMARK]);
1166
1167         return 0;
1168 }
1169
1170 static int erspan_netlink_parms(struct net_device *dev,
1171                                 struct nlattr *data[],
1172                                 struct nlattr *tb[],
1173                                 struct ip_tunnel_parm *parms,
1174                                 __u32 *fwmark)
1175 {
1176         struct ip_tunnel *t = netdev_priv(dev);
1177         int err;
1178
1179         err = ipgre_netlink_parms(dev, data, tb, parms, fwmark);
1180         if (err)
1181                 return err;
1182         if (!data)
1183                 return 0;
1184
1185         if (data[IFLA_GRE_ERSPAN_VER]) {
1186                 t->erspan_ver = nla_get_u8(data[IFLA_GRE_ERSPAN_VER]);
1187
1188                 if (t->erspan_ver != 1 && t->erspan_ver != 2)
1189                         return -EINVAL;
1190         }
1191
1192         if (t->erspan_ver == 1) {
1193                 if (data[IFLA_GRE_ERSPAN_INDEX]) {
1194                         t->index = nla_get_u32(data[IFLA_GRE_ERSPAN_INDEX]);
1195                         if (t->index & ~INDEX_MASK)
1196                                 return -EINVAL;
1197                 }
1198         } else if (t->erspan_ver == 2) {
1199                 if (data[IFLA_GRE_ERSPAN_DIR]) {
1200                         t->dir = nla_get_u8(data[IFLA_GRE_ERSPAN_DIR]);
1201                         if (t->dir & ~(DIR_MASK >> DIR_OFFSET))
1202                                 return -EINVAL;
1203                 }
1204                 if (data[IFLA_GRE_ERSPAN_HWID]) {
1205                         t->hwid = nla_get_u16(data[IFLA_GRE_ERSPAN_HWID]);
1206                         if (t->hwid & ~(HWID_MASK >> HWID_OFFSET))
1207                                 return -EINVAL;
1208                 }
1209         }
1210
1211         return 0;
1212 }
1213
1214 /* This function returns true when ENCAP attributes are present in the nl msg */
1215 static bool ipgre_netlink_encap_parms(struct nlattr *data[],
1216                                       struct ip_tunnel_encap *ipencap)
1217 {
1218         bool ret = false;
1219
1220         memset(ipencap, 0, sizeof(*ipencap));
1221
1222         if (!data)
1223                 return ret;
1224
1225         if (data[IFLA_GRE_ENCAP_TYPE]) {
1226                 ret = true;
1227                 ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]);
1228         }
1229
1230         if (data[IFLA_GRE_ENCAP_FLAGS]) {
1231                 ret = true;
1232                 ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]);
1233         }
1234
1235         if (data[IFLA_GRE_ENCAP_SPORT]) {
1236                 ret = true;
1237                 ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]);
1238         }
1239
1240         if (data[IFLA_GRE_ENCAP_DPORT]) {
1241                 ret = true;
1242                 ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]);
1243         }
1244
1245         return ret;
1246 }
1247
1248 static int gre_tap_init(struct net_device *dev)
1249 {
1250         __gre_tunnel_init(dev);
1251         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
1252         netif_keep_dst(dev);
1253
1254         return ip_tunnel_init(dev);
1255 }
1256
1257 static const struct net_device_ops gre_tap_netdev_ops = {
1258         .ndo_init               = gre_tap_init,
1259         .ndo_uninit             = ip_tunnel_uninit,
1260         .ndo_start_xmit         = gre_tap_xmit,
1261         .ndo_set_mac_address    = eth_mac_addr,
1262         .ndo_validate_addr      = eth_validate_addr,
1263         .ndo_change_mtu         = ip_tunnel_change_mtu,
1264         .ndo_get_stats64        = ip_tunnel_get_stats64,
1265         .ndo_get_iflink         = ip_tunnel_get_iflink,
1266         .ndo_fill_metadata_dst  = gre_fill_metadata_dst,
1267 };
1268
1269 static int erspan_tunnel_init(struct net_device *dev)
1270 {
1271         struct ip_tunnel *tunnel = netdev_priv(dev);
1272
1273         tunnel->tun_hlen = 8;
1274         tunnel->parms.iph.protocol = IPPROTO_GRE;
1275         tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen +
1276                        erspan_hdr_len(tunnel->erspan_ver);
1277
1278         dev->features           |= GRE_FEATURES;
1279         dev->hw_features        |= GRE_FEATURES;
1280         dev->priv_flags         |= IFF_LIVE_ADDR_CHANGE;
1281         netif_keep_dst(dev);
1282
1283         return ip_tunnel_init(dev);
1284 }
1285
1286 static const struct net_device_ops erspan_netdev_ops = {
1287         .ndo_init               = erspan_tunnel_init,
1288         .ndo_uninit             = ip_tunnel_uninit,
1289         .ndo_start_xmit         = erspan_xmit,
1290         .ndo_set_mac_address    = eth_mac_addr,
1291         .ndo_validate_addr      = eth_validate_addr,
1292         .ndo_change_mtu         = ip_tunnel_change_mtu,
1293         .ndo_get_stats64        = ip_tunnel_get_stats64,
1294         .ndo_get_iflink         = ip_tunnel_get_iflink,
1295         .ndo_fill_metadata_dst  = gre_fill_metadata_dst,
1296 };
1297
1298 static void ipgre_tap_setup(struct net_device *dev)
1299 {
1300         ether_setup(dev);
1301         dev->max_mtu = 0;
1302         dev->netdev_ops = &gre_tap_netdev_ops;
1303         dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1304         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
1305         ip_tunnel_setup(dev, gre_tap_net_id);
1306 }
1307
1308 static int
1309 ipgre_newlink_encap_setup(struct net_device *dev, struct nlattr *data[])
1310 {
1311         struct ip_tunnel_encap ipencap;
1312
1313         if (ipgre_netlink_encap_parms(data, &ipencap)) {
1314                 struct ip_tunnel *t = netdev_priv(dev);
1315                 int err = ip_tunnel_encap_setup(t, &ipencap);
1316
1317                 if (err < 0)
1318                         return err;
1319         }
1320
1321         return 0;
1322 }
1323
1324 static int ipgre_newlink(struct net *src_net, struct net_device *dev,
1325                          struct nlattr *tb[], struct nlattr *data[],
1326                          struct netlink_ext_ack *extack)
1327 {
1328         struct ip_tunnel_parm p;
1329         __u32 fwmark = 0;
1330         int err;
1331
1332         err = ipgre_newlink_encap_setup(dev, data);
1333         if (err)
1334                 return err;
1335
1336         err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark);
1337         if (err < 0)
1338                 return err;
1339         return ip_tunnel_newlink(dev, tb, &p, fwmark);
1340 }
1341
1342 static int erspan_newlink(struct net *src_net, struct net_device *dev,
1343                           struct nlattr *tb[], struct nlattr *data[],
1344                           struct netlink_ext_ack *extack)
1345 {
1346         struct ip_tunnel_parm p;
1347         __u32 fwmark = 0;
1348         int err;
1349
1350         err = ipgre_newlink_encap_setup(dev, data);
1351         if (err)
1352                 return err;
1353
1354         err = erspan_netlink_parms(dev, data, tb, &p, &fwmark);
1355         if (err)
1356                 return err;
1357         return ip_tunnel_newlink(dev, tb, &p, fwmark);
1358 }
1359
1360 static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
1361                             struct nlattr *data[],
1362                             struct netlink_ext_ack *extack)
1363 {
1364         struct ip_tunnel *t = netdev_priv(dev);
1365         __u32 fwmark = t->fwmark;
1366         struct ip_tunnel_parm p;
1367         int err;
1368
1369         err = ipgre_newlink_encap_setup(dev, data);
1370         if (err)
1371                 return err;
1372
1373         err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark);
1374         if (err < 0)
1375                 return err;
1376
1377         err = ip_tunnel_changelink(dev, tb, &p, fwmark);
1378         if (err < 0)
1379                 return err;
1380
1381         t->parms.i_flags = p.i_flags;
1382         t->parms.o_flags = p.o_flags;
1383
1384         ipgre_link_update(dev, !tb[IFLA_MTU]);
1385
1386         return 0;
1387 }
1388
1389 static int erspan_changelink(struct net_device *dev, struct nlattr *tb[],
1390                              struct nlattr *data[],
1391                              struct netlink_ext_ack *extack)
1392 {
1393         struct ip_tunnel *t = netdev_priv(dev);
1394         __u32 fwmark = t->fwmark;
1395         struct ip_tunnel_parm p;
1396         int err;
1397
1398         err = ipgre_newlink_encap_setup(dev, data);
1399         if (err)
1400                 return err;
1401
1402         err = erspan_netlink_parms(dev, data, tb, &p, &fwmark);
1403         if (err < 0)
1404                 return err;
1405
1406         err = ip_tunnel_changelink(dev, tb, &p, fwmark);
1407         if (err < 0)
1408                 return err;
1409
1410         t->parms.i_flags = p.i_flags;
1411         t->parms.o_flags = p.o_flags;
1412
1413         return 0;
1414 }
1415
1416 static size_t ipgre_get_size(const struct net_device *dev)
1417 {
1418         return
1419                 /* IFLA_GRE_LINK */
1420                 nla_total_size(4) +
1421                 /* IFLA_GRE_IFLAGS */
1422                 nla_total_size(2) +
1423                 /* IFLA_GRE_OFLAGS */
1424                 nla_total_size(2) +
1425                 /* IFLA_GRE_IKEY */
1426                 nla_total_size(4) +
1427                 /* IFLA_GRE_OKEY */
1428                 nla_total_size(4) +
1429                 /* IFLA_GRE_LOCAL */
1430                 nla_total_size(4) +
1431                 /* IFLA_GRE_REMOTE */
1432                 nla_total_size(4) +
1433                 /* IFLA_GRE_TTL */
1434                 nla_total_size(1) +
1435                 /* IFLA_GRE_TOS */
1436                 nla_total_size(1) +
1437                 /* IFLA_GRE_PMTUDISC */
1438                 nla_total_size(1) +
1439                 /* IFLA_GRE_ENCAP_TYPE */
1440                 nla_total_size(2) +
1441                 /* IFLA_GRE_ENCAP_FLAGS */
1442                 nla_total_size(2) +
1443                 /* IFLA_GRE_ENCAP_SPORT */
1444                 nla_total_size(2) +
1445                 /* IFLA_GRE_ENCAP_DPORT */
1446                 nla_total_size(2) +
1447                 /* IFLA_GRE_COLLECT_METADATA */
1448                 nla_total_size(0) +
1449                 /* IFLA_GRE_IGNORE_DF */
1450                 nla_total_size(1) +
1451                 /* IFLA_GRE_FWMARK */
1452                 nla_total_size(4) +
1453                 /* IFLA_GRE_ERSPAN_INDEX */
1454                 nla_total_size(4) +
1455                 /* IFLA_GRE_ERSPAN_VER */
1456                 nla_total_size(1) +
1457                 /* IFLA_GRE_ERSPAN_DIR */
1458                 nla_total_size(1) +
1459                 /* IFLA_GRE_ERSPAN_HWID */
1460                 nla_total_size(2) +
1461                 0;
1462 }
1463
1464 static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
1465 {
1466         struct ip_tunnel *t = netdev_priv(dev);
1467         struct ip_tunnel_parm *p = &t->parms;
1468         __be16 o_flags = p->o_flags;
1469
1470         if (t->erspan_ver == 1 || t->erspan_ver == 2) {
1471                 if (!t->collect_md)
1472                         o_flags |= TUNNEL_KEY;
1473
1474                 if (nla_put_u8(skb, IFLA_GRE_ERSPAN_VER, t->erspan_ver))
1475                         goto nla_put_failure;
1476
1477                 if (t->erspan_ver == 1) {
1478                         if (nla_put_u32(skb, IFLA_GRE_ERSPAN_INDEX, t->index))
1479                                 goto nla_put_failure;
1480                 } else {
1481                         if (nla_put_u8(skb, IFLA_GRE_ERSPAN_DIR, t->dir))
1482                                 goto nla_put_failure;
1483                         if (nla_put_u16(skb, IFLA_GRE_ERSPAN_HWID, t->hwid))
1484                                 goto nla_put_failure;
1485                 }
1486         }
1487
1488         if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
1489             nla_put_be16(skb, IFLA_GRE_IFLAGS,
1490                          gre_tnl_flags_to_gre_flags(p->i_flags)) ||
1491             nla_put_be16(skb, IFLA_GRE_OFLAGS,
1492                          gre_tnl_flags_to_gre_flags(o_flags)) ||
1493             nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
1494             nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
1495             nla_put_in_addr(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
1496             nla_put_in_addr(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
1497             nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
1498             nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
1499             nla_put_u8(skb, IFLA_GRE_PMTUDISC,
1500                        !!(p->iph.frag_off & htons(IP_DF))) ||
1501             nla_put_u32(skb, IFLA_GRE_FWMARK, t->fwmark))
1502                 goto nla_put_failure;
1503
1504         if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE,
1505                         t->encap.type) ||
1506             nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT,
1507                          t->encap.sport) ||
1508             nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT,
1509                          t->encap.dport) ||
1510             nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS,
1511                         t->encap.flags))
1512                 goto nla_put_failure;
1513
1514         if (nla_put_u8(skb, IFLA_GRE_IGNORE_DF, t->ignore_df))
1515                 goto nla_put_failure;
1516
1517         if (t->collect_md) {
1518                 if (nla_put_flag(skb, IFLA_GRE_COLLECT_METADATA))
1519                         goto nla_put_failure;
1520         }
1521
1522         return 0;
1523
1524 nla_put_failure:
1525         return -EMSGSIZE;
1526 }
1527
1528 static void erspan_setup(struct net_device *dev)
1529 {
1530         struct ip_tunnel *t = netdev_priv(dev);
1531
1532         ether_setup(dev);
1533         dev->max_mtu = 0;
1534         dev->netdev_ops = &erspan_netdev_ops;
1535         dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1536         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
1537         ip_tunnel_setup(dev, erspan_net_id);
1538         t->erspan_ver = 1;
1539 }
1540
1541 static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
1542         [IFLA_GRE_LINK]         = { .type = NLA_U32 },
1543         [IFLA_GRE_IFLAGS]       = { .type = NLA_U16 },
1544         [IFLA_GRE_OFLAGS]       = { .type = NLA_U16 },
1545         [IFLA_GRE_IKEY]         = { .type = NLA_U32 },
1546         [IFLA_GRE_OKEY]         = { .type = NLA_U32 },
1547         [IFLA_GRE_LOCAL]        = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
1548         [IFLA_GRE_REMOTE]       = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
1549         [IFLA_GRE_TTL]          = { .type = NLA_U8 },
1550         [IFLA_GRE_TOS]          = { .type = NLA_U8 },
1551         [IFLA_GRE_PMTUDISC]     = { .type = NLA_U8 },
1552         [IFLA_GRE_ENCAP_TYPE]   = { .type = NLA_U16 },
1553         [IFLA_GRE_ENCAP_FLAGS]  = { .type = NLA_U16 },
1554         [IFLA_GRE_ENCAP_SPORT]  = { .type = NLA_U16 },
1555         [IFLA_GRE_ENCAP_DPORT]  = { .type = NLA_U16 },
1556         [IFLA_GRE_COLLECT_METADATA]     = { .type = NLA_FLAG },
1557         [IFLA_GRE_IGNORE_DF]    = { .type = NLA_U8 },
1558         [IFLA_GRE_FWMARK]       = { .type = NLA_U32 },
1559         [IFLA_GRE_ERSPAN_INDEX] = { .type = NLA_U32 },
1560         [IFLA_GRE_ERSPAN_VER]   = { .type = NLA_U8 },
1561         [IFLA_GRE_ERSPAN_DIR]   = { .type = NLA_U8 },
1562         [IFLA_GRE_ERSPAN_HWID]  = { .type = NLA_U16 },
1563 };
1564
1565 static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
1566         .kind           = "gre",
1567         .maxtype        = IFLA_GRE_MAX,
1568         .policy         = ipgre_policy,
1569         .priv_size      = sizeof(struct ip_tunnel),
1570         .setup          = ipgre_tunnel_setup,
1571         .validate       = ipgre_tunnel_validate,
1572         .newlink        = ipgre_newlink,
1573         .changelink     = ipgre_changelink,
1574         .dellink        = ip_tunnel_dellink,
1575         .get_size       = ipgre_get_size,
1576         .fill_info      = ipgre_fill_info,
1577         .get_link_net   = ip_tunnel_get_link_net,
1578 };
1579
1580 static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
1581         .kind           = "gretap",
1582         .maxtype        = IFLA_GRE_MAX,
1583         .policy         = ipgre_policy,
1584         .priv_size      = sizeof(struct ip_tunnel),
1585         .setup          = ipgre_tap_setup,
1586         .validate       = ipgre_tap_validate,
1587         .newlink        = ipgre_newlink,
1588         .changelink     = ipgre_changelink,
1589         .dellink        = ip_tunnel_dellink,
1590         .get_size       = ipgre_get_size,
1591         .fill_info      = ipgre_fill_info,
1592         .get_link_net   = ip_tunnel_get_link_net,
1593 };
1594
1595 static struct rtnl_link_ops erspan_link_ops __read_mostly = {
1596         .kind           = "erspan",
1597         .maxtype        = IFLA_GRE_MAX,
1598         .policy         = ipgre_policy,
1599         .priv_size      = sizeof(struct ip_tunnel),
1600         .setup          = erspan_setup,
1601         .validate       = erspan_validate,
1602         .newlink        = erspan_newlink,
1603         .changelink     = erspan_changelink,
1604         .dellink        = ip_tunnel_dellink,
1605         .get_size       = ipgre_get_size,
1606         .fill_info      = ipgre_fill_info,
1607         .get_link_net   = ip_tunnel_get_link_net,
1608 };
1609
1610 struct net_device *gretap_fb_dev_create(struct net *net, const char *name,
1611                                         u8 name_assign_type)
1612 {
1613         struct nlattr *tb[IFLA_MAX + 1];
1614         struct net_device *dev;
1615         LIST_HEAD(list_kill);
1616         struct ip_tunnel *t;
1617         int err;
1618
1619         memset(&tb, 0, sizeof(tb));
1620
1621         dev = rtnl_create_link(net, name, name_assign_type,
1622                                &ipgre_tap_ops, tb, NULL);
1623         if (IS_ERR(dev))
1624                 return dev;
1625
1626         /* Configure flow based GRE device. */
1627         t = netdev_priv(dev);
1628         t->collect_md = true;
1629
1630         err = ipgre_newlink(net, dev, tb, NULL, NULL);
1631         if (err < 0) {
1632                 free_netdev(dev);
1633                 return ERR_PTR(err);
1634         }
1635
1636         /* openvswitch users expect packet sizes to be unrestricted,
1637          * so set the largest MTU we can.
1638          */
1639         err = __ip_tunnel_change_mtu(dev, IP_MAX_MTU, false);
1640         if (err)
1641                 goto out;
1642
1643         err = rtnl_configure_link(dev, NULL);
1644         if (err < 0)
1645                 goto out;
1646
1647         return dev;
1648 out:
1649         ip_tunnel_dellink(dev, &list_kill);
1650         unregister_netdevice_many(&list_kill);
1651         return ERR_PTR(err);
1652 }
1653 EXPORT_SYMBOL_GPL(gretap_fb_dev_create);
1654
1655 static int __net_init ipgre_tap_init_net(struct net *net)
1656 {
1657         return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, "gretap0");
1658 }
1659
1660 static void __net_exit ipgre_tap_exit_batch_net(struct list_head *list_net)
1661 {
1662         ip_tunnel_delete_nets(list_net, gre_tap_net_id, &ipgre_tap_ops);
1663 }
1664
1665 static struct pernet_operations ipgre_tap_net_ops = {
1666         .init = ipgre_tap_init_net,
1667         .exit_batch = ipgre_tap_exit_batch_net,
1668         .id   = &gre_tap_net_id,
1669         .size = sizeof(struct ip_tunnel_net),
1670 };
1671
1672 static int __net_init erspan_init_net(struct net *net)
1673 {
1674         return ip_tunnel_init_net(net, erspan_net_id,
1675                                   &erspan_link_ops, "erspan0");
1676 }
1677
1678 static void __net_exit erspan_exit_batch_net(struct list_head *net_list)
1679 {
1680         ip_tunnel_delete_nets(net_list, erspan_net_id, &erspan_link_ops);
1681 }
1682
1683 static struct pernet_operations erspan_net_ops = {
1684         .init = erspan_init_net,
1685         .exit_batch = erspan_exit_batch_net,
1686         .id   = &erspan_net_id,
1687         .size = sizeof(struct ip_tunnel_net),
1688 };
1689
1690 static int __init ipgre_init(void)
1691 {
1692         int err;
1693
1694         pr_info("GRE over IPv4 tunneling driver\n");
1695
1696         err = register_pernet_device(&ipgre_net_ops);
1697         if (err < 0)
1698                 return err;
1699
1700         err = register_pernet_device(&ipgre_tap_net_ops);
1701         if (err < 0)
1702                 goto pnet_tap_failed;
1703
1704         err = register_pernet_device(&erspan_net_ops);
1705         if (err < 0)
1706                 goto pnet_erspan_failed;
1707
1708         err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
1709         if (err < 0) {
1710                 pr_info("%s: can't add protocol\n", __func__);
1711                 goto add_proto_failed;
1712         }
1713
1714         err = rtnl_link_register(&ipgre_link_ops);
1715         if (err < 0)
1716                 goto rtnl_link_failed;
1717
1718         err = rtnl_link_register(&ipgre_tap_ops);
1719         if (err < 0)
1720                 goto tap_ops_failed;
1721
1722         err = rtnl_link_register(&erspan_link_ops);
1723         if (err < 0)
1724                 goto erspan_link_failed;
1725
1726         return 0;
1727
1728 erspan_link_failed:
1729         rtnl_link_unregister(&ipgre_tap_ops);
1730 tap_ops_failed:
1731         rtnl_link_unregister(&ipgre_link_ops);
1732 rtnl_link_failed:
1733         gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1734 add_proto_failed:
1735         unregister_pernet_device(&erspan_net_ops);
1736 pnet_erspan_failed:
1737         unregister_pernet_device(&ipgre_tap_net_ops);
1738 pnet_tap_failed:
1739         unregister_pernet_device(&ipgre_net_ops);
1740         return err;
1741 }
1742
1743 static void __exit ipgre_fini(void)
1744 {
1745         rtnl_link_unregister(&ipgre_tap_ops);
1746         rtnl_link_unregister(&ipgre_link_ops);
1747         rtnl_link_unregister(&erspan_link_ops);
1748         gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1749         unregister_pernet_device(&ipgre_tap_net_ops);
1750         unregister_pernet_device(&ipgre_net_ops);
1751         unregister_pernet_device(&erspan_net_ops);
1752 }
1753
1754 module_init(ipgre_init);
1755 module_exit(ipgre_fini);
1756 MODULE_LICENSE("GPL");
1757 MODULE_ALIAS_RTNL_LINK("gre");
1758 MODULE_ALIAS_RTNL_LINK("gretap");
1759 MODULE_ALIAS_RTNL_LINK("erspan");
1760 MODULE_ALIAS_NETDEV("gre0");
1761 MODULE_ALIAS_NETDEV("gretap0");
1762 MODULE_ALIAS_NETDEV("erspan0");