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