raw.c 23.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9
/*
 * 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.
 *
 *		RAW - implementation of IP "raw" sockets.
 *
 * Version:	$Id: raw.c,v 1.64 2002/02/01 22:01:04 davem Exp $
 *
10
 * Authors:	Ross Biro
L
Linus Torvalds 已提交
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
 *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
 *
 * Fixes:
 *		Alan Cox	:	verify_area() fixed up
 *		Alan Cox	:	ICMP error handling
 *		Alan Cox	:	EMSGSIZE if you send too big a packet
 *		Alan Cox	: 	Now uses generic datagrams and shared
 *					skbuff library. No more peek crashes,
 *					no more backlogs
 *		Alan Cox	:	Checks sk->broadcast.
 *		Alan Cox	:	Uses skb_free_datagram/skb_copy_datagram
 *		Alan Cox	:	Raw passes ip options too
 *		Alan Cox	:	Setsocketopt added
 *		Alan Cox	:	Fixed error return for broadcasts
 *		Alan Cox	:	Removed wake_up calls
 *		Alan Cox	:	Use ttl/tos
 *		Alan Cox	:	Cleaned up old debugging
 *		Alan Cox	:	Use new kernel side addresses
 *	Arnt Gulbrandsen	:	Fixed MSG_DONTROUTE in raw sockets.
 *		Alan Cox	:	BSD style RAW socket demultiplexing.
 *		Alan Cox	:	Beginnings of mrouted support.
 *		Alan Cox	:	Added IP_HDRINCL option.
 *		Alan Cox	:	Skip broadcast check if BSDism set.
 *		David S. Miller	:	New socket lookup architecture.
 *
 *		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.
 */
41

A
Alan Cox 已提交
42
#include <linux/types.h>
L
Linus Torvalds 已提交
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
#include <asm/atomic.h>
#include <asm/byteorder.h>
#include <asm/current.h>
#include <asm/uaccess.h>
#include <asm/ioctls.h>
#include <linux/stddef.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/aio.h>
#include <linux/kernel.h>
#include <linux/spinlock.h>
#include <linux/sockios.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/mroute.h>
#include <linux/netdevice.h>
#include <linux/in_route.h>
#include <linux/route.h>
#include <linux/skbuff.h>
62
#include <net/net_namespace.h>
L
Linus Torvalds 已提交
63 64 65 66 67 68 69 70 71 72
#include <net/dst.h>
#include <net/sock.h>
#include <linux/gfp.h>
#include <linux/ip.h>
#include <linux/net.h>
#include <net/ip.h>
#include <net/icmp.h>
#include <net/udp.h>
#include <net/raw.h>
#include <net/snmp.h>
73
#include <net/tcp_states.h>
L
Linus Torvalds 已提交
74 75 76 77 78 79 80 81 82
#include <net/inet_common.h>
#include <net/checksum.h>
#include <net/xfrm.h>
#include <linux/rtnetlink.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/netfilter.h>
#include <linux/netfilter_ipv4.h>

83
static struct raw_hashinfo raw_v4_hashinfo = {
84
	.lock = __RW_LOCK_UNLOCKED(raw_v4_hashinfo.lock),
85
};
L
Linus Torvalds 已提交
86

87
void raw_hash_sk(struct sock *sk)
L
Linus Torvalds 已提交
88
{
89
	struct raw_hashinfo *h = sk->sk_prot->h.raw_hash;
90
	struct hlist_head *head;
L
Linus Torvalds 已提交
91

92 93 94
	head = &h->ht[inet_sk(sk)->num & (RAW_HTABLE_SIZE - 1)];

	write_lock_bh(&h->lock);
L
Linus Torvalds 已提交
95
	sk_add_node(sk, head);
96
	sock_prot_inuse_add(sk->sk_prot, 1);
97 98 99 100
	write_unlock_bh(&h->lock);
}
EXPORT_SYMBOL_GPL(raw_hash_sk);

101
void raw_unhash_sk(struct sock *sk)
102
{
103 104
	struct raw_hashinfo *h = sk->sk_prot->h.raw_hash;

105 106
	write_lock_bh(&h->lock);
	if (sk_del_node_init(sk))
107
		sock_prot_inuse_add(sk->sk_prot, -1);
108 109 110 111
	write_unlock_bh(&h->lock);
}
EXPORT_SYMBOL_GPL(raw_unhash_sk);

112 113
static struct sock *__raw_v4_lookup(struct net *net, struct sock *sk,
		unsigned short num, __be32 raddr, __be32 laddr, int dif)
L
Linus Torvalds 已提交
114 115 116 117 118 119
{
	struct hlist_node *node;

	sk_for_each_from(sk, node) {
		struct inet_sock *inet = inet_sk(sk);

120
		if (net_eq(sock_net(sk), net) && inet->num == num	&&
L
Linus Torvalds 已提交
121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
		    !(inet->daddr && inet->daddr != raddr) 		&&
		    !(inet->rcv_saddr && inet->rcv_saddr != laddr)	&&
		    !(sk->sk_bound_dev_if && sk->sk_bound_dev_if != dif))
			goto found; /* gotcha */
	}
	sk = NULL;
found:
	return sk;
}

/*
 *	0 - deliver
 *	1 - block
 */
static __inline__ int icmp_filter(struct sock *sk, struct sk_buff *skb)
{
	int type;

	if (!pskb_may_pull(skb, sizeof(struct icmphdr)))
		return 1;

142
	type = icmp_hdr(skb)->type;
L
Linus Torvalds 已提交
143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
	if (type < 32) {
		__u32 data = raw_sk(sk)->filter.data;

		return ((1 << type) & data) != 0;
	}

	/* Do not block unknown ICMP types */
	return 0;
}

/* IP input processing comes here for RAW socket delivery.
 * Caller owns SKB, so we must make clones.
 *
 * RFC 1122: SHOULD pass TOS value up to the transport layer.
 * -> It does. And not only TOS, but all IP header.
 */
159
static int raw_v4_input(struct sk_buff *skb, struct iphdr *iph, int hash)
L
Linus Torvalds 已提交
160 161 162
{
	struct sock *sk;
	struct hlist_head *head;
163
	int delivered = 0;
164
	struct net *net;
L
Linus Torvalds 已提交
165

166 167
	read_lock(&raw_v4_hashinfo.lock);
	head = &raw_v4_hashinfo.ht[hash];
L
Linus Torvalds 已提交
168 169
	if (hlist_empty(head))
		goto out;
170

171
	net = dev_net(skb->dev);
172
	sk = __raw_v4_lookup(net, __sk_head(head), iph->protocol,
L
Linus Torvalds 已提交
173 174 175 176
			     iph->saddr, iph->daddr,
			     skb->dev->ifindex);

	while (sk) {
177
		delivered = 1;
L
Linus Torvalds 已提交
178 179 180 181 182 183 184
		if (iph->protocol != IPPROTO_ICMP || !icmp_filter(sk, skb)) {
			struct sk_buff *clone = skb_clone(skb, GFP_ATOMIC);

			/* Not releasing hash table! */
			if (clone)
				raw_rcv(sk, clone);
		}
185
		sk = __raw_v4_lookup(net, sk_next(sk), iph->protocol,
L
Linus Torvalds 已提交
186 187 188 189
				     iph->saddr, iph->daddr,
				     skb->dev->ifindex);
	}
out:
190
	read_unlock(&raw_v4_hashinfo.lock);
191
	return delivered;
L
Linus Torvalds 已提交
192 193
}

194 195 196 197 198
int raw_local_deliver(struct sk_buff *skb, int protocol)
{
	int hash;
	struct sock *raw_sk;

199 200
	hash = protocol & (RAW_HTABLE_SIZE - 1);
	raw_sk = sk_head(&raw_v4_hashinfo.ht[hash]);
201 202 203 204 205 206 207 208 209 210 211 212

	/* If there maybe a raw socket we must check - if not we
	 * don't care less
	 */
	if (raw_sk && !raw_v4_input(skb, ip_hdr(skb), hash))
		raw_sk = NULL;

	return raw_sk != NULL;

}

static void raw_err(struct sock *sk, struct sk_buff *skb, u32 info)
L
Linus Torvalds 已提交
213 214
{
	struct inet_sock *inet = inet_sk(sk);
215 216
	const int type = icmp_hdr(skb)->type;
	const int code = icmp_hdr(skb)->code;
L
Linus Torvalds 已提交
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
	int err = 0;
	int harderr = 0;

	/* Report error on raw socket, if:
	   1. User requested ip_recverr.
	   2. Socket is connected (otherwise the error indication
	      is useless without ip_recverr and error is hard.
	 */
	if (!inet->recverr && sk->sk_state != TCP_ESTABLISHED)
		return;

	switch (type) {
	default:
	case ICMP_TIME_EXCEEDED:
		err = EHOSTUNREACH;
		break;
	case ICMP_SOURCE_QUENCH:
		return;
	case ICMP_PARAMETERPROB:
		err = EPROTO;
		harderr = 1;
		break;
	case ICMP_DEST_UNREACH:
		err = EHOSTUNREACH;
		if (code > NR_ICMP_UNREACH)
			break;
		err = icmp_err_convert[code].errno;
		harderr = icmp_err_convert[code].fatal;
		if (code == ICMP_FRAG_NEEDED) {
			harderr = inet->pmtudisc != IP_PMTUDISC_DONT;
			err = EMSGSIZE;
		}
	}

	if (inet->recverr) {
		struct iphdr *iph = (struct iphdr*)skb->data;
		u8 *payload = skb->data + (iph->ihl << 2);

		if (inet->hdrincl)
			payload = skb->data;
		ip_icmp_error(sk, skb, err, 0, info, payload);
	}

	if (inet->recverr || harderr) {
		sk->sk_err = err;
		sk->sk_error_report(sk);
	}
}

266 267 268 269 270
void raw_icmp_error(struct sk_buff *skb, int protocol, u32 info)
{
	int hash;
	struct sock *raw_sk;
	struct iphdr *iph;
271
	struct net *net;
272

273
	hash = protocol & (RAW_HTABLE_SIZE - 1);
274

275 276
	read_lock(&raw_v4_hashinfo.lock);
	raw_sk = sk_head(&raw_v4_hashinfo.ht[hash]);
277 278
	if (raw_sk != NULL) {
		iph = (struct iphdr *)skb->data;
279
		net = dev_net(skb->dev);
280 281 282

		while ((raw_sk = __raw_v4_lookup(net, raw_sk, protocol,
						iph->daddr, iph->saddr,
283 284 285 286 287 288
						skb->dev->ifindex)) != NULL) {
			raw_err(raw_sk, skb, info);
			raw_sk = sk_next(raw_sk);
			iph = (struct iphdr *)skb->data;
		}
	}
289
	read_unlock(&raw_v4_hashinfo.lock);
290 291
}

L
Linus Torvalds 已提交
292 293 294
static int raw_rcv_skb(struct sock * sk, struct sk_buff * skb)
{
	/* Charge it to the socket. */
295

L
Linus Torvalds 已提交
296
	if (sock_queue_rcv_skb(sk, skb) < 0) {
W
Wang Chen 已提交
297
		atomic_inc(&sk->sk_drops);
L
Linus Torvalds 已提交
298 299 300 301 302 303 304 305 306 307
		kfree_skb(skb);
		return NET_RX_DROP;
	}

	return NET_RX_SUCCESS;
}

int raw_rcv(struct sock *sk, struct sk_buff *skb)
{
	if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb)) {
W
Wang Chen 已提交
308
		atomic_inc(&sk->sk_drops);
L
Linus Torvalds 已提交
309 310 311
		kfree_skb(skb);
		return NET_RX_DROP;
	}
312
	nf_reset(skb);
L
Linus Torvalds 已提交
313

314
	skb_push(skb, skb->data - skb_network_header(skb));
L
Linus Torvalds 已提交
315 316 317 318 319

	raw_rcv_skb(sk, skb);
	return 0;
}

320
static int raw_send_hdrinc(struct sock *sk, void *from, size_t length,
321
			struct rtable *rt,
L
Linus Torvalds 已提交
322 323 324 325 326 327
			unsigned int flags)
{
	struct inet_sock *inet = inet_sk(sk);
	int hh_len;
	struct iphdr *iph;
	struct sk_buff *skb;
328
	unsigned int iphlen;
L
Linus Torvalds 已提交
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
	int err;

	if (length > rt->u.dst.dev->mtu) {
		ip_local_error(sk, EMSGSIZE, rt->rt_dst, inet->dport,
			       rt->u.dst.dev->mtu);
		return -EMSGSIZE;
	}
	if (flags&MSG_PROBE)
		goto out;

	hh_len = LL_RESERVED_SPACE(rt->u.dst.dev);

	skb = sock_alloc_send_skb(sk, length+hh_len+15,
				  flags&MSG_DONTWAIT, &err);
	if (skb == NULL)
344
		goto error;
L
Linus Torvalds 已提交
345 346 347
	skb_reserve(skb, hh_len);

	skb->priority = sk->sk_priority;
348
	skb->mark = sk->sk_mark;
L
Linus Torvalds 已提交
349 350
	skb->dst = dst_clone(&rt->u.dst);

351
	skb_reset_network_header(skb);
352
	iph = ip_hdr(skb);
353
	skb_put(skb, length);
L
Linus Torvalds 已提交
354 355 356

	skb->ip_summed = CHECKSUM_NONE;

357
	skb->transport_header = skb->network_header;
L
Linus Torvalds 已提交
358 359 360 361 362
	err = memcpy_fromiovecend((void *)iph, from, 0, length);
	if (err)
		goto error_fault;

	/* We don't modify invalid header */
363 364
	iphlen = iph->ihl * 4;
	if (iphlen >= sizeof(*iph) && iphlen <= length) {
L
Linus Torvalds 已提交
365 366 367 368 369 370 371 372 373
		if (!iph->saddr)
			iph->saddr = rt->rt_src;
		iph->check   = 0;
		iph->tot_len = htons(length);
		if (!iph->id)
			ip_select_ident(iph, &rt->u.dst, NULL);

		iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
	}
374 375 376
	if (iph->protocol == IPPROTO_ICMP)
		icmp_out_count(((struct icmphdr *)
			skb_transport_header(skb))->type);
L
Linus Torvalds 已提交
377

378
	err = NF_HOOK(PF_INET, NF_INET_LOCAL_OUT, skb, NULL, rt->u.dst.dev,
L
Linus Torvalds 已提交
379 380 381 382 383 384 385 386 387 388 389 390 391
		      dst_output);
	if (err > 0)
		err = inet->recverr ? net_xmit_errno(err) : 0;
	if (err)
		goto error;
out:
	return 0;

error_fault:
	err = -EFAULT;
	kfree_skb(skb);
error:
	IP_INC_STATS(IPSTATS_MIB_OUTDISCARDS);
392
	return err;
L
Linus Torvalds 已提交
393 394
}

H
Heiko Carstens 已提交
395
static int raw_probe_proto_opt(struct flowi *fl, struct msghdr *msg)
L
Linus Torvalds 已提交
396 397 398 399 400
{
	struct iovec *iov;
	u8 __user *type = NULL;
	u8 __user *code = NULL;
	int probed = 0;
401
	unsigned int i;
L
Linus Torvalds 已提交
402 403

	if (!msg->msg_iov)
H
Heiko Carstens 已提交
404
		return 0;
L
Linus Torvalds 已提交
405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425

	for (i = 0; i < msg->msg_iovlen; i++) {
		iov = &msg->msg_iov[i];
		if (!iov)
			continue;

		switch (fl->proto) {
		case IPPROTO_ICMP:
			/* check if one-byte field is readable or not. */
			if (iov->iov_base && iov->iov_len < 1)
				break;

			if (!type) {
				type = iov->iov_base;
				/* check if code field is readable or not. */
				if (iov->iov_len > 1)
					code = type + 1;
			} else if (!code)
				code = iov->iov_base;

			if (type && code) {
H
Heiko Carstens 已提交
426 427 428
				if (get_user(fl->fl_icmp_type, type) ||
				    get_user(fl->fl_icmp_code, code))
					return -EFAULT;
L
Linus Torvalds 已提交
429 430 431 432 433 434 435 436 437 438
				probed = 1;
			}
			break;
		default:
			probed = 1;
			break;
		}
		if (probed)
			break;
	}
H
Heiko Carstens 已提交
439
	return 0;
L
Linus Torvalds 已提交
440 441 442 443 444 445 446 447 448
}

static int raw_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
		       size_t len)
{
	struct inet_sock *inet = inet_sk(sk);
	struct ipcm_cookie ipc;
	struct rtable *rt = NULL;
	int free = 0;
A
Al Viro 已提交
449
	__be32 daddr;
A
Al Viro 已提交
450
	__be32 saddr;
L
Linus Torvalds 已提交
451 452 453 454
	u8  tos;
	int err;

	err = -EMSGSIZE;
455
	if (len > 0xFFFF)
L
Linus Torvalds 已提交
456 457 458 459 460 461 462 463 464
		goto out;

	/*
	 *	Check the flags.
	 */

	err = -EOPNOTSUPP;
	if (msg->msg_flags & MSG_OOB)	/* Mirror BSD error message */
		goto out;               /* compatibility */
465

L
Linus Torvalds 已提交
466
	/*
467
	 *	Get and verify the address.
L
Linus Torvalds 已提交
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491
	 */

	if (msg->msg_namelen) {
		struct sockaddr_in *usin = (struct sockaddr_in*)msg->msg_name;
		err = -EINVAL;
		if (msg->msg_namelen < sizeof(*usin))
			goto out;
		if (usin->sin_family != AF_INET) {
			static int complained;
			if (!complained++)
				printk(KERN_INFO "%s forgot to set AF_INET in "
						 "raw sendmsg. Fix it!\n",
						 current->comm);
			err = -EAFNOSUPPORT;
			if (usin->sin_family)
				goto out;
		}
		daddr = usin->sin_addr.s_addr;
		/* ANK: I did not forget to get protocol from port field.
		 * I just do not know, who uses this weirdness.
		 * IP_HDRINCL is much more convenient.
		 */
	} else {
		err = -EDESTADDRREQ;
492
		if (sk->sk_state != TCP_ESTABLISHED)
L
Linus Torvalds 已提交
493 494 495 496 497 498 499 500 501
			goto out;
		daddr = inet->daddr;
	}

	ipc.addr = inet->saddr;
	ipc.opt = NULL;
	ipc.oif = sk->sk_bound_dev_if;

	if (msg->msg_controllen) {
502
		err = ip_cmsg_send(sock_net(sk), msg, &ipc);
L
Linus Torvalds 已提交
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
		if (err)
			goto out;
		if (ipc.opt)
			free = 1;
	}

	saddr = ipc.addr;
	ipc.addr = daddr;

	if (!ipc.opt)
		ipc.opt = inet->opt;

	if (ipc.opt) {
		err = -EINVAL;
		/* Linux does not mangle headers on raw sockets,
		 * so that IP options + IP_HDRINCL is non-sense.
		 */
		if (inet->hdrincl)
			goto done;
		if (ipc.opt->srr) {
			if (!daddr)
				goto done;
			daddr = ipc.opt->faddr;
		}
	}
	tos = RT_CONN_FLAGS(sk);
	if (msg->msg_flags & MSG_DONTROUTE)
		tos |= RTO_ONLINK;

532
	if (ipv4_is_multicast(daddr)) {
L
Linus Torvalds 已提交
533 534 535 536 537 538 539 540
		if (!ipc.oif)
			ipc.oif = inet->mc_index;
		if (!saddr)
			saddr = inet->mc_addr;
	}

	{
		struct flowi fl = { .oif = ipc.oif,
541
				    .mark = sk->sk_mark,
L
Linus Torvalds 已提交
542 543 544 545 546
				    .nl_u = { .ip4_u =
					      { .daddr = daddr,
						.saddr = saddr,
						.tos = tos } },
				    .proto = inet->hdrincl ? IPPROTO_RAW :
547
							     sk->sk_protocol,
L
Linus Torvalds 已提交
548
				  };
H
Heiko Carstens 已提交
549 550 551 552 553
		if (!inet->hdrincl) {
			err = raw_probe_proto_opt(&fl, msg);
			if (err)
				goto done;
		}
L
Linus Torvalds 已提交
554

V
Venkat Yekkirala 已提交
555
		security_sk_classify_flow(sk, &fl);
556
		err = ip_route_output_flow(sock_net(sk), &rt, &fl, sk, 1);
L
Linus Torvalds 已提交
557 558 559 560 561 562 563 564 565 566 567 568 569
	}
	if (err)
		goto done;

	err = -EACCES;
	if (rt->rt_flags & RTCF_BROADCAST && !sock_flag(sk, SOCK_BROADCAST))
		goto done;

	if (msg->msg_flags & MSG_CONFIRM)
		goto do_confirm;
back_from_confirm:

	if (inet->hdrincl)
570
		err = raw_send_hdrinc(sk, msg->msg_iov, len,
L
Linus Torvalds 已提交
571
					rt, msg->msg_flags);
572

L
Linus Torvalds 已提交
573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
	 else {
		if (!ipc.addr)
			ipc.addr = rt->rt_dst;
		lock_sock(sk);
		err = ip_append_data(sk, ip_generic_getfrag, msg->msg_iov, len, 0,
					&ipc, rt, msg->msg_flags);
		if (err)
			ip_flush_pending_frames(sk);
		else if (!(msg->msg_flags & MSG_MORE))
			err = ip_push_pending_frames(sk);
		release_sock(sk);
	}
done:
	if (free)
		kfree(ipc.opt);
	ip_rt_put(rt);

590 591 592 593
out:
	if (err < 0)
		return err;
	return len;
L
Linus Torvalds 已提交
594 595 596 597 598 599 600 601 602 603 604

do_confirm:
	dst_confirm(&rt->u.dst);
	if (!(msg->msg_flags & MSG_PROBE) || len)
		goto back_from_confirm;
	err = 0;
	goto done;
}

static void raw_close(struct sock *sk, long timeout)
{
605
	/*
L
Linus Torvalds 已提交
606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622
	 * Raw sockets may have direct kernel refereneces. Kill them.
	 */
	ip_ra_control(sk, 0, NULL);

	sk_common_release(sk);
}

/* This gets rid of all the nasties in af_inet. -DaveM */
static int raw_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
{
	struct inet_sock *inet = inet_sk(sk);
	struct sockaddr_in *addr = (struct sockaddr_in *) uaddr;
	int ret = -EINVAL;
	int chk_addr_ret;

	if (sk->sk_state != TCP_CLOSE || addr_len < sizeof(struct sockaddr_in))
		goto out;
623
	chk_addr_ret = inet_addr_type(sock_net(sk), addr->sin_addr.s_addr);
L
Linus Torvalds 已提交
624 625 626 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 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679
	ret = -EADDRNOTAVAIL;
	if (addr->sin_addr.s_addr && chk_addr_ret != RTN_LOCAL &&
	    chk_addr_ret != RTN_MULTICAST && chk_addr_ret != RTN_BROADCAST)
		goto out;
	inet->rcv_saddr = inet->saddr = addr->sin_addr.s_addr;
	if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
		inet->saddr = 0;  /* Use device */
	sk_dst_reset(sk);
	ret = 0;
out:	return ret;
}

/*
 *	This should be easy, if there is something there
 *	we return it, otherwise we block.
 */

static int raw_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
		       size_t len, int noblock, int flags, int *addr_len)
{
	struct inet_sock *inet = inet_sk(sk);
	size_t copied = 0;
	int err = -EOPNOTSUPP;
	struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;
	struct sk_buff *skb;

	if (flags & MSG_OOB)
		goto out;

	if (addr_len)
		*addr_len = sizeof(*sin);

	if (flags & MSG_ERRQUEUE) {
		err = ip_recv_error(sk, msg, len);
		goto out;
	}

	skb = skb_recv_datagram(sk, flags, noblock, &err);
	if (!skb)
		goto out;

	copied = skb->len;
	if (len < copied) {
		msg->msg_flags |= MSG_TRUNC;
		copied = len;
	}

	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
	if (err)
		goto done;

	sock_recv_timestamp(msg, sk, skb);

	/* Copy the address. */
	if (sin) {
		sin->sin_family = AF_INET;
680
		sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
681
		sin->sin_port = 0;
L
Linus Torvalds 已提交
682 683 684 685 686 687 688 689
		memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
	}
	if (inet->cmsg_flags)
		ip_cmsg_recv(msg, skb);
	if (flags & MSG_TRUNC)
		copied = skb->len;
done:
	skb_free_datagram(sk, skb);
690 691 692 693
out:
	if (err)
		return err;
	return copied;
L
Linus Torvalds 已提交
694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732
}

static int raw_init(struct sock *sk)
{
	struct raw_sock *rp = raw_sk(sk);

	if (inet_sk(sk)->num == IPPROTO_ICMP)
		memset(&rp->filter, 0, sizeof(rp->filter));
	return 0;
}

static int raw_seticmpfilter(struct sock *sk, char __user *optval, int optlen)
{
	if (optlen > sizeof(struct icmp_filter))
		optlen = sizeof(struct icmp_filter);
	if (copy_from_user(&raw_sk(sk)->filter, optval, optlen))
		return -EFAULT;
	return 0;
}

static int raw_geticmpfilter(struct sock *sk, char __user *optval, int __user *optlen)
{
	int len, ret = -EFAULT;

	if (get_user(len, optlen))
		goto out;
	ret = -EINVAL;
	if (len < 0)
		goto out;
	if (len > sizeof(struct icmp_filter))
		len = sizeof(struct icmp_filter);
	ret = -EFAULT;
	if (put_user(len, optlen) ||
	    copy_to_user(optval, &raw_sk(sk)->filter, len))
		goto out;
	ret = 0;
out:	return ret;
}

733
static int do_raw_setsockopt(struct sock *sk, int level, int optname,
L
Linus Torvalds 已提交
734 735 736 737 738 739 740 741 742 743 744
			  char __user *optval, int optlen)
{
	if (optname == ICMP_FILTER) {
		if (inet_sk(sk)->num != IPPROTO_ICMP)
			return -EOPNOTSUPP;
		else
			return raw_seticmpfilter(sk, optval, optlen);
	}
	return -ENOPROTOOPT;
}

745 746
static int raw_setsockopt(struct sock *sk, int level, int optname,
			  char __user *optval, int optlen)
L
Linus Torvalds 已提交
747 748
{
	if (level != SOL_RAW)
749 750 751
		return ip_setsockopt(sk, level, optname, optval, optlen);
	return do_raw_setsockopt(sk, level, optname, optval, optlen);
}
L
Linus Torvalds 已提交
752

753 754
#ifdef CONFIG_COMPAT
static int compat_raw_setsockopt(struct sock *sk, int level, int optname,
755
				 char __user *optval, int optlen)
756 757
{
	if (level != SOL_RAW)
758
		return compat_ip_setsockopt(sk, level, optname, optval, optlen);
759 760 761 762 763 764 765
	return do_raw_setsockopt(sk, level, optname, optval, optlen);
}
#endif

static int do_raw_getsockopt(struct sock *sk, int level, int optname,
			  char __user *optval, int __user *optlen)
{
L
Linus Torvalds 已提交
766 767 768 769 770 771 772 773 774
	if (optname == ICMP_FILTER) {
		if (inet_sk(sk)->num != IPPROTO_ICMP)
			return -EOPNOTSUPP;
		else
			return raw_geticmpfilter(sk, optval, optlen);
	}
	return -ENOPROTOOPT;
}

775 776 777 778 779 780 781 782 783 784
static int raw_getsockopt(struct sock *sk, int level, int optname,
			  char __user *optval, int __user *optlen)
{
	if (level != SOL_RAW)
		return ip_getsockopt(sk, level, optname, optval, optlen);
	return do_raw_getsockopt(sk, level, optname, optval, optlen);
}

#ifdef CONFIG_COMPAT
static int compat_raw_getsockopt(struct sock *sk, int level, int optname,
785
				 char __user *optval, int __user *optlen)
786 787
{
	if (level != SOL_RAW)
788
		return compat_ip_getsockopt(sk, level, optname, optval, optlen);
789 790 791 792
	return do_raw_getsockopt(sk, level, optname, optval, optlen);
}
#endif

L
Linus Torvalds 已提交
793 794 795 796 797 798 799 800 801 802 803
static int raw_ioctl(struct sock *sk, int cmd, unsigned long arg)
{
	switch (cmd) {
		case SIOCOUTQ: {
			int amount = atomic_read(&sk->sk_wmem_alloc);
			return put_user(amount, (int __user *)arg);
		}
		case SIOCINQ: {
			struct sk_buff *skb;
			int amount = 0;

804
			spin_lock_bh(&sk->sk_receive_queue.lock);
L
Linus Torvalds 已提交
805 806 807
			skb = skb_peek(&sk->sk_receive_queue);
			if (skb != NULL)
				amount = skb->len;
808
			spin_unlock_bh(&sk->sk_receive_queue.lock);
L
Linus Torvalds 已提交
809 810 811 812 813 814 815 816 817 818 819 820 821
			return put_user(amount, (int __user *)arg);
		}

		default:
#ifdef CONFIG_IP_MROUTE
			return ipmr_ioctl(sk, cmd, (void __user *)arg);
#else
			return -ENOIOCTLCMD;
#endif
	}
}

struct proto raw_prot = {
822 823 824 825 826 827 828 829 830 831 832 833 834
	.name		   = "RAW",
	.owner		   = THIS_MODULE,
	.close		   = raw_close,
	.connect	   = ip4_datagram_connect,
	.disconnect	   = udp_disconnect,
	.ioctl		   = raw_ioctl,
	.init		   = raw_init,
	.setsockopt	   = raw_setsockopt,
	.getsockopt	   = raw_getsockopt,
	.sendmsg	   = raw_sendmsg,
	.recvmsg	   = raw_recvmsg,
	.bind		   = raw_bind,
	.backlog_rcv	   = raw_rcv_skb,
835 836
	.hash		   = raw_hash_sk,
	.unhash		   = raw_unhash_sk,
837
	.obj_size	   = sizeof(struct raw_sock),
838
	.h.raw_hash	   = &raw_v4_hashinfo,
839
#ifdef CONFIG_COMPAT
840 841
	.compat_setsockopt = compat_raw_setsockopt,
	.compat_getsockopt = compat_raw_getsockopt,
842
#endif
L
Linus Torvalds 已提交
843 844 845 846 847 848 849 850
};

#ifdef CONFIG_PROC_FS
static struct sock *raw_get_first(struct seq_file *seq)
{
	struct sock *sk;
	struct raw_iter_state* state = raw_seq_private(seq);

851 852
	for (state->bucket = 0; state->bucket < RAW_HTABLE_SIZE;
			++state->bucket) {
L
Linus Torvalds 已提交
853 854
		struct hlist_node *node;

855
		sk_for_each(sk, node, &state->h->ht[state->bucket])
856
			if (sock_net(sk) == seq_file_net(seq))
L
Linus Torvalds 已提交
857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
				goto found;
	}
	sk = NULL;
found:
	return sk;
}

static struct sock *raw_get_next(struct seq_file *seq, struct sock *sk)
{
	struct raw_iter_state* state = raw_seq_private(seq);

	do {
		sk = sk_next(sk);
try_again:
		;
872
	} while (sk && sock_net(sk) != seq_file_net(seq));
L
Linus Torvalds 已提交
873

874
	if (!sk && ++state->bucket < RAW_HTABLE_SIZE) {
875
		sk = sk_head(&state->h->ht[state->bucket]);
L
Linus Torvalds 已提交
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890
		goto try_again;
	}
	return sk;
}

static struct sock *raw_get_idx(struct seq_file *seq, loff_t pos)
{
	struct sock *sk = raw_get_first(seq);

	if (sk)
		while (pos && (sk = raw_get_next(seq, sk)) != NULL)
			--pos;
	return pos ? NULL : sk;
}

891
void *raw_seq_start(struct seq_file *seq, loff_t *pos)
L
Linus Torvalds 已提交
892
{
893 894 895
	struct raw_iter_state *state = raw_seq_private(seq);

	read_lock(&state->h->lock);
L
Linus Torvalds 已提交
896 897
	return *pos ? raw_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
}
898
EXPORT_SYMBOL_GPL(raw_seq_start);
L
Linus Torvalds 已提交
899

900
void *raw_seq_next(struct seq_file *seq, void *v, loff_t *pos)
L
Linus Torvalds 已提交
901 902 903 904 905 906 907 908 909 910
{
	struct sock *sk;

	if (v == SEQ_START_TOKEN)
		sk = raw_get_first(seq);
	else
		sk = raw_get_next(seq, v);
	++*pos;
	return sk;
}
911
EXPORT_SYMBOL_GPL(raw_seq_next);
L
Linus Torvalds 已提交
912

913
void raw_seq_stop(struct seq_file *seq, void *v)
L
Linus Torvalds 已提交
914
{
915 916 917
	struct raw_iter_state *state = raw_seq_private(seq);

	read_unlock(&state->h->lock);
L
Linus Torvalds 已提交
918
}
919
EXPORT_SYMBOL_GPL(raw_seq_stop);
L
Linus Torvalds 已提交
920

921
static void raw_sock_seq_show(struct seq_file *seq, struct sock *sp, int i)
L
Linus Torvalds 已提交
922 923
{
	struct inet_sock *inet = inet_sk(sp);
924 925
	__be32 dest = inet->daddr,
	       src = inet->rcv_saddr;
L
Linus Torvalds 已提交
926 927 928
	__u16 destp = 0,
	      srcp  = inet->num;

929
	seq_printf(seq, "%4d: %08X:%04X %08X:%04X"
W
Wang Chen 已提交
930
		" %02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %d",
931
		i, src, srcp, dest, destp, sp->sk_state,
L
Linus Torvalds 已提交
932 933 934
		atomic_read(&sp->sk_wmem_alloc),
		atomic_read(&sp->sk_rmem_alloc),
		0, 0L, 0, sock_i_uid(sp), 0, sock_i_ino(sp),
W
Wang Chen 已提交
935
		atomic_read(&sp->sk_refcnt), sp, atomic_read(&sp->sk_drops));
L
Linus Torvalds 已提交
936 937 938 939 940
}

static int raw_seq_show(struct seq_file *seq, void *v)
{
	if (v == SEQ_START_TOKEN)
941 942 943 944 945
		seq_printf(seq, "  sl  local_address rem_address   st tx_queue "
				"rx_queue tr tm->when retrnsmt   uid  timeout "
				"inode  drops\n");
	else
		raw_sock_seq_show(seq, v, raw_seq_private(seq)->bucket);
L
Linus Torvalds 已提交
946 947 948
	return 0;
}

949
static const struct seq_operations raw_seq_ops = {
L
Linus Torvalds 已提交
950 951 952 953 954 955
	.start = raw_seq_start,
	.next  = raw_seq_next,
	.stop  = raw_seq_stop,
	.show  = raw_seq_show,
};

956 957
int raw_seq_open(struct inode *ino, struct file *file,
		 struct raw_hashinfo *h, const struct seq_operations *ops)
L
Linus Torvalds 已提交
958
{
959
	int err;
960 961
	struct raw_iter_state *i;

962
	err = seq_open_net(ino, file, ops, sizeof(struct raw_iter_state));
963 964
	if (err < 0)
		return err;
965

966
	i = raw_seq_private((struct seq_file *)file->private_data);
967 968 969 970 971 972 973
	i->h = h;
	return 0;
}
EXPORT_SYMBOL_GPL(raw_seq_open);

static int raw_v4_seq_open(struct inode *inode, struct file *file)
{
974
	return raw_seq_open(inode, file, &raw_v4_hashinfo, &raw_seq_ops);
L
Linus Torvalds 已提交
975 976
}

977
static const struct file_operations raw_seq_fops = {
L
Linus Torvalds 已提交
978
	.owner	 = THIS_MODULE,
979
	.open	 = raw_v4_seq_open,
L
Linus Torvalds 已提交
980 981
	.read	 = seq_read,
	.llseek	 = seq_lseek,
982
	.release = seq_release_net,
L
Linus Torvalds 已提交
983 984
};

985
static __net_init int raw_init_net(struct net *net)
L
Linus Torvalds 已提交
986
{
987
	if (!proc_net_fops_create(net, "raw", S_IRUGO, &raw_seq_fops))
L
Linus Torvalds 已提交
988
		return -ENOMEM;
989

L
Linus Torvalds 已提交
990 991 992
	return 0;
}

993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
static __net_exit void raw_exit_net(struct net *net)
{
	proc_net_remove(net, "raw");
}

static __net_initdata struct pernet_operations raw_net_ops = {
	.init = raw_init_net,
	.exit = raw_exit_net,
};

int __init raw_proc_init(void)
{
	return register_pernet_subsys(&raw_net_ops);
}

L
Linus Torvalds 已提交
1008 1009
void __init raw_proc_exit(void)
{
1010
	unregister_pernet_subsys(&raw_net_ops);
L
Linus Torvalds 已提交
1011 1012
}
#endif /* CONFIG_PROC_FS */