net/ipv4/tcp_ipv4.c

   1 /*
   2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
   3  *              operating system.  INET is implemented using the  BSD Socket
   4  *              interface as the means of communication with the user level.
   5  *
   6  *              Implementation of the Transmission Control Protocol(TCP).
   7  *
   8  * Version:     $Id$
   9  *
  10  *              IPv4 specific functions
  11  *
  12  *
  13  *              code split from:
  14  *              linux/ipv4/tcp.c
  15  *              linux/ipv4/tcp_input.c
  16  *              linux/ipv4/tcp_output.c
  17  *
  18  *              See tcp.c for author information
  19  *
  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.
  24  */
  25
  26 /*
  27  * Changes:
  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
  36  *                                      ACK bit.
  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
  47  *                                      coma.
  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.
  53  */
  54
  55 #include <linux/config.h>
  56
  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>
  65
  66 #include <net/icmp.h>
  67 #include <net/inet_hashtables.h>
  68 #include <net/tcp.h>
  69 #include <net/transp_v6.h>
  70 #include <net/ipv6.h>
  71 #include <net/inet_common.h>
  72 #include <net/timewait_sock.h>
  73 #include <net/xfrm.h>
  74
  75 #include <linux/inet.h>
  76 #include <linux/ipv6.h>
  77 #include <linux/stddef.h>
  78 #include <linux/proc_fs.h>
  79 #include <linux/seq_file.h>
  80 #include <linux/vserver/debug.h>
  81
  82 int sysctl_tcp_tw_reuse;
  83 int sysctl_tcp_low_latency;
  84
  85 /* Check TCP sequence numbers in ICMP packets. */
  86 #define ICMP_MIN_LENGTH 8
  87
  88 /* Socket used for sending RSTs */
  89 static struct socket *tcp_socket;
  90
  91 void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb);
  92
  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),
  97 };
  98
  99 static int tcp_v4_get_port(struct sock *sk, unsigned short snum)
 100 {
 101         return inet_csk_get_port(&tcp_hashinfo, sk, snum,
 102                                  inet_csk_bind_conflict);
 103 }
 104
 105 static void tcp_v4_hash(struct sock *sk)
 106 {
 107         inet_hash(&tcp_hashinfo, sk);
 108 }
 109
 110 void tcp_unhash(struct sock *sk)
 111 {
 112         inet_unhash(&tcp_hashinfo, sk);
 113 }
 114
 115 static inline __u32 tcp_v4_init_sequence(struct sock *sk, struct sk_buff *skb)
 116 {
 117         return secure_tcp_sequence_number(skb->nh.iph->daddr,
 118                                           skb->nh.iph->saddr,
 119                                           skb->h.th->dest,
 120                                           skb->h.th->source);
 121 }
 122
 123 int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
 124 {
 125         const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
 126         struct tcp_sock *tp = tcp_sk(sk);
 127
 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.
 131
 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
 134            holder.
 135
 136            If TW bucket has been already destroyed we fall back to VJ's scheme
 137            and use initial timestamp retrieved from peer table.
 138          */
 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)
 144                         tp->write_seq = 1;
 145                 tp->rx_opt.ts_recent       = tcptw->tw_ts_recent;
 146                 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
 147                 sock_hold(sktw);
 148                 return 1;
 149         }
 150
 151         return 0;
 152 }
 153
 154 EXPORT_SYMBOL_GPL(tcp_twsk_unique);
 155
 156 /* This will initiate an outgoing connection. */
 157 int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
 158 {
 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;
 162         struct rtable *rt;
 163         u32 daddr, nexthop;
 164         int tmp;
 165         int err;
 166
 167         if (addr_len < sizeof(struct sockaddr_in))
 168                 return -EINVAL;
 169
 170         if (usin->sin_family != AF_INET)
 171                 return -EAFNOSUPPORT;
 172
 173         nexthop = daddr = usin->sin_addr.s_addr;
 174         if (inet->opt && inet->opt->srr) {
 175                 if (!daddr)
 176                         return -EINVAL;
 177                 nexthop = inet->opt->faddr;
 178         }
 179
 180         tmp = ip_route_connect(&rt, nexthop, inet->saddr,
 181                                RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
 182                                IPPROTO_TCP,
 183                                inet->sport, usin->sin_port, sk);
 184         if (tmp < 0)
 185                 return tmp;
 186
 187         if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
 188                 ip_rt_put(rt);
 189                 return -ENETUNREACH;
 190         }
 191
 192         if (!inet->opt || !inet->opt->srr)
 193                 daddr = rt->rt_dst;
 194
 195         if (!inet->saddr)
 196                 inet->saddr = rt->rt_src;
 197         inet->rcv_saddr = inet->saddr;
 198
 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;
 203                 tp->write_seq              = 0;
 204         }
 205
 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);
 209
 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.
 213                  */
 214
 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;
 218                 }
 219         }
 220
 221         inet->dport = usin->sin_port;
 222         inet->daddr = daddr;
 223
 224         inet_csk(sk)->icsk_ext_hdr_len = 0;
 225         if (inet->opt)
 226                 inet_csk(sk)->icsk_ext_hdr_len = inet->opt->optlen;
 227
 228         tp->rx_opt.mss_clamp = 536;
 229
 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.
 234          */
 235         tcp_set_state(sk, TCP_SYN_SENT);
 236         err = inet_hash_connect(&tcp_death_row, sk);
 237         if (err)
 238                 goto failure;
 239
 240         err = ip_route_newports(&rt, IPPROTO_TCP, inet->sport, inet->dport, sk);
 241         if (err)
 242                 goto failure;
 243
 244         /* OK, now commit destination to socket.  */
 245         sk_setup_caps(sk, &rt->u.dst);
 246
 247         if (!tp->write_seq)
 248                 tp->write_seq = secure_tcp_sequence_number(inet->saddr,
 249                                                            inet->daddr,
 250                                                            inet->sport,
 251                                                            usin->sin_port);
 252
 253         inet->id = tp->write_seq ^ jiffies;
 254
 255         err = tcp_connect(sk);
 256         rt = NULL;
 257         if (err)
 258                 goto failure;
 259
 260         return 0;
 261
 262 failure:
 263         /* This unhashes the socket and releases the local port, if necessary. */
 264         tcp_set_state(sk, TCP_CLOSE);
 265         ip_rt_put(rt);
 266         sk->sk_route_caps = 0;
 267         inet->dport = 0;
 268         return err;
 269 }
 270
 271 /*
 272  * This routine does path mtu discovery as defined in RFC1191.
 273  */
 274 static void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, u32 mtu)
 275 {
 276         struct dst_entry *dst;
 277         struct inet_sock *inet = inet_sk(sk);
 278
 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
 281          * unfragmented).
 282          */
 283         if (sk->sk_state == TCP_LISTEN)
 284                 return;
 285
 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.
 291          */
 292         if ((dst = __sk_dst_check(sk, 0)) == NULL)
 293                 return;
 294
 295         dst->ops->update_pmtu(dst, mtu);
 296
 297         /* Something is about to be wrong... Remember soft error
 298          * for the case, if this connection will not able to recover.
 299          */
 300         if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
 301                 sk->sk_err_soft = EMSGSIZE;
 302
 303         mtu = dst_mtu(dst);
 304
 305         if (inet->pmtudisc != IP_PMTUDISC_DONT &&
 306             inet_csk(sk)->icsk_pmtu_cookie > mtu) {
 307                 tcp_sync_mss(sk, mtu);
 308
 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
 312                  * discovery.
 313                  */
 314                 tcp_simple_retransmit(sk);
 315         } /* else let the usual retransmit timer handle it */
 316 }
 317
 318 /*
 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.
 325  *
 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.
 331  *
 332  */
 333
 334 void tcp_v4_err(struct sk_buff *skb, u32 info)
 335 {
 336         struct iphdr *iph = (struct iphdr *)skb->data;
 337         struct tcphdr *th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
 338         struct tcp_sock *tp;
 339         struct inet_sock *inet;
 340         int type = skb->h.icmph->type;
 341         int code = skb->h.icmph->code;
 342         struct sock *sk;
 343         __u32 seq;
 344         int err;
 345
 346         if (skb->len < (iph->ihl << 2) + 8) {
 347                 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
 348                 return;
 349         }
 350
 351         sk = inet_lookup(&tcp_hashinfo, iph->daddr, th->dest, iph->saddr,
 352                          th->source, inet_iif(skb));
 353         if (!sk) {
 354                 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
 355                 return;
 356         }
 357         if (sk->sk_state == TCP_TIME_WAIT) {
 358                 inet_twsk_put((struct inet_timewait_sock *)sk);
 359                 return;
 360         }
 361
 362         bh_lock_sock(sk);
 363         /* If too many ICMPs get dropped on busy
 364          * servers this needs to be solved differently.
 365          */
 366         if (sock_owned_by_user(sk))
 367                 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
 368
 369         if (sk->sk_state == TCP_CLOSE)
 370                 goto out;
 371
 372         tp = tcp_sk(sk);
 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);
 377                 goto out;
 378         }
 379
 380         switch (type) {
 381         case ICMP_SOURCE_QUENCH:
 382                 /* Just silently ignore these. */
 383                 goto out;
 384         case ICMP_PARAMETERPROB:
 385                 err = EPROTO;
 386                 break;
 387         case ICMP_DEST_UNREACH:
 388                 if (code > NR_ICMP_UNREACH)
 389                         goto out;
 390
 391                 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
 392                         if (!sock_owned_by_user(sk))
 393                                 do_pmtu_discovery(sk, iph, info);
 394                         goto out;
 395                 }
 396
 397                 err = icmp_err_convert[code].errno;
 398                 break;
 399         case ICMP_TIME_EXCEEDED:
 400                 err = EHOSTUNREACH;
 401                 break;
 402         default:
 403                 goto out;
 404         }
 405
 406         switch (sk->sk_state) {
 407                 struct request_sock *req, **prev;
 408         case TCP_LISTEN:
 409                 if (sock_owned_by_user(sk))
 410                         goto out;
 411
 412                 req = inet_csk_search_req(sk, &prev, th->dest,
 413                                           iph->daddr, iph->saddr);
 414                 if (!req)
 415                         goto out;
 416
 417                 /* ICMPs are not backlogged, hence we cannot get
 418                    an established socket here.
 419                  */
 420                 BUG_TRAP(!req->sk);
 421
 422                 if (seq != tcp_rsk(req)->snt_isn) {
 423                         NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
 424                         goto out;
 425                 }
 426
 427                 /*
 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().
 432                  */
 433                 inet_csk_reqsk_queue_drop(sk, req, prev);
 434                 goto out;
 435
 436         case TCP_SYN_SENT:
 437         case TCP_SYN_RECV:  /* Cannot happen.
 438                                It can f.e. if SYNs crossed.
 439                              */
 440                 if (!sock_owned_by_user(sk)) {
 441                         TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
 442                         sk->sk_err = err;
 443
 444                         sk->sk_error_report(sk);
 445
 446                         tcp_done(sk);
 447                 } else {
 448                         sk->sk_err_soft = err;
 449                 }
 450                 goto out;
 451         }
 452
 453         /* If we've already connected we will keep trying
 454          * until we time out, or the user gives up.
 455          *
 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).
 459          *
 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)
 464          *
 465          * Now we are in compliance with RFCs.
 466          *                                                      --ANK (980905)
 467          */
 468
 469         inet = inet_sk(sk);
 470         if (!sock_owned_by_user(sk) && inet->recverr) {
 471                 sk->sk_err = err;
 472                 sk->sk_error_report(sk);
 473         } else  { /* Only an error on timeout */
 474                 sk->sk_err_soft = err;
 475         }
 476
 477 out:
 478         bh_unlock_sock(sk);
 479         sock_put(sk);
 480 }
 481
 482 /* This routine computes an IPv4 TCP checksum. */
 483 void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb)
 484 {
 485         struct inet_sock *inet = inet_sk(sk);
 486         struct tcphdr *th = skb->h.th;
 487
 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);
 491         } else {
 492                 th->check = tcp_v4_check(th, len, inet->saddr, inet->daddr,
 493                                          csum_partial((char *)th,
 494                                                       th->doff << 2,
 495                                                       skb->csum));
 496         }
 497 }
 498
 499 /*
 500  *      This routine will send an RST to the other tcp.
 501  *
 502  *      Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
 503  *                    for reset.
 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.
 510  */
 511
 512 static void tcp_v4_send_reset(struct sk_buff *skb)
 513 {
 514         struct tcphdr *th = skb->h.th;
 515         struct tcphdr rth;
 516         struct ip_reply_arg arg;
 517
 518         /* Never send a reset in response to a reset. */
 519         if (th->rst)
 520                 return;
 521
 522         if (((struct rtable *)skb->dst)->rt_type != RTN_LOCAL)
 523                 return;
 524
 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;
 530         rth.rst    = 1;
 531
 532         if (th->ack) {
 533                 rth.seq = th->ack_seq;
 534         } else {
 535                 rth.ack = 1;
 536                 rth.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
 537                                     skb->len - (th->doff << 2));
 538         }
 539
 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;
 547
 548         ip_send_reply(tcp_socket->sk, skb, &arg, sizeof rth);
 549
 550         TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
 551         TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
 552 }
 553
 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?
 556  */
 557
 558 static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
 559                             u32 win, u32 ts)
 560 {
 561         struct tcphdr *th = skb->h.th;
 562         struct {
 563                 struct tcphdr th;
 564                 u32 tsopt[3];
 565         } rep;
 566         struct ip_reply_arg arg;
 567
 568         memset(&rep.th, 0, sizeof(struct tcphdr));
 569         memset(&arg, 0, sizeof arg);
 570
 571         arg.iov[0].iov_base = (unsigned char *)&rep;
 572         arg.iov[0].iov_len  = sizeof(rep.th);
 573         if (ts) {
 574                 rep.tsopt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
 575                                      (TCPOPT_TIMESTAMP << 8) |
 576                                      TCPOLEN_TIMESTAMP);
 577                 rep.tsopt[1] = htonl(tcp_time_stamp);
 578                 rep.tsopt[2] = htonl(ts);
 579                 arg.iov[0].iov_len = sizeof(rep);
 580         }
 581
 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);
 588         rep.th.ack     = 1;
 589         rep.th.window  = htons(win);
 590
 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;
 595
 596         ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len);
 597
 598         TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
 599 }
 600
 601 static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
 602 {
 603         struct inet_timewait_sock *tw = inet_twsk(sk);
 604         const struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
 605
 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);
 608
 609         inet_twsk_put(tw);
 610 }
 611
 612 static void tcp_v4_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
 613 {
 614         tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
 615                         req->ts_recent);
 616 }
 617
 618 /*
 619  *      Send a SYN-ACK after having received an ACK.
 620  *      This still operates on a request_sock only, not on a big
 621  *      socket.
 622  */
 623 static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
 624                               struct dst_entry *dst)
 625 {
 626         const struct inet_request_sock *ireq = inet_rsk(req);
 627         int err = -1;
 628         struct sk_buff * skb;
 629
 630         /* First, grab a route. */
 631         if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
 632                 goto out;
 633
 634         skb = tcp_make_synack(sk, dst, req);
 635
 636         if (skb) {
 637                 struct tcphdr *th = skb->h.th;
 638
 639                 th->check = tcp_v4_check(th, skb->len,
 640                                          ireq->loc_addr,
 641                                          ireq->rmt_addr,
 642                                          csum_partial((char *)th, skb->len,
 643                                                       skb->csum));
 644
 645                 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
 646                                             ireq->rmt_addr,
 647                                             ireq->opt);
 648                 if (err == NET_XMIT_CN)
 649                         err = 0;
 650         }
 651
 652 out:
 653         dst_release(dst);
 654         return err;
 655 }
 656
 657 /*
 658  *      IPv4 request_sock destructor.
 659  */
 660 static void tcp_v4_reqsk_destructor(struct request_sock *req)
 661 {
 662         kfree(inet_rsk(req)->opt);
 663 }
 664
 665 #ifdef CONFIG_SYN_COOKIES
 666 static void syn_flood_warning(struct sk_buff *skb)
 667 {
 668         static unsigned long warntime;
 669
 670         if (time_after(jiffies, (warntime + HZ * 60))) {
 671                 warntime = jiffies;
 672                 printk(KERN_INFO
 673                        "possible SYN flooding on port %d. Sending cookies.\n",
 674                        ntohs(skb->h.th->dest));
 675         }
 676 }
 677 #endif
 678
 679 /*
 680  * Save and compile IPv4 options into the request_sock if needed.
 681  */
 682 static struct ip_options *tcp_v4_save_options(struct sock *sk,
 683                                               struct sk_buff *skb)
 684 {
 685         struct ip_options *opt = &(IPCB(skb)->opt);
 686         struct ip_options *dopt = NULL;
 687
 688         if (opt && opt->optlen) {
 689                 int opt_size = optlength(opt);
 690                 dopt = kmalloc(opt_size, GFP_ATOMIC);
 691                 if (dopt) {
 692                         if (ip_options_echo(dopt, skb)) {
 693                                 kfree(dopt);
 694                                 dopt = NULL;
 695                         }
 696                 }
 697         }
 698         return dopt;
 699 }
 700
 701 struct request_sock_ops tcp_request_sock_ops = {
 702         .family         =       PF_INET,
 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,
 708 };
 709
 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,
 713 };
 714
 715 int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
 716 {
 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
 725         int want_cookie = 0;
 726 #else
 727 #define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
 728 #endif
 729
 730         /* Never answer to SYNs send to broadcast or multicast */
 731         if (((struct rtable *)skb->dst)->rt_flags &
 732             (RTCF_BROADCAST | RTCF_MULTICAST))
 733                 goto drop;
 734
 735         /* TW buckets are converted to open requests without
 736          * limitations, they conserve resources and peer is
 737          * evidently real one.
 738          */
 739         if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
 740 #ifdef CONFIG_SYN_COOKIES
 741                 if (sysctl_tcp_syncookies) {
 742                         want_cookie = 1;
 743                 } else
 744 #endif
 745                 goto drop;
 746         }
 747
 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
 751          * timeout.
 752          */
 753         if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
 754                 goto drop;
 755
 756         req = reqsk_alloc(&tcp_request_sock_ops);
 757         if (!req)
 758                 goto drop;
 759
 760         tcp_clear_options(&tmp_opt);
 761         tmp_opt.mss_clamp = 536;
 762         tmp_opt.user_mss  = tcp_sk(sk)->rx_opt.user_mss;
 763
 764         tcp_parse_options(skb, &tmp_opt, 0);
 765
 766         if (want_cookie) {
 767                 tcp_clear_options(&tmp_opt);
 768                 tmp_opt.saw_tstamp = 0;
 769         }
 770
 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.
 776                  */
 777                 tmp_opt.saw_tstamp = 0;
 778                 tmp_opt.tstamp_ok  = 0;
 779         }
 780         tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
 781
 782         tcp_openreq_init(req, &tmp_opt, skb);
 783
 784         ireq = inet_rsk(req);
 785         ireq->loc_addr = daddr;
 786         ireq->rmt_addr = saddr;
 787         ireq->opt = tcp_v4_save_options(sk, skb);
 788         if (!want_cookie)
 789                 TCP_ECN_create_request(req, skb->h.th);
 790
 791         if (want_cookie) {
 792 #ifdef CONFIG_SYN_COOKIES
 793                 syn_flood_warning(skb);
 794 #endif
 795                 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
 796         } else if (!isn) {
 797                 struct inet_peer *peer = NULL;
 798
 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.
 803                  *
 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.
 807                  */
 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) >
 815                                                         TCP_PAWS_WINDOW) {
 816                                 NET_INC_STATS_BH(LINUX_MIB_PAWSPASSIVEREJECTED);
 817                                 dst_release(dst);
 818                                 goto drop_and_free;
 819                         }
 820                 }
 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.
 833                          */
 834                         LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open "
 835                                        "request from %u.%u.%u.%u/%u\n",
 836                                        NIPQUAD(saddr),
 837                                        ntohs(skb->h.th->source));
 838                         dst_release(dst);
 839                         goto drop_and_free;
 840                 }
 841
 842                 isn = tcp_v4_init_sequence(sk, skb);
 843         }
 844         tcp_rsk(req)->snt_isn = isn;
 845
 846         if (tcp_v4_send_synack(sk, req, dst))
 847                 goto drop_and_free;
 848
 849         if (want_cookie) {
 850                 reqsk_free(req);
 851         } else {
 852                 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
 853         }
 854         return 0;
 855
 856 drop_and_free:
 857         reqsk_free(req);
 858 drop:
 859         TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
 860         return 0;
 861 }
 862
 863
 864 /*
 865  * The three way handshake has completed - we got a valid synack -
 866  * now create the new socket.
 867  */
 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)
 871 {
 872         struct inet_request_sock *ireq;
 873         struct inet_sock *newinet;
 874         struct tcp_sock *newtp;
 875         struct sock *newsk;
 876
 877         if (sk_acceptq_is_full(sk))
 878                 goto exit_overflow;
 879
 880         if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
 881                 goto exit;
 882
 883         newsk = tcp_create_openreq_child(sk, req, skb);
 884         if (!newsk)
 885                 goto exit;
 886
 887         sk_setup_caps(newsk, dst);
 888
 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;
 896         ireq->opt             = NULL;
 897         newinet->mc_index     = inet_iif(skb);
 898         newinet->mc_ttl       = skb->nh.iph->ttl;
 899         inet_csk(newsk)->icsk_ext_hdr_len = 0;
 900         if (newinet->opt)
 901                 inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
 902         newinet->id = newtp->write_seq ^ jiffies;
 903
 904         tcp_sync_mss(newsk, dst_mtu(dst));
 905         newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
 906         tcp_initialize_rcv_mss(newsk);
 907
 908         __inet_hash(&tcp_hashinfo, newsk, 0);
 909         __inet_inherit_port(&tcp_hashinfo, sk, newsk);
 910
 911         return newsk;
 912
 913 exit_overflow:
 914         NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
 915 exit:
 916         NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
 917         dst_release(dst);
 918         return NULL;
 919 }
 920
 921 static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
 922 {
 923         struct tcphdr *th = skb->h.th;
 924         struct iphdr *iph = skb->nh.iph;
 925         struct sock *nsk;
 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);
 930         if (req)
 931                 return tcp_check_req(sk, skb, req, prev);
 932
 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));
 936
 937         if (nsk) {
 938                 if (nsk->sk_state != TCP_TIME_WAIT) {
 939                         bh_lock_sock(nsk);
 940                         return nsk;
 941                 }
 942                 inet_twsk_put((struct inet_timewait_sock *)nsk);
 943                 return NULL;
 944         }
 945
 946 #ifdef CONFIG_SYN_COOKIES
 947         if (!th->rst && !th->syn && th->ack)
 948                 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
 949 #endif
 950         return sk;
 951 }
 952
 953 static int tcp_v4_checksum_init(struct sk_buff *skb)
 954 {
 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;
 959                         return 0;
 960                 }
 961         }
 962
 963         skb->csum = csum_tcpudp_nofold(skb->nh.iph->saddr, skb->nh.iph->daddr,
 964                                        skb->len, IPPROTO_TCP, 0);
 965
 966         if (skb->len <= 76) {
 967                 return __skb_checksum_complete(skb);
 968         }
 969         return 0;
 970 }
 971
 972
 973 /* The socket must have it's spinlock held when we get
 974  * here.
 975  *
 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
 979  * held.
 980  */
 981 int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
 982 {
 983         if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
 984                 TCP_CHECK_TIMER(sk);
 985                 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len))
 986                         goto reset;
 987                 TCP_CHECK_TIMER(sk);
 988                 return 0;
 989         }
 990
 991         if (skb->len < (skb->h.th->doff << 2) || tcp_checksum_complete(skb))
 992                 goto csum_err;
 993
 994         if (sk->sk_state == TCP_LISTEN) {
 995                 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
 996                 if (!nsk)
 997                         goto discard;
 998
 999                 if (nsk != sk) {
1000                         if (tcp_child_process(sk, nsk, skb))
1001                                 goto reset;
1002                         return 0;
1003                 }
1004         }
1005
1006         TCP_CHECK_TIMER(sk);
1007         if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len))
1008                 goto reset;
1009         TCP_CHECK_TIMER(sk);
1010         return 0;
1011
1012 reset:
1013         tcp_v4_send_reset(skb);
1014 discard:
1015         kfree_skb(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.
1020          */
1021         return 0;
1022
1023 csum_err:
1024         TCP_INC_STATS_BH(TCP_MIB_INERRS);
1025         goto discard;
1026 }
1027
1028 /*
1029  *      From tcp_input.c
1030  */
1031
1032 int tcp_v4_rcv(struct sk_buff *skb)
1033 {
1034         struct tcphdr *th;
1035         struct sock *sk;
1036         int ret;
1037
1038         if (skb->pkt_type != PACKET_HOST)
1039                 goto discard_it;
1040
1041         /* Count it even if it's bad */
1042         TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1043
1044         if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1045                 goto discard_it;
1046
1047         th = skb->h.th;
1048
1049         if (th->doff < sizeof(struct tcphdr) / 4)
1050                 goto bad_packet;
1051         if (!pskb_may_pull(skb, th->doff * 4))
1052                 goto discard_it;
1053
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)))
1060                 goto bad_packet;
1061
1062         th = skb->h.th;
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;
1070
1071         sk = __inet_lookup(&tcp_hashinfo, skb->nh.iph->saddr, th->source,
1072                            skb->nh.iph->daddr, ntohs(th->dest),
1073                            inet_iif(skb));
1074
1075         if (!sk)
1076                 goto no_tcp_socket;
1077
1078 process:
1079 #if defined(CONFIG_VNET) || defined(CONFIG_VNET_MODULE)
1080         /* Silently drop if VNET is active and the context is not
1081          * entitled to read the packet.
1082          */
1083         if (vnet_active) {
1084                 /* Transfer ownership of reusable TIME_WAIT buckets to
1085                  * whomever VNET decided should own the packet.
1086                  */
1087                 if (sk->sk_state == TCP_TIME_WAIT)
1088                         sk->sk_xid = skb->xid;
1089
1090                 if ((int) sk->sk_xid > 0 && sk->sk_xid != skb->xid)
1091                         goto discard_it;
1092         }
1093 #endif
1094
1095         if (sk->sk_state == TCP_TIME_WAIT)
1096                 goto do_time_wait;
1097
1098         if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1099                 goto discard_and_relse;
1100         nf_reset(skb);
1101
1102         if (sk_filter(sk, skb, 0))
1103                 goto discard_and_relse;
1104
1105         skb->dev = NULL;
1106
1107         bh_lock_sock(sk);
1108         ret = 0;
1109         if (!sock_owned_by_user(sk)) {
1110                 if (!tcp_prequeue(sk, skb))
1111                         ret = tcp_v4_do_rcv(sk, skb);
1112         } else
1113                 sk_add_backlog(sk, skb);
1114         bh_unlock_sock(sk);
1115
1116         sock_put(sk);
1117
1118         return ret;
1119
1120 no_tcp_socket:
1121         if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1122                 goto discard_it;
1123
1124         if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1125 bad_packet:
1126                 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1127 #if defined(CONFIG_VNET) || defined(CONFIG_VNET_MODULE)
1128         } else if (vnet_active && skb->sk) {
1129                 /* VNET: Suppress RST if the port was bound to a (presumably raw) socket */
1130 #endif
1131         } else {
1132                 tcp_v4_send_reset(skb);
1133         }
1134
1135 discard_it:
1136         /* Discard frame. */
1137         kfree_skb(skb);
1138         return 0;
1139
1140 discard_and_relse:
1141         sock_put(sk);
1142         goto discard_it;
1143
1144 do_time_wait:
1145         if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1146                 inet_twsk_put((struct inet_timewait_sock *) sk);
1147                 goto discard_it;
1148         }
1149
1150         if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1151                 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1152                 inet_twsk_put((struct inet_timewait_sock *) sk);
1153                 goto discard_it;
1154         }
1155         switch (tcp_timewait_state_process((struct inet_timewait_sock *)sk,
1156                                            skb, th)) {
1157         case TCP_TW_SYN: {
1158                 struct sock *sk2 = inet_lookup_listener(&tcp_hashinfo,
1159                                                         skb->nh.iph->daddr,
1160                                                         ntohs(th->dest),
1161                                                         inet_iif(skb));
1162                 if (sk2) {
1163                         inet_twsk_deschedule((struct inet_timewait_sock *)sk,
1164                                              &tcp_death_row);
1165                         inet_twsk_put((struct inet_timewait_sock *)sk);
1166                         sk = sk2;
1167                         goto process;
1168                 }
1169                 /* Fall through to ACK */
1170         }
1171         case TCP_TW_ACK:
1172                 tcp_v4_timewait_ack(sk, skb);
1173                 break;
1174         case TCP_TW_RST:
1175                 goto no_tcp_socket;
1176         case TCP_TW_SUCCESS:;
1177         }
1178         goto discard_it;
1179 }
1180
1181 /* VJ's idea. Save last timestamp seen from this destination
1182  * and hold it at least for normal timewait interval to use for duplicate
1183  * segment detection in subsequent connections, before they enter synchronized
1184  * state.
1185  */
1186
1187 int tcp_v4_remember_stamp(struct sock *sk)
1188 {
1189         struct inet_sock *inet = inet_sk(sk);
1190         struct tcp_sock *tp = tcp_sk(sk);
1191         struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1192         struct inet_peer *peer = NULL;
1193         int release_it = 0;
1194
1195         if (!rt || rt->rt_dst != inet->daddr) {
1196                 peer = inet_getpeer(inet->daddr, 1);
1197                 release_it = 1;
1198         } else {
1199                 if (!rt->peer)
1200                         rt_bind_peer(rt, 1);
1201                 peer = rt->peer;
1202         }
1203
1204         if (peer) {
1205                 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
1206                     (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1207                      peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {
1208                         peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;
1209                         peer->tcp_ts = tp->rx_opt.ts_recent;
1210                 }
1211                 if (release_it)
1212                         inet_putpeer(peer);
1213                 return 1;
1214         }
1215
1216         return 0;
1217 }
1218
1219 int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
1220 {
1221         struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
1222
1223         if (peer) {
1224                 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1225
1226                 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
1227                     (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1228                      peer->tcp_ts_stamp <= tcptw->tw_ts_recent_stamp)) {
1229                         peer->tcp_ts_stamp = tcptw->tw_ts_recent_stamp;
1230                         peer->tcp_ts       = tcptw->tw_ts_recent;
1231                 }
1232                 inet_putpeer(peer);
1233                 return 1;
1234         }
1235
1236         return 0;
1237 }
1238
1239 struct inet_connection_sock_af_ops ipv4_specific = {
1240         .queue_xmit     =       ip_queue_xmit,
1241         .send_check     =       tcp_v4_send_check,
1242         .rebuild_header =       inet_sk_rebuild_header,
1243         .conn_request   =       tcp_v4_conn_request,
1244         .syn_recv_sock  =       tcp_v4_syn_recv_sock,
1245         .remember_stamp =       tcp_v4_remember_stamp,
1246         .net_header_len =       sizeof(struct iphdr),
1247         .setsockopt     =       ip_setsockopt,
1248         .getsockopt     =       ip_getsockopt,
1249         .addr2sockaddr  =       inet_csk_addr2sockaddr,
1250         .sockaddr_len   =       sizeof(struct sockaddr_in),
1251 };
1252
1253 /* NOTE: A lot of things set to zero explicitly by call to
1254  *       sk_alloc() so need not be done here.
1255  */
1256 static int tcp_v4_init_sock(struct sock *sk)
1257 {
1258         struct inet_connection_sock *icsk = inet_csk(sk);
1259         struct tcp_sock *tp = tcp_sk(sk);
1260
1261         skb_queue_head_init(&tp->out_of_order_queue);
1262         tcp_init_xmit_timers(sk);
1263         tcp_prequeue_init(tp);
1264
1265         icsk->icsk_rto = TCP_TIMEOUT_INIT;
1266         tp->mdev = TCP_TIMEOUT_INIT;
1267
1268         /* So many TCP implementations out there (incorrectly) count the
1269          * initial SYN frame in their delayed-ACK and congestion control
1270          * algorithms that we must have the following bandaid to talk
1271          * efficiently to them.  -DaveM
1272          */
1273         tp->snd_cwnd = 2;
1274
1275         /* See draft-stevens-tcpca-spec-01 for discussion of the
1276          * initialization of these values.
1277          */
1278         tp->snd_ssthresh = 0x7fffffff;  /* Infinity */
1279         tp->snd_cwnd_clamp = ~0;
1280         tp->mss_cache = 536;
1281
1282         tp->reordering = sysctl_tcp_reordering;
1283         icsk->icsk_ca_ops = &tcp_init_congestion_ops;
1284
1285         sk->sk_state = TCP_CLOSE;
1286
1287         sk->sk_write_space = sk_stream_write_space;
1288         sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1289
1290         icsk->icsk_af_ops = &ipv4_specific;
1291         icsk->icsk_sync_mss = tcp_sync_mss;
1292
1293         sk->sk_sndbuf = sysctl_tcp_wmem[1];
1294         sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1295
1296         atomic_inc(&tcp_sockets_allocated);
1297
1298         return 0;
1299 }
1300
1301 int tcp_v4_destroy_sock(struct sock *sk)
1302 {
1303         struct tcp_sock *tp = tcp_sk(sk);
1304
1305         tcp_clear_xmit_timers(sk);
1306
1307         tcp_cleanup_congestion_control(sk);
1308
1309         /* Cleanup up the write buffer. */
1310         sk_stream_writequeue_purge(sk);
1311
1312         /* Cleans up our, hopefully empty, out_of_order_queue. */
1313         __skb_queue_purge(&tp->out_of_order_queue);
1314
1315         /* Clean prequeue, it must be empty really */
1316         __skb_queue_purge(&tp->ucopy.prequeue);
1317
1318         /* Clean up a referenced TCP bind bucket. */
1319         if (inet_csk(sk)->icsk_bind_hash)
1320                 inet_put_port(&tcp_hashinfo, sk);
1321
1322         /*
1323          * If sendmsg cached page exists, toss it.
1324          */
1325         if (sk->sk_sndmsg_page) {
1326                 __free_page(sk->sk_sndmsg_page);
1327                 sk->sk_sndmsg_page = NULL;
1328         }
1329
1330         atomic_dec(&tcp_sockets_allocated);
1331
1332         return 0;
1333 }
1334
1335 EXPORT_SYMBOL(tcp_v4_destroy_sock);
1336
1337 #ifdef CONFIG_PROC_FS
1338 /* Proc filesystem TCP sock list dumping. */
1339
1340 static inline struct inet_timewait_sock *tw_head(struct hlist_head *head)
1341 {
1342         return hlist_empty(head) ? NULL :
1343                 list_entry(head->first, struct inet_timewait_sock, tw_node);
1344 }
1345
1346 static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
1347 {
1348         return tw->tw_node.next ?
1349                 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
1350 }
1351
1352 static void *listening_get_next(struct seq_file *seq, void *cur)
1353 {
1354         struct inet_connection_sock *icsk;
1355         struct hlist_node *node;
1356         struct sock *sk = cur;
1357         struct tcp_iter_state* st = seq->private;
1358
1359         if (!sk) {
1360                 st->bucket = 0;
1361                 sk = sk_head(&tcp_hashinfo.listening_hash[0]);
1362                 goto get_sk;
1363         }
1364
1365         ++st->num;
1366
1367         if (st->state == TCP_SEQ_STATE_OPENREQ) {
1368                 struct request_sock *req = cur;
1369
1370                 icsk = inet_csk(st->syn_wait_sk);
1371                 req = req->dl_next;
1372                 while (1) {
1373                         while (req) {
1374                                 vxdprintk(VXD_CBIT(net, 6),
1375                                         "sk,req: %p [#%d] (from %d)", req->sk,
1376                                         (req->sk)?req->sk->sk_xid:0, vx_current_xid());
1377                                 if (req->sk &&
1378                                         !vx_check(req->sk->sk_xid, VX_IDENT|VX_WATCH))
1379                                         continue;
1380                                 if (req->rsk_ops->family == st->family) {
1381                                         cur = req;
1382                                         goto out;
1383                                 }
1384                                 req = req->dl_next;
1385                         }
1386                         if (++st->sbucket >= TCP_SYNQ_HSIZE)
1387                                 break;
1388 get_req:
1389                         req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
1390                 }
1391                 sk        = sk_next(st->syn_wait_sk);
1392                 st->state = TCP_SEQ_STATE_LISTENING;
1393                 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1394         } else {
1395                 icsk = inet_csk(sk);
1396                 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1397                 if (reqsk_queue_len(&icsk->icsk_accept_queue))
1398                         goto start_req;
1399                 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1400                 sk = sk_next(sk);
1401         }
1402 get_sk:
1403         sk_for_each_from(sk, node) {
1404                 vxdprintk(VXD_CBIT(net, 6), "sk: %p [#%d] (from %d)",
1405                         sk, sk->sk_xid, vx_current_xid());
1406                 if (!vx_check(sk->sk_xid, VX_IDENT|VX_WATCH))
1407                         continue;
1408                 if (sk->sk_family == st->family) {
1409                         cur = sk;
1410                         goto out;
1411                 }
1412                 icsk = inet_csk(sk);
1413                 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1414                 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
1415 start_req:
1416                         st->uid         = sock_i_uid(sk);
1417                         st->syn_wait_sk = sk;
1418                         st->state       = TCP_SEQ_STATE_OPENREQ;
1419                         st->sbucket     = 0;
1420                         goto get_req;
1421                 }
1422                 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1423         }
1424         if (++st->bucket < INET_LHTABLE_SIZE) {
1425                 sk = sk_head(&tcp_hashinfo.listening_hash[st->bucket]);
1426                 goto get_sk;
1427         }
1428         cur = NULL;
1429 out:
1430         return cur;
1431 }
1432
1433 static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
1434 {
1435         void *rc = listening_get_next(seq, NULL);
1436
1437         while (rc && *pos) {
1438                 rc = listening_get_next(seq, rc);
1439                 --*pos;
1440         }
1441         return rc;
1442 }
1443
1444 static void *established_get_first(struct seq_file *seq)
1445 {
1446         struct tcp_iter_state* st = seq->private;
1447         void *rc = NULL;
1448
1449         for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
1450                 struct sock *sk;
1451                 struct hlist_node *node;
1452                 struct inet_timewait_sock *tw;
1453
1454                 /* We can reschedule _before_ having picked the target: */
1455                 cond_resched_softirq();
1456
1457                 read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
1458                 sk_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
1459                         vxdprintk(VXD_CBIT(net, 6),
1460                                 "sk,egf: %p [#%d] (from %d)",
1461                                 sk, sk->sk_xid, vx_current_xid());
1462                         if (!vx_check(sk->sk_xid, VX_IDENT|VX_WATCH))
1463                                 continue;
1464                         if (sk->sk_family != st->family)
1465                                 continue;
1466                         rc = sk;
1467                         goto out;
1468                 }
1469                 st->state = TCP_SEQ_STATE_TIME_WAIT;
1470                 inet_twsk_for_each(tw, node,
1471                                    &tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain) {
1472                         vxdprintk(VXD_CBIT(net, 6),
1473                                 "tw: %p [#%d] (from %d)",
1474                                 tw, tw->tw_xid, vx_current_xid());
1475                         if (!vx_check(tw->tw_xid, VX_IDENT|VX_WATCH))
1476                                 continue;
1477                         if (tw->tw_family != st->family)
1478                                 continue;
1479                         rc = tw;
1480                         goto out;
1481                 }
1482                 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1483                 st->state = TCP_SEQ_STATE_ESTABLISHED;
1484         }
1485 out:
1486         return rc;
1487 }
1488
1489 static void *established_get_next(struct seq_file *seq, void *cur)
1490 {
1491         struct sock *sk = cur;
1492         struct inet_timewait_sock *tw;
1493         struct hlist_node *node;
1494         struct tcp_iter_state* st = seq->private;
1495
1496         ++st->num;
1497
1498         if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
1499                 tw = cur;
1500                 tw = tw_next(tw);
1501 get_tw:
1502                 while (tw && (tw->tw_family != st->family ||
1503                         !vx_check(tw->tw_xid, VX_IDENT|VX_WATCH))) {
1504                         tw = tw_next(tw);
1505                 }
1506                 if (tw) {
1507                         cur = tw;
1508                         goto out;
1509                 }
1510                 read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1511                 st->state = TCP_SEQ_STATE_ESTABLISHED;
1512
1513                 /* We can reschedule between buckets: */
1514                 cond_resched_softirq();
1515
1516                 if (++st->bucket < tcp_hashinfo.ehash_size) {
1517                         read_lock(&tcp_hashinfo.ehash[st->bucket].lock);
1518                         sk = sk_head(&tcp_hashinfo.ehash[st->bucket].chain);
1519                 } else {
1520                         cur = NULL;
1521                         goto out;
1522                 }
1523         } else
1524                 sk = sk_next(sk);
1525
1526         sk_for_each_from(sk, node) {
1527                 vxdprintk(VXD_CBIT(net, 6),
1528                         "sk,egn: %p [#%d] (from %d)",
1529                         sk, sk->sk_xid, vx_current_xid());
1530                 if (!vx_check(sk->sk_xid, VX_IDENT|VX_WATCH))
1531                         continue;
1532                 if (sk->sk_family == st->family)
1533                         goto found;
1534         }
1535
1536         st->state = TCP_SEQ_STATE_TIME_WAIT;
1537         tw = tw_head(&tcp_hashinfo.ehash[st->bucket + tcp_hashinfo.ehash_size].chain);
1538         goto get_tw;
1539 found:
1540         cur = sk;
1541 out:
1542         return cur;
1543 }
1544
1545 static void *established_get_idx(struct seq_file *seq, loff_t pos)
1546 {
1547         void *rc = established_get_first(seq);
1548
1549         while (rc && pos) {
1550                 rc = established_get_next(seq, rc);
1551                 --pos;
1552         }
1553         return rc;
1554 }
1555
1556 static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
1557 {
1558         void *rc;
1559         struct tcp_iter_state* st = seq->private;
1560
1561         inet_listen_lock(&tcp_hashinfo);
1562         st->state = TCP_SEQ_STATE_LISTENING;
1563         rc        = listening_get_idx(seq, &pos);
1564
1565         if (!rc) {
1566                 inet_listen_unlock(&tcp_hashinfo);
1567                 local_bh_disable();
1568                 st->state = TCP_SEQ_STATE_ESTABLISHED;
1569                 rc        = established_get_idx(seq, pos);
1570         }
1571
1572         return rc;
1573 }
1574
1575 static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
1576 {
1577         struct tcp_iter_state* st = seq->private;
1578         st->state = TCP_SEQ_STATE_LISTENING;
1579         st->num = 0;
1580         return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
1581 }
1582
1583 static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1584 {
1585         void *rc = NULL;
1586         struct tcp_iter_state* st;
1587
1588         if (v == SEQ_START_TOKEN) {
1589                 rc = tcp_get_idx(seq, 0);
1590                 goto out;
1591         }
1592         st = seq->private;
1593
1594         switch (st->state) {
1595         case TCP_SEQ_STATE_OPENREQ:
1596         case TCP_SEQ_STATE_LISTENING:
1597                 rc = listening_get_next(seq, v);
1598                 if (!rc) {
1599                         inet_listen_unlock(&tcp_hashinfo);
1600                         local_bh_disable();
1601                         st->state = TCP_SEQ_STATE_ESTABLISHED;
1602                         rc        = established_get_first(seq);
1603                 }
1604                 break;
1605         case TCP_SEQ_STATE_ESTABLISHED:
1606         case TCP_SEQ_STATE_TIME_WAIT:
1607                 rc = established_get_next(seq, v);
1608                 break;
1609         }
1610 out:
1611         ++*pos;
1612         return rc;
1613 }
1614
1615 static void tcp_seq_stop(struct seq_file *seq, void *v)
1616 {
1617         struct tcp_iter_state* st = seq->private;
1618
1619         switch (st->state) {
1620         case TCP_SEQ_STATE_OPENREQ:
1621                 if (v) {
1622                         struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
1623                         read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1624                 }
1625         case TCP_SEQ_STATE_LISTENING:
1626                 if (v != SEQ_START_TOKEN)
1627                         inet_listen_unlock(&tcp_hashinfo);
1628                 break;
1629         case TCP_SEQ_STATE_TIME_WAIT:
1630         case TCP_SEQ_STATE_ESTABLISHED:
1631                 if (v)
1632                         read_unlock(&tcp_hashinfo.ehash[st->bucket].lock);
1633                 local_bh_enable();
1634                 break;
1635         }
1636 }
1637
1638 static int tcp_seq_open(struct inode *inode, struct file *file)
1639 {
1640         struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
1641         struct seq_file *seq;
1642         struct tcp_iter_state *s;
1643         int rc;
1644
1645         if (unlikely(afinfo == NULL))
1646                 return -EINVAL;
1647
1648         s = kmalloc(sizeof(*s), GFP_KERNEL);
1649         if (!s)
1650                 return -ENOMEM;
1651         memset(s, 0, sizeof(*s));
1652         s->family               = afinfo->family;
1653         s->seq_ops.start        = tcp_seq_start;
1654         s->seq_ops.next         = tcp_seq_next;
1655         s->seq_ops.show         = afinfo->seq_show;
1656         s->seq_ops.stop         = tcp_seq_stop;
1657
1658         rc = seq_open(file, &s->seq_ops);
1659         if (rc)
1660                 goto out_kfree;
1661         seq          = file->private_data;
1662         seq->private = s;
1663 out:
1664         return rc;
1665 out_kfree:
1666         kfree(s);
1667         goto out;
1668 }
1669
1670 int tcp_proc_register(struct tcp_seq_afinfo *afinfo)
1671 {
1672         int rc = 0;
1673         struct proc_dir_entry *p;
1674
1675         if (!afinfo)
1676                 return -EINVAL;
1677         afinfo->seq_fops->owner         = afinfo->owner;
1678         afinfo->seq_fops->open          = tcp_seq_open;
1679         afinfo->seq_fops->read          = seq_read;
1680         afinfo->seq_fops->llseek        = seq_lseek;
1681         afinfo->seq_fops->release       = seq_release_private;
1682
1683         p = proc_net_fops_create(afinfo->name, S_IRUGO, afinfo->seq_fops);
1684         if (p)
1685                 p->data = afinfo;
1686         else
1687                 rc = -ENOMEM;
1688         return rc;
1689 }
1690
1691 void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo)
1692 {
1693         if (!afinfo)
1694                 return;
1695         proc_net_remove(afinfo->name);
1696         memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops));
1697 }
1698
1699 static void get_openreq4(struct sock *sk, struct request_sock *req,
1700                          char *tmpbuf, int i, int uid)
1701 {
1702         const struct inet_request_sock *ireq = inet_rsk(req);
1703         int ttd = req->expires - jiffies;
1704
1705         sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
1706                 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p",
1707                 i,
1708                 ireq->loc_addr,
1709                 ntohs(inet_sk(sk)->sport),
1710                 ireq->rmt_addr,
1711                 ntohs(ireq->rmt_port),
1712                 TCP_SYN_RECV,
1713                 0, 0, /* could print option size, but that is af dependent. */
1714                 1,    /* timers active (only the expire timer) */
1715                 jiffies_to_clock_t(ttd),
1716                 req->retrans,
1717                 uid,
1718                 0,  /* non standard timer */
1719                 0, /* open_requests have no inode */
1720                 atomic_read(&sk->sk_refcnt),
1721                 req);
1722 }
1723
1724 static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i)
1725 {
1726         int timer_active;
1727         unsigned long timer_expires;
1728         struct tcp_sock *tp = tcp_sk(sp);
1729         const struct inet_connection_sock *icsk = inet_csk(sp);
1730         struct inet_sock *inet = inet_sk(sp);
1731         unsigned int dest = inet->daddr;
1732         unsigned int src = inet->rcv_saddr;
1733         __u16 destp = ntohs(inet->dport);
1734         __u16 srcp = ntohs(inet->sport);
1735
1736         if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
1737                 timer_active    = 1;
1738                 timer_expires   = icsk->icsk_timeout;
1739         } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
1740                 timer_active    = 4;
1741                 timer_expires   = icsk->icsk_timeout;
1742         } else if (timer_pending(&sp->sk_timer)) {
1743                 timer_active    = 2;
1744                 timer_expires   = sp->sk_timer.expires;
1745         } else {
1746                 timer_active    = 0;
1747                 timer_expires = jiffies;
1748         }
1749
1750         sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
1751                         "%08X %5d %8d %lu %d %p %u %u %u %u %d",
1752                 i, src, srcp, dest, destp, sp->sk_state,
1753                 tp->write_seq - tp->snd_una, tp->rcv_nxt - tp->copied_seq,
1754                 timer_active,
1755                 jiffies_to_clock_t(timer_expires - jiffies),
1756                 icsk->icsk_retransmits,
1757                 sock_i_uid(sp),
1758                 icsk->icsk_probes_out,
1759                 sock_i_ino(sp),
1760                 atomic_read(&sp->sk_refcnt), sp,
1761                 icsk->icsk_rto,
1762                 icsk->icsk_ack.ato,
1763                 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
1764                 tp->snd_cwnd,
1765                 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh);
1766 }
1767
1768 static void get_timewait4_sock(struct inet_timewait_sock *tw, char *tmpbuf, int i)
1769 {
1770         unsigned int dest, src;
1771         __u16 destp, srcp;
1772         int ttd = tw->tw_ttd - jiffies;
1773
1774         if (ttd < 0)
1775                 ttd = 0;
1776
1777         dest  = tw->tw_daddr;
1778         src   = tw->tw_rcv_saddr;
1779         destp = ntohs(tw->tw_dport);
1780         srcp  = ntohs(tw->tw_sport);
1781
1782         sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
1783                 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p",
1784                 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
1785                 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
1786                 atomic_read(&tw->tw_refcnt), tw);
1787 }
1788
1789 #define TMPSZ 150
1790
1791 static int tcp4_seq_show(struct seq_file *seq, void *v)
1792 {
1793         struct tcp_iter_state* st;
1794         char tmpbuf[TMPSZ + 1];
1795
1796         if (v == SEQ_START_TOKEN) {
1797                 seq_printf(seq, "%-*s\n", TMPSZ - 1,
1798                            "  sl  local_address rem_address   st tx_queue "
1799                            "rx_queue tr tm->when retrnsmt   uid  timeout "
1800                            "inode");
1801                 goto out;
1802         }
1803         st = seq->private;
1804
1805         switch (st->state) {
1806         case TCP_SEQ_STATE_LISTENING:
1807         case TCP_SEQ_STATE_ESTABLISHED:
1808                 get_tcp4_sock(v, tmpbuf, st->num);
1809                 break;
1810         case TCP_SEQ_STATE_OPENREQ:
1811                 get_openreq4(st->syn_wait_sk, v, tmpbuf, st->num, st->uid);
1812                 break;
1813         case TCP_SEQ_STATE_TIME_WAIT:
1814                 get_timewait4_sock(v, tmpbuf, st->num);
1815                 break;
1816         }
1817         seq_printf(seq, "%-*s\n", TMPSZ - 1, tmpbuf);
1818 out:
1819         return 0;
1820 }
1821
1822 static struct file_operations tcp4_seq_fops;
1823 static struct tcp_seq_afinfo tcp4_seq_afinfo = {
1824         .owner          = THIS_MODULE,
1825         .name           = "tcp",
1826         .family         = AF_INET,
1827         .seq_show       = tcp4_seq_show,
1828         .seq_fops       = &tcp4_seq_fops,
1829 };
1830
1831 int __init tcp4_proc_init(void)
1832 {
1833         return tcp_proc_register(&tcp4_seq_afinfo);
1834 }
1835
1836 void tcp4_proc_exit(void)
1837 {
1838         tcp_proc_unregister(&tcp4_seq_afinfo);
1839 }
1840 #endif /* CONFIG_PROC_FS */
1841
1842 struct proto tcp_prot = {
1843         .name                   = "TCP",
1844         .owner                  = THIS_MODULE,
1845         .close                  = tcp_close,
1846         .connect                = tcp_v4_connect,
1847         .disconnect             = tcp_disconnect,
1848         .accept                 = inet_csk_accept,
1849         .ioctl                  = tcp_ioctl,
1850         .init                   = tcp_v4_init_sock,
1851         .destroy                = tcp_v4_destroy_sock,
1852         .shutdown               = tcp_shutdown,
1853         .setsockopt             = tcp_setsockopt,
1854         .getsockopt             = tcp_getsockopt,
1855         .sendmsg                = tcp_sendmsg,
1856         .recvmsg                = tcp_recvmsg,
1857         .backlog_rcv            = tcp_v4_do_rcv,
1858         .hash                   = tcp_v4_hash,
1859         .unhash                 = tcp_unhash,
1860         .get_port               = tcp_v4_get_port,
1861         .enter_memory_pressure  = tcp_enter_memory_pressure,
1862         .sockets_allocated      = &tcp_sockets_allocated,
1863         .orphan_count           = &tcp_orphan_count,
1864         .memory_allocated       = &tcp_memory_allocated,
1865         .memory_pressure        = &tcp_memory_pressure,
1866         .sysctl_mem             = sysctl_tcp_mem,
1867         .sysctl_wmem            = sysctl_tcp_wmem,
1868         .sysctl_rmem            = sysctl_tcp_rmem,
1869         .max_header             = MAX_TCP_HEADER,
1870         .obj_size               = sizeof(struct tcp_sock),
1871         .twsk_prot              = &tcp_timewait_sock_ops,
1872         .rsk_prot               = &tcp_request_sock_ops,
1873 };
1874
1875
1876
1877 void __init tcp_v4_init(struct net_proto_family *ops)
1878 {
1879         int err = sock_create_kern(PF_INET, SOCK_RAW, IPPROTO_TCP, &tcp_socket);
1880         if (err < 0)
1881                 panic("Failed to create the TCP control socket.\n");
1882         tcp_socket->sk->sk_allocation   = GFP_ATOMIC;
1883         inet_sk(tcp_socket->sk)->uc_ttl = -1;
1884
1885         /* Unhash it so that IP input processing does not even
1886          * see it, we do not wish this socket to see incoming
1887          * packets.
1888          */
1889         tcp_socket->sk->sk_prot->unhash(tcp_socket->sk);
1890 }
1891
1892 EXPORT_SYMBOL(ipv4_specific);
1893 EXPORT_SYMBOL(tcp_hashinfo);
1894 EXPORT_SYMBOL(tcp_prot);
1895 EXPORT_SYMBOL(tcp_unhash);
1896 EXPORT_SYMBOL(tcp_v4_conn_request);
1897 EXPORT_SYMBOL(tcp_v4_connect);
1898 EXPORT_SYMBOL(tcp_v4_do_rcv);
1899 EXPORT_SYMBOL(tcp_v4_remember_stamp);
1900 EXPORT_SYMBOL(tcp_v4_send_check);
1901 EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
1902
1903 #ifdef CONFIG_PROC_FS
1904 EXPORT_SYMBOL(tcp_proc_register);
1905 EXPORT_SYMBOL(tcp_proc_unregister);
1906 #endif
1907 EXPORT_SYMBOL(sysctl_local_port_range);
1908 EXPORT_SYMBOL(sysctl_tcp_low_latency);
1909 EXPORT_SYMBOL(sysctl_tcp_tw_reuse);
1910