![[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 / linux / src / include / net|
Return to tcp.h CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / 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: /* This is for all connections with a full identity, no wildcards. */
25: #define TCP_HTABLE_SIZE 256
26:
27: /* This is for listening sockets, thus all sockets which possess wildcards. */
28: #define TCP_LHTABLE_SIZE 32 /* Yes, really, this is all you need. */
29:
30: /* This is for all sockets, to keep track of the local port allocations. */
31: #define TCP_BHTABLE_SIZE 64
32:
33: /* tcp_ipv4.c: These need to be shared by v4 and v6 because the lookup
34: * and hashing code needs to work with different AF's yet
35: * the port space is shared.
36: */
37: extern struct sock *tcp_established_hash[TCP_HTABLE_SIZE];
38: extern struct sock *tcp_listening_hash[TCP_LHTABLE_SIZE];
39: extern struct sock *tcp_bound_hash[TCP_BHTABLE_SIZE];
40:
41: /* These are AF independant. */
42: static __inline__ int tcp_bhashfn(__u16 lport)
43: {
44: return (lport ^ (lport >> 7)) & (TCP_BHTABLE_SIZE-1);
45: }
46:
47: /* Find the next port that hashes h that is larger than lport.
48: * If you change the hash, change this function to match, or you will
49: * break TCP port selection. This function must also NOT wrap around
50: * when the next number exceeds the largest possible port (2^16-1).
51: */
52: static __inline__ int tcp_bhashnext(__u16 lport, __u16 h)
53: {
54: __u32 s; /* don't change this to a smaller type! */
55:
56: s = (lport ^ (h ^ tcp_bhashfn(lport)));
57: if (s > lport)
58: return s;
59: s = lport + TCP_BHTABLE_SIZE;
60: return (s ^ (h ^ tcp_bhashfn(s)));
61: }
62:
63: static __inline__ int tcp_sk_bhashfn(struct sock *sk)
64: {
65: __u16 lport = sk->num;
66: return tcp_bhashfn(lport);
67: }
68:
69: /* These can have wildcards, don't try too hard.
70: * XXX deal with thousands of IP aliases for listening ports later
71: */
72: static __inline__ int tcp_lhashfn(unsigned short num)
73: {
74: return num & (TCP_LHTABLE_SIZE - 1);
75: }
76:
77: static __inline__ int tcp_sk_listen_hashfn(struct sock *sk)
78: {
79: return tcp_lhashfn(sk->num);
80: }
81:
82: /* This is IPv4 specific. */
83: static __inline__ int tcp_hashfn(__u32 laddr, __u16 lport,
84: __u32 faddr, __u16 fport)
85: {
86: return ((laddr ^ lport) ^ (faddr ^ fport)) & (TCP_HTABLE_SIZE - 1);
87: }
88:
89: static __inline__ int tcp_sk_hashfn(struct sock *sk)
90: {
91: __u32 laddr = sk->rcv_saddr;
92: __u16 lport = sk->num;
93: __u32 faddr = sk->daddr;
94: __u16 fport = sk->dummy_th.dest;
95:
96: return tcp_hashfn(laddr, lport, faddr, fport);
97: }
98:
99: /* Only those holding the sockhash lock call these two things here.
100: * Note the slightly gross overloading of sk->prev, AF_UNIX is the
101: * only other main benefactor of that member of SK, so who cares.
102: */
103: static __inline__ void tcp_sk_bindify(struct sock *sk)
104: {
105: int hashent = tcp_sk_bhashfn(sk);
106: struct sock **htable = &tcp_bound_hash[hashent];
107:
108: if((sk->bind_next = *htable) != NULL)
109: (*htable)->bind_pprev = &sk->bind_next;
110: *htable = sk;
111: sk->bind_pprev = htable;
112: }
113:
114: static __inline__ void tcp_sk_unbindify(struct sock *sk)
115: {
116: if(sk->bind_next)
117: sk->bind_next->bind_pprev = sk->bind_pprev;
118: *(sk->bind_pprev) = sk->bind_next;
119: }
120:
121: /*
122: * 40 is maximal IP options size
123: * 4 is TCP option size (MSS)
124: */
125: #define MAX_SYN_SIZE (sizeof(struct iphdr) + 40 + sizeof(struct tcphdr) + 4 + MAX_HEADER + 15)
126: #define MAX_FIN_SIZE (sizeof(struct iphdr) + 40 + sizeof(struct tcphdr) + MAX_HEADER + 15)
127: #define MAX_ACK_SIZE (sizeof(struct iphdr) + 40 + sizeof(struct tcphdr) + MAX_HEADER + 15)
128: #define MAX_RESET_SIZE (sizeof(struct iphdr) + 40 + sizeof(struct tcphdr) + MAX_HEADER + 15)
129:
130: #define MAX_WINDOW 32767 /* Never offer a window over 32767 without using
131: window scaling (not yet supported). Some poor
132: stacks do signed 16bit maths! */
133: #define MIN_WINDOW 2048
134: #define MAX_ACK_BACKLOG 2
135: #define MAX_DUP_ACKS 3
136: #define MIN_WRITE_SPACE 2048
137: #define TCP_WINDOW_DIFF 2048
138:
139: /* urg_data states */
140: #define URG_VALID 0x0100
141: #define URG_NOTYET 0x0200
142: #define URG_READ 0x0400
143:
144: #define TCP_RETR1 7 /*
145: * This is how many retries it does before it
146: * tries to figure out if the gateway is
147: * down.
148: */
149:
150: #define TCP_RETR2 15 /*
151: * This should take at least
152: * 90 minutes to time out.
153: */
154:
155: #define TCP_TIMEOUT_LEN (15*60*HZ) /* should be about 15 mins */
156: #define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to successfully
157: * close the socket, about 60 seconds */
158: #define TCP_FIN_TIMEOUT (3*60*HZ) /* BSD style FIN_WAIT2 deadlock breaker */
159: #define TCP_ACK_TIME (3*HZ) /* time to delay before sending an ACK */
160: #define TCP_DONE_TIME (5*HZ/2)/* maximum time to wait before actually
161: * destroying a socket */
162: #define TCP_WRITE_TIME (30*HZ) /* initial time to wait for an ACK,
163: * after last transmit */
164: #define TCP_TIMEOUT_INIT (3*HZ) /* RFC 1122 initial timeout value */
165: #define TCP_SYN_RETRIES 5 /* number of times to retry opening a
166: * connection (TCP_RETR2-....) */
167: #define TCP_PROBEWAIT_LEN (1*HZ)/* time to wait between probes when
168: * I've got something to write and
169: * there is no window */
170:
171: #define TCP_NO_CHECK 0 /* turn to one if you want the default
172: * to be no checksum */
173:
174:
175: /*
176: * TCP option
177: */
178:
179: #define TCPOPT_NOP 1 /* Padding */
180: #define TCPOPT_EOL 0 /* End of options */
181: #define TCPOPT_MSS 2 /* Segment size negotiating */
182: /*
183: * We don't use these yet, but they are for PAWS and big windows
184: */
185: #define TCPOPT_WINDOW 3 /* Window scaling */
186: #define TCPOPT_TIMESTAMP 8 /* Better RTT estimations/PAWS */
187:
188:
189: /*
190: * The next routines deal with comparing 32 bit unsigned ints
191: * and worry about wraparound (automatic with unsigned arithmetic).
192: */
193:
194: extern __inline int before(__u32 seq1, __u32 seq2)
195: {
196: return (__s32)(seq1-seq2) < 0;
197: }
198:
199: extern __inline int after(__u32 seq1, __u32 seq2)
200: {
201: return (__s32)(seq2-seq1) < 0;
202: }
203:
204:
205: /* is s2<=s1<=s3 ? */
206: extern __inline int between(__u32 seq1, __u32 seq2, __u32 seq3)
207: {
208: return (after(seq1+1, seq2) && before(seq1, seq3+1));
209: }
210:
211: static __inline__ int min(unsigned int a, unsigned int b)
212: {
213: if (a > b)
214: a = b;
215: return a;
216: }
217:
218: static __inline__ int max(unsigned int a, unsigned int b)
219: {
220: if (a < b)
221: a = b;
222: return a;
223: }
224:
225: extern struct proto tcp_prot;
226: extern struct tcp_mib tcp_statistics;
227:
228: extern unsigned short tcp_good_socknum(void);
229:
230: extern void tcp_err(int type, int code, unsigned char *header, __u32 daddr,
231: __u32, struct inet_protocol *protocol, int len);
232: extern void tcp_shutdown (struct sock *sk, int how);
233: extern int tcp_rcv(struct sk_buff *skb, struct device *dev,
234: struct options *opt, __u32 daddr,
235: unsigned short len, __u32 saddr, int redo,
236: struct inet_protocol *protocol);
237:
238: extern int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg);
239:
240: extern void tcp_v4_unhash(struct sock *sk);
241:
242: extern void tcp_read_wakeup(struct sock *);
243: extern void tcp_write_xmit(struct sock *);
244: extern void tcp_time_wait(struct sock *);
245: extern void tcp_retransmit(struct sock *, int);
246: extern void tcp_do_retransmit(struct sock *, int);
247: extern void tcp_send_check(struct tcphdr *th, unsigned long saddr,
248: unsigned long daddr, int len, struct sk_buff *skb);
249:
250: /* tcp_output.c */
251:
252: extern void tcp_send_probe0(struct sock *);
253: extern void tcp_send_partial(struct sock *);
254: extern void tcp_write_wakeup(struct sock *);
255: extern void tcp_send_fin(struct sock *sk);
256: extern void tcp_send_synack(struct sock *, struct sock *, struct sk_buff *, int);
257: extern void tcp_send_skb(struct sock *, struct sk_buff *);
258: extern void tcp_send_ack(struct sock *sk);
259: extern void tcp_send_delayed_ack(struct sock *sk, int max_timeout, unsigned long timeout);
260: extern void tcp_send_reset(unsigned long saddr, unsigned long daddr, struct tcphdr *th,
261: struct proto *prot, struct options *opt, struct device *dev, int tos, int ttl);
262:
263: extern void tcp_enqueue_partial(struct sk_buff *, struct sock *);
264: extern struct sk_buff * tcp_dequeue_partial(struct sock *);
265: extern void tcp_shrink_skb(struct sock *,struct sk_buff *,u32);
266:
267: /* CONFIG_IP_TRANSPARENT_PROXY */
268: extern int tcp_chkaddr(struct sk_buff *);
269:
270: /* tcp_timer.c */
271: #define tcp_reset_msl_timer(x,y,z) reset_timer(x,y,z)
272: extern void tcp_reset_xmit_timer(struct sock *, int, unsigned long);
273: extern void tcp_delack_timer(unsigned long);
274: extern void tcp_retransmit_timer(unsigned long);
275:
276: static __inline__ int tcp_old_window(struct sock * sk)
277: {
278: return sk->window - (sk->acked_seq - sk->lastwin_seq);
279: }
280:
281: extern int tcp_new_window(struct sock *);
282:
283: /*
284: * Return true if we should raise the window when we
285: * have cleaned up the receive queue. We don't want to
286: * do this normally, only if it makes sense to avoid
287: * zero window probes..
288: *
289: * We do this only if we can raise the window noticeably.
290: */
291: static __inline__ int tcp_raise_window(struct sock * sk)
292: {
293: int new = tcp_new_window(sk);
294: return new && (new >= 2*tcp_old_window(sk));
295: }
296:
297: static __inline__ unsigned short tcp_select_window(struct sock *sk)
298: {
299: int window = tcp_new_window(sk);
300: int oldwin = tcp_old_window(sk);
301:
302: /* Don't allow a shrinking window */
303: if (window > oldwin) {
304: sk->window = window;
305: sk->lastwin_seq = sk->acked_seq;
306: oldwin = window;
307: }
308: return oldwin;
309: }
310:
311: /*
312: * List all states of a TCP socket that can be viewed as a "connected"
313: * state. This now includes TCP_SYN_RECV, although I am not yet fully
314: * convinced that this is the solution for the 'getpeername(2)'
315: * problem. Thanks to Stephen A. Wood <[email protected]> -FvK
316: */
317:
318: extern __inline const int tcp_connected(const int state)
319: {
320: return(state == TCP_ESTABLISHED || state == TCP_CLOSE_WAIT ||
321: state == TCP_FIN_WAIT1 || state == TCP_FIN_WAIT2 ||
322: state == TCP_SYN_RECV);
323: }
324:
325: /*
326: * Calculate(/check) TCP checksum
327: */
328: static __inline__ u16 tcp_check(struct tcphdr *th, int len,
329: unsigned long saddr, unsigned long daddr, unsigned long base)
330: {
331: return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base);
332: }
333:
334: #undef STATE_TRACE
335:
336: #ifdef STATE_TRACE
337: static char *statename[]={
338: "Unused","Established","Syn Sent","Syn Recv",
339: "Fin Wait 1","Fin Wait 2","Time Wait", "Close",
340: "Close Wait","Last ACK","Listen","Closing"
341: };
342: #endif
343:
344: static __inline__ void tcp_set_state(struct sock *sk, int state)
345: {
346: int oldstate = sk->state;
347:
348: sk->state = state;
349:
350: #ifdef STATE_TRACE
351: if(sk->debug)
352: printk("TCP sk=%p, State %s -> %s\n",sk, statename[oldstate],statename[state]);
353: #endif
354:
355: switch (state) {
356: case TCP_ESTABLISHED:
357: if (oldstate != TCP_ESTABLISHED) {
358: tcp_statistics.TcpCurrEstab++;
359: }
360: break;
361:
362: case TCP_CLOSE:
363: /* Preserve the invariant */
364: tcp_v4_unhash(sk);
365: /* Should be about 2 rtt's */
366: reset_timer(sk, TIME_DONE, min(sk->rtt * 2, TCP_DONE_TIME));
367: /* fall through */
368: default:
369: if (oldstate==TCP_ESTABLISHED)
370: tcp_statistics.TcpCurrEstab--;
371: }
372: }
373:
374: #endif /* _TCP_H */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.