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).
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>
80 #include <linux/vserver/debug.h>
82 int sysctl_tcp_tw_reuse;
83 int sysctl_tcp_low_latency;
85 /* Check TCP sequence numbers in ICMP packets. */
86 #define ICMP_MIN_LENGTH 8
88 /* Socket used for sending RSTs */
89 static struct socket *tcp_socket;
91 void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb);
93 struct inet_hashinfo __cacheline_aligned tcp_hashinfo = {
94 .lhash_lock = RW_LOCK_UNLOCKED,
95 .lhash_users = ATOMIC_INIT(0),
96 .lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(tcp_hashinfo.lhash_wait),
99 static int tcp_v4_get_port(struct sock *sk, unsigned short snum)
101 return inet_csk_get_port(&tcp_hashinfo, sk, snum,
102 inet_csk_bind_conflict);
105 static void tcp_v4_hash(struct sock *sk)
107 inet_hash(&tcp_hashinfo, sk);
110 void tcp_unhash(struct sock *sk)
112 inet_unhash(&tcp_hashinfo, sk);
115 static inline __u32 tcp_v4_init_sequence(struct sock *sk, struct sk_buff *skb)
117 return secure_tcp_sequence_number(skb->nh.iph->daddr,
123 int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
125 const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
126 struct tcp_sock *tp = tcp_sk(sk);
128 /* With PAWS, it is safe from the viewpoint
129 of data integrity. Even without PAWS it is safe provided sequence
130 spaces do not overlap i.e. at data rates <= 80Mbit/sec.
132 Actually, the idea is close to VJ's one, only timestamp cache is
133 held not per host, but per port pair and TW bucket is used as state
136 If TW bucket has been already destroyed we fall back to VJ's scheme
137 and use initial timestamp retrieved from peer table.
139 if (tcptw->tw_ts_recent_stamp &&
140 (twp == NULL || (sysctl_tcp_tw_reuse &&
141 xtime.tv_sec - tcptw->tw_ts_recent_stamp > 1))) {
142 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
143 if (tp->write_seq == 0)
145 tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
146 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
154 EXPORT_SYMBOL_GPL(tcp_twsk_unique);
156 /* This will initiate an outgoing connection. */
157 int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
159 struct inet_sock *inet = inet_sk(sk);
160 struct tcp_sock *tp = tcp_sk(sk);
161 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
167 if (addr_len < sizeof(struct sockaddr_in))
170 if (usin->sin_family != AF_INET)
171 return -EAFNOSUPPORT;
173 nexthop = daddr = usin->sin_addr.s_addr;
174 if (inet->opt && inet->opt->srr) {
177 nexthop = inet->opt->faddr;
180 tmp = ip_route_connect(&rt, nexthop, inet->saddr,
181 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
183 inet->sport, usin->sin_port, sk);
187 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
192 if (!inet->opt || !inet->opt->srr)
196 inet->saddr = rt->rt_src;
197 inet->rcv_saddr = inet->saddr;
199 if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) {
200 /* Reset inherited state */
201 tp->rx_opt.ts_recent = 0;
202 tp->rx_opt.ts_recent_stamp = 0;
206 if (tcp_death_row.sysctl_tw_recycle &&
207 !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
208 struct inet_peer *peer = rt_get_peer(rt);
210 /* VJ's idea. We save last timestamp seen from
211 * the destination in peer table, when entering state TIME-WAIT
212 * and initialize rx_opt.ts_recent from it, when trying new connection.
215 if (peer && peer->tcp_ts_stamp + TCP_PAWS_MSL >= xtime.tv_sec) {
216 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
217 tp->rx_opt.ts_recent = peer->tcp_ts;
221 inet->dport = usin->sin_port;
224 inet_csk(sk)->icsk_ext_hdr_len = 0;
226 inet_csk(sk)->icsk_ext_hdr_len = inet->opt->optlen;
228 tp->rx_opt.mss_clamp = 536;
230 /* Socket identity is still unknown (sport may be zero).
231 * However we set state to SYN-SENT and not releasing socket
232 * lock select source port, enter ourselves into the hash tables and
233 * complete initialization after this.
235 tcp_set_state(sk, TCP_SYN_SENT);
236 err = inet_hash_connect(&tcp_death_row, sk);
240 err = ip_route_newports(&rt, IPPROTO_TCP, inet->sport, inet->dport, sk);
244 /* OK, now commit destination to socket. */
245 sk_setup_caps(sk, &rt->u.dst);
248 tp->write_seq = secure_tcp_sequence_number(inet->saddr,
253 inet->id = tp->write_seq ^ jiffies;
255 err = tcp_connect(sk);
263 /* This unhashes the socket and releases the local port, if necessary. */
264 tcp_set_state(sk, TCP_CLOSE);
266 sk->sk_route_caps = 0;
272 * This routine does path mtu discovery as defined in RFC1191.
274 static void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, u32 mtu)
276 struct dst_entry *dst;
277 struct inet_sock *inet = inet_sk(sk);
279 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
280 * send out by Linux are always <576bytes so they should go through
283 if (sk->sk_state == TCP_LISTEN)
286 /* We don't check in the destentry if pmtu discovery is forbidden
287 * on this route. We just assume that no packet_to_big packets
288 * are send back when pmtu discovery is not active.
289 * There is a small race when the user changes this flag in the
290 * route, but I think that's acceptable.
292 if ((dst = __sk_dst_check(sk, 0)) == NULL)
295 dst->ops->update_pmtu(dst, mtu);
297 /* Something is about to be wrong... Remember soft error
298 * for the case, if this connection will not able to recover.
300 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
301 sk->sk_err_soft = EMSGSIZE;
305 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
306 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
307 tcp_sync_mss(sk, mtu);
309 /* Resend the TCP packet because it's
310 * clear that the old packet has been
311 * dropped. This is the new "fast" path mtu
314 tcp_simple_retransmit(sk);
315 } /* else let the usual retransmit timer handle it */
319 * This routine is called by the ICMP module when it gets some
320 * sort of error condition. If err < 0 then the socket should
321 * be closed and the error returned to the user. If err > 0
322 * it's just the icmp type << 8 | icmp code. After adjustment
323 * header points to the first 8 bytes of the tcp header. We need
324 * to find the appropriate port.
326 * The locking strategy used here is very "optimistic". When
327 * someone else accesses the socket the ICMP is just dropped
328 * and for some paths there is no check at all.
329 * A more general error queue to queue errors for later handling
330 * is probably better.
334 void tcp_v4_err(struct sk_buff *skb, u32 info)
336 struct iphdr *iph = (struct iphdr *)skb->data;
337 struct tcphdr *th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
339 struct inet_sock *inet;
340 int type = skb->h.icmph->type;
341 int code = skb->h.icmph->code;
346 if (skb->len < (iph->ihl << 2) + 8) {
347 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
351 sk = inet_lookup(&tcp_hashinfo, iph->daddr, th->dest, iph->saddr,
352 th->source, inet_iif(skb));
354 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
357 if (sk->sk_state == TCP_TIME_WAIT) {
358 inet_twsk_put((struct inet_timewait_sock *)sk);
363 /* If too many ICMPs get dropped on busy
364 * servers this needs to be solved differently.
366 if (sock_owned_by_user(sk))
367 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
369 if (sk->sk_state == TCP_CLOSE)
373 seq = ntohl(th->seq);
374 if (sk->sk_state != TCP_LISTEN &&
375 !between(seq, tp->snd_una, tp->snd_nxt)) {
376 NET_INC_STATS(LINUX_MIB_OUTOFWINDOWICMPS);
381 case ICMP_SOURCE_QUENCH:
382 /* Just silently ignore these. */
384 case ICMP_PARAMETERPROB:
387 case ICMP_DEST_UNREACH:
388 if (code > NR_ICMP_UNREACH)
391 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
392 if (!sock_owned_by_user(sk))
393 do_pmtu_discovery(sk, iph, info);
397 err = icmp_err_convert[code].errno;
399 case ICMP_TIME_EXCEEDED:
406 switch (sk->sk_state) {
407 struct request_sock *req, **prev;
409 if (sock_owned_by_user(sk))
412 req = inet_csk_search_req(sk, &prev, th->dest,
413 iph->daddr, iph->saddr);
417 /* ICMPs are not backlogged, hence we cannot get
418 an established socket here.
422 if (seq != tcp_rsk(req)->snt_isn) {
423 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
428 * Still in SYN_RECV, just remove it silently.
429 * There is no good way to pass the error to the newly
430 * created socket, and POSIX does not want network
431 * errors returned from accept().
433 inet_csk_reqsk_queue_drop(sk, req, prev);
437 case TCP_SYN_RECV: /* Cannot happen.
438 It can f.e. if SYNs crossed.
440 if (!sock_owned_by_user(sk)) {
441 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
444 sk->sk_error_report(sk);
448 sk->sk_err_soft = err;
453 /* If we've already connected we will keep trying
454 * until we time out, or the user gives up.
456 * rfc1122 4.2.3.9 allows to consider as hard errors
457 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
458 * but it is obsoleted by pmtu discovery).
460 * Note, that in modern internet, where routing is unreliable
461 * and in each dark corner broken firewalls sit, sending random
462 * errors ordered by their masters even this two messages finally lose
463 * their original sense (even Linux sends invalid PORT_UNREACHs)
465 * Now we are in compliance with RFCs.
470 if (!sock_owned_by_user(sk) && inet->recverr) {
472 sk->sk_error_report(sk);
473 } else { /* Only an error on timeout */
474 sk->sk_err_soft = err;
482 /* This routine computes an IPv4 TCP checksum. */
483 void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb)
485 struct inet_sock *inet = inet_sk(sk);
486 struct tcphdr *th = skb->h.th;
488 if (skb->ip_summed == CHECKSUM_HW) {
489 th->check = ~tcp_v4_check(th, len, inet->saddr, inet->daddr, 0);
490 skb->csum = offsetof(struct tcphdr, check);
492 th->check = tcp_v4_check(th, len, inet->saddr, inet->daddr,
493 csum_partial((char *)th,
500 * This routine will send an RST to the other tcp.
502 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
504 * Answer: if a packet caused RST, it is not for a socket
505 * existing in our system, if it is matched to a socket,
506 * it is just duplicate segment or bug in other side's TCP.
507 * So that we build reply only basing on parameters
508 * arrived with segment.
509 * Exception: precedence violation. We do not implement it in any case.
512 static void tcp_v4_send_reset(struct sk_buff *skb)
514 struct tcphdr *th = skb->h.th;
516 struct ip_reply_arg arg;
518 /* Never send a reset in response to a reset. */
522 if (((struct rtable *)skb->dst)->rt_type != RTN_LOCAL)
525 /* Swap the send and the receive. */
526 memset(&rth, 0, sizeof(struct tcphdr));
527 rth.dest = th->source;
528 rth.source = th->dest;
529 rth.doff = sizeof(struct tcphdr) / 4;
533 rth.seq = th->ack_seq;
536 rth.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
537 skb->len - (th->doff << 2));
540 memset(&arg, 0, sizeof arg);
541 arg.iov[0].iov_base = (unsigned char *)&rth;
542 arg.iov[0].iov_len = sizeof rth;
543 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
544 skb->nh.iph->saddr, /*XXX*/
545 sizeof(struct tcphdr), IPPROTO_TCP, 0);
546 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
548 ip_send_reply(tcp_socket->sk, skb, &arg, sizeof rth);
550 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
551 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
554 /* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
555 outside socket context is ugly, certainly. What can I do?
558 static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
561 struct tcphdr *th = skb->h.th;
566 struct ip_reply_arg arg;
568 memset(&rep.th, 0, sizeof(struct tcphdr));
569 memset(&arg, 0, sizeof arg);
571 arg.iov[0].iov_base = (unsigned char *)&rep;
572 arg.iov[0].iov_len = sizeof(rep.th);
574 rep.tsopt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
575 (TCPOPT_TIMESTAMP << 8) |
577 rep.tsopt[1] = htonl(tcp_time_stamp);
578 rep.tsopt[2] = htonl(ts);
579 arg.iov[0].iov_len = sizeof(rep);
582 /* Swap the send and the receive. */
583 rep.th.dest = th->source;
584 rep.th.source = th->dest;
585 rep.th.doff = arg.iov[0].iov_len / 4;
586 rep.th.seq = htonl(seq);
587 rep.th.ack_seq = htonl(ack);
589 rep.th.window = htons(win);
591 arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
592 skb->nh.iph->saddr, /*XXX*/
593 arg.iov[0].iov_len, IPPROTO_TCP, 0);
594 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
596 ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len);
598 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
601 static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
603 struct inet_timewait_sock *tw = inet_twsk(sk);
604 const struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
606 tcp_v4_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
607 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale, tcptw->tw_ts_recent);
612 static void tcp_v4_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
614 tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
619 * Send a SYN-ACK after having received an ACK.
620 * This still operates on a request_sock only, not on a big
623 static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
624 struct dst_entry *dst)
626 const struct inet_request_sock *ireq = inet_rsk(req);
628 struct sk_buff * skb;
630 /* First, grab a route. */
631 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
634 skb = tcp_make_synack(sk, dst, req);
637 struct tcphdr *th = skb->h.th;
639 th->check = tcp_v4_check(th, skb->len,
642 csum_partial((char *)th, skb->len,
645 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
648 if (err == NET_XMIT_CN)
658 * IPv4 request_sock destructor.
660 static void tcp_v4_reqsk_destructor(struct request_sock *req)
662 kfree(inet_rsk(req)->opt);
665 #ifdef CONFIG_SYN_COOKIES
666 static void syn_flood_warning(struct sk_buff *skb)
668 static unsigned long warntime;
670 if (time_after(jiffies, (warntime + HZ * 60))) {
673 "possible SYN flooding on port %d. Sending cookies.\n",
674 ntohs(skb->h.th->dest));
680 * Save and compile IPv4 options into the request_sock if needed.
682 static struct ip_options *tcp_v4_save_options(struct sock *sk,
685 struct ip_options *opt = &(IPCB(skb)->opt);
686 struct ip_options *dopt = NULL;
688 if (opt && opt->optlen) {
689 int opt_size = optlength(opt);
690 dopt = kmalloc(opt_size, GFP_ATOMIC);
692 if (ip_options_echo(dopt, skb)) {
701 struct request_sock_ops tcp_request_sock_ops = {
703 .obj_size = sizeof(struct tcp_request_sock),
704 .rtx_syn_ack = tcp_v4_send_synack,
705 .send_ack = tcp_v4_reqsk_send_ack,
706 .destructor = tcp_v4_reqsk_destructor,
707 .send_reset = tcp_v4_send_reset,
710 static struct timewait_sock_ops tcp_timewait_sock_ops = {
711 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
712 .twsk_unique = tcp_twsk_unique,
715 int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
717 struct inet_request_sock *ireq;
718 struct tcp_options_received tmp_opt;
719 struct request_sock *req;
720 __u32 saddr = skb->nh.iph->saddr;
721 __u32 daddr = skb->nh.iph->daddr;
722 __u32 isn = TCP_SKB_CB(skb)->when;
723 struct dst_entry *dst = NULL;
724 #ifdef CONFIG_SYN_COOKIES
727 #define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
730 /* Never answer to SYNs send to broadcast or multicast */
731 if (((struct rtable *)skb->dst)->rt_flags &
732 (RTCF_BROADCAST | RTCF_MULTICAST))
735 /* TW buckets are converted to open requests without
736 * limitations, they conserve resources and peer is
737 * evidently real one.
739 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
740 #ifdef CONFIG_SYN_COOKIES
741 if (sysctl_tcp_syncookies) {
748 /* Accept backlog is full. If we have already queued enough
749 * of warm entries in syn queue, drop request. It is better than
750 * clogging syn queue with openreqs with exponentially increasing
753 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
756 req = reqsk_alloc(&tcp_request_sock_ops);
760 tcp_clear_options(&tmp_opt);
761 tmp_opt.mss_clamp = 536;
762 tmp_opt.user_mss = tcp_sk(sk)->rx_opt.user_mss;
764 tcp_parse_options(skb, &tmp_opt, 0);
767 tcp_clear_options(&tmp_opt);
768 tmp_opt.saw_tstamp = 0;
771 if (tmp_opt.saw_tstamp && !tmp_opt.rcv_tsval) {
772 /* Some OSes (unknown ones, but I see them on web server, which
773 * contains information interesting only for windows'
774 * users) do not send their stamp in SYN. It is easy case.
775 * We simply do not advertise TS support.
777 tmp_opt.saw_tstamp = 0;
778 tmp_opt.tstamp_ok = 0;
780 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
782 tcp_openreq_init(req, &tmp_opt, skb);
784 ireq = inet_rsk(req);
785 ireq->loc_addr = daddr;
786 ireq->rmt_addr = saddr;
787 ireq->opt = tcp_v4_save_options(sk, skb);
789 TCP_ECN_create_request(req, skb->h.th);
792 #ifdef CONFIG_SYN_COOKIES
793 syn_flood_warning(skb);
795 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
797 struct inet_peer *peer = NULL;
799 /* VJ's idea. We save last timestamp seen
800 * from the destination in peer table, when entering
801 * state TIME-WAIT, and check against it before
802 * accepting new connection request.
804 * If "isn" is not zero, this request hit alive
805 * timewait bucket, so that all the necessary checks
806 * are made in the function processing timewait state.
808 if (tmp_opt.saw_tstamp &&
809 tcp_death_row.sysctl_tw_recycle &&
810 (dst = inet_csk_route_req(sk, req)) != NULL &&
811 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
812 peer->v4daddr == saddr) {
813 if (xtime.tv_sec < peer->tcp_ts_stamp + TCP_PAWS_MSL &&
814 (s32)(peer->tcp_ts - req->ts_recent) >
816 NET_INC_STATS_BH(LINUX_MIB_PAWSPASSIVEREJECTED);
821 /* Kill the following clause, if you dislike this way. */
822 else if (!sysctl_tcp_syncookies &&
823 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
824 (sysctl_max_syn_backlog >> 2)) &&
825 (!peer || !peer->tcp_ts_stamp) &&
826 (!dst || !dst_metric(dst, RTAX_RTT))) {
827 /* Without syncookies last quarter of
828 * backlog is filled with destinations,
829 * proven to be alive.
830 * It means that we continue to communicate
831 * to destinations, already remembered
832 * to the moment of synflood.
834 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open "
835 "request from %u.%u.%u.%u/%u\n",
837 ntohs(skb->h.th->source));
842 isn = tcp_v4_init_sequence(sk, skb);
844 tcp_rsk(req)->snt_isn = isn;
846 if (tcp_v4_send_synack(sk, req, dst))
852 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
859 TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
865 * The three way handshake has completed - we got a valid synack -
866 * now create the new socket.
868 struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
869 struct request_sock *req,
870 struct dst_entry *dst)
872 struct inet_request_sock *ireq;
873 struct inet_sock *newinet;
874 struct tcp_sock *newtp;
877 if (sk_acceptq_is_full(sk))
880 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
883 newsk = tcp_create_openreq_child(sk, req, skb);
887 sk_setup_caps(newsk, dst);
889 newtp = tcp_sk(newsk);
890 newinet = inet_sk(newsk);
891 ireq = inet_rsk(req);
892 newinet->daddr = ireq->rmt_addr;
893 newinet->rcv_saddr = ireq->loc_addr;
894 newinet->saddr = ireq->loc_addr;
895 newinet->opt = ireq->opt;
897 newinet->mc_index = inet_iif(skb);
898 newinet->mc_ttl = skb->nh.iph->ttl;
899 inet_csk(newsk)->icsk_ext_hdr_len = 0;
901 inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
902 newinet->id = newtp->write_seq ^ jiffies;
904 tcp_mtup_init(newsk);
905 tcp_sync_mss(newsk, dst_mtu(dst));
906 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
907 tcp_initialize_rcv_mss(newsk);
909 __inet_hash(&tcp_hashinfo, newsk, 0);
910 __inet_inherit_port(&tcp_hashinfo, sk, newsk);
915 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
917 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
922 static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
924 struct tcphdr *th = skb->h.th;
925 struct iphdr *iph = skb->nh.iph;
927 struct request_sock **prev;
928 /* Find possible connection requests. */
929 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
930 iph->saddr, iph->daddr);
932 return tcp_check_req(sk, skb, req, prev);
934 nsk = __inet_lookup_established(&tcp_hashinfo, skb->nh.iph->saddr,
935 th->source, skb->nh.iph->daddr,
936 ntohs(th->dest), inet_iif(skb));
939 if (nsk->sk_state != TCP_TIME_WAIT) {
943 inet_twsk_put((struct inet_timewait_sock *)nsk);
947 #ifdef CONFIG_SYN_COOKIES
948 if (!th->rst && !th->syn && th->ack)
949 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
954 static int tcp_v4_checksum_init(struct sk_buff *skb)
956 if (skb->ip_summed == CHECKSUM_HW) {
957 if (!tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
958 skb->nh.iph->daddr, skb->csum)) {
959 skb->ip_summed = CHECKSUM_UNNECESSARY;
964 skb->csum = csum_tcpudp_nofold(skb->nh.iph->saddr, skb->nh.iph->daddr,
965 skb->len, IPPROTO_TCP, 0);
967 if (skb->len <= 76) {
968 return __skb_checksum_complete(skb);
974 /* The socket must have it's spinlock held when we get
977 * We have a potential double-lock case here, so even when
978 * doing backlog processing we use the BH locking scheme.
979 * This is because we cannot sleep with the original spinlock
982 int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
984 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
986 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len))
992 if (skb->len < (skb->h.th->doff << 2) || tcp_checksum_complete(skb))
995 if (sk->sk_state == TCP_LISTEN) {
996 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1001 if (tcp_child_process(sk, nsk, skb))
1007 TCP_CHECK_TIMER(sk);
1008 if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len))
1010 TCP_CHECK_TIMER(sk);
1014 tcp_v4_send_reset(skb);
1017 /* Be careful here. If this function gets more complicated and
1018 * gcc suffers from register pressure on the x86, sk (in %ebx)
1019 * might be destroyed here. This current version compiles correctly,
1020 * but you have been warned.
1025 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1033 int tcp_v4_rcv(struct sk_buff *skb)
1039 if (skb->pkt_type != PACKET_HOST)
1042 /* Count it even if it's bad */
1043 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1045 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1050 if (th->doff < sizeof(struct tcphdr) / 4)
1052 if (!pskb_may_pull(skb, th->doff * 4))
1055 /* An explanation is required here, I think.
1056 * Packet length and doff are validated by header prediction,
1057 * provided case of th->doff==0 is eliminated.
1058 * So, we defer the checks. */
1059 if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
1060 tcp_v4_checksum_init(skb)))
1064 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1065 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1066 skb->len - th->doff * 4);
1067 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1068 TCP_SKB_CB(skb)->when = 0;
1069 TCP_SKB_CB(skb)->flags = skb->nh.iph->tos;
1070 TCP_SKB_CB(skb)->sacked = 0;
1072 sk = __inet_lookup(&tcp_hashinfo, skb->nh.iph->saddr, th->source,
1073 skb->nh.iph->daddr, ntohs(th->dest),
1080 #if defined(CONFIG_VNET) || defined(CONFIG_VNET_MODULE)
1081 /* Silently drop if VNET is active and the context is not
1082 * entitled to read the packet.
1085 /* Transfer ownership of reusable TIME_WAIT buckets to
1086 * whomever VNET decided should own the packet.
1088 if (sk->sk_state == TCP_TIME_WAIT)
1089 sk->sk_xid = skb->xid;
1091 if ((int) sk->sk_xid > 0 && sk->sk_xid != skb->xid)
1096 if (sk->sk_state == TCP_TIME_WAIT)
1099 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1100 goto discard_and_relse;
1103 if (sk_filter(sk, skb, 0))
1104 goto discard_and_relse;
1110 if (!sock_owned_by_user(sk)) {
1111 if (!tcp_prequeue(sk, skb))
1112 ret = tcp_v4_do_rcv(sk, skb);
1114 sk_add_backlog(sk, skb);
1122 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1125 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1127 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1128 #if defined(CONFIG_VNET) || defined(CONFIG_VNET_MODULE)
1129 } else if (vnet_active && skb->sk) {
1130 /* VNET: Suppress RST if the port was bound to a (presumably raw) socket */
1133 tcp_v4_send_reset(skb);
1137 /* Discard frame. */
1146 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1147 inet_twsk_put((struct inet_timewait_sock *) sk);
1151 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1152 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1153 inet_twsk_put((struct inet_timewait_sock *) sk);
1156 switch (tcp_timewait_state_process((struct inet_timewait_sock *)sk,
1159 struct sock *sk2 = inet_lookup_listener(&tcp_hashinfo,
1164 inet_twsk_deschedule((struct inet_timewait_sock *)sk,
1166 inet_twsk_put((struct inet_timewait_sock *)sk);
1170 /* Fall through to ACK */
1173 tcp_v4_timewait_ack(sk, skb);
1177 case TCP_TW_SUCCESS:;
1182 /* VJ's idea. Save last timestamp seen from this destination
1183 * and hold it at least for normal timewait interval to use for duplicate
1184 * segment detection in subsequent connections, before they enter synchronized
1188 int tcp_v4_remember_stamp(struct sock *sk)
1190 struct inet_sock *inet = inet_sk(sk);
1191 struct tcp_sock *tp = tcp_sk(sk);
1192 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1193 struct inet_peer *peer = NULL;
1196 if (!rt || rt->rt_dst != inet->daddr) {
1197 peer = inet_getpeer(inet->daddr, 1);
1201 rt_bind_peer(rt, 1);
1206 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
1207 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1208 peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {
1209 peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;
1210 peer->tcp_ts = tp->rx_opt.ts_recent;
1220 int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
1222 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
1225 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1227 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
1228 (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1229 peer->tcp_ts_stamp <= tcptw->tw_ts_recent_stamp)) {
1230 peer->tcp_ts_stamp = tcptw->tw_ts_recent_stamp;
1231 peer->tcp_ts = tcptw->tw_ts_recent;
1240 struct inet_connection_sock_af_ops ipv4_specific = {
1241 .queue_xmit = ip_queue_xmit,
1242 .send_check = tcp_v4_send_check,
1243 .rebuild_header = inet_sk_rebuild_header,
1244 .conn_request = tcp_v4_conn_request,
1245 .syn_recv_sock = tcp_v4_syn_recv_sock,
1246 .remember_stamp = tcp_v4_remember_stamp,
1247 .net_header_len = sizeof(struct iphdr),
1248 .setsockopt = ip_setsockopt,
1249 .getsockopt = ip_getsockopt,
1250 .addr2sockaddr = inet_csk_addr2sockaddr,
1251 .sockaddr_len = sizeof(struct sockaddr_in),
1252 #ifdef CONFIG_COMPAT
1253 .compat_setsockopt = compat_ip_setsockopt,
1254 .compat_getsockopt = compat_ip_getsockopt,
1258 /* NOTE: A lot of things set to zero explicitly by call to
1259 * sk_alloc() so need not be done here.
1261 static int tcp_v4_init_sock(struct sock *sk)
1263 struct inet_connection_sock *icsk = inet_csk(sk);
1264 struct tcp_sock *tp = tcp_sk(sk);
1266 skb_queue_head_init(&tp->out_of_order_queue);
1267 tcp_init_xmit_timers(sk);
1268 tcp_prequeue_init(tp);
1270 icsk->icsk_rto = TCP_TIMEOUT_INIT;
1271 tp->mdev = TCP_TIMEOUT_INIT;
1273 /* So many TCP implementations out there (incorrectly) count the
1274 * initial SYN frame in their delayed-ACK and congestion control
1275 * algorithms that we must have the following bandaid to talk
1276 * efficiently to them. -DaveM
1280 /* See draft-stevens-tcpca-spec-01 for discussion of the
1281 * initialization of these values.
1283 tp->snd_ssthresh = 0x7fffffff; /* Infinity */
1284 tp->snd_cwnd_clamp = ~0;
1285 tp->mss_cache = 536;
1287 tp->reordering = sysctl_tcp_reordering;
1288 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
1290 sk->sk_state = TCP_CLOSE;
1292 sk->sk_write_space = sk_stream_write_space;
1293 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1295 icsk->icsk_af_ops = &ipv4_specific;
1296 icsk->icsk_sync_mss = tcp_sync_mss;
1298 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1299 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1301 atomic_inc(&tcp_sockets_allocated);
1306 int tcp_v4_destroy_sock(struct sock *sk)
1308 struct tcp_sock *tp = tcp_sk(sk);
1310 tcp_clear_xmit_timers(sk);
1312 tcp_cleanup_congestion_control(sk);
1314 /* Cleanup up the write buffer. */
1315 sk_stream_writequeue_purge(sk);
1317 /* Cleans up our, hopefully empty, out_of_order_queue. */
1318 __skb_queue_purge(&tp->out_of_order_queue);
1320 /* Clean prequeue, it must be empty really */
1321 __skb_queue_purge(&tp->ucopy.prequeue);
1323 /* Clean up a referenced TCP bind bucket. */
1324 if (inet_csk(sk)->icsk_bind_hash)
1325 inet_put_port(&tcp_hashinfo, sk);
1328 * If sendmsg cached page exists, toss it.
1330 if (sk->sk_sndmsg_page) {
1331 __free_page(sk->sk_sndmsg_page);
1332 sk->sk_sndmsg_page = NULL;
1335 atomic_dec(&tcp_sockets_allocated);
1340 EXPORT_SYMBOL(tcp_v4_destroy_sock);
1342 #ifdef CONFIG_PROC_FS
1343 /* Proc filesystem TCP sock list dumping. */
1345 static inline struct inet_timewait_sock *tw_head(struct hlist_head *head)
1347 return hlist_empty(head) ? NULL :
1348 list_entry(head->first, struct inet_timewait_sock, tw_node);
1351 static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
1353 return tw->tw_node.next ?
1354 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
1357 static void *listening_get_next(struct seq_file *seq, void *cur)
1359 struct inet_connection_sock *icsk;
1360 struct hlist_node *node;
1361 struct sock *sk = cur;
1362 struct tcp_iter_state* st = seq->private;
1366 sk = sk_head(&tcp_hashinfo.listening_hash[0]);
1372 if (st->state == TCP_SEQ_STATE_OPENREQ) {
1373 struct request_sock *req = cur;
1375 icsk = inet_csk(st->syn_wait_sk);
1379 vxdprintk(VXD_CBIT(net, 6),
1380 "sk,req: %p [#%d] (from %d)", req->sk,
1381 (req->sk)?req->sk->sk_xid:0, vx_current_xid());
1383 !vx_check(req->sk->sk_xid, VX_IDENT|VX_WATCH))
1385 if (req->rsk_ops->family == st->family) {
1391 if (++st->sbucket >= TCP_SYNQ_HSIZE)
1394 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
1396 sk = sk_next(st->syn_wait_sk);
1397 st->state = TCP_SEQ_STATE_LISTENING;
1398 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1400 icsk = inet_csk(sk);
1401 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1402 if (reqsk_queue_len(&icsk->icsk_accept_queue))
1404 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1408 sk_for_each_from(sk, node) {
1409 vxdprintk(VXD_CBIT(net, 6), "sk: %p [#%d] (from %d)",
1410 sk, sk->sk_xid, vx_current_xid());
1411 if (!vx_check(sk->sk_xid, VX_IDENT|VX_WATCH))
1413 if (sk->sk_family == st->family) {
1417 icsk = inet_csk(sk);
1418 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1419 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
1421 st->uid = sock_i_uid(sk);
1422 st->syn_wait_sk = sk;
1423 st->state = TCP_SEQ_STATE_OPENREQ;
1427 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1429 if (++st->bucket < INET_LHTABLE_SIZE) {
1430 sk = sk_head(&tcp_hashinfo.listening_hash[st->bucket]);
1438 static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
1440 void *rc = listening_get_next(seq, NULL);
1442 while (rc && *pos) {
1443 rc = listening_get_next(seq, rc);
1449 static void *established_get_first(struct seq_file *seq)
1451 struct tcp_iter_state* st = seq->private;
1454 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
1456 struct hlist_node *node;
1457 struct inet_timewait_sock *tw;
1459 /* We can reschedule _before_ having picked the target: */
1460 cond_resched_softirq();
1462 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
1463 sk_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
1464 vxdprintk(VXD_CBIT(net, 6),
1465 "sk,egf: %p [#%d] (from %d)",
1466 sk, sk->sk_xid, vx_current_xid());
1467 if (!vx_check(sk->sk_xid, VX_IDENT|VX_WATCH))
1469 if (sk->sk_family != st->family)
1474 st->state = TCP_SEQ_STATE_TIME_WAIT;
1475 inet_twsk_for_each(tw, node,
1476 &tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain) {
1477 vxdprintk(VXD_CBIT(net, 6),
1478 "tw: %p [#%d] (from %d)",
1479 tw, tw->tw_xid, vx_current_xid());
1480 if (!vx_check(tw->tw_xid, VX_IDENT|VX_WATCH))
1482 if (tw->tw_family != st->family)
1487 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1488 st->state = TCP_SEQ_STATE_ESTABLISHED;
1494 static void *established_get_next(struct seq_file *seq, void *cur)
1496 struct sock *sk = cur;
1497 struct inet_timewait_sock *tw;
1498 struct hlist_node *node;
1499 struct tcp_iter_state* st = seq->private;
1503 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
1507 while (tw && (tw->tw_family != st->family ||
1508 !vx_check(tw->tw_xid, VX_IDENT|VX_WATCH))) {
1515 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1516 st->state = TCP_SEQ_STATE_ESTABLISHED;
1518 /* We can reschedule between buckets: */
1519 cond_resched_softirq();
1521 if (++st->bucket < tcp_hashinfo.ehash_size) {
1522 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
1523 sk = sk_head(&tcp_hashinfo.ehash[st->bucket].chain);
1531 sk_for_each_from(sk, node) {
1532 vxdprintk(VXD_CBIT(net, 6),
1533 "sk,egn: %p [#%d] (from %d)",
1534 sk, sk->sk_xid, vx_current_xid());
1535 if (!vx_check(sk->sk_xid, VX_IDENT|VX_WATCH))
1537 if (sk->sk_family == st->family)
1541 st->state = TCP_SEQ_STATE_TIME_WAIT;
1542 tw = tw_head(&tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain);
1550 static void *established_get_idx(struct seq_file *seq, loff_t pos)
1552 void *rc = established_get_first(seq);
1555 rc = established_get_next(seq, rc);
1561 static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
1564 struct tcp_iter_state* st = seq->private;
1566 inet_listen_lock(&tcp_hashinfo);
1567 st->state = TCP_SEQ_STATE_LISTENING;
1568 rc = listening_get_idx(seq, &pos);
1571 inet_listen_unlock(&tcp_hashinfo);
1573 st->state = TCP_SEQ_STATE_ESTABLISHED;
1574 rc = established_get_idx(seq, pos);
1580 static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
1582 struct tcp_iter_state* st = seq->private;
1583 st->state = TCP_SEQ_STATE_LISTENING;
1585 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
1588 static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1591 struct tcp_iter_state* st;
1593 if (v == SEQ_START_TOKEN) {
1594 rc = tcp_get_idx(seq, 0);
1599 switch (st->state) {
1600 case TCP_SEQ_STATE_OPENREQ:
1601 case TCP_SEQ_STATE_LISTENING:
1602 rc = listening_get_next(seq, v);
1604 inet_listen_unlock(&tcp_hashinfo);
1606 st->state = TCP_SEQ_STATE_ESTABLISHED;
1607 rc = established_get_first(seq);
1610 case TCP_SEQ_STATE_ESTABLISHED:
1611 case TCP_SEQ_STATE_TIME_WAIT:
1612 rc = established_get_next(seq, v);
1620 static void tcp_seq_stop(struct seq_file *seq, void *v)
1622 struct tcp_iter_state* st = seq->private;
1624 switch (st->state) {
1625 case TCP_SEQ_STATE_OPENREQ:
1627 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
1628 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1630 case TCP_SEQ_STATE_LISTENING:
1631 if (v != SEQ_START_TOKEN)
1632 inet_listen_unlock(&tcp_hashinfo);
1634 case TCP_SEQ_STATE_TIME_WAIT:
1635 case TCP_SEQ_STATE_ESTABLISHED:
1637 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1643 static int tcp_seq_open(struct inode *inode, struct file *file)
1645 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
1646 struct seq_file *seq;
1647 struct tcp_iter_state *s;
1650 if (unlikely(afinfo == NULL))
1653 s = kmalloc(sizeof(*s), GFP_KERNEL);
1656 memset(s, 0, sizeof(*s));
1657 s->family = afinfo->family;
1658 s->seq_ops.start = tcp_seq_start;
1659 s->seq_ops.next = tcp_seq_next;
1660 s->seq_ops.show = afinfo->seq_show;
1661 s->seq_ops.stop = tcp_seq_stop;
1663 rc = seq_open(file, &s->seq_ops);
1666 seq = file->private_data;
1675 int tcp_proc_register(struct tcp_seq_afinfo *afinfo)
1678 struct proc_dir_entry *p;
1682 afinfo->seq_fops->owner = afinfo->owner;
1683 afinfo->seq_fops->open = tcp_seq_open;
1684 afinfo->seq_fops->read = seq_read;
1685 afinfo->seq_fops->llseek = seq_lseek;
1686 afinfo->seq_fops->release = seq_release_private;
1688 p = proc_net_fops_create(afinfo->name, S_IRUGO, afinfo->seq_fops);
1696 void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo)
1700 proc_net_remove(afinfo->name);
1701 memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops));
1704 static void get_openreq4(struct sock *sk, struct request_sock *req,
1705 char *tmpbuf, int i, int uid)
1707 const struct inet_request_sock *ireq = inet_rsk(req);
1708 int ttd = req->expires - jiffies;
1710 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
1711 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p",
1714 ntohs(inet_sk(sk)->sport),
1716 ntohs(ireq->rmt_port),
1718 0, 0, /* could print option size, but that is af dependent. */
1719 1, /* timers active (only the expire timer) */
1720 jiffies_to_clock_t(ttd),
1723 0, /* non standard timer */
1724 0, /* open_requests have no inode */
1725 atomic_read(&sk->sk_refcnt),
1729 static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i)
1732 unsigned long timer_expires;
1733 struct tcp_sock *tp = tcp_sk(sp);
1734 const struct inet_connection_sock *icsk = inet_csk(sp);
1735 struct inet_sock *inet = inet_sk(sp);
1736 unsigned int dest = inet->daddr;
1737 unsigned int src = inet->rcv_saddr;
1738 __u16 destp = ntohs(inet->dport);
1739 __u16 srcp = ntohs(inet->sport);
1741 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
1743 timer_expires = icsk->icsk_timeout;
1744 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
1746 timer_expires = icsk->icsk_timeout;
1747 } else if (timer_pending(&sp->sk_timer)) {
1749 timer_expires = sp->sk_timer.expires;
1752 timer_expires = jiffies;
1755 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
1756 "%08X %5d %8d %lu %d %p %u %u %u %u %d",
1757 i, src, srcp, dest, destp, sp->sk_state,
1758 tp->write_seq - tp->snd_una, tp->rcv_nxt - tp->copied_seq,
1760 jiffies_to_clock_t(timer_expires - jiffies),
1761 icsk->icsk_retransmits,
1763 icsk->icsk_probes_out,
1765 atomic_read(&sp->sk_refcnt), sp,
1768 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
1770 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh);
1773 static void get_timewait4_sock(struct inet_timewait_sock *tw, char *tmpbuf, int i)
1775 unsigned int dest, src;
1777 int ttd = tw->tw_ttd - jiffies;
1782 dest = tw->tw_daddr;
1783 src = tw->tw_rcv_saddr;
1784 destp = ntohs(tw->tw_dport);
1785 srcp = ntohs(tw->tw_sport);
1787 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
1788 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p",
1789 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
1790 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
1791 atomic_read(&tw->tw_refcnt), tw);
1796 static int tcp4_seq_show(struct seq_file *seq, void *v)
1798 struct tcp_iter_state* st;
1799 char tmpbuf[TMPSZ + 1];
1801 if (v == SEQ_START_TOKEN) {
1802 seq_printf(seq, "%-*s\n", TMPSZ - 1,
1803 " sl local_address rem_address st tx_queue "
1804 "rx_queue tr tm->when retrnsmt uid timeout "
1810 switch (st->state) {
1811 case TCP_SEQ_STATE_LISTENING:
1812 case TCP_SEQ_STATE_ESTABLISHED:
1813 get_tcp4_sock(v, tmpbuf, st->num);
1815 case TCP_SEQ_STATE_OPENREQ:
1816 get_openreq4(st->syn_wait_sk, v, tmpbuf, st->num, st->uid);
1818 case TCP_SEQ_STATE_TIME_WAIT:
1819 get_timewait4_sock(v, tmpbuf, st->num);
1822 seq_printf(seq, "%-*s\n", TMPSZ - 1, tmpbuf);
1827 static struct file_operations tcp4_seq_fops;
1828 static struct tcp_seq_afinfo tcp4_seq_afinfo = {
1829 .owner = THIS_MODULE,
1832 .seq_show = tcp4_seq_show,
1833 .seq_fops = &tcp4_seq_fops,
1836 int __init tcp4_proc_init(void)
1838 return tcp_proc_register(&tcp4_seq_afinfo);
1841 void tcp4_proc_exit(void)
1843 tcp_proc_unregister(&tcp4_seq_afinfo);
1845 #endif /* CONFIG_PROC_FS */
1847 struct proto tcp_prot = {
1849 .owner = THIS_MODULE,
1851 .connect = tcp_v4_connect,
1852 .disconnect = tcp_disconnect,
1853 .accept = inet_csk_accept,
1855 .init = tcp_v4_init_sock,
1856 .destroy = tcp_v4_destroy_sock,
1857 .shutdown = tcp_shutdown,
1858 .setsockopt = tcp_setsockopt,
1859 .getsockopt = tcp_getsockopt,
1860 .sendmsg = tcp_sendmsg,
1861 .recvmsg = tcp_recvmsg,
1862 .backlog_rcv = tcp_v4_do_rcv,
1863 .hash = tcp_v4_hash,
1864 .unhash = tcp_unhash,
1865 .get_port = tcp_v4_get_port,
1866 .enter_memory_pressure = tcp_enter_memory_pressure,
1867 .sockets_allocated = &tcp_sockets_allocated,
1868 .orphan_count = &tcp_orphan_count,
1869 .memory_allocated = &tcp_memory_allocated,
1870 .memory_pressure = &tcp_memory_pressure,
1871 .sysctl_mem = sysctl_tcp_mem,
1872 .sysctl_wmem = sysctl_tcp_wmem,
1873 .sysctl_rmem = sysctl_tcp_rmem,
1874 .max_header = MAX_TCP_HEADER,
1875 .obj_size = sizeof(struct tcp_sock),
1876 .twsk_prot = &tcp_timewait_sock_ops,
1877 .rsk_prot = &tcp_request_sock_ops,
1878 #ifdef CONFIG_COMPAT
1879 .compat_setsockopt = compat_tcp_setsockopt,
1880 .compat_getsockopt = compat_tcp_getsockopt,
1884 void __init tcp_v4_init(struct net_proto_family *ops)
1886 if (inet_csk_ctl_sock_create(&tcp_socket, PF_INET, SOCK_RAW, IPPROTO_TCP) < 0)
1887 panic("Failed to create the TCP control socket.\n");
1890 EXPORT_SYMBOL(ipv4_specific);
1891 EXPORT_SYMBOL(tcp_hashinfo);
1892 EXPORT_SYMBOL(tcp_prot);
1893 EXPORT_SYMBOL(tcp_unhash);
1894 EXPORT_SYMBOL(tcp_v4_conn_request);
1895 EXPORT_SYMBOL(tcp_v4_connect);
1896 EXPORT_SYMBOL(tcp_v4_do_rcv);
1897 EXPORT_SYMBOL(tcp_v4_remember_stamp);
1898 EXPORT_SYMBOL(tcp_v4_send_check);
1899 EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
1901 #ifdef CONFIG_PROC_FS
1902 EXPORT_SYMBOL(tcp_proc_register);
1903 EXPORT_SYMBOL(tcp_proc_unregister);
1905 EXPORT_SYMBOL(sysctl_local_port_range);
1906 EXPORT_SYMBOL(sysctl_tcp_low_latency);