@Override
public void run() {
    // Don't need to synchronize, as it only runs in one thread.
    for (Map.Entry<HandshakeCompletedListener,
            AccessControlContext> entry : targets) {
        final HandshakeCompletedListener listener = entry.getKey();
        AccessControlContext acc = entry.getValue();
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            @Override
            public Void run() {
                listener.handshakeCompleted(event);
                return null;
            }
        }, acc);
    }
}
 

@Override
@SuppressWarnings({"unchecked", "CloneDeclaresCloneNotSupported"})
public Object clone() {
    // Note that only references to the configurations are copied.
    try {
        SSLConfiguration config = (SSLConfiguration)super.clone();
        if (handshakeListeners != null) {
            config.handshakeListeners =
                (HashMap<HandshakeCompletedListener, AccessControlContext>)
                        handshakeListeners.clone();
        }

        return config;
    } catch (CloneNotSupportedException cnse) {
        // unlikely
    }

    return null;    // unlikely
}
 

@Override
public void run() {
    // Don't need to synchronize, as it only runs in one thread.
    for (Map.Entry<HandshakeCompletedListener,
            AccessControlContext> entry : targets) {
        final HandshakeCompletedListener listener = entry.getKey();
        AccessControlContext acc = entry.getValue();
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            @Override
            public Void run() {
                listener.handshakeCompleted(event);
                return null;
            }
        }, acc);
    }
}
 

@Override
@SuppressWarnings({"unchecked", "CloneDeclaresCloneNotSupported"})
public Object clone() {
    // Note that only references to the configurations are copied.
    try {
        SSLConfiguration config = (SSLConfiguration)super.clone();
        if (handshakeListeners != null) {
            config.handshakeListeners =
                (HashMap<HandshakeCompletedListener, AccessControlContext>)
                        handshakeListeners.clone();
        }

        return config;
    } catch (CloneNotSupportedException cnse) {
        // unlikely
    }

    return null;    // unlikely
}
 

@Override
public synchronized void addHandshakeCompletedListener(
        HandshakeCompletedListener listener) {
    if (listener == null) {
        throw new IllegalArgumentException("listener is null");
    }

    conContext.sslConfig.addHandshakeCompletedListener(listener);
}
 

@Override
public synchronized void removeHandshakeCompletedListener(
        HandshakeCompletedListener listener) {
    if (listener == null) {
        throw new IllegalArgumentException("listener is null");
    }

    conContext.sslConfig.removeHandshakeCompletedListener(listener);
}
 

void addHandshakeCompletedListener(
        HandshakeCompletedListener listener) {

    if (handshakeListeners == null) {
        handshakeListeners = new HashMap<>(4);
    }

    handshakeListeners.put(listener, AccessController.getContext());
}
 

void removeHandshakeCompletedListener(
        HandshakeCompletedListener listener) {

    if (handshakeListeners == null) {
        throw new IllegalArgumentException("no listeners");
    }

    if (handshakeListeners.remove(listener) == null) {
        throw new IllegalArgumentException("listener not registered");
    }

    if (handshakeListeners.isEmpty()) {
        handshakeListeners = null;
    }
}
 

@Override
public void addHandshakeCompletedListener(
        HandshakeCompletedListener listener) {
    if (listener == null) {
        throw new IllegalArgumentException("listener is null");
    }

    socketLock.lock();
    try {
        conContext.sslConfig.addHandshakeCompletedListener(listener);
    } finally {
        socketLock.unlock();
    }
}
 

@Override
public void removeHandshakeCompletedListener(
        HandshakeCompletedListener listener) {
    if (listener == null) {
        throw new IllegalArgumentException("listener is null");
    }

    socketLock.lock();
    try {
        conContext.sslConfig.removeHandshakeCompletedListener(listener);
    } finally {
        socketLock.unlock();
    }
}
 

void addHandshakeCompletedListener(
        HandshakeCompletedListener listener) {

    if (handshakeListeners == null) {
        handshakeListeners = new HashMap<>(4);
    }

    handshakeListeners.put(listener, AccessController.getContext());
}
 

void removeHandshakeCompletedListener(
        HandshakeCompletedListener listener) {

    if (handshakeListeners == null) {
        throw new IllegalArgumentException("no listeners");
    }

    if (handshakeListeners.remove(listener) == null) {
        throw new IllegalArgumentException("listener not registered");
    }

    if (handshakeListeners.isEmpty()) {
        handshakeListeners = null;
    }
}
 

/**
 * Create an SSL client socket using the IOR-encoded
 * security characteristics.
 * Setting want/need client auth on a client socket has no effect so all we can do is use the right host, port, ciphers
 *
 * @param host     The target host name.
 * @param port     The target connection port.
 *
 * @return An appropriately configured client SSLSocket.
 * @exception IOException if ssl socket can't be obtained and configured.
 */
private Socket createSSLSocket(String host, int port, int requires, int supports) throws IOException {
    SSLSocketFactory factory = getSocketFactory();
    SSLSocket socket = (SSLSocket) factory.createSocket(host, port);

    socket.setSoTimeout(SOCKET_TIMEOUT_MS);

    // get a set of cipher suites appropriate for this connections requirements.
    // We request this for each connection, since the outgoing IOR's requirements may be different from
    // our server listener requirements.
    String[] iorSuites = SSLCipherSuiteDatabase.getCipherSuites(requires, supports, factory.getSupportedCipherSuites());
    socket.setEnabledCipherSuites(iorSuites);
    if (log.isDebugEnabled()) {
        log.debug("Created SSL socket to " + host + ":" + port);
        log.debug("    cipher suites:");

        for (int i = 0; i < iorSuites.length; i++) {
            log.debug("    " + iorSuites[i]);
        }
        socket.addHandshakeCompletedListener(new HandshakeCompletedListener() {

            public void handshakeCompleted(HandshakeCompletedEvent handshakeCompletedEvent) {
                Certificate[] certs = handshakeCompletedEvent.getLocalCertificates();
                if (certs != null) {
                    log.debug("handshake returned local certs count: " + certs.length);
                    for (int i = 0; i < certs.length; i++) {
                        Certificate cert = certs[i];
                        log.debug("cert: " + cert.toString());
                    }
                } else {
                    log.debug("handshake returned no local certs");
                }
            }
        });
    }
    return socket;
}
 

/**
 * Constructor
 *
 * @param sslSocketFactory The actual SSLSocketFactory (used by this class)
 * @param handshakeListener The class that handles "handshake completed" events
 */
public CustomSslSocketFactory(SSLSocketFactory sslSocketFactory, HandshakeCompletedListener handshakeListener,
		boolean sniEnabled) {
	this.sslSocketFactory = sslSocketFactory;
	this.handshakeListener = handshakeListener;
	this.sniEnabled = sniEnabled;
}
 

/**
 * javax.net.ssl.SSLSocket#addHandshakeCompletedListener(HandshakeCompletedListener listener)
 */
// AndroidOnly("RI doesn't throw the specified IAE")
public void j2objcNotImplemented_test_addHandshakeCompletedListener() throws IOException {
    SSLSocket ssl = getSSLSocket();
    HandshakeCompletedListener ls = new HandshakeCL();
    try {
        ssl.addHandshakeCompletedListener(null);
        fail();
    } catch (IllegalArgumentException expected) {
    }
    ssl.addHandshakeCompletedListener(ls);
    ssl.close();
}
 

public void test_SSLSocket_HandshakeCompletedListener_RuntimeException() throws Exception {
    final Thread self = Thread.currentThread();
    final UncaughtExceptionHandler original = self.getUncaughtExceptionHandler();

    final RuntimeException expectedException = new RuntimeException("expected");
    final TestUncaughtExceptionHandler test = new TestUncaughtExceptionHandler();
    self.setUncaughtExceptionHandler(test);

    final TestSSLContext c = TestSSLContext.create();
    final SSLSocket client = (SSLSocket)
            c.clientContext.getSocketFactory().createSocket(c.host, c.port);
    final SSLSocket server = (SSLSocket) c.serverSocket.accept();
    ExecutorService executor = Executors.newSingleThreadExecutor();
    Future<Void> future = executor.submit(new Callable<Void>() {
        @Override public Void call() throws Exception {
            server.startHandshake();
            return null;
        }
    });
    executor.shutdown();
    client.addHandshakeCompletedListener(new HandshakeCompletedListener() {
        public void handshakeCompleted(HandshakeCompletedEvent event) {
            throw expectedException;
        }
    });
    client.startHandshake();
    future.get();
    client.close();
    server.close();
    c.close();

    assertSame(expectedException, test.actualException);
    self.setUncaughtExceptionHandler(original);
}
 

@Override
public void addHandshakeCompletedListener(HandshakeCompletedListener listener) {}
 

@Override
public void removeHandshakeCompletedListener(HandshakeCompletedListener listener) {}
 

NotifyHandshake(
        Map<HandshakeCompletedListener,AccessControlContext> listeners,
        HandshakeCompletedEvent event) {
    this.targets = new HashSet<>(listeners.entrySet());     // clone
    this.event = event;
}
 

@Override
public void addHandshakeCompletedListener(HandshakeCompletedListener listener) {
    socket.addHandshakeCompletedListener(listener);
}
 

@Override
public void removeHandshakeCompletedListener(HandshakeCompletedListener listener) {
    socket.removeHandshakeCompletedListener(listener);
}
 

@Override
public void addHandshakeCompletedListener(HandshakeCompletedListener listener) {
    delegate.addHandshakeCompletedListener(listener);
}
 

@Override
public void removeHandshakeCompletedListener(HandshakeCompletedListener listener) {
    delegate.removeHandshakeCompletedListener(listener);
}
 

@Override
public void addHandshakeCompletedListener(HandshakeCompletedListener listener) {
    delegate.addHandshakeCompletedListener(listener);
}
 

@Override
public void removeHandshakeCompletedListener(HandshakeCompletedListener listener) {
    delegate.removeHandshakeCompletedListener(listener);
}
 

@Test
public void testRenegotiateFail() throws Exception {

    // If RFC5746 is supported, renegotiation will always work (and will
    // always be secure)
    if (TesterSupport.RFC_5746_SUPPORTED) {
        return;
    }

    Tomcat tomcat = getTomcatInstance();

    File appDir = new File(getBuildDirectory(), "webapps/examples");
    // app dir is relative to server home
    tomcat.addWebapp(null, "/examples", appDir.getAbsolutePath());

    TesterSupport.initSsl(tomcat);

    // Default - MITM attack prevented

    tomcat.start();
    SSLContext sslCtx = SSLContext.getInstance("TLS");
    sslCtx.init(null, TesterSupport.getTrustManagers(), null);
    SSLSocketFactory socketFactory = sslCtx.getSocketFactory();
    SSLSocket socket = (SSLSocket) socketFactory.createSocket("localhost", getPort());

    socket.addHandshakeCompletedListener(new HandshakeCompletedListener() {
        @Override
        public void handshakeCompleted(HandshakeCompletedEvent event) {
            handshakeDone = true;
        }
    });

    OutputStream os = socket.getOutputStream();
    os.write("GET /examples/servlets/servlet/HelloWorldExample HTTP/1.0\n".getBytes());
    os.flush();


    InputStream is = socket.getInputStream();

    // Make sure the NIO connector has read the request before the handshake
    Thread.sleep(100);

    socket.startHandshake();

    os = socket.getOutputStream();

    try {
        os.write("Host: localhost\n\n".getBytes());
    } catch (IOException ex) {
        ex.printStackTrace();
        fail("Re-negotiation failed");
    }
    Reader r = new InputStreamReader(is);
    BufferedReader br = new BufferedReader(r);
    String line = br.readLine();
    while (line != null) {
        // For testing System.out.println(line);
        line = br.readLine();
    }

    if (!handshakeDone) {
        // success - we timed-out without handshake
        return;
    }

    fail("Re-negotiation worked");
}
 

NotifyHandshake(
        Map<HandshakeCompletedListener,AccessControlContext> listeners,
        HandshakeCompletedEvent event) {
    this.targets = new HashSet<>(listeners.entrySet());     // clone
    this.event = event;
}
 

@Override
public void addHandshakeCompletedListener(
        HandshakeCompletedListener listener) {
    sock.addHandshakeCompletedListener(listener);
}
 

@Override
public void removeHandshakeCompletedListener(
        HandshakeCompletedListener listener) {
    sock.removeHandshakeCompletedListener(listener);
}
 

@Override
public void addHandshakeCompletedListener(
        HandshakeCompletedListener listener) {
}