1 /*
2 * IPv6 BSD socket options interface
3 * Linux INET6 implementation
4 *
5 * Authors:
6 * Pedro Roque <roque@di.fc.ul.pt>
7 *
8 * Based on linux/net/ipv4/ip_sockglue.c
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
14 *
15 * FIXME: Make the setsockopt code POSIX compliant: That is
16 *
17 * o Truncate getsockopt returns
18 * o Return an optlen of the truncated length if need be
19 *
20 * Changes:
21 * David L Stevens <dlstevens@us.ibm.com>:
22 * - added multicast source filtering API for MLDv2
23 */
24
25 #include <linux/module.h>
26 #include <linux/capability.h>
27 #include <linux/errno.h>
28 #include <linux/types.h>
29 #include <linux/socket.h>
30 #include <linux/sockios.h>
31 #include <linux/net.h>
32 #include <linux/in6.h>
33 #include <linux/mroute6.h>
34 #include <linux/netdevice.h>
35 #include <linux/if_arp.h>
36 #include <linux/init.h>
37 #include <linux/sysctl.h>
38 #include <linux/netfilter.h>
39 #include <linux/slab.h>
40
41 #include <net/sock.h>
42 #include <net/snmp.h>
43 #include <net/ipv6.h>
44 #include <net/ndisc.h>
45 #include <net/protocol.h>
46 #include <net/transp_v6.h>
47 #include <net/ip6_route.h>
48 #include <net/addrconf.h>
49 #include <net/inet_common.h>
50 #include <net/tcp.h>
51 #include <net/udp.h>
52 #include <net/udplite.h>
53 #include <net/xfrm.h>
54 #include <net/compat.h>
55 #include <net/seg6.h>
56
57 #include <linux/uaccess.h>
58
59 struct ip6_ra_chain *ip6_ra_chain;
60 DEFINE_RWLOCK(ip6_ra_lock);
61
ip6_ra_control(struct sock * sk,int sel)62 int ip6_ra_control(struct sock *sk, int sel)
63 {
64 struct ip6_ra_chain *ra, *new_ra, **rap;
65
66 /* RA packet may be delivered ONLY to IPPROTO_RAW socket */
67 if (sk->sk_type != SOCK_RAW || inet_sk(sk)->inet_num != IPPROTO_RAW)
68 return -ENOPROTOOPT;
69
70 new_ra = (sel >= 0) ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
71
72 write_lock_bh(&ip6_ra_lock);
73 for (rap = &ip6_ra_chain; (ra = *rap) != NULL; rap = &ra->next) {
74 if (ra->sk == sk) {
75 if (sel >= 0) {
76 write_unlock_bh(&ip6_ra_lock);
77 kfree(new_ra);
78 return -EADDRINUSE;
79 }
80
81 *rap = ra->next;
82 write_unlock_bh(&ip6_ra_lock);
83
84 sock_put(sk);
85 kfree(ra);
86 return 0;
87 }
88 }
89 if (!new_ra) {
90 write_unlock_bh(&ip6_ra_lock);
91 return -ENOBUFS;
92 }
93 new_ra->sk = sk;
94 new_ra->sel = sel;
95 new_ra->next = ra;
96 *rap = new_ra;
97 sock_hold(sk);
98 write_unlock_bh(&ip6_ra_lock);
99 return 0;
100 }
101
ipv6_update_options(struct sock * sk,struct ipv6_txoptions * opt)102 struct ipv6_txoptions *ipv6_update_options(struct sock *sk,
103 struct ipv6_txoptions *opt)
104 {
105 if (inet_sk(sk)->is_icsk) {
106 if (opt &&
107 !((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE)) &&
108 inet_sk(sk)->inet_daddr != LOOPBACK4_IPV6) {
109 struct inet_connection_sock *icsk = inet_csk(sk);
110 icsk->icsk_ext_hdr_len = opt->opt_flen + opt->opt_nflen;
111 icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie);
112 }
113 }
114 opt = xchg((__force struct ipv6_txoptions **)&inet6_sk(sk)->opt,
115 opt);
116 sk_dst_reset(sk);
117
118 return opt;
119 }
120
setsockopt_needs_rtnl(int optname)121 static bool setsockopt_needs_rtnl(int optname)
122 {
123 switch (optname) {
124 case IPV6_ADDRFORM:
125 case IPV6_ADD_MEMBERSHIP:
126 case IPV6_DROP_MEMBERSHIP:
127 case IPV6_JOIN_ANYCAST:
128 case IPV6_LEAVE_ANYCAST:
129 case MCAST_JOIN_GROUP:
130 case MCAST_LEAVE_GROUP:
131 case MCAST_JOIN_SOURCE_GROUP:
132 case MCAST_LEAVE_SOURCE_GROUP:
133 case MCAST_BLOCK_SOURCE:
134 case MCAST_UNBLOCK_SOURCE:
135 case MCAST_MSFILTER:
136 return true;
137 }
138 return false;
139 }
140
do_ipv6_setsockopt(struct sock * sk,int level,int optname,char __user * optval,unsigned int optlen)141 static int do_ipv6_setsockopt(struct sock *sk, int level, int optname,
142 char __user *optval, unsigned int optlen)
143 {
144 struct ipv6_pinfo *np = inet6_sk(sk);
145 struct net *net = sock_net(sk);
146 int val, valbool;
147 int retv = -ENOPROTOOPT;
148 bool needs_rtnl = setsockopt_needs_rtnl(optname);
149
150 if (!optval)
151 val = 0;
152 else {
153 if (optlen >= sizeof(int)) {
154 if (get_user(val, (int __user *) optval))
155 return -EFAULT;
156 } else
157 val = 0;
158 }
159
160 valbool = (val != 0);
161
162 if (ip6_mroute_opt(optname))
163 return ip6_mroute_setsockopt(sk, optname, optval, optlen);
164
165 if (needs_rtnl)
166 rtnl_lock();
167 lock_sock(sk);
168
169 switch (optname) {
170
171 case IPV6_ADDRFORM:
172 if (optlen < sizeof(int))
173 goto e_inval;
174 if (val == PF_INET) {
175 struct ipv6_txoptions *opt;
176 struct sk_buff *pktopt;
177
178 if (sk->sk_type == SOCK_RAW)
179 break;
180
181 if (sk->sk_protocol == IPPROTO_UDP ||
182 sk->sk_protocol == IPPROTO_UDPLITE) {
183 struct udp_sock *up = udp_sk(sk);
184 if (up->pending == AF_INET6) {
185 retv = -EBUSY;
186 break;
187 }
188 } else if (sk->sk_protocol == IPPROTO_TCP) {
189 if (sk->sk_prot != &tcpv6_prot) {
190 retv = -EBUSY;
191 break;
192 }
193 break;
194 } else {
195 break;
196 }
197 if (sk->sk_state != TCP_ESTABLISHED) {
198 retv = -ENOTCONN;
199 break;
200 }
201
202 if (ipv6_only_sock(sk) ||
203 !ipv6_addr_v4mapped(&sk->sk_v6_daddr)) {
204 retv = -EADDRNOTAVAIL;
205 break;
206 }
207
208 fl6_free_socklist(sk);
209 __ipv6_sock_mc_close(sk);
210
211 /*
212 * Sock is moving from IPv6 to IPv4 (sk_prot), so
213 * remove it from the refcnt debug socks count in the
214 * original family...
215 */
216 sk_refcnt_debug_dec(sk);
217
218 if (sk->sk_protocol == IPPROTO_TCP) {
219 struct inet_connection_sock *icsk = inet_csk(sk);
220 local_bh_disable();
221 sock_prot_inuse_add(net, sk->sk_prot, -1);
222 sock_prot_inuse_add(net, &tcp_prot, 1);
223 local_bh_enable();
224 sk->sk_prot = &tcp_prot;
225 icsk->icsk_af_ops = &ipv4_specific;
226 sk->sk_socket->ops = &inet_stream_ops;
227 sk->sk_family = PF_INET;
228 tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
229 } else {
230 struct proto *prot = &udp_prot;
231
232 if (sk->sk_protocol == IPPROTO_UDPLITE)
233 prot = &udplite_prot;
234 local_bh_disable();
235 sock_prot_inuse_add(net, sk->sk_prot, -1);
236 sock_prot_inuse_add(net, prot, 1);
237 local_bh_enable();
238 sk->sk_prot = prot;
239 sk->sk_socket->ops = &inet_dgram_ops;
240 sk->sk_family = PF_INET;
241 }
242 opt = xchg((__force struct ipv6_txoptions **)&np->opt,
243 NULL);
244 if (opt) {
245 atomic_sub(opt->tot_len, &sk->sk_omem_alloc);
246 txopt_put(opt);
247 }
248 pktopt = xchg(&np->pktoptions, NULL);
249 kfree_skb(pktopt);
250
251 /*
252 * ... and add it to the refcnt debug socks count
253 * in the new family. -acme
254 */
255 sk_refcnt_debug_inc(sk);
256 module_put(THIS_MODULE);
257 retv = 0;
258 break;
259 }
260 goto e_inval;
261
262 case IPV6_V6ONLY:
263 if (optlen < sizeof(int) ||
264 inet_sk(sk)->inet_num)
265 goto e_inval;
266 sk->sk_ipv6only = valbool;
267 retv = 0;
268 break;
269
270 case IPV6_RECVPKTINFO:
271 if (optlen < sizeof(int))
272 goto e_inval;
273 np->rxopt.bits.rxinfo = valbool;
274 retv = 0;
275 break;
276
277 case IPV6_2292PKTINFO:
278 if (optlen < sizeof(int))
279 goto e_inval;
280 np->rxopt.bits.rxoinfo = valbool;
281 retv = 0;
282 break;
283
284 case IPV6_RECVHOPLIMIT:
285 if (optlen < sizeof(int))
286 goto e_inval;
287 np->rxopt.bits.rxhlim = valbool;
288 retv = 0;
289 break;
290
291 case IPV6_2292HOPLIMIT:
292 if (optlen < sizeof(int))
293 goto e_inval;
294 np->rxopt.bits.rxohlim = valbool;
295 retv = 0;
296 break;
297
298 case IPV6_RECVRTHDR:
299 if (optlen < sizeof(int))
300 goto e_inval;
301 np->rxopt.bits.srcrt = valbool;
302 retv = 0;
303 break;
304
305 case IPV6_2292RTHDR:
306 if (optlen < sizeof(int))
307 goto e_inval;
308 np->rxopt.bits.osrcrt = valbool;
309 retv = 0;
310 break;
311
312 case IPV6_RECVHOPOPTS:
313 if (optlen < sizeof(int))
314 goto e_inval;
315 np->rxopt.bits.hopopts = valbool;
316 retv = 0;
317 break;
318
319 case IPV6_2292HOPOPTS:
320 if (optlen < sizeof(int))
321 goto e_inval;
322 np->rxopt.bits.ohopopts = valbool;
323 retv = 0;
324 break;
325
326 case IPV6_RECVDSTOPTS:
327 if (optlen < sizeof(int))
328 goto e_inval;
329 np->rxopt.bits.dstopts = valbool;
330 retv = 0;
331 break;
332
333 case IPV6_2292DSTOPTS:
334 if (optlen < sizeof(int))
335 goto e_inval;
336 np->rxopt.bits.odstopts = valbool;
337 retv = 0;
338 break;
339
340 case IPV6_TCLASS:
341 if (optlen < sizeof(int))
342 goto e_inval;
343 if (val < -1 || val > 0xff)
344 goto e_inval;
345 /* RFC 3542, 6.5: default traffic class of 0x0 */
346 if (val == -1)
347 val = 0;
348 np->tclass = val;
349 retv = 0;
350 break;
351
352 case IPV6_RECVTCLASS:
353 if (optlen < sizeof(int))
354 goto e_inval;
355 np->rxopt.bits.rxtclass = valbool;
356 retv = 0;
357 break;
358
359 case IPV6_FLOWINFO:
360 if (optlen < sizeof(int))
361 goto e_inval;
362 np->rxopt.bits.rxflow = valbool;
363 retv = 0;
364 break;
365
366 case IPV6_RECVPATHMTU:
367 if (optlen < sizeof(int))
368 goto e_inval;
369 np->rxopt.bits.rxpmtu = valbool;
370 retv = 0;
371 break;
372
373 case IPV6_TRANSPARENT:
374 if (valbool && !ns_capable(net->user_ns, CAP_NET_ADMIN) &&
375 !ns_capable(net->user_ns, CAP_NET_RAW)) {
376 retv = -EPERM;
377 break;
378 }
379 if (optlen < sizeof(int))
380 goto e_inval;
381 /* we don't have a separate transparent bit for IPV6 we use the one in the IPv4 socket */
382 inet_sk(sk)->transparent = valbool;
383 retv = 0;
384 break;
385
386 case IPV6_RECVORIGDSTADDR:
387 if (optlen < sizeof(int))
388 goto e_inval;
389 np->rxopt.bits.rxorigdstaddr = valbool;
390 retv = 0;
391 break;
392
393 case IPV6_HOPOPTS:
394 case IPV6_RTHDRDSTOPTS:
395 case IPV6_RTHDR:
396 case IPV6_DSTOPTS:
397 {
398 struct ipv6_txoptions *opt;
399 struct ipv6_opt_hdr *new = NULL;
400
401 /* hop-by-hop / destination options are privileged option */
402 retv = -EPERM;
403 if (optname != IPV6_RTHDR && !ns_capable(net->user_ns, CAP_NET_RAW))
404 break;
405
406 /* remove any sticky options header with a zero option
407 * length, per RFC3542.
408 */
409 if (optlen == 0)
410 optval = NULL;
411 else if (!optval)
412 goto e_inval;
413 else if (optlen < sizeof(struct ipv6_opt_hdr) ||
414 optlen & 0x7 || optlen > 8 * 255)
415 goto e_inval;
416 else {
417 new = memdup_user(optval, optlen);
418 if (IS_ERR(new)) {
419 retv = PTR_ERR(new);
420 break;
421 }
422 if (unlikely(ipv6_optlen(new) > optlen)) {
423 kfree(new);
424 goto e_inval;
425 }
426 }
427
428 opt = rcu_dereference_protected(np->opt,
429 lockdep_sock_is_held(sk));
430 opt = ipv6_renew_options(sk, opt, optname, new);
431 kfree(new);
432 if (IS_ERR(opt)) {
433 retv = PTR_ERR(opt);
434 break;
435 }
436
437 /* routing header option needs extra check */
438 retv = -EINVAL;
439 if (optname == IPV6_RTHDR && opt && opt->srcrt) {
440 struct ipv6_rt_hdr *rthdr = opt->srcrt;
441 switch (rthdr->type) {
442 #if IS_ENABLED(CONFIG_IPV6_MIP6)
443 case IPV6_SRCRT_TYPE_2:
444 if (rthdr->hdrlen != 2 ||
445 rthdr->segments_left != 1)
446 goto sticky_done;
447
448 break;
449 #endif
450 case IPV6_SRCRT_TYPE_4:
451 {
452 struct ipv6_sr_hdr *srh = (struct ipv6_sr_hdr *)
453 opt->srcrt;
454
455 if (!seg6_validate_srh(srh, optlen))
456 goto sticky_done;
457 break;
458 }
459 default:
460 goto sticky_done;
461 }
462 }
463
464 retv = 0;
465 opt = ipv6_update_options(sk, opt);
466 sticky_done:
467 if (opt) {
468 atomic_sub(opt->tot_len, &sk->sk_omem_alloc);
469 txopt_put(opt);
470 }
471 break;
472 }
473
474 case IPV6_PKTINFO:
475 {
476 struct in6_pktinfo pkt;
477
478 if (optlen == 0)
479 goto e_inval;
480 else if (optlen < sizeof(struct in6_pktinfo) || !optval)
481 goto e_inval;
482
483 if (copy_from_user(&pkt, optval, sizeof(struct in6_pktinfo))) {
484 retv = -EFAULT;
485 break;
486 }
487 if (sk->sk_bound_dev_if && pkt.ipi6_ifindex != sk->sk_bound_dev_if)
488 goto e_inval;
489
490 np->sticky_pktinfo.ipi6_ifindex = pkt.ipi6_ifindex;
491 np->sticky_pktinfo.ipi6_addr = pkt.ipi6_addr;
492 retv = 0;
493 break;
494 }
495
496 case IPV6_2292PKTOPTIONS:
497 {
498 struct ipv6_txoptions *opt = NULL;
499 struct msghdr msg;
500 struct flowi6 fl6;
501 struct sockcm_cookie sockc_junk;
502 struct ipcm6_cookie ipc6;
503
504 memset(&fl6, 0, sizeof(fl6));
505 fl6.flowi6_oif = sk->sk_bound_dev_if;
506 fl6.flowi6_mark = sk->sk_mark;
507
508 if (optlen == 0)
509 goto update;
510
511 /* 1K is probably excessive
512 * 1K is surely not enough, 2K per standard header is 16K.
513 */
514 retv = -EINVAL;
515 if (optlen > 64*1024)
516 break;
517
518 opt = sock_kmalloc(sk, sizeof(*opt) + optlen, GFP_KERNEL);
519 retv = -ENOBUFS;
520 if (!opt)
521 break;
522
523 memset(opt, 0, sizeof(*opt));
524 refcount_set(&opt->refcnt, 1);
525 opt->tot_len = sizeof(*opt) + optlen;
526 retv = -EFAULT;
527 if (copy_from_user(opt+1, optval, optlen))
528 goto done;
529
530 msg.msg_controllen = optlen;
531 msg.msg_control = (void *)(opt+1);
532 ipc6.opt = opt;
533
534 retv = ip6_datagram_send_ctl(net, sk, &msg, &fl6, &ipc6, &sockc_junk);
535 if (retv)
536 goto done;
537 update:
538 retv = 0;
539 opt = ipv6_update_options(sk, opt);
540 done:
541 if (opt) {
542 atomic_sub(opt->tot_len, &sk->sk_omem_alloc);
543 txopt_put(opt);
544 }
545 break;
546 }
547 case IPV6_UNICAST_HOPS:
548 if (optlen < sizeof(int))
549 goto e_inval;
550 if (val > 255 || val < -1)
551 goto e_inval;
552 np->hop_limit = val;
553 retv = 0;
554 break;
555
556 case IPV6_MULTICAST_HOPS:
557 if (sk->sk_type == SOCK_STREAM)
558 break;
559 if (optlen < sizeof(int))
560 goto e_inval;
561 if (val > 255 || val < -1)
562 goto e_inval;
563 np->mcast_hops = (val == -1 ? IPV6_DEFAULT_MCASTHOPS : val);
564 retv = 0;
565 break;
566
567 case IPV6_MULTICAST_LOOP:
568 if (optlen < sizeof(int))
569 goto e_inval;
570 if (val != valbool)
571 goto e_inval;
572 np->mc_loop = valbool;
573 retv = 0;
574 break;
575
576 case IPV6_UNICAST_IF:
577 {
578 struct net_device *dev = NULL;
579 int ifindex;
580
581 if (optlen != sizeof(int))
582 goto e_inval;
583
584 ifindex = (__force int)ntohl((__force __be32)val);
585 if (ifindex == 0) {
586 np->ucast_oif = 0;
587 retv = 0;
588 break;
589 }
590
591 dev = dev_get_by_index(net, ifindex);
592 retv = -EADDRNOTAVAIL;
593 if (!dev)
594 break;
595 dev_put(dev);
596
597 retv = -EINVAL;
598 if (sk->sk_bound_dev_if)
599 break;
600
601 np->ucast_oif = ifindex;
602 retv = 0;
603 break;
604 }
605
606 case IPV6_MULTICAST_IF:
607 if (sk->sk_type == SOCK_STREAM)
608 break;
609 if (optlen < sizeof(int))
610 goto e_inval;
611
612 if (val) {
613 struct net_device *dev;
614 int midx;
615
616 rcu_read_lock();
617
618 dev = dev_get_by_index_rcu(net, val);
619 if (!dev) {
620 rcu_read_unlock();
621 retv = -ENODEV;
622 break;
623 }
624 midx = l3mdev_master_ifindex_rcu(dev);
625
626 rcu_read_unlock();
627
628 if (sk->sk_bound_dev_if &&
629 sk->sk_bound_dev_if != val &&
630 (!midx || midx != sk->sk_bound_dev_if))
631 goto e_inval;
632 }
633 np->mcast_oif = val;
634 retv = 0;
635 break;
636 case IPV6_ADD_MEMBERSHIP:
637 case IPV6_DROP_MEMBERSHIP:
638 {
639 struct ipv6_mreq mreq;
640
641 if (optlen < sizeof(struct ipv6_mreq))
642 goto e_inval;
643
644 retv = -EPROTO;
645 if (inet_sk(sk)->is_icsk)
646 break;
647
648 retv = -EFAULT;
649 if (copy_from_user(&mreq, optval, sizeof(struct ipv6_mreq)))
650 break;
651
652 if (optname == IPV6_ADD_MEMBERSHIP)
653 retv = ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
654 else
655 retv = ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
656 break;
657 }
658 case IPV6_JOIN_ANYCAST:
659 case IPV6_LEAVE_ANYCAST:
660 {
661 struct ipv6_mreq mreq;
662
663 if (optlen < sizeof(struct ipv6_mreq))
664 goto e_inval;
665
666 retv = -EFAULT;
667 if (copy_from_user(&mreq, optval, sizeof(struct ipv6_mreq)))
668 break;
669
670 if (optname == IPV6_JOIN_ANYCAST)
671 retv = ipv6_sock_ac_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr);
672 else
673 retv = ipv6_sock_ac_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr);
674 break;
675 }
676 case MCAST_JOIN_GROUP:
677 case MCAST_LEAVE_GROUP:
678 {
679 struct group_req greq;
680 struct sockaddr_in6 *psin6;
681
682 if (optlen < sizeof(struct group_req))
683 goto e_inval;
684
685 retv = -EFAULT;
686 if (copy_from_user(&greq, optval, sizeof(struct group_req)))
687 break;
688 if (greq.gr_group.ss_family != AF_INET6) {
689 retv = -EADDRNOTAVAIL;
690 break;
691 }
692 psin6 = (struct sockaddr_in6 *)&greq.gr_group;
693 if (optname == MCAST_JOIN_GROUP)
694 retv = ipv6_sock_mc_join(sk, greq.gr_interface,
695 &psin6->sin6_addr);
696 else
697 retv = ipv6_sock_mc_drop(sk, greq.gr_interface,
698 &psin6->sin6_addr);
699 break;
700 }
701 case MCAST_JOIN_SOURCE_GROUP:
702 case MCAST_LEAVE_SOURCE_GROUP:
703 case MCAST_BLOCK_SOURCE:
704 case MCAST_UNBLOCK_SOURCE:
705 {
706 struct group_source_req greqs;
707 int omode, add;
708
709 if (optlen < sizeof(struct group_source_req))
710 goto e_inval;
711 if (copy_from_user(&greqs, optval, sizeof(greqs))) {
712 retv = -EFAULT;
713 break;
714 }
715 if (greqs.gsr_group.ss_family != AF_INET6 ||
716 greqs.gsr_source.ss_family != AF_INET6) {
717 retv = -EADDRNOTAVAIL;
718 break;
719 }
720 if (optname == MCAST_BLOCK_SOURCE) {
721 omode = MCAST_EXCLUDE;
722 add = 1;
723 } else if (optname == MCAST_UNBLOCK_SOURCE) {
724 omode = MCAST_EXCLUDE;
725 add = 0;
726 } else if (optname == MCAST_JOIN_SOURCE_GROUP) {
727 struct sockaddr_in6 *psin6;
728
729 psin6 = (struct sockaddr_in6 *)&greqs.gsr_group;
730 retv = ipv6_sock_mc_join(sk, greqs.gsr_interface,
731 &psin6->sin6_addr);
732 /* prior join w/ different source is ok */
733 if (retv && retv != -EADDRINUSE)
734 break;
735 omode = MCAST_INCLUDE;
736 add = 1;
737 } else /* MCAST_LEAVE_SOURCE_GROUP */ {
738 omode = MCAST_INCLUDE;
739 add = 0;
740 }
741 retv = ip6_mc_source(add, omode, sk, &greqs);
742 break;
743 }
744 case MCAST_MSFILTER:
745 {
746 struct group_filter *gsf;
747
748 if (optlen < GROUP_FILTER_SIZE(0))
749 goto e_inval;
750 if (optlen > sysctl_optmem_max) {
751 retv = -ENOBUFS;
752 break;
753 }
754 gsf = memdup_user(optval, optlen);
755 if (IS_ERR(gsf)) {
756 retv = PTR_ERR(gsf);
757 break;
758 }
759 /* numsrc >= (4G-140)/128 overflow in 32 bits */
760 if (gsf->gf_numsrc >= 0x1ffffffU ||
761 gsf->gf_numsrc > sysctl_mld_max_msf) {
762 kfree(gsf);
763 retv = -ENOBUFS;
764 break;
765 }
766 if (GROUP_FILTER_SIZE(gsf->gf_numsrc) > optlen) {
767 kfree(gsf);
768 retv = -EINVAL;
769 break;
770 }
771 retv = ip6_mc_msfilter(sk, gsf);
772 kfree(gsf);
773
774 break;
775 }
776 case IPV6_ROUTER_ALERT:
777 if (optlen < sizeof(int))
778 goto e_inval;
779 retv = ip6_ra_control(sk, val);
780 break;
781 case IPV6_MTU_DISCOVER:
782 if (optlen < sizeof(int))
783 goto e_inval;
784 if (val < IPV6_PMTUDISC_DONT || val > IPV6_PMTUDISC_OMIT)
785 goto e_inval;
786 np->pmtudisc = val;
787 retv = 0;
788 break;
789 case IPV6_MTU:
790 if (optlen < sizeof(int))
791 goto e_inval;
792 if (val && val < IPV6_MIN_MTU)
793 goto e_inval;
794 np->frag_size = val;
795 retv = 0;
796 break;
797 case IPV6_RECVERR:
798 if (optlen < sizeof(int))
799 goto e_inval;
800 np->recverr = valbool;
801 if (!val)
802 skb_queue_purge(&sk->sk_error_queue);
803 retv = 0;
804 break;
805 case IPV6_FLOWINFO_SEND:
806 if (optlen < sizeof(int))
807 goto e_inval;
808 np->sndflow = valbool;
809 retv = 0;
810 break;
811 case IPV6_FLOWLABEL_MGR:
812 retv = ipv6_flowlabel_opt(sk, optval, optlen);
813 break;
814 case IPV6_IPSEC_POLICY:
815 case IPV6_XFRM_POLICY:
816 retv = -EPERM;
817 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
818 break;
819 retv = xfrm_user_policy(sk, optname, optval, optlen);
820 break;
821
822 case IPV6_ADDR_PREFERENCES:
823 {
824 unsigned int pref = 0;
825 unsigned int prefmask = ~0;
826
827 if (optlen < sizeof(int))
828 goto e_inval;
829
830 retv = -EINVAL;
831
832 /* check PUBLIC/TMP/PUBTMP_DEFAULT conflicts */
833 switch (val & (IPV6_PREFER_SRC_PUBLIC|
834 IPV6_PREFER_SRC_TMP|
835 IPV6_PREFER_SRC_PUBTMP_DEFAULT)) {
836 case IPV6_PREFER_SRC_PUBLIC:
837 pref |= IPV6_PREFER_SRC_PUBLIC;
838 break;
839 case IPV6_PREFER_SRC_TMP:
840 pref |= IPV6_PREFER_SRC_TMP;
841 break;
842 case IPV6_PREFER_SRC_PUBTMP_DEFAULT:
843 break;
844 case 0:
845 goto pref_skip_pubtmp;
846 default:
847 goto e_inval;
848 }
849
850 prefmask &= ~(IPV6_PREFER_SRC_PUBLIC|
851 IPV6_PREFER_SRC_TMP);
852 pref_skip_pubtmp:
853
854 /* check HOME/COA conflicts */
855 switch (val & (IPV6_PREFER_SRC_HOME|IPV6_PREFER_SRC_COA)) {
856 case IPV6_PREFER_SRC_HOME:
857 break;
858 case IPV6_PREFER_SRC_COA:
859 pref |= IPV6_PREFER_SRC_COA;
860 case 0:
861 goto pref_skip_coa;
862 default:
863 goto e_inval;
864 }
865
866 prefmask &= ~IPV6_PREFER_SRC_COA;
867 pref_skip_coa:
868
869 /* check CGA/NONCGA conflicts */
870 switch (val & (IPV6_PREFER_SRC_CGA|IPV6_PREFER_SRC_NONCGA)) {
871 case IPV6_PREFER_SRC_CGA:
872 case IPV6_PREFER_SRC_NONCGA:
873 case 0:
874 break;
875 default:
876 goto e_inval;
877 }
878
879 np->srcprefs = (np->srcprefs & prefmask) | pref;
880 retv = 0;
881
882 break;
883 }
884 case IPV6_MINHOPCOUNT:
885 if (optlen < sizeof(int))
886 goto e_inval;
887 if (val < 0 || val > 255)
888 goto e_inval;
889 np->min_hopcount = val;
890 retv = 0;
891 break;
892 case IPV6_DONTFRAG:
893 np->dontfrag = valbool;
894 retv = 0;
895 break;
896 case IPV6_AUTOFLOWLABEL:
897 np->autoflowlabel = valbool;
898 np->autoflowlabel_set = 1;
899 retv = 0;
900 break;
901 case IPV6_RECVFRAGSIZE:
902 np->rxopt.bits.recvfragsize = valbool;
903 retv = 0;
904 break;
905 }
906
907 release_sock(sk);
908 if (needs_rtnl)
909 rtnl_unlock();
910
911 return retv;
912
913 e_inval:
914 release_sock(sk);
915 if (needs_rtnl)
916 rtnl_unlock();
917 return -EINVAL;
918 }
919
ipv6_setsockopt(struct sock * sk,int level,int optname,char __user * optval,unsigned int optlen)920 int ipv6_setsockopt(struct sock *sk, int level, int optname,
921 char __user *optval, unsigned int optlen)
922 {
923 int err;
924
925 if (level == SOL_IP && sk->sk_type != SOCK_RAW)
926 return udp_prot.setsockopt(sk, level, optname, optval, optlen);
927
928 if (level != SOL_IPV6)
929 return -ENOPROTOOPT;
930
931 err = do_ipv6_setsockopt(sk, level, optname, optval, optlen);
932 #ifdef CONFIG_NETFILTER
933 /* we need to exclude all possible ENOPROTOOPTs except default case */
934 if (err == -ENOPROTOOPT && optname != IPV6_IPSEC_POLICY &&
935 optname != IPV6_XFRM_POLICY)
936 err = nf_setsockopt(sk, PF_INET6, optname, optval, optlen);
937 #endif
938 return err;
939 }
940 EXPORT_SYMBOL(ipv6_setsockopt);
941
942 #ifdef CONFIG_COMPAT
compat_ipv6_setsockopt(struct sock * sk,int level,int optname,char __user * optval,unsigned int optlen)943 int compat_ipv6_setsockopt(struct sock *sk, int level, int optname,
944 char __user *optval, unsigned int optlen)
945 {
946 int err;
947
948 if (level == SOL_IP && sk->sk_type != SOCK_RAW) {
949 if (udp_prot.compat_setsockopt != NULL)
950 return udp_prot.compat_setsockopt(sk, level, optname,
951 optval, optlen);
952 return udp_prot.setsockopt(sk, level, optname, optval, optlen);
953 }
954
955 if (level != SOL_IPV6)
956 return -ENOPROTOOPT;
957
958 if (optname >= MCAST_JOIN_GROUP && optname <= MCAST_MSFILTER)
959 return compat_mc_setsockopt(sk, level, optname, optval, optlen,
960 ipv6_setsockopt);
961
962 err = do_ipv6_setsockopt(sk, level, optname, optval, optlen);
963 #ifdef CONFIG_NETFILTER
964 /* we need to exclude all possible ENOPROTOOPTs except default case */
965 if (err == -ENOPROTOOPT && optname != IPV6_IPSEC_POLICY &&
966 optname != IPV6_XFRM_POLICY)
967 err = compat_nf_setsockopt(sk, PF_INET6, optname, optval,
968 optlen);
969 #endif
970 return err;
971 }
972 EXPORT_SYMBOL(compat_ipv6_setsockopt);
973 #endif
974
ipv6_getsockopt_sticky(struct sock * sk,struct ipv6_txoptions * opt,int optname,char __user * optval,int len)975 static int ipv6_getsockopt_sticky(struct sock *sk, struct ipv6_txoptions *opt,
976 int optname, char __user *optval, int len)
977 {
978 struct ipv6_opt_hdr *hdr;
979
980 if (!opt)
981 return 0;
982
983 switch (optname) {
984 case IPV6_HOPOPTS:
985 hdr = opt->hopopt;
986 break;
987 case IPV6_RTHDRDSTOPTS:
988 hdr = opt->dst0opt;
989 break;
990 case IPV6_RTHDR:
991 hdr = (struct ipv6_opt_hdr *)opt->srcrt;
992 break;
993 case IPV6_DSTOPTS:
994 hdr = opt->dst1opt;
995 break;
996 default:
997 return -EINVAL; /* should not happen */
998 }
999
1000 if (!hdr)
1001 return 0;
1002
1003 len = min_t(unsigned int, len, ipv6_optlen(hdr));
1004 if (copy_to_user(optval, hdr, len))
1005 return -EFAULT;
1006 return len;
1007 }
1008
do_ipv6_getsockopt(struct sock * sk,int level,int optname,char __user * optval,int __user * optlen,unsigned int flags)1009 static int do_ipv6_getsockopt(struct sock *sk, int level, int optname,
1010 char __user *optval, int __user *optlen, unsigned int flags)
1011 {
1012 struct ipv6_pinfo *np = inet6_sk(sk);
1013 int len;
1014 int val;
1015
1016 if (ip6_mroute_opt(optname))
1017 return ip6_mroute_getsockopt(sk, optname, optval, optlen);
1018
1019 if (get_user(len, optlen))
1020 return -EFAULT;
1021 switch (optname) {
1022 case IPV6_ADDRFORM:
1023 if (sk->sk_protocol != IPPROTO_UDP &&
1024 sk->sk_protocol != IPPROTO_UDPLITE &&
1025 sk->sk_protocol != IPPROTO_TCP)
1026 return -ENOPROTOOPT;
1027 if (sk->sk_state != TCP_ESTABLISHED)
1028 return -ENOTCONN;
1029 val = sk->sk_family;
1030 break;
1031 case MCAST_MSFILTER:
1032 {
1033 struct group_filter gsf;
1034 int err;
1035
1036 if (len < GROUP_FILTER_SIZE(0))
1037 return -EINVAL;
1038 if (copy_from_user(&gsf, optval, GROUP_FILTER_SIZE(0)))
1039 return -EFAULT;
1040 if (gsf.gf_group.ss_family != AF_INET6)
1041 return -EADDRNOTAVAIL;
1042 lock_sock(sk);
1043 err = ip6_mc_msfget(sk, &gsf,
1044 (struct group_filter __user *)optval, optlen);
1045 release_sock(sk);
1046 return err;
1047 }
1048
1049 case IPV6_2292PKTOPTIONS:
1050 {
1051 struct msghdr msg;
1052 struct sk_buff *skb;
1053
1054 if (sk->sk_type != SOCK_STREAM)
1055 return -ENOPROTOOPT;
1056
1057 msg.msg_control = optval;
1058 msg.msg_controllen = len;
1059 msg.msg_flags = flags;
1060
1061 lock_sock(sk);
1062 skb = np->pktoptions;
1063 if (skb)
1064 ip6_datagram_recv_ctl(sk, &msg, skb);
1065 release_sock(sk);
1066 if (!skb) {
1067 if (np->rxopt.bits.rxinfo) {
1068 struct in6_pktinfo src_info;
1069 src_info.ipi6_ifindex = np->mcast_oif ? np->mcast_oif :
1070 np->sticky_pktinfo.ipi6_ifindex;
1071 src_info.ipi6_addr = np->mcast_oif ? sk->sk_v6_daddr : np->sticky_pktinfo.ipi6_addr;
1072 put_cmsg(&msg, SOL_IPV6, IPV6_PKTINFO, sizeof(src_info), &src_info);
1073 }
1074 if (np->rxopt.bits.rxhlim) {
1075 int hlim = np->mcast_hops;
1076 put_cmsg(&msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);
1077 }
1078 if (np->rxopt.bits.rxtclass) {
1079 int tclass = (int)ip6_tclass(np->rcv_flowinfo);
1080
1081 put_cmsg(&msg, SOL_IPV6, IPV6_TCLASS, sizeof(tclass), &tclass);
1082 }
1083 if (np->rxopt.bits.rxoinfo) {
1084 struct in6_pktinfo src_info;
1085 src_info.ipi6_ifindex = np->mcast_oif ? np->mcast_oif :
1086 np->sticky_pktinfo.ipi6_ifindex;
1087 src_info.ipi6_addr = np->mcast_oif ? sk->sk_v6_daddr :
1088 np->sticky_pktinfo.ipi6_addr;
1089 put_cmsg(&msg, SOL_IPV6, IPV6_2292PKTINFO, sizeof(src_info), &src_info);
1090 }
1091 if (np->rxopt.bits.rxohlim) {
1092 int hlim = np->mcast_hops;
1093 put_cmsg(&msg, SOL_IPV6, IPV6_2292HOPLIMIT, sizeof(hlim), &hlim);
1094 }
1095 if (np->rxopt.bits.rxflow) {
1096 __be32 flowinfo = np->rcv_flowinfo;
1097
1098 put_cmsg(&msg, SOL_IPV6, IPV6_FLOWINFO, sizeof(flowinfo), &flowinfo);
1099 }
1100 }
1101 len -= msg.msg_controllen;
1102 return put_user(len, optlen);
1103 }
1104 case IPV6_MTU:
1105 {
1106 struct dst_entry *dst;
1107
1108 val = 0;
1109 rcu_read_lock();
1110 dst = __sk_dst_get(sk);
1111 if (dst)
1112 val = dst_mtu(dst);
1113 rcu_read_unlock();
1114 if (!val)
1115 return -ENOTCONN;
1116 break;
1117 }
1118
1119 case IPV6_V6ONLY:
1120 val = sk->sk_ipv6only;
1121 break;
1122
1123 case IPV6_RECVPKTINFO:
1124 val = np->rxopt.bits.rxinfo;
1125 break;
1126
1127 case IPV6_2292PKTINFO:
1128 val = np->rxopt.bits.rxoinfo;
1129 break;
1130
1131 case IPV6_RECVHOPLIMIT:
1132 val = np->rxopt.bits.rxhlim;
1133 break;
1134
1135 case IPV6_2292HOPLIMIT:
1136 val = np->rxopt.bits.rxohlim;
1137 break;
1138
1139 case IPV6_RECVRTHDR:
1140 val = np->rxopt.bits.srcrt;
1141 break;
1142
1143 case IPV6_2292RTHDR:
1144 val = np->rxopt.bits.osrcrt;
1145 break;
1146
1147 case IPV6_HOPOPTS:
1148 case IPV6_RTHDRDSTOPTS:
1149 case IPV6_RTHDR:
1150 case IPV6_DSTOPTS:
1151 {
1152 struct ipv6_txoptions *opt;
1153
1154 lock_sock(sk);
1155 opt = rcu_dereference_protected(np->opt,
1156 lockdep_sock_is_held(sk));
1157 len = ipv6_getsockopt_sticky(sk, opt, optname, optval, len);
1158 release_sock(sk);
1159 /* check if ipv6_getsockopt_sticky() returns err code */
1160 if (len < 0)
1161 return len;
1162 return put_user(len, optlen);
1163 }
1164
1165 case IPV6_RECVHOPOPTS:
1166 val = np->rxopt.bits.hopopts;
1167 break;
1168
1169 case IPV6_2292HOPOPTS:
1170 val = np->rxopt.bits.ohopopts;
1171 break;
1172
1173 case IPV6_RECVDSTOPTS:
1174 val = np->rxopt.bits.dstopts;
1175 break;
1176
1177 case IPV6_2292DSTOPTS:
1178 val = np->rxopt.bits.odstopts;
1179 break;
1180
1181 case IPV6_TCLASS:
1182 val = np->tclass;
1183 break;
1184
1185 case IPV6_RECVTCLASS:
1186 val = np->rxopt.bits.rxtclass;
1187 break;
1188
1189 case IPV6_FLOWINFO:
1190 val = np->rxopt.bits.rxflow;
1191 break;
1192
1193 case IPV6_RECVPATHMTU:
1194 val = np->rxopt.bits.rxpmtu;
1195 break;
1196
1197 case IPV6_PATHMTU:
1198 {
1199 struct dst_entry *dst;
1200 struct ip6_mtuinfo mtuinfo;
1201
1202 if (len < sizeof(mtuinfo))
1203 return -EINVAL;
1204
1205 len = sizeof(mtuinfo);
1206 memset(&mtuinfo, 0, sizeof(mtuinfo));
1207
1208 rcu_read_lock();
1209 dst = __sk_dst_get(sk);
1210 if (dst)
1211 mtuinfo.ip6m_mtu = dst_mtu(dst);
1212 rcu_read_unlock();
1213 if (!mtuinfo.ip6m_mtu)
1214 return -ENOTCONN;
1215
1216 if (put_user(len, optlen))
1217 return -EFAULT;
1218 if (copy_to_user(optval, &mtuinfo, len))
1219 return -EFAULT;
1220
1221 return 0;
1222 }
1223
1224 case IPV6_TRANSPARENT:
1225 val = inet_sk(sk)->transparent;
1226 break;
1227
1228 case IPV6_RECVORIGDSTADDR:
1229 val = np->rxopt.bits.rxorigdstaddr;
1230 break;
1231
1232 case IPV6_UNICAST_HOPS:
1233 case IPV6_MULTICAST_HOPS:
1234 {
1235 struct dst_entry *dst;
1236
1237 if (optname == IPV6_UNICAST_HOPS)
1238 val = np->hop_limit;
1239 else
1240 val = np->mcast_hops;
1241
1242 if (val < 0) {
1243 rcu_read_lock();
1244 dst = __sk_dst_get(sk);
1245 if (dst)
1246 val = ip6_dst_hoplimit(dst);
1247 rcu_read_unlock();
1248 }
1249
1250 if (val < 0)
1251 val = sock_net(sk)->ipv6.devconf_all->hop_limit;
1252 break;
1253 }
1254
1255 case IPV6_MULTICAST_LOOP:
1256 val = np->mc_loop;
1257 break;
1258
1259 case IPV6_MULTICAST_IF:
1260 val = np->mcast_oif;
1261 break;
1262
1263 case IPV6_UNICAST_IF:
1264 val = (__force int)htonl((__u32) np->ucast_oif);
1265 break;
1266
1267 case IPV6_MTU_DISCOVER:
1268 val = np->pmtudisc;
1269 break;
1270
1271 case IPV6_RECVERR:
1272 val = np->recverr;
1273 break;
1274
1275 case IPV6_FLOWINFO_SEND:
1276 val = np->sndflow;
1277 break;
1278
1279 case IPV6_FLOWLABEL_MGR:
1280 {
1281 struct in6_flowlabel_req freq;
1282 int flags;
1283
1284 if (len < sizeof(freq))
1285 return -EINVAL;
1286
1287 if (copy_from_user(&freq, optval, sizeof(freq)))
1288 return -EFAULT;
1289
1290 if (freq.flr_action != IPV6_FL_A_GET)
1291 return -EINVAL;
1292
1293 len = sizeof(freq);
1294 flags = freq.flr_flags;
1295
1296 memset(&freq, 0, sizeof(freq));
1297
1298 val = ipv6_flowlabel_opt_get(sk, &freq, flags);
1299 if (val < 0)
1300 return val;
1301
1302 if (put_user(len, optlen))
1303 return -EFAULT;
1304 if (copy_to_user(optval, &freq, len))
1305 return -EFAULT;
1306
1307 return 0;
1308 }
1309
1310 case IPV6_ADDR_PREFERENCES:
1311 val = 0;
1312
1313 if (np->srcprefs & IPV6_PREFER_SRC_TMP)
1314 val |= IPV6_PREFER_SRC_TMP;
1315 else if (np->srcprefs & IPV6_PREFER_SRC_PUBLIC)
1316 val |= IPV6_PREFER_SRC_PUBLIC;
1317 else {
1318 /* XXX: should we return system default? */
1319 val |= IPV6_PREFER_SRC_PUBTMP_DEFAULT;
1320 }
1321
1322 if (np->srcprefs & IPV6_PREFER_SRC_COA)
1323 val |= IPV6_PREFER_SRC_COA;
1324 else
1325 val |= IPV6_PREFER_SRC_HOME;
1326 break;
1327
1328 case IPV6_MINHOPCOUNT:
1329 val = np->min_hopcount;
1330 break;
1331
1332 case IPV6_DONTFRAG:
1333 val = np->dontfrag;
1334 break;
1335
1336 case IPV6_AUTOFLOWLABEL:
1337 val = ip6_autoflowlabel(sock_net(sk), np);
1338 break;
1339
1340 case IPV6_RECVFRAGSIZE:
1341 val = np->rxopt.bits.recvfragsize;
1342 break;
1343
1344 default:
1345 return -ENOPROTOOPT;
1346 }
1347 len = min_t(unsigned int, sizeof(int), len);
1348 if (put_user(len, optlen))
1349 return -EFAULT;
1350 if (copy_to_user(optval, &val, len))
1351 return -EFAULT;
1352 return 0;
1353 }
1354
ipv6_getsockopt(struct sock * sk,int level,int optname,char __user * optval,int __user * optlen)1355 int ipv6_getsockopt(struct sock *sk, int level, int optname,
1356 char __user *optval, int __user *optlen)
1357 {
1358 int err;
1359
1360 if (level == SOL_IP && sk->sk_type != SOCK_RAW)
1361 return udp_prot.getsockopt(sk, level, optname, optval, optlen);
1362
1363 if (level != SOL_IPV6)
1364 return -ENOPROTOOPT;
1365
1366 err = do_ipv6_getsockopt(sk, level, optname, optval, optlen, 0);
1367 #ifdef CONFIG_NETFILTER
1368 /* we need to exclude all possible ENOPROTOOPTs except default case */
1369 if (err == -ENOPROTOOPT && optname != IPV6_2292PKTOPTIONS) {
1370 int len;
1371
1372 if (get_user(len, optlen))
1373 return -EFAULT;
1374
1375 err = nf_getsockopt(sk, PF_INET6, optname, optval, &len);
1376 if (err >= 0)
1377 err = put_user(len, optlen);
1378 }
1379 #endif
1380 return err;
1381 }
1382 EXPORT_SYMBOL(ipv6_getsockopt);
1383
1384 #ifdef CONFIG_COMPAT
compat_ipv6_getsockopt(struct sock * sk,int level,int optname,char __user * optval,int __user * optlen)1385 int compat_ipv6_getsockopt(struct sock *sk, int level, int optname,
1386 char __user *optval, int __user *optlen)
1387 {
1388 int err;
1389
1390 if (level == SOL_IP && sk->sk_type != SOCK_RAW) {
1391 if (udp_prot.compat_getsockopt != NULL)
1392 return udp_prot.compat_getsockopt(sk, level, optname,
1393 optval, optlen);
1394 return udp_prot.getsockopt(sk, level, optname, optval, optlen);
1395 }
1396
1397 if (level != SOL_IPV6)
1398 return -ENOPROTOOPT;
1399
1400 if (optname == MCAST_MSFILTER)
1401 return compat_mc_getsockopt(sk, level, optname, optval, optlen,
1402 ipv6_getsockopt);
1403
1404 err = do_ipv6_getsockopt(sk, level, optname, optval, optlen,
1405 MSG_CMSG_COMPAT);
1406 #ifdef CONFIG_NETFILTER
1407 /* we need to exclude all possible ENOPROTOOPTs except default case */
1408 if (err == -ENOPROTOOPT && optname != IPV6_2292PKTOPTIONS) {
1409 int len;
1410
1411 if (get_user(len, optlen))
1412 return -EFAULT;
1413
1414 err = compat_nf_getsockopt(sk, PF_INET6, optname, optval, &len);
1415 if (err >= 0)
1416 err = put_user(len, optlen);
1417 }
1418 #endif
1419 return err;
1420 }
1421 EXPORT_SYMBOL(compat_ipv6_getsockopt);
1422 #endif
1423
1424