3 * Linux INET6 implementation
6 * Pedro Roque <roque@di.fc.ul.pt>
8 * Adapted from linux/net/ipv4/raw.c
11 * Hideaki YOSHIFUJI : sin6_scope_id support
12 * YOSHIFUJI,H.@USAGI : raw checksum (RFC2292(bis) compliance)
13 * Kazunori MIYAZAWA @USAGI: change process style to use ip6_append_data
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version
18 * 2 of the License, or (at your option) any later version.
21 #include <linux/errno.h>
22 #include <linux/types.h>
23 #include <linux/socket.h>
24 #include <linux/sockios.h>
25 #include <linux/net.h>
26 #include <linux/in6.h>
27 #include <linux/netdevice.h>
28 #include <linux/if_arp.h>
29 #include <linux/icmpv6.h>
30 #include <linux/netfilter.h>
31 #include <linux/netfilter_ipv6.h>
32 #include <linux/skbuff.h>
33 #include <asm/uaccess.h>
34 #include <asm/ioctls.h>
36 #include <net/net_namespace.h>
42 #include <net/ndisc.h>
43 #include <net/protocol.h>
44 #include <net/ip6_route.h>
45 #include <net/ip6_checksum.h>
46 #include <net/addrconf.h>
47 #include <net/transp_v6.h>
49 #include <net/inet_common.h>
50 #include <net/tcp_states.h>
51 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
54 #include <linux/mroute6.h>
57 #include <net/rawv6.h>
60 #include <linux/proc_fs.h>
61 #include <linux/seq_file.h>
63 static struct raw_hashinfo raw_v6_hashinfo
= {
64 .lock
= __RW_LOCK_UNLOCKED(raw_v6_hashinfo
.lock
),
67 static struct sock
*__raw_v6_lookup(struct net
*net
, struct sock
*sk
,
68 unsigned short num
, struct in6_addr
*loc_addr
,
69 struct in6_addr
*rmt_addr
, int dif
)
71 struct hlist_node
*node
;
72 int is_multicast
= ipv6_addr_is_multicast(loc_addr
);
74 sk_for_each_from(sk
, node
)
75 if (inet_sk(sk
)->num
== num
) {
76 struct ipv6_pinfo
*np
= inet6_sk(sk
);
78 if (!net_eq(sock_net(sk
), net
))
81 if (!ipv6_addr_any(&np
->daddr
) &&
82 !ipv6_addr_equal(&np
->daddr
, rmt_addr
))
85 if (sk
->sk_bound_dev_if
&& sk
->sk_bound_dev_if
!= dif
)
88 if (!ipv6_addr_any(&np
->rcv_saddr
)) {
89 if (ipv6_addr_equal(&np
->rcv_saddr
, loc_addr
))
92 inet6_mc_check(sk
, loc_addr
, rmt_addr
))
107 static __inline__
int icmpv6_filter(struct sock
*sk
, struct sk_buff
*skb
)
109 struct icmp6hdr
*icmph
;
110 struct raw6_sock
*rp
= raw6_sk(sk
);
112 if (pskb_may_pull(skb
, sizeof(struct icmp6hdr
))) {
113 __u32
*data
= &rp
->filter
.data
[0];
116 icmph
= (struct icmp6hdr
*) skb
->data
;
117 bit_nr
= icmph
->icmp6_type
;
119 return (data
[bit_nr
>> 5] & (1 << (bit_nr
& 31))) != 0;
124 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
125 static int (*mh_filter
)(struct sock
*sock
, struct sk_buff
*skb
);
127 int rawv6_mh_filter_register(int (*filter
)(struct sock
*sock
,
128 struct sk_buff
*skb
))
130 rcu_assign_pointer(mh_filter
, filter
);
133 EXPORT_SYMBOL(rawv6_mh_filter_register
);
135 int rawv6_mh_filter_unregister(int (*filter
)(struct sock
*sock
,
136 struct sk_buff
*skb
))
138 rcu_assign_pointer(mh_filter
, NULL
);
142 EXPORT_SYMBOL(rawv6_mh_filter_unregister
);
147 * demultiplex raw sockets.
148 * (should consider queueing the skb in the sock receive_queue
149 * without calling rawv6.c)
151 * Caller owns SKB so we must make clones.
153 static int ipv6_raw_deliver(struct sk_buff
*skb
, int nexthdr
)
155 struct in6_addr
*saddr
;
156 struct in6_addr
*daddr
;
162 saddr
= &ipv6_hdr(skb
)->saddr
;
165 hash
= nexthdr
& (MAX_INET_PROTOS
- 1);
167 read_lock(&raw_v6_hashinfo
.lock
);
168 sk
= sk_head(&raw_v6_hashinfo
.ht
[hash
]);
173 net
= dev_net(skb
->dev
);
174 sk
= __raw_v6_lookup(net
, sk
, nexthdr
, daddr
, saddr
, IP6CB(skb
)->iif
);
182 filtered
= icmpv6_filter(sk
, skb
);
185 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
188 /* XXX: To validate MH only once for each packet,
189 * this is placed here. It should be after checking
190 * xfrm policy, however it doesn't. The checking xfrm
191 * policy is placed in rawv6_rcv() because it is
192 * required for each socket.
194 int (*filter
)(struct sock
*sock
, struct sk_buff
*skb
);
196 filter
= rcu_dereference(mh_filter
);
197 filtered
= filter
? filter(sk
, skb
) : 0;
209 struct sk_buff
*clone
= skb_clone(skb
, GFP_ATOMIC
);
211 /* Not releasing hash table! */
214 rawv6_rcv(sk
, clone
);
217 sk
= __raw_v6_lookup(net
, sk_next(sk
), nexthdr
, daddr
, saddr
,
221 read_unlock(&raw_v6_hashinfo
.lock
);
225 int raw6_local_deliver(struct sk_buff
*skb
, int nexthdr
)
229 raw_sk
= sk_head(&raw_v6_hashinfo
.ht
[nexthdr
& (MAX_INET_PROTOS
- 1)]);
230 if (raw_sk
&& !ipv6_raw_deliver(skb
, nexthdr
))
233 return raw_sk
!= NULL
;
236 /* This cleans up af_inet6 a bit. -DaveM */
237 static int rawv6_bind(struct sock
*sk
, struct sockaddr
*uaddr
, int addr_len
)
239 struct inet_sock
*inet
= inet_sk(sk
);
240 struct ipv6_pinfo
*np
= inet6_sk(sk
);
241 struct sockaddr_in6
*addr
= (struct sockaddr_in6
*) uaddr
;
246 if (addr_len
< SIN6_LEN_RFC2133
)
248 addr_type
= ipv6_addr_type(&addr
->sin6_addr
);
250 /* Raw sockets are IPv6 only */
251 if (addr_type
== IPV6_ADDR_MAPPED
)
252 return(-EADDRNOTAVAIL
);
257 if (sk
->sk_state
!= TCP_CLOSE
)
260 /* Check if the address belongs to the host. */
261 if (addr_type
!= IPV6_ADDR_ANY
) {
262 struct net_device
*dev
= NULL
;
264 if (addr_type
& IPV6_ADDR_LINKLOCAL
) {
265 if (addr_len
>= sizeof(struct sockaddr_in6
) &&
266 addr
->sin6_scope_id
) {
267 /* Override any existing binding, if another
268 * one is supplied by user.
270 sk
->sk_bound_dev_if
= addr
->sin6_scope_id
;
273 /* Binding to link-local address requires an interface */
274 if (!sk
->sk_bound_dev_if
)
277 dev
= dev_get_by_index(sock_net(sk
), sk
->sk_bound_dev_if
);
284 /* ipv4 addr of the socket is invalid. Only the
285 * unspecified and mapped address have a v4 equivalent.
287 v4addr
= LOOPBACK4_IPV6
;
288 if (!(addr_type
& IPV6_ADDR_MULTICAST
)) {
289 err
= -EADDRNOTAVAIL
;
290 if (!ipv6_chk_addr(sock_net(sk
), &addr
->sin6_addr
,
301 inet
->rcv_saddr
= inet
->saddr
= v4addr
;
302 ipv6_addr_copy(&np
->rcv_saddr
, &addr
->sin6_addr
);
303 if (!(addr_type
& IPV6_ADDR_MULTICAST
))
304 ipv6_addr_copy(&np
->saddr
, &addr
->sin6_addr
);
311 static void rawv6_err(struct sock
*sk
, struct sk_buff
*skb
,
312 struct inet6_skb_parm
*opt
,
313 u8 type
, u8 code
, int offset
, __be32 info
)
315 struct inet_sock
*inet
= inet_sk(sk
);
316 struct ipv6_pinfo
*np
= inet6_sk(sk
);
320 /* Report error on raw socket, if:
321 1. User requested recverr.
322 2. Socket is connected (otherwise the error indication
323 is useless without recverr and error is hard.
325 if (!np
->recverr
&& sk
->sk_state
!= TCP_ESTABLISHED
)
328 harderr
= icmpv6_err_convert(type
, code
, &err
);
329 if (type
== ICMPV6_PKT_TOOBIG
)
330 harderr
= (np
->pmtudisc
== IPV6_PMTUDISC_DO
);
333 u8
*payload
= skb
->data
;
336 ipv6_icmp_error(sk
, skb
, err
, 0, ntohl(info
), payload
);
339 if (np
->recverr
|| harderr
) {
341 sk
->sk_error_report(sk
);
345 void raw6_icmp_error(struct sk_buff
*skb
, int nexthdr
,
346 u8 type
, u8 code
, int inner_offset
, __be32 info
)
350 struct in6_addr
*saddr
, *daddr
;
353 hash
= nexthdr
& (RAW_HTABLE_SIZE
- 1);
355 read_lock(&raw_v6_hashinfo
.lock
);
356 sk
= sk_head(&raw_v6_hashinfo
.ht
[hash
]);
358 /* Note: ipv6_hdr(skb) != skb->data */
359 struct ipv6hdr
*ip6h
= (struct ipv6hdr
*)skb
->data
;
360 saddr
= &ip6h
->saddr
;
361 daddr
= &ip6h
->daddr
;
362 net
= dev_net(skb
->dev
);
364 while ((sk
= __raw_v6_lookup(net
, sk
, nexthdr
, saddr
, daddr
,
366 rawv6_err(sk
, skb
, NULL
, type
, code
,
371 read_unlock(&raw_v6_hashinfo
.lock
);
374 static inline int rawv6_rcv_skb(struct sock
* sk
, struct sk_buff
* skb
)
376 if ((raw6_sk(sk
)->checksum
|| sk
->sk_filter
) &&
377 skb_checksum_complete(skb
)) {
378 atomic_inc(&sk
->sk_drops
);
383 /* Charge it to the socket. */
384 if (sock_queue_rcv_skb(sk
,skb
)<0) {
385 atomic_inc(&sk
->sk_drops
);
394 * This is next to useless...
395 * if we demultiplex in network layer we don't need the extra call
396 * just to queue the skb...
397 * maybe we could have the network decide upon a hint if it
398 * should call raw_rcv for demultiplexing
400 int rawv6_rcv(struct sock
*sk
, struct sk_buff
*skb
)
402 struct inet_sock
*inet
= inet_sk(sk
);
403 struct raw6_sock
*rp
= raw6_sk(sk
);
405 if (!xfrm6_policy_check(sk
, XFRM_POLICY_IN
, skb
)) {
406 atomic_inc(&sk
->sk_drops
);
412 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
414 if (skb
->ip_summed
== CHECKSUM_COMPLETE
) {
415 skb_postpull_rcsum(skb
, skb_network_header(skb
),
416 skb_network_header_len(skb
));
417 if (!csum_ipv6_magic(&ipv6_hdr(skb
)->saddr
,
418 &ipv6_hdr(skb
)->daddr
,
419 skb
->len
, inet
->num
, skb
->csum
))
420 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
422 if (!skb_csum_unnecessary(skb
))
423 skb
->csum
= ~csum_unfold(csum_ipv6_magic(&ipv6_hdr(skb
)->saddr
,
424 &ipv6_hdr(skb
)->daddr
,
429 if (skb_checksum_complete(skb
)) {
430 atomic_inc(&sk
->sk_drops
);
436 rawv6_rcv_skb(sk
, skb
);
442 * This should be easy, if there is something there
443 * we return it, otherwise we block.
446 static int rawv6_recvmsg(struct kiocb
*iocb
, struct sock
*sk
,
447 struct msghdr
*msg
, size_t len
,
448 int noblock
, int flags
, int *addr_len
)
450 struct ipv6_pinfo
*np
= inet6_sk(sk
);
451 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)msg
->msg_name
;
460 *addr_len
=sizeof(*sin6
);
462 if (flags
& MSG_ERRQUEUE
)
463 return ipv6_recv_error(sk
, msg
, len
);
465 skb
= skb_recv_datagram(sk
, flags
, noblock
, &err
);
472 msg
->msg_flags
|= MSG_TRUNC
;
475 if (skb_csum_unnecessary(skb
)) {
476 err
= skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, copied
);
477 } else if (msg
->msg_flags
&MSG_TRUNC
) {
478 if (__skb_checksum_complete(skb
))
480 err
= skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, copied
);
482 err
= skb_copy_and_csum_datagram_iovec(skb
, 0, msg
->msg_iov
);
489 /* Copy the address. */
491 sin6
->sin6_family
= AF_INET6
;
493 ipv6_addr_copy(&sin6
->sin6_addr
, &ipv6_hdr(skb
)->saddr
);
494 sin6
->sin6_flowinfo
= 0;
495 sin6
->sin6_scope_id
= 0;
496 if (ipv6_addr_type(&sin6
->sin6_addr
) & IPV6_ADDR_LINKLOCAL
)
497 sin6
->sin6_scope_id
= IP6CB(skb
)->iif
;
500 sock_recv_timestamp(msg
, sk
, skb
);
503 datagram_recv_ctl(sk
, msg
, skb
);
506 if (flags
& MSG_TRUNC
)
510 skb_free_datagram(sk
, skb
);
515 skb_kill_datagram(sk
, skb
, flags
);
517 /* Error for blocking case is chosen to masquerade
518 as some normal condition.
520 err
= (flags
&MSG_DONTWAIT
) ? -EAGAIN
: -EHOSTUNREACH
;
521 atomic_inc(&sk
->sk_drops
);
525 static int rawv6_push_pending_frames(struct sock
*sk
, struct flowi
*fl
,
526 struct raw6_sock
*rp
)
539 if ((skb
= skb_peek(&sk
->sk_write_queue
)) == NULL
)
543 total_len
= inet_sk(sk
)->cork
.length
- (skb_network_header(skb
) -
545 if (offset
>= total_len
- 1) {
547 ip6_flush_pending_frames(sk
);
551 /* should be check HW csum miyazawa */
552 if (skb_queue_len(&sk
->sk_write_queue
) == 1) {
554 * Only one fragment on the socket.
556 tmp_csum
= skb
->csum
;
558 struct sk_buff
*csum_skb
= NULL
;
561 skb_queue_walk(&sk
->sk_write_queue
, skb
) {
562 tmp_csum
= csum_add(tmp_csum
, skb
->csum
);
567 len
= skb
->len
- skb_transport_offset(skb
);
579 offset
+= skb_transport_offset(skb
);
580 if (skb_copy_bits(skb
, offset
, &csum
, 2))
583 /* in case cksum was not initialized */
585 tmp_csum
= csum_sub(tmp_csum
, csum_unfold(csum
));
587 csum
= csum_ipv6_magic(&fl
->fl6_src
,
589 total_len
, fl
->proto
, tmp_csum
);
591 if (csum
== 0 && fl
->proto
== IPPROTO_UDP
)
592 csum
= CSUM_MANGLED_0
;
594 if (skb_store_bits(skb
, offset
, &csum
, 2))
598 err
= ip6_push_pending_frames(sk
);
603 static int rawv6_send_hdrinc(struct sock
*sk
, void *from
, int length
,
604 struct flowi
*fl
, struct rt6_info
*rt
,
607 struct ipv6_pinfo
*np
= inet6_sk(sk
);
612 if (length
> rt
->u
.dst
.dev
->mtu
) {
613 ipv6_local_error(sk
, EMSGSIZE
, fl
, rt
->u
.dst
.dev
->mtu
);
619 skb
= sock_alloc_send_skb(sk
,
620 length
+ LL_ALLOCATED_SPACE(rt
->u
.dst
.dev
) + 15,
621 flags
& MSG_DONTWAIT
, &err
);
624 skb_reserve(skb
, LL_RESERVED_SPACE(rt
->u
.dst
.dev
));
626 skb
->priority
= sk
->sk_priority
;
627 skb
->mark
= sk
->sk_mark
;
628 skb_dst_set(skb
, dst_clone(&rt
->u
.dst
));
630 skb_put(skb
, length
);
631 skb_reset_network_header(skb
);
634 skb
->ip_summed
= CHECKSUM_NONE
;
636 skb
->transport_header
= skb
->network_header
;
637 err
= memcpy_fromiovecend((void *)iph
, from
, 0, length
);
641 IP6_UPD_PO_STATS(sock_net(sk
), rt
->rt6i_idev
, IPSTATS_MIB_OUT
, skb
->len
);
642 err
= NF_HOOK(PF_INET6
, NF_INET_LOCAL_OUT
, skb
, NULL
, rt
->u
.dst
.dev
,
645 err
= np
->recverr
? net_xmit_errno(err
) : 0;
655 IP6_INC_STATS(sock_net(sk
), rt
->rt6i_idev
, IPSTATS_MIB_OUTDISCARDS
);
659 static int rawv6_probe_proto_opt(struct flowi
*fl
, struct msghdr
*msg
)
662 u8 __user
*type
= NULL
;
663 u8 __user
*code
= NULL
;
671 for (i
= 0; i
< msg
->msg_iovlen
; i
++) {
672 iov
= &msg
->msg_iov
[i
];
678 /* check if one-byte field is readable or not. */
679 if (iov
->iov_base
&& iov
->iov_len
< 1)
683 type
= iov
->iov_base
;
684 /* check if code field is readable or not. */
685 if (iov
->iov_len
> 1)
688 code
= iov
->iov_base
;
691 if (get_user(fl
->fl_icmp_type
, type
) ||
692 get_user(fl
->fl_icmp_code
, code
))
698 if (iov
->iov_base
&& iov
->iov_len
< 1)
700 /* check if type field is readable or not. */
701 if (iov
->iov_len
> 2 - len
) {
702 u8 __user
*p
= iov
->iov_base
;
703 if (get_user(fl
->fl_mh_type
, &p
[2 - len
]))
720 static int rawv6_sendmsg(struct kiocb
*iocb
, struct sock
*sk
,
721 struct msghdr
*msg
, size_t len
)
723 struct ipv6_txoptions opt_space
;
724 struct sockaddr_in6
* sin6
= (struct sockaddr_in6
*) msg
->msg_name
;
725 struct in6_addr
*daddr
, *final_p
= NULL
, final
;
726 struct inet_sock
*inet
= inet_sk(sk
);
727 struct ipv6_pinfo
*np
= inet6_sk(sk
);
728 struct raw6_sock
*rp
= raw6_sk(sk
);
729 struct ipv6_txoptions
*opt
= NULL
;
730 struct ip6_flowlabel
*flowlabel
= NULL
;
731 struct dst_entry
*dst
= NULL
;
733 int addr_len
= msg
->msg_namelen
;
739 /* Rough check on arithmetic overflow,
740 better check is made in ip6_append_data().
745 /* Mirror BSD error message compatibility */
746 if (msg
->msg_flags
& MSG_OOB
)
750 * Get and verify the address.
752 memset(&fl
, 0, sizeof(fl
));
754 fl
.mark
= sk
->sk_mark
;
757 if (addr_len
< SIN6_LEN_RFC2133
)
760 if (sin6
->sin6_family
&& sin6
->sin6_family
!= AF_INET6
)
761 return(-EAFNOSUPPORT
);
763 /* port is the proto value [0..255] carried in nexthdr */
764 proto
= ntohs(sin6
->sin6_port
);
768 else if (proto
!= inet
->num
)
774 daddr
= &sin6
->sin6_addr
;
776 fl
.fl6_flowlabel
= sin6
->sin6_flowinfo
&IPV6_FLOWINFO_MASK
;
777 if (fl
.fl6_flowlabel
&IPV6_FLOWLABEL_MASK
) {
778 flowlabel
= fl6_sock_lookup(sk
, fl
.fl6_flowlabel
);
779 if (flowlabel
== NULL
)
781 daddr
= &flowlabel
->dst
;
786 * Otherwise it will be difficult to maintain
789 if (sk
->sk_state
== TCP_ESTABLISHED
&&
790 ipv6_addr_equal(daddr
, &np
->daddr
))
793 if (addr_len
>= sizeof(struct sockaddr_in6
) &&
794 sin6
->sin6_scope_id
&&
795 ipv6_addr_type(daddr
)&IPV6_ADDR_LINKLOCAL
)
796 fl
.oif
= sin6
->sin6_scope_id
;
798 if (sk
->sk_state
!= TCP_ESTABLISHED
)
799 return -EDESTADDRREQ
;
803 fl
.fl6_flowlabel
= np
->flow_label
;
807 fl
.oif
= sk
->sk_bound_dev_if
;
809 if (msg
->msg_controllen
) {
811 memset(opt
, 0, sizeof(struct ipv6_txoptions
));
812 opt
->tot_len
= sizeof(struct ipv6_txoptions
);
814 err
= datagram_send_ctl(sock_net(sk
), msg
, &fl
, opt
, &hlimit
, &tclass
);
816 fl6_sock_release(flowlabel
);
819 if ((fl
.fl6_flowlabel
&IPV6_FLOWLABEL_MASK
) && !flowlabel
) {
820 flowlabel
= fl6_sock_lookup(sk
, fl
.fl6_flowlabel
);
821 if (flowlabel
== NULL
)
824 if (!(opt
->opt_nflen
|opt
->opt_flen
))
830 opt
= fl6_merge_options(&opt_space
, flowlabel
, opt
);
831 opt
= ipv6_fixup_options(&opt_space
, opt
);
834 err
= rawv6_probe_proto_opt(&fl
, msg
);
838 if (!ipv6_addr_any(daddr
))
839 ipv6_addr_copy(&fl
.fl6_dst
, daddr
);
841 fl
.fl6_dst
.s6_addr
[15] = 0x1; /* :: means loopback (BSD'ism) */
842 if (ipv6_addr_any(&fl
.fl6_src
) && !ipv6_addr_any(&np
->saddr
))
843 ipv6_addr_copy(&fl
.fl6_src
, &np
->saddr
);
845 /* merge ip6_build_xmit from ip6_output */
846 if (opt
&& opt
->srcrt
) {
847 struct rt0_hdr
*rt0
= (struct rt0_hdr
*) opt
->srcrt
;
848 ipv6_addr_copy(&final
, &fl
.fl6_dst
);
849 ipv6_addr_copy(&fl
.fl6_dst
, rt0
->addr
);
853 if (!fl
.oif
&& ipv6_addr_is_multicast(&fl
.fl6_dst
))
854 fl
.oif
= np
->mcast_oif
;
855 security_sk_classify_flow(sk
, &fl
);
857 err
= ip6_dst_lookup(sk
, &dst
, &fl
);
861 ipv6_addr_copy(&fl
.fl6_dst
, final_p
);
863 err
= __xfrm_lookup(sock_net(sk
), &dst
, &fl
, sk
, XFRM_LOOKUP_WAIT
);
866 err
= ip6_dst_blackhole(sk
, &dst
, &fl
);
872 if (ipv6_addr_is_multicast(&fl
.fl6_dst
))
873 hlimit
= np
->mcast_hops
;
875 hlimit
= np
->hop_limit
;
877 hlimit
= ip6_dst_hoplimit(dst
);
883 if (msg
->msg_flags
&MSG_CONFIRM
)
888 err
= rawv6_send_hdrinc(sk
, msg
->msg_iov
, len
, &fl
, (struct rt6_info
*)dst
, msg
->msg_flags
);
891 err
= ip6_append_data(sk
, ip_generic_getfrag
, msg
->msg_iov
,
892 len
, 0, hlimit
, tclass
, opt
, &fl
, (struct rt6_info
*)dst
,
896 ip6_flush_pending_frames(sk
);
897 else if (!(msg
->msg_flags
& MSG_MORE
))
898 err
= rawv6_push_pending_frames(sk
, &fl
, rp
);
904 fl6_sock_release(flowlabel
);
905 return err
<0?err
:len
;
908 if (!(msg
->msg_flags
& MSG_PROBE
) || len
)
909 goto back_from_confirm
;
914 static int rawv6_seticmpfilter(struct sock
*sk
, int level
, int optname
,
915 char __user
*optval
, int optlen
)
919 if (optlen
> sizeof(struct icmp6_filter
))
920 optlen
= sizeof(struct icmp6_filter
);
921 if (copy_from_user(&raw6_sk(sk
)->filter
, optval
, optlen
))
931 static int rawv6_geticmpfilter(struct sock
*sk
, int level
, int optname
,
932 char __user
*optval
, int __user
*optlen
)
938 if (get_user(len
, optlen
))
942 if (len
> sizeof(struct icmp6_filter
))
943 len
= sizeof(struct icmp6_filter
);
944 if (put_user(len
, optlen
))
946 if (copy_to_user(optval
, &raw6_sk(sk
)->filter
, len
))
957 static int do_rawv6_setsockopt(struct sock
*sk
, int level
, int optname
,
958 char __user
*optval
, int optlen
)
960 struct raw6_sock
*rp
= raw6_sk(sk
);
963 if (get_user(val
, (int __user
*)optval
))
968 if (inet_sk(sk
)->num
== IPPROTO_ICMPV6
&&
969 level
== IPPROTO_IPV6
) {
971 * RFC3542 tells that IPV6_CHECKSUM socket
972 * option in the IPPROTO_IPV6 level is not
973 * allowed on ICMPv6 sockets.
974 * If you want to set it, use IPPROTO_RAW
975 * level IPV6_CHECKSUM socket option
981 /* You may get strange result with a positive odd offset;
982 RFC2292bis agrees with me. */
983 if (val
> 0 && (val
&1))
996 return(-ENOPROTOOPT
);
1000 static int rawv6_setsockopt(struct sock
*sk
, int level
, int optname
,
1001 char __user
*optval
, int optlen
)
1008 if (inet_sk(sk
)->num
!= IPPROTO_ICMPV6
)
1010 return rawv6_seticmpfilter(sk
, level
, optname
, optval
,
1013 if (optname
== IPV6_CHECKSUM
)
1016 return ipv6_setsockopt(sk
, level
, optname
, optval
,
1020 return do_rawv6_setsockopt(sk
, level
, optname
, optval
, optlen
);
1023 #ifdef CONFIG_COMPAT
1024 static int compat_rawv6_setsockopt(struct sock
*sk
, int level
, int optname
,
1025 char __user
*optval
, int optlen
)
1031 if (inet_sk(sk
)->num
!= IPPROTO_ICMPV6
)
1033 return rawv6_seticmpfilter(sk
, level
, optname
, optval
, optlen
);
1035 if (optname
== IPV6_CHECKSUM
)
1038 return compat_ipv6_setsockopt(sk
, level
, optname
,
1041 return do_rawv6_setsockopt(sk
, level
, optname
, optval
, optlen
);
1045 static int do_rawv6_getsockopt(struct sock
*sk
, int level
, int optname
,
1046 char __user
*optval
, int __user
*optlen
)
1048 struct raw6_sock
*rp
= raw6_sk(sk
);
1051 if (get_user(len
,optlen
))
1057 * We allow getsockopt() for IPPROTO_IPV6-level
1058 * IPV6_CHECKSUM socket option on ICMPv6 sockets
1059 * since RFC3542 is silent about it.
1061 if (rp
->checksum
== 0)
1068 return -ENOPROTOOPT
;
1071 len
= min_t(unsigned int, sizeof(int), len
);
1073 if (put_user(len
, optlen
))
1075 if (copy_to_user(optval
,&val
,len
))
1080 static int rawv6_getsockopt(struct sock
*sk
, int level
, int optname
,
1081 char __user
*optval
, int __user
*optlen
)
1088 if (inet_sk(sk
)->num
!= IPPROTO_ICMPV6
)
1090 return rawv6_geticmpfilter(sk
, level
, optname
, optval
,
1093 if (optname
== IPV6_CHECKSUM
)
1096 return ipv6_getsockopt(sk
, level
, optname
, optval
,
1100 return do_rawv6_getsockopt(sk
, level
, optname
, optval
, optlen
);
1103 #ifdef CONFIG_COMPAT
1104 static int compat_rawv6_getsockopt(struct sock
*sk
, int level
, int optname
,
1105 char __user
*optval
, int __user
*optlen
)
1111 if (inet_sk(sk
)->num
!= IPPROTO_ICMPV6
)
1113 return rawv6_geticmpfilter(sk
, level
, optname
, optval
, optlen
);
1115 if (optname
== IPV6_CHECKSUM
)
1118 return compat_ipv6_getsockopt(sk
, level
, optname
,
1121 return do_rawv6_getsockopt(sk
, level
, optname
, optval
, optlen
);
1125 static int rawv6_ioctl(struct sock
*sk
, int cmd
, unsigned long arg
)
1130 int amount
= sk_wmem_alloc_get(sk
);
1132 return put_user(amount
, (int __user
*)arg
);
1136 struct sk_buff
*skb
;
1139 spin_lock_bh(&sk
->sk_receive_queue
.lock
);
1140 skb
= skb_peek(&sk
->sk_receive_queue
);
1142 amount
= skb
->tail
- skb
->transport_header
;
1143 spin_unlock_bh(&sk
->sk_receive_queue
.lock
);
1144 return put_user(amount
, (int __user
*)arg
);
1148 #ifdef CONFIG_IPV6_MROUTE
1149 return ip6mr_ioctl(sk
, cmd
, (void __user
*)arg
);
1151 return -ENOIOCTLCMD
;
1156 static void rawv6_close(struct sock
*sk
, long timeout
)
1158 if (inet_sk(sk
)->num
== IPPROTO_RAW
)
1159 ip6_ra_control(sk
, -1);
1161 sk_common_release(sk
);
1164 static void raw6_destroy(struct sock
*sk
)
1167 ip6_flush_pending_frames(sk
);
1170 inet6_destroy_sock(sk
);
1173 static int rawv6_init_sk(struct sock
*sk
)
1175 struct raw6_sock
*rp
= raw6_sk(sk
);
1177 switch (inet_sk(sk
)->num
) {
1178 case IPPROTO_ICMPV6
:
1192 struct proto rawv6_prot
= {
1194 .owner
= THIS_MODULE
,
1195 .close
= rawv6_close
,
1196 .destroy
= raw6_destroy
,
1197 .connect
= ip6_datagram_connect
,
1198 .disconnect
= udp_disconnect
,
1199 .ioctl
= rawv6_ioctl
,
1200 .init
= rawv6_init_sk
,
1201 .setsockopt
= rawv6_setsockopt
,
1202 .getsockopt
= rawv6_getsockopt
,
1203 .sendmsg
= rawv6_sendmsg
,
1204 .recvmsg
= rawv6_recvmsg
,
1206 .backlog_rcv
= rawv6_rcv_skb
,
1207 .hash
= raw_hash_sk
,
1208 .unhash
= raw_unhash_sk
,
1209 .obj_size
= sizeof(struct raw6_sock
),
1210 .h
.raw_hash
= &raw_v6_hashinfo
,
1211 #ifdef CONFIG_COMPAT
1212 .compat_setsockopt
= compat_rawv6_setsockopt
,
1213 .compat_getsockopt
= compat_rawv6_getsockopt
,
1217 #ifdef CONFIG_PROC_FS
1218 static void raw6_sock_seq_show(struct seq_file
*seq
, struct sock
*sp
, int i
)
1220 struct ipv6_pinfo
*np
= inet6_sk(sp
);
1221 struct in6_addr
*dest
, *src
;
1225 src
= &np
->rcv_saddr
;
1227 srcp
= inet_sk(sp
)->num
;
1229 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1230 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %d\n",
1232 src
->s6_addr32
[0], src
->s6_addr32
[1],
1233 src
->s6_addr32
[2], src
->s6_addr32
[3], srcp
,
1234 dest
->s6_addr32
[0], dest
->s6_addr32
[1],
1235 dest
->s6_addr32
[2], dest
->s6_addr32
[3], destp
,
1237 sk_wmem_alloc_get(sp
),
1238 sk_rmem_alloc_get(sp
),
1242 atomic_read(&sp
->sk_refcnt
), sp
, atomic_read(&sp
->sk_drops
));
1245 static int raw6_seq_show(struct seq_file
*seq
, void *v
)
1247 if (v
== SEQ_START_TOKEN
)
1252 "st tx_queue rx_queue tr tm->when retrnsmt"
1253 " uid timeout inode ref pointer drops\n");
1255 raw6_sock_seq_show(seq
, v
, raw_seq_private(seq
)->bucket
);
1259 static const struct seq_operations raw6_seq_ops
= {
1260 .start
= raw_seq_start
,
1261 .next
= raw_seq_next
,
1262 .stop
= raw_seq_stop
,
1263 .show
= raw6_seq_show
,
1266 static int raw6_seq_open(struct inode
*inode
, struct file
*file
)
1268 return raw_seq_open(inode
, file
, &raw_v6_hashinfo
, &raw6_seq_ops
);
1271 static const struct file_operations raw6_seq_fops
= {
1272 .owner
= THIS_MODULE
,
1273 .open
= raw6_seq_open
,
1275 .llseek
= seq_lseek
,
1276 .release
= seq_release_net
,
1279 static int raw6_init_net(struct net
*net
)
1281 if (!proc_net_fops_create(net
, "raw6", S_IRUGO
, &raw6_seq_fops
))
1287 static void raw6_exit_net(struct net
*net
)
1289 proc_net_remove(net
, "raw6");
1292 static struct pernet_operations raw6_net_ops
= {
1293 .init
= raw6_init_net
,
1294 .exit
= raw6_exit_net
,
1297 int __init
raw6_proc_init(void)
1299 return register_pernet_subsys(&raw6_net_ops
);
1302 void raw6_proc_exit(void)
1304 unregister_pernet_subsys(&raw6_net_ops
);
1306 #endif /* CONFIG_PROC_FS */
1308 /* Same as inet6_dgram_ops, sans udp_poll. */
1309 static const struct proto_ops inet6_sockraw_ops
= {
1311 .owner
= THIS_MODULE
,
1312 .release
= inet6_release
,
1314 .connect
= inet_dgram_connect
, /* ok */
1315 .socketpair
= sock_no_socketpair
, /* a do nothing */
1316 .accept
= sock_no_accept
, /* a do nothing */
1317 .getname
= inet6_getname
,
1318 .poll
= datagram_poll
, /* ok */
1319 .ioctl
= inet6_ioctl
, /* must change */
1320 .listen
= sock_no_listen
, /* ok */
1321 .shutdown
= inet_shutdown
, /* ok */
1322 .setsockopt
= sock_common_setsockopt
, /* ok */
1323 .getsockopt
= sock_common_getsockopt
, /* ok */
1324 .sendmsg
= inet_sendmsg
, /* ok */
1325 .recvmsg
= sock_common_recvmsg
, /* ok */
1326 .mmap
= sock_no_mmap
,
1327 .sendpage
= sock_no_sendpage
,
1328 #ifdef CONFIG_COMPAT
1329 .compat_setsockopt
= compat_sock_common_setsockopt
,
1330 .compat_getsockopt
= compat_sock_common_getsockopt
,
1334 static struct inet_protosw rawv6_protosw
= {
1336 .protocol
= IPPROTO_IP
, /* wild card */
1337 .prot
= &rawv6_prot
,
1338 .ops
= &inet6_sockraw_ops
,
1339 .capability
= CAP_NET_RAW
,
1340 .no_check
= UDP_CSUM_DEFAULT
,
1341 .flags
= INET_PROTOSW_REUSE
,
1344 int __init
rawv6_init(void)
1348 ret
= inet6_register_protosw(&rawv6_protosw
);
1355 void rawv6_exit(void)
1357 inet6_unregister_protosw(&rawv6_protosw
);