xref: /openbmc/linux/net/ipv6/sit.c (revision ae40e94f)
1 /*
2  *	IPv6 over IPv4 tunnel device - Simple Internet Transition (SIT)
3  *	Linux INET6 implementation
4  *
5  *	Authors:
6  *	Pedro Roque		<roque@di.fc.ul.pt>
7  *	Alexey Kuznetsov	<kuznet@ms2.inr.ac.ru>
8  *
9  *	This program is free software; you can redistribute it and/or
10  *      modify it under the terms of the GNU General Public License
11  *      as published by the Free Software Foundation; either version
12  *      2 of the License, or (at your option) any later version.
13  *
14  *	Changes:
15  * Roger Venning <r.venning@telstra.com>:	6to4 support
16  * Nate Thompson <nate@thebog.net>:		6to4 support
17  * Fred Templin <fred.l.templin@boeing.com>:	isatap support
18  */
19 
20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21 
22 #include <linux/module.h>
23 #include <linux/capability.h>
24 #include <linux/errno.h>
25 #include <linux/types.h>
26 #include <linux/socket.h>
27 #include <linux/sockios.h>
28 #include <linux/net.h>
29 #include <linux/in6.h>
30 #include <linux/netdevice.h>
31 #include <linux/if_arp.h>
32 #include <linux/icmp.h>
33 #include <linux/slab.h>
34 #include <linux/uaccess.h>
35 #include <linux/init.h>
36 #include <linux/netfilter_ipv4.h>
37 #include <linux/if_ether.h>
38 
39 #include <net/sock.h>
40 #include <net/snmp.h>
41 
42 #include <net/ipv6.h>
43 #include <net/protocol.h>
44 #include <net/transp_v6.h>
45 #include <net/ip6_fib.h>
46 #include <net/ip6_route.h>
47 #include <net/ndisc.h>
48 #include <net/addrconf.h>
49 #include <net/ip.h>
50 #include <net/udp.h>
51 #include <net/icmp.h>
52 #include <net/ip_tunnels.h>
53 #include <net/inet_ecn.h>
54 #include <net/xfrm.h>
55 #include <net/dsfield.h>
56 #include <net/net_namespace.h>
57 #include <net/netns/generic.h>
58 
59 /*
60    This version of net/ipv6/sit.c is cloned of net/ipv4/ip_gre.c
61 
62    For comments look at net/ipv4/ip_gre.c --ANK
63  */
64 
65 #define IP6_SIT_HASH_SIZE  16
66 #define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
67 
68 static bool log_ecn_error = true;
69 module_param(log_ecn_error, bool, 0644);
70 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
71 
72 static int ipip6_tunnel_init(struct net_device *dev);
73 static void ipip6_tunnel_setup(struct net_device *dev);
74 static void ipip6_dev_free(struct net_device *dev);
75 static bool check_6rd(struct ip_tunnel *tunnel, const struct in6_addr *v6dst,
76 		      __be32 *v4dst);
77 static struct rtnl_link_ops sit_link_ops __read_mostly;
78 
79 static unsigned int sit_net_id __read_mostly;
80 struct sit_net {
81 	struct ip_tunnel __rcu *tunnels_r_l[IP6_SIT_HASH_SIZE];
82 	struct ip_tunnel __rcu *tunnels_r[IP6_SIT_HASH_SIZE];
83 	struct ip_tunnel __rcu *tunnels_l[IP6_SIT_HASH_SIZE];
84 	struct ip_tunnel __rcu *tunnels_wc[1];
85 	struct ip_tunnel __rcu **tunnels[4];
86 
87 	struct net_device *fb_tunnel_dev;
88 };
89 
90 /*
91  * Must be invoked with rcu_read_lock
92  */
93 static struct ip_tunnel *ipip6_tunnel_lookup(struct net *net,
94 					     struct net_device *dev,
95 					     __be32 remote, __be32 local,
96 					     int sifindex)
97 {
98 	unsigned int h0 = HASH(remote);
99 	unsigned int h1 = HASH(local);
100 	struct ip_tunnel *t;
101 	struct sit_net *sitn = net_generic(net, sit_net_id);
102 	int ifindex = dev ? dev->ifindex : 0;
103 
104 	for_each_ip_tunnel_rcu(t, sitn->tunnels_r_l[h0 ^ h1]) {
105 		if (local == t->parms.iph.saddr &&
106 		    remote == t->parms.iph.daddr &&
107 		    (!dev || !t->parms.link || ifindex == t->parms.link ||
108 		     sifindex == t->parms.link) &&
109 		    (t->dev->flags & IFF_UP))
110 			return t;
111 	}
112 	for_each_ip_tunnel_rcu(t, sitn->tunnels_r[h0]) {
113 		if (remote == t->parms.iph.daddr &&
114 		    (!dev || !t->parms.link || ifindex == t->parms.link ||
115 		     sifindex == t->parms.link) &&
116 		    (t->dev->flags & IFF_UP))
117 			return t;
118 	}
119 	for_each_ip_tunnel_rcu(t, sitn->tunnels_l[h1]) {
120 		if (local == t->parms.iph.saddr &&
121 		    (!dev || !t->parms.link || ifindex == t->parms.link ||
122 		     sifindex == t->parms.link) &&
123 		    (t->dev->flags & IFF_UP))
124 			return t;
125 	}
126 	t = rcu_dereference(sitn->tunnels_wc[0]);
127 	if (t && (t->dev->flags & IFF_UP))
128 		return t;
129 	return NULL;
130 }
131 
132 static struct ip_tunnel __rcu **__ipip6_bucket(struct sit_net *sitn,
133 		struct ip_tunnel_parm *parms)
134 {
135 	__be32 remote = parms->iph.daddr;
136 	__be32 local = parms->iph.saddr;
137 	unsigned int h = 0;
138 	int prio = 0;
139 
140 	if (remote) {
141 		prio |= 2;
142 		h ^= HASH(remote);
143 	}
144 	if (local) {
145 		prio |= 1;
146 		h ^= HASH(local);
147 	}
148 	return &sitn->tunnels[prio][h];
149 }
150 
151 static inline struct ip_tunnel __rcu **ipip6_bucket(struct sit_net *sitn,
152 		struct ip_tunnel *t)
153 {
154 	return __ipip6_bucket(sitn, &t->parms);
155 }
156 
157 static void ipip6_tunnel_unlink(struct sit_net *sitn, struct ip_tunnel *t)
158 {
159 	struct ip_tunnel __rcu **tp;
160 	struct ip_tunnel *iter;
161 
162 	for (tp = ipip6_bucket(sitn, t);
163 	     (iter = rtnl_dereference(*tp)) != NULL;
164 	     tp = &iter->next) {
165 		if (t == iter) {
166 			rcu_assign_pointer(*tp, t->next);
167 			break;
168 		}
169 	}
170 }
171 
172 static void ipip6_tunnel_link(struct sit_net *sitn, struct ip_tunnel *t)
173 {
174 	struct ip_tunnel __rcu **tp = ipip6_bucket(sitn, t);
175 
176 	rcu_assign_pointer(t->next, rtnl_dereference(*tp));
177 	rcu_assign_pointer(*tp, t);
178 }
179 
180 static void ipip6_tunnel_clone_6rd(struct net_device *dev, struct sit_net *sitn)
181 {
182 #ifdef CONFIG_IPV6_SIT_6RD
183 	struct ip_tunnel *t = netdev_priv(dev);
184 
185 	if (dev == sitn->fb_tunnel_dev || !sitn->fb_tunnel_dev) {
186 		ipv6_addr_set(&t->ip6rd.prefix, htonl(0x20020000), 0, 0, 0);
187 		t->ip6rd.relay_prefix = 0;
188 		t->ip6rd.prefixlen = 16;
189 		t->ip6rd.relay_prefixlen = 0;
190 	} else {
191 		struct ip_tunnel *t0 = netdev_priv(sitn->fb_tunnel_dev);
192 		memcpy(&t->ip6rd, &t0->ip6rd, sizeof(t->ip6rd));
193 	}
194 #endif
195 }
196 
197 static int ipip6_tunnel_create(struct net_device *dev)
198 {
199 	struct ip_tunnel *t = netdev_priv(dev);
200 	struct net *net = dev_net(dev);
201 	struct sit_net *sitn = net_generic(net, sit_net_id);
202 	int err;
203 
204 	memcpy(dev->dev_addr, &t->parms.iph.saddr, 4);
205 	memcpy(dev->broadcast, &t->parms.iph.daddr, 4);
206 
207 	if ((__force u16)t->parms.i_flags & SIT_ISATAP)
208 		dev->priv_flags |= IFF_ISATAP;
209 
210 	dev->rtnl_link_ops = &sit_link_ops;
211 
212 	err = register_netdevice(dev);
213 	if (err < 0)
214 		goto out;
215 
216 	ipip6_tunnel_clone_6rd(dev, sitn);
217 
218 	dev_hold(dev);
219 
220 	ipip6_tunnel_link(sitn, t);
221 	return 0;
222 
223 out:
224 	return err;
225 }
226 
227 static struct ip_tunnel *ipip6_tunnel_locate(struct net *net,
228 		struct ip_tunnel_parm *parms, int create)
229 {
230 	__be32 remote = parms->iph.daddr;
231 	__be32 local = parms->iph.saddr;
232 	struct ip_tunnel *t, *nt;
233 	struct ip_tunnel __rcu **tp;
234 	struct net_device *dev;
235 	char name[IFNAMSIZ];
236 	struct sit_net *sitn = net_generic(net, sit_net_id);
237 
238 	for (tp = __ipip6_bucket(sitn, parms);
239 	    (t = rtnl_dereference(*tp)) != NULL;
240 	     tp = &t->next) {
241 		if (local == t->parms.iph.saddr &&
242 		    remote == t->parms.iph.daddr &&
243 		    parms->link == t->parms.link) {
244 			if (create)
245 				return NULL;
246 			else
247 				return t;
248 		}
249 	}
250 	if (!create)
251 		goto failed;
252 
253 	if (parms->name[0]) {
254 		if (!dev_valid_name(parms->name))
255 			goto failed;
256 		strlcpy(name, parms->name, IFNAMSIZ);
257 	} else {
258 		strcpy(name, "sit%d");
259 	}
260 	dev = alloc_netdev(sizeof(*t), name, NET_NAME_UNKNOWN,
261 			   ipip6_tunnel_setup);
262 	if (!dev)
263 		return NULL;
264 
265 	dev_net_set(dev, net);
266 
267 	nt = netdev_priv(dev);
268 
269 	nt->parms = *parms;
270 	if (ipip6_tunnel_create(dev) < 0)
271 		goto failed_free;
272 
273 	return nt;
274 
275 failed_free:
276 	free_netdev(dev);
277 failed:
278 	return NULL;
279 }
280 
281 #define for_each_prl_rcu(start)			\
282 	for (prl = rcu_dereference(start);	\
283 	     prl;				\
284 	     prl = rcu_dereference(prl->next))
285 
286 static struct ip_tunnel_prl_entry *
287 __ipip6_tunnel_locate_prl(struct ip_tunnel *t, __be32 addr)
288 {
289 	struct ip_tunnel_prl_entry *prl;
290 
291 	for_each_prl_rcu(t->prl)
292 		if (prl->addr == addr)
293 			break;
294 	return prl;
295 
296 }
297 
298 static int ipip6_tunnel_get_prl(struct ip_tunnel *t,
299 				struct ip_tunnel_prl __user *a)
300 {
301 	struct ip_tunnel_prl kprl, *kp;
302 	struct ip_tunnel_prl_entry *prl;
303 	unsigned int cmax, c = 0, ca, len;
304 	int ret = 0;
305 
306 	if (copy_from_user(&kprl, a, sizeof(kprl)))
307 		return -EFAULT;
308 	cmax = kprl.datalen / sizeof(kprl);
309 	if (cmax > 1 && kprl.addr != htonl(INADDR_ANY))
310 		cmax = 1;
311 
312 	/* For simple GET or for root users,
313 	 * we try harder to allocate.
314 	 */
315 	kp = (cmax <= 1 || capable(CAP_NET_ADMIN)) ?
316 		kcalloc(cmax, sizeof(*kp), GFP_KERNEL | __GFP_NOWARN) :
317 		NULL;
318 
319 	rcu_read_lock();
320 
321 	ca = t->prl_count < cmax ? t->prl_count : cmax;
322 
323 	if (!kp) {
324 		/* We don't try hard to allocate much memory for
325 		 * non-root users.
326 		 * For root users, retry allocating enough memory for
327 		 * the answer.
328 		 */
329 		kp = kcalloc(ca, sizeof(*kp), GFP_ATOMIC);
330 		if (!kp) {
331 			ret = -ENOMEM;
332 			goto out;
333 		}
334 	}
335 
336 	c = 0;
337 	for_each_prl_rcu(t->prl) {
338 		if (c >= cmax)
339 			break;
340 		if (kprl.addr != htonl(INADDR_ANY) && prl->addr != kprl.addr)
341 			continue;
342 		kp[c].addr = prl->addr;
343 		kp[c].flags = prl->flags;
344 		c++;
345 		if (kprl.addr != htonl(INADDR_ANY))
346 			break;
347 	}
348 out:
349 	rcu_read_unlock();
350 
351 	len = sizeof(*kp) * c;
352 	ret = 0;
353 	if ((len && copy_to_user(a + 1, kp, len)) || put_user(len, &a->datalen))
354 		ret = -EFAULT;
355 
356 	kfree(kp);
357 
358 	return ret;
359 }
360 
361 static int
362 ipip6_tunnel_add_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a, int chg)
363 {
364 	struct ip_tunnel_prl_entry *p;
365 	int err = 0;
366 
367 	if (a->addr == htonl(INADDR_ANY))
368 		return -EINVAL;
369 
370 	ASSERT_RTNL();
371 
372 	for (p = rtnl_dereference(t->prl); p; p = rtnl_dereference(p->next)) {
373 		if (p->addr == a->addr) {
374 			if (chg) {
375 				p->flags = a->flags;
376 				goto out;
377 			}
378 			err = -EEXIST;
379 			goto out;
380 		}
381 	}
382 
383 	if (chg) {
384 		err = -ENXIO;
385 		goto out;
386 	}
387 
388 	p = kzalloc(sizeof(struct ip_tunnel_prl_entry), GFP_KERNEL);
389 	if (!p) {
390 		err = -ENOBUFS;
391 		goto out;
392 	}
393 
394 	p->next = t->prl;
395 	p->addr = a->addr;
396 	p->flags = a->flags;
397 	t->prl_count++;
398 	rcu_assign_pointer(t->prl, p);
399 out:
400 	return err;
401 }
402 
403 static void prl_list_destroy_rcu(struct rcu_head *head)
404 {
405 	struct ip_tunnel_prl_entry *p, *n;
406 
407 	p = container_of(head, struct ip_tunnel_prl_entry, rcu_head);
408 	do {
409 		n = rcu_dereference_protected(p->next, 1);
410 		kfree(p);
411 		p = n;
412 	} while (p);
413 }
414 
415 static int
416 ipip6_tunnel_del_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a)
417 {
418 	struct ip_tunnel_prl_entry *x;
419 	struct ip_tunnel_prl_entry __rcu **p;
420 	int err = 0;
421 
422 	ASSERT_RTNL();
423 
424 	if (a && a->addr != htonl(INADDR_ANY)) {
425 		for (p = &t->prl;
426 		     (x = rtnl_dereference(*p)) != NULL;
427 		     p = &x->next) {
428 			if (x->addr == a->addr) {
429 				*p = x->next;
430 				kfree_rcu(x, rcu_head);
431 				t->prl_count--;
432 				goto out;
433 			}
434 		}
435 		err = -ENXIO;
436 	} else {
437 		x = rtnl_dereference(t->prl);
438 		if (x) {
439 			t->prl_count = 0;
440 			call_rcu(&x->rcu_head, prl_list_destroy_rcu);
441 			t->prl = NULL;
442 		}
443 	}
444 out:
445 	return err;
446 }
447 
448 static int
449 isatap_chksrc(struct sk_buff *skb, const struct iphdr *iph, struct ip_tunnel *t)
450 {
451 	struct ip_tunnel_prl_entry *p;
452 	int ok = 1;
453 
454 	rcu_read_lock();
455 	p = __ipip6_tunnel_locate_prl(t, iph->saddr);
456 	if (p) {
457 		if (p->flags & PRL_DEFAULT)
458 			skb->ndisc_nodetype = NDISC_NODETYPE_DEFAULT;
459 		else
460 			skb->ndisc_nodetype = NDISC_NODETYPE_NODEFAULT;
461 	} else {
462 		const struct in6_addr *addr6 = &ipv6_hdr(skb)->saddr;
463 
464 		if (ipv6_addr_is_isatap(addr6) &&
465 		    (addr6->s6_addr32[3] == iph->saddr) &&
466 		    ipv6_chk_prefix(addr6, t->dev))
467 			skb->ndisc_nodetype = NDISC_NODETYPE_HOST;
468 		else
469 			ok = 0;
470 	}
471 	rcu_read_unlock();
472 	return ok;
473 }
474 
475 static void ipip6_tunnel_uninit(struct net_device *dev)
476 {
477 	struct ip_tunnel *tunnel = netdev_priv(dev);
478 	struct sit_net *sitn = net_generic(tunnel->net, sit_net_id);
479 
480 	if (dev == sitn->fb_tunnel_dev) {
481 		RCU_INIT_POINTER(sitn->tunnels_wc[0], NULL);
482 	} else {
483 		ipip6_tunnel_unlink(sitn, tunnel);
484 		ipip6_tunnel_del_prl(tunnel, NULL);
485 	}
486 	dst_cache_reset(&tunnel->dst_cache);
487 	dev_put(dev);
488 }
489 
490 static int ipip6_err(struct sk_buff *skb, u32 info)
491 {
492 	const struct iphdr *iph = (const struct iphdr *)skb->data;
493 	const int type = icmp_hdr(skb)->type;
494 	const int code = icmp_hdr(skb)->code;
495 	unsigned int data_len = 0;
496 	struct ip_tunnel *t;
497 	int sifindex;
498 	int err;
499 
500 	switch (type) {
501 	default:
502 	case ICMP_PARAMETERPROB:
503 		return 0;
504 
505 	case ICMP_DEST_UNREACH:
506 		switch (code) {
507 		case ICMP_SR_FAILED:
508 			/* Impossible event. */
509 			return 0;
510 		default:
511 			/* All others are translated to HOST_UNREACH.
512 			   rfc2003 contains "deep thoughts" about NET_UNREACH,
513 			   I believe they are just ether pollution. --ANK
514 			 */
515 			break;
516 		}
517 		break;
518 	case ICMP_TIME_EXCEEDED:
519 		if (code != ICMP_EXC_TTL)
520 			return 0;
521 		data_len = icmp_hdr(skb)->un.reserved[1] * 4; /* RFC 4884 4.1 */
522 		break;
523 	case ICMP_REDIRECT:
524 		break;
525 	}
526 
527 	err = -ENOENT;
528 
529 	sifindex = netif_is_l3_master(skb->dev) ? IPCB(skb)->iif : 0;
530 	t = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
531 				iph->daddr, iph->saddr, sifindex);
532 	if (!t)
533 		goto out;
534 
535 	if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
536 		ipv4_update_pmtu(skb, dev_net(skb->dev), info,
537 				 t->parms.link, iph->protocol);
538 		err = 0;
539 		goto out;
540 	}
541 	if (type == ICMP_REDIRECT) {
542 		ipv4_redirect(skb, dev_net(skb->dev), t->parms.link,
543 			      iph->protocol);
544 		err = 0;
545 		goto out;
546 	}
547 
548 	err = 0;
549 	if (__in6_dev_get(skb->dev) &&
550 	    !ip6_err_gen_icmpv6_unreach(skb, iph->ihl * 4, type, data_len))
551 		goto out;
552 
553 	if (t->parms.iph.daddr == 0)
554 		goto out;
555 
556 	if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
557 		goto out;
558 
559 	if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
560 		t->err_count++;
561 	else
562 		t->err_count = 1;
563 	t->err_time = jiffies;
564 out:
565 	return err;
566 }
567 
568 static inline bool is_spoofed_6rd(struct ip_tunnel *tunnel, const __be32 v4addr,
569 				  const struct in6_addr *v6addr)
570 {
571 	__be32 v4embed = 0;
572 	if (check_6rd(tunnel, v6addr, &v4embed) && v4addr != v4embed)
573 		return true;
574 	return false;
575 }
576 
577 /* Checks if an address matches an address on the tunnel interface.
578  * Used to detect the NAT of proto 41 packets and let them pass spoofing test.
579  * Long story:
580  * This function is called after we considered the packet as spoofed
581  * in is_spoofed_6rd.
582  * We may have a router that is doing NAT for proto 41 packets
583  * for an internal station. Destination a.a.a.a/PREFIX:bbbb:bbbb
584  * will be translated to n.n.n.n/PREFIX:bbbb:bbbb. And is_spoofed_6rd
585  * function will return true, dropping the packet.
586  * But, we can still check if is spoofed against the IP
587  * addresses associated with the interface.
588  */
589 static bool only_dnatted(const struct ip_tunnel *tunnel,
590 	const struct in6_addr *v6dst)
591 {
592 	int prefix_len;
593 
594 #ifdef CONFIG_IPV6_SIT_6RD
595 	prefix_len = tunnel->ip6rd.prefixlen + 32
596 		- tunnel->ip6rd.relay_prefixlen;
597 #else
598 	prefix_len = 48;
599 #endif
600 	return ipv6_chk_custom_prefix(v6dst, prefix_len, tunnel->dev);
601 }
602 
603 /* Returns true if a packet is spoofed */
604 static bool packet_is_spoofed(struct sk_buff *skb,
605 			      const struct iphdr *iph,
606 			      struct ip_tunnel *tunnel)
607 {
608 	const struct ipv6hdr *ipv6h;
609 
610 	if (tunnel->dev->priv_flags & IFF_ISATAP) {
611 		if (!isatap_chksrc(skb, iph, tunnel))
612 			return true;
613 
614 		return false;
615 	}
616 
617 	if (tunnel->dev->flags & IFF_POINTOPOINT)
618 		return false;
619 
620 	ipv6h = ipv6_hdr(skb);
621 
622 	if (unlikely(is_spoofed_6rd(tunnel, iph->saddr, &ipv6h->saddr))) {
623 		net_warn_ratelimited("Src spoofed %pI4/%pI6c -> %pI4/%pI6c\n",
624 				     &iph->saddr, &ipv6h->saddr,
625 				     &iph->daddr, &ipv6h->daddr);
626 		return true;
627 	}
628 
629 	if (likely(!is_spoofed_6rd(tunnel, iph->daddr, &ipv6h->daddr)))
630 		return false;
631 
632 	if (only_dnatted(tunnel, &ipv6h->daddr))
633 		return false;
634 
635 	net_warn_ratelimited("Dst spoofed %pI4/%pI6c -> %pI4/%pI6c\n",
636 			     &iph->saddr, &ipv6h->saddr,
637 			     &iph->daddr, &ipv6h->daddr);
638 	return true;
639 }
640 
641 static int ipip6_rcv(struct sk_buff *skb)
642 {
643 	const struct iphdr *iph = ip_hdr(skb);
644 	struct ip_tunnel *tunnel;
645 	int sifindex;
646 	int err;
647 
648 	sifindex = netif_is_l3_master(skb->dev) ? IPCB(skb)->iif : 0;
649 	tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
650 				     iph->saddr, iph->daddr, sifindex);
651 	if (tunnel) {
652 		struct pcpu_sw_netstats *tstats;
653 
654 		if (tunnel->parms.iph.protocol != IPPROTO_IPV6 &&
655 		    tunnel->parms.iph.protocol != 0)
656 			goto out;
657 
658 		skb->mac_header = skb->network_header;
659 		skb_reset_network_header(skb);
660 		IPCB(skb)->flags = 0;
661 		skb->dev = tunnel->dev;
662 
663 		if (packet_is_spoofed(skb, iph, tunnel)) {
664 			tunnel->dev->stats.rx_errors++;
665 			goto out;
666 		}
667 
668 		if (iptunnel_pull_header(skb, 0, htons(ETH_P_IPV6),
669 		    !net_eq(tunnel->net, dev_net(tunnel->dev))))
670 			goto out;
671 
672 		err = IP_ECN_decapsulate(iph, skb);
673 		if (unlikely(err)) {
674 			if (log_ecn_error)
675 				net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
676 						     &iph->saddr, iph->tos);
677 			if (err > 1) {
678 				++tunnel->dev->stats.rx_frame_errors;
679 				++tunnel->dev->stats.rx_errors;
680 				goto out;
681 			}
682 		}
683 
684 		tstats = this_cpu_ptr(tunnel->dev->tstats);
685 		u64_stats_update_begin(&tstats->syncp);
686 		tstats->rx_packets++;
687 		tstats->rx_bytes += skb->len;
688 		u64_stats_update_end(&tstats->syncp);
689 
690 		netif_rx(skb);
691 
692 		return 0;
693 	}
694 
695 	/* no tunnel matched,  let upstream know, ipsec may handle it */
696 	return 1;
697 out:
698 	kfree_skb(skb);
699 	return 0;
700 }
701 
702 static const struct tnl_ptk_info ipip_tpi = {
703 	/* no tunnel info required for ipip. */
704 	.proto = htons(ETH_P_IP),
705 };
706 
707 #if IS_ENABLED(CONFIG_MPLS)
708 static const struct tnl_ptk_info mplsip_tpi = {
709 	/* no tunnel info required for mplsip. */
710 	.proto = htons(ETH_P_MPLS_UC),
711 };
712 #endif
713 
714 static int sit_tunnel_rcv(struct sk_buff *skb, u8 ipproto)
715 {
716 	const struct iphdr *iph;
717 	struct ip_tunnel *tunnel;
718 	int sifindex;
719 
720 	sifindex = netif_is_l3_master(skb->dev) ? IPCB(skb)->iif : 0;
721 
722 	iph = ip_hdr(skb);
723 	tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
724 				     iph->saddr, iph->daddr, sifindex);
725 	if (tunnel) {
726 		const struct tnl_ptk_info *tpi;
727 
728 		if (tunnel->parms.iph.protocol != ipproto &&
729 		    tunnel->parms.iph.protocol != 0)
730 			goto drop;
731 
732 		if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
733 			goto drop;
734 #if IS_ENABLED(CONFIG_MPLS)
735 		if (ipproto == IPPROTO_MPLS)
736 			tpi = &mplsip_tpi;
737 		else
738 #endif
739 			tpi = &ipip_tpi;
740 		if (iptunnel_pull_header(skb, 0, tpi->proto, false))
741 			goto drop;
742 		return ip_tunnel_rcv(tunnel, skb, tpi, NULL, log_ecn_error);
743 	}
744 
745 	return 1;
746 
747 drop:
748 	kfree_skb(skb);
749 	return 0;
750 }
751 
752 static int ipip_rcv(struct sk_buff *skb)
753 {
754 	return sit_tunnel_rcv(skb, IPPROTO_IPIP);
755 }
756 
757 #if IS_ENABLED(CONFIG_MPLS)
758 static int mplsip_rcv(struct sk_buff *skb)
759 {
760 	return sit_tunnel_rcv(skb, IPPROTO_MPLS);
761 }
762 #endif
763 
764 /*
765  * If the IPv6 address comes from 6rd / 6to4 (RFC 3056) addr space this function
766  * stores the embedded IPv4 address in v4dst and returns true.
767  */
768 static bool check_6rd(struct ip_tunnel *tunnel, const struct in6_addr *v6dst,
769 		      __be32 *v4dst)
770 {
771 #ifdef CONFIG_IPV6_SIT_6RD
772 	if (ipv6_prefix_equal(v6dst, &tunnel->ip6rd.prefix,
773 			      tunnel->ip6rd.prefixlen)) {
774 		unsigned int pbw0, pbi0;
775 		int pbi1;
776 		u32 d;
777 
778 		pbw0 = tunnel->ip6rd.prefixlen >> 5;
779 		pbi0 = tunnel->ip6rd.prefixlen & 0x1f;
780 
781 		d = tunnel->ip6rd.relay_prefixlen < 32 ?
782 			(ntohl(v6dst->s6_addr32[pbw0]) << pbi0) >>
783 		    tunnel->ip6rd.relay_prefixlen : 0;
784 
785 		pbi1 = pbi0 - tunnel->ip6rd.relay_prefixlen;
786 		if (pbi1 > 0)
787 			d |= ntohl(v6dst->s6_addr32[pbw0 + 1]) >>
788 			     (32 - pbi1);
789 
790 		*v4dst = tunnel->ip6rd.relay_prefix | htonl(d);
791 		return true;
792 	}
793 #else
794 	if (v6dst->s6_addr16[0] == htons(0x2002)) {
795 		/* 6to4 v6 addr has 16 bits prefix, 32 v4addr, 16 SLA, ... */
796 		memcpy(v4dst, &v6dst->s6_addr16[1], 4);
797 		return true;
798 	}
799 #endif
800 	return false;
801 }
802 
803 static inline __be32 try_6rd(struct ip_tunnel *tunnel,
804 			     const struct in6_addr *v6dst)
805 {
806 	__be32 dst = 0;
807 	check_6rd(tunnel, v6dst, &dst);
808 	return dst;
809 }
810 
811 /*
812  *	This function assumes it is being called from dev_queue_xmit()
813  *	and that skb is filled properly by that function.
814  */
815 
816 static netdev_tx_t ipip6_tunnel_xmit(struct sk_buff *skb,
817 				     struct net_device *dev)
818 {
819 	struct ip_tunnel *tunnel = netdev_priv(dev);
820 	const struct iphdr  *tiph = &tunnel->parms.iph;
821 	const struct ipv6hdr *iph6 = ipv6_hdr(skb);
822 	u8     tos = tunnel->parms.iph.tos;
823 	__be16 df = tiph->frag_off;
824 	struct rtable *rt;		/* Route to the other host */
825 	struct net_device *tdev;	/* Device to other host */
826 	unsigned int max_headroom;	/* The extra header space needed */
827 	__be32 dst = tiph->daddr;
828 	struct flowi4 fl4;
829 	int    mtu;
830 	const struct in6_addr *addr6;
831 	int addr_type;
832 	u8 ttl;
833 	u8 protocol = IPPROTO_IPV6;
834 	int t_hlen = tunnel->hlen + sizeof(struct iphdr);
835 
836 	if (tos == 1)
837 		tos = ipv6_get_dsfield(iph6);
838 
839 	/* ISATAP (RFC4214) - must come before 6to4 */
840 	if (dev->priv_flags & IFF_ISATAP) {
841 		struct neighbour *neigh = NULL;
842 		bool do_tx_error = false;
843 
844 		if (skb_dst(skb))
845 			neigh = dst_neigh_lookup(skb_dst(skb), &iph6->daddr);
846 
847 		if (!neigh) {
848 			net_dbg_ratelimited("nexthop == NULL\n");
849 			goto tx_error;
850 		}
851 
852 		addr6 = (const struct in6_addr *)&neigh->primary_key;
853 		addr_type = ipv6_addr_type(addr6);
854 
855 		if ((addr_type & IPV6_ADDR_UNICAST) &&
856 		     ipv6_addr_is_isatap(addr6))
857 			dst = addr6->s6_addr32[3];
858 		else
859 			do_tx_error = true;
860 
861 		neigh_release(neigh);
862 		if (do_tx_error)
863 			goto tx_error;
864 	}
865 
866 	if (!dst)
867 		dst = try_6rd(tunnel, &iph6->daddr);
868 
869 	if (!dst) {
870 		struct neighbour *neigh = NULL;
871 		bool do_tx_error = false;
872 
873 		if (skb_dst(skb))
874 			neigh = dst_neigh_lookup(skb_dst(skb), &iph6->daddr);
875 
876 		if (!neigh) {
877 			net_dbg_ratelimited("nexthop == NULL\n");
878 			goto tx_error;
879 		}
880 
881 		addr6 = (const struct in6_addr *)&neigh->primary_key;
882 		addr_type = ipv6_addr_type(addr6);
883 
884 		if (addr_type == IPV6_ADDR_ANY) {
885 			addr6 = &ipv6_hdr(skb)->daddr;
886 			addr_type = ipv6_addr_type(addr6);
887 		}
888 
889 		if ((addr_type & IPV6_ADDR_COMPATv4) != 0)
890 			dst = addr6->s6_addr32[3];
891 		else
892 			do_tx_error = true;
893 
894 		neigh_release(neigh);
895 		if (do_tx_error)
896 			goto tx_error;
897 	}
898 
899 	flowi4_init_output(&fl4, tunnel->parms.link, tunnel->fwmark,
900 			   RT_TOS(tos), RT_SCOPE_UNIVERSE, IPPROTO_IPV6,
901 			   0, dst, tiph->saddr, 0, 0,
902 			   sock_net_uid(tunnel->net, NULL));
903 	rt = ip_route_output_flow(tunnel->net, &fl4, NULL);
904 
905 	if (IS_ERR(rt)) {
906 		dev->stats.tx_carrier_errors++;
907 		goto tx_error_icmp;
908 	}
909 	if (rt->rt_type != RTN_UNICAST) {
910 		ip_rt_put(rt);
911 		dev->stats.tx_carrier_errors++;
912 		goto tx_error_icmp;
913 	}
914 	tdev = rt->dst.dev;
915 
916 	if (tdev == dev) {
917 		ip_rt_put(rt);
918 		dev->stats.collisions++;
919 		goto tx_error;
920 	}
921 
922 	if (iptunnel_handle_offloads(skb, SKB_GSO_IPXIP4)) {
923 		ip_rt_put(rt);
924 		goto tx_error;
925 	}
926 
927 	if (df) {
928 		mtu = dst_mtu(&rt->dst) - t_hlen;
929 
930 		if (mtu < 68) {
931 			dev->stats.collisions++;
932 			ip_rt_put(rt);
933 			goto tx_error;
934 		}
935 
936 		if (mtu < IPV6_MIN_MTU) {
937 			mtu = IPV6_MIN_MTU;
938 			df = 0;
939 		}
940 
941 		if (tunnel->parms.iph.daddr)
942 			skb_dst_update_pmtu(skb, mtu);
943 
944 		if (skb->len > mtu && !skb_is_gso(skb)) {
945 			icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
946 			ip_rt_put(rt);
947 			goto tx_error;
948 		}
949 	}
950 
951 	if (tunnel->err_count > 0) {
952 		if (time_before(jiffies,
953 				tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
954 			tunnel->err_count--;
955 			dst_link_failure(skb);
956 		} else
957 			tunnel->err_count = 0;
958 	}
959 
960 	/*
961 	 * Okay, now see if we can stuff it in the buffer as-is.
962 	 */
963 	max_headroom = LL_RESERVED_SPACE(tdev) + t_hlen;
964 
965 	if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
966 	    (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
967 		struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
968 		if (!new_skb) {
969 			ip_rt_put(rt);
970 			dev->stats.tx_dropped++;
971 			kfree_skb(skb);
972 			return NETDEV_TX_OK;
973 		}
974 		if (skb->sk)
975 			skb_set_owner_w(new_skb, skb->sk);
976 		dev_kfree_skb(skb);
977 		skb = new_skb;
978 		iph6 = ipv6_hdr(skb);
979 	}
980 	ttl = tiph->ttl;
981 	if (ttl == 0)
982 		ttl = iph6->hop_limit;
983 	tos = INET_ECN_encapsulate(tos, ipv6_get_dsfield(iph6));
984 
985 	if (ip_tunnel_encap(skb, tunnel, &protocol, &fl4) < 0) {
986 		ip_rt_put(rt);
987 		goto tx_error;
988 	}
989 
990 	skb_set_inner_ipproto(skb, IPPROTO_IPV6);
991 
992 	iptunnel_xmit(NULL, rt, skb, fl4.saddr, fl4.daddr, protocol, tos, ttl,
993 		      df, !net_eq(tunnel->net, dev_net(dev)));
994 	return NETDEV_TX_OK;
995 
996 tx_error_icmp:
997 	dst_link_failure(skb);
998 tx_error:
999 	kfree_skb(skb);
1000 	dev->stats.tx_errors++;
1001 	return NETDEV_TX_OK;
1002 }
1003 
1004 static netdev_tx_t sit_tunnel_xmit__(struct sk_buff *skb,
1005 				     struct net_device *dev, u8 ipproto)
1006 {
1007 	struct ip_tunnel *tunnel = netdev_priv(dev);
1008 	const struct iphdr  *tiph = &tunnel->parms.iph;
1009 
1010 	if (iptunnel_handle_offloads(skb, SKB_GSO_IPXIP4))
1011 		goto tx_error;
1012 
1013 	skb_set_inner_ipproto(skb, ipproto);
1014 
1015 	ip_tunnel_xmit(skb, dev, tiph, ipproto);
1016 	return NETDEV_TX_OK;
1017 tx_error:
1018 	kfree_skb(skb);
1019 	dev->stats.tx_errors++;
1020 	return NETDEV_TX_OK;
1021 }
1022 
1023 static netdev_tx_t sit_tunnel_xmit(struct sk_buff *skb,
1024 				   struct net_device *dev)
1025 {
1026 	if (!pskb_inet_may_pull(skb))
1027 		goto tx_err;
1028 
1029 	switch (skb->protocol) {
1030 	case htons(ETH_P_IP):
1031 		sit_tunnel_xmit__(skb, dev, IPPROTO_IPIP);
1032 		break;
1033 	case htons(ETH_P_IPV6):
1034 		ipip6_tunnel_xmit(skb, dev);
1035 		break;
1036 #if IS_ENABLED(CONFIG_MPLS)
1037 	case htons(ETH_P_MPLS_UC):
1038 		sit_tunnel_xmit__(skb, dev, IPPROTO_MPLS);
1039 		break;
1040 #endif
1041 	default:
1042 		goto tx_err;
1043 	}
1044 
1045 	return NETDEV_TX_OK;
1046 
1047 tx_err:
1048 	dev->stats.tx_errors++;
1049 	kfree_skb(skb);
1050 	return NETDEV_TX_OK;
1051 
1052 }
1053 
1054 static void ipip6_tunnel_bind_dev(struct net_device *dev)
1055 {
1056 	struct net_device *tdev = NULL;
1057 	struct ip_tunnel *tunnel;
1058 	const struct iphdr *iph;
1059 	struct flowi4 fl4;
1060 
1061 	tunnel = netdev_priv(dev);
1062 	iph = &tunnel->parms.iph;
1063 
1064 	if (iph->daddr) {
1065 		struct rtable *rt = ip_route_output_ports(tunnel->net, &fl4,
1066 							  NULL,
1067 							  iph->daddr, iph->saddr,
1068 							  0, 0,
1069 							  IPPROTO_IPV6,
1070 							  RT_TOS(iph->tos),
1071 							  tunnel->parms.link);
1072 
1073 		if (!IS_ERR(rt)) {
1074 			tdev = rt->dst.dev;
1075 			ip_rt_put(rt);
1076 		}
1077 		dev->flags |= IFF_POINTOPOINT;
1078 	}
1079 
1080 	if (!tdev && tunnel->parms.link)
1081 		tdev = __dev_get_by_index(tunnel->net, tunnel->parms.link);
1082 
1083 	if (tdev) {
1084 		int t_hlen = tunnel->hlen + sizeof(struct iphdr);
1085 
1086 		dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
1087 		dev->mtu = tdev->mtu - t_hlen;
1088 		if (dev->mtu < IPV6_MIN_MTU)
1089 			dev->mtu = IPV6_MIN_MTU;
1090 	}
1091 }
1092 
1093 static void ipip6_tunnel_update(struct ip_tunnel *t, struct ip_tunnel_parm *p,
1094 				__u32 fwmark)
1095 {
1096 	struct net *net = t->net;
1097 	struct sit_net *sitn = net_generic(net, sit_net_id);
1098 
1099 	ipip6_tunnel_unlink(sitn, t);
1100 	synchronize_net();
1101 	t->parms.iph.saddr = p->iph.saddr;
1102 	t->parms.iph.daddr = p->iph.daddr;
1103 	memcpy(t->dev->dev_addr, &p->iph.saddr, 4);
1104 	memcpy(t->dev->broadcast, &p->iph.daddr, 4);
1105 	ipip6_tunnel_link(sitn, t);
1106 	t->parms.iph.ttl = p->iph.ttl;
1107 	t->parms.iph.tos = p->iph.tos;
1108 	t->parms.iph.frag_off = p->iph.frag_off;
1109 	if (t->parms.link != p->link || t->fwmark != fwmark) {
1110 		t->parms.link = p->link;
1111 		t->fwmark = fwmark;
1112 		ipip6_tunnel_bind_dev(t->dev);
1113 	}
1114 	dst_cache_reset(&t->dst_cache);
1115 	netdev_state_change(t->dev);
1116 }
1117 
1118 #ifdef CONFIG_IPV6_SIT_6RD
1119 static int ipip6_tunnel_update_6rd(struct ip_tunnel *t,
1120 				   struct ip_tunnel_6rd *ip6rd)
1121 {
1122 	struct in6_addr prefix;
1123 	__be32 relay_prefix;
1124 
1125 	if (ip6rd->relay_prefixlen > 32 ||
1126 	    ip6rd->prefixlen + (32 - ip6rd->relay_prefixlen) > 64)
1127 		return -EINVAL;
1128 
1129 	ipv6_addr_prefix(&prefix, &ip6rd->prefix, ip6rd->prefixlen);
1130 	if (!ipv6_addr_equal(&prefix, &ip6rd->prefix))
1131 		return -EINVAL;
1132 	if (ip6rd->relay_prefixlen)
1133 		relay_prefix = ip6rd->relay_prefix &
1134 			       htonl(0xffffffffUL <<
1135 				     (32 - ip6rd->relay_prefixlen));
1136 	else
1137 		relay_prefix = 0;
1138 	if (relay_prefix != ip6rd->relay_prefix)
1139 		return -EINVAL;
1140 
1141 	t->ip6rd.prefix = prefix;
1142 	t->ip6rd.relay_prefix = relay_prefix;
1143 	t->ip6rd.prefixlen = ip6rd->prefixlen;
1144 	t->ip6rd.relay_prefixlen = ip6rd->relay_prefixlen;
1145 	dst_cache_reset(&t->dst_cache);
1146 	netdev_state_change(t->dev);
1147 	return 0;
1148 }
1149 #endif
1150 
1151 static bool ipip6_valid_ip_proto(u8 ipproto)
1152 {
1153 	return ipproto == IPPROTO_IPV6 ||
1154 		ipproto == IPPROTO_IPIP ||
1155 #if IS_ENABLED(CONFIG_MPLS)
1156 		ipproto == IPPROTO_MPLS ||
1157 #endif
1158 		ipproto == 0;
1159 }
1160 
1161 static int
1162 ipip6_tunnel_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1163 {
1164 	int err = 0;
1165 	struct ip_tunnel_parm p;
1166 	struct ip_tunnel_prl prl;
1167 	struct ip_tunnel *t = netdev_priv(dev);
1168 	struct net *net = t->net;
1169 	struct sit_net *sitn = net_generic(net, sit_net_id);
1170 #ifdef CONFIG_IPV6_SIT_6RD
1171 	struct ip_tunnel_6rd ip6rd;
1172 #endif
1173 
1174 	switch (cmd) {
1175 	case SIOCGETTUNNEL:
1176 #ifdef CONFIG_IPV6_SIT_6RD
1177 	case SIOCGET6RD:
1178 #endif
1179 		if (dev == sitn->fb_tunnel_dev) {
1180 			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
1181 				err = -EFAULT;
1182 				break;
1183 			}
1184 			t = ipip6_tunnel_locate(net, &p, 0);
1185 			if (!t)
1186 				t = netdev_priv(dev);
1187 		}
1188 
1189 		err = -EFAULT;
1190 		if (cmd == SIOCGETTUNNEL) {
1191 			memcpy(&p, &t->parms, sizeof(p));
1192 			if (copy_to_user(ifr->ifr_ifru.ifru_data, &p,
1193 					 sizeof(p)))
1194 				goto done;
1195 #ifdef CONFIG_IPV6_SIT_6RD
1196 		} else {
1197 			ip6rd.prefix = t->ip6rd.prefix;
1198 			ip6rd.relay_prefix = t->ip6rd.relay_prefix;
1199 			ip6rd.prefixlen = t->ip6rd.prefixlen;
1200 			ip6rd.relay_prefixlen = t->ip6rd.relay_prefixlen;
1201 			if (copy_to_user(ifr->ifr_ifru.ifru_data, &ip6rd,
1202 					 sizeof(ip6rd)))
1203 				goto done;
1204 #endif
1205 		}
1206 		err = 0;
1207 		break;
1208 
1209 	case SIOCADDTUNNEL:
1210 	case SIOCCHGTUNNEL:
1211 		err = -EPERM;
1212 		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1213 			goto done;
1214 
1215 		err = -EFAULT;
1216 		if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1217 			goto done;
1218 
1219 		err = -EINVAL;
1220 		if (!ipip6_valid_ip_proto(p.iph.protocol))
1221 			goto done;
1222 		if (p.iph.version != 4 ||
1223 		    p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
1224 			goto done;
1225 		if (p.iph.ttl)
1226 			p.iph.frag_off |= htons(IP_DF);
1227 
1228 		t = ipip6_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
1229 
1230 		if (dev != sitn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
1231 			if (t) {
1232 				if (t->dev != dev) {
1233 					err = -EEXIST;
1234 					break;
1235 				}
1236 			} else {
1237 				if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
1238 				    (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
1239 					err = -EINVAL;
1240 					break;
1241 				}
1242 				t = netdev_priv(dev);
1243 			}
1244 
1245 			ipip6_tunnel_update(t, &p, t->fwmark);
1246 		}
1247 
1248 		if (t) {
1249 			err = 0;
1250 			if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
1251 				err = -EFAULT;
1252 		} else
1253 			err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
1254 		break;
1255 
1256 	case SIOCDELTUNNEL:
1257 		err = -EPERM;
1258 		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1259 			goto done;
1260 
1261 		if (dev == sitn->fb_tunnel_dev) {
1262 			err = -EFAULT;
1263 			if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1264 				goto done;
1265 			err = -ENOENT;
1266 			t = ipip6_tunnel_locate(net, &p, 0);
1267 			if (!t)
1268 				goto done;
1269 			err = -EPERM;
1270 			if (t == netdev_priv(sitn->fb_tunnel_dev))
1271 				goto done;
1272 			dev = t->dev;
1273 		}
1274 		unregister_netdevice(dev);
1275 		err = 0;
1276 		break;
1277 
1278 	case SIOCGETPRL:
1279 		err = -EINVAL;
1280 		if (dev == sitn->fb_tunnel_dev)
1281 			goto done;
1282 		err = ipip6_tunnel_get_prl(t, ifr->ifr_ifru.ifru_data);
1283 		break;
1284 
1285 	case SIOCADDPRL:
1286 	case SIOCDELPRL:
1287 	case SIOCCHGPRL:
1288 		err = -EPERM;
1289 		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1290 			goto done;
1291 		err = -EINVAL;
1292 		if (dev == sitn->fb_tunnel_dev)
1293 			goto done;
1294 		err = -EFAULT;
1295 		if (copy_from_user(&prl, ifr->ifr_ifru.ifru_data, sizeof(prl)))
1296 			goto done;
1297 
1298 		switch (cmd) {
1299 		case SIOCDELPRL:
1300 			err = ipip6_tunnel_del_prl(t, &prl);
1301 			break;
1302 		case SIOCADDPRL:
1303 		case SIOCCHGPRL:
1304 			err = ipip6_tunnel_add_prl(t, &prl, cmd == SIOCCHGPRL);
1305 			break;
1306 		}
1307 		dst_cache_reset(&t->dst_cache);
1308 		netdev_state_change(dev);
1309 		break;
1310 
1311 #ifdef CONFIG_IPV6_SIT_6RD
1312 	case SIOCADD6RD:
1313 	case SIOCCHG6RD:
1314 	case SIOCDEL6RD:
1315 		err = -EPERM;
1316 		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1317 			goto done;
1318 
1319 		err = -EFAULT;
1320 		if (copy_from_user(&ip6rd, ifr->ifr_ifru.ifru_data,
1321 				   sizeof(ip6rd)))
1322 			goto done;
1323 
1324 		if (cmd != SIOCDEL6RD) {
1325 			err = ipip6_tunnel_update_6rd(t, &ip6rd);
1326 			if (err < 0)
1327 				goto done;
1328 		} else
1329 			ipip6_tunnel_clone_6rd(dev, sitn);
1330 
1331 		err = 0;
1332 		break;
1333 #endif
1334 
1335 	default:
1336 		err = -EINVAL;
1337 	}
1338 
1339 done:
1340 	return err;
1341 }
1342 
1343 static const struct net_device_ops ipip6_netdev_ops = {
1344 	.ndo_init	= ipip6_tunnel_init,
1345 	.ndo_uninit	= ipip6_tunnel_uninit,
1346 	.ndo_start_xmit	= sit_tunnel_xmit,
1347 	.ndo_do_ioctl	= ipip6_tunnel_ioctl,
1348 	.ndo_get_stats64 = ip_tunnel_get_stats64,
1349 	.ndo_get_iflink = ip_tunnel_get_iflink,
1350 };
1351 
1352 static void ipip6_dev_free(struct net_device *dev)
1353 {
1354 	struct ip_tunnel *tunnel = netdev_priv(dev);
1355 
1356 	dst_cache_destroy(&tunnel->dst_cache);
1357 	free_percpu(dev->tstats);
1358 }
1359 
1360 #define SIT_FEATURES (NETIF_F_SG	   | \
1361 		      NETIF_F_FRAGLIST	   | \
1362 		      NETIF_F_HIGHDMA	   | \
1363 		      NETIF_F_GSO_SOFTWARE | \
1364 		      NETIF_F_HW_CSUM)
1365 
1366 static void ipip6_tunnel_setup(struct net_device *dev)
1367 {
1368 	struct ip_tunnel *tunnel = netdev_priv(dev);
1369 	int t_hlen = tunnel->hlen + sizeof(struct iphdr);
1370 
1371 	dev->netdev_ops		= &ipip6_netdev_ops;
1372 	dev->needs_free_netdev	= true;
1373 	dev->priv_destructor	= ipip6_dev_free;
1374 
1375 	dev->type		= ARPHRD_SIT;
1376 	dev->hard_header_len	= LL_MAX_HEADER + t_hlen;
1377 	dev->mtu		= ETH_DATA_LEN - t_hlen;
1378 	dev->min_mtu		= IPV6_MIN_MTU;
1379 	dev->max_mtu		= IP6_MAX_MTU - t_hlen;
1380 	dev->flags		= IFF_NOARP;
1381 	netif_keep_dst(dev);
1382 	dev->addr_len		= 4;
1383 	dev->features		|= NETIF_F_LLTX;
1384 	dev->features		|= SIT_FEATURES;
1385 	dev->hw_features	|= SIT_FEATURES;
1386 }
1387 
1388 static int ipip6_tunnel_init(struct net_device *dev)
1389 {
1390 	struct ip_tunnel *tunnel = netdev_priv(dev);
1391 	int err;
1392 
1393 	tunnel->dev = dev;
1394 	tunnel->net = dev_net(dev);
1395 	strcpy(tunnel->parms.name, dev->name);
1396 
1397 	ipip6_tunnel_bind_dev(dev);
1398 	dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
1399 	if (!dev->tstats)
1400 		return -ENOMEM;
1401 
1402 	err = dst_cache_init(&tunnel->dst_cache, GFP_KERNEL);
1403 	if (err) {
1404 		free_percpu(dev->tstats);
1405 		dev->tstats = NULL;
1406 		return err;
1407 	}
1408 
1409 	return 0;
1410 }
1411 
1412 static void __net_init ipip6_fb_tunnel_init(struct net_device *dev)
1413 {
1414 	struct ip_tunnel *tunnel = netdev_priv(dev);
1415 	struct iphdr *iph = &tunnel->parms.iph;
1416 	struct net *net = dev_net(dev);
1417 	struct sit_net *sitn = net_generic(net, sit_net_id);
1418 
1419 	iph->version		= 4;
1420 	iph->protocol		= IPPROTO_IPV6;
1421 	iph->ihl		= 5;
1422 	iph->ttl		= 64;
1423 
1424 	dev_hold(dev);
1425 	rcu_assign_pointer(sitn->tunnels_wc[0], tunnel);
1426 }
1427 
1428 static int ipip6_validate(struct nlattr *tb[], struct nlattr *data[],
1429 			  struct netlink_ext_ack *extack)
1430 {
1431 	u8 proto;
1432 
1433 	if (!data || !data[IFLA_IPTUN_PROTO])
1434 		return 0;
1435 
1436 	proto = nla_get_u8(data[IFLA_IPTUN_PROTO]);
1437 	if (!ipip6_valid_ip_proto(proto))
1438 		return -EINVAL;
1439 
1440 	return 0;
1441 }
1442 
1443 static void ipip6_netlink_parms(struct nlattr *data[],
1444 				struct ip_tunnel_parm *parms,
1445 				__u32 *fwmark)
1446 {
1447 	memset(parms, 0, sizeof(*parms));
1448 
1449 	parms->iph.version = 4;
1450 	parms->iph.protocol = IPPROTO_IPV6;
1451 	parms->iph.ihl = 5;
1452 	parms->iph.ttl = 64;
1453 
1454 	if (!data)
1455 		return;
1456 
1457 	if (data[IFLA_IPTUN_LINK])
1458 		parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
1459 
1460 	if (data[IFLA_IPTUN_LOCAL])
1461 		parms->iph.saddr = nla_get_be32(data[IFLA_IPTUN_LOCAL]);
1462 
1463 	if (data[IFLA_IPTUN_REMOTE])
1464 		parms->iph.daddr = nla_get_be32(data[IFLA_IPTUN_REMOTE]);
1465 
1466 	if (data[IFLA_IPTUN_TTL]) {
1467 		parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]);
1468 		if (parms->iph.ttl)
1469 			parms->iph.frag_off = htons(IP_DF);
1470 	}
1471 
1472 	if (data[IFLA_IPTUN_TOS])
1473 		parms->iph.tos = nla_get_u8(data[IFLA_IPTUN_TOS]);
1474 
1475 	if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC]))
1476 		parms->iph.frag_off = htons(IP_DF);
1477 
1478 	if (data[IFLA_IPTUN_FLAGS])
1479 		parms->i_flags = nla_get_be16(data[IFLA_IPTUN_FLAGS]);
1480 
1481 	if (data[IFLA_IPTUN_PROTO])
1482 		parms->iph.protocol = nla_get_u8(data[IFLA_IPTUN_PROTO]);
1483 
1484 	if (data[IFLA_IPTUN_FWMARK])
1485 		*fwmark = nla_get_u32(data[IFLA_IPTUN_FWMARK]);
1486 }
1487 
1488 /* This function returns true when ENCAP attributes are present in the nl msg */
1489 static bool ipip6_netlink_encap_parms(struct nlattr *data[],
1490 				      struct ip_tunnel_encap *ipencap)
1491 {
1492 	bool ret = false;
1493 
1494 	memset(ipencap, 0, sizeof(*ipencap));
1495 
1496 	if (!data)
1497 		return ret;
1498 
1499 	if (data[IFLA_IPTUN_ENCAP_TYPE]) {
1500 		ret = true;
1501 		ipencap->type = nla_get_u16(data[IFLA_IPTUN_ENCAP_TYPE]);
1502 	}
1503 
1504 	if (data[IFLA_IPTUN_ENCAP_FLAGS]) {
1505 		ret = true;
1506 		ipencap->flags = nla_get_u16(data[IFLA_IPTUN_ENCAP_FLAGS]);
1507 	}
1508 
1509 	if (data[IFLA_IPTUN_ENCAP_SPORT]) {
1510 		ret = true;
1511 		ipencap->sport = nla_get_be16(data[IFLA_IPTUN_ENCAP_SPORT]);
1512 	}
1513 
1514 	if (data[IFLA_IPTUN_ENCAP_DPORT]) {
1515 		ret = true;
1516 		ipencap->dport = nla_get_be16(data[IFLA_IPTUN_ENCAP_DPORT]);
1517 	}
1518 
1519 	return ret;
1520 }
1521 
1522 #ifdef CONFIG_IPV6_SIT_6RD
1523 /* This function returns true when 6RD attributes are present in the nl msg */
1524 static bool ipip6_netlink_6rd_parms(struct nlattr *data[],
1525 				    struct ip_tunnel_6rd *ip6rd)
1526 {
1527 	bool ret = false;
1528 	memset(ip6rd, 0, sizeof(*ip6rd));
1529 
1530 	if (!data)
1531 		return ret;
1532 
1533 	if (data[IFLA_IPTUN_6RD_PREFIX]) {
1534 		ret = true;
1535 		ip6rd->prefix = nla_get_in6_addr(data[IFLA_IPTUN_6RD_PREFIX]);
1536 	}
1537 
1538 	if (data[IFLA_IPTUN_6RD_RELAY_PREFIX]) {
1539 		ret = true;
1540 		ip6rd->relay_prefix =
1541 			nla_get_be32(data[IFLA_IPTUN_6RD_RELAY_PREFIX]);
1542 	}
1543 
1544 	if (data[IFLA_IPTUN_6RD_PREFIXLEN]) {
1545 		ret = true;
1546 		ip6rd->prefixlen = nla_get_u16(data[IFLA_IPTUN_6RD_PREFIXLEN]);
1547 	}
1548 
1549 	if (data[IFLA_IPTUN_6RD_RELAY_PREFIXLEN]) {
1550 		ret = true;
1551 		ip6rd->relay_prefixlen =
1552 			nla_get_u16(data[IFLA_IPTUN_6RD_RELAY_PREFIXLEN]);
1553 	}
1554 
1555 	return ret;
1556 }
1557 #endif
1558 
1559 static int ipip6_newlink(struct net *src_net, struct net_device *dev,
1560 			 struct nlattr *tb[], struct nlattr *data[],
1561 			 struct netlink_ext_ack *extack)
1562 {
1563 	struct net *net = dev_net(dev);
1564 	struct ip_tunnel *nt;
1565 	struct ip_tunnel_encap ipencap;
1566 #ifdef CONFIG_IPV6_SIT_6RD
1567 	struct ip_tunnel_6rd ip6rd;
1568 #endif
1569 	int err;
1570 
1571 	nt = netdev_priv(dev);
1572 
1573 	if (ipip6_netlink_encap_parms(data, &ipencap)) {
1574 		err = ip_tunnel_encap_setup(nt, &ipencap);
1575 		if (err < 0)
1576 			return err;
1577 	}
1578 
1579 	ipip6_netlink_parms(data, &nt->parms, &nt->fwmark);
1580 
1581 	if (ipip6_tunnel_locate(net, &nt->parms, 0))
1582 		return -EEXIST;
1583 
1584 	err = ipip6_tunnel_create(dev);
1585 	if (err < 0)
1586 		return err;
1587 
1588 	if (tb[IFLA_MTU]) {
1589 		u32 mtu = nla_get_u32(tb[IFLA_MTU]);
1590 
1591 		if (mtu >= IPV6_MIN_MTU &&
1592 		    mtu <= IP6_MAX_MTU - dev->hard_header_len)
1593 			dev->mtu = mtu;
1594 	}
1595 
1596 #ifdef CONFIG_IPV6_SIT_6RD
1597 	if (ipip6_netlink_6rd_parms(data, &ip6rd))
1598 		err = ipip6_tunnel_update_6rd(nt, &ip6rd);
1599 #endif
1600 
1601 	return err;
1602 }
1603 
1604 static int ipip6_changelink(struct net_device *dev, struct nlattr *tb[],
1605 			    struct nlattr *data[],
1606 			    struct netlink_ext_ack *extack)
1607 {
1608 	struct ip_tunnel *t = netdev_priv(dev);
1609 	struct ip_tunnel_parm p;
1610 	struct ip_tunnel_encap ipencap;
1611 	struct net *net = t->net;
1612 	struct sit_net *sitn = net_generic(net, sit_net_id);
1613 #ifdef CONFIG_IPV6_SIT_6RD
1614 	struct ip_tunnel_6rd ip6rd;
1615 #endif
1616 	__u32 fwmark = t->fwmark;
1617 	int err;
1618 
1619 	if (dev == sitn->fb_tunnel_dev)
1620 		return -EINVAL;
1621 
1622 	if (ipip6_netlink_encap_parms(data, &ipencap)) {
1623 		err = ip_tunnel_encap_setup(t, &ipencap);
1624 		if (err < 0)
1625 			return err;
1626 	}
1627 
1628 	ipip6_netlink_parms(data, &p, &fwmark);
1629 
1630 	if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
1631 	    (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
1632 		return -EINVAL;
1633 
1634 	t = ipip6_tunnel_locate(net, &p, 0);
1635 
1636 	if (t) {
1637 		if (t->dev != dev)
1638 			return -EEXIST;
1639 	} else
1640 		t = netdev_priv(dev);
1641 
1642 	ipip6_tunnel_update(t, &p, fwmark);
1643 
1644 #ifdef CONFIG_IPV6_SIT_6RD
1645 	if (ipip6_netlink_6rd_parms(data, &ip6rd))
1646 		return ipip6_tunnel_update_6rd(t, &ip6rd);
1647 #endif
1648 
1649 	return 0;
1650 }
1651 
1652 static size_t ipip6_get_size(const struct net_device *dev)
1653 {
1654 	return
1655 		/* IFLA_IPTUN_LINK */
1656 		nla_total_size(4) +
1657 		/* IFLA_IPTUN_LOCAL */
1658 		nla_total_size(4) +
1659 		/* IFLA_IPTUN_REMOTE */
1660 		nla_total_size(4) +
1661 		/* IFLA_IPTUN_TTL */
1662 		nla_total_size(1) +
1663 		/* IFLA_IPTUN_TOS */
1664 		nla_total_size(1) +
1665 		/* IFLA_IPTUN_PMTUDISC */
1666 		nla_total_size(1) +
1667 		/* IFLA_IPTUN_FLAGS */
1668 		nla_total_size(2) +
1669 		/* IFLA_IPTUN_PROTO */
1670 		nla_total_size(1) +
1671 #ifdef CONFIG_IPV6_SIT_6RD
1672 		/* IFLA_IPTUN_6RD_PREFIX */
1673 		nla_total_size(sizeof(struct in6_addr)) +
1674 		/* IFLA_IPTUN_6RD_RELAY_PREFIX */
1675 		nla_total_size(4) +
1676 		/* IFLA_IPTUN_6RD_PREFIXLEN */
1677 		nla_total_size(2) +
1678 		/* IFLA_IPTUN_6RD_RELAY_PREFIXLEN */
1679 		nla_total_size(2) +
1680 #endif
1681 		/* IFLA_IPTUN_ENCAP_TYPE */
1682 		nla_total_size(2) +
1683 		/* IFLA_IPTUN_ENCAP_FLAGS */
1684 		nla_total_size(2) +
1685 		/* IFLA_IPTUN_ENCAP_SPORT */
1686 		nla_total_size(2) +
1687 		/* IFLA_IPTUN_ENCAP_DPORT */
1688 		nla_total_size(2) +
1689 		/* IFLA_IPTUN_FWMARK */
1690 		nla_total_size(4) +
1691 		0;
1692 }
1693 
1694 static int ipip6_fill_info(struct sk_buff *skb, const struct net_device *dev)
1695 {
1696 	struct ip_tunnel *tunnel = netdev_priv(dev);
1697 	struct ip_tunnel_parm *parm = &tunnel->parms;
1698 
1699 	if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
1700 	    nla_put_in_addr(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) ||
1701 	    nla_put_in_addr(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) ||
1702 	    nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) ||
1703 	    nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) ||
1704 	    nla_put_u8(skb, IFLA_IPTUN_PMTUDISC,
1705 		       !!(parm->iph.frag_off & htons(IP_DF))) ||
1706 	    nla_put_u8(skb, IFLA_IPTUN_PROTO, parm->iph.protocol) ||
1707 	    nla_put_be16(skb, IFLA_IPTUN_FLAGS, parm->i_flags) ||
1708 	    nla_put_u32(skb, IFLA_IPTUN_FWMARK, tunnel->fwmark))
1709 		goto nla_put_failure;
1710 
1711 #ifdef CONFIG_IPV6_SIT_6RD
1712 	if (nla_put_in6_addr(skb, IFLA_IPTUN_6RD_PREFIX,
1713 			     &tunnel->ip6rd.prefix) ||
1714 	    nla_put_in_addr(skb, IFLA_IPTUN_6RD_RELAY_PREFIX,
1715 			    tunnel->ip6rd.relay_prefix) ||
1716 	    nla_put_u16(skb, IFLA_IPTUN_6RD_PREFIXLEN,
1717 			tunnel->ip6rd.prefixlen) ||
1718 	    nla_put_u16(skb, IFLA_IPTUN_6RD_RELAY_PREFIXLEN,
1719 			tunnel->ip6rd.relay_prefixlen))
1720 		goto nla_put_failure;
1721 #endif
1722 
1723 	if (nla_put_u16(skb, IFLA_IPTUN_ENCAP_TYPE,
1724 			tunnel->encap.type) ||
1725 	    nla_put_be16(skb, IFLA_IPTUN_ENCAP_SPORT,
1726 			tunnel->encap.sport) ||
1727 	    nla_put_be16(skb, IFLA_IPTUN_ENCAP_DPORT,
1728 			tunnel->encap.dport) ||
1729 	    nla_put_u16(skb, IFLA_IPTUN_ENCAP_FLAGS,
1730 			tunnel->encap.flags))
1731 		goto nla_put_failure;
1732 
1733 	return 0;
1734 
1735 nla_put_failure:
1736 	return -EMSGSIZE;
1737 }
1738 
1739 static const struct nla_policy ipip6_policy[IFLA_IPTUN_MAX + 1] = {
1740 	[IFLA_IPTUN_LINK]		= { .type = NLA_U32 },
1741 	[IFLA_IPTUN_LOCAL]		= { .type = NLA_U32 },
1742 	[IFLA_IPTUN_REMOTE]		= { .type = NLA_U32 },
1743 	[IFLA_IPTUN_TTL]		= { .type = NLA_U8 },
1744 	[IFLA_IPTUN_TOS]		= { .type = NLA_U8 },
1745 	[IFLA_IPTUN_PMTUDISC]		= { .type = NLA_U8 },
1746 	[IFLA_IPTUN_FLAGS]		= { .type = NLA_U16 },
1747 	[IFLA_IPTUN_PROTO]		= { .type = NLA_U8 },
1748 #ifdef CONFIG_IPV6_SIT_6RD
1749 	[IFLA_IPTUN_6RD_PREFIX]		= { .len = sizeof(struct in6_addr) },
1750 	[IFLA_IPTUN_6RD_RELAY_PREFIX]	= { .type = NLA_U32 },
1751 	[IFLA_IPTUN_6RD_PREFIXLEN]	= { .type = NLA_U16 },
1752 	[IFLA_IPTUN_6RD_RELAY_PREFIXLEN] = { .type = NLA_U16 },
1753 #endif
1754 	[IFLA_IPTUN_ENCAP_TYPE]		= { .type = NLA_U16 },
1755 	[IFLA_IPTUN_ENCAP_FLAGS]	= { .type = NLA_U16 },
1756 	[IFLA_IPTUN_ENCAP_SPORT]	= { .type = NLA_U16 },
1757 	[IFLA_IPTUN_ENCAP_DPORT]	= { .type = NLA_U16 },
1758 	[IFLA_IPTUN_FWMARK]		= { .type = NLA_U32 },
1759 };
1760 
1761 static void ipip6_dellink(struct net_device *dev, struct list_head *head)
1762 {
1763 	struct net *net = dev_net(dev);
1764 	struct sit_net *sitn = net_generic(net, sit_net_id);
1765 
1766 	if (dev != sitn->fb_tunnel_dev)
1767 		unregister_netdevice_queue(dev, head);
1768 }
1769 
1770 static struct rtnl_link_ops sit_link_ops __read_mostly = {
1771 	.kind		= "sit",
1772 	.maxtype	= IFLA_IPTUN_MAX,
1773 	.policy		= ipip6_policy,
1774 	.priv_size	= sizeof(struct ip_tunnel),
1775 	.setup		= ipip6_tunnel_setup,
1776 	.validate	= ipip6_validate,
1777 	.newlink	= ipip6_newlink,
1778 	.changelink	= ipip6_changelink,
1779 	.get_size	= ipip6_get_size,
1780 	.fill_info	= ipip6_fill_info,
1781 	.dellink	= ipip6_dellink,
1782 	.get_link_net	= ip_tunnel_get_link_net,
1783 };
1784 
1785 static struct xfrm_tunnel sit_handler __read_mostly = {
1786 	.handler	=	ipip6_rcv,
1787 	.err_handler	=	ipip6_err,
1788 	.priority	=	1,
1789 };
1790 
1791 static struct xfrm_tunnel ipip_handler __read_mostly = {
1792 	.handler	=	ipip_rcv,
1793 	.err_handler	=	ipip6_err,
1794 	.priority	=	2,
1795 };
1796 
1797 #if IS_ENABLED(CONFIG_MPLS)
1798 static struct xfrm_tunnel mplsip_handler __read_mostly = {
1799 	.handler	=	mplsip_rcv,
1800 	.err_handler	=	ipip6_err,
1801 	.priority	=	2,
1802 };
1803 #endif
1804 
1805 static void __net_exit sit_destroy_tunnels(struct net *net,
1806 					   struct list_head *head)
1807 {
1808 	struct sit_net *sitn = net_generic(net, sit_net_id);
1809 	struct net_device *dev, *aux;
1810 	int prio;
1811 
1812 	for_each_netdev_safe(net, dev, aux)
1813 		if (dev->rtnl_link_ops == &sit_link_ops)
1814 			unregister_netdevice_queue(dev, head);
1815 
1816 	for (prio = 1; prio < 4; prio++) {
1817 		int h;
1818 		for (h = 0; h < IP6_SIT_HASH_SIZE; h++) {
1819 			struct ip_tunnel *t;
1820 
1821 			t = rtnl_dereference(sitn->tunnels[prio][h]);
1822 			while (t) {
1823 				/* If dev is in the same netns, it has already
1824 				 * been added to the list by the previous loop.
1825 				 */
1826 				if (!net_eq(dev_net(t->dev), net))
1827 					unregister_netdevice_queue(t->dev,
1828 								   head);
1829 				t = rtnl_dereference(t->next);
1830 			}
1831 		}
1832 	}
1833 }
1834 
1835 static int __net_init sit_init_net(struct net *net)
1836 {
1837 	struct sit_net *sitn = net_generic(net, sit_net_id);
1838 	struct ip_tunnel *t;
1839 	int err;
1840 
1841 	sitn->tunnels[0] = sitn->tunnels_wc;
1842 	sitn->tunnels[1] = sitn->tunnels_l;
1843 	sitn->tunnels[2] = sitn->tunnels_r;
1844 	sitn->tunnels[3] = sitn->tunnels_r_l;
1845 
1846 	if (!net_has_fallback_tunnels(net))
1847 		return 0;
1848 
1849 	sitn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "sit0",
1850 					   NET_NAME_UNKNOWN,
1851 					   ipip6_tunnel_setup);
1852 	if (!sitn->fb_tunnel_dev) {
1853 		err = -ENOMEM;
1854 		goto err_alloc_dev;
1855 	}
1856 	dev_net_set(sitn->fb_tunnel_dev, net);
1857 	sitn->fb_tunnel_dev->rtnl_link_ops = &sit_link_ops;
1858 	/* FB netdevice is special: we have one, and only one per netns.
1859 	 * Allowing to move it to another netns is clearly unsafe.
1860 	 */
1861 	sitn->fb_tunnel_dev->features |= NETIF_F_NETNS_LOCAL;
1862 
1863 	err = register_netdev(sitn->fb_tunnel_dev);
1864 	if (err)
1865 		goto err_reg_dev;
1866 
1867 	ipip6_tunnel_clone_6rd(sitn->fb_tunnel_dev, sitn);
1868 	ipip6_fb_tunnel_init(sitn->fb_tunnel_dev);
1869 
1870 	t = netdev_priv(sitn->fb_tunnel_dev);
1871 
1872 	strcpy(t->parms.name, sitn->fb_tunnel_dev->name);
1873 	return 0;
1874 
1875 err_reg_dev:
1876 	ipip6_dev_free(sitn->fb_tunnel_dev);
1877 	free_netdev(sitn->fb_tunnel_dev);
1878 err_alloc_dev:
1879 	return err;
1880 }
1881 
1882 static void __net_exit sit_exit_batch_net(struct list_head *net_list)
1883 {
1884 	LIST_HEAD(list);
1885 	struct net *net;
1886 
1887 	rtnl_lock();
1888 	list_for_each_entry(net, net_list, exit_list)
1889 		sit_destroy_tunnels(net, &list);
1890 
1891 	unregister_netdevice_many(&list);
1892 	rtnl_unlock();
1893 }
1894 
1895 static struct pernet_operations sit_net_ops = {
1896 	.init = sit_init_net,
1897 	.exit_batch = sit_exit_batch_net,
1898 	.id   = &sit_net_id,
1899 	.size = sizeof(struct sit_net),
1900 };
1901 
1902 static void __exit sit_cleanup(void)
1903 {
1904 	rtnl_link_unregister(&sit_link_ops);
1905 	xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
1906 	xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
1907 #if IS_ENABLED(CONFIG_MPLS)
1908 	xfrm4_tunnel_deregister(&mplsip_handler, AF_MPLS);
1909 #endif
1910 
1911 	unregister_pernet_device(&sit_net_ops);
1912 	rcu_barrier(); /* Wait for completion of call_rcu()'s */
1913 }
1914 
1915 static int __init sit_init(void)
1916 {
1917 	int err;
1918 
1919 	pr_info("IPv6, IPv4 and MPLS over IPv4 tunneling driver\n");
1920 
1921 	err = register_pernet_device(&sit_net_ops);
1922 	if (err < 0)
1923 		return err;
1924 	err = xfrm4_tunnel_register(&sit_handler, AF_INET6);
1925 	if (err < 0) {
1926 		pr_info("%s: can't register ip6ip4\n", __func__);
1927 		goto xfrm_tunnel_failed;
1928 	}
1929 	err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
1930 	if (err < 0) {
1931 		pr_info("%s: can't register ip4ip4\n", __func__);
1932 		goto xfrm_tunnel4_failed;
1933 	}
1934 #if IS_ENABLED(CONFIG_MPLS)
1935 	err = xfrm4_tunnel_register(&mplsip_handler, AF_MPLS);
1936 	if (err < 0) {
1937 		pr_info("%s: can't register mplsip\n", __func__);
1938 		goto xfrm_tunnel_mpls_failed;
1939 	}
1940 #endif
1941 	err = rtnl_link_register(&sit_link_ops);
1942 	if (err < 0)
1943 		goto rtnl_link_failed;
1944 
1945 out:
1946 	return err;
1947 
1948 rtnl_link_failed:
1949 #if IS_ENABLED(CONFIG_MPLS)
1950 	xfrm4_tunnel_deregister(&mplsip_handler, AF_MPLS);
1951 xfrm_tunnel_mpls_failed:
1952 #endif
1953 	xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
1954 xfrm_tunnel4_failed:
1955 	xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
1956 xfrm_tunnel_failed:
1957 	unregister_pernet_device(&sit_net_ops);
1958 	goto out;
1959 }
1960 
1961 module_init(sit_init);
1962 module_exit(sit_cleanup);
1963 MODULE_LICENSE("GPL");
1964 MODULE_ALIAS_RTNL_LINK("sit");
1965 MODULE_ALIAS_NETDEV("sit0");
1966