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.
6 * Implementation of the Transmission Control Protocol(TCP).
8 * Version: $Id: tcp_ipv4.c,v 1.240 2002/02/01 22:01:04 davem Exp $
10 * IPv4 specific functions
15 * linux/ipv4/tcp_input.c
16 * linux/ipv4/tcp_output.c
18 * See tcp.c for author information
20 * This program is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU General Public License
22 * as published by the Free Software Foundation; either version
23 * 2 of the License, or (at your option) any later version.
28 * David S. Miller : New socket lookup architecture.
29 * This code is dedicated to John Dyson.
30 * David S. Miller : Change semantics of established hash,
31 * half is devoted to TIME_WAIT sockets
32 * and the rest go in the other half.
33 * Andi Kleen : Add support for syncookies and fixed
34 * some bugs: ip options weren't passed to
35 * the TCP layer, missed a check for an
37 * Andi Kleen : Implemented fast path mtu discovery.
38 * Fixed many serious bugs in the
39 * request_sock handling and moved
40 * most of it into the af independent code.
41 * Added tail drop and some other bugfixes.
42 * Added new listen semantics.
43 * Mike McLagan : Routing by source
44 * Juan Jose Ciarlante: ip_dynaddr bits
45 * Andi Kleen: various fixes.
46 * Vitaly E. Lavrov : Transparent proxy revived after year
48 * Andi Kleen : Fix new listen.
49 * Andi Kleen : Fix accept error reporting.
50 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
51 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
52 * a single port at the same time.
56 #include <linux/types.h>
57 #include <linux/fcntl.h>
58 #include <linux/module.h>
59 #include <linux/random.h>
60 #include <linux/cache.h>
61 #include <linux/jhash.h>
62 #include <linux/init.h>
63 #include <linux/times.h>
66 #include <net/inet_hashtables.h>
68 #include <net/transp_v6.h>
70 #include <net/inet_common.h>
71 #include <net/timewait_sock.h>
73 #include <net/netdma.h>
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>
81 int sysctl_tcp_tw_reuse;
82 int sysctl_tcp_low_latency;
84 /* Check TCP sequence numbers in ICMP packets. */
85 #define ICMP_MIN_LENGTH 8
87 /* Socket used for sending RSTs */
88 static struct socket *tcp_socket;
90 void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb);
92 struct inet_hashinfo __cacheline_aligned tcp_hashinfo = {
93 .lhash_lock = RW_LOCK_UNLOCKED,
94 .lhash_users = ATOMIC_INIT(0),
95 .lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(tcp_hashinfo.lhash_wait),
98 static int tcp_v4_get_port(struct sock *sk, unsigned short snum)
100 return inet_csk_get_port(&tcp_hashinfo, sk, snum,
101 inet_csk_bind_conflict);
104 static void tcp_v4_hash(struct sock *sk)
106 inet_hash(&tcp_hashinfo, sk);
109 void tcp_unhash(struct sock *sk)
111 inet_unhash(&tcp_hashinfo, sk);
114 static inline __u32 tcp_v4_init_sequence(struct sock *sk, struct sk_buff *skb)
116 return secure_tcp_sequence_number(skb->nh.iph->daddr,
122 int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
124 const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
125 struct tcp_sock *tp = tcp_sk(sk);
127 /* With PAWS, it is safe from the viewpoint
128 of data integrity. Even without PAWS it is safe provided sequence
129 spaces do not overlap i.e. at data rates <= 80Mbit/sec.
131 Actually, the idea is close to VJ's one, only timestamp cache is
132 held not per host, but per port pair and TW bucket is used as state
135 If TW bucket has been already destroyed we fall back to VJ's scheme
136 and use initial timestamp retrieved from peer table.
138 if (tcptw->tw_ts_recent_stamp &&
139 (twp == NULL || (sysctl_tcp_tw_reuse &&
140 xtime.tv_sec - tcptw->tw_ts_recent_stamp > 1))) {
141 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
142 if (tp->write_seq == 0)
144 tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
145 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
153 EXPORT_SYMBOL_GPL(tcp_twsk_unique);
155 /* This will initiate an outgoing connection. */
156 int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
158 struct inet_sock *inet = inet_sk(sk);
159 struct tcp_sock *tp = tcp_sk(sk);
160 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
166 if (addr_len < sizeof(struct sockaddr_in))
169 if (usin->sin_family != AF_INET)
170 return -EAFNOSUPPORT;
172 nexthop = daddr = usin->sin_addr.s_addr;
173 if (inet->opt && inet->opt->srr) {
176 nexthop = inet->opt->faddr;
179 tmp = ip_route_connect(&rt, nexthop, inet->saddr,
180 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
182 inet->sport, usin->sin_port, sk);
186 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
191 if (!inet->opt || !inet->opt->srr)
195 inet->saddr = rt->rt_src;
196 inet->rcv_saddr = inet->saddr;
198 if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) {
199 /* Reset inherited state */
200 tp->rx_opt.ts_recent = 0;
201 tp->rx_opt.ts_recent_stamp = 0;
205 if (tcp_death_row.sysctl_tw_recycle &&
206 !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
207 struct inet_peer *peer = rt_get_peer(rt);
209 /* VJ's idea. We save last timestamp seen from
210 * the destination in peer table, when entering state TIME-WAIT
211 * and initialize rx_opt.ts_recent from it, when trying new connection.
214 if (peer && peer->tcp_ts_stamp + TCP_PAWS_MSL >= xtime.tv_sec) {
215 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
216 tp->rx_opt.ts_recent = peer->tcp_ts;
220 inet->dport = usin->sin_port;
223 inet_csk(sk)->icsk_ext_hdr_len = 0;
225 inet_csk(sk)->icsk_ext_hdr_len = inet->opt->optlen;
227 tp->rx_opt.mss_clamp = 536;
229 /* Socket identity is still unknown (sport may be zero).
230 * However we set state to SYN-SENT and not releasing socket
231 * lock select source port, enter ourselves into the hash tables and
232 * complete initialization after this.
234 tcp_set_state(sk, TCP_SYN_SENT);
235 err = inet_hash_connect(&tcp_death_row, sk);
239 err = ip_route_newports(&rt, IPPROTO_TCP, inet->sport, inet->dport, sk);
243 /* OK, now commit destination to socket. */
244 sk_setup_caps(sk, &rt->u.dst);
247 tp->write_seq = secure_tcp_sequence_number(inet->saddr,
252 inet->id = tp->write_seq ^ jiffies;
254 err = tcp_connect(sk);
262 /* This unhashes the socket and releases the local port, if necessary. */
263 tcp_set_state(sk, TCP_CLOSE);
265 sk->sk_route_caps = 0;
271 * This routine does path mtu discovery as defined in RFC1191.
273 static void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, u32 mtu)
275 struct dst_entry *dst;
276 struct inet_sock *inet = inet_sk(sk);
278 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
279 * send out by Linux are always <576bytes so they should go through
282 if (sk->sk_state == TCP_LISTEN)
285 /* We don't check in the destentry if pmtu discovery is forbidden
286 * on this route. We just assume that no packet_to_big packets
287 * are send back when pmtu discovery is not active.
288 * There is a small race when the user changes this flag in the
289 * route, but I think that's acceptable.
291 if ((dst = __sk_dst_check(sk, 0)) == NULL)
294 dst->ops->update_pmtu(dst, mtu);
296 /* Something is about to be wrong... Remember soft error
297 * for the case, if this connection will not able to recover.
299 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
300 sk->sk_err_soft = EMSGSIZE;
304 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
305 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
306 tcp_sync_mss(sk, mtu);
308 /* Resend the TCP packet because it's
309 * clear that the old packet has been
310 * dropped. This is the new "fast" path mtu
313 tcp_simple_retransmit(sk);
314 } /* else let the usual retransmit timer handle it */
318 * This routine is called by the ICMP module when it gets some
319 * sort of error condition. If err < 0 then the socket should
320 * be closed and the error returned to the user. If err > 0
321 * it's just the icmp type << 8 | icmp code. After adjustment
322 * header points to the first 8 bytes of the tcp header. We need
323 * to find the appropriate port.
325 * The locking strategy used here is very "optimistic". When
326 * someone else accesses the socket the ICMP is just dropped
327 * and for some paths there is no check at all.
328 * A more general error queue to queue errors for later handling
329 * is probably better.
333 void tcp_v4_err(struct sk_buff *skb, u32 info)
335 struct iphdr *iph = (struct iphdr *)skb->data;
336 struct tcphdr *th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
338 struct inet_sock *inet;
339 int type = skb->h.icmph->type;
340 int code = skb->h.icmph->code;
345 if (skb->len < (iph->ihl << 2) + 8) {
346 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
350 sk = inet_lookup(&tcp_hashinfo, iph->daddr, th->dest, iph->saddr,
351 th->source, inet_iif(skb));
353 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
356 if (sk->sk_state == TCP_TIME_WAIT) {
357 inet_twsk_put((struct inet_timewait_sock *)sk);
362 /* If too many ICMPs get dropped on busy
363 * servers this needs to be solved differently.
365 if (sock_owned_by_user(sk))
366 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
368 if (sk->sk_state == TCP_CLOSE)
372 seq = ntohl(th->seq);
373 if (sk->sk_state != TCP_LISTEN &&
374 !between(seq, tp->snd_una, tp->snd_nxt)) {
375 NET_INC_STATS(LINUX_MIB_OUTOFWINDOWICMPS);
380 case ICMP_SOURCE_QUENCH:
381 /* Just silently ignore these. */
383 case ICMP_PARAMETERPROB:
386 case ICMP_DEST_UNREACH:
387 if (code > NR_ICMP_UNREACH)
390 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
391 if (!sock_owned_by_user(sk))
392 do_pmtu_discovery(sk, iph, info);
396 err = icmp_err_convert[code].errno;
398 case ICMP_TIME_EXCEEDED:
405 switch (sk->sk_state) {
406 struct request_sock *req, **prev;
408 if (sock_owned_by_user(sk))
411 req = inet_csk_search_req(sk, &prev, th->dest,
412 iph->daddr, iph->saddr);
416 /* ICMPs are not backlogged, hence we cannot get
417 an established socket here.
421 if (seq != tcp_rsk(req)->snt_isn) {
422 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
427 * Still in SYN_RECV, just remove it silently.
428 * There is no good way to pass the error to the newly
429 * created socket, and POSIX does not want network
430 * errors returned from accept().
432 inet_csk_reqsk_queue_drop(sk, req, prev);
436 case TCP_SYN_RECV: /* Cannot happen.
437 It can f.e. if SYNs crossed.
439 if (!sock_owned_by_user(sk)) {
440 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
443 sk->sk_error_report(sk);
447 sk->sk_err_soft = err;
452 /* If we've already connected we will keep trying
453 * until we time out, or the user gives up.
455 * rfc1122 4.2.3.9 allows to consider as hard errors
456 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
457 * but it is obsoleted by pmtu discovery).
459 * Note, that in modern internet, where routing is unreliable
460 * and in each dark corner broken firewalls sit, sending random
461 * errors ordered by their masters even this two messages finally lose
462 * their original sense (even Linux sends invalid PORT_UNREACHs)
464 * Now we are in compliance with RFCs.
469 if (!sock_owned_by_user(sk) && inet->recverr) {
471 sk->sk_error_report(sk);
472 } else { /* Only an error on timeout */
473 sk->sk_err_soft = err;
481 /* This routine computes an IPv4 TCP checksum. */
482 void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb)
484 struct inet_sock *inet = inet_sk(sk);
485 struct tcphdr *th = skb->h.th;
487 if (skb->ip_summed == CHECKSUM_HW) {
488 th->check = ~tcp_v4_check(th, len, inet->saddr, inet->daddr, 0);
489 skb->csum = offsetof(struct tcphdr, check);
491 th->check = tcp_v4_check(th, len, inet->saddr, inet->daddr,
492 csum_partial((char *)th,
499 * This routine will send an RST to the other tcp.
501 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
503 * Answer: if a packet caused RST, it is not for a socket
504 * existing in our system, if it is matched to a socket,
505 * it is just duplicate segment or bug in other side's TCP.
506 * So that we build reply only basing on parameters
507 * arrived with segment.
508 * Exception: precedence violation. We do not implement it in any case.
511 static void tcp_v4_send_reset(struct sk_buff *skb)
513 struct tcphdr *th = skb->h.th;
515 struct ip_reply_arg arg;
517 /* Never send a reset in response to a reset. */
521 if (((struct rtable *)skb->dst)->rt_type != RTN_LOCAL)
524 /* Swap the send and the receive. */
525 memset(&rth, 0, sizeof(struct tcphdr));
526 rth.dest = th->source;
527 rth.source = th->dest;
528 rth.doff = sizeof(struct tcphdr) / 4;
532 rth.seq = th->ack_seq;
535 rth.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
536 skb->len - (th->doff << 2));
539 memset(&arg, 0, sizeof arg);
540 arg.iov[0].iov_base = (unsigned char *)&rth;
541 arg.iov[0].iov_len = sizeof rth;
542 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
543 skb->nh.iph->saddr, /*XXX*/
544 sizeof(struct tcphdr), IPPROTO_TCP, 0);
545 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
547 ip_send_reply(tcp_socket->sk, skb, &arg, sizeof rth);
549 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
550 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
553 /* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
554 outside socket context is ugly, certainly. What can I do?
557 static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
560 struct tcphdr *th = skb->h.th;
565 struct ip_reply_arg arg;
567 memset(&rep.th, 0, sizeof(struct tcphdr));
568 memset(&arg, 0, sizeof arg);
570 arg.iov[0].iov_base = (unsigned char *)&rep;
571 arg.iov[0].iov_len = sizeof(rep.th);
573 rep.tsopt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
574 (TCPOPT_TIMESTAMP << 8) |
576 rep.tsopt[1] = htonl(tcp_time_stamp);
577 rep.tsopt[2] = htonl(ts);
578 arg.iov[0].iov_len = sizeof(rep);
581 /* Swap the send and the receive. */
582 rep.th.dest = th->source;
583 rep.th.source = th->dest;
584 rep.th.doff = arg.iov[0].iov_len / 4;
585 rep.th.seq = htonl(seq);
586 rep.th.ack_seq = htonl(ack);
588 rep.th.window = htons(win);
590 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
591 skb->nh.iph->saddr, /*XXX*/
592 arg.iov[0].iov_len, IPPROTO_TCP, 0);
593 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
595 ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len);
597 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
600 static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
602 struct inet_timewait_sock *tw = inet_twsk(sk);
603 const struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
605 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
606 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale, tcptw->tw_ts_recent);
611 static void tcp_v4_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
613 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
618 * Send a SYN-ACK after having received an ACK.
619 * This still operates on a request_sock only, not on a big
622 static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
623 struct dst_entry *dst)
625 const struct inet_request_sock *ireq = inet_rsk(req);
627 struct sk_buff * skb;
629 /* First, grab a route. */
630 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
633 skb = tcp_make_synack(sk, dst, req);
636 struct tcphdr *th = skb->h.th;
638 th->check = tcp_v4_check(th, skb->len,
641 csum_partial((char *)th, skb->len,
644 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
647 if (err == NET_XMIT_CN)
657 * IPv4 request_sock destructor.
659 static void tcp_v4_reqsk_destructor(struct request_sock *req)
661 kfree(inet_rsk(req)->opt);
664 #ifdef CONFIG_SYN_COOKIES
665 static void syn_flood_warning(struct sk_buff *skb)
667 static unsigned long warntime;
669 if (time_after(jiffies, (warntime + HZ * 60))) {
672 "possible SYN flooding on port %d. Sending cookies.\n",
673 ntohs(skb->h.th->dest));
679 * Save and compile IPv4 options into the request_sock if needed.
681 static struct ip_options *tcp_v4_save_options(struct sock *sk,
684 struct ip_options *opt = &(IPCB(skb)->opt);
685 struct ip_options *dopt = NULL;
687 if (opt && opt->optlen) {
688 int opt_size = optlength(opt);
689 dopt = kmalloc(opt_size, GFP_ATOMIC);
691 if (ip_options_echo(dopt, skb)) {
700 struct request_sock_ops tcp_request_sock_ops = {
702 .obj_size = sizeof(struct tcp_request_sock),
703 .rtx_syn_ack = tcp_v4_send_synack,
704 .send_ack = tcp_v4_reqsk_send_ack,
705 .destructor = tcp_v4_reqsk_destructor,
706 .send_reset = tcp_v4_send_reset,
709 static struct timewait_sock_ops tcp_timewait_sock_ops = {
710 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
711 .twsk_unique = tcp_twsk_unique,
714 int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
716 struct inet_request_sock *ireq;
717 struct tcp_options_received tmp_opt;
718 struct request_sock *req;
719 __u32 saddr = skb->nh.iph->saddr;
720 __u32 daddr = skb->nh.iph->daddr;
721 __u32 isn = TCP_SKB_CB(skb)->when;
722 struct dst_entry *dst = NULL;
723 #ifdef CONFIG_SYN_COOKIES
726 #define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
729 /* Never answer to SYNs send to broadcast or multicast */
730 if (((struct rtable *)skb->dst)->rt_flags &
731 (RTCF_BROADCAST | RTCF_MULTICAST))
734 /* TW buckets are converted to open requests without
735 * limitations, they conserve resources and peer is
736 * evidently real one.
738 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
739 #ifdef CONFIG_SYN_COOKIES
740 if (sysctl_tcp_syncookies) {
747 /* Accept backlog is full. If we have already queued enough
748 * of warm entries in syn queue, drop request. It is better than
749 * clogging syn queue with openreqs with exponentially increasing
752 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
755 req = reqsk_alloc(&tcp_request_sock_ops);
759 tcp_clear_options(&tmp_opt);
760 tmp_opt.mss_clamp = 536;
761 tmp_opt.user_mss = tcp_sk(sk)->rx_opt.user_mss;
763 tcp_parse_options(skb, &tmp_opt, 0);
766 tcp_clear_options(&tmp_opt);
767 tmp_opt.saw_tstamp = 0;
770 if (tmp_opt.saw_tstamp && !tmp_opt.rcv_tsval) {
771 /* Some OSes (unknown ones, but I see them on web server, which
772 * contains information interesting only for windows'
773 * users) do not send their stamp in SYN. It is easy case.
774 * We simply do not advertise TS support.
776 tmp_opt.saw_tstamp = 0;
777 tmp_opt.tstamp_ok = 0;
779 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
781 tcp_openreq_init(req, &tmp_opt, skb);
783 ireq = inet_rsk(req);
784 ireq->loc_addr = daddr;
785 ireq->rmt_addr = saddr;
786 ireq->opt = tcp_v4_save_options(sk, skb);
788 TCP_ECN_create_request(req, skb->h.th);
791 #ifdef CONFIG_SYN_COOKIES
792 syn_flood_warning(skb);
794 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
796 struct inet_peer *peer = NULL;
798 /* VJ's idea. We save last timestamp seen
799 * from the destination in peer table, when entering
800 * state TIME-WAIT, and check against it before
801 * accepting new connection request.
803 * If "isn" is not zero, this request hit alive
804 * timewait bucket, so that all the necessary checks
805 * are made in the function processing timewait state.
807 if (tmp_opt.saw_tstamp &&
808 tcp_death_row.sysctl_tw_recycle &&
809 (dst = inet_csk_route_req(sk, req)) != NULL &&
810 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
811 peer->v4daddr == saddr) {
812 if (xtime.tv_sec < peer->tcp_ts_stamp + TCP_PAWS_MSL &&
813 (s32)(peer->tcp_ts - req->ts_recent) >
815 NET_INC_STATS_BH(LINUX_MIB_PAWSPASSIVEREJECTED);
820 /* Kill the following clause, if you dislike this way. */
821 else if (!sysctl_tcp_syncookies &&
822 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
823 (sysctl_max_syn_backlog >> 2)) &&
824 (!peer || !peer->tcp_ts_stamp) &&
825 (!dst || !dst_metric(dst, RTAX_RTT))) {
826 /* Without syncookies last quarter of
827 * backlog is filled with destinations,
828 * proven to be alive.
829 * It means that we continue to communicate
830 * to destinations, already remembered
831 * to the moment of synflood.
833 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open "
834 "request from %u.%u.%u.%u/%u\n",
836 ntohs(skb->h.th->source));
841 isn = tcp_v4_init_sequence(sk, skb);
843 tcp_rsk(req)->snt_isn = isn;
845 if (tcp_v4_send_synack(sk, req, dst))
851 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
858 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
864 * The three way handshake has completed - we got a valid synack -
865 * now create the new socket.
867 struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
868 struct request_sock *req,
869 struct dst_entry *dst)
871 struct inet_request_sock *ireq;
872 struct inet_sock *newinet;
873 struct tcp_sock *newtp;
876 if (sk_acceptq_is_full(sk))
879 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
882 newsk = tcp_create_openreq_child(sk, req, skb);
886 sk_setup_caps(newsk, dst);
888 newtp = tcp_sk(newsk);
889 newinet = inet_sk(newsk);
890 ireq = inet_rsk(req);
891 newinet->daddr = ireq->rmt_addr;
892 newinet->rcv_saddr = ireq->loc_addr;
893 newinet->saddr = ireq->loc_addr;
894 newinet->opt = ireq->opt;
896 newinet->mc_index = inet_iif(skb);
897 newinet->mc_ttl = skb->nh.iph->ttl;
898 inet_csk(newsk)->icsk_ext_hdr_len = 0;
900 inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
901 newinet->id = newtp->write_seq ^ jiffies;
903 tcp_mtup_init(newsk);
904 tcp_sync_mss(newsk, dst_mtu(dst));
905 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
906 tcp_initialize_rcv_mss(newsk);
908 __inet_hash(&tcp_hashinfo, newsk, 0);
909 __inet_inherit_port(&tcp_hashinfo, sk, newsk);
914 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
916 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
921 static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
923 struct tcphdr *th = skb->h.th;
924 struct iphdr *iph = skb->nh.iph;
926 struct request_sock **prev;
927 /* Find possible connection requests. */
928 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
929 iph->saddr, iph->daddr);
931 return tcp_check_req(sk, skb, req, prev);
933 nsk = __inet_lookup_established(&tcp_hashinfo, skb->nh.iph->saddr,
934 th->source, skb->nh.iph->daddr,
935 ntohs(th->dest), inet_iif(skb));
938 if (nsk->sk_state != TCP_TIME_WAIT) {
942 inet_twsk_put((struct inet_timewait_sock *)nsk);
946 #ifdef CONFIG_SYN_COOKIES
947 if (!th->rst && !th->syn && th->ack)
948 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
953 static int tcp_v4_checksum_init(struct sk_buff *skb)
955 if (skb->ip_summed == CHECKSUM_HW) {
956 if (!tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
957 skb->nh.iph->daddr, skb->csum)) {
958 skb->ip_summed = CHECKSUM_UNNECESSARY;
963 skb->csum = csum_tcpudp_nofold(skb->nh.iph->saddr, skb->nh.iph->daddr,
964 skb->len, IPPROTO_TCP, 0);
966 if (skb->len <= 76) {
967 return __skb_checksum_complete(skb);
973 /* The socket must have it's spinlock held when we get
976 * We have a potential double-lock case here, so even when
977 * doing backlog processing we use the BH locking scheme.
978 * This is because we cannot sleep with the original spinlock
981 int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
983 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
985 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len))
991 if (skb->len < (skb->h.th->doff << 2) || tcp_checksum_complete(skb))
994 if (sk->sk_state == TCP_LISTEN) {
995 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1000 if (tcp_child_process(sk, nsk, skb))
1006 TCP_CHECK_TIMER(sk);
1007 if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len))
1009 TCP_CHECK_TIMER(sk);
1013 tcp_v4_send_reset(skb);
1016 /* Be careful here. If this function gets more complicated and
1017 * gcc suffers from register pressure on the x86, sk (in %ebx)
1018 * might be destroyed here. This current version compiles correctly,
1019 * but you have been warned.
1024 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1032 int tcp_v4_rcv(struct sk_buff *skb)
1038 if (skb->pkt_type != PACKET_HOST)
1041 /* Count it even if it's bad */
1042 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1044 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1049 if (th->doff < sizeof(struct tcphdr) / 4)
1051 if (!pskb_may_pull(skb, th->doff * 4))
1054 /* An explanation is required here, I think.
1055 * Packet length and doff are validated by header prediction,
1056 * provided case of th->doff==0 is eliminated.
1057 * So, we defer the checks. */
1058 if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
1059 tcp_v4_checksum_init(skb)))
1063 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1064 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1065 skb->len - th->doff * 4);
1066 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1067 TCP_SKB_CB(skb)->when = 0;
1068 TCP_SKB_CB(skb)->flags = skb->nh.iph->tos;
1069 TCP_SKB_CB(skb)->sacked = 0;
1071 sk = __inet_lookup(&tcp_hashinfo, skb->nh.iph->saddr, th->source,
1072 skb->nh.iph->daddr, ntohs(th->dest),
1079 if (sk->sk_state == TCP_TIME_WAIT)
1082 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1083 goto discard_and_relse;
1086 if (sk_filter(sk, skb, 0))
1087 goto discard_and_relse;
1093 if (!sock_owned_by_user(sk)) {
1094 #ifdef CONFIG_NET_DMA
1095 struct tcp_sock *tp = tcp_sk(sk);
1096 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1097 tp->ucopy.dma_chan = get_softnet_dma();
1098 if (tp->ucopy.dma_chan)
1099 ret = tcp_v4_do_rcv(sk, skb);
1103 if (!tcp_prequeue(sk, skb))
1104 ret = tcp_v4_do_rcv(sk, skb);
1107 sk_add_backlog(sk, skb);
1115 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1118 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1120 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1122 tcp_v4_send_reset(skb);
1126 /* Discard frame. */
1135 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1136 inet_twsk_put((struct inet_timewait_sock *) sk);
1140 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1141 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1142 inet_twsk_put((struct inet_timewait_sock *) sk);
1145 switch (tcp_timewait_state_process((struct inet_timewait_sock *)sk,
1148 struct sock *sk2 = inet_lookup_listener(&tcp_hashinfo,
1153 inet_twsk_deschedule((struct inet_timewait_sock *)sk,
1155 inet_twsk_put((struct inet_timewait_sock *)sk);
1159 /* Fall through to ACK */
1162 tcp_v4_timewait_ack(sk, skb);
1166 case TCP_TW_SUCCESS:;
1171 /* VJ's idea. Save last timestamp seen from this destination
1172 * and hold it at least for normal timewait interval to use for duplicate
1173 * segment detection in subsequent connections, before they enter synchronized
1177 int tcp_v4_remember_stamp(struct sock *sk)
1179 struct inet_sock *inet = inet_sk(sk);
1180 struct tcp_sock *tp = tcp_sk(sk);
1181 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1182 struct inet_peer *peer = NULL;
1185 if (!rt || rt->rt_dst != inet->daddr) {
1186 peer = inet_getpeer(inet->daddr, 1);
1190 rt_bind_peer(rt, 1);
1195 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
1196 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1197 peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {
1198 peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;
1199 peer->tcp_ts = tp->rx_opt.ts_recent;
1209 int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
1211 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
1214 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1216 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
1217 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1218 peer->tcp_ts_stamp <= tcptw->tw_ts_recent_stamp)) {
1219 peer->tcp_ts_stamp = tcptw->tw_ts_recent_stamp;
1220 peer->tcp_ts = tcptw->tw_ts_recent;
1229 struct inet_connection_sock_af_ops ipv4_specific = {
1230 .queue_xmit = ip_queue_xmit,
1231 .send_check = tcp_v4_send_check,
1232 .rebuild_header = inet_sk_rebuild_header,
1233 .conn_request = tcp_v4_conn_request,
1234 .syn_recv_sock = tcp_v4_syn_recv_sock,
1235 .remember_stamp = tcp_v4_remember_stamp,
1236 .net_header_len = sizeof(struct iphdr),
1237 .setsockopt = ip_setsockopt,
1238 .getsockopt = ip_getsockopt,
1239 .addr2sockaddr = inet_csk_addr2sockaddr,
1240 .sockaddr_len = sizeof(struct sockaddr_in),
1241 #ifdef CONFIG_COMPAT
1242 .compat_setsockopt = compat_ip_setsockopt,
1243 .compat_getsockopt = compat_ip_getsockopt,
1247 /* NOTE: A lot of things set to zero explicitly by call to
1248 * sk_alloc() so need not be done here.
1250 static int tcp_v4_init_sock(struct sock *sk)
1252 struct inet_connection_sock *icsk = inet_csk(sk);
1253 struct tcp_sock *tp = tcp_sk(sk);
1255 skb_queue_head_init(&tp->out_of_order_queue);
1256 tcp_init_xmit_timers(sk);
1257 tcp_prequeue_init(tp);
1259 icsk->icsk_rto = TCP_TIMEOUT_INIT;
1260 tp->mdev = TCP_TIMEOUT_INIT;
1262 /* So many TCP implementations out there (incorrectly) count the
1263 * initial SYN frame in their delayed-ACK and congestion control
1264 * algorithms that we must have the following bandaid to talk
1265 * efficiently to them. -DaveM
1269 /* See draft-stevens-tcpca-spec-01 for discussion of the
1270 * initialization of these values.
1272 tp->snd_ssthresh = 0x7fffffff; /* Infinity */
1273 tp->snd_cwnd_clamp = ~0;
1274 tp->mss_cache = 536;
1276 tp->reordering = sysctl_tcp_reordering;
1277 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
1279 sk->sk_state = TCP_CLOSE;
1281 sk->sk_write_space = sk_stream_write_space;
1282 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1284 icsk->icsk_af_ops = &ipv4_specific;
1285 icsk->icsk_sync_mss = tcp_sync_mss;
1287 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1288 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1290 atomic_inc(&tcp_sockets_allocated);
1295 int tcp_v4_destroy_sock(struct sock *sk)
1297 struct tcp_sock *tp = tcp_sk(sk);
1299 tcp_clear_xmit_timers(sk);
1301 tcp_cleanup_congestion_control(sk);
1303 /* Cleanup up the write buffer. */
1304 sk_stream_writequeue_purge(sk);
1306 /* Cleans up our, hopefully empty, out_of_order_queue. */
1307 __skb_queue_purge(&tp->out_of_order_queue);
1309 #ifdef CONFIG_NET_DMA
1310 /* Cleans up our sk_async_wait_queue */
1311 __skb_queue_purge(&sk->sk_async_wait_queue);
1314 /* Clean prequeue, it must be empty really */
1315 __skb_queue_purge(&tp->ucopy.prequeue);
1317 /* Clean up a referenced TCP bind bucket. */
1318 if (inet_csk(sk)->icsk_bind_hash)
1319 inet_put_port(&tcp_hashinfo, sk);
1322 * If sendmsg cached page exists, toss it.
1324 if (sk->sk_sndmsg_page) {
1325 __free_page(sk->sk_sndmsg_page);
1326 sk->sk_sndmsg_page = NULL;
1329 atomic_dec(&tcp_sockets_allocated);
1334 EXPORT_SYMBOL(tcp_v4_destroy_sock);
1336 #ifdef CONFIG_PROC_FS
1337 /* Proc filesystem TCP sock list dumping. */
1339 static inline struct inet_timewait_sock *tw_head(struct hlist_head *head)
1341 return hlist_empty(head) ? NULL :
1342 list_entry(head->first, struct inet_timewait_sock, tw_node);
1345 static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
1347 return tw->tw_node.next ?
1348 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
1351 static void *listening_get_next(struct seq_file *seq, void *cur)
1353 struct inet_connection_sock *icsk;
1354 struct hlist_node *node;
1355 struct sock *sk = cur;
1356 struct tcp_iter_state* st = seq->private;
1360 sk = sk_head(&tcp_hashinfo.listening_hash[0]);
1366 if (st->state == TCP_SEQ_STATE_OPENREQ) {
1367 struct request_sock *req = cur;
1369 icsk = inet_csk(st->syn_wait_sk);
1373 if (req->rsk_ops->family == st->family) {
1379 if (++st->sbucket >= TCP_SYNQ_HSIZE)
1382 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
1384 sk = sk_next(st->syn_wait_sk);
1385 st->state = TCP_SEQ_STATE_LISTENING;
1386 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1388 icsk = inet_csk(sk);
1389 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1390 if (reqsk_queue_len(&icsk->icsk_accept_queue))
1392 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1396 sk_for_each_from(sk, node) {
1397 if (sk->sk_family == st->family) {
1401 icsk = inet_csk(sk);
1402 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1403 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
1405 st->uid = sock_i_uid(sk);
1406 st->syn_wait_sk = sk;
1407 st->state = TCP_SEQ_STATE_OPENREQ;
1411 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1413 if (++st->bucket < INET_LHTABLE_SIZE) {
1414 sk = sk_head(&tcp_hashinfo.listening_hash[st->bucket]);
1422 static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
1424 void *rc = listening_get_next(seq, NULL);
1426 while (rc && *pos) {
1427 rc = listening_get_next(seq, rc);
1433 static void *established_get_first(struct seq_file *seq)
1435 struct tcp_iter_state* st = seq->private;
1438 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
1440 struct hlist_node *node;
1441 struct inet_timewait_sock *tw;
1443 /* We can reschedule _before_ having picked the target: */
1444 cond_resched_softirq();
1446 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
1447 sk_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
1448 if (sk->sk_family != st->family) {
1454 st->state = TCP_SEQ_STATE_TIME_WAIT;
1455 inet_twsk_for_each(tw, node,
1456 &tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain) {
1457 if (tw->tw_family != st->family) {
1463 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1464 st->state = TCP_SEQ_STATE_ESTABLISHED;
1470 static void *established_get_next(struct seq_file *seq, void *cur)
1472 struct sock *sk = cur;
1473 struct inet_timewait_sock *tw;
1474 struct hlist_node *node;
1475 struct tcp_iter_state* st = seq->private;
1479 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
1483 while (tw && tw->tw_family != st->family) {
1490 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1491 st->state = TCP_SEQ_STATE_ESTABLISHED;
1493 /* We can reschedule between buckets: */
1494 cond_resched_softirq();
1496 if (++st->bucket < tcp_hashinfo.ehash_size) {
1497 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
1498 sk = sk_head(&tcp_hashinfo.ehash[st->bucket].chain);
1506 sk_for_each_from(sk, node) {
1507 if (sk->sk_family == st->family)
1511 st->state = TCP_SEQ_STATE_TIME_WAIT;
1512 tw = tw_head(&tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain);
1520 static void *established_get_idx(struct seq_file *seq, loff_t pos)
1522 void *rc = established_get_first(seq);
1525 rc = established_get_next(seq, rc);
1531 static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
1534 struct tcp_iter_state* st = seq->private;
1536 inet_listen_lock(&tcp_hashinfo);
1537 st->state = TCP_SEQ_STATE_LISTENING;
1538 rc = listening_get_idx(seq, &pos);
1541 inet_listen_unlock(&tcp_hashinfo);
1543 st->state = TCP_SEQ_STATE_ESTABLISHED;
1544 rc = established_get_idx(seq, pos);
1550 static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
1552 struct tcp_iter_state* st = seq->private;
1553 st->state = TCP_SEQ_STATE_LISTENING;
1555 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
1558 static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1561 struct tcp_iter_state* st;
1563 if (v == SEQ_START_TOKEN) {
1564 rc = tcp_get_idx(seq, 0);
1569 switch (st->state) {
1570 case TCP_SEQ_STATE_OPENREQ:
1571 case TCP_SEQ_STATE_LISTENING:
1572 rc = listening_get_next(seq, v);
1574 inet_listen_unlock(&tcp_hashinfo);
1576 st->state = TCP_SEQ_STATE_ESTABLISHED;
1577 rc = established_get_first(seq);
1580 case TCP_SEQ_STATE_ESTABLISHED:
1581 case TCP_SEQ_STATE_TIME_WAIT:
1582 rc = established_get_next(seq, v);
1590 static void tcp_seq_stop(struct seq_file *seq, void *v)
1592 struct tcp_iter_state* st = seq->private;
1594 switch (st->state) {
1595 case TCP_SEQ_STATE_OPENREQ:
1597 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
1598 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1600 case TCP_SEQ_STATE_LISTENING:
1601 if (v != SEQ_START_TOKEN)
1602 inet_listen_unlock(&tcp_hashinfo);
1604 case TCP_SEQ_STATE_TIME_WAIT:
1605 case TCP_SEQ_STATE_ESTABLISHED:
1607 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1613 static int tcp_seq_open(struct inode *inode, struct file *file)
1615 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
1616 struct seq_file *seq;
1617 struct tcp_iter_state *s;
1620 if (unlikely(afinfo == NULL))
1623 s = kmalloc(sizeof(*s), GFP_KERNEL);
1626 memset(s, 0, sizeof(*s));
1627 s->family = afinfo->family;
1628 s->seq_ops.start = tcp_seq_start;
1629 s->seq_ops.next = tcp_seq_next;
1630 s->seq_ops.show = afinfo->seq_show;
1631 s->seq_ops.stop = tcp_seq_stop;
1633 rc = seq_open(file, &s->seq_ops);
1636 seq = file->private_data;
1645 int tcp_proc_register(struct tcp_seq_afinfo *afinfo)
1648 struct proc_dir_entry *p;
1652 afinfo->seq_fops->owner = afinfo->owner;
1653 afinfo->seq_fops->open = tcp_seq_open;
1654 afinfo->seq_fops->read = seq_read;
1655 afinfo->seq_fops->llseek = seq_lseek;
1656 afinfo->seq_fops->release = seq_release_private;
1658 p = proc_net_fops_create(afinfo->name, S_IRUGO, afinfo->seq_fops);
1666 void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo)
1670 proc_net_remove(afinfo->name);
1671 memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops));
1674 static void get_openreq4(struct sock *sk, struct request_sock *req,
1675 char *tmpbuf, int i, int uid)
1677 const struct inet_request_sock *ireq = inet_rsk(req);
1678 int ttd = req->expires - jiffies;
1680 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
1681 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p",
1684 ntohs(inet_sk(sk)->sport),
1686 ntohs(ireq->rmt_port),
1688 0, 0, /* could print option size, but that is af dependent. */
1689 1, /* timers active (only the expire timer) */
1690 jiffies_to_clock_t(ttd),
1693 0, /* non standard timer */
1694 0, /* open_requests have no inode */
1695 atomic_read(&sk->sk_refcnt),
1699 static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i)
1702 unsigned long timer_expires;
1703 struct tcp_sock *tp = tcp_sk(sp);
1704 const struct inet_connection_sock *icsk = inet_csk(sp);
1705 struct inet_sock *inet = inet_sk(sp);
1706 unsigned int dest = inet->daddr;
1707 unsigned int src = inet->rcv_saddr;
1708 __u16 destp = ntohs(inet->dport);
1709 __u16 srcp = ntohs(inet->sport);
1711 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
1713 timer_expires = icsk->icsk_timeout;
1714 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
1716 timer_expires = icsk->icsk_timeout;
1717 } else if (timer_pending(&sp->sk_timer)) {
1719 timer_expires = sp->sk_timer.expires;
1722 timer_expires = jiffies;
1725 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
1726 "%08X %5d %8d %lu %d %p %u %u %u %u %d",
1727 i, src, srcp, dest, destp, sp->sk_state,
1728 tp->write_seq - tp->snd_una,
1729 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
1731 jiffies_to_clock_t(timer_expires - jiffies),
1732 icsk->icsk_retransmits,
1734 icsk->icsk_probes_out,
1736 atomic_read(&sp->sk_refcnt), sp,
1739 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
1741 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh);
1744 static void get_timewait4_sock(struct inet_timewait_sock *tw, char *tmpbuf, int i)
1746 unsigned int dest, src;
1748 int ttd = tw->tw_ttd - jiffies;
1753 dest = tw->tw_daddr;
1754 src = tw->tw_rcv_saddr;
1755 destp = ntohs(tw->tw_dport);
1756 srcp = ntohs(tw->tw_sport);
1758 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
1759 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p",
1760 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
1761 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
1762 atomic_read(&tw->tw_refcnt), tw);
1767 static int tcp4_seq_show(struct seq_file *seq, void *v)
1769 struct tcp_iter_state* st;
1770 char tmpbuf[TMPSZ + 1];
1772 if (v == SEQ_START_TOKEN) {
1773 seq_printf(seq, "%-*s\n", TMPSZ - 1,
1774 " sl local_address rem_address st tx_queue "
1775 "rx_queue tr tm->when retrnsmt uid timeout "
1781 switch (st->state) {
1782 case TCP_SEQ_STATE_LISTENING:
1783 case TCP_SEQ_STATE_ESTABLISHED:
1784 get_tcp4_sock(v, tmpbuf, st->num);
1786 case TCP_SEQ_STATE_OPENREQ:
1787 get_openreq4(st->syn_wait_sk, v, tmpbuf, st->num, st->uid);
1789 case TCP_SEQ_STATE_TIME_WAIT:
1790 get_timewait4_sock(v, tmpbuf, st->num);
1793 seq_printf(seq, "%-*s\n", TMPSZ - 1, tmpbuf);
1798 static struct file_operations tcp4_seq_fops;
1799 static struct tcp_seq_afinfo tcp4_seq_afinfo = {
1800 .owner = THIS_MODULE,
1803 .seq_show = tcp4_seq_show,
1804 .seq_fops = &tcp4_seq_fops,
1807 int __init tcp4_proc_init(void)
1809 return tcp_proc_register(&tcp4_seq_afinfo);
1812 void tcp4_proc_exit(void)
1814 tcp_proc_unregister(&tcp4_seq_afinfo);
1816 #endif /* CONFIG_PROC_FS */
1818 struct proto tcp_prot = {
1820 .owner = THIS_MODULE,
1822 .connect = tcp_v4_connect,
1823 .disconnect = tcp_disconnect,
1824 .accept = inet_csk_accept,
1826 .init = tcp_v4_init_sock,
1827 .destroy = tcp_v4_destroy_sock,
1828 .shutdown = tcp_shutdown,
1829 .setsockopt = tcp_setsockopt,
1830 .getsockopt = tcp_getsockopt,
1831 .sendmsg = tcp_sendmsg,
1832 .recvmsg = tcp_recvmsg,
1833 .backlog_rcv = tcp_v4_do_rcv,
1834 .hash = tcp_v4_hash,
1835 .unhash = tcp_unhash,
1836 .get_port = tcp_v4_get_port,
1837 .enter_memory_pressure = tcp_enter_memory_pressure,
1838 .sockets_allocated = &tcp_sockets_allocated,
1839 .orphan_count = &tcp_orphan_count,
1840 .memory_allocated = &tcp_memory_allocated,
1841 .memory_pressure = &tcp_memory_pressure,
1842 .sysctl_mem = sysctl_tcp_mem,
1843 .sysctl_wmem = sysctl_tcp_wmem,
1844 .sysctl_rmem = sysctl_tcp_rmem,
1845 .max_header = MAX_TCP_HEADER,
1846 .obj_size = sizeof(struct tcp_sock),
1847 .twsk_prot = &tcp_timewait_sock_ops,
1848 .rsk_prot = &tcp_request_sock_ops,
1849 #ifdef CONFIG_COMPAT
1850 .compat_setsockopt = compat_tcp_setsockopt,
1851 .compat_getsockopt = compat_tcp_getsockopt,
1855 void __init tcp_v4_init(struct net_proto_family *ops)
1857 if (inet_csk_ctl_sock_create(&tcp_socket, PF_INET, SOCK_RAW, IPPROTO_TCP) < 0)
1858 panic("Failed to create the TCP control socket.\n");
1861 EXPORT_SYMBOL(ipv4_specific);
1862 EXPORT_SYMBOL(tcp_hashinfo);
1863 EXPORT_SYMBOL(tcp_prot);
1864 EXPORT_SYMBOL(tcp_unhash);
1865 EXPORT_SYMBOL(tcp_v4_conn_request);
1866 EXPORT_SYMBOL(tcp_v4_connect);
1867 EXPORT_SYMBOL(tcp_v4_do_rcv);
1868 EXPORT_SYMBOL(tcp_v4_remember_stamp);
1869 EXPORT_SYMBOL(tcp_v4_send_check);
1870 EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
1872 #ifdef CONFIG_PROC_FS
1873 EXPORT_SYMBOL(tcp_proc_register);
1874 EXPORT_SYMBOL(tcp_proc_unregister);
1876 EXPORT_SYMBOL(sysctl_local_port_range);
1877 EXPORT_SYMBOL(sysctl_tcp_low_latency);