include/net/tcp.h

/* */
This source file includes following definitions.
before
after
between
min
max
tcp_init_seq
tcp_old_window
tcp_new_window
tcp_raise_window
tcp_select_window
tcp_connected
tcp_check
tcp_set_state
   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, <bir7@leland.Stanford.Edu>
  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 #include <linux/tcp.h>
  22 #include <net/checksum.h>
  23 
  24 /*
  25  * 40 is maximal IP options size
  26  * 4  is TCP option size (MSS)
  27  */
  28 #define MAX_SYN_SIZE    (sizeof(struct iphdr) + 40 + sizeof(struct tcphdr) + 4 + MAX_HEADER + 15)
  29 #define MAX_FIN_SIZE    (sizeof(struct iphdr) + 40 + sizeof(struct tcphdr) + MAX_HEADER + 15)
  30 #define MAX_ACK_SIZE    (sizeof(struct iphdr) + 40 + sizeof(struct tcphdr) + MAX_HEADER + 15)
  31 #define MAX_RESET_SIZE  (sizeof(struct iphdr) + 40 + sizeof(struct tcphdr) + MAX_HEADER + 15)
  32 
  33 #define MAX_WINDOW      32767           /* Never offer a window over 32767 without using
  34                                            window scaling (not yet supported). Some poor
  35                                            stacks do signed 16bit maths! */
  36 #define MIN_WINDOW      2048
  37 #define MAX_ACK_BACKLOG 2
  38 #define MAX_DUP_ACKS    2
  39 #define MIN_WRITE_SPACE 2048
  40 #define TCP_WINDOW_DIFF 2048
  41 
  42 /* urg_data states */
  43 #define URG_VALID       0x0100
  44 #define URG_NOTYET      0x0200
  45 #define URG_READ        0x0400
  46 
  47 #define TCP_RETR1       7       /*
  48                                  * This is how many retries it does before it
  49                                  * tries to figure out if the gateway is
  50                                  * down.
  51                                  */
  52 
  53 #define TCP_RETR2       15      /*
  54                                  * This should take at least
  55                                  * 90 minutes to time out.
  56                                  */
  57 
  58 #define TCP_TIMEOUT_LEN (15*60*HZ) /* should be about 15 mins           */
  59 #define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to successfully 
  60                                   * close the socket, about 60 seconds  */
  61 #define TCP_FIN_TIMEOUT (3*60*HZ) /* BSD style FIN_WAIT2 deadlock breaker */                              
  62 #define TCP_ACK_TIME    (3*HZ)  /* time to delay before sending an ACK  */
  63 #define TCP_DONE_TIME   (5*HZ/2)/* maximum time to wait before actually
  64                                  * destroying a socket                  */
  65 #define TCP_WRITE_TIME  (30*HZ) /* initial time to wait for an ACK,
  66                                  * after last transmit                  */
  67 #define TCP_TIMEOUT_INIT (3*HZ) /* RFC 1122 initial timeout value       */
  68 #define TCP_SYN_RETRIES  10     /* number of times to retry opening a
  69                                  * connection   (TCP_RETR2-....)        */
  70 #define TCP_PROBEWAIT_LEN (1*HZ)/* time to wait between probes when
  71                                  * I've got something to write and
  72                                  * there is no window                   */
  73 
  74 #define TCP_NO_CHECK    0       /* turn to one if you want the default
  75                                  * to be no checksum                    */
  76 
  77 
  78 /*
  79  *      TCP option
  80  */
  81  
  82 #define TCPOPT_NOP              1       /* Padding */
  83 #define TCPOPT_EOL              0       /* End of options */
  84 #define TCPOPT_MSS              2       /* Segment size negotiating */
  85 /*
  86  *      We don't use these yet, but they are for PAWS and big windows
  87  */
  88 #define TCPOPT_WINDOW           3       /* Window scaling */
  89 #define TCPOPT_TIMESTAMP        8       /* Better RTT estimations/PAWS */
  90 
  91 
  92 /*
  93  * The next routines deal with comparing 32 bit unsigned ints
  94  * and worry about wraparound (automatic with unsigned arithmetic).
  95  */
  96 
  97 extern __inline int before(__u32 seq1, __u32 seq2)
     /*  */
  98 {
  99         return (__s32)(seq1-seq2) < 0;
 100 }
 101 
 102 extern __inline int after(__u32 seq1, __u32 seq2)
     /*  */
 103 {
 104         return (__s32)(seq2-seq1) < 0;
 105 }
 106 
 107 
 108 /* is s2<=s1<=s3 ? */
 109 extern __inline int between(__u32 seq1, __u32 seq2, __u32 seq3)
     /*  */
 110 {
 111         return (after(seq1+1, seq2) && before(seq1, seq3+1));
 112 }
 113 
 114 static __inline__ int min(unsigned int a, unsigned int b)
     /*  */
 115 {
 116         if (a > b)
 117                 a = b;
 118         return a;
 119 }
 120 
 121 static __inline__ int max(unsigned int a, unsigned int b)
     /*  */
 122 {
 123         if (a < b)
 124                 a = b;
 125         return a;
 126 }
 127 
 128 extern struct proto tcp_prot;
 129 extern struct tcp_mib tcp_statistics;
 130 
 131 extern void     tcp_err(int type, int code, unsigned char *header, __u32 daddr,
 132                         __u32, struct inet_protocol *protocol);
 133 extern void     tcp_shutdown (struct sock *sk, int how);
 134 extern int      tcp_rcv(struct sk_buff *skb, struct device *dev,
 135                         struct options *opt, __u32 daddr,
 136                         unsigned short len, __u32 saddr, int redo,
 137                         struct inet_protocol *protocol);
 138 
 139 extern int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg);
 140 
 141 extern void tcp_read_wakeup(struct sock *);
 142 extern void tcp_write_xmit(struct sock *);
 143 extern void tcp_time_wait(struct sock *);
 144 extern void tcp_retransmit(struct sock *, int);
 145 extern void tcp_do_retransmit(struct sock *, int);
 146 extern void tcp_send_check(struct tcphdr *th, unsigned long saddr, 
 147                 unsigned long daddr, int len, struct sk_buff *skb);
 148 
 149 /* tcp_output.c */
 150 
 151 extern void tcp_send_probe0(struct sock *);
 152 extern void tcp_send_partial(struct sock *);
 153 extern void tcp_write_wakeup(struct sock *);
 154 extern void tcp_send_fin(struct sock *sk);
 155 extern void tcp_send_synack(struct sock *, struct sock *, struct sk_buff *);
 156 extern void tcp_send_skb(struct sock *, struct sk_buff *);
 157 extern void tcp_send_ack(struct sock *sk);
 158 extern void tcp_send_delayed_ack(struct sock *sk, int timeout);
 159 extern void tcp_send_reset(unsigned long saddr, unsigned long daddr, struct tcphdr *th,
 160           struct proto *prot, struct options *opt, struct device *dev, int tos, int ttl);
 161 
 162 extern void tcp_enqueue_partial(struct sk_buff *, struct sock *);
 163 extern struct sk_buff * tcp_dequeue_partial(struct sock *);
 164 
 165 /* tcp_input.c */
 166 extern void tcp_cache_zap(void);
 167 
 168 /* tcp_timer.c */
 169 #define     tcp_reset_msl_timer(x,y,z)  reset_timer(x,y,z)
 170 extern void tcp_reset_xmit_timer(struct sock *, int, unsigned long);
 171 extern void tcp_delack_timer(unsigned long);
 172 extern void tcp_retransmit_timer(unsigned long);
 173 
 174 /*
 175  *      Default sequence number picking algorithm.
 176  *      As close as possible to RFC 793, which
 177  *      suggests using a 250kHz clock.
 178  *      Further reading shows this assumes 2MB/s networks.
 179  *      For 10MB/s ethernet, a 1MHz clock is appropriate.
 180  *      That's funny, Linux has one built in!  Use it!
 181  */
 182 
 183 static inline u32 tcp_init_seq(void)
     /*  */
 184 {
 185         struct timeval tv;
 186         do_gettimeofday(&tv);
 187         return tv.tv_usec+tv.tv_sec*1000000;
 188 }
 189 
 190 static __inline__ int tcp_old_window(struct sock * sk)
     /*  */
 191 {
 192         return sk->window - (sk->acked_seq - sk->lastwin_seq);
 193 }
 194 
 195 static __inline__ int tcp_new_window(struct sock * sk)
     /*  */
 196 {
 197         int window = sock_rspace(sk);
 198 
 199         if (window > 1024)
 200                 window &= ~0x3FF;       /* make free space a multiple of 1024 */
 201 
 202         if (sk->window_clamp && sk->window_clamp < window)
 203                 window = sk->window_clamp;
 204 
 205         /*
 206          * RFC 1122 says:
 207          *
 208          * "the suggested [SWS] avoidance algorithm for the receiver is to keep
 209          *  RECV.NEXT + RCV.WIN fixed until:
 210          *  RCV.BUFF - RCV.USER - RCV.WINDOW >= min(1/2 RCV.BUFF, MSS)"
 211          *
 212          * Experiments against BSD and Solaris machines show that following
 213          * these rules results in the BSD and Solaris machines making very
 214          * bad guesses about how much data they can have in flight.
 215          *
 216          * Instead we follow the BSD lead and offer a window that gives
 217          * the size of the current free space, truncated to a multiple
 218          * of 1024 bytes. If the window is smaller than
 219          *      min(sk->mss, MAX_WINDOW/2)
 220          * then we advertise the window as having size 0, unless this
 221          * would shrink the window we offered last time.
 222          * This results in as much as double the throughput as the original
 223          * implementation.
 224          */
 225 
 226         if (sk->mss == 0)
 227                 sk->mss = sk->mtu;
 228 
 229         /* BSD style SWS avoidance
 230          * Note that RFC1122 only says we must do silly window avoidance,
 231          * it does not require that we use the suggested algorithm.
 232          */
 233 
 234         if (window < min(sk->mss, MAX_WINDOW/2))
 235                 window = 0;
 236 
 237         return window;
 238 }
 239 
 240 /*
 241  * Return true if we should raise the window when we
 242  * have cleaned up the receive queue. We don't want to
 243  * do this normally, only if it makes sense to avoid
 244  * zero window probes..
 245  *
 246  * We do this only if we can raise the window noticeably.
 247  */
 248 static __inline__ int tcp_raise_window(struct sock * sk)
     /*  */
 249 {
 250         return tcp_new_window(sk) >= 2*tcp_old_window(sk);
 251 }
 252 
 253 static __inline__ unsigned short tcp_select_window(struct sock *sk)
     /*  */
 254 {
 255         int window = tcp_new_window(sk);
 256 
 257         /* Don't allow a shrinking window */
 258         if (window > tcp_old_window(sk)) {
 259                 sk->window = window;
 260                 sk->lastwin_seq = sk->acked_seq;
 261         }
 262         return sk->window;
 263 }
 264 
 265 /*
 266  * List all states of a TCP socket that can be viewed as a "connected"
 267  * state.  This now includes TCP_SYN_RECV, although I am not yet fully
 268  * convinced that this is the solution for the 'getpeername(2)'
 269  * problem. Thanks to Stephen A. Wood <saw@cebaf.gov>  -FvK
 270  */
 271 
 272 extern __inline const int tcp_connected(const int state)
     /*  */
 273 {
 274   return(state == TCP_ESTABLISHED || state == TCP_CLOSE_WAIT ||
 275          state == TCP_FIN_WAIT1   || state == TCP_FIN_WAIT2 ||
 276          state == TCP_SYN_RECV);
 277 }
 278 
 279 /*
 280  * Calculate(/check) TCP checksum
 281  */
 282 static __inline__ u16 tcp_check(struct tcphdr *th, int len,
     /*  */
 283         unsigned long saddr, unsigned long daddr, unsigned long base)
 284 {
 285         return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base);
 286 }
 287 
 288 #undef STATE_TRACE
 289 
 290 #ifdef STATE_TRACE
 291 static char *statename[]={
 292         "Unused","Established","Syn Sent","Syn Recv",
 293         "Fin Wait 1","Fin Wait 2","Time Wait", "Close",
 294         "Close Wait","Last ACK","Listen","Closing"
 295 };
 296 #endif
 297 
 298 static __inline__ void tcp_set_state(struct sock *sk, int state)
     /*  */
 299 {
 300         int oldstate = sk->state;
 301 
 302         sk->state = state;
 303 
 304 #ifdef STATE_TRACE
 305         if(sk->debug)
 306                 printk("TCP sk=%p, State %s -> %s\n",sk, statename[oldstate],statename[state]);
 307 #endif  
 308 
 309         switch (state) {
 310         case TCP_ESTABLISHED:
 311                 if (oldstate != TCP_ESTABLISHED) {
 312                         tcp_statistics.TcpCurrEstab++;
 313                 }
 314                 break;
 315 
 316         case TCP_CLOSE:
 317                 tcp_cache_zap();
 318                 /* Should be about 2 rtt's */
 319                 reset_timer(sk, TIME_DONE, min(sk->rtt * 2, TCP_DONE_TIME));
 320                 /* fall through */
 321         default:
 322                 if (oldstate==TCP_ESTABLISHED)
 323                         tcp_statistics.TcpCurrEstab--;
 324         }
 325 }
 326 
 327 #endif  /* _TCP_H */
/* */
root/include/net/tcp.h

INCLUDED FROM

DEFINITIONS
