af_inet.c revision bf0d52492d82ad70684e17c8a46942c13d0e140e 
1/*
2 * INET		An implementation of the TCP/IP protocol suite for the LINUX
3 *		operating system.  INET is implemented using the  BSD Socket
4 *		interface as the means of communication with the user level.
5 *
6 *		PF_INET protocol family socket handler.
7 *
8 * Version:	$Id: af_inet.c,v 1.137 2002/02/01 22:01:03 davem Exp $
9 *
10 * Authors:	Ross Biro
11 *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 *		Florian La Roche, <flla@stud.uni-sb.de>
13 *		Alan Cox, <A.Cox@swansea.ac.uk>
14 *
15 * Changes (see also sock.c)
16 *
17 *		piggy,
18 *		Karl Knutson	:	Socket protocol table
19 *		A.N.Kuznetsov	:	Socket death error in accept().
20 *		John Richardson :	Fix non blocking error in connect()
21 *					so sockets that fail to connect
22 *					don't return -EINPROGRESS.
23 *		Alan Cox	:	Asynchronous I/O support
24 *		Alan Cox	:	Keep correct socket pointer on sock
25 *					structures
26 *					when accept() ed
27 *		Alan Cox	:	Semantics of SO_LINGER aren't state
28 *					moved to close when you look carefully.
29 *					With this fixed and the accept bug fixed
30 *					some RPC stuff seems happier.
31 *		Niibe Yutaka	:	4.4BSD style write async I/O
32 *		Alan Cox,
33 *		Tony Gale 	:	Fixed reuse semantics.
34 *		Alan Cox	:	bind() shouldn't abort existing but dead
35 *					sockets. Stops FTP netin:.. I hope.
36 *		Alan Cox	:	bind() works correctly for RAW sockets.
37 *					Note that FreeBSD at least was broken
38 *					in this respect so be careful with
39 *					compatibility tests...
40 *		Alan Cox	:	routing cache support
41 *		Alan Cox	:	memzero the socket structure for
42 *					compactness.
43 *		Matt Day	:	nonblock connect error handler
44 *		Alan Cox	:	Allow large numbers of pending sockets
45 *					(eg for big web sites), but only if
46 *					specifically application requested.
47 *		Alan Cox	:	New buffering throughout IP. Used
48 *					dumbly.
49 *		Alan Cox	:	New buffering now used smartly.
50 *		Alan Cox	:	BSD rather than common sense
51 *					interpretation of listen.
52 *		Germano Caronni	:	Assorted small races.
53 *		Alan Cox	:	sendmsg/recvmsg basic support.
54 *		Alan Cox	:	Only sendmsg/recvmsg now supported.
55 *		Alan Cox	:	Locked down bind (see security list).
56 *		Alan Cox	:	Loosened bind a little.
57 *		Mike McLagan	:	ADD/DEL DLCI Ioctls
58 *	Willy Konynenberg	:	Transparent proxying support.
59 *		David S. Miller	:	New socket lookup architecture.
60 *					Some other random speedups.
61 *		Cyrus Durgin	:	Cleaned up file for kmod hacks.
62 *		Andi Kleen	:	Fix inet_stream_connect TCP race.
63 *
64 *		This program is free software; you can redistribute it and/or
65 *		modify it under the terms of the GNU General Public License
66 *		as published by the Free Software Foundation; either version
67 *		2 of the License, or (at your option) any later version.
68 */
69
70#include <linux/err.h>
71#include <linux/errno.h>
72#include <linux/types.h>
73#include <linux/socket.h>
74#include <linux/in.h>
75#include <linux/kernel.h>
76#include <linux/module.h>
77#include <linux/sched.h>
78#include <linux/timer.h>
79#include <linux/string.h>
80#include <linux/sockios.h>
81#include <linux/net.h>
82#include <linux/capability.h>
83#include <linux/fcntl.h>
84#include <linux/mm.h>
85#include <linux/interrupt.h>
86#include <linux/stat.h>
87#include <linux/init.h>
88#include <linux/poll.h>
89#include <linux/netfilter_ipv4.h>
90
91#include <asm/uaccess.h>
92#include <asm/system.h>
93
94#include <linux/smp_lock.h>
95#include <linux/inet.h>
96#include <linux/igmp.h>
97#include <linux/inetdevice.h>
98#include <linux/netdevice.h>
99#include <net/ip.h>
100#include <net/protocol.h>
101#include <net/arp.h>
102#include <net/route.h>
103#include <net/ip_fib.h>
104#include <net/inet_connection_sock.h>
105#include <net/tcp.h>
106#include <net/udp.h>
107#include <linux/skbuff.h>
108#include <net/sock.h>
109#include <net/raw.h>
110#include <net/icmp.h>
111#include <net/ipip.h>
112#include <net/inet_common.h>
113#include <net/xfrm.h>
114#ifdef CONFIG_IP_MROUTE
115#include <linux/mroute.h>
116#endif
117
118DEFINE_SNMP_STAT(struct linux_mib, net_statistics) __read_mostly;
119
120extern void ip_mc_drop_socket(struct sock *sk);
121
122/* The inetsw table contains everything that inet_create needs to
123 * build a new socket.
124 */
125static struct list_head inetsw[SOCK_MAX];
126static DEFINE_SPINLOCK(inetsw_lock);
127
128/* New destruction routine */
129
130void inet_sock_destruct(struct sock *sk)
131{
132	struct inet_sock *inet = inet_sk(sk);
133
134	__skb_queue_purge(&sk->sk_receive_queue);
135	__skb_queue_purge(&sk->sk_error_queue);
136
137	if (sk->sk_type == SOCK_STREAM && sk->sk_state != TCP_CLOSE) {
138		printk("Attempt to release TCP socket in state %d %p\n",
139		       sk->sk_state, sk);
140		return;
141	}
142	if (!sock_flag(sk, SOCK_DEAD)) {
143		printk("Attempt to release alive inet socket %p\n", sk);
144		return;
145	}
146
147	BUG_TRAP(!atomic_read(&sk->sk_rmem_alloc));
148	BUG_TRAP(!atomic_read(&sk->sk_wmem_alloc));
149	BUG_TRAP(!sk->sk_wmem_queued);
150	BUG_TRAP(!sk->sk_forward_alloc);
151
152	kfree(inet->opt);
153	dst_release(sk->sk_dst_cache);
154	sk_refcnt_debug_dec(sk);
155}
156
157/*
158 *	The routines beyond this point handle the behaviour of an AF_INET
159 *	socket object. Mostly it punts to the subprotocols of IP to do
160 *	the work.
161 */
162
163/*
164 *	Automatically bind an unbound socket.
165 */
166
167static int inet_autobind(struct sock *sk)
168{
169	struct inet_sock *inet;
170	/* We may need to bind the socket. */
171	lock_sock(sk);
172	inet = inet_sk(sk);
173	if (!inet->num) {
174		if (sk->sk_prot->get_port(sk, 0)) {
175			release_sock(sk);
176			return -EAGAIN;
177		}
178		inet->sport = htons(inet->num);
179	}
180	release_sock(sk);
181	return 0;
182}
183
184/*
185 *	Move a socket into listening state.
186 */
187int inet_listen(struct socket *sock, int backlog)
188{
189	struct sock *sk = sock->sk;
190	unsigned char old_state;
191	int err;
192
193	lock_sock(sk);
194
195	err = -EINVAL;
196	if (sock->state != SS_UNCONNECTED || sock->type != SOCK_STREAM)
197		goto out;
198
199	old_state = sk->sk_state;
200	if (!((1 << old_state) & (TCPF_CLOSE | TCPF_LISTEN)))
201		goto out;
202
203	/* Really, if the socket is already in listen state
204	 * we can only allow the backlog to be adjusted.
205	 */
206	if (old_state != TCP_LISTEN) {
207		err = inet_csk_listen_start(sk, TCP_SYNQ_HSIZE);
208		if (err)
209			goto out;
210	}
211	sk->sk_max_ack_backlog = backlog;
212	err = 0;
213
214out:
215	release_sock(sk);
216	return err;
217}
218
219/*
220 *	Create an inet socket.
221 */
222
223static int inet_create(struct socket *sock, int protocol)
224{
225	struct sock *sk;
226	struct list_head *p;
227	struct inet_protosw *answer;
228	struct inet_sock *inet;
229	struct proto *answer_prot;
230	unsigned char answer_flags;
231	char answer_no_check;
232	int try_loading_module = 0;
233	int err;
234
235	sock->state = SS_UNCONNECTED;
236
237	/* Look for the requested type/protocol pair. */
238	answer = NULL;
239lookup_protocol:
240	err = -ESOCKTNOSUPPORT;
241	rcu_read_lock();
242	list_for_each_rcu(p, &inetsw[sock->type]) {
243		answer = list_entry(p, struct inet_protosw, list);
244
245		/* Check the non-wild match. */
246		if (protocol == answer->protocol) {
247			if (protocol != IPPROTO_IP)
248				break;
249		} else {
250			/* Check for the two wild cases. */
251			if (IPPROTO_IP == protocol) {
252				protocol = answer->protocol;
253				break;
254			}
255			if (IPPROTO_IP == answer->protocol)
256				break;
257		}
258		err = -EPROTONOSUPPORT;
259		answer = NULL;
260	}
261
262	if (unlikely(answer == NULL)) {
263		if (try_loading_module < 2) {
264			rcu_read_unlock();
265			/*
266			 * Be more specific, e.g. net-pf-2-proto-132-type-1
267			 * (net-pf-PF_INET-proto-IPPROTO_SCTP-type-SOCK_STREAM)
268			 */
269			if (++try_loading_module == 1)
270				request_module("net-pf-%d-proto-%d-type-%d",
271					       PF_INET, protocol, sock->type);
272			/*
273			 * Fall back to generic, e.g. net-pf-2-proto-132
274			 * (net-pf-PF_INET-proto-IPPROTO_SCTP)
275			 */
276			else
277				request_module("net-pf-%d-proto-%d",
278					       PF_INET, protocol);
279			goto lookup_protocol;
280		} else
281			goto out_rcu_unlock;
282	}
283
284	err = -EPERM;
285	if (answer->capability > 0 && !capable(answer->capability))
286		goto out_rcu_unlock;
287
288	sock->ops = answer->ops;
289	answer_prot = answer->prot;
290	answer_no_check = answer->no_check;
291	answer_flags = answer->flags;
292	rcu_read_unlock();
293
294	BUG_TRAP(answer_prot->slab != NULL);
295
296	err = -ENOBUFS;
297	sk = sk_alloc(PF_INET, GFP_KERNEL, answer_prot, 1);
298	if (sk == NULL)
299		goto out;
300
301	err = 0;
302	sk->sk_no_check = answer_no_check;
303	if (INET_PROTOSW_REUSE & answer_flags)
304		sk->sk_reuse = 1;
305
306	inet = inet_sk(sk);
307	inet->is_icsk = INET_PROTOSW_ICSK & answer_flags;
308
309	if (SOCK_RAW == sock->type) {
310		inet->num = protocol;
311		if (IPPROTO_RAW == protocol)
312			inet->hdrincl = 1;
313	}
314
315	if (ipv4_config.no_pmtu_disc)
316		inet->pmtudisc = IP_PMTUDISC_DONT;
317	else
318		inet->pmtudisc = IP_PMTUDISC_WANT;
319
320	inet->id = 0;
321
322	sock_init_data(sock, sk);
323
324	sk->sk_destruct	   = inet_sock_destruct;
325	sk->sk_family	   = PF_INET;
326	sk->sk_protocol	   = protocol;
327	sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
328
329	inet->uc_ttl	= -1;
330	inet->mc_loop	= 1;
331	inet->mc_ttl	= 1;
332	inet->mc_index	= 0;
333	inet->mc_list	= NULL;
334
335	sk_refcnt_debug_inc(sk);
336
337	if (inet->num) {
338		/* It assumes that any protocol which allows
339		 * the user to assign a number at socket
340		 * creation time automatically
341		 * shares.
342		 */
343		inet->sport = htons(inet->num);
344		/* Add to protocol hash chains. */
345		sk->sk_prot->hash(sk);
346	}
347
348	if (sk->sk_prot->init) {
349		err = sk->sk_prot->init(sk);
350		if (err)
351			sk_common_release(sk);
352	}
353out:
354	return err;
355out_rcu_unlock:
356	rcu_read_unlock();
357	goto out;
358}
359
360
361/*
362 *	The peer socket should always be NULL (or else). When we call this
363 *	function we are destroying the object and from then on nobody
364 *	should refer to it.
365 */
366int inet_release(struct socket *sock)
367{
368	struct sock *sk = sock->sk;
369
370	if (sk) {
371		long timeout;
372
373		/* Applications forget to leave groups before exiting */
374		ip_mc_drop_socket(sk);
375
376		/* If linger is set, we don't return until the close
377		 * is complete.  Otherwise we return immediately. The
378		 * actually closing is done the same either way.
379		 *
380		 * If the close is due to the process exiting, we never
381		 * linger..
382		 */
383		timeout = 0;
384		if (sock_flag(sk, SOCK_LINGER) &&
385		    !(current->flags & PF_EXITING))
386			timeout = sk->sk_lingertime;
387		sock->sk = NULL;
388		sk->sk_prot->close(sk, timeout);
389	}
390	return 0;
391}
392
393/* It is off by default, see below. */
394int sysctl_ip_nonlocal_bind;
395
396int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
397{
398	struct sockaddr_in *addr = (struct sockaddr_in *)uaddr;
399	struct sock *sk = sock->sk;
400	struct inet_sock *inet = inet_sk(sk);
401	unsigned short snum;
402	int chk_addr_ret;
403	int err;
404
405	/* If the socket has its own bind function then use it. (RAW) */
406	if (sk->sk_prot->bind) {
407		err = sk->sk_prot->bind(sk, uaddr, addr_len);
408		goto out;
409	}
410	err = -EINVAL;
411	if (addr_len < sizeof(struct sockaddr_in))
412		goto out;
413
414	chk_addr_ret = inet_addr_type(addr->sin_addr.s_addr);
415
416	/* Not specified by any standard per-se, however it breaks too
417	 * many applications when removed.  It is unfortunate since
418	 * allowing applications to make a non-local bind solves
419	 * several problems with systems using dynamic addressing.
420	 * (ie. your servers still start up even if your ISDN link
421	 *  is temporarily down)
422	 */
423	err = -EADDRNOTAVAIL;
424	if (!sysctl_ip_nonlocal_bind &&
425	    !inet->freebind &&
426	    addr->sin_addr.s_addr != INADDR_ANY &&
427	    chk_addr_ret != RTN_LOCAL &&
428	    chk_addr_ret != RTN_MULTICAST &&
429	    chk_addr_ret != RTN_BROADCAST)
430		goto out;
431
432	snum = ntohs(addr->sin_port);
433	err = -EACCES;
434	if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))
435		goto out;
436
437	/*      We keep a pair of addresses. rcv_saddr is the one
438	 *      used by hash lookups, and saddr is used for transmit.
439	 *
440	 *      In the BSD API these are the same except where it
441	 *      would be illegal to use them (multicast/broadcast) in
442	 *      which case the sending device address is used.
443	 */
444	lock_sock(sk);
445
446	/* Check these errors (active socket, double bind). */
447	err = -EINVAL;
448	if (sk->sk_state != TCP_CLOSE || inet->num)
449		goto out_release_sock;
450
451	inet->rcv_saddr = inet->saddr = addr->sin_addr.s_addr;
452	if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
453		inet->saddr = 0;  /* Use device */
454
455	/* Make sure we are allowed to bind here. */
456	if (sk->sk_prot->get_port(sk, snum)) {
457		inet->saddr = inet->rcv_saddr = 0;
458		err = -EADDRINUSE;
459		goto out_release_sock;
460	}
461
462	if (inet->rcv_saddr)
463		sk->sk_userlocks |= SOCK_BINDADDR_LOCK;
464	if (snum)
465		sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
466	inet->sport = htons(inet->num);
467	inet->daddr = 0;
468	inet->dport = 0;
469	sk_dst_reset(sk);
470	err = 0;
471out_release_sock:
472	release_sock(sk);
473out:
474	return err;
475}
476
477int inet_dgram_connect(struct socket *sock, struct sockaddr * uaddr,
478		       int addr_len, int flags)
479{
480	struct sock *sk = sock->sk;
481
482	if (uaddr->sa_family == AF_UNSPEC)
483		return sk->sk_prot->disconnect(sk, flags);
484
485	if (!inet_sk(sk)->num && inet_autobind(sk))
486		return -EAGAIN;
487	return sk->sk_prot->connect(sk, (struct sockaddr *)uaddr, addr_len);
488}
489
490static long inet_wait_for_connect(struct sock *sk, long timeo)
491{
492	DEFINE_WAIT(wait);
493
494	prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
495
496	/* Basic assumption: if someone sets sk->sk_err, he _must_
497	 * change state of the socket from TCP_SYN_*.
498	 * Connect() does not allow to get error notifications
499	 * without closing the socket.
500	 */
501	while ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
502		release_sock(sk);
503		timeo = schedule_timeout(timeo);
504		lock_sock(sk);
505		if (signal_pending(current) || !timeo)
506			break;
507		prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
508	}
509	finish_wait(sk->sk_sleep, &wait);
510	return timeo;
511}
512
513/*
514 *	Connect to a remote host. There is regrettably still a little
515 *	TCP 'magic' in here.
516 */
517int inet_stream_connect(struct socket *sock, struct sockaddr *uaddr,
518			int addr_len, int flags)
519{
520	struct sock *sk = sock->sk;
521	int err;
522	long timeo;
523
524	lock_sock(sk);
525
526	if (uaddr->sa_family == AF_UNSPEC) {
527		err = sk->sk_prot->disconnect(sk, flags);
528		sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED;
529		goto out;
530	}
531
532	switch (sock->state) {
533	default:
534		err = -EINVAL;
535		goto out;
536	case SS_CONNECTED:
537		err = -EISCONN;
538		goto out;
539	case SS_CONNECTING:
540		err = -EALREADY;
541		/* Fall out of switch with err, set for this state */
542		break;
543	case SS_UNCONNECTED:
544		err = -EISCONN;
545		if (sk->sk_state != TCP_CLOSE)
546			goto out;
547
548		err = sk->sk_prot->connect(sk, uaddr, addr_len);
549		if (err < 0)
550			goto out;
551
552  		sock->state = SS_CONNECTING;
553
554		/* Just entered SS_CONNECTING state; the only
555		 * difference is that return value in non-blocking
556		 * case is EINPROGRESS, rather than EALREADY.
557		 */
558		err = -EINPROGRESS;
559		break;
560	}
561
562	timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
563
564	if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
565		/* Error code is set above */
566		if (!timeo || !inet_wait_for_connect(sk, timeo))
567			goto out;
568
569		err = sock_intr_errno(timeo);
570		if (signal_pending(current))
571			goto out;
572	}
573
574	/* Connection was closed by RST, timeout, ICMP error
575	 * or another process disconnected us.
576	 */
577	if (sk->sk_state == TCP_CLOSE)
578		goto sock_error;
579
580	/* sk->sk_err may be not zero now, if RECVERR was ordered by user
581	 * and error was received after socket entered established state.
582	 * Hence, it is handled normally after connect() return successfully.
583	 */
584
585	sock->state = SS_CONNECTED;
586	err = 0;
587out:
588	release_sock(sk);
589	return err;
590
591sock_error:
592	err = sock_error(sk) ? : -ECONNABORTED;
593	sock->state = SS_UNCONNECTED;
594	if (sk->sk_prot->disconnect(sk, flags))
595		sock->state = SS_DISCONNECTING;
596	goto out;
597}
598
599/*
600 *	Accept a pending connection. The TCP layer now gives BSD semantics.
601 */
602
603int inet_accept(struct socket *sock, struct socket *newsock, int flags)
604{
605	struct sock *sk1 = sock->sk;
606	int err = -EINVAL;
607	struct sock *sk2 = sk1->sk_prot->accept(sk1, flags, &err);
608
609	if (!sk2)
610		goto do_err;
611
612	lock_sock(sk2);
613
614	BUG_TRAP((1 << sk2->sk_state) &
615		 (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_CLOSE));
616
617	sock_graft(sk2, newsock);
618
619	newsock->state = SS_CONNECTED;
620	err = 0;
621	release_sock(sk2);
622do_err:
623	return err;
624}
625
626
627/*
628 *	This does both peername and sockname.
629 */
630int inet_getname(struct socket *sock, struct sockaddr *uaddr,
631			int *uaddr_len, int peer)
632{
633	struct sock *sk		= sock->sk;
634	struct inet_sock *inet	= inet_sk(sk);
635	struct sockaddr_in *sin	= (struct sockaddr_in *)uaddr;
636
637	sin->sin_family = AF_INET;
638	if (peer) {
639		if (!inet->dport ||
640		    (((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_SYN_SENT)) &&
641		     peer == 1))
642			return -ENOTCONN;
643		sin->sin_port = inet->dport;
644		sin->sin_addr.s_addr = inet->daddr;
645	} else {
646		__u32 addr = inet->rcv_saddr;
647		if (!addr)
648			addr = inet->saddr;
649		sin->sin_port = inet->sport;
650		sin->sin_addr.s_addr = addr;
651	}
652	memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
653	*uaddr_len = sizeof(*sin);
654	return 0;
655}
656
657int inet_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
658		 size_t size)
659{
660	struct sock *sk = sock->sk;
661
662	/* We may need to bind the socket. */
663	if (!inet_sk(sk)->num && inet_autobind(sk))
664		return -EAGAIN;
665
666	return sk->sk_prot->sendmsg(iocb, sk, msg, size);
667}
668
669
670static ssize_t inet_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
671{
672	struct sock *sk = sock->sk;
673
674	/* We may need to bind the socket. */
675	if (!inet_sk(sk)->num && inet_autobind(sk))
676		return -EAGAIN;
677
678	if (sk->sk_prot->sendpage)
679		return sk->sk_prot->sendpage(sk, page, offset, size, flags);
680	return sock_no_sendpage(sock, page, offset, size, flags);
681}
682
683
684int inet_shutdown(struct socket *sock, int how)
685{
686	struct sock *sk = sock->sk;
687	int err = 0;
688
689	/* This should really check to make sure
690	 * the socket is a TCP socket. (WHY AC...)
691	 */
692	how++; /* maps 0->1 has the advantage of making bit 1 rcvs and
693		       1->2 bit 2 snds.
694		       2->3 */
695	if ((how & ~SHUTDOWN_MASK) || !how)	/* MAXINT->0 */
696		return -EINVAL;
697
698	lock_sock(sk);
699	if (sock->state == SS_CONNECTING) {
700		if ((1 << sk->sk_state) &
701		    (TCPF_SYN_SENT | TCPF_SYN_RECV | TCPF_CLOSE))
702			sock->state = SS_DISCONNECTING;
703		else
704			sock->state = SS_CONNECTED;
705	}
706
707	switch (sk->sk_state) {
708	case TCP_CLOSE:
709		err = -ENOTCONN;
710		/* Hack to wake up other listeners, who can poll for
711		   POLLHUP, even on eg. unconnected UDP sockets -- RR */
712	default:
713		sk->sk_shutdown |= how;
714		if (sk->sk_prot->shutdown)
715			sk->sk_prot->shutdown(sk, how);
716		break;
717
718	/* Remaining two branches are temporary solution for missing
719	 * close() in multithreaded environment. It is _not_ a good idea,
720	 * but we have no choice until close() is repaired at VFS level.
721	 */
722	case TCP_LISTEN:
723		if (!(how & RCV_SHUTDOWN))
724			break;
725		/* Fall through */
726	case TCP_SYN_SENT:
727		err = sk->sk_prot->disconnect(sk, O_NONBLOCK);
728		sock->state = err ? SS_DISCONNECTING : SS_UNCONNECTED;
729		break;
730	}
731
732	/* Wake up anyone sleeping in poll. */
733	sk->sk_state_change(sk);
734	release_sock(sk);
735	return err;
736}
737
738/*
739 *	ioctl() calls you can issue on an INET socket. Most of these are
740 *	device configuration and stuff and very rarely used. Some ioctls
741 *	pass on to the socket itself.
742 *
743 *	NOTE: I like the idea of a module for the config stuff. ie ifconfig
744 *	loads the devconfigure module does its configuring and unloads it.
745 *	There's a good 20K of config code hanging around the kernel.
746 */
747
748int inet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
749{
750	struct sock *sk = sock->sk;
751	int err = 0;
752
753	switch (cmd) {
754		case SIOCGSTAMP:
755			err = sock_get_timestamp(sk, (struct timeval __user *)arg);
756			break;
757		case SIOCADDRT:
758		case SIOCDELRT:
759		case SIOCRTMSG:
760			err = ip_rt_ioctl(cmd, (void __user *)arg);
761			break;
762		case SIOCDARP:
763		case SIOCGARP:
764		case SIOCSARP:
765			err = arp_ioctl(cmd, (void __user *)arg);
766			break;
767		case SIOCGIFADDR:
768		case SIOCSIFADDR:
769		case SIOCGIFBRDADDR:
770		case SIOCSIFBRDADDR:
771		case SIOCGIFNETMASK:
772		case SIOCSIFNETMASK:
773		case SIOCGIFDSTADDR:
774		case SIOCSIFDSTADDR:
775		case SIOCSIFPFLAGS:
776		case SIOCGIFPFLAGS:
777		case SIOCSIFFLAGS:
778			err = devinet_ioctl(cmd, (void __user *)arg);
779			break;
780		default:
781			if (sk->sk_prot->ioctl)
782				err = sk->sk_prot->ioctl(sk, cmd, arg);
783			else
784				err = -ENOIOCTLCMD;
785			break;
786	}
787	return err;
788}
789
790const struct proto_ops inet_stream_ops = {
791	.family		   = PF_INET,
792	.owner		   = THIS_MODULE,
793	.release	   = inet_release,
794	.bind		   = inet_bind,
795	.connect	   = inet_stream_connect,
796	.socketpair	   = sock_no_socketpair,
797	.accept		   = inet_accept,
798	.getname	   = inet_getname,
799	.poll		   = tcp_poll,
800	.ioctl		   = inet_ioctl,
801	.listen		   = inet_listen,
802	.shutdown	   = inet_shutdown,
803	.setsockopt	   = sock_common_setsockopt,
804	.getsockopt	   = sock_common_getsockopt,
805	.sendmsg	   = inet_sendmsg,
806	.recvmsg	   = sock_common_recvmsg,
807	.mmap		   = sock_no_mmap,
808	.sendpage	   = tcp_sendpage,
809#ifdef CONFIG_COMPAT
810	.compat_setsockopt = compat_sock_common_setsockopt,
811	.compat_getsockopt = compat_sock_common_getsockopt,
812#endif
813};
814
815const struct proto_ops inet_dgram_ops = {
816	.family		   = PF_INET,
817	.owner		   = THIS_MODULE,
818	.release	   = inet_release,
819	.bind		   = inet_bind,
820	.connect	   = inet_dgram_connect,
821	.socketpair	   = sock_no_socketpair,
822	.accept		   = sock_no_accept,
823	.getname	   = inet_getname,
824	.poll		   = udp_poll,
825	.ioctl		   = inet_ioctl,
826	.listen		   = sock_no_listen,
827	.shutdown	   = inet_shutdown,
828	.setsockopt	   = sock_common_setsockopt,
829	.getsockopt	   = sock_common_getsockopt,
830	.sendmsg	   = inet_sendmsg,
831	.recvmsg	   = sock_common_recvmsg,
832	.mmap		   = sock_no_mmap,
833	.sendpage	   = inet_sendpage,
834#ifdef CONFIG_COMPAT
835	.compat_setsockopt = compat_sock_common_setsockopt,
836	.compat_getsockopt = compat_sock_common_getsockopt,
837#endif
838};
839
840/*
841 * For SOCK_RAW sockets; should be the same as inet_dgram_ops but without
842 * udp_poll
843 */
844static const struct proto_ops inet_sockraw_ops = {
845	.family		   = PF_INET,
846	.owner		   = THIS_MODULE,
847	.release	   = inet_release,
848	.bind		   = inet_bind,
849	.connect	   = inet_dgram_connect,
850	.socketpair	   = sock_no_socketpair,
851	.accept		   = sock_no_accept,
852	.getname	   = inet_getname,
853	.poll		   = datagram_poll,
854	.ioctl		   = inet_ioctl,
855	.listen		   = sock_no_listen,
856	.shutdown	   = inet_shutdown,
857	.setsockopt	   = sock_common_setsockopt,
858	.getsockopt	   = sock_common_getsockopt,
859	.sendmsg	   = inet_sendmsg,
860	.recvmsg	   = sock_common_recvmsg,
861	.mmap		   = sock_no_mmap,
862	.sendpage	   = inet_sendpage,
863#ifdef CONFIG_COMPAT
864	.compat_setsockopt = compat_sock_common_setsockopt,
865	.compat_getsockopt = compat_sock_common_getsockopt,
866#endif
867};
868
869static struct net_proto_family inet_family_ops = {
870	.family = PF_INET,
871	.create = inet_create,
872	.owner	= THIS_MODULE,
873};
874
875/* Upon startup we insert all the elements in inetsw_array[] into
876 * the linked list inetsw.
877 */
878static struct inet_protosw inetsw_array[] =
879{
880        {
881                .type =       SOCK_STREAM,
882                .protocol =   IPPROTO_TCP,
883                .prot =       &tcp_prot,
884                .ops =        &inet_stream_ops,
885                .capability = -1,
886                .no_check =   0,
887                .flags =      INET_PROTOSW_PERMANENT |
888			      INET_PROTOSW_ICSK,
889        },
890
891        {
892                .type =       SOCK_DGRAM,
893                .protocol =   IPPROTO_UDP,
894                .prot =       &udp_prot,
895                .ops =        &inet_dgram_ops,
896                .capability = -1,
897                .no_check =   UDP_CSUM_DEFAULT,
898                .flags =      INET_PROTOSW_PERMANENT,
899       },
900
901
902       {
903               .type =       SOCK_RAW,
904               .protocol =   IPPROTO_IP,	/* wild card */
905               .prot =       &raw_prot,
906               .ops =        &inet_sockraw_ops,
907               .capability = CAP_NET_RAW,
908               .no_check =   UDP_CSUM_DEFAULT,
909               .flags =      INET_PROTOSW_REUSE,
910       }
911};
912
913#define INETSW_ARRAY_LEN (sizeof(inetsw_array) / sizeof(struct inet_protosw))
914
915void inet_register_protosw(struct inet_protosw *p)
916{
917	struct list_head *lh;
918	struct inet_protosw *answer;
919	int protocol = p->protocol;
920	struct list_head *last_perm;
921
922	spin_lock_bh(&inetsw_lock);
923
924	if (p->type >= SOCK_MAX)
925		goto out_illegal;
926
927	/* If we are trying to override a permanent protocol, bail. */
928	answer = NULL;
929	last_perm = &inetsw[p->type];
930	list_for_each(lh, &inetsw[p->type]) {
931		answer = list_entry(lh, struct inet_protosw, list);
932
933		/* Check only the non-wild match. */
934		if (INET_PROTOSW_PERMANENT & answer->flags) {
935			if (protocol == answer->protocol)
936				break;
937			last_perm = lh;
938		}
939
940		answer = NULL;
941	}
942	if (answer)
943		goto out_permanent;
944
945	/* Add the new entry after the last permanent entry if any, so that
946	 * the new entry does not override a permanent entry when matched with
947	 * a wild-card protocol. But it is allowed to override any existing
948	 * non-permanent entry.  This means that when we remove this entry, the
949	 * system automatically returns to the old behavior.
950	 */
951	list_add_rcu(&p->list, last_perm);
952out:
953	spin_unlock_bh(&inetsw_lock);
954
955	synchronize_net();
956
957	return;
958
959out_permanent:
960	printk(KERN_ERR "Attempt to override permanent protocol %d.\n",
961	       protocol);
962	goto out;
963
964out_illegal:
965	printk(KERN_ERR
966	       "Ignoring attempt to register invalid socket type %d.\n",
967	       p->type);
968	goto out;
969}
970
971void inet_unregister_protosw(struct inet_protosw *p)
972{
973	if (INET_PROTOSW_PERMANENT & p->flags) {
974		printk(KERN_ERR
975		       "Attempt to unregister permanent protocol %d.\n",
976		       p->protocol);
977	} else {
978		spin_lock_bh(&inetsw_lock);
979		list_del_rcu(&p->list);
980		spin_unlock_bh(&inetsw_lock);
981
982		synchronize_net();
983	}
984}
985
986/*
987 *      Shall we try to damage output packets if routing dev changes?
988 */
989
990int sysctl_ip_dynaddr;
991
992static int inet_sk_reselect_saddr(struct sock *sk)
993{
994	struct inet_sock *inet = inet_sk(sk);
995	int err;
996	struct rtable *rt;
997	__u32 old_saddr = inet->saddr;
998	__u32 new_saddr;
999	__u32 daddr = inet->daddr;
1000
1001	if (inet->opt && inet->opt->srr)
1002		daddr = inet->opt->faddr;
1003
1004	/* Query new route. */
1005	err = ip_route_connect(&rt, daddr, 0,
1006			       RT_CONN_FLAGS(sk),
1007			       sk->sk_bound_dev_if,
1008			       sk->sk_protocol,
1009			       inet->sport, inet->dport, sk);
1010	if (err)
1011		return err;
1012
1013	sk_setup_caps(sk, &rt->u.dst);
1014
1015	new_saddr = rt->rt_src;
1016
1017	if (new_saddr == old_saddr)
1018		return 0;
1019
1020	if (sysctl_ip_dynaddr > 1) {
1021		printk(KERN_INFO "%s(): shifting inet->"
1022				 "saddr from %d.%d.%d.%d to %d.%d.%d.%d\n",
1023		       __FUNCTION__,
1024		       NIPQUAD(old_saddr),
1025		       NIPQUAD(new_saddr));
1026	}
1027
1028	inet->saddr = inet->rcv_saddr = new_saddr;
1029
1030	/*
1031	 * XXX The only one ugly spot where we need to
1032	 * XXX really change the sockets identity after
1033	 * XXX it has entered the hashes. -DaveM
1034	 *
1035	 * Besides that, it does not check for connection
1036	 * uniqueness. Wait for troubles.
1037	 */
1038	__sk_prot_rehash(sk);
1039	return 0;
1040}
1041
1042int inet_sk_rebuild_header(struct sock *sk)
1043{
1044	struct inet_sock *inet = inet_sk(sk);
1045	struct rtable *rt = (struct rtable *)__sk_dst_check(sk, 0);
1046	u32 daddr;
1047	int err;
1048
1049	/* Route is OK, nothing to do. */
1050	if (rt)
1051		return 0;
1052
1053	/* Reroute. */
1054	daddr = inet->daddr;
1055	if (inet->opt && inet->opt->srr)
1056		daddr = inet->opt->faddr;
1057{
1058	struct flowi fl = {
1059		.oif = sk->sk_bound_dev_if,
1060		.nl_u = {
1061			.ip4_u = {
1062				.daddr	= daddr,
1063				.saddr	= inet->saddr,
1064				.tos	= RT_CONN_FLAGS(sk),
1065			},
1066		},
1067		.proto = sk->sk_protocol,
1068		.uli_u = {
1069			.ports = {
1070				.sport = inet->sport,
1071				.dport = inet->dport,
1072			},
1073		},
1074	};
1075
1076	security_sk_classify_flow(sk, &fl);
1077	err = ip_route_output_flow(&rt, &fl, sk, 0);
1078}
1079	if (!err)
1080		sk_setup_caps(sk, &rt->u.dst);
1081	else {
1082		/* Routing failed... */
1083		sk->sk_route_caps = 0;
1084		/*
1085		 * Other protocols have to map its equivalent state to TCP_SYN_SENT.
1086		 * DCCP maps its DCCP_REQUESTING state to TCP_SYN_SENT. -acme
1087		 */
1088		if (!sysctl_ip_dynaddr ||
1089		    sk->sk_state != TCP_SYN_SENT ||
1090		    (sk->sk_userlocks & SOCK_BINDADDR_LOCK) ||
1091		    (err = inet_sk_reselect_saddr(sk)) != 0)
1092			sk->sk_err_soft = -err;
1093	}
1094
1095	return err;
1096}
1097
1098EXPORT_SYMBOL(inet_sk_rebuild_header);
1099
1100static int inet_gso_send_check(struct sk_buff *skb)
1101{
1102	struct iphdr *iph;
1103	struct net_protocol *ops;
1104	int proto;
1105	int ihl;
1106	int err = -EINVAL;
1107
1108	if (unlikely(!pskb_may_pull(skb, sizeof(*iph))))
1109		goto out;
1110
1111	iph = skb->nh.iph;
1112	ihl = iph->ihl * 4;
1113	if (ihl < sizeof(*iph))
1114		goto out;
1115
1116	if (unlikely(!pskb_may_pull(skb, ihl)))
1117		goto out;
1118
1119	skb->h.raw = __skb_pull(skb, ihl);
1120	iph = skb->nh.iph;
1121	proto = iph->protocol & (MAX_INET_PROTOS - 1);
1122	err = -EPROTONOSUPPORT;
1123
1124	rcu_read_lock();
1125	ops = rcu_dereference(inet_protos[proto]);
1126	if (likely(ops && ops->gso_send_check))
1127		err = ops->gso_send_check(skb);
1128	rcu_read_unlock();
1129
1130out:
1131	return err;
1132}
1133
1134static struct sk_buff *inet_gso_segment(struct sk_buff *skb, int features)
1135{
1136	struct sk_buff *segs = ERR_PTR(-EINVAL);
1137	struct iphdr *iph;
1138	struct net_protocol *ops;
1139	int proto;
1140	int ihl;
1141	int id;
1142
1143	if (unlikely(skb_shinfo(skb)->gso_type &
1144		     ~(SKB_GSO_TCPV4 |
1145		       SKB_GSO_UDP |
1146		       SKB_GSO_DODGY |
1147		       SKB_GSO_TCP_ECN |
1148		       0)))
1149		goto out;
1150
1151	if (unlikely(!pskb_may_pull(skb, sizeof(*iph))))
1152		goto out;
1153
1154	iph = skb->nh.iph;
1155	ihl = iph->ihl * 4;
1156	if (ihl < sizeof(*iph))
1157		goto out;
1158
1159	if (unlikely(!pskb_may_pull(skb, ihl)))
1160		goto out;
1161
1162	skb->h.raw = __skb_pull(skb, ihl);
1163	iph = skb->nh.iph;
1164	id = ntohs(iph->id);
1165	proto = iph->protocol & (MAX_INET_PROTOS - 1);
1166	segs = ERR_PTR(-EPROTONOSUPPORT);
1167
1168	rcu_read_lock();
1169	ops = rcu_dereference(inet_protos[proto]);
1170	if (likely(ops && ops->gso_segment))
1171		segs = ops->gso_segment(skb, features);
1172	rcu_read_unlock();
1173
1174	if (!segs || unlikely(IS_ERR(segs)))
1175		goto out;
1176
1177	skb = segs;
1178	do {
1179		iph = skb->nh.iph;
1180		iph->id = htons(id++);
1181		iph->tot_len = htons(skb->len - skb->mac_len);
1182		iph->check = 0;
1183		iph->check = ip_fast_csum(skb->nh.raw, iph->ihl);
1184	} while ((skb = skb->next));
1185
1186out:
1187	return segs;
1188}
1189
1190#ifdef CONFIG_IP_MULTICAST
1191static struct net_protocol igmp_protocol = {
1192	.handler =	igmp_rcv,
1193};
1194#endif
1195
1196static struct net_protocol tcp_protocol = {
1197	.handler =	tcp_v4_rcv,
1198	.err_handler =	tcp_v4_err,
1199	.gso_send_check = tcp_v4_gso_send_check,
1200	.gso_segment =	tcp_tso_segment,
1201	.no_policy =	1,
1202};
1203
1204static struct net_protocol udp_protocol = {
1205	.handler =	udp_rcv,
1206	.err_handler =	udp_err,
1207	.no_policy =	1,
1208};
1209
1210static struct net_protocol icmp_protocol = {
1211	.handler =	icmp_rcv,
1212};
1213
1214static int __init init_ipv4_mibs(void)
1215{
1216	net_statistics[0] = alloc_percpu(struct linux_mib);
1217	net_statistics[1] = alloc_percpu(struct linux_mib);
1218	ip_statistics[0] = alloc_percpu(struct ipstats_mib);
1219	ip_statistics[1] = alloc_percpu(struct ipstats_mib);
1220	icmp_statistics[0] = alloc_percpu(struct icmp_mib);
1221	icmp_statistics[1] = alloc_percpu(struct icmp_mib);
1222	tcp_statistics[0] = alloc_percpu(struct tcp_mib);
1223	tcp_statistics[1] = alloc_percpu(struct tcp_mib);
1224	udp_statistics[0] = alloc_percpu(struct udp_mib);
1225	udp_statistics[1] = alloc_percpu(struct udp_mib);
1226	if (!
1227	    (net_statistics[0] && net_statistics[1] && ip_statistics[0]
1228	     && ip_statistics[1] && tcp_statistics[0] && tcp_statistics[1]
1229	     && udp_statistics[0] && udp_statistics[1]))
1230		return -ENOMEM;
1231
1232	(void) tcp_mib_init();
1233
1234	return 0;
1235}
1236
1237static int ipv4_proc_init(void);
1238
1239/*
1240 *	IP protocol layer initialiser
1241 */
1242
1243static struct packet_type ip_packet_type = {
1244	.type = __constant_htons(ETH_P_IP),
1245	.func = ip_rcv,
1246	.gso_send_check = inet_gso_send_check,
1247	.gso_segment = inet_gso_segment,
1248};
1249
1250static int __init inet_init(void)
1251{
1252	struct sk_buff *dummy_skb;
1253	struct inet_protosw *q;
1254	struct list_head *r;
1255	int rc = -EINVAL;
1256
1257	if (sizeof(struct inet_skb_parm) > sizeof(dummy_skb->cb)) {
1258		printk(KERN_CRIT "%s: panic\n", __FUNCTION__);
1259		goto out;
1260	}
1261
1262	rc = proto_register(&tcp_prot, 1);
1263	if (rc)
1264		goto out;
1265
1266	rc = proto_register(&udp_prot, 1);
1267	if (rc)
1268		goto out_unregister_tcp_proto;
1269
1270	rc = proto_register(&raw_prot, 1);
1271	if (rc)
1272		goto out_unregister_udp_proto;
1273
1274	/*
1275	 *	Tell SOCKET that we are alive...
1276	 */
1277
1278  	(void)sock_register(&inet_family_ops);
1279
1280	/*
1281	 *	Add all the base protocols.
1282	 */
1283
1284	if (inet_add_protocol(&icmp_protocol, IPPROTO_ICMP) < 0)
1285		printk(KERN_CRIT "inet_init: Cannot add ICMP protocol\n");
1286	if (inet_add_protocol(&udp_protocol, IPPROTO_UDP) < 0)
1287		printk(KERN_CRIT "inet_init: Cannot add UDP protocol\n");
1288	if (inet_add_protocol(&tcp_protocol, IPPROTO_TCP) < 0)
1289		printk(KERN_CRIT "inet_init: Cannot add TCP protocol\n");
1290#ifdef CONFIG_IP_MULTICAST
1291	if (inet_add_protocol(&igmp_protocol, IPPROTO_IGMP) < 0)
1292		printk(KERN_CRIT "inet_init: Cannot add IGMP protocol\n");
1293#endif
1294
1295	/* Register the socket-side information for inet_create. */
1296	for (r = &inetsw[0]; r < &inetsw[SOCK_MAX]; ++r)
1297		INIT_LIST_HEAD(r);
1298
1299	for (q = inetsw_array; q < &inetsw_array[INETSW_ARRAY_LEN]; ++q)
1300		inet_register_protosw(q);
1301
1302	/*
1303	 *	Set the ARP module up
1304	 */
1305
1306	arp_init();
1307
1308  	/*
1309  	 *	Set the IP module up
1310  	 */
1311
1312	ip_init();
1313
1314	tcp_v4_init(&inet_family_ops);
1315
1316	/* Setup TCP slab cache for open requests. */
1317	tcp_init();
1318
1319
1320	/*
1321	 *	Set the ICMP layer up
1322	 */
1323
1324	icmp_init(&inet_family_ops);
1325
1326	/*
1327	 *	Initialise the multicast router
1328	 */
1329#if defined(CONFIG_IP_MROUTE)
1330	ip_mr_init();
1331#endif
1332	/*
1333	 *	Initialise per-cpu ipv4 mibs
1334	 */
1335
1336	if(init_ipv4_mibs())
1337		printk(KERN_CRIT "inet_init: Cannot init ipv4 mibs\n"); ;
1338
1339	ipv4_proc_init();
1340
1341	ipfrag_init();
1342
1343	dev_add_pack(&ip_packet_type);
1344
1345	rc = 0;
1346out:
1347	return rc;
1348out_unregister_tcp_proto:
1349	proto_unregister(&tcp_prot);
1350out_unregister_udp_proto:
1351	proto_unregister(&udp_prot);
1352	goto out;
1353}
1354
1355fs_initcall(inet_init);
1356
1357/* ------------------------------------------------------------------------ */
1358
1359#ifdef CONFIG_PROC_FS
1360static int __init ipv4_proc_init(void)
1361{
1362	int rc = 0;
1363
1364	if (raw_proc_init())
1365		goto out_raw;
1366	if (tcp4_proc_init())
1367		goto out_tcp;
1368	if (udp4_proc_init())
1369		goto out_udp;
1370	if (fib_proc_init())
1371		goto out_fib;
1372	if (ip_misc_proc_init())
1373		goto out_misc;
1374out:
1375	return rc;
1376out_misc:
1377	fib_proc_exit();
1378out_fib:
1379	udp4_proc_exit();
1380out_udp:
1381	tcp4_proc_exit();
1382out_tcp:
1383	raw_proc_exit();
1384out_raw:
1385	rc = -ENOMEM;
1386	goto out;
1387}
1388
1389#else /* CONFIG_PROC_FS */
1390static int __init ipv4_proc_init(void)
1391{
1392	return 0;
1393}
1394#endif /* CONFIG_PROC_FS */
1395
1396MODULE_ALIAS_NETPROTO(PF_INET);
1397
1398EXPORT_SYMBOL(inet_accept);
1399EXPORT_SYMBOL(inet_bind);
1400EXPORT_SYMBOL(inet_dgram_connect);
1401EXPORT_SYMBOL(inet_dgram_ops);
1402EXPORT_SYMBOL(inet_getname);
1403EXPORT_SYMBOL(inet_ioctl);
1404EXPORT_SYMBOL(inet_listen);
1405EXPORT_SYMBOL(inet_register_protosw);
1406EXPORT_SYMBOL(inet_release);
1407EXPORT_SYMBOL(inet_sendmsg);
1408EXPORT_SYMBOL(inet_shutdown);
1409EXPORT_SYMBOL(inet_sock_destruct);
1410EXPORT_SYMBOL(inet_stream_connect);
1411EXPORT_SYMBOL(inet_stream_ops);
1412EXPORT_SYMBOL(inet_unregister_protosw);
1413EXPORT_SYMBOL(net_statistics);
1414EXPORT_SYMBOL(sysctl_ip_nonlocal_bind);
1415