AJavaNetworking [Compatibility Mode]
description
Transcript of AJavaNetworking [Compatibility Mode]
Advanced Java Programming
Unit One: Networking
Gareth LeeDepartment of Electrical and Electronic Engineering,
University of Western Australia
JohnMorris
GarethLee Overview
• Java’s network support
• Addressing other machines
• Communicating using TCP/IP
• Communicating using UDP
• Broadcasting and multicasting
Recommended Reading
• Java Network Programming, Elliotte Rusty Harold, O’Reilly and Associates, 1997, ISBN 1-56592-227-1
• TCP/IP Network Administration, Second Edition, Craig Hunt, O’Reilly and Associates, 1997, ISBN 1-56592-322-7
• The Java Developer’s connection: http://www.javasoft.com/jdc
• The Javadoc documentation
Network Programming
• Mechanisms by which software running on two or more computational devices can exchange messages
• Desktop Computers
• PDAs / Set Top Boxes / Mobile Telephones?
• Java is a network centric programming language
• Java abstracts details of network implementation behind a standard API
• Portable (and future proof) . . .
• but may be rather limiting
A programming model for network communications
HTTP/FTP/etc...
TCP, UDP
Internet Protocol
Java & IP don’t care
Java APIs
1:1 or 1:Many
Physical Transport
Datagrams
Broadcast Multicast
Application Protocols
Applications
Streams
Addressing & Routing
Unicast
Dealt with in this Unit One.
Dealt with in this Unit Two.
Internet Protocol (IPv4)
• Abstracts away the details of the physical network implementations (such as Ethernet, Token Ring, ATM, Sonet)
• All traffic uses the same rules to move from machine to machine
• Easy to write programs
• Easy to build network hardware
• Works with Datagrams: small discrete packets of data (rather like a letter)
Internet Protocol (IPv4)
• A way of uniquely addressing machines using 32 bit addresses: giving 4 billion possible addresses (like a zip code)
• A system for numbering ports on each machine (like a post office box)
• Port numbers allow several services to operate from a machine at the same time
Common well known ports
• Ports 20/21 File Transfer Protocol
• Port 23 Telnet
• Port 25 Simple Mail Transport Proto.
• Port 79 Finger
• Port 80 HTTP
• Port 110 POP3 (Post Office Protocol)
• All well known ports in the range 1..1023
Internet Protocol (IPv4)
• The Internet consists of a large number of independent sub-networks (subnets)
• A mechanism for relaying datagrams from one network to another (routing)
• For routing to work each organisation must have a well known prefix (all UWA addresses start with the bytes 130.95)
• . . but we don’t use addresses very efficiently and we’re running out fast (UWA doesn’t need 65536 separate addresses)
Next Generation Internet
• The solution is IPv6 which uses 128 bit addresses
• Improves services such as multicasting and secure communication
• Several addresses per m2 of the Earth’s surface (3.4 x 1038 to be precise)
• Not yet widely deployed by ISPs
• Perhaps widely deployed in 2-4 years
• Well written Java software should move to IPv6 without modification/recompilation
• One benefit of abstracted APIs
IP Addresses and Java
• Java has a class java.net.InetAddresswhich abstracts network addresses
• Serves three main purposes:
• Encapsulates an address
• Performs name lookup (converting a host name into an IP address)
• Performs reverse lookup (converting the address into a host name)
java.net.InetAddress (1)
• Abstraction of a network address
• Currently uses IPv4 (a 32 bit address)
• Will support other address formats in future
• Allows an address to be obtained from a host name and vice versa
• Is immutable (is a read-only object)
• Create an InetAddress object with the address you need and throw it away when you have finished
java.net.InetAddress (2)
• Static construction using a factory method• InetAddress getByName(String hostName)
• hostName can be “host.domain.com.au”, or
• hostName can be “130.95.72.134”
• InetAddress getLocalHost()
• Some useful methods:• String getHostName()
• Gives you the host name (for example “www.sun.com”)
• String getHostAddress()
• Gives you the address (for example “192.18.97.241”)
• InetAddress getLocalHost()
• InetAddress[] getAllByName(String hostName)
Using InetAddress objects
import java.net.InetAddress;import java.net.UnknownHostExcepion;
public static void main(String[] args){
try {InetAddress inet1 =
InetAddress.getByName("asp.ee.uwa.edu.au");System.out.println(
"HostAddress=" + inet1.getHostAddress());InetAddress inet2 =
InetAddress.getByName("130.95.72.134");System.out.println("HostName=" + inet2.getHostName());if (inet1.equals(inet2))
System.out.println("Addresses are equal");}catch (UnknownHostException uhe) {
uhe.printStackTrace();}
}
Transmission Control Protocol
• TCP is built on top of IP
• Provides the illusion of a continuous flow (or stream) of data between sender and receiver (rather like a telephone call)
• Splits up streams into strings of small datagrams which are sent in succession
• Contains an error recovery mechanism to recover datagrams which are lost
• These features make application development simpler and so it is widely used
Transmission Control Protocol
• Used by FTP / Telnet / Finger and numerous other network applications
• Used by stream oriented servers such as HTTP (as we will see in unit 2)
• Can also be used to provide inter-process communications (IPC) between the applications on a single machine (such as a X-windows clients and servers)
Two types of TCP Socket
• java.net.ServerSocket is used by servers so that they can accept incoming TCP/IP connections
• A server is a piece of software which advertisesand then provides some service on request
• java.net.Socket is used by clients who wish to establish a connection to a (remote) server
• A client is a piece of software (usually on a different machine) which makes use of some service
java.net.ServerSocket (1)
• Listens on well-known port for incoming connections
• Creates a dynamically allocated port for each newly established connection
• Provides a Socket connected to the new port
• Maintains a queue to ensure that prospective clients are not lost
java.net.ServerSocket (2)
• Construction:• ServerSocket(int port, int backlog)
• Allows up to backlog requests to queue waiting for the server to deal with them
• Some useful methods:• Socket accept()
• Blocks waiting for a client to attempt to establish a connection
• void close()
• Called by the server when it is shutting down to ensure that any resources are deallocated
• More details in the Javadoc (as always!)
java.net.Socket (1)
• Provides access to TCP/IP streams
• Bi-directional communication between sender and receiver
• Can be used to connect to a remote address and port by using the constructor:• Socket(String remoteHost, int port)
• Also used to accept an incoming connection (see ServerSocket)
java.net.Socket (2)
• Can obtain access to input and output streams
• Input stream allows reception of data from the other party• InputSteam getInputStream()
• Output stream allows dispatch of data to the other party• OutputStream getOutputStream()
How it all fits together
2037 80
2037 1583
2037 1583
Client (sid) Server (fred)
ServerSocket ss.s = ss.accept()
s = new Socket(“fred”, 80)
Socket s
s.getInputStream()s.getOuputStream()
s.getInputStream()s.getOuputStream()
A sample TCP serverpublic static void main(String[] args){
try {ServerSocket agreedPort =
new ServerSocket(AGREED_PORT_NUMBER, 5);
while (isStillServing()) {Socket session = agreedPort.accept();respond(session);session.close();
}
agreedPort.close();}catch (UnknownHostException uhe) {
// Very unlikely to occur}catch (IOException ioe) {
// May occur if the client misbehaves?}
}
A sample TCP client
public static void main(String[] args){
try {InetAddress server = InetAddress.getByName(args[0]);Socket connection =
new Socket(server, AGREED_PORT_NUMBER);makeRequestToServer(connection);getReplyFromServer(connection);connection.close();
}catch (UnknownHostException uhe) {
// arg[0] is not a valid server name or IP address}catch (IOException ioe) {
// The connection to the server failed somehow:// the server might have crashed mid sentence?
}}
What are datagrams?
• Datagrams are discrete packets of data
• Each is like a parcel that can be addressed and sent to an recipient anywhere on the Internet
• This is abstracted as the User Datagram Protocol (UDP) in RFC768 (August 1980)
• Most networks cannot guarantee reliable delivery of datagrams
Why use datagrams?
• Good for sending data that can naturally be divided into small chunks
• Poor for (lossless) stream based communications
• Makes economical use of network bandwidth (up to 3 times the efficiency of TCP/IP for small messages)
• Datagrams can be locally broadcast or multicast (one-to-many communication)
Application using datagrams
• UDP can be used for economical point-to-point communications over LANs
• Unix NFS (Network File System)
• NIS (a.k.a. Yellow Pages)
• Datagrams can be used for one-to-many communication:
• Local network broadcasting;
• Multicasting (MBONE)
• but there is no way to create one-to-many streams using TCP/IP
java.net.DatagramPacket (1)
• DatagramPackets normally used as short lived envelopes for datagram messages:
• Used to assemble messages before they are dispatched onto the network,
• or dismantle messages after they have been received
• Has the following attributes:
• Destination/source address
• Destination/source port number
• Data bytes constituting the message
• Length of message data bytes
java.net.DatagramPacket (2)
• Construction:• DatagramPacket(byte[] data, int length)
• Some useful methods:• void setAddress(InetAddress addr)
• InetAddress getAddress()
• void setPort(int port)
• int getPort()
• DatagramPackets are not immutable so, in principle you can reuse then, but . .
• Experience has shown that they often misbehave when you do -- create a new one, use it once, throw it away!
java.net.DatagramSocket (1)
• Used to represent a socket associated with a specific port on the local host
• Used to send or receive datagrams
• Note: there is no counterpart to java.net.ServerSocket! Just use a DatagramSocket with a agreed port number so others know which address and port to send their datagrams to
java.net.DatagramSocket (2)
• Construction:• DatagramSocket(int port)
• Uses a specified port (used for receiving datagrams)
• DatagramSocket()
• Allocate any available port number (for sending)
• Some useful methods:• void send(DatagramPacket fullPacket)
• Sends the full datagram out onto the network
• void receive(DatagramPacket emptyPacket)
• Waits until a datagram and fills in emptyPacket with the message
• . . . and a few more in the Javadoc
sea.datagram.DatagramSender
• This example sends datagrams to a specific host (anywhere on the Internet)
• The steps are as follows:
• Create a new DatagramPacket
• Put some data which constitutes your message in the new DatagramPacket
• Set a destination address and port so that the network knows where to deliver the datagram
• Create a socket with a dynamically allocatedport number (if you are just sending from it)
• Send the packet through the socket onto the network
sea.datagram.DatagramSender
byte[] data = “This is the message”.getBytes();DatagramPacket packet =
new DatagramPacket(data, data.length);
// Create an addressInetAddress destAddress =
InetAddress.getByName(“fred.domain.com”);packet.setAddress(destAddress);packet.setPort(9876);
DatagramSocket socket = new DatagramSocket();socket.send(packet);
sea.datagram.DatagramReceiver
• The steps are the reserve of sending:
• Create an empty DatagramPacket (and allocate a buffer for the incoming data)
• Create a DatagramSocket on an agreed socket number to provide access to arrivals
• Use the socket to receive the datagram (the thread will block until a new datagram arrrives)
• Extract the data bytes which make up the message
sea.datagram.DatagramReceiver
// Create an empty packet with some buffer spacebyte[] data = new byte[1500];DatagramPacket packet =
new DatagramPacket(data, data.length);
DatagramSocket socket = new DatagramSocket(9876);
// This call will block until a datagram arrivessocket.receive(packet);
// Convert the bytes back into a String and printString message =
new String(packet.getData(), 0, packet.getLength());System.out.println("message is " + message);System.out.println("from " + packet.getAddress());
But it’s never quite that simple!
• Several of the constructors/methods throw exceptions which I have omitted
• Each datagrams can only hold up to a maximum of 64KB of data . .
• . . but the underlying transport layer may split the message into smaller packets (for instance Ethernet uses about 1500 bytes)
• Always remember that UDP is an unreliable protocol: If any of the split datagrams are lost the whole message will be lost
Broadcasting
• Broadcasting allows a single datagram to be sent to a group of listeners
• The group consists of all the computers within the local network
• The previous code examples can be used for broadcasting
• Just change the address: each network has a unique broadcast address
IP addresses revisited
• Each 32 bit IP number consists of two components:
• The network address
• The unique international address of the network
• The host address
• The unique address of a specific host in the net
• There are three classes of network address denoted class ‘A’, ‘B’ and ‘C’
Class A,B and C addresses
Class A
Class B
Class C
192 . 85 . 35 . 87
Network Address Byte
Host Address Byte
0...
10...
110...
Broadcast addresses
• CIIPS has a class ‘C’ network which has the address 130.95.72
• This portable computer has host address 134 within the CIIPS network
• Each network has a single host address which is set aside for broadcasts (either all one bits or all zero bits)
• The CIIPS network uses broadcast address 130.95.72.255
• Broadcasts are never routed onto other networks
Multicasting (1)
• Described in RFC1112 (August 1989)
• Multicasting allows distribution of a datagram to a group of listeners who are not within the local network
• Routers between networks need to pass multicast datagrams. . but many do not!
• The MBONE is a way of tunneling datagrams across the Internet between islands of multicast activity
Multicasting (2)
• Multicasts are also sent to a special address (known as a “group”)
• Multicast groups need to be agreed in advance. They are not derived from a specific network/host address
• Multicast groups identify a subject area (or stream of content) rather than a specific computer or network. They are more like a TV channel number than a telephone number.
• The IETF has set aside addresses from 224.0.0.1 to 239.255.255.255 specifically for multicasting
Multicasting (3)
• To send to (or receive from) a multicast group it is first necessary to register interest in the group
• This results in an Internet Group Management Protocol (IGMP) message being sent to your router (RFCs 988/1112/2236)
• Then a datagram is created, addressed to the group (and the chosen port)
• Java has a specialised socket for multicasting: java.net.MulticastSocket
Some multicast groups
• 224.0.0.1 All hosts within local subnet
• 224.0.1.7 Audio news multicast
• 224.0.1.12 Video from IETF meetings
• 224.0.1.20 Expts. within local subnet
• 224.0.1.25 NBC Professional News
• There are 268 million multicast addresses (in IPv4) with 65 thousand ports in each!
java.net.MulticastSocket
• Subclass of java.net.DatagramSocket
• Constructed the same way
• Adds some extra methods:• void joinGroup(InetAddress mcastGroup)
• Enter the specifies group so that you can send or receive datagrams
• void leaveGroup(InetAddress mcastGroup)
• Leave a group that you previously joined
• void setTimeToLive(int ttl)
• Sets how far your datagrams will travel before routers ignore them
• int getTimeToLive()
sea.datagram.MulticastSender
• Sending similar to the previous example. .
• . . .but must register with the multicast group and decide the longevity
• The steps involved are:
• Create the MulticastSocket.
• Join the multicast group(s) (on startup).
• Create the DatagramPacket.
• Send the packet through the socket.
• Leave the multicast group (on exit).
sea.datagram.MulticastSender
InetAddress multicastGroup =InetAddress.getByName(multicastGroupAddr);
MulticastSocket socket = new MulticastSocket();socket.joinGroup(multicastGroup);socket.setTimeToLive(5);
byte[] data = “This is the message”.getBytes();DatagramPacket datagram =
new DatagramPacket(data, data.length);datagram.setAddress(multicastGroup);datagram.setPort(9876);
socket.send(datagram);
socket.leaveGroup(multicastGroup);
sea.datagram.MulticastReceiver
• The steps are:
• Create a multicast socket on an agreed port.
• Join the multicast group (on startup).
• Create an empty datagram.
• Wait for datagram to be delivered on the socket.
• Unpack and use the datagram.
• Leave the multicast group (on exit).
sea.datagram.MulticastReceiver
InetAddress multicastGroup =InetAddress.getByName(multicastGroupAddr);
MulticastSocket socket = new MulticastSocket(9876);socket.joinGroup(multicastGroup);
byte[] data = new byte[1000];DatagramPacket packet =
new DatagramPacket(data, data.length);socket.receive(packet);
String message = new String(packet.getData(), 0, packet.getLength());
socket.leaveGroup(multicastGroup);
Useful sources of information
• The Internet Engineering Task Force (IETF) which is at http://www.ietf.org -- you will be able to download RFCs from here
• Multicasting try reading the HOWTO which is available from the URL: http://ftp.southcom.com.au/LDP/HOWTO/...Multicast-HOWTO.html
Homework
• Read through the code samples to convince yourself you understand what’s going on
• Sample code can be downloaded from http://ciips.ee.uwa.edu.au/~gareth
• If you can, run the examples
Comments, Suggestions. . .
• How was the presentation paced?
• Was there enough (or too much) technical content?
• Any areas of particular interest?
• Comments regarding presentation style?