Question

Suppose a client \(C\) repeatedly connects via TCP to a given port on a server \(S\), and that each time it is \(\mathrm{C}\) that initiates the close. (a) How many TCP connections a second can C make here before it ties up all its available ports in TIME_WAIT state? Assume client ephemeral ports are in the range 1024-5119, and that TIME_WAIT lasts 60 seconds. (b) Berkeley-derived TCP implementations typically allow a socket in TIME WAIT state to be reopened before TIME_WAIT expires, if the highest sequence number used by the old incarnation of the connection is less than the ISN used by the new incarnation. This solves the problem of old data accepted as new; however, TIME_WAIT also serves the purpose of handling late final FINs. What would such an implementation have to do to address this and still achieve strict compliance with the TCP requirement that a FIN sent anytime before or during a connection's TIME_WAIT receive the same response?

Short answer

(a) Approximately 68 connections per second. (b) Implement careful sequence number tracking to handle late FIN packets while complying with TCP requirements.

Step-by-step solution

(a) - Determine the number of available ports

The range of ephemeral ports for client C is 1024-5119. To find the total number of available ports, subtract the lower bound from the upper bound and add one: \[ \text{Total ports} = 5119 - 1024 + 1 = 4096 \]

(a) - Calculate the maximum connections per second

The TIME_WAIT state lasts 60 seconds, meaning each of the 4096 ports can only be reused once per minute. To find the maximum number of TCP connections that can be initiated per second, divide the total number of ports by the TIME_WAIT duration: \[ \text{Max connections per second} = \frac{4096}{60} \approx 68 \]

(b) - Understand the sequence number check

Berkeley-derived TCP implementations allow reopening of sockets in TIME_WAIT if the new Initial Sequence Number (ISN) exceeds the highest sequence number used by the previous connection. This prevents old data from being accepted as new.

(b) - Addressing late FIN packets

To handle late FIN packets while complying with TCP requirements, the new implementation must ensure that any FIN packet received during TIME_WAIT receives appropriate acknowledgment. This can be achieved by carefully tracking sequence numbers and ensuring that any FIN received after the ISN check will receive the same response as it would have before the check.

Key concepts

Ephemeral Ports

Ephemeral ports are temporary ports used by client devices when establishing a connection to a server. These ports are automatically selected from a predefined range by the operating system. In this case, the ephemeral port range is 1024 to 5119. This range provides a total of 4096 ports, calculated by subtracting the lower bound from the upper bound and adding one: \(\text{Total Ports} = 5119 - 1024 + 1 = 4096\).
When a client initiates a TCP connection, an ephemeral port is chosen to serve as the source port for the communication. Each connection will use a unique port within the specified range, ensuring that data sent and received can be correctly handled.
These ports are essential for managing multiple simultaneous connections, as each pair of client and server ports must be unique. Running out of ephemeral ports can limit the client’s ability to initiate new connections. This becomes significant when understanding TIME_WAIT, as outlined in the next section.

TIME_WAIT State

The TIME_WAIT state is a mechanism within the TCP protocol to ensure all packets of a closing connection are appropriately dealt with.
When a client initiates a connection closure, the port enters the TIME_WAIT state, which lasts for a specified duration (60 seconds in this case). During this period, the port cannot be reused for a new connection, ensuring any delayed packets are either acknowledged or dropped.
To determine how many TCP connections a client can make per second before all ephemeral ports are occupied, we calculate the following:

• Total ephemeral ports: 4096
• Duration of TIME_WAIT: 60 seconds

Thus, the maximum number of new TCP connections the client can initiate per second is \( \frac{4096}{60} \approx 68 \) connections. This highlights the importance of managing ephemeral ports efficiently to sustain high-frequency connection requests.

Sequence Number Handling

Sequence numbers in TCP ensure that packets are received and processed in the correct order. After a connection is closed, a mechanism must uphold the integrity of these sequence numbers.
Berkeley-derived TCP implementations allow reuse of a socket in TIME_WAIT if the new Initial Sequence Number (ISN) is greater than the highest sequence number previously used. This prevents old data from masquerading as new.
However, handling late FIN packets still requires compliance with TCP requirements. Even with the old connection closed, any late-arriving FIN packets should be acknowledged correctly to maintain protocol integrity. The implementation must maintain a record of sequence numbers to ensure late FIN packets, even during TIME_WAIT, receive the appropriate response.
This systematic handling of sequence numbers ensures a robust and reliable communication process, preventing potential data corruption or loss due to improper sequence tracking.