IP Fragmentation Calculations: Mastering the Mathematics

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

import math
 
# Problem 1.1: Standard Ethernet Fragmentation
print("Problem 1.1 Solution")
print("="*60)
 
# Given
total_length = 4500  # Including header
ip_header = 20
mtu = 1500
 
# a) Maximum data per fragment
original_data = total_length - ip_header  # 4480 bytes
max_frag_data = ((mtu - ip_header) // 8) * 8
print(f"a) Original data: {original_data} bytes")
print(f"   Max data per fragment: {max_frag_data} bytes")
 
# b) Number of fragments
num_fragments = math.ceil(original_data / max_frag_data)
print(f"\nb) Number of fragments: {num_fragments}")
 
# c) Data size in each fragment
print(f"\nc) Data sizes:")
remaining = original_data
for i in range(num_fragments):
    if remaining >= max_frag_data:
        frag_data = max_frag_data
    else:
        frag_data = remaining
    print(f"   Fragment {i+1}: {frag_data} bytes")
    remaining -= frag_data
 
# d) Fragment Offset values
print(f"\nd) Fragment Offset values:")
cumulative = 0
for i in range(num_fragments):
    offset_bytes = cumulative
    offset_field = cumulative // 8
    frag_data = max_frag_data if i < num_fragments-1 else original_data - cumulative
    mf = 1 if i < num_fragments-1 else 0
    print(f"   Fragment {i+1}: Offset = {offset_field} (byte {offset_bytes}), MF = {mf}")
    cumulative += frag_data
 
# e) Total bytes transmitted
total_transmitted = original_data + (num_fragments * ip_header)
print(f"\ne) Total bytes transmitted: {total_transmitted} bytes")
print(f"   ({original_data} data + {num_fragments * ip_header} headers)")
print(f"   Overhead: {(num_fragments-1) * ip_header} bytes additional headers")

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

import math
 
# Problem 1.2: Non-Standard MTU with alignment
print("Problem 1.2 Solution")
print("="*60)
 
# Given
original_data = 3180
mtu = 1006
ip_header = 20
 
# a) Maximum fragment data with 8-byte alignment
available = mtu - ip_header  # 986 bytes
max_frag_data = (available // 8) * 8  # 984 bytes
print(f"a) Available space: {available} bytes")
print(f"   Max fragment data (8-byte aligned): {max_frag_data} bytes")
print(f"   Note: {available} ÷ 8 = {available/8} → floor to {available//8} × 8 = {max_frag_data}")
 
# b) Number of fragments
num_fragments = math.ceil(original_data / max_frag_data)
print(f"\nb) Number of fragments: {num_fragments}")
print(f"   {original_data} ÷ {max_frag_data} = {original_data/max_frag_data:.4f} → ⌈⌉ = {num_fragments}")
 
# c) Last fragment data size
last_frag_data = original_data - (num_fragments - 1) * max_frag_data
print(f"\nc) Last fragment data: {last_frag_data} bytes")
print(f"   3180 - (3 × 984) = 3180 - 2952 = {last_frag_data}")
 
# d) Wasted bytes per fragment
wasted_per_frag = available - max_frag_data
total_wasted = wasted_per_frag * (num_fragments - 1)  # Last fragment can use any size
print(f"\nd) Wasted per non-final fragment: {wasted_per_frag} bytes")
print(f"   Total wasted: {total_wasted} bytes (first {num_fragments-1} fragments)")
print(f"   Last fragment uses only {last_frag_data}/{available} available bytes")

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

import math
 
# Problem 2.1: Cascading Fragmentation
print("Problem 2.1 Solution: Cascading Fragmentation")
print("="*60)
 
def max_frag_data(mtu, header=20):
    return ((mtu - header) // 8) * 8
 
def fragment_at_hop(current_fragments, mtu):
    """Fragment a list of (offset_bytes, size) tuples at given MTU."""
    max_data = max_frag_data(mtu)
    new_fragments = []
    
    for offset_bytes, size in current_fragments:
        if size <= max_data:
            new_fragments.append((offset_bytes, size))
        else:
            curr_offset = offset_bytes
            remaining = size
            while remaining > 0:
                frag_size = min(remaining, max_data)
                # Align all but potentially last piece
                if remaining > max_data:
                    frag_size = max_data
                new_fragments.append((curr_offset, frag_size))
                curr_offset += frag_size
                remaining -= frag_size
    
    return new_fragments
 
# Initial datagram
original_data = 9980
initial = [(0, original_data)]  # (offset, size)
 
mtu_path = [4000, 1500, 576]
 
for hop, mtu in enumerate(mtu_path):
    print(f"\n--- Link {hop+1}: MTU {mtu} ---")
    print(f"Max fragment data: {max_frag_data(mtu)} bytes")
    
    if hop == 0:
        fragments = fragment_at_hop(initial, mtu)
    else:
        fragments = fragment_at_hop(fragments, mtu)
    
    print(f"Fragments after this link: {len(fragments)}")
 
# b) Final fragment count
print(f"\n" + "="*60)
print(f"b) Total fragments at destination: {len(fragments)}")
 
# c) Fragment Offset values
print(f"\nc) Final fragment details:")
for i, (offset, size) in enumerate(fragments):
    offset_field = offset // 8
    mf = 0 if i == len(fragments)-1 else 1
    print(f"   Frag {i+1:2d}: Offset = {offset_field:4d} (byte {offset:5d}), "
          f"Size = {size:3d} bytes, MF = {mf}")
 
# d) Header overhead
ip_header = 20
total_headers = len(fragments) * ip_header
original_header = ip_header
overhead = total_headers - original_header
print(f"\nd) Header overhead:")
print(f"   Total headers: {len(fragments)} × {ip_header} = {total_headers} bytes")
print(f"   Original header: {original_header} bytes")
print(f"   Overhead: {overhead} bytes")
 
# Verify total data
total_data = sum(size for _, size in fragments)
print(f"\nVerification: Total data = {total_data} bytes "
      f"({'✓' if total_data == original_data else '✗'})")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import math
 
# Problem 2.2: Shortcut verification
print("Problem 2.2: Shortcut Verification")
print("="*60)
 
original_data = 9980
min_mtu = 576
ip_header = 20
 
max_data_at_min = ((min_mtu - ip_header) // 8) * 8
direct_fragments = math.ceil(original_data / max_data_at_min)
 
print(f"Original data: {original_data} bytes")
print(f"Minimum MTU: {min_mtu}")
print(f"Max fragment data at min MTU: {max_data_at_min} bytes")
print(f"Direct fragmentation: ⌈{original_data}/{max_data_at_min}⌉ = {direct_fragments} fragments")
print(f"\nThis matches the cascaded result: {direct_fragments} == 19 ✓")
print("\nKey insight: Final fragment count depends ONLY on minimum MTU,")
print("regardless of where or how many times fragmentation occurs.")

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

# Problem 3.1: VoIP Packet Fragmentation
print("Problem 3.1 Solution: VoIP over IPsec VPN")
print("="*60)
 
# Given parameters
audio_data = 160
udp_header = 8
inner_ip = 20
esp_header = 8
esp_trailer = 10
esp_auth = 12
outer_ip = 20
mtu = 1500
 
print("Encapsulation stack:")
print(f"  Audio data:     {audio_data} bytes")
print(f"  UDP header:     {udp_header} bytes")
print(f"  Inner IP:       {inner_ip} bytes")
print(f"  ESP header:     {esp_header} bytes")
print(f"  ESP trailer:    {esp_trailer} bytes")
print(f"  ESP auth:       {esp_auth} bytes")
print(f"  Outer IP:       {outer_ip} bytes")
 
# a) Complete encapsulated size
inner_packet = audio_data + udp_header + inner_ip
ipsec_payload = inner_packet + esp_trailer
ipsec_total = esp_header + ipsec_payload + esp_auth
outer_packet = outer_ip + ipsec_total
 
print(f"\na) Encapsulated packet size:")
print(f"   Inner packet: {inner_packet} bytes")
print(f"   After IPsec: {ipsec_total} bytes")
print(f"   Outer packet: {outer_packet} bytes")
 
# b) Fragmentation check
print(f"\nb) MTU: {mtu} bytes")
if outer_packet <= mtu:
    print(f"   {outer_packet} ≤ {mtu}: NO fragmentation ✓")
else:
    print(f"   {outer_packet} > {mtu}: Fragmentation required!")
 
# c) With larger audio payload
print(f"\nc) With 1,000 bytes audio:")
larger_audio = 1000
larger_inner = larger_audio + udp_header + inner_ip
larger_ipsec = esp_header + larger_inner + esp_trailer + esp_auth
larger_outer = outer_ip + larger_ipsec
print(f"   Outer packet: {larger_outer} bytes")
if larger_outer <= mtu:
    print(f"   {larger_outer} ≤ {mtu}: NO fragmentation")
else:
    print(f"   {larger_outer} > {mtu}: Fragmentation REQUIRED")
    # Calculate fragments
    outer_data = larger_ipsec
    max_frag = ((mtu - outer_ip) // 8) * 8
    import math
    frags = math.ceil(outer_data / max_frag)
    print(f"   Fragments: {frags}")
 
# d) Maximum audio payload
print(f"\nd) Maximum audio payload without fragmentation:")
# Work backwards from MTU
max_outer_data = mtu - outer_ip  # 1480
max_ipsec_payload = max_outer_data - esp_header - esp_auth  # 1460
max_inner = max_ipsec_payload - esp_trailer  # 1450
max_audio = max_inner - udp_header - inner_ip  # 1422
print(f"   Max outer IP data: {max_outer_data} bytes")
print(f"   Max IPsec payload: {max_ipsec_payload} bytes")
print(f"   Max inner packet: {max_inner} bytes")
print(f"   Max audio data: {max_audio} bytes")

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

import math
 
# Problem 3.2: DNS Response Fragmentation
print("Problem 3.2 Solution: DNS Response Fragmentation")
print("="*60)
 
# Given
dns_response = 2048  # Including DNS header
udp_header = 8
ip_header = 20
min_mtu = 576
 
# a) Complete IP datagram size
udp_data = dns_response  # DNS is the UDP payload
ip_data = udp_data + udp_header
ip_datagram = ip_data + ip_header
 
print(f"a) IP datagram size:")
print(f"   DNS response: {dns_response} bytes")
print(f"   UDP datagram: {udp_data + udp_header} bytes")
print(f"   IP datagram: {ip_datagram} bytes")
 
# b) Number of fragments
max_frag_data = ((min_mtu - ip_header) // 8) * 8
num_fragments = math.ceil(ip_data / max_frag_data)
 
print(f"\nb) Fragmentation at MTU {min_mtu}:")
print(f"   Max fragment data: {max_frag_data} bytes")
print(f"   IP payload to fragment: {ip_data} bytes")
print(f"   Fragments: ⌈{ip_data}/{max_frag_data}⌉ = {num_fragments}")
 
# c) Historical DNS limit
print(f"\nc) Why 512-byte DNS limit:")
traditional_dns = 512
traditional_udp = traditional_dns + udp_header  # 520
traditional_ip = traditional_udp + ip_header  # 540
print(f"   512-byte DNS + 8 UDP + 20 IP = {traditional_ip} bytes")
print(f"   {traditional_ip} < {min_mtu} (minimum MTU): NO fragmentation")
print(f"   This ensured DNS worked across ALL IPv4 networks without fragmentation")
 
# d) Efficiency
total_transmitted = ip_data + (num_fragments * ip_header)
efficiency = (dns_response / total_transmitted) * 100
overhead = (num_fragments - 1) * ip_header
 
print(f"\nd) Efficiency analysis:")
print(f"   DNS data (what we care about): {dns_response} bytes")
print(f"   Total transmitted: {total_transmitted} bytes")
print(f"   Header overhead: {overhead} bytes")
print(f"   Efficiency: {efficiency:.1f}%")
print(f"   For comparison, unfragmented efficiency: "
      f"{(dns_response/ip_datagram)*100:.1f}%")

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

# Problem 4.1: Reconstruct Original Datagram
print("Problem 4.1 Solution: Reconstruct from Capture")
print("="*60)
 
# Captured fragments
fragments = [
    {'name': 'A', 'total_len': 556, 'ihl': 5, 'mf': 1, 'offset': 0},
    {'name': 'B', 'total_len': 556, 'ihl': 5, 'mf': 1, 'offset': 67},
    {'name': 'C', 'total_len': 556, 'ihl': 5, 'mf': 1, 'offset': 134},
    {'name': 'D', 'total_len': 280, 'ihl': 5, 'mf': 0, 'offset': 201},
]
 
print("a) Data size in each fragment:")
for f in fragments:
    header_size = f['ihl'] * 4
    data_size = f['total_len'] - header_size
    f['data_size'] = data_size
    f['header_size'] = header_size
    print(f"   Fragment {f['name']}: {f['total_len']} - {header_size} = {data_size} bytes")
 
print("\nb) Byte range covered by each fragment:")
for f in fragments:
    start_byte = f['offset'] * 8
    end_byte = start_byte + f['data_size'] - 1
    f['start_byte'] = start_byte
    f['end_byte'] = end_byte
    print(f"   Fragment {f['name']}: bytes {start_byte:4d} to {end_byte:4d} "
          f"(offset {f['offset']} × 8 = {start_byte}, +{f['data_size']}-1 = {end_byte})")
 
print("\nc) Original datagram data size:")
last = fragments[-1]  # Fragment with MF=0
original_data = last['offset'] * 8 + last['data_size']
print(f"   Last fragment offset × 8 + last fragment data")
print(f"   = {last['offset']} × 8 + {last['data_size']}")
print(f"   = {last['offset'] * 8} + {last['data_size']}")
print(f"   = {original_data} bytes")
 
print("\nd) Original datagram Total Length:")
original_total = original_data + 20  # Original had one 20-byte header
print(f"   Data + original header = {original_data} + 20 = {original_total} bytes")
 
print("\ne) Continuity verification:")
sorted_frags = sorted(fragments, key=lambda f: f['offset'])
all_continuous = True
for i in range(len(sorted_frags) - 1):
    current = sorted_frags[i]
    next_f = sorted_frags[i + 1]
    expected_next_start = current['end_byte'] + 1
    actual_next_start = next_f['start_byte']
    
    if actual_next_start == expected_next_start:
        status = "✓"
    elif actual_next_start > expected_next_start:
        status = f"GAP of {actual_next_start - expected_next_start} bytes!"
        all_continuous = False
    else:
        status = f"OVERLAP of {expected_next_start - actual_next_start} bytes!"
        all_continuous = False
    
    print(f"   {current['name']}→{next_f['name']}: "
          f"Expected next at {expected_next_start}, found at {actual_next_start} {status}")
 
print(f"\n   Continuity: {'PASSED ✓' if all_continuous else 'FAILED ✗'}")

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

# Problem 4.2: Missing Fragment Detection
print("Problem 4.2 Solution: Missing Fragment Detection")
print("="*60)
 
# Captured fragments (IHL=5 assumed)
fragments = [
    {'num': 1, 'total_len': 1500, 'offset': 0, 'mf': 1},
    {'num': 2, 'total_len': 1500, 'offset': 185, 'mf': 1},
    {'num': 3, 'total_len': 1500, 'offset': 555, 'mf': 0},
]
 
ip_header = 20
 
# Calculate data sizes and byte ranges
for f in fragments:
    f['data'] = f['total_len'] - ip_header
    f['start'] = f['offset'] * 8
    f['end'] = f['start'] + f['data'] - 1
 
print("Fragment analysis:")
for f in fragments:
    print(f"  Fragment {f['num']}: Offset={f['offset']:3d} ({f['start']:5d}-{f['end']:5d}), "
          f"Data={f['data']:4d}, MF={f['mf']}")
 
# Check for gaps
print("\na) Completeness check:")
sorted_frags = sorted(fragments, key=lambda f: f['offset'])
 
missing = []
prev_end = -1
 
for f in sorted_frags:
    expected_start = prev_end + 1
    actual_start = f['start']
    
    if actual_start > expected_start:
        gap_start = expected_start
        gap_end = actual_start - 1
        gap_size = gap_end - gap_start + 1
        missing.append((gap_start, gap_end, gap_size))
        print(f"   GAP detected: bytes {gap_start} to {gap_end} ({gap_size} bytes)")
    
    prev_end = f['end']
 
if not missing:
    print("   Fragment set is COMPLETE ✓")
else:
    print(f"\nb) Missing fragment analysis:")
    for gap_start, gap_end, gap_size in missing:
        expected_offset = gap_start // 8
        print(f"   Missing: bytes {gap_start} to {gap_end}")
        print(f"   Expected offset (field value): {expected_offset}")
        print(f"   Expected data size: {gap_size} bytes")
 
print(f"\nc) Expected offset for missing fragment:")
if missing:
    gap_start = missing[0][0]
    print(f"   Byte position {gap_start} → offset field = {gap_start} ÷ 8 = {gap_start // 8}")
    print(f"   Fragment 2 ends at byte {sorted_frags[1]['end']}")
    print(f"   Fragment 3 starts at byte {sorted_frags[2]['start']}")
    print(f"   Missing fragment should have offset = {(sorted_frags[1]['end']+1) // 8}")

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

# Problem 5.1: GRE Tunnel MTU Configuration
print("Problem 5.1 Solution: GRE Tunnel Configuration")
print("="*60)
 
# Given
physical_mtu = 1500
gre_header = 4
outer_ip = 20
inner_ip = 20
tcp_header = 20  # Minimum
udp_header = 8
 
# a) Maximum tunnel MTU
tunnel_overhead = gre_header + outer_ip  # 24 bytes
max_tunnel_mtu = physical_mtu - tunnel_overhead
 
print(f"a) Maximum tunnel MTU:")
print(f"   Physical MTU: {physical_mtu}")
print(f"   GRE + outer IP overhead: {tunnel_overhead} bytes")
print(f"   Max tunnel MTU: {max_tunnel_mtu} bytes")
print(f"   (This is the max inner IP datagram size)")
 
# b) Recommended TCP MSS
tcp_mss = max_tunnel_mtu - inner_ip - tcp_header
 
print(f"\nb) Recommended TCP MSS:")
print(f"   Tunnel MTU: {max_tunnel_mtu}")
print(f"   Minus inner IP header: -{inner_ip}")
print(f"   Minus TCP header: -{tcp_header}")
print(f"   TCP MSS: {tcp_mss} bytes")
 
# c) Maximum UDP payload
max_udp_payload = max_tunnel_mtu - inner_ip - udp_header
 
print(f"\nc) Maximum UDP payload:")
print(f"   Tunnel MTU: {max_tunnel_mtu}")
print(f"   Minus inner IP: -{inner_ip}")
print(f"   Minus UDP header: -{udp_header}")
print(f"   Max UDP payload: {max_udp_payload} bytes")
 
# d) Check 1400-byte UDP payload
print(f"\nd) 1400-byte UDP payload check:")
test_payload = 1400
inner_datagram = test_payload + udp_header + inner_ip  # 1428
print(f"   UDP payload: {test_payload}")
print(f"   Inner IP datagram: {inner_datagram} bytes")
print(f"   Tunnel MTU: {max_tunnel_mtu} bytes")
 
if inner_datagram <= max_tunnel_mtu:
    print(f"   {inner_datagram} ≤ {max_tunnel_mtu}: NO fragmentation ✓")
else:
    print(f"   {inner_datagram} > {max_tunnel_mtu}: Fragmentation REQUIRED")
 
print(f"\nRecommendation:")
print(f"   Configure 'ip mtu {max_tunnel_mtu}' on tunnel interfaces")
print(f"   Or use 'ip tcp adjust-mss {tcp_mss}' for TCP optimization")

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

import math
 
# Problem 5.2: Data Center Jumbo Frame Analysis
print("Problem 5.2 Solution: Jumbo Frame Analysis")
print("="*60)
 
# Given
internal_mtu = 9000
edge_mtu = 1500
nfs_data = 8000
ip_header = 20
 
# a) Internal network check
print("a) Internal network (MTU 9000):")
ip_datagram = nfs_data + ip_header
print(f"   NFS data: {nfs_data} bytes")
print(f"   IP datagram: {ip_datagram} bytes")
if ip_datagram <= internal_mtu:
    print(f"   {ip_datagram} ≤ {internal_mtu}: NO fragmentation internally ✓")
else:
    print(f"   Fragmentation required internally")
 
# b) Fragments at Internet edge
print(f"\nb) At Internet edge (MTU {edge_mtu}):")
max_frag_data = ((edge_mtu - ip_header) // 8) * 8
num_fragments = math.ceil(nfs_data / max_frag_data)
print(f"   Max fragment data: {max_frag_data} bytes")
print(f"   Fragments per NFS block: {num_fragments}")
 
# c) Daily overhead for 1M blocks
blocks_per_day = 1_000_000
extra_headers_per_block = (num_fragments - 1) * ip_header
daily_overhead = blocks_per_day * extra_headers_per_block
 
print(f"\nc) Daily overhead (1M blocks):")
print(f"   Extra headers per block: {extra_headers_per_block} bytes")
print(f"   Daily overhead: {daily_overhead:,} bytes")
print(f"   = {daily_overhead / 1e6:.1f} MB")
print(f"   = {daily_overhead / 1e9:.3f} GB")
 
# d) Efficiency comparison
print(f"\nd) Efficiency comparison:")
 
# Current: 8000-byte blocks
current_transmitted = nfs_data + (num_fragments * ip_header)
current_efficiency = nfs_data / current_transmitted * 100
 
# Optimized: size for 1500 MTU (no fragmentation)
optimized_data = max_frag_data  # 1480 bytes per datagram
datagrams_optimized = math.ceil(nfs_data / optimized_data)
optimized_transmitted = nfs_data + (datagrams_optimized * ip_header)
optimized_efficiency = nfs_data / optimized_transmitted * 100
 
print(f"   Current (8000-byte blocks):")
print(f"     Transmitted: {current_transmitted} bytes for {nfs_data} bytes data")
print(f"     Efficiency: {current_efficiency:.2f}%")
print(f"\n   Optimized (1480-byte blocks):")
print(f"     Datagrams: {datagrams_optimized}")
print(f"     Transmitted: {optimized_transmitted} bytes for {nfs_data} bytes data")
print(f"     Efficiency: {optimized_efficiency:.2f}%")
 
# Hmm, more datagrams = more headers. Let's reconsider.
# Actually, the question might mean: what if we sent 1480-byte payload datagrams
# that don't require fragmentation?
print(f"\n   Note: More datagrams = more headers, so fragmenting large blocks")
print(f"   and sending smaller blocks are comparable in overhead.")
print(f"   The real win is avoiding reassembly at destination and")
print(f"   preventing all-or-nothing loss of large datagrams.")

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

import math
 
# Problem 6.1: Complete ICMP Fragmentation Analysis
print("Problem 6.1 Solution: Complete ICMP Fragmentation Analysis")
print("="*70)
 
# Given
icmp_data = 4000
icmp_header = 8
ip_header = 20
mtu_path = [1500, 1000, 1500]  # Fragmentation only at MTU decreases
 
# a) Original datagram size
ip_payload = icmp_data + icmp_header  # 4008 bytes
original_total = ip_payload + ip_header  # 4028 bytes
 
print(f"a) Original datagram:")
print(f"   ICMP data: {icmp_data} bytes")
print(f"   ICMP header: {icmp_header} bytes")
print(f"   IP payload: {ip_payload} bytes")
print(f"   Total size: {original_total} bytes")
 
# b) IP payload
print(f"\nb) IP payload (data to fragment): {ip_payload} bytes")
 
# c) Fragments after first hop (MTU 1500→1500: no fragmentation)
# Then at WAN (1500→1000): fragmentation occurs
print(f"\nc) Fragmentation analysis:")
 
def max_frag_data(mtu):
    return ((mtu - ip_header) // 8) * 8
 
min_mtu = min(mtu_path)
max_data = max_frag_data(min_mtu)
print(f"   Minimum MTU on path: {min_mtu} bytes")
print(f"   Max fragment data at min MTU: {max_data} bytes")
print(f"   Local ETH (MTU 1500): No fragmentation (packet fits)")
print(f"   WAN (MTU 1000): Fragmentation required")
 
# d) Final fragments
num_fragments = math.ceil(ip_payload / max_data)
print(f"\nd) Final fragments: {num_fragments}")
 
# e) Fragment details
print(f"\ne) Fragment Offset and MF for each final fragment:")
print(f"   {'Frag':<6} {'Offset':<10} {'OBytes':<10} {'Data':<8} {'MF':<4}")
print(f"   {'-'*6} {'-'*10} {'-'*10} {'-'*8} {'-'*4}")
 
fragment_sizes = []
remaining = ip_payload
current_offset = 0
 
for i in range(num_fragments):
    if remaining > max_data:
        frag_data = max_data
        mf = 1
    else:
        frag_data = remaining
        mf = 0
    
    offset_field = current_offset // 8
    fragment_sizes.append(frag_data)
    
    print(f"   {i+1:<6} {offset_field:<10} {current_offset:<10} {frag_data:<8} {mf}")
    
    current_offset += frag_data
    remaining -= frag_data
 
# f) Total bytes transmitted
total_transmitted = ip_payload + (num_fragments * ip_header)
print(f"\nf) Total bytes transmitted:")
print(f"   IP payload: {ip_payload} bytes")
print(f"   Headers: {num_fragments} × {ip_header} = {num_fragments * ip_header} bytes")
print(f"   Total: {total_transmitted} bytes")
 
# Convert to fragmented packets' wire size
print(f"\n   Individual fragment sizes (Total Length):")
for i, frag_data in enumerate(fragment_sizes):
    frag_total = frag_data + ip_header
    print(f"   Fragment {i+1}: {frag_total} bytes")
 
# g) Overhead percentage
original_headers = ip_header  # Just one 20-byte header originally
extra_headers = (num_fragments - 1) * ip_header
overhead_pct = (extra_headers / original_total) * 100
 
print(f"\ng) Header overhead:")
print(f"   Original header: {original_headers} bytes")
print(f"   Extra from fragmentation: {extra_headers} bytes")
print(f"   Overhead percentage: {overhead_pct:.2f}%")
 
# Verification
print(f"\n{'='*70}")
print(f"Verification:")
print(f"   Sum of fragment data: {sum(fragment_sizes)} bytes")
print(f"   Original IP payload: {ip_payload} bytes")
print(f"   Match: {'✓' if sum(fragment_sizes) == ip_payload else '✗'}")