My understanding is that

1/ the Transport Layer in the TCP/IP stack creates packets for data that is being sent out, and

2/ the packets reassembly process occurs at the receiving end's Internet layer, not at its Transport layer.

Please confirm whether any of this is accurate.

EDIT: my textbook claims that apparently

  1. TCP creates one or more packets and sends the first one to IP...

and says that the Internet Layer simply passes on this as a datagram with IP addresses, and does not mention anything about reassembly, so I was simply curious.

  • TCP (layer-4, Transport layer) divides a data stream into segments, which are encapsulated by IP (layer-3, Network layer) into packets, which are encapsulated by layer-2 (Data-Link layer) into frames which are encoded on the "wire" by layer-1 (Physical layer).
    – Ron Maupin
    May 14, 2017 at 19:45

3 Answers 3


Packets are layer-3 (Network layer) datagrams. Fragmentation and reassembly of packets is built into IPv4.

Many people get confused because TCP (layer-4, Transport layer) segments a data stream, guarantees delivery of the individual segments, and reassembles them back into a data stream for the application. This is not the same as packet fragmentation and reassembly.

Fragmentation and reassembly of packets can be processor intensive and use resources required to perform high-speed packet switching (routing). Because of this, fragmentation is performed by IPv4, but IPv6 has done away with packet fragmentation. Instead, IPv6 requires the source host to perform fragmentation if it is necessary anywhere along the path.

RFC 791, Internet Protocol:

The internet protocol also provides for fragmentation and reassembly of long datagrams, if necessary, for transmission through "small packet" networks.


The internet protocol implements two basic functions: addressing and fragmentation.


In the routing of messages from one internet module to another, datagrams may need to traverse a network whose maximum packet size is smaller than the size of the datagram. To overcome this difficulty, a fragmentation mechanism is provided in the internet protocol.



Fragmentation of an internet datagram is necessary when it originates in a local net that allows a large packet size and must traverse a local net that limits packets to a smaller size to reach its destination.

An internet datagram can be marked "don't fragment." Any internet datagram so marked is not to be internet fragmented under any circumstances. If internet datagram marked don't fragment cannot be delivered to its destination without fragmenting it, it is to be discarded instead.

Fragmentation, transmission and reassembly across a local network which is invisible to the internet protocol module is called intranet fragmentation and may be used [6].

The internet fragmentation and reassembly procedure needs to be able to break a datagram into an almost arbitrary number of pieces that can be later reassembled. The receiver of the fragments uses the identification field to ensure that fragments of different datagrams are not mixed. The fragment offset field tells the receiver the position of a fragment in the original datagram. The fragment offset and length determine the portion of the original datagram covered by this fragment. The more-fragments flag indicates (by being reset) the last fragment. These fields provide sufficient information to reassemble datagrams.

The identification field is used to distinguish the fragments of one datagram from those of another. The originating protocol module of an internet datagram sets the identification field to a value that must be unique for that source-destination pair and protocol for the time the datagram will be active in the internet system. The originating protocol module of a complete datagram sets the more-fragments flag to zero and the fragment offset to zero.

To fragment a long internet datagram, an internet protocol module (for example, in a gateway), creates two new internet datagrams and copies the contents of the internet header fields from the long datagram into both new internet headers. The data of the long datagram is divided into two portions on a 8 octet (64 bit) boundary (the second portion might not be an integral multiple of 8 octets, but the first must be). Call the number of 8 octet blocks in the first portion NFB (for Number of Fragment Blocks). The first portion of the data is placed in the first new internet datagram, and the total length field is set to the length of the first datagram. The more-fragments flag is set to one. The second portion of the data is placed in the second new internet datagram, and the total length field is set to the length of the second datagram. The more-fragments flag carries the same value as the long datagram. The fragment offset field of the second new internet datagram is set to the value of that field in the long datagram plus NFB.

This procedure can be generalized for an n-way split, rather than the two-way split described.

To assemble the fragments of an internet datagram, an internet protocol module (for example at a destination host) combines internet datagrams that all have the same value for the four fields: identification, source, destination, and protocol. The combination is done by placing the data portion of each fragment in the relative position indicated by the fragment offset in that fragment's internet header. The first fragment will have the fragment offset zero, and the last fragment will have the more-fragments flag reset to zero.

also, fragmentation happens in routers, but reassembly is performed by the destination host

The basic internet service is datagram oriented and provides for the fragmentation of datagrams at gateways, with reassembly taking place at the destination internet protocol module in the destination host. Of course, fragmentation and reassembly of datagrams within a network or by private agreement between the gateways of a network is also allowed since this is transparent to the internet protocols and the higher-level protocols. This transparent type of fragmentation and reassembly is termed "network-dependent" (or intranet) fragmentation and is not discussed further here.

  • Quite a bit of reading, but really comprehensive
    – tsp216
    May 15, 2017 at 11:28

1) (IP) packets are created by the network layer. While TCP has its own transmission size, MSS, that should correspond to the path MTU, it can send larger segments that must be fragmented (and potentially even reassembled) on the Internet layer. (The path MTU is not easily discovered and the MSS may be too large.)

2) Packet reassembly happens at the network layer. The transport layer doesn't handle packets.


Originally there were two separate division and reassembly processes.

At the transmitter, TCP would segment a data stream into segments, each of which would be sent as an IP packet. If the packets were too large to pass over a particular network link then each IP packet could be further split by the IP layer, either at the sending host or at an intermediate router in a process known as Fragmentation.

There is a bit in the IP header called "don't fragment", if this bit is set then the IP layer will not fragment the packet, instead it is supposed to generate an ICMP error.

Reassembly is always performed by the same layer that performed the splitting, so IP fragmentation is reassembled by the IP implementation on the receiving host, TCP segments are reassembled by the TCP implementation on the receiving host.

IP fragmentation has a few problems.

  1. The packet identifier field is too damn small, this creates a risk of incorrect reassembly at high data rates.
  2. If any fragment is lost then fragment reassembly will time out and none of the fragments will be delivered to TCP, therefore they will all have to re retransmitted.
  3. A slight reduction in MTU can result in nearly every packet being fragmented dramatically reducing the average packet size.
  4. Splitting is cheap, but reassembly is a relatively expensive process. Doing it twice makes little sense.
  5. Only the first fragment has transport layer headers, this poses problems for firewalls.

Therefore, modern TCP implementations do not allow their packets to be fragmented, instead they use a process known as "path MTU discovery", where the sender sends packets with the "don't fragment" bit set and if it gets ICMP errors, the packet size is reduced. This does cause some problems of it's own though.

UDP over IPv4 is still fragmented in the traditional way unless the application requests otherwise.

IPv6 forbids fragmentation in the network entirely, fragmentation support still exists but fragmentation is only supposed to be performed by the sending host this is no problem for TCP, since modern TCP implementations disable fragmentation anyway, it can be more of a challenge for UDP though.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.