TCP

A port is a 16-bit number (0 to 65535) that identifies a process on a host. A socket is one end of a communication, identified by an IP address and a port. A TCP connection is identified by four values: source IP, source port, destination IP and destination port. A UDP socket at the receiver is identified only by its destination IP and destination port, so datagrams from different senders to that address and port all reach the same socket. A TCP server, by contrast, has a separate connected socket for each client.

The server prepares to receive with socket, bind, listen and accept. The client uses socket and connect. Once the connection is made, both sides use send and recv (or write and read) and finish with close.

SERVER                         CLIENT
s = socket()                   c = socket()
bind(s, local IP and port)
listen(s, backlog)
conn = accept(s)   <--------   connect(c, server IP and port)
                   (three-way handshake happens inside connect/accept)
recv(conn) / send(conn)  <-->  send(c) / recv(c)
close(conn)                    close(c)

A SYN and a FIN each use up exactly one sequence number, even though they carry no data. A pure ACK segment with no data uses none. The acknowledgement number is cumulative and names the next byte expected.

Release normally takes four segments, because each direction is closed separately: a FIN from the side that closes first, an ACK, a FIN from the other side, and an ACK. It takes three segments when the second side sends its FIN together with its ACK. The side that closed first sends the last ACK. It then waits in TIME_WAIT for twice the maximum segment lifetime before the connection is fully removed, so that a lost last ACK can be answered and old segments die out.

The maximum segment size (MSS) is the largest number of data bytes in one segment. Each side announces the MSS it can receive through an option in its SYN segment. With IPv4 and no IP or TCP options, it is usually the link MTU minus 40: a 20-byte IP header and a 20-byte TCP header.

Flow control stops a fast sender from overflowing a slow receiver. In every ACK the receiver advertises its free buffer space as the receiver window (rwnd), in bytes. The sender keeps the amount of unacknowledged data at or below the window. The window field is 16 bits, so without the window-scale option the largest advertised window is $2^{16}-1=65535$ bytes. With the window-scale option, agreed in the SYN segments, the window is $65535\times 2^S$ bytes with $S\le 14$. For example, filling a 1 Gbps path with a 100 ms RTT needs $1.25\times 10^7$ bytes, so $2^S\ge 1.25\times 10^7/65535\approx 190.7$, and $S=8$.

If the receiver advertises a window of 0, the sender stops sending data. It sends small window probes on a persist timer until a non-zero window is advertised. Advertising or sending very small windows, a few bytes at a time, is called silly window syndrome. The receiver avoids it by not advertising a window until a reasonable amount of space is free, and the sender avoids it with Nagle's algorithm, which holds back small segments while earlier data is unacknowledged.

RTT samples are not taken from retransmitted segments, because the ACK cannot be matched to a particular transmission (Karn's algorithm). After each timeout the RTO is doubled (exponential back-off) until a fresh sample arrives. If a question gives its own smoothing weight α, use that weight. Check whether α multiplies the old estimate (new = α × old + (1 − α) × sample) or the sample. Unit convention: for data rates, 1 Mbps = $10^6$ bits per second and 1 Gbps = $10^9$ bits per second; 1 byte = 8 bits; a window or buffer quoted in KB is $2^{10}$ bytes only if the question says so, otherwise $10^3$ bytes.

The congestion window (cwnd) limits the data in flight so that the network is not overloaded. The slow-start threshold (ssthresh) marks where growth changes from exponential to linear. In the traces below, window sizes are counted in units of MSS and cwnd starts at 1 MSS unless the question says otherwise. If a question gives windows in KB, divide by the MSS to work in segments.

Conventions used when tracing round by round. Round $n$ is the round trip in which the sender transmits cwnd segments. In slow start the window doubles from one round to the next but is capped at ssthresh: if doubling would pass ssthresh, the next round uses exactly ssthresh, and from then on the window grows by 1 per round. After a loss in round $n$, round $n+1$ uses the new cwnd. If the question states a different convention, follow it.