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