Networking

Introduction
• Java is practically a synonym for Internet programming.
• There are a number of reasons for this, not the least of
which is its ability to generate secure, cross platform,
portable code.
• However, one of the most important reasons that Java is
the premier language for network programming are the
classes defined in the java.net package.
• They provide an easy-to-use means by which
programmers of all skill levels can access network
resources.
• This chapter explores the java.net package.
NETWORKING BASICS
 A Network Is...
• node
– any device on the network
• host
– a computer on the network
• address
– computer-readable name for host
• host name
– human-readable name for host
 A Network Does...
• datagram (or “packet”)
– little bundle of information
– sent from one node to another
• protocol
– roles, vocabulary, rules for communication
• IP
– the Internet Protocol
 The Three ‘I’s
• internet
– any IP-based network
• Internet
– the big, famous, world-wide IP network
• intranet
– a corporate LAN-based IP network
• extranet
– accessing corporate data across the Internet
 Socket
• At the core of Java’s networking support is the concept of a socket.
• A socket identifies an endpoint in a network.
• Sockets are at the foundation of modern networking because a socket
allows a single computer to serve many different clients at once, as
well as to serve many different types of information.
• This is accomplished through the use of a port, which is a numbered
socket on a particular machine.
• A server process is said to "listen" to a port until a client connects to it.
• A server is allowed to accept multiple clients connected to the same
port number, although each session is unique.
• To manage multiple client connections, a server process must be
multithreaded or have some other means of multiplexing the
simultaneous I/O.
 Sockets
• A network socket is a lot like an electrical socket.
• Socket: a two-way connection
• Internet Protocol (IP) is a low-level routing protocol that
breaks data into small packets and sends them to an address
across a network, which does not guarantee to deliver said
packets to the destination.
• Transmission Control Protocol (TCP) is a higher-level protocol
that manages to robustly string together these packets,
sorting and retransmitting them as necessary to reliably
transmit your data.
• A third protocol, User Datagram Protocol (UDP), sits next to
TCP and can be used directly to support fast, connectionless,
unreliable transport of packets.
 Ports
• Once a connection has been established, a higher-level
protocol ensues, which is dependent on which port you are
using.
• TCP/IP reserves the lower 1,024 ports for specific protocols.
• Many of these will seem familiar to you if you have spent
any time surfing the Internet.
• Port number 21 is for FTP; 23 is for Telnet; 25 is for e-mail;
43 is for whois; 80 is for HTTP; 119 is for netnews—and the
list goes on.
• It is up to each protocol to determine how a client should
interact with the port.
 Ports
• Port: a meeting place on a host
1. one service per port
2. 1-1023 = well-known services
3. 1024+ = experimental services, temporary
 Well-Known Ports
• 20,21: FTP
• 23: telnet
• 25: SMTP
• 43: whois
• 80: HTTP
• 119: NNTP
• 1099: RMI
 Sockets and Ports

port 13 Time Service

Client Web Service

port 80

Socket Socket

Server
 Addresses
• Every computer on the Internet has an address.
• An Internet address is a number that uniquely identifies each
computer on the Net.
• There are 32 bits in an IP address, and often refer to them as a
sequence of four numbers between 0 and 255 separated by
dots
• The first few bits define which class of network, lettered A, B,
• C, D, or E, the address represents.
• Most Internet users are on a class C network, since there are
over two million networks in class C.
 IP Addresses
• The first byte of a class C network is between
192 and 224, with the last byte actually
identifying an individual computer among the
256 allowed on a single class C network.
• IP Address: identifies a host
• DNS: converts host names / domain names
into IP addresses.
 Protocols for socket communication
• Socket communication takes place via a protocol.
1. Internet Protocol (IP) is a low-level routing protocol that
breaks data into small packets and sends them to an address
across a network, which does not guarantee to deliver said
packets to the destination.
2. Transmission Control Protocol (TCP) is a higher-level protocol
that manages to robustly string together these packets,
sorting and retransmitting them as necessary to reliably
transmit data.
3. A third protocol, User Datagram Protocol (UDP), sits next to
TCP and can be used directly to support fast, connectionless,
unreliable transport of packets.
 HTTP Protocol
• For example, HTTP is the protocol that web browsers
and servers use to transfer hypertext pages and images.
• It is a quite simple protocol for a basic page-browsing
web server.
• Here’s how it works.
– When a client requests a file from an HTTP server, an action
known as a hit, it simply sends the name of the file in a
special format to a predefined port and reads back the
contents of the file.
– The server also responds with a status code to tell the client
whether or not the request can be fulfilled and why.
 TCP/IP Protocol Suit

Application Layer (HTTP, FTP, SMTP)

Transport Layer (TCP, UDP)

Internet Layer (IP)

Physical Network
 TCP/UDP/IP
IP
raw packets
the “Internet Layer”
TCP
data stream
reliable, ordered
the “Transport Layer”
UDP
user datagrams (packets)
unreliable, unordered
the “Transport Layer”
Basics of network programming: Overview

RMI JDBC CORBA

java.net

TCP/IP

Network OS
JAVA AND NETWORKING
 The Socket Class

• Socket(String host, int port)

• InputStream getInputStream()
• OutputStream getOutputStream()
• void close()
Socket s = new Socket(“www.starwave.com”, 90);
 Client-Server
• Client - initiates connection
– retrieves data,
– displays data,
– responds to user input,
– requests more data
• Examples:
– Web Browser
– Chat Program
– PC accessing files
 Simple client server program-client

/** Client program using TCP */

public class Tclient {

final static String serverIPname = “starwave.com";// server IP name

final static int serverPort = 3456; // server port number
public static void main(String args[]) {
java.net.Socket sock = null; // Socket object for communicating
java.io.PrintWriter pw = null; // socket output to server
java.io.BufferedReader br = null; // socket input from server
try {
sock = new java.net.Socket(serverIPname,serverPort);// create socket
and connect
pw = new java.io.PrintWriter(sock.getOutputStream(), true); // create
reader and writer
br = new java.io.BufferedReader(new
java.io.InputStreamReader(sock.getInputStream()));
System.out.println("Connected to Server");
 pw.println("Message from the client"); // send msg to the server
System.out.println("Sent message to server");
String answer = br.readLine(); // get data from the
server
System.out.println("Response from the server >" + answer);

pw.close();
// close everything
br.close();
sock.close();
} catch (Throwable e) {
System.out.println("Error " + e.getMessage());
e.printStackTrace();
}
}
}
 Server program
/** Server program using TCP */
public class Tserver {

final static int serverPort = 3456; // server

port number

public static void main(String args[]) {

java.net.ServerSocket sock = null; //
original server socket
java.net.Socket clientSocket = null; // //socket
created by accept
java.io.PrintWriter pw = null; //
//socket output stream
java.io.BufferedReader br = null; //
socket input stream
try {
sock = new java.net.ServerSocket(serverPort); // create
socket and bind to port
System.out.println("waiting for client to connect");
clientSocket = sock.accept();
// wait for client to connect
System.out.println("client has connected");
pw = new java.io.PrintWriter(clientSocket.getOutputStream(),true);
br = new java.io.BufferedReader(
new java.io.InputStreamReader(clientSocket.getInputStream()));

String msg = br.readLine(); // read msg from

client
System.out.println("Message from the client >" + msg);
pw.println("Got it!"); // send msg to client
pw.close(); // close everything
br.close();
clientSocket.close();
sock.close();
} catch (Throwable e) {
System.out.println("Error " + e.getMessage());
e.printStackTrace();
}
}
}
 Multiple Clients
• Multiple clients can connect to the same port
on the server at the same time.
• Incoming data is distinguished by the port to
which it is addressed and the client host and
port from which it came.
• The server can tell for which service (like http or
ftp) the data is intended by inspecting the port.
• It can tell which open socket on that service the
data is intended for by looking at the client
address and port stored with the data.
 Queueing
• Incoming connections are stored in a queue
until the server can accept them.
• On most systems the default queue length is
between 5 and 50.
• Once the queue fills up further incoming
connections are refused until space in the
queue opens up.
 The java.net.ServerSocket Class
• The java.net.ServerSocket class represents a server
socket.
• A ServerSocket object is constructed on a particular
local port. Then it calls accept() to listen for incoming
connections.
• accept() blocks until a connection is detected. Then
accept() returns a java.net.Socket object that performs
the actual communication with the client.
 Constructors
• There are three constructors that specify the port to
bind to, the queue length for incoming connections,
and the IP address to bind to:
– public ServerSocket(int port) throws IOException
– public ServerSocket(int port, int backlog) throws
IOException
– public ServerSocket(int port, int backlog,
InetAddress networkInterface) throws IOException
 Constructing Server Sockets
• specify the port number to listen :
try {
ServerSocket ss = new ServerSocket(80);
}
catch (IOException e) {
System.err.println(e);
}
THE NETWORKING CLASSES AND
INTERFACES
Classes in java.net
Classes in java.net
Interfaces in java.net
A DATAGRAM EXAMPLE
 A Datagram Example
• The following example implements a very
simple networked communications client and
server.
• Messages are typed into the window at the
server and written across the network to the
client side, where they are displayed.
// Demonstrate Datagrams.
import java.net.*;

class WriteServer {
public static int serverPort = 998;
public static int clientPort = 999;
public static int buffer_size = 1024;
public static DatagramSocket ds;
public static byte buffer[] = new byte[buffer_size];

public static void TheServer() throws Exception {

int pos=0;
while (true) {
int c = System.in.read();
switch (c) {
case -1:
System.out.println("Server Quits.");
ds.close();
return;
case '\r':
break;
case '\n':
ds.send(new DatagramPacket(buffer,pos,
InetAddress.getLocalHost(),clientPort));
pos=0;
break;
default:
buffer[pos++] = (byte) c;
}
}
}
public static void TheClient() throws Exception {
while(true) {
DatagramPacket p = new DatagramPacket(buffer,
buffer.length);
ds.receive(p);
System.out.println(new String(p.getData(), 0, p.getLength
()));
}
}

public static void main(String args[]) throws Exception {

if(args.length == 1) {
ds = new DatagramSocket(serverPort);
TheServer();
} else {
ds = new DatagramSocket(clientPort);
TheClient();
}
}
}
• This sample program is restricted by the
DatagramSocket constructor to running
between two ports on the local machine.
• To use the program, run java WriteServer in
one window; this will be the client.
• Then run java WriteServer 1
• This will be the server. Anything that is typed in
the server window will be sent to the client
window after a newline is received.