public HandshakeCompletedEvent(SSLSocket sock,
    SSLSession s) 
{
        super(sock);
        session = s;
}

Constructs a new HandshakeCompletedEvent.

Parameters:

sock - the SSLSocket acting as the source of the event

s - the SSLSession this event is associated with

 public String getCipherSuite() 
{
        return session.getCipherSuite();
}

Returns the cipher suite in use by the session which was produced by the handshake. (This is a convenience method for getting the ciphersuite from the SSLsession.)

 public Certificate[] getLocalCertificates() 
{
        return session.getLocalCertificates();
}

Returns the certificate(s) that were sent to the peer during handshaking. Note: This method is useful only when using certificate-based cipher suites. When multiple certificates are available for use in a handshake, the implementation chooses what it considers the "best" certificate chain available, and transmits that to the other side. This method allows the caller to know which certificate chain was actually used.

 public Principal getLocalPrincipal() 
{
        Principal principal;
        try {
            principal = session.getLocalPrincipal();
        } catch (AbstractMethodError e) {
            principal = null;
            // if the provider does not support it, fallback to local certs.
            // return the X500Principal of the end-entity cert.
            Certificate[] certs = getLocalCertificates();
            if (certs != null) {
                principal = (X500Principal)
                        ((X509Certificate)certs[0]).getSubjectX500Principal();
            }
        }
        return principal;
}

Returns the principal that was sent to the peer during handshaking.

 public X509Certificate[] getPeerCertificateChain() throws SSLPeerUnverifiedException 
{
        return session.getPeerCertificateChain();
}

Returns the identity of the peer which was identified as part of defining the session. Note: This method can be used only when using certificate-based cipher suites; using it with non-certificate-based cipher suites, such as Kerberos, will throw an SSLPeerUnverifiedException.

Note: this method exists for compatibility with previous releases. New applications should use #getPeerCertificates instead.

 public Certificate[] getPeerCertificates() throws SSLPeerUnverifiedException 
{
        return session.getPeerCertificates();
}

Returns the identity of the peer which was established as part of defining the session. Note: This method can be used only when using certificate-based cipher suites; using it with non-certificate-based cipher suites, such as Kerberos, will throw an SSLPeerUnverifiedException.

 public Principal getPeerPrincipal() throws SSLPeerUnverifiedException 
{
        Principal principal;
        try {
            principal = session.getPeerPrincipal();
        } catch (AbstractMethodError e) {
            // if the provider does not support it, fallback to peer certs.
            // return the X500Principal of the end-entity cert.
            Certificate[] certs = getPeerCertificates();
            principal = (X500Principal)
                ((X509Certificate)certs[0]).getSubjectX500Principal();
        }
        return principal;
}

Returns the identity of the peer which was established as part of defining the session.

 public SSLSession getSession() 
{
        return session;
}

Returns the session that triggered this event.

 public SSLSocket getSocket() 
{
        return (SSLSocket) getSource();
}

Returns the socket which is the source of this event. (This is a convenience function, to let applications write code without type casts.)