blob: 9e85c04161090e7687024906e2d288f3132cb4c1 [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 *
8 * Version: $Id: tcp_ipv4.c,v 1.240 2002/02/01 22:01:04 davem Exp $
9 *
10 * IPv4 specific functions
11 *
12 *
13 * code split from:
14 * linux/ipv4/tcp.c
15 * linux/ipv4/tcp_input.c
16 * linux/ipv4/tcp_output.c
17 *
18 * See tcp.c for author information
19 *
20 * This program is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU General Public License
22 * as published by the Free Software Foundation; either version
23 * 2 of the License, or (at your option) any later version.
24 */
25
26/*
27 * Changes:
28 * David S. Miller : New socket lookup architecture.
29 * This code is dedicated to John Dyson.
30 * David S. Miller : Change semantics of established hash,
31 * half is devoted to TIME_WAIT sockets
32 * and the rest go in the other half.
33 * Andi Kleen : Add support for syncookies and fixed
34 * some bugs: ip options weren't passed to
35 * the TCP layer, missed a check for an
36 * ACK bit.
37 * Andi Kleen : Implemented fast path mtu discovery.
38 * Fixed many serious bugs in the
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -070039 * request_sock handling and moved
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 * most of it into the af independent code.
41 * Added tail drop and some other bugfixes.
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -080042 * Added new listen semantics.
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 * Mike McLagan : Routing by source
44 * Juan Jose Ciarlante: ip_dynaddr bits
45 * Andi Kleen: various fixes.
46 * Vitaly E. Lavrov : Transparent proxy revived after year
47 * coma.
48 * Andi Kleen : Fix new listen.
49 * Andi Kleen : Fix accept error reporting.
50 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
51 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
52 * a single port at the same time.
53 */
54
55#include <linux/config.h>
56
57#include <linux/types.h>
58#include <linux/fcntl.h>
59#include <linux/module.h>
60#include <linux/random.h>
61#include <linux/cache.h>
62#include <linux/jhash.h>
63#include <linux/init.h>
64#include <linux/times.h>
65
66#include <net/icmp.h>
Arnaldo Carvalho de Melo304a1612005-08-09 19:59:20 -070067#include <net/inet_hashtables.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <net/tcp.h>
Arnaldo Carvalho de Melo20380732005-08-16 02:18:02 -030069#include <net/transp_v6.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#include <net/ipv6.h>
71#include <net/inet_common.h>
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -080072#include <net/timewait_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070073#include <net/xfrm.h>
74
75#include <linux/inet.h>
76#include <linux/ipv6.h>
77#include <linux/stddef.h>
78#include <linux/proc_fs.h>
79#include <linux/seq_file.h>
80
Linus Torvalds1da177e2005-04-16 15:20:36 -070081int sysctl_tcp_tw_reuse;
82int sysctl_tcp_low_latency;
83
84/* Check TCP sequence numbers in ICMP packets. */
85#define ICMP_MIN_LENGTH 8
86
87/* Socket used for sending RSTs */
88static struct socket *tcp_socket;
89
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -080090void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -070092struct inet_hashinfo __cacheline_aligned tcp_hashinfo = {
93 .lhash_lock = RW_LOCK_UNLOCKED,
94 .lhash_users = ATOMIC_INIT(0),
95 .lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(tcp_hashinfo.lhash_wait),
Linus Torvalds1da177e2005-04-16 15:20:36 -070096};
97
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -070098static int tcp_v4_get_port(struct sock *sk, unsigned short snum)
99{
Arnaldo Carvalho de Melo971af182005-12-13 23:14:47 -0800100 return inet_csk_get_port(&tcp_hashinfo, sk, snum,
101 inet_csk_bind_conflict);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700102}
103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104static void tcp_v4_hash(struct sock *sk)
105{
Arnaldo Carvalho de Melo81849d12005-08-09 20:08:50 -0700106 inet_hash(&tcp_hashinfo, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107}
108
109void tcp_unhash(struct sock *sk)
110{
Arnaldo Carvalho de Melo81849d12005-08-09 20:08:50 -0700111 inet_unhash(&tcp_hashinfo, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112}
113
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114static inline __u32 tcp_v4_init_sequence(struct sock *sk, struct sk_buff *skb)
115{
116 return secure_tcp_sequence_number(skb->nh.iph->daddr,
117 skb->nh.iph->saddr,
118 skb->h.th->dest,
119 skb->h.th->source);
120}
121
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800122int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
123{
124 const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
125 struct tcp_sock *tp = tcp_sk(sk);
126
127 /* With PAWS, it is safe from the viewpoint
128 of data integrity. Even without PAWS it is safe provided sequence
129 spaces do not overlap i.e. at data rates <= 80Mbit/sec.
130
131 Actually, the idea is close to VJ's one, only timestamp cache is
132 held not per host, but per port pair and TW bucket is used as state
133 holder.
134
135 If TW bucket has been already destroyed we fall back to VJ's scheme
136 and use initial timestamp retrieved from peer table.
137 */
138 if (tcptw->tw_ts_recent_stamp &&
139 (twp == NULL || (sysctl_tcp_tw_reuse &&
140 xtime.tv_sec - tcptw->tw_ts_recent_stamp > 1))) {
141 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
142 if (tp->write_seq == 0)
143 tp->write_seq = 1;
144 tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
145 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
146 sock_hold(sktw);
147 return 1;
148 }
149
150 return 0;
151}
152
153EXPORT_SYMBOL_GPL(tcp_twsk_unique);
154
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155/* This will initiate an outgoing connection. */
156int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
157{
158 struct inet_sock *inet = inet_sk(sk);
159 struct tcp_sock *tp = tcp_sk(sk);
160 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
161 struct rtable *rt;
162 u32 daddr, nexthop;
163 int tmp;
164 int err;
165
166 if (addr_len < sizeof(struct sockaddr_in))
167 return -EINVAL;
168
169 if (usin->sin_family != AF_INET)
170 return -EAFNOSUPPORT;
171
172 nexthop = daddr = usin->sin_addr.s_addr;
173 if (inet->opt && inet->opt->srr) {
174 if (!daddr)
175 return -EINVAL;
176 nexthop = inet->opt->faddr;
177 }
178
179 tmp = ip_route_connect(&rt, nexthop, inet->saddr,
180 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
181 IPPROTO_TCP,
182 inet->sport, usin->sin_port, sk);
183 if (tmp < 0)
184 return tmp;
185
186 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
187 ip_rt_put(rt);
188 return -ENETUNREACH;
189 }
190
191 if (!inet->opt || !inet->opt->srr)
192 daddr = rt->rt_dst;
193
194 if (!inet->saddr)
195 inet->saddr = rt->rt_src;
196 inet->rcv_saddr = inet->saddr;
197
198 if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) {
199 /* Reset inherited state */
200 tp->rx_opt.ts_recent = 0;
201 tp->rx_opt.ts_recent_stamp = 0;
202 tp->write_seq = 0;
203 }
204
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700205 if (tcp_death_row.sysctl_tw_recycle &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
207 struct inet_peer *peer = rt_get_peer(rt);
208
209 /* VJ's idea. We save last timestamp seen from
210 * the destination in peer table, when entering state TIME-WAIT
211 * and initialize rx_opt.ts_recent from it, when trying new connection.
212 */
213
214 if (peer && peer->tcp_ts_stamp + TCP_PAWS_MSL >= xtime.tv_sec) {
215 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
216 tp->rx_opt.ts_recent = peer->tcp_ts;
217 }
218 }
219
220 inet->dport = usin->sin_port;
221 inet->daddr = daddr;
222
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800223 inet_csk(sk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 if (inet->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800225 inet_csk(sk)->icsk_ext_hdr_len = inet->opt->optlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
227 tp->rx_opt.mss_clamp = 536;
228
229 /* Socket identity is still unknown (sport may be zero).
230 * However we set state to SYN-SENT and not releasing socket
231 * lock select source port, enter ourselves into the hash tables and
232 * complete initialization after this.
233 */
234 tcp_set_state(sk, TCP_SYN_SENT);
Arnaldo Carvalho de Meloa7f5e7f2005-12-13 23:25:31 -0800235 err = inet_hash_connect(&tcp_death_row, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 if (err)
237 goto failure;
238
Patrick McHardy5d39a792006-01-31 17:35:35 -0800239 err = ip_route_newports(&rt, IPPROTO_TCP, inet->sport, inet->dport, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 if (err)
241 goto failure;
242
243 /* OK, now commit destination to socket. */
Arnaldo Carvalho de Melo6cbb0df2005-08-09 19:49:02 -0700244 sk_setup_caps(sk, &rt->u.dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245
246 if (!tp->write_seq)
247 tp->write_seq = secure_tcp_sequence_number(inet->saddr,
248 inet->daddr,
249 inet->sport,
250 usin->sin_port);
251
252 inet->id = tp->write_seq ^ jiffies;
253
254 err = tcp_connect(sk);
255 rt = NULL;
256 if (err)
257 goto failure;
258
259 return 0;
260
261failure:
262 /* This unhashes the socket and releases the local port, if necessary. */
263 tcp_set_state(sk, TCP_CLOSE);
264 ip_rt_put(rt);
265 sk->sk_route_caps = 0;
266 inet->dport = 0;
267 return err;
268}
269
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270/*
271 * This routine does path mtu discovery as defined in RFC1191.
272 */
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800273static void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, u32 mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274{
275 struct dst_entry *dst;
276 struct inet_sock *inet = inet_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
278 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
279 * send out by Linux are always <576bytes so they should go through
280 * unfragmented).
281 */
282 if (sk->sk_state == TCP_LISTEN)
283 return;
284
285 /* We don't check in the destentry if pmtu discovery is forbidden
286 * on this route. We just assume that no packet_to_big packets
287 * are send back when pmtu discovery is not active.
288 * There is a small race when the user changes this flag in the
289 * route, but I think that's acceptable.
290 */
291 if ((dst = __sk_dst_check(sk, 0)) == NULL)
292 return;
293
294 dst->ops->update_pmtu(dst, mtu);
295
296 /* Something is about to be wrong... Remember soft error
297 * for the case, if this connection will not able to recover.
298 */
299 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
300 sk->sk_err_soft = EMSGSIZE;
301
302 mtu = dst_mtu(dst);
303
304 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800305 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 tcp_sync_mss(sk, mtu);
307
308 /* Resend the TCP packet because it's
309 * clear that the old packet has been
310 * dropped. This is the new "fast" path mtu
311 * discovery.
312 */
313 tcp_simple_retransmit(sk);
314 } /* else let the usual retransmit timer handle it */
315}
316
317/*
318 * This routine is called by the ICMP module when it gets some
319 * sort of error condition. If err < 0 then the socket should
320 * be closed and the error returned to the user. If err > 0
321 * it's just the icmp type << 8 | icmp code. After adjustment
322 * header points to the first 8 bytes of the tcp header. We need
323 * to find the appropriate port.
324 *
325 * The locking strategy used here is very "optimistic". When
326 * someone else accesses the socket the ICMP is just dropped
327 * and for some paths there is no check at all.
328 * A more general error queue to queue errors for later handling
329 * is probably better.
330 *
331 */
332
333void tcp_v4_err(struct sk_buff *skb, u32 info)
334{
335 struct iphdr *iph = (struct iphdr *)skb->data;
336 struct tcphdr *th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
337 struct tcp_sock *tp;
338 struct inet_sock *inet;
339 int type = skb->h.icmph->type;
340 int code = skb->h.icmph->code;
341 struct sock *sk;
342 __u32 seq;
343 int err;
344
345 if (skb->len < (iph->ihl << 2) + 8) {
346 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
347 return;
348 }
349
Arnaldo Carvalho de Meloe48c4142005-08-09 20:09:46 -0700350 sk = inet_lookup(&tcp_hashinfo, iph->daddr, th->dest, iph->saddr,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700351 th->source, inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 if (!sk) {
353 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
354 return;
355 }
356 if (sk->sk_state == TCP_TIME_WAIT) {
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700357 inet_twsk_put((struct inet_timewait_sock *)sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 return;
359 }
360
361 bh_lock_sock(sk);
362 /* If too many ICMPs get dropped on busy
363 * servers this needs to be solved differently.
364 */
365 if (sock_owned_by_user(sk))
366 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
367
368 if (sk->sk_state == TCP_CLOSE)
369 goto out;
370
371 tp = tcp_sk(sk);
372 seq = ntohl(th->seq);
373 if (sk->sk_state != TCP_LISTEN &&
374 !between(seq, tp->snd_una, tp->snd_nxt)) {
375 NET_INC_STATS(LINUX_MIB_OUTOFWINDOWICMPS);
376 goto out;
377 }
378
379 switch (type) {
380 case ICMP_SOURCE_QUENCH:
381 /* Just silently ignore these. */
382 goto out;
383 case ICMP_PARAMETERPROB:
384 err = EPROTO;
385 break;
386 case ICMP_DEST_UNREACH:
387 if (code > NR_ICMP_UNREACH)
388 goto out;
389
390 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
391 if (!sock_owned_by_user(sk))
392 do_pmtu_discovery(sk, iph, info);
393 goto out;
394 }
395
396 err = icmp_err_convert[code].errno;
397 break;
398 case ICMP_TIME_EXCEEDED:
399 err = EHOSTUNREACH;
400 break;
401 default:
402 goto out;
403 }
404
405 switch (sk->sk_state) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700406 struct request_sock *req, **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 case TCP_LISTEN:
408 if (sock_owned_by_user(sk))
409 goto out;
410
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700411 req = inet_csk_search_req(sk, &prev, th->dest,
412 iph->daddr, iph->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 if (!req)
414 goto out;
415
416 /* ICMPs are not backlogged, hence we cannot get
417 an established socket here.
418 */
419 BUG_TRAP(!req->sk);
420
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700421 if (seq != tcp_rsk(req)->snt_isn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
423 goto out;
424 }
425
426 /*
427 * Still in SYN_RECV, just remove it silently.
428 * There is no good way to pass the error to the newly
429 * created socket, and POSIX does not want network
430 * errors returned from accept().
431 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700432 inet_csk_reqsk_queue_drop(sk, req, prev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 goto out;
434
435 case TCP_SYN_SENT:
436 case TCP_SYN_RECV: /* Cannot happen.
437 It can f.e. if SYNs crossed.
438 */
439 if (!sock_owned_by_user(sk)) {
440 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
441 sk->sk_err = err;
442
443 sk->sk_error_report(sk);
444
445 tcp_done(sk);
446 } else {
447 sk->sk_err_soft = err;
448 }
449 goto out;
450 }
451
452 /* If we've already connected we will keep trying
453 * until we time out, or the user gives up.
454 *
455 * rfc1122 4.2.3.9 allows to consider as hard errors
456 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
457 * but it is obsoleted by pmtu discovery).
458 *
459 * Note, that in modern internet, where routing is unreliable
460 * and in each dark corner broken firewalls sit, sending random
461 * errors ordered by their masters even this two messages finally lose
462 * their original sense (even Linux sends invalid PORT_UNREACHs)
463 *
464 * Now we are in compliance with RFCs.
465 * --ANK (980905)
466 */
467
468 inet = inet_sk(sk);
469 if (!sock_owned_by_user(sk) && inet->recverr) {
470 sk->sk_err = err;
471 sk->sk_error_report(sk);
472 } else { /* Only an error on timeout */
473 sk->sk_err_soft = err;
474 }
475
476out:
477 bh_unlock_sock(sk);
478 sock_put(sk);
479}
480
481/* This routine computes an IPv4 TCP checksum. */
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800482void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483{
484 struct inet_sock *inet = inet_sk(sk);
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800485 struct tcphdr *th = skb->h.th;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486
487 if (skb->ip_summed == CHECKSUM_HW) {
488 th->check = ~tcp_v4_check(th, len, inet->saddr, inet->daddr, 0);
489 skb->csum = offsetof(struct tcphdr, check);
490 } else {
491 th->check = tcp_v4_check(th, len, inet->saddr, inet->daddr,
492 csum_partial((char *)th,
493 th->doff << 2,
494 skb->csum));
495 }
496}
497
498/*
499 * This routine will send an RST to the other tcp.
500 *
501 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
502 * for reset.
503 * Answer: if a packet caused RST, it is not for a socket
504 * existing in our system, if it is matched to a socket,
505 * it is just duplicate segment or bug in other side's TCP.
506 * So that we build reply only basing on parameters
507 * arrived with segment.
508 * Exception: precedence violation. We do not implement it in any case.
509 */
510
511static void tcp_v4_send_reset(struct sk_buff *skb)
512{
513 struct tcphdr *th = skb->h.th;
514 struct tcphdr rth;
515 struct ip_reply_arg arg;
516
517 /* Never send a reset in response to a reset. */
518 if (th->rst)
519 return;
520
521 if (((struct rtable *)skb->dst)->rt_type != RTN_LOCAL)
522 return;
523
524 /* Swap the send and the receive. */
525 memset(&rth, 0, sizeof(struct tcphdr));
526 rth.dest = th->source;
527 rth.source = th->dest;
528 rth.doff = sizeof(struct tcphdr) / 4;
529 rth.rst = 1;
530
531 if (th->ack) {
532 rth.seq = th->ack_seq;
533 } else {
534 rth.ack = 1;
535 rth.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
536 skb->len - (th->doff << 2));
537 }
538
539 memset(&arg, 0, sizeof arg);
540 arg.iov[0].iov_base = (unsigned char *)&rth;
541 arg.iov[0].iov_len = sizeof rth;
542 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
543 skb->nh.iph->saddr, /*XXX*/
544 sizeof(struct tcphdr), IPPROTO_TCP, 0);
545 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
546
547 ip_send_reply(tcp_socket->sk, skb, &arg, sizeof rth);
548
549 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
550 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
551}
552
553/* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
554 outside socket context is ugly, certainly. What can I do?
555 */
556
557static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
558 u32 win, u32 ts)
559{
560 struct tcphdr *th = skb->h.th;
561 struct {
562 struct tcphdr th;
563 u32 tsopt[3];
564 } rep;
565 struct ip_reply_arg arg;
566
567 memset(&rep.th, 0, sizeof(struct tcphdr));
568 memset(&arg, 0, sizeof arg);
569
570 arg.iov[0].iov_base = (unsigned char *)&rep;
571 arg.iov[0].iov_len = sizeof(rep.th);
572 if (ts) {
573 rep.tsopt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
574 (TCPOPT_TIMESTAMP << 8) |
575 TCPOLEN_TIMESTAMP);
576 rep.tsopt[1] = htonl(tcp_time_stamp);
577 rep.tsopt[2] = htonl(ts);
578 arg.iov[0].iov_len = sizeof(rep);
579 }
580
581 /* Swap the send and the receive. */
582 rep.th.dest = th->source;
583 rep.th.source = th->dest;
584 rep.th.doff = arg.iov[0].iov_len / 4;
585 rep.th.seq = htonl(seq);
586 rep.th.ack_seq = htonl(ack);
587 rep.th.ack = 1;
588 rep.th.window = htons(win);
589
590 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
591 skb->nh.iph->saddr, /*XXX*/
592 arg.iov[0].iov_len, IPPROTO_TCP, 0);
593 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
594
595 ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len);
596
597 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
598}
599
600static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
601{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700602 struct inet_timewait_sock *tw = inet_twsk(sk);
603 const struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700605 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
606 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale, tcptw->tw_ts_recent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700608 inet_twsk_put(tw);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609}
610
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700611static void tcp_v4_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700613 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 req->ts_recent);
615}
616
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617/*
618 * Send a SYN-ACK after having received an ACK.
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700619 * This still operates on a request_sock only, not on a big
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 * socket.
621 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700622static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 struct dst_entry *dst)
624{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700625 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 int err = -1;
627 struct sk_buff * skb;
628
629 /* First, grab a route. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700630 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 goto out;
632
633 skb = tcp_make_synack(sk, dst, req);
634
635 if (skb) {
636 struct tcphdr *th = skb->h.th;
637
638 th->check = tcp_v4_check(th, skb->len,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700639 ireq->loc_addr,
640 ireq->rmt_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 csum_partial((char *)th, skb->len,
642 skb->csum));
643
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700644 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
645 ireq->rmt_addr,
646 ireq->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 if (err == NET_XMIT_CN)
648 err = 0;
649 }
650
651out:
652 dst_release(dst);
653 return err;
654}
655
656/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700657 * IPv4 request_sock destructor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 */
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700659static void tcp_v4_reqsk_destructor(struct request_sock *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660{
Jesper Juhla51482b2005-11-08 09:41:34 -0800661 kfree(inet_rsk(req)->opt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662}
663
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200664#ifdef CONFIG_SYN_COOKIES
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800665static void syn_flood_warning(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666{
667 static unsigned long warntime;
668
669 if (time_after(jiffies, (warntime + HZ * 60))) {
670 warntime = jiffies;
671 printk(KERN_INFO
672 "possible SYN flooding on port %d. Sending cookies.\n",
673 ntohs(skb->h.th->dest));
674 }
675}
Arnaldo Carvalho de Melo80e40da2006-01-04 01:58:06 -0200676#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
678/*
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700679 * Save and compile IPv4 options into the request_sock if needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 */
Stephen Hemminger40efc6f2006-01-03 16:03:49 -0800681static struct ip_options *tcp_v4_save_options(struct sock *sk,
682 struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683{
684 struct ip_options *opt = &(IPCB(skb)->opt);
685 struct ip_options *dopt = NULL;
686
687 if (opt && opt->optlen) {
688 int opt_size = optlength(opt);
689 dopt = kmalloc(opt_size, GFP_ATOMIC);
690 if (dopt) {
691 if (ip_options_echo(dopt, skb)) {
692 kfree(dopt);
693 dopt = NULL;
694 }
695 }
696 }
697 return dopt;
698}
699
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700700struct request_sock_ops tcp_request_sock_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 .family = PF_INET,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700702 .obj_size = sizeof(struct tcp_request_sock),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 .rtx_syn_ack = tcp_v4_send_synack,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700704 .send_ack = tcp_v4_reqsk_send_ack,
705 .destructor = tcp_v4_reqsk_destructor,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 .send_reset = tcp_v4_send_reset,
707};
708
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -0800709static struct timewait_sock_ops tcp_timewait_sock_ops = {
710 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
711 .twsk_unique = tcp_twsk_unique,
712};
713
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
715{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700716 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 struct tcp_options_received tmp_opt;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700718 struct request_sock *req;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 __u32 saddr = skb->nh.iph->saddr;
720 __u32 daddr = skb->nh.iph->daddr;
721 __u32 isn = TCP_SKB_CB(skb)->when;
722 struct dst_entry *dst = NULL;
723#ifdef CONFIG_SYN_COOKIES
724 int want_cookie = 0;
725#else
726#define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
727#endif
728
729 /* Never answer to SYNs send to broadcast or multicast */
730 if (((struct rtable *)skb->dst)->rt_flags &
731 (RTCF_BROADCAST | RTCF_MULTICAST))
732 goto drop;
733
734 /* TW buckets are converted to open requests without
735 * limitations, they conserve resources and peer is
736 * evidently real one.
737 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700738 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739#ifdef CONFIG_SYN_COOKIES
740 if (sysctl_tcp_syncookies) {
741 want_cookie = 1;
742 } else
743#endif
744 goto drop;
745 }
746
747 /* Accept backlog is full. If we have already queued enough
748 * of warm entries in syn queue, drop request. It is better than
749 * clogging syn queue with openreqs with exponentially increasing
750 * timeout.
751 */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700752 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 goto drop;
754
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700755 req = reqsk_alloc(&tcp_request_sock_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 if (!req)
757 goto drop;
758
759 tcp_clear_options(&tmp_opt);
760 tmp_opt.mss_clamp = 536;
761 tmp_opt.user_mss = tcp_sk(sk)->rx_opt.user_mss;
762
763 tcp_parse_options(skb, &tmp_opt, 0);
764
765 if (want_cookie) {
766 tcp_clear_options(&tmp_opt);
767 tmp_opt.saw_tstamp = 0;
768 }
769
770 if (tmp_opt.saw_tstamp && !tmp_opt.rcv_tsval) {
771 /* Some OSes (unknown ones, but I see them on web server, which
772 * contains information interesting only for windows'
773 * users) do not send their stamp in SYN. It is easy case.
774 * We simply do not advertise TS support.
775 */
776 tmp_opt.saw_tstamp = 0;
777 tmp_opt.tstamp_ok = 0;
778 }
779 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
780
781 tcp_openreq_init(req, &tmp_opt, skb);
782
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700783 ireq = inet_rsk(req);
784 ireq->loc_addr = daddr;
785 ireq->rmt_addr = saddr;
786 ireq->opt = tcp_v4_save_options(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 if (!want_cookie)
788 TCP_ECN_create_request(req, skb->h.th);
789
790 if (want_cookie) {
791#ifdef CONFIG_SYN_COOKIES
792 syn_flood_warning(skb);
793#endif
794 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
795 } else if (!isn) {
796 struct inet_peer *peer = NULL;
797
798 /* VJ's idea. We save last timestamp seen
799 * from the destination in peer table, when entering
800 * state TIME-WAIT, and check against it before
801 * accepting new connection request.
802 *
803 * If "isn" is not zero, this request hit alive
804 * timewait bucket, so that all the necessary checks
805 * are made in the function processing timewait state.
806 */
807 if (tmp_opt.saw_tstamp &&
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -0700808 tcp_death_row.sysctl_tw_recycle &&
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700809 (dst = inet_csk_route_req(sk, req)) != NULL &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
811 peer->v4daddr == saddr) {
812 if (xtime.tv_sec < peer->tcp_ts_stamp + TCP_PAWS_MSL &&
813 (s32)(peer->tcp_ts - req->ts_recent) >
814 TCP_PAWS_WINDOW) {
815 NET_INC_STATS_BH(LINUX_MIB_PAWSPASSIVEREJECTED);
816 dst_release(dst);
817 goto drop_and_free;
818 }
819 }
820 /* Kill the following clause, if you dislike this way. */
821 else if (!sysctl_tcp_syncookies &&
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700822 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 (sysctl_max_syn_backlog >> 2)) &&
824 (!peer || !peer->tcp_ts_stamp) &&
825 (!dst || !dst_metric(dst, RTAX_RTT))) {
826 /* Without syncookies last quarter of
827 * backlog is filled with destinations,
828 * proven to be alive.
829 * It means that we continue to communicate
830 * to destinations, already remembered
831 * to the moment of synflood.
832 */
Patrick McHardy64ce2072005-08-09 20:50:53 -0700833 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open "
834 "request from %u.%u.%u.%u/%u\n",
835 NIPQUAD(saddr),
836 ntohs(skb->h.th->source));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 dst_release(dst);
838 goto drop_and_free;
839 }
840
841 isn = tcp_v4_init_sequence(sk, skb);
842 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700843 tcp_rsk(req)->snt_isn = isn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844
845 if (tcp_v4_send_synack(sk, req, dst))
846 goto drop_and_free;
847
848 if (want_cookie) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700849 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 } else {
Arnaldo Carvalho de Melo3f421ba2005-08-09 20:11:08 -0700851 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 }
853 return 0;
854
855drop_and_free:
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700856 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857drop:
858 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
859 return 0;
860}
861
862
863/*
864 * The three way handshake has completed - we got a valid synack -
865 * now create the new socket.
866 */
867struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700868 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 struct dst_entry *dst)
870{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700871 struct inet_request_sock *ireq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 struct inet_sock *newinet;
873 struct tcp_sock *newtp;
874 struct sock *newsk;
875
876 if (sk_acceptq_is_full(sk))
877 goto exit_overflow;
878
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700879 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 goto exit;
881
882 newsk = tcp_create_openreq_child(sk, req, skb);
883 if (!newsk)
884 goto exit;
885
Arnaldo Carvalho de Melo6cbb0df2005-08-09 19:49:02 -0700886 sk_setup_caps(newsk, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887
888 newtp = tcp_sk(newsk);
889 newinet = inet_sk(newsk);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700890 ireq = inet_rsk(req);
891 newinet->daddr = ireq->rmt_addr;
892 newinet->rcv_saddr = ireq->loc_addr;
893 newinet->saddr = ireq->loc_addr;
894 newinet->opt = ireq->opt;
895 ireq->opt = NULL;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700896 newinet->mc_index = inet_iif(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 newinet->mc_ttl = skb->nh.iph->ttl;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800898 inet_csk(newsk)->icsk_ext_hdr_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 if (newinet->opt)
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -0800900 inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 newinet->id = newtp->write_seq ^ jiffies;
902
John Heffner5d424d52006-03-20 17:53:41 -0800903 tcp_mtup_init(newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 tcp_sync_mss(newsk, dst_mtu(dst));
905 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
906 tcp_initialize_rcv_mss(newsk);
907
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -0700908 __inet_hash(&tcp_hashinfo, newsk, 0);
Arnaldo Carvalho de Melo2d8c4ce2005-08-09 20:07:13 -0700909 __inet_inherit_port(&tcp_hashinfo, sk, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910
911 return newsk;
912
913exit_overflow:
914 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
915exit:
916 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
917 dst_release(dst);
918 return NULL;
919}
920
921static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
922{
923 struct tcphdr *th = skb->h.th;
924 struct iphdr *iph = skb->nh.iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 struct sock *nsk;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700926 struct request_sock **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 /* Find possible connection requests. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700928 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
929 iph->saddr, iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 if (req)
931 return tcp_check_req(sk, skb, req, prev);
932
Arnaldo Carvalho de Meloe48c4142005-08-09 20:09:46 -0700933 nsk = __inet_lookup_established(&tcp_hashinfo, skb->nh.iph->saddr,
934 th->source, skb->nh.iph->daddr,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700935 ntohs(th->dest), inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936
937 if (nsk) {
938 if (nsk->sk_state != TCP_TIME_WAIT) {
939 bh_lock_sock(nsk);
940 return nsk;
941 }
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700942 inet_twsk_put((struct inet_timewait_sock *)nsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 return NULL;
944 }
945
946#ifdef CONFIG_SYN_COOKIES
947 if (!th->rst && !th->syn && th->ack)
948 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
949#endif
950 return sk;
951}
952
953static int tcp_v4_checksum_init(struct sk_buff *skb)
954{
955 if (skb->ip_summed == CHECKSUM_HW) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 if (!tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
Herbert Xufb286bb2005-11-10 13:01:24 -0800957 skb->nh.iph->daddr, skb->csum)) {
958 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -0800960 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 }
Herbert Xufb286bb2005-11-10 13:01:24 -0800962
963 skb->csum = csum_tcpudp_nofold(skb->nh.iph->saddr, skb->nh.iph->daddr,
964 skb->len, IPPROTO_TCP, 0);
965
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -0800967 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 }
969 return 0;
970}
971
972
973/* The socket must have it's spinlock held when we get
974 * here.
975 *
976 * We have a potential double-lock case here, so even when
977 * doing backlog processing we use the BH locking scheme.
978 * This is because we cannot sleep with the original spinlock
979 * held.
980 */
981int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
982{
983 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
984 TCP_CHECK_TIMER(sk);
985 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len))
986 goto reset;
987 TCP_CHECK_TIMER(sk);
988 return 0;
989 }
990
991 if (skb->len < (skb->h.th->doff << 2) || tcp_checksum_complete(skb))
992 goto csum_err;
993
994 if (sk->sk_state == TCP_LISTEN) {
995 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
996 if (!nsk)
997 goto discard;
998
999 if (nsk != sk) {
1000 if (tcp_child_process(sk, nsk, skb))
1001 goto reset;
1002 return 0;
1003 }
1004 }
1005
1006 TCP_CHECK_TIMER(sk);
1007 if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len))
1008 goto reset;
1009 TCP_CHECK_TIMER(sk);
1010 return 0;
1011
1012reset:
1013 tcp_v4_send_reset(skb);
1014discard:
1015 kfree_skb(skb);
1016 /* Be careful here. If this function gets more complicated and
1017 * gcc suffers from register pressure on the x86, sk (in %ebx)
1018 * might be destroyed here. This current version compiles correctly,
1019 * but you have been warned.
1020 */
1021 return 0;
1022
1023csum_err:
1024 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1025 goto discard;
1026}
1027
1028/*
1029 * From tcp_input.c
1030 */
1031
1032int tcp_v4_rcv(struct sk_buff *skb)
1033{
1034 struct tcphdr *th;
1035 struct sock *sk;
1036 int ret;
1037
1038 if (skb->pkt_type != PACKET_HOST)
1039 goto discard_it;
1040
1041 /* Count it even if it's bad */
1042 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1043
1044 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1045 goto discard_it;
1046
1047 th = skb->h.th;
1048
1049 if (th->doff < sizeof(struct tcphdr) / 4)
1050 goto bad_packet;
1051 if (!pskb_may_pull(skb, th->doff * 4))
1052 goto discard_it;
1053
1054 /* An explanation is required here, I think.
1055 * Packet length and doff are validated by header prediction,
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -08001056 * provided case of th->doff==0 is eliminated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 * So, we defer the checks. */
1058 if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
Herbert Xufb286bb2005-11-10 13:01:24 -08001059 tcp_v4_checksum_init(skb)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 goto bad_packet;
1061
1062 th = skb->h.th;
1063 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1064 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1065 skb->len - th->doff * 4);
1066 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1067 TCP_SKB_CB(skb)->when = 0;
1068 TCP_SKB_CB(skb)->flags = skb->nh.iph->tos;
1069 TCP_SKB_CB(skb)->sacked = 0;
1070
Arnaldo Carvalho de Meloe48c4142005-08-09 20:09:46 -07001071 sk = __inet_lookup(&tcp_hashinfo, skb->nh.iph->saddr, th->source,
1072 skb->nh.iph->daddr, ntohs(th->dest),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001073 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074
1075 if (!sk)
1076 goto no_tcp_socket;
1077
1078process:
1079 if (sk->sk_state == TCP_TIME_WAIT)
1080 goto do_time_wait;
1081
1082 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1083 goto discard_and_relse;
Patrick McHardyb59c2702006-01-06 23:06:10 -08001084 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085
1086 if (sk_filter(sk, skb, 0))
1087 goto discard_and_relse;
1088
1089 skb->dev = NULL;
1090
1091 bh_lock_sock(sk);
1092 ret = 0;
1093 if (!sock_owned_by_user(sk)) {
1094 if (!tcp_prequeue(sk, skb))
1095 ret = tcp_v4_do_rcv(sk, skb);
1096 } else
1097 sk_add_backlog(sk, skb);
1098 bh_unlock_sock(sk);
1099
1100 sock_put(sk);
1101
1102 return ret;
1103
1104no_tcp_socket:
1105 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1106 goto discard_it;
1107
1108 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1109bad_packet:
1110 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1111 } else {
1112 tcp_v4_send_reset(skb);
1113 }
1114
1115discard_it:
1116 /* Discard frame. */
1117 kfree_skb(skb);
1118 return 0;
1119
1120discard_and_relse:
1121 sock_put(sk);
1122 goto discard_it;
1123
1124do_time_wait:
1125 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001126 inet_twsk_put((struct inet_timewait_sock *) sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 goto discard_it;
1128 }
1129
1130 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1131 TCP_INC_STATS_BH(TCP_MIB_INERRS);
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001132 inet_twsk_put((struct inet_timewait_sock *) sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 goto discard_it;
1134 }
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001135 switch (tcp_timewait_state_process((struct inet_timewait_sock *)sk,
1136 skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 case TCP_TW_SYN: {
Arnaldo Carvalho de Melo33b62232005-08-09 20:09:06 -07001138 struct sock *sk2 = inet_lookup_listener(&tcp_hashinfo,
1139 skb->nh.iph->daddr,
1140 ntohs(th->dest),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001141 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 if (sk2) {
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001143 inet_twsk_deschedule((struct inet_timewait_sock *)sk,
1144 &tcp_death_row);
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001145 inet_twsk_put((struct inet_timewait_sock *)sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 sk = sk2;
1147 goto process;
1148 }
1149 /* Fall through to ACK */
1150 }
1151 case TCP_TW_ACK:
1152 tcp_v4_timewait_ack(sk, skb);
1153 break;
1154 case TCP_TW_RST:
1155 goto no_tcp_socket;
1156 case TCP_TW_SUCCESS:;
1157 }
1158 goto discard_it;
1159}
1160
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161/* VJ's idea. Save last timestamp seen from this destination
1162 * and hold it at least for normal timewait interval to use for duplicate
1163 * segment detection in subsequent connections, before they enter synchronized
1164 * state.
1165 */
1166
1167int tcp_v4_remember_stamp(struct sock *sk)
1168{
1169 struct inet_sock *inet = inet_sk(sk);
1170 struct tcp_sock *tp = tcp_sk(sk);
1171 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1172 struct inet_peer *peer = NULL;
1173 int release_it = 0;
1174
1175 if (!rt || rt->rt_dst != inet->daddr) {
1176 peer = inet_getpeer(inet->daddr, 1);
1177 release_it = 1;
1178 } else {
1179 if (!rt->peer)
1180 rt_bind_peer(rt, 1);
1181 peer = rt->peer;
1182 }
1183
1184 if (peer) {
1185 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
1186 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1187 peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {
1188 peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;
1189 peer->tcp_ts = tp->rx_opt.ts_recent;
1190 }
1191 if (release_it)
1192 inet_putpeer(peer);
1193 return 1;
1194 }
1195
1196 return 0;
1197}
1198
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001199int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001201 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202
1203 if (peer) {
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001204 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1205
1206 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001208 peer->tcp_ts_stamp <= tcptw->tw_ts_recent_stamp)) {
1209 peer->tcp_ts_stamp = tcptw->tw_ts_recent_stamp;
1210 peer->tcp_ts = tcptw->tw_ts_recent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 }
1212 inet_putpeer(peer);
1213 return 1;
1214 }
1215
1216 return 0;
1217}
1218
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001219struct inet_connection_sock_af_ops ipv4_specific = {
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001220 .queue_xmit = ip_queue_xmit,
1221 .send_check = tcp_v4_send_check,
1222 .rebuild_header = inet_sk_rebuild_header,
1223 .conn_request = tcp_v4_conn_request,
1224 .syn_recv_sock = tcp_v4_syn_recv_sock,
1225 .remember_stamp = tcp_v4_remember_stamp,
1226 .net_header_len = sizeof(struct iphdr),
1227 .setsockopt = ip_setsockopt,
1228 .getsockopt = ip_getsockopt,
1229 .addr2sockaddr = inet_csk_addr2sockaddr,
1230 .sockaddr_len = sizeof(struct sockaddr_in),
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001231#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001232 .compat_setsockopt = compat_ip_setsockopt,
1233 .compat_getsockopt = compat_ip_getsockopt,
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001234#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235};
1236
1237/* NOTE: A lot of things set to zero explicitly by call to
1238 * sk_alloc() so need not be done here.
1239 */
1240static int tcp_v4_init_sock(struct sock *sk)
1241{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001242 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 struct tcp_sock *tp = tcp_sk(sk);
1244
1245 skb_queue_head_init(&tp->out_of_order_queue);
1246 tcp_init_xmit_timers(sk);
1247 tcp_prequeue_init(tp);
1248
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001249 icsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 tp->mdev = TCP_TIMEOUT_INIT;
1251
1252 /* So many TCP implementations out there (incorrectly) count the
1253 * initial SYN frame in their delayed-ACK and congestion control
1254 * algorithms that we must have the following bandaid to talk
1255 * efficiently to them. -DaveM
1256 */
1257 tp->snd_cwnd = 2;
1258
1259 /* See draft-stevens-tcpca-spec-01 for discussion of the
1260 * initialization of these values.
1261 */
1262 tp->snd_ssthresh = 0x7fffffff; /* Infinity */
1263 tp->snd_cwnd_clamp = ~0;
David S. Millerc1b4a7e2005-07-05 15:24:38 -07001264 tp->mss_cache = 536;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265
1266 tp->reordering = sysctl_tcp_reordering;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001267 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268
1269 sk->sk_state = TCP_CLOSE;
1270
1271 sk->sk_write_space = sk_stream_write_space;
1272 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1273
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001274 icsk->icsk_af_ops = &ipv4_specific;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001275 icsk->icsk_sync_mss = tcp_sync_mss;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276
1277 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1278 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1279
1280 atomic_inc(&tcp_sockets_allocated);
1281
1282 return 0;
1283}
1284
1285int tcp_v4_destroy_sock(struct sock *sk)
1286{
1287 struct tcp_sock *tp = tcp_sk(sk);
1288
1289 tcp_clear_xmit_timers(sk);
1290
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001291 tcp_cleanup_congestion_control(sk);
Stephen Hemminger317a76f2005-06-23 12:19:55 -07001292
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 /* Cleanup up the write buffer. */
1294 sk_stream_writequeue_purge(sk);
1295
1296 /* Cleans up our, hopefully empty, out_of_order_queue. */
1297 __skb_queue_purge(&tp->out_of_order_queue);
1298
1299 /* Clean prequeue, it must be empty really */
1300 __skb_queue_purge(&tp->ucopy.prequeue);
1301
1302 /* Clean up a referenced TCP bind bucket. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001303 if (inet_csk(sk)->icsk_bind_hash)
Arnaldo Carvalho de Melo2d8c4ce2005-08-09 20:07:13 -07001304 inet_put_port(&tcp_hashinfo, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305
1306 /*
1307 * If sendmsg cached page exists, toss it.
1308 */
1309 if (sk->sk_sndmsg_page) {
1310 __free_page(sk->sk_sndmsg_page);
1311 sk->sk_sndmsg_page = NULL;
1312 }
1313
1314 atomic_dec(&tcp_sockets_allocated);
1315
1316 return 0;
1317}
1318
1319EXPORT_SYMBOL(tcp_v4_destroy_sock);
1320
1321#ifdef CONFIG_PROC_FS
1322/* Proc filesystem TCP sock list dumping. */
1323
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001324static inline struct inet_timewait_sock *tw_head(struct hlist_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325{
1326 return hlist_empty(head) ? NULL :
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001327 list_entry(head->first, struct inet_timewait_sock, tw_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328}
1329
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001330static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331{
1332 return tw->tw_node.next ?
1333 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
1334}
1335
1336static void *listening_get_next(struct seq_file *seq, void *cur)
1337{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001338 struct inet_connection_sock *icsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 struct hlist_node *node;
1340 struct sock *sk = cur;
1341 struct tcp_iter_state* st = seq->private;
1342
1343 if (!sk) {
1344 st->bucket = 0;
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001345 sk = sk_head(&tcp_hashinfo.listening_hash[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 goto get_sk;
1347 }
1348
1349 ++st->num;
1350
1351 if (st->state == TCP_SEQ_STATE_OPENREQ) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001352 struct request_sock *req = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001354 icsk = inet_csk(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 req = req->dl_next;
1356 while (1) {
1357 while (req) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001358 if (req->rsk_ops->family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 cur = req;
1360 goto out;
1361 }
1362 req = req->dl_next;
1363 }
1364 if (++st->sbucket >= TCP_SYNQ_HSIZE)
1365 break;
1366get_req:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001367 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 }
1369 sk = sk_next(st->syn_wait_sk);
1370 st->state = TCP_SEQ_STATE_LISTENING;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001371 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 } else {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001373 icsk = inet_csk(sk);
1374 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1375 if (reqsk_queue_len(&icsk->icsk_accept_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 goto start_req;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001377 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 sk = sk_next(sk);
1379 }
1380get_sk:
1381 sk_for_each_from(sk, node) {
1382 if (sk->sk_family == st->family) {
1383 cur = sk;
1384 goto out;
1385 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001386 icsk = inet_csk(sk);
1387 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1388 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389start_req:
1390 st->uid = sock_i_uid(sk);
1391 st->syn_wait_sk = sk;
1392 st->state = TCP_SEQ_STATE_OPENREQ;
1393 st->sbucket = 0;
1394 goto get_req;
1395 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001396 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 }
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -07001398 if (++st->bucket < INET_LHTABLE_SIZE) {
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001399 sk = sk_head(&tcp_hashinfo.listening_hash[st->bucket]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 goto get_sk;
1401 }
1402 cur = NULL;
1403out:
1404 return cur;
1405}
1406
1407static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
1408{
1409 void *rc = listening_get_next(seq, NULL);
1410
1411 while (rc && *pos) {
1412 rc = listening_get_next(seq, rc);
1413 --*pos;
1414 }
1415 return rc;
1416}
1417
1418static void *established_get_first(struct seq_file *seq)
1419{
1420 struct tcp_iter_state* st = seq->private;
1421 void *rc = NULL;
1422
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001423 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 struct sock *sk;
1425 struct hlist_node *node;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001426 struct inet_timewait_sock *tw;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427
1428 /* We can reschedule _before_ having picked the target: */
1429 cond_resched_softirq();
1430
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001431 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
1432 sk_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 if (sk->sk_family != st->family) {
1434 continue;
1435 }
1436 rc = sk;
1437 goto out;
1438 }
1439 st->state = TCP_SEQ_STATE_TIME_WAIT;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001440 inet_twsk_for_each(tw, node,
1441 &tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 if (tw->tw_family != st->family) {
1443 continue;
1444 }
1445 rc = tw;
1446 goto out;
1447 }
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001448 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 st->state = TCP_SEQ_STATE_ESTABLISHED;
1450 }
1451out:
1452 return rc;
1453}
1454
1455static void *established_get_next(struct seq_file *seq, void *cur)
1456{
1457 struct sock *sk = cur;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001458 struct inet_timewait_sock *tw;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 struct hlist_node *node;
1460 struct tcp_iter_state* st = seq->private;
1461
1462 ++st->num;
1463
1464 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
1465 tw = cur;
1466 tw = tw_next(tw);
1467get_tw:
1468 while (tw && tw->tw_family != st->family) {
1469 tw = tw_next(tw);
1470 }
1471 if (tw) {
1472 cur = tw;
1473 goto out;
1474 }
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001475 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 st->state = TCP_SEQ_STATE_ESTABLISHED;
1477
1478 /* We can reschedule between buckets: */
1479 cond_resched_softirq();
1480
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001481 if (++st->bucket < tcp_hashinfo.ehash_size) {
1482 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
1483 sk = sk_head(&tcp_hashinfo.ehash[st->bucket].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 } else {
1485 cur = NULL;
1486 goto out;
1487 }
1488 } else
1489 sk = sk_next(sk);
1490
1491 sk_for_each_from(sk, node) {
1492 if (sk->sk_family == st->family)
1493 goto found;
1494 }
1495
1496 st->state = TCP_SEQ_STATE_TIME_WAIT;
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001497 tw = tw_head(&tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 goto get_tw;
1499found:
1500 cur = sk;
1501out:
1502 return cur;
1503}
1504
1505static void *established_get_idx(struct seq_file *seq, loff_t pos)
1506{
1507 void *rc = established_get_first(seq);
1508
1509 while (rc && pos) {
1510 rc = established_get_next(seq, rc);
1511 --pos;
1512 }
1513 return rc;
1514}
1515
1516static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
1517{
1518 void *rc;
1519 struct tcp_iter_state* st = seq->private;
1520
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -07001521 inet_listen_lock(&tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 st->state = TCP_SEQ_STATE_LISTENING;
1523 rc = listening_get_idx(seq, &pos);
1524
1525 if (!rc) {
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -07001526 inet_listen_unlock(&tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 local_bh_disable();
1528 st->state = TCP_SEQ_STATE_ESTABLISHED;
1529 rc = established_get_idx(seq, pos);
1530 }
1531
1532 return rc;
1533}
1534
1535static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
1536{
1537 struct tcp_iter_state* st = seq->private;
1538 st->state = TCP_SEQ_STATE_LISTENING;
1539 st->num = 0;
1540 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
1541}
1542
1543static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1544{
1545 void *rc = NULL;
1546 struct tcp_iter_state* st;
1547
1548 if (v == SEQ_START_TOKEN) {
1549 rc = tcp_get_idx(seq, 0);
1550 goto out;
1551 }
1552 st = seq->private;
1553
1554 switch (st->state) {
1555 case TCP_SEQ_STATE_OPENREQ:
1556 case TCP_SEQ_STATE_LISTENING:
1557 rc = listening_get_next(seq, v);
1558 if (!rc) {
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -07001559 inet_listen_unlock(&tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560 local_bh_disable();
1561 st->state = TCP_SEQ_STATE_ESTABLISHED;
1562 rc = established_get_first(seq);
1563 }
1564 break;
1565 case TCP_SEQ_STATE_ESTABLISHED:
1566 case TCP_SEQ_STATE_TIME_WAIT:
1567 rc = established_get_next(seq, v);
1568 break;
1569 }
1570out:
1571 ++*pos;
1572 return rc;
1573}
1574
1575static void tcp_seq_stop(struct seq_file *seq, void *v)
1576{
1577 struct tcp_iter_state* st = seq->private;
1578
1579 switch (st->state) {
1580 case TCP_SEQ_STATE_OPENREQ:
1581 if (v) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001582 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
1583 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 }
1585 case TCP_SEQ_STATE_LISTENING:
1586 if (v != SEQ_START_TOKEN)
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -07001587 inet_listen_unlock(&tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 break;
1589 case TCP_SEQ_STATE_TIME_WAIT:
1590 case TCP_SEQ_STATE_ESTABLISHED:
1591 if (v)
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001592 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 local_bh_enable();
1594 break;
1595 }
1596}
1597
1598static int tcp_seq_open(struct inode *inode, struct file *file)
1599{
1600 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
1601 struct seq_file *seq;
1602 struct tcp_iter_state *s;
1603 int rc;
1604
1605 if (unlikely(afinfo == NULL))
1606 return -EINVAL;
1607
1608 s = kmalloc(sizeof(*s), GFP_KERNEL);
1609 if (!s)
1610 return -ENOMEM;
1611 memset(s, 0, sizeof(*s));
1612 s->family = afinfo->family;
1613 s->seq_ops.start = tcp_seq_start;
1614 s->seq_ops.next = tcp_seq_next;
1615 s->seq_ops.show = afinfo->seq_show;
1616 s->seq_ops.stop = tcp_seq_stop;
1617
1618 rc = seq_open(file, &s->seq_ops);
1619 if (rc)
1620 goto out_kfree;
1621 seq = file->private_data;
1622 seq->private = s;
1623out:
1624 return rc;
1625out_kfree:
1626 kfree(s);
1627 goto out;
1628}
1629
1630int tcp_proc_register(struct tcp_seq_afinfo *afinfo)
1631{
1632 int rc = 0;
1633 struct proc_dir_entry *p;
1634
1635 if (!afinfo)
1636 return -EINVAL;
1637 afinfo->seq_fops->owner = afinfo->owner;
1638 afinfo->seq_fops->open = tcp_seq_open;
1639 afinfo->seq_fops->read = seq_read;
1640 afinfo->seq_fops->llseek = seq_lseek;
1641 afinfo->seq_fops->release = seq_release_private;
1642
1643 p = proc_net_fops_create(afinfo->name, S_IRUGO, afinfo->seq_fops);
1644 if (p)
1645 p->data = afinfo;
1646 else
1647 rc = -ENOMEM;
1648 return rc;
1649}
1650
1651void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo)
1652{
1653 if (!afinfo)
1654 return;
1655 proc_net_remove(afinfo->name);
1656 memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops));
1657}
1658
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001659static void get_openreq4(struct sock *sk, struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 char *tmpbuf, int i, int uid)
1661{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001662 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 int ttd = req->expires - jiffies;
1664
1665 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
1666 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p",
1667 i,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001668 ireq->loc_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 ntohs(inet_sk(sk)->sport),
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001670 ireq->rmt_addr,
1671 ntohs(ireq->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 TCP_SYN_RECV,
1673 0, 0, /* could print option size, but that is af dependent. */
1674 1, /* timers active (only the expire timer) */
1675 jiffies_to_clock_t(ttd),
1676 req->retrans,
1677 uid,
1678 0, /* non standard timer */
1679 0, /* open_requests have no inode */
1680 atomic_read(&sk->sk_refcnt),
1681 req);
1682}
1683
1684static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i)
1685{
1686 int timer_active;
1687 unsigned long timer_expires;
1688 struct tcp_sock *tp = tcp_sk(sp);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001689 const struct inet_connection_sock *icsk = inet_csk(sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 struct inet_sock *inet = inet_sk(sp);
1691 unsigned int dest = inet->daddr;
1692 unsigned int src = inet->rcv_saddr;
1693 __u16 destp = ntohs(inet->dport);
1694 __u16 srcp = ntohs(inet->sport);
1695
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001696 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001698 timer_expires = icsk->icsk_timeout;
1699 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001701 timer_expires = icsk->icsk_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702 } else if (timer_pending(&sp->sk_timer)) {
1703 timer_active = 2;
1704 timer_expires = sp->sk_timer.expires;
1705 } else {
1706 timer_active = 0;
1707 timer_expires = jiffies;
1708 }
1709
1710 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
1711 "%08X %5d %8d %lu %d %p %u %u %u %u %d",
1712 i, src, srcp, dest, destp, sp->sk_state,
1713 tp->write_seq - tp->snd_una, tp->rcv_nxt - tp->copied_seq,
1714 timer_active,
1715 jiffies_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001716 icsk->icsk_retransmits,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 sock_i_uid(sp),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001718 icsk->icsk_probes_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 sock_i_ino(sp),
1720 atomic_read(&sp->sk_refcnt), sp,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001721 icsk->icsk_rto,
1722 icsk->icsk_ack.ato,
1723 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 tp->snd_cwnd,
1725 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh);
1726}
1727
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001728static void get_timewait4_sock(struct inet_timewait_sock *tw, char *tmpbuf, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729{
1730 unsigned int dest, src;
1731 __u16 destp, srcp;
1732 int ttd = tw->tw_ttd - jiffies;
1733
1734 if (ttd < 0)
1735 ttd = 0;
1736
1737 dest = tw->tw_daddr;
1738 src = tw->tw_rcv_saddr;
1739 destp = ntohs(tw->tw_dport);
1740 srcp = ntohs(tw->tw_sport);
1741
1742 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
1743 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p",
1744 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
1745 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
1746 atomic_read(&tw->tw_refcnt), tw);
1747}
1748
1749#define TMPSZ 150
1750
1751static int tcp4_seq_show(struct seq_file *seq, void *v)
1752{
1753 struct tcp_iter_state* st;
1754 char tmpbuf[TMPSZ + 1];
1755
1756 if (v == SEQ_START_TOKEN) {
1757 seq_printf(seq, "%-*s\n", TMPSZ - 1,
1758 " sl local_address rem_address st tx_queue "
1759 "rx_queue tr tm->when retrnsmt uid timeout "
1760 "inode");
1761 goto out;
1762 }
1763 st = seq->private;
1764
1765 switch (st->state) {
1766 case TCP_SEQ_STATE_LISTENING:
1767 case TCP_SEQ_STATE_ESTABLISHED:
1768 get_tcp4_sock(v, tmpbuf, st->num);
1769 break;
1770 case TCP_SEQ_STATE_OPENREQ:
1771 get_openreq4(st->syn_wait_sk, v, tmpbuf, st->num, st->uid);
1772 break;
1773 case TCP_SEQ_STATE_TIME_WAIT:
1774 get_timewait4_sock(v, tmpbuf, st->num);
1775 break;
1776 }
1777 seq_printf(seq, "%-*s\n", TMPSZ - 1, tmpbuf);
1778out:
1779 return 0;
1780}
1781
1782static struct file_operations tcp4_seq_fops;
1783static struct tcp_seq_afinfo tcp4_seq_afinfo = {
1784 .owner = THIS_MODULE,
1785 .name = "tcp",
1786 .family = AF_INET,
1787 .seq_show = tcp4_seq_show,
1788 .seq_fops = &tcp4_seq_fops,
1789};
1790
1791int __init tcp4_proc_init(void)
1792{
1793 return tcp_proc_register(&tcp4_seq_afinfo);
1794}
1795
1796void tcp4_proc_exit(void)
1797{
1798 tcp_proc_unregister(&tcp4_seq_afinfo);
1799}
1800#endif /* CONFIG_PROC_FS */
1801
1802struct proto tcp_prot = {
1803 .name = "TCP",
1804 .owner = THIS_MODULE,
1805 .close = tcp_close,
1806 .connect = tcp_v4_connect,
1807 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001808 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809 .ioctl = tcp_ioctl,
1810 .init = tcp_v4_init_sock,
1811 .destroy = tcp_v4_destroy_sock,
1812 .shutdown = tcp_shutdown,
1813 .setsockopt = tcp_setsockopt,
1814 .getsockopt = tcp_getsockopt,
1815 .sendmsg = tcp_sendmsg,
1816 .recvmsg = tcp_recvmsg,
1817 .backlog_rcv = tcp_v4_do_rcv,
1818 .hash = tcp_v4_hash,
1819 .unhash = tcp_unhash,
1820 .get_port = tcp_v4_get_port,
1821 .enter_memory_pressure = tcp_enter_memory_pressure,
1822 .sockets_allocated = &tcp_sockets_allocated,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07001823 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 .memory_allocated = &tcp_memory_allocated,
1825 .memory_pressure = &tcp_memory_pressure,
1826 .sysctl_mem = sysctl_tcp_mem,
1827 .sysctl_wmem = sysctl_tcp_wmem,
1828 .sysctl_rmem = sysctl_tcp_rmem,
1829 .max_header = MAX_TCP_HEADER,
1830 .obj_size = sizeof(struct tcp_sock),
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001831 .twsk_prot = &tcp_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001832 .rsk_prot = &tcp_request_sock_ops,
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001833#ifdef CONFIG_COMPAT
1834 .compat_setsockopt = compat_tcp_setsockopt,
1835 .compat_getsockopt = compat_tcp_getsockopt,
1836#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837};
1838
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839void __init tcp_v4_init(struct net_proto_family *ops)
1840{
Arnaldo Carvalho de Meloc4d93902006-03-20 22:01:03 -08001841 if (inet_csk_ctl_sock_create(&tcp_socket, PF_INET, SOCK_RAW, IPPROTO_TCP) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 panic("Failed to create the TCP control socket.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843}
1844
1845EXPORT_SYMBOL(ipv4_specific);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846EXPORT_SYMBOL(tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847EXPORT_SYMBOL(tcp_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848EXPORT_SYMBOL(tcp_unhash);
1849EXPORT_SYMBOL(tcp_v4_conn_request);
1850EXPORT_SYMBOL(tcp_v4_connect);
1851EXPORT_SYMBOL(tcp_v4_do_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852EXPORT_SYMBOL(tcp_v4_remember_stamp);
1853EXPORT_SYMBOL(tcp_v4_send_check);
1854EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
1855
1856#ifdef CONFIG_PROC_FS
1857EXPORT_SYMBOL(tcp_proc_register);
1858EXPORT_SYMBOL(tcp_proc_unregister);
1859#endif
1860EXPORT_SYMBOL(sysctl_local_port_range);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861EXPORT_SYMBOL(sysctl_tcp_low_latency);
1862EXPORT_SYMBOL(sysctl_tcp_tw_reuse);
1863