sit.c 41.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5
/*
 *	IPv6 over IPv4 tunnel device - Simple Internet Transition (SIT)
 *	Linux INET6 implementation
 *
 *	Authors:
6
 *	Pedro Roque		<roque@di.fc.ul.pt>
L
Linus Torvalds 已提交
7 8 9 10 11 12 13 14 15 16
 *	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.
 *
 *	Changes:
 * Roger Venning <r.venning@telstra.com>:	6to4 support
 * Nate Thompson <nate@thebog.net>:		6to4 support
17
 * Fred Templin <fred.l.templin@boeing.com>:	isatap support
L
Linus Torvalds 已提交
18 19
 */

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

L
Linus Torvalds 已提交
22
#include <linux/module.h>
23
#include <linux/capability.h>
L
Linus Torvalds 已提交
24 25 26 27 28 29 30 31 32
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <linux/in6.h>
#include <linux/netdevice.h>
#include <linux/if_arp.h>
#include <linux/icmp.h>
33
#include <linux/slab.h>
L
Linus Torvalds 已提交
34 35 36
#include <asm/uaccess.h>
#include <linux/init.h>
#include <linux/netfilter_ipv4.h>
37
#include <linux/if_ether.h>
L
Linus Torvalds 已提交
38 39 40 41 42 43 44 45 46 47 48 49 50 51

#include <net/sock.h>
#include <net/snmp.h>

#include <net/ipv6.h>
#include <net/protocol.h>
#include <net/transp_v6.h>
#include <net/ip6_fib.h>
#include <net/ip6_route.h>
#include <net/ndisc.h>
#include <net/addrconf.h>
#include <net/ip.h>
#include <net/udp.h>
#include <net/icmp.h>
52
#include <net/ip_tunnels.h>
L
Linus Torvalds 已提交
53 54 55
#include <net/inet_ecn.h>
#include <net/xfrm.h>
#include <net/dsfield.h>
56 57
#include <net/net_namespace.h>
#include <net/netns/generic.h>
L
Linus Torvalds 已提交
58 59 60 61 62 63 64 65

/*
   This version of net/ipv6/sit.c is cloned of net/ipv4/ip_gre.c

   For comments look at net/ipv4/ip_gre.c --ANK
 */

#define HASH_SIZE  16
A
Al Viro 已提交
66
#define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
L
Linus Torvalds 已提交
67

68 69 70 71
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 已提交
72
static int ipip6_tunnel_init(struct net_device *dev);
L
Linus Torvalds 已提交
73
static void ipip6_tunnel_setup(struct net_device *dev);
E
Eric Dumazet 已提交
74
static void ipip6_dev_free(struct net_device *dev);
75 76
static bool check_6rd(struct ip_tunnel *tunnel, const struct in6_addr *v6dst,
		      __be32 *v4dst);
77
static struct rtnl_link_ops sit_link_ops __read_mostly;
L
Linus Torvalds 已提交
78

79
static int sit_net_id __read_mostly;
80
struct sit_net {
E
Eric Dumazet 已提交
81 82 83 84 85
	struct ip_tunnel __rcu *tunnels_r_l[HASH_SIZE];
	struct ip_tunnel __rcu *tunnels_r[HASH_SIZE];
	struct ip_tunnel __rcu *tunnels_l[HASH_SIZE];
	struct ip_tunnel __rcu *tunnels_wc[1];
	struct ip_tunnel __rcu **tunnels[4];
86

87
	struct net_device *fb_tunnel_dev;
88 89
};

E
Eric Dumazet 已提交
90 91 92
/*
 * Must be invoked with rcu_read_lock
 */
E
Eldad Zack 已提交
93
static struct ip_tunnel *ipip6_tunnel_lookup(struct net *net,
94
		struct net_device *dev, __be32 remote, __be32 local)
L
Linus Torvalds 已提交
95
{
E
Eric Dumazet 已提交
96 97
	unsigned int h0 = HASH(remote);
	unsigned int h1 = HASH(local);
L
Linus Torvalds 已提交
98
	struct ip_tunnel *t;
99
	struct sit_net *sitn = net_generic(net, sit_net_id);
L
Linus Torvalds 已提交
100

A
Amerigo Wang 已提交
101
	for_each_ip_tunnel_rcu(t, sitn->tunnels_r_l[h0 ^ h1]) {
L
Linus Torvalds 已提交
102
		if (local == t->parms.iph.saddr &&
103 104 105
		    remote == t->parms.iph.daddr &&
		    (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
		    (t->dev->flags & IFF_UP))
L
Linus Torvalds 已提交
106 107
			return t;
	}
A
Amerigo Wang 已提交
108
	for_each_ip_tunnel_rcu(t, sitn->tunnels_r[h0]) {
109 110 111
		if (remote == t->parms.iph.daddr &&
		    (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
		    (t->dev->flags & IFF_UP))
L
Linus Torvalds 已提交
112 113
			return t;
	}
A
Amerigo Wang 已提交
114
	for_each_ip_tunnel_rcu(t, sitn->tunnels_l[h1]) {
115 116 117
		if (local == t->parms.iph.saddr &&
		    (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
		    (t->dev->flags & IFF_UP))
L
Linus Torvalds 已提交
118 119
			return t;
	}
E
Eric Dumazet 已提交
120
	t = rcu_dereference(sitn->tunnels_wc[0]);
121
	if ((t != NULL) && (t->dev->flags & IFF_UP))
L
Linus Torvalds 已提交
122 123 124 125
		return t;
	return NULL;
}

E
Eric Dumazet 已提交
126
static struct ip_tunnel __rcu **__ipip6_bucket(struct sit_net *sitn,
127
		struct ip_tunnel_parm *parms)
L
Linus Torvalds 已提交
128
{
129 130
	__be32 remote = parms->iph.daddr;
	__be32 local = parms->iph.saddr;
E
Eric Dumazet 已提交
131
	unsigned int h = 0;
L
Linus Torvalds 已提交
132 133 134 135 136 137 138 139 140 141
	int prio = 0;

	if (remote) {
		prio |= 2;
		h ^= HASH(remote);
	}
	if (local) {
		prio |= 1;
		h ^= HASH(local);
	}
142
	return &sitn->tunnels[prio][h];
L
Linus Torvalds 已提交
143 144
}

E
Eric Dumazet 已提交
145
static inline struct ip_tunnel __rcu **ipip6_bucket(struct sit_net *sitn,
146
		struct ip_tunnel *t)
147
{
148
	return __ipip6_bucket(sitn, &t->parms);
149 150
}

151
static void ipip6_tunnel_unlink(struct sit_net *sitn, struct ip_tunnel *t)
L
Linus Torvalds 已提交
152
{
E
Eric Dumazet 已提交
153 154 155 156 157 158 159
	struct ip_tunnel __rcu **tp;
	struct ip_tunnel *iter;

	for (tp = ipip6_bucket(sitn, t);
	     (iter = rtnl_dereference(*tp)) != NULL;
	     tp = &iter->next) {
		if (t == iter) {
160
			rcu_assign_pointer(*tp, t->next);
L
Linus Torvalds 已提交
161 162 163 164 165
			break;
		}
	}
}

166
static void ipip6_tunnel_link(struct sit_net *sitn, struct ip_tunnel *t)
L
Linus Torvalds 已提交
167
{
E
Eric Dumazet 已提交
168
	struct ip_tunnel __rcu **tp = ipip6_bucket(sitn, t);
L
Linus Torvalds 已提交
169

170 171
	rcu_assign_pointer(t->next, rtnl_dereference(*tp));
	rcu_assign_pointer(*tp, t);
L
Linus Torvalds 已提交
172 173
}

174
static void ipip6_tunnel_clone_6rd(struct net_device *dev, struct sit_net *sitn)
175 176
{
#ifdef CONFIG_IPV6_SIT_6RD
177 178
	struct ip_tunnel *t = netdev_priv(dev);

179 180 181 182 183 184 185 186 187 188 189 190
	if (t->dev == sitn->fb_tunnel_dev) {
		ipv6_addr_set(&t->ip6rd.prefix, htonl(0x20020000), 0, 0, 0);
		t->ip6rd.relay_prefix = 0;
		t->ip6rd.prefixlen = 16;
		t->ip6rd.relay_prefixlen = 0;
	} else {
		struct ip_tunnel *t0 = netdev_priv(sitn->fb_tunnel_dev);
		memcpy(&t->ip6rd, &t0->ip6rd, sizeof(t->ip6rd));
	}
#endif
}

191 192 193 194 195 196 197 198 199 200 201 202
static int ipip6_tunnel_create(struct net_device *dev)
{
	struct ip_tunnel *t = netdev_priv(dev);
	struct net *net = dev_net(dev);
	struct sit_net *sitn = net_generic(net, sit_net_id);
	int err;

	err = ipip6_tunnel_init(dev);
	if (err < 0)
		goto out;
	ipip6_tunnel_clone_6rd(dev, sitn);

N
Nicolas Dichtel 已提交
203
	if ((__force u16)t->parms.i_flags & SIT_ISATAP)
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
		dev->priv_flags |= IFF_ISATAP;

	err = register_netdevice(dev);
	if (err < 0)
		goto out;

	strcpy(t->parms.name, dev->name);
	dev->rtnl_link_ops = &sit_link_ops;

	dev_hold(dev);

	ipip6_tunnel_link(sitn, t);
	return 0;

out:
	return err;
}

E
Eric Dumazet 已提交
222
static struct ip_tunnel *ipip6_tunnel_locate(struct net *net,
223
		struct ip_tunnel_parm *parms, int create)
L
Linus Torvalds 已提交
224
{
A
Al Viro 已提交
225 226
	__be32 remote = parms->iph.daddr;
	__be32 local = parms->iph.saddr;
E
Eric Dumazet 已提交
227 228
	struct ip_tunnel *t, *nt;
	struct ip_tunnel __rcu **tp;
L
Linus Torvalds 已提交
229 230
	struct net_device *dev;
	char name[IFNAMSIZ];
231
	struct sit_net *sitn = net_generic(net, sit_net_id);
L
Linus Torvalds 已提交
232

E
Eric Dumazet 已提交
233 234 235
	for (tp = __ipip6_bucket(sitn, parms);
	    (t = rtnl_dereference(*tp)) != NULL;
	     tp = &t->next) {
236
		if (local == t->parms.iph.saddr &&
237 238
		    remote == t->parms.iph.daddr &&
		    parms->link == t->parms.link) {
239 240 241 242 243
			if (create)
				return NULL;
			else
				return t;
		}
L
Linus Torvalds 已提交
244 245 246 247 248 249
	}
	if (!create)
		goto failed;

	if (parms->name[0])
		strlcpy(name, parms->name, IFNAMSIZ);
250
	else
E
Eric Dumazet 已提交
251
		strcpy(name, "sit%d");
L
Linus Torvalds 已提交
252 253 254 255 256

	dev = alloc_netdev(sizeof(*t), name, ipip6_tunnel_setup);
	if (dev == NULL)
		return NULL;

257 258
	dev_net_set(dev, net);

259
	nt = netdev_priv(dev);
260

L
Linus Torvalds 已提交
261
	nt->parms = *parms;
262
	if (ipip6_tunnel_create(dev) < 0)
263
		goto failed_free;
L
Linus Torvalds 已提交
264 265 266

	return nt;

267
failed_free:
E
Eric Dumazet 已提交
268
	ipip6_dev_free(dev);
L
Linus Torvalds 已提交
269 270 271 272
failed:
	return NULL;
}

E
Eric Dumazet 已提交
273 274 275 276 277
#define for_each_prl_rcu(start)			\
	for (prl = rcu_dereference(start);	\
	     prl;				\
	     prl = rcu_dereference(prl->next))

278
static struct ip_tunnel_prl_entry *
279
__ipip6_tunnel_locate_prl(struct ip_tunnel *t, __be32 addr)
280
{
E
Eric Dumazet 已提交
281
	struct ip_tunnel_prl_entry *prl;
282

E
Eric Dumazet 已提交
283 284
	for_each_prl_rcu(t->prl)
		if (prl->addr == addr)
285
			break;
E
Eric Dumazet 已提交
286
	return prl;
287 288 289

}

290 291
static int ipip6_tunnel_get_prl(struct ip_tunnel *t,
				struct ip_tunnel_prl __user *a)
292
{
293
	struct ip_tunnel_prl kprl, *kp;
294 295 296 297
	struct ip_tunnel_prl_entry *prl;
	unsigned int cmax, c = 0, ca, len;
	int ret = 0;

298 299 300 301
	if (copy_from_user(&kprl, a, sizeof(kprl)))
		return -EFAULT;
	cmax = kprl.datalen / sizeof(kprl);
	if (cmax > 1 && kprl.addr != htonl(INADDR_ANY))
302 303 304 305 306 307 308 309 310
		cmax = 1;

	/* For simple GET or for root users,
	 * we try harder to allocate.
	 */
	kp = (cmax <= 1 || capable(CAP_NET_ADMIN)) ?
		kcalloc(cmax, sizeof(*kp), GFP_KERNEL) :
		NULL;

E
Eric Dumazet 已提交
311
	rcu_read_lock();
312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328

	ca = t->prl_count < cmax ? t->prl_count : cmax;

	if (!kp) {
		/* We don't try hard to allocate much memory for
		 * non-root users.
		 * For root users, retry allocating enough memory for
		 * the answer.
		 */
		kp = kcalloc(ca, sizeof(*kp), GFP_ATOMIC);
		if (!kp) {
			ret = -ENOMEM;
			goto out;
		}
	}

	c = 0;
E
Eric Dumazet 已提交
329
	for_each_prl_rcu(t->prl) {
330
		if (c >= cmax)
331
			break;
332
		if (kprl.addr != htonl(INADDR_ANY) && prl->addr != kprl.addr)
333 334 335 336
			continue;
		kp[c].addr = prl->addr;
		kp[c].flags = prl->flags;
		c++;
337
		if (kprl.addr != htonl(INADDR_ANY))
338 339 340
			break;
	}
out:
E
Eric Dumazet 已提交
341
	rcu_read_unlock();
342 343

	len = sizeof(*kp) * c;
344 345 346
	ret = 0;
	if ((len && copy_to_user(a + 1, kp, len)) || put_user(len, &a->datalen))
		ret = -EFAULT;
347 348 349

	kfree(kp);

350
	return ret;
351 352
}

353 354 355 356
static int
ipip6_tunnel_add_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a, int chg)
{
	struct ip_tunnel_prl_entry *p;
357 358
	int err = 0;

359 360 361
	if (a->addr == htonl(INADDR_ANY))
		return -EINVAL;

E
Eric Dumazet 已提交
362
	ASSERT_RTNL();
363

E
Eric Dumazet 已提交
364
	for (p = rtnl_dereference(t->prl); p; p = rtnl_dereference(p->next)) {
365
		if (p->addr == a->addr) {
E
Eric Dumazet 已提交
366 367 368 369
			if (chg) {
				p->flags = a->flags;
				goto out;
			}
370 371
			err = -EEXIST;
			goto out;
372 373 374
		}
	}

375 376 377 378
	if (chg) {
		err = -ENXIO;
		goto out;
	}
379 380

	p = kzalloc(sizeof(struct ip_tunnel_prl_entry), GFP_KERNEL);
381 382 383 384
	if (!p) {
		err = -ENOBUFS;
		goto out;
	}
385 386

	p->next = t->prl;
387 388
	p->addr = a->addr;
	p->flags = a->flags;
E
Eric Dumazet 已提交
389
	t->prl_count++;
390
	rcu_assign_pointer(t->prl, p);
391 392
out:
	return err;
393 394
}

E
Eric Dumazet 已提交
395 396 397 398 399 400
static void prl_list_destroy_rcu(struct rcu_head *head)
{
	struct ip_tunnel_prl_entry *p, *n;

	p = container_of(head, struct ip_tunnel_prl_entry, rcu_head);
	do {
401
		n = rcu_dereference_protected(p->next, 1);
E
Eric Dumazet 已提交
402 403 404 405 406
		kfree(p);
		p = n;
	} while (p);
}

407 408 409
static int
ipip6_tunnel_del_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a)
{
410 411
	struct ip_tunnel_prl_entry *x;
	struct ip_tunnel_prl_entry __rcu **p;
412 413
	int err = 0;

E
Eric Dumazet 已提交
414
	ASSERT_RTNL();
415

416
	if (a && a->addr != htonl(INADDR_ANY)) {
417 418 419 420
		for (p = &t->prl;
		     (x = rtnl_dereference(*p)) != NULL;
		     p = &x->next) {
			if (x->addr == a->addr) {
421
				*p = x->next;
422
				kfree_rcu(x, rcu_head);
423
				t->prl_count--;
424
				goto out;
425 426
			}
		}
427
		err = -ENXIO;
428
	} else {
429 430
		x = rtnl_dereference(t->prl);
		if (x) {
E
Eric Dumazet 已提交
431 432 433
			t->prl_count = 0;
			call_rcu(&x->rcu_head, prl_list_destroy_rcu);
			t->prl = NULL;
434 435
		}
	}
436
out:
437
	return err;
438 439 440
}

static int
441
isatap_chksrc(struct sk_buff *skb, const struct iphdr *iph, struct ip_tunnel *t)
442
{
443
	struct ip_tunnel_prl_entry *p;
444 445
	int ok = 1;

E
Eric Dumazet 已提交
446
	rcu_read_lock();
447
	p = __ipip6_tunnel_locate_prl(t, iph->saddr);
448
	if (p) {
449
		if (p->flags & PRL_DEFAULT)
450 451 452 453
			skb->ndisc_nodetype = NDISC_NODETYPE_DEFAULT;
		else
			skb->ndisc_nodetype = NDISC_NODETYPE_NODEFAULT;
	} else {
454 455
		const struct in6_addr *addr6 = &ipv6_hdr(skb)->saddr;

456 457
		if (ipv6_addr_is_isatap(addr6) &&
		    (addr6->s6_addr32[3] == iph->saddr) &&
458
		    ipv6_chk_prefix(addr6, t->dev))
459 460 461 462
			skb->ndisc_nodetype = NDISC_NODETYPE_HOST;
		else
			ok = 0;
	}
E
Eric Dumazet 已提交
463
	rcu_read_unlock();
464 465 466
	return ok;
}

L
Linus Torvalds 已提交
467 468
static void ipip6_tunnel_uninit(struct net_device *dev)
{
N
Nicolas Dichtel 已提交
469 470
	struct ip_tunnel *tunnel = netdev_priv(dev);
	struct sit_net *sitn = net_generic(tunnel->net, sit_net_id);
471

472
	if (dev == sitn->fb_tunnel_dev) {
473
		RCU_INIT_POINTER(sitn->tunnels_wc[0], NULL);
L
Linus Torvalds 已提交
474
	} else {
N
Nicolas Dichtel 已提交
475 476
		ipip6_tunnel_unlink(sitn, tunnel);
		ipip6_tunnel_del_prl(tunnel, NULL);
L
Linus Torvalds 已提交
477
	}
E
Eric Dumazet 已提交
478
	dev_put(dev);
L
Linus Torvalds 已提交
479 480
}

481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
/* Generate icmpv6 with type/code ICMPV6_DEST_UNREACH/ICMPV6_ADDR_UNREACH
 * if sufficient data bytes are available
 */
static int ipip6_err_gen_icmpv6_unreach(struct sk_buff *skb)
{
	const struct iphdr *iph = (const struct iphdr *) skb->data;
	struct rt6_info *rt;
	struct sk_buff *skb2;

	if (!pskb_may_pull(skb, iph->ihl * 4 + sizeof(struct ipv6hdr) + 8))
		return 1;

	skb2 = skb_clone(skb, GFP_ATOMIC);

	if (!skb2)
		return 1;

	skb_dst_drop(skb2);
	skb_pull(skb2, iph->ihl * 4);
	skb_reset_network_header(skb2);

	rt = rt6_lookup(dev_net(skb->dev), &ipv6_hdr(skb2)->saddr, NULL, 0, 0);

	if (rt && rt->dst.dev)
		skb2->dev = rt->dst.dev;

	icmpv6_send(skb2, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH, 0);

	if (rt)
		ip6_rt_put(rt);

	kfree_skb(skb2);

	return 0;
}
L
Linus Torvalds 已提交
516

517
static int ipip6_err(struct sk_buff *skb, u32 info)
L
Linus Torvalds 已提交
518
{
519
	const struct iphdr *iph = (const struct iphdr *)skb->data;
520 521
	const int type = icmp_hdr(skb)->type;
	const int code = icmp_hdr(skb)->code;
L
Linus Torvalds 已提交
522
	struct ip_tunnel *t;
523
	int err;
L
Linus Torvalds 已提交
524 525 526 527

	switch (type) {
	default:
	case ICMP_PARAMETERPROB:
528
		return 0;
L
Linus Torvalds 已提交
529 530 531 532 533

	case ICMP_DEST_UNREACH:
		switch (code) {
		case ICMP_SR_FAILED:
			/* Impossible event. */
534
			return 0;
L
Linus Torvalds 已提交
535 536 537 538 539 540 541 542 543 544
		default:
			/* All others are translated to HOST_UNREACH.
			   rfc2003 contains "deep thoughts" about NET_UNREACH,
			   I believe they are just ether pollution. --ANK
			 */
			break;
		}
		break;
	case ICMP_TIME_EXCEEDED:
		if (code != ICMP_EXC_TTL)
545
			return 0;
L
Linus Torvalds 已提交
546
		break;
547 548
	case ICMP_REDIRECT:
		break;
L
Linus Torvalds 已提交
549 550
	}

551 552
	err = -ENOENT;

553 554 555 556
	t = ipip6_tunnel_lookup(dev_net(skb->dev),
				skb->dev,
				iph->daddr,
				iph->saddr);
557 558 559 560 561 562 563 564 565
	if (t == NULL)
		goto out;

	if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
		ipv4_update_pmtu(skb, dev_net(skb->dev), info,
				 t->dev->ifindex, 0, IPPROTO_IPV6, 0);
		err = 0;
		goto out;
	}
566 567 568 569 570 571
	if (type == ICMP_REDIRECT) {
		ipv4_redirect(skb, dev_net(skb->dev), t->dev->ifindex, 0,
			      IPPROTO_IPV6, 0);
		err = 0;
		goto out;
	}
572 573

	if (t->parms.iph.daddr == 0)
L
Linus Torvalds 已提交
574
		goto out;
575 576

	err = 0;
577 578 579
	if (!ipip6_err_gen_icmpv6_unreach(skb))
		goto out;

L
Linus Torvalds 已提交
580 581 582
	if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
		goto out;

583
	if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
L
Linus Torvalds 已提交
584 585 586 587 588
		t->err_count++;
	else
		t->err_count = 1;
	t->err_time = jiffies;
out:
589
	return err;
L
Linus Torvalds 已提交
590 591
}

592 593 594 595 596 597 598 599 600
static inline bool is_spoofed_6rd(struct ip_tunnel *tunnel, const __be32 v4addr,
				  const struct in6_addr *v6addr)
{
	__be32 v4embed = 0;
	if (check_6rd(tunnel, v6addr, &v4embed) && v4addr != v4embed)
		return true;
	return false;
}

601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664
/* Checks if an address matches an address on the tunnel interface.
 * Used to detect the NAT of proto 41 packets and let them pass spoofing test.
 * Long story:
 * This function is called after we considered the packet as spoofed
 * in is_spoofed_6rd.
 * We may have a router that is doing NAT for proto 41 packets
 * for an internal station. Destination a.a.a.a/PREFIX:bbbb:bbbb
 * will be translated to n.n.n.n/PREFIX:bbbb:bbbb. And is_spoofed_6rd
 * function will return true, dropping the packet.
 * But, we can still check if is spoofed against the IP
 * addresses associated with the interface.
 */
static bool only_dnatted(const struct ip_tunnel *tunnel,
	const struct in6_addr *v6dst)
{
	int prefix_len;

#ifdef CONFIG_IPV6_SIT_6RD
	prefix_len = tunnel->ip6rd.prefixlen + 32
		- tunnel->ip6rd.relay_prefixlen;
#else
	prefix_len = 48;
#endif
	return ipv6_chk_custom_prefix(v6dst, prefix_len, tunnel->dev);
}

/* Returns true if a packet is spoofed */
static bool packet_is_spoofed(struct sk_buff *skb,
			      const struct iphdr *iph,
			      struct ip_tunnel *tunnel)
{
	const struct ipv6hdr *ipv6h;

	if (tunnel->dev->priv_flags & IFF_ISATAP) {
		if (!isatap_chksrc(skb, iph, tunnel))
			return true;

		return false;
	}

	if (tunnel->dev->flags & IFF_POINTOPOINT)
		return false;

	ipv6h = ipv6_hdr(skb);

	if (unlikely(is_spoofed_6rd(tunnel, iph->saddr, &ipv6h->saddr))) {
		net_warn_ratelimited("Src spoofed %pI4/%pI6c -> %pI4/%pI6c\n",
				     &iph->saddr, &ipv6h->saddr,
				     &iph->daddr, &ipv6h->daddr);
		return true;
	}

	if (likely(!is_spoofed_6rd(tunnel, iph->daddr, &ipv6h->daddr)))
		return false;

	if (only_dnatted(tunnel, &ipv6h->daddr))
		return false;

	net_warn_ratelimited("Dst spoofed %pI4/%pI6c -> %pI4/%pI6c\n",
			     &iph->saddr, &ipv6h->saddr,
			     &iph->daddr, &ipv6h->daddr);
	return true;
}

L
Linus Torvalds 已提交
665 666
static int ipip6_rcv(struct sk_buff *skb)
{
667
	const struct iphdr *iph = ip_hdr(skb);
L
Linus Torvalds 已提交
668
	struct ip_tunnel *tunnel;
669
	int err;
L
Linus Torvalds 已提交
670

671 672 673
	tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
				     iph->saddr, iph->daddr);
	if (tunnel != NULL) {
E
Eric Dumazet 已提交
674 675
		struct pcpu_tstats *tstats;

676 677 678 679
		if (tunnel->parms.iph.protocol != IPPROTO_IPV6 &&
		    tunnel->parms.iph.protocol != 0)
			goto out;

680
		skb->mac_header = skb->network_header;
681
		skb_reset_network_header(skb);
682
		IPCB(skb)->flags = 0;
L
Linus Torvalds 已提交
683
		skb->protocol = htons(ETH_P_IPV6);
F
Fred L. Templin 已提交
684

685 686 687
		if (packet_is_spoofed(skb, iph, tunnel)) {
			tunnel->dev->stats.rx_errors++;
			goto out;
688 689
		}

690
		__skb_tunnel_rx(skb, tunnel->dev, tunnel->net);
691 692 693 694 695 696 697 698 699 700 701

		err = IP_ECN_decapsulate(iph, skb);
		if (unlikely(err)) {
			if (log_ecn_error)
				net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
						     &iph->saddr, iph->tos);
			if (err > 1) {
				++tunnel->dev->stats.rx_frame_errors;
				++tunnel->dev->stats.rx_errors;
				goto out;
			}
F
Fred L. Templin 已提交
702
		}
703

E
Eric Dumazet 已提交
704 705 706 707
		tstats = this_cpu_ptr(tunnel->dev->tstats);
		tstats->rx_packets++;
		tstats->rx_bytes += skb->len;

708
		netif_rx(skb);
E
Eric Dumazet 已提交
709

L
Linus Torvalds 已提交
710 711 712
		return 0;
	}

713 714
	/* no tunnel matched,  let upstream know, ipsec may handle it */
	return 1;
L
Linus Torvalds 已提交
715
out:
716
	kfree_skb(skb);
L
Linus Torvalds 已提交
717 718 719
	return 0;
}

720 721 722 723 724 725 726
static const struct tnl_ptk_info tpi = {
	/* no tunnel info required for ipip. */
	.proto = htons(ETH_P_IP),
};

static int ipip_rcv(struct sk_buff *skb)
{
727
	const struct iphdr *iph;
728 729
	struct ip_tunnel *tunnel;

730
	iph = ip_hdr(skb);
731 732 733 734 735 736 737 738 739
	tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
				     iph->saddr, iph->daddr);
	if (tunnel != NULL) {
		if (tunnel->parms.iph.protocol != IPPROTO_IPIP &&
		    tunnel->parms.iph.protocol != 0)
			goto drop;

		if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
			goto drop;
740 741
		if (iptunnel_pull_header(skb, 0, tpi.proto))
			goto drop;
742 743 744 745 746 747 748 749 750 751
		return ip_tunnel_rcv(tunnel, skb, &tpi, log_ecn_error);
	}

	return 1;

drop:
	kfree_skb(skb);
	return 0;
}

752
/*
753 754
 * If the IPv6 address comes from 6rd / 6to4 (RFC 3056) addr space this function
 * stores the embedded IPv4 address in v4dst and returns true.
755
 */
756 757
static bool check_6rd(struct ip_tunnel *tunnel, const struct in6_addr *v6dst,
		      __be32 *v4dst)
L
Linus Torvalds 已提交
758
{
759 760 761
#ifdef CONFIG_IPV6_SIT_6RD
	if (ipv6_prefix_equal(v6dst, &tunnel->ip6rd.prefix,
			      tunnel->ip6rd.prefixlen)) {
E
Eric Dumazet 已提交
762
		unsigned int pbw0, pbi0;
763 764 765 766 767 768
		int pbi1;
		u32 d;

		pbw0 = tunnel->ip6rd.prefixlen >> 5;
		pbi0 = tunnel->ip6rd.prefixlen & 0x1f;

769
		d = (ntohl(v6dst->s6_addr32[pbw0]) << pbi0) >>
770 771 772 773
		    tunnel->ip6rd.relay_prefixlen;

		pbi1 = pbi0 - tunnel->ip6rd.relay_prefixlen;
		if (pbi1 > 0)
774
			d |= ntohl(v6dst->s6_addr32[pbw0 + 1]) >>
775 776
			     (32 - pbi1);

777 778
		*v4dst = tunnel->ip6rd.relay_prefix | htonl(d);
		return true;
779 780
	}
#else
L
Linus Torvalds 已提交
781
	if (v6dst->s6_addr16[0] == htons(0x2002)) {
782
		/* 6to4 v6 addr has 16 bits prefix, 32 v4addr, 16 SLA, ... */
783 784
		memcpy(v4dst, &v6dst->s6_addr16[1], 4);
		return true;
L
Linus Torvalds 已提交
785
	}
786
#endif
787 788 789 790 791 792 793 794
	return false;
}

static inline __be32 try_6rd(struct ip_tunnel *tunnel,
			     const struct in6_addr *v6dst)
{
	__be32 dst = 0;
	check_6rd(tunnel, v6dst, &dst);
L
Linus Torvalds 已提交
795 796 797 798 799 800 801 802
	return dst;
}

/*
 *	This function assumes it is being called from dev_queue_xmit()
 *	and that skb is filled properly by that function.
 */

803 804
static netdev_tx_t ipip6_tunnel_xmit(struct sk_buff *skb,
				     struct net_device *dev)
L
Linus Torvalds 已提交
805
{
806
	struct ip_tunnel *tunnel = netdev_priv(dev);
807 808
	const struct iphdr  *tiph = &tunnel->parms.iph;
	const struct ipv6hdr *iph6 = ipv6_hdr(skb);
L
Linus Torvalds 已提交
809
	u8     tos = tunnel->parms.iph.tos;
810
	__be16 df = tiph->frag_off;
L
Linus Torvalds 已提交
811
	struct rtable *rt;     			/* Route to the other host */
E
Eric Dumazet 已提交
812
	struct net_device *tdev;		/* Device to other host */
813
	unsigned int max_headroom;		/* The extra header space needed */
A
Al Viro 已提交
814
	__be32 dst = tiph->daddr;
815
	struct flowi4 fl4;
L
Linus Torvalds 已提交
816
	int    mtu;
817
	const struct in6_addr *addr6;
L
Linus Torvalds 已提交
818
	int addr_type;
819 820
	u8 ttl;
	int err;
L
Linus Torvalds 已提交
821 822 823 824

	if (skb->protocol != htons(ETH_P_IPV6))
		goto tx_error;

825 826 827
	if (tos == 1)
		tos = ipv6_get_dsfield(iph6);

F
Fred L. Templin 已提交
828 829 830
	/* ISATAP (RFC4214) - must come before 6to4 */
	if (dev->priv_flags & IFF_ISATAP) {
		struct neighbour *neigh = NULL;
831
		bool do_tx_error = false;
F
Fred L. Templin 已提交
832

E
Eric Dumazet 已提交
833
		if (skb_dst(skb))
834
			neigh = dst_neigh_lookup(skb_dst(skb), &iph6->daddr);
F
Fred L. Templin 已提交
835 836

		if (neigh == NULL) {
837
			net_dbg_ratelimited("nexthop == NULL\n");
F
Fred L. Templin 已提交
838 839 840
			goto tx_error;
		}

E
Eldad Zack 已提交
841
		addr6 = (const struct in6_addr *)&neigh->primary_key;
F
Fred L. Templin 已提交
842 843 844 845 846 847
		addr_type = ipv6_addr_type(addr6);

		if ((addr_type & IPV6_ADDR_UNICAST) &&
		     ipv6_addr_is_isatap(addr6))
			dst = addr6->s6_addr32[3];
		else
848 849 850 851
			do_tx_error = true;

		neigh_release(neigh);
		if (do_tx_error)
F
Fred L. Templin 已提交
852 853 854
			goto tx_error;
	}

L
Linus Torvalds 已提交
855
	if (!dst)
856
		dst = try_6rd(tunnel, &iph6->daddr);
L
Linus Torvalds 已提交
857 858 859

	if (!dst) {
		struct neighbour *neigh = NULL;
860
		bool do_tx_error = false;
L
Linus Torvalds 已提交
861

E
Eric Dumazet 已提交
862
		if (skb_dst(skb))
863
			neigh = dst_neigh_lookup(skb_dst(skb), &iph6->daddr);
L
Linus Torvalds 已提交
864 865

		if (neigh == NULL) {
866
			net_dbg_ratelimited("nexthop == NULL\n");
L
Linus Torvalds 已提交
867 868 869
			goto tx_error;
		}

E
Eldad Zack 已提交
870
		addr6 = (const struct in6_addr *)&neigh->primary_key;
L
Linus Torvalds 已提交
871 872 873
		addr_type = ipv6_addr_type(addr6);

		if (addr_type == IPV6_ADDR_ANY) {
874
			addr6 = &ipv6_hdr(skb)->daddr;
L
Linus Torvalds 已提交
875 876 877
			addr_type = ipv6_addr_type(addr6);
		}

878 879 880 881
		if ((addr_type & IPV6_ADDR_COMPATv4) != 0)
			dst = addr6->s6_addr32[3];
		else
			do_tx_error = true;
L
Linus Torvalds 已提交
882

883 884 885
		neigh_release(neigh);
		if (do_tx_error)
			goto tx_error;
L
Linus Torvalds 已提交
886 887
	}

N
Nicolas Dichtel 已提交
888
	rt = ip_route_output_ports(tunnel->net, &fl4, NULL,
889 890 891 892 893 894 895
				   dst, tiph->saddr,
				   0, 0,
				   IPPROTO_IPV6, RT_TOS(tos),
				   tunnel->parms.link);
	if (IS_ERR(rt)) {
		dev->stats.tx_carrier_errors++;
		goto tx_error_icmp;
L
Linus Torvalds 已提交
896 897 898
	}
	if (rt->rt_type != RTN_UNICAST) {
		ip_rt_put(rt);
E
Eric Dumazet 已提交
899
		dev->stats.tx_carrier_errors++;
L
Linus Torvalds 已提交
900 901
		goto tx_error_icmp;
	}
902
	tdev = rt->dst.dev;
L
Linus Torvalds 已提交
903 904 905

	if (tdev == dev) {
		ip_rt_put(rt);
E
Eric Dumazet 已提交
906
		dev->stats.collisions++;
L
Linus Torvalds 已提交
907 908 909
		goto tx_error;
	}

910
	if (df) {
911
		mtu = dst_mtu(&rt->dst) - sizeof(struct iphdr);
L
Linus Torvalds 已提交
912

913
		if (mtu < 68) {
E
Eric Dumazet 已提交
914
			dev->stats.collisions++;
915 916 917
			ip_rt_put(rt);
			goto tx_error;
		}
L
Linus Torvalds 已提交
918

919 920 921 922 923 924
		if (mtu < IPV6_MIN_MTU) {
			mtu = IPV6_MIN_MTU;
			df = 0;
		}

		if (tunnel->parms.iph.daddr && skb_dst(skb))
925
			skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
926 927

		if (skb->len > mtu) {
928
			icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
929 930 931
			ip_rt_put(rt);
			goto tx_error;
		}
L
Linus Torvalds 已提交
932 933 934
	}

	if (tunnel->err_count > 0) {
935 936
		if (time_before(jiffies,
				tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
L
Linus Torvalds 已提交
937 938 939 940 941 942 943 944 945 946 947
			tunnel->err_count--;
			dst_link_failure(skb);
		} else
			tunnel->err_count = 0;
	}

	/*
	 * Okay, now see if we can stuff it in the buffer as-is.
	 */
	max_headroom = LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr);

948 949
	if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
	    (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
L
Linus Torvalds 已提交
950 951 952
		struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
		if (!new_skb) {
			ip_rt_put(rt);
E
Eric Dumazet 已提交
953
			dev->stats.tx_dropped++;
954
			kfree_skb(skb);
955
			return NETDEV_TX_OK;
L
Linus Torvalds 已提交
956 957 958 959 960
		}
		if (skb->sk)
			skb_set_owner_w(new_skb, skb->sk);
		dev_kfree_skb(skb);
		skb = new_skb;
961
		iph6 = ipv6_hdr(skb);
L
Linus Torvalds 已提交
962
	}
963 964 965 966
	ttl = tiph->ttl;
	if (ttl == 0)
		ttl = iph6->hop_limit;
	tos = INET_ECN_encapsulate(tos, ipv6_get_dsfield(iph6));
L
Linus Torvalds 已提交
967

E
Eric Dumazet 已提交
968 969 970
	skb = iptunnel_handle_offloads(skb, false, SKB_GSO_SIT);
	if (IS_ERR(skb))
		goto out;
971

972
	err = iptunnel_xmit(rt, skb, fl4.saddr, fl4.daddr, IPPROTO_IPV6, tos,
973
			    ttl, df, !net_eq(tunnel->net, dev_net(dev)));
974
	iptunnel_xmit_stats(err, &dev->stats, dev->tstats);
975
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
976 977 978 979

tx_error_icmp:
	dst_link_failure(skb);
tx_error:
980
	kfree_skb(skb);
E
Eric Dumazet 已提交
981 982
out:
	dev->stats.tx_errors++;
983
	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
984 985
}

986 987 988 989 990
static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct ip_tunnel *tunnel = netdev_priv(dev);
	const struct iphdr  *tiph = &tunnel->parms.iph;

E
Eric Dumazet 已提交
991 992 993
	skb = iptunnel_handle_offloads(skb, false, SKB_GSO_IPIP);
	if (IS_ERR(skb))
		goto out;
994 995 996

	ip_tunnel_xmit(skb, dev, tiph, IPPROTO_IPIP);
	return NETDEV_TX_OK;
E
Eric Dumazet 已提交
997 998 999
out:
	dev->stats.tx_errors++;
	return NETDEV_TX_OK;
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019
}

static netdev_tx_t sit_tunnel_xmit(struct sk_buff *skb,
				   struct net_device *dev)
{
	switch (skb->protocol) {
	case htons(ETH_P_IP):
		ipip_tunnel_xmit(skb, dev);
		break;
	case htons(ETH_P_IPV6):
		ipip6_tunnel_xmit(skb, dev);
		break;
	default:
		goto tx_err;
	}

	return NETDEV_TX_OK;

tx_err:
	dev->stats.tx_errors++;
1020
	kfree_skb(skb);
1021 1022 1023 1024
	return NETDEV_TX_OK;

}

1025 1026 1027 1028
static void ipip6_tunnel_bind_dev(struct net_device *dev)
{
	struct net_device *tdev = NULL;
	struct ip_tunnel *tunnel;
1029
	const struct iphdr *iph;
1030
	struct flowi4 fl4;
1031 1032 1033 1034 1035

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

	if (iph->daddr) {
N
Nicolas Dichtel 已提交
1036 1037
		struct rtable *rt = ip_route_output_ports(tunnel->net, &fl4,
							  NULL,
1038 1039 1040 1041 1042
							  iph->daddr, iph->saddr,
							  0, 0,
							  IPPROTO_IPV6,
							  RT_TOS(iph->tos),
							  tunnel->parms.link);
1043 1044

		if (!IS_ERR(rt)) {
1045
			tdev = rt->dst.dev;
1046 1047 1048 1049 1050 1051
			ip_rt_put(rt);
		}
		dev->flags |= IFF_POINTOPOINT;
	}

	if (!tdev && tunnel->parms.link)
N
Nicolas Dichtel 已提交
1052
		tdev = __dev_get_by_index(tunnel->net, tunnel->parms.link);
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062

	if (tdev) {
		dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
		dev->mtu = tdev->mtu - sizeof(struct iphdr);
		if (dev->mtu < IPV6_MIN_MTU)
			dev->mtu = IPV6_MIN_MTU;
	}
	dev->iflink = tunnel->parms.link;
}

1063 1064
static void ipip6_tunnel_update(struct ip_tunnel *t, struct ip_tunnel_parm *p)
{
N
Nicolas Dichtel 已提交
1065
	struct net *net = t->net;
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
	struct sit_net *sitn = net_generic(net, sit_net_id);

	ipip6_tunnel_unlink(sitn, t);
	synchronize_net();
	t->parms.iph.saddr = p->iph.saddr;
	t->parms.iph.daddr = p->iph.daddr;
	memcpy(t->dev->dev_addr, &p->iph.saddr, 4);
	memcpy(t->dev->broadcast, &p->iph.daddr, 4);
	ipip6_tunnel_link(sitn, t);
	t->parms.iph.ttl = p->iph.ttl;
	t->parms.iph.tos = p->iph.tos;
	if (t->parms.link != p->link) {
		t->parms.link = p->link;
		ipip6_tunnel_bind_dev(t->dev);
	}
	netdev_state_change(t->dev);
}

1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
#ifdef CONFIG_IPV6_SIT_6RD
static int ipip6_tunnel_update_6rd(struct ip_tunnel *t,
				   struct ip_tunnel_6rd *ip6rd)
{
	struct in6_addr prefix;
	__be32 relay_prefix;

	if (ip6rd->relay_prefixlen > 32 ||
	    ip6rd->prefixlen + (32 - ip6rd->relay_prefixlen) > 64)
		return -EINVAL;

	ipv6_addr_prefix(&prefix, &ip6rd->prefix, ip6rd->prefixlen);
	if (!ipv6_addr_equal(&prefix, &ip6rd->prefix))
		return -EINVAL;
	if (ip6rd->relay_prefixlen)
		relay_prefix = ip6rd->relay_prefix &
			       htonl(0xffffffffUL <<
				     (32 - ip6rd->relay_prefixlen));
	else
		relay_prefix = 0;
	if (relay_prefix != ip6rd->relay_prefix)
		return -EINVAL;

	t->ip6rd.prefix = prefix;
	t->ip6rd.relay_prefix = relay_prefix;
	t->ip6rd.prefixlen = ip6rd->prefixlen;
	t->ip6rd.relay_prefixlen = ip6rd->relay_prefixlen;
	netdev_state_change(t->dev);
	return 0;
}
#endif

L
Linus Torvalds 已提交
1116 1117 1118 1119 1120
static int
ipip6_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
{
	int err = 0;
	struct ip_tunnel_parm p;
1121
	struct ip_tunnel_prl prl;
L
Linus Torvalds 已提交
1122
	struct ip_tunnel *t;
1123 1124
	struct net *net = dev_net(dev);
	struct sit_net *sitn = net_generic(net, sit_net_id);
1125 1126 1127
#ifdef CONFIG_IPV6_SIT_6RD
	struct ip_tunnel_6rd ip6rd;
#endif
L
Linus Torvalds 已提交
1128 1129 1130

	switch (cmd) {
	case SIOCGETTUNNEL:
1131 1132 1133
#ifdef CONFIG_IPV6_SIT_6RD
	case SIOCGET6RD:
#endif
L
Linus Torvalds 已提交
1134
		t = NULL;
1135
		if (dev == sitn->fb_tunnel_dev) {
L
Linus Torvalds 已提交
1136 1137 1138 1139
			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
				err = -EFAULT;
				break;
			}
1140
			t = ipip6_tunnel_locate(net, &p, 0);
L
Linus Torvalds 已提交
1141 1142
		}
		if (t == NULL)
1143
			t = netdev_priv(dev);
1144 1145 1146 1147 1148 1149 1150 1151 1152

		err = -EFAULT;
		if (cmd == SIOCGETTUNNEL) {
			memcpy(&p, &t->parms, sizeof(p));
			if (copy_to_user(ifr->ifr_ifru.ifru_data, &p,
					 sizeof(p)))
				goto done;
#ifdef CONFIG_IPV6_SIT_6RD
		} else {
A
Alexey Dobriyan 已提交
1153
			ip6rd.prefix = t->ip6rd.prefix;
1154 1155 1156 1157 1158 1159 1160 1161 1162
			ip6rd.relay_prefix = t->ip6rd.relay_prefix;
			ip6rd.prefixlen = t->ip6rd.prefixlen;
			ip6rd.relay_prefixlen = t->ip6rd.relay_prefixlen;
			if (copy_to_user(ifr->ifr_ifru.ifru_data, &ip6rd,
					 sizeof(ip6rd)))
				goto done;
#endif
		}
		err = 0;
L
Linus Torvalds 已提交
1163 1164 1165 1166 1167
		break;

	case SIOCADDTUNNEL:
	case SIOCCHGTUNNEL:
		err = -EPERM;
1168
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
L
Linus Torvalds 已提交
1169 1170 1171 1172 1173 1174 1175
			goto done;

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

		err = -EINVAL;
1176 1177 1178 1179 1180
		if (p.iph.protocol != IPPROTO_IPV6 &&
		    p.iph.protocol != IPPROTO_IPIP &&
		    p.iph.protocol != 0)
			goto done;
		if (p.iph.version != 4 ||
L
Linus Torvalds 已提交
1181 1182 1183 1184 1185
		    p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
			goto done;
		if (p.iph.ttl)
			p.iph.frag_off |= htons(IP_DF);

1186
		t = ipip6_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
L
Linus Torvalds 已提交
1187

1188
		if (dev != sitn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
L
Linus Torvalds 已提交
1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
			if (t != NULL) {
				if (t->dev != dev) {
					err = -EEXIST;
					break;
				}
			} else {
				if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
				    (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
					err = -EINVAL;
					break;
				}
1200
				t = netdev_priv(dev);
L
Linus Torvalds 已提交
1201
			}
1202

1203
			ipip6_tunnel_update(t, &p);
L
Linus Torvalds 已提交
1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
		}

		if (t) {
			err = 0;
			if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
				err = -EFAULT;
		} else
			err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
		break;

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

1219
		if (dev == sitn->fb_tunnel_dev) {
L
Linus Torvalds 已提交
1220 1221 1222 1223
			err = -EFAULT;
			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
				goto done;
			err = -ENOENT;
1224
			if ((t = ipip6_tunnel_locate(net, &p, 0)) == NULL)
L
Linus Torvalds 已提交
1225 1226
				goto done;
			err = -EPERM;
1227
			if (t == netdev_priv(sitn->fb_tunnel_dev))
L
Linus Torvalds 已提交
1228 1229 1230
				goto done;
			dev = t->dev;
		}
1231 1232
		unregister_netdevice(dev);
		err = 0;
L
Linus Torvalds 已提交
1233 1234
		break;

1235
	case SIOCGETPRL:
1236 1237 1238 1239 1240 1241 1242 1243 1244
		err = -EINVAL;
		if (dev == sitn->fb_tunnel_dev)
			goto done;
		err = -ENOENT;
		if (!(t = netdev_priv(dev)))
			goto done;
		err = ipip6_tunnel_get_prl(t, ifr->ifr_ifru.ifru_data);
		break;

1245 1246 1247 1248
	case SIOCADDPRL:
	case SIOCDELPRL:
	case SIOCCHGPRL:
		err = -EPERM;
1249
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1250 1251
			goto done;
		err = -EINVAL;
1252
		if (dev == sitn->fb_tunnel_dev)
1253 1254 1255 1256 1257 1258 1259 1260
			goto done;
		err = -EFAULT;
		if (copy_from_user(&prl, ifr->ifr_ifru.ifru_data, sizeof(prl)))
			goto done;
		err = -ENOENT;
		if (!(t = netdev_priv(dev)))
			goto done;

1261 1262
		switch (cmd) {
		case SIOCDELPRL:
1263
			err = ipip6_tunnel_del_prl(t, &prl);
1264 1265 1266
			break;
		case SIOCADDPRL:
		case SIOCCHGPRL:
1267
			err = ipip6_tunnel_add_prl(t, &prl, cmd == SIOCCHGPRL);
1268 1269
			break;
		}
1270
		netdev_state_change(dev);
1271 1272
		break;

1273 1274 1275 1276 1277
#ifdef CONFIG_IPV6_SIT_6RD
	case SIOCADD6RD:
	case SIOCCHG6RD:
	case SIOCDEL6RD:
		err = -EPERM;
1278
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1279 1280 1281 1282 1283 1284 1285 1286 1287 1288
			goto done;

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

		t = netdev_priv(dev);

		if (cmd != SIOCDEL6RD) {
1289 1290
			err = ipip6_tunnel_update_6rd(t, &ip6rd);
			if (err < 0)
1291 1292
				goto done;
		} else
1293
			ipip6_tunnel_clone_6rd(dev, sitn);
1294 1295 1296 1297 1298

		err = 0;
		break;
#endif

L
Linus Torvalds 已提交
1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314
	default:
		err = -EINVAL;
	}

done:
	return err;
}

static int ipip6_tunnel_change_mtu(struct net_device *dev, int new_mtu)
{
	if (new_mtu < IPV6_MIN_MTU || new_mtu > 0xFFF8 - sizeof(struct iphdr))
		return -EINVAL;
	dev->mtu = new_mtu;
	return 0;
}

1315 1316
static const struct net_device_ops ipip6_netdev_ops = {
	.ndo_uninit	= ipip6_tunnel_uninit,
1317
	.ndo_start_xmit	= sit_tunnel_xmit,
1318 1319
	.ndo_do_ioctl	= ipip6_tunnel_ioctl,
	.ndo_change_mtu	= ipip6_tunnel_change_mtu,
1320
	.ndo_get_stats64 = ip_tunnel_get_stats64,
1321 1322
};

E
Eric Dumazet 已提交
1323 1324 1325 1326 1327 1328
static void ipip6_dev_free(struct net_device *dev)
{
	free_percpu(dev->tstats);
	free_netdev(dev);
}

E
Eric Dumazet 已提交
1329 1330 1331 1332 1333 1334
#define SIT_FEATURES (NETIF_F_SG	   | \
		      NETIF_F_FRAGLIST	   | \
		      NETIF_F_HIGHDMA	   | \
		      NETIF_F_GSO_SOFTWARE | \
		      NETIF_F_HW_CSUM)

L
Linus Torvalds 已提交
1335 1336
static void ipip6_tunnel_setup(struct net_device *dev)
{
1337
	dev->netdev_ops		= &ipip6_netdev_ops;
E
Eric Dumazet 已提交
1338
	dev->destructor 	= ipip6_dev_free;
L
Linus Torvalds 已提交
1339 1340 1341

	dev->type		= ARPHRD_SIT;
	dev->hard_header_len 	= LL_MAX_HEADER + sizeof(struct iphdr);
1342
	dev->mtu		= ETH_DATA_LEN - sizeof(struct iphdr);
L
Linus Torvalds 已提交
1343
	dev->flags		= IFF_NOARP;
1344
	dev->priv_flags	       &= ~IFF_XMIT_DST_RELEASE;
L
Linus Torvalds 已提交
1345 1346
	dev->iflink		= 0;
	dev->addr_len		= 4;
E
Eric Dumazet 已提交
1347
	dev->features		|= NETIF_F_LLTX;
E
Eric Dumazet 已提交
1348 1349
	dev->features		|= SIT_FEATURES;
	dev->hw_features	|= SIT_FEATURES;
L
Linus Torvalds 已提交
1350 1351
}

E
Eric Dumazet 已提交
1352
static int ipip6_tunnel_init(struct net_device *dev)
L
Linus Torvalds 已提交
1353
{
1354
	struct ip_tunnel *tunnel = netdev_priv(dev);
1355
	int i;
L
Linus Torvalds 已提交
1356 1357

	tunnel->dev = dev;
N
Nicolas Dichtel 已提交
1358
	tunnel->net = dev_net(dev);
L
Linus Torvalds 已提交
1359 1360 1361 1362

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

1363
	ipip6_tunnel_bind_dev(dev);
E
Eric Dumazet 已提交
1364 1365 1366 1367
	dev->tstats = alloc_percpu(struct pcpu_tstats);
	if (!dev->tstats)
		return -ENOMEM;

1368 1369 1370 1371 1372 1373
	for_each_possible_cpu(i) {
		struct pcpu_tstats *ipip6_tunnel_stats;
		ipip6_tunnel_stats = per_cpu_ptr(dev->tstats, i);
		u64_stats_init(&ipip6_tunnel_stats->syncp);
	}

E
Eric Dumazet 已提交
1374
	return 0;
L
Linus Torvalds 已提交
1375 1376
}

E
Eric Dumazet 已提交
1377
static int __net_init ipip6_fb_tunnel_init(struct net_device *dev)
L
Linus Torvalds 已提交
1378
{
1379
	struct ip_tunnel *tunnel = netdev_priv(dev);
L
Linus Torvalds 已提交
1380
	struct iphdr *iph = &tunnel->parms.iph;
1381 1382
	struct net *net = dev_net(dev);
	struct sit_net *sitn = net_generic(net, sit_net_id);
1383
	int i;
L
Linus Torvalds 已提交
1384 1385

	tunnel->dev = dev;
N
Nicolas Dichtel 已提交
1386
	tunnel->net = dev_net(dev);
L
Linus Torvalds 已提交
1387 1388 1389 1390 1391 1392 1393
	strcpy(tunnel->parms.name, dev->name);

	iph->version		= 4;
	iph->protocol		= IPPROTO_IPV6;
	iph->ihl		= 5;
	iph->ttl		= 64;

E
Eric Dumazet 已提交
1394 1395 1396
	dev->tstats = alloc_percpu(struct pcpu_tstats);
	if (!dev->tstats)
		return -ENOMEM;
1397 1398 1399 1400 1401 1402 1403

	for_each_possible_cpu(i) {
		struct pcpu_tstats *ipip6_fb_stats;
		ipip6_fb_stats = per_cpu_ptr(dev->tstats, i);
		u64_stats_init(&ipip6_fb_stats->syncp);
	}

L
Linus Torvalds 已提交
1404
	dev_hold(dev);
1405
	rcu_assign_pointer(sitn->tunnels_wc[0], tunnel);
E
Eric Dumazet 已提交
1406
	return 0;
L
Linus Torvalds 已提交
1407 1408
}

1409 1410 1411 1412
static int ipip6_validate(struct nlattr *tb[], struct nlattr *data[])
{
	u8 proto;

1413
	if (!data || !data[IFLA_IPTUN_PROTO])
1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424
		return 0;

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

	return 0;
}

1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441
static void ipip6_netlink_parms(struct nlattr *data[],
				struct ip_tunnel_parm *parms)
{
	memset(parms, 0, sizeof(*parms));

	parms->iph.version = 4;
	parms->iph.protocol = IPPROTO_IPV6;
	parms->iph.ihl = 5;
	parms->iph.ttl = 64;

	if (!data)
		return;

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

	if (data[IFLA_IPTUN_LOCAL])
N
Nicolas Dichtel 已提交
1442
		parms->iph.saddr = nla_get_be32(data[IFLA_IPTUN_LOCAL]);
1443 1444

	if (data[IFLA_IPTUN_REMOTE])
N
Nicolas Dichtel 已提交
1445
		parms->iph.daddr = nla_get_be32(data[IFLA_IPTUN_REMOTE]);
1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459

	if (data[IFLA_IPTUN_TTL]) {
		parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]);
		if (parms->iph.ttl)
			parms->iph.frag_off = htons(IP_DF);
	}

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

	if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC]))
		parms->iph.frag_off = htons(IP_DF);

	if (data[IFLA_IPTUN_FLAGS])
N
Nicolas Dichtel 已提交
1460
		parms->i_flags = nla_get_be16(data[IFLA_IPTUN_FLAGS]);
1461 1462 1463 1464

	if (data[IFLA_IPTUN_PROTO])
		parms->iph.protocol = nla_get_u8(data[IFLA_IPTUN_PROTO]);

1465 1466
}

1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504
#ifdef CONFIG_IPV6_SIT_6RD
/* This function returns true when 6RD attributes are present in the nl msg */
static bool ipip6_netlink_6rd_parms(struct nlattr *data[],
				    struct ip_tunnel_6rd *ip6rd)
{
	bool ret = false;
	memset(ip6rd, 0, sizeof(*ip6rd));

	if (!data)
		return ret;

	if (data[IFLA_IPTUN_6RD_PREFIX]) {
		ret = true;
		nla_memcpy(&ip6rd->prefix, data[IFLA_IPTUN_6RD_PREFIX],
			   sizeof(struct in6_addr));
	}

	if (data[IFLA_IPTUN_6RD_RELAY_PREFIX]) {
		ret = true;
		ip6rd->relay_prefix =
			nla_get_be32(data[IFLA_IPTUN_6RD_RELAY_PREFIX]);
	}

	if (data[IFLA_IPTUN_6RD_PREFIXLEN]) {
		ret = true;
		ip6rd->prefixlen = nla_get_u16(data[IFLA_IPTUN_6RD_PREFIXLEN]);
	}

	if (data[IFLA_IPTUN_6RD_RELAY_PREFIXLEN]) {
		ret = true;
		ip6rd->relay_prefixlen =
			nla_get_u16(data[IFLA_IPTUN_6RD_RELAY_PREFIXLEN]);
	}

	return ret;
}
#endif

1505 1506 1507 1508 1509
static int ipip6_newlink(struct net *src_net, struct net_device *dev,
			 struct nlattr *tb[], struct nlattr *data[])
{
	struct net *net = dev_net(dev);
	struct ip_tunnel *nt;
1510 1511 1512 1513
#ifdef CONFIG_IPV6_SIT_6RD
	struct ip_tunnel_6rd ip6rd;
#endif
	int err;
1514 1515 1516 1517 1518 1519 1520

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

	if (ipip6_tunnel_locate(net, &nt->parms, 0))
		return -EEXIST;

1521 1522 1523 1524 1525 1526 1527 1528 1529 1530
	err = ipip6_tunnel_create(dev);
	if (err < 0)
		return err;

#ifdef CONFIG_IPV6_SIT_6RD
	if (ipip6_netlink_6rd_parms(data, &ip6rd))
		err = ipip6_tunnel_update_6rd(nt, &ip6rd);
#endif

	return err;
1531 1532 1533 1534 1535
}

static int ipip6_changelink(struct net_device *dev, struct nlattr *tb[],
			  struct nlattr *data[])
{
1536
	struct ip_tunnel *t = netdev_priv(dev);
1537
	struct ip_tunnel_parm p;
1538
	struct net *net = t->net;
1539
	struct sit_net *sitn = net_generic(net, sit_net_id);
1540 1541 1542
#ifdef CONFIG_IPV6_SIT_6RD
	struct ip_tunnel_6rd ip6rd;
#endif
1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561

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

	ipip6_netlink_parms(data, &p);

	if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
	    (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
		return -EINVAL;

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

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

	ipip6_tunnel_update(t, &p);
1562 1563 1564 1565 1566 1567

#ifdef CONFIG_IPV6_SIT_6RD
	if (ipip6_netlink_6rd_parms(data, &ip6rd))
		return ipip6_tunnel_update_6rd(t, &ip6rd);
#endif

1568 1569 1570
	return 0;
}

1571
static size_t ipip6_get_size(const struct net_device *dev)
1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583
{
	return
		/* IFLA_IPTUN_LINK */
		nla_total_size(4) +
		/* IFLA_IPTUN_LOCAL */
		nla_total_size(4) +
		/* IFLA_IPTUN_REMOTE */
		nla_total_size(4) +
		/* IFLA_IPTUN_TTL */
		nla_total_size(1) +
		/* IFLA_IPTUN_TOS */
		nla_total_size(1) +
1584 1585 1586 1587
		/* IFLA_IPTUN_PMTUDISC */
		nla_total_size(1) +
		/* IFLA_IPTUN_FLAGS */
		nla_total_size(2) +
1588 1589
		/* IFLA_IPTUN_PROTO */
		nla_total_size(1) +
1590 1591 1592 1593 1594 1595 1596 1597 1598 1599
#ifdef CONFIG_IPV6_SIT_6RD
		/* IFLA_IPTUN_6RD_PREFIX */
		nla_total_size(sizeof(struct in6_addr)) +
		/* IFLA_IPTUN_6RD_RELAY_PREFIX */
		nla_total_size(4) +
		/* IFLA_IPTUN_6RD_PREFIXLEN */
		nla_total_size(2) +
		/* IFLA_IPTUN_6RD_RELAY_PREFIXLEN */
		nla_total_size(2) +
#endif
1600 1601 1602
		0;
}

1603
static int ipip6_fill_info(struct sk_buff *skb, const struct net_device *dev)
1604 1605 1606 1607 1608 1609 1610 1611
{
	struct ip_tunnel *tunnel = netdev_priv(dev);
	struct ip_tunnel_parm *parm = &tunnel->parms;

	if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
	    nla_put_be32(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) ||
	    nla_put_be32(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) ||
	    nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) ||
1612 1613 1614
	    nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) ||
	    nla_put_u8(skb, IFLA_IPTUN_PMTUDISC,
		       !!(parm->iph.frag_off & htons(IP_DF))) ||
1615
	    nla_put_u8(skb, IFLA_IPTUN_PROTO, parm->iph.protocol) ||
N
Nicolas Dichtel 已提交
1616
	    nla_put_be16(skb, IFLA_IPTUN_FLAGS, parm->i_flags))
1617
		goto nla_put_failure;
1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630

#ifdef CONFIG_IPV6_SIT_6RD
	if (nla_put(skb, IFLA_IPTUN_6RD_PREFIX, sizeof(struct in6_addr),
		    &tunnel->ip6rd.prefix) ||
	    nla_put_be32(skb, IFLA_IPTUN_6RD_RELAY_PREFIX,
			 tunnel->ip6rd.relay_prefix) ||
	    nla_put_u16(skb, IFLA_IPTUN_6RD_PREFIXLEN,
			tunnel->ip6rd.prefixlen) ||
	    nla_put_u16(skb, IFLA_IPTUN_6RD_RELAY_PREFIXLEN,
			tunnel->ip6rd.relay_prefixlen))
		goto nla_put_failure;
#endif

1631 1632 1633 1634 1635 1636
	return 0;

nla_put_failure:
	return -EMSGSIZE;
}

1637 1638 1639 1640 1641 1642 1643 1644
static const struct nla_policy ipip6_policy[IFLA_IPTUN_MAX + 1] = {
	[IFLA_IPTUN_LINK]		= { .type = NLA_U32 },
	[IFLA_IPTUN_LOCAL]		= { .type = NLA_U32 },
	[IFLA_IPTUN_REMOTE]		= { .type = NLA_U32 },
	[IFLA_IPTUN_TTL]		= { .type = NLA_U8 },
	[IFLA_IPTUN_TOS]		= { .type = NLA_U8 },
	[IFLA_IPTUN_PMTUDISC]		= { .type = NLA_U8 },
	[IFLA_IPTUN_FLAGS]		= { .type = NLA_U16 },
1645
	[IFLA_IPTUN_PROTO]		= { .type = NLA_U8 },
1646 1647 1648 1649 1650 1651
#ifdef CONFIG_IPV6_SIT_6RD
	[IFLA_IPTUN_6RD_PREFIX]		= { .len = sizeof(struct in6_addr) },
	[IFLA_IPTUN_6RD_RELAY_PREFIX]	= { .type = NLA_U32 },
	[IFLA_IPTUN_6RD_PREFIXLEN]	= { .type = NLA_U16 },
	[IFLA_IPTUN_6RD_RELAY_PREFIXLEN] = { .type = NLA_U16 },
#endif
1652 1653
};

1654 1655 1656 1657 1658 1659 1660 1661 1662
static void ipip6_dellink(struct net_device *dev, struct list_head *head)
{
	struct net *net = dev_net(dev);
	struct sit_net *sitn = net_generic(net, sit_net_id);

	if (dev != sitn->fb_tunnel_dev)
		unregister_netdevice_queue(dev, head);
}

1663 1664 1665
static struct rtnl_link_ops sit_link_ops __read_mostly = {
	.kind		= "sit",
	.maxtype	= IFLA_IPTUN_MAX,
1666
	.policy		= ipip6_policy,
1667
	.priv_size	= sizeof(struct ip_tunnel),
1668
	.setup		= ipip6_tunnel_setup,
1669
	.validate	= ipip6_validate,
1670 1671
	.newlink	= ipip6_newlink,
	.changelink	= ipip6_changelink,
1672 1673
	.get_size	= ipip6_get_size,
	.fill_info	= ipip6_fill_info,
1674
	.dellink	= ipip6_dellink,
1675 1676
};

1677
static struct xfrm_tunnel sit_handler __read_mostly = {
L
Linus Torvalds 已提交
1678 1679
	.handler	=	ipip6_rcv,
	.err_handler	=	ipip6_err,
1680
	.priority	=	1,
L
Linus Torvalds 已提交
1681 1682
};

1683 1684 1685 1686 1687 1688
static struct xfrm_tunnel ipip_handler __read_mostly = {
	.handler	=	ipip_rcv,
	.err_handler	=	ipip6_err,
	.priority	=	2,
};

1689 1690
static void __net_exit sit_destroy_tunnels(struct net *net,
					   struct list_head *head)
1691
{
1692
	struct sit_net *sitn = net_generic(net, sit_net_id);
N
Nicolas Dichtel 已提交
1693
	struct net_device *dev, *aux;
1694 1695
	int prio;

N
Nicolas Dichtel 已提交
1696 1697 1698 1699
	for_each_netdev_safe(net, dev, aux)
		if (dev->rtnl_link_ops == &sit_link_ops)
			unregister_netdevice_queue(dev, head);

1700 1701 1702
	for (prio = 1; prio < 4; prio++) {
		int h;
		for (h = 0; h < HASH_SIZE; h++) {
1703
			struct ip_tunnel *t;
1704

1705
			t = rtnl_dereference(sitn->tunnels[prio][h]);
1706
			while (t != NULL) {
N
Nicolas Dichtel 已提交
1707 1708 1709
				/* If dev is in the same netns, it has already
				 * been added to the list by the previous loop.
				 */
1710
				if (!net_eq(dev_net(t->dev), net))
N
Nicolas Dichtel 已提交
1711 1712
					unregister_netdevice_queue(t->dev,
								   head);
1713
				t = rtnl_dereference(t->next);
1714
			}
1715 1716 1717 1718
		}
	}
}

1719
static int __net_init sit_init_net(struct net *net)
1720
{
1721
	struct sit_net *sitn = net_generic(net, sit_net_id);
1722
	struct ip_tunnel *t;
1723 1724
	int err;

1725 1726 1727 1728 1729
	sitn->tunnels[0] = sitn->tunnels_wc;
	sitn->tunnels[1] = sitn->tunnels_l;
	sitn->tunnels[2] = sitn->tunnels_r;
	sitn->tunnels[3] = sitn->tunnels_r_l;

1730 1731 1732 1733 1734 1735
	sitn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "sit0",
					   ipip6_tunnel_setup);
	if (!sitn->fb_tunnel_dev) {
		err = -ENOMEM;
		goto err_alloc_dev;
	}
1736
	dev_net_set(sitn->fb_tunnel_dev, net);
1737
	sitn->fb_tunnel_dev->rtnl_link_ops = &sit_link_ops;
N
Nicolas Dichtel 已提交
1738 1739 1740 1741
	/* FB netdevice is special: we have one, and only one per netns.
	 * Allowing to move it to another netns is clearly unsafe.
	 */
	sitn->fb_tunnel_dev->features |= NETIF_F_NETNS_LOCAL;
1742

E
Eric Dumazet 已提交
1743 1744 1745 1746
	err = ipip6_fb_tunnel_init(sitn->fb_tunnel_dev);
	if (err)
		goto err_dev_free;

1747
	ipip6_tunnel_clone_6rd(sitn->fb_tunnel_dev, sitn);
1748 1749 1750 1751

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

1752 1753 1754
	t = netdev_priv(sitn->fb_tunnel_dev);

	strcpy(t->parms.name, sitn->fb_tunnel_dev->name);
1755 1756
	return 0;

1757
err_reg_dev:
1758
	dev_put(sitn->fb_tunnel_dev);
E
Eric Dumazet 已提交
1759 1760
err_dev_free:
	ipip6_dev_free(sitn->fb_tunnel_dev);
1761
err_alloc_dev:
1762 1763 1764
	return err;
}

1765
static void __net_exit sit_exit_net(struct net *net)
1766
{
1767
	LIST_HEAD(list);
1768

1769
	rtnl_lock();
1770
	sit_destroy_tunnels(net, &list);
1771
	unregister_netdevice_many(&list);
1772
	rtnl_unlock();
1773 1774 1775 1776 1777
}

static struct pernet_operations sit_net_ops = {
	.init = sit_init_net,
	.exit = sit_exit_net,
1778 1779
	.id   = &sit_net_id,
	.size = sizeof(struct sit_net),
1780 1781
};

1782
static void __exit sit_cleanup(void)
L
Linus Torvalds 已提交
1783
{
1784
	rtnl_link_unregister(&sit_link_ops);
1785
	xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
1786
	xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
1787

1788
	unregister_pernet_device(&sit_net_ops);
E
Eric Dumazet 已提交
1789
	rcu_barrier(); /* Wait for completion of call_rcu()'s */
L
Linus Torvalds 已提交
1790 1791
}

1792
static int __init sit_init(void)
L
Linus Torvalds 已提交
1793 1794 1795
{
	int err;

1796
	pr_info("IPv6 over IPv4 tunneling driver\n");
L
Linus Torvalds 已提交
1797

1798
	err = register_pernet_device(&sit_net_ops);
1799
	if (err < 0)
1800 1801 1802
		return err;
	err = xfrm4_tunnel_register(&sit_handler, AF_INET6);
	if (err < 0) {
1803
		pr_info("%s: can't register ip6ip4\n", __func__);
1804
		goto xfrm_tunnel_failed;
1805
	}
1806 1807 1808 1809 1810
	err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
	if (err < 0) {
		pr_info("%s: can't register ip4ip4\n", __func__);
		goto xfrm_tunnel4_failed;
	}
1811 1812 1813 1814 1815
	err = rtnl_link_register(&sit_link_ops);
	if (err < 0)
		goto rtnl_link_failed;

out:
L
Linus Torvalds 已提交
1816
	return err;
1817 1818

rtnl_link_failed:
1819 1820
	xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
xfrm_tunnel4_failed:
1821 1822 1823 1824
	xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
xfrm_tunnel_failed:
	unregister_pernet_device(&sit_net_ops);
	goto out;
L
Linus Torvalds 已提交
1825
}
1826 1827 1828

module_init(sit_init);
module_exit(sit_cleanup);
1829
MODULE_LICENSE("GPL");
1830
MODULE_ALIAS_NETDEV("sit0");