1/*
2 *	common UDP/RAW code
3 *	Linux INET6 implementation
4 *
5 *	Authors:
6 *	Pedro Roque		<roque@di.fc.ul.pt>
7 *
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.
12 */
13
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
26#include <net/ipv6.h>
27#include <net/ndisc.h>
28#include <net/addrconf.h>
29#include <net/transp_v6.h>
30#include <net/ip6_route.h>
31#include <net/tcp_states.h>
32
33#include <linux/errqueue.h>
34#include <asm/uaccess.h>
35
36int ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
37{
38	struct sockaddr_in6	*usin = (struct sockaddr_in6 *) uaddr;
39	struct inet_sock      	*inet = inet_sk(sk);
40	struct ipv6_pinfo      	*np = inet6_sk(sk);
41	struct in6_addr		*daddr, *final_p, final;
42	struct dst_entry	*dst;
43	struct flowi		fl;
44	struct ip6_flowlabel	*flowlabel = NULL;
45	struct ipv6_txoptions   *opt;
46	int			addr_type;
47	int			err;
48
49	if (usin->sin6_family == AF_INET) {
50		if (__ipv6_only_sock(sk))
51			return -EAFNOSUPPORT;
52		err = ip4_datagram_connect(sk, uaddr, addr_len);
53		goto ipv4_connected;
54	}
55
56	if (addr_len < SIN6_LEN_RFC2133)
57		return -EINVAL;
58
59	if (usin->sin6_family != AF_INET6)
60		return -EAFNOSUPPORT;
61
62	memset(&fl, 0, sizeof(fl));
63	if (np->sndflow) {
64		fl.fl6_flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
65		if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) {
66			flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
67			if (flowlabel == NULL)
68				return -EINVAL;
69			ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
70		}
71	}
72
73	addr_type = ipv6_addr_type(&usin->sin6_addr);
74
75	if (addr_type == IPV6_ADDR_ANY) {
76		/*
77		 *	connect to self
78		 */
79		usin->sin6_addr.s6_addr[15] = 0x01;
80	}
81
82	daddr = &usin->sin6_addr;
83
84	if (addr_type == IPV6_ADDR_MAPPED) {
85		struct sockaddr_in sin;
86
87		if (__ipv6_only_sock(sk)) {
88			err = -ENETUNREACH;
89			goto out;
90		}
91		sin.sin_family = AF_INET;
92		sin.sin_addr.s_addr = daddr->s6_addr32[3];
93		sin.sin_port = usin->sin6_port;
94
95		err = ip4_datagram_connect(sk,
96					   (struct sockaddr*) &sin,
97					   sizeof(sin));
98
99ipv4_connected:
100		if (err)
101			goto out;
102
103		ipv6_addr_set_v4mapped(inet->inet_daddr, &np->daddr);
104
105		if (ipv6_addr_any(&np->saddr))
106			ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
107
108		if (ipv6_addr_any(&np->rcv_saddr)) {
109			ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
110					       &np->rcv_saddr);
111			if (sk->sk_prot->rehash)
112				sk->sk_prot->rehash(sk);
113		}
114
115		goto out;
116	}
117
118	if (addr_type&IPV6_ADDR_LINKLOCAL) {
119		if (addr_len >= sizeof(struct sockaddr_in6) &&
120		    usin->sin6_scope_id) {
121			if (sk->sk_bound_dev_if &&
122			    sk->sk_bound_dev_if != usin->sin6_scope_id) {
123				err = -EINVAL;
124				goto out;
125			}
126			sk->sk_bound_dev_if = usin->sin6_scope_id;
127		}
128
129		if (!sk->sk_bound_dev_if && (addr_type & IPV6_ADDR_MULTICAST))
130			sk->sk_bound_dev_if = np->mcast_oif;
131
132		/* Connect to link-local address requires an interface */
133		if (!sk->sk_bound_dev_if) {
134			err = -EINVAL;
135			goto out;
136		}
137	}
138
139	ipv6_addr_copy(&np->daddr, daddr);
140	np->flow_label = fl.fl6_flowlabel;
141
142	inet->inet_dport = usin->sin6_port;
143
144	/*
145	 *	Check for a route to destination an obtain the
146	 *	destination cache for it.
147	 */
148
149	fl.proto = sk->sk_protocol;
150	ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
151	ipv6_addr_copy(&fl.fl6_src, &np->saddr);
152	fl.oif = sk->sk_bound_dev_if;
153	fl.mark = sk->sk_mark;
154	fl.fl_ip_dport = inet->inet_dport;
155	fl.fl_ip_sport = inet->inet_sport;
156
157	if (!fl.oif && (addr_type&IPV6_ADDR_MULTICAST))
158		fl.oif = np->mcast_oif;
159
160	security_sk_classify_flow(sk, &fl);
161
162	opt = flowlabel ? flowlabel->opt : np->opt;
163	final_p = fl6_update_dst(&fl, opt, &final);
164
165	err = ip6_dst_lookup(sk, &dst, &fl);
166	if (err)
167		goto out;
168	if (final_p)
169		ipv6_addr_copy(&fl.fl6_dst, final_p);
170
171	err = __xfrm_lookup(sock_net(sk), &dst, &fl, sk, XFRM_LOOKUP_WAIT);
172	if (err < 0) {
173		if (err == -EREMOTE)
174			err = ip6_dst_blackhole(sk, &dst, &fl);
175		if (err < 0)
176			goto out;
177	}
178
179	/* source address lookup done in ip6_dst_lookup */
180
181	if (ipv6_addr_any(&np->saddr))
182		ipv6_addr_copy(&np->saddr, &fl.fl6_src);
183
184	if (ipv6_addr_any(&np->rcv_saddr)) {
185		ipv6_addr_copy(&np->rcv_saddr, &fl.fl6_src);
186		inet->inet_rcv_saddr = LOOPBACK4_IPV6;
187		if (sk->sk_prot->rehash)
188			sk->sk_prot->rehash(sk);
189	}
190
191	ip6_dst_store(sk, dst,
192		      ipv6_addr_equal(&fl.fl6_dst, &np->daddr) ?
193		      &np->daddr : NULL,
194#ifdef CONFIG_IPV6_SUBTREES
195		      ipv6_addr_equal(&fl.fl6_src, &np->saddr) ?
196		      &np->saddr :
197#endif
198		      NULL);
199
200	sk->sk_state = TCP_ESTABLISHED;
201out:
202	fl6_sock_release(flowlabel);
203	return err;
204}
205
206void ipv6_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
207		     __be16 port, u32 info, u8 *payload)
208{
209	struct ipv6_pinfo *np  = inet6_sk(sk);
210	struct icmp6hdr *icmph = icmp6_hdr(skb);
211	struct sock_exterr_skb *serr;
212
213	if (!np->recverr)
214		return;
215
216	skb = skb_clone(skb, GFP_ATOMIC);
217	if (!skb)
218		return;
219
220	skb->protocol = htons(ETH_P_IPV6);
221
222	serr = SKB_EXT_ERR(skb);
223	serr->ee.ee_errno = err;
224	serr->ee.ee_origin = SO_EE_ORIGIN_ICMP6;
225	serr->ee.ee_type = icmph->icmp6_type;
226	serr->ee.ee_code = icmph->icmp6_code;
227	serr->ee.ee_pad = 0;
228	serr->ee.ee_info = info;
229	serr->ee.ee_data = 0;
230	serr->addr_offset = (u8 *)&(((struct ipv6hdr *)(icmph + 1))->daddr) -
231				  skb_network_header(skb);
232	serr->port = port;
233
234	__skb_pull(skb, payload - skb->data);
235	skb_reset_transport_header(skb);
236
237	if (sock_queue_err_skb(sk, skb))
238		kfree_skb(skb);
239}
240
241void ipv6_local_error(struct sock *sk, int err, struct flowi *fl, u32 info)
242{
243	struct ipv6_pinfo *np = inet6_sk(sk);
244	struct sock_exterr_skb *serr;
245	struct ipv6hdr *iph;
246	struct sk_buff *skb;
247
248	if (!np->recverr)
249		return;
250
251	skb = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
252	if (!skb)
253		return;
254
255	skb->protocol = htons(ETH_P_IPV6);
256
257	skb_put(skb, sizeof(struct ipv6hdr));
258	skb_reset_network_header(skb);
259	iph = ipv6_hdr(skb);
260	ipv6_addr_copy(&iph->daddr, &fl->fl6_dst);
261
262	serr = SKB_EXT_ERR(skb);
263	serr->ee.ee_errno = err;
264	serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
265	serr->ee.ee_type = 0;
266	serr->ee.ee_code = 0;
267	serr->ee.ee_pad = 0;
268	serr->ee.ee_info = info;
269	serr->ee.ee_data = 0;
270	serr->addr_offset = (u8 *)&iph->daddr - skb_network_header(skb);
271	serr->port = fl->fl_ip_dport;
272
273	__skb_pull(skb, skb_tail_pointer(skb) - skb->data);
274	skb_reset_transport_header(skb);
275
276	if (sock_queue_err_skb(sk, skb))
277		kfree_skb(skb);
278}
279
280void ipv6_local_rxpmtu(struct sock *sk, struct flowi *fl, u32 mtu)
281{
282	struct ipv6_pinfo *np = inet6_sk(sk);
283	struct ipv6hdr *iph;
284	struct sk_buff *skb;
285	struct ip6_mtuinfo *mtu_info;
286
287	if (!np->rxopt.bits.rxpmtu)
288		return;
289
290	skb = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
291	if (!skb)
292		return;
293
294	skb_put(skb, sizeof(struct ipv6hdr));
295	skb_reset_network_header(skb);
296	iph = ipv6_hdr(skb);
297	ipv6_addr_copy(&iph->daddr, &fl->fl6_dst);
298
299	mtu_info = IP6CBMTU(skb);
300	if (!mtu_info) {
301		kfree_skb(skb);
302		return;
303	}
304
305	mtu_info->ip6m_mtu = mtu;
306	mtu_info->ip6m_addr.sin6_family = AF_INET6;
307	mtu_info->ip6m_addr.sin6_port = 0;
308	mtu_info->ip6m_addr.sin6_flowinfo = 0;
309	mtu_info->ip6m_addr.sin6_scope_id = fl->oif;
310	ipv6_addr_copy(&mtu_info->ip6m_addr.sin6_addr, &ipv6_hdr(skb)->daddr);
311
312	__skb_pull(skb, skb_tail_pointer(skb) - skb->data);
313	skb_reset_transport_header(skb);
314
315	skb = xchg(&np->rxpmtu, skb);
316	kfree_skb(skb);
317}
318
319/*
320 *	Handle MSG_ERRQUEUE
321 */
322int ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len)
323{
324	struct ipv6_pinfo *np = inet6_sk(sk);
325	struct sock_exterr_skb *serr;
326	struct sk_buff *skb, *skb2;
327	struct sockaddr_in6 *sin;
328	struct {
329		struct sock_extended_err ee;
330		struct sockaddr_in6	 offender;
331	} errhdr;
332	int err;
333	int copied;
334
335	err = -EAGAIN;
336	skb = skb_dequeue(&sk->sk_error_queue);
337	if (skb == NULL)
338		goto out;
339
340	copied = skb->len;
341	if (copied > len) {
342		msg->msg_flags |= MSG_TRUNC;
343		copied = len;
344	}
345	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
346	if (err)
347		goto out_free_skb;
348
349	sock_recv_timestamp(msg, sk, skb);
350
351	serr = SKB_EXT_ERR(skb);
352
353	sin = (struct sockaddr_in6 *)msg->msg_name;
354	if (sin) {
355		const unsigned char *nh = skb_network_header(skb);
356		sin->sin6_family = AF_INET6;
357		sin->sin6_flowinfo = 0;
358		sin->sin6_port = serr->port;
359		sin->sin6_scope_id = 0;
360		if (skb->protocol == htons(ETH_P_IPV6)) {
361			ipv6_addr_copy(&sin->sin6_addr,
362				  (struct in6_addr *)(nh + serr->addr_offset));
363			if (np->sndflow)
364				sin->sin6_flowinfo =
365					(*(__be32 *)(nh + serr->addr_offset - 24) &
366					 IPV6_FLOWINFO_MASK);
367			if (ipv6_addr_type(&sin->sin6_addr) & IPV6_ADDR_LINKLOCAL)
368				sin->sin6_scope_id = IP6CB(skb)->iif;
369		} else {
370			ipv6_addr_set_v4mapped(*(__be32 *)(nh + serr->addr_offset),
371					       &sin->sin6_addr);
372		}
373	}
374
375	memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
376	sin = &errhdr.offender;
377	sin->sin6_family = AF_UNSPEC;
378	if (serr->ee.ee_origin != SO_EE_ORIGIN_LOCAL) {
379		sin->sin6_family = AF_INET6;
380		sin->sin6_flowinfo = 0;
381		sin->sin6_scope_id = 0;
382		if (skb->protocol == htons(ETH_P_IPV6)) {
383			ipv6_addr_copy(&sin->sin6_addr, &ipv6_hdr(skb)->saddr);
384			if (np->rxopt.all)
385				datagram_recv_ctl(sk, msg, skb);
386			if (ipv6_addr_type(&sin->sin6_addr) & IPV6_ADDR_LINKLOCAL)
387				sin->sin6_scope_id = IP6CB(skb)->iif;
388		} else {
389			struct inet_sock *inet = inet_sk(sk);
390
391			ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr,
392					       &sin->sin6_addr);
393			if (inet->cmsg_flags)
394				ip_cmsg_recv(msg, skb);
395		}
396	}
397
398	put_cmsg(msg, SOL_IPV6, IPV6_RECVERR, sizeof(errhdr), &errhdr);
399
400	/* Now we could try to dump offended packet options */
401
402	msg->msg_flags |= MSG_ERRQUEUE;
403	err = copied;
404
405	/* Reset and regenerate socket error */
406	spin_lock_bh(&sk->sk_error_queue.lock);
407	sk->sk_err = 0;
408	if ((skb2 = skb_peek(&sk->sk_error_queue)) != NULL) {
409		sk->sk_err = SKB_EXT_ERR(skb2)->ee.ee_errno;
410		spin_unlock_bh(&sk->sk_error_queue.lock);
411		sk->sk_error_report(sk);
412	} else {
413		spin_unlock_bh(&sk->sk_error_queue.lock);
414	}
415
416out_free_skb:
417	kfree_skb(skb);
418out:
419	return err;
420}
421
422/*
423 *	Handle IPV6_RECVPATHMTU
424 */
425int ipv6_recv_rxpmtu(struct sock *sk, struct msghdr *msg, int len)
426{
427	struct ipv6_pinfo *np = inet6_sk(sk);
428	struct sk_buff *skb;
429	struct sockaddr_in6 *sin;
430	struct ip6_mtuinfo mtu_info;
431	int err;
432	int copied;
433
434	err = -EAGAIN;
435	skb = xchg(&np->rxpmtu, NULL);
436	if (skb == NULL)
437		goto out;
438
439	copied = skb->len;
440	if (copied > len) {
441		msg->msg_flags |= MSG_TRUNC;
442		copied = len;
443	}
444	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
445	if (err)
446		goto out_free_skb;
447
448	sock_recv_timestamp(msg, sk, skb);
449
450	memcpy(&mtu_info, IP6CBMTU(skb), sizeof(mtu_info));
451
452	sin = (struct sockaddr_in6 *)msg->msg_name;
453	if (sin) {
454		sin->sin6_family = AF_INET6;
455		sin->sin6_flowinfo = 0;
456		sin->sin6_port = 0;
457		sin->sin6_scope_id = mtu_info.ip6m_addr.sin6_scope_id;
458		ipv6_addr_copy(&sin->sin6_addr, &mtu_info.ip6m_addr.sin6_addr);
459	}
460
461	put_cmsg(msg, SOL_IPV6, IPV6_PATHMTU, sizeof(mtu_info), &mtu_info);
462
463	err = copied;
464
465out_free_skb:
466	kfree_skb(skb);
467out:
468	return err;
469}
470
471
472int datagram_recv_ctl(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
473{
474	struct ipv6_pinfo *np = inet6_sk(sk);
475	struct inet6_skb_parm *opt = IP6CB(skb);
476	unsigned char *nh = skb_network_header(skb);
477
478	if (np->rxopt.bits.rxinfo) {
479		struct in6_pktinfo src_info;
480
481		src_info.ipi6_ifindex = opt->iif;
482		ipv6_addr_copy(&src_info.ipi6_addr, &ipv6_hdr(skb)->daddr);
483		put_cmsg(msg, SOL_IPV6, IPV6_PKTINFO, sizeof(src_info), &src_info);
484	}
485
486	if (np->rxopt.bits.rxhlim) {
487		int hlim = ipv6_hdr(skb)->hop_limit;
488		put_cmsg(msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);
489	}
490
491	if (np->rxopt.bits.rxtclass) {
492		int tclass = (ntohl(*(__be32 *)ipv6_hdr(skb)) >> 20) & 0xff;
493		put_cmsg(msg, SOL_IPV6, IPV6_TCLASS, sizeof(tclass), &tclass);
494	}
495
496	if (np->rxopt.bits.rxflow && (*(__be32 *)nh & IPV6_FLOWINFO_MASK)) {
497		__be32 flowinfo = *(__be32 *)nh & IPV6_FLOWINFO_MASK;
498		put_cmsg(msg, SOL_IPV6, IPV6_FLOWINFO, sizeof(flowinfo), &flowinfo);
499	}
500
501	/* HbH is allowed only once */
502	if (np->rxopt.bits.hopopts && opt->hop) {
503		u8 *ptr = nh + opt->hop;
504		put_cmsg(msg, SOL_IPV6, IPV6_HOPOPTS, (ptr[1]+1)<<3, ptr);
505	}
506
507	if (opt->lastopt &&
508	    (np->rxopt.bits.dstopts || np->rxopt.bits.srcrt)) {
509		/*
510		 * Silly enough, but we need to reparse in order to
511		 * report extension headers (except for HbH)
512		 * in order.
513		 *
514		 * Also note that IPV6_RECVRTHDRDSTOPTS is NOT
515		 * (and WILL NOT be) defined because
516		 * IPV6_RECVDSTOPTS is more generic. --yoshfuji
517		 */
518		unsigned int off = sizeof(struct ipv6hdr);
519		u8 nexthdr = ipv6_hdr(skb)->nexthdr;
520
521		while (off <= opt->lastopt) {
522			unsigned len;
523			u8 *ptr = nh + off;
524
525			switch(nexthdr) {
526			case IPPROTO_DSTOPTS:
527				nexthdr = ptr[0];
528				len = (ptr[1] + 1) << 3;
529				if (np->rxopt.bits.dstopts)
530					put_cmsg(msg, SOL_IPV6, IPV6_DSTOPTS, len, ptr);
531				break;
532			case IPPROTO_ROUTING:
533				nexthdr = ptr[0];
534				len = (ptr[1] + 1) << 3;
535				if (np->rxopt.bits.srcrt)
536					put_cmsg(msg, SOL_IPV6, IPV6_RTHDR, len, ptr);
537				break;
538			case IPPROTO_AH:
539				nexthdr = ptr[0];
540				len = (ptr[1] + 2) << 2;
541				break;
542			default:
543				nexthdr = ptr[0];
544				len = (ptr[1] + 1) << 3;
545				break;
546			}
547
548			off += len;
549		}
550	}
551
552	/* socket options in old style */
553	if (np->rxopt.bits.rxoinfo) {
554		struct in6_pktinfo src_info;
555
556		src_info.ipi6_ifindex = opt->iif;
557		ipv6_addr_copy(&src_info.ipi6_addr, &ipv6_hdr(skb)->daddr);
558		put_cmsg(msg, SOL_IPV6, IPV6_2292PKTINFO, sizeof(src_info), &src_info);
559	}
560	if (np->rxopt.bits.rxohlim) {
561		int hlim = ipv6_hdr(skb)->hop_limit;
562		put_cmsg(msg, SOL_IPV6, IPV6_2292HOPLIMIT, sizeof(hlim), &hlim);
563	}
564	if (np->rxopt.bits.ohopopts && opt->hop) {
565		u8 *ptr = nh + opt->hop;
566		put_cmsg(msg, SOL_IPV6, IPV6_2292HOPOPTS, (ptr[1]+1)<<3, ptr);
567	}
568	if (np->rxopt.bits.odstopts && opt->dst0) {
569		u8 *ptr = nh + opt->dst0;
570		put_cmsg(msg, SOL_IPV6, IPV6_2292DSTOPTS, (ptr[1]+1)<<3, ptr);
571	}
572	if (np->rxopt.bits.osrcrt && opt->srcrt) {
573		struct ipv6_rt_hdr *rthdr = (struct ipv6_rt_hdr *)(nh + opt->srcrt);
574		put_cmsg(msg, SOL_IPV6, IPV6_2292RTHDR, (rthdr->hdrlen+1) << 3, rthdr);
575	}
576	if (np->rxopt.bits.odstopts && opt->dst1) {
577		u8 *ptr = nh + opt->dst1;
578		put_cmsg(msg, SOL_IPV6, IPV6_2292DSTOPTS, (ptr[1]+1)<<3, ptr);
579	}
580	return 0;
581}
582
583int datagram_send_ctl(struct net *net,
584		      struct msghdr *msg, struct flowi *fl,
585		      struct ipv6_txoptions *opt,
586		      int *hlimit, int *tclass, int *dontfrag)
587{
588	struct in6_pktinfo *src_info;
589	struct cmsghdr *cmsg;
590	struct ipv6_rt_hdr *rthdr;
591	struct ipv6_opt_hdr *hdr;
592	int len;
593	int err = 0;
594
595	for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
596		int addr_type;
597
598		if (!CMSG_OK(msg, cmsg)) {
599			err = -EINVAL;
600			goto exit_f;
601		}
602
603		if (cmsg->cmsg_level != SOL_IPV6)
604			continue;
605
606		switch (cmsg->cmsg_type) {
607		case IPV6_PKTINFO:
608		case IPV6_2292PKTINFO:
609		    {
610			struct net_device *dev = NULL;
611
612			if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct in6_pktinfo))) {
613				err = -EINVAL;
614				goto exit_f;
615			}
616
617			src_info = (struct in6_pktinfo *)CMSG_DATA(cmsg);
618
619			if (src_info->ipi6_ifindex) {
620				if (fl->oif && src_info->ipi6_ifindex != fl->oif)
621					return -EINVAL;
622				fl->oif = src_info->ipi6_ifindex;
623			}
624
625			addr_type = __ipv6_addr_type(&src_info->ipi6_addr);
626
627			rcu_read_lock();
628			if (fl->oif) {
629				dev = dev_get_by_index_rcu(net, fl->oif);
630				if (!dev) {
631					rcu_read_unlock();
632					return -ENODEV;
633				}
634			} else if (addr_type & IPV6_ADDR_LINKLOCAL) {
635				rcu_read_unlock();
636				return -EINVAL;
637			}
638
639			if (addr_type != IPV6_ADDR_ANY) {
640				int strict = __ipv6_addr_src_scope(addr_type) <= IPV6_ADDR_SCOPE_LINKLOCAL;
641				if (!ipv6_chk_addr(net, &src_info->ipi6_addr,
642						   strict ? dev : NULL, 0))
643					err = -EINVAL;
644				else
645					ipv6_addr_copy(&fl->fl6_src, &src_info->ipi6_addr);
646			}
647
648			rcu_read_unlock();
649
650			if (err)
651				goto exit_f;
652
653			break;
654		    }
655
656		case IPV6_FLOWINFO:
657			if (cmsg->cmsg_len < CMSG_LEN(4)) {
658				err = -EINVAL;
659				goto exit_f;
660			}
661
662			if (fl->fl6_flowlabel&IPV6_FLOWINFO_MASK) {
663				if ((fl->fl6_flowlabel^*(__be32 *)CMSG_DATA(cmsg))&~IPV6_FLOWINFO_MASK) {
664					err = -EINVAL;
665					goto exit_f;
666				}
667			}
668			fl->fl6_flowlabel = IPV6_FLOWINFO_MASK & *(__be32 *)CMSG_DATA(cmsg);
669			break;
670
671		case IPV6_2292HOPOPTS:
672		case IPV6_HOPOPTS:
673			if (opt->hopopt || cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
674				err = -EINVAL;
675				goto exit_f;
676			}
677
678			hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
679			len = ((hdr->hdrlen + 1) << 3);
680			if (cmsg->cmsg_len < CMSG_LEN(len)) {
681				err = -EINVAL;
682				goto exit_f;
683			}
684			if (!capable(CAP_NET_RAW)) {
685				err = -EPERM;
686				goto exit_f;
687			}
688			opt->opt_nflen += len;
689			opt->hopopt = hdr;
690			break;
691
692		case IPV6_2292DSTOPTS:
693			if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
694				err = -EINVAL;
695				goto exit_f;
696			}
697
698			hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
699			len = ((hdr->hdrlen + 1) << 3);
700			if (cmsg->cmsg_len < CMSG_LEN(len)) {
701				err = -EINVAL;
702				goto exit_f;
703			}
704			if (!capable(CAP_NET_RAW)) {
705				err = -EPERM;
706				goto exit_f;
707			}
708			if (opt->dst1opt) {
709				err = -EINVAL;
710				goto exit_f;
711			}
712			opt->opt_flen += len;
713			opt->dst1opt = hdr;
714			break;
715
716		case IPV6_DSTOPTS:
717		case IPV6_RTHDRDSTOPTS:
718			if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
719				err = -EINVAL;
720				goto exit_f;
721			}
722
723			hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
724			len = ((hdr->hdrlen + 1) << 3);
725			if (cmsg->cmsg_len < CMSG_LEN(len)) {
726				err = -EINVAL;
727				goto exit_f;
728			}
729			if (!capable(CAP_NET_RAW)) {
730				err = -EPERM;
731				goto exit_f;
732			}
733			if (cmsg->cmsg_type == IPV6_DSTOPTS) {
734				opt->opt_flen += len;
735				opt->dst1opt = hdr;
736			} else {
737				opt->opt_nflen += len;
738				opt->dst0opt = hdr;
739			}
740			break;
741
742		case IPV6_2292RTHDR:
743		case IPV6_RTHDR:
744			if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_rt_hdr))) {
745				err = -EINVAL;
746				goto exit_f;
747			}
748
749			rthdr = (struct ipv6_rt_hdr *)CMSG_DATA(cmsg);
750
751			switch (rthdr->type) {
752#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
753			case IPV6_SRCRT_TYPE_2:
754				if (rthdr->hdrlen != 2 ||
755				    rthdr->segments_left != 1) {
756					err = -EINVAL;
757					goto exit_f;
758				}
759				break;
760#endif
761			default:
762				err = -EINVAL;
763				goto exit_f;
764			}
765
766			len = ((rthdr->hdrlen + 1) << 3);
767
768			if (cmsg->cmsg_len < CMSG_LEN(len)) {
769				err = -EINVAL;
770				goto exit_f;
771			}
772
773			/* segments left must also match */
774			if ((rthdr->hdrlen >> 1) != rthdr->segments_left) {
775				err = -EINVAL;
776				goto exit_f;
777			}
778
779			opt->opt_nflen += len;
780			opt->srcrt = rthdr;
781
782			if (cmsg->cmsg_type == IPV6_2292RTHDR && opt->dst1opt) {
783				int dsthdrlen = ((opt->dst1opt->hdrlen+1)<<3);
784
785				opt->opt_nflen += dsthdrlen;
786				opt->dst0opt = opt->dst1opt;
787				opt->dst1opt = NULL;
788				opt->opt_flen -= dsthdrlen;
789			}
790
791			break;
792
793		case IPV6_2292HOPLIMIT:
794		case IPV6_HOPLIMIT:
795			if (cmsg->cmsg_len != CMSG_LEN(sizeof(int))) {
796				err = -EINVAL;
797				goto exit_f;
798			}
799
800			*hlimit = *(int *)CMSG_DATA(cmsg);
801			if (*hlimit < -1 || *hlimit > 0xff) {
802				err = -EINVAL;
803				goto exit_f;
804			}
805
806			break;
807
808		case IPV6_TCLASS:
809		    {
810			int tc;
811
812			err = -EINVAL;
813			if (cmsg->cmsg_len != CMSG_LEN(sizeof(int))) {
814				goto exit_f;
815			}
816
817			tc = *(int *)CMSG_DATA(cmsg);
818			if (tc < -1 || tc > 0xff)
819				goto exit_f;
820
821			err = 0;
822			*tclass = tc;
823
824			break;
825		    }
826
827		case IPV6_DONTFRAG:
828		    {
829			int df;
830
831			err = -EINVAL;
832			if (cmsg->cmsg_len != CMSG_LEN(sizeof(int))) {
833				goto exit_f;
834			}
835
836			df = *(int *)CMSG_DATA(cmsg);
837			if (df < 0 || df > 1)
838				goto exit_f;
839
840			err = 0;
841			*dontfrag = df;
842
843			break;
844		    }
845		default:
846			LIMIT_NETDEBUG(KERN_DEBUG "invalid cmsg type: %d\n",
847				       cmsg->cmsg_type);
848			err = -EINVAL;
849			goto exit_f;
850		}
851	}
852
853exit_f:
854	return err;
855}
856