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