User Datagram Protocol

1
User Datagram Protocol
2
Introduction

• UDP is a connectionless transport protocol, i.e.
  it doesn't guarantee either packet delivery or
  that packets arrive in sequential order.
• With UDP, bytes of data are grouped together in
  discrete packets which are sent over the network.

3

• Packets may travel along different paths
  depending on the state of the network.
• No two packets are guaranteed the same route.
• Each packet has a time-to-live (TTL) counter,
  which is updated when it is routed along to the
  next point in the network. When the timer
  expires, it will be discarded, and the recipient
  will not be notified.

4

• If a packet does arrive, it will always arrive
  intact. Packets that are corrupt or only
  partially delivered are discarded.

5
Advantages of UDP

• UDP communication can be more efficient than
  guaranteed-delivery data streams.
• Unlike TCP streams, which establish a connection,
  UDP causes fewer overheads.
• Real-time applications that demand
  up-to-the-second or better performance may be
  candidates for UDP, as there are fewer delays due
  to error checking and flow control of TCP.

6

• UDP sockets can receive data from more than one
  host machine.
• Some network protocols specify UDP as the
  transport mechanism.

7
Java Support for UDP

• Two classes are provided
• DatagramPacket class (java.net)
• DatagramSocket class (java.net)

8
DatagramPacket Class

• A DatagramPacket object represents a data packet
  intended for transmission using UDP.
• It contains addressing information such as an IP
  address and a port.
• When a DatagramPacket is read from a UDP socket,
  the IP address/port of the packet represents the
  address/port of the sender.

9

• When a DatagramPacket is used to send a UDP
  packet, the IP address/port represents the
  address/port of the recipient.

DatagramPacket
IP address (java.net.InetAddr)
Port address (int)
Packet data (byte)
10
Creating a DatagramPacket

• Constructor to use for creating a DatagramPacket
  for receiving incoming UDP packets
• DatagramPacket(byte buffer, int length)
• Example
• DatagramPacket packet
• packet new DatagramPacket(new byte256, 256)

11

• Constructor to use for sending a DatagramPacket
  to a remote machine
• DatagramPacket(byte buffer, int length,
  InetAddress dest_addr, int dest_port)
• Example
• DatagramPacket packet
• InetAddress addr
• addr InetAddress.getByName("192.168.0.1")
• packet new DatagramPacket(new byte128,
  128,addr, 2000)

12
DatagramPacket Methods

• Refer p121.
• InetAddress getAddress()
• byte getData()
• int getLength()
• int getPort()
• void setAddress(InetAddress addr)
• void setData(byte buffer)
• void setLength(int length)
• void setPort(int port)

13
DatagramSocket Class

• The DatagramSocket class provides access to a UDP
  socket, which allows UDP packets to be sent and
  received.
• The same DatagramSocket can be used to receive as
  well as to send packets.
• read operations are blocking - i.e. the
  application will continue to wait until a packet
  arrives.

14

• Each DatagramSocket binds to a port on the local
  machine. The port number need not match the port
  number of the remote machine.
• If the application is a UDP server, it will
  usually bind to a specific port number.

15
Creating a DatagramSocket

• Constructor to use for creating a client
  DatagramSocket
• DatagramSocket() throws java.net.SocketException
• Example
• DatagramSocket socket
• try
• socket new DatagramSocket()
• catch (SocketException exception)

16

• Constructor to use for creating a server
  DatagramSocket
• DatagramSocket(int port) throws
  java.net.SocketException
• Example
• DatagramSocket socket
• try
• socket new DatagramSocket(2000)
• catch (SocketException exception)

17
DatagramSocket Methods

• Refer p123.
• void close()
• void connect(InetAddress r_addr, int r_port)
• void disconnect()
• InetAddress getInetAddress()
• int getPort()
• InetAddress getLocalAddress()
• int getLocalPort()
• int getReceiveBufferSize() throws
  java.net.SocketException

18

• int getSendBufferSize() throws java.net.SocketExce
  ption
• int getSoTimeout() throws java.net.SocketException
  
• void receive(DatagramPacket packet) throws
  java.io.IOException
• void send(DatagramPacket packet) throws
  java.io.IOException
• int setReceiveBufferSize(int length) throws
  java.net.SocketException
• int setSendBufferSize(int length) throws
  java.net.SocketException
• void setSoTimeout(int duration) throws
  java.net.SocketException

19
Listening for UDP Packets

• Before an application can read UDP packets, it
  must
• bind a socket to a local UDP port using
  DatagramSocket
• create a DatagramPacket that will contain the
  data.

20
Packet
Reads packets
DatagramSocket
DatagramPacket
Translates packets Into a DatagramPacket
UDP application
21

• The following code illustrates the process for
  reading UDP packets.

DatagramPacket packet DatagramSocket
socket packet new DatagramPacket(new
byte256, 256) socket new DatagramSocket(2000)
boolean finished false while (!finished)
socket.receive(packet) // process the
packet socket.close()
22

• Java I/O streams are usually used to access the
  contents of the byte array in a DatagramPacket.
  See example later.

ByteArrayInputStream
DataInputStream
DatagramPacket
IP address (java.net.InetAddr)
Port address (int)
Packet data (byte)
UDP application
23
Sending UDP Packets

• When sending a packet, the application must
  create a DatagramPacket that will contain the
  data. The address and port information must also
  be set.
• When the packet is ready for transmission, the
  send method of DatagramSocket should be invoked.

24
DatagramSocket
Binds to a UDP port
UDP application
Send DatagramPacket using DatagramSocket
Packet
Constructs packet
DatagramPacket
25

• The following code illustrates the process for
  sending UDP packets.

DatagramPacket packet DatagramSocket
socket packet new DatagramPacket(new
byte256, 256) socket new DatagramSocket(2000)
packet.setAddress() packet.setPort(2000) bool
ean finished false while (!finished) //
write data to packet buffer socket.send(packet)
socket.close()
26
User Datagram Protocol Example

• Run receiving application
• java PacketReceiveDemo
• Run sending application
• java PacketSendDemo

27
PacketSendDemo
PrintStream
print(str)
ByteArrayOutputStream
toByteArray()
send(packet)
DatagramSocket
28
DatagramSocket
receive(packet)
ByteArrayInputStream
getData()
read()
PacketReceiveDemo
29
Building a UDP Client/Server

• Run echo server
• java EchoServer
• Run echo client
• java EchoClient

30
Algorithm for Echo Server

• Create socket
• Create an empty packet
• Repeat the following forever
• Wait for a packet
• Send the packet back to sender

31
Algorithm for Echo Client

1. Create socket
2. Set timeout value for socket
3. Repeat the following ten times
4. Create the message to be sent
5. Create packet containing the message as well as
   the destination IP and the port
6. Send the packet through socket
7. Wait for packet from receiver through socket or
   timeout
8. if packet received
9. Create an input stream to access data in the
   packet
10. Use the input stream to read the data and then
    display it on the screen.
11. Sleep for a second

32
Overcoming UDP Limitations

• UDP limitations
• Lack of Guaranteed Delivery
• Lack of Guaranteed Packet Sequencing
• Lack of Flow Control

33
Lack of Guaranteed Delivery

• Packets sent via UDP may become lost in transit.
• UDP packets can also become damaged or lost.
• For some applications, the loss of individual
  packets may not have a noticeable effect (e.g.
  video streams).
• For other applications, loss of packets is not
  acceptable (e.g. file transfers).

34

• If guaranteed delivery is required,
• avoid packet-based communication, and use a more
  suitable transport mechanism (e.g. TCP).
• send acknowledgement to sender after receiving
  packets.

35
Lack of Guaranteed Packet Sequencing

• Applications that require sequential access to
  data should include a sequence number in the
  contents of a datagram packet.
• This enables detection of duplicate packets and
  also missing packets.

36
Lack of Flow Control

• The technique of flow control is important to
  avoid flooding a system with more data than it
  can handle due to limited bandwidth.
• One technique of flow control is to limit the
  number of unacknowledged packets. E.g. increase
  control when number of acknowledgement packets
  received is much less than the number of packets
  sent.