projects / pub / USBasp.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Make Control Endpoint stream transfers more reliable by adding in early aborts for...
[pub/USBasp.git] / Demos / Device / ClassDriver / 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_TCPTask(USB_ClassInfo_RNDIS_Device_t* RNDISInterfaceInfo)
60 {
61 /* Task to hand off TCP packets to and from the listening applications. */
62
63 /* Run each application in sequence, to process incoming and generate outgoing packets */
64 for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
65 {
66 /* Find the corresponding port entry in the port table */
67 for (uint8_t PTableEntry = 0; PTableEntry < MAX_TCP_CONNECTIONS; PTableEntry++)
68 {
69 /* Run the application handler for the port */
70 if ((PortStateTable[PTableEntry].Port == ConnectionStateTable[CSTableEntry].Port) &&
71 (PortStateTable[PTableEntry].State == TCP_Port_Open))
72 {
73 PortStateTable[PTableEntry].ApplicationHandler(&ConnectionStateTable[CSTableEntry], &ConnectionStateTable[CSTableEntry].Info.Buffer);
74 }
75 }
76 }
77
78 /* Bail out early if there is already a frame waiting to be sent in the Ethernet OUT buffer */
79 if (RNDISInterfaceInfo->State.FrameOUT.FrameInBuffer)
80 return;
81
82 /* Send response packets from each application as the TCP packet buffers are filled by the applications */
83 for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
84 {
85 /* For each completely received packet, pass it along to the listening application */
86 if ((ConnectionStateTable[CSTableEntry].Info.Buffer.Direction == TCP_PACKETDIR_OUT) &&
87 (ConnectionStateTable[CSTableEntry].Info.Buffer.Ready))
88 {
89 Ethernet_Frame_Header_t* FrameOUTHeader = (Ethernet_Frame_Header_t*)&RNDISInterfaceInfo->State.FrameOUT.FrameData;
90 IP_Header_t* IPHeaderOUT = (IP_Header_t*)&RNDISInterfaceInfo->State.FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t)];
91 TCP_Header_t* TCPHeaderOUT = (TCP_Header_t*)&RNDISInterfaceInfo->State.FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t) +
92 sizeof(IP_Header_t)];
93 void* TCPDataOUT = &RNDISInterfaceInfo->State.FrameOUT.FrameData[sizeof(Ethernet_Frame_Header_t) +
94 sizeof(IP_Header_t) +
95 sizeof(TCP_Header_t)];
96
97 uint16_t PacketSize = ConnectionStateTable[CSTableEntry].Info.Buffer.Length;
98
99 /* Fill out the TCP data */
100 TCPHeaderOUT->SourcePort = ConnectionStateTable[CSTableEntry].Port;
101 TCPHeaderOUT->DestinationPort = ConnectionStateTable[CSTableEntry].RemotePort;
102 TCPHeaderOUT->SequenceNumber = SwapEndian_32(ConnectionStateTable[CSTableEntry].Info.SequenceNumberOut);
103 TCPHeaderOUT->AcknowledgmentNumber = SwapEndian_32(ConnectionStateTable[CSTableEntry].Info.SequenceNumberIn);
104 TCPHeaderOUT->DataOffset = (sizeof(TCP_Header_t) / sizeof(uint32_t));
105 TCPHeaderOUT->WindowSize = SwapEndian_16(TCP_WINDOW_SIZE);
106
107 TCPHeaderOUT->Flags = TCP_FLAG_ACK;
108 TCPHeaderOUT->UrgentPointer = 0;
109 TCPHeaderOUT->Checksum = 0;
110 TCPHeaderOUT->Reserved = 0;
111
112 memcpy(TCPDataOUT, ConnectionStateTable[CSTableEntry].Info.Buffer.Data, PacketSize);
113
114 ConnectionStateTable[CSTableEntry].Info.SequenceNumberOut += PacketSize;
115
116 TCPHeaderOUT->Checksum = TCP_Checksum16(TCPHeaderOUT, ServerIPAddress,
117 ConnectionStateTable[CSTableEntry].RemoteAddress,
118 (sizeof(TCP_Header_t) + PacketSize));
119
120 PacketSize += sizeof(TCP_Header_t);
121
122 /* Fill out the response IP header */
123 IPHeaderOUT->TotalLength = SwapEndian_16(sizeof(IP_Header_t) + PacketSize);
124 IPHeaderOUT->TypeOfService = 0;
125 IPHeaderOUT->HeaderLength = (sizeof(IP_Header_t) / sizeof(uint32_t));
126 IPHeaderOUT->Version = 4;
127 IPHeaderOUT->Flags = 0;
128 IPHeaderOUT->FragmentOffset = 0;
129 IPHeaderOUT->Identification = 0;
130 IPHeaderOUT->HeaderChecksum = 0;
131 IPHeaderOUT->Protocol = PROTOCOL_TCP;
132 IPHeaderOUT->TTL = DEFAULT_TTL;
133 IPHeaderOUT->SourceAddress = ServerIPAddress;
134 IPHeaderOUT->DestinationAddress = ConnectionStateTable[CSTableEntry].RemoteAddress;
135
136 IPHeaderOUT->HeaderChecksum = Ethernet_Checksum16(IPHeaderOUT, sizeof(IP_Header_t));
137
138 PacketSize += sizeof(IP_Header_t);
139
140 /* Fill out the response Ethernet frame header */
141 FrameOUTHeader->Source = ServerMACAddress;
142 FrameOUTHeader->Destination = (MAC_Address_t){{0x02, 0x00, 0x02, 0x00, 0x02, 0x00}};
143 FrameOUTHeader->EtherType = SwapEndian_16(ETHERTYPE_IPV4);
144
145 PacketSize += sizeof(Ethernet_Frame_Header_t);
146
147 /* Set the response length in the buffer and indicate that a response is ready to be sent */
148 RNDISInterfaceInfo->State.FrameOUT.FrameLength = PacketSize;
149 RNDISInterfaceInfo->State.FrameOUT.FrameInBuffer = true;
150
151 ConnectionStateTable[CSTableEntry].Info.Buffer.Ready = false;
152
153 break;
154 }
155 }
156 }
157
158 /** Initializes the TCP protocol handler, clearing the port and connection state tables. This must be called before TCP packets are
159 * processed.
160 */
161 void TCP_Init(void)
162 {
163 /* Initialize the port state table with all CLOSED entries */
164 for (uint8_t PTableEntry = 0; PTableEntry < MAX_OPEN_TCP_PORTS; PTableEntry++)
165 PortStateTable[PTableEntry].State = TCP_Port_Closed;
166
167 /* Initialize the connection table with all CLOSED entries */
168 for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
169 ConnectionStateTable[CSTableEntry].State = TCP_Connection_Closed;
170 }
171
172 /** Sets the state and callback handler of the given port, specified in big endian to the given state.
173 *
174 * \param[in] Port Port whose state and callback function to set, specified in big endian
175 * \param[in] State New state of the port, a value from the TCP_PortStates_t enum
176 * \param[in] Handler Application callback handler for the port
177 *
178 * \return Boolean true if the port state was set, false otherwise (no more space in the port state table)
179 */
180 bool TCP_SetPortState(uint16_t Port, uint8_t State, void (*Handler)(TCP_ConnectionState_t*, TCP_ConnectionBuffer_t*))
181 {
182 /* Note, Port number should be specified in BIG endian to simplify network code */
183
184 /* Check to see if the port entry is already in the port state table */
185 for (uint8_t PTableEntry = 0; PTableEntry < MAX_TCP_CONNECTIONS; PTableEntry++)
186 {
187 /* Find existing entry for the port in the table, update it if found */
188 if (PortStateTable[PTableEntry].Port == Port)
189 {
190 PortStateTable[PTableEntry].State = State;
191 PortStateTable[PTableEntry].ApplicationHandler = Handler;
192 return true;
193 }
194 }
195
196 /* Check if trying to open the port -- if so we need to find an unused (closed) entry and replace it */
197 if (State == TCP_Port_Open)
198 {
199 for (uint8_t PTableEntry = 0; PTableEntry < MAX_TCP_CONNECTIONS; PTableEntry++)
200 {
201 /* Find a closed port entry in the table, change it to the given port and state */
202 if (PortStateTable[PTableEntry].State == TCP_Port_Closed)
203 {
204 PortStateTable[PTableEntry].Port = Port;
205 PortStateTable[PTableEntry].State = State;
206 PortStateTable[PTableEntry].ApplicationHandler = Handler;
207 return true;
208 }
209 }
210
211 /* Port not in table and no room to add it, return failure */
212 return false;
213 }
214 else
215 {
216 /* Port not in table but trying to close it, so operation successful */
217 return true;
218 }
219 }
220
221 /** Retrieves the current state of a given TCP port, specified in big endian.
222 *
223 * \param[in] Port TCP port whose state is to be retrieved, given in big-endian
224 *
225 * \return A value from the TCP_PortStates_t enum
226 */
227 uint8_t TCP_GetPortState(uint16_t Port)
228 {
229 /* Note, Port number should be specified in BIG endian to simplify network code */
230
231 for (uint8_t PTableEntry = 0; PTableEntry < MAX_TCP_CONNECTIONS; PTableEntry++)
232 {
233 /* Find existing entry for the port in the table, return the port status if found */
234 if (PortStateTable[PTableEntry].Port == Port)
235 return PortStateTable[PTableEntry].State;
236 }
237
238 /* Port not in table, assume closed */
239 return TCP_Port_Closed;
240 }
241
242 /** Sets the connection state of the given port, remote address and remote port to the given TCP connection state. If the
243 * connection exists in the connection state table it is updated, otherwise it is created if possible.
244 *
245 * \param[in] Port TCP port of the connection on the device, specified in big endian
246 * \param[in] RemoteAddress Remote protocol IP address of the connected device
247 * \param[in] RemotePort TCP port of the remote device in the connection, specified in big endian
248 * \param[in] State TCP connection state, a value from the TCP_ConnectionStates_t enum
249 *
250 * \return Boolean true if the connection was updated or created, false otherwise (no more space in the connection state table)
251 */
252 bool TCP_SetConnectionState(uint16_t Port, IP_Address_t RemoteAddress, uint16_t RemotePort, uint8_t State)
253 {
254 /* Note, Port number should be specified in BIG endian to simplify network code */
255
256 for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
257 {
258 /* Find port entry in the table */
259 if ((ConnectionStateTable[CSTableEntry].Port == Port) &&
260 IP_COMPARE(&ConnectionStateTable[CSTableEntry].RemoteAddress, &RemoteAddress) &&
261 ConnectionStateTable[CSTableEntry].RemotePort == RemotePort)
262 {
263 ConnectionStateTable[CSTableEntry].State = State;
264 return true;
265 }
266 }
267
268 for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
269 {
270 /* Find empty entry in the table */
271 if (ConnectionStateTable[CSTableEntry].State == TCP_Connection_Closed)
272 {
273 ConnectionStateTable[CSTableEntry].Port = Port;
274 ConnectionStateTable[CSTableEntry].RemoteAddress = RemoteAddress;
275 ConnectionStateTable[CSTableEntry].RemotePort = RemotePort;
276 ConnectionStateTable[CSTableEntry].State = State;
277 return true;
278 }
279 }
280
281 return false;
282 }
283
284 /** Retrieves the current state of a given TCP connection to a host.
285 *
286 * \param[in] Port TCP port on the device in the connection, specified in big endian
287 * \param[in] RemoteAddress Remote protocol IP address of the connected host
288 * \param[in] RemotePort Remote TCP port of the connected host, specified in big endian
289 *
290 * \return A value from the TCP_ConnectionStates_t enum
291 */
292 uint8_t TCP_GetConnectionState(uint16_t Port, IP_Address_t RemoteAddress, uint16_t RemotePort)
293 {
294 /* Note, Port number should be specified in BIG endian to simplify network code */
295
296 for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
297 {
298 /* Find port entry in the table */
299 if ((ConnectionStateTable[CSTableEntry].Port == Port) &&
300 IP_COMPARE(&ConnectionStateTable[CSTableEntry].RemoteAddress, &RemoteAddress) &&
301 ConnectionStateTable[CSTableEntry].RemotePort == RemotePort)
302
303 {
304 return ConnectionStateTable[CSTableEntry].State;
305 }
306 }
307
308 return TCP_Connection_Closed;
309 }
310
311 /** Retrieves the connection info structure of a given connection to a host.
312 *
313 * \param[in] Port TCP port on the device in the connection, specified in big endian
314 * \param[in] RemoteAddress Remote protocol IP address of the connected host
315 * \param[in] RemotePort Remote TCP port of the connected host, specified in big endian
316 *
317 * \return ConnectionInfo structure of the connection if found, NULL otherwise
318 */
319 TCP_ConnectionInfo_t* TCP_GetConnectionInfo(uint16_t Port, IP_Address_t RemoteAddress, uint16_t RemotePort)
320 {
321 /* Note, Port number should be specified in BIG endian to simplify network code */
322
323 for (uint8_t CSTableEntry = 0; CSTableEntry < MAX_TCP_CONNECTIONS; CSTableEntry++)
324 {
325 /* Find port entry in the table */
326 if ((ConnectionStateTable[CSTableEntry].Port == Port) &&
327 IP_COMPARE(&ConnectionStateTable[CSTableEntry].RemoteAddress, &RemoteAddress) &&
328 ConnectionStateTable[CSTableEntry].RemotePort == RemotePort)
329 {
330 return &ConnectionStateTable[CSTableEntry].Info;
331 }
332 }
333
334 return NULL;
335 }
336
337 /** Processes a TCP packet inside an Ethernet frame, and writes the appropriate response
338 * to the output Ethernet frame if one is created by a application handler.
339 *
340 * \param[in] IPHeaderInStart Pointer to the start of the incoming packet's IP header
341 * \param[in] TCPHeaderInStart Pointer to the start of the incoming packet's TCP header
342 * \param[out] TCPHeaderOutStart Pointer to the start of the outgoing packet's TCP header
343 *
344 * \return The number of bytes written to the out Ethernet frame if any, NO_RESPONSE if no
345 * response was generated, NO_PROCESS if the packet processing was deferred until the
346 * next Ethernet packet handler iteration
347 */
348 int16_t TCP_ProcessTCPPacket(void* IPHeaderInStart, void* TCPHeaderInStart, void* TCPHeaderOutStart)
349 {
350 IP_Header_t* IPHeaderIN = (IP_Header_t*)IPHeaderInStart;
351 TCP_Header_t* TCPHeaderIN = (TCP_Header_t*)TCPHeaderInStart;
352 TCP_Header_t* TCPHeaderOUT = (TCP_Header_t*)TCPHeaderOutStart;
353
354 TCP_ConnectionInfo_t* ConnectionInfo;
355
356 DecodeTCPHeader(TCPHeaderInStart);
357
358 bool PacketResponse = false;
359
360 /* Check if the destination port is open and allows incoming connections */
361 if (TCP_GetPortState(TCPHeaderIN->DestinationPort) == TCP_Port_Open)
362 {
363 /* Detect SYN from host to start a connection */
364 if (TCPHeaderIN->Flags & TCP_FLAG_SYN)
365 TCP_SetConnectionState(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress, TCPHeaderIN->SourcePort, TCP_Connection_Listen);
366
367 /* Detect RST from host to abort existing connection */
368 if (TCPHeaderIN->Flags & TCP_FLAG_RST)
369 {
370 TCPHeaderOUT->Flags = (TCP_FLAG_RST | TCP_FLAG_ACK);
371 PacketResponse = true;
372
373 TCP_SetConnectionState(TCPHeaderIN->DestinationPort, IPHeaderIN->SourceAddress,
374 TCPHeaderIN->SourcePort, TCP_Connection_Closed);
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 }
USB isp AVR programmer