Distributed Systems Lab 3 - TCP/IP connections in Java

Objectives

In today's lab you will use TCP and UDP sockets for communication. In Task 1 you will use TCP to retrieve a web pages and UDP to send strings between two different machines. At the end of the lab, you should know how to use Java to implement TCP and UDP sockets and in the lecture you will learn what the pros/cons of the two protocols are.
And finally, you will also learn how to use javadoc to document you code (TASK 3) (This will be useful for documenting your coursework code, so do attempt it).

Overview

TCP and UDP are example protocols at the "Transport" layer in the OSI model of network architecture

TCP

Connection Oriented (like a telephone service)
Reliable (i.e in the way of handling data): Guarantees delivery of data.
Examples: Web (HTTP), Email (SMTP, IMAP)

UDP

Connection-less (postal service like)
Unreliable, no guaranteed delivery
Example: DNS, Various types of streaming media.

...About Sockets...

Sockets are essentially end points for communication, analagous to telephones on a telephone line. You need to have one on each end in order for there to be communication. So before you use a program to talk using UDP or TCP you need to open a socket. When you open a socket you bind (binding is like plugging in) it to a specific IP address and port. After a socket is bound it is ready to send and receive data. At least in UNIX type systems, sockets are like file descriptors. So the important thing to remember is that they need to be properly opened and closed like files in order to keep things from getting messy. Trying to bind multiple sockets to the same port on a computer can cause conflicts. Also, when you create a socket it comes back to you as a socket descriptor number, this descriptor is the handle for the socket and is how you will refer to it in the future.

A final bit to remember about sockets is that they have both sending and receiving buffers associated with them. In relation to UDP the sending buffer does not have much relevance as long as it is bigger than any single packet you will send. On the receiving side, a socket will store up UDP packets in the buffer until the buffer is full. Of course, when you read a packet from the socket it will remove it from the buffer. When the buffer is full any more packets going to the buffer will be lost. So if you are sending data at high speeds and your packet reading application can't keep up with the sender it is important to keep in mind that the buffer may have some kind of effect on your program's behavior.

Task 1: Retrieving web pages using TCP sockets

The program Browse retrieves a web page and prints the contents onto the screen.
Save the file Browse.java (i.e. move your mouse over the link and press the right mouse button and select 'save link as')
Edit Browse.java and fill in the missing code (search for ToDo).
You may want to consult java.net in the Java API, e.g Java 1.3 (sun site) for help.
Open a shell
Type
```
module add java
```
Compile Browse
```
javac Browse.java
```

Execute it, e.g.

java Browse www.soi.city.ac.uk /~kloukin/teaching/ds-labs/tut/udp/readme.html

...This should retrieve the web page (HTML) for today's lab..

Task 2: Client/server interaction using UDP sockets

The program UDPClient sends a sentence (i.e. a character string which is entered by the user) to the program UDPServer via UDP sockets. The UDPServer displays the string, capitalises it and sends it back to the UDPClient, which then displays the result.
Save the files UDPServer.java and UDPClient.java
Edit UDPClient.java and fill in the missing code (search for ToDo).
You may want to consult java.net in the java api Java 1.3 (sun site) for help.
Open a shell
```
xterm &
```
Type
```
module add java
```
Compile UDPServer.java and UDPClient.java
```
javac UDPServer.java UDPClient.java
```
Open another shell (Note: it may be on a different machine)
```
xterm &
```
Execute the UDPServer in one shell
```
java UDPServer
```
Execute the UDPClient in the other shell
```
java UDPClient
```

Task 3:

Documenting Java code

Question:

Which type of application is better off with TCP, which with UDP? Discuss the trade-off between reliability and performance.