Abstract

One of the most basic network programming tasks youll likely face as a Java programmer is performing socket functions. You may have to create a network client that talks to a server via a socket connection. Or, you may have to create a server that listens for socket connections. This report illustrates several examples on the two types of socket APIs: connectionless datagram sockets and connection-oriented stream-mode sockets. With datagram sockets, communication occurs in the form of discrete messages sent from the sender to receiver; whereas with streammode sockets, data is transferred using the concept of a continuous data stream flowing from a source to a destination. For both kinds of sockets, we illustrate examples for simplex (one-way) and duplex (bi-directional) communication. We also explain in detail the difference between a concurrent server and iterative server and show example programs on how to develop the two types of servers, along with an example. The last section of the report describes the Multicast Socket API in Java and illustrates examples for multicast communication

Introduction
Interprocess communication (IPC) is the backbone of distributed computing. Processes are runtime representations of a program. IPC refers to the ability for separate, independent processes to communicate among themselves to collaborate on a task. System Design goes through logical and physical stages of development. Logical reviews the present physics system, prepare input-output specification, detail implementation plan, a logical design walkthrough. The physical system maps out the details of the physical system, plans, the system implementation and specification of any hardware and software. System design is highly creative process, which can be greatly facilitated by the following stages: 1. Proper problem definition. 2. Set of requirements of the new system. 3. Overall design of the whole system

During analysis the focus is on what needs to be done, independent of how it is done. During design, decisions are made about how the problem will be solved, first at a high level, then at increasingly detailed level. System design is the first stage in which the basic approach to solving the problem is selected. During system design, the overall structure and style is decided. The System architecture is the overall organization of the system into components called sub-systems. The architecture provides the context in which more detailed decisions are made in later design stages. By making high level decisions that apply to the entire system, the system designer partitions the problem into sub-systems so that several designers working independently on different subsystems can do further work.

The system designer must make the following decisions: Organize the system into subsystem Strategy for data stores (Data structure)

Basic architecture for system

SYSTEM DESIGN
The whole FTP Client and Server application can be divided into following subsystems. Client UI- This subsystem should provide the complete User interface for the user to Download and Upload a file on the Server. So this subsystem again can be divided into following subsystems Defining protocol for data transfer: In this subsystem we define a simple protocol for data transfer from client to server and server to client. Networking of the clients: This subsystem is responsible for networking of the all the clients and multithreading of the application to avoid data corruption and inconsistency.

Identify concurrency inherent in the system: For handling this problem we have to make that function synchronized which modify on server data structure. For each user we have a different thread, which is maintaining list of operations and sending the operation to client one by one.

Notification of Server to Client: Whenever server is notifying any operation to Client. The operation is modifying data structure of Client in different thread so client needs not to stop his work when server is notifying any operation to client.

Notifying from client to server: Whenever client is notifying any operation to server thats going on in different thread.

Basic architecture for system: In this section we define basic architecture of implementation. Whole design of our application can be divided in two basic parts.

Architecture of FTPClient We use AWT for designing UI part of Client side.

Architecture of FTPServer (for making networked) We use socket programming for making our application networked. Javas Networking protocol: TCP/IP: Javas view of networking means TCP/IP. TCP/IP stands for Transmission-Control Protocol/ Internet Protocol, the two data communication protocols on which the Internet relies for all its functionality. In practice however, TCP/IP stands for a whole collection of related protocols, all based around TCP and IP.

IP: Whatever application protocol is used to implement some internet service, IP relies at the heart of all Internet data communications. IP is a datagram protocol, which means that transmitted packets of information (packets, for short) are not guaranteed to be delivered. IP packets also do not form part of a stream of related packets; IP is a connectionless protocol. Each IP packet travel on its own, like an individual letter in a postal network. An IP packet can be a maximum of 64KB long.

TCP: For Guaranteed delivery: Since IP packets are never guaranteed to arrive at their destination, a high level protocol, TCP is used to provide a basic service that does guarantee delivery. TCP manages this by using IP as a building block. Wherever IP is a datagram service, TCP presents a connection-oriented data stream service (like the telephone network). Before sending data via TCP, a computer needs to connect with the computer at the other end; only then can data be exchanged. Another difference is that the TCP protocol allows you to send or receive arbitrary amounts if data as one big stream of byte data. IP is theoretically limited to sending 65,536 byte packet, which would be insufficient for sending many files or even many large GIF images embedded in web pages. TCP solves this problem by breaking up the users data stream into separate IP packets, numbering them, and then reassembling them on arrival. This is the function of the sequence number and sequence acknowledges number fields. The most important TCP header fields, from users stand point are the source and destination port fields, while IP allows you to send an IP packet to an individual machine on the network.

TCP forces you to refine this addressing by adding some destination port address every machine that talks TCP/IP has 65,536 different TCP ports (or socket) it can talk through. A large collection of standard port numbers has been defined. Following table shows some port addresses for familiar Internet services. Port Name Echo Discard Daytime Qotd chargen ftp telnet Smtp Finger http Pop3 nntp Port No. 7 9 13 17 19 21 23 25 79 80 110 119 Service description Echoes whatever you send to it. Discards whatever you send it Produces destination machines local time Produce the quote of the day for that m/c. Produce a test stream of characters FTP port Telnet protocol port SMTP port Finger protocol port Web server port POP version 3 port NNTP port

Javas networking (Package java.net):

Java has very good features for TCP/IP based data transmission. Most of the classes used for network based data transmission are available in java.net package. Most useful classes of this package are given below:

DatagramPacket DatagramSocket InetAddress ServerSocket Socket

This class represents a datagram packet. This class represents a socket for sending and receiving datagram packets. This class represents an Internet Protocol (IP) address. This class implements server sockets. This class implements client sockets (also called just "sockets").

Identifying objects and classes:

FTPServer FTPClient

Graphical User Interface Formats

FTPClient:

Input dialog for Server Location

FTPCLIENT GUI

Download Save FileDialogBox

Upload File Selection DialogBox

Downloading In Progress.

10

FTPSERVER Console

11

Event Flow Diagram:

1. Send connection information.

2. Notify operation

FTP Client
Send connection confirmation to client

Other FTP Clients

Notification of operation

FTP Server

Event Flow Diagram

Identify Constraints:
Performance Constraints Speed in transferring data among various clients. Because data is getting shared among various clients, speed of data transfer must be fast enough.4KB data send at a time. Time Constraints The project should be completed in fifteen days time duration.

12

Object Design
Introduction: The analysis phase determines what the implementation must do and the system design phase determines the plan of attack. The object design phase determines the full definitions of the classes and associations used in the implementation, as well as the interfaces and algorithms of the methods used in the implementation of operations. The object design phase adds internal objects for implementation and optimizes data structure and algorithms. Object design is analogous to the preliminary design phase of the traditional software development life cycle. During object design the designer carries out the strategy chosen during system design and fleshes out the details. There is a shift in emphasis from application domain concepts towards computer concepts. The objects discovered during system design serve as the skeleton of the design but the object designer must choose among different ways to implement them with an eye towards minimizing execution time, memory and measure of costs. During object design approach of solution is given as the algorithm with decomposing the complex operations into simpler smaller internal operation. The classes, attributes, and associations from analysis must be implemented as specific data structures. New object must be introduced to store intermediate results during program execution and to avoid the need for re-computation. Optimization of the design should not be carried to excess, as ease of implementation; maintainability and extensibility are also important concerns. Steps of object design: Detailed design of User interface module Detailed design for network protocol Detailed design for classes

13

Detailed design for User Interface Module: This document intends to provide information about the user interface of the FTP Server & Client Application . The FTP application has two parts the client part and the server part. Using AWT we developed Client UI part. FTP Client side: Initializes its components like TextField for writing commands and display them. Initializes a Text area to show the command list. Two buttons to upload and download a file from the FTP Server. Makes a connection back to the FTP server from where it originated by opening a socket. 1. If the step 2 encounters a problem, then it displays the error message to the user and quits. 2. Else it starts a new thread that listens infinitely for the incoming commands. This application contains following visual elements: 1. A TextField for writing the commands. 2. Two button A upload button & second is download button. 3. A component TextArea at the center to display the entire coming commands with file name. FTP Server Side: Server Maintain all the incoming commands by the client and send the appropriate message according their commands. When server get a command Download to download and Upload to upload a file from the server or client then its open a new port on the client side to send the file data on end. This Project is designed on the actual FTP based protocol.

14

Documentation of JavaAPI
1. Input / Output in Java Streams:
Java programs perform I/O through streams. A stream in an abstraction that either produces or consumes information. A stream is linked to a physical device by the Java I/O system. All streams behave in the same manner, even if the actual physical devices to which they are linked differ. Thus, the same I/O classes and methods can be applied to any type of device. This means an input stream can abstract many different kinds of input from a disk file, a keyboard or a network socket. Likewise an output stream may refer to the console, a disk file, or a network connection. Streams are a clean way to deal with input/output without having every part of your code understand the difference between a keyboard and a network, for example. Java implements streams within class hierarchies defined in the java.io package.

Input and Output streams:

Java streams are classified into two basic types: normally input streams and output streams. An input stream extracts (i.e. reads) data from the source and sends it to the program. Source Input Stream (Reads) Program

(a) Reading Data into a program Similarly, an output stream takes data from the program and sends (i.o.writes) it to the destination. Program Output Stream (writes) Destination

(b) Writing data to a destination The program connects and opens an input stream on the data source and then reads the data serially. Similarly, the program connects and opens an output stream to the destination place of data and writes data out serially. In both the cases, the program does not know the details of end points (i.e. source and destination).

15

Byte Stream and Character Streams:

Java 2 defines two types of stream: Byte and Character. Byte streams provide a convenient means for handling input and output of bytes. Byte streams are used, for example, when reading or writing binary data. Character streams provide a convenient means for handling input and output of character. They use Unicode and therefore, can be internationalized. Also, in some cases, character streams are more efficient than byhte streams. The original version of Java (Java 1.0) did not include character streams and thus, all I/O was byte oriented. Character streams were added by Java 1.1 and certain byte oriented classes and methods were deprecated. One other point: at the lowest level, all I/O is still byte oriented. The character-based streams simply provide a convenient and efficient means for handling characters. These two groups may be further classified based on their purposes. Byte stream and Character stream classes contain specialized classes to deal with input and output operations independently on various tyupes of devices. We can also cross-group the streams based on the type of source or destination they read from or write to. The source (or destination) may be memory, a file or a pipe.

Methods of InputStream class: int available() Gives the number of bytes available in the input (must be overridden by the subclasses). void close() Closes this input stream and releases any system resources associated with the stream (Endorsing). mark(int readlimit) Marks the current position in this input stream.

void

boolean markSupported() Tests if this input stream supports the mark and reset methods. abstract read() int Reads the next byte of data from the input stream. int read(byte[] b) Reads some number of bytes from the input stream and stores them into the buffer array b. read(byte[] b, int off, int len) Reads up to len bytes of data from the input stream into an array of bytes. 16

int

void

reset() Repositions this stream to the position at the time the mark method was last called on this input stream.

skip(long n) Skips over and discards n bytes of data from this input stream. Note that the class DataInputStream extends FilterInputStream and implements the interface DataInput. Therefore, the DataInputStream class implements the methods described in DataInput in addition to using methods of InputStream class. The DataInput interface contains the following methods: boolean readBoolean() Reads one input byte and returns true if that byte is nonzero, false if that byte is zero. byte char readByte() Reads and returns one input byte. readChar() Reads an input char and returns the char value.

long

double readDouble() Reads eight input bytes and returns a double value. float void void int String long short String int readFloat() Reads four input bytes and returns a float value. readFully(byte[] b) Reads some bytes from an input stream and stores them into the buffer array b. readFully(byte[] b, Reads len bytes from an input stream. int off, int len)

readInt() Reads four input bytes and returns an int value. readLine() Reads the next line of text from the input stream. readLong() Reads eight input bytes and returns a long value. readShort() Reads two input bytes and returns a short value. readUTF() Reads in a string that has been encoded using a modified UTF-8 format. skipBytes(int n) Makes an attempt to skip over n bytes of data from the input stream, discarding the skipped bytes.

17

A FilterInputStream contains some other input stream which it uses as its basic source of data, possibly transforming the data along the way providing additional functionality. The class FilterInputStream itself simply overrides all methods of InputStream with versions that pass all requests to the contained input stream. Sub-classes of FilterInputStream may further override some of these methods and may also provide additional methods and fields.

Input stream classes summery: InputStream BufferedInputStream ByteArrayInputStream DataInputStream FileInputStream FilterInputStream This abstract class is the superclass of all classes representing an input stream of bytes. A BufferedInputStream adds functionality to another input streamnamely, the ability to buffer the input and to support the mark and reset methods. A ByteArrayInputStream contains an internal buffer that contains bytes that may be read from the stream. A data input stream lets an application read primitive Java data types from an underlying input stream in a machine-independent way. A FileInputStream obtains input bytes from a file in a file system. A FilterInputStream contains some other input stream, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality. A piped input stream should be connected to a piped output stream; the piped input stream then provides whatever data bytes are written to the piped output stream. A PushbackInputStream adds functionality to another input stream, namely the ability to "push back" or "unread" one byte. A SequenceInputStream represents the logical concatenation of other input streams. An ObjectInputStream deserializes primitive data and objects previously written using an ObjectOutputStream. Instances of this class support both reading and writing to a random access file.

PipedInputStream PushbackInputStream SequenceInputStream ObjectInputStream RandomAccessFile

18

Output Stream Classes: Output stream classes are derived from the base class OutputStream, which is an abstract class. The OutputStream includes methods that are designed to perform the following tasks: Writing bytes Closing streams Flushing streams

Methods of the OutputStream methods: void close() Closes this output stream and releases any system resources associated with this stream. void void void flush() Flushes this output stream and forces any buffered output bytes to be written out. write(byte[] b) Writes b.length bytes from the specified byte array to this output stream. write(byte[] b, int off, int len) Writes len bytes from the specified byte array starting at offset off to this output stream.

abstract write(int b) void Writes the specified byte to this output stream. The DataOutputStream is a counter part of DataInputStream, implements the DataOutput interface and therefore, implements the following methods contained in the DataOutput interface: void writeBoolean(boolean v) Writes a boolean value to this output stream. void writeByte(int v) Writes to the output stream the eight low- order bits of the argument v. void writeBytes(String s) Writes a string to the output stream. void writeChar(int v) Writes a char value, which is comprised of two bytes, to the output stream. void writeChars(String s) Writes every character in the string s, to the output stream, in order, two bytes per character. void writeDouble(double v) Writes a double value, which is comprised of eight bytes, to the output stream. void writeFloat(float v) Writes a float value, which is comprised of four bytes, to the output stream. void writeInt(int v) 19

Writes an int value, which is comprised of four bytes, to the output stream. void writeLong(long v) Writes a long value, which is comprised of eight bytes, to the output stream. void writeShort(int v) Writes two bytes to the output stream to represent the value of the argument. void writeUTF(String str) Writes two bytes of length information to the output stream, followed by the modified UTF-8 representation of every character in the string s.

Output Stream Classes Summery: This abstract class is the superclass of all classes representing an OutputStream output stream of bytes. BufferedOutputStream ByteArrayOutputStream DataOutputStream FileOutputStream The class implements a buffered output stream. This class implements an output stream in which the data is written into a byte array. A data output stream lets an application write primitive Java data types to an output stream in a portable way. A file output stream is an output stream for writing data to a File or to a FileDescriptor.

A piped output stream can be connected to a piped input stream to PipedOutputStream create a communications pipe. BufferedOutputStrea PrintStream A PrintStream adds functionality to another output stream, namely m the ability to print representations of various data values PrintStream DataOutputStream conveniently. RandomAccessFile Instances of this class support both reading and writing to a random access file. DataOutput

20

The Character stream classes:

Character streams are defined by using two class hierarchies. At the top are two abstract classes: Reader and Writer. These abstract classes handle Unicode character streams. The Java has several concrete subclasses of each of these. The abstract Reader and Writer classes define several key methods that the other stream classes implement. Two of the most important methods are read() and write(), which read and write characters of data, respectively. These methods are overridden by derived stream classes.

Reader stream classes:

Reader stream classes are designed to read character from the files. Reader class is the base class for all other classes in this group. These classes are functionally very similar to the input stream classes, except input streams use bytes as their fundamental unit of information, while reader streams use characters. The Reader class contains methods that are identical to those available in the InputStream class. Therefore, Reader classes can perform almost all the functions implemented by the input stream classes. Reader Stream Classes Summery: Abstract class for reading character streams. Read text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines. This class implements a character buffer that can be used as a characterinput stream. Convenience class for reading character files. Abstract class for reading filtered character streams. An InputStreamReader is a bridge from byte streams to character streams: It reads bytes and decodes them into characters using a specified charset. Piped character-input streams. A character-stream reader that allows characters to be pushed back into the stream. A character stream whose source is a string.

Reader BufferedReader CharArrayReader FileReader FilterReader InputStreamReader PipedReader PushbackReader StringReader

21

Writer Stream Class:

The writer class is an abstract class which acts as a base class for all the other write stream class. The base class provides support for all output operations by defining methods that are identical to those in OutputStream class.

Writer Stream classes summery: Abstract class for writing to character streams. Writer BufferedWriter CharArrayWriter FileWriter FilterWriter Write text to a character-output stream, buffering characters so as to provide for the efficient writing of single characters, arrays, and strings. This class implements a character buffer that can be used as an Writer. Convenience class for writing character files. Abstract class for writing filtered character streams.

An OutputStreamWriter is a bridge from character streams to byte OutputStreamWriter streams: Characters written to it are encoded into bytes using a specified charset. PipedWriter PrintWriter StringWriter Piped character-output streams. Print formatted representations of objects to a text-output stream. A character stream that collects its output in a string buffer, which can then be used to construct a string.

File:
Although most of the classes defined by java.io operate on streams, the File class does not. It deals directly with files and the file system. That is, the file class does not specify how information is retrieved form or stored in files. It describes the properties of a file itself. A File object is used to obtain or manipulate the information associated with a disk file, such as the permissions, time, date, and directory path, and to navigate sub-directory hierarchies. Although there are severe restrictions on their use within applets for security reasons, files are still a central resource for staring persistent and shared information. A directory in Java is treated simply as a file with one additional property- a list of filenames that can examined by the list() method. The following constructors can be used to create File objects: 22

File(String directoryPath) File(String directoryPath, String filename) File(File dirObj, String filename) File(URI uriObj)

Utility methods of File class: boolean renameTo(File newName) This method, renames the filename of the file corresponding to invoking file object to newName. It will return true upon success and false if the file cannot be renamed (if you either attempt to rename a file so that it moves from one directory to another or use an existing file, for example). boolean delete() This method deletes the disk file represented by the path of the invoking file object. You can also use delete() to delete a directory if the directory is empty. delete() returns true if it deletes the file and false if the file cannot be removed.
void DeleteOnExit()

Requests that the file or directory denoted by this abstract pathname be deleted when the virtual machine terminates.
boolean isHidden()

Returns true if the invoking file is hidden, otherwise returns false.

boolean setLastModified(long millisec)

Sets the time stamp on the invoking file to that specified by millisec, which is the no. of milli-seconds from January, 1970, Co-ordinated Universal Time (UTC).
boolean SetReadOnly()

Marks the file or directory named by this abstract pathname so that only read operations are allowed.

23

Java Networking

INTRODUCTION

This chapter explores the java.net package, which provides support for networking. Its creators have called Java Programming for the Internet. While true, there is actually very little in java, programming language, that makes it any more appropriate for writing Networked Programs than, say C++ or FORTRAN. What makes Java a good language for networking are the classes defined in the java.net package.

Socket Overview A network socket is a lot like an electrical socket. Various plugs around the network have a standard way of delivering their payload. Anything that understands the standard protocol can plug in to the socket and communicate. With electrical sockets, it doesnt matter if you plug in a lamp or a toaster; as long as they are expecting 50Hz, 220-volt electricity, the devices will work. Think how your electric bill is created. There is a meter somewhere between your house and the rest of the network. For each kilowatt of power that goes through that meter, you are billed. The bill comes to your address So even though the electricity flows freely around the power grid; all of the sockets in your house have a particular address.

The same idea applies to network sockets, except we talk about TCP/IP packets and IP addresses rather than electrons and street addresses. All the sockets have a specific IP address. But one machine can have many sockets and each socket needs to be identified uniquely. This is done with the help of port number. Each socket is associated with a unique port number.

Client/Server A Computer, which requests for some service from another computer, is called a client. The one that processes the request is called as server. A server waits till one of its clients makes a request. It can accept multiple connections at a time to the same port number. Multi-threading is used to 24

serve multiple users at the same time. The popular client-sever architecture is based on this approach. Reserved Sockets Once client is connected with the server, a higher level protocol follows, which is dependent on which port you are using. TCP/IP reserves the lower 1,024 ports for specific protocols. Many of these will seem familiar to you if you have spent any time surfing the Internet. Port number 21 is for FTP, 23 is for Telnet, 25 is for SMTP, 80 is for HTTP and the list goes on. It is up to each protocol to determine how a client should interact with the port. Internet Addressing Every computer on the Internet has a unique IP address. An IP address is a 32-bit number, which has four numbers separated by periods. It is possible to connect to the Internet either directly or through ISP (Internet Services Provider). For connecting directly to the Internet, the computer is assigned with a permanent IP address. In case connection is made using ISP, it assigns a temporary IP address for each Session. Domain Name Service (DNS) It is very difficult to remember a set of numbers (IP address) to connect to the Internet. The Domain Naming Service (DNS) is used to overcome this problem. It maps are particular IP address to a string of characters.

Just as the four numbers of an IP address describe a network hierarchy from left to right, the name of an Internet address, called its domain name, describe a machines location in a name space, from right to left. For example, www.microsoft.com is in the COM domain, it is called microsoft after the company name, and www is the name of the specific computer that is Microsofts web server.

25

Java and the Net (java.net package)

The InetAddress Class

Whether you are making a phone call, sending mail, or establishing a connection across the Internet, addresses are fundamental. The InetAddress class is used to encapsulate both the numerical IP address and the domain name for that address. You interact with this class by using the name of an IP host, which is more convenient and understandable than its IP address. The InetAddress class hides the number inside. Factory Methods The InetAddress class has no visible constructors. To create an InetAddress object, you have to use one of the available factory methods. Factory methods are merely a convention whereby static methods in a class return an instance of that class. This is done in lieu of overloading a constructor with various parameter lists when having unique method names makes the results much clearer. In the case of InetAddress the three static methods can be used to create instance of InetAddress. These methods are shown here: static InetAddress getLocalHost() throws UnknownHostException static InetAddress getByName(String hostName) throws UnknownHostException static InetAddress[] getAllByName(String hostName) throws UnknownHostException

Instance Methods boolean equals(Object other) Returns true if this object has the same Internet address as other. byte[] getAddress() Returns a four-element byte array that represents the objects Internet address in network byte order. String getHostAddress() 26

Returns a string that represent the host address associated with the InetAddress object. (eg 172.16.1.1) String getHostName() Returns a string that represents the host name associated with the InetAddress object. (eg everest.devnet.com) int hashCode() Returns the hashcode of the invoking object. String toString() Returns a string that lists the host name and the IP address for convenience Internet addresses are looked up in a series of hierarchically cached servers. That means that your local computer might know a particular name-to-IP-address mapping automatically, such as for itself and nearby servers. For other names, it may ask a local DNS server for IP address information. If that server doesnt have a particular address, it can go to a remote site and ask for it. This can continue all the way up to the root server, called InterNIC (internic.net). This process might take a long time, so it is wise to structure your code so that you cache IP address information locally rather than look it up repeatedly.

The URL Class URL stands for Uniform Resources Locator and it points to resource files on the Internet. The term Web is often used when there is a discussion about the Internet. The web is a collection of higher-level protocols and file formats. An important aspect of a web is its ability to locate files on the Internet. The URL helps in locating such files using their addresses on the net. Java provides URL class that provides an API to access information across the Internet. Components of URL 1. Protocol: HTTP, SMTP, FTP etc. 2. IP Address or the Host Name 3. Port Number 27

4. Actual File Path.

Constructors Javas URL class has several constructors and each can throw a MalformedURLException. URL (String urlSpecifier) URL (String protocolName, String hostname, int port, String path) URL (String protocolName, String hostname, String path)

Methods String getProtocol() String getHost() String getFile() String toExternalForm() int getPort() InputStream openStream() URLConnection openConnection()

TCP Based Classes:

The TCP protocol is not symmetrical like UDP protocol. It uses two types of sockets: Client Socket on the client side and Server Socket on the server side.

Client socket performs the following basic operations: Connecting to a remote machine/server (i.e. preparing to send or receive data) Send data Receive data Close a Connection

The Java Socket class which is used by both client and server has methods that correspond to the above four operations. 28

Server socket performs the following basic operations: Binding to a port Listening for incoming data Accept connections from remote machines/clients on the bound port.

The Java ServerSocket class which is used by the server has methods that correspond to above three operations.

The Socket Class

This class represents the client socket. Client sockets are normally used in the following fashion: The new Socket is created using a Socket() Constructor. The Socket attempts to connect to a remote host. Once the connection is established the local and remote hosts get input and output streams from the socket and use those streams to send data to each other. This connection is full duplex; both hosts can send and/or receive data simultaneously. When the transmission of data is complete, one or both sides close the connection.

Constructors public Socket (String host, int port) throws IOException, UnknownHostException public Socket(InetAddress host, int port) throws IOException, UnknownHostException public Socket(String host, int port, InetAddress interface, int localport) throws IOException, UnknownHostException public Socket(InetAddress host, int port, InetAddress interface, int localport) throws IOException, UnknownHostException Methods public InetAddress getInetAddress() public int getPort() 29

public int getLocalPort() public InetAddress getLocalAddress() InputStream getInputStream() OutputStream getOutputStream() public String toString()

The ServerSocket Class Java provides a ServerSocket class to allow you to write servers. Basically a server sockets job is to sit by the phone and wait for incoming calls. Each ServerSocket listens on a particular port on the local host. When a client socket on a remote host attempts to connect to that port, the server wakes up, negotiates the connection between the client & the server and opens a regular socket between two hosts. Server Socket waits for connection while client sockets initiate connections. Once the server socket has setup the connection, the server uses a regular socket to send data to the client. Data always travels over the regular socket. The Basic Life Cycle of a Server 1. A new ServerSocket is created on a particular port using a ServerSocket constructor. 2. The ServerSocket listens for incoming connection attempts on that port using its accept() method. The accept() method blocks until a client attempts to make a connection at which point accept() returns a socket object that connects the client to server. 3. Depending on the type of server either the sockets getInputStream() method, or getOutputStream() method or both are called to get input and output streams that communicates with the client. 4. The server and the client interact according to an agreed upon protocol until it is time to close the Connection.

30

5. The server, the client or both, close the connection. 6. The server returns to step 2 and waits for next connection.

In Java, you should use a thread to interact with the client so that the server can be ready to process the next cnnection sooner. Threads place far smaller loads on the server than a complete child process.

The O.S Stores incoming connections addressed to a particular port in a first-in first-out (FIFO) queue. The default length of the queue is normally 50 through this can very from OS to OS.

Several ServerSocket constructors allow you to change the length of the queue if its default length is not large enough; however you want be able to increase the queue beyond the maximum size that your OS supports.

Constructors public ServerSocket(int port) throws IOException, BindException public ServerSocket(int port, int queuelength) throws IOException, BindException public ServerSocket(int port, int queuelength, InetAddress bindAddress) throws IOException, BindException

Methods

public Socket accept() When your setup is done, and you are ready to accept a connection, call the ServerSockets accept() method. This method blocks; it stops the flow of execution and waits until a client connects.

31

When a client does connect, the accept() method return a Socket object. You use the streams returned by this Sockets getInputStream() and getOutputStream() methods to communicate with the client. public void close() throws IOException This method is used to close the Connection. public InetAddress getInetAddress() Returns the InetAddress object of the host on which ServerSocket is created. public int getLocalPort() Returns the port number on which the ServerSocket is listening for incoming requests.

32

References:
Complete Reference by Herbert Schildt. Java Programming by James Gosling. Various Sites related to Networking.

33