Networking.ppt

(1)

(2)

Introduction

 _{Java.net package provides support for}

networking.

 _{What makes Java a good language for}

networking are the classes defined in the java.net package.

(3)

(4)

Sockets

 _{Socket is the name given , in one}

particular programming model, to the end points of a communication link

between processes.

 _{When processes communicate over a}

network, Java Technology uses streams model.

(5)

Sockets

 _Sockets:

 _{Sockets hold two streams: an input}

stream and an output stream.

 _{Each end of the socket has a pair of}

(6)

Socket

 _{A process send data to another process}

through a network by writing to the output stream associated with the Socket.

 _{A process reads data written by another}

process by reading from the input stream associated with the Socket.

(7)

Setting Up the Connection

 _{To setup the network connection, one}

machine must run a program that is waiting for a connection, and a

second machine must try to reach the first.

 _{Set up of a network connection is}

similar to a telephone system: One end must dial the other end, which must be listening.

(8)

(9)

Addressing the Connection

 _{When you make a network connection,}

you need to know the address or the name of the remote machine.

 _{In addition, a network connection,}

requires a port number, which you can think of as a telephone extension

(10)

Port Numbers

 _{Port numbers in TCP/IP systems are}

16-bit numbers and the values range from 0-65535.

 _{Port numbers below 1024 are reserved}

for predefined services.

 _{Client port numbers are allocated by the}

host OS to something not in use, while server port numbers are specified by the programmer, and are used to identify a particular service.

(11)

 _{Both client and server must agree in}

advance on which port to use.

 _{If the port numbers used by the two}

parts of the system do not agree, communication does not occur.

(12)

Server

 _A_server_{is anything that has some}

resource that can be shared.

 _{There are}_{compute servers,}_which

provide computing power;

 _{print servers,}_{which manage a collection}

of printers;

 _{disk servers,}_{which provide networked}

disk space;

(13)

Client

 _A_client_{is simply any other entity that}

wants to gain access to a particular server.

(14)

 _{The notion of a socket allows a single computer to} serve many different clients at once, as well as serving many different types of information.

 _{This feat is managed by the introduction 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.

(15)

Local Host Info

// Demonstrate InetAddress. import java.net.*;

class InetAddressTest {

public static void main(String args[]) throws UnknownHostException

{

InetAddress Address = InetAddress.getLocalHost(); System.out.println(Address.getHostName());

System.out.println(Address.getHostAddress()); }

(16)

TCP/IP

 _{TCP/IP sockets are used to implement}

 reliable,

 bidirectional,

 persistent,

 point-to- point,

 stream-based connections between hosts on the Internet.

 _{A socket can be used to connect Java's I/O}

system to other programs that may reside either on the local machine or on any other machine on the Internet.

(17)

 _{There are two kinds of TCP sockets in Java.}  _{One is for servers, and the other is for}

clients.

 _The_ServerSocket_{class is designed to be}

a "listener," which waits for clients to connect before doing anything.

 _The_Socket_{class is designed to connect to}

server sockets and initiate protocol exchanges.

(18)

 _{The creation of a}_Socket_object

implicitly establishes a connection between the client and server.

 _{There are no methods or constructors}

that explicitly expose the details of establishing that connection.

(19)

 _{Here are two constructors used to create}

client sockets:

 Socket(String hostName, int port)

 Creates a socket connecting the local host to the named host and port; can throw an

UnknownHostException or an IOException.

 Socket(InetAddress ipAddress, int port)

 Creates a socket using a preexisting

InetAddress object and a port; can throw an IOException.

(20)

 _{A socket can be examined at any time for}

the address and port information associated with it, by use of the following methods:

 _{InetAddress getInetAddress( )}

 _{Returns the}_InetAddress_{associated with}

the Socket object.

 _{int getPort( )}

 _{Returns the remote port to which this}

Socket object is connected.

 _{int getLocalPort( )}

 _{Returns the local port to which this}_Socket

(21)

 _{Once the}_Socket_{object has been created, it}

can also be examined to gain access to the input and output streams associated with it.

 _{Each of these methods can throw an}

IOException if the sockets have been

invalidated by a loss of connection on the Net.

 _{These streams are used exactly like the I/O}

streams receive data.

 _{InputStream getInputStream( )}  _{Returns the}_InputStream

(22)

 _{InputStream getInputStream( )}

 _{Returns the}_InputStream_associated

with the invoking socket.

 _{OutputStream getOutputStream()}  _{Returns the}_OutputStream

associated with the invoking socket.

 _{void close()}

 _{Closes both the}_InputStream_and

(23)

Socket functional calls

 socket (): Create a socket

 bind(): bind a socket to a local IP address and port #

 listen(): passively waiting for connections

 connect(): initiating connection to another socket

 accept(): accept a new connection

 Write(): write data to a socket

 Read(): read data from a socket

(24)

Socket-programming using TCP

TCP service: reliable byte stream transfer

process TCP with buffers, variables socket controlled by application developer controlled by operating system process TCP with buffers, variables socket internet

client socket( )bind( ) server connect( ) socket( ) bind( ) listen( ) accept( ) send( ) recv( )

close( ) _{close( )}

recv( )

send( )

TCP conn. request

(25)

Socket programming with TCP

Example client-server app:

 client reads line from standard input (inFromUser stream) , sends to server via socket (outToServer stream)

 server reads line from socket

 server converts line to uppercase, sends back to client

 client reads, prints modified line from socket

(inFromServer stream)

ou tT oS er ve r

to network from network

in F ro m S er ve r in F ro m U se r keyboard monitor Process clientSocket input stream input stream output stream TCP socket Input stream:

sequence of bytes into process

output stream:

sequence of bytes out of process

Client process

client TCP socket

(26)

Client/server socket interaction: TCP

wait for incoming connection request

connectionSocket = welcomeSocket.accept()

create socket, port=x, for

incoming request:

welcomeSocket = ServerSocket()

create socket,

connect to hostid, port=x

clientSocket = Socket()

close

connectionSocket

read reply from

clientSocket

close

clientSocket

Server (running on hostid) Client

send request using

clientSocket

read request from

connectionSocket

write reply to

connectionSocket

TCP

(27)

TCPClient.java

import java.io.*; import java.net.*; class TCPClient {

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

String sentence;

String modifiedSentence; BufferedReader inFromUser =

new BufferedReader(new InputStreamReader(System.in)); Socket clientSocket = new Socket("hostname", 6789);

DataOutputStream outToServer =

(28)

TCPClient.java

BufferedReader inFromServer = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

sentence = inFromUser.readLine();

outToServer.writeBytes(sentence + '\n');

modifiedSentence = inFromServer.readLine();

System.out.println("FROM SERVER: " + modifiedSentence);

clientSocket.close();

} }

(29)

TCPServer.java

import java.io.*; import java.net.*; class TCPServer {

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

String clientSentence, capitalizedSentence;

ServerSocket welcomeSocket = new ServerSocket(6789); while(true) {

Socket connectionSocket = welcomeSocket.accept();

BufferedReader inFromClient = new BufferedReader(new

(30)

TCPServer.java

DataOutputStream outToClient =

new DataOutputStream(connectionSocket.getOutputStream());

clientSentence = inFromClient.readLine();

capitalizedSentence = clientSentence.toUpperCase() + '\n'; outToClient.writeBytes(capitalizedSentence);

} } }