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

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