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.
55 #include <linux/config.h>
57 #include <linux/types.h>
58 #include <linux/fcntl.h>
59 #include <linux/module.h>
60 #include <linux/random.h>
61 #include <linux/cache.h>
62 #include <linux/jhash.h>
63 #include <linux/init.h>
64 #include <linux/times.h>
67 #include <net/inet_hashtables.h>
69 #include <net/transp_v6.h>
71 #include <net/inet_common.h>
72 #include <net/timewait_sock.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 /* called with local bh disabled */
156 static int __tcp_v4_check_established(struct sock *sk, __u16 lport,
157 struct inet_timewait_sock **twp)
159 struct inet_sock *inet = inet_sk(sk);
160 u32 daddr = inet->rcv_saddr;
161 u32 saddr = inet->daddr;
162 int dif = sk->sk_bound_dev_if;
163 INET_ADDR_COOKIE(acookie, saddr, daddr)
164 const __u32 ports = INET_COMBINED_PORTS(inet->dport, lport);
165 unsigned int hash = inet_ehashfn(daddr, lport, saddr, inet->dport);
166 struct inet_ehash_bucket *head = inet_ehash_bucket(&tcp_hashinfo, hash);
168 const struct hlist_node *node;
169 struct inet_timewait_sock *tw;
171 prefetch(head->chain.first);
172 write_lock(&head->lock);
174 /* Check TIME-WAIT sockets first. */
175 sk_for_each(sk2, node, &(head + tcp_hashinfo.ehash_size)->chain) {
178 if (INET_TW_MATCH(sk2, hash, acookie, saddr, daddr, ports, dif)) {
179 if (twsk_unique(sk, sk2, twp))
187 /* And established part... */
188 sk_for_each(sk2, node, &head->chain) {
189 if (INET_MATCH(sk2, hash, acookie, saddr, daddr, ports, dif))
194 /* Must record num and sport now. Otherwise we will see
195 * in hash table socket with a funny identity. */
197 inet->sport = htons(lport);
199 BUG_TRAP(sk_unhashed(sk));
200 __sk_add_node(sk, &head->chain);
201 sock_prot_inc_use(sk->sk_prot);
202 write_unlock(&head->lock);
206 NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED);
208 /* Silly. Should hash-dance instead... */
209 inet_twsk_deschedule(tw, &tcp_death_row);
210 NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED);
218 write_unlock(&head->lock);
219 return -EADDRNOTAVAIL;
222 static inline u32 connect_port_offset(const struct sock *sk)
224 const struct inet_sock *inet = inet_sk(sk);
226 return secure_tcp_port_ephemeral(inet->rcv_saddr, inet->daddr,
231 * Bind a port for a connect operation and hash it.
233 static inline int tcp_v4_hash_connect(struct sock *sk)
235 const unsigned short snum = inet_sk(sk)->num;
236 struct inet_bind_hashbucket *head;
237 struct inet_bind_bucket *tb;
241 int low = sysctl_local_port_range[0];
242 int high = sysctl_local_port_range[1];
243 int range = high - low;
247 u32 offset = hint + connect_port_offset(sk);
248 struct hlist_node *node;
249 struct inet_timewait_sock *tw = NULL;
252 for (i = 1; i <= range; i++) {
253 port = low + (i + offset) % range;
254 head = &tcp_hashinfo.bhash[inet_bhashfn(port, tcp_hashinfo.bhash_size)];
255 spin_lock(&head->lock);
257 /* Does not bother with rcv_saddr checks,
258 * because the established check is already
261 inet_bind_bucket_for_each(tb, node, &head->chain) {
262 if (tb->port == port) {
263 BUG_TRAP(!hlist_empty(&tb->owners));
264 if (tb->fastreuse >= 0)
266 if (!__tcp_v4_check_established(sk,
274 tb = inet_bind_bucket_create(tcp_hashinfo.bind_bucket_cachep, head, port);
276 spin_unlock(&head->lock);
283 spin_unlock(&head->lock);
287 return -EADDRNOTAVAIL;
292 /* Head lock still held and bh's disabled */
293 inet_bind_hash(sk, tb, port);
294 if (sk_unhashed(sk)) {
295 inet_sk(sk)->sport = htons(port);
296 __inet_hash(&tcp_hashinfo, sk, 0);
298 spin_unlock(&head->lock);
301 inet_twsk_deschedule(tw, &tcp_death_row);;
309 head = &tcp_hashinfo.bhash[inet_bhashfn(snum, tcp_hashinfo.bhash_size)];
310 tb = inet_csk(sk)->icsk_bind_hash;
311 spin_lock_bh(&head->lock);
312 if (sk_head(&tb->owners) == sk && !sk->sk_bind_node.next) {
313 __inet_hash(&tcp_hashinfo, sk, 0);
314 spin_unlock_bh(&head->lock);
317 spin_unlock(&head->lock);
318 /* No definite answer... Walk to established hash table */
319 ret = __tcp_v4_check_established(sk, snum, NULL);
326 /* This will initiate an outgoing connection. */
327 int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
329 struct inet_sock *inet = inet_sk(sk);
330 struct tcp_sock *tp = tcp_sk(sk);
331 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
337 if (addr_len < sizeof(struct sockaddr_in))
340 if (usin->sin_family != AF_INET)
341 return -EAFNOSUPPORT;
343 nexthop = daddr = usin->sin_addr.s_addr;
344 if (inet->opt && inet->opt->srr) {
347 nexthop = inet->opt->faddr;
350 tmp = ip_route_connect(&rt, nexthop, inet->saddr,
351 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
353 inet->sport, usin->sin_port, sk);
357 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
362 if (!inet->opt || !inet->opt->srr)
366 inet->saddr = rt->rt_src;
367 inet->rcv_saddr = inet->saddr;
369 if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) {
370 /* Reset inherited state */
371 tp->rx_opt.ts_recent = 0;
372 tp->rx_opt.ts_recent_stamp = 0;
376 if (tcp_death_row.sysctl_tw_recycle &&
377 !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
378 struct inet_peer *peer = rt_get_peer(rt);
380 /* VJ's idea. We save last timestamp seen from
381 * the destination in peer table, when entering state TIME-WAIT
382 * and initialize rx_opt.ts_recent from it, when trying new connection.
385 if (peer && peer->tcp_ts_stamp + TCP_PAWS_MSL >= xtime.tv_sec) {
386 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
387 tp->rx_opt.ts_recent = peer->tcp_ts;
391 inet->dport = usin->sin_port;
394 tp->ext_header_len = 0;
396 tp->ext_header_len = inet->opt->optlen;
398 tp->rx_opt.mss_clamp = 536;
400 /* Socket identity is still unknown (sport may be zero).
401 * However we set state to SYN-SENT and not releasing socket
402 * lock select source port, enter ourselves into the hash tables and
403 * complete initialization after this.
405 tcp_set_state(sk, TCP_SYN_SENT);
406 err = tcp_v4_hash_connect(sk);
410 err = ip_route_newports(&rt, inet->sport, inet->dport, sk);
414 /* OK, now commit destination to socket. */
415 sk_setup_caps(sk, &rt->u.dst);
418 tp->write_seq = secure_tcp_sequence_number(inet->saddr,
423 inet->id = tp->write_seq ^ jiffies;
425 err = tcp_connect(sk);
433 /* This unhashes the socket and releases the local port, if necessary. */
434 tcp_set_state(sk, TCP_CLOSE);
436 sk->sk_route_caps = 0;
442 * This routine does path mtu discovery as defined in RFC1191.
444 static inline void do_pmtu_discovery(struct sock *sk, struct iphdr *iph,
447 struct dst_entry *dst;
448 struct inet_sock *inet = inet_sk(sk);
449 struct tcp_sock *tp = tcp_sk(sk);
451 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
452 * send out by Linux are always <576bytes so they should go through
455 if (sk->sk_state == TCP_LISTEN)
458 /* We don't check in the destentry if pmtu discovery is forbidden
459 * on this route. We just assume that no packet_to_big packets
460 * are send back when pmtu discovery is not active.
461 * There is a small race when the user changes this flag in the
462 * route, but I think that's acceptable.
464 if ((dst = __sk_dst_check(sk, 0)) == NULL)
467 dst->ops->update_pmtu(dst, mtu);
469 /* Something is about to be wrong... Remember soft error
470 * for the case, if this connection will not able to recover.
472 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
473 sk->sk_err_soft = EMSGSIZE;
477 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
478 tp->pmtu_cookie > mtu) {
479 tcp_sync_mss(sk, mtu);
481 /* Resend the TCP packet because it's
482 * clear that the old packet has been
483 * dropped. This is the new "fast" path mtu
486 tcp_simple_retransmit(sk);
487 } /* else let the usual retransmit timer handle it */
491 * This routine is called by the ICMP module when it gets some
492 * sort of error condition. If err < 0 then the socket should
493 * be closed and the error returned to the user. If err > 0
494 * it's just the icmp type << 8 | icmp code. After adjustment
495 * header points to the first 8 bytes of the tcp header. We need
496 * to find the appropriate port.
498 * The locking strategy used here is very "optimistic". When
499 * someone else accesses the socket the ICMP is just dropped
500 * and for some paths there is no check at all.
501 * A more general error queue to queue errors for later handling
502 * is probably better.
506 void tcp_v4_err(struct sk_buff *skb, u32 info)
508 struct iphdr *iph = (struct iphdr *)skb->data;
509 struct tcphdr *th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
511 struct inet_sock *inet;
512 int type = skb->h.icmph->type;
513 int code = skb->h.icmph->code;
518 if (skb->len < (iph->ihl << 2) + 8) {
519 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
523 sk = inet_lookup(&tcp_hashinfo, iph->daddr, th->dest, iph->saddr,
524 th->source, inet_iif(skb));
526 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
529 if (sk->sk_state == TCP_TIME_WAIT) {
530 inet_twsk_put((struct inet_timewait_sock *)sk);
535 /* If too many ICMPs get dropped on busy
536 * servers this needs to be solved differently.
538 if (sock_owned_by_user(sk))
539 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
541 if (sk->sk_state == TCP_CLOSE)
545 seq = ntohl(th->seq);
546 if (sk->sk_state != TCP_LISTEN &&
547 !between(seq, tp->snd_una, tp->snd_nxt)) {
548 NET_INC_STATS(LINUX_MIB_OUTOFWINDOWICMPS);
553 case ICMP_SOURCE_QUENCH:
554 /* Just silently ignore these. */
556 case ICMP_PARAMETERPROB:
559 case ICMP_DEST_UNREACH:
560 if (code > NR_ICMP_UNREACH)
563 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
564 if (!sock_owned_by_user(sk))
565 do_pmtu_discovery(sk, iph, info);
569 err = icmp_err_convert[code].errno;
571 case ICMP_TIME_EXCEEDED:
578 switch (sk->sk_state) {
579 struct request_sock *req, **prev;
581 if (sock_owned_by_user(sk))
584 req = inet_csk_search_req(sk, &prev, th->dest,
585 iph->daddr, iph->saddr);
589 /* ICMPs are not backlogged, hence we cannot get
590 an established socket here.
594 if (seq != tcp_rsk(req)->snt_isn) {
595 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
600 * Still in SYN_RECV, just remove it silently.
601 * There is no good way to pass the error to the newly
602 * created socket, and POSIX does not want network
603 * errors returned from accept().
605 inet_csk_reqsk_queue_drop(sk, req, prev);
609 case TCP_SYN_RECV: /* Cannot happen.
610 It can f.e. if SYNs crossed.
612 if (!sock_owned_by_user(sk)) {
613 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
616 sk->sk_error_report(sk);
620 sk->sk_err_soft = err;
625 /* If we've already connected we will keep trying
626 * until we time out, or the user gives up.
628 * rfc1122 4.2.3.9 allows to consider as hard errors
629 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
630 * but it is obsoleted by pmtu discovery).
632 * Note, that in modern internet, where routing is unreliable
633 * and in each dark corner broken firewalls sit, sending random
634 * errors ordered by their masters even this two messages finally lose
635 * their original sense (even Linux sends invalid PORT_UNREACHs)
637 * Now we are in compliance with RFCs.
642 if (!sock_owned_by_user(sk) && inet->recverr) {
644 sk->sk_error_report(sk);
645 } else { /* Only an error on timeout */
646 sk->sk_err_soft = err;
654 /* This routine computes an IPv4 TCP checksum. */
655 void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb)
657 struct inet_sock *inet = inet_sk(sk);
658 struct tcphdr *th = skb->h.th;
660 if (skb->ip_summed == CHECKSUM_HW) {
661 th->check = ~tcp_v4_check(th, len, inet->saddr, inet->daddr, 0);
662 skb->csum = offsetof(struct tcphdr, check);
664 th->check = tcp_v4_check(th, len, inet->saddr, inet->daddr,
665 csum_partial((char *)th,
672 * This routine will send an RST to the other tcp.
674 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
676 * Answer: if a packet caused RST, it is not for a socket
677 * existing in our system, if it is matched to a socket,
678 * it is just duplicate segment or bug in other side's TCP.
679 * So that we build reply only basing on parameters
680 * arrived with segment.
681 * Exception: precedence violation. We do not implement it in any case.
684 static void tcp_v4_send_reset(struct sk_buff *skb)
686 struct tcphdr *th = skb->h.th;
688 struct ip_reply_arg arg;
690 /* Never send a reset in response to a reset. */
694 if (((struct rtable *)skb->dst)->rt_type != RTN_LOCAL)
697 /* Swap the send and the receive. */
698 memset(&rth, 0, sizeof(struct tcphdr));
699 rth.dest = th->source;
700 rth.source = th->dest;
701 rth.doff = sizeof(struct tcphdr) / 4;
705 rth.seq = th->ack_seq;
708 rth.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
709 skb->len - (th->doff << 2));
712 memset(&arg, 0, sizeof arg);
713 arg.iov[0].iov_base = (unsigned char *)&rth;
714 arg.iov[0].iov_len = sizeof rth;
715 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
716 skb->nh.iph->saddr, /*XXX*/
717 sizeof(struct tcphdr), IPPROTO_TCP, 0);
718 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
720 ip_send_reply(tcp_socket->sk, skb, &arg, sizeof rth);
722 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
723 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
726 /* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
727 outside socket context is ugly, certainly. What can I do?
730 static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
733 struct tcphdr *th = skb->h.th;
738 struct ip_reply_arg arg;
740 memset(&rep.th, 0, sizeof(struct tcphdr));
741 memset(&arg, 0, sizeof arg);
743 arg.iov[0].iov_base = (unsigned char *)&rep;
744 arg.iov[0].iov_len = sizeof(rep.th);
746 rep.tsopt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
747 (TCPOPT_TIMESTAMP << 8) |
749 rep.tsopt[1] = htonl(tcp_time_stamp);
750 rep.tsopt[2] = htonl(ts);
751 arg.iov[0].iov_len = sizeof(rep);
754 /* Swap the send and the receive. */
755 rep.th.dest = th->source;
756 rep.th.source = th->dest;
757 rep.th.doff = arg.iov[0].iov_len / 4;
758 rep.th.seq = htonl(seq);
759 rep.th.ack_seq = htonl(ack);
761 rep.th.window = htons(win);
763 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
764 skb->nh.iph->saddr, /*XXX*/
765 arg.iov[0].iov_len, IPPROTO_TCP, 0);
766 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
768 ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len);
770 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
773 static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
775 struct inet_timewait_sock *tw = inet_twsk(sk);
776 const struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
778 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
779 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale, tcptw->tw_ts_recent);
784 static void tcp_v4_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
786 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
791 * Send a SYN-ACK after having received an ACK.
792 * This still operates on a request_sock only, not on a big
795 static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
796 struct dst_entry *dst)
798 const struct inet_request_sock *ireq = inet_rsk(req);
800 struct sk_buff * skb;
802 /* First, grab a route. */
803 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
806 skb = tcp_make_synack(sk, dst, req);
809 struct tcphdr *th = skb->h.th;
811 th->check = tcp_v4_check(th, skb->len,
814 csum_partial((char *)th, skb->len,
817 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
820 if (err == NET_XMIT_CN)
830 * IPv4 request_sock destructor.
832 static void tcp_v4_reqsk_destructor(struct request_sock *req)
834 kfree(inet_rsk(req)->opt);
837 static inline void syn_flood_warning(struct sk_buff *skb)
839 static unsigned long warntime;
841 if (time_after(jiffies, (warntime + HZ * 60))) {
844 "possible SYN flooding on port %d. Sending cookies.\n",
845 ntohs(skb->h.th->dest));
850 * Save and compile IPv4 options into the request_sock if needed.
852 static inline struct ip_options *tcp_v4_save_options(struct sock *sk,
855 struct ip_options *opt = &(IPCB(skb)->opt);
856 struct ip_options *dopt = NULL;
858 if (opt && opt->optlen) {
859 int opt_size = optlength(opt);
860 dopt = kmalloc(opt_size, GFP_ATOMIC);
862 if (ip_options_echo(dopt, skb)) {
871 struct request_sock_ops tcp_request_sock_ops = {
873 .obj_size = sizeof(struct tcp_request_sock),
874 .rtx_syn_ack = tcp_v4_send_synack,
875 .send_ack = tcp_v4_reqsk_send_ack,
876 .destructor = tcp_v4_reqsk_destructor,
877 .send_reset = tcp_v4_send_reset,
880 static struct timewait_sock_ops tcp_timewait_sock_ops = {
881 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
882 .twsk_unique = tcp_twsk_unique,
885 int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
887 struct inet_request_sock *ireq;
888 struct tcp_options_received tmp_opt;
889 struct request_sock *req;
890 __u32 saddr = skb->nh.iph->saddr;
891 __u32 daddr = skb->nh.iph->daddr;
892 __u32 isn = TCP_SKB_CB(skb)->when;
893 struct dst_entry *dst = NULL;
894 #ifdef CONFIG_SYN_COOKIES
897 #define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
900 /* Never answer to SYNs send to broadcast or multicast */
901 if (((struct rtable *)skb->dst)->rt_flags &
902 (RTCF_BROADCAST | RTCF_MULTICAST))
905 /* TW buckets are converted to open requests without
906 * limitations, they conserve resources and peer is
907 * evidently real one.
909 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
910 #ifdef CONFIG_SYN_COOKIES
911 if (sysctl_tcp_syncookies) {
918 /* Accept backlog is full. If we have already queued enough
919 * of warm entries in syn queue, drop request. It is better than
920 * clogging syn queue with openreqs with exponentially increasing
923 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
926 req = reqsk_alloc(&tcp_request_sock_ops);
930 tcp_clear_options(&tmp_opt);
931 tmp_opt.mss_clamp = 536;
932 tmp_opt.user_mss = tcp_sk(sk)->rx_opt.user_mss;
934 tcp_parse_options(skb, &tmp_opt, 0);
937 tcp_clear_options(&tmp_opt);
938 tmp_opt.saw_tstamp = 0;
941 if (tmp_opt.saw_tstamp && !tmp_opt.rcv_tsval) {
942 /* Some OSes (unknown ones, but I see them on web server, which
943 * contains information interesting only for windows'
944 * users) do not send their stamp in SYN. It is easy case.
945 * We simply do not advertise TS support.
947 tmp_opt.saw_tstamp = 0;
948 tmp_opt.tstamp_ok = 0;
950 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
952 tcp_openreq_init(req, &tmp_opt, skb);
954 ireq = inet_rsk(req);
955 ireq->loc_addr = daddr;
956 ireq->rmt_addr = saddr;
957 ireq->opt = tcp_v4_save_options(sk, skb);
959 TCP_ECN_create_request(req, skb->h.th);
962 #ifdef CONFIG_SYN_COOKIES
963 syn_flood_warning(skb);
965 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
967 struct inet_peer *peer = NULL;
969 /* VJ's idea. We save last timestamp seen
970 * from the destination in peer table, when entering
971 * state TIME-WAIT, and check against it before
972 * accepting new connection request.
974 * If "isn" is not zero, this request hit alive
975 * timewait bucket, so that all the necessary checks
976 * are made in the function processing timewait state.
978 if (tmp_opt.saw_tstamp &&
979 tcp_death_row.sysctl_tw_recycle &&
980 (dst = inet_csk_route_req(sk, req)) != NULL &&
981 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
982 peer->v4daddr == saddr) {
983 if (xtime.tv_sec < peer->tcp_ts_stamp + TCP_PAWS_MSL &&
984 (s32)(peer->tcp_ts - req->ts_recent) >
986 NET_INC_STATS_BH(LINUX_MIB_PAWSPASSIVEREJECTED);
991 /* Kill the following clause, if you dislike this way. */
992 else if (!sysctl_tcp_syncookies &&
993 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
994 (sysctl_max_syn_backlog >> 2)) &&
995 (!peer || !peer->tcp_ts_stamp) &&
996 (!dst || !dst_metric(dst, RTAX_RTT))) {
997 /* Without syncookies last quarter of
998 * backlog is filled with destinations,
999 * proven to be alive.
1000 * It means that we continue to communicate
1001 * to destinations, already remembered
1002 * to the moment of synflood.
1004 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open "
1005 "request from %u.%u.%u.%u/%u\n",
1007 ntohs(skb->h.th->source));
1012 isn = tcp_v4_init_sequence(sk, skb);
1014 tcp_rsk(req)->snt_isn = isn;
1016 if (tcp_v4_send_synack(sk, req, dst))
1022 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1029 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
1035 * The three way handshake has completed - we got a valid synack -
1036 * now create the new socket.
1038 struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1039 struct request_sock *req,
1040 struct dst_entry *dst)
1042 struct inet_request_sock *ireq;
1043 struct inet_sock *newinet;
1044 struct tcp_sock *newtp;
1047 if (sk_acceptq_is_full(sk))
1050 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
1053 newsk = tcp_create_openreq_child(sk, req, skb);
1057 sk_setup_caps(newsk, dst);
1059 newtp = tcp_sk(newsk);
1060 newinet = inet_sk(newsk);
1061 ireq = inet_rsk(req);
1062 newinet->daddr = ireq->rmt_addr;
1063 newinet->rcv_saddr = ireq->loc_addr;
1064 newinet->saddr = ireq->loc_addr;
1065 newinet->opt = ireq->opt;
1067 newinet->mc_index = inet_iif(skb);
1068 newinet->mc_ttl = skb->nh.iph->ttl;
1069 newtp->ext_header_len = 0;
1071 newtp->ext_header_len = newinet->opt->optlen;
1072 newinet->id = newtp->write_seq ^ jiffies;
1074 tcp_sync_mss(newsk, dst_mtu(dst));
1075 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
1076 tcp_initialize_rcv_mss(newsk);
1078 __inet_hash(&tcp_hashinfo, newsk, 0);
1079 __inet_inherit_port(&tcp_hashinfo, sk, newsk);
1084 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
1086 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
1091 static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1093 struct tcphdr *th = skb->h.th;
1094 struct iphdr *iph = skb->nh.iph;
1096 struct request_sock **prev;
1097 /* Find possible connection requests. */
1098 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1099 iph->saddr, iph->daddr);
1101 return tcp_check_req(sk, skb, req, prev);
1103 nsk = __inet_lookup_established(&tcp_hashinfo, skb->nh.iph->saddr,
1104 th->source, skb->nh.iph->daddr,
1105 ntohs(th->dest), inet_iif(skb));
1108 if (nsk->sk_state != TCP_TIME_WAIT) {
1112 inet_twsk_put((struct inet_timewait_sock *)nsk);
1116 #ifdef CONFIG_SYN_COOKIES
1117 if (!th->rst && !th->syn && th->ack)
1118 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1123 static int tcp_v4_checksum_init(struct sk_buff *skb)
1125 if (skb->ip_summed == CHECKSUM_HW) {
1126 if (!tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
1127 skb->nh.iph->daddr, skb->csum)) {
1128 skb->ip_summed = CHECKSUM_UNNECESSARY;
1133 skb->csum = csum_tcpudp_nofold(skb->nh.iph->saddr, skb->nh.iph->daddr,
1134 skb->len, IPPROTO_TCP, 0);
1136 if (skb->len <= 76) {
1137 return __skb_checksum_complete(skb);
1143 /* The socket must have it's spinlock held when we get
1146 * We have a potential double-lock case here, so even when
1147 * doing backlog processing we use the BH locking scheme.
1148 * This is because we cannot sleep with the original spinlock
1151 int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1153 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1154 TCP_CHECK_TIMER(sk);
1155 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len))
1157 TCP_CHECK_TIMER(sk);
1161 if (skb->len < (skb->h.th->doff << 2) || tcp_checksum_complete(skb))
1164 if (sk->sk_state == TCP_LISTEN) {
1165 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1170 if (tcp_child_process(sk, nsk, skb))
1176 TCP_CHECK_TIMER(sk);
1177 if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len))
1179 TCP_CHECK_TIMER(sk);
1183 tcp_v4_send_reset(skb);
1186 /* Be careful here. If this function gets more complicated and
1187 * gcc suffers from register pressure on the x86, sk (in %ebx)
1188 * might be destroyed here. This current version compiles correctly,
1189 * but you have been warned.
1194 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1202 int tcp_v4_rcv(struct sk_buff *skb)
1208 if (skb->pkt_type != PACKET_HOST)
1211 /* Count it even if it's bad */
1212 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1214 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1219 if (th->doff < sizeof(struct tcphdr) / 4)
1221 if (!pskb_may_pull(skb, th->doff * 4))
1224 /* An explanation is required here, I think.
1225 * Packet length and doff are validated by header prediction,
1226 * provided case of th->doff==0 is eliminated.
1227 * So, we defer the checks. */
1228 if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
1229 tcp_v4_checksum_init(skb)))
1233 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1234 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1235 skb->len - th->doff * 4);
1236 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1237 TCP_SKB_CB(skb)->when = 0;
1238 TCP_SKB_CB(skb)->flags = skb->nh.iph->tos;
1239 TCP_SKB_CB(skb)->sacked = 0;
1241 sk = __inet_lookup(&tcp_hashinfo, skb->nh.iph->saddr, th->source,
1242 skb->nh.iph->daddr, ntohs(th->dest),
1249 if (sk->sk_state == TCP_TIME_WAIT)
1252 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1253 goto discard_and_relse;
1255 if (sk_filter(sk, skb, 0))
1256 goto discard_and_relse;
1262 if (!sock_owned_by_user(sk)) {
1263 if (!tcp_prequeue(sk, skb))
1264 ret = tcp_v4_do_rcv(sk, skb);
1266 sk_add_backlog(sk, skb);
1274 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1277 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1279 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1281 tcp_v4_send_reset(skb);
1285 /* Discard frame. */
1294 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1295 inet_twsk_put((struct inet_timewait_sock *) sk);
1299 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1300 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1301 inet_twsk_put((struct inet_timewait_sock *) sk);
1304 switch (tcp_timewait_state_process((struct inet_timewait_sock *)sk,
1307 struct sock *sk2 = inet_lookup_listener(&tcp_hashinfo,
1312 inet_twsk_deschedule((struct inet_timewait_sock *)sk,
1314 inet_twsk_put((struct inet_timewait_sock *)sk);
1318 /* Fall through to ACK */
1321 tcp_v4_timewait_ack(sk, skb);
1325 case TCP_TW_SUCCESS:;
1330 /* VJ's idea. Save last timestamp seen from this destination
1331 * and hold it at least for normal timewait interval to use for duplicate
1332 * segment detection in subsequent connections, before they enter synchronized
1336 int tcp_v4_remember_stamp(struct sock *sk)
1338 struct inet_sock *inet = inet_sk(sk);
1339 struct tcp_sock *tp = tcp_sk(sk);
1340 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1341 struct inet_peer *peer = NULL;
1344 if (!rt || rt->rt_dst != inet->daddr) {
1345 peer = inet_getpeer(inet->daddr, 1);
1349 rt_bind_peer(rt, 1);
1354 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
1355 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1356 peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {
1357 peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;
1358 peer->tcp_ts = tp->rx_opt.ts_recent;
1368 int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
1370 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
1373 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1375 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
1376 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1377 peer->tcp_ts_stamp <= tcptw->tw_ts_recent_stamp)) {
1378 peer->tcp_ts_stamp = tcptw->tw_ts_recent_stamp;
1379 peer->tcp_ts = tcptw->tw_ts_recent;
1388 struct inet_connection_sock_af_ops ipv4_specific = {
1389 .queue_xmit = ip_queue_xmit,
1390 .send_check = tcp_v4_send_check,
1391 .rebuild_header = inet_sk_rebuild_header,
1392 .conn_request = tcp_v4_conn_request,
1393 .syn_recv_sock = tcp_v4_syn_recv_sock,
1394 .remember_stamp = tcp_v4_remember_stamp,
1395 .net_header_len = sizeof(struct iphdr),
1396 .setsockopt = ip_setsockopt,
1397 .getsockopt = ip_getsockopt,
1398 .addr2sockaddr = inet_csk_addr2sockaddr,
1399 .sockaddr_len = sizeof(struct sockaddr_in),
1402 /* NOTE: A lot of things set to zero explicitly by call to
1403 * sk_alloc() so need not be done here.
1405 static int tcp_v4_init_sock(struct sock *sk)
1407 struct inet_connection_sock *icsk = inet_csk(sk);
1408 struct tcp_sock *tp = tcp_sk(sk);
1410 skb_queue_head_init(&tp->out_of_order_queue);
1411 tcp_init_xmit_timers(sk);
1412 tcp_prequeue_init(tp);
1414 icsk->icsk_rto = TCP_TIMEOUT_INIT;
1415 tp->mdev = TCP_TIMEOUT_INIT;
1417 /* So many TCP implementations out there (incorrectly) count the
1418 * initial SYN frame in their delayed-ACK and congestion control
1419 * algorithms that we must have the following bandaid to talk
1420 * efficiently to them. -DaveM
1424 /* See draft-stevens-tcpca-spec-01 for discussion of the
1425 * initialization of these values.
1427 tp->snd_ssthresh = 0x7fffffff; /* Infinity */
1428 tp->snd_cwnd_clamp = ~0;
1429 tp->mss_cache = 536;
1431 tp->reordering = sysctl_tcp_reordering;
1432 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
1434 sk->sk_state = TCP_CLOSE;
1436 sk->sk_write_space = sk_stream_write_space;
1437 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1439 icsk->icsk_af_ops = &ipv4_specific;
1441 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1442 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1444 atomic_inc(&tcp_sockets_allocated);
1449 int tcp_v4_destroy_sock(struct sock *sk)
1451 struct tcp_sock *tp = tcp_sk(sk);
1453 tcp_clear_xmit_timers(sk);
1455 tcp_cleanup_congestion_control(sk);
1457 /* Cleanup up the write buffer. */
1458 sk_stream_writequeue_purge(sk);
1460 /* Cleans up our, hopefully empty, out_of_order_queue. */
1461 __skb_queue_purge(&tp->out_of_order_queue);
1463 /* Clean prequeue, it must be empty really */
1464 __skb_queue_purge(&tp->ucopy.prequeue);
1466 /* Clean up a referenced TCP bind bucket. */
1467 if (inet_csk(sk)->icsk_bind_hash)
1468 inet_put_port(&tcp_hashinfo, sk);
1471 * If sendmsg cached page exists, toss it.
1473 if (sk->sk_sndmsg_page) {
1474 __free_page(sk->sk_sndmsg_page);
1475 sk->sk_sndmsg_page = NULL;
1478 atomic_dec(&tcp_sockets_allocated);
1483 EXPORT_SYMBOL(tcp_v4_destroy_sock);
1485 #ifdef CONFIG_PROC_FS
1486 /* Proc filesystem TCP sock list dumping. */
1488 static inline struct inet_timewait_sock *tw_head(struct hlist_head *head)
1490 return hlist_empty(head) ? NULL :
1491 list_entry(head->first, struct inet_timewait_sock, tw_node);
1494 static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
1496 return tw->tw_node.next ?
1497 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
1500 static void *listening_get_next(struct seq_file *seq, void *cur)
1502 struct inet_connection_sock *icsk;
1503 struct hlist_node *node;
1504 struct sock *sk = cur;
1505 struct tcp_iter_state* st = seq->private;
1509 sk = sk_head(&tcp_hashinfo.listening_hash[0]);
1515 if (st->state == TCP_SEQ_STATE_OPENREQ) {
1516 struct request_sock *req = cur;
1518 icsk = inet_csk(st->syn_wait_sk);
1522 if (req->rsk_ops->family == st->family) {
1528 if (++st->sbucket >= TCP_SYNQ_HSIZE)
1531 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
1533 sk = sk_next(st->syn_wait_sk);
1534 st->state = TCP_SEQ_STATE_LISTENING;
1535 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1537 icsk = inet_csk(sk);
1538 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1539 if (reqsk_queue_len(&icsk->icsk_accept_queue))
1541 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1545 sk_for_each_from(sk, node) {
1546 if (sk->sk_family == st->family) {
1550 icsk = inet_csk(sk);
1551 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1552 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
1554 st->uid = sock_i_uid(sk);
1555 st->syn_wait_sk = sk;
1556 st->state = TCP_SEQ_STATE_OPENREQ;
1560 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1562 if (++st->bucket < INET_LHTABLE_SIZE) {
1563 sk = sk_head(&tcp_hashinfo.listening_hash[st->bucket]);
1571 static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
1573 void *rc = listening_get_next(seq, NULL);
1575 while (rc && *pos) {
1576 rc = listening_get_next(seq, rc);
1582 static void *established_get_first(struct seq_file *seq)
1584 struct tcp_iter_state* st = seq->private;
1587 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
1589 struct hlist_node *node;
1590 struct inet_timewait_sock *tw;
1592 /* We can reschedule _before_ having picked the target: */
1593 cond_resched_softirq();
1595 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
1596 sk_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
1597 if (sk->sk_family != st->family) {
1603 st->state = TCP_SEQ_STATE_TIME_WAIT;
1604 inet_twsk_for_each(tw, node,
1605 &tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain) {
1606 if (tw->tw_family != st->family) {
1612 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1613 st->state = TCP_SEQ_STATE_ESTABLISHED;
1619 static void *established_get_next(struct seq_file *seq, void *cur)
1621 struct sock *sk = cur;
1622 struct inet_timewait_sock *tw;
1623 struct hlist_node *node;
1624 struct tcp_iter_state* st = seq->private;
1628 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
1632 while (tw && tw->tw_family != st->family) {
1639 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1640 st->state = TCP_SEQ_STATE_ESTABLISHED;
1642 /* We can reschedule between buckets: */
1643 cond_resched_softirq();
1645 if (++st->bucket < tcp_hashinfo.ehash_size) {
1646 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
1647 sk = sk_head(&tcp_hashinfo.ehash[st->bucket].chain);
1655 sk_for_each_from(sk, node) {
1656 if (sk->sk_family == st->family)
1660 st->state = TCP_SEQ_STATE_TIME_WAIT;
1661 tw = tw_head(&tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain);
1669 static void *established_get_idx(struct seq_file *seq, loff_t pos)
1671 void *rc = established_get_first(seq);
1674 rc = established_get_next(seq, rc);
1680 static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
1683 struct tcp_iter_state* st = seq->private;
1685 inet_listen_lock(&tcp_hashinfo);
1686 st->state = TCP_SEQ_STATE_LISTENING;
1687 rc = listening_get_idx(seq, &pos);
1690 inet_listen_unlock(&tcp_hashinfo);
1692 st->state = TCP_SEQ_STATE_ESTABLISHED;
1693 rc = established_get_idx(seq, pos);
1699 static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
1701 struct tcp_iter_state* st = seq->private;
1702 st->state = TCP_SEQ_STATE_LISTENING;
1704 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
1707 static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1710 struct tcp_iter_state* st;
1712 if (v == SEQ_START_TOKEN) {
1713 rc = tcp_get_idx(seq, 0);
1718 switch (st->state) {
1719 case TCP_SEQ_STATE_OPENREQ:
1720 case TCP_SEQ_STATE_LISTENING:
1721 rc = listening_get_next(seq, v);
1723 inet_listen_unlock(&tcp_hashinfo);
1725 st->state = TCP_SEQ_STATE_ESTABLISHED;
1726 rc = established_get_first(seq);
1729 case TCP_SEQ_STATE_ESTABLISHED:
1730 case TCP_SEQ_STATE_TIME_WAIT:
1731 rc = established_get_next(seq, v);
1739 static void tcp_seq_stop(struct seq_file *seq, void *v)
1741 struct tcp_iter_state* st = seq->private;
1743 switch (st->state) {
1744 case TCP_SEQ_STATE_OPENREQ:
1746 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
1747 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1749 case TCP_SEQ_STATE_LISTENING:
1750 if (v != SEQ_START_TOKEN)
1751 inet_listen_unlock(&tcp_hashinfo);
1753 case TCP_SEQ_STATE_TIME_WAIT:
1754 case TCP_SEQ_STATE_ESTABLISHED:
1756 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1762 static int tcp_seq_open(struct inode *inode, struct file *file)
1764 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
1765 struct seq_file *seq;
1766 struct tcp_iter_state *s;
1769 if (unlikely(afinfo == NULL))
1772 s = kmalloc(sizeof(*s), GFP_KERNEL);
1775 memset(s, 0, sizeof(*s));
1776 s->family = afinfo->family;
1777 s->seq_ops.start = tcp_seq_start;
1778 s->seq_ops.next = tcp_seq_next;
1779 s->seq_ops.show = afinfo->seq_show;
1780 s->seq_ops.stop = tcp_seq_stop;
1782 rc = seq_open(file, &s->seq_ops);
1785 seq = file->private_data;
1794 int tcp_proc_register(struct tcp_seq_afinfo *afinfo)
1797 struct proc_dir_entry *p;
1801 afinfo->seq_fops->owner = afinfo->owner;
1802 afinfo->seq_fops->open = tcp_seq_open;
1803 afinfo->seq_fops->read = seq_read;
1804 afinfo->seq_fops->llseek = seq_lseek;
1805 afinfo->seq_fops->release = seq_release_private;
1807 p = proc_net_fops_create(afinfo->name, S_IRUGO, afinfo->seq_fops);
1815 void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo)
1819 proc_net_remove(afinfo->name);
1820 memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops));
1823 static void get_openreq4(struct sock *sk, struct request_sock *req,
1824 char *tmpbuf, int i, int uid)
1826 const struct inet_request_sock *ireq = inet_rsk(req);
1827 int ttd = req->expires - jiffies;
1829 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
1830 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p",
1833 ntohs(inet_sk(sk)->sport),
1835 ntohs(ireq->rmt_port),
1837 0, 0, /* could print option size, but that is af dependent. */
1838 1, /* timers active (only the expire timer) */
1839 jiffies_to_clock_t(ttd),
1842 0, /* non standard timer */
1843 0, /* open_requests have no inode */
1844 atomic_read(&sk->sk_refcnt),
1848 static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i)
1851 unsigned long timer_expires;
1852 struct tcp_sock *tp = tcp_sk(sp);
1853 const struct inet_connection_sock *icsk = inet_csk(sp);
1854 struct inet_sock *inet = inet_sk(sp);
1855 unsigned int dest = inet->daddr;
1856 unsigned int src = inet->rcv_saddr;
1857 __u16 destp = ntohs(inet->dport);
1858 __u16 srcp = ntohs(inet->sport);
1860 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
1862 timer_expires = icsk->icsk_timeout;
1863 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
1865 timer_expires = icsk->icsk_timeout;
1866 } else if (timer_pending(&sp->sk_timer)) {
1868 timer_expires = sp->sk_timer.expires;
1871 timer_expires = jiffies;
1874 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
1875 "%08X %5d %8d %lu %d %p %u %u %u %u %d",
1876 i, src, srcp, dest, destp, sp->sk_state,
1877 tp->write_seq - tp->snd_una, tp->rcv_nxt - tp->copied_seq,
1879 jiffies_to_clock_t(timer_expires - jiffies),
1880 icsk->icsk_retransmits,
1882 icsk->icsk_probes_out,
1884 atomic_read(&sp->sk_refcnt), sp,
1887 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
1889 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh);
1892 static void get_timewait4_sock(struct inet_timewait_sock *tw, char *tmpbuf, int i)
1894 unsigned int dest, src;
1896 int ttd = tw->tw_ttd - jiffies;
1901 dest = tw->tw_daddr;
1902 src = tw->tw_rcv_saddr;
1903 destp = ntohs(tw->tw_dport);
1904 srcp = ntohs(tw->tw_sport);
1906 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
1907 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p",
1908 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
1909 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
1910 atomic_read(&tw->tw_refcnt), tw);
1915 static int tcp4_seq_show(struct seq_file *seq, void *v)
1917 struct tcp_iter_state* st;
1918 char tmpbuf[TMPSZ + 1];
1920 if (v == SEQ_START_TOKEN) {
1921 seq_printf(seq, "%-*s\n", TMPSZ - 1,
1922 " sl local_address rem_address st tx_queue "
1923 "rx_queue tr tm->when retrnsmt uid timeout "
1929 switch (st->state) {
1930 case TCP_SEQ_STATE_LISTENING:
1931 case TCP_SEQ_STATE_ESTABLISHED:
1932 get_tcp4_sock(v, tmpbuf, st->num);
1934 case TCP_SEQ_STATE_OPENREQ:
1935 get_openreq4(st->syn_wait_sk, v, tmpbuf, st->num, st->uid);
1937 case TCP_SEQ_STATE_TIME_WAIT:
1938 get_timewait4_sock(v, tmpbuf, st->num);
1941 seq_printf(seq, "%-*s\n", TMPSZ - 1, tmpbuf);
1946 static struct file_operations tcp4_seq_fops;
1947 static struct tcp_seq_afinfo tcp4_seq_afinfo = {
1948 .owner = THIS_MODULE,
1951 .seq_show = tcp4_seq_show,
1952 .seq_fops = &tcp4_seq_fops,
1955 int __init tcp4_proc_init(void)
1957 return tcp_proc_register(&tcp4_seq_afinfo);
1960 void tcp4_proc_exit(void)
1962 tcp_proc_unregister(&tcp4_seq_afinfo);
1964 #endif /* CONFIG_PROC_FS */
1966 struct proto tcp_prot = {
1968 .owner = THIS_MODULE,
1970 .connect = tcp_v4_connect,
1971 .disconnect = tcp_disconnect,
1972 .accept = inet_csk_accept,
1974 .init = tcp_v4_init_sock,
1975 .destroy = tcp_v4_destroy_sock,
1976 .shutdown = tcp_shutdown,
1977 .setsockopt = tcp_setsockopt,
1978 .getsockopt = tcp_getsockopt,
1979 .sendmsg = tcp_sendmsg,
1980 .recvmsg = tcp_recvmsg,
1981 .backlog_rcv = tcp_v4_do_rcv,
1982 .hash = tcp_v4_hash,
1983 .unhash = tcp_unhash,
1984 .get_port = tcp_v4_get_port,
1985 .enter_memory_pressure = tcp_enter_memory_pressure,
1986 .sockets_allocated = &tcp_sockets_allocated,
1987 .orphan_count = &tcp_orphan_count,
1988 .memory_allocated = &tcp_memory_allocated,
1989 .memory_pressure = &tcp_memory_pressure,
1990 .sysctl_mem = sysctl_tcp_mem,
1991 .sysctl_wmem = sysctl_tcp_wmem,
1992 .sysctl_rmem = sysctl_tcp_rmem,
1993 .max_header = MAX_TCP_HEADER,
1994 .obj_size = sizeof(struct tcp_sock),
1995 .twsk_prot = &tcp_timewait_sock_ops,
1996 .rsk_prot = &tcp_request_sock_ops,
2001 void __init tcp_v4_init(struct net_proto_family *ops)
2003 int err = sock_create_kern(PF_INET, SOCK_RAW, IPPROTO_TCP, &tcp_socket);
2005 panic("Failed to create the TCP control socket.\n");
2006 tcp_socket->sk->sk_allocation = GFP_ATOMIC;
2007 inet_sk(tcp_socket->sk)->uc_ttl = -1;
2009 /* Unhash it so that IP input processing does not even
2010 * see it, we do not wish this socket to see incoming
2013 tcp_socket->sk->sk_prot->unhash(tcp_socket->sk);
2016 EXPORT_SYMBOL(ipv4_specific);
2017 EXPORT_SYMBOL(inet_bind_bucket_create);
2018 EXPORT_SYMBOL(tcp_hashinfo);
2019 EXPORT_SYMBOL(tcp_prot);
2020 EXPORT_SYMBOL(tcp_unhash);
2021 EXPORT_SYMBOL(tcp_v4_conn_request);
2022 EXPORT_SYMBOL(tcp_v4_connect);
2023 EXPORT_SYMBOL(tcp_v4_do_rcv);
2024 EXPORT_SYMBOL(tcp_v4_remember_stamp);
2025 EXPORT_SYMBOL(tcp_v4_send_check);
2026 EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
2028 #ifdef CONFIG_PROC_FS
2029 EXPORT_SYMBOL(tcp_proc_register);
2030 EXPORT_SYMBOL(tcp_proc_unregister);
2032 EXPORT_SYMBOL(sysctl_local_port_range);
2033 EXPORT_SYMBOL(sysctl_tcp_low_latency);
2034 EXPORT_SYMBOL(sysctl_tcp_tw_reuse);