]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - net/ipv4/tcp_ipv4.c
[NETFILTER]: netbios conntrack: fix compile
[mirror_ubuntu-bionic-kernel.git] / net / ipv4 / tcp_ipv4.c
CommitLineData
1da177e4
LT
1/*
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
60236fdd 39 * request_sock handling and moved
1da177e4
LT
40 * most of it into the af independent code.
41 * Added tail drop and some other bugfixes.
caa20d9a 42 * Added new listen semantics.
1da177e4
LT
43 * 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
1da177e4
LT
55
56#include <linux/types.h>
57#include <linux/fcntl.h>
58#include <linux/module.h>
59#include <linux/random.h>
60#include <linux/cache.h>
61#include <linux/jhash.h>
62#include <linux/init.h>
63#include <linux/times.h>
64
65#include <net/icmp.h>
304a1618 66#include <net/inet_hashtables.h>
1da177e4 67#include <net/tcp.h>
20380731 68#include <net/transp_v6.h>
1da177e4
LT
69#include <net/ipv6.h>
70#include <net/inet_common.h>
6d6ee43e 71#include <net/timewait_sock.h>
1da177e4 72#include <net/xfrm.h>
1a2449a8 73#include <net/netdma.h>
1da177e4
LT
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
1da177e4
LT
81int 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
8292a17a 90void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb);
1da177e4 91
0f7ff927 92struct inet_hashinfo __cacheline_aligned tcp_hashinfo = {
e4d91918 93 .lhash_lock = __RW_LOCK_UNLOCKED(tcp_hashinfo.lhash_lock),
0f7ff927
ACM
94 .lhash_users = ATOMIC_INIT(0),
95 .lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(tcp_hashinfo.lhash_wait),
1da177e4
LT
96};
97
463c84b9
ACM
98static int tcp_v4_get_port(struct sock *sk, unsigned short snum)
99{
971af18b
ACM
100 return inet_csk_get_port(&tcp_hashinfo, sk, snum,
101 inet_csk_bind_conflict);
463c84b9
ACM
102}
103
1da177e4
LT
104static void tcp_v4_hash(struct sock *sk)
105{
81849d10 106 inet_hash(&tcp_hashinfo, sk);
1da177e4
LT
107}
108
109void tcp_unhash(struct sock *sk)
110{
81849d10 111 inet_unhash(&tcp_hashinfo, sk);
1da177e4
LT
112}
113
1da177e4
LT
114static 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
6d6ee43e
ACM
122int 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
1da177e4
LT
155/* 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
295ff7ed 205 if (tcp_death_row.sysctl_tw_recycle &&
1da177e4
LT
206 !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
d83d8461 223 inet_csk(sk)->icsk_ext_hdr_len = 0;
1da177e4 224 if (inet->opt)
d83d8461 225 inet_csk(sk)->icsk_ext_hdr_len = inet->opt->optlen;
1da177e4
LT
226
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);
a7f5e7f1 235 err = inet_hash_connect(&tcp_death_row, sk);
1da177e4
LT
236 if (err)
237 goto failure;
238
5d39a795 239 err = ip_route_newports(&rt, IPPROTO_TCP, inet->sport, inet->dport, sk);
1da177e4
LT
240 if (err)
241 goto failure;
242
243 /* OK, now commit destination to socket. */
bcd76111 244 sk->sk_gso_type = SKB_GSO_TCPV4;
6cbb0df7 245 sk_setup_caps(sk, &rt->u.dst);
1da177e4
LT
246
247 if (!tp->write_seq)
248 tp->write_seq = secure_tcp_sequence_number(inet->saddr,
249 inet->daddr,
250 inet->sport,
251 usin->sin_port);
252
253 inet->id = tp->write_seq ^ jiffies;
254
255 err = tcp_connect(sk);
256 rt = NULL;
257 if (err)
258 goto failure;
259
260 return 0;
261
262failure:
263 /* This unhashes the socket and releases the local port, if necessary. */
264 tcp_set_state(sk, TCP_CLOSE);
265 ip_rt_put(rt);
266 sk->sk_route_caps = 0;
267 inet->dport = 0;
268 return err;
269}
270
1da177e4
LT
271/*
272 * This routine does path mtu discovery as defined in RFC1191.
273 */
40efc6fa 274static void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, u32 mtu)
1da177e4
LT
275{
276 struct dst_entry *dst;
277 struct inet_sock *inet = inet_sk(sk);
1da177e4
LT
278
279 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
280 * send out by Linux are always <576bytes so they should go through
281 * unfragmented).
282 */
283 if (sk->sk_state == TCP_LISTEN)
284 return;
285
286 /* We don't check in the destentry if pmtu discovery is forbidden
287 * on this route. We just assume that no packet_to_big packets
288 * are send back when pmtu discovery is not active.
289 * There is a small race when the user changes this flag in the
290 * route, but I think that's acceptable.
291 */
292 if ((dst = __sk_dst_check(sk, 0)) == NULL)
293 return;
294
295 dst->ops->update_pmtu(dst, mtu);
296
297 /* Something is about to be wrong... Remember soft error
298 * for the case, if this connection will not able to recover.
299 */
300 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
301 sk->sk_err_soft = EMSGSIZE;
302
303 mtu = dst_mtu(dst);
304
305 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
d83d8461 306 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
1da177e4
LT
307 tcp_sync_mss(sk, mtu);
308
309 /* Resend the TCP packet because it's
310 * clear that the old packet has been
311 * dropped. This is the new "fast" path mtu
312 * discovery.
313 */
314 tcp_simple_retransmit(sk);
315 } /* else let the usual retransmit timer handle it */
316}
317
318/*
319 * This routine is called by the ICMP module when it gets some
320 * sort of error condition. If err < 0 then the socket should
321 * be closed and the error returned to the user. If err > 0
322 * it's just the icmp type << 8 | icmp code. After adjustment
323 * header points to the first 8 bytes of the tcp header. We need
324 * to find the appropriate port.
325 *
326 * The locking strategy used here is very "optimistic". When
327 * someone else accesses the socket the ICMP is just dropped
328 * and for some paths there is no check at all.
329 * A more general error queue to queue errors for later handling
330 * is probably better.
331 *
332 */
333
334void tcp_v4_err(struct sk_buff *skb, u32 info)
335{
336 struct iphdr *iph = (struct iphdr *)skb->data;
337 struct tcphdr *th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
338 struct tcp_sock *tp;
339 struct inet_sock *inet;
340 int type = skb->h.icmph->type;
341 int code = skb->h.icmph->code;
342 struct sock *sk;
343 __u32 seq;
344 int err;
345
346 if (skb->len < (iph->ihl << 2) + 8) {
347 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
348 return;
349 }
350
e48c414e 351 sk = inet_lookup(&tcp_hashinfo, iph->daddr, th->dest, iph->saddr,
463c84b9 352 th->source, inet_iif(skb));
1da177e4
LT
353 if (!sk) {
354 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
355 return;
356 }
357 if (sk->sk_state == TCP_TIME_WAIT) {
8feaf0c0 358 inet_twsk_put((struct inet_timewait_sock *)sk);
1da177e4
LT
359 return;
360 }
361
362 bh_lock_sock(sk);
363 /* If too many ICMPs get dropped on busy
364 * servers this needs to be solved differently.
365 */
366 if (sock_owned_by_user(sk))
367 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
368
369 if (sk->sk_state == TCP_CLOSE)
370 goto out;
371
372 tp = tcp_sk(sk);
373 seq = ntohl(th->seq);
374 if (sk->sk_state != TCP_LISTEN &&
375 !between(seq, tp->snd_una, tp->snd_nxt)) {
376 NET_INC_STATS(LINUX_MIB_OUTOFWINDOWICMPS);
377 goto out;
378 }
379
380 switch (type) {
381 case ICMP_SOURCE_QUENCH:
382 /* Just silently ignore these. */
383 goto out;
384 case ICMP_PARAMETERPROB:
385 err = EPROTO;
386 break;
387 case ICMP_DEST_UNREACH:
388 if (code > NR_ICMP_UNREACH)
389 goto out;
390
391 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
392 if (!sock_owned_by_user(sk))
393 do_pmtu_discovery(sk, iph, info);
394 goto out;
395 }
396
397 err = icmp_err_convert[code].errno;
398 break;
399 case ICMP_TIME_EXCEEDED:
400 err = EHOSTUNREACH;
401 break;
402 default:
403 goto out;
404 }
405
406 switch (sk->sk_state) {
60236fdd 407 struct request_sock *req, **prev;
1da177e4
LT
408 case TCP_LISTEN:
409 if (sock_owned_by_user(sk))
410 goto out;
411
463c84b9
ACM
412 req = inet_csk_search_req(sk, &prev, th->dest,
413 iph->daddr, iph->saddr);
1da177e4
LT
414 if (!req)
415 goto out;
416
417 /* ICMPs are not backlogged, hence we cannot get
418 an established socket here.
419 */
420 BUG_TRAP(!req->sk);
421
2e6599cb 422 if (seq != tcp_rsk(req)->snt_isn) {
1da177e4
LT
423 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
424 goto out;
425 }
426
427 /*
428 * Still in SYN_RECV, just remove it silently.
429 * There is no good way to pass the error to the newly
430 * created socket, and POSIX does not want network
431 * errors returned from accept().
432 */
463c84b9 433 inet_csk_reqsk_queue_drop(sk, req, prev);
1da177e4
LT
434 goto out;
435
436 case TCP_SYN_SENT:
437 case TCP_SYN_RECV: /* Cannot happen.
438 It can f.e. if SYNs crossed.
439 */
440 if (!sock_owned_by_user(sk)) {
1da177e4
LT
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. */
8292a17a 482void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb)
1da177e4
LT
483{
484 struct inet_sock *inet = inet_sk(sk);
8292a17a 485 struct tcphdr *th = skb->h.th;
1da177e4
LT
486
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
a430a43d
HX
498int tcp_v4_gso_send_check(struct sk_buff *skb)
499{
500 struct iphdr *iph;
501 struct tcphdr *th;
502
503 if (!pskb_may_pull(skb, sizeof(*th)))
504 return -EINVAL;
505
506 iph = skb->nh.iph;
507 th = skb->h.th;
508
509 th->check = 0;
510 th->check = ~tcp_v4_check(th, skb->len, iph->saddr, iph->daddr, 0);
511 skb->csum = offsetof(struct tcphdr, check);
512 skb->ip_summed = CHECKSUM_HW;
513 return 0;
514}
515
1da177e4
LT
516/*
517 * This routine will send an RST to the other tcp.
518 *
519 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
520 * for reset.
521 * Answer: if a packet caused RST, it is not for a socket
522 * existing in our system, if it is matched to a socket,
523 * it is just duplicate segment or bug in other side's TCP.
524 * So that we build reply only basing on parameters
525 * arrived with segment.
526 * Exception: precedence violation. We do not implement it in any case.
527 */
528
529static void tcp_v4_send_reset(struct sk_buff *skb)
530{
531 struct tcphdr *th = skb->h.th;
532 struct tcphdr rth;
533 struct ip_reply_arg arg;
534
535 /* Never send a reset in response to a reset. */
536 if (th->rst)
537 return;
538
539 if (((struct rtable *)skb->dst)->rt_type != RTN_LOCAL)
540 return;
541
542 /* Swap the send and the receive. */
543 memset(&rth, 0, sizeof(struct tcphdr));
544 rth.dest = th->source;
545 rth.source = th->dest;
546 rth.doff = sizeof(struct tcphdr) / 4;
547 rth.rst = 1;
548
549 if (th->ack) {
550 rth.seq = th->ack_seq;
551 } else {
552 rth.ack = 1;
553 rth.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
554 skb->len - (th->doff << 2));
555 }
556
557 memset(&arg, 0, sizeof arg);
558 arg.iov[0].iov_base = (unsigned char *)&rth;
559 arg.iov[0].iov_len = sizeof rth;
560 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
561 skb->nh.iph->saddr, /*XXX*/
562 sizeof(struct tcphdr), IPPROTO_TCP, 0);
563 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
564
565 ip_send_reply(tcp_socket->sk, skb, &arg, sizeof rth);
566
567 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
568 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
569}
570
571/* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
572 outside socket context is ugly, certainly. What can I do?
573 */
574
575static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
576 u32 win, u32 ts)
577{
578 struct tcphdr *th = skb->h.th;
579 struct {
580 struct tcphdr th;
581 u32 tsopt[3];
582 } rep;
583 struct ip_reply_arg arg;
584
585 memset(&rep.th, 0, sizeof(struct tcphdr));
586 memset(&arg, 0, sizeof arg);
587
588 arg.iov[0].iov_base = (unsigned char *)&rep;
589 arg.iov[0].iov_len = sizeof(rep.th);
590 if (ts) {
591 rep.tsopt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
592 (TCPOPT_TIMESTAMP << 8) |
593 TCPOLEN_TIMESTAMP);
594 rep.tsopt[1] = htonl(tcp_time_stamp);
595 rep.tsopt[2] = htonl(ts);
596 arg.iov[0].iov_len = sizeof(rep);
597 }
598
599 /* Swap the send and the receive. */
600 rep.th.dest = th->source;
601 rep.th.source = th->dest;
602 rep.th.doff = arg.iov[0].iov_len / 4;
603 rep.th.seq = htonl(seq);
604 rep.th.ack_seq = htonl(ack);
605 rep.th.ack = 1;
606 rep.th.window = htons(win);
607
608 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
609 skb->nh.iph->saddr, /*XXX*/
610 arg.iov[0].iov_len, IPPROTO_TCP, 0);
611 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
612
613 ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len);
614
615 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
616}
617
618static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
619{
8feaf0c0
ACM
620 struct inet_timewait_sock *tw = inet_twsk(sk);
621 const struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
1da177e4 622
8feaf0c0
ACM
623 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
624 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale, tcptw->tw_ts_recent);
1da177e4 625
8feaf0c0 626 inet_twsk_put(tw);
1da177e4
LT
627}
628
60236fdd 629static void tcp_v4_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
1da177e4 630{
2e6599cb 631 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
1da177e4
LT
632 req->ts_recent);
633}
634
1da177e4
LT
635/*
636 * Send a SYN-ACK after having received an ACK.
60236fdd 637 * This still operates on a request_sock only, not on a big
1da177e4
LT
638 * socket.
639 */
60236fdd 640static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
1da177e4
LT
641 struct dst_entry *dst)
642{
2e6599cb 643 const struct inet_request_sock *ireq = inet_rsk(req);
1da177e4
LT
644 int err = -1;
645 struct sk_buff * skb;
646
647 /* First, grab a route. */
463c84b9 648 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
1da177e4
LT
649 goto out;
650
651 skb = tcp_make_synack(sk, dst, req);
652
653 if (skb) {
654 struct tcphdr *th = skb->h.th;
655
656 th->check = tcp_v4_check(th, skb->len,
2e6599cb
ACM
657 ireq->loc_addr,
658 ireq->rmt_addr,
1da177e4
LT
659 csum_partial((char *)th, skb->len,
660 skb->csum));
661
2e6599cb
ACM
662 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
663 ireq->rmt_addr,
664 ireq->opt);
1da177e4
LT
665 if (err == NET_XMIT_CN)
666 err = 0;
667 }
668
669out:
670 dst_release(dst);
671 return err;
672}
673
674/*
60236fdd 675 * IPv4 request_sock destructor.
1da177e4 676 */
60236fdd 677static void tcp_v4_reqsk_destructor(struct request_sock *req)
1da177e4 678{
a51482bd 679 kfree(inet_rsk(req)->opt);
1da177e4
LT
680}
681
80e40daa 682#ifdef CONFIG_SYN_COOKIES
40efc6fa 683static void syn_flood_warning(struct sk_buff *skb)
1da177e4
LT
684{
685 static unsigned long warntime;
686
687 if (time_after(jiffies, (warntime + HZ * 60))) {
688 warntime = jiffies;
689 printk(KERN_INFO
690 "possible SYN flooding on port %d. Sending cookies.\n",
691 ntohs(skb->h.th->dest));
692 }
693}
80e40daa 694#endif
1da177e4
LT
695
696/*
60236fdd 697 * Save and compile IPv4 options into the request_sock if needed.
1da177e4 698 */
40efc6fa
SH
699static struct ip_options *tcp_v4_save_options(struct sock *sk,
700 struct sk_buff *skb)
1da177e4
LT
701{
702 struct ip_options *opt = &(IPCB(skb)->opt);
703 struct ip_options *dopt = NULL;
704
705 if (opt && opt->optlen) {
706 int opt_size = optlength(opt);
707 dopt = kmalloc(opt_size, GFP_ATOMIC);
708 if (dopt) {
709 if (ip_options_echo(dopt, skb)) {
710 kfree(dopt);
711 dopt = NULL;
712 }
713 }
714 }
715 return dopt;
716}
717
60236fdd 718struct request_sock_ops tcp_request_sock_ops = {
1da177e4 719 .family = PF_INET,
2e6599cb 720 .obj_size = sizeof(struct tcp_request_sock),
1da177e4 721 .rtx_syn_ack = tcp_v4_send_synack,
60236fdd
ACM
722 .send_ack = tcp_v4_reqsk_send_ack,
723 .destructor = tcp_v4_reqsk_destructor,
1da177e4
LT
724 .send_reset = tcp_v4_send_reset,
725};
726
6d6ee43e
ACM
727static struct timewait_sock_ops tcp_timewait_sock_ops = {
728 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
729 .twsk_unique = tcp_twsk_unique,
730};
731
1da177e4
LT
732int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
733{
2e6599cb 734 struct inet_request_sock *ireq;
1da177e4 735 struct tcp_options_received tmp_opt;
60236fdd 736 struct request_sock *req;
1da177e4
LT
737 __u32 saddr = skb->nh.iph->saddr;
738 __u32 daddr = skb->nh.iph->daddr;
739 __u32 isn = TCP_SKB_CB(skb)->when;
740 struct dst_entry *dst = NULL;
741#ifdef CONFIG_SYN_COOKIES
742 int want_cookie = 0;
743#else
744#define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
745#endif
746
747 /* Never answer to SYNs send to broadcast or multicast */
748 if (((struct rtable *)skb->dst)->rt_flags &
749 (RTCF_BROADCAST | RTCF_MULTICAST))
750 goto drop;
751
752 /* TW buckets are converted to open requests without
753 * limitations, they conserve resources and peer is
754 * evidently real one.
755 */
463c84b9 756 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
1da177e4
LT
757#ifdef CONFIG_SYN_COOKIES
758 if (sysctl_tcp_syncookies) {
759 want_cookie = 1;
760 } else
761#endif
762 goto drop;
763 }
764
765 /* Accept backlog is full. If we have already queued enough
766 * of warm entries in syn queue, drop request. It is better than
767 * clogging syn queue with openreqs with exponentially increasing
768 * timeout.
769 */
463c84b9 770 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
1da177e4
LT
771 goto drop;
772
60236fdd 773 req = reqsk_alloc(&tcp_request_sock_ops);
1da177e4
LT
774 if (!req)
775 goto drop;
776
777 tcp_clear_options(&tmp_opt);
778 tmp_opt.mss_clamp = 536;
779 tmp_opt.user_mss = tcp_sk(sk)->rx_opt.user_mss;
780
781 tcp_parse_options(skb, &tmp_opt, 0);
782
783 if (want_cookie) {
784 tcp_clear_options(&tmp_opt);
785 tmp_opt.saw_tstamp = 0;
786 }
787
788 if (tmp_opt.saw_tstamp && !tmp_opt.rcv_tsval) {
789 /* Some OSes (unknown ones, but I see them on web server, which
790 * contains information interesting only for windows'
791 * users) do not send their stamp in SYN. It is easy case.
792 * We simply do not advertise TS support.
793 */
794 tmp_opt.saw_tstamp = 0;
795 tmp_opt.tstamp_ok = 0;
796 }
797 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
798
799 tcp_openreq_init(req, &tmp_opt, skb);
800
4237c75c
VY
801 if (security_inet_conn_request(sk, skb, req))
802 goto drop_and_free;
803
2e6599cb
ACM
804 ireq = inet_rsk(req);
805 ireq->loc_addr = daddr;
806 ireq->rmt_addr = saddr;
807 ireq->opt = tcp_v4_save_options(sk, skb);
1da177e4
LT
808 if (!want_cookie)
809 TCP_ECN_create_request(req, skb->h.th);
810
811 if (want_cookie) {
812#ifdef CONFIG_SYN_COOKIES
813 syn_flood_warning(skb);
814#endif
815 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
816 } else if (!isn) {
817 struct inet_peer *peer = NULL;
818
819 /* VJ's idea. We save last timestamp seen
820 * from the destination in peer table, when entering
821 * state TIME-WAIT, and check against it before
822 * accepting new connection request.
823 *
824 * If "isn" is not zero, this request hit alive
825 * timewait bucket, so that all the necessary checks
826 * are made in the function processing timewait state.
827 */
828 if (tmp_opt.saw_tstamp &&
295ff7ed 829 tcp_death_row.sysctl_tw_recycle &&
463c84b9 830 (dst = inet_csk_route_req(sk, req)) != NULL &&
1da177e4
LT
831 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
832 peer->v4daddr == saddr) {
833 if (xtime.tv_sec < peer->tcp_ts_stamp + TCP_PAWS_MSL &&
834 (s32)(peer->tcp_ts - req->ts_recent) >
835 TCP_PAWS_WINDOW) {
836 NET_INC_STATS_BH(LINUX_MIB_PAWSPASSIVEREJECTED);
837 dst_release(dst);
838 goto drop_and_free;
839 }
840 }
841 /* Kill the following clause, if you dislike this way. */
842 else if (!sysctl_tcp_syncookies &&
463c84b9 843 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
1da177e4
LT
844 (sysctl_max_syn_backlog >> 2)) &&
845 (!peer || !peer->tcp_ts_stamp) &&
846 (!dst || !dst_metric(dst, RTAX_RTT))) {
847 /* Without syncookies last quarter of
848 * backlog is filled with destinations,
849 * proven to be alive.
850 * It means that we continue to communicate
851 * to destinations, already remembered
852 * to the moment of synflood.
853 */
64ce2073
PM
854 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open "
855 "request from %u.%u.%u.%u/%u\n",
856 NIPQUAD(saddr),
857 ntohs(skb->h.th->source));
1da177e4
LT
858 dst_release(dst);
859 goto drop_and_free;
860 }
861
862 isn = tcp_v4_init_sequence(sk, skb);
863 }
2e6599cb 864 tcp_rsk(req)->snt_isn = isn;
1da177e4
LT
865
866 if (tcp_v4_send_synack(sk, req, dst))
867 goto drop_and_free;
868
869 if (want_cookie) {
60236fdd 870 reqsk_free(req);
1da177e4 871 } else {
3f421baa 872 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1da177e4
LT
873 }
874 return 0;
875
876drop_and_free:
60236fdd 877 reqsk_free(req);
1da177e4 878drop:
1da177e4
LT
879 return 0;
880}
881
882
883/*
884 * The three way handshake has completed - we got a valid synack -
885 * now create the new socket.
886 */
887struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
60236fdd 888 struct request_sock *req,
1da177e4
LT
889 struct dst_entry *dst)
890{
2e6599cb 891 struct inet_request_sock *ireq;
1da177e4
LT
892 struct inet_sock *newinet;
893 struct tcp_sock *newtp;
894 struct sock *newsk;
895
896 if (sk_acceptq_is_full(sk))
897 goto exit_overflow;
898
463c84b9 899 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
1da177e4
LT
900 goto exit;
901
902 newsk = tcp_create_openreq_child(sk, req, skb);
903 if (!newsk)
904 goto exit;
905
bcd76111 906 newsk->sk_gso_type = SKB_GSO_TCPV4;
6cbb0df7 907 sk_setup_caps(newsk, dst);
1da177e4
LT
908
909 newtp = tcp_sk(newsk);
910 newinet = inet_sk(newsk);
2e6599cb
ACM
911 ireq = inet_rsk(req);
912 newinet->daddr = ireq->rmt_addr;
913 newinet->rcv_saddr = ireq->loc_addr;
914 newinet->saddr = ireq->loc_addr;
915 newinet->opt = ireq->opt;
916 ireq->opt = NULL;
463c84b9 917 newinet->mc_index = inet_iif(skb);
1da177e4 918 newinet->mc_ttl = skb->nh.iph->ttl;
d83d8461 919 inet_csk(newsk)->icsk_ext_hdr_len = 0;
1da177e4 920 if (newinet->opt)
d83d8461 921 inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
1da177e4
LT
922 newinet->id = newtp->write_seq ^ jiffies;
923
5d424d5a 924 tcp_mtup_init(newsk);
1da177e4
LT
925 tcp_sync_mss(newsk, dst_mtu(dst));
926 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
927 tcp_initialize_rcv_mss(newsk);
928
f3f05f70 929 __inet_hash(&tcp_hashinfo, newsk, 0);
2d8c4ce5 930 __inet_inherit_port(&tcp_hashinfo, sk, newsk);
1da177e4
LT
931
932 return newsk;
933
934exit_overflow:
935 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
936exit:
937 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
938 dst_release(dst);
939 return NULL;
940}
941
942static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
943{
944 struct tcphdr *th = skb->h.th;
945 struct iphdr *iph = skb->nh.iph;
1da177e4 946 struct sock *nsk;
60236fdd 947 struct request_sock **prev;
1da177e4 948 /* Find possible connection requests. */
463c84b9
ACM
949 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
950 iph->saddr, iph->daddr);
1da177e4
LT
951 if (req)
952 return tcp_check_req(sk, skb, req, prev);
953
e48c414e
ACM
954 nsk = __inet_lookup_established(&tcp_hashinfo, skb->nh.iph->saddr,
955 th->source, skb->nh.iph->daddr,
463c84b9 956 ntohs(th->dest), inet_iif(skb));
1da177e4
LT
957
958 if (nsk) {
959 if (nsk->sk_state != TCP_TIME_WAIT) {
960 bh_lock_sock(nsk);
961 return nsk;
962 }
8feaf0c0 963 inet_twsk_put((struct inet_timewait_sock *)nsk);
1da177e4
LT
964 return NULL;
965 }
966
967#ifdef CONFIG_SYN_COOKIES
968 if (!th->rst && !th->syn && th->ack)
969 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
970#endif
971 return sk;
972}
973
974static int tcp_v4_checksum_init(struct sk_buff *skb)
975{
976 if (skb->ip_summed == CHECKSUM_HW) {
1da177e4 977 if (!tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
fb286bb2
HX
978 skb->nh.iph->daddr, skb->csum)) {
979 skb->ip_summed = CHECKSUM_UNNECESSARY;
1da177e4 980 return 0;
fb286bb2 981 }
1da177e4 982 }
fb286bb2
HX
983
984 skb->csum = csum_tcpudp_nofold(skb->nh.iph->saddr, skb->nh.iph->daddr,
985 skb->len, IPPROTO_TCP, 0);
986
1da177e4 987 if (skb->len <= 76) {
fb286bb2 988 return __skb_checksum_complete(skb);
1da177e4
LT
989 }
990 return 0;
991}
992
993
994/* The socket must have it's spinlock held when we get
995 * here.
996 *
997 * We have a potential double-lock case here, so even when
998 * doing backlog processing we use the BH locking scheme.
999 * This is because we cannot sleep with the original spinlock
1000 * held.
1001 */
1002int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1003{
1004 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1005 TCP_CHECK_TIMER(sk);
1006 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len))
1007 goto reset;
1008 TCP_CHECK_TIMER(sk);
1009 return 0;
1010 }
1011
1012 if (skb->len < (skb->h.th->doff << 2) || tcp_checksum_complete(skb))
1013 goto csum_err;
1014
1015 if (sk->sk_state == TCP_LISTEN) {
1016 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1017 if (!nsk)
1018 goto discard;
1019
1020 if (nsk != sk) {
1021 if (tcp_child_process(sk, nsk, skb))
1022 goto reset;
1023 return 0;
1024 }
1025 }
1026
1027 TCP_CHECK_TIMER(sk);
1028 if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len))
1029 goto reset;
1030 TCP_CHECK_TIMER(sk);
1031 return 0;
1032
1033reset:
1034 tcp_v4_send_reset(skb);
1035discard:
1036 kfree_skb(skb);
1037 /* Be careful here. If this function gets more complicated and
1038 * gcc suffers from register pressure on the x86, sk (in %ebx)
1039 * might be destroyed here. This current version compiles correctly,
1040 * but you have been warned.
1041 */
1042 return 0;
1043
1044csum_err:
1045 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1046 goto discard;
1047}
1048
1049/*
1050 * From tcp_input.c
1051 */
1052
1053int tcp_v4_rcv(struct sk_buff *skb)
1054{
1055 struct tcphdr *th;
1056 struct sock *sk;
1057 int ret;
1058
1059 if (skb->pkt_type != PACKET_HOST)
1060 goto discard_it;
1061
1062 /* Count it even if it's bad */
1063 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1064
1065 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1066 goto discard_it;
1067
1068 th = skb->h.th;
1069
1070 if (th->doff < sizeof(struct tcphdr) / 4)
1071 goto bad_packet;
1072 if (!pskb_may_pull(skb, th->doff * 4))
1073 goto discard_it;
1074
1075 /* An explanation is required here, I think.
1076 * Packet length and doff are validated by header prediction,
caa20d9a 1077 * provided case of th->doff==0 is eliminated.
1da177e4
LT
1078 * So, we defer the checks. */
1079 if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
fb286bb2 1080 tcp_v4_checksum_init(skb)))
1da177e4
LT
1081 goto bad_packet;
1082
1083 th = skb->h.th;
1084 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1085 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1086 skb->len - th->doff * 4);
1087 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1088 TCP_SKB_CB(skb)->when = 0;
1089 TCP_SKB_CB(skb)->flags = skb->nh.iph->tos;
1090 TCP_SKB_CB(skb)->sacked = 0;
1091
e48c414e
ACM
1092 sk = __inet_lookup(&tcp_hashinfo, skb->nh.iph->saddr, th->source,
1093 skb->nh.iph->daddr, ntohs(th->dest),
463c84b9 1094 inet_iif(skb));
1da177e4
LT
1095
1096 if (!sk)
1097 goto no_tcp_socket;
1098
1099process:
1100 if (sk->sk_state == TCP_TIME_WAIT)
1101 goto do_time_wait;
1102
1103 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1104 goto discard_and_relse;
b59c2701 1105 nf_reset(skb);
1da177e4
LT
1106
1107 if (sk_filter(sk, skb, 0))
1108 goto discard_and_relse;
1109
1110 skb->dev = NULL;
1111
c6366184 1112 bh_lock_sock_nested(sk);
1da177e4
LT
1113 ret = 0;
1114 if (!sock_owned_by_user(sk)) {
1a2449a8
CL
1115#ifdef CONFIG_NET_DMA
1116 struct tcp_sock *tp = tcp_sk(sk);
1117 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1118 tp->ucopy.dma_chan = get_softnet_dma();
1119 if (tp->ucopy.dma_chan)
1da177e4 1120 ret = tcp_v4_do_rcv(sk, skb);
1a2449a8
CL
1121 else
1122#endif
1123 {
1124 if (!tcp_prequeue(sk, skb))
1125 ret = tcp_v4_do_rcv(sk, skb);
1126 }
1da177e4
LT
1127 } else
1128 sk_add_backlog(sk, skb);
1129 bh_unlock_sock(sk);
1130
1131 sock_put(sk);
1132
1133 return ret;
1134
1135no_tcp_socket:
1136 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1137 goto discard_it;
1138
1139 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1140bad_packet:
1141 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1142 } else {
1143 tcp_v4_send_reset(skb);
1144 }
1145
1146discard_it:
1147 /* Discard frame. */
1148 kfree_skb(skb);
1149 return 0;
1150
1151discard_and_relse:
1152 sock_put(sk);
1153 goto discard_it;
1154
1155do_time_wait:
1156 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
8feaf0c0 1157 inet_twsk_put((struct inet_timewait_sock *) sk);
1da177e4
LT
1158 goto discard_it;
1159 }
1160
1161 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1162 TCP_INC_STATS_BH(TCP_MIB_INERRS);
8feaf0c0 1163 inet_twsk_put((struct inet_timewait_sock *) sk);
1da177e4
LT
1164 goto discard_it;
1165 }
8feaf0c0
ACM
1166 switch (tcp_timewait_state_process((struct inet_timewait_sock *)sk,
1167 skb, th)) {
1da177e4 1168 case TCP_TW_SYN: {
33b62231
ACM
1169 struct sock *sk2 = inet_lookup_listener(&tcp_hashinfo,
1170 skb->nh.iph->daddr,
1171 ntohs(th->dest),
463c84b9 1172 inet_iif(skb));
1da177e4 1173 if (sk2) {
295ff7ed
ACM
1174 inet_twsk_deschedule((struct inet_timewait_sock *)sk,
1175 &tcp_death_row);
8feaf0c0 1176 inet_twsk_put((struct inet_timewait_sock *)sk);
1da177e4
LT
1177 sk = sk2;
1178 goto process;
1179 }
1180 /* Fall through to ACK */
1181 }
1182 case TCP_TW_ACK:
1183 tcp_v4_timewait_ack(sk, skb);
1184 break;
1185 case TCP_TW_RST:
1186 goto no_tcp_socket;
1187 case TCP_TW_SUCCESS:;
1188 }
1189 goto discard_it;
1190}
1191
1da177e4
LT
1192/* VJ's idea. Save last timestamp seen from this destination
1193 * and hold it at least for normal timewait interval to use for duplicate
1194 * segment detection in subsequent connections, before they enter synchronized
1195 * state.
1196 */
1197
1198int tcp_v4_remember_stamp(struct sock *sk)
1199{
1200 struct inet_sock *inet = inet_sk(sk);
1201 struct tcp_sock *tp = tcp_sk(sk);
1202 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1203 struct inet_peer *peer = NULL;
1204 int release_it = 0;
1205
1206 if (!rt || rt->rt_dst != inet->daddr) {
1207 peer = inet_getpeer(inet->daddr, 1);
1208 release_it = 1;
1209 } else {
1210 if (!rt->peer)
1211 rt_bind_peer(rt, 1);
1212 peer = rt->peer;
1213 }
1214
1215 if (peer) {
1216 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
1217 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1218 peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {
1219 peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;
1220 peer->tcp_ts = tp->rx_opt.ts_recent;
1221 }
1222 if (release_it)
1223 inet_putpeer(peer);
1224 return 1;
1225 }
1226
1227 return 0;
1228}
1229
8feaf0c0 1230int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
1da177e4 1231{
8feaf0c0 1232 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
1da177e4
LT
1233
1234 if (peer) {
8feaf0c0
ACM
1235 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1236
1237 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
1da177e4 1238 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
8feaf0c0
ACM
1239 peer->tcp_ts_stamp <= tcptw->tw_ts_recent_stamp)) {
1240 peer->tcp_ts_stamp = tcptw->tw_ts_recent_stamp;
1241 peer->tcp_ts = tcptw->tw_ts_recent;
1da177e4
LT
1242 }
1243 inet_putpeer(peer);
1244 return 1;
1245 }
1246
1247 return 0;
1248}
1249
8292a17a 1250struct inet_connection_sock_af_ops ipv4_specific = {
543d9cfe
ACM
1251 .queue_xmit = ip_queue_xmit,
1252 .send_check = tcp_v4_send_check,
1253 .rebuild_header = inet_sk_rebuild_header,
1254 .conn_request = tcp_v4_conn_request,
1255 .syn_recv_sock = tcp_v4_syn_recv_sock,
1256 .remember_stamp = tcp_v4_remember_stamp,
1257 .net_header_len = sizeof(struct iphdr),
1258 .setsockopt = ip_setsockopt,
1259 .getsockopt = ip_getsockopt,
1260 .addr2sockaddr = inet_csk_addr2sockaddr,
1261 .sockaddr_len = sizeof(struct sockaddr_in),
3fdadf7d 1262#ifdef CONFIG_COMPAT
543d9cfe
ACM
1263 .compat_setsockopt = compat_ip_setsockopt,
1264 .compat_getsockopt = compat_ip_getsockopt,
3fdadf7d 1265#endif
1da177e4
LT
1266};
1267
1268/* NOTE: A lot of things set to zero explicitly by call to
1269 * sk_alloc() so need not be done here.
1270 */
1271static int tcp_v4_init_sock(struct sock *sk)
1272{
6687e988 1273 struct inet_connection_sock *icsk = inet_csk(sk);
1da177e4
LT
1274 struct tcp_sock *tp = tcp_sk(sk);
1275
1276 skb_queue_head_init(&tp->out_of_order_queue);
1277 tcp_init_xmit_timers(sk);
1278 tcp_prequeue_init(tp);
1279
6687e988 1280 icsk->icsk_rto = TCP_TIMEOUT_INIT;
1da177e4
LT
1281 tp->mdev = TCP_TIMEOUT_INIT;
1282
1283 /* So many TCP implementations out there (incorrectly) count the
1284 * initial SYN frame in their delayed-ACK and congestion control
1285 * algorithms that we must have the following bandaid to talk
1286 * efficiently to them. -DaveM
1287 */
1288 tp->snd_cwnd = 2;
1289
1290 /* See draft-stevens-tcpca-spec-01 for discussion of the
1291 * initialization of these values.
1292 */
1293 tp->snd_ssthresh = 0x7fffffff; /* Infinity */
1294 tp->snd_cwnd_clamp = ~0;
c1b4a7e6 1295 tp->mss_cache = 536;
1da177e4
LT
1296
1297 tp->reordering = sysctl_tcp_reordering;
6687e988 1298 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
1da177e4
LT
1299
1300 sk->sk_state = TCP_CLOSE;
1301
1302 sk->sk_write_space = sk_stream_write_space;
1303 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1304
8292a17a 1305 icsk->icsk_af_ops = &ipv4_specific;
d83d8461 1306 icsk->icsk_sync_mss = tcp_sync_mss;
1da177e4
LT
1307
1308 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1309 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1310
1311 atomic_inc(&tcp_sockets_allocated);
1312
1313 return 0;
1314}
1315
1316int tcp_v4_destroy_sock(struct sock *sk)
1317{
1318 struct tcp_sock *tp = tcp_sk(sk);
1319
1320 tcp_clear_xmit_timers(sk);
1321
6687e988 1322 tcp_cleanup_congestion_control(sk);
317a76f9 1323
1da177e4
LT
1324 /* Cleanup up the write buffer. */
1325 sk_stream_writequeue_purge(sk);
1326
1327 /* Cleans up our, hopefully empty, out_of_order_queue. */
1328 __skb_queue_purge(&tp->out_of_order_queue);
1329
1a2449a8
CL
1330#ifdef CONFIG_NET_DMA
1331 /* Cleans up our sk_async_wait_queue */
1332 __skb_queue_purge(&sk->sk_async_wait_queue);
1333#endif
1334
1da177e4
LT
1335 /* Clean prequeue, it must be empty really */
1336 __skb_queue_purge(&tp->ucopy.prequeue);
1337
1338 /* Clean up a referenced TCP bind bucket. */
463c84b9 1339 if (inet_csk(sk)->icsk_bind_hash)
2d8c4ce5 1340 inet_put_port(&tcp_hashinfo, sk);
1da177e4
LT
1341
1342 /*
1343 * If sendmsg cached page exists, toss it.
1344 */
1345 if (sk->sk_sndmsg_page) {
1346 __free_page(sk->sk_sndmsg_page);
1347 sk->sk_sndmsg_page = NULL;
1348 }
1349
1350 atomic_dec(&tcp_sockets_allocated);
1351
1352 return 0;
1353}
1354
1355EXPORT_SYMBOL(tcp_v4_destroy_sock);
1356
1357#ifdef CONFIG_PROC_FS
1358/* Proc filesystem TCP sock list dumping. */
1359
8feaf0c0 1360static inline struct inet_timewait_sock *tw_head(struct hlist_head *head)
1da177e4
LT
1361{
1362 return hlist_empty(head) ? NULL :
8feaf0c0 1363 list_entry(head->first, struct inet_timewait_sock, tw_node);
1da177e4
LT
1364}
1365
8feaf0c0 1366static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
1da177e4
LT
1367{
1368 return tw->tw_node.next ?
1369 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
1370}
1371
1372static void *listening_get_next(struct seq_file *seq, void *cur)
1373{
463c84b9 1374 struct inet_connection_sock *icsk;
1da177e4
LT
1375 struct hlist_node *node;
1376 struct sock *sk = cur;
1377 struct tcp_iter_state* st = seq->private;
1378
1379 if (!sk) {
1380 st->bucket = 0;
6e04e021 1381 sk = sk_head(&tcp_hashinfo.listening_hash[0]);
1da177e4
LT
1382 goto get_sk;
1383 }
1384
1385 ++st->num;
1386
1387 if (st->state == TCP_SEQ_STATE_OPENREQ) {
60236fdd 1388 struct request_sock *req = cur;
1da177e4 1389
463c84b9 1390 icsk = inet_csk(st->syn_wait_sk);
1da177e4
LT
1391 req = req->dl_next;
1392 while (1) {
1393 while (req) {
60236fdd 1394 if (req->rsk_ops->family == st->family) {
1da177e4
LT
1395 cur = req;
1396 goto out;
1397 }
1398 req = req->dl_next;
1399 }
1400 if (++st->sbucket >= TCP_SYNQ_HSIZE)
1401 break;
1402get_req:
463c84b9 1403 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
1da177e4
LT
1404 }
1405 sk = sk_next(st->syn_wait_sk);
1406 st->state = TCP_SEQ_STATE_LISTENING;
463c84b9 1407 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1da177e4 1408 } else {
463c84b9
ACM
1409 icsk = inet_csk(sk);
1410 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1411 if (reqsk_queue_len(&icsk->icsk_accept_queue))
1da177e4 1412 goto start_req;
463c84b9 1413 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1da177e4
LT
1414 sk = sk_next(sk);
1415 }
1416get_sk:
1417 sk_for_each_from(sk, node) {
1418 if (sk->sk_family == st->family) {
1419 cur = sk;
1420 goto out;
1421 }
463c84b9
ACM
1422 icsk = inet_csk(sk);
1423 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1424 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
1da177e4
LT
1425start_req:
1426 st->uid = sock_i_uid(sk);
1427 st->syn_wait_sk = sk;
1428 st->state = TCP_SEQ_STATE_OPENREQ;
1429 st->sbucket = 0;
1430 goto get_req;
1431 }
463c84b9 1432 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1da177e4 1433 }
0f7ff927 1434 if (++st->bucket < INET_LHTABLE_SIZE) {
6e04e021 1435 sk = sk_head(&tcp_hashinfo.listening_hash[st->bucket]);
1da177e4
LT
1436 goto get_sk;
1437 }
1438 cur = NULL;
1439out:
1440 return cur;
1441}
1442
1443static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
1444{
1445 void *rc = listening_get_next(seq, NULL);
1446
1447 while (rc && *pos) {
1448 rc = listening_get_next(seq, rc);
1449 --*pos;
1450 }
1451 return rc;
1452}
1453
1454static void *established_get_first(struct seq_file *seq)
1455{
1456 struct tcp_iter_state* st = seq->private;
1457 void *rc = NULL;
1458
6e04e021 1459 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
1da177e4
LT
1460 struct sock *sk;
1461 struct hlist_node *node;
8feaf0c0 1462 struct inet_timewait_sock *tw;
1da177e4
LT
1463
1464 /* We can reschedule _before_ having picked the target: */
1465 cond_resched_softirq();
1466
6e04e021
ACM
1467 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
1468 sk_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
1da177e4
LT
1469 if (sk->sk_family != st->family) {
1470 continue;
1471 }
1472 rc = sk;
1473 goto out;
1474 }
1475 st->state = TCP_SEQ_STATE_TIME_WAIT;
8feaf0c0
ACM
1476 inet_twsk_for_each(tw, node,
1477 &tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain) {
1da177e4
LT
1478 if (tw->tw_family != st->family) {
1479 continue;
1480 }
1481 rc = tw;
1482 goto out;
1483 }
6e04e021 1484 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1da177e4
LT
1485 st->state = TCP_SEQ_STATE_ESTABLISHED;
1486 }
1487out:
1488 return rc;
1489}
1490
1491static void *established_get_next(struct seq_file *seq, void *cur)
1492{
1493 struct sock *sk = cur;
8feaf0c0 1494 struct inet_timewait_sock *tw;
1da177e4
LT
1495 struct hlist_node *node;
1496 struct tcp_iter_state* st = seq->private;
1497
1498 ++st->num;
1499
1500 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
1501 tw = cur;
1502 tw = tw_next(tw);
1503get_tw:
1504 while (tw && tw->tw_family != st->family) {
1505 tw = tw_next(tw);
1506 }
1507 if (tw) {
1508 cur = tw;
1509 goto out;
1510 }
6e04e021 1511 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1da177e4
LT
1512 st->state = TCP_SEQ_STATE_ESTABLISHED;
1513
1514 /* We can reschedule between buckets: */
1515 cond_resched_softirq();
1516
6e04e021
ACM
1517 if (++st->bucket < tcp_hashinfo.ehash_size) {
1518 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
1519 sk = sk_head(&tcp_hashinfo.ehash[st->bucket].chain);
1da177e4
LT
1520 } else {
1521 cur = NULL;
1522 goto out;
1523 }
1524 } else
1525 sk = sk_next(sk);
1526
1527 sk_for_each_from(sk, node) {
1528 if (sk->sk_family == st->family)
1529 goto found;
1530 }
1531
1532 st->state = TCP_SEQ_STATE_TIME_WAIT;
6e04e021 1533 tw = tw_head(&tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain);
1da177e4
LT
1534 goto get_tw;
1535found:
1536 cur = sk;
1537out:
1538 return cur;
1539}
1540
1541static void *established_get_idx(struct seq_file *seq, loff_t pos)
1542{
1543 void *rc = established_get_first(seq);
1544
1545 while (rc && pos) {
1546 rc = established_get_next(seq, rc);
1547 --pos;
1548 }
1549 return rc;
1550}
1551
1552static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
1553{
1554 void *rc;
1555 struct tcp_iter_state* st = seq->private;
1556
f3f05f70 1557 inet_listen_lock(&tcp_hashinfo);
1da177e4
LT
1558 st->state = TCP_SEQ_STATE_LISTENING;
1559 rc = listening_get_idx(seq, &pos);
1560
1561 if (!rc) {
f3f05f70 1562 inet_listen_unlock(&tcp_hashinfo);
1da177e4
LT
1563 local_bh_disable();
1564 st->state = TCP_SEQ_STATE_ESTABLISHED;
1565 rc = established_get_idx(seq, pos);
1566 }
1567
1568 return rc;
1569}
1570
1571static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
1572{
1573 struct tcp_iter_state* st = seq->private;
1574 st->state = TCP_SEQ_STATE_LISTENING;
1575 st->num = 0;
1576 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
1577}
1578
1579static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1580{
1581 void *rc = NULL;
1582 struct tcp_iter_state* st;
1583
1584 if (v == SEQ_START_TOKEN) {
1585 rc = tcp_get_idx(seq, 0);
1586 goto out;
1587 }
1588 st = seq->private;
1589
1590 switch (st->state) {
1591 case TCP_SEQ_STATE_OPENREQ:
1592 case TCP_SEQ_STATE_LISTENING:
1593 rc = listening_get_next(seq, v);
1594 if (!rc) {
f3f05f70 1595 inet_listen_unlock(&tcp_hashinfo);
1da177e4
LT
1596 local_bh_disable();
1597 st->state = TCP_SEQ_STATE_ESTABLISHED;
1598 rc = established_get_first(seq);
1599 }
1600 break;
1601 case TCP_SEQ_STATE_ESTABLISHED:
1602 case TCP_SEQ_STATE_TIME_WAIT:
1603 rc = established_get_next(seq, v);
1604 break;
1605 }
1606out:
1607 ++*pos;
1608 return rc;
1609}
1610
1611static void tcp_seq_stop(struct seq_file *seq, void *v)
1612{
1613 struct tcp_iter_state* st = seq->private;
1614
1615 switch (st->state) {
1616 case TCP_SEQ_STATE_OPENREQ:
1617 if (v) {
463c84b9
ACM
1618 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
1619 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1da177e4
LT
1620 }
1621 case TCP_SEQ_STATE_LISTENING:
1622 if (v != SEQ_START_TOKEN)
f3f05f70 1623 inet_listen_unlock(&tcp_hashinfo);
1da177e4
LT
1624 break;
1625 case TCP_SEQ_STATE_TIME_WAIT:
1626 case TCP_SEQ_STATE_ESTABLISHED:
1627 if (v)
6e04e021 1628 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1da177e4
LT
1629 local_bh_enable();
1630 break;
1631 }
1632}
1633
1634static int tcp_seq_open(struct inode *inode, struct file *file)
1635{
1636 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
1637 struct seq_file *seq;
1638 struct tcp_iter_state *s;
1639 int rc;
1640
1641 if (unlikely(afinfo == NULL))
1642 return -EINVAL;
1643
0da974f4 1644 s = kzalloc(sizeof(*s), GFP_KERNEL);
1da177e4
LT
1645 if (!s)
1646 return -ENOMEM;
1da177e4
LT
1647 s->family = afinfo->family;
1648 s->seq_ops.start = tcp_seq_start;
1649 s->seq_ops.next = tcp_seq_next;
1650 s->seq_ops.show = afinfo->seq_show;
1651 s->seq_ops.stop = tcp_seq_stop;
1652
1653 rc = seq_open(file, &s->seq_ops);
1654 if (rc)
1655 goto out_kfree;
1656 seq = file->private_data;
1657 seq->private = s;
1658out:
1659 return rc;
1660out_kfree:
1661 kfree(s);
1662 goto out;
1663}
1664
1665int tcp_proc_register(struct tcp_seq_afinfo *afinfo)
1666{
1667 int rc = 0;
1668 struct proc_dir_entry *p;
1669
1670 if (!afinfo)
1671 return -EINVAL;
1672 afinfo->seq_fops->owner = afinfo->owner;
1673 afinfo->seq_fops->open = tcp_seq_open;
1674 afinfo->seq_fops->read = seq_read;
1675 afinfo->seq_fops->llseek = seq_lseek;
1676 afinfo->seq_fops->release = seq_release_private;
1677
1678 p = proc_net_fops_create(afinfo->name, S_IRUGO, afinfo->seq_fops);
1679 if (p)
1680 p->data = afinfo;
1681 else
1682 rc = -ENOMEM;
1683 return rc;
1684}
1685
1686void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo)
1687{
1688 if (!afinfo)
1689 return;
1690 proc_net_remove(afinfo->name);
1691 memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops));
1692}
1693
60236fdd 1694static void get_openreq4(struct sock *sk, struct request_sock *req,
1da177e4
LT
1695 char *tmpbuf, int i, int uid)
1696{
2e6599cb 1697 const struct inet_request_sock *ireq = inet_rsk(req);
1da177e4
LT
1698 int ttd = req->expires - jiffies;
1699
1700 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
1701 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p",
1702 i,
2e6599cb 1703 ireq->loc_addr,
1da177e4 1704 ntohs(inet_sk(sk)->sport),
2e6599cb
ACM
1705 ireq->rmt_addr,
1706 ntohs(ireq->rmt_port),
1da177e4
LT
1707 TCP_SYN_RECV,
1708 0, 0, /* could print option size, but that is af dependent. */
1709 1, /* timers active (only the expire timer) */
1710 jiffies_to_clock_t(ttd),
1711 req->retrans,
1712 uid,
1713 0, /* non standard timer */
1714 0, /* open_requests have no inode */
1715 atomic_read(&sk->sk_refcnt),
1716 req);
1717}
1718
1719static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i)
1720{
1721 int timer_active;
1722 unsigned long timer_expires;
1723 struct tcp_sock *tp = tcp_sk(sp);
463c84b9 1724 const struct inet_connection_sock *icsk = inet_csk(sp);
1da177e4
LT
1725 struct inet_sock *inet = inet_sk(sp);
1726 unsigned int dest = inet->daddr;
1727 unsigned int src = inet->rcv_saddr;
1728 __u16 destp = ntohs(inet->dport);
1729 __u16 srcp = ntohs(inet->sport);
1730
463c84b9 1731 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
1da177e4 1732 timer_active = 1;
463c84b9
ACM
1733 timer_expires = icsk->icsk_timeout;
1734 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
1da177e4 1735 timer_active = 4;
463c84b9 1736 timer_expires = icsk->icsk_timeout;
1da177e4
LT
1737 } else if (timer_pending(&sp->sk_timer)) {
1738 timer_active = 2;
1739 timer_expires = sp->sk_timer.expires;
1740 } else {
1741 timer_active = 0;
1742 timer_expires = jiffies;
1743 }
1744
1745 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
1746 "%08X %5d %8d %lu %d %p %u %u %u %u %d",
1747 i, src, srcp, dest, destp, sp->sk_state,
47da8ee6
SS
1748 tp->write_seq - tp->snd_una,
1749 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
1da177e4
LT
1750 timer_active,
1751 jiffies_to_clock_t(timer_expires - jiffies),
463c84b9 1752 icsk->icsk_retransmits,
1da177e4 1753 sock_i_uid(sp),
6687e988 1754 icsk->icsk_probes_out,
1da177e4
LT
1755 sock_i_ino(sp),
1756 atomic_read(&sp->sk_refcnt), sp,
463c84b9
ACM
1757 icsk->icsk_rto,
1758 icsk->icsk_ack.ato,
1759 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
1da177e4
LT
1760 tp->snd_cwnd,
1761 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh);
1762}
1763
8feaf0c0 1764static void get_timewait4_sock(struct inet_timewait_sock *tw, char *tmpbuf, int i)
1da177e4
LT
1765{
1766 unsigned int dest, src;
1767 __u16 destp, srcp;
1768 int ttd = tw->tw_ttd - jiffies;
1769
1770 if (ttd < 0)
1771 ttd = 0;
1772
1773 dest = tw->tw_daddr;
1774 src = tw->tw_rcv_saddr;
1775 destp = ntohs(tw->tw_dport);
1776 srcp = ntohs(tw->tw_sport);
1777
1778 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
1779 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p",
1780 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
1781 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
1782 atomic_read(&tw->tw_refcnt), tw);
1783}
1784
1785#define TMPSZ 150
1786
1787static int tcp4_seq_show(struct seq_file *seq, void *v)
1788{
1789 struct tcp_iter_state* st;
1790 char tmpbuf[TMPSZ + 1];
1791
1792 if (v == SEQ_START_TOKEN) {
1793 seq_printf(seq, "%-*s\n", TMPSZ - 1,
1794 " sl local_address rem_address st tx_queue "
1795 "rx_queue tr tm->when retrnsmt uid timeout "
1796 "inode");
1797 goto out;
1798 }
1799 st = seq->private;
1800
1801 switch (st->state) {
1802 case TCP_SEQ_STATE_LISTENING:
1803 case TCP_SEQ_STATE_ESTABLISHED:
1804 get_tcp4_sock(v, tmpbuf, st->num);
1805 break;
1806 case TCP_SEQ_STATE_OPENREQ:
1807 get_openreq4(st->syn_wait_sk, v, tmpbuf, st->num, st->uid);
1808 break;
1809 case TCP_SEQ_STATE_TIME_WAIT:
1810 get_timewait4_sock(v, tmpbuf, st->num);
1811 break;
1812 }
1813 seq_printf(seq, "%-*s\n", TMPSZ - 1, tmpbuf);
1814out:
1815 return 0;
1816}
1817
1818static struct file_operations tcp4_seq_fops;
1819static struct tcp_seq_afinfo tcp4_seq_afinfo = {
1820 .owner = THIS_MODULE,
1821 .name = "tcp",
1822 .family = AF_INET,
1823 .seq_show = tcp4_seq_show,
1824 .seq_fops = &tcp4_seq_fops,
1825};
1826
1827int __init tcp4_proc_init(void)
1828{
1829 return tcp_proc_register(&tcp4_seq_afinfo);
1830}
1831
1832void tcp4_proc_exit(void)
1833{
1834 tcp_proc_unregister(&tcp4_seq_afinfo);
1835}
1836#endif /* CONFIG_PROC_FS */
1837
1838struct proto tcp_prot = {
1839 .name = "TCP",
1840 .owner = THIS_MODULE,
1841 .close = tcp_close,
1842 .connect = tcp_v4_connect,
1843 .disconnect = tcp_disconnect,
463c84b9 1844 .accept = inet_csk_accept,
1da177e4
LT
1845 .ioctl = tcp_ioctl,
1846 .init = tcp_v4_init_sock,
1847 .destroy = tcp_v4_destroy_sock,
1848 .shutdown = tcp_shutdown,
1849 .setsockopt = tcp_setsockopt,
1850 .getsockopt = tcp_getsockopt,
1851 .sendmsg = tcp_sendmsg,
1852 .recvmsg = tcp_recvmsg,
1853 .backlog_rcv = tcp_v4_do_rcv,
1854 .hash = tcp_v4_hash,
1855 .unhash = tcp_unhash,
1856 .get_port = tcp_v4_get_port,
1857 .enter_memory_pressure = tcp_enter_memory_pressure,
1858 .sockets_allocated = &tcp_sockets_allocated,
0a5578cf 1859 .orphan_count = &tcp_orphan_count,
1da177e4
LT
1860 .memory_allocated = &tcp_memory_allocated,
1861 .memory_pressure = &tcp_memory_pressure,
1862 .sysctl_mem = sysctl_tcp_mem,
1863 .sysctl_wmem = sysctl_tcp_wmem,
1864 .sysctl_rmem = sysctl_tcp_rmem,
1865 .max_header = MAX_TCP_HEADER,
1866 .obj_size = sizeof(struct tcp_sock),
6d6ee43e 1867 .twsk_prot = &tcp_timewait_sock_ops,
60236fdd 1868 .rsk_prot = &tcp_request_sock_ops,
543d9cfe
ACM
1869#ifdef CONFIG_COMPAT
1870 .compat_setsockopt = compat_tcp_setsockopt,
1871 .compat_getsockopt = compat_tcp_getsockopt,
1872#endif
1da177e4
LT
1873};
1874
1da177e4
LT
1875void __init tcp_v4_init(struct net_proto_family *ops)
1876{
c4d93909 1877 if (inet_csk_ctl_sock_create(&tcp_socket, PF_INET, SOCK_RAW, IPPROTO_TCP) < 0)
1da177e4 1878 panic("Failed to create the TCP control socket.\n");
1da177e4
LT
1879}
1880
1881EXPORT_SYMBOL(ipv4_specific);
1da177e4 1882EXPORT_SYMBOL(tcp_hashinfo);
1da177e4 1883EXPORT_SYMBOL(tcp_prot);
1da177e4
LT
1884EXPORT_SYMBOL(tcp_unhash);
1885EXPORT_SYMBOL(tcp_v4_conn_request);
1886EXPORT_SYMBOL(tcp_v4_connect);
1887EXPORT_SYMBOL(tcp_v4_do_rcv);
1da177e4
LT
1888EXPORT_SYMBOL(tcp_v4_remember_stamp);
1889EXPORT_SYMBOL(tcp_v4_send_check);
1890EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
1891
1892#ifdef CONFIG_PROC_FS
1893EXPORT_SYMBOL(tcp_proc_register);
1894EXPORT_SYMBOL(tcp_proc_unregister);
1895#endif
1896EXPORT_SYMBOL(sysctl_local_port_range);
1da177e4 1897EXPORT_SYMBOL(sysctl_tcp_low_latency);
1da177e4 1898