TCP

WebSocket is a protocol for full-duplex communication over a single TCP connection, allowing the server to proactively push data to the client.

HTTP/2 uses multiplexing technology to allow concurrent transmission of multiple requests over a single TCP connection, while HTTP/3 switches the transport layer from TCP to the QUIC protocol.

WebSocket establishes a persistent full-duplex TCP connection through a single handshake, allowing the client and server to push data to each other at any time over the same connection.

Socket provides two main communication modes: TCP (connection-oriented, reliable transmission) and UDP (connectionless, low latency)

QUIC supports multiplexing, where packet loss on a single stream does not block other streams, solving TCP's head-of-line blocking problem.

SYN Flood attacks abuse the TCP three-way handshake mechanism.

Under the same protocol (TCP/UDP), the same port can be listened on by only one process at a time, otherwise an "Address already in use" error is triggered.

HPACK runs over a reliable TCP connection, where header blocks arrive strictly in order, so a single dynamic table can be used and ordering can be relied upon.

The TCP model fuses the two branches of trajectory prediction and control, and the related work was published at NeurIPS 2022.

Flight simulators typically mix protocols: high-frequency state such as position and velocity goes over UDP, while one-off events such as navigation light switches and weapon firing go over TCP or a reliable UDP channel.

Flight simulator network synchronization is almost entirely built on UDP, because position packets are sent at high frequency and occasional packet loss is acceptable, whereas TCP's reliable transmission introduces unnecessary latency and overhead.

TCP provides a reliable, ordered data stream, but at the cost of head-of-line blocking and unpredictable latency; UDP is a best-effort transport that does not guarantee delivery or order, and has no congestion control.

QUIC is a transport layer protocol running on top of UDP, with built-in TLS encryption, multiplexing, and flow control; compared with TCP it can reduce the number of round trips for connection establishment and is more tolerant of packet loss.

The TCP receive window is the size of the currently available buffer space that the receiver advertises to the sender via the Window Size field in the TCP header, in bytes; when the application does not read for a long time, the buffer fills up, the window drops to zero, and the sender must stop sending, which is the zero-window state.

When the TCP four-tuple (source IP, source port, destination IP, destination port) is exhausted, new connections cannot be established, manifesting as connection timeouts or the connect: cannot assign requested address error.

According to the TCP state machine, the party that actively closes the connection enters the TIME_WAIT state and by default remains there for 2 times MSL (usually about 60 seconds) before being fully released.

Stacking abstraction layers is a common pattern in software engineering: HTTP sits on top of TCP, REST sits on top of HTTP, and various SDKs sit on top of REST, with each layer not eliminating the layer below.

The core logic of the TCP client, state machine code, demonstration slides, and instructional documents were primarily completed with the assistance of AI tools such as Cursor.

TCP sequence numbers increment in units of bytes rather than packets; sending 4 bytes increases the sequence number by 4 regardless of how many packets it is split into.

The TCP client implementation covers mechanisms including slow start, advertised window, MSS option negotiation, timeout retransmission (SYN timeout of 1 second, data timeout of 200 milliseconds), retransmission from the unacknowledged pointer, fast retransmission triggered by three duplicate ACKs, zero-window probing, and keepalive.