Chapter 2 Applications and

Transcription

1 Chapter 2 Applications and Layered Architectures Sockets Socket API API (Application Programming Interface) Provides a standard set of functions that can be called by applications Berkeley UNIX Sockets API Abstraction for applications to send & receive data Applications create sockets that plug into network Applications write/read to/from sockets Implemented in the kernel Facilitates development of network applications Hides details of underlying protocols & mechanisms Also in Windows, Linux, and other OS s 1

2 Communications through Socket Interface Socket Application 1 interface Application 2 Socket interface descriptor port number Socket User Kernel User Kernel Socket Application references a socket through a descriptor Socket bound to a port number descriptor port number Underlying communication protocols Underlying communication protocols Communications network Stream mode of service ion-oriented First, setup connection between two peer application processes Then, reliable bidirectional in-sequence transfer of byte stream (boundaries not preserved in transfer) Multiple write/read between peer processes Finally, connection release Uses TCP ionless Immediate transfer of one block of information (boundaries preserved) No setup overhead & delay Destination address with each block Send/receive to/from multiple peer processes Best-effort service only Possible out-of-order Possible loss Uses UDP 2

3 & Differences Specifies well-known port # when creating socket May have multiple IP addresses (net interfaces) Waits passively for client requests Assigned temporary port # Initiates communications with server Needs to know server s IP address & port # DNS for URL & server well-known port # learns client s address & port # does Passive Open socket creates socket to listen for connection requests specifies type: TCP (stream) socket call returns: non-negative integer descriptor; or -1 if unsuccessful 3

4 does Passive Open bind assigns local address & port # to socket with specified descriptor Can wildcard IP address for multiple net interfaces bind call returns: 0 (success); or -1 (failure) Failure if port # already in use or if reuse option not set does Passive Open listen indicates to TCP readiness to receive connection requests for socket with given descriptor Parameter specifies max number of requests that may be queued while waiting for server to accept them listen call returns: 0 (success); or -1 (failure) 4

5 does Passive Open calls accept to accept incoming requests accept blocks if queue is empty does Active Open socket creates socket to connect to server specifies type: TCP (stream) socket call returns: non-negative integer descriptor; or -1 if unsuccessful 5

6 does Active Open connect establishes a connection on the local socket with the specified descriptor to the specified remote address and port # connect returns 0 if successful; -1 if unsuccessful Note: connect initiates TCP three-way handshake accept wakes with incoming connection request accept fills client address & port # into address structure accept call returns: descriptor of new connection socket (success); or -1 (failure) & server use new socket for data transfer Original socket continues to listen for new requests 6

7 Transfer or server call write to transmit data into a connected socket write specifies: socket descriptor; pointer to a buffer; amount of data; flags to control transmission behavior write call returns: # bytes transferred (success); or -1 (failure); blocks until all data transferred Transfer or server call read to receive data from a connected socket read specifies: socket descriptor; pointer to a buffer; amount of data read call returns: # bytes read (success); or -1 (failure); blocks if no data arrives Note: write and read can be called multiple times to transfer byte streams in both directions 7

8 ion Termination or server call close when socket is no longer needed close specifies the socket descriptor close call returns: 0 (success); or -1 (failure) Note: close initiates TCP graceful close sequence TCPEcho.java import java.net.socket; import java.net.socketexception; import java.io.ioexception; import java.io.inputstream; import java.io.outputstream; tst public class TCPEcho { public static void main(string[] args) throws IOException { if ((args.length < 2) (args.length > 3)) // Test for correct # of args throw new IllegalArgumentException("Parameter(s): <> <Word> [<Port>]"); String server = args[0]; // name or IP address // Convert argument String to bytes using the default character encoding byte[] data = args[1].getbytes(); int servport = (args.length == 3)? Integer.parseInt(args[2]) : 7; InputStream in = socket.getinputstream(); OutputStream out = socket.getoutputstream(); out.write(data); // Send the encoded string to the server // Receive the same string back from the server int totalbytesrcvd = 0; // Total bytes received so far int bytesrcvd; // Bytes received in last read while (totalbytesrcvd < data.length) { if ((bytesrcvd = in.read(data, totalbytesrcvd, data.length - totalbytesrcvd)) == -1) throw new SocketException("ion closed prematurely"); totalbytesrcvd += bytesrcvd; } // data array is full System.out.println("Received: " + new String(data)); socket.; // Close the socket and its streams } } // Create socket that is connected to server on specified port Socket socket = new Socket(server, servport); System.out.println("ed to server...sending echo string"); 8

9 TCPEcho.java Can communicate with an echo server named server.example.com with IP address in either of the following ways: Java TCPEcho server.example.com Echo this! Java TCPEcho Echo this! TCPEcho.java import java.net.*; // for Socket, Socket, and InetAddress import java.io.*; // for IOException and Input/OutputStream public class TCPEcho { private static final int BUFSIZE = 32; // Size of receive buffer public static void main(string[] args) throws IOException { if (args.length!= 1) // Test for correct # of args throw new IllegalArgumentException("Parameter(s): <Port>"); int servport = Integer.parseInt(args[0]); // Create a server socket to accept client connection requests Socket servsock = new Socket(servPort); int recvmsgsize; // Size of received message byte[] receivebuf = new byte[bufsize]; // Receive buffer InputStream in = clntsock.getinputstream(); OutputStream out = clntsock.getoutputstream(); // Receive until client closes connection, indicated by -1 return while ((recvmsgsize = in.read(receivebuf))!= -1) { out.write(receivebuf, 0, recvmsgsize); } // Close the socket. We are done with this client! clntsock.; } /* NOT REACHED */ } } while (true) { // Run forever, accepting and servicing connections Socket clntsock = servsock.; // Get client connection SocketAddress clientaddress = clntsock.getremotesocketaddress(); System.out.println("Handling client at " + clientaddress); 9

10 Less Mode until server receives data from client started socket creates socket of type UDP (datagram) socket call returns: descriptor; or -1 if unsuccessful bind assigns local address & port # to socket with specified descriptor; Can wildcard IP address Less Mode recvfrom copies bytes received in specified socket into a specified location recvfrom blocks until data arrives until server receives data from client 10

11 Less Mode started socket creates socket of type UDP (datagram) socket call returns: descriptor; or -1 if unsuccessful until server receives data from client Less Mode until server receives data from client started sendto transfer bytes in buffer to specified socket sendto specifies: socket descriptor; pointer to a buffer; amount of data; flags to control transmission behavior; destination address & port #; length of destination address structure sendto returns: # bytes sent; or -1 if unsuccessful 11

12 Less Mode until server receives data from client recvfrom wakes when data arrives recvfrom specifies: socket descriptor; pointer to a buffer to put data; max # bytes to put in buffer; control flags; copies: sender address & port #; length of sender address structure recvfrom returns # bytes received or -1 (failure) Note: receivefrom returns data from at most one send, i.e. from one datagram Less Mode Socket Close or server call close when socket is no longer needed close specifies the socket descriptor close call returns: 0 (success); or -1 (failure) until server receives data from client 12

13 UDP and See code in for this and many other programs using Java and sockets 13