computer networks 364 internet architecture

Computer Networks 364Computer Networks 364Internet ArchitectureInternet Architecture

John Morris

Computer Science/Electrical EngineeringUniversity of Auckland

Email: [email protected]: http:/www.cs.auckland.ac.nz/~jmor159

Internet ArchitectureInternet Architecture

FTP HTTP NV TFTP

TCP UDP

IP

NET1 NET2 NET3…….

Network protocols - implemented in a combination of hardware and software, eg Ethernet, Fibre Distributed Data Interface (FDDI)


FTP HTTP NV TFTP

TCP UDP

IP


Internet protocol - supports interconnection of multiple networking technologies into a single, logical network


FTP HTTP NV TFTP

TCP UDP

IP


Transmission Control Protocol - reliable byte-stream channel

User Datagram Protocol - unreliable datagram delivery channel

TCP, UDP: Transport protocols (end-to-end protocols)

Sockets Sockets Application Programming Interface (API)Application Programming Interface (API)► Socket interface

Network interface Provided by most OS’s Originally provided by the Berkeley Unix distribution

► API defines services provided by a protocol► Socket

Major abstraction Point where a local application process attaches to the network Operations

► Create a socket► Attach the socket to the network► Send / receive messages via the socket► Close the socket

SocketsSockets

► Sockets are the “endpoints” of Internet connections

► Socket constructors require Internet addresses Socket( String host, int port ) throws

UnknownHostException, IOException;

Socket(InetAddress address, int port) throws IOException;

... and a host of other alternatives, see the API documentation!

► Note: these constructors throw exceptions Use them in a try { } catch .. block

MachineA

MachineB

Po

rts

Po

rts

00

nnnnnn

Internet

SocketsSockets

► Note: these constructors throw exceptions Use them in a try { } catch .. Block

Note: UnknownHostException is a subclass of IOException

catch( IOException e ) alone would suffice

String name = new String(“ciips.ee.uwa.edu.au”);try { Socket t = new Socket( name, 80 ); ... }catch( UnknownHostException e ) { System.out.println(“Unknown host:” + name ); }catch( IOException e ) { ...

}

static final int lut_port = 3062;String name = new String(“ciips.ee.uwa.edu.au”);static final String query = “?”;try { Socket server = new Socket( name, lut_port ); DataInputStream input = new DataInputStream( server.getInputStream() ); PrintStream output = new PrintStream( server.getOutputStream() ); do { output.println( query ); String resp = input.readLine(); System.out.println( name + “ response: “ + resp ); } while ( !( resp.equal( quit_string ) ) ); server.close(); }catch( UnknownHostException e ) { System.out.println(“Unknown host:” + name ); }catch( IOException e ) { ...

}

Talking to a serverTalking to a server


}

Socket (and almost all the rest) throws an exception, so put it all in a try { } block

Once the Socket has been created,create input and outputstreams on it

DataInputStreamDataOutputStreamPrintStream

Just part of the streamzoo - there are 55 more!


static final int lut_port = 3062;String name = new String(“ciips.ee.uwa.edu.au”);static final String query = “?”;try { Socket server = new Socket( name, lut_port ); DataInputStream input = new DataInputStream( server.getInputStream() ); PrintStream output = new PrintStream( server.getOutputStream() ); do { output.println( query ); String resp = input.readLine(); System.out.println( name + “ response: “ + resp ); } while ( !( resp.equal( quit_string ) ) ); server.close(); }catch( UnknownHostException e ) { System.out.println(“Unknown host:” + name ); }catch( IOException e ) { ... }

Now use methods on thestreams just like any otherI/O device println on PrintStreamreadLine on DataInputStream



}

Finally add some code to handle exceptions!Choices (Java usually gives you plenty ) Separate catch blocks for different types One “catch all” (IOException) try { } catch { } for each method call Throw the exception from here


static final int lut_port = 3062;String name = new String(“ciips.ee.uwa.edu.au”);static final String query = “?”;try { Socket server = new Socket( name, lut_port ); }catch( UnknownHostException e ) { System.out.println(“Unknown host:” + name ); return error_flag; }catch( IOException e ) { /* process other errors .... */ return error_flag; }

try { DataInputStream input = new DataInputStream( server.getInputStream() ); PrintStream output = new PrintStream( server.getOutputStream() ); }catch( IOException e ) { System.out.println(“Cant form streams”); return error_flag;

} do { /* do some real work ... */

Talking to a server - variant 1Talking to a server - variant 1Exception Choices (Java usually gives you plenty ) try { } catch { } for each method call Throw the exception from here

try { } catch { } around each exception throwing call

public String ServerResp( String query ) throws IOException { static final int lut_port = 3062; String name = new String(“ciips.ee.uwa.edu.au”); Socket server = new Socket( name, lut_port ); DataInputStream input = new DataInputStream( server.getInputStream() ); PrintStream output = new PrintStream( server.getOutputStream() ); output.println( query ); String resp = input.readLine(); server.close(); return resp; }

Talking to a server - variant 2Talking to a server - variant 2

Exception Choices (Java usually gives you plenty ) try { } catch { } for each method call Throw the exception from here

This method throws any exceptions

up a level

static final int lut_port = 3062;static final int queue_len = 10;try { Socket server = new ServerSocket( lut_port, queue_len ); }catch( IOException e ) { System.out.println(“Can’t establish server on port “ + lut_port ); }while( true ) { // The server never dies! // Wait for a connection attempt try { Socket s = server.accept(); PrintStream ps = new PrintStream( s.getOutputStream() ); DataInputStream in = new DataInputStream( s.getInputStream() ); while( true ) { String q = in.readLine(); if ( q.equal( “?” ) ) ps.println( “Hello” ); else if ( q.equal( “quit” ) ) break; else ps.println( “??” ); } s.close(); // Close this connection } catch ( IOException e ) { /* Do something about it! */ } }

Simple ServerSimple Server

static final int lut_port = 3062;static final int queue_len = 10;try { Socket server = new ServerSocket( lut_port, queue_len ); }catch( IOException e ) { System.out.println(“Can’t establish server on port “ + lut_port ); }while( true ) { // The server never dies! // Wait for a connection attemtp try { Socket s = server.accept(); PrintStream ps = new PrintStream( s.getOutputStream() ); DataInputStream in = new DataInputStream( s.getInputStream() ); while( true ) { String q = in.readLine(); if ( q.equal( “?” ) ) ps.println( “Hello” ); else if ( q.equal( “quit” ) ) break; else ps.println( “??” ); } s.close(); // Close this connection } catch ( IOException e ) { /* Do something about it! */ } }

Simple ServerSimple ServerSet up a ServerSocket- basically just a socketwith an accept method

Servers usually liveforever!!

The code will blockhere until a

client attempts a connection



Now we just create the input & output streams read and write to them close the connection when we’re finished



But ...This server blocks whilst one user is using it!A second client can’t connect ‘til the first one finishes!

Solution ...A thread for each client

static final int lut_port = 3062;static final int queue_len = 10;try { Socket server = new ServerSocket( lut_port, queue_len ); }catch( IOException e ) { System.out.println(“Can’t establish server on port “ + lut_port ); }while( true ) { // The server never dies! // Wait for a connection attempt try { Socket s = server.accept(); // This thread will do the talking ClientHandler ch = new ClientHandler( s ); ch.start(); } catch ( IOException e ) { /* Do something about it! */ } }

Multi-threaded ServerMulti-threaded Server

Make this parameter relevant!Number of queued requests

As soon as we get a connection,

spawn a handler thread to talk to the client

Start the thread

class ClientHandler extends Thread { Socket s; public ClientHandler( Socket s ) { this.s = s; } public void run() { PrintStream ps = new PrintStream( s.getOutputStream() ); DataInputStream in = new DataInputStream( s.getInputStream() ); while( true ) { String q = in.readLine(); if ( q.equal( “?” ) ) ps.println( “Hello” ); else if ( q.equal( “quit” ) ) break; else ps.println( “??” ); } s.close(); // Close this connection } }

Multi-threaded Server - The HandlerMulti-threaded Server - The Handler

Same operational code ..Just embedded in the

thread’s run method

Constructor - just save a reference to the

socket

This class is a Thread

UDP - DatagramsUDP - Datagrams► Use a DatagramSocket

Constructor DatagramSocket( int port ) throws IOException;

creates a datagram socket on port Methods

void receive( DatagramPacket p ) throws IOException;

void send( DatagramPacket p ) throws IOException;► DatagramPacket

Constructor DatagramPacket( byte[] buf, int length, InetAddress add, int port );

creates a packet to be sent to port at add Methods

► byte[] getData();► void setData( byte[] buf );► InetAddress getAddress();

Datagrams, ...Datagrams, ...► Use a DatagramSocket

Constructor DatagramSocket( int port ) throws IOException;

creates a datagram socket on port Methods

void receive( DatagramPacket p ) throws IOException;

void send( DatagramPacket p ) throws IOException;► DatagramPacket

Constructor DatagramPacket( byte[] buf, int length, InetAddress add, int port );

creates a packet to be sent to port at add Methods

► byte[] getData();► void setData( byte[] buf );► InetAddress getAddress();

Note: byte[]not char[]...See your Java text

Datagrams, ...Datagrams, ...► Differences

UDP is connectionless► DatagramSocket can be closed at any time

No ‘close’ message is sent Any socket on any machine can send a datagram addressed to this port This socket doesn’t ‘know’ who was sending messages to it! Compare TCP sockets: if either end closes, the other is notified

► Each DatagramPacket contains its own destination address One DatagramSocket can send messages to many different receivers

► Change the address in the DatagramPacket

► A single DatagramSocket can receive messages from many sources Use getInetAddress() on the received DatagramPacket to determine

the sender’s address and

Use getPort() to determine the port number:

dg_socket = new DatagramSocket( portxx );DatagramPacket dp = new DatagramPacket( … );dg_socket.receive( dp ); // Blocks until a packet arrivesInetAddress sender_add = dp.getInetAddress();int sender_port = dp.getPort();

Thus a response can be sent if needed

Datagrams, ...Datagrams, ...► Differences

UDP is connectionless► Threading is not needed to handle multiple sessions

A server application can manage multiple connections It keeps track of the state of the session with each individual client

► Broadcast Packets can be addressed to the ‘broadcast’ address: xx.xx.xx.255 Received by all listeners on the specified port on that subnet Message is only transmitted once on ‘bus’ networks (eg Ethernet)

► All receivers read and extract it from the net at the same time

► Multicast capability Software is simpler

► Simple state machine - each port is either sending, receiving or idle No reliability management (acks, retrys, etc) No congestion control

Minimum send rate possible► (Subject to hardware capabilities!)► TCP’s congestion control can ‘throttle back’ transmission rate

Smaller packet overhead► UDP - 8byte header vs TCP - 20 byte header

Applications Applications

Application Application-layer protocol Transportprotocole mail SMTP TCP

Remote terminal telnet TCP

Web HTTP TCP

File transfer FTP TCP

Remote file server NFS typically UDP

Streaming multimedia Proprietary typically UDP

Network management SNMP typically UDP

Name translation DNS typically UDP

Routing protocol RIP typically UDP

Internet telephony Proprietary typically UDPem

UDP UDP vsvs TCP TCP

► email, terminal access, web serving, file transfer Not time critical Lost of packets not tolerable

► Routing protocol (RIP) Updates every ~5mins

► Lost updates replaced by newer ones

► Network management (SNMP) Messages needed when network is ‘stressed’

► Reliable transport difficult at these times

► Name lookup (DNS) TCP connection establishment delay multiplied Use UDP

► Single request► Simple try again on failure, timeout, etc

UDP UDP vsvs TCP TCP

► Multimedia (video, telephony, etc) Natural redundancy in information

Packet loss easily tolerated Congestion control mechanisms

Unpredictable delivery times Unacceptable for voice, video, etc

but► UDP can’t guarantee bandwidth either!

Network congestion leads to ► delay► complete loss of information

► Internet Telephony, etc, using UDP Controversial Impossible to guarantee anything! Internet is a shared ‘store-and-forward’ network

► Routers store messages for variable times before forwarding Time-critical services may work

► When other users have little demand► but ...

Multicast sockets ...Multicast sockets ...

► Messages to multiple hosts Use a MulticastSocket Constructor

MulticastSocket( int port ) throws IOException;creates a datagram socket bound to port

Methods► void receive( DatagramPacket p ) throws IOException;► void send( DatagramPacket p ) throws IOException;► void joinGroup( InetAddress mcastaddr ) throws IOException;

► void leaveGroup( InetAddress mcastaddr ) throws IOException;

Hosts can join and leave multicast groups Security feature:

► An applet is not allowed to use a multicast socket

Inherited fromDatagramSocket

Protocols - HTTPProtocols - HTTP

► HyperText Transfer Protocol (HTTP) WWW application layer protocol Client: browser (Netscape, Opera, that other one, … ) Server: a web server (source of Web pages - Apache, … ) Defines the language used by clients to request web pages

► RFC 2616 (HTTP/1.1)

► Default port is 80

RFC = Request for CommentNow managed by the Internet Engineering Task Force (IETF)Over 2000Standards for the Internet

Protocols - HTTPProtocols - HTTP

► HyperText Transfer Protocol (HTTP) Web pages consist of a number of objects

► Basic page► Embedded images, etc► Each object is fetched from the server in a single session

Open TCP connection GET message from client Response from server with object Close connection

► Obviously rather inefficient TCP connection establishment is expensive Persistent connections

► TCP connection is left open for subsequent requests

► Further efficiency from pipelining Send additional requests before first response received Allows browser to do useful work while server is fetching objects

► Parsing to discover embedded objects,► Formatting and displaying pages, etc

computer networks 364 internet architecture

Documents

new socket

string server

socket server

new printstream server

new datainputstream

println query string

unknownhostexception

port datainputstream