f3dbc8dc126346822b4a1e1f4116b5caf51c1013
[linux-2.6.git] / net / ipv4 / tcp.c
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  *              Implementation of the Transmission Control Protocol(TCP).
7  *
8  * Version:     $Id: tcp.c,v 1.216 2002/02/01 22:01:04 davem Exp $
9  *
10  * Authors:     Ross Biro
11  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12  *              Mark Evans, <evansmp@uhura.aston.ac.uk>
13  *              Corey Minyard <wf-rch!minyard@relay.EU.net>
14  *              Florian La Roche, <flla@stud.uni-sb.de>
15  *              Charles Hedrick, <hedrick@klinzhai.rutgers.edu>
16  *              Linus Torvalds, <torvalds@cs.helsinki.fi>
17  *              Alan Cox, <gw4pts@gw4pts.ampr.org>
18  *              Matthew Dillon, <dillon@apollo.west.oic.com>
19  *              Arnt Gulbrandsen, <agulbra@nvg.unit.no>
20  *              Jorge Cwik, <jorge@laser.satlink.net>
21  *
22  * Fixes:
23  *              Alan Cox        :       Numerous verify_area() calls
24  *              Alan Cox        :       Set the ACK bit on a reset
25  *              Alan Cox        :       Stopped it crashing if it closed while
26  *                                      sk->inuse=1 and was trying to connect
27  *                                      (tcp_err()).
28  *              Alan Cox        :       All icmp error handling was broken
29  *                                      pointers passed where wrong and the
30  *                                      socket was looked up backwards. Nobody
31  *                                      tested any icmp error code obviously.
32  *              Alan Cox        :       tcp_err() now handled properly. It
33  *                                      wakes people on errors. poll
34  *                                      behaves and the icmp error race
35  *                                      has gone by moving it into sock.c
36  *              Alan Cox        :       tcp_send_reset() fixed to work for
37  *                                      everything not just packets for
38  *                                      unknown sockets.
39  *              Alan Cox        :       tcp option processing.
40  *              Alan Cox        :       Reset tweaked (still not 100%) [Had
41  *                                      syn rule wrong]
42  *              Herp Rosmanith  :       More reset fixes
43  *              Alan Cox        :       No longer acks invalid rst frames.
44  *                                      Acking any kind of RST is right out.
45  *              Alan Cox        :       Sets an ignore me flag on an rst
46  *                                      receive otherwise odd bits of prattle
47  *                                      escape still
48  *              Alan Cox        :       Fixed another acking RST frame bug.
49  *                                      Should stop LAN workplace lockups.
50  *              Alan Cox        :       Some tidyups using the new skb list
51  *                                      facilities
52  *              Alan Cox        :       sk->keepopen now seems to work
53  *              Alan Cox        :       Pulls options out correctly on accepts
54  *              Alan Cox        :       Fixed assorted sk->rqueue->next errors
55  *              Alan Cox        :       PSH doesn't end a TCP read. Switched a
56  *                                      bit to skb ops.
57  *              Alan Cox        :       Tidied tcp_data to avoid a potential
58  *                                      nasty.
59  *              Alan Cox        :       Added some better commenting, as the
60  *                                      tcp is hard to follow
61  *              Alan Cox        :       Removed incorrect check for 20 * psh
62  *      Michael O'Reilly        :       ack < copied bug fix.
63  *      Johannes Stille         :       Misc tcp fixes (not all in yet).
64  *              Alan Cox        :       FIN with no memory -> CRASH
65  *              Alan Cox        :       Added socket option proto entries.
66  *                                      Also added awareness of them to accept.
67  *              Alan Cox        :       Added TCP options (SOL_TCP)
68  *              Alan Cox        :       Switched wakeup calls to callbacks,
69  *                                      so the kernel can layer network
70  *                                      sockets.
71  *              Alan Cox        :       Use ip_tos/ip_ttl settings.
72  *              Alan Cox        :       Handle FIN (more) properly (we hope).
73  *              Alan Cox        :       RST frames sent on unsynchronised
74  *                                      state ack error.
75  *              Alan Cox        :       Put in missing check for SYN bit.
76  *              Alan Cox        :       Added tcp_select_window() aka NET2E
77  *                                      window non shrink trick.
78  *              Alan Cox        :       Added a couple of small NET2E timer
79  *                                      fixes
80  *              Charles Hedrick :       TCP fixes
81  *              Toomas Tamm     :       TCP window fixes
82  *              Alan Cox        :       Small URG fix to rlogin ^C ack fight
83  *              Charles Hedrick :       Rewrote most of it to actually work
84  *              Linus           :       Rewrote tcp_read() and URG handling
85  *                                      completely
86  *              Gerhard Koerting:       Fixed some missing timer handling
87  *              Matthew Dillon  :       Reworked TCP machine states as per RFC
88  *              Gerhard Koerting:       PC/TCP workarounds
89  *              Adam Caldwell   :       Assorted timer/timing errors
90  *              Matthew Dillon  :       Fixed another RST bug
91  *              Alan Cox        :       Move to kernel side addressing changes.
92  *              Alan Cox        :       Beginning work on TCP fastpathing
93  *                                      (not yet usable)
94  *              Arnt Gulbrandsen:       Turbocharged tcp_check() routine.
95  *              Alan Cox        :       TCP fast path debugging
96  *              Alan Cox        :       Window clamping
97  *              Michael Riepe   :       Bug in tcp_check()
98  *              Matt Dillon     :       More TCP improvements and RST bug fixes
99  *              Matt Dillon     :       Yet more small nasties remove from the
100  *                                      TCP code (Be very nice to this man if
101  *                                      tcp finally works 100%) 8)
102  *              Alan Cox        :       BSD accept semantics.
103  *              Alan Cox        :       Reset on closedown bug.
104  *      Peter De Schrijver      :       ENOTCONN check missing in tcp_sendto().
105  *              Michael Pall    :       Handle poll() after URG properly in
106  *                                      all cases.
107  *              Michael Pall    :       Undo the last fix in tcp_read_urg()
108  *                                      (multi URG PUSH broke rlogin).
109  *              Michael Pall    :       Fix the multi URG PUSH problem in
110  *                                      tcp_readable(), poll() after URG
111  *                                      works now.
112  *              Michael Pall    :       recv(...,MSG_OOB) never blocks in the
113  *                                      BSD api.
114  *              Alan Cox        :       Changed the semantics of sk->socket to
115  *                                      fix a race and a signal problem with
116  *                                      accept() and async I/O.
117  *              Alan Cox        :       Relaxed the rules on tcp_sendto().
118  *              Yury Shevchuk   :       Really fixed accept() blocking problem.
119  *              Craig I. Hagan  :       Allow for BSD compatible TIME_WAIT for
120  *                                      clients/servers which listen in on
121  *                                      fixed ports.
122  *              Alan Cox        :       Cleaned the above up and shrank it to
123  *                                      a sensible code size.
124  *              Alan Cox        :       Self connect lockup fix.
125  *              Alan Cox        :       No connect to multicast.
126  *              Ross Biro       :       Close unaccepted children on master
127  *                                      socket close.
128  *              Alan Cox        :       Reset tracing code.
129  *              Alan Cox        :       Spurious resets on shutdown.
130  *              Alan Cox        :       Giant 15 minute/60 second timer error
131  *              Alan Cox        :       Small whoops in polling before an
132  *                                      accept.
133  *              Alan Cox        :       Kept the state trace facility since
134  *                                      it's handy for debugging.
135  *              Alan Cox        :       More reset handler fixes.
136  *              Alan Cox        :       Started rewriting the code based on
137  *                                      the RFC's for other useful protocol
138  *                                      references see: Comer, KA9Q NOS, and
139  *                                      for a reference on the difference
140  *                                      between specifications and how BSD
141  *                                      works see the 4.4lite source.
142  *              A.N.Kuznetsov   :       Don't time wait on completion of tidy
143  *                                      close.
144  *              Linus Torvalds  :       Fin/Shutdown & copied_seq changes.
145  *              Linus Torvalds  :       Fixed BSD port reuse to work first syn
146  *              Alan Cox        :       Reimplemented timers as per the RFC
147  *                                      and using multiple timers for sanity.
148  *              Alan Cox        :       Small bug fixes, and a lot of new
149  *                                      comments.
150  *              Alan Cox        :       Fixed dual reader crash by locking
151  *                                      the buffers (much like datagram.c)
152  *              Alan Cox        :       Fixed stuck sockets in probe. A probe
153  *                                      now gets fed up of retrying without
154  *                                      (even a no space) answer.
155  *              Alan Cox        :       Extracted closing code better
156  *              Alan Cox        :       Fixed the closing state machine to
157  *                                      resemble the RFC.
158  *              Alan Cox        :       More 'per spec' fixes.
159  *              Jorge Cwik      :       Even faster checksumming.
160  *              Alan Cox        :       tcp_data() doesn't ack illegal PSH
161  *                                      only frames. At least one pc tcp stack
162  *                                      generates them.
163  *              Alan Cox        :       Cache last socket.
164  *              Alan Cox        :       Per route irtt.
165  *              Matt Day        :       poll()->select() match BSD precisely on error
166  *              Alan Cox        :       New buffers
167  *              Marc Tamsky     :       Various sk->prot->retransmits and
168  *                                      sk->retransmits misupdating fixed.
169  *                                      Fixed tcp_write_timeout: stuck close,
170  *                                      and TCP syn retries gets used now.
171  *              Mark Yarvis     :       In tcp_read_wakeup(), don't send an
172  *                                      ack if state is TCP_CLOSED.
173  *              Alan Cox        :       Look up device on a retransmit - routes may
174  *                                      change. Doesn't yet cope with MSS shrink right
175  *                                      but it's a start!
176  *              Marc Tamsky     :       Closing in closing fixes.
177  *              Mike Shaver     :       RFC1122 verifications.
178  *              Alan Cox        :       rcv_saddr errors.
179  *              Alan Cox        :       Block double connect().
180  *              Alan Cox        :       Small hooks for enSKIP.
181  *              Alexey Kuznetsov:       Path MTU discovery.
182  *              Alan Cox        :       Support soft errors.
183  *              Alan Cox        :       Fix MTU discovery pathological case
184  *                                      when the remote claims no mtu!
185  *              Marc Tamsky     :       TCP_CLOSE fix.
186  *              Colin (G3TNE)   :       Send a reset on syn ack replies in
187  *                                      window but wrong (fixes NT lpd problems)
188  *              Pedro Roque     :       Better TCP window handling, delayed ack.
189  *              Joerg Reuter    :       No modification of locked buffers in
190  *                                      tcp_do_retransmit()
191  *              Eric Schenk     :       Changed receiver side silly window
192  *                                      avoidance algorithm to BSD style
193  *                                      algorithm. This doubles throughput
194  *                                      against machines running Solaris,
195  *                                      and seems to result in general
196  *                                      improvement.
197  *      Stefan Magdalinski      :       adjusted tcp_readable() to fix FIONREAD
198  *      Willy Konynenberg       :       Transparent proxying support.
199  *      Mike McLagan            :       Routing by source
200  *              Keith Owens     :       Do proper merging with partial SKB's in
201  *                                      tcp_do_sendmsg to avoid burstiness.
202  *              Eric Schenk     :       Fix fast close down bug with
203  *                                      shutdown() followed by close().
204  *              Andi Kleen      :       Make poll agree with SIGIO
205  *      Salvatore Sanfilippo    :       Support SO_LINGER with linger == 1 and
206  *                                      lingertime == 0 (RFC 793 ABORT Call)
207  *      Hirokazu Takahashi      :       Use copy_from_user() instead of
208  *                                      csum_and_copy_from_user() if possible.
209  *
210  *              This program is free software; you can redistribute it and/or
211  *              modify it under the terms of the GNU General Public License
212  *              as published by the Free Software Foundation; either version
213  *              2 of the License, or(at your option) any later version.
214  *
215  * Description of States:
216  *
217  *      TCP_SYN_SENT            sent a connection request, waiting for ack
218  *
219  *      TCP_SYN_RECV            received a connection request, sent ack,
220  *                              waiting for final ack in three-way handshake.
221  *
222  *      TCP_ESTABLISHED         connection established
223  *
224  *      TCP_FIN_WAIT1           our side has shutdown, waiting to complete
225  *                              transmission of remaining buffered data
226  *
227  *      TCP_FIN_WAIT2           all buffered data sent, waiting for remote
228  *                              to shutdown
229  *
230  *      TCP_CLOSING             both sides have shutdown but we still have
231  *                              data we have to finish sending
232  *
233  *      TCP_TIME_WAIT           timeout to catch resent junk before entering
234  *                              closed, can only be entered from FIN_WAIT2
235  *                              or CLOSING.  Required because the other end
236  *                              may not have gotten our last ACK causing it
237  *                              to retransmit the data packet (which we ignore)
238  *
239  *      TCP_CLOSE_WAIT          remote side has shutdown and is waiting for
240  *                              us to finish writing our data and to shutdown
241  *                              (we have to close() to move on to LAST_ACK)
242  *
243  *      TCP_LAST_ACK            out side has shutdown after remote has
244  *                              shutdown.  There may still be data in our
245  *                              buffer that we have to finish sending
246  *
247  *      TCP_CLOSE               socket is finished
248  */
249
250 #include <linux/config.h>
251 #include <linux/module.h>
252 #include <linux/types.h>
253 #include <linux/fcntl.h>
254 #include <linux/poll.h>
255 #include <linux/init.h>
256 #include <linux/smp_lock.h>
257 #include <linux/fs.h>
258 #include <linux/random.h>
259 #include <linux/bootmem.h>
260
261 #include <net/icmp.h>
262 #include <net/tcp.h>
263 #include <net/xfrm.h>
264 #include <net/ip.h>
265
266
267 #include <asm/uaccess.h>
268 #include <asm/ioctls.h>
269
270 int sysctl_tcp_fin_timeout = TCP_FIN_TIMEOUT;
271
272 DEFINE_SNMP_STAT(struct tcp_mib, tcp_statistics);
273
274 kmem_cache_t *tcp_bucket_cachep;
275 kmem_cache_t *tcp_timewait_cachep;
276
277 atomic_t tcp_orphan_count = ATOMIC_INIT(0);
278
279 int sysctl_tcp_mem[3];
280 int sysctl_tcp_wmem[3] = { 4 * 1024, 16 * 1024, 128 * 1024 };
281 int sysctl_tcp_rmem[3] = { 4 * 1024, 87380, 87380 * 2 };
282
283 EXPORT_SYMBOL(sysctl_tcp_mem);
284 EXPORT_SYMBOL(sysctl_tcp_rmem);
285 EXPORT_SYMBOL(sysctl_tcp_wmem);
286
287 atomic_t tcp_memory_allocated;  /* Current allocated memory. */
288 atomic_t tcp_sockets_allocated; /* Current number of TCP sockets. */
289
290 EXPORT_SYMBOL(tcp_memory_allocated);
291 EXPORT_SYMBOL(tcp_sockets_allocated);
292
293 /*
294  * Pressure flag: try to collapse.
295  * Technical note: it is used by multiple contexts non atomically.
296  * All the sk_stream_mem_schedule() is of this nature: accounting
297  * is strict, actions are advisory and have some latency.
298  */
299 int tcp_memory_pressure;
300
301 EXPORT_SYMBOL(tcp_memory_pressure);
302
303 void tcp_enter_memory_pressure(void)
304 {
305         if (!tcp_memory_pressure) {
306                 NET_INC_STATS(LINUX_MIB_TCPMEMORYPRESSURES);
307                 tcp_memory_pressure = 1;
308         }
309 }
310
311 EXPORT_SYMBOL(tcp_enter_memory_pressure);
312
313 /*
314  * LISTEN is a special case for poll..
315  */
316 static __inline__ unsigned int tcp_listen_poll(struct sock *sk,
317                                                poll_table *wait)
318 {
319         return !reqsk_queue_empty(&tcp_sk(sk)->accept_queue) ? (POLLIN | POLLRDNORM) : 0;
320 }
321
322 /*
323  *      Wait for a TCP event.
324  *
325  *      Note that we don't need to lock the socket, as the upper poll layers
326  *      take care of normal races (between the test and the event) and we don't
327  *      go look at any of the socket buffers directly.
328  */
329 unsigned int tcp_poll(struct file *file, struct socket *sock, poll_table *wait)
330 {
331         unsigned int mask;
332         struct sock *sk = sock->sk;
333         struct tcp_sock *tp = tcp_sk(sk);
334
335         poll_wait(file, sk->sk_sleep, wait);
336         if (sk->sk_state == TCP_LISTEN)
337                 return tcp_listen_poll(sk, wait);
338
339         /* Socket is not locked. We are protected from async events
340            by poll logic and correct handling of state changes
341            made by another threads is impossible in any case.
342          */
343
344         mask = 0;
345         if (sk->sk_err)
346                 mask = POLLERR;
347
348         /*
349          * POLLHUP is certainly not done right. But poll() doesn't
350          * have a notion of HUP in just one direction, and for a
351          * socket the read side is more interesting.
352          *
353          * Some poll() documentation says that POLLHUP is incompatible
354          * with the POLLOUT/POLLWR flags, so somebody should check this
355          * all. But careful, it tends to be safer to return too many
356          * bits than too few, and you can easily break real applications
357          * if you don't tell them that something has hung up!
358          *
359          * Check-me.
360          *
361          * Check number 1. POLLHUP is _UNMASKABLE_ event (see UNIX98 and
362          * our fs/select.c). It means that after we received EOF,
363          * poll always returns immediately, making impossible poll() on write()
364          * in state CLOSE_WAIT. One solution is evident --- to set POLLHUP
365          * if and only if shutdown has been made in both directions.
366          * Actually, it is interesting to look how Solaris and DUX
367          * solve this dilemma. I would prefer, if PULLHUP were maskable,
368          * then we could set it on SND_SHUTDOWN. BTW examples given
369          * in Stevens' books assume exactly this behaviour, it explains
370          * why PULLHUP is incompatible with POLLOUT.    --ANK
371          *
372          * NOTE. Check for TCP_CLOSE is added. The goal is to prevent
373          * blocking on fresh not-connected or disconnected socket. --ANK
374          */
375         if (sk->sk_shutdown == SHUTDOWN_MASK || sk->sk_state == TCP_CLOSE)
376                 mask |= POLLHUP;
377         if (sk->sk_shutdown & RCV_SHUTDOWN)
378                 mask |= POLLIN | POLLRDNORM;
379
380         /* Connected? */
381         if ((1 << sk->sk_state) & ~(TCPF_SYN_SENT | TCPF_SYN_RECV)) {
382                 /* Potential race condition. If read of tp below will
383                  * escape above sk->sk_state, we can be illegally awaken
384                  * in SYN_* states. */
385                 if ((tp->rcv_nxt != tp->copied_seq) &&
386                     (tp->urg_seq != tp->copied_seq ||
387                      tp->rcv_nxt != tp->copied_seq + 1 ||
388                      sock_flag(sk, SOCK_URGINLINE) || !tp->urg_data))
389                         mask |= POLLIN | POLLRDNORM;
390
391                 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
392                         if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk)) {
393                                 mask |= POLLOUT | POLLWRNORM;
394                         } else {  /* send SIGIO later */
395                                 set_bit(SOCK_ASYNC_NOSPACE,
396                                         &sk->sk_socket->flags);
397                                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
398
399                                 /* Race breaker. If space is freed after
400                                  * wspace test but before the flags are set,
401                                  * IO signal will be lost.
402                                  */
403                                 if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk))
404                                         mask |= POLLOUT | POLLWRNORM;
405                         }
406                 }
407
408                 if (tp->urg_data & TCP_URG_VALID)
409                         mask |= POLLPRI;
410         }
411         return mask;
412 }
413
414 int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
415 {
416         struct tcp_sock *tp = tcp_sk(sk);
417         int answ;
418
419         switch (cmd) {
420         case SIOCINQ:
421                 if (sk->sk_state == TCP_LISTEN)
422                         return -EINVAL;
423
424                 lock_sock(sk);
425                 if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
426                         answ = 0;
427                 else if (sock_flag(sk, SOCK_URGINLINE) ||
428                          !tp->urg_data ||
429                          before(tp->urg_seq, tp->copied_seq) ||
430                          !before(tp->urg_seq, tp->rcv_nxt)) {
431                         answ = tp->rcv_nxt - tp->copied_seq;
432
433                         /* Subtract 1, if FIN is in queue. */
434                         if (answ && !skb_queue_empty(&sk->sk_receive_queue))
435                                 answ -=
436                        ((struct sk_buff *)sk->sk_receive_queue.prev)->h.th->fin;
437                 } else
438                         answ = tp->urg_seq - tp->copied_seq;
439                 release_sock(sk);
440                 break;
441         case SIOCATMARK:
442                 answ = tp->urg_data && tp->urg_seq == tp->copied_seq;
443                 break;
444         case SIOCOUTQ:
445                 if (sk->sk_state == TCP_LISTEN)
446                         return -EINVAL;
447
448                 if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
449                         answ = 0;
450                 else
451                         answ = tp->write_seq - tp->snd_una;
452                 break;
453         default:
454                 return -ENOIOCTLCMD;
455         };
456
457         return put_user(answ, (int __user *)arg);
458 }
459
460
461 int tcp_listen_start(struct sock *sk)
462 {
463         struct inet_sock *inet = inet_sk(sk);
464         struct tcp_sock *tp = tcp_sk(sk);
465         int rc = reqsk_queue_alloc(&tp->accept_queue, TCP_SYNQ_HSIZE);
466
467         if (rc != 0)
468                 return rc;
469
470         sk->sk_max_ack_backlog = 0;
471         sk->sk_ack_backlog = 0;
472         tcp_delack_init(tp);
473
474         /* There is race window here: we announce ourselves listening,
475          * but this transition is still not validated by get_port().
476          * It is OK, because this socket enters to hash table only
477          * after validation is complete.
478          */
479         sk->sk_state = TCP_LISTEN;
480         if (!sk->sk_prot->get_port(sk, inet->num)) {
481                 inet->sport = htons(inet->num);
482
483                 sk_dst_reset(sk);
484                 sk->sk_prot->hash(sk);
485
486                 return 0;
487         }
488
489         sk->sk_state = TCP_CLOSE;
490         reqsk_queue_destroy(&tp->accept_queue);
491         return -EADDRINUSE;
492 }
493
494 /*
495  *      This routine closes sockets which have been at least partially
496  *      opened, but not yet accepted.
497  */
498
499 static void tcp_listen_stop (struct sock *sk)
500 {
501         struct tcp_sock *tp = tcp_sk(sk);
502         struct listen_sock *lopt;
503         struct request_sock *acc_req;
504         struct request_sock *req;
505         int i;
506
507         tcp_delete_keepalive_timer(sk);
508
509         /* make all the listen_opt local to us */
510         lopt = reqsk_queue_yank_listen_sk(&tp->accept_queue);
511         acc_req = reqsk_queue_yank_acceptq(&tp->accept_queue);
512
513         if (lopt->qlen) {
514                 for (i = 0; i < TCP_SYNQ_HSIZE; i++) {
515                         while ((req = lopt->syn_table[i]) != NULL) {
516                                 lopt->syn_table[i] = req->dl_next;
517                                 lopt->qlen--;
518                                 reqsk_free(req);
519
520                 /* Following specs, it would be better either to send FIN
521                  * (and enter FIN-WAIT-1, it is normal close)
522                  * or to send active reset (abort).
523                  * Certainly, it is pretty dangerous while synflood, but it is
524                  * bad justification for our negligence 8)
525                  * To be honest, we are not able to make either
526                  * of the variants now.                 --ANK
527                  */
528                         }
529                 }
530         }
531         BUG_TRAP(!lopt->qlen);
532
533         kfree(lopt);
534
535         while ((req = acc_req) != NULL) {
536                 struct sock *child = req->sk;
537
538                 acc_req = req->dl_next;
539
540                 local_bh_disable();
541                 bh_lock_sock(child);
542                 BUG_TRAP(!sock_owned_by_user(child));
543                 sock_hold(child);
544
545                 tcp_disconnect(child, O_NONBLOCK);
546
547                 sock_orphan(child);
548
549                 atomic_inc(&tcp_orphan_count);
550
551                 tcp_destroy_sock(child);
552
553                 bh_unlock_sock(child);
554                 local_bh_enable();
555                 sock_put(child);
556
557                 sk_acceptq_removed(sk);
558                 __reqsk_free(req);
559         }
560         BUG_TRAP(!sk->sk_ack_backlog);
561 }
562
563 static inline void tcp_mark_push(struct tcp_sock *tp, struct sk_buff *skb)
564 {
565         TCP_SKB_CB(skb)->flags |= TCPCB_FLAG_PSH;
566         tp->pushed_seq = tp->write_seq;
567 }
568
569 static inline int forced_push(struct tcp_sock *tp)
570 {
571         return after(tp->write_seq, tp->pushed_seq + (tp->max_window >> 1));
572 }
573
574 static inline void skb_entail(struct sock *sk, struct tcp_sock *tp,
575                               struct sk_buff *skb)
576 {
577         skb->csum = 0;
578         TCP_SKB_CB(skb)->seq = tp->write_seq;
579         TCP_SKB_CB(skb)->end_seq = tp->write_seq;
580         TCP_SKB_CB(skb)->flags = TCPCB_FLAG_ACK;
581         TCP_SKB_CB(skb)->sacked = 0;
582         skb_header_release(skb);
583         __skb_queue_tail(&sk->sk_write_queue, skb);
584         sk_charge_skb(sk, skb);
585         if (!sk->sk_send_head)
586                 sk->sk_send_head = skb;
587         else if (tp->nonagle&TCP_NAGLE_PUSH)
588                 tp->nonagle &= ~TCP_NAGLE_PUSH; 
589 }
590
591 static inline void tcp_mark_urg(struct tcp_sock *tp, int flags,
592                                 struct sk_buff *skb)
593 {
594         if (flags & MSG_OOB) {
595                 tp->urg_mode = 1;
596                 tp->snd_up = tp->write_seq;
597                 TCP_SKB_CB(skb)->sacked |= TCPCB_URG;
598         }
599 }
600
601 static inline void tcp_push(struct sock *sk, struct tcp_sock *tp, int flags,
602                             int mss_now, int nonagle)
603 {
604         if (sk->sk_send_head) {
605                 struct sk_buff *skb = sk->sk_write_queue.prev;
606                 if (!(flags & MSG_MORE) || forced_push(tp))
607                         tcp_mark_push(tp, skb);
608                 tcp_mark_urg(tp, flags, skb);
609                 __tcp_push_pending_frames(sk, tp, mss_now,
610                                           (flags & MSG_MORE) ? TCP_NAGLE_CORK : nonagle);
611         }
612 }
613
614 static ssize_t do_tcp_sendpages(struct sock *sk, struct page **pages, int poffset,
615                          size_t psize, int flags)
616 {
617         struct tcp_sock *tp = tcp_sk(sk);
618         int mss_now;
619         int err;
620         ssize_t copied;
621         long timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
622
623         /* Wait for a connection to finish. */
624         if ((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT))
625                 if ((err = sk_stream_wait_connect(sk, &timeo)) != 0)
626                         goto out_err;
627
628         clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
629
630         mss_now = tcp_current_mss(sk, !(flags&MSG_OOB));
631         copied = 0;
632
633         err = -EPIPE;
634         if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
635                 goto do_error;
636
637         while (psize > 0) {
638                 struct sk_buff *skb = sk->sk_write_queue.prev;
639                 struct page *page = pages[poffset / PAGE_SIZE];
640                 int copy, i, can_coalesce;
641                 int offset = poffset % PAGE_SIZE;
642                 int size = min_t(size_t, psize, PAGE_SIZE - offset);
643
644                 if (!sk->sk_send_head || (copy = mss_now - skb->len) <= 0) {
645 new_segment:
646                         if (!sk_stream_memory_free(sk))
647                                 goto wait_for_sndbuf;
648
649                         skb = sk_stream_alloc_pskb(sk, 0, 0,
650                                                    sk->sk_allocation);
651                         if (!skb)
652                                 goto wait_for_memory;
653
654                         skb_entail(sk, tp, skb);
655                         copy = mss_now;
656                 }
657
658                 if (copy > size)
659                         copy = size;
660
661                 i = skb_shinfo(skb)->nr_frags;
662                 can_coalesce = skb_can_coalesce(skb, i, page, offset);
663                 if (!can_coalesce && i >= MAX_SKB_FRAGS) {
664                         tcp_mark_push(tp, skb);
665                         goto new_segment;
666                 }
667                 if (sk->sk_forward_alloc < copy &&
668                     !sk_stream_mem_schedule(sk, copy, 0))
669                         goto wait_for_memory;
670                 
671                 if (can_coalesce) {
672                         skb_shinfo(skb)->frags[i - 1].size += copy;
673                 } else {
674                         get_page(page);
675                         skb_fill_page_desc(skb, i, page, offset, copy);
676                 }
677
678                 skb->len += copy;
679                 skb->data_len += copy;
680                 skb->truesize += copy;
681                 sk->sk_wmem_queued += copy;
682                 sk->sk_forward_alloc -= copy;
683                 skb->ip_summed = CHECKSUM_HW;
684                 tp->write_seq += copy;
685                 TCP_SKB_CB(skb)->end_seq += copy;
686                 skb_shinfo(skb)->tso_segs = 0;
687
688                 if (!copied)
689                         TCP_SKB_CB(skb)->flags &= ~TCPCB_FLAG_PSH;
690
691                 copied += copy;
692                 poffset += copy;
693                 if (!(psize -= copy))
694                         goto out;
695
696                 if (skb->len != mss_now || (flags & MSG_OOB))
697                         continue;
698
699                 if (forced_push(tp)) {
700                         tcp_mark_push(tp, skb);
701                         __tcp_push_pending_frames(sk, tp, mss_now, TCP_NAGLE_PUSH);
702                 } else if (skb == sk->sk_send_head)
703                         tcp_push_one(sk, mss_now);
704                 continue;
705
706 wait_for_sndbuf:
707                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
708 wait_for_memory:
709                 if (copied)
710                         tcp_push(sk, tp, flags & ~MSG_MORE, mss_now, TCP_NAGLE_PUSH);
711
712                 if ((err = sk_stream_wait_memory(sk, &timeo)) != 0)
713                         goto do_error;
714
715                 mss_now = tcp_current_mss(sk, !(flags&MSG_OOB));
716         }
717
718 out:
719         if (copied)
720                 tcp_push(sk, tp, flags, mss_now, tp->nonagle);
721         return copied;
722
723 do_error:
724         if (copied)
725                 goto out;
726 out_err:
727         return sk_stream_error(sk, flags, err);
728 }
729
730 ssize_t tcp_sendpage(struct socket *sock, struct page *page, int offset,
731                      size_t size, int flags)
732 {
733         ssize_t res;
734         struct sock *sk = sock->sk;
735
736 #define TCP_ZC_CSUM_FLAGS (NETIF_F_IP_CSUM | NETIF_F_NO_CSUM | NETIF_F_HW_CSUM)
737
738         if (!(sk->sk_route_caps & NETIF_F_SG) ||
739             !(sk->sk_route_caps & TCP_ZC_CSUM_FLAGS))
740                 return sock_no_sendpage(sock, page, offset, size, flags);
741
742 #undef TCP_ZC_CSUM_FLAGS
743
744         lock_sock(sk);
745         TCP_CHECK_TIMER(sk);
746         res = do_tcp_sendpages(sk, &page, offset, size, flags);
747         TCP_CHECK_TIMER(sk);
748         release_sock(sk);
749         return res;
750 }
751
752 #define TCP_PAGE(sk)    (sk->sk_sndmsg_page)
753 #define TCP_OFF(sk)     (sk->sk_sndmsg_off)
754
755 static inline int select_size(struct sock *sk, struct tcp_sock *tp)
756 {
757         int tmp = tp->mss_cache_std;
758
759         if (sk->sk_route_caps & NETIF_F_SG) {
760                 int pgbreak = SKB_MAX_HEAD(MAX_TCP_HEADER);
761
762                 if (tmp >= pgbreak &&
763                     tmp <= pgbreak + (MAX_SKB_FRAGS - 1) * PAGE_SIZE)
764                         tmp = pgbreak;
765         }
766         return tmp;
767 }
768
769 int tcp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
770                 size_t size)
771 {
772         struct iovec *iov;
773         struct tcp_sock *tp = tcp_sk(sk);
774         struct sk_buff *skb;
775         int iovlen, flags;
776         int mss_now;
777         int err, copied;
778         long timeo;
779
780         lock_sock(sk);
781         TCP_CHECK_TIMER(sk);
782
783         flags = msg->msg_flags;
784         timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
785
786         /* Wait for a connection to finish. */
787         if ((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT))
788                 if ((err = sk_stream_wait_connect(sk, &timeo)) != 0)
789                         goto out_err;
790
791         /* This should be in poll */
792         clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
793
794         mss_now = tcp_current_mss(sk, !(flags&MSG_OOB));
795
796         /* Ok commence sending. */
797         iovlen = msg->msg_iovlen;
798         iov = msg->msg_iov;
799         copied = 0;
800
801         err = -EPIPE;
802         if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
803                 goto do_error;
804
805         while (--iovlen >= 0) {
806                 int seglen = iov->iov_len;
807                 unsigned char __user *from = iov->iov_base;
808
809                 iov++;
810
811                 while (seglen > 0) {
812                         int copy;
813
814                         skb = sk->sk_write_queue.prev;
815
816                         if (!sk->sk_send_head ||
817                             (copy = mss_now - skb->len) <= 0) {
818
819 new_segment:
820                                 /* Allocate new segment. If the interface is SG,
821                                  * allocate skb fitting to single page.
822                                  */
823                                 if (!sk_stream_memory_free(sk))
824                                         goto wait_for_sndbuf;
825
826                                 skb = sk_stream_alloc_pskb(sk, select_size(sk, tp),
827                                                            0, sk->sk_allocation);
828                                 if (!skb)
829                                         goto wait_for_memory;
830
831                                 /*
832                                  * Check whether we can use HW checksum.
833                                  */
834                                 if (sk->sk_route_caps &
835                                     (NETIF_F_IP_CSUM | NETIF_F_NO_CSUM |
836                                      NETIF_F_HW_CSUM))
837                                         skb->ip_summed = CHECKSUM_HW;
838
839                                 skb_entail(sk, tp, skb);
840                                 copy = mss_now;
841                         }
842
843                         /* Try to append data to the end of skb. */
844                         if (copy > seglen)
845                                 copy = seglen;
846
847                         /* Where to copy to? */
848                         if (skb_tailroom(skb) > 0) {
849                                 /* We have some space in skb head. Superb! */
850                                 if (copy > skb_tailroom(skb))
851                                         copy = skb_tailroom(skb);
852                                 if ((err = skb_add_data(skb, from, copy)) != 0)
853                                         goto do_fault;
854                         } else {
855                                 int merge = 0;
856                                 int i = skb_shinfo(skb)->nr_frags;
857                                 struct page *page = TCP_PAGE(sk);
858                                 int off = TCP_OFF(sk);
859
860                                 if (skb_can_coalesce(skb, i, page, off) &&
861                                     off != PAGE_SIZE) {
862                                         /* We can extend the last page
863                                          * fragment. */
864                                         merge = 1;
865                                 } else if (i == MAX_SKB_FRAGS ||
866                                            (!i &&
867                                            !(sk->sk_route_caps & NETIF_F_SG))) {
868                                         /* Need to add new fragment and cannot
869                                          * do this because interface is non-SG,
870                                          * or because all the page slots are
871                                          * busy. */
872                                         tcp_mark_push(tp, skb);
873                                         goto new_segment;
874                                 } else if (page) {
875                                         /* If page is cached, align
876                                          * offset to L1 cache boundary
877                                          */
878                                         off = (off + L1_CACHE_BYTES - 1) &
879                                               ~(L1_CACHE_BYTES - 1);
880                                         if (off == PAGE_SIZE) {
881                                                 put_page(page);
882                                                 TCP_PAGE(sk) = page = NULL;
883                                         }
884                                 }
885
886                                 if (!page) {
887                                         /* Allocate new cache page. */
888                                         if (!(page = sk_stream_alloc_page(sk)))
889                                                 goto wait_for_memory;
890                                         off = 0;
891                                 }
892
893                                 if (copy > PAGE_SIZE - off)
894                                         copy = PAGE_SIZE - off;
895
896                                 /* Time to copy data. We are close to
897                                  * the end! */
898                                 err = skb_copy_to_page(sk, from, skb, page,
899                                                        off, copy);
900                                 if (err) {
901                                         /* If this page was new, give it to the
902                                          * socket so it does not get leaked.
903                                          */
904                                         if (!TCP_PAGE(sk)) {
905                                                 TCP_PAGE(sk) = page;
906                                                 TCP_OFF(sk) = 0;
907                                         }
908                                         goto do_error;
909                                 }
910
911                                 /* Update the skb. */
912                                 if (merge) {
913                                         skb_shinfo(skb)->frags[i - 1].size +=
914                                                                         copy;
915                                 } else {
916                                         skb_fill_page_desc(skb, i, page, off, copy);
917                                         if (TCP_PAGE(sk)) {
918                                                 get_page(page);
919                                         } else if (off + copy < PAGE_SIZE) {
920                                                 get_page(page);
921                                                 TCP_PAGE(sk) = page;
922                                         }
923                                 }
924
925                                 TCP_OFF(sk) = off + copy;
926                         }
927
928                         if (!copied)
929                                 TCP_SKB_CB(skb)->flags &= ~TCPCB_FLAG_PSH;
930
931                         tp->write_seq += copy;
932                         TCP_SKB_CB(skb)->end_seq += copy;
933                         skb_shinfo(skb)->tso_segs = 0;
934
935                         from += copy;
936                         copied += copy;
937                         if ((seglen -= copy) == 0 && iovlen == 0)
938                                 goto out;
939
940                         if (skb->len != mss_now || (flags & MSG_OOB))
941                                 continue;
942
943                         if (forced_push(tp)) {
944                                 tcp_mark_push(tp, skb);
945                                 __tcp_push_pending_frames(sk, tp, mss_now, TCP_NAGLE_PUSH);
946                         } else if (skb == sk->sk_send_head)
947                                 tcp_push_one(sk, mss_now);
948                         continue;
949
950 wait_for_sndbuf:
951                         set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
952 wait_for_memory:
953                         if (copied)
954                                 tcp_push(sk, tp, flags & ~MSG_MORE, mss_now, TCP_NAGLE_PUSH);
955
956                         if ((err = sk_stream_wait_memory(sk, &timeo)) != 0)
957                                 goto do_error;
958
959                         mss_now = tcp_current_mss(sk, !(flags&MSG_OOB));
960                 }
961         }
962
963 out:
964         if (copied)
965                 tcp_push(sk, tp, flags, mss_now, tp->nonagle);
966         TCP_CHECK_TIMER(sk);
967         release_sock(sk);
968         return copied;
969
970 do_fault:
971         if (!skb->len) {
972                 if (sk->sk_send_head == skb)
973                         sk->sk_send_head = NULL;
974                 __skb_unlink(skb, skb->list);
975                 sk_stream_free_skb(sk, skb);
976         }
977
978 do_error:
979         if (copied)
980                 goto out;
981 out_err:
982         err = sk_stream_error(sk, flags, err);
983         TCP_CHECK_TIMER(sk);
984         release_sock(sk);
985         return err;
986 }
987
988 /*
989  *      Handle reading urgent data. BSD has very simple semantics for
990  *      this, no blocking and very strange errors 8)
991  */
992
993 static int tcp_recv_urg(struct sock *sk, long timeo,
994                         struct msghdr *msg, int len, int flags,
995                         int *addr_len)
996 {
997         struct tcp_sock *tp = tcp_sk(sk);
998
999         /* No URG data to read. */
1000         if (sock_flag(sk, SOCK_URGINLINE) || !tp->urg_data ||
1001             tp->urg_data == TCP_URG_READ)
1002                 return -EINVAL; /* Yes this is right ! */
1003
1004         if (sk->sk_state == TCP_CLOSE && !sock_flag(sk, SOCK_DONE))
1005                 return -ENOTCONN;
1006
1007         if (tp->urg_data & TCP_URG_VALID) {
1008                 int err = 0;
1009                 char c = tp->urg_data;
1010
1011                 if (!(flags & MSG_PEEK))
1012                         tp->urg_data = TCP_URG_READ;
1013
1014                 /* Read urgent data. */
1015                 msg->msg_flags |= MSG_OOB;
1016
1017                 if (len > 0) {
1018                         if (!(flags & MSG_TRUNC))
1019                                 err = memcpy_toiovec(msg->msg_iov, &c, 1);
1020                         len = 1;
1021                 } else
1022                         msg->msg_flags |= MSG_TRUNC;
1023
1024                 return err ? -EFAULT : len;
1025         }
1026
1027         if (sk->sk_state == TCP_CLOSE || (sk->sk_shutdown & RCV_SHUTDOWN))
1028                 return 0;
1029
1030         /* Fixed the recv(..., MSG_OOB) behaviour.  BSD docs and
1031          * the available implementations agree in this case:
1032          * this call should never block, independent of the
1033          * blocking state of the socket.
1034          * Mike <pall@rz.uni-karlsruhe.de>
1035          */
1036         return -EAGAIN;
1037 }
1038
1039 /* Clean up the receive buffer for full frames taken by the user,
1040  * then send an ACK if necessary.  COPIED is the number of bytes
1041  * tcp_recvmsg has given to the user so far, it speeds up the
1042  * calculation of whether or not we must ACK for the sake of
1043  * a window update.
1044  */
1045 static void cleanup_rbuf(struct sock *sk, int copied)
1046 {
1047         struct tcp_sock *tp = tcp_sk(sk);
1048         int time_to_ack = 0;
1049
1050 #if TCP_DEBUG
1051         struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
1052
1053         BUG_TRAP(!skb || before(tp->copied_seq, TCP_SKB_CB(skb)->end_seq));
1054 #endif
1055
1056         if (tcp_ack_scheduled(tp)) {
1057                    /* Delayed ACKs frequently hit locked sockets during bulk
1058                     * receive. */
1059                 if (tp->ack.blocked ||
1060                     /* Once-per-two-segments ACK was not sent by tcp_input.c */
1061                     tp->rcv_nxt - tp->rcv_wup > tp->ack.rcv_mss ||
1062                     /*
1063                      * If this read emptied read buffer, we send ACK, if
1064                      * connection is not bidirectional, user drained
1065                      * receive buffer and there was a small segment
1066                      * in queue.
1067                      */
1068                     (copied > 0 && (tp->ack.pending & TCP_ACK_PUSHED) &&
1069                      !tp->ack.pingpong && !atomic_read(&sk->sk_rmem_alloc)))
1070                         time_to_ack = 1;
1071         }
1072
1073         /* We send an ACK if we can now advertise a non-zero window
1074          * which has been raised "significantly".
1075          *
1076          * Even if window raised up to infinity, do not send window open ACK
1077          * in states, where we will not receive more. It is useless.
1078          */
1079         if (copied > 0 && !time_to_ack && !(sk->sk_shutdown & RCV_SHUTDOWN)) {
1080                 __u32 rcv_window_now = tcp_receive_window(tp);
1081
1082                 /* Optimize, __tcp_select_window() is not cheap. */
1083                 if (2*rcv_window_now <= tp->window_clamp) {
1084                         __u32 new_window = __tcp_select_window(sk);
1085
1086                         /* Send ACK now, if this read freed lots of space
1087                          * in our buffer. Certainly, new_window is new window.
1088                          * We can advertise it now, if it is not less than current one.
1089                          * "Lots" means "at least twice" here.
1090                          */
1091                         if (new_window && new_window >= 2 * rcv_window_now)
1092                                 time_to_ack = 1;
1093                 }
1094         }
1095         if (time_to_ack)
1096                 tcp_send_ack(sk);
1097 }
1098
1099 static void tcp_prequeue_process(struct sock *sk)
1100 {
1101         struct sk_buff *skb;
1102         struct tcp_sock *tp = tcp_sk(sk);
1103
1104         NET_ADD_STATS_USER(LINUX_MIB_TCPPREQUEUED, skb_queue_len(&tp->ucopy.prequeue));
1105
1106         /* RX process wants to run with disabled BHs, though it is not
1107          * necessary */
1108         local_bh_disable();
1109         while ((skb = __skb_dequeue(&tp->ucopy.prequeue)) != NULL)
1110                 sk->sk_backlog_rcv(sk, skb);
1111         local_bh_enable();
1112
1113         /* Clear memory counter. */
1114         tp->ucopy.memory = 0;
1115 }
1116
1117 static inline struct sk_buff *tcp_recv_skb(struct sock *sk, u32 seq, u32 *off)
1118 {
1119         struct sk_buff *skb;
1120         u32 offset;
1121
1122         skb_queue_walk(&sk->sk_receive_queue, skb) {
1123                 offset = seq - TCP_SKB_CB(skb)->seq;
1124                 if (skb->h.th->syn)
1125                         offset--;
1126                 if (offset < skb->len || skb->h.th->fin) {
1127                         *off = offset;
1128                         return skb;
1129                 }
1130         }
1131         return NULL;
1132 }
1133
1134 /*
1135  * This routine provides an alternative to tcp_recvmsg() for routines
1136  * that would like to handle copying from skbuffs directly in 'sendfile'
1137  * fashion.
1138  * Note:
1139  *      - It is assumed that the socket was locked by the caller.
1140  *      - The routine does not block.
1141  *      - At present, there is no support for reading OOB data
1142  *        or for 'peeking' the socket using this routine
1143  *        (although both would be easy to implement).
1144  */
1145 int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
1146                   sk_read_actor_t recv_actor)
1147 {
1148         struct sk_buff *skb;
1149         struct tcp_sock *tp = tcp_sk(sk);
1150         u32 seq = tp->copied_seq;
1151         u32 offset;
1152         int copied = 0;
1153
1154         if (sk->sk_state == TCP_LISTEN)
1155                 return -ENOTCONN;
1156         while ((skb = tcp_recv_skb(sk, seq, &offset)) != NULL) {
1157                 if (offset < skb->len) {
1158                         size_t used, len;
1159
1160                         len = skb->len - offset;
1161                         /* Stop reading if we hit a patch of urgent data */
1162                         if (tp->urg_data) {
1163                                 u32 urg_offset = tp->urg_seq - seq;
1164                                 if (urg_offset < len)
1165                                         len = urg_offset;
1166                                 if (!len)
1167                                         break;
1168                         }
1169                         used = recv_actor(desc, skb, offset, len);
1170                         if (used <= len) {
1171                                 seq += used;
1172                                 copied += used;
1173                                 offset += used;
1174                         }
1175                         if (offset != skb->len)
1176                                 break;
1177                 }
1178                 if (skb->h.th->fin) {
1179                         sk_eat_skb(sk, skb);
1180                         ++seq;
1181                         break;
1182                 }
1183                 sk_eat_skb(sk, skb);
1184                 if (!desc->count)
1185                         break;
1186         }
1187         tp->copied_seq = seq;
1188
1189         tcp_rcv_space_adjust(sk);
1190
1191         /* Clean up data we have read: This will do ACK frames. */
1192         if (copied)
1193                 cleanup_rbuf(sk, copied);
1194         return copied;
1195 }
1196
1197 /*
1198  *      This routine copies from a sock struct into the user buffer.
1199  *
1200  *      Technical note: in 2.3 we work on _locked_ socket, so that
1201  *      tricks with *seq access order and skb->users are not required.
1202  *      Probably, code can be easily improved even more.
1203  */
1204
1205 int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
1206                 size_t len, int nonblock, int flags, int *addr_len)
1207 {
1208         struct tcp_sock *tp = tcp_sk(sk);
1209         int copied = 0;
1210         u32 peek_seq;
1211         u32 *seq;
1212         unsigned long used;
1213         int err;
1214         int target;             /* Read at least this many bytes */
1215         long timeo;
1216         struct task_struct *user_recv = NULL;
1217
1218         lock_sock(sk);
1219
1220         TCP_CHECK_TIMER(sk);
1221
1222         err = -ENOTCONN;
1223         if (sk->sk_state == TCP_LISTEN)
1224                 goto out;
1225
1226         timeo = sock_rcvtimeo(sk, nonblock);
1227
1228         /* Urgent data needs to be handled specially. */
1229         if (flags & MSG_OOB)
1230                 goto recv_urg;
1231
1232         seq = &tp->copied_seq;
1233         if (flags & MSG_PEEK) {
1234                 peek_seq = tp->copied_seq;
1235                 seq = &peek_seq;
1236         }
1237
1238         target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
1239
1240         do {
1241                 struct sk_buff *skb;
1242                 u32 offset;
1243
1244                 /* Are we at urgent data? Stop if we have read anything or have SIGURG pending. */
1245                 if (tp->urg_data && tp->urg_seq == *seq) {
1246                         if (copied)
1247                                 break;
1248                         if (signal_pending(current)) {
1249                                 copied = timeo ? sock_intr_errno(timeo) : -EAGAIN;
1250                                 break;
1251                         }
1252                 }
1253
1254                 /* Next get a buffer. */
1255
1256                 skb = skb_peek(&sk->sk_receive_queue);
1257                 do {
1258                         if (!skb)
1259                                 break;
1260
1261                         /* Now that we have two receive queues this
1262                          * shouldn't happen.
1263                          */
1264                         if (before(*seq, TCP_SKB_CB(skb)->seq)) {
1265                                 printk(KERN_INFO "recvmsg bug: copied %X "
1266                                        "seq %X\n", *seq, TCP_SKB_CB(skb)->seq);
1267                                 break;
1268                         }
1269                         offset = *seq - TCP_SKB_CB(skb)->seq;
1270                         if (skb->h.th->syn)
1271                                 offset--;
1272                         if (offset < skb->len)
1273                                 goto found_ok_skb;
1274                         if (skb->h.th->fin)
1275                                 goto found_fin_ok;
1276                         BUG_TRAP(flags & MSG_PEEK);
1277                         skb = skb->next;
1278                 } while (skb != (struct sk_buff *)&sk->sk_receive_queue);
1279
1280                 /* Well, if we have backlog, try to process it now yet. */
1281
1282                 if (copied >= target && !sk->sk_backlog.tail)
1283                         break;
1284
1285                 if (copied) {
1286                         if (sk->sk_err ||
1287                             sk->sk_state == TCP_CLOSE ||
1288                             (sk->sk_shutdown & RCV_SHUTDOWN) ||
1289                             !timeo ||
1290                             signal_pending(current) ||
1291                             (flags & MSG_PEEK))
1292                                 break;
1293                 } else {
1294                         if (sock_flag(sk, SOCK_DONE))
1295                                 break;
1296
1297                         if (sk->sk_err) {
1298                                 copied = sock_error(sk);
1299                                 break;
1300                         }
1301
1302                         if (sk->sk_shutdown & RCV_SHUTDOWN)
1303                                 break;
1304
1305                         if (sk->sk_state == TCP_CLOSE) {
1306                                 if (!sock_flag(sk, SOCK_DONE)) {
1307                                         /* This occurs when user tries to read
1308                                          * from never connected socket.
1309                                          */
1310                                         copied = -ENOTCONN;
1311                                         break;
1312                                 }
1313                                 break;
1314                         }
1315
1316                         if (!timeo) {
1317                                 copied = -EAGAIN;
1318                                 break;
1319                         }
1320
1321                         if (signal_pending(current)) {
1322                                 copied = sock_intr_errno(timeo);
1323                                 break;
1324                         }
1325                 }
1326
1327                 cleanup_rbuf(sk, copied);
1328
1329                 if (!sysctl_tcp_low_latency && tp->ucopy.task == user_recv) {
1330                         /* Install new reader */
1331                         if (!user_recv && !(flags & (MSG_TRUNC | MSG_PEEK))) {
1332                                 user_recv = current;
1333                                 tp->ucopy.task = user_recv;
1334                                 tp->ucopy.iov = msg->msg_iov;
1335                         }
1336
1337                         tp->ucopy.len = len;
1338
1339                         BUG_TRAP(tp->copied_seq == tp->rcv_nxt ||
1340                                  (flags & (MSG_PEEK | MSG_TRUNC)));
1341
1342                         /* Ugly... If prequeue is not empty, we have to
1343                          * process it before releasing socket, otherwise
1344                          * order will be broken at second iteration.
1345                          * More elegant solution is required!!!
1346                          *
1347                          * Look: we have the following (pseudo)queues:
1348                          *
1349                          * 1. packets in flight
1350                          * 2. backlog
1351                          * 3. prequeue
1352                          * 4. receive_queue
1353                          *
1354                          * Each queue can be processed only if the next ones
1355                          * are empty. At this point we have empty receive_queue.
1356                          * But prequeue _can_ be not empty after 2nd iteration,
1357                          * when we jumped to start of loop because backlog
1358                          * processing added something to receive_queue.
1359                          * We cannot release_sock(), because backlog contains
1360                          * packets arrived _after_ prequeued ones.
1361                          *
1362                          * Shortly, algorithm is clear --- to process all
1363                          * the queues in order. We could make it more directly,
1364                          * requeueing packets from backlog to prequeue, if
1365                          * is not empty. It is more elegant, but eats cycles,
1366                          * unfortunately.
1367                          */
1368                         if (skb_queue_len(&tp->ucopy.prequeue))
1369                                 goto do_prequeue;
1370
1371                         /* __ Set realtime policy in scheduler __ */
1372                 }
1373
1374                 if (copied >= target) {
1375                         /* Do not sleep, just process backlog. */
1376                         release_sock(sk);
1377                         lock_sock(sk);
1378                 } else
1379                         sk_wait_data(sk, &timeo);
1380
1381                 if (user_recv) {
1382                         int chunk;
1383
1384                         /* __ Restore normal policy in scheduler __ */
1385
1386                         if ((chunk = len - tp->ucopy.len) != 0) {
1387                                 NET_ADD_STATS_USER(LINUX_MIB_TCPDIRECTCOPYFROMBACKLOG, chunk);
1388                                 len -= chunk;
1389                                 copied += chunk;
1390                         }
1391
1392                         if (tp->rcv_nxt == tp->copied_seq &&
1393                             skb_queue_len(&tp->ucopy.prequeue)) {
1394 do_prequeue:
1395                                 tcp_prequeue_process(sk);
1396
1397                                 if ((chunk = len - tp->ucopy.len) != 0) {
1398                                         NET_ADD_STATS_USER(LINUX_MIB_TCPDIRECTCOPYFROMPREQUEUE, chunk);
1399                                         len -= chunk;
1400                                         copied += chunk;
1401                                 }
1402                         }
1403                 }
1404                 if ((flags & MSG_PEEK) && peek_seq != tp->copied_seq) {
1405                         if (net_ratelimit())
1406                                 printk(KERN_DEBUG "TCP(%s:%d): Application bug, race in MSG_PEEK.\n",
1407                                        current->comm, current->pid);
1408                         peek_seq = tp->copied_seq;
1409                 }
1410                 continue;
1411
1412         found_ok_skb:
1413                 /* Ok so how much can we use? */
1414                 used = skb->len - offset;
1415                 if (len < used)
1416                         used = len;
1417
1418                 /* Do we have urgent data here? */
1419                 if (tp->urg_data) {
1420                         u32 urg_offset = tp->urg_seq - *seq;
1421                         if (urg_offset < used) {
1422                                 if (!urg_offset) {
1423                                         if (!sock_flag(sk, SOCK_URGINLINE)) {
1424                                                 ++*seq;
1425                                                 offset++;
1426                                                 used--;
1427                                                 if (!used)
1428                                                         goto skip_copy;
1429                                         }
1430                                 } else
1431                                         used = urg_offset;
1432                         }
1433                 }
1434
1435                 if (!(flags & MSG_TRUNC)) {
1436                         err = skb_copy_datagram_iovec(skb, offset,
1437                                                       msg->msg_iov, used);
1438                         if (err) {
1439                                 /* Exception. Bailout! */
1440                                 if (!copied)
1441                                         copied = -EFAULT;
1442                                 break;
1443                         }
1444                 }
1445
1446                 *seq += used;
1447                 copied += used;
1448                 len -= used;
1449
1450                 tcp_rcv_space_adjust(sk);
1451
1452 skip_copy:
1453                 if (tp->urg_data && after(tp->copied_seq, tp->urg_seq)) {
1454                         tp->urg_data = 0;
1455                         tcp_fast_path_check(sk, tp);
1456                 }
1457                 if (used + offset < skb->len)
1458                         continue;
1459
1460                 if (skb->h.th->fin)
1461                         goto found_fin_ok;
1462                 if (!(flags & MSG_PEEK))
1463                         sk_eat_skb(sk, skb);
1464                 continue;
1465
1466         found_fin_ok:
1467                 /* Process the FIN. */
1468                 ++*seq;
1469                 if (!(flags & MSG_PEEK))
1470                         sk_eat_skb(sk, skb);
1471                 break;
1472         } while (len > 0);
1473
1474         if (user_recv) {
1475                 if (skb_queue_len(&tp->ucopy.prequeue)) {
1476                         int chunk;
1477
1478                         tp->ucopy.len = copied > 0 ? len : 0;
1479
1480                         tcp_prequeue_process(sk);
1481
1482                         if (copied > 0 && (chunk = len - tp->ucopy.len) != 0) {
1483                                 NET_ADD_STATS_USER(LINUX_MIB_TCPDIRECTCOPYFROMPREQUEUE, chunk);
1484                                 len -= chunk;
1485                                 copied += chunk;
1486                         }
1487                 }
1488
1489                 tp->ucopy.task = NULL;
1490                 tp->ucopy.len = 0;
1491         }
1492
1493         /* According to UNIX98, msg_name/msg_namelen are ignored
1494          * on connected socket. I was just happy when found this 8) --ANK
1495          */
1496
1497         /* Clean up data we have read: This will do ACK frames. */
1498         cleanup_rbuf(sk, copied);
1499
1500         TCP_CHECK_TIMER(sk);
1501         release_sock(sk);
1502         return copied;
1503
1504 out:
1505         TCP_CHECK_TIMER(sk);
1506         release_sock(sk);
1507         return err;
1508
1509 recv_urg:
1510         err = tcp_recv_urg(sk, timeo, msg, len, flags, addr_len);
1511         goto out;
1512 }
1513
1514 /*
1515  *      State processing on a close. This implements the state shift for
1516  *      sending our FIN frame. Note that we only send a FIN for some
1517  *      states. A shutdown() may have already sent the FIN, or we may be
1518  *      closed.
1519  */
1520
1521 static unsigned char new_state[16] = {
1522   /* current state:        new state:      action:      */
1523   /* (Invalid)          */ TCP_CLOSE,
1524   /* TCP_ESTABLISHED    */ TCP_FIN_WAIT1 | TCP_ACTION_FIN,
1525   /* TCP_SYN_SENT       */ TCP_CLOSE,
1526   /* TCP_SYN_RECV       */ TCP_FIN_WAIT1 | TCP_ACTION_FIN,
1527   /* TCP_FIN_WAIT1      */ TCP_FIN_WAIT1,
1528   /* TCP_FIN_WAIT2      */ TCP_FIN_WAIT2,
1529   /* TCP_TIME_WAIT      */ TCP_CLOSE,
1530   /* TCP_CLOSE          */ TCP_CLOSE,
1531   /* TCP_CLOSE_WAIT     */ TCP_LAST_ACK  | TCP_ACTION_FIN,
1532   /* TCP_LAST_ACK       */ TCP_LAST_ACK,
1533   /* TCP_LISTEN         */ TCP_CLOSE,
1534   /* TCP_CLOSING        */ TCP_CLOSING,
1535 };
1536
1537 static int tcp_close_state(struct sock *sk)
1538 {
1539         int next = (int)new_state[sk->sk_state];
1540         int ns = next & TCP_STATE_MASK;
1541
1542         tcp_set_state(sk, ns);
1543
1544         return next & TCP_ACTION_FIN;
1545 }
1546
1547 /*
1548  *      Shutdown the sending side of a connection. Much like close except
1549  *      that we don't receive shut down or set_sock_flag(sk, SOCK_DEAD).
1550  */
1551
1552 void tcp_shutdown(struct sock *sk, int how)
1553 {
1554         /*      We need to grab some memory, and put together a FIN,
1555          *      and then put it into the queue to be sent.
1556          *              Tim MacKenzie(tym@dibbler.cs.monash.edu.au) 4 Dec '92.
1557          */
1558         if (!(how & SEND_SHUTDOWN))
1559                 return;
1560
1561         /* If we've already sent a FIN, or it's a closed state, skip this. */
1562         if ((1 << sk->sk_state) &
1563             (TCPF_ESTABLISHED | TCPF_SYN_SENT |
1564              TCPF_SYN_RECV | TCPF_CLOSE_WAIT)) {
1565                 /* Clear out any half completed packets.  FIN if needed. */
1566                 if (tcp_close_state(sk))
1567                         tcp_send_fin(sk);
1568         }
1569 }
1570
1571 /*
1572  * At this point, there should be no process reference to this
1573  * socket, and thus no user references at all.  Therefore we
1574  * can assume the socket waitqueue is inactive and nobody will
1575  * try to jump onto it.
1576  */
1577 void tcp_destroy_sock(struct sock *sk)
1578 {
1579         BUG_TRAP(sk->sk_state == TCP_CLOSE);
1580         BUG_TRAP(sock_flag(sk, SOCK_DEAD));
1581
1582         /* It cannot be in hash table! */
1583         BUG_TRAP(sk_unhashed(sk));
1584
1585         /* If it has not 0 inet_sk(sk)->num, it must be bound */
1586         BUG_TRAP(!inet_sk(sk)->num || tcp_sk(sk)->bind_hash);
1587
1588         sk->sk_prot->destroy(sk);
1589
1590         sk_stream_kill_queues(sk);
1591
1592         xfrm_sk_free_policy(sk);
1593
1594 #ifdef INET_REFCNT_DEBUG
1595         if (atomic_read(&sk->sk_refcnt) != 1) {
1596                 printk(KERN_DEBUG "Destruction TCP %p delayed, c=%d\n",
1597                        sk, atomic_read(&sk->sk_refcnt));
1598         }
1599 #endif
1600
1601         atomic_dec(&tcp_orphan_count);
1602         sock_put(sk);
1603 }
1604
1605 void tcp_close(struct sock *sk, long timeout)
1606 {
1607         struct sk_buff *skb;
1608         int data_was_unread = 0;
1609
1610         lock_sock(sk);
1611         sk->sk_shutdown = SHUTDOWN_MASK;
1612
1613         if (sk->sk_state == TCP_LISTEN) {
1614                 tcp_set_state(sk, TCP_CLOSE);
1615
1616                 /* Special case. */
1617                 tcp_listen_stop(sk);
1618
1619                 goto adjudge_to_death;
1620         }
1621
1622         /*  We need to flush the recv. buffs.  We do this only on the
1623          *  descriptor close, not protocol-sourced closes, because the
1624          *  reader process may not have drained the data yet!
1625          */
1626         while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
1627                 u32 len = TCP_SKB_CB(skb)->end_seq - TCP_SKB_CB(skb)->seq -
1628                           skb->h.th->fin;
1629                 data_was_unread += len;
1630                 __kfree_skb(skb);
1631         }
1632
1633         sk_stream_mem_reclaim(sk);
1634
1635         /* As outlined in draft-ietf-tcpimpl-prob-03.txt, section
1636          * 3.10, we send a RST here because data was lost.  To
1637          * witness the awful effects of the old behavior of always
1638          * doing a FIN, run an older 2.1.x kernel or 2.0.x, start
1639          * a bulk GET in an FTP client, suspend the process, wait
1640          * for the client to advertise a zero window, then kill -9
1641          * the FTP client, wheee...  Note: timeout is always zero
1642          * in such a case.
1643          */
1644         if (data_was_unread) {
1645                 /* Unread data was tossed, zap the connection. */
1646                 NET_INC_STATS_USER(LINUX_MIB_TCPABORTONCLOSE);
1647                 tcp_set_state(sk, TCP_CLOSE);
1648                 tcp_send_active_reset(sk, GFP_KERNEL);
1649         } else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
1650                 /* Check zero linger _after_ checking for unread data. */
1651                 sk->sk_prot->disconnect(sk, 0);
1652                 NET_INC_STATS_USER(LINUX_MIB_TCPABORTONDATA);
1653         } else if (tcp_close_state(sk)) {
1654                 /* We FIN if the application ate all the data before
1655                  * zapping the connection.
1656                  */
1657
1658                 /* RED-PEN. Formally speaking, we have broken TCP state
1659                  * machine. State transitions:
1660                  *
1661                  * TCP_ESTABLISHED -> TCP_FIN_WAIT1
1662                  * TCP_SYN_RECV -> TCP_FIN_WAIT1 (forget it, it's impossible)
1663                  * TCP_CLOSE_WAIT -> TCP_LAST_ACK
1664                  *
1665                  * are legal only when FIN has been sent (i.e. in window),
1666                  * rather than queued out of window. Purists blame.
1667                  *
1668                  * F.e. "RFC state" is ESTABLISHED,
1669                  * if Linux state is FIN-WAIT-1, but FIN is still not sent.
1670                  *
1671                  * The visible declinations are that sometimes
1672                  * we enter time-wait state, when it is not required really
1673                  * (harmless), do not send active resets, when they are
1674                  * required by specs (TCP_ESTABLISHED, TCP_CLOSE_WAIT, when
1675                  * they look as CLOSING or LAST_ACK for Linux)
1676                  * Probably, I missed some more holelets.
1677                  *                                              --ANK
1678                  */
1679                 tcp_send_fin(sk);
1680         }
1681
1682         sk_stream_wait_close(sk, timeout);
1683
1684 adjudge_to_death:
1685         /* It is the last release_sock in its life. It will remove backlog. */
1686         release_sock(sk);
1687
1688
1689         /* Now socket is owned by kernel and we acquire BH lock
1690            to finish close. No need to check for user refs.
1691          */
1692         local_bh_disable();
1693         bh_lock_sock(sk);
1694         BUG_TRAP(!sock_owned_by_user(sk));
1695
1696         sock_hold(sk);
1697         sock_orphan(sk);
1698
1699         /*      This is a (useful) BSD violating of the RFC. There is a
1700          *      problem with TCP as specified in that the other end could
1701          *      keep a socket open forever with no application left this end.
1702          *      We use a 3 minute timeout (about the same as BSD) then kill
1703          *      our end. If they send after that then tough - BUT: long enough
1704          *      that we won't make the old 4*rto = almost no time - whoops
1705          *      reset mistake.
1706          *
1707          *      Nope, it was not mistake. It is really desired behaviour
1708          *      f.e. on http servers, when such sockets are useless, but
1709          *      consume significant resources. Let's do it with special
1710          *      linger2 option.                                 --ANK
1711          */
1712
1713         if (sk->sk_state == TCP_FIN_WAIT2) {
1714                 struct tcp_sock *tp = tcp_sk(sk);
1715                 if (tp->linger2 < 0) {
1716                         tcp_set_state(sk, TCP_CLOSE);
1717                         tcp_send_active_reset(sk, GFP_ATOMIC);
1718                         NET_INC_STATS_BH(LINUX_MIB_TCPABORTONLINGER);
1719                 } else {
1720                         int tmo = tcp_fin_time(tp);
1721
1722                         if (tmo > TCP_TIMEWAIT_LEN) {
1723                                 tcp_reset_keepalive_timer(sk, tcp_fin_time(tp));
1724                         } else {
1725                                 atomic_inc(&tcp_orphan_count);
1726                                 tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
1727                                 goto out;
1728                         }
1729                 }
1730         }
1731         if (sk->sk_state != TCP_CLOSE) {
1732                 sk_stream_mem_reclaim(sk);
1733                 if (atomic_read(&tcp_orphan_count) > sysctl_tcp_max_orphans ||
1734                     (sk->sk_wmem_queued > SOCK_MIN_SNDBUF &&
1735                      atomic_read(&tcp_memory_allocated) > sysctl_tcp_mem[2])) {
1736                         if (net_ratelimit())
1737                                 printk(KERN_INFO "TCP: too many of orphaned "
1738                                        "sockets\n");
1739                         tcp_set_state(sk, TCP_CLOSE);
1740                         tcp_send_active_reset(sk, GFP_ATOMIC);
1741                         NET_INC_STATS_BH(LINUX_MIB_TCPABORTONMEMORY);
1742                 }
1743         }
1744         atomic_inc(&tcp_orphan_count);
1745
1746         if (sk->sk_state == TCP_CLOSE)
1747                 tcp_destroy_sock(sk);
1748         /* Otherwise, socket is reprieved until protocol close. */
1749
1750 out:
1751         bh_unlock_sock(sk);
1752         local_bh_enable();
1753         sock_put(sk);
1754 }
1755
1756 /* These states need RST on ABORT according to RFC793 */
1757
1758 static inline int tcp_need_reset(int state)
1759 {
1760         return (1 << state) &
1761                (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_FIN_WAIT1 |
1762                 TCPF_FIN_WAIT2 | TCPF_SYN_RECV);
1763 }
1764
1765 int tcp_disconnect(struct sock *sk, int flags)
1766 {
1767         struct inet_sock *inet = inet_sk(sk);
1768         struct tcp_sock *tp = tcp_sk(sk);
1769         int err = 0;
1770         int old_state = sk->sk_state;
1771
1772         if (old_state != TCP_CLOSE)
1773                 tcp_set_state(sk, TCP_CLOSE);
1774
1775         /* ABORT function of RFC793 */
1776         if (old_state == TCP_LISTEN) {
1777                 tcp_listen_stop(sk);
1778         } else if (tcp_need_reset(old_state) ||
1779                    (tp->snd_nxt != tp->write_seq &&
1780                     (1 << old_state) & (TCPF_CLOSING | TCPF_LAST_ACK))) {
1781                 /* The last check adjusts for discrepance of Linux wrt. RFC
1782                  * states
1783                  */
1784                 tcp_send_active_reset(sk, gfp_any());
1785                 sk->sk_err = ECONNRESET;
1786         } else if (old_state == TCP_SYN_SENT)
1787                 sk->sk_err = ECONNRESET;
1788
1789         tcp_clear_xmit_timers(sk);
1790         __skb_queue_purge(&sk->sk_receive_queue);
1791         sk_stream_writequeue_purge(sk);
1792         __skb_queue_purge(&tp->out_of_order_queue);
1793
1794         inet->dport = 0;
1795
1796         if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
1797                 inet_reset_saddr(sk);
1798
1799         sk->sk_shutdown = 0;
1800         sock_reset_flag(sk, SOCK_DONE);
1801         tp->srtt = 0;
1802         if ((tp->write_seq += tp->max_window + 2) == 0)
1803                 tp->write_seq = 1;
1804         tp->backoff = 0;
1805         tp->snd_cwnd = 2;
1806         tp->probes_out = 0;
1807         tp->packets_out = 0;
1808         tp->snd_ssthresh = 0x7fffffff;
1809         tp->snd_cwnd_cnt = 0;
1810         tcp_set_ca_state(tp, TCP_CA_Open);
1811         tcp_clear_retrans(tp);
1812         tcp_delack_init(tp);
1813         sk->sk_send_head = NULL;
1814         tp->rx_opt.saw_tstamp = 0;
1815         tcp_sack_reset(&tp->rx_opt);
1816         __sk_dst_reset(sk);
1817
1818         BUG_TRAP(!inet->num || tp->bind_hash);
1819
1820         sk->sk_error_report(sk);
1821         return err;
1822 }
1823
1824 /*
1825  *      Wait for an incoming connection, avoid race
1826  *      conditions. This must be called with the socket locked.
1827  */
1828 static int wait_for_connect(struct sock *sk, long timeo)
1829 {
1830         struct tcp_sock *tp = tcp_sk(sk);
1831         DEFINE_WAIT(wait);
1832         int err;
1833
1834         /*
1835          * True wake-one mechanism for incoming connections: only
1836          * one process gets woken up, not the 'whole herd'.
1837          * Since we do not 'race & poll' for established sockets
1838          * anymore, the common case will execute the loop only once.
1839          *
1840          * Subtle issue: "add_wait_queue_exclusive()" will be added
1841          * after any current non-exclusive waiters, and we know that
1842          * it will always _stay_ after any new non-exclusive waiters
1843          * because all non-exclusive waiters are added at the
1844          * beginning of the wait-queue. As such, it's ok to "drop"
1845          * our exclusiveness temporarily when we get woken up without
1846          * having to remove and re-insert us on the wait queue.
1847          */
1848         for (;;) {
1849                 prepare_to_wait_exclusive(sk->sk_sleep, &wait,
1850                                           TASK_INTERRUPTIBLE);
1851                 release_sock(sk);
1852                 if (reqsk_queue_empty(&tp->accept_queue))
1853                         timeo = schedule_timeout(timeo);
1854                 lock_sock(sk);
1855                 err = 0;
1856                 if (!reqsk_queue_empty(&tp->accept_queue))
1857                         break;
1858                 err = -EINVAL;
1859                 if (sk->sk_state != TCP_LISTEN)
1860                         break;
1861                 err = sock_intr_errno(timeo);
1862                 if (signal_pending(current))
1863                         break;
1864                 err = -EAGAIN;
1865                 if (!timeo)
1866                         break;
1867         }
1868         finish_wait(sk->sk_sleep, &wait);
1869         return err;
1870 }
1871
1872 /*
1873  *      This will accept the next outstanding connection.
1874  */
1875
1876 struct sock *tcp_accept(struct sock *sk, int flags, int *err)
1877 {
1878         struct tcp_sock *tp = tcp_sk(sk);
1879         struct sock *newsk;
1880         int error;
1881
1882         lock_sock(sk);
1883
1884         /* We need to make sure that this socket is listening,
1885          * and that it has something pending.
1886          */
1887         error = -EINVAL;
1888         if (sk->sk_state != TCP_LISTEN)
1889                 goto out_err;
1890
1891         /* Find already established connection */
1892         if (reqsk_queue_empty(&tp->accept_queue)) {
1893                 long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
1894
1895                 /* If this is a non blocking socket don't sleep */
1896                 error = -EAGAIN;
1897                 if (!timeo)
1898                         goto out_err;
1899
1900                 error = wait_for_connect(sk, timeo);
1901                 if (error)
1902                         goto out_err;
1903         }
1904
1905         newsk = reqsk_queue_get_child(&tp->accept_queue, sk);
1906         BUG_TRAP(newsk->sk_state != TCP_SYN_RECV);
1907 out:
1908         release_sock(sk);
1909         return newsk;
1910 out_err:
1911         newsk = NULL;
1912         *err = error;
1913         goto out;
1914 }
1915
1916 /*
1917  *      Socket option code for TCP.
1918  */
1919 int tcp_setsockopt(struct sock *sk, int level, int optname, char __user *optval,
1920                    int optlen)
1921 {
1922         struct tcp_sock *tp = tcp_sk(sk);
1923         int val;
1924         int err = 0;
1925
1926         if (level != SOL_TCP)
1927                 return tp->af_specific->setsockopt(sk, level, optname,
1928                                                    optval, optlen);
1929
1930         if (optlen < sizeof(int))
1931                 return -EINVAL;
1932
1933         if (get_user(val, (int __user *)optval))
1934                 return -EFAULT;
1935
1936         lock_sock(sk);
1937
1938         switch (optname) {
1939         case TCP_MAXSEG:
1940                 /* Values greater than interface MTU won't take effect. However
1941                  * at the point when this call is done we typically don't yet
1942                  * know which interface is going to be used */
1943                 if (val < 8 || val > MAX_TCP_WINDOW) {
1944                         err = -EINVAL;
1945                         break;
1946                 }
1947                 tp->rx_opt.user_mss = val;
1948                 break;
1949
1950         case TCP_NODELAY:
1951                 if (val) {
1952                         /* TCP_NODELAY is weaker than TCP_CORK, so that
1953                          * this option on corked socket is remembered, but
1954                          * it is not activated until cork is cleared.
1955                          *
1956                          * However, when TCP_NODELAY is set we make
1957                          * an explicit push, which overrides even TCP_CORK
1958                          * for currently queued segments.
1959                          */
1960                         tp->nonagle |= TCP_NAGLE_OFF|TCP_NAGLE_PUSH;
1961                         tcp_push_pending_frames(sk, tp);
1962                 } else {
1963                         tp->nonagle &= ~TCP_NAGLE_OFF;
1964                 }
1965                 break;
1966
1967         case TCP_CORK:
1968                 /* When set indicates to always queue non-full frames.
1969                  * Later the user clears this option and we transmit
1970                  * any pending partial frames in the queue.  This is
1971                  * meant to be used alongside sendfile() to get properly
1972                  * filled frames when the user (for example) must write
1973                  * out headers with a write() call first and then use
1974                  * sendfile to send out the data parts.
1975                  *
1976                  * TCP_CORK can be set together with TCP_NODELAY and it is
1977                  * stronger than TCP_NODELAY.
1978                  */
1979                 if (val) {
1980                         tp->nonagle |= TCP_NAGLE_CORK;
1981                 } else {
1982                         tp->nonagle &= ~TCP_NAGLE_CORK;
1983                         if (tp->nonagle&TCP_NAGLE_OFF)
1984                                 tp->nonagle |= TCP_NAGLE_PUSH;
1985                         tcp_push_pending_frames(sk, tp);
1986                 }
1987                 break;
1988
1989         case TCP_KEEPIDLE:
1990                 if (val < 1 || val > MAX_TCP_KEEPIDLE)
1991                         err = -EINVAL;
1992                 else {
1993                         tp->keepalive_time = val * HZ;
1994                         if (sock_flag(sk, SOCK_KEEPOPEN) &&
1995                             !((1 << sk->sk_state) &
1996                               (TCPF_CLOSE | TCPF_LISTEN))) {
1997                                 __u32 elapsed = tcp_time_stamp - tp->rcv_tstamp;
1998                                 if (tp->keepalive_time > elapsed)
1999                                         elapsed = tp->keepalive_time - elapsed;
2000                                 else
2001                                         elapsed = 0;
2002                                 tcp_reset_keepalive_timer(sk, elapsed);
2003                         }
2004                 }
2005                 break;
2006         case TCP_KEEPINTVL:
2007                 if (val < 1 || val > MAX_TCP_KEEPINTVL)
2008                         err = -EINVAL;
2009                 else
2010                         tp->keepalive_intvl = val * HZ;
2011                 break;
2012         case TCP_KEEPCNT:
2013                 if (val < 1 || val > MAX_TCP_KEEPCNT)
2014                         err = -EINVAL;
2015                 else
2016                         tp->keepalive_probes = val;
2017                 break;
2018         case TCP_SYNCNT:
2019                 if (val < 1 || val > MAX_TCP_SYNCNT)
2020                         err = -EINVAL;
2021                 else
2022                         tp->syn_retries = val;
2023                 break;
2024
2025         case TCP_LINGER2:
2026                 if (val < 0)
2027                         tp->linger2 = -1;
2028                 else if (val > sysctl_tcp_fin_timeout / HZ)
2029                         tp->linger2 = 0;
2030                 else
2031                         tp->linger2 = val * HZ;
2032                 break;
2033
2034         case TCP_DEFER_ACCEPT:
2035                 tp->defer_accept = 0;
2036                 if (val > 0) {
2037                         /* Translate value in seconds to number of
2038                          * retransmits */
2039                         while (tp->defer_accept < 32 &&
2040                                val > ((TCP_TIMEOUT_INIT / HZ) <<
2041                                        tp->defer_accept))
2042                                 tp->defer_accept++;
2043                         tp->defer_accept++;
2044                 }
2045                 break;
2046
2047         case TCP_WINDOW_CLAMP:
2048                 if (!val) {
2049                         if (sk->sk_state != TCP_CLOSE) {
2050                                 err = -EINVAL;
2051                                 break;
2052                         }
2053                         tp->window_clamp = 0;
2054                 } else
2055                         tp->window_clamp = val < SOCK_MIN_RCVBUF / 2 ?
2056                                                 SOCK_MIN_RCVBUF / 2 : val;
2057                 break;
2058
2059         case TCP_QUICKACK:
2060                 if (!val) {
2061                         tp->ack.pingpong = 1;
2062                 } else {
2063                         tp->ack.pingpong = 0;
2064                         if ((1 << sk->sk_state) &
2065                             (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT) &&
2066                             tcp_ack_scheduled(tp)) {
2067                                 tp->ack.pending |= TCP_ACK_PUSHED;
2068                                 cleanup_rbuf(sk, 1);
2069                                 if (!(val & 1))
2070                                         tp->ack.pingpong = 1;
2071                         }
2072                 }
2073                 break;
2074
2075         default:
2076                 err = -ENOPROTOOPT;
2077                 break;
2078         };
2079         release_sock(sk);
2080         return err;
2081 }
2082
2083 /* Return information about state of tcp endpoint in API format. */
2084 void tcp_get_info(struct sock *sk, struct tcp_info *info)
2085 {
2086         struct tcp_sock *tp = tcp_sk(sk);
2087         u32 now = tcp_time_stamp;
2088
2089         memset(info, 0, sizeof(*info));
2090
2091         info->tcpi_state = sk->sk_state;
2092         info->tcpi_ca_state = tp->ca_state;
2093         info->tcpi_retransmits = tp->retransmits;
2094         info->tcpi_probes = tp->probes_out;
2095         info->tcpi_backoff = tp->backoff;
2096
2097         if (tp->rx_opt.tstamp_ok)
2098                 info->tcpi_options |= TCPI_OPT_TIMESTAMPS;
2099         if (tp->rx_opt.sack_ok)
2100                 info->tcpi_options |= TCPI_OPT_SACK;
2101         if (tp->rx_opt.wscale_ok) {
2102                 info->tcpi_options |= TCPI_OPT_WSCALE;
2103                 info->tcpi_snd_wscale = tp->rx_opt.snd_wscale;
2104                 info->tcpi_rcv_wscale = tp->rx_opt.rcv_wscale;
2105         } 
2106
2107         if (tp->ecn_flags&TCP_ECN_OK)
2108                 info->tcpi_options |= TCPI_OPT_ECN;
2109
2110         info->tcpi_rto = jiffies_to_usecs(tp->rto);
2111         info->tcpi_ato = jiffies_to_usecs(tp->ack.ato);
2112         info->tcpi_snd_mss = tp->mss_cache_std;
2113         info->tcpi_rcv_mss = tp->ack.rcv_mss;
2114
2115         info->tcpi_unacked = tp->packets_out;
2116         info->tcpi_sacked = tp->sacked_out;
2117         info->tcpi_lost = tp->lost_out;
2118         info->tcpi_retrans = tp->retrans_out;
2119         info->tcpi_fackets = tp->fackets_out;
2120
2121         info->tcpi_last_data_sent = jiffies_to_msecs(now - tp->lsndtime);
2122         info->tcpi_last_data_recv = jiffies_to_msecs(now - tp->ack.lrcvtime);
2123         info->tcpi_last_ack_recv = jiffies_to_msecs(now - tp->rcv_tstamp);
2124
2125         info->tcpi_pmtu = tp->pmtu_cookie;
2126         info->tcpi_rcv_ssthresh = tp->rcv_ssthresh;
2127         info->tcpi_rtt = jiffies_to_usecs(tp->srtt)>>3;
2128         info->tcpi_rttvar = jiffies_to_usecs(tp->mdev)>>2;
2129         info->tcpi_snd_ssthresh = tp->snd_ssthresh;
2130         info->tcpi_snd_cwnd = tp->snd_cwnd;
2131         info->tcpi_advmss = tp->advmss;
2132         info->tcpi_reordering = tp->reordering;
2133
2134         info->tcpi_rcv_rtt = jiffies_to_usecs(tp->rcv_rtt_est.rtt)>>3;
2135         info->tcpi_rcv_space = tp->rcvq_space.space;
2136
2137         info->tcpi_total_retrans = tp->total_retrans;
2138 }
2139
2140 EXPORT_SYMBOL_GPL(tcp_get_info);
2141
2142 int tcp_getsockopt(struct sock *sk, int level, int optname, char __user *optval,
2143                    int __user *optlen)
2144 {
2145         struct tcp_sock *tp = tcp_sk(sk);
2146         int val, len;
2147
2148         if (level != SOL_TCP)
2149                 return tp->af_specific->getsockopt(sk, level, optname,
2150                                                    optval, optlen);
2151
2152         if (get_user(len, optlen))
2153                 return -EFAULT;
2154
2155         len = min_t(unsigned int, len, sizeof(int));
2156
2157         if (len < 0)
2158                 return -EINVAL;
2159
2160         switch (optname) {
2161         case TCP_MAXSEG:
2162                 val = tp->mss_cache_std;
2163                 if (!val && ((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN)))
2164                         val = tp->rx_opt.user_mss;
2165                 break;
2166         case TCP_NODELAY:
2167                 val = !!(tp->nonagle&TCP_NAGLE_OFF);
2168                 break;
2169         case TCP_CORK:
2170                 val = !!(tp->nonagle&TCP_NAGLE_CORK);
2171                 break;
2172         case TCP_KEEPIDLE:
2173                 val = (tp->keepalive_time ? : sysctl_tcp_keepalive_time) / HZ;
2174                 break;
2175         case TCP_KEEPINTVL:
2176                 val = (tp->keepalive_intvl ? : sysctl_tcp_keepalive_intvl) / HZ;
2177                 break;
2178         case TCP_KEEPCNT:
2179                 val = tp->keepalive_probes ? : sysctl_tcp_keepalive_probes;
2180                 break;
2181         case TCP_SYNCNT:
2182                 val = tp->syn_retries ? : sysctl_tcp_syn_retries;
2183                 break;
2184         case TCP_LINGER2:
2185                 val = tp->linger2;
2186                 if (val >= 0)
2187                         val = (val ? : sysctl_tcp_fin_timeout) / HZ;
2188                 break;
2189         case TCP_DEFER_ACCEPT:
2190                 val = !tp->defer_accept ? 0 : ((TCP_TIMEOUT_INIT / HZ) <<
2191                                                (tp->defer_accept - 1));
2192                 break;
2193         case TCP_WINDOW_CLAMP:
2194                 val = tp->window_clamp;
2195                 break;
2196         case TCP_INFO: {
2197                 struct tcp_info info;
2198
2199                 if (get_user(len, optlen))
2200                         return -EFAULT;
2201
2202                 tcp_get_info(sk, &info);
2203
2204                 len = min_t(unsigned int, len, sizeof(info));
2205                 if (put_user(len, optlen))
2206                         return -EFAULT;
2207                 if (copy_to_user(optval, &info, len))
2208                         return -EFAULT;
2209                 return 0;
2210         }
2211         case TCP_QUICKACK:
2212                 val = !tp->ack.pingpong;
2213                 break;
2214         default:
2215                 return -ENOPROTOOPT;
2216         };
2217
2218         if (put_user(len, optlen))
2219                 return -EFAULT;
2220         if (copy_to_user(optval, &val, len))
2221                 return -EFAULT;
2222         return 0;
2223 }
2224
2225
2226 extern void __skb_cb_too_small_for_tcp(int, int);
2227 extern void tcpdiag_init(void);
2228
2229 static __initdata unsigned long thash_entries;
2230 static int __init set_thash_entries(char *str)
2231 {
2232         if (!str)
2233                 return 0;
2234         thash_entries = simple_strtoul(str, &str, 0);
2235         return 1;
2236 }
2237 __setup("thash_entries=", set_thash_entries);
2238
2239 void __init tcp_init(void)
2240 {
2241         struct sk_buff *skb = NULL;
2242         int order, i;
2243
2244         if (sizeof(struct tcp_skb_cb) > sizeof(skb->cb))
2245                 __skb_cb_too_small_for_tcp(sizeof(struct tcp_skb_cb),
2246                                            sizeof(skb->cb));
2247
2248         tcp_bucket_cachep = kmem_cache_create("tcp_bind_bucket",
2249                                               sizeof(struct tcp_bind_bucket),
2250                                               0, SLAB_HWCACHE_ALIGN,
2251                                               NULL, NULL);
2252         if (!tcp_bucket_cachep)
2253                 panic("tcp_init: Cannot alloc tcp_bind_bucket cache.");
2254
2255         tcp_timewait_cachep = kmem_cache_create("tcp_tw_bucket",
2256                                                 sizeof(struct tcp_tw_bucket),
2257                                                 0, SLAB_HWCACHE_ALIGN,
2258                                                 NULL, NULL);
2259         if (!tcp_timewait_cachep)
2260                 panic("tcp_init: Cannot alloc tcp_tw_bucket cache.");
2261
2262         /* Size and allocate the main established and bind bucket
2263          * hash tables.
2264          *
2265          * The methodology is similar to that of the buffer cache.
2266          */
2267         tcp_ehash = (struct tcp_ehash_bucket *)
2268                 alloc_large_system_hash("TCP established",
2269                                         sizeof(struct tcp_ehash_bucket),
2270                                         thash_entries,
2271                                         (num_physpages >= 128 * 1024) ?
2272                                                 (25 - PAGE_SHIFT) :
2273                                                 (27 - PAGE_SHIFT),
2274                                         HASH_HIGHMEM,
2275                                         &tcp_ehash_size,
2276                                         NULL,
2277                                         0);
2278         tcp_ehash_size = (1 << tcp_ehash_size) >> 1;
2279         for (i = 0; i < (tcp_ehash_size << 1); i++) {
2280                 rwlock_init(&tcp_ehash[i].lock);
2281                 INIT_HLIST_HEAD(&tcp_ehash[i].chain);
2282         }
2283
2284         tcp_bhash = (struct tcp_bind_hashbucket *)
2285                 alloc_large_system_hash("TCP bind",
2286                                         sizeof(struct tcp_bind_hashbucket),
2287                                         tcp_ehash_size,
2288                                         (num_physpages >= 128 * 1024) ?
2289                                                 (25 - PAGE_SHIFT) :
2290                                                 (27 - PAGE_SHIFT),
2291                                         HASH_HIGHMEM,
2292                                         &tcp_bhash_size,
2293                                         NULL,
2294                                         64 * 1024);
2295         tcp_bhash_size = 1 << tcp_bhash_size;
2296         for (i = 0; i < tcp_bhash_size; i++) {
2297                 spin_lock_init(&tcp_bhash[i].lock);
2298                 INIT_HLIST_HEAD(&tcp_bhash[i].chain);
2299         }
2300
2301         /* Try to be a bit smarter and adjust defaults depending
2302          * on available memory.
2303          */
2304         for (order = 0; ((1 << order) << PAGE_SHIFT) <
2305                         (tcp_bhash_size * sizeof(struct tcp_bind_hashbucket));
2306                         order++)
2307                 ;
2308         if (order >= 4) {
2309                 sysctl_local_port_range[0] = 32768;
2310                 sysctl_local_port_range[1] = 61000;
2311                 sysctl_tcp_max_tw_buckets = 180000;
2312                 sysctl_tcp_max_orphans = 4096 << (order - 4);
2313                 sysctl_max_syn_backlog = 1024;
2314         } else if (order < 3) {
2315                 sysctl_local_port_range[0] = 1024 * (3 - order);
2316                 sysctl_tcp_max_tw_buckets >>= (3 - order);
2317                 sysctl_tcp_max_orphans >>= (3 - order);
2318                 sysctl_max_syn_backlog = 128;
2319         }
2320         tcp_port_rover = sysctl_local_port_range[0] - 1;
2321
2322         sysctl_tcp_mem[0] =  768 << order;
2323         sysctl_tcp_mem[1] = 1024 << order;
2324         sysctl_tcp_mem[2] = 1536 << order;
2325
2326         if (order < 3) {
2327                 sysctl_tcp_wmem[2] = 64 * 1024;
2328                 sysctl_tcp_rmem[0] = PAGE_SIZE;
2329                 sysctl_tcp_rmem[1] = 43689;
2330                 sysctl_tcp_rmem[2] = 2 * 43689;
2331         }
2332
2333         printk(KERN_INFO "TCP: Hash tables configured "
2334                "(established %d bind %d)\n",
2335                tcp_ehash_size << 1, tcp_bhash_size);
2336
2337         tcp_register_congestion_control(&tcp_reno);
2338 }
2339
2340 EXPORT_SYMBOL(tcp_accept);
2341 EXPORT_SYMBOL(tcp_close);
2342 EXPORT_SYMBOL(tcp_destroy_sock);
2343 EXPORT_SYMBOL(tcp_disconnect);
2344 EXPORT_SYMBOL(tcp_getsockopt);
2345 EXPORT_SYMBOL(tcp_ioctl);
2346 EXPORT_SYMBOL(tcp_poll);
2347 EXPORT_SYMBOL(tcp_read_sock);
2348 EXPORT_SYMBOL(tcp_recvmsg);
2349 EXPORT_SYMBOL(tcp_sendmsg);
2350 EXPORT_SYMBOL(tcp_sendpage);
2351 EXPORT_SYMBOL(tcp_setsockopt);
2352 EXPORT_SYMBOL(tcp_shutdown);
2353 EXPORT_SYMBOL(tcp_statistics);
2354 EXPORT_SYMBOL(tcp_timewait_cachep);