xref: /openbmc/linux/net/ipv6/ipv6_sockglue.c (revision 732a675a)
1 /*
2  *	IPv6 BSD socket options interface
3  *	Linux INET6 implementation
4  *
5  *	Authors:
6  *	Pedro Roque		<roque@di.fc.ul.pt>
7  *
8  *	Based on linux/net/ipv4/ip_sockglue.c
9  *
10  *	$Id: ipv6_sockglue.c,v 1.41 2002/02/01 22:01:04 davem Exp $
11  *
12  *	This program is free software; you can redistribute it and/or
13  *      modify it under the terms of the GNU General Public License
14  *      as published by the Free Software Foundation; either version
15  *      2 of the License, or (at your option) any later version.
16  *
17  *	FIXME: Make the setsockopt code POSIX compliant: That is
18  *
19  *	o	Truncate getsockopt returns
20  *	o	Return an optlen of the truncated length if need be
21  *
22  *	Changes:
23  *	David L Stevens <dlstevens@us.ibm.com>:
24  *		- added multicast source filtering API for MLDv2
25  */
26 
27 #include <linux/module.h>
28 #include <linux/capability.h>
29 #include <linux/errno.h>
30 #include <linux/types.h>
31 #include <linux/socket.h>
32 #include <linux/sockios.h>
33 #include <linux/net.h>
34 #include <linux/in6.h>
35 #include <linux/mroute6.h>
36 #include <linux/netdevice.h>
37 #include <linux/if_arp.h>
38 #include <linux/init.h>
39 #include <linux/sysctl.h>
40 #include <linux/netfilter.h>
41 
42 #include <net/sock.h>
43 #include <net/snmp.h>
44 #include <net/ipv6.h>
45 #include <net/ndisc.h>
46 #include <net/protocol.h>
47 #include <net/transp_v6.h>
48 #include <net/ip6_route.h>
49 #include <net/addrconf.h>
50 #include <net/inet_common.h>
51 #include <net/tcp.h>
52 #include <net/udp.h>
53 #include <net/udplite.h>
54 #include <net/xfrm.h>
55 #include <net/compat.h>
56 
57 #include <asm/uaccess.h>
58 
59 DEFINE_SNMP_STAT(struct ipstats_mib, ipv6_statistics) __read_mostly;
60 
61 struct ip6_ra_chain *ip6_ra_chain;
62 DEFINE_RWLOCK(ip6_ra_lock);
63 
64 int ip6_ra_control(struct sock *sk, int sel, void (*destructor)(struct sock *))
65 {
66 	struct ip6_ra_chain *ra, *new_ra, **rap;
67 
68 	/* RA packet may be delivered ONLY to IPPROTO_RAW socket */
69 	if (sk->sk_type != SOCK_RAW || inet_sk(sk)->num != IPPROTO_RAW)
70 		return -EINVAL;
71 
72 	new_ra = (sel>=0) ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
73 
74 	write_lock_bh(&ip6_ra_lock);
75 	for (rap = &ip6_ra_chain; (ra=*rap) != NULL; rap = &ra->next) {
76 		if (ra->sk == sk) {
77 			if (sel>=0) {
78 				write_unlock_bh(&ip6_ra_lock);
79 				kfree(new_ra);
80 				return -EADDRINUSE;
81 			}
82 
83 			*rap = ra->next;
84 			write_unlock_bh(&ip6_ra_lock);
85 
86 			if (ra->destructor)
87 				ra->destructor(sk);
88 			sock_put(sk);
89 			kfree(ra);
90 			return 0;
91 		}
92 	}
93 	if (new_ra == NULL) {
94 		write_unlock_bh(&ip6_ra_lock);
95 		return -ENOBUFS;
96 	}
97 	new_ra->sk = sk;
98 	new_ra->sel = sel;
99 	new_ra->destructor = destructor;
100 	new_ra->next = ra;
101 	*rap = new_ra;
102 	sock_hold(sk);
103 	write_unlock_bh(&ip6_ra_lock);
104 	return 0;
105 }
106 
107 static
108 struct ipv6_txoptions *ipv6_update_options(struct sock *sk,
109 					   struct ipv6_txoptions *opt)
110 {
111 	if (inet_sk(sk)->is_icsk) {
112 		if (opt &&
113 		    !((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE)) &&
114 		    inet_sk(sk)->daddr != LOOPBACK4_IPV6) {
115 			struct inet_connection_sock *icsk = inet_csk(sk);
116 			icsk->icsk_ext_hdr_len = opt->opt_flen + opt->opt_nflen;
117 			icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie);
118 		}
119 		opt = xchg(&inet6_sk(sk)->opt, opt);
120 	} else {
121 		write_lock(&sk->sk_dst_lock);
122 		opt = xchg(&inet6_sk(sk)->opt, opt);
123 		write_unlock(&sk->sk_dst_lock);
124 	}
125 	sk_dst_reset(sk);
126 
127 	return opt;
128 }
129 
130 static int do_ipv6_setsockopt(struct sock *sk, int level, int optname,
131 		    char __user *optval, int optlen)
132 {
133 	struct ipv6_pinfo *np = inet6_sk(sk);
134 	struct net *net = sock_net(sk);
135 	int val, valbool;
136 	int retv = -ENOPROTOOPT;
137 
138 	if (optval == NULL)
139 		val=0;
140 	else {
141 		if (optlen >= sizeof(int)) {
142 			if (get_user(val, (int __user *) optval))
143 				return -EFAULT;
144 		} else
145 			val = 0;
146 	}
147 
148 	valbool = (val!=0);
149 
150 	if (ip6_mroute_opt(optname))
151 		return ip6_mroute_setsockopt(sk, optname, optval, optlen);
152 
153 	lock_sock(sk);
154 
155 	switch (optname) {
156 
157 	case IPV6_ADDRFORM:
158 		if (optlen < sizeof(int))
159 			goto e_inval;
160 		if (val == PF_INET) {
161 			struct ipv6_txoptions *opt;
162 			struct sk_buff *pktopt;
163 
164 			if (sk->sk_type == SOCK_RAW)
165 				break;
166 
167 			if (sk->sk_protocol == IPPROTO_UDP ||
168 			    sk->sk_protocol == IPPROTO_UDPLITE) {
169 				struct udp_sock *up = udp_sk(sk);
170 				if (up->pending == AF_INET6) {
171 					retv = -EBUSY;
172 					break;
173 				}
174 			} else if (sk->sk_protocol != IPPROTO_TCP)
175 				break;
176 
177 			if (sk->sk_state != TCP_ESTABLISHED) {
178 				retv = -ENOTCONN;
179 				break;
180 			}
181 
182 			if (ipv6_only_sock(sk) ||
183 			    !ipv6_addr_v4mapped(&np->daddr)) {
184 				retv = -EADDRNOTAVAIL;
185 				break;
186 			}
187 
188 			fl6_free_socklist(sk);
189 			ipv6_sock_mc_close(sk);
190 
191 			/*
192 			 * Sock is moving from IPv6 to IPv4 (sk_prot), so
193 			 * remove it from the refcnt debug socks count in the
194 			 * original family...
195 			 */
196 			sk_refcnt_debug_dec(sk);
197 
198 			if (sk->sk_protocol == IPPROTO_TCP) {
199 				struct inet_connection_sock *icsk = inet_csk(sk);
200 				local_bh_disable();
201 				sock_prot_inuse_add(net, sk->sk_prot, -1);
202 				sock_prot_inuse_add(net, &tcp_prot, 1);
203 				local_bh_enable();
204 				sk->sk_prot = &tcp_prot;
205 				icsk->icsk_af_ops = &ipv4_specific;
206 				sk->sk_socket->ops = &inet_stream_ops;
207 				sk->sk_family = PF_INET;
208 				tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
209 			} else {
210 				struct proto *prot = &udp_prot;
211 
212 				if (sk->sk_protocol == IPPROTO_UDPLITE)
213 					prot = &udplite_prot;
214 				local_bh_disable();
215 				sock_prot_inuse_add(net, sk->sk_prot, -1);
216 				sock_prot_inuse_add(net, prot, 1);
217 				local_bh_enable();
218 				sk->sk_prot = prot;
219 				sk->sk_socket->ops = &inet_dgram_ops;
220 				sk->sk_family = PF_INET;
221 			}
222 			opt = xchg(&np->opt, NULL);
223 			if (opt)
224 				sock_kfree_s(sk, opt, opt->tot_len);
225 			pktopt = xchg(&np->pktoptions, NULL);
226 			if (pktopt)
227 				kfree_skb(pktopt);
228 
229 			sk->sk_destruct = inet_sock_destruct;
230 			/*
231 			 * ... and add it to the refcnt debug socks count
232 			 * in the new family. -acme
233 			 */
234 			sk_refcnt_debug_inc(sk);
235 			module_put(THIS_MODULE);
236 			retv = 0;
237 			break;
238 		}
239 		goto e_inval;
240 
241 	case IPV6_V6ONLY:
242 		if (optlen < sizeof(int) ||
243 		    inet_sk(sk)->num)
244 			goto e_inval;
245 		np->ipv6only = valbool;
246 		retv = 0;
247 		break;
248 
249 	case IPV6_RECVPKTINFO:
250 		if (optlen < sizeof(int))
251 			goto e_inval;
252 		np->rxopt.bits.rxinfo = valbool;
253 		retv = 0;
254 		break;
255 
256 	case IPV6_2292PKTINFO:
257 		if (optlen < sizeof(int))
258 			goto e_inval;
259 		np->rxopt.bits.rxoinfo = valbool;
260 		retv = 0;
261 		break;
262 
263 	case IPV6_RECVHOPLIMIT:
264 		if (optlen < sizeof(int))
265 			goto e_inval;
266 		np->rxopt.bits.rxhlim = valbool;
267 		retv = 0;
268 		break;
269 
270 	case IPV6_2292HOPLIMIT:
271 		if (optlen < sizeof(int))
272 			goto e_inval;
273 		np->rxopt.bits.rxohlim = valbool;
274 		retv = 0;
275 		break;
276 
277 	case IPV6_RECVRTHDR:
278 		if (optlen < sizeof(int))
279 			goto e_inval;
280 		np->rxopt.bits.srcrt = valbool;
281 		retv = 0;
282 		break;
283 
284 	case IPV6_2292RTHDR:
285 		if (optlen < sizeof(int))
286 			goto e_inval;
287 		np->rxopt.bits.osrcrt = valbool;
288 		retv = 0;
289 		break;
290 
291 	case IPV6_RECVHOPOPTS:
292 		if (optlen < sizeof(int))
293 			goto e_inval;
294 		np->rxopt.bits.hopopts = valbool;
295 		retv = 0;
296 		break;
297 
298 	case IPV6_2292HOPOPTS:
299 		if (optlen < sizeof(int))
300 			goto e_inval;
301 		np->rxopt.bits.ohopopts = valbool;
302 		retv = 0;
303 		break;
304 
305 	case IPV6_RECVDSTOPTS:
306 		if (optlen < sizeof(int))
307 			goto e_inval;
308 		np->rxopt.bits.dstopts = valbool;
309 		retv = 0;
310 		break;
311 
312 	case IPV6_2292DSTOPTS:
313 		if (optlen < sizeof(int))
314 			goto e_inval;
315 		np->rxopt.bits.odstopts = valbool;
316 		retv = 0;
317 		break;
318 
319 	case IPV6_TCLASS:
320 		if (optlen < sizeof(int))
321 			goto e_inval;
322 		if (val < -1 || val > 0xff)
323 			goto e_inval;
324 		np->tclass = val;
325 		retv = 0;
326 		break;
327 
328 	case IPV6_RECVTCLASS:
329 		if (optlen < sizeof(int))
330 			goto e_inval;
331 		np->rxopt.bits.rxtclass = valbool;
332 		retv = 0;
333 		break;
334 
335 	case IPV6_FLOWINFO:
336 		if (optlen < sizeof(int))
337 			goto e_inval;
338 		np->rxopt.bits.rxflow = valbool;
339 		retv = 0;
340 		break;
341 
342 	case IPV6_HOPOPTS:
343 	case IPV6_RTHDRDSTOPTS:
344 	case IPV6_RTHDR:
345 	case IPV6_DSTOPTS:
346 	{
347 		struct ipv6_txoptions *opt;
348 		if (optlen == 0)
349 			optval = NULL;
350 
351 		/* hop-by-hop / destination options are privileged option */
352 		retv = -EPERM;
353 		if (optname != IPV6_RTHDR && !capable(CAP_NET_RAW))
354 			break;
355 
356 		if (optlen < sizeof(struct ipv6_opt_hdr) ||
357 		    optlen & 0x7 || optlen > 8 * 255)
358 			goto e_inval;
359 
360 		opt = ipv6_renew_options(sk, np->opt, optname,
361 					 (struct ipv6_opt_hdr __user *)optval,
362 					 optlen);
363 		if (IS_ERR(opt)) {
364 			retv = PTR_ERR(opt);
365 			break;
366 		}
367 
368 		/* routing header option needs extra check */
369 		if (optname == IPV6_RTHDR && opt && opt->srcrt) {
370 			struct ipv6_rt_hdr *rthdr = opt->srcrt;
371 			switch (rthdr->type) {
372 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
373 			case IPV6_SRCRT_TYPE_2:
374 				break;
375 #endif
376 			default:
377 				goto sticky_done;
378 			}
379 
380 			if ((rthdr->hdrlen & 1) ||
381 			    (rthdr->hdrlen >> 1) != rthdr->segments_left)
382 				goto sticky_done;
383 		}
384 
385 		retv = 0;
386 		opt = ipv6_update_options(sk, opt);
387 sticky_done:
388 		if (opt)
389 			sock_kfree_s(sk, opt, opt->tot_len);
390 		break;
391 	}
392 
393 	case IPV6_2292PKTOPTIONS:
394 	{
395 		struct ipv6_txoptions *opt = NULL;
396 		struct msghdr msg;
397 		struct flowi fl;
398 		int junk;
399 
400 		fl.fl6_flowlabel = 0;
401 		fl.oif = sk->sk_bound_dev_if;
402 
403 		if (optlen == 0)
404 			goto update;
405 
406 		/* 1K is probably excessive
407 		 * 1K is surely not enough, 2K per standard header is 16K.
408 		 */
409 		retv = -EINVAL;
410 		if (optlen > 64*1024)
411 			break;
412 
413 		opt = sock_kmalloc(sk, sizeof(*opt) + optlen, GFP_KERNEL);
414 		retv = -ENOBUFS;
415 		if (opt == NULL)
416 			break;
417 
418 		memset(opt, 0, sizeof(*opt));
419 		opt->tot_len = sizeof(*opt) + optlen;
420 		retv = -EFAULT;
421 		if (copy_from_user(opt+1, optval, optlen))
422 			goto done;
423 
424 		msg.msg_controllen = optlen;
425 		msg.msg_control = (void*)(opt+1);
426 
427 		retv = datagram_send_ctl(net, &msg, &fl, opt, &junk, &junk);
428 		if (retv)
429 			goto done;
430 update:
431 		retv = 0;
432 		opt = ipv6_update_options(sk, opt);
433 done:
434 		if (opt)
435 			sock_kfree_s(sk, opt, opt->tot_len);
436 		break;
437 	}
438 	case IPV6_UNICAST_HOPS:
439 		if (optlen < sizeof(int))
440 			goto e_inval;
441 		if (val > 255 || val < -1)
442 			goto e_inval;
443 		np->hop_limit = val;
444 		retv = 0;
445 		break;
446 
447 	case IPV6_MULTICAST_HOPS:
448 		if (sk->sk_type == SOCK_STREAM)
449 			goto e_inval;
450 		if (optlen < sizeof(int))
451 			goto e_inval;
452 		if (val > 255 || val < -1)
453 			goto e_inval;
454 		np->mcast_hops = val;
455 		retv = 0;
456 		break;
457 
458 	case IPV6_MULTICAST_LOOP:
459 		if (optlen < sizeof(int))
460 			goto e_inval;
461 		np->mc_loop = valbool;
462 		retv = 0;
463 		break;
464 
465 	case IPV6_MULTICAST_IF:
466 		if (sk->sk_type == SOCK_STREAM)
467 			goto e_inval;
468 		if (optlen < sizeof(int))
469 			goto e_inval;
470 
471 		if (val) {
472 			if (sk->sk_bound_dev_if && sk->sk_bound_dev_if != val)
473 				goto e_inval;
474 
475 			if (__dev_get_by_index(net, val) == NULL) {
476 				retv = -ENODEV;
477 				break;
478 			}
479 		}
480 		np->mcast_oif = val;
481 		retv = 0;
482 		break;
483 	case IPV6_ADD_MEMBERSHIP:
484 	case IPV6_DROP_MEMBERSHIP:
485 	{
486 		struct ipv6_mreq mreq;
487 
488 		if (optlen < sizeof(struct ipv6_mreq))
489 			goto e_inval;
490 
491 		retv = -EPROTO;
492 		if (inet_sk(sk)->is_icsk)
493 			break;
494 
495 		retv = -EFAULT;
496 		if (copy_from_user(&mreq, optval, sizeof(struct ipv6_mreq)))
497 			break;
498 
499 		if (optname == IPV6_ADD_MEMBERSHIP)
500 			retv = ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
501 		else
502 			retv = ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
503 		break;
504 	}
505 	case IPV6_JOIN_ANYCAST:
506 	case IPV6_LEAVE_ANYCAST:
507 	{
508 		struct ipv6_mreq mreq;
509 
510 		if (optlen < sizeof(struct ipv6_mreq))
511 			goto e_inval;
512 
513 		retv = -EFAULT;
514 		if (copy_from_user(&mreq, optval, sizeof(struct ipv6_mreq)))
515 			break;
516 
517 		if (optname == IPV6_JOIN_ANYCAST)
518 			retv = ipv6_sock_ac_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr);
519 		else
520 			retv = ipv6_sock_ac_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr);
521 		break;
522 	}
523 	case MCAST_JOIN_GROUP:
524 	case MCAST_LEAVE_GROUP:
525 	{
526 		struct group_req greq;
527 		struct sockaddr_in6 *psin6;
528 
529 		if (optlen < sizeof(struct group_req))
530 			goto e_inval;
531 
532 		retv = -EFAULT;
533 		if (copy_from_user(&greq, optval, sizeof(struct group_req)))
534 			break;
535 		if (greq.gr_group.ss_family != AF_INET6) {
536 			retv = -EADDRNOTAVAIL;
537 			break;
538 		}
539 		psin6 = (struct sockaddr_in6 *)&greq.gr_group;
540 		if (optname == MCAST_JOIN_GROUP)
541 			retv = ipv6_sock_mc_join(sk, greq.gr_interface,
542 				&psin6->sin6_addr);
543 		else
544 			retv = ipv6_sock_mc_drop(sk, greq.gr_interface,
545 				&psin6->sin6_addr);
546 		break;
547 	}
548 	case MCAST_JOIN_SOURCE_GROUP:
549 	case MCAST_LEAVE_SOURCE_GROUP:
550 	case MCAST_BLOCK_SOURCE:
551 	case MCAST_UNBLOCK_SOURCE:
552 	{
553 		struct group_source_req greqs;
554 		int omode, add;
555 
556 		if (optlen < sizeof(struct group_source_req))
557 			goto e_inval;
558 		if (copy_from_user(&greqs, optval, sizeof(greqs))) {
559 			retv = -EFAULT;
560 			break;
561 		}
562 		if (greqs.gsr_group.ss_family != AF_INET6 ||
563 		    greqs.gsr_source.ss_family != AF_INET6) {
564 			retv = -EADDRNOTAVAIL;
565 			break;
566 		}
567 		if (optname == MCAST_BLOCK_SOURCE) {
568 			omode = MCAST_EXCLUDE;
569 			add = 1;
570 		} else if (optname == MCAST_UNBLOCK_SOURCE) {
571 			omode = MCAST_EXCLUDE;
572 			add = 0;
573 		} else if (optname == MCAST_JOIN_SOURCE_GROUP) {
574 			struct sockaddr_in6 *psin6;
575 
576 			psin6 = (struct sockaddr_in6 *)&greqs.gsr_group;
577 			retv = ipv6_sock_mc_join(sk, greqs.gsr_interface,
578 				&psin6->sin6_addr);
579 			/* prior join w/ different source is ok */
580 			if (retv && retv != -EADDRINUSE)
581 				break;
582 			omode = MCAST_INCLUDE;
583 			add = 1;
584 		} else /* MCAST_LEAVE_SOURCE_GROUP */ {
585 			omode = MCAST_INCLUDE;
586 			add = 0;
587 		}
588 		retv = ip6_mc_source(add, omode, sk, &greqs);
589 		break;
590 	}
591 	case MCAST_MSFILTER:
592 	{
593 		extern int sysctl_mld_max_msf;
594 		struct group_filter *gsf;
595 
596 		if (optlen < GROUP_FILTER_SIZE(0))
597 			goto e_inval;
598 		if (optlen > sysctl_optmem_max) {
599 			retv = -ENOBUFS;
600 			break;
601 		}
602 		gsf = kmalloc(optlen,GFP_KERNEL);
603 		if (!gsf) {
604 			retv = -ENOBUFS;
605 			break;
606 		}
607 		retv = -EFAULT;
608 		if (copy_from_user(gsf, optval, optlen)) {
609 			kfree(gsf);
610 			break;
611 		}
612 		/* numsrc >= (4G-140)/128 overflow in 32 bits */
613 		if (gsf->gf_numsrc >= 0x1ffffffU ||
614 		    gsf->gf_numsrc > sysctl_mld_max_msf) {
615 			kfree(gsf);
616 			retv = -ENOBUFS;
617 			break;
618 		}
619 		if (GROUP_FILTER_SIZE(gsf->gf_numsrc) > optlen) {
620 			kfree(gsf);
621 			retv = -EINVAL;
622 			break;
623 		}
624 		retv = ip6_mc_msfilter(sk, gsf);
625 		kfree(gsf);
626 
627 		break;
628 	}
629 	case IPV6_ROUTER_ALERT:
630 		if (optlen < sizeof(int))
631 			goto e_inval;
632 		retv = ip6_ra_control(sk, val, NULL);
633 		break;
634 	case IPV6_MTU_DISCOVER:
635 		if (optlen < sizeof(int))
636 			goto e_inval;
637 		if (val<0 || val>3)
638 			goto e_inval;
639 		np->pmtudisc = val;
640 		retv = 0;
641 		break;
642 	case IPV6_MTU:
643 		if (optlen < sizeof(int))
644 			goto e_inval;
645 		if (val && val < IPV6_MIN_MTU)
646 			goto e_inval;
647 		np->frag_size = val;
648 		retv = 0;
649 		break;
650 	case IPV6_RECVERR:
651 		if (optlen < sizeof(int))
652 			goto e_inval;
653 		np->recverr = valbool;
654 		if (!val)
655 			skb_queue_purge(&sk->sk_error_queue);
656 		retv = 0;
657 		break;
658 	case IPV6_FLOWINFO_SEND:
659 		if (optlen < sizeof(int))
660 			goto e_inval;
661 		np->sndflow = valbool;
662 		retv = 0;
663 		break;
664 	case IPV6_FLOWLABEL_MGR:
665 		retv = ipv6_flowlabel_opt(sk, optval, optlen);
666 		break;
667 	case IPV6_IPSEC_POLICY:
668 	case IPV6_XFRM_POLICY:
669 		retv = -EPERM;
670 		if (!capable(CAP_NET_ADMIN))
671 			break;
672 		retv = xfrm_user_policy(sk, optname, optval, optlen);
673 		break;
674 
675 	case IPV6_ADDR_PREFERENCES:
676 	    {
677 		unsigned int pref = 0;
678 		unsigned int prefmask = ~0;
679 
680 		if (optlen < sizeof(int))
681 			goto e_inval;
682 
683 		retv = -EINVAL;
684 
685 		/* check PUBLIC/TMP/PUBTMP_DEFAULT conflicts */
686 		switch (val & (IPV6_PREFER_SRC_PUBLIC|
687 			       IPV6_PREFER_SRC_TMP|
688 			       IPV6_PREFER_SRC_PUBTMP_DEFAULT)) {
689 		case IPV6_PREFER_SRC_PUBLIC:
690 			pref |= IPV6_PREFER_SRC_PUBLIC;
691 			break;
692 		case IPV6_PREFER_SRC_TMP:
693 			pref |= IPV6_PREFER_SRC_TMP;
694 			break;
695 		case IPV6_PREFER_SRC_PUBTMP_DEFAULT:
696 			break;
697 		case 0:
698 			goto pref_skip_pubtmp;
699 		default:
700 			goto e_inval;
701 		}
702 
703 		prefmask &= ~(IPV6_PREFER_SRC_PUBLIC|
704 			      IPV6_PREFER_SRC_TMP);
705 pref_skip_pubtmp:
706 
707 		/* check HOME/COA conflicts */
708 		switch (val & (IPV6_PREFER_SRC_HOME|IPV6_PREFER_SRC_COA)) {
709 		case IPV6_PREFER_SRC_HOME:
710 			break;
711 		case IPV6_PREFER_SRC_COA:
712 			pref |= IPV6_PREFER_SRC_COA;
713 		case 0:
714 			goto pref_skip_coa;
715 		default:
716 			goto e_inval;
717 		}
718 
719 		prefmask &= ~IPV6_PREFER_SRC_COA;
720 pref_skip_coa:
721 
722 		/* check CGA/NONCGA conflicts */
723 		switch (val & (IPV6_PREFER_SRC_CGA|IPV6_PREFER_SRC_NONCGA)) {
724 		case IPV6_PREFER_SRC_CGA:
725 		case IPV6_PREFER_SRC_NONCGA:
726 		case 0:
727 			break;
728 		default:
729 			goto e_inval;
730 		}
731 
732 		np->srcprefs = (np->srcprefs & prefmask) | pref;
733 		retv = 0;
734 
735 		break;
736 	    }
737 	}
738 
739 	release_sock(sk);
740 
741 	return retv;
742 
743 e_inval:
744 	release_sock(sk);
745 	return -EINVAL;
746 }
747 
748 int ipv6_setsockopt(struct sock *sk, int level, int optname,
749 		    char __user *optval, int optlen)
750 {
751 	int err;
752 
753 	if (level == SOL_IP && sk->sk_type != SOCK_RAW)
754 		return udp_prot.setsockopt(sk, level, optname, optval, optlen);
755 
756 	if (level != SOL_IPV6)
757 		return -ENOPROTOOPT;
758 
759 	err = do_ipv6_setsockopt(sk, level, optname, optval, optlen);
760 #ifdef CONFIG_NETFILTER
761 	/* we need to exclude all possible ENOPROTOOPTs except default case */
762 	if (err == -ENOPROTOOPT && optname != IPV6_IPSEC_POLICY &&
763 			optname != IPV6_XFRM_POLICY) {
764 		lock_sock(sk);
765 		err = nf_setsockopt(sk, PF_INET6, optname, optval,
766 				optlen);
767 		release_sock(sk);
768 	}
769 #endif
770 	return err;
771 }
772 
773 EXPORT_SYMBOL(ipv6_setsockopt);
774 
775 #ifdef CONFIG_COMPAT
776 int compat_ipv6_setsockopt(struct sock *sk, int level, int optname,
777 			   char __user *optval, int optlen)
778 {
779 	int err;
780 
781 	if (level == SOL_IP && sk->sk_type != SOCK_RAW) {
782 		if (udp_prot.compat_setsockopt != NULL)
783 			return udp_prot.compat_setsockopt(sk, level, optname,
784 							  optval, optlen);
785 		return udp_prot.setsockopt(sk, level, optname, optval, optlen);
786 	}
787 
788 	if (level != SOL_IPV6)
789 		return -ENOPROTOOPT;
790 
791 	if (optname >= MCAST_JOIN_GROUP && optname <= MCAST_MSFILTER)
792 		return compat_mc_setsockopt(sk, level, optname, optval, optlen,
793 			ipv6_setsockopt);
794 
795 	err = do_ipv6_setsockopt(sk, level, optname, optval, optlen);
796 #ifdef CONFIG_NETFILTER
797 	/* we need to exclude all possible ENOPROTOOPTs except default case */
798 	if (err == -ENOPROTOOPT && optname != IPV6_IPSEC_POLICY &&
799 	    optname != IPV6_XFRM_POLICY) {
800 		lock_sock(sk);
801 		err = compat_nf_setsockopt(sk, PF_INET6, optname,
802 					   optval, optlen);
803 		release_sock(sk);
804 	}
805 #endif
806 	return err;
807 }
808 
809 EXPORT_SYMBOL(compat_ipv6_setsockopt);
810 #endif
811 
812 static int ipv6_getsockopt_sticky(struct sock *sk, struct ipv6_txoptions *opt,
813 				  int optname, char __user *optval, int len)
814 {
815 	struct ipv6_opt_hdr *hdr;
816 
817 	if (!opt)
818 		return 0;
819 
820 	switch(optname) {
821 	case IPV6_HOPOPTS:
822 		hdr = opt->hopopt;
823 		break;
824 	case IPV6_RTHDRDSTOPTS:
825 		hdr = opt->dst0opt;
826 		break;
827 	case IPV6_RTHDR:
828 		hdr = (struct ipv6_opt_hdr *)opt->srcrt;
829 		break;
830 	case IPV6_DSTOPTS:
831 		hdr = opt->dst1opt;
832 		break;
833 	default:
834 		return -EINVAL;	/* should not happen */
835 	}
836 
837 	if (!hdr)
838 		return 0;
839 
840 	len = min_t(unsigned int, len, ipv6_optlen(hdr));
841 	if (copy_to_user(optval, hdr, len))
842 		return -EFAULT;
843 	return len;
844 }
845 
846 static int do_ipv6_getsockopt(struct sock *sk, int level, int optname,
847 		    char __user *optval, int __user *optlen)
848 {
849 	struct ipv6_pinfo *np = inet6_sk(sk);
850 	int len;
851 	int val;
852 
853 	if (ip6_mroute_opt(optname))
854 		return ip6_mroute_getsockopt(sk, optname, optval, optlen);
855 
856 	if (get_user(len, optlen))
857 		return -EFAULT;
858 	switch (optname) {
859 	case IPV6_ADDRFORM:
860 		if (sk->sk_protocol != IPPROTO_UDP &&
861 		    sk->sk_protocol != IPPROTO_UDPLITE &&
862 		    sk->sk_protocol != IPPROTO_TCP)
863 			return -EINVAL;
864 		if (sk->sk_state != TCP_ESTABLISHED)
865 			return -ENOTCONN;
866 		val = sk->sk_family;
867 		break;
868 	case MCAST_MSFILTER:
869 	{
870 		struct group_filter gsf;
871 		int err;
872 
873 		if (len < GROUP_FILTER_SIZE(0))
874 			return -EINVAL;
875 		if (copy_from_user(&gsf, optval, GROUP_FILTER_SIZE(0)))
876 			return -EFAULT;
877 		lock_sock(sk);
878 		err = ip6_mc_msfget(sk, &gsf,
879 			(struct group_filter __user *)optval, optlen);
880 		release_sock(sk);
881 		return err;
882 	}
883 
884 	case IPV6_2292PKTOPTIONS:
885 	{
886 		struct msghdr msg;
887 		struct sk_buff *skb;
888 
889 		if (sk->sk_type != SOCK_STREAM)
890 			return -ENOPROTOOPT;
891 
892 		msg.msg_control = optval;
893 		msg.msg_controllen = len;
894 		msg.msg_flags = 0;
895 
896 		lock_sock(sk);
897 		skb = np->pktoptions;
898 		if (skb)
899 			atomic_inc(&skb->users);
900 		release_sock(sk);
901 
902 		if (skb) {
903 			int err = datagram_recv_ctl(sk, &msg, skb);
904 			kfree_skb(skb);
905 			if (err)
906 				return err;
907 		} else {
908 			if (np->rxopt.bits.rxinfo) {
909 				struct in6_pktinfo src_info;
910 				src_info.ipi6_ifindex = np->mcast_oif;
911 				ipv6_addr_copy(&src_info.ipi6_addr, &np->daddr);
912 				put_cmsg(&msg, SOL_IPV6, IPV6_PKTINFO, sizeof(src_info), &src_info);
913 			}
914 			if (np->rxopt.bits.rxhlim) {
915 				int hlim = np->mcast_hops;
916 				put_cmsg(&msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);
917 			}
918 			if (np->rxopt.bits.rxoinfo) {
919 				struct in6_pktinfo src_info;
920 				src_info.ipi6_ifindex = np->mcast_oif;
921 				ipv6_addr_copy(&src_info.ipi6_addr, &np->daddr);
922 				put_cmsg(&msg, SOL_IPV6, IPV6_2292PKTINFO, sizeof(src_info), &src_info);
923 			}
924 			if (np->rxopt.bits.rxohlim) {
925 				int hlim = np->mcast_hops;
926 				put_cmsg(&msg, SOL_IPV6, IPV6_2292HOPLIMIT, sizeof(hlim), &hlim);
927 			}
928 		}
929 		len -= msg.msg_controllen;
930 		return put_user(len, optlen);
931 	}
932 	case IPV6_MTU:
933 	{
934 		struct dst_entry *dst;
935 		val = 0;
936 		lock_sock(sk);
937 		dst = sk_dst_get(sk);
938 		if (dst) {
939 			val = dst_mtu(dst);
940 			dst_release(dst);
941 		}
942 		release_sock(sk);
943 		if (!val)
944 			return -ENOTCONN;
945 		break;
946 	}
947 
948 	case IPV6_V6ONLY:
949 		val = np->ipv6only;
950 		break;
951 
952 	case IPV6_RECVPKTINFO:
953 		val = np->rxopt.bits.rxinfo;
954 		break;
955 
956 	case IPV6_2292PKTINFO:
957 		val = np->rxopt.bits.rxoinfo;
958 		break;
959 
960 	case IPV6_RECVHOPLIMIT:
961 		val = np->rxopt.bits.rxhlim;
962 		break;
963 
964 	case IPV6_2292HOPLIMIT:
965 		val = np->rxopt.bits.rxohlim;
966 		break;
967 
968 	case IPV6_RECVRTHDR:
969 		val = np->rxopt.bits.srcrt;
970 		break;
971 
972 	case IPV6_2292RTHDR:
973 		val = np->rxopt.bits.osrcrt;
974 		break;
975 
976 	case IPV6_HOPOPTS:
977 	case IPV6_RTHDRDSTOPTS:
978 	case IPV6_RTHDR:
979 	case IPV6_DSTOPTS:
980 	{
981 
982 		lock_sock(sk);
983 		len = ipv6_getsockopt_sticky(sk, np->opt,
984 					     optname, optval, len);
985 		release_sock(sk);
986 		/* check if ipv6_getsockopt_sticky() returns err code */
987 		if (len < 0)
988 			return len;
989 		return put_user(len, optlen);
990 	}
991 
992 	case IPV6_RECVHOPOPTS:
993 		val = np->rxopt.bits.hopopts;
994 		break;
995 
996 	case IPV6_2292HOPOPTS:
997 		val = np->rxopt.bits.ohopopts;
998 		break;
999 
1000 	case IPV6_RECVDSTOPTS:
1001 		val = np->rxopt.bits.dstopts;
1002 		break;
1003 
1004 	case IPV6_2292DSTOPTS:
1005 		val = np->rxopt.bits.odstopts;
1006 		break;
1007 
1008 	case IPV6_TCLASS:
1009 		val = np->tclass;
1010 		if (val < 0)
1011 			val = 0;
1012 		break;
1013 
1014 	case IPV6_RECVTCLASS:
1015 		val = np->rxopt.bits.rxtclass;
1016 		break;
1017 
1018 	case IPV6_FLOWINFO:
1019 		val = np->rxopt.bits.rxflow;
1020 		break;
1021 
1022 	case IPV6_UNICAST_HOPS:
1023 	case IPV6_MULTICAST_HOPS:
1024 	{
1025 		struct dst_entry *dst;
1026 
1027 		if (optname == IPV6_UNICAST_HOPS)
1028 			val = np->hop_limit;
1029 		else
1030 			val = np->mcast_hops;
1031 
1032 		dst = sk_dst_get(sk);
1033 		if (dst) {
1034 			if (val < 0)
1035 				val = ip6_dst_hoplimit(dst);
1036 			dst_release(dst);
1037 		}
1038 		if (val < 0)
1039 			val = ipv6_devconf.hop_limit;
1040 		break;
1041 	}
1042 
1043 	case IPV6_MULTICAST_LOOP:
1044 		val = np->mc_loop;
1045 		break;
1046 
1047 	case IPV6_MULTICAST_IF:
1048 		val = np->mcast_oif;
1049 		break;
1050 
1051 	case IPV6_MTU_DISCOVER:
1052 		val = np->pmtudisc;
1053 		break;
1054 
1055 	case IPV6_RECVERR:
1056 		val = np->recverr;
1057 		break;
1058 
1059 	case IPV6_FLOWINFO_SEND:
1060 		val = np->sndflow;
1061 		break;
1062 
1063 	case IPV6_ADDR_PREFERENCES:
1064 		val = 0;
1065 
1066 		if (np->srcprefs & IPV6_PREFER_SRC_TMP)
1067 			val |= IPV6_PREFER_SRC_TMP;
1068 		else if (np->srcprefs & IPV6_PREFER_SRC_PUBLIC)
1069 			val |= IPV6_PREFER_SRC_PUBLIC;
1070 		else {
1071 			/* XXX: should we return system default? */
1072 			val |= IPV6_PREFER_SRC_PUBTMP_DEFAULT;
1073 		}
1074 
1075 		if (np->srcprefs & IPV6_PREFER_SRC_COA)
1076 			val |= IPV6_PREFER_SRC_COA;
1077 		else
1078 			val |= IPV6_PREFER_SRC_HOME;
1079 		break;
1080 
1081 	default:
1082 		return -ENOPROTOOPT;
1083 	}
1084 	len = min_t(unsigned int, sizeof(int), len);
1085 	if(put_user(len, optlen))
1086 		return -EFAULT;
1087 	if(copy_to_user(optval,&val,len))
1088 		return -EFAULT;
1089 	return 0;
1090 }
1091 
1092 int ipv6_getsockopt(struct sock *sk, int level, int optname,
1093 		    char __user *optval, int __user *optlen)
1094 {
1095 	int err;
1096 
1097 	if (level == SOL_IP && sk->sk_type != SOCK_RAW)
1098 		return udp_prot.getsockopt(sk, level, optname, optval, optlen);
1099 
1100 	if(level != SOL_IPV6)
1101 		return -ENOPROTOOPT;
1102 
1103 	err = do_ipv6_getsockopt(sk, level, optname, optval, optlen);
1104 #ifdef CONFIG_NETFILTER
1105 	/* we need to exclude all possible ENOPROTOOPTs except default case */
1106 	if (err == -ENOPROTOOPT && optname != IPV6_2292PKTOPTIONS) {
1107 		int len;
1108 
1109 		if (get_user(len, optlen))
1110 			return -EFAULT;
1111 
1112 		lock_sock(sk);
1113 		err = nf_getsockopt(sk, PF_INET6, optname, optval,
1114 				&len);
1115 		release_sock(sk);
1116 		if (err >= 0)
1117 			err = put_user(len, optlen);
1118 	}
1119 #endif
1120 	return err;
1121 }
1122 
1123 EXPORT_SYMBOL(ipv6_getsockopt);
1124 
1125 #ifdef CONFIG_COMPAT
1126 int compat_ipv6_getsockopt(struct sock *sk, int level, int optname,
1127 			   char __user *optval, int __user *optlen)
1128 {
1129 	int err;
1130 
1131 	if (level == SOL_IP && sk->sk_type != SOCK_RAW) {
1132 		if (udp_prot.compat_getsockopt != NULL)
1133 			return udp_prot.compat_getsockopt(sk, level, optname,
1134 							  optval, optlen);
1135 		return udp_prot.getsockopt(sk, level, optname, optval, optlen);
1136 	}
1137 
1138 	if (level != SOL_IPV6)
1139 		return -ENOPROTOOPT;
1140 
1141 	if (optname == MCAST_MSFILTER)
1142 		return compat_mc_getsockopt(sk, level, optname, optval, optlen,
1143 			ipv6_getsockopt);
1144 
1145 	err = do_ipv6_getsockopt(sk, level, optname, optval, optlen);
1146 #ifdef CONFIG_NETFILTER
1147 	/* we need to exclude all possible ENOPROTOOPTs except default case */
1148 	if (err == -ENOPROTOOPT && optname != IPV6_2292PKTOPTIONS) {
1149 		int len;
1150 
1151 		if (get_user(len, optlen))
1152 			return -EFAULT;
1153 
1154 		lock_sock(sk);
1155 		err = compat_nf_getsockopt(sk, PF_INET6,
1156 					   optname, optval, &len);
1157 		release_sock(sk);
1158 		if (err >= 0)
1159 			err = put_user(len, optlen);
1160 	}
1161 #endif
1162 	return err;
1163 }
1164 
1165 EXPORT_SYMBOL(compat_ipv6_getsockopt);
1166 #endif
1167 
1168