Transcript DatagramPacket packet

User Datagram
Protocol
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.

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.


If a packet does arrive, it will always arrive
intact. Packets that are corrupt or only
partially delivered are discarded.
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-tothe-second or better performance may be
candidates for UDP, as there are fewer
delays due to error checking and flow
control of TCP.

UDP sockets can receive data from more
than one host machine.
 Some network protocols specify UDP as
the transport mechanism.

Java Support for UDP

Two classes are provided:
 DatagramPacket
class (java.net)
 DatagramSocket class (java.net)
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.


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[])
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 byte[256], 256);

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 byte[128],
128,addr, 2000);
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)
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.

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.

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) {
…
}

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) {
…
}
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
 int
 int
getSendBufferSize() throws java.net.SocketException
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
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.
Packet
Reads packets
DatagramSocket
DatagramPacket
Translates packets
Into a DatagramPacket
UDP application

The following code illustrates the process
for reading UDP packets.
DatagramPacket packet;
DatagramSocket socket;
packet = new DatagramPacket(new byte[256], 256);
socket = new DatagramSocket(2000);
boolean finished = false;
while (!finished) {
socket.receive(packet);
// process the packet
}
socket.close();

Java I/O streams are usually used to
access the contents of the byte array in a
DatagramPacket. See example later.
DatagramPacket
ByteArrayInputStream
IP address (java.net.InetAddr)
Port address (int)
Packet data (byte[])
DataInputStream
UDP
application
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.

DatagramSocket
Binds to a
UDP port
UDP application
Send DatagramPacket
using DatagramSocket
Constructs
packet
DatagramPacket
Packet

The following code illustrates the process
for sending UDP packets.
DatagramPacket packet;
DatagramSocket socket;
packet = new DatagramPacket(new byte[256], 256);
socket = new DatagramSocket(2000);
packet.setAddress(…);
packet.setPort(2000);
boolean finished = false;
while (!finished) {
// write data to packet buffer
socket.send(packet);
…
}
socket.close();
User Datagram Protocol Example

Run receiving application
java PacketReceiveDemo

Run sending application
java PacketSendDemo
PacketSendDemo
print(str)
PrintStream
DatagramPacket
ByteArrayOutputStream
toByteArray()
send(packet)
DatagramSocket
DatagramSocket
receive(packet)
DatagramPacket
getData()
ByteArrayInputStream
read()
PacketReceiveDemo
Building a UDP Client/Server

Run echo server
java EchoServer

Run echo client
java EchoClient
Algorithm for Echo Server
1.
2.
3.
Create socket
Create an empty packet
Repeat the following forever
Wait for a packet
2. Send the packet back to sender
1.
Algorithm for Echo Client
1.
2.
3.
Create socket
Set timeout value for socket
Repeat the following ten times
1.
2.
3.
4.
5.
Create the message to be sent
Create packet containing the message as well as the
destination IP and the port
Send the packet through socket
Wait for packet from receiver through socket or
timeout
if packet received
1.
2.
6.
Create an input stream to access data in the packet
Use the input stream to read the data and then display it on
the screen.
Sleep for a second
Overcoming UDP Limitations

UDP limitations:
Lack of Guaranteed Delivery
Lack of Guaranteed Packet Sequencing
Lack of Flow Control
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).


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.
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.

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.
