2 * IPv6 BSD socket options interface
3 * Linux INET6 implementation
6 * Pedro Roque <roque@di.fc.ul.pt>
8 * Based on linux/net/ipv4/ip_sockglue.c
10 * $Id: ipv6_sockglue.c,v 1.41 2002/02/01 22:01:04 davem Exp $
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
17 * FIXME: Make the setsockopt code POSIX compliant: That is
19 * o Return -EINVAL for setsockopt of short lengths
20 * o Truncate getsockopt returns
21 * o Return an optlen of the truncated length if need be
24 * David L Stevens <dlstevens@us.ibm.com>:
25 * - added multicast source filtering API for MLDv2
28 #include <linux/module.h>
29 #include <linux/capability.h>
30 #include <linux/errno.h>
31 #include <linux/types.h>
32 #include <linux/socket.h>
33 #include <linux/sockios.h>
34 #include <linux/net.h>
35 #include <linux/in6.h>
36 #include <linux/netdevice.h>
37 #include <linux/if_arp.h>
38 #include <linux/init.h>
39 #include <linux/sysctl.h>
40 #include <linux/netfilter.h>
45 #include <net/ndisc.h>
46 #include <net/protocol.h>
47 #include <net/transp_v6.h>
48 #include <net/ip6_route.h>
49 #include <net/addrconf.h>
50 #include <net/inet_common.h>
53 #include <net/udplite.h>
56 #include <asm/uaccess.h>
58 DEFINE_SNMP_STAT(struct ipstats_mib
, ipv6_statistics
) __read_mostly
;
60 struct ip6_ra_chain
*ip6_ra_chain
;
61 DEFINE_RWLOCK(ip6_ra_lock
);
63 int ip6_ra_control(struct sock
*sk
, int sel
, void (*destructor
)(struct sock
*))
65 struct ip6_ra_chain
*ra
, *new_ra
, **rap
;
67 /* RA packet may be delivered ONLY to IPPROTO_RAW socket */
68 if (sk
->sk_type
!= SOCK_RAW
|| inet_sk(sk
)->num
!= IPPROTO_RAW
)
71 new_ra
= (sel
>=0) ? kmalloc(sizeof(*new_ra
), GFP_KERNEL
) : NULL
;
73 write_lock_bh(&ip6_ra_lock
);
74 for (rap
= &ip6_ra_chain
; (ra
=*rap
) != NULL
; rap
= &ra
->next
) {
77 write_unlock_bh(&ip6_ra_lock
);
83 write_unlock_bh(&ip6_ra_lock
);
93 write_unlock_bh(&ip6_ra_lock
);
98 new_ra
->destructor
= destructor
;
102 write_unlock_bh(&ip6_ra_lock
);
106 static int do_ipv6_setsockopt(struct sock
*sk
, int level
, int optname
,
107 char __user
*optval
, int optlen
)
109 struct ipv6_pinfo
*np
= inet6_sk(sk
);
111 int retv
= -ENOPROTOOPT
;
115 else if (get_user(val
, (int __user
*) optval
))
125 if (val
== PF_INET
) {
126 struct ipv6_txoptions
*opt
;
127 struct sk_buff
*pktopt
;
129 if (sk
->sk_protocol
!= IPPROTO_UDP
&&
130 sk
->sk_protocol
!= IPPROTO_UDPLITE
&&
131 sk
->sk_protocol
!= IPPROTO_TCP
)
134 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
139 if (ipv6_only_sock(sk
) ||
140 !ipv6_addr_v4mapped(&np
->daddr
)) {
141 retv
= -EADDRNOTAVAIL
;
145 fl6_free_socklist(sk
);
146 ipv6_sock_mc_close(sk
);
149 * Sock is moving from IPv6 to IPv4 (sk_prot), so
150 * remove it from the refcnt debug socks count in the
153 sk_refcnt_debug_dec(sk
);
155 if (sk
->sk_protocol
== IPPROTO_TCP
) {
156 struct inet_connection_sock
*icsk
= inet_csk(sk
);
159 sock_prot_inuse_add(sk
->sk_prot
, -1);
160 sock_prot_inuse_add(&tcp_prot
, 1);
162 sk
->sk_prot
= &tcp_prot
;
163 icsk
->icsk_af_ops
= &ipv4_specific
;
164 sk
->sk_socket
->ops
= &inet_stream_ops
;
165 sk
->sk_family
= PF_INET
;
166 tcp_sync_mss(sk
, icsk
->icsk_pmtu_cookie
);
168 struct proto
*prot
= &udp_prot
;
170 if (sk
->sk_protocol
== IPPROTO_UDPLITE
)
171 prot
= &udplite_prot
;
173 sock_prot_inuse_add(sk
->sk_prot
, -1);
174 sock_prot_inuse_add(prot
, 1);
177 sk
->sk_socket
->ops
= &inet_dgram_ops
;
178 sk
->sk_family
= PF_INET
;
180 opt
= xchg(&np
->opt
, NULL
);
182 sock_kfree_s(sk
, opt
, opt
->tot_len
);
183 pktopt
= xchg(&np
->pktoptions
, NULL
);
187 sk
->sk_destruct
= inet_sock_destruct
;
189 * ... and add it to the refcnt debug socks count
190 * in the new family. -acme
192 sk_refcnt_debug_inc(sk
);
193 module_put(THIS_MODULE
);
200 if (inet_sk(sk
)->num
)
202 np
->ipv6only
= valbool
;
206 case IPV6_RECVPKTINFO
:
207 np
->rxopt
.bits
.rxinfo
= valbool
;
211 case IPV6_2292PKTINFO
:
212 np
->rxopt
.bits
.rxoinfo
= valbool
;
216 case IPV6_RECVHOPLIMIT
:
217 np
->rxopt
.bits
.rxhlim
= valbool
;
221 case IPV6_2292HOPLIMIT
:
222 np
->rxopt
.bits
.rxohlim
= valbool
;
227 np
->rxopt
.bits
.srcrt
= valbool
;
232 np
->rxopt
.bits
.osrcrt
= valbool
;
236 case IPV6_RECVHOPOPTS
:
237 np
->rxopt
.bits
.hopopts
= valbool
;
241 case IPV6_2292HOPOPTS
:
242 np
->rxopt
.bits
.ohopopts
= valbool
;
246 case IPV6_RECVDSTOPTS
:
247 np
->rxopt
.bits
.dstopts
= valbool
;
251 case IPV6_2292DSTOPTS
:
252 np
->rxopt
.bits
.odstopts
= valbool
;
257 if (val
< -1 || val
> 0xff)
263 case IPV6_RECVTCLASS
:
264 np
->rxopt
.bits
.rxtclass
= valbool
;
269 np
->rxopt
.bits
.rxflow
= valbool
;
274 case IPV6_RTHDRDSTOPTS
:
278 struct ipv6_txoptions
*opt
;
282 /* hop-by-hop / destination options are privileged option */
284 if (optname
!= IPV6_RTHDR
&& !capable(CAP_NET_RAW
))
288 if (optlen
& 0x7 || optlen
> 8 * 255)
291 opt
= ipv6_renew_options(sk
, np
->opt
, optname
,
292 (struct ipv6_opt_hdr __user
*)optval
,
299 /* routing header option needs extra check */
300 if (optname
== IPV6_RTHDR
&& opt
&& opt
->srcrt
) {
301 struct ipv6_rt_hdr
*rthdr
= opt
->srcrt
;
302 switch (rthdr
->type
) {
303 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
304 case IPV6_SRCRT_TYPE_2
:
311 if ((rthdr
->hdrlen
& 1) ||
312 (rthdr
->hdrlen
>> 1) != rthdr
->segments_left
)
317 if (inet_sk(sk
)->is_icsk
) {
319 struct inet_connection_sock
*icsk
= inet_csk(sk
);
320 if (!((1 << sk
->sk_state
) &
321 (TCPF_LISTEN
| TCPF_CLOSE
))
322 && inet_sk(sk
)->daddr
!= LOOPBACK4_IPV6
) {
323 icsk
->icsk_ext_hdr_len
=
324 opt
->opt_flen
+ opt
->opt_nflen
;
325 icsk
->icsk_sync_mss(sk
, icsk
->icsk_pmtu_cookie
);
328 opt
= xchg(&np
->opt
, opt
);
331 write_lock(&sk
->sk_dst_lock
);
332 opt
= xchg(&np
->opt
, opt
);
333 write_unlock(&sk
->sk_dst_lock
);
338 sock_kfree_s(sk
, opt
, opt
->tot_len
);
342 case IPV6_2292PKTOPTIONS
:
344 struct ipv6_txoptions
*opt
= NULL
;
349 fl
.fl6_flowlabel
= 0;
350 fl
.oif
= sk
->sk_bound_dev_if
;
355 /* 1K is probably excessive
356 * 1K is surely not enough, 2K per standard header is 16K.
359 if (optlen
> 64*1024)
362 opt
= sock_kmalloc(sk
, sizeof(*opt
) + optlen
, GFP_KERNEL
);
367 memset(opt
, 0, sizeof(*opt
));
368 opt
->tot_len
= sizeof(*opt
) + optlen
;
370 if (copy_from_user(opt
+1, optval
, optlen
))
373 msg
.msg_controllen
= optlen
;
374 msg
.msg_control
= (void*)(opt
+1);
376 retv
= datagram_send_ctl(&msg
, &fl
, opt
, &junk
, &junk
);
381 if (inet_sk(sk
)->is_icsk
) {
383 struct inet_connection_sock
*icsk
= inet_csk(sk
);
384 if (!((1 << sk
->sk_state
) &
385 (TCPF_LISTEN
| TCPF_CLOSE
))
386 && inet_sk(sk
)->daddr
!= LOOPBACK4_IPV6
) {
387 icsk
->icsk_ext_hdr_len
=
388 opt
->opt_flen
+ opt
->opt_nflen
;
389 icsk
->icsk_sync_mss(sk
, icsk
->icsk_pmtu_cookie
);
392 opt
= xchg(&np
->opt
, opt
);
395 write_lock(&sk
->sk_dst_lock
);
396 opt
= xchg(&np
->opt
, opt
);
397 write_unlock(&sk
->sk_dst_lock
);
403 sock_kfree_s(sk
, opt
, opt
->tot_len
);
406 case IPV6_UNICAST_HOPS
:
407 if (val
> 255 || val
< -1)
413 case IPV6_MULTICAST_HOPS
:
414 if (sk
->sk_type
== SOCK_STREAM
)
416 if (val
> 255 || val
< -1)
418 np
->mcast_hops
= val
;
422 case IPV6_MULTICAST_LOOP
:
423 np
->mc_loop
= valbool
;
427 case IPV6_MULTICAST_IF
:
428 if (sk
->sk_type
== SOCK_STREAM
)
432 if (sk
->sk_bound_dev_if
&& sk
->sk_bound_dev_if
!= val
)
435 if (__dev_get_by_index(&init_net
, val
) == NULL
) {
443 case IPV6_ADD_MEMBERSHIP
:
444 case IPV6_DROP_MEMBERSHIP
:
446 struct ipv6_mreq mreq
;
449 if (inet_sk(sk
)->is_icsk
)
453 if (copy_from_user(&mreq
, optval
, sizeof(struct ipv6_mreq
)))
456 if (optname
== IPV6_ADD_MEMBERSHIP
)
457 retv
= ipv6_sock_mc_join(sk
, mreq
.ipv6mr_ifindex
, &mreq
.ipv6mr_multiaddr
);
459 retv
= ipv6_sock_mc_drop(sk
, mreq
.ipv6mr_ifindex
, &mreq
.ipv6mr_multiaddr
);
462 case IPV6_JOIN_ANYCAST
:
463 case IPV6_LEAVE_ANYCAST
:
465 struct ipv6_mreq mreq
;
467 if (optlen
!= sizeof(struct ipv6_mreq
))
471 if (copy_from_user(&mreq
, optval
, sizeof(struct ipv6_mreq
)))
474 if (optname
== IPV6_JOIN_ANYCAST
)
475 retv
= ipv6_sock_ac_join(sk
, mreq
.ipv6mr_ifindex
, &mreq
.ipv6mr_acaddr
);
477 retv
= ipv6_sock_ac_drop(sk
, mreq
.ipv6mr_ifindex
, &mreq
.ipv6mr_acaddr
);
480 case MCAST_JOIN_GROUP
:
481 case MCAST_LEAVE_GROUP
:
483 struct group_req greq
;
484 struct sockaddr_in6
*psin6
;
487 if (copy_from_user(&greq
, optval
, sizeof(struct group_req
)))
489 if (greq
.gr_group
.ss_family
!= AF_INET6
) {
490 retv
= -EADDRNOTAVAIL
;
493 psin6
= (struct sockaddr_in6
*)&greq
.gr_group
;
494 if (optname
== MCAST_JOIN_GROUP
)
495 retv
= ipv6_sock_mc_join(sk
, greq
.gr_interface
,
498 retv
= ipv6_sock_mc_drop(sk
, greq
.gr_interface
,
502 case MCAST_JOIN_SOURCE_GROUP
:
503 case MCAST_LEAVE_SOURCE_GROUP
:
504 case MCAST_BLOCK_SOURCE
:
505 case MCAST_UNBLOCK_SOURCE
:
507 struct group_source_req greqs
;
510 if (optlen
!= sizeof(struct group_source_req
))
512 if (copy_from_user(&greqs
, optval
, sizeof(greqs
))) {
516 if (greqs
.gsr_group
.ss_family
!= AF_INET6
||
517 greqs
.gsr_source
.ss_family
!= AF_INET6
) {
518 retv
= -EADDRNOTAVAIL
;
521 if (optname
== MCAST_BLOCK_SOURCE
) {
522 omode
= MCAST_EXCLUDE
;
524 } else if (optname
== MCAST_UNBLOCK_SOURCE
) {
525 omode
= MCAST_EXCLUDE
;
527 } else if (optname
== MCAST_JOIN_SOURCE_GROUP
) {
528 struct sockaddr_in6
*psin6
;
530 psin6
= (struct sockaddr_in6
*)&greqs
.gsr_group
;
531 retv
= ipv6_sock_mc_join(sk
, greqs
.gsr_interface
,
533 /* prior join w/ different source is ok */
534 if (retv
&& retv
!= -EADDRINUSE
)
536 omode
= MCAST_INCLUDE
;
538 } else /* MCAST_LEAVE_SOURCE_GROUP */ {
539 omode
= MCAST_INCLUDE
;
542 retv
= ip6_mc_source(add
, omode
, sk
, &greqs
);
547 extern int sysctl_mld_max_msf
;
548 struct group_filter
*gsf
;
550 if (optlen
< GROUP_FILTER_SIZE(0))
552 if (optlen
> sysctl_optmem_max
) {
556 gsf
= kmalloc(optlen
,GFP_KERNEL
);
562 if (copy_from_user(gsf
, optval
, optlen
)) {
566 /* numsrc >= (4G-140)/128 overflow in 32 bits */
567 if (gsf
->gf_numsrc
>= 0x1ffffffU
||
568 gsf
->gf_numsrc
> sysctl_mld_max_msf
) {
573 if (GROUP_FILTER_SIZE(gsf
->gf_numsrc
) > optlen
) {
578 retv
= ip6_mc_msfilter(sk
, gsf
);
583 case IPV6_ROUTER_ALERT
:
584 retv
= ip6_ra_control(sk
, val
, NULL
);
586 case IPV6_MTU_DISCOVER
:
593 if (val
&& val
< IPV6_MIN_MTU
)
599 np
->recverr
= valbool
;
601 skb_queue_purge(&sk
->sk_error_queue
);
604 case IPV6_FLOWINFO_SEND
:
605 np
->sndflow
= valbool
;
608 case IPV6_FLOWLABEL_MGR
:
609 retv
= ipv6_flowlabel_opt(sk
, optval
, optlen
);
611 case IPV6_IPSEC_POLICY
:
612 case IPV6_XFRM_POLICY
:
614 if (!capable(CAP_NET_ADMIN
))
616 retv
= xfrm_user_policy(sk
, optname
, optval
, optlen
);
629 int ipv6_setsockopt(struct sock
*sk
, int level
, int optname
,
630 char __user
*optval
, int optlen
)
634 if (level
== SOL_IP
&& sk
->sk_type
!= SOCK_RAW
)
635 return udp_prot
.setsockopt(sk
, level
, optname
, optval
, optlen
);
637 if (level
!= SOL_IPV6
)
640 err
= do_ipv6_setsockopt(sk
, level
, optname
, optval
, optlen
);
641 #ifdef CONFIG_NETFILTER
642 /* we need to exclude all possible ENOPROTOOPTs except default case */
643 if (err
== -ENOPROTOOPT
&& optname
!= IPV6_IPSEC_POLICY
&&
644 optname
!= IPV6_XFRM_POLICY
) {
646 err
= nf_setsockopt(sk
, PF_INET6
, optname
, optval
,
654 EXPORT_SYMBOL(ipv6_setsockopt
);
657 int compat_ipv6_setsockopt(struct sock
*sk
, int level
, int optname
,
658 char __user
*optval
, int optlen
)
662 if (level
== SOL_IP
&& sk
->sk_type
!= SOCK_RAW
) {
663 if (udp_prot
.compat_setsockopt
!= NULL
)
664 return udp_prot
.compat_setsockopt(sk
, level
, optname
,
666 return udp_prot
.setsockopt(sk
, level
, optname
, optval
, optlen
);
669 if (level
!= SOL_IPV6
)
672 err
= do_ipv6_setsockopt(sk
, level
, optname
, optval
, optlen
);
673 #ifdef CONFIG_NETFILTER
674 /* we need to exclude all possible ENOPROTOOPTs except default case */
675 if (err
== -ENOPROTOOPT
&& optname
!= IPV6_IPSEC_POLICY
&&
676 optname
!= IPV6_XFRM_POLICY
) {
678 err
= compat_nf_setsockopt(sk
, PF_INET6
, optname
,
686 EXPORT_SYMBOL(compat_ipv6_setsockopt
);
689 static int ipv6_getsockopt_sticky(struct sock
*sk
, struct ipv6_txoptions
*opt
,
690 int optname
, char __user
*optval
, int len
)
692 struct ipv6_opt_hdr
*hdr
;
701 case IPV6_RTHDRDSTOPTS
:
705 hdr
= (struct ipv6_opt_hdr
*)opt
->srcrt
;
711 return -EINVAL
; /* should not happen */
717 len
= min_t(unsigned int, len
, ipv6_optlen(hdr
));
718 if (copy_to_user(optval
, hdr
, len
))
720 return ipv6_optlen(hdr
);
723 static int do_ipv6_getsockopt(struct sock
*sk
, int level
, int optname
,
724 char __user
*optval
, int __user
*optlen
)
726 struct ipv6_pinfo
*np
= inet6_sk(sk
);
730 if (get_user(len
, optlen
))
734 if (sk
->sk_protocol
!= IPPROTO_UDP
&&
735 sk
->sk_protocol
!= IPPROTO_UDPLITE
&&
736 sk
->sk_protocol
!= IPPROTO_TCP
)
738 if (sk
->sk_state
!= TCP_ESTABLISHED
)
744 struct group_filter gsf
;
747 if (len
< GROUP_FILTER_SIZE(0))
749 if (copy_from_user(&gsf
, optval
, GROUP_FILTER_SIZE(0)))
752 err
= ip6_mc_msfget(sk
, &gsf
,
753 (struct group_filter __user
*)optval
, optlen
);
758 case IPV6_2292PKTOPTIONS
:
763 if (sk
->sk_type
!= SOCK_STREAM
)
766 msg
.msg_control
= optval
;
767 msg
.msg_controllen
= len
;
771 skb
= np
->pktoptions
;
773 atomic_inc(&skb
->users
);
777 int err
= datagram_recv_ctl(sk
, &msg
, skb
);
782 if (np
->rxopt
.bits
.rxinfo
) {
783 struct in6_pktinfo src_info
;
784 src_info
.ipi6_ifindex
= np
->mcast_oif
;
785 ipv6_addr_copy(&src_info
.ipi6_addr
, &np
->daddr
);
786 put_cmsg(&msg
, SOL_IPV6
, IPV6_PKTINFO
, sizeof(src_info
), &src_info
);
788 if (np
->rxopt
.bits
.rxhlim
) {
789 int hlim
= np
->mcast_hops
;
790 put_cmsg(&msg
, SOL_IPV6
, IPV6_HOPLIMIT
, sizeof(hlim
), &hlim
);
792 if (np
->rxopt
.bits
.rxoinfo
) {
793 struct in6_pktinfo src_info
;
794 src_info
.ipi6_ifindex
= np
->mcast_oif
;
795 ipv6_addr_copy(&src_info
.ipi6_addr
, &np
->daddr
);
796 put_cmsg(&msg
, SOL_IPV6
, IPV6_2292PKTINFO
, sizeof(src_info
), &src_info
);
798 if (np
->rxopt
.bits
.rxohlim
) {
799 int hlim
= np
->mcast_hops
;
800 put_cmsg(&msg
, SOL_IPV6
, IPV6_2292HOPLIMIT
, sizeof(hlim
), &hlim
);
803 len
-= msg
.msg_controllen
;
804 return put_user(len
, optlen
);
808 struct dst_entry
*dst
;
811 dst
= sk_dst_get(sk
);
826 case IPV6_RECVPKTINFO
:
827 val
= np
->rxopt
.bits
.rxinfo
;
830 case IPV6_2292PKTINFO
:
831 val
= np
->rxopt
.bits
.rxoinfo
;
834 case IPV6_RECVHOPLIMIT
:
835 val
= np
->rxopt
.bits
.rxhlim
;
838 case IPV6_2292HOPLIMIT
:
839 val
= np
->rxopt
.bits
.rxohlim
;
843 val
= np
->rxopt
.bits
.srcrt
;
847 val
= np
->rxopt
.bits
.osrcrt
;
851 case IPV6_RTHDRDSTOPTS
:
857 len
= ipv6_getsockopt_sticky(sk
, np
->opt
,
858 optname
, optval
, len
);
860 return put_user(len
, optlen
);
863 case IPV6_RECVHOPOPTS
:
864 val
= np
->rxopt
.bits
.hopopts
;
867 case IPV6_2292HOPOPTS
:
868 val
= np
->rxopt
.bits
.ohopopts
;
871 case IPV6_RECVDSTOPTS
:
872 val
= np
->rxopt
.bits
.dstopts
;
875 case IPV6_2292DSTOPTS
:
876 val
= np
->rxopt
.bits
.odstopts
;
885 case IPV6_RECVTCLASS
:
886 val
= np
->rxopt
.bits
.rxtclass
;
890 val
= np
->rxopt
.bits
.rxflow
;
893 case IPV6_UNICAST_HOPS
:
894 case IPV6_MULTICAST_HOPS
:
896 struct dst_entry
*dst
;
898 if (optname
== IPV6_UNICAST_HOPS
)
901 val
= np
->mcast_hops
;
903 dst
= sk_dst_get(sk
);
906 val
= dst_metric(dst
, RTAX_HOPLIMIT
);
908 val
= ipv6_get_hoplimit(dst
->dev
);
912 val
= ipv6_devconf
.hop_limit
;
916 case IPV6_MULTICAST_LOOP
:
920 case IPV6_MULTICAST_IF
:
924 case IPV6_MTU_DISCOVER
:
932 case IPV6_FLOWINFO_SEND
:
939 len
= min_t(unsigned int, sizeof(int), len
);
940 if(put_user(len
, optlen
))
942 if(copy_to_user(optval
,&val
,len
))
947 int ipv6_getsockopt(struct sock
*sk
, int level
, int optname
,
948 char __user
*optval
, int __user
*optlen
)
952 if (level
== SOL_IP
&& sk
->sk_type
!= SOCK_RAW
)
953 return udp_prot
.getsockopt(sk
, level
, optname
, optval
, optlen
);
955 if(level
!= SOL_IPV6
)
958 err
= do_ipv6_getsockopt(sk
, level
, optname
, optval
, optlen
);
959 #ifdef CONFIG_NETFILTER
960 /* we need to exclude all possible ENOPROTOOPTs except default case */
961 if (err
== -ENOPROTOOPT
&& optname
!= IPV6_2292PKTOPTIONS
) {
964 if (get_user(len
, optlen
))
968 err
= nf_getsockopt(sk
, PF_INET6
, optname
, optval
,
972 err
= put_user(len
, optlen
);
978 EXPORT_SYMBOL(ipv6_getsockopt
);
981 int compat_ipv6_getsockopt(struct sock
*sk
, int level
, int optname
,
982 char __user
*optval
, int __user
*optlen
)
986 if (level
== SOL_IP
&& sk
->sk_type
!= SOCK_RAW
) {
987 if (udp_prot
.compat_getsockopt
!= NULL
)
988 return udp_prot
.compat_getsockopt(sk
, level
, optname
,
990 return udp_prot
.getsockopt(sk
, level
, optname
, optval
, optlen
);
993 if (level
!= SOL_IPV6
)
996 err
= do_ipv6_getsockopt(sk
, level
, optname
, optval
, optlen
);
997 #ifdef CONFIG_NETFILTER
998 /* we need to exclude all possible ENOPROTOOPTs except default case */
999 if (err
== -ENOPROTOOPT
&& optname
!= IPV6_2292PKTOPTIONS
) {
1002 if (get_user(len
, optlen
))
1006 err
= compat_nf_getsockopt(sk
, PF_INET6
,
1007 optname
, optval
, &len
);
1010 err
= put_user(len
, optlen
);
1016 EXPORT_SYMBOL(compat_ipv6_getsockopt
);
This page took 0.064822 seconds and 6 git commands to generate.