Languages
Pages
Legal
CS451 - Lecture 41
CS451Lecture 4: Network Programming
Yugi Lee
STB #555(816) 235-5932
www.cstp.umkc.edu/~yugi
*Acknowledgement: This lecture is based on material courtesy of Monash University
2CS451 - Lecture 4
Networks
• The communication between processes on different machines – logical messages each want to send to each other.– These messages may be simple strings or arrays of
bytes (binary data).
3CS451 - Lecture 4
Networks
• At the application programmer level, – a connection to another process on another machine to
simply send each message as a high level logical unit.
– the underlying layers of software responsible for sending the message may split it into smaller units for physical transfer called PDU's (protocol data units).
– With each of these smaller packets will be a wrapper with additional header information: Address of sender/receiver Error detection codes Protocol control information
4CS451 - Lecture 4
Protocols
• an agreement between entities (programs) on the transmission of data.
• exist for different layers of network software. – At lower levels it allow for determining the amount of data to
be sent, the size of packets and the speed of transmission.
• Connection Control /Data transfer
• Flow control/Error control
• Synchronization/Addressing
– At higher levels (the application level) it may cover the syntax and sequencing of logical messages.
5CS451 - Lecture 4
Connection Control
• A program may send information to another at an indeterminate time with no explicit prior co-ordination
• UDP datagram packets: sent across the network to the receiving program. – the packet may get lost or packets may arrive in a different
order to that in which they were sent.
– reorganize the packets and make requests for new packets when problems occur.
– dynamically routed; split into a number of PDUs that take different routes to their destination depending on network congestion.
6CS451 - Lecture 4
Connection Control
• Alternatively, establish a virtual connection (a link between two communicating programs) – Steps: Connection establishment, Data transfer, Connection
termination.
– a connection-oriented protocol such as the TCP/IP (Transfer Control Protocol / Internet Protocol) used by Sockets provides sequencing and re-transmission of lost packets.
– send logical messages without having to explicitly deal with these other issues.
– can be slower as more time is required to set up and terminate the link.
7CS451 - Lecture 4
Connection Establishment
• a degree of handshaking where the host accepts the connection from the client.
• Initial handshaking involves an agreement on protocols being used:– the number of unacknowledged packets that can be
send (window size) – the size of these packets.
8CS451 - Lecture 4
Connection Establishment
• requires global addresses. • IP addresses are organized hierarchically:
– 32 bit number to identify the domain, the network, the sub-net and the host.
– The number is divided into four components each taking a value between 0 and 255.
– Symbolic names may be associated with the IP numbers.
– Addresses are determined by using name servers to look-up the numeric IP address of particular hosts.
9CS451 - Lecture 4
Connection Establishment
• For example: insect.sd.monash.edu.au Domain: au Australia Organisation type: edu Education Network: monash Sub-net: sd Department of Software Development
Machine: insect a Sun sparc station.
10CS451 - Lecture 4
Connection Establishment
• Internet names are divided into a range of classes to suit different organizations. Each type of address allows an additional byte section – class "C" address provides up to 255 addresses (machines) for
the name holder to use: e.g., 205.161.65.x
– class "B" allows 65,534 addresses: e.g., 128.34.x.x
– class "A" allows for around 16,777,214 addresses: E.g., 126.x.x.x
• To allow for the growth in the internet the name space is being expanded to allow for 128 bit numbers rather than 32 bit number.
11CS451 - Lecture 4
Connection Establishment
• Once a particular machine has been identified, the process on the machine the packet is intended for can be determined by associating the process with a port.
• A port is a logical abstraction for virtual connections.
• In TCP/IP a connection is defined as – the client IP address and port– the server IP address and port.
12CS451 - Lecture 4
Issues in Data Transfer
Sequencing: Packets may arrive out of order and need to be resequenced by the receiver.
Flow Control: the sender may try to send more packets than the receiver can hold in its buffers resulting in packet loss.
Error control: as packets are received they are acknowledged. Missing packets can be re-sent as can packets which were received but were corrupted in the network.
13CS451 - Lecture 4
Issues in Data Transfer
• Synchronization: communicating programs require information about the state of each other. – This may require checkpointing and raises similar
issues in relation to the use of monitors and synchronization of objects.
– Processes simultaneously updating a database may need to know whether another process has completed.
– A failure in synchronization in these cases could lead to dead-lock (the two generals problem).
14CS451 - Lecture 4
Connection Termination
• Once transmission is complete, typically processes will cleanly terminate a connection.
• If unexpected terminations occur, a connection based service will try to live up to its guarantees of delivery. – When one end of connection terminates (the process was killed or the
machine crashed) the other end may still try to send any outstanding data.
– wait to try and receive any outstanding data – Buffers may still be open and maintained after a client has
disconnected if it was not done cleanly.
– Explicitly closing the connection on the server end will force the
server to clear the buffers and clean-up the connection.
15CS451 - Lecture 4
Socket Programming
• A socket can be described as "one end of a two-way communication between a server program and a client".
• None of many current programming languages have socket connectivity built into the language at such a basic level.
• Java: Socket and ServerSocket classes, (client and server programs with a minimum of time and effort).
16CS451 - Lecture 4
Network Programming
• A key concept in the network programming– the notion of a port, which is an address uniquely
assigned to a server program, through which the server can receive connections from client programs.
– From the programmers' point of view, a port is merely a number uniquely identifying the communication channel to which the server is listening.
– A client can connect to a particular port by using programs such as telnet, as follows:
telnet firefly.sd.monash.edu.au 11000
17CS451 - Lecture 4
Connecting to a Server
• Using the java.net classes makes connecting to a server incredibly simple
• To enable communication between your Java client and the server program, by creating – InputStream (using the getInputStream method)
– OutputStream from a Socket object (using the getOutputStream method).
18CS451 - Lecture 4
Process of Connecting to a Server
1. Identify the host machine on which the server is running
2. Identify the port on the host machine to which the server is listening
3. Understand the protocol used when communicating with the server, and code your program to conform to this protocol: If information can be sent to the server, an OutputStream object must
be associated with the Socket If information is received from the server (which invariably is the case),
an InputStream object must be associated with the Socket All of the demonstration Socket code appearing in this document
adhere to this methodology.
19CS451 - Lecture 4
Protocol for communicating with the Time Server
1. Connect to the server on port 13 using telnet or an equivalent (like the QueryTimeServer Applet)
2. Upon connection, the time server displays the time on the host machine, then terminates the connection immediately As only one-way communication is needed in this example,
only an InputStream object is associated with the Socket
When the input returned from the InputStream is determined to be null, the server has terminated the connection
20CS451 - Lecture 4
Protocol for communicating with the Finger Server
1. Connect to the server on port 79 using telnet or an equivalent (like the FingerClient Applet)
2. Upon connection the user has the option to enter the name of a user on that host machine or just press the ENTER key.
3. Information pertaining to the user entered is returned by the
server, then the server terminates the connection As two-way communication needs to be supported by this
example, both OutputStream and InputStream objects are associated with the Socket
When the input returned from the InputStream is determined to be null, the server has terminated the connection
21CS451 - Lecture 4
Building a Socket Server
• a server program generally runs continuously whilst it's host machine is running (usually executed during the startup procedures of the host machine)
• As with constructing client programs, building any (socket) server program follows the sequence of steps: 1.Decide on a currently unused port to which your server
will listen (your local sysadmin will know which ports are free for this purpose)
2.Create a ServerSocket object associated with the port identified in the previous step
22CS451 - Lecture 4
Building a Socket Server
3. Create a Socket object from the return value of the accept method, which blocks (i.e., waits) until a client has connected to the server
4. Decide on a send-and-receive protocol to which any client programs must conform if they wish to communicate with your server
5. Once the protocol has been settled upon, the server knows – when to send output to the client,
– when to wait for the client's input, and
– what input is deemed valid (or invalid) and the correct response to valid (or invalid) input
23CS451 - Lecture 4
Building a Socket Server
6. The Socket object can then be used to open InputStream and OutputStream objects from which to receive and send data to the server
• The easiest way to test a server program for correct functionality is to use telnet– to connect to the correct host machine and port for
your server, and, conforming to the communication protocol assumed by the server,
– to test that the server responds in an appropriate manner to your sample input.
24CS451 - Lecture 4
Datagram Communication
• The rules governing the use of datagrams are rather more restrictive than those associated with sockets (less frequently used than sockets)
• Client/Server Communication
– Socket communication: the existence of a "perfect channel", which is permanently open and guarantees the arrival of information at the destination in the same order in which it departed from the source.
– Datagram communication: when such conditions are not required of the communication (i.e., where a constant channel is not needed and where the sequence of the data is irrelevant)
25CS451 - Lecture 4
Datagram Communication
• Packets (the data to be communicated) contains the address of the intended recipient, and the port to which the recipient is bound.
• It is routed from the client to the server using a non-deterministic path which could change for successive packets,
• It gives no guarantee of packets arriving in the original sending sequence.
• For a limited set of communication domains like single send and/or receive transfers, datagram communication is appropriate.
26CS451 - Lecture 4
Datagram Communication
java.net package:• DatagramSocket: the link through which the client
and server communicate, and objects of this class need to be created by both programs. If no port is specified when creating an object of this type, the port is allocated dynamically.
• DatagramPacket: acts as a container for a byte array containing the information to be transferred, the address of the receiver, and port to which the receiver is connected.
27CS451 - Lecture 4
Creating a Datagram Server
• Steps:– The server attaches (binds) itself to a particular port,
– then creates a packet initially either to send or receive data, depending on the communication protocol.
• As with most servers, the body of the serving mechanism is encased in an infinite loop.
• the example server has not been threaded to allow multiple concurrent accesses, but the technique to do so is the same as with socket-based servers.
28CS451 - Lecture 4
Creating a Datagram Server
import java.io.*;
import java.net.*;
import java.util.*;
public class QuoteServer {
private static Vector quotes = new Vector();
private DatagramSocket socket = null;
public static void main(String args[]) {
setupQuotes();
new QuoteServer();
}
QuoteServer() {
try {
socket = new DatagramSocket(12000); System.out.println
("QuoteServer listening on port: "+ socket.getLocalPort());
} catch (java.net.SocketException e)
{System.err.println("Could not create datagram socket.");
}
29CS451 - Lecture 4
Creating a Datagram Server
while (true) {
try {
byte[] packetBuffer = new byte[256];
String quoteString = null;
// receive request
DatagramPacket packet = new DatagramPacket(packetBuffer, 256);
socket.receive(packet);
InetAddress clientAddress = packet.getAddress();
int clientPort = packet.getPort();
quoteString = getAQuote();
packetBuffer = quoteString.getBytes();
packet = new DatagramPacket(packetBuffer, packetBuffer.length,clientAddress, clientPort);
socket.send(packet);
} catch (IOException e) {
System.err.println("IOException: " + e);
}}}
protected void finalize() {
if (socket != null) {
socket.close();
socket = null;
System.out.println("Closing datagram socket.");
}
}
30CS451 - Lecture 4
Creating a Datagram Server
private static void setupQuotes() {
quotes.addElement("Life wasn't meant to be easy");
quotes.addElement("The recession we had to have");
quotes.addElement("I have a huge whiteboard in my office");
quotes.addElement("Please explain?");
quotes.addElement("The things that batter");
quotes.addElement("No child shall live in poverty");
quotes.addElement("Porcus Madonna");
quotes.addElement("Don't you worry about that");}
private static String getAQuote() {
return (String) quotes.elementAt
((int)(Math.random() * (float) quotes.size()));
}
}
31CS451 - Lecture 4
Creating a Datagram Server
The server begins by creating a DatagramSocket object. getLocalPort: if no port was specified it could ask the socket for
the port
The server creates a DatagramPacket by constructors for sending data, the constructor needs a data buffer
containing the information to send, the length of the data buffer, and the address and port of the recipient
for receiving data, the constructor needs a data buffer to store the information being received, and the length of the buffer.
32CS451 - Lecture 4
Creating a Datagram Server
receive(java.net.DatagramPacket): blocks until a client connects to the server
getAddress(): The address of a client connecting to a server can be obtained by querying a received packet for it's address(InetAddress)
getPort(): The port of a client connecting to a server can be obtained by querying a received packet for it's port
send: Once a DatagramPacket has been created for sending, it is routed to the address and port specified in the packet
33CS451 - Lecture 4
Creating a Datagram Client
public class QuoteClientFrame extends Frame implements ActionListener {
Button b = new
Button("Get Quote");
b.addActionListener(this)
public void
actionPerformed(ActionEvent event) {
int port = 0;
InetAddress hostAddress = null;
DatagramSocket socket = null;
DatagramPacket packet = null;
byte[] sendBuffer = new byte[PACKET_SIZE];
try {
// bind to the socket
socket = new DatagramSocket();
} catch (java.net.SocketException e) {
System.err.println("Could not create datagram socket.");
}
34CS451 - Lecture 4
Creating a Datagram Client
if (socket != null) {
try {
// send request
port Integer.parseInt
(serverPort.getText().trim();
hostAddress = InetAddress.getByName(serverName.getText());
packet = new DatagramPacket(sendBuffer,
PACKET_SIZE,
hostAddress,
port);
socket.send(packet);
// get response
packet = new DatagramPacket(sendBuffer, PACKET_SIZE);
socket.receive(packet);
String received = new String(packet.getData());
currentQuote.setText(received);
socket.close();
} catch (IOException e) {
System.err.println("IOException: " + e);
}}}}
35CS451 - Lecture 4
Creating a Datagram Client
• Like a server, a datagram client also binds to a DatagramSocket object through which communication occurs
All client programs need knowledge of the machine on which the server is running; the machine name is turned into a InetAddress object using the getByName method
If the specified size of the data in a receiving packet is less than the actual size of the data in the packet received, the data is truncated to the size specified
36CS451 - Lecture 4
When to use Datagrams?
• They can be used for short messages which are not critical if not received (the client can request the data again).
• Also useful for live Video or Audio feeds, in these cases a few lost packets may not be critical.
• For other purposes where you may need high speed communication and survive without the overhead of flow control and guaranteed ordered delivery.
Top Related