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/slab.h>
25 #include <linux/sockios.h>
26 #include <linux/net.h>
27 #include <linux/in6.h>
28 #include <linux/netdevice.h>
29 #include <linux/if_arp.h>
30 #include <linux/icmpv6.h>
31 #include <linux/netfilter.h>
32 #include <linux/netfilter_ipv6.h>
33 #include <linux/skbuff.h>
34 #include <linux/compat.h>
35 #include <linux/uaccess.h>
36 #include <asm/ioctls.h>
38 #include <net/net_namespace.h>
44 #include <net/ndisc.h>
45 #include <net/protocol.h>
46 #include <net/ip6_route.h>
47 #include <net/ip6_checksum.h>
48 #include <net/addrconf.h>
49 #include <net/transp_v6.h>
51 #include <net/inet_common.h>
52 #include <net/tcp_states.h>
53 #if IS_ENABLED(CONFIG_IPV6_MIP6)
56 #include <linux/mroute6.h>
59 #include <net/rawv6.h>
62 #include <linux/proc_fs.h>
63 #include <linux/seq_file.h>
64 #include <linux/export.h>
66 #define ICMPV6_HDRLEN 4 /* ICMPv6 header, RFC 4443 Section 2.1 */
68 struct raw_hashinfo raw_v6_hashinfo
= {
69 .lock
= __RW_LOCK_UNLOCKED(raw_v6_hashinfo
.lock
),
71 EXPORT_SYMBOL_GPL(raw_v6_hashinfo
);
73 struct sock
*__raw_v6_lookup(struct net
*net
, struct sock
*sk
,
74 unsigned short num
, const struct in6_addr
*loc_addr
,
75 const struct in6_addr
*rmt_addr
, int dif
, int sdif
)
77 bool is_multicast
= ipv6_addr_is_multicast(loc_addr
);
80 if (inet_sk(sk
)->inet_num
== num
) {
82 if (!net_eq(sock_net(sk
), net
))
85 if (!ipv6_addr_any(&sk
->sk_v6_daddr
) &&
86 !ipv6_addr_equal(&sk
->sk_v6_daddr
, rmt_addr
))
89 if (sk
->sk_bound_dev_if
&&
90 sk
->sk_bound_dev_if
!= dif
&&
91 sk
->sk_bound_dev_if
!= sdif
)
94 if (!ipv6_addr_any(&sk
->sk_v6_rcv_saddr
)) {
95 if (ipv6_addr_equal(&sk
->sk_v6_rcv_saddr
, loc_addr
))
98 inet6_mc_check(sk
, loc_addr
, rmt_addr
))
108 EXPORT_SYMBOL_GPL(__raw_v6_lookup
);
114 static int icmpv6_filter(const struct sock
*sk
, const struct sk_buff
*skb
)
116 struct icmp6hdr _hdr
;
117 const struct icmp6hdr
*hdr
;
119 /* We require only the four bytes of the ICMPv6 header, not any
120 * additional bytes of message body in "struct icmp6hdr".
122 hdr
= skb_header_pointer(skb
, skb_transport_offset(skb
),
123 ICMPV6_HDRLEN
, &_hdr
);
125 const __u32
*data
= &raw6_sk(sk
)->filter
.data
[0];
126 unsigned int type
= hdr
->icmp6_type
;
128 return (data
[type
>> 5] & (1U << (type
& 31))) != 0;
133 #if IS_ENABLED(CONFIG_IPV6_MIP6)
134 typedef int mh_filter_t(struct sock
*sock
, struct sk_buff
*skb
);
136 static mh_filter_t __rcu
*mh_filter __read_mostly
;
138 int rawv6_mh_filter_register(mh_filter_t filter
)
140 rcu_assign_pointer(mh_filter
, filter
);
143 EXPORT_SYMBOL(rawv6_mh_filter_register
);
145 int rawv6_mh_filter_unregister(mh_filter_t filter
)
147 RCU_INIT_POINTER(mh_filter
, NULL
);
151 EXPORT_SYMBOL(rawv6_mh_filter_unregister
);
156 * demultiplex raw sockets.
157 * (should consider queueing the skb in the sock receive_queue
158 * without calling rawv6.c)
160 * Caller owns SKB so we must make clones.
162 static bool ipv6_raw_deliver(struct sk_buff
*skb
, int nexthdr
)
164 const struct in6_addr
*saddr
;
165 const struct in6_addr
*daddr
;
167 bool delivered
= false;
171 saddr
= &ipv6_hdr(skb
)->saddr
;
174 hash
= nexthdr
& (RAW_HTABLE_SIZE
- 1);
176 read_lock(&raw_v6_hashinfo
.lock
);
177 sk
= sk_head(&raw_v6_hashinfo
.ht
[hash
]);
182 net
= dev_net(skb
->dev
);
183 sk
= __raw_v6_lookup(net
, sk
, nexthdr
, daddr
, saddr
,
184 inet6_iif(skb
), inet6_sdif(skb
));
192 filtered
= icmpv6_filter(sk
, skb
);
195 #if IS_ENABLED(CONFIG_IPV6_MIP6)
198 /* XXX: To validate MH only once for each packet,
199 * this is placed here. It should be after checking
200 * xfrm policy, however it doesn't. The checking xfrm
201 * policy is placed in rawv6_rcv() because it is
202 * required for each socket.
206 filter
= rcu_dereference(mh_filter
);
207 filtered
= filter
? (*filter
)(sk
, skb
) : 0;
219 struct sk_buff
*clone
= skb_clone(skb
, GFP_ATOMIC
);
221 /* Not releasing hash table! */
224 rawv6_rcv(sk
, clone
);
227 sk
= __raw_v6_lookup(net
, sk_next(sk
), nexthdr
, daddr
, saddr
,
228 inet6_iif(skb
), inet6_sdif(skb
));
231 read_unlock(&raw_v6_hashinfo
.lock
);
235 bool raw6_local_deliver(struct sk_buff
*skb
, int nexthdr
)
239 raw_sk
= sk_head(&raw_v6_hashinfo
.ht
[nexthdr
& (RAW_HTABLE_SIZE
- 1)]);
240 if (raw_sk
&& !ipv6_raw_deliver(skb
, nexthdr
))
243 return raw_sk
!= NULL
;
246 /* This cleans up af_inet6 a bit. -DaveM */
247 static int rawv6_bind(struct sock
*sk
, struct sockaddr
*uaddr
, int addr_len
)
249 struct inet_sock
*inet
= inet_sk(sk
);
250 struct ipv6_pinfo
*np
= inet6_sk(sk
);
251 struct sockaddr_in6
*addr
= (struct sockaddr_in6
*) uaddr
;
256 if (addr_len
< SIN6_LEN_RFC2133
)
259 if (addr
->sin6_family
!= AF_INET6
)
262 addr_type
= ipv6_addr_type(&addr
->sin6_addr
);
264 /* Raw sockets are IPv6 only */
265 if (addr_type
== IPV6_ADDR_MAPPED
)
266 return -EADDRNOTAVAIL
;
271 if (sk
->sk_state
!= TCP_CLOSE
)
275 /* Check if the address belongs to the host. */
276 if (addr_type
!= IPV6_ADDR_ANY
) {
277 struct net_device
*dev
= NULL
;
279 if (__ipv6_addr_needs_scope_id(addr_type
)) {
280 if (addr_len
>= sizeof(struct sockaddr_in6
) &&
281 addr
->sin6_scope_id
) {
282 /* Override any existing binding, if another
283 * one is supplied by user.
285 sk
->sk_bound_dev_if
= addr
->sin6_scope_id
;
288 /* Binding to link-local address requires an interface */
289 if (!sk
->sk_bound_dev_if
)
293 if (sk
->sk_bound_dev_if
) {
295 dev
= dev_get_by_index_rcu(sock_net(sk
),
296 sk
->sk_bound_dev_if
);
301 /* ipv4 addr of the socket is invalid. Only the
302 * unspecified and mapped address have a v4 equivalent.
304 v4addr
= LOOPBACK4_IPV6
;
305 if (!(addr_type
& IPV6_ADDR_MULTICAST
) &&
306 !sock_net(sk
)->ipv6
.sysctl
.ip_nonlocal_bind
) {
307 err
= -EADDRNOTAVAIL
;
308 if (!ipv6_chk_addr(sock_net(sk
), &addr
->sin6_addr
,
315 inet
->inet_rcv_saddr
= inet
->inet_saddr
= v4addr
;
316 sk
->sk_v6_rcv_saddr
= addr
->sin6_addr
;
317 if (!(addr_type
& IPV6_ADDR_MULTICAST
))
318 np
->saddr
= addr
->sin6_addr
;
327 static void rawv6_err(struct sock
*sk
, struct sk_buff
*skb
,
328 struct inet6_skb_parm
*opt
,
329 u8 type
, u8 code
, int offset
, __be32 info
)
331 struct inet_sock
*inet
= inet_sk(sk
);
332 struct ipv6_pinfo
*np
= inet6_sk(sk
);
336 /* Report error on raw socket, if:
337 1. User requested recverr.
338 2. Socket is connected (otherwise the error indication
339 is useless without recverr and error is hard.
341 if (!np
->recverr
&& sk
->sk_state
!= TCP_ESTABLISHED
)
344 harderr
= icmpv6_err_convert(type
, code
, &err
);
345 if (type
== ICMPV6_PKT_TOOBIG
) {
346 ip6_sk_update_pmtu(skb
, sk
, info
);
347 harderr
= (np
->pmtudisc
== IPV6_PMTUDISC_DO
);
349 if (type
== NDISC_REDIRECT
) {
350 ip6_sk_redirect(skb
, sk
);
354 u8
*payload
= skb
->data
;
357 ipv6_icmp_error(sk
, skb
, err
, 0, ntohl(info
), payload
);
360 if (np
->recverr
|| harderr
) {
362 sk
->sk_error_report(sk
);
366 void raw6_icmp_error(struct sk_buff
*skb
, int nexthdr
,
367 u8 type
, u8 code
, int inner_offset
, __be32 info
)
371 const struct in6_addr
*saddr
, *daddr
;
374 hash
= nexthdr
& (RAW_HTABLE_SIZE
- 1);
376 read_lock(&raw_v6_hashinfo
.lock
);
377 sk
= sk_head(&raw_v6_hashinfo
.ht
[hash
]);
379 /* Note: ipv6_hdr(skb) != skb->data */
380 const struct ipv6hdr
*ip6h
= (const struct ipv6hdr
*)skb
->data
;
381 saddr
= &ip6h
->saddr
;
382 daddr
= &ip6h
->daddr
;
383 net
= dev_net(skb
->dev
);
385 while ((sk
= __raw_v6_lookup(net
, sk
, nexthdr
, saddr
, daddr
,
386 inet6_iif(skb
), inet6_iif(skb
)))) {
387 rawv6_err(sk
, skb
, NULL
, type
, code
,
392 read_unlock(&raw_v6_hashinfo
.lock
);
395 static inline int rawv6_rcv_skb(struct sock
*sk
, struct sk_buff
*skb
)
397 if ((raw6_sk(sk
)->checksum
|| rcu_access_pointer(sk
->sk_filter
)) &&
398 skb_checksum_complete(skb
)) {
399 atomic_inc(&sk
->sk_drops
);
404 /* Charge it to the socket. */
406 if (sock_queue_rcv_skb(sk
, skb
) < 0) {
415 * This is next to useless...
416 * if we demultiplex in network layer we don't need the extra call
417 * just to queue the skb...
418 * maybe we could have the network decide upon a hint if it
419 * should call raw_rcv for demultiplexing
421 int rawv6_rcv(struct sock
*sk
, struct sk_buff
*skb
)
423 struct inet_sock
*inet
= inet_sk(sk
);
424 struct raw6_sock
*rp
= raw6_sk(sk
);
426 if (!xfrm6_policy_check(sk
, XFRM_POLICY_IN
, skb
)) {
427 atomic_inc(&sk
->sk_drops
);
433 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
435 if (skb
->ip_summed
== CHECKSUM_COMPLETE
) {
436 skb_postpull_rcsum(skb
, skb_network_header(skb
),
437 skb_network_header_len(skb
));
438 if (!csum_ipv6_magic(&ipv6_hdr(skb
)->saddr
,
439 &ipv6_hdr(skb
)->daddr
,
440 skb
->len
, inet
->inet_num
, skb
->csum
))
441 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
443 if (!skb_csum_unnecessary(skb
))
444 skb
->csum
= ~csum_unfold(csum_ipv6_magic(&ipv6_hdr(skb
)->saddr
,
445 &ipv6_hdr(skb
)->daddr
,
450 if (skb_checksum_complete(skb
)) {
451 atomic_inc(&sk
->sk_drops
);
457 rawv6_rcv_skb(sk
, skb
);
463 * This should be easy, if there is something there
464 * we return it, otherwise we block.
467 static int rawv6_recvmsg(struct sock
*sk
, struct msghdr
*msg
, size_t len
,
468 int noblock
, int flags
, int *addr_len
)
470 struct ipv6_pinfo
*np
= inet6_sk(sk
);
471 DECLARE_SOCKADDR(struct sockaddr_in6
*, sin6
, msg
->msg_name
);
479 if (flags
& MSG_ERRQUEUE
)
480 return ipv6_recv_error(sk
, msg
, len
, addr_len
);
482 if (np
->rxpmtu
&& np
->rxopt
.bits
.rxpmtu
)
483 return ipv6_recv_rxpmtu(sk
, msg
, len
, addr_len
);
485 skb
= skb_recv_datagram(sk
, flags
, noblock
, &err
);
492 msg
->msg_flags
|= MSG_TRUNC
;
495 if (skb_csum_unnecessary(skb
)) {
496 err
= skb_copy_datagram_msg(skb
, 0, msg
, copied
);
497 } else if (msg
->msg_flags
&MSG_TRUNC
) {
498 if (__skb_checksum_complete(skb
))
500 err
= skb_copy_datagram_msg(skb
, 0, msg
, copied
);
502 err
= skb_copy_and_csum_datagram_msg(skb
, 0, msg
);
509 /* Copy the address. */
511 sin6
->sin6_family
= AF_INET6
;
513 sin6
->sin6_addr
= ipv6_hdr(skb
)->saddr
;
514 sin6
->sin6_flowinfo
= 0;
515 sin6
->sin6_scope_id
= ipv6_iface_scope_id(&sin6
->sin6_addr
,
517 *addr_len
= sizeof(*sin6
);
520 sock_recv_ts_and_drops(msg
, sk
, skb
);
523 ip6_datagram_recv_ctl(sk
, msg
, skb
);
526 if (flags
& MSG_TRUNC
)
530 skb_free_datagram(sk
, skb
);
535 skb_kill_datagram(sk
, skb
, flags
);
537 /* Error for blocking case is chosen to masquerade
538 as some normal condition.
540 err
= (flags
&MSG_DONTWAIT
) ? -EAGAIN
: -EHOSTUNREACH
;
544 static int rawv6_push_pending_frames(struct sock
*sk
, struct flowi6
*fl6
,
545 struct raw6_sock
*rp
)
558 skb
= skb_peek(&sk
->sk_write_queue
);
563 total_len
= inet_sk(sk
)->cork
.base
.length
;
564 if (offset
>= total_len
- 1) {
566 ip6_flush_pending_frames(sk
);
570 /* should be check HW csum miyazawa */
571 if (skb_queue_len(&sk
->sk_write_queue
) == 1) {
573 * Only one fragment on the socket.
575 tmp_csum
= skb
->csum
;
577 struct sk_buff
*csum_skb
= NULL
;
580 skb_queue_walk(&sk
->sk_write_queue
, skb
) {
581 tmp_csum
= csum_add(tmp_csum
, skb
->csum
);
586 len
= skb
->len
- skb_transport_offset(skb
);
598 offset
+= skb_transport_offset(skb
);
599 err
= skb_copy_bits(skb
, offset
, &csum
, 2);
601 ip6_flush_pending_frames(sk
);
605 /* in case cksum was not initialized */
607 tmp_csum
= csum_sub(tmp_csum
, csum_unfold(csum
));
609 csum
= csum_ipv6_magic(&fl6
->saddr
, &fl6
->daddr
,
610 total_len
, fl6
->flowi6_proto
, tmp_csum
);
612 if (csum
== 0 && fl6
->flowi6_proto
== IPPROTO_UDP
)
613 csum
= CSUM_MANGLED_0
;
615 BUG_ON(skb_store_bits(skb
, offset
, &csum
, 2));
618 err
= ip6_push_pending_frames(sk
);
623 static int rawv6_send_hdrinc(struct sock
*sk
, struct msghdr
*msg
, int length
,
624 struct flowi6
*fl6
, struct dst_entry
**dstp
,
627 struct ipv6_pinfo
*np
= inet6_sk(sk
);
628 struct net
*net
= sock_net(sk
);
632 struct rt6_info
*rt
= (struct rt6_info
*)*dstp
;
633 int hlen
= LL_RESERVED_SPACE(rt
->dst
.dev
);
634 int tlen
= rt
->dst
.dev
->needed_tailroom
;
636 if (length
> rt
->dst
.dev
->mtu
) {
637 ipv6_local_error(sk
, EMSGSIZE
, fl6
, rt
->dst
.dev
->mtu
);
640 if (length
< sizeof(struct ipv6hdr
))
645 skb
= sock_alloc_send_skb(sk
,
646 length
+ hlen
+ tlen
+ 15,
647 flags
& MSG_DONTWAIT
, &err
);
650 skb_reserve(skb
, hlen
);
652 skb
->protocol
= htons(ETH_P_IPV6
);
653 skb
->priority
= sk
->sk_priority
;
654 skb
->mark
= sk
->sk_mark
;
656 skb_put(skb
, length
);
657 skb_reset_network_header(skb
);
660 skb
->ip_summed
= CHECKSUM_NONE
;
662 if (flags
& MSG_CONFIRM
)
663 skb_set_dst_pending_confirm(skb
, 1);
665 skb
->transport_header
= skb
->network_header
;
666 err
= memcpy_from_msg(iph
, msg
, length
);
673 skb_dst_set(skb
, &rt
->dst
);
676 /* if egress device is enslaved to an L3 master device pass the
677 * skb to its handler for processing
679 skb
= l3mdev_ip6_out(sk
, skb
);
683 /* Acquire rcu_read_lock() in case we need to use rt->rt6i_idev
684 * in the error path. Since skb has been freed, the dst could
685 * have been queued for deletion.
688 IP6_UPD_PO_STATS(net
, rt
->rt6i_idev
, IPSTATS_MIB_OUT
, skb
->len
);
689 err
= NF_HOOK(NFPROTO_IPV6
, NF_INET_LOCAL_OUT
, net
, sk
, skb
,
690 NULL
, rt
->dst
.dev
, dst_output
);
692 err
= net_xmit_errno(err
);
694 IP6_INC_STATS(net
, rt
->rt6i_idev
, IPSTATS_MIB_OUTDISCARDS
);
703 IP6_INC_STATS(net
, rt
->rt6i_idev
, IPSTATS_MIB_OUTDISCARDS
);
705 if (err
== -ENOBUFS
&& !np
->recverr
)
710 struct raw6_frag_vec
{
716 static int rawv6_probe_proto_opt(struct raw6_frag_vec
*rfv
, struct flowi6
*fl6
)
719 switch (fl6
->flowi6_proto
) {
722 err
= memcpy_from_msg(rfv
->c
, rfv
->msg
, rfv
->hlen
);
724 fl6
->fl6_icmp_type
= rfv
->c
[0];
725 fl6
->fl6_icmp_code
= rfv
->c
[1];
730 err
= memcpy_from_msg(rfv
->c
, rfv
->msg
, rfv
->hlen
);
732 fl6
->fl6_mh_type
= rfv
->c
[2];
737 static int raw6_getfrag(void *from
, char *to
, int offset
, int len
, int odd
,
740 struct raw6_frag_vec
*rfv
= from
;
742 if (offset
< rfv
->hlen
) {
743 int copy
= min(rfv
->hlen
- offset
, len
);
745 if (skb
->ip_summed
== CHECKSUM_PARTIAL
)
746 memcpy(to
, rfv
->c
+ offset
, copy
);
748 skb
->csum
= csum_block_add(
750 csum_partial_copy_nocheck(rfv
->c
+ offset
,
765 return ip_generic_getfrag(rfv
->msg
, to
, offset
, len
, odd
, skb
);
768 static int rawv6_sendmsg(struct sock
*sk
, struct msghdr
*msg
, size_t len
)
770 struct ipv6_txoptions
*opt_to_free
= NULL
;
771 struct ipv6_txoptions opt_space
;
772 DECLARE_SOCKADDR(struct sockaddr_in6
*, sin6
, msg
->msg_name
);
773 struct in6_addr
*daddr
, *final_p
, final
;
774 struct inet_sock
*inet
= inet_sk(sk
);
775 struct ipv6_pinfo
*np
= inet6_sk(sk
);
776 struct raw6_sock
*rp
= raw6_sk(sk
);
777 struct ipv6_txoptions
*opt
= NULL
;
778 struct ip6_flowlabel
*flowlabel
= NULL
;
779 struct dst_entry
*dst
= NULL
;
780 struct raw6_frag_vec rfv
;
782 struct sockcm_cookie sockc
;
783 struct ipcm6_cookie ipc6
;
784 int addr_len
= msg
->msg_namelen
;
788 /* Rough check on arithmetic overflow,
789 better check is made in ip6_append_data().
794 /* Mirror BSD error message compatibility */
795 if (msg
->msg_flags
& MSG_OOB
)
799 * Get and verify the address.
801 memset(&fl6
, 0, sizeof(fl6
));
803 fl6
.flowi6_mark
= sk
->sk_mark
;
804 fl6
.flowi6_uid
= sk
->sk_uid
;
812 if (addr_len
< SIN6_LEN_RFC2133
)
815 if (sin6
->sin6_family
&& sin6
->sin6_family
!= AF_INET6
)
816 return -EAFNOSUPPORT
;
818 /* port is the proto value [0..255] carried in nexthdr */
819 proto
= ntohs(sin6
->sin6_port
);
822 proto
= inet
->inet_num
;
823 else if (proto
!= inet
->inet_num
)
829 daddr
= &sin6
->sin6_addr
;
831 fl6
.flowlabel
= sin6
->sin6_flowinfo
&IPV6_FLOWINFO_MASK
;
832 if (fl6
.flowlabel
&IPV6_FLOWLABEL_MASK
) {
833 flowlabel
= fl6_sock_lookup(sk
, fl6
.flowlabel
);
840 * Otherwise it will be difficult to maintain
843 if (sk
->sk_state
== TCP_ESTABLISHED
&&
844 ipv6_addr_equal(daddr
, &sk
->sk_v6_daddr
))
845 daddr
= &sk
->sk_v6_daddr
;
847 if (addr_len
>= sizeof(struct sockaddr_in6
) &&
848 sin6
->sin6_scope_id
&&
849 __ipv6_addr_needs_scope_id(__ipv6_addr_type(daddr
)))
850 fl6
.flowi6_oif
= sin6
->sin6_scope_id
;
852 if (sk
->sk_state
!= TCP_ESTABLISHED
)
853 return -EDESTADDRREQ
;
855 proto
= inet
->inet_num
;
856 daddr
= &sk
->sk_v6_daddr
;
857 fl6
.flowlabel
= np
->flow_label
;
860 if (fl6
.flowi6_oif
== 0)
861 fl6
.flowi6_oif
= sk
->sk_bound_dev_if
;
863 sockc
.tsflags
= sk
->sk_tsflags
;
864 if (msg
->msg_controllen
) {
866 memset(opt
, 0, sizeof(struct ipv6_txoptions
));
867 opt
->tot_len
= sizeof(struct ipv6_txoptions
);
870 err
= ip6_datagram_send_ctl(sock_net(sk
), sk
, msg
, &fl6
, &ipc6
, &sockc
);
872 fl6_sock_release(flowlabel
);
875 if ((fl6
.flowlabel
&IPV6_FLOWLABEL_MASK
) && !flowlabel
) {
876 flowlabel
= fl6_sock_lookup(sk
, fl6
.flowlabel
);
880 if (!(opt
->opt_nflen
|opt
->opt_flen
))
888 opt
= fl6_merge_options(&opt_space
, flowlabel
, opt
);
889 opt
= ipv6_fixup_options(&opt_space
, opt
);
891 fl6
.flowi6_proto
= proto
;
894 err
= rawv6_probe_proto_opt(&rfv
, &fl6
);
898 if (!ipv6_addr_any(daddr
))
901 fl6
.daddr
.s6_addr
[15] = 0x1; /* :: means loopback (BSD'ism) */
902 if (ipv6_addr_any(&fl6
.saddr
) && !ipv6_addr_any(&np
->saddr
))
903 fl6
.saddr
= np
->saddr
;
905 final_p
= fl6_update_dst(&fl6
, opt
, &final
);
907 if (!fl6
.flowi6_oif
&& ipv6_addr_is_multicast(&fl6
.daddr
))
908 fl6
.flowi6_oif
= np
->mcast_oif
;
909 else if (!fl6
.flowi6_oif
)
910 fl6
.flowi6_oif
= np
->ucast_oif
;
911 security_sk_classify_flow(sk
, flowi6_to_flowi(&fl6
));
914 fl6
.flowi6_flags
|= FLOWI_FLAG_KNOWN_NH
;
917 ipc6
.tclass
= np
->tclass
;
919 fl6
.flowlabel
= ip6_make_flowinfo(ipc6
.tclass
, fl6
.flowlabel
);
921 dst
= ip6_dst_lookup_flow(sk
, &fl6
, final_p
);
927 ipc6
.hlimit
= ip6_sk_dst_hoplimit(np
, &fl6
, dst
);
929 if (ipc6
.dontfrag
< 0)
930 ipc6
.dontfrag
= np
->dontfrag
;
932 if (msg
->msg_flags
&MSG_CONFIRM
)
937 err
= rawv6_send_hdrinc(sk
, msg
, len
, &fl6
, &dst
, msg
->msg_flags
);
941 err
= ip6_append_data(sk
, raw6_getfrag
, &rfv
,
942 len
, 0, &ipc6
, &fl6
, (struct rt6_info
*)dst
,
943 msg
->msg_flags
, &sockc
);
946 ip6_flush_pending_frames(sk
);
947 else if (!(msg
->msg_flags
& MSG_MORE
))
948 err
= rawv6_push_pending_frames(sk
, &fl6
, rp
);
954 fl6_sock_release(flowlabel
);
955 txopt_put(opt_to_free
);
956 return err
< 0 ? err
: len
;
958 if (msg
->msg_flags
& MSG_PROBE
)
959 dst_confirm_neigh(dst
, &fl6
.daddr
);
960 if (!(msg
->msg_flags
& MSG_PROBE
) || len
)
961 goto back_from_confirm
;
966 static int rawv6_seticmpfilter(struct sock
*sk
, int level
, int optname
,
967 char __user
*optval
, int optlen
)
971 if (optlen
> sizeof(struct icmp6_filter
))
972 optlen
= sizeof(struct icmp6_filter
);
973 if (copy_from_user(&raw6_sk(sk
)->filter
, optval
, optlen
))
983 static int rawv6_geticmpfilter(struct sock
*sk
, int level
, int optname
,
984 char __user
*optval
, int __user
*optlen
)
990 if (get_user(len
, optlen
))
994 if (len
> sizeof(struct icmp6_filter
))
995 len
= sizeof(struct icmp6_filter
);
996 if (put_user(len
, optlen
))
998 if (copy_to_user(optval
, &raw6_sk(sk
)->filter
, len
))
1002 return -ENOPROTOOPT
;
1009 static int do_rawv6_setsockopt(struct sock
*sk
, int level
, int optname
,
1010 char __user
*optval
, unsigned int optlen
)
1012 struct raw6_sock
*rp
= raw6_sk(sk
);
1015 if (get_user(val
, (int __user
*)optval
))
1020 if (sk
->sk_type
!= SOCK_RAW
)
1022 inet_sk(sk
)->hdrincl
= !!val
;
1025 if (inet_sk(sk
)->inet_num
== IPPROTO_ICMPV6
&&
1026 level
== IPPROTO_IPV6
) {
1028 * RFC3542 tells that IPV6_CHECKSUM socket
1029 * option in the IPPROTO_IPV6 level is not
1030 * allowed on ICMPv6 sockets.
1031 * If you want to set it, use IPPROTO_RAW
1032 * level IPV6_CHECKSUM socket option
1033 * (Linux extension).
1038 /* You may get strange result with a positive odd offset;
1039 RFC2292bis agrees with me. */
1040 if (val
> 0 && (val
&1))
1052 return -ENOPROTOOPT
;
1056 static int rawv6_setsockopt(struct sock
*sk
, int level
, int optname
,
1057 char __user
*optval
, unsigned int optlen
)
1064 if (inet_sk(sk
)->inet_num
!= IPPROTO_ICMPV6
)
1066 return rawv6_seticmpfilter(sk
, level
, optname
, optval
, optlen
);
1068 if (optname
== IPV6_CHECKSUM
||
1069 optname
== IPV6_HDRINCL
)
1072 return ipv6_setsockopt(sk
, level
, optname
, optval
, optlen
);
1075 return do_rawv6_setsockopt(sk
, level
, optname
, optval
, optlen
);
1078 #ifdef CONFIG_COMPAT
1079 static int compat_rawv6_setsockopt(struct sock
*sk
, int level
, int optname
,
1080 char __user
*optval
, unsigned int optlen
)
1086 if (inet_sk(sk
)->inet_num
!= IPPROTO_ICMPV6
)
1088 return rawv6_seticmpfilter(sk
, level
, optname
, optval
, optlen
);
1090 if (optname
== IPV6_CHECKSUM
||
1091 optname
== IPV6_HDRINCL
)
1094 return compat_ipv6_setsockopt(sk
, level
, optname
,
1097 return do_rawv6_setsockopt(sk
, level
, optname
, optval
, optlen
);
1101 static int do_rawv6_getsockopt(struct sock
*sk
, int level
, int optname
,
1102 char __user
*optval
, int __user
*optlen
)
1104 struct raw6_sock
*rp
= raw6_sk(sk
);
1107 if (get_user(len
, optlen
))
1112 val
= inet_sk(sk
)->hdrincl
;
1116 * We allow getsockopt() for IPPROTO_IPV6-level
1117 * IPV6_CHECKSUM socket option on ICMPv6 sockets
1118 * since RFC3542 is silent about it.
1120 if (rp
->checksum
== 0)
1127 return -ENOPROTOOPT
;
1130 len
= min_t(unsigned int, sizeof(int), len
);
1132 if (put_user(len
, optlen
))
1134 if (copy_to_user(optval
, &val
, len
))
1139 static int rawv6_getsockopt(struct sock
*sk
, int level
, int optname
,
1140 char __user
*optval
, int __user
*optlen
)
1147 if (inet_sk(sk
)->inet_num
!= IPPROTO_ICMPV6
)
1149 return rawv6_geticmpfilter(sk
, level
, optname
, optval
, optlen
);
1151 if (optname
== IPV6_CHECKSUM
||
1152 optname
== IPV6_HDRINCL
)
1155 return ipv6_getsockopt(sk
, level
, optname
, optval
, optlen
);
1158 return do_rawv6_getsockopt(sk
, level
, optname
, optval
, optlen
);
1161 #ifdef CONFIG_COMPAT
1162 static int compat_rawv6_getsockopt(struct sock
*sk
, int level
, int optname
,
1163 char __user
*optval
, int __user
*optlen
)
1169 if (inet_sk(sk
)->inet_num
!= IPPROTO_ICMPV6
)
1171 return rawv6_geticmpfilter(sk
, level
, optname
, optval
, optlen
);
1173 if (optname
== IPV6_CHECKSUM
||
1174 optname
== IPV6_HDRINCL
)
1177 return compat_ipv6_getsockopt(sk
, level
, optname
,
1180 return do_rawv6_getsockopt(sk
, level
, optname
, optval
, optlen
);
1184 static int rawv6_ioctl(struct sock
*sk
, int cmd
, unsigned long arg
)
1188 int amount
= sk_wmem_alloc_get(sk
);
1190 return put_user(amount
, (int __user
*)arg
);
1193 struct sk_buff
*skb
;
1196 spin_lock_bh(&sk
->sk_receive_queue
.lock
);
1197 skb
= skb_peek(&sk
->sk_receive_queue
);
1200 spin_unlock_bh(&sk
->sk_receive_queue
.lock
);
1201 return put_user(amount
, (int __user
*)arg
);
1205 #ifdef CONFIG_IPV6_MROUTE
1206 return ip6mr_ioctl(sk
, cmd
, (void __user
*)arg
);
1208 return -ENOIOCTLCMD
;
1213 #ifdef CONFIG_COMPAT
1214 static int compat_rawv6_ioctl(struct sock
*sk
, unsigned int cmd
, unsigned long arg
)
1219 return -ENOIOCTLCMD
;
1221 #ifdef CONFIG_IPV6_MROUTE
1222 return ip6mr_compat_ioctl(sk
, cmd
, compat_ptr(arg
));
1224 return -ENOIOCTLCMD
;
1230 static void rawv6_close(struct sock
*sk
, long timeout
)
1232 if (inet_sk(sk
)->inet_num
== IPPROTO_RAW
)
1233 ip6_ra_control(sk
, -1);
1235 sk_common_release(sk
);
1238 static void raw6_destroy(struct sock
*sk
)
1241 ip6_flush_pending_frames(sk
);
1244 inet6_destroy_sock(sk
);
1247 static int rawv6_init_sk(struct sock
*sk
)
1249 struct raw6_sock
*rp
= raw6_sk(sk
);
1251 switch (inet_sk(sk
)->inet_num
) {
1252 case IPPROTO_ICMPV6
:
1266 struct proto rawv6_prot
= {
1268 .owner
= THIS_MODULE
,
1269 .close
= rawv6_close
,
1270 .destroy
= raw6_destroy
,
1271 .connect
= ip6_datagram_connect_v6_only
,
1272 .disconnect
= __udp_disconnect
,
1273 .ioctl
= rawv6_ioctl
,
1274 .init
= rawv6_init_sk
,
1275 .setsockopt
= rawv6_setsockopt
,
1276 .getsockopt
= rawv6_getsockopt
,
1277 .sendmsg
= rawv6_sendmsg
,
1278 .recvmsg
= rawv6_recvmsg
,
1280 .backlog_rcv
= rawv6_rcv_skb
,
1281 .hash
= raw_hash_sk
,
1282 .unhash
= raw_unhash_sk
,
1283 .obj_size
= sizeof(struct raw6_sock
),
1284 .h
.raw_hash
= &raw_v6_hashinfo
,
1285 #ifdef CONFIG_COMPAT
1286 .compat_setsockopt
= compat_rawv6_setsockopt
,
1287 .compat_getsockopt
= compat_rawv6_getsockopt
,
1288 .compat_ioctl
= compat_rawv6_ioctl
,
1290 .diag_destroy
= raw_abort
,
1293 #ifdef CONFIG_PROC_FS
1294 static int raw6_seq_show(struct seq_file
*seq
, void *v
)
1296 if (v
== SEQ_START_TOKEN
) {
1297 seq_puts(seq
, IPV6_SEQ_DGRAM_HEADER
);
1299 struct sock
*sp
= v
;
1300 __u16 srcp
= inet_sk(sp
)->inet_num
;
1301 ip6_dgram_sock_seq_show(seq
, v
, srcp
, 0,
1302 raw_seq_private(seq
)->bucket
);
1307 static const struct seq_operations raw6_seq_ops
= {
1308 .start
= raw_seq_start
,
1309 .next
= raw_seq_next
,
1310 .stop
= raw_seq_stop
,
1311 .show
= raw6_seq_show
,
1314 static int raw6_seq_open(struct inode
*inode
, struct file
*file
)
1316 return raw_seq_open(inode
, file
, &raw_v6_hashinfo
, &raw6_seq_ops
);
1319 static const struct file_operations raw6_seq_fops
= {
1320 .owner
= THIS_MODULE
,
1321 .open
= raw6_seq_open
,
1323 .llseek
= seq_lseek
,
1324 .release
= seq_release_net
,
1327 static int __net_init
raw6_init_net(struct net
*net
)
1329 if (!proc_create("raw6", S_IRUGO
, net
->proc_net
, &raw6_seq_fops
))
1335 static void __net_exit
raw6_exit_net(struct net
*net
)
1337 remove_proc_entry("raw6", net
->proc_net
);
1340 static struct pernet_operations raw6_net_ops
= {
1341 .init
= raw6_init_net
,
1342 .exit
= raw6_exit_net
,
1345 int __init
raw6_proc_init(void)
1347 return register_pernet_subsys(&raw6_net_ops
);
1350 void raw6_proc_exit(void)
1352 unregister_pernet_subsys(&raw6_net_ops
);
1354 #endif /* CONFIG_PROC_FS */
1356 /* Same as inet6_dgram_ops, sans udp_poll. */
1357 const struct proto_ops inet6_sockraw_ops
= {
1359 .owner
= THIS_MODULE
,
1360 .release
= inet6_release
,
1362 .connect
= inet_dgram_connect
, /* ok */
1363 .socketpair
= sock_no_socketpair
, /* a do nothing */
1364 .accept
= sock_no_accept
, /* a do nothing */
1365 .getname
= inet6_getname
,
1366 .poll
= datagram_poll
, /* ok */
1367 .ioctl
= inet6_ioctl
, /* must change */
1368 .listen
= sock_no_listen
, /* ok */
1369 .shutdown
= inet_shutdown
, /* ok */
1370 .setsockopt
= sock_common_setsockopt
, /* ok */
1371 .getsockopt
= sock_common_getsockopt
, /* ok */
1372 .sendmsg
= inet_sendmsg
, /* ok */
1373 .recvmsg
= sock_common_recvmsg
, /* ok */
1374 .mmap
= sock_no_mmap
,
1375 .sendpage
= sock_no_sendpage
,
1376 #ifdef CONFIG_COMPAT
1377 .compat_setsockopt
= compat_sock_common_setsockopt
,
1378 .compat_getsockopt
= compat_sock_common_getsockopt
,
1382 static struct inet_protosw rawv6_protosw
= {
1384 .protocol
= IPPROTO_IP
, /* wild card */
1385 .prot
= &rawv6_prot
,
1386 .ops
= &inet6_sockraw_ops
,
1387 .flags
= INET_PROTOSW_REUSE
,
1390 int __init
rawv6_init(void)
1392 return inet6_register_protosw(&rawv6_protosw
);
1395 void rawv6_exit(void)
1397 inet6_unregister_protosw(&rawv6_protosw
);