git.oblomov.eu Git - linux-2.6/blob - include/net/tcp.h

   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  *              Definitions for the TCP module.
   7  *
   8  * Version:     @(#)tcp.h       1.0.5   05/23/93
   9  *
  10  * Authors:     Ross Biro
  11  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12  *
  13  *              This program is free software; you can redistribute it and/or
  14  *              modify it under the terms of the GNU General Public License
  15  *              as published by the Free Software Foundation; either version
  16  *              2 of the License, or (at your option) any later version.
  17  */
  18 #ifndef _TCP_H
  19 #define _TCP_H
  20
  21 #define TCP_DEBUG 1
  22 #define FASTRETRANS_DEBUG 1
  23
  24 /* Cancel timers, when they are not required. */
  25 #undef TCP_CLEAR_TIMERS
  26
  27 #include <linux/config.h>
  28 #include <linux/list.h>
  29 #include <linux/tcp.h>
  30 #include <linux/slab.h>
  31 #include <linux/cache.h>
  32 #include <linux/percpu.h>
  33 #include <net/inet_hashtables.h>
  34 #include <net/checksum.h>
  35 #include <net/request_sock.h>
  36 #include <net/sock.h>
  37 #include <net/snmp.h>
  38 #include <net/ip.h>
  39 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
  40 #include <linux/ipv6.h>
  41 #endif
  42 #include <linux/seq_file.h>
  43
  44 extern struct inet_hashinfo     tcp_hashinfo;
  45 #define tcp_ehash               (tcp_hashinfo.ehash)
  46 #define tcp_bhash               (tcp_hashinfo.bhash)
  47 #define tcp_ehash_size          (tcp_hashinfo.ehash_size)
  48 #define tcp_bhash_size          (tcp_hashinfo.bhash_size)
  49 #define tcp_listening_hash      (tcp_hashinfo.listening_hash)
  50 #define tcp_lhash_lock          (tcp_hashinfo.lhash_lock)
  51 #define tcp_lhash_users         (tcp_hashinfo.lhash_users)
  52 #define tcp_lhash_wait          (tcp_hashinfo.lhash_wait)
  53 #define tcp_portalloc_lock      (tcp_hashinfo.portalloc_lock)
  54 #define tcp_bucket_cachep       (tcp_hashinfo.bind_bucket_cachep)
  55
  56 extern int tcp_port_rover;
  57
  58 #if (BITS_PER_LONG == 64)
  59 #define TCP_ADDRCMP_ALIGN_BYTES 8
  60 #else
  61 #define TCP_ADDRCMP_ALIGN_BYTES 4
  62 #endif
  63
  64 /* This is a TIME_WAIT bucket.  It works around the memory consumption
  65  * problems of sockets in such a state on heavily loaded servers, but
  66  * without violating the protocol specification.
  67  */
  68 struct tcp_tw_bucket {
  69         /*
  70          * Now struct sock also uses sock_common, so please just
  71          * don't add nothing before this first member (__tw_common) --acme
  72          */
  73         struct sock_common      __tw_common;
  74 #define tw_family               __tw_common.skc_family
  75 #define tw_state                __tw_common.skc_state
  76 #define tw_reuse                __tw_common.skc_reuse
  77 #define tw_bound_dev_if         __tw_common.skc_bound_dev_if
  78 #define tw_node                 __tw_common.skc_node
  79 #define tw_bind_node            __tw_common.skc_bind_node
  80 #define tw_refcnt               __tw_common.skc_refcnt
  81         volatile unsigned char  tw_substate;
  82         unsigned char           tw_rcv_wscale;
  83         __u16                   tw_sport;
  84         /* Socket demultiplex comparisons on incoming packets. */
  85         /* these five are in inet_sock */
  86         __u32                   tw_daddr
  87                 __attribute__((aligned(TCP_ADDRCMP_ALIGN_BYTES)));
  88         __u32                   tw_rcv_saddr;
  89         __u16                   tw_dport;
  90         __u16                   tw_num;
  91         /* And these are ours. */
  92         int                     tw_hashent;
  93         int                     tw_timeout;
  94         __u32                   tw_rcv_nxt;
  95         __u32                   tw_snd_nxt;
  96         __u32                   tw_rcv_wnd;
  97         __u32                   tw_ts_recent;
  98         long                    tw_ts_recent_stamp;
  99         unsigned long           tw_ttd;
 100         struct inet_bind_bucket *tw_tb;
 101         struct hlist_node       tw_death_node;
 102 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 103         struct in6_addr         tw_v6_daddr;
 104         struct in6_addr         tw_v6_rcv_saddr;
 105         int                     tw_v6_ipv6only;
 106 #endif
 107 };
 108
 109 static __inline__ void tw_add_node(struct tcp_tw_bucket *tw,
 110                                    struct hlist_head *list)
 111 {
 112         hlist_add_head(&tw->tw_node, list);
 113 }
 114
 115 static __inline__ void tw_add_bind_node(struct tcp_tw_bucket *tw,
 116                                         struct hlist_head *list)
 117 {
 118         hlist_add_head(&tw->tw_bind_node, list);
 119 }
 120
 121 static inline int tw_dead_hashed(struct tcp_tw_bucket *tw)
 122 {
 123         return tw->tw_death_node.pprev != NULL;
 124 }
 125
 126 static __inline__ void tw_dead_node_init(struct tcp_tw_bucket *tw)
 127 {
 128         tw->tw_death_node.pprev = NULL;
 129 }
 130
 131 static __inline__ void __tw_del_dead_node(struct tcp_tw_bucket *tw)
 132 {
 133         __hlist_del(&tw->tw_death_node);
 134         tw_dead_node_init(tw);
 135 }
 136
 137 static __inline__ int tw_del_dead_node(struct tcp_tw_bucket *tw)
 138 {
 139         if (tw_dead_hashed(tw)) {
 140                 __tw_del_dead_node(tw);
 141                 return 1;
 142         }
 143         return 0;
 144 }
 145
 146 #define tw_for_each(tw, node, head) \
 147         hlist_for_each_entry(tw, node, head, tw_node)
 148
 149 #define tw_for_each_inmate(tw, node, jail) \
 150         hlist_for_each_entry(tw, node, jail, tw_death_node)
 151
 152 #define tw_for_each_inmate_safe(tw, node, safe, jail) \
 153         hlist_for_each_entry_safe(tw, node, safe, jail, tw_death_node)
 154
 155 #define tcptw_sk(__sk)  ((struct tcp_tw_bucket *)(__sk))
 156
 157 static inline u32 tcp_v4_rcv_saddr(const struct sock *sk)
 158 {
 159         return likely(sk->sk_state != TCP_TIME_WAIT) ?
 160                 inet_sk(sk)->rcv_saddr : tcptw_sk(sk)->tw_rcv_saddr;
 161 }
 162
 163 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 164 static inline struct in6_addr *__tcp_v6_rcv_saddr(const struct sock *sk)
 165 {
 166         return likely(sk->sk_state != TCP_TIME_WAIT) ?
 167                 &inet6_sk(sk)->rcv_saddr : &tcptw_sk(sk)->tw_v6_rcv_saddr;
 168 }
 169
 170 static inline struct in6_addr *tcp_v6_rcv_saddr(const struct sock *sk)
 171 {
 172         return sk->sk_family == AF_INET6 ? __tcp_v6_rcv_saddr(sk) : NULL;
 173 }
 174
 175 #define tcptw_sk_ipv6only(__sk) (tcptw_sk(__sk)->tw_v6_ipv6only)
 176
 177 static inline int tcp_v6_ipv6only(const struct sock *sk)
 178 {
 179         return likely(sk->sk_state != TCP_TIME_WAIT) ?
 180                 ipv6_only_sock(sk) : tcptw_sk_ipv6only(sk);
 181 }
 182 #else
 183 # define __tcp_v6_rcv_saddr(__sk)       NULL
 184 # define tcp_v6_rcv_saddr(__sk)         NULL
 185 # define tcptw_sk_ipv6only(__sk)        0
 186 # define tcp_v6_ipv6only(__sk)          0
 187 #endif
 188
 189 extern kmem_cache_t *tcp_timewait_cachep;
 190
 191 static inline void tcp_tw_put(struct tcp_tw_bucket *tw)
 192 {
 193         if (atomic_dec_and_test(&tw->tw_refcnt)) {
 194 #ifdef SOCK_REFCNT_DEBUG
 195                 printk(KERN_DEBUG "tw_bucket %p released\n", tw);
 196 #endif
 197                 kmem_cache_free(tcp_timewait_cachep, tw);
 198         }
 199 }
 200
 201 extern atomic_t tcp_orphan_count;
 202 extern int tcp_tw_count;
 203 extern void tcp_time_wait(struct sock *sk, int state, int timeo);
 204 extern void tcp_tw_deschedule(struct tcp_tw_bucket *tw);
 205
 206
 207 /* Socket demux engine toys. */
 208 #ifdef __BIG_ENDIAN
 209 #define TCP_COMBINED_PORTS(__sport, __dport) \
 210         (((__u32)(__sport)<<16) | (__u32)(__dport))
 211 #else /* __LITTLE_ENDIAN */
 212 #define TCP_COMBINED_PORTS(__sport, __dport) \
 213         (((__u32)(__dport)<<16) | (__u32)(__sport))
 214 #endif
 215
 216 #if (BITS_PER_LONG == 64)
 217 #ifdef __BIG_ENDIAN
 218 #define TCP_V4_ADDR_COOKIE(__name, __saddr, __daddr) \
 219         __u64 __name = (((__u64)(__saddr))<<32)|((__u64)(__daddr));
 220 #else /* __LITTLE_ENDIAN */
 221 #define TCP_V4_ADDR_COOKIE(__name, __saddr, __daddr) \
 222         __u64 __name = (((__u64)(__daddr))<<32)|((__u64)(__saddr));
 223 #endif /* __BIG_ENDIAN */
 224 #define TCP_IPV4_MATCH(__sk, __cookie, __saddr, __daddr, __ports, __dif)\
 225         (((*((__u64 *)&(inet_sk(__sk)->daddr)))== (__cookie))   &&      \
 226          ((*((__u32 *)&(inet_sk(__sk)->dport)))== (__ports))    &&      \
 227          (!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
 228 #define TCP_IPV4_TW_MATCH(__sk, __cookie, __saddr, __daddr, __ports, __dif)\
 229         (((*((__u64 *)&(tcptw_sk(__sk)->tw_daddr))) == (__cookie)) &&   \
 230          ((*((__u32 *)&(tcptw_sk(__sk)->tw_dport))) == (__ports)) &&    \
 231          (!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
 232 #else /* 32-bit arch */
 233 #define TCP_V4_ADDR_COOKIE(__name, __saddr, __daddr)
 234 #define TCP_IPV4_MATCH(__sk, __cookie, __saddr, __daddr, __ports, __dif)\
 235         ((inet_sk(__sk)->daddr                  == (__saddr))   &&      \
 236          (inet_sk(__sk)->rcv_saddr              == (__daddr))   &&      \
 237          ((*((__u32 *)&(inet_sk(__sk)->dport)))== (__ports))    &&      \
 238          (!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
 239 #define TCP_IPV4_TW_MATCH(__sk, __cookie, __saddr, __daddr, __ports, __dif)\
 240         ((tcptw_sk(__sk)->tw_daddr              == (__saddr))   &&      \
 241          (tcptw_sk(__sk)->tw_rcv_saddr          == (__daddr))   &&      \
 242          ((*((__u32 *)&(tcptw_sk(__sk)->tw_dport))) == (__ports)) &&    \
 243          (!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
 244 #endif /* 64-bit arch */
 245
 246 #define TCP_IPV6_MATCH(__sk, __saddr, __daddr, __ports, __dif)     \
 247         (((*((__u32 *)&(inet_sk(__sk)->dport)))== (__ports))    && \
 248          ((__sk)->sk_family             == AF_INET6)            && \
 249          ipv6_addr_equal(&inet6_sk(__sk)->daddr, (__saddr))     && \
 250          ipv6_addr_equal(&inet6_sk(__sk)->rcv_saddr, (__daddr)) && \
 251          (!((__sk)->sk_bound_dev_if) || ((__sk)->sk_bound_dev_if == (__dif))))
 252
 253 #define MAX_TCP_HEADER  (128 + MAX_HEADER)
 254
 255 /*
 256  * Never offer a window over 32767 without using window scaling. Some
 257  * poor stacks do signed 16bit maths!
 258  */
 259 #define MAX_TCP_WINDOW          32767U
 260
 261 /* Minimal accepted MSS. It is (60+60+8) - (20+20). */
 262 #define TCP_MIN_MSS             88U
 263
 264 /* Minimal RCV_MSS. */
 265 #define TCP_MIN_RCVMSS          536U
 266
 267 /* After receiving this amount of duplicate ACKs fast retransmit starts. */
 268 #define TCP_FASTRETRANS_THRESH 3
 269
 270 /* Maximal reordering. */
 271 #define TCP_MAX_REORDERING      127
 272
 273 /* Maximal number of ACKs sent quickly to accelerate slow-start. */
 274 #define TCP_MAX_QUICKACKS       16U
 275
 276 /* urg_data states */
 277 #define TCP_URG_VALID   0x0100
 278 #define TCP_URG_NOTYET  0x0200
 279 #define TCP_URG_READ    0x0400
 280
 281 #define TCP_RETR1       3       /*
 282                                  * This is how many retries it does before it
 283                                  * tries to figure out if the gateway is
 284                                  * down. Minimal RFC value is 3; it corresponds
 285                                  * to ~3sec-8min depending on RTO.
 286                                  */
 287
 288 #define TCP_RETR2       15      /*
 289                                  * This should take at least
 290                                  * 90 minutes to time out.
 291                                  * RFC1122 says that the limit is 100 sec.
 292                                  * 15 is ~13-30min depending on RTO.
 293                                  */
 294
 295 #define TCP_SYN_RETRIES  5      /* number of times to retry active opening a
 296                                  * connection: ~180sec is RFC minumum   */
 297
 298 #define TCP_SYNACK_RETRIES 5    /* number of times to retry passive opening a
 299                                  * connection: ~180sec is RFC minumum   */
 300
 301
 302 #define TCP_ORPHAN_RETRIES 7    /* number of times to retry on an orphaned
 303                                  * socket. 7 is ~50sec-16min.
 304                                  */
 305
 306
 307 #define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to destroy TIME-WAIT
 308                                   * state, about 60 seconds     */
 309 #define TCP_FIN_TIMEOUT TCP_TIMEWAIT_LEN
 310                                  /* BSD style FIN_WAIT2 deadlock breaker.
 311                                   * It used to be 3min, new value is 60sec,
 312                                   * to combine FIN-WAIT-2 timeout with
 313                                   * TIME-WAIT timer.
 314                                   */
 315
 316 #define TCP_DELACK_MAX  ((unsigned)(HZ/5))      /* maximal time to delay before sending an ACK */
 317 #if HZ >= 100
 318 #define TCP_DELACK_MIN  ((unsigned)(HZ/25))     /* minimal time to delay before sending an ACK */
 319 #define TCP_ATO_MIN     ((unsigned)(HZ/25))
 320 #else
 321 #define TCP_DELACK_MIN  4U
 322 #define TCP_ATO_MIN     4U
 323 #endif
 324 #define TCP_RTO_MAX     ((unsigned)(120*HZ))
 325 #define TCP_RTO_MIN     ((unsigned)(HZ/5))
 326 #define TCP_TIMEOUT_INIT ((unsigned)(3*HZ))     /* RFC 1122 initial RTO value   */
 327
 328 #define TCP_RESOURCE_PROBE_INTERVAL ((unsigned)(HZ/2U)) /* Maximal interval between probes
 329                                                          * for local resources.
 330                                                          */
 331
 332 #define TCP_KEEPALIVE_TIME      (120*60*HZ)     /* two hours */
 333 #define TCP_KEEPALIVE_PROBES    9               /* Max of 9 keepalive probes    */
 334 #define TCP_KEEPALIVE_INTVL     (75*HZ)
 335
 336 #define MAX_TCP_KEEPIDLE        32767
 337 #define MAX_TCP_KEEPINTVL       32767
 338 #define MAX_TCP_KEEPCNT         127
 339 #define MAX_TCP_SYNCNT          127
 340
 341 #define TCP_SYNQ_INTERVAL       (HZ/5)  /* Period of SYNACK timer */
 342 #define TCP_SYNQ_HSIZE          512     /* Size of SYNACK hash table */
 343
 344 #define TCP_PAWS_24DAYS (60 * 60 * 24 * 24)
 345 #define TCP_PAWS_MSL    60              /* Per-host timestamps are invalidated
 346                                          * after this time. It should be equal
 347                                          * (or greater than) TCP_TIMEWAIT_LEN
 348                                          * to provide reliability equal to one
 349                                          * provided by timewait state.
 350                                          */
 351 #define TCP_PAWS_WINDOW 1               /* Replay window for per-host
 352                                          * timestamps. It must be less than
 353                                          * minimal timewait lifetime.
 354                                          */
 355
 356 #define TCP_TW_RECYCLE_SLOTS_LOG        5
 357 #define TCP_TW_RECYCLE_SLOTS            (1<<TCP_TW_RECYCLE_SLOTS_LOG)
 358
 359 /* If time > 4sec, it is "slow" path, no recycling is required,
 360    so that we select tick to get range about 4 seconds.
 361  */
 362
 363 #if HZ <= 16 || HZ > 4096
 364 # error Unsupported: HZ <= 16 or HZ > 4096
 365 #elif HZ <= 32
 366 # define TCP_TW_RECYCLE_TICK (5+2-TCP_TW_RECYCLE_SLOTS_LOG)
 367 #elif HZ <= 64
 368 # define TCP_TW_RECYCLE_TICK (6+2-TCP_TW_RECYCLE_SLOTS_LOG)
 369 #elif HZ <= 128
 370 # define TCP_TW_RECYCLE_TICK (7+2-TCP_TW_RECYCLE_SLOTS_LOG)
 371 #elif HZ <= 256
 372 # define TCP_TW_RECYCLE_TICK (8+2-TCP_TW_RECYCLE_SLOTS_LOG)
 373 #elif HZ <= 512
 374 # define TCP_TW_RECYCLE_TICK (9+2-TCP_TW_RECYCLE_SLOTS_LOG)
 375 #elif HZ <= 1024
 376 # define TCP_TW_RECYCLE_TICK (10+2-TCP_TW_RECYCLE_SLOTS_LOG)
 377 #elif HZ <= 2048
 378 # define TCP_TW_RECYCLE_TICK (11+2-TCP_TW_RECYCLE_SLOTS_LOG)
 379 #else
 380 # define TCP_TW_RECYCLE_TICK (12+2-TCP_TW_RECYCLE_SLOTS_LOG)
 381 #endif
 382 /*
 383  *      TCP option
 384  */
 385
 386 #define TCPOPT_NOP              1       /* Padding */
 387 #define TCPOPT_EOL              0       /* End of options */
 388 #define TCPOPT_MSS              2       /* Segment size negotiating */
 389 #define TCPOPT_WINDOW           3       /* Window scaling */
 390 #define TCPOPT_SACK_PERM        4       /* SACK Permitted */
 391 #define TCPOPT_SACK             5       /* SACK Block */
 392 #define TCPOPT_TIMESTAMP        8       /* Better RTT estimations/PAWS */
 393
 394 /*
 395  *     TCP option lengths
 396  */
 397
 398 #define TCPOLEN_MSS            4
 399 #define TCPOLEN_WINDOW         3
 400 #define TCPOLEN_SACK_PERM      2
 401 #define TCPOLEN_TIMESTAMP      10
 402
 403 /* But this is what stacks really send out. */
 404 #define TCPOLEN_TSTAMP_ALIGNED          12
 405 #define TCPOLEN_WSCALE_ALIGNED          4
 406 #define TCPOLEN_SACKPERM_ALIGNED        4
 407 #define TCPOLEN_SACK_BASE               2
 408 #define TCPOLEN_SACK_BASE_ALIGNED       4
 409 #define TCPOLEN_SACK_PERBLOCK           8
 410
 411 #define TCP_TIME_RETRANS        1       /* Retransmit timer */
 412 #define TCP_TIME_DACK           2       /* Delayed ack timer */
 413 #define TCP_TIME_PROBE0         3       /* Zero window probe timer */
 414 #define TCP_TIME_KEEPOPEN       4       /* Keepalive timer */
 415
 416 /* Flags in tp->nonagle */
 417 #define TCP_NAGLE_OFF           1       /* Nagle's algo is disabled */
 418 #define TCP_NAGLE_CORK          2       /* Socket is corked         */
 419 #define TCP_NAGLE_PUSH          4       /* Cork is overriden for already queued data */
 420
 421 /* sysctl variables for tcp */
 422 extern int sysctl_tcp_timestamps;
 423 extern int sysctl_tcp_window_scaling;
 424 extern int sysctl_tcp_sack;
 425 extern int sysctl_tcp_fin_timeout;
 426 extern int sysctl_tcp_tw_recycle;
 427 extern int sysctl_tcp_keepalive_time;
 428 extern int sysctl_tcp_keepalive_probes;
 429 extern int sysctl_tcp_keepalive_intvl;
 430 extern int sysctl_tcp_syn_retries;
 431 extern int sysctl_tcp_synack_retries;
 432 extern int sysctl_tcp_retries1;
 433 extern int sysctl_tcp_retries2;
 434 extern int sysctl_tcp_orphan_retries;
 435 extern int sysctl_tcp_syncookies;
 436 extern int sysctl_tcp_retrans_collapse;
 437 extern int sysctl_tcp_stdurg;
 438 extern int sysctl_tcp_rfc1337;
 439 extern int sysctl_tcp_abort_on_overflow;
 440 extern int sysctl_tcp_max_orphans;
 441 extern int sysctl_tcp_max_tw_buckets;
 442 extern int sysctl_tcp_fack;
 443 extern int sysctl_tcp_reordering;
 444 extern int sysctl_tcp_ecn;
 445 extern int sysctl_tcp_dsack;
 446 extern int sysctl_tcp_mem[3];
 447 extern int sysctl_tcp_wmem[3];
 448 extern int sysctl_tcp_rmem[3];
 449 extern int sysctl_tcp_app_win;
 450 extern int sysctl_tcp_adv_win_scale;
 451 extern int sysctl_tcp_tw_reuse;
 452 extern int sysctl_tcp_frto;
 453 extern int sysctl_tcp_low_latency;
 454 extern int sysctl_tcp_nometrics_save;
 455 extern int sysctl_tcp_moderate_rcvbuf;
 456 extern int sysctl_tcp_tso_win_divisor;
 457
 458 extern atomic_t tcp_memory_allocated;
 459 extern atomic_t tcp_sockets_allocated;
 460 extern int tcp_memory_pressure;
 461
 462 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 463 #define TCP_INET_FAMILY(fam) ((fam) == AF_INET)
 464 #else
 465 #define TCP_INET_FAMILY(fam) 1
 466 #endif
 467
 468 /*
 469  *      Pointers to address related TCP functions
 470  *      (i.e. things that depend on the address family)
 471  */
 472
 473 struct tcp_func {
 474         int                     (*queue_xmit)           (struct sk_buff *skb,
 475                                                          int ipfragok);
 476
 477         void                    (*send_check)           (struct sock *sk,
 478                                                          struct tcphdr *th,
 479                                                          int len,
 480                                                          struct sk_buff *skb);
 481
 482         int                     (*rebuild_header)       (struct sock *sk);
 483
 484         int                     (*conn_request)         (struct sock *sk,
 485                                                          struct sk_buff *skb);
 486
 487         struct sock *           (*syn_recv_sock)        (struct sock *sk,
 488                                                          struct sk_buff *skb,
 489                                                          struct request_sock *req,
 490                                                          struct dst_entry *dst);
 491
 492         int                     (*remember_stamp)       (struct sock *sk);
 493
 494         __u16                   net_header_len;
 495
 496         int                     (*setsockopt)           (struct sock *sk,
 497                                                          int level,
 498                                                          int optname,
 499                                                          char __user *optval,
 500                                                          int optlen);
 501
 502         int                     (*getsockopt)           (struct sock *sk,
 503                                                          int level,
 504                                                          int optname,
 505                                                          char __user *optval,
 506                                                          int __user *optlen);
 507
 508
 509         void                    (*addr2sockaddr)        (struct sock *sk,
 510                                                          struct sockaddr *);
 511
 512         int sockaddr_len;
 513 };
 514
 515 /*
 516  * The next routines deal with comparing 32 bit unsigned ints
 517  * and worry about wraparound (automatic with unsigned arithmetic).
 518  */
 519
 520 static inline int before(__u32 seq1, __u32 seq2)
 521 {
 522         return (__s32)(seq1-seq2) < 0;
 523 }
 524
 525 static inline int after(__u32 seq1, __u32 seq2)
 526 {
 527         return (__s32)(seq2-seq1) < 0;
 528 }
 529
 530
 531 /* is s2<=s1<=s3 ? */
 532 static inline int between(__u32 seq1, __u32 seq2, __u32 seq3)
 533 {
 534         return seq3 - seq2 >= seq1 - seq2;
 535 }
 536
 537
 538 extern struct proto tcp_prot;
 539
 540 DECLARE_SNMP_STAT(struct tcp_mib, tcp_statistics);
 541 #define TCP_INC_STATS(field)            SNMP_INC_STATS(tcp_statistics, field)
 542 #define TCP_INC_STATS_BH(field)         SNMP_INC_STATS_BH(tcp_statistics, field)
 543 #define TCP_INC_STATS_USER(field)       SNMP_INC_STATS_USER(tcp_statistics, field)
 544 #define TCP_DEC_STATS(field)            SNMP_DEC_STATS(tcp_statistics, field)
 545 #define TCP_ADD_STATS_BH(field, val)    SNMP_ADD_STATS_BH(tcp_statistics, field, val)
 546 #define TCP_ADD_STATS_USER(field, val)  SNMP_ADD_STATS_USER(tcp_statistics, field, val)
 547
 548 extern void                     tcp_v4_err(struct sk_buff *skb, u32);
 549
 550 extern void                     tcp_shutdown (struct sock *sk, int how);
 551
 552 extern int                      tcp_v4_rcv(struct sk_buff *skb);
 553
 554 extern int                      tcp_v4_remember_stamp(struct sock *sk);
 555
 556 extern int                      tcp_v4_tw_remember_stamp(struct tcp_tw_bucket *tw);
 557
 558 extern int                      tcp_sendmsg(struct kiocb *iocb, struct sock *sk,
 559                                             struct msghdr *msg, size_t size);
 560 extern ssize_t                  tcp_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags);
 561
 562 extern int                      tcp_ioctl(struct sock *sk,
 563                                           int cmd,
 564                                           unsigned long arg);
 565
 566 extern int                      tcp_rcv_state_process(struct sock *sk,
 567                                                       struct sk_buff *skb,
 568                                                       struct tcphdr *th,
 569                                                       unsigned len);
 570
 571 extern int                      tcp_rcv_established(struct sock *sk,
 572                                                     struct sk_buff *skb,
 573                                                     struct tcphdr *th,
 574                                                     unsigned len);
 575
 576 extern void                     tcp_rcv_space_adjust(struct sock *sk);
 577
 578 enum tcp_ack_state_t
 579 {
 580         TCP_ACK_SCHED = 1,
 581         TCP_ACK_TIMER = 2,
 582         TCP_ACK_PUSHED= 4
 583 };
 584
 585 static inline void tcp_schedule_ack(struct tcp_sock *tp)
 586 {
 587         tp->ack.pending |= TCP_ACK_SCHED;
 588 }
 589
 590 static inline int tcp_ack_scheduled(struct tcp_sock *tp)
 591 {
 592         return tp->ack.pending&TCP_ACK_SCHED;
 593 }
 594
 595 static __inline__ void tcp_dec_quickack_mode(struct tcp_sock *tp, unsigned int pkts)
 596 {
 597         if (tp->ack.quick) {
 598                 if (pkts >= tp->ack.quick) {
 599                         tp->ack.quick = 0;
 600
 601                         /* Leaving quickack mode we deflate ATO. */
 602                         tp->ack.ato = TCP_ATO_MIN;
 603                 } else
 604                         tp->ack.quick -= pkts;
 605         }
 606 }
 607
 608 extern void tcp_enter_quickack_mode(struct tcp_sock *tp);
 609
 610 static __inline__ void tcp_delack_init(struct tcp_sock *tp)
 611 {
 612         memset(&tp->ack, 0, sizeof(tp->ack));
 613 }
 614
 615 static inline void tcp_clear_options(struct tcp_options_received *rx_opt)
 616 {
 617         rx_opt->tstamp_ok = rx_opt->sack_ok = rx_opt->wscale_ok = rx_opt->snd_wscale = 0;
 618 }
 619
 620 enum tcp_tw_status
 621 {
 622         TCP_TW_SUCCESS = 0,
 623         TCP_TW_RST = 1,
 624         TCP_TW_ACK = 2,
 625         TCP_TW_SYN = 3
 626 };
 627
 628
 629 extern enum tcp_tw_status       tcp_timewait_state_process(struct tcp_tw_bucket *tw,
 630                                                            struct sk_buff *skb,
 631                                                            struct tcphdr *th,
 632                                                            unsigned len);
 633
 634 extern struct sock *            tcp_check_req(struct sock *sk,struct sk_buff *skb,
 635                                               struct request_sock *req,
 636                                               struct request_sock **prev);
 637 extern int                      tcp_child_process(struct sock *parent,
 638                                                   struct sock *child,
 639                                                   struct sk_buff *skb);
 640 extern void                     tcp_enter_frto(struct sock *sk);
 641 extern void                     tcp_enter_loss(struct sock *sk, int how);
 642 extern void                     tcp_clear_retrans(struct tcp_sock *tp);
 643 extern void                     tcp_update_metrics(struct sock *sk);
 644
 645 extern void                     tcp_close(struct sock *sk,
 646                                           long timeout);
 647 extern struct sock *            tcp_accept(struct sock *sk, int flags, int *err);
 648 extern unsigned int             tcp_poll(struct file * file, struct socket *sock, struct poll_table_struct *wait);
 649
 650 extern int                      tcp_getsockopt(struct sock *sk, int level,
 651                                                int optname,
 652                                                char __user *optval,
 653                                                int __user *optlen);
 654 extern int                      tcp_setsockopt(struct sock *sk, int level,
 655                                                int optname, char __user *optval,
 656                                                int optlen);
 657 extern void                     tcp_set_keepalive(struct sock *sk, int val);
 658 extern int                      tcp_recvmsg(struct kiocb *iocb, struct sock *sk,
 659                                             struct msghdr *msg,
 660                                             size_t len, int nonblock,
 661                                             int flags, int *addr_len);
 662
 663 extern int                      tcp_listen_start(struct sock *sk);
 664
 665 extern void                     tcp_parse_options(struct sk_buff *skb,
 666                                                   struct tcp_options_received *opt_rx,
 667                                                   int estab);
 668
 669 /*
 670  *      TCP v4 functions exported for the inet6 API
 671  */
 672
 673 extern void                     tcp_v4_send_check(struct sock *sk,
 674                                                   struct tcphdr *th, int len,
 675                                                   struct sk_buff *skb);
 676
 677 extern int                      tcp_v4_conn_request(struct sock *sk,
 678                                                     struct sk_buff *skb);
 679
 680 extern struct sock *            tcp_create_openreq_child(struct sock *sk,
 681                                                          struct request_sock *req,
 682                                                          struct sk_buff *skb);
 683
 684 extern struct sock *            tcp_v4_syn_recv_sock(struct sock *sk,
 685                                                      struct sk_buff *skb,
 686                                                      struct request_sock *req,
 687                                                         struct dst_entry *dst);
 688
 689 extern int                      tcp_v4_do_rcv(struct sock *sk,
 690                                               struct sk_buff *skb);
 691
 692 extern int                      tcp_v4_connect(struct sock *sk,
 693                                                struct sockaddr *uaddr,
 694                                                int addr_len);
 695
 696 extern int                      tcp_connect(struct sock *sk);
 697
 698 extern struct sk_buff *         tcp_make_synack(struct sock *sk,
 699                                                 struct dst_entry *dst,
 700                                                 struct request_sock *req);
 701
 702 extern int                      tcp_disconnect(struct sock *sk, int flags);
 703
 704 extern void                     tcp_unhash(struct sock *sk);
 705
 706 extern int                      tcp_v4_hash_connecting(struct sock *sk);
 707
 708
 709 /* From syncookies.c */
 710 extern struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
 711                                     struct ip_options *opt);
 712 extern __u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb,
 713                                      __u16 *mss);
 714
 715 /* tcp_output.c */
 716
 717 extern void __tcp_push_pending_frames(struct sock *sk, struct tcp_sock *tp,
 718                                       unsigned int cur_mss, int nonagle);
 719 extern int tcp_may_send_now(struct sock *sk, struct tcp_sock *tp);
 720 extern int tcp_retransmit_skb(struct sock *, struct sk_buff *);
 721 extern void tcp_xmit_retransmit_queue(struct sock *);
 722 extern void tcp_simple_retransmit(struct sock *);
 723 extern int tcp_trim_head(struct sock *, struct sk_buff *, u32);
 724
 725 extern void tcp_send_probe0(struct sock *);
 726 extern void tcp_send_partial(struct sock *);
 727 extern int  tcp_write_wakeup(struct sock *);
 728 extern void tcp_send_fin(struct sock *sk);
 729 extern void tcp_send_active_reset(struct sock *sk,
 730                                   unsigned int __nocast priority);
 731 extern int  tcp_send_synack(struct sock *);
 732 extern void tcp_push_one(struct sock *, unsigned int mss_now);
 733 extern void tcp_send_ack(struct sock *sk);
 734 extern void tcp_send_delayed_ack(struct sock *sk);
 735
 736 /* tcp_input.c */
 737 extern void tcp_cwnd_application_limited(struct sock *sk);
 738
 739 /* tcp_timer.c */
 740 extern void tcp_init_xmit_timers(struct sock *);
 741 extern void tcp_clear_xmit_timers(struct sock *);
 742
 743 extern void tcp_delete_keepalive_timer(struct sock *);
 744 extern void tcp_reset_keepalive_timer(struct sock *, unsigned long);
 745 extern unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu);
 746 extern unsigned int tcp_current_mss(struct sock *sk, int large);
 747
 748 #ifdef TCP_DEBUG
 749 extern const char tcp_timer_bug_msg[];
 750 #endif
 751
 752 /* tcp_diag.c */
 753 extern void tcp_get_info(struct sock *, struct tcp_info *);
 754
 755 /* Read 'sendfile()'-style from a TCP socket */
 756 typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *,
 757                                 unsigned int, size_t);
 758 extern int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
 759                          sk_read_actor_t recv_actor);
 760
 761 static inline void tcp_clear_xmit_timer(struct sock *sk, int what)
 762 {
 763         struct tcp_sock *tp = tcp_sk(sk);
 764
 765         switch (what) {
 766         case TCP_TIME_RETRANS:
 767         case TCP_TIME_PROBE0:
 768                 tp->pending = 0;
 769
 770 #ifdef TCP_CLEAR_TIMERS
 771                 sk_stop_timer(sk, &tp->retransmit_timer);
 772 #endif
 773                 break;
 774         case TCP_TIME_DACK:
 775                 tp->ack.blocked = 0;
 776                 tp->ack.pending = 0;
 777
 778 #ifdef TCP_CLEAR_TIMERS
 779                 sk_stop_timer(sk, &tp->delack_timer);
 780 #endif
 781                 break;
 782         default:
 783 #ifdef TCP_DEBUG
 784                 printk(tcp_timer_bug_msg);
 785 #endif
 786                 return;
 787         };
 788
 789 }
 790
 791 /*
 792  *      Reset the retransmission timer
 793  */
 794 static inline void tcp_reset_xmit_timer(struct sock *sk, int what, unsigned long when)
 795 {
 796         struct tcp_sock *tp = tcp_sk(sk);
 797
 798         if (when > TCP_RTO_MAX) {
 799 #ifdef TCP_DEBUG
 800                 printk(KERN_DEBUG "reset_xmit_timer sk=%p %d when=0x%lx, caller=%p\n", sk, what, when, current_text_addr());
 801 #endif
 802                 when = TCP_RTO_MAX;
 803         }
 804
 805         switch (what) {
 806         case TCP_TIME_RETRANS:
 807         case TCP_TIME_PROBE0:
 808                 tp->pending = what;
 809                 tp->timeout = jiffies+when;
 810                 sk_reset_timer(sk, &tp->retransmit_timer, tp->timeout);
 811                 break;
 812
 813         case TCP_TIME_DACK:
 814                 tp->ack.pending |= TCP_ACK_TIMER;
 815                 tp->ack.timeout = jiffies+when;
 816                 sk_reset_timer(sk, &tp->delack_timer, tp->ack.timeout);
 817                 break;
 818
 819         default:
 820 #ifdef TCP_DEBUG
 821                 printk(tcp_timer_bug_msg);
 822 #endif
 823                 return;
 824         };
 825 }
 826
 827 /* Initialize RCV_MSS value.
 828  * RCV_MSS is an our guess about MSS used by the peer.
 829  * We haven't any direct information about the MSS.
 830  * It's better to underestimate the RCV_MSS rather than overestimate.
 831  * Overestimations make us ACKing less frequently than needed.
 832  * Underestimations are more easy to detect and fix by tcp_measure_rcv_mss().
 833  */
 834
 835 static inline void tcp_initialize_rcv_mss(struct sock *sk)
 836 {
 837         struct tcp_sock *tp = tcp_sk(sk);
 838         unsigned int hint = min_t(unsigned int, tp->advmss, tp->mss_cache);
 839
 840         hint = min(hint, tp->rcv_wnd/2);
 841         hint = min(hint, TCP_MIN_RCVMSS);
 842         hint = max(hint, TCP_MIN_MSS);
 843
 844         tp->ack.rcv_mss = hint;
 845 }
 846
 847 static __inline__ void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)
 848 {
 849         tp->pred_flags = htonl((tp->tcp_header_len << 26) |
 850                                ntohl(TCP_FLAG_ACK) |
 851                                snd_wnd);
 852 }
 853
 854 static __inline__ void tcp_fast_path_on(struct tcp_sock *tp)
 855 {
 856         __tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale);
 857 }
 858
 859 static inline void tcp_fast_path_check(struct sock *sk, struct tcp_sock *tp)
 860 {
 861         if (skb_queue_empty(&tp->out_of_order_queue) &&
 862             tp->rcv_wnd &&
 863             atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf &&
 864             !tp->urg_data)
 865                 tcp_fast_path_on(tp);
 866 }
 867
 868 /* Compute the actual receive window we are currently advertising.
 869  * Rcv_nxt can be after the window if our peer push more data
 870  * than the offered window.
 871  */
 872 static __inline__ u32 tcp_receive_window(const struct tcp_sock *tp)
 873 {
 874         s32 win = tp->rcv_wup + tp->rcv_wnd - tp->rcv_nxt;
 875
 876         if (win < 0)
 877                 win = 0;
 878         return (u32) win;
 879 }
 880
 881 /* Choose a new window, without checks for shrinking, and without
 882  * scaling applied to the result.  The caller does these things
 883  * if necessary.  This is a "raw" window selection.
 884  */
 885 extern u32      __tcp_select_window(struct sock *sk);
 886
 887 /* TCP timestamps are only 32-bits, this causes a slight
 888  * complication on 64-bit systems since we store a snapshot
 889  * of jiffies in the buffer control blocks below.  We decidely
 890  * only use of the low 32-bits of jiffies and hide the ugly
 891  * casts with the following macro.
 892  */
 893 #define tcp_time_stamp          ((__u32)(jiffies))
 894
 895 /* This is what the send packet queueing engine uses to pass
 896  * TCP per-packet control information to the transmission
 897  * code.  We also store the host-order sequence numbers in
 898  * here too.  This is 36 bytes on 32-bit architectures,
 899  * 40 bytes on 64-bit machines, if this grows please adjust
 900  * skbuff.h:skbuff->cb[xxx] size appropriately.
 901  */
 902 struct tcp_skb_cb {
 903         union {
 904                 struct inet_skb_parm    h4;
 905 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
 906                 struct inet6_skb_parm   h6;
 907 #endif
 908         } header;       /* For incoming frames          */
 909         __u32           seq;            /* Starting sequence number     */
 910         __u32           end_seq;        /* SEQ + FIN + SYN + datalen    */
 911         __u32           when;           /* used to compute rtt's        */
 912         __u8            flags;          /* TCP header flags.            */
 913
 914         /* NOTE: These must match up to the flags byte in a
 915          *       real TCP header.
 916          */
 917 #define TCPCB_FLAG_FIN          0x01
 918 #define TCPCB_FLAG_SYN          0x02
 919 #define TCPCB_FLAG_RST          0x04
 920 #define TCPCB_FLAG_PSH          0x08
 921 #define TCPCB_FLAG_ACK          0x10
 922 #define TCPCB_FLAG_URG          0x20
 923 #define TCPCB_FLAG_ECE          0x40
 924 #define TCPCB_FLAG_CWR          0x80
 925
 926         __u8            sacked;         /* State flags for SACK/FACK.   */
 927 #define TCPCB_SACKED_ACKED      0x01    /* SKB ACK'd by a SACK block    */
 928 #define TCPCB_SACKED_RETRANS    0x02    /* SKB retransmitted            */
 929 #define TCPCB_LOST              0x04    /* SKB is lost                  */
 930 #define TCPCB_TAGBITS           0x07    /* All tag bits                 */
 931
 932 #define TCPCB_EVER_RETRANS      0x80    /* Ever retransmitted frame     */
 933 #define TCPCB_RETRANS           (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS)
 934
 935 #define TCPCB_URG               0x20    /* Urgent pointer advenced here */
 936
 937 #define TCPCB_AT_TAIL           (TCPCB_URG)
 938
 939         __u16           urg_ptr;        /* Valid w/URG flags is set.    */
 940         __u32           ack_seq;        /* Sequence number ACK'd        */
 941 };
 942
 943 #define TCP_SKB_CB(__skb)       ((struct tcp_skb_cb *)&((__skb)->cb[0]))
 944
 945 #include <net/tcp_ecn.h>
 946
 947 /* Due to TSO, an SKB can be composed of multiple actual
 948  * packets.  To keep these tracked properly, we use this.
 949  */
 950 static inline int tcp_skb_pcount(const struct sk_buff *skb)
 951 {
 952         return skb_shinfo(skb)->tso_segs;
 953 }
 954
 955 /* This is valid iff tcp_skb_pcount() > 1. */
 956 static inline int tcp_skb_mss(const struct sk_buff *skb)
 957 {
 958         return skb_shinfo(skb)->tso_size;
 959 }
 960
 961 static inline void tcp_dec_pcount_approx(__u32 *count,
 962                                          const struct sk_buff *skb)
 963 {
 964         if (*count) {
 965                 *count -= tcp_skb_pcount(skb);
 966                 if ((int)*count < 0)
 967                         *count = 0;
 968         }
 969 }
 970
 971 static inline void tcp_packets_out_inc(struct sock *sk,
 972                                        struct tcp_sock *tp,
 973                                        const struct sk_buff *skb)
 974 {
 975         int orig = tp->packets_out;
 976
 977         tp->packets_out += tcp_skb_pcount(skb);
 978         if (!orig)
 979                 tcp_reset_xmit_timer(sk, TCP_TIME_RETRANS, tp->rto);
 980 }
 981
 982 static inline void tcp_packets_out_dec(struct tcp_sock *tp,
 983                                        const struct sk_buff *skb)
 984 {
 985         tp->packets_out -= tcp_skb_pcount(skb);
 986 }
 987
 988 /* Events passed to congestion control interface */
 989 enum tcp_ca_event {
 990         CA_EVENT_TX_START,      /* first transmit when no packets in flight */
 991         CA_EVENT_CWND_RESTART,  /* congestion window restart */
 992         CA_EVENT_COMPLETE_CWR,  /* end of congestion recovery */
 993         CA_EVENT_FRTO,          /* fast recovery timeout */
 994         CA_EVENT_LOSS,          /* loss timeout */
 995         CA_EVENT_FAST_ACK,      /* in sequence ack */
 996         CA_EVENT_SLOW_ACK,      /* other ack */
 997 };
 998
 999 /*
1000  * Interface for adding new TCP congestion control handlers
1001  */
1002 #define TCP_CA_NAME_MAX 16
1003 struct tcp_congestion_ops {
1004         struct list_head        list;
1005
1006         /* initialize private data (optional) */
1007         void (*init)(struct tcp_sock *tp);
1008         /* cleanup private data  (optional) */
1009         void (*release)(struct tcp_sock *tp);
1010
1011         /* return slow start threshold (required) */
1012         u32 (*ssthresh)(struct tcp_sock *tp);
1013         /* lower bound for congestion window (optional) */
1014         u32 (*min_cwnd)(struct tcp_sock *tp);
1015         /* do new cwnd calculation (required) */
1016         void (*cong_avoid)(struct tcp_sock *tp, u32 ack,
1017                            u32 rtt, u32 in_flight, int good_ack);
1018         /* round trip time sample per acked packet (optional) */
1019         void (*rtt_sample)(struct tcp_sock *tp, u32 usrtt);
1020         /* call before changing ca_state (optional) */
1021         void (*set_state)(struct tcp_sock *tp, u8 new_state);
1022         /* call when cwnd event occurs (optional) */
1023         void (*cwnd_event)(struct tcp_sock *tp, enum tcp_ca_event ev);
1024         /* new value of cwnd after loss (optional) */
1025         u32  (*undo_cwnd)(struct tcp_sock *tp);
1026         /* hook for packet ack accounting (optional) */
1027         void (*pkts_acked)(struct tcp_sock *tp, u32 num_acked);
1028         /* get info for tcp_diag (optional) */
1029         void (*get_info)(struct tcp_sock *tp, u32 ext, struct sk_buff *skb);
1030
1031         char            name[TCP_CA_NAME_MAX];
1032         struct module   *owner;
1033 };
1034
1035 extern int tcp_register_congestion_control(struct tcp_congestion_ops *type);
1036 extern void tcp_unregister_congestion_control(struct tcp_congestion_ops *type);
1037
1038 extern void tcp_init_congestion_control(struct tcp_sock *tp);
1039 extern void tcp_cleanup_congestion_control(struct tcp_sock *tp);
1040 extern int tcp_set_default_congestion_control(const char *name);
1041 extern void tcp_get_default_congestion_control(char *name);
1042 extern int tcp_set_congestion_control(struct tcp_sock *tp, const char *name);
1043
1044 extern struct tcp_congestion_ops tcp_init_congestion_ops;
1045 extern u32 tcp_reno_ssthresh(struct tcp_sock *tp);
1046 extern void tcp_reno_cong_avoid(struct tcp_sock *tp, u32 ack,
1047                                 u32 rtt, u32 in_flight, int flag);
1048 extern u32 tcp_reno_min_cwnd(struct tcp_sock *tp);
1049 extern struct tcp_congestion_ops tcp_reno;
1050
1051 static inline void tcp_set_ca_state(struct tcp_sock *tp, u8 ca_state)
1052 {
1053         if (tp->ca_ops->set_state)
1054                 tp->ca_ops->set_state(tp, ca_state);
1055         tp->ca_state = ca_state;
1056 }
1057
1058 static inline void tcp_ca_event(struct tcp_sock *tp, enum tcp_ca_event event)
1059 {
1060         if (tp->ca_ops->cwnd_event)
1061                 tp->ca_ops->cwnd_event(tp, event);
1062 }
1063
1064 /* This determines how many packets are "in the network" to the best
1065  * of our knowledge.  In many cases it is conservative, but where
1066  * detailed information is available from the receiver (via SACK
1067  * blocks etc.) we can make more aggressive calculations.
1068  *
1069  * Use this for decisions involving congestion control, use just
1070  * tp->packets_out to determine if the send queue is empty or not.
1071  *
1072  * Read this equation as:
1073  *
1074  *      "Packets sent once on transmission queue" MINUS
1075  *      "Packets left network, but not honestly ACKed yet" PLUS
1076  *      "Packets fast retransmitted"
1077  */
1078 static __inline__ unsigned int tcp_packets_in_flight(const struct tcp_sock *tp)
1079 {
1080         return (tp->packets_out - tp->left_out + tp->retrans_out);
1081 }
1082
1083 /* If cwnd > ssthresh, we may raise ssthresh to be half-way to cwnd.
1084  * The exception is rate halving phase, when cwnd is decreasing towards
1085  * ssthresh.
1086  */
1087 static inline __u32 tcp_current_ssthresh(struct tcp_sock *tp)
1088 {
1089         if ((1<<tp->ca_state)&(TCPF_CA_CWR|TCPF_CA_Recovery))
1090                 return tp->snd_ssthresh;
1091         else
1092                 return max(tp->snd_ssthresh,
1093                            ((tp->snd_cwnd >> 1) +
1094                             (tp->snd_cwnd >> 2)));
1095 }
1096
1097 static inline void tcp_sync_left_out(struct tcp_sock *tp)
1098 {
1099         if (tp->rx_opt.sack_ok &&
1100             (tp->sacked_out >= tp->packets_out - tp->lost_out))
1101                 tp->sacked_out = tp->packets_out - tp->lost_out;
1102         tp->left_out = tp->sacked_out + tp->lost_out;
1103 }
1104
1105 /* Set slow start threshold and cwnd not falling to slow start */
1106 static inline void __tcp_enter_cwr(struct tcp_sock *tp)
1107 {
1108         tp->undo_marker = 0;
1109         tp->snd_ssthresh = tp->ca_ops->ssthresh(tp);
1110         tp->snd_cwnd = min(tp->snd_cwnd,
1111                            tcp_packets_in_flight(tp) + 1U);
1112         tp->snd_cwnd_cnt = 0;
1113         tp->high_seq = tp->snd_nxt;
1114         tp->snd_cwnd_stamp = tcp_time_stamp;
1115         TCP_ECN_queue_cwr(tp);
1116 }
1117
1118 static inline void tcp_enter_cwr(struct tcp_sock *tp)
1119 {
1120         tp->prior_ssthresh = 0;
1121         if (tp->ca_state < TCP_CA_CWR) {
1122                 __tcp_enter_cwr(tp);
1123                 tcp_set_ca_state(tp, TCP_CA_CWR);
1124         }
1125 }
1126
1127 extern __u32 tcp_init_cwnd(struct tcp_sock *tp, struct dst_entry *dst);
1128
1129 /* Slow start with delack produces 3 packets of burst, so that
1130  * it is safe "de facto".
1131  */
1132 static __inline__ __u32 tcp_max_burst(const struct tcp_sock *tp)
1133 {
1134         return 3;
1135 }
1136
1137 static __inline__ void tcp_minshall_update(struct tcp_sock *tp, int mss,
1138                                            const struct sk_buff *skb)
1139 {
1140         if (skb->len < mss)
1141                 tp->snd_sml = TCP_SKB_CB(skb)->end_seq;
1142 }
1143
1144 static __inline__ void tcp_check_probe_timer(struct sock *sk, struct tcp_sock *tp)
1145 {
1146         if (!tp->packets_out && !tp->pending)
1147                 tcp_reset_xmit_timer(sk, TCP_TIME_PROBE0, tp->rto);
1148 }
1149
1150 static __inline__ void tcp_push_pending_frames(struct sock *sk,
1151                                                struct tcp_sock *tp)
1152 {
1153         __tcp_push_pending_frames(sk, tp, tcp_current_mss(sk, 1), tp->nonagle);
1154 }
1155
1156 static __inline__ void tcp_init_wl(struct tcp_sock *tp, u32 ack, u32 seq)
1157 {
1158         tp->snd_wl1 = seq;
1159 }
1160
1161 static __inline__ void tcp_update_wl(struct tcp_sock *tp, u32 ack, u32 seq)
1162 {
1163         tp->snd_wl1 = seq;
1164 }
1165
1166 extern void tcp_destroy_sock(struct sock *sk);
1167
1168
1169 /*
1170  * Calculate(/check) TCP checksum
1171  */
1172 static __inline__ u16 tcp_v4_check(struct tcphdr *th, int len,
1173                                    unsigned long saddr, unsigned long daddr,
1174                                    unsigned long base)
1175 {
1176         return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base);
1177 }
1178
1179 static __inline__ int __tcp_checksum_complete(struct sk_buff *skb)
1180 {
1181         return (unsigned short)csum_fold(skb_checksum(skb, 0, skb->len, skb->csum));
1182 }
1183
1184 static __inline__ int tcp_checksum_complete(struct sk_buff *skb)
1185 {
1186         return skb->ip_summed != CHECKSUM_UNNECESSARY &&
1187                 __tcp_checksum_complete(skb);
1188 }
1189
1190 /* Prequeue for VJ style copy to user, combined with checksumming. */
1191
1192 static __inline__ void tcp_prequeue_init(struct tcp_sock *tp)
1193 {
1194         tp->ucopy.task = NULL;
1195         tp->ucopy.len = 0;
1196         tp->ucopy.memory = 0;
1197         skb_queue_head_init(&tp->ucopy.prequeue);
1198 }
1199
1200 /* Packet is added to VJ-style prequeue for processing in process
1201  * context, if a reader task is waiting. Apparently, this exciting
1202  * idea (VJ's mail "Re: query about TCP header on tcp-ip" of 07 Sep 93)
1203  * failed somewhere. Latency? Burstiness? Well, at least now we will
1204  * see, why it failed. 8)8)                               --ANK
1205  *
1206  * NOTE: is this not too big to inline?
1207  */
1208 static __inline__ int tcp_prequeue(struct sock *sk, struct sk_buff *skb)
1209 {
1210         struct tcp_sock *tp = tcp_sk(sk);
1211
1212         if (!sysctl_tcp_low_latency && tp->ucopy.task) {
1213                 __skb_queue_tail(&tp->ucopy.prequeue, skb);
1214                 tp->ucopy.memory += skb->truesize;
1215                 if (tp->ucopy.memory > sk->sk_rcvbuf) {
1216                         struct sk_buff *skb1;
1217
1218                         BUG_ON(sock_owned_by_user(sk));
1219
1220                         while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) {
1221                                 sk->sk_backlog_rcv(sk, skb1);
1222                                 NET_INC_STATS_BH(LINUX_MIB_TCPPREQUEUEDROPPED);
1223                         }
1224
1225                         tp->ucopy.memory = 0;
1226                 } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) {
1227                         wake_up_interruptible(sk->sk_sleep);
1228                         if (!tcp_ack_scheduled(tp))
1229                                 tcp_reset_xmit_timer(sk, TCP_TIME_DACK, (3*TCP_RTO_MIN)/4);
1230                 }
1231                 return 1;
1232         }
1233         return 0;
1234 }
1235
1236
1237 #undef STATE_TRACE
1238
1239 #ifdef STATE_TRACE
1240 static const char *statename[]={
1241         "Unused","Established","Syn Sent","Syn Recv",
1242         "Fin Wait 1","Fin Wait 2","Time Wait", "Close",
1243         "Close Wait","Last ACK","Listen","Closing"
1244 };
1245 #endif
1246
1247 static __inline__ void tcp_set_state(struct sock *sk, int state)
1248 {
1249         int oldstate = sk->sk_state;
1250
1251         switch (state) {
1252         case TCP_ESTABLISHED:
1253                 if (oldstate != TCP_ESTABLISHED)
1254                         TCP_INC_STATS(TCP_MIB_CURRESTAB);
1255                 break;
1256
1257         case TCP_CLOSE:
1258                 if (oldstate == TCP_CLOSE_WAIT || oldstate == TCP_ESTABLISHED)
1259                         TCP_INC_STATS(TCP_MIB_ESTABRESETS);
1260
1261                 sk->sk_prot->unhash(sk);
1262                 if (inet_sk(sk)->bind_hash &&
1263                     !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
1264                         inet_put_port(&tcp_hashinfo, sk);
1265                 /* fall through */
1266         default:
1267                 if (oldstate==TCP_ESTABLISHED)
1268                         TCP_DEC_STATS(TCP_MIB_CURRESTAB);
1269         }
1270
1271         /* Change state AFTER socket is unhashed to avoid closed
1272          * socket sitting in hash tables.
1273          */
1274         sk->sk_state = state;
1275
1276 #ifdef STATE_TRACE
1277         SOCK_DEBUG(sk, "TCP sk=%p, State %s -> %s\n",sk, statename[oldstate],statename[state]);
1278 #endif
1279 }
1280
1281 static __inline__ void tcp_done(struct sock *sk)
1282 {
1283         tcp_set_state(sk, TCP_CLOSE);
1284         tcp_clear_xmit_timers(sk);
1285
1286         sk->sk_shutdown = SHUTDOWN_MASK;
1287
1288         if (!sock_flag(sk, SOCK_DEAD))
1289                 sk->sk_state_change(sk);
1290         else
1291                 tcp_destroy_sock(sk);
1292 }
1293
1294 static __inline__ void tcp_sack_reset(struct tcp_options_received *rx_opt)
1295 {
1296         rx_opt->dsack = 0;
1297         rx_opt->eff_sacks = 0;
1298         rx_opt->num_sacks = 0;
1299 }
1300
1301 static __inline__ void tcp_build_and_update_options(__u32 *ptr, struct tcp_sock *tp, __u32 tstamp)
1302 {
1303         if (tp->rx_opt.tstamp_ok) {
1304                 *ptr++ = __constant_htonl((TCPOPT_NOP << 24) |
1305                                           (TCPOPT_NOP << 16) |
1306                                           (TCPOPT_TIMESTAMP << 8) |
1307                                           TCPOLEN_TIMESTAMP);
1308                 *ptr++ = htonl(tstamp);
1309                 *ptr++ = htonl(tp->rx_opt.ts_recent);
1310         }
1311         if (tp->rx_opt.eff_sacks) {
1312                 struct tcp_sack_block *sp = tp->rx_opt.dsack ? tp->duplicate_sack : tp->selective_acks;
1313                 int this_sack;
1314
1315                 *ptr++ = __constant_htonl((TCPOPT_NOP << 24) |
1316                                           (TCPOPT_NOP << 16) |
1317                                           (TCPOPT_SACK << 8) |
1318                                           (TCPOLEN_SACK_BASE +
1319                                            (tp->rx_opt.eff_sacks * TCPOLEN_SACK_PERBLOCK)));
1320                 for(this_sack = 0; this_sack < tp->rx_opt.eff_sacks; this_sack++) {
1321                         *ptr++ = htonl(sp[this_sack].start_seq);
1322                         *ptr++ = htonl(sp[this_sack].end_seq);
1323                 }
1324                 if (tp->rx_opt.dsack) {
1325                         tp->rx_opt.dsack = 0;
1326                         tp->rx_opt.eff_sacks--;
1327                 }
1328         }
1329 }
1330
1331 /* Construct a tcp options header for a SYN or SYN_ACK packet.
1332  * If this is every changed make sure to change the definition of
1333  * MAX_SYN_SIZE to match the new maximum number of options that you
1334  * can generate.
1335  */
1336 static inline void tcp_syn_build_options(__u32 *ptr, int mss, int ts, int sack,
1337                                              int offer_wscale, int wscale, __u32 tstamp, __u32 ts_recent)
1338 {
1339         /* We always get an MSS option.
1340          * The option bytes which will be seen in normal data
1341          * packets should timestamps be used, must be in the MSS
1342          * advertised.  But we subtract them from tp->mss_cache so
1343          * that calculations in tcp_sendmsg are simpler etc.
1344          * So account for this fact here if necessary.  If we
1345          * don't do this correctly, as a receiver we won't
1346          * recognize data packets as being full sized when we
1347          * should, and thus we won't abide by the delayed ACK
1348          * rules correctly.
1349          * SACKs don't matter, we never delay an ACK when we
1350          * have any of those going out.
1351          */
1352         *ptr++ = htonl((TCPOPT_MSS << 24) | (TCPOLEN_MSS << 16) | mss);
1353         if (ts) {
1354                 if(sack)
1355                         *ptr++ = __constant_htonl((TCPOPT_SACK_PERM << 24) | (TCPOLEN_SACK_PERM << 16) |
1356                                                   (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1357                 else
1358                         *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1359                                                   (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1360                 *ptr++ = htonl(tstamp);         /* TSVAL */
1361                 *ptr++ = htonl(ts_recent);      /* TSECR */
1362         } else if(sack)
1363                 *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1364                                           (TCPOPT_SACK_PERM << 8) | TCPOLEN_SACK_PERM);
1365         if (offer_wscale)
1366                 *ptr++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_WINDOW << 16) | (TCPOLEN_WINDOW << 8) | (wscale));
1367 }
1368
1369 /* Determine a window scaling and initial window to offer. */
1370 extern void tcp_select_initial_window(int __space, __u32 mss,
1371                                       __u32 *rcv_wnd, __u32 *window_clamp,
1372                                       int wscale_ok, __u8 *rcv_wscale);
1373
1374 static inline int tcp_win_from_space(int space)
1375 {
1376         return sysctl_tcp_adv_win_scale<=0 ?
1377                 (space>>(-sysctl_tcp_adv_win_scale)) :
1378                 space - (space>>sysctl_tcp_adv_win_scale);
1379 }
1380
1381 /* Note: caller must be prepared to deal with negative returns */
1382 static inline int tcp_space(const struct sock *sk)
1383 {
1384         return tcp_win_from_space(sk->sk_rcvbuf -
1385                                   atomic_read(&sk->sk_rmem_alloc));
1386 }
1387
1388 static inline int tcp_full_space(const struct sock *sk)
1389 {
1390         return tcp_win_from_space(sk->sk_rcvbuf);
1391 }
1392
1393 static inline void tcp_acceptq_queue(struct sock *sk, struct request_sock *req,
1394                                          struct sock *child)
1395 {
1396         reqsk_queue_add(&tcp_sk(sk)->accept_queue, req, sk, child);
1397 }
1398
1399 static inline void
1400 tcp_synq_removed(struct sock *sk, struct request_sock *req)
1401 {
1402         if (reqsk_queue_removed(&tcp_sk(sk)->accept_queue, req) == 0)
1403                 tcp_delete_keepalive_timer(sk);
1404 }
1405
1406 static inline void tcp_synq_added(struct sock *sk)
1407 {
1408         if (reqsk_queue_added(&tcp_sk(sk)->accept_queue) == 0)
1409                 tcp_reset_keepalive_timer(sk, TCP_TIMEOUT_INIT);
1410 }
1411
1412 static inline int tcp_synq_len(struct sock *sk)
1413 {
1414         return reqsk_queue_len(&tcp_sk(sk)->accept_queue);
1415 }
1416
1417 static inline int tcp_synq_young(struct sock *sk)
1418 {
1419         return reqsk_queue_len_young(&tcp_sk(sk)->accept_queue);
1420 }
1421
1422 static inline int tcp_synq_is_full(struct sock *sk)
1423 {
1424         return reqsk_queue_is_full(&tcp_sk(sk)->accept_queue);
1425 }
1426
1427 static inline void tcp_synq_unlink(struct tcp_sock *tp, struct request_sock *req,
1428                                    struct request_sock **prev)
1429 {
1430         reqsk_queue_unlink(&tp->accept_queue, req, prev);
1431 }
1432
1433 static inline void tcp_synq_drop(struct sock *sk, struct request_sock *req,
1434                                      struct request_sock **prev)
1435 {
1436         tcp_synq_unlink(tcp_sk(sk), req, prev);
1437         tcp_synq_removed(sk, req);
1438         reqsk_free(req);
1439 }
1440
1441 static __inline__ void tcp_openreq_init(struct request_sock *req,
1442                                         struct tcp_options_received *rx_opt,
1443                                         struct sk_buff *skb)
1444 {
1445         struct inet_request_sock *ireq = inet_rsk(req);
1446
1447         req->rcv_wnd = 0;               /* So that tcp_send_synack() knows! */
1448         tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq;
1449         req->mss = rx_opt->mss_clamp;
1450         req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0;
1451         ireq->tstamp_ok = rx_opt->tstamp_ok;
1452         ireq->sack_ok = rx_opt->sack_ok;
1453         ireq->snd_wscale = rx_opt->snd_wscale;
1454         ireq->wscale_ok = rx_opt->wscale_ok;
1455         ireq->acked = 0;
1456         ireq->ecn_ok = 0;
1457         ireq->rmt_port = skb->h.th->source;
1458 }
1459
1460 extern void tcp_enter_memory_pressure(void);
1461
1462 extern void tcp_listen_wlock(void);
1463
1464 /* - We may sleep inside this lock.
1465  * - If sleeping is not required (or called from BH),
1466  *   use plain read_(un)lock(&tcp_lhash_lock).
1467  */
1468
1469 static inline void tcp_listen_lock(void)
1470 {
1471         /* read_lock synchronizes to candidates to writers */
1472         read_lock(&tcp_lhash_lock);
1473         atomic_inc(&tcp_lhash_users);
1474         read_unlock(&tcp_lhash_lock);
1475 }
1476
1477 static inline void tcp_listen_unlock(void)
1478 {
1479         if (atomic_dec_and_test(&tcp_lhash_users))
1480                 wake_up(&tcp_lhash_wait);
1481 }
1482
1483 static inline int keepalive_intvl_when(const struct tcp_sock *tp)
1484 {
1485         return tp->keepalive_intvl ? : sysctl_tcp_keepalive_intvl;
1486 }
1487
1488 static inline int keepalive_time_when(const struct tcp_sock *tp)
1489 {
1490         return tp->keepalive_time ? : sysctl_tcp_keepalive_time;
1491 }
1492
1493 static inline int tcp_fin_time(const struct tcp_sock *tp)
1494 {
1495         int fin_timeout = tp->linger2 ? : sysctl_tcp_fin_timeout;
1496
1497         if (fin_timeout < (tp->rto<<2) - (tp->rto>>1))
1498                 fin_timeout = (tp->rto<<2) - (tp->rto>>1);
1499
1500         return fin_timeout;
1501 }
1502
1503 static inline int tcp_paws_check(const struct tcp_options_received *rx_opt, int rst)
1504 {
1505         if ((s32)(rx_opt->rcv_tsval - rx_opt->ts_recent) >= 0)
1506                 return 0;
1507         if (xtime.tv_sec >= rx_opt->ts_recent_stamp + TCP_PAWS_24DAYS)
1508                 return 0;
1509
1510         /* RST segments are not recommended to carry timestamp,
1511            and, if they do, it is recommended to ignore PAWS because
1512            "their cleanup function should take precedence over timestamps."
1513            Certainly, it is mistake. It is necessary to understand the reasons
1514            of this constraint to relax it: if peer reboots, clock may go
1515            out-of-sync and half-open connections will not be reset.
1516            Actually, the problem would be not existing if all
1517            the implementations followed draft about maintaining clock
1518            via reboots. Linux-2.2 DOES NOT!
1519
1520            However, we can relax time bounds for RST segments to MSL.
1521          */
1522         if (rst && xtime.tv_sec >= rx_opt->ts_recent_stamp + TCP_PAWS_MSL)
1523                 return 0;
1524         return 1;
1525 }
1526
1527 #define TCP_CHECK_TIMER(sk) do { } while (0)
1528
1529 static inline int tcp_use_frto(const struct sock *sk)
1530 {
1531         const struct tcp_sock *tp = tcp_sk(sk);
1532
1533         /* F-RTO must be activated in sysctl and there must be some
1534          * unsent new data, and the advertised window should allow
1535          * sending it.
1536          */
1537         return (sysctl_tcp_frto && sk->sk_send_head &&
1538                 !after(TCP_SKB_CB(sk->sk_send_head)->end_seq,
1539                        tp->snd_una + tp->snd_wnd));
1540 }
1541
1542 static inline void tcp_mib_init(void)
1543 {
1544         /* See RFC 2012 */
1545         TCP_ADD_STATS_USER(TCP_MIB_RTOALGORITHM, 1);
1546         TCP_ADD_STATS_USER(TCP_MIB_RTOMIN, TCP_RTO_MIN*1000/HZ);
1547         TCP_ADD_STATS_USER(TCP_MIB_RTOMAX, TCP_RTO_MAX*1000/HZ);
1548         TCP_ADD_STATS_USER(TCP_MIB_MAXCONN, -1);
1549 }
1550
1551 /* /proc */
1552 enum tcp_seq_states {
1553         TCP_SEQ_STATE_LISTENING,
1554         TCP_SEQ_STATE_OPENREQ,
1555         TCP_SEQ_STATE_ESTABLISHED,
1556         TCP_SEQ_STATE_TIME_WAIT,
1557 };
1558
1559 struct tcp_seq_afinfo {
1560         struct module           *owner;
1561         char                    *name;
1562         sa_family_t             family;
1563         int                     (*seq_show) (struct seq_file *m, void *v);
1564         struct file_operations  *seq_fops;
1565 };
1566
1567 struct tcp_iter_state {
1568         sa_family_t             family;
1569         enum tcp_seq_states     state;
1570         struct sock             *syn_wait_sk;
1571         int                     bucket, sbucket, num, uid;
1572         struct seq_operations   seq_ops;
1573 };
1574
1575 extern int tcp_proc_register(struct tcp_seq_afinfo *afinfo);
1576 extern void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo);
1577
1578 #endif  /* _TCP_H */