Foundations of Python Network Programming 978-1-4302-3004-5

CHAPTER 2 ■ UDP
UDP Fragmentation
I have been claiming so far in this chapter that UDP lets you, as a user, send raw network packets to
which just a little bit of information (an IP address and port for both the sender and receiver) has been
added. But you might already have become suspicious, because the foregoing program listings have
suggested that a UDP packet can be up to 64kB in size, whereas you probably already know that your
Ethernet or wireless card can only handle packets of around 1,500 bytes instead.
The actual truth is that IP sends small UDP packets as single packets on the wire, but splits up larger UDP
packets into several small physical packets, as was briefly discussed in Chapter 1. This means that large
packets are more likely to be dropped, since if any one of their pieces fails to make its way to the destination,
then the whole packet can never be reassembled and delivered to the listening operating system.
But aside from the higher chance of failure, this process of fragmenting large UDP packets so that
they will fit on the wire should be invisible to your application. There are three ways, however, in which
it might be relevant:
• If you are thinking about efficiency, you might want to limit your protocol to small
packets, to make retransmission less likely and to limit how long it takes the
remote IP stack to reassemble your UDP packet and give it to the waiting
application.
• If the ICMP packets are wrongfully blocked by a firewall that would normally allow
your host to auto-detect the MTU between you and the remote host, then your
larger UDP packets might disappear into oblivion without your ever knowing. The
MTU is the “maximum transmission unit” or “largest packet size” that all of the
network devices between two hosts will support.
• If your protocol can make its own choices about how it splits up data between
different packets, and you want to be able to auto-adjust this size based on the
actual MTU between two hosts, then some operating systems let you turn off
fragmentation and receive an error if a UDP packet is too big. This lets you
regroup and split it into several packets if that is possible.
Linux is one operating system that supports this last option. Take a look at Listing 2–3, which sends
a very large message to one of the servers that we have just designed.
Listing 2–3. Sending a Very Large UDP Packet
#!/usr/bin/env python
# Foundations of Python Network Programming - Chapter 2 - big_sender.py
# Send a big UDP packet to our server.
import IN, socket, sys
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
MAX = 65535
PORT = 1060
if len(sys.argv) != 2:
» print >>sys.stderr, 'usage: big_sender.py host'
» sys.exit(2)
hostname = sys.argv[1]
30