![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tcp.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / include / net|
Return to tcp.h CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / include / net |
1.1 ! root 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, <[email protected]> ! 11: * Fred N. van Kempen, <[email protected]> ! 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) ! 92: { ! 93: return (__s32)(seq1-seq2) < 0; ! 94: } ! 95: ! 96: extern __inline int after(__u32 seq1, __u32 seq2) ! 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) ! 104: { ! 105: return (after(seq1+1, seq2) && before(seq1, seq3+1)); ! 106: } ! 107: ! 108: static __inline__ int min(unsigned int a, unsigned int b) ! 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) ! 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: */ ! 183: ! 184: static __inline__ unsigned short tcp_raise_window(struct sock *sk) ! 185: { ! 186: long free_space = sock_rspace(sk); ! 187: long window; ! 188: ! 189: if (free_space > 1024) ! 190: free_space &= ~0x3FF; /* make free space a multiple of 1024 */ ! 191: ! 192: if(sk->window_clamp) ! 193: free_space = min(sk->window_clamp, free_space); ! 194: ! 195: /* ! 196: * compute the actual window i.e. ! 197: * old_window - received_bytes_on_that_win ! 198: */ ! 199: ! 200: window = sk->window - (sk->acked_seq - sk->lastwin_seq); ! 201: ! 202: if (sk->mss == 0) ! 203: sk->mss = sk->mtu; ! 204: ! 205: if ( window < 0 ) { ! 206: window = 0; ! 207: printk(KERN_DEBUG "TRW: win < 0 w=%d 1=%u 2=%u\n", ! 208: sk->window, sk->acked_seq, sk->lastwin_seq); ! 209: } ! 210: ! 211: if ( (free_space - window) >= min(sk->mss, MAX_WINDOW/2) ) ! 212: return ((free_space - window) / sk->mss) * sk->mss; ! 213: ! 214: return 0; ! 215: } ! 216: ! 217: static __inline__ unsigned short tcp_select_window(struct sock *sk) ! 218: { ! 219: long free_space = sock_rspace(sk); ! 220: long window; ! 221: ! 222: if (free_space > 1024) ! 223: free_space &= ~0x3FF; /* make free space a multiple of 1024 */ ! 224: ! 225: if (sk->window_clamp) ! 226: free_space = min(sk->window_clamp, free_space); ! 227: ! 228: /* ! 229: * compute the actual window i.e. ! 230: * old_window - received_bytes_on_that_win ! 231: */ ! 232: ! 233: if (sk->mss == 0) ! 234: sk->mss = sk->mtu; ! 235: ! 236: window = sk->window - (sk->acked_seq - sk->lastwin_seq); ! 237: ! 238: if ( window < 0 ) { ! 239: window = 0; ! 240: printk(KERN_DEBUG "TSW: win < 0 w=%d 1=%u 2=%u\n", ! 241: sk->window, sk->acked_seq, sk->lastwin_seq); ! 242: } ! 243: ! 244: /* ! 245: * RFC 1122: ! 246: * "the suggested [SWS] avoidance algoritm for the receiver is to keep ! 247: * RECV.NEXT + RCV.WIN fixed until: ! 248: * RCV.BUFF - RCV.USER - RCV.WINDOW >= min(1/2 RCV.BUFF, MSS)" ! 249: * ! 250: * i.e. don't raise the right edge of the window until you can't raise ! 251: * it MSS bytes ! 252: */ ! 253: ! 254: if ( (free_space - window) >= min(sk->mss, MAX_WINDOW/2) ) ! 255: window += ((free_space - window) / sk->mss) * sk->mss; ! 256: ! 257: sk->window = window; ! 258: sk->lastwin_seq = sk->acked_seq; ! 259: ! 260: return sk->window; ! 261: } ! 262: ! 263: /* ! 264: * List all states of a TCP socket that can be viewed as a "connected" ! 265: * state. This now includes TCP_SYN_RECV, although I am not yet fully ! 266: * convinced that this is the solution for the 'getpeername(2)' ! 267: * problem. Thanks to Stephen A. Wood <[email protected]> -FvK ! 268: */ ! 269: ! 270: extern __inline const int tcp_connected(const int state) ! 271: { ! 272: return(state == TCP_ESTABLISHED || state == TCP_CLOSE_WAIT || ! 273: state == TCP_FIN_WAIT1 || state == TCP_FIN_WAIT2 || ! 274: state == TCP_SYN_RECV); ! 275: } ! 276: ! 277: /* ! 278: * Calculate(/check) TCP checksum ! 279: */ ! 280: static __inline__ u16 tcp_check(struct tcphdr *th, int len, ! 281: unsigned long saddr, unsigned long daddr, unsigned long base) ! 282: { ! 283: return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base); ! 284: } ! 285: ! 286: #undef STATE_TRACE ! 287: ! 288: #ifdef STATE_TRACE ! 289: static char *statename[]={ ! 290: "Unused","Established","Syn Sent","Syn Recv", ! 291: "Fin Wait 1","Fin Wait 2","Time Wait", "Close", ! 292: "Close Wait","Last ACK","Listen","Closing" ! 293: }; ! 294: #endif ! 295: ! 296: static __inline__ void tcp_set_state(struct sock *sk, int state) ! 297: { ! 298: int oldstate = sk->state; ! 299: ! 300: sk->state = state; ! 301: ! 302: #ifdef STATE_TRACE ! 303: if(sk->debug) ! 304: printk("TCP sk=%p, State %s -> %s\n",sk, statename[oldstate],statename[state]); ! 305: #endif ! 306: ! 307: switch (state) { ! 308: case TCP_ESTABLISHED: ! 309: if (oldstate != TCP_ESTABLISHED) { ! 310: tcp_statistics.TcpCurrEstab++; ! 311: /* This is a hack but it doesn't occur often and it's going to ! 312: be a real to fix nicely */ ! 313: if (oldstate == TCP_SYN_RECV) ! 314: wake_up_interruptible(&master_select_wakeup); ! 315: } ! 316: break; ! 317: ! 318: case TCP_CLOSE: ! 319: tcp_cache_zap(); ! 320: /* Should be about 2 rtt's */ ! 321: reset_timer(sk, TIME_DONE, min(sk->rtt * 2, TCP_DONE_TIME)); ! 322: /* fall through */ ! 323: default: ! 324: if (oldstate==TCP_ESTABLISHED) ! 325: tcp_statistics.TcpCurrEstab--; ! 326: } ! 327: } ! 328: ! 329: #endif /* _TCP_H */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.