blob: f206ee5dda80b4e8c29f6576276bb1452e09c53e [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>
23#include <linux/sysctl.h>
24#include <linux/workqueue.h>
25#include <net/tcp.h>
26#include <net/inet_common.h>
27#include <net/xfrm.h>
28
David S. Millere994b7c2009-11-21 11:22:25 -080029int sysctl_tcp_syncookies __read_mostly = 1;
Glenn Griffinc6aefaf2008-02-07 21:49:26 -080030EXPORT_SYMBOL(sysctl_tcp_syncookies);
31
Brian Haleyab32ea52006-09-22 14:15:41 -070032int sysctl_tcp_abort_on_overflow __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -070034struct inet_timewait_death_row tcp_death_row = {
35 .sysctl_max_tw_buckets = NR_FILE * 2,
36 .period = TCP_TIMEWAIT_LEN / INET_TWDR_TWKILL_SLOTS,
Ingo Molnare4d91912006-07-03 00:24:34 -070037 .death_lock = __SPIN_LOCK_UNLOCKED(tcp_death_row.death_lock),
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -070038 .hashinfo = &tcp_hashinfo,
39 .tw_timer = TIMER_INITIALIZER(inet_twdr_hangman, 0,
40 (unsigned long)&tcp_death_row),
41 .twkill_work = __WORK_INITIALIZER(tcp_death_row.twkill_work,
David Howells65f27f32006-11-22 14:55:48 +000042 inet_twdr_twkill_work),
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -070043/* Short-time timewait calendar */
44
45 .twcal_hand = -1,
46 .twcal_timer = TIMER_INITIALIZER(inet_twdr_twcal_tick, 0,
47 (unsigned long)&tcp_death_row),
48};
49
50EXPORT_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;
58 return (seq == e_win && seq == end_seq);
59}
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 Melo8feaf0c02005-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 Simpson4957faade2009-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-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 Melo8feaf0c02005-08-09 20:09:30 -0700261 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 return TCP_TW_SUCCESS;
263}
264
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900265/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 * Move a socket to time-wait or dead fin-wait-2 state.
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900267 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268void tcp_time_wait(struct sock *sk, int state, int timeo)
269{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700270 struct inet_timewait_sock *tw = NULL;
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800271 const struct inet_connection_sock *icsk = inet_csk(sk);
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700272 const struct tcp_sock *tp = tcp_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 int recycle_ok = 0;
274
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700275 if (tcp_death_row.sysctl_tw_recycle && tp->rx_opt.ts_recent_stamp)
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800276 recycle_ok = icsk->icsk_af_ops->remember_stamp(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700278 if (tcp_death_row.tw_count < tcp_death_row.sysctl_max_tw_buckets)
Arnaldo Carvalho de Meloc6762702005-08-09 20:09:59 -0700279 tw = inet_twsk_alloc(sk, state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700281 if (tw != NULL) {
282 struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700283 const int rto = (icsk->icsk_rto << 2) - (icsk->icsk_rto >> 1);
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700284
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 tw->tw_rcv_wscale = tp->rx_opt.rcv_wscale;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700286 tcptw->tw_rcv_nxt = tp->rcv_nxt;
287 tcptw->tw_snd_nxt = tp->snd_nxt;
288 tcptw->tw_rcv_wnd = tcp_receive_window(tp);
289 tcptw->tw_ts_recent = tp->rx_opt.ts_recent;
290 tcptw->tw_ts_recent_stamp = tp->rx_opt.ts_recent_stamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
292#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
293 if (tw->tw_family == PF_INET6) {
294 struct ipv6_pinfo *np = inet6_sk(sk);
Arnaldo Carvalho de Melo0fa1a532005-12-13 23:23:09 -0800295 struct inet6_timewait_sock *tw6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296
Arnaldo Carvalho de Melo0fa1a532005-12-13 23:23:09 -0800297 tw->tw_ipv6_offset = inet6_tw_offset(sk->sk_prot);
298 tw6 = inet6_twsk((struct sock *)tw);
299 ipv6_addr_copy(&tw6->tw_v6_daddr, &np->daddr);
300 ipv6_addr_copy(&tw6->tw_v6_rcv_saddr, &np->rcv_saddr);
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700301 tw->tw_ipv6only = np->ipv6only;
Arnaldo Carvalho de Meloc6762702005-08-09 20:09:59 -0700302 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303#endif
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800304
305#ifdef CONFIG_TCP_MD5SIG
306 /*
307 * The timewait bucket does not have the key DB from the
308 * sock structure. We just make a quick copy of the
309 * md5 key being used (if indeed we are using one)
310 * so the timewait ack generating code has the key.
311 */
312 do {
313 struct tcp_md5sig_key *key;
314 memset(tcptw->tw_md5_key, 0, sizeof(tcptw->tw_md5_key));
315 tcptw->tw_md5_keylen = 0;
316 key = tp->af_specific->md5_lookup(sk, sk);
317 if (key != NULL) {
318 memcpy(&tcptw->tw_md5_key, key->key, key->keylen);
319 tcptw->tw_md5_keylen = key->keylen;
Wu Fengguangaa133072009-09-02 23:45:45 -0700320 if (tcp_alloc_md5sig_pool(sk) == NULL)
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800321 BUG();
322 }
Stephen Hemminger2de979b2007-03-08 20:45:19 -0800323 } while (0);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800324#endif
325
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 /* Linkage updates. */
Arnaldo Carvalho de Meloe48c4142005-08-09 20:09:46 -0700327 __inet_twsk_hashdance(tw, sk, &tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328
329 /* Get the TIME_WAIT timeout firing. */
330 if (timeo < rto)
331 timeo = rto;
332
333 if (recycle_ok) {
334 tw->tw_timeout = rto;
335 } else {
336 tw->tw_timeout = TCP_TIMEWAIT_LEN;
337 if (state == TCP_TIME_WAIT)
338 timeo = TCP_TIMEWAIT_LEN;
339 }
340
Arnaldo Carvalho de Melo696ab2d2005-08-09 20:45:03 -0700341 inet_twsk_schedule(tw, &tcp_death_row, timeo,
342 TCP_TIMEWAIT_LEN);
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700343 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 } else {
345 /* Sorry, if we're out of memory, just CLOSE this
346 * socket up. We've got bigger problems than
347 * non-graceful socket closings.
348 */
Arnaldo Carvalho de Meloc6786242006-11-17 11:25:49 -0200349 LIMIT_NETDEBUG(KERN_INFO "TCP: time wait bucket table overflow\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 }
351
352 tcp_update_metrics(sk);
353 tcp_done(sk);
354}
355
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800356void tcp_twsk_destructor(struct sock *sk)
357{
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800358#ifdef CONFIG_TCP_MD5SIG
David S. Millera9286302006-11-14 19:53:22 -0800359 struct tcp_timewait_sock *twsk = tcp_twsk(sk);
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800360 if (twsk->tw_md5_keylen)
Robert Varga657e9642009-09-15 23:49:21 -0700361 tcp_free_md5sig_pool();
YOSHIFUJI Hideakicfb6eeb2006-11-14 19:07:45 -0800362#endif
363}
364
365EXPORT_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}
512
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900513/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 * Process an incoming packet for SYN_RECV sockets represented
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700515 * as a request_sock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 */
517
Jianjun Kong5a5f3a82008-11-03 00:24:34 -0800518struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700519 struct request_sock *req,
520 struct request_sock **prev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521{
William Allen Simpson4957faade2009-12-02 18:25:27 +0000522 struct tcp_options_received tmp_opt;
523 u8 *hash_location;
524 struct sock *child;
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700525 const struct tcphdr *th = tcp_hdr(skb);
Al Viro714e85b2006-11-14 20:51:49 -0800526 __be32 flg = tcp_flag_word(th) & (TCP_FLAG_RST|TCP_FLAG_SYN|TCP_FLAG_ACK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 int paws_reject = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
David S. Millerbb5b7c12009-12-15 20:56:42 -0800529 tmp_opt.saw_tstamp = 0;
530 if (th->doff > (sizeof(struct tcphdr)>>2)) {
531 tcp_parse_options(skb, &tmp_opt, &hash_location, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
533 if (tmp_opt.saw_tstamp) {
534 tmp_opt.ts_recent = req->ts_recent;
535 /* We do not store true stamp, but it is not required,
536 * it can be estimated (approximately)
537 * from another data.
538 */
James Morris9d729f72007-03-04 16:12:44 -0800539 tmp_opt.ts_recent_stamp = get_seconds() - ((TCP_TIMEOUT_INIT/HZ)<<req->retrans);
Ilpo Järvinenc887e6d2009-03-14 14:23:03 +0000540 paws_reject = tcp_paws_reject(&tmp_opt, th->rst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 }
542 }
543
544 /* Check for pure retransmitted SYN. */
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700545 if (TCP_SKB_CB(skb)->seq == tcp_rsk(req)->rcv_isn &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 flg == TCP_FLAG_SYN &&
547 !paws_reject) {
548 /*
549 * RFC793 draws (Incorrectly! It was fixed in RFC1122)
550 * this case on figure 6 and figure 8, but formal
551 * protocol description says NOTHING.
552 * To be more exact, it says that we should send ACK,
553 * because this segment (at least, if it has no data)
554 * is out of window.
555 *
556 * CONCLUSION: RFC793 (even with RFC1122) DOES NOT
557 * describe SYN-RECV state. All the description
558 * is wrong, we cannot believe to it and should
559 * rely only on common sense and implementation
560 * experience.
561 *
562 * Enforce "SYN-ACK" according to figure 8, figure 6
563 * of RFC793, fixed by RFC1122.
564 */
William Allen Simpsone6b4d112009-12-02 18:07:39 +0000565 req->rsk_ops->rtx_syn_ack(sk, req, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 return NULL;
567 }
568
569 /* Further reproduces section "SEGMENT ARRIVES"
570 for state SYN-RECEIVED of RFC793.
571 It is broken, however, it does not work only
572 when SYNs are crossed.
573
574 You would think that SYN crossing is impossible here, since
575 we should have a SYN_SENT socket (from connect()) on our end,
576 but this is not true if the crossed SYNs were sent to both
577 ends by a malicious third party. We must defend against this,
578 and to do that we first verify the ACK (as per RFC793, page
579 36) and reset if it is invalid. Is this a true full defense?
580 To convince ourselves, let us consider a way in which the ACK
581 test can still pass in this 'malicious crossed SYNs' case.
582 Malicious sender sends identical SYNs (and thus identical sequence
583 numbers) to both A and B:
584
585 A: gets SYN, seq=7
586 B: gets SYN, seq=7
587
588 By our good fortune, both A and B select the same initial
589 send sequence number of seven :-)
590
591 A: sends SYN|ACK, seq=7, ack_seq=8
592 B: sends SYN|ACK, seq=7, ack_seq=8
593
594 So we are now A eating this SYN|ACK, ACK test passes. So
595 does sequence test, SYN is truncated, and thus we consider
596 it a bare ACK.
597
David S. Millerec0a1962008-06-12 16:31:35 -0700598 If icsk->icsk_accept_queue.rskq_defer_accept, we silently drop this
599 bare ACK. Otherwise, we create an established connection. Both
600 ends (listening sockets) accept the new incoming connection and try
601 to talk to each other. 8-)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
603 Note: This case is both harmless, and rare. Possibility is about the
604 same as us discovering intelligent life on another plant tomorrow.
605
606 But generally, we should (RFC lies!) to accept ACK
607 from SYNACK both here and in tcp_rcv_state_process().
608 tcp_rcv_state_process() does not, hence, we do not too.
609
610 Note that the case is absolutely generic:
611 we cannot optimize anything here without
612 violating protocol. All the checks must be made
613 before attempt to create socket.
614 */
615
616 /* RFC793 page 36: "If the connection is in any non-synchronized state ...
617 * and the incoming segment acknowledges something not yet
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -0800618 * sent (the segment carries an unacceptable ACK) ...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 * a reset is sent."
620 *
621 * Invalid ACK: reset will be sent by listening socket
622 */
623 if ((flg & TCP_FLAG_ACK) &&
William Allen Simpson435cf552009-12-02 18:17:05 +0000624 (TCP_SKB_CB(skb)->ack_seq !=
625 tcp_rsk(req)->snt_isn + 1 + tcp_s_data_size(tcp_sk(sk))))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 return sk;
627
628 /* Also, it would be not so bad idea to check rcv_tsecr, which
629 * is essentially ACK extension and too early or too late values
630 * should cause reset in unsynchronized states.
631 */
632
633 /* RFC793: "first check sequence number". */
634
635 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 -0700636 tcp_rsk(req)->rcv_isn + 1, tcp_rsk(req)->rcv_isn + 1 + req->rcv_wnd)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 /* Out of window: send ACK and drop. */
638 if (!(flg & TCP_FLAG_RST))
Gui Jianfeng6edafaa2008-08-06 23:50:04 -0700639 req->rsk_ops->send_ack(sk, skb, req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 if (paws_reject)
Pavel Emelyanovde0744a2008-07-16 20:31:16 -0700641 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSESTABREJECTED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 return NULL;
643 }
644
645 /* In sequence, PAWS is OK. */
646
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700647 if (tmp_opt.saw_tstamp && !after(TCP_SKB_CB(skb)->seq, tcp_rsk(req)->rcv_isn + 1))
Adam Langley2aaab9a2008-08-07 20:27:45 -0700648 req->ts_recent = tmp_opt.rcv_tsval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649
Adam Langley2aaab9a2008-08-07 20:27:45 -0700650 if (TCP_SKB_CB(skb)->seq == tcp_rsk(req)->rcv_isn) {
651 /* Truncate SYN, it is out of window starting
652 at tcp_rsk(req)->rcv_isn + 1. */
653 flg &= ~TCP_FLAG_SYN;
654 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655
Adam Langley2aaab9a2008-08-07 20:27:45 -0700656 /* RFC793: "second check the RST bit" and
657 * "fourth, check the SYN bit"
658 */
659 if (flg & (TCP_FLAG_RST|TCP_FLAG_SYN)) {
660 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_ATTEMPTFAILS);
661 goto embryonic_reset;
662 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
Adam Langley2aaab9a2008-08-07 20:27:45 -0700664 /* ACK sequence verified above, just make sure ACK is
665 * set. If ACK not set, just silently drop the packet.
666 */
667 if (!(flg & TCP_FLAG_ACK))
668 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669
Julian Anastasovd1b99ba2009-10-19 10:01:56 +0000670 /* While TCP_DEFER_ACCEPT is active, drop bare ACK. */
671 if (req->retrans < inet_csk(sk)->icsk_accept_queue.rskq_defer_accept &&
Adam Langley2aaab9a2008-08-07 20:27:45 -0700672 TCP_SKB_CB(skb)->end_seq == tcp_rsk(req)->rcv_isn + 1) {
673 inet_rsk(req)->acked = 1;
674 return NULL;
675 }
David S. Millerec0a1962008-06-12 16:31:35 -0700676
Adam Langley2aaab9a2008-08-07 20:27:45 -0700677 /* OK, ACK is valid, create big socket and
678 * feed this segment to it. It will repeat all
679 * the tests. THIS SEGMENT MUST MOVE SOCKET TO
680 * ESTABLISHED STATE. If it will be dropped after
681 * socket is created, wait for troubles.
682 */
683 child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL);
684 if (child == NULL)
685 goto listen_overflow;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
Adam Langley2aaab9a2008-08-07 20:27:45 -0700687 inet_csk_reqsk_queue_unlink(sk, req, prev);
688 inet_csk_reqsk_queue_removed(sk, req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
Adam Langley2aaab9a2008-08-07 20:27:45 -0700690 inet_csk_reqsk_queue_add(sk, req, child);
691 return child;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692
Adam Langley2aaab9a2008-08-07 20:27:45 -0700693listen_overflow:
694 if (!sysctl_tcp_abort_on_overflow) {
695 inet_rsk(req)->acked = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 return NULL;
Adam Langley2aaab9a2008-08-07 20:27:45 -0700697 }
698
699embryonic_reset:
700 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_EMBRYONICRSTS);
701 if (!(flg & TCP_FLAG_RST))
702 req->rsk_ops->send_reset(sk, skb);
703
704 inet_csk_reqsk_queue_drop(sk, req, prev);
705 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706}
707
708/*
709 * Queue segment on the new socket if the new socket is active,
710 * otherwise we just shortcircuit this and continue with
711 * the new socket.
712 */
713
714int tcp_child_process(struct sock *parent, struct sock *child,
715 struct sk_buff *skb)
716{
717 int ret = 0;
718 int state = child->sk_state;
719
720 if (!sock_owned_by_user(child)) {
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700721 ret = tcp_rcv_state_process(child, skb, tcp_hdr(skb),
722 skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 /* Wakeup parent, send SIGIO */
724 if (state == TCP_SYN_RECV && child->sk_state != state)
725 parent->sk_data_ready(parent, 0);
726 } else {
727 /* Alas, it is possible again, because we do lookup
728 * in main socket hash table and lock on listening
729 * socket does not protect us more.
730 */
731 sk_add_backlog(child, skb);
732 }
733
734 bh_unlock_sock(child);
735 sock_put(child);
736 return ret;
737}
738
739EXPORT_SYMBOL(tcp_check_req);
740EXPORT_SYMBOL(tcp_child_process);
741EXPORT_SYMBOL(tcp_create_openreq_child);
742EXPORT_SYMBOL(tcp_timewait_state_process);