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