?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
jbd: Journal block numbers can ever be only 32-bit use unsigned int for them
[linux/fpc-iii.git] / net / ipv4 / tcp_ipv4.c
blob0543561da9992125fa2afe24312c78ddf6f88cbb
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 * 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
37 * request_sock handling and moved
38 * most of it into the af independent code.
39 * Added tail drop and some other bugfixes.
40 * Added new listen semantics.
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
53
54 #include <linux/bottom_half.h>
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
64 #include <net/net_namespace.h>
65 #include <net/icmp.h>
66 #include <net/inet_hashtables.h>
67 #include <net/tcp.h>
68 #include <net/transp_v6.h>
69 #include <net/ipv6.h>
70 #include <net/inet_common.h>
71 #include <net/timewait_sock.h>
72 #include <net/xfrm.h>
73 #include <net/netdma.h>
74
75 #include <linux/inet.h>
76 #include <linux/ipv6.h>
77 #include <linux/stddef.h>
78 #include <linux/proc_fs.h>
79 #include <linux/seq_file.h>
80
81 #include <linux/crypto.h>
82 #include <linux/scatterlist.h>
83
84 int sysctl_tcp_tw_reuse __read_mostly;
85 int sysctl_tcp_low_latency __read_mostly;
86
87
88 #ifdef CONFIG_TCP_MD5SIG
89 static struct tcp_md5sig_key *tcp_v4_md5_do_lookup(struct sock *sk,
90 __be32 addr);
91 static int tcp_v4_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
92 __be32 daddr, __be32 saddr, struct tcphdr *th);
93 #else
94 static inline
95 struct tcp_md5sig_key *tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr)
96 {
97 return NULL;
98 }
99 #endif
100
101 struct inet_hashinfo tcp_hashinfo;
102
103 static inline __u32 tcp_v4_init_sequence(struct sk_buff *skb)
104 {
105 return secure_tcp_sequence_number(ip_hdr(skb)->daddr,
106 ip_hdr(skb)->saddr,
107 tcp_hdr(skb)->dest,
108 tcp_hdr(skb)->source);
109 }
110
111 int 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 &&
129 get_seconds() - tcptw->tw_ts_recent_stamp > 1))) {
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
142 EXPORT_SYMBOL_GPL(tcp_twsk_unique);
143
144 /* This will initiate an outgoing connection. */
145 int 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;
151 __be32 daddr, nexthop;
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,
171 inet->sport, usin->sin_port, sk, 1);
172 if (tmp < 0) {
173 if (tmp == -ENETUNREACH)
174 IP_INC_STATS_BH(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
175 return tmp;
176 }
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
197 if (tcp_death_row.sysctl_tw_recycle &&
198 !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
199 struct inet_peer *peer = rt_get_peer(rt);
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.
205 */
206 if (peer != NULL &&
207 peer->tcp_ts_stamp + TCP_PAWS_MSL >= get_seconds()) {
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
216 inet_csk(sk)->icsk_ext_hdr_len = 0;
217 if (inet->opt)
218 inet_csk(sk)->icsk_ext_hdr_len = inet->opt->optlen;
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);
228 err = inet_hash_connect(&tcp_death_row, sk);
229 if (err)
230 goto failure;
231
232 err = ip_route_newports(&rt, IPPROTO_TCP,
233 inet->sport, inet->dport, sk);
234 if (err)
235 goto failure;
236
237 /* OK, now commit destination to socket. */
238 sk->sk_gso_type = SKB_GSO_TCPV4;
239 sk_setup_caps(sk, &rt->u.dst);
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
256 failure:
257 /*
258 * This unhashes the socket and releases the local port,
259 * if necessary.
260 */
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
268 /*
269 * This routine does path mtu discovery as defined in RFC1191.
270 */
271 static void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, u32 mtu)
272 {
273 struct dst_entry *dst;
274 struct inet_sock *inet = inet_sk(sk);
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.
286 * There is a small race when the user changes this flag in the
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 &&
303 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
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
331 void tcp_v4_err(struct sk_buff *icmp_skb, u32 info)
332 {
333 struct iphdr *iph = (struct iphdr *)icmp_skb->data;
334 struct tcphdr *th = (struct tcphdr *)(icmp_skb->data + (iph->ihl << 2));
335 struct inet_connection_sock *icsk;
336 struct tcp_sock *tp;
337 struct inet_sock *inet;
338 const int type = icmp_hdr(icmp_skb)->type;
339 const int code = icmp_hdr(icmp_skb)->code;
340 struct sock *sk;
341 struct sk_buff *skb;
342 __u32 seq;
343 __u32 remaining;
344 int err;
345 struct net *net = dev_net(icmp_skb->dev);
346
347 if (icmp_skb->len < (iph->ihl << 2) + 8) {
348 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
349 return;
350 }
351
352 sk = inet_lookup(net, &tcp_hashinfo, iph->daddr, th->dest,
353 iph->saddr, th->source, inet_iif(icmp_skb));
354 if (!sk) {
355 ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
356 return;
357 }
358 if (sk->sk_state == TCP_TIME_WAIT) {
359 inet_twsk_put(inet_twsk(sk));
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))
368 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
369
370 if (sk->sk_state == TCP_CLOSE)
371 goto out;
372
373 icsk = inet_csk(sk);
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)) {
378 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
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;
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
433 break;
434 case ICMP_TIME_EXCEEDED:
435 err = EHOSTUNREACH;
436 break;
437 default:
438 goto out;
439 }
440
441 switch (sk->sk_state) {
442 struct request_sock *req, **prev;
443 case TCP_LISTEN:
444 if (sock_owned_by_user(sk))
445 goto out;
446
447 req = inet_csk_search_req(sk, &prev, th->dest,
448 iph->daddr, iph->saddr);
449 if (!req)
450 goto out;
451
452 /* ICMPs are not backlogged, hence we cannot get
453 an established socket here.
454 */
455 WARN_ON(req->sk);
456
457 if (seq != tcp_rsk(req)->snt_isn) {
458 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
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 */
468 inet_csk_reqsk_queue_drop(sk, req, prev);
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)) {
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
511 out:
512 bh_unlock_sock(sk);
513 sock_put(sk);
514 }
515
516 /* This routine computes an IPv4 TCP checksum. */
517 void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb)
518 {
519 struct inet_sock *inet = inet_sk(sk);
520 struct tcphdr *th = tcp_hdr(skb);
521
522 if (skb->ip_summed == CHECKSUM_PARTIAL) {
523 th->check = ~tcp_v4_check(len, inet->saddr,
524 inet->daddr, 0);
525 skb->csum_start = skb_transport_header(skb) - skb->head;
526 skb->csum_offset = offsetof(struct tcphdr, check);
527 } else {
528 th->check = tcp_v4_check(len, inet->saddr, inet->daddr,
529 csum_partial(th,
530 th->doff << 2,
531 skb->csum));
532 }
533 }
534
535 int tcp_v4_gso_send_check(struct sk_buff *skb)
536 {
537 const struct iphdr *iph;
538 struct tcphdr *th;
539
540 if (!pskb_may_pull(skb, sizeof(*th)))
541 return -EINVAL;
542
543 iph = ip_hdr(skb);
544 th = tcp_hdr(skb);
545
546 th->check = 0;
547 th->check = ~tcp_v4_check(skb->len, iph->saddr, iph->daddr, 0);
548 skb->csum_start = skb_transport_header(skb) - skb->head;
549 skb->csum_offset = offsetof(struct tcphdr, check);
550 skb->ip_summed = CHECKSUM_PARTIAL;
551 return 0;
552 }
553
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
567 static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb)
568 {
569 struct tcphdr *th = tcp_hdr(skb);
570 struct {
571 struct tcphdr th;
572 #ifdef CONFIG_TCP_MD5SIG
573 __be32 opt[(TCPOLEN_MD5SIG_ALIGNED >> 2)];
574 #endif
575 } rep;
576 struct ip_reply_arg arg;
577 #ifdef CONFIG_TCP_MD5SIG
578 struct tcp_md5sig_key *key;
579 #endif
580 struct net *net;
581
582 /* Never send a reset in response to a reset. */
583 if (th->rst)
584 return;
585
586 if (skb_rtable(skb)->rt_type != RTN_LOCAL)
587 return;
588
589 /* Swap the send and the receive. */
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;
595
596 if (th->ack) {
597 rep.th.seq = th->ack_seq;
598 } else {
599 rep.th.ack = 1;
600 rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
601 skb->len - (th->doff << 2));
602 }
603
604 memset(&arg, 0, sizeof(arg));
605 arg.iov[0].iov_base = (unsigned char *)&rep;
606 arg.iov[0].iov_len = sizeof(rep.th);
607
608 #ifdef CONFIG_TCP_MD5SIG
609 key = sk ? tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr) : NULL;
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
619 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[1],
620 key, ip_hdr(skb)->saddr,
621 ip_hdr(skb)->daddr, &rep.th);
622 }
623 #endif
624 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
625 ip_hdr(skb)->saddr, /* XXX */
626 arg.iov[0].iov_len, IPPROTO_TCP, 0);
627 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
628 arg.flags = (sk && inet_sk(sk)->transparent) ? IP_REPLY_ARG_NOSRCCHECK : 0;
629
630 net = dev_net(skb_dst(skb)->dev);
631 ip_send_reply(net->ipv4.tcp_sock, skb,
632 &arg, arg.iov[0].iov_len);
633
634 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
635 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
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
642 static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
643 u32 win, u32 ts, int oif,
644 struct tcp_md5sig_key *key,
645 int reply_flags)
646 {
647 struct tcphdr *th = tcp_hdr(skb);
648 struct {
649 struct tcphdr th;
650 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
651 #ifdef CONFIG_TCP_MD5SIG
652 + (TCPOLEN_MD5SIG_ALIGNED >> 2)
653 #endif
654 ];
655 } rep;
656 struct ip_reply_arg arg;
657 struct net *net = dev_net(skb_dst(skb)->dev);
658
659 memset(&rep.th, 0, sizeof(struct tcphdr));
660 memset(&arg, 0, sizeof(arg));
661
662 arg.iov[0].iov_base = (unsigned char *)&rep;
663 arg.iov[0].iov_len = sizeof(rep.th);
664 if (ts) {
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);
670 arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED;
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
682 #ifdef CONFIG_TCP_MD5SIG
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
693 tcp_v4_md5_hash_hdr((__u8 *) &rep.opt[offset],
694 key, ip_hdr(skb)->saddr,
695 ip_hdr(skb)->daddr, &rep.th);
696 }
697 #endif
698 arg.flags = reply_flags;
699 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
700 ip_hdr(skb)->saddr, /* XXX */
701 arg.iov[0].iov_len, IPPROTO_TCP, 0);
702 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
703 if (oif)
704 arg.bound_dev_if = oif;
705
706 ip_send_reply(net->ipv4.tcp_sock, skb,
707 &arg, arg.iov[0].iov_len);
708
709 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
710 }
711
712 static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
713 {
714 struct inet_timewait_sock *tw = inet_twsk(sk);
715 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
716
717 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
718 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
719 tcptw->tw_ts_recent,
720 tw->tw_bound_dev_if,
721 tcp_twsk_md5_key(tcptw),
722 tw->tw_transparent ? IP_REPLY_ARG_NOSRCCHECK : 0
723 );
724
725 inet_twsk_put(tw);
726 }
727
728 static void tcp_v4_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
729 struct request_sock *req)
730 {
731 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1,
732 tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
733 req->ts_recent,
734 0,
735 tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr),
736 inet_rsk(req)->no_srccheck ? IP_REPLY_ARG_NOSRCCHECK : 0);
737 }
738
739 /*
740 * Send a SYN-ACK after having received a SYN.
741 * This still operates on a request_sock only, not on a big
742 * socket.
743 */
744 static int __tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
745 struct dst_entry *dst)
746 {
747 const struct inet_request_sock *ireq = inet_rsk(req);
748 int err = -1;
749 struct sk_buff * skb;
750
751 /* First, grab a route. */
752 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
753 return -1;
754
755 skb = tcp_make_synack(sk, dst, req);
756
757 if (skb) {
758 struct tcphdr *th = tcp_hdr(skb);
759
760 th->check = tcp_v4_check(skb->len,
761 ireq->loc_addr,
762 ireq->rmt_addr,
763 csum_partial(th, skb->len,
764 skb->csum));
765
766 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
767 ireq->rmt_addr,
768 ireq->opt);
769 err = net_xmit_eval(err);
770 }
771
772 dst_release(dst);
773 return err;
774 }
775
776 static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req)
777 {
778 return __tcp_v4_send_synack(sk, req, NULL);
779 }
780
781 /*
782 * IPv4 request_sock destructor.
783 */
784 static void tcp_v4_reqsk_destructor(struct request_sock *req)
785 {
786 kfree(inet_rsk(req)->opt);
787 }
788
789 #ifdef CONFIG_SYN_COOKIES
790 static void syn_flood_warning(struct sk_buff *skb)
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",
798 ntohs(tcp_hdr(skb)->dest));
799 }
800 }
801 #endif
802
803 /*
804 * Save and compile IPv4 options into the request_sock if needed.
805 */
806 static struct ip_options *tcp_v4_save_options(struct sock *sk,
807 struct sk_buff *skb)
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
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. */
833 static struct tcp_md5sig_key *
834 tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr)
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)
843 return &tp->md5sig_info->keys4[i].base;
844 }
845 return NULL;
846 }
847
848 struct 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
854 EXPORT_SYMBOL(tcp_v4_md5_lookup);
855
856 static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
857 struct request_sock *req)
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 */
863 int tcp_v4_md5_do_add(struct sock *sk, __be32 addr,
864 u8 *newkey, u8 newkeylen)
865 {
866 /* Add Key to the list */
867 struct tcp_md5sig_key *key;
868 struct tcp_sock *tp = tcp_sk(sk);
869 struct tcp4_md5sig_key *keys;
870
871 key = tcp_v4_md5_do_lookup(sk, addr);
872 if (key) {
873 /* Pre-existing entry - just update that one. */
874 kfree(key->key);
875 key->key = newkey;
876 key->keylen = newkeylen;
877 } else {
878 struct tcp_md5sig_info *md5sig;
879
880 if (!tp->md5sig_info) {
881 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info),
882 GFP_ATOMIC);
883 if (!tp->md5sig_info) {
884 kfree(newkey);
885 return -ENOMEM;
886 }
887 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
888 }
889 if (tcp_alloc_md5sig_pool(sk) == NULL) {
890 kfree(newkey);
891 return -ENOMEM;
892 }
893 md5sig = tp->md5sig_info;
894
895 if (md5sig->alloced4 == md5sig->entries4) {
896 keys = kmalloc((sizeof(*keys) *
897 (md5sig->entries4 + 1)), GFP_ATOMIC);
898 if (!keys) {
899 kfree(newkey);
900 tcp_free_md5sig_pool();
901 return -ENOMEM;
902 }
903
904 if (md5sig->entries4)
905 memcpy(keys, md5sig->keys4,
906 sizeof(*keys) * md5sig->entries4);
907
908 /* Free old key list, and reference new one */
909 kfree(md5sig->keys4);
910 md5sig->keys4 = keys;
911 md5sig->alloced4++;
912 }
913 md5sig->entries4++;
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;
917 }
918 return 0;
919 }
920
921 EXPORT_SYMBOL(tcp_v4_md5_do_add);
922
923 static 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
930 int 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 */
938 kfree(tp->md5sig_info->keys4[i].base.key);
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;
944 tp->md5sig_info->alloced4 = 0;
945 } else if (tp->md5sig_info->entries4 != i) {
946 /* Need to do some manipulation */
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));
951 }
952 tcp_free_md5sig_pool();
953 return 0;
954 }
955 }
956 return -ENOENT;
957 }
958
959 EXPORT_SYMBOL(tcp_v4_md5_do_del);
960
961 static void tcp_v4_clear_md5_list(struct sock *sk)
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++)
972 kfree(tp->md5sig_info->keys4[i].base.key);
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
983 static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
984 int optlen)
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
993 if (copy_from_user(&cmd, optval, sizeof(cmd)))
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);
1010 struct tcp_md5sig_info *p;
1011
1012 p = kzalloc(sizeof(*p), sk->sk_allocation);
1013 if (!p)
1014 return -EINVAL;
1015
1016 tp->md5sig_info = p;
1017 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
1018 }
1019
1020 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, sk->sk_allocation);
1021 if (!newkey)
1022 return -ENOMEM;
1023 return tcp_v4_md5_do_add(sk, sin->sin_addr.s_addr,
1024 newkey, cmd.tcpm_keylen);
1025 }
1026
1027 static int tcp_v4_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
1028 __be32 daddr, __be32 saddr, int nbytes)
1029 {
1030 struct tcp4_pseudohdr *bp;
1031 struct scatterlist sg;
1032
1033 bp = &hp->md5_blk.ip4;
1034
1035 /*
1036 * 1. the TCP pseudo-header (in the order: source IP address,
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;
1043 bp->protocol = IPPROTO_TCP;
1044 bp->len = cpu_to_be16(nbytes);
1045
1046 sg_init_one(&sg, bp, sizeof(*bp));
1047 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
1048 }
1049
1050 static 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))
1070 goto clear_hash;
1071
1072 tcp_put_md5sig_pool();
1073 return 0;
1074
1075 clear_hash:
1076 tcp_put_md5sig_pool();
1077 clear_hash_noput:
1078 memset(md5_hash, 0, 16);
1079 return 1;
1080 }
1081
1082 int 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)
1085 {
1086 struct tcp_md5sig_pool *hp;
1087 struct hash_desc *desc;
1088 struct tcphdr *th = tcp_hdr(skb);
1089 __be32 saddr, daddr;
1090
1091 if (sk) {
1092 saddr = inet_sk(sk)->saddr;
1093 daddr = inet_sk(sk)->daddr;
1094 } else if (req) {
1095 saddr = inet_rsk(req)->loc_addr;
1096 daddr = inet_rsk(req)->rmt_addr;
1097 } else {
1098 const struct iphdr *iph = ip_hdr(skb);
1099 saddr = iph->saddr;
1100 daddr = iph->daddr;
1101 }
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
1125 clear_hash:
1126 tcp_put_md5sig_pool();
1127 clear_hash_noput:
1128 memset(md5_hash, 0, 16);
1129 return 1;
1130 }
1131
1132 EXPORT_SYMBOL(tcp_v4_md5_hash_skb);
1133
1134 static int tcp_v4_inbound_md5_hash(struct sock *sk, struct sk_buff *skb)
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;
1146 const struct iphdr *iph = ip_hdr(skb);
1147 struct tcphdr *th = tcp_hdr(skb);
1148 int genhash;
1149 unsigned char newhash[16];
1150
1151 hash_expected = tcp_v4_md5_do_lookup(sk, iph->saddr);
1152 hash_location = tcp_parse_md5sig_option(th);
1153
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) {
1159 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
1160 return 1;
1161 }
1162
1163 if (!hash_expected && hash_location) {
1164 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
1165 return 1;
1166 }
1167
1168 /* Okay, so this is hash_expected and hash_location -
1169 * so we need to calculate the checksum.
1170 */
1171 genhash = tcp_v4_md5_hash_skb(newhash,
1172 hash_expected,
1173 NULL, NULL, skb);
1174
1175 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
1176 if (net_ratelimit()) {
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),
1180 genhash ? " tcp_v4_calc_md5_hash failed" : "");
1181 }
1182 return 1;
1183 }
1184 return 0;
1185 }
1186
1187 #endif
1188
1189 struct request_sock_ops tcp_request_sock_ops __read_mostly = {
1190 .family = PF_INET,
1191 .obj_size = sizeof(struct tcp_request_sock),
1192 .rtx_syn_ack = tcp_v4_send_synack,
1193 .send_ack = tcp_v4_reqsk_send_ack,
1194 .destructor = tcp_v4_reqsk_destructor,
1195 .send_reset = tcp_v4_send_reset,
1196 };
1197
1198 #ifdef CONFIG_TCP_MD5SIG
1199 static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
1200 .md5_lookup = tcp_v4_reqsk_md5_lookup,
1201 .calc_md5_hash = tcp_v4_md5_hash_skb,
1202 };
1203 #endif
1204
1205 static struct timewait_sock_ops tcp_timewait_sock_ops = {
1206 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
1207 .twsk_unique = tcp_twsk_unique,
1208 .twsk_destructor= tcp_twsk_destructor,
1209 };
1210
1211 int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1212 {
1213 struct inet_request_sock *ireq;
1214 struct tcp_options_received tmp_opt;
1215 struct request_sock *req;
1216 __be32 saddr = ip_hdr(skb)->saddr;
1217 __be32 daddr = ip_hdr(skb)->daddr;
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 */
1227 if (skb_rtable(skb)->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
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 */
1234 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
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 */
1248 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
1249 goto drop;
1250
1251 req = inet_reqsk_alloc(&tcp_request_sock_ops);
1252 if (!req)
1253 goto drop;
1254
1255 #ifdef CONFIG_TCP_MD5SIG
1256 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops;
1257 #endif
1258
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
1265 if (want_cookie && !tmp_opt.saw_tstamp)
1266 tcp_clear_options(&tmp_opt);
1267
1268 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1269
1270 tcp_openreq_init(req, &tmp_opt, skb);
1271
1272 ireq = inet_rsk(req);
1273 ireq->loc_addr = daddr;
1274 ireq->rmt_addr = saddr;
1275 ireq->no_srccheck = inet_sk(sk)->transparent;
1276 ireq->opt = tcp_v4_save_options(sk, skb);
1277
1278 if (security_inet_conn_request(sk, skb, req))
1279 goto drop_and_free;
1280
1281 if (!want_cookie)
1282 TCP_ECN_create_request(req, tcp_hdr(skb));
1283
1284 if (want_cookie) {
1285 #ifdef CONFIG_SYN_COOKIES
1286 syn_flood_warning(skb);
1287 req->cookie_ts = tmp_opt.tstamp_ok;
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 &&
1303 tcp_death_row.sysctl_tw_recycle &&
1304 (dst = inet_csk_route_req(sk, req)) != NULL &&
1305 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
1306 peer->v4daddr == saddr) {
1307 if (get_seconds() < peer->tcp_ts_stamp + TCP_PAWS_MSL &&
1308 (s32)(peer->tcp_ts - req->ts_recent) >
1309 TCP_PAWS_WINDOW) {
1310 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
1311 goto drop_and_release;
1312 }
1313 }
1314 /* Kill the following clause, if you dislike this way. */
1315 else if (!sysctl_tcp_syncookies &&
1316 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
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 */
1327 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI4/%u\n",
1328 &saddr, ntohs(tcp_hdr(skb)->source));
1329 goto drop_and_release;
1330 }
1331
1332 isn = tcp_v4_init_sequence(skb);
1333 }
1334 tcp_rsk(req)->snt_isn = isn;
1335
1336 if (__tcp_v4_send_synack(sk, req, dst) || want_cookie)
1337 goto drop_and_free;
1338
1339 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1340 return 0;
1341
1342 drop_and_release:
1343 dst_release(dst);
1344 drop_and_free:
1345 reqsk_free(req);
1346 drop:
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 */
1355 struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1356 struct request_sock *req,
1357 struct dst_entry *dst)
1358 {
1359 struct inet_request_sock *ireq;
1360 struct inet_sock *newinet;
1361 struct tcp_sock *newtp;
1362 struct sock *newsk;
1363 #ifdef CONFIG_TCP_MD5SIG
1364 struct tcp_md5sig_key *key;
1365 #endif
1366
1367 if (sk_acceptq_is_full(sk))
1368 goto exit_overflow;
1369
1370 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
1371 goto exit;
1372
1373 newsk = tcp_create_openreq_child(sk, req, skb);
1374 if (!newsk)
1375 goto exit;
1376
1377 newsk->sk_gso_type = SKB_GSO_TCPV4;
1378 sk_setup_caps(newsk, dst);
1379
1380 newtp = tcp_sk(newsk);
1381 newinet = inet_sk(newsk);
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;
1388 newinet->mc_index = inet_iif(skb);
1389 newinet->mc_ttl = ip_hdr(skb)->ttl;
1390 inet_csk(newsk)->icsk_ext_hdr_len = 0;
1391 if (newinet->opt)
1392 inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
1393 newinet->id = newtp->write_seq ^ jiffies;
1394
1395 tcp_mtup_init(newsk);
1396 tcp_sync_mss(newsk, dst_mtu(dst));
1397 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
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
1402 tcp_initialize_rcv_mss(newsk);
1403
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 */
1413 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1414 if (newkey != NULL)
1415 tcp_v4_md5_do_add(newsk, newinet->daddr,
1416 newkey, key->keylen);
1417 newsk->sk_route_caps &= ~NETIF_F_GSO_MASK;
1418 }
1419 #endif
1420
1421 __inet_hash_nolisten(newsk);
1422 __inet_inherit_port(sk, newsk);
1423
1424 return newsk;
1425
1426 exit_overflow:
1427 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
1428 exit:
1429 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
1430 dst_release(dst);
1431 return NULL;
1432 }
1433
1434 static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1435 {
1436 struct tcphdr *th = tcp_hdr(skb);
1437 const struct iphdr *iph = ip_hdr(skb);
1438 struct sock *nsk;
1439 struct request_sock **prev;
1440 /* Find possible connection requests. */
1441 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1442 iph->saddr, iph->daddr);
1443 if (req)
1444 return tcp_check_req(sk, skb, req, prev);
1445
1446 nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr,
1447 th->source, iph->daddr, th->dest, inet_iif(skb));
1448
1449 if (nsk) {
1450 if (nsk->sk_state != TCP_TIME_WAIT) {
1451 bh_lock_sock(nsk);
1452 return nsk;
1453 }
1454 inet_twsk_put(inet_twsk(nsk));
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
1465 static __sum16 tcp_v4_checksum_init(struct sk_buff *skb)
1466 {
1467 const struct iphdr *iph = ip_hdr(skb);
1468
1469 if (skb->ip_summed == CHECKSUM_COMPLETE) {
1470 if (!tcp_v4_check(skb->len, iph->saddr,
1471 iph->daddr, skb->csum)) {
1472 skb->ip_summed = CHECKSUM_UNNECESSARY;
1473 return 0;
1474 }
1475 }
1476
1477 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
1478 skb->len, IPPROTO_TCP, 0);
1479
1480 if (skb->len <= 76) {
1481 return __skb_checksum_complete(skb);
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 */
1495 int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1496 {
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 */
1505 if (tcp_v4_inbound_md5_hash(sk, skb))
1506 goto discard;
1507 #endif
1508
1509 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1510 TCP_CHECK_TIMER(sk);
1511 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) {
1512 rsk = sk;
1513 goto reset;
1514 }
1515 TCP_CHECK_TIMER(sk);
1516 return 0;
1517 }
1518
1519 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
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) {
1528 if (tcp_child_process(sk, nsk, skb)) {
1529 rsk = nsk;
1530 goto reset;
1531 }
1532 return 0;
1533 }
1534 }
1535
1536 TCP_CHECK_TIMER(sk);
1537 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
1538 rsk = sk;
1539 goto reset;
1540 }
1541 TCP_CHECK_TIMER(sk);
1542 return 0;
1543
1544 reset:
1545 tcp_v4_send_reset(rsk, skb);
1546 discard:
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
1555 csum_err:
1556 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
1557 goto discard;
1558 }
1559
1560 /*
1561 * From tcp_input.c
1562 */
1563
1564 int tcp_v4_rcv(struct sk_buff *skb)
1565 {
1566 const struct iphdr *iph;
1567 struct tcphdr *th;
1568 struct sock *sk;
1569 int ret;
1570 struct net *net = dev_net(skb->dev);
1571
1572 if (skb->pkt_type != PACKET_HOST)
1573 goto discard_it;
1574
1575 /* Count it even if it's bad */
1576 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
1577
1578 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1579 goto discard_it;
1580
1581 th = tcp_hdr(skb);
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,
1590 * provided case of th->doff==0 is eliminated.
1591 * So, we defer the checks. */
1592 if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb))
1593 goto bad_packet;
1594
1595 th = tcp_hdr(skb);
1596 iph = ip_hdr(skb);
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;
1602 TCP_SKB_CB(skb)->flags = iph->tos;
1603 TCP_SKB_CB(skb)->sacked = 0;
1604
1605 sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
1606 if (!sk)
1607 goto no_tcp_socket;
1608
1609 process:
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;
1615 nf_reset(skb);
1616
1617 if (sk_filter(sk, skb))
1618 goto discard_and_relse;
1619
1620 skb->dev = NULL;
1621
1622 bh_lock_sock_nested(sk);
1623 ret = 0;
1624 if (!sock_owned_by_user(sk)) {
1625 #ifdef CONFIG_NET_DMA
1626 struct tcp_sock *tp = tcp_sk(sk);
1627 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1628 tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
1629 if (tp->ucopy.dma_chan)
1630 ret = tcp_v4_do_rcv(sk, skb);
1631 else
1632 #endif
1633 {
1634 if (!tcp_prequeue(sk, skb))
1635 ret = tcp_v4_do_rcv(sk, skb);
1636 }
1637 } else
1638 sk_add_backlog(sk, skb);
1639 bh_unlock_sock(sk);
1640
1641 sock_put(sk);
1642
1643 return ret;
1644
1645 no_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)) {
1650 bad_packet:
1651 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
1652 } else {
1653 tcp_v4_send_reset(NULL, skb);
1654 }
1655
1656 discard_it:
1657 /* Discard frame. */
1658 kfree_skb(skb);
1659 return 0;
1660
1661 discard_and_relse:
1662 sock_put(sk);
1663 goto discard_it;
1664
1665 do_time_wait:
1666 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1667 inet_twsk_put(inet_twsk(sk));
1668 goto discard_it;
1669 }
1670
1671 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1672 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
1673 inet_twsk_put(inet_twsk(sk));
1674 goto discard_it;
1675 }
1676 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
1677 case TCP_TW_SYN: {
1678 struct sock *sk2 = inet_lookup_listener(dev_net(skb->dev),
1679 &tcp_hashinfo,
1680 iph->daddr, th->dest,
1681 inet_iif(skb));
1682 if (sk2) {
1683 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
1684 inet_twsk_put(inet_twsk(sk));
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
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
1706 int 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 ||
1725 (peer->tcp_ts_stamp + TCP_PAWS_MSL < get_seconds() &&
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
1738 int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
1739 {
1740 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
1741
1742 if (peer) {
1743 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1744
1745 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
1746 (peer->tcp_ts_stamp + TCP_PAWS_MSL < get_seconds() &&
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;
1750 }
1751 inet_putpeer(peer);
1752 return 1;
1753 }
1754
1755 return 0;
1756 }
1757
1758 const struct inet_connection_sock_af_ops ipv4_specific = {
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),
1770 .bind_conflict = inet_csk_bind_conflict,
1771 #ifdef CONFIG_COMPAT
1772 .compat_setsockopt = compat_ip_setsockopt,
1773 .compat_getsockopt = compat_ip_getsockopt,
1774 #endif
1775 };
1776
1777 #ifdef CONFIG_TCP_MD5SIG
1778 static const struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
1779 .md5_lookup = tcp_v4_md5_lookup,
1780 .calc_md5_hash = tcp_v4_md5_hash_skb,
1781 .md5_add = tcp_v4_md5_add_func,
1782 .md5_parse = tcp_v4_parse_md5_keys,
1783 };
1784 #endif
1785
1786 /* NOTE: A lot of things set to zero explicitly by call to
1787 * sk_alloc() so need not be done here.
1788 */
1789 static int tcp_v4_init_sock(struct sock *sk)
1790 {
1791 struct inet_connection_sock *icsk = inet_csk(sk);
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
1798 icsk->icsk_rto = TCP_TIMEOUT_INIT;
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 */
1811 tp->snd_ssthresh = 0x7fffffff; /* Infinity */
1812 tp->snd_cwnd_clamp = ~0;
1813 tp->mss_cache = 536;
1814
1815 tp->reordering = sysctl_tcp_reordering;
1816 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
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
1823 icsk->icsk_af_ops = &ipv4_specific;
1824 icsk->icsk_sync_mss = tcp_sync_mss;
1825 #ifdef CONFIG_TCP_MD5SIG
1826 tp->af_specific = &tcp_sock_ipv4_specific;
1827 #endif
1828
1829 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1830 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1831
1832 local_bh_disable();
1833 percpu_counter_inc(&tcp_sockets_allocated);
1834 local_bh_enable();
1835
1836 return 0;
1837 }
1838
1839 void tcp_v4_destroy_sock(struct sock *sk)
1840 {
1841 struct tcp_sock *tp = tcp_sk(sk);
1842
1843 tcp_clear_xmit_timers(sk);
1844
1845 tcp_cleanup_congestion_control(sk);
1846
1847 /* Cleanup up the write buffer. */
1848 tcp_write_queue_purge(sk);
1849
1850 /* Cleans up our, hopefully empty, out_of_order_queue. */
1851 __skb_queue_purge(&tp->out_of_order_queue);
1852
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
1862 #ifdef CONFIG_NET_DMA
1863 /* Cleans up our sk_async_wait_queue */
1864 __skb_queue_purge(&sk->sk_async_wait_queue);
1865 #endif
1866
1867 /* Clean prequeue, it must be empty really */
1868 __skb_queue_purge(&tp->ucopy.prequeue);
1869
1870 /* Clean up a referenced TCP bind bucket. */
1871 if (inet_csk(sk)->icsk_bind_hash)
1872 inet_put_port(sk);
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
1882 percpu_counter_dec(&tcp_sockets_allocated);
1883 }
1884
1885 EXPORT_SYMBOL(tcp_v4_destroy_sock);
1886
1887 #ifdef CONFIG_PROC_FS
1888 /* Proc filesystem TCP sock list dumping. */
1889
1890 static inline struct inet_timewait_sock *tw_head(struct hlist_nulls_head *head)
1891 {
1892 return hlist_nulls_empty(head) ? NULL :
1893 list_entry(head->first, struct inet_timewait_sock, tw_node);
1894 }
1895
1896 static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
1897 {
1898 return !is_a_nulls(tw->tw_node.next) ?
1899 hlist_nulls_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
1900 }
1901
1902 static void *listening_get_next(struct seq_file *seq, void *cur)
1903 {
1904 struct inet_connection_sock *icsk;
1905 struct hlist_nulls_node *node;
1906 struct sock *sk = cur;
1907 struct inet_listen_hashbucket *ilb;
1908 struct tcp_iter_state *st = seq->private;
1909 struct net *net = seq_file_net(seq);
1910
1911 if (!sk) {
1912 st->bucket = 0;
1913 ilb = &tcp_hashinfo.listening_hash[0];
1914 spin_lock_bh(&ilb->lock);
1915 sk = sk_nulls_head(&ilb->head);
1916 goto get_sk;
1917 }
1918 ilb = &tcp_hashinfo.listening_hash[st->bucket];
1919 ++st->num;
1920
1921 if (st->state == TCP_SEQ_STATE_OPENREQ) {
1922 struct request_sock *req = cur;
1923
1924 icsk = inet_csk(st->syn_wait_sk);
1925 req = req->dl_next;
1926 while (1) {
1927 while (req) {
1928 if (req->rsk_ops->family == st->family) {
1929 cur = req;
1930 goto out;
1931 }
1932 req = req->dl_next;
1933 }
1934 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
1935 break;
1936 get_req:
1937 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
1938 }
1939 sk = sk_next(st->syn_wait_sk);
1940 st->state = TCP_SEQ_STATE_LISTENING;
1941 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1942 } else {
1943 icsk = inet_csk(sk);
1944 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1945 if (reqsk_queue_len(&icsk->icsk_accept_queue))
1946 goto start_req;
1947 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1948 sk = sk_next(sk);
1949 }
1950 get_sk:
1951 sk_nulls_for_each_from(sk, node) {
1952 if (sk->sk_family == st->family && net_eq(sock_net(sk), net)) {
1953 cur = sk;
1954 goto out;
1955 }
1956 icsk = inet_csk(sk);
1957 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1958 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
1959 start_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 }
1966 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1967 }
1968 spin_unlock_bh(&ilb->lock);
1969 if (++st->bucket < INET_LHTABLE_SIZE) {
1970 ilb = &tcp_hashinfo.listening_hash[st->bucket];
1971 spin_lock_bh(&ilb->lock);
1972 sk = sk_nulls_head(&ilb->head);
1973 goto get_sk;
1974 }
1975 cur = NULL;
1976 out:
1977 return cur;
1978 }
1979
1980 static 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
1991 static inline int empty_bucket(struct tcp_iter_state *st)
1992 {
1993 return hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].chain) &&
1994 hlist_nulls_empty(&tcp_hashinfo.ehash[st->bucket].twchain);
1995 }
1996
1997 static void *established_get_first(struct seq_file *seq)
1998 {
1999 struct tcp_iter_state *st = seq->private;
2000 struct net *net = seq_file_net(seq);
2001 void *rc = NULL;
2002
2003 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
2004 struct sock *sk;
2005 struct hlist_nulls_node *node;
2006 struct inet_timewait_sock *tw;
2007 spinlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
2008
2009 /* Lockless fast path for the common case of empty buckets */
2010 if (empty_bucket(st))
2011 continue;
2012
2013 spin_lock_bh(lock);
2014 sk_nulls_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
2015 if (sk->sk_family != st->family ||
2016 !net_eq(sock_net(sk), net)) {
2017 continue;
2018 }
2019 rc = sk;
2020 goto out;
2021 }
2022 st->state = TCP_SEQ_STATE_TIME_WAIT;
2023 inet_twsk_for_each(tw, node,
2024 &tcp_hashinfo.ehash[st->bucket].twchain) {
2025 if (tw->tw_family != st->family ||
2026 !net_eq(twsk_net(tw), net)) {
2027 continue;
2028 }
2029 rc = tw;
2030 goto out;
2031 }
2032 spin_unlock_bh(lock);
2033 st->state = TCP_SEQ_STATE_ESTABLISHED;
2034 }
2035 out:
2036 return rc;
2037 }
2038
2039 static void *established_get_next(struct seq_file *seq, void *cur)
2040 {
2041 struct sock *sk = cur;
2042 struct inet_timewait_sock *tw;
2043 struct hlist_nulls_node *node;
2044 struct tcp_iter_state *st = seq->private;
2045 struct net *net = seq_file_net(seq);
2046
2047 ++st->num;
2048
2049 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2050 tw = cur;
2051 tw = tw_next(tw);
2052 get_tw:
2053 while (tw && (tw->tw_family != st->family || !net_eq(twsk_net(tw), net))) {
2054 tw = tw_next(tw);
2055 }
2056 if (tw) {
2057 cur = tw;
2058 goto out;
2059 }
2060 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
2061 st->state = TCP_SEQ_STATE_ESTABLISHED;
2062
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
2070 spin_lock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
2071 sk = sk_nulls_head(&tcp_hashinfo.ehash[st->bucket].chain);
2072 } else
2073 sk = sk_nulls_next(sk);
2074
2075 sk_nulls_for_each_from(sk, node) {
2076 if (sk->sk_family == st->family && net_eq(sock_net(sk), net))
2077 goto found;
2078 }
2079
2080 st->state = TCP_SEQ_STATE_TIME_WAIT;
2081 tw = tw_head(&tcp_hashinfo.ehash[st->bucket].twchain);
2082 goto get_tw;
2083 found:
2084 cur = sk;
2085 out:
2086 return cur;
2087 }
2088
2089 static 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;
2096 }
2097 return rc;
2098 }
2099
2100 static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2101 {
2102 void *rc;
2103 struct tcp_iter_state *st = seq->private;
2104
2105 st->state = TCP_SEQ_STATE_LISTENING;
2106 rc = listening_get_idx(seq, &pos);
2107
2108 if (!rc) {
2109 st->state = TCP_SEQ_STATE_ESTABLISHED;
2110 rc = established_get_idx(seq, pos);
2111 }
2112
2113 return rc;
2114 }
2115
2116 static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2117 {
2118 struct tcp_iter_state *st = seq->private;
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
2124 static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2125 {
2126 void *rc = NULL;
2127 struct tcp_iter_state *st;
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) {
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 }
2149 out:
2150 ++*pos;
2151 return rc;
2152 }
2153
2154 static void tcp_seq_stop(struct seq_file *seq, void *v)
2155 {
2156 struct tcp_iter_state *st = seq->private;
2157
2158 switch (st->state) {
2159 case TCP_SEQ_STATE_OPENREQ:
2160 if (v) {
2161 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2162 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2163 }
2164 case TCP_SEQ_STATE_LISTENING:
2165 if (v != SEQ_START_TOKEN)
2166 spin_unlock_bh(&tcp_hashinfo.listening_hash[st->bucket].lock);
2167 break;
2168 case TCP_SEQ_STATE_TIME_WAIT:
2169 case TCP_SEQ_STATE_ESTABLISHED:
2170 if (v)
2171 spin_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
2172 break;
2173 }
2174 }
2175
2176 static int tcp_seq_open(struct inode *inode, struct file *file)
2177 {
2178 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
2179 struct tcp_iter_state *s;
2180 int err;
2181
2182 err = seq_open_net(inode, file, &afinfo->seq_ops,
2183 sizeof(struct tcp_iter_state));
2184 if (err < 0)
2185 return err;
2186
2187 s = ((struct seq_file *)file->private_data)->private;
2188 s->family = afinfo->family;
2189 return 0;
2190 }
2191
2192 int tcp_proc_register(struct net *net, struct tcp_seq_afinfo *afinfo)
2193 {
2194 int rc = 0;
2195 struct proc_dir_entry *p;
2196
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;
2201
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
2206 p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net,
2207 &afinfo->seq_fops, afinfo);
2208 if (!p)
2209 rc = -ENOMEM;
2210 return rc;
2211 }
2212
2213 void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
2214 {
2215 proc_net_remove(net, afinfo->name);
2216 }
2217
2218 static void get_openreq4(struct sock *sk, struct request_sock *req,
2219 struct seq_file *f, int i, int uid, int *len)
2220 {
2221 const struct inet_request_sock *ireq = inet_rsk(req);
2222 int ttd = req->expires - jiffies;
2223
2224 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2225 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p%n",
2226 i,
2227 ireq->loc_addr,
2228 ntohs(inet_sk(sk)->sport),
2229 ireq->rmt_addr,
2230 ntohs(ireq->rmt_port),
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),
2240 req,
2241 len);
2242 }
2243
2244 static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i, int *len)
2245 {
2246 int timer_active;
2247 unsigned long timer_expires;
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);
2251 __be32 dest = inet->daddr;
2252 __be32 src = inet->rcv_saddr;
2253 __u16 destp = ntohs(inet->dport);
2254 __u16 srcp = ntohs(inet->sport);
2255
2256 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
2257 timer_active = 1;
2258 timer_expires = icsk->icsk_timeout;
2259 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
2260 timer_active = 4;
2261 timer_expires = icsk->icsk_timeout;
2262 } else if (timer_pending(&sk->sk_timer)) {
2263 timer_active = 2;
2264 timer_expires = sk->sk_timer.expires;
2265 } else {
2266 timer_active = 0;
2267 timer_expires = jiffies;
2268 }
2269
2270 seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
2271 "%08X %5d %8d %lu %d %p %lu %lu %u %u %d%n",
2272 i, src, srcp, dest, destp, sk->sk_state,
2273 tp->write_seq - tp->snd_una,
2274 sk->sk_state == TCP_LISTEN ? sk->sk_ack_backlog :
2275 (tp->rcv_nxt - tp->copied_seq),
2276 timer_active,
2277 jiffies_to_clock_t(timer_expires - jiffies),
2278 icsk->icsk_retransmits,
2279 sock_i_uid(sk),
2280 icsk->icsk_probes_out,
2281 sock_i_ino(sk),
2282 atomic_read(&sk->sk_refcnt), sk,
2283 jiffies_to_clock_t(icsk->icsk_rto),
2284 jiffies_to_clock_t(icsk->icsk_ack.ato),
2285 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
2286 tp->snd_cwnd,
2287 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh,
2288 len);
2289 }
2290
2291 static void get_timewait4_sock(struct inet_timewait_sock *tw,
2292 struct seq_file *f, int i, int *len)
2293 {
2294 __be32 dest, src;
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
2306 seq_printf(f, "%4d: %08X:%04X %08X:%04X"
2307 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p%n",
2308 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2309 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2310 atomic_read(&tw->tw_refcnt), tw, len);
2311 }
2312
2313 #define TMPSZ 150
2314
2315 static int tcp4_seq_show(struct seq_file *seq, void *v)
2316 {
2317 struct tcp_iter_state *st;
2318 int len;
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:
2332 get_tcp4_sock(v, seq, st->num, &len);
2333 break;
2334 case TCP_SEQ_STATE_OPENREQ:
2335 get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid, &len);
2336 break;
2337 case TCP_SEQ_STATE_TIME_WAIT:
2338 get_timewait4_sock(v, seq, st->num, &len);
2339 break;
2340 }
2341 seq_printf(seq, "%*s\n", TMPSZ - 1 - len, "");
2342 out:
2343 return 0;
2344 }
2345
2346 static struct tcp_seq_afinfo tcp4_seq_afinfo = {
2347 .name = "tcp",
2348 .family = AF_INET,
2349 .seq_fops = {
2350 .owner = THIS_MODULE,
2351 },
2352 .seq_ops = {
2353 .show = tcp4_seq_show,
2354 },
2355 };
2356
2357 static int tcp4_proc_init_net(struct net *net)
2358 {
2359 return tcp_proc_register(net, &tcp4_seq_afinfo);
2360 }
2361
2362 static void tcp4_proc_exit_net(struct net *net)
2363 {
2364 tcp_proc_unregister(net, &tcp4_seq_afinfo);
2365 }
2366
2367 static struct pernet_operations tcp4_net_ops = {
2368 .init = tcp4_proc_init_net,
2369 .exit = tcp4_proc_exit_net,
2370 };
2371
2372 int __init tcp4_proc_init(void)
2373 {
2374 return register_pernet_subsys(&tcp4_net_ops);
2375 }
2376
2377 void tcp4_proc_exit(void)
2378 {
2379 unregister_pernet_subsys(&tcp4_net_ops);
2380 }
2381 #endif /* CONFIG_PROC_FS */
2382
2383 struct sk_buff **tcp4_gro_receive(struct sk_buff **head, struct sk_buff *skb)
2384 {
2385 struct iphdr *iph = skb_gro_network_header(skb);
2386
2387 switch (skb->ip_summed) {
2388 case CHECKSUM_COMPLETE:
2389 if (!tcp_v4_check(skb_gro_len(skb), iph->saddr, iph->daddr,
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 }
2403 EXPORT_SYMBOL(tcp4_gro_receive);
2404
2405 int 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 }
2416 EXPORT_SYMBOL(tcp4_gro_complete);
2417
2418 struct proto tcp_prot = {
2419 .name = "TCP",
2420 .owner = THIS_MODULE,
2421 .close = tcp_close,
2422 .connect = tcp_v4_connect,
2423 .disconnect = tcp_disconnect,
2424 .accept = inet_csk_accept,
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,
2431 .recvmsg = tcp_recvmsg,
2432 .backlog_rcv = tcp_v4_do_rcv,
2433 .hash = inet_hash,
2434 .unhash = inet_unhash,
2435 .get_port = inet_csk_get_port,
2436 .enter_memory_pressure = tcp_enter_memory_pressure,
2437 .sockets_allocated = &tcp_sockets_allocated,
2438 .orphan_count = &tcp_orphan_count,
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),
2446 .slab_flags = SLAB_DESTROY_BY_RCU,
2447 .twsk_prot = &tcp_timewait_sock_ops,
2448 .rsk_prot = &tcp_request_sock_ops,
2449 .h.hashinfo = &tcp_hashinfo,
2450 #ifdef CONFIG_COMPAT
2451 .compat_setsockopt = compat_tcp_setsockopt,
2452 .compat_getsockopt = compat_tcp_getsockopt,
2453 #endif
2454 };
2455
2456
2457 static 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
2463 static void __net_exit tcp_sk_exit(struct net *net)
2464 {
2465 inet_ctl_sock_destroy(net->ipv4.tcp_sock);
2466 inet_twsk_purge(net, &tcp_hashinfo, &tcp_death_row, AF_INET);
2467 }
2468
2469 static struct pernet_operations __net_initdata tcp_sk_ops = {
2470 .init = tcp_sk_init,
2471 .exit = tcp_sk_exit,
2472 };
2473
2474 void __init tcp_v4_init(void)
2475 {
2476 inet_hashinfo_init(&tcp_hashinfo);
2477 if (register_pernet_subsys(&tcp_sk_ops))
2478 panic("Failed to create the TCP control socket.\n");
2479 }
2480
2481 EXPORT_SYMBOL(ipv4_specific);
2482 EXPORT_SYMBOL(tcp_hashinfo);
2483 EXPORT_SYMBOL(tcp_prot);
2484 EXPORT_SYMBOL(tcp_v4_conn_request);
2485 EXPORT_SYMBOL(tcp_v4_connect);
2486 EXPORT_SYMBOL(tcp_v4_do_rcv);
2487 EXPORT_SYMBOL(tcp_v4_remember_stamp);
2488 EXPORT_SYMBOL(tcp_v4_send_check);
2489 EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
2490
2491 #ifdef CONFIG_PROC_FS
2492 EXPORT_SYMBOL(tcp_proc_register);
2493 EXPORT_SYMBOL(tcp_proc_unregister);
2494 #endif
2495 EXPORT_SYMBOL(sysctl_tcp_low_latency);
2496
Linux with added FPC-III support