ip_gre.c 45.9 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 *	Linux NET3:	GRE over IP protocol decoder.
L
Linus Torvalds 已提交
3 4 5 6 7 8 9 10 11 12
 *
 *	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.
 *
 */

13 14
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

15
#include <linux/capability.h>
L
Linus Torvalds 已提交
16 17 18
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
19
#include <linux/slab.h>
L
Linus Torvalds 已提交
20 21 22 23 24 25 26 27 28 29 30 31 32
#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/mroute.h>
#include <linux/init.h>
#include <linux/in6.h>
#include <linux/inetdevice.h>
#include <linux/igmp.h>
#include <linux/netfilter_ipv4.h>
33
#include <linux/etherdevice.h>
34
#include <linux/if_ether.h>
L
Linus Torvalds 已提交
35 36 37 38 39 40 41 42 43 44 45

#include <net/sock.h>
#include <net/ip.h>
#include <net/icmp.h>
#include <net/protocol.h>
#include <net/ipip.h>
#include <net/arp.h>
#include <net/checksum.h>
#include <net/dsfield.h>
#include <net/inet_ecn.h>
#include <net/xfrm.h>
46 47
#include <net/net_namespace.h>
#include <net/netns/generic.h>
H
Herbert Xu 已提交
48
#include <net/rtnetlink.h>
49
#include <net/gre.h>
L
Linus Torvalds 已提交
50

E
Eric Dumazet 已提交
51
#if IS_ENABLED(CONFIG_IPV6)
L
Linus Torvalds 已提交
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
#include <net/ipv6.h>
#include <net/ip6_fib.h>
#include <net/ip6_route.h>
#endif

/*
   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),
E
Eric Dumazet 已提交
69
   and silently drop packet when it expires. It is a good
70
   solution, but it supposes maintaining new variable in ALL
L
Linus Torvalds 已提交
71 72
   skb, even if no tunneling is used.

E
Eric Dumazet 已提交
73 74 75
   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
L
Linus Torvalds 已提交
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95

   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,
96
   taking into account fragmentation. TO be short, ttl is not solution at all.
L
Linus Torvalds 已提交
97 98 99 100 101 102

   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
103
   rapidly degrades to value <68, where looping stops.
L
Linus Torvalds 已提交
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
   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. :-)



   3. Really, ipv4/ipip.c, ipv4/ip_gre.c and ipv6/sit.c contain
   practically identical code. It would be good to glue them
   together, but it is not very evident, how to make them modular.
   sit is integral part of IPv6, ipip and gre are naturally modular.
   We could extract common parts (hash table, ioctl etc)
   to a separate module (ip_tunnel.c).

   Alexey Kuznetsov.
 */

123 124 125 126
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");

H
Herbert Xu 已提交
127
static struct rtnl_link_ops ipgre_link_ops __read_mostly;
L
Linus Torvalds 已提交
128 129
static int ipgre_tunnel_init(struct net_device *dev);
static void ipgre_tunnel_setup(struct net_device *dev);
130
static int ipgre_tunnel_bind_dev(struct net_device *dev);
L
Linus Torvalds 已提交
131 132 133

/* Fallback tunnel: no source, no destination, no key, no options */

134 135
#define HASH_SIZE  16

136
static int ipgre_net_id __read_mostly;
137
struct ipgre_net {
E
Eric Dumazet 已提交
138
	struct ip_tunnel __rcu *tunnels[4][HASH_SIZE];
139

140
	struct net_device *fb_tunnel_dev;
141 142
};

L
Linus Torvalds 已提交
143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
/* Tunnel hash table */

/*
   4 hash tables:

   3: (remote,local)
   2: (remote,*)
   1: (*,local)
   0: (*,*)

   We require exact key match i.e. if a key is present in packet
   it will match only tunnel with the same key; if it is not present,
   it will match only keyless tunnel.

   All keysless packets, if not matched configured keyless tunnels
   will match fallback tunnel.
 */

A
Al Viro 已提交
161
#define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
L
Linus Torvalds 已提交
162

163 164 165 166
#define tunnels_r_l	tunnels[3]
#define tunnels_r	tunnels[2]
#define tunnels_l	tunnels[1]
#define tunnels_wc	tunnels[0]
L
Linus Torvalds 已提交
167

168 169
static struct rtnl_link_stats64 *ipgre_get_stats64(struct net_device *dev,
						   struct rtnl_link_stats64 *tot)
E
Eric Dumazet 已提交
170 171 172 173 174
{
	int i;

	for_each_possible_cpu(i) {
		const struct pcpu_tstats *tstats = per_cpu_ptr(dev->tstats, i);
175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
		u64 rx_packets, rx_bytes, tx_packets, tx_bytes;
		unsigned int start;

		do {
			start = u64_stats_fetch_begin_bh(&tstats->syncp);
			rx_packets = tstats->rx_packets;
			tx_packets = tstats->tx_packets;
			rx_bytes = tstats->rx_bytes;
			tx_bytes = tstats->tx_bytes;
		} while (u64_stats_fetch_retry_bh(&tstats->syncp, start));

		tot->rx_packets += rx_packets;
		tot->tx_packets += tx_packets;
		tot->rx_bytes   += rx_bytes;
		tot->tx_bytes   += tx_bytes;
E
Eric Dumazet 已提交
190
	}
191 192 193 194 195

	tot->multicast = dev->stats.multicast;
	tot->rx_crc_errors = dev->stats.rx_crc_errors;
	tot->rx_fifo_errors = dev->stats.rx_fifo_errors;
	tot->rx_length_errors = dev->stats.rx_length_errors;
196
	tot->rx_frame_errors = dev->stats.rx_frame_errors;
197
	tot->rx_errors = dev->stats.rx_errors;
198

199 200 201 202 203 204 205
	tot->tx_fifo_errors = dev->stats.tx_fifo_errors;
	tot->tx_carrier_errors = dev->stats.tx_carrier_errors;
	tot->tx_dropped = dev->stats.tx_dropped;
	tot->tx_aborted_errors = dev->stats.tx_aborted_errors;
	tot->tx_errors = dev->stats.tx_errors;

	return tot;
E
Eric Dumazet 已提交
206 207
}

S
stephen hemminger 已提交
208 209
/* Does key in tunnel parameters match packet */
static bool ipgre_key_match(const struct ip_tunnel_parm *p,
S
stephen hemminger 已提交
210
			    __be16 flags, __be32 key)
S
stephen hemminger 已提交
211 212 213 214 215 216 217 218 219 220
{
	if (p->i_flags & GRE_KEY) {
		if (flags & GRE_KEY)
			return key == p->i_key;
		else
			return false;	/* key expected, none present */
	} else
		return !(flags & GRE_KEY);
}

L
Linus Torvalds 已提交
221 222
/* Given src, dst and key, find appropriate for input tunnel. */

D
Daniel Baluta 已提交
223 224
static struct ip_tunnel *ipgre_tunnel_lookup(struct net_device *dev,
					     __be32 remote, __be32 local,
S
stephen hemminger 已提交
225
					     __be16 flags, __be32 key,
S
stephen hemminger 已提交
226
					     __be16 gre_proto)
L
Linus Torvalds 已提交
227
{
T
Timo Teras 已提交
228 229
	struct net *net = dev_net(dev);
	int link = dev->ifindex;
E
Eric Dumazet 已提交
230 231
	unsigned int h0 = HASH(remote);
	unsigned int h1 = HASH(key);
T
Timo Teras 已提交
232
	struct ip_tunnel *t, *cand = NULL;
233
	struct ipgre_net *ign = net_generic(net, ipgre_net_id);
234 235
	int dev_type = (gre_proto == htons(ETH_P_TEB)) ?
		       ARPHRD_ETHER : ARPHRD_IPGRE;
T
Timo Teras 已提交
236
	int score, cand_score = 4;
L
Linus Torvalds 已提交
237

A
Amerigo Wang 已提交
238
	for_each_ip_tunnel_rcu(t, ign->tunnels_r_l[h0 ^ h1]) {
T
Timo Teras 已提交
239 240 241 242 243
		if (local != t->parms.iph.saddr ||
		    remote != t->parms.iph.daddr ||
		    !(t->dev->flags & IFF_UP))
			continue;

S
stephen hemminger 已提交
244 245 246
		if (!ipgre_key_match(&t->parms, flags, key))
			continue;

T
Timo Teras 已提交
247 248 249 250
		if (t->dev->type != ARPHRD_IPGRE &&
		    t->dev->type != dev_type)
			continue;

T
Timo Teras 已提交
251
		score = 0;
T
Timo Teras 已提交
252
		if (t->parms.link != link)
T
Timo Teras 已提交
253
			score |= 1;
T
Timo Teras 已提交
254
		if (t->dev->type != dev_type)
T
Timo Teras 已提交
255 256
			score |= 2;
		if (score == 0)
T
Timo Teras 已提交
257
			return t;
T
Timo Teras 已提交
258 259 260 261 262

		if (score < cand_score) {
			cand = t;
			cand_score = score;
		}
L
Linus Torvalds 已提交
263
	}
264

A
Amerigo Wang 已提交
265
	for_each_ip_tunnel_rcu(t, ign->tunnels_r[h0 ^ h1]) {
T
Timo Teras 已提交
266 267 268 269
		if (remote != t->parms.iph.daddr ||
		    !(t->dev->flags & IFF_UP))
			continue;

S
stephen hemminger 已提交
270 271 272
		if (!ipgre_key_match(&t->parms, flags, key))
			continue;

T
Timo Teras 已提交
273 274 275 276
		if (t->dev->type != ARPHRD_IPGRE &&
		    t->dev->type != dev_type)
			continue;

T
Timo Teras 已提交
277
		score = 0;
T
Timo Teras 已提交
278
		if (t->parms.link != link)
T
Timo Teras 已提交
279
			score |= 1;
T
Timo Teras 已提交
280
		if (t->dev->type != dev_type)
T
Timo Teras 已提交
281 282
			score |= 2;
		if (score == 0)
T
Timo Teras 已提交
283
			return t;
T
Timo Teras 已提交
284 285 286 287 288

		if (score < cand_score) {
			cand = t;
			cand_score = score;
		}
L
Linus Torvalds 已提交
289
	}
290

A
Amerigo Wang 已提交
291
	for_each_ip_tunnel_rcu(t, ign->tunnels_l[h1]) {
T
Timo Teras 已提交
292 293 294 295 296 297
		if ((local != t->parms.iph.saddr &&
		     (local != t->parms.iph.daddr ||
		      !ipv4_is_multicast(local))) ||
		    !(t->dev->flags & IFF_UP))
			continue;

S
stephen hemminger 已提交
298 299 300
		if (!ipgre_key_match(&t->parms, flags, key))
			continue;

T
Timo Teras 已提交
301 302 303 304
		if (t->dev->type != ARPHRD_IPGRE &&
		    t->dev->type != dev_type)
			continue;

T
Timo Teras 已提交
305
		score = 0;
T
Timo Teras 已提交
306
		if (t->parms.link != link)
T
Timo Teras 已提交
307
			score |= 1;
T
Timo Teras 已提交
308
		if (t->dev->type != dev_type)
T
Timo Teras 已提交
309 310
			score |= 2;
		if (score == 0)
T
Timo Teras 已提交
311
			return t;
T
Timo Teras 已提交
312 313 314 315 316

		if (score < cand_score) {
			cand = t;
			cand_score = score;
		}
L
Linus Torvalds 已提交
317
	}
318

A
Amerigo Wang 已提交
319
	for_each_ip_tunnel_rcu(t, ign->tunnels_wc[h1]) {
T
Timo Teras 已提交
320 321 322 323 324 325 326 327
		if (t->parms.i_key != key ||
		    !(t->dev->flags & IFF_UP))
			continue;

		if (t->dev->type != ARPHRD_IPGRE &&
		    t->dev->type != dev_type)
			continue;

T
Timo Teras 已提交
328
		score = 0;
T
Timo Teras 已提交
329
		if (t->parms.link != link)
T
Timo Teras 已提交
330
			score |= 1;
T
Timo Teras 已提交
331
		if (t->dev->type != dev_type)
T
Timo Teras 已提交
332 333
			score |= 2;
		if (score == 0)
T
Timo Teras 已提交
334
			return t;
T
Timo Teras 已提交
335 336 337 338 339

		if (score < cand_score) {
			cand = t;
			cand_score = score;
		}
L
Linus Torvalds 已提交
340 341
	}

T
Timo Teras 已提交
342 343
	if (cand != NULL)
		return cand;
344

345 346 347
	dev = ign->fb_tunnel_dev;
	if (dev->flags & IFF_UP)
		return netdev_priv(dev);
T
Timo Teras 已提交
348

L
Linus Torvalds 已提交
349 350 351
	return NULL;
}

E
Eric Dumazet 已提交
352
static struct ip_tunnel __rcu **__ipgre_bucket(struct ipgre_net *ign,
353
		struct ip_tunnel_parm *parms)
L
Linus Torvalds 已提交
354
{
355 356 357
	__be32 remote = parms->iph.daddr;
	__be32 local = parms->iph.saddr;
	__be32 key = parms->i_key;
E
Eric Dumazet 已提交
358
	unsigned int h = HASH(key);
L
Linus Torvalds 已提交
359 360 361 362
	int prio = 0;

	if (local)
		prio |= 1;
363
	if (remote && !ipv4_is_multicast(remote)) {
L
Linus Torvalds 已提交
364 365 366 367
		prio |= 2;
		h ^= HASH(remote);
	}

368
	return &ign->tunnels[prio][h];
L
Linus Torvalds 已提交
369 370
}

E
Eric Dumazet 已提交
371
static inline struct ip_tunnel __rcu **ipgre_bucket(struct ipgre_net *ign,
372
		struct ip_tunnel *t)
373
{
374
	return __ipgre_bucket(ign, &t->parms);
375 376
}

377
static void ipgre_tunnel_link(struct ipgre_net *ign, struct ip_tunnel *t)
L
Linus Torvalds 已提交
378
{
E
Eric Dumazet 已提交
379
	struct ip_tunnel __rcu **tp = ipgre_bucket(ign, t);
L
Linus Torvalds 已提交
380

E
Eric Dumazet 已提交
381
	rcu_assign_pointer(t->next, rtnl_dereference(*tp));
382
	rcu_assign_pointer(*tp, t);
L
Linus Torvalds 已提交
383 384
}

385
static void ipgre_tunnel_unlink(struct ipgre_net *ign, struct ip_tunnel *t)
L
Linus Torvalds 已提交
386
{
E
Eric Dumazet 已提交
387 388 389 390 391 392 393 394
	struct ip_tunnel __rcu **tp;
	struct ip_tunnel *iter;

	for (tp = ipgre_bucket(ign, t);
	     (iter = rtnl_dereference(*tp)) != NULL;
	     tp = &iter->next) {
		if (t == iter) {
			rcu_assign_pointer(*tp, t->next);
L
Linus Torvalds 已提交
395 396 397 398 399
			break;
		}
	}
}

400 401 402
static struct ip_tunnel *ipgre_tunnel_find(struct net *net,
					   struct ip_tunnel_parm *parms,
					   int type)
L
Linus Torvalds 已提交
403
{
A
Al Viro 已提交
404 405 406
	__be32 remote = parms->iph.daddr;
	__be32 local = parms->iph.saddr;
	__be32 key = parms->i_key;
T
Timo Teras 已提交
407
	int link = parms->link;
E
Eric Dumazet 已提交
408 409
	struct ip_tunnel *t;
	struct ip_tunnel __rcu **tp;
410 411
	struct ipgre_net *ign = net_generic(net, ipgre_net_id);

E
Eric Dumazet 已提交
412 413 414
	for (tp = __ipgre_bucket(ign, parms);
	     (t = rtnl_dereference(*tp)) != NULL;
	     tp = &t->next)
415 416 417
		if (local == t->parms.iph.saddr &&
		    remote == t->parms.iph.daddr &&
		    key == t->parms.i_key &&
T
Timo Teras 已提交
418
		    link == t->parms.link &&
419 420 421 422 423 424
		    type == t->dev->type)
			break;

	return t;
}

E
Eric Dumazet 已提交
425
static struct ip_tunnel *ipgre_tunnel_locate(struct net *net,
426 427 428
		struct ip_tunnel_parm *parms, int create)
{
	struct ip_tunnel *t, *nt;
L
Linus Torvalds 已提交
429 430
	struct net_device *dev;
	char name[IFNAMSIZ];
431
	struct ipgre_net *ign = net_generic(net, ipgre_net_id);
L
Linus Torvalds 已提交
432

433 434 435
	t = ipgre_tunnel_find(net, parms, ARPHRD_IPGRE);
	if (t || !create)
		return t;
L
Linus Torvalds 已提交
436 437 438

	if (parms->name[0])
		strlcpy(name, parms->name, IFNAMSIZ);
439
	else
S
stephen hemminger 已提交
440
		strcpy(name, "gre%d");
L
Linus Torvalds 已提交
441 442 443

	dev = alloc_netdev(sizeof(*t), name, ipgre_tunnel_setup);
	if (!dev)
S
stephen hemminger 已提交
444
		return NULL;
L
Linus Torvalds 已提交
445

446 447
	dev_net_set(dev, net);

448
	nt = netdev_priv(dev);
L
Linus Torvalds 已提交
449
	nt->parms = *parms;
H
Herbert Xu 已提交
450
	dev->rtnl_link_ops = &ipgre_link_ops;
L
Linus Torvalds 已提交
451

452 453
	dev->mtu = ipgre_tunnel_bind_dev(dev);

454 455
	if (register_netdevice(dev) < 0)
		goto failed_free;
L
Linus Torvalds 已提交
456

457 458 459 460
	/* Can use a lockless transmit, unless we generate output sequences */
	if (!(nt->parms.o_flags & GRE_SEQ))
		dev->features |= NETIF_F_LLTX;

L
Linus Torvalds 已提交
461
	dev_hold(dev);
462
	ipgre_tunnel_link(ign, nt);
L
Linus Torvalds 已提交
463 464
	return nt;

465 466
failed_free:
	free_netdev(dev);
L
Linus Torvalds 已提交
467 468 469 470 471
	return NULL;
}

static void ipgre_tunnel_uninit(struct net_device *dev)
{
472 473 474 475
	struct net *net = dev_net(dev);
	struct ipgre_net *ign = net_generic(net, ipgre_net_id);

	ipgre_tunnel_unlink(ign, netdev_priv(dev));
L
Linus Torvalds 已提交
476 477 478 479 480 481 482
	dev_put(dev);
}


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

483
/* All the routers (except for Linux) return only
L
Linus Torvalds 已提交
484 485 486 487 488 489 490 491
   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,
492 493
   what the hell these idiots break standards established
   by themselves???
L
Linus Torvalds 已提交
494 495
 */

496
	const struct iphdr *iph = (const struct iphdr *)skb->data;
D
Daniel Baluta 已提交
497
	__be16	     *p = (__be16 *)(skb->data+(iph->ihl<<2));
L
Linus Torvalds 已提交
498
	int grehlen = (iph->ihl<<2) + 4;
499 500
	const int type = icmp_hdr(skb)->type;
	const int code = icmp_hdr(skb)->code;
L
Linus Torvalds 已提交
501
	struct ip_tunnel *t;
A
Al Viro 已提交
502
	__be16 flags;
S
stephen hemminger 已提交
503
	__be32 key = 0;
L
Linus Torvalds 已提交
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519

	flags = p[0];
	if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
		if (flags&(GRE_VERSION|GRE_ROUTING))
			return;
		if (flags&GRE_KEY) {
			grehlen += 4;
			if (flags&GRE_CSUM)
				grehlen += 4;
		}
	}

	/* If only 8 bytes returned, keyed message will be dropped here */
	if (skb_headlen(skb) < grehlen)
		return;

S
stephen hemminger 已提交
520 521 522
	if (flags & GRE_KEY)
		key = *(((__be32 *)p) + (grehlen / 4) - 1);

L
Linus Torvalds 已提交
523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545
	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;
		break;
546 547 548

	case ICMP_REDIRECT:
		break;
L
Linus Torvalds 已提交
549 550
	}

T
Timo Teras 已提交
551
	t = ipgre_tunnel_lookup(skb->dev, iph->daddr, iph->saddr,
S
stephen hemminger 已提交
552 553
				flags, key, p[1]);

554
	if (t == NULL)
555
		return;
556 557 558 559

	if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
		ipv4_update_pmtu(skb, dev_net(skb->dev), info,
				 t->parms.link, 0, IPPROTO_GRE, 0);
560
		return;
561
	}
562 563 564
	if (type == ICMP_REDIRECT) {
		ipv4_redirect(skb, dev_net(skb->dev), t->parms.link, 0,
			      IPPROTO_GRE, 0);
565
		return;
566
	}
567
	if (t->parms.iph.daddr == 0 ||
568
	    ipv4_is_multicast(t->parms.iph.daddr))
569
		return;
L
Linus Torvalds 已提交
570 571

	if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
572
		return;
L
Linus Torvalds 已提交
573

574
	if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
L
Linus Torvalds 已提交
575 576 577 578 579 580 581
		t->err_count++;
	else
		t->err_count = 1;
	t->err_time = jiffies;
}

static inline u8
582
ipgre_ecn_encapsulate(u8 tos, const struct iphdr *old_iph, struct sk_buff *skb)
L
Linus Torvalds 已提交
583 584 585 586 587
{
	u8 inner = 0;
	if (skb->protocol == htons(ETH_P_IP))
		inner = old_iph->tos;
	else if (skb->protocol == htons(ETH_P_IPV6))
588
		inner = ipv6_get_dsfield((const struct ipv6hdr *)old_iph);
L
Linus Torvalds 已提交
589 590 591 592 593
	return INET_ECN_encapsulate(tos, inner);
}

static int ipgre_rcv(struct sk_buff *skb)
{
594
	const struct iphdr *iph;
L
Linus Torvalds 已提交
595
	u8     *h;
A
Al Viro 已提交
596
	__be16    flags;
597
	__sum16   csum = 0;
A
Al Viro 已提交
598
	__be32 key = 0;
L
Linus Torvalds 已提交
599 600 601
	u32    seqno = 0;
	struct ip_tunnel *tunnel;
	int    offset = 4;
602
	__be16 gre_proto;
603
	int    err;
L
Linus Torvalds 已提交
604 605

	if (!pskb_may_pull(skb, 16))
606
		goto drop;
L
Linus Torvalds 已提交
607

608
	iph = ip_hdr(skb);
L
Linus Torvalds 已提交
609
	h = skb->data;
D
Daniel Baluta 已提交
610
	flags = *(__be16 *)h;
L
Linus Torvalds 已提交
611 612 613 614 615 616

	if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {
		/* - Version must be 0.
		   - We do not support routing headers.
		 */
		if (flags&(GRE_VERSION|GRE_ROUTING))
617
			goto drop;
L
Linus Torvalds 已提交
618 619

		if (flags&GRE_CSUM) {
620
			switch (skb->ip_summed) {
621
			case CHECKSUM_COMPLETE:
622
				csum = csum_fold(skb->csum);
623 624 625 626 627 628
				if (!csum)
					break;
				/* fall through */
			case CHECKSUM_NONE:
				skb->csum = 0;
				csum = __skb_checksum_complete(skb);
629
				skb->ip_summed = CHECKSUM_COMPLETE;
L
Linus Torvalds 已提交
630 631 632 633
			}
			offset += 4;
		}
		if (flags&GRE_KEY) {
D
Daniel Baluta 已提交
634
			key = *(__be32 *)(h + offset);
L
Linus Torvalds 已提交
635 636 637
			offset += 4;
		}
		if (flags&GRE_SEQ) {
D
Daniel Baluta 已提交
638
			seqno = ntohl(*(__be32 *)(h + offset));
L
Linus Torvalds 已提交
639 640 641 642
			offset += 4;
		}
	}

643 644
	gre_proto = *(__be16 *)(h + 2);

S
stephen hemminger 已提交
645 646 647 648
	tunnel = ipgre_tunnel_lookup(skb->dev,
				     iph->saddr, iph->daddr, flags, key,
				     gre_proto);
	if (tunnel) {
E
Eric Dumazet 已提交
649
		struct pcpu_tstats *tstats;
650

L
Linus Torvalds 已提交
651 652
		secpath_reset(skb);

653
		skb->protocol = gre_proto;
L
Linus Torvalds 已提交
654 655 656 657
		/* WCCP version 1 and 2 protocol decoding.
		 * - Change protocol to IP
		 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
		 */
658
		if (flags == 0 && gre_proto == htons(ETH_P_WCCP)) {
659
			skb->protocol = htons(ETH_P_IP);
660
			if ((*(h + offset) & 0xF0) != 0x40)
L
Linus Torvalds 已提交
661 662 663
				offset += 4;
		}

664
		skb->mac_header = skb->network_header;
665
		__pskb_pull(skb, offset);
666
		skb_postpull_rcsum(skb, skb_transport_header(skb), offset);
L
Linus Torvalds 已提交
667 668
		skb->pkt_type = PACKET_HOST;
#ifdef CONFIG_NET_IPGRE_BROADCAST
669
		if (ipv4_is_multicast(iph->daddr)) {
L
Linus Torvalds 已提交
670
			/* Looped back packet, drop it! */
671
			if (rt_is_output_route(skb_rtable(skb)))
L
Linus Torvalds 已提交
672
				goto drop;
E
Eric Dumazet 已提交
673
			tunnel->dev->stats.multicast++;
L
Linus Torvalds 已提交
674 675 676 677 678 679
			skb->pkt_type = PACKET_BROADCAST;
		}
#endif

		if (((flags&GRE_CSUM) && csum) ||
		    (!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {
E
Eric Dumazet 已提交
680 681
			tunnel->dev->stats.rx_crc_errors++;
			tunnel->dev->stats.rx_errors++;
L
Linus Torvalds 已提交
682 683 684 685 686
			goto drop;
		}
		if (tunnel->parms.i_flags&GRE_SEQ) {
			if (!(flags&GRE_SEQ) ||
			    (tunnel->i_seqno && (s32)(seqno - tunnel->i_seqno) < 0)) {
E
Eric Dumazet 已提交
687 688
				tunnel->dev->stats.rx_fifo_errors++;
				tunnel->dev->stats.rx_errors++;
L
Linus Torvalds 已提交
689 690 691 692
				goto drop;
			}
			tunnel->i_seqno = seqno + 1;
		}
693 694 695 696

		/* Warning: All skb pointers will be invalidated! */
		if (tunnel->dev->type == ARPHRD_ETHER) {
			if (!pskb_may_pull(skb, ETH_HLEN)) {
E
Eric Dumazet 已提交
697 698
				tunnel->dev->stats.rx_length_errors++;
				tunnel->dev->stats.rx_errors++;
699 700 701 702 703 704 705 706
				goto drop;
			}

			iph = ip_hdr(skb);
			skb->protocol = eth_type_trans(skb, tunnel->dev);
			skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
		}

707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
		__skb_tunnel_rx(skb, tunnel->dev);

		skb_reset_network_header(skb);
		err = IP_ECN_decapsulate(iph, skb);
		if (unlikely(err)) {
			if (log_ecn_error)
				net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
						     &iph->saddr, iph->tos);
			if (err > 1) {
				++tunnel->dev->stats.rx_frame_errors;
				++tunnel->dev->stats.rx_errors;
				goto drop;
			}
		}

E
Eric Dumazet 已提交
722
		tstats = this_cpu_ptr(tunnel->dev->tstats);
723
		u64_stats_update_begin(&tstats->syncp);
E
Eric Dumazet 已提交
724 725
		tstats->rx_packets++;
		tstats->rx_bytes += skb->len;
726
		u64_stats_update_end(&tstats->syncp);
E
Eric Dumazet 已提交
727

E
Eric Dumazet 已提交
728
		gro_cells_receive(&tunnel->gro_cells, skb);
E
Eric Dumazet 已提交
729
		return 0;
L
Linus Torvalds 已提交
730
	}
731
	icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
L
Linus Torvalds 已提交
732 733 734

drop:
	kfree_skb(skb);
E
Eric Dumazet 已提交
735
	return 0;
L
Linus Torvalds 已提交
736 737
}

738 739 740 741 742 743 744 745 746 747 748
static struct sk_buff *handle_offloads(struct sk_buff *skb)
{
	int err;

	if (skb_is_gso(skb)) {
		err = skb_unclone(skb, GFP_ATOMIC);
		if (unlikely(err))
			goto error;
		skb_shinfo(skb)->gso_type |= SKB_GSO_GRE;
		return skb;
	}
749 750
	if (skb->ip_summed != CHECKSUM_PARTIAL)
		skb->ip_summed = CHECKSUM_NONE;
751 752 753 754 755 756 757 758

	return skb;

error:
	kfree_skb(skb);
	return ERR_PTR(err);
}

759
static netdev_tx_t ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
L
Linus Torvalds 已提交
760
{
761
	struct pcpu_tstats *tstats = this_cpu_ptr(dev->tstats);
762
	struct ip_tunnel *tunnel = netdev_priv(dev);
763
	const struct iphdr  *old_iph;
764
	const struct iphdr  *tiph;
765
	struct flowi4 fl4;
L
Linus Torvalds 已提交
766
	u8     tos;
A
Al Viro 已提交
767
	__be16 df;
L
Linus Torvalds 已提交
768
	struct rtable *rt;     			/* Route to the other host */
E
Eric Dumazet 已提交
769
	struct net_device *tdev;		/* Device to other host */
L
Linus Torvalds 已提交
770
	struct iphdr  *iph;			/* Our new IP header */
771
	unsigned int max_headroom;		/* The extra header space needed */
L
Linus Torvalds 已提交
772
	int    gre_hlen;
A
Al Viro 已提交
773
	__be32 dst;
L
Linus Torvalds 已提交
774
	int    mtu;
E
Eric Dumazet 已提交
775
	u8     ttl;
776 777
	int    err;
	int    pkt_len;
L
Linus Torvalds 已提交
778

779 780 781 782 783 784 785 786 787 788
	skb = handle_offloads(skb);
	if (IS_ERR(skb)) {
		dev->stats.tx_dropped++;
		return NETDEV_TX_OK;
	}

	if (!skb->encapsulation) {
		skb_reset_inner_headers(skb);
		skb->encapsulation = 1;
	}
E
Eric Dumazet 已提交
789

790 791
	old_iph = ip_hdr(skb);

792 793 794 795
	if (dev->type == ARPHRD_ETHER)
		IPCB(skb)->flags = 0;

	if (dev->header_ops && dev->type == ARPHRD_IPGRE) {
L
Linus Torvalds 已提交
796
		gre_hlen = 0;
797 798 799 800
		if (skb->protocol == htons(ETH_P_IP))
			tiph = (const struct iphdr *)skb->data;
		else
			tiph = &tunnel->parms.iph;
L
Linus Torvalds 已提交
801 802 803 804 805 806 807 808
	} else {
		gre_hlen = tunnel->hlen;
		tiph = &tunnel->parms.iph;
	}

	if ((dst = tiph->daddr) == 0) {
		/* NBMA tunnel */

E
Eric Dumazet 已提交
809
		if (skb_dst(skb) == NULL) {
E
Eric Dumazet 已提交
810
			dev->stats.tx_fifo_errors++;
L
Linus Torvalds 已提交
811 812 813
			goto tx_error;
		}

814
		if (skb->protocol == htons(ETH_P_IP)) {
E
Eric Dumazet 已提交
815
			rt = skb_rtable(skb);
816
			dst = rt_nexthop(rt, old_iph->daddr);
817
		}
E
Eric Dumazet 已提交
818
#if IS_ENABLED(CONFIG_IPV6)
L
Linus Torvalds 已提交
819
		else if (skb->protocol == htons(ETH_P_IPV6)) {
820
			const struct in6_addr *addr6;
821 822
			struct neighbour *neigh;
			bool do_tx_error_icmp;
L
Linus Torvalds 已提交
823 824
			int addr_type;

825
			neigh = dst_neigh_lookup(skb_dst(skb), &ipv6_hdr(skb)->daddr);
L
Linus Torvalds 已提交
826 827 828
			if (neigh == NULL)
				goto tx_error;

829
			addr6 = (const struct in6_addr *)&neigh->primary_key;
L
Linus Torvalds 已提交
830 831 832
			addr_type = ipv6_addr_type(addr6);

			if (addr_type == IPV6_ADDR_ANY) {
833
				addr6 = &ipv6_hdr(skb)->daddr;
L
Linus Torvalds 已提交
834 835 836 837
				addr_type = ipv6_addr_type(addr6);
			}

			if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
838 839 840 841 842 843 844
				do_tx_error_icmp = true;
			else {
				do_tx_error_icmp = false;
				dst = addr6->s6_addr32[3];
			}
			neigh_release(neigh);
			if (do_tx_error_icmp)
L
Linus Torvalds 已提交
845 846 847 848 849 850 851
				goto tx_error_icmp;
		}
#endif
		else
			goto tx_error;
	}

E
Eric Dumazet 已提交
852
	ttl = tiph->ttl;
L
Linus Torvalds 已提交
853
	tos = tiph->tos;
854 855
	if (tos & 0x1) {
		tos &= ~0x1;
L
Linus Torvalds 已提交
856 857
		if (skb->protocol == htons(ETH_P_IP))
			tos = old_iph->tos;
858
		else if (skb->protocol == htons(ETH_P_IPV6))
859
			tos = ipv6_get_dsfield((const struct ipv6hdr *)old_iph);
L
Linus Torvalds 已提交
860 861
	}

862
	rt = ip_route_output_gre(dev_net(dev), &fl4, dst, tiph->saddr,
863 864 865 866 867
				 tunnel->parms.o_key, RT_TOS(tos),
				 tunnel->parms.link);
	if (IS_ERR(rt)) {
		dev->stats.tx_carrier_errors++;
		goto tx_error;
L
Linus Torvalds 已提交
868
	}
869
	tdev = rt->dst.dev;
L
Linus Torvalds 已提交
870 871 872

	if (tdev == dev) {
		ip_rt_put(rt);
E
Eric Dumazet 已提交
873
		dev->stats.collisions++;
L
Linus Torvalds 已提交
874 875 876 877 878
		goto tx_error;
	}

	df = tiph->frag_off;
	if (df)
879
		mtu = dst_mtu(&rt->dst) - dev->hard_header_len - tunnel->hlen;
L
Linus Torvalds 已提交
880
	else
E
Eric Dumazet 已提交
881
		mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
L
Linus Torvalds 已提交
882

E
Eric Dumazet 已提交
883
	if (skb_dst(skb))
884
		skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
L
Linus Torvalds 已提交
885 886 887 888

	if (skb->protocol == htons(ETH_P_IP)) {
		df |= (old_iph->frag_off&htons(IP_DF));

889 890
		if (!skb_is_gso(skb) &&
		    (old_iph->frag_off&htons(IP_DF)) &&
L
Linus Torvalds 已提交
891 892 893 894 895 896
		    mtu < ntohs(old_iph->tot_len)) {
			icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
			ip_rt_put(rt);
			goto tx_error;
		}
	}
E
Eric Dumazet 已提交
897
#if IS_ENABLED(CONFIG_IPV6)
L
Linus Torvalds 已提交
898
	else if (skb->protocol == htons(ETH_P_IPV6)) {
E
Eric Dumazet 已提交
899
		struct rt6_info *rt6 = (struct rt6_info *)skb_dst(skb);
L
Linus Torvalds 已提交
900

E
Eric Dumazet 已提交
901
		if (rt6 && mtu < dst_mtu(skb_dst(skb)) && mtu >= IPV6_MIN_MTU) {
902 903
			if ((tunnel->parms.iph.daddr &&
			     !ipv4_is_multicast(tunnel->parms.iph.daddr)) ||
L
Linus Torvalds 已提交
904 905
			    rt6->rt6i_dst.plen == 128) {
				rt6->rt6i_flags |= RTF_MODIFIED;
906
				dst_metric_set(skb_dst(skb), RTAX_MTU, mtu);
L
Linus Torvalds 已提交
907 908 909
			}
		}

910 911 912
		if (!skb_is_gso(skb) &&
		    mtu >= IPV6_MIN_MTU &&
		    mtu < skb->len - tunnel->hlen + gre_hlen) {
913
			icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
L
Linus Torvalds 已提交
914 915 916 917 918 919 920
			ip_rt_put(rt);
			goto tx_error;
		}
	}
#endif

	if (tunnel->err_count > 0) {
921 922
		if (time_before(jiffies,
				tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
L
Linus Torvalds 已提交
923 924 925 926 927 928 929
			tunnel->err_count--;

			dst_link_failure(skb);
		} else
			tunnel->err_count = 0;
	}

930
	max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen + rt->dst.header_len;
L
Linus Torvalds 已提交
931

932 933
	if (skb_headroom(skb) < max_headroom || skb_shared(skb)||
	    (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
L
Linus Torvalds 已提交
934
		struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
935 936
		if (max_headroom > dev->needed_headroom)
			dev->needed_headroom = max_headroom;
L
Linus Torvalds 已提交
937 938
		if (!new_skb) {
			ip_rt_put(rt);
E
Eric Dumazet 已提交
939
			dev->stats.tx_dropped++;
L
Linus Torvalds 已提交
940
			dev_kfree_skb(skb);
941
			return NETDEV_TX_OK;
L
Linus Torvalds 已提交
942 943 944 945 946
		}
		if (skb->sk)
			skb_set_owner_w(new_skb, skb->sk);
		dev_kfree_skb(skb);
		skb = new_skb;
947
		old_iph = ip_hdr(skb);
E
Eric Dumazet 已提交
948
		/* Warning : tiph value might point to freed memory */
L
Linus Torvalds 已提交
949 950
	}

951 952
	skb_push(skb, gre_hlen);
	skb_reset_network_header(skb);
953
	skb_set_transport_header(skb, sizeof(*iph));
L
Linus Torvalds 已提交
954
	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
955 956
	IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
			      IPSKB_REROUTED);
E
Eric Dumazet 已提交
957
	skb_dst_drop(skb);
958
	skb_dst_set(skb, &rt->dst);
L
Linus Torvalds 已提交
959 960 961 962 963

	/*
	 *	Push down and install the IPIP header.
	 */

964
	iph 			=	ip_hdr(skb);
L
Linus Torvalds 已提交
965 966 967 968 969
	iph->version		=	4;
	iph->ihl		=	sizeof(struct iphdr) >> 2;
	iph->frag_off		=	df;
	iph->protocol		=	IPPROTO_GRE;
	iph->tos		=	ipgre_ecn_encapsulate(tos, old_iph, skb);
970 971
	iph->daddr		=	fl4.daddr;
	iph->saddr		=	fl4.saddr;
E
Eric Dumazet 已提交
972
	iph->ttl		=	ttl;
P
Pravin B Shelar 已提交
973 974

	tunnel_ip_select_ident(skb, old_iph, &rt->dst);
L
Linus Torvalds 已提交
975

E
Eric Dumazet 已提交
976
	if (ttl == 0) {
L
Linus Torvalds 已提交
977 978
		if (skb->protocol == htons(ETH_P_IP))
			iph->ttl = old_iph->ttl;
E
Eric Dumazet 已提交
979
#if IS_ENABLED(CONFIG_IPV6)
L
Linus Torvalds 已提交
980
		else if (skb->protocol == htons(ETH_P_IPV6))
981
			iph->ttl = ((const struct ipv6hdr *)old_iph)->hop_limit;
L
Linus Torvalds 已提交
982 983
#endif
		else
984
			iph->ttl = ip4_dst_hoplimit(&rt->dst);
L
Linus Torvalds 已提交
985 986
	}

987 988 989
	((__be16 *)(iph + 1))[0] = tunnel->parms.o_flags;
	((__be16 *)(iph + 1))[1] = (dev->type == ARPHRD_ETHER) ?
				   htons(ETH_P_TEB) : skb->protocol;
L
Linus Torvalds 已提交
990 991

	if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
D
Daniel Baluta 已提交
992
		__be32 *ptr = (__be32 *)(((u8 *)iph) + tunnel->hlen - 4);
L
Linus Torvalds 已提交
993 994 995 996 997 998 999 1000 1001 1002

		if (tunnel->parms.o_flags&GRE_SEQ) {
			++tunnel->o_seqno;
			*ptr = htonl(tunnel->o_seqno);
			ptr--;
		}
		if (tunnel->parms.o_flags&GRE_KEY) {
			*ptr = tunnel->parms.o_key;
			ptr--;
		}
1003 1004 1005
		/* Skip GRE checksum if skb is getting offloaded. */
		if (!(skb_shinfo(skb)->gso_type & SKB_GSO_GRE) &&
		    (tunnel->parms.o_flags&GRE_CSUM)) {
1006 1007
			int offset = skb_transport_offset(skb);

1008 1009
			if (skb_has_shared_frag(skb)) {
				err = __skb_linearize(skb);
1010
				if (err)
1011 1012 1013
					goto tx_error;
			}

L
Linus Torvalds 已提交
1014
			*ptr = 0;
1015 1016 1017
			*(__sum16 *)ptr = csum_fold(skb_checksum(skb, offset,
								 skb->len - offset,
								 0));
L
Linus Torvalds 已提交
1018 1019 1020
		}
	}

1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
	nf_reset(skb);

	pkt_len = skb->len - skb_transport_offset(skb);
	err = ip_local_out(skb);
	if (likely(net_xmit_eval(err) == 0)) {
		u64_stats_update_begin(&tstats->syncp);
		tstats->tx_bytes += pkt_len;
		tstats->tx_packets++;
		u64_stats_update_end(&tstats->syncp);
	} else {
		dev->stats.tx_errors++;
		dev->stats.tx_aborted_errors++;
	}
1034
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
1035

1036
#if IS_ENABLED(CONFIG_IPV6)
L
Linus Torvalds 已提交
1037 1038
tx_error_icmp:
	dst_link_failure(skb);
1039
#endif
L
Linus Torvalds 已提交
1040
tx_error:
E
Eric Dumazet 已提交
1041
	dev->stats.tx_errors++;
L
Linus Torvalds 已提交
1042
	dev_kfree_skb(skb);
1043
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
1044 1045
}

1046
static int ipgre_tunnel_bind_dev(struct net_device *dev)
1047 1048 1049
{
	struct net_device *tdev = NULL;
	struct ip_tunnel *tunnel;
1050
	const struct iphdr *iph;
1051 1052 1053 1054 1055 1056 1057
	int hlen = LL_MAX_HEADER;
	int mtu = ETH_DATA_LEN;
	int addend = sizeof(struct iphdr) + 4;

	tunnel = netdev_priv(dev);
	iph = &tunnel->parms.iph;

H
Herbert Xu 已提交
1058
	/* Guess output device to choose reasonable mtu and needed_headroom */
1059 1060

	if (iph->daddr) {
1061 1062 1063 1064 1065 1066 1067 1068
		struct flowi4 fl4;
		struct rtable *rt;

		rt = ip_route_output_gre(dev_net(dev), &fl4,
					 iph->daddr, iph->saddr,
					 tunnel->parms.o_key,
					 RT_TOS(iph->tos),
					 tunnel->parms.link);
1069
		if (!IS_ERR(rt)) {
1070
			tdev = rt->dst.dev;
1071 1072
			ip_rt_put(rt);
		}
1073 1074 1075

		if (dev->type != ARPHRD_ETHER)
			dev->flags |= IFF_POINTOPOINT;
1076 1077 1078
	}

	if (!tdev && tunnel->parms.link)
1079
		tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
1080 1081

	if (tdev) {
H
Herbert Xu 已提交
1082
		hlen = tdev->hard_header_len + tdev->needed_headroom;
1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095
		mtu = tdev->mtu;
	}
	dev->iflink = tunnel->parms.link;

	/* Precalculate GRE options length */
	if (tunnel->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {
		if (tunnel->parms.o_flags&GRE_CSUM)
			addend += 4;
		if (tunnel->parms.o_flags&GRE_KEY)
			addend += 4;
		if (tunnel->parms.o_flags&GRE_SEQ)
			addend += 4;
	}
H
Herbert Xu 已提交
1096
	dev->needed_headroom = addend + hlen;
1097
	mtu -= dev->hard_header_len + addend;
1098 1099 1100 1101

	if (mtu < 68)
		mtu = 68;

1102
	tunnel->hlen = addend;
1103 1104
	/* TCP offload with GRE SEQ is not supported. */
	if (!(tunnel->parms.o_flags & GRE_SEQ)) {
1105 1106 1107 1108 1109 1110 1111 1112
		/* device supports enc gso offload*/
		if (tdev->hw_enc_features & NETIF_F_GRE_GSO) {
			dev->features		|= NETIF_F_TSO;
			dev->hw_features	|= NETIF_F_TSO;
		} else {
			dev->features		|= NETIF_F_GSO_SOFTWARE;
			dev->hw_features	|= NETIF_F_GSO_SOFTWARE;
		}
1113
	}
1114

1115
	return mtu;
1116 1117
}

L
Linus Torvalds 已提交
1118 1119 1120 1121 1122 1123
static int
ipgre_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
{
	int err = 0;
	struct ip_tunnel_parm p;
	struct ip_tunnel *t;
1124 1125
	struct net *net = dev_net(dev);
	struct ipgre_net *ign = net_generic(net, ipgre_net_id);
L
Linus Torvalds 已提交
1126 1127 1128 1129

	switch (cmd) {
	case SIOCGETTUNNEL:
		t = NULL;
1130
		if (dev == ign->fb_tunnel_dev) {
L
Linus Torvalds 已提交
1131 1132 1133 1134
			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
				err = -EFAULT;
				break;
			}
1135
			t = ipgre_tunnel_locate(net, &p, 0);
L
Linus Torvalds 已提交
1136 1137
		}
		if (t == NULL)
1138
			t = netdev_priv(dev);
L
Linus Torvalds 已提交
1139 1140 1141 1142 1143 1144 1145 1146
		memcpy(&p, &t->parms, sizeof(p));
		if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
			err = -EFAULT;
		break;

	case SIOCADDTUNNEL:
	case SIOCCHGTUNNEL:
		err = -EPERM;
1147
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166
			goto done;

		err = -EFAULT;
		if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
			goto done;

		err = -EINVAL;
		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)))
			goto done;
		if (p.iph.ttl)
			p.iph.frag_off |= htons(IP_DF);

		if (!(p.i_flags&GRE_KEY))
			p.i_key = 0;
		if (!(p.o_flags&GRE_KEY))
			p.o_key = 0;

1167
		t = ipgre_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
L
Linus Torvalds 已提交
1168

1169
		if (dev != ign->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
L
Linus Torvalds 已提交
1170 1171 1172 1173 1174 1175
			if (t != NULL) {
				if (t->dev != dev) {
					err = -EEXIST;
					break;
				}
			} else {
E
Eric Dumazet 已提交
1176
				unsigned int nflags = 0;
L
Linus Torvalds 已提交
1177

1178
				t = netdev_priv(dev);
L
Linus Torvalds 已提交
1179

1180
				if (ipv4_is_multicast(p.iph.daddr))
L
Linus Torvalds 已提交
1181 1182 1183 1184 1185 1186 1187 1188
					nflags = IFF_BROADCAST;
				else if (p.iph.daddr)
					nflags = IFF_POINTOPOINT;

				if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
					err = -EINVAL;
					break;
				}
1189
				ipgre_tunnel_unlink(ign, t);
1190
				synchronize_net();
L
Linus Torvalds 已提交
1191 1192 1193 1194 1195 1196
				t->parms.iph.saddr = p.iph.saddr;
				t->parms.iph.daddr = p.iph.daddr;
				t->parms.i_key = p.i_key;
				t->parms.o_key = p.o_key;
				memcpy(dev->dev_addr, &p.iph.saddr, 4);
				memcpy(dev->broadcast, &p.iph.daddr, 4);
1197
				ipgre_tunnel_link(ign, t);
L
Linus Torvalds 已提交
1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
				netdev_state_change(dev);
			}
		}

		if (t) {
			err = 0;
			if (cmd == SIOCCHGTUNNEL) {
				t->parms.iph.ttl = p.iph.ttl;
				t->parms.iph.tos = p.iph.tos;
				t->parms.iph.frag_off = p.iph.frag_off;
1208 1209
				if (t->parms.link != p.link) {
					t->parms.link = p.link;
1210
					dev->mtu = ipgre_tunnel_bind_dev(dev);
1211 1212
					netdev_state_change(dev);
				}
L
Linus Torvalds 已提交
1213 1214 1215 1216 1217 1218 1219 1220 1221
			}
			if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
				err = -EFAULT;
		} else
			err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
		break;

	case SIOCDELTUNNEL:
		err = -EPERM;
1222
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
1223 1224
			goto done;

1225
		if (dev == ign->fb_tunnel_dev) {
L
Linus Torvalds 已提交
1226 1227 1228 1229
			err = -EFAULT;
			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
				goto done;
			err = -ENOENT;
1230
			if ((t = ipgre_tunnel_locate(net, &p, 0)) == NULL)
L
Linus Torvalds 已提交
1231 1232
				goto done;
			err = -EPERM;
1233
			if (t == netdev_priv(ign->fb_tunnel_dev))
L
Linus Torvalds 已提交
1234 1235 1236
				goto done;
			dev = t->dev;
		}
1237 1238
		unregister_netdevice(dev);
		err = 0;
L
Linus Torvalds 已提交
1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
		break;

	default:
		err = -EINVAL;
	}

done:
	return err;
}

static int ipgre_tunnel_change_mtu(struct net_device *dev, int new_mtu)
{
1251
	struct ip_tunnel *tunnel = netdev_priv(dev);
H
Herbert Xu 已提交
1252 1253
	if (new_mtu < 68 ||
	    new_mtu > 0xFFF8 - dev->hard_header_len - tunnel->hlen)
L
Linus Torvalds 已提交
1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267
		return -EINVAL;
	dev->mtu = new_mtu;
	return 0;
}

/* 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).
1268

L
Linus Torvalds 已提交
1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287
   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
   ...

 */

1288 1289
static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
			unsigned short type,
E
Eric Dumazet 已提交
1290
			const void *daddr, const void *saddr, unsigned int len)
L
Linus Torvalds 已提交
1291
{
1292
	struct ip_tunnel *t = netdev_priv(dev);
L
Linus Torvalds 已提交
1293
	struct iphdr *iph = (struct iphdr *)skb_push(skb, t->hlen);
D
Daniel Baluta 已提交
1294
	__be16 *p = (__be16 *)(iph+1);
L
Linus Torvalds 已提交
1295 1296 1297 1298 1299 1300

	memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
	p[0]		= t->parms.o_flags;
	p[1]		= htons(type);

	/*
1301
	 *	Set the source hardware address.
L
Linus Torvalds 已提交
1302
	 */
1303

L
Linus Torvalds 已提交
1304 1305
	if (saddr)
		memcpy(&iph->saddr, saddr, 4);
1306
	if (daddr)
L
Linus Torvalds 已提交
1307
		memcpy(&iph->daddr, daddr, 4);
1308
	if (iph->daddr)
L
Linus Torvalds 已提交
1309
		return t->hlen;
1310

L
Linus Torvalds 已提交
1311 1312 1313
	return -t->hlen;
}

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

1321 1322
static const struct header_ops ipgre_header_ops = {
	.create	= ipgre_header,
1323
	.parse	= ipgre_header_parse,
1324 1325
};

1326
#ifdef CONFIG_NET_IPGRE_BROADCAST
L
Linus Torvalds 已提交
1327 1328
static int ipgre_open(struct net_device *dev)
{
1329
	struct ip_tunnel *t = netdev_priv(dev);
L
Linus Torvalds 已提交
1330

1331
	if (ipv4_is_multicast(t->parms.iph.daddr)) {
1332 1333 1334 1335 1336 1337 1338 1339 1340
		struct flowi4 fl4;
		struct rtable *rt;

		rt = ip_route_output_gre(dev_net(dev), &fl4,
					 t->parms.iph.daddr,
					 t->parms.iph.saddr,
					 t->parms.o_key,
					 RT_TOS(t->parms.iph.tos),
					 t->parms.link);
1341
		if (IS_ERR(rt))
L
Linus Torvalds 已提交
1342
			return -EADDRNOTAVAIL;
1343
		dev = rt->dst.dev;
L
Linus Torvalds 已提交
1344
		ip_rt_put(rt);
1345
		if (__in_dev_get_rtnl(dev) == NULL)
L
Linus Torvalds 已提交
1346 1347
			return -EADDRNOTAVAIL;
		t->mlink = dev->ifindex;
1348
		ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
L
Linus Torvalds 已提交
1349 1350 1351 1352 1353 1354
	}
	return 0;
}

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

1357
	if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
1358
		struct in_device *in_dev;
1359
		in_dev = inetdev_by_index(dev_net(dev), t->mlink);
1360
		if (in_dev)
L
Linus Torvalds 已提交
1361 1362 1363 1364 1365 1366 1367
			ip_mc_dec_group(in_dev, t->parms.iph.daddr);
	}
	return 0;
}

#endif

1368 1369 1370 1371 1372 1373 1374 1375 1376 1377
static const struct net_device_ops ipgre_netdev_ops = {
	.ndo_init		= ipgre_tunnel_init,
	.ndo_uninit		= ipgre_tunnel_uninit,
#ifdef CONFIG_NET_IPGRE_BROADCAST
	.ndo_open		= ipgre_open,
	.ndo_stop		= ipgre_close,
#endif
	.ndo_start_xmit		= ipgre_tunnel_xmit,
	.ndo_do_ioctl		= ipgre_tunnel_ioctl,
	.ndo_change_mtu		= ipgre_tunnel_change_mtu,
1378
	.ndo_get_stats64	= ipgre_get_stats64,
1379 1380
};

E
Eric Dumazet 已提交
1381 1382
static void ipgre_dev_free(struct net_device *dev)
{
E
Eric Dumazet 已提交
1383 1384 1385
	struct ip_tunnel *tunnel = netdev_priv(dev);

	gro_cells_destroy(&tunnel->gro_cells);
E
Eric Dumazet 已提交
1386 1387 1388 1389
	free_percpu(dev->tstats);
	free_netdev(dev);
}

E
Eric Dumazet 已提交
1390 1391 1392 1393 1394
#define GRE_FEATURES (NETIF_F_SG |		\
		      NETIF_F_FRAGLIST |	\
		      NETIF_F_HIGHDMA |		\
		      NETIF_F_HW_CSUM)

L
Linus Torvalds 已提交
1395 1396
static void ipgre_tunnel_setup(struct net_device *dev)
{
1397
	dev->netdev_ops		= &ipgre_netdev_ops;
E
Eric Dumazet 已提交
1398
	dev->destructor 	= ipgre_dev_free;
L
Linus Torvalds 已提交
1399 1400

	dev->type		= ARPHRD_IPGRE;
H
Herbert Xu 已提交
1401
	dev->needed_headroom 	= LL_MAX_HEADER + sizeof(struct iphdr) + 4;
1402
	dev->mtu		= ETH_DATA_LEN - sizeof(struct iphdr) - 4;
L
Linus Torvalds 已提交
1403 1404 1405
	dev->flags		= IFF_NOARP;
	dev->iflink		= 0;
	dev->addr_len		= 4;
1406
	dev->features		|= NETIF_F_NETNS_LOCAL;
1407
	dev->priv_flags		&= ~IFF_XMIT_DST_RELEASE;
E
Eric Dumazet 已提交
1408 1409 1410

	dev->features		|= GRE_FEATURES;
	dev->hw_features	|= GRE_FEATURES;
L
Linus Torvalds 已提交
1411 1412 1413 1414 1415 1416
}

static int ipgre_tunnel_init(struct net_device *dev)
{
	struct ip_tunnel *tunnel;
	struct iphdr *iph;
E
Eric Dumazet 已提交
1417
	int err;
L
Linus Torvalds 已提交
1418

1419
	tunnel = netdev_priv(dev);
L
Linus Torvalds 已提交
1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
	iph = &tunnel->parms.iph;

	tunnel->dev = dev;
	strcpy(tunnel->parms.name, dev->name);

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

	if (iph->daddr) {
#ifdef CONFIG_NET_IPGRE_BROADCAST
1430
		if (ipv4_is_multicast(iph->daddr)) {
L
Linus Torvalds 已提交
1431 1432 1433
			if (!iph->saddr)
				return -EINVAL;
			dev->flags = IFF_BROADCAST;
1434
			dev->header_ops = &ipgre_header_ops;
L
Linus Torvalds 已提交
1435 1436
		}
#endif
1437
	} else
1438
		dev->header_ops = &ipgre_header_ops;
L
Linus Torvalds 已提交
1439

E
Eric Dumazet 已提交
1440 1441 1442 1443
	dev->tstats = alloc_percpu(struct pcpu_tstats);
	if (!dev->tstats)
		return -ENOMEM;

E
Eric Dumazet 已提交
1444 1445 1446 1447 1448 1449
	err = gro_cells_init(&tunnel->gro_cells, dev);
	if (err) {
		free_percpu(dev->tstats);
		return err;
	}

L
Linus Torvalds 已提交
1450 1451 1452
	return 0;
}

1453
static void ipgre_fb_tunnel_init(struct net_device *dev)
L
Linus Torvalds 已提交
1454
{
1455
	struct ip_tunnel *tunnel = netdev_priv(dev);
L
Linus Torvalds 已提交
1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469
	struct iphdr *iph = &tunnel->parms.iph;

	tunnel->dev = dev;
	strcpy(tunnel->parms.name, dev->name);

	iph->version		= 4;
	iph->protocol		= IPPROTO_GRE;
	iph->ihl		= 5;
	tunnel->hlen		= sizeof(struct iphdr) + 4;

	dev_hold(dev);
}


1470 1471 1472
static const struct gre_protocol ipgre_protocol = {
	.handler     = ipgre_rcv,
	.err_handler = ipgre_err,
L
Linus Torvalds 已提交
1473 1474
};

1475
static void ipgre_destroy_tunnels(struct ipgre_net *ign, struct list_head *head)
1476 1477 1478 1479 1480 1481
{
	int prio;

	for (prio = 0; prio < 4; prio++) {
		int h;
		for (h = 0; h < HASH_SIZE; h++) {
E
Eric Dumazet 已提交
1482 1483 1484
			struct ip_tunnel *t;

			t = rtnl_dereference(ign->tunnels[prio][h]);
1485 1486 1487

			while (t != NULL) {
				unregister_netdevice_queue(t->dev, head);
E
Eric Dumazet 已提交
1488
				t = rtnl_dereference(t->next);
1489
			}
1490 1491 1492 1493
		}
	}
}

1494
static int __net_init ipgre_init_net(struct net *net)
1495
{
1496
	struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1497 1498
	int err;

1499 1500 1501 1502 1503 1504
	ign->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "gre0",
					   ipgre_tunnel_setup);
	if (!ign->fb_tunnel_dev) {
		err = -ENOMEM;
		goto err_alloc_dev;
	}
1505
	dev_net_set(ign->fb_tunnel_dev, net);
1506

1507
	ipgre_fb_tunnel_init(ign->fb_tunnel_dev);
H
Herbert Xu 已提交
1508
	ign->fb_tunnel_dev->rtnl_link_ops = &ipgre_link_ops;
1509 1510 1511 1512

	if ((err = register_netdev(ign->fb_tunnel_dev)))
		goto err_reg_dev;

E
Eric Dumazet 已提交
1513 1514
	rcu_assign_pointer(ign->tunnels_wc[0],
			   netdev_priv(ign->fb_tunnel_dev));
1515 1516
	return 0;

1517
err_reg_dev:
E
Eric Dumazet 已提交
1518
	ipgre_dev_free(ign->fb_tunnel_dev);
1519
err_alloc_dev:
1520 1521 1522
	return err;
}

1523
static void __net_exit ipgre_exit_net(struct net *net)
1524 1525
{
	struct ipgre_net *ign;
1526
	LIST_HEAD(list);
1527 1528

	ign = net_generic(net, ipgre_net_id);
1529
	rtnl_lock();
1530 1531
	ipgre_destroy_tunnels(ign, &list);
	unregister_netdevice_many(&list);
1532
	rtnl_unlock();
1533 1534 1535 1536 1537
}

static struct pernet_operations ipgre_net_ops = {
	.init = ipgre_init_net,
	.exit = ipgre_exit_net,
1538 1539
	.id   = &ipgre_net_id,
	.size = sizeof(struct ipgre_net),
1540
};
L
Linus Torvalds 已提交
1541

H
Herbert Xu 已提交
1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559
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;

	return 0;
}

1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583
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);
}

H
Herbert Xu 已提交
1584 1585 1586
static void ipgre_netlink_parms(struct nlattr *data[],
				struct ip_tunnel_parm *parms)
{
1587
	memset(parms, 0, sizeof(*parms));
H
Herbert Xu 已提交
1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609

	parms->iph.protocol = IPPROTO_GRE;

	if (!data)
		return;

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

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

	if (data[IFLA_GRE_OFLAGS])
		parms->o_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])
1610
		parms->iph.saddr = nla_get_be32(data[IFLA_GRE_LOCAL]);
H
Herbert Xu 已提交
1611 1612

	if (data[IFLA_GRE_REMOTE])
1613
		parms->iph.daddr = nla_get_be32(data[IFLA_GRE_REMOTE]);
H
Herbert Xu 已提交
1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624

	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]))
		parms->iph.frag_off = htons(IP_DF);
}

1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635
static int ipgre_tap_init(struct net_device *dev)
{
	struct ip_tunnel *tunnel;

	tunnel = netdev_priv(dev);

	tunnel->dev = dev;
	strcpy(tunnel->parms.name, dev->name);

	ipgre_tunnel_bind_dev(dev);

E
Eric Dumazet 已提交
1636 1637 1638 1639
	dev->tstats = alloc_percpu(struct pcpu_tstats);
	if (!dev->tstats)
		return -ENOMEM;

1640 1641 1642
	return 0;
}

1643 1644 1645 1646 1647 1648 1649
static const struct net_device_ops ipgre_tap_netdev_ops = {
	.ndo_init		= ipgre_tap_init,
	.ndo_uninit		= ipgre_tunnel_uninit,
	.ndo_start_xmit		= ipgre_tunnel_xmit,
	.ndo_set_mac_address 	= eth_mac_addr,
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_change_mtu		= ipgre_tunnel_change_mtu,
1650
	.ndo_get_stats64	= ipgre_get_stats64,
1651 1652
};

1653 1654 1655 1656 1657
static void ipgre_tap_setup(struct net_device *dev)
{

	ether_setup(dev);

1658
	dev->netdev_ops		= &ipgre_tap_netdev_ops;
E
Eric Dumazet 已提交
1659
	dev->destructor 	= ipgre_dev_free;
1660 1661 1662

	dev->iflink		= 0;
	dev->features		|= NETIF_F_NETNS_LOCAL;
1663 1664 1665

	dev->features		|= GRE_FEATURES;
	dev->hw_features	|= GRE_FEATURES;
1666 1667
}

1668
static int ipgre_newlink(struct net *src_net, struct net_device *dev, struct nlattr *tb[],
H
Herbert Xu 已提交
1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679
			 struct nlattr *data[])
{
	struct ip_tunnel *nt;
	struct net *net = dev_net(dev);
	struct ipgre_net *ign = net_generic(net, ipgre_net_id);
	int mtu;
	int err;

	nt = netdev_priv(dev);
	ipgre_netlink_parms(data, &nt->parms);

1680
	if (ipgre_tunnel_find(net, &nt->parms, dev->type))
H
Herbert Xu 已提交
1681 1682
		return -EEXIST;

1683
	if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])
1684
		eth_hw_addr_random(dev);
1685

H
Herbert Xu 已提交
1686 1687 1688 1689
	mtu = ipgre_tunnel_bind_dev(dev);
	if (!tb[IFLA_MTU])
		dev->mtu = mtu;

E
Eric Dumazet 已提交
1690 1691 1692 1693
	/* Can use a lockless transmit, unless we generate output sequences */
	if (!(nt->parms.o_flags & GRE_SEQ))
		dev->features |= NETIF_F_LLTX;

H
Herbert Xu 已提交
1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727
	err = register_netdevice(dev);
	if (err)
		goto out;

	dev_hold(dev);
	ipgre_tunnel_link(ign, nt);

out:
	return err;
}

static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
			    struct nlattr *data[])
{
	struct ip_tunnel *t, *nt;
	struct net *net = dev_net(dev);
	struct ipgre_net *ign = net_generic(net, ipgre_net_id);
	struct ip_tunnel_parm p;
	int mtu;

	if (dev == ign->fb_tunnel_dev)
		return -EINVAL;

	nt = netdev_priv(dev);
	ipgre_netlink_parms(data, &p);

	t = ipgre_tunnel_locate(net, &p, 0);

	if (t) {
		if (t->dev != dev)
			return -EEXIST;
	} else {
		t = nt;

1728
		if (dev->type != ARPHRD_ETHER) {
E
Eric Dumazet 已提交
1729
			unsigned int nflags = 0;
H
Herbert Xu 已提交
1730

1731 1732 1733 1734 1735 1736 1737 1738 1739
			if (ipv4_is_multicast(p.iph.daddr))
				nflags = IFF_BROADCAST;
			else if (p.iph.daddr)
				nflags = IFF_POINTOPOINT;

			if ((dev->flags ^ nflags) &
			    (IFF_POINTOPOINT | IFF_BROADCAST))
				return -EINVAL;
		}
H
Herbert Xu 已提交
1740 1741 1742 1743 1744

		ipgre_tunnel_unlink(ign, t);
		t->parms.iph.saddr = p.iph.saddr;
		t->parms.iph.daddr = p.iph.daddr;
		t->parms.i_key = p.i_key;
1745 1746 1747 1748
		if (dev->type != ARPHRD_ETHER) {
			memcpy(dev->dev_addr, &p.iph.saddr, 4);
			memcpy(dev->broadcast, &p.iph.daddr, 4);
		}
H
Herbert Xu 已提交
1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799
		ipgre_tunnel_link(ign, t);
		netdev_state_change(dev);
	}

	t->parms.o_key = p.o_key;
	t->parms.iph.ttl = p.iph.ttl;
	t->parms.iph.tos = p.iph.tos;
	t->parms.iph.frag_off = p.iph.frag_off;

	if (t->parms.link != p.link) {
		t->parms.link = p.link;
		mtu = ipgre_tunnel_bind_dev(dev);
		if (!tb[IFLA_MTU])
			dev->mtu = mtu;
		netdev_state_change(dev);
	}

	return 0;
}

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) +
		0;
}

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;

D
David S. Miller 已提交
1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811
	if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
	    nla_put_be16(skb, IFLA_GRE_IFLAGS, p->i_flags) ||
	    nla_put_be16(skb, IFLA_GRE_OFLAGS, 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_be32(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
	    nla_put_be32(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;
H
Herbert Xu 已提交
1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823
	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

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 },
1824 1825
	[IFLA_GRE_LOCAL]	= { .len = FIELD_SIZEOF(struct iphdr, saddr) },
	[IFLA_GRE_REMOTE]	= { .len = FIELD_SIZEOF(struct iphdr, daddr) },
H
Herbert Xu 已提交
1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843
	[IFLA_GRE_TTL]		= { .type = NLA_U8 },
	[IFLA_GRE_TOS]		= { .type = NLA_U8 },
	[IFLA_GRE_PMTUDISC]	= { .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,
	.get_size	= ipgre_get_size,
	.fill_info	= ipgre_fill_info,
};

1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856
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,
	.get_size	= ipgre_get_size,
	.fill_info	= ipgre_fill_info,
};

L
Linus Torvalds 已提交
1857 1858 1859 1860 1861 1862 1863 1864
/*
 *	And now the modules code and kernel interface.
 */

static int __init ipgre_init(void)
{
	int err;

J
Joe Perches 已提交
1865
	pr_info("GRE over IPv4 tunneling driver\n");
L
Linus Torvalds 已提交
1866

1867
	err = register_pernet_device(&ipgre_net_ops);
1868
	if (err < 0)
1869 1870
		return err;

1871
	err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
1872
	if (err < 0) {
J
Joe Perches 已提交
1873
		pr_info("%s: can't add protocol\n", __func__);
1874 1875
		goto add_proto_failed;
	}
1876

H
Herbert Xu 已提交
1877 1878 1879 1880
	err = rtnl_link_register(&ipgre_link_ops);
	if (err < 0)
		goto rtnl_link_failed;

1881 1882 1883 1884
	err = rtnl_link_register(&ipgre_tap_ops);
	if (err < 0)
		goto tap_ops_failed;

H
Herbert Xu 已提交
1885
out:
L
Linus Torvalds 已提交
1886
	return err;
H
Herbert Xu 已提交
1887

1888 1889
tap_ops_failed:
	rtnl_link_unregister(&ipgre_link_ops);
H
Herbert Xu 已提交
1890
rtnl_link_failed:
1891
	gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1892 1893
add_proto_failed:
	unregister_pernet_device(&ipgre_net_ops);
H
Herbert Xu 已提交
1894
	goto out;
L
Linus Torvalds 已提交
1895 1896
}

1897
static void __exit ipgre_fini(void)
L
Linus Torvalds 已提交
1898
{
1899
	rtnl_link_unregister(&ipgre_tap_ops);
H
Herbert Xu 已提交
1900
	rtnl_link_unregister(&ipgre_link_ops);
1901
	if (gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO) < 0)
J
Joe Perches 已提交
1902
		pr_info("%s: can't remove protocol\n", __func__);
1903
	unregister_pernet_device(&ipgre_net_ops);
L
Linus Torvalds 已提交
1904 1905 1906 1907 1908
}

module_init(ipgre_init);
module_exit(ipgre_fini);
MODULE_LICENSE("GPL");
1909 1910
MODULE_ALIAS_RTNL_LINK("gre");
MODULE_ALIAS_RTNL_LINK("gretap");
1911
MODULE_ALIAS_NETDEV("gre0");