BindServer.java

/*
 * Copyright (c) 2001, 2018, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package nsk.share.jpda;

import java.io.*;
import java.net.*;
import java.util.*;

import nsk.share.*;
import nsk.share.jpda.*;

/**
 * <code>BindServer</code> is an utility to perform JPDA tests
 * in remote mode across network.
 * <p>
 * This utility should be started on remote host. It listens for connection
 * from JPDA tests and launches debuggee VM on this host.
 * <p>
 * <code>BindServer</code> works together with <code>Binder</code> used in
 * the tests to incapsulate actions required for launching debuggee VM.
 * See <code>ProcessBinder</code> and <code>DebugeeArgumentHandler</code>
 * to know how run tests in local or remote mode across network or
 * on an single host.
 * <p>
 * <code>BindServer</code> is started on the debuggee host.
 * It recognizes following command line options:
 * <ul>
 *   <li><code>-bind.file=<i>filename</i></code> - configuration file
 *   <li><code>-verbose</code> - print verbose messages
 * </ul>
 * <p>
 * Only required option is <code>-bind.file</code>, which points to the file
 * where pairs of particular pathes are presented as they are seen from
 * both hosts along with some other <code>BindServer</code> options.
 * See <i>execution.html</i> to read more about format of bind-file.
 *
 * @see DebugeeBinder
 * @see DebugeeArgumentHandler
 */
public class BindServer implements Finalizable {

    /** Version of <code>BindServer</code> implementation. */
    public static final long VERSION = 2;

    /** Timeout in milliseconds used for waiting for inner threads. */
    private static long THREAD_TIMEOUT = DebugeeBinder.THREAD_TIMEOUT;      // milliseconds

    private static int PASSED = 0;
    private static int FAILED = 2;
    private static int JCK_BASE = 95;

    private static int TRACE_LEVEL_PACKETS = 10;
    private static int TRACE_LEVEL_THREADS = 20;
    private static int TRACE_LEVEL_ACTIONS = 30;
    private static int TRACE_LEVEL_SOCKETS = 40;
    private static int TRACE_LEVEL_IO = 50;

    private static String pathSeparator = System.getProperty("path.separator");
    private static String fileSeparator = System.getProperty("file.separator");

    private static char pathSeparatorChar = pathSeparator.charAt(0);
    private static char fileSeparatorChar = fileSeparator.charAt(0);

    private static Log log = null;
    private static Log.Logger logger = null;
    private static ArgumentHandler argHandler = null;

    private static String pathConvertions[][] = null;

    private ListeningThread listeningThread = null;

    private int totalRequests = 0;
    private int acceptedRequests = 0;
    private int unauthorizedRequests = 0;
    private int busyRequests = 0;

    /**
     * Start <code>BindServer</code> utility from command line.
     * This method invokes <code>run()</code> and redirects output
     * to <code>System.err</code>.
     *
     * @param argv list of command line arguments
     */
    public static void main (String argv[]) {
        System.exit(run(argv,System.err) + JCK_BASE);
    }

    /**
     * Start <code>BindServer</code> utility from JCK-compatible
     * environment.
     *
     * @param argv list of command line arguments
     * @param out outpur stream for log messages
     *
     * @return FAILED if error occured
     *         PASSED oterwise
     */
    public static int run(String argv[], PrintStream out) {
        return new BindServer().runIt(argv, out);
    }

    /**
     * Perform execution of <code>BindServer</code>.
     * This method handles command line arguments, starts seperate
     * thread for listening connection from test on remote host,
     * and waits for command "exit" from a user.
     * Finally it closes all conections and prints connections
     * statiscs.
     *
     * @param argv list of command line arguments
     * @param out outpur stream for log messages
     *
     * @return FAILED if error occured
     *         PASSED oterwise
     */
    private int runIt(String argv[], PrintStream out) {
        try {
            argHandler = new ArgumentHandler(argv);
        } catch (ArgumentHandler.BadOption e) {
            out.println("ERROR: " + e.getMessage());
            return FAILED;
        }

        if (argHandler.getArguments().length > 0) {
            out.println("ERROR: " + "Too many positional arguments in command line");
            return FAILED;
        }

        log = new Log(out, argHandler);
        log.enableErrorsSummary(false);
        log.enableVerboseOnError(false);
        logger = new Log.Logger(log, "");

        Finalizer bindFinalizer = new Finalizer(this);
        bindFinalizer.activate();

        logger.trace(TRACE_LEVEL_THREADS, "BindServer: starting main thread");

        logger.display("Listening to port: " + argHandler.getBindPortNumber());
        logger.display("Authorizing host: " + argHandler.getDebuggerHost());

        pathConvertions = new String[][] {
            { "TESTED_JAVA_HOME", argHandler.getDebuggerJavaHome(), argHandler.getDebugeeJavaHome() },
            { "TESTBASE", argHandler.getDebuggerTestbase(), argHandler.getDebugeeTestbase() },
            { "WORKDIR", argHandler.getDebuggerWorkDir(), argHandler.getDebugeeWorkDir() }
        };

        logger.display("Translating pathes:");
        for (int i = 0; i < pathConvertions.length; i++) {
            logger.display(pathConvertions[i][0] + ":" +"\n"
                         + "  " + pathConvertions[i][1] + "\n"
                         + "  =>" + "\n"
                         + "  " + pathConvertions[i][2]);
        }

        String windir = argHandler.getDebugeeWinDir();
        if (!(windir == null || windir.equals(""))) {
            logger.display("Using WINDIR: \n"
                         + "  " + argHandler.getDebugeeWinDir());
        }

        BufferedReader stdIn = new BufferedReader(
            new InputStreamReader(System.in));

        listeningThread = new ListeningThread(this);
        listeningThread.bind();
        listeningThread.start();

        System.out.println("\n"
                          + "BindServer started" + "\n"
                          + "Type \"exit\" to shut down BindServer"
                          + "\n");

        for (;;) {
            try {
                String userInput = stdIn.readLine();
                if (userInput == null || userInput.equals("exit")
                        || userInput.equals("quit")) {
                    logger.display("Shutting down BindServer");
                    stdIn.close();
                    stdIn = null;
                    break;
                } else if (userInput.trim().equals("")) {
                    continue;
                } else {
                    System.out.println("ERROR: Unknown command: " + userInput);
                }
            } catch(IOException e) {
                e.printStackTrace(log.getOutStream());
                throw new Failure("Caught exception while reading console command:\n\t"
                                    + e);
            }
        }

        printSummary(System.out);

        logger.trace(TRACE_LEVEL_THREADS, "BindServer: exiting main thread");
        try {
            finalize();
        } catch (Throwable e) {
            e.printStackTrace(log.getOutStream());
            logger.complain("Caught exception while finalization of BindServer:\n\t" + e);
        }

        return PASSED;
    }

    /**
     * Print usefull summary statistics about connections occured.
     *
     * @param out output stream for printing statistics
     */
    private void printSummary(PrintStream out) {
        out.println("\n"
                + "Connections summary:" + "\n"
                + "  Tolal connections:     " + totalRequests + "\n"
                + "  Accepted authorized:   " + acceptedRequests + "\n"
                + "  Rejected unauthorized  " + unauthorizedRequests + "\n"
                + "  Rejected being busy:   " + busyRequests + "\n");
    };

    /**
     * Check if given <code>path</code> starts with the specified prefix taking
     * into account difference between <code>slashChar<code> used in <code>path</code>
     * and <code>fileSeparatorChar</code> used in <code>prefix</code>.
     *
     * @param path path to check
     * @param prefix prefix to compare with
     * @param slashChar file separator used in <code>path</code>
     */
    private static boolean checkPathPrefix(String path, String prefix, char slashChar) {
        int prefixLength = prefix.length();
        if (prefixLength > path.length()) {
            return false;
        }
        for (int i = 0; i < prefixLength; i++) {
            char pathChar = path.charAt(i);
            char prefixChar = prefix.charAt(i);

            if (pathChar != prefixChar) {
                if ((pathChar == slashChar || pathChar == fileSeparatorChar
                         || pathChar == '\\' || pathChar == '/')
                    && (prefixChar == slashChar || prefixChar == fileSeparatorChar
                         || prefixChar == '\\' || prefixChar == '/')) {
                    // do nothing
                } else {
                    return false;
                }
            }
        }
        return true;
    }

    /**
     * Convert given path according to list of prefixes from
     * <code>pathConvertions</code> table.
     *
     * @param path path for converting
     * @param slash file separator used in <code>path</code>
     * @param name path identifier used for error messages
     * @param strict force throwing Failure if path is not matched
     *
     * @return string with the converted path
     *
     * @throws Failure if path does not matched for translation
     */
    private static String convertPath(String path, String slash, String name, boolean strict) {
        if (path == null)
            return null;

        char slashChar = slash.charAt(0);

        for (int i = 0; i < pathConvertions.length; i++) {
            String from = pathConvertions[i][1];
            String to = pathConvertions[i][2];
            if (checkPathPrefix(path, from, slashChar)) {
                return (to + path.substring(from.length())).replace(slashChar, fileSeparatorChar);
            }
        }
        if (strict) {
            throw new Failure("Path not matched for translation " + name + ":\n\t" + path);
        }
        return path;
    }

    /**
     * Convert given list of pathes according to list of prefixes from
     * <code>pathConvertions</code> table by invoking <code>convertPath()</code>
     * for each path from the list.
     *
     * @param list list of pathes for converting
     * @param slash file separator used in pathes
     * @param name path identifier used for error messages
     * @param strict force throwing Failure if some path is not matched
     *
     * @return list of strings with converted pathes
     *
     * @throws Failure if some path does not matched for translation
     *
     * @see #convertPath()
     */
    private static String[] convertPathes(String[] list, String slash, String name, boolean strict) {
        String[] converted = new String[list.length];
        for (int i = 0; i < list.length; i++) {
            converted[i] = convertPath(list[i], slash, name, strict);
        }
        return converted;
    }

    /**
     * Pause current thread for specified amount of time in milliseconds,
     * This method uses <code>Object.wait(long)</code> method as a reliable
     * method which prevents whole VM from suspending.
     *
     * @param millisecs - amount of time in milliseconds
     */
    private static void sleeping(int millisecs) {
        Object obj = new Object();

        synchronized(obj) {
            try {
                obj.wait(millisecs);
            } catch (InterruptedException e) {
                e.printStackTrace(log.getOutStream());
                new Failure("Thread interrupted while sleeping:\n\t" + e);
            }
        }
    }

    /**
     * Wait for given thread finished for specified timeout or
     * interrupt this thread if not finished.
     *
     * @param thr thread to wait for
     * @param millisecs timeout in milliseconds
     */
    private static void waitInterruptThread(Thread thr, long millisecs) {
        if (thr != null) {
            String name = thr.getName();
            try {
                if (thr.isAlive()) {
                    logger.trace(TRACE_LEVEL_THREADS, "Waiting for thread: " + name);
                    thr.join(millisecs);
                }
            } catch (InterruptedException e) {
                e.printStackTrace(log.getOutStream());
                throw new Failure ("Thread interrupted while waiting for another thread:\n\t"
                                     + e);
            } finally {
                if (thr.isAlive()) {
                    logger.trace(TRACE_LEVEL_THREADS, "Interrupting not finished thread: " + name);
                    thr.interrupt();
/*
                    logger.display("Stopping not finished thread: " + thr);
                    thr.stop();
 */
                }
            }
        }
    }

    /**
     * Wait for given thread finished for default timeout
     * <code>THREAD_TIMEOUT</code> and
     * interrupt this thread if not finished.
     *
     * @param thr thread to wait for
     */
    private static void waitInterruptThread(Thread thr) {
        waitInterruptThread(thr, THREAD_TIMEOUT);
    }

    /**
     * Close <code>BindServer</code> by finishing all threads and closing
     * all conections.
     */
    public synchronized void close() {
        if (listeningThread != null) {
            listeningThread.close();
            listeningThread = null;
        }
    }

    /**
     * Make finalization of <code>BindServer</code> object by invoking
     * method <code>close()</code>.
     *
     * @see #close()
     */
    protected void finalize() throws Throwable {
        close();
        super.finalize();
    }

    /**
     * Make finalization of <code>BindServer</code> object at program exit
     * by invoking method <code>finalize()</code>.
     *
     * @see #finalize()
     */
    public void finalizeAtExit() throws Throwable {
        finalize();
        logger.trace(TRACE_LEVEL_THREADS, "BindServer: finalization at exit completed");
    }

///////// Thread listening a TCP/IP socket //////////

    /**
     * An inner thread used for listening connection from remote test
     * and starting separate serving thread for each accepted connection.
     *
     * @see ServingThread
     */
    private static class ListeningThread extends Thread {
        private volatile boolean shouldStop = false;
        private volatile boolean closed = false;

        private BindServer owner = null;
        private volatile ServingThread servingThread = null;
        private volatile int taskCount = 0;

        private ObjectOutputStream socOut = null;
        private ObjectInputStream socIn = null;

        private String autorizedHostName = argHandler.getDebuggerHost();
        private InetAddress autorizedInetAddresses[] = null;
        private int port = argHandler.getBindPortNumber();
        private Socket socket = null;
        private ServerSocket serverSocket = null;
        private InetAddress clientInetAddr = null;
        private String clientHostName = null;
        private SocketConnection connection = null;

        /**
         * Make listening thread for given <code>BindServer</code> object
         * as an owner and bind it to listening port by invoking method
         * <code>bind()</code>.
         *
         * @see bind()
         */
        public ListeningThread(BindServer owner) {
            super("ListeningThread");
            this.owner = owner;
            try {
                autorizedInetAddresses = InetAddress.getAllByName(autorizedHostName);
            } catch (UnknownHostException e) {
                e.printStackTrace(log.getOutStream());
                throw new Failure("Cannot resolve DEBUGGER_HOST value: " + autorizedHostName);
            }
        }

        /**
         * Bind ServerSocket to the specified port.
         */
        public void bind() {
            for (int i = 0; !shouldStop && i < DebugeeBinder.CONNECT_TRIES; i++) {
                try {
                    logger.trace(TRACE_LEVEL_SOCKETS, "ListeningThread: binding to server socket ...");
                    // length of the queue = 2
                    serverSocket = new ServerSocket(port, 2);
                    // timeout for the ServerSocket.accept()
                    serverSocket.setSoTimeout(DebugeeBinder.CONNECT_TRY_DELAY);
                    logger.trace(TRACE_LEVEL_SOCKETS, "ListeningThread: socket bound: " + serverSocket);
                    logger.display("Bound to listening port");
                    return;
                } catch (BindException e) {
                    logger.display("Socket binding try #" + i + " failed:\n\t" + e);
                    sleeping(DebugeeBinder.CONNECT_TRY_DELAY);
                } catch (IOException e) {
                    e.printStackTrace(log.getOutStream());
                    throw new Failure("Caught exception while binding to socket:\n\t"
                                    + e);
                }
            }
            throw new Failure("Unable to bind to socket after "
                + DebugeeBinder.CONNECT_TRIES + " tries");
        }

        /**
         * Accept socket connection from authorized remote host and
         * start separate <code>SrvingThread</code> to handle each connection.
         * Connection from unauthorized hosts or connections made while
         * current connection is alive are rejected.
         *
         * @see ServingThread
         * @see #llowConnection()
         * @see allowServing()
         */
        public void run() {
            String reply = null;

            logger.trace(TRACE_LEVEL_THREADS, "ListeningThread: started");
            logger.display("Listening for connection from remote host");
            while(!(shouldStop || isInterrupted())) {
                try {
                    try {
                        logger.trace(TRACE_LEVEL_SOCKETS, "ListeningThread: waiting for connection from test");
                        socket = serverSocket.accept();
                        logger.trace(TRACE_LEVEL_SOCKETS, "ListeningThread: connection accepted");
                    } catch(InterruptedIOException e) {
//                        logger.trace(TRACE_LEVEL_SOCKETS, "ListeningThread: timeout of waiting for connection from test");
                        continue;
                    }
                    owner.totalRequests++;
                    logger.display("");
                    clientInetAddr = socket.getInetAddress();
                    clientHostName = clientInetAddr.getHostName();
                    logger.display("Connection #" + owner.totalRequests
                                    + " requested from host: " + clientHostName);
                    connection = new SocketConnection(logger, "BindServer");
//                    connection.setPingTimeout(DebugeeBinder.PING_TIMEOUT);
                    connection.setSocket(socket);
                    socket = null;
                    if (allowConnection()) {
                        if (allowServing()) {
                            owner.acceptedRequests++;
                            reply = "host authorized: " + clientHostName;
                            logger.display("Accepting connection #" + owner.acceptedRequests
                                            + ": " + reply);
                            servingThread = new ServingThread(this, connection);
                            servingThread.start();
                            cleanHostConnection();
                        } else {
                            owner.busyRequests++;
                            reply = "BindServer is busy";
                            logger.complain("Rejecting connection #" + owner.busyRequests
                                            + ": " + reply);
                            connection.writeObject(new RequestFailed(reply));
                            closeHostConnection();
                        }
                    } else {
                        owner.unauthorizedRequests++;
                        reply = "host unauthorized: " + clientHostName;
                        logger.complain("Rejecting connection #" + owner.unauthorizedRequests
                                            + ": " + reply);
                        connection.writeObject(new RequestFailed(reply));
                        closeHostConnection();
                    }
                } catch (Exception e) {
                    logger.complain("Caught exception while accepting connection:\n" + e);
                    e.printStackTrace(log.getOutStream());
                }
            }
            logger.trace(TRACE_LEVEL_THREADS, "ListeningThread: exiting");
            closeConnection();
        }

        /**
         * Check if the connection made is from authorized host.
         *
         * @return true if connection is allowed because host authorized
         *         false if connection is rejected because host unauthorized
         */
        private boolean allowConnection() {
            // check if local host from loopback address
            if (autorizedHostName.equals("localhost"))
                return clientInetAddr.isLoopbackAddress();

            // check if equal hostname
            if (autorizedHostName.equals(clientHostName))
                return true;

            // check if equal host address
            for (int i = 0; i < autorizedInetAddresses.length; i++) {
                if (clientInetAddr.equals(autorizedInetAddresses[i])) {
                    return true;
                }
            }
            return false;
        }

        /**
         * Check if no current connection exists or it is dead.
         * If current connection presents it will be tested by pinging
         * remote host and aborted if host sends no reply. If an alive
         * connection exists, new connection will be rejected.
         *
         * @return true if no alive connection exists
         *         false otherwise
         */
        private boolean allowServing() {
            if (servingThread == null) {
                return true;
            }
            if (servingThread.done) {
                return true;
            }
            if (!servingThread.isConnectionAlive()) {
                logger.display("# WARNING: Previous connection from remote host is dead: aborting connection");
                servingThread.close();
                servingThread = null;
                return true;
            }

/*
            logger.complain("Previous connection from remote host is alive: starting new connection");
            servingThread = null;
            return true;
 */
            logger.complain("Previous connection from remote host is alive: reject new connection");
            return false;
        }

        /**
         * Wait for this thread finished
         * for specified timeout or interrupt it.
         *
         * @param millis timeout in milliseconds
         */
        public void waitForThread(long millis) {
            shouldStop = true;
            waitInterruptThread(this, millis);
        }

        /**
         * Close socket connection from remote host.
         */
        private void closeHostConnection() {
            if (connection != null) {
                connection.close();
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    logger.complain("Caught IOException while closing socket:\n\t"
                                    + e);
                }
                socket = null;
            }
        }

        /**
         * Assign <null> to connection and socket objects
         * but do not close them.
         */
        private void cleanHostConnection() {
            connection = null;
            socket = null;
        }

        /**
         * Close all connections and sockets.
         */
        private void closeConnection() {
            closeHostConnection();
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    logger.complain("Caught IOException while closing ServerSocket:\n\t"
                                    + e);
                }
                serverSocket = null;
            }
        }

        /**
         * Close thread by closing all connections and waiting
         * foor thread finished.
         *
         * @see #closeConnection()
         */
        public synchronized void close() {
            if (closed) {
                return;
            }
            closeHostConnection();
            if (servingThread != null) {
                servingThread.close();
                servingThread = null;
            }
            waitForThread(THREAD_TIMEOUT);
            closeConnection();
            closed = true;
            logger.trace(TRACE_LEVEL_THREADS, "ListeningThread closed");
        }

    } // ListeningThread

///////// Thread working with a communication channel //////////

    /**
     * An internal thread for handling each connection from a test
     * on remote host. It reads requests from test and starts separate
     * <code>LaunchingThread</code> to execute each request.
     *
     * @see LaunchingThread
     */
    private static class ServingThread extends Thread {
        private volatile boolean shouldStop = false;
        private volatile boolean closed = false;
        private volatile boolean done = false;

        private ListeningThread owner = null;
        private LaunchingThread launchingThread = null;

        private SocketConnection connection = null;

        /**
         * Make serving thread with specified input/output connection streams
         * and given <code>Listenerthread</code> as an owner.
         *
         * @param owner owner of this thread
         * @param connection established socket connection with test
         */
        public ServingThread(ListeningThread owner, SocketConnection connection) {
            super("ServingThread");
            this.owner = owner;
            this.connection = connection;
        }

        /**
         * Read requests from socket connection and start <code>LaunchingThread</code>
         * to perform each requested action.
         */
        public void run() {
            logger.trace(TRACE_LEVEL_THREADS, "ServingThread: starting handling requests from debugger");
            try {
                // sending OK(version)
                logger.trace(TRACE_LEVEL_ACTIONS, "ServingThread: sending initial OK(VERSION) to debugger");
                connection.writeObject(new OK(VERSION));

                // receiving TaskID(id)
                logger.trace(TRACE_LEVEL_IO, "ServingThread: waiting for TaskID from debugger");
                Object taskID = connection.readObject();
                logger.trace(TRACE_LEVEL_IO, "ServingThread: received TaskID from debugger: " + taskID);
                if (taskID instanceof TaskID) {
                    String id = ((TaskID)taskID).id;
                    owner.taskCount++;
                    logger.println("[" + owner.taskCount + "/" + owner.owner.totalRequests + "]: " + id);
                } else {
                    throw new Failure("Unexpected TaskID received form debugger: " + taskID);
                }

                // starting launching thread
                launchingThread = new LaunchingThread(this, connection);
                launchingThread.start();

                // receiving and handling requests
                while(!(shouldStop || isInterrupted())) {
                    logger.trace(TRACE_LEVEL_IO, "ServingThread: waiting for request from debugger");
                    Object request = connection.readObject();
                    logger.trace(TRACE_LEVEL_IO, "ServingThread: received request from debugger: " + request);
                    if (request == null) {
                        logger.display("Connection closed");
                        break;
                    } else if (request instanceof Disconnect) {
                        logger.display("Closing connection by request");
                        request = null;
                        break;
                    } else {
                        boolean success = false;
                        long timeToFinish = System.currentTimeMillis() + THREAD_TIMEOUT;
                        while (System.currentTimeMillis() < timeToFinish) {
                            if (launchingThread.doneRequest()) {
                                success = true;
                                logger.trace(TRACE_LEVEL_ACTIONS, "ServingThread: asking launching thread to handle request: " + request);
                                launchingThread.handleRequest(request);
                                break;
                            }
                            try {
                                launchingThread.join(DebugeeBinder.TRY_DELAY);
                            } catch (InterruptedException e) {
                                throw new Failure("ServingThread interrupted while waiting for LaunchingThread:\n\t"
                                                + e);
                            }
                        }
                        if (!success) {
                            logger.complain("Rejecting request because of being busy:\n" + request);
                            connection.writeObject(
                                new RequestFailed("Busy with handling previous request"));
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace(log.getOutStream());
                logger.complain("Caught exception while handling request:\n\t" + e);
            } finally {
                logger.trace(TRACE_LEVEL_THREADS, "ServingThread: exiting");
                closeConnection();
                done = true;
            }
        }

        /**
         * Check if present socket connection is alive.
         */
        private boolean isConnectionAlive() {
            return (connection != null && connection.isConnected());
        }

        /**
         * Wait for this thread finished
         * for specified timeout or interrupt it.
         *
         * @param millis timeout in milliseconds
         */
        public void waitForThread(long millis) {
            shouldStop = true;
            waitInterruptThread(this, millis);
        }

        /**
         * Close socket connection from remote host.
         */
        private void closeConnection() {
            if (connection != null) {
                connection.close();
            }
            if (launchingThread != null) {
                launchingThread.handleRequest(null);
            }
        }

        /**
         * Close thread closing socket connection and
         * waiting for thread finished.
         */
        public synchronized void close() {
            if (closed) {
                return;
            }
            closeConnection();
            if (launchingThread != null) {
                launchingThread.close();
                launchingThread = null;
            }
            waitForThread(THREAD_TIMEOUT);
            closed = true;
            logger.trace(TRACE_LEVEL_THREADS, "ServingThread closed");
        }

    } // ServingThread

///////// Thread serving a particular Binder's request //////////

    /**
     * An internal thread to execute each request from a test on remote host.
     * Requests are coming from ServingThread by invoking handleRequest(Object)
     * method.
     */
    private static class LaunchingThread extends Thread {
        private volatile boolean shouldStop = false;
        private volatile boolean closed = false;
        public volatile boolean done = false;

        private ServingThread owner = null;
//        private ProcessWaitingThread waitingThread = null;
        private Process process = null;

        private StreamRedirectingThread stdoutRedirectingThread = null;
        private StreamRedirectingThread stderrRedirectingThread = null;

        /** Notification about request occurence. */
        private volatile Object notification = new Object();
        /** Request to execute. */
        private volatile Object request = null;
        /** Socket stream to send replies to. */
        private SocketConnection connection = null;

        /**
         * Make thread for executing requests from a test and
         * send reply.
         *
         * @param owner owner of this thread
         * @connection socket connection for sending replies
         */
        public LaunchingThread(ServingThread owner, SocketConnection connection) {
            super("LaunchingThread");
            this.owner = owner;
            this.connection = connection;
        }

        /**
         * Notify this thread that new request has come.
         *
         * @param request request to execute
         */
        public void handleRequest(Object request) {
            synchronized (notification) {
                this.request = request;
                notification.notifyAll();
            }
        }

        /**
         * Check if request has been executed.
         */
        public boolean doneRequest() {
            return done;
        }

        /**
         * Wait for request notification from <code>ServingThread</code>
         * and execute an action according to the request.
         * Request <i>null</code> means thread should finish.
         */
        public void run() {
            logger.trace(TRACE_LEVEL_THREADS, "LaunchingThread: started to handle request");
            done = true;
            while (!isInterrupted()) {
                // wait for new request notification
                logger.trace(TRACE_LEVEL_ACTIONS, "LaunchingThread: waiting for request");
                synchronized (notification) {
                    try {
                        notification.wait();
                    } catch (InterruptedException e) {
                        logger.complain("LaunchingThread interrupted while waiting for request:\n\t"
                                        + e);
                        break;
                    }
                }

                // execute the request
                try {
                    logger.trace(TRACE_LEVEL_ACTIONS, "LaunchingThread: handling request: " + request);
                    if (request == null) {
                        break;
                    } else if (request instanceof LaunchDebugee) {
                        launchDebugee((LaunchDebugee)request);
                    } else if (request instanceof WaitForDebugee) {
                        waitForDebugee((WaitForDebugee)request);
                    } else if (request instanceof DebugeeExitCode) {
                        debugeeExitCode((DebugeeExitCode)request);
                    } else if (request instanceof KillDebugee) {
                        killDebugee((KillDebugee)request);
                    } else {
                        String reason = "Unknown request: " + request;
                        logger.complain(reason);
                        sendReply(new RequestFailed(reason));
                    }
                } catch (Exception e) {
                    e.printStackTrace(log.getOutStream());
                    logger.complain("Caught exception while handling request:\n\t" + e);
                }
                done = true;
            }
            done = true;
            logger.trace(TRACE_LEVEL_THREADS, "LaunchingThread: exiting");
            closeConnection();
        }

        /**
         * Send given reply to remote test.
         *
         * @param reply reply object to send
         */
        public void sendReply(Object reply) throws IOException {
            connection.writeObject(reply);
        }

        /**
         * Send given output line to remote test.
         *
         * @param reply wrapper object for output line to send
         */
        public void sendStreamMessage(RedirectedStream wrapper) throws IOException {
            logger.trace(TRACE_LEVEL_ACTIONS, "Sending output line wrapper to debugger: " + wrapper);
            if (connection.isConnected()) {
                sendReply(wrapper);
            } else {
                logger.complain("NOT redirected: " + wrapper.line);
            }
        }

        /**
         * Launch two <code>StreamRedirectingThread</code> threads to redirect
         * stdin/stderr output of debuggee VM process via <code>BindServer</code>
         * connection.
         *
         * @param process debuggee VM process
         */
        private void launchStreamRedirectors(Process process) {
            stdoutRedirectingThread =
                new StdoutRedirectingThread(this, process.getInputStream(),
                                            DebugeeProcess.DEBUGEE_STDOUT_LOG_PREFIX);
            stdoutRedirectingThread.start();
            stderrRedirectingThread =
                new StderrRedirectingThread(this, process.getErrorStream(),
                                            DebugeeProcess.DEBUGEE_STDERR_LOG_PREFIX);
            stderrRedirectingThread.start();
        }

        /**
         * Execute request for launching debuggee.
         *
         * @param request request to execute
         */
        private void launchDebugee(LaunchDebugee request) throws IOException {
            logger.trace(TRACE_LEVEL_ACTIONS, "LaunchDebugee: handle request: " + request);

            if (process != null) {
                logger.complain("Unable to launch debuggee: process already launched");
                sendReply(new RequestFailed("Debuggee process already launched"));
                return;
            }

            try {
                String[] cmd = request.cmd;
                cmd[0] = convertPath(cmd[0], request.slash, "TESTED_JAVA_HOME", true);
                for (int i = 1; i < cmd.length; i++) {
                    cmd[i] = convertPath(cmd[i], request.slash, "JAVA_ARGS", false);
                }
                String workDir = convertPath(request.workDir, request.slash, "WORKDIR", true);
                String[] classPathes = convertPathes(request.classPathes, request.slash, "CLASSPATH", true);
                String windir = argHandler.getDebugeeWinDir();

                boolean win = (!(windir == null || windir.equals("")));
                String[] envp = new String[win ? 3 : 1] ;
                envp[0] = "CLASSPATH=" + ArgumentParser.joinArguments(classPathes, "", pathSeparator);
                if (win) {
                    envp[1] = "WINDIR=" + windir;
                    envp[2] = "SystemRoot=" + windir;
                }

                logger.display("Setting environment:\n"
                                + "  " + ArgumentHandler.joinArguments(envp, "", "\n  "));
                logger.display("Setting work dir:\n"
                                + "  " + workDir);
                logger.display("Launching debuggee:\n"
                                + "  " + ArgumentHandler.joinArguments(cmd, "\""));

                process = Runtime.getRuntime().exec(cmd, envp, new File(workDir));
                logger.display("  debuggee launched successfully");

                launchStreamRedirectors(process);
            } catch (Exception e) {
                if (!(e instanceof Failure)) {
                    e.printStackTrace(log.getOutStream());
                }
                logger.complain("Caught exception while launching debuggee:\n\t" + e);
                sendReply(new CaughtException(e));
                return;
            }

            sendReply(new OK());
        }

        /**
         * Execute request for waiting for debuggee exited.
         *
         * @param request request to execute
         */
        private void waitForDebugee(WaitForDebugee request) throws IOException {
            logger.trace(TRACE_LEVEL_ACTIONS, "WaitForDebugee: handle request: " + request);

            if (process == null) {
                String reply = "No debuggee process to wait for";
                logger.complain(reply);
                sendReply(new RequestFailed(reply));
                return;
            }

            logger.display("Waiting for debuggee to exit");
/*
            // because timeout is not supported now
            // we do not use separate thread for waiting for process
            // and so following lines are commented out

            waitingThread = new ProcessWaitingThread();
            logger.trace(TRACE_LEVEL_ACTIONS, "LaunchingThread: starting thread for waiting for debugee process");
            waitingThread.start();
            try {
                waitingThread.join(request.timeout);
                if (waitingThread.isAlive()) {
                    String reply = "Timeout exceeded while waiting for debuggee to exit";
                    logger.complain(reply);
                    waitingThread.interrupt();
                    sendReply(socOut, new RequestFailed(reply));
                    return;
                }
            } catch (InterruptedException e) {
                e.printStackTrace(log.getOutStream());
                logger.complain("Caught exception while waiting for debuggee:\n\t" + e);
                sendReply(new CaughtException(e));
                return;
            }
            int exitStatus = waitingThread.exitStatus;
            waitingThread = null;
 */
            int exitStatus;
            try {
                exitStatus = process.waitFor();
                waitForRedirectors(THREAD_TIMEOUT);
                process.destroy();
            } catch (InterruptedException e) {
                e.printStackTrace(log.getOutStream());
                logger.complain("Caught exception while waiting for debuggee process to exit:\n\t"
                                + e);
                sendReply(new CaughtException(e));
                return;
            }
            logger.display("  debuggee exited with exit status: " + exitStatus);
            sendReply(new OK(exitStatus));
        }

        /**
         * Execute request for returning debuggee exit code.
         *
         * @param request request to execute
         */
        private void debugeeExitCode(DebugeeExitCode request) throws IOException {
            logger.trace(TRACE_LEVEL_ACTIONS, "DebugeeExitCode: handle request: " + request);

            if (process == null) {
                String reply = "No debuggee process to get exit code for";
                logger.complain(reply);
                sendReply(new RequestFailed(reply));
                return;
            }

            int exitStatus = 0;
            try {
                exitStatus = process.exitValue();
            } catch (IllegalThreadStateException e) {
                logger.display("# WARNING: Caught exception while getting exit status of debuggee:\n\t"
                                + e);
                sendReply(new CaughtException(e));
                return;
            }
            logger.trace(TRACE_LEVEL_ACTIONS, "DebugeeExitCode: return debuggee exit status: " + exitStatus);
            sendReply(new OK(exitStatus));
        }

        /**
         * Execute request for unconditional terminating debuggee process.
         *
         * @param request request to execute
         */
        private void killDebugee(KillDebugee request) throws IOException {
            logger.trace(TRACE_LEVEL_ACTIONS, "killDebugee: handle request: " + request);

            if (process == null) {
                String reply = "No debuggee process to kill";
                logger.complain(reply);
                sendReply(new RequestFailed(reply));
                return;
            }

            logger.trace(TRACE_LEVEL_ACTIONS, "killDebugee: killing debuggee process");
            process.destroy();

            logger.trace(TRACE_LEVEL_ACTIONS, "killDebugee: debuggee process killed");
            sendReply(new OK());
        }

        /**
         * Terminate debigee VM process if still alive.
         */
        private void terminateDebugeeAtExit() {
            if (process != null) {
                logger.trace(TRACE_LEVEL_ACTIONS, "Checking that debuggee process has exited correctly");
                try {
                    int value = process.exitValue();
                } catch (IllegalThreadStateException e) {
                    logger.complain("Debuggee process has not exited correctly: trying to kill it");
                    process.destroy();
                    try {
                        int value = process.exitValue();
                    } catch (IllegalThreadStateException ie) {
                        logger.complain("Debuggee process is alive after killing it");
                    }
                    process = null;
                    return;
                }
                logger.trace(TRACE_LEVEL_ACTIONS, "Debuggee process has exited correctly");
            }
        }

        /**
         * Wait for stream redirecting threads finished
         * for specified timeout.
         *
         * @param millis timeout in milliseconds
         */
        private void waitForRedirectors(long millis) {
            try {
                if (stdoutRedirectingThread != null) {
                    stdoutRedirectingThread.join(millis);
                }
                if (stderrRedirectingThread != null) {
                    stderrRedirectingThread.join(millis);
                }
            } catch (InterruptedException e) {
                e.printStackTrace(log.getOutStream());
                logger.complain("Caught exception while waiting for debuggee process exited:\n\t"
                                + e);
            }
        }

        /**
         * Wait for this thread finished
         * for specified timeout or interrupt it.
         *
         * @param millis timeout in milliseconds
         */
        public void waitForThread(long millis) {
            shouldStop = true;
            handleRequest(null);
            waitInterruptThread(this, millis);
        }

        /**
         * Close connection with debuggee.
         */
        public void closeConnection() {
            // no connections to close
        }

        /**
         * Close thread by closing all connections with debuggee,
         * finishing all redirectors and wait for thread finished.
         */
        public synchronized void close() {
            if (closed) {
                return;
            }
            closeConnection();
            terminateDebugeeAtExit();
            if (stdoutRedirectingThread != null) {
                stdoutRedirectingThread.close();
                stdoutRedirectingThread = null;
            }
            if (stderrRedirectingThread != null) {
                stderrRedirectingThread.close();
                stderrRedirectingThread = null;
            }
            waitForThread(THREAD_TIMEOUT);
            closed = true;
            logger.trace(TRACE_LEVEL_THREADS, "LaunchingThread closed");
        }

        /**
         * An inner thread for waiting for debuggee process exited
         * and saving its exit status. (currently not used)
         */
/*
        private class ProcessWaitingThread extends Thread {
            int exitStatus = 0;

            ProcessWaitingThread() {
                super("ProcessWaitingThread");
            }

            public void run() {
                logger.trace(TRACE_LEVEL_THREADS, "ProcessWaitingThread: starting waiting for process");
                try {
                    exitStatus = process.waitFor();
                } catch (InterruptedException e) {
                    e.printStackTrace(log.getOutStream());
                    logger.complain("Caught exception while waiting for debuggee process:\n\t"
                                    + e);
                }
                logger.trace(TRACE_LEVEL_ACTIONS, "ProcessWaitingThread: process finished with status: " + exitStatus);
                logger.trace(TRACE_LEVEL_THREADS, "ProcessWaitingThread: exiting");
            }

            public synchronized void close() {
                logger.trace(TRACE_LEVEL_THREADS, "ProcessWaitingThread closed");
            }

        } // ProcessWaitingThread
 */
    } // LaunchingThread

///////// Redirecting threads /////////

    /**
     * An abstract base class for internal threads which redirects stderr/stdout
     * output from debuggee process via <code>BindServer</code> connection.
     * <p>
     * Two derived classes will redirect <i>stderr</i> or </i>stdout</i> stream
     * by enwrapping stream line by <code>DebugeeStderr</code> or
     * <code>DebugeeStderr</code> objects. They should implement only one
     * abstract method <code>enwrapLine(String)</code> to make the difference.
     */
    public static abstract class StreamRedirectingThread extends Thread {
        private volatile boolean shouldStop = false;
        private volatile boolean closed = false;

        private LaunchingThread owner = null;

        private BufferedReader bin = null;
        private String prefix = null;

        /**
         * Make a thread to enwrap and redirect lines from specified
         * input stream with given prefix.
         *
         * @param owner owner of this thread
         * @param is input stream to redirect lines from
         * @param prefix prefix to add to each line
         */
        public StreamRedirectingThread(LaunchingThread owner, InputStream is, String prefix) {
            super("StreamRedirectingThread");
            this.prefix = prefix;
            this.owner = owner;
            bin = new BufferedReader(new InputStreamReader(is));
        }

        /**
         * Read lines from an input stream, enwrap them, and send to remote
         * test via <code>BindServer</code> connection.
         */
        public void run() {
            logger.trace(TRACE_LEVEL_THREADS, "StreamRedirectingThread: starting redirect output stream");
            try {
                String line;
                logger.trace(TRACE_LEVEL_IO, "StreamRedirectingThread: waiting for line from debuggee output");
                while(!shouldStop) {
                    line = bin.readLine();
                    if (line == null)
                        break;
                    owner.sendStreamMessage(enwrapLine(prefix + line));
                }
            } catch (EOFException e) {
                logger.display("Debuggee output stream closed by process");
            } catch (IOException e) {
                e.printStackTrace(log.getOutStream());
                logger.display("# WARNING: Connection to debuggee output stream aborted:\n\t" + e);
            } catch (Exception e) {
                e.printStackTrace(log.getOutStream());
                logger.complain("Caught exception while redirecting debuggee output stream:\n\t"
                                + e);
            }
            logger.trace(TRACE_LEVEL_THREADS, "StreamRedirectingThread: exiting");
            closeConnection();
        }

        /**
         * Envrap output line by the appropriate wrapper.
         * @param line line to enwrap
         */
        protected abstract RedirectedStream enwrapLine(String line);

        /**
         * Wait for this thread finished or interrupt it.
         *
         * @param millis timeout in milliseconds
         */
        public void waitForThread(long millis) {
            shouldStop = true;
            waitInterruptThread(this, millis);
        }

        /**
         * Close redirected process output stream.
         */
        public void closeConnection() {
            if (closed) {
                return;
            }
            if (bin != null) {
                try {
                    bin.close();
                } catch (IOException e) {
                    e.printStackTrace(log.getOutStream());
                    logger.complain("Caught exception while closing debuggee output stream:\n\t"
                                    + e);
                }
                bin = null;
            }
            closed = true;
            logger.trace(TRACE_LEVEL_THREADS, "StreamRedirectingThread closed");
        }

        /**
         * Close thread by waiting redirected stream closed
         * and finish the thread.
         */
        public synchronized void close() {
            if (closed) {
                return;
            }
            waitForThread(THREAD_TIMEOUT);
            closeConnection();
            closed = true;
            logger.trace(TRACE_LEVEL_THREADS, "StreamRedirectingThread closed");
        }

    } // StreamRedirectingThread

    /**
     * Particalar case of <code>StreamRedirectingThread</code> to redirect
     * <i>stderr</i> stream by enwrapping lines into <code>DebugeeStderr</code>
     * objects.
     */
    private static class StderrRedirectingThread extends StreamRedirectingThread {

        /**
         * Make a thread to redirect <i>stderr</i> output stream.
         */
        StderrRedirectingThread(LaunchingThread owner, InputStream is, String prefix) {
            super(owner, is, prefix);
            setName("StderrRedirectingThread");
        }

        /**
         * Enwrap given line into <code>DebugeeStderr</code> object.
         */
        protected RedirectedStream enwrapLine(String line) {
            return new DebugeeStderr(line);
        }

    }

    /**
     * Particalar case of <code>StreamRedirectingThread</code> to redirect
     * <i>stdout</i> stream by enwrapping lines into <code>DebugeeStdout</code>
     * objects.
     */
    private static class StdoutRedirectingThread extends StreamRedirectingThread {

        /**
         * Make a thread to redirect <i>stdout</i> output stream.
         */
        StdoutRedirectingThread(LaunchingThread owner, InputStream is, String prefix) {
            super(owner, is, prefix);
            setName("StdoutRedirectingThread");
        }

        /**
         * Enwrap given line into <code>DebugeeStdout</code> object.
         */
        protected RedirectedStream enwrapLine(String line) {
            return new DebugeeStdout(line);
        }

    }

///////// BinderServer's packets //////////

    /**
     * Base serializable object to transmit request or reply
     * via <code>BindServer</code> connection.
     */
    public static class Packet implements Serializable {}

    ///////// Binder's requests //////////

    /**
     * Base class to represent request to <code>BindServer</code>.
     */
    public static abstract class Request extends Packet {}

    /**
     * This class implements task identification command.
     */
    public static class TaskID extends Request {
        public String id;

        public TaskID(String id) {
            this.id = id;
        }

        public String toString() {
            return "TaskID: id=" + id;
        }
    }

    /**
     * This class implements a request for launching a debugee.
     */
    public static class LaunchDebugee extends Request {
        public String slash;         // slash symbol used on debugger host
        public String[] cmd;         // command line arguments as seen on debugger host
        public String workDir;       // path to working directory as seen on debugger host
        public String[] classPathes; // list of class pathes as seen on debugger host

        public LaunchDebugee(String[] cmd, String slash, String workDir,
                            String[] pathes, String[] classPathes,
                            String[] libPathes) {
            this.cmd = cmd;
            this.slash = slash;
            this.workDir = workDir;
            this.classPathes = classPathes;
        }

        public String toString() {
            return "LaunchDebugee:"
                + "\n\tcommand=" + ArgumentParser.joinArguments(cmd, "\"")
                + "\n\tWORKDIR=" + workDir
                + "\n\tCLASSPATH=" + ArgumentParser.joinArguments(classPathes, "", ":")
                + "\n\tslash=" + slash;
        }
    }

    /**
     * This class implements a request for waiting for debugee
     * termination.
     */
    public static class WaitForDebugee extends Request {
        public long timeout = 0; // timeout in minutes for waiting

        public WaitForDebugee(long value) {
            timeout = value;
        }

        public String toString() {
            return "WaitForDebugee: timeout=" + timeout;
        }
    }

    /**
     * This class implements a request for exit code of
     * debugee process.
     */
    public static class DebugeeExitCode extends Request {
        public String toString() {
            return "SebugeeExitCode";
        }
    }

    /**
     * This class implements a request for killing debugee process.
     */
    public static class KillDebugee extends Request {
        public String toString() {
            return "KillDebugee";
        }
    }

    /**
     * This class implements a request to disconnect connection with test.
     */
    public static class Disconnect extends Request {
        public String toString() {
            return "Disconnect";
        }
    }

    ///////// BindServer's responses //////////

    /**
     * Base class to represent response from <code>BindServer</code>.
     */
    public static abstract class Response extends Packet {}

    /**
     * This class implements a response that a previoulsy received
     * request has been successfully performed.
     */
    public static class OK extends Response {
        public long info = BindServer.VERSION; // optional additional info

        public OK() {
        }

        public OK(long value) {
            info = value;
        }

        public String toString() {
            return "OK(" + info + ")";
        }
    }

    /**
     * This class implements a response that the BindServer is
     * unable to serve a previoulsy received request.
     */
    public static class RequestFailed extends Response {
        public String reason; // the short explanation of failure

        public RequestFailed(String reason) {
            this.reason = reason;
        }

        public String toString() {
            return "RequestFailed(" + reason + ")";
        }
    }

    /**
     * This class implements a response that the BindServer is
     * unable to serve a previoulsy received request because of
     * caught exception.
     */
    public static class CaughtException extends RequestFailed {
        public CaughtException(Exception cause) {
            super("Caught exception: " + cause);
        }
    }

    ///////// Wrappers for redirected messages //////////

    /**
     * Base class to represent wrappers for redirected streams.
     */
    public static class RedirectedStream extends Packet {
        public String line; // line containing line from redirected stream

        public RedirectedStream(String str) {
            line = str;
        }

        public String toString() {
            return "RedirectedStream(" + line + ")";
        }
    }

    /**
     * This class enwraps redirected line of <i>stdout</i> stream.
     */
    public static class DebugeeStdout extends RedirectedStream {

        public DebugeeStdout(String str) {
            super(str);
        }

        public String toString() {
            return "DebugeeStdout(" + line + ")";
        }
    }

    /**
     * This class enwraps redirected line of <i>stderr</i> stream.
     */
    public static class DebugeeStderr extends RedirectedStream {
        public DebugeeStderr(String str) {
            super(str);
        }

        public String toString() {
            return "DebugeeStderr(" + line + ")";
        }
    }

/////// ArgumentHandler for BindServer command line /////////

    /**
     * This class is used to parse arguments from command line
     * and specified <i>bind-file</i>,
     */
    private static class ArgumentHandler extends ArgumentParser {

        protected Properties fileOptions;

        /**
         * Make parser object for command line arguments.
         *
         * @param args list of command line arguments
         */
        public ArgumentHandler(String[] args) {
            super(args);
        }

        /**
         * Check if given command line option is aloowed.
         *
         * @param option option name
         * @param value option value
         */
        protected boolean checkOption(String option, String value) {
            if (option.equals("bind.file")) {
                // accept any file name
                return true;
            }
            return super.checkOption(option, value);
        }

        /**
         * Check if all recignized options are compatible.
         */
        protected void checkOptions() {
            if (getBindFileName() == null) {
                throw new BadOption("Option -bind.file is requred ");
            }
            super.checkOptions();
        }

        /**
         * Check if value of this option points to a existing directory.
         *
         * @param option option name
         * @param dir option value
         */
        private void checkDir(String option, String dir) {
            File file = new File(dir);
            if (!file.exists()) {
                throw new BadOption(option + " does not exist: " + dir);
            }
            if (!file.isAbsolute()) {
                throw new BadOption(option + " is not absolute pathname: " + dir);
            }
            if (!file.isDirectory()) {
                throw new BadOption(option + " is not directory: " + dir);
            }
        }

        /**
         * Check if option from <i>bind-file</i> is allowed.
         *
         * @param option option name
         * @param value option value
         */
        protected boolean checkAdditionalOption(String option, String value) {

            if (option.equals("DEBUGGER_HOST")) {
                // accept any hostname
                return true;
            }

            if (option.equals("BINDSERVER_PORT")) {
                // accept only integer value
                try {
                    int port = Integer.parseInt(value);
                } catch (NumberFormatException e) {
                    throw new Failure("Not integer value of bind-file option " + option
                                        + ": " + value);
                }
                return true;
            }

            if (option.equals("DEBUGGER_TESTED_JAVA_HOME")
                    || option.equals("DEBUGGER_WORKDIR")
                    || option.equals("DEBUGGER_TESTBASE")) {
                if (value == null || value.equals("")) {
                    throw new BadOption("Empty value of bind-file option " + option);
                }
                return true;
            }

            if (option.equals("DEBUGGEE_TESTED_JAVA_HOME")
                    || option.equals("DEBUGGEE_WORKDIR")
                    || option.equals("DEBUGGEE_TESTBASE")) {
                if (value == null || value.equals("")) {
                    throw new BadOption("Empty value of bind-file option " + option);
                }
                checkDir(option, value);
                return true;
            }

            if (option.equals("DEBUGGEE_WINDIR")) {
                if (!(value == null || value.equals(""))) {
                    checkDir(option, value);
                }
                return true;
            }

            return false;
        }

        /**
         * Check if all recignized options form <i>bind-file</i> are compatible.
         */
        protected void checkAdditionalOptions() {

            if (getDebuggerJavaHome() == null) {
                throw new BadOption("Option DEBUGGER_JAVA_HOME missed from bind-file");
            }
            if (getDebuggerWorkDir() == null) {
                throw new BadOption("Option DEBUGGER_WORKDIR missed from bind-file");
            }
            if (getDebuggerTestbase() == null) {
                throw new BadOption("Option DEBUGGER_TESTBASE missed from bind-file");
            }

            if (getDebugeeJavaHome() == null) {
                throw new BadOption("Option DEBUGGEE_JAVA_HOME missed from bind-file");
            }
            if (getDebugeeWorkDir() == null) {
                throw new BadOption("Option DEBUGGEE_WORKDIR missed from bind-file");
            }
            if (getDebugeeTestbase() == null) {
                throw new BadOption("Option DEBUGGEE_TESTBASE missed from bind-file");
            }
        }

        /**
         * Parse options form specified <i>bind-file</i>.
         */
        protected void parseAdditionalOptions() {
            Enumeration keys = fileOptions.keys();
            while (keys.hasMoreElements()) {
                String option = (String)keys.nextElement();
                String value = fileOptions.getProperty(option);
                if (! checkAdditionalOption(option, value)) {
                    throw new BadOption("Unrecognized bind-file option: " + option);
                }
            }
            checkAdditionalOptions();
        }

        /**
         * Parse all options from command line and specified <i>bind-file</i>.
         */
        protected void parseArguments() {
            super.parseArguments();
            String fileName = getBindFileName();
            try {
                FileInputStream bindFile = new FileInputStream(fileName);
                fileOptions = new Properties();
                fileOptions.load(bindFile);
                bindFile.close();
            } catch(FileNotFoundException e) {
                throw new BadOption("Unable to open bind-file " + fileName + ": " + e);
            } catch(IOException e) {
                e.printStackTrace(log.getOutStream());
                throw new Failure("Caught exception while reading bind-file:\n" + e);
            }
            parseAdditionalOptions();
        }

        /** Return name of specified <i>bind-file<i>. */
        public String getBindFileName() {
            return options.getProperty("bind.file");
        }

        /** Return specified debuggee host name . */
        public String getDebuggerHost() {
            return fileOptions.getProperty("DEBUGGER_HOST", "localhost");
        }

        /** Return string representation of port number for <code>BindServer<code> connection. */
        public String getBindPort() {
            return fileOptions.getProperty("BINDSERVER_PORT", "9000");
        }

        /** Return specified port number for <code>BindServer<code> connection. */
        public int getBindPortNumber() {
            try {
                return Integer.parseInt(getBindPort());
            } catch (NumberFormatException e) {
                throw new Failure("Not integer value of BindServer port");
            }
        }

        /** Return specified path to tested JDK used for debuggee VM. */
        public String getDebugeeJavaHome() {
            return fileOptions.getProperty("DEBUGGEE_TESTED_JAVA_HOME");
        }

        /** Return specified path to tested JDK used for debugger. */
        public String getDebuggerJavaHome() {
            return fileOptions.getProperty("DEBUGGER_TESTED_JAVA_HOME");
        }

        /** Return specified path to working dir from debuggee host. */
        public String getDebugeeWorkDir() {
            return fileOptions.getProperty("DEBUGGEE_WORKDIR");
        }

        /** Return specified path to working dir from debugger host. */
        public String getDebuggerWorkDir() {
            return fileOptions.getProperty("DEBUGGER_WORKDIR");
        }

        /** Return specified path to testbase dir from debuggee host. */
        public String getDebugeeTestbase() {
            return fileOptions.getProperty("DEBUGGEE_TESTBASE");
        }

        /** Return specified path to testbase dir from debugger host. */
        public String getDebuggerTestbase() {
            return fileOptions.getProperty("DEBUGGER_TESTBASE");
        }

        /** Return specified path to system directory on Wimdows platform. */
        public String getDebugeeWinDir() {
            return fileOptions.getProperty("DEBUGGEE_WINDIR");
        }

    } // ArgumentHandler

} // BindServer