if (lastPrimingReadResult <= 0) {
        // Check for OpenSSL errors caused by the priming read
        long error = SSL.getLastErrorNumber();
        if (OpenSsl.isError(error)) {
            String err = SSL.getErrorString(error);
            if (logger.isDebugEnabled()) {
                logger.debug(
                        "SSL_read failed: primingReadResult: " + lastPrimingReadResult +
                                "; OpenSSL error: '" + err + '\'');
            }
           if (pendingWrittenBytesInBIO(networkBIO) > 0) {
             return NEED_WRAP_OK;
           } else {
             // There was an internal error -- shutdown
                 shutdown();
                 throw new SSLException(err);
           }
}

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.URL;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.UnrecoverableKeyException;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509ExtendedKeyManager;

import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;

public class TestHttpsConnection {

    public static final String TEST_URL = "https://test-server:8443/test.html";
    public static final String TEST_REQUEST = "Test Request";
    public static KeyManager[] kms;
    public static TrustManager[] tms;


    @BeforeClass
    public static void init() throws Exception {

        // load client private key
        KeyStore clientKeys = KeyStore.getInstance("PKCS12");
        clientKeys
                .load(new FileInputStream(
                        "test-keystore.p12"),
                        "password".toCharArray());

        kms = getKeyManagers(clientKeys, "password".toCharArray(),
                "test-key-alias");

        // load server public key
        KeyStore serverPub = KeyStore.getInstance("JKS");
        serverPub
                .load(new FileInputStream(
                        "test-truststore.jks"),
                        "password".toCharArray());
        TrustManagerFactory trustManager = TrustManagerFactory
                .getInstance("SunX509");
        trustManager.init(serverPub);
        tms = trustManager.getTrustManagers();
    }

    private static KeyManager[] getKeyManagers(KeyStore keystore,
            char[] keyPassword, String keyAlias)
            throws NoSuchAlgorithmException, UnrecoverableKeyException,
            KeyStoreException {

        KeyManagerFactory keyManagerFactory;
        KeyManager[] keyManagers;
        KeyManager keyManager;

        keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory
                .getDefaultAlgorithm());
        keyManagerFactory.init(keystore, keyPassword);
        keyManagers = keyManagerFactory.getKeyManagers();

        if (keyAlias == null || "".equals(keyAlias))
            throw new KeyStoreException("There was no alias found!");

        if (keyManagers != null) {
            for (int i = 0; i < keyManagers.length; i++) {
                keyManager = keyManagers[i];
                if (keyManager instanceof X509ExtendedKeyManager) {
                    keyManagers[i] = new AliasSelectorKeyManager(
                            (X509ExtendedKeyManager) keyManager, keyAlias);
                }
            }
        }

        return keyManagers;
    }

    @Test
    public void testSSLClientWithSocket() {
        HttpsURLConnection httpsURLConnection = null;
        try {
            URL url = new URL(TEST_URL);
            SSLContext sc = getSSLContext();
            SSLSocketFactory socketFactory = sc
                    .getSocketFactory();

            HttpsURLConnection.setDefaultSSLSocketFactory(socketFactory);
            HttpsURLConnection
                    .setDefaultHostnameVerifier(new HostnameVerifier() {
                        @Override
                        public boolean verify(String arg0, SSLSession arg1) {
                            return true;
                        }
                    });
            httpsURLConnection = (HttpsURLConnection) url.openConnection();
            httpsURLConnection.setDoOutput(true);
            httpsURLConnection.setRequestMethod("POST");
            httpsURLConnection.setRequestProperty("Content-type",
                    "text/xml; charset=utf-8");
            httpsURLConnection.setRequestProperty("Connection", "close");
            OutputStream reqStream = httpsURLConnection.getOutputStream();
            reqStream.write(TEST_REQUEST.getBytes());

            StringBuffer sb = this.getContent(httpsURLConnection
                    .getInputStream());

            if (sb != null) {
                Assert.assertTrue(sb.length() > 0);
            } else
                Assert.fail();
        } catch (Exception e) {
            e.printStackTrace();
            Assert.fail();
        } finally {
            if (httpsURLConnection != null)
                httpsURLConnection.disconnect();
        }
    }

    private StringBuffer getContent(InputStream inputStream) {
        if (inputStream != null) {
            try {
                StringBuffer sb = new StringBuffer();
                String s;
                BufferedReader br = new BufferedReader(new InputStreamReader(
                        inputStream));

                while ((s = br.readLine()) != null) {
                    sb.append(s);
                }
                br.close();
                return sb;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return null;
    }

    private SSLContext getSSLContext() throws Exception {
        SSLContext sc = SSLContext.getInstance("TLSv1.2");
        sc.init(kms, tms, new SecureRandom());
        return sc;
    }
}

import java.net.Socket;
import java.security.Principal;
import java.security.PrivateKey;
import java.security.cert.X509Certificate;

import javax.net.ssl.SSLEngine;
import javax.net.ssl.X509ExtendedKeyManager;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class AliasSelectorKeyManager extends X509ExtendedKeyManager {

    private static Logger log = LogManager
            .getLogger(AliasSelectorKeyManager.class);

    private final X509ExtendedKeyManager sourceKeyManager;
    private final String expectedAlias;

    public AliasSelectorKeyManager(X509ExtendedKeyManager keyManager,
            String expectedAlias) {
        if (keyManager == null)
            throw new IllegalArgumentException("Source Keymanger can not be null!");
        this.sourceKeyManager = keyManager;
        this.expectedAlias = expectedAlias;
    }

    @Override
    public String chooseEngineServerAlias(String keyType, Principal[] issuers,
            SSLEngine engine) {
        log.entry(keyType, issuers, engine);
        return log.exit(expectedAlias == null ? this.sourceKeyManager
                .chooseEngineServerAlias(keyType, issuers, engine)
                : expectedAlias);
    }

    @Override
    public String chooseEngineClientAlias(String[] keyTypes,
            Principal[] issuers, SSLEngine engine) {
        log.entry(keyTypes, issuers, engine);
        return log.exit(expectedAlias == null ? this.sourceKeyManager
                .chooseEngineClientAlias(keyTypes, issuers, engine)
                : expectedAlias);
    }

    @Override
    public String chooseServerAlias(String keyType, Principal[] issuers,
            Socket socket) {
        log.entry(keyType, issuers, socket);
        return log.exit(expectedAlias == null ? this.sourceKeyManager
                .chooseServerAlias(keyType, issuers, socket) : expectedAlias);
    }

    @Override
    public String chooseClientAlias(final String[] keyTypes,
            Principal[] issuers, final Socket socket) {
        log.entry(keyTypes, issuers, socket);
        return log.exit(expectedAlias == null ? this.sourceKeyManager
                .chooseClientAlias(keyTypes, issuers, socket) : expectedAlias);
    }

    @Override
    public X509Certificate[] getCertificateChain(String alias) {
        log.entry(alias);
        return log.exit(sourceKeyManager.getCertificateChain(alias));
    }

    @Override
    public String[] getClientAliases(final String keyType,
            final Principal[] issuers) {
        log.entry();
        return log.exit(this.sourceKeyManager
                .getClientAliases(keyType, issuers));
    }

    @Override
    public PrivateKey getPrivateKey(String alias) {
        log.entry();
        return log.exit(sourceKeyManager.getPrivateKey(alias));
    }

    @Override
    public String[] getServerAliases(String keyType, Principal[] issuers) {
        log.entry();
        return log.exit(sourceKeyManager.getServerAliases(keyType,
                issuers));
    }

}

private void wrapNonAppData(ChannelHandlerContext ctx, boolean inUnwrap)
            throws SSLException {
        ByteBuf out = null;
        ByteBufAllocator alloc = ctx.alloc();
        try {
            for (;;) {
                if (out == null) {
                    out = allocateOutNetBuf(ctx, 0);
                }
                SSLEngineResult result = wrap(alloc, engine,
                        Unpooled.EMPTY_BUFFER, out);

                if (result.bytesProduced() > 0) {
                    ctx.write(out);
                    if (inUnwrap) {
                        needsFlush = true;
                    }
                    out = null;
                }

                switch (result.getHandshakeStatus()) {
                case FINISHED:
                    setHandshakeSuccess();
                    break;
                case NEED_TASK:
                    runDelegatedTasks();
                    break;
                case NEED_UNWRAP:
                    if (!inUnwrap) {
                        unwrapNonAppData(ctx);
                    }
                    break;
                case NEED_WRAP:
                    break;
                case NOT_HANDSHAKING:
                    setHandshakeSuccessIfStillHandshaking();
                    // Workaround for TLS False Start problem reported at:
                    // https://github.com/netty/netty/issues/1108#issuecomment-14266970
                    if (!inUnwrap) {
                        unwrapNonAppData(ctx);
                    }
                    break;
                default:
                    throw new IllegalStateException(
                            "Unknown handshake status: "
                                    + result.getHandshakeStatus());
                }

                if (result.bytesProduced() == 0) {
                    break;
                }

                // It should not consume empty buffers when it is not
                // handshaking
                // Fix for Android, where it was encrypting empty buffers even
                // when not handshaking
                if (result.bytesConsumed() == 0
                        && result.getHandshakeStatus() == HandshakeStatus.NOT_HANDSHAKING) {
                    break;
                }
            }
        } catch (SSLException e) {
            /** TLS ALERT FIX START */
            ctx.flush();
            /** TLS ALERT FIX END */
            setHandshakeFailure(ctx, e);
            throw e;
        } finally {
            if (out != null) {
                out.release();
            }
        }
    }