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                 const struct iphdr *tnl_params;
 344
 345                 if (__iptunnel_pull_header(skb, hdr_len, tpi->proto,
 346                                            raw_proto, false) < 0)
 347                         goto drop;
 348
 349                 if (tunnel->dev->type != ARPHRD_NONE)
 350                         skb_pop_mac_header(skb);
 351                 else
 352                         skb_reset_mac_header(skb);
 353
 354                 tnl_params = &tunnel->parms.iph;
 355                 if (tunnel->collect_md || tnl_params->daddr == 0) {
 356                         __be16 flags;
 357                         __be64 tun_id;
 358
 359                         flags = tpi->flags & (TUNNEL_CSUM | TUNNEL_KEY);
 360                         tun_id = key32_to_tunnel_id(tpi->key);
 361                         tun_dst = ip_tun_rx_dst(skb, flags, tun_id, 0);
 362                         if (!tun_dst)
 363                                 return PACKET_REJECT;
 364                 }
 365
 366                 ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error);
 367                 return PACKET_RCVD;
 368         }
 369         return PACKET_NEXT;
 370
 371 drop:
 372         kfree_skb(skb);
 373         return PACKET_RCVD;
 374 }
 375
 376 static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
 377                      int hdr_len)
 378 {
 379         struct net *net = dev_net(skb->dev);
 380         struct ip_tunnel_net *itn;
 381         int res;
 382
 383         if (tpi->proto == htons(ETH_P_TEB))
 384                 itn = net_generic(net, gre_tap_net_id);
 385         else
 386                 itn = net_generic(net, ipgre_net_id);
 387
 388         res = __ipgre_rcv(skb, tpi, itn, hdr_len, false);
 389         if (res == PACKET_NEXT && tpi->proto == htons(ETH_P_TEB)) {
 390                 /* ipgre tunnels in collect metadata mode should receive
 391                  * also ETH_P_TEB traffic.
 392                  */
 393                 itn = net_generic(net, ipgre_net_id);
 394                 res = __ipgre_rcv(skb, tpi, itn, hdr_len, true);
 395         }
 396         return res;
 397 }
 398
 399 static int gre_rcv(struct sk_buff *skb)
 400 {
 401         struct tnl_ptk_info tpi;
 402         bool csum_err = false;
 403         int hdr_len;
 404
 405 #ifdef CONFIG_NET_IPGRE_BROADCAST
 406         if (ipv4_is_multicast(ip_hdr(skb)->daddr)) {
 407                 /* Looped back packet, drop it! */
 408                 if (rt_is_output_route(skb_rtable(skb)))
 409                         goto drop;
 410         }
 411 #endif
 412
 413         hdr_len = gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP), 0);
 414         if (hdr_len < 0)
 415                 goto drop;
 416
 417         if (unlikely(tpi.proto == htons(ETH_P_ERSPAN) ||
 418                      tpi.proto == htons(ETH_P_ERSPAN2))) {
 419                 if (erspan_rcv(skb, &tpi, hdr_len) == PACKET_RCVD)
 420                         return 0;
 421                 goto out;
 422         }
 423
 424         if (ipgre_rcv(skb, &tpi, hdr_len) == PACKET_RCVD)
 425                 return 0;
 426
 427 out:
 428         icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
 429 drop:
 430         kfree_skb(skb);
 431         return 0;
 432 }
 433
 434 static void __gre_xmit(struct sk_buff *skb, struct net_device *dev,
 435                        const struct iphdr *tnl_params,
 436                        __be16 proto)
 437 {
 438         struct ip_tunnel *tunnel = netdev_priv(dev);
 439
 440         if (tunnel->parms.o_flags & TUNNEL_SEQ)
 441                 tunnel->o_seqno++;
 442
 443         /* Push GRE header. */
 444         gre_build_header(skb, tunnel->tun_hlen,
 445                          tunnel->parms.o_flags, proto, tunnel->parms.o_key,
 446                          htonl(tunnel->o_seqno));
 447
 448         ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol);
 449 }
 450
 451 static int gre_handle_offloads(struct sk_buff *skb, bool csum)
 452 {
 453         return iptunnel_handle_offloads(skb, csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE);
 454 }
 455
 456 static void gre_fb_xmit(struct sk_buff *skb, struct net_device *dev,
 457                         __be16 proto)
 458 {
 459         struct ip_tunnel *tunnel = netdev_priv(dev);
 460         struct ip_tunnel_info *tun_info;
 461         const struct ip_tunnel_key *key;
 462         int tunnel_hlen;
 463         __be16 flags;
 464
 465         tun_info = skb_tunnel_info(skb);
 466         if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
 467                      ip_tunnel_info_af(tun_info) != AF_INET))
 468                 goto err_free_skb;
 469
 470         key = &tun_info->key;
 471         tunnel_hlen = gre_calc_hlen(key->tun_flags);
 472
 473         if (skb_cow_head(skb, dev->needed_headroom))
 474                 goto err_free_skb;
 475
 476         /* Push Tunnel header. */
 477         if (gre_handle_offloads(skb, !!(tun_info->key.tun_flags & TUNNEL_CSUM)))
 478                 goto err_free_skb;
 479
 480         flags = tun_info->key.tun_flags &
 481                 (TUNNEL_CSUM | TUNNEL_KEY | TUNNEL_SEQ);
 482         gre_build_header(skb, tunnel_hlen, flags, proto,
 483                          tunnel_id_to_key32(tun_info->key.tun_id),
 484                          (flags & TUNNEL_SEQ) ? htonl(tunnel->o_seqno++) : 0);
 485
 486         ip_md_tunnel_xmit(skb, dev, IPPROTO_GRE, tunnel_hlen);
 487
 488         return;
 489
 490 err_free_skb:
 491         kfree_skb(skb);
 492         dev->stats.tx_dropped++;
 493 }
 494
 495 static void erspan_fb_xmit(struct sk_buff *skb, struct net_device *dev)
 496 {
 497         struct ip_tunnel *tunnel = netdev_priv(dev);
 498         struct ip_tunnel_info *tun_info;
 499         const struct ip_tunnel_key *key;
 500         struct erspan_metadata *md;
 501         bool truncate = false;
 502         __be16 proto;
 503         int tunnel_hlen;
 504         int version;
 505         int nhoff;
 506         int thoff;
 507
 508         tun_info = skb_tunnel_info(skb);
 509         if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
 510                      ip_tunnel_info_af(tun_info) != AF_INET))
 511                 goto err_free_skb;
 512
 513         key = &tun_info->key;
 514         if (!(tun_info->key.tun_flags & TUNNEL_ERSPAN_OPT))
 515                 goto err_free_skb;
 516         if (tun_info->options_len < sizeof(*md))
 517                 goto err_free_skb;
 518         md = ip_tunnel_info_opts(tun_info);
 519
 520         /* ERSPAN has fixed 8 byte GRE header */
 521         version = md->version;
 522         tunnel_hlen = 8 + erspan_hdr_len(version);
 523
 524         if (skb_cow_head(skb, dev->needed_headroom))
 525                 goto err_free_skb;
 526
 527         if (gre_handle_offloads(skb, false))
 528                 goto err_free_skb;
 529
 530         if (skb->len > dev->mtu + dev->hard_header_len) {
 531                 pskb_trim(skb, dev->mtu + dev->hard_header_len);
 532                 truncate = true;
 533         }
 534
 535         nhoff = skb_network_header(skb) - skb_mac_header(skb);
 536         if (skb->protocol == htons(ETH_P_IP) &&
 537             (ntohs(ip_hdr(skb)->tot_len) > skb->len - nhoff))
 538                 truncate = true;
 539
 540         thoff = skb_transport_header(skb) - skb_mac_header(skb);
 541         if (skb->protocol == htons(ETH_P_IPV6) &&
 542             (ntohs(ipv6_hdr(skb)->payload_len) > skb->len - thoff))
 543                 truncate = true;
 544
 545         if (version == 1) {
 546                 erspan_build_header(skb, ntohl(tunnel_id_to_key32(key->tun_id)),
 547                                     ntohl(md->u.index), truncate, true);
 548                 proto = htons(ETH_P_ERSPAN);
 549         } else if (version == 2) {
 550                 erspan_build_header_v2(skb,
 551                                        ntohl(tunnel_id_to_key32(key->tun_id)),
 552                                        md->u.md2.dir,
 553                                        get_hwid(&md->u.md2),
 554                                        truncate, true);
 555                 proto = htons(ETH_P_ERSPAN2);
 556         } else {
 557                 goto err_free_skb;
 558         }
 559
 560         gre_build_header(skb, 8, TUNNEL_SEQ,
 561                          proto, 0, htonl(tunnel->o_seqno++));
 562
 563         ip_md_tunnel_xmit(skb, dev, IPPROTO_GRE, tunnel_hlen);
 564
 565         return;
 566
 567 err_free_skb:
 568         kfree_skb(skb);
 569         dev->stats.tx_dropped++;
 570 }
 571
 572 static int gre_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
 573 {
 574         struct ip_tunnel_info *info = skb_tunnel_info(skb);
 575         const struct ip_tunnel_key *key;
 576         struct rtable *rt;
 577         struct flowi4 fl4;
 578
 579         if (ip_tunnel_info_af(info) != AF_INET)
 580                 return -EINVAL;
 581
 582         key = &info->key;
 583         ip_tunnel_init_flow(&fl4, IPPROTO_GRE, key->u.ipv4.dst, key->u.ipv4.src,
 584                             tunnel_id_to_key32(key->tun_id), key->tos, 0,
 585                             skb->mark, 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                 /* Need space for new headers */
 611                 if (skb_cow_head(skb, dev->needed_headroom -
 612                                       (tunnel->hlen + sizeof(struct iphdr))))
 613                         goto free_skb;
 614
 615                 tnl_params = (const struct iphdr *)skb->data;
 616
 617                 /* Pull skb since ip_tunnel_xmit() needs skb->data pointing
 618                  * to gre header.
 619                  */
 620                 skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
 621                 skb_reset_mac_header(skb);
 622         } else {
 623                 if (skb_cow_head(skb, dev->needed_headroom))
 624                         goto free_skb;
 625
 626                 tnl_params = &tunnel->parms.iph;
 627         }
 628
 629         if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
 630                 goto free_skb;
 631
 632         __gre_xmit(skb, dev, tnl_params, skb->protocol);
 633         return NETDEV_TX_OK;
 634
 635 free_skb:
 636         kfree_skb(skb);
 637         dev->stats.tx_dropped++;
 638         return NETDEV_TX_OK;
 639 }
 640
 641 static netdev_tx_t erspan_xmit(struct sk_buff *skb,
 642                                struct net_device *dev)
 643 {
 644         struct ip_tunnel *tunnel = netdev_priv(dev);
 645         bool truncate = false;
 646         __be16 proto;
 647
 648         if (!pskb_inet_may_pull(skb))
 649                 goto free_skb;
 650
 651         if (tunnel->collect_md) {
 652                 erspan_fb_xmit(skb, dev);
 653                 return NETDEV_TX_OK;
 654         }
 655
 656         if (gre_handle_offloads(skb, false))
 657                 goto free_skb;
 658
 659         if (skb_cow_head(skb, dev->needed_headroom))
 660                 goto free_skb;
 661
 662         if (skb->len > dev->mtu + dev->hard_header_len) {
 663                 pskb_trim(skb, dev->mtu + dev->hard_header_len);
 664                 truncate = true;
 665         }
 666
 667         /* Push ERSPAN header */
 668         if (tunnel->erspan_ver == 1) {
 669                 erspan_build_header(skb, ntohl(tunnel->parms.o_key),
 670                                     tunnel->index,
 671                                     truncate, true);
 672                 proto = htons(ETH_P_ERSPAN);
 673         } else if (tunnel->erspan_ver == 2) {
 674                 erspan_build_header_v2(skb, ntohl(tunnel->parms.o_key),
 675                                        tunnel->dir, tunnel->hwid,
 676                                        truncate, true);
 677                 proto = htons(ETH_P_ERSPAN2);
 678         } else {
 679                 goto free_skb;
 680         }
 681
 682         tunnel->parms.o_flags &= ~TUNNEL_KEY;
 683         __gre_xmit(skb, dev, &tunnel->parms.iph, proto);
 684         return NETDEV_TX_OK;
 685
 686 free_skb:
 687         kfree_skb(skb);
 688         dev->stats.tx_dropped++;
 689         return NETDEV_TX_OK;
 690 }
 691
 692 static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
 693                                 struct net_device *dev)
 694 {
 695         struct ip_tunnel *tunnel = netdev_priv(dev);
 696
 697         if (!pskb_inet_may_pull(skb))
 698                 goto free_skb;
 699
 700         if (tunnel->collect_md) {
 701                 gre_fb_xmit(skb, dev, htons(ETH_P_TEB));
 702                 return NETDEV_TX_OK;
 703         }
 704
 705         if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
 706                 goto free_skb;
 707
 708         if (skb_cow_head(skb, dev->needed_headroom))
 709                 goto free_skb;
 710
 711         __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
 712         return NETDEV_TX_OK;
 713
 714 free_skb:
 715         kfree_skb(skb);
 716         dev->stats.tx_dropped++;
 717         return NETDEV_TX_OK;
 718 }
 719
 720 static void ipgre_link_update(struct net_device *dev, bool set_mtu)
 721 {
 722         struct ip_tunnel *tunnel = netdev_priv(dev);
 723         int len;
 724
 725         len = tunnel->tun_hlen;
 726         tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
 727         len = tunnel->tun_hlen - len;
 728         tunnel->hlen = tunnel->hlen + len;
 729
 730         dev->needed_headroom = dev->needed_headroom + len;
 731         if (set_mtu)
 732                 dev->mtu = max_t(int, dev->mtu - len, 68);
 733
 734         if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
 735                 if (!(tunnel->parms.o_flags & TUNNEL_CSUM) ||
 736                     tunnel->encap.type == TUNNEL_ENCAP_NONE) {
 737                         dev->features |= NETIF_F_GSO_SOFTWARE;
 738                         dev->hw_features |= NETIF_F_GSO_SOFTWARE;
 739                 } else {
 740                         dev->features &= ~NETIF_F_GSO_SOFTWARE;
 741                         dev->hw_features &= ~NETIF_F_GSO_SOFTWARE;
 742                 }
 743                 dev->features |= NETIF_F_LLTX;
 744         } else {
 745                 dev->hw_features &= ~NETIF_F_GSO_SOFTWARE;
 746                 dev->features &= ~(NETIF_F_LLTX | NETIF_F_GSO_SOFTWARE);
 747         }
 748 }
 749
 750 static int ipgre_tunnel_ioctl(struct net_device *dev,
 751                               struct ifreq *ifr, int cmd)
 752 {
 753         struct ip_tunnel_parm p;
 754         int err;
 755
 756         if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
 757                 return -EFAULT;
 758
 759         if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
 760                 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
 761                     p.iph.ihl != 5 || (p.iph.frag_off & htons(~IP_DF)) ||
 762                     ((p.i_flags | p.o_flags) & (GRE_VERSION | GRE_ROUTING)))
 763                         return -EINVAL;
 764         }
 765
 766         p.i_flags = gre_flags_to_tnl_flags(p.i_flags);
 767         p.o_flags = gre_flags_to_tnl_flags(p.o_flags);
 768
 769         err = ip_tunnel_ioctl(dev, &p, cmd);
 770         if (err)
 771                 return err;
 772
 773         if (cmd == SIOCCHGTUNNEL) {
 774                 struct ip_tunnel *t = netdev_priv(dev);
 775
 776                 t->parms.i_flags = p.i_flags;
 777                 t->parms.o_flags = p.o_flags;
 778
 779                 if (strcmp(dev->rtnl_link_ops->kind, "erspan"))
 780                         ipgre_link_update(dev, true);
 781         }
 782
 783         p.i_flags = gre_tnl_flags_to_gre_flags(p.i_flags);
 784         p.o_flags = gre_tnl_flags_to_gre_flags(p.o_flags);
 785
 786         if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
 787                 return -EFAULT;
 788
 789         return 0;
 790 }
 791
 792 /* Nice toy. Unfortunately, useless in real life :-)
 793    It allows to construct virtual multiprotocol broadcast "LAN"
 794    over the Internet, provided multicast routing is tuned.
 795
 796
 797    I have no idea was this bicycle invented before me,
 798    so that I had to set ARPHRD_IPGRE to a random value.
 799    I have an impression, that Cisco could make something similar,
 800    but this feature is apparently missing in IOS<=11.2(8).
 801
 802    I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
 803    with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
 804
 805    ping -t 255 224.66.66.66
 806
 807    If nobody answers, mbone does not work.
 808
 809    ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
 810    ip addr add 10.66.66.<somewhat>/24 dev Universe
 811    ifconfig Universe up
 812    ifconfig Universe add fe80::<Your_real_addr>/10
 813    ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
 814    ftp 10.66.66.66
 815    ...
 816    ftp fec0:6666:6666::193.233.7.65
 817    ...
 818  */
 819 static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
 820                         unsigned short type,
 821                         const void *daddr, const void *saddr, unsigned int len)
 822 {
 823         struct ip_tunnel *t = netdev_priv(dev);
 824         struct iphdr *iph;
 825         struct gre_base_hdr *greh;
 826
 827         iph = skb_push(skb, t->hlen + sizeof(*iph));
 828         greh = (struct gre_base_hdr *)(iph+1);
 829         greh->flags = gre_tnl_flags_to_gre_flags(t->parms.o_flags);
 830         greh->protocol = htons(type);
 831
 832         memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
 833
 834         /* Set the source hardware address. */
 835         if (saddr)
 836                 memcpy(&iph->saddr, saddr, 4);
 837         if (daddr)
 838                 memcpy(&iph->daddr, daddr, 4);
 839         if (iph->daddr)
 840                 return t->hlen + sizeof(*iph);
 841
 842         return -(t->hlen + sizeof(*iph));
 843 }
 844
 845 static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
 846 {
 847         const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
 848         memcpy(haddr, &iph->saddr, 4);
 849         return 4;
 850 }
 851
 852 static const struct header_ops ipgre_header_ops = {
 853         .create = ipgre_header,
 854         .parse  = ipgre_header_parse,
 855 };
 856
 857 #ifdef CONFIG_NET_IPGRE_BROADCAST
 858 static int ipgre_open(struct net_device *dev)
 859 {
 860         struct ip_tunnel *t = netdev_priv(dev);
 861
 862         if (ipv4_is_multicast(t->parms.iph.daddr)) {
 863                 struct flowi4 fl4;
 864                 struct rtable *rt;
 865
 866                 rt = ip_route_output_gre(t->net, &fl4,
 867                                          t->parms.iph.daddr,
 868                                          t->parms.iph.saddr,
 869                                          t->parms.o_key,
 870                                          RT_TOS(t->parms.iph.tos),
 871                                          t->parms.link);
 872                 if (IS_ERR(rt))
 873                         return -EADDRNOTAVAIL;
 874                 dev = rt->dst.dev;
 875                 ip_rt_put(rt);
 876                 if (!__in_dev_get_rtnl(dev))
 877                         return -EADDRNOTAVAIL;
 878                 t->mlink = dev->ifindex;
 879                 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
 880         }
 881         return 0;
 882 }
 883
 884 static int ipgre_close(struct net_device *dev)
 885 {
 886         struct ip_tunnel *t = netdev_priv(dev);
 887
 888         if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
 889                 struct in_device *in_dev;
 890                 in_dev = inetdev_by_index(t->net, t->mlink);
 891                 if (in_dev)
 892                         ip_mc_dec_group(in_dev, t->parms.iph.daddr);
 893         }
 894         return 0;
 895 }
 896 #endif
 897
 898 static const struct net_device_ops ipgre_netdev_ops = {
 899         .ndo_init               = ipgre_tunnel_init,
 900         .ndo_uninit             = ip_tunnel_uninit,
 901 #ifdef CONFIG_NET_IPGRE_BROADCAST
 902         .ndo_open               = ipgre_open,
 903         .ndo_stop               = ipgre_close,
 904 #endif
 905         .ndo_start_xmit         = ipgre_xmit,
 906         .ndo_do_ioctl           = ipgre_tunnel_ioctl,
 907         .ndo_change_mtu         = ip_tunnel_change_mtu,
 908         .ndo_get_stats64        = ip_tunnel_get_stats64,
 909         .ndo_get_iflink         = ip_tunnel_get_iflink,
 910 };
 911
 912 #define GRE_FEATURES (NETIF_F_SG |              \
 913                       NETIF_F_FRAGLIST |        \
 914                       NETIF_F_HIGHDMA |         \
 915                       NETIF_F_HW_CSUM)
 916
 917 static void ipgre_tunnel_setup(struct net_device *dev)
 918 {
 919         dev->netdev_ops         = &ipgre_netdev_ops;
 920         dev->type               = ARPHRD_IPGRE;
 921         ip_tunnel_setup(dev, ipgre_net_id);
 922 }
 923
 924 static void __gre_tunnel_init(struct net_device *dev)
 925 {
 926         struct ip_tunnel *tunnel;
 927
 928         tunnel = netdev_priv(dev);
 929         tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
 930         tunnel->parms.iph.protocol = IPPROTO_GRE;
 931
 932         tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
 933
 934         dev->features           |= GRE_FEATURES;
 935         dev->hw_features        |= GRE_FEATURES;
 936
 937         if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
 938                 /* TCP offload with GRE SEQ is not supported, nor
 939                  * can we support 2 levels of outer headers requiring
 940                  * an update.
 941                  */
 942                 if (!(tunnel->parms.o_flags & TUNNEL_CSUM) ||
 943                     (tunnel->encap.type == TUNNEL_ENCAP_NONE)) {
 944                         dev->features    |= NETIF_F_GSO_SOFTWARE;
 945                         dev->hw_features |= NETIF_F_GSO_SOFTWARE;
 946                 }
 947
 948                 /* Can use a lockless transmit, unless we generate
 949                  * output sequences
 950                  */
 951                 dev->features |= NETIF_F_LLTX;
 952         }
 953 }
 954
 955 static int ipgre_tunnel_init(struct net_device *dev)
 956 {
 957         struct ip_tunnel *tunnel = netdev_priv(dev);
 958         struct iphdr *iph = &tunnel->parms.iph;
 959
 960         __gre_tunnel_init(dev);
 961
 962         memcpy(dev->dev_addr, &iph->saddr, 4);
 963         memcpy(dev->broadcast, &iph->daddr, 4);
 964
 965         dev->flags              = IFF_NOARP;
 966         netif_keep_dst(dev);
 967         dev->addr_len           = 4;
 968
 969         if (iph->daddr && !tunnel->collect_md) {
 970 #ifdef CONFIG_NET_IPGRE_BROADCAST
 971                 if (ipv4_is_multicast(iph->daddr)) {
 972                         if (!iph->saddr)
 973                                 return -EINVAL;
 974                         dev->flags = IFF_BROADCAST;
 975                         dev->header_ops = &ipgre_header_ops;
 976                 }
 977 #endif
 978         } else if (!tunnel->collect_md) {
 979                 dev->header_ops = &ipgre_header_ops;
 980         }
 981
 982         return ip_tunnel_init(dev);
 983 }
 984
 985 static const struct gre_protocol ipgre_protocol = {
 986         .handler     = gre_rcv,
 987         .err_handler = gre_err,
 988 };
 989
 990 static int __net_init ipgre_init_net(struct net *net)
 991 {
 992         return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
 993 }
 994
 995 static void __net_exit ipgre_exit_batch_net(struct list_head *list_net)
 996 {
 997         ip_tunnel_delete_nets(list_net, ipgre_net_id, &ipgre_link_ops);
 998 }
 999
1000 static struct pernet_operations ipgre_net_ops = {
1001         .init = ipgre_init_net,
1002         .exit_batch = ipgre_exit_batch_net,
1003         .id   = &ipgre_net_id,
1004         .size = sizeof(struct ip_tunnel_net),
1005 };
1006
1007 static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[],
1008                                  struct netlink_ext_ack *extack)
1009 {
1010         __be16 flags;
1011
1012         if (!data)
1013                 return 0;
1014
1015         flags = 0;
1016         if (data[IFLA_GRE_IFLAGS])
1017                 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1018         if (data[IFLA_GRE_OFLAGS])
1019                 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1020         if (flags & (GRE_VERSION|GRE_ROUTING))
1021                 return -EINVAL;
1022
1023         if (data[IFLA_GRE_COLLECT_METADATA] &&
1024             data[IFLA_GRE_ENCAP_TYPE] &&
1025             nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]) != TUNNEL_ENCAP_NONE)
1026                 return -EINVAL;
1027
1028         return 0;
1029 }
1030
1031 static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[],
1032                               struct netlink_ext_ack *extack)
1033 {
1034         __be32 daddr;
1035
1036         if (tb[IFLA_ADDRESS]) {
1037                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1038                         return -EINVAL;
1039                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1040                         return -EADDRNOTAVAIL;
1041         }
1042
1043         if (!data)
1044                 goto out;
1045
1046         if (data[IFLA_GRE_REMOTE]) {
1047                 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
1048                 if (!daddr)
1049                         return -EINVAL;
1050         }
1051
1052 out:
1053         return ipgre_tunnel_validate(tb, data, extack);
1054 }
1055
1056 static int erspan_validate(struct nlattr *tb[], struct nlattr *data[],
1057                            struct netlink_ext_ack *extack)
1058 {
1059         __be16 flags = 0;
1060         int ret;
1061
1062         if (!data)
1063                 return 0;
1064
1065         ret = ipgre_tap_validate(tb, data, extack);
1066         if (ret)
1067                 return ret;
1068
1069         /* ERSPAN should only have GRE sequence and key flag */
1070         if (data[IFLA_GRE_OFLAGS])
1071                 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1072         if (data[IFLA_GRE_IFLAGS])
1073                 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1074         if (!data[IFLA_GRE_COLLECT_METADATA] &&
1075             flags != (GRE_SEQ | GRE_KEY))
1076                 return -EINVAL;
1077
1078         /* ERSPAN Session ID only has 10-bit. Since we reuse
1079          * 32-bit key field as ID, check it's range.
1080          */
1081         if (data[IFLA_GRE_IKEY] &&
1082             (ntohl(nla_get_be32(data[IFLA_GRE_IKEY])) & ~ID_MASK))
1083                 return -EINVAL;
1084
1085         if (data[IFLA_GRE_OKEY] &&
1086             (ntohl(nla_get_be32(data[IFLA_GRE_OKEY])) & ~ID_MASK))
1087                 return -EINVAL;
1088
1089         return 0;
1090 }
1091
1092 static int ipgre_netlink_parms(struct net_device *dev,
1093                                 struct nlattr *data[],
1094                                 struct nlattr *tb[],
1095                                 struct ip_tunnel_parm *parms,
1096                                 __u32 *fwmark)
1097 {
1098         struct ip_tunnel *t = netdev_priv(dev);
1099
1100         memset(parms, 0, sizeof(*parms));
1101
1102         parms->iph.protocol = IPPROTO_GRE;
1103
1104         if (!data)
1105                 return 0;
1106
1107         if (data[IFLA_GRE_LINK])
1108                 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
1109
1110         if (data[IFLA_GRE_IFLAGS])
1111                 parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
1112
1113         if (data[IFLA_GRE_OFLAGS])
1114                 parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
1115
1116         if (data[IFLA_GRE_IKEY])
1117                 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
1118
1119         if (data[IFLA_GRE_OKEY])
1120                 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
1121
1122         if (data[IFLA_GRE_LOCAL])
1123                 parms->iph.saddr = nla_get_in_addr(data[IFLA_GRE_LOCAL]);
1124
1125         if (data[IFLA_GRE_REMOTE])
1126                 parms->iph.daddr = nla_get_in_addr(data[IFLA_GRE_REMOTE]);
1127
1128         if (data[IFLA_GRE_TTL])
1129                 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
1130
1131         if (data[IFLA_GRE_TOS])
1132                 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
1133
1134         if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC])) {
1135                 if (t->ignore_df)
1136                         return -EINVAL;
1137                 parms->iph.frag_off = htons(IP_DF);
1138         }
1139
1140         if (data[IFLA_GRE_COLLECT_METADATA]) {
1141                 t->collect_md = true;
1142                 if (dev->type == ARPHRD_IPGRE)
1143                         dev->type = ARPHRD_NONE;
1144         }
1145
1146         if (data[IFLA_GRE_IGNORE_DF]) {
1147                 if (nla_get_u8(data[IFLA_GRE_IGNORE_DF])
1148                   && (parms->iph.frag_off & htons(IP_DF)))
1149                         return -EINVAL;
1150                 t->ignore_df = !!nla_get_u8(data[IFLA_GRE_IGNORE_DF]);
1151         }
1152
1153         if (data[IFLA_GRE_FWMARK])
1154                 *fwmark = nla_get_u32(data[IFLA_GRE_FWMARK]);
1155
1156         return 0;
1157 }
1158
1159 static int erspan_netlink_parms(struct net_device *dev,
1160                                 struct nlattr *data[],
1161                                 struct nlattr *tb[],
1162                                 struct ip_tunnel_parm *parms,
1163                                 __u32 *fwmark)
1164 {
1165         struct ip_tunnel *t = netdev_priv(dev);
1166         int err;
1167
1168         err = ipgre_netlink_parms(dev, data, tb, parms, fwmark);
1169         if (err)
1170                 return err;
1171         if (!data)
1172                 return 0;
1173
1174         if (data[IFLA_GRE_ERSPAN_VER]) {
1175                 t->erspan_ver = nla_get_u8(data[IFLA_GRE_ERSPAN_VER]);
1176
1177                 if (t->erspan_ver != 1 && t->erspan_ver != 2)
1178                         return -EINVAL;
1179         }
1180
1181         if (t->erspan_ver == 1) {
1182                 if (data[IFLA_GRE_ERSPAN_INDEX]) {
1183                         t->index = nla_get_u32(data[IFLA_GRE_ERSPAN_INDEX]);
1184                         if (t->index & ~INDEX_MASK)
1185                                 return -EINVAL;
1186                 }
1187         } else if (t->erspan_ver == 2) {
1188                 if (data[IFLA_GRE_ERSPAN_DIR]) {
1189                         t->dir = nla_get_u8(data[IFLA_GRE_ERSPAN_DIR]);
1190                         if (t->dir & ~(DIR_MASK >> DIR_OFFSET))
1191                                 return -EINVAL;
1192                 }
1193                 if (data[IFLA_GRE_ERSPAN_HWID]) {
1194                         t->hwid = nla_get_u16(data[IFLA_GRE_ERSPAN_HWID]);
1195                         if (t->hwid & ~(HWID_MASK >> HWID_OFFSET))
1196                                 return -EINVAL;
1197                 }
1198         }
1199
1200         return 0;
1201 }
1202
1203 /* This function returns true when ENCAP attributes are present in the nl msg */
1204 static bool ipgre_netlink_encap_parms(struct nlattr *data[],
1205                                       struct ip_tunnel_encap *ipencap)
1206 {
1207         bool ret = false;
1208
1209         memset(ipencap, 0, sizeof(*ipencap));
1210
1211         if (!data)
1212                 return ret;
1213
1214         if (data[IFLA_GRE_ENCAP_TYPE]) {
1215                 ret = true;
1216                 ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]);
1217         }
1218
1219         if (data[IFLA_GRE_ENCAP_FLAGS]) {
1220                 ret = true;
1221                 ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]);
1222         }
1223
1224         if (data[IFLA_GRE_ENCAP_SPORT]) {
1225                 ret = true;
1226                 ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]);
1227         }
1228
1229         if (data[IFLA_GRE_ENCAP_DPORT]) {
1230                 ret = true;
1231                 ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]);
1232         }
1233
1234         return ret;
1235 }
1236
1237 static int gre_tap_init(struct net_device *dev)
1238 {
1239         __gre_tunnel_init(dev);
1240         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
1241         netif_keep_dst(dev);
1242
1243         return ip_tunnel_init(dev);
1244 }
1245
1246 static const struct net_device_ops gre_tap_netdev_ops = {
1247         .ndo_init               = gre_tap_init,
1248         .ndo_uninit             = ip_tunnel_uninit,
1249         .ndo_start_xmit         = gre_tap_xmit,
1250         .ndo_set_mac_address    = eth_mac_addr,
1251         .ndo_validate_addr      = eth_validate_addr,
1252         .ndo_change_mtu         = ip_tunnel_change_mtu,
1253         .ndo_get_stats64        = ip_tunnel_get_stats64,
1254         .ndo_get_iflink         = ip_tunnel_get_iflink,
1255         .ndo_fill_metadata_dst  = gre_fill_metadata_dst,
1256 };
1257
1258 static int erspan_tunnel_init(struct net_device *dev)
1259 {
1260         struct ip_tunnel *tunnel = netdev_priv(dev);
1261
1262         tunnel->tun_hlen = 8;
1263         tunnel->parms.iph.protocol = IPPROTO_GRE;
1264         tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen +
1265                        erspan_hdr_len(tunnel->erspan_ver);
1266
1267         dev->features           |= GRE_FEATURES;
1268         dev->hw_features        |= GRE_FEATURES;
1269         dev->priv_flags         |= IFF_LIVE_ADDR_CHANGE;
1270         netif_keep_dst(dev);
1271
1272         return ip_tunnel_init(dev);
1273 }
1274
1275 static const struct net_device_ops erspan_netdev_ops = {
1276         .ndo_init               = erspan_tunnel_init,
1277         .ndo_uninit             = ip_tunnel_uninit,
1278         .ndo_start_xmit         = erspan_xmit,
1279         .ndo_set_mac_address    = eth_mac_addr,
1280         .ndo_validate_addr      = eth_validate_addr,
1281         .ndo_change_mtu         = ip_tunnel_change_mtu,
1282         .ndo_get_stats64        = ip_tunnel_get_stats64,
1283         .ndo_get_iflink         = ip_tunnel_get_iflink,
1284         .ndo_fill_metadata_dst  = gre_fill_metadata_dst,
1285 };
1286
1287 static void ipgre_tap_setup(struct net_device *dev)
1288 {
1289         ether_setup(dev);
1290         dev->max_mtu = 0;
1291         dev->netdev_ops = &gre_tap_netdev_ops;
1292         dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1293         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
1294         ip_tunnel_setup(dev, gre_tap_net_id);
1295 }
1296
1297 static int
1298 ipgre_newlink_encap_setup(struct net_device *dev, struct nlattr *data[])
1299 {
1300         struct ip_tunnel_encap ipencap;
1301
1302         if (ipgre_netlink_encap_parms(data, &ipencap)) {
1303                 struct ip_tunnel *t = netdev_priv(dev);
1304                 int err = ip_tunnel_encap_setup(t, &ipencap);
1305
1306                 if (err < 0)
1307                         return err;
1308         }
1309
1310         return 0;
1311 }
1312
1313 static int ipgre_newlink(struct net *src_net, struct net_device *dev,
1314                          struct nlattr *tb[], struct nlattr *data[],
1315                          struct netlink_ext_ack *extack)
1316 {
1317         struct ip_tunnel_parm p;
1318         __u32 fwmark = 0;
1319         int err;
1320
1321         err = ipgre_newlink_encap_setup(dev, data);
1322         if (err)
1323                 return err;
1324
1325         err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark);
1326         if (err < 0)
1327                 return err;
1328         return ip_tunnel_newlink(dev, tb, &p, fwmark);
1329 }
1330
1331 static int erspan_newlink(struct net *src_net, struct net_device *dev,
1332                           struct nlattr *tb[], struct nlattr *data[],
1333                           struct netlink_ext_ack *extack)
1334 {
1335         struct ip_tunnel_parm p;
1336         __u32 fwmark = 0;
1337         int err;
1338
1339         err = ipgre_newlink_encap_setup(dev, data);
1340         if (err)
1341                 return err;
1342
1343         err = erspan_netlink_parms(dev, data, tb, &p, &fwmark);
1344         if (err)
1345                 return err;
1346         return ip_tunnel_newlink(dev, tb, &p, fwmark);
1347 }
1348
1349 static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
1350                             struct nlattr *data[],
1351                             struct netlink_ext_ack *extack)
1352 {
1353         struct ip_tunnel *t = netdev_priv(dev);
1354         __u32 fwmark = t->fwmark;
1355         struct ip_tunnel_parm p;
1356         int err;
1357
1358         err = ipgre_newlink_encap_setup(dev, data);
1359         if (err)
1360                 return err;
1361
1362         err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark);
1363         if (err < 0)
1364                 return err;
1365
1366         err = ip_tunnel_changelink(dev, tb, &p, fwmark);
1367         if (err < 0)
1368                 return err;
1369
1370         t->parms.i_flags = p.i_flags;
1371         t->parms.o_flags = p.o_flags;
1372
1373         ipgre_link_update(dev, !tb[IFLA_MTU]);
1374
1375         return 0;
1376 }
1377
1378 static int erspan_changelink(struct net_device *dev, struct nlattr *tb[],
1379                              struct nlattr *data[],
1380                              struct netlink_ext_ack *extack)
1381 {
1382         struct ip_tunnel *t = netdev_priv(dev);
1383         __u32 fwmark = t->fwmark;
1384         struct ip_tunnel_parm p;
1385         int err;
1386
1387         err = ipgre_newlink_encap_setup(dev, data);
1388         if (err)
1389                 return err;
1390
1391         err = erspan_netlink_parms(dev, data, tb, &p, &fwmark);
1392         if (err < 0)
1393                 return err;
1394
1395         err = ip_tunnel_changelink(dev, tb, &p, fwmark);
1396         if (err < 0)
1397                 return err;
1398
1399         t->parms.i_flags = p.i_flags;
1400         t->parms.o_flags = p.o_flags;
1401
1402         return 0;
1403 }
1404
1405 static size_t ipgre_get_size(const struct net_device *dev)
1406 {
1407         return
1408                 /* IFLA_GRE_LINK */
1409                 nla_total_size(4) +
1410                 /* IFLA_GRE_IFLAGS */
1411                 nla_total_size(2) +
1412                 /* IFLA_GRE_OFLAGS */
1413                 nla_total_size(2) +
1414                 /* IFLA_GRE_IKEY */
1415                 nla_total_size(4) +
1416                 /* IFLA_GRE_OKEY */
1417                 nla_total_size(4) +
1418                 /* IFLA_GRE_LOCAL */
1419                 nla_total_size(4) +
1420                 /* IFLA_GRE_REMOTE */
1421                 nla_total_size(4) +
1422                 /* IFLA_GRE_TTL */
1423                 nla_total_size(1) +
1424                 /* IFLA_GRE_TOS */
1425                 nla_total_size(1) +
1426                 /* IFLA_GRE_PMTUDISC */
1427                 nla_total_size(1) +
1428                 /* IFLA_GRE_ENCAP_TYPE */
1429                 nla_total_size(2) +
1430                 /* IFLA_GRE_ENCAP_FLAGS */
1431                 nla_total_size(2) +
1432                 /* IFLA_GRE_ENCAP_SPORT */
1433                 nla_total_size(2) +
1434                 /* IFLA_GRE_ENCAP_DPORT */
1435                 nla_total_size(2) +
1436                 /* IFLA_GRE_COLLECT_METADATA */
1437                 nla_total_size(0) +
1438                 /* IFLA_GRE_IGNORE_DF */
1439                 nla_total_size(1) +
1440                 /* IFLA_GRE_FWMARK */
1441                 nla_total_size(4) +
1442                 /* IFLA_GRE_ERSPAN_INDEX */
1443                 nla_total_size(4) +
1444                 /* IFLA_GRE_ERSPAN_VER */
1445                 nla_total_size(1) +
1446                 /* IFLA_GRE_ERSPAN_DIR */
1447                 nla_total_size(1) +
1448                 /* IFLA_GRE_ERSPAN_HWID */
1449                 nla_total_size(2) +
1450                 0;
1451 }
1452
1453 static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
1454 {
1455         struct ip_tunnel *t = netdev_priv(dev);
1456         struct ip_tunnel_parm *p = &t->parms;
1457         __be16 o_flags = p->o_flags;
1458
1459         if (t->erspan_ver == 1 || t->erspan_ver == 2) {
1460                 if (!t->collect_md)
1461                         o_flags |= TUNNEL_KEY;
1462
1463                 if (nla_put_u8(skb, IFLA_GRE_ERSPAN_VER, t->erspan_ver))
1464                         goto nla_put_failure;
1465
1466                 if (t->erspan_ver == 1) {
1467                         if (nla_put_u32(skb, IFLA_GRE_ERSPAN_INDEX, t->index))
1468                                 goto nla_put_failure;
1469                 } else {
1470                         if (nla_put_u8(skb, IFLA_GRE_ERSPAN_DIR, t->dir))
1471                                 goto nla_put_failure;
1472                         if (nla_put_u16(skb, IFLA_GRE_ERSPAN_HWID, t->hwid))
1473                                 goto nla_put_failure;
1474                 }
1475         }
1476
1477         if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
1478             nla_put_be16(skb, IFLA_GRE_IFLAGS,
1479                          gre_tnl_flags_to_gre_flags(p->i_flags)) ||
1480             nla_put_be16(skb, IFLA_GRE_OFLAGS,
1481                          gre_tnl_flags_to_gre_flags(o_flags)) ||
1482             nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
1483             nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
1484             nla_put_in_addr(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
1485             nla_put_in_addr(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
1486             nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
1487             nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
1488             nla_put_u8(skb, IFLA_GRE_PMTUDISC,
1489                        !!(p->iph.frag_off & htons(IP_DF))) ||
1490             nla_put_u32(skb, IFLA_GRE_FWMARK, t->fwmark))
1491                 goto nla_put_failure;
1492
1493         if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE,
1494                         t->encap.type) ||
1495             nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT,
1496                          t->encap.sport) ||
1497             nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT,
1498                          t->encap.dport) ||
1499             nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS,
1500                         t->encap.flags))
1501                 goto nla_put_failure;
1502
1503         if (nla_put_u8(skb, IFLA_GRE_IGNORE_DF, t->ignore_df))
1504                 goto nla_put_failure;
1505
1506         if (t->collect_md) {
1507                 if (nla_put_flag(skb, IFLA_GRE_COLLECT_METADATA))
1508                         goto nla_put_failure;
1509         }
1510
1511         return 0;
1512
1513 nla_put_failure:
1514         return -EMSGSIZE;
1515 }
1516
1517 static void erspan_setup(struct net_device *dev)
1518 {
1519         struct ip_tunnel *t = netdev_priv(dev);
1520
1521         ether_setup(dev);
1522         dev->max_mtu = 0;
1523         dev->netdev_ops = &erspan_netdev_ops;
1524         dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1525         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
1526         ip_tunnel_setup(dev, erspan_net_id);
1527         t->erspan_ver = 1;
1528 }
1529
1530 static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
1531         [IFLA_GRE_LINK]         = { .type = NLA_U32 },
1532         [IFLA_GRE_IFLAGS]       = { .type = NLA_U16 },
1533         [IFLA_GRE_OFLAGS]       = { .type = NLA_U16 },
1534         [IFLA_GRE_IKEY]         = { .type = NLA_U32 },
1535         [IFLA_GRE_OKEY]         = { .type = NLA_U32 },
1536         [IFLA_GRE_LOCAL]        = { .len = sizeof_field(struct iphdr, saddr) },
1537         [IFLA_GRE_REMOTE]       = { .len = sizeof_field(struct iphdr, daddr) },
1538         [IFLA_GRE_TTL]          = { .type = NLA_U8 },
1539         [IFLA_GRE_TOS]          = { .type = NLA_U8 },
1540         [IFLA_GRE_PMTUDISC]     = { .type = NLA_U8 },
1541         [IFLA_GRE_ENCAP_TYPE]   = { .type = NLA_U16 },
1542         [IFLA_GRE_ENCAP_FLAGS]  = { .type = NLA_U16 },
1543         [IFLA_GRE_ENCAP_SPORT]  = { .type = NLA_U16 },
1544         [IFLA_GRE_ENCAP_DPORT]  = { .type = NLA_U16 },
1545         [IFLA_GRE_COLLECT_METADATA]     = { .type = NLA_FLAG },
1546         [IFLA_GRE_IGNORE_DF]    = { .type = NLA_U8 },
1547         [IFLA_GRE_FWMARK]       = { .type = NLA_U32 },
1548         [IFLA_GRE_ERSPAN_INDEX] = { .type = NLA_U32 },
1549         [IFLA_GRE_ERSPAN_VER]   = { .type = NLA_U8 },
1550         [IFLA_GRE_ERSPAN_DIR]   = { .type = NLA_U8 },
1551         [IFLA_GRE_ERSPAN_HWID]  = { .type = NLA_U16 },
1552 };
1553
1554 static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
1555         .kind           = "gre",
1556         .maxtype        = IFLA_GRE_MAX,
1557         .policy         = ipgre_policy,
1558         .priv_size      = sizeof(struct ip_tunnel),
1559         .setup          = ipgre_tunnel_setup,
1560         .validate       = ipgre_tunnel_validate,
1561         .newlink        = ipgre_newlink,
1562         .changelink     = ipgre_changelink,
1563         .dellink        = ip_tunnel_dellink,
1564         .get_size       = ipgre_get_size,
1565         .fill_info      = ipgre_fill_info,
1566         .get_link_net   = ip_tunnel_get_link_net,
1567 };
1568
1569 static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
1570         .kind           = "gretap",
1571         .maxtype        = IFLA_GRE_MAX,
1572         .policy         = ipgre_policy,
1573         .priv_size      = sizeof(struct ip_tunnel),
1574         .setup          = ipgre_tap_setup,
1575         .validate       = ipgre_tap_validate,
1576         .newlink        = ipgre_newlink,
1577         .changelink     = ipgre_changelink,
1578         .dellink        = ip_tunnel_dellink,
1579         .get_size       = ipgre_get_size,
1580         .fill_info      = ipgre_fill_info,
1581         .get_link_net   = ip_tunnel_get_link_net,
1582 };
1583
1584 static struct rtnl_link_ops erspan_link_ops __read_mostly = {
1585         .kind           = "erspan",
1586         .maxtype        = IFLA_GRE_MAX,
1587         .policy         = ipgre_policy,
1588         .priv_size      = sizeof(struct ip_tunnel),
1589         .setup          = erspan_setup,
1590         .validate       = erspan_validate,
1591         .newlink        = erspan_newlink,
1592         .changelink     = erspan_changelink,
1593         .dellink        = ip_tunnel_dellink,
1594         .get_size       = ipgre_get_size,
1595         .fill_info      = ipgre_fill_info,
1596         .get_link_net   = ip_tunnel_get_link_net,
1597 };
1598
1599 struct net_device *gretap_fb_dev_create(struct net *net, const char *name,
1600                                         u8 name_assign_type)
1601 {
1602         struct nlattr *tb[IFLA_MAX + 1];
1603         struct net_device *dev;
1604         LIST_HEAD(list_kill);
1605         struct ip_tunnel *t;
1606         int err;
1607
1608         memset(&tb, 0, sizeof(tb));
1609
1610         dev = rtnl_create_link(net, name, name_assign_type,
1611                                &ipgre_tap_ops, tb, NULL);
1612         if (IS_ERR(dev))
1613                 return dev;
1614
1615         /* Configure flow based GRE device. */
1616         t = netdev_priv(dev);
1617         t->collect_md = true;
1618
1619         err = ipgre_newlink(net, dev, tb, NULL, NULL);
1620         if (err < 0) {
1621                 free_netdev(dev);
1622                 return ERR_PTR(err);
1623         }
1624
1625         /* openvswitch users expect packet sizes to be unrestricted,
1626          * so set the largest MTU we can.
1627          */
1628         err = __ip_tunnel_change_mtu(dev, IP_MAX_MTU, false);
1629         if (err)
1630                 goto out;
1631
1632         err = rtnl_configure_link(dev, NULL);
1633         if (err < 0)
1634                 goto out;
1635
1636         return dev;
1637 out:
1638         ip_tunnel_dellink(dev, &list_kill);
1639         unregister_netdevice_many(&list_kill);
1640         return ERR_PTR(err);
1641 }
1642 EXPORT_SYMBOL_GPL(gretap_fb_dev_create);
1643
1644 static int __net_init ipgre_tap_init_net(struct net *net)
1645 {
1646         return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, "gretap0");
1647 }
1648
1649 static void __net_exit ipgre_tap_exit_batch_net(struct list_head *list_net)
1650 {
1651         ip_tunnel_delete_nets(list_net, gre_tap_net_id, &ipgre_tap_ops);
1652 }
1653
1654 static struct pernet_operations ipgre_tap_net_ops = {
1655         .init = ipgre_tap_init_net,
1656         .exit_batch = ipgre_tap_exit_batch_net,
1657         .id   = &gre_tap_net_id,
1658         .size = sizeof(struct ip_tunnel_net),
1659 };
1660
1661 static int __net_init erspan_init_net(struct net *net)
1662 {
1663         return ip_tunnel_init_net(net, erspan_net_id,
1664                                   &erspan_link_ops, "erspan0");
1665 }
1666
1667 static void __net_exit erspan_exit_batch_net(struct list_head *net_list)
1668 {
1669         ip_tunnel_delete_nets(net_list, erspan_net_id, &erspan_link_ops);
1670 }
1671
1672 static struct pernet_operations erspan_net_ops = {
1673         .init = erspan_init_net,
1674         .exit_batch = erspan_exit_batch_net,
1675         .id   = &erspan_net_id,
1676         .size = sizeof(struct ip_tunnel_net),
1677 };
1678
1679 static int __init ipgre_init(void)
1680 {
1681         int err;
1682
1683         pr_info("GRE over IPv4 tunneling driver\n");
1684
1685         err = register_pernet_device(&ipgre_net_ops);
1686         if (err < 0)
1687                 return err;
1688
1689         err = register_pernet_device(&ipgre_tap_net_ops);
1690         if (err < 0)
1691                 goto pnet_tap_failed;
1692
1693         err = register_pernet_device(&erspan_net_ops);
1694         if (err < 0)
1695                 goto pnet_erspan_failed;
1696
1697         err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
1698         if (err < 0) {
1699                 pr_info("%s: can't add protocol\n", __func__);
1700                 goto add_proto_failed;
1701         }
1702
1703         err = rtnl_link_register(&ipgre_link_ops);
1704         if (err < 0)
1705                 goto rtnl_link_failed;
1706
1707         err = rtnl_link_register(&ipgre_tap_ops);
1708         if (err < 0)
1709                 goto tap_ops_failed;
1710
1711         err = rtnl_link_register(&erspan_link_ops);
1712         if (err < 0)
1713                 goto erspan_link_failed;
1714
1715         return 0;
1716
1717 erspan_link_failed:
1718         rtnl_link_unregister(&ipgre_tap_ops);
1719 tap_ops_failed:
1720         rtnl_link_unregister(&ipgre_link_ops);
1721 rtnl_link_failed:
1722         gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1723 add_proto_failed:
1724         unregister_pernet_device(&erspan_net_ops);
1725 pnet_erspan_failed:
1726         unregister_pernet_device(&ipgre_tap_net_ops);
1727 pnet_tap_failed:
1728         unregister_pernet_device(&ipgre_net_ops);
1729         return err;
1730 }
1731
1732 static void __exit ipgre_fini(void)
1733 {
1734         rtnl_link_unregister(&ipgre_tap_ops);
1735         rtnl_link_unregister(&ipgre_link_ops);
1736         rtnl_link_unregister(&erspan_link_ops);
1737         gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1738         unregister_pernet_device(&ipgre_tap_net_ops);
1739         unregister_pernet_device(&ipgre_net_ops);
1740         unregister_pernet_device(&erspan_net_ops);
1741 }
1742
1743 module_init(ipgre_init);
1744 module_exit(ipgre_fini);
1745 MODULE_LICENSE("GPL");
1746 MODULE_ALIAS_RTNL_LINK("gre");
1747 MODULE_ALIAS_RTNL_LINK("gretap");
1748 MODULE_ALIAS_RTNL_LINK("erspan");
1749 MODULE_ALIAS_NETDEV("gre0");
1750 MODULE_ALIAS_NETDEV("gretap0");
1751 MODULE_ALIAS_NETDEV("erspan0");