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