blob: 5fabff9ac6d6b42596fcc96727598e087b455ceb [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};
50
51EXPORT_SYMBOL_GPL(tcp_death_row);
52
Linus Torvalds1da177e2005-04-16 15:20:36 -070053static __inline__ int tcp_in_window(u32 seq, u32 end_seq, u32 s_win, u32 e_win)
54{
55 if (seq == s_win)
56 return 1;
57 if (after(end_seq, s_win) && before(seq, e_win))
58 return 1;
59 return (seq == e_win && seq == end_seq);
60}
61
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090062/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 * * Main purpose of TIME-WAIT state is to close connection gracefully,
64 * when one of ends sits in LAST-ACK or CLOSING retransmitting FIN
65 * (and, probably, tail of data) and one or more our ACKs are lost.
66 * * What is TIME-WAIT timeout? It is associated with maximal packet
67 * lifetime in the internet, which results in wrong conclusion, that
68 * it is set to catch "old duplicate segments" wandering out of their path.
69 * It is not quite correct. This timeout is calculated so that it exceeds
70 * maximal retransmission timeout enough to allow to lose one (or more)
71 * segments sent by peer and our ACKs. This time may be calculated from RTO.
72 * * When TIME-WAIT socket receives RST, it means that another end
73 * finally closed and we are allowed to kill TIME-WAIT too.
74 * * Second purpose of TIME-WAIT is catching old duplicate segments.
75 * Well, certainly it is pure paranoia, but if we load TIME-WAIT
76 * with this semantics, we MUST NOT kill TIME-WAIT state with RSTs.
77 * * If we invented some more clever way to catch duplicates
78 * (f.e. based on PAWS), we could truncate TIME-WAIT to several RTOs.
79 *
80 * The algorithm below is based on FORMAL INTERPRETATION of RFCs.
81 * When you compare it to RFCs, please, read section SEGMENT ARRIVES
82 * from the very beginning.
83 *
84 * NOTE. With recycling (and later with fin-wait-2) TW bucket
85 * is _not_ stateless. It means, that strictly speaking we must
86 * spinlock it. I do not want! Well, probability of misbehaviour
87 * is ridiculously low and, seems, we could use some mb() tricks
88 * to avoid misread sequence numbers, states etc. --ANK
89 */
90enum tcp_tw_status
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -070091tcp_timewait_state_process(struct inet_timewait_sock *tw, struct sk_buff *skb,
92 const struct tcphdr *th)
Linus Torvalds1da177e2005-04-16 15:20:36 -070093{
94 struct tcp_options_received tmp_opt;
William Allen Simpson4957faade2009-12-02 18:25:27 +000095 u8 *hash_location;
96 struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 int paws_reject = 0;
98
David S. Millerbb5b7c12009-12-15 20:56:42 -080099 tmp_opt.saw_tstamp = 0;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700100 if (th->doff > (sizeof(*th) >> 2) && tcptw->tw_ts_recent_stamp) {
David S. Millerbb5b7c12009-12-15 20:56:42 -0800101 tcp_parse_options(skb, &tmp_opt, &hash_location, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
103 if (tmp_opt.saw_tstamp) {
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700104 tmp_opt.ts_recent = tcptw->tw_ts_recent;
105 tmp_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
Ilpo Järvinenc887e6d2009-03-14 14:23:03 +0000106 paws_reject = tcp_paws_reject(&tmp_opt, th->rst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 }
108 }
109
110 if (tw->tw_substate == TCP_FIN_WAIT2) {
111 /* Just repeat all the checks of tcp_rcv_state_process() */
112
113 /* Out of window, send ACK */
114 if (paws_reject ||
115 !tcp_in_window(TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq,
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700116 tcptw->tw_rcv_nxt,
117 tcptw->tw_rcv_nxt + tcptw->tw_rcv_wnd))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 return TCP_TW_ACK;
119
120 if (th->rst)
121 goto kill;
122
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700123 if (th->syn && !before(TCP_SKB_CB(skb)->seq, tcptw->tw_rcv_nxt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 goto kill_with_rst;
125
126 /* Dup ACK? */
Wei Yongjun1ac530b2009-06-24 22:29:31 +0000127 if (!th->ack ||
128 !after(TCP_SKB_CB(skb)->end_seq, tcptw->tw_rcv_nxt) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 TCP_SKB_CB(skb)->end_seq == TCP_SKB_CB(skb)->seq) {
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700130 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 return TCP_TW_SUCCESS;
132 }
133
134 /* New data or FIN. If new data arrive after half-duplex close,
135 * reset.
136 */
137 if (!th->fin ||
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700138 TCP_SKB_CB(skb)->end_seq != tcptw->tw_rcv_nxt + 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139kill_with_rst:
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700140 inet_twsk_deschedule(tw, &tcp_death_row);
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700141 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 return TCP_TW_RST;
143 }
144
145 /* FIN arrived, enter true time-wait state. */
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700146 tw->tw_substate = TCP_TIME_WAIT;
147 tcptw->tw_rcv_nxt = TCP_SKB_CB(skb)->end_seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 if (tmp_opt.saw_tstamp) {
James Morris9d729f72007-03-04 16:12:44 -0800149 tcptw->tw_ts_recent_stamp = get_seconds();
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700150 tcptw->tw_ts_recent = tmp_opt.rcv_tsval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 }
152
153 /* I am shamed, but failed to make it more elegant.
154 * Yes, it is direct reference to IP, which is impossible
155 * to generalize to IPv6. Taking into account that IPv6
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -0800156 * do not understand recycling in any case, it not
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 * a big problem in practice. --ANK */
158 if (tw->tw_family == AF_INET &&
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700159 tcp_death_row.sysctl_tw_recycle && tcptw->tw_ts_recent_stamp &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 tcp_v4_tw_remember_stamp(tw))
Arnaldo Carvalho de Melo696ab2d2005-08-09 20:45:03 -0700161 inet_twsk_schedule(tw, &tcp_death_row, tw->tw_timeout,
162 TCP_TIMEWAIT_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 else
Arnaldo Carvalho de Melo696ab2d2005-08-09 20:45:03 -0700164 inet_twsk_schedule(tw, &tcp_death_row, TCP_TIMEWAIT_LEN,
165 TCP_TIMEWAIT_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 return TCP_TW_ACK;
167 }
168
169 /*
170 * Now real TIME-WAIT state.
171 *
172 * RFC 1122:
173 * "When a connection is [...] on TIME-WAIT state [...]
174 * [a TCP] MAY accept a new SYN from the remote TCP to
175 * reopen the connection directly, if it:
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900176 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 * (1) assigns its initial sequence number for the new
178 * connection to be larger than the largest sequence
179 * number it used on the previous connection incarnation,
180 * and
181 *
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900182 * (2) returns to TIME-WAIT state if the SYN turns out
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 * to be an old duplicate".
184 */
185
186 if (!paws_reject &&
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700187 (TCP_SKB_CB(skb)->seq == tcptw->tw_rcv_nxt &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq || th->rst))) {
189 /* In window segment, it may be only reset or bare ack. */
190
191 if (th->rst) {
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -0800192 /* This is TIME_WAIT assassination, in two flavors.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 * Oh well... nobody has a sufficient solution to this
194 * protocol bug yet.
195 */
196 if (sysctl_tcp_rfc1337 == 0) {
197kill:
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700198 inet_twsk_deschedule(tw, &tcp_death_row);
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700199 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 return TCP_TW_SUCCESS;
201 }
202 }
Arnaldo Carvalho de Melo696ab2d2005-08-09 20:45:03 -0700203 inet_twsk_schedule(tw, &tcp_death_row, TCP_TIMEWAIT_LEN,
204 TCP_TIMEWAIT_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
206 if (tmp_opt.saw_tstamp) {
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700207 tcptw->tw_ts_recent = tmp_opt.rcv_tsval;
James Morris9d729f72007-03-04 16:12:44 -0800208 tcptw->tw_ts_recent_stamp = get_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 }
210
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700211 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 return TCP_TW_SUCCESS;
213 }
214
215 /* Out of window segment.
216
217 All the segments are ACKed immediately.
218
219 The only exception is new SYN. We accept it, if it is
220 not old duplicate and we are not in danger to be killed
221 by delayed old duplicates. RFC check is that it has
222 newer sequence number works at rates <40Mbit/sec.
223 However, if paws works, it is reliable AND even more,
224 we even may relax silly seq space cutoff.
225
226 RED-PEN: we violate main RFC requirement, if this SYN will appear
227 old duplicate (i.e. we receive RST in reply to SYN-ACK),
228 we must return socket to time-wait state. It is not good,
229 but not fatal yet.
230 */
231
232 if (th->syn && !th->rst && !th->ack && !paws_reject &&
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700233 (after(TCP_SKB_CB(skb)->seq, tcptw->tw_rcv_nxt) ||
234 (tmp_opt.saw_tstamp &&
235 (s32)(tcptw->tw_ts_recent - tmp_opt.rcv_tsval) < 0))) {
236 u32 isn = tcptw->tw_snd_nxt + 65535 + 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 if (isn == 0)
238 isn++;
239 TCP_SKB_CB(skb)->when = isn;
240 return TCP_TW_SYN;
241 }
242
243 if (paws_reject)
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700244 NET_INC_STATS_BH(twsk_net(tw), LINUX_MIB_PAWSESTABREJECTED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245
Stephen Hemminger2de979b2007-03-08 20:45:19 -0800246 if (!th->rst) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 /* In this case we must reset the TIMEWAIT timer.
248 *
249 * If it is ACKless SYN it may be both old duplicate
250 * and new good SYN with random sequence number <rcv_nxt.
251 * Do not reschedule in the last case.
252 */
253 if (paws_reject || th->ack)
Arnaldo Carvalho de Melo696ab2d2005-08-09 20:45:03 -0700254 inet_twsk_schedule(tw, &tcp_death_row, TCP_TIMEWAIT_LEN,
255 TCP_TIMEWAIT_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
257 /* Send ACK. Note, we do not put the bucket,
258 * it will be released by caller.
259 */
260 return TCP_TW_ACK;
261 }
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700262 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 return TCP_TW_SUCCESS;
264}
265
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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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}
365
366EXPORT_SYMBOL_GPL(tcp_twsk_destructor);
367
Ilpo Järvinenbdf1ee52007-05-27 02:04:16 -0700368static inline void TCP_ECN_openreq_child(struct tcp_sock *tp,
369 struct request_sock *req)
370{
371 tp->ecn_flags = inet_rsk(req)->ecn_ok ? TCP_ECN_OK : 0;
372}
373
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374/* This is not only more efficient than what we used to do, it eliminates
375 * a lot of code duplication between IPv4/IPv6 SYN recv processing. -DaveM
376 *
377 * Actually, we could lots of memory writes here. tp of listening
378 * socket contains all necessary default parameters.
379 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700380struct sock *tcp_create_openreq_child(struct sock *sk, struct request_sock *req, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381{
Arnaldo Carvalho de Melo9f1d2602005-08-09 20:11:24 -0700382 struct sock *newsk = inet_csk_clone(sk, req, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -0700384 if (newsk != NULL) {
Arnaldo Carvalho de Melo9f1d2602005-08-09 20:11:24 -0700385 const struct inet_request_sock *ireq = inet_rsk(req);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700386 struct tcp_request_sock *treq = tcp_rsk(req);
Arnaldo Carvalho de Meloa9948a72007-02-28 11:05:56 -0800387 struct inet_connection_sock *newicsk = inet_csk(newsk);
William Allen Simpson435cf552009-12-02 18:17:05 +0000388 struct tcp_sock *newtp = tcp_sk(newsk);
389 struct tcp_sock *oldtp = tcp_sk(sk);
390 struct tcp_cookie_values *oldcvp = oldtp->cookie_values;
391
392 /* TCP Cookie Transactions require space for the cookie pair,
393 * as it differs for each connection. There is no need to
394 * copy any s_data_payload stored at the original socket.
395 * Failure will prevent resuming the connection.
396 *
397 * Presumed copied, in order of appearance:
398 * cookie_in_always, cookie_out_never
399 */
400 if (oldcvp != NULL) {
401 struct tcp_cookie_values *newcvp =
402 kzalloc(sizeof(*newtp->cookie_values),
403 GFP_ATOMIC);
404
405 if (newcvp != NULL) {
406 kref_init(&newcvp->kref);
407 newcvp->cookie_desired =
408 oldcvp->cookie_desired;
409 newtp->cookie_values = newcvp;
410 } else {
411 /* Not Yet Implemented */
412 newtp->cookie_values = NULL;
413 }
414 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 /* Now setup tcp_sock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 newtp->pred_flags = 0;
William Allen Simpson435cf552009-12-02 18:17:05 +0000418
419 newtp->rcv_wup = newtp->copied_seq =
420 newtp->rcv_nxt = treq->rcv_isn + 1;
421
422 newtp->snd_sml = newtp->snd_una =
423 newtp->snd_nxt = newtp->snd_up =
424 treq->snt_isn + 1 + tcp_s_data_size(oldtp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
426 tcp_prequeue_init(newtp);
427
Hantzis Fotisee7537b2009-03-02 22:42:02 -0800428 tcp_init_wl(newtp, treq->rcv_isn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 newtp->srtt = 0;
431 newtp->mdev = TCP_TIMEOUT_INIT;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700432 newicsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
434 newtp->packets_out = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 newtp->retrans_out = 0;
436 newtp->sacked_out = 0;
437 newtp->fackets_out = 0;
Ilpo Järvinen0b6a05c2009-09-15 01:30:10 -0700438 newtp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
440 /* So many TCP implementations out there (incorrectly) count the
441 * initial SYN frame in their delayed-ACK and congestion control
442 * algorithms that we must have the following bandaid to talk
443 * efficiently to them. -DaveM
444 */
445 newtp->snd_cwnd = 2;
446 newtp->snd_cwnd_cnt = 0;
Stephen Hemminger9772efb92005-11-10 17:09:53 -0800447 newtp->bytes_acked = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448
449 newtp->frto_counter = 0;
450 newtp->frto_highmark = 0;
451
Stephen Hemminger7957aed2005-09-21 00:19:46 -0700452 newicsk->icsk_ca_ops = &tcp_init_congestion_ops;
Stephen Hemminger317a76f2005-06-23 12:19:55 -0700453
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -0300454 tcp_set_ca_state(newsk, TCP_CA_Open);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 tcp_init_xmit_timers(newsk);
456 skb_queue_head_init(&newtp->out_of_order_queue);
William Allen Simpson435cf552009-12-02 18:17:05 +0000457 newtp->write_seq = newtp->pushed_seq =
458 treq->snt_isn + 1 + tcp_s_data_size(oldtp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
460 newtp->rx_opt.saw_tstamp = 0;
461
462 newtp->rx_opt.dsack = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 newtp->rx_opt.num_sacks = 0;
Ilpo Järvinencabeccb2009-02-28 04:44:38 +0000464
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 newtp->urg_data = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 if (sock_flag(newsk, SOCK_KEEPOPEN))
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700468 inet_csk_reset_keepalive_timer(newsk,
469 keepalive_time_when(newtp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700471 newtp->rx_opt.tstamp_ok = ireq->tstamp_ok;
Stephen Hemminger2de979b2007-03-08 20:45:19 -0800472 if ((newtp->rx_opt.sack_ok = ireq->sack_ok) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 if (sysctl_tcp_fack)
Ilpo Järvinene60402d2007-08-09 15:14:46 +0300474 tcp_enable_fack(newtp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 }
476 newtp->window_clamp = req->window_clamp;
477 newtp->rcv_ssthresh = req->rcv_wnd;
478 newtp->rcv_wnd = req->rcv_wnd;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700479 newtp->rx_opt.wscale_ok = ireq->wscale_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 if (newtp->rx_opt.wscale_ok) {
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700481 newtp->rx_opt.snd_wscale = ireq->snd_wscale;
482 newtp->rx_opt.rcv_wscale = ireq->rcv_wscale;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 } else {
484 newtp->rx_opt.snd_wscale = newtp->rx_opt.rcv_wscale = 0;
485 newtp->window_clamp = min(newtp->window_clamp, 65535U);
486 }
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700487 newtp->snd_wnd = (ntohs(tcp_hdr(skb)->window) <<
488 newtp->rx_opt.snd_wscale);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 newtp->max_window = newtp->snd_wnd;
490
491 if (newtp->rx_opt.tstamp_ok) {
492 newtp->rx_opt.ts_recent = req->ts_recent;
James Morris9d729f72007-03-04 16:12:44 -0800493 newtp->rx_opt.ts_recent_stamp = get_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 newtp->tcp_header_len = sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED;
495 } else {
496 newtp->rx_opt.ts_recent_stamp = 0;
497 newtp->tcp_header_len = sizeof(struct tcphdr);
498 }
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800499#ifdef CONFIG_TCP_MD5SIG
500 newtp->md5sig_info = NULL; /*XXX*/
501 if (newtp->af_specific->md5_lookup(sk, newsk))
502 newtp->tcp_header_len += TCPOLEN_MD5SIG_ALIGNED;
503#endif
William Allen Simpsonbee7ca92009-11-10 09:51:18 +0000504 if (skb->len >= TCP_MSS_DEFAULT + newtp->tcp_header_len)
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700505 newicsk->icsk_ack.last_seg_size = skb->len - newtp->tcp_header_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 newtp->rx_opt.mss_clamp = req->mss;
507 TCP_ECN_openreq_child(newtp, req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
Pavel Emelyanov63231bd2008-07-16 20:22:25 -0700509 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_PASSIVEOPENS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 }
511 return newsk;
512}
513
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 Simpson4957faade2009-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;
675 return NULL;
676 }
David S. Millerec0a1962008-06-12 16:31:35 -0700677
Adam Langley2aaab9a2008-08-07 20:27:45 -0700678 /* OK, ACK is valid, create big socket and
679 * feed this segment to it. It will repeat all
680 * the tests. THIS SEGMENT MUST MOVE SOCKET TO
681 * ESTABLISHED STATE. If it will be dropped after
682 * socket is created, wait for troubles.
683 */
684 child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL);
685 if (child == NULL)
686 goto listen_overflow;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
Adam Langley2aaab9a2008-08-07 20:27:45 -0700688 inet_csk_reqsk_queue_unlink(sk, req, prev);
689 inet_csk_reqsk_queue_removed(sk, req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
Adam Langley2aaab9a2008-08-07 20:27:45 -0700691 inet_csk_reqsk_queue_add(sk, req, child);
692 return child;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
Adam Langley2aaab9a2008-08-07 20:27:45 -0700694listen_overflow:
695 if (!sysctl_tcp_abort_on_overflow) {
696 inet_rsk(req)->acked = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 return NULL;
Adam Langley2aaab9a2008-08-07 20:27:45 -0700698 }
699
700embryonic_reset:
701 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_EMBRYONICRSTS);
702 if (!(flg & TCP_FLAG_RST))
703 req->rsk_ops->send_reset(sk, skb);
704
705 inet_csk_reqsk_queue_drop(sk, req, prev);
706 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707}
708
709/*
710 * Queue segment on the new socket if the new socket is active,
711 * otherwise we just shortcircuit this and continue with
712 * the new socket.
713 */
714
715int tcp_child_process(struct sock *parent, struct sock *child,
716 struct sk_buff *skb)
717{
718 int ret = 0;
719 int state = child->sk_state;
720
721 if (!sock_owned_by_user(child)) {
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700722 ret = tcp_rcv_state_process(child, skb, tcp_hdr(skb),
723 skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 /* Wakeup parent, send SIGIO */
725 if (state == TCP_SYN_RECV && child->sk_state != state)
726 parent->sk_data_ready(parent, 0);
727 } else {
728 /* Alas, it is possible again, because we do lookup
729 * in main socket hash table and lock on listening
730 * socket does not protect us more.
731 */
Zhu Yia3a858f2010-03-04 18:01:47 +0000732 __sk_add_backlog(child, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 }
734
735 bh_unlock_sock(child);
736 sock_put(child);
737 return ret;
738}
739
740EXPORT_SYMBOL(tcp_check_req);
741EXPORT_SYMBOL(tcp_child_process);
742EXPORT_SYMBOL(tcp_create_openreq_child);
743EXPORT_SYMBOL(tcp_timewait_state_process);