Lecture 06 UDP Programming

CSIE33000 Network Programming 

Lecture06 UDP Programming 

Lecture 06 

UDP Programming 

CSIE33000 

Network Programming in Java 

Why UDP? 

• TCP incurs connection overhead which is not 

appropriate p for app making small exchange. 

• The delivery guarantee of TCP can be a bad 

fit for real-time applications (av streaming). 

• User Datagram Protocol (UDP) provides a 

connectionless, best-effor datagram 

transport service. 

• A very thin layer on top of IP with port 

addressing and payload integrity verification. 


UDP Programming 2 

Shiow-yang Wu Note 1



How about Using IP Directly? 

• IP does not verify the integrity of the 

datagram data payload. 

• The destination of an IP datagram is an IP 

address. Can’t distinguish between 

datagram of different applications. Protocolspecific 

application addressing is needed. 

• Allowing applications i access to raw IP 

transmission is considered dangerous from a 

security standpoint. 



User Datagram Protocol (UDP) 

• connectionless, best-effort service (RFC768) 

• Destination port addressing: same as TCP 

port number (16-bit value, 0~65535) 

• Data payload integrity verification 

• associate a 16-bit checksum with each datagram 

• one’s complement checksum algorithm (catches 

all single bit-errors and many multiple-bit errors) 

• Source port identification 

• store the source port number in each datagram 

• to provide a return address (with IP address) 






UDP Datagram Structure 

4 bytes 

IP 

Header 

UDP 

Header 

UDP 

Payload 

Ver IHL TOS 

Total length 

Identification Flag Frag Ofset 

TTL Protocol Header checksum 

Source Address 

Destination Address 

Variable-size IP Options 

source port 

destination port 

length 

checksum 

data (bytes) 

20 bytes 

0-40 bytes 

8 bytes 

up to 

65508 

bytes 



UDP Operations 

IP Payload 

IP Header 

Destination Port:37 Destination:3139.52.12.2 

39 “What is the Source Port:4321 Source:128.59.22.38 

time?” Checksum Protocol:UDP 

UDP Time 

Client 

UDP Payload 

UDP Header 

best effort 

UDP Time 

Server 

bind(4321, 

UDP) Host A 

128.59.22.38 


Internet 

(IP) 

Host B 

139.52.12.2 

bind(37, 

UDP) 





UDP vs. TCP 

TCP Main Functions 

• Packet ordering 

• Reliable transmission 

• Streaming abstraction 

• Flow control 

• Congestion control 

⇒ Good for services that 

need to exchange large 

amounts data in a reliable 

manner w/o real-time 

constraints 

UDP App Characteristics 

• Small requests and replies 

• Read-only/re-entrant 

servers 

• Stateless servers 

• Real-time streaming 



Common UDP-based Applications 

• Domain Name System (DNS) 

• Simple Network Management Protocol (SNMP) 

• Trivial File Transfer Protocol (TFTP) 

• Network File Systems (NFS) 

• Network Time Protocol (NTP) 

• Real Audio 

• Echo 

• Talk 






Designing UDP-based Protocols 

• Use simple request-reply model 

• Each request should fit into a single UDP 

packet (data < 508 bytes = 576-60-8, where 

576 is the minimum packet size that should 

be handled by all IP networks, specified in 

RFC791). 

• Keep the state machines small 

• Provide loss handling through retransmission 

on one side only (client or server) 



Java UDP Programming 

• Two main classes: 

• java.net.DatagramPacket 

• java.net.DatagramSocket 

• No differentiation between client and server 

sockets. Every datagram socket can be used 

both for sending and receiving datagrams 

• DatagramPacket instances contain 

destination or source address and a message. 

Can only be used with DatagramSocket. 






Java UDP Programming 

Java client 

program 

5.Create 

DatagramPacket 

(“server”,4567,data) 

Java server 

program 

2.Create 

DatagramPacket 

(data buffer) 

4.Create 

(any) 

java.net. 

Datagram. 

Packet 

1.Create 

(4567) 

java.net. 

Datagram. 

Packet 

java.net. 

DatagramSocket 

6.send 

(datagram) 


7.Create UDP header; 

send as IP packet 

java.net. 

DatagramSocket 

3.receivei 

(datagram) 

8.Write 

sender 

host/port+ 

data 


java.net.DatagramPacket 

• Store the header and data content of a UDP 

datagram 

• Three main attributes 

• IP address 

• UDP port 

• payload data stored in a byte-array 

• When used for transmission, the IP and port 

are the destination; when used for receiving, 

they are source IP and port. 






DatagramPacket Constructors 

• DatagramPacket(bute[] buf, int length) 

max buf length 

• DatagramPacket(bute[] buf, int offset, int length) 

// use indeces [offset .. offset+length-1] 

// used in appending the data received 

• DatagramPacket(bute[] buf, int length, InetAddress 

address, int port) 

// destination/source address and port 

• DatagramPacket(bute[] buf, int offset, int length, 

InetAddress address, int port) 

• All above throw IllegalArgumentException 



Creating a UDP packet 

// to receive data from a remote machine 

DatagramPacket packet = 

new DatagramPacket(new byte[256], 256); 

// to send data to a remote machine 


new DatagramPacket( new byte[128], 128, 

address, port ); 






DatagramPacket Methods (1) 

• Get destination/source address and port 

• InetAddress getAddress() 

• int getPort() 

• Access packet payload 

• byte[] getData() 

• int getOffset() 

• int getLength() // returns the actual length received 



DatagramPacket Write Methods 

• To change destination address and port 

• void setAddress(InetAddress address) 

• void setPort(int port) 

• To change the data buffer 

• void setData(byte[] buf) 

• void setData(bute[] buf, int offset, in length) 

// use the specified portion of the buf as payload 

• Note that change the buffer does not 

automatically change the max buffer size. A 

setLength() must be made if this is desired. 






java.net.DatagramSocket 

• The same socket class can serve both as 

client and server datagram sockets. 

• Unlike stream sockets, datagram sockets do 

not have a protocol peer. 

• The same socket instance can be used to 

send/receive datagrams to/from any 

host/port destination/source 

i CSIE33000 Network Programming 


Creating UDP sockets 

• A UDP socket can be used both for reading 

and writing packets. 

• Write operations are asynchronous; however, 

read operations are blocking. 

• Since there is no guaranteed delivery, a 

single-threaded application could stall. 






DatagramSocket Constructors 

• DatagramSocket() throws SocketException, 

SecurityException 

// use an arbitrary available UDP port 

• DatagramSocket(int port) throws SocketException, 

SecurityException 

• DatagramSocket(int port, InetAddress address) 

throws SocketException, SecurityException 



Creating UDP Sockets 

// A client datagram socket: 

DatagramSocket clientSocket = 

new DatagramSocket(); 

// A server datagram socket: 

DatagramSocket serverSocket = 

new DatagramSocket(port); 






DatagramSocket Operations 

• To send a datagram 

• void send(DatagramPacket packet) throws 

IOException, SecurityException, 

IllegalArgumentException; 

• To receive a datagram 

• void receive(DatagramPacket packet) throws 

IOException, SecurityException; 

• Note: if the received datagram is larger than the 

packet buffer, it is truncated. 

• void close() 



Sending UDP Packets 

// create datagram packet 

. . . 

// create datagram client socket 

. . . 

boolean finished = false; 

while ( ! finished ) { 

// write data to packet buffer 

clientSocket.send(packet); 

// see if there is more to send 

} 






Listening for UDP Packets 

// create datagram packet 

. . . 

// create datagram server socket 

. . . 

boolean finished = false; 

while ( ! finished ) { 

serverSocket.receive(packet); 

// process the packet 

} 

serverSocket.close(); 



DatagramSocket Methods 

• Get the port and net interface the socket is 

associated with 

• int getLocalPort() 

• InetAddress getLocalAddress() 

• To restrict the packets to a single destination 

• void connect(InetAddress address, int port) throws 

SecurityException, IllegalArgumentException 

• void disconnect() 

• To get the restricted address and port 

• InetAddress getInetAddress() // null if not restricted 

• int getPort() // -1 if not restricted 






• Timeout 

DatagramSocket Configuration 

• void setSoTimeout(int timeout) throws SocketException 

• int getSoTimeout() 

• Buffer size management 

• void setSendBufferSize(int size) throws SocketException 

• int getSendBufferSize() throws SocketException 

• void setReceiveBufferSize(int size) throws 

SocketException 

ti 

• int getReceiveBufferSize() throws SocketException 

• Size management methods only affect performance. 

They will not cause datagram truncation. 



Non-blocking I/O receiving 

UDP packets 

• You can set a time-out in milliseconds to 

determine how long a read operation blocks, 

before throwing an exception. 

• socket.setSoTimeout(duration); 

• If the duration given in milliseconds is 

exceeded, an exception is thrown: 

• java.io.InterruptedException 

i 






SimpleUDPExample.java (1) 

import java.net.*; 

// Simple example that sends and receives a UDP datagram */ 

public class SimpleUDPExample { 

public static void main(String[] main) 

throws UnknownHostException, SocketException, 

java.io.IOException { 

int port = 5264; // hard-coded for simplicity 

// create datagram socket 

DatagramSocket socket = new DatagramSocket(port); 

socket.setSoTimeout(5000); 




// create datagram payload + set destination to self 

String outMessage = "Hello UDP world!"; 

byte[] data = outMessage.getBytes(); 


new DatagramPacket(data, data.length, 

InetAddress.getByName("localhost"), port); 

// send datagram (to ourself) 

System.out.println("Sending message: " + 

outMessage); 

socket.send(packet); 







// prepare to receive datagram: because we reuse the 

// DatagramPacket instance we must reset its length even 

// though we replace its data buffer! 

packet.setData(new byte[512]); 

packet.setLength(512); 

// receive datagram (may time out) 

System.out.println("Waiting t tl iti for datagram ..."); 

socket.receive(packet); 




// print result 

String inMessage = new String(packet.getData(), 

0, packet.getLength()); 

System.out.println("Received message: " + 

inMessage); 

socket.close(); 

} 

} 






Processing UDP Packets 

ByteArrayInputStream bin = 

new ByteArrayInputStream( 

packet.getData() ); 

DataInputStream din = 

new DataInputStream(bin); 

// read the contents of the packet 



Sending UDP packets 

• When you receive a packet, the ip and port 

number of the sender are set in the 

DatagramPacket. 

• You can use the same packet to reply, by 

overwriting the data, using the method: 

• packet.setData(newbuffer); 






9 Steps for UDP Server 

1. Create a DatagramSocket object 

DatagramSocket datagramSocket = 

new DatagramSocket(1234); 

2. Create a buffer for incoming datagram 

byte[] buffer = new byte[256]; 

3. Create a DatagramPacket object for the 

incoming datagrams 

DatagramPacket inPacket = 

new DatagramPacket(buffer, buffer.length); 

CSIE33000 Network Programming UDP Programming 33 

9 Steps for UDP Server (2) 

4. Accept an incoming datagram. 

datagramSocket.receive(inPacket); 

5. Accept the sender's address and port from the 

packet. 

InetAddress clientAddress = 

inPacket.getAddress(); 

int clientPort = inPacket.getPort(); 

6. Retrieve the data from the buffer. 

String message = new String( 

inPacket.getData(), 

0, inPacket.getLength()); 





9 Steps for UDP Server (3) 

7. Create the response datagram. 

DatagramPacket outPacket = new 

DatagramPacket(response.getBytes(), 

response.length(),clientAddress, 

clientPort); // response is a String 

8. Send the response datagram. (4~8 may be 

executed indefinitely) 

datagramSocket.send(outPacket); 

9. Close the DatagramSocket. 

datagramSocket.close(); 


UDPEchoServer.java 

import java.io.*; 


public class UDPEchoServer 

{ 

private static final int PORT = 1234; 

private static DatagramSocket amSocket datagramSocket; 

amSocket 

private static DatagramPacket inPacket, outPacket; 

private static byte[] buffer; 





UDPEchoServer.java (2) 

public static void main(String[] args) { 

System.out.println("Opening port...\n"); 

try { //Step 1. 

datagramSocket = new DatagramSocket(PORT); 

} 

catch(SocketException sockEx) { 

System.out.println("Unable to attach to port!"); 

System.exit(1); 

} 

handleClient(); 

} 



private static void handleClient() { 

try { 

String messageIn,messageOut; 

int numMessages = 0; 

do { 

buffer = new byte[256]; //Step 2. 

inPacket = new DatagramPacket( 

buffer, buffer.length); //Step 3. 

datagramSocket.receive(inPacket); //Step 4. 






InetAddress clientAddress = 

inPacket.getAddress(); //Step 5. 

int clientPort = inPacket.getPort(); //Step 5. 

messageIn = new String( inPacket.getData(), 0, 

inPacket.getLength() ); //Step 6. 

System.out.println("Message received."); 

numMessages++; 

messageOut = "Message " + numMessages 

+ ": " + messageIn; 



} 

outPacket = new DatagramPacket( 

messageOut.getBytes(), 

g messageOut.length(), 

clientAddress, 

clientPort); //Step 7. 

//Step 8. 


} while (true); 





} 

} 


catch(IOException ioEx) { 

ioEx.printStackTrace(); 

} 

finally //If exception, close connection. 

{ 

System.out.println("\n* Closing connection... *"); 

datagramSocket.close(); close(); //Step 9. 

} 


8 Steps for UDP Client 

1. Create a DatagramSocket object. 

DatagramSocket datagramSocket = 

new DatagramSocket(); 

2. Create the outgoing datagram. 

DatagramPacket outPacket = new 

DatagramPacket(message.getBytes(), 

message.length(), host, PORT); 

3. Send the datagram message. 






8 Steps for UDP Client (2) 

4. Create a buffer for incoming datagrams. 

byte[] buffer = new byte[256]; 

5. Create a DatagramPacket object for the 

incoming datagrams. 

DatagramPacket inPacket = new 

DatagramPacket(buffer, 

buffer.length); 

6. Accept an incoming datagram. 

datagramSocket.receive(inPacket); 


8 Steps for UDP Client (3) 

7. Retrieve the data from the buffer. 

String response = new 

String(inPacket.getData(),0, 

inPacket.getLength()); 

8. Close the DatagramSocket. 

datagramSocket.close(); 





UDPEchoClient.java 



import java.util.*; 

public class UDPEchoClient 

{ 

private static InetAddress host; 

private static ti final int PORT = 1234; 

private static DatagramSocket datagramSocket; 

private static DatagramPacket inPacket, outPacket; 

private static byte[] buffer; 


UDPEchoClient.java (2) 


try { 

host = InetAddress.getLocalHost(); 

} 

catch(UnknownHostException uhEx) { 

System.out.println("Host ID not found!"); 

System.exit(1); exit(1); 

} 

accessServer(); 

} 






private static void accessServer() { 

try { 

//Step 1. 

datagramSocket = new DatagramSocket(); 

//Set up stream for keyboard entry... 

Scanner userEntry = new Scanner(System.in); 

String message="", response=""; 

do { 

System.out.print("Enter message: "); 

message = userEntry.nextLine(); 



if (!message.equals("***CLOSE***")) { 

outPacket = new DatagramPacket( 

message.getBytes(), getBytes() 

message.length(), 

host,PORT); //Step 2. 

datagramSocket.send(outPacket); //Step 3. 

buffer = new byte[256]; //Step 4. 

inPacket = new DatagramPacket( 

buffer, buffer.length); //Step 5. 

datagramSocket.receive(inPacket); //Step 6. 

response = new String(inPacket.getData(), 

0, inPacket.getLength());//Step 7. 





} 

} 


System.out.println("\nSERVER> " + response); 

} 

} while (!message.equals( equals("***CLOSE***")); 

} 

catch(IOException ioEx) { 

ioEx.printStackTrace(); 

} 

finally { 

System.out.println("\n* t tl *Closing connection... *"); 

datagramSocket.close(); //Step 8. 

} 


Execution of UDPEchoServer 





Execution of UDPEchoClient 


UDP Echo Service 

• The Echo protocol (RFC862) is an old 

Internet standard. 

• The server receive datagrams on port 7 and 

send the same data back. 

1. UDP datagram to port 7, 

with arbitrary data 

Client 

2. UDP datagram to originating 

port, with same data 

Echo Server 






EchoUDPClient.java (1) 



// Static methods for the RFC 862 UDP echo protocol client */ 

public class EchoUDPClient { 

// Standard UDP echo service port (port=7) 

public static final int STANDARD_ECHO_PORT = 7; 

// Default number of tries to receive an echo response 

public static final int DEFAULT_TRIES = 3; 

/** Default polling expiration in milliseconds */ 

public static final int DEFAULT_EXPIRE_MILLIS = 2000; 




// Maximum UDP payload size to be sent or received 

public static final int MAX_UDP_BUFFER_SIZE = 508; 

// Counter used to generate unique Echo requests 

protected static int nextRequestID= 0; 

// Prevent instantiation (only static methods offerred) 

private EchoUDPClient() { 

} 







/** Returns true if the host is running a UDP echo service in 

the specified port number and successfully returned an 

exact copy of a test message transmitted. 

The service is polled up to tries times, with 

pollMillis in between polls. 

@param address - the UDP echo service address 

@param port - the UDP echo service port 

@param a tries - number of echo tries before e failure 

@param pollMillis - number of milliseconds for poll expiration 

@exception IOException - if the socket could not be created 

@exception SecurityException - if the security manager did 

not permit the network operations 

CSIE33000 */ Network Programming 



public static boolean echo(InetAddress address, int port, 

int tries, int pollExpireMillis) 

throws IOException, SecurityException { 

if (address == null) 

throw new NullPointerException("null server address"); 

// Generate a unique request ID 

long outValue; 

synchronized(EchoUDPClient.class) { 

outValue = nextRequestID; 

nextRequestID++; 

} 







// Create request payload (write current time to byte array) 

ByteArrayOutputStream byteOut = new 

ByteArrayOutputStream(); 

DataOutputStream dataOut = new 

DataOutputStream(byteOut); 

try { 

dataOut.writeLong(outValue); 

dataOut.close(); 

} catch (IOException e) { 

throw new RuntimeException("Unexpected I/O exception:" 

+ e); 

} 




// Create datagram packet out of request 

DatagramPacket outPacket = 

new DatagramPacket(byteOut.toByteArray(), 

byteOut.size(), address, port); 

DatagramPacket inPacket = new DatagramPacket 

(new byte[MAX_UDP_BUFFER_SIZE], 

MAX_UDP_BUFFER_SIZE); 

// Create and configure socket 

DatagramSocket socket = new DatagramSocket(); 

socket.setSoTimeout(pollExpireMillis); 







try { 

// Loop "tries" times sending the UDP packet. 

for(int i=0; i




// We're looping back so reset the inPacket buffer length 

// (must do so every time we reuse a DatagramPacket 

// instance for a DatagramSocket.receive() invocation) 

inPacket.setLength(MAX_UDP_BUFFER_SIZE); 

} // for (each try) 

} finally { 

try { socket.close(); } catch (Throwable e) { } 

} 

return(false); 

} // echo() 




// Command-line utility for performing UDP echo requests. 


if ( (args.length == 0) || (args.length > 2) ) { 

System.err.println("Usage: EchoUDPClient {}"); 


} 

InetAddress address = null; 

try { 

address = InetAddress.getByName(args[0]); 

} catch (UnknownHostException e) { 

System.err.println("EchoUDPClient: unknown host " + args[0]); 


} 







int port = STANDARD_ECHO_PORT; 

if (args.length > 1) { 

try { 

port = Integer.parseInt(args[1]); 

} catch (NumberFormatException e) { 

System.err.println("EchoUDPClient: invalid port number " + args[1]); 


} 

} 




try { 

if (echo(address, port, 

DEFAULT_TRIES, DEFAULT_EXPIRE_MILLIS)) { 

System.out.println("Echo service active on " + address); 

} else { 

System.out.println("No echo reply from " + address); 

} 

System.exit(0); exit(0); 

} catch (Throwable e) { 

System.err.println("EchoUDPClient: " + e); 


} } } // EchoUDPClient 






EchoUDPServer.java (1) 



// Server implementing the RFC 862 UDP echo protocol 

public class EchoUDPServer extends Thread { 

// Standard UDP echo service port in RFC 862 (port=7) 

public static int STANDARD_ECHO_PORT = 7; 

// Default no. of milliseconds between termination checks 

public static int DEFAULT_TERMINATION_CHECK_MILLIS TERMINATION MILLIS = 5000; 

// The maximum UDP data length possible (in bytes) 

public static int MAX_UDP_DATA_LENGTH = 65508; 




/** UDP socket used to receive echo requests */ 

protected DatagramSocket socket; 

/** Controls execution of the datagram receive thread */ 

protected boolean isActive; 

/** Constructs an RFC 862 UDP Echo Protocol server 

* @param port - the UDP port number used for binding 

* @exception SocketException - if the socket creation fails 

* @exception SecurityException - if permission refused 

*/ 

public EchoUDPServer(int port) throws SocketException { 

super("EchoServer(" + port + ")"); 

socket = new DatagramSocket(port); 







socket.setSoTimeout(DEFAULT_TERMINATION_CHECK_MILLIS); 

isActive = true; 

start(); 

} 

// Requests asynchronous termination of the receiving thread 

public void terminate() { 

isActive = false; 

} 




/** Main thread receives and sends back any data received. 

* 

* Loop termination controlled by the terminate() method. 

*/ 

public void run() { 

System.out.println("Echo server bound to port " + 

socket.getLocalPort()); 

DatagramPacket receivePacket = 

new DatagramPacket( 

new byte[MAX_UDP_DATA_LENGTH], 

MAX_UDP_DATA_LENGTH); 







while(isActive) { 

try { 

// Reset the receivePacket length to the byte array length 

receivePacket.setLength(MAX_UDP_DATA_LENGTH); 

// Wait to receive echo request (may also time-out) 

socket.receive(receivePacket); 

// We just send the packet back to the sender 

socket.send(receivePacket); 

} catch (InterruptedIOException e) { 

// ignore (used to check for termination) 


// ignore 

} 

} 




try { socket.close(); } catch (Throwable e) { } 

} 

/** Command-line utility for performing UDP echo requests. */ 


if (args.length > 1) { 

System.err.println("Usage: EchoUDPServer { }"); 


} 

int port = STANDARD_ECHO_PORT; 

if (args.length == 1) { 

try { 

port = Integer.parseInt(args[0]); 

} catch (NumberFormatException e) { 







System.err.println("EchoUDPServer: invalid port number " + 

args[0]); 


} 

} 

try { 

EchoUDPServer server = new EchoUDPServer(port); 

server.join(); 


System.err.println("EchoUDPServer: " + e); 


} 

} 

} 



Typical UDP client code 

• Create UDP socket to contact server (with a 

given hostname and service port number) 

• Create UDP packet. 

• Call send(packet), sending request to the 

server. 

• Possibly call receive(packet) (if we need a 

reply). 






Typical UDP Server code 

• Create UDP socket listening to a well known 

port number. 

• Create UDP packet buffer 

• Call receive(packet) to get a request, 

noting the address of the client. 

• Process request and send reply back with 

send(packet). 



Debugging 

• Debugging UDP can be difficult. 

• Write routines to print out addresses. 

• Use a debugger. 

• Include code that can handle unexpected 

situations. 





Asynchronous Errors 

• What happens if a client sends data to a 

server that is not running? 

• ICMP “port unreachable” error is generated by 

receiving host and send to sending host. 

• The ICMP error may reach the sending host after 

send() has already returned! 

• The next call dealing with the socket could return 

the error. 



Assignment 2 

1. Modify the TCP and UDP Echo examples discussed 

in the class such that the server and client are 

running on different machines. 

2. Write a TCPcalculatorServer.java program that 

accepts client request for arithmetic calculation in 

prefix form (eg. “+ 3 8”) and returns the result in 

the response. Write a TCPcalculatorClient.java 

program that interactively accepts user’s calculation 

command, sends to the server, receives the 

response, and print the result. 






Assignment 2 (cont.) 

3. Write a UDPmessageServer.java program that provides 

on-line messaging service by accepting client requests of 

the form “send mboxID message” or “receive mboxID” 

which are to send(receive) a message to(from) the 

designated mailbox. You are free to assume that each 

part of the request is in a separate line. Write the 

corresponding client program to test the service. Note 

that you may need to save the messages before they are 

received. Once a message is received, it can be deleted 

from the server. 

• Due Date: Oct 30, 2008

Lecture 06 UDP Programming

Create successful ePaper yourself

Delete template?

Save as template?