]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - net/ipv4/tcp_ipv4.c
[CONNECTOR]: Fix compilation breakage introduced recently.
[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
cfb6eeb4
YH
81#include <linux/crypto.h>
82#include <linux/scatterlist.h>
83
ab32ea5d
BH
84int sysctl_tcp_tw_reuse __read_mostly;
85int sysctl_tcp_low_latency __read_mostly;
1da177e4
LT
86
87/* Check TCP sequence numbers in ICMP packets. */
88#define ICMP_MIN_LENGTH 8
89
90/* Socket used for sending RSTs */
91static struct socket *tcp_socket;
92
8292a17a 93void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb);
1da177e4 94
cfb6eeb4 95#ifdef CONFIG_TCP_MD5SIG
7174259e
ACM
96static struct tcp_md5sig_key *tcp_v4_md5_do_lookup(struct sock *sk,
97 __be32 addr);
cfb6eeb4 98static int tcp_v4_do_calc_md5_hash(char *md5_hash, struct tcp_md5sig_key *key,
7174259e
ACM
99 __be32 saddr, __be32 daddr,
100 struct tcphdr *th, int protocol,
101 int tcplen);
cfb6eeb4
YH
102#endif
103
0f7ff927 104struct inet_hashinfo __cacheline_aligned tcp_hashinfo = {
7174259e
ACM
105 .lhash_lock = __RW_LOCK_UNLOCKED(tcp_hashinfo.lhash_lock),
106 .lhash_users = ATOMIC_INIT(0),
107 .lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(tcp_hashinfo.lhash_wait),
1da177e4
LT
108};
109
463c84b9
ACM
110static int tcp_v4_get_port(struct sock *sk, unsigned short snum)
111{
971af18b
ACM
112 return inet_csk_get_port(&tcp_hashinfo, sk, snum,
113 inet_csk_bind_conflict);
463c84b9
ACM
114}
115
1da177e4
LT
116static void tcp_v4_hash(struct sock *sk)
117{
81849d10 118 inet_hash(&tcp_hashinfo, sk);
1da177e4
LT
119}
120
121void tcp_unhash(struct sock *sk)
122{
81849d10 123 inet_unhash(&tcp_hashinfo, sk);
1da177e4
LT
124}
125
a94f723d 126static inline __u32 tcp_v4_init_sequence(struct sk_buff *skb)
1da177e4
LT
127{
128 return secure_tcp_sequence_number(skb->nh.iph->daddr,
129 skb->nh.iph->saddr,
130 skb->h.th->dest,
131 skb->h.th->source);
132}
133
6d6ee43e
ACM
134int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
135{
136 const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
137 struct tcp_sock *tp = tcp_sk(sk);
138
139 /* With PAWS, it is safe from the viewpoint
140 of data integrity. Even without PAWS it is safe provided sequence
141 spaces do not overlap i.e. at data rates <= 80Mbit/sec.
142
143 Actually, the idea is close to VJ's one, only timestamp cache is
144 held not per host, but per port pair and TW bucket is used as state
145 holder.
146
147 If TW bucket has been already destroyed we fall back to VJ's scheme
148 and use initial timestamp retrieved from peer table.
149 */
150 if (tcptw->tw_ts_recent_stamp &&
151 (twp == NULL || (sysctl_tcp_tw_reuse &&
152 xtime.tv_sec - tcptw->tw_ts_recent_stamp > 1))) {
153 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
154 if (tp->write_seq == 0)
155 tp->write_seq = 1;
156 tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
157 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
158 sock_hold(sktw);
159 return 1;
160 }
161
162 return 0;
163}
164
165EXPORT_SYMBOL_GPL(tcp_twsk_unique);
166
1da177e4
LT
167/* This will initiate an outgoing connection. */
168int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
169{
170 struct inet_sock *inet = inet_sk(sk);
171 struct tcp_sock *tp = tcp_sk(sk);
172 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
173 struct rtable *rt;
bada8adc 174 __be32 daddr, nexthop;
1da177e4
LT
175 int tmp;
176 int err;
177
178 if (addr_len < sizeof(struct sockaddr_in))
179 return -EINVAL;
180
181 if (usin->sin_family != AF_INET)
182 return -EAFNOSUPPORT;
183
184 nexthop = daddr = usin->sin_addr.s_addr;
185 if (inet->opt && inet->opt->srr) {
186 if (!daddr)
187 return -EINVAL;
188 nexthop = inet->opt->faddr;
189 }
190
191 tmp = ip_route_connect(&rt, nexthop, inet->saddr,
192 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
193 IPPROTO_TCP,
194 inet->sport, usin->sin_port, sk);
195 if (tmp < 0)
196 return tmp;
197
198 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
199 ip_rt_put(rt);
200 return -ENETUNREACH;
201 }
202
203 if (!inet->opt || !inet->opt->srr)
204 daddr = rt->rt_dst;
205
206 if (!inet->saddr)
207 inet->saddr = rt->rt_src;
208 inet->rcv_saddr = inet->saddr;
209
210 if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) {
211 /* Reset inherited state */
212 tp->rx_opt.ts_recent = 0;
213 tp->rx_opt.ts_recent_stamp = 0;
214 tp->write_seq = 0;
215 }
216
295ff7ed 217 if (tcp_death_row.sysctl_tw_recycle &&
1da177e4
LT
218 !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
219 struct inet_peer *peer = rt_get_peer(rt);
7174259e
ACM
220 /*
221 * VJ's idea. We save last timestamp seen from
222 * the destination in peer table, when entering state
223 * TIME-WAIT * and initialize rx_opt.ts_recent from it,
224 * when trying new connection.
1da177e4 225 */
7174259e
ACM
226 if (peer != NULL &&
227 peer->tcp_ts_stamp + TCP_PAWS_MSL >= xtime.tv_sec) {
1da177e4
LT
228 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
229 tp->rx_opt.ts_recent = peer->tcp_ts;
230 }
231 }
232
233 inet->dport = usin->sin_port;
234 inet->daddr = daddr;
235
d83d8461 236 inet_csk(sk)->icsk_ext_hdr_len = 0;
1da177e4 237 if (inet->opt)
d83d8461 238 inet_csk(sk)->icsk_ext_hdr_len = inet->opt->optlen;
1da177e4
LT
239
240 tp->rx_opt.mss_clamp = 536;
241
242 /* Socket identity is still unknown (sport may be zero).
243 * However we set state to SYN-SENT and not releasing socket
244 * lock select source port, enter ourselves into the hash tables and
245 * complete initialization after this.
246 */
247 tcp_set_state(sk, TCP_SYN_SENT);
a7f5e7f1 248 err = inet_hash_connect(&tcp_death_row, sk);
1da177e4
LT
249 if (err)
250 goto failure;
251
7174259e
ACM
252 err = ip_route_newports(&rt, IPPROTO_TCP,
253 inet->sport, inet->dport, sk);
1da177e4
LT
254 if (err)
255 goto failure;
256
257 /* OK, now commit destination to socket. */
bcd76111 258 sk->sk_gso_type = SKB_GSO_TCPV4;
6cbb0df7 259 sk_setup_caps(sk, &rt->u.dst);
1da177e4
LT
260
261 if (!tp->write_seq)
262 tp->write_seq = secure_tcp_sequence_number(inet->saddr,
263 inet->daddr,
264 inet->sport,
265 usin->sin_port);
266
267 inet->id = tp->write_seq ^ jiffies;
268
269 err = tcp_connect(sk);
270 rt = NULL;
271 if (err)
272 goto failure;
273
274 return 0;
275
276failure:
7174259e
ACM
277 /*
278 * This unhashes the socket and releases the local port,
279 * if necessary.
280 */
1da177e4
LT
281 tcp_set_state(sk, TCP_CLOSE);
282 ip_rt_put(rt);
283 sk->sk_route_caps = 0;
284 inet->dport = 0;
285 return err;
286}
287
1da177e4
LT
288/*
289 * This routine does path mtu discovery as defined in RFC1191.
290 */
40efc6fa 291static void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, u32 mtu)
1da177e4
LT
292{
293 struct dst_entry *dst;
294 struct inet_sock *inet = inet_sk(sk);
1da177e4
LT
295
296 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
297 * send out by Linux are always <576bytes so they should go through
298 * unfragmented).
299 */
300 if (sk->sk_state == TCP_LISTEN)
301 return;
302
303 /* We don't check in the destentry if pmtu discovery is forbidden
304 * on this route. We just assume that no packet_to_big packets
305 * are send back when pmtu discovery is not active.
306 * There is a small race when the user changes this flag in the
307 * route, but I think that's acceptable.
308 */
309 if ((dst = __sk_dst_check(sk, 0)) == NULL)
310 return;
311
312 dst->ops->update_pmtu(dst, mtu);
313
314 /* Something is about to be wrong... Remember soft error
315 * for the case, if this connection will not able to recover.
316 */
317 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
318 sk->sk_err_soft = EMSGSIZE;
319
320 mtu = dst_mtu(dst);
321
322 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
d83d8461 323 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
1da177e4
LT
324 tcp_sync_mss(sk, mtu);
325
326 /* Resend the TCP packet because it's
327 * clear that the old packet has been
328 * dropped. This is the new "fast" path mtu
329 * discovery.
330 */
331 tcp_simple_retransmit(sk);
332 } /* else let the usual retransmit timer handle it */
333}
334
335/*
336 * This routine is called by the ICMP module when it gets some
337 * sort of error condition. If err < 0 then the socket should
338 * be closed and the error returned to the user. If err > 0
339 * it's just the icmp type << 8 | icmp code. After adjustment
340 * header points to the first 8 bytes of the tcp header. We need
341 * to find the appropriate port.
342 *
343 * The locking strategy used here is very "optimistic". When
344 * someone else accesses the socket the ICMP is just dropped
345 * and for some paths there is no check at all.
346 * A more general error queue to queue errors for later handling
347 * is probably better.
348 *
349 */
350
351void tcp_v4_err(struct sk_buff *skb, u32 info)
352{
353 struct iphdr *iph = (struct iphdr *)skb->data;
354 struct tcphdr *th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
355 struct tcp_sock *tp;
356 struct inet_sock *inet;
357 int type = skb->h.icmph->type;
358 int code = skb->h.icmph->code;
359 struct sock *sk;
360 __u32 seq;
361 int err;
362
363 if (skb->len < (iph->ihl << 2) + 8) {
364 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
365 return;
366 }
367
e48c414e 368 sk = inet_lookup(&tcp_hashinfo, iph->daddr, th->dest, iph->saddr,
463c84b9 369 th->source, inet_iif(skb));
1da177e4
LT
370 if (!sk) {
371 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
372 return;
373 }
374 if (sk->sk_state == TCP_TIME_WAIT) {
9469c7b4 375 inet_twsk_put(inet_twsk(sk));
1da177e4
LT
376 return;
377 }
378
379 bh_lock_sock(sk);
380 /* If too many ICMPs get dropped on busy
381 * servers this needs to be solved differently.
382 */
383 if (sock_owned_by_user(sk))
384 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
385
386 if (sk->sk_state == TCP_CLOSE)
387 goto out;
388
389 tp = tcp_sk(sk);
390 seq = ntohl(th->seq);
391 if (sk->sk_state != TCP_LISTEN &&
392 !between(seq, tp->snd_una, tp->snd_nxt)) {
06ca719f 393 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
1da177e4
LT
394 goto out;
395 }
396
397 switch (type) {
398 case ICMP_SOURCE_QUENCH:
399 /* Just silently ignore these. */
400 goto out;
401 case ICMP_PARAMETERPROB:
402 err = EPROTO;
403 break;
404 case ICMP_DEST_UNREACH:
405 if (code > NR_ICMP_UNREACH)
406 goto out;
407
408 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
409 if (!sock_owned_by_user(sk))
410 do_pmtu_discovery(sk, iph, info);
411 goto out;
412 }
413
414 err = icmp_err_convert[code].errno;
415 break;
416 case ICMP_TIME_EXCEEDED:
417 err = EHOSTUNREACH;
418 break;
419 default:
420 goto out;
421 }
422
423 switch (sk->sk_state) {
60236fdd 424 struct request_sock *req, **prev;
1da177e4
LT
425 case TCP_LISTEN:
426 if (sock_owned_by_user(sk))
427 goto out;
428
463c84b9
ACM
429 req = inet_csk_search_req(sk, &prev, th->dest,
430 iph->daddr, iph->saddr);
1da177e4
LT
431 if (!req)
432 goto out;
433
434 /* ICMPs are not backlogged, hence we cannot get
435 an established socket here.
436 */
437 BUG_TRAP(!req->sk);
438
2e6599cb 439 if (seq != tcp_rsk(req)->snt_isn) {
1da177e4
LT
440 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
441 goto out;
442 }
443
444 /*
445 * Still in SYN_RECV, just remove it silently.
446 * There is no good way to pass the error to the newly
447 * created socket, and POSIX does not want network
448 * errors returned from accept().
449 */
463c84b9 450 inet_csk_reqsk_queue_drop(sk, req, prev);
1da177e4
LT
451 goto out;
452
453 case TCP_SYN_SENT:
454 case TCP_SYN_RECV: /* Cannot happen.
455 It can f.e. if SYNs crossed.
456 */
457 if (!sock_owned_by_user(sk)) {
1da177e4
LT
458 sk->sk_err = err;
459
460 sk->sk_error_report(sk);
461
462 tcp_done(sk);
463 } else {
464 sk->sk_err_soft = err;
465 }
466 goto out;
467 }
468
469 /* If we've already connected we will keep trying
470 * until we time out, or the user gives up.
471 *
472 * rfc1122 4.2.3.9 allows to consider as hard errors
473 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
474 * but it is obsoleted by pmtu discovery).
475 *
476 * Note, that in modern internet, where routing is unreliable
477 * and in each dark corner broken firewalls sit, sending random
478 * errors ordered by their masters even this two messages finally lose
479 * their original sense (even Linux sends invalid PORT_UNREACHs)
480 *
481 * Now we are in compliance with RFCs.
482 * --ANK (980905)
483 */
484
485 inet = inet_sk(sk);
486 if (!sock_owned_by_user(sk) && inet->recverr) {
487 sk->sk_err = err;
488 sk->sk_error_report(sk);
489 } else { /* Only an error on timeout */
490 sk->sk_err_soft = err;
491 }
492
493out:
494 bh_unlock_sock(sk);
495 sock_put(sk);
496}
497
498/* This routine computes an IPv4 TCP checksum. */
8292a17a 499void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb)
1da177e4
LT
500{
501 struct inet_sock *inet = inet_sk(sk);
8292a17a 502 struct tcphdr *th = skb->h.th;
1da177e4 503
84fa7933 504 if (skb->ip_summed == CHECKSUM_PARTIAL) {
7174259e
ACM
505 th->check = ~tcp_v4_check(th, len,
506 inet->saddr, inet->daddr, 0);
ff1dcadb 507 skb->csum_offset = offsetof(struct tcphdr, check);
1da177e4
LT
508 } else {
509 th->check = tcp_v4_check(th, len, inet->saddr, inet->daddr,
510 csum_partial((char *)th,
511 th->doff << 2,
512 skb->csum));
513 }
514}
515
a430a43d
HX
516int tcp_v4_gso_send_check(struct sk_buff *skb)
517{
518 struct iphdr *iph;
519 struct tcphdr *th;
520
521 if (!pskb_may_pull(skb, sizeof(*th)))
522 return -EINVAL;
523
524 iph = skb->nh.iph;
525 th = skb->h.th;
526
527 th->check = 0;
528 th->check = ~tcp_v4_check(th, skb->len, iph->saddr, iph->daddr, 0);
ff1dcadb 529 skb->csum_offset = offsetof(struct tcphdr, check);
84fa7933 530 skb->ip_summed = CHECKSUM_PARTIAL;
a430a43d
HX
531 return 0;
532}
533
1da177e4
LT
534/*
535 * This routine will send an RST to the other tcp.
536 *
537 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
538 * for reset.
539 * Answer: if a packet caused RST, it is not for a socket
540 * existing in our system, if it is matched to a socket,
541 * it is just duplicate segment or bug in other side's TCP.
542 * So that we build reply only basing on parameters
543 * arrived with segment.
544 * Exception: precedence violation. We do not implement it in any case.
545 */
546
cfb6eeb4 547static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb)
1da177e4
LT
548{
549 struct tcphdr *th = skb->h.th;
cfb6eeb4
YH
550 struct {
551 struct tcphdr th;
552#ifdef CONFIG_TCP_MD5SIG
714e85be 553 __be32 opt[(TCPOLEN_MD5SIG_ALIGNED >> 2)];
cfb6eeb4
YH
554#endif
555 } rep;
1da177e4 556 struct ip_reply_arg arg;
cfb6eeb4
YH
557#ifdef CONFIG_TCP_MD5SIG
558 struct tcp_md5sig_key *key;
559#endif
1da177e4
LT
560
561 /* Never send a reset in response to a reset. */
562 if (th->rst)
563 return;
564
565 if (((struct rtable *)skb->dst)->rt_type != RTN_LOCAL)
566 return;
567
568 /* Swap the send and the receive. */
cfb6eeb4
YH
569 memset(&rep, 0, sizeof(rep));
570 rep.th.dest = th->source;
571 rep.th.source = th->dest;
572 rep.th.doff = sizeof(struct tcphdr) / 4;
573 rep.th.rst = 1;
1da177e4
LT
574
575 if (th->ack) {
cfb6eeb4 576 rep.th.seq = th->ack_seq;
1da177e4 577 } else {
cfb6eeb4
YH
578 rep.th.ack = 1;
579 rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
580 skb->len - (th->doff << 2));
1da177e4
LT
581 }
582
7174259e 583 memset(&arg, 0, sizeof(arg));
cfb6eeb4
YH
584 arg.iov[0].iov_base = (unsigned char *)&rep;
585 arg.iov[0].iov_len = sizeof(rep.th);
586
587#ifdef CONFIG_TCP_MD5SIG
588 key = sk ? tcp_v4_md5_do_lookup(sk, skb->nh.iph->daddr) : NULL;
589 if (key) {
590 rep.opt[0] = htonl((TCPOPT_NOP << 24) |
591 (TCPOPT_NOP << 16) |
592 (TCPOPT_MD5SIG << 8) |
593 TCPOLEN_MD5SIG);
594 /* Update length and the length the header thinks exists */
595 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
596 rep.th.doff = arg.iov[0].iov_len / 4;
597
598 tcp_v4_do_calc_md5_hash((__u8 *)&rep.opt[1],
599 key,
600 skb->nh.iph->daddr,
601 skb->nh.iph->saddr,
602 &rep.th, IPPROTO_TCP,
603 arg.iov[0].iov_len);
604 }
605#endif
1da177e4 606 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
7174259e 607 skb->nh.iph->saddr, /* XXX */
1da177e4
LT
608 sizeof(struct tcphdr), IPPROTO_TCP, 0);
609 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
610
cfb6eeb4 611 ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len);
1da177e4
LT
612
613 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
614 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
615}
616
617/* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
618 outside socket context is ugly, certainly. What can I do?
619 */
620
cfb6eeb4
YH
621static void tcp_v4_send_ack(struct tcp_timewait_sock *twsk,
622 struct sk_buff *skb, u32 seq, u32 ack,
1da177e4
LT
623 u32 win, u32 ts)
624{
625 struct tcphdr *th = skb->h.th;
626 struct {
627 struct tcphdr th;
714e85be 628 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
cfb6eeb4 629#ifdef CONFIG_TCP_MD5SIG
714e85be 630 + (TCPOLEN_MD5SIG_ALIGNED >> 2)
cfb6eeb4
YH
631#endif
632 ];
1da177e4
LT
633 } rep;
634 struct ip_reply_arg arg;
cfb6eeb4
YH
635#ifdef CONFIG_TCP_MD5SIG
636 struct tcp_md5sig_key *key;
637 struct tcp_md5sig_key tw_key;
638#endif
1da177e4
LT
639
640 memset(&rep.th, 0, sizeof(struct tcphdr));
7174259e 641 memset(&arg, 0, sizeof(arg));
1da177e4
LT
642
643 arg.iov[0].iov_base = (unsigned char *)&rep;
644 arg.iov[0].iov_len = sizeof(rep.th);
645 if (ts) {
cfb6eeb4
YH
646 rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
647 (TCPOPT_TIMESTAMP << 8) |
648 TCPOLEN_TIMESTAMP);
649 rep.opt[1] = htonl(tcp_time_stamp);
650 rep.opt[2] = htonl(ts);
651 arg.iov[0].iov_len = TCPOLEN_TSTAMP_ALIGNED;
1da177e4
LT
652 }
653
654 /* Swap the send and the receive. */
655 rep.th.dest = th->source;
656 rep.th.source = th->dest;
657 rep.th.doff = arg.iov[0].iov_len / 4;
658 rep.th.seq = htonl(seq);
659 rep.th.ack_seq = htonl(ack);
660 rep.th.ack = 1;
661 rep.th.window = htons(win);
662
cfb6eeb4
YH
663#ifdef CONFIG_TCP_MD5SIG
664 /*
665 * The SKB holds an imcoming packet, but may not have a valid ->sk
666 * pointer. This is especially the case when we're dealing with a
667 * TIME_WAIT ack, because the sk structure is long gone, and only
668 * the tcp_timewait_sock remains. So the md5 key is stashed in that
669 * structure, and we use it in preference. I believe that (twsk ||
670 * skb->sk) holds true, but we program defensively.
671 */
672 if (!twsk && skb->sk) {
673 key = tcp_v4_md5_do_lookup(skb->sk, skb->nh.iph->daddr);
674 } else if (twsk && twsk->tw_md5_keylen) {
675 tw_key.key = twsk->tw_md5_key;
676 tw_key.keylen = twsk->tw_md5_keylen;
677 key = &tw_key;
7174259e 678 } else
cfb6eeb4 679 key = NULL;
cfb6eeb4
YH
680
681 if (key) {
682 int offset = (ts) ? 3 : 0;
683
684 rep.opt[offset++] = htonl((TCPOPT_NOP << 24) |
685 (TCPOPT_NOP << 16) |
686 (TCPOPT_MD5SIG << 8) |
687 TCPOLEN_MD5SIG);
688 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
689 rep.th.doff = arg.iov[0].iov_len/4;
690
691 tcp_v4_do_calc_md5_hash((__u8 *)&rep.opt[offset],
692 key,
693 skb->nh.iph->daddr,
694 skb->nh.iph->saddr,
695 &rep.th, IPPROTO_TCP,
696 arg.iov[0].iov_len);
697 }
698#endif
1da177e4 699 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
7174259e 700 skb->nh.iph->saddr, /* XXX */
1da177e4
LT
701 arg.iov[0].iov_len, IPPROTO_TCP, 0);
702 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
703
704 ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len);
705
706 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
707}
708
709static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
710{
8feaf0c0 711 struct inet_timewait_sock *tw = inet_twsk(sk);
cfb6eeb4 712 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
1da177e4 713
cfb6eeb4 714 tcp_v4_send_ack(tcptw, skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
7174259e
ACM
715 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
716 tcptw->tw_ts_recent);
1da177e4 717
8feaf0c0 718 inet_twsk_put(tw);
1da177e4
LT
719}
720
7174259e
ACM
721static void tcp_v4_reqsk_send_ack(struct sk_buff *skb,
722 struct request_sock *req)
1da177e4 723{
cfb6eeb4
YH
724 tcp_v4_send_ack(NULL, skb, tcp_rsk(req)->snt_isn + 1,
725 tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
1da177e4
LT
726 req->ts_recent);
727}
728
1da177e4
LT
729/*
730 * Send a SYN-ACK after having received an ACK.
60236fdd 731 * This still operates on a request_sock only, not on a big
1da177e4
LT
732 * socket.
733 */
60236fdd 734static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
1da177e4
LT
735 struct dst_entry *dst)
736{
2e6599cb 737 const struct inet_request_sock *ireq = inet_rsk(req);
1da177e4
LT
738 int err = -1;
739 struct sk_buff * skb;
740
741 /* First, grab a route. */
463c84b9 742 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
1da177e4
LT
743 goto out;
744
745 skb = tcp_make_synack(sk, dst, req);
746
747 if (skb) {
748 struct tcphdr *th = skb->h.th;
749
750 th->check = tcp_v4_check(th, skb->len,
2e6599cb
ACM
751 ireq->loc_addr,
752 ireq->rmt_addr,
1da177e4
LT
753 csum_partial((char *)th, skb->len,
754 skb->csum));
755
2e6599cb
ACM
756 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
757 ireq->rmt_addr,
758 ireq->opt);
b9df3cb8 759 err = net_xmit_eval(err);
1da177e4
LT
760 }
761
762out:
763 dst_release(dst);
764 return err;
765}
766
767/*
60236fdd 768 * IPv4 request_sock destructor.
1da177e4 769 */
60236fdd 770static void tcp_v4_reqsk_destructor(struct request_sock *req)
1da177e4 771{
a51482bd 772 kfree(inet_rsk(req)->opt);
1da177e4
LT
773}
774
80e40daa 775#ifdef CONFIG_SYN_COOKIES
40efc6fa 776static void syn_flood_warning(struct sk_buff *skb)
1da177e4
LT
777{
778 static unsigned long warntime;
779
780 if (time_after(jiffies, (warntime + HZ * 60))) {
781 warntime = jiffies;
782 printk(KERN_INFO
783 "possible SYN flooding on port %d. Sending cookies.\n",
784 ntohs(skb->h.th->dest));
785 }
786}
80e40daa 787#endif
1da177e4
LT
788
789/*
60236fdd 790 * Save and compile IPv4 options into the request_sock if needed.
1da177e4 791 */
40efc6fa
SH
792static struct ip_options *tcp_v4_save_options(struct sock *sk,
793 struct sk_buff *skb)
1da177e4
LT
794{
795 struct ip_options *opt = &(IPCB(skb)->opt);
796 struct ip_options *dopt = NULL;
797
798 if (opt && opt->optlen) {
799 int opt_size = optlength(opt);
800 dopt = kmalloc(opt_size, GFP_ATOMIC);
801 if (dopt) {
802 if (ip_options_echo(dopt, skb)) {
803 kfree(dopt);
804 dopt = NULL;
805 }
806 }
807 }
808 return dopt;
809}
810
cfb6eeb4
YH
811#ifdef CONFIG_TCP_MD5SIG
812/*
813 * RFC2385 MD5 checksumming requires a mapping of
814 * IP address->MD5 Key.
815 * We need to maintain these in the sk structure.
816 */
817
818/* Find the Key structure for an address. */
7174259e
ACM
819static struct tcp_md5sig_key *
820 tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr)
cfb6eeb4
YH
821{
822 struct tcp_sock *tp = tcp_sk(sk);
823 int i;
824
825 if (!tp->md5sig_info || !tp->md5sig_info->entries4)
826 return NULL;
827 for (i = 0; i < tp->md5sig_info->entries4; i++) {
828 if (tp->md5sig_info->keys4[i].addr == addr)
7174259e
ACM
829 return (struct tcp_md5sig_key *)
830 &tp->md5sig_info->keys4[i];
cfb6eeb4
YH
831 }
832 return NULL;
833}
834
835struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
836 struct sock *addr_sk)
837{
838 return tcp_v4_md5_do_lookup(sk, inet_sk(addr_sk)->daddr);
839}
840
841EXPORT_SYMBOL(tcp_v4_md5_lookup);
842
f5b99bcd
AB
843static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
844 struct request_sock *req)
cfb6eeb4
YH
845{
846 return tcp_v4_md5_do_lookup(sk, inet_rsk(req)->rmt_addr);
847}
848
849/* This can be called on a newly created socket, from other files */
850int tcp_v4_md5_do_add(struct sock *sk, __be32 addr,
851 u8 *newkey, u8 newkeylen)
852{
853 /* Add Key to the list */
854 struct tcp4_md5sig_key *key;
855 struct tcp_sock *tp = tcp_sk(sk);
856 struct tcp4_md5sig_key *keys;
857
f6685938 858 key = (struct tcp4_md5sig_key *)tcp_v4_md5_do_lookup(sk, addr);
cfb6eeb4
YH
859 if (key) {
860 /* Pre-existing entry - just update that one. */
f6685938 861 kfree(key->key);
cfb6eeb4
YH
862 key->key = newkey;
863 key->keylen = newkeylen;
864 } else {
f6685938
ACM
865 struct tcp_md5sig_info *md5sig;
866
cfb6eeb4 867 if (!tp->md5sig_info) {
f6685938
ACM
868 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info),
869 GFP_ATOMIC);
cfb6eeb4
YH
870 if (!tp->md5sig_info) {
871 kfree(newkey);
872 return -ENOMEM;
873 }
874 }
875 if (tcp_alloc_md5sig_pool() == NULL) {
876 kfree(newkey);
877 return -ENOMEM;
878 }
f6685938
ACM
879 md5sig = tp->md5sig_info;
880
881 if (md5sig->alloced4 == md5sig->entries4) {
882 keys = kmalloc((sizeof(*keys) *
883 (md5sig->entries4 + 1)), GFP_ATOMIC);
cfb6eeb4
YH
884 if (!keys) {
885 kfree(newkey);
886 tcp_free_md5sig_pool();
887 return -ENOMEM;
888 }
889
f6685938
ACM
890 if (md5sig->entries4)
891 memcpy(keys, md5sig->keys4,
892 sizeof(*keys) * md5sig->entries4);
cfb6eeb4
YH
893
894 /* Free old key list, and reference new one */
f6685938
ACM
895 if (md5sig->keys4)
896 kfree(md5sig->keys4);
897 md5sig->keys4 = keys;
898 md5sig->alloced4++;
cfb6eeb4 899 }
f6685938
ACM
900 md5sig->entries4++;
901 md5sig->keys4[md5sig->entries4 - 1].addr = addr;
902 md5sig->keys4[md5sig->entries4 - 1].key = newkey;
903 md5sig->keys4[md5sig->entries4 - 1].keylen = newkeylen;
cfb6eeb4
YH
904 }
905 return 0;
906}
907
908EXPORT_SYMBOL(tcp_v4_md5_do_add);
909
910static int tcp_v4_md5_add_func(struct sock *sk, struct sock *addr_sk,
911 u8 *newkey, u8 newkeylen)
912{
913 return tcp_v4_md5_do_add(sk, inet_sk(addr_sk)->daddr,
914 newkey, newkeylen);
915}
916
917int tcp_v4_md5_do_del(struct sock *sk, __be32 addr)
918{
919 struct tcp_sock *tp = tcp_sk(sk);
920 int i;
921
922 for (i = 0; i < tp->md5sig_info->entries4; i++) {
923 if (tp->md5sig_info->keys4[i].addr == addr) {
924 /* Free the key */
925 kfree(tp->md5sig_info->keys4[i].key);
926 tp->md5sig_info->entries4--;
927
928 if (tp->md5sig_info->entries4 == 0) {
929 kfree(tp->md5sig_info->keys4);
930 tp->md5sig_info->keys4 = NULL;
7174259e 931 } else if (tp->md5sig_info->entries4 != i) {
cfb6eeb4 932 /* Need to do some manipulation */
7174259e
ACM
933 memcpy(&tp->md5sig_info->keys4[i],
934 &tp->md5sig_info->keys4[i+1],
935 (tp->md5sig_info->entries4 - i) *
936 sizeof(struct tcp4_md5sig_key));
cfb6eeb4
YH
937 }
938 tcp_free_md5sig_pool();
939 return 0;
940 }
941 }
942 return -ENOENT;
943}
944
945EXPORT_SYMBOL(tcp_v4_md5_do_del);
946
7174259e 947static void tcp_v4_clear_md5_list(struct sock *sk)
cfb6eeb4
YH
948{
949 struct tcp_sock *tp = tcp_sk(sk);
950
951 /* Free each key, then the set of key keys,
952 * the crypto element, and then decrement our
953 * hold on the last resort crypto.
954 */
955 if (tp->md5sig_info->entries4) {
956 int i;
957 for (i = 0; i < tp->md5sig_info->entries4; i++)
958 kfree(tp->md5sig_info->keys4[i].key);
959 tp->md5sig_info->entries4 = 0;
960 tcp_free_md5sig_pool();
961 }
962 if (tp->md5sig_info->keys4) {
963 kfree(tp->md5sig_info->keys4);
964 tp->md5sig_info->keys4 = NULL;
965 tp->md5sig_info->alloced4 = 0;
966 }
967}
968
7174259e
ACM
969static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
970 int optlen)
cfb6eeb4
YH
971{
972 struct tcp_md5sig cmd;
973 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
974 u8 *newkey;
975
976 if (optlen < sizeof(cmd))
977 return -EINVAL;
978
7174259e 979 if (copy_from_user(&cmd, optval, sizeof(cmd)))
cfb6eeb4
YH
980 return -EFAULT;
981
982 if (sin->sin_family != AF_INET)
983 return -EINVAL;
984
985 if (!cmd.tcpm_key || !cmd.tcpm_keylen) {
986 if (!tcp_sk(sk)->md5sig_info)
987 return -ENOENT;
988 return tcp_v4_md5_do_del(sk, sin->sin_addr.s_addr);
989 }
990
991 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
992 return -EINVAL;
993
994 if (!tcp_sk(sk)->md5sig_info) {
995 struct tcp_sock *tp = tcp_sk(sk);
7174259e 996 struct tcp_md5sig_info *p = kzalloc(sizeof(*p), GFP_KERNEL);
cfb6eeb4 997
cfb6eeb4
YH
998 if (!p)
999 return -EINVAL;
1000
1001 tp->md5sig_info = p;
1002
1003 }
1004
f6685938 1005 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
cfb6eeb4
YH
1006 if (!newkey)
1007 return -ENOMEM;
cfb6eeb4
YH
1008 return tcp_v4_md5_do_add(sk, sin->sin_addr.s_addr,
1009 newkey, cmd.tcpm_keylen);
1010}
1011
1012static int tcp_v4_do_calc_md5_hash(char *md5_hash, struct tcp_md5sig_key *key,
1013 __be32 saddr, __be32 daddr,
1014 struct tcphdr *th, int protocol,
1015 int tcplen)
1016{
1017 struct scatterlist sg[4];
1018 __u16 data_len;
1019 int block = 0;
8e5200f5 1020 __sum16 old_checksum;
cfb6eeb4
YH
1021 struct tcp_md5sig_pool *hp;
1022 struct tcp4_pseudohdr *bp;
1023 struct hash_desc *desc;
1024 int err;
1025 unsigned int nbytes = 0;
1026
1027 /*
1028 * Okay, so RFC2385 is turned on for this connection,
1029 * so we need to generate the MD5 hash for the packet now.
1030 */
1031
1032 hp = tcp_get_md5sig_pool();
1033 if (!hp)
1034 goto clear_hash_noput;
1035
1036 bp = &hp->md5_blk.ip4;
1037 desc = &hp->md5_desc;
1038
1039 /*
1040 * 1. the TCP pseudo-header (in the order: source IP address,
1041 * destination IP address, zero-padded protocol number, and
1042 * segment length)
1043 */
1044 bp->saddr = saddr;
1045 bp->daddr = daddr;
1046 bp->pad = 0;
1047 bp->protocol = protocol;
1048 bp->len = htons(tcplen);
1049 sg_set_buf(&sg[block++], bp, sizeof(*bp));
1050 nbytes += sizeof(*bp);
1051
cfb6eeb4
YH
1052 /* 2. the TCP header, excluding options, and assuming a
1053 * checksum of zero/
1054 */
1055 old_checksum = th->check;
1056 th->check = 0;
1057 sg_set_buf(&sg[block++], th, sizeof(struct tcphdr));
1058 nbytes += sizeof(struct tcphdr);
08dd1a50 1059
cfb6eeb4
YH
1060 /* 3. the TCP segment data (if any) */
1061 data_len = tcplen - (th->doff << 2);
1062 if (data_len > 0) {
1063 unsigned char *data = (unsigned char *)th + (th->doff << 2);
1064 sg_set_buf(&sg[block++], data, data_len);
1065 nbytes += data_len;
1066 }
1067
1068 /* 4. an independently-specified key or password, known to both
1069 * TCPs and presumably connection-specific
1070 */
1071 sg_set_buf(&sg[block++], key->key, key->keylen);
1072 nbytes += key->keylen;
1073
cfb6eeb4
YH
1074 /* Now store the Hash into the packet */
1075 err = crypto_hash_init(desc);
1076 if (err)
1077 goto clear_hash;
1078 err = crypto_hash_update(desc, sg, nbytes);
1079 if (err)
1080 goto clear_hash;
1081 err = crypto_hash_final(desc, md5_hash);
1082 if (err)
1083 goto clear_hash;
1084
1085 /* Reset header, and free up the crypto */
1086 tcp_put_md5sig_pool();
1087 th->check = old_checksum;
1088
1089out:
cfb6eeb4
YH
1090 return 0;
1091clear_hash:
1092 tcp_put_md5sig_pool();
1093clear_hash_noput:
1094 memset(md5_hash, 0, 16);
1095 goto out;
1096}
1097
1098int tcp_v4_calc_md5_hash(char *md5_hash, struct tcp_md5sig_key *key,
1099 struct sock *sk,
1100 struct dst_entry *dst,
1101 struct request_sock *req,
1102 struct tcphdr *th, int protocol,
1103 int tcplen)
1104{
1105 __be32 saddr, daddr;
1106
1107 if (sk) {
1108 saddr = inet_sk(sk)->saddr;
1109 daddr = inet_sk(sk)->daddr;
1110 } else {
1111 struct rtable *rt = (struct rtable *)dst;
1112 BUG_ON(!rt);
1113 saddr = rt->rt_src;
1114 daddr = rt->rt_dst;
1115 }
1116 return tcp_v4_do_calc_md5_hash(md5_hash, key,
1117 saddr, daddr,
1118 th, protocol, tcplen);
1119}
1120
1121EXPORT_SYMBOL(tcp_v4_calc_md5_hash);
1122
7174259e 1123static int tcp_v4_inbound_md5_hash(struct sock *sk, struct sk_buff *skb)
cfb6eeb4
YH
1124{
1125 /*
1126 * This gets called for each TCP segment that arrives
1127 * so we want to be efficient.
1128 * We have 3 drop cases:
1129 * o No MD5 hash and one expected.
1130 * o MD5 hash and we're not expecting one.
1131 * o MD5 hash and its wrong.
1132 */
1133 __u8 *hash_location = NULL;
1134 struct tcp_md5sig_key *hash_expected;
1135 struct iphdr *iph = skb->nh.iph;
1136 struct tcphdr *th = skb->h.th;
7174259e 1137 int length = (th->doff << 2) - sizeof(struct tcphdr);
cfb6eeb4
YH
1138 int genhash;
1139 unsigned char *ptr;
1140 unsigned char newhash[16];
1141
1142 hash_expected = tcp_v4_md5_do_lookup(sk, iph->saddr);
1143
1144 /*
1145 * If the TCP option length is less than the TCP_MD5SIG
1146 * option length, then we can shortcut
1147 */
1148 if (length < TCPOLEN_MD5SIG) {
1149 if (hash_expected)
1150 return 1;
1151 else
1152 return 0;
1153 }
1154
1155 /* Okay, we can't shortcut - we have to grub through the options */
1156 ptr = (unsigned char *)(th + 1);
1157 while (length > 0) {
1158 int opcode = *ptr++;
1159 int opsize;
1160
1161 switch (opcode) {
1162 case TCPOPT_EOL:
1163 goto done_opts;
1164 case TCPOPT_NOP:
1165 length--;
1166 continue;
1167 default:
1168 opsize = *ptr++;
1169 if (opsize < 2)
1170 goto done_opts;
1171 if (opsize > length)
1172 goto done_opts;
1173
1174 if (opcode == TCPOPT_MD5SIG) {
1175 hash_location = ptr;
1176 goto done_opts;
1177 }
1178 }
1179 ptr += opsize-2;
1180 length -= opsize;
1181 }
1182done_opts:
1183 /* We've parsed the options - do we have a hash? */
1184 if (!hash_expected && !hash_location)
1185 return 0;
1186
1187 if (hash_expected && !hash_location) {
7174259e 1188 LIMIT_NETDEBUG(KERN_INFO "MD5 Hash NOT expected but found "
cfb6eeb4 1189 "(" NIPQUAD_FMT ", %d)->(" NIPQUAD_FMT ", %d)\n",
7174259e
ACM
1190 NIPQUAD(iph->saddr), ntohs(th->source),
1191 NIPQUAD(iph->daddr), ntohs(th->dest));
cfb6eeb4
YH
1192 return 1;
1193 }
1194
1195 if (!hash_expected && hash_location) {
7174259e 1196 LIMIT_NETDEBUG(KERN_INFO "MD5 Hash NOT expected but found "
cfb6eeb4 1197 "(" NIPQUAD_FMT ", %d)->(" NIPQUAD_FMT ", %d)\n",
7174259e
ACM
1198 NIPQUAD(iph->saddr), ntohs(th->source),
1199 NIPQUAD(iph->daddr), ntohs(th->dest));
cfb6eeb4
YH
1200 return 1;
1201 }
1202
1203 /* Okay, so this is hash_expected and hash_location -
1204 * so we need to calculate the checksum.
1205 */
1206 genhash = tcp_v4_do_calc_md5_hash(newhash,
1207 hash_expected,
1208 iph->saddr, iph->daddr,
1209 th, sk->sk_protocol,
1210 skb->len);
1211
1212 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
1213 if (net_ratelimit()) {
1214 printk(KERN_INFO "MD5 Hash failed for "
1215 "(" NIPQUAD_FMT ", %d)->(" NIPQUAD_FMT ", %d)%s\n",
7174259e
ACM
1216 NIPQUAD(iph->saddr), ntohs(th->source),
1217 NIPQUAD(iph->daddr), ntohs(th->dest),
cfb6eeb4 1218 genhash ? " tcp_v4_calc_md5_hash failed" : "");
cfb6eeb4
YH
1219 }
1220 return 1;
1221 }
1222 return 0;
1223}
1224
1225#endif
1226
72a3effa 1227struct request_sock_ops tcp_request_sock_ops __read_mostly = {
1da177e4 1228 .family = PF_INET,
2e6599cb 1229 .obj_size = sizeof(struct tcp_request_sock),
1da177e4 1230 .rtx_syn_ack = tcp_v4_send_synack,
60236fdd
ACM
1231 .send_ack = tcp_v4_reqsk_send_ack,
1232 .destructor = tcp_v4_reqsk_destructor,
1da177e4
LT
1233 .send_reset = tcp_v4_send_reset,
1234};
1235
cfb6eeb4 1236#ifdef CONFIG_TCP_MD5SIG
b6332e6c 1237static struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
cfb6eeb4 1238 .md5_lookup = tcp_v4_reqsk_md5_lookup,
cfb6eeb4 1239};
b6332e6c 1240#endif
cfb6eeb4 1241
6d6ee43e
ACM
1242static struct timewait_sock_ops tcp_timewait_sock_ops = {
1243 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
1244 .twsk_unique = tcp_twsk_unique,
cfb6eeb4 1245 .twsk_destructor= tcp_twsk_destructor,
6d6ee43e
ACM
1246};
1247
1da177e4
LT
1248int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1249{
2e6599cb 1250 struct inet_request_sock *ireq;
1da177e4 1251 struct tcp_options_received tmp_opt;
60236fdd 1252 struct request_sock *req;
adaf345b
AV
1253 __be32 saddr = skb->nh.iph->saddr;
1254 __be32 daddr = skb->nh.iph->daddr;
1da177e4
LT
1255 __u32 isn = TCP_SKB_CB(skb)->when;
1256 struct dst_entry *dst = NULL;
1257#ifdef CONFIG_SYN_COOKIES
1258 int want_cookie = 0;
1259#else
1260#define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
1261#endif
1262
1263 /* Never answer to SYNs send to broadcast or multicast */
1264 if (((struct rtable *)skb->dst)->rt_flags &
1265 (RTCF_BROADCAST | RTCF_MULTICAST))
1266 goto drop;
1267
1268 /* TW buckets are converted to open requests without
1269 * limitations, they conserve resources and peer is
1270 * evidently real one.
1271 */
463c84b9 1272 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
1da177e4
LT
1273#ifdef CONFIG_SYN_COOKIES
1274 if (sysctl_tcp_syncookies) {
1275 want_cookie = 1;
1276 } else
1277#endif
1278 goto drop;
1279 }
1280
1281 /* Accept backlog is full. If we have already queued enough
1282 * of warm entries in syn queue, drop request. It is better than
1283 * clogging syn queue with openreqs with exponentially increasing
1284 * timeout.
1285 */
463c84b9 1286 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
1da177e4
LT
1287 goto drop;
1288
60236fdd 1289 req = reqsk_alloc(&tcp_request_sock_ops);
1da177e4
LT
1290 if (!req)
1291 goto drop;
1292
cfb6eeb4
YH
1293#ifdef CONFIG_TCP_MD5SIG
1294 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops;
1295#endif
1296
1da177e4
LT
1297 tcp_clear_options(&tmp_opt);
1298 tmp_opt.mss_clamp = 536;
1299 tmp_opt.user_mss = tcp_sk(sk)->rx_opt.user_mss;
1300
1301 tcp_parse_options(skb, &tmp_opt, 0);
1302
1303 if (want_cookie) {
1304 tcp_clear_options(&tmp_opt);
1305 tmp_opt.saw_tstamp = 0;
1306 }
1307
1308 if (tmp_opt.saw_tstamp && !tmp_opt.rcv_tsval) {
1309 /* Some OSes (unknown ones, but I see them on web server, which
1310 * contains information interesting only for windows'
1311 * users) do not send their stamp in SYN. It is easy case.
1312 * We simply do not advertise TS support.
1313 */
1314 tmp_opt.saw_tstamp = 0;
1315 tmp_opt.tstamp_ok = 0;
1316 }
1317 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1318
1319 tcp_openreq_init(req, &tmp_opt, skb);
1320
4237c75c
VY
1321 if (security_inet_conn_request(sk, skb, req))
1322 goto drop_and_free;
1323
2e6599cb
ACM
1324 ireq = inet_rsk(req);
1325 ireq->loc_addr = daddr;
1326 ireq->rmt_addr = saddr;
1327 ireq->opt = tcp_v4_save_options(sk, skb);
1da177e4
LT
1328 if (!want_cookie)
1329 TCP_ECN_create_request(req, skb->h.th);
1330
1331 if (want_cookie) {
1332#ifdef CONFIG_SYN_COOKIES
1333 syn_flood_warning(skb);
1334#endif
1335 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
1336 } else if (!isn) {
1337 struct inet_peer *peer = NULL;
1338
1339 /* VJ's idea. We save last timestamp seen
1340 * from the destination in peer table, when entering
1341 * state TIME-WAIT, and check against it before
1342 * accepting new connection request.
1343 *
1344 * If "isn" is not zero, this request hit alive
1345 * timewait bucket, so that all the necessary checks
1346 * are made in the function processing timewait state.
1347 */
1348 if (tmp_opt.saw_tstamp &&
295ff7ed 1349 tcp_death_row.sysctl_tw_recycle &&
463c84b9 1350 (dst = inet_csk_route_req(sk, req)) != NULL &&
1da177e4
LT
1351 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
1352 peer->v4daddr == saddr) {
1353 if (xtime.tv_sec < peer->tcp_ts_stamp + TCP_PAWS_MSL &&
1354 (s32)(peer->tcp_ts - req->ts_recent) >
1355 TCP_PAWS_WINDOW) {
1356 NET_INC_STATS_BH(LINUX_MIB_PAWSPASSIVEREJECTED);
1357 dst_release(dst);
1358 goto drop_and_free;
1359 }
1360 }
1361 /* Kill the following clause, if you dislike this way. */
1362 else if (!sysctl_tcp_syncookies &&
463c84b9 1363 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
1da177e4
LT
1364 (sysctl_max_syn_backlog >> 2)) &&
1365 (!peer || !peer->tcp_ts_stamp) &&
1366 (!dst || !dst_metric(dst, RTAX_RTT))) {
1367 /* Without syncookies last quarter of
1368 * backlog is filled with destinations,
1369 * proven to be alive.
1370 * It means that we continue to communicate
1371 * to destinations, already remembered
1372 * to the moment of synflood.
1373 */
64ce2073
PM
1374 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open "
1375 "request from %u.%u.%u.%u/%u\n",
1376 NIPQUAD(saddr),
1377 ntohs(skb->h.th->source));
1da177e4
LT
1378 dst_release(dst);
1379 goto drop_and_free;
1380 }
1381
a94f723d 1382 isn = tcp_v4_init_sequence(skb);
1da177e4 1383 }
2e6599cb 1384 tcp_rsk(req)->snt_isn = isn;
1da177e4
LT
1385
1386 if (tcp_v4_send_synack(sk, req, dst))
1387 goto drop_and_free;
1388
1389 if (want_cookie) {
60236fdd 1390 reqsk_free(req);
1da177e4 1391 } else {
3f421baa 1392 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1da177e4
LT
1393 }
1394 return 0;
1395
1396drop_and_free:
60236fdd 1397 reqsk_free(req);
1da177e4 1398drop:
1da177e4
LT
1399 return 0;
1400}
1401
1402
1403/*
1404 * The three way handshake has completed - we got a valid synack -
1405 * now create the new socket.
1406 */
1407struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
60236fdd 1408 struct request_sock *req,
1da177e4
LT
1409 struct dst_entry *dst)
1410{
2e6599cb 1411 struct inet_request_sock *ireq;
1da177e4
LT
1412 struct inet_sock *newinet;
1413 struct tcp_sock *newtp;
1414 struct sock *newsk;
cfb6eeb4
YH
1415#ifdef CONFIG_TCP_MD5SIG
1416 struct tcp_md5sig_key *key;
1417#endif
1da177e4
LT
1418
1419 if (sk_acceptq_is_full(sk))
1420 goto exit_overflow;
1421
463c84b9 1422 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
1da177e4
LT
1423 goto exit;
1424
1425 newsk = tcp_create_openreq_child(sk, req, skb);
1426 if (!newsk)
1427 goto exit;
1428
bcd76111 1429 newsk->sk_gso_type = SKB_GSO_TCPV4;
6cbb0df7 1430 sk_setup_caps(newsk, dst);
1da177e4
LT
1431
1432 newtp = tcp_sk(newsk);
1433 newinet = inet_sk(newsk);
2e6599cb
ACM
1434 ireq = inet_rsk(req);
1435 newinet->daddr = ireq->rmt_addr;
1436 newinet->rcv_saddr = ireq->loc_addr;
1437 newinet->saddr = ireq->loc_addr;
1438 newinet->opt = ireq->opt;
1439 ireq->opt = NULL;
463c84b9 1440 newinet->mc_index = inet_iif(skb);
1da177e4 1441 newinet->mc_ttl = skb->nh.iph->ttl;
d83d8461 1442 inet_csk(newsk)->icsk_ext_hdr_len = 0;
1da177e4 1443 if (newinet->opt)
d83d8461 1444 inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
1da177e4
LT
1445 newinet->id = newtp->write_seq ^ jiffies;
1446
5d424d5a 1447 tcp_mtup_init(newsk);
1da177e4
LT
1448 tcp_sync_mss(newsk, dst_mtu(dst));
1449 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
1450 tcp_initialize_rcv_mss(newsk);
1451
cfb6eeb4
YH
1452#ifdef CONFIG_TCP_MD5SIG
1453 /* Copy over the MD5 key from the original socket */
1454 if ((key = tcp_v4_md5_do_lookup(sk, newinet->daddr)) != NULL) {
1455 /*
1456 * We're using one, so create a matching key
1457 * on the newsk structure. If we fail to get
1458 * memory, then we end up not copying the key
1459 * across. Shucks.
1460 */
f6685938
ACM
1461 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1462 if (newkey != NULL)
cfb6eeb4
YH
1463 tcp_v4_md5_do_add(newsk, inet_sk(sk)->daddr,
1464 newkey, key->keylen);
cfb6eeb4
YH
1465 }
1466#endif
1467
f3f05f70 1468 __inet_hash(&tcp_hashinfo, newsk, 0);
2d8c4ce5 1469 __inet_inherit_port(&tcp_hashinfo, sk, newsk);
1da177e4
LT
1470
1471 return newsk;
1472
1473exit_overflow:
1474 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
1475exit:
1476 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
1477 dst_release(dst);
1478 return NULL;
1479}
1480
1481static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1482{
1483 struct tcphdr *th = skb->h.th;
1484 struct iphdr *iph = skb->nh.iph;
1da177e4 1485 struct sock *nsk;
60236fdd 1486 struct request_sock **prev;
1da177e4 1487 /* Find possible connection requests. */
463c84b9
ACM
1488 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1489 iph->saddr, iph->daddr);
1da177e4
LT
1490 if (req)
1491 return tcp_check_req(sk, skb, req, prev);
1492
8f491069
HX
1493 nsk = inet_lookup_established(&tcp_hashinfo, skb->nh.iph->saddr,
1494 th->source, skb->nh.iph->daddr,
1495 th->dest, inet_iif(skb));
1da177e4
LT
1496
1497 if (nsk) {
1498 if (nsk->sk_state != TCP_TIME_WAIT) {
1499 bh_lock_sock(nsk);
1500 return nsk;
1501 }
9469c7b4 1502 inet_twsk_put(inet_twsk(nsk));
1da177e4
LT
1503 return NULL;
1504 }
1505
1506#ifdef CONFIG_SYN_COOKIES
1507 if (!th->rst && !th->syn && th->ack)
1508 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1509#endif
1510 return sk;
1511}
1512
b51655b9 1513static __sum16 tcp_v4_checksum_init(struct sk_buff *skb)
1da177e4 1514{
84fa7933 1515 if (skb->ip_summed == CHECKSUM_COMPLETE) {
1da177e4 1516 if (!tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
fb286bb2
HX
1517 skb->nh.iph->daddr, skb->csum)) {
1518 skb->ip_summed = CHECKSUM_UNNECESSARY;
1da177e4 1519 return 0;
fb286bb2 1520 }
1da177e4 1521 }
fb286bb2
HX
1522
1523 skb->csum = csum_tcpudp_nofold(skb->nh.iph->saddr, skb->nh.iph->daddr,
1524 skb->len, IPPROTO_TCP, 0);
1525
1da177e4 1526 if (skb->len <= 76) {
fb286bb2 1527 return __skb_checksum_complete(skb);
1da177e4
LT
1528 }
1529 return 0;
1530}
1531
1532
1533/* The socket must have it's spinlock held when we get
1534 * here.
1535 *
1536 * We have a potential double-lock case here, so even when
1537 * doing backlog processing we use the BH locking scheme.
1538 * This is because we cannot sleep with the original spinlock
1539 * held.
1540 */
1541int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1542{
cfb6eeb4
YH
1543 struct sock *rsk;
1544#ifdef CONFIG_TCP_MD5SIG
1545 /*
1546 * We really want to reject the packet as early as possible
1547 * if:
1548 * o We're expecting an MD5'd packet and this is no MD5 tcp option
1549 * o There is an MD5 option and we're not expecting one
1550 */
7174259e 1551 if (tcp_v4_inbound_md5_hash(sk, skb))
cfb6eeb4
YH
1552 goto discard;
1553#endif
1554
1da177e4
LT
1555 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1556 TCP_CHECK_TIMER(sk);
cfb6eeb4
YH
1557 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len)) {
1558 rsk = sk;
1da177e4 1559 goto reset;
cfb6eeb4 1560 }
1da177e4
LT
1561 TCP_CHECK_TIMER(sk);
1562 return 0;
1563 }
1564
1565 if (skb->len < (skb->h.th->doff << 2) || tcp_checksum_complete(skb))
1566 goto csum_err;
1567
1568 if (sk->sk_state == TCP_LISTEN) {
1569 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1570 if (!nsk)
1571 goto discard;
1572
1573 if (nsk != sk) {
cfb6eeb4
YH
1574 if (tcp_child_process(sk, nsk, skb)) {
1575 rsk = nsk;
1da177e4 1576 goto reset;
cfb6eeb4 1577 }
1da177e4
LT
1578 return 0;
1579 }
1580 }
1581
1582 TCP_CHECK_TIMER(sk);
cfb6eeb4
YH
1583 if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len)) {
1584 rsk = sk;
1da177e4 1585 goto reset;
cfb6eeb4 1586 }
1da177e4
LT
1587 TCP_CHECK_TIMER(sk);
1588 return 0;
1589
1590reset:
cfb6eeb4 1591 tcp_v4_send_reset(rsk, skb);
1da177e4
LT
1592discard:
1593 kfree_skb(skb);
1594 /* Be careful here. If this function gets more complicated and
1595 * gcc suffers from register pressure on the x86, sk (in %ebx)
1596 * might be destroyed here. This current version compiles correctly,
1597 * but you have been warned.
1598 */
1599 return 0;
1600
1601csum_err:
1602 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1603 goto discard;
1604}
1605
1606/*
1607 * From tcp_input.c
1608 */
1609
1610int tcp_v4_rcv(struct sk_buff *skb)
1611{
1612 struct tcphdr *th;
1613 struct sock *sk;
1614 int ret;
1615
1616 if (skb->pkt_type != PACKET_HOST)
1617 goto discard_it;
1618
1619 /* Count it even if it's bad */
1620 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1621
1622 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1623 goto discard_it;
1624
1625 th = skb->h.th;
1626
1627 if (th->doff < sizeof(struct tcphdr) / 4)
1628 goto bad_packet;
1629 if (!pskb_may_pull(skb, th->doff * 4))
1630 goto discard_it;
1631
1632 /* An explanation is required here, I think.
1633 * Packet length and doff are validated by header prediction,
caa20d9a 1634 * provided case of th->doff==0 is eliminated.
1da177e4
LT
1635 * So, we defer the checks. */
1636 if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
fb286bb2 1637 tcp_v4_checksum_init(skb)))
1da177e4
LT
1638 goto bad_packet;
1639
1640 th = skb->h.th;
1641 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1642 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1643 skb->len - th->doff * 4);
1644 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1645 TCP_SKB_CB(skb)->when = 0;
1646 TCP_SKB_CB(skb)->flags = skb->nh.iph->tos;
1647 TCP_SKB_CB(skb)->sacked = 0;
1648
e48c414e 1649 sk = __inet_lookup(&tcp_hashinfo, skb->nh.iph->saddr, th->source,
8f491069 1650 skb->nh.iph->daddr, th->dest,
463c84b9 1651 inet_iif(skb));
1da177e4
LT
1652
1653 if (!sk)
1654 goto no_tcp_socket;
1655
1656process:
1657 if (sk->sk_state == TCP_TIME_WAIT)
1658 goto do_time_wait;
1659
1660 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1661 goto discard_and_relse;
b59c2701 1662 nf_reset(skb);
1da177e4 1663
fda9ef5d 1664 if (sk_filter(sk, skb))
1da177e4
LT
1665 goto discard_and_relse;
1666
1667 skb->dev = NULL;
1668
c6366184 1669 bh_lock_sock_nested(sk);
1da177e4
LT
1670 ret = 0;
1671 if (!sock_owned_by_user(sk)) {
1a2449a8
CL
1672#ifdef CONFIG_NET_DMA
1673 struct tcp_sock *tp = tcp_sk(sk);
1674 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1675 tp->ucopy.dma_chan = get_softnet_dma();
1676 if (tp->ucopy.dma_chan)
1da177e4 1677 ret = tcp_v4_do_rcv(sk, skb);
1a2449a8
CL
1678 else
1679#endif
1680 {
1681 if (!tcp_prequeue(sk, skb))
1682 ret = tcp_v4_do_rcv(sk, skb);
1683 }
1da177e4
LT
1684 } else
1685 sk_add_backlog(sk, skb);
1686 bh_unlock_sock(sk);
1687
1688 sock_put(sk);
1689
1690 return ret;
1691
1692no_tcp_socket:
1693 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1694 goto discard_it;
1695
1696 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1697bad_packet:
1698 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1699 } else {
cfb6eeb4 1700 tcp_v4_send_reset(NULL, skb);
1da177e4
LT
1701 }
1702
1703discard_it:
1704 /* Discard frame. */
1705 kfree_skb(skb);
1706 return 0;
1707
1708discard_and_relse:
1709 sock_put(sk);
1710 goto discard_it;
1711
1712do_time_wait:
1713 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
9469c7b4 1714 inet_twsk_put(inet_twsk(sk));
1da177e4
LT
1715 goto discard_it;
1716 }
1717
1718 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1719 TCP_INC_STATS_BH(TCP_MIB_INERRS);
9469c7b4 1720 inet_twsk_put(inet_twsk(sk));
1da177e4
LT
1721 goto discard_it;
1722 }
9469c7b4 1723 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
1da177e4 1724 case TCP_TW_SYN: {
33b62231
ACM
1725 struct sock *sk2 = inet_lookup_listener(&tcp_hashinfo,
1726 skb->nh.iph->daddr,
8f491069 1727 th->dest,
463c84b9 1728 inet_iif(skb));
1da177e4 1729 if (sk2) {
9469c7b4
YH
1730 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
1731 inet_twsk_put(inet_twsk(sk));
1da177e4
LT
1732 sk = sk2;
1733 goto process;
1734 }
1735 /* Fall through to ACK */
1736 }
1737 case TCP_TW_ACK:
1738 tcp_v4_timewait_ack(sk, skb);
1739 break;
1740 case TCP_TW_RST:
1741 goto no_tcp_socket;
1742 case TCP_TW_SUCCESS:;
1743 }
1744 goto discard_it;
1745}
1746
1da177e4
LT
1747/* VJ's idea. Save last timestamp seen from this destination
1748 * and hold it at least for normal timewait interval to use for duplicate
1749 * segment detection in subsequent connections, before they enter synchronized
1750 * state.
1751 */
1752
1753int tcp_v4_remember_stamp(struct sock *sk)
1754{
1755 struct inet_sock *inet = inet_sk(sk);
1756 struct tcp_sock *tp = tcp_sk(sk);
1757 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1758 struct inet_peer *peer = NULL;
1759 int release_it = 0;
1760
1761 if (!rt || rt->rt_dst != inet->daddr) {
1762 peer = inet_getpeer(inet->daddr, 1);
1763 release_it = 1;
1764 } else {
1765 if (!rt->peer)
1766 rt_bind_peer(rt, 1);
1767 peer = rt->peer;
1768 }
1769
1770 if (peer) {
1771 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
1772 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1773 peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {
1774 peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;
1775 peer->tcp_ts = tp->rx_opt.ts_recent;
1776 }
1777 if (release_it)
1778 inet_putpeer(peer);
1779 return 1;
1780 }
1781
1782 return 0;
1783}
1784
8feaf0c0 1785int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
1da177e4 1786{
8feaf0c0 1787 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
1da177e4
LT
1788
1789 if (peer) {
8feaf0c0
ACM
1790 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1791
1792 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
1da177e4 1793 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
8feaf0c0
ACM
1794 peer->tcp_ts_stamp <= tcptw->tw_ts_recent_stamp)) {
1795 peer->tcp_ts_stamp = tcptw->tw_ts_recent_stamp;
1796 peer->tcp_ts = tcptw->tw_ts_recent;
1da177e4
LT
1797 }
1798 inet_putpeer(peer);
1799 return 1;
1800 }
1801
1802 return 0;
1803}
1804
8292a17a 1805struct inet_connection_sock_af_ops ipv4_specific = {
543d9cfe
ACM
1806 .queue_xmit = ip_queue_xmit,
1807 .send_check = tcp_v4_send_check,
1808 .rebuild_header = inet_sk_rebuild_header,
1809 .conn_request = tcp_v4_conn_request,
1810 .syn_recv_sock = tcp_v4_syn_recv_sock,
1811 .remember_stamp = tcp_v4_remember_stamp,
1812 .net_header_len = sizeof(struct iphdr),
1813 .setsockopt = ip_setsockopt,
1814 .getsockopt = ip_getsockopt,
1815 .addr2sockaddr = inet_csk_addr2sockaddr,
1816 .sockaddr_len = sizeof(struct sockaddr_in),
3fdadf7d 1817#ifdef CONFIG_COMPAT
543d9cfe
ACM
1818 .compat_setsockopt = compat_ip_setsockopt,
1819 .compat_getsockopt = compat_ip_getsockopt,
3fdadf7d 1820#endif
1da177e4
LT
1821};
1822
cfb6eeb4 1823#ifdef CONFIG_TCP_MD5SIG
b6332e6c 1824static struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
cfb6eeb4
YH
1825 .md5_lookup = tcp_v4_md5_lookup,
1826 .calc_md5_hash = tcp_v4_calc_md5_hash,
1827 .md5_add = tcp_v4_md5_add_func,
1828 .md5_parse = tcp_v4_parse_md5_keys,
cfb6eeb4 1829};
b6332e6c 1830#endif
cfb6eeb4 1831
1da177e4
LT
1832/* NOTE: A lot of things set to zero explicitly by call to
1833 * sk_alloc() so need not be done here.
1834 */
1835static int tcp_v4_init_sock(struct sock *sk)
1836{
6687e988 1837 struct inet_connection_sock *icsk = inet_csk(sk);
1da177e4
LT
1838 struct tcp_sock *tp = tcp_sk(sk);
1839
1840 skb_queue_head_init(&tp->out_of_order_queue);
1841 tcp_init_xmit_timers(sk);
1842 tcp_prequeue_init(tp);
1843
6687e988 1844 icsk->icsk_rto = TCP_TIMEOUT_INIT;
1da177e4
LT
1845 tp->mdev = TCP_TIMEOUT_INIT;
1846
1847 /* So many TCP implementations out there (incorrectly) count the
1848 * initial SYN frame in their delayed-ACK and congestion control
1849 * algorithms that we must have the following bandaid to talk
1850 * efficiently to them. -DaveM
1851 */
1852 tp->snd_cwnd = 2;
1853
1854 /* See draft-stevens-tcpca-spec-01 for discussion of the
1855 * initialization of these values.
1856 */
1857 tp->snd_ssthresh = 0x7fffffff; /* Infinity */
1858 tp->snd_cwnd_clamp = ~0;
c1b4a7e6 1859 tp->mss_cache = 536;
1da177e4
LT
1860
1861 tp->reordering = sysctl_tcp_reordering;
6687e988 1862 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
1da177e4
LT
1863
1864 sk->sk_state = TCP_CLOSE;
1865
1866 sk->sk_write_space = sk_stream_write_space;
1867 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1868
8292a17a 1869 icsk->icsk_af_ops = &ipv4_specific;
d83d8461 1870 icsk->icsk_sync_mss = tcp_sync_mss;
cfb6eeb4
YH
1871#ifdef CONFIG_TCP_MD5SIG
1872 tp->af_specific = &tcp_sock_ipv4_specific;
1873#endif
1da177e4
LT
1874
1875 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1876 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1877
1878 atomic_inc(&tcp_sockets_allocated);
1879
1880 return 0;
1881}
1882
1883int tcp_v4_destroy_sock(struct sock *sk)
1884{
1885 struct tcp_sock *tp = tcp_sk(sk);
1886
1887 tcp_clear_xmit_timers(sk);
1888
6687e988 1889 tcp_cleanup_congestion_control(sk);
317a76f9 1890
1da177e4
LT
1891 /* Cleanup up the write buffer. */
1892 sk_stream_writequeue_purge(sk);
1893
1894 /* Cleans up our, hopefully empty, out_of_order_queue. */
1895 __skb_queue_purge(&tp->out_of_order_queue);
1896
cfb6eeb4
YH
1897#ifdef CONFIG_TCP_MD5SIG
1898 /* Clean up the MD5 key list, if any */
1899 if (tp->md5sig_info) {
1900 tcp_v4_clear_md5_list(sk);
1901 kfree(tp->md5sig_info);
1902 tp->md5sig_info = NULL;
1903 }
1904#endif
1905
1a2449a8
CL
1906#ifdef CONFIG_NET_DMA
1907 /* Cleans up our sk_async_wait_queue */
1908 __skb_queue_purge(&sk->sk_async_wait_queue);
1909#endif
1910
1da177e4
LT
1911 /* Clean prequeue, it must be empty really */
1912 __skb_queue_purge(&tp->ucopy.prequeue);
1913
1914 /* Clean up a referenced TCP bind bucket. */
463c84b9 1915 if (inet_csk(sk)->icsk_bind_hash)
2d8c4ce5 1916 inet_put_port(&tcp_hashinfo, sk);
1da177e4
LT
1917
1918 /*
1919 * If sendmsg cached page exists, toss it.
1920 */
1921 if (sk->sk_sndmsg_page) {
1922 __free_page(sk->sk_sndmsg_page);
1923 sk->sk_sndmsg_page = NULL;
1924 }
1925
1926 atomic_dec(&tcp_sockets_allocated);
1927
1928 return 0;
1929}
1930
1931EXPORT_SYMBOL(tcp_v4_destroy_sock);
1932
1933#ifdef CONFIG_PROC_FS
1934/* Proc filesystem TCP sock list dumping. */
1935
8feaf0c0 1936static inline struct inet_timewait_sock *tw_head(struct hlist_head *head)
1da177e4
LT
1937{
1938 return hlist_empty(head) ? NULL :
8feaf0c0 1939 list_entry(head->first, struct inet_timewait_sock, tw_node);
1da177e4
LT
1940}
1941
8feaf0c0 1942static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
1da177e4
LT
1943{
1944 return tw->tw_node.next ?
1945 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
1946}
1947
1948static void *listening_get_next(struct seq_file *seq, void *cur)
1949{
463c84b9 1950 struct inet_connection_sock *icsk;
1da177e4
LT
1951 struct hlist_node *node;
1952 struct sock *sk = cur;
1953 struct tcp_iter_state* st = seq->private;
1954
1955 if (!sk) {
1956 st->bucket = 0;
6e04e021 1957 sk = sk_head(&tcp_hashinfo.listening_hash[0]);
1da177e4
LT
1958 goto get_sk;
1959 }
1960
1961 ++st->num;
1962
1963 if (st->state == TCP_SEQ_STATE_OPENREQ) {
60236fdd 1964 struct request_sock *req = cur;
1da177e4 1965
72a3effa 1966 icsk = inet_csk(st->syn_wait_sk);
1da177e4
LT
1967 req = req->dl_next;
1968 while (1) {
1969 while (req) {
60236fdd 1970 if (req->rsk_ops->family == st->family) {
1da177e4
LT
1971 cur = req;
1972 goto out;
1973 }
1974 req = req->dl_next;
1975 }
72a3effa 1976 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
1da177e4
LT
1977 break;
1978get_req:
463c84b9 1979 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
1da177e4
LT
1980 }
1981 sk = sk_next(st->syn_wait_sk);
1982 st->state = TCP_SEQ_STATE_LISTENING;
463c84b9 1983 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1da177e4 1984 } else {
463c84b9
ACM
1985 icsk = inet_csk(sk);
1986 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1987 if (reqsk_queue_len(&icsk->icsk_accept_queue))
1da177e4 1988 goto start_req;
463c84b9 1989 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1da177e4
LT
1990 sk = sk_next(sk);
1991 }
1992get_sk:
1993 sk_for_each_from(sk, node) {
1994 if (sk->sk_family == st->family) {
1995 cur = sk;
1996 goto out;
1997 }
463c84b9
ACM
1998 icsk = inet_csk(sk);
1999 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2000 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
1da177e4
LT
2001start_req:
2002 st->uid = sock_i_uid(sk);
2003 st->syn_wait_sk = sk;
2004 st->state = TCP_SEQ_STATE_OPENREQ;
2005 st->sbucket = 0;
2006 goto get_req;
2007 }
463c84b9 2008 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1da177e4 2009 }
0f7ff927 2010 if (++st->bucket < INET_LHTABLE_SIZE) {
6e04e021 2011 sk = sk_head(&tcp_hashinfo.listening_hash[st->bucket]);
1da177e4
LT
2012 goto get_sk;
2013 }
2014 cur = NULL;
2015out:
2016 return cur;
2017}
2018
2019static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
2020{
2021 void *rc = listening_get_next(seq, NULL);
2022
2023 while (rc && *pos) {
2024 rc = listening_get_next(seq, rc);
2025 --*pos;
2026 }
2027 return rc;
2028}
2029
2030static void *established_get_first(struct seq_file *seq)
2031{
2032 struct tcp_iter_state* st = seq->private;
2033 void *rc = NULL;
2034
6e04e021 2035 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
1da177e4
LT
2036 struct sock *sk;
2037 struct hlist_node *node;
8feaf0c0 2038 struct inet_timewait_sock *tw;
1da177e4
LT
2039
2040 /* We can reschedule _before_ having picked the target: */
2041 cond_resched_softirq();
2042
6e04e021
ACM
2043 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
2044 sk_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
1da177e4
LT
2045 if (sk->sk_family != st->family) {
2046 continue;
2047 }
2048 rc = sk;
2049 goto out;
2050 }
2051 st->state = TCP_SEQ_STATE_TIME_WAIT;
8feaf0c0
ACM
2052 inet_twsk_for_each(tw, node,
2053 &tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain) {
1da177e4
LT
2054 if (tw->tw_family != st->family) {
2055 continue;
2056 }
2057 rc = tw;
2058 goto out;
2059 }
6e04e021 2060 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1da177e4
LT
2061 st->state = TCP_SEQ_STATE_ESTABLISHED;
2062 }
2063out:
2064 return rc;
2065}
2066
2067static void *established_get_next(struct seq_file *seq, void *cur)
2068{
2069 struct sock *sk = cur;
8feaf0c0 2070 struct inet_timewait_sock *tw;
1da177e4
LT
2071 struct hlist_node *node;
2072 struct tcp_iter_state* st = seq->private;
2073
2074 ++st->num;
2075
2076 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2077 tw = cur;
2078 tw = tw_next(tw);
2079get_tw:
2080 while (tw && tw->tw_family != st->family) {
2081 tw = tw_next(tw);
2082 }
2083 if (tw) {
2084 cur = tw;
2085 goto out;
2086 }
6e04e021 2087 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1da177e4
LT
2088 st->state = TCP_SEQ_STATE_ESTABLISHED;
2089
2090 /* We can reschedule between buckets: */
2091 cond_resched_softirq();
2092
6e04e021
ACM
2093 if (++st->bucket < tcp_hashinfo.ehash_size) {
2094 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
2095 sk = sk_head(&tcp_hashinfo.ehash[st->bucket].chain);
1da177e4
LT
2096 } else {
2097 cur = NULL;
2098 goto out;
2099 }
2100 } else
2101 sk = sk_next(sk);
2102
2103 sk_for_each_from(sk, node) {
2104 if (sk->sk_family == st->family)
2105 goto found;
2106 }
2107
2108 st->state = TCP_SEQ_STATE_TIME_WAIT;
6e04e021 2109 tw = tw_head(&tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain);
1da177e4
LT
2110 goto get_tw;
2111found:
2112 cur = sk;
2113out:
2114 return cur;
2115}
2116
2117static void *established_get_idx(struct seq_file *seq, loff_t pos)
2118{
2119 void *rc = established_get_first(seq);
2120
2121 while (rc && pos) {
2122 rc = established_get_next(seq, rc);
2123 --pos;
7174259e 2124 }
1da177e4
LT
2125 return rc;
2126}
2127
2128static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2129{
2130 void *rc;
2131 struct tcp_iter_state* st = seq->private;
2132
f3f05f70 2133 inet_listen_lock(&tcp_hashinfo);
1da177e4
LT
2134 st->state = TCP_SEQ_STATE_LISTENING;
2135 rc = listening_get_idx(seq, &pos);
2136
2137 if (!rc) {
f3f05f70 2138 inet_listen_unlock(&tcp_hashinfo);
1da177e4
LT
2139 local_bh_disable();
2140 st->state = TCP_SEQ_STATE_ESTABLISHED;
2141 rc = established_get_idx(seq, pos);
2142 }
2143
2144 return rc;
2145}
2146
2147static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2148{
2149 struct tcp_iter_state* st = seq->private;
2150 st->state = TCP_SEQ_STATE_LISTENING;
2151 st->num = 0;
2152 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2153}
2154
2155static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2156{
2157 void *rc = NULL;
2158 struct tcp_iter_state* st;
2159
2160 if (v == SEQ_START_TOKEN) {
2161 rc = tcp_get_idx(seq, 0);
2162 goto out;
2163 }
2164 st = seq->private;
2165
2166 switch (st->state) {
2167 case TCP_SEQ_STATE_OPENREQ:
2168 case TCP_SEQ_STATE_LISTENING:
2169 rc = listening_get_next(seq, v);
2170 if (!rc) {
f3f05f70 2171 inet_listen_unlock(&tcp_hashinfo);
1da177e4
LT
2172 local_bh_disable();
2173 st->state = TCP_SEQ_STATE_ESTABLISHED;
2174 rc = established_get_first(seq);
2175 }
2176 break;
2177 case TCP_SEQ_STATE_ESTABLISHED:
2178 case TCP_SEQ_STATE_TIME_WAIT:
2179 rc = established_get_next(seq, v);
2180 break;
2181 }
2182out:
2183 ++*pos;
2184 return rc;
2185}
2186
2187static void tcp_seq_stop(struct seq_file *seq, void *v)
2188{
2189 struct tcp_iter_state* st = seq->private;
2190
2191 switch (st->state) {
2192 case TCP_SEQ_STATE_OPENREQ:
2193 if (v) {
463c84b9
ACM
2194 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2195 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1da177e4
LT
2196 }
2197 case TCP_SEQ_STATE_LISTENING:
2198 if (v != SEQ_START_TOKEN)
f3f05f70 2199 inet_listen_unlock(&tcp_hashinfo);
1da177e4
LT
2200 break;
2201 case TCP_SEQ_STATE_TIME_WAIT:
2202 case TCP_SEQ_STATE_ESTABLISHED:
2203 if (v)
6e04e021 2204 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1da177e4
LT
2205 local_bh_enable();
2206 break;
2207 }
2208}
2209
2210static int tcp_seq_open(struct inode *inode, struct file *file)
2211{
2212 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
2213 struct seq_file *seq;
2214 struct tcp_iter_state *s;
2215 int rc;
2216
2217 if (unlikely(afinfo == NULL))
2218 return -EINVAL;
2219
0da974f4 2220 s = kzalloc(sizeof(*s), GFP_KERNEL);
1da177e4
LT
2221 if (!s)
2222 return -ENOMEM;
1da177e4
LT
2223 s->family = afinfo->family;
2224 s->seq_ops.start = tcp_seq_start;
2225 s->seq_ops.next = tcp_seq_next;
2226 s->seq_ops.show = afinfo->seq_show;
2227 s->seq_ops.stop = tcp_seq_stop;
2228
2229 rc = seq_open(file, &s->seq_ops);
2230 if (rc)
2231 goto out_kfree;
2232 seq = file->private_data;
2233 seq->private = s;
2234out:
2235 return rc;
2236out_kfree:
2237 kfree(s);
2238 goto out;
2239}
2240
2241int tcp_proc_register(struct tcp_seq_afinfo *afinfo)
2242{
2243 int rc = 0;
2244 struct proc_dir_entry *p;
2245
2246 if (!afinfo)
2247 return -EINVAL;
2248 afinfo->seq_fops->owner = afinfo->owner;
2249 afinfo->seq_fops->open = tcp_seq_open;
2250 afinfo->seq_fops->read = seq_read;
2251 afinfo->seq_fops->llseek = seq_lseek;
2252 afinfo->seq_fops->release = seq_release_private;
7174259e 2253
1da177e4
LT
2254 p = proc_net_fops_create(afinfo->name, S_IRUGO, afinfo->seq_fops);
2255 if (p)
2256 p->data = afinfo;
2257 else
2258 rc = -ENOMEM;
2259 return rc;
2260}
2261
2262void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo)
2263{
2264 if (!afinfo)
2265 return;
2266 proc_net_remove(afinfo->name);
7174259e 2267 memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops));
1da177e4
LT
2268}
2269
60236fdd 2270static void get_openreq4(struct sock *sk, struct request_sock *req,
1da177e4
LT
2271 char *tmpbuf, int i, int uid)
2272{
2e6599cb 2273 const struct inet_request_sock *ireq = inet_rsk(req);
1da177e4
LT
2274 int ttd = req->expires - jiffies;
2275
2276 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
2277 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p",
2278 i,
2e6599cb 2279 ireq->loc_addr,
1da177e4 2280 ntohs(inet_sk(sk)->sport),
2e6599cb
ACM
2281 ireq->rmt_addr,
2282 ntohs(ireq->rmt_port),
1da177e4
LT
2283 TCP_SYN_RECV,
2284 0, 0, /* could print option size, but that is af dependent. */
2285 1, /* timers active (only the expire timer) */
2286 jiffies_to_clock_t(ttd),
2287 req->retrans,
2288 uid,
2289 0, /* non standard timer */
2290 0, /* open_requests have no inode */
2291 atomic_read(&sk->sk_refcnt),
2292 req);
2293}
2294
2295static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i)
2296{
2297 int timer_active;
2298 unsigned long timer_expires;
2299 struct tcp_sock *tp = tcp_sk(sp);
463c84b9 2300 const struct inet_connection_sock *icsk = inet_csk(sp);
1da177e4 2301 struct inet_sock *inet = inet_sk(sp);
714e85be
AV
2302 __be32 dest = inet->daddr;
2303 __be32 src = inet->rcv_saddr;
1da177e4
LT
2304 __u16 destp = ntohs(inet->dport);
2305 __u16 srcp = ntohs(inet->sport);
2306
463c84b9 2307 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
1da177e4 2308 timer_active = 1;
463c84b9
ACM
2309 timer_expires = icsk->icsk_timeout;
2310 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
1da177e4 2311 timer_active = 4;
463c84b9 2312 timer_expires = icsk->icsk_timeout;
1da177e4
LT
2313 } else if (timer_pending(&sp->sk_timer)) {
2314 timer_active = 2;
2315 timer_expires = sp->sk_timer.expires;
2316 } else {
2317 timer_active = 0;
2318 timer_expires = jiffies;
2319 }
2320
2321 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
2322 "%08X %5d %8d %lu %d %p %u %u %u %u %d",
2323 i, src, srcp, dest, destp, sp->sk_state,
47da8ee6 2324 tp->write_seq - tp->snd_una,
7174259e
ACM
2325 sp->sk_state == TCP_LISTEN ? sp->sk_ack_backlog :
2326 (tp->rcv_nxt - tp->copied_seq),
1da177e4
LT
2327 timer_active,
2328 jiffies_to_clock_t(timer_expires - jiffies),
463c84b9 2329 icsk->icsk_retransmits,
1da177e4 2330 sock_i_uid(sp),
6687e988 2331 icsk->icsk_probes_out,
1da177e4
LT
2332 sock_i_ino(sp),
2333 atomic_read(&sp->sk_refcnt), sp,
463c84b9
ACM
2334 icsk->icsk_rto,
2335 icsk->icsk_ack.ato,
2336 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
1da177e4
LT
2337 tp->snd_cwnd,
2338 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh);
2339}
2340
7174259e
ACM
2341static void get_timewait4_sock(struct inet_timewait_sock *tw,
2342 char *tmpbuf, int i)
1da177e4 2343{
23f33c2d 2344 __be32 dest, src;
1da177e4
LT
2345 __u16 destp, srcp;
2346 int ttd = tw->tw_ttd - jiffies;
2347
2348 if (ttd < 0)
2349 ttd = 0;
2350
2351 dest = tw->tw_daddr;
2352 src = tw->tw_rcv_saddr;
2353 destp = ntohs(tw->tw_dport);
2354 srcp = ntohs(tw->tw_sport);
2355
2356 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
2357 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p",
2358 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2359 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2360 atomic_read(&tw->tw_refcnt), tw);
2361}
2362
2363#define TMPSZ 150
2364
2365static int tcp4_seq_show(struct seq_file *seq, void *v)
2366{
2367 struct tcp_iter_state* st;
2368 char tmpbuf[TMPSZ + 1];
2369
2370 if (v == SEQ_START_TOKEN) {
2371 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2372 " sl local_address rem_address st tx_queue "
2373 "rx_queue tr tm->when retrnsmt uid timeout "
2374 "inode");
2375 goto out;
2376 }
2377 st = seq->private;
2378
2379 switch (st->state) {
2380 case TCP_SEQ_STATE_LISTENING:
2381 case TCP_SEQ_STATE_ESTABLISHED:
2382 get_tcp4_sock(v, tmpbuf, st->num);
2383 break;
2384 case TCP_SEQ_STATE_OPENREQ:
2385 get_openreq4(st->syn_wait_sk, v, tmpbuf, st->num, st->uid);
2386 break;
2387 case TCP_SEQ_STATE_TIME_WAIT:
2388 get_timewait4_sock(v, tmpbuf, st->num);
2389 break;
2390 }
2391 seq_printf(seq, "%-*s\n", TMPSZ - 1, tmpbuf);
2392out:
2393 return 0;
2394}
2395
2396static struct file_operations tcp4_seq_fops;
2397static struct tcp_seq_afinfo tcp4_seq_afinfo = {
2398 .owner = THIS_MODULE,
2399 .name = "tcp",
2400 .family = AF_INET,
2401 .seq_show = tcp4_seq_show,
2402 .seq_fops = &tcp4_seq_fops,
2403};
2404
2405int __init tcp4_proc_init(void)
2406{
2407 return tcp_proc_register(&tcp4_seq_afinfo);
2408}
2409
2410void tcp4_proc_exit(void)
2411{
2412 tcp_proc_unregister(&tcp4_seq_afinfo);
2413}
2414#endif /* CONFIG_PROC_FS */
2415
2416struct proto tcp_prot = {
2417 .name = "TCP",
2418 .owner = THIS_MODULE,
2419 .close = tcp_close,
2420 .connect = tcp_v4_connect,
2421 .disconnect = tcp_disconnect,
463c84b9 2422 .accept = inet_csk_accept,
1da177e4
LT
2423 .ioctl = tcp_ioctl,
2424 .init = tcp_v4_init_sock,
2425 .destroy = tcp_v4_destroy_sock,
2426 .shutdown = tcp_shutdown,
2427 .setsockopt = tcp_setsockopt,
2428 .getsockopt = tcp_getsockopt,
2429 .sendmsg = tcp_sendmsg,
2430 .recvmsg = tcp_recvmsg,
2431 .backlog_rcv = tcp_v4_do_rcv,
2432 .hash = tcp_v4_hash,
2433 .unhash = tcp_unhash,
2434 .get_port = tcp_v4_get_port,
2435 .enter_memory_pressure = tcp_enter_memory_pressure,
2436 .sockets_allocated = &tcp_sockets_allocated,
0a5578cf 2437 .orphan_count = &tcp_orphan_count,
1da177e4
LT
2438 .memory_allocated = &tcp_memory_allocated,
2439 .memory_pressure = &tcp_memory_pressure,
2440 .sysctl_mem = sysctl_tcp_mem,
2441 .sysctl_wmem = sysctl_tcp_wmem,
2442 .sysctl_rmem = sysctl_tcp_rmem,
2443 .max_header = MAX_TCP_HEADER,
2444 .obj_size = sizeof(struct tcp_sock),
6d6ee43e 2445 .twsk_prot = &tcp_timewait_sock_ops,
60236fdd 2446 .rsk_prot = &tcp_request_sock_ops,
543d9cfe
ACM
2447#ifdef CONFIG_COMPAT
2448 .compat_setsockopt = compat_tcp_setsockopt,
2449 .compat_getsockopt = compat_tcp_getsockopt,
2450#endif
1da177e4
LT
2451};
2452
1da177e4
LT
2453void __init tcp_v4_init(struct net_proto_family *ops)
2454{
7174259e
ACM
2455 if (inet_csk_ctl_sock_create(&tcp_socket, PF_INET, SOCK_RAW,
2456 IPPROTO_TCP) < 0)
1da177e4 2457 panic("Failed to create the TCP control socket.\n");
1da177e4
LT
2458}
2459
2460EXPORT_SYMBOL(ipv4_specific);
1da177e4 2461EXPORT_SYMBOL(tcp_hashinfo);
1da177e4 2462EXPORT_SYMBOL(tcp_prot);
1da177e4
LT
2463EXPORT_SYMBOL(tcp_unhash);
2464EXPORT_SYMBOL(tcp_v4_conn_request);
2465EXPORT_SYMBOL(tcp_v4_connect);
2466EXPORT_SYMBOL(tcp_v4_do_rcv);
1da177e4
LT
2467EXPORT_SYMBOL(tcp_v4_remember_stamp);
2468EXPORT_SYMBOL(tcp_v4_send_check);
2469EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
2470
2471#ifdef CONFIG_PROC_FS
2472EXPORT_SYMBOL(tcp_proc_register);
2473EXPORT_SYMBOL(tcp_proc_unregister);
2474#endif
2475EXPORT_SYMBOL(sysctl_local_port_range);
1da177e4 2476EXPORT_SYMBOL(sysctl_tcp_low_latency);
1da177e4 2477