blob: 6ea353907af5757de1abc84e6b87274afa4d26fe [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
239 err = ip_route_newports(&rt, inet->sport, inet->dport, sk);
240 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
903 tcp_sync_mss(newsk, dst_mtu(dst));
904 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
905 tcp_initialize_rcv_mss(newsk);
906
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -0700907 __inet_hash(&tcp_hashinfo, newsk, 0);
Arnaldo Carvalho de Melo2d8c4ce2005-08-09 20:07:13 -0700908 __inet_inherit_port(&tcp_hashinfo, sk, newsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909
910 return newsk;
911
912exit_overflow:
913 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
914exit:
915 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
916 dst_release(dst);
917 return NULL;
918}
919
920static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
921{
922 struct tcphdr *th = skb->h.th;
923 struct iphdr *iph = skb->nh.iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 struct sock *nsk;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700925 struct request_sock **prev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 /* Find possible connection requests. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700927 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
928 iph->saddr, iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 if (req)
930 return tcp_check_req(sk, skb, req, prev);
931
Arnaldo Carvalho de Meloe48c4142005-08-09 20:09:46 -0700932 nsk = __inet_lookup_established(&tcp_hashinfo, skb->nh.iph->saddr,
933 th->source, skb->nh.iph->daddr,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700934 ntohs(th->dest), inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935
936 if (nsk) {
937 if (nsk->sk_state != TCP_TIME_WAIT) {
938 bh_lock_sock(nsk);
939 return nsk;
940 }
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -0700941 inet_twsk_put((struct inet_timewait_sock *)nsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 return NULL;
943 }
944
945#ifdef CONFIG_SYN_COOKIES
946 if (!th->rst && !th->syn && th->ack)
947 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
948#endif
949 return sk;
950}
951
952static int tcp_v4_checksum_init(struct sk_buff *skb)
953{
954 if (skb->ip_summed == CHECKSUM_HW) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 if (!tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
Herbert Xufb286bb2005-11-10 13:01:24 -0800956 skb->nh.iph->daddr, skb->csum)) {
957 skb->ip_summed = CHECKSUM_UNNECESSARY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 return 0;
Herbert Xufb286bb2005-11-10 13:01:24 -0800959 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 }
Herbert Xufb286bb2005-11-10 13:01:24 -0800961
962 skb->csum = csum_tcpudp_nofold(skb->nh.iph->saddr, skb->nh.iph->daddr,
963 skb->len, IPPROTO_TCP, 0);
964
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 if (skb->len <= 76) {
Herbert Xufb286bb2005-11-10 13:01:24 -0800966 return __skb_checksum_complete(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 }
968 return 0;
969}
970
971
972/* The socket must have it's spinlock held when we get
973 * here.
974 *
975 * We have a potential double-lock case here, so even when
976 * doing backlog processing we use the BH locking scheme.
977 * This is because we cannot sleep with the original spinlock
978 * held.
979 */
980int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
981{
982 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
983 TCP_CHECK_TIMER(sk);
984 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len))
985 goto reset;
986 TCP_CHECK_TIMER(sk);
987 return 0;
988 }
989
990 if (skb->len < (skb->h.th->doff << 2) || tcp_checksum_complete(skb))
991 goto csum_err;
992
993 if (sk->sk_state == TCP_LISTEN) {
994 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
995 if (!nsk)
996 goto discard;
997
998 if (nsk != sk) {
999 if (tcp_child_process(sk, nsk, skb))
1000 goto reset;
1001 return 0;
1002 }
1003 }
1004
1005 TCP_CHECK_TIMER(sk);
1006 if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len))
1007 goto reset;
1008 TCP_CHECK_TIMER(sk);
1009 return 0;
1010
1011reset:
1012 tcp_v4_send_reset(skb);
1013discard:
1014 kfree_skb(skb);
1015 /* Be careful here. If this function gets more complicated and
1016 * gcc suffers from register pressure on the x86, sk (in %ebx)
1017 * might be destroyed here. This current version compiles correctly,
1018 * but you have been warned.
1019 */
1020 return 0;
1021
1022csum_err:
1023 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1024 goto discard;
1025}
1026
1027/*
1028 * From tcp_input.c
1029 */
1030
1031int tcp_v4_rcv(struct sk_buff *skb)
1032{
1033 struct tcphdr *th;
1034 struct sock *sk;
1035 int ret;
1036
1037 if (skb->pkt_type != PACKET_HOST)
1038 goto discard_it;
1039
1040 /* Count it even if it's bad */
1041 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1042
1043 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1044 goto discard_it;
1045
1046 th = skb->h.th;
1047
1048 if (th->doff < sizeof(struct tcphdr) / 4)
1049 goto bad_packet;
1050 if (!pskb_may_pull(skb, th->doff * 4))
1051 goto discard_it;
1052
1053 /* An explanation is required here, I think.
1054 * Packet length and doff are validated by header prediction,
Stephen Hemmingercaa20d9a2005-11-10 17:13:47 -08001055 * provided case of th->doff==0 is eliminated.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 * So, we defer the checks. */
1057 if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
Herbert Xufb286bb2005-11-10 13:01:24 -08001058 tcp_v4_checksum_init(skb)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 goto bad_packet;
1060
1061 th = skb->h.th;
1062 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1063 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1064 skb->len - th->doff * 4);
1065 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1066 TCP_SKB_CB(skb)->when = 0;
1067 TCP_SKB_CB(skb)->flags = skb->nh.iph->tos;
1068 TCP_SKB_CB(skb)->sacked = 0;
1069
Arnaldo Carvalho de Meloe48c4142005-08-09 20:09:46 -07001070 sk = __inet_lookup(&tcp_hashinfo, skb->nh.iph->saddr, th->source,
1071 skb->nh.iph->daddr, ntohs(th->dest),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001072 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073
1074 if (!sk)
1075 goto no_tcp_socket;
1076
1077process:
1078 if (sk->sk_state == TCP_TIME_WAIT)
1079 goto do_time_wait;
1080
1081 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1082 goto discard_and_relse;
Patrick McHardyb59c2702006-01-06 23:06:10 -08001083 nf_reset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084
1085 if (sk_filter(sk, skb, 0))
1086 goto discard_and_relse;
1087
1088 skb->dev = NULL;
1089
1090 bh_lock_sock(sk);
1091 ret = 0;
1092 if (!sock_owned_by_user(sk)) {
1093 if (!tcp_prequeue(sk, skb))
1094 ret = tcp_v4_do_rcv(sk, skb);
1095 } else
1096 sk_add_backlog(sk, skb);
1097 bh_unlock_sock(sk);
1098
1099 sock_put(sk);
1100
1101 return ret;
1102
1103no_tcp_socket:
1104 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1105 goto discard_it;
1106
1107 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1108bad_packet:
1109 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1110 } else {
1111 tcp_v4_send_reset(skb);
1112 }
1113
1114discard_it:
1115 /* Discard frame. */
1116 kfree_skb(skb);
1117 return 0;
1118
1119discard_and_relse:
1120 sock_put(sk);
1121 goto discard_it;
1122
1123do_time_wait:
1124 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001125 inet_twsk_put((struct inet_timewait_sock *) sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 goto discard_it;
1127 }
1128
1129 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1130 TCP_INC_STATS_BH(TCP_MIB_INERRS);
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001131 inet_twsk_put((struct inet_timewait_sock *) sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 goto discard_it;
1133 }
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001134 switch (tcp_timewait_state_process((struct inet_timewait_sock *)sk,
1135 skb, th)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 case TCP_TW_SYN: {
Arnaldo Carvalho de Melo33b62232005-08-09 20:09:06 -07001137 struct sock *sk2 = inet_lookup_listener(&tcp_hashinfo,
1138 skb->nh.iph->daddr,
1139 ntohs(th->dest),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001140 inet_iif(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 if (sk2) {
Arnaldo Carvalho de Melo295ff7e2005-08-09 20:44:40 -07001142 inet_twsk_deschedule((struct inet_timewait_sock *)sk,
1143 &tcp_death_row);
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001144 inet_twsk_put((struct inet_timewait_sock *)sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 sk = sk2;
1146 goto process;
1147 }
1148 /* Fall through to ACK */
1149 }
1150 case TCP_TW_ACK:
1151 tcp_v4_timewait_ack(sk, skb);
1152 break;
1153 case TCP_TW_RST:
1154 goto no_tcp_socket;
1155 case TCP_TW_SUCCESS:;
1156 }
1157 goto discard_it;
1158}
1159
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160/* VJ's idea. Save last timestamp seen from this destination
1161 * and hold it at least for normal timewait interval to use for duplicate
1162 * segment detection in subsequent connections, before they enter synchronized
1163 * state.
1164 */
1165
1166int tcp_v4_remember_stamp(struct sock *sk)
1167{
1168 struct inet_sock *inet = inet_sk(sk);
1169 struct tcp_sock *tp = tcp_sk(sk);
1170 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1171 struct inet_peer *peer = NULL;
1172 int release_it = 0;
1173
1174 if (!rt || rt->rt_dst != inet->daddr) {
1175 peer = inet_getpeer(inet->daddr, 1);
1176 release_it = 1;
1177 } else {
1178 if (!rt->peer)
1179 rt_bind_peer(rt, 1);
1180 peer = rt->peer;
1181 }
1182
1183 if (peer) {
1184 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
1185 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1186 peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {
1187 peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;
1188 peer->tcp_ts = tp->rx_opt.ts_recent;
1189 }
1190 if (release_it)
1191 inet_putpeer(peer);
1192 return 1;
1193 }
1194
1195 return 0;
1196}
1197
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001198int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199{
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001200 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201
1202 if (peer) {
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001203 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1204
1205 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001207 peer->tcp_ts_stamp <= tcptw->tw_ts_recent_stamp)) {
1208 peer->tcp_ts_stamp = tcptw->tw_ts_recent_stamp;
1209 peer->tcp_ts = tcptw->tw_ts_recent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 }
1211 inet_putpeer(peer);
1212 return 1;
1213 }
1214
1215 return 0;
1216}
1217
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001218struct inet_connection_sock_af_ops ipv4_specific = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 .queue_xmit = ip_queue_xmit,
1220 .send_check = tcp_v4_send_check,
Arnaldo Carvalho de Melo32519f12005-08-09 19:50:02 -07001221 .rebuild_header = inet_sk_rebuild_header,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 .conn_request = tcp_v4_conn_request,
1223 .syn_recv_sock = tcp_v4_syn_recv_sock,
1224 .remember_stamp = tcp_v4_remember_stamp,
1225 .net_header_len = sizeof(struct iphdr),
1226 .setsockopt = ip_setsockopt,
1227 .getsockopt = ip_getsockopt,
Arnaldo Carvalho de Meloaf05dc92005-12-13 23:16:04 -08001228 .addr2sockaddr = inet_csk_addr2sockaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 .sockaddr_len = sizeof(struct sockaddr_in),
1230};
1231
1232/* NOTE: A lot of things set to zero explicitly by call to
1233 * sk_alloc() so need not be done here.
1234 */
1235static int tcp_v4_init_sock(struct sock *sk)
1236{
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001237 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 struct tcp_sock *tp = tcp_sk(sk);
1239
1240 skb_queue_head_init(&tp->out_of_order_queue);
1241 tcp_init_xmit_timers(sk);
1242 tcp_prequeue_init(tp);
1243
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001244 icsk->icsk_rto = TCP_TIMEOUT_INIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 tp->mdev = TCP_TIMEOUT_INIT;
1246
1247 /* So many TCP implementations out there (incorrectly) count the
1248 * initial SYN frame in their delayed-ACK and congestion control
1249 * algorithms that we must have the following bandaid to talk
1250 * efficiently to them. -DaveM
1251 */
1252 tp->snd_cwnd = 2;
1253
1254 /* See draft-stevens-tcpca-spec-01 for discussion of the
1255 * initialization of these values.
1256 */
1257 tp->snd_ssthresh = 0x7fffffff; /* Infinity */
1258 tp->snd_cwnd_clamp = ~0;
David S. Millerc1b4a7e2005-07-05 15:24:38 -07001259 tp->mss_cache = 536;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
1261 tp->reordering = sysctl_tcp_reordering;
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001262 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263
1264 sk->sk_state = TCP_CLOSE;
1265
1266 sk->sk_write_space = sk_stream_write_space;
1267 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1268
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -08001269 icsk->icsk_af_ops = &ipv4_specific;
Arnaldo Carvalho de Melod83d8462005-12-13 23:26:10 -08001270 icsk->icsk_sync_mss = tcp_sync_mss;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271
1272 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1273 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1274
1275 atomic_inc(&tcp_sockets_allocated);
1276
1277 return 0;
1278}
1279
1280int tcp_v4_destroy_sock(struct sock *sk)
1281{
1282 struct tcp_sock *tp = tcp_sk(sk);
1283
1284 tcp_clear_xmit_timers(sk);
1285
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001286 tcp_cleanup_congestion_control(sk);
Stephen Hemminger317a76f2005-06-23 12:19:55 -07001287
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 /* Cleanup up the write buffer. */
1289 sk_stream_writequeue_purge(sk);
1290
1291 /* Cleans up our, hopefully empty, out_of_order_queue. */
1292 __skb_queue_purge(&tp->out_of_order_queue);
1293
1294 /* Clean prequeue, it must be empty really */
1295 __skb_queue_purge(&tp->ucopy.prequeue);
1296
1297 /* Clean up a referenced TCP bind bucket. */
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001298 if (inet_csk(sk)->icsk_bind_hash)
Arnaldo Carvalho de Melo2d8c4ce2005-08-09 20:07:13 -07001299 inet_put_port(&tcp_hashinfo, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300
1301 /*
1302 * If sendmsg cached page exists, toss it.
1303 */
1304 if (sk->sk_sndmsg_page) {
1305 __free_page(sk->sk_sndmsg_page);
1306 sk->sk_sndmsg_page = NULL;
1307 }
1308
1309 atomic_dec(&tcp_sockets_allocated);
1310
1311 return 0;
1312}
1313
1314EXPORT_SYMBOL(tcp_v4_destroy_sock);
1315
1316#ifdef CONFIG_PROC_FS
1317/* Proc filesystem TCP sock list dumping. */
1318
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001319static inline struct inet_timewait_sock *tw_head(struct hlist_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320{
1321 return hlist_empty(head) ? NULL :
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001322 list_entry(head->first, struct inet_timewait_sock, tw_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323}
1324
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001325static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326{
1327 return tw->tw_node.next ?
1328 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
1329}
1330
1331static void *listening_get_next(struct seq_file *seq, void *cur)
1332{
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001333 struct inet_connection_sock *icsk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 struct hlist_node *node;
1335 struct sock *sk = cur;
1336 struct tcp_iter_state* st = seq->private;
1337
1338 if (!sk) {
1339 st->bucket = 0;
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001340 sk = sk_head(&tcp_hashinfo.listening_hash[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 goto get_sk;
1342 }
1343
1344 ++st->num;
1345
1346 if (st->state == TCP_SEQ_STATE_OPENREQ) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001347 struct request_sock *req = cur;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001349 icsk = inet_csk(st->syn_wait_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 req = req->dl_next;
1351 while (1) {
1352 while (req) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001353 if (req->rsk_ops->family == st->family) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 cur = req;
1355 goto out;
1356 }
1357 req = req->dl_next;
1358 }
1359 if (++st->sbucket >= TCP_SYNQ_HSIZE)
1360 break;
1361get_req:
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001362 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 }
1364 sk = sk_next(st->syn_wait_sk);
1365 st->state = TCP_SEQ_STATE_LISTENING;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001366 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 } else {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001368 icsk = inet_csk(sk);
1369 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1370 if (reqsk_queue_len(&icsk->icsk_accept_queue))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 goto start_req;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001372 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 sk = sk_next(sk);
1374 }
1375get_sk:
1376 sk_for_each_from(sk, node) {
1377 if (sk->sk_family == st->family) {
1378 cur = sk;
1379 goto out;
1380 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001381 icsk = inet_csk(sk);
1382 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1383 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384start_req:
1385 st->uid = sock_i_uid(sk);
1386 st->syn_wait_sk = sk;
1387 st->state = TCP_SEQ_STATE_OPENREQ;
1388 st->sbucket = 0;
1389 goto get_req;
1390 }
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001391 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 }
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -07001393 if (++st->bucket < INET_LHTABLE_SIZE) {
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001394 sk = sk_head(&tcp_hashinfo.listening_hash[st->bucket]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 goto get_sk;
1396 }
1397 cur = NULL;
1398out:
1399 return cur;
1400}
1401
1402static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
1403{
1404 void *rc = listening_get_next(seq, NULL);
1405
1406 while (rc && *pos) {
1407 rc = listening_get_next(seq, rc);
1408 --*pos;
1409 }
1410 return rc;
1411}
1412
1413static void *established_get_first(struct seq_file *seq)
1414{
1415 struct tcp_iter_state* st = seq->private;
1416 void *rc = NULL;
1417
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001418 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 struct sock *sk;
1420 struct hlist_node *node;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001421 struct inet_timewait_sock *tw;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422
1423 /* We can reschedule _before_ having picked the target: */
1424 cond_resched_softirq();
1425
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001426 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
1427 sk_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 if (sk->sk_family != st->family) {
1429 continue;
1430 }
1431 rc = sk;
1432 goto out;
1433 }
1434 st->state = TCP_SEQ_STATE_TIME_WAIT;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001435 inet_twsk_for_each(tw, node,
1436 &tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 if (tw->tw_family != st->family) {
1438 continue;
1439 }
1440 rc = tw;
1441 goto out;
1442 }
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001443 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 st->state = TCP_SEQ_STATE_ESTABLISHED;
1445 }
1446out:
1447 return rc;
1448}
1449
1450static void *established_get_next(struct seq_file *seq, void *cur)
1451{
1452 struct sock *sk = cur;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001453 struct inet_timewait_sock *tw;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 struct hlist_node *node;
1455 struct tcp_iter_state* st = seq->private;
1456
1457 ++st->num;
1458
1459 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
1460 tw = cur;
1461 tw = tw_next(tw);
1462get_tw:
1463 while (tw && tw->tw_family != st->family) {
1464 tw = tw_next(tw);
1465 }
1466 if (tw) {
1467 cur = tw;
1468 goto out;
1469 }
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001470 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 st->state = TCP_SEQ_STATE_ESTABLISHED;
1472
1473 /* We can reschedule between buckets: */
1474 cond_resched_softirq();
1475
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001476 if (++st->bucket < tcp_hashinfo.ehash_size) {
1477 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
1478 sk = sk_head(&tcp_hashinfo.ehash[st->bucket].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 } else {
1480 cur = NULL;
1481 goto out;
1482 }
1483 } else
1484 sk = sk_next(sk);
1485
1486 sk_for_each_from(sk, node) {
1487 if (sk->sk_family == st->family)
1488 goto found;
1489 }
1490
1491 st->state = TCP_SEQ_STATE_TIME_WAIT;
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001492 tw = tw_head(&tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 goto get_tw;
1494found:
1495 cur = sk;
1496out:
1497 return cur;
1498}
1499
1500static void *established_get_idx(struct seq_file *seq, loff_t pos)
1501{
1502 void *rc = established_get_first(seq);
1503
1504 while (rc && pos) {
1505 rc = established_get_next(seq, rc);
1506 --pos;
1507 }
1508 return rc;
1509}
1510
1511static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
1512{
1513 void *rc;
1514 struct tcp_iter_state* st = seq->private;
1515
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -07001516 inet_listen_lock(&tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 st->state = TCP_SEQ_STATE_LISTENING;
1518 rc = listening_get_idx(seq, &pos);
1519
1520 if (!rc) {
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -07001521 inet_listen_unlock(&tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 local_bh_disable();
1523 st->state = TCP_SEQ_STATE_ESTABLISHED;
1524 rc = established_get_idx(seq, pos);
1525 }
1526
1527 return rc;
1528}
1529
1530static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
1531{
1532 struct tcp_iter_state* st = seq->private;
1533 st->state = TCP_SEQ_STATE_LISTENING;
1534 st->num = 0;
1535 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
1536}
1537
1538static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1539{
1540 void *rc = NULL;
1541 struct tcp_iter_state* st;
1542
1543 if (v == SEQ_START_TOKEN) {
1544 rc = tcp_get_idx(seq, 0);
1545 goto out;
1546 }
1547 st = seq->private;
1548
1549 switch (st->state) {
1550 case TCP_SEQ_STATE_OPENREQ:
1551 case TCP_SEQ_STATE_LISTENING:
1552 rc = listening_get_next(seq, v);
1553 if (!rc) {
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -07001554 inet_listen_unlock(&tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 local_bh_disable();
1556 st->state = TCP_SEQ_STATE_ESTABLISHED;
1557 rc = established_get_first(seq);
1558 }
1559 break;
1560 case TCP_SEQ_STATE_ESTABLISHED:
1561 case TCP_SEQ_STATE_TIME_WAIT:
1562 rc = established_get_next(seq, v);
1563 break;
1564 }
1565out:
1566 ++*pos;
1567 return rc;
1568}
1569
1570static void tcp_seq_stop(struct seq_file *seq, void *v)
1571{
1572 struct tcp_iter_state* st = seq->private;
1573
1574 switch (st->state) {
1575 case TCP_SEQ_STATE_OPENREQ:
1576 if (v) {
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001577 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
1578 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 }
1580 case TCP_SEQ_STATE_LISTENING:
1581 if (v != SEQ_START_TOKEN)
Arnaldo Carvalho de Melof3f05f72005-08-09 20:08:09 -07001582 inet_listen_unlock(&tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 break;
1584 case TCP_SEQ_STATE_TIME_WAIT:
1585 case TCP_SEQ_STATE_ESTABLISHED:
1586 if (v)
Arnaldo Carvalho de Melo6e04e022005-08-09 20:07:35 -07001587 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 local_bh_enable();
1589 break;
1590 }
1591}
1592
1593static int tcp_seq_open(struct inode *inode, struct file *file)
1594{
1595 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
1596 struct seq_file *seq;
1597 struct tcp_iter_state *s;
1598 int rc;
1599
1600 if (unlikely(afinfo == NULL))
1601 return -EINVAL;
1602
1603 s = kmalloc(sizeof(*s), GFP_KERNEL);
1604 if (!s)
1605 return -ENOMEM;
1606 memset(s, 0, sizeof(*s));
1607 s->family = afinfo->family;
1608 s->seq_ops.start = tcp_seq_start;
1609 s->seq_ops.next = tcp_seq_next;
1610 s->seq_ops.show = afinfo->seq_show;
1611 s->seq_ops.stop = tcp_seq_stop;
1612
1613 rc = seq_open(file, &s->seq_ops);
1614 if (rc)
1615 goto out_kfree;
1616 seq = file->private_data;
1617 seq->private = s;
1618out:
1619 return rc;
1620out_kfree:
1621 kfree(s);
1622 goto out;
1623}
1624
1625int tcp_proc_register(struct tcp_seq_afinfo *afinfo)
1626{
1627 int rc = 0;
1628 struct proc_dir_entry *p;
1629
1630 if (!afinfo)
1631 return -EINVAL;
1632 afinfo->seq_fops->owner = afinfo->owner;
1633 afinfo->seq_fops->open = tcp_seq_open;
1634 afinfo->seq_fops->read = seq_read;
1635 afinfo->seq_fops->llseek = seq_lseek;
1636 afinfo->seq_fops->release = seq_release_private;
1637
1638 p = proc_net_fops_create(afinfo->name, S_IRUGO, afinfo->seq_fops);
1639 if (p)
1640 p->data = afinfo;
1641 else
1642 rc = -ENOMEM;
1643 return rc;
1644}
1645
1646void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo)
1647{
1648 if (!afinfo)
1649 return;
1650 proc_net_remove(afinfo->name);
1651 memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops));
1652}
1653
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001654static void get_openreq4(struct sock *sk, struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 char *tmpbuf, int i, int uid)
1656{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001657 const struct inet_request_sock *ireq = inet_rsk(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 int ttd = req->expires - jiffies;
1659
1660 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
1661 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p",
1662 i,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001663 ireq->loc_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 ntohs(inet_sk(sk)->sport),
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07001665 ireq->rmt_addr,
1666 ntohs(ireq->rmt_port),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 TCP_SYN_RECV,
1668 0, 0, /* could print option size, but that is af dependent. */
1669 1, /* timers active (only the expire timer) */
1670 jiffies_to_clock_t(ttd),
1671 req->retrans,
1672 uid,
1673 0, /* non standard timer */
1674 0, /* open_requests have no inode */
1675 atomic_read(&sk->sk_refcnt),
1676 req);
1677}
1678
1679static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i)
1680{
1681 int timer_active;
1682 unsigned long timer_expires;
1683 struct tcp_sock *tp = tcp_sk(sp);
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001684 const struct inet_connection_sock *icsk = inet_csk(sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 struct inet_sock *inet = inet_sk(sp);
1686 unsigned int dest = inet->daddr;
1687 unsigned int src = inet->rcv_saddr;
1688 __u16 destp = ntohs(inet->dport);
1689 __u16 srcp = ntohs(inet->sport);
1690
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001691 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 timer_active = 1;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001693 timer_expires = icsk->icsk_timeout;
1694 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 timer_active = 4;
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001696 timer_expires = icsk->icsk_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 } else if (timer_pending(&sp->sk_timer)) {
1698 timer_active = 2;
1699 timer_expires = sp->sk_timer.expires;
1700 } else {
1701 timer_active = 0;
1702 timer_expires = jiffies;
1703 }
1704
1705 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
1706 "%08X %5d %8d %lu %d %p %u %u %u %u %d",
1707 i, src, srcp, dest, destp, sp->sk_state,
1708 tp->write_seq - tp->snd_una, tp->rcv_nxt - tp->copied_seq,
1709 timer_active,
1710 jiffies_to_clock_t(timer_expires - jiffies),
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001711 icsk->icsk_retransmits,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 sock_i_uid(sp),
Arnaldo Carvalho de Melo6687e982005-08-10 04:03:31 -03001713 icsk->icsk_probes_out,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 sock_i_ino(sp),
1715 atomic_read(&sp->sk_refcnt), sp,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001716 icsk->icsk_rto,
1717 icsk->icsk_ack.ato,
1718 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 tp->snd_cwnd,
1720 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh);
1721}
1722
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07001723static void get_timewait4_sock(struct inet_timewait_sock *tw, char *tmpbuf, int i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724{
1725 unsigned int dest, src;
1726 __u16 destp, srcp;
1727 int ttd = tw->tw_ttd - jiffies;
1728
1729 if (ttd < 0)
1730 ttd = 0;
1731
1732 dest = tw->tw_daddr;
1733 src = tw->tw_rcv_saddr;
1734 destp = ntohs(tw->tw_dport);
1735 srcp = ntohs(tw->tw_sport);
1736
1737 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
1738 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p",
1739 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
1740 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
1741 atomic_read(&tw->tw_refcnt), tw);
1742}
1743
1744#define TMPSZ 150
1745
1746static int tcp4_seq_show(struct seq_file *seq, void *v)
1747{
1748 struct tcp_iter_state* st;
1749 char tmpbuf[TMPSZ + 1];
1750
1751 if (v == SEQ_START_TOKEN) {
1752 seq_printf(seq, "%-*s\n", TMPSZ - 1,
1753 " sl local_address rem_address st tx_queue "
1754 "rx_queue tr tm->when retrnsmt uid timeout "
1755 "inode");
1756 goto out;
1757 }
1758 st = seq->private;
1759
1760 switch (st->state) {
1761 case TCP_SEQ_STATE_LISTENING:
1762 case TCP_SEQ_STATE_ESTABLISHED:
1763 get_tcp4_sock(v, tmpbuf, st->num);
1764 break;
1765 case TCP_SEQ_STATE_OPENREQ:
1766 get_openreq4(st->syn_wait_sk, v, tmpbuf, st->num, st->uid);
1767 break;
1768 case TCP_SEQ_STATE_TIME_WAIT:
1769 get_timewait4_sock(v, tmpbuf, st->num);
1770 break;
1771 }
1772 seq_printf(seq, "%-*s\n", TMPSZ - 1, tmpbuf);
1773out:
1774 return 0;
1775}
1776
1777static struct file_operations tcp4_seq_fops;
1778static struct tcp_seq_afinfo tcp4_seq_afinfo = {
1779 .owner = THIS_MODULE,
1780 .name = "tcp",
1781 .family = AF_INET,
1782 .seq_show = tcp4_seq_show,
1783 .seq_fops = &tcp4_seq_fops,
1784};
1785
1786int __init tcp4_proc_init(void)
1787{
1788 return tcp_proc_register(&tcp4_seq_afinfo);
1789}
1790
1791void tcp4_proc_exit(void)
1792{
1793 tcp_proc_unregister(&tcp4_seq_afinfo);
1794}
1795#endif /* CONFIG_PROC_FS */
1796
1797struct proto tcp_prot = {
1798 .name = "TCP",
1799 .owner = THIS_MODULE,
1800 .close = tcp_close,
1801 .connect = tcp_v4_connect,
1802 .disconnect = tcp_disconnect,
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -07001803 .accept = inet_csk_accept,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 .ioctl = tcp_ioctl,
1805 .init = tcp_v4_init_sock,
1806 .destroy = tcp_v4_destroy_sock,
1807 .shutdown = tcp_shutdown,
1808 .setsockopt = tcp_setsockopt,
1809 .getsockopt = tcp_getsockopt,
1810 .sendmsg = tcp_sendmsg,
1811 .recvmsg = tcp_recvmsg,
1812 .backlog_rcv = tcp_v4_do_rcv,
1813 .hash = tcp_v4_hash,
1814 .unhash = tcp_unhash,
1815 .get_port = tcp_v4_get_port,
1816 .enter_memory_pressure = tcp_enter_memory_pressure,
1817 .sockets_allocated = &tcp_sockets_allocated,
Arnaldo Carvalho de Melo0a5578c2005-08-09 20:11:41 -07001818 .orphan_count = &tcp_orphan_count,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819 .memory_allocated = &tcp_memory_allocated,
1820 .memory_pressure = &tcp_memory_pressure,
1821 .sysctl_mem = sysctl_tcp_mem,
1822 .sysctl_wmem = sysctl_tcp_wmem,
1823 .sysctl_rmem = sysctl_tcp_rmem,
1824 .max_header = MAX_TCP_HEADER,
1825 .obj_size = sizeof(struct tcp_sock),
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08001826 .twsk_prot = &tcp_timewait_sock_ops,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -07001827 .rsk_prot = &tcp_request_sock_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828};
1829
1830
1831
1832void __init tcp_v4_init(struct net_proto_family *ops)
1833{
1834 int err = sock_create_kern(PF_INET, SOCK_RAW, IPPROTO_TCP, &tcp_socket);
1835 if (err < 0)
1836 panic("Failed to create the TCP control socket.\n");
1837 tcp_socket->sk->sk_allocation = GFP_ATOMIC;
1838 inet_sk(tcp_socket->sk)->uc_ttl = -1;
1839
1840 /* Unhash it so that IP input processing does not even
1841 * see it, we do not wish this socket to see incoming
1842 * packets.
1843 */
1844 tcp_socket->sk->sk_prot->unhash(tcp_socket->sk);
1845}
1846
1847EXPORT_SYMBOL(ipv4_specific);
Arnaldo Carvalho de Melo0f7ff922005-08-09 19:59:44 -07001848EXPORT_SYMBOL(inet_bind_bucket_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849EXPORT_SYMBOL(tcp_hashinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850EXPORT_SYMBOL(tcp_prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851EXPORT_SYMBOL(tcp_unhash);
1852EXPORT_SYMBOL(tcp_v4_conn_request);
1853EXPORT_SYMBOL(tcp_v4_connect);
1854EXPORT_SYMBOL(tcp_v4_do_rcv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855EXPORT_SYMBOL(tcp_v4_remember_stamp);
1856EXPORT_SYMBOL(tcp_v4_send_check);
1857EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
1858
1859#ifdef CONFIG_PROC_FS
1860EXPORT_SYMBOL(tcp_proc_register);
1861EXPORT_SYMBOL(tcp_proc_unregister);
1862#endif
1863EXPORT_SYMBOL(sysctl_local_port_range);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864EXPORT_SYMBOL(sysctl_tcp_low_latency);
1865EXPORT_SYMBOL(sysctl_tcp_tw_reuse);
1866