package org.spiderwiz.tutorial.lesson15.plugins;

import java.io.IOException;
import java.net.Socket;
import java.util.Map;
import javax.net.ServerSocketFactory;
import javax.net.ssl.SSLServerSocket;
import javax.net.ssl.SSLServerSocketFactory;
import org.spiderwiz.core.Channel;
import org.spiderwiz.core.Main;
import org.spiderwiz.core.ServerChannel;
import org.spiderwiz.zutils.ZUtilities;

/**
 * Implementation of an SSL TCP/IP server plugin.
 */
public class SslServerSocket extends ServerChannel {
    private static final String TYPES[] = {"import", "producer", "consumer"};
    private static final String NO_PORT = "No port number specified for %1$s server-%2$d";

    private SSLServerSocket serverSocket = null;
    private int port;

    /**
     * Called by the framework to configure the server with the parameters defined in
     * "producer server-n" or "consumer server-n" configuration properties. The relevant parameters for an SSL server are:
     *      port    port number that the server needs to listen on.
     *      ks      a path to a file that contains the server key store.
     *      pwd     the key store private password.
     * @param configParams      a map of key=value configuration parameters.
     * @param type              type of server - 1:producer, 2:consumer.
     * @param n                 the n value of "producer server-n" or "consumer server-n" configuration properties.
     * @return true if and only if configuration is successful.
     */
    @Override
    protected boolean configure(Map<String, String> configParams, int type, int n) {
        port = ZUtilities.parseInt(configParams.get("port"));
        if (port <= 0) {
            Main.getInstance().sendExceptionMail(null, String.format(NO_PORT, TYPES[type], n), null, true);
            return false;
        }
        String keystoreLocation = configParams.get("ks");
        String keystorePassword = configParams.get("pwd");
        if (keystoreLocation != null)
            System.setProperty("javax.net.ssl.keyStore", keystoreLocation);
        if (keystorePassword != null)
            System.setProperty("javax.net.ssl.keyStorePassword", keystorePassword);
        return true;
    }
    
    /**
     * Opens the server for arriving connection requests.
     * @throws IOException
     */
    @Override
    protected void open() throws IOException {
        ServerSocketFactory ssf = (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
        serverSocket = (SSLServerSocket) ssf.createServerSocket(port);
    }

    /**
     * Listens for a connection to be made to this server and accepts it.
     * @return the server side of an SSL socket plugin.
     * @throws IOException
     */
    @Override
    protected Channel accept() throws IOException {
        if (serverSocket == null)
            return null;
        Socket socket = serverSocket.accept();
        if (socket == null)
            return null;
        SslSocket channel = new SslSocket();
        channel.setSocket(socket);
        return channel;
    }

    /**
     * Closes the server.
     * @throws IOException
     */
    @Override
    protected void close() throws IOException {
        if (serverSocket != null)
            serverSocket.close();
    }

    /**
     * @return the server point identification.
     */
    @Override
    public String getGateID() {
        return "SSL port " + port;
    }
}

package org.spiderwiz.tutorial.lesson15.plugins;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Map;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import org.spiderwiz.core.Channel;
import org.spiderwiz.core.Main;
import org.spiderwiz.zutils.ZUtilities;

/**
 * Implementation of an SSL TCP/IP socket plugin.
 */
public class SslSocket extends Channel{
    private static final String NO_TCP_PARAMS = "No IP address or port number specified for %1$s-%2$d";
    private static final String TYPES[] = {"import", "producer", "consumer"};

    private Socket socket = null;
    private String ip;
    private int port;

    /**
     * Called by the framework to configure the socket with the parameters defined in
     * "producer-n", "consumer-n" or "import-n" configuration properties. The relevant parameters for an SSL socket are:
     *      ip      the address of the server to connect to
     *      port    the port number to connect to
     *      ks      a path to a file that contains the client key store.
     * @param configParams      a map of key=value configuration parameters.
     * @param type              type of channel - 0: import, 1:producer, 2:consumer.
     * @param n                 the <em>n</em> value of <em>import-n</em>, <em>producer-n</em> or <em>consumer-n</em>.
     * @return true if and only if configuration is successful.
     */
    @Override
    protected boolean configure(Map<String, String> configParams, int type, int n) {
        ip = configParams.get("ip");
        port = ZUtilities.parseInt(configParams.get("port"));
        if (ip == null || port <= 0) {
            Main.getInstance().sendExceptionMail(null, String.format(NO_TCP_PARAMS, TYPES[type], n), null, true);
            return false;
        }
        socket = null;
        String truststoreLocation = configParams.get("ks");
        if (truststoreLocation != null)
            System.setProperty("javax.net.ssl.trustStore", truststoreLocation);
        return true;
    }

    /**
     * Creates an SSL socket connection to the server and perform handshake.
     * @return true if and only if the operation is successful.
     * @throws UnknownHostException
     * @throws IOException
     */
    @Override
    protected boolean open() throws UnknownHostException, IOException {
        // create a socket only if this is a client side socket. A server side socket already exists
        if (port != 0) {
            SSLSocketFactory f = (SSLSocketFactory) SSLSocketFactory.getDefault();
            socket = f.createSocket(InetAddress.getByName(ip).getHostAddress(), port);
            ((SSLSocket)socket).startHandshake();
        }
        return true;
    }

    /**
     * Disconnects by closing the socket.
     * @throws IOException
     */
    @Override
    protected void close() throws IOException {
        if (socket != null)
            socket.close();
        socket = null;
    }

    /**
     * @return the input stream of the connected socket
     * @throws IOException
     */
    @Override
    protected InputStream getInputStream() throws IOException {
        return socket == null ? null : socket.getInputStream();
    }

    /**
     * @return the output stream of the connected socket.
     * @throws IOException
     */
    @Override
    protected OutputStream getOutputStream() throws IOException {
        return socket == null ? null : socket.getOutputStream();
    }

    /**
     * A client socket should try to reconnect if disconnected while a server side socket shall not.
     * @return true if this is a server side socket.
     */
    @Override
    protected boolean dontReconnect() {
        return port == 0;
    }

    /**
     * @return a string that represents the socket protocol and the address it is connected to in the form:
     * "ssl:<ip address>:<port number>". If this is a server side socket then the <port number> part is omitted.
     */
    @Override
    public String getRemoteAddress() {
        return "ssl:" + ip + (port == 0 ? "" : ":" + port);
    }

    /**
     * Called by SslServerSocket when the server accepts a connection and creates a Socket object to handle it on the server
     * side. Attaches the Socket object to the current object and constructs the peer IP address.
     * @param socket the Socket object that shall be attached to this object.
     */
    public void setSocket(Socket socket) {
        this.socket = socket;
        ip = socket.getRemoteSocketAddress().toString().replace("/", "");
        int n = ip.indexOf(":");
        if (n > 0)
            ip = ip.substring(0, n);
        port = 0;
    }
}

package org.spiderwiz.tutorial.lesson15.sslhub;

import org.spiderwiz.tutorial.objectLib.ConsoleMain;

/**
 * Main class for SSL Hub.
 */
public class SslHubMain extends ConsoleMain{
    private static final String ROOT_DIRECTORY = "/tests/SslHub";
    private static final String CONFIG_FILE_NAME = "sslhub.conf";
    private static final String APP_NAME = "SSL Hub";
    private static final String APP_VERSION = "Z15.01";  // Version Z15.01: SSL hub for Lesson 15

    public SslHubMain() {
        super(ROOT_DIRECTORY, CONFIG_FILE_NAME, APP_NAME, APP_VERSION);
    }

    /**
     * Application entry point. Instantiate the class and initialize the instance.
     * 
     * @param args the command line arguments. Not used in this application.
     */
    public static void main(String[] args) {
        new SslHubMain().init();
    }

    /**
     * @return an empty list as we produce nothing
     */
    @Override
    protected String[] getProducedObjects() {
        return new String[]{};
    }

    /**
     * @return an empty list as we produce nothing
     */
    @Override
    protected String[] getConsumedObjects() {
        return new String[]{};
    }

    /**
     * Process an input line - nothing to process in our case.
     * @param line      The input line
     * @return true
     */
    @Override
    protected boolean processConsoleLine(String line) {
        return true;
    }
}

[log folder]Logs
[consumer server-1]class=org.spiderwiz.tutorial.lesson15.plugins.SslServerSocket;port=10002;ks=C:/Keys/ServerKeyStore.jks;pwd=Pass1word
[producer-1]ip=localhost;port=10001
[hub mode]yes

[application name]Chat 1
[log folder]/tests/Chat1/Logs
[backup folder]/tests/Chat1/Backup
[history file]/tests/Chat1/history.dat
[producer-1]class=org.spiderwiz.tutorial.lesson15.plugins.SslSocket;ip=localhost;port=10002;ks=C:/CA/ClientKeyStore.jks