root/include/net/tcp.h

/* [previous][next][first][last][top][bottom][index][help] */

INCLUDED FROM


DEFINITIONS

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

/* [previous][next][first][last][top][bottom][index][help] */