ip_sockglue.c 31.2 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];
D
Daniel Baluta 已提交
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))) ||
467
	    optname == IP_UNICAST_IF ||
S
Stephen Hemminger 已提交
468
	    optname == IP_MULTICAST_TTL ||
469
	    optname == IP_MULTICAST_ALL ||
470 471
	    optname == IP_MULTICAST_LOOP ||
	    optname == IP_RECVORIGDSTADDR) {
L
Linus Torvalds 已提交
472 473 474 475 476 477 478 479 480 481 482 483 484 485
		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 */

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

	err = 0;
	lock_sock(sk);

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

497
		if (optlen > 40)
S
Stephen Hemminger 已提交
498
			goto e_inval;
499
		err = ip_options_get_from_user(sock_net(sk), &opt,
500
					       optval, optlen);
S
Stephen Hemminger 已提交
501 502
		if (err)
			break;
503 504
		old = rcu_dereference_protected(inet->inet_opt,
						sock_owned_by_user(sk));
S
Stephen Hemminger 已提交
505 506
		if (inet->is_icsk) {
			struct inet_connection_sock *icsk = inet_csk(sk);
E
Eric Dumazet 已提交
507
#if IS_ENABLED(CONFIG_IPV6)
S
Stephen Hemminger 已提交
508 509 510
			if (sk->sk_family == PF_INET ||
			    (!((1 << sk->sk_state) &
			       (TCPF_LISTEN | TCPF_CLOSE)) &&
E
Eric Dumazet 已提交
511
			     inet->inet_daddr != LOOPBACK4_IPV6)) {
L
Linus Torvalds 已提交
512
#endif
513 514
				if (old)
					icsk->icsk_ext_hdr_len -= old->opt.optlen;
S
Stephen Hemminger 已提交
515
				if (opt)
516
					icsk->icsk_ext_hdr_len += opt->opt.optlen;
S
Stephen Hemminger 已提交
517
				icsk->icsk_sync_mss(sk, icsk->icsk_pmtu_cookie);
E
Eric Dumazet 已提交
518
#if IS_ENABLED(CONFIG_IPV6)
L
Linus Torvalds 已提交
519
			}
S
Stephen Hemminger 已提交
520
#endif
L
Linus Torvalds 已提交
521
		}
522 523
		rcu_assign_pointer(inet->inet_opt, opt);
		if (old)
524
			kfree_rcu(old, rcu);
S
Stephen Hemminger 已提交
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 562
		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;
563 564 565 566 567 568
	case IP_RECVORIGDSTADDR:
		if (val)
			inet->cmsg_flags |= IP_CMSG_ORIGDSTADDR;
		else
			inet->cmsg_flags &= ~IP_CMSG_ORIGDSTADDR;
		break;
S
Stephen Hemminger 已提交
569 570
	case IP_TOS:	/* This sets both TOS and Precedence */
		if (sk->sk_type == SOCK_STREAM) {
571 572
			val &= ~INET_ECN_MASK;
			val |= inet->tos & INET_ECN_MASK;
S
Stephen Hemminger 已提交
573 574 575 576 577 578 579 580
		}
		if (inet->tos != val) {
			inet->tos = val;
			sk->sk_priority = rt_tos2priority(val);
			sk_dst_reset(sk);
		}
		break;
	case IP_TTL:
E
Eric Dumazet 已提交
581
		if (optlen < 1)
S
Stephen Hemminger 已提交
582
			goto e_inval;
E
Eric Dumazet 已提交
583
		if (val != -1 && (val < 0 || val > 255))
S
Stephen Hemminger 已提交
584 585 586 587 588 589
			goto e_inval;
		inet->uc_ttl = val;
		break;
	case IP_HDRINCL:
		if (sk->sk_type != SOCK_RAW) {
			err = -ENOPROTOOPT;
C
Catherine Zhang 已提交
590
			break;
S
Stephen Hemminger 已提交
591 592 593
		}
		inet->hdrincl = val ? 1 : 0;
		break;
594 595 596 597 598 599 600
	case IP_NODEFRAG:
		if (sk->sk_type != SOCK_RAW) {
			err = -ENOPROTOOPT;
			break;
		}
		inet->nodefrag = val ? 1 : 0;
		break;
S
Stephen Hemminger 已提交
601
	case IP_MTU_DISCOVER:
J
John Dykstra 已提交
602
		if (val < IP_PMTUDISC_DONT || val > IP_PMTUDISC_PROBE)
S
Stephen Hemminger 已提交
603 604 605 606 607 608 609 610 611 612 613
			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 已提交
614
		if (optlen < 1)
S
Stephen Hemminger 已提交
615
			goto e_inval;
616
		if (val == -1)
S
Stephen Hemminger 已提交
617 618 619 620 621 622
			val = 1;
		if (val < 0 || val > 255)
			goto e_inval;
		inet->mc_ttl = val;
		break;
	case IP_MULTICAST_LOOP:
E
Eric Dumazet 已提交
623
		if (optlen < 1)
S
Stephen Hemminger 已提交
624 625 626
			goto e_inval;
		inet->mc_loop = !!val;
		break;
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
	case IP_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) {
			inet->uc_index = 0;
			err = 0;
			break;
		}

		dev = dev_get_by_index(sock_net(sk), ifindex);
		err = -EADDRNOTAVAIL;
		if (!dev)
			break;
		dev_put(dev);

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

		inet->uc_index = ifindex;
		err = 0;
		break;
	}
S
Stephen Hemminger 已提交
656 657 658 659 660 661 662 663 664 665 666
	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
		 */

667 668 669
		if (optlen < sizeof(struct in_addr))
			goto e_inval;

S
Stephen Hemminger 已提交
670 671
		err = -EFAULT;
		if (optlen >= sizeof(struct ip_mreqn)) {
672
			if (copy_from_user(&mreq, optval, sizeof(mreq)))
L
Linus Torvalds 已提交
673
				break;
S
Stephen Hemminger 已提交
674 675 676
		} else {
			memset(&mreq, 0, sizeof(mreq));
			if (optlen >= sizeof(struct in_addr) &&
E
Eric Dumazet 已提交
677 678
			    copy_from_user(&mreq.imr_address, optval,
					   sizeof(struct in_addr)))
S
Stephen Hemminger 已提交
679 680 681 682
				break;
		}

		if (!mreq.imr_ifindex) {
A
Al Viro 已提交
683
			if (mreq.imr_address.s_addr == htonl(INADDR_ANY)) {
S
Stephen Hemminger 已提交
684 685 686
				inet->mc_index = 0;
				inet->mc_addr  = 0;
				err = 0;
L
Linus Torvalds 已提交
687 688
				break;
			}
689
			dev = ip_dev_find(sock_net(sk), mreq.imr_address.s_addr);
E
Eric Dumazet 已提交
690
			if (dev)
S
Stephen Hemminger 已提交
691 692
				mreq.imr_ifindex = dev->ifindex;
		} else
E
Eric Dumazet 已提交
693
			dev = dev_get_by_index(sock_net(sk), mreq.imr_ifindex);
L
Linus Torvalds 已提交
694 695


S
Stephen Hemminger 已提交
696 697 698
		err = -EADDRNOTAVAIL;
		if (!dev)
			break;
E
Eric Dumazet 已提交
699
		dev_put(dev);
S
Stephen Hemminger 已提交
700 701 702 703 704

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

S
Stephen Hemminger 已提交
706 707 708 709 710
		inet->mc_index = mreq.imr_ifindex;
		inet->mc_addr  = mreq.imr_address.s_addr;
		err = 0;
		break;
	}
L
Linus Torvalds 已提交
711

S
Stephen Hemminger 已提交
712 713 714 715
	case IP_ADD_MEMBERSHIP:
	case IP_DROP_MEMBERSHIP:
	{
		struct ip_mreqn mreq;
L
Linus Torvalds 已提交
716

717 718 719 720
		err = -EPROTO;
		if (inet_sk(sk)->is_icsk)
			break;

S
Stephen Hemminger 已提交
721 722 723 724
		if (optlen < sizeof(struct ip_mreq))
			goto e_inval;
		err = -EFAULT;
		if (optlen >= sizeof(struct ip_mreqn)) {
725
			if (copy_from_user(&mreq, optval, sizeof(mreq)))
L
Linus Torvalds 已提交
726
				break;
S
Stephen Hemminger 已提交
727 728
		} else {
			memset(&mreq, 0, sizeof(mreq));
729
			if (copy_from_user(&mreq, optval, sizeof(struct ip_mreq)))
L
Linus Torvalds 已提交
730
				break;
S
Stephen Hemminger 已提交
731
		}
L
Linus Torvalds 已提交
732

S
Stephen Hemminger 已提交
733 734 735 736 737 738 739 740 741 742 743 744 745 746
		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 已提交
747 748
			break;
		}
S
Stephen Hemminger 已提交
749
		msf = kmalloc(optlen, GFP_KERNEL);
S
Stephen Hemminger 已提交
750
		if (!msf) {
S
Stephen Hemminger 已提交
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781
			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 已提交
782

S
Stephen Hemminger 已提交
783 784 785
		if (optlen != sizeof(struct ip_mreq_source))
			goto e_inval;
		if (copy_from_user(&mreqs, optval, sizeof(mreqs))) {
L
Linus Torvalds 已提交
786 787 788
			err = -EFAULT;
			break;
		}
S
Stephen Hemminger 已提交
789 790 791 792 793 794 795 796
		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 已提交
797

S
Stephen Hemminger 已提交
798 799 800 801 802
			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 已提交
803
				break;
S
Stephen Hemminger 已提交
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
			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 已提交
851 852 853
			err = -EFAULT;
			break;
		}
S
Stephen Hemminger 已提交
854 855 856
		if (greqs.gsr_group.ss_family != AF_INET ||
		    greqs.gsr_source.ss_family != AF_INET) {
			err = -EADDRNOTAVAIL;
L
Linus Torvalds 已提交
857 858
			break;
		}
S
Stephen Hemminger 已提交
859 860 861 862 863 864 865 866 867 868 869 870 871
		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 已提交
872 873
			struct ip_mreqn mreq;

S
Stephen Hemminger 已提交
874
			psin = (struct sockaddr_in *)&greqs.gsr_group;
L
Linus Torvalds 已提交
875
			mreq.imr_multiaddr = psin->sin_addr;
S
Stephen Hemminger 已提交
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902
			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 已提交
903 904
			break;
		}
905
		gsf = kmalloc(optlen, GFP_KERNEL);
S
Stephen Hemminger 已提交
906
		if (!gsf) {
S
Stephen Hemminger 已提交
907
			err = -ENOBUFS;
L
Linus Torvalds 已提交
908 909
			break;
		}
S
Stephen Hemminger 已提交
910
		err = -EFAULT;
E
Eric Dumazet 已提交
911
		if (copy_from_user(gsf, optval, optlen))
S
Stephen Hemminger 已提交
912
			goto mc_msf_out;
E
Eric Dumazet 已提交
913

S
Stephen Hemminger 已提交
914 915 916 917 918 919 920 921 922 923 924
		/* 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);
925
		msf = kmalloc(msize, GFP_KERNEL);
S
Stephen Hemminger 已提交
926
		if (!msf) {
S
Stephen Hemminger 已提交
927 928 929 930 931 932
			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 已提交
933
			err = -EADDRNOTAVAIL;
S
Stephen Hemminger 已提交
934
			goto mc_msf_out;
L
Linus Torvalds 已提交
935
		}
S
Stephen Hemminger 已提交
936 937 938 939 940
		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 已提交
941
		for (i = 0; i < gsf->gf_numsrc; ++i) {
S
Stephen Hemminger 已提交
942
			psin = (struct sockaddr_in *)&gsf->gf_slist[i];
943

S
Stephen Hemminger 已提交
944 945 946 947 948 949 950 951
			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 已提交
952
mc_msf_out:
S
Stephen Hemminger 已提交
953 954 955 956
		kfree(msf);
		kfree(gsf);
		break;
	}
957 958 959 960 961 962 963
	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 已提交
964 965 966 967 968
	case IP_ROUTER_ALERT:
		err = ip_ra_control(sk, val ? 1 : 0, NULL);
		break;

	case IP_FREEBIND:
E
Eric Dumazet 已提交
969
		if (optlen < 1)
S
Stephen Hemminger 已提交
970 971 972 973 974 975 976 977
			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 已提交
978
			break;
S
Stephen Hemminger 已提交
979 980
		err = xfrm_user_policy(sk, optname, optval, optlen);
		break;
L
Linus Torvalds 已提交
981

982
	case IP_TRANSPARENT:
983
		if (!!val && !capable(CAP_NET_RAW) && !capable(CAP_NET_ADMIN)) {
984 985 986 987 988 989 990 991
			err = -EPERM;
			break;
		}
		if (optlen < 1)
			goto e_inval;
		inet->transparent = !!val;
		break;

992 993 994 995 996 997 998 999
	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 已提交
1000 1001 1002
	default:
		err = -ENOPROTOOPT;
		break;
L
Linus Torvalds 已提交
1003 1004 1005 1006 1007 1008 1009 1010 1011
	}
	release_sock(sk);
	return err;

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

E
Eric Dumazet 已提交
1012
/**
1013
 * ipv4_pktinfo_prepare - transfert some info from rtable to skb
E
Eric Dumazet 已提交
1014 1015 1016
 * @sk: socket
 * @skb: buffer
 *
1017 1018 1019
 * 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 已提交
1020
 */
1021
void ipv4_pktinfo_prepare(struct sk_buff *skb)
E
Eric Dumazet 已提交
1022
{
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
	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 已提交
1034 1035
}

1036
int ip_setsockopt(struct sock *sk, int level,
1037
		int optname, char __user *optval, unsigned int optlen)
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
{
	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 &&
1048 1049 1050
			optname != IP_IPSEC_POLICY &&
			optname != IP_XFRM_POLICY &&
			!ip_mroute_opt(optname)) {
1051 1052 1053 1054 1055 1056 1057
		lock_sock(sk);
		err = nf_setsockopt(sk, PF_INET, optname, optval, optlen);
		release_sock(sk);
	}
#endif
	return err;
}
E
Eric Dumazet 已提交
1058
EXPORT_SYMBOL(ip_setsockopt);
1059 1060

#ifdef CONFIG_COMPAT
1061
int compat_ip_setsockopt(struct sock *sk, int level, int optname,
1062
			 char __user *optval, unsigned int optlen)
1063 1064 1065 1066 1067 1068
{
	int err;

	if (level != SOL_IP)
		return -ENOPROTOOPT;

1069 1070 1071 1072
	if (optname >= MCAST_JOIN_GROUP && optname <= MCAST_MSFILTER)
		return compat_mc_setsockopt(sk, level, optname, optval, optlen,
			ip_setsockopt);

1073 1074 1075 1076
	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 &&
1077 1078 1079
			optname != IP_IPSEC_POLICY &&
			optname != IP_XFRM_POLICY &&
			!ip_mroute_opt(optname)) {
1080
		lock_sock(sk);
1081 1082
		err = compat_nf_setsockopt(sk, PF_INET, optname,
					   optval, optlen);
1083 1084 1085 1086 1087
		release_sock(sk);
	}
#endif
	return err;
}
1088
EXPORT_SYMBOL(compat_ip_setsockopt);
1089 1090
#endif

L
Linus Torvalds 已提交
1091
/*
E
Eric Dumazet 已提交
1092 1093
 *	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 已提交
1094 1095
 */

1096
static int do_ip_getsockopt(struct sock *sk, int level, int optname,
1097
			    char __user *optval, int __user *optlen, unsigned flags)
L
Linus Torvalds 已提交
1098 1099 1100 1101
{
	struct inet_sock *inet = inet_sk(sk);
	int val;
	int len;
1102

S
Stephen Hemminger 已提交
1103
	if (level != SOL_IP)
L
Linus Torvalds 已提交
1104 1105
		return -EOPNOTSUPP;

1106
	if (ip_mroute_opt(optname))
1107
		return ip_mroute_getsockopt(sk, optname, optval, optlen);
L
Linus Torvalds 已提交
1108

1109
	if (get_user(len, optlen))
L
Linus Torvalds 已提交
1110
		return -EFAULT;
S
Stephen Hemminger 已提交
1111
	if (len < 0)
L
Linus Torvalds 已提交
1112
		return -EINVAL;
1113

L
Linus Torvalds 已提交
1114 1115
	lock_sock(sk);

S
Stephen Hemminger 已提交
1116 1117 1118 1119
	switch (optname) {
	case IP_OPTIONS:
	{
		unsigned char optbuf[sizeof(struct ip_options)+40];
1120 1121 1122 1123 1124
		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 已提交
1125
		opt->optlen = 0;
1126 1127 1128 1129
		if (inet_opt)
			memcpy(optbuf, &inet_opt->opt,
			       sizeof(struct ip_options) +
			       inet_opt->opt.optlen);
S
Stephen Hemminger 已提交
1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
		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;
1162 1163 1164
	case IP_RECVORIGDSTADDR:
		val = (inet->cmsg_flags & IP_CMSG_ORIGDSTADDR) != 0;
		break;
S
Stephen Hemminger 已提交
1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
	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;
1176 1177 1178
	case IP_NODEFRAG:
		val = inet->nodefrag;
		break;
S
Stephen Hemminger 已提交
1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
	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 已提交
1190
		}
S
Stephen Hemminger 已提交
1191
		if (!val) {
L
Linus Torvalds 已提交
1192
			release_sock(sk);
S
Stephen Hemminger 已提交
1193
			return -ENOTCONN;
L
Linus Torvalds 已提交
1194
		}
S
Stephen Hemminger 已提交
1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
		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;
1206 1207 1208
	case IP_UNICAST_IF:
		val = (__force int)htonl((__u32) inet->uc_index);
		break;
S
Stephen Hemminger 已提交
1209 1210 1211 1212 1213 1214
	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 已提交
1215

S
Stephen Hemminger 已提交
1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227
		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 已提交
1228
			release_sock(sk);
S
Stephen Hemminger 已提交
1229
			return -EINVAL;
L
Linus Torvalds 已提交
1230
		}
S
Stephen Hemminger 已提交
1231
		if (copy_from_user(&msf, optval, IP_MSFILTER_SIZE(0))) {
L
Linus Torvalds 已提交
1232
			release_sock(sk);
S
Stephen Hemminger 已提交
1233
			return -EFAULT;
L
Linus Torvalds 已提交
1234
		}
S
Stephen Hemminger 已提交
1235 1236 1237 1238 1239 1240 1241 1242 1243
		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 已提交
1244

S
Stephen Hemminger 已提交
1245
		if (len < GROUP_FILTER_SIZE(0)) {
L
Linus Torvalds 已提交
1246
			release_sock(sk);
S
Stephen Hemminger 已提交
1247 1248 1249 1250 1251 1252 1253
			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 已提交
1254 1255
				   (struct group_filter __user *)optval,
				   optlen);
S
Stephen Hemminger 已提交
1256 1257 1258
		release_sock(sk);
		return err;
	}
1259 1260 1261
	case IP_MULTICAST_ALL:
		val = inet->mc_all;
		break;
S
Stephen Hemminger 已提交
1262 1263 1264
	case IP_PKTOPTIONS:
	{
		struct msghdr msg;
L
Linus Torvalds 已提交
1265

S
Stephen Hemminger 已提交
1266
		release_sock(sk);
L
Linus Torvalds 已提交
1267

S
Stephen Hemminger 已提交
1268 1269
		if (sk->sk_type != SOCK_STREAM)
			return -ENOPROTOOPT;
L
Linus Torvalds 已提交
1270

S
Stephen Hemminger 已提交
1271 1272
		msg.msg_control = optval;
		msg.msg_controllen = len;
1273
		msg.msg_flags = flags;
L
Linus Torvalds 已提交
1274

S
Stephen Hemminger 已提交
1275 1276 1277
		if (inet->cmsg_flags & IP_CMSG_PKTINFO) {
			struct in_pktinfo info;

E
Eric Dumazet 已提交
1278 1279
			info.ipi_addr.s_addr = inet->inet_rcv_saddr;
			info.ipi_spec_dst.s_addr = inet->inet_rcv_saddr;
S
Stephen Hemminger 已提交
1280 1281
			info.ipi_ifindex = inet->mc_index;
			put_cmsg(&msg, SOL_IP, IP_PKTINFO, sizeof(info), &info);
L
Linus Torvalds 已提交
1282
		}
S
Stephen Hemminger 已提交
1283 1284 1285 1286
		if (inet->cmsg_flags & IP_CMSG_TTL) {
			int hlim = inet->mc_ttl;
			put_cmsg(&msg, SOL_IP, IP_TTL, sizeof(hlim), &hlim);
		}
1287 1288 1289 1290
		if (inet->cmsg_flags & IP_CMSG_TOS) {
			int tos = inet->rcv_tos;
			put_cmsg(&msg, SOL_IP, IP_TOS, sizeof(tos), &tos);
		}
S
Stephen Hemminger 已提交
1291 1292 1293 1294 1295 1296
		len -= msg.msg_controllen;
		return put_user(len, optlen);
	}
	case IP_FREEBIND:
		val = inet->freebind;
		break;
1297 1298 1299
	case IP_TRANSPARENT:
		val = inet->transparent;
		break;
1300 1301 1302
	case IP_MINTTL:
		val = inet->min_ttl;
		break;
S
Stephen Hemminger 已提交
1303 1304 1305
	default:
		release_sock(sk);
		return -ENOPROTOOPT;
L
Linus Torvalds 已提交
1306 1307
	}
	release_sock(sk);
1308

E
Eric Dumazet 已提交
1309
	if (len < sizeof(int) && len > 0 && val >= 0 && val <= 255) {
L
Linus Torvalds 已提交
1310 1311
		unsigned char ucval = (unsigned char)val;
		len = 1;
S
Stephen Hemminger 已提交
1312
		if (put_user(len, optlen))
L
Linus Torvalds 已提交
1313
			return -EFAULT;
1314
		if (copy_to_user(optval, &ucval, 1))
L
Linus Torvalds 已提交
1315 1316 1317
			return -EFAULT;
	} else {
		len = min_t(unsigned int, sizeof(int), len);
S
Stephen Hemminger 已提交
1318
		if (put_user(len, optlen))
L
Linus Torvalds 已提交
1319
			return -EFAULT;
1320
		if (copy_to_user(optval, &val, len))
L
Linus Torvalds 已提交
1321 1322 1323 1324 1325
			return -EFAULT;
	}
	return 0;
}

1326
int ip_getsockopt(struct sock *sk, int level,
S
Stephen Hemminger 已提交
1327
		  int optname, char __user *optval, int __user *optlen)
1328 1329 1330
{
	int err;

1331
	err = do_ip_getsockopt(sk, level, optname, optval, optlen, 0);
1332 1333
#ifdef CONFIG_NETFILTER
	/* we need to exclude all possible ENOPROTOOPTs except default case */
1334 1335
	if (err == -ENOPROTOOPT && optname != IP_PKTOPTIONS &&
			!ip_mroute_opt(optname)) {
1336
		int len;
1337

1338
		if (get_user(len, optlen))
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
			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 已提交
1352
EXPORT_SYMBOL(ip_getsockopt);
1353 1354

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

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

1364 1365
	err = do_ip_getsockopt(sk, level, optname, optval, optlen,
		MSG_CMSG_COMPAT);
1366

1367 1368
#ifdef CONFIG_NETFILTER
	/* we need to exclude all possible ENOPROTOOPTs except default case */
1369 1370
	if (err == -ENOPROTOOPT && optname != IP_PKTOPTIONS &&
			!ip_mroute_opt(optname)) {
1371
		int len;
1372

1373
		if (get_user(len, optlen))
1374 1375 1376
			return -EFAULT;

		lock_sock(sk);
1377
		err = compat_nf_getsockopt(sk, PF_INET, optname, optval, &len);
1378 1379 1380 1381 1382 1383 1384 1385
		release_sock(sk);
		if (err >= 0)
			err = put_user(len, optlen);
		return err;
	}
#endif
	return err;
}
1386
EXPORT_SYMBOL(compat_ip_getsockopt);
1387
#endif