jdk-sandbox: comparison jdk/test/javax/net/ssl/templates/SSLSocketTemplate.java

equal deleted inserted replaced

-:cd6c5ce91538
+:c9b28ab5297b
 * 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.
 */
-// SunJSSE does not support dynamic system properties, no way to re-use
+import java.io.FileInputStream;
-// system properties in samevm/agentvm mode.
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetSocketAddress;
+import java.net.SocketTimeoutException;
+import java.security.KeyStore;
+import java.security.Security;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLServerSocket;
+import javax.net.ssl.SSLServerSocketFactory;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+/**
+* This class defines a framework for JSSE tests.
+*
+* Please run in othervm mode.  SunJSSE does not support dynamic system
+* properties, no way to re-use system properties in samevm/agentvm mode.
+*/
 /*
 * @test
 * @bug 1234567
-* @summary Use this template to help speed your client/server tests.
+* @summary Use this class for JSSE tests
 * @run main/othervm SSLSocketTemplate
 * @author Brad Wetmore
 */
-import java.io.*;
-import javax.net.ssl.*;
 public class SSLSocketTemplate {
-/*
+public static final String TEST_SRC = System.getProperty("test.src", ".");
-* =============================================================
-* Set the various variables needed for the tests, then
+/*
-* specify what tests to run on each side.
+* Where do we find the keystores?
 */
+public static final String PATH_TO_STORES = "../etc";
+public static final String KEY_STORE_FILE = "keystore";
+public static final String TRUST_STORE_FILE = "truststore";
+public static final String PASSWORD = "passphrase";
+public static final int FREE_PORT = 0;
+// in seconds
+public static final long CLIENT_SIGNAL_TIMEOUT = 30L;
+public static final long SERVER_SIGNAL_TIMEOUT = 90L;
+// in millis
+public static final int CLIENT_TIMEOUT = 15000;
+public static final int SERVER_TIMEOUT = 30000;
 /*
 * Should we run the client or server in a separate thread?
 * Both sides can throw exceptions, but do you have a preference
 * as to which side should be the main thread.
 */
-static boolean separateServerThread = false;
+private boolean separateServerThread = false;
 /*
-* Where do we find the keystores?
+* What's the server port?  Use any free port by default
 */
-static String pathToStores = "../etc";
+private volatile int serverPort;
-static String keyStoreFile = "keystore";
-static String trustStoreFile = "truststore";
+private volatile Exception serverException;
-static String passwd = "passphrase";
+private volatile Exception clientException;
+private Thread clientThread;
+private Thread serverThread;
+private Peer serverPeer;
+private Peer clientPeer;
+private Application serverApplication;
+private Application clientApplication;
+private SSLContext context;
 /*
 * Is the server ready to serve?
 */
-volatile static boolean serverReady = false;
+private final CountDownLatch serverReadyCondition = new CountDownLatch(1);
 /*
-* Turn on SSL debugging?
+* Is the client ready to handshake?
 */
-static boolean debug = false;
+private final CountDownLatch clientReadyCondition = new CountDownLatch(1);
 /*
-* If the client or server is doing some kind of object creation
+* Is the server done?
-* that the other side depends on, and that thread prematurely
+*/
-* exits, you may experience a hang.  The test harness will
+private final CountDownLatch serverDoneCondition = new CountDownLatch(1);
-* terminate all hung threads after its timeout has expired,
-* currently 3 minutes by default, but you might try to be
+/*
-* smart about it....
+* Is the client done?
+*/
+private final CountDownLatch clientDoneCondition = new CountDownLatch(1);
+/*
+* Public API.
+*/
+public static interface Peer {
+void run(SSLSocketTemplate test) throws Exception;
+}
+public static interface Application {
+void run(SSLSocket socket, SSLSocketTemplate test) throws Exception;
+}
+public static void debug() {
+debug("ssl");
+}
+public static void debug(String mode) {
+System.setProperty("javax.net.debug", mode);
+}
+public static void setup(String keyFilename, String trustFilename,
+String password) {
+System.setProperty("javax.net.ssl.keyStore", keyFilename);
+System.setProperty("javax.net.ssl.keyStorePassword", password);
+System.setProperty("javax.net.ssl.trustStore", trustFilename);
+System.setProperty("javax.net.ssl.trustStorePassword", password);
+}
+public static void setup() throws Exception {
+String keyFilename = TEST_SRC + "/" + PATH_TO_STORES + "/"
++ KEY_STORE_FILE;
+String trustFilename = TEST_SRC + "/" + PATH_TO_STORES + "/"
++ TRUST_STORE_FILE;
+setup(keyFilename, trustFilename, PASSWORD);
+}
+public static void print(String message, Throwable... errors) {
+synchronized (System.out) {
+System.out.println(message);
+for (Throwable e : errors) {
+e.printStackTrace(System.out);
+}
+}
+}
+public static KeyStore loadJksKeyStore(String filename, String password)
+throws Exception {
+return loadKeyStore(filename, password, "JKS");
+}
+public static KeyStore loadKeyStore(String filename, String password,
+String type) throws Exception {
+KeyStore keystore = KeyStore.getInstance(type);
+FileInputStream fis = new FileInputStream(filename);
+try {
+keystore.load(fis, password.toCharArray());
+} finally {
+fis.close();
+}
+return keystore;
+}
+// Try to accept a connection in 30 seconds.
+public static SSLSocket accept(SSLServerSocket sslServerSocket)
+throws IOException {
+return accept(sslServerSocket, SERVER_TIMEOUT);
+}
+public static SSLSocket accept(SSLServerSocket sslServerSocket, int timeout)
+throws IOException {
+try {
+sslServerSocket.setSoTimeout(timeout);
+return (SSLSocket) sslServerSocket.accept();
+} catch (SocketTimeoutException ste) {
+print("Warning: ", ste);
+return null;
+}
+}
+public SSLSocketTemplate setSeparateServerThread(
+boolean separateServerThread) {
+this.separateServerThread = separateServerThread;
+return this;
+}
+public SSLSocketTemplate setServerPort(int serverPort) {
+this.serverPort = serverPort;
+return this;
+}
+public int getServerPort() {
+return serverPort;
+}
+public SSLSocketTemplate setSSLContext(SSLContext context) {
+this.context = context;
+return this;
+}
+public SSLContext getSSLContext() {
+return context;
+}
+public SSLServerSocketFactory getSSLServerSocketFactory() {
+if (context != null) {
+return context.getServerSocketFactory();
+}
+return (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
+}
+public SSLSocketFactory getSSLSocketFactory() {
+if (context != null) {
+return context.getSocketFactory();
+}
+return (SSLSocketFactory) SSLSocketFactory.getDefault();
+}
+public void signalServerReady() {
+serverReadyCondition.countDown();
+}
+public void signalServerDone() {
+serverDoneCondition.countDown();
+}
+public boolean waitForClientSignal(long timeout, TimeUnit unit)
+throws InterruptedException {
+return clientReadyCondition.await(timeout, unit);
+}
+public boolean waitForClientSignal() throws InterruptedException {
+return waitForClientSignal(CLIENT_SIGNAL_TIMEOUT, TimeUnit.SECONDS);
+}
+public boolean waitForClientDone(long timeout, TimeUnit unit)
+throws InterruptedException {
+return clientDoneCondition.await(timeout, unit);
+}
+public boolean waitForClientDone() throws InterruptedException {
+return waitForClientDone(CLIENT_SIGNAL_TIMEOUT, TimeUnit.SECONDS);
+}
+public void signalClientReady() {
+clientReadyCondition.countDown();
+}
+public void signalClientDone() {
+clientDoneCondition.countDown();
+}
+public boolean waitForServerSignal(long timeout, TimeUnit unit)
+throws InterruptedException {
+return serverReadyCondition.await(timeout, unit);
+}
+public boolean waitForServerSignal() throws InterruptedException {
+return waitForServerSignal(SERVER_SIGNAL_TIMEOUT, TimeUnit.SECONDS);
+}
+public boolean waitForServerDone(long timeout, TimeUnit unit)
+throws InterruptedException {
+return serverDoneCondition.await(timeout, unit);
+}
+public boolean waitForServerDone() throws InterruptedException {
+return waitForServerDone(SERVER_SIGNAL_TIMEOUT, TimeUnit.SECONDS);
+}
+public SSLSocketTemplate setServerPeer(Peer serverPeer) {
+this.serverPeer = serverPeer;
+return this;
+}
+public Peer getServerPeer() {
+return serverPeer;
+}
+public SSLSocketTemplate setServerApplication(
+Application serverApplication) {
+this.serverApplication = serverApplication;
+return this;
+}
+public Application getServerApplication() {
+return serverApplication;
+}
+public SSLSocketTemplate setClientPeer(Peer clientPeer) {
+this.clientPeer = clientPeer;
+return this;
+}
+public Peer getClientPeer() {
+return clientPeer;
+}
+public SSLSocketTemplate setClientApplication(
+Application clientApplication) {
+this.clientApplication = clientApplication;
+return this;
+}
+public Application getClientApplication() {
+return clientApplication;
+}
+public void runTest() throws Exception {
+if (separateServerThread) {
+startServer(true, this);
+startClient(false, this);
+serverThread.join();
+} else {
+startClient(true, this);
+startServer(false, this);
+clientThread.join();
+}
+if (clientException != null || serverException != null) {
+throw new RuntimeException("Test failed");
+}
+}
+public SSLSocketTemplate() {
+serverPeer = new Peer() {
+@Override
+public void run(SSLSocketTemplate test) throws Exception {
+doServerSide(test);
+}
+};
+clientPeer = new Peer() {
+@Override
+public void run(SSLSocketTemplate test) throws Exception {
+doClientSide(test);
+}
+};
+serverApplication = new Application() {
+@Override
+public void run(SSLSocket socket, SSLSocketTemplate test)
+throws Exception {
+runServerApplication(socket);
+}
+};
+clientApplication = new Application() {
+@Override
+public void run(SSLSocket socket, SSLSocketTemplate test)
+throws Exception {
+runClientApplication(socket);
+}
+};
+}
+public static void main(String args[]) throws Exception {
+// reset the security property to make sure that the algorithms
+// and keys used in this test are not disabled.
+Security.setProperty("jdk.tls.disabledAlgorithms", "");
+// MD5 is used in this test case, don't disable MD5 algorithm.
+Security.setProperty(
+"jdk.certpath.disabledAlgorithms", "MD2, RSA keySize < 1024");
+setup();
+new SSLSocketTemplate().runTest();
+}
+/*
+* Private part.
 */
 /*
 * Define the server side of the test.
-*
+*/
-* If the server prematurely exits, serverReady will be set to true
+private static void doServerSide(SSLSocketTemplate test) throws Exception {
-* to avoid infinite hangs.
+SSLServerSocket sslServerSocket;
-*/
-void doServerSide() throws Exception {
+// kick start the server side service
-SSLServerSocketFactory sslssf =
+SSLServerSocketFactory sslssf = test.getSSLServerSocketFactory();
-(SSLServerSocketFactory)SSLServerSocketFactory.getDefault();
+sslServerSocket = (SSLServerSocket)sslssf.createServerSocket(FREE_PORT);
-try (SSLServerSocket sslServerSocket =
-(SSLServerSocket)sslssf.createServerSocket(serverPort)) {
+test.setServerPort(sslServerSocket.getLocalPort());
+print("Server is listening on port " + test.getServerPort());
-serverPort = sslServerSocket.getLocalPort();
+// Signal the client, the server is ready to accept connection.
-/*
+test.signalServerReady();
-* Signal Client, we're ready for his connect.
-*/
+// Try to accept a connection in 30 seconds.
-serverReady = true;
+SSLSocket sslSocket = accept(sslServerSocket);
+if (sslSocket == null) {
-try (SSLSocket sslSocket = (SSLSocket)sslServerSocket.accept()) {
+// Ignore the test case if no connection within 30 seconds.
-InputStream sslIS = sslSocket.getInputStream();
+print("No incoming client connection in 30 seconds. "
-OutputStream sslOS = sslSocket.getOutputStream();
++ "Ignore in server side.");
+return;
-sslIS.read();
+}
-sslOS.write(85);
+print("Server accepted connection");
-sslOS.flush();
-}
+// handle the connection
-}
+try {
+// Is it the expected client connection?
+//
+// Naughty test cases or third party routines may try to
+// connection to this server port unintentionally.  In
+// order to mitigate the impact of unexpected client
+// connections and avoid intermittent failure, it should
+// be checked that the accepted connection is really linked
+// to the expected client.
+boolean clientIsReady = test.waitForClientSignal();
+if (clientIsReady) {
+// Run the application in server side.
+print("Run server application");
+test.getServerApplication().run(sslSocket, test);
+} else {    // Otherwise, ignore
+// We don't actually care about plain socket connections
+// for TLS communication testing generally.  Just ignore
+// the test if the accepted connection is not linked to
+// the expected client or the client connection timeout
+// in 30 seconds.
+print("The client is not the expected one or timeout. "
++ "Ignore in server side.");
+}
+} finally {
+sslSocket.close();
+sslServerSocket.close();
+}
+test.signalServerDone();
+}
+/*
+* Define the server side application of the test for the specified socket.
+*/
+private static void runServerApplication(SSLSocket socket)
+throws Exception {
+// here comes the test logic
+InputStream sslIS = socket.getInputStream();
+OutputStream sslOS = socket.getOutputStream();
+sslIS.read();
+sslOS.write(85);
+sslOS.flush();
 }
 /*
 * Define the client side of the test.
-*
+*/
-* If the server prematurely exits, serverReady will be set to true
+private static void doClientSide(SSLSocketTemplate test) throws Exception {
-* to avoid infinite hangs.
-*/
+// Wait for server to get started.
-void doClientSide() throws Exception {
+//
+// The server side takes care of the issue if the server cannot
-/*
+// get started in 90 seconds.  The client side would just ignore
-* Wait for server to get started.
+// the test case if the serer is not ready.
-*/
+boolean serverIsReady = test.waitForServerSignal();
-while (!serverReady) {
+if (!serverIsReady) {
-Thread.sleep(50);
+print("The server is not ready yet in 90 seconds. "
-}
++ "Ignore in client side.");
+return;
-SSLSocketFactory sslsf =
+}
-(SSLSocketFactory)SSLSocketFactory.getDefault();
-try (SSLSocket sslSocket =
+SSLSocketFactory sslsf = test.getSSLSocketFactory();
-(SSLSocket)sslsf.createSocket("localhost", serverPort)) {
+SSLSocket sslSocket = (SSLSocket)sslsf.createSocket();
-InputStream sslIS = sslSocket.getInputStream();
-OutputStream sslOS = sslSocket.getOutputStream();
-sslOS.write(280);
-sslOS.flush();
-sslIS.read();
-}
-}
-/*
-* =============================================================
-* The remainder is just support stuff
-*/
-// use any free port by default
-volatile int serverPort = 0;
-volatile Exception serverException = null;
-volatile Exception clientException = null;
-public static void main(String[] args) throws Exception {
-String keyFilename =
-System.getProperty("test.src", ".") + "/" + pathToStores +
-"/" + keyStoreFile;
-String trustFilename =
-System.getProperty("test.src", ".") + "/" + pathToStores +
-"/" + trustStoreFile;
-System.setProperty("javax.net.ssl.keyStore", keyFilename);
-System.setProperty("javax.net.ssl.keyStorePassword", passwd);
-System.setProperty("javax.net.ssl.trustStore", trustFilename);
-System.setProperty("javax.net.ssl.trustStorePassword", passwd);
-if (debug) {
-System.setProperty("javax.net.debug", "all");
-}
-/*
-* Start the tests.
-*/
-new SSLSocketTemplate();
-}
-Thread clientThread = null;
-Thread serverThread = null;
-/*
-* Primary constructor, used to drive remainder of the test.
-*
-* Fork off the other side, then do your work.
-*/
-SSLSocketTemplate() throws Exception {
-Exception startException = null;
 try {
-if (separateServerThread) {
+try {
-startServer(true);
+sslSocket.connect(
-startClient(false);
+new InetSocketAddress("localhost",
-} else {
+test.getServerPort()), CLIENT_TIMEOUT);
-startClient(true);
+print("Client connected to server");
-startServer(false);
+} catch (IOException ioe) {
-}
+// The server side may be impacted by naughty test cases or
-} catch (Exception e) {
+// third party routines, and cannot accept connections.
-startException = e;
+//
-}
+// Just ignore the test if the connection cannot be
+// established.
-/*
+print("Cannot make a connection in 15 seconds. "
-* Wait for other side to close down.
++ "Ignore in client side.", ioe);
-*/
+return;
-if (separateServerThread) {
+}
-if (serverThread != null) {
-serverThread.join();
+// OK, here the client and server get connected.
-}
-} else {
+// Signal the server, the client is ready to communicate.
-if (clientThread != null) {
+test.signalClientReady();
-clientThread.join();
-}
+// There is still a chance in theory that the server thread may
-}
+// wait client-ready timeout and then quit.  The chance should
+// be really rare so we don't consider it until it becomes a
-/*
+// real problem.
-* When we get here, the test is pretty much over.
-* Which side threw the error?
+// Run the application in client side.
-*/
+print("Run client application");
-Exception local;
+test.getClientApplication().run(sslSocket, test);
-Exception remote;
+} finally {
+sslSocket.close();
-if (separateServerThread) {
+}
-remote = serverException;
-local = clientException;
+test.signalClientDone();
-} else {
+}
-remote = clientException;
-local = serverException;
+/*
-}
+* Define the client side application of the test for the specified socket.
+*/
-Exception exception = null;
+private static void runClientApplication(SSLSocket socket)
+throws Exception {
-/*
-* Check various exception conditions.
+InputStream sslIS = socket.getInputStream();
-*/
+OutputStream sslOS = socket.getOutputStream();
-if ((local != null) && (remote != null)) {
-// If both failed, return the curthread's exception.
+sslOS.write(280);
-local.initCause(remote);
+sslOS.flush();
-exception = local;
+sslIS.read();
-} else if (local != null) {
+}
-exception = local;
-} else if (remote != null) {
+private void startServer(boolean newThread, SSLSocketTemplate test)
-exception = remote;
+throws Exception {
-} else if (startException != null) {
-exception = startException;
-}
-/*
-* If there was an exception *AND* a startException,
-* output it.
-*/
-if (exception != null) {
-if (exception != startException && startException != null) {
-exception.addSuppressed(startException);
-}
-throw exception;
-}
-// Fall-through: no exception to throw!
-}
-void startServer(boolean newThread) throws Exception {
 if (newThread) {
 serverThread = new Thread() {
 @Override
 public void run() {
 try {
-doServerSide();
+serverPeer.run(test);
 } catch (Exception e) {
 /*
 * Our server thread just died.
 *
 * Release the client, if not active already...
 */
-System.err.println("Server died...");
+print("Server died ...", e);
-serverReady = true;
 serverException = e;
 }
 }
 };
 serverThread.start();
 } else {
 try {
-doServerSide();
+serverPeer.run(test);
 } catch (Exception e) {
+print("Server failed ...", e);
 serverException = e;
-} finally {
+}
-serverReady = true;
+}
 }
-}
-}
+private void startClient(boolean newThread, SSLSocketTemplate test)
+throws Exception {
-void startClient(boolean newThread) throws Exception {
 if (newThread) {
 clientThread = new Thread() {
 @Override
 public void run() {
 try {
-doClientSide();
+clientPeer.run(test);
 } catch (Exception e) {
 /*
 * Our client thread just died.
 */
-System.err.println("Client died...");
+print("Client died ...", e);
 clientException = e;
 }
 }
 };
 clientThread.start();
 } else {
 try {
-doClientSide();
+clientPeer.run(test);
 } catch (Exception e) {
+print("Client failed ...", e);
 clientException = e;
 }
 }
 }
 }

changeset 42155	c9b28ab5297b
parent 41595	f1213215e135
child 42164	8a725a4f3757