11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * Linux NET3: GRE over IP protocol decoder. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru) 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 71da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 81da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 91da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 101da177e4SLinus Torvalds * 111da177e4SLinus Torvalds */ 121da177e4SLinus Torvalds 13afd46503SJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 14afd46503SJoe Perches 154fc268d2SRandy Dunlap #include <linux/capability.h> 161da177e4SLinus Torvalds #include <linux/module.h> 171da177e4SLinus Torvalds #include <linux/types.h> 181da177e4SLinus Torvalds #include <linux/kernel.h> 195a0e3ad6STejun Heo #include <linux/slab.h> 207c0f6ba6SLinus Torvalds #include <linux/uaccess.h> 211da177e4SLinus Torvalds #include <linux/skbuff.h> 221da177e4SLinus Torvalds #include <linux/netdevice.h> 231da177e4SLinus Torvalds #include <linux/in.h> 241da177e4SLinus Torvalds #include <linux/tcp.h> 251da177e4SLinus Torvalds #include <linux/udp.h> 261da177e4SLinus Torvalds #include <linux/if_arp.h> 272e15ea39SPravin B Shelar #include <linux/if_vlan.h> 281da177e4SLinus Torvalds #include <linux/init.h> 291da177e4SLinus Torvalds #include <linux/in6.h> 301da177e4SLinus Torvalds #include <linux/inetdevice.h> 311da177e4SLinus Torvalds #include <linux/igmp.h> 321da177e4SLinus Torvalds #include <linux/netfilter_ipv4.h> 33e1a80002SHerbert Xu #include <linux/etherdevice.h> 3446f25dffSKris Katterjohn #include <linux/if_ether.h> 351da177e4SLinus Torvalds 361da177e4SLinus Torvalds #include <net/sock.h> 371da177e4SLinus Torvalds #include <net/ip.h> 381da177e4SLinus Torvalds #include <net/icmp.h> 391da177e4SLinus Torvalds #include <net/protocol.h> 40c5441932SPravin B Shelar #include <net/ip_tunnels.h> 411da177e4SLinus Torvalds #include <net/arp.h> 421da177e4SLinus Torvalds #include <net/checksum.h> 431da177e4SLinus Torvalds #include <net/dsfield.h> 441da177e4SLinus Torvalds #include <net/inet_ecn.h> 451da177e4SLinus Torvalds #include <net/xfrm.h> 4659a4c759SPavel Emelyanov #include <net/net_namespace.h> 4759a4c759SPavel Emelyanov #include <net/netns/generic.h> 48c19e654dSHerbert Xu #include <net/rtnetlink.h> 4900959adeSDmitry Kozlov #include <net/gre.h> 502e15ea39SPravin B Shelar #include <net/dst_metadata.h> 5184e54fe0SWilliam Tu #include <net/erspan.h> 521da177e4SLinus Torvalds 531da177e4SLinus Torvalds /* 541da177e4SLinus Torvalds Problems & solutions 551da177e4SLinus Torvalds -------------------- 561da177e4SLinus Torvalds 571da177e4SLinus Torvalds 1. The most important issue is detecting local dead loops. 581da177e4SLinus Torvalds They would cause complete host lockup in transmit, which 591da177e4SLinus Torvalds would be "resolved" by stack overflow or, if queueing is enabled, 601da177e4SLinus Torvalds with infinite looping in net_bh. 611da177e4SLinus Torvalds 621da177e4SLinus Torvalds We cannot track such dead loops during route installation, 631da177e4SLinus Torvalds it is infeasible task. The most general solutions would be 641da177e4SLinus Torvalds to keep skb->encapsulation counter (sort of local ttl), 656d0722a2SEric Dumazet and silently drop packet when it expires. It is a good 66bff52857Sstephen hemminger solution, but it supposes maintaining new variable in ALL 671da177e4SLinus Torvalds skb, even if no tunneling is used. 681da177e4SLinus Torvalds 696d0722a2SEric Dumazet Current solution: xmit_recursion breaks dead loops. This is a percpu 706d0722a2SEric Dumazet counter, since when we enter the first ndo_xmit(), cpu migration is 716d0722a2SEric Dumazet forbidden. We force an exit if this counter reaches RECURSION_LIMIT 721da177e4SLinus Torvalds 731da177e4SLinus Torvalds 2. Networking dead loops would not kill routers, but would really 741da177e4SLinus Torvalds kill network. IP hop limit plays role of "t->recursion" in this case, 751da177e4SLinus Torvalds if we copy it from packet being encapsulated to upper header. 761da177e4SLinus Torvalds It is very good solution, but it introduces two problems: 771da177e4SLinus Torvalds 781da177e4SLinus Torvalds - Routing protocols, using packets with ttl=1 (OSPF, RIP2), 791da177e4SLinus Torvalds do not work over tunnels. 801da177e4SLinus Torvalds - traceroute does not work. I planned to relay ICMP from tunnel, 811da177e4SLinus Torvalds so that this problem would be solved and traceroute output 821da177e4SLinus Torvalds would even more informative. This idea appeared to be wrong: 831da177e4SLinus Torvalds only Linux complies to rfc1812 now (yes, guys, Linux is the only 841da177e4SLinus Torvalds true router now :-)), all routers (at least, in neighbourhood of mine) 851da177e4SLinus Torvalds return only 8 bytes of payload. It is the end. 861da177e4SLinus Torvalds 871da177e4SLinus Torvalds Hence, if we want that OSPF worked or traceroute said something reasonable, 881da177e4SLinus Torvalds we should search for another solution. 891da177e4SLinus Torvalds 901da177e4SLinus Torvalds One of them is to parse packet trying to detect inner encapsulation 911da177e4SLinus Torvalds made by our node. It is difficult or even impossible, especially, 92bff52857Sstephen hemminger taking into account fragmentation. TO be short, ttl is not solution at all. 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds Current solution: The solution was UNEXPECTEDLY SIMPLE. 951da177e4SLinus Torvalds We force DF flag on tunnels with preconfigured hop limit, 961da177e4SLinus Torvalds that is ALL. :-) Well, it does not remove the problem completely, 971da177e4SLinus Torvalds but exponential growth of network traffic is changed to linear 981da177e4SLinus Torvalds (branches, that exceed pmtu are pruned) and tunnel mtu 99bff52857Sstephen hemminger rapidly degrades to value <68, where looping stops. 1001da177e4SLinus Torvalds Yes, it is not good if there exists a router in the loop, 1011da177e4SLinus Torvalds which does not force DF, even when encapsulating packets have DF set. 1021da177e4SLinus Torvalds But it is not our problem! Nobody could accuse us, we made 1031da177e4SLinus Torvalds all that we could make. Even if it is your gated who injected 1041da177e4SLinus Torvalds fatal route to network, even if it were you who configured 1051da177e4SLinus Torvalds fatal static route: you are innocent. :-) 1061da177e4SLinus Torvalds 1071da177e4SLinus Torvalds Alexey Kuznetsov. 1081da177e4SLinus Torvalds */ 1091da177e4SLinus Torvalds 110eccc1bb8Sstephen hemminger static bool log_ecn_error = true; 111eccc1bb8Sstephen hemminger module_param(log_ecn_error, bool, 0644); 112eccc1bb8Sstephen hemminger MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN"); 113eccc1bb8Sstephen hemminger 114c19e654dSHerbert Xu static struct rtnl_link_ops ipgre_link_ops __read_mostly; 1151da177e4SLinus Torvalds static int ipgre_tunnel_init(struct net_device *dev); 1161a66a836SWilliam Tu static void erspan_build_header(struct sk_buff *skb, 117c69de58bSWilliam Tu u32 id, u32 index, 118a3222dc9SWilliam Tu bool truncate, bool is_ipv4); 119eb8ce741SPavel Emelyanov 120c7d03a00SAlexey Dobriyan static unsigned int ipgre_net_id __read_mostly; 121c7d03a00SAlexey Dobriyan static unsigned int gre_tap_net_id __read_mostly; 12284e54fe0SWilliam Tu static unsigned int erspan_net_id __read_mostly; 123eb8ce741SPavel Emelyanov 1249f57c67cSPravin B Shelar static void ipgre_err(struct sk_buff *skb, u32 info, 125bda7bb46SPravin B Shelar const struct tnl_ptk_info *tpi) 1261da177e4SLinus Torvalds { 1271da177e4SLinus Torvalds 128071f92d0SRami Rosen /* All the routers (except for Linux) return only 1291da177e4SLinus Torvalds 8 bytes of packet payload. It means, that precise relaying of 1301da177e4SLinus Torvalds ICMP in the real Internet is absolutely infeasible. 1311da177e4SLinus Torvalds 1321da177e4SLinus Torvalds Moreover, Cisco "wise men" put GRE key to the third word 133c5441932SPravin B Shelar in GRE header. It makes impossible maintaining even soft 134c5441932SPravin B Shelar state for keyed GRE tunnels with enabled checksum. Tell 135c5441932SPravin B Shelar them "thank you". 1361da177e4SLinus Torvalds 1371da177e4SLinus Torvalds Well, I wonder, rfc1812 was written by Cisco employee, 138bff52857Sstephen hemminger what the hell these idiots break standards established 139bff52857Sstephen hemminger by themselves??? 1401da177e4SLinus Torvalds */ 141c5441932SPravin B Shelar struct net *net = dev_net(skb->dev); 142c5441932SPravin B Shelar struct ip_tunnel_net *itn; 14396f5a846SEric Dumazet const struct iphdr *iph; 14488c7664fSArnaldo Carvalho de Melo const int type = icmp_hdr(skb)->type; 14588c7664fSArnaldo Carvalho de Melo const int code = icmp_hdr(skb)->code; 14620e1954fSEric Dumazet unsigned int data_len = 0; 1471da177e4SLinus Torvalds struct ip_tunnel *t; 148d2083287Sstephen hemminger 1491da177e4SLinus Torvalds switch (type) { 1501da177e4SLinus Torvalds default: 1511da177e4SLinus Torvalds case ICMP_PARAMETERPROB: 1529f57c67cSPravin B Shelar return; 1531da177e4SLinus Torvalds 1541da177e4SLinus Torvalds case ICMP_DEST_UNREACH: 1551da177e4SLinus Torvalds switch (code) { 1561da177e4SLinus Torvalds case ICMP_SR_FAILED: 1571da177e4SLinus Torvalds case ICMP_PORT_UNREACH: 1581da177e4SLinus Torvalds /* Impossible event. */ 1599f57c67cSPravin B Shelar return; 1601da177e4SLinus Torvalds default: 1611da177e4SLinus Torvalds /* All others are translated to HOST_UNREACH. 1621da177e4SLinus Torvalds rfc2003 contains "deep thoughts" about NET_UNREACH, 1631da177e4SLinus Torvalds I believe they are just ether pollution. --ANK 1641da177e4SLinus Torvalds */ 1651da177e4SLinus Torvalds break; 1661da177e4SLinus Torvalds } 1671da177e4SLinus Torvalds break; 1689f57c67cSPravin B Shelar 1691da177e4SLinus Torvalds case ICMP_TIME_EXCEEDED: 1701da177e4SLinus Torvalds if (code != ICMP_EXC_TTL) 1719f57c67cSPravin B Shelar return; 17220e1954fSEric Dumazet data_len = icmp_hdr(skb)->un.reserved[1] * 4; /* RFC 4884 4.1 */ 1731da177e4SLinus Torvalds break; 17455be7a9cSDavid S. Miller 17555be7a9cSDavid S. Miller case ICMP_REDIRECT: 17655be7a9cSDavid S. Miller break; 1771da177e4SLinus Torvalds } 1781da177e4SLinus Torvalds 179bda7bb46SPravin B Shelar if (tpi->proto == htons(ETH_P_TEB)) 180c5441932SPravin B Shelar itn = net_generic(net, gre_tap_net_id); 181c5441932SPravin B Shelar else 182c5441932SPravin B Shelar itn = net_generic(net, ipgre_net_id); 183c5441932SPravin B Shelar 184c0c0c50fSDuan Jiong iph = (const struct iphdr *)(icmp_hdr(skb) + 1); 185bda7bb46SPravin B Shelar t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags, 186bda7bb46SPravin B Shelar iph->daddr, iph->saddr, tpi->key); 187d2083287Sstephen hemminger 18851456b29SIan Morris if (!t) 1899f57c67cSPravin B Shelar return; 19036393395SDavid S. Miller 1919b8c6d7bSEric Dumazet #if IS_ENABLED(CONFIG_IPV6) 1929b8c6d7bSEric Dumazet if (tpi->proto == htons(ETH_P_IPV6) && 19320e1954fSEric Dumazet !ip6_err_gen_icmpv6_unreach(skb, iph->ihl * 4 + tpi->hdr_len, 19420e1954fSEric Dumazet type, data_len)) 1959b8c6d7bSEric Dumazet return; 1969b8c6d7bSEric Dumazet #endif 1979b8c6d7bSEric Dumazet 19836393395SDavid S. Miller if (t->parms.iph.daddr == 0 || 199f97c1e0cSJoe Perches ipv4_is_multicast(t->parms.iph.daddr)) 2009f57c67cSPravin B Shelar return; 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED) 2039f57c67cSPravin B Shelar return; 2041da177e4SLinus Torvalds 205da6185d8SWei Yongjun if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO)) 2061da177e4SLinus Torvalds t->err_count++; 2071da177e4SLinus Torvalds else 2081da177e4SLinus Torvalds t->err_count = 1; 2091da177e4SLinus Torvalds t->err_time = jiffies; 2109f57c67cSPravin B Shelar } 2119f57c67cSPravin B Shelar 2129f57c67cSPravin B Shelar static void gre_err(struct sk_buff *skb, u32 info) 2139f57c67cSPravin B Shelar { 2149f57c67cSPravin B Shelar /* All the routers (except for Linux) return only 2159f57c67cSPravin B Shelar * 8 bytes of packet payload. It means, that precise relaying of 2169f57c67cSPravin B Shelar * ICMP in the real Internet is absolutely infeasible. 2179f57c67cSPravin B Shelar * 2189f57c67cSPravin B Shelar * Moreover, Cisco "wise men" put GRE key to the third word 2199f57c67cSPravin B Shelar * in GRE header. It makes impossible maintaining even soft 2209f57c67cSPravin B Shelar * state for keyed 2219f57c67cSPravin B Shelar * GRE tunnels with enabled checksum. Tell them "thank you". 2229f57c67cSPravin B Shelar * 2239f57c67cSPravin B Shelar * Well, I wonder, rfc1812 was written by Cisco employee, 2249f57c67cSPravin B Shelar * what the hell these idiots break standards established 2259f57c67cSPravin B Shelar * by themselves??? 2269f57c67cSPravin B Shelar */ 2279f57c67cSPravin B Shelar 228e582615aSEric Dumazet const struct iphdr *iph = (struct iphdr *)skb->data; 2299f57c67cSPravin B Shelar const int type = icmp_hdr(skb)->type; 2309f57c67cSPravin B Shelar const int code = icmp_hdr(skb)->code; 2319f57c67cSPravin B Shelar struct tnl_ptk_info tpi; 2329f57c67cSPravin B Shelar bool csum_err = false; 2339f57c67cSPravin B Shelar 234e582615aSEric Dumazet if (gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP), 235e582615aSEric Dumazet iph->ihl * 4) < 0) { 2369f57c67cSPravin B Shelar if (!csum_err) /* ignore csum errors. */ 2379f57c67cSPravin B Shelar return; 2389f57c67cSPravin B Shelar } 2399f57c67cSPravin B Shelar 2409f57c67cSPravin B Shelar if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) { 2419f57c67cSPravin B Shelar ipv4_update_pmtu(skb, dev_net(skb->dev), info, 2429f57c67cSPravin B Shelar skb->dev->ifindex, 0, IPPROTO_GRE, 0); 2439f57c67cSPravin B Shelar return; 2449f57c67cSPravin B Shelar } 2459f57c67cSPravin B Shelar if (type == ICMP_REDIRECT) { 2469f57c67cSPravin B Shelar ipv4_redirect(skb, dev_net(skb->dev), skb->dev->ifindex, 0, 2479f57c67cSPravin B Shelar IPPROTO_GRE, 0); 2489f57c67cSPravin B Shelar return; 2499f57c67cSPravin B Shelar } 2509f57c67cSPravin B Shelar 2519f57c67cSPravin B Shelar ipgre_err(skb, info, &tpi); 2521da177e4SLinus Torvalds } 2531da177e4SLinus Torvalds 25484e54fe0SWilliam Tu static int erspan_rcv(struct sk_buff *skb, struct tnl_ptk_info *tpi, 25584e54fe0SWilliam Tu int gre_hdr_len) 25684e54fe0SWilliam Tu { 25784e54fe0SWilliam Tu struct net *net = dev_net(skb->dev); 25884e54fe0SWilliam Tu struct metadata_dst *tun_dst = NULL; 2591d7e2ed2SWilliam Tu struct erspan_base_hdr *ershdr; 2601d7e2ed2SWilliam Tu struct erspan_metadata *pkt_md; 26184e54fe0SWilliam Tu struct ip_tunnel_net *itn; 26284e54fe0SWilliam Tu struct ip_tunnel *tunnel; 26384e54fe0SWilliam Tu const struct iphdr *iph; 264*3df19283SWilliam Tu struct erspan_md2 *md2; 2651d7e2ed2SWilliam Tu int ver; 26684e54fe0SWilliam Tu int len; 26784e54fe0SWilliam Tu 26884e54fe0SWilliam Tu itn = net_generic(net, erspan_net_id); 26984e54fe0SWilliam Tu len = gre_hdr_len + sizeof(*ershdr); 27084e54fe0SWilliam Tu 2711d7e2ed2SWilliam Tu /* Check based hdr len */ 27284e54fe0SWilliam Tu if (unlikely(!pskb_may_pull(skb, len))) 273c05fad57SHaishuang Yan return PACKET_REJECT; 27484e54fe0SWilliam Tu 27584e54fe0SWilliam Tu iph = ip_hdr(skb); 2761d7e2ed2SWilliam Tu ershdr = (struct erspan_base_hdr *)(skb->data + gre_hdr_len); 277c69de58bSWilliam Tu ver = ershdr->ver; 27884e54fe0SWilliam Tu 27984e54fe0SWilliam Tu /* The original GRE header does not have key field, 28084e54fe0SWilliam Tu * Use ERSPAN 10-bit session ID as key. 28184e54fe0SWilliam Tu */ 282c69de58bSWilliam Tu tpi->key = cpu_to_be32(get_session_id(ershdr)); 28384e54fe0SWilliam Tu tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, 28484e54fe0SWilliam Tu tpi->flags | TUNNEL_KEY, 28584e54fe0SWilliam Tu iph->saddr, iph->daddr, tpi->key); 28684e54fe0SWilliam Tu 28784e54fe0SWilliam Tu if (tunnel) { 2881d7e2ed2SWilliam Tu len = gre_hdr_len + erspan_hdr_len(ver); 2891d7e2ed2SWilliam Tu if (unlikely(!pskb_may_pull(skb, len))) 290ae3e1337SWilliam Tu return PACKET_REJECT; 2911d7e2ed2SWilliam Tu 292d91e8db5SWilliam Tu ershdr = (struct erspan_base_hdr *)(skb->data + gre_hdr_len); 293d91e8db5SWilliam Tu pkt_md = (struct erspan_metadata *)(ershdr + 1); 294d91e8db5SWilliam Tu 29584e54fe0SWilliam Tu if (__iptunnel_pull_header(skb, 2961d7e2ed2SWilliam Tu len, 29784e54fe0SWilliam Tu htons(ETH_P_TEB), 29884e54fe0SWilliam Tu false, false) < 0) 29984e54fe0SWilliam Tu goto drop; 30084e54fe0SWilliam Tu 3011a66a836SWilliam Tu if (tunnel->collect_md) { 3021a66a836SWilliam Tu struct ip_tunnel_info *info; 3031a66a836SWilliam Tu struct erspan_metadata *md; 3041a66a836SWilliam Tu __be64 tun_id; 3051a66a836SWilliam Tu __be16 flags; 3061a66a836SWilliam Tu 3071a66a836SWilliam Tu tpi->flags |= TUNNEL_KEY; 3081a66a836SWilliam Tu flags = tpi->flags; 3091a66a836SWilliam Tu tun_id = key32_to_tunnel_id(tpi->key); 3101a66a836SWilliam Tu 3111a66a836SWilliam Tu tun_dst = ip_tun_rx_dst(skb, flags, 3121a66a836SWilliam Tu tun_id, sizeof(*md)); 3131a66a836SWilliam Tu if (!tun_dst) 3141a66a836SWilliam Tu return PACKET_REJECT; 3151a66a836SWilliam Tu 3161a66a836SWilliam Tu md = ip_tunnel_info_opts(&tun_dst->u.tun_info); 317f551c91dSWilliam Tu md->version = ver; 318*3df19283SWilliam Tu md2 = &md->u.md2; 319*3df19283SWilliam Tu memcpy(md2, pkt_md, ver == 1 ? ERSPAN_V1_MDSIZE : 320*3df19283SWilliam Tu ERSPAN_V2_MDSIZE); 321f551c91dSWilliam Tu 3221a66a836SWilliam Tu info = &tun_dst->u.tun_info; 3231a66a836SWilliam Tu info->key.tun_flags |= TUNNEL_ERSPAN_OPT; 3241a66a836SWilliam Tu info->options_len = sizeof(*md); 3251a66a836SWilliam Tu } else { 326f551c91dSWilliam Tu tunnel->erspan_ver = ver; 327f551c91dSWilliam Tu if (ver == 1) { 3281d7e2ed2SWilliam Tu tunnel->index = ntohl(pkt_md->u.index); 329f551c91dSWilliam Tu } else { 330c69de58bSWilliam Tu tunnel->dir = pkt_md->u.md2.dir; 331c69de58bSWilliam Tu tunnel->hwid = get_hwid(&pkt_md->u.md2); 332f551c91dSWilliam Tu } 333f551c91dSWilliam Tu 3341a66a836SWilliam Tu } 3351a66a836SWilliam Tu 33684e54fe0SWilliam Tu skb_reset_mac_header(skb); 33784e54fe0SWilliam Tu ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error); 33884e54fe0SWilliam Tu return PACKET_RCVD; 33984e54fe0SWilliam Tu } 34084e54fe0SWilliam Tu drop: 34184e54fe0SWilliam Tu kfree_skb(skb); 34284e54fe0SWilliam Tu return PACKET_RCVD; 34384e54fe0SWilliam Tu } 34484e54fe0SWilliam Tu 345125372faSJiri Benc static int __ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi, 346125372faSJiri Benc struct ip_tunnel_net *itn, int hdr_len, bool raw_proto) 3471da177e4SLinus Torvalds { 3482e15ea39SPravin B Shelar struct metadata_dst *tun_dst = NULL; 349b71d1d42SEric Dumazet const struct iphdr *iph; 3501da177e4SLinus Torvalds struct ip_tunnel *tunnel; 3511da177e4SLinus Torvalds 352eddc9ec5SArnaldo Carvalho de Melo iph = ip_hdr(skb); 353bda7bb46SPravin B Shelar tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags, 354bda7bb46SPravin B Shelar iph->saddr, iph->daddr, tpi->key); 3551da177e4SLinus Torvalds 356d2083287Sstephen hemminger if (tunnel) { 357125372faSJiri Benc if (__iptunnel_pull_header(skb, hdr_len, tpi->proto, 358125372faSJiri Benc raw_proto, false) < 0) 359244a797bSJiri Benc goto drop; 360244a797bSJiri Benc 361e271c7b4SJiri Benc if (tunnel->dev->type != ARPHRD_NONE) 3620e3da5bbSTimo Teräs skb_pop_mac_header(skb); 363e271c7b4SJiri Benc else 364e271c7b4SJiri Benc skb_reset_mac_header(skb); 3652e15ea39SPravin B Shelar if (tunnel->collect_md) { 366c29a70d2SPravin B Shelar __be16 flags; 367c29a70d2SPravin B Shelar __be64 tun_id; 3682e15ea39SPravin B Shelar 369c29a70d2SPravin B Shelar flags = tpi->flags & (TUNNEL_CSUM | TUNNEL_KEY); 370d817f432SAmir Vadai tun_id = key32_to_tunnel_id(tpi->key); 371c29a70d2SPravin B Shelar tun_dst = ip_tun_rx_dst(skb, flags, tun_id, 0); 3722e15ea39SPravin B Shelar if (!tun_dst) 3732e15ea39SPravin B Shelar return PACKET_REJECT; 3742e15ea39SPravin B Shelar } 3752e15ea39SPravin B Shelar 3762e15ea39SPravin B Shelar ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error); 377bda7bb46SPravin B Shelar return PACKET_RCVD; 3781da177e4SLinus Torvalds } 379125372faSJiri Benc return PACKET_NEXT; 380244a797bSJiri Benc 381244a797bSJiri Benc drop: 382244a797bSJiri Benc kfree_skb(skb); 383244a797bSJiri Benc return PACKET_RCVD; 3841da177e4SLinus Torvalds } 3851da177e4SLinus Torvalds 386125372faSJiri Benc static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi, 387125372faSJiri Benc int hdr_len) 388125372faSJiri Benc { 389125372faSJiri Benc struct net *net = dev_net(skb->dev); 390125372faSJiri Benc struct ip_tunnel_net *itn; 391125372faSJiri Benc int res; 392125372faSJiri Benc 393125372faSJiri Benc if (tpi->proto == htons(ETH_P_TEB)) 394125372faSJiri Benc itn = net_generic(net, gre_tap_net_id); 395125372faSJiri Benc else 396125372faSJiri Benc itn = net_generic(net, ipgre_net_id); 397125372faSJiri Benc 398125372faSJiri Benc res = __ipgre_rcv(skb, tpi, itn, hdr_len, false); 399125372faSJiri Benc if (res == PACKET_NEXT && tpi->proto == htons(ETH_P_TEB)) { 400125372faSJiri Benc /* ipgre tunnels in collect metadata mode should receive 401125372faSJiri Benc * also ETH_P_TEB traffic. 402125372faSJiri Benc */ 403125372faSJiri Benc itn = net_generic(net, ipgre_net_id); 404125372faSJiri Benc res = __ipgre_rcv(skb, tpi, itn, hdr_len, true); 405125372faSJiri Benc } 406125372faSJiri Benc return res; 407125372faSJiri Benc } 408125372faSJiri Benc 4099f57c67cSPravin B Shelar static int gre_rcv(struct sk_buff *skb) 4109f57c67cSPravin B Shelar { 4119f57c67cSPravin B Shelar struct tnl_ptk_info tpi; 4129f57c67cSPravin B Shelar bool csum_err = false; 41395f5c64cSTom Herbert int hdr_len; 4149f57c67cSPravin B Shelar 4159f57c67cSPravin B Shelar #ifdef CONFIG_NET_IPGRE_BROADCAST 4169f57c67cSPravin B Shelar if (ipv4_is_multicast(ip_hdr(skb)->daddr)) { 4179f57c67cSPravin B Shelar /* Looped back packet, drop it! */ 4189f57c67cSPravin B Shelar if (rt_is_output_route(skb_rtable(skb))) 4199f57c67cSPravin B Shelar goto drop; 4209f57c67cSPravin B Shelar } 4219f57c67cSPravin B Shelar #endif 4229f57c67cSPravin B Shelar 423e582615aSEric Dumazet hdr_len = gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP), 0); 424f132ae7cSJiri Benc if (hdr_len < 0) 42595f5c64cSTom Herbert goto drop; 42695f5c64cSTom Herbert 427f551c91dSWilliam Tu if (unlikely(tpi.proto == htons(ETH_P_ERSPAN) || 428f551c91dSWilliam Tu tpi.proto == htons(ETH_P_ERSPAN2))) { 42984e54fe0SWilliam Tu if (erspan_rcv(skb, &tpi, hdr_len) == PACKET_RCVD) 43084e54fe0SWilliam Tu return 0; 431dd8d5b8cSHaishuang Yan goto out; 43284e54fe0SWilliam Tu } 43384e54fe0SWilliam Tu 434244a797bSJiri Benc if (ipgre_rcv(skb, &tpi, hdr_len) == PACKET_RCVD) 4359f57c67cSPravin B Shelar return 0; 4369f57c67cSPravin B Shelar 437dd8d5b8cSHaishuang Yan out: 4389f57c67cSPravin B Shelar icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0); 4399f57c67cSPravin B Shelar drop: 4409f57c67cSPravin B Shelar kfree_skb(skb); 4419f57c67cSPravin B Shelar return 0; 4429f57c67cSPravin B Shelar } 4439f57c67cSPravin B Shelar 444c5441932SPravin B Shelar static void __gre_xmit(struct sk_buff *skb, struct net_device *dev, 445c5441932SPravin B Shelar const struct iphdr *tnl_params, 446c5441932SPravin B Shelar __be16 proto) 447c5441932SPravin B Shelar { 448c5441932SPravin B Shelar struct ip_tunnel *tunnel = netdev_priv(dev); 449c5441932SPravin B Shelar 450c5441932SPravin B Shelar if (tunnel->parms.o_flags & TUNNEL_SEQ) 451c5441932SPravin B Shelar tunnel->o_seqno++; 452cef401deSEric Dumazet 453c5441932SPravin B Shelar /* Push GRE header. */ 454182a352dSTom Herbert gre_build_header(skb, tunnel->tun_hlen, 455182a352dSTom Herbert tunnel->parms.o_flags, proto, tunnel->parms.o_key, 456182a352dSTom Herbert htonl(tunnel->o_seqno)); 4571da177e4SLinus Torvalds 458bf3d6a8fSNicolas Dichtel ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol); 4591da177e4SLinus Torvalds } 4601da177e4SLinus Torvalds 461aed069dfSAlexander Duyck static int gre_handle_offloads(struct sk_buff *skb, bool csum) 462b2acd1dcSPravin B Shelar { 4636fa79666SEdward Cree return iptunnel_handle_offloads(skb, csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE); 464b2acd1dcSPravin B Shelar } 465b2acd1dcSPravin B Shelar 466fc4099f1SPravin B Shelar static struct rtable *gre_get_rt(struct sk_buff *skb, 467fc4099f1SPravin B Shelar struct net_device *dev, 468fc4099f1SPravin B Shelar struct flowi4 *fl, 469fc4099f1SPravin B Shelar const struct ip_tunnel_key *key) 470fc4099f1SPravin B Shelar { 471fc4099f1SPravin B Shelar struct net *net = dev_net(dev); 472fc4099f1SPravin B Shelar 473fc4099f1SPravin B Shelar memset(fl, 0, sizeof(*fl)); 474fc4099f1SPravin B Shelar fl->daddr = key->u.ipv4.dst; 475fc4099f1SPravin B Shelar fl->saddr = key->u.ipv4.src; 476fc4099f1SPravin B Shelar fl->flowi4_tos = RT_TOS(key->tos); 477fc4099f1SPravin B Shelar fl->flowi4_mark = skb->mark; 478fc4099f1SPravin B Shelar fl->flowi4_proto = IPPROTO_GRE; 479fc4099f1SPravin B Shelar 480fc4099f1SPravin B Shelar return ip_route_output_key(net, fl); 481fc4099f1SPravin B Shelar } 482fc4099f1SPravin B Shelar 483862a03c3SWilliam Tu static struct rtable *prepare_fb_xmit(struct sk_buff *skb, 484862a03c3SWilliam Tu struct net_device *dev, 485862a03c3SWilliam Tu struct flowi4 *fl, 486862a03c3SWilliam Tu int tunnel_hlen) 4872e15ea39SPravin B Shelar { 4882e15ea39SPravin B Shelar struct ip_tunnel_info *tun_info; 4892e15ea39SPravin B Shelar const struct ip_tunnel_key *key; 490db3c6139SDaniel Borkmann struct rtable *rt = NULL; 4912e15ea39SPravin B Shelar int min_headroom; 492db3c6139SDaniel Borkmann bool use_cache; 4932e15ea39SPravin B Shelar int err; 4942e15ea39SPravin B Shelar 49561adedf3SJiri Benc tun_info = skb_tunnel_info(skb); 4962e15ea39SPravin B Shelar key = &tun_info->key; 497db3c6139SDaniel Borkmann use_cache = ip_tunnel_dst_cache_usable(skb, tun_info); 498862a03c3SWilliam Tu 499db3c6139SDaniel Borkmann if (use_cache) 500862a03c3SWilliam Tu rt = dst_cache_get_ip4(&tun_info->dst_cache, &fl->saddr); 5013c1cb4d2SPaolo Abeni if (!rt) { 502862a03c3SWilliam Tu rt = gre_get_rt(skb, dev, fl, key); 5032e15ea39SPravin B Shelar if (IS_ERR(rt)) 5042e15ea39SPravin B Shelar goto err_free_skb; 505db3c6139SDaniel Borkmann if (use_cache) 5063c1cb4d2SPaolo Abeni dst_cache_set_ip4(&tun_info->dst_cache, &rt->dst, 507862a03c3SWilliam Tu fl->saddr); 5083c1cb4d2SPaolo Abeni } 5092e15ea39SPravin B Shelar 5102e15ea39SPravin B Shelar min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len 5112e15ea39SPravin B Shelar + tunnel_hlen + sizeof(struct iphdr); 5122e15ea39SPravin B Shelar if (skb_headroom(skb) < min_headroom || skb_header_cloned(skb)) { 5132e15ea39SPravin B Shelar int head_delta = SKB_DATA_ALIGN(min_headroom - 5142e15ea39SPravin B Shelar skb_headroom(skb) + 5152e15ea39SPravin B Shelar 16); 5162e15ea39SPravin B Shelar err = pskb_expand_head(skb, max_t(int, head_delta, 0), 5172e15ea39SPravin B Shelar 0, GFP_ATOMIC); 5182e15ea39SPravin B Shelar if (unlikely(err)) 5192e15ea39SPravin B Shelar goto err_free_rt; 5202e15ea39SPravin B Shelar } 521862a03c3SWilliam Tu return rt; 522862a03c3SWilliam Tu 523862a03c3SWilliam Tu err_free_rt: 524862a03c3SWilliam Tu ip_rt_put(rt); 525862a03c3SWilliam Tu err_free_skb: 526862a03c3SWilliam Tu kfree_skb(skb); 527862a03c3SWilliam Tu dev->stats.tx_dropped++; 528862a03c3SWilliam Tu return NULL; 529862a03c3SWilliam Tu } 530862a03c3SWilliam Tu 531862a03c3SWilliam Tu static void gre_fb_xmit(struct sk_buff *skb, struct net_device *dev, 532862a03c3SWilliam Tu __be16 proto) 533862a03c3SWilliam Tu { 534862a03c3SWilliam Tu struct ip_tunnel_info *tun_info; 535862a03c3SWilliam Tu const struct ip_tunnel_key *key; 536862a03c3SWilliam Tu struct rtable *rt = NULL; 537862a03c3SWilliam Tu struct flowi4 fl; 538862a03c3SWilliam Tu int tunnel_hlen; 539862a03c3SWilliam Tu __be16 df, flags; 540862a03c3SWilliam Tu 541862a03c3SWilliam Tu tun_info = skb_tunnel_info(skb); 542862a03c3SWilliam Tu if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) || 543862a03c3SWilliam Tu ip_tunnel_info_af(tun_info) != AF_INET)) 544862a03c3SWilliam Tu goto err_free_skb; 545862a03c3SWilliam Tu 546862a03c3SWilliam Tu key = &tun_info->key; 547862a03c3SWilliam Tu tunnel_hlen = gre_calc_hlen(key->tun_flags); 548862a03c3SWilliam Tu 549862a03c3SWilliam Tu rt = prepare_fb_xmit(skb, dev, &fl, tunnel_hlen); 550862a03c3SWilliam Tu if (!rt) 551862a03c3SWilliam Tu return; 5522e15ea39SPravin B Shelar 5532e15ea39SPravin B Shelar /* Push Tunnel header. */ 554aed069dfSAlexander Duyck if (gre_handle_offloads(skb, !!(tun_info->key.tun_flags & TUNNEL_CSUM))) 5552e15ea39SPravin B Shelar goto err_free_rt; 5562e15ea39SPravin B Shelar 5572e15ea39SPravin B Shelar flags = tun_info->key.tun_flags & (TUNNEL_CSUM | TUNNEL_KEY); 558cba65321SDavid S. Miller gre_build_header(skb, tunnel_hlen, flags, proto, 559d817f432SAmir Vadai tunnel_id_to_key32(tun_info->key.tun_id), 0); 5602e15ea39SPravin B Shelar 5612e15ea39SPravin B Shelar df = key->tun_flags & TUNNEL_DONT_FRAGMENT ? htons(IP_DF) : 0; 562039f5062SPravin B Shelar 563039f5062SPravin B Shelar iptunnel_xmit(skb->sk, rt, skb, fl.saddr, key->u.ipv4.dst, IPPROTO_GRE, 5647c383fb2SJiri Benc key->tos, key->ttl, df, false); 5652e15ea39SPravin B Shelar return; 5662e15ea39SPravin B Shelar 5672e15ea39SPravin B Shelar err_free_rt: 5682e15ea39SPravin B Shelar ip_rt_put(rt); 5692e15ea39SPravin B Shelar err_free_skb: 5702e15ea39SPravin B Shelar kfree_skb(skb); 5712e15ea39SPravin B Shelar dev->stats.tx_dropped++; 5722e15ea39SPravin B Shelar } 5732e15ea39SPravin B Shelar 5741a66a836SWilliam Tu static void erspan_fb_xmit(struct sk_buff *skb, struct net_device *dev, 5751a66a836SWilliam Tu __be16 proto) 5761a66a836SWilliam Tu { 5771a66a836SWilliam Tu struct ip_tunnel *tunnel = netdev_priv(dev); 5781a66a836SWilliam Tu struct ip_tunnel_info *tun_info; 5791a66a836SWilliam Tu const struct ip_tunnel_key *key; 5801a66a836SWilliam Tu struct erspan_metadata *md; 5811a66a836SWilliam Tu struct rtable *rt = NULL; 5821a66a836SWilliam Tu bool truncate = false; 5831a66a836SWilliam Tu struct flowi4 fl; 5841a66a836SWilliam Tu int tunnel_hlen; 585f551c91dSWilliam Tu int version; 5861a66a836SWilliam Tu __be16 df; 5871a66a836SWilliam Tu 5881a66a836SWilliam Tu tun_info = skb_tunnel_info(skb); 5891a66a836SWilliam Tu if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) || 5901a66a836SWilliam Tu ip_tunnel_info_af(tun_info) != AF_INET)) 5911a66a836SWilliam Tu goto err_free_skb; 5921a66a836SWilliam Tu 5931a66a836SWilliam Tu key = &tun_info->key; 594f551c91dSWilliam Tu md = ip_tunnel_info_opts(tun_info); 595f551c91dSWilliam Tu if (!md) 596f551c91dSWilliam Tu goto err_free_rt; 5971a66a836SWilliam Tu 5981a66a836SWilliam Tu /* ERSPAN has fixed 8 byte GRE header */ 599f551c91dSWilliam Tu version = md->version; 600f551c91dSWilliam Tu tunnel_hlen = 8 + erspan_hdr_len(version); 6011a66a836SWilliam Tu 6021a66a836SWilliam Tu rt = prepare_fb_xmit(skb, dev, &fl, tunnel_hlen); 6031a66a836SWilliam Tu if (!rt) 6041a66a836SWilliam Tu return; 6051a66a836SWilliam Tu 6061a66a836SWilliam Tu if (gre_handle_offloads(skb, false)) 6071a66a836SWilliam Tu goto err_free_rt; 6081a66a836SWilliam Tu 609f192970dSWilliam Tu if (skb->len > dev->mtu + dev->hard_header_len) { 610f192970dSWilliam Tu pskb_trim(skb, dev->mtu + dev->hard_header_len); 6111a66a836SWilliam Tu truncate = true; 6121a66a836SWilliam Tu } 6131a66a836SWilliam Tu 614f551c91dSWilliam Tu if (version == 1) { 615c69de58bSWilliam Tu erspan_build_header(skb, ntohl(tunnel_id_to_key32(key->tun_id)), 6161d7e2ed2SWilliam Tu ntohl(md->u.index), truncate, true); 617f551c91dSWilliam Tu } else if (version == 2) { 618c69de58bSWilliam Tu erspan_build_header_v2(skb, 619c69de58bSWilliam Tu ntohl(tunnel_id_to_key32(key->tun_id)), 620c69de58bSWilliam Tu md->u.md2.dir, 621c69de58bSWilliam Tu get_hwid(&md->u.md2), 622c69de58bSWilliam Tu truncate, true); 623f551c91dSWilliam Tu } else { 624f551c91dSWilliam Tu goto err_free_rt; 625f551c91dSWilliam Tu } 6261a66a836SWilliam Tu 6271a66a836SWilliam Tu gre_build_header(skb, 8, TUNNEL_SEQ, 6281a66a836SWilliam Tu htons(ETH_P_ERSPAN), 0, htonl(tunnel->o_seqno++)); 6291a66a836SWilliam Tu 6301a66a836SWilliam Tu df = key->tun_flags & TUNNEL_DONT_FRAGMENT ? htons(IP_DF) : 0; 6311a66a836SWilliam Tu 6321a66a836SWilliam Tu iptunnel_xmit(skb->sk, rt, skb, fl.saddr, key->u.ipv4.dst, IPPROTO_GRE, 6331a66a836SWilliam Tu key->tos, key->ttl, df, false); 6341a66a836SWilliam Tu return; 6351a66a836SWilliam Tu 6361a66a836SWilliam Tu err_free_rt: 6371a66a836SWilliam Tu ip_rt_put(rt); 6381a66a836SWilliam Tu err_free_skb: 6391a66a836SWilliam Tu kfree_skb(skb); 6401a66a836SWilliam Tu dev->stats.tx_dropped++; 6411a66a836SWilliam Tu } 6421a66a836SWilliam Tu 643fc4099f1SPravin B Shelar static int gre_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb) 644fc4099f1SPravin B Shelar { 645fc4099f1SPravin B Shelar struct ip_tunnel_info *info = skb_tunnel_info(skb); 646fc4099f1SPravin B Shelar struct rtable *rt; 647fc4099f1SPravin B Shelar struct flowi4 fl4; 648fc4099f1SPravin B Shelar 649fc4099f1SPravin B Shelar if (ip_tunnel_info_af(info) != AF_INET) 650fc4099f1SPravin B Shelar return -EINVAL; 651fc4099f1SPravin B Shelar 652fc4099f1SPravin B Shelar rt = gre_get_rt(skb, dev, &fl4, &info->key); 653fc4099f1SPravin B Shelar if (IS_ERR(rt)) 654fc4099f1SPravin B Shelar return PTR_ERR(rt); 655fc4099f1SPravin B Shelar 656fc4099f1SPravin B Shelar ip_rt_put(rt); 657fc4099f1SPravin B Shelar info->key.u.ipv4.src = fl4.saddr; 658fc4099f1SPravin B Shelar return 0; 659fc4099f1SPravin B Shelar } 660fc4099f1SPravin B Shelar 661c5441932SPravin B Shelar static netdev_tx_t ipgre_xmit(struct sk_buff *skb, 662c5441932SPravin B Shelar struct net_device *dev) 663ee34c1ebSMichal Schmidt { 664c5441932SPravin B Shelar struct ip_tunnel *tunnel = netdev_priv(dev); 665c5441932SPravin B Shelar const struct iphdr *tnl_params; 666ee34c1ebSMichal Schmidt 6672e15ea39SPravin B Shelar if (tunnel->collect_md) { 6682090714eSJiri Benc gre_fb_xmit(skb, dev, skb->protocol); 6692e15ea39SPravin B Shelar return NETDEV_TX_OK; 6702e15ea39SPravin B Shelar } 6712e15ea39SPravin B Shelar 672c5441932SPravin B Shelar if (dev->header_ops) { 673c5441932SPravin B Shelar /* Need space for new headers */ 674c5441932SPravin B Shelar if (skb_cow_head(skb, dev->needed_headroom - 6752bac7cb3SChen Gang (tunnel->hlen + sizeof(struct iphdr)))) 676c5441932SPravin B Shelar goto free_skb; 677ee34c1ebSMichal Schmidt 678c5441932SPravin B Shelar tnl_params = (const struct iphdr *)skb->data; 679cbb1e85fSDavid S. Miller 680c5441932SPravin B Shelar /* Pull skb since ip_tunnel_xmit() needs skb->data pointing 681c5441932SPravin B Shelar * to gre header. 682c5441932SPravin B Shelar */ 683c5441932SPravin B Shelar skb_pull(skb, tunnel->hlen + sizeof(struct iphdr)); 6848a0033a9STimo Teräs skb_reset_mac_header(skb); 685c5441932SPravin B Shelar } else { 686c5441932SPravin B Shelar if (skb_cow_head(skb, dev->needed_headroom)) 687c5441932SPravin B Shelar goto free_skb; 688c5441932SPravin B Shelar 689c5441932SPravin B Shelar tnl_params = &tunnel->parms.iph; 690ee34c1ebSMichal Schmidt } 691e1a80002SHerbert Xu 692aed069dfSAlexander Duyck if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM))) 693aed069dfSAlexander Duyck goto free_skb; 6948a0033a9STimo Teräs 695c5441932SPravin B Shelar __gre_xmit(skb, dev, tnl_params, skb->protocol); 696c5441932SPravin B Shelar return NETDEV_TX_OK; 697c5441932SPravin B Shelar 698c5441932SPravin B Shelar free_skb: 6993acfa1e7SEric Dumazet kfree_skb(skb); 700c5441932SPravin B Shelar dev->stats.tx_dropped++; 701c5441932SPravin B Shelar return NETDEV_TX_OK; 702ee34c1ebSMichal Schmidt } 703ee34c1ebSMichal Schmidt 70484e54fe0SWilliam Tu static netdev_tx_t erspan_xmit(struct sk_buff *skb, 70584e54fe0SWilliam Tu struct net_device *dev) 70684e54fe0SWilliam Tu { 70784e54fe0SWilliam Tu struct ip_tunnel *tunnel = netdev_priv(dev); 70884e54fe0SWilliam Tu bool truncate = false; 70984e54fe0SWilliam Tu 7101a66a836SWilliam Tu if (tunnel->collect_md) { 7111a66a836SWilliam Tu erspan_fb_xmit(skb, dev, skb->protocol); 7121a66a836SWilliam Tu return NETDEV_TX_OK; 7131a66a836SWilliam Tu } 7141a66a836SWilliam Tu 71584e54fe0SWilliam Tu if (gre_handle_offloads(skb, false)) 71684e54fe0SWilliam Tu goto free_skb; 71784e54fe0SWilliam Tu 71884e54fe0SWilliam Tu if (skb_cow_head(skb, dev->needed_headroom)) 71984e54fe0SWilliam Tu goto free_skb; 72084e54fe0SWilliam Tu 721f192970dSWilliam Tu if (skb->len > dev->mtu + dev->hard_header_len) { 722f192970dSWilliam Tu pskb_trim(skb, dev->mtu + dev->hard_header_len); 72384e54fe0SWilliam Tu truncate = true; 72484e54fe0SWilliam Tu } 72584e54fe0SWilliam Tu 72684e54fe0SWilliam Tu /* Push ERSPAN header */ 727f551c91dSWilliam Tu if (tunnel->erspan_ver == 1) 728c69de58bSWilliam Tu erspan_build_header(skb, ntohl(tunnel->parms.o_key), 729c69de58bSWilliam Tu tunnel->index, 730a3222dc9SWilliam Tu truncate, true); 731f551c91dSWilliam Tu else 732c69de58bSWilliam Tu erspan_build_header_v2(skb, ntohl(tunnel->parms.o_key), 733f551c91dSWilliam Tu tunnel->dir, tunnel->hwid, 734f551c91dSWilliam Tu truncate, true); 735f551c91dSWilliam Tu 73684e54fe0SWilliam Tu tunnel->parms.o_flags &= ~TUNNEL_KEY; 73784e54fe0SWilliam Tu __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_ERSPAN)); 73884e54fe0SWilliam Tu return NETDEV_TX_OK; 73984e54fe0SWilliam Tu 74084e54fe0SWilliam Tu free_skb: 74184e54fe0SWilliam Tu kfree_skb(skb); 74284e54fe0SWilliam Tu dev->stats.tx_dropped++; 74384e54fe0SWilliam Tu return NETDEV_TX_OK; 74484e54fe0SWilliam Tu } 74584e54fe0SWilliam Tu 746c5441932SPravin B Shelar static netdev_tx_t gre_tap_xmit(struct sk_buff *skb, 747c5441932SPravin B Shelar struct net_device *dev) 748c5441932SPravin B Shelar { 749c5441932SPravin B Shelar struct ip_tunnel *tunnel = netdev_priv(dev); 750ee34c1ebSMichal Schmidt 7512e15ea39SPravin B Shelar if (tunnel->collect_md) { 7522090714eSJiri Benc gre_fb_xmit(skb, dev, htons(ETH_P_TEB)); 7532e15ea39SPravin B Shelar return NETDEV_TX_OK; 7542e15ea39SPravin B Shelar } 7552e15ea39SPravin B Shelar 756aed069dfSAlexander Duyck if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM))) 757aed069dfSAlexander Duyck goto free_skb; 758ee34c1ebSMichal Schmidt 759c5441932SPravin B Shelar if (skb_cow_head(skb, dev->needed_headroom)) 760c5441932SPravin B Shelar goto free_skb; 76142aa9162SHerbert Xu 762c5441932SPravin B Shelar __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB)); 763c5441932SPravin B Shelar return NETDEV_TX_OK; 764c5441932SPravin B Shelar 765c5441932SPravin B Shelar free_skb: 7663acfa1e7SEric Dumazet kfree_skb(skb); 767c5441932SPravin B Shelar dev->stats.tx_dropped++; 768c5441932SPravin B Shelar return NETDEV_TX_OK; 76968c33163SPravin B Shelar } 770ee34c1ebSMichal Schmidt 771dd9d598cSXin Long static void ipgre_link_update(struct net_device *dev, bool set_mtu) 772dd9d598cSXin Long { 773dd9d598cSXin Long struct ip_tunnel *tunnel = netdev_priv(dev); 774dd9d598cSXin Long int len; 775dd9d598cSXin Long 776dd9d598cSXin Long len = tunnel->tun_hlen; 777dd9d598cSXin Long tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags); 778dd9d598cSXin Long len = tunnel->tun_hlen - len; 779dd9d598cSXin Long tunnel->hlen = tunnel->hlen + len; 780dd9d598cSXin Long 781dd9d598cSXin Long dev->needed_headroom = dev->needed_headroom + len; 782dd9d598cSXin Long if (set_mtu) 783dd9d598cSXin Long dev->mtu = max_t(int, dev->mtu - len, 68); 784dd9d598cSXin Long 785dd9d598cSXin Long if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) { 786dd9d598cSXin Long if (!(tunnel->parms.o_flags & TUNNEL_CSUM) || 787dd9d598cSXin Long tunnel->encap.type == TUNNEL_ENCAP_NONE) { 788dd9d598cSXin Long dev->features |= NETIF_F_GSO_SOFTWARE; 789dd9d598cSXin Long dev->hw_features |= NETIF_F_GSO_SOFTWARE; 790dd9d598cSXin Long } 791dd9d598cSXin Long dev->features |= NETIF_F_LLTX; 792dd9d598cSXin Long } 793dd9d598cSXin Long } 794dd9d598cSXin Long 795c5441932SPravin B Shelar static int ipgre_tunnel_ioctl(struct net_device *dev, 796c5441932SPravin B Shelar struct ifreq *ifr, int cmd) 7971da177e4SLinus Torvalds { 7981da177e4SLinus Torvalds struct ip_tunnel_parm p; 799a0efab67SXin Long int err; 8001da177e4SLinus Torvalds 8011da177e4SLinus Torvalds if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) 802c5441932SPravin B Shelar return -EFAULT; 803a0efab67SXin Long 8046c734fb8SCong Wang if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) { 8051da177e4SLinus Torvalds if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE || 8061da177e4SLinus Torvalds p.iph.ihl != 5 || (p.iph.frag_off & htons(~IP_DF)) || 8076c734fb8SCong Wang ((p.i_flags | p.o_flags) & (GRE_VERSION | GRE_ROUTING))) 8081da177e4SLinus Torvalds return -EINVAL; 809c5441932SPravin B Shelar } 810a0efab67SXin Long 811c5441932SPravin B Shelar p.i_flags = gre_flags_to_tnl_flags(p.i_flags); 812c5441932SPravin B Shelar p.o_flags = gre_flags_to_tnl_flags(p.o_flags); 813c5441932SPravin B Shelar 814c5441932SPravin B Shelar err = ip_tunnel_ioctl(dev, &p, cmd); 815c5441932SPravin B Shelar if (err) 816c5441932SPravin B Shelar return err; 817c5441932SPravin B Shelar 818a0efab67SXin Long if (cmd == SIOCCHGTUNNEL) { 819a0efab67SXin Long struct ip_tunnel *t = netdev_priv(dev); 820a0efab67SXin Long 821a0efab67SXin Long t->parms.i_flags = p.i_flags; 822a0efab67SXin Long t->parms.o_flags = p.o_flags; 823a0efab67SXin Long 824a0efab67SXin Long if (strcmp(dev->rtnl_link_ops->kind, "erspan")) 825a0efab67SXin Long ipgre_link_update(dev, true); 826a0efab67SXin Long } 827a0efab67SXin Long 82895f5c64cSTom Herbert p.i_flags = gre_tnl_flags_to_gre_flags(p.i_flags); 82995f5c64cSTom Herbert p.o_flags = gre_tnl_flags_to_gre_flags(p.o_flags); 830c5441932SPravin B Shelar 831c5441932SPravin B Shelar if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p))) 832c5441932SPravin B Shelar return -EFAULT; 833a0efab67SXin Long 8341da177e4SLinus Torvalds return 0; 8351da177e4SLinus Torvalds } 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds /* Nice toy. Unfortunately, useless in real life :-) 8381da177e4SLinus Torvalds It allows to construct virtual multiprotocol broadcast "LAN" 8391da177e4SLinus Torvalds over the Internet, provided multicast routing is tuned. 8401da177e4SLinus Torvalds 8411da177e4SLinus Torvalds 8421da177e4SLinus Torvalds I have no idea was this bicycle invented before me, 8431da177e4SLinus Torvalds so that I had to set ARPHRD_IPGRE to a random value. 8441da177e4SLinus Torvalds I have an impression, that Cisco could make something similar, 8451da177e4SLinus Torvalds but this feature is apparently missing in IOS<=11.2(8). 8461da177e4SLinus Torvalds 8471da177e4SLinus Torvalds I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks 8481da177e4SLinus Torvalds with broadcast 224.66.66.66. If you have access to mbone, play with me :-) 8491da177e4SLinus Torvalds 8501da177e4SLinus Torvalds ping -t 255 224.66.66.66 8511da177e4SLinus Torvalds 8521da177e4SLinus Torvalds If nobody answers, mbone does not work. 8531da177e4SLinus Torvalds 8541da177e4SLinus Torvalds ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255 8551da177e4SLinus Torvalds ip addr add 10.66.66.<somewhat>/24 dev Universe 8561da177e4SLinus Torvalds ifconfig Universe up 8571da177e4SLinus Torvalds ifconfig Universe add fe80::<Your_real_addr>/10 8581da177e4SLinus Torvalds ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96 8591da177e4SLinus Torvalds ftp 10.66.66.66 8601da177e4SLinus Torvalds ... 8611da177e4SLinus Torvalds ftp fec0:6666:6666::193.233.7.65 8621da177e4SLinus Torvalds ... 8631da177e4SLinus Torvalds */ 8643b04dddeSStephen Hemminger static int ipgre_header(struct sk_buff *skb, struct net_device *dev, 8653b04dddeSStephen Hemminger unsigned short type, 8661507850bSEric Dumazet const void *daddr, const void *saddr, unsigned int len) 8671da177e4SLinus Torvalds { 8682941a486SPatrick McHardy struct ip_tunnel *t = netdev_priv(dev); 869c5441932SPravin B Shelar struct iphdr *iph; 870c5441932SPravin B Shelar struct gre_base_hdr *greh; 871c5441932SPravin B Shelar 872d58ff351SJohannes Berg iph = skb_push(skb, t->hlen + sizeof(*iph)); 873c5441932SPravin B Shelar greh = (struct gre_base_hdr *)(iph+1); 87495f5c64cSTom Herbert greh->flags = gre_tnl_flags_to_gre_flags(t->parms.o_flags); 875c5441932SPravin B Shelar greh->protocol = htons(type); 8761da177e4SLinus Torvalds 8771da177e4SLinus Torvalds memcpy(iph, &t->parms.iph, sizeof(struct iphdr)); 8781da177e4SLinus Torvalds 879c5441932SPravin B Shelar /* Set the source hardware address. */ 8801da177e4SLinus Torvalds if (saddr) 8811da177e4SLinus Torvalds memcpy(&iph->saddr, saddr, 4); 8826d55cb91STimo Teräs if (daddr) 8831da177e4SLinus Torvalds memcpy(&iph->daddr, daddr, 4); 8846d55cb91STimo Teräs if (iph->daddr) 88577a482bdSTimo Teräs return t->hlen + sizeof(*iph); 8861da177e4SLinus Torvalds 887c5441932SPravin B Shelar return -(t->hlen + sizeof(*iph)); 8881da177e4SLinus Torvalds } 8891da177e4SLinus Torvalds 8906a5f44d7STimo Teras static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr) 8916a5f44d7STimo Teras { 892b71d1d42SEric Dumazet const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb); 8936a5f44d7STimo Teras memcpy(haddr, &iph->saddr, 4); 8946a5f44d7STimo Teras return 4; 8956a5f44d7STimo Teras } 8966a5f44d7STimo Teras 8973b04dddeSStephen Hemminger static const struct header_ops ipgre_header_ops = { 8983b04dddeSStephen Hemminger .create = ipgre_header, 8996a5f44d7STimo Teras .parse = ipgre_header_parse, 9003b04dddeSStephen Hemminger }; 9013b04dddeSStephen Hemminger 9026a5f44d7STimo Teras #ifdef CONFIG_NET_IPGRE_BROADCAST 9031da177e4SLinus Torvalds static int ipgre_open(struct net_device *dev) 9041da177e4SLinus Torvalds { 9052941a486SPatrick McHardy struct ip_tunnel *t = netdev_priv(dev); 9061da177e4SLinus Torvalds 907f97c1e0cSJoe Perches if (ipv4_is_multicast(t->parms.iph.daddr)) { 908cbb1e85fSDavid S. Miller struct flowi4 fl4; 909cbb1e85fSDavid S. Miller struct rtable *rt; 910cbb1e85fSDavid S. Miller 911b57708adSNicolas Dichtel rt = ip_route_output_gre(t->net, &fl4, 91278fbfd8aSDavid S. Miller t->parms.iph.daddr, 91378fbfd8aSDavid S. Miller t->parms.iph.saddr, 91478fbfd8aSDavid S. Miller t->parms.o_key, 91578fbfd8aSDavid S. Miller RT_TOS(t->parms.iph.tos), 91678fbfd8aSDavid S. Miller t->parms.link); 917b23dd4feSDavid S. Miller if (IS_ERR(rt)) 9181da177e4SLinus Torvalds return -EADDRNOTAVAIL; 919d8d1f30bSChangli Gao dev = rt->dst.dev; 9201da177e4SLinus Torvalds ip_rt_put(rt); 92151456b29SIan Morris if (!__in_dev_get_rtnl(dev)) 9221da177e4SLinus Torvalds return -EADDRNOTAVAIL; 9231da177e4SLinus Torvalds t->mlink = dev->ifindex; 924e5ed6399SHerbert Xu ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr); 9251da177e4SLinus Torvalds } 9261da177e4SLinus Torvalds return 0; 9271da177e4SLinus Torvalds } 9281da177e4SLinus Torvalds 9291da177e4SLinus Torvalds static int ipgre_close(struct net_device *dev) 9301da177e4SLinus Torvalds { 9312941a486SPatrick McHardy struct ip_tunnel *t = netdev_priv(dev); 932b8c26a33SStephen Hemminger 933f97c1e0cSJoe Perches if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) { 9347fee0ca2SDenis V. Lunev struct in_device *in_dev; 935b57708adSNicolas Dichtel in_dev = inetdev_by_index(t->net, t->mlink); 9368723e1b4SEric Dumazet if (in_dev) 9371da177e4SLinus Torvalds ip_mc_dec_group(in_dev, t->parms.iph.daddr); 9381da177e4SLinus Torvalds } 9391da177e4SLinus Torvalds return 0; 9401da177e4SLinus Torvalds } 9411da177e4SLinus Torvalds #endif 9421da177e4SLinus Torvalds 943b8c26a33SStephen Hemminger static const struct net_device_ops ipgre_netdev_ops = { 944b8c26a33SStephen Hemminger .ndo_init = ipgre_tunnel_init, 945c5441932SPravin B Shelar .ndo_uninit = ip_tunnel_uninit, 946b8c26a33SStephen Hemminger #ifdef CONFIG_NET_IPGRE_BROADCAST 947b8c26a33SStephen Hemminger .ndo_open = ipgre_open, 948b8c26a33SStephen Hemminger .ndo_stop = ipgre_close, 949b8c26a33SStephen Hemminger #endif 950c5441932SPravin B Shelar .ndo_start_xmit = ipgre_xmit, 951b8c26a33SStephen Hemminger .ndo_do_ioctl = ipgre_tunnel_ioctl, 952c5441932SPravin B Shelar .ndo_change_mtu = ip_tunnel_change_mtu, 953c5441932SPravin B Shelar .ndo_get_stats64 = ip_tunnel_get_stats64, 9541e99584bSNicolas Dichtel .ndo_get_iflink = ip_tunnel_get_iflink, 955b8c26a33SStephen Hemminger }; 956b8c26a33SStephen Hemminger 9576b78f16eSEric Dumazet #define GRE_FEATURES (NETIF_F_SG | \ 9586b78f16eSEric Dumazet NETIF_F_FRAGLIST | \ 9596b78f16eSEric Dumazet NETIF_F_HIGHDMA | \ 9606b78f16eSEric Dumazet NETIF_F_HW_CSUM) 9616b78f16eSEric Dumazet 9621da177e4SLinus Torvalds static void ipgre_tunnel_setup(struct net_device *dev) 9631da177e4SLinus Torvalds { 964b8c26a33SStephen Hemminger dev->netdev_ops = &ipgre_netdev_ops; 9655a455275SNicolas Dichtel dev->type = ARPHRD_IPGRE; 966c5441932SPravin B Shelar ip_tunnel_setup(dev, ipgre_net_id); 967c5441932SPravin B Shelar } 9681da177e4SLinus Torvalds 969c5441932SPravin B Shelar static void __gre_tunnel_init(struct net_device *dev) 970c5441932SPravin B Shelar { 971c5441932SPravin B Shelar struct ip_tunnel *tunnel; 9724565e991STom Herbert int t_hlen; 973c5441932SPravin B Shelar 974c5441932SPravin B Shelar tunnel = netdev_priv(dev); 97595f5c64cSTom Herbert tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags); 976c5441932SPravin B Shelar tunnel->parms.iph.protocol = IPPROTO_GRE; 977c5441932SPravin B Shelar 9784565e991STom Herbert tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen; 9794565e991STom Herbert 9804565e991STom Herbert t_hlen = tunnel->hlen + sizeof(struct iphdr); 9814565e991STom Herbert 9824565e991STom Herbert dev->needed_headroom = LL_MAX_HEADER + t_hlen + 4; 9834565e991STom Herbert dev->mtu = ETH_DATA_LEN - t_hlen - 4; 9846b78f16eSEric Dumazet 985b57708adSNicolas Dichtel dev->features |= GRE_FEATURES; 9866b78f16eSEric Dumazet dev->hw_features |= GRE_FEATURES; 987c5441932SPravin B Shelar 988c5441932SPravin B Shelar if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) { 989a0ca153fSAlexander Duyck /* TCP offload with GRE SEQ is not supported, nor 990a0ca153fSAlexander Duyck * can we support 2 levels of outer headers requiring 991a0ca153fSAlexander Duyck * an update. 992a0ca153fSAlexander Duyck */ 993a0ca153fSAlexander Duyck if (!(tunnel->parms.o_flags & TUNNEL_CSUM) || 994a0ca153fSAlexander Duyck (tunnel->encap.type == TUNNEL_ENCAP_NONE)) { 995c5441932SPravin B Shelar dev->features |= NETIF_F_GSO_SOFTWARE; 996c5441932SPravin B Shelar dev->hw_features |= NETIF_F_GSO_SOFTWARE; 997a0ca153fSAlexander Duyck } 998a0ca153fSAlexander Duyck 999c5441932SPravin B Shelar /* Can use a lockless transmit, unless we generate 1000c5441932SPravin B Shelar * output sequences 1001c5441932SPravin B Shelar */ 1002c5441932SPravin B Shelar dev->features |= NETIF_F_LLTX; 1003c5441932SPravin B Shelar } 10041da177e4SLinus Torvalds } 10051da177e4SLinus Torvalds 10061da177e4SLinus Torvalds static int ipgre_tunnel_init(struct net_device *dev) 10071da177e4SLinus Torvalds { 1008c5441932SPravin B Shelar struct ip_tunnel *tunnel = netdev_priv(dev); 1009c5441932SPravin B Shelar struct iphdr *iph = &tunnel->parms.iph; 10101da177e4SLinus Torvalds 1011c5441932SPravin B Shelar __gre_tunnel_init(dev); 10121da177e4SLinus Torvalds 1013c5441932SPravin B Shelar memcpy(dev->dev_addr, &iph->saddr, 4); 1014c5441932SPravin B Shelar memcpy(dev->broadcast, &iph->daddr, 4); 10151da177e4SLinus Torvalds 1016c5441932SPravin B Shelar dev->flags = IFF_NOARP; 101702875878SEric Dumazet netif_keep_dst(dev); 1018c5441932SPravin B Shelar dev->addr_len = 4; 10191da177e4SLinus Torvalds 1020a64b04d8SJiri Benc if (iph->daddr && !tunnel->collect_md) { 10211da177e4SLinus Torvalds #ifdef CONFIG_NET_IPGRE_BROADCAST 1022f97c1e0cSJoe Perches if (ipv4_is_multicast(iph->daddr)) { 10231da177e4SLinus Torvalds if (!iph->saddr) 10241da177e4SLinus Torvalds return -EINVAL; 10251da177e4SLinus Torvalds dev->flags = IFF_BROADCAST; 10263b04dddeSStephen Hemminger dev->header_ops = &ipgre_header_ops; 10271da177e4SLinus Torvalds } 10281da177e4SLinus Torvalds #endif 1029a64b04d8SJiri Benc } else if (!tunnel->collect_md) { 10306a5f44d7STimo Teras dev->header_ops = &ipgre_header_ops; 1031a64b04d8SJiri Benc } 10321da177e4SLinus Torvalds 1033c5441932SPravin B Shelar return ip_tunnel_init(dev); 103460769a5dSEric Dumazet } 103560769a5dSEric Dumazet 10369f57c67cSPravin B Shelar static const struct gre_protocol ipgre_protocol = { 10379f57c67cSPravin B Shelar .handler = gre_rcv, 10389f57c67cSPravin B Shelar .err_handler = gre_err, 10391da177e4SLinus Torvalds }; 10401da177e4SLinus Torvalds 10412c8c1e72SAlexey Dobriyan static int __net_init ipgre_init_net(struct net *net) 104259a4c759SPavel Emelyanov { 1043c5441932SPravin B Shelar return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL); 104459a4c759SPavel Emelyanov } 104559a4c759SPavel Emelyanov 104664bc1781SEric Dumazet static void __net_exit ipgre_exit_batch_net(struct list_head *list_net) 104759a4c759SPavel Emelyanov { 104864bc1781SEric Dumazet ip_tunnel_delete_nets(list_net, ipgre_net_id, &ipgre_link_ops); 104959a4c759SPavel Emelyanov } 105059a4c759SPavel Emelyanov 105159a4c759SPavel Emelyanov static struct pernet_operations ipgre_net_ops = { 105259a4c759SPavel Emelyanov .init = ipgre_init_net, 105364bc1781SEric Dumazet .exit_batch = ipgre_exit_batch_net, 1054cfb8fbf2SEric W. Biederman .id = &ipgre_net_id, 1055c5441932SPravin B Shelar .size = sizeof(struct ip_tunnel_net), 105659a4c759SPavel Emelyanov }; 10571da177e4SLinus Torvalds 1058a8b8a889SMatthias Schiffer static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[], 1059a8b8a889SMatthias Schiffer struct netlink_ext_ack *extack) 1060c19e654dSHerbert Xu { 1061c19e654dSHerbert Xu __be16 flags; 1062c19e654dSHerbert Xu 1063c19e654dSHerbert Xu if (!data) 1064c19e654dSHerbert Xu return 0; 1065c19e654dSHerbert Xu 1066c19e654dSHerbert Xu flags = 0; 1067c19e654dSHerbert Xu if (data[IFLA_GRE_IFLAGS]) 1068c19e654dSHerbert Xu flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]); 1069c19e654dSHerbert Xu if (data[IFLA_GRE_OFLAGS]) 1070c19e654dSHerbert Xu flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]); 1071c19e654dSHerbert Xu if (flags & (GRE_VERSION|GRE_ROUTING)) 1072c19e654dSHerbert Xu return -EINVAL; 1073c19e654dSHerbert Xu 1074946b636fSJiri Benc if (data[IFLA_GRE_COLLECT_METADATA] && 1075946b636fSJiri Benc data[IFLA_GRE_ENCAP_TYPE] && 1076946b636fSJiri Benc nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]) != TUNNEL_ENCAP_NONE) 1077946b636fSJiri Benc return -EINVAL; 1078946b636fSJiri Benc 1079c19e654dSHerbert Xu return 0; 1080c19e654dSHerbert Xu } 1081c19e654dSHerbert Xu 1082a8b8a889SMatthias Schiffer static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[], 1083a8b8a889SMatthias Schiffer struct netlink_ext_ack *extack) 1084e1a80002SHerbert Xu { 1085e1a80002SHerbert Xu __be32 daddr; 1086e1a80002SHerbert Xu 1087e1a80002SHerbert Xu if (tb[IFLA_ADDRESS]) { 1088e1a80002SHerbert Xu if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) 1089e1a80002SHerbert Xu return -EINVAL; 1090e1a80002SHerbert Xu if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) 1091e1a80002SHerbert Xu return -EADDRNOTAVAIL; 1092e1a80002SHerbert Xu } 1093e1a80002SHerbert Xu 1094e1a80002SHerbert Xu if (!data) 1095e1a80002SHerbert Xu goto out; 1096e1a80002SHerbert Xu 1097e1a80002SHerbert Xu if (data[IFLA_GRE_REMOTE]) { 1098e1a80002SHerbert Xu memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4); 1099e1a80002SHerbert Xu if (!daddr) 1100e1a80002SHerbert Xu return -EINVAL; 1101e1a80002SHerbert Xu } 1102e1a80002SHerbert Xu 1103e1a80002SHerbert Xu out: 1104a8b8a889SMatthias Schiffer return ipgre_tunnel_validate(tb, data, extack); 1105e1a80002SHerbert Xu } 1106e1a80002SHerbert Xu 110784e54fe0SWilliam Tu static int erspan_validate(struct nlattr *tb[], struct nlattr *data[], 110884e54fe0SWilliam Tu struct netlink_ext_ack *extack) 110984e54fe0SWilliam Tu { 111084e54fe0SWilliam Tu __be16 flags = 0; 111184e54fe0SWilliam Tu int ret; 111284e54fe0SWilliam Tu 111384e54fe0SWilliam Tu if (!data) 111484e54fe0SWilliam Tu return 0; 111584e54fe0SWilliam Tu 111684e54fe0SWilliam Tu ret = ipgre_tap_validate(tb, data, extack); 111784e54fe0SWilliam Tu if (ret) 111884e54fe0SWilliam Tu return ret; 111984e54fe0SWilliam Tu 112084e54fe0SWilliam Tu /* ERSPAN should only have GRE sequence and key flag */ 11211a66a836SWilliam Tu if (data[IFLA_GRE_OFLAGS]) 112284e54fe0SWilliam Tu flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]); 11231a66a836SWilliam Tu if (data[IFLA_GRE_IFLAGS]) 112484e54fe0SWilliam Tu flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]); 11251a66a836SWilliam Tu if (!data[IFLA_GRE_COLLECT_METADATA] && 11261a66a836SWilliam Tu flags != (GRE_SEQ | GRE_KEY)) 112784e54fe0SWilliam Tu return -EINVAL; 112884e54fe0SWilliam Tu 112984e54fe0SWilliam Tu /* ERSPAN Session ID only has 10-bit. Since we reuse 113084e54fe0SWilliam Tu * 32-bit key field as ID, check it's range. 113184e54fe0SWilliam Tu */ 113284e54fe0SWilliam Tu if (data[IFLA_GRE_IKEY] && 113384e54fe0SWilliam Tu (ntohl(nla_get_be32(data[IFLA_GRE_IKEY])) & ~ID_MASK)) 113484e54fe0SWilliam Tu return -EINVAL; 113584e54fe0SWilliam Tu 113684e54fe0SWilliam Tu if (data[IFLA_GRE_OKEY] && 113784e54fe0SWilliam Tu (ntohl(nla_get_be32(data[IFLA_GRE_OKEY])) & ~ID_MASK)) 113884e54fe0SWilliam Tu return -EINVAL; 113984e54fe0SWilliam Tu 114084e54fe0SWilliam Tu return 0; 114184e54fe0SWilliam Tu } 114284e54fe0SWilliam Tu 114322a59be8SPhilip Prindeville static int ipgre_netlink_parms(struct net_device *dev, 11442e15ea39SPravin B Shelar struct nlattr *data[], 11452e15ea39SPravin B Shelar struct nlattr *tb[], 11469830ad4cSCraig Gallek struct ip_tunnel_parm *parms, 11479830ad4cSCraig Gallek __u32 *fwmark) 1148c19e654dSHerbert Xu { 114922a59be8SPhilip Prindeville struct ip_tunnel *t = netdev_priv(dev); 115022a59be8SPhilip Prindeville 11517bb82d92SHerbert Xu memset(parms, 0, sizeof(*parms)); 1152c19e654dSHerbert Xu 1153c19e654dSHerbert Xu parms->iph.protocol = IPPROTO_GRE; 1154c19e654dSHerbert Xu 1155c19e654dSHerbert Xu if (!data) 115622a59be8SPhilip Prindeville return 0; 1157c19e654dSHerbert Xu 1158c19e654dSHerbert Xu if (data[IFLA_GRE_LINK]) 1159c19e654dSHerbert Xu parms->link = nla_get_u32(data[IFLA_GRE_LINK]); 1160c19e654dSHerbert Xu 1161c19e654dSHerbert Xu if (data[IFLA_GRE_IFLAGS]) 1162c5441932SPravin B Shelar parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS])); 1163c19e654dSHerbert Xu 1164c19e654dSHerbert Xu if (data[IFLA_GRE_OFLAGS]) 1165c5441932SPravin B Shelar parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS])); 1166c19e654dSHerbert Xu 1167c19e654dSHerbert Xu if (data[IFLA_GRE_IKEY]) 1168c19e654dSHerbert Xu parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]); 1169c19e654dSHerbert Xu 1170c19e654dSHerbert Xu if (data[IFLA_GRE_OKEY]) 1171c19e654dSHerbert Xu parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]); 1172c19e654dSHerbert Xu 1173c19e654dSHerbert Xu if (data[IFLA_GRE_LOCAL]) 117467b61f6cSJiri Benc parms->iph.saddr = nla_get_in_addr(data[IFLA_GRE_LOCAL]); 1175c19e654dSHerbert Xu 1176c19e654dSHerbert Xu if (data[IFLA_GRE_REMOTE]) 117767b61f6cSJiri Benc parms->iph.daddr = nla_get_in_addr(data[IFLA_GRE_REMOTE]); 1178c19e654dSHerbert Xu 1179c19e654dSHerbert Xu if (data[IFLA_GRE_TTL]) 1180c19e654dSHerbert Xu parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]); 1181c19e654dSHerbert Xu 1182c19e654dSHerbert Xu if (data[IFLA_GRE_TOS]) 1183c19e654dSHerbert Xu parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]); 1184c19e654dSHerbert Xu 118522a59be8SPhilip Prindeville if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC])) { 118622a59be8SPhilip Prindeville if (t->ignore_df) 118722a59be8SPhilip Prindeville return -EINVAL; 1188c19e654dSHerbert Xu parms->iph.frag_off = htons(IP_DF); 118922a59be8SPhilip Prindeville } 11902e15ea39SPravin B Shelar 11912e15ea39SPravin B Shelar if (data[IFLA_GRE_COLLECT_METADATA]) { 11922e15ea39SPravin B Shelar t->collect_md = true; 1193e271c7b4SJiri Benc if (dev->type == ARPHRD_IPGRE) 1194e271c7b4SJiri Benc dev->type = ARPHRD_NONE; 11952e15ea39SPravin B Shelar } 119622a59be8SPhilip Prindeville 119722a59be8SPhilip Prindeville if (data[IFLA_GRE_IGNORE_DF]) { 119822a59be8SPhilip Prindeville if (nla_get_u8(data[IFLA_GRE_IGNORE_DF]) 119922a59be8SPhilip Prindeville && (parms->iph.frag_off & htons(IP_DF))) 120022a59be8SPhilip Prindeville return -EINVAL; 120122a59be8SPhilip Prindeville t->ignore_df = !!nla_get_u8(data[IFLA_GRE_IGNORE_DF]); 120222a59be8SPhilip Prindeville } 120322a59be8SPhilip Prindeville 12049830ad4cSCraig Gallek if (data[IFLA_GRE_FWMARK]) 12059830ad4cSCraig Gallek *fwmark = nla_get_u32(data[IFLA_GRE_FWMARK]); 12069830ad4cSCraig Gallek 1207f551c91dSWilliam Tu if (data[IFLA_GRE_ERSPAN_VER]) { 1208f551c91dSWilliam Tu t->erspan_ver = nla_get_u8(data[IFLA_GRE_ERSPAN_VER]); 1209f551c91dSWilliam Tu 1210f551c91dSWilliam Tu if (t->erspan_ver != 1 && t->erspan_ver != 2) 1211f551c91dSWilliam Tu return -EINVAL; 1212f551c91dSWilliam Tu } 1213f551c91dSWilliam Tu 1214f551c91dSWilliam Tu if (t->erspan_ver == 1) { 121584e54fe0SWilliam Tu if (data[IFLA_GRE_ERSPAN_INDEX]) { 121684e54fe0SWilliam Tu t->index = nla_get_u32(data[IFLA_GRE_ERSPAN_INDEX]); 121784e54fe0SWilliam Tu if (t->index & ~INDEX_MASK) 121884e54fe0SWilliam Tu return -EINVAL; 121984e54fe0SWilliam Tu } 1220f551c91dSWilliam Tu } else if (t->erspan_ver == 2) { 1221f551c91dSWilliam Tu if (data[IFLA_GRE_ERSPAN_DIR]) { 1222f551c91dSWilliam Tu t->dir = nla_get_u8(data[IFLA_GRE_ERSPAN_DIR]); 1223f551c91dSWilliam Tu if (t->dir & ~(DIR_MASK >> DIR_OFFSET)) 1224f551c91dSWilliam Tu return -EINVAL; 1225f551c91dSWilliam Tu } 1226f551c91dSWilliam Tu if (data[IFLA_GRE_ERSPAN_HWID]) { 1227f551c91dSWilliam Tu t->hwid = nla_get_u16(data[IFLA_GRE_ERSPAN_HWID]); 1228f551c91dSWilliam Tu if (t->hwid & ~(HWID_MASK >> HWID_OFFSET)) 1229f551c91dSWilliam Tu return -EINVAL; 1230f551c91dSWilliam Tu } 1231f551c91dSWilliam Tu } 123284e54fe0SWilliam Tu 123322a59be8SPhilip Prindeville return 0; 1234c19e654dSHerbert Xu } 1235c19e654dSHerbert Xu 12364565e991STom Herbert /* This function returns true when ENCAP attributes are present in the nl msg */ 12374565e991STom Herbert static bool ipgre_netlink_encap_parms(struct nlattr *data[], 12384565e991STom Herbert struct ip_tunnel_encap *ipencap) 12394565e991STom Herbert { 12404565e991STom Herbert bool ret = false; 12414565e991STom Herbert 12424565e991STom Herbert memset(ipencap, 0, sizeof(*ipencap)); 12434565e991STom Herbert 12444565e991STom Herbert if (!data) 12454565e991STom Herbert return ret; 12464565e991STom Herbert 12474565e991STom Herbert if (data[IFLA_GRE_ENCAP_TYPE]) { 12484565e991STom Herbert ret = true; 12494565e991STom Herbert ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]); 12504565e991STom Herbert } 12514565e991STom Herbert 12524565e991STom Herbert if (data[IFLA_GRE_ENCAP_FLAGS]) { 12534565e991STom Herbert ret = true; 12544565e991STom Herbert ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]); 12554565e991STom Herbert } 12564565e991STom Herbert 12574565e991STom Herbert if (data[IFLA_GRE_ENCAP_SPORT]) { 12584565e991STom Herbert ret = true; 12593e97fa70SSabrina Dubroca ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]); 12604565e991STom Herbert } 12614565e991STom Herbert 12624565e991STom Herbert if (data[IFLA_GRE_ENCAP_DPORT]) { 12634565e991STom Herbert ret = true; 12643e97fa70SSabrina Dubroca ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]); 12654565e991STom Herbert } 12664565e991STom Herbert 12674565e991STom Herbert return ret; 12684565e991STom Herbert } 12694565e991STom Herbert 1270c5441932SPravin B Shelar static int gre_tap_init(struct net_device *dev) 1271e1a80002SHerbert Xu { 1272c5441932SPravin B Shelar __gre_tunnel_init(dev); 1273bec94d43Sstephen hemminger dev->priv_flags |= IFF_LIVE_ADDR_CHANGE; 1274d51711c0SXin Long netif_keep_dst(dev); 1275e1a80002SHerbert Xu 1276c5441932SPravin B Shelar return ip_tunnel_init(dev); 1277e1a80002SHerbert Xu } 1278e1a80002SHerbert Xu 1279c5441932SPravin B Shelar static const struct net_device_ops gre_tap_netdev_ops = { 1280c5441932SPravin B Shelar .ndo_init = gre_tap_init, 1281c5441932SPravin B Shelar .ndo_uninit = ip_tunnel_uninit, 1282c5441932SPravin B Shelar .ndo_start_xmit = gre_tap_xmit, 1283b8c26a33SStephen Hemminger .ndo_set_mac_address = eth_mac_addr, 1284b8c26a33SStephen Hemminger .ndo_validate_addr = eth_validate_addr, 1285c5441932SPravin B Shelar .ndo_change_mtu = ip_tunnel_change_mtu, 1286c5441932SPravin B Shelar .ndo_get_stats64 = ip_tunnel_get_stats64, 12871e99584bSNicolas Dichtel .ndo_get_iflink = ip_tunnel_get_iflink, 1288fc4099f1SPravin B Shelar .ndo_fill_metadata_dst = gre_fill_metadata_dst, 1289b8c26a33SStephen Hemminger }; 1290b8c26a33SStephen Hemminger 129184e54fe0SWilliam Tu static int erspan_tunnel_init(struct net_device *dev) 129284e54fe0SWilliam Tu { 129384e54fe0SWilliam Tu struct ip_tunnel *tunnel = netdev_priv(dev); 129484e54fe0SWilliam Tu int t_hlen; 129584e54fe0SWilliam Tu 129684e54fe0SWilliam Tu tunnel->tun_hlen = 8; 129784e54fe0SWilliam Tu tunnel->parms.iph.protocol = IPPROTO_GRE; 1298c122fda2SXin Long tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen + 1299f551c91dSWilliam Tu erspan_hdr_len(tunnel->erspan_ver); 1300c122fda2SXin Long t_hlen = tunnel->hlen + sizeof(struct iphdr); 130184e54fe0SWilliam Tu 130284e54fe0SWilliam Tu dev->needed_headroom = LL_MAX_HEADER + t_hlen + 4; 130384e54fe0SWilliam Tu dev->mtu = ETH_DATA_LEN - t_hlen - 4; 130484e54fe0SWilliam Tu dev->features |= GRE_FEATURES; 130584e54fe0SWilliam Tu dev->hw_features |= GRE_FEATURES; 130684e54fe0SWilliam Tu dev->priv_flags |= IFF_LIVE_ADDR_CHANGE; 1307c84bed44SXin Long netif_keep_dst(dev); 130884e54fe0SWilliam Tu 130984e54fe0SWilliam Tu return ip_tunnel_init(dev); 131084e54fe0SWilliam Tu } 131184e54fe0SWilliam Tu 131284e54fe0SWilliam Tu static const struct net_device_ops erspan_netdev_ops = { 131384e54fe0SWilliam Tu .ndo_init = erspan_tunnel_init, 131484e54fe0SWilliam Tu .ndo_uninit = ip_tunnel_uninit, 131584e54fe0SWilliam Tu .ndo_start_xmit = erspan_xmit, 131684e54fe0SWilliam Tu .ndo_set_mac_address = eth_mac_addr, 131784e54fe0SWilliam Tu .ndo_validate_addr = eth_validate_addr, 131884e54fe0SWilliam Tu .ndo_change_mtu = ip_tunnel_change_mtu, 131984e54fe0SWilliam Tu .ndo_get_stats64 = ip_tunnel_get_stats64, 132084e54fe0SWilliam Tu .ndo_get_iflink = ip_tunnel_get_iflink, 132184e54fe0SWilliam Tu .ndo_fill_metadata_dst = gre_fill_metadata_dst, 132284e54fe0SWilliam Tu }; 132384e54fe0SWilliam Tu 1324e1a80002SHerbert Xu static void ipgre_tap_setup(struct net_device *dev) 1325e1a80002SHerbert Xu { 1326e1a80002SHerbert Xu ether_setup(dev); 1327cfddd4c3SXin Long dev->max_mtu = 0; 1328c5441932SPravin B Shelar dev->netdev_ops = &gre_tap_netdev_ops; 1329d13b161cSJiri Benc dev->priv_flags &= ~IFF_TX_SKB_SHARING; 1330f8c1b7ceSstephen hemminger dev->priv_flags |= IFF_LIVE_ADDR_CHANGE; 1331c5441932SPravin B Shelar ip_tunnel_setup(dev, gre_tap_net_id); 1332e1a80002SHerbert Xu } 1333e1a80002SHerbert Xu 1334c5441932SPravin B Shelar static int ipgre_newlink(struct net *src_net, struct net_device *dev, 13357a3f4a18SMatthias Schiffer struct nlattr *tb[], struct nlattr *data[], 13367a3f4a18SMatthias Schiffer struct netlink_ext_ack *extack) 1337c19e654dSHerbert Xu { 1338c5441932SPravin B Shelar struct ip_tunnel_parm p; 13394565e991STom Herbert struct ip_tunnel_encap ipencap; 13409830ad4cSCraig Gallek __u32 fwmark = 0; 134122a59be8SPhilip Prindeville int err; 13424565e991STom Herbert 13434565e991STom Herbert if (ipgre_netlink_encap_parms(data, &ipencap)) { 13444565e991STom Herbert struct ip_tunnel *t = netdev_priv(dev); 134522a59be8SPhilip Prindeville err = ip_tunnel_encap_setup(t, &ipencap); 13464565e991STom Herbert 13474565e991STom Herbert if (err < 0) 13484565e991STom Herbert return err; 13494565e991STom Herbert } 1350c19e654dSHerbert Xu 13519830ad4cSCraig Gallek err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark); 135222a59be8SPhilip Prindeville if (err < 0) 135322a59be8SPhilip Prindeville return err; 13549830ad4cSCraig Gallek return ip_tunnel_newlink(dev, tb, &p, fwmark); 1355c19e654dSHerbert Xu } 1356c19e654dSHerbert Xu 1357c19e654dSHerbert Xu static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[], 1358ad744b22SMatthias Schiffer struct nlattr *data[], 1359ad744b22SMatthias Schiffer struct netlink_ext_ack *extack) 1360c19e654dSHerbert Xu { 13619830ad4cSCraig Gallek struct ip_tunnel *t = netdev_priv(dev); 13624565e991STom Herbert struct ip_tunnel_encap ipencap; 13639830ad4cSCraig Gallek __u32 fwmark = t->fwmark; 1364dd9d598cSXin Long struct ip_tunnel_parm p; 136522a59be8SPhilip Prindeville int err; 13664565e991STom Herbert 13674565e991STom Herbert if (ipgre_netlink_encap_parms(data, &ipencap)) { 136822a59be8SPhilip Prindeville err = ip_tunnel_encap_setup(t, &ipencap); 13694565e991STom Herbert 13704565e991STom Herbert if (err < 0) 13714565e991STom Herbert return err; 13724565e991STom Herbert } 1373c19e654dSHerbert Xu 13749830ad4cSCraig Gallek err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark); 137522a59be8SPhilip Prindeville if (err < 0) 137622a59be8SPhilip Prindeville return err; 1377dd9d598cSXin Long 1378dd9d598cSXin Long err = ip_tunnel_changelink(dev, tb, &p, fwmark); 1379dd9d598cSXin Long if (err < 0) 1380dd9d598cSXin Long return err; 1381dd9d598cSXin Long 1382dd9d598cSXin Long t->parms.i_flags = p.i_flags; 1383dd9d598cSXin Long t->parms.o_flags = p.o_flags; 1384dd9d598cSXin Long 1385dd9d598cSXin Long if (strcmp(dev->rtnl_link_ops->kind, "erspan")) 1386dd9d598cSXin Long ipgre_link_update(dev, !tb[IFLA_MTU]); 1387dd9d598cSXin Long 1388dd9d598cSXin Long return 0; 1389c19e654dSHerbert Xu } 1390c19e654dSHerbert Xu 1391c19e654dSHerbert Xu static size_t ipgre_get_size(const struct net_device *dev) 1392c19e654dSHerbert Xu { 1393c19e654dSHerbert Xu return 1394c19e654dSHerbert Xu /* IFLA_GRE_LINK */ 1395c19e654dSHerbert Xu nla_total_size(4) + 1396c19e654dSHerbert Xu /* IFLA_GRE_IFLAGS */ 1397c19e654dSHerbert Xu nla_total_size(2) + 1398c19e654dSHerbert Xu /* IFLA_GRE_OFLAGS */ 1399c19e654dSHerbert Xu nla_total_size(2) + 1400c19e654dSHerbert Xu /* IFLA_GRE_IKEY */ 1401c19e654dSHerbert Xu nla_total_size(4) + 1402c19e654dSHerbert Xu /* IFLA_GRE_OKEY */ 1403c19e654dSHerbert Xu nla_total_size(4) + 1404c19e654dSHerbert Xu /* IFLA_GRE_LOCAL */ 1405c19e654dSHerbert Xu nla_total_size(4) + 1406c19e654dSHerbert Xu /* IFLA_GRE_REMOTE */ 1407c19e654dSHerbert Xu nla_total_size(4) + 1408c19e654dSHerbert Xu /* IFLA_GRE_TTL */ 1409c19e654dSHerbert Xu nla_total_size(1) + 1410c19e654dSHerbert Xu /* IFLA_GRE_TOS */ 1411c19e654dSHerbert Xu nla_total_size(1) + 1412c19e654dSHerbert Xu /* IFLA_GRE_PMTUDISC */ 1413c19e654dSHerbert Xu nla_total_size(1) + 14144565e991STom Herbert /* IFLA_GRE_ENCAP_TYPE */ 14154565e991STom Herbert nla_total_size(2) + 14164565e991STom Herbert /* IFLA_GRE_ENCAP_FLAGS */ 14174565e991STom Herbert nla_total_size(2) + 14184565e991STom Herbert /* IFLA_GRE_ENCAP_SPORT */ 14194565e991STom Herbert nla_total_size(2) + 14204565e991STom Herbert /* IFLA_GRE_ENCAP_DPORT */ 14214565e991STom Herbert nla_total_size(2) + 14222e15ea39SPravin B Shelar /* IFLA_GRE_COLLECT_METADATA */ 14232e15ea39SPravin B Shelar nla_total_size(0) + 142422a59be8SPhilip Prindeville /* IFLA_GRE_IGNORE_DF */ 142522a59be8SPhilip Prindeville nla_total_size(1) + 14269830ad4cSCraig Gallek /* IFLA_GRE_FWMARK */ 14279830ad4cSCraig Gallek nla_total_size(4) + 142884e54fe0SWilliam Tu /* IFLA_GRE_ERSPAN_INDEX */ 142984e54fe0SWilliam Tu nla_total_size(4) + 1430f551c91dSWilliam Tu /* IFLA_GRE_ERSPAN_VER */ 1431f551c91dSWilliam Tu nla_total_size(1) + 1432f551c91dSWilliam Tu /* IFLA_GRE_ERSPAN_DIR */ 1433f551c91dSWilliam Tu nla_total_size(1) + 1434f551c91dSWilliam Tu /* IFLA_GRE_ERSPAN_HWID */ 1435f551c91dSWilliam Tu nla_total_size(2) + 1436c19e654dSHerbert Xu 0; 1437c19e654dSHerbert Xu } 1438c19e654dSHerbert Xu 1439c19e654dSHerbert Xu static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev) 1440c19e654dSHerbert Xu { 1441c19e654dSHerbert Xu struct ip_tunnel *t = netdev_priv(dev); 1442c19e654dSHerbert Xu struct ip_tunnel_parm *p = &t->parms; 1443c19e654dSHerbert Xu 1444f3756b79SDavid S. Miller if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) || 144595f5c64cSTom Herbert nla_put_be16(skb, IFLA_GRE_IFLAGS, 144695f5c64cSTom Herbert gre_tnl_flags_to_gre_flags(p->i_flags)) || 144795f5c64cSTom Herbert nla_put_be16(skb, IFLA_GRE_OFLAGS, 144895f5c64cSTom Herbert gre_tnl_flags_to_gre_flags(p->o_flags)) || 1449f3756b79SDavid S. Miller nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) || 1450f3756b79SDavid S. Miller nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) || 1451930345eaSJiri Benc nla_put_in_addr(skb, IFLA_GRE_LOCAL, p->iph.saddr) || 1452930345eaSJiri Benc nla_put_in_addr(skb, IFLA_GRE_REMOTE, p->iph.daddr) || 1453f3756b79SDavid S. Miller nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) || 1454f3756b79SDavid S. Miller nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) || 1455f3756b79SDavid S. Miller nla_put_u8(skb, IFLA_GRE_PMTUDISC, 14569830ad4cSCraig Gallek !!(p->iph.frag_off & htons(IP_DF))) || 14579830ad4cSCraig Gallek nla_put_u32(skb, IFLA_GRE_FWMARK, t->fwmark)) 1458f3756b79SDavid S. Miller goto nla_put_failure; 14594565e991STom Herbert 14604565e991STom Herbert if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE, 14614565e991STom Herbert t->encap.type) || 14623e97fa70SSabrina Dubroca nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT, 14634565e991STom Herbert t->encap.sport) || 14643e97fa70SSabrina Dubroca nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT, 14654565e991STom Herbert t->encap.dport) || 14664565e991STom Herbert nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS, 1467e1b2cb65STom Herbert t->encap.flags)) 14684565e991STom Herbert goto nla_put_failure; 14694565e991STom Herbert 147022a59be8SPhilip Prindeville if (nla_put_u8(skb, IFLA_GRE_IGNORE_DF, t->ignore_df)) 147122a59be8SPhilip Prindeville goto nla_put_failure; 147222a59be8SPhilip Prindeville 14732e15ea39SPravin B Shelar if (t->collect_md) { 14742e15ea39SPravin B Shelar if (nla_put_flag(skb, IFLA_GRE_COLLECT_METADATA)) 14752e15ea39SPravin B Shelar goto nla_put_failure; 14762e15ea39SPravin B Shelar } 14772e15ea39SPravin B Shelar 1478f551c91dSWilliam Tu if (nla_put_u8(skb, IFLA_GRE_ERSPAN_VER, t->erspan_ver)) 1479f551c91dSWilliam Tu goto nla_put_failure; 1480f551c91dSWilliam Tu 1481f551c91dSWilliam Tu if (t->erspan_ver == 1) { 148284e54fe0SWilliam Tu if (nla_put_u32(skb, IFLA_GRE_ERSPAN_INDEX, t->index)) 148384e54fe0SWilliam Tu goto nla_put_failure; 1484f551c91dSWilliam Tu } else if (t->erspan_ver == 2) { 1485f551c91dSWilliam Tu if (nla_put_u8(skb, IFLA_GRE_ERSPAN_DIR, t->dir)) 1486f551c91dSWilliam Tu goto nla_put_failure; 1487f551c91dSWilliam Tu if (nla_put_u16(skb, IFLA_GRE_ERSPAN_HWID, t->hwid)) 1488f551c91dSWilliam Tu goto nla_put_failure; 1489f551c91dSWilliam Tu } 149084e54fe0SWilliam Tu 1491c19e654dSHerbert Xu return 0; 1492c19e654dSHerbert Xu 1493c19e654dSHerbert Xu nla_put_failure: 1494c19e654dSHerbert Xu return -EMSGSIZE; 1495c19e654dSHerbert Xu } 1496c19e654dSHerbert Xu 149784e54fe0SWilliam Tu static void erspan_setup(struct net_device *dev) 149884e54fe0SWilliam Tu { 149984e54fe0SWilliam Tu ether_setup(dev); 150084e54fe0SWilliam Tu dev->netdev_ops = &erspan_netdev_ops; 150184e54fe0SWilliam Tu dev->priv_flags &= ~IFF_TX_SKB_SHARING; 150284e54fe0SWilliam Tu dev->priv_flags |= IFF_LIVE_ADDR_CHANGE; 150384e54fe0SWilliam Tu ip_tunnel_setup(dev, erspan_net_id); 150484e54fe0SWilliam Tu } 150584e54fe0SWilliam Tu 1506c19e654dSHerbert Xu static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = { 1507c19e654dSHerbert Xu [IFLA_GRE_LINK] = { .type = NLA_U32 }, 1508c19e654dSHerbert Xu [IFLA_GRE_IFLAGS] = { .type = NLA_U16 }, 1509c19e654dSHerbert Xu [IFLA_GRE_OFLAGS] = { .type = NLA_U16 }, 1510c19e654dSHerbert Xu [IFLA_GRE_IKEY] = { .type = NLA_U32 }, 1511c19e654dSHerbert Xu [IFLA_GRE_OKEY] = { .type = NLA_U32 }, 15124d74f8baSPatrick McHardy [IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) }, 15134d74f8baSPatrick McHardy [IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct iphdr, daddr) }, 1514c19e654dSHerbert Xu [IFLA_GRE_TTL] = { .type = NLA_U8 }, 1515c19e654dSHerbert Xu [IFLA_GRE_TOS] = { .type = NLA_U8 }, 1516c19e654dSHerbert Xu [IFLA_GRE_PMTUDISC] = { .type = NLA_U8 }, 15174565e991STom Herbert [IFLA_GRE_ENCAP_TYPE] = { .type = NLA_U16 }, 15184565e991STom Herbert [IFLA_GRE_ENCAP_FLAGS] = { .type = NLA_U16 }, 15194565e991STom Herbert [IFLA_GRE_ENCAP_SPORT] = { .type = NLA_U16 }, 15204565e991STom Herbert [IFLA_GRE_ENCAP_DPORT] = { .type = NLA_U16 }, 15212e15ea39SPravin B Shelar [IFLA_GRE_COLLECT_METADATA] = { .type = NLA_FLAG }, 152222a59be8SPhilip Prindeville [IFLA_GRE_IGNORE_DF] = { .type = NLA_U8 }, 15239830ad4cSCraig Gallek [IFLA_GRE_FWMARK] = { .type = NLA_U32 }, 152484e54fe0SWilliam Tu [IFLA_GRE_ERSPAN_INDEX] = { .type = NLA_U32 }, 1525f551c91dSWilliam Tu [IFLA_GRE_ERSPAN_VER] = { .type = NLA_U8 }, 1526f551c91dSWilliam Tu [IFLA_GRE_ERSPAN_DIR] = { .type = NLA_U8 }, 1527f551c91dSWilliam Tu [IFLA_GRE_ERSPAN_HWID] = { .type = NLA_U16 }, 1528c19e654dSHerbert Xu }; 1529c19e654dSHerbert Xu 1530c19e654dSHerbert Xu static struct rtnl_link_ops ipgre_link_ops __read_mostly = { 1531c19e654dSHerbert Xu .kind = "gre", 1532c19e654dSHerbert Xu .maxtype = IFLA_GRE_MAX, 1533c19e654dSHerbert Xu .policy = ipgre_policy, 1534c19e654dSHerbert Xu .priv_size = sizeof(struct ip_tunnel), 1535c19e654dSHerbert Xu .setup = ipgre_tunnel_setup, 1536c19e654dSHerbert Xu .validate = ipgre_tunnel_validate, 1537c19e654dSHerbert Xu .newlink = ipgre_newlink, 1538c19e654dSHerbert Xu .changelink = ipgre_changelink, 1539c5441932SPravin B Shelar .dellink = ip_tunnel_dellink, 1540c19e654dSHerbert Xu .get_size = ipgre_get_size, 1541c19e654dSHerbert Xu .fill_info = ipgre_fill_info, 15421728d4faSNicolas Dichtel .get_link_net = ip_tunnel_get_link_net, 1543c19e654dSHerbert Xu }; 1544c19e654dSHerbert Xu 1545e1a80002SHerbert Xu static struct rtnl_link_ops ipgre_tap_ops __read_mostly = { 1546e1a80002SHerbert Xu .kind = "gretap", 1547e1a80002SHerbert Xu .maxtype = IFLA_GRE_MAX, 1548e1a80002SHerbert Xu .policy = ipgre_policy, 1549e1a80002SHerbert Xu .priv_size = sizeof(struct ip_tunnel), 1550e1a80002SHerbert Xu .setup = ipgre_tap_setup, 1551e1a80002SHerbert Xu .validate = ipgre_tap_validate, 1552e1a80002SHerbert Xu .newlink = ipgre_newlink, 1553e1a80002SHerbert Xu .changelink = ipgre_changelink, 1554c5441932SPravin B Shelar .dellink = ip_tunnel_dellink, 1555e1a80002SHerbert Xu .get_size = ipgre_get_size, 1556e1a80002SHerbert Xu .fill_info = ipgre_fill_info, 15571728d4faSNicolas Dichtel .get_link_net = ip_tunnel_get_link_net, 1558e1a80002SHerbert Xu }; 1559e1a80002SHerbert Xu 156084e54fe0SWilliam Tu static struct rtnl_link_ops erspan_link_ops __read_mostly = { 156184e54fe0SWilliam Tu .kind = "erspan", 156284e54fe0SWilliam Tu .maxtype = IFLA_GRE_MAX, 156384e54fe0SWilliam Tu .policy = ipgre_policy, 156484e54fe0SWilliam Tu .priv_size = sizeof(struct ip_tunnel), 156584e54fe0SWilliam Tu .setup = erspan_setup, 156684e54fe0SWilliam Tu .validate = erspan_validate, 156784e54fe0SWilliam Tu .newlink = ipgre_newlink, 156884e54fe0SWilliam Tu .changelink = ipgre_changelink, 156984e54fe0SWilliam Tu .dellink = ip_tunnel_dellink, 157084e54fe0SWilliam Tu .get_size = ipgre_get_size, 157184e54fe0SWilliam Tu .fill_info = ipgre_fill_info, 157284e54fe0SWilliam Tu .get_link_net = ip_tunnel_get_link_net, 157384e54fe0SWilliam Tu }; 157484e54fe0SWilliam Tu 1575b2acd1dcSPravin B Shelar struct net_device *gretap_fb_dev_create(struct net *net, const char *name, 1576b2acd1dcSPravin B Shelar u8 name_assign_type) 1577b2acd1dcSPravin B Shelar { 1578b2acd1dcSPravin B Shelar struct nlattr *tb[IFLA_MAX + 1]; 1579b2acd1dcSPravin B Shelar struct net_device *dev; 1580106da663SNicolas Dichtel LIST_HEAD(list_kill); 1581b2acd1dcSPravin B Shelar struct ip_tunnel *t; 1582b2acd1dcSPravin B Shelar int err; 1583b2acd1dcSPravin B Shelar 1584b2acd1dcSPravin B Shelar memset(&tb, 0, sizeof(tb)); 1585b2acd1dcSPravin B Shelar 1586b2acd1dcSPravin B Shelar dev = rtnl_create_link(net, name, name_assign_type, 1587b2acd1dcSPravin B Shelar &ipgre_tap_ops, tb); 1588b2acd1dcSPravin B Shelar if (IS_ERR(dev)) 1589b2acd1dcSPravin B Shelar return dev; 1590b2acd1dcSPravin B Shelar 1591b2acd1dcSPravin B Shelar /* Configure flow based GRE device. */ 1592b2acd1dcSPravin B Shelar t = netdev_priv(dev); 1593b2acd1dcSPravin B Shelar t->collect_md = true; 1594b2acd1dcSPravin B Shelar 15957a3f4a18SMatthias Schiffer err = ipgre_newlink(net, dev, tb, NULL, NULL); 1596106da663SNicolas Dichtel if (err < 0) { 1597106da663SNicolas Dichtel free_netdev(dev); 1598106da663SNicolas Dichtel return ERR_PTR(err); 1599106da663SNicolas Dichtel } 16007e059158SDavid Wragg 16017e059158SDavid Wragg /* openvswitch users expect packet sizes to be unrestricted, 16027e059158SDavid Wragg * so set the largest MTU we can. 16037e059158SDavid Wragg */ 16047e059158SDavid Wragg err = __ip_tunnel_change_mtu(dev, IP_MAX_MTU, false); 16057e059158SDavid Wragg if (err) 16067e059158SDavid Wragg goto out; 16077e059158SDavid Wragg 1608da6f1da8SNicolas Dichtel err = rtnl_configure_link(dev, NULL); 1609da6f1da8SNicolas Dichtel if (err < 0) 1610da6f1da8SNicolas Dichtel goto out; 1611da6f1da8SNicolas Dichtel 1612b2acd1dcSPravin B Shelar return dev; 1613b2acd1dcSPravin B Shelar out: 1614106da663SNicolas Dichtel ip_tunnel_dellink(dev, &list_kill); 1615106da663SNicolas Dichtel unregister_netdevice_many(&list_kill); 1616b2acd1dcSPravin B Shelar return ERR_PTR(err); 1617b2acd1dcSPravin B Shelar } 1618b2acd1dcSPravin B Shelar EXPORT_SYMBOL_GPL(gretap_fb_dev_create); 1619b2acd1dcSPravin B Shelar 1620c5441932SPravin B Shelar static int __net_init ipgre_tap_init_net(struct net *net) 1621c5441932SPravin B Shelar { 16222e15ea39SPravin B Shelar return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, "gretap0"); 1623c5441932SPravin B Shelar } 1624c5441932SPravin B Shelar 162564bc1781SEric Dumazet static void __net_exit ipgre_tap_exit_batch_net(struct list_head *list_net) 1626c5441932SPravin B Shelar { 162764bc1781SEric Dumazet ip_tunnel_delete_nets(list_net, gre_tap_net_id, &ipgre_tap_ops); 1628c5441932SPravin B Shelar } 1629c5441932SPravin B Shelar 1630c5441932SPravin B Shelar static struct pernet_operations ipgre_tap_net_ops = { 1631c5441932SPravin B Shelar .init = ipgre_tap_init_net, 163264bc1781SEric Dumazet .exit_batch = ipgre_tap_exit_batch_net, 1633c5441932SPravin B Shelar .id = &gre_tap_net_id, 1634c5441932SPravin B Shelar .size = sizeof(struct ip_tunnel_net), 1635c5441932SPravin B Shelar }; 16361da177e4SLinus Torvalds 163784e54fe0SWilliam Tu static int __net_init erspan_init_net(struct net *net) 163884e54fe0SWilliam Tu { 163984e54fe0SWilliam Tu return ip_tunnel_init_net(net, erspan_net_id, 164084e54fe0SWilliam Tu &erspan_link_ops, "erspan0"); 164184e54fe0SWilliam Tu } 164284e54fe0SWilliam Tu 164364bc1781SEric Dumazet static void __net_exit erspan_exit_batch_net(struct list_head *net_list) 164484e54fe0SWilliam Tu { 164564bc1781SEric Dumazet ip_tunnel_delete_nets(net_list, erspan_net_id, &erspan_link_ops); 164684e54fe0SWilliam Tu } 164784e54fe0SWilliam Tu 164884e54fe0SWilliam Tu static struct pernet_operations erspan_net_ops = { 164984e54fe0SWilliam Tu .init = erspan_init_net, 165064bc1781SEric Dumazet .exit_batch = erspan_exit_batch_net, 165184e54fe0SWilliam Tu .id = &erspan_net_id, 165284e54fe0SWilliam Tu .size = sizeof(struct ip_tunnel_net), 165384e54fe0SWilliam Tu }; 165484e54fe0SWilliam Tu 16551da177e4SLinus Torvalds static int __init ipgre_init(void) 16561da177e4SLinus Torvalds { 16571da177e4SLinus Torvalds int err; 16581da177e4SLinus Torvalds 1659058bd4d2SJoe Perches pr_info("GRE over IPv4 tunneling driver\n"); 16601da177e4SLinus Torvalds 1661cfb8fbf2SEric W. Biederman err = register_pernet_device(&ipgre_net_ops); 166259a4c759SPavel Emelyanov if (err < 0) 1663c2892f02SAlexey Dobriyan return err; 1664c2892f02SAlexey Dobriyan 1665c5441932SPravin B Shelar err = register_pernet_device(&ipgre_tap_net_ops); 1666c5441932SPravin B Shelar if (err < 0) 1667e3d0328cSWilliam Tu goto pnet_tap_failed; 1668c5441932SPravin B Shelar 166984e54fe0SWilliam Tu err = register_pernet_device(&erspan_net_ops); 167084e54fe0SWilliam Tu if (err < 0) 167184e54fe0SWilliam Tu goto pnet_erspan_failed; 167284e54fe0SWilliam Tu 16739f57c67cSPravin B Shelar err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO); 1674c2892f02SAlexey Dobriyan if (err < 0) { 1675058bd4d2SJoe Perches pr_info("%s: can't add protocol\n", __func__); 1676c2892f02SAlexey Dobriyan goto add_proto_failed; 1677c2892f02SAlexey Dobriyan } 16787daa0004SPavel Emelyanov 1679c19e654dSHerbert Xu err = rtnl_link_register(&ipgre_link_ops); 1680c19e654dSHerbert Xu if (err < 0) 1681c19e654dSHerbert Xu goto rtnl_link_failed; 1682c19e654dSHerbert Xu 1683e1a80002SHerbert Xu err = rtnl_link_register(&ipgre_tap_ops); 1684e1a80002SHerbert Xu if (err < 0) 1685e1a80002SHerbert Xu goto tap_ops_failed; 1686e1a80002SHerbert Xu 168784e54fe0SWilliam Tu err = rtnl_link_register(&erspan_link_ops); 168884e54fe0SWilliam Tu if (err < 0) 168984e54fe0SWilliam Tu goto erspan_link_failed; 169084e54fe0SWilliam Tu 1691c5441932SPravin B Shelar return 0; 1692c19e654dSHerbert Xu 169384e54fe0SWilliam Tu erspan_link_failed: 169484e54fe0SWilliam Tu rtnl_link_unregister(&ipgre_tap_ops); 1695e1a80002SHerbert Xu tap_ops_failed: 1696e1a80002SHerbert Xu rtnl_link_unregister(&ipgre_link_ops); 1697c19e654dSHerbert Xu rtnl_link_failed: 16989f57c67cSPravin B Shelar gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO); 1699c2892f02SAlexey Dobriyan add_proto_failed: 170084e54fe0SWilliam Tu unregister_pernet_device(&erspan_net_ops); 170184e54fe0SWilliam Tu pnet_erspan_failed: 1702c5441932SPravin B Shelar unregister_pernet_device(&ipgre_tap_net_ops); 1703e3d0328cSWilliam Tu pnet_tap_failed: 1704c2892f02SAlexey Dobriyan unregister_pernet_device(&ipgre_net_ops); 1705c5441932SPravin B Shelar return err; 17061da177e4SLinus Torvalds } 17071da177e4SLinus Torvalds 1708db44575fSAlexey Kuznetsov static void __exit ipgre_fini(void) 17091da177e4SLinus Torvalds { 1710e1a80002SHerbert Xu rtnl_link_unregister(&ipgre_tap_ops); 1711c19e654dSHerbert Xu rtnl_link_unregister(&ipgre_link_ops); 171284e54fe0SWilliam Tu rtnl_link_unregister(&erspan_link_ops); 17139f57c67cSPravin B Shelar gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO); 1714c5441932SPravin B Shelar unregister_pernet_device(&ipgre_tap_net_ops); 1715c2892f02SAlexey Dobriyan unregister_pernet_device(&ipgre_net_ops); 171684e54fe0SWilliam Tu unregister_pernet_device(&erspan_net_ops); 17171da177e4SLinus Torvalds } 17181da177e4SLinus Torvalds 17191da177e4SLinus Torvalds module_init(ipgre_init); 17201da177e4SLinus Torvalds module_exit(ipgre_fini); 17211da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 17224d74f8baSPatrick McHardy MODULE_ALIAS_RTNL_LINK("gre"); 17234d74f8baSPatrick McHardy MODULE_ALIAS_RTNL_LINK("gretap"); 172484e54fe0SWilliam Tu MODULE_ALIAS_RTNL_LINK("erspan"); 17258909c9adSVasiliy Kulikov MODULE_ALIAS_NETDEV("gre0"); 1726c5441932SPravin B Shelar MODULE_ALIAS_NETDEV("gretap0"); 172784e54fe0SWilliam Tu MODULE_ALIAS_NETDEV("erspan0"); 1728