ip6_tunnel.c 51.5 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 *	IPv6 tunneling device
L
Linus Torvalds 已提交
3 4 5
 *	Linux INET6 implementation
 *
 *	Authors:
6
 *	Ville Nuorvala		<vnuorval@tcs.hut.fi>
7
 *	Yasuyuki Kozakai	<kozakai@linux-ipv6.org>
L
Linus Torvalds 已提交
8 9
 *
 *      Based on:
10
 *      linux/net/ipv6/sit.c and linux/net/ipv4/ipip.c
L
Linus Torvalds 已提交
11 12 13 14 15 16 17 18 19 20
 *
 *      RFC 2473
 *
 *	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.
 *
 */

21 22
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

L
Linus Torvalds 已提交
23
#include <linux/module.h>
24
#include <linux/capability.h>
L
Linus Torvalds 已提交
25 26 27
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/sockios.h>
28
#include <linux/icmp.h>
L
Linus Torvalds 已提交
29 30 31 32 33 34 35 36 37 38 39 40
#include <linux/if.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/net.h>
#include <linux/in6.h>
#include <linux/netdevice.h>
#include <linux/if_arp.h>
#include <linux/icmpv6.h>
#include <linux/init.h>
#include <linux/route.h>
#include <linux/rtnetlink.h>
#include <linux/netfilter_ipv6.h>
41
#include <linux/slab.h>
E
Eric Dumazet 已提交
42
#include <linux/hash.h>
43
#include <linux/etherdevice.h>
L
Linus Torvalds 已提交
44 45

#include <asm/uaccess.h>
A
Arun Sharma 已提交
46
#include <linux/atomic.h>
L
Linus Torvalds 已提交
47

48
#include <net/icmp.h>
L
Linus Torvalds 已提交
49
#include <net/ip.h>
50
#include <net/ip_tunnels.h>
L
Linus Torvalds 已提交
51 52 53 54 55 56 57
#include <net/ipv6.h>
#include <net/ip6_route.h>
#include <net/addrconf.h>
#include <net/ip6_tunnel.h>
#include <net/xfrm.h>
#include <net/dsfield.h>
#include <net/inet_ecn.h>
58 59
#include <net/net_namespace.h>
#include <net/netns/generic.h>
L
Linus Torvalds 已提交
60 61

MODULE_AUTHOR("Ville Nuorvala");
62
MODULE_DESCRIPTION("IPv6 tunneling device");
L
Linus Torvalds 已提交
63
MODULE_LICENSE("GPL");
64
MODULE_ALIAS_RTNL_LINK("ip6tnl");
S
stephen hemminger 已提交
65
MODULE_ALIAS_NETDEV("ip6tnl0");
L
Linus Torvalds 已提交
66

67 68
#define IP6_TUNNEL_HASH_SIZE_SHIFT  5
#define IP6_TUNNEL_HASH_SIZE (1 << IP6_TUNNEL_HASH_SIZE_SHIFT)
L
Linus Torvalds 已提交
69

70 71 72 73
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");

E
Eric Dumazet 已提交
74 75 76 77
static u32 HASH(const struct in6_addr *addr1, const struct in6_addr *addr2)
{
	u32 hash = ipv6_addr_hash(addr1) ^ ipv6_addr_hash(addr2);

78
	return hash_32(hash, IP6_TUNNEL_HASH_SIZE_SHIFT);
E
Eric Dumazet 已提交
79
}
L
Linus Torvalds 已提交
80

E
Eric Dumazet 已提交
81
static int ip6_tnl_dev_init(struct net_device *dev);
82
static void ip6_tnl_dev_setup(struct net_device *dev);
83
static struct rtnl_link_ops ip6_link_ops __read_mostly;
L
Linus Torvalds 已提交
84

85
static int ip6_tnl_net_id __read_mostly;
86
struct ip6_tnl_net {
87 88
	/* the IPv6 tunnel fallback device */
	struct net_device *fb_tnl_dev;
89
	/* lists for storing tunnels in use */
90
	struct ip6_tnl __rcu *tnls_r_l[IP6_TUNNEL_HASH_SIZE];
E
Eric Dumazet 已提交
91 92
	struct ip6_tnl __rcu *tnls_wc[1];
	struct ip6_tnl __rcu **tnls[2];
93 94
};

E
Eric Dumazet 已提交
95 96
static struct net_device_stats *ip6_get_stats(struct net_device *dev)
{
97
	struct pcpu_sw_netstats tmp, sum = { 0 };
E
Eric Dumazet 已提交
98 99 100
	int i;

	for_each_possible_cpu(i) {
101
		unsigned int start;
102 103
		const struct pcpu_sw_netstats *tstats =
						   per_cpu_ptr(dev->tstats, i);
E
Eric Dumazet 已提交
104

105
		do {
106
			start = u64_stats_fetch_begin_irq(&tstats->syncp);
107 108 109 110
			tmp.rx_packets = tstats->rx_packets;
			tmp.rx_bytes = tstats->rx_bytes;
			tmp.tx_packets = tstats->tx_packets;
			tmp.tx_bytes =  tstats->tx_bytes;
111
		} while (u64_stats_fetch_retry_irq(&tstats->syncp, start));
112 113 114 115 116

		sum.rx_packets += tmp.rx_packets;
		sum.rx_bytes   += tmp.rx_bytes;
		sum.tx_packets += tmp.tx_packets;
		sum.tx_bytes   += tmp.tx_bytes;
E
Eric Dumazet 已提交
117 118 119 120 121 122 123 124
	}
	dev->stats.rx_packets = sum.rx_packets;
	dev->stats.rx_bytes   = sum.rx_bytes;
	dev->stats.tx_packets = sum.tx_packets;
	dev->stats.tx_bytes   = sum.tx_bytes;
	return &dev->stats;
}

L
Linus Torvalds 已提交
125
/**
126
 * ip6_tnl_lookup - fetch tunnel matching the end-point addresses
127 128
 *   @remote: the address of the tunnel exit-point
 *   @local: the address of the tunnel entry-point
L
Linus Torvalds 已提交
129
 *
130
 * Return:
L
Linus Torvalds 已提交
131
 *   tunnel matching given end-points if found,
132
 *   else fallback tunnel if its device is up,
L
Linus Torvalds 已提交
133 134 135
 *   else %NULL
 **/

136 137 138
#define for_each_ip6_tunnel_rcu(start) \
	for (t = rcu_dereference(start); t; t = rcu_dereference(t->next))

L
Linus Torvalds 已提交
139
static struct ip6_tnl *
140
ip6_tnl_lookup(struct net *net, const struct in6_addr *remote, const struct in6_addr *local)
L
Linus Torvalds 已提交
141
{
E
Eric Dumazet 已提交
142
	unsigned int hash = HASH(remote, local);
L
Linus Torvalds 已提交
143
	struct ip6_tnl *t;
144
	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
145
	struct in6_addr any;
L
Linus Torvalds 已提交
146

E
Eric Dumazet 已提交
147
	for_each_ip6_tunnel_rcu(ip6n->tnls_r_l[hash]) {
L
Linus Torvalds 已提交
148 149 150 151 152
		if (ipv6_addr_equal(local, &t->parms.laddr) &&
		    ipv6_addr_equal(remote, &t->parms.raddr) &&
		    (t->dev->flags & IFF_UP))
			return t;
	}
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168

	memset(&any, 0, sizeof(any));
	hash = HASH(&any, local);
	for_each_ip6_tunnel_rcu(ip6n->tnls_r_l[hash]) {
		if (ipv6_addr_equal(local, &t->parms.laddr) &&
		    (t->dev->flags & IFF_UP))
			return t;
	}

	hash = HASH(remote, &any);
	for_each_ip6_tunnel_rcu(ip6n->tnls_r_l[hash]) {
		if (ipv6_addr_equal(remote, &t->parms.raddr) &&
		    (t->dev->flags & IFF_UP))
			return t;
	}

169 170
	t = rcu_dereference(ip6n->tnls_wc[0]);
	if (t && (t->dev->flags & IFF_UP))
L
Linus Torvalds 已提交
171 172 173 174 175 176
		return t;

	return NULL;
}

/**
177
 * ip6_tnl_bucket - get head of list matching given tunnel parameters
178
 *   @p: parameters containing tunnel end-points
L
Linus Torvalds 已提交
179 180
 *
 * Description:
181
 *   ip6_tnl_bucket() returns the head of the list matching the
L
Linus Torvalds 已提交
182 183
 *   &struct in6_addr entries laddr and raddr in @p.
 *
184
 * Return: head of IPv6 tunnel list
L
Linus Torvalds 已提交
185 186
 **/

E
Eric Dumazet 已提交
187
static struct ip6_tnl __rcu **
X
xeb@mail.ru 已提交
188
ip6_tnl_bucket(struct ip6_tnl_net *ip6n, const struct __ip6_tnl_parm *p)
L
Linus Torvalds 已提交
189
{
190 191
	const struct in6_addr *remote = &p->raddr;
	const struct in6_addr *local = &p->laddr;
192
	unsigned int h = 0;
L
Linus Torvalds 已提交
193 194 195 196
	int prio = 0;

	if (!ipv6_addr_any(remote) || !ipv6_addr_any(local)) {
		prio = 1;
E
Eric Dumazet 已提交
197
		h = HASH(remote, local);
L
Linus Torvalds 已提交
198
	}
199
	return &ip6n->tnls[prio][h];
L
Linus Torvalds 已提交
200 201 202
}

/**
203
 * ip6_tnl_link - add tunnel to hash table
L
Linus Torvalds 已提交
204 205 206 207
 *   @t: tunnel to be added
 **/

static void
208
ip6_tnl_link(struct ip6_tnl_net *ip6n, struct ip6_tnl *t)
L
Linus Torvalds 已提交
209
{
E
Eric Dumazet 已提交
210
	struct ip6_tnl __rcu **tp = ip6_tnl_bucket(ip6n, &t->parms);
L
Linus Torvalds 已提交
211

212 213
	rcu_assign_pointer(t->next , rtnl_dereference(*tp));
	rcu_assign_pointer(*tp, t);
L
Linus Torvalds 已提交
214 215 216
}

/**
217
 * ip6_tnl_unlink - remove tunnel from hash table
L
Linus Torvalds 已提交
218 219 220 221
 *   @t: tunnel to be removed
 **/

static void
222
ip6_tnl_unlink(struct ip6_tnl_net *ip6n, struct ip6_tnl *t)
L
Linus Torvalds 已提交
223
{
E
Eric Dumazet 已提交
224 225 226 227 228 229 230
	struct ip6_tnl __rcu **tp;
	struct ip6_tnl *iter;

	for (tp = ip6_tnl_bucket(ip6n, &t->parms);
	     (iter = rtnl_dereference(*tp)) != NULL;
	     tp = &iter->next) {
		if (t == iter) {
231
			rcu_assign_pointer(*tp, t->next);
L
Linus Torvalds 已提交
232 233 234 235 236
			break;
		}
	}
}

E
Eric Dumazet 已提交
237 238
static void ip6_dev_free(struct net_device *dev)
{
239 240
	struct ip6_tnl *t = netdev_priv(dev);

241
	gro_cells_destroy(&t->gro_cells);
242
	dst_cache_destroy(&t->dst_cache);
E
Eric Dumazet 已提交
243 244 245 246
	free_percpu(dev->tstats);
	free_netdev(dev);
}

247 248 249 250 251 252 253 254 255
static int ip6_tnl_create2(struct net_device *dev)
{
	struct ip6_tnl *t = netdev_priv(dev);
	struct net *net = dev_net(dev);
	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
	int err;

	t = netdev_priv(dev);

256
	dev->rtnl_link_ops = &ip6_link_ops;
257 258 259 260 261 262 263 264 265 266 267 268 269 270
	err = register_netdevice(dev);
	if (err < 0)
		goto out;

	strcpy(t->parms.name, dev->name);

	dev_hold(dev);
	ip6_tnl_link(ip6n, t);
	return 0;

out:
	return err;
}

L
Linus Torvalds 已提交
271
/**
272
 * ip6_tnl_create - create a new tunnel
L
Linus Torvalds 已提交
273 274 275 276 277
 *   @p: tunnel parameters
 *   @pt: pointer to new tunnel
 *
 * Description:
 *   Create tunnel matching given parameters.
278 279
 *
 * Return:
280
 *   created tunnel or error pointer
L
Linus Torvalds 已提交
281 282
 **/

X
xeb@mail.ru 已提交
283
static struct ip6_tnl *ip6_tnl_create(struct net *net, struct __ip6_tnl_parm *p)
L
Linus Torvalds 已提交
284 285 286 287
{
	struct net_device *dev;
	struct ip6_tnl *t;
	char name[IFNAMSIZ];
288
	int err = -ENOMEM;
L
Linus Torvalds 已提交
289

290
	if (p->name[0])
L
Linus Torvalds 已提交
291
		strlcpy(name, p->name, IFNAMSIZ);
292 293 294
	else
		sprintf(name, "ip6tnl%%d");

295 296
	dev = alloc_netdev(sizeof(*t), name, NET_NAME_UNKNOWN,
			   ip6_tnl_dev_setup);
297
	if (!dev)
298
		goto failed;
L
Linus Torvalds 已提交
299

300 301
	dev_net_set(dev, net);

302
	t = netdev_priv(dev);
L
Linus Torvalds 已提交
303
	t->parms = *p;
N
Nicolas Dichtel 已提交
304
	t->net = dev_net(dev);
305
	err = ip6_tnl_create2(dev);
E
Eric Dumazet 已提交
306 307
	if (err < 0)
		goto failed_free;
L
Linus Torvalds 已提交
308

309
	return t;
310 311

failed_free:
E
Eric Dumazet 已提交
312
	ip6_dev_free(dev);
313
failed:
314
	return ERR_PTR(err);
L
Linus Torvalds 已提交
315 316 317
}

/**
318
 * ip6_tnl_locate - find or create tunnel matching given parameters
319
 *   @p: tunnel parameters
L
Linus Torvalds 已提交
320 321 322
 *   @create: != 0 if allowed to create new tunnel if no match found
 *
 * Description:
323
 *   ip6_tnl_locate() first tries to locate an existing tunnel
L
Linus Torvalds 已提交
324 325 326 327
 *   based on @parms. If this is unsuccessful, but @create is set a new
 *   tunnel device is created and registered for use.
 *
 * Return:
328
 *   matching tunnel or error pointer
L
Linus Torvalds 已提交
329 330
 **/

331
static struct ip6_tnl *ip6_tnl_locate(struct net *net,
X
xeb@mail.ru 已提交
332
		struct __ip6_tnl_parm *p, int create)
L
Linus Torvalds 已提交
333
{
334 335
	const struct in6_addr *remote = &p->raddr;
	const struct in6_addr *local = &p->laddr;
E
Eric Dumazet 已提交
336
	struct ip6_tnl __rcu **tp;
L
Linus Torvalds 已提交
337
	struct ip6_tnl *t;
338
	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
L
Linus Torvalds 已提交
339

E
Eric Dumazet 已提交
340 341 342
	for (tp = ip6_tnl_bucket(ip6n, p);
	     (t = rtnl_dereference(*tp)) != NULL;
	     tp = &t->next) {
L
Linus Torvalds 已提交
343
		if (ipv6_addr_equal(local, &t->parms.laddr) &&
344 345
		    ipv6_addr_equal(remote, &t->parms.raddr)) {
			if (create)
346
				return ERR_PTR(-EEXIST);
347

348
			return t;
349
		}
L
Linus Torvalds 已提交
350 351
	}
	if (!create)
352
		return ERR_PTR(-ENODEV);
353
	return ip6_tnl_create(net, p);
L
Linus Torvalds 已提交
354 355 356
}

/**
357
 * ip6_tnl_dev_uninit - tunnel device uninitializer
L
Linus Torvalds 已提交
358
 *   @dev: the device to be destroyed
359
 *
L
Linus Torvalds 已提交
360
 * Description:
361
 *   ip6_tnl_dev_uninit() removes tunnel from its list
L
Linus Torvalds 已提交
362 363 364
 **/

static void
365
ip6_tnl_dev_uninit(struct net_device *dev)
L
Linus Torvalds 已提交
366
{
367
	struct ip6_tnl *t = netdev_priv(dev);
N
Nicolas Dichtel 已提交
368
	struct net *net = t->net;
369
	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
L
Linus Torvalds 已提交
370

E
Eric Dumazet 已提交
371
	if (dev == ip6n->fb_tnl_dev)
372
		RCU_INIT_POINTER(ip6n->tnls_wc[0], NULL);
E
Eric Dumazet 已提交
373
	else
374
		ip6_tnl_unlink(ip6n, t);
375
	dst_cache_reset(&t->dst_cache);
L
Linus Torvalds 已提交
376 377 378 379 380 381 382
	dev_put(dev);
}

/**
 * parse_tvl_tnl_enc_lim - handle encapsulation limit option
 *   @skb: received socket buffer
 *
383 384
 * Return:
 *   0 if none was found,
L
Linus Torvalds 已提交
385 386 387
 *   else index to encapsulation limit
 **/

X
xeb@mail.ru 已提交
388
__u16 ip6_tnl_parse_tlv_enc_lim(struct sk_buff *skb, __u8 *raw)
L
Linus Torvalds 已提交
389
{
390
	const struct ipv6hdr *ipv6h = (const struct ipv6hdr *) raw;
L
Linus Torvalds 已提交
391
	__u8 nexthdr = ipv6h->nexthdr;
392
	__u16 off = sizeof(*ipv6h);
L
Linus Torvalds 已提交
393 394 395 396

	while (ipv6_ext_hdr(nexthdr) && nexthdr != NEXTHDR_NONE) {
		__u16 optlen = 0;
		struct ipv6_opt_hdr *hdr;
397
		if (raw + off + sizeof(*hdr) > skb->data &&
L
Linus Torvalds 已提交
398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
		    !pskb_may_pull(skb, raw - skb->data + off + sizeof (*hdr)))
			break;

		hdr = (struct ipv6_opt_hdr *) (raw + off);
		if (nexthdr == NEXTHDR_FRAGMENT) {
			struct frag_hdr *frag_hdr = (struct frag_hdr *) hdr;
			if (frag_hdr->frag_off)
				break;
			optlen = 8;
		} else if (nexthdr == NEXTHDR_AUTH) {
			optlen = (hdr->hdrlen + 2) << 2;
		} else {
			optlen = ipv6_optlen(hdr);
		}
		if (nexthdr == NEXTHDR_DEST) {
			__u16 i = off + 2;
			while (1) {
				struct ipv6_tlv_tnl_enc_lim *tel;

				/* No more room for encapsulation limit */
				if (i + sizeof (*tel) > off + optlen)
					break;

				tel = (struct ipv6_tlv_tnl_enc_lim *) &raw[i];
				/* return index of option if found and valid */
				if (tel->type == IPV6_TLV_TNL_ENCAP_LIMIT &&
				    tel->length == 1)
					return i;
				/* else jump to next option */
				if (tel->type)
					i += tel->length + 2;
				else
					i++;
			}
		}
		nexthdr = hdr->nexthdr;
		off += optlen;
	}
	return 0;
}
X
xeb@mail.ru 已提交
438
EXPORT_SYMBOL(ip6_tnl_parse_tlv_enc_lim);
L
Linus Torvalds 已提交
439 440

/**
441
 * ip6_tnl_err - tunnel error handler
L
Linus Torvalds 已提交
442 443
 *
 * Description:
444
 *   ip6_tnl_err() should handle errors in the tunnel according
L
Linus Torvalds 已提交
445 446 447
 *   to the specifications in RFC 2473.
 **/

H
Herbert Xu 已提交
448
static int
449
ip6_tnl_err(struct sk_buff *skb, __u8 ipproto, struct inet6_skb_parm *opt,
450
	    u8 *type, u8 *code, int *msg, __u32 *info, int offset)
L
Linus Torvalds 已提交
451
{
452
	const struct ipv6hdr *ipv6h = (const struct ipv6hdr *) skb->data;
L
Linus Torvalds 已提交
453 454
	struct ip6_tnl *t;
	int rel_msg = 0;
455 456
	u8 rel_type = ICMPV6_DEST_UNREACH;
	u8 rel_code = ICMPV6_ADDR_UNREACH;
457
	u8 tproto;
L
Linus Torvalds 已提交
458 459
	__u32 rel_info = 0;
	__u16 len;
H
Herbert Xu 已提交
460
	int err = -ENOENT;
L
Linus Torvalds 已提交
461

462 463
	/* If the packet doesn't contain the original IPv6 header we are
	   in trouble since we might need the source address for further
L
Linus Torvalds 已提交
464 465
	   processing of the error. */

466
	rcu_read_lock();
467
	t = ip6_tnl_lookup(dev_net(skb->dev), &ipv6h->daddr, &ipv6h->saddr);
468
	if (!t)
L
Linus Torvalds 已提交
469 470
		goto out;

471 472
	tproto = ACCESS_ONCE(t->parms.proto);
	if (tproto != ipproto && tproto != 0)
473 474
		goto out;

H
Herbert Xu 已提交
475 476
	err = 0;

477
	switch (*type) {
L
Linus Torvalds 已提交
478 479 480 481
		__u32 teli;
		struct ipv6_tlv_tnl_enc_lim *tel;
		__u32 mtu;
	case ICMPV6_DEST_UNREACH:
482 483
		net_dbg_ratelimited("%s: Path to destination invalid or inactive!\n",
				    t->parms.name);
L
Linus Torvalds 已提交
484 485 486
		rel_msg = 1;
		break;
	case ICMPV6_TIME_EXCEED:
487
		if ((*code) == ICMPV6_EXC_HOPLIMIT) {
488 489
			net_dbg_ratelimited("%s: Too small hop limit or routing loop in tunnel!\n",
					    t->parms.name);
L
Linus Torvalds 已提交
490 491 492 493
			rel_msg = 1;
		}
		break;
	case ICMPV6_PARAMPROB:
494
		teli = 0;
495
		if ((*code) == ICMPV6_HDR_FIELD)
X
xeb@mail.ru 已提交
496
			teli = ip6_tnl_parse_tlv_enc_lim(skb, skb->data);
L
Linus Torvalds 已提交
497

A
Al Viro 已提交
498
		if (teli && teli == *info - 2) {
L
Linus Torvalds 已提交
499 500
			tel = (struct ipv6_tlv_tnl_enc_lim *) &skb->data[teli];
			if (tel->encap_limit == 0) {
501 502
				net_dbg_ratelimited("%s: Too small encapsulation limit or routing loop in tunnel!\n",
						    t->parms.name);
L
Linus Torvalds 已提交
503 504
				rel_msg = 1;
			}
505
		} else {
506 507
			net_dbg_ratelimited("%s: Recipient unable to parse tunneled packet!\n",
					    t->parms.name);
L
Linus Torvalds 已提交
508 509 510
		}
		break;
	case ICMPV6_PKT_TOOBIG:
A
Al Viro 已提交
511
		mtu = *info - offset;
L
Linus Torvalds 已提交
512 513 514 515
		if (mtu < IPV6_MIN_MTU)
			mtu = IPV6_MIN_MTU;
		t->dev->mtu = mtu;

516 517
		len = sizeof(*ipv6h) + ntohs(ipv6h->payload_len);
		if (len > mtu) {
L
Linus Torvalds 已提交
518 519 520 521 522 523 524
			rel_type = ICMPV6_PKT_TOOBIG;
			rel_code = 0;
			rel_info = mtu;
			rel_msg = 1;
		}
		break;
	}
525 526 527 528 529 530 531

	*type = rel_type;
	*code = rel_code;
	*info = rel_info;
	*msg = rel_msg;

out:
532
	rcu_read_unlock();
533 534 535
	return err;
}

536 537
static int
ip4ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
538
	   u8 type, u8 code, int offset, __be32 info)
539 540
{
	int rel_msg = 0;
541 542
	u8 rel_type = type;
	u8 rel_code = code;
A
Al Viro 已提交
543
	__u32 rel_info = ntohl(info);
544 545
	int err;
	struct sk_buff *skb2;
546
	const struct iphdr *eiph;
547
	struct rtable *rt;
548
	struct flowi4 fl4;
549

550 551
	err = ip6_tnl_err(skb, IPPROTO_IPIP, opt, &rel_type, &rel_code,
			  &rel_msg, &rel_info, offset);
552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570
	if (err < 0)
		return err;

	if (rel_msg == 0)
		return 0;

	switch (rel_type) {
	case ICMPV6_DEST_UNREACH:
		if (rel_code != ICMPV6_ADDR_UNREACH)
			return 0;
		rel_type = ICMP_DEST_UNREACH;
		rel_code = ICMP_HOST_UNREACH;
		break;
	case ICMPV6_PKT_TOOBIG:
		if (rel_code != 0)
			return 0;
		rel_type = ICMP_DEST_UNREACH;
		rel_code = ICMP_FRAG_NEEDED;
		break;
571 572 573
	case NDISC_REDIRECT:
		rel_type = ICMP_REDIRECT;
		rel_code = ICMP_REDIR_HOST;
574 575 576 577 578 579 580 581 582 583 584
	default:
		return 0;
	}

	if (!pskb_may_pull(skb, offset + sizeof(struct iphdr)))
		return 0;

	skb2 = skb_clone(skb, GFP_ATOMIC);
	if (!skb2)
		return 0;

E
Eric Dumazet 已提交
585 586
	skb_dst_drop(skb2);

587
	skb_pull(skb2, offset);
588
	skb_reset_network_header(skb2);
589
	eiph = ip_hdr(skb2);
590 591

	/* Try to guess incoming interface */
592
	rt = ip_route_output_ports(dev_net(skb->dev), &fl4, NULL,
593 594 595
				   eiph->saddr, 0,
				   0, 0,
				   IPPROTO_IPIP, RT_TOS(eiph->tos), 0);
596
	if (IS_ERR(rt))
597 598
		goto out;

599
	skb2->dev = rt->dst.dev;
600 601 602 603 604

	/* route "incoming" packet */
	if (rt->rt_flags & RTCF_LOCAL) {
		ip_rt_put(rt);
		rt = NULL;
605
		rt = ip_route_output_ports(dev_net(skb->dev), &fl4, NULL,
606 607 608 609
					   eiph->daddr, eiph->saddr,
					   0, 0,
					   IPPROTO_IPIP,
					   RT_TOS(eiph->tos), 0);
610
		if (IS_ERR(rt) ||
611
		    rt->dst.dev->type != ARPHRD_TUNNEL) {
612 613
			if (!IS_ERR(rt))
				ip_rt_put(rt);
614 615
			goto out;
		}
616
		skb_dst_set(skb2, &rt->dst);
617 618 619 620
	} else {
		ip_rt_put(rt);
		if (ip_route_input(skb2, eiph->daddr, eiph->saddr, eiph->tos,
				   skb2->dev) ||
E
Eric Dumazet 已提交
621
		    skb_dst(skb2)->dev->type != ARPHRD_TUNNEL)
622 623 624 625 626
			goto out;
	}

	/* change mtu on this route */
	if (rel_type == ICMP_DEST_UNREACH && rel_code == ICMP_FRAG_NEEDED) {
E
Eric Dumazet 已提交
627
		if (rel_info > dst_mtu(skb_dst(skb2)))
628 629
			goto out;

630
		skb_dst(skb2)->ops->update_pmtu(skb_dst(skb2), NULL, skb2, rel_info);
631
	}
632
	if (rel_type == ICMP_REDIRECT)
633
		skb_dst(skb2)->ops->redirect(skb_dst(skb2), NULL, skb2);
634

A
Al Viro 已提交
635
	icmp_send(skb2, rel_type, rel_code, htonl(rel_info));
636 637 638 639 640 641

out:
	kfree_skb(skb2);
	return 0;
}

642 643
static int
ip6ip6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
644
	   u8 type, u8 code, int offset, __be32 info)
645 646
{
	int rel_msg = 0;
647 648
	u8 rel_type = type;
	u8 rel_code = code;
A
Al Viro 已提交
649
	__u32 rel_info = ntohl(info);
650 651
	int err;

652 653
	err = ip6_tnl_err(skb, IPPROTO_IPV6, opt, &rel_type, &rel_code,
			  &rel_msg, &rel_info, offset);
654 655 656 657
	if (err < 0)
		return err;

	if (rel_msg && pskb_may_pull(skb, offset + sizeof(struct ipv6hdr))) {
L
Linus Torvalds 已提交
658 659
		struct rt6_info *rt;
		struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
660

L
Linus Torvalds 已提交
661
		if (!skb2)
662
			return 0;
L
Linus Torvalds 已提交
663

E
Eric Dumazet 已提交
664
		skb_dst_drop(skb2);
L
Linus Torvalds 已提交
665
		skb_pull(skb2, offset);
666
		skb_reset_network_header(skb2);
L
Linus Torvalds 已提交
667 668

		/* Try to guess incoming interface */
669 670
		rt = rt6_lookup(dev_net(skb->dev), &ipv6_hdr(skb2)->saddr,
				NULL, 0, 0);
L
Linus Torvalds 已提交
671

672 673
		if (rt && rt->dst.dev)
			skb2->dev = rt->dst.dev;
L
Linus Torvalds 已提交
674

675
		icmpv6_send(skb2, rel_type, rel_code, rel_info);
L
Linus Torvalds 已提交
676

A
Amerigo Wang 已提交
677
		ip6_rt_put(rt);
L
Linus Torvalds 已提交
678 679 680

		kfree_skb(skb2);
	}
681 682

	return 0;
L
Linus Torvalds 已提交
683 684
}

685 686 687
static int ip4ip6_dscp_ecn_decapsulate(const struct ip6_tnl *t,
				       const struct ipv6hdr *ipv6h,
				       struct sk_buff *skb)
688 689 690 691
{
	__u8 dsfield = ipv6_get_dsfield(ipv6h) & ~INET_ECN_MASK;

	if (t->parms.flags & IP6_TNL_F_RCV_DSCP_COPY)
692
		ipv4_change_dsfield(ip_hdr(skb), INET_ECN_MASK, dsfield);
693

694
	return IP6_ECN_decapsulate(ipv6h, skb);
695 696
}

697 698 699
static int ip6ip6_dscp_ecn_decapsulate(const struct ip6_tnl *t,
				       const struct ipv6hdr *ipv6h,
				       struct sk_buff *skb)
L
Linus Torvalds 已提交
700
{
701
	if (t->parms.flags & IP6_TNL_F_RCV_DSCP_COPY)
702
		ipv6_copy_dscp(ipv6_get_dsfield(ipv6h), ipv6_hdr(skb));
L
Linus Torvalds 已提交
703

704
	return IP6_ECN_decapsulate(ipv6h, skb);
L
Linus Torvalds 已提交
705
}
706

X
xeb@mail.ru 已提交
707
__u32 ip6_tnl_get_cap(struct ip6_tnl *t,
708 709 710
			     const struct in6_addr *laddr,
			     const struct in6_addr *raddr)
{
X
xeb@mail.ru 已提交
711
	struct __ip6_tnl_parm *p = &t->parms;
712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728
	int ltype = ipv6_addr_type(laddr);
	int rtype = ipv6_addr_type(raddr);
	__u32 flags = 0;

	if (ltype == IPV6_ADDR_ANY || rtype == IPV6_ADDR_ANY) {
		flags = IP6_TNL_F_CAP_PER_PACKET;
	} else if (ltype & (IPV6_ADDR_UNICAST|IPV6_ADDR_MULTICAST) &&
		   rtype & (IPV6_ADDR_UNICAST|IPV6_ADDR_MULTICAST) &&
		   !((ltype|rtype) & IPV6_ADDR_LOOPBACK) &&
		   (!((ltype|rtype) & IPV6_ADDR_LINKLOCAL) || p->link)) {
		if (ltype&IPV6_ADDR_UNICAST)
			flags |= IP6_TNL_F_CAP_XMIT;
		if (rtype&IPV6_ADDR_UNICAST)
			flags |= IP6_TNL_F_CAP_RCV;
	}
	return flags;
}
X
xeb@mail.ru 已提交
729
EXPORT_SYMBOL(ip6_tnl_get_cap);
730

E
Eric Dumazet 已提交
731
/* called with rcu_read_lock() */
X
xeb@mail.ru 已提交
732
int ip6_tnl_rcv_ctl(struct ip6_tnl *t,
733 734
				  const struct in6_addr *laddr,
				  const struct in6_addr *raddr)
735
{
X
xeb@mail.ru 已提交
736
	struct __ip6_tnl_parm *p = &t->parms;
737
	int ret = 0;
N
Nicolas Dichtel 已提交
738
	struct net *net = t->net;
739

740 741 742
	if ((p->flags & IP6_TNL_F_CAP_RCV) ||
	    ((p->flags & IP6_TNL_F_CAP_PER_PACKET) &&
	     (ip6_tnl_get_cap(t, laddr, raddr) & IP6_TNL_F_CAP_RCV))) {
743
		struct net_device *ldev = NULL;
744 745

		if (p->link)
E
Eric Dumazet 已提交
746
			ldev = dev_get_by_index_rcu(net, p->link);
747

748 749 750
		if ((ipv6_addr_is_multicast(laddr) ||
		     likely(ipv6_chk_addr(net, laddr, ldev, 0))) &&
		    likely(!ipv6_chk_addr(net, raddr, NULL, 0)))
751 752 753 754
			ret = 1;
	}
	return ret;
}
X
xeb@mail.ru 已提交
755
EXPORT_SYMBOL_GPL(ip6_tnl_rcv_ctl);
L
Linus Torvalds 已提交
756

757 758 759 760 761 762 763
static int __ip6_tnl_rcv(struct ip6_tnl *tunnel, struct sk_buff *skb,
			 const struct tnl_ptk_info *tpi,
			 struct metadata_dst *tun_dst,
			 int (*dscp_ecn_decapsulate)(const struct ip6_tnl *t,
						const struct ipv6hdr *ipv6h,
						struct sk_buff *skb),
			 bool log_ecn_err)
L
Linus Torvalds 已提交
764
{
765
	struct pcpu_sw_netstats *tstats;
766
	const struct ipv6hdr *ipv6h = ipv6_hdr(skb);
767
	int err;
L
Linus Torvalds 已提交
768

769 770 771 772 773 774 775 776
	if ((!(tpi->flags & TUNNEL_CSUM) &&
	     (tunnel->parms.i_flags & TUNNEL_CSUM)) ||
	    ((tpi->flags & TUNNEL_CSUM) &&
	     !(tunnel->parms.i_flags & TUNNEL_CSUM))) {
		tunnel->dev->stats.rx_crc_errors++;
		tunnel->dev->stats.rx_errors++;
		goto drop;
	}
E
Eric Dumazet 已提交
777

778 779 780 781 782 783 784
	if (tunnel->parms.i_flags & TUNNEL_SEQ) {
		if (!(tpi->flags & TUNNEL_SEQ) ||
		    (tunnel->i_seqno &&
		     (s32)(ntohl(tpi->seq) - tunnel->i_seqno) < 0)) {
			tunnel->dev->stats.rx_fifo_errors++;
			tunnel->dev->stats.rx_errors++;
			goto drop;
785
		}
786 787
		tunnel->i_seqno = ntohl(tpi->seq) + 1;
	}
788

789
	skb->protocol = tpi->proto;
L
Linus Torvalds 已提交
790

791 792 793 794 795 796
	/* Warning: All skb pointers will be invalidated! */
	if (tunnel->dev->type == ARPHRD_ETHER) {
		if (!pskb_may_pull(skb, ETH_HLEN)) {
			tunnel->dev->stats.rx_length_errors++;
			tunnel->dev->stats.rx_errors++;
			goto drop;
L
Linus Torvalds 已提交
797
		}
798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820

		ipv6h = ipv6_hdr(skb);
		skb->protocol = eth_type_trans(skb, tunnel->dev);
		skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
	} else {
		skb->dev = tunnel->dev;
	}

	skb_reset_network_header(skb);
	memset(skb->cb, 0, sizeof(struct inet6_skb_parm));

	__skb_tunnel_rx(skb, tunnel->dev, tunnel->net);

	err = dscp_ecn_decapsulate(tunnel, ipv6h, skb);
	if (unlikely(err)) {
		if (log_ecn_err)
			net_info_ratelimited("non-ECT from %pI6 with DS=%#x\n",
					     &ipv6h->saddr,
					     ipv6_get_dsfield(ipv6h));
		if (err > 1) {
			++tunnel->dev->stats.rx_frame_errors;
			++tunnel->dev->stats.rx_errors;
			goto drop;
821
		}
822
	}
823

824 825 826 827 828
	tstats = this_cpu_ptr(tunnel->dev->tstats);
	u64_stats_update_begin(&tstats->syncp);
	tstats->rx_packets++;
	tstats->rx_bytes += skb->len;
	u64_stats_update_end(&tstats->syncp);
E
Eric Dumazet 已提交
829

830
	skb_scrub_packet(skb, !net_eq(tunnel->net, dev_net(tunnel->dev)));
E
Eric Dumazet 已提交
831

832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885
	gro_cells_receive(&tunnel->gro_cells, skb);
	return 0;

drop:
	kfree_skb(skb);
	return 0;
}

int ip6_tnl_rcv(struct ip6_tnl *t, struct sk_buff *skb,
		const struct tnl_ptk_info *tpi,
		struct metadata_dst *tun_dst,
		bool log_ecn_err)
{
	return __ip6_tnl_rcv(t, skb, tpi, NULL, ip6ip6_dscp_ecn_decapsulate,
			     log_ecn_err);
}
EXPORT_SYMBOL(ip6_tnl_rcv);

static const struct tnl_ptk_info tpi_v6 = {
	/* no tunnel info required for ipxip6. */
	.proto = htons(ETH_P_IPV6),
};

static const struct tnl_ptk_info tpi_v4 = {
	/* no tunnel info required for ipxip6. */
	.proto = htons(ETH_P_IP),
};

static int ipxip6_rcv(struct sk_buff *skb, u8 ipproto,
		      const struct tnl_ptk_info *tpi,
		      int (*dscp_ecn_decapsulate)(const struct ip6_tnl *t,
						  const struct ipv6hdr *ipv6h,
						  struct sk_buff *skb))
{
	struct ip6_tnl *t;
	const struct ipv6hdr *ipv6h = ipv6_hdr(skb);
	int ret = -1;

	rcu_read_lock();
	t = ip6_tnl_lookup(dev_net(skb->dev), &ipv6h->saddr, &ipv6h->daddr);

	if (t) {
		u8 tproto = ACCESS_ONCE(t->parms.proto);

		if (tproto != ipproto && tproto != 0)
			goto drop;
		if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
			goto drop;
		if (!ip6_tnl_rcv_ctl(t, &ipv6h->daddr, &ipv6h->saddr))
			goto drop;
		if (iptunnel_pull_header(skb, 0, tpi->proto, false))
			goto drop;
		ret = __ip6_tnl_rcv(t, skb, tpi, NULL, dscp_ecn_decapsulate,
				    log_ecn_error);
L
Linus Torvalds 已提交
886
	}
887

888
	rcu_read_unlock();
889

890 891 892 893
	return ret;

drop:
	rcu_read_unlock();
894 895
	kfree_skb(skb);
	return 0;
L
Linus Torvalds 已提交
896 897
}

898 899
static int ip4ip6_rcv(struct sk_buff *skb)
{
900
	return ipxip6_rcv(skb, IPPROTO_IPIP, &tpi_v4,
901
			  ip4ip6_dscp_ecn_decapsulate);
902 903
}

904 905
static int ip6ip6_rcv(struct sk_buff *skb)
{
906 907
	return ipxip6_rcv(skb, IPPROTO_IPV6, &tpi_v6,
			  ip6ip6_dscp_ecn_decapsulate);
908 909
}

910 911 912 913
struct ipv6_tel_txoption {
	struct ipv6_txoptions ops;
	__u8 dst_opt[8];
};
L
Linus Torvalds 已提交
914

915 916 917
static void init_tel_txopt(struct ipv6_tel_txoption *opt, __u8 encap_limit)
{
	memset(opt, 0, sizeof(struct ipv6_tel_txoption));
L
Linus Torvalds 已提交
918

919 920 921 922 923
	opt->dst_opt[2] = IPV6_TLV_TNL_ENCAP_LIMIT;
	opt->dst_opt[3] = 1;
	opt->dst_opt[4] = encap_limit;
	opt->dst_opt[5] = IPV6_TLV_PADN;
	opt->dst_opt[6] = 1;
L
Linus Torvalds 已提交
924

925 926
	opt->ops.dst0opt = (struct ipv6_opt_hdr *) opt->dst_opt;
	opt->ops.opt_nflen = 8;
L
Linus Torvalds 已提交
927 928 929
}

/**
930
 * ip6_tnl_addr_conflict - compare packet addresses to tunnel's own
L
Linus Torvalds 已提交
931
 *   @t: the outgoing tunnel device
932
 *   @hdr: IPv6 header from the incoming packet
L
Linus Torvalds 已提交
933 934
 *
 * Description:
935
 *   Avoid trivial tunneling loop by checking that tunnel exit-point
L
Linus Torvalds 已提交
936 937
 *   doesn't match source of incoming packet.
 *
938
 * Return:
L
Linus Torvalds 已提交
939 940 941 942
 *   1 if conflict,
 *   0 else
 **/

E
Eric Dumazet 已提交
943
static inline bool
944
ip6_tnl_addr_conflict(const struct ip6_tnl *t, const struct ipv6hdr *hdr)
L
Linus Torvalds 已提交
945 946 947 948
{
	return ipv6_addr_equal(&t->parms.raddr, &hdr->saddr);
}

949 950 951
int ip6_tnl_xmit_ctl(struct ip6_tnl *t,
		     const struct in6_addr *laddr,
		     const struct in6_addr *raddr)
952
{
X
xeb@mail.ru 已提交
953
	struct __ip6_tnl_parm *p = &t->parms;
954
	int ret = 0;
N
Nicolas Dichtel 已提交
955
	struct net *net = t->net;
956

957 958 959
	if ((p->flags & IP6_TNL_F_CAP_XMIT) ||
	    ((p->flags & IP6_TNL_F_CAP_PER_PACKET) &&
	     (ip6_tnl_get_cap(t, laddr, raddr) & IP6_TNL_F_CAP_XMIT))) {
960 961
		struct net_device *ldev = NULL;

E
Eric Dumazet 已提交
962
		rcu_read_lock();
963
		if (p->link)
E
Eric Dumazet 已提交
964
			ldev = dev_get_by_index_rcu(net, p->link);
965

966
		if (unlikely(!ipv6_chk_addr(net, laddr, ldev, 0)))
967 968
			pr_warn("%s xmit: Local address not yet configured!\n",
				p->name);
969 970
		else if (!ipv6_addr_is_multicast(raddr) &&
			 unlikely(ipv6_chk_addr(net, raddr, NULL, 0)))
971 972
			pr_warn("%s xmit: Routing loop! Remote address found on this node!\n",
				p->name);
973 974
		else
			ret = 1;
E
Eric Dumazet 已提交
975
		rcu_read_unlock();
976 977 978
	}
	return ret;
}
X
xeb@mail.ru 已提交
979 980
EXPORT_SYMBOL_GPL(ip6_tnl_xmit_ctl);

L
Linus Torvalds 已提交
981
/**
T
Tom Herbert 已提交
982
 * ip6_tnl_xmit - encapsulate packet and send
L
Linus Torvalds 已提交
983
 *   @skb: the outgoing socket buffer
984
 *   @dev: the outgoing tunnel device
985
 *   @dsfield: dscp code for outer header
T
Tom Herbert 已提交
986
 *   @fl6: flow of tunneled packet
987 988
 *   @encap_limit: encapsulation limit
 *   @pmtu: Path MTU is stored if packet is too big
T
Tom Herbert 已提交
989
 *   @proto: next header value
L
Linus Torvalds 已提交
990 991 992 993 994
 *
 * Description:
 *   Build new header and do some sanity checks on the packet before sending
 *   it.
 *
995
 * Return:
996
 *   0 on success
997 998
 *   -1 fail
 *   %-EMSGSIZE message too big. return mtu in this case.
L
Linus Torvalds 已提交
999 1000
 **/

T
Tom Herbert 已提交
1001 1002 1003
int ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev, __u8 dsfield,
		 struct flowi6 *fl6, int encap_limit, __u32 *pmtu,
		 __u8 proto)
L
Linus Torvalds 已提交
1004
{
1005
	struct ip6_tnl *t = netdev_priv(dev);
N
Nicolas Dichtel 已提交
1006
	struct net *net = t->net;
1007
	struct net_device_stats *stats = &t->dev->stats;
1008
	struct ipv6hdr *ipv6h = ipv6_hdr(skb);
1009
	struct ipv6_tel_txoption opt;
1010
	struct dst_entry *dst = NULL, *ndst = NULL;
L
Linus Torvalds 已提交
1011 1012
	struct net_device *tdev;
	int mtu;
1013 1014
	unsigned int psh_hlen = sizeof(struct ipv6hdr) + t->encap_hlen;
	unsigned int max_headroom = psh_hlen;
1015
	int err = -1;
L
Linus Torvalds 已提交
1016

1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039
	/* NBMA tunnel */
	if (ipv6_addr_any(&t->parms.raddr)) {
		struct in6_addr *addr6;
		struct neighbour *neigh;
		int addr_type;

		if (!skb_dst(skb))
			goto tx_err_link_failure;

		neigh = dst_neigh_lookup(skb_dst(skb),
					 &ipv6_hdr(skb)->daddr);
		if (!neigh)
			goto tx_err_link_failure;

		addr6 = (struct in6_addr *)&neigh->primary_key;
		addr_type = ipv6_addr_type(addr6);

		if (addr_type == IPV6_ADDR_ANY)
			addr6 = &ipv6_hdr(skb)->daddr;

		memcpy(&fl6->daddr, addr6, sizeof(fl6->daddr));
		neigh_release(neigh);
	} else if (!fl6->flowi6_mark)
1040
		dst = dst_cache_get(&t->dst_cache);
1041 1042 1043 1044

	if (!ip6_tnl_xmit_ctl(t, &fl6->saddr, &fl6->daddr))
		goto tx_err_link_failure;

1045
	if (!dst) {
1046
		dst = ip6_route_output(net, NULL, fl6);
L
Linus Torvalds 已提交
1047

1048
		if (dst->error)
1049
			goto tx_err_link_failure;
1050 1051 1052 1053
		dst = xfrm_lookup(net, dst, flowi6_to_flowi(fl6), NULL, 0);
		if (IS_ERR(dst)) {
			err = PTR_ERR(dst);
			dst = NULL;
1054 1055
			goto tx_err_link_failure;
		}
1056
		ndst = dst;
1057
	}
L
Linus Torvalds 已提交
1058 1059 1060 1061 1062

	tdev = dst->dev;

	if (tdev == dev) {
		stats->collisions++;
1063 1064
		net_warn_ratelimited("%s: Local routing loop detected!\n",
				     t->parms.name);
L
Linus Torvalds 已提交
1065 1066
		goto tx_err_dst_release;
	}
1067
	mtu = dst_mtu(dst) - psh_hlen;
1068
	if (encap_limit >= 0) {
L
Linus Torvalds 已提交
1069 1070 1071 1072 1073
		max_headroom += 8;
		mtu -= 8;
	}
	if (mtu < IPV6_MIN_MTU)
		mtu = IPV6_MIN_MTU;
E
Eric Dumazet 已提交
1074
	if (skb_dst(skb))
1075
		skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
T
Tom Herbert 已提交
1076
	if (skb->len > mtu && !skb_is_gso(skb)) {
1077 1078
		*pmtu = mtu;
		err = -EMSGSIZE;
L
Linus Torvalds 已提交
1079 1080 1081
		goto tx_err_dst_release;
	}

T
Tom Herbert 已提交
1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
	if (t->err_count > 0) {
		if (time_before(jiffies,
				t->err_time + IP6TUNNEL_ERR_TIMEO)) {
			t->err_count--;

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

1093
	skb_scrub_packet(skb, !net_eq(t->net, dev_net(dev)));
N
Nicolas Dichtel 已提交
1094

L
Linus Torvalds 已提交
1095 1096 1097 1098
	/*
	 * Okay, now see if we can stuff it in the buffer as-is.
	 */
	max_headroom += LL_RESERVED_SPACE(tdev);
1099

1100 1101
	if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
	    (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
L
Linus Torvalds 已提交
1102
		struct sk_buff *new_skb;
1103

1104 1105
		new_skb = skb_realloc_headroom(skb, max_headroom);
		if (!new_skb)
L
Linus Torvalds 已提交
1106 1107 1108 1109
			goto tx_err_dst_release;

		if (skb->sk)
			skb_set_owner_w(new_skb, skb->sk);
1110
		consume_skb(skb);
L
Linus Torvalds 已提交
1111 1112
		skb = new_skb;
	}
1113 1114

	if (!fl6->flowi6_mark && ndst)
1115
		dst_cache_set_ip6(&t->dst_cache, ndst, &fl6->saddr);
1116 1117
	skb_dst_set(skb, dst);

1118 1119 1120 1121
	if (encap_limit >= 0) {
		init_tel_txopt(&opt, encap_limit);
		ipv6_push_nfrag_opts(skb, &opt.ops, &proto, NULL);
	}
1122

1123 1124 1125
	/* Calculate max headroom for all the headers and adjust
	 * needed_headroom if necessary.
	 */
T
Tom Herbert 已提交
1126
	max_headroom = LL_RESERVED_SPACE(dst->dev) + sizeof(struct ipv6hdr)
1127
			+ dst->header_len + t->hlen;
T
Tom Herbert 已提交
1128 1129 1130
	if (max_headroom > dev->needed_headroom)
		dev->needed_headroom = max_headroom;

1131 1132 1133 1134
	err = ip6_tnl_encap(skb, t, &proto, fl6);
	if (err)
		return err;

1135 1136
	skb_push(skb, sizeof(struct ipv6hdr));
	skb_reset_network_header(skb);
1137
	ipv6h = ipv6_hdr(skb);
1138
	ip6_flow_hdr(ipv6h, INET_ECN_encapsulate(0, dsfield),
1139
		     ip6_make_flowlabel(net, skb, fl6->flowlabel, true, fl6));
L
Linus Torvalds 已提交
1140 1141
	ipv6h->hop_limit = t->parms.hop_limit;
	ipv6h->nexthdr = proto;
A
Alexey Dobriyan 已提交
1142 1143
	ipv6h->saddr = fl6->saddr;
	ipv6h->daddr = fl6->daddr;
1144
	ip6tunnel_xmit(NULL, skb, dev);
L
Linus Torvalds 已提交
1145 1146 1147 1148 1149
	return 0;
tx_err_link_failure:
	stats->tx_carrier_errors++;
	dst_link_failure(skb);
tx_err_dst_release:
1150
	dst_release(dst);
1151 1152
	return err;
}
T
Tom Herbert 已提交
1153
EXPORT_SYMBOL(ip6_tnl_xmit);
1154

1155 1156 1157 1158
static inline int
ip4ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct ip6_tnl *t = netdev_priv(dev);
1159
	const struct iphdr  *iph = ip_hdr(skb);
1160
	int encap_limit = -1;
1161
	struct flowi6 fl6;
1162 1163
	__u8 dsfield;
	__u32 mtu;
1164
	u8 tproto;
1165 1166
	int err;

1167 1168
	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));

1169
	tproto = ACCESS_ONCE(t->parms.proto);
1170
	if (tproto != IPPROTO_IPIP && tproto != 0)
1171 1172 1173 1174 1175
		return -1;

	if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
		encap_limit = t->parms.encap_limit;

1176
	memcpy(&fl6, &t->fl.u.ip6, sizeof(fl6));
1177 1178 1179

	dsfield = ipv4_get_dsfield(iph);

1180
	if (t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS)
1181
		fl6.flowlabel |= htonl((__u32)iph->tos << IPV6_TCLASS_SHIFT)
A
Al Viro 已提交
1182
					  & IPV6_TCLASS_MASK;
1183 1184
	if (t->parms.flags & IP6_TNL_F_USE_ORIG_FWMARK)
		fl6.flowi6_mark = skb->mark;
1185

T
Tom Herbert 已提交
1186 1187 1188 1189 1190
	if (iptunnel_handle_offloads(skb, SKB_GSO_IPXIP6))
		return -1;

	skb_set_inner_ipproto(skb, IPPROTO_IPIP);

T
Tom Herbert 已提交
1191 1192
	err = ip6_tnl_xmit(skb, dev, dsfield, &fl6, encap_limit, &mtu,
			   IPPROTO_IPIP);
1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
	if (err != 0) {
		/* XXX: send ICMP error even if DF is not set. */
		if (err == -EMSGSIZE)
			icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
				  htonl(mtu));
		return -1;
	}

	return 0;
}

1204 1205 1206 1207
static inline int
ip6ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct ip6_tnl *t = netdev_priv(dev);
1208
	struct ipv6hdr *ipv6h = ipv6_hdr(skb);
1209 1210
	int encap_limit = -1;
	__u16 offset;
1211
	struct flowi6 fl6;
1212 1213
	__u8 dsfield;
	__u32 mtu;
1214
	u8 tproto;
1215 1216
	int err;

1217 1218
	tproto = ACCESS_ONCE(t->parms.proto);
	if ((tproto != IPPROTO_IPV6 && tproto != 0) ||
1219
	    ip6_tnl_addr_conflict(t, ipv6h))
1220 1221
		return -1;

X
xeb@mail.ru 已提交
1222
	offset = ip6_tnl_parse_tlv_enc_lim(skb, skb_network_header(skb));
1223
	if (offset > 0) {
1224
		struct ipv6_tlv_tnl_enc_lim *tel;
1225
		tel = (struct ipv6_tlv_tnl_enc_lim *)&skb_network_header(skb)[offset];
1226 1227
		if (tel->encap_limit == 0) {
			icmpv6_send(skb, ICMPV6_PARAMPROB,
1228
				    ICMPV6_HDR_FIELD, offset + 2);
1229 1230 1231 1232 1233 1234
			return -1;
		}
		encap_limit = tel->encap_limit - 1;
	} else if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
		encap_limit = t->parms.encap_limit;

1235
	memcpy(&fl6, &t->fl.u.ip6, sizeof(fl6));
1236 1237

	dsfield = ipv6_get_dsfield(ipv6h);
1238
	if (t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS)
1239
		fl6.flowlabel |= (*(__be32 *) ipv6h & IPV6_TCLASS_MASK);
1240
	if (t->parms.flags & IP6_TNL_F_USE_ORIG_FLOWLABEL)
F
Florent Fourcot 已提交
1241
		fl6.flowlabel |= ip6_flowlabel(ipv6h);
1242 1243
	if (t->parms.flags & IP6_TNL_F_USE_ORIG_FWMARK)
		fl6.flowi6_mark = skb->mark;
1244

T
Tom Herbert 已提交
1245 1246 1247 1248 1249
	if (iptunnel_handle_offloads(skb, SKB_GSO_IPXIP6))
		return -1;

	skb_set_inner_ipproto(skb, IPPROTO_IPV6);

T
Tom Herbert 已提交
1250 1251
	err = ip6_tnl_xmit(skb, dev, dsfield, &fl6, encap_limit, &mtu,
			   IPPROTO_IPV6);
1252 1253
	if (err != 0) {
		if (err == -EMSGSIZE)
1254
			icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
1255 1256 1257 1258 1259 1260
		return -1;
	}

	return 0;
}

1261
static netdev_tx_t
T
Tom Herbert 已提交
1262
ip6_tnl_start_xmit(struct sk_buff *skb, struct net_device *dev)
1263 1264
{
	struct ip6_tnl *t = netdev_priv(dev);
1265
	struct net_device_stats *stats = &t->dev->stats;
1266 1267 1268
	int ret;

	switch (skb->protocol) {
1269
	case htons(ETH_P_IP):
1270 1271
		ret = ip4ip6_tnl_xmit(skb, dev);
		break;
1272
	case htons(ETH_P_IPV6):
1273 1274 1275 1276 1277 1278 1279 1280 1281
		ret = ip6ip6_tnl_xmit(skb, dev);
		break;
	default:
		goto tx_err;
	}

	if (ret < 0)
		goto tx_err;

1282
	return NETDEV_TX_OK;
1283

L
Linus Torvalds 已提交
1284 1285 1286 1287
tx_err:
	stats->tx_errors++;
	stats->tx_dropped++;
	kfree_skb(skb);
1288
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
1289 1290
}

1291
static void ip6_tnl_link_config(struct ip6_tnl *t)
L
Linus Torvalds 已提交
1292 1293
{
	struct net_device *dev = t->dev;
X
xeb@mail.ru 已提交
1294
	struct __ip6_tnl_parm *p = &t->parms;
1295
	struct flowi6 *fl6 = &t->fl.u.ip6;
1296
	int t_hlen;
L
Linus Torvalds 已提交
1297

1298 1299
	memcpy(dev->dev_addr, &p->laddr, sizeof(struct in6_addr));
	memcpy(dev->broadcast, &p->raddr, sizeof(struct in6_addr));
L
Linus Torvalds 已提交
1300 1301

	/* Set up flowi template */
A
Alexey Dobriyan 已提交
1302 1303
	fl6->saddr = p->laddr;
	fl6->daddr = p->raddr;
1304 1305
	fl6->flowi6_oif = p->link;
	fl6->flowlabel = 0;
L
Linus Torvalds 已提交
1306 1307

	if (!(p->flags&IP6_TNL_F_USE_ORIG_TCLASS))
1308
		fl6->flowlabel |= IPV6_TCLASS_MASK & p->flowinfo;
L
Linus Torvalds 已提交
1309
	if (!(p->flags&IP6_TNL_F_USE_ORIG_FLOWLABEL))
1310
		fl6->flowlabel |= IPV6_FLOWLABEL_MASK & p->flowinfo;
L
Linus Torvalds 已提交
1311

1312 1313
	p->flags &= ~(IP6_TNL_F_CAP_XMIT|IP6_TNL_F_CAP_RCV|IP6_TNL_F_CAP_PER_PACKET);
	p->flags |= ip6_tnl_get_cap(t, &p->laddr, &p->raddr);
L
Linus Torvalds 已提交
1314 1315 1316 1317 1318 1319

	if (p->flags&IP6_TNL_F_CAP_XMIT && p->flags&IP6_TNL_F_CAP_RCV)
		dev->flags |= IFF_POINTOPOINT;
	else
		dev->flags &= ~IFF_POINTOPOINT;

1320 1321 1322 1323
	t->tun_hlen = 0;
	t->hlen = t->encap_hlen + t->tun_hlen;
	t_hlen = t->hlen + sizeof(struct ipv6hdr);

L
Linus Torvalds 已提交
1324
	if (p->flags & IP6_TNL_F_CAP_XMIT) {
1325 1326 1327
		int strict = (ipv6_addr_type(&p->raddr) &
			      (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL));

N
Nicolas Dichtel 已提交
1328
		struct rt6_info *rt = rt6_lookup(t->net,
1329
						 &p->raddr, &p->laddr,
1330
						 p->link, strict);
L
Linus Torvalds 已提交
1331

1332
		if (!rt)
L
Linus Torvalds 已提交
1333 1334
			return;

1335 1336
		if (rt->dst.dev) {
			dev->hard_header_len = rt->dst.dev->hard_header_len +
1337
				t_hlen;
L
Linus Torvalds 已提交
1338

1339
			dev->mtu = rt->dst.dev->mtu - t_hlen;
1340
			if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
1341
				dev->mtu -= 8;
L
Linus Torvalds 已提交
1342 1343 1344 1345

			if (dev->mtu < IPV6_MIN_MTU)
				dev->mtu = IPV6_MIN_MTU;
		}
A
Amerigo Wang 已提交
1346
		ip6_rt_put(rt);
L
Linus Torvalds 已提交
1347 1348 1349 1350
	}
}

/**
1351
 * ip6_tnl_change - update the tunnel parameters
L
Linus Torvalds 已提交
1352 1353 1354 1355
 *   @t: tunnel to be changed
 *   @p: tunnel configuration parameters
 *
 * Description:
1356
 *   ip6_tnl_change() updates the tunnel parameters
L
Linus Torvalds 已提交
1357 1358 1359
 **/

static int
X
xeb@mail.ru 已提交
1360
ip6_tnl_change(struct ip6_tnl *t, const struct __ip6_tnl_parm *p)
L
Linus Torvalds 已提交
1361
{
A
Alexey Dobriyan 已提交
1362 1363
	t->parms.laddr = p->laddr;
	t->parms.raddr = p->raddr;
L
Linus Torvalds 已提交
1364 1365 1366 1367
	t->parms.flags = p->flags;
	t->parms.hop_limit = p->hop_limit;
	t->parms.encap_limit = p->encap_limit;
	t->parms.flowinfo = p->flowinfo;
1368
	t->parms.link = p->link;
1369
	t->parms.proto = p->proto;
1370
	dst_cache_reset(&t->dst_cache);
1371
	ip6_tnl_link_config(t);
L
Linus Torvalds 已提交
1372 1373 1374
	return 0;
}

1375 1376
static int ip6_tnl_update(struct ip6_tnl *t, struct __ip6_tnl_parm *p)
{
N
Nicolas Dichtel 已提交
1377
	struct net *net = t->net;
1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
	int err;

	ip6_tnl_unlink(ip6n, t);
	synchronize_net();
	err = ip6_tnl_change(t, p);
	ip6_tnl_link(ip6n, t);
	netdev_state_change(t->dev);
	return err;
}

1389 1390 1391 1392 1393 1394 1395 1396
static int ip6_tnl0_update(struct ip6_tnl *t, struct __ip6_tnl_parm *p)
{
	/* for default tnl0 device allow to change only the proto */
	t->parms.proto = p->proto;
	netdev_state_change(t->dev);
	return 0;
}

X
xeb@mail.ru 已提交
1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424
static void
ip6_tnl_parm_from_user(struct __ip6_tnl_parm *p, const struct ip6_tnl_parm *u)
{
	p->laddr = u->laddr;
	p->raddr = u->raddr;
	p->flags = u->flags;
	p->hop_limit = u->hop_limit;
	p->encap_limit = u->encap_limit;
	p->flowinfo = u->flowinfo;
	p->link = u->link;
	p->proto = u->proto;
	memcpy(p->name, u->name, sizeof(u->name));
}

static void
ip6_tnl_parm_to_user(struct ip6_tnl_parm *u, const struct __ip6_tnl_parm *p)
{
	u->laddr = p->laddr;
	u->raddr = p->raddr;
	u->flags = p->flags;
	u->hop_limit = p->hop_limit;
	u->encap_limit = p->encap_limit;
	u->flowinfo = p->flowinfo;
	u->link = p->link;
	u->proto = p->proto;
	memcpy(u->name, p->name, sizeof(u->name));
}

L
Linus Torvalds 已提交
1425
/**
1426
 * ip6_tnl_ioctl - configure ipv6 tunnels from userspace
L
Linus Torvalds 已提交
1427 1428 1429 1430 1431
 *   @dev: virtual device associated with tunnel
 *   @ifr: parameters passed from userspace
 *   @cmd: command to be performed
 *
 * Description:
1432
 *   ip6_tnl_ioctl() is used for managing IPv6 tunnels
1433
 *   from userspace.
L
Linus Torvalds 已提交
1434 1435 1436 1437 1438 1439 1440
 *
 *   The possible commands are the following:
 *     %SIOCGETTUNNEL: get tunnel parameters for device
 *     %SIOCADDTUNNEL: add tunnel matching given tunnel parameters
 *     %SIOCCHGTUNNEL: change tunnel parameters to those given
 *     %SIOCDELTUNNEL: delete tunnel
 *
1441
 *   The fallback device "ip6tnl0", created during module
L
Linus Torvalds 已提交
1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453
 *   initialization, can be used for creating other tunnel devices.
 *
 * Return:
 *   0 on success,
 *   %-EFAULT if unable to copy data to or from userspace,
 *   %-EPERM if current process hasn't %CAP_NET_ADMIN set
 *   %-EINVAL if passed tunnel parameters are invalid,
 *   %-EEXIST if changing a tunnel's parameters would cause a conflict
 *   %-ENODEV if attempting to change or delete a nonexisting device
 **/

static int
1454
ip6_tnl_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
L
Linus Torvalds 已提交
1455 1456 1457
{
	int err = 0;
	struct ip6_tnl_parm p;
X
xeb@mail.ru 已提交
1458
	struct __ip6_tnl_parm p1;
1459 1460
	struct ip6_tnl *t = netdev_priv(dev);
	struct net *net = t->net;
1461
	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
L
Linus Torvalds 已提交
1462

1463 1464
	memset(&p1, 0, sizeof(p1));

L
Linus Torvalds 已提交
1465 1466
	switch (cmd) {
	case SIOCGETTUNNEL:
1467
		if (dev == ip6n->fb_tnl_dev) {
1468
			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
L
Linus Torvalds 已提交
1469 1470 1471
				err = -EFAULT;
				break;
			}
X
xeb@mail.ru 已提交
1472 1473
			ip6_tnl_parm_from_user(&p1, &p);
			t = ip6_tnl_locate(net, &p1, 0);
1474
			if (IS_ERR(t))
1475
				t = netdev_priv(dev);
1476 1477
		} else {
			memset(&p, 0, sizeof(p));
1478
		}
X
xeb@mail.ru 已提交
1479
		ip6_tnl_parm_to_user(&p, &t->parms);
1480
		if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p))) {
L
Linus Torvalds 已提交
1481 1482 1483 1484 1485 1486
			err = -EFAULT;
		}
		break;
	case SIOCADDTUNNEL:
	case SIOCCHGTUNNEL:
		err = -EPERM;
1487
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
1488
			break;
1489
		err = -EFAULT;
1490
		if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
L
Linus Torvalds 已提交
1491
			break;
1492
		err = -EINVAL;
1493 1494
		if (p.proto != IPPROTO_IPV6 && p.proto != IPPROTO_IPIP &&
		    p.proto != 0)
L
Linus Torvalds 已提交
1495
			break;
X
xeb@mail.ru 已提交
1496 1497
		ip6_tnl_parm_from_user(&p1, &p);
		t = ip6_tnl_locate(net, &p1, cmd == SIOCADDTUNNEL);
1498
		if (cmd == SIOCCHGTUNNEL) {
1499
			if (!IS_ERR(t)) {
1500 1501 1502 1503 1504 1505
				if (t->dev != dev) {
					err = -EEXIST;
					break;
				}
			} else
				t = netdev_priv(dev);
1506 1507 1508 1509
			if (dev == ip6n->fb_tnl_dev)
				err = ip6_tnl0_update(t, &p1);
			else
				err = ip6_tnl_update(t, &p1);
L
Linus Torvalds 已提交
1510
		}
1511
		if (!IS_ERR(t)) {
L
Linus Torvalds 已提交
1512
			err = 0;
X
xeb@mail.ru 已提交
1513 1514
			ip6_tnl_parm_to_user(&p, &t->parms);
			if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
1515 1516
				err = -EFAULT;

1517 1518 1519
		} else {
			err = PTR_ERR(t);
		}
L
Linus Torvalds 已提交
1520 1521 1522
		break;
	case SIOCDELTUNNEL:
		err = -EPERM;
1523
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
1524 1525
			break;

1526
		if (dev == ip6n->fb_tnl_dev) {
1527
			err = -EFAULT;
1528
			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
L
Linus Torvalds 已提交
1529
				break;
1530
			err = -ENOENT;
X
xeb@mail.ru 已提交
1531 1532
			ip6_tnl_parm_from_user(&p1, &p);
			t = ip6_tnl_locate(net, &p1, 0);
1533
			if (IS_ERR(t))
L
Linus Torvalds 已提交
1534
				break;
1535
			err = -EPERM;
1536
			if (t->dev == ip6n->fb_tnl_dev)
L
Linus Torvalds 已提交
1537
				break;
1538
			dev = t->dev;
L
Linus Torvalds 已提交
1539
		}
1540 1541
		err = 0;
		unregister_netdevice(dev);
L
Linus Torvalds 已提交
1542 1543 1544 1545 1546 1547 1548 1549
		break;
	default:
		err = -EINVAL;
	}
	return err;
}

/**
1550
 * ip6_tnl_change_mtu - change mtu manually for tunnel device
L
Linus Torvalds 已提交
1551 1552 1553 1554 1555 1556 1557 1558
 *   @dev: virtual device associated with tunnel
 *   @new_mtu: the new mtu
 *
 * Return:
 *   0 on success,
 *   %-EINVAL if mtu too small
 **/

T
Tom Herbert 已提交
1559
int ip6_tnl_change_mtu(struct net_device *dev, int new_mtu)
L
Linus Torvalds 已提交
1560
{
1561 1562 1563 1564 1565 1566 1567 1568
	struct ip6_tnl *tnl = netdev_priv(dev);

	if (tnl->parms.proto == IPPROTO_IPIP) {
		if (new_mtu < 68)
			return -EINVAL;
	} else {
		if (new_mtu < IPV6_MIN_MTU)
			return -EINVAL;
L
Linus Torvalds 已提交
1569
	}
1570 1571
	if (new_mtu > 0xFFF8 - dev->hard_header_len)
		return -EINVAL;
L
Linus Torvalds 已提交
1572 1573 1574
	dev->mtu = new_mtu;
	return 0;
}
T
Tom Herbert 已提交
1575
EXPORT_SYMBOL(ip6_tnl_change_mtu);
L
Linus Torvalds 已提交
1576

1577 1578 1579 1580 1581 1582 1583
int ip6_tnl_get_iflink(const struct net_device *dev)
{
	struct ip6_tnl *t = netdev_priv(dev);

	return t->parms.link;
}
EXPORT_SYMBOL(ip6_tnl_get_iflink);
1584

1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 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
int ip6_tnl_encap_add_ops(const struct ip6_tnl_encap_ops *ops,
			  unsigned int num)
{
	if (num >= MAX_IPTUN_ENCAP_OPS)
		return -ERANGE;

	return !cmpxchg((const struct ip6_tnl_encap_ops **)
			&ip6tun_encaps[num],
			NULL, ops) ? 0 : -1;
}
EXPORT_SYMBOL(ip6_tnl_encap_add_ops);

int ip6_tnl_encap_del_ops(const struct ip6_tnl_encap_ops *ops,
			  unsigned int num)
{
	int ret;

	if (num >= MAX_IPTUN_ENCAP_OPS)
		return -ERANGE;

	ret = (cmpxchg((const struct ip6_tnl_encap_ops **)
		       &ip6tun_encaps[num],
		       ops, NULL) == ops) ? 0 : -1;

	synchronize_net();

	return ret;
}
EXPORT_SYMBOL(ip6_tnl_encap_del_ops);

int ip6_tnl_encap_setup(struct ip6_tnl *t,
			struct ip_tunnel_encap *ipencap)
{
	int hlen;

	memset(&t->encap, 0, sizeof(t->encap));

	hlen = ip6_encap_hlen(ipencap);
	if (hlen < 0)
		return hlen;

	t->encap.type = ipencap->type;
	t->encap.sport = ipencap->sport;
	t->encap.dport = ipencap->dport;
	t->encap.flags = ipencap->flags;

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

	return 0;
}
EXPORT_SYMBOL_GPL(ip6_tnl_encap_setup);

1638
static const struct net_device_ops ip6_tnl_netdev_ops = {
1639
	.ndo_init	= ip6_tnl_dev_init,
E
Eric Dumazet 已提交
1640
	.ndo_uninit	= ip6_tnl_dev_uninit,
T
Tom Herbert 已提交
1641
	.ndo_start_xmit = ip6_tnl_start_xmit,
E
Eric Dumazet 已提交
1642
	.ndo_do_ioctl	= ip6_tnl_ioctl,
1643
	.ndo_change_mtu = ip6_tnl_change_mtu,
E
Eric Dumazet 已提交
1644
	.ndo_get_stats	= ip6_get_stats,
1645
	.ndo_get_iflink = ip6_tnl_get_iflink,
1646 1647
};

1648 1649 1650 1651 1652
#define IPXIPX_FEATURES (NETIF_F_SG |		\
			 NETIF_F_FRAGLIST |	\
			 NETIF_F_HIGHDMA |	\
			 NETIF_F_GSO_SOFTWARE |	\
			 NETIF_F_HW_CSUM)
E
Eric Dumazet 已提交
1653

L
Linus Torvalds 已提交
1654
/**
1655
 * ip6_tnl_dev_setup - setup virtual tunnel device
L
Linus Torvalds 已提交
1656 1657 1658 1659 1660 1661
 *   @dev: virtual device associated with tunnel
 *
 * Description:
 *   Initialize function pointers and device parameters
 **/

1662
static void ip6_tnl_dev_setup(struct net_device *dev)
L
Linus Torvalds 已提交
1663
{
1664
	dev->netdev_ops = &ip6_tnl_netdev_ops;
E
Eric Dumazet 已提交
1665
	dev->destructor = ip6_dev_free;
L
Linus Torvalds 已提交
1666 1667 1668 1669

	dev->type = ARPHRD_TUNNEL6;
	dev->flags |= IFF_NOARP;
	dev->addr_len = sizeof(struct in6_addr);
1670
	dev->features |= NETIF_F_LLTX;
1671
	netif_keep_dst(dev);
1672 1673 1674 1675

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

1676 1677 1678
	/* This perm addr will be used as interface identifier by IPv6 */
	dev->addr_assign_type = NET_ADDR_RANDOM;
	eth_random_addr(dev->perm_addr);
L
Linus Torvalds 已提交
1679 1680 1681 1682
}


/**
1683
 * ip6_tnl_dev_init_gen - general initializer for all tunnel devices
L
Linus Torvalds 已提交
1684 1685 1686
 *   @dev: virtual device associated with tunnel
 **/

E
Eric Dumazet 已提交
1687
static inline int
1688
ip6_tnl_dev_init_gen(struct net_device *dev)
L
Linus Torvalds 已提交
1689
{
1690
	struct ip6_tnl *t = netdev_priv(dev);
1691
	int ret;
1692
	int t_hlen;
E
Eric Dumazet 已提交
1693

L
Linus Torvalds 已提交
1694
	t->dev = dev;
N
Nicolas Dichtel 已提交
1695
	t->net = dev_net(dev);
1696
	dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
E
Eric Dumazet 已提交
1697 1698
	if (!dev->tstats)
		return -ENOMEM;
1699

1700
	ret = dst_cache_init(&t->dst_cache, GFP_KERNEL);
1701 1702 1703 1704 1705 1706
	if (ret)
		goto free_stats;

	ret = gro_cells_init(&t->gro_cells, dev);
	if (ret)
		goto destroy_dst;
1707

T
Tom Herbert 已提交
1708
	t->tun_hlen = 0;
1709 1710 1711 1712 1713 1714 1715 1716
	t->hlen = t->encap_hlen + t->tun_hlen;
	t_hlen = t->hlen + sizeof(struct ipv6hdr);

	dev->type = ARPHRD_TUNNEL6;
	dev->hard_header_len = LL_MAX_HEADER + t_hlen;
	dev->mtu = ETH_DATA_LEN - t_hlen;
	if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
		dev->mtu -= 8;
T
Tom Herbert 已提交
1717

E
Eric Dumazet 已提交
1718
	return 0;
1719 1720 1721 1722 1723 1724 1725 1726

destroy_dst:
	dst_cache_destroy(&t->dst_cache);
free_stats:
	free_percpu(dev->tstats);
	dev->tstats = NULL;

	return ret;
L
Linus Torvalds 已提交
1727 1728 1729
}

/**
1730
 * ip6_tnl_dev_init - initializer for all non fallback tunnel devices
L
Linus Torvalds 已提交
1731 1732 1733
 *   @dev: virtual device associated with tunnel
 **/

E
Eric Dumazet 已提交
1734
static int ip6_tnl_dev_init(struct net_device *dev)
L
Linus Torvalds 已提交
1735
{
1736
	struct ip6_tnl *t = netdev_priv(dev);
E
Eric Dumazet 已提交
1737 1738 1739 1740
	int err = ip6_tnl_dev_init_gen(dev);

	if (err)
		return err;
1741
	ip6_tnl_link_config(t);
E
Eric Dumazet 已提交
1742
	return 0;
L
Linus Torvalds 已提交
1743 1744 1745
}

/**
1746
 * ip6_fb_tnl_dev_init - initializer for fallback tunnel device
L
Linus Torvalds 已提交
1747 1748 1749 1750 1751
 *   @dev: fallback device
 *
 * Return: 0
 **/

E
Eric Dumazet 已提交
1752
static int __net_init ip6_fb_tnl_dev_init(struct net_device *dev)
L
Linus Torvalds 已提交
1753
{
1754
	struct ip6_tnl *t = netdev_priv(dev);
1755 1756 1757
	struct net *net = dev_net(dev);
	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);

1758
	t->parms.proto = IPPROTO_IPV6;
L
Linus Torvalds 已提交
1759
	dev_hold(dev);
1760

1761
	rcu_assign_pointer(ip6n->tnls_wc[0], t);
E
Eric Dumazet 已提交
1762
	return 0;
L
Linus Torvalds 已提交
1763 1764
}

1765 1766 1767 1768
static int ip6_tnl_validate(struct nlattr *tb[], struct nlattr *data[])
{
	u8 proto;

1769
	if (!data || !data[IFLA_IPTUN_PROTO])
1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792
		return 0;

	proto = nla_get_u8(data[IFLA_IPTUN_PROTO]);
	if (proto != IPPROTO_IPV6 &&
	    proto != IPPROTO_IPIP &&
	    proto != 0)
		return -EINVAL;

	return 0;
}

static void ip6_tnl_netlink_parms(struct nlattr *data[],
				  struct __ip6_tnl_parm *parms)
{
	memset(parms, 0, sizeof(*parms));

	if (!data)
		return;

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

	if (data[IFLA_IPTUN_LOCAL])
1793
		parms->laddr = nla_get_in6_addr(data[IFLA_IPTUN_LOCAL]);
1794 1795

	if (data[IFLA_IPTUN_REMOTE])
1796
		parms->raddr = nla_get_in6_addr(data[IFLA_IPTUN_REMOTE]);
1797 1798 1799 1800 1801 1802 1803 1804

	if (data[IFLA_IPTUN_TTL])
		parms->hop_limit = nla_get_u8(data[IFLA_IPTUN_TTL]);

	if (data[IFLA_IPTUN_ENCAP_LIMIT])
		parms->encap_limit = nla_get_u8(data[IFLA_IPTUN_ENCAP_LIMIT]);

	if (data[IFLA_IPTUN_FLOWINFO])
1805
		parms->flowinfo = nla_get_be32(data[IFLA_IPTUN_FLOWINFO]);
1806 1807 1808 1809 1810 1811 1812 1813

	if (data[IFLA_IPTUN_FLAGS])
		parms->flags = nla_get_u32(data[IFLA_IPTUN_FLAGS]);

	if (data[IFLA_IPTUN_PROTO])
		parms->proto = nla_get_u8(data[IFLA_IPTUN_PROTO]);
}

1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846
static bool ip6_tnl_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_IPTUN_ENCAP_TYPE]) {
		ret = true;
		ipencap->type = nla_get_u16(data[IFLA_IPTUN_ENCAP_TYPE]);
	}

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

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

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

	return ret;
}

1847 1848 1849 1850
static int ip6_tnl_newlink(struct net *src_net, struct net_device *dev,
			   struct nlattr *tb[], struct nlattr *data[])
{
	struct net *net = dev_net(dev);
1851
	struct ip6_tnl *nt, *t;
1852
	struct ip_tunnel_encap ipencap;
1853 1854

	nt = netdev_priv(dev);
1855 1856 1857 1858 1859 1860 1861 1862

	if (ip6_tnl_netlink_encap_parms(data, &ipencap)) {
		int err = ip6_tnl_encap_setup(nt, &ipencap);

		if (err < 0)
			return err;
	}

1863 1864
	ip6_tnl_netlink_parms(data, &nt->parms);

1865 1866
	t = ip6_tnl_locate(net, &nt->parms, 0);
	if (!IS_ERR(t))
1867 1868 1869 1870 1871 1872 1873 1874
		return -EEXIST;

	return ip6_tnl_create2(dev);
}

static int ip6_tnl_changelink(struct net_device *dev, struct nlattr *tb[],
			      struct nlattr *data[])
{
N
Nicolas Dichtel 已提交
1875
	struct ip6_tnl *t = netdev_priv(dev);
1876
	struct __ip6_tnl_parm p;
N
Nicolas Dichtel 已提交
1877
	struct net *net = t->net;
1878
	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
1879
	struct ip_tunnel_encap ipencap;
1880 1881 1882 1883

	if (dev == ip6n->fb_tnl_dev)
		return -EINVAL;

1884 1885 1886 1887 1888 1889
	if (ip6_tnl_netlink_encap_parms(data, &ipencap)) {
		int err = ip6_tnl_encap_setup(t, &ipencap);

		if (err < 0)
			return err;
	}
1890 1891 1892
	ip6_tnl_netlink_parms(data, &p);

	t = ip6_tnl_locate(net, &p, 0);
1893
	if (!IS_ERR(t)) {
1894 1895 1896 1897 1898 1899 1900 1901
		if (t->dev != dev)
			return -EEXIST;
	} else
		t = netdev_priv(dev);

	return ip6_tnl_update(t, &p);
}

1902 1903 1904 1905 1906 1907 1908 1909 1910
static void ip6_tnl_dellink(struct net_device *dev, struct list_head *head)
{
	struct net *net = dev_net(dev);
	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);

	if (dev != ip6n->fb_tnl_dev)
		unregister_netdevice_queue(dev, head);
}

1911
static size_t ip6_tnl_get_size(const struct net_device *dev)
1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927
{
	return
		/* IFLA_IPTUN_LINK */
		nla_total_size(4) +
		/* IFLA_IPTUN_LOCAL */
		nla_total_size(sizeof(struct in6_addr)) +
		/* IFLA_IPTUN_REMOTE */
		nla_total_size(sizeof(struct in6_addr)) +
		/* IFLA_IPTUN_TTL */
		nla_total_size(1) +
		/* IFLA_IPTUN_ENCAP_LIMIT */
		nla_total_size(1) +
		/* IFLA_IPTUN_FLOWINFO */
		nla_total_size(4) +
		/* IFLA_IPTUN_FLAGS */
		nla_total_size(4) +
1928 1929
		/* IFLA_IPTUN_PROTO */
		nla_total_size(1) +
1930 1931 1932 1933 1934 1935 1936 1937
		/* IFLA_IPTUN_ENCAP_TYPE */
		nla_total_size(2) +
		/* IFLA_IPTUN_ENCAP_FLAGS */
		nla_total_size(2) +
		/* IFLA_IPTUN_ENCAP_SPORT */
		nla_total_size(2) +
		/* IFLA_IPTUN_ENCAP_DPORT */
		nla_total_size(2) +
1938 1939 1940
		0;
}

1941
static int ip6_tnl_fill_info(struct sk_buff *skb, const struct net_device *dev)
1942 1943 1944 1945 1946
{
	struct ip6_tnl *tunnel = netdev_priv(dev);
	struct __ip6_tnl_parm *parm = &tunnel->parms;

	if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
1947 1948
	    nla_put_in6_addr(skb, IFLA_IPTUN_LOCAL, &parm->laddr) ||
	    nla_put_in6_addr(skb, IFLA_IPTUN_REMOTE, &parm->raddr) ||
1949 1950 1951
	    nla_put_u8(skb, IFLA_IPTUN_TTL, parm->hop_limit) ||
	    nla_put_u8(skb, IFLA_IPTUN_ENCAP_LIMIT, parm->encap_limit) ||
	    nla_put_be32(skb, IFLA_IPTUN_FLOWINFO, parm->flowinfo) ||
1952 1953
	    nla_put_u32(skb, IFLA_IPTUN_FLAGS, parm->flags) ||
	    nla_put_u8(skb, IFLA_IPTUN_PROTO, parm->proto))
1954
		goto nla_put_failure;
1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965

	if (nla_put_u16(skb, IFLA_IPTUN_ENCAP_TYPE,
			tunnel->encap.type) ||
	nla_put_be16(skb, IFLA_IPTUN_ENCAP_SPORT,
		     tunnel->encap.sport) ||
	nla_put_be16(skb, IFLA_IPTUN_ENCAP_DPORT,
		     tunnel->encap.dport) ||
	nla_put_u16(skb, IFLA_IPTUN_ENCAP_FLAGS,
		    tunnel->encap.flags))
		goto nla_put_failure;

1966 1967 1968 1969 1970 1971
	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

1972 1973 1974 1975 1976 1977 1978 1979
struct net *ip6_tnl_get_link_net(const struct net_device *dev)
{
	struct ip6_tnl *tunnel = netdev_priv(dev);

	return tunnel->net;
}
EXPORT_SYMBOL(ip6_tnl_get_link_net);

1980 1981 1982 1983 1984 1985 1986 1987 1988
static const struct nla_policy ip6_tnl_policy[IFLA_IPTUN_MAX + 1] = {
	[IFLA_IPTUN_LINK]		= { .type = NLA_U32 },
	[IFLA_IPTUN_LOCAL]		= { .len = sizeof(struct in6_addr) },
	[IFLA_IPTUN_REMOTE]		= { .len = sizeof(struct in6_addr) },
	[IFLA_IPTUN_TTL]		= { .type = NLA_U8 },
	[IFLA_IPTUN_ENCAP_LIMIT]	= { .type = NLA_U8 },
	[IFLA_IPTUN_FLOWINFO]		= { .type = NLA_U32 },
	[IFLA_IPTUN_FLAGS]		= { .type = NLA_U32 },
	[IFLA_IPTUN_PROTO]		= { .type = NLA_U8 },
1989 1990 1991 1992
	[IFLA_IPTUN_ENCAP_TYPE]		= { .type = NLA_U16 },
	[IFLA_IPTUN_ENCAP_FLAGS]	= { .type = NLA_U16 },
	[IFLA_IPTUN_ENCAP_SPORT]	= { .type = NLA_U16 },
	[IFLA_IPTUN_ENCAP_DPORT]	= { .type = NLA_U16 },
1993 1994
};

1995 1996 1997
static struct rtnl_link_ops ip6_link_ops __read_mostly = {
	.kind		= "ip6tnl",
	.maxtype	= IFLA_IPTUN_MAX,
1998
	.policy		= ip6_tnl_policy,
1999
	.priv_size	= sizeof(struct ip6_tnl),
2000 2001 2002 2003
	.setup		= ip6_tnl_dev_setup,
	.validate	= ip6_tnl_validate,
	.newlink	= ip6_tnl_newlink,
	.changelink	= ip6_tnl_changelink,
2004
	.dellink	= ip6_tnl_dellink,
2005 2006
	.get_size	= ip6_tnl_get_size,
	.fill_info	= ip6_tnl_fill_info,
2007
	.get_link_net	= ip6_tnl_get_link_net,
2008 2009
};

2010
static struct xfrm6_tunnel ip4ip6_handler __read_mostly = {
2011 2012 2013 2014 2015
	.handler	= ip4ip6_rcv,
	.err_handler	= ip4ip6_err,
	.priority	=	1,
};

2016
static struct xfrm6_tunnel ip6ip6_handler __read_mostly = {
2017 2018
	.handler	= ip6ip6_rcv,
	.err_handler	= ip6ip6_err,
H
Herbert Xu 已提交
2019
	.priority	=	1,
L
Linus Torvalds 已提交
2020 2021
};

2022
static void __net_exit ip6_tnl_destroy_tunnels(struct net *net)
2023
{
2024
	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
N
Nicolas Dichtel 已提交
2025
	struct net_device *dev, *aux;
2026 2027
	int h;
	struct ip6_tnl *t;
2028
	LIST_HEAD(list);
2029

N
Nicolas Dichtel 已提交
2030 2031 2032 2033
	for_each_netdev_safe(net, dev, aux)
		if (dev->rtnl_link_ops == &ip6_link_ops)
			unregister_netdevice_queue(dev, &list);

2034
	for (h = 0; h < IP6_TUNNEL_HASH_SIZE; h++) {
E
Eric Dumazet 已提交
2035
		t = rtnl_dereference(ip6n->tnls_r_l[h]);
2036
		while (t) {
N
Nicolas Dichtel 已提交
2037 2038 2039 2040 2041
			/* If dev is in the same netns, it has already
			 * been added to the list by the previous loop.
			 */
			if (!net_eq(dev_net(t->dev), net))
				unregister_netdevice_queue(t->dev, &list);
E
Eric Dumazet 已提交
2042
			t = rtnl_dereference(t->next);
2043
		}
2044 2045
	}

2046
	unregister_netdevice_many(&list);
2047 2048
}

2049
static int __net_init ip6_tnl_init_net(struct net *net)
2050
{
2051
	struct ip6_tnl_net *ip6n = net_generic(net, ip6_tnl_net_id);
2052
	struct ip6_tnl *t = NULL;
2053 2054
	int err;

2055 2056 2057
	ip6n->tnls[0] = ip6n->tnls_wc;
	ip6n->tnls[1] = ip6n->tnls_r_l;

2058 2059
	err = -ENOMEM;
	ip6n->fb_tnl_dev = alloc_netdev(sizeof(struct ip6_tnl), "ip6tnl0",
2060
					NET_NAME_UNKNOWN, ip6_tnl_dev_setup);
2061 2062 2063

	if (!ip6n->fb_tnl_dev)
		goto err_alloc_dev;
2064
	dev_net_set(ip6n->fb_tnl_dev, net);
2065
	ip6n->fb_tnl_dev->rtnl_link_ops = &ip6_link_ops;
N
Nicolas Dichtel 已提交
2066 2067 2068 2069
	/* FB netdevice is special: we have one, and only one per netns.
	 * Allowing to move it to another netns is clearly unsafe.
	 */
	ip6n->fb_tnl_dev->features |= NETIF_F_NETNS_LOCAL;
2070

E
Eric Dumazet 已提交
2071 2072 2073
	err = ip6_fb_tnl_dev_init(ip6n->fb_tnl_dev);
	if (err < 0)
		goto err_register;
2074 2075 2076 2077

	err = register_netdev(ip6n->fb_tnl_dev);
	if (err < 0)
		goto err_register;
2078 2079 2080 2081

	t = netdev_priv(ip6n->fb_tnl_dev);

	strcpy(t->parms.name, ip6n->fb_tnl_dev->name);
2082 2083
	return 0;

2084
err_register:
E
Eric Dumazet 已提交
2085
	ip6_dev_free(ip6n->fb_tnl_dev);
2086
err_alloc_dev:
2087 2088 2089
	return err;
}

2090
static void __net_exit ip6_tnl_exit_net(struct net *net)
2091
{
2092
	rtnl_lock();
2093
	ip6_tnl_destroy_tunnels(net);
2094
	rtnl_unlock();
2095 2096 2097 2098 2099
}

static struct pernet_operations ip6_tnl_net_ops = {
	.init = ip6_tnl_init_net,
	.exit = ip6_tnl_exit_net,
2100 2101
	.id   = &ip6_tnl_net_id,
	.size = sizeof(struct ip6_tnl_net),
2102 2103
};

L
Linus Torvalds 已提交
2104 2105 2106 2107 2108 2109 2110 2111 2112 2113
/**
 * ip6_tunnel_init - register protocol and reserve needed resources
 *
 * Return: 0 on success
 **/

static int __init ip6_tunnel_init(void)
{
	int  err;

2114 2115 2116 2117 2118 2119
	err = register_pernet_device(&ip6_tnl_net_ops);
	if (err < 0)
		goto out_pernet;

	err = xfrm6_tunnel_register(&ip4ip6_handler, AF_INET);
	if (err < 0) {
2120
		pr_err("%s: can't register ip4ip6\n", __func__);
2121
		goto out_ip4ip6;
2122 2123
	}

2124 2125
	err = xfrm6_tunnel_register(&ip6ip6_handler, AF_INET6);
	if (err < 0) {
2126
		pr_err("%s: can't register ip6ip6\n", __func__);
2127
		goto out_ip6ip6;
L
Linus Torvalds 已提交
2128
	}
2129 2130 2131
	err = rtnl_link_register(&ip6_link_ops);
	if (err < 0)
		goto rtnl_link_failed;
2132

L
Linus Torvalds 已提交
2133
	return 0;
2134

2135 2136
rtnl_link_failed:
	xfrm6_tunnel_deregister(&ip6ip6_handler, AF_INET6);
2137
out_ip6ip6:
2138
	xfrm6_tunnel_deregister(&ip4ip6_handler, AF_INET);
2139 2140 2141
out_ip4ip6:
	unregister_pernet_device(&ip6_tnl_net_ops);
out_pernet:
L
Linus Torvalds 已提交
2142 2143 2144 2145 2146 2147 2148 2149 2150
	return err;
}

/**
 * ip6_tunnel_cleanup - free resources and unregister protocol
 **/

static void __exit ip6_tunnel_cleanup(void)
{
2151
	rtnl_link_unregister(&ip6_link_ops);
2152
	if (xfrm6_tunnel_deregister(&ip4ip6_handler, AF_INET))
2153
		pr_info("%s: can't deregister ip4ip6\n", __func__);
2154

2155
	if (xfrm6_tunnel_deregister(&ip6ip6_handler, AF_INET6))
2156
		pr_info("%s: can't deregister ip6ip6\n", __func__);
L
Linus Torvalds 已提交
2157

2158
	unregister_pernet_device(&ip6_tnl_net_ops);
L
Linus Torvalds 已提交
2159 2160 2161 2162
}

module_init(ip6_tunnel_init);
module_exit(ip6_tunnel_cleanup);