Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Mail Systems
Eclipse Documentation

How To Guides
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Problem Solutions
Privacy Policy




Solution for
Programming Exercise 10.4

THIS PAGE DISCUSSES ONE POSSIBLE SOLUTION to the following exercise from this on-line Java textbook.

Exercise 10.4: For this exercise, you will write a network server program. The program is a simple file server that makes a collection of files available for transmission to clients. When the server starts up, it needs to know the name of the directory that contains the collection of files. This information can be provided as a command-line argument. You can assume that the directory contains only regular files (that is, it does not contain any sub-directories). You can also assume that all the files are text files.

When a client connects to the server, the server first reads a one-line command from the client. The command can be the string "index". In this case, the server responds by sending a list of names of all the files that are available on the server. Or the command can be of the form "get <file>", where <file> is a file name. The server checks whether the requested file actually exists. If so, it first sends the word "ok" as a message to the client. Then it sends the contents of the file and closes the connection. Otherwise, it sends the word "error" to the client and closes the connection.

Ideally, your server should start a separate thread to handle each connection request. However, if you don't want to deal with threads you can just call a subroutine to handle the request. See the DirectoryList example in Section 10.2 for help with the problem of getting the list of files in the directory.


The sample program shows the typical outline of a server program. For this exercise, the processing of each connection request is more complicated, but the basic outline of the program is the same.

My program begins by getting the directory name from the command line. An object of type File is created which can be used to check whether the specified directory exists and is in fact a directory rather than a regular file. This allows for some basic error checking before the server starts running:

     if (args.length == 0) {
        System.out.println("Usage:  java FileServer <directory>");
     directory = new File(args[0]);
     if ( ! directory.exists() ) {
        System.out.println("Specified directory does not exist.");
     if (! directory.isDirectory() ) {
        System.out.println("The specified file is not a directory.");

The File object is needed later, in any case, for reading the list of files in the directory.

The rest of the main() routine takes the typical form for a server program. A listening socket is established. Then the server accepts and processes connection requests in an infinite loop. In this case, the processing is done by creating a thread belonging to the class ConnectionHandler, which is a subclass of the standard class, Thread. The actual communication with the client is done in the run() method of this thread, which is executed in parallel with the main() routine and with any other ConnectionHandler threads that are created. This allows the server to process more than one client simultaneously. Since it can potentially take a long time to transmit a file, multithreading is very desirable in this example.

The run() method of the thread implements the communication protocol of the server in a straightforward way: It reads a line from the client. If the line is "index", it sends a list of available files. If the line starts with the string "get", it sends the requested file. Finally, it closes the connection. (In fact, the connection is closed in the finally clause of a try statement to make sure that the connection is closed before the thread terminates.) You should be able to follow all this in the solution that follows.

(My ConnectionHandler class is a static nested class inside the FileServer class. Nested classes were covered in Section 5.6. It's not essential in this example that the class be nested. It could easily be a separate class.)

The Solution

       This program is a very simple network file server.  The
       server has a list of available text files that can be
       downloaded by the client.  The client can also download
       the list of files.  When the connection is opened, the
       client sends one of two possible commands to the server:
       "index" or "get <file-name>".  The server replies to
       the first command by sending the list of available files.
       It responds to the second with a one-line message,
       either "ok" or "error".  If the message is "ok", it is
       followed by the contents of the file with the specified
       name.  The "error" message indicates that the specified
       file does not exist on the server. (The server can also
       respond with the message "unknown command" if the command
       it reads is not one of the two possible legal commands.)
       The server program requires a command-line parameter
       that specifies the directory that contains the files
       that the server can serve.  The files should all be
       text files, but this is not checked.  Also, the server
       must have permission to read all the files.
       This program uses the non-standard class, TextReader.
   public class FileServer {
      static final int LISTENING_PORT = 3210;
      public static void main(String[] args) {
         File directory;        // The directory from which the
                                //    gets the files that it serves.
         ServerSocket listener; // Listens for connection requests.
         Socket connection;     // A socket for communicating with
                                //                a client.
         /* Check that there is a command-line argument.
            If not, print a usage message and end. */
         if (args.length == 0) {
            System.out.println("Usage:  java FileServer <directory>");
         /* Get the directory name from the command line, and make
            it into a file object.  Check that the file exists and
            is in fact a directory. */
         directory = new File(args[0]);
         if ( ! directory.exists() ) {
            System.out.println("Specified directory does not exist.");
         if (! directory.isDirectory() ) {
            System.out.println("The specified file is not a directory.");
         /* Listen for connection requests from clients.  For
            each connection, create a separate Thread of type
            ConnectionHandler to process it.  The ConnectionHandler
            class is defined below.  The server runs until the
            program is terminated, for example by a CONTROL-C. */
         try {
            listener = new ServerSocket(LISTENING_PORT);
            System.out.println("Listening on port " + LISTENING_PORT);
            while (true) {
               connection = listener.accept();
               new ConnectionHandler(directory,connection);
         catch (Exception e) {
            System.out.println("Server shut down unexpectedly.");
            System.out.println("Error:  " + e);
      } // end main()
      static class ConnectionHandler extends Thread {
           // An object of this class is a thread that will
           // process the connection with one client.  The
           // thread starts itself in the constructor.
         File directory;       // The directory from which files are served
         Socket connection;    // A connection to the client.
         TextReader incoming;  // For reading data from the client.
         PrintWriter outgoing; // For transmitting data to the client.
         ConnectionHandler(File dir, Socket conn) {
               // Constructor.  Record the connection and
               // the directory and start the thread running.
            directory = dir;
            connection = conn;
         void sendIndex() throws Exception {
               // This is called by the run() method in response
               // to an "index" command.  Send the list of files
               // in the directory.
            String[] fileList = directory.list();
            for (int i = 0; i < fileList.length; i++)
            if (outgoing.checkError())
               throw new Exception("Error while transmitting data.");
         void sendFile(String fileName) throws Exception {
               // This is called by the run() command in response
               // to "get <fileName>" command.  If the file doesn't
               // exist, send the message "error".  Otherwise,
               // send the message "ok" followed by the contents
               // of the file.
            File file = new File(directory,fileName);
            if ( (! file.exists()) || file.isDirectory() ) {
                 // (Note:  Don't try to send a directory, which
                 // shouldn't be there anyway.)
            else {
               TextReader fileIn = new TextReader( new FileReader(file) );
               while (fileIn.peek() != '\0') {
                     // Read and send lines from the file until
                     // an end-of-file is encountered.
                  String line = fileIn.getln();
            if (outgoing.checkError())
               throw new Exception("Error while transmitting data.");
         public void run() {
               // This is the method that is executed by the thread.
               // It creates streams for communicating with the client,
               // reads a command from the client, and carries out that
               // command.  The connection is logged to standard output.
               // An output beginning with ERROR indicates that a network
               // error occurred.  A line beginning with OK means that
               // there was no network error, but does not imply that the
               // command from the client was a legal command.
            String command = "Command not read";
            try {
               incoming = new TextReader( connection.getInputStream() );
               outgoing = new PrintWriter( connection.getOutputStream() );
               command = incoming.getln();
               if (command.equals("index")) {
               else if (command.startsWith("get")){
                  String fileName = command.substring(3).trim();
               else {
                  outgoing.println("unknown command");
               System.out.println("OK    " + connection.getInetAddress()
                                           + " " + command);
            catch (Exception e) {
               System.out.println("ERROR " + connection.getInetAddress()
                                        + " " + command + " " + e);
            finally {
               try {
               catch (IOException e) {
      }  // end nested class ConnectionHandler
   } //end class FileServer

[ Exercises | Chapter Index | Main Index ]

  Published under free license. Design by Interspire