ip_gre.c 44.1 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
static netdev_tx_t ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
L
Linus Torvalds 已提交
739
{
740
	struct ip_tunnel *tunnel = netdev_priv(dev);
741 742
	const struct iphdr  *old_iph = ip_hdr(skb);
	const struct iphdr  *tiph;
743
	struct flowi4 fl4;
L
Linus Torvalds 已提交
744
	u8     tos;
A
Al Viro 已提交
745
	__be16 df;
L
Linus Torvalds 已提交
746
	struct rtable *rt;     			/* Route to the other host */
E
Eric Dumazet 已提交
747
	struct net_device *tdev;		/* Device to other host */
L
Linus Torvalds 已提交
748
	struct iphdr  *iph;			/* Our new IP header */
749
	unsigned int max_headroom;		/* The extra header space needed */
L
Linus Torvalds 已提交
750
	int    gre_hlen;
A
Al Viro 已提交
751
	__be32 dst;
L
Linus Torvalds 已提交
752 753
	int    mtu;

E
Eric Dumazet 已提交
754 755 756 757
	if (skb->ip_summed == CHECKSUM_PARTIAL &&
	    skb_checksum_help(skb))
		goto tx_error;

758 759 760 761
	if (dev->type == ARPHRD_ETHER)
		IPCB(skb)->flags = 0;

	if (dev->header_ops && dev->type == ARPHRD_IPGRE) {
L
Linus Torvalds 已提交
762
		gre_hlen = 0;
763
		tiph = (const struct iphdr *)skb->data;
L
Linus Torvalds 已提交
764 765 766 767 768 769 770 771
	} else {
		gre_hlen = tunnel->hlen;
		tiph = &tunnel->parms.iph;
	}

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

E
Eric Dumazet 已提交
772
		if (skb_dst(skb) == NULL) {
E
Eric Dumazet 已提交
773
			dev->stats.tx_fifo_errors++;
L
Linus Torvalds 已提交
774 775 776
			goto tx_error;
		}

777
		if (skb->protocol == htons(ETH_P_IP)) {
E
Eric Dumazet 已提交
778
			rt = skb_rtable(skb);
779
			dst = rt_nexthop(rt, old_iph->daddr);
780
		}
E
Eric Dumazet 已提交
781
#if IS_ENABLED(CONFIG_IPV6)
L
Linus Torvalds 已提交
782
		else if (skb->protocol == htons(ETH_P_IPV6)) {
783
			const struct in6_addr *addr6;
784 785
			struct neighbour *neigh;
			bool do_tx_error_icmp;
L
Linus Torvalds 已提交
786 787
			int addr_type;

788
			neigh = dst_neigh_lookup(skb_dst(skb), &ipv6_hdr(skb)->daddr);
L
Linus Torvalds 已提交
789 790 791
			if (neigh == NULL)
				goto tx_error;

792
			addr6 = (const struct in6_addr *)&neigh->primary_key;
L
Linus Torvalds 已提交
793 794 795
			addr_type = ipv6_addr_type(addr6);

			if (addr_type == IPV6_ADDR_ANY) {
796
				addr6 = &ipv6_hdr(skb)->daddr;
L
Linus Torvalds 已提交
797 798 799 800
				addr_type = ipv6_addr_type(addr6);
			}

			if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
801 802 803 804 805 806 807
				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 已提交
808 809 810 811 812 813 814 815
				goto tx_error_icmp;
		}
#endif
		else
			goto tx_error;
	}

	tos = tiph->tos;
816 817
	if (tos == 1) {
		tos = 0;
L
Linus Torvalds 已提交
818 819
		if (skb->protocol == htons(ETH_P_IP))
			tos = old_iph->tos;
820
		else if (skb->protocol == htons(ETH_P_IPV6))
821
			tos = ipv6_get_dsfield((const struct ipv6hdr *)old_iph);
L
Linus Torvalds 已提交
822 823
	}

824
	rt = ip_route_output_gre(dev_net(dev), &fl4, dst, tiph->saddr,
825 826 827 828 829
				 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 已提交
830
	}
831
	tdev = rt->dst.dev;
L
Linus Torvalds 已提交
832 833 834

	if (tdev == dev) {
		ip_rt_put(rt);
E
Eric Dumazet 已提交
835
		dev->stats.collisions++;
L
Linus Torvalds 已提交
836 837 838 839 840
		goto tx_error;
	}

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

E
Eric Dumazet 已提交
845
	if (skb_dst(skb))
846
		skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
L
Linus Torvalds 已提交
847 848 849 850 851 852 853 854 855 856 857

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

		if ((old_iph->frag_off&htons(IP_DF)) &&
		    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 已提交
858
#if IS_ENABLED(CONFIG_IPV6)
L
Linus Torvalds 已提交
859
	else if (skb->protocol == htons(ETH_P_IPV6)) {
E
Eric Dumazet 已提交
860
		struct rt6_info *rt6 = (struct rt6_info *)skb_dst(skb);
L
Linus Torvalds 已提交
861

E
Eric Dumazet 已提交
862
		if (rt6 && mtu < dst_mtu(skb_dst(skb)) && mtu >= IPV6_MIN_MTU) {
863 864
			if ((tunnel->parms.iph.daddr &&
			     !ipv4_is_multicast(tunnel->parms.iph.daddr)) ||
L
Linus Torvalds 已提交
865 866
			    rt6->rt6i_dst.plen == 128) {
				rt6->rt6i_flags |= RTF_MODIFIED;
867
				dst_metric_set(skb_dst(skb), RTAX_MTU, mtu);
L
Linus Torvalds 已提交
868 869 870 871
			}
		}

		if (mtu >= IPV6_MIN_MTU && mtu < skb->len - tunnel->hlen + gre_hlen) {
872
			icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
L
Linus Torvalds 已提交
873 874 875 876 877 878 879
			ip_rt_put(rt);
			goto tx_error;
		}
	}
#endif

	if (tunnel->err_count > 0) {
880 881
		if (time_before(jiffies,
				tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
L
Linus Torvalds 已提交
882 883 884 885 886 887 888
			tunnel->err_count--;

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

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

891 892
	if (skb_headroom(skb) < max_headroom || skb_shared(skb)||
	    (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
L
Linus Torvalds 已提交
893
		struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
894 895
		if (max_headroom > dev->needed_headroom)
			dev->needed_headroom = max_headroom;
L
Linus Torvalds 已提交
896 897
		if (!new_skb) {
			ip_rt_put(rt);
E
Eric Dumazet 已提交
898
			dev->stats.tx_dropped++;
L
Linus Torvalds 已提交
899
			dev_kfree_skb(skb);
900
			return NETDEV_TX_OK;
L
Linus Torvalds 已提交
901 902 903 904 905
		}
		if (skb->sk)
			skb_set_owner_w(new_skb, skb->sk);
		dev_kfree_skb(skb);
		skb = new_skb;
906
		old_iph = ip_hdr(skb);
L
Linus Torvalds 已提交
907 908
	}

909
	skb_reset_transport_header(skb);
910 911
	skb_push(skb, gre_hlen);
	skb_reset_network_header(skb);
L
Linus Torvalds 已提交
912
	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
913 914
	IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
			      IPSKB_REROUTED);
E
Eric Dumazet 已提交
915
	skb_dst_drop(skb);
916
	skb_dst_set(skb, &rt->dst);
L
Linus Torvalds 已提交
917 918 919 920 921

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

922
	iph 			=	ip_hdr(skb);
L
Linus Torvalds 已提交
923 924 925 926 927
	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);
928 929
	iph->daddr		=	fl4.daddr;
	iph->saddr		=	fl4.saddr;
L
Linus Torvalds 已提交
930 931 932 933

	if ((iph->ttl = tiph->ttl) == 0) {
		if (skb->protocol == htons(ETH_P_IP))
			iph->ttl = old_iph->ttl;
E
Eric Dumazet 已提交
934
#if IS_ENABLED(CONFIG_IPV6)
L
Linus Torvalds 已提交
935
		else if (skb->protocol == htons(ETH_P_IPV6))
936
			iph->ttl = ((const struct ipv6hdr *)old_iph)->hop_limit;
L
Linus Torvalds 已提交
937 938
#endif
		else
939
			iph->ttl = ip4_dst_hoplimit(&rt->dst);
L
Linus Torvalds 已提交
940 941
	}

942 943 944
	((__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 已提交
945 946

	if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
D
Daniel Baluta 已提交
947
		__be32 *ptr = (__be32 *)(((u8 *)iph) + tunnel->hlen - 4);
L
Linus Torvalds 已提交
948 949 950 951 952 953 954 955 956 957 958 959

		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--;
		}
		if (tunnel->parms.o_flags&GRE_CSUM) {
			*ptr = 0;
D
Daniel Baluta 已提交
960
			*(__sum16 *)ptr = ip_compute_csum((void *)(iph+1), skb->len - sizeof(struct iphdr));
L
Linus Torvalds 已提交
961 962 963
		}
	}

964
	iptunnel_xmit(skb, dev);
965
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
966

967
#if IS_ENABLED(CONFIG_IPV6)
L
Linus Torvalds 已提交
968 969
tx_error_icmp:
	dst_link_failure(skb);
970
#endif
L
Linus Torvalds 已提交
971
tx_error:
E
Eric Dumazet 已提交
972
	dev->stats.tx_errors++;
L
Linus Torvalds 已提交
973
	dev_kfree_skb(skb);
974
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
975 976
}

977
static int ipgre_tunnel_bind_dev(struct net_device *dev)
978 979 980
{
	struct net_device *tdev = NULL;
	struct ip_tunnel *tunnel;
981
	const struct iphdr *iph;
982 983 984 985 986 987 988
	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 已提交
989
	/* Guess output device to choose reasonable mtu and needed_headroom */
990 991

	if (iph->daddr) {
992 993 994 995 996 997 998 999
		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);
1000
		if (!IS_ERR(rt)) {
1001
			tdev = rt->dst.dev;
1002 1003
			ip_rt_put(rt);
		}
1004 1005 1006

		if (dev->type != ARPHRD_ETHER)
			dev->flags |= IFF_POINTOPOINT;
1007 1008 1009
	}

	if (!tdev && tunnel->parms.link)
1010
		tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
1011 1012

	if (tdev) {
H
Herbert Xu 已提交
1013
		hlen = tdev->hard_header_len + tdev->needed_headroom;
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
		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 已提交
1027
	dev->needed_headroom = addend + hlen;
1028
	mtu -= dev->hard_header_len + addend;
1029 1030 1031 1032

	if (mtu < 68)
		mtu = 68;

1033 1034
	tunnel->hlen = addend;

1035
	return mtu;
1036 1037
}

L
Linus Torvalds 已提交
1038 1039 1040 1041 1042 1043
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;
1044 1045
	struct net *net = dev_net(dev);
	struct ipgre_net *ign = net_generic(net, ipgre_net_id);
L
Linus Torvalds 已提交
1046 1047 1048 1049

	switch (cmd) {
	case SIOCGETTUNNEL:
		t = NULL;
1050
		if (dev == ign->fb_tunnel_dev) {
L
Linus Torvalds 已提交
1051 1052 1053 1054
			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
				err = -EFAULT;
				break;
			}
1055
			t = ipgre_tunnel_locate(net, &p, 0);
L
Linus Torvalds 已提交
1056 1057
		}
		if (t == NULL)
1058
			t = netdev_priv(dev);
L
Linus Torvalds 已提交
1059 1060 1061 1062 1063 1064 1065 1066
		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;
1067
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
			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;

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

1089
		if (dev != ign->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
L
Linus Torvalds 已提交
1090 1091 1092 1093 1094 1095
			if (t != NULL) {
				if (t->dev != dev) {
					err = -EEXIST;
					break;
				}
			} else {
E
Eric Dumazet 已提交
1096
				unsigned int nflags = 0;
L
Linus Torvalds 已提交
1097

1098
				t = netdev_priv(dev);
L
Linus Torvalds 已提交
1099

1100
				if (ipv4_is_multicast(p.iph.daddr))
L
Linus Torvalds 已提交
1101 1102 1103 1104 1105 1106 1107 1108
					nflags = IFF_BROADCAST;
				else if (p.iph.daddr)
					nflags = IFF_POINTOPOINT;

				if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
					err = -EINVAL;
					break;
				}
1109
				ipgre_tunnel_unlink(ign, t);
1110
				synchronize_net();
L
Linus Torvalds 已提交
1111 1112 1113 1114 1115 1116
				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);
1117
				ipgre_tunnel_link(ign, t);
L
Linus Torvalds 已提交
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127
				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;
1128 1129
				if (t->parms.link != p.link) {
					t->parms.link = p.link;
1130
					dev->mtu = ipgre_tunnel_bind_dev(dev);
1131 1132
					netdev_state_change(dev);
				}
L
Linus Torvalds 已提交
1133 1134 1135 1136 1137 1138 1139 1140 1141
			}
			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;
1142
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
1143 1144
			goto done;

1145
		if (dev == ign->fb_tunnel_dev) {
L
Linus Torvalds 已提交
1146 1147 1148 1149
			err = -EFAULT;
			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
				goto done;
			err = -ENOENT;
1150
			if ((t = ipgre_tunnel_locate(net, &p, 0)) == NULL)
L
Linus Torvalds 已提交
1151 1152
				goto done;
			err = -EPERM;
1153
			if (t == netdev_priv(ign->fb_tunnel_dev))
L
Linus Torvalds 已提交
1154 1155 1156
				goto done;
			dev = t->dev;
		}
1157 1158
		unregister_netdevice(dev);
		err = 0;
L
Linus Torvalds 已提交
1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170
		break;

	default:
		err = -EINVAL;
	}

done:
	return err;
}

static int ipgre_tunnel_change_mtu(struct net_device *dev, int new_mtu)
{
1171
	struct ip_tunnel *tunnel = netdev_priv(dev);
H
Herbert Xu 已提交
1172 1173
	if (new_mtu < 68 ||
	    new_mtu > 0xFFF8 - dev->hard_header_len - tunnel->hlen)
L
Linus Torvalds 已提交
1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187
		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).
1188

L
Linus Torvalds 已提交
1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
   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
   ...

 */

1208 1209
static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
			unsigned short type,
E
Eric Dumazet 已提交
1210
			const void *daddr, const void *saddr, unsigned int len)
L
Linus Torvalds 已提交
1211
{
1212
	struct ip_tunnel *t = netdev_priv(dev);
L
Linus Torvalds 已提交
1213
	struct iphdr *iph = (struct iphdr *)skb_push(skb, t->hlen);
D
Daniel Baluta 已提交
1214
	__be16 *p = (__be16 *)(iph+1);
L
Linus Torvalds 已提交
1215 1216 1217 1218 1219 1220

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

	/*
1221
	 *	Set the source hardware address.
L
Linus Torvalds 已提交
1222
	 */
1223

L
Linus Torvalds 已提交
1224 1225
	if (saddr)
		memcpy(&iph->saddr, saddr, 4);
1226
	if (daddr)
L
Linus Torvalds 已提交
1227
		memcpy(&iph->daddr, daddr, 4);
1228
	if (iph->daddr)
L
Linus Torvalds 已提交
1229
		return t->hlen;
1230

L
Linus Torvalds 已提交
1231 1232 1233
	return -t->hlen;
}

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

1241 1242
static const struct header_ops ipgre_header_ops = {
	.create	= ipgre_header,
1243
	.parse	= ipgre_header_parse,
1244 1245
};

1246
#ifdef CONFIG_NET_IPGRE_BROADCAST
L
Linus Torvalds 已提交
1247 1248
static int ipgre_open(struct net_device *dev)
{
1249
	struct ip_tunnel *t = netdev_priv(dev);
L
Linus Torvalds 已提交
1250

1251
	if (ipv4_is_multicast(t->parms.iph.daddr)) {
1252 1253 1254 1255 1256 1257 1258 1259 1260
		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);
1261
		if (IS_ERR(rt))
L
Linus Torvalds 已提交
1262
			return -EADDRNOTAVAIL;
1263
		dev = rt->dst.dev;
L
Linus Torvalds 已提交
1264
		ip_rt_put(rt);
1265
		if (__in_dev_get_rtnl(dev) == NULL)
L
Linus Torvalds 已提交
1266 1267
			return -EADDRNOTAVAIL;
		t->mlink = dev->ifindex;
1268
		ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
L
Linus Torvalds 已提交
1269 1270 1271 1272 1273 1274
	}
	return 0;
}

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

1277
	if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
1278
		struct in_device *in_dev;
1279
		in_dev = inetdev_by_index(dev_net(dev), t->mlink);
1280
		if (in_dev)
L
Linus Torvalds 已提交
1281 1282 1283 1284 1285 1286 1287
			ip_mc_dec_group(in_dev, t->parms.iph.daddr);
	}
	return 0;
}

#endif

1288 1289 1290 1291 1292 1293 1294 1295 1296 1297
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,
1298
	.ndo_get_stats64	= ipgre_get_stats64,
1299 1300
};

E
Eric Dumazet 已提交
1301 1302
static void ipgre_dev_free(struct net_device *dev)
{
E
Eric Dumazet 已提交
1303 1304 1305
	struct ip_tunnel *tunnel = netdev_priv(dev);

	gro_cells_destroy(&tunnel->gro_cells);
E
Eric Dumazet 已提交
1306 1307 1308 1309
	free_percpu(dev->tstats);
	free_netdev(dev);
}

E
Eric Dumazet 已提交
1310 1311 1312 1313 1314
#define GRE_FEATURES (NETIF_F_SG |		\
		      NETIF_F_FRAGLIST |	\
		      NETIF_F_HIGHDMA |		\
		      NETIF_F_HW_CSUM)

L
Linus Torvalds 已提交
1315 1316
static void ipgre_tunnel_setup(struct net_device *dev)
{
1317
	dev->netdev_ops		= &ipgre_netdev_ops;
E
Eric Dumazet 已提交
1318
	dev->destructor 	= ipgre_dev_free;
L
Linus Torvalds 已提交
1319 1320

	dev->type		= ARPHRD_IPGRE;
H
Herbert Xu 已提交
1321
	dev->needed_headroom 	= LL_MAX_HEADER + sizeof(struct iphdr) + 4;
1322
	dev->mtu		= ETH_DATA_LEN - sizeof(struct iphdr) - 4;
L
Linus Torvalds 已提交
1323 1324 1325
	dev->flags		= IFF_NOARP;
	dev->iflink		= 0;
	dev->addr_len		= 4;
1326
	dev->features		|= NETIF_F_NETNS_LOCAL;
1327
	dev->priv_flags		&= ~IFF_XMIT_DST_RELEASE;
E
Eric Dumazet 已提交
1328 1329 1330

	dev->features		|= GRE_FEATURES;
	dev->hw_features	|= GRE_FEATURES;
L
Linus Torvalds 已提交
1331 1332 1333 1334 1335 1336
}

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

1339
	tunnel = netdev_priv(dev);
L
Linus Torvalds 已提交
1340 1341 1342 1343 1344 1345 1346 1347 1348 1349
	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
1350
		if (ipv4_is_multicast(iph->daddr)) {
L
Linus Torvalds 已提交
1351 1352 1353
			if (!iph->saddr)
				return -EINVAL;
			dev->flags = IFF_BROADCAST;
1354
			dev->header_ops = &ipgre_header_ops;
L
Linus Torvalds 已提交
1355 1356
		}
#endif
1357
	} else
1358
		dev->header_ops = &ipgre_header_ops;
L
Linus Torvalds 已提交
1359

E
Eric Dumazet 已提交
1360 1361 1362 1363
	dev->tstats = alloc_percpu(struct pcpu_tstats);
	if (!dev->tstats)
		return -ENOMEM;

E
Eric Dumazet 已提交
1364 1365 1366 1367 1368 1369
	err = gro_cells_init(&tunnel->gro_cells, dev);
	if (err) {
		free_percpu(dev->tstats);
		return err;
	}

L
Linus Torvalds 已提交
1370 1371 1372
	return 0;
}

1373
static void ipgre_fb_tunnel_init(struct net_device *dev)
L
Linus Torvalds 已提交
1374
{
1375
	struct ip_tunnel *tunnel = netdev_priv(dev);
L
Linus Torvalds 已提交
1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389
	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);
}


1390 1391 1392
static const struct gre_protocol ipgre_protocol = {
	.handler     = ipgre_rcv,
	.err_handler = ipgre_err,
L
Linus Torvalds 已提交
1393 1394
};

1395
static void ipgre_destroy_tunnels(struct ipgre_net *ign, struct list_head *head)
1396 1397 1398 1399 1400 1401
{
	int prio;

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

			t = rtnl_dereference(ign->tunnels[prio][h]);
1405 1406 1407

			while (t != NULL) {
				unregister_netdevice_queue(t->dev, head);
E
Eric Dumazet 已提交
1408
				t = rtnl_dereference(t->next);
1409
			}
1410 1411 1412 1413
		}
	}
}

1414
static int __net_init ipgre_init_net(struct net *net)
1415
{
1416
	struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1417 1418
	int err;

1419 1420 1421 1422 1423 1424
	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;
	}
1425
	dev_net_set(ign->fb_tunnel_dev, net);
1426

1427
	ipgre_fb_tunnel_init(ign->fb_tunnel_dev);
H
Herbert Xu 已提交
1428
	ign->fb_tunnel_dev->rtnl_link_ops = &ipgre_link_ops;
1429 1430 1431 1432

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

E
Eric Dumazet 已提交
1433 1434
	rcu_assign_pointer(ign->tunnels_wc[0],
			   netdev_priv(ign->fb_tunnel_dev));
1435 1436
	return 0;

1437
err_reg_dev:
E
Eric Dumazet 已提交
1438
	ipgre_dev_free(ign->fb_tunnel_dev);
1439
err_alloc_dev:
1440 1441 1442
	return err;
}

1443
static void __net_exit ipgre_exit_net(struct net *net)
1444 1445
{
	struct ipgre_net *ign;
1446
	LIST_HEAD(list);
1447 1448

	ign = net_generic(net, ipgre_net_id);
1449
	rtnl_lock();
1450 1451
	ipgre_destroy_tunnels(ign, &list);
	unregister_netdevice_many(&list);
1452
	rtnl_unlock();
1453 1454 1455 1456 1457
}

static struct pernet_operations ipgre_net_ops = {
	.init = ipgre_init_net,
	.exit = ipgre_exit_net,
1458 1459
	.id   = &ipgre_net_id,
	.size = sizeof(struct ipgre_net),
1460
};
L
Linus Torvalds 已提交
1461

H
Herbert Xu 已提交
1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479
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;
}

1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503
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 已提交
1504 1505 1506
static void ipgre_netlink_parms(struct nlattr *data[],
				struct ip_tunnel_parm *parms)
{
1507
	memset(parms, 0, sizeof(*parms));
H
Herbert Xu 已提交
1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529

	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])
1530
		parms->iph.saddr = nla_get_be32(data[IFLA_GRE_LOCAL]);
H
Herbert Xu 已提交
1531 1532

	if (data[IFLA_GRE_REMOTE])
1533
		parms->iph.daddr = nla_get_be32(data[IFLA_GRE_REMOTE]);
H
Herbert Xu 已提交
1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544

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

1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
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 已提交
1556 1557 1558 1559
	dev->tstats = alloc_percpu(struct pcpu_tstats);
	if (!dev->tstats)
		return -ENOMEM;

1560 1561 1562
	return 0;
}

1563 1564 1565 1566 1567 1568 1569
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,
1570
	.ndo_get_stats64	= ipgre_get_stats64,
1571 1572
};

1573 1574 1575 1576 1577
static void ipgre_tap_setup(struct net_device *dev)
{

	ether_setup(dev);

1578
	dev->netdev_ops		= &ipgre_tap_netdev_ops;
E
Eric Dumazet 已提交
1579
	dev->destructor 	= ipgre_dev_free;
1580 1581 1582 1583 1584

	dev->iflink		= 0;
	dev->features		|= NETIF_F_NETNS_LOCAL;
}

1585
static int ipgre_newlink(struct net *src_net, struct net_device *dev, struct nlattr *tb[],
H
Herbert Xu 已提交
1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596
			 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);

1597
	if (ipgre_tunnel_find(net, &nt->parms, dev->type))
H
Herbert Xu 已提交
1598 1599
		return -EEXIST;

1600
	if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])
1601
		eth_hw_addr_random(dev);
1602

H
Herbert Xu 已提交
1603 1604 1605 1606
	mtu = ipgre_tunnel_bind_dev(dev);
	if (!tb[IFLA_MTU])
		dev->mtu = mtu;

E
Eric Dumazet 已提交
1607 1608 1609 1610
	/* 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 已提交
1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644
	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;

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

1648 1649 1650 1651 1652 1653 1654 1655 1656
			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 已提交
1657 1658 1659 1660 1661

		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;
1662 1663 1664 1665
		if (dev->type != ARPHRD_ETHER) {
			memcpy(dev->dev_addr, &p.iph.saddr, 4);
			memcpy(dev->broadcast, &p.iph.daddr, 4);
		}
H
Herbert Xu 已提交
1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
		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 已提交
1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728
	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 已提交
1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740
	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 },
1741 1742
	[IFLA_GRE_LOCAL]	= { .len = FIELD_SIZEOF(struct iphdr, saddr) },
	[IFLA_GRE_REMOTE]	= { .len = FIELD_SIZEOF(struct iphdr, daddr) },
H
Herbert Xu 已提交
1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760
	[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,
};

1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773
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 已提交
1774 1775 1776 1777 1778 1779 1780 1781
/*
 *	And now the modules code and kernel interface.
 */

static int __init ipgre_init(void)
{
	int err;

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

1784
	err = register_pernet_device(&ipgre_net_ops);
1785
	if (err < 0)
1786 1787
		return err;

1788
	err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
1789
	if (err < 0) {
J
Joe Perches 已提交
1790
		pr_info("%s: can't add protocol\n", __func__);
1791 1792
		goto add_proto_failed;
	}
1793

H
Herbert Xu 已提交
1794 1795 1796 1797
	err = rtnl_link_register(&ipgre_link_ops);
	if (err < 0)
		goto rtnl_link_failed;

1798 1799 1800 1801
	err = rtnl_link_register(&ipgre_tap_ops);
	if (err < 0)
		goto tap_ops_failed;

H
Herbert Xu 已提交
1802
out:
L
Linus Torvalds 已提交
1803
	return err;
H
Herbert Xu 已提交
1804

1805 1806
tap_ops_failed:
	rtnl_link_unregister(&ipgre_link_ops);
H
Herbert Xu 已提交
1807
rtnl_link_failed:
1808
	gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1809 1810
add_proto_failed:
	unregister_pernet_device(&ipgre_net_ops);
H
Herbert Xu 已提交
1811
	goto out;
L
Linus Torvalds 已提交
1812 1813
}

1814
static void __exit ipgre_fini(void)
L
Linus Torvalds 已提交
1815
{
1816
	rtnl_link_unregister(&ipgre_tap_ops);
H
Herbert Xu 已提交
1817
	rtnl_link_unregister(&ipgre_link_ops);
1818
	if (gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO) < 0)
J
Joe Perches 已提交
1819
		pr_info("%s: can't remove protocol\n", __func__);
1820
	unregister_pernet_device(&ipgre_net_ops);
L
Linus Torvalds 已提交
1821 1822 1823 1824 1825
}

module_init(ipgre_init);
module_exit(ipgre_fini);
MODULE_LICENSE("GPL");
1826 1827
MODULE_ALIAS_RTNL_LINK("gre");
MODULE_ALIAS_RTNL_LINK("gretap");
1828
MODULE_ALIAS_NETDEV("gre0");