PMTU Calculation Using TCP MSS: Reliable for Asymmetric Paths?

Title: Reliable Determination of Path Maximum Transmission Unit (PMTU) using TCP Connections

Introduction

In this article, we will discuss a method for determining the Path Maximum Transmission Unit (PMTU) using TCP connections. The PMTU is the maximum size of a data packet that can be transmitted along a network path without being fragmented. Fragmentation can lead to increased network congestion and reduced performance. This article will cover the key concepts of PMTU, the method for determining it using TCP, and potential reliability issues in various routing scenarios.

Determining PMTU using TCP Connections

To determine the PMTU of a network path, we can use the TCP connection setup process. When a client initiates a TCP connection with a server, the server sends a SYN-ACK response containing the Maximum Segment Size (MSS) field. The MSS field indicates the maximum size of data segments that the server can handle. By sending packets of varying sizes and observing packet losses due to fragmentation, we can deduce the PMTU of the network path.

Potential Reliability Issues

While this method is generally reliable, there are scenarios where it may not work as expected. For instance, if the network path includes multiple routers with different MTUs, the method may not accurately determine the smallest MTU along the path. Additionally, if the network is congested, the method may not reliably detect packet losses due to fragmentation, as losses may be due to other reasons such as network congestion or router errors.

Code Example

Here's a simple Python script that demonstrates the process of determining the PMTU using TCP connections:

import socket
import time

def find_pmtu(target_host, target_port):
    # Create a raw socket
    s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)

    # Set the IP TTL to 1
    s.setsockopt(socket.IPPROTO_IP, socket.IP_TTL, 1)

    # Set the initial MSS to a large value
    initial_mss = 65535

    # Define the buffer size
    buffer_size = 8192

    # Define the maximum number of attempts
    max_attempts = 10

    # Define the minimum MSS
    min_mss = 40

    # Initialize the MSS
    mss = initial_mss

    for _ in range(max_attempts):
        # Create a TCP packet
        packet = (
            b'\x45'  # TCP header (SYN flag set)
            + struct.pack('!H', mss)  # MSS field
            + b'\x00' * (buffer_size - (mss + 20))  # Options and padding
            + b'\x00' * 44  # TCP and IP headers
        )

        # Send the packet to the target host and port
        s.sendto(packet, (target_host, target_port))

        # Wait for a response
        start_time = time.time()
        while True:
            try:
                response, addr = s.recvfrom(4096)
                if response[0] == 0x45:  # Check for TCP SYN-ACK response
                    break
            except socket.timeout:
                continue

        # Calculate the round-trip time (RTT)
        rtt = time.time() - start_time

        # If the response is too late, assume fragmentation and decrease MSS
        if rtt > 0.1:
            mss = max(mss - 40, min_mss)
            print(f"MSS: {mss}")
        else:
            # If the response is timely, assume the current MSS is the PMTU
            print(f"PMTU: {mss}")
            return mss

    # If the maximum number of attempts is reached, return an error
    print("Failed to determine PMTU")
    return None

# Example usage
find_pmtu('8.8.8.8', 80)

References

• RFC 1191: Path MTU Discovery
• TCP/IP Illustrated, Volume 1: The Protocols
• Understanding Path MTU Discovery