Packet Size greater than MTU set

Dear all,

If i need to transport packets of size ( say 1524 bytes ) greater than
MTU set ( 1500 bytes ), & DF bit of all the packets is set to 1, how
could i transport these packets...

1. Changing the MTU size on Physical Interface or Logical interface (
tunnel ).
2. or else

Please suggest...


Cheers,

Akhtar

 

Which kind of transport medium do you use?
- Ethernet - Ethernet with crossover cable?
- Ethernet via switch infrastructure?
- IP connection via Int(er|ra)net?
- Anything else?

If you set up a tunnel the command "ip mtu 1524" command on both sides is
sufficient.

Please describe your layer 1 and layer 2 setup.

 

.... or else ... clear the DF-bit ...

Usually DF-bit is set because the sender of the packet wants to
get informed about the fact that the MTU is (somewhere on the
routing path) smaller than the packet he sent. An icmp (type3 code4)
would be generated for this. If the sender gets this icmp, he would
resent the data in the packet, but would repacketize into smaller
packets. (This is part of TCPs path-mtu-detection).

However, there are situations, when the original sender cannot be
determined anymore ... or cannot be reached from where the bottleneck
(regarding mtu-size) is. In such a case, it might be a good idea,
to clear the DF bit ... by doing that, you allow your router to
break the packet into two ... and route them (rather than discard
the packet).

Rainer

 

You would have to use an encapsulating protocol that handled the
fragmentation itself, with the decapsulation routine
reassembling the packets before submitting them to the layer that
believes it needs the larger packet size.

But normally this is not a problem because normally you send
a stream, not a packet.

This is especially true for TCP: you might happen to have 1524 bytes to
send, but TCP would look at the MTU, see that only 1460 bytes would fit,
and would prepare a packet with those bytes, leaving the remaining
64 bytes in the transmit buffers, to remain there until more data
is ready to send, or a PUSH or URG packet is formed, or a timer
goes off and the packet is sent without being full. TCP does not
deal in packets, and makes absolutely no promise that packet boundaries
will be preserved.

In order to send a "packet" with a larger MTU, you would need to
be building RAW packets, or else be attempting to use send() or
sendto() or sendmsg() -- and for the send*() family, if you
attempt to send something too large, the send*() will error out.