Info 408 Distributed Applications programming 2 nd semester of 2017/2018 Credits: 5 Lecturer: Dr. Antoun Yaacoub

Transcription

1 Lebanese University Faculty of Science I Master 1 degree Computer Science Info 408 Distributed Applications programming 2 nd semester of 2017/2018 Credits: 5 Lecturer: Dr. Antoun Yaacoub

2 Starting Network Programming in Java Chapter IV 2

3 Objectives 1. know how to determine the host machine's IP address via a Java program; 2. know how to use TCP sockets in both client programs and server programs; Core package java.net contains a number of very useful classes that allow programmers to carry out network programming very easily. 3

4 The InetAddress Class One of the classes within package java.net is called InetAddress, which handles Internet addresses both as host names and as IP addresses. Static method getbyname of this class uses DNS (Domain Name System) to return the Internet address of a specified host name as an InetAddress object. In order to display the IP address from this object, we can simply use method println (which will cause the object's tostring method to be executed). Since method getbyname throws the checked exception UnknownHostException if the host name is not recognized, we must either throw this exception or (preferably) handle it with a catch clause. 4

5 Example IPFinder.java 5

6 The InetAddress Class InetAddress has three static methods that return suitably initialized InetAddress objects given a little information. They are: public static InetAddress getbyname(string hostname) throws UnknownHostException public static InetAddress[] getallbyname(string hostname) throws UnknownHostException public static InetAddress getlocalhost( ) throws UnknownHostException These three methods have to go outside Java and the local system to get their work done. The other methods in this class, such as getaddress( ) and gethostname( ), mostly work with the information provided by one of these three methods. They do not make network connections; on the rare occasions that they do, they do not throw any exceptions. 6

7 public static InetAddress[ ] getallbyname(string hostname) throws UnknownHostException Some computers have more than one Internet address. Given a hostname, InetAddress.getAllByName() returns an array that contains all the addresses corresponding to that name. Its use is straightforward: InetAddress[] addresses = InetAddress.getAllByName(" Like InetAddress.getByName( ), InetAddress.getAllByName( ) can throw an UnknownHostException, so you need to enclose it in a try block or declare that your method throws UnknownHostException. 7

8 Example AllAddressesOfGoogle.java 8

9 public static InetAddress getlocalhost( ) throws UnknownHostException The InetAddress class contains one final means of getting an InetAddress object. The static method InetAddress.getLocalHost() returns the InetAddress of the machine on which it's running. Like InetAddress.getByName( ) and InetAddress.getAllByName( ), it throws an UnknownHostException when it can't find the address of the local machine (though this really shouldn't happen). Its use is straightforward: InetAddress me = InetAddress.getLocalHost( ); 9

10 Example MyLocalIPAddress.java 10

11 Getter Methods The InetAddress class contains three getter methods that return the hostname as a string and the IP address as both a string and a byte array: public String gethostname( ) public String gethostaddress( ) public byte[] getaddress( ) There are NO corresponding sethostname( ) and setaddress( ) methods. 11

12 public String gethostname( ) The gethostname( ) method returns a String that contains the name of the host with the IP address represented by this InetAddress object. For example: InetAddress machine = InetAddress.getLocalHost( ); String localhost = machine.gethostname( ); The gethostname( ) method is particularly useful when you're starting with a dotted quad IP address rather than the hostname. 12

13 Example ReverseTest.java 13

14 public String gethostaddress( ) The gethostaddress() method returns a string containing the dotted quad format of the IP address. 14

15 public byte[] getaddress( ) If you want to know the IP address of a machine (and you rarely do), getaddress( ) returns an IP address as an array of bytes in network byte order. The most significant byte (i.e., the first byte in the address's dotted quad form) is the first byte in the array, or element zero remember, Java array indices start with zero. The bytes returned are unsigned, which poses a problem. Unlike C, Java doesn't have an unsigned byte primitive data type. Bytes with values higher than 127 are treated as negative numbers. Therefore, if you want to do anything with the bytes returned by getaddress( ), you need to promote the bytes to ints and make appropriate adjustments. Here's one way to do it: int unsignedbyte = signedbyte < 0? signedbyte : signedbyte; One reason to look at the raw bytes of an IP address is to determine the type of the address. Test the number of bytes in the array returned by getaddress( ) to determine whether you're dealing with an IPv4 or IPv6 address. 15

16 Example AddressTests.java 16

17 TCP Sockets Chapter V 17

18 Using Sockets Different processes (programs) can communicate with each other across networks by means of sockets. Java implements both TCP/IP sockets and datagram sockets (UDP sockets). Very often, the two communicating processes will have a client/server relationship. Sockets allow the programmer to treat a network connection as just another stream onto which bytes can be written and from which bytes can be read. Sockets shield the programmer from low-level details of the network, such as error detection, packet sizes, packet retransmission, network addresses, and more. 18

19 Socket Basics A socket can perform seven basic operations: 1. Connect to a remote machine 2. Send data 3. Receive data 4. Close a connection 5. Bind to a port 6. Listen for incoming data 7. Accept connections from remote machines on the bound port Java's Socket class, which is used by both clients and servers, has methods that correspond to the first four of these operations. The last three operations are needed only by servers, which wait for clients to connect to them. 19

20 TCP Sockets A communication link created via TCP/IP sockets is a connection-oriented link. This means that the connection between server and client remains open throughout the duration of the dialogue between the two and is only broken (under normal circumstances) when one end of the dialogue formally terminates the exchanges (via an agreed protocol). Since there are two separate types of process involved (client and server), we shall examine them separately, taking the server first. 20

21 TCP Sockets Keyboard Monitor Input stream InFromUser Client process Server Welcome socket Server process Output stream OutToServer InFromServer Client TCP socket Input stream Output stream OutToClient InFromClient Server Connection socket Input stream To network From network To network From network 21

22 TCP Sockets Server Side Setting up a server process requires five steps Create a ServerSocket object. The ServerSocket constructor requires a port number ( , for nonreserved ones) as an argument. For example: ServerSocket servsock = new ServerSocket(1234); In this example, the server will await ('listen for') a connection from a client on port Put the server into a waiting state. The server waits indefinitely ('blocks') for a client to connect. It does this by calling method accept of class ServerSocket, which returns a Socket object when a connection is made. For example: Socket link = servsock.accept(); 22

23 TCP Sockets Server Side 3. Set up input and output streams. Methods getinputstream and getoutputstream of class Socket are used to get references to streams associated with the socket returned in step 2. These streams will be used for communication with the client that has just made connection. For a non-gui application, we can wrap a Scanner object around the InputStream object returned by method getinputstream, in order to obtain string-orientated input (just as we would do with input from the standard input stream, System.in). For example: Scanner InFromClient= new Scanner(link.getInputStream()); Similarly, we can wrap a PrintWriter object around the OutputStream object returned by method getoutputstream. Supplying the PrintWriter constructor with a second argument of true will cause the output buffer to be flushed for every call of println (which is usually desirable). For example: PrintWriter OutToclient= new PrintWriter(link.getOutputStream(),true); 23

24 TCP Sockets Server Side 4. Send and receive data. Having set up our Scanner and PrintWriter objects, sending and receiving data is very straightforward. We simply use method nextline for receiving data and method println for sending data, just as we might do for console I/O. For example: OutToClient.println("Awaiting data..."); String input = InFromClient.nextLine(); 5. Close the connection (after completion of the dialogue). This is achieved via method close of class Socket. For example: link.close(); 24

25 TCP Sockets Client Side Setting up the corresponding client involves four steps Establish a connection to the server. We create a Socket object, supplying its constructor with the following two arguments: the server's IP address (of type InetAddress); the appropriate port number for the service. (The port number for server and client programs must be the same, of course!) For simplicity's sake, we shall place client and server on the same host, which will allow us to retrieve the IP address by calling static method getlocalhost of class InetAddress. For example: Socket link = new Socket(InetAddress.getLocalHost(),1234); 25

26 TCP Sockets Client Side 2. Set up input and output streams. These are set up in exactly the same way as the server streams were set up (by calling methods getinputstream and getoutputstream of the Socket object that was created in step 2). 3. Send and receive data. The Scanner object at the client end will receive messages sent by the PrintWriter object at the server end, while the PrintWriter object at the client end will send messages that are received by the Scanner object at the server end (using methods nextline and println respectively). 4. Close the connection. This is exactly the same as for the server process (using method close of class Socket). 26

27 Example 1 TCPEchoServer_V1.java In this simple example, the server: will accept messages from the client and echo back each message. The main protocol for this service is that client and server must alternate between sending and receiving (with the client initiating the process with its opening message, of course). The client, of course, must wait for the final message from the server before closing the connection at its own end. 27

28 Example 1 TCPEchoServer_V1.java Since an IOException may be generated by any of the socket operations, ONE OR MORE try blocks MUST be used. Rather than have one large try block (with no variation in the error message produced and, consequently, no indication of precisely what operation caused the problem), it is probably good practice to have the opening of the port and the dialogue with the client in separate try blocks. It is also good practice to place the closing of the socket in a finally clause, so that, whether an exception occurs or not, the socket will be closed (unless, of course, the exception is generated when actually closing the socket, but there is nothing we can do about that). Since the finally clause will need to know about the Socket object, we shall have to declare this object within a scope that covers both the try block handling the dialogue and the finally block. Thus, step 2 shown above will be broken up into separate declaration and assignment. In our example program, this will also mean that the Socket object will have to be explicitly initialized to null (as it will not be a global variable). 28

29 Example 1 TCPEchoServer_V1.java Since a server offering a public service would keep running indefinitely, the call to method handleclient in our example has been placed inside an infinite loop, thus: 29

30 Example 1 TCPEchoServer_V1.java 30

31 31

32 Example 1 TCPEchoClient_V1.java The client program for our example is shown next. In addition to an input stream to accept messages from the server, our client program will need to set up an input stream (as another Scanner object) to accept user messages from the keyboard. 32

33 33

34 Example 1 34

35 Example 2 Modify the server process in order to echo back each message but in capital letters. 35

36 Example 3 Write the client and the server processes that implement the following ECHO protocol: The server must accepts ONLY 3 messages from a client. The server before echoing back each message converts the message to uppercase, appends the date and the number of each message as shown in the following screenshots: 36

37 Example 4 TCPEchoServer.java In this simple example, the server will accept messages from the client and will keep count of those messages, echoing back each (numbered) message. The main protocol for this service is that client and server must alternate between sending and receiving (with the client initiating the process with its opening message, of course). The only details that remain to be determined are the means of indicating when the dialogue is to cease and what final data (if any) should be sent by the server. For this simple example, the string "***CLOSE***" will be sent by the client when it wishes to close down the connection. When the server receives this message, it will confirm the number of preceding messages received and then close its connection to this client. The client, of course, must wait for the final message from the server before closing the connection at its own end. 37

38 38

39 39

40 The Socket Class The Constructors: public Socket(String host, int port) throws UnknownHostException, IOException public Socket(InetAddress host, int port) throws IOException Getting Information About a Socket public int getport( ) public int getlocalport( ) public InetAddress getlocaladdress( ) public InputStream getinputstream( ) throws IOException public OutputStream getoutputstream( ) throws IOException Closing the Socket public void close( ) throws IOException 40

41 The Socket Class It is true that a socket closes automatically when one of its two streams closes, when the program ends, or when it's garbage collected. However, it is a bad practice to assume that the system will close sockets for you, especially for programs that may run for an indefinite period of time. In a socket-intensive program like a web browser, the system may well hit its maximum number of open sockets before the garbage collector kicks in. 41

42 The ServerSocket Class The Constructors public ServerSocket(int port) throws BindException, IOException public ServerSocket(int port, int queuelength) throws BindException, IOException public ServerSocket(int port, int queuelength, InetAddress bindaddress) throws IOException public ServerSocket( ) throws IOException // Java 1.4 Accepting and Closing Connections public Socket accept( ) throws IOException public void close( ) throws IOException The get Methods public InetAddress getinetaddress( ) public int getlocalport( ) 42