ActionReceiver.java

package edu.stanford.hci.r3.actions.remote;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import com.thoughtworks.xstream.XStream;

import edu.stanford.hci.r3.actions.R3Action;
import edu.stanford.hci.r3.config.Configuration;
import edu.stanford.hci.r3.config.Constants;
import edu.stanford.hci.r3.util.DebugUtils;
import edu.stanford.hci.r3.util.networking.ClientServerType;

public class ActionReceiver {

        public static final String CONFIG_FILE_KEY = "actionreceiver.trustedsenders";

        public static final String CONFIG_FILE_VALUE = "/config/ActionReceiver.xml";

        public static final int DEFAULT_JAVA_PORT = Constants.Ports.ACTION_RECEIVER_JAVA;

        public static final int DEFAULT_PLAINTEXT_PORT = Constants.Ports.ACTION_RECEIVER_PLAINTEXT;

        private static ActionReceiver javaDaemon;

        private static final String PROPERTY_NAME = "trustedClients";

        private static ActionReceiver textDaemon;

        public static void startDaemons() {
                startDaemons(DEFAULT_JAVA_PORT, DEFAULT_PLAINTEXT_PORT);
        }

        public static void startDaemons(int tcpipPortJava, int tcpipPortPlainText) {
                if (javaDaemon == null) {
                        javaDaemon = new ActionReceiver(tcpipPortJava, ClientServerType.JAVA);
                }
                if (textDaemon == null) {
                        textDaemon = new ActionReceiver(tcpipPortPlainText, ClientServerType.PLAINTEXT);
                }
        }

        public static void stopDaemons() {
                DebugUtils.println("Stopping Action Receiver Daemons.");
                if (javaDaemon != null) {
                        javaDaemon.stopDaemon();
                        javaDaemon = null;
                }

                if (textDaemon != null) {
                        textDaemon.stopDaemon();
                        textDaemon = null;
                }
        }

        private List<ActionHandler> actionHandlers = new ArrayList<ActionHandler>();

        private List<Socket> clients = new ArrayList<Socket>();

        private ActionReceiverConnectionListener connectionListener;

        private boolean exitFlag = false;

        private String hostAddress;

        private String hostName;

        private int serverPort;

        private ServerSocket serverSocket;

        private ClientServerType serverType;

        private Set<String> trustedSenders = new HashSet<String>();

        public ActionReceiver(int tcpipPort, ClientServerType type) {
                this(tcpipPort, type, "localhost");
        }

        public ActionReceiver(int tcpipPort, ClientServerType type, String... trusted) {
                trustedSenders.addAll(Arrays.asList(trusted));
                readTrustedClientsFromConfigFile();
                DebugUtils.println("Trusted Client Set: " + trustedSenders);

                try {
                        serverSocket = new ServerSocket(tcpipPort);
                } catch (IOException e) {
                        System.out.println("Error with server socket: " + e.getLocalizedMessage());
                }
                serverType = type;

                // the server port
                serverPort = serverSocket.getLocalPort();

                try {
                        hostAddress = InetAddress.getLocalHost().getHostAddress();
                        hostName = InetAddress.getLocalHost().getHostName();
                } catch (UnknownHostException e) {
                        e.printStackTrace();
                }

                // start thread to accept connections
                getDaemonThread().start();
        }

        public void addActionHandler(ActionHandler handler) {
                actionHandlers.add(handler);
        }

        private Thread getDaemonThread() {
                return new Thread() {

                        public void run() {
                                while (true) {
                                        Socket client = null;
                                        try {
                                                if (exitFlag) {
                                                        System.out.println("Closing Action Receiver Daemon.");
                                                        break;
                                                }

                                                log("ActionReceiver :: Waiting for a " + serverType + " connection on port ["
                                                                + serverPort + "]");

                                                client = serverSocket.accept();

                                                final InetAddress inetAddress = client.getInetAddress();
                                                final String ipAddr = inetAddress.toString();
                                                final String dnsName = inetAddress.getHostName();

                                                // we got a connection with the client
                                                log("ActionReceiver :: Got a connection on server port " + serverPort);
                                                log("               from client: " + ipAddr + " :: " + dnsName);
                                                if (connectionListener != null) {
                                                        connectionListener.newConnectionFrom(dnsName, ipAddr);
                                                }

                                                // check whether it's ok to get messages from this remote machine...
                                                boolean clientIsOK = false;
                                                for (String nameOrAddress : trustedSenders) {
                                                        if (nameOrAddress.contains("*")) {
                                                                // 128.15.*.* --> 128.15.
                                                                nameOrAddress = nameOrAddress.substring(0, nameOrAddress.indexOf("*"));
                                                        }

                                                        if (dnsName.toLowerCase().endsWith(nameOrAddress)
                                                                        || ipAddr.startsWith(nameOrAddress)) {
                                                                // .stanford.edu
                                                                // 128.15.
                                                                // good enough for us!
                                                                DebugUtils.println("This is a trusted client. Matched: " + nameOrAddress);
                                                                clientIsOK = true;
                                                        } else {
                                                                DebugUtils.println("Did not match our client. Filter [" + nameOrAddress
                                                                                + "] does not match " + dnsName + " next!");
                                                        }
                                                }
                                                if (!clientIsOK) {
                                                        client.close();
                                                        continue;
                                                }

                                                // keep it around
                                                clients.add(client);
                                        } catch (IOException ioe) {
                                                log("ActionReceiver :: Error with server socket: " + ioe.getLocalizedMessage());
                                        }

                                        if (client != null) {
                                                if (serverType == ClientServerType.PLAINTEXT) {
                                                        getTextClientHandlerThread(client).start();
                                                } else { // serverType == Java Server
                                                        getJavaClientHandlerThread(client).start();
                                                }
                                        }
                                }
                        }
                };
        }

        public String getHostAddress() {
                return hostAddress;
        }

        public String getHostName() {
                return hostName;
        }

        private Thread getJavaClientHandlerThread(final Socket clientSocket) {
                return new Thread() {
                        private BufferedReader br;

                        public void run() {
                                try {
                                        final InputStream inputStream = clientSocket.getInputStream();
                                        br = new BufferedReader(new InputStreamReader(inputStream));
                                        String line = null;
                                        final XStream xml = new XStream();
                                        while ((line = br.readLine()) != null) {
                                                // System.out.println(line);

                                                if (exitFlag) {
                                                        break;
                                                }

                                                // reconstruct the action
                                                final R3Action action = (R3Action) xml.fromXML(line);

                                                // tell my listeners!
                                                for (ActionHandler ah : actionHandlers) {
                                                        ah.receivedAction(action);
                                                }
                                        }
                                } catch (IOException e) {
                                        DebugUtils.println(e);
                                        DebugUtils.println("The client " + clientSocket.getInetAddress().getHostName()
                                                        + " has probably disconnected...");
                                }
                        }
                };
        }

        private Thread getTextClientHandlerThread(final Socket clientSocket) {
                return new Thread() {
                        private BufferedReader br;

                        public synchronized void disconnect() {
                                try {
                                        if (!clientSocket.isClosed()) {
                                                clientSocket.close();
                                        }
                                        if (br != null) {
                                                br.close();
                                                br = null;
                                        }
                                } catch (IOException e) {
                                        e.printStackTrace();
                                }
                        }

                        public void run() {
                                try {
                                        final InputStream inputStream = clientSocket.getInputStream();
                                        br = new BufferedReader(new InputStreamReader(inputStream));
                                        String line = null;
                                        while ((line = br.readLine()) != null) {
                                                System.out.println(line);

                                                if (line.toLowerCase().equals("[[exit]]")) {
                                                        break;
                                                }

                                                // the server's exit flag
                                                // it can kill all clients at the same time
                                                if (exitFlag) {
                                                        break;
                                                }

                                                // tell my listeners!
                                                for (ActionHandler ah : actionHandlers) {
                                                        ah.receivedActionText(line);
                                                }
                                        }
                                } catch (IOException e) {
                                        e.printStackTrace();
                                }
                                disconnect();
                        }

                };
        }

        private void log(String msg) {
                System.out.println(msg);
        }

        private void readTrustedClientsFromConfigFile() {
                final String trustedClients = Configuration.getPropertyFromConfigFile(PROPERTY_NAME,
                                CONFIG_FILE_KEY);
                final String[] clients = trustedClients.split("[,]");
                for (String client : clients) {
                        trustedSenders.add(client.trim());
                }
        }

        public void setConnectionListener(ActionReceiverConnectionListener listener) {
                connectionListener = listener;
        }

        public void stopDaemon() {
                try {
                        exitFlag = true;
                        for (Socket client : clients) {
                                client.close();
                        }
                        System.out.println("ActionReceiver :: " + serverType + " on port "
                                        + serverSocket.getLocalPort() + " is stopping...");
                        serverSocket.close();
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }
}

---