Release 4.8 net/ipv4/ip_gre.c

/*
 *      Linux NET3:     GRE over IP protocol decoder.
 *
 *      Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 *
 */


#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/capability.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <asm/uaccess.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/in.h>
#include <linux/tcp.h>
#include <linux/udp.h>
#include <linux/if_arp.h>
#include <linux/if_vlan.h>
#include <linux/init.h>
#include <linux/in6.h>
#include <linux/inetdevice.h>
#include <linux/igmp.h>
#include <linux/netfilter_ipv4.h>
#include <linux/etherdevice.h>
#include <linux/if_ether.h>

#include <net/sock.h>
#include <net/ip.h>
#include <net/icmp.h>
#include <net/protocol.h>
#include <net/ip_tunnels.h>
#include <net/arp.h>
#include <net/checksum.h>
#include <net/dsfield.h>
#include <net/inet_ecn.h>
#include <net/xfrm.h>
#include <net/net_namespace.h>
#include <net/netns/generic.h>
#include <net/rtnetlink.h>
#include <net/gre.h>
#include <net/dst_metadata.h>

/*
   Problems & solutions
   --------------------

   1. The most important issue is detecting local dead loops.
   They would cause complete host lockup in transmit, which
   would be "resolved" by stack overflow or, if queueing is enabled,
   with infinite looping in net_bh.

   We cannot track such dead loops during route installation,
   it is infeasible task. The most general solutions would be
   to keep skb->encapsulation counter (sort of local ttl),
   and silently drop packet when it expires. It is a good
   solution, but it supposes maintaining new variable in ALL
   skb, even if no tunneling is used.

   Current solution: xmit_recursion breaks dead loops. This is a percpu
   counter, since when we enter the first ndo_xmit(), cpu migration is
   forbidden. We force an exit if this counter reaches RECURSION_LIMIT

   2. Networking dead loops would not kill routers, but would really
   kill network. IP hop limit plays role of "t->recursion" in this case,
   if we copy it from packet being encapsulated to upper header.
   It is very good solution, but it introduces two problems:

   - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
     do not work over tunnels.
   - traceroute does not work. I planned to relay ICMP from tunnel,
     so that this problem would be solved and traceroute output
     would even more informative. This idea appeared to be wrong:
     only Linux complies to rfc1812 now (yes, guys, Linux is the only
     true router now :-)), all routers (at least, in neighbourhood of mine)
     return only 8 bytes of payload. It is the end.

   Hence, if we want that OSPF worked or traceroute said something reasonable,
   we should search for another solution.

   One of them is to parse packet trying to detect inner encapsulation
   made by our node. It is difficult or even impossible, especially,
   taking into account fragmentation. TO be short, ttl is not solution at all.

   Current solution: The solution was UNEXPECTEDLY SIMPLE.
   We force DF flag on tunnels with preconfigured hop limit,
   that is ALL. :-) Well, it does not remove the problem completely,
   but exponential growth of network traffic is changed to linear
   (branches, that exceed pmtu are pruned) and tunnel mtu
   rapidly degrades to value <68, where looping stops.
   Yes, it is not good if there exists a router in the loop,
   which does not force DF, even when encapsulating packets have DF set.
   But it is not our problem! Nobody could accuse us, we made
   all that we could make. Even if it is your gated who injected
   fatal route to network, even if it were you who configured
   fatal static route: you are innocent. :-)

   Alexey Kuznetsov.
 */


static bool log_ecn_error = true;
module_param(log_ecn_error, bool, 0644);
MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");


static struct rtnl_link_ops ipgre_link_ops __read_mostly;
static int ipgre_tunnel_init(struct net_device *dev);


static int ipgre_net_id __read_mostly;

static int gre_tap_net_id __read_mostly;



static void ipgre_err(struct sk_buff *skb, u32 info,
		      const struct tnl_ptk_info *tpi)
{

	/* All the routers (except for Linux) return only
           8 bytes of packet payload. It means, that precise relaying of
           ICMP in the real Internet is absolutely infeasible.

           Moreover, Cisco "wise men" put GRE key to the third word
           in GRE header. It makes impossible maintaining even soft
           state for keyed GRE tunnels with enabled checksum. Tell
           them "thank you".

           Well, I wonder, rfc1812 was written by Cisco employee,
           what the hell these idiots break standards established
           by themselves???
           */
	struct net *net = dev_net(skb->dev);
	struct ip_tunnel_net *itn;
	const struct iphdr *iph;
	const int type = icmp_hdr(skb)->type;
	const int code = icmp_hdr(skb)->code;
	unsigned int data_len = 0;
	struct ip_tunnel *t;

	switch (type) {
	default:
	case ICMP_PARAMETERPROB:
		return;

	case ICMP_DEST_UNREACH:
		switch (code) {
		case ICMP_SR_FAILED:
		case ICMP_PORT_UNREACH:
			/* Impossible event. */
			return;
		default:
			/* All others are translated to HOST_UNREACH.
                           rfc2003 contains "deep thoughts" about NET_UNREACH,
                           I believe they are just ether pollution. --ANK
                         */
			break;
		}
		break;

	case ICMP_TIME_EXCEEDED:
		if (code != ICMP_EXC_TTL)
			return;
		data_len = icmp_hdr(skb)->un.reserved[1] * 4; /* RFC 4884 4.1 */
		break;

	case ICMP_REDIRECT:
		break;
	}

	if (tpi->proto == htons(ETH_P_TEB))
		itn = net_generic(net, gre_tap_net_id);
	else
		itn = net_generic(net, ipgre_net_id);

	iph = (const struct iphdr *)(icmp_hdr(skb) + 1);
	t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
			     iph->daddr, iph->saddr, tpi->key);

	if (!t)
		return;

#if IS_ENABLED(CONFIG_IPV6)
       if (tpi->proto == htons(ETH_P_IPV6) &&
           !ip6_err_gen_icmpv6_unreach(skb, iph->ihl * 4 + tpi->hdr_len,
				       type, data_len))
               return;
#endif

	if (t->parms.iph.daddr == 0 ||
	    ipv4_is_multicast(t->parms.iph.daddr))
		return;

	if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
		return;

	if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
		t->err_count++;
	else
		t->err_count = 1;
	t->err_time = jiffies;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
158
47.16%
3
16.67%
eric dumazet
eric dumazet
77
22.99%
5
27.78%
pre-git
pre-git
30
8.96%
1
5.56%
timo teras
timo teras
30
8.96%
2
11.11%
herbert xu
herbert xu
15
4.48%
1
5.56%
stephen hemminger
stephen hemminger
13
3.88%
1
5.56%
duan jiong
duan jiong
7
2.09%
1
5.56%
pavel emelianov
pavel emelianov
2
0.60%
1
5.56%
ian morris
ian morris
1
0.30%
1
5.56%
americo wang
americo wang
1
0.30%
1
5.56%
joe perches
joe perches
1
0.30%
1
5.56%
Total
335
100.00%
18
100.00%



static void gre_err(struct sk_buff *skb, u32 info)
{
	/* All the routers (except for Linux) return only
         * 8 bytes of packet payload. It means, that precise relaying of
         * ICMP in the real Internet is absolutely infeasible.
         *
         * Moreover, Cisco "wise men" put GRE key to the third word
         * in GRE header. It makes impossible maintaining even soft
         * state for keyed
         * GRE tunnels with enabled checksum. Tell them "thank you".
         *
         * Well, I wonder, rfc1812 was written by Cisco employee,
         * what the hell these idiots break standards established
         * by themselves???
         */

	const struct iphdr *iph = (struct iphdr *)skb->data;
	const int type = icmp_hdr(skb)->type;
	const int code = icmp_hdr(skb)->code;
	struct tnl_ptk_info tpi;
	bool csum_err = false;

	if (gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP),
			     iph->ihl * 4) < 0) {
		if (!csum_err)		/* ignore csum errors. */
			return;
	}

	if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
		ipv4_update_pmtu(skb, dev_net(skb->dev), info,
				 skb->dev->ifindex, 0, IPPROTO_GRE, 0);
		return;
	}
	if (type == ICMP_REDIRECT) {
		ipv4_redirect(skb, dev_net(skb->dev), skb->dev->ifindex, 0,
			      IPPROTO_GRE, 0);
		return;
	}

	ipgre_err(skb, info, &tpi);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
148
83.15%
1
16.67%
eric dumazet
eric dumazet
21
11.80%
1
16.67%
haishuang yan
haishuang yan
5
2.81%
1
16.67%
jiri benc
jiri benc
2
1.12%
1
16.67%
tom herbert
tom herbert
1
0.56%
1
16.67%
timo teras
timo teras
1
0.56%
1
16.67%
Total
178
100.00%
6
100.00%



static __be64 key_to_tunnel_id(__be32 key)
{
#ifdef __BIG_ENDIAN
	return (__force __be64)((__force u32)key);
#else
	return (__force __be64)((__force u64)key << 32);
#endif
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
44
100.00%
1
100.00%
Total
44
100.00%
1
100.00%

/* Returns the least-significant 32 bits of a __be64. */


static __be32 tunnel_id_to_key(__be64 x)
{
#ifdef __BIG_ENDIAN
	return (__force __be32)x;
#else
	return (__force __be32)((__force u64)x >> 32);
#endif
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
38
100.00%
1
100.00%
Total
38
100.00%
1
100.00%



static int __ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
		       struct ip_tunnel_net *itn, int hdr_len, bool raw_proto)
{
	struct metadata_dst *tun_dst = NULL;
	const struct iphdr *iph;
	struct ip_tunnel *tunnel;

	iph = ip_hdr(skb);
	tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
				  iph->saddr, iph->daddr, tpi->key);

	if (tunnel) {
		if (__iptunnel_pull_header(skb, hdr_len, tpi->proto,
					   raw_proto, false) < 0)
			goto drop;

		if (tunnel->dev->type != ARPHRD_NONE)
			skb_pop_mac_header(skb);
		else
			skb_reset_mac_header(skb);
		if (tunnel->collect_md) {
			__be16 flags;
			__be64 tun_id;

			flags = tpi->flags & (TUNNEL_CSUM | TUNNEL_KEY);
			tun_id = key_to_tunnel_id(tpi->key);
			tun_dst = ip_tun_rx_dst(skb, flags, tun_id, 0);
			if (!tun_dst)
				return PACKET_REJECT;
		}

		ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error);
		return PACKET_RCVD;
	}
	return PACKET_NEXT;

drop:
	kfree_skb(skb);
	return PACKET_RCVD;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
135
62.50%
4
30.77%
jiri benc
jiri benc
59
27.31%
3
23.08%
timo teras
timo teras
11
5.09%
3
23.08%
herbert xu
herbert xu
5
2.31%
1
7.69%
pre-git
pre-git
4
1.85%
1
7.69%
david s. miller
david s. miller
2
0.93%
1
7.69%
Total
216
100.00%
13
100.00%



static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
		     int hdr_len)
{
	struct net *net = dev_net(skb->dev);
	struct ip_tunnel_net *itn;
	int res;

	if (tpi->proto == htons(ETH_P_TEB))
		itn = net_generic(net, gre_tap_net_id);
	else
		itn = net_generic(net, ipgre_net_id);

	res = __ipgre_rcv(skb, tpi, itn, hdr_len, false);
	if (res == PACKET_NEXT && tpi->proto == htons(ETH_P_TEB)) {
		/* ipgre tunnels in collect metadata mode should receive
                 * also ETH_P_TEB traffic.
                 */
		itn = net_generic(net, ipgre_net_id);
		res = __ipgre_rcv(skb, tpi, itn, hdr_len, true);
	}
	return res;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jiri benc
jiri benc
130
100.00%
1
100.00%
Total
130
100.00%
1
100.00%



static int gre_rcv(struct sk_buff *skb)
{
	struct tnl_ptk_info tpi;
	bool csum_err = false;
	int hdr_len;

#ifdef CONFIG_NET_IPGRE_BROADCAST
	if (ipv4_is_multicast(ip_hdr(skb)->daddr)) {
		/* Looped back packet, drop it! */
		if (rt_is_output_route(skb_rtable(skb)))
			goto drop;
	}
#endif

	hdr_len = gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP), 0);
	if (hdr_len < 0)
		goto drop;

	if (ipgre_rcv(skb, &tpi, hdr_len) == PACKET_RCVD)
		return 0;

	icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
drop:
	kfree_skb(skb);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
104
84.55%
1
16.67%
jiri benc
jiri benc
8
6.50%
2
33.33%
haishuang yan
haishuang yan
5
4.07%
1
16.67%
tom herbert
tom herbert
4
3.25%
1
16.67%
eric dumazet
eric dumazet
2
1.63%
1
16.67%
Total
123
100.00%
6
100.00%



static void __gre_xmit(struct sk_buff *skb, struct net_device *dev,
		       const struct iphdr *tnl_params,
		       __be16 proto)
{
	struct ip_tunnel *tunnel = netdev_priv(dev);

	if (tunnel->parms.o_flags & TUNNEL_SEQ)
		tunnel->o_seqno++;

	/* Push GRE header. */
	gre_build_header(skb, tunnel->tun_hlen,
			 tunnel->parms.o_flags, proto, tunnel->parms.o_key,
			 htonl(tunnel->o_seqno));

	ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
93
98.94%
1
50.00%
tom herbert
tom herbert
1
1.06%
1
50.00%
Total
94
100.00%
2
100.00%



static int gre_handle_offloads(struct sk_buff *skb, bool csum)
{
	return iptunnel_handle_offloads(skb, csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
25
96.15%
1
50.00%
alexander duyck
alexander duyck
1
3.85%
1
50.00%
Total
26
100.00%
2
100.00%



static struct rtable *gre_get_rt(struct sk_buff *skb,
				 struct net_device *dev,
				 struct flowi4 *fl,
				 const struct ip_tunnel_key *key)
{
	struct net *net = dev_net(dev);

	memset(fl, 0, sizeof(*fl));
	fl->daddr = key->u.ipv4.dst;
	fl->saddr = key->u.ipv4.src;
	fl->flowi4_tos = RT_TOS(key->tos);
	fl->flowi4_mark = skb->mark;
	fl->flowi4_proto = IPPROTO_GRE;

	return ip_route_output_key(net, fl);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
109
100.00%
2
100.00%
Total
109
100.00%
2
100.00%



static void gre_fb_xmit(struct sk_buff *skb, struct net_device *dev,
			__be16 proto)
{
	struct ip_tunnel_info *tun_info;
	const struct ip_tunnel_key *key;
	struct rtable *rt = NULL;
	struct flowi4 fl;
	int min_headroom;
	int tunnel_hlen;
	__be16 df, flags;
	bool use_cache;
	int err;

	tun_info = skb_tunnel_info(skb);
	if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
		     ip_tunnel_info_af(tun_info) != AF_INET))
		goto err_free_skb;

	key = &tun_info->key;
	use_cache = ip_tunnel_dst_cache_usable(skb, tun_info);
	if (use_cache)
		rt = dst_cache_get_ip4(&tun_info->dst_cache, &fl.saddr);
	if (!rt) {
		rt = gre_get_rt(skb, dev, &fl, key);
		if (IS_ERR(rt))
				goto err_free_skb;
		if (use_cache)
			dst_cache_set_ip4(&tun_info->dst_cache, &rt->dst,
					  fl.saddr);
	}

	tunnel_hlen = gre_calc_hlen(key->tun_flags);

	min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len
			+ tunnel_hlen + sizeof(struct iphdr);
	if (skb_headroom(skb) < min_headroom || skb_header_cloned(skb)) {
		int head_delta = SKB_DATA_ALIGN(min_headroom -
						skb_headroom(skb) +
						16);
		err = pskb_expand_head(skb, max_t(int, head_delta, 0),
				       0, GFP_ATOMIC);
		if (unlikely(err))
			goto err_free_rt;
	}

	/* Push Tunnel header. */
	if (gre_handle_offloads(skb, !!(tun_info->key.tun_flags & TUNNEL_CSUM)))
		goto err_free_rt;

	flags = tun_info->key.tun_flags & (TUNNEL_CSUM | TUNNEL_KEY);
	gre_build_header(skb, tunnel_hlen, flags, proto,
			 tunnel_id_to_key(tun_info->key.tun_id), 0);

	df = key->tun_flags & TUNNEL_DONT_FRAGMENT ?  htons(IP_DF) : 0;

	iptunnel_xmit(skb->sk, rt, skb, fl.saddr, key->u.ipv4.dst, IPPROTO_GRE,
		      key->tos, key->ttl, df, false);
	return;

err_free_rt:
	ip_rt_put(rt);
err_free_skb:
	kfree_skb(skb);
	dev->stats.tx_dropped++;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
306
75.18%
3
16.67%
paolo abeni
paolo abeni
43
10.57%
1
5.56%
daniel borkmann
daniel borkmann
23
5.65%
1
5.56%
jiri benc
jiri benc
22
5.41%
5
27.78%
tom herbert
tom herbert
5
1.23%
3
16.67%
pavel emelianov
pavel emelianov
3
0.74%
1
5.56%
alexander duyck
alexander duyck
2
0.49%
1
5.56%
herbert xu
herbert xu
1
0.25%
1
5.56%
nicolas dichtel
nicolas dichtel
1
0.25%
1
5.56%
stephen hemminger
stephen hemminger
1
0.25%
1
5.56%
Total
407
100.00%
18
100.00%



static int gre_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
{
	struct ip_tunnel_info *info = skb_tunnel_info(skb);
	struct rtable *rt;
	struct flowi4 fl4;

	if (ip_tunnel_info_af(info) != AF_INET)
		return -EINVAL;

	rt = gre_get_rt(skb, dev, &fl4, &info->key);
	if (IS_ERR(rt))
		return PTR_ERR(rt);

	ip_rt_put(rt);
	info->key.u.ipv4.src = fl4.saddr;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
100
100.00%
1
100.00%
Total
100
100.00%
1
100.00%



static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
			      struct net_device *dev)
{
	struct ip_tunnel *tunnel = netdev_priv(dev);
	const struct iphdr *tnl_params;

	if (tunnel->collect_md) {
		gre_fb_xmit(skb, dev, skb->protocol);
		return NETDEV_TX_OK;
	}

	if (dev->header_ops) {
		/* Need space for new headers */
		if (skb_cow_head(skb, dev->needed_headroom -
				      (tunnel->hlen + sizeof(struct iphdr))))
			goto free_skb;

		tnl_params = (const struct iphdr *)skb->data;

		/* Pull skb since ip_tunnel_xmit() needs skb->data pointing
                 * to gre header.
                 */
		skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
		skb_reset_mac_header(skb);
	} else {
		if (skb_cow_head(skb, dev->needed_headroom))
			goto free_skb;

		tnl_params = &tunnel->parms.iph;
	}

	if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
		goto free_skb;

	__gre_xmit(skb, dev, tnl_params, skb->protocol);
	return NETDEV_TX_OK;

free_skb:
	kfree_skb(skb);
	dev->stats.tx_dropped++;
	return NETDEV_TX_OK;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
142
69.95%
2
14.29%
timo teras
timo teras
24
11.82%
1
7.14%
pre-git
pre-git
13
6.40%
3
21.43%
willem de bruijn
willem de bruijn
8
3.94%
1
7.14%
pavel emelianov
pavel emelianov
4
1.97%
2
14.29%
jiri benc
jiri benc
4
1.97%
1
7.14%
alexander duyck
alexander duyck
3
1.48%
1
7.14%
patrick mchardy
patrick mchardy
3
1.48%
1
7.14%
eric dumazet
eric dumazet
1
0.49%
1
7.14%
paul e. erkkila
paul e. erkkila
1
0.49%
1
7.14%
Total
203
100.00%
14
100.00%



static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
				struct net_device *dev)
{
	struct ip_tunnel *tunnel = netdev_priv(dev);

	if (tunnel->collect_md) {
		gre_fb_xmit(skb, dev, htons(ETH_P_TEB));
		return NETDEV_TX_OK;
	}

	if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
		goto free_skb;

	if (skb_cow_head(skb, dev->needed_headroom))
		goto free_skb;

	__gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
	return NETDEV_TX_OK;

free_skb:
	kfree_skb(skb);
	dev->stats.tx_dropped++;
	return NETDEV_TX_OK;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
89
71.77%
3
25.00%
pre-git
pre-git
15
12.10%
4
33.33%
pavel emelianov
pavel emelianov
9
7.26%
1
8.33%
jiri benc
jiri benc
5
4.03%
1
8.33%
alexander duyck
alexander duyck
3
2.42%
1
8.33%
patrick mchardy
patrick mchardy
2
1.61%
1
8.33%
eric dumazet
eric dumazet
1
0.81%
1
8.33%
Total
124
100.00%
12
100.00%



static int ipgre_tunnel_ioctl(struct net_device *dev,
			      struct ifreq *ifr, int cmd)
{
	int err;
	struct ip_tunnel_parm p;

	if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
		return -EFAULT;
	if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
		if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
		    p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
		    ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
			return -EINVAL;
	}
	p.i_flags = gre_flags_to_tnl_flags(p.i_flags);
	p.o_flags = gre_flags_to_tnl_flags(p.o_flags);

	err = ip_tunnel_ioctl(dev, &p, cmd);
	if (err)
		return err;

	p.i_flags = gre_tnl_flags_to_gre_flags(p.i_flags);
	p.o_flags = gre_tnl_flags_to_gre_flags(p.o_flags);

	if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
		return -EFAULT;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
130
61.32%
1
10.00%
pre-git
pre-git
37
17.45%
1
10.00%
eric dumazet
eric dumazet
15
7.08%
2
20.00%
americo wang
americo wang
11
5.19%
1
10.00%
stephen hemminger
stephen hemminger
10
4.72%
1
10.00%
ville nuorvala
ville nuorvala
4
1.89%
1
10.00%
tom herbert
tom herbert
2
0.94%
1
10.00%
arnaldo carvalho de melo
arnaldo carvalho de melo
2
0.94%
1
10.00%
adrian bunk
adrian bunk
1
0.47%
1
10.00%
Total
212
100.00%
10
100.00%

/* Nice toy. Unfortunately, useless in real life :-)
   It allows to construct virtual multiprotocol broadcast "LAN"
   over the Internet, provided multicast routing is tuned.


   I have no idea was this bicycle invented before me,
   so that I had to set ARPHRD_IPGRE to a random value.
   I have an impression, that Cisco could make something similar,
   but this feature is apparently missing in IOS<=11.2(8).

   I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
   with broadcast 224.66.66.66. If you have access to mbone, play with me :-)

   ping -t 255 224.66.66.66

   If nobody answers, mbone does not work.

   ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
   ip addr add 10.66.66.<somewhat>/24 dev Universe
   ifconfig Universe up
   ifconfig Universe add fe80::<Your_real_addr>/10
   ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
   ftp 10.66.66.66
   ...
   ftp fec0:6666:6666::193.233.7.65
   ...
 */


static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
			unsigned short type,
			const void *daddr, const void *saddr, unsigned int len)
{
	struct ip_tunnel *t = netdev_priv(dev);
	struct iphdr *iph;
	struct gre_base_hdr *greh;

	iph = (struct iphdr *)skb_push(skb, t->hlen + sizeof(*iph));
	greh = (struct gre_base_hdr *)(iph+1);
	greh->flags = gre_tnl_flags_to_gre_flags(t->parms.o_flags);
	greh->protocol = htons(type);

	memcpy(iph, &t->parms.iph, sizeof(struct iphdr));

	/* Set the source hardware address. */
	if (saddr)
		memcpy(&iph->saddr, saddr, 4);
	if (daddr)
		memcpy(&iph->daddr, daddr, 4);
	if (iph->daddr)
		return t->hlen + sizeof(*iph);

	return -(t->hlen + sizeof(*iph));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
112
58.03%
1
5.56%
pavel emelianov
pavel emelianov
29
15.03%
3
16.67%
pre-git
pre-git
24
12.44%
3
16.67%
eric dumazet
eric dumazet
11
5.70%
3
16.67%
timo teras
timo teras
6
3.11%
1
5.56%
ville nuorvala
ville nuorvala
3
1.55%
1
5.56%
patrick mchardy
patrick mchardy
3
1.55%
1
5.56%
stephen hemminger
stephen hemminger
2
1.04%
2
11.11%
adrian bunk
adrian bunk
1
0.52%
1
5.56%
tom herbert
tom herbert
1
0.52%
1
5.56%
alexey dobriyan
alexey dobriyan
1
0.52%
1
5.56%
Total
193
100.00%
18
100.00%



static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
{
	const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
	memcpy(haddr, &iph->saddr, 4);
	return 4;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
33
67.35%
1
25.00%
pavel emelianov
pavel emelianov
14
28.57%
2
50.00%
eric dumazet
eric dumazet
2
4.08%
1
25.00%
Total
49
100.00%
4
100.00%


static const struct header_ops ipgre_header_ops = {
	.create	= ipgre_header,
	.parse	= ipgre_header_parse,
};

#ifdef CONFIG_NET_IPGRE_BROADCAST


static int ipgre_open(struct net_device *dev)
{
	struct ip_tunnel *t = netdev_priv(dev);

	if (ipv4_is_multicast(t->parms.iph.daddr)) {
		struct flowi4 fl4;
		struct rtable *rt;

		rt = ip_route_output_gre(t->net, &fl4,
					 t->parms.iph.daddr,
					 t->parms.iph.saddr,
					 t->parms.o_key,
					 RT_TOS(t->parms.iph.tos),
					 t->parms.link);
		if (IS_ERR(rt))
			return -EADDRNOTAVAIL;
		dev = rt->dst.dev;
		ip_rt_put(rt);
		if (!__in_dev_get_rtnl(dev))
			return -EADDRNOTAVAIL;
		t->mlink = dev->ifindex;
		ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
124
77.99%
1
9.09%
herbert xu
herbert xu
9
5.66%
1
9.09%
pavel emelianov
pavel emelianov
9
5.66%
2
18.18%
david s. miller
david s. miller
8
5.03%
2
18.18%
pre-git
pre-git
3
1.89%
1
9.09%
nicolas dichtel
nicolas dichtel
3
1.89%
1
9.09%
ian morris
ian morris
1
0.63%
1
9.09%
al viro
al viro
1
0.63%
1
9.09%
stephen hemminger
stephen hemminger
1
0.63%
1
9.09%
Total
159
100.00%
11
100.00%



static int ipgre_close(struct net_device *dev)
{
	struct ip_tunnel *t = netdev_priv(dev);

	if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
		struct in_device *in_dev;
		in_dev = inetdev_by_index(t->net, t->mlink);
		if (in_dev)
			ip_mc_dec_group(in_dev, t->parms.iph.daddr);
	}
	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
53
67.95%
1
33.33%
herbert xu
herbert xu
22
28.21%
1
33.33%
nicolas dichtel
nicolas dichtel
3
3.85%
1
33.33%
Total
78
100.00%
3
100.00%

#endif


static const struct net_device_ops ipgre_netdev_ops = {
	.ndo_init		= ipgre_tunnel_init,
	.ndo_uninit		= ip_tunnel_uninit,
#ifdef CONFIG_NET_IPGRE_BROADCAST
	.ndo_open		= ipgre_open,
	.ndo_stop		= ipgre_close,
#endif
	.ndo_start_xmit		= ipgre_xmit,
	.ndo_do_ioctl		= ipgre_tunnel_ioctl,
	.ndo_change_mtu		= ip_tunnel_change_mtu,
	.ndo_get_stats64	= ip_tunnel_get_stats64,
	.ndo_get_iflink		= ip_tunnel_get_iflink,
};


#define GRE_FEATURES (NETIF_F_SG |           \
                      NETIF_F_FRAGLIST |        \
                      NETIF_F_HIGHDMA |         \
                      NETIF_F_HW_CSUM)



static void ipgre_tunnel_setup(struct net_device *dev)
{
	dev->netdev_ops		= &ipgre_netdev_ops;
	dev->type		= ARPHRD_IPGRE;
	ip_tunnel_setup(dev, ipgre_net_id);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
21
67.74%
1
33.33%
nicolas dichtel
nicolas dichtel
6
19.35%
1
33.33%
herbert xu
herbert xu
4
12.90%
1
33.33%
Total
31
100.00%
3
100.00%



static void __gre_tunnel_init(struct net_device *dev)
{
	struct ip_tunnel *tunnel;
	int t_hlen;

	tunnel = netdev_priv(dev);
	tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
	tunnel->parms.iph.protocol = IPPROTO_GRE;

	tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;

	t_hlen = tunnel->hlen + sizeof(struct iphdr);

	dev->needed_headroom	= LL_MAX_HEADER + t_hlen + 4;
	dev->mtu		= ETH_DATA_LEN - t_hlen - 4;

	dev->features		|= GRE_FEATURES;
	dev->hw_features	|= GRE_FEATURES;

	if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
		/* TCP offload with GRE SEQ is not supported, nor
                 * can we support 2 levels of outer headers requiring
                 * an update.
                 */
		if (!(tunnel->parms.o_flags & TUNNEL_CSUM) ||
		    (tunnel->encap.type == TUNNEL_ENCAP_NONE)) {
			dev->features    |= NETIF_F_GSO_SOFTWARE;
			dev->hw_features |= NETIF_F_GSO_SOFTWARE;
		}

		/* Can use a lockless transmit, unless we generate
                 * output sequences
                 */
		dev->features |= NETIF_F_LLTX;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
67
40.61%
1
11.11%
herbert xu
herbert xu
30
18.18%
1
11.11%
tom herbert
tom herbert
29
17.58%
2
22.22%
alexander duyck
alexander duyck
26
15.76%
1
11.11%
pre-git
pre-git
8
4.85%
1
11.11%
pavel emelianov
pavel emelianov
3
1.82%
1
11.11%
adrian bunk
adrian bunk
1
0.61%
1
11.11%
david s. miller
david s. miller
1
0.61%
1
11.11%
Total
165
100.00%
9
100.00%



static int ipgre_tunnel_init(struct net_device *dev)
{
	struct ip_tunnel *tunnel = netdev_priv(dev);
	struct iphdr *iph = &tunnel->parms.iph;

	__gre_tunnel_init(dev);

	memcpy(dev->dev_addr, &iph->saddr, 4);
	memcpy(dev->broadcast, &iph->daddr, 4);

	dev->flags		= IFF_NOARP;
	netif_keep_dst(dev);
	dev->addr_len		= 4;

	if (iph->daddr && !tunnel->collect_md) {
#ifdef CONFIG_NET_IPGRE_BROADCAST
		if (ipv4_is_multicast(iph->daddr)) {
			if (!iph->saddr)
				return -EINVAL;
			dev->flags = IFF_BROADCAST;
			dev->header_ops = &ipgre_header_ops;
		}
#endif
	} else if (!tunnel->collect_md) {
		dev->header_ops = &ipgre_header_ops;
	}

	return ip_tunnel_init(dev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
94
59.12%
1
20.00%
herbert xu
herbert xu
34
21.38%
1
20.00%
eric dumazet
eric dumazet
16
10.06%
2
40.00%
jiri benc
jiri benc
15
9.43%
1
20.00%
Total
159
100.00%
5
100.00%


static const struct gre_protocol ipgre_protocol = {
	.handler     = gre_rcv,
	.err_handler = gre_err,
};



static int __net_init ipgre_init_net(struct net *net)
{
	return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
25
100.00%
1
100.00%
Total
25
100.00%
1
100.00%



static void __net_exit ipgre_exit_net(struct net *net)
{
	struct ip_tunnel_net *itn = net_generic(net, ipgre_net_id);
	ip_tunnel_delete_net(itn, &ipgre_link_ops);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
29
90.62%
1
50.00%
nicolas dichtel
nicolas dichtel
3
9.38%
1
50.00%
Total
32
100.00%
2
100.00%


static struct pernet_operations ipgre_net_ops = {
	.init = ipgre_init_net,
	.exit = ipgre_exit_net,
	.id   = &ipgre_net_id,
	.size = sizeof(struct ip_tunnel_net),
};



static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
{
	__be16 flags;

	if (!data)
		return 0;

	flags = 0;
	if (data[IFLA_GRE_IFLAGS])
		flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
	if (data[IFLA_GRE_OFLAGS])
		flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
	if (flags & (GRE_VERSION|GRE_ROUTING))
		return -EINVAL;

	if (data[IFLA_GRE_COLLECT_METADATA] &&
	    data[IFLA_GRE_ENCAP_TYPE] &&
	    nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]) != TUNNEL_ENCAP_NONE)
		return -EINVAL;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
74
67.27%
2
50.00%
jiri benc
jiri benc
26
23.64%
1
25.00%
herbert xu
herbert xu
10
9.09%
1
25.00%
Total
110
100.00%
4
100.00%



static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
{
	__be32 daddr;

	if (tb[IFLA_ADDRESS]) {
		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
			return -EINVAL;
		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
			return -EADDRNOTAVAIL;
	}

	if (!data)
		goto out;

	if (data[IFLA_GRE_REMOTE]) {
		memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
		if (!daddr)
			return -EINVAL;
	}

out:
	return ipgre_tunnel_validate(tb, data);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
65
56.03%
1
25.00%
herbert xu
herbert xu
48
41.38%
2
50.00%
eric dumazet
eric dumazet
3
2.59%
1
25.00%
Total
116
100.00%
4
100.00%



static int ipgre_netlink_parms(struct net_device *dev,
				struct nlattr *data[],
				struct nlattr *tb[],
				struct ip_tunnel_parm *parms)
{
	struct ip_tunnel *t = netdev_priv(dev);

	memset(parms, 0, sizeof(*parms));

	parms->iph.protocol = IPPROTO_GRE;

	if (!data)
		return 0;

	if (data[IFLA_GRE_LINK])
		parms->link = nla_get_u32(data[IFLA_GRE_LINK]);

	if (data[IFLA_GRE_IFLAGS])
		parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));

	if (data[IFLA_GRE_OFLAGS])
		parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));

	if (data[IFLA_GRE_IKEY])
		parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);

	if (data[IFLA_GRE_OKEY])
		parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);

	if (data[IFLA_GRE_LOCAL])
		parms->iph.saddr = nla_get_in_addr(data[IFLA_GRE_LOCAL]);

	if (data[IFLA_GRE_REMOTE])
		parms->iph.daddr = nla_get_in_addr(data[IFLA_GRE_REMOTE]);

	if (data[IFLA_GRE_TTL])
		parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);

	if (data[IFLA_GRE_TOS])
		parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);

	if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC])) {
		if (t->ignore_df)
			return -EINVAL;
		parms->iph.frag_off = htons(IP_DF);
	}

	if (data[IFLA_GRE_COLLECT_METADATA]) {
		t->collect_md = true;
		if (dev->type == ARPHRD_IPGRE)
			dev->type = ARPHRD_NONE;
	}

	if (data[IFLA_GRE_IGNORE_DF]) {
		if (nla_get_u8(data[IFLA_GRE_IGNORE_DF])
		  && (parms->iph.frag_off & htons(IP_DF)))
			return -EINVAL;
		t->ignore_df = !!nla_get_u8(data[IFLA_GRE_IGNORE_DF]);
	}

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
198
53.08%
2
28.57%
herbert xu
herbert xu
80
21.45%
2
28.57%
philip prindeville
philip prindeville
79
21.18%
1
14.29%
jiri benc
jiri benc
16
4.29%
2
28.57%
Total
373
100.00%
7
100.00%

/* This function returns true when ENCAP attributes are present in the nl msg */


static bool ipgre_netlink_encap_parms(struct nlattr *data[],
				      struct ip_tunnel_encap *ipencap)
{
	bool ret = false;

	memset(ipencap, 0, sizeof(*ipencap));

	if (!data)
		return ret;

	if (data[IFLA_GRE_ENCAP_TYPE]) {
		ret = true;
		ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]);
	}

	if (data[IFLA_GRE_ENCAP_FLAGS]) {
		ret = true;
		ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]);
	}

	if (data[IFLA_GRE_ENCAP_SPORT]) {
		ret = true;
		ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]);
	}

	if (data[IFLA_GRE_ENCAP_DPORT]) {
		ret = true;
		ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]);
	}

	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
tom herbert
tom herbert
144
98.63%
1
50.00%
sabrina dubroca
sabrina dubroca
2
1.37%
1
50.00%
Total
146
100.00%
2
100.00%



static int gre_tap_init(struct net_device *dev)
{
	__gre_tunnel_init(dev);
	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;

	return ip_tunnel_init(dev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
15
53.57%
1
33.33%
herbert xu
herbert xu
7
25.00%
1
33.33%
stephen hemminger
stephen hemminger
6
21.43%
1
33.33%
Total
28
100.00%
3
100.00%


static const struct net_device_ops gre_tap_netdev_ops = {
	.ndo_init		= gre_tap_init,
	.ndo_uninit		= ip_tunnel_uninit,
	.ndo_start_xmit		= gre_tap_xmit,
	.ndo_set_mac_address 	= eth_mac_addr,
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_change_mtu		= ip_tunnel_change_mtu,
	.ndo_get_stats64	= ip_tunnel_get_stats64,
	.ndo_get_iflink		= ip_tunnel_get_iflink,
	.ndo_fill_metadata_dst	= gre_fill_metadata_dst,
};



static void ipgre_tap_setup(struct net_device *dev)
{
	ether_setup(dev);
	dev->netdev_ops	= &gre_tap_netdev_ops;
	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
	dev->priv_flags	|= IFF_LIVE_ADDR_CHANGE;
	ip_tunnel_setup(dev, gre_tap_net_id);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
20
46.51%
1
25.00%
herbert xu
herbert xu
10
23.26%
1
25.00%
jiri benc
jiri benc
7
16.28%
1
25.00%
stephen hemminger
stephen hemminger
6
13.95%
1
25.00%
Total
43
100.00%
4
100.00%



static int ipgre_newlink(struct net *src_net, struct net_device *dev,
			 struct nlattr *tb[], struct nlattr *data[])
{
	struct ip_tunnel_parm p;
	struct ip_tunnel_encap ipencap;
	int err;

	if (ipgre_netlink_encap_parms(data, &ipencap)) {
		struct ip_tunnel *t = netdev_priv(dev);
		err = ip_tunnel_encap_setup(t, &ipencap);

		if (err < 0)
			return err;
	}

	err = ipgre_netlink_parms(dev, data, tb, &p);
	if (err < 0)
		return err;
	return ip_tunnel_newlink(dev, tb, &p);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
52
45.61%
2
40.00%
tom herbert
tom herbert
43
37.72%
1
20.00%
philip prindeville
philip prindeville
16
14.04%
1
20.00%
herbert xu
herbert xu
3
2.63%
1
20.00%
Total
114
100.00%
5
100.00%



static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
			    struct nlattr *data[])
{
	struct ip_tunnel_parm p;
	struct ip_tunnel_encap ipencap;
	int err;

	if (ipgre_netlink_encap_parms(data, &ipencap)) {
		struct ip_tunnel *t = netdev_priv(dev);
		err = ip_tunnel_encap_setup(t, &ipencap);

		if (err < 0)
			return err;
	}

	err = ipgre_netlink_parms(dev, data, tb, &p);
	if (err < 0)
		return err;
	return ip_tunnel_changelink(dev, tb, &p);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
47
43.12%
2
40.00%
tom herbert
tom herbert
43
39.45%
1
20.00%
philip prindeville
philip prindeville
16
14.68%
1
20.00%
herbert xu
herbert xu
3
2.75%
1
20.00%
Total
109
100.00%
5
100.00%



static size_t ipgre_get_size(const struct net_device *dev)
{
	return
		/* IFLA_GRE_LINK */
		nla_total_size(4) +
		/* IFLA_GRE_IFLAGS */
		nla_total_size(2) +
		/* IFLA_GRE_OFLAGS */
		nla_total_size(2) +
		/* IFLA_GRE_IKEY */
		nla_total_size(4) +
		/* IFLA_GRE_OKEY */
		nla_total_size(4) +
		/* IFLA_GRE_LOCAL */
		nla_total_size(4) +
		/* IFLA_GRE_REMOTE */
		nla_total_size(4) +
		/* IFLA_GRE_TTL */
		nla_total_size(1) +
		/* IFLA_GRE_TOS */
		nla_total_size(1) +
		/* IFLA_GRE_PMTUDISC */
		nla_total_size(1) +
		/* IFLA_GRE_ENCAP_TYPE */
		nla_total_size(2) +
		/* IFLA_GRE_ENCAP_FLAGS */
		nla_total_size(2) +
		/* IFLA_GRE_ENCAP_SPORT */
		nla_total_size(2) +
		/* IFLA_GRE_ENCAP_DPORT */
		nla_total_size(2) +
		/* IFLA_GRE_COLLECT_METADATA */
		nla_total_size(0) +
		/* IFLA_GRE_IGNORE_DF */
		nla_total_size(1) +
		0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
herbert xu
herbert xu
75
67.57%
1
25.00%
tom herbert
tom herbert
24
21.62%
1
25.00%
pravin b shelar
pravin b shelar
6
5.41%
1
25.00%
philip prindeville
philip prindeville
6
5.41%
1
25.00%
Total
111
100.00%
4
100.00%



static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
{
	struct ip_tunnel *t = netdev_priv(dev);
	struct ip_tunnel_parm *p = &t->parms;

	if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
	    nla_put_be16(skb, IFLA_GRE_IFLAGS,
			 gre_tnl_flags_to_gre_flags(p->i_flags)) ||
	    nla_put_be16(skb, IFLA_GRE_OFLAGS,
			 gre_tnl_flags_to_gre_flags(p->o_flags)) ||
	    nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
	    nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
	    nla_put_in_addr(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
	    nla_put_in_addr(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
	    nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
	    nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
	    nla_put_u8(skb, IFLA_GRE_PMTUDISC,
		       !!(p->iph.frag_off & htons(IP_DF))))
		goto nla_put_failure;

	if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE,
			t->encap.type) ||
	    nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT,
			 t->encap.sport) ||
	    nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT,
			 t->encap.dport) ||
	    nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS,
			t->encap.flags))
		goto nla_put_failure;

	if (nla_put_u8(skb, IFLA_GRE_IGNORE_DF, t->ignore_df))
		goto nla_put_failure;

	if (t->collect_md) {
		if (nla_put_flag(skb, IFLA_GRE_COLLECT_METADATA))
			goto nla_put_failure;
	}

	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
herbert xu
herbert xu
151
54.12%
1
9.09%
tom herbert
tom herbert
57
20.43%
3
27.27%
pravin b shelar
pravin b shelar
24
8.60%
2
18.18%
david s. miller
david s. miller
23
8.24%
1
9.09%
philip prindeville
philip prindeville
16
5.73%
1
9.09%
patrick mchardy
patrick mchardy
4
1.43%
1
9.09%
jiri benc
jiri benc
2
0.72%
1
9.09%
sabrina dubroca
sabrina dubroca
2
0.72%
1
9.09%
Total
279
100.00%
11
100.00%


static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
	[IFLA_GRE_LINK]		= { .type = NLA_U32 },
	[IFLA_GRE_IFLAGS]	= { .type = NLA_U16 },
	[IFLA_GRE_OFLAGS]	= { .type = NLA_U16 },
	[IFLA_GRE_IKEY]		= { .type = NLA_U32 },
	[IFLA_GRE_OKEY]		= { .type = NLA_U32 },
	[IFLA_GRE_LOCAL]	= { .len = FIELD_SIZEOF(struct iphdr, saddr) },
	[IFLA_GRE_REMOTE]	= { .len = FIELD_SIZEOF(struct iphdr, daddr) },
	[IFLA_GRE_TTL]		= { .type = NLA_U8 },
	[IFLA_GRE_TOS]		= { .type = NLA_U8 },
	[IFLA_GRE_PMTUDISC]	= { .type = NLA_U8 },
	[IFLA_GRE_ENCAP_TYPE]	= { .type = NLA_U16 },
	[IFLA_GRE_ENCAP_FLAGS]	= { .type = NLA_U16 },
	[IFLA_GRE_ENCAP_SPORT]	= { .type = NLA_U16 },
	[IFLA_GRE_ENCAP_DPORT]	= { .type = NLA_U16 },
	[IFLA_GRE_COLLECT_METADATA]	= { .type = NLA_FLAG },
	[IFLA_GRE_IGNORE_DF]	= { .type = NLA_U8 },
};


static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
	.kind		= "gre",
	.maxtype	= IFLA_GRE_MAX,
	.policy		= ipgre_policy,
	.priv_size	= sizeof(struct ip_tunnel),
	.setup		= ipgre_tunnel_setup,
	.validate	= ipgre_tunnel_validate,
	.newlink	= ipgre_newlink,
	.changelink	= ipgre_changelink,
	.dellink	= ip_tunnel_dellink,
	.get_size	= ipgre_get_size,
	.fill_info	= ipgre_fill_info,
	.get_link_net	= ip_tunnel_get_link_net,
};


static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
	.kind		= "gretap",
	.maxtype	= IFLA_GRE_MAX,
	.policy		= ipgre_policy,
	.priv_size	= sizeof(struct ip_tunnel),
	.setup		= ipgre_tap_setup,
	.validate	= ipgre_tap_validate,
	.newlink	= ipgre_newlink,
	.changelink	= ipgre_changelink,
	.dellink	= ip_tunnel_dellink,
	.get_size	= ipgre_get_size,
	.fill_info	= ipgre_fill_info,
	.get_link_net	= ip_tunnel_get_link_net,
};



struct net_device *gretap_fb_dev_create(struct net *net, const char *name,
					u8 name_assign_type)
{
	struct nlattr *tb[IFLA_MAX + 1];
	struct net_device *dev;
	LIST_HEAD(list_kill);
	struct ip_tunnel *t;
	int err;

	memset(&tb, 0, sizeof(tb));

	dev = rtnl_create_link(net, name, name_assign_type,
			       &ipgre_tap_ops, tb);
	if (IS_ERR(dev))
		return dev;

	/* Configure flow based GRE device. */
	t = netdev_priv(dev);
	t->collect_md = true;

	err = ipgre_newlink(net, dev, tb, NULL);
	if (err < 0) {
		free_netdev(dev);
		return ERR_PTR(err);
	}

	/* openvswitch users expect packet sizes to be unrestricted,
         * so set the largest MTU we can.
         */
	err = __ip_tunnel_change_mtu(dev, IP_MAX_MTU, false);
	if (err)
		goto out;

	err = rtnl_configure_link(dev, NULL);
	if (err < 0)
		goto out;

	return dev;
out:
	ip_tunnel_dellink(dev, &list_kill);
	unregister_netdevice_many(&list_kill);
	return ERR_PTR(err);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
130
66.67%
1
25.00%
nicolas dichtel
nicolas dichtel
46
23.59%
2
50.00%
david wragg
david wragg
19
9.74%
1
25.00%
Total
195
100.00%
4
100.00%


EXPORT_SYMBOL_GPL(gretap_fb_dev_create);



static int __net_init ipgre_tap_init_net(struct net *net)
{
	return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, "gretap0");
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
25
100.00%
2
100.00%
Total
25
100.00%
2
100.00%



static void __net_exit ipgre_tap_exit_net(struct net *net)
{
	struct ip_tunnel_net *itn = net_generic(net, gre_tap_net_id);
	ip_tunnel_delete_net(itn, &ipgre_tap_ops);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
29
90.62%
1
50.00%
nicolas dichtel
nicolas dichtel
3
9.38%
1
50.00%
Total
32
100.00%
2
100.00%


static struct pernet_operations ipgre_tap_net_ops = {
	.init = ipgre_tap_init_net,
	.exit = ipgre_tap_exit_net,
	.id   = &gre_tap_net_id,
	.size = sizeof(struct ip_tunnel_net),
};



static int __init ipgre_init(void)
{
	int err;

	pr_info("GRE over IPv4 tunneling driver\n");

	err = register_pernet_device(&ipgre_net_ops);
	if (err < 0)
		return err;

	err = register_pernet_device(&ipgre_tap_net_ops);
	if (err < 0)
		goto pnet_tap_faied;

	err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
	if (err < 0) {
		pr_info("%s: can't add protocol\n", __func__);
		goto add_proto_failed;
	}

	err = rtnl_link_register(&ipgre_link_ops);
	if (err < 0)
		goto rtnl_link_failed;

	err = rtnl_link_register(&ipgre_tap_ops);
	if (err < 0)
		goto tap_ops_failed;

	return 0;

tap_ops_failed:
	rtnl_link_unregister(&ipgre_link_ops);
rtnl_link_failed:
	gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
add_proto_failed:
	unregister_pernet_device(&ipgre_tap_net_ops);
pnet_tap_faied:
	unregister_pernet_device(&ipgre_net_ops);
	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
herbert xu
herbert xu
93
60.78%
2
33.33%
pravin b shelar
pravin b shelar
35
22.88%
2
33.33%
alexey dobriyan
alexey dobriyan
20
13.07%
1
16.67%
joe perches
joe perches
5
3.27%
1
16.67%
Total
153
100.00%
6
100.00%



static void __exit ipgre_fini(void)
{
	rtnl_link_unregister(&ipgre_tap_ops);
	rtnl_link_unregister(&ipgre_link_ops);
	gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
	unregister_pernet_device(&ipgre_tap_net_ops);
	unregister_pernet_device(&ipgre_net_ops);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
herbert xu
herbert xu
26
63.41%
2
40.00%
pravin b shelar
pravin b shelar
9
21.95%
2
40.00%
alexey dobriyan
alexey dobriyan
6
14.63%
1
20.00%
Total
41
100.00%
5
100.00%


module_init(ipgre_init);

module_exit(ipgre_fini);
MODULE_LICENSE("GPL");
MODULE_ALIAS_RTNL_LINK("gre");
MODULE_ALIAS_RTNL_LINK("gretap");
MODULE_ALIAS_NETDEV("gre0");
MODULE_ALIAS_NETDEV("gretap0");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
pravin b shelar
pravin b shelar
3117
53.07%
9
7.56%
herbert xu
herbert xu
921
15.68%
5
4.20%
tom herbert
tom herbert
399
6.79%
5
4.20%
jiri benc
jiri benc
296
5.04%
14
11.76%
pre-git
pre-git
213
3.63%
7
5.88%
eric dumazet
eric dumazet
153
2.61%
14
11.76%
philip prindeville
philip prindeville
144
2.45%
1
0.84%
pavel emelianov
pavel emelianov
90
1.53%
6
5.04%
nicolas dichtel
nicolas dichtel
85
1.45%
8
6.72%
stephen hemminger
stephen hemminger
84
1.43%
7
5.88%
timo teras
timo teras
72
1.23%
5
4.20%
paolo abeni
paolo abeni
43
0.73%
1
0.84%
alexander duyck
alexander duyck
35
0.60%
2
1.68%
david s. miller
david s. miller
34
0.58%
4
3.36%
patrick mchardy
patrick mchardy
28
0.48%
3
2.52%
alexey dobriyan
alexey dobriyan
27
0.46%
2
1.68%
daniel borkmann
daniel borkmann
23
0.39%
1
0.84%
david wragg
david wragg
19
0.32%
1
0.84%
joe perches
joe perches
13
0.22%
3
2.52%
americo wang
americo wang
12
0.20%
2
1.68%
haishuang yan
haishuang yan
10
0.17%
1
0.84%
willem de bruijn
willem de bruijn
8
0.14%
1
0.84%
duan jiong
duan jiong
7
0.12%
1
0.84%
ville nuorvala
ville nuorvala
7
0.12%
1
0.84%
eric w. biederman
eric w. biederman
4
0.07%
1
0.84%
sabrina dubroca
sabrina dubroca
4
0.07%
1
0.84%
dmitry kozlov
dmitry kozlov
3
0.05%
1
0.84%
adrian bunk
adrian bunk
3
0.05%
2
1.68%
tejun heo
tejun heo
3
0.05%
1
0.84%
randy dunlap
randy dunlap
3
0.05%
1
0.84%
kris katterjohn
kris katterjohn
3
0.05%
1
0.84%
linus torvalds
linus torvalds
2
0.03%
1
0.84%
arnaldo carvalho de melo
arnaldo carvalho de melo
2
0.03%
1
0.84%
ian morris
ian morris
2
0.03%
1
0.84%
paul e. erkkila
paul e. erkkila
1
0.02%
1
0.84%
al viro
al viro
1
0.02%
1
0.84%
vasiliy kulikov
vasiliy kulikov
1
0.02%
1
0.84%
hideaki yoshifuji
hideaki yoshifuji
1
0.02%
1
0.84%
Total
5873
100.00%
119
100.00%
  
Directory: net/ipv4

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.