1 / 29

Computer Networks 364 Internet Architecture

Computer Networks 364 Internet Architecture. John Morris Computer Science/Electrical Engineering University of Auckland Email: jmor159@cs.auckland.ac.nz URL: http:/www.cs.auckland.ac.nz/~jmor159. Internet Architecture. FTP. HTTP. NV. TFTP. TCP. UDP. IP. Network protocols -

keely-logan
Download Presentation

Computer Networks 364 Internet Architecture

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Computer Networks 364Internet Architecture John Morris Computer Science/Electrical Engineering University of Auckland Email: jmor159@cs.auckland.ac.nz URL: http:/www.cs.auckland.ac.nz/~jmor159

  2. Internet Architecture FTP HTTP NV TFTP TCP UDP IP Network protocols - implemented in a combination of hardware and software, eg Ethernet, Fibre Distributed Data Interface (FDDI) ……. NET1 NET2 NET3

  3. Internet Architecture FTP HTTP NV TFTP TCP UDP Internet protocol - supports interconnection of multiple networking technologies into a single, logical network IP ……. NET1 NET2 NET3

  4. Internet Architecture FTP HTTP NV TFTP Transmission Control Protocol - reliable byte-stream channel User Datagram Protocol - unreliable datagram delivery channel TCP UDP IP ……. NET1 NET2 NET3 TCP, UDP: Transport protocols (end-to-end protocols)

  5. Sockets 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

  6. Sockets • 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 0 0 Ports Internet Ports MachineB nnn nnn

  7. Sockets • Note: these constructors throw exceptions • Use them in a try { } catch .. Block • Note:UnknownHostExceptionis a subclass ofIOException • 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 ) { ... }

  8. Talking to a server 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 ) { ... }

  9. Talking to a server Socket(and almost all the rest)throws an exception, so put it all in atry { }block 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 ) { ... } Once the Sockethas been created, create input and output streams on it DataInputStream DataOutputStream PrintStream Just part of the stream zoo - there are 55 more!

  10. Talking to a server 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 the streams just like any other I/O device printlnonPrintStream readLineonDataInputStream

  11. Talking to a server • 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 ); 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 ) { ... }

  12. Talking to a server - variant 1 • Exception Choices (Java usually gives you plenty ) • 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 ... */ try { } catch { } around each exception throwing call

  13. Talking 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 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; }

  14. Simple 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 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! */ } }

  15. Simple Server Set up aServerSocket - basically just a socket with an accept method 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! */ } } Servers usually live forever!! The code will block here until a client attempts a connection

  16. Simple 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! */ } } • Now we just • create the input & output streams • read and write to them • close the connection when we’re finished

  17. Simple 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! */ } } 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

  18. Multi-threaded Server Make this parameter relevant! Number of queued requests 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! */ } } As soon as we get a connection, spawn a handler thread to talk to the client Start the thread

  19. Multi-threaded Server - The Handler This class is a 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 } } Constructor - just save a reference to the socket Same operational code .. Just embedded in the thread’s run method

  20. UDP - Datagrams • Use aDatagramSocket • 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();

  21. Datagrams, ... • Use aDatagramSocket • 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

  22. 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 theDatagramPacket • A single DatagramSocketcan receive messages from many sources • Use getInetAddress()on the receivedDatagramPacketto 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

  23. 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

  24. Applications em

  25. UDP vs 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

  26. UDP vs 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 ...

  27. Multicast sockets ... • Messages to multiple hosts • Use a MulticastSocket • ConstructorMulticastSocket( int port ) throws IOException;creates a datagram socket bound toport • 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

  28. Protocols - 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 Comment • Now managed by the Internet Engineering Task Force (IETF)Over 2000 • Standards for the Internet

  29. Protocols - 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

More Related