ipv6_sockglue.c 30.4 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2
/*
 *	IPv6 BSD socket options interface
3
 *	Linux INET6 implementation
Linus Torvalds's avatar
Linus Torvalds committed
4 5
 *
 *	Authors:
6
 *	Pedro Roque		<roque@di.fc.ul.pt>
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
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>
Linus Torvalds's avatar
Linus Torvalds committed
53
#include <net/xfrm.h>
54
#include <net/compat.h>
55
#include <net/seg6.h>
Linus Torvalds's avatar
Linus Torvalds committed
56

57
#include <linux/uaccess.h>
Linus Torvalds's avatar
Linus Torvalds committed
58 59 60 61

struct ip6_ra_chain *ip6_ra_chain;
DEFINE_RWLOCK(ip6_ra_lock);

62
int ip6_ra_control(struct sock *sk, int sel)
Linus Torvalds's avatar
Linus Torvalds committed
63 64 65 66
{
	struct ip6_ra_chain *ra, *new_ra, **rap;

	/* RA packet may be delivered ONLY to IPPROTO_RAW socket */
67
	if (sk->sk_type != SOCK_RAW || inet_sk(sk)->inet_num != IPPROTO_RAW)
68
		return -ENOPROTOOPT;
Linus Torvalds's avatar
Linus Torvalds committed
69

70
	new_ra = (sel >= 0) ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;
Linus Torvalds's avatar
Linus Torvalds committed
71 72

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

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

			sock_put(sk);
			kfree(ra);
			return 0;
		}
	}
89
	if (!new_ra) {
Linus Torvalds's avatar
Linus Torvalds committed
90 91 92 93 94 95 96 97 98 99 100 101
		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;
}

102 103 104 105 106 107
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)) &&
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
static bool setsockopt_needs_rtnl(int optname)
{
	switch (optname) {
124
	case IPV6_ADDRFORM:
125 126
	case IPV6_ADD_MEMBERSHIP:
	case IPV6_DROP_MEMBERSHIP:
127 128
	case IPV6_JOIN_ANYCAST:
	case IPV6_LEAVE_ANYCAST:
129 130
	case MCAST_JOIN_GROUP:
	case MCAST_LEAVE_GROUP:
131 132 133 134 135
	case MCAST_JOIN_SOURCE_GROUP:
	case MCAST_LEAVE_SOURCE_GROUP:
	case MCAST_BLOCK_SOURCE:
	case MCAST_UNBLOCK_SOURCE:
	case MCAST_MSFILTER:
136 137 138 139 140
		return true;
	}
	return false;
}

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

150
	if (!optval)
151
		val = 0;
152 153 154 155 156 157 158
	else {
		if (optlen >= sizeof(int)) {
			if (get_user(val, (int __user *) optval))
				return -EFAULT;
		} else
			val = 0;
	}
Linus Torvalds's avatar
Linus Torvalds committed
159

160
	valbool = (val != 0);
Linus Torvalds's avatar
Linus Torvalds committed
161

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

165 166
	if (needs_rtnl)
		rtnl_lock();
Linus Torvalds's avatar
Linus Torvalds committed
167 168 169 170 171
	lock_sock(sk);

	switch (optname) {

	case IPV6_ADDRFORM:
172 173
		if (optlen < sizeof(int))
			goto e_inval;
Linus Torvalds's avatar
Linus Torvalds committed
174 175 176 177
		if (val == PF_INET) {
			struct ipv6_txoptions *opt;
			struct sk_buff *pktopt;

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

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;
				}
188 189 190 191 192 193
			} else if (sk->sk_protocol == IPPROTO_TCP) {
				if (sk->sk_prot != &tcpv6_prot) {
					retv = -EBUSY;
					break;
				}
			} else {
194 195
				break;
			}
196

Linus Torvalds's avatar
Linus Torvalds committed
197 198 199 200 201 202
			if (sk->sk_state != TCP_ESTABLISHED) {
				retv = -ENOTCONN;
				break;
			}

			if (ipv6_only_sock(sk) ||
203
			    !ipv6_addr_v4mapped(&sk->sk_v6_daddr)) {
Linus Torvalds's avatar
Linus Torvalds committed
204 205 206 207 208
				retv = -EADDRNOTAVAIL;
				break;
			}

			fl6_free_socklist(sk);
209
			__ipv6_sock_mc_close(sk);
210
			__ipv6_sock_ac_close(sk);
Linus Torvalds's avatar
Linus Torvalds committed
211

212 213 214 215 216 217 218
			/*
			 * 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);

Linus Torvalds's avatar
Linus Torvalds committed
219
			if (sk->sk_protocol == IPPROTO_TCP) {
220
				struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds's avatar
Linus Torvalds committed
221
				local_bh_disable();
222 223
				sock_prot_inuse_add(net, sk->sk_prot, -1);
				sock_prot_inuse_add(net, &tcp_prot, 1);
Linus Torvalds's avatar
Linus Torvalds committed
224 225
				local_bh_enable();
				sk->sk_prot = &tcp_prot;
226
				icsk->icsk_af_ops = &ipv4_specific;
Linus Torvalds's avatar
Linus Torvalds committed
227 228
				sk->sk_socket->ops = &inet_stream_ops;
				sk->sk_family = PF_INET;
229
				tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
Linus Torvalds's avatar
Linus Torvalds committed
230
			} else {
231 232
				struct proto *prot = &udp_prot;

233
				if (sk->sk_protocol == IPPROTO_UDPLITE)
234
					prot = &udplite_prot;
Linus Torvalds's avatar
Linus Torvalds committed
235
				local_bh_disable();
236 237
				sock_prot_inuse_add(net, sk->sk_prot, -1);
				sock_prot_inuse_add(net, prot, 1);
Linus Torvalds's avatar
Linus Torvalds committed
238
				local_bh_enable();
239
				sk->sk_prot = prot;
Linus Torvalds's avatar
Linus Torvalds committed
240 241 242
				sk->sk_socket->ops = &inet_dgram_ops;
				sk->sk_family = PF_INET;
			}
243 244 245 246 247 248
			opt = xchg((__force struct ipv6_txoptions **)&np->opt,
				   NULL);
			if (opt) {
				atomic_sub(opt->tot_len, &sk->sk_omem_alloc);
				txopt_put(opt);
			}
Linus Torvalds's avatar
Linus Torvalds committed
249
			pktopt = xchg(&np->pktoptions, NULL);
250
			kfree_skb(pktopt);
Linus Torvalds's avatar
Linus Torvalds committed
251

252 253 254 255 256
			/*
			 * ... and add it to the refcnt debug socks count
			 * in the new family. -acme
			 */
			sk_refcnt_debug_inc(sk);
Linus Torvalds's avatar
Linus Torvalds committed
257 258 259 260 261 262 263
			module_put(THIS_MODULE);
			retv = 0;
			break;
		}
		goto e_inval;

	case IPV6_V6ONLY:
264
		if (optlen < sizeof(int) ||
265
		    inet_sk(sk)->inet_num)
Linus Torvalds's avatar
Linus Torvalds committed
266
			goto e_inval;
267
		sk->sk_ipv6only = valbool;
Linus Torvalds's avatar
Linus Torvalds committed
268 269 270
		retv = 0;
		break;

271
	case IPV6_RECVPKTINFO:
272 273
		if (optlen < sizeof(int))
			goto e_inval;
Linus Torvalds's avatar
Linus Torvalds committed
274 275 276
		np->rxopt.bits.rxinfo = valbool;
		retv = 0;
		break;
277

278
	case IPV6_2292PKTINFO:
279 280
		if (optlen < sizeof(int))
			goto e_inval;
281 282 283
		np->rxopt.bits.rxoinfo = valbool;
		retv = 0;
		break;
Linus Torvalds's avatar
Linus Torvalds committed
284

285
	case IPV6_RECVHOPLIMIT:
286 287
		if (optlen < sizeof(int))
			goto e_inval;
Linus Torvalds's avatar
Linus Torvalds committed
288 289 290 291
		np->rxopt.bits.rxhlim = valbool;
		retv = 0;
		break;

292
	case IPV6_2292HOPLIMIT:
293 294
		if (optlen < sizeof(int))
			goto e_inval;
295 296 297 298 299
		np->rxopt.bits.rxohlim = valbool;
		retv = 0;
		break;

	case IPV6_RECVRTHDR:
300 301
		if (optlen < sizeof(int))
			goto e_inval;
302
		np->rxopt.bits.srcrt = valbool;
Linus Torvalds's avatar
Linus Torvalds committed
303 304 305
		retv = 0;
		break;

306
	case IPV6_2292RTHDR:
307 308
		if (optlen < sizeof(int))
			goto e_inval;
309
		np->rxopt.bits.osrcrt = valbool;
310 311 312 313
		retv = 0;
		break;

	case IPV6_RECVHOPOPTS:
314 315
		if (optlen < sizeof(int))
			goto e_inval;
Linus Torvalds's avatar
Linus Torvalds committed
316 317 318 319
		np->rxopt.bits.hopopts = valbool;
		retv = 0;
		break;

320
	case IPV6_2292HOPOPTS:
321 322
		if (optlen < sizeof(int))
			goto e_inval;
323 324 325 326 327
		np->rxopt.bits.ohopopts = valbool;
		retv = 0;
		break;

	case IPV6_RECVDSTOPTS:
328 329
		if (optlen < sizeof(int))
			goto e_inval;
Linus Torvalds's avatar
Linus Torvalds committed
330 331 332 333
		np->rxopt.bits.dstopts = valbool;
		retv = 0;
		break;

334
	case IPV6_2292DSTOPTS:
335 336
		if (optlen < sizeof(int))
			goto e_inval;
337 338 339 340
		np->rxopt.bits.odstopts = valbool;
		retv = 0;
		break;

341
	case IPV6_TCLASS:
342 343
		if (optlen < sizeof(int))
			goto e_inval;
344
		if (val < -1 || val > 0xff)
345
			goto e_inval;
346 347 348
		/* RFC 3542, 6.5: default traffic class of 0x0 */
		if (val == -1)
			val = 0;
349 350 351
		np->tclass = val;
		retv = 0;
		break;
352

353
	case IPV6_RECVTCLASS:
354 355
		if (optlen < sizeof(int))
			goto e_inval;
356 357 358 359
		np->rxopt.bits.rxtclass = valbool;
		retv = 0;
		break;

Linus Torvalds's avatar
Linus Torvalds committed
360
	case IPV6_FLOWINFO:
361 362
		if (optlen < sizeof(int))
			goto e_inval;
Linus Torvalds's avatar
Linus Torvalds committed
363 364 365 366
		np->rxopt.bits.rxflow = valbool;
		retv = 0;
		break;

367 368 369 370 371 372 373
	case IPV6_RECVPATHMTU:
		if (optlen < sizeof(int))
			goto e_inval;
		np->rxopt.bits.rxpmtu = valbool;
		retv = 0;
		break;

374
	case IPV6_TRANSPARENT:
375 376
		if (valbool && !ns_capable(net->user_ns, CAP_NET_ADMIN) &&
		    !ns_capable(net->user_ns, CAP_NET_RAW)) {
377 378 379
			retv = -EPERM;
			break;
		}
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;

387 388 389 390 391 392 393 394
	case IPV6_FREEBIND:
		if (optlen < sizeof(int))
			goto e_inval;
		/* we also don't have a separate freebind bit for IPV6 */
		inet_sk(sk)->freebind = valbool;
		retv = 0;
		break;

395 396 397 398 399 400 401
	case IPV6_RECVORIGDSTADDR:
		if (optlen < sizeof(int))
			goto e_inval;
		np->rxopt.bits.rxorigdstaddr = valbool;
		retv = 0;
		break;

402 403 404 405 406 407
	case IPV6_HOPOPTS:
	case IPV6_RTHDRDSTOPTS:
	case IPV6_RTHDR:
	case IPV6_DSTOPTS:
	{
		struct ipv6_txoptions *opt;
408 409 410 411 412 413
		struct ipv6_opt_hdr *new = NULL;

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

		/* remove any sticky options header with a zero option
		 * length, per RFC3542.
		 */
418
		if (optlen == 0)
419
			optval = NULL;
420
		else if (!optval)
421
			goto e_inval;
422 423 424
		else if (optlen < sizeof(struct ipv6_opt_hdr) ||
			 optlen & 0x7 || optlen > 8 * 255)
			goto e_inval;
425 426 427 428 429 430 431 432 433 434 435
		else {
			new = memdup_user(optval, optlen);
			if (IS_ERR(new)) {
				retv = PTR_ERR(new);
				break;
			}
			if (unlikely(ipv6_optlen(new) > optlen)) {
				kfree(new);
				goto e_inval;
			}
		}
436

437 438
		opt = rcu_dereference_protected(np->opt,
						lockdep_sock_is_held(sk));
439 440
		opt = ipv6_renew_options(sk, opt, optname, new);
		kfree(new);
441 442 443 444 445 446
		if (IS_ERR(opt)) {
			retv = PTR_ERR(opt);
			break;
		}

		/* routing header option needs extra check */
Brian Haley's avatar
Brian Haley committed
447
		retv = -EINVAL;
448
		if (optname == IPV6_RTHDR && opt && opt->srcrt) {
449
			struct ipv6_rt_hdr *rthdr = opt->srcrt;
450
			switch (rthdr->type) {
Amerigo Wang's avatar
Amerigo Wang committed
451
#if IS_ENABLED(CONFIG_IPV6_MIP6)
452
			case IPV6_SRCRT_TYPE_2:
Brian Haley's avatar
Brian Haley committed
453 454 455 456
				if (rthdr->hdrlen != 2 ||
				    rthdr->segments_left != 1)
					goto sticky_done;

457
				break;
458
#endif
459 460 461 462 463 464 465 466 467
			case IPV6_SRCRT_TYPE_4:
			{
				struct ipv6_sr_hdr *srh = (struct ipv6_sr_hdr *)
							  opt->srcrt;

				if (!seg6_validate_srh(srh, optlen))
					goto sticky_done;
				break;
			}
468
			default:
469
				goto sticky_done;
470
			}
471 472 473
		}

		retv = 0;
474
		opt = ipv6_update_options(sk, opt);
475
sticky_done:
476 477 478 479
		if (opt) {
			atomic_sub(opt->tot_len, &sk->sk_omem_alloc);
			txopt_put(opt);
		}
480 481 482
		break;
	}

483 484 485 486 487 488
	case IPV6_PKTINFO:
	{
		struct in6_pktinfo pkt;

		if (optlen == 0)
			goto e_inval;
489
		else if (optlen < sizeof(struct in6_pktinfo) || !optval)
490 491
			goto e_inval;

492
		if (copy_from_user(&pkt, optval, sizeof(struct in6_pktinfo))) {
493 494 495 496 497 498 499
				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;
500
		np->sticky_pktinfo.ipi6_addr = pkt.ipi6_addr;
501 502 503 504
		retv = 0;
		break;
	}

505
	case IPV6_2292PKTOPTIONS:
Linus Torvalds's avatar
Linus Torvalds committed
506 507 508
	{
		struct ipv6_txoptions *opt = NULL;
		struct msghdr msg;
509
		struct flowi6 fl6;
510
		struct ipcm6_cookie ipc6;
Linus Torvalds's avatar
Linus Torvalds committed
511

512 513 514
		memset(&fl6, 0, sizeof(fl6));
		fl6.flowi6_oif = sk->sk_bound_dev_if;
		fl6.flowi6_mark = sk->sk_mark;
Linus Torvalds's avatar
Linus Torvalds committed
515 516 517 518 519 520 521 522 523 524 525 526 527

		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;
528
		if (!opt)
Linus Torvalds's avatar
Linus Torvalds committed
529 530 531
			break;

		memset(opt, 0, sizeof(*opt));
532
		refcount_set(&opt->refcnt, 1);
Linus Torvalds's avatar
Linus Torvalds committed
533 534 535 536 537 538
		opt->tot_len = sizeof(*opt) + optlen;
		retv = -EFAULT;
		if (copy_from_user(opt+1, optval, optlen))
			goto done;

		msg.msg_controllen = optlen;
539
		msg.msg_control = (void *)(opt+1);
540
		ipc6.opt = opt;
Linus Torvalds's avatar
Linus Torvalds committed
541

542
		retv = ip6_datagram_send_ctl(net, sk, &msg, &fl6, &ipc6);
Linus Torvalds's avatar
Linus Torvalds committed
543 544 545 546
		if (retv)
			goto done;
update:
		retv = 0;
547
		opt = ipv6_update_options(sk, opt);
Linus Torvalds's avatar
Linus Torvalds committed
548
done:
549 550 551 552
		if (opt) {
			atomic_sub(opt->tot_len, &sk->sk_omem_alloc);
			txopt_put(opt);
		}
Linus Torvalds's avatar
Linus Torvalds committed
553 554 555
		break;
	}
	case IPV6_UNICAST_HOPS:
556 557
		if (optlen < sizeof(int))
			goto e_inval;
Linus Torvalds's avatar
Linus Torvalds committed
558 559 560 561 562 563 564 565
		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)
566
			break;
567 568
		if (optlen < sizeof(int))
			goto e_inval;
Linus Torvalds's avatar
Linus Torvalds committed
569 570
		if (val > 255 || val < -1)
			goto e_inval;
571
		np->mcast_hops = (val == -1 ? IPV6_DEFAULT_MCASTHOPS : val);
Linus Torvalds's avatar
Linus Torvalds committed
572 573 574 575
		retv = 0;
		break;

	case IPV6_MULTICAST_LOOP:
576 577
		if (optlen < sizeof(int))
			goto e_inval;
578 579
		if (val != valbool)
			goto e_inval;
Linus Torvalds's avatar
Linus Torvalds committed
580 581 582 583
		np->mc_loop = valbool;
		retv = 0;
		break;

584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613
	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;
	}

Linus Torvalds's avatar
Linus Torvalds committed
614 615
	case IPV6_MULTICAST_IF:
		if (sk->sk_type == SOCK_STREAM)
616
			break;
617 618
		if (optlen < sizeof(int))
			goto e_inval;
Linus Torvalds's avatar
Linus Torvalds committed
619

620
		if (val) {
Eric Dumazet's avatar
Eric Dumazet committed
621
			struct net_device *dev;
622
			int midx;
Eric Dumazet's avatar
Eric Dumazet committed
623

624
			rcu_read_lock();
625

626
			dev = dev_get_by_index_rcu(net, val);
Eric Dumazet's avatar
Eric Dumazet committed
627
			if (!dev) {
628
				rcu_read_unlock();
629 630 631
				retv = -ENODEV;
				break;
			}
632 633 634 635 636 637 638 639
			midx = l3mdev_master_ifindex_rcu(dev);

			rcu_read_unlock();

			if (sk->sk_bound_dev_if &&
			    sk->sk_bound_dev_if != val &&
			    (!midx || midx != sk->sk_bound_dev_if))
				goto e_inval;
Linus Torvalds's avatar
Linus Torvalds committed
640 641 642 643 644 645 646 647 648
		}
		np->mcast_oif = val;
		retv = 0;
		break;
	case IPV6_ADD_MEMBERSHIP:
	case IPV6_DROP_MEMBERSHIP:
	{
		struct ipv6_mreq mreq;

649 650 651
		if (optlen < sizeof(struct ipv6_mreq))
			goto e_inval;

652 653 654 655
		retv = -EPROTO;
		if (inet_sk(sk)->is_icsk)
			break;

Linus Torvalds's avatar
Linus Torvalds committed
656 657 658 659 660
		retv = -EFAULT;
		if (copy_from_user(&mreq, optval, sizeof(struct ipv6_mreq)))
			break;

		if (optname == IPV6_ADD_MEMBERSHIP)
661
			retv = ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
Linus Torvalds's avatar
Linus Torvalds committed
662
		else
663
			retv = ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr);
Linus Torvalds's avatar
Linus Torvalds committed
664 665 666 667 668 669 670
		break;
	}
	case IPV6_JOIN_ANYCAST:
	case IPV6_LEAVE_ANYCAST:
	{
		struct ipv6_mreq mreq;

671
		if (optlen < sizeof(struct ipv6_mreq))
Linus Torvalds's avatar
Linus Torvalds committed
672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
			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;

690 691 692
		if (optlen < sizeof(struct group_req))
			goto e_inval;

Linus Torvalds's avatar
Linus Torvalds committed
693 694 695 696 697 698 699 700 701
		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)
702 703
			retv = ipv6_sock_mc_join(sk, greq.gr_interface,
						 &psin6->sin6_addr);
Linus Torvalds's avatar
Linus Torvalds committed
704
		else
705 706
			retv = ipv6_sock_mc_drop(sk, greq.gr_interface,
						 &psin6->sin6_addr);
Linus Torvalds's avatar
Linus Torvalds committed
707 708 709 710 711 712 713 714 715 716
		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;

717
		if (optlen < sizeof(struct group_source_req))
Linus Torvalds's avatar
Linus Torvalds committed
718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737
			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;
738 739 740
			retv = ipv6_sock_mc_join_ssm(sk, greqs.gsr_interface,
						     &psin6->sin6_addr,
						     MCAST_INCLUDE);
741 742
			/* prior join w/ different source is ok */
			if (retv && retv != -EADDRINUSE)
Linus Torvalds's avatar
Linus Torvalds committed
743 744 745
				break;
			omode = MCAST_INCLUDE;
			add = 1;
746
		} else /* MCAST_LEAVE_SOURCE_GROUP */ {
Linus Torvalds's avatar
Linus Torvalds committed
747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
			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;
		}
763 764 765
		gsf = memdup_user(optval, optlen);
		if (IS_ERR(gsf)) {
			retv = PTR_ERR(gsf);
Linus Torvalds's avatar
Linus Torvalds committed
766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785
			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:
786 787
		if (optlen < sizeof(int))
			goto e_inval;
788
		retv = ip6_ra_control(sk, val);
Linus Torvalds's avatar
Linus Torvalds committed
789 790
		break;
	case IPV6_MTU_DISCOVER:
791 792
		if (optlen < sizeof(int))
			goto e_inval;
793
		if (val < IPV6_PMTUDISC_DONT || val > IPV6_PMTUDISC_OMIT)
Linus Torvalds's avatar
Linus Torvalds committed
794 795 796 797 798
			goto e_inval;
		np->pmtudisc = val;
		retv = 0;
		break;
	case IPV6_MTU:
799 800
		if (optlen < sizeof(int))
			goto e_inval;
Linus Torvalds's avatar
Linus Torvalds committed
801 802 803 804 805 806
		if (val && val < IPV6_MIN_MTU)
			goto e_inval;
		np->frag_size = val;
		retv = 0;
		break;
	case IPV6_RECVERR:
807 808
		if (optlen < sizeof(int))
			goto e_inval;
Linus Torvalds's avatar
Linus Torvalds committed
809 810 811 812 813 814
		np->recverr = valbool;
		if (!val)
			skb_queue_purge(&sk->sk_error_queue);
		retv = 0;
		break;
	case IPV6_FLOWINFO_SEND:
815 816
		if (optlen < sizeof(int))
			goto e_inval;
Linus Torvalds's avatar
Linus Torvalds committed
817 818 819 820 821 822 823 824
		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:
825
		retv = -EPERM;
826
		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
827
			break;
Linus Torvalds's avatar
Linus Torvalds committed
828 829 830
		retv = xfrm_user_policy(sk, optname, optval, optlen);
		break;

831 832 833 834 835
	case IPV6_ADDR_PREFERENCES:
	    {
		unsigned int pref = 0;
		unsigned int prefmask = ~0;

836 837 838
		if (optlen < sizeof(int))
			goto e_inval;

839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
		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;
	    }
893 894 895 896 897 898
	case IPV6_MINHOPCOUNT:
		if (optlen < sizeof(int))
			goto e_inval;
		if (val < 0 || val > 255)
			goto e_inval;
		np->min_hopcount = val;
899
		retv = 0;
900 901 902
		break;
	case IPV6_DONTFRAG:
		np->dontfrag = valbool;
903 904
		retv = 0;
		break;
905 906
	case IPV6_AUTOFLOWLABEL:
		np->autoflowlabel = valbool;
907
		np->autoflowlabel_set = 1;
908 909
		retv = 0;
		break;
910 911 912 913
	case IPV6_RECVFRAGSIZE:
		np->rxopt.bits.recvfragsize = valbool;
		retv = 0;
		break;
Linus Torvalds's avatar
Linus Torvalds committed
914
	}
915

Linus Torvalds's avatar
Linus Torvalds committed
916
	release_sock(sk);
917 918
	if (needs_rtnl)
		rtnl_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
919 920 921 922 923

	return retv;

e_inval:
	release_sock(sk);
924 925
	if (needs_rtnl)
		rtnl_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
926 927 928
	return -EINVAL;
}

929
int ipv6_setsockopt(struct sock *sk, int level, int optname,
930
		    char __user *optval, unsigned int optlen)
931 932 933 934 935 936 937 938 939 940 941 942 943
{
	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 &&
944 945
			optname != IPV6_XFRM_POLICY)
		err = nf_setsockopt(sk, PF_INET6, optname, optval, optlen);
946 947 948
#endif
	return err;
}
949
EXPORT_SYMBOL(ipv6_setsockopt);
950 951 952

#ifdef CONFIG_COMPAT
int compat_ipv6_setsockopt(struct sock *sk, int level, int optname,
953
			   char __user *optval, unsigned int optlen)
954 955 956 957
{
	int err;

	if (level == SOL_IP && sk->sk_type != SOCK_RAW) {
958 959 960 961
		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);
962 963 964 965 966
	}

	if (level != SOL_IPV6)
		return -ENOPROTOOPT;

967 968 969 970
	if (optname >= MCAST_JOIN_GROUP && optname <= MCAST_MSFILTER)
		return compat_mc_setsockopt(sk, level, optname, optval, optlen,
			ipv6_setsockopt);

971 972 973 974
	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 &&
975 976 977
	    optname != IPV6_XFRM_POLICY)
		err = compat_nf_setsockopt(sk, PF_INET6, optname, optval,
					   optlen);
978 979 980
#endif
	return err;
}
981
EXPORT_SYMBOL(compat_ipv6_setsockopt);
982 983
#endif

984
static int ipv6_getsockopt_sticky(struct sock *sk, struct ipv6_txoptions *opt,
985
				  int optname, char __user *optval, int len)
986
{
987 988
	struct ipv6_opt_hdr *hdr;

989 990 991
	if (!opt)
		return 0;

992
	switch (optname) {
993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
	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)
1010
		return 0;
1011

1012
	len = min_t(unsigned int, len, ipv6_optlen(hdr));
1013
	if (copy_to_user(optval, hdr, len))
1014
		return -EFAULT;
1015
	return len;
1016 1017
}

1018
static int do_ipv6_getsockopt(struct sock *sk, int level, int optname,
1019
		    char __user *optval, int __user *optlen, unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
1020 1021 1022 1023 1024
{
	struct ipv6_pinfo *np = inet6_sk(sk);
	int len;
	int val;

1025 1026 1027
	if (ip6_mroute_opt(optname))
		return ip6_mroute_getsockopt(sk, optname, optval, optlen);

Linus Torvalds's avatar
Linus Torvalds committed
1028 1029 1030 1031 1032
	if (get_user(len, optlen))
		return -EFAULT;
	switch (optname) {
	case IPV6_ADDRFORM:
		if (sk->sk_protocol != IPPROTO_UDP &&
1033
		    sk->sk_protocol != IPPROTO_UDPLITE &&
Linus Torvalds's avatar
Linus Torvalds committed
1034
		    sk->sk_protocol != IPPROTO_TCP)
1035
			return -ENOPROTOOPT;
Linus Torvalds's avatar
Linus Torvalds committed
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
		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;
1049 1050
		if (gsf.gf_group.ss_family != AF_INET6)
			return -EADDRNOTAVAIL;
Linus Torvalds's avatar
Linus Torvalds committed
1051 1052 1053 1054 1055 1056 1057
		lock_sock(sk);
		err = ip6_mc_msfget(sk, &gsf,
			(struct group_filter __user *)optval, optlen);
		release_sock(sk);
		return err;
	}

1058
	case IPV6_2292PKTOPTIONS:
Linus Torvalds's avatar
Linus Torvalds committed
1059 1060 1061 1062 1063 1064 1065 1066 1067
	{
		struct msghdr msg;
		struct sk_buff *skb;

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

		msg.msg_control = optval;
		msg.msg_controllen = len;
1068
		msg.msg_flags = flags;
Linus Torvalds's avatar
Linus Torvalds committed
1069 1070 1071 1072

		lock_sock(sk);
		skb = np->pktoptions;
		if (skb)
1073
			ip6_datagram_recv_ctl(sk, &msg, skb);
1074 1075
		release_sock(sk);
		if (!skb) {
Linus Torvalds's avatar
Linus Torvalds committed
1076 1077
			if (np->rxopt.bits.rxinfo) {
				struct in6_pktinfo src_info;
1078 1079
				src_info.ipi6_ifindex = np->mcast_oif ? np->mcast_oif :
					np->sticky_pktinfo.ipi6_ifindex;
1080
				src_info.ipi6_addr = np->mcast_oif ? sk->sk_v6_daddr : np->sticky_pktinfo.ipi6_addr;
Linus Torvalds's avatar
Linus Torvalds committed
1081 1082 1083 1084 1085 1086
				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);
			}
1087
			if (np->rxopt.bits.rxtclass) {
1088 1089
				int tclass = (int)ip6_tclass(np->rcv_flowinfo);

1090 1091
				put_cmsg(&msg, SOL_IPV6, IPV6_TCLASS, sizeof(tclass), &tclass);
			}
1092 1093
			if (np->rxopt.bits.rxoinfo) {
				struct in6_pktinfo src_info;
1094 1095
				src_info.ipi6_ifindex = np->mcast_oif ? np->mcast_oif :
					np->sticky_pktinfo.ipi6_ifindex;
1096 1097
				src_info.ipi6_addr = np->mcast_oif ? sk->sk_v6_daddr :
								     np->sticky_pktinfo.ipi6_addr;
1098 1099 1100 1101 1102 1103
				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);
			}
1104
			if (np->rxopt.bits.rxflow) {
1105 1106
				__be32 flowinfo = np->rcv_flowinfo;

1107 1108
				put_cmsg(&msg, SOL_IPV6, IPV6_FLOWINFO, sizeof(flowinfo), &flowinfo);
			}
Linus Torvalds's avatar
Linus Torvalds committed
1109 1110 1111 1112 1113 1114 1115
		}
		len -= msg.msg_controllen;
		return put_user(len, optlen);
	}
	case IPV6_MTU:
	{
		struct dst_entry *dst;
1116

1117
		val = 0;
1118 1119 1120
		rcu_read_lock();
		dst = __sk_dst_get(sk);
		if (dst)
Linus Torvalds's avatar
Linus Torvalds committed
1121
			val = dst_mtu(dst);
1122
		rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
1123 1124 1125 1126 1127 1128
		if (!val)
			return -ENOTCONN;
		break;
	}

	case IPV6_V6ONLY:
1129
		val = sk->sk_ipv6only;
Linus Torvalds's avatar
Linus Torvalds committed
1130 1131
		break;

1132
	case IPV6_RECVPKTINFO:
Linus Torvalds's avatar
Linus Torvalds committed
1133 1134 1135
		val = np->rxopt.bits.rxinfo;
		break;

1136 1137 1138 1139 1140
	case IPV6_2292PKTINFO:
		val = np->rxopt.bits.rxoinfo;
		break;

	case IPV6_RECVHOPLIMIT:
Linus Torvalds's avatar
Linus Torvalds committed
1141 1142 1143
		val = np->rxopt.bits.rxhlim;
		break;

1144 1145 1146 1147 1148
	case IPV6_2292HOPLIMIT:
		val = np->rxopt.bits.rxohlim;
		break;

	case IPV6_RECVRTHDR:
Linus Torvalds's avatar
Linus Torvalds committed
1149 1150 1151
		val = np->rxopt.bits.srcrt;
		break;

1152 1153 1154 1155
	case IPV6_2292RTHDR:
		val = np->rxopt.bits.osrcrt;
		break;

Linus Torvalds's avatar
Linus Torvalds committed
1156
	case IPV6_HOPOPTS:
1157 1158 1159 1160
	case IPV6_RTHDRDSTOPTS:
	case IPV6_RTHDR:
	case IPV6_DSTOPTS:
	{
1161
		struct ipv6_txoptions *opt;
1162 1163

		lock_sock(sk);
1164 1165
		opt = rcu_dereference_protected(np->opt,
						lockdep_sock_is_held(sk));
1166
		len = ipv6_getsockopt_sticky(sk, opt, optname, optval, len);
1167
		release_sock(sk);
1168 1169 1170
		/* check if ipv6_getsockopt_sticky() returns err code */
		if (len < 0)
			return len;
1171 1172 1173 1174
		return put_user(len, optlen);
	}

	case IPV6_RECVHOPOPTS:
Linus Torvalds's avatar
Linus Torvalds committed
1175 1176 1177
		val = np->rxopt.bits.hopopts;
		break;

1178 1179 1180 1181 1182
	case IPV6_2292HOPOPTS:
		val = np->rxopt.bits.ohopopts;
		break;

	case IPV6_RECVDSTOPTS:
Linus Torvalds's avatar
Linus Torvalds committed
1183 1184 1185
		val = np->rxopt.bits.dstopts;
		break;

1186 1187 1188 1189
	case IPV6_2292DSTOPTS:
		val = np->rxopt.bits.odstopts;
		break;

1190 1191 1192 1193 1194 1195 1196 1197
	case IPV6_TCLASS:
		val = np->tclass;
		break;

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

Linus Torvalds's avatar
Linus Torvalds committed
1198 1199 1200 1201
	case IPV6_FLOWINFO:
		val = np->rxopt.bits.rxflow;
		break;

1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
	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;
	}

1233 1234 1235 1236
	case IPV6_TRANSPARENT:
		val = inet_sk(sk)->transparent;
		break;

1237 1238 1239 1240
	case IPV6_FREEBIND:
		val = inet_sk(sk)->freebind;
		break;

1241 1242 1243 1244
	case IPV6_RECVORIGDSTADDR:
		val = np->rxopt.bits.rxorigdstaddr;
		break;

Linus Torvalds's avatar
Linus Torvalds committed
1245 1246
	case IPV6_UNICAST_HOPS:
	case IPV6_MULTICAST_HOPS:
1247 1248 1249 1250 1251 1252 1253 1254
	{
		struct dst_entry *dst;

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

1255 1256 1257 1258
		if (val < 0) {
			rcu_read_lock();
			dst = __sk_dst_get(sk);
			if (dst)
1259
				val = ip6_dst_hoplimit(dst);
1260
			rcu_read_unlock();
1261
		}
1262

1263
		if (val < 0)
1264
			val = sock_net(sk)->ipv6.devconf_all->hop_limit;
Linus Torvalds's avatar
Linus Torvalds committed
1265
		break;
1266
	}
Linus Torvalds's avatar
Linus Torvalds committed
1267 1268 1269 1270 1271 1272 1273 1274 1275

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

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

1276 1277 1278 1279
	case IPV6_UNICAST_IF:
		val = (__force int)htonl((__u32) np->ucast_oif);
		break;

Linus Torvalds's avatar
Linus Torvalds committed
1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291
	case IPV6_MTU_DISCOVER:
		val = np->pmtudisc;
		break;

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

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

1292 1293 1294
	case IPV6_FLOWLABEL_MGR:
	{
		struct in6_flowlabel_req freq;
1295
		int flags;
1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306

		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);
1307 1308
		flags = freq.flr_flags;

1309 1310
		memset(&freq, 0, sizeof(freq));

1311
		val = ipv6_flowlabel_opt_get(sk, &freq, flags);
1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322
		if (val < 0)
			return val;

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

		return 0;
	}

1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
	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;
1340 1341 1342 1343

	case IPV6_MINHOPCOUNT:
		val = np->min_hopcount;
		break;
1344 1345 1346 1347

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

1349
	case IPV6_AUTOFLOWLABEL:
1350
		val = ip6_autoflowlabel(sock_net(sk), np);
1351 1352
		break;

1353 1354 1355 1356
	case IPV6_RECVFRAGSIZE:
		val = np->rxopt.bits.recvfragsize;
		break;

Linus Torvalds's avatar
Linus Torvalds committed
1357
	default:
1358
		return -ENOPROTOOPT;
Linus Torvalds's avatar
Linus Torvalds committed
1359 1360
	}
	len = min_t(unsigned int, sizeof(int), len);
1361
	if (put_user(len, optlen))
Linus Torvalds's avatar
Linus Torvalds committed
1362
		return -EFAULT;
1363
	if (copy_to_user(optval, &val, len))
Linus Torvalds's avatar
Linus Torvalds committed
1364 1365 1366 1367
		return -EFAULT;
	return 0;
}

1368 1369 1370 1371 1372 1373 1374 1375
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);

1376
	if (level != SOL_IPV6)
1377 1378
		return -ENOPROTOOPT;

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

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

1388
		err = nf_getsockopt(sk, PF_INET6, optname, optval, &len);
1389 1390 1391 1392 1393 1394
		if (err >= 0)
			err = put_user(len, optlen);
	}
#endif
	return err;
}
1395 1396
EXPORT_SYMBOL(ipv6_getsockopt);

1397 1398
#ifdef CONFIG_COMPAT
int compat_ipv6_getsockopt(struct sock *sk, int level, int optname,
1399
			   char __user *optval, int __user *optlen)
1400 1401 1402 1403
{
	int err;

	if (level == SOL_IP && sk->sk_type != SOCK_RAW) {
1404 1405 1406 1407
		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);
1408 1409
	}

1410
	if (level != SOL_IPV6)
1411 1412
		return -ENOPROTOOPT;

1413 1414 1415 1416
	if (optname == MCAST_MSFILTER)
		return compat_mc_getsockopt(sk, level, optname, optval, optlen,
			ipv6_getsockopt);

1417 1418
	err = do_ipv6_getsockopt(sk, level, optname, optval, optlen,
				 MSG_CMSG_COMPAT);
1419
#ifdef CONFIG_NETFILTER
1420 1421
	/* we need to exclude all possible ENOPROTOOPTs except default case */
	if (err == -ENOPROTOOPT && optname != IPV6_2292PKTOPTIONS) {
1422 1423 1424 1425 1426
		int len;

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

1427
		err = compat_nf_getsockopt(sk, PF_INET6, optname, optval, &len);
1428 1429 1430 1431 1432 1433
		if (err >= 0)
			err = put_user(len, optlen);
	}
#endif
	return err;
}
1434
EXPORT_SYMBOL(compat_ipv6_getsockopt);
1435
#endif