TIME_WAIT Timer: The Guardian of Connection Integrity

TCP Connection Termination: Four-Way Handshake with TIME_WAIT
 
    Active Closer (Client)              Passive Closer (Server)
         |                                       |
         |  ESTABLISHED                          | ESTABLISHED
         |                                       |
         |----------- FIN (Seq=X) ------------->| 
         |  FIN_WAIT_1                           | CLOSE_WAIT
         |                                       |
         |<---------- ACK (Ack=X+1) ------------|
         |  FIN_WAIT_2                           |
         |                                       | [Server app calls close()]
         |                                       |
         |<---------- FIN (Seq=Y) --------------|
         |                                       | LAST_ACK
         |                                       |
         |----------- ACK (Ack=Y+1) ----------->|
         |  TIME_WAIT                            | CLOSED ✓
         |                                       |
         |  [Waits 2MSL...]                      |
         |                                       |
         |  [2MSL timer expires]                 |
         |  CLOSED ✓                             |
         
         Timeline:
         ─────────────────────────────────────────────────
         │<──── Active termination ────>│<─ 2MSL wait ─>│
                                        │               │
                                        Passive closer  Active closer
                                        is done         can finally
                                                        close

The Old Duplicate Problem (Without TIME_WAIT)
 
Time    Connection A                    Connection B (Same port pair)
        Host1:5000 ↔ Host2:80          Host1:5000 ↔ Host2:80
────────────────────────────────────────────────────────────────────
t=0     Sends Data(Seq=1000)            
        Segment takes slow path          
        through congested router...      
        
t=1     Connection closes               
        (No TIME_WAIT in                
        this hypothetical)               
        
t=2                                     Opens (same ports)
                                        Seq numbers start fresh
                                        (e.g., ISN=950)
                                        
t=3                                     Sends Data(Seq=1000)
                                        Receives ACK(Ack=1500)
                                        
t=4     Old segment finally             
        arrives! ─────────────────────> Arrives at Host2
                                        Seq=1000 (within window!)
                                        
                                        💥 Host2 ACCEPTS old data
                                        as valid!
                                        
                                        Data stream corrupted.
 
───────────────────────────────────────────────────────────────────
 
With TIME_WAIT: Host1 holds port 5000 for 2MSL after Connection A 
closes. The old segment expires in transit. Connection B must wait
or use a different port. Problem prevented.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

"""
Maximum Segment Lifetime (MSL) and TIME_WAIT Duration
 
Demonstrates the relationship between MSL and TIME_WAIT across
different operating systems and how connection closure timing works.
"""
 
from dataclasses import dataclass
from typing import Dict
 
 
@dataclass
class TCPTimingConfig:
    """TCP timing configuration for an operating system."""
    name: str
    msl_seconds: int
    additional_notes: str = ""
    
    @property
    def time_wait_seconds(self) -> int:
        return 2 * self.msl_seconds
    
    @property
    def time_wait_formatted(self) -> str:
        tw = self.time_wait_seconds
        if tw >= 60:
            return f"{tw // 60}m {tw % 60}s"
        return f"{tw}s"
 
 
# Common OS configurations
OS_CONFIGS = {
    "linux_default": TCPTimingConfig(
        name="Linux (default)",
        msl_seconds=30,
        additional_notes="Can be affected by tcp_fin_timeout (not MSL directly)"
    ),
    "linux_lowlatency": TCPTimingConfig(
        name="Linux (tuned)",
        msl_seconds=15,
        additional_notes="Sometimes reduced for high-frequency trading"
    ),
    "windows_default": TCPTimingConfig(
        name="Windows (default)",
        msl_seconds=120,
        additional_notes="Registry: TcpTimedWaitDelay"
    ),
    "macos_default": TCPTimingConfig(
        name="macOS (default)",
        msl_seconds=15,
        additional_notes="Shorter than traditional 30 seconds"
    ),
    "rfc793_spec": TCPTimingConfig(
        name="RFC 793 Specification",
        msl_seconds=120,
        additional_notes="Original conservative specification"
    ),
    "bsd_typical": TCPTimingConfig(
        name="BSD (typical)",
        msl_seconds=30,
        additional_notes="FreeBSD, OpenBSD"
    ),
}
 
 
def print_msl_comparison():
    """Print MSL and TIME_WAIT comparison across operating systems."""
    
    print("=" * 75)
    print("Maximum Segment Lifetime (MSL) and TIME_WAIT Duration")
    print("=" * 75)
    print()
    
    print(f"{'OS/Specification':<25} {'MSL':<10} {'TIME_WAIT':<12} {'Notes'}")
    print("-" * 75)
    
    for config in OS_CONFIGS.values():
        print(f"{config.name:<25} {config.msl_seconds:>4}s     "
              f"{config.time_wait_formatted:<12} {config.additional_notes}")
    
    print()
    print("Formula: TIME_WAIT = 2 × MSL")
    print()
 
 
def calculate_time_wait_impact(connections_per_second: int, 
                               msl_seconds: int = 30) -> Dict[str, float]:
    """
    Calculate the impact of TIME_WAIT on a busy server.
    
    Args:
        connections_per_second: Rate of new connections (active closer)
        msl_seconds: MSL value in seconds
    
    Returns:
        Dictionary with impact metrics
    """
    time_wait_duration = 2 * msl_seconds
    
    # Connections in TIME_WAIT at steady state:
    # = connections_per_second × time_wait_duration
    connections_in_time_wait = connections_per_second * time_wait_duration
    
    # Each connection uses ~1KB memory for TCB
    memory_usage_kb = connections_in_time_wait * 1
    memory_usage_mb = memory_usage_kb / 1024
    
    return {
        "connections_in_time_wait": connections_in_time_wait,
        "time_wait_duration_seconds": time_wait_duration,
        "estimated_memory_mb": memory_usage_mb,
        "ephemeral_port_usage_percent": 
            (connections_in_time_wait / 16384) * 100  # Assuming 16K port range
    }
 
 
def demonstrate_time_wait_accumulation():
    """Show how TIME_WAIT connections accumulate on busy servers."""
    
    print("=" * 75)
    print("TIME_WAIT Accumulation on Busy Servers")
    print("=" * 75)
    print()
    
    scenarios = [
        ("Low traffic website", 10),
        ("Moderate API server", 100),
        ("High traffic service", 1000),
        ("Heavy load balancer", 5000),
        ("Extreme: benchmarking", 10000),
    ]
    
    print(f"{'Scenario':<25} {'Conn/s':<10} {'TW Conns':<12} "
          f"{'Memory':<10} {'Port %'}")
    print("-" * 75)
    
    for name, cps in scenarios:
        impact = calculate_time_wait_impact(cps)
        warning = " ⚠️" if impact["ephemeral_port_usage_percent"] > 50 else ""
        
        print(f"{name:<25} {cps:<10} "
              f"{impact['connections_in_time_wait']:<12,.0f} "
              f"{impact['estimated_memory_mb']:<10.1f}MB "
              f"{impact['ephemeral_port_usage_percent']:.1f}%{warning}")
    
    print()
    print("⚠️  = High ephemeral port usage (may cause port exhaustion)")
    print()
    print("Note: Each TIME_WAIT connection holds a port for 60 seconds (default)")
 
 
if __name__ == "__main__":
    print_msl_comparison()
    print()
    demonstrate_time_wait_accumulation()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

"""
TIME_WAIT Management Socket Options
 
Demonstrates various socket options and techniques for
managing TIME_WAIT connections.
"""
 
import socket
import struct
 
 
def create_server_socket_with_reuseaddr(port: int) -> socket.socket:
    """
    Create a server socket with SO_REUSEADDR.
    
    This is the standard, safe approach that should be used
    on virtually all server sockets.
    """
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
    # SO_REUSEADDR: Allow binding to an address in TIME_WAIT
    # This is safe and almost always desirable for servers
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    
    sock.bind(('0.0.0.0', port))
    sock.listen(128)
    
    print(f"Server listening on port {port} with SO_REUSEADDR")
    return sock
 
 
def close_with_rst_no_time_wait(sock: socket.socket):
    """
    Close socket with RST, skipping TIME_WAIT entirely.
    
    ⚠️ WARNING: This is dangerous and should only be used for
    abnormal termination. It can cause data loss.
    
    Setting SO_LINGER with l_linger=0 causes close() to:
    1. Discard any unsent data
    2. Send RST instead of FIN
    3. Close immediately without TIME_WAIT
    """
    # struct linger { int l_onoff; int l_linger; }
    # l_onoff=1 (enable), l_linger=0 (zero timeout = RST)
    linger_struct = struct.pack('ii', 1, 0)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, linger_struct)
    
    print("⚠️  Socket will send RST on close (no TIME_WAIT, but risky!)")
    sock.close()
 
 
def configure_linux_tcp_tw_reuse():
    """
    Instructions for enabling tcp_tw_reuse on Linux.
    
    tcp_tw_reuse allows reusing TIME_WAIT sockets for NEW OUTBOUND
    connections if certain conditions are met:
    - TCP timestamps are enabled
    - New connection is from same local IP (different from SO_REUSEADDR)
    """
    print("Linux tcp_tw_reuse configuration:")
    print("=" * 50)
    print()
    print("# Check current setting")
    print("sysctl net.ipv4.tcp_tw_reuse")
    print()
    print("# Enable (requires timestamps)")
    print("sysctl -w net.ipv4.tcp_tw_reuse=1")
    print()
    print("# Ensure timestamps are enabled (usually default)")
    print("sysctl net.ipv4.tcp_timestamps")
    print()
    print("Note: Only helps OUTBOUND connections, not inbound.")
    print("For servers (inbound), use SO_REUSEADDR instead.")
 
 
def connection_pool_example():
    """
    Conceptual example of connection pooling to avoid TIME_WAIT.
    
    Instead of:
        for request in requests:
            conn = connect(server)
            send(conn, request)
            response = recv(conn)
            close(conn)  # Creates TIME_WAIT!
            
    Use:
        pool = ConnectionPool(server, size=10)
        for request in requests:
            conn = pool.get()  # Reuses existing connection
            send(conn, request)
            response = recv(conn)
            pool.put(conn)  # Returns to pool, stays open
    """
    
    print("Connection Pooling: The Best Solution")
    print("=" * 50)
    print()
    print("Without pooling:")
    print("  1000 req/s × 60s TIME_WAIT = 60,000 sockets")
    print()
    print("With pooling (10 connections):")
    print("  1000 req/s ÷ 100 req/s per conn = 10 active sockets")
    print("  No TIME_WAIT accumulation!")
    print()
    print("Common pooling libraries:")
    print("  - SQLAlchemy (database)")
    print("  - urllib3 (HTTP)")
    print("  - redis-py (Redis)")
    print("  - grpcio (gRPC channels)")
 
 
def demonstrate_who_should_close_first():
    """
    Show the impact of which side closes first.
    
    The side that closes first enters TIME_WAIT.
    Choosing wisely can shift TIME_WAIT to clients or to servers.
    """
    
    print("Who Should Close First?")
    print("=" * 50)
    print()
    print("Server closes first (HTTP/1.0 typical):")
    print("  → Server accumulates TIME_WAIT")
    print("  → Problem: Busy servers exhaust resources")
    print()
    print("Client closes first (HTTP/1.1 typical):")
    print("  → Client accumulates TIME_WAIT")  
    print("  → Better: Distributed across many clients")
    print()
    print("Neither closes (Keep-Alive):")
    print("  → Connections reused")
    print("  → Best: Minimal TIME_WAIT overall")
    print()
    print("Strategy: Use Keep-Alive when possible.")
    print("When closing is needed, prefer client closes first.")
 
 
if __name__ == "__main__":
    configure_linux_tcp_tw_reuse()
    print()
    connection_pool_example()
    print()
    demonstrate_who_should_close_first()