blob: 43cf901d765970b6a1a80f167a80ec285a8397b6 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 *
Jesper Juhl02c30a82005-05-05 16:16:16 -07008 * Authors: Ross Biro
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
10 * Mark Evans, <evansmp@uhura.aston.ac.uk>
11 * Corey Minyard <wf-rch!minyard@relay.EU.net>
12 * Florian La Roche, <flla@stud.uni-sb.de>
13 * Charles Hedrick, <hedrick@klinzhai.rutgers.edu>
14 * Linus Torvalds, <torvalds@cs.helsinki.fi>
15 * Alan Cox, <gw4pts@gw4pts.ampr.org>
16 * Matthew Dillon, <dillon@apollo.west.oic.com>
17 * Arnt Gulbrandsen, <agulbra@nvg.unit.no>
18 * Jorge Cwik, <jorge@laser.satlink.net>
19 */
20
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/mm.h>
22#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090023#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/sysctl.h>
25#include <linux/workqueue.h>
26#include <net/tcp.h>
27#include <net/inet_common.h>
28#include <net/xfrm.h>
29
David S. Millere994b7c2009-11-21 11:22:25 -080030int sysctl_tcp_syncookies __read_mostly = 1;
Glenn Griffinc6aefaf2008-02-07 21:49:26 -080031EXPORT_SYMBOL(sysctl_tcp_syncookies);
32
Brian Haleyab32ea52006-09-22 14:15:41 -070033int sysctl_tcp_abort_on_overflow __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -070035struct inet_timewait_death_row tcp_death_row = {
36 .sysctl_max_tw_buckets = NR_FILE * 2,
37 .period = TCP_TIMEWAIT_LEN / INET_TWDR_TWKILL_SLOTS,
Ingo Molnare4d91912006-07-03 00:24:34 -070038 .death_lock = __SPIN_LOCK_UNLOCKED(tcp_death_row.death_lock),
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -070039 .hashinfo = &tcp_hashinfo,
40 .tw_timer = TIMER_INITIALIZER(inet_twdr_hangman, 0,
41 (unsigned long)&tcp_death_row),
42 .twkill_work = __WORK_INITIALIZER(tcp_death_row.twkill_work,
David Howells65f27f32006-11-22 14:55:48 +000043 inet_twdr_twkill_work),
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -070044/* Short-time timewait calendar */
45
46 .twcal_hand = -1,
47 .twcal_timer = TIMER_INITIALIZER(inet_twdr_twcal_tick, 0,
48 (unsigned long)&tcp_death_row),
49};
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -070050EXPORT_SYMBOL_GPL(tcp_death_row);
51
Linus Torvalds1da177e2005-04-16 15:20:36 -070052static __inline__ int tcp_in_window(u32 seq, u32 end_seq, u32 s_win, u32 e_win)
53{
54 if (seq == s_win)
55 return 1;
56 if (after(end_seq, s_win) && before(seq, e_win))
57 return 1;
Eric Dumazeta02cec22010-09-22 20:43:57 +000058 return seq == e_win && seq == end_seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -070059}
60
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090061/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 * * Main purpose of TIME-WAIT state is to close connection gracefully,
63 * when one of ends sits in LAST-ACK or CLOSING retransmitting FIN
64 * (and, probably, tail of data) and one or more our ACKs are lost.
65 * * What is TIME-WAIT timeout? It is associated with maximal packet
66 * lifetime in the internet, which results in wrong conclusion, that
67 * it is set to catch "old duplicate segments" wandering out of their path.
68 * It is not quite correct. This timeout is calculated so that it exceeds
69 * maximal retransmission timeout enough to allow to lose one (or more)
70 * segments sent by peer and our ACKs. This time may be calculated from RTO.
71 * * When TIME-WAIT socket receives RST, it means that another end
72 * finally closed and we are allowed to kill TIME-WAIT too.
73 * * Second purpose of TIME-WAIT is catching old duplicate segments.
74 * Well, certainly it is pure paranoia, but if we load TIME-WAIT
75 * with this semantics, we MUST NOT kill TIME-WAIT state with RSTs.
76 * * If we invented some more clever way to catch duplicates
77 * (f.e. based on PAWS), we could truncate TIME-WAIT to several RTOs.
78 *
79 * The algorithm below is based on FORMAL INTERPRETATION of RFCs.
80 * When you compare it to RFCs, please, read section SEGMENT ARRIVES
81 * from the very beginning.
82 *
83 * NOTE. With recycling (and later with fin-wait-2) TW bucket
84 * is _not_ stateless. It means, that strictly speaking we must
85 * spinlock it. I do not want! Well, probability of misbehaviour
86 * is ridiculously low and, seems, we could use some mb() tricks
87 * to avoid misread sequence numbers, states etc. --ANK
88 */
89enum tcp_tw_status
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -070090tcp_timewait_state_process(struct inet_timewait_sock *tw, struct sk_buff *skb,
91 const struct tcphdr *th)
Linus Torvalds1da177e2005-04-16 15:20:36 -070092{
93 struct tcp_options_received tmp_opt;
William Allen Simpson4957faa2009-12-02 18:25:27 +000094 u8 *hash_location;
95 struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 int paws_reject = 0;
97
David S. Millerbb5b7c12009-12-15 20:56:42 -080098 tmp_opt.saw_tstamp = 0;
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -070099 if (th->doff > (sizeof(*th) >> 2) && tcptw->tw_ts_recent_stamp) {
David S. Millerbb5b7c12009-12-15 20:56:42 -0800100 tcp_parse_options(skb, &tmp_opt, &hash_location, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
102 if (tmp_opt.saw_tstamp) {
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700103 tmp_opt.ts_recent = tcptw->tw_ts_recent;
104 tmp_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
Ilpo Järvinenc887e6d2009-03-14 14:23:03 +0000105 paws_reject = tcp_paws_reject(&tmp_opt, th->rst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 }
107 }
108
109 if (tw->tw_substate == TCP_FIN_WAIT2) {
110 /* Just repeat all the checks of tcp_rcv_state_process() */
111
112 /* Out of window, send ACK */
113 if (paws_reject ||
114 !tcp_in_window(TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq,
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700115 tcptw->tw_rcv_nxt,
116 tcptw->tw_rcv_nxt + tcptw->tw_rcv_wnd))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 return TCP_TW_ACK;
118
119 if (th->rst)
120 goto kill;
121
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700122 if (th->syn && !before(TCP_SKB_CB(skb)->seq, tcptw->tw_rcv_nxt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 goto kill_with_rst;
124
125 /* Dup ACK? */
Wei Yongjun1ac530b2009-06-24 22:29:31 +0000126 if (!th->ack ||
127 !after(TCP_SKB_CB(skb)->end_seq, tcptw->tw_rcv_nxt) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 TCP_SKB_CB(skb)->end_seq == TCP_SKB_CB(skb)->seq) {
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700129 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 return TCP_TW_SUCCESS;
131 }
132
133 /* New data or FIN. If new data arrive after half-duplex close,
134 * reset.
135 */
136 if (!th->fin ||
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700137 TCP_SKB_CB(skb)->end_seq != tcptw->tw_rcv_nxt + 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138kill_with_rst:
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700139 inet_twsk_deschedule(tw, &tcp_death_row);
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700140 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 return TCP_TW_RST;
142 }
143
144 /* FIN arrived, enter true time-wait state. */
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700145 tw->tw_substate = TCP_TIME_WAIT;
146 tcptw->tw_rcv_nxt = TCP_SKB_CB(skb)->end_seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 if (tmp_opt.saw_tstamp) {
James Morris9d729f72007-03-04 16:12:44 -0800148 tcptw->tw_ts_recent_stamp = get_seconds();
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700149 tcptw->tw_ts_recent = tmp_opt.rcv_tsval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 }
151
152 /* I am shamed, but failed to make it more elegant.
153 * Yes, it is direct reference to IP, which is impossible
154 * to generalize to IPv6. Taking into account that IPv6
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -0800155 * do not understand recycling in any case, it not
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 * a big problem in practice. --ANK */
157 if (tw->tw_family == AF_INET &&
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700158 tcp_death_row.sysctl_tw_recycle && tcptw->tw_ts_recent_stamp &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 tcp_v4_tw_remember_stamp(tw))
Arnaldo Carvalho de Melo696ab2d2005-08-09 20:45:03 -0700160 inet_twsk_schedule(tw, &tcp_death_row, tw->tw_timeout,
161 TCP_TIMEWAIT_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 else
Arnaldo Carvalho de Melo696ab2d2005-08-09 20:45:03 -0700163 inet_twsk_schedule(tw, &tcp_death_row, TCP_TIMEWAIT_LEN,
164 TCP_TIMEWAIT_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 return TCP_TW_ACK;
166 }
167
168 /*
169 * Now real TIME-WAIT state.
170 *
171 * RFC 1122:
172 * "When a connection is [...] on TIME-WAIT state [...]
173 * [a TCP] MAY accept a new SYN from the remote TCP to
174 * reopen the connection directly, if it:
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900175 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 * (1) assigns its initial sequence number for the new
177 * connection to be larger than the largest sequence
178 * number it used on the previous connection incarnation,
179 * and
180 *
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900181 * (2) returns to TIME-WAIT state if the SYN turns out
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 * to be an old duplicate".
183 */
184
185 if (!paws_reject &&
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700186 (TCP_SKB_CB(skb)->seq == tcptw->tw_rcv_nxt &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq || th->rst))) {
188 /* In window segment, it may be only reset or bare ack. */
189
190 if (th->rst) {
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -0800191 /* This is TIME_WAIT assassination, in two flavors.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 * Oh well... nobody has a sufficient solution to this
193 * protocol bug yet.
194 */
195 if (sysctl_tcp_rfc1337 == 0) {
196kill:
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700197 inet_twsk_deschedule(tw, &tcp_death_row);
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700198 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 return TCP_TW_SUCCESS;
200 }
201 }
Arnaldo Carvalho de Melo696ab2d2005-08-09 20:45:03 -0700202 inet_twsk_schedule(tw, &tcp_death_row, TCP_TIMEWAIT_LEN,
203 TCP_TIMEWAIT_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
205 if (tmp_opt.saw_tstamp) {
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700206 tcptw->tw_ts_recent = tmp_opt.rcv_tsval;
James Morris9d729f72007-03-04 16:12:44 -0800207 tcptw->tw_ts_recent_stamp = get_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 }
209
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700210 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 return TCP_TW_SUCCESS;
212 }
213
214 /* Out of window segment.
215
216 All the segments are ACKed immediately.
217
218 The only exception is new SYN. We accept it, if it is
219 not old duplicate and we are not in danger to be killed
220 by delayed old duplicates. RFC check is that it has
221 newer sequence number works at rates <40Mbit/sec.
222 However, if paws works, it is reliable AND even more,
223 we even may relax silly seq space cutoff.
224
225 RED-PEN: we violate main RFC requirement, if this SYN will appear
226 old duplicate (i.e. we receive RST in reply to SYN-ACK),
227 we must return socket to time-wait state. It is not good,
228 but not fatal yet.
229 */
230
231 if (th->syn && !th->rst && !th->ack && !paws_reject &&
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700232 (after(TCP_SKB_CB(skb)->seq, tcptw->tw_rcv_nxt) ||
233 (tmp_opt.saw_tstamp &&
234 (s32)(tcptw->tw_ts_recent - tmp_opt.rcv_tsval) < 0))) {
235 u32 isn = tcptw->tw_snd_nxt + 65535 + 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 if (isn == 0)
237 isn++;
238 TCP_SKB_CB(skb)->when = isn;
239 return TCP_TW_SYN;
240 }
241
242 if (paws_reject)
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700243 NET_INC_STATS_BH(twsk_net(tw), LINUX_MIB_PAWSESTABREJECTED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
Stephen Hemminger2de979b2007-03-08 20:45:19 -0800245 if (!th->rst) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 /* In this case we must reset the TIMEWAIT timer.
247 *
248 * If it is ACKless SYN it may be both old duplicate
249 * and new good SYN with random sequence number <rcv_nxt.
250 * Do not reschedule in the last case.
251 */
252 if (paws_reject || th->ack)
Arnaldo Carvalho de Melo696ab2d2005-08-09 20:45:03 -0700253 inet_twsk_schedule(tw, &tcp_death_row, TCP_TIMEWAIT_LEN,
254 TCP_TIMEWAIT_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
256 /* Send ACK. Note, we do not put the bucket,
257 * it will be released by caller.
258 */
259 return TCP_TW_ACK;
260 }
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700261 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 return TCP_TW_SUCCESS;
263}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000264EXPORT_SYMBOL(tcp_timewait_state_process);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900266/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 * Move a socket to time-wait or dead fin-wait-2 state.
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900268 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269void tcp_time_wait(struct sock *sk, int state, int timeo)
270{
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700271 struct inet_timewait_sock *tw = NULL;
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800272 const struct inet_connection_sock *icsk = inet_csk(sk);
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700273 const struct tcp_sock *tp = tcp_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 int recycle_ok = 0;
275
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700276 if (tcp_death_row.sysctl_tw_recycle && tp->rx_opt.ts_recent_stamp)
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800277 recycle_ok = icsk->icsk_af_ops->remember_stamp(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700279 if (tcp_death_row.tw_count < tcp_death_row.sysctl_max_tw_buckets)
Arnaldo Carvalho de Meloc6762702005-08-09 20:09:59 -0700280 tw = inet_twsk_alloc(sk, state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700282 if (tw != NULL) {
283 struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700284 const int rto = (icsk->icsk_rto << 2) - (icsk->icsk_rto >> 1);
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700285
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 tw->tw_rcv_wscale = tp->rx_opt.rcv_wscale;
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700287 tcptw->tw_rcv_nxt = tp->rcv_nxt;
288 tcptw->tw_snd_nxt = tp->snd_nxt;
289 tcptw->tw_rcv_wnd = tcp_receive_window(tp);
290 tcptw->tw_ts_recent = tp->rx_opt.ts_recent;
291 tcptw->tw_ts_recent_stamp = tp->rx_opt.ts_recent_stamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
293#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
294 if (tw->tw_family == PF_INET6) {
295 struct ipv6_pinfo *np = inet6_sk(sk);
Arnaldo Carvalho de Melo0fa1a532005-12-13 23:23:09 -0800296 struct inet6_timewait_sock *tw6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
Arnaldo Carvalho de Melo0fa1a532005-12-13 23:23:09 -0800298 tw->tw_ipv6_offset = inet6_tw_offset(sk->sk_prot);
299 tw6 = inet6_twsk((struct sock *)tw);
300 ipv6_addr_copy(&tw6->tw_v6_daddr, &np->daddr);
301 ipv6_addr_copy(&tw6->tw_v6_rcv_saddr, &np->rcv_saddr);
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700302 tw->tw_ipv6only = np->ipv6only;
Arnaldo Carvalho de Meloc6762702005-08-09 20:09:59 -0700303 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800305
306#ifdef CONFIG_TCP_MD5SIG
307 /*
308 * The timewait bucket does not have the key DB from the
309 * sock structure. We just make a quick copy of the
310 * md5 key being used (if indeed we are using one)
311 * so the timewait ack generating code has the key.
312 */
313 do {
314 struct tcp_md5sig_key *key;
315 memset(tcptw->tw_md5_key, 0, sizeof(tcptw->tw_md5_key));
316 tcptw->tw_md5_keylen = 0;
317 key = tp->af_specific->md5_lookup(sk, sk);
318 if (key != NULL) {
319 memcpy(&tcptw->tw_md5_key, key->key, key->keylen);
320 tcptw->tw_md5_keylen = key->keylen;
Wu Fengguangaa133072009-09-02 23:45:45 -0700321 if (tcp_alloc_md5sig_pool(sk) == NULL)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800322 BUG();
323 }
Stephen Hemminger2de979b2007-03-08 20:45:19 -0800324 } while (0);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800325#endif
326
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 /* Linkage updates. */
Arnaldo Carvalho de Meloe48c4142005-08-09 20:09:46 -0700328 __inet_twsk_hashdance(tw, sk, &tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
330 /* Get the TIME_WAIT timeout firing. */
331 if (timeo < rto)
332 timeo = rto;
333
334 if (recycle_ok) {
335 tw->tw_timeout = rto;
336 } else {
337 tw->tw_timeout = TCP_TIMEWAIT_LEN;
338 if (state == TCP_TIME_WAIT)
339 timeo = TCP_TIMEWAIT_LEN;
340 }
341
Arnaldo Carvalho de Melo696ab2d2005-08-09 20:45:03 -0700342 inet_twsk_schedule(tw, &tcp_death_row, timeo,
343 TCP_TIMEWAIT_LEN);
Arnaldo Carvalho de Melo8feaf0c2005-08-09 20:09:30 -0700344 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 } else {
346 /* Sorry, if we're out of memory, just CLOSE this
347 * socket up. We've got bigger problems than
348 * non-graceful socket closings.
349 */
Arnaldo Carvalho de Meloc6786242006-11-17 11:25:49 -0200350 LIMIT_NETDEBUG(KERN_INFO "TCP: time wait bucket table overflow\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 }
352
353 tcp_update_metrics(sk);
354 tcp_done(sk);
355}
356
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800357void tcp_twsk_destructor(struct sock *sk)
358{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800359#ifdef CONFIG_TCP_MD5SIG
David S. Millera9286302006-11-14 19:53:22 -0800360 struct tcp_timewait_sock *twsk = tcp_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800361 if (twsk->tw_md5_keylen)
Robert Varga657e9642009-09-15 23:49:21 -0700362 tcp_free_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800363#endif
364}
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800365EXPORT_SYMBOL_GPL(tcp_twsk_destructor);
366
Ilpo Järvinenbdf1ee52007-05-27 02:04:16 -0700367static inline void TCP_ECN_openreq_child(struct tcp_sock *tp,
368 struct request_sock *req)
369{
370 tp->ecn_flags = inet_rsk(req)->ecn_ok ? TCP_ECN_OK : 0;
371}
372
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373/* This is not only more efficient than what we used to do, it eliminates
374 * a lot of code duplication between IPv4/IPv6 SYN recv processing. -DaveM
375 *
376 * Actually, we could lots of memory writes here. tp of listening
377 * socket contains all necessary default parameters.
378 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700379struct sock *tcp_create_openreq_child(struct sock *sk, struct request_sock *req, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380{
Arnaldo Carvalho de Melo9f1d2602005-08-09 20:11:24 -0700381 struct sock *newsk = inet_csk_clone(sk, req, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -0700383 if (newsk != NULL) {
Arnaldo Carvalho de Melo9f1d2602005-08-09 20:11:24 -0700384 const struct inet_request_sock *ireq = inet_rsk(req);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700385 struct tcp_request_sock *treq = tcp_rsk(req);
Arnaldo Carvalho de Meloa9948a72007-02-28 11:05:56 -0800386 struct inet_connection_sock *newicsk = inet_csk(newsk);
William Allen Simpson435cf552009-12-02 18:17:05 +0000387 struct tcp_sock *newtp = tcp_sk(newsk);
388 struct tcp_sock *oldtp = tcp_sk(sk);
389 struct tcp_cookie_values *oldcvp = oldtp->cookie_values;
390
391 /* TCP Cookie Transactions require space for the cookie pair,
392 * as it differs for each connection. There is no need to
393 * copy any s_data_payload stored at the original socket.
394 * Failure will prevent resuming the connection.
395 *
396 * Presumed copied, in order of appearance:
397 * cookie_in_always, cookie_out_never
398 */
399 if (oldcvp != NULL) {
400 struct tcp_cookie_values *newcvp =
401 kzalloc(sizeof(*newtp->cookie_values),
402 GFP_ATOMIC);
403
404 if (newcvp != NULL) {
405 kref_init(&newcvp->kref);
406 newcvp->cookie_desired =
407 oldcvp->cookie_desired;
408 newtp->cookie_values = newcvp;
409 } else {
410 /* Not Yet Implemented */
411 newtp->cookie_values = NULL;
412 }
413 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 /* Now setup tcp_sock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 newtp->pred_flags = 0;
William Allen Simpson435cf552009-12-02 18:17:05 +0000417
418 newtp->rcv_wup = newtp->copied_seq =
419 newtp->rcv_nxt = treq->rcv_isn + 1;
420
421 newtp->snd_sml = newtp->snd_una =
422 newtp->snd_nxt = newtp->snd_up =
423 treq->snt_isn + 1 + tcp_s_data_size(oldtp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424
425 tcp_prequeue_init(newtp);
426
Hantzis Fotisee7537b2009-03-02 22:42:02 -0800427 tcp_init_wl(newtp, treq->rcv_isn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 newtp->srtt = 0;
430 newtp->mdev = TCP_TIMEOUT_INIT;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700431 newicsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
433 newtp->packets_out = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 newtp->retrans_out = 0;
435 newtp->sacked_out = 0;
436 newtp->fackets_out = 0;
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -0700437 newtp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438
439 /* So many TCP implementations out there (incorrectly) count the
440 * initial SYN frame in their delayed-ACK and congestion control
441 * algorithms that we must have the following bandaid to talk
442 * efficiently to them. -DaveM
443 */
444 newtp->snd_cwnd = 2;
445 newtp->snd_cwnd_cnt = 0;
Stephen Hemminger9772efb2005-11-10 17:09:53 -0800446 newtp->bytes_acked = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447
448 newtp->frto_counter = 0;
449 newtp->frto_highmark = 0;
450
Stephen Hemminger7957aed2005-09-21 00:19:46 -0700451 newicsk->icsk_ca_ops = &tcp_init_congestion_ops;
Stephen Hemminger317a76f2005-06-23 12:19:55 -0700452
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -0300453 tcp_set_ca_state(newsk, TCP_CA_Open);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 tcp_init_xmit_timers(newsk);
455 skb_queue_head_init(&newtp->out_of_order_queue);
William Allen Simpson435cf552009-12-02 18:17:05 +0000456 newtp->write_seq = newtp->pushed_seq =
457 treq->snt_isn + 1 + tcp_s_data_size(oldtp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458
459 newtp->rx_opt.saw_tstamp = 0;
460
461 newtp->rx_opt.dsack = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 newtp->rx_opt.num_sacks = 0;
Ilpo Järvinencabeccb2009-02-28 04:44:38 +0000463
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 newtp->urg_data = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 if (sock_flag(newsk, SOCK_KEEPOPEN))
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700467 inet_csk_reset_keepalive_timer(newsk,
468 keepalive_time_when(newtp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700470 newtp->rx_opt.tstamp_ok = ireq->tstamp_ok;
Stephen Hemminger2de979b2007-03-08 20:45:19 -0800471 if ((newtp->rx_opt.sack_ok = ireq->sack_ok) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 if (sysctl_tcp_fack)
Ilpo Järvinene60402d2007-08-09 15:14:46 +0300473 tcp_enable_fack(newtp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 }
475 newtp->window_clamp = req->window_clamp;
476 newtp->rcv_ssthresh = req->rcv_wnd;
477 newtp->rcv_wnd = req->rcv_wnd;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700478 newtp->rx_opt.wscale_ok = ireq->wscale_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 if (newtp->rx_opt.wscale_ok) {
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700480 newtp->rx_opt.snd_wscale = ireq->snd_wscale;
481 newtp->rx_opt.rcv_wscale = ireq->rcv_wscale;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 } else {
483 newtp->rx_opt.snd_wscale = newtp->rx_opt.rcv_wscale = 0;
484 newtp->window_clamp = min(newtp->window_clamp, 65535U);
485 }
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700486 newtp->snd_wnd = (ntohs(tcp_hdr(skb)->window) <<
487 newtp->rx_opt.snd_wscale);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 newtp->max_window = newtp->snd_wnd;
489
490 if (newtp->rx_opt.tstamp_ok) {
491 newtp->rx_opt.ts_recent = req->ts_recent;
James Morris9d729f72007-03-04 16:12:44 -0800492 newtp->rx_opt.ts_recent_stamp = get_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 newtp->tcp_header_len = sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED;
494 } else {
495 newtp->rx_opt.ts_recent_stamp = 0;
496 newtp->tcp_header_len = sizeof(struct tcphdr);
497 }
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800498#ifdef CONFIG_TCP_MD5SIG
499 newtp->md5sig_info = NULL; /*XXX*/
500 if (newtp->af_specific->md5_lookup(sk, newsk))
501 newtp->tcp_header_len += TCPOLEN_MD5SIG_ALIGNED;
502#endif
William Allen Simpsonbee7ca92009-11-10 09:51:18 +0000503 if (skb->len >= TCP_MSS_DEFAULT + newtp->tcp_header_len)
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700504 newicsk->icsk_ack.last_seg_size = skb->len - newtp->tcp_header_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 newtp->rx_opt.mss_clamp = req->mss;
506 TCP_ECN_openreq_child(newtp, req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700508 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_PASSIVEOPENS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 }
510 return newsk;
511}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000512EXPORT_SYMBOL(tcp_create_openreq_child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900514/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 * Process an incoming packet for SYN_RECV sockets represented
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700516 * as a request_sock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 */
518
Jianjun Kong5a5f3a82008-11-03 00:24:34 -0800519struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700520 struct request_sock *req,
521 struct request_sock **prev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522{
William Allen Simpson4957faa2009-12-02 18:25:27 +0000523 struct tcp_options_received tmp_opt;
524 u8 *hash_location;
525 struct sock *child;
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700526 const struct tcphdr *th = tcp_hdr(skb);
Al Viro714e85b2006-11-14 20:51:49 -0800527 __be32 flg = tcp_flag_word(th) & (TCP_FLAG_RST|TCP_FLAG_SYN|TCP_FLAG_ACK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 int paws_reject = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529
David S. Millerbb5b7c12009-12-15 20:56:42 -0800530 tmp_opt.saw_tstamp = 0;
531 if (th->doff > (sizeof(struct tcphdr)>>2)) {
532 tcp_parse_options(skb, &tmp_opt, &hash_location, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533
534 if (tmp_opt.saw_tstamp) {
535 tmp_opt.ts_recent = req->ts_recent;
536 /* We do not store true stamp, but it is not required,
537 * it can be estimated (approximately)
538 * from another data.
539 */
James Morris9d729f72007-03-04 16:12:44 -0800540 tmp_opt.ts_recent_stamp = get_seconds() - ((TCP_TIMEOUT_INIT/HZ)<<req->retrans);
Ilpo Järvinenc887e6d2009-03-14 14:23:03 +0000541 paws_reject = tcp_paws_reject(&tmp_opt, th->rst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 }
543 }
544
545 /* Check for pure retransmitted SYN. */
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700546 if (TCP_SKB_CB(skb)->seq == tcp_rsk(req)->rcv_isn &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 flg == TCP_FLAG_SYN &&
548 !paws_reject) {
549 /*
550 * RFC793 draws (Incorrectly! It was fixed in RFC1122)
551 * this case on figure 6 and figure 8, but formal
552 * protocol description says NOTHING.
553 * To be more exact, it says that we should send ACK,
554 * because this segment (at least, if it has no data)
555 * is out of window.
556 *
557 * CONCLUSION: RFC793 (even with RFC1122) DOES NOT
558 * describe SYN-RECV state. All the description
559 * is wrong, we cannot believe to it and should
560 * rely only on common sense and implementation
561 * experience.
562 *
563 * Enforce "SYN-ACK" according to figure 8, figure 6
564 * of RFC793, fixed by RFC1122.
565 */
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000566 req->rsk_ops->rtx_syn_ack(sk, req, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 return NULL;
568 }
569
570 /* Further reproduces section "SEGMENT ARRIVES"
571 for state SYN-RECEIVED of RFC793.
572 It is broken, however, it does not work only
573 when SYNs are crossed.
574
575 You would think that SYN crossing is impossible here, since
576 we should have a SYN_SENT socket (from connect()) on our end,
577 but this is not true if the crossed SYNs were sent to both
578 ends by a malicious third party. We must defend against this,
579 and to do that we first verify the ACK (as per RFC793, page
580 36) and reset if it is invalid. Is this a true full defense?
581 To convince ourselves, let us consider a way in which the ACK
582 test can still pass in this 'malicious crossed SYNs' case.
583 Malicious sender sends identical SYNs (and thus identical sequence
584 numbers) to both A and B:
585
586 A: gets SYN, seq=7
587 B: gets SYN, seq=7
588
589 By our good fortune, both A and B select the same initial
590 send sequence number of seven :-)
591
592 A: sends SYN|ACK, seq=7, ack_seq=8
593 B: sends SYN|ACK, seq=7, ack_seq=8
594
595 So we are now A eating this SYN|ACK, ACK test passes. So
596 does sequence test, SYN is truncated, and thus we consider
597 it a bare ACK.
598
David S. Millerec0a1962008-06-12 16:31:35 -0700599 If icsk->icsk_accept_queue.rskq_defer_accept, we silently drop this
600 bare ACK. Otherwise, we create an established connection. Both
601 ends (listening sockets) accept the new incoming connection and try
602 to talk to each other. 8-)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603
604 Note: This case is both harmless, and rare. Possibility is about the
605 same as us discovering intelligent life on another plant tomorrow.
606
607 But generally, we should (RFC lies!) to accept ACK
608 from SYNACK both here and in tcp_rcv_state_process().
609 tcp_rcv_state_process() does not, hence, we do not too.
610
611 Note that the case is absolutely generic:
612 we cannot optimize anything here without
613 violating protocol. All the checks must be made
614 before attempt to create socket.
615 */
616
617 /* RFC793 page 36: "If the connection is in any non-synchronized state ...
618 * and the incoming segment acknowledges something not yet
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -0800619 * sent (the segment carries an unacceptable ACK) ...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 * a reset is sent."
621 *
622 * Invalid ACK: reset will be sent by listening socket
623 */
624 if ((flg & TCP_FLAG_ACK) &&
William Allen Simpson435cf552009-12-02 18:17:05 +0000625 (TCP_SKB_CB(skb)->ack_seq !=
626 tcp_rsk(req)->snt_isn + 1 + tcp_s_data_size(tcp_sk(sk))))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 return sk;
628
629 /* Also, it would be not so bad idea to check rcv_tsecr, which
630 * is essentially ACK extension and too early or too late values
631 * should cause reset in unsynchronized states.
632 */
633
634 /* RFC793: "first check sequence number". */
635
636 if (paws_reject || !tcp_in_window(TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700637 tcp_rsk(req)->rcv_isn + 1, tcp_rsk(req)->rcv_isn + 1 + req->rcv_wnd)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 /* Out of window: send ACK and drop. */
639 if (!(flg & TCP_FLAG_RST))
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700640 req->rsk_ops->send_ack(sk, skb, req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 if (paws_reject)
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700642 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSESTABREJECTED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 return NULL;
644 }
645
646 /* In sequence, PAWS is OK. */
647
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700648 if (tmp_opt.saw_tstamp && !after(TCP_SKB_CB(skb)->seq, tcp_rsk(req)->rcv_isn + 1))
Adam Langley2aaab9a2008-08-07 20:27:45 -0700649 req->ts_recent = tmp_opt.rcv_tsval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
Adam Langley2aaab9a2008-08-07 20:27:45 -0700651 if (TCP_SKB_CB(skb)->seq == tcp_rsk(req)->rcv_isn) {
652 /* Truncate SYN, it is out of window starting
653 at tcp_rsk(req)->rcv_isn + 1. */
654 flg &= ~TCP_FLAG_SYN;
655 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
Adam Langley2aaab9a2008-08-07 20:27:45 -0700657 /* RFC793: "second check the RST bit" and
658 * "fourth, check the SYN bit"
659 */
660 if (flg & (TCP_FLAG_RST|TCP_FLAG_SYN)) {
661 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_ATTEMPTFAILS);
662 goto embryonic_reset;
663 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
Adam Langley2aaab9a2008-08-07 20:27:45 -0700665 /* ACK sequence verified above, just make sure ACK is
666 * set. If ACK not set, just silently drop the packet.
667 */
668 if (!(flg & TCP_FLAG_ACK))
669 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670
Julian Anastasovd1b99ba2009-10-19 10:01:56 +0000671 /* While TCP_DEFER_ACCEPT is active, drop bare ACK. */
672 if (req->retrans < inet_csk(sk)->icsk_accept_queue.rskq_defer_accept &&
Adam Langley2aaab9a2008-08-07 20:27:45 -0700673 TCP_SKB_CB(skb)->end_seq == tcp_rsk(req)->rcv_isn + 1) {
674 inet_rsk(req)->acked = 1;
Eric Dumazet907cdda2010-03-19 05:37:18 +0000675 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPDEFERACCEPTDROP);
Adam Langley2aaab9a2008-08-07 20:27:45 -0700676 return NULL;
677 }
David S. Millerec0a1962008-06-12 16:31:35 -0700678
Adam Langley2aaab9a2008-08-07 20:27:45 -0700679 /* OK, ACK is valid, create big socket and
680 * feed this segment to it. It will repeat all
681 * the tests. THIS SEGMENT MUST MOVE SOCKET TO
682 * ESTABLISHED STATE. If it will be dropped after
683 * socket is created, wait for troubles.
684 */
685 child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL);
686 if (child == NULL)
687 goto listen_overflow;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
Adam Langley2aaab9a2008-08-07 20:27:45 -0700689 inet_csk_reqsk_queue_unlink(sk, req, prev);
690 inet_csk_reqsk_queue_removed(sk, req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
Adam Langley2aaab9a2008-08-07 20:27:45 -0700692 inet_csk_reqsk_queue_add(sk, req, child);
693 return child;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694
Adam Langley2aaab9a2008-08-07 20:27:45 -0700695listen_overflow:
696 if (!sysctl_tcp_abort_on_overflow) {
697 inet_rsk(req)->acked = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 return NULL;
Adam Langley2aaab9a2008-08-07 20:27:45 -0700699 }
700
701embryonic_reset:
702 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_EMBRYONICRSTS);
703 if (!(flg & TCP_FLAG_RST))
704 req->rsk_ops->send_reset(sk, skb);
705
706 inet_csk_reqsk_queue_drop(sk, req, prev);
707 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708}
Eric Dumazet4bc2f182010-07-09 21:22:10 +0000709EXPORT_SYMBOL(tcp_check_req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710
711/*
712 * Queue segment on the new socket if the new socket is active,
713 * otherwise we just shortcircuit this and continue with
714 * the new socket.
715 */
716
717int tcp_child_process(struct sock *parent, struct sock *child,
718 struct sk_buff *skb)
719{
720 int ret = 0;
721 int state = child->sk_state;
722
723 if (!sock_owned_by_user(child)) {
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700724 ret = tcp_rcv_state_process(child, skb, tcp_hdr(skb),
725 skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 /* Wakeup parent, send SIGIO */
727 if (state == TCP_SYN_RECV && child->sk_state != state)
728 parent->sk_data_ready(parent, 0);
729 } else {
730 /* Alas, it is possible again, because we do lookup
731 * in main socket hash table and lock on listening
732 * socket does not protect us more.
733 */
Zhu Yia3a858f2010-03-04 18:01:47 +0000734 __sk_add_backlog(child, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 }
736
737 bh_unlock_sock(child);
738 sock_put(child);
739 return ret;
740}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741EXPORT_SYMBOL(tcp_child_process);