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

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