1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *	PF_INET6 socket protocol family
4  *	Linux INET6 implementation
5  *
6  *	Authors:
7  *	Pedro Roque		<roque@di.fc.ul.pt>
8  *
9  *	Adapted from linux/net/ipv4/af_inet.c
10  *
11  *	Fixes:
12  *	piggy, Karl Knutson	:	Socket protocol table
13  *	Hideaki YOSHIFUJI	:	sin6_scope_id support
14  *	Arnaldo Melo		:	check proc_net_create return, cleanups
15  */
16 
17 #define pr_fmt(fmt) "IPv6: " fmt
18 
19 #include <linux/module.h>
20 #include <linux/capability.h>
21 #include <linux/errno.h>
22 #include <linux/types.h>
23 #include <linux/socket.h>
24 #include <linux/in.h>
25 #include <linux/kernel.h>
26 #include <linux/timer.h>
27 #include <linux/string.h>
28 #include <linux/sockios.h>
29 #include <linux/net.h>
30 #include <linux/fcntl.h>
31 #include <linux/mm.h>
32 #include <linux/interrupt.h>
33 #include <linux/proc_fs.h>
34 #include <linux/stat.h>
35 #include <linux/init.h>
36 #include <linux/slab.h>
37 
38 #include <linux/inet.h>
39 #include <linux/netdevice.h>
40 #include <linux/icmpv6.h>
41 #include <linux/netfilter_ipv6.h>
42 
43 #include <net/ip.h>
44 #include <net/ipv6.h>
45 #include <net/udp.h>
46 #include <net/udplite.h>
47 #include <net/tcp.h>
48 #include <net/ping.h>
49 #include <net/protocol.h>
50 #include <net/inet_common.h>
51 #include <net/route.h>
52 #include <net/transp_v6.h>
53 #include <net/ip6_route.h>
54 #include <net/addrconf.h>
55 #include <net/ipv6_stubs.h>
56 #include <net/ndisc.h>
57 #ifdef CONFIG_IPV6_TUNNEL
58 #include <net/ip6_tunnel.h>
59 #endif
60 #include <net/calipso.h>
61 #include <net/seg6.h>
62 #include <net/rpl.h>
63 #include <net/compat.h>
64 #include <net/xfrm.h>
65 #include <net/ioam6.h>
66 #include <net/rawv6.h>
67 
68 #include <linux/uaccess.h>
69 #include <linux/mroute6.h>
70 
71 #include "ip6_offload.h"
72 
73 MODULE_AUTHOR("Cast of dozens");
74 MODULE_DESCRIPTION("IPv6 protocol stack for Linux");
75 MODULE_LICENSE("GPL");
76 
77 /* The inetsw6 table contains everything that inet6_create needs to
78  * build a new socket.
79  */
80 static struct list_head inetsw6[SOCK_MAX];
81 static DEFINE_SPINLOCK(inetsw6_lock);
82 
83 struct ipv6_params ipv6_defaults = {
84 	.disable_ipv6 = 0,
85 	.autoconf = 1,
86 };
87 
88 static int disable_ipv6_mod;
89 
90 module_param_named(disable, disable_ipv6_mod, int, 0444);
91 MODULE_PARM_DESC(disable, "Disable IPv6 module such that it is non-functional");
92 
93 module_param_named(disable_ipv6, ipv6_defaults.disable_ipv6, int, 0444);
94 MODULE_PARM_DESC(disable_ipv6, "Disable IPv6 on all interfaces");
95 
96 module_param_named(autoconf, ipv6_defaults.autoconf, int, 0444);
97 MODULE_PARM_DESC(autoconf, "Enable IPv6 address autoconfiguration on all interfaces");
98 
ipv6_mod_enabled(void)99 bool ipv6_mod_enabled(void)
100 {
101 	return disable_ipv6_mod == 0;
102 }
103 EXPORT_SYMBOL_GPL(ipv6_mod_enabled);
104 
inet6_sk_generic(struct sock * sk)105 static __inline__ struct ipv6_pinfo *inet6_sk_generic(struct sock *sk)
106 {
107 	const int offset = sk->sk_prot->obj_size - sizeof(struct ipv6_pinfo);
108 
109 	return (struct ipv6_pinfo *)(((u8 *)sk) + offset);
110 }
111 
inet6_sock_destruct(struct sock * sk)112 void inet6_sock_destruct(struct sock *sk)
113 {
114 	inet6_cleanup_sock(sk);
115 	inet_sock_destruct(sk);
116 }
117 
inet6_create(struct net * net,struct socket * sock,int protocol,int kern)118 static int inet6_create(struct net *net, struct socket *sock, int protocol,
119 			int kern)
120 {
121 	struct inet_sock *inet;
122 	struct ipv6_pinfo *np;
123 	struct sock *sk;
124 	struct inet_protosw *answer;
125 	struct proto *answer_prot;
126 	unsigned char answer_flags;
127 	int try_loading_module = 0;
128 	int err;
129 
130 	if (protocol < 0 || protocol >= IPPROTO_MAX)
131 		return -EINVAL;
132 
133 	/* Look for the requested type/protocol pair. */
134 lookup_protocol:
135 	err = -ESOCKTNOSUPPORT;
136 	rcu_read_lock();
137 	list_for_each_entry_rcu(answer, &inetsw6[sock->type], list) {
138 
139 		err = 0;
140 		/* Check the non-wild match. */
141 		if (protocol == answer->protocol) {
142 			if (protocol != IPPROTO_IP)
143 				break;
144 		} else {
145 			/* Check for the two wild cases. */
146 			if (IPPROTO_IP == protocol) {
147 				protocol = answer->protocol;
148 				break;
149 			}
150 			if (IPPROTO_IP == answer->protocol)
151 				break;
152 		}
153 		err = -EPROTONOSUPPORT;
154 	}
155 
156 	if (err) {
157 		if (try_loading_module < 2) {
158 			rcu_read_unlock();
159 			/*
160 			 * Be more specific, e.g. net-pf-10-proto-132-type-1
161 			 * (net-pf-PF_INET6-proto-IPPROTO_SCTP-type-SOCK_STREAM)
162 			 */
163 			if (++try_loading_module == 1)
164 				request_module("net-pf-%d-proto-%d-type-%d",
165 						PF_INET6, protocol, sock->type);
166 			/*
167 			 * Fall back to generic, e.g. net-pf-10-proto-132
168 			 * (net-pf-PF_INET6-proto-IPPROTO_SCTP)
169 			 */
170 			else
171 				request_module("net-pf-%d-proto-%d",
172 						PF_INET6, protocol);
173 			goto lookup_protocol;
174 		} else
175 			goto out_rcu_unlock;
176 	}
177 
178 	err = -EPERM;
179 	if (sock->type == SOCK_RAW && !kern &&
180 	    !ns_capable(net->user_ns, CAP_NET_RAW))
181 		goto out_rcu_unlock;
182 
183 	sock->ops = answer->ops;
184 	answer_prot = answer->prot;
185 	answer_flags = answer->flags;
186 	rcu_read_unlock();
187 
188 	WARN_ON(!answer_prot->slab);
189 
190 	err = -ENOBUFS;
191 	sk = sk_alloc(net, PF_INET6, GFP_KERNEL, answer_prot, kern);
192 	if (!sk)
193 		goto out;
194 
195 	sock_init_data(sock, sk);
196 
197 	err = 0;
198 	if (INET_PROTOSW_REUSE & answer_flags)
199 		sk->sk_reuse = SK_CAN_REUSE;
200 
201 	inet = inet_sk(sk);
202 	inet->is_icsk = (INET_PROTOSW_ICSK & answer_flags) != 0;
203 
204 	if (SOCK_RAW == sock->type) {
205 		inet->inet_num = protocol;
206 		if (IPPROTO_RAW == protocol)
207 			inet->hdrincl = 1;
208 	}
209 
210 	sk->sk_destruct		= inet6_sock_destruct;
211 	sk->sk_family		= PF_INET6;
212 	sk->sk_protocol		= protocol;
213 
214 	sk->sk_backlog_rcv	= answer->prot->backlog_rcv;
215 
216 	inet_sk(sk)->pinet6 = np = inet6_sk_generic(sk);
217 	np->hop_limit	= -1;
218 	np->mcast_hops	= IPV6_DEFAULT_MCASTHOPS;
219 	np->mc_loop	= 1;
220 	np->mc_all	= 1;
221 	np->pmtudisc	= IPV6_PMTUDISC_WANT;
222 	np->repflow	= net->ipv6.sysctl.flowlabel_reflect & FLOWLABEL_REFLECT_ESTABLISHED;
223 	sk->sk_ipv6only	= net->ipv6.sysctl.bindv6only;
224 
225 	/* Init the ipv4 part of the socket since we can have sockets
226 	 * using v6 API for ipv4.
227 	 */
228 	inet->uc_ttl	= -1;
229 
230 	inet->mc_loop	= 1;
231 	inet->mc_ttl	= 1;
232 	inet->mc_index	= 0;
233 	RCU_INIT_POINTER(inet->mc_list, NULL);
234 	inet->rcv_tos	= 0;
235 
236 	if (READ_ONCE(net->ipv4.sysctl_ip_no_pmtu_disc))
237 		inet->pmtudisc = IP_PMTUDISC_DONT;
238 	else
239 		inet->pmtudisc = IP_PMTUDISC_WANT;
240 	/*
241 	 * Increment only the relevant sk_prot->socks debug field, this changes
242 	 * the previous behaviour of incrementing both the equivalent to
243 	 * answer->prot->socks (inet6_sock_nr) and inet_sock_nr.
244 	 *
245 	 * This allows better debug granularity as we'll know exactly how many
246 	 * UDPv6, TCPv6, etc socks were allocated, not the sum of all IPv6
247 	 * transport protocol socks. -acme
248 	 */
249 	sk_refcnt_debug_inc(sk);
250 
251 	if (inet->inet_num) {
252 		/* It assumes that any protocol which allows
253 		 * the user to assign a number at socket
254 		 * creation time automatically shares.
255 		 */
256 		inet->inet_sport = htons(inet->inet_num);
257 		err = sk->sk_prot->hash(sk);
258 		if (err) {
259 			sk_common_release(sk);
260 			goto out;
261 		}
262 	}
263 	if (sk->sk_prot->init) {
264 		err = sk->sk_prot->init(sk);
265 		if (err) {
266 			sk_common_release(sk);
267 			goto out;
268 		}
269 	}
270 
271 	if (!kern) {
272 		err = BPF_CGROUP_RUN_PROG_INET_SOCK(sk);
273 		if (err) {
274 			sk_common_release(sk);
275 			goto out;
276 		}
277 	}
278 out:
279 	return err;
280 out_rcu_unlock:
281 	rcu_read_unlock();
282 	goto out;
283 }
284 
__inet6_bind(struct sock * sk,struct sockaddr * uaddr,int addr_len,u32 flags)285 static int __inet6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len,
286 			u32 flags)
287 {
288 	struct sockaddr_in6 *addr = (struct sockaddr_in6 *)uaddr;
289 	struct inet_sock *inet = inet_sk(sk);
290 	struct ipv6_pinfo *np = inet6_sk(sk);
291 	struct net *net = sock_net(sk);
292 	__be32 v4addr = 0;
293 	unsigned short snum;
294 	bool saved_ipv6only;
295 	int addr_type = 0;
296 	int err = 0;
297 
298 	if (addr->sin6_family != AF_INET6)
299 		return -EAFNOSUPPORT;
300 
301 	addr_type = ipv6_addr_type(&addr->sin6_addr);
302 	if ((addr_type & IPV6_ADDR_MULTICAST) && sk->sk_type == SOCK_STREAM)
303 		return -EINVAL;
304 
305 	snum = ntohs(addr->sin6_port);
306 	if (!(flags & BIND_NO_CAP_NET_BIND_SERVICE) &&
307 	    snum && inet_port_requires_bind_service(net, snum) &&
308 	    !ns_capable(net->user_ns, CAP_NET_BIND_SERVICE))
309 		return -EACCES;
310 
311 	if (flags & BIND_WITH_LOCK)
312 		lock_sock(sk);
313 
314 	/* Check these errors (active socket, double bind). */
315 	if (sk->sk_state != TCP_CLOSE || inet->inet_num) {
316 		err = -EINVAL;
317 		goto out;
318 	}
319 
320 	/* Check if the address belongs to the host. */
321 	if (addr_type == IPV6_ADDR_MAPPED) {
322 		struct net_device *dev = NULL;
323 		int chk_addr_ret;
324 
325 		/* Binding to v4-mapped address on a v6-only socket
326 		 * makes no sense
327 		 */
328 		if (ipv6_only_sock(sk)) {
329 			err = -EINVAL;
330 			goto out;
331 		}
332 
333 		rcu_read_lock();
334 		if (sk->sk_bound_dev_if) {
335 			dev = dev_get_by_index_rcu(net, sk->sk_bound_dev_if);
336 			if (!dev) {
337 				err = -ENODEV;
338 				goto out_unlock;
339 			}
340 		}
341 
342 		/* Reproduce AF_INET checks to make the bindings consistent */
343 		v4addr = addr->sin6_addr.s6_addr32[3];
344 		chk_addr_ret = inet_addr_type_dev_table(net, dev, v4addr);
345 		rcu_read_unlock();
346 
347 		if (!inet_addr_valid_or_nonlocal(net, inet, v4addr,
348 						 chk_addr_ret)) {
349 			err = -EADDRNOTAVAIL;
350 			goto out;
351 		}
352 	} else {
353 		if (addr_type != IPV6_ADDR_ANY) {
354 			struct net_device *dev = NULL;
355 
356 			rcu_read_lock();
357 			if (__ipv6_addr_needs_scope_id(addr_type)) {
358 				if (addr_len >= sizeof(struct sockaddr_in6) &&
359 				    addr->sin6_scope_id) {
360 					/* Override any existing binding, if another one
361 					 * is supplied by user.
362 					 */
363 					sk->sk_bound_dev_if = addr->sin6_scope_id;
364 				}
365 
366 				/* Binding to link-local address requires an interface */
367 				if (!sk->sk_bound_dev_if) {
368 					err = -EINVAL;
369 					goto out_unlock;
370 				}
371 			}
372 
373 			if (sk->sk_bound_dev_if) {
374 				dev = dev_get_by_index_rcu(net, sk->sk_bound_dev_if);
375 				if (!dev) {
376 					err = -ENODEV;
377 					goto out_unlock;
378 				}
379 			}
380 
381 			/* ipv4 addr of the socket is invalid.  Only the
382 			 * unspecified and mapped address have a v4 equivalent.
383 			 */
384 			v4addr = LOOPBACK4_IPV6;
385 			if (!(addr_type & IPV6_ADDR_MULTICAST))	{
386 				if (!ipv6_can_nonlocal_bind(net, inet) &&
387 				    !ipv6_chk_addr(net, &addr->sin6_addr,
388 						   dev, 0)) {
389 					err = -EADDRNOTAVAIL;
390 					goto out_unlock;
391 				}
392 			}
393 			rcu_read_unlock();
394 		}
395 	}
396 
397 	inet->inet_rcv_saddr = v4addr;
398 	inet->inet_saddr = v4addr;
399 
400 	sk->sk_v6_rcv_saddr = addr->sin6_addr;
401 
402 	if (!(addr_type & IPV6_ADDR_MULTICAST))
403 		np->saddr = addr->sin6_addr;
404 
405 	saved_ipv6only = sk->sk_ipv6only;
406 	if (addr_type != IPV6_ADDR_ANY && addr_type != IPV6_ADDR_MAPPED)
407 		sk->sk_ipv6only = 1;
408 
409 	/* Make sure we are allowed to bind here. */
410 	if (snum || !(inet->bind_address_no_port ||
411 		      (flags & BIND_FORCE_ADDRESS_NO_PORT))) {
412 		err = sk->sk_prot->get_port(sk, snum);
413 		if (err) {
414 			sk->sk_ipv6only = saved_ipv6only;
415 			inet_reset_saddr(sk);
416 			goto out;
417 		}
418 		if (!(flags & BIND_FROM_BPF)) {
419 			err = BPF_CGROUP_RUN_PROG_INET6_POST_BIND(sk);
420 			if (err) {
421 				sk->sk_ipv6only = saved_ipv6only;
422 				inet_reset_saddr(sk);
423 				if (sk->sk_prot->put_port)
424 					sk->sk_prot->put_port(sk);
425 				goto out;
426 			}
427 		}
428 	}
429 
430 	if (addr_type != IPV6_ADDR_ANY)
431 		sk->sk_userlocks |= SOCK_BINDADDR_LOCK;
432 	if (snum)
433 		sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
434 	inet->inet_sport = htons(inet->inet_num);
435 	inet->inet_dport = 0;
436 	inet->inet_daddr = 0;
437 out:
438 	if (flags & BIND_WITH_LOCK)
439 		release_sock(sk);
440 	return err;
441 out_unlock:
442 	rcu_read_unlock();
443 	goto out;
444 }
445 
446 /* bind for INET6 API */
inet6_bind(struct socket * sock,struct sockaddr * uaddr,int addr_len)447 int inet6_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
448 {
449 	struct sock *sk = sock->sk;
450 	u32 flags = BIND_WITH_LOCK;
451 	const struct proto *prot;
452 	int err = 0;
453 
454 	/* IPV6_ADDRFORM can change sk->sk_prot under us. */
455 	prot = READ_ONCE(sk->sk_prot);
456 	/* If the socket has its own bind function then use it. */
457 	if (prot->bind)
458 		return prot->bind(sk, uaddr, addr_len);
459 
460 	if (addr_len < SIN6_LEN_RFC2133)
461 		return -EINVAL;
462 
463 	/* BPF prog is run before any checks are done so that if the prog
464 	 * changes context in a wrong way it will be caught.
465 	 */
466 	err = BPF_CGROUP_RUN_PROG_INET_BIND_LOCK(sk, uaddr,
467 						 CGROUP_INET6_BIND, &flags);
468 	if (err)
469 		return err;
470 
471 	return __inet6_bind(sk, uaddr, addr_len, flags);
472 }
473 EXPORT_SYMBOL(inet6_bind);
474 
inet6_release(struct socket * sock)475 int inet6_release(struct socket *sock)
476 {
477 	struct sock *sk = sock->sk;
478 
479 	if (!sk)
480 		return -EINVAL;
481 
482 	/* Free mc lists */
483 	ipv6_sock_mc_close(sk);
484 
485 	/* Free ac lists */
486 	ipv6_sock_ac_close(sk);
487 
488 	return inet_release(sock);
489 }
490 EXPORT_SYMBOL(inet6_release);
491 
inet6_destroy_sock(struct sock * sk)492 void inet6_destroy_sock(struct sock *sk)
493 {
494 	struct ipv6_pinfo *np = inet6_sk(sk);
495 	struct sk_buff *skb;
496 	struct ipv6_txoptions *opt;
497 
498 	/* Release rx options */
499 
500 	skb = xchg(&np->pktoptions, NULL);
501 	kfree_skb(skb);
502 
503 	skb = xchg(&np->rxpmtu, NULL);
504 	kfree_skb(skb);
505 
506 	/* Free flowlabels */
507 	fl6_free_socklist(sk);
508 
509 	/* Free tx options */
510 
511 	opt = xchg((__force struct ipv6_txoptions **)&np->opt, NULL);
512 	if (opt) {
513 		atomic_sub(opt->tot_len, &sk->sk_omem_alloc);
514 		txopt_put(opt);
515 	}
516 }
517 EXPORT_SYMBOL_GPL(inet6_destroy_sock);
518 
inet6_cleanup_sock(struct sock * sk)519 void inet6_cleanup_sock(struct sock *sk)
520 {
521 	inet6_destroy_sock(sk);
522 }
523 EXPORT_SYMBOL_GPL(inet6_cleanup_sock);
524 
525 /*
526  *	This does both peername and sockname.
527  */
inet6_getname(struct socket * sock,struct sockaddr * uaddr,int peer)528 int inet6_getname(struct socket *sock, struct sockaddr *uaddr,
529 		  int peer)
530 {
531 	struct sockaddr_in6 *sin = (struct sockaddr_in6 *)uaddr;
532 	struct sock *sk = sock->sk;
533 	struct inet_sock *inet = inet_sk(sk);
534 	struct ipv6_pinfo *np = inet6_sk(sk);
535 
536 	sin->sin6_family = AF_INET6;
537 	sin->sin6_flowinfo = 0;
538 	sin->sin6_scope_id = 0;
539 	lock_sock(sk);
540 	if (peer) {
541 		if (!inet->inet_dport ||
542 		    (((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_SYN_SENT)) &&
543 		    peer == 1)) {
544 			release_sock(sk);
545 			return -ENOTCONN;
546 		}
547 		sin->sin6_port = inet->inet_dport;
548 		sin->sin6_addr = sk->sk_v6_daddr;
549 		if (np->sndflow)
550 			sin->sin6_flowinfo = np->flow_label;
551 		BPF_CGROUP_RUN_SA_PROG(sk, (struct sockaddr *)sin,
552 				       CGROUP_INET6_GETPEERNAME);
553 	} else {
554 		if (ipv6_addr_any(&sk->sk_v6_rcv_saddr))
555 			sin->sin6_addr = np->saddr;
556 		else
557 			sin->sin6_addr = sk->sk_v6_rcv_saddr;
558 		sin->sin6_port = inet->inet_sport;
559 		BPF_CGROUP_RUN_SA_PROG(sk, (struct sockaddr *)sin,
560 				       CGROUP_INET6_GETSOCKNAME);
561 	}
562 	sin->sin6_scope_id = ipv6_iface_scope_id(&sin->sin6_addr,
563 						 sk->sk_bound_dev_if);
564 	release_sock(sk);
565 	return sizeof(*sin);
566 }
567 EXPORT_SYMBOL(inet6_getname);
568 
inet6_ioctl(struct socket * sock,unsigned int cmd,unsigned long arg)569 int inet6_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
570 {
571 	void __user *argp = (void __user *)arg;
572 	struct sock *sk = sock->sk;
573 	struct net *net = sock_net(sk);
574 	const struct proto *prot;
575 
576 	switch (cmd) {
577 	case SIOCADDRT:
578 	case SIOCDELRT: {
579 		struct in6_rtmsg rtmsg;
580 
581 		if (copy_from_user(&rtmsg, argp, sizeof(rtmsg)))
582 			return -EFAULT;
583 		return ipv6_route_ioctl(net, cmd, &rtmsg);
584 	}
585 	case SIOCSIFADDR:
586 		return addrconf_add_ifaddr(net, argp);
587 	case SIOCDIFADDR:
588 		return addrconf_del_ifaddr(net, argp);
589 	case SIOCSIFDSTADDR:
590 		return addrconf_set_dstaddr(net, argp);
591 	default:
592 		/* IPV6_ADDRFORM can change sk->sk_prot under us. */
593 		prot = READ_ONCE(sk->sk_prot);
594 		if (!prot->ioctl)
595 			return -ENOIOCTLCMD;
596 		return prot->ioctl(sk, cmd, arg);
597 	}
598 	/*NOTREACHED*/
599 	return 0;
600 }
601 EXPORT_SYMBOL(inet6_ioctl);
602 
603 #ifdef CONFIG_COMPAT
604 struct compat_in6_rtmsg {
605 	struct in6_addr		rtmsg_dst;
606 	struct in6_addr		rtmsg_src;
607 	struct in6_addr		rtmsg_gateway;
608 	u32			rtmsg_type;
609 	u16			rtmsg_dst_len;
610 	u16			rtmsg_src_len;
611 	u32			rtmsg_metric;
612 	u32			rtmsg_info;
613 	u32			rtmsg_flags;
614 	s32			rtmsg_ifindex;
615 };
616 
inet6_compat_routing_ioctl(struct sock * sk,unsigned int cmd,struct compat_in6_rtmsg __user * ur)617 static int inet6_compat_routing_ioctl(struct sock *sk, unsigned int cmd,
618 		struct compat_in6_rtmsg __user *ur)
619 {
620 	struct in6_rtmsg rt;
621 
622 	if (copy_from_user(&rt.rtmsg_dst, &ur->rtmsg_dst,
623 			3 * sizeof(struct in6_addr)) ||
624 	    get_user(rt.rtmsg_type, &ur->rtmsg_type) ||
625 	    get_user(rt.rtmsg_dst_len, &ur->rtmsg_dst_len) ||
626 	    get_user(rt.rtmsg_src_len, &ur->rtmsg_src_len) ||
627 	    get_user(rt.rtmsg_metric, &ur->rtmsg_metric) ||
628 	    get_user(rt.rtmsg_info, &ur->rtmsg_info) ||
629 	    get_user(rt.rtmsg_flags, &ur->rtmsg_flags) ||
630 	    get_user(rt.rtmsg_ifindex, &ur->rtmsg_ifindex))
631 		return -EFAULT;
632 
633 
634 	return ipv6_route_ioctl(sock_net(sk), cmd, &rt);
635 }
636 
inet6_compat_ioctl(struct socket * sock,unsigned int cmd,unsigned long arg)637 int inet6_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
638 {
639 	void __user *argp = compat_ptr(arg);
640 	struct sock *sk = sock->sk;
641 
642 	switch (cmd) {
643 	case SIOCADDRT:
644 	case SIOCDELRT:
645 		return inet6_compat_routing_ioctl(sk, cmd, argp);
646 	default:
647 		return -ENOIOCTLCMD;
648 	}
649 }
650 EXPORT_SYMBOL_GPL(inet6_compat_ioctl);
651 #endif /* CONFIG_COMPAT */
652 
653 INDIRECT_CALLABLE_DECLARE(int udpv6_sendmsg(struct sock *, struct msghdr *,
654 					    size_t));
inet6_sendmsg(struct socket * sock,struct msghdr * msg,size_t size)655 int inet6_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
656 {
657 	struct sock *sk = sock->sk;
658 	const struct proto *prot;
659 
660 	if (unlikely(inet_send_prepare(sk)))
661 		return -EAGAIN;
662 
663 	/* IPV6_ADDRFORM can change sk->sk_prot under us. */
664 	prot = READ_ONCE(sk->sk_prot);
665 	return INDIRECT_CALL_2(prot->sendmsg, tcp_sendmsg, udpv6_sendmsg,
666 			       sk, msg, size);
667 }
668 
669 INDIRECT_CALLABLE_DECLARE(int udpv6_recvmsg(struct sock *, struct msghdr *,
670 					    size_t, int, int *));
inet6_recvmsg(struct socket * sock,struct msghdr * msg,size_t size,int flags)671 int inet6_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
672 		  int flags)
673 {
674 	struct sock *sk = sock->sk;
675 	const struct proto *prot;
676 	int addr_len = 0;
677 	int err;
678 
679 	if (likely(!(flags & MSG_ERRQUEUE)))
680 		sock_rps_record_flow(sk);
681 
682 	/* IPV6_ADDRFORM can change sk->sk_prot under us. */
683 	prot = READ_ONCE(sk->sk_prot);
684 	err = INDIRECT_CALL_2(prot->recvmsg, tcp_recvmsg, udpv6_recvmsg,
685 			      sk, msg, size, flags, &addr_len);
686 	if (err >= 0)
687 		msg->msg_namelen = addr_len;
688 	return err;
689 }
690 
691 const struct proto_ops inet6_stream_ops = {
692 	.family		   = PF_INET6,
693 	.owner		   = THIS_MODULE,
694 	.release	   = inet6_release,
695 	.bind		   = inet6_bind,
696 	.connect	   = inet_stream_connect,	/* ok		*/
697 	.socketpair	   = sock_no_socketpair,	/* a do nothing	*/
698 	.accept		   = inet_accept,		/* ok		*/
699 	.getname	   = inet6_getname,
700 	.poll		   = tcp_poll,			/* ok		*/
701 	.ioctl		   = inet6_ioctl,		/* must change  */
702 	.gettstamp	   = sock_gettstamp,
703 	.listen		   = inet_listen,		/* ok		*/
704 	.shutdown	   = inet_shutdown,		/* ok		*/
705 	.setsockopt	   = sock_common_setsockopt,	/* ok		*/
706 	.getsockopt	   = sock_common_getsockopt,	/* ok		*/
707 	.sendmsg	   = inet6_sendmsg,		/* retpoline's sake */
708 	.recvmsg	   = inet6_recvmsg,		/* retpoline's sake */
709 #ifdef CONFIG_MMU
710 	.mmap		   = tcp_mmap,
711 #endif
712 	.sendpage	   = inet_sendpage,
713 	.sendmsg_locked    = tcp_sendmsg_locked,
714 	.sendpage_locked   = tcp_sendpage_locked,
715 	.splice_read	   = tcp_splice_read,
716 	.read_sock	   = tcp_read_sock,
717 	.read_skb	   = tcp_read_skb,
718 	.peek_len	   = tcp_peek_len,
719 #ifdef CONFIG_COMPAT
720 	.compat_ioctl	   = inet6_compat_ioctl,
721 #endif
722 	.set_rcvlowat	   = tcp_set_rcvlowat,
723 };
724 
725 const struct proto_ops inet6_dgram_ops = {
726 	.family		   = PF_INET6,
727 	.owner		   = THIS_MODULE,
728 	.release	   = inet6_release,
729 	.bind		   = inet6_bind,
730 	.connect	   = inet_dgram_connect,	/* ok		*/
731 	.socketpair	   = sock_no_socketpair,	/* a do nothing	*/
732 	.accept		   = sock_no_accept,		/* a do nothing	*/
733 	.getname	   = inet6_getname,
734 	.poll		   = udp_poll,			/* ok		*/
735 	.ioctl		   = inet6_ioctl,		/* must change  */
736 	.gettstamp	   = sock_gettstamp,
737 	.listen		   = sock_no_listen,		/* ok		*/
738 	.shutdown	   = inet_shutdown,		/* ok		*/
739 	.setsockopt	   = sock_common_setsockopt,	/* ok		*/
740 	.getsockopt	   = sock_common_getsockopt,	/* ok		*/
741 	.sendmsg	   = inet6_sendmsg,		/* retpoline's sake */
742 	.recvmsg	   = inet6_recvmsg,		/* retpoline's sake */
743 	.read_skb	   = udp_read_skb,
744 	.mmap		   = sock_no_mmap,
745 	.sendpage	   = sock_no_sendpage,
746 	.set_peek_off	   = sk_set_peek_off,
747 #ifdef CONFIG_COMPAT
748 	.compat_ioctl	   = inet6_compat_ioctl,
749 #endif
750 };
751 
752 static const struct net_proto_family inet6_family_ops = {
753 	.family = PF_INET6,
754 	.create = inet6_create,
755 	.owner	= THIS_MODULE,
756 };
757 
inet6_register_protosw(struct inet_protosw * p)758 int inet6_register_protosw(struct inet_protosw *p)
759 {
760 	struct list_head *lh;
761 	struct inet_protosw *answer;
762 	struct list_head *last_perm;
763 	int protocol = p->protocol;
764 	int ret;
765 
766 	spin_lock_bh(&inetsw6_lock);
767 
768 	ret = -EINVAL;
769 	if (p->type >= SOCK_MAX)
770 		goto out_illegal;
771 
772 	/* If we are trying to override a permanent protocol, bail. */
773 	answer = NULL;
774 	ret = -EPERM;
775 	last_perm = &inetsw6[p->type];
776 	list_for_each(lh, &inetsw6[p->type]) {
777 		answer = list_entry(lh, struct inet_protosw, list);
778 
779 		/* Check only the non-wild match. */
780 		if (INET_PROTOSW_PERMANENT & answer->flags) {
781 			if (protocol == answer->protocol)
782 				break;
783 			last_perm = lh;
784 		}
785 
786 		answer = NULL;
787 	}
788 	if (answer)
789 		goto out_permanent;
790 
791 	/* Add the new entry after the last permanent entry if any, so that
792 	 * the new entry does not override a permanent entry when matched with
793 	 * a wild-card protocol. But it is allowed to override any existing
794 	 * non-permanent entry.  This means that when we remove this entry, the
795 	 * system automatically returns to the old behavior.
796 	 */
797 	list_add_rcu(&p->list, last_perm);
798 	ret = 0;
799 out:
800 	spin_unlock_bh(&inetsw6_lock);
801 	return ret;
802 
803 out_permanent:
804 	pr_err("Attempt to override permanent protocol %d\n", protocol);
805 	goto out;
806 
807 out_illegal:
808 	pr_err("Ignoring attempt to register invalid socket type %d\n",
809 	       p->type);
810 	goto out;
811 }
812 EXPORT_SYMBOL(inet6_register_protosw);
813 
814 void
inet6_unregister_protosw(struct inet_protosw * p)815 inet6_unregister_protosw(struct inet_protosw *p)
816 {
817 	if (INET_PROTOSW_PERMANENT & p->flags) {
818 		pr_err("Attempt to unregister permanent protocol %d\n",
819 		       p->protocol);
820 	} else {
821 		spin_lock_bh(&inetsw6_lock);
822 		list_del_rcu(&p->list);
823 		spin_unlock_bh(&inetsw6_lock);
824 
825 		synchronize_net();
826 	}
827 }
828 EXPORT_SYMBOL(inet6_unregister_protosw);
829 
inet6_sk_rebuild_header(struct sock * sk)830 int inet6_sk_rebuild_header(struct sock *sk)
831 {
832 	struct ipv6_pinfo *np = inet6_sk(sk);
833 	struct dst_entry *dst;
834 
835 	dst = __sk_dst_check(sk, np->dst_cookie);
836 
837 	if (!dst) {
838 		struct inet_sock *inet = inet_sk(sk);
839 		struct in6_addr *final_p, final;
840 		struct flowi6 fl6;
841 
842 		memset(&fl6, 0, sizeof(fl6));
843 		fl6.flowi6_proto = sk->sk_protocol;
844 		fl6.daddr = sk->sk_v6_daddr;
845 		fl6.saddr = np->saddr;
846 		fl6.flowlabel = np->flow_label;
847 		fl6.flowi6_oif = sk->sk_bound_dev_if;
848 		fl6.flowi6_mark = sk->sk_mark;
849 		fl6.fl6_dport = inet->inet_dport;
850 		fl6.fl6_sport = inet->inet_sport;
851 		fl6.flowi6_uid = sk->sk_uid;
852 		security_sk_classify_flow(sk, flowi6_to_flowi_common(&fl6));
853 
854 		rcu_read_lock();
855 		final_p = fl6_update_dst(&fl6, rcu_dereference(np->opt),
856 					 &final);
857 		rcu_read_unlock();
858 
859 		dst = ip6_dst_lookup_flow(sock_net(sk), sk, &fl6, final_p);
860 		if (IS_ERR(dst)) {
861 			sk->sk_route_caps = 0;
862 			sk->sk_err_soft = -PTR_ERR(dst);
863 			return PTR_ERR(dst);
864 		}
865 
866 		ip6_dst_store(sk, dst, NULL, NULL);
867 	}
868 
869 	return 0;
870 }
871 EXPORT_SYMBOL_GPL(inet6_sk_rebuild_header);
872 
ipv6_opt_accepted(const struct sock * sk,const struct sk_buff * skb,const struct inet6_skb_parm * opt)873 bool ipv6_opt_accepted(const struct sock *sk, const struct sk_buff *skb,
874 		       const struct inet6_skb_parm *opt)
875 {
876 	const struct ipv6_pinfo *np = inet6_sk(sk);
877 
878 	if (np->rxopt.all) {
879 		if (((opt->flags & IP6SKB_HOPBYHOP) &&
880 		     (np->rxopt.bits.hopopts || np->rxopt.bits.ohopopts)) ||
881 		    (ip6_flowinfo((struct ipv6hdr *) skb_network_header(skb)) &&
882 		     np->rxopt.bits.rxflow) ||
883 		    (opt->srcrt && (np->rxopt.bits.srcrt ||
884 		     np->rxopt.bits.osrcrt)) ||
885 		    ((opt->dst1 || opt->dst0) &&
886 		     (np->rxopt.bits.dstopts || np->rxopt.bits.odstopts)))
887 			return true;
888 	}
889 	return false;
890 }
891 EXPORT_SYMBOL_GPL(ipv6_opt_accepted);
892 
893 static struct packet_type ipv6_packet_type __read_mostly = {
894 	.type = cpu_to_be16(ETH_P_IPV6),
895 	.func = ipv6_rcv,
896 	.list_func = ipv6_list_rcv,
897 };
898 
ipv6_packet_init(void)899 static int __init ipv6_packet_init(void)
900 {
901 	dev_add_pack(&ipv6_packet_type);
902 	return 0;
903 }
904 
ipv6_packet_cleanup(void)905 static void ipv6_packet_cleanup(void)
906 {
907 	dev_remove_pack(&ipv6_packet_type);
908 }
909 
ipv6_init_mibs(struct net * net)910 static int __net_init ipv6_init_mibs(struct net *net)
911 {
912 	int i;
913 
914 	net->mib.udp_stats_in6 = alloc_percpu(struct udp_mib);
915 	if (!net->mib.udp_stats_in6)
916 		return -ENOMEM;
917 	net->mib.udplite_stats_in6 = alloc_percpu(struct udp_mib);
918 	if (!net->mib.udplite_stats_in6)
919 		goto err_udplite_mib;
920 	net->mib.ipv6_statistics = alloc_percpu(struct ipstats_mib);
921 	if (!net->mib.ipv6_statistics)
922 		goto err_ip_mib;
923 
924 	for_each_possible_cpu(i) {
925 		struct ipstats_mib *af_inet6_stats;
926 		af_inet6_stats = per_cpu_ptr(net->mib.ipv6_statistics, i);
927 		u64_stats_init(&af_inet6_stats->syncp);
928 	}
929 
930 
931 	net->mib.icmpv6_statistics = alloc_percpu(struct icmpv6_mib);
932 	if (!net->mib.icmpv6_statistics)
933 		goto err_icmp_mib;
934 	net->mib.icmpv6msg_statistics = kzalloc(sizeof(struct icmpv6msg_mib),
935 						GFP_KERNEL);
936 	if (!net->mib.icmpv6msg_statistics)
937 		goto err_icmpmsg_mib;
938 	return 0;
939 
940 err_icmpmsg_mib:
941 	free_percpu(net->mib.icmpv6_statistics);
942 err_icmp_mib:
943 	free_percpu(net->mib.ipv6_statistics);
944 err_ip_mib:
945 	free_percpu(net->mib.udplite_stats_in6);
946 err_udplite_mib:
947 	free_percpu(net->mib.udp_stats_in6);
948 	return -ENOMEM;
949 }
950 
ipv6_cleanup_mibs(struct net * net)951 static void ipv6_cleanup_mibs(struct net *net)
952 {
953 	free_percpu(net->mib.udp_stats_in6);
954 	free_percpu(net->mib.udplite_stats_in6);
955 	free_percpu(net->mib.ipv6_statistics);
956 	free_percpu(net->mib.icmpv6_statistics);
957 	kfree(net->mib.icmpv6msg_statistics);
958 }
959 
inet6_net_init(struct net * net)960 static int __net_init inet6_net_init(struct net *net)
961 {
962 	int err = 0;
963 
964 	net->ipv6.sysctl.bindv6only = 0;
965 	net->ipv6.sysctl.icmpv6_time = 1*HZ;
966 	net->ipv6.sysctl.icmpv6_echo_ignore_all = 0;
967 	net->ipv6.sysctl.icmpv6_echo_ignore_multicast = 0;
968 	net->ipv6.sysctl.icmpv6_echo_ignore_anycast = 0;
969 
970 	/* By default, rate limit error messages.
971 	 * Except for pmtu discovery, it would break it.
972 	 * proc_do_large_bitmap needs pointer to the bitmap.
973 	 */
974 	bitmap_set(net->ipv6.sysctl.icmpv6_ratemask, 0, ICMPV6_ERRMSG_MAX + 1);
975 	bitmap_clear(net->ipv6.sysctl.icmpv6_ratemask, ICMPV6_PKT_TOOBIG, 1);
976 	net->ipv6.sysctl.icmpv6_ratemask_ptr = net->ipv6.sysctl.icmpv6_ratemask;
977 
978 	net->ipv6.sysctl.flowlabel_consistency = 1;
979 	net->ipv6.sysctl.auto_flowlabels = IP6_DEFAULT_AUTO_FLOW_LABELS;
980 	net->ipv6.sysctl.idgen_retries = 3;
981 	net->ipv6.sysctl.idgen_delay = 1 * HZ;
982 	net->ipv6.sysctl.flowlabel_state_ranges = 0;
983 	net->ipv6.sysctl.max_dst_opts_cnt = IP6_DEFAULT_MAX_DST_OPTS_CNT;
984 	net->ipv6.sysctl.max_hbh_opts_cnt = IP6_DEFAULT_MAX_HBH_OPTS_CNT;
985 	net->ipv6.sysctl.max_dst_opts_len = IP6_DEFAULT_MAX_DST_OPTS_LEN;
986 	net->ipv6.sysctl.max_hbh_opts_len = IP6_DEFAULT_MAX_HBH_OPTS_LEN;
987 	net->ipv6.sysctl.fib_notify_on_flag_change = 0;
988 	atomic_set(&net->ipv6.fib6_sernum, 1);
989 
990 	net->ipv6.sysctl.ioam6_id = IOAM6_DEFAULT_ID;
991 	net->ipv6.sysctl.ioam6_id_wide = IOAM6_DEFAULT_ID_WIDE;
992 
993 	err = ipv6_init_mibs(net);
994 	if (err)
995 		return err;
996 #ifdef CONFIG_PROC_FS
997 	err = udp6_proc_init(net);
998 	if (err)
999 		goto out;
1000 	err = tcp6_proc_init(net);
1001 	if (err)
1002 		goto proc_tcp6_fail;
1003 	err = ac6_proc_init(net);
1004 	if (err)
1005 		goto proc_ac6_fail;
1006 #endif
1007 	return err;
1008 
1009 #ifdef CONFIG_PROC_FS
1010 proc_ac6_fail:
1011 	tcp6_proc_exit(net);
1012 proc_tcp6_fail:
1013 	udp6_proc_exit(net);
1014 out:
1015 	ipv6_cleanup_mibs(net);
1016 	return err;
1017 #endif
1018 }
1019 
inet6_net_exit(struct net * net)1020 static void __net_exit inet6_net_exit(struct net *net)
1021 {
1022 #ifdef CONFIG_PROC_FS
1023 	udp6_proc_exit(net);
1024 	tcp6_proc_exit(net);
1025 	ac6_proc_exit(net);
1026 #endif
1027 	ipv6_cleanup_mibs(net);
1028 }
1029 
1030 static struct pernet_operations inet6_net_ops = {
1031 	.init = inet6_net_init,
1032 	.exit = inet6_net_exit,
1033 };
1034 
ipv6_route_input(struct sk_buff * skb)1035 static int ipv6_route_input(struct sk_buff *skb)
1036 {
1037 	ip6_route_input(skb);
1038 	return skb_dst(skb)->error;
1039 }
1040 
1041 static const struct ipv6_stub ipv6_stub_impl = {
1042 	.ipv6_sock_mc_join = ipv6_sock_mc_join,
1043 	.ipv6_sock_mc_drop = ipv6_sock_mc_drop,
1044 	.ipv6_dst_lookup_flow = ip6_dst_lookup_flow,
1045 	.ipv6_route_input  = ipv6_route_input,
1046 	.fib6_get_table	   = fib6_get_table,
1047 	.fib6_table_lookup = fib6_table_lookup,
1048 	.fib6_lookup       = fib6_lookup,
1049 	.fib6_select_path  = fib6_select_path,
1050 	.ip6_mtu_from_fib6 = ip6_mtu_from_fib6,
1051 	.fib6_nh_init	   = fib6_nh_init,
1052 	.fib6_nh_release   = fib6_nh_release,
1053 	.fib6_nh_release_dsts = fib6_nh_release_dsts,
1054 	.fib6_update_sernum = fib6_update_sernum_stub,
1055 	.fib6_rt_update	   = fib6_rt_update,
1056 	.ip6_del_rt	   = ip6_del_rt,
1057 	.udpv6_encap_enable = udpv6_encap_enable,
1058 	.ndisc_send_na = ndisc_send_na,
1059 #if IS_ENABLED(CONFIG_XFRM)
1060 	.xfrm6_local_rxpmtu = xfrm6_local_rxpmtu,
1061 	.xfrm6_udp_encap_rcv = xfrm6_udp_encap_rcv,
1062 	.xfrm6_rcv_encap = xfrm6_rcv_encap,
1063 #endif
1064 	.nd_tbl	= &nd_tbl,
1065 	.ipv6_fragment = ip6_fragment,
1066 	.ipv6_dev_find = ipv6_dev_find,
1067 };
1068 
1069 static const struct ipv6_bpf_stub ipv6_bpf_stub_impl = {
1070 	.inet6_bind = __inet6_bind,
1071 	.udp6_lib_lookup = __udp6_lib_lookup,
1072 	.ipv6_setsockopt = do_ipv6_setsockopt,
1073 	.ipv6_getsockopt = do_ipv6_getsockopt,
1074 };
1075 
inet6_init(void)1076 static int __init inet6_init(void)
1077 {
1078 	struct list_head *r;
1079 	int err = 0;
1080 
1081 	sock_skb_cb_check_size(sizeof(struct inet6_skb_parm));
1082 
1083 	/* Register the socket-side information for inet6_create.  */
1084 	for (r = &inetsw6[0]; r < &inetsw6[SOCK_MAX]; ++r)
1085 		INIT_LIST_HEAD(r);
1086 
1087 	raw_hashinfo_init(&raw_v6_hashinfo);
1088 
1089 	if (disable_ipv6_mod) {
1090 		pr_info("Loaded, but administratively disabled, reboot required to enable\n");
1091 		goto out;
1092 	}
1093 
1094 	err = proto_register(&tcpv6_prot, 1);
1095 	if (err)
1096 		goto out;
1097 
1098 	err = proto_register(&udpv6_prot, 1);
1099 	if (err)
1100 		goto out_unregister_tcp_proto;
1101 
1102 	err = proto_register(&udplitev6_prot, 1);
1103 	if (err)
1104 		goto out_unregister_udp_proto;
1105 
1106 	err = proto_register(&rawv6_prot, 1);
1107 	if (err)
1108 		goto out_unregister_udplite_proto;
1109 
1110 	err = proto_register(&pingv6_prot, 1);
1111 	if (err)
1112 		goto out_unregister_raw_proto;
1113 
1114 	/* We MUST register RAW sockets before we create the ICMP6,
1115 	 * IGMP6, or NDISC control sockets.
1116 	 */
1117 	err = rawv6_init();
1118 	if (err)
1119 		goto out_unregister_ping_proto;
1120 
1121 	/* Register the family here so that the init calls below will
1122 	 * be able to create sockets. (?? is this dangerous ??)
1123 	 */
1124 	err = sock_register(&inet6_family_ops);
1125 	if (err)
1126 		goto out_sock_register_fail;
1127 
1128 	/*
1129 	 *	ipngwg API draft makes clear that the correct semantics
1130 	 *	for TCP and UDP is to consider one TCP and UDP instance
1131 	 *	in a host available by both INET and INET6 APIs and
1132 	 *	able to communicate via both network protocols.
1133 	 */
1134 
1135 	err = register_pernet_subsys(&inet6_net_ops);
1136 	if (err)
1137 		goto register_pernet_fail;
1138 	err = ip6_mr_init();
1139 	if (err)
1140 		goto ipmr_fail;
1141 	err = icmpv6_init();
1142 	if (err)
1143 		goto icmp_fail;
1144 	err = ndisc_init();
1145 	if (err)
1146 		goto ndisc_fail;
1147 	err = igmp6_init();
1148 	if (err)
1149 		goto igmp_fail;
1150 
1151 	err = ipv6_netfilter_init();
1152 	if (err)
1153 		goto netfilter_fail;
1154 	/* Create /proc/foo6 entries. */
1155 #ifdef CONFIG_PROC_FS
1156 	err = -ENOMEM;
1157 	if (raw6_proc_init())
1158 		goto proc_raw6_fail;
1159 	if (udplite6_proc_init())
1160 		goto proc_udplite6_fail;
1161 	if (ipv6_misc_proc_init())
1162 		goto proc_misc6_fail;
1163 	if (if6_proc_init())
1164 		goto proc_if6_fail;
1165 #endif
1166 	err = ip6_route_init();
1167 	if (err)
1168 		goto ip6_route_fail;
1169 	err = ndisc_late_init();
1170 	if (err)
1171 		goto ndisc_late_fail;
1172 	err = ip6_flowlabel_init();
1173 	if (err)
1174 		goto ip6_flowlabel_fail;
1175 	err = ipv6_anycast_init();
1176 	if (err)
1177 		goto ipv6_anycast_fail;
1178 	err = addrconf_init();
1179 	if (err)
1180 		goto addrconf_fail;
1181 
1182 	/* Init v6 extension headers. */
1183 	err = ipv6_exthdrs_init();
1184 	if (err)
1185 		goto ipv6_exthdrs_fail;
1186 
1187 	err = ipv6_frag_init();
1188 	if (err)
1189 		goto ipv6_frag_fail;
1190 
1191 	/* Init v6 transport protocols. */
1192 	err = udpv6_init();
1193 	if (err)
1194 		goto udpv6_fail;
1195 
1196 	err = udplitev6_init();
1197 	if (err)
1198 		goto udplitev6_fail;
1199 
1200 	err = udpv6_offload_init();
1201 	if (err)
1202 		goto udpv6_offload_fail;
1203 
1204 	err = tcpv6_init();
1205 	if (err)
1206 		goto tcpv6_fail;
1207 
1208 	err = ipv6_packet_init();
1209 	if (err)
1210 		goto ipv6_packet_fail;
1211 
1212 	err = pingv6_init();
1213 	if (err)
1214 		goto pingv6_fail;
1215 
1216 	err = calipso_init();
1217 	if (err)
1218 		goto calipso_fail;
1219 
1220 	err = seg6_init();
1221 	if (err)
1222 		goto seg6_fail;
1223 
1224 	err = rpl_init();
1225 	if (err)
1226 		goto rpl_fail;
1227 
1228 	err = ioam6_init();
1229 	if (err)
1230 		goto ioam6_fail;
1231 
1232 	err = igmp6_late_init();
1233 	if (err)
1234 		goto igmp6_late_err;
1235 
1236 #ifdef CONFIG_SYSCTL
1237 	err = ipv6_sysctl_register();
1238 	if (err)
1239 		goto sysctl_fail;
1240 #endif
1241 
1242 	/* ensure that ipv6 stubs are visible only after ipv6 is ready */
1243 	wmb();
1244 	ipv6_stub = &ipv6_stub_impl;
1245 	ipv6_bpf_stub = &ipv6_bpf_stub_impl;
1246 out:
1247 	return err;
1248 
1249 #ifdef CONFIG_SYSCTL
1250 sysctl_fail:
1251 	igmp6_late_cleanup();
1252 #endif
1253 igmp6_late_err:
1254 	ioam6_exit();
1255 ioam6_fail:
1256 	rpl_exit();
1257 rpl_fail:
1258 	seg6_exit();
1259 seg6_fail:
1260 	calipso_exit();
1261 calipso_fail:
1262 	pingv6_exit();
1263 pingv6_fail:
1264 	ipv6_packet_cleanup();
1265 ipv6_packet_fail:
1266 	tcpv6_exit();
1267 tcpv6_fail:
1268 	udpv6_offload_exit();
1269 udpv6_offload_fail:
1270 	udplitev6_exit();
1271 udplitev6_fail:
1272 	udpv6_exit();
1273 udpv6_fail:
1274 	ipv6_frag_exit();
1275 ipv6_frag_fail:
1276 	ipv6_exthdrs_exit();
1277 ipv6_exthdrs_fail:
1278 	addrconf_cleanup();
1279 addrconf_fail:
1280 	ipv6_anycast_cleanup();
1281 ipv6_anycast_fail:
1282 	ip6_flowlabel_cleanup();
1283 ip6_flowlabel_fail:
1284 	ndisc_late_cleanup();
1285 ndisc_late_fail:
1286 	ip6_route_cleanup();
1287 ip6_route_fail:
1288 #ifdef CONFIG_PROC_FS
1289 	if6_proc_exit();
1290 proc_if6_fail:
1291 	ipv6_misc_proc_exit();
1292 proc_misc6_fail:
1293 	udplite6_proc_exit();
1294 proc_udplite6_fail:
1295 	raw6_proc_exit();
1296 proc_raw6_fail:
1297 #endif
1298 	ipv6_netfilter_fini();
1299 netfilter_fail:
1300 	igmp6_cleanup();
1301 igmp_fail:
1302 	ndisc_cleanup();
1303 ndisc_fail:
1304 	icmpv6_cleanup();
1305 icmp_fail:
1306 	ip6_mr_cleanup();
1307 ipmr_fail:
1308 	unregister_pernet_subsys(&inet6_net_ops);
1309 register_pernet_fail:
1310 	sock_unregister(PF_INET6);
1311 	rtnl_unregister_all(PF_INET6);
1312 out_sock_register_fail:
1313 	rawv6_exit();
1314 out_unregister_ping_proto:
1315 	proto_unregister(&pingv6_prot);
1316 out_unregister_raw_proto:
1317 	proto_unregister(&rawv6_prot);
1318 out_unregister_udplite_proto:
1319 	proto_unregister(&udplitev6_prot);
1320 out_unregister_udp_proto:
1321 	proto_unregister(&udpv6_prot);
1322 out_unregister_tcp_proto:
1323 	proto_unregister(&tcpv6_prot);
1324 	goto out;
1325 }
1326 module_init(inet6_init);
1327 
1328 MODULE_ALIAS_NETPROTO(PF_INET6);
1329