blob: 49f5e73db1224549c7f3fc156209a85ed6ce4056 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * common UDP/RAW code
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09003 * Linux INET6 implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * Authors:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09006 * Pedro Roque <roque@di.fc.ul.pt>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * 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.
12 */
13
Randy Dunlap4fc268d2006-01-11 12:17:47 -080014#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/errno.h>
16#include <linux/types.h>
17#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090024#include <linux/slab.h>
Chris Elstona495f832012-04-29 21:48:53 +000025#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
27#include <net/ipv6.h>
28#include <net/ndisc.h>
29#include <net/addrconf.h>
30#include <net/transp_v6.h>
31#include <net/ip6_route.h>
Arnaldo Carvalho de Meloc752f072005-08-09 20:08:28 -070032#include <net/tcp_states.h>
YOSHIFUJI Hideaki / 吉藤英明e7219852013-01-13 05:02:01 +000033#include <net/dsfield.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
35#include <linux/errqueue.h>
36#include <asm/uaccess.h>
37
Eric Dumazeta50feda2012-05-18 18:57:34 +000038static bool ipv6_mapped_addr_any(const struct in6_addr *a)
Max Matveevc15fea22011-08-05 03:56:30 -070039{
Eric Dumazeta50feda2012-05-18 18:57:34 +000040 return ipv6_addr_v4mapped(a) && (a->s6_addr32[3] == 0);
Max Matveevc15fea22011-08-05 03:56:30 -070041}
42
Linus Torvalds1da177e2005-04-16 15:20:36 -070043int ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
44{
45 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
Ian Morris67ba4152014-08-24 21:53:10 +010046 struct inet_sock *inet = inet_sk(sk);
47 struct ipv6_pinfo *np = inet6_sk(sk);
48 struct in6_addr *daddr, *final_p, final;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 struct dst_entry *dst;
David S. Miller4c9483b2011-03-12 16:22:43 -050050 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 struct ip6_flowlabel *flowlabel = NULL;
Ian Morris67ba4152014-08-24 21:53:10 +010052 struct ipv6_txoptions *opt;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 int addr_type;
54 int err;
55
56 if (usin->sin6_family == AF_INET) {
57 if (__ipv6_only_sock(sk))
58 return -EAFNOSUPPORT;
59 err = ip4_datagram_connect(sk, uaddr, addr_len);
60 goto ipv4_connected;
61 }
62
63 if (addr_len < SIN6_LEN_RFC2133)
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +090064 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +090066 if (usin->sin6_family != AF_INET6)
67 return -EAFNOSUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
David S. Miller4c9483b2011-03-12 16:22:43 -050069 memset(&fl6, 0, sizeof(fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 if (np->sndflow) {
David S. Miller4c9483b2011-03-12 16:22:43 -050071 fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
72 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
73 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 if (flowlabel == NULL)
75 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 }
77 }
78
79 addr_type = ipv6_addr_type(&usin->sin6_addr);
80
81 if (addr_type == IPV6_ADDR_ANY) {
82 /*
83 * connect to self
84 */
85 usin->sin6_addr.s6_addr[15] = 0x01;
86 }
87
88 daddr = &usin->sin6_addr;
89
90 if (addr_type == IPV6_ADDR_MAPPED) {
91 struct sockaddr_in sin;
92
93 if (__ipv6_only_sock(sk)) {
94 err = -ENETUNREACH;
95 goto out;
96 }
97 sin.sin_family = AF_INET;
98 sin.sin_addr.s_addr = daddr->s6_addr32[3];
99 sin.sin_port = usin->sin6_port;
100
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900101 err = ip4_datagram_connect(sk,
Eldad Zackb5a42572012-04-01 07:49:03 +0000102 (struct sockaddr *) &sin,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 sizeof(sin));
104
105ipv4_connected:
106 if (err)
107 goto out;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900108
Eric Dumazetefe42082013-10-03 15:42:29 -0700109 ipv6_addr_set_v4mapped(inet->inet_daddr, &sk->sk_v6_daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
Max Matveevc15fea22011-08-05 03:56:30 -0700111 if (ipv6_addr_any(&np->saddr) ||
112 ipv6_mapped_addr_any(&np->saddr))
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000113 ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
Eric Dumazetefe42082013-10-03 15:42:29 -0700115 if (ipv6_addr_any(&sk->sk_v6_rcv_saddr) ||
116 ipv6_mapped_addr_any(&sk->sk_v6_rcv_saddr)) {
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000117 ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
Eric Dumazetefe42082013-10-03 15:42:29 -0700118 &sk->sk_v6_rcv_saddr);
Eric Dumazet719f8352010-09-08 05:08:44 +0000119 if (sk->sk_prot->rehash)
120 sk->sk_prot->rehash(sk);
121 }
Brian Haleyb301e822009-10-07 13:58:25 -0700122
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 goto out;
124 }
125
Hannes Frederic Sowa842df072013-03-08 02:07:19 +0000126 if (__ipv6_addr_needs_scope_id(addr_type)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 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) {
131 err = -EINVAL;
132 goto out;
133 }
134 sk->sk_bound_dev_if = usin->sin6_scope_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 }
136
Brian Haley1ac4f002008-01-08 23:52:21 -0800137 if (!sk->sk_bound_dev_if && (addr_type & IPV6_ADDR_MULTICAST))
138 sk->sk_bound_dev_if = np->mcast_oif;
139
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 /* Connect to link-local address requires an interface */
141 if (!sk->sk_bound_dev_if) {
142 err = -EINVAL;
143 goto out;
144 }
145 }
146
Eric Dumazetefe42082013-10-03 15:42:29 -0700147 sk->sk_v6_daddr = *daddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500148 np->flow_label = fl6.flowlabel;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000150 inet->inet_dport = usin->sin6_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
152 /*
153 * Check for a route to destination an obtain the
154 * destination cache for it.
155 */
156
David S. Miller4c9483b2011-03-12 16:22:43 -0500157 fl6.flowi6_proto = sk->sk_protocol;
Eric Dumazetefe42082013-10-03 15:42:29 -0700158 fl6.daddr = sk->sk_v6_daddr;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000159 fl6.saddr = np->saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500160 fl6.flowi6_oif = sk->sk_bound_dev_if;
161 fl6.flowi6_mark = sk->sk_mark;
David S. Miller1958b852011-03-12 16:36:19 -0500162 fl6.fl6_dport = inet->inet_dport;
163 fl6.fl6_sport = inet->inet_sport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
David S. Miller4c9483b2011-03-12 16:22:43 -0500165 if (!fl6.flowi6_oif && (addr_type&IPV6_ADDR_MULTICAST))
166 fl6.flowi6_oif = np->mcast_oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
David S. Miller4c9483b2011-03-12 16:22:43 -0500168 security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700169
Arnaud Ebalard20c59de2010-06-01 21:35:01 +0000170 opt = flowlabel ? flowlabel->opt : np->opt;
David S. Miller4c9483b2011-03-12 16:22:43 -0500171 final_p = fl6_update_dst(&fl6, opt, &final);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172
Steffen Klassert0e0d44a2013-08-28 08:04:14 +0200173 dst = ip6_dst_lookup_flow(sk, &fl6, final_p);
David S. Miller68d0c6d2011-03-01 13:19:07 -0800174 err = 0;
175 if (IS_ERR(dst)) {
176 err = PTR_ERR(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 goto out;
David S. Miller14e50e52007-05-24 18:17:54 -0700178 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
180 /* source address lookup done in ip6_dst_lookup */
181
182 if (ipv6_addr_any(&np->saddr))
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000183 np->saddr = fl6.saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
Eric Dumazetefe42082013-10-03 15:42:29 -0700185 if (ipv6_addr_any(&sk->sk_v6_rcv_saddr)) {
186 sk->sk_v6_rcv_saddr = fl6.saddr;
Eric Dumazetc720c7e2009-10-15 06:30:45 +0000187 inet->inet_rcv_saddr = LOOPBACK4_IPV6;
Eric Dumazet719f8352010-09-08 05:08:44 +0000188 if (sk->sk_prot->rehash)
189 sk->sk_prot->rehash(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 }
191
192 ip6_dst_store(sk, dst,
Eric Dumazetefe42082013-10-03 15:42:29 -0700193 ipv6_addr_equal(&fl6.daddr, &sk->sk_v6_daddr) ?
194 &sk->sk_v6_daddr : NULL,
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -0700195#ifdef CONFIG_IPV6_SUBTREES
David S. Miller4c9483b2011-03-12 16:22:43 -0500196 ipv6_addr_equal(&fl6.saddr, &np->saddr) ?
YOSHIFUJI Hideaki8e1ef0a2006-08-29 17:15:09 -0700197 &np->saddr :
198#endif
199 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200
201 sk->sk_state = TCP_ESTABLISHED;
Tom Herbertb73c3d02014-07-01 21:32:17 -0700202 ip6_set_txhash(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203out:
204 fl6_sock_release(flowlabel);
205 return err;
206}
Chris Elstona495f832012-04-29 21:48:53 +0000207EXPORT_SYMBOL_GPL(ip6_datagram_connect);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208
Hannes Frederic Sowa82b276c2014-01-20 05:16:39 +0100209int ip6_datagram_connect_v6_only(struct sock *sk, struct sockaddr *uaddr,
210 int addr_len)
211{
212 DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, uaddr);
213 if (sin6->sin6_family != AF_INET6)
214 return -EAFNOSUPPORT;
215 return ip6_datagram_connect(sk, uaddr, addr_len);
216}
217EXPORT_SYMBOL_GPL(ip6_datagram_connect_v6_only);
218
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900219void ipv6_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
Al Viroe69a4adc2006-11-14 20:56:00 -0800220 __be16 port, u32 info, u8 *payload)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221{
222 struct ipv6_pinfo *np = inet6_sk(sk);
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300223 struct icmp6hdr *icmph = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 struct sock_exterr_skb *serr;
225
226 if (!np->recverr)
227 return;
228
229 skb = skb_clone(skb, GFP_ATOMIC);
230 if (!skb)
231 return;
232
Brian Haleyd40a4de2010-05-03 15:44:27 +0000233 skb->protocol = htons(ETH_P_IPV6);
234
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 serr = SKB_EXT_ERR(skb);
236 serr->ee.ee_errno = err;
237 serr->ee.ee_origin = SO_EE_ORIGIN_ICMP6;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900238 serr->ee.ee_type = icmph->icmp6_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 serr->ee.ee_code = icmph->icmp6_code;
240 serr->ee.ee_pad = 0;
241 serr->ee.ee_info = info;
242 serr->ee.ee_data = 0;
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700243 serr->addr_offset = (u8 *)&(((struct ipv6hdr *)(icmph + 1))->daddr) -
244 skb_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 serr->port = port;
246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 __skb_pull(skb, payload - skb->data);
Arnaldo Carvalho de Melobd823932007-03-13 17:10:43 -0300248 skb_reset_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249
250 if (sock_queue_err_skb(sk, skb))
251 kfree_skb(skb);
252}
253
David S. Miller4c9483b2011-03-12 16:22:43 -0500254void ipv6_local_error(struct sock *sk, int err, struct flowi6 *fl6, u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255{
256 struct ipv6_pinfo *np = inet6_sk(sk);
257 struct sock_exterr_skb *serr;
258 struct ipv6hdr *iph;
259 struct sk_buff *skb;
260
261 if (!np->recverr)
262 return;
263
264 skb = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
265 if (!skb)
266 return;
267
Brian Haleyd40a4de2010-05-03 15:44:27 +0000268 skb->protocol = htons(ETH_P_IPV6);
269
Arnaldo Carvalho de Melo1ced98e2007-03-10 19:57:15 -0300270 skb_put(skb, sizeof(struct ipv6hdr));
271 skb_reset_network_header(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700272 iph = ipv6_hdr(skb);
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000273 iph->daddr = fl6->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274
275 serr = SKB_EXT_ERR(skb);
276 serr->ee.ee_errno = err;
277 serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900278 serr->ee.ee_type = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 serr->ee.ee_code = 0;
280 serr->ee.ee_pad = 0;
281 serr->ee.ee_info = info;
282 serr->ee.ee_data = 0;
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700283 serr->addr_offset = (u8 *)&iph->daddr - skb_network_header(skb);
David S. Miller1958b852011-03-12 16:36:19 -0500284 serr->port = fl6->fl6_dport;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700286 __skb_pull(skb, skb_tail_pointer(skb) - skb->data);
Arnaldo Carvalho de Melobd823932007-03-13 17:10:43 -0300287 skb_reset_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
289 if (sock_queue_err_skb(sk, skb))
290 kfree_skb(skb);
291}
292
David S. Miller4c9483b2011-03-12 16:22:43 -0500293void ipv6_local_rxpmtu(struct sock *sk, struct flowi6 *fl6, u32 mtu)
Brian Haley4b340ae2010-04-23 11:26:09 +0000294{
295 struct ipv6_pinfo *np = inet6_sk(sk);
296 struct ipv6hdr *iph;
297 struct sk_buff *skb;
298 struct ip6_mtuinfo *mtu_info;
299
300 if (!np->rxopt.bits.rxpmtu)
301 return;
302
303 skb = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
304 if (!skb)
305 return;
306
307 skb_put(skb, sizeof(struct ipv6hdr));
308 skb_reset_network_header(skb);
309 iph = ipv6_hdr(skb);
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000310 iph->daddr = fl6->daddr;
Brian Haley4b340ae2010-04-23 11:26:09 +0000311
312 mtu_info = IP6CBMTU(skb);
Brian Haley4b340ae2010-04-23 11:26:09 +0000313
314 mtu_info->ip6m_mtu = mtu;
315 mtu_info->ip6m_addr.sin6_family = AF_INET6;
316 mtu_info->ip6m_addr.sin6_port = 0;
317 mtu_info->ip6m_addr.sin6_flowinfo = 0;
David S. Miller4c9483b2011-03-12 16:22:43 -0500318 mtu_info->ip6m_addr.sin6_scope_id = fl6->flowi6_oif;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000319 mtu_info->ip6m_addr.sin6_addr = ipv6_hdr(skb)->daddr;
Brian Haley4b340ae2010-04-23 11:26:09 +0000320
321 __skb_pull(skb, skb_tail_pointer(skb) - skb->data);
322 skb_reset_transport_header(skb);
323
324 skb = xchg(&np->rxpmtu, skb);
325 kfree_skb(skb);
326}
327
Willem de Bruijn829ae9d2014-11-30 22:22:34 -0500328static void ip6_datagram_prepare_pktinfo_errqueue(struct sk_buff *skb)
329{
330 int ifindex = skb->dev ? skb->dev->ifindex : -1;
331
332 if (skb->protocol == htons(ETH_P_IPV6))
333 IP6CB(skb)->iif = ifindex;
334 else
335 PKTINFO_SKB_CB(skb)->ipi_ifindex = ifindex;
336}
337
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900338/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 * Handle MSG_ERRQUEUE
340 */
Hannes Frederic Sowa85fbaa72013-11-23 00:46:12 +0100341int ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len, int *addr_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342{
343 struct ipv6_pinfo *np = inet6_sk(sk);
344 struct sock_exterr_skb *serr;
Willem de Bruijn364a9e92014-08-31 21:30:27 -0400345 struct sk_buff *skb;
Steffen Hurrle342dfc32014-01-17 22:53:15 +0100346 DECLARE_SOCKADDR(struct sockaddr_in6 *, sin, msg->msg_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 struct {
348 struct sock_extended_err ee;
349 struct sockaddr_in6 offender;
350 } errhdr;
351 int err;
352 int copied;
353
354 err = -EAGAIN;
Willem de Bruijn364a9e92014-08-31 21:30:27 -0400355 skb = sock_dequeue_err_skb(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 if (skb == NULL)
357 goto out;
358
359 copied = skb->len;
360 if (copied > len) {
361 msg->msg_flags |= MSG_TRUNC;
362 copied = len;
363 }
David S. Miller51f3d022014-11-05 16:46:40 -0500364 err = skb_copy_datagram_msg(skb, 0, msg, copied);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 if (err)
366 goto out_free_skb;
367
368 sock_recv_timestamp(msg, sk, skb);
369
370 serr = SKB_EXT_ERR(skb);
371
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 if (sin) {
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700373 const unsigned char *nh = skb_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 sin->sin6_family = AF_INET6;
375 sin->sin6_flowinfo = 0;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900376 sin->sin6_port = serr->port;
Brian Haleyd40a4de2010-05-03 15:44:27 +0000377 if (skb->protocol == htons(ETH_P_IPV6)) {
YOSHIFUJI Hideaki / 吉藤英明6c40d102013-01-08 06:44:23 +0000378 const struct ipv6hdr *ip6h = container_of((struct in6_addr *)(nh + serr->addr_offset),
379 struct ipv6hdr, daddr);
380 sin->sin6_addr = ip6h->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 if (np->sndflow)
YOSHIFUJI Hideaki / 吉藤英明6502ca52013-01-13 05:01:51 +0000382 sin->sin6_flowinfo = ip6_flowinfo(ip6h);
Hannes Frederic Sowa842df072013-03-08 02:07:19 +0000383 sin->sin6_scope_id =
384 ipv6_iface_scope_id(&sin->sin6_addr,
385 IP6CB(skb)->iif);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 } else {
Brian Haleyb301e822009-10-07 13:58:25 -0700387 ipv6_addr_set_v4mapped(*(__be32 *)(nh + serr->addr_offset),
388 &sin->sin6_addr);
Hannes Frederic Sowa842df072013-03-08 02:07:19 +0000389 sin->sin6_scope_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 }
Hannes Frederic Sowa85fbaa72013-11-23 00:46:12 +0100391 *addr_len = sizeof(*sin);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 }
393
394 memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
395 sin = &errhdr.offender;
Willem de Bruijnf8121162015-01-15 13:18:40 -0500396 memset(sin, 0, sizeof(*sin));
397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 if (serr->ee.ee_origin != SO_EE_ORIGIN_LOCAL) {
399 sin->sin6_family = AF_INET6;
Willem de Bruijn829ae9d2014-11-30 22:22:34 -0500400 if (np->rxopt.all) {
401 if (serr->ee.ee_origin != SO_EE_ORIGIN_ICMP &&
402 serr->ee.ee_origin != SO_EE_ORIGIN_ICMP6)
403 ip6_datagram_prepare_pktinfo_errqueue(skb);
Hannes Frederic Sowa4b261c72014-01-20 03:43:08 +0100404 ip6_datagram_recv_common_ctl(sk, msg, skb);
Willem de Bruijn829ae9d2014-11-30 22:22:34 -0500405 }
Brian Haleyd40a4de2010-05-03 15:44:27 +0000406 if (skb->protocol == htons(ETH_P_IPV6)) {
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000407 sin->sin6_addr = ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 if (np->rxopt.all)
Hannes Frederic Sowa4b261c72014-01-20 03:43:08 +0100409 ip6_datagram_recv_specific_ctl(sk, msg, skb);
Hannes Frederic Sowa842df072013-03-08 02:07:19 +0000410 sin->sin6_scope_id =
411 ipv6_iface_scope_id(&sin->sin6_addr,
412 IP6CB(skb)->iif);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 } else {
Brian Haleyb301e822009-10-07 13:58:25 -0700414 ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr,
415 &sin->sin6_addr);
Willem de Bruijnf8121162015-01-15 13:18:40 -0500416 if (inet_sk(sk)->cmsg_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 ip_cmsg_recv(msg, skb);
418 }
419 }
420
421 put_cmsg(msg, SOL_IPV6, IPV6_RECVERR, sizeof(errhdr), &errhdr);
422
423 /* Now we could try to dump offended packet options */
424
425 msg->msg_flags |= MSG_ERRQUEUE;
426 err = copied;
427
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900428out_free_skb:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 kfree_skb(skb);
430out:
431 return err;
432}
Chris Elstona495f832012-04-29 21:48:53 +0000433EXPORT_SYMBOL_GPL(ipv6_recv_error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
Brian Haley4b340ae2010-04-23 11:26:09 +0000435/*
436 * Handle IPV6_RECVPATHMTU
437 */
Hannes Frederic Sowa85fbaa72013-11-23 00:46:12 +0100438int ipv6_recv_rxpmtu(struct sock *sk, struct msghdr *msg, int len,
439 int *addr_len)
Brian Haley4b340ae2010-04-23 11:26:09 +0000440{
441 struct ipv6_pinfo *np = inet6_sk(sk);
442 struct sk_buff *skb;
Brian Haley4b340ae2010-04-23 11:26:09 +0000443 struct ip6_mtuinfo mtu_info;
Steffen Hurrle342dfc32014-01-17 22:53:15 +0100444 DECLARE_SOCKADDR(struct sockaddr_in6 *, sin, msg->msg_name);
Brian Haley4b340ae2010-04-23 11:26:09 +0000445 int err;
446 int copied;
447
448 err = -EAGAIN;
449 skb = xchg(&np->rxpmtu, NULL);
450 if (skb == NULL)
451 goto out;
452
453 copied = skb->len;
454 if (copied > len) {
455 msg->msg_flags |= MSG_TRUNC;
456 copied = len;
457 }
David S. Miller51f3d022014-11-05 16:46:40 -0500458 err = skb_copy_datagram_msg(skb, 0, msg, copied);
Brian Haley4b340ae2010-04-23 11:26:09 +0000459 if (err)
460 goto out_free_skb;
461
462 sock_recv_timestamp(msg, sk, skb);
463
464 memcpy(&mtu_info, IP6CBMTU(skb), sizeof(mtu_info));
465
Brian Haley4b340ae2010-04-23 11:26:09 +0000466 if (sin) {
467 sin->sin6_family = AF_INET6;
468 sin->sin6_flowinfo = 0;
469 sin->sin6_port = 0;
470 sin->sin6_scope_id = mtu_info.ip6m_addr.sin6_scope_id;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000471 sin->sin6_addr = mtu_info.ip6m_addr.sin6_addr;
Hannes Frederic Sowa85fbaa72013-11-23 00:46:12 +0100472 *addr_len = sizeof(*sin);
Brian Haley4b340ae2010-04-23 11:26:09 +0000473 }
474
475 put_cmsg(msg, SOL_IPV6, IPV6_PATHMTU, sizeof(mtu_info), &mtu_info);
476
477 err = copied;
478
479out_free_skb:
480 kfree_skb(skb);
481out:
482 return err;
483}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
485
Hannes Frederic Sowa4b261c72014-01-20 03:43:08 +0100486void ip6_datagram_recv_common_ctl(struct sock *sk, struct msghdr *msg,
487 struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488{
489 struct ipv6_pinfo *np = inet6_sk(sk);
Hannes Frederic Sowa4b261c72014-01-20 03:43:08 +0100490 bool is_ipv6 = skb->protocol == htons(ETH_P_IPV6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
492 if (np->rxopt.bits.rxinfo) {
493 struct in6_pktinfo src_info;
494
Hannes Frederic Sowa4b261c72014-01-20 03:43:08 +0100495 if (is_ipv6) {
496 src_info.ipi6_ifindex = IP6CB(skb)->iif;
497 src_info.ipi6_addr = ipv6_hdr(skb)->daddr;
498 } else {
499 src_info.ipi6_ifindex =
500 PKTINFO_SKB_CB(skb)->ipi_ifindex;
501 ipv6_addr_set_v4mapped(ip_hdr(skb)->daddr,
502 &src_info.ipi6_addr);
503 }
Willem de Bruijn829ae9d2014-11-30 22:22:34 -0500504
505 if (src_info.ipi6_ifindex >= 0)
506 put_cmsg(msg, SOL_IPV6, IPV6_PKTINFO,
507 sizeof(src_info), &src_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 }
Hannes Frederic Sowa4b261c72014-01-20 03:43:08 +0100509}
510
511void ip6_datagram_recv_specific_ctl(struct sock *sk, struct msghdr *msg,
512 struct sk_buff *skb)
513{
514 struct ipv6_pinfo *np = inet6_sk(sk);
515 struct inet6_skb_parm *opt = IP6CB(skb);
516 unsigned char *nh = skb_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517
518 if (np->rxopt.bits.rxhlim) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700519 int hlim = ipv6_hdr(skb)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 put_cmsg(msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);
521 }
522
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900523 if (np->rxopt.bits.rxtclass) {
YOSHIFUJI Hideaki / 吉藤英明e7219852013-01-13 05:02:01 +0000524 int tclass = ipv6_get_dsfield(ipv6_hdr(skb));
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900525 put_cmsg(msg, SOL_IPV6, IPV6_TCLASS, sizeof(tclass), &tclass);
526 }
527
YOSHIFUJI Hideaki / 吉藤英明6502ca52013-01-13 05:01:51 +0000528 if (np->rxopt.bits.rxflow) {
529 __be32 flowinfo = ip6_flowinfo((struct ipv6hdr *)nh);
530 if (flowinfo)
531 put_cmsg(msg, SOL_IPV6, IPV6_FLOWINFO, sizeof(flowinfo), &flowinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 }
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900533
534 /* HbH is allowed only once */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 if (np->rxopt.bits.hopopts && opt->hop) {
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700536 u8 *ptr = nh + opt->hop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 put_cmsg(msg, SOL_IPV6, IPV6_HOPOPTS, (ptr[1]+1)<<3, ptr);
538 }
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900539
540 if (opt->lastopt &&
541 (np->rxopt.bits.dstopts || np->rxopt.bits.srcrt)) {
542 /*
543 * Silly enough, but we need to reparse in order to
544 * report extension headers (except for HbH)
545 * in order.
546 *
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900547 * Also note that IPV6_RECVRTHDRDSTOPTS is NOT
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900548 * (and WILL NOT be) defined because
549 * IPV6_RECVDSTOPTS is more generic. --yoshfuji
550 */
551 unsigned int off = sizeof(struct ipv6hdr);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700552 u8 nexthdr = ipv6_hdr(skb)->nexthdr;
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900553
554 while (off <= opt->lastopt) {
Eric Dumazet95c96172012-04-15 05:58:06 +0000555 unsigned int len;
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700556 u8 *ptr = nh + off;
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900557
Eldad Zackb5a42572012-04-01 07:49:03 +0000558 switch (nexthdr) {
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900559 case IPPROTO_DSTOPTS:
560 nexthdr = ptr[0];
561 len = (ptr[1] + 1) << 3;
562 if (np->rxopt.bits.dstopts)
563 put_cmsg(msg, SOL_IPV6, IPV6_DSTOPTS, len, ptr);
564 break;
565 case IPPROTO_ROUTING:
566 nexthdr = ptr[0];
567 len = (ptr[1] + 1) << 3;
568 if (np->rxopt.bits.srcrt)
569 put_cmsg(msg, SOL_IPV6, IPV6_RTHDR, len, ptr);
570 break;
571 case IPPROTO_AH:
572 nexthdr = ptr[0];
Ville Nuorvalaa3059892005-11-20 12:21:59 +0900573 len = (ptr[1] + 2) << 2;
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900574 break;
575 default:
576 nexthdr = ptr[0];
577 len = (ptr[1] + 1) << 3;
578 break;
579 }
580
581 off += len;
582 }
583 }
584
585 /* socket options in old style */
586 if (np->rxopt.bits.rxoinfo) {
587 struct in6_pktinfo src_info;
588
589 src_info.ipi6_ifindex = opt->iif;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000590 src_info.ipi6_addr = ipv6_hdr(skb)->daddr;
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900591 put_cmsg(msg, SOL_IPV6, IPV6_2292PKTINFO, sizeof(src_info), &src_info);
592 }
593 if (np->rxopt.bits.rxohlim) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700594 int hlim = ipv6_hdr(skb)->hop_limit;
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900595 put_cmsg(msg, SOL_IPV6, IPV6_2292HOPLIMIT, sizeof(hlim), &hlim);
596 }
597 if (np->rxopt.bits.ohopopts && opt->hop) {
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700598 u8 *ptr = nh + opt->hop;
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900599 put_cmsg(msg, SOL_IPV6, IPV6_2292HOPOPTS, (ptr[1]+1)<<3, ptr);
600 }
601 if (np->rxopt.bits.odstopts && opt->dst0) {
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700602 u8 *ptr = nh + opt->dst0;
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900603 put_cmsg(msg, SOL_IPV6, IPV6_2292DSTOPTS, (ptr[1]+1)<<3, ptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 }
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900605 if (np->rxopt.bits.osrcrt && opt->srcrt) {
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700606 struct ipv6_rt_hdr *rthdr = (struct ipv6_rt_hdr *)(nh + opt->srcrt);
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900607 put_cmsg(msg, SOL_IPV6, IPV6_2292RTHDR, (rthdr->hdrlen+1) << 3, rthdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 }
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900609 if (np->rxopt.bits.odstopts && opt->dst1) {
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700610 u8 *ptr = nh + opt->dst1;
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900611 put_cmsg(msg, SOL_IPV6, IPV6_2292DSTOPTS, (ptr[1]+1)<<3, ptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 }
Balazs Scheidler6c468622010-10-21 16:08:28 +0200613 if (np->rxopt.bits.rxorigdstaddr) {
614 struct sockaddr_in6 sin6;
Eric Dumazet747465e2012-01-16 19:27:39 +0000615 __be16 *ports = (__be16 *) skb_transport_header(skb);
Balazs Scheidler6c468622010-10-21 16:08:28 +0200616
617 if (skb_transport_offset(skb) + 4 <= skb->len) {
618 /* All current transport protocols have the port numbers in the
619 * first four bytes of the transport header and this function is
620 * written with this assumption in mind.
621 */
622
623 sin6.sin6_family = AF_INET6;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000624 sin6.sin6_addr = ipv6_hdr(skb)->daddr;
Balazs Scheidler6c468622010-10-21 16:08:28 +0200625 sin6.sin6_port = ports[1];
626 sin6.sin6_flowinfo = 0;
Hannes Frederic Sowa3868b7a2013-03-08 02:07:26 +0000627 sin6.sin6_scope_id =
628 ipv6_iface_scope_id(&ipv6_hdr(skb)->daddr,
629 opt->iif);
Balazs Scheidler6c468622010-10-21 16:08:28 +0200630
631 put_cmsg(msg, SOL_IPV6, IPV6_ORIGDSTADDR, sizeof(sin6), &sin6);
632 }
633 }
Hannes Frederic Sowa4b261c72014-01-20 03:43:08 +0100634}
635
636void ip6_datagram_recv_ctl(struct sock *sk, struct msghdr *msg,
637 struct sk_buff *skb)
638{
639 ip6_datagram_recv_common_ctl(sk, msg, skb);
640 ip6_datagram_recv_specific_ctl(sk, msg, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641}
Tom Parkin8e72d372013-01-31 01:02:25 +0000642EXPORT_SYMBOL_GPL(ip6_datagram_recv_ctl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
Tom Parkin73df66f2013-01-31 01:02:24 +0000644int ip6_datagram_send_ctl(struct net *net, struct sock *sk,
645 struct msghdr *msg, struct flowi6 *fl6,
646 struct ipv6_txoptions *opt,
647 int *hlimit, int *tclass, int *dontfrag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648{
649 struct in6_pktinfo *src_info;
650 struct cmsghdr *cmsg;
651 struct ipv6_rt_hdr *rthdr;
652 struct ipv6_opt_hdr *hdr;
653 int len;
654 int err = 0;
655
Gu Zhengf95b4142014-12-11 11:22:04 +0800656 for_each_cmsghdr(cmsg, msg) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 int addr_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
659 if (!CMSG_OK(msg, cmsg)) {
660 err = -EINVAL;
661 goto exit_f;
662 }
663
664 if (cmsg->cmsg_level != SOL_IPV6)
665 continue;
666
667 switch (cmsg->cmsg_type) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900668 case IPV6_PKTINFO:
669 case IPV6_2292PKTINFO:
YOSHIFUJI Hideaki187e3832008-06-04 13:01:37 +0900670 {
671 struct net_device *dev = NULL;
672
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900673 if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct in6_pktinfo))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 err = -EINVAL;
675 goto exit_f;
676 }
677
678 src_info = (struct in6_pktinfo *)CMSG_DATA(cmsg);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900679
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 if (src_info->ipi6_ifindex) {
David S. Miller4c9483b2011-03-12 16:22:43 -0500681 if (fl6->flowi6_oif &&
682 src_info->ipi6_ifindex != fl6->flowi6_oif)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 return -EINVAL;
David S. Miller4c9483b2011-03-12 16:22:43 -0500684 fl6->flowi6_oif = src_info->ipi6_ifindex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 }
686
YOSHIFUJI Hideaki187e3832008-06-04 13:01:37 +0900687 addr_type = __ipv6_addr_type(&src_info->ipi6_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
Eric Dumazet536b2e92009-11-02 12:21:06 +0100689 rcu_read_lock();
David S. Miller4c9483b2011-03-12 16:22:43 -0500690 if (fl6->flowi6_oif) {
691 dev = dev_get_by_index_rcu(net, fl6->flowi6_oif);
Eric Dumazet536b2e92009-11-02 12:21:06 +0100692 if (!dev) {
693 rcu_read_unlock();
YOSHIFUJI Hideaki187e3832008-06-04 13:01:37 +0900694 return -ENODEV;
Eric Dumazet536b2e92009-11-02 12:21:06 +0100695 }
696 } else if (addr_type & IPV6_ADDR_LINKLOCAL) {
697 rcu_read_unlock();
YOSHIFUJI Hideaki187e3832008-06-04 13:01:37 +0900698 return -EINVAL;
Eric Dumazet536b2e92009-11-02 12:21:06 +0100699 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900700
YOSHIFUJI Hideaki187e3832008-06-04 13:01:37 +0900701 if (addr_type != IPV6_ADDR_ANY) {
702 int strict = __ipv6_addr_src_scope(addr_type) <= IPV6_ADDR_SCOPE_LINKLOCAL;
Maciej Żenczykowski2563fa52011-11-07 14:57:22 +0000703 if (!(inet_sk(sk)->freebind || inet_sk(sk)->transparent) &&
Maciej Żenczykowskiec0506d2011-08-28 12:35:31 +0000704 !ipv6_chk_addr(net, &src_info->ipi6_addr,
FX Le Bail7c90cc22014-01-22 07:42:37 +0100705 strict ? dev : NULL, 0) &&
706 !ipv6_chk_acast_addr_src(net, dev,
707 &src_info->ipi6_addr))
YOSHIFUJI Hideaki187e3832008-06-04 13:01:37 +0900708 err = -EINVAL;
709 else
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000710 fl6->saddr = src_info->ipi6_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 }
YOSHIFUJI Hideaki187e3832008-06-04 13:01:37 +0900712
Eric Dumazet536b2e92009-11-02 12:21:06 +0100713 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
YOSHIFUJI Hideaki187e3832008-06-04 13:01:37 +0900715 if (err)
716 goto exit_f;
717
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 break;
YOSHIFUJI Hideaki187e3832008-06-04 13:01:37 +0900719 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720
721 case IPV6_FLOWINFO:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900722 if (cmsg->cmsg_len < CMSG_LEN(4)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 err = -EINVAL;
724 goto exit_f;
725 }
726
David S. Miller4c9483b2011-03-12 16:22:43 -0500727 if (fl6->flowlabel&IPV6_FLOWINFO_MASK) {
728 if ((fl6->flowlabel^*(__be32 *)CMSG_DATA(cmsg))&~IPV6_FLOWINFO_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 err = -EINVAL;
730 goto exit_f;
731 }
732 }
David S. Miller4c9483b2011-03-12 16:22:43 -0500733 fl6->flowlabel = IPV6_FLOWINFO_MASK & *(__be32 *)CMSG_DATA(cmsg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 break;
735
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900736 case IPV6_2292HOPOPTS:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 case IPV6_HOPOPTS:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900738 if (opt->hopopt || cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 err = -EINVAL;
740 goto exit_f;
741 }
742
743 hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
744 len = ((hdr->hdrlen + 1) << 3);
745 if (cmsg->cmsg_len < CMSG_LEN(len)) {
746 err = -EINVAL;
747 goto exit_f;
748 }
Eric W. Biedermanaf31f412012-11-16 03:03:06 +0000749 if (!ns_capable(net->user_ns, CAP_NET_RAW)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 err = -EPERM;
751 goto exit_f;
752 }
753 opt->opt_nflen += len;
754 opt->hopopt = hdr;
755 break;
756
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900757 case IPV6_2292DSTOPTS:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900758 if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 err = -EINVAL;
760 goto exit_f;
761 }
762
763 hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
764 len = ((hdr->hdrlen + 1) << 3);
765 if (cmsg->cmsg_len < CMSG_LEN(len)) {
766 err = -EINVAL;
767 goto exit_f;
768 }
Eric W. Biedermanaf31f412012-11-16 03:03:06 +0000769 if (!ns_capable(net->user_ns, CAP_NET_RAW)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 err = -EPERM;
771 goto exit_f;
772 }
773 if (opt->dst1opt) {
774 err = -EINVAL;
775 goto exit_f;
776 }
777 opt->opt_flen += len;
778 opt->dst1opt = hdr;
779 break;
780
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900781 case IPV6_DSTOPTS:
782 case IPV6_RTHDRDSTOPTS:
783 if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
784 err = -EINVAL;
785 goto exit_f;
786 }
787
788 hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
789 len = ((hdr->hdrlen + 1) << 3);
790 if (cmsg->cmsg_len < CMSG_LEN(len)) {
791 err = -EINVAL;
792 goto exit_f;
793 }
Eric W. Biedermanaf31f412012-11-16 03:03:06 +0000794 if (!ns_capable(net->user_ns, CAP_NET_RAW)) {
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900795 err = -EPERM;
796 goto exit_f;
797 }
798 if (cmsg->cmsg_type == IPV6_DSTOPTS) {
799 opt->opt_flen += len;
800 opt->dst1opt = hdr;
801 } else {
802 opt->opt_nflen += len;
803 opt->dst0opt = hdr;
804 }
805 break;
806
807 case IPV6_2292RTHDR:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 case IPV6_RTHDR:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900809 if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_rt_hdr))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 err = -EINVAL;
811 goto exit_f;
812 }
813
814 rthdr = (struct ipv6_rt_hdr *)CMSG_DATA(cmsg);
815
Masahide NAKAMURA280a9d32006-08-23 19:17:12 -0700816 switch (rthdr->type) {
Amerigo Wang07a93622012-10-29 16:23:10 +0000817#if IS_ENABLED(CONFIG_IPV6_MIP6)
Masahide NAKAMURA280a9d32006-08-23 19:17:12 -0700818 case IPV6_SRCRT_TYPE_2:
Brian Haley6e093d92008-11-12 22:59:21 -0800819 if (rthdr->hdrlen != 2 ||
820 rthdr->segments_left != 1) {
821 err = -EINVAL;
822 goto exit_f;
823 }
Masahide NAKAMURA280a9d32006-08-23 19:17:12 -0700824 break;
YOSHIFUJI Hideakibb4dbf92007-07-10 22:55:49 -0700825#endif
Masahide NAKAMURA280a9d32006-08-23 19:17:12 -0700826 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 err = -EINVAL;
828 goto exit_f;
829 }
830
831 len = ((rthdr->hdrlen + 1) << 3);
832
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900833 if (cmsg->cmsg_len < CMSG_LEN(len)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 err = -EINVAL;
835 goto exit_f;
836 }
837
838 /* segments left must also match */
839 if ((rthdr->hdrlen >> 1) != rthdr->segments_left) {
840 err = -EINVAL;
841 goto exit_f;
842 }
843
844 opt->opt_nflen += len;
845 opt->srcrt = rthdr;
846
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900847 if (cmsg->cmsg_type == IPV6_2292RTHDR && opt->dst1opt) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 int dsthdrlen = ((opt->dst1opt->hdrlen+1)<<3);
849
850 opt->opt_nflen += dsthdrlen;
851 opt->dst0opt = opt->dst1opt;
852 opt->dst1opt = NULL;
853 opt->opt_flen -= dsthdrlen;
854 }
855
856 break;
857
YOSHIFUJI Hideaki333fad52005-09-08 09:59:17 +0900858 case IPV6_2292HOPLIMIT:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 case IPV6_HOPLIMIT:
860 if (cmsg->cmsg_len != CMSG_LEN(sizeof(int))) {
861 err = -EINVAL;
862 goto exit_f;
863 }
864
865 *hlimit = *(int *)CMSG_DATA(cmsg);
Shan Weie8766fc2008-06-10 15:50:55 +0800866 if (*hlimit < -1 || *hlimit > 0xff) {
867 err = -EINVAL;
868 goto exit_f;
869 }
870
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 break;
872
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900873 case IPV6_TCLASS:
874 {
875 int tc;
876
877 err = -EINVAL;
Eldad Zackb5a42572012-04-01 07:49:03 +0000878 if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)))
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900879 goto exit_f;
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900880
881 tc = *(int *)CMSG_DATA(cmsg);
Remi Denis-Courmontd0ee0112006-09-13 20:08:07 -0700882 if (tc < -1 || tc > 0xff)
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900883 goto exit_f;
884
885 err = 0;
886 *tclass = tc;
887
888 break;
889 }
Brian Haley13b52cd2010-04-23 11:26:08 +0000890
891 case IPV6_DONTFRAG:
892 {
893 int df;
894
895 err = -EINVAL;
Eldad Zackb5a42572012-04-01 07:49:03 +0000896 if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)))
Brian Haley13b52cd2010-04-23 11:26:08 +0000897 goto exit_f;
Brian Haley13b52cd2010-04-23 11:26:08 +0000898
899 df = *(int *)CMSG_DATA(cmsg);
900 if (df < 0 || df > 1)
901 goto exit_f;
902
903 err = 0;
904 *dontfrag = df;
905
906 break;
907 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 default:
Joe Perchesba7a46f2014-11-11 10:59:17 -0800909 net_dbg_ratelimited("invalid cmsg type: %d\n",
910 cmsg->cmsg_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 err = -EINVAL;
Miao Xie4a367022008-07-29 23:57:58 -0700912 goto exit_f;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700913 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 }
915
916exit_f:
917 return err;
918}
Tom Parkin73df66f2013-01-31 01:02:24 +0000919EXPORT_SYMBOL_GPL(ip6_datagram_send_ctl);
Lorenzo Colitti17ef66af2013-05-31 15:05:48 +0000920
921void ip6_dgram_sock_seq_show(struct seq_file *seq, struct sock *sp,
922 __u16 srcp, __u16 destp, int bucket)
923{
Lorenzo Colitti17ef66af2013-05-31 15:05:48 +0000924 const struct in6_addr *dest, *src;
925
Eric Dumazetefe42082013-10-03 15:42:29 -0700926 dest = &sp->sk_v6_daddr;
927 src = &sp->sk_v6_rcv_saddr;
Lorenzo Colitti17ef66af2013-05-31 15:05:48 +0000928 seq_printf(seq,
929 "%5d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
Francesco Fuscod14c5ab2013-08-15 13:42:14 +0200930 "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %d\n",
Lorenzo Colitti17ef66af2013-05-31 15:05:48 +0000931 bucket,
932 src->s6_addr32[0], src->s6_addr32[1],
933 src->s6_addr32[2], src->s6_addr32[3], srcp,
934 dest->s6_addr32[0], dest->s6_addr32[1],
935 dest->s6_addr32[2], dest->s6_addr32[3], destp,
936 sp->sk_state,
937 sk_wmem_alloc_get(sp),
938 sk_rmem_alloc_get(sp),
939 0, 0L, 0,
940 from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
941 0,
942 sock_i_ino(sp),
943 atomic_read(&sp->sk_refcnt), sp,
944 atomic_read(&sp->sk_drops));
945}