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: tcp_ipv4.c,v 1.240 2002/02/01 22:01:04 davem Exp $
   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  *                                      open_request handling and moved
  40  *                                      most of it into the af independent code.
  41  *                                      Added tail drop and some other bugfixes.
  42  *                                      Added new listen sematics.
  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/tcp.h>
  68 #include <net/ipv6.h>
  69 #include <net/inet_common.h>
  70 #include <net/xfrm.h>
  71
  72 #include <linux/inet.h>
  73 #include <linux/ipv6.h>
  74 #include <linux/stddef.h>
  75 #include <linux/proc_fs.h>
  76 #include <linux/seq_file.h>
  77
  78 extern int sysctl_ip_dynaddr;
  79 int sysctl_tcp_tw_reuse;
  80 int sysctl_tcp_low_latency;
  81
  82 /* Check TCP sequence numbers in ICMP packets. */
  83 #define ICMP_MIN_LENGTH 8
  84
  85 /* Socket used for sending RSTs */
  86 static struct socket *tcp_socket;
  87
  88 void tcp_v4_send_check(struct sock *sk, struct tcphdr *th, int len,
  89                        struct sk_buff *skb);
  90
  91 struct tcp_hashinfo __cacheline_aligned tcp_hashinfo = {
  92         .__tcp_lhash_lock       =       RW_LOCK_UNLOCKED,
  93         .__tcp_lhash_users      =       ATOMIC_INIT(0),
  94         .__tcp_lhash_wait
  95           = __WAIT_QUEUE_HEAD_INITIALIZER(tcp_hashinfo.__tcp_lhash_wait),
  96         .__tcp_portalloc_lock   =       SPIN_LOCK_UNLOCKED
  97 };
  98
  99 /*
 100  * This array holds the first and last local port number.
 101  * For high-usage systems, use sysctl to change this to
 102  * 32768-61000
 103  */
 104 int sysctl_local_port_range[2] = { 1024, 4999 };
 105 int tcp_port_rover = 1024 - 1;
 106
 107 static __inline__ int tcp_hashfn(__u32 laddr, __u16 lport,
 108                                  __u32 faddr, __u16 fport)
 109 {
 110         int h = (laddr ^ lport) ^ (faddr ^ fport);
 111         h ^= h >> 16;
 112         h ^= h >> 8;
 113         return h & (tcp_ehash_size - 1);
 114 }
 115
 116 static __inline__ int tcp_sk_hashfn(struct sock *sk)
 117 {
 118         struct inet_sock *inet = inet_sk(sk);
 119         __u32 laddr = inet->rcv_saddr;
 120         __u16 lport = inet->num;
 121         __u32 faddr = inet->daddr;
 122         __u16 fport = inet->dport;
 123
 124         return tcp_hashfn(laddr, lport, faddr, fport);
 125 }
 126
 127 /* Allocate and initialize a new TCP local port bind bucket.
 128  * The bindhash mutex for snum's hash chain must be held here.
 129  */
 130 struct tcp_bind_bucket *tcp_bucket_create(struct tcp_bind_hashbucket *head,
 131                                           unsigned short snum)
 132 {
 133         struct tcp_bind_bucket *tb = kmem_cache_alloc(tcp_bucket_cachep,
 134                                                       SLAB_ATOMIC);
 135         if (tb) {
 136                 tb->port = snum;
 137                 tb->fastreuse = 0;
 138                 INIT_HLIST_HEAD(&tb->owners);
 139                 hlist_add_head(&tb->node, &head->chain);
 140         }
 141         return tb;
 142 }
 143
 144 /* Caller must hold hashbucket lock for this tb with local BH disabled */
 145 void tcp_bucket_destroy(struct tcp_bind_bucket *tb)
 146 {
 147         if (hlist_empty(&tb->owners)) {
 148                 __hlist_del(&tb->node);
 149                 kmem_cache_free(tcp_bucket_cachep, tb);
 150         }
 151 }
 152
 153 /* Caller must disable local BH processing. */
 154 static __inline__ void __tcp_inherit_port(struct sock *sk, struct sock *child)
 155 {
 156         struct tcp_bind_hashbucket *head =
 157                                 &tcp_bhash[tcp_bhashfn(inet_sk(child)->num)];
 158         struct tcp_bind_bucket *tb;
 159
 160         spin_lock(&head->lock);
 161         tb = tcp_sk(sk)->bind_hash;
 162         sk_add_bind_node(child, &tb->owners);
 163         tcp_sk(child)->bind_hash = tb;
 164         spin_unlock(&head->lock);
 165 }
 166
 167 inline void tcp_inherit_port(struct sock *sk, struct sock *child)
 168 {
 169         local_bh_disable();
 170         __tcp_inherit_port(sk, child);
 171         local_bh_enable();
 172 }
 173
 174 void tcp_bind_hash(struct sock *sk, struct tcp_bind_bucket *tb,
 175                    unsigned short snum)
 176 {
 177         inet_sk(sk)->num = snum;
 178         sk_add_bind_node(sk, &tb->owners);
 179         tcp_sk(sk)->bind_hash = tb;
 180 }
 181
 182 static inline int tcp_bind_conflict(struct sock *sk, struct tcp_bind_bucket *tb)
 183 {
 184         const u32 sk_rcv_saddr = tcp_v4_rcv_saddr(sk);
 185         struct sock *sk2;
 186         struct hlist_node *node;
 187         int reuse = sk->sk_reuse;
 188
 189         sk_for_each_bound(sk2, node, &tb->owners) {
 190                 if (sk != sk2 &&
 191                     !tcp_v6_ipv6only(sk2) &&
 192                     (!sk->sk_bound_dev_if ||
 193                      !sk2->sk_bound_dev_if ||
 194                      sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) {
 195                         if (!reuse || !sk2->sk_reuse ||
 196                             sk2->sk_state == TCP_LISTEN) {
 197                                 const u32 sk2_rcv_saddr = tcp_v4_rcv_saddr(sk2);
 198                                 if (!sk2_rcv_saddr || !sk_rcv_saddr ||
 199                                     sk2_rcv_saddr == sk_rcv_saddr)
 200                                         break;
 201                         }
 202                 }
 203         }
 204         return node != NULL;
 205 }
 206
 207 /* Obtain a reference to a local port for the given sock,
 208  * if snum is zero it means select any available local port.
 209  */
 210 static int tcp_v4_get_port(struct sock *sk, unsigned short snum)
 211 {
 212         struct tcp_bind_hashbucket *head;
 213         struct hlist_node *node;
 214         struct tcp_bind_bucket *tb;
 215         int ret;
 216
 217         local_bh_disable();
 218         if (!snum) {
 219                 int low = sysctl_local_port_range[0];
 220                 int high = sysctl_local_port_range[1];
 221                 int remaining = (high - low) + 1;
 222                 int rover;
 223
 224                 spin_lock(&tcp_portalloc_lock);
 225                 if (tcp_port_rover < low)
 226                         rover = low;
 227                 else
 228                         rover = tcp_port_rover;
 229                 do {
 230                         rover++;
 231                         if (rover > high)
 232                                 rover = low;
 233                         head = &tcp_bhash[tcp_bhashfn(rover)];
 234                         spin_lock(&head->lock);
 235                         tb_for_each(tb, node, &head->chain)
 236                                 if (tb->port == rover)
 237                                         goto next;
 238                         break;
 239                 next:
 240                         spin_unlock(&head->lock);
 241                 } while (--remaining > 0);
 242                 tcp_port_rover = rover;
 243                 spin_unlock(&tcp_portalloc_lock);
 244
 245                 /* Exhausted local port range during search? */
 246                 ret = 1;
 247                 if (remaining <= 0)
 248                         goto fail;
 249
 250                 /* OK, here is the one we will use.  HEAD is
 251                  * non-NULL and we hold it's mutex.
 252                  */
 253                 snum = rover;
 254         } else {
 255                 head = &tcp_bhash[tcp_bhashfn(snum)];
 256                 spin_lock(&head->lock);
 257                 tb_for_each(tb, node, &head->chain)
 258                         if (tb->port == snum)
 259                                 goto tb_found;
 260         }
 261         tb = NULL;
 262         goto tb_not_found;
 263 tb_found:
 264         if (!hlist_empty(&tb->owners)) {
 265                 if (sk->sk_reuse > 1)
 266                         goto success;
 267                 if (tb->fastreuse > 0 &&
 268                     sk->sk_reuse && sk->sk_state != TCP_LISTEN) {
 269                         goto success;
 270                 } else {
 271                         ret = 1;
 272                         if (tcp_bind_conflict(sk, tb))
 273                                 goto fail_unlock;
 274                 }
 275         }
 276 tb_not_found:
 277         ret = 1;
 278         if (!tb && (tb = tcp_bucket_create(head, snum)) == NULL)
 279                 goto fail_unlock;
 280         if (hlist_empty(&tb->owners)) {
 281                 if (sk->sk_reuse && sk->sk_state != TCP_LISTEN)
 282                         tb->fastreuse = 1;
 283                 else
 284                         tb->fastreuse = 0;
 285         } else if (tb->fastreuse &&
 286                    (!sk->sk_reuse || sk->sk_state == TCP_LISTEN))
 287                 tb->fastreuse = 0;
 288 success:
 289         if (!tcp_sk(sk)->bind_hash)
 290                 tcp_bind_hash(sk, tb, snum);
 291         BUG_TRAP(tcp_sk(sk)->bind_hash == tb);
 292         ret = 0;
 293
 294 fail_unlock:
 295         spin_unlock(&head->lock);
 296 fail:
 297         local_bh_enable();
 298         return ret;
 299 }
 300
 301 /* Get rid of any references to a local port held by the
 302  * given sock.
 303  */
 304 static void __tcp_put_port(struct sock *sk)
 305 {
 306         struct inet_sock *inet = inet_sk(sk);
 307         struct tcp_bind_hashbucket *head = &tcp_bhash[tcp_bhashfn(inet->num)];
 308         struct tcp_bind_bucket *tb;
 309
 310         spin_lock(&head->lock);
 311         tb = tcp_sk(sk)->bind_hash;
 312         __sk_del_bind_node(sk);
 313         tcp_sk(sk)->bind_hash = NULL;
 314         inet->num = 0;
 315         tcp_bucket_destroy(tb);
 316         spin_unlock(&head->lock);
 317 }
 318
 319 void tcp_put_port(struct sock *sk)
 320 {
 321         local_bh_disable();
 322         __tcp_put_port(sk);
 323         local_bh_enable();
 324 }
 325
 326 /* This lock without WQ_FLAG_EXCLUSIVE is good on UP and it can be very bad on SMP.
 327  * Look, when several writers sleep and reader wakes them up, all but one
 328  * immediately hit write lock and grab all the cpus. Exclusive sleep solves
 329  * this, _but_ remember, it adds useless work on UP machines (wake up each
 330  * exclusive lock release). It should be ifdefed really.
 331  */
 332
 333 void tcp_listen_wlock(void)
 334 {
 335         write_lock(&tcp_lhash_lock);
 336
 337         if (atomic_read(&tcp_lhash_users)) {
 338                 DEFINE_WAIT(wait);
 339
 340                 for (;;) {
 341                         prepare_to_wait_exclusive(&tcp_lhash_wait,
 342                                                 &wait, TASK_UNINTERRUPTIBLE);
 343                         if (!atomic_read(&tcp_lhash_users))
 344                                 break;
 345                         write_unlock_bh(&tcp_lhash_lock);
 346                         schedule();
 347                         write_lock_bh(&tcp_lhash_lock);
 348                 }
 349
 350                 finish_wait(&tcp_lhash_wait, &wait);
 351         }
 352 }
 353
 354 static __inline__ void __tcp_v4_hash(struct sock *sk, const int listen_possible)
 355 {
 356         struct hlist_head *list;
 357         rwlock_t *lock;
 358
 359         BUG_TRAP(sk_unhashed(sk));
 360         if (listen_possible && sk->sk_state == TCP_LISTEN) {
 361                 list = &tcp_listening_hash[tcp_sk_listen_hashfn(sk)];
 362                 lock = &tcp_lhash_lock;
 363                 tcp_listen_wlock();
 364         } else {
 365                 list = &tcp_ehash[(sk->sk_hashent = tcp_sk_hashfn(sk))].chain;
 366                 lock = &tcp_ehash[sk->sk_hashent].lock;
 367                 write_lock(lock);
 368         }
 369         __sk_add_node(sk, list);
 370         sock_prot_inc_use(sk->sk_prot);
 371         write_unlock(lock);
 372         if (listen_possible && sk->sk_state == TCP_LISTEN)
 373                 wake_up(&tcp_lhash_wait);
 374 }
 375
 376 static void tcp_v4_hash(struct sock *sk)
 377 {
 378         if (sk->sk_state != TCP_CLOSE) {
 379                 local_bh_disable();
 380                 __tcp_v4_hash(sk, 1);
 381                 local_bh_enable();
 382         }
 383 }
 384
 385 void tcp_unhash(struct sock *sk)
 386 {
 387         rwlock_t *lock;
 388
 389         if (sk_unhashed(sk))
 390                 goto ende;
 391
 392         if (sk->sk_state == TCP_LISTEN) {
 393                 local_bh_disable();
 394                 tcp_listen_wlock();
 395                 lock = &tcp_lhash_lock;
 396         } else {
 397                 struct tcp_ehash_bucket *head = &tcp_ehash[sk->sk_hashent];
 398                 lock = &head->lock;
 399                 write_lock_bh(&head->lock);
 400         }
 401
 402         if (__sk_del_node_init(sk))
 403                 sock_prot_dec_use(sk->sk_prot);
 404         write_unlock_bh(lock);
 405
 406  ende:
 407         if (sk->sk_state == TCP_LISTEN)
 408                 wake_up(&tcp_lhash_wait);
 409 }
 410
 411 /* Don't inline this cruft.  Here are some nice properties to
 412  * exploit here.  The BSD API does not allow a listening TCP
 413  * to specify the remote port nor the remote address for the
 414  * connection.  So always assume those are both wildcarded
 415  * during the search since they can never be otherwise.
 416  */
 417 static struct sock *__tcp_v4_lookup_listener(struct hlist_head *head, u32 daddr,
 418                                              unsigned short hnum, int dif)
 419 {
 420         struct sock *result = NULL, *sk;
 421         struct hlist_node *node;
 422         int score, hiscore;
 423
 424         hiscore=-1;
 425         sk_for_each(sk, node, head) {
 426                 struct inet_sock *inet = inet_sk(sk);
 427
 428                 if (inet->num == hnum && !ipv6_only_sock(sk)) {
 429                         __u32 rcv_saddr = inet->rcv_saddr;
 430
 431                         score = (sk->sk_family == PF_INET ? 1 : 0);
 432                         if (rcv_saddr) {
 433                                 if (rcv_saddr != daddr)
 434                                         continue;
 435                                 score+=2;
 436                         }
 437                         if (sk->sk_bound_dev_if) {
 438                                 if (sk->sk_bound_dev_if != dif)
 439                                         continue;
 440                                 score+=2;
 441                         }
 442                         if (score == 5)
 443                                 return sk;
 444                         if (score > hiscore) {
 445                                 hiscore = score;
 446                                 result = sk;
 447                         }
 448                 }
 449         }
 450         return result;
 451 }
 452
 453 /* Optimize the common listener case. */
 454 static inline struct sock *tcp_v4_lookup_listener(u32 daddr,
 455                 unsigned short hnum, int dif)
 456 {
 457         struct sock *sk = NULL;
 458         struct hlist_head *head;
 459
 460         read_lock(&tcp_lhash_lock);
 461         head = &tcp_listening_hash[tcp_lhashfn(hnum)];
 462         if (!hlist_empty(head)) {
 463                 struct inet_sock *inet = inet_sk((sk = __sk_head(head)));
 464
 465                 if (inet->num == hnum && !sk->sk_node.next &&
 466                     (!inet->rcv_saddr || inet->rcv_saddr == daddr) &&
 467                     (sk->sk_family == PF_INET || !ipv6_only_sock(sk)) &&
 468                     !sk->sk_bound_dev_if)
 469                         goto sherry_cache;
 470                 sk = __tcp_v4_lookup_listener(head, daddr, hnum, dif);
 471         }
 472         if (sk) {
 473 sherry_cache:
 474                 sock_hold(sk);
 475         }
 476         read_unlock(&tcp_lhash_lock);
 477         return sk;
 478 }
 479
 480 /* Sockets in TCP_CLOSE state are _always_ taken out of the hash, so
 481  * we need not check it for TCP lookups anymore, thanks Alexey. -DaveM
 482  *
 483  * Local BH must be disabled here.
 484  */
 485
 486 static inline struct sock *__tcp_v4_lookup_established(u32 saddr, u16 sport,
 487                                                        u32 daddr, u16 hnum,
 488                                                        int dif)
 489 {
 490         struct tcp_ehash_bucket *head;
 491         TCP_V4_ADDR_COOKIE(acookie, saddr, daddr)
 492         __u32 ports = TCP_COMBINED_PORTS(sport, hnum);
 493         struct sock *sk;
 494         struct hlist_node *node;
 495         /* Optimize here for direct hit, only listening connections can
 496          * have wildcards anyways.
 497          */
 498         int hash = tcp_hashfn(daddr, hnum, saddr, sport);
 499         head = &tcp_ehash[hash];
 500         read_lock(&head->lock);
 501         sk_for_each(sk, node, &head->chain) {
 502                 if (TCP_IPV4_MATCH(sk, acookie, saddr, daddr, ports, dif))
 503                         goto hit; /* You sunk my battleship! */
 504         }
 505
 506         /* Must check for a TIME_WAIT'er before going to listener hash. */
 507         sk_for_each(sk, node, &(head + tcp_ehash_size)->chain) {
 508                 if (TCP_IPV4_TW_MATCH(sk, acookie, saddr, daddr, ports, dif))
 509                         goto hit;
 510         }
 511         sk = NULL;
 512 out:
 513         read_unlock(&head->lock);
 514         return sk;
 515 hit:
 516         sock_hold(sk);
 517         goto out;
 518 }
 519
 520 static inline struct sock *__tcp_v4_lookup(u32 saddr, u16 sport,
 521                                            u32 daddr, u16 hnum, int dif)
 522 {
 523         struct sock *sk = __tcp_v4_lookup_established(saddr, sport,
 524                                                       daddr, hnum, dif);
 525
 526         return sk ? : tcp_v4_lookup_listener(daddr, hnum, dif);
 527 }
 528
 529 inline struct sock *tcp_v4_lookup(u32 saddr, u16 sport, u32 daddr,
 530                                   u16 dport, int dif)
 531 {
 532         struct sock *sk;
 533
 534         local_bh_disable();
 535         sk = __tcp_v4_lookup(saddr, sport, daddr, ntohs(dport), dif);
 536         local_bh_enable();
 537
 538         return sk;
 539 }
 540
 541 EXPORT_SYMBOL_GPL(tcp_v4_lookup);
 542
 543 static inline __u32 tcp_v4_init_sequence(struct sock *sk, struct sk_buff *skb)
 544 {
 545         return secure_tcp_sequence_number(skb->nh.iph->daddr,
 546                                           skb->nh.iph->saddr,
 547                                           skb->h.th->dest,
 548                                           skb->h.th->source);
 549 }
 550
 551 /* called with local bh disabled */
 552 static int __tcp_v4_check_established(struct sock *sk, __u16 lport,
 553                                       struct tcp_tw_bucket **twp)
 554 {
 555         struct inet_sock *inet = inet_sk(sk);
 556         u32 daddr = inet->rcv_saddr;
 557         u32 saddr = inet->daddr;
 558         int dif = sk->sk_bound_dev_if;
 559         TCP_V4_ADDR_COOKIE(acookie, saddr, daddr)
 560         __u32 ports = TCP_COMBINED_PORTS(inet->dport, lport);
 561         int hash = tcp_hashfn(daddr, lport, saddr, inet->dport);
 562         struct tcp_ehash_bucket *head = &tcp_ehash[hash];
 563         struct sock *sk2;
 564         struct hlist_node *node;
 565         struct tcp_tw_bucket *tw;
 566
 567         write_lock(&head->lock);
 568
 569         /* Check TIME-WAIT sockets first. */
 570         sk_for_each(sk2, node, &(head + tcp_ehash_size)->chain) {
 571                 tw = (struct tcp_tw_bucket *)sk2;
 572
 573                 if (TCP_IPV4_TW_MATCH(sk2, acookie, saddr, daddr, ports, dif)) {
 574                         struct tcp_sock *tp = tcp_sk(sk);
 575
 576                         /* With PAWS, it is safe from the viewpoint
 577                            of data integrity. Even without PAWS it
 578                            is safe provided sequence spaces do not
 579                            overlap i.e. at data rates <= 80Mbit/sec.
 580
 581                            Actually, the idea is close to VJ's one,
 582                            only timestamp cache is held not per host,
 583                            but per port pair and TW bucket is used
 584                            as state holder.
 585
 586                            If TW bucket has been already destroyed we
 587                            fall back to VJ's scheme and use initial
 588                            timestamp retrieved from peer table.
 589                          */
 590                         if (tw->tw_ts_recent_stamp &&
 591                             (!twp || (sysctl_tcp_tw_reuse &&
 592                                       xtime.tv_sec -
 593                                       tw->tw_ts_recent_stamp > 1))) {
 594                                 if ((tp->write_seq =
 595                                                 tw->tw_snd_nxt + 65535 + 2) == 0)
 596                                         tp->write_seq = 1;
 597                                 tp->rx_opt.ts_recent       = tw->tw_ts_recent;
 598                                 tp->rx_opt.ts_recent_stamp = tw->tw_ts_recent_stamp;
 599                                 sock_hold(sk2);
 600                                 goto unique;
 601                         } else
 602                                 goto not_unique;
 603                 }
 604         }
 605         tw = NULL;
 606
 607         /* And established part... */
 608         sk_for_each(sk2, node, &head->chain) {
 609                 if (TCP_IPV4_MATCH(sk2, acookie, saddr, daddr, ports, dif))
 610                         goto not_unique;
 611         }
 612
 613 unique:
 614         /* Must record num and sport now. Otherwise we will see
 615          * in hash table socket with a funny identity. */
 616         inet->num = lport;
 617         inet->sport = htons(lport);
 618         sk->sk_hashent = hash;
 619         BUG_TRAP(sk_unhashed(sk));
 620         __sk_add_node(sk, &head->chain);
 621         sock_prot_inc_use(sk->sk_prot);
 622         write_unlock(&head->lock);
 623
 624         if (twp) {
 625                 *twp = tw;
 626                 NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED);
 627         } else if (tw) {
 628                 /* Silly. Should hash-dance instead... */
 629                 tcp_tw_deschedule(tw);
 630                 NET_INC_STATS_BH(LINUX_MIB_TIMEWAITRECYCLED);
 631
 632                 tcp_tw_put(tw);
 633         }
 634
 635         return 0;
 636
 637 not_unique:
 638         write_unlock(&head->lock);
 639         return -EADDRNOTAVAIL;
 640 }
 641
 642 static inline u32 connect_port_offset(const struct sock *sk)
 643 {
 644         const struct inet_sock *inet = inet_sk(sk);
 645
 646         return secure_tcp_port_ephemeral(inet->rcv_saddr, inet->daddr,
 647                                          inet->dport);
 648 }
 649
 650 /*
 651  * Bind a port for a connect operation and hash it.
 652  */
 653 static inline int tcp_v4_hash_connect(struct sock *sk)
 654 {
 655         unsigned short snum = inet_sk(sk)->num;
 656         struct tcp_bind_hashbucket *head;
 657         struct tcp_bind_bucket *tb;
 658         int ret;
 659
 660         if (!snum) {
 661                 int low = sysctl_local_port_range[0];
 662                 int high = sysctl_local_port_range[1];
 663                 int range = high - low;
 664                 int i;
 665                 int port;
 666                 static u32 hint;
 667                 u32 offset = hint + connect_port_offset(sk);
 668                 struct hlist_node *node;
 669                 struct tcp_tw_bucket *tw = NULL;
 670
 671                 local_bh_disable();
 672                 for (i = 1; i <= range; i++) {
 673                         port = low + (i + offset) % range;
 674                         head = &tcp_bhash[tcp_bhashfn(port)];
 675                         spin_lock(&head->lock);
 676
 677                         /* Does not bother with rcv_saddr checks,
 678                          * because the established check is already
 679                          * unique enough.
 680                          */
 681                         tb_for_each(tb, node, &head->chain) {
 682                                 if (tb->port == port) {
 683                                         BUG_TRAP(!hlist_empty(&tb->owners));
 684                                         if (tb->fastreuse >= 0)
 685                                                 goto next_port;
 686                                         if (!__tcp_v4_check_established(sk,
 687                                                                         port,
 688                                                                         &tw))
 689                                                 goto ok;
 690                                         goto next_port;
 691                                 }
 692                         }
 693
 694                         tb = tcp_bucket_create(head, port);
 695                         if (!tb) {
 696                                 spin_unlock(&head->lock);
 697                                 break;
 698                         }
 699                         tb->fastreuse = -1;
 700                         goto ok;
 701
 702                 next_port:
 703                         spin_unlock(&head->lock);
 704                 }
 705                 local_bh_enable();
 706
 707                 return -EADDRNOTAVAIL;
 708
 709 ok:
 710                 hint += i;
 711
 712                 /* Head lock still held and bh's disabled */
 713                 tcp_bind_hash(sk, tb, port);
 714                 if (sk_unhashed(sk)) {
 715                         inet_sk(sk)->sport = htons(port);
 716                         __tcp_v4_hash(sk, 0);
 717                 }
 718                 spin_unlock(&head->lock);
 719
 720                 if (tw) {
 721                         tcp_tw_deschedule(tw);
 722                         tcp_tw_put(tw);
 723                 }
 724
 725                 ret = 0;
 726                 goto out;
 727         }
 728
 729         head  = &tcp_bhash[tcp_bhashfn(snum)];
 730         tb  = tcp_sk(sk)->bind_hash;
 731         spin_lock_bh(&head->lock);
 732         if (sk_head(&tb->owners) == sk && !sk->sk_bind_node.next) {
 733                 __tcp_v4_hash(sk, 0);
 734                 spin_unlock_bh(&head->lock);
 735                 return 0;
 736         } else {
 737                 spin_unlock(&head->lock);
 738                 /* No definite answer... Walk to established hash table */
 739                 ret = __tcp_v4_check_established(sk, snum, NULL);
 740 out:
 741                 local_bh_enable();
 742                 return ret;
 743         }
 744 }
 745
 746 /* This will initiate an outgoing connection. */
 747 int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
 748 {
 749         struct inet_sock *inet = inet_sk(sk);
 750         struct tcp_sock *tp = tcp_sk(sk);
 751         struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
 752         struct rtable *rt;
 753         u32 daddr, nexthop;
 754         int tmp;
 755         int err;
 756
 757         if (addr_len < sizeof(struct sockaddr_in))
 758                 return -EINVAL;
 759
 760         if (usin->sin_family != AF_INET)
 761                 return -EAFNOSUPPORT;
 762
 763         nexthop = daddr = usin->sin_addr.s_addr;
 764         if (inet->opt && inet->opt->srr) {
 765                 if (!daddr)
 766                         return -EINVAL;
 767                 nexthop = inet->opt->faddr;
 768         }
 769
 770         tmp = ip_route_connect(&rt, nexthop, inet->saddr,
 771                                RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
 772                                IPPROTO_TCP,
 773                                inet->sport, usin->sin_port, sk);
 774         if (tmp < 0)
 775                 return tmp;
 776
 777         if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
 778                 ip_rt_put(rt);
 779                 return -ENETUNREACH;
 780         }
 781
 782         if (!inet->opt || !inet->opt->srr)
 783                 daddr = rt->rt_dst;
 784
 785         if (!inet->saddr)
 786                 inet->saddr = rt->rt_src;
 787         inet->rcv_saddr = inet->saddr;
 788
 789         if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) {
 790                 /* Reset inherited state */
 791                 tp->rx_opt.ts_recent       = 0;
 792                 tp->rx_opt.ts_recent_stamp = 0;
 793                 tp->write_seq              = 0;
 794         }
 795
 796         if (sysctl_tcp_tw_recycle &&
 797             !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
 798                 struct inet_peer *peer = rt_get_peer(rt);
 799
 800                 /* VJ's idea. We save last timestamp seen from
 801                  * the destination in peer table, when entering state TIME-WAIT
 802                  * and initialize rx_opt.ts_recent from it, when trying new connection.
 803                  */
 804
 805                 if (peer && peer->tcp_ts_stamp + TCP_PAWS_MSL >= xtime.tv_sec) {
 806                         tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
 807                         tp->rx_opt.ts_recent = peer->tcp_ts;
 808                 }
 809         }
 810
 811         inet->dport = usin->sin_port;
 812         inet->daddr = daddr;
 813
 814         tp->ext_header_len = 0;
 815         if (inet->opt)
 816                 tp->ext_header_len = inet->opt->optlen;
 817
 818         tp->rx_opt.mss_clamp = 536;
 819
 820         /* Socket identity is still unknown (sport may be zero).
 821          * However we set state to SYN-SENT and not releasing socket
 822          * lock select source port, enter ourselves into the hash tables and
 823          * complete initialization after this.
 824          */
 825         tcp_set_state(sk, TCP_SYN_SENT);
 826         err = tcp_v4_hash_connect(sk);
 827         if (err)
 828                 goto failure;
 829
 830         err = ip_route_newports(&rt, inet->sport, inet->dport, sk);
 831         if (err)
 832                 goto failure;
 833
 834         /* OK, now commit destination to socket.  */
 835         __sk_dst_set(sk, &rt->u.dst);
 836         tcp_v4_setup_caps(sk, &rt->u.dst);
 837
 838         if (!tp->write_seq)
 839                 tp->write_seq = secure_tcp_sequence_number(inet->saddr,
 840                                                            inet->daddr,
 841                                                            inet->sport,
 842                                                            usin->sin_port);
 843
 844         inet->id = tp->write_seq ^ jiffies;
 845
 846         err = tcp_connect(sk);
 847         rt = NULL;
 848         if (err)
 849                 goto failure;
 850
 851         return 0;
 852
 853 failure:
 854         /* This unhashes the socket and releases the local port, if necessary. */
 855         tcp_set_state(sk, TCP_CLOSE);
 856         ip_rt_put(rt);
 857         sk->sk_route_caps = 0;
 858         inet->dport = 0;
 859         return err;
 860 }
 861
 862 static __inline__ int tcp_v4_iif(struct sk_buff *skb)
 863 {
 864         return ((struct rtable *)skb->dst)->rt_iif;
 865 }
 866
 867 static __inline__ u32 tcp_v4_synq_hash(u32 raddr, u16 rport, u32 rnd)
 868 {
 869         return (jhash_2words(raddr, (u32) rport, rnd) & (TCP_SYNQ_HSIZE - 1));
 870 }
 871
 872 static struct open_request *tcp_v4_search_req(struct tcp_sock *tp,
 873                                               struct open_request ***prevp,
 874                                               __u16 rport,
 875                                               __u32 raddr, __u32 laddr)
 876 {
 877         struct tcp_listen_opt *lopt = tp->listen_opt;
 878         struct open_request *req, **prev;
 879
 880         for (prev = &lopt->syn_table[tcp_v4_synq_hash(raddr, rport, lopt->hash_rnd)];
 881              (req = *prev) != NULL;
 882              prev = &req->dl_next) {
 883                 if (req->rmt_port == rport &&
 884                     req->af.v4_req.rmt_addr == raddr &&
 885                     req->af.v4_req.loc_addr == laddr &&
 886                     TCP_INET_FAMILY(req->class->family)) {
 887                         BUG_TRAP(!req->sk);
 888                         *prevp = prev;
 889                         break;
 890                 }
 891         }
 892
 893         return req;
 894 }
 895
 896 static void tcp_v4_synq_add(struct sock *sk, struct open_request *req)
 897 {
 898         struct tcp_sock *tp = tcp_sk(sk);
 899         struct tcp_listen_opt *lopt = tp->listen_opt;
 900         u32 h = tcp_v4_synq_hash(req->af.v4_req.rmt_addr, req->rmt_port, lopt->hash_rnd);
 901
 902         req->expires = jiffies + TCP_TIMEOUT_INIT;
 903         req->retrans = 0;
 904         req->sk = NULL;
 905         req->dl_next = lopt->syn_table[h];
 906
 907         write_lock(&tp->syn_wait_lock);
 908         lopt->syn_table[h] = req;
 909         write_unlock(&tp->syn_wait_lock);
 910
 911         tcp_synq_added(sk);
 912 }
 913
 914
 915 /*
 916  * This routine does path mtu discovery as defined in RFC1191.
 917  */
 918 static inline void do_pmtu_discovery(struct sock *sk, struct iphdr *iph,
 919                                      u32 mtu)
 920 {
 921         struct dst_entry *dst;
 922         struct inet_sock *inet = inet_sk(sk);
 923         struct tcp_sock *tp = tcp_sk(sk);
 924
 925         /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
 926          * send out by Linux are always <576bytes so they should go through
 927          * unfragmented).
 928          */
 929         if (sk->sk_state == TCP_LISTEN)
 930                 return;
 931
 932         /* We don't check in the destentry if pmtu discovery is forbidden
 933          * on this route. We just assume that no packet_to_big packets
 934          * are send back when pmtu discovery is not active.
 935          * There is a small race when the user changes this flag in the
 936          * route, but I think that's acceptable.
 937          */
 938         if ((dst = __sk_dst_check(sk, 0)) == NULL)
 939                 return;
 940
 941         dst->ops->update_pmtu(dst, mtu);
 942
 943         /* Something is about to be wrong... Remember soft error
 944          * for the case, if this connection will not able to recover.
 945          */
 946         if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
 947                 sk->sk_err_soft = EMSGSIZE;
 948
 949         mtu = dst_mtu(dst);
 950
 951         if (inet->pmtudisc != IP_PMTUDISC_DONT &&
 952             tp->pmtu_cookie > mtu) {
 953                 tcp_sync_mss(sk, mtu);
 954
 955                 /* Resend the TCP packet because it's
 956                  * clear that the old packet has been
 957                  * dropped. This is the new "fast" path mtu
 958                  * discovery.
 959                  */
 960                 tcp_simple_retransmit(sk);
 961         } /* else let the usual retransmit timer handle it */
 962 }
 963
 964 /*
 965  * This routine is called by the ICMP module when it gets some
 966  * sort of error condition.  If err < 0 then the socket should
 967  * be closed and the error returned to the user.  If err > 0
 968  * it's just the icmp type << 8 | icmp code.  After adjustment
 969  * header points to the first 8 bytes of the tcp header.  We need
 970  * to find the appropriate port.
 971  *
 972  * The locking strategy used here is very "optimistic". When
 973  * someone else accesses the socket the ICMP is just dropped
 974  * and for some paths there is no check at all.
 975  * A more general error queue to queue errors for later handling
 976  * is probably better.
 977  *
 978  */
 979
 980 void tcp_v4_err(struct sk_buff *skb, u32 info)
 981 {
 982         struct iphdr *iph = (struct iphdr *)skb->data;
 983         struct tcphdr *th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
 984         struct tcp_sock *tp;
 985         struct inet_sock *inet;
 986         int type = skb->h.icmph->type;
 987         int code = skb->h.icmph->code;
 988         struct sock *sk;
 989         __u32 seq;
 990         int err;
 991
 992         if (skb->len < (iph->ihl << 2) + 8) {
 993                 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
 994                 return;
 995         }
 996
 997         sk = tcp_v4_lookup(iph->daddr, th->dest, iph->saddr,
 998                            th->source, tcp_v4_iif(skb));
 999         if (!sk) {
1000                 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
1001                 return;
1002         }
1003         if (sk->sk_state == TCP_TIME_WAIT) {
1004                 tcp_tw_put((struct tcp_tw_bucket *)sk);
1005                 return;
1006         }
1007
1008         bh_lock_sock(sk);
1009         /* If too many ICMPs get dropped on busy
1010          * servers this needs to be solved differently.
1011          */
1012         if (sock_owned_by_user(sk))
1013                 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
1014
1015         if (sk->sk_state == TCP_CLOSE)
1016                 goto out;
1017
1018         tp = tcp_sk(sk);
1019         seq = ntohl(th->seq);
1020         if (sk->sk_state != TCP_LISTEN &&
1021             !between(seq, tp->snd_una, tp->snd_nxt)) {
1022                 NET_INC_STATS(LINUX_MIB_OUTOFWINDOWICMPS);
1023                 goto out;
1024         }
1025
1026         switch (type) {
1027         case ICMP_SOURCE_QUENCH:
1028                 /* Just silently ignore these. */
1029                 goto out;
1030         case ICMP_PARAMETERPROB:
1031                 err = EPROTO;
1032                 break;
1033         case ICMP_DEST_UNREACH:
1034                 if (code > NR_ICMP_UNREACH)
1035                         goto out;
1036
1037                 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
1038                         if (!sock_owned_by_user(sk))
1039                                 do_pmtu_discovery(sk, iph, info);
1040                         goto out;
1041                 }
1042
1043                 err = icmp_err_convert[code].errno;
1044                 break;
1045         case ICMP_TIME_EXCEEDED:
1046                 err = EHOSTUNREACH;
1047                 break;
1048         default:
1049                 goto out;
1050         }
1051
1052         switch (sk->sk_state) {
1053                 struct open_request *req, **prev;
1054         case TCP_LISTEN:
1055                 if (sock_owned_by_user(sk))
1056                         goto out;
1057
1058                 req = tcp_v4_search_req(tp, &prev, th->dest,
1059                                         iph->daddr, iph->saddr);
1060                 if (!req)
1061                         goto out;
1062
1063                 /* ICMPs are not backlogged, hence we cannot get
1064                    an established socket here.
1065                  */
1066                 BUG_TRAP(!req->sk);
1067
1068                 if (seq != req->snt_isn) {
1069                         NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
1070                         goto out;
1071                 }
1072
1073                 /*
1074                  * Still in SYN_RECV, just remove it silently.
1075                  * There is no good way to pass the error to the newly
1076                  * created socket, and POSIX does not want network
1077                  * errors returned from accept().
1078                  */
1079                 tcp_synq_drop(sk, req, prev);
1080                 goto out;
1081
1082         case TCP_SYN_SENT:
1083         case TCP_SYN_RECV:  /* Cannot happen.
1084                                It can f.e. if SYNs crossed.
1085                              */
1086                 if (!sock_owned_by_user(sk)) {
1087                         TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
1088                         sk->sk_err = err;
1089
1090                         sk->sk_error_report(sk);
1091
1092                         tcp_done(sk);
1093                 } else {
1094                         sk->sk_err_soft = err;
1095                 }
1096                 goto out;
1097         }
1098
1099         /* If we've already connected we will keep trying
1100          * until we time out, or the user gives up.
1101          *
1102          * rfc1122 4.2.3.9 allows to consider as hard errors
1103          * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
1104          * but it is obsoleted by pmtu discovery).
1105          *
1106          * Note, that in modern internet, where routing is unreliable
1107          * and in each dark corner broken firewalls sit, sending random
1108          * errors ordered by their masters even this two messages finally lose
1109          * their original sense (even Linux sends invalid PORT_UNREACHs)
1110          *
1111          * Now we are in compliance with RFCs.
1112          *                                                      --ANK (980905)
1113          */
1114
1115         inet = inet_sk(sk);
1116         if (!sock_owned_by_user(sk) && inet->recverr) {
1117                 sk->sk_err = err;
1118                 sk->sk_error_report(sk);
1119         } else  { /* Only an error on timeout */
1120                 sk->sk_err_soft = err;
1121         }
1122
1123 out:
1124         bh_unlock_sock(sk);
1125         sock_put(sk);
1126 }
1127
1128 /* This routine computes an IPv4 TCP checksum. */
1129 void tcp_v4_send_check(struct sock *sk, struct tcphdr *th, int len,
1130                        struct sk_buff *skb)
1131 {
1132         struct inet_sock *inet = inet_sk(sk);
1133
1134         if (skb->ip_summed == CHECKSUM_HW) {
1135                 th->check = ~tcp_v4_check(th, len, inet->saddr, inet->daddr, 0);
1136                 skb->csum = offsetof(struct tcphdr, check);
1137         } else {
1138                 th->check = tcp_v4_check(th, len, inet->saddr, inet->daddr,
1139                                          csum_partial((char *)th,
1140                                                       th->doff << 2,
1141                                                       skb->csum));
1142         }
1143 }
1144
1145 /*
1146  *      This routine will send an RST to the other tcp.
1147  *
1148  *      Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
1149  *                    for reset.
1150  *      Answer: if a packet caused RST, it is not for a socket
1151  *              existing in our system, if it is matched to a socket,
1152  *              it is just duplicate segment or bug in other side's TCP.
1153  *              So that we build reply only basing on parameters
1154  *              arrived with segment.
1155  *      Exception: precedence violation. We do not implement it in any case.
1156  */
1157
1158 static void tcp_v4_send_reset(struct sk_buff *skb)
1159 {
1160         struct tcphdr *th = skb->h.th;
1161         struct tcphdr rth;
1162         struct ip_reply_arg arg;
1163
1164         /* Never send a reset in response to a reset. */
1165         if (th->rst)
1166                 return;
1167
1168         if (((struct rtable *)skb->dst)->rt_type != RTN_LOCAL)
1169                 return;
1170
1171         /* Swap the send and the receive. */
1172         memset(&rth, 0, sizeof(struct tcphdr));
1173         rth.dest   = th->source;
1174         rth.source = th->dest;
1175         rth.doff   = sizeof(struct tcphdr) / 4;
1176         rth.rst    = 1;
1177
1178         if (th->ack) {
1179                 rth.seq = th->ack_seq;
1180         } else {
1181                 rth.ack = 1;
1182                 rth.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
1183                                     skb->len - (th->doff << 2));
1184         }
1185
1186         memset(&arg, 0, sizeof arg);
1187         arg.iov[0].iov_base = (unsigned char *)&rth;
1188         arg.iov[0].iov_len  = sizeof rth;
1189         arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
1190                                       skb->nh.iph->saddr, /*XXX*/
1191                                       sizeof(struct tcphdr), IPPROTO_TCP, 0);
1192         arg.csumoffset = offsetof(struct tcphdr, check) / 2;
1193
1194         ip_send_reply(tcp_socket->sk, skb, &arg, sizeof rth);
1195
1196         TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
1197         TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
1198 }
1199
1200 /* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
1201    outside socket context is ugly, certainly. What can I do?
1202  */
1203
1204 static void tcp_v4_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
1205                             u32 win, u32 ts)
1206 {
1207         struct tcphdr *th = skb->h.th;
1208         struct {
1209                 struct tcphdr th;
1210                 u32 tsopt[3];
1211         } rep;
1212         struct ip_reply_arg arg;
1213
1214         memset(&rep.th, 0, sizeof(struct tcphdr));
1215         memset(&arg, 0, sizeof arg);
1216
1217         arg.iov[0].iov_base = (unsigned char *)&rep;
1218         arg.iov[0].iov_len  = sizeof(rep.th);
1219         if (ts) {
1220                 rep.tsopt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1221                                      (TCPOPT_TIMESTAMP << 8) |
1222                                      TCPOLEN_TIMESTAMP);
1223                 rep.tsopt[1] = htonl(tcp_time_stamp);
1224                 rep.tsopt[2] = htonl(ts);
1225                 arg.iov[0].iov_len = sizeof(rep);
1226         }
1227
1228         /* Swap the send and the receive. */
1229         rep.th.dest    = th->source;
1230         rep.th.source  = th->dest;
1231         rep.th.doff    = arg.iov[0].iov_len / 4;
1232         rep.th.seq     = htonl(seq);
1233         rep.th.ack_seq = htonl(ack);
1234         rep.th.ack     = 1;
1235         rep.th.window  = htons(win);
1236
1237         arg.csum = csum_tcpudp_nofold(skb->nh.iph->daddr,
1238                                       skb->nh.iph->saddr, /*XXX*/
1239                                       arg.iov[0].iov_len, IPPROTO_TCP, 0);
1240         arg.csumoffset = offsetof(struct tcphdr, check) / 2;
1241
1242         ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len);
1243
1244         TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
1245 }
1246
1247 static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
1248 {
1249         struct tcp_tw_bucket *tw = (struct tcp_tw_bucket *)sk;
1250
1251         tcp_v4_send_ack(skb, tw->tw_snd_nxt, tw->tw_rcv_nxt,
1252                         tw->tw_rcv_wnd >> tw->tw_rcv_wscale, tw->tw_ts_recent);
1253
1254         tcp_tw_put(tw);
1255 }
1256
1257 static void tcp_v4_or_send_ack(struct sk_buff *skb, struct open_request *req)
1258 {
1259         tcp_v4_send_ack(skb, req->snt_isn + 1, req->rcv_isn + 1, req->rcv_wnd,
1260                         req->ts_recent);
1261 }
1262
1263 static struct dst_entry* tcp_v4_route_req(struct sock *sk,
1264                                           struct open_request *req)
1265 {
1266         struct rtable *rt;
1267         struct ip_options *opt = req->af.v4_req.opt;
1268         struct flowi fl = { .oif = sk->sk_bound_dev_if,
1269                             .nl_u = { .ip4_u =
1270                                       { .daddr = ((opt && opt->srr) ?
1271                                                   opt->faddr :
1272                                                   req->af.v4_req.rmt_addr),
1273                                         .saddr = req->af.v4_req.loc_addr,
1274                                         .tos = RT_CONN_FLAGS(sk) } },
1275                             .proto = IPPROTO_TCP,
1276                             .uli_u = { .ports =
1277                                        { .sport = inet_sk(sk)->sport,
1278                                          .dport = req->rmt_port } } };
1279
1280         if (ip_route_output_flow(&rt, &fl, sk, 0)) {
1281                 IP_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES);
1282                 return NULL;
1283         }
1284         if (opt && opt->is_strictroute && rt->rt_dst != rt->rt_gateway) {
1285                 ip_rt_put(rt);
1286                 IP_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES);
1287                 return NULL;
1288         }
1289         return &rt->u.dst;
1290 }
1291
1292 /*
1293  *      Send a SYN-ACK after having received an ACK.
1294  *      This still operates on a open_request only, not on a big
1295  *      socket.
1296  */
1297 static int tcp_v4_send_synack(struct sock *sk, struct open_request *req,
1298                               struct dst_entry *dst)
1299 {
1300         int err = -1;
1301         struct sk_buff * skb;
1302
1303         /* First, grab a route. */
1304         if (!dst && (dst = tcp_v4_route_req(sk, req)) == NULL)
1305                 goto out;
1306
1307         skb = tcp_make_synack(sk, dst, req);
1308
1309         if (skb) {
1310                 struct tcphdr *th = skb->h.th;
1311
1312                 th->check = tcp_v4_check(th, skb->len,
1313                                          req->af.v4_req.loc_addr,
1314                                          req->af.v4_req.rmt_addr,
1315                                          csum_partial((char *)th, skb->len,
1316                                                       skb->csum));
1317
1318                 err = ip_build_and_send_pkt(skb, sk, req->af.v4_req.loc_addr,
1319                                             req->af.v4_req.rmt_addr,
1320                                             req->af.v4_req.opt);
1321                 if (err == NET_XMIT_CN)
1322                         err = 0;
1323         }
1324
1325 out:
1326         dst_release(dst);
1327         return err;
1328 }
1329
1330 /*
1331  *      IPv4 open_request destructor.
1332  */
1333 static void tcp_v4_or_free(struct open_request *req)
1334 {
1335         if (req->af.v4_req.opt)
1336                 kfree(req->af.v4_req.opt);
1337 }
1338
1339 static inline void syn_flood_warning(struct sk_buff *skb)
1340 {
1341         static unsigned long warntime;
1342
1343         if (time_after(jiffies, (warntime + HZ * 60))) {
1344                 warntime = jiffies;
1345                 printk(KERN_INFO
1346                        "possible SYN flooding on port %d. Sending cookies.\n",
1347                        ntohs(skb->h.th->dest));
1348         }
1349 }
1350
1351 /*
1352  * Save and compile IPv4 options into the open_request if needed.
1353  */
1354 static inline struct ip_options *tcp_v4_save_options(struct sock *sk,
1355                                                      struct sk_buff *skb)
1356 {
1357         struct ip_options *opt = &(IPCB(skb)->opt);
1358         struct ip_options *dopt = NULL;
1359
1360         if (opt && opt->optlen) {
1361                 int opt_size = optlength(opt);
1362                 dopt = kmalloc(opt_size, GFP_ATOMIC);
1363                 if (dopt) {
1364                         if (ip_options_echo(dopt, skb)) {
1365                                 kfree(dopt);
1366                                 dopt = NULL;
1367                         }
1368                 }
1369         }
1370         return dopt;
1371 }
1372
1373 /*
1374  * Maximum number of SYN_RECV sockets in queue per LISTEN socket.
1375  * One SYN_RECV socket costs about 80bytes on a 32bit machine.
1376  * It would be better to replace it with a global counter for all sockets
1377  * but then some measure against one socket starving all other sockets
1378  * would be needed.
1379  *
1380  * It was 128 by default. Experiments with real servers show, that
1381  * it is absolutely not enough even at 100conn/sec. 256 cures most
1382  * of problems. This value is adjusted to 128 for very small machines
1383  * (<=32Mb of memory) and to 1024 on normal or better ones (>=256Mb).
1384  * Further increasing requires to change hash table size.
1385  */
1386 int sysctl_max_syn_backlog = 256;
1387
1388 struct or_calltable or_ipv4 = {
1389         .family         =       PF_INET,
1390         .rtx_syn_ack    =       tcp_v4_send_synack,
1391         .send_ack       =       tcp_v4_or_send_ack,
1392         .destructor     =       tcp_v4_or_free,
1393         .send_reset     =       tcp_v4_send_reset,
1394 };
1395
1396 int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1397 {
1398         struct tcp_options_received tmp_opt;
1399         struct open_request *req;
1400         __u32 saddr = skb->nh.iph->saddr;
1401         __u32 daddr = skb->nh.iph->daddr;
1402         __u32 isn = TCP_SKB_CB(skb)->when;
1403         struct dst_entry *dst = NULL;
1404 #ifdef CONFIG_SYN_COOKIES
1405         int want_cookie = 0;
1406 #else
1407 #define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
1408 #endif
1409
1410         /* Never answer to SYNs send to broadcast or multicast */
1411         if (((struct rtable *)skb->dst)->rt_flags &
1412             (RTCF_BROADCAST | RTCF_MULTICAST))
1413                 goto drop;
1414
1415         /* TW buckets are converted to open requests without
1416          * limitations, they conserve resources and peer is
1417          * evidently real one.
1418          */
1419         if (tcp_synq_is_full(sk) && !isn) {
1420 #ifdef CONFIG_SYN_COOKIES
1421                 if (sysctl_tcp_syncookies) {
1422                         want_cookie = 1;
1423                 } else
1424 #endif
1425                 goto drop;
1426         }
1427
1428         /* Accept backlog is full. If we have already queued enough
1429          * of warm entries in syn queue, drop request. It is better than
1430          * clogging syn queue with openreqs with exponentially increasing
1431          * timeout.
1432          */
1433         if (sk_acceptq_is_full(sk) && tcp_synq_young(sk) > 1)
1434                 goto drop;
1435
1436         req = tcp_openreq_alloc();
1437         if (!req)
1438                 goto drop;
1439
1440         tcp_clear_options(&tmp_opt);
1441         tmp_opt.mss_clamp = 536;
1442         tmp_opt.user_mss  = tcp_sk(sk)->rx_opt.user_mss;
1443
1444         tcp_parse_options(skb, &tmp_opt, 0);
1445
1446         if (want_cookie) {
1447                 tcp_clear_options(&tmp_opt);
1448                 tmp_opt.saw_tstamp = 0;
1449         }
1450
1451         if (tmp_opt.saw_tstamp && !tmp_opt.rcv_tsval) {
1452                 /* Some OSes (unknown ones, but I see them on web server, which
1453                  * contains information interesting only for windows'
1454                  * users) do not send their stamp in SYN. It is easy case.
1455                  * We simply do not advertise TS support.
1456                  */
1457                 tmp_opt.saw_tstamp = 0;
1458                 tmp_opt.tstamp_ok  = 0;
1459         }
1460         tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1461
1462         tcp_openreq_init(req, &tmp_opt, skb);
1463
1464         req->af.v4_req.loc_addr = daddr;
1465         req->af.v4_req.rmt_addr = saddr;
1466         req->af.v4_req.opt = tcp_v4_save_options(sk, skb);
1467         req->class = &or_ipv4;
1468         if (!want_cookie)
1469                 TCP_ECN_create_request(req, skb->h.th);
1470
1471         if (want_cookie) {
1472 #ifdef CONFIG_SYN_COOKIES
1473                 syn_flood_warning(skb);
1474 #endif
1475                 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
1476         } else if (!isn) {
1477                 struct inet_peer *peer = NULL;
1478
1479                 /* VJ's idea. We save last timestamp seen
1480                  * from the destination in peer table, when entering
1481                  * state TIME-WAIT, and check against it before
1482                  * accepting new connection request.
1483                  *
1484                  * If "isn" is not zero, this request hit alive
1485                  * timewait bucket, so that all the necessary checks
1486                  * are made in the function processing timewait state.
1487                  */
1488                 if (tmp_opt.saw_tstamp &&
1489                     sysctl_tcp_tw_recycle &&
1490                     (dst = tcp_v4_route_req(sk, req)) != NULL &&
1491                     (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
1492                     peer->v4daddr == saddr) {
1493                         if (xtime.tv_sec < peer->tcp_ts_stamp + TCP_PAWS_MSL &&
1494                             (s32)(peer->tcp_ts - req->ts_recent) >
1495                                                         TCP_PAWS_WINDOW) {
1496                                 NET_INC_STATS_BH(LINUX_MIB_PAWSPASSIVEREJECTED);
1497                                 dst_release(dst);
1498                                 goto drop_and_free;
1499                         }
1500                 }
1501                 /* Kill the following clause, if you dislike this way. */
1502                 else if (!sysctl_tcp_syncookies &&
1503                          (sysctl_max_syn_backlog - tcp_synq_len(sk) <
1504                           (sysctl_max_syn_backlog >> 2)) &&
1505                          (!peer || !peer->tcp_ts_stamp) &&
1506                          (!dst || !dst_metric(dst, RTAX_RTT))) {
1507                         /* Without syncookies last quarter of
1508                          * backlog is filled with destinations,
1509                          * proven to be alive.
1510                          * It means that we continue to communicate
1511                          * to destinations, already remembered
1512                          * to the moment of synflood.
1513                          */
1514                         NETDEBUG(if (net_ratelimit()) \
1515                                         printk(KERN_DEBUG "TCP: drop open "
1516                                                           "request from %u.%u."
1517                                                           "%u.%u/%u\n", \
1518                                                NIPQUAD(saddr),
1519                                                ntohs(skb->h.th->source)));
1520                         dst_release(dst);
1521                         goto drop_and_free;
1522                 }
1523
1524                 isn = tcp_v4_init_sequence(sk, skb);
1525         }
1526         req->snt_isn = isn;
1527
1528         if (tcp_v4_send_synack(sk, req, dst))
1529                 goto drop_and_free;
1530
1531         if (want_cookie) {
1532                 tcp_openreq_free(req);
1533         } else {
1534                 tcp_v4_synq_add(sk, req);
1535         }
1536         return 0;
1537
1538 drop_and_free:
1539         tcp_openreq_free(req);
1540 drop:
1541         TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
1542         return 0;
1543 }
1544
1545
1546 /*
1547  * The three way handshake has completed - we got a valid synack -
1548  * now create the new socket.
1549  */
1550 struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1551                                   struct open_request *req,
1552                                   struct dst_entry *dst)
1553 {
1554         struct inet_sock *newinet;
1555         struct tcp_sock *newtp;
1556         struct sock *newsk;
1557
1558         if (sk_acceptq_is_full(sk))
1559                 goto exit_overflow;
1560
1561         if (!dst && (dst = tcp_v4_route_req(sk, req)) == NULL)
1562                 goto exit;
1563
1564         newsk = tcp_create_openreq_child(sk, req, skb);
1565         if (!newsk)
1566                 goto exit;
1567
1568         newsk->sk_dst_cache = dst;
1569         tcp_v4_setup_caps(newsk, dst);
1570
1571         newtp                 = tcp_sk(newsk);
1572         newinet               = inet_sk(newsk);
1573         newinet->daddr        = req->af.v4_req.rmt_addr;
1574         newinet->rcv_saddr    = req->af.v4_req.loc_addr;
1575         newinet->saddr        = req->af.v4_req.loc_addr;
1576         newinet->opt          = req->af.v4_req.opt;
1577         req->af.v4_req.opt    = NULL;
1578         newinet->mc_index     = tcp_v4_iif(skb);
1579         newinet->mc_ttl       = skb->nh.iph->ttl;
1580         newtp->ext_header_len = 0;
1581         if (newinet->opt)
1582                 newtp->ext_header_len = newinet->opt->optlen;
1583         newinet->id = newtp->write_seq ^ jiffies;
1584
1585         tcp_sync_mss(newsk, dst_mtu(dst));
1586         newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
1587         tcp_initialize_rcv_mss(newsk);
1588
1589         __tcp_v4_hash(newsk, 0);
1590         __tcp_inherit_port(sk, newsk);
1591
1592         return newsk;
1593
1594 exit_overflow:
1595         NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
1596 exit:
1597         NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
1598         dst_release(dst);
1599         return NULL;
1600 }
1601
1602 static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1603 {
1604         struct tcphdr *th = skb->h.th;
1605         struct iphdr *iph = skb->nh.iph;
1606         struct tcp_sock *tp = tcp_sk(sk);
1607         struct sock *nsk;
1608         struct open_request **prev;
1609         /* Find possible connection requests. */
1610         struct open_request *req = tcp_v4_search_req(tp, &prev, th->source,
1611                                                      iph->saddr, iph->daddr);
1612         if (req)
1613                 return tcp_check_req(sk, skb, req, prev);
1614
1615         nsk = __tcp_v4_lookup_established(skb->nh.iph->saddr,
1616                                           th->source,
1617                                           skb->nh.iph->daddr,
1618                                           ntohs(th->dest),
1619                                           tcp_v4_iif(skb));
1620
1621         if (nsk) {
1622                 if (nsk->sk_state != TCP_TIME_WAIT) {
1623                         bh_lock_sock(nsk);
1624                         return nsk;
1625                 }
1626                 tcp_tw_put((struct tcp_tw_bucket *)nsk);
1627                 return NULL;
1628         }
1629
1630 #ifdef CONFIG_SYN_COOKIES
1631         if (!th->rst && !th->syn && th->ack)
1632                 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1633 #endif
1634         return sk;
1635 }
1636
1637 static int tcp_v4_checksum_init(struct sk_buff *skb)
1638 {
1639         if (skb->ip_summed == CHECKSUM_HW) {
1640                 skb->ip_summed = CHECKSUM_UNNECESSARY;
1641                 if (!tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
1642                                   skb->nh.iph->daddr, skb->csum))
1643                         return 0;
1644
1645                 NETDEBUG(if (net_ratelimit())
1646                                 printk(KERN_DEBUG "hw tcp v4 csum failed\n"));
1647                 skb->ip_summed = CHECKSUM_NONE;
1648         }
1649         if (skb->len <= 76) {
1650                 if (tcp_v4_check(skb->h.th, skb->len, skb->nh.iph->saddr,
1651                                  skb->nh.iph->daddr,
1652                                  skb_checksum(skb, 0, skb->len, 0)))
1653                         return -1;
1654                 skb->ip_summed = CHECKSUM_UNNECESSARY;
1655         } else {
1656                 skb->csum = ~tcp_v4_check(skb->h.th, skb->len,
1657                                           skb->nh.iph->saddr,
1658                                           skb->nh.iph->daddr, 0);
1659         }
1660         return 0;
1661 }
1662
1663
1664 /* The socket must have it's spinlock held when we get
1665  * here.
1666  *
1667  * We have a potential double-lock case here, so even when
1668  * doing backlog processing we use the BH locking scheme.
1669  * This is because we cannot sleep with the original spinlock
1670  * held.
1671  */
1672 int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1673 {
1674         if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1675                 TCP_CHECK_TIMER(sk);
1676                 if (tcp_rcv_established(sk, skb, skb->h.th, skb->len))
1677                         goto reset;
1678                 TCP_CHECK_TIMER(sk);
1679                 return 0;
1680         }
1681
1682         if (skb->len < (skb->h.th->doff << 2) || tcp_checksum_complete(skb))
1683                 goto csum_err;
1684
1685         if (sk->sk_state == TCP_LISTEN) {
1686                 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1687                 if (!nsk)
1688                         goto discard;
1689
1690                 if (nsk != sk) {
1691                         if (tcp_child_process(sk, nsk, skb))
1692                                 goto reset;
1693                         return 0;
1694                 }
1695         }
1696
1697         TCP_CHECK_TIMER(sk);
1698         if (tcp_rcv_state_process(sk, skb, skb->h.th, skb->len))
1699                 goto reset;
1700         TCP_CHECK_TIMER(sk);
1701         return 0;
1702
1703 reset:
1704         tcp_v4_send_reset(skb);
1705 discard:
1706         kfree_skb(skb);
1707         /* Be careful here. If this function gets more complicated and
1708          * gcc suffers from register pressure on the x86, sk (in %ebx)
1709          * might be destroyed here. This current version compiles correctly,
1710          * but you have been warned.
1711          */
1712         return 0;
1713
1714 csum_err:
1715         TCP_INC_STATS_BH(TCP_MIB_INERRS);
1716         goto discard;
1717 }
1718
1719 /*
1720  *      From tcp_input.c
1721  */
1722
1723 int tcp_v4_rcv(struct sk_buff *skb)
1724 {
1725         struct tcphdr *th;
1726         struct sock *sk;
1727         int ret;
1728
1729         if (skb->pkt_type != PACKET_HOST)
1730                 goto discard_it;
1731
1732         /* Count it even if it's bad */
1733         TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1734
1735         if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1736                 goto discard_it;
1737
1738         th = skb->h.th;
1739
1740         if (th->doff < sizeof(struct tcphdr) / 4)
1741                 goto bad_packet;
1742         if (!pskb_may_pull(skb, th->doff * 4))
1743                 goto discard_it;
1744
1745         /* An explanation is required here, I think.
1746          * Packet length and doff are validated by header prediction,
1747          * provided case of th->doff==0 is elimineted.
1748          * So, we defer the checks. */
1749         if ((skb->ip_summed != CHECKSUM_UNNECESSARY &&
1750              tcp_v4_checksum_init(skb) < 0))
1751                 goto bad_packet;
1752
1753         th = skb->h.th;
1754         TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1755         TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1756                                     skb->len - th->doff * 4);
1757         TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1758         TCP_SKB_CB(skb)->when    = 0;
1759         TCP_SKB_CB(skb)->flags   = skb->nh.iph->tos;
1760         TCP_SKB_CB(skb)->sacked  = 0;
1761
1762         sk = __tcp_v4_lookup(skb->nh.iph->saddr, th->source,
1763                              skb->nh.iph->daddr, ntohs(th->dest),
1764                              tcp_v4_iif(skb));
1765
1766         if (!sk)
1767                 goto no_tcp_socket;
1768
1769 process:
1770         if (sk->sk_state == TCP_TIME_WAIT)
1771                 goto do_time_wait;
1772
1773         if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1774                 goto discard_and_relse;
1775
1776         if (sk_filter(sk, skb, 0))
1777                 goto discard_and_relse;
1778
1779         skb->dev = NULL;
1780
1781         bh_lock_sock(sk);
1782         ret = 0;
1783         if (!sock_owned_by_user(sk)) {
1784                 if (!tcp_prequeue(sk, skb))
1785                         ret = tcp_v4_do_rcv(sk, skb);
1786         } else
1787                 sk_add_backlog(sk, skb);
1788         bh_unlock_sock(sk);
1789
1790         sock_put(sk);
1791
1792         return ret;
1793
1794 no_tcp_socket:
1795         if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1796                 goto discard_it;
1797
1798         if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1799 bad_packet:
1800                 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1801         } else {
1802                 tcp_v4_send_reset(skb);
1803         }
1804
1805 discard_it:
1806         /* Discard frame. */
1807         kfree_skb(skb);
1808         return 0;
1809
1810 discard_and_relse:
1811         sock_put(sk);
1812         goto discard_it;
1813
1814 do_time_wait:
1815         if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1816                 tcp_tw_put((struct tcp_tw_bucket *) sk);
1817                 goto discard_it;
1818         }
1819
1820         if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1821                 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1822                 tcp_tw_put((struct tcp_tw_bucket *) sk);
1823                 goto discard_it;
1824         }
1825         switch (tcp_timewait_state_process((struct tcp_tw_bucket *)sk,
1826                                            skb, th, skb->len)) {
1827         case TCP_TW_SYN: {
1828                 struct sock *sk2 = tcp_v4_lookup_listener(skb->nh.iph->daddr,
1829                                                           ntohs(th->dest),
1830                                                           tcp_v4_iif(skb));
1831                 if (sk2) {
1832                         tcp_tw_deschedule((struct tcp_tw_bucket *)sk);
1833                         tcp_tw_put((struct tcp_tw_bucket *)sk);
1834                         sk = sk2;
1835                         goto process;
1836                 }
1837                 /* Fall through to ACK */
1838         }
1839         case TCP_TW_ACK:
1840                 tcp_v4_timewait_ack(sk, skb);
1841                 break;
1842         case TCP_TW_RST:
1843                 goto no_tcp_socket;
1844         case TCP_TW_SUCCESS:;
1845         }
1846         goto discard_it;
1847 }
1848
1849 /* With per-bucket locks this operation is not-atomic, so that
1850  * this version is not worse.
1851  */
1852 static void __tcp_v4_rehash(struct sock *sk)
1853 {
1854         sk->sk_prot->unhash(sk);
1855         sk->sk_prot->hash(sk);
1856 }
1857
1858 static int tcp_v4_reselect_saddr(struct sock *sk)
1859 {
1860         struct inet_sock *inet = inet_sk(sk);
1861         int err;
1862         struct rtable *rt;
1863         __u32 old_saddr = inet->saddr;
1864         __u32 new_saddr;
1865         __u32 daddr = inet->daddr;
1866
1867         if (inet->opt && inet->opt->srr)
1868                 daddr = inet->opt->faddr;
1869
1870         /* Query new route. */
1871         err = ip_route_connect(&rt, daddr, 0,
1872                                RT_CONN_FLAGS(sk),
1873                                sk->sk_bound_dev_if,
1874                                IPPROTO_TCP,
1875                                inet->sport, inet->dport, sk);
1876         if (err)
1877                 return err;
1878
1879         __sk_dst_set(sk, &rt->u.dst);
1880         tcp_v4_setup_caps(sk, &rt->u.dst);
1881
1882         new_saddr = rt->rt_src;
1883
1884         if (new_saddr == old_saddr)
1885                 return 0;
1886
1887         if (sysctl_ip_dynaddr > 1) {
1888                 printk(KERN_INFO "tcp_v4_rebuild_header(): shifting inet->"
1889                                  "saddr from %d.%d.%d.%d to %d.%d.%d.%d\n",
1890                        NIPQUAD(old_saddr),
1891                        NIPQUAD(new_saddr));
1892         }
1893
1894         inet->saddr = new_saddr;
1895         inet->rcv_saddr = new_saddr;
1896
1897         /* XXX The only one ugly spot where we need to
1898          * XXX really change the sockets identity after
1899          * XXX it has entered the hashes. -DaveM
1900          *
1901          * Besides that, it does not check for connection
1902          * uniqueness. Wait for troubles.
1903          */
1904         __tcp_v4_rehash(sk);
1905         return 0;
1906 }
1907
1908 int tcp_v4_rebuild_header(struct sock *sk)
1909 {
1910         struct inet_sock *inet = inet_sk(sk);
1911         struct rtable *rt = (struct rtable *)__sk_dst_check(sk, 0);
1912         u32 daddr;
1913         int err;
1914
1915         /* Route is OK, nothing to do. */
1916         if (rt)
1917                 return 0;
1918
1919         /* Reroute. */
1920         daddr = inet->daddr;
1921         if (inet->opt && inet->opt->srr)
1922                 daddr = inet->opt->faddr;
1923
1924         {
1925                 struct flowi fl = { .oif = sk->sk_bound_dev_if,
1926                                     .nl_u = { .ip4_u =
1927                                               { .daddr = daddr,
1928                                                 .saddr = inet->saddr,
1929                                                 .tos = RT_CONN_FLAGS(sk) } },
1930                                     .proto = IPPROTO_TCP,
1931                                     .uli_u = { .ports =
1932                                                { .sport = inet->sport,
1933                                                  .dport = inet->dport } } };
1934
1935                 err = ip_route_output_flow(&rt, &fl, sk, 0);
1936         }
1937         if (!err) {
1938                 __sk_dst_set(sk, &rt->u.dst);
1939                 tcp_v4_setup_caps(sk, &rt->u.dst);
1940                 return 0;
1941         }
1942
1943         /* Routing failed... */
1944         sk->sk_route_caps = 0;
1945
1946         if (!sysctl_ip_dynaddr ||
1947             sk->sk_state != TCP_SYN_SENT ||
1948             (sk->sk_userlocks & SOCK_BINDADDR_LOCK) ||
1949             (err = tcp_v4_reselect_saddr(sk)) != 0)
1950                 sk->sk_err_soft = -err;
1951
1952         return err;
1953 }
1954
1955 static void v4_addr2sockaddr(struct sock *sk, struct sockaddr * uaddr)
1956 {
1957         struct sockaddr_in *sin = (struct sockaddr_in *) uaddr;
1958         struct inet_sock *inet = inet_sk(sk);
1959
1960         sin->sin_family         = AF_INET;
1961         sin->sin_addr.s_addr    = inet->daddr;
1962         sin->sin_port           = inet->dport;
1963 }
1964
1965 /* VJ's idea. Save last timestamp seen from this destination
1966  * and hold it at least for normal timewait interval to use for duplicate
1967  * segment detection in subsequent connections, before they enter synchronized
1968  * state.
1969  */
1970
1971 int tcp_v4_remember_stamp(struct sock *sk)
1972 {
1973         struct inet_sock *inet = inet_sk(sk);
1974         struct tcp_sock *tp = tcp_sk(sk);
1975         struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1976         struct inet_peer *peer = NULL;
1977         int release_it = 0;
1978
1979         if (!rt || rt->rt_dst != inet->daddr) {
1980                 peer = inet_getpeer(inet->daddr, 1);
1981                 release_it = 1;
1982         } else {
1983                 if (!rt->peer)
1984                         rt_bind_peer(rt, 1);
1985                 peer = rt->peer;
1986         }
1987
1988         if (peer) {
1989                 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
1990                     (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
1991                      peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {
1992                         peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;
1993                         peer->tcp_ts = tp->rx_opt.ts_recent;
1994                 }
1995                 if (release_it)
1996                         inet_putpeer(peer);
1997                 return 1;
1998         }
1999
2000         return 0;
2001 }
2002
2003 int tcp_v4_tw_remember_stamp(struct tcp_tw_bucket *tw)
2004 {
2005         struct inet_peer *peer = NULL;
2006
2007         peer = inet_getpeer(tw->tw_daddr, 1);
2008
2009         if (peer) {
2010                 if ((s32)(peer->tcp_ts - tw->tw_ts_recent) <= 0 ||
2011                     (peer->tcp_ts_stamp + TCP_PAWS_MSL < xtime.tv_sec &&
2012                      peer->tcp_ts_stamp <= tw->tw_ts_recent_stamp)) {
2013                         peer->tcp_ts_stamp = tw->tw_ts_recent_stamp;
2014                         peer->tcp_ts = tw->tw_ts_recent;
2015                 }
2016                 inet_putpeer(peer);
2017                 return 1;
2018         }
2019
2020         return 0;
2021 }
2022
2023 struct tcp_func ipv4_specific = {
2024         .queue_xmit     =       ip_queue_xmit,
2025         .send_check     =       tcp_v4_send_check,
2026         .rebuild_header =       tcp_v4_rebuild_header,
2027         .conn_request   =       tcp_v4_conn_request,
2028         .syn_recv_sock  =       tcp_v4_syn_recv_sock,
2029         .remember_stamp =       tcp_v4_remember_stamp,
2030         .net_header_len =       sizeof(struct iphdr),
2031         .setsockopt     =       ip_setsockopt,
2032         .getsockopt     =       ip_getsockopt,
2033         .addr2sockaddr  =       v4_addr2sockaddr,
2034         .sockaddr_len   =       sizeof(struct sockaddr_in),
2035 };
2036
2037 /* NOTE: A lot of things set to zero explicitly by call to
2038  *       sk_alloc() so need not be done here.
2039  */
2040 static int tcp_v4_init_sock(struct sock *sk)
2041 {
2042         struct tcp_sock *tp = tcp_sk(sk);
2043
2044         skb_queue_head_init(&tp->out_of_order_queue);
2045         tcp_init_xmit_timers(sk);
2046         tcp_prequeue_init(tp);
2047
2048         tp->rto  = TCP_TIMEOUT_INIT;
2049         tp->mdev = TCP_TIMEOUT_INIT;
2050
2051         /* So many TCP implementations out there (incorrectly) count the
2052          * initial SYN frame in their delayed-ACK and congestion control
2053          * algorithms that we must have the following bandaid to talk
2054          * efficiently to them.  -DaveM
2055          */
2056         tp->snd_cwnd = 2;
2057
2058         /* See draft-stevens-tcpca-spec-01 for discussion of the
2059          * initialization of these values.
2060          */
2061         tp->snd_ssthresh = 0x7fffffff;  /* Infinity */
2062         tp->snd_cwnd_clamp = ~0;
2063         tp->mss_cache_std = tp->mss_cache = 536;
2064
2065         tp->reordering = sysctl_tcp_reordering;
2066
2067         sk->sk_state = TCP_CLOSE;
2068
2069         sk->sk_write_space = sk_stream_write_space;
2070         sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
2071
2072         tp->af_specific = &ipv4_specific;
2073
2074         sk->sk_sndbuf = sysctl_tcp_wmem[1];
2075         sk->sk_rcvbuf = sysctl_tcp_rmem[1];
2076
2077         atomic_inc(&tcp_sockets_allocated);
2078
2079         return 0;
2080 }
2081
2082 int tcp_v4_destroy_sock(struct sock *sk)
2083 {
2084         struct tcp_sock *tp = tcp_sk(sk);
2085
2086         tcp_clear_xmit_timers(sk);
2087
2088         /* Cleanup up the write buffer. */
2089         sk_stream_writequeue_purge(sk);
2090
2091         /* Cleans up our, hopefully empty, out_of_order_queue. */
2092         __skb_queue_purge(&tp->out_of_order_queue);
2093
2094         /* Clean prequeue, it must be empty really */
2095         __skb_queue_purge(&tp->ucopy.prequeue);
2096
2097         /* Clean up a referenced TCP bind bucket. */
2098         if (tp->bind_hash)
2099                 tcp_put_port(sk);
2100
2101         /*
2102          * If sendmsg cached page exists, toss it.
2103          */
2104         if (sk->sk_sndmsg_page) {
2105                 __free_page(sk->sk_sndmsg_page);
2106                 sk->sk_sndmsg_page = NULL;
2107         }
2108
2109         atomic_dec(&tcp_sockets_allocated);
2110
2111         return 0;
2112 }
2113
2114 EXPORT_SYMBOL(tcp_v4_destroy_sock);
2115
2116 #ifdef CONFIG_PROC_FS
2117 /* Proc filesystem TCP sock list dumping. */
2118
2119 static inline struct tcp_tw_bucket *tw_head(struct hlist_head *head)
2120 {
2121         return hlist_empty(head) ? NULL :
2122                 list_entry(head->first, struct tcp_tw_bucket, tw_node);
2123 }
2124
2125 static inline struct tcp_tw_bucket *tw_next(struct tcp_tw_bucket *tw)
2126 {
2127         return tw->tw_node.next ?
2128                 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
2129 }
2130
2131 static void *listening_get_next(struct seq_file *seq, void *cur)
2132 {
2133         struct tcp_sock *tp;
2134         struct hlist_node *node;
2135         struct sock *sk = cur;
2136         struct tcp_iter_state* st = seq->private;
2137
2138         if (!sk) {
2139                 st->bucket = 0;
2140                 sk = sk_head(&tcp_listening_hash[0]);
2141                 goto get_sk;
2142         }
2143
2144         ++st->num;
2145
2146         if (st->state == TCP_SEQ_STATE_OPENREQ) {
2147                 struct open_request *req = cur;
2148
2149                 tp = tcp_sk(st->syn_wait_sk);
2150                 req = req->dl_next;
2151                 while (1) {
2152                         while (req) {
2153                                 if (req->class->family == st->family) {
2154                                         cur = req;
2155                                         goto out;
2156                                 }
2157                                 req = req->dl_next;
2158                         }
2159                         if (++st->sbucket >= TCP_SYNQ_HSIZE)
2160                                 break;
2161 get_req:
2162                         req = tp->listen_opt->syn_table[st->sbucket];
2163                 }
2164                 sk        = sk_next(st->syn_wait_sk);
2165                 st->state = TCP_SEQ_STATE_LISTENING;
2166                 read_unlock_bh(&tp->syn_wait_lock);
2167         } else {
2168                 tp = tcp_sk(sk);
2169                 read_lock_bh(&tp->syn_wait_lock);
2170                 if (tp->listen_opt && tp->listen_opt->qlen)
2171                         goto start_req;
2172                 read_unlock_bh(&tp->syn_wait_lock);
2173                 sk = sk_next(sk);
2174         }
2175 get_sk:
2176         sk_for_each_from(sk, node) {
2177                 if (sk->sk_family == st->family) {
2178                         cur = sk;
2179                         goto out;
2180                 }
2181                 tp = tcp_sk(sk);
2182                 read_lock_bh(&tp->syn_wait_lock);
2183                 if (tp->listen_opt && tp->listen_opt->qlen) {
2184 start_req:
2185                         st->uid         = sock_i_uid(sk);
2186                         st->syn_wait_sk = sk;
2187                         st->state       = TCP_SEQ_STATE_OPENREQ;
2188                         st->sbucket     = 0;
2189                         goto get_req;
2190                 }
2191                 read_unlock_bh(&tp->syn_wait_lock);
2192         }
2193         if (++st->bucket < TCP_LHTABLE_SIZE) {
2194                 sk = sk_head(&tcp_listening_hash[st->bucket]);
2195                 goto get_sk;
2196         }
2197         cur = NULL;
2198 out:
2199         return cur;
2200 }
2201
2202 static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
2203 {
2204         void *rc = listening_get_next(seq, NULL);
2205
2206         while (rc && *pos) {
2207                 rc = listening_get_next(seq, rc);
2208                 --*pos;
2209         }
2210         return rc;
2211 }
2212
2213 static void *established_get_first(struct seq_file *seq)
2214 {
2215         struct tcp_iter_state* st = seq->private;
2216         void *rc = NULL;
2217
2218         for (st->bucket = 0; st->bucket < tcp_ehash_size; ++st->bucket) {
2219                 struct sock *sk;
2220                 struct hlist_node *node;
2221                 struct tcp_tw_bucket *tw;
2222
2223                 /* We can reschedule _before_ having picked the target: */
2224                 cond_resched_softirq();
2225
2226                 read_lock(&tcp_ehash[st->bucket].lock);
2227                 sk_for_each(sk, node, &tcp_ehash[st->bucket].chain) {
2228                         if (sk->sk_family != st->family) {
2229                                 continue;
2230                         }
2231                         rc = sk;
2232                         goto out;
2233                 }
2234                 st->state = TCP_SEQ_STATE_TIME_WAIT;
2235                 tw_for_each(tw, node,
2236                             &tcp_ehash[st->bucket + tcp_ehash_size].chain) {
2237                         if (tw->tw_family != st->family) {
2238                                 continue;
2239                         }
2240                         rc = tw;
2241                         goto out;
2242                 }
2243                 read_unlock(&tcp_ehash[st->bucket].lock);
2244                 st->state = TCP_SEQ_STATE_ESTABLISHED;
2245         }
2246 out:
2247         return rc;
2248 }
2249
2250 static void *established_get_next(struct seq_file *seq, void *cur)
2251 {
2252         struct sock *sk = cur;
2253         struct tcp_tw_bucket *tw;
2254         struct hlist_node *node;
2255         struct tcp_iter_state* st = seq->private;
2256
2257         ++st->num;
2258
2259         if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2260                 tw = cur;
2261                 tw = tw_next(tw);
2262 get_tw:
2263                 while (tw && tw->tw_family != st->family) {
2264                         tw = tw_next(tw);
2265                 }
2266                 if (tw) {
2267                         cur = tw;
2268                         goto out;
2269                 }
2270                 read_unlock(&tcp_ehash[st->bucket].lock);
2271                 st->state = TCP_SEQ_STATE_ESTABLISHED;
2272
2273                 /* We can reschedule between buckets: */
2274                 cond_resched_softirq();
2275
2276                 if (++st->bucket < tcp_ehash_size) {
2277                         read_lock(&tcp_ehash[st->bucket].lock);
2278                         sk = sk_head(&tcp_ehash[st->bucket].chain);
2279                 } else {
2280                         cur = NULL;
2281                         goto out;
2282                 }
2283         } else
2284                 sk = sk_next(sk);
2285
2286         sk_for_each_from(sk, node) {
2287                 if (sk->sk_family == st->family)
2288                         goto found;
2289         }
2290
2291         st->state = TCP_SEQ_STATE_TIME_WAIT;
2292         tw = tw_head(&tcp_ehash[st->bucket + tcp_ehash_size].chain);
2293         goto get_tw;
2294 found:
2295         cur = sk;
2296 out:
2297         return cur;
2298 }
2299
2300 static void *established_get_idx(struct seq_file *seq, loff_t pos)
2301 {
2302         void *rc = established_get_first(seq);
2303
2304         while (rc && pos) {
2305                 rc = established_get_next(seq, rc);
2306                 --pos;
2307         }
2308         return rc;
2309 }
2310
2311 static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2312 {
2313         void *rc;
2314         struct tcp_iter_state* st = seq->private;
2315
2316         tcp_listen_lock();
2317         st->state = TCP_SEQ_STATE_LISTENING;
2318         rc        = listening_get_idx(seq, &pos);
2319
2320         if (!rc) {
2321                 tcp_listen_unlock();
2322                 local_bh_disable();
2323                 st->state = TCP_SEQ_STATE_ESTABLISHED;
2324                 rc        = established_get_idx(seq, pos);
2325         }
2326
2327         return rc;
2328 }
2329
2330 static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2331 {
2332         struct tcp_iter_state* st = seq->private;
2333         st->state = TCP_SEQ_STATE_LISTENING;
2334         st->num = 0;
2335         return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2336 }
2337
2338 static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2339 {
2340         void *rc = NULL;
2341         struct tcp_iter_state* st;
2342
2343         if (v == SEQ_START_TOKEN) {
2344                 rc = tcp_get_idx(seq, 0);
2345                 goto out;
2346         }
2347         st = seq->private;
2348
2349         switch (st->state) {
2350         case TCP_SEQ_STATE_OPENREQ:
2351         case TCP_SEQ_STATE_LISTENING:
2352                 rc = listening_get_next(seq, v);
2353                 if (!rc) {
2354                         tcp_listen_unlock();
2355                         local_bh_disable();
2356                         st->state = TCP_SEQ_STATE_ESTABLISHED;
2357                         rc        = established_get_first(seq);
2358                 }
2359                 break;
2360         case TCP_SEQ_STATE_ESTABLISHED:
2361         case TCP_SEQ_STATE_TIME_WAIT:
2362                 rc = established_get_next(seq, v);
2363                 break;
2364         }
2365 out:
2366         ++*pos;
2367         return rc;
2368 }
2369
2370 static void tcp_seq_stop(struct seq_file *seq, void *v)
2371 {
2372         struct tcp_iter_state* st = seq->private;
2373
2374         switch (st->state) {
2375         case TCP_SEQ_STATE_OPENREQ:
2376                 if (v) {
2377                         struct tcp_sock *tp = tcp_sk(st->syn_wait_sk);
2378                         read_unlock_bh(&tp->syn_wait_lock);
2379                 }
2380         case TCP_SEQ_STATE_LISTENING:
2381                 if (v != SEQ_START_TOKEN)
2382                         tcp_listen_unlock();
2383                 break;
2384         case TCP_SEQ_STATE_TIME_WAIT:
2385         case TCP_SEQ_STATE_ESTABLISHED:
2386                 if (v)
2387                         read_unlock(&tcp_ehash[st->bucket].lock);
2388                 local_bh_enable();
2389                 break;
2390         }
2391 }
2392
2393 static int tcp_seq_open(struct inode *inode, struct file *file)
2394 {
2395         struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
2396         struct seq_file *seq;
2397         struct tcp_iter_state *s;
2398         int rc;
2399
2400         if (unlikely(afinfo == NULL))
2401                 return -EINVAL;
2402
2403         s = kmalloc(sizeof(*s), GFP_KERNEL);
2404         if (!s)
2405                 return -ENOMEM;
2406         memset(s, 0, sizeof(*s));
2407         s->family               = afinfo->family;
2408         s->seq_ops.start        = tcp_seq_start;
2409         s->seq_ops.next         = tcp_seq_next;
2410         s->seq_ops.show         = afinfo->seq_show;
2411         s->seq_ops.stop         = tcp_seq_stop;
2412
2413         rc = seq_open(file, &s->seq_ops);
2414         if (rc)
2415                 goto out_kfree;
2416         seq          = file->private_data;
2417         seq->private = s;
2418 out:
2419         return rc;
2420 out_kfree:
2421         kfree(s);
2422         goto out;
2423 }
2424
2425 int tcp_proc_register(struct tcp_seq_afinfo *afinfo)
2426 {
2427         int rc = 0;
2428         struct proc_dir_entry *p;
2429
2430         if (!afinfo)
2431                 return -EINVAL;
2432         afinfo->seq_fops->owner         = afinfo->owner;
2433         afinfo->seq_fops->open          = tcp_seq_open;
2434         afinfo->seq_fops->read          = seq_read;
2435         afinfo->seq_fops->llseek        = seq_lseek;
2436         afinfo->seq_fops->release       = seq_release_private;
2437
2438         p = proc_net_fops_create(afinfo->name, S_IRUGO, afinfo->seq_fops);
2439         if (p)
2440                 p->data = afinfo;
2441         else
2442                 rc = -ENOMEM;
2443         return rc;
2444 }
2445
2446 void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo)
2447 {
2448         if (!afinfo)
2449                 return;
2450         proc_net_remove(afinfo->name);
2451         memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops));
2452 }
2453
2454 static void get_openreq4(struct sock *sk, struct open_request *req,
2455                          char *tmpbuf, int i, int uid)
2456 {
2457         int ttd = req->expires - jiffies;
2458
2459         sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
2460                 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p",
2461                 i,
2462                 req->af.v4_req.loc_addr,
2463                 ntohs(inet_sk(sk)->sport),
2464                 req->af.v4_req.rmt_addr,
2465                 ntohs(req->rmt_port),
2466                 TCP_SYN_RECV,
2467                 0, 0, /* could print option size, but that is af dependent. */
2468                 1,    /* timers active (only the expire timer) */
2469                 jiffies_to_clock_t(ttd),
2470                 req->retrans,
2471                 uid,
2472                 0,  /* non standard timer */
2473                 0, /* open_requests have no inode */
2474                 atomic_read(&sk->sk_refcnt),
2475                 req);
2476 }
2477
2478 static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i)
2479 {
2480         int timer_active;
2481         unsigned long timer_expires;
2482         struct tcp_sock *tp = tcp_sk(sp);
2483         struct inet_sock *inet = inet_sk(sp);
2484         unsigned int dest = inet->daddr;
2485         unsigned int src = inet->rcv_saddr;
2486         __u16 destp = ntohs(inet->dport);
2487         __u16 srcp = ntohs(inet->sport);
2488
2489         if (tp->pending == TCP_TIME_RETRANS) {
2490                 timer_active    = 1;
2491                 timer_expires   = tp->timeout;
2492         } else if (tp->pending == TCP_TIME_PROBE0) {
2493                 timer_active    = 4;
2494                 timer_expires   = tp->timeout;
2495         } else if (timer_pending(&sp->sk_timer)) {
2496                 timer_active    = 2;
2497                 timer_expires   = sp->sk_timer.expires;
2498         } else {
2499                 timer_active    = 0;
2500                 timer_expires = jiffies;
2501         }
2502
2503         sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
2504                         "%08X %5d %8d %lu %d %p %u %u %u %u %d",
2505                 i, src, srcp, dest, destp, sp->sk_state,
2506                 tp->write_seq - tp->snd_una, tp->rcv_nxt - tp->copied_seq,
2507                 timer_active,
2508                 jiffies_to_clock_t(timer_expires - jiffies),
2509                 tp->retransmits,
2510                 sock_i_uid(sp),
2511                 tp->probes_out,
2512                 sock_i_ino(sp),
2513                 atomic_read(&sp->sk_refcnt), sp,
2514                 tp->rto, tp->ack.ato, (tp->ack.quick << 1) | tp->ack.pingpong,
2515                 tp->snd_cwnd,
2516                 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh);
2517 }
2518
2519 static void get_timewait4_sock(struct tcp_tw_bucket *tw, char *tmpbuf, int i)
2520 {
2521         unsigned int dest, src;
2522         __u16 destp, srcp;
2523         int ttd = tw->tw_ttd - jiffies;
2524
2525         if (ttd < 0)
2526                 ttd = 0;
2527
2528         dest  = tw->tw_daddr;
2529         src   = tw->tw_rcv_saddr;
2530         destp = ntohs(tw->tw_dport);
2531         srcp  = ntohs(tw->tw_sport);
2532
2533         sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
2534                 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p",
2535                 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2536                 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2537                 atomic_read(&tw->tw_refcnt), tw);
2538 }
2539
2540 #define TMPSZ 150
2541
2542 static int tcp4_seq_show(struct seq_file *seq, void *v)
2543 {
2544         struct tcp_iter_state* st;
2545         char tmpbuf[TMPSZ + 1];
2546
2547         if (v == SEQ_START_TOKEN) {
2548                 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2549                            "  sl  local_address rem_address   st tx_queue "
2550                            "rx_queue tr tm->when retrnsmt   uid  timeout "
2551                            "inode");
2552                 goto out;
2553         }
2554         st = seq->private;
2555
2556         switch (st->state) {
2557         case TCP_SEQ_STATE_LISTENING:
2558         case TCP_SEQ_STATE_ESTABLISHED:
2559                 get_tcp4_sock(v, tmpbuf, st->num);
2560                 break;
2561         case TCP_SEQ_STATE_OPENREQ:
2562                 get_openreq4(st->syn_wait_sk, v, tmpbuf, st->num, st->uid);
2563                 break;
2564         case TCP_SEQ_STATE_TIME_WAIT:
2565                 get_timewait4_sock(v, tmpbuf, st->num);
2566                 break;
2567         }
2568         seq_printf(seq, "%-*s\n", TMPSZ - 1, tmpbuf);
2569 out:
2570         return 0;
2571 }
2572
2573 static struct file_operations tcp4_seq_fops;
2574 static struct tcp_seq_afinfo tcp4_seq_afinfo = {
2575         .owner          = THIS_MODULE,
2576         .name           = "tcp",
2577         .family         = AF_INET,
2578         .seq_show       = tcp4_seq_show,
2579         .seq_fops       = &tcp4_seq_fops,
2580 };
2581
2582 int __init tcp4_proc_init(void)
2583 {
2584         return tcp_proc_register(&tcp4_seq_afinfo);
2585 }
2586
2587 void tcp4_proc_exit(void)
2588 {
2589         tcp_proc_unregister(&tcp4_seq_afinfo);
2590 }
2591 #endif /* CONFIG_PROC_FS */
2592
2593 struct proto tcp_prot = {
2594         .name                   = "TCP",
2595         .owner                  = THIS_MODULE,
2596         .close                  = tcp_close,
2597         .connect                = tcp_v4_connect,
2598         .disconnect             = tcp_disconnect,
2599         .accept                 = tcp_accept,
2600         .ioctl                  = tcp_ioctl,
2601         .init                   = tcp_v4_init_sock,
2602         .destroy                = tcp_v4_destroy_sock,
2603         .shutdown               = tcp_shutdown,
2604         .setsockopt             = tcp_setsockopt,
2605         .getsockopt             = tcp_getsockopt,
2606         .sendmsg                = tcp_sendmsg,
2607         .recvmsg                = tcp_recvmsg,
2608         .backlog_rcv            = tcp_v4_do_rcv,
2609         .hash                   = tcp_v4_hash,
2610         .unhash                 = tcp_unhash,
2611         .get_port               = tcp_v4_get_port,
2612         .enter_memory_pressure  = tcp_enter_memory_pressure,
2613         .sockets_allocated      = &tcp_sockets_allocated,
2614         .memory_allocated       = &tcp_memory_allocated,
2615         .memory_pressure        = &tcp_memory_pressure,
2616         .sysctl_mem             = sysctl_tcp_mem,
2617         .sysctl_wmem            = sysctl_tcp_wmem,
2618         .sysctl_rmem            = sysctl_tcp_rmem,
2619         .max_header             = MAX_TCP_HEADER,
2620         .obj_size               = sizeof(struct tcp_sock),
2621 };
2622
2623
2624
2625 void __init tcp_v4_init(struct net_proto_family *ops)
2626 {
2627         int err = sock_create_kern(PF_INET, SOCK_RAW, IPPROTO_TCP, &tcp_socket);
2628         if (err < 0)
2629                 panic("Failed to create the TCP control socket.\n");
2630         tcp_socket->sk->sk_allocation   = GFP_ATOMIC;
2631         inet_sk(tcp_socket->sk)->uc_ttl = -1;
2632
2633         /* Unhash it so that IP input processing does not even
2634          * see it, we do not wish this socket to see incoming
2635          * packets.
2636          */
2637         tcp_socket->sk->sk_prot->unhash(tcp_socket->sk);
2638 }
2639
2640 EXPORT_SYMBOL(ipv4_specific);
2641 EXPORT_SYMBOL(tcp_bind_hash);
2642 EXPORT_SYMBOL(tcp_bucket_create);
2643 EXPORT_SYMBOL(tcp_hashinfo);
2644 EXPORT_SYMBOL(tcp_inherit_port);
2645 EXPORT_SYMBOL(tcp_listen_wlock);
2646 EXPORT_SYMBOL(tcp_port_rover);
2647 EXPORT_SYMBOL(tcp_prot);
2648 EXPORT_SYMBOL(tcp_put_port);
2649 EXPORT_SYMBOL(tcp_unhash);
2650 EXPORT_SYMBOL(tcp_v4_conn_request);
2651 EXPORT_SYMBOL(tcp_v4_connect);
2652 EXPORT_SYMBOL(tcp_v4_do_rcv);
2653 EXPORT_SYMBOL(tcp_v4_rebuild_header);
2654 EXPORT_SYMBOL(tcp_v4_remember_stamp);
2655 EXPORT_SYMBOL(tcp_v4_send_check);
2656 EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
2657
2658 #ifdef CONFIG_PROC_FS
2659 EXPORT_SYMBOL(tcp_proc_register);
2660 EXPORT_SYMBOL(tcp_proc_unregister);
2661 #endif
2662 EXPORT_SYMBOL(sysctl_local_port_range);
2663 EXPORT_SYMBOL(sysctl_max_syn_backlog);
2664 EXPORT_SYMBOL(sysctl_tcp_low_latency);
2665 EXPORT_SYMBOL(sysctl_tcp_tw_reuse);
2666