Question

Suppose a TCP message that contains 2048 bytes of data and 20 bytes of TCP header is passed to IP for delivery across two networks of the Internet (i.e., from the source host to a router to the destination host). The first network uses 14-byte headers and has an MTU of 1024 bytes; the second uses 8-byte headers with an MTU of 512 bytes. Each network's MTU gives the size of the largest IP datagram that can be carried in a link-layer frame. Give the sizes and offsets of the sequence of fragments delivered to the network layer at the destination host. Assume all IP headers are 20 bytes.

Short answer

Fragment sizes: 512, 512, 40, 512, 512, 60 bytes. Offsets: 0, 492/8, 984/8, 1004/8, (1004+492)/8, 2008/8.

Step-by-step solution

Understand the problem

We need to break down a TCP message for delivery across two networks and calculate the sizes and offsets of fragments. The original TCP message is 2048 bytes with a TCP header of 20 bytes. IP headers are 20 bytes. The two networks have MTU of 1024 and 512 bytes, respectively, with their own additional headers.

Calculate data segments without headers

Subtract TCP and IP headers from the MTU to find the maximum data that can be sent in each fragment. First network (MTU 1024 bytes): 1024 - 20 (IP header) = 1004 bytes of data. Second network (MTU 512 bytes): 512 - 20 (IP header) = 492 bytes of data.

Fragment for the first network

Divide the 2048 bytes of data by the first network's data segment size. 2048 / 1004 is approximately 2 full segments with leftover data. - First fragment: Data 1004 bytes + IP header 20 bytes (total 1024 bytes), offset=0.- Second fragment: Data 1004 bytes + IP header 20 bytes (total 1024 bytes), offset=1004/8.

Handle leftover data for the first network

Leftover data: 2048 - 2 * 1004 = 40 bytes. - Third fragment: Data 40 bytes + IP header 20 bytes (total 60 bytes), offset=2008/8.

Fragment for the second network

Now handle the data segments for the second network's MTU (512 bytes). Each fragment can carry 492 bytes of data: - First fragment from 1st fragment: Data 492 bytes + IP header 20 bytes (total 512 bytes), offset=0.- Second fragment from 1st fragment: Data 492 bytes + IP header 20 bytes (total 512 bytes), offset=492/8.- Third fragment from 1st fragment: Data 20 bytes + IP header 20 bytes (total 40 bytes), offset=984/8.

Fragment for the second network's second 1004 bytes data

Divide the next 1004 bytes into smaller parts based on the MTU. - Fourth fragment from 2nd segment: Data 492 bytes + IP header 20 bytes (total 512 bytes), offset=1004/8.- Fifth fragment from 2nd segment: Data 492 bytes + IP header 20 bytes (total 512 bytes), offset=(1004+492)/8.

Handle leftover data for the second network

The remaining 40 bytes from the first network's last segment: - Sixth fragment: Data 40 bytes + IP header (total 60 bytes), offset=2008/8.

Compile list of all fragments

Summarize each fragment sent to the second network: 1. Fragment size=512 bytes, offset=0.2. Fragment size=512 bytes, offset=492/8.3. Fragment size=40 bytes, offset=984/8.4. Fragment size=512 bytes, offset=1004/8.5. Fragment size=512 bytes, offset=(1004+492)/8.6. Fragment size=60 bytes, offset=2008/8.

Key concepts

Maximum Transmission Unit (MTU)

The Maximum Transmission Unit (MTU) signifies the largest packet size that can be transmitted over a network. It includes both the data payload and the headers added by protocol layers. This size limitation ensures that packets can traverse networks without being fragmented.
In our exercise, we encountered two networks with different MTU sizes:

• The first network has an MTU of 1024 bytes.
• The second network has an MTU of 512 bytes.

To calculate how much data each fragment can carry, we subtract the IP header size from the MTU:
For the first network: 1024 bytes - 20 bytes (IP header) = 1004 bytes of data.
For the second network: 512 bytes - 20 bytes (IP header) = 492 bytes of data.

TCP message

The TCP (Transmission Control Protocol) message contains both a header and data payload. In this exercise, the message is divided before transmission to ensure it adheres to the MTU sizes of both networks.
Given the outlined problem:

• The original TCP message has 2048 bytes of data.
• The TCP header, which includes control information, is 20 bytes.

The total message size before fragmentation is 2068 bytes (2048 bytes of data + 20 bytes TCP header). The task is to break this message into fragments that conform to the MTU restrictions of 1024 and 512 bytes, taking the headers into account.

IP headers

IP (Internet Protocol) headers play a crucial role in networking by providing information on how data packets should be transmitted and routed. Each fragment of a fragmented TCP message carries its own IP header.
In this exercise, each fragment needs an additional 20 bytes IP header:

• For the first network, each fragment carries 1004 bytes of data plus a 20-byte IP header.
• For the second network, each fragment carries 492 bytes of data plus a 20-byte IP header.

These headers are essential for correctly reassembling the message at the destination.

Data segments

Data segments refer to the portions of data that are transmitted within each network packet. They are derived by subtracting the size of necessary headers from the MTU. In this exercise, we fragment the TCP message into smaller segments to fit the MTU requirements.
The fragmentation steps for the first network, with an MTU of 1024 bytes, resulted in:

• Two full segments of 1004 bytes of data, each with a 20-byte IP header.
• A final remaining segment of 40 bytes of data with a 20-byte IP header.

Then, for the second network, with an MTU of 512 bytes:

• Each of these larger fragments was further divided into segments of 492 bytes of data with a 20-byte IP header.

This ensures that all data segments match the respective MTU limits.

Network fragmentation

Network fragmentation occurs when a packet is too large to be transmitted over a network and must be broken down into smaller fragments. Each fragment includes its own header to ensure the data is correctly reassembled at the receiving end.
For the first network, the fragmentation sequence was as follows:

• Fragment 1: 1004 bytes of data + 20-byte IP header = 1024 bytes, offset=0.
• Fragment 2: 1004 bytes of data + 20-byte IP header = 1024 bytes, offset=1004/8.
• Fragment 3: 40 bytes of data + 20-byte IP header = 60 bytes, offset=2008/8.

Further fragmentation occurred for the second network:

• These fragments were broken down further to meet the MTU of 512 bytes.
• E.g., Fragment 1 from the first segment was split into smaller 492-byte segments plus a 20-byte IP header.

Proper fragmentation and reassembly processes are vital for data integrity in networking.