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 <trace/hooks/net.h>
72
73 #include "ip6_offload.h"
74
75 MODULE_AUTHOR("Cast of dozens");
76 MODULE_DESCRIPTION("IPv6 protocol stack for Linux");
77 MODULE_LICENSE("GPL");
78
79 /* The inetsw6 table contains everything that inet6_create needs to
80 * build a new socket.
81 */
82 static struct list_head inetsw6[SOCK_MAX];
83 static DEFINE_SPINLOCK(inetsw6_lock);
84
85 struct ipv6_params ipv6_defaults = {
86 .disable_ipv6 = 0,
87 .autoconf = 1,
88 };
89
90 static int disable_ipv6_mod;
91
92 module_param_named(disable, disable_ipv6_mod, int, 0444);
93 MODULE_PARM_DESC(disable, "Disable IPv6 module such that it is non-functional");
94
95 module_param_named(disable_ipv6, ipv6_defaults.disable_ipv6, int, 0444);
96 MODULE_PARM_DESC(disable_ipv6, "Disable IPv6 on all interfaces");
97
98 module_param_named(autoconf, ipv6_defaults.autoconf, int, 0444);
99 MODULE_PARM_DESC(autoconf, "Enable IPv6 address autoconfiguration on all interfaces");
100
ipv6_mod_enabled(void)101 bool ipv6_mod_enabled(void)
102 {
103 return disable_ipv6_mod == 0;
104 }
105 EXPORT_SYMBOL_GPL(ipv6_mod_enabled);
106
inet6_sk_generic(struct sock * sk)107 static struct ipv6_pinfo *inet6_sk_generic(struct sock *sk)
108 {
109 const int offset = sk->sk_prot->ipv6_pinfo_offset;
110
111 return (struct ipv6_pinfo *)(((u8 *)sk) + offset);
112 }
113
inet6_sock_destruct(struct sock * sk)114 void inet6_sock_destruct(struct sock *sk)
115 {
116 inet6_cleanup_sock(sk);
117 inet_sock_destruct(sk);
118 }
119 EXPORT_SYMBOL_GPL(inet6_sock_destruct);
120
inet6_create(struct net * net,struct socket * sock,int protocol,int kern)121 static int inet6_create(struct net *net, struct socket *sock, int protocol,
122 int kern)
123 {
124 struct inet_sock *inet;
125 struct ipv6_pinfo *np;
126 struct sock *sk = NULL;
127 struct inet_protosw *answer;
128 struct proto *answer_prot;
129 unsigned char answer_flags;
130 int try_loading_module = 0;
131 int err;
132
133 if (protocol < 0 || protocol >= IPPROTO_MAX)
134 return -EINVAL;
135
136 /* Look for the requested type/protocol pair. */
137 lookup_protocol:
138 err = -ESOCKTNOSUPPORT;
139 rcu_read_lock();
140 list_for_each_entry_rcu(answer, &inetsw6[sock->type], list) {
141
142 err = 0;
143 /* Check the non-wild match. */
144 if (protocol == answer->protocol) {
145 if (protocol != IPPROTO_IP)
146 break;
147 } else {
148 /* Check for the two wild cases. */
149 if (IPPROTO_IP == protocol) {
150 protocol = answer->protocol;
151 break;
152 }
153 if (IPPROTO_IP == answer->protocol)
154 break;
155 }
156 err = -EPROTONOSUPPORT;
157 }
158
159 if (err) {
160 if (try_loading_module < 2) {
161 rcu_read_unlock();
162 /*
163 * Be more specific, e.g. net-pf-10-proto-132-type-1
164 * (net-pf-PF_INET6-proto-IPPROTO_SCTP-type-SOCK_STREAM)
165 */
166 if (++try_loading_module == 1)
167 request_module("net-pf-%d-proto-%d-type-%d",
168 PF_INET6, protocol, sock->type);
169 /*
170 * Fall back to generic, e.g. net-pf-10-proto-132
171 * (net-pf-PF_INET6-proto-IPPROTO_SCTP)
172 */
173 else
174 request_module("net-pf-%d-proto-%d",
175 PF_INET6, protocol);
176 goto lookup_protocol;
177 } else
178 goto out_rcu_unlock;
179 }
180
181 err = -EPERM;
182 if (sock->type == SOCK_RAW && !kern &&
183 !ns_capable(net->user_ns, CAP_NET_RAW))
184 goto out_rcu_unlock;
185
186 sock->ops = answer->ops;
187 answer_prot = answer->prot;
188 answer_flags = answer->flags;
189 rcu_read_unlock();
190
191 WARN_ON(!answer_prot->slab);
192
193 err = -ENOBUFS;
194 sk = sk_alloc(net, PF_INET6, GFP_KERNEL, answer_prot, kern);
195 if (!sk)
196 goto out;
197
198 sock_init_data(sock, sk);
199
200 err = 0;
201 if (INET_PROTOSW_REUSE & answer_flags)
202 sk->sk_reuse = SK_CAN_REUSE;
203
204 if (INET_PROTOSW_ICSK & answer_flags)
205 inet_init_csk_locks(sk);
206
207 inet = inet_sk(sk);
208 inet_assign_bit(IS_ICSK, sk, INET_PROTOSW_ICSK & answer_flags);
209
210 if (SOCK_RAW == sock->type) {
211 inet->inet_num = protocol;
212 if (IPPROTO_RAW == protocol)
213 inet_set_bit(HDRINCL, sk);
214 }
215
216 sk->sk_destruct = inet6_sock_destruct;
217 sk->sk_family = PF_INET6;
218 sk->sk_protocol = protocol;
219
220 sk->sk_backlog_rcv = answer->prot->backlog_rcv;
221
222 inet_sk(sk)->pinet6 = np = inet6_sk_generic(sk);
223 np->hop_limit = -1;
224 np->mcast_hops = IPV6_DEFAULT_MCASTHOPS;
225 np->mc_loop = 1;
226 np->mc_all = 1;
227 np->pmtudisc = IPV6_PMTUDISC_WANT;
228 np->repflow = net->ipv6.sysctl.flowlabel_reflect & FLOWLABEL_REFLECT_ESTABLISHED;
229 sk->sk_ipv6only = net->ipv6.sysctl.bindv6only;
230 sk->sk_txrehash = READ_ONCE(net->core.sysctl_txrehash);
231
232 /* Init the ipv4 part of the socket since we can have sockets
233 * using v6 API for ipv4.
234 */
235 inet->uc_ttl = -1;
236
237 inet_set_bit(MC_LOOP, sk);
238 inet->mc_ttl = 1;
239 inet->mc_index = 0;
240 RCU_INIT_POINTER(inet->mc_list, NULL);
241 inet->rcv_tos = 0;
242
243 if (READ_ONCE(net->ipv4.sysctl_ip_no_pmtu_disc))
244 inet->pmtudisc = IP_PMTUDISC_DONT;
245 else
246 inet->pmtudisc = IP_PMTUDISC_WANT;
247
248 if (inet->inet_num) {
249 /* It assumes that any protocol which allows
250 * the user to assign a number at socket
251 * creation time automatically shares.
252 */
253 inet->inet_sport = htons(inet->inet_num);
254 err = sk->sk_prot->hash(sk);
255 if (err) {
256 sk_common_release(sk);
257 goto out;
258 }
259 }
260 if (sk->sk_prot->init) {
261 err = sk->sk_prot->init(sk);
262 if (err) {
263 sk_common_release(sk);
264 goto out;
265 }
266 }
267
268 if (!kern) {
269 err = BPF_CGROUP_RUN_PROG_INET_SOCK(sk);
270 if (err) {
271 sk_common_release(sk);
272 goto out;
273 }
274 }
275
276 trace_android_rvh_inet_sock_create(sk);
277
278 out:
279 trace_android_vh_inet_create(sk, err);
280 return err;
281 out_rcu_unlock:
282 rcu_read_unlock();
283 goto out;
284 }
285
__inet6_bind(struct sock * sk,struct sockaddr * uaddr,int addr_len,u32 flags)286 static int __inet6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len,
287 u32 flags)
288 {
289 struct sockaddr_in6 *addr = (struct sockaddr_in6 *)uaddr;
290 struct inet_sock *inet = inet_sk(sk);
291 struct ipv6_pinfo *np = inet6_sk(sk);
292 struct net *net = sock_net(sk);
293 __be32 v4addr = 0;
294 unsigned short snum;
295 bool saved_ipv6only;
296 int addr_type = 0;
297 int err = 0;
298
299 if (addr->sin6_family != AF_INET6)
300 return -EAFNOSUPPORT;
301
302 addr_type = ipv6_addr_type(&addr->sin6_addr);
303 if ((addr_type & IPV6_ADDR_MULTICAST) && sk->sk_type == SOCK_STREAM)
304 return -EINVAL;
305
306 snum = ntohs(addr->sin6_port);
307 if (!(flags & BIND_NO_CAP_NET_BIND_SERVICE) &&
308 snum && inet_port_requires_bind_service(net, snum) &&
309 !ns_capable(net->user_ns, CAP_NET_BIND_SERVICE))
310 return -EACCES;
311
312 if (flags & BIND_WITH_LOCK)
313 lock_sock(sk);
314
315 /* Check these errors (active socket, double bind). */
316 if (sk->sk_state != TCP_CLOSE || inet->inet_num) {
317 err = -EINVAL;
318 goto out;
319 }
320
321 /* Check if the address belongs to the host. */
322 if (addr_type == IPV6_ADDR_MAPPED) {
323 struct net_device *dev = NULL;
324 int chk_addr_ret;
325
326 /* Binding to v4-mapped address on a v6-only socket
327 * makes no sense
328 */
329 if (ipv6_only_sock(sk)) {
330 err = -EINVAL;
331 goto out;
332 }
333
334 rcu_read_lock();
335 if (sk->sk_bound_dev_if) {
336 dev = dev_get_by_index_rcu(net, sk->sk_bound_dev_if);
337 if (!dev) {
338 err = -ENODEV;
339 goto out_unlock;
340 }
341 }
342
343 /* Reproduce AF_INET checks to make the bindings consistent */
344 v4addr = addr->sin6_addr.s6_addr32[3];
345 chk_addr_ret = inet_addr_type_dev_table(net, dev, v4addr);
346 rcu_read_unlock();
347
348 if (!inet_addr_valid_or_nonlocal(net, inet, v4addr,
349 chk_addr_ret)) {
350 err = -EADDRNOTAVAIL;
351 goto out;
352 }
353 } else {
354 if (addr_type != IPV6_ADDR_ANY) {
355 struct net_device *dev = NULL;
356
357 rcu_read_lock();
358 if (__ipv6_addr_needs_scope_id(addr_type)) {
359 if (addr_len >= sizeof(struct sockaddr_in6) &&
360 addr->sin6_scope_id) {
361 /* Override any existing binding, if another one
362 * is supplied by user.
363 */
364 sk->sk_bound_dev_if = addr->sin6_scope_id;
365 }
366
367 /* Binding to link-local address requires an interface */
368 if (!sk->sk_bound_dev_if) {
369 err = -EINVAL;
370 goto out_unlock;
371 }
372 }
373
374 if (sk->sk_bound_dev_if) {
375 dev = dev_get_by_index_rcu(net, sk->sk_bound_dev_if);
376 if (!dev) {
377 err = -ENODEV;
378 goto out_unlock;
379 }
380 }
381
382 /* ipv4 addr of the socket is invalid. Only the
383 * unspecified and mapped address have a v4 equivalent.
384 */
385 v4addr = LOOPBACK4_IPV6;
386 if (!(addr_type & IPV6_ADDR_MULTICAST)) {
387 if (!ipv6_can_nonlocal_bind(net, inet) &&
388 !ipv6_chk_addr(net, &addr->sin6_addr,
389 dev, 0)) {
390 err = -EADDRNOTAVAIL;
391 goto out_unlock;
392 }
393 }
394 rcu_read_unlock();
395 }
396 }
397
398 inet->inet_rcv_saddr = v4addr;
399 inet->inet_saddr = v4addr;
400
401 sk->sk_v6_rcv_saddr = addr->sin6_addr;
402
403 if (!(addr_type & IPV6_ADDR_MULTICAST))
404 np->saddr = addr->sin6_addr;
405
406 saved_ipv6only = sk->sk_ipv6only;
407 if (addr_type != IPV6_ADDR_ANY && addr_type != IPV6_ADDR_MAPPED)
408 sk->sk_ipv6only = 1;
409
410 /* Make sure we are allowed to bind here. */
411 if (snum || !(inet_test_bit(BIND_ADDRESS_NO_PORT, sk) ||
412 (flags & BIND_FORCE_ADDRESS_NO_PORT))) {
413 err = sk->sk_prot->get_port(sk, snum);
414 if (err) {
415 sk->sk_ipv6only = saved_ipv6only;
416 inet_reset_saddr(sk);
417 goto out;
418 }
419 if (!(flags & BIND_FROM_BPF)) {
420 err = BPF_CGROUP_RUN_PROG_INET6_POST_BIND(sk);
421 if (err) {
422 sk->sk_ipv6only = saved_ipv6only;
423 inet_reset_saddr(sk);
424 if (sk->sk_prot->put_port)
425 sk->sk_prot->put_port(sk);
426 goto out;
427 }
428 }
429 }
430
431 if (addr_type != IPV6_ADDR_ANY)
432 sk->sk_userlocks |= SOCK_BINDADDR_LOCK;
433 if (snum)
434 sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
435 inet->inet_sport = htons(inet->inet_num);
436 inet->inet_dport = 0;
437 inet->inet_daddr = 0;
438 out:
439 if (flags & BIND_WITH_LOCK)
440 release_sock(sk);
441 return err;
442 out_unlock:
443 rcu_read_unlock();
444 goto out;
445 }
446
inet6_bind_sk(struct sock * sk,struct sockaddr * uaddr,int addr_len)447 int inet6_bind_sk(struct sock *sk, struct sockaddr *uaddr, int addr_len)
448 {
449 u32 flags = BIND_WITH_LOCK;
450 const struct proto *prot;
451 int err = 0;
452
453 /* IPV6_ADDRFORM can change sk->sk_prot under us. */
454 prot = READ_ONCE(sk->sk_prot);
455 /* If the socket has its own bind function then use it. */
456 if (prot->bind)
457 return prot->bind(sk, uaddr, addr_len);
458
459 if (addr_len < SIN6_LEN_RFC2133)
460 return -EINVAL;
461
462 /* BPF prog is run before any checks are done so that if the prog
463 * changes context in a wrong way it will be caught.
464 */
465 err = BPF_CGROUP_RUN_PROG_INET_BIND_LOCK(sk, uaddr, &addr_len,
466 CGROUP_INET6_BIND, &flags);
467 if (err)
468 return err;
469
470 return __inet6_bind(sk, uaddr, addr_len, flags);
471 }
472
473 /* bind for INET6 API */
inet6_bind(struct socket * sock,struct sockaddr * uaddr,int addr_len)474 int inet6_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
475 {
476 return inet6_bind_sk(sock->sk, uaddr, addr_len);
477 }
478 EXPORT_SYMBOL(inet6_bind);
479
inet6_release(struct socket * sock)480 int inet6_release(struct socket *sock)
481 {
482 struct sock *sk = sock->sk;
483
484 if (!sk)
485 return -EINVAL;
486
487 /* Free mc lists */
488 ipv6_sock_mc_close(sk);
489
490 /* Free ac lists */
491 ipv6_sock_ac_close(sk);
492
493 return inet_release(sock);
494 }
495 EXPORT_SYMBOL(inet6_release);
496
inet6_cleanup_sock(struct sock * sk)497 void inet6_cleanup_sock(struct sock *sk)
498 {
499 struct ipv6_pinfo *np = inet6_sk(sk);
500 struct sk_buff *skb;
501 struct ipv6_txoptions *opt;
502
503 /* Release rx options */
504
505 skb = xchg(&np->pktoptions, NULL);
506 kfree_skb(skb);
507
508 skb = xchg(&np->rxpmtu, NULL);
509 kfree_skb(skb);
510
511 /* Free flowlabels */
512 fl6_free_socklist(sk);
513
514 /* Free tx options */
515
516 opt = xchg((__force struct ipv6_txoptions **)&np->opt, NULL);
517 if (opt) {
518 atomic_sub(opt->tot_len, &sk->sk_omem_alloc);
519 txopt_put(opt);
520 }
521 }
522 EXPORT_SYMBOL_GPL(inet6_cleanup_sock);
523
524 /*
525 * This does both peername and sockname.
526 */
inet6_getname(struct socket * sock,struct sockaddr * uaddr,int peer)527 int inet6_getname(struct socket *sock, struct sockaddr *uaddr,
528 int peer)
529 {
530 struct sockaddr_in6 *sin = (struct sockaddr_in6 *)uaddr;
531 int sin_addr_len = sizeof(*sin);
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, &sin_addr_len,
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, &sin_addr_len,
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 sin_addr_len;
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 sk_ioctl(sk, cmd, (void __user *)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 .splice_eof = inet_splice_eof,
713 .sendmsg_locked = tcp_sendmsg_locked,
714 .splice_read = tcp_splice_read,
715 .read_sock = tcp_read_sock,
716 .read_skb = tcp_read_skb,
717 .peek_len = tcp_peek_len,
718 #ifdef CONFIG_COMPAT
719 .compat_ioctl = inet6_compat_ioctl,
720 #endif
721 .set_rcvlowat = tcp_set_rcvlowat,
722 };
723
724 const struct proto_ops inet6_dgram_ops = {
725 .family = PF_INET6,
726 .owner = THIS_MODULE,
727 .release = inet6_release,
728 .bind = inet6_bind,
729 .connect = inet_dgram_connect, /* ok */
730 .socketpair = sock_no_socketpair, /* a do nothing */
731 .accept = sock_no_accept, /* a do nothing */
732 .getname = inet6_getname,
733 .poll = udp_poll, /* ok */
734 .ioctl = inet6_ioctl, /* must change */
735 .gettstamp = sock_gettstamp,
736 .listen = sock_no_listen, /* ok */
737 .shutdown = inet_shutdown, /* ok */
738 .setsockopt = sock_common_setsockopt, /* ok */
739 .getsockopt = sock_common_getsockopt, /* ok */
740 .sendmsg = inet6_sendmsg, /* retpoline's sake */
741 .recvmsg = inet6_recvmsg, /* retpoline's sake */
742 .read_skb = udp_read_skb,
743 .mmap = sock_no_mmap,
744 .set_peek_off = sk_set_peek_off,
745 #ifdef CONFIG_COMPAT
746 .compat_ioctl = inet6_compat_ioctl,
747 #endif
748 };
749
750 static const struct net_proto_family inet6_family_ops = {
751 .family = PF_INET6,
752 .create = inet6_create,
753 .owner = THIS_MODULE,
754 };
755
inet6_register_protosw(struct inet_protosw * p)756 int inet6_register_protosw(struct inet_protosw *p)
757 {
758 struct list_head *lh;
759 struct inet_protosw *answer;
760 struct list_head *last_perm;
761 int protocol = p->protocol;
762 int ret;
763
764 spin_lock_bh(&inetsw6_lock);
765
766 ret = -EINVAL;
767 if (p->type >= SOCK_MAX)
768 goto out_illegal;
769
770 /* If we are trying to override a permanent protocol, bail. */
771 answer = NULL;
772 ret = -EPERM;
773 last_perm = &inetsw6[p->type];
774 list_for_each(lh, &inetsw6[p->type]) {
775 answer = list_entry(lh, struct inet_protosw, list);
776
777 /* Check only the non-wild match. */
778 if (INET_PROTOSW_PERMANENT & answer->flags) {
779 if (protocol == answer->protocol)
780 break;
781 last_perm = lh;
782 }
783
784 answer = NULL;
785 }
786 if (answer)
787 goto out_permanent;
788
789 /* Add the new entry after the last permanent entry if any, so that
790 * the new entry does not override a permanent entry when matched with
791 * a wild-card protocol. But it is allowed to override any existing
792 * non-permanent entry. This means that when we remove this entry, the
793 * system automatically returns to the old behavior.
794 */
795 list_add_rcu(&p->list, last_perm);
796 ret = 0;
797 out:
798 spin_unlock_bh(&inetsw6_lock);
799 return ret;
800
801 out_permanent:
802 pr_err("Attempt to override permanent protocol %d\n", protocol);
803 goto out;
804
805 out_illegal:
806 pr_err("Ignoring attempt to register invalid socket type %d\n",
807 p->type);
808 goto out;
809 }
810 EXPORT_SYMBOL(inet6_register_protosw);
811
812 void
inet6_unregister_protosw(struct inet_protosw * p)813 inet6_unregister_protosw(struct inet_protosw *p)
814 {
815 if (INET_PROTOSW_PERMANENT & p->flags) {
816 pr_err("Attempt to unregister permanent protocol %d\n",
817 p->protocol);
818 } else {
819 spin_lock_bh(&inetsw6_lock);
820 list_del_rcu(&p->list);
821 spin_unlock_bh(&inetsw6_lock);
822
823 synchronize_net();
824 }
825 }
826 EXPORT_SYMBOL(inet6_unregister_protosw);
827
inet6_sk_rebuild_header(struct sock * sk)828 int inet6_sk_rebuild_header(struct sock *sk)
829 {
830 struct ipv6_pinfo *np = inet6_sk(sk);
831 struct dst_entry *dst;
832
833 dst = __sk_dst_check(sk, np->dst_cookie);
834
835 if (!dst) {
836 struct inet_sock *inet = inet_sk(sk);
837 struct in6_addr *final_p, final;
838 struct flowi6 fl6;
839
840 memset(&fl6, 0, sizeof(fl6));
841 fl6.flowi6_proto = sk->sk_protocol;
842 fl6.daddr = sk->sk_v6_daddr;
843 fl6.saddr = np->saddr;
844 fl6.flowlabel = np->flow_label;
845 fl6.flowi6_oif = sk->sk_bound_dev_if;
846 fl6.flowi6_mark = sk->sk_mark;
847 fl6.fl6_dport = inet->inet_dport;
848 fl6.fl6_sport = inet->inet_sport;
849 fl6.flowi6_uid = sk->sk_uid;
850 security_sk_classify_flow(sk, flowi6_to_flowi_common(&fl6));
851
852 rcu_read_lock();
853 final_p = fl6_update_dst(&fl6, rcu_dereference(np->opt),
854 &final);
855 rcu_read_unlock();
856
857 dst = ip6_dst_lookup_flow(sock_net(sk), sk, &fl6, final_p);
858 if (IS_ERR(dst)) {
859 sk->sk_route_caps = 0;
860 WRITE_ONCE(sk->sk_err_soft, -PTR_ERR(dst));
861 return PTR_ERR(dst);
862 }
863
864 ip6_dst_store(sk, dst, NULL, NULL);
865 }
866
867 return 0;
868 }
869 EXPORT_SYMBOL_GPL(inet6_sk_rebuild_header);
870
ipv6_opt_accepted(const struct sock * sk,const struct sk_buff * skb,const struct inet6_skb_parm * opt)871 bool ipv6_opt_accepted(const struct sock *sk, const struct sk_buff *skb,
872 const struct inet6_skb_parm *opt)
873 {
874 const struct ipv6_pinfo *np = inet6_sk(sk);
875
876 if (np->rxopt.all) {
877 if (((opt->flags & IP6SKB_HOPBYHOP) &&
878 (np->rxopt.bits.hopopts || np->rxopt.bits.ohopopts)) ||
879 (ip6_flowinfo((struct ipv6hdr *) skb_network_header(skb)) &&
880 np->rxopt.bits.rxflow) ||
881 (opt->srcrt && (np->rxopt.bits.srcrt ||
882 np->rxopt.bits.osrcrt)) ||
883 ((opt->dst1 || opt->dst0) &&
884 (np->rxopt.bits.dstopts || np->rxopt.bits.odstopts)))
885 return true;
886 }
887 return false;
888 }
889 EXPORT_SYMBOL_GPL(ipv6_opt_accepted);
890
891 static struct packet_type ipv6_packet_type __read_mostly = {
892 .type = cpu_to_be16(ETH_P_IPV6),
893 .func = ipv6_rcv,
894 .list_func = ipv6_list_rcv,
895 };
896
ipv6_packet_init(void)897 static int __init ipv6_packet_init(void)
898 {
899 dev_add_pack(&ipv6_packet_type);
900 return 0;
901 }
902
ipv6_packet_cleanup(void)903 static void ipv6_packet_cleanup(void)
904 {
905 dev_remove_pack(&ipv6_packet_type);
906 }
907
ipv6_init_mibs(struct net * net)908 static int __net_init ipv6_init_mibs(struct net *net)
909 {
910 int i;
911
912 net->mib.udp_stats_in6 = alloc_percpu(struct udp_mib);
913 if (!net->mib.udp_stats_in6)
914 return -ENOMEM;
915 net->mib.udplite_stats_in6 = alloc_percpu(struct udp_mib);
916 if (!net->mib.udplite_stats_in6)
917 goto err_udplite_mib;
918 net->mib.ipv6_statistics = alloc_percpu(struct ipstats_mib);
919 if (!net->mib.ipv6_statistics)
920 goto err_ip_mib;
921
922 for_each_possible_cpu(i) {
923 struct ipstats_mib *af_inet6_stats;
924 af_inet6_stats = per_cpu_ptr(net->mib.ipv6_statistics, i);
925 u64_stats_init(&af_inet6_stats->syncp);
926 }
927
928
929 net->mib.icmpv6_statistics = alloc_percpu(struct icmpv6_mib);
930 if (!net->mib.icmpv6_statistics)
931 goto err_icmp_mib;
932 net->mib.icmpv6msg_statistics = kzalloc(sizeof(struct icmpv6msg_mib),
933 GFP_KERNEL);
934 if (!net->mib.icmpv6msg_statistics)
935 goto err_icmpmsg_mib;
936 return 0;
937
938 err_icmpmsg_mib:
939 free_percpu(net->mib.icmpv6_statistics);
940 err_icmp_mib:
941 free_percpu(net->mib.ipv6_statistics);
942 err_ip_mib:
943 free_percpu(net->mib.udplite_stats_in6);
944 err_udplite_mib:
945 free_percpu(net->mib.udp_stats_in6);
946 return -ENOMEM;
947 }
948
ipv6_cleanup_mibs(struct net * net)949 static void ipv6_cleanup_mibs(struct net *net)
950 {
951 free_percpu(net->mib.udp_stats_in6);
952 free_percpu(net->mib.udplite_stats_in6);
953 free_percpu(net->mib.ipv6_statistics);
954 free_percpu(net->mib.icmpv6_statistics);
955 kfree(net->mib.icmpv6msg_statistics);
956 }
957
inet6_net_init(struct net * net)958 static int __net_init inet6_net_init(struct net *net)
959 {
960 int err = 0;
961
962 net->ipv6.sysctl.bindv6only = 0;
963 net->ipv6.sysctl.icmpv6_time = 1*HZ;
964 net->ipv6.sysctl.icmpv6_echo_ignore_all = 0;
965 net->ipv6.sysctl.icmpv6_echo_ignore_multicast = 0;
966 net->ipv6.sysctl.icmpv6_echo_ignore_anycast = 0;
967 net->ipv6.sysctl.icmpv6_error_anycast_as_unicast = 0;
968
969 /* By default, rate limit error messages.
970 * Except for pmtu discovery, it would break it.
971 * proc_do_large_bitmap needs pointer to the bitmap.
972 */
973 bitmap_set(net->ipv6.sysctl.icmpv6_ratemask, 0, ICMPV6_ERRMSG_MAX + 1);
974 bitmap_clear(net->ipv6.sysctl.icmpv6_ratemask, ICMPV6_PKT_TOOBIG, 1);
975 net->ipv6.sysctl.icmpv6_ratemask_ptr = net->ipv6.sysctl.icmpv6_ratemask;
976
977 net->ipv6.sysctl.flowlabel_consistency = 1;
978 net->ipv6.sysctl.auto_flowlabels = IP6_DEFAULT_AUTO_FLOW_LABELS;
979 net->ipv6.sysctl.idgen_retries = 3;
980 net->ipv6.sysctl.idgen_delay = 1 * HZ;
981 net->ipv6.sysctl.flowlabel_state_ranges = 0;
982 net->ipv6.sysctl.max_dst_opts_cnt = IP6_DEFAULT_MAX_DST_OPTS_CNT;
983 net->ipv6.sysctl.max_hbh_opts_cnt = IP6_DEFAULT_MAX_HBH_OPTS_CNT;
984 net->ipv6.sysctl.max_dst_opts_len = IP6_DEFAULT_MAX_DST_OPTS_LEN;
985 net->ipv6.sysctl.max_hbh_opts_len = IP6_DEFAULT_MAX_HBH_OPTS_LEN;
986 net->ipv6.sysctl.fib_notify_on_flag_change = 0;
987 atomic_set(&net->ipv6.fib6_sernum, 1);
988
989 net->ipv6.sysctl.ioam6_id = IOAM6_DEFAULT_ID;
990 net->ipv6.sysctl.ioam6_id_wide = IOAM6_DEFAULT_ID_WIDE;
991
992 err = ipv6_init_mibs(net);
993 if (err)
994 return err;
995 #ifdef CONFIG_PROC_FS
996 err = udp6_proc_init(net);
997 if (err)
998 goto out;
999 err = tcp6_proc_init(net);
1000 if (err)
1001 goto proc_tcp6_fail;
1002 err = ac6_proc_init(net);
1003 if (err)
1004 goto proc_ac6_fail;
1005 #endif
1006 return err;
1007
1008 #ifdef CONFIG_PROC_FS
1009 proc_ac6_fail:
1010 tcp6_proc_exit(net);
1011 proc_tcp6_fail:
1012 udp6_proc_exit(net);
1013 out:
1014 ipv6_cleanup_mibs(net);
1015 return err;
1016 #endif
1017 }
1018
inet6_net_exit(struct net * net)1019 static void __net_exit inet6_net_exit(struct net *net)
1020 {
1021 #ifdef CONFIG_PROC_FS
1022 udp6_proc_exit(net);
1023 tcp6_proc_exit(net);
1024 ac6_proc_exit(net);
1025 #endif
1026 ipv6_cleanup_mibs(net);
1027 }
1028
1029 static struct pernet_operations inet6_net_ops = {
1030 .init = inet6_net_init,
1031 .exit = inet6_net_exit,
1032 };
1033
ipv6_route_input(struct sk_buff * skb)1034 static int ipv6_route_input(struct sk_buff *skb)
1035 {
1036 ip6_route_input(skb);
1037 return skb_dst(skb)->error;
1038 }
1039
1040 static const struct ipv6_stub ipv6_stub_impl = {
1041 .ipv6_sock_mc_join = ipv6_sock_mc_join,
1042 .ipv6_sock_mc_drop = ipv6_sock_mc_drop,
1043 .ipv6_dst_lookup_flow = ip6_dst_lookup_flow,
1044 .ipv6_route_input = ipv6_route_input,
1045 .fib6_get_table = fib6_get_table,
1046 .fib6_table_lookup = fib6_table_lookup,
1047 .fib6_lookup = fib6_lookup,
1048 .fib6_select_path = fib6_select_path,
1049 .ip6_mtu_from_fib6 = ip6_mtu_from_fib6,
1050 .fib6_nh_init = fib6_nh_init,
1051 .fib6_nh_release = fib6_nh_release,
1052 .fib6_nh_release_dsts = fib6_nh_release_dsts,
1053 .fib6_update_sernum = fib6_update_sernum_stub,
1054 .fib6_rt_update = fib6_rt_update,
1055 .ip6_del_rt = ip6_del_rt,
1056 .udpv6_encap_enable = udpv6_encap_enable,
1057 .ndisc_send_na = ndisc_send_na,
1058 #if IS_ENABLED(CONFIG_XFRM)
1059 .xfrm6_local_rxpmtu = xfrm6_local_rxpmtu,
1060 .xfrm6_udp_encap_rcv = xfrm6_udp_encap_rcv,
1061 .xfrm6_rcv_encap = xfrm6_rcv_encap,
1062 #endif
1063 .nd_tbl = &nd_tbl,
1064 .ipv6_fragment = ip6_fragment,
1065 .ipv6_dev_find = ipv6_dev_find,
1066 };
1067
1068 static const struct ipv6_bpf_stub ipv6_bpf_stub_impl = {
1069 .inet6_bind = __inet6_bind,
1070 .udp6_lib_lookup = __udp6_lib_lookup,
1071 .ipv6_setsockopt = do_ipv6_setsockopt,
1072 .ipv6_getsockopt = do_ipv6_getsockopt,
1073 .ipv6_dev_get_saddr = ipv6_dev_get_saddr,
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