d927d24117d411b6c3d094bf6b6ca0738b13e4c3
[people/holger/gpxe.git] / src / include / gpxe / tcp.h
1 #ifndef _GPXE_TCP_H
2 #define _GPXE_TCP_H
3
4 /** @file
5  *
6  * TCP protocol
7  *
8  * This file defines the gPXE TCP API.
9  *
10  */
11
12 #include "latch.h"
13 #include <gpxe/tcpip.h>
14
15 /**
16  * A TCP header
17  */
18 struct tcp_header {
19         uint16_t src;           /* Source port */
20         uint16_t dest;          /* Destination port */
21         uint32_t seq;           /* Sequence number */
22         uint32_t ack;           /* Acknowledgement number */
23         uint8_t hlen;           /* Header length (4), Reserved (4) */
24         uint8_t flags;          /* Reserved (2), Flags (6) */
25         uint16_t win;           /* Advertised window */
26         uint16_t csum;          /* Checksum */
27         uint16_t urg;           /* Urgent pointer */
28 };
29
30 /**
31  * TCP MSS option
32  */
33 struct tcp_mss_option {
34         uint8_t kind;
35         uint8_t length;
36         uint16_t mss;
37 };
38
39 /** Code for the TCP MSS option */
40 #define TCP_OPTION_MSS 2
41
42 /*
43  * TCP flags
44  */
45 #define TCP_CWR         0x80
46 #define TCP_ECE         0x40
47 #define TCP_URG         0x20
48 #define TCP_ACK         0x10
49 #define TCP_PSH         0x08
50 #define TCP_RST         0x04
51 #define TCP_SYN         0x02
52 #define TCP_FIN         0x01
53
54 /**
55 * @defgroup tcpstates TCP states
56 *
57 * The TCP state is defined by a combination of the flags that have
58 * been sent to the peer, the flags that have been acknowledged by the
59 * peer, and the flags that have been received from the peer.
60 *
61 * @{
62 */
63
64 /** TCP flags that have been sent in outgoing packets */
65 #define TCP_STATE_SENT(flags) ( (flags) << 0 )
66 #define TCP_FLAGS_SENT(state) ( ( (state) >> 0 ) & 0xff )
67
68 /** TCP flags that have been acknowledged by the peer
69  *
70  * Note that this applies only to SYN and FIN.
71  */
72 #define TCP_STATE_ACKED(flags) ( (flags) << 8 )
73 #define TCP_FLAGS_ACKED(state) ( ( (state) >> 8 ) & 0xff )
74
75 /** TCP flags that have been received from the peer
76  *
77  * Note that this applies only to SYN and FIN, and that once SYN has
78  * been received, we should always be sending ACK.
79  */
80 #define TCP_STATE_RCVD(flags) ( (flags) << 16 )
81 #define TCP_FLAGS_RCVD(state) ( ( (state) >> 16 ) & 0xff )
82
83 /** TCP flags that are currently being sent in outgoing packets */
84 #define TCP_FLAGS_SENDING(state) \
85         ( TCP_FLAGS_SENT ( state ) & ~TCP_FLAGS_ACKED ( state ) )
86
87 /** CLOSED
88  *
89  * The connection has not yet been used for anything.
90  */
91 #define TCP_CLOSED TCP_RST
92
93 /** LISTEN
94  *
95  * Not currently used as a state; we have no support for listening
96  * connections.  Given a unique value to avoid compiler warnings.
97  */
98 #define TCP_LISTEN 0
99
100 /** SYN_SENT
101  *
102  * SYN has been sent, nothing has yet been received or acknowledged.
103  */
104 #define TCP_SYN_SENT    ( TCP_STATE_SENT ( TCP_SYN ) )
105
106 /** SYN_RCVD
107  *
108  * SYN has been sent but not acknowledged, SYN has been received.
109  */
110 #define TCP_SYN_RCVD    ( TCP_STATE_SENT ( TCP_SYN | TCP_ACK ) |            \
111                           TCP_STATE_RCVD ( TCP_SYN ) )
112
113 /** ESTABLISHED
114  *
115  * SYN has been sent and acknowledged, SYN has been received.
116  */
117 #define TCP_ESTABLISHED ( TCP_STATE_SENT ( TCP_SYN | TCP_ACK ) |            \
118                           TCP_STATE_ACKED ( TCP_SYN ) |                     \
119                           TCP_STATE_RCVD ( TCP_SYN ) )
120
121 /** FIN_WAIT_1
122  *
123  * SYN has been sent and acknowledged, SYN has been received, FIN has
124  * been sent but not acknowledged, FIN has not been received.
125  *
126  * RFC 793 shows that we can enter FIN_WAIT_1 without have had SYN
127  * acknowledged, i.e. if the application closes the connection after
128  * sending and receiving SYN, but before having had SYN acknowledged.
129  * However, we have to *pretend* that SYN has been acknowledged
130  * anyway, otherwise we end up sending SYN and FIN in the same
131  * sequence number slot.  Therefore, when we transition from SYN_RCVD
132  * to FIN_WAIT_1, we have to remember to set TCP_STATE_ACKED(TCP_SYN)
133  * and increment our sequence number.
134  */
135 #define TCP_FIN_WAIT_1  ( TCP_STATE_SENT ( TCP_SYN | TCP_ACK | TCP_FIN ) |  \
136                           TCP_STATE_ACKED ( TCP_SYN ) |                     \
137                           TCP_STATE_RCVD ( TCP_SYN ) )
138
139 /** FIN_WAIT_2
140  *
141  * SYN has been sent and acknowledged, SYN has been received, FIN has
142  * been sent and acknowledged, FIN ha not been received.
143  */
144 #define TCP_FIN_WAIT_2  ( TCP_STATE_SENT ( TCP_SYN | TCP_ACK | TCP_FIN ) |  \
145                           TCP_STATE_ACKED ( TCP_SYN | TCP_FIN ) |           \
146                           TCP_STATE_RCVD ( TCP_SYN ) )
147
148 /** CLOSING / LAST_ACK
149  *
150  * SYN has been sent and acknowledged, SYN has been received, FIN has
151  * been sent but not acknowledged, FIN has been received.
152  *
153  * This state actually encompasses both CLOSING and LAST_ACK; they are
154  * identical with the definition of state that we use.  I don't
155  * *believe* that they need to be distinguished.
156  */
157 #define TCP_CLOSING_OR_LAST_ACK                                             \
158                         ( TCP_STATE_SENT ( TCP_SYN | TCP_ACK | TCP_FIN ) |  \
159                           TCP_STATE_ACKED ( TCP_SYN ) |                     \
160                           TCP_STATE_RCVD ( TCP_SYN | TCP_FIN ) )
161
162 /** TIME_WAIT
163  *
164  * SYN has been sent and acknowledged, SYN has been received, FIN has
165  * been sent and acknowledged, FIN has been received.
166  */
167 #define TCP_TIME_WAIT   ( TCP_STATE_SENT ( TCP_SYN | TCP_ACK | TCP_FIN ) |  \
168                           TCP_STATE_ACKED ( TCP_SYN | TCP_FIN ) |           \
169                           TCP_STATE_RCVD ( TCP_SYN | TCP_FIN ) )
170
171 /** CLOSE_WAIT
172  *
173  * SYN has been sent and acknowledged, SYN has been received, FIN has
174  * been received.
175  */
176 #define TCP_CLOSE_WAIT  ( TCP_STATE_SENT ( TCP_SYN | TCP_ACK ) |            \
177                           TCP_STATE_ACKED ( TCP_SYN ) |                     \
178                           TCP_STATE_RCVD ( TCP_SYN | TCP_FIN ) )
179
180 /** Can send data in current state
181  *
182  * We can send data if and only if we have had our SYN acked and we
183  * have not yet sent our FIN.
184  */
185 #define TCP_CAN_SEND_DATA(state)                                            \
186         ( ( (state) & ( TCP_STATE_ACKED ( TCP_SYN ) |                       \
187                         TCP_STATE_SENT ( TCP_FIN ) ) )                      \
188           == TCP_STATE_ACKED ( TCP_SYN ) )
189
190 /** Have closed gracefully
191  *
192  * We have closed gracefully if we have both received a FIN and had
193  * our own FIN acked.
194  */
195 #define TCP_CLOSED_GRACEFULLY(state)                                        \
196         ( ( (state) & ( TCP_STATE_ACKED ( TCP_FIN ) |                       \
197                         TCP_STATE_RCVD ( TCP_FIN ) ) )                      \
198           == ( TCP_STATE_ACKED ( TCP_FIN ) | TCP_STATE_RCVD ( TCP_FIN ) ) )
199
200 /** @} */
201
202 /** Mask for TCP header length field */
203 #define TCP_MASK_HLEN   0xf0
204
205 /** Smallest port number on which a TCP connection can listen */
206 #define TCP_MIN_PORT 1
207
208 /* Some IOB constants */
209 #define MAX_HDR_LEN     100
210 #define MAX_IOB_LEN     1500
211 #define MIN_IOB_LEN     MAX_HDR_LEN + 100 /* To account for padding by LL */
212
213 /**
214  * Maxmimum advertised TCP window size
215  *
216  * We estimate the TCP window size as the amount of free memory we
217  * have.  This is not strictly accurate (since it ignores any space
218  * already allocated as RX buffers), but it will do for now.
219  *
220  * Since we don't store out-of-order received packets, the
221  * retransmission penalty is that the whole window contents must be
222  * resent.  This suggests keeping the window size small, but bear in
223  * mind that the maximum bandwidth on any link is limited to
224  *
225  *    max_bandwidth = ( tcp_window / round_trip_time )
226  *
227  * With a 48kB window, which probably accurately reflects our amount
228  * of free memory, and a WAN RTT of say 200ms, this gives a maximum
229  * bandwidth of 240kB/s.  This is sufficiently close to realistic that
230  * we will need to be careful that our advertised window doesn't end
231  * up limiting WAN download speeds.
232  *
233  * Finally, since the window goes into a 16-bit field and we cannot
234  * actually use 65536, we use a window size of (65536-4) to ensure
235  * that payloads remain dword-aligned.
236  */
237 #define TCP_MAX_WINDOW_SIZE     ( 65536 - 4 )
238
239 /**
240  * Path MTU
241  *
242  * We really ought to implement Path MTU discovery.  Until we do,
243  * anything with a path MTU greater than this may fail.
244  */
245 #define TCP_PATH_MTU 1460
246
247 /**
248  * Advertised TCP MSS
249  *
250  * We currently hardcode this to a reasonable value and hope that the
251  * sender uses path MTU discovery.  The alternative is breaking the
252  * abstraction layer so that we can find out the MTU from the IP layer
253  * (which would have to find out from the net device layer).
254  */
255 #define TCP_MSS 1460
256
257 /** TCP maximum segment lifetime
258  *
259  * Currently set to 2 minutes, as per RFC 793.
260  */
261 #define TCP_MSL ( 2 * 60 * TICKS_PER_SEC )
262
263 extern struct tcpip_protocol tcp_protocol;
264
265 #endif /* _GPXE_TCP_H */