3 * Linux INET6 implementation
6 * Pedro Roque <roque@di.fc.ul.pt>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
14 #include <linux/capability.h>
15 #include <linux/errno.h>
16 #include <linux/types.h>
17 #include <linux/kernel.h>
18 #include <linux/interrupt.h>
19 #include <linux/socket.h>
20 #include <linux/sockios.h>
21 #include <linux/in6.h>
22 #include <linux/ipv6.h>
23 #include <linux/route.h>
24 #include <linux/slab.h>
25 #include <linux/export.h>
28 #include <net/ndisc.h>
29 #include <net/addrconf.h>
30 #include <net/transp_v6.h>
31 #include <net/ip6_route.h>
32 #include <net/tcp_states.h>
34 #include <linux/errqueue.h>
35 #include <asm/uaccess.h>
37 static bool ipv6_mapped_addr_any(const struct in6_addr
*a
)
39 return ipv6_addr_v4mapped(a
) && (a
->s6_addr32
[3] == 0);
42 int ip6_datagram_connect(struct sock
*sk
, struct sockaddr
*uaddr
, int addr_len
)
44 struct sockaddr_in6
*usin
= (struct sockaddr_in6
*) uaddr
;
45 struct inet_sock
*inet
= inet_sk(sk
);
46 struct ipv6_pinfo
*np
= inet6_sk(sk
);
47 struct in6_addr
*daddr
, *final_p
, final
;
48 struct dst_entry
*dst
;
50 struct ip6_flowlabel
*flowlabel
= NULL
;
51 struct ipv6_txoptions
*opt
;
55 if (usin
->sin6_family
== AF_INET
) {
56 if (__ipv6_only_sock(sk
))
58 err
= ip4_datagram_connect(sk
, uaddr
, addr_len
);
62 if (addr_len
< SIN6_LEN_RFC2133
)
65 if (usin
->sin6_family
!= AF_INET6
)
68 memset(&fl6
, 0, sizeof(fl6
));
70 fl6
.flowlabel
= usin
->sin6_flowinfo
&IPV6_FLOWINFO_MASK
;
71 if (fl6
.flowlabel
&IPV6_FLOWLABEL_MASK
) {
72 flowlabel
= fl6_sock_lookup(sk
, fl6
.flowlabel
);
73 if (flowlabel
== NULL
)
75 usin
->sin6_addr
= flowlabel
->dst
;
79 addr_type
= ipv6_addr_type(&usin
->sin6_addr
);
81 if (addr_type
== IPV6_ADDR_ANY
) {
85 usin
->sin6_addr
.s6_addr
[15] = 0x01;
88 daddr
= &usin
->sin6_addr
;
90 if (addr_type
== IPV6_ADDR_MAPPED
) {
91 struct sockaddr_in sin
;
93 if (__ipv6_only_sock(sk
)) {
97 sin
.sin_family
= AF_INET
;
98 sin
.sin_addr
.s_addr
= daddr
->s6_addr32
[3];
99 sin
.sin_port
= usin
->sin6_port
;
101 err
= ip4_datagram_connect(sk
,
102 (struct sockaddr
*) &sin
,
109 ipv6_addr_set_v4mapped(inet
->inet_daddr
, &np
->daddr
);
111 if (ipv6_addr_any(&np
->saddr
) ||
112 ipv6_mapped_addr_any(&np
->saddr
))
113 ipv6_addr_set_v4mapped(inet
->inet_saddr
, &np
->saddr
);
115 if (ipv6_addr_any(&np
->rcv_saddr
) ||
116 ipv6_mapped_addr_any(&np
->rcv_saddr
)) {
117 ipv6_addr_set_v4mapped(inet
->inet_rcv_saddr
,
119 if (sk
->sk_prot
->rehash
)
120 sk
->sk_prot
->rehash(sk
);
126 if (addr_type
&IPV6_ADDR_LINKLOCAL
) {
127 if (addr_len
>= sizeof(struct sockaddr_in6
) &&
128 usin
->sin6_scope_id
) {
129 if (sk
->sk_bound_dev_if
&&
130 sk
->sk_bound_dev_if
!= usin
->sin6_scope_id
) {
134 sk
->sk_bound_dev_if
= usin
->sin6_scope_id
;
137 if (!sk
->sk_bound_dev_if
&& (addr_type
& IPV6_ADDR_MULTICAST
))
138 sk
->sk_bound_dev_if
= np
->mcast_oif
;
140 /* Connect to link-local address requires an interface */
141 if (!sk
->sk_bound_dev_if
) {
148 np
->flow_label
= fl6
.flowlabel
;
150 inet
->inet_dport
= usin
->sin6_port
;
153 * Check for a route to destination an obtain the
154 * destination cache for it.
157 fl6
.flowi6_proto
= sk
->sk_protocol
;
158 fl6
.daddr
= np
->daddr
;
159 fl6
.saddr
= np
->saddr
;
160 fl6
.flowi6_oif
= sk
->sk_bound_dev_if
;
161 fl6
.flowi6_mark
= sk
->sk_mark
;
162 fl6
.fl6_dport
= inet
->inet_dport
;
163 fl6
.fl6_sport
= inet
->inet_sport
;
165 if (!fl6
.flowi6_oif
&& (addr_type
&IPV6_ADDR_MULTICAST
))
166 fl6
.flowi6_oif
= np
->mcast_oif
;
168 security_sk_classify_flow(sk
, flowi6_to_flowi(&fl6
));
170 opt
= flowlabel
? flowlabel
->opt
: np
->opt
;
171 final_p
= fl6_update_dst(&fl6
, opt
, &final
);
173 dst
= ip6_dst_lookup_flow(sk
, &fl6
, final_p
, true);
180 /* source address lookup done in ip6_dst_lookup */
182 if (ipv6_addr_any(&np
->saddr
))
183 np
->saddr
= fl6
.saddr
;
185 if (ipv6_addr_any(&np
->rcv_saddr
)) {
186 np
->rcv_saddr
= fl6
.saddr
;
187 inet
->inet_rcv_saddr
= LOOPBACK4_IPV6
;
188 if (sk
->sk_prot
->rehash
)
189 sk
->sk_prot
->rehash(sk
);
192 ip6_dst_store(sk
, dst
,
193 ipv6_addr_equal(&fl6
.daddr
, &np
->daddr
) ?
195 #ifdef CONFIG_IPV6_SUBTREES
196 ipv6_addr_equal(&fl6
.saddr
, &np
->saddr
) ?
201 sk
->sk_state
= TCP_ESTABLISHED
;
203 fl6_sock_release(flowlabel
);
206 EXPORT_SYMBOL_GPL(ip6_datagram_connect
);
208 void ipv6_icmp_error(struct sock
*sk
, struct sk_buff
*skb
, int err
,
209 __be16 port
, u32 info
, u8
*payload
)
211 struct ipv6_pinfo
*np
= inet6_sk(sk
);
212 struct icmp6hdr
*icmph
= icmp6_hdr(skb
);
213 struct sock_exterr_skb
*serr
;
218 skb
= skb_clone(skb
, GFP_ATOMIC
);
222 skb
->protocol
= htons(ETH_P_IPV6
);
224 serr
= SKB_EXT_ERR(skb
);
225 serr
->ee
.ee_errno
= err
;
226 serr
->ee
.ee_origin
= SO_EE_ORIGIN_ICMP6
;
227 serr
->ee
.ee_type
= icmph
->icmp6_type
;
228 serr
->ee
.ee_code
= icmph
->icmp6_code
;
230 serr
->ee
.ee_info
= info
;
231 serr
->ee
.ee_data
= 0;
232 serr
->addr_offset
= (u8
*)&(((struct ipv6hdr
*)(icmph
+ 1))->daddr
) -
233 skb_network_header(skb
);
236 __skb_pull(skb
, payload
- skb
->data
);
237 skb_reset_transport_header(skb
);
239 if (sock_queue_err_skb(sk
, skb
))
243 void ipv6_local_error(struct sock
*sk
, int err
, struct flowi6
*fl6
, u32 info
)
245 struct ipv6_pinfo
*np
= inet6_sk(sk
);
246 struct sock_exterr_skb
*serr
;
253 skb
= alloc_skb(sizeof(struct ipv6hdr
), GFP_ATOMIC
);
257 skb
->protocol
= htons(ETH_P_IPV6
);
259 skb_put(skb
, sizeof(struct ipv6hdr
));
260 skb_reset_network_header(skb
);
262 iph
->daddr
= fl6
->daddr
;
264 serr
= SKB_EXT_ERR(skb
);
265 serr
->ee
.ee_errno
= err
;
266 serr
->ee
.ee_origin
= SO_EE_ORIGIN_LOCAL
;
267 serr
->ee
.ee_type
= 0;
268 serr
->ee
.ee_code
= 0;
270 serr
->ee
.ee_info
= info
;
271 serr
->ee
.ee_data
= 0;
272 serr
->addr_offset
= (u8
*)&iph
->daddr
- skb_network_header(skb
);
273 serr
->port
= fl6
->fl6_dport
;
275 __skb_pull(skb
, skb_tail_pointer(skb
) - skb
->data
);
276 skb_reset_transport_header(skb
);
278 if (sock_queue_err_skb(sk
, skb
))
282 void ipv6_local_rxpmtu(struct sock
*sk
, struct flowi6
*fl6
, u32 mtu
)
284 struct ipv6_pinfo
*np
= inet6_sk(sk
);
287 struct ip6_mtuinfo
*mtu_info
;
289 if (!np
->rxopt
.bits
.rxpmtu
)
292 skb
= alloc_skb(sizeof(struct ipv6hdr
), GFP_ATOMIC
);
296 skb_put(skb
, sizeof(struct ipv6hdr
));
297 skb_reset_network_header(skb
);
299 iph
->daddr
= fl6
->daddr
;
301 mtu_info
= IP6CBMTU(skb
);
303 mtu_info
->ip6m_mtu
= mtu
;
304 mtu_info
->ip6m_addr
.sin6_family
= AF_INET6
;
305 mtu_info
->ip6m_addr
.sin6_port
= 0;
306 mtu_info
->ip6m_addr
.sin6_flowinfo
= 0;
307 mtu_info
->ip6m_addr
.sin6_scope_id
= fl6
->flowi6_oif
;
308 mtu_info
->ip6m_addr
.sin6_addr
= ipv6_hdr(skb
)->daddr
;
310 __skb_pull(skb
, skb_tail_pointer(skb
) - skb
->data
);
311 skb_reset_transport_header(skb
);
313 skb
= xchg(&np
->rxpmtu
, skb
);
318 * Handle MSG_ERRQUEUE
320 int ipv6_recv_error(struct sock
*sk
, struct msghdr
*msg
, int len
)
322 struct ipv6_pinfo
*np
= inet6_sk(sk
);
323 struct sock_exterr_skb
*serr
;
324 struct sk_buff
*skb
, *skb2
;
325 struct sockaddr_in6
*sin
;
327 struct sock_extended_err ee
;
328 struct sockaddr_in6 offender
;
334 skb
= skb_dequeue(&sk
->sk_error_queue
);
340 msg
->msg_flags
|= MSG_TRUNC
;
343 err
= skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, copied
);
347 sock_recv_timestamp(msg
, sk
, skb
);
349 serr
= SKB_EXT_ERR(skb
);
351 sin
= (struct sockaddr_in6
*)msg
->msg_name
;
353 const unsigned char *nh
= skb_network_header(skb
);
354 sin
->sin6_family
= AF_INET6
;
355 sin
->sin6_flowinfo
= 0;
356 sin
->sin6_port
= serr
->port
;
357 sin
->sin6_scope_id
= 0;
358 if (skb
->protocol
== htons(ETH_P_IPV6
)) {
360 *(struct in6_addr
*)(nh
+ serr
->addr_offset
);
363 (*(__be32
*)(nh
+ serr
->addr_offset
- 24) &
365 if (ipv6_addr_type(&sin
->sin6_addr
) & IPV6_ADDR_LINKLOCAL
)
366 sin
->sin6_scope_id
= IP6CB(skb
)->iif
;
368 ipv6_addr_set_v4mapped(*(__be32
*)(nh
+ serr
->addr_offset
),
373 memcpy(&errhdr
.ee
, &serr
->ee
, sizeof(struct sock_extended_err
));
374 sin
= &errhdr
.offender
;
375 sin
->sin6_family
= AF_UNSPEC
;
376 if (serr
->ee
.ee_origin
!= SO_EE_ORIGIN_LOCAL
) {
377 sin
->sin6_family
= AF_INET6
;
378 sin
->sin6_flowinfo
= 0;
379 sin
->sin6_scope_id
= 0;
380 if (skb
->protocol
== htons(ETH_P_IPV6
)) {
381 sin
->sin6_addr
= ipv6_hdr(skb
)->saddr
;
383 datagram_recv_ctl(sk
, msg
, skb
);
384 if (ipv6_addr_type(&sin
->sin6_addr
) & IPV6_ADDR_LINKLOCAL
)
385 sin
->sin6_scope_id
= IP6CB(skb
)->iif
;
387 struct inet_sock
*inet
= inet_sk(sk
);
389 ipv6_addr_set_v4mapped(ip_hdr(skb
)->saddr
,
391 if (inet
->cmsg_flags
)
392 ip_cmsg_recv(msg
, skb
);
396 put_cmsg(msg
, SOL_IPV6
, IPV6_RECVERR
, sizeof(errhdr
), &errhdr
);
398 /* Now we could try to dump offended packet options */
400 msg
->msg_flags
|= MSG_ERRQUEUE
;
403 /* Reset and regenerate socket error */
404 spin_lock_bh(&sk
->sk_error_queue
.lock
);
406 if ((skb2
= skb_peek(&sk
->sk_error_queue
)) != NULL
) {
407 sk
->sk_err
= SKB_EXT_ERR(skb2
)->ee
.ee_errno
;
408 spin_unlock_bh(&sk
->sk_error_queue
.lock
);
409 sk
->sk_error_report(sk
);
411 spin_unlock_bh(&sk
->sk_error_queue
.lock
);
419 EXPORT_SYMBOL_GPL(ipv6_recv_error
);
422 * Handle IPV6_RECVPATHMTU
424 int ipv6_recv_rxpmtu(struct sock
*sk
, struct msghdr
*msg
, int len
)
426 struct ipv6_pinfo
*np
= inet6_sk(sk
);
428 struct sockaddr_in6
*sin
;
429 struct ip6_mtuinfo mtu_info
;
434 skb
= xchg(&np
->rxpmtu
, NULL
);
440 msg
->msg_flags
|= MSG_TRUNC
;
443 err
= skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, copied
);
447 sock_recv_timestamp(msg
, sk
, skb
);
449 memcpy(&mtu_info
, IP6CBMTU(skb
), sizeof(mtu_info
));
451 sin
= (struct sockaddr_in6
*)msg
->msg_name
;
453 sin
->sin6_family
= AF_INET6
;
454 sin
->sin6_flowinfo
= 0;
456 sin
->sin6_scope_id
= mtu_info
.ip6m_addr
.sin6_scope_id
;
457 sin
->sin6_addr
= mtu_info
.ip6m_addr
.sin6_addr
;
460 put_cmsg(msg
, SOL_IPV6
, IPV6_PATHMTU
, sizeof(mtu_info
), &mtu_info
);
471 int datagram_recv_ctl(struct sock
*sk
, struct msghdr
*msg
, struct sk_buff
*skb
)
473 struct ipv6_pinfo
*np
= inet6_sk(sk
);
474 struct inet6_skb_parm
*opt
= IP6CB(skb
);
475 unsigned char *nh
= skb_network_header(skb
);
477 if (np
->rxopt
.bits
.rxinfo
) {
478 struct in6_pktinfo src_info
;
480 src_info
.ipi6_ifindex
= opt
->iif
;
481 src_info
.ipi6_addr
= ipv6_hdr(skb
)->daddr
;
482 put_cmsg(msg
, SOL_IPV6
, IPV6_PKTINFO
, sizeof(src_info
), &src_info
);
485 if (np
->rxopt
.bits
.rxhlim
) {
486 int hlim
= ipv6_hdr(skb
)->hop_limit
;
487 put_cmsg(msg
, SOL_IPV6
, IPV6_HOPLIMIT
, sizeof(hlim
), &hlim
);
490 if (np
->rxopt
.bits
.rxtclass
) {
491 int tclass
= ipv6_tclass(ipv6_hdr(skb
));
492 put_cmsg(msg
, SOL_IPV6
, IPV6_TCLASS
, sizeof(tclass
), &tclass
);
495 if (np
->rxopt
.bits
.rxflow
&& (*(__be32
*)nh
& IPV6_FLOWINFO_MASK
)) {
496 __be32 flowinfo
= *(__be32
*)nh
& IPV6_FLOWINFO_MASK
;
497 put_cmsg(msg
, SOL_IPV6
, IPV6_FLOWINFO
, sizeof(flowinfo
), &flowinfo
);
500 /* HbH is allowed only once */
501 if (np
->rxopt
.bits
.hopopts
&& opt
->hop
) {
502 u8
*ptr
= nh
+ opt
->hop
;
503 put_cmsg(msg
, SOL_IPV6
, IPV6_HOPOPTS
, (ptr
[1]+1)<<3, ptr
);
507 (np
->rxopt
.bits
.dstopts
|| np
->rxopt
.bits
.srcrt
)) {
509 * Silly enough, but we need to reparse in order to
510 * report extension headers (except for HbH)
513 * Also note that IPV6_RECVRTHDRDSTOPTS is NOT
514 * (and WILL NOT be) defined because
515 * IPV6_RECVDSTOPTS is more generic. --yoshfuji
517 unsigned int off
= sizeof(struct ipv6hdr
);
518 u8 nexthdr
= ipv6_hdr(skb
)->nexthdr
;
520 while (off
<= opt
->lastopt
) {
525 case IPPROTO_DSTOPTS
:
527 len
= (ptr
[1] + 1) << 3;
528 if (np
->rxopt
.bits
.dstopts
)
529 put_cmsg(msg
, SOL_IPV6
, IPV6_DSTOPTS
, len
, ptr
);
531 case IPPROTO_ROUTING
:
533 len
= (ptr
[1] + 1) << 3;
534 if (np
->rxopt
.bits
.srcrt
)
535 put_cmsg(msg
, SOL_IPV6
, IPV6_RTHDR
, len
, ptr
);
539 len
= (ptr
[1] + 2) << 2;
543 len
= (ptr
[1] + 1) << 3;
551 /* socket options in old style */
552 if (np
->rxopt
.bits
.rxoinfo
) {
553 struct in6_pktinfo src_info
;
555 src_info
.ipi6_ifindex
= opt
->iif
;
556 src_info
.ipi6_addr
= ipv6_hdr(skb
)->daddr
;
557 put_cmsg(msg
, SOL_IPV6
, IPV6_2292PKTINFO
, sizeof(src_info
), &src_info
);
559 if (np
->rxopt
.bits
.rxohlim
) {
560 int hlim
= ipv6_hdr(skb
)->hop_limit
;
561 put_cmsg(msg
, SOL_IPV6
, IPV6_2292HOPLIMIT
, sizeof(hlim
), &hlim
);
563 if (np
->rxopt
.bits
.ohopopts
&& opt
->hop
) {
564 u8
*ptr
= nh
+ opt
->hop
;
565 put_cmsg(msg
, SOL_IPV6
, IPV6_2292HOPOPTS
, (ptr
[1]+1)<<3, ptr
);
567 if (np
->rxopt
.bits
.odstopts
&& opt
->dst0
) {
568 u8
*ptr
= nh
+ opt
->dst0
;
569 put_cmsg(msg
, SOL_IPV6
, IPV6_2292DSTOPTS
, (ptr
[1]+1)<<3, ptr
);
571 if (np
->rxopt
.bits
.osrcrt
&& opt
->srcrt
) {
572 struct ipv6_rt_hdr
*rthdr
= (struct ipv6_rt_hdr
*)(nh
+ opt
->srcrt
);
573 put_cmsg(msg
, SOL_IPV6
, IPV6_2292RTHDR
, (rthdr
->hdrlen
+1) << 3, rthdr
);
575 if (np
->rxopt
.bits
.odstopts
&& opt
->dst1
) {
576 u8
*ptr
= nh
+ opt
->dst1
;
577 put_cmsg(msg
, SOL_IPV6
, IPV6_2292DSTOPTS
, (ptr
[1]+1)<<3, ptr
);
579 if (np
->rxopt
.bits
.rxorigdstaddr
) {
580 struct sockaddr_in6 sin6
;
581 __be16
*ports
= (__be16
*) skb_transport_header(skb
);
583 if (skb_transport_offset(skb
) + 4 <= skb
->len
) {
584 /* All current transport protocols have the port numbers in the
585 * first four bytes of the transport header and this function is
586 * written with this assumption in mind.
589 sin6
.sin6_family
= AF_INET6
;
590 sin6
.sin6_addr
= ipv6_hdr(skb
)->daddr
;
591 sin6
.sin6_port
= ports
[1];
592 sin6
.sin6_flowinfo
= 0;
593 sin6
.sin6_scope_id
= 0;
595 put_cmsg(msg
, SOL_IPV6
, IPV6_ORIGDSTADDR
, sizeof(sin6
), &sin6
);
601 int datagram_send_ctl(struct net
*net
, struct sock
*sk
,
602 struct msghdr
*msg
, struct flowi6
*fl6
,
603 struct ipv6_txoptions
*opt
,
604 int *hlimit
, int *tclass
, int *dontfrag
)
606 struct in6_pktinfo
*src_info
;
607 struct cmsghdr
*cmsg
;
608 struct ipv6_rt_hdr
*rthdr
;
609 struct ipv6_opt_hdr
*hdr
;
613 for (cmsg
= CMSG_FIRSTHDR(msg
); cmsg
; cmsg
= CMSG_NXTHDR(msg
, cmsg
)) {
616 if (!CMSG_OK(msg
, cmsg
)) {
621 if (cmsg
->cmsg_level
!= SOL_IPV6
)
624 switch (cmsg
->cmsg_type
) {
626 case IPV6_2292PKTINFO
:
628 struct net_device
*dev
= NULL
;
630 if (cmsg
->cmsg_len
< CMSG_LEN(sizeof(struct in6_pktinfo
))) {
635 src_info
= (struct in6_pktinfo
*)CMSG_DATA(cmsg
);
637 if (src_info
->ipi6_ifindex
) {
638 if (fl6
->flowi6_oif
&&
639 src_info
->ipi6_ifindex
!= fl6
->flowi6_oif
)
641 fl6
->flowi6_oif
= src_info
->ipi6_ifindex
;
644 addr_type
= __ipv6_addr_type(&src_info
->ipi6_addr
);
647 if (fl6
->flowi6_oif
) {
648 dev
= dev_get_by_index_rcu(net
, fl6
->flowi6_oif
);
653 } else if (addr_type
& IPV6_ADDR_LINKLOCAL
) {
658 if (addr_type
!= IPV6_ADDR_ANY
) {
659 int strict
= __ipv6_addr_src_scope(addr_type
) <= IPV6_ADDR_SCOPE_LINKLOCAL
;
660 if (!(inet_sk(sk
)->freebind
|| inet_sk(sk
)->transparent
) &&
661 !ipv6_chk_addr(net
, &src_info
->ipi6_addr
,
662 strict
? dev
: NULL
, 0))
665 fl6
->saddr
= src_info
->ipi6_addr
;
677 if (cmsg
->cmsg_len
< CMSG_LEN(4)) {
682 if (fl6
->flowlabel
&IPV6_FLOWINFO_MASK
) {
683 if ((fl6
->flowlabel
^*(__be32
*)CMSG_DATA(cmsg
))&~IPV6_FLOWINFO_MASK
) {
688 fl6
->flowlabel
= IPV6_FLOWINFO_MASK
& *(__be32
*)CMSG_DATA(cmsg
);
691 case IPV6_2292HOPOPTS
:
693 if (opt
->hopopt
|| cmsg
->cmsg_len
< CMSG_LEN(sizeof(struct ipv6_opt_hdr
))) {
698 hdr
= (struct ipv6_opt_hdr
*)CMSG_DATA(cmsg
);
699 len
= ((hdr
->hdrlen
+ 1) << 3);
700 if (cmsg
->cmsg_len
< CMSG_LEN(len
)) {
704 if (!capable(CAP_NET_RAW
)) {
708 opt
->opt_nflen
+= len
;
712 case IPV6_2292DSTOPTS
:
713 if (cmsg
->cmsg_len
< CMSG_LEN(sizeof(struct ipv6_opt_hdr
))) {
718 hdr
= (struct ipv6_opt_hdr
*)CMSG_DATA(cmsg
);
719 len
= ((hdr
->hdrlen
+ 1) << 3);
720 if (cmsg
->cmsg_len
< CMSG_LEN(len
)) {
724 if (!capable(CAP_NET_RAW
)) {
732 opt
->opt_flen
+= len
;
737 case IPV6_RTHDRDSTOPTS
:
738 if (cmsg
->cmsg_len
< CMSG_LEN(sizeof(struct ipv6_opt_hdr
))) {
743 hdr
= (struct ipv6_opt_hdr
*)CMSG_DATA(cmsg
);
744 len
= ((hdr
->hdrlen
+ 1) << 3);
745 if (cmsg
->cmsg_len
< CMSG_LEN(len
)) {
749 if (!capable(CAP_NET_RAW
)) {
753 if (cmsg
->cmsg_type
== IPV6_DSTOPTS
) {
754 opt
->opt_flen
+= len
;
757 opt
->opt_nflen
+= len
;
764 if (cmsg
->cmsg_len
< CMSG_LEN(sizeof(struct ipv6_rt_hdr
))) {
769 rthdr
= (struct ipv6_rt_hdr
*)CMSG_DATA(cmsg
);
771 switch (rthdr
->type
) {
772 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
773 case IPV6_SRCRT_TYPE_2
:
774 if (rthdr
->hdrlen
!= 2 ||
775 rthdr
->segments_left
!= 1) {
786 len
= ((rthdr
->hdrlen
+ 1) << 3);
788 if (cmsg
->cmsg_len
< CMSG_LEN(len
)) {
793 /* segments left must also match */
794 if ((rthdr
->hdrlen
>> 1) != rthdr
->segments_left
) {
799 opt
->opt_nflen
+= len
;
802 if (cmsg
->cmsg_type
== IPV6_2292RTHDR
&& opt
->dst1opt
) {
803 int dsthdrlen
= ((opt
->dst1opt
->hdrlen
+1)<<3);
805 opt
->opt_nflen
+= dsthdrlen
;
806 opt
->dst0opt
= opt
->dst1opt
;
808 opt
->opt_flen
-= dsthdrlen
;
813 case IPV6_2292HOPLIMIT
:
815 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(int))) {
820 *hlimit
= *(int *)CMSG_DATA(cmsg
);
821 if (*hlimit
< -1 || *hlimit
> 0xff) {
833 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(int)))
836 tc
= *(int *)CMSG_DATA(cmsg
);
837 if (tc
< -1 || tc
> 0xff)
851 if (cmsg
->cmsg_len
!= CMSG_LEN(sizeof(int)))
854 df
= *(int *)CMSG_DATA(cmsg
);
855 if (df
< 0 || df
> 1)
864 LIMIT_NETDEBUG(KERN_DEBUG
"invalid cmsg type: %d\n",
874 EXPORT_SYMBOL_GPL(datagram_send_ctl
);