ipv6_sockglue.c 29.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/*
 *	IPv6 BSD socket options interface
3
 *	Linux INET6 implementation
L
Linus Torvalds 已提交
4 5
 *
 *	Authors:
6
 *	Pedro Roque		<roque@di.fc.ul.pt>
L
Linus Torvalds 已提交
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
 *
 *	Based on linux/net/ipv4/ip_sockglue.c
 *
 *	This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 *
 *	FIXME: Make the setsockopt code POSIX compliant: That is
 *
 *	o	Truncate getsockopt returns
 *	o	Return an optlen of the truncated length if need be
 *
 *	Changes:
 *	David L Stevens <dlstevens@us.ibm.com>:
 *		- added multicast source filtering API for MLDv2
 */

#include <linux/module.h>
26
#include <linux/capability.h>
L
Linus Torvalds 已提交
27 28 29 30 31 32
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <linux/in6.h>
33
#include <linux/mroute6.h>
L
Linus Torvalds 已提交
34 35 36 37 38
#include <linux/netdevice.h>
#include <linux/if_arp.h>
#include <linux/init.h>
#include <linux/sysctl.h>
#include <linux/netfilter.h>
39
#include <linux/slab.h>
L
Linus Torvalds 已提交
40 41 42 43 44 45 46 47 48 49 50 51

#include <net/sock.h>
#include <net/snmp.h>
#include <net/ipv6.h>
#include <net/ndisc.h>
#include <net/protocol.h>
#include <net/transp_v6.h>
#include <net/ip6_route.h>
#include <net/addrconf.h>
#include <net/inet_common.h>
#include <net/tcp.h>
#include <net/udp.h>
52
#include <net/udplite.h>
L
Linus Torvalds 已提交
53
#include <net/xfrm.h>
54
#include <net/compat.h>
L
Linus Torvalds 已提交
55 56 57 58 59 60

#include <asm/uaccess.h>

struct ip6_ra_chain *ip6_ra_chain;
DEFINE_RWLOCK(ip6_ra_lock);

61
int ip6_ra_control(struct sock *sk, int sel)
L
Linus Torvalds 已提交
62 63 64 65
{
	struct ip6_ra_chain *ra, *new_ra, **rap;

	/* RA packet may be delivered ONLY to IPPROTO_RAW socket */
E
Eric Dumazet 已提交
66
	if (sk->sk_type != SOCK_RAW || inet_sk(sk)->inet_num != IPPROTO_RAW)
67
		return -ENOPROTOOPT;
L
Linus Torvalds 已提交
68

69
	new_ra = (sel >= 0) ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
L
Linus Torvalds 已提交
70 71

	write_lock_bh(&ip6_ra_lock);
72
	for (rap = &ip6_ra_chain; (ra = *rap) != NULL; rap = &ra->next) {
L
Linus Torvalds 已提交
73
		if (ra->sk == sk) {
74
			if (sel >= 0) {
L
Linus Torvalds 已提交
75
				write_unlock_bh(&ip6_ra_lock);
J
Jesper Juhl 已提交
76
				kfree(new_ra);
L
Linus Torvalds 已提交
77 78 79 80 81 82 83 84 85 86 87
				return -EADDRINUSE;
			}

			*rap = ra->next;
			write_unlock_bh(&ip6_ra_lock);

			sock_put(sk);
			kfree(ra);
			return 0;
		}
	}
88
	if (!new_ra) {
L
Linus Torvalds 已提交
89 90 91 92 93 94 95 96 97 98 99 100
		write_unlock_bh(&ip6_ra_lock);
		return -ENOBUFS;
	}
	new_ra->sk = sk;
	new_ra->sel = sel;
	new_ra->next = ra;
	*rap = new_ra;
	sock_hold(sk);
	write_unlock_bh(&ip6_ra_lock);
	return 0;
}

101 102 103 104 105 106 107
static
struct ipv6_txoptions *ipv6_update_options(struct sock *sk,
					   struct ipv6_txoptions *opt)
{
	if (inet_sk(sk)->is_icsk) {
		if (opt &&
		    !((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE)) &&
E
Eric Dumazet 已提交
108
		    inet_sk(sk)->inet_daddr != LOOPBACK4_IPV6) {
109 110 111 112 113
			struct inet_connection_sock *icsk = inet_csk(sk);
			icsk->icsk_ext_hdr_len = opt->opt_flen + opt->opt_nflen;
			icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie);
		}
	}
114 115
	opt = xchg((__force struct ipv6_txoptions **)&inet6_sk(sk)->opt,
		   opt);
116 117 118 119 120
	sk_dst_reset(sk);

	return opt;
}

121 122 123 124 125
static bool setsockopt_needs_rtnl(int optname)
{
	switch (optname) {
	case IPV6_ADD_MEMBERSHIP:
	case IPV6_DROP_MEMBERSHIP:
126 127
	case IPV6_JOIN_ANYCAST:
	case IPV6_LEAVE_ANYCAST:
128 129
	case MCAST_JOIN_GROUP:
	case MCAST_LEAVE_GROUP:
130 131 132 133 134
	case MCAST_JOIN_SOURCE_GROUP:
	case MCAST_LEAVE_SOURCE_GROUP:
	case MCAST_BLOCK_SOURCE:
	case MCAST_UNBLOCK_SOURCE:
	case MCAST_MSFILTER:
135 136 137 138 139
		return true;
	}
	return false;
}

140
static int do_ipv6_setsockopt(struct sock *sk, int level, int optname,
141
		    char __user *optval, unsigned int optlen)
L
Linus Torvalds 已提交
142 143
{
	struct ipv6_pinfo *np = inet6_sk(sk);
144
	struct net *net = sock_net(sk);
L
Linus Torvalds 已提交
145 146
	int val, valbool;
	int retv = -ENOPROTOOPT;
147
	bool needs_rtnl = setsockopt_needs_rtnl(optname);
L
Linus Torvalds 已提交
148

149
	if (!optval)
150
		val = 0;
151 152 153 154 155 156 157
	else {
		if (optlen >= sizeof(int)) {
			if (get_user(val, (int __user *) optval))
				return -EFAULT;
		} else
			val = 0;
	}
L
Linus Torvalds 已提交
158

159
	valbool = (val != 0);
L
Linus Torvalds 已提交
160

161 162 163
	if (ip6_mroute_opt(optname))
		return ip6_mroute_setsockopt(sk, optname, optval, optlen);

164 165
	if (needs_rtnl)
		rtnl_lock();
L
Linus Torvalds 已提交
166 167 168 169 170
	lock_sock(sk);

	switch (optname) {

	case IPV6_ADDRFORM:
171 172
		if (optlen < sizeof(int))
			goto e_inval;
L
Linus Torvalds 已提交
173 174 175 176
		if (val == PF_INET) {
			struct ipv6_txoptions *opt;
			struct sk_buff *pktopt;

177 178 179
			if (sk->sk_type == SOCK_RAW)
				break;

180 181 182 183 184 185 186 187
			if (sk->sk_protocol == IPPROTO_UDP ||
			    sk->sk_protocol == IPPROTO_UDPLITE) {
				struct udp_sock *up = udp_sk(sk);
				if (up->pending == AF_INET6) {
					retv = -EBUSY;
					break;
				}
			} else if (sk->sk_protocol != IPPROTO_TCP)
L
Linus Torvalds 已提交
188 189 190 191 192 193 194 195
				break;

			if (sk->sk_state != TCP_ESTABLISHED) {
				retv = -ENOTCONN;
				break;
			}

			if (ipv6_only_sock(sk) ||
196
			    !ipv6_addr_v4mapped(&sk->sk_v6_daddr)) {
L
Linus Torvalds 已提交
197 198 199 200 201 202 203
				retv = -EADDRNOTAVAIL;
				break;
			}

			fl6_free_socklist(sk);
			ipv6_sock_mc_close(sk);

204 205 206 207 208 209 210
			/*
			 * Sock is moving from IPv6 to IPv4 (sk_prot), so
			 * remove it from the refcnt debug socks count in the
			 * original family...
			 */
			sk_refcnt_debug_dec(sk);

L
Linus Torvalds 已提交
211
			if (sk->sk_protocol == IPPROTO_TCP) {
212
				struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
213
				local_bh_disable();
214 215
				sock_prot_inuse_add(net, sk->sk_prot, -1);
				sock_prot_inuse_add(net, &tcp_prot, 1);
L
Linus Torvalds 已提交
216 217
				local_bh_enable();
				sk->sk_prot = &tcp_prot;
218
				icsk->icsk_af_ops = &ipv4_specific;
L
Linus Torvalds 已提交
219 220
				sk->sk_socket->ops = &inet_stream_ops;
				sk->sk_family = PF_INET;
221
				tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
222
			} else {
223 224
				struct proto *prot = &udp_prot;

225
				if (sk->sk_protocol == IPPROTO_UDPLITE)
226
					prot = &udplite_prot;
L
Linus Torvalds 已提交
227
				local_bh_disable();
228 229
				sock_prot_inuse_add(net, sk->sk_prot, -1);
				sock_prot_inuse_add(net, prot, 1);
L
Linus Torvalds 已提交
230
				local_bh_enable();
231
				sk->sk_prot = prot;
L
Linus Torvalds 已提交
232 233 234
				sk->sk_socket->ops = &inet_dgram_ops;
				sk->sk_family = PF_INET;
			}
235 236 237 238 239 240
			opt = xchg((__force struct ipv6_txoptions **)&np->opt,
				   NULL);
			if (opt) {
				atomic_sub(opt->tot_len, &sk->sk_omem_alloc);
				txopt_put(opt);
			}
L
Linus Torvalds 已提交
241
			pktopt = xchg(&np->pktoptions, NULL);
242
			kfree_skb(pktopt);
L
Linus Torvalds 已提交
243 244

			sk->sk_destruct = inet_sock_destruct;
245 246 247 248 249
			/*
			 * ... and add it to the refcnt debug socks count
			 * in the new family. -acme
			 */
			sk_refcnt_debug_inc(sk);
L
Linus Torvalds 已提交
250 251 252 253 254 255 256
			module_put(THIS_MODULE);
			retv = 0;
			break;
		}
		goto e_inval;

	case IPV6_V6ONLY:
257
		if (optlen < sizeof(int) ||
E
Eric Dumazet 已提交
258
		    inet_sk(sk)->inet_num)
L
Linus Torvalds 已提交
259
			goto e_inval;
260
		sk->sk_ipv6only = valbool;
L
Linus Torvalds 已提交
261 262 263
		retv = 0;
		break;

264
	case IPV6_RECVPKTINFO:
265 266
		if (optlen < sizeof(int))
			goto e_inval;
L
Linus Torvalds 已提交
267 268 269
		np->rxopt.bits.rxinfo = valbool;
		retv = 0;
		break;
270

271
	case IPV6_2292PKTINFO:
272 273
		if (optlen < sizeof(int))
			goto e_inval;
274 275 276
		np->rxopt.bits.rxoinfo = valbool;
		retv = 0;
		break;
L
Linus Torvalds 已提交
277

278
	case IPV6_RECVHOPLIMIT:
279 280
		if (optlen < sizeof(int))
			goto e_inval;
L
Linus Torvalds 已提交
281 282 283 284
		np->rxopt.bits.rxhlim = valbool;
		retv = 0;
		break;

285
	case IPV6_2292HOPLIMIT:
286 287
		if (optlen < sizeof(int))
			goto e_inval;
288 289 290 291 292
		np->rxopt.bits.rxohlim = valbool;
		retv = 0;
		break;

	case IPV6_RECVRTHDR:
293 294
		if (optlen < sizeof(int))
			goto e_inval;
295
		np->rxopt.bits.srcrt = valbool;
L
Linus Torvalds 已提交
296 297 298
		retv = 0;
		break;

299
	case IPV6_2292RTHDR:
300 301
		if (optlen < sizeof(int))
			goto e_inval;
302
		np->rxopt.bits.osrcrt = valbool;
303 304 305 306
		retv = 0;
		break;

	case IPV6_RECVHOPOPTS:
307 308
		if (optlen < sizeof(int))
			goto e_inval;
L
Linus Torvalds 已提交
309 310 311 312
		np->rxopt.bits.hopopts = valbool;
		retv = 0;
		break;

313
	case IPV6_2292HOPOPTS:
314 315
		if (optlen < sizeof(int))
			goto e_inval;
316 317 318 319 320
		np->rxopt.bits.ohopopts = valbool;
		retv = 0;
		break;

	case IPV6_RECVDSTOPTS:
321 322
		if (optlen < sizeof(int))
			goto e_inval;
L
Linus Torvalds 已提交
323 324 325 326
		np->rxopt.bits.dstopts = valbool;
		retv = 0;
		break;

327
	case IPV6_2292DSTOPTS:
328 329
		if (optlen < sizeof(int))
			goto e_inval;
330 331 332 333
		np->rxopt.bits.odstopts = valbool;
		retv = 0;
		break;

334
	case IPV6_TCLASS:
335 336
		if (optlen < sizeof(int))
			goto e_inval;
337
		if (val < -1 || val > 0xff)
338
			goto e_inval;
G
Gerrit Renker 已提交
339 340 341
		/* RFC 3542, 6.5: default traffic class of 0x0 */
		if (val == -1)
			val = 0;
342 343 344
		np->tclass = val;
		retv = 0;
		break;
345

346
	case IPV6_RECVTCLASS:
347 348
		if (optlen < sizeof(int))
			goto e_inval;
349 350 351 352
		np->rxopt.bits.rxtclass = valbool;
		retv = 0;
		break;

L
Linus Torvalds 已提交
353
	case IPV6_FLOWINFO:
354 355
		if (optlen < sizeof(int))
			goto e_inval;
L
Linus Torvalds 已提交
356 357 358 359
		np->rxopt.bits.rxflow = valbool;
		retv = 0;
		break;

360 361 362 363 364 365 366
	case IPV6_RECVPATHMTU:
		if (optlen < sizeof(int))
			goto e_inval;
		np->rxopt.bits.rxpmtu = valbool;
		retv = 0;
		break;

367
	case IPV6_TRANSPARENT:
368 369
		if (valbool && !ns_capable(net->user_ns, CAP_NET_ADMIN) &&
		    !ns_capable(net->user_ns, CAP_NET_RAW)) {
370 371 372
			retv = -EPERM;
			break;
		}
373 374 375 376 377 378 379 380 381 382 383 384 385 386
		if (optlen < sizeof(int))
			goto e_inval;
		/* we don't have a separate transparent bit for IPV6 we use the one in the IPv4 socket */
		inet_sk(sk)->transparent = valbool;
		retv = 0;
		break;

	case IPV6_RECVORIGDSTADDR:
		if (optlen < sizeof(int))
			goto e_inval;
		np->rxopt.bits.rxorigdstaddr = valbool;
		retv = 0;
		break;

387 388 389 390 391 392
	case IPV6_HOPOPTS:
	case IPV6_RTHDRDSTOPTS:
	case IPV6_RTHDR:
	case IPV6_DSTOPTS:
	{
		struct ipv6_txoptions *opt;
393 394 395 396

		/* remove any sticky options header with a zero option
		 * length, per RFC3542.
		 */
397
		if (optlen == 0)
398
			optval = NULL;
399
		else if (!optval)
400
			goto e_inval;
401 402 403
		else if (optlen < sizeof(struct ipv6_opt_hdr) ||
			 optlen & 0x7 || optlen > 8 * 255)
			goto e_inval;
404 405 406

		/* hop-by-hop / destination options are privileged option */
		retv = -EPERM;
407
		if (optname != IPV6_RTHDR && !ns_capable(net->user_ns, CAP_NET_RAW))
408 409
			break;

410 411
		opt = rcu_dereference_protected(np->opt,
						lockdep_sock_is_held(sk));
412
		opt = ipv6_renew_options(sk, opt, optname,
413 414 415 416 417 418 419 420
					 (struct ipv6_opt_hdr __user *)optval,
					 optlen);
		if (IS_ERR(opt)) {
			retv = PTR_ERR(opt);
			break;
		}

		/* routing header option needs extra check */
B
Brian Haley 已提交
421
		retv = -EINVAL;
422
		if (optname == IPV6_RTHDR && opt && opt->srcrt) {
423
			struct ipv6_rt_hdr *rthdr = opt->srcrt;
424
			switch (rthdr->type) {
A
Amerigo Wang 已提交
425
#if IS_ENABLED(CONFIG_IPV6_MIP6)
426
			case IPV6_SRCRT_TYPE_2:
B
Brian Haley 已提交
427 428 429 430
				if (rthdr->hdrlen != 2 ||
				    rthdr->segments_left != 1)
					goto sticky_done;

431
				break;
432
#endif
433
			default:
434
				goto sticky_done;
435
			}
436 437 438
		}

		retv = 0;
439
		opt = ipv6_update_options(sk, opt);
440
sticky_done:
441 442 443 444
		if (opt) {
			atomic_sub(opt->tot_len, &sk->sk_omem_alloc);
			txopt_put(opt);
		}
445 446 447
		break;
	}

448 449 450 451 452 453
	case IPV6_PKTINFO:
	{
		struct in6_pktinfo pkt;

		if (optlen == 0)
			goto e_inval;
454
		else if (optlen < sizeof(struct in6_pktinfo) || !optval)
455 456
			goto e_inval;

457
		if (copy_from_user(&pkt, optval, sizeof(struct in6_pktinfo))) {
458 459 460 461 462 463 464
				retv = -EFAULT;
				break;
		}
		if (sk->sk_bound_dev_if && pkt.ipi6_ifindex != sk->sk_bound_dev_if)
			goto e_inval;

		np->sticky_pktinfo.ipi6_ifindex = pkt.ipi6_ifindex;
A
Alexey Dobriyan 已提交
465
		np->sticky_pktinfo.ipi6_addr = pkt.ipi6_addr;
466 467 468 469
		retv = 0;
		break;
	}

470
	case IPV6_2292PKTOPTIONS:
L
Linus Torvalds 已提交
471 472 473
	{
		struct ipv6_txoptions *opt = NULL;
		struct msghdr msg;
474
		struct flowi6 fl6;
475
		struct sockcm_cookie sockc_junk;
L
Linus Torvalds 已提交
476 477
		int junk;

478 479 480
		memset(&fl6, 0, sizeof(fl6));
		fl6.flowi6_oif = sk->sk_bound_dev_if;
		fl6.flowi6_mark = sk->sk_mark;
L
Linus Torvalds 已提交
481 482 483 484 485 486 487 488 489 490 491 492 493

		if (optlen == 0)
			goto update;

		/* 1K is probably excessive
		 * 1K is surely not enough, 2K per standard header is 16K.
		 */
		retv = -EINVAL;
		if (optlen > 64*1024)
			break;

		opt = sock_kmalloc(sk, sizeof(*opt) + optlen, GFP_KERNEL);
		retv = -ENOBUFS;
494
		if (!opt)
L
Linus Torvalds 已提交
495 496 497
			break;

		memset(opt, 0, sizeof(*opt));
498
		atomic_set(&opt->refcnt, 1);
L
Linus Torvalds 已提交
499 500 501 502 503 504
		opt->tot_len = sizeof(*opt) + optlen;
		retv = -EFAULT;
		if (copy_from_user(opt+1, optval, optlen))
			goto done;

		msg.msg_controllen = optlen;
505
		msg.msg_control = (void *)(opt+1);
L
Linus Torvalds 已提交
506

507
		retv = ip6_datagram_send_ctl(net, sk, &msg, &fl6, opt, &junk,
508
					     &junk, &junk, &sockc_junk);
L
Linus Torvalds 已提交
509 510 511 512
		if (retv)
			goto done;
update:
		retv = 0;
513
		opt = ipv6_update_options(sk, opt);
L
Linus Torvalds 已提交
514
done:
515 516 517 518
		if (opt) {
			atomic_sub(opt->tot_len, &sk->sk_omem_alloc);
			txopt_put(opt);
		}
L
Linus Torvalds 已提交
519 520 521
		break;
	}
	case IPV6_UNICAST_HOPS:
522 523
		if (optlen < sizeof(int))
			goto e_inval;
L
Linus Torvalds 已提交
524 525 526 527 528 529 530 531
		if (val > 255 || val < -1)
			goto e_inval;
		np->hop_limit = val;
		retv = 0;
		break;

	case IPV6_MULTICAST_HOPS:
		if (sk->sk_type == SOCK_STREAM)
532
			break;
533 534
		if (optlen < sizeof(int))
			goto e_inval;
L
Linus Torvalds 已提交
535 536
		if (val > 255 || val < -1)
			goto e_inval;
537
		np->mcast_hops = (val == -1 ? IPV6_DEFAULT_MCASTHOPS : val);
L
Linus Torvalds 已提交
538 539 540 541
		retv = 0;
		break;

	case IPV6_MULTICAST_LOOP:
542 543
		if (optlen < sizeof(int))
			goto e_inval;
544 545
		if (val != valbool)
			goto e_inval;
L
Linus Torvalds 已提交
546 547 548 549
		np->mc_loop = valbool;
		retv = 0;
		break;

550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579
	case IPV6_UNICAST_IF:
	{
		struct net_device *dev = NULL;
		int ifindex;

		if (optlen != sizeof(int))
			goto e_inval;

		ifindex = (__force int)ntohl((__force __be32)val);
		if (ifindex == 0) {
			np->ucast_oif = 0;
			retv = 0;
			break;
		}

		dev = dev_get_by_index(net, ifindex);
		retv = -EADDRNOTAVAIL;
		if (!dev)
			break;
		dev_put(dev);

		retv = -EINVAL;
		if (sk->sk_bound_dev_if)
			break;

		np->ucast_oif = ifindex;
		retv = 0;
		break;
	}

L
Linus Torvalds 已提交
580 581
	case IPV6_MULTICAST_IF:
		if (sk->sk_type == SOCK_STREAM)
582
			break;
583 584
		if (optlen < sizeof(int))
			goto e_inval;
L
Linus Torvalds 已提交
585

586
		if (val) {
E
Eric Dumazet 已提交
587 588
			struct net_device *dev;

589 590 591
			if (sk->sk_bound_dev_if && sk->sk_bound_dev_if != val)
				goto e_inval;

E
Eric Dumazet 已提交
592 593
			dev = dev_get_by_index(net, val);
			if (!dev) {
594 595 596
				retv = -ENODEV;
				break;
			}
E
Eric Dumazet 已提交
597
			dev_put(dev);
L
Linus Torvalds 已提交
598 599 600 601 602 603 604 605 606
		}
		np->mcast_oif = val;
		retv = 0;
		break;
	case IPV6_ADD_MEMBERSHIP:
	case IPV6_DROP_MEMBERSHIP:
	{
		struct ipv6_mreq mreq;

607 608 609
		if (optlen < sizeof(struct ipv6_mreq))
			goto e_inval;

610 611 612 613
		retv = -EPROTO;
		if (inet_sk(sk)->is_icsk)
			break;

L
Linus Torvalds 已提交
614 615 616 617 618
		retv = -EFAULT;
		if (copy_from_user(&mreq, optval, sizeof(struct ipv6_mreq)))
			break;

		if (optname == IPV6_ADD_MEMBERSHIP)
619
			retv = ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
L
Linus Torvalds 已提交
620
		else
621
			retv = ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
L
Linus Torvalds 已提交
622 623 624 625 626 627 628
		break;
	}
	case IPV6_JOIN_ANYCAST:
	case IPV6_LEAVE_ANYCAST:
	{
		struct ipv6_mreq mreq;

629
		if (optlen < sizeof(struct ipv6_mreq))
L
Linus Torvalds 已提交
630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647
			goto e_inval;

		retv = -EFAULT;
		if (copy_from_user(&mreq, optval, sizeof(struct ipv6_mreq)))
			break;

		if (optname == IPV6_JOIN_ANYCAST)
			retv = ipv6_sock_ac_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr);
		else
			retv = ipv6_sock_ac_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr);
		break;
	}
	case MCAST_JOIN_GROUP:
	case MCAST_LEAVE_GROUP:
	{
		struct group_req greq;
		struct sockaddr_in6 *psin6;

648 649 650
		if (optlen < sizeof(struct group_req))
			goto e_inval;

L
Linus Torvalds 已提交
651 652 653 654 655 656 657 658 659
		retv = -EFAULT;
		if (copy_from_user(&greq, optval, sizeof(struct group_req)))
			break;
		if (greq.gr_group.ss_family != AF_INET6) {
			retv = -EADDRNOTAVAIL;
			break;
		}
		psin6 = (struct sockaddr_in6 *)&greq.gr_group;
		if (optname == MCAST_JOIN_GROUP)
660 661
			retv = ipv6_sock_mc_join(sk, greq.gr_interface,
						 &psin6->sin6_addr);
L
Linus Torvalds 已提交
662
		else
663 664
			retv = ipv6_sock_mc_drop(sk, greq.gr_interface,
						 &psin6->sin6_addr);
L
Linus Torvalds 已提交
665 666 667 668 669 670 671 672 673 674
		break;
	}
	case MCAST_JOIN_SOURCE_GROUP:
	case MCAST_LEAVE_SOURCE_GROUP:
	case MCAST_BLOCK_SOURCE:
	case MCAST_UNBLOCK_SOURCE:
	{
		struct group_source_req greqs;
		int omode, add;

675
		if (optlen < sizeof(struct group_source_req))
L
Linus Torvalds 已提交
676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695
			goto e_inval;
		if (copy_from_user(&greqs, optval, sizeof(greqs))) {
			retv = -EFAULT;
			break;
		}
		if (greqs.gsr_group.ss_family != AF_INET6 ||
		    greqs.gsr_source.ss_family != AF_INET6) {
			retv = -EADDRNOTAVAIL;
			break;
		}
		if (optname == MCAST_BLOCK_SOURCE) {
			omode = MCAST_EXCLUDE;
			add = 1;
		} else if (optname == MCAST_UNBLOCK_SOURCE) {
			omode = MCAST_EXCLUDE;
			add = 0;
		} else if (optname == MCAST_JOIN_SOURCE_GROUP) {
			struct sockaddr_in6 *psin6;

			psin6 = (struct sockaddr_in6 *)&greqs.gsr_group;
696 697
			retv = ipv6_sock_mc_join(sk, greqs.gsr_interface,
						 &psin6->sin6_addr);
698 699
			/* prior join w/ different source is ok */
			if (retv && retv != -EADDRINUSE)
L
Linus Torvalds 已提交
700 701 702
				break;
			omode = MCAST_INCLUDE;
			add = 1;
703
		} else /* MCAST_LEAVE_SOURCE_GROUP */ {
L
Linus Torvalds 已提交
704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719
			omode = MCAST_INCLUDE;
			add = 0;
		}
		retv = ip6_mc_source(add, omode, sk, &greqs);
		break;
	}
	case MCAST_MSFILTER:
	{
		struct group_filter *gsf;

		if (optlen < GROUP_FILTER_SIZE(0))
			goto e_inval;
		if (optlen > sysctl_optmem_max) {
			retv = -ENOBUFS;
			break;
		}
720
		gsf = kmalloc(optlen, GFP_KERNEL);
S
Stephen Hemminger 已提交
721
		if (!gsf) {
L
Linus Torvalds 已提交
722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
			retv = -ENOBUFS;
			break;
		}
		retv = -EFAULT;
		if (copy_from_user(gsf, optval, optlen)) {
			kfree(gsf);
			break;
		}
		/* numsrc >= (4G-140)/128 overflow in 32 bits */
		if (gsf->gf_numsrc >= 0x1ffffffU ||
		    gsf->gf_numsrc > sysctl_mld_max_msf) {
			kfree(gsf);
			retv = -ENOBUFS;
			break;
		}
		if (GROUP_FILTER_SIZE(gsf->gf_numsrc) > optlen) {
			kfree(gsf);
			retv = -EINVAL;
			break;
		}
		retv = ip6_mc_msfilter(sk, gsf);
		kfree(gsf);

		break;
	}
	case IPV6_ROUTER_ALERT:
748 749
		if (optlen < sizeof(int))
			goto e_inval;
750
		retv = ip6_ra_control(sk, val);
L
Linus Torvalds 已提交
751 752
		break;
	case IPV6_MTU_DISCOVER:
753 754
		if (optlen < sizeof(int))
			goto e_inval;
755
		if (val < IPV6_PMTUDISC_DONT || val > IPV6_PMTUDISC_OMIT)
L
Linus Torvalds 已提交
756 757 758 759 760
			goto e_inval;
		np->pmtudisc = val;
		retv = 0;
		break;
	case IPV6_MTU:
761 762
		if (optlen < sizeof(int))
			goto e_inval;
L
Linus Torvalds 已提交
763 764 765 766 767 768
		if (val && val < IPV6_MIN_MTU)
			goto e_inval;
		np->frag_size = val;
		retv = 0;
		break;
	case IPV6_RECVERR:
769 770
		if (optlen < sizeof(int))
			goto e_inval;
L
Linus Torvalds 已提交
771 772 773 774 775 776
		np->recverr = valbool;
		if (!val)
			skb_queue_purge(&sk->sk_error_queue);
		retv = 0;
		break;
	case IPV6_FLOWINFO_SEND:
777 778
		if (optlen < sizeof(int))
			goto e_inval;
L
Linus Torvalds 已提交
779 780 781 782 783 784 785 786
		np->sndflow = valbool;
		retv = 0;
		break;
	case IPV6_FLOWLABEL_MGR:
		retv = ipv6_flowlabel_opt(sk, optval, optlen);
		break;
	case IPV6_IPSEC_POLICY:
	case IPV6_XFRM_POLICY:
787
		retv = -EPERM;
788
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
789
			break;
L
Linus Torvalds 已提交
790 791 792
		retv = xfrm_user_policy(sk, optname, optval, optlen);
		break;

793 794 795 796 797
	case IPV6_ADDR_PREFERENCES:
	    {
		unsigned int pref = 0;
		unsigned int prefmask = ~0;

798 799 800
		if (optlen < sizeof(int))
			goto e_inval;

801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854
		retv = -EINVAL;

		/* check PUBLIC/TMP/PUBTMP_DEFAULT conflicts */
		switch (val & (IPV6_PREFER_SRC_PUBLIC|
			       IPV6_PREFER_SRC_TMP|
			       IPV6_PREFER_SRC_PUBTMP_DEFAULT)) {
		case IPV6_PREFER_SRC_PUBLIC:
			pref |= IPV6_PREFER_SRC_PUBLIC;
			break;
		case IPV6_PREFER_SRC_TMP:
			pref |= IPV6_PREFER_SRC_TMP;
			break;
		case IPV6_PREFER_SRC_PUBTMP_DEFAULT:
			break;
		case 0:
			goto pref_skip_pubtmp;
		default:
			goto e_inval;
		}

		prefmask &= ~(IPV6_PREFER_SRC_PUBLIC|
			      IPV6_PREFER_SRC_TMP);
pref_skip_pubtmp:

		/* check HOME/COA conflicts */
		switch (val & (IPV6_PREFER_SRC_HOME|IPV6_PREFER_SRC_COA)) {
		case IPV6_PREFER_SRC_HOME:
			break;
		case IPV6_PREFER_SRC_COA:
			pref |= IPV6_PREFER_SRC_COA;
		case 0:
			goto pref_skip_coa;
		default:
			goto e_inval;
		}

		prefmask &= ~IPV6_PREFER_SRC_COA;
pref_skip_coa:

		/* check CGA/NONCGA conflicts */
		switch (val & (IPV6_PREFER_SRC_CGA|IPV6_PREFER_SRC_NONCGA)) {
		case IPV6_PREFER_SRC_CGA:
		case IPV6_PREFER_SRC_NONCGA:
		case 0:
			break;
		default:
			goto e_inval;
		}

		np->srcprefs = (np->srcprefs & prefmask) | pref;
		retv = 0;

		break;
	    }
855 856 857 858 859 860
	case IPV6_MINHOPCOUNT:
		if (optlen < sizeof(int))
			goto e_inval;
		if (val < 0 || val > 255)
			goto e_inval;
		np->min_hopcount = val;
861
		retv = 0;
862 863 864
		break;
	case IPV6_DONTFRAG:
		np->dontfrag = valbool;
865 866
		retv = 0;
		break;
867 868 869 870
	case IPV6_AUTOFLOWLABEL:
		np->autoflowlabel = valbool;
		retv = 0;
		break;
L
Linus Torvalds 已提交
871
	}
872

L
Linus Torvalds 已提交
873
	release_sock(sk);
874 875
	if (needs_rtnl)
		rtnl_unlock();
L
Linus Torvalds 已提交
876 877 878 879 880

	return retv;

e_inval:
	release_sock(sk);
881 882
	if (needs_rtnl)
		rtnl_unlock();
L
Linus Torvalds 已提交
883 884 885
	return -EINVAL;
}

886
int ipv6_setsockopt(struct sock *sk, int level, int optname,
887
		    char __user *optval, unsigned int optlen)
888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909
{
	int err;

	if (level == SOL_IP && sk->sk_type != SOCK_RAW)
		return udp_prot.setsockopt(sk, level, optname, optval, optlen);

	if (level != SOL_IPV6)
		return -ENOPROTOOPT;

	err = do_ipv6_setsockopt(sk, level, optname, optval, optlen);
#ifdef CONFIG_NETFILTER
	/* we need to exclude all possible ENOPROTOOPTs except default case */
	if (err == -ENOPROTOOPT && optname != IPV6_IPSEC_POLICY &&
			optname != IPV6_XFRM_POLICY) {
		lock_sock(sk);
		err = nf_setsockopt(sk, PF_INET6, optname, optval,
				optlen);
		release_sock(sk);
	}
#endif
	return err;
}
910
EXPORT_SYMBOL(ipv6_setsockopt);
911 912 913

#ifdef CONFIG_COMPAT
int compat_ipv6_setsockopt(struct sock *sk, int level, int optname,
914
			   char __user *optval, unsigned int optlen)
915 916 917 918
{
	int err;

	if (level == SOL_IP && sk->sk_type != SOCK_RAW) {
919 920 921 922
		if (udp_prot.compat_setsockopt != NULL)
			return udp_prot.compat_setsockopt(sk, level, optname,
							  optval, optlen);
		return udp_prot.setsockopt(sk, level, optname, optval, optlen);
923 924 925 926 927
	}

	if (level != SOL_IPV6)
		return -ENOPROTOOPT;

928 929 930 931
	if (optname >= MCAST_JOIN_GROUP && optname <= MCAST_MSFILTER)
		return compat_mc_setsockopt(sk, level, optname, optval, optlen,
			ipv6_setsockopt);

932 933 934 935
	err = do_ipv6_setsockopt(sk, level, optname, optval, optlen);
#ifdef CONFIG_NETFILTER
	/* we need to exclude all possible ENOPROTOOPTs except default case */
	if (err == -ENOPROTOOPT && optname != IPV6_IPSEC_POLICY &&
936
	    optname != IPV6_XFRM_POLICY) {
937
		lock_sock(sk);
938 939
		err = compat_nf_setsockopt(sk, PF_INET6, optname,
					   optval, optlen);
940 941 942 943 944
		release_sock(sk);
	}
#endif
	return err;
}
945
EXPORT_SYMBOL(compat_ipv6_setsockopt);
946 947
#endif

948
static int ipv6_getsockopt_sticky(struct sock *sk, struct ipv6_txoptions *opt,
949
				  int optname, char __user *optval, int len)
950
{
951 952
	struct ipv6_opt_hdr *hdr;

953 954 955
	if (!opt)
		return 0;

956
	switch (optname) {
957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973
	case IPV6_HOPOPTS:
		hdr = opt->hopopt;
		break;
	case IPV6_RTHDRDSTOPTS:
		hdr = opt->dst0opt;
		break;
	case IPV6_RTHDR:
		hdr = (struct ipv6_opt_hdr *)opt->srcrt;
		break;
	case IPV6_DSTOPTS:
		hdr = opt->dst1opt;
		break;
	default:
		return -EINVAL;	/* should not happen */
	}

	if (!hdr)
974
		return 0;
975

976
	len = min_t(unsigned int, len, ipv6_optlen(hdr));
977
	if (copy_to_user(optval, hdr, len))
978
		return -EFAULT;
979
	return len;
980 981
}

982
static int do_ipv6_getsockopt(struct sock *sk, int level, int optname,
983
		    char __user *optval, int __user *optlen, unsigned int flags)
L
Linus Torvalds 已提交
984 985 986 987 988
{
	struct ipv6_pinfo *np = inet6_sk(sk);
	int len;
	int val;

989 990 991
	if (ip6_mroute_opt(optname))
		return ip6_mroute_getsockopt(sk, optname, optval, optlen);

L
Linus Torvalds 已提交
992 993 994 995 996
	if (get_user(len, optlen))
		return -EFAULT;
	switch (optname) {
	case IPV6_ADDRFORM:
		if (sk->sk_protocol != IPPROTO_UDP &&
997
		    sk->sk_protocol != IPPROTO_UDPLITE &&
L
Linus Torvalds 已提交
998
		    sk->sk_protocol != IPPROTO_TCP)
999
			return -ENOPROTOOPT;
L
Linus Torvalds 已提交
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
		if (sk->sk_state != TCP_ESTABLISHED)
			return -ENOTCONN;
		val = sk->sk_family;
		break;
	case MCAST_MSFILTER:
	{
		struct group_filter gsf;
		int err;

		if (len < GROUP_FILTER_SIZE(0))
			return -EINVAL;
		if (copy_from_user(&gsf, optval, GROUP_FILTER_SIZE(0)))
			return -EFAULT;
1013 1014
		if (gsf.gf_group.ss_family != AF_INET6)
			return -EADDRNOTAVAIL;
L
Linus Torvalds 已提交
1015 1016 1017 1018 1019 1020 1021
		lock_sock(sk);
		err = ip6_mc_msfget(sk, &gsf,
			(struct group_filter __user *)optval, optlen);
		release_sock(sk);
		return err;
	}

1022
	case IPV6_2292PKTOPTIONS:
L
Linus Torvalds 已提交
1023 1024 1025 1026 1027 1028 1029 1030 1031
	{
		struct msghdr msg;
		struct sk_buff *skb;

		if (sk->sk_type != SOCK_STREAM)
			return -ENOPROTOOPT;

		msg.msg_control = optval;
		msg.msg_controllen = len;
1032
		msg.msg_flags = flags;
L
Linus Torvalds 已提交
1033 1034 1035 1036

		lock_sock(sk);
		skb = np->pktoptions;
		if (skb)
1037
			ip6_datagram_recv_ctl(sk, &msg, skb);
1038 1039
		release_sock(sk);
		if (!skb) {
L
Linus Torvalds 已提交
1040 1041
			if (np->rxopt.bits.rxinfo) {
				struct in6_pktinfo src_info;
1042 1043
				src_info.ipi6_ifindex = np->mcast_oif ? np->mcast_oif :
					np->sticky_pktinfo.ipi6_ifindex;
1044
				src_info.ipi6_addr = np->mcast_oif ? sk->sk_v6_daddr : np->sticky_pktinfo.ipi6_addr;
L
Linus Torvalds 已提交
1045 1046 1047 1048 1049 1050
				put_cmsg(&msg, SOL_IPV6, IPV6_PKTINFO, sizeof(src_info), &src_info);
			}
			if (np->rxopt.bits.rxhlim) {
				int hlim = np->mcast_hops;
				put_cmsg(&msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);
			}
1051
			if (np->rxopt.bits.rxtclass) {
1052 1053
				int tclass = (int)ip6_tclass(np->rcv_flowinfo);

1054 1055
				put_cmsg(&msg, SOL_IPV6, IPV6_TCLASS, sizeof(tclass), &tclass);
			}
1056 1057
			if (np->rxopt.bits.rxoinfo) {
				struct in6_pktinfo src_info;
1058 1059
				src_info.ipi6_ifindex = np->mcast_oif ? np->mcast_oif :
					np->sticky_pktinfo.ipi6_ifindex;
1060 1061
				src_info.ipi6_addr = np->mcast_oif ? sk->sk_v6_daddr :
								     np->sticky_pktinfo.ipi6_addr;
1062 1063 1064 1065 1066 1067
				put_cmsg(&msg, SOL_IPV6, IPV6_2292PKTINFO, sizeof(src_info), &src_info);
			}
			if (np->rxopt.bits.rxohlim) {
				int hlim = np->mcast_hops;
				put_cmsg(&msg, SOL_IPV6, IPV6_2292HOPLIMIT, sizeof(hlim), &hlim);
			}
1068
			if (np->rxopt.bits.rxflow) {
1069 1070
				__be32 flowinfo = np->rcv_flowinfo;

1071 1072
				put_cmsg(&msg, SOL_IPV6, IPV6_FLOWINFO, sizeof(flowinfo), &flowinfo);
			}
L
Linus Torvalds 已提交
1073 1074 1075 1076 1077 1078 1079
		}
		len -= msg.msg_controllen;
		return put_user(len, optlen);
	}
	case IPV6_MTU:
	{
		struct dst_entry *dst;
E
Eric Dumazet 已提交
1080

1081
		val = 0;
E
Eric Dumazet 已提交
1082 1083 1084
		rcu_read_lock();
		dst = __sk_dst_get(sk);
		if (dst)
L
Linus Torvalds 已提交
1085
			val = dst_mtu(dst);
E
Eric Dumazet 已提交
1086
		rcu_read_unlock();
L
Linus Torvalds 已提交
1087 1088 1089 1090 1091 1092
		if (!val)
			return -ENOTCONN;
		break;
	}

	case IPV6_V6ONLY:
1093
		val = sk->sk_ipv6only;
L
Linus Torvalds 已提交
1094 1095
		break;

1096
	case IPV6_RECVPKTINFO:
L
Linus Torvalds 已提交
1097 1098 1099
		val = np->rxopt.bits.rxinfo;
		break;

1100 1101 1102 1103 1104
	case IPV6_2292PKTINFO:
		val = np->rxopt.bits.rxoinfo;
		break;

	case IPV6_RECVHOPLIMIT:
L
Linus Torvalds 已提交
1105 1106 1107
		val = np->rxopt.bits.rxhlim;
		break;

1108 1109 1110 1111 1112
	case IPV6_2292HOPLIMIT:
		val = np->rxopt.bits.rxohlim;
		break;

	case IPV6_RECVRTHDR:
L
Linus Torvalds 已提交
1113 1114 1115
		val = np->rxopt.bits.srcrt;
		break;

1116 1117 1118 1119
	case IPV6_2292RTHDR:
		val = np->rxopt.bits.osrcrt;
		break;

L
Linus Torvalds 已提交
1120
	case IPV6_HOPOPTS:
1121 1122 1123 1124
	case IPV6_RTHDRDSTOPTS:
	case IPV6_RTHDR:
	case IPV6_DSTOPTS:
	{
1125
		struct ipv6_txoptions *opt;
1126 1127

		lock_sock(sk);
1128 1129
		opt = rcu_dereference_protected(np->opt,
						lockdep_sock_is_held(sk));
1130
		len = ipv6_getsockopt_sticky(sk, opt, optname, optval, len);
1131
		release_sock(sk);
1132 1133 1134
		/* check if ipv6_getsockopt_sticky() returns err code */
		if (len < 0)
			return len;
1135 1136 1137 1138
		return put_user(len, optlen);
	}

	case IPV6_RECVHOPOPTS:
L
Linus Torvalds 已提交
1139 1140 1141
		val = np->rxopt.bits.hopopts;
		break;

1142 1143 1144 1145 1146
	case IPV6_2292HOPOPTS:
		val = np->rxopt.bits.ohopopts;
		break;

	case IPV6_RECVDSTOPTS:
L
Linus Torvalds 已提交
1147 1148 1149
		val = np->rxopt.bits.dstopts;
		break;

1150 1151 1152 1153
	case IPV6_2292DSTOPTS:
		val = np->rxopt.bits.odstopts;
		break;

1154 1155 1156 1157 1158 1159 1160 1161
	case IPV6_TCLASS:
		val = np->tclass;
		break;

	case IPV6_RECVTCLASS:
		val = np->rxopt.bits.rxtclass;
		break;

L
Linus Torvalds 已提交
1162 1163 1164 1165
	case IPV6_FLOWINFO:
		val = np->rxopt.bits.rxflow;
		break;

1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
	case IPV6_RECVPATHMTU:
		val = np->rxopt.bits.rxpmtu;
		break;

	case IPV6_PATHMTU:
	{
		struct dst_entry *dst;
		struct ip6_mtuinfo mtuinfo;

		if (len < sizeof(mtuinfo))
			return -EINVAL;

		len = sizeof(mtuinfo);
		memset(&mtuinfo, 0, sizeof(mtuinfo));

		rcu_read_lock();
		dst = __sk_dst_get(sk);
		if (dst)
			mtuinfo.ip6m_mtu = dst_mtu(dst);
		rcu_read_unlock();
		if (!mtuinfo.ip6m_mtu)
			return -ENOTCONN;

		if (put_user(len, optlen))
			return -EFAULT;
		if (copy_to_user(optval, &mtuinfo, len))
			return -EFAULT;

		return 0;
	}

1197 1198 1199 1200 1201 1202 1203 1204
	case IPV6_TRANSPARENT:
		val = inet_sk(sk)->transparent;
		break;

	case IPV6_RECVORIGDSTADDR:
		val = np->rxopt.bits.rxorigdstaddr;
		break;

L
Linus Torvalds 已提交
1205 1206
	case IPV6_UNICAST_HOPS:
	case IPV6_MULTICAST_HOPS:
1207 1208 1209 1210 1211 1212 1213 1214
	{
		struct dst_entry *dst;

		if (optname == IPV6_UNICAST_HOPS)
			val = np->hop_limit;
		else
			val = np->mcast_hops;

E
Eric Dumazet 已提交
1215 1216 1217 1218
		if (val < 0) {
			rcu_read_lock();
			dst = __sk_dst_get(sk);
			if (dst)
1219
				val = ip6_dst_hoplimit(dst);
E
Eric Dumazet 已提交
1220
			rcu_read_unlock();
1221
		}
E
Eric Dumazet 已提交
1222

1223
		if (val < 0)
1224
			val = sock_net(sk)->ipv6.devconf_all->hop_limit;
L
Linus Torvalds 已提交
1225
		break;
1226
	}
L
Linus Torvalds 已提交
1227 1228 1229 1230 1231 1232 1233 1234 1235

	case IPV6_MULTICAST_LOOP:
		val = np->mc_loop;
		break;

	case IPV6_MULTICAST_IF:
		val = np->mcast_oif;
		break;

1236 1237 1238 1239
	case IPV6_UNICAST_IF:
		val = (__force int)htonl((__u32) np->ucast_oif);
		break;

L
Linus Torvalds 已提交
1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251
	case IPV6_MTU_DISCOVER:
		val = np->pmtudisc;
		break;

	case IPV6_RECVERR:
		val = np->recverr;
		break;

	case IPV6_FLOWINFO_SEND:
		val = np->sndflow;
		break;

1252 1253 1254
	case IPV6_FLOWLABEL_MGR:
	{
		struct in6_flowlabel_req freq;
1255
		int flags;
1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266

		if (len < sizeof(freq))
			return -EINVAL;

		if (copy_from_user(&freq, optval, sizeof(freq)))
			return -EFAULT;

		if (freq.flr_action != IPV6_FL_A_GET)
			return -EINVAL;

		len = sizeof(freq);
1267 1268
		flags = freq.flr_flags;

1269 1270
		memset(&freq, 0, sizeof(freq));

1271
		val = ipv6_flowlabel_opt_get(sk, &freq, flags);
1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282
		if (val < 0)
			return val;

		if (put_user(len, optlen))
			return -EFAULT;
		if (copy_to_user(optval, &freq, len))
			return -EFAULT;

		return 0;
	}

1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299
	case IPV6_ADDR_PREFERENCES:
		val = 0;

		if (np->srcprefs & IPV6_PREFER_SRC_TMP)
			val |= IPV6_PREFER_SRC_TMP;
		else if (np->srcprefs & IPV6_PREFER_SRC_PUBLIC)
			val |= IPV6_PREFER_SRC_PUBLIC;
		else {
			/* XXX: should we return system default? */
			val |= IPV6_PREFER_SRC_PUBTMP_DEFAULT;
		}

		if (np->srcprefs & IPV6_PREFER_SRC_COA)
			val |= IPV6_PREFER_SRC_COA;
		else
			val |= IPV6_PREFER_SRC_HOME;
		break;
1300 1301 1302 1303

	case IPV6_MINHOPCOUNT:
		val = np->min_hopcount;
		break;
1304 1305 1306 1307

	case IPV6_DONTFRAG:
		val = np->dontfrag;
		break;
1308

1309 1310 1311 1312
	case IPV6_AUTOFLOWLABEL:
		val = np->autoflowlabel;
		break;

L
Linus Torvalds 已提交
1313
	default:
1314
		return -ENOPROTOOPT;
L
Linus Torvalds 已提交
1315 1316
	}
	len = min_t(unsigned int, sizeof(int), len);
1317
	if (put_user(len, optlen))
L
Linus Torvalds 已提交
1318
		return -EFAULT;
1319
	if (copy_to_user(optval, &val, len))
L
Linus Torvalds 已提交
1320 1321 1322 1323
		return -EFAULT;
	return 0;
}

1324 1325 1326 1327 1328 1329 1330 1331
int ipv6_getsockopt(struct sock *sk, int level, int optname,
		    char __user *optval, int __user *optlen)
{
	int err;

	if (level == SOL_IP && sk->sk_type != SOCK_RAW)
		return udp_prot.getsockopt(sk, level, optname, optval, optlen);

1332
	if (level != SOL_IPV6)
1333 1334
		return -ENOPROTOOPT;

1335
	err = do_ipv6_getsockopt(sk, level, optname, optval, optlen, 0);
1336
#ifdef CONFIG_NETFILTER
1337 1338
	/* we need to exclude all possible ENOPROTOOPTs except default case */
	if (err == -ENOPROTOOPT && optname != IPV6_2292PKTOPTIONS) {
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353
		int len;

		if (get_user(len, optlen))
			return -EFAULT;

		lock_sock(sk);
		err = nf_getsockopt(sk, PF_INET6, optname, optval,
				&len);
		release_sock(sk);
		if (err >= 0)
			err = put_user(len, optlen);
	}
#endif
	return err;
}
1354 1355
EXPORT_SYMBOL(ipv6_getsockopt);

1356 1357
#ifdef CONFIG_COMPAT
int compat_ipv6_getsockopt(struct sock *sk, int level, int optname,
1358
			   char __user *optval, int __user *optlen)
1359 1360 1361 1362
{
	int err;

	if (level == SOL_IP && sk->sk_type != SOCK_RAW) {
1363 1364 1365 1366
		if (udp_prot.compat_getsockopt != NULL)
			return udp_prot.compat_getsockopt(sk, level, optname,
							  optval, optlen);
		return udp_prot.getsockopt(sk, level, optname, optval, optlen);
1367 1368
	}

1369
	if (level != SOL_IPV6)
1370 1371
		return -ENOPROTOOPT;

1372 1373 1374 1375
	if (optname == MCAST_MSFILTER)
		return compat_mc_getsockopt(sk, level, optname, optval, optlen,
			ipv6_getsockopt);

1376 1377
	err = do_ipv6_getsockopt(sk, level, optname, optval, optlen,
				 MSG_CMSG_COMPAT);
1378
#ifdef CONFIG_NETFILTER
1379 1380
	/* we need to exclude all possible ENOPROTOOPTs except default case */
	if (err == -ENOPROTOOPT && optname != IPV6_2292PKTOPTIONS) {
1381 1382 1383 1384 1385 1386
		int len;

		if (get_user(len, optlen))
			return -EFAULT;

		lock_sock(sk);
1387 1388
		err = compat_nf_getsockopt(sk, PF_INET6,
					   optname, optval, &len);
1389 1390 1391 1392 1393 1394 1395
		release_sock(sk);
		if (err >= 0)
			err = put_user(len, optlen);
	}
#endif
	return err;
}
1396
EXPORT_SYMBOL(compat_ipv6_getsockopt);
1397 1398
#endif