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/sched.h>
35 #include <linux/net.h>
36 #include <linux/in6.h>
37 #include <linux/netdevice.h>
38 #include <linux/if_arp.h>
39 #include <linux/init.h>
40 #include <linux/sysctl.h>
41 #include <linux/netfilter.h>
46 #include <net/ndisc.h>
47 #include <net/protocol.h>
48 #include <net/transp_v6.h>
49 #include <net/ip6_route.h>
50 #include <net/addrconf.h>
51 #include <net/inet_common.h>
56 #include <asm/uaccess.h>
58 DEFINE_SNMP_STAT(struct ipstats_mib
, ipv6_statistics
) __read_mostly
;
60 static struct sk_buff
*ipv6_gso_segment(struct sk_buff
*skb
, int features
)
62 struct sk_buff
*segs
= ERR_PTR(-EINVAL
);
63 struct ipv6hdr
*ipv6h
;
64 struct inet6_protocol
*ops
;
67 if (unlikely(skb_shinfo(skb
)->gso_type
&
75 if (unlikely(!pskb_may_pull(skb
, sizeof(*ipv6h
))))
78 ipv6h
= skb
->nh
.ipv6h
;
79 proto
= ipv6h
->nexthdr
;
80 __skb_pull(skb
, sizeof(*ipv6h
));
84 struct ipv6_opt_hdr
*opth
;
87 if (proto
!= NEXTHDR_HOP
) {
88 ops
= rcu_dereference(inet6_protos
[proto
]);
93 if (!(ops
->flags
& INET6_PROTO_GSO_EXTHDR
))
97 if (unlikely(!pskb_may_pull(skb
, 8)))
100 opth
= (void *)skb
->data
;
101 len
= opth
->hdrlen
* 8 + 8;
103 if (unlikely(!pskb_may_pull(skb
, len
)))
106 proto
= opth
->nexthdr
;
107 __skb_pull(skb
, len
);
110 skb
->h
.raw
= skb
->data
;
111 if (likely(ops
->gso_segment
))
112 segs
= ops
->gso_segment(skb
, features
);
117 if (unlikely(IS_ERR(segs
)))
120 for (skb
= segs
; skb
; skb
= skb
->next
) {
121 ipv6h
= skb
->nh
.ipv6h
;
122 ipv6h
->payload_len
= htons(skb
->len
- skb
->mac_len
-
130 static struct packet_type ipv6_packet_type
= {
131 .type
= __constant_htons(ETH_P_IPV6
),
133 .gso_segment
= ipv6_gso_segment
,
136 struct ip6_ra_chain
*ip6_ra_chain
;
137 DEFINE_RWLOCK(ip6_ra_lock
);
139 int ip6_ra_control(struct sock
*sk
, int sel
, void (*destructor
)(struct sock
*))
141 struct ip6_ra_chain
*ra
, *new_ra
, **rap
;
143 /* RA packet may be delivered ONLY to IPPROTO_RAW socket */
144 if (sk
->sk_type
!= SOCK_RAW
|| inet_sk(sk
)->num
!= IPPROTO_RAW
)
147 new_ra
= (sel
>=0) ? kmalloc(sizeof(*new_ra
), GFP_KERNEL
) : NULL
;
149 write_lock_bh(&ip6_ra_lock
);
150 for (rap
= &ip6_ra_chain
; (ra
=*rap
) != NULL
; rap
= &ra
->next
) {
153 write_unlock_bh(&ip6_ra_lock
);
159 write_unlock_bh(&ip6_ra_lock
);
168 if (new_ra
== NULL
) {
169 write_unlock_bh(&ip6_ra_lock
);
174 new_ra
->destructor
= destructor
;
178 write_unlock_bh(&ip6_ra_lock
);
182 static int do_ipv6_setsockopt(struct sock
*sk
, int level
, int optname
,
183 char __user
*optval
, int optlen
)
185 struct ipv6_pinfo
*np
= inet6_sk(sk
);
187 int retv
= -ENOPROTOOPT
;
191 else if (get_user(val
, (int __user
*) optval
))
201 if (val
== PF_INET
) {
202 struct ipv6_txoptions
*opt
;
203 struct sk_buff
*pktopt
;
205 if (sk
->sk_protocol
!= IPPROTO_UDP
&&
206 sk
->sk_protocol
!= IPPROTO_TCP
)
209 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
214 if (ipv6_only_sock(sk
) ||
215 !(ipv6_addr_type(&np
->daddr
) & IPV6_ADDR_MAPPED
)) {
216 retv
= -EADDRNOTAVAIL
;
220 fl6_free_socklist(sk
);
221 ipv6_sock_mc_close(sk
);
224 * Sock is moving from IPv6 to IPv4 (sk_prot), so
225 * remove it from the refcnt debug socks count in the
228 sk_refcnt_debug_dec(sk
);
230 if (sk
->sk_protocol
== IPPROTO_TCP
) {
231 struct inet_connection_sock
*icsk
= inet_csk(sk
);
234 sock_prot_dec_use(sk
->sk_prot
);
235 sock_prot_inc_use(&tcp_prot
);
237 sk
->sk_prot
= &tcp_prot
;
238 icsk
->icsk_af_ops
= &ipv4_specific
;
239 sk
->sk_socket
->ops
= &inet_stream_ops
;
240 sk
->sk_family
= PF_INET
;
241 tcp_sync_mss(sk
, icsk
->icsk_pmtu_cookie
);
244 sock_prot_dec_use(sk
->sk_prot
);
245 sock_prot_inc_use(&udp_prot
);
247 sk
->sk_prot
= &udp_prot
;
248 sk
->sk_socket
->ops
= &inet_dgram_ops
;
249 sk
->sk_family
= PF_INET
;
251 opt
= xchg(&np
->opt
, NULL
);
253 sock_kfree_s(sk
, opt
, opt
->tot_len
);
254 pktopt
= xchg(&np
->pktoptions
, NULL
);
258 sk
->sk_destruct
= inet_sock_destruct
;
260 * ... and add it to the refcnt debug socks count
261 * in the new family. -acme
263 sk_refcnt_debug_inc(sk
);
264 module_put(THIS_MODULE
);
271 if (inet_sk(sk
)->num
)
273 np
->ipv6only
= valbool
;
277 case IPV6_RECVPKTINFO
:
278 np
->rxopt
.bits
.rxinfo
= valbool
;
282 case IPV6_2292PKTINFO
:
283 np
->rxopt
.bits
.rxoinfo
= valbool
;
287 case IPV6_RECVHOPLIMIT
:
288 np
->rxopt
.bits
.rxhlim
= valbool
;
292 case IPV6_2292HOPLIMIT
:
293 np
->rxopt
.bits
.rxohlim
= valbool
;
298 if (val
< 0 || val
> 2)
300 np
->rxopt
.bits
.srcrt
= val
;
305 if (val
< 0 || val
> 2)
307 np
->rxopt
.bits
.osrcrt
= val
;
311 case IPV6_RECVHOPOPTS
:
312 np
->rxopt
.bits
.hopopts
= valbool
;
316 case IPV6_2292HOPOPTS
:
317 np
->rxopt
.bits
.ohopopts
= valbool
;
321 case IPV6_RECVDSTOPTS
:
322 np
->rxopt
.bits
.dstopts
= valbool
;
326 case IPV6_2292DSTOPTS
:
327 np
->rxopt
.bits
.odstopts
= valbool
;
332 if (val
< 0 || val
> 0xff)
338 case IPV6_RECVTCLASS
:
339 np
->rxopt
.bits
.rxtclass
= valbool
;
344 np
->rxopt
.bits
.rxflow
= valbool
;
349 case IPV6_RTHDRDSTOPTS
:
353 struct ipv6_txoptions
*opt
;
357 /* hop-by-hop / destination options are privileged option */
359 if (optname
!= IPV6_RTHDR
&& !capable(CAP_NET_RAW
))
363 if (optlen
& 0x7 || optlen
> 8 * 255)
366 opt
= ipv6_renew_options(sk
, np
->opt
, optname
,
367 (struct ipv6_opt_hdr __user
*)optval
,
374 /* routing header option needs extra check */
375 if (optname
== IPV6_RTHDR
&& opt
->srcrt
) {
376 struct ipv6_rt_hdr
*rthdr
= opt
->srcrt
;
379 if ((rthdr
->hdrlen
& 1) ||
380 (rthdr
->hdrlen
>> 1) != rthdr
->segments_left
)
385 if (inet_sk(sk
)->is_icsk
) {
387 struct inet_connection_sock
*icsk
= inet_csk(sk
);
388 if (!((1 << sk
->sk_state
) &
389 (TCPF_LISTEN
| TCPF_CLOSE
))
390 && inet_sk(sk
)->daddr
!= LOOPBACK4_IPV6
) {
391 icsk
->icsk_ext_hdr_len
=
392 opt
->opt_flen
+ opt
->opt_nflen
;
393 icsk
->icsk_sync_mss(sk
, icsk
->icsk_pmtu_cookie
);
396 opt
= xchg(&np
->opt
, opt
);
399 write_lock(&sk
->sk_dst_lock
);
400 opt
= xchg(&np
->opt
, opt
);
401 write_unlock(&sk
->sk_dst_lock
);
406 sock_kfree_s(sk
, opt
, opt
->tot_len
);
410 case IPV6_2292PKTOPTIONS
:
412 struct ipv6_txoptions
*opt
= NULL
;
417 fl
.fl6_flowlabel
= 0;
418 fl
.oif
= sk
->sk_bound_dev_if
;
423 /* 1K is probably excessive
424 * 1K is surely not enough, 2K per standard header is 16K.
427 if (optlen
> 64*1024)
430 opt
= sock_kmalloc(sk
, sizeof(*opt
) + optlen
, GFP_KERNEL
);
435 memset(opt
, 0, sizeof(*opt
));
436 opt
->tot_len
= sizeof(*opt
) + optlen
;
438 if (copy_from_user(opt
+1, optval
, optlen
))
441 msg
.msg_controllen
= optlen
;
442 msg
.msg_control
= (void*)(opt
+1);
444 retv
= datagram_send_ctl(&msg
, &fl
, opt
, &junk
, &junk
);
449 if (inet_sk(sk
)->is_icsk
) {
451 struct inet_connection_sock
*icsk
= inet_csk(sk
);
452 if (!((1 << sk
->sk_state
) &
453 (TCPF_LISTEN
| TCPF_CLOSE
))
454 && inet_sk(sk
)->daddr
!= LOOPBACK4_IPV6
) {
455 icsk
->icsk_ext_hdr_len
=
456 opt
->opt_flen
+ opt
->opt_nflen
;
457 icsk
->icsk_sync_mss(sk
, icsk
->icsk_pmtu_cookie
);
460 opt
= xchg(&np
->opt
, opt
);
463 write_lock(&sk
->sk_dst_lock
);
464 opt
= xchg(&np
->opt
, opt
);
465 write_unlock(&sk
->sk_dst_lock
);
471 sock_kfree_s(sk
, opt
, opt
->tot_len
);
474 case IPV6_UNICAST_HOPS
:
475 if (val
> 255 || val
< -1)
481 case IPV6_MULTICAST_HOPS
:
482 if (sk
->sk_type
== SOCK_STREAM
)
484 if (val
> 255 || val
< -1)
486 np
->mcast_hops
= val
;
490 case IPV6_MULTICAST_LOOP
:
491 np
->mc_loop
= valbool
;
495 case IPV6_MULTICAST_IF
:
496 if (sk
->sk_type
== SOCK_STREAM
)
498 if (sk
->sk_bound_dev_if
&& sk
->sk_bound_dev_if
!= val
)
501 if (__dev_get_by_index(val
) == NULL
) {
508 case IPV6_ADD_MEMBERSHIP
:
509 case IPV6_DROP_MEMBERSHIP
:
511 struct ipv6_mreq mreq
;
514 if (copy_from_user(&mreq
, optval
, sizeof(struct ipv6_mreq
)))
517 if (optname
== IPV6_ADD_MEMBERSHIP
)
518 retv
= ipv6_sock_mc_join(sk
, mreq
.ipv6mr_ifindex
, &mreq
.ipv6mr_multiaddr
);
520 retv
= ipv6_sock_mc_drop(sk
, mreq
.ipv6mr_ifindex
, &mreq
.ipv6mr_multiaddr
);
523 case IPV6_JOIN_ANYCAST
:
524 case IPV6_LEAVE_ANYCAST
:
526 struct ipv6_mreq mreq
;
528 if (optlen
!= sizeof(struct ipv6_mreq
))
532 if (copy_from_user(&mreq
, optval
, sizeof(struct ipv6_mreq
)))
535 if (optname
== IPV6_JOIN_ANYCAST
)
536 retv
= ipv6_sock_ac_join(sk
, mreq
.ipv6mr_ifindex
, &mreq
.ipv6mr_acaddr
);
538 retv
= ipv6_sock_ac_drop(sk
, mreq
.ipv6mr_ifindex
, &mreq
.ipv6mr_acaddr
);
541 case MCAST_JOIN_GROUP
:
542 case MCAST_LEAVE_GROUP
:
544 struct group_req greq
;
545 struct sockaddr_in6
*psin6
;
548 if (copy_from_user(&greq
, optval
, sizeof(struct group_req
)))
550 if (greq
.gr_group
.ss_family
!= AF_INET6
) {
551 retv
= -EADDRNOTAVAIL
;
554 psin6
= (struct sockaddr_in6
*)&greq
.gr_group
;
555 if (optname
== MCAST_JOIN_GROUP
)
556 retv
= ipv6_sock_mc_join(sk
, greq
.gr_interface
,
559 retv
= ipv6_sock_mc_drop(sk
, greq
.gr_interface
,
563 case MCAST_JOIN_SOURCE_GROUP
:
564 case MCAST_LEAVE_SOURCE_GROUP
:
565 case MCAST_BLOCK_SOURCE
:
566 case MCAST_UNBLOCK_SOURCE
:
568 struct group_source_req greqs
;
571 if (optlen
!= sizeof(struct group_source_req
))
573 if (copy_from_user(&greqs
, optval
, sizeof(greqs
))) {
577 if (greqs
.gsr_group
.ss_family
!= AF_INET6
||
578 greqs
.gsr_source
.ss_family
!= AF_INET6
) {
579 retv
= -EADDRNOTAVAIL
;
582 if (optname
== MCAST_BLOCK_SOURCE
) {
583 omode
= MCAST_EXCLUDE
;
585 } else if (optname
== MCAST_UNBLOCK_SOURCE
) {
586 omode
= MCAST_EXCLUDE
;
588 } else if (optname
== MCAST_JOIN_SOURCE_GROUP
) {
589 struct sockaddr_in6
*psin6
;
591 psin6
= (struct sockaddr_in6
*)&greqs
.gsr_group
;
592 retv
= ipv6_sock_mc_join(sk
, greqs
.gsr_interface
,
594 /* prior join w/ different source is ok */
595 if (retv
&& retv
!= -EADDRINUSE
)
597 omode
= MCAST_INCLUDE
;
599 } else /* MCAST_LEAVE_SOURCE_GROUP */ {
600 omode
= MCAST_INCLUDE
;
603 retv
= ip6_mc_source(add
, omode
, sk
, &greqs
);
608 extern int sysctl_mld_max_msf
;
609 struct group_filter
*gsf
;
611 if (optlen
< GROUP_FILTER_SIZE(0))
613 if (optlen
> sysctl_optmem_max
) {
617 gsf
= kmalloc(optlen
,GFP_KERNEL
);
623 if (copy_from_user(gsf
, optval
, optlen
)) {
627 /* numsrc >= (4G-140)/128 overflow in 32 bits */
628 if (gsf
->gf_numsrc
>= 0x1ffffffU
||
629 gsf
->gf_numsrc
> sysctl_mld_max_msf
) {
634 if (GROUP_FILTER_SIZE(gsf
->gf_numsrc
) > optlen
) {
639 retv
= ip6_mc_msfilter(sk
, gsf
);
644 case IPV6_ROUTER_ALERT
:
645 retv
= ip6_ra_control(sk
, val
, NULL
);
647 case IPV6_MTU_DISCOVER
:
654 if (val
&& val
< IPV6_MIN_MTU
)
660 np
->recverr
= valbool
;
662 skb_queue_purge(&sk
->sk_error_queue
);
665 case IPV6_FLOWINFO_SEND
:
666 np
->sndflow
= valbool
;
669 case IPV6_FLOWLABEL_MGR
:
670 retv
= ipv6_flowlabel_opt(sk
, optval
, optlen
);
672 case IPV6_IPSEC_POLICY
:
673 case IPV6_XFRM_POLICY
:
675 if (!capable(CAP_NET_ADMIN
))
677 retv
= xfrm_user_policy(sk
, optname
, optval
, optlen
);
690 int ipv6_setsockopt(struct sock
*sk
, int level
, int optname
,
691 char __user
*optval
, int optlen
)
695 if (level
== SOL_IP
&& sk
->sk_type
!= SOCK_RAW
)
696 return udp_prot
.setsockopt(sk
, level
, optname
, optval
, optlen
);
698 if (level
!= SOL_IPV6
)
701 err
= do_ipv6_setsockopt(sk
, level
, optname
, optval
, optlen
);
702 #ifdef CONFIG_NETFILTER
703 /* we need to exclude all possible ENOPROTOOPTs except default case */
704 if (err
== -ENOPROTOOPT
&& optname
!= IPV6_IPSEC_POLICY
&&
705 optname
!= IPV6_XFRM_POLICY
) {
707 err
= nf_setsockopt(sk
, PF_INET6
, optname
, optval
,
717 int compat_ipv6_setsockopt(struct sock
*sk
, int level
, int optname
,
718 char __user
*optval
, int optlen
)
722 if (level
== SOL_IP
&& sk
->sk_type
!= SOCK_RAW
) {
723 if (udp_prot
.compat_setsockopt
!= NULL
)
724 return udp_prot
.compat_setsockopt(sk
, level
, optname
,
726 return udp_prot
.setsockopt(sk
, level
, optname
, optval
, optlen
);
729 if (level
!= SOL_IPV6
)
732 err
= do_ipv6_setsockopt(sk
, level
, optname
, optval
, optlen
);
733 #ifdef CONFIG_NETFILTER
734 /* we need to exclude all possible ENOPROTOOPTs except default case */
735 if (err
== -ENOPROTOOPT
&& optname
!= IPV6_IPSEC_POLICY
&&
736 optname
!= IPV6_XFRM_POLICY
) {
738 err
= compat_nf_setsockopt(sk
, PF_INET6
, optname
,
746 EXPORT_SYMBOL(compat_ipv6_setsockopt
);
749 static int ipv6_getsockopt_sticky(struct sock
*sk
, struct ipv6_opt_hdr
*hdr
,
750 char __user
*optval
, int len
)
754 len
= min_t(int, len
, ipv6_optlen(hdr
));
755 if (copy_to_user(optval
, hdr
, ipv6_optlen(hdr
)))
760 static int do_ipv6_getsockopt(struct sock
*sk
, int level
, int optname
,
761 char __user
*optval
, int __user
*optlen
)
763 struct ipv6_pinfo
*np
= inet6_sk(sk
);
767 if (get_user(len
, optlen
))
771 if (sk
->sk_protocol
!= IPPROTO_UDP
&&
772 sk
->sk_protocol
!= IPPROTO_TCP
)
774 if (sk
->sk_state
!= TCP_ESTABLISHED
)
780 struct group_filter gsf
;
783 if (len
< GROUP_FILTER_SIZE(0))
785 if (copy_from_user(&gsf
, optval
, GROUP_FILTER_SIZE(0)))
788 err
= ip6_mc_msfget(sk
, &gsf
,
789 (struct group_filter __user
*)optval
, optlen
);
794 case IPV6_2292PKTOPTIONS
:
799 if (sk
->sk_type
!= SOCK_STREAM
)
802 msg
.msg_control
= optval
;
803 msg
.msg_controllen
= len
;
807 skb
= np
->pktoptions
;
809 atomic_inc(&skb
->users
);
813 int err
= datagram_recv_ctl(sk
, &msg
, skb
);
818 if (np
->rxopt
.bits
.rxinfo
) {
819 struct in6_pktinfo src_info
;
820 src_info
.ipi6_ifindex
= np
->mcast_oif
;
821 ipv6_addr_copy(&src_info
.ipi6_addr
, &np
->daddr
);
822 put_cmsg(&msg
, SOL_IPV6
, IPV6_PKTINFO
, sizeof(src_info
), &src_info
);
824 if (np
->rxopt
.bits
.rxhlim
) {
825 int hlim
= np
->mcast_hops
;
826 put_cmsg(&msg
, SOL_IPV6
, IPV6_HOPLIMIT
, sizeof(hlim
), &hlim
);
828 if (np
->rxopt
.bits
.rxoinfo
) {
829 struct in6_pktinfo src_info
;
830 src_info
.ipi6_ifindex
= np
->mcast_oif
;
831 ipv6_addr_copy(&src_info
.ipi6_addr
, &np
->daddr
);
832 put_cmsg(&msg
, SOL_IPV6
, IPV6_2292PKTINFO
, sizeof(src_info
), &src_info
);
834 if (np
->rxopt
.bits
.rxohlim
) {
835 int hlim
= np
->mcast_hops
;
836 put_cmsg(&msg
, SOL_IPV6
, IPV6_2292HOPLIMIT
, sizeof(hlim
), &hlim
);
839 len
-= msg
.msg_controllen
;
840 return put_user(len
, optlen
);
844 struct dst_entry
*dst
;
847 dst
= sk_dst_get(sk
);
862 case IPV6_RECVPKTINFO
:
863 val
= np
->rxopt
.bits
.rxinfo
;
866 case IPV6_2292PKTINFO
:
867 val
= np
->rxopt
.bits
.rxoinfo
;
870 case IPV6_RECVHOPLIMIT
:
871 val
= np
->rxopt
.bits
.rxhlim
;
874 case IPV6_2292HOPLIMIT
:
875 val
= np
->rxopt
.bits
.rxohlim
;
879 val
= np
->rxopt
.bits
.srcrt
;
883 val
= np
->rxopt
.bits
.osrcrt
;
887 case IPV6_RTHDRDSTOPTS
:
893 len
= ipv6_getsockopt_sticky(sk
, np
->opt
->hopopt
,
896 return put_user(len
, optlen
);
899 case IPV6_RECVHOPOPTS
:
900 val
= np
->rxopt
.bits
.hopopts
;
903 case IPV6_2292HOPOPTS
:
904 val
= np
->rxopt
.bits
.ohopopts
;
907 case IPV6_RECVDSTOPTS
:
908 val
= np
->rxopt
.bits
.dstopts
;
911 case IPV6_2292DSTOPTS
:
912 val
= np
->rxopt
.bits
.odstopts
;
919 case IPV6_RECVTCLASS
:
920 val
= np
->rxopt
.bits
.rxtclass
;
924 val
= np
->rxopt
.bits
.rxflow
;
927 case IPV6_UNICAST_HOPS
:
931 case IPV6_MULTICAST_HOPS
:
932 val
= np
->mcast_hops
;
935 case IPV6_MULTICAST_LOOP
:
939 case IPV6_MULTICAST_IF
:
943 case IPV6_MTU_DISCOVER
:
951 case IPV6_FLOWINFO_SEND
:
958 len
= min_t(unsigned int, sizeof(int), len
);
959 if(put_user(len
, optlen
))
961 if(copy_to_user(optval
,&val
,len
))
966 int ipv6_getsockopt(struct sock
*sk
, int level
, int optname
,
967 char __user
*optval
, int __user
*optlen
)
971 if (level
== SOL_IP
&& sk
->sk_type
!= SOCK_RAW
)
972 return udp_prot
.getsockopt(sk
, level
, optname
, optval
, optlen
);
974 if(level
!= SOL_IPV6
)
977 err
= do_ipv6_getsockopt(sk
, level
, optname
, optval
, optlen
);
978 #ifdef CONFIG_NETFILTER
979 /* we need to exclude all possible EINVALs except default case */
980 if (err
== -EINVAL
&& optname
!= IPV6_ADDRFORM
&&
981 optname
!= MCAST_MSFILTER
) {
984 if (get_user(len
, optlen
))
988 err
= nf_getsockopt(sk
, PF_INET6
, optname
, optval
,
992 err
= put_user(len
, optlen
);
999 int compat_ipv6_getsockopt(struct sock
*sk
, int level
, int optname
,
1000 char __user
*optval
, int __user
*optlen
)
1004 if (level
== SOL_IP
&& sk
->sk_type
!= SOCK_RAW
) {
1005 if (udp_prot
.compat_getsockopt
!= NULL
)
1006 return udp_prot
.compat_getsockopt(sk
, level
, optname
,
1008 return udp_prot
.getsockopt(sk
, level
, optname
, optval
, optlen
);
1011 if (level
!= SOL_IPV6
)
1012 return -ENOPROTOOPT
;
1014 err
= do_ipv6_getsockopt(sk
, level
, optname
, optval
, optlen
);
1015 #ifdef CONFIG_NETFILTER
1016 /* we need to exclude all possible EINVALs except default case */
1017 if (err
== -EINVAL
&& optname
!= IPV6_ADDRFORM
&&
1018 optname
!= MCAST_MSFILTER
) {
1021 if (get_user(len
, optlen
))
1025 err
= compat_nf_getsockopt(sk
, PF_INET6
,
1026 optname
, optval
, &len
);
1029 err
= put_user(len
, optlen
);
1035 EXPORT_SYMBOL(compat_ipv6_getsockopt
);
1038 void __init
ipv6_packet_init(void)
1040 dev_add_pack(&ipv6_packet_type
);
1043 void ipv6_packet_cleanup(void)
1045 dev_remove_pack(&ipv6_packet_type
);