raw.c 23.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7
/*
 * 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.
 *
8
 * Authors:	Ross Biro
Linus Torvalds's avatar
Linus Torvalds committed
9 10 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
 *		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.
 */
39

40
#include <linux/types.h>
Linus Torvalds's avatar
Linus Torvalds committed
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
#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>
60
#include <net/net_namespace.h>
Linus Torvalds's avatar
Linus Torvalds committed
61 62 63 64 65 66 67 68 69 70
#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>
71
#include <net/tcp_states.h>
Linus Torvalds's avatar
Linus Torvalds committed
72 73 74 75 76 77 78 79 80
#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>

81
static struct raw_hashinfo raw_v4_hashinfo = {
82
	.lock = __RW_LOCK_UNLOCKED(raw_v4_hashinfo.lock),
83
};
Linus Torvalds's avatar
Linus Torvalds committed
84

85
void raw_hash_sk(struct sock *sk)
Linus Torvalds's avatar
Linus Torvalds committed
86
{
87
	struct raw_hashinfo *h = sk->sk_prot->h.raw_hash;
88
	struct hlist_head *head;
Linus Torvalds's avatar
Linus Torvalds committed
89

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

	write_lock_bh(&h->lock);
Linus Torvalds's avatar
Linus Torvalds committed
93
	sk_add_node(sk, head);
94
	sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
95 96 97 98
	write_unlock_bh(&h->lock);
}
EXPORT_SYMBOL_GPL(raw_hash_sk);

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

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

110 111
static struct sock *__raw_v4_lookup(struct net *net, struct sock *sk,
		unsigned short num, __be32 raddr, __be32 laddr, int dif)
Linus Torvalds's avatar
Linus Torvalds committed
112 113 114 115 116 117
{
	struct hlist_node *node;

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

118
		if (net_eq(sock_net(sk), net) && inet->num == num	&&
Linus Torvalds's avatar
Linus Torvalds committed
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
		    !(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;

140
	type = icmp_hdr(skb)->type;
Linus Torvalds's avatar
Linus Torvalds committed
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
	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.
 */
157
static int raw_v4_input(struct sk_buff *skb, struct iphdr *iph, int hash)
Linus Torvalds's avatar
Linus Torvalds committed
158 159 160
{
	struct sock *sk;
	struct hlist_head *head;
161
	int delivered = 0;
162
	struct net *net;
Linus Torvalds's avatar
Linus Torvalds committed
163

164 165
	read_lock(&raw_v4_hashinfo.lock);
	head = &raw_v4_hashinfo.ht[hash];
Linus Torvalds's avatar
Linus Torvalds committed
166 167
	if (hlist_empty(head))
		goto out;
168

169
	net = dev_net(skb->dev);
170
	sk = __raw_v4_lookup(net, __sk_head(head), iph->protocol,
Linus Torvalds's avatar
Linus Torvalds committed
171 172 173 174
			     iph->saddr, iph->daddr,
			     skb->dev->ifindex);

	while (sk) {
175
		delivered = 1;
Linus Torvalds's avatar
Linus Torvalds committed
176 177 178 179 180 181 182
		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);
		}
183
		sk = __raw_v4_lookup(net, sk_next(sk), iph->protocol,
Linus Torvalds's avatar
Linus Torvalds committed
184 185 186 187
				     iph->saddr, iph->daddr,
				     skb->dev->ifindex);
	}
out:
188
	read_unlock(&raw_v4_hashinfo.lock);
189
	return delivered;
Linus Torvalds's avatar
Linus Torvalds committed
190 191
}

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

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

	/* 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)
Linus Torvalds's avatar
Linus Torvalds committed
211 212
{
	struct inet_sock *inet = inet_sk(sk);
213 214
	const int type = icmp_hdr(skb)->type;
	const int code = icmp_hdr(skb)->code;
Linus Torvalds's avatar
Linus Torvalds committed
215 216 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
	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);
	}
}

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

271
	hash = protocol & (RAW_HTABLE_SIZE - 1);
272

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

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

Linus Torvalds's avatar
Linus Torvalds committed
290 291 292
static int raw_rcv_skb(struct sock * sk, struct sk_buff * skb)
{
	/* Charge it to the socket. */
293

Linus Torvalds's avatar
Linus Torvalds committed
294
	if (sock_queue_rcv_skb(sk, skb) < 0) {
Wang Chen's avatar
Wang Chen committed
295
		atomic_inc(&sk->sk_drops);
Linus Torvalds's avatar
Linus Torvalds committed
296 297 298 299 300 301 302 303 304 305
		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)) {
Wang Chen's avatar
Wang Chen committed
306
		atomic_inc(&sk->sk_drops);
Linus Torvalds's avatar
Linus Torvalds committed
307 308 309
		kfree_skb(skb);
		return NET_RX_DROP;
	}
310
	nf_reset(skb);
Linus Torvalds's avatar
Linus Torvalds committed
311

312
	skb_push(skb, skb->data - skb_network_header(skb));
Linus Torvalds's avatar
Linus Torvalds committed
313 314 315 316 317

	raw_rcv_skb(sk, skb);
	return 0;
}

318
static int raw_send_hdrinc(struct sock *sk, void *from, size_t length,
319
			struct rtable *rt,
Linus Torvalds's avatar
Linus Torvalds committed
320 321 322 323 324
			unsigned int flags)
{
	struct inet_sock *inet = inet_sk(sk);
	struct iphdr *iph;
	struct sk_buff *skb;
325
	unsigned int iphlen;
Linus Torvalds's avatar
Linus Torvalds committed
326 327 328 329 330 331 332 333 334 335
	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;

336 337 338
	skb = sock_alloc_send_skb(sk,
				  length + LL_ALLOCATED_SPACE(rt->u.dst.dev) + 15,
				  flags & MSG_DONTWAIT, &err);
Linus Torvalds's avatar
Linus Torvalds committed
339
	if (skb == NULL)
340
		goto error;
341
	skb_reserve(skb, LL_RESERVED_SPACE(rt->u.dst.dev));
Linus Torvalds's avatar
Linus Torvalds committed
342 343

	skb->priority = sk->sk_priority;
344
	skb->mark = sk->sk_mark;
Linus Torvalds's avatar
Linus Torvalds committed
345 346
	skb->dst = dst_clone(&rt->u.dst);

347
	skb_reset_network_header(skb);
348
	iph = ip_hdr(skb);
349
	skb_put(skb, length);
Linus Torvalds's avatar
Linus Torvalds committed
350 351 352

	skb->ip_summed = CHECKSUM_NONE;

353
	skb->transport_header = skb->network_header;
Linus Torvalds's avatar
Linus Torvalds committed
354 355 356 357 358
	err = memcpy_fromiovecend((void *)iph, from, 0, length);
	if (err)
		goto error_fault;

	/* We don't modify invalid header */
359 360
	iphlen = iph->ihl * 4;
	if (iphlen >= sizeof(*iph) && iphlen <= length) {
Linus Torvalds's avatar
Linus Torvalds committed
361 362 363 364 365 366 367 368 369
		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);
	}
370 371 372
	if (iph->protocol == IPPROTO_ICMP)
		icmp_out_count(((struct icmphdr *)
			skb_transport_header(skb))->type);
Linus Torvalds's avatar
Linus Torvalds committed
373

374
	err = NF_HOOK(PF_INET, NF_INET_LOCAL_OUT, skb, NULL, rt->u.dst.dev,
Linus Torvalds's avatar
Linus Torvalds committed
375 376 377 378 379 380 381 382 383 384 385 386 387
		      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);
388
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
389 390
}

Heiko Carstens's avatar
Heiko Carstens committed
391
static int raw_probe_proto_opt(struct flowi *fl, struct msghdr *msg)
Linus Torvalds's avatar
Linus Torvalds committed
392 393 394 395 396
{
	struct iovec *iov;
	u8 __user *type = NULL;
	u8 __user *code = NULL;
	int probed = 0;
397
	unsigned int i;
Linus Torvalds's avatar
Linus Torvalds committed
398 399

	if (!msg->msg_iov)
Heiko Carstens's avatar
Heiko Carstens committed
400
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421

	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) {
Heiko Carstens's avatar
Heiko Carstens committed
422 423 424
				if (get_user(fl->fl_icmp_type, type) ||
				    get_user(fl->fl_icmp_code, code))
					return -EFAULT;
Linus Torvalds's avatar
Linus Torvalds committed
425 426 427 428 429 430 431 432 433 434
				probed = 1;
			}
			break;
		default:
			probed = 1;
			break;
		}
		if (probed)
			break;
	}
Heiko Carstens's avatar
Heiko Carstens committed
435
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
436 437 438 439 440 441 442 443 444
}

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;
445
	__be32 daddr;
446
	__be32 saddr;
Linus Torvalds's avatar
Linus Torvalds committed
447 448 449 450
	u8  tos;
	int err;

	err = -EMSGSIZE;
451
	if (len > 0xFFFF)
Linus Torvalds's avatar
Linus Torvalds committed
452 453 454 455 456 457 458 459 460
		goto out;

	/*
	 *	Check the flags.
	 */

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

Linus Torvalds's avatar
Linus Torvalds committed
462
	/*
463
	 *	Get and verify the address.
Linus Torvalds's avatar
Linus Torvalds committed
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
	 */

	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;
488
		if (sk->sk_state != TCP_ESTABLISHED)
Linus Torvalds's avatar
Linus Torvalds committed
489 490 491 492 493 494 495 496 497
			goto out;
		daddr = inet->daddr;
	}

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

	if (msg->msg_controllen) {
498
		err = ip_cmsg_send(sock_net(sk), msg, &ipc);
Linus Torvalds's avatar
Linus Torvalds committed
499 500 501 502 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
		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;

528
	if (ipv4_is_multicast(daddr)) {
Linus Torvalds's avatar
Linus Torvalds committed
529 530 531 532 533 534 535 536
		if (!ipc.oif)
			ipc.oif = inet->mc_index;
		if (!saddr)
			saddr = inet->mc_addr;
	}

	{
		struct flowi fl = { .oif = ipc.oif,
537
				    .mark = sk->sk_mark,
Linus Torvalds's avatar
Linus Torvalds committed
538 539 540 541 542
				    .nl_u = { .ip4_u =
					      { .daddr = daddr,
						.saddr = saddr,
						.tos = tos } },
				    .proto = inet->hdrincl ? IPPROTO_RAW :
543
							     sk->sk_protocol,
Linus Torvalds's avatar
Linus Torvalds committed
544
				  };
Heiko Carstens's avatar
Heiko Carstens committed
545 546 547 548 549
		if (!inet->hdrincl) {
			err = raw_probe_proto_opt(&fl, msg);
			if (err)
				goto done;
		}
Linus Torvalds's avatar
Linus Torvalds committed
550

551
		security_sk_classify_flow(sk, &fl);
552
		err = ip_route_output_flow(sock_net(sk), &rt, &fl, sk, 1);
Linus Torvalds's avatar
Linus Torvalds committed
553 554 555 556 557 558 559 560 561 562 563 564 565
	}
	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)
566
		err = raw_send_hdrinc(sk, msg->msg_iov, len,
Linus Torvalds's avatar
Linus Torvalds committed
567
					rt, msg->msg_flags);
568

Linus Torvalds's avatar
Linus Torvalds committed
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
	 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);

586 587 588 589
out:
	if (err < 0)
		return err;
	return len;
Linus Torvalds's avatar
Linus Torvalds committed
590 591 592 593 594 595 596 597 598 599 600

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)
{
601
	/*
Linus Torvalds's avatar
Linus Torvalds committed
602 603 604 605 606 607 608
	 * Raw sockets may have direct kernel refereneces. Kill them.
	 */
	ip_ra_control(sk, 0, NULL);

	sk_common_release(sk);
}

609
static void raw_destroy(struct sock *sk)
Denis V. Lunev's avatar
Denis V. Lunev committed
610 611 612 613 614 615
{
	lock_sock(sk);
	ip_flush_pending_frames(sk);
	release_sock(sk);
}

Linus Torvalds's avatar
Linus Torvalds committed
616 617 618 619 620 621 622 623 624 625
/* 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;
626
	chk_addr_ret = inet_addr_type(sock_net(sk), addr->sin_addr.s_addr);
Linus Torvalds's avatar
Linus Torvalds committed
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 680 681 682
	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;
683
		sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
684
		sin->sin_port = 0;
Linus Torvalds's avatar
Linus Torvalds committed
685 686 687 688 689 690 691 692
		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);
693 694 695 696
out:
	if (err)
		return err;
	return copied;
Linus Torvalds's avatar
Linus Torvalds committed
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 733 734 735
}

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;
}

736
static int do_raw_setsockopt(struct sock *sk, int level, int optname,
Linus Torvalds's avatar
Linus Torvalds committed
737 738 739 740 741 742 743 744 745 746 747
			  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;
}

748 749
static int raw_setsockopt(struct sock *sk, int level, int optname,
			  char __user *optval, int optlen)
Linus Torvalds's avatar
Linus Torvalds committed
750 751
{
	if (level != SOL_RAW)
752 753 754
		return ip_setsockopt(sk, level, optname, optval, optlen);
	return do_raw_setsockopt(sk, level, optname, optval, optlen);
}
Linus Torvalds's avatar
Linus Torvalds committed
755

756 757
#ifdef CONFIG_COMPAT
static int compat_raw_setsockopt(struct sock *sk, int level, int optname,
758
				 char __user *optval, int optlen)
759 760
{
	if (level != SOL_RAW)
761
		return compat_ip_setsockopt(sk, level, optname, optval, optlen);
762 763 764 765 766 767 768
	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)
{
Linus Torvalds's avatar
Linus Torvalds committed
769 770 771 772 773 774 775 776 777
	if (optname == ICMP_FILTER) {
		if (inet_sk(sk)->num != IPPROTO_ICMP)
			return -EOPNOTSUPP;
		else
			return raw_geticmpfilter(sk, optval, optlen);
	}
	return -ENOPROTOOPT;
}

778 779 780 781 782 783 784 785 786 787
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,
788
				 char __user *optval, int __user *optlen)
789 790
{
	if (level != SOL_RAW)
791
		return compat_ip_getsockopt(sk, level, optname, optval, optlen);
792 793 794 795
	return do_raw_getsockopt(sk, level, optname, optval, optlen);
}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
796 797 798 799 800 801 802 803 804 805 806
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;

807
			spin_lock_bh(&sk->sk_receive_queue.lock);
Linus Torvalds's avatar
Linus Torvalds committed
808 809 810
			skb = skb_peek(&sk->sk_receive_queue);
			if (skb != NULL)
				amount = skb->len;
811
			spin_unlock_bh(&sk->sk_receive_queue.lock);
Linus Torvalds's avatar
Linus Torvalds committed
812 813 814 815 816 817 818 819 820 821 822 823 824
			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 = {
825 826 827
	.name		   = "RAW",
	.owner		   = THIS_MODULE,
	.close		   = raw_close,
Denis V. Lunev's avatar
Denis V. Lunev committed
828
	.destroy	   = raw_destroy,
829 830 831 832 833 834 835 836 837 838
	.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,
839 840
	.hash		   = raw_hash_sk,
	.unhash		   = raw_unhash_sk,
841
	.obj_size	   = sizeof(struct raw_sock),
842
	.h.raw_hash	   = &raw_v4_hashinfo,
843
#ifdef CONFIG_COMPAT
844 845
	.compat_setsockopt = compat_raw_setsockopt,
	.compat_getsockopt = compat_raw_getsockopt,
846
#endif
Linus Torvalds's avatar
Linus Torvalds committed
847 848 849 850 851 852 853 854
};

#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);

855 856
	for (state->bucket = 0; state->bucket < RAW_HTABLE_SIZE;
			++state->bucket) {
Linus Torvalds's avatar
Linus Torvalds committed
857 858
		struct hlist_node *node;

859
		sk_for_each(sk, node, &state->h->ht[state->bucket])
860
			if (sock_net(sk) == seq_file_net(seq))
Linus Torvalds's avatar
Linus Torvalds committed
861 862 863 864 865 866 867 868 869 870 871 872 873 874 875
				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:
		;
876
	} while (sk && sock_net(sk) != seq_file_net(seq));
Linus Torvalds's avatar
Linus Torvalds committed
877

878
	if (!sk && ++state->bucket < RAW_HTABLE_SIZE) {
879
		sk = sk_head(&state->h->ht[state->bucket]);
Linus Torvalds's avatar
Linus Torvalds committed
880 881 882 883 884 885 886 887 888 889 890 891 892 893 894
		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;
}

895
void *raw_seq_start(struct seq_file *seq, loff_t *pos)
Linus Torvalds's avatar
Linus Torvalds committed
896
{
897 898 899
	struct raw_iter_state *state = raw_seq_private(seq);

	read_lock(&state->h->lock);
Linus Torvalds's avatar
Linus Torvalds committed
900 901
	return *pos ? raw_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
}
902
EXPORT_SYMBOL_GPL(raw_seq_start);
Linus Torvalds's avatar
Linus Torvalds committed
903

904
void *raw_seq_next(struct seq_file *seq, void *v, loff_t *pos)
Linus Torvalds's avatar
Linus Torvalds committed
905 906 907 908 909 910 911 912 913 914
{
	struct sock *sk;

	if (v == SEQ_START_TOKEN)
		sk = raw_get_first(seq);
	else
		sk = raw_get_next(seq, v);
	++*pos;
	return sk;
}
915
EXPORT_SYMBOL_GPL(raw_seq_next);
Linus Torvalds's avatar
Linus Torvalds committed
916

917
void raw_seq_stop(struct seq_file *seq, void *v)
Linus Torvalds's avatar
Linus Torvalds committed
918
{
919 920 921
	struct raw_iter_state *state = raw_seq_private(seq);

	read_unlock(&state->h->lock);
Linus Torvalds's avatar
Linus Torvalds committed
922
}
923
EXPORT_SYMBOL_GPL(raw_seq_stop);
Linus Torvalds's avatar
Linus Torvalds committed
924

925
static void raw_sock_seq_show(struct seq_file *seq, struct sock *sp, int i)
Linus Torvalds's avatar
Linus Torvalds committed
926 927
{
	struct inet_sock *inet = inet_sk(sp);
928 929
	__be32 dest = inet->daddr,
	       src = inet->rcv_saddr;
Linus Torvalds's avatar
Linus Torvalds committed
930 931 932
	__u16 destp = 0,
	      srcp  = inet->num;

933
	seq_printf(seq, "%4d: %08X:%04X %08X:%04X"
Wang Chen's avatar
Wang Chen committed
934
		" %02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %d",
935
		i, src, srcp, dest, destp, sp->sk_state,
Linus Torvalds's avatar
Linus Torvalds committed
936 937 938
		atomic_read(&sp->sk_wmem_alloc),
		atomic_read(&sp->sk_rmem_alloc),
		0, 0L, 0, sock_i_uid(sp), 0, sock_i_ino(sp),
Wang Chen's avatar
Wang Chen committed
939
		atomic_read(&sp->sk_refcnt), sp, atomic_read(&sp->sk_drops));
Linus Torvalds's avatar
Linus Torvalds committed
940 941 942 943 944
}

static int raw_seq_show(struct seq_file *seq, void *v)
{
	if (v == SEQ_START_TOKEN)
945 946 947 948 949
		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);
Linus Torvalds's avatar
Linus Torvalds committed
950 951 952
	return 0;
}

953
static const struct seq_operations raw_seq_ops = {
Linus Torvalds's avatar
Linus Torvalds committed
954 955 956 957 958 959
	.start = raw_seq_start,
	.next  = raw_seq_next,
	.stop  = raw_seq_stop,
	.show  = raw_seq_show,
};

960 961
int raw_seq_open(struct inode *ino, struct file *file,
		 struct raw_hashinfo *h, const struct seq_operations *ops)
Linus Torvalds's avatar
Linus Torvalds committed
962
{
963
	int err;
964 965
	struct raw_iter_state *i;

966
	err = seq_open_net(ino, file, ops, sizeof(struct raw_iter_state));
967 968
	if (err < 0)
		return err;
969

970
	i = raw_seq_private((struct seq_file *)file->private_data);
971 972 973 974 975 976 977
	i->h = h;
	return 0;
}
EXPORT_SYMBOL_GPL(raw_seq_open);

static int raw_v4_seq_open(struct inode *inode, struct file *file)
{
978
	return raw_seq_open(inode, file, &raw_v4_hashinfo, &raw_seq_ops);
Linus Torvalds's avatar
Linus Torvalds committed
979 980
}

981
static const struct file_operations raw_seq_fops = {
Linus Torvalds's avatar
Linus Torvalds committed
982
	.owner	 = THIS_MODULE,
983
	.open	 = raw_v4_seq_open,
Linus Torvalds's avatar
Linus Torvalds committed
984 985
	.read	 = seq_read,
	.llseek	 = seq_lseek,
986
	.release = seq_release_net,
Linus Torvalds's avatar
Linus Torvalds committed
987 988
};

989
static __net_init int raw_init_net(struct net *net)
Linus Torvalds's avatar
Linus Torvalds committed
990
{
991
	if (!proc_net_fops_create(net, "raw", S_IRUGO, &raw_seq_fops))
Linus Torvalds's avatar
Linus Torvalds committed
992
		return -ENOMEM;
993

Linus Torvalds's avatar
Linus Torvalds committed
994 995 996
	return 0;
}

997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
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);
}

Linus Torvalds's avatar
Linus Torvalds committed
1012 1013
void __init raw_proc_exit(void)
{
1014
	unregister_pernet_subsys(&raw_net_ops);
Linus Torvalds's avatar
Linus Torvalds committed
1015 1016
}
#endif /* CONFIG_PROC_FS */