ip_gre.c 31.6 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
#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>
27
#include <linux/if_vlan.h>
L
Linus Torvalds 已提交
28 29 30 31 32
#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

#include <net/sock.h>
#include <net/ip.h>
#include <net/icmp.h>
#include <net/protocol.h>
40
#include <net/ip_tunnels.h>
L
Linus Torvalds 已提交
41 42 43 44 45
#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>
50
#include <net/dst_metadata.h>
L
Linus Torvalds 已提交
51

E
Eric Dumazet 已提交
52
#if IS_ENABLED(CONFIG_IPV6)
L
Linus Torvalds 已提交
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
#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 已提交
70
   and silently drop packet when it expires. It is a good
71
   solution, but it supposes maintaining new variable in ALL
L
Linus Torvalds 已提交
72 73
   skb, even if no tunneling is used.

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

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

   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
104
   rapidly degrades to value <68, where looping stops.
L
Linus Torvalds 已提交
105 106 107 108 109 110 111 112 113 114
   Yes, it is not good if there exists a router in the loop,
   which does not force DF, even when encapsulating packets have DF set.
   But it is not our problem! Nobody could accuse us, we made
   all that we could make. Even if it is your gated who injected
   fatal route to network, even if it were you who configured
   fatal static route: you are innocent. :-)

   Alexey Kuznetsov.
 */

115 116 117 118
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 已提交
119
static struct rtnl_link_ops ipgre_link_ops __read_mostly;
L
Linus Torvalds 已提交
120
static int ipgre_tunnel_init(struct net_device *dev);
121

122
static int ipgre_net_id __read_mostly;
123
static int gre_tap_net_id __read_mostly;
L
Linus Torvalds 已提交
124

125 126
static void ipgre_err(struct sk_buff *skb, u32 info,
		      const struct tnl_ptk_info *tpi)
L
Linus Torvalds 已提交
127 128
{

129 130 131
	/* All the routers (except for Linux) return only
	   8 bytes of packet payload. It means, that precise relaying of
	   ICMP in the real Internet is absolutely infeasible.
L
Linus Torvalds 已提交
132

133 134 135 136
	   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".
L
Linus Torvalds 已提交
137

138 139 140 141 142 143
	   Well, I wonder, rfc1812 was written by Cisco employee,
	   what the hell these idiots break standards established
	   by themselves???
	   */
	struct net *net = dev_net(skb->dev);
	struct ip_tunnel_net *itn;
144
	const struct iphdr *iph;
145 146
	const int type = icmp_hdr(skb)->type;
	const int code = icmp_hdr(skb)->code;
L
Linus Torvalds 已提交
147 148 149 150 151
	struct ip_tunnel *t;

	switch (type) {
	default:
	case ICMP_PARAMETERPROB:
152
		return;
L
Linus Torvalds 已提交
153 154 155 156 157 158

	case ICMP_DEST_UNREACH:
		switch (code) {
		case ICMP_SR_FAILED:
		case ICMP_PORT_UNREACH:
			/* Impossible event. */
159
			return;
L
Linus Torvalds 已提交
160 161 162 163 164 165 166 167
		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;
168

L
Linus Torvalds 已提交
169 170
	case ICMP_TIME_EXCEEDED:
		if (code != ICMP_EXC_TTL)
171
			return;
L
Linus Torvalds 已提交
172
		break;
173 174 175

	case ICMP_REDIRECT:
		break;
L
Linus Torvalds 已提交
176 177
	}

178
	if (tpi->proto == htons(ETH_P_TEB))
179 180 181 182
		itn = net_generic(net, gre_tap_net_id);
	else
		itn = net_generic(net, ipgre_net_id);

183
	iph = (const struct iphdr *)(icmp_hdr(skb) + 1);
184 185
	t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
			     iph->daddr, iph->saddr, tpi->key);
S
stephen hemminger 已提交
186

187
	if (!t)
188
		return;
189 190

	if (t->parms.iph.daddr == 0 ||
191
	    ipv4_is_multicast(t->parms.iph.daddr))
192
		return;
L
Linus Torvalds 已提交
193 194

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

197
	if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
L
Linus Torvalds 已提交
198 199 200 201
		t->err_count++;
	else
		t->err_count = 1;
	t->err_time = jiffies;
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
}

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

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

225
	if (gre_parse_header(skb, &tpi, &csum_err) < 0) {
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
		if (!csum_err)		/* ignore csum errors. */
			return;
	}

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

	ipgre_err(skb, info, &tpi);
L
Linus Torvalds 已提交
242 243
}

244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
static __be64 key_to_tunnel_id(__be32 key)
{
#ifdef __BIG_ENDIAN
	return (__force __be64)((__force u32)key);
#else
	return (__force __be64)((__force u64)key << 32);
#endif
}

/* Returns the least-significant 32 bits of a __be64. */
static __be32 tunnel_id_to_key(__be64 x)
{
#ifdef __BIG_ENDIAN
	return (__force __be32)x;
#else
	return (__force __be32)((__force u64)x >> 32);
#endif
}

263 264
static int __ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
		       struct ip_tunnel_net *itn, int hdr_len, bool raw_proto)
L
Linus Torvalds 已提交
265
{
266
	struct metadata_dst *tun_dst = NULL;
267
	const struct iphdr *iph;
L
Linus Torvalds 已提交
268 269
	struct ip_tunnel *tunnel;

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

S
stephen hemminger 已提交
274
	if (tunnel) {
275 276
		if (__iptunnel_pull_header(skb, hdr_len, tpi->proto,
					   raw_proto, false) < 0)
277 278
			goto drop;

279
		skb_pop_mac_header(skb);
280
		if (tunnel->collect_md) {
281 282
			__be16 flags;
			__be64 tun_id;
283

284 285 286
			flags = tpi->flags & (TUNNEL_CSUM | TUNNEL_KEY);
			tun_id = key_to_tunnel_id(tpi->key);
			tun_dst = ip_tun_rx_dst(skb, flags, tun_id, 0);
287 288 289 290 291
			if (!tun_dst)
				return PACKET_REJECT;
		}

		ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error);
292
		return PACKET_RCVD;
L
Linus Torvalds 已提交
293
	}
294
	return PACKET_NEXT;
295 296 297 298

drop:
	kfree_skb(skb);
	return PACKET_RCVD;
L
Linus Torvalds 已提交
299 300
}

301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
		     int hdr_len)
{
	struct net *net = dev_net(skb->dev);
	struct ip_tunnel_net *itn;
	int res;

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

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

324 325 326 327
static int gre_rcv(struct sk_buff *skb)
{
	struct tnl_ptk_info tpi;
	bool csum_err = false;
328
	int hdr_len;
329 330 331 332 333 334 335 336 337

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

338 339
	hdr_len = gre_parse_header(skb, &tpi, &csum_err);
	if (hdr_len < 0)
340 341
		goto drop;

342
	if (ipgre_rcv(skb, &tpi, hdr_len) == PACKET_RCVD)
343 344 345 346 347 348 349 350
		return 0;

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

351 352 353 354 355
static void __gre_xmit(struct sk_buff *skb, struct net_device *dev,
		       const struct iphdr *tnl_params,
		       __be16 proto)
{
	struct ip_tunnel *tunnel = netdev_priv(dev);
L
Linus Torvalds 已提交
356

357 358
	if (tunnel->parms.o_flags & TUNNEL_SEQ)
		tunnel->o_seqno++;
L
Linus Torvalds 已提交
359

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

365
	skb_set_inner_protocol(skb, proto);
366
	ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol);
367
}
L
Linus Torvalds 已提交
368

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

374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390
static struct rtable *gre_get_rt(struct sk_buff *skb,
				 struct net_device *dev,
				 struct flowi4 *fl,
				 const struct ip_tunnel_key *key)
{
	struct net *net = dev_net(dev);

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

	return ip_route_output_key(net, fl);
}

391 392
static void gre_fb_xmit(struct sk_buff *skb, struct net_device *dev,
			__be16 proto)
393 394 395
{
	struct ip_tunnel_info *tun_info;
	const struct ip_tunnel_key *key;
396
	struct rtable *rt = NULL;
397 398 399 400
	struct flowi4 fl;
	int min_headroom;
	int tunnel_hlen;
	__be16 df, flags;
401
	bool use_cache;
402 403
	int err;

404
	tun_info = skb_tunnel_info(skb);
405 406
	if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
		     ip_tunnel_info_af(tun_info) != AF_INET))
407 408 409
		goto err_free_skb;

	key = &tun_info->key;
410 411 412
	use_cache = ip_tunnel_dst_cache_usable(skb, tun_info);
	if (use_cache)
		rt = dst_cache_get_ip4(&tun_info->dst_cache, &fl.saddr);
413 414 415 416
	if (!rt) {
		rt = gre_get_rt(skb, dev, &fl, key);
		if (IS_ERR(rt))
				goto err_free_skb;
417
		if (use_cache)
418 419 420
			dst_cache_set_ip4(&tun_info->dst_cache, &rt->dst,
					  fl.saddr);
	}
421

422
	tunnel_hlen = gre_calc_hlen(key->tun_flags);
423 424 425 426 427 428 429 430 431 432 433 434 435 436

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

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

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

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

	iptunnel_xmit(skb->sk, rt, skb, fl.saddr, key->u.ipv4.dst, IPPROTO_GRE,
		      key->tos, key->ttl, df, false);
448 449 450 451 452 453 454 455 456
	return;

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

457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474
static int gre_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
{
	struct ip_tunnel_info *info = skb_tunnel_info(skb);
	struct rtable *rt;
	struct flowi4 fl4;

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

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

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

475 476 477 478 479
static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
			      struct net_device *dev)
{
	struct ip_tunnel *tunnel = netdev_priv(dev);
	const struct iphdr *tnl_params;
L
Linus Torvalds 已提交
480

481
	if (tunnel->collect_md) {
482
		gre_fb_xmit(skb, dev, skb->protocol);
483 484 485
		return NETDEV_TX_OK;
	}

486 487 488
	if (dev->header_ops) {
		/* Need space for new headers */
		if (skb_cow_head(skb, dev->needed_headroom -
489
				      (tunnel->hlen + sizeof(struct iphdr))))
490
			goto free_skb;
L
Linus Torvalds 已提交
491

492
		tnl_params = (const struct iphdr *)skb->data;
L
Linus Torvalds 已提交
493

494 495 496 497
		/* Pull skb since ip_tunnel_xmit() needs skb->data pointing
		 * to gre header.
		 */
		skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
498
		skb_reset_mac_header(skb);
499 500 501
	} else {
		if (skb_cow_head(skb, dev->needed_headroom))
			goto free_skb;
L
Linus Torvalds 已提交
502

503
		tnl_params = &tunnel->parms.iph;
L
Linus Torvalds 已提交
504 505
	}

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

509
	__gre_xmit(skb, dev, tnl_params, skb->protocol);
510
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
511

512
free_skb:
E
Eric Dumazet 已提交
513
	kfree_skb(skb);
514
	dev->stats.tx_dropped++;
515
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
516 517
}

518 519
static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
				struct net_device *dev)
520
{
521
	struct ip_tunnel *tunnel = netdev_priv(dev);
522

523
	if (tunnel->collect_md) {
524
		gre_fb_xmit(skb, dev, htons(ETH_P_TEB));
525 526 527
		return NETDEV_TX_OK;
	}

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

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

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

537
free_skb:
E
Eric Dumazet 已提交
538
	kfree_skb(skb);
539 540
	dev->stats.tx_dropped++;
	return NETDEV_TX_OK;
541 542
}

543 544
static int ipgre_tunnel_ioctl(struct net_device *dev,
			      struct ifreq *ifr, int cmd)
L
Linus Torvalds 已提交
545
{
546
	int err;
L
Linus Torvalds 已提交
547 548
	struct ip_tunnel_parm p;

549 550
	if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
		return -EFAULT;
C
Cong Wang 已提交
551 552 553 554 555
	if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
		if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
		    p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
		    ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
			return -EINVAL;
L
Linus Torvalds 已提交
556
	}
557 558
	p.i_flags = gre_flags_to_tnl_flags(p.i_flags);
	p.o_flags = gre_flags_to_tnl_flags(p.o_flags);
L
Linus Torvalds 已提交
559

560 561 562
	err = ip_tunnel_ioctl(dev, &p, cmd);
	if (err)
		return err;
L
Linus Torvalds 已提交
563

564 565
	p.i_flags = gre_tnl_flags_to_gre_flags(p.i_flags);
	p.o_flags = gre_tnl_flags_to_gre_flags(p.o_flags);
566 567 568

	if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
		return -EFAULT;
L
Linus Torvalds 已提交
569 570 571 572 573 574 575 576 577 578 579 580
	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).
581

L
Linus Torvalds 已提交
582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
   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
   ...
 */
599 600
static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
			unsigned short type,
E
Eric Dumazet 已提交
601
			const void *daddr, const void *saddr, unsigned int len)
L
Linus Torvalds 已提交
602
{
603
	struct ip_tunnel *t = netdev_priv(dev);
604 605
	struct iphdr *iph;
	struct gre_base_hdr *greh;
L
Linus Torvalds 已提交
606

607 608
	iph = (struct iphdr *)skb_push(skb, t->hlen + sizeof(*iph));
	greh = (struct gre_base_hdr *)(iph+1);
609
	greh->flags = gre_tnl_flags_to_gre_flags(t->parms.o_flags);
610
	greh->protocol = htons(type);
L
Linus Torvalds 已提交
611

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

614
	/* Set the source hardware address. */
L
Linus Torvalds 已提交
615 616
	if (saddr)
		memcpy(&iph->saddr, saddr, 4);
617
	if (daddr)
L
Linus Torvalds 已提交
618
		memcpy(&iph->daddr, daddr, 4);
619
	if (iph->daddr)
620
		return t->hlen + sizeof(*iph);
621

622
	return -(t->hlen + sizeof(*iph));
L
Linus Torvalds 已提交
623 624
}

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

632 633
static const struct header_ops ipgre_header_ops = {
	.create	= ipgre_header,
634
	.parse	= ipgre_header_parse,
635 636
};

637
#ifdef CONFIG_NET_IPGRE_BROADCAST
L
Linus Torvalds 已提交
638 639
static int ipgre_open(struct net_device *dev)
{
640
	struct ip_tunnel *t = netdev_priv(dev);
L
Linus Torvalds 已提交
641

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

N
Nicolas Dichtel 已提交
646
		rt = ip_route_output_gre(t->net, &fl4,
647 648 649 650 651
					 t->parms.iph.daddr,
					 t->parms.iph.saddr,
					 t->parms.o_key,
					 RT_TOS(t->parms.iph.tos),
					 t->parms.link);
652
		if (IS_ERR(rt))
L
Linus Torvalds 已提交
653
			return -EADDRNOTAVAIL;
654
		dev = rt->dst.dev;
L
Linus Torvalds 已提交
655
		ip_rt_put(rt);
656
		if (!__in_dev_get_rtnl(dev))
L
Linus Torvalds 已提交
657 658
			return -EADDRNOTAVAIL;
		t->mlink = dev->ifindex;
659
		ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
L
Linus Torvalds 已提交
660 661 662 663 664 665
	}
	return 0;
}

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

668
	if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
669
		struct in_device *in_dev;
N
Nicolas Dichtel 已提交
670
		in_dev = inetdev_by_index(t->net, t->mlink);
671
		if (in_dev)
L
Linus Torvalds 已提交
672 673 674 675 676 677
			ip_mc_dec_group(in_dev, t->parms.iph.daddr);
	}
	return 0;
}
#endif

678 679
static const struct net_device_ops ipgre_netdev_ops = {
	.ndo_init		= ipgre_tunnel_init,
680
	.ndo_uninit		= ip_tunnel_uninit,
681 682 683 684
#ifdef CONFIG_NET_IPGRE_BROADCAST
	.ndo_open		= ipgre_open,
	.ndo_stop		= ipgre_close,
#endif
685
	.ndo_start_xmit		= ipgre_xmit,
686
	.ndo_do_ioctl		= ipgre_tunnel_ioctl,
687 688
	.ndo_change_mtu		= ip_tunnel_change_mtu,
	.ndo_get_stats64	= ip_tunnel_get_stats64,
689
	.ndo_get_iflink		= ip_tunnel_get_iflink,
690 691
};

E
Eric Dumazet 已提交
692 693 694 695 696
#define GRE_FEATURES (NETIF_F_SG |		\
		      NETIF_F_FRAGLIST |	\
		      NETIF_F_HIGHDMA |		\
		      NETIF_F_HW_CSUM)

L
Linus Torvalds 已提交
697 698
static void ipgre_tunnel_setup(struct net_device *dev)
{
699
	dev->netdev_ops		= &ipgre_netdev_ops;
700
	dev->type		= ARPHRD_IPGRE;
701 702
	ip_tunnel_setup(dev, ipgre_net_id);
}
L
Linus Torvalds 已提交
703

704 705 706
static void __gre_tunnel_init(struct net_device *dev)
{
	struct ip_tunnel *tunnel;
707
	int t_hlen;
708 709

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

713 714 715 716 717 718
	tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;

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

	dev->needed_headroom	= LL_MAX_HEADER + t_hlen + 4;
	dev->mtu		= ETH_DATA_LEN - t_hlen - 4;
E
Eric Dumazet 已提交
719

N
Nicolas Dichtel 已提交
720
	dev->features		|= GRE_FEATURES;
E
Eric Dumazet 已提交
721
	dev->hw_features	|= GRE_FEATURES;
722 723

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

734 735 736 737 738
		/* Can use a lockless transmit, unless we generate
		 * output sequences
		 */
		dev->features |= NETIF_F_LLTX;
	}
L
Linus Torvalds 已提交
739 740 741 742
}

static int ipgre_tunnel_init(struct net_device *dev)
{
743 744
	struct ip_tunnel *tunnel = netdev_priv(dev);
	struct iphdr *iph = &tunnel->parms.iph;
L
Linus Torvalds 已提交
745

746
	__gre_tunnel_init(dev);
L
Linus Torvalds 已提交
747

748 749
	memcpy(dev->dev_addr, &iph->saddr, 4);
	memcpy(dev->broadcast, &iph->daddr, 4);
L
Linus Torvalds 已提交
750

751
	dev->flags		= IFF_NOARP;
752
	netif_keep_dst(dev);
753
	dev->addr_len		= 4;
L
Linus Torvalds 已提交
754

755
	if (iph->daddr && !tunnel->collect_md) {
L
Linus Torvalds 已提交
756
#ifdef CONFIG_NET_IPGRE_BROADCAST
757
		if (ipv4_is_multicast(iph->daddr)) {
L
Linus Torvalds 已提交
758 759 760
			if (!iph->saddr)
				return -EINVAL;
			dev->flags = IFF_BROADCAST;
761
			dev->header_ops = &ipgre_header_ops;
L
Linus Torvalds 已提交
762 763
		}
#endif
764
	} else if (!tunnel->collect_md) {
765
		dev->header_ops = &ipgre_header_ops;
766
	}
L
Linus Torvalds 已提交
767

768
	return ip_tunnel_init(dev);
L
Linus Torvalds 已提交
769 770
}

771 772 773
static const struct gre_protocol ipgre_protocol = {
	.handler     = gre_rcv,
	.err_handler = gre_err,
L
Linus Torvalds 已提交
774 775
};

776
static int __net_init ipgre_init_net(struct net *net)
777
{
778
	return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
779 780
}

781
static void __net_exit ipgre_exit_net(struct net *net)
782
{
783
	struct ip_tunnel_net *itn = net_generic(net, ipgre_net_id);
N
Nicolas Dichtel 已提交
784
	ip_tunnel_delete_net(itn, &ipgre_link_ops);
785 786 787 788 789
}

static struct pernet_operations ipgre_net_ops = {
	.init = ipgre_init_net,
	.exit = ipgre_exit_net,
790
	.id   = &ipgre_net_id,
791
	.size = sizeof(struct ip_tunnel_net),
792
};
L
Linus Torvalds 已提交
793

H
Herbert Xu 已提交
794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
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;

809 810 811 812 813
	if (data[IFLA_GRE_COLLECT_METADATA] &&
	    data[IFLA_GRE_ENCAP_TYPE] &&
	    nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]) != TUNNEL_ENCAP_NONE)
		return -EINVAL;

H
Herbert Xu 已提交
814 815 816
	return 0;
}

817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840
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);
}

841 842 843 844
static void ipgre_netlink_parms(struct net_device *dev,
				struct nlattr *data[],
				struct nlattr *tb[],
				struct ip_tunnel_parm *parms)
H
Herbert Xu 已提交
845
{
846
	memset(parms, 0, sizeof(*parms));
H
Herbert Xu 已提交
847 848 849 850 851 852 853 854 855 856

	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])
857
		parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
H
Herbert Xu 已提交
858 859

	if (data[IFLA_GRE_OFLAGS])
860
		parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
H
Herbert Xu 已提交
861 862 863 864 865 866 867 868

	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])
869
		parms->iph.saddr = nla_get_in_addr(data[IFLA_GRE_LOCAL]);
H
Herbert Xu 已提交
870 871

	if (data[IFLA_GRE_REMOTE])
872
		parms->iph.daddr = nla_get_in_addr(data[IFLA_GRE_REMOTE]);
H
Herbert Xu 已提交
873 874 875 876 877 878 879 880 881

	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);
882 883 884 885 886 887

	if (data[IFLA_GRE_COLLECT_METADATA]) {
		struct ip_tunnel *t = netdev_priv(dev);

		t->collect_md = true;
	}
H
Herbert Xu 已提交
888 889
}

890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912
/* This function returns true when ENCAP attributes are present in the nl msg */
static bool ipgre_netlink_encap_parms(struct nlattr *data[],
				      struct ip_tunnel_encap *ipencap)
{
	bool ret = false;

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

	if (!data)
		return ret;

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

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

	if (data[IFLA_GRE_ENCAP_SPORT]) {
		ret = true;
913
		ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]);
914 915 916 917
	}

	if (data[IFLA_GRE_ENCAP_DPORT]) {
		ret = true;
918
		ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]);
919 920 921 922 923
	}

	return ret;
}

924
static int gre_tap_init(struct net_device *dev)
925
{
926
	__gre_tunnel_init(dev);
S
stephen hemminger 已提交
927
	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
928

929
	return ip_tunnel_init(dev);
930 931
}

932 933 934 935
static const struct net_device_ops gre_tap_netdev_ops = {
	.ndo_init		= gre_tap_init,
	.ndo_uninit		= ip_tunnel_uninit,
	.ndo_start_xmit		= gre_tap_xmit,
936 937
	.ndo_set_mac_address 	= eth_mac_addr,
	.ndo_validate_addr	= eth_validate_addr,
938 939
	.ndo_change_mtu		= ip_tunnel_change_mtu,
	.ndo_get_stats64	= ip_tunnel_get_stats64,
940
	.ndo_get_iflink		= ip_tunnel_get_iflink,
941
	.ndo_fill_metadata_dst	= gre_fill_metadata_dst,
942 943
};

944 945 946
static void ipgre_tap_setup(struct net_device *dev)
{
	ether_setup(dev);
J
Jiri Benc 已提交
947 948 949
	dev->netdev_ops	= &gre_tap_netdev_ops;
	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
	dev->priv_flags	|= IFF_LIVE_ADDR_CHANGE;
950
	ip_tunnel_setup(dev, gre_tap_net_id);
951 952
}

953 954
static int ipgre_newlink(struct net *src_net, struct net_device *dev,
			 struct nlattr *tb[], struct nlattr *data[])
H
Herbert Xu 已提交
955
{
956
	struct ip_tunnel_parm p;
957 958 959 960 961 962 963 964 965
	struct ip_tunnel_encap ipencap;

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

		if (err < 0)
			return err;
	}
H
Herbert Xu 已提交
966

967
	ipgre_netlink_parms(dev, data, tb, &p);
968
	return ip_tunnel_newlink(dev, tb, &p);
H
Herbert Xu 已提交
969 970 971 972 973 974
}

static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
			    struct nlattr *data[])
{
	struct ip_tunnel_parm p;
975 976 977 978 979 980 981 982 983
	struct ip_tunnel_encap ipencap;

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

		if (err < 0)
			return err;
	}
H
Herbert Xu 已提交
984

985
	ipgre_netlink_parms(dev, data, tb, &p);
986
	return ip_tunnel_changelink(dev, tb, &p);
H
Herbert Xu 已提交
987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
}

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) +
1012 1013 1014 1015 1016 1017 1018 1019
		/* IFLA_GRE_ENCAP_TYPE */
		nla_total_size(2) +
		/* IFLA_GRE_ENCAP_FLAGS */
		nla_total_size(2) +
		/* IFLA_GRE_ENCAP_SPORT */
		nla_total_size(2) +
		/* IFLA_GRE_ENCAP_DPORT */
		nla_total_size(2) +
1020 1021
		/* IFLA_GRE_COLLECT_METADATA */
		nla_total_size(0) +
H
Herbert Xu 已提交
1022 1023 1024 1025 1026 1027 1028 1029
		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 已提交
1030
	if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
1031 1032 1033 1034
	    nla_put_be16(skb, IFLA_GRE_IFLAGS,
			 gre_tnl_flags_to_gre_flags(p->i_flags)) ||
	    nla_put_be16(skb, IFLA_GRE_OFLAGS,
			 gre_tnl_flags_to_gre_flags(p->o_flags)) ||
D
David S. Miller 已提交
1035 1036
	    nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
	    nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
1037 1038
	    nla_put_in_addr(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
	    nla_put_in_addr(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
D
David S. Miller 已提交
1039 1040 1041 1042 1043
	    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;
1044 1045 1046

	if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE,
			t->encap.type) ||
1047 1048 1049 1050
	    nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT,
			 t->encap.sport) ||
	    nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT,
			 t->encap.dport) ||
1051
	    nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS,
1052
			t->encap.flags))
1053 1054
		goto nla_put_failure;

1055 1056 1057 1058 1059
	if (t->collect_md) {
		if (nla_put_flag(skb, IFLA_GRE_COLLECT_METADATA))
			goto nla_put_failure;
	}

H
Herbert Xu 已提交
1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071
	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 },
1072 1073
	[IFLA_GRE_LOCAL]	= { .len = FIELD_SIZEOF(struct iphdr, saddr) },
	[IFLA_GRE_REMOTE]	= { .len = FIELD_SIZEOF(struct iphdr, daddr) },
H
Herbert Xu 已提交
1074 1075 1076
	[IFLA_GRE_TTL]		= { .type = NLA_U8 },
	[IFLA_GRE_TOS]		= { .type = NLA_U8 },
	[IFLA_GRE_PMTUDISC]	= { .type = NLA_U8 },
1077 1078 1079 1080
	[IFLA_GRE_ENCAP_TYPE]	= { .type = NLA_U16 },
	[IFLA_GRE_ENCAP_FLAGS]	= { .type = NLA_U16 },
	[IFLA_GRE_ENCAP_SPORT]	= { .type = NLA_U16 },
	[IFLA_GRE_ENCAP_DPORT]	= { .type = NLA_U16 },
1081
	[IFLA_GRE_COLLECT_METADATA]	= { .type = NLA_FLAG },
H
Herbert Xu 已提交
1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
};

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,
1093
	.dellink	= ip_tunnel_dellink,
H
Herbert Xu 已提交
1094 1095
	.get_size	= ipgre_get_size,
	.fill_info	= ipgre_fill_info,
1096
	.get_link_net	= ip_tunnel_get_link_net,
H
Herbert Xu 已提交
1097 1098
};

1099 1100 1101 1102 1103 1104 1105 1106 1107
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,
1108
	.dellink	= ip_tunnel_dellink,
1109 1110
	.get_size	= ipgre_get_size,
	.fill_info	= ipgre_fill_info,
1111
	.get_link_net	= ip_tunnel_get_link_net,
1112 1113
};

1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135
struct net_device *gretap_fb_dev_create(struct net *net, const char *name,
					u8 name_assign_type)
{
	struct nlattr *tb[IFLA_MAX + 1];
	struct net_device *dev;
	struct ip_tunnel *t;
	int err;

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

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

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

	err = ipgre_newlink(net, dev, tb, NULL);
	if (err < 0)
		goto out;
1136 1137 1138 1139 1140 1141 1142 1143

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

1144 1145 1146 1147 1148 1149 1150
	return dev;
out:
	free_netdev(dev);
	return ERR_PTR(err);
}
EXPORT_SYMBOL_GPL(gretap_fb_dev_create);

1151 1152
static int __net_init ipgre_tap_init_net(struct net *net)
{
1153
	return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, "gretap0");
1154 1155 1156 1157 1158
}

static void __net_exit ipgre_tap_exit_net(struct net *net)
{
	struct ip_tunnel_net *itn = net_generic(net, gre_tap_net_id);
N
Nicolas Dichtel 已提交
1159
	ip_tunnel_delete_net(itn, &ipgre_tap_ops);
1160 1161 1162 1163 1164 1165 1166 1167
}

static struct pernet_operations ipgre_tap_net_ops = {
	.init = ipgre_tap_init_net,
	.exit = ipgre_tap_exit_net,
	.id   = &gre_tap_net_id,
	.size = sizeof(struct ip_tunnel_net),
};
L
Linus Torvalds 已提交
1168 1169 1170 1171 1172

static int __init ipgre_init(void)
{
	int err;

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

1175
	err = register_pernet_device(&ipgre_net_ops);
1176
	if (err < 0)
1177 1178
		return err;

1179 1180 1181 1182
	err = register_pernet_device(&ipgre_tap_net_ops);
	if (err < 0)
		goto pnet_tap_faied;

1183
	err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
1184
	if (err < 0) {
J
Joe Perches 已提交
1185
		pr_info("%s: can't add protocol\n", __func__);
1186 1187
		goto add_proto_failed;
	}
1188

H
Herbert Xu 已提交
1189 1190 1191 1192
	err = rtnl_link_register(&ipgre_link_ops);
	if (err < 0)
		goto rtnl_link_failed;

1193 1194 1195 1196
	err = rtnl_link_register(&ipgre_tap_ops);
	if (err < 0)
		goto tap_ops_failed;

1197
	return 0;
H
Herbert Xu 已提交
1198

1199 1200
tap_ops_failed:
	rtnl_link_unregister(&ipgre_link_ops);
H
Herbert Xu 已提交
1201
rtnl_link_failed:
1202
	gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1203
add_proto_failed:
1204 1205
	unregister_pernet_device(&ipgre_tap_net_ops);
pnet_tap_faied:
1206
	unregister_pernet_device(&ipgre_net_ops);
1207
	return err;
L
Linus Torvalds 已提交
1208 1209
}

1210
static void __exit ipgre_fini(void)
L
Linus Torvalds 已提交
1211
{
1212
	rtnl_link_unregister(&ipgre_tap_ops);
H
Herbert Xu 已提交
1213
	rtnl_link_unregister(&ipgre_link_ops);
1214
	gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1215
	unregister_pernet_device(&ipgre_tap_net_ops);
1216
	unregister_pernet_device(&ipgre_net_ops);
L
Linus Torvalds 已提交
1217 1218 1219 1220 1221
}

module_init(ipgre_init);
module_exit(ipgre_fini);
MODULE_LICENSE("GPL");
1222 1223
MODULE_ALIAS_RTNL_LINK("gre");
MODULE_ALIAS_RTNL_LINK("gretap");
1224
MODULE_ALIAS_NETDEV("gre0");
1225
MODULE_ALIAS_NETDEV("gretap0");