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