Demos/Device/LowLevel/RNDISEthernet/Lib/TCP.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2009.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6       www.fourwalledcubicle.com
   7 */
   8
   9 /*
  10   Copyright 2009  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, and distribute this software
  13   and its documentation for any purpose and without fee is hereby
  14   granted, provided that the above copyright notice appear in all
  15   copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 /** \file
  32  *
  33  *  Transmission Control Protocol (TCP) packet handling routines. This protocol handles the reliable in-order transmission
  34  *  and reception of packets to and from devices on a network, to "ports" on the device. It is used in situations where data
  35  *  delivery must be reliable and correct, e.g. HTTP, TELNET and most other non-streaming protocols.
  36  */
  37
  38 #define  INCLUDE_FROM_TCP_C
  39 #include "TCP.h"
  40
  41 /* Global Variables: */
  42 /** Port state table array. This contains the current status of TCP ports in the device. To save on space, only open ports are
  43  *  stored - closed ports may be overwritten at any time, and the system will assume any ports not present in the array are closed. This
  44  *  allows for MAX_OPEN_TCP_PORTS to be less than the number of ports used by the application if desired.
  45  */
  46 TCP_PortState_t        PortStateTable[MAX_OPEN_TCP_PORTS];
  47
  48 /** Connection state table array. This contains the current status of TCP connections in the device. To save on space, only active
  49  *  (non-closed) connections are stored - closed connections may be overwritten at any time, and the system will assume any connections
  50  *  not present in the array are closed.
  51  */
  52 TCP_ConnectionState_t  ConnectionStateTable[MAX_TCP_CONNECTIONS];
  53
  54
  55 /** Task to handle the calling of each registered application's callback function, to process and generate TCP packets at the application
  56  *  level. If an application produces a response, this task constructs the appropriate Ethernet frame and places it into the Ethernet OUT
  57  *  buffer for later transmission.
  58  */
  59 void TCP_Task(void)
  60 {
  61         /* Run each application in sequence, to process incoming and generate outgoing packets */
  62         for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
  63         {
  64                 /* Find the corresponding port entry in the port table */
  65                 for (uint8_t PTableEntry = 0; PTableEntry < MAX_OPEN_TCP_PORTS; PTableEntry++)
  66                 {
  67                         /* Run the application handler for the port */
  68                         if ((PortStateTable[PTableEntry].Port  == ConnectionStateTable[CSTableEntry].Port) &&
  69                             (PortStateTable[PTableEntry].State == TCP_Port_Open))
  70                         {
  71                                 PortStateTable[PTableEntry].ApplicationHandler(&ConnectionStateTable[CSTableEntry],
  72                                                                                &ConnectionStateTable[CSTableEntry].Info.Buffer);
  73                         }
  74                 }
  75         }
  76
  77         /* Bail out early if there is already a frame waiting to be sent in the Ethernet OUT buffer */
  78         if (FrameOUT.FrameInBuffer)
  79           return;
  80
  81         /* Send response packets from each application as the TCP packet buffers are filled by the applications */
  82         for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
  83         {
  84                 /* For each completely received packet, pass it along to the listening application */
  85                 if ((ConnectionStateTable[CSTableEntry].Info.Buffer.Direction == TCP_PACKETDIR_OUT) &&
  86                     (ConnectionStateTable[CSTableEntry].Info.Buffer.Ready))
  87                 {
  88                         Ethernet_Frame_Header_t* FrameOUTHeader = (Ethernet_Frame_Header_t*)&FrameOUT.FrameData;
  89                         IP_Header_t*             IPHeaderOUT    = (IP_Header_t*)&FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)];
  90                         TCP_Header_t*            TCPHeaderOUT   = (TCP_Header_t*)&FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t) +
  91                                                                                                      sizeof(IP_Header_t)];
  92                         void*                    TCPDataOUT     = &FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t) +
  93                                                                                       sizeof(IP_Header_t) +
  94                                                                                       sizeof(TCP_Header_t)];
  95
  96                         uint16_t PacketSize = ConnectionStateTable[CSTableEntry].Info.Buffer.Length;
  97
  98                         /* Fill out the TCP data */
  99                         TCPHeaderOUT->SourcePort           = ConnectionStateTable[CSTableEntry].Port;
 100                         TCPHeaderOUT->DestinationPort      = ConnectionStateTable[CSTableEntry].RemotePort;
 101                         TCPHeaderOUT->SequenceNumber       = SwapEndian_32(ConnectionStateTable[CSTableEntry].Info.SequenceNumberOut);
 102                         TCPHeaderOUT->AcknowledgmentNumber = SwapEndian_32(ConnectionStateTable[CSTableEntry].Info.SequenceNumberIn);
 103                         TCPHeaderOUT->DataOffset           = (sizeof(TCP_Header_t) / sizeof(uint32_t));
 104                         TCPHeaderOUT->WindowSize           = SwapEndian_16(TCP_WINDOW_SIZE);
 105
 106                         TCPHeaderOUT->Flags                = TCP_FLAG_ACK;
 107                         TCPHeaderOUT->UrgentPointer        = 0;
 108                         TCPHeaderOUT->Checksum             = 0;
 109                         TCPHeaderOUT->Reserved             = 0;
 110
 111                         memcpy(TCPDataOUT, ConnectionStateTable[CSTableEntry].Info.Buffer.Data, PacketSize);
 112
 113                         ConnectionStateTable[CSTableEntry].Info.SequenceNumberOut += PacketSize;
 114
 115                         TCPHeaderOUT->Checksum             = TCP_Checksum16(TCPHeaderOUT, ServerIPAddress,
 116                                                                             ConnectionStateTable[CSTableEntry].RemoteAddress,
 117                                                                             (sizeof(TCP_Header_t) + PacketSize));
 118
 119                         PacketSize += sizeof(TCP_Header_t);
 120
 121                         /* Fill out the response IP header */
 122                         IPHeaderOUT->TotalLength        = SwapEndian_16(sizeof(IP_Header_t) + PacketSize);
 123                         IPHeaderOUT->TypeOfService      = 0;
 124                         IPHeaderOUT->HeaderLength       = (sizeof(IP_Header_t) / sizeof(uint32_t));
 125                         IPHeaderOUT->Version            = 4;
 126                         IPHeaderOUT->Flags              = 0;
 127                         IPHeaderOUT->FragmentOffset     = 0;
 128                         IPHeaderOUT->Identification     = 0;
 129                         IPHeaderOUT->HeaderChecksum     = 0;
 130                         IPHeaderOUT->Protocol           = PROTOCOL_TCP;
 131                         IPHeaderOUT->TTL                = DEFAULT_TTL;
 132                         IPHeaderOUT->SourceAddress      = ServerIPAddress;
 133                         IPHeaderOUT->DestinationAddress = ConnectionStateTable[CSTableEntry].RemoteAddress;
 134
 135                         IPHeaderOUT->HeaderChecksum     = Ethernet_Checksum16(IPHeaderOUT, sizeof(IP_Header_t));
 136
 137                         PacketSize += sizeof(IP_Header_t);
 138
 139                         /* Fill out the response Ethernet frame header */
 140                         FrameOUTHeader->Source          = ServerMACAddress;
 141                         FrameOUTHeader->Destination     = (MAC_Address_t){{0x02, 0x00, 0x02, 0x00, 0x02, 0x00}};
 142                         FrameOUTHeader->EtherType       = SwapEndian_16(ETHERTYPE_IPV4);
 143
 144                         PacketSize += sizeof(Ethernet_Frame_Header_t);
 145
 146                         /* Set the response length in the buffer and indicate that a response is ready to be sent */
 147                         FrameOUT.FrameLength            = PacketSize;
 148                         FrameOUT.FrameInBuffer          = true;
 149
 150                         ConnectionStateTable[CSTableEntry].Info.Buffer.Ready = false;
 151
 152                         break;
 153                 }
 154         }
 155 }
 156
 157 /** Initializes the TCP protocol handler, clearing the port and connection state tables. This must be called before TCP packets are
 158  *  processed.
 159  */
 160 void TCP_Init(void)
 161 {
 162         /* Initialize the port state table with all CLOSED entries */
 163         for (uint8_t PTableEntry = 0; PTableEntry < MAX_OPEN_TCP_PORTS; PTableEntry++)
 164           PortStateTable[PTableEntry].State = TCP_Port_Closed;
 165
 166         /* Initialize the connection table with all CLOSED entries */
 167         for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
 168           ConnectionStateTable[CSTableEntry].State = TCP_Connection_Closed;
 169 }
 170
 171 /** Sets the state and callback handler of the given port, specified in big endian to the given state.
 172  *
 173  *  \param[in] Port     Port whose state and callback function to set, specified in big endian
 174  *  \param[in] State    New state of the port, a value from the TCP_PortStates_t enum
 175  *  \param[in] Handler  Application callback handler for the port
 176  *
 177  *  \return Boolean true if the port state was set, false otherwise (no more space in the port state table)
 178  */
 179 bool TCP_SetPortState(uint16_t Port, uint8_t State, void (*Handler)(TCP_ConnectionState_t*, TCP_ConnectionBuffer_t*))
 180 {
 181         /* Note, Port number should be specified in BIG endian to simplify network code */
 182
 183         /* Check to see if the port entry is already in the port state table */
 184         for (uint8_t PTableEntry = 0; PTableEntry < MAX_TCP_CONNECTIONS; PTableEntry++)
 185         {
 186                 /* Find existing entry for the port in the table, update it if found */
 187                 if (PortStateTable[PTableEntry].Port == Port)
 188                 {
 189                         PortStateTable[PTableEntry].State = State;
 190                         PortStateTable[PTableEntry].ApplicationHandler = Handler;
 191                         return true;
 192                 }
 193         }
 194
 195         /* Check if trying to open the port -- if so we need to find an unused (closed) entry and replace it */
 196         if (State == TCP_Port_Open)
 197         {
 198                 for (uint8_t PTableEntry = 0; PTableEntry < MAX_TCP_CONNECTIONS; PTableEntry++)
 199                 {
 200                         /* Find a closed port entry in the table, change it to the given port and state */
 201                         if (PortStateTable[PTableEntry].State == TCP_Port_Closed)
 202                         {
 203                                 PortStateTable[PTableEntry].Port  = Port;
 204                                 PortStateTable[PTableEntry].State = State;
 205                                 PortStateTable[PTableEntry].ApplicationHandler = Handler;
 206                                 return true;
 207                         }
 208                 }
 209
 210                 /* Port not in table and no room to add it, return failure */
 211                 return false;
 212         }
 213         else
 214         {
 215                 /* Port not in table but trying to close it, so operation successful */
 216                 return true;
 217         }
 218 }
 219
 220 /** Retrieves the current state of a given TCP port, specified in big endian.
 221  *
 222  *  \param[in] Port  TCP port whose state is to be retrieved, given in big-endian
 223  *
 224  *  \return A value from the TCP_PortStates_t enum
 225  */
 226 uint8_t TCP_GetPortState(uint16_t Port)
 227 {
 228         /* Note, Port number should be specified in BIG endian to simplify network code */
 229
 230         for (uint8_t PTableEntry = 0; PTableEntry < MAX_TCP_CONNECTIONS; PTableEntry++)
 231         {
 232                 /* Find existing entry for the port in the table, return the port status if found */
 233                 if (PortStateTable[PTableEntry].Port == Port)
 234                   return PortStateTable[PTableEntry].State;
 235         }
 236
 237         /* Port not in table, assume closed */
 238         return TCP_Port_Closed;
 239 }
 240
 241 /** Sets the connection state of the given port, remote address and remote port to the given TCP connection state. If the
 242  *  connection exists in the connection state table it is updated, otherwise it is created if possible.
 243  *
 244  *  \param[in] Port           TCP port of the connection on the device, specified in big endian
 245  *  \param[in] RemoteAddress  Remote protocol IP address of the connected device
 246  *  \param[in] RemotePort     TCP port of the remote device in the connection, specified in big endian
 247  *  \param[in] State          TCP connection state, a value from the TCP_ConnectionStates_t enum
 248  *
 249  *  \return Boolean true if the connection was updated or created, false otherwise (no more space in the connection state table)
 250  */
 251 bool TCP_SetConnectionState(uint16_t Port, IP_Address_t RemoteAddress, uint16_t RemotePort, uint8_t State)
 252 {
 253         /* Note, Port number should be specified in BIG endian to simplify network code */
 254
 255         for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
 256         {
 257                 /* Find port entry in the table */
 258                 if ((ConnectionStateTable[CSTableEntry].Port == Port) &&
 259                      IP_COMPARE(&ConnectionStateTable[CSTableEntry].RemoteAddress, &RemoteAddress) &&
 260                          ConnectionStateTable[CSTableEntry].RemotePort == RemotePort)
 261                 {
 262                         ConnectionStateTable[CSTableEntry].State = State;
 263                         return true;
 264                 }
 265         }
 266
 267         for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
 268         {
 269                 /* Find empty entry in the table */
 270                 if (ConnectionStateTable[CSTableEntry].State == TCP_Connection_Closed)
 271                 {
 272                         ConnectionStateTable[CSTableEntry].Port          = Port;
 273                         ConnectionStateTable[CSTableEntry].RemoteAddress = RemoteAddress;
 274                         ConnectionStateTable[CSTableEntry].RemotePort    = RemotePort;
 275                         ConnectionStateTable[CSTableEntry].State         = State;
 276                         return true;
 277                 }
 278         }
 279
 280         return false;
 281 }
 282
 283 /** Retrieves the current state of a given TCP connection to a host.
 284  *
 285  *  \param[in] Port           TCP port on the device in the connection, specified in big endian
 286  *  \param[in] RemoteAddress  Remote protocol IP address of the connected host
 287  *  \param[in] RemotePort     Remote TCP port of the connected host, specified in big endian
 288  *
 289  *  \return A value from the TCP_ConnectionStates_t enum
 290  */
 291 uint8_t TCP_GetConnectionState(uint16_t Port, IP_Address_t RemoteAddress, uint16_t RemotePort)
 292 {
 293         /* Note, Port number should be specified in BIG endian to simplify network code */
 294
 295         for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
 296         {
 297                 /* Find port entry in the table */
 298                 if ((ConnectionStateTable[CSTableEntry].Port == Port) &&
 299                      IP_COMPARE(&ConnectionStateTable[CSTableEntry].RemoteAddress, &RemoteAddress) &&
 300                          ConnectionStateTable[CSTableEntry].RemotePort == RemotePort)
 301
 302                 {
 303                         return ConnectionStateTable[CSTableEntry].State;
 304                 }
 305         }
 306
 307         return TCP_Connection_Closed;
 308 }
 309
 310 /** Retrieves the connection info structure of a given connection to a host.
 311  *
 312  *  \param[in] Port           TCP port on the device in the connection, specified in big endian
 313  *  \param[in] RemoteAddress  Remote protocol IP address of the connected host
 314  *  \param[in] RemotePort     Remote TCP port of the connected host, specified in big endian
 315  *
 316  *  \return ConnectionInfo structure of the connection if found, NULL otherwise
 317  */
 318 TCP_ConnectionInfo_t* TCP_GetConnectionInfo(uint16_t Port, IP_Address_t RemoteAddress, uint16_t RemotePort)
 319 {
 320         /* Note, Port number should be specified in BIG endian to simplify network code */
 321
 322         for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
 323         {
 324                 /* Find port entry in the table */
 325                 if ((ConnectionStateTable[CSTableEntry].Port == Port) &&
 326                      IP_COMPARE(&ConnectionStateTable[CSTableEntry].RemoteAddress, &RemoteAddress) &&
 327                          ConnectionStateTable[CSTableEntry].RemotePort == RemotePort)
 328                 {
 329                         return &ConnectionStateTable[CSTableEntry].Info;
 330                 }
 331         }
 332
 333         return NULL;
 334 }
 335
 336 /** Processes a TCP packet inside an Ethernet frame, and writes the appropriate response
 337  *  to the output Ethernet frame if one is created by a application handler.
 338  *
 339  *  \param[in] IPHeaderInStart     Pointer to the start of the incoming packet's IP header
 340  *  \param[in] TCPHeaderInStart    Pointer to the start of the incoming packet's TCP header
 341  *  \param[out] TCPHeaderOutStart  Pointer to the start of the outgoing packet's TCP header
 342  *
 343  *  \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE if no
 344  *           response was generated, NO_PROCESS if the packet processing was deferred until the
 345  *           next Ethernet packet handler iteration
 346  */
 347 int16_t TCP_ProcessTCPPacket(void* IPHeaderInStart, void* TCPHeaderInStart, void* TCPHeaderOutStart)
 348 {
 349         IP_Header_t*  IPHeaderIN   = (IP_Header_t*)IPHeaderInStart;
 350         TCP_Header_t* TCPHeaderIN  = (TCP_Header_t*)TCPHeaderInStart;
 351         TCP_Header_t* TCPHeaderOUT = (TCP_Header_t*)TCPHeaderOutStart;
 352
 353         TCP_ConnectionInfo_t* ConnectionInfo;
 354
 355         DecodeTCPHeader(TCPHeaderInStart);
 356
 357         bool PacketResponse = false;
 358
 359         /* Check if the destination port is open and allows incoming connections */
 360         if (TCP_GetPortState(TCPHeaderIN->DestinationPort) == TCP_Port_Open)
 361         {
 362                 /* Detect SYN from host to start a connection */
 363                 if (TCPHeaderIN->Flags & TCP_FLAG_SYN)
 364                   TCP_SetConnectionState(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress, TCPHeaderIN->SourcePort, TCP_Connection_Listen);
 365
 366                 /* Detect RST from host to abort existing connection */
 367                 if (TCPHeaderIN->Flags & TCP_FLAG_RST)
 368                 {
 369                         if (TCP_SetConnectionState(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
 370                                                    TCPHeaderIN->SourcePort, TCP_Connection_Closed))
 371                         {
 372                                 TCPHeaderOUT->Flags = (TCP_FLAG_RST | TCP_FLAG_ACK);
 373                                 PacketResponse = true;
 374                         }
 375                 }
 376                 else
 377                 {
 378                         /* Process the incoming TCP packet based on the current connection state for the sender and port */
 379                         switch (TCP_GetConnectionState(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress, TCPHeaderIN->SourcePort))
 380                         {
 381                                 case TCP_Connection_Listen:
 382                                         if (TCPHeaderIN->Flags == TCP_FLAG_SYN)
 383                                         {
 384                                                 /* SYN connection starts a connection with a peer */
 385                                                 if (TCP_SetConnectionState(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
 386                                                                            TCPHeaderIN->SourcePort, TCP_Connection_SYNReceived))
 387                                                 {
 388                                                         TCPHeaderOUT->Flags = (TCP_FLAG_SYN | TCP_FLAG_ACK);
 389
 390                                                         ConnectionInfo = TCP_GetConnectionInfo(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress, TCPHeaderIN->SourcePort);
 391
 392                                                         ConnectionInfo->SequenceNumberIn  = (SwapEndian_32(TCPHeaderIN->SequenceNumber) + 1);
 393                                                         ConnectionInfo->SequenceNumberOut = 0;
 394                                                         ConnectionInfo->Buffer.InUse      = false;
 395                                                 }
 396                                                 else
 397                                                 {
 398                                                         TCPHeaderOUT->Flags = TCP_FLAG_RST;
 399                                                 }
 400
 401                                                 PacketResponse      = true;
 402                                         }
 403
 404                                         break;
 405                                 case TCP_Connection_SYNReceived:
 406                                         if (TCPHeaderIN->Flags == TCP_FLAG_ACK)
 407                                         {
 408                                                 /* ACK during the connection process completes the connection to a peer */
 409
 410                                                 TCP_SetConnectionState(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
 411                                                                                            TCPHeaderIN->SourcePort, TCP_Connection_Established);
 412
 413                                                 ConnectionInfo = TCP_GetConnectionInfo(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
 414                                                                                                                            TCPHeaderIN->SourcePort);
 415
 416                                                 ConnectionInfo->SequenceNumberOut++;
 417                                         }
 418
 419                                         break;
 420                                 case TCP_Connection_Established:
 421                                         if (TCPHeaderIN->Flags == (TCP_FLAG_FIN | TCP_FLAG_ACK))
 422                                         {
 423                                                 /* FIN ACK when connected to a peer starts the finalization process */
 424
 425                                                 TCPHeaderOUT->Flags = (TCP_FLAG_FIN | TCP_FLAG_ACK);
 426                                                 PacketResponse      = true;
 427
 428                                                 TCP_SetConnectionState(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
 429                                                                                            TCPHeaderIN->SourcePort, TCP_Connection_CloseWait);
 430
 431                                                 ConnectionInfo = TCP_GetConnectionInfo(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
 432                                                                                                                            TCPHeaderIN->SourcePort);
 433
 434                                                 ConnectionInfo->SequenceNumberIn++;
 435                                                 ConnectionInfo->SequenceNumberOut++;
 436                                         }
 437                                         else if ((TCPHeaderIN->Flags == TCP_FLAG_ACK) || (TCPHeaderIN->Flags == (TCP_FLAG_ACK | TCP_FLAG_PSH)))
 438                                         {
 439                                                 ConnectionInfo = TCP_GetConnectionInfo(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
 440                                                                                                                            TCPHeaderIN->SourcePort);
 441
 442                                                 /* Check if the buffer is currently in use either by a buffered data to send, or receive */
 443                                                 if ((ConnectionInfo->Buffer.InUse == false) && (ConnectionInfo->Buffer.Ready == false))
 444                                                 {
 445                                                         ConnectionInfo->Buffer.Direction = TCP_PACKETDIR_IN;
 446                                                         ConnectionInfo->Buffer.InUse     = true;
 447                                                         ConnectionInfo->Buffer.Length    = 0;
 448                                                 }
 449
 450                                                 /* Check if the buffer has been claimed by us to read in data from the peer */
 451                                                 if ((ConnectionInfo->Buffer.Direction == TCP_PACKETDIR_IN) &&
 452                                                         (ConnectionInfo->Buffer.Length != TCP_WINDOW_SIZE))
 453                                                 {
 454                                                         uint16_t IPOffset   = (IPHeaderIN->HeaderLength * sizeof(uint32_t));
 455                                                         uint16_t TCPOffset  = (TCPHeaderIN->DataOffset * sizeof(uint32_t));
 456                                                         uint16_t DataLength = (SwapEndian_16(IPHeaderIN->TotalLength) - IPOffset - TCPOffset);
 457
 458                                                         /* Copy the packet data into the buffer */
 459                                                         memcpy(&ConnectionInfo->Buffer.Data[ConnectionInfo->Buffer.Length],
 460                                                                    &((uint8_t*)TCPHeaderInStart)[TCPOffset],
 461                                                                    DataLength);
 462
 463                                                         ConnectionInfo->SequenceNumberIn += DataLength;
 464                                                         ConnectionInfo->Buffer.Length    += DataLength;
 465
 466                                                         /* Check if the buffer is full or if the PSH flag is set, if so indicate buffer ready */
 467                                                         if ((!(TCP_WINDOW_SIZE - ConnectionInfo->Buffer.Length)) || (TCPHeaderIN->Flags & TCP_FLAG_PSH))
 468                                                         {
 469                                                                 ConnectionInfo->Buffer.InUse = false;
 470                                                                 ConnectionInfo->Buffer.Ready = true;
 471
 472                                                                 TCPHeaderOUT->Flags = TCP_FLAG_ACK;
 473                                                                 PacketResponse      = true;
 474                                                         }
 475                                                 }
 476                                                 else
 477                                                 {
 478                                                         /* Buffer is currently in use by the application, defer processing of the incoming packet */
 479                                                         return NO_PROCESS;
 480                                                 }
 481                                         }
 482
 483                                         break;
 484                                 case TCP_Connection_Closing:
 485                                                 ConnectionInfo = TCP_GetConnectionInfo(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
 486                                                                                                                            TCPHeaderIN->SourcePort);
 487
 488                                                 TCPHeaderOUT->Flags = (TCP_FLAG_ACK | TCP_FLAG_FIN);
 489                                                 PacketResponse      = true;
 490
 491                                                 ConnectionInfo->Buffer.InUse = false;
 492
 493                                                 TCP_SetConnectionState(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
 494                                                                                            TCPHeaderIN->SourcePort, TCP_Connection_FINWait1);
 495
 496                                         break;
 497                                 case TCP_Connection_FINWait1:
 498                                         if (TCPHeaderIN->Flags == (TCP_FLAG_FIN | TCP_FLAG_ACK))
 499                                         {
 500                                                 ConnectionInfo = TCP_GetConnectionInfo(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
 501                                                                                                                            TCPHeaderIN->SourcePort);
 502
 503                                                 TCPHeaderOUT->Flags = TCP_FLAG_ACK;
 504                                                 PacketResponse      = true;
 505
 506                                                 ConnectionInfo->SequenceNumberIn++;
 507                                                 ConnectionInfo->SequenceNumberOut++;
 508
 509                                                 TCP_SetConnectionState(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
 510                                                                                            TCPHeaderIN->SourcePort, TCP_Connection_Closed);
 511                                         }
 512                                         else if (TCPHeaderIN->Flags == TCP_FLAG_ACK)
 513                                         {
 514                                                 TCP_SetConnectionState(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
 515                                                                                            TCPHeaderIN->SourcePort, TCP_Connection_FINWait2);
 516                                         }
 517
 518                                         break;
 519                                 case TCP_Connection_FINWait2:
 520                                         if (TCPHeaderIN->Flags == (TCP_FLAG_FIN | TCP_FLAG_ACK))
 521                                         {
 522                                                 ConnectionInfo = TCP_GetConnectionInfo(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
 523                                                                                                                            TCPHeaderIN->SourcePort);
 524
 525                                                 TCPHeaderOUT->Flags = TCP_FLAG_ACK;
 526                                                 PacketResponse      = true;
 527
 528                                                 ConnectionInfo->SequenceNumberIn++;
 529                                                 ConnectionInfo->SequenceNumberOut++;
 530
 531                                                 TCP_SetConnectionState(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
 532                                                                                            TCPHeaderIN->SourcePort, TCP_Connection_Closed);
 533                                         }
 534
 535                                         break;
 536                                 case TCP_Connection_CloseWait:
 537                                         if (TCPHeaderIN->Flags == TCP_FLAG_ACK)
 538                                         {
 539                                                 TCP_SetConnectionState(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
 540                                                                                            TCPHeaderIN->SourcePort, TCP_Connection_Closed);
 541                                         }
 542
 543                                         break;
 544                         }
 545                 }
 546         }
 547         else
 548         {
 549                 /* Port is not open, indicate via a RST/ACK response to the sender */
 550                 TCPHeaderOUT->Flags = (TCP_FLAG_RST | TCP_FLAG_ACK);
 551                 PacketResponse      = true;
 552         }
 553
 554         /* Check if we need to respond to the sent packet */
 555         if (PacketResponse)
 556         {
 557                 ConnectionInfo = TCP_GetConnectionInfo(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
 558                                                        TCPHeaderIN->SourcePort);
 559
 560                 TCPHeaderOUT->SourcePort           = TCPHeaderIN->DestinationPort;
 561                 TCPHeaderOUT->DestinationPort      = TCPHeaderIN->SourcePort;
 562                 TCPHeaderOUT->SequenceNumber       = SwapEndian_32(ConnectionInfo->SequenceNumberOut);
 563                 TCPHeaderOUT->AcknowledgmentNumber = SwapEndian_32(ConnectionInfo->SequenceNumberIn);
 564                 TCPHeaderOUT->DataOffset           = (sizeof(TCP_Header_t) / sizeof(uint32_t));
 565
 566                 if (!(ConnectionInfo->Buffer.InUse))
 567                   TCPHeaderOUT->WindowSize         = SwapEndian_16(TCP_WINDOW_SIZE);
 568                 else
 569                   TCPHeaderOUT->WindowSize         = SwapEndian_16(TCP_WINDOW_SIZE - ConnectionInfo->Buffer.Length);
 570
 571                 TCPHeaderOUT->UrgentPointer        = 0;
 572                 TCPHeaderOUT->Checksum             = 0;
 573                 TCPHeaderOUT->Reserved             = 0;
 574
 575                 TCPHeaderOUT->Checksum             = TCP_Checksum16(TCPHeaderOUT, IPHeaderIN->DestinationAddress,
 576                                                                     IPHeaderIN->SourceAddress, sizeof(TCP_Header_t));
 577
 578                 return sizeof(TCP_Header_t);
 579         }
 580
 581         return NO_RESPONSE;
 582 }
 583
 584 /** Calculates the appropriate TCP checksum, consisting of the addition of the one's compliment of each word,
 585  *  complimented.
 586  *
 587  *  \param[in] TCPHeaderOutStart   Pointer to the start of the packet's outgoing TCP header
 588  *  \param[in] SourceAddress       Source protocol IP address of the outgoing IP header
 589  *  \param[in] DestinationAddress  Destination protocol IP address of the outgoing IP header
 590  *  \param[in] TCPOutSize          Size in bytes of the TCP data header and payload
 591  *
 592  *  \return A 16-bit TCP checksum value
 593  */
 594 static uint16_t TCP_Checksum16(void* TCPHeaderOutStart, IP_Address_t SourceAddress,
 595                                IP_Address_t DestinationAddress, uint16_t TCPOutSize)
 596 {
 597         uint32_t Checksum = 0;
 598
 599         /* TCP/IP checksums are the addition of the one's compliment of each word including the IP pseudo-header,
 600            complimented */
 601
 602         Checksum += ((uint16_t*)&SourceAddress)[0];
 603         Checksum += ((uint16_t*)&SourceAddress)[1];
 604         Checksum += ((uint16_t*)&DestinationAddress)[0];
 605         Checksum += ((uint16_t*)&DestinationAddress)[1];
 606         Checksum += SwapEndian_16(PROTOCOL_TCP);
 607         Checksum += SwapEndian_16(TCPOutSize);
 608
 609         for (uint8_t CurrWord = 0; CurrWord < (TCPOutSize >> 1); CurrWord++)
 610           Checksum += ((uint16_t*)TCPHeaderOutStart)[CurrWord];
 611
 612         if (TCPOutSize & 0x01)
 613           Checksum += (((uint16_t*)TCPHeaderOutStart)[TCPOutSize >> 1] & 0x00FF);
 614
 615         while (Checksum & 0xFFFF0000)
 616           Checksum = ((Checksum & 0xFFFF) + (Checksum >> 16));
 617
 618         return ~Checksum;
 619 }