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