ip_sockglue.c 30.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6
/*
 * INET		An implementation of the TCP/IP protocol suite for the LINUX
 *		operating system.  INET is implemented using the  BSD Socket
 *		interface as the means of communication with the user level.
 *
 *		The IP to API glue.
7
 *
L
Linus Torvalds 已提交
8 9 10 11 12
 * Authors:	see ip.c
 *
 * Fixes:
 *		Many		:	Split from ip.c , see ip.c for history.
 *		Martin Mares	:	TOS setting fixed.
13
 *		Alan Cox	:	Fixed a couple of oopses in Martin's
L
Linus Torvalds 已提交
14 15 16 17 18 19 20 21 22 23
 *					TOS tweaks.
 *		Mike McLagan	:	Routing by source
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/mm.h>
#include <linux/skbuff.h>
#include <linux/ip.h>
#include <linux/icmp.h>
24
#include <linux/inetdevice.h>
L
Linus Torvalds 已提交
25
#include <linux/netdevice.h>
26
#include <linux/slab.h>
L
Linus Torvalds 已提交
27 28 29
#include <net/sock.h>
#include <net/ip.h>
#include <net/icmp.h>
30
#include <net/tcp_states.h>
L
Linus Torvalds 已提交
31 32 33 34 35
#include <linux/udp.h>
#include <linux/igmp.h>
#include <linux/netfilter.h>
#include <linux/route.h>
#include <linux/mroute.h>
36
#include <net/inet_ecn.h>
L
Linus Torvalds 已提交
37 38
#include <net/route.h>
#include <net/xfrm.h>
39
#include <net/compat.h>
E
Eric Dumazet 已提交
40
#if IS_ENABLED(CONFIG_IPV6)
L
Linus Torvalds 已提交
41 42 43 44 45 46 47 48 49 50 51
#include <net/transp_v6.h>
#endif

#include <linux/errqueue.h>
#include <asm/uaccess.h>

#define IP_CMSG_PKTINFO		1
#define IP_CMSG_TTL		2
#define IP_CMSG_TOS		4
#define IP_CMSG_RECVOPTS	8
#define IP_CMSG_RETOPTS		16
C
Catherine Zhang 已提交
52
#define IP_CMSG_PASSSEC		32
53
#define IP_CMSG_ORIGDSTADDR     64
L
Linus Torvalds 已提交
54 55 56 57

/*
 *	SOL_IP control messages.
 */
58
#define PKTINFO_SKB_CB(__skb) ((struct in_pktinfo *)((__skb)->cb))
L
Linus Torvalds 已提交
59 60 61

static void ip_cmsg_recv_pktinfo(struct msghdr *msg, struct sk_buff *skb)
{
62
	struct in_pktinfo info = *PKTINFO_SKB_CB(skb);
L
Linus Torvalds 已提交
63

64
	info.ipi_addr.s_addr = ip_hdr(skb)->daddr;
L
Linus Torvalds 已提交
65 66 67 68 69 70

	put_cmsg(msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
}

static void ip_cmsg_recv_ttl(struct msghdr *msg, struct sk_buff *skb)
{
71
	int ttl = ip_hdr(skb)->ttl;
L
Linus Torvalds 已提交
72 73 74 75 76
	put_cmsg(msg, SOL_IP, IP_TTL, sizeof(int), &ttl);
}

static void ip_cmsg_recv_tos(struct msghdr *msg, struct sk_buff *skb)
{
77
	put_cmsg(msg, SOL_IP, IP_TOS, 1, &ip_hdr(skb)->tos);
L
Linus Torvalds 已提交
78 79 80 81 82 83 84
}

static void ip_cmsg_recv_opts(struct msghdr *msg, struct sk_buff *skb)
{
	if (IPCB(skb)->opt.optlen == 0)
		return;

85 86
	put_cmsg(msg, SOL_IP, IP_RECVOPTS, IPCB(skb)->opt.optlen,
		 ip_hdr(skb) + 1);
L
Linus Torvalds 已提交
87 88 89 90 91 92
}


static void ip_cmsg_recv_retopts(struct msghdr *msg, struct sk_buff *skb)
{
	unsigned char optbuf[sizeof(struct ip_options) + 40];
93
	struct ip_options * opt = (struct ip_options *)optbuf;
L
Linus Torvalds 已提交
94 95 96 97 98 99 100 101 102 103 104 105 106

	if (IPCB(skb)->opt.optlen == 0)
		return;

	if (ip_options_echo(opt, skb)) {
		msg->msg_flags |= MSG_CTRUNC;
		return;
	}
	ip_options_undo(opt);

	put_cmsg(msg, SOL_IP, IP_RETOPTS, opt->optlen, opt->__data);
}

C
Catherine Zhang 已提交
107 108 109
static void ip_cmsg_recv_security(struct msghdr *msg, struct sk_buff *skb)
{
	char *secdata;
110
	u32 seclen, secid;
C
Catherine Zhang 已提交
111 112
	int err;

113 114 115 116 117
	err = security_socket_getpeersec_dgram(NULL, skb, &secid);
	if (err)
		return;

	err = security_secid_to_secctx(secid, &secdata, &seclen);
C
Catherine Zhang 已提交
118 119 120 121
	if (err)
		return;

	put_cmsg(msg, SOL_IP, SCM_SECURITY, seclen, secdata);
122
	security_release_secctx(secdata, seclen);
C
Catherine Zhang 已提交
123 124
}

125
static void ip_cmsg_recv_dstaddr(struct msghdr *msg, struct sk_buff *skb)
126 127
{
	struct sockaddr_in sin;
128
	const struct iphdr *iph = ip_hdr(skb);
129
	__be16 *ports = (__be16 *)skb_transport_header(skb);
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145

	if (skb_transport_offset(skb) + 4 > skb->len)
		return;

	/* All current transport protocols have the port numbers in the
	 * first four bytes of the transport header and this function is
	 * written with this assumption in mind.
	 */

	sin.sin_family = AF_INET;
	sin.sin_addr.s_addr = iph->daddr;
	sin.sin_port = ports[1];
	memset(sin.sin_zero, 0, sizeof(sin.sin_zero));

	put_cmsg(msg, SOL_IP, IP_ORIGDSTADDR, sizeof(sin), &sin);
}
L
Linus Torvalds 已提交
146 147 148 149 150 151 152 153 154

void ip_cmsg_recv(struct msghdr *msg, struct sk_buff *skb)
{
	struct inet_sock *inet = inet_sk(skb->sk);
	unsigned flags = inet->cmsg_flags;

	/* Ordered by supposed usage frequency */
	if (flags & 1)
		ip_cmsg_recv_pktinfo(msg, skb);
E
Eric Dumazet 已提交
155
	if ((flags >>= 1) == 0)
L
Linus Torvalds 已提交
156 157 158 159
		return;

	if (flags & 1)
		ip_cmsg_recv_ttl(msg, skb);
E
Eric Dumazet 已提交
160
	if ((flags >>= 1) == 0)
L
Linus Torvalds 已提交
161 162 163 164
		return;

	if (flags & 1)
		ip_cmsg_recv_tos(msg, skb);
E
Eric Dumazet 已提交
165
	if ((flags >>= 1) == 0)
L
Linus Torvalds 已提交
166 167 168 169
		return;

	if (flags & 1)
		ip_cmsg_recv_opts(msg, skb);
E
Eric Dumazet 已提交
170
	if ((flags >>= 1) == 0)
L
Linus Torvalds 已提交
171 172 173 174
		return;

	if (flags & 1)
		ip_cmsg_recv_retopts(msg, skb);
E
Eric Dumazet 已提交
175
	if ((flags >>= 1) == 0)
C
Catherine Zhang 已提交
176 177 178 179
		return;

	if (flags & 1)
		ip_cmsg_recv_security(msg, skb);
180

E
Eric Dumazet 已提交
181
	if ((flags >>= 1) == 0)
182 183 184 185
		return;
	if (flags & 1)
		ip_cmsg_recv_dstaddr(msg, skb);

L
Linus Torvalds 已提交
186
}
E
Eric Dumazet 已提交
187
EXPORT_SYMBOL(ip_cmsg_recv);
L
Linus Torvalds 已提交
188

189
int ip_cmsg_send(struct net *net, struct msghdr *msg, struct ipcm_cookie *ipc)
L
Linus Torvalds 已提交
190 191 192 193 194 195 196 197 198 199 200 201
{
	int err;
	struct cmsghdr *cmsg;

	for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
		if (!CMSG_OK(msg, cmsg))
			return -EINVAL;
		if (cmsg->cmsg_level != SOL_IP)
			continue;
		switch (cmsg->cmsg_type) {
		case IP_RETOPTS:
			err = cmsg->cmsg_len - CMSG_ALIGN(sizeof(struct cmsghdr));
E
Eric Dumazet 已提交
202 203
			err = ip_options_get(net, &ipc->opt, CMSG_DATA(cmsg),
					     err < 40 ? err : 40);
L
Linus Torvalds 已提交
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
			if (err)
				return err;
			break;
		case IP_PKTINFO:
		{
			struct in_pktinfo *info;
			if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct in_pktinfo)))
				return -EINVAL;
			info = (struct in_pktinfo *)CMSG_DATA(cmsg);
			ipc->oif = info->ipi_ifindex;
			ipc->addr = info->ipi_spec_dst.s_addr;
			break;
		}
		default:
			return -EINVAL;
		}
	}
	return 0;
}


/* Special input handler for packets caught by router alert option.
   They are selected only by protocol field, and then processed likely
   local ones; but only if someone wants them! Otherwise, router
   not running rsvpd will kill RSVP.

   It is user level problem, what it will make with them.
   I have no idea, how it will masquearde or NAT them (it is joke, joke :-)),
   but receiver should be enough clever f.e. to forward mtrace requests,
   sent to multicast group to reach destination designated router.
 */
235
struct ip_ra_chain __rcu *ip_ra_chain;
E
Eric Dumazet 已提交
236 237
static DEFINE_SPINLOCK(ip_ra_lock);

E
Eric Dumazet 已提交
238 239

static void ip_ra_destroy_rcu(struct rcu_head *head)
E
Eric Dumazet 已提交
240
{
E
Eric Dumazet 已提交
241 242 243 244
	struct ip_ra_chain *ra = container_of(head, struct ip_ra_chain, rcu);

	sock_put(ra->saved_sk);
	kfree(ra);
E
Eric Dumazet 已提交
245
}
L
Linus Torvalds 已提交
246

E
Eric Dumazet 已提交
247 248
int ip_ra_control(struct sock *sk, unsigned char on,
		  void (*destructor)(struct sock *))
L
Linus Torvalds 已提交
249
{
250 251
	struct ip_ra_chain *ra, *new_ra;
	struct ip_ra_chain __rcu **rap;
L
Linus Torvalds 已提交
252

E
Eric Dumazet 已提交
253
	if (sk->sk_type != SOCK_RAW || inet_sk(sk)->inet_num == IPPROTO_RAW)
L
Linus Torvalds 已提交
254 255 256 257
		return -EINVAL;

	new_ra = on ? kmalloc(sizeof(*new_ra), GFP_KERNEL) : NULL;

E
Eric Dumazet 已提交
258
	spin_lock_bh(&ip_ra_lock);
259 260 261 262
	for (rap = &ip_ra_chain;
	     (ra = rcu_dereference_protected(*rap,
			lockdep_is_held(&ip_ra_lock))) != NULL;
	     rap = &ra->next) {
L
Linus Torvalds 已提交
263 264
		if (ra->sk == sk) {
			if (on) {
E
Eric Dumazet 已提交
265
				spin_unlock_bh(&ip_ra_lock);
J
Jesper Juhl 已提交
266
				kfree(new_ra);
L
Linus Torvalds 已提交
267 268
				return -EADDRINUSE;
			}
E
Eric Dumazet 已提交
269 270
			/* dont let ip_call_ra_chain() use sk again */
			ra->sk = NULL;
E
Eric Dumazet 已提交
271 272
			rcu_assign_pointer(*rap, ra->next);
			spin_unlock_bh(&ip_ra_lock);
L
Linus Torvalds 已提交
273 274 275

			if (ra->destructor)
				ra->destructor(sk);
E
Eric Dumazet 已提交
276 277 278 279 280 281 282
			/*
			 * Delay sock_put(sk) and kfree(ra) after one rcu grace
			 * period. This guarantee ip_call_ra_chain() dont need
			 * to mess with socket refcounts.
			 */
			ra->saved_sk = sk;
			call_rcu(&ra->rcu, ip_ra_destroy_rcu);
L
Linus Torvalds 已提交
283 284 285 286
			return 0;
		}
	}
	if (new_ra == NULL) {
E
Eric Dumazet 已提交
287
		spin_unlock_bh(&ip_ra_lock);
L
Linus Torvalds 已提交
288 289 290 291 292 293
		return -ENOBUFS;
	}
	new_ra->sk = sk;
	new_ra->destructor = destructor;

	new_ra->next = ra;
E
Eric Dumazet 已提交
294
	rcu_assign_pointer(*rap, new_ra);
L
Linus Torvalds 已提交
295
	sock_hold(sk);
E
Eric Dumazet 已提交
296
	spin_unlock_bh(&ip_ra_lock);
L
Linus Torvalds 已提交
297 298 299 300

	return 0;
}

301
void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
A
Al Viro 已提交
302
		   __be16 port, u32 info, u8 *payload)
L
Linus Torvalds 已提交
303 304 305 306 307 308 309
{
	struct sock_exterr_skb *serr;

	skb = skb_clone(skb, GFP_ATOMIC);
	if (!skb)
		return;

310
	serr = SKB_EXT_ERR(skb);
L
Linus Torvalds 已提交
311 312
	serr->ee.ee_errno = err;
	serr->ee.ee_origin = SO_EE_ORIGIN_ICMP;
313 314
	serr->ee.ee_type = icmp_hdr(skb)->type;
	serr->ee.ee_code = icmp_hdr(skb)->code;
L
Linus Torvalds 已提交
315 316 317
	serr->ee.ee_pad = 0;
	serr->ee.ee_info = info;
	serr->ee.ee_data = 0;
318
	serr->addr_offset = (u8 *)&(((struct iphdr *)(icmp_hdr(skb) + 1))->daddr) -
319
				   skb_network_header(skb);
L
Linus Torvalds 已提交
320 321
	serr->port = port;

322 323 324 325 326 327
	if (skb_pull(skb, payload - skb->data) != NULL) {
		skb_reset_transport_header(skb);
		if (sock_queue_err_skb(sk, skb) == 0)
			return;
	}
	kfree_skb(skb);
L
Linus Torvalds 已提交
328 329
}

A
Al Viro 已提交
330
void ip_local_error(struct sock *sk, int err, __be32 daddr, __be16 port, u32 info)
L
Linus Torvalds 已提交
331 332 333 334 335 336 337 338 339 340 341 342 343
{
	struct inet_sock *inet = inet_sk(sk);
	struct sock_exterr_skb *serr;
	struct iphdr *iph;
	struct sk_buff *skb;

	if (!inet->recverr)
		return;

	skb = alloc_skb(sizeof(struct iphdr), GFP_ATOMIC);
	if (!skb)
		return;

344 345
	skb_put(skb, sizeof(struct iphdr));
	skb_reset_network_header(skb);
346
	iph = ip_hdr(skb);
L
Linus Torvalds 已提交
347 348
	iph->daddr = daddr;

349
	serr = SKB_EXT_ERR(skb);
L
Linus Torvalds 已提交
350 351
	serr->ee.ee_errno = err;
	serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
352
	serr->ee.ee_type = 0;
L
Linus Torvalds 已提交
353 354 355 356
	serr->ee.ee_code = 0;
	serr->ee.ee_pad = 0;
	serr->ee.ee_info = info;
	serr->ee.ee_data = 0;
357
	serr->addr_offset = (u8 *)&iph->daddr - skb_network_header(skb);
L
Linus Torvalds 已提交
358 359
	serr->port = port;

360
	__skb_pull(skb, skb_tail_pointer(skb) - skb->data);
361
	skb_reset_transport_header(skb);
L
Linus Torvalds 已提交
362 363 364 365 366

	if (sock_queue_err_skb(sk, skb))
		kfree_skb(skb);
}

367
/*
L
Linus Torvalds 已提交
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
 *	Handle MSG_ERRQUEUE
 */
int ip_recv_error(struct sock *sk, struct msghdr *msg, int len)
{
	struct sock_exterr_skb *serr;
	struct sk_buff *skb, *skb2;
	struct sockaddr_in *sin;
	struct {
		struct sock_extended_err ee;
		struct sockaddr_in	 offender;
	} errhdr;
	int err;
	int copied;

	err = -EAGAIN;
	skb = skb_dequeue(&sk->sk_error_queue);
	if (skb == NULL)
		goto out;

	copied = skb->len;
	if (copied > len) {
		msg->msg_flags |= MSG_TRUNC;
		copied = len;
	}
	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
	if (err)
		goto out_free_skb;

	sock_recv_timestamp(msg, sk, skb);

	serr = SKB_EXT_ERR(skb);

	sin = (struct sockaddr_in *)msg->msg_name;
	if (sin) {
		sin->sin_family = AF_INET;
403 404
		sin->sin_addr.s_addr = *(__be32 *)(skb_network_header(skb) +
						   serr->addr_offset);
L
Linus Torvalds 已提交
405 406 407 408 409 410 411 412 413 414 415
		sin->sin_port = serr->port;
		memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
	}

	memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
	sin = &errhdr.offender;
	sin->sin_family = AF_UNSPEC;
	if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP) {
		struct inet_sock *inet = inet_sk(sk);

		sin->sin_family = AF_INET;
416
		sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
L
Linus Torvalds 已提交
417 418 419 420 421 422 423 424 425 426 427 428 429 430
		sin->sin_port = 0;
		memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
		if (inet->cmsg_flags)
			ip_cmsg_recv(msg, skb);
	}

	put_cmsg(msg, SOL_IP, IP_RECVERR, sizeof(errhdr), &errhdr);

	/* Now we could try to dump offended packet options */

	msg->msg_flags |= MSG_ERRQUEUE;
	err = copied;

	/* Reset and regenerate socket error */
431
	spin_lock_bh(&sk->sk_error_queue.lock);
L
Linus Torvalds 已提交
432
	sk->sk_err = 0;
E
Eric Dumazet 已提交
433 434
	skb2 = skb_peek(&sk->sk_error_queue);
	if (skb2 != NULL) {
L
Linus Torvalds 已提交
435
		sk->sk_err = SKB_EXT_ERR(skb2)->ee.ee_errno;
436
		spin_unlock_bh(&sk->sk_error_queue.lock);
L
Linus Torvalds 已提交
437 438
		sk->sk_error_report(sk);
	} else
439
		spin_unlock_bh(&sk->sk_error_queue.lock);
L
Linus Torvalds 已提交
440

441
out_free_skb:
L
Linus Torvalds 已提交
442 443 444 445 446 447 448
	kfree_skb(skb);
out:
	return err;
}


/*
E
Eric Dumazet 已提交
449 450
 *	Socket option code for IP. This is the end of the line after any
 *	TCP,UDP etc options on an IP socket.
L
Linus Torvalds 已提交
451 452
 */

453
static int do_ip_setsockopt(struct sock *sk, int level,
454
			    int optname, char __user *optval, unsigned int optlen)
L
Linus Torvalds 已提交
455 456
{
	struct inet_sock *inet = inet_sk(sk);
457
	int val = 0, err;
L
Linus Torvalds 已提交
458

459
	if (((1<<optname) & ((1<<IP_PKTINFO) | (1<<IP_RECVTTL) |
S
Stephen Hemminger 已提交
460 461 462 463 464
			     (1<<IP_RECVOPTS) | (1<<IP_RECVTOS) |
			     (1<<IP_RETOPTS) | (1<<IP_TOS) |
			     (1<<IP_TTL) | (1<<IP_HDRINCL) |
			     (1<<IP_MTU_DISCOVER) | (1<<IP_RECVERR) |
			     (1<<IP_ROUTER_ALERT) | (1<<IP_FREEBIND) |
465
			     (1<<IP_PASSSEC) | (1<<IP_TRANSPARENT) |
466
			     (1<<IP_MINTTL) | (1<<IP_NODEFRAG))) ||
S
Stephen Hemminger 已提交
467
	    optname == IP_MULTICAST_TTL ||
468
	    optname == IP_MULTICAST_ALL ||
469 470
	    optname == IP_MULTICAST_LOOP ||
	    optname == IP_RECVORIGDSTADDR) {
L
Linus Torvalds 已提交
471 472 473 474 475 476 477 478 479 480 481 482 483 484
		if (optlen >= sizeof(int)) {
			if (get_user(val, (int __user *) optval))
				return -EFAULT;
		} else if (optlen >= sizeof(char)) {
			unsigned char ucval;

			if (get_user(ucval, (unsigned char __user *) optval))
				return -EFAULT;
			val = (int) ucval;
		}
	}

	/* If optlen==0, it is equivalent to val == 0 */

485
	if (ip_mroute_opt(optname))
486
		return ip_mroute_setsockopt(sk, optname, optval, optlen);
L
Linus Torvalds 已提交
487 488 489 490 491

	err = 0;
	lock_sock(sk);

	switch (optname) {
S
Stephen Hemminger 已提交
492 493
	case IP_OPTIONS:
	{
494 495
		struct ip_options_rcu *old, *opt = NULL;

496
		if (optlen > 40)
S
Stephen Hemminger 已提交
497
			goto e_inval;
498
		err = ip_options_get_from_user(sock_net(sk), &opt,
499
					       optval, optlen);
S
Stephen Hemminger 已提交
500 501
		if (err)
			break;
502 503
		old = rcu_dereference_protected(inet->inet_opt,
						sock_owned_by_user(sk));
S
Stephen Hemminger 已提交
504 505
		if (inet->is_icsk) {
			struct inet_connection_sock *icsk = inet_csk(sk);
E
Eric Dumazet 已提交
506
#if IS_ENABLED(CONFIG_IPV6)
S
Stephen Hemminger 已提交
507 508 509
			if (sk->sk_family == PF_INET ||
			    (!((1 << sk->sk_state) &
			       (TCPF_LISTEN | TCPF_CLOSE)) &&
E
Eric Dumazet 已提交
510
			     inet->inet_daddr != LOOPBACK4_IPV6)) {
L
Linus Torvalds 已提交
511
#endif
512 513
				if (old)
					icsk->icsk_ext_hdr_len -= old->opt.optlen;
S
Stephen Hemminger 已提交
514
				if (opt)
515
					icsk->icsk_ext_hdr_len += opt->opt.optlen;
S
Stephen Hemminger 已提交
516
				icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie);
E
Eric Dumazet 已提交
517
#if IS_ENABLED(CONFIG_IPV6)
L
Linus Torvalds 已提交
518
			}
S
Stephen Hemminger 已提交
519
#endif
L
Linus Torvalds 已提交
520
		}
521 522
		rcu_assign_pointer(inet->inet_opt, opt);
		if (old)
523
			kfree_rcu(old, rcu);
S
Stephen Hemminger 已提交
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561
		break;
	}
	case IP_PKTINFO:
		if (val)
			inet->cmsg_flags |= IP_CMSG_PKTINFO;
		else
			inet->cmsg_flags &= ~IP_CMSG_PKTINFO;
		break;
	case IP_RECVTTL:
		if (val)
			inet->cmsg_flags |=  IP_CMSG_TTL;
		else
			inet->cmsg_flags &= ~IP_CMSG_TTL;
		break;
	case IP_RECVTOS:
		if (val)
			inet->cmsg_flags |=  IP_CMSG_TOS;
		else
			inet->cmsg_flags &= ~IP_CMSG_TOS;
		break;
	case IP_RECVOPTS:
		if (val)
			inet->cmsg_flags |=  IP_CMSG_RECVOPTS;
		else
			inet->cmsg_flags &= ~IP_CMSG_RECVOPTS;
		break;
	case IP_RETOPTS:
		if (val)
			inet->cmsg_flags |= IP_CMSG_RETOPTS;
		else
			inet->cmsg_flags &= ~IP_CMSG_RETOPTS;
		break;
	case IP_PASSSEC:
		if (val)
			inet->cmsg_flags |= IP_CMSG_PASSSEC;
		else
			inet->cmsg_flags &= ~IP_CMSG_PASSSEC;
		break;
562 563 564 565 566 567
	case IP_RECVORIGDSTADDR:
		if (val)
			inet->cmsg_flags |= IP_CMSG_ORIGDSTADDR;
		else
			inet->cmsg_flags &= ~IP_CMSG_ORIGDSTADDR;
		break;
S
Stephen Hemminger 已提交
568 569
	case IP_TOS:	/* This sets both TOS and Precedence */
		if (sk->sk_type == SOCK_STREAM) {
570 571
			val &= ~INET_ECN_MASK;
			val |= inet->tos & INET_ECN_MASK;
S
Stephen Hemminger 已提交
572 573 574 575 576 577 578 579
		}
		if (inet->tos != val) {
			inet->tos = val;
			sk->sk_priority = rt_tos2priority(val);
			sk_dst_reset(sk);
		}
		break;
	case IP_TTL:
E
Eric Dumazet 已提交
580
		if (optlen < 1)
S
Stephen Hemminger 已提交
581
			goto e_inval;
E
Eric Dumazet 已提交
582
		if (val != -1 && (val < 0 || val > 255))
S
Stephen Hemminger 已提交
583 584 585 586 587 588
			goto e_inval;
		inet->uc_ttl = val;
		break;
	case IP_HDRINCL:
		if (sk->sk_type != SOCK_RAW) {
			err = -ENOPROTOOPT;
C
Catherine Zhang 已提交
589
			break;
S
Stephen Hemminger 已提交
590 591 592
		}
		inet->hdrincl = val ? 1 : 0;
		break;
593 594 595 596 597 598 599
	case IP_NODEFRAG:
		if (sk->sk_type != SOCK_RAW) {
			err = -ENOPROTOOPT;
			break;
		}
		inet->nodefrag = val ? 1 : 0;
		break;
S
Stephen Hemminger 已提交
600
	case IP_MTU_DISCOVER:
J
John Dykstra 已提交
601
		if (val < IP_PMTUDISC_DONT || val > IP_PMTUDISC_PROBE)
S
Stephen Hemminger 已提交
602 603 604 605 606 607 608 609 610 611 612
			goto e_inval;
		inet->pmtudisc = val;
		break;
	case IP_RECVERR:
		inet->recverr = !!val;
		if (!val)
			skb_queue_purge(&sk->sk_error_queue);
		break;
	case IP_MULTICAST_TTL:
		if (sk->sk_type == SOCK_STREAM)
			goto e_inval;
E
Eric Dumazet 已提交
613
		if (optlen < 1)
S
Stephen Hemminger 已提交
614
			goto e_inval;
615
		if (val == -1)
S
Stephen Hemminger 已提交
616 617 618 619 620 621
			val = 1;
		if (val < 0 || val > 255)
			goto e_inval;
		inet->mc_ttl = val;
		break;
	case IP_MULTICAST_LOOP:
E
Eric Dumazet 已提交
622
		if (optlen < 1)
S
Stephen Hemminger 已提交
623 624 625 626 627 628 629 630 631 632 633 634 635 636
			goto e_inval;
		inet->mc_loop = !!val;
		break;
	case IP_MULTICAST_IF:
	{
		struct ip_mreqn mreq;
		struct net_device *dev = NULL;

		if (sk->sk_type == SOCK_STREAM)
			goto e_inval;
		/*
		 *	Check the arguments are allowable
		 */

637 638 639
		if (optlen < sizeof(struct in_addr))
			goto e_inval;

S
Stephen Hemminger 已提交
640 641
		err = -EFAULT;
		if (optlen >= sizeof(struct ip_mreqn)) {
642
			if (copy_from_user(&mreq, optval, sizeof(mreq)))
L
Linus Torvalds 已提交
643
				break;
S
Stephen Hemminger 已提交
644 645 646
		} else {
			memset(&mreq, 0, sizeof(mreq));
			if (optlen >= sizeof(struct in_addr) &&
E
Eric Dumazet 已提交
647 648
			    copy_from_user(&mreq.imr_address, optval,
					   sizeof(struct in_addr)))
S
Stephen Hemminger 已提交
649 650 651 652
				break;
		}

		if (!mreq.imr_ifindex) {
A
Al Viro 已提交
653
			if (mreq.imr_address.s_addr == htonl(INADDR_ANY)) {
S
Stephen Hemminger 已提交
654 655 656
				inet->mc_index = 0;
				inet->mc_addr  = 0;
				err = 0;
L
Linus Torvalds 已提交
657 658
				break;
			}
659
			dev = ip_dev_find(sock_net(sk), mreq.imr_address.s_addr);
E
Eric Dumazet 已提交
660
			if (dev)
S
Stephen Hemminger 已提交
661 662
				mreq.imr_ifindex = dev->ifindex;
		} else
E
Eric Dumazet 已提交
663
			dev = dev_get_by_index(sock_net(sk), mreq.imr_ifindex);
L
Linus Torvalds 已提交
664 665


S
Stephen Hemminger 已提交
666 667 668
		err = -EADDRNOTAVAIL;
		if (!dev)
			break;
E
Eric Dumazet 已提交
669
		dev_put(dev);
S
Stephen Hemminger 已提交
670 671 672 673 674

		err = -EINVAL;
		if (sk->sk_bound_dev_if &&
		    mreq.imr_ifindex != sk->sk_bound_dev_if)
			break;
L
Linus Torvalds 已提交
675

S
Stephen Hemminger 已提交
676 677 678 679 680
		inet->mc_index = mreq.imr_ifindex;
		inet->mc_addr  = mreq.imr_address.s_addr;
		err = 0;
		break;
	}
L
Linus Torvalds 已提交
681

S
Stephen Hemminger 已提交
682 683 684 685
	case IP_ADD_MEMBERSHIP:
	case IP_DROP_MEMBERSHIP:
	{
		struct ip_mreqn mreq;
L
Linus Torvalds 已提交
686

687 688 689 690
		err = -EPROTO;
		if (inet_sk(sk)->is_icsk)
			break;

S
Stephen Hemminger 已提交
691 692 693 694
		if (optlen < sizeof(struct ip_mreq))
			goto e_inval;
		err = -EFAULT;
		if (optlen >= sizeof(struct ip_mreqn)) {
695
			if (copy_from_user(&mreq, optval, sizeof(mreq)))
L
Linus Torvalds 已提交
696
				break;
S
Stephen Hemminger 已提交
697 698
		} else {
			memset(&mreq, 0, sizeof(mreq));
699
			if (copy_from_user(&mreq, optval, sizeof(struct ip_mreq)))
L
Linus Torvalds 已提交
700
				break;
S
Stephen Hemminger 已提交
701
		}
L
Linus Torvalds 已提交
702

S
Stephen Hemminger 已提交
703 704 705 706 707 708 709 710 711 712 713 714 715 716
		if (optname == IP_ADD_MEMBERSHIP)
			err = ip_mc_join_group(sk, &mreq);
		else
			err = ip_mc_leave_group(sk, &mreq);
		break;
	}
	case IP_MSFILTER:
	{
		struct ip_msfilter *msf;

		if (optlen < IP_MSFILTER_SIZE(0))
			goto e_inval;
		if (optlen > sysctl_optmem_max) {
			err = -ENOBUFS;
L
Linus Torvalds 已提交
717 718
			break;
		}
S
Stephen Hemminger 已提交
719
		msf = kmalloc(optlen, GFP_KERNEL);
S
Stephen Hemminger 已提交
720
		if (!msf) {
S
Stephen Hemminger 已提交
721 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 748 749 750 751
			err = -ENOBUFS;
			break;
		}
		err = -EFAULT;
		if (copy_from_user(msf, optval, optlen)) {
			kfree(msf);
			break;
		}
		/* numsrc >= (1G-4) overflow in 32 bits */
		if (msf->imsf_numsrc >= 0x3ffffffcU ||
		    msf->imsf_numsrc > sysctl_igmp_max_msf) {
			kfree(msf);
			err = -ENOBUFS;
			break;
		}
		if (IP_MSFILTER_SIZE(msf->imsf_numsrc) > optlen) {
			kfree(msf);
			err = -EINVAL;
			break;
		}
		err = ip_mc_msfilter(sk, msf, 0);
		kfree(msf);
		break;
	}
	case IP_BLOCK_SOURCE:
	case IP_UNBLOCK_SOURCE:
	case IP_ADD_SOURCE_MEMBERSHIP:
	case IP_DROP_SOURCE_MEMBERSHIP:
	{
		struct ip_mreq_source mreqs;
		int omode, add;
L
Linus Torvalds 已提交
752

S
Stephen Hemminger 已提交
753 754 755
		if (optlen != sizeof(struct ip_mreq_source))
			goto e_inval;
		if (copy_from_user(&mreqs, optval, sizeof(mreqs))) {
L
Linus Torvalds 已提交
756 757 758
			err = -EFAULT;
			break;
		}
S
Stephen Hemminger 已提交
759 760 761 762 763 764 765 766
		if (optname == IP_BLOCK_SOURCE) {
			omode = MCAST_EXCLUDE;
			add = 1;
		} else if (optname == IP_UNBLOCK_SOURCE) {
			omode = MCAST_EXCLUDE;
			add = 0;
		} else if (optname == IP_ADD_SOURCE_MEMBERSHIP) {
			struct ip_mreqn mreq;
L
Linus Torvalds 已提交
767

S
Stephen Hemminger 已提交
768 769 770 771 772
			mreq.imr_multiaddr.s_addr = mreqs.imr_multiaddr;
			mreq.imr_address.s_addr = mreqs.imr_interface;
			mreq.imr_ifindex = 0;
			err = ip_mc_join_group(sk, &mreq);
			if (err && err != -EADDRINUSE)
L
Linus Torvalds 已提交
773
				break;
S
Stephen Hemminger 已提交
774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820
			omode = MCAST_INCLUDE;
			add = 1;
		} else /* IP_DROP_SOURCE_MEMBERSHIP */ {
			omode = MCAST_INCLUDE;
			add = 0;
		}
		err = ip_mc_source(add, omode, sk, &mreqs, 0);
		break;
	}
	case MCAST_JOIN_GROUP:
	case MCAST_LEAVE_GROUP:
	{
		struct group_req greq;
		struct sockaddr_in *psin;
		struct ip_mreqn mreq;

		if (optlen < sizeof(struct group_req))
			goto e_inval;
		err = -EFAULT;
		if (copy_from_user(&greq, optval, sizeof(greq)))
			break;
		psin = (struct sockaddr_in *)&greq.gr_group;
		if (psin->sin_family != AF_INET)
			goto e_inval;
		memset(&mreq, 0, sizeof(mreq));
		mreq.imr_multiaddr = psin->sin_addr;
		mreq.imr_ifindex = greq.gr_interface;

		if (optname == MCAST_JOIN_GROUP)
			err = ip_mc_join_group(sk, &mreq);
		else
			err = ip_mc_leave_group(sk, &mreq);
		break;
	}
	case MCAST_JOIN_SOURCE_GROUP:
	case MCAST_LEAVE_SOURCE_GROUP:
	case MCAST_BLOCK_SOURCE:
	case MCAST_UNBLOCK_SOURCE:
	{
		struct group_source_req greqs;
		struct ip_mreq_source mreqs;
		struct sockaddr_in *psin;
		int omode, add;

		if (optlen != sizeof(struct group_source_req))
			goto e_inval;
		if (copy_from_user(&greqs, optval, sizeof(greqs))) {
L
Linus Torvalds 已提交
821 822 823
			err = -EFAULT;
			break;
		}
S
Stephen Hemminger 已提交
824 825 826
		if (greqs.gsr_group.ss_family != AF_INET ||
		    greqs.gsr_source.ss_family != AF_INET) {
			err = -EADDRNOTAVAIL;
L
Linus Torvalds 已提交
827 828
			break;
		}
S
Stephen Hemminger 已提交
829 830 831 832 833 834 835 836 837 838 839 840 841
		psin = (struct sockaddr_in *)&greqs.gsr_group;
		mreqs.imr_multiaddr = psin->sin_addr.s_addr;
		psin = (struct sockaddr_in *)&greqs.gsr_source;
		mreqs.imr_sourceaddr = psin->sin_addr.s_addr;
		mreqs.imr_interface = 0; /* use index for mc_source */

		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) {
L
Linus Torvalds 已提交
842 843
			struct ip_mreqn mreq;

S
Stephen Hemminger 已提交
844
			psin = (struct sockaddr_in *)&greqs.gsr_group;
L
Linus Torvalds 已提交
845
			mreq.imr_multiaddr = psin->sin_addr;
S
Stephen Hemminger 已提交
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
			mreq.imr_address.s_addr = 0;
			mreq.imr_ifindex = greqs.gsr_interface;
			err = ip_mc_join_group(sk, &mreq);
			if (err && err != -EADDRINUSE)
				break;
			greqs.gsr_interface = mreq.imr_ifindex;
			omode = MCAST_INCLUDE;
			add = 1;
		} else /* MCAST_LEAVE_SOURCE_GROUP */ {
			omode = MCAST_INCLUDE;
			add = 0;
		}
		err = ip_mc_source(add, omode, sk, &mreqs,
				   greqs.gsr_interface);
		break;
	}
	case MCAST_MSFILTER:
	{
		struct sockaddr_in *psin;
		struct ip_msfilter *msf = NULL;
		struct group_filter *gsf = NULL;
		int msize, i, ifindex;

		if (optlen < GROUP_FILTER_SIZE(0))
			goto e_inval;
		if (optlen > sysctl_optmem_max) {
			err = -ENOBUFS;
L
Linus Torvalds 已提交
873 874
			break;
		}
875
		gsf = kmalloc(optlen, GFP_KERNEL);
S
Stephen Hemminger 已提交
876
		if (!gsf) {
S
Stephen Hemminger 已提交
877
			err = -ENOBUFS;
L
Linus Torvalds 已提交
878 879
			break;
		}
S
Stephen Hemminger 已提交
880
		err = -EFAULT;
E
Eric Dumazet 已提交
881
		if (copy_from_user(gsf, optval, optlen))
S
Stephen Hemminger 已提交
882
			goto mc_msf_out;
E
Eric Dumazet 已提交
883

S
Stephen Hemminger 已提交
884 885 886 887 888 889 890 891 892 893 894
		/* numsrc >= (4G-140)/128 overflow in 32 bits */
		if (gsf->gf_numsrc >= 0x1ffffff ||
		    gsf->gf_numsrc > sysctl_igmp_max_msf) {
			err = -ENOBUFS;
			goto mc_msf_out;
		}
		if (GROUP_FILTER_SIZE(gsf->gf_numsrc) > optlen) {
			err = -EINVAL;
			goto mc_msf_out;
		}
		msize = IP_MSFILTER_SIZE(gsf->gf_numsrc);
895
		msf = kmalloc(msize, GFP_KERNEL);
S
Stephen Hemminger 已提交
896
		if (!msf) {
S
Stephen Hemminger 已提交
897 898 899 900 901 902
			err = -ENOBUFS;
			goto mc_msf_out;
		}
		ifindex = gsf->gf_interface;
		psin = (struct sockaddr_in *)&gsf->gf_group;
		if (psin->sin_family != AF_INET) {
L
Linus Torvalds 已提交
903
			err = -EADDRNOTAVAIL;
S
Stephen Hemminger 已提交
904
			goto mc_msf_out;
L
Linus Torvalds 已提交
905
		}
S
Stephen Hemminger 已提交
906 907 908 909 910
		msf->imsf_multiaddr = psin->sin_addr.s_addr;
		msf->imsf_interface = 0;
		msf->imsf_fmode = gsf->gf_fmode;
		msf->imsf_numsrc = gsf->gf_numsrc;
		err = -EADDRNOTAVAIL;
E
Eric Dumazet 已提交
911
		for (i = 0; i < gsf->gf_numsrc; ++i) {
S
Stephen Hemminger 已提交
912
			psin = (struct sockaddr_in *)&gsf->gf_slist[i];
913

S
Stephen Hemminger 已提交
914 915 916 917 918 919 920 921
			if (psin->sin_family != AF_INET)
				goto mc_msf_out;
			msf->imsf_slist[i] = psin->sin_addr.s_addr;
		}
		kfree(gsf);
		gsf = NULL;

		err = ip_mc_msfilter(sk, msf, ifindex);
E
Eric Dumazet 已提交
922
mc_msf_out:
S
Stephen Hemminger 已提交
923 924 925 926
		kfree(msf);
		kfree(gsf);
		break;
	}
927 928 929 930 931 932 933
	case IP_MULTICAST_ALL:
		if (optlen < 1)
			goto e_inval;
		if (val != 0 && val != 1)
			goto e_inval;
		inet->mc_all = val;
		break;
S
Stephen Hemminger 已提交
934 935 936 937 938
	case IP_ROUTER_ALERT:
		err = ip_ra_control(sk, val ? 1 : 0, NULL);
		break;

	case IP_FREEBIND:
E
Eric Dumazet 已提交
939
		if (optlen < 1)
S
Stephen Hemminger 已提交
940 941 942 943 944 945 946 947
			goto e_inval;
		inet->freebind = !!val;
		break;

	case IP_IPSEC_POLICY:
	case IP_XFRM_POLICY:
		err = -EPERM;
		if (!capable(CAP_NET_ADMIN))
L
Linus Torvalds 已提交
948
			break;
S
Stephen Hemminger 已提交
949 950
		err = xfrm_user_policy(sk, optname, optval, optlen);
		break;
L
Linus Torvalds 已提交
951

952
	case IP_TRANSPARENT:
953
		if (!!val && !capable(CAP_NET_RAW) && !capable(CAP_NET_ADMIN)) {
954 955 956 957 958 959 960 961
			err = -EPERM;
			break;
		}
		if (optlen < 1)
			goto e_inval;
		inet->transparent = !!val;
		break;

962 963 964 965 966 967 968 969
	case IP_MINTTL:
		if (optlen < 1)
			goto e_inval;
		if (val < 0 || val > 255)
			goto e_inval;
		inet->min_ttl = val;
		break;

S
Stephen Hemminger 已提交
970 971 972
	default:
		err = -ENOPROTOOPT;
		break;
L
Linus Torvalds 已提交
973 974 975 976 977 978 979 980 981
	}
	release_sock(sk);
	return err;

e_inval:
	release_sock(sk);
	return -EINVAL;
}

E
Eric Dumazet 已提交
982
/**
983
 * ipv4_pktinfo_prepare - transfert some info from rtable to skb
E
Eric Dumazet 已提交
984 985 986
 * @sk: socket
 * @skb: buffer
 *
987 988 989
 * To support IP_CMSG_PKTINFO option, we store rt_iif and rt_spec_dst
 * in skb->cb[] before dst drop.
 * This way, receiver doesnt make cache line misses to read rtable.
E
Eric Dumazet 已提交
990
 */
991
void ipv4_pktinfo_prepare(struct sk_buff *skb)
E
Eric Dumazet 已提交
992
{
993 994 995 996 997 998 999 1000 1001 1002 1003
	struct in_pktinfo *pktinfo = PKTINFO_SKB_CB(skb);
	const struct rtable *rt = skb_rtable(skb);

	if (rt) {
		pktinfo->ipi_ifindex = rt->rt_iif;
		pktinfo->ipi_spec_dst.s_addr = rt->rt_spec_dst;
	} else {
		pktinfo->ipi_ifindex = 0;
		pktinfo->ipi_spec_dst.s_addr = 0;
	}
	skb_dst_drop(skb);
E
Eric Dumazet 已提交
1004 1005
}

1006
int ip_setsockopt(struct sock *sk, int level,
1007
		int optname, char __user *optval, unsigned int optlen)
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017
{
	int err;

	if (level != SOL_IP)
		return -ENOPROTOOPT;

	err = do_ip_setsockopt(sk, level, optname, optval, optlen);
#ifdef CONFIG_NETFILTER
	/* we need to exclude all possible ENOPROTOOPTs except default case */
	if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
1018 1019 1020
			optname != IP_IPSEC_POLICY &&
			optname != IP_XFRM_POLICY &&
			!ip_mroute_opt(optname)) {
1021 1022 1023 1024 1025 1026 1027
		lock_sock(sk);
		err = nf_setsockopt(sk, PF_INET, optname, optval, optlen);
		release_sock(sk);
	}
#endif
	return err;
}
E
Eric Dumazet 已提交
1028
EXPORT_SYMBOL(ip_setsockopt);
1029 1030

#ifdef CONFIG_COMPAT
1031
int compat_ip_setsockopt(struct sock *sk, int level, int optname,
1032
			 char __user *optval, unsigned int optlen)
1033 1034 1035 1036 1037 1038
{
	int err;

	if (level != SOL_IP)
		return -ENOPROTOOPT;

1039 1040 1041 1042
	if (optname >= MCAST_JOIN_GROUP && optname <= MCAST_MSFILTER)
		return compat_mc_setsockopt(sk, level, optname, optval, optlen,
			ip_setsockopt);

1043 1044 1045 1046
	err = do_ip_setsockopt(sk, level, optname, optval, optlen);
#ifdef CONFIG_NETFILTER
	/* we need to exclude all possible ENOPROTOOPTs except default case */
	if (err == -ENOPROTOOPT && optname != IP_HDRINCL &&
1047 1048 1049
			optname != IP_IPSEC_POLICY &&
			optname != IP_XFRM_POLICY &&
			!ip_mroute_opt(optname)) {
1050
		lock_sock(sk);
1051 1052
		err = compat_nf_setsockopt(sk, PF_INET, optname,
					   optval, optlen);
1053 1054 1055 1056 1057
		release_sock(sk);
	}
#endif
	return err;
}
1058
EXPORT_SYMBOL(compat_ip_setsockopt);
1059 1060
#endif

L
Linus Torvalds 已提交
1061
/*
E
Eric Dumazet 已提交
1062 1063
 *	Get the options. Note for future reference. The GET of IP options gets
 *	the _received_ ones. The set sets the _sent_ ones.
L
Linus Torvalds 已提交
1064 1065
 */

1066
static int do_ip_getsockopt(struct sock *sk, int level, int optname,
1067
			    char __user *optval, int __user *optlen, unsigned flags)
L
Linus Torvalds 已提交
1068 1069 1070 1071
{
	struct inet_sock *inet = inet_sk(sk);
	int val;
	int len;
1072

S
Stephen Hemminger 已提交
1073
	if (level != SOL_IP)
L
Linus Torvalds 已提交
1074 1075
		return -EOPNOTSUPP;

1076
	if (ip_mroute_opt(optname))
1077
		return ip_mroute_getsockopt(sk, optname, optval, optlen);
L
Linus Torvalds 已提交
1078

1079
	if (get_user(len, optlen))
L
Linus Torvalds 已提交
1080
		return -EFAULT;
S
Stephen Hemminger 已提交
1081
	if (len < 0)
L
Linus Torvalds 已提交
1082
		return -EINVAL;
1083

L
Linus Torvalds 已提交
1084 1085
	lock_sock(sk);

S
Stephen Hemminger 已提交
1086 1087 1088 1089
	switch (optname) {
	case IP_OPTIONS:
	{
		unsigned char optbuf[sizeof(struct ip_options)+40];
1090 1091 1092 1093 1094
		struct ip_options *opt = (struct ip_options *)optbuf;
		struct ip_options_rcu *inet_opt;

		inet_opt = rcu_dereference_protected(inet->inet_opt,
						     sock_owned_by_user(sk));
S
Stephen Hemminger 已提交
1095
		opt->optlen = 0;
1096 1097 1098 1099
		if (inet_opt)
			memcpy(optbuf, &inet_opt->opt,
			       sizeof(struct ip_options) +
			       inet_opt->opt.optlen);
S
Stephen Hemminger 已提交
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
		release_sock(sk);

		if (opt->optlen == 0)
			return put_user(0, optlen);

		ip_options_undo(opt);

		len = min_t(unsigned int, len, opt->optlen);
		if (put_user(len, optlen))
			return -EFAULT;
		if (copy_to_user(optval, opt->__data, len))
			return -EFAULT;
		return 0;
	}
	case IP_PKTINFO:
		val = (inet->cmsg_flags & IP_CMSG_PKTINFO) != 0;
		break;
	case IP_RECVTTL:
		val = (inet->cmsg_flags & IP_CMSG_TTL) != 0;
		break;
	case IP_RECVTOS:
		val = (inet->cmsg_flags & IP_CMSG_TOS) != 0;
		break;
	case IP_RECVOPTS:
		val = (inet->cmsg_flags & IP_CMSG_RECVOPTS) != 0;
		break;
	case IP_RETOPTS:
		val = (inet->cmsg_flags & IP_CMSG_RETOPTS) != 0;
		break;
	case IP_PASSSEC:
		val = (inet->cmsg_flags & IP_CMSG_PASSSEC) != 0;
		break;
1132 1133 1134
	case IP_RECVORIGDSTADDR:
		val = (inet->cmsg_flags & IP_CMSG_ORIGDSTADDR) != 0;
		break;
S
Stephen Hemminger 已提交
1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145
	case IP_TOS:
		val = inet->tos;
		break;
	case IP_TTL:
		val = (inet->uc_ttl == -1 ?
		       sysctl_ip_default_ttl :
		       inet->uc_ttl);
		break;
	case IP_HDRINCL:
		val = inet->hdrincl;
		break;
1146 1147 1148
	case IP_NODEFRAG:
		val = inet->nodefrag;
		break;
S
Stephen Hemminger 已提交
1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159
	case IP_MTU_DISCOVER:
		val = inet->pmtudisc;
		break;
	case IP_MTU:
	{
		struct dst_entry *dst;
		val = 0;
		dst = sk_dst_get(sk);
		if (dst) {
			val = dst_mtu(dst);
			dst_release(dst);
L
Linus Torvalds 已提交
1160
		}
S
Stephen Hemminger 已提交
1161
		if (!val) {
L
Linus Torvalds 已提交
1162
			release_sock(sk);
S
Stephen Hemminger 已提交
1163
			return -ENOTCONN;
L
Linus Torvalds 已提交
1164
		}
S
Stephen Hemminger 已提交
1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
		break;
	}
	case IP_RECVERR:
		val = inet->recverr;
		break;
	case IP_MULTICAST_TTL:
		val = inet->mc_ttl;
		break;
	case IP_MULTICAST_LOOP:
		val = inet->mc_loop;
		break;
	case IP_MULTICAST_IF:
	{
		struct in_addr addr;
		len = min_t(unsigned int, len, sizeof(struct in_addr));
		addr.s_addr = inet->mc_addr;
		release_sock(sk);
L
Linus Torvalds 已提交
1182

S
Stephen Hemminger 已提交
1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194
		if (put_user(len, optlen))
			return -EFAULT;
		if (copy_to_user(optval, &addr, len))
			return -EFAULT;
		return 0;
	}
	case IP_MSFILTER:
	{
		struct ip_msfilter msf;
		int err;

		if (len < IP_MSFILTER_SIZE(0)) {
L
Linus Torvalds 已提交
1195
			release_sock(sk);
S
Stephen Hemminger 已提交
1196
			return -EINVAL;
L
Linus Torvalds 已提交
1197
		}
S
Stephen Hemminger 已提交
1198
		if (copy_from_user(&msf, optval, IP_MSFILTER_SIZE(0))) {
L
Linus Torvalds 已提交
1199
			release_sock(sk);
S
Stephen Hemminger 已提交
1200
			return -EFAULT;
L
Linus Torvalds 已提交
1201
		}
S
Stephen Hemminger 已提交
1202 1203 1204 1205 1206 1207 1208 1209 1210
		err = ip_mc_msfget(sk, &msf,
				   (struct ip_msfilter __user *)optval, optlen);
		release_sock(sk);
		return err;
	}
	case MCAST_MSFILTER:
	{
		struct group_filter gsf;
		int err;
L
Linus Torvalds 已提交
1211

S
Stephen Hemminger 已提交
1212
		if (len < GROUP_FILTER_SIZE(0)) {
L
Linus Torvalds 已提交
1213
			release_sock(sk);
S
Stephen Hemminger 已提交
1214 1215 1216 1217 1218 1219 1220
			return -EINVAL;
		}
		if (copy_from_user(&gsf, optval, GROUP_FILTER_SIZE(0))) {
			release_sock(sk);
			return -EFAULT;
		}
		err = ip_mc_gsfget(sk, &gsf,
E
Eric Dumazet 已提交
1221 1222
				   (struct group_filter __user *)optval,
				   optlen);
S
Stephen Hemminger 已提交
1223 1224 1225
		release_sock(sk);
		return err;
	}
1226 1227 1228
	case IP_MULTICAST_ALL:
		val = inet->mc_all;
		break;
S
Stephen Hemminger 已提交
1229 1230 1231
	case IP_PKTOPTIONS:
	{
		struct msghdr msg;
L
Linus Torvalds 已提交
1232

S
Stephen Hemminger 已提交
1233
		release_sock(sk);
L
Linus Torvalds 已提交
1234

S
Stephen Hemminger 已提交
1235 1236
		if (sk->sk_type != SOCK_STREAM)
			return -ENOPROTOOPT;
L
Linus Torvalds 已提交
1237

S
Stephen Hemminger 已提交
1238 1239
		msg.msg_control = optval;
		msg.msg_controllen = len;
1240
		msg.msg_flags = flags;
L
Linus Torvalds 已提交
1241

S
Stephen Hemminger 已提交
1242 1243 1244
		if (inet->cmsg_flags & IP_CMSG_PKTINFO) {
			struct in_pktinfo info;

E
Eric Dumazet 已提交
1245 1246
			info.ipi_addr.s_addr = inet->inet_rcv_saddr;
			info.ipi_spec_dst.s_addr = inet->inet_rcv_saddr;
S
Stephen Hemminger 已提交
1247 1248
			info.ipi_ifindex = inet->mc_index;
			put_cmsg(&msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
L
Linus Torvalds 已提交
1249
		}
S
Stephen Hemminger 已提交
1250 1251 1252 1253 1254 1255 1256 1257 1258 1259
		if (inet->cmsg_flags & IP_CMSG_TTL) {
			int hlim = inet->mc_ttl;
			put_cmsg(&msg, SOL_IP, IP_TTL, sizeof(hlim), &hlim);
		}
		len -= msg.msg_controllen;
		return put_user(len, optlen);
	}
	case IP_FREEBIND:
		val = inet->freebind;
		break;
1260 1261 1262
	case IP_TRANSPARENT:
		val = inet->transparent;
		break;
1263 1264 1265
	case IP_MINTTL:
		val = inet->min_ttl;
		break;
S
Stephen Hemminger 已提交
1266 1267 1268
	default:
		release_sock(sk);
		return -ENOPROTOOPT;
L
Linus Torvalds 已提交
1269 1270
	}
	release_sock(sk);
1271

E
Eric Dumazet 已提交
1272
	if (len < sizeof(int) && len > 0 && val >= 0 && val <= 255) {
L
Linus Torvalds 已提交
1273 1274
		unsigned char ucval = (unsigned char)val;
		len = 1;
S
Stephen Hemminger 已提交
1275
		if (put_user(len, optlen))
L
Linus Torvalds 已提交
1276
			return -EFAULT;
1277
		if (copy_to_user(optval, &ucval, 1))
L
Linus Torvalds 已提交
1278 1279 1280
			return -EFAULT;
	} else {
		len = min_t(unsigned int, sizeof(int), len);
S
Stephen Hemminger 已提交
1281
		if (put_user(len, optlen))
L
Linus Torvalds 已提交
1282
			return -EFAULT;
1283
		if (copy_to_user(optval, &val, len))
L
Linus Torvalds 已提交
1284 1285 1286 1287 1288
			return -EFAULT;
	}
	return 0;
}

1289
int ip_getsockopt(struct sock *sk, int level,
S
Stephen Hemminger 已提交
1290
		  int optname, char __user *optval, int __user *optlen)
1291 1292 1293
{
	int err;

1294
	err = do_ip_getsockopt(sk, level, optname, optval, optlen, 0);
1295 1296
#ifdef CONFIG_NETFILTER
	/* we need to exclude all possible ENOPROTOOPTs except default case */
1297 1298
	if (err == -ENOPROTOOPT && optname != IP_PKTOPTIONS &&
			!ip_mroute_opt(optname)) {
1299
		int len;
1300

1301
		if (get_user(len, optlen))
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314
			return -EFAULT;

		lock_sock(sk);
		err = nf_getsockopt(sk, PF_INET, optname, optval,
				&len);
		release_sock(sk);
		if (err >= 0)
			err = put_user(len, optlen);
		return err;
	}
#endif
	return err;
}
E
Eric Dumazet 已提交
1315
EXPORT_SYMBOL(ip_getsockopt);
1316 1317

#ifdef CONFIG_COMPAT
1318 1319
int compat_ip_getsockopt(struct sock *sk, int level, int optname,
			 char __user *optval, int __user *optlen)
1320
{
1321 1322 1323 1324 1325 1326
	int err;

	if (optname == MCAST_MSFILTER)
		return compat_mc_getsockopt(sk, level, optname, optval, optlen,
			ip_getsockopt);

1327 1328
	err = do_ip_getsockopt(sk, level, optname, optval, optlen,
		MSG_CMSG_COMPAT);
1329

1330 1331
#ifdef CONFIG_NETFILTER
	/* we need to exclude all possible ENOPROTOOPTs except default case */
1332 1333
	if (err == -ENOPROTOOPT && optname != IP_PKTOPTIONS &&
			!ip_mroute_opt(optname)) {
1334
		int len;
1335

1336
		if (get_user(len, optlen))
1337 1338 1339
			return -EFAULT;

		lock_sock(sk);
1340
		err = compat_nf_getsockopt(sk, PF_INET, optname, optval, &len);
1341 1342 1343 1344 1345 1346 1347 1348
		release_sock(sk);
		if (err >= 0)
			err = put_user(len, optlen);
		return err;
	}
#endif
	return err;
}
1349
EXPORT_SYMBOL(compat_ip_getsockopt);
1350
#endif