include/net/tcp.h

/* */
This source file includes following definitions.
before
after
between
min
max
tcp_init_seq
tcp_old_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 extern int tcp_new_window(struct sock *);
 196 
 197 /*
 198  * Return true if we should raise the window when we
 199  * have cleaned up the receive queue. We don't want to
 200  * do this normally, only if it makes sense to avoid
 201  * zero window probes..
 202  *
 203  * We do this only if we can raise the window noticeably.
 204  */
 205 static __inline__ int tcp_raise_window(struct sock * sk)
     /*  */
 206 {
 207         int new = tcp_new_window(sk);
 208         return new && (new >= 2*tcp_old_window(sk));
 209 }
 210 
 211 static __inline__ unsigned short tcp_select_window(struct sock *sk)
     /*  */
 212 {
 213         int window = tcp_new_window(sk);
 214 
 215         /* Don't allow a shrinking window */
 216         if (window > tcp_old_window(sk)) {
 217                 sk->window = window;
 218                 sk->lastwin_seq = sk->acked_seq;
 219         }
 220         return sk->window;
 221 }
 222 
 223 /*
 224  * List all states of a TCP socket that can be viewed as a "connected"
 225  * state.  This now includes TCP_SYN_RECV, although I am not yet fully
 226  * convinced that this is the solution for the 'getpeername(2)'
 227  * problem. Thanks to Stephen A. Wood <saw@cebaf.gov>  -FvK
 228  */
 229 
 230 extern __inline const int tcp_connected(const int state)
     /*  */
 231 {
 232   return(state == TCP_ESTABLISHED || state == TCP_CLOSE_WAIT ||
 233          state == TCP_FIN_WAIT1   || state == TCP_FIN_WAIT2 ||
 234          state == TCP_SYN_RECV);
 235 }
 236 
 237 /*
 238  * Calculate(/check) TCP checksum
 239  */
 240 static __inline__ u16 tcp_check(struct tcphdr *th, int len,
     /*  */
 241         unsigned long saddr, unsigned long daddr, unsigned long base)
 242 {
 243         return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base);
 244 }
 245 
 246 #undef STATE_TRACE
 247 
 248 #ifdef STATE_TRACE
 249 static char *statename[]={
 250         "Unused","Established","Syn Sent","Syn Recv",
 251         "Fin Wait 1","Fin Wait 2","Time Wait", "Close",
 252         "Close Wait","Last ACK","Listen","Closing"
 253 };
 254 #endif
 255 
 256 static __inline__ void tcp_set_state(struct sock *sk, int state)
     /*  */
 257 {
 258         int oldstate = sk->state;
 259 
 260         sk->state = state;
 261 
 262 #ifdef STATE_TRACE
 263         if(sk->debug)
 264                 printk("TCP sk=%p, State %s -> %s\n",sk, statename[oldstate],statename[state]);
 265 #endif  
 266 
 267         switch (state) {
 268         case TCP_ESTABLISHED:
 269                 if (oldstate != TCP_ESTABLISHED) {
 270                         tcp_statistics.TcpCurrEstab++;
 271                 }
 272                 break;
 273 
 274         case TCP_CLOSE:
 275                 tcp_cache_zap();
 276                 /* Should be about 2 rtt's */
 277                 reset_timer(sk, TIME_DONE, min(sk->rtt * 2, TCP_DONE_TIME));
 278                 /* fall through */
 279         default:
 280                 if (oldstate==TCP_ESTABLISHED)
 281                         tcp_statistics.TcpCurrEstab--;
 282         }
 283 }
 284 
 285 #endif  /* _TCP_H */
/* */
root/include/net/tcp.h

INCLUDED FROM

DEFINITIONS
