You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hc.apache.org by ol...@apache.org on 2024/06/04 09:33:35 UTC

(httpcomponents-core) branch HTTPCLIENT-2328 created (now fc093c403)

This is an automated email from the ASF dual-hosted git repository.

olegk pushed a change to branch HTTPCLIENT-2328
in repository https://gitbox.apache.org/repos/asf/httpcomponents-core.git


      at fc093c403 HTTPCLIENT-2328: Blocking i/o connections to check if the opposite TLS endpoint has been closed by the opposite endpoint while writing out request body

This branch includes the following new commits:

     new 884f28014 More flexible TLS layer initialization by the classic HTTP server bootstrap
     new 3277ffe85 HTTPCLIENT-2328: Better control over the TLS layer of blocking connections. TLS layer no longer automatically closes the underlying network socket. Connections close the network socket manually after TLS session termination.
     new fc093c403 HTTPCLIENT-2328: Blocking i/o connections to check if the opposite TLS endpoint has been closed by the opposite endpoint while writing out request body

The 3 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.



(httpcomponents-core) 03/03: HTTPCLIENT-2328: Blocking i/o connections to check if the opposite TLS endpoint has been closed by the opposite endpoint while writing out request body

Posted by ol...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

olegk pushed a commit to branch HTTPCLIENT-2328
in repository https://gitbox.apache.org/repos/asf/httpcomponents-core.git

commit fc093c403ef4cbee9e0c6100fabe5a5e2ff73efc
Author: Oleg Kalnichevski <ol...@apache.org>
AuthorDate: Tue Jun 4 09:36:22 2024 +0200

    HTTPCLIENT-2328: Blocking i/o connections to check if the opposite TLS endpoint has been closed by the opposite endpoint while writing out request body
---
 .../http/impl/io/DefaultBHttpClientConnection.java      | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpClientConnection.java b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpClientConnection.java
index 7cbf8b3ea..5cf22a0b7 100644
--- a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpClientConnection.java
+++ b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpClientConnection.java
@@ -39,6 +39,7 @@ import javax.net.ssl.SSLSocket;
 
 import org.apache.hc.core5.http.ClassicHttpRequest;
 import org.apache.hc.core5.http.ClassicHttpResponse;
+import org.apache.hc.core5.http.ConnectionClosedException;
 import org.apache.hc.core5.http.ContentLengthStrategy;
 import org.apache.hc.core5.http.HeaderElements;
 import org.apache.hc.core5.http.HttpEntity;
@@ -212,9 +213,16 @@ public class DefaultBHttpClientConnection extends BHttpConnectionBase
 
                     final OutputStream socketOutputStream = socketHolder.getOutputStream();
                     final InputStream socketInputStream = socketHolder.getInputStream();
+                    final SSLSocket sslSocket = socketHolder.getSSLSocket();
 
                     long totalBytes;
 
+                    void checkTLS(final SSLSocket sslSocket) throws IOException {
+                        if (sslSocket.isInputShutdown()) {
+                            throw new ConnectionClosedException();
+                        }
+                    }
+
                     void checkForEarlyResponse(final long totalBytesSent, final int nextWriteSize) throws IOException {
                         if (responseOutOfOrderStrategy.isEarlyResponseDetected(
                                 request,
@@ -228,6 +236,9 @@ public class DefaultBHttpClientConnection extends BHttpConnectionBase
 
                     @Override
                     public void write(final byte[] b) throws IOException {
+                        if (sslSocket != null) {
+                            checkTLS(sslSocket);
+                        }
                         if (responseOutOfOrderStrategy != null) {
                             checkForEarlyResponse(totalBytes, b.length);
                         }
@@ -237,6 +248,9 @@ public class DefaultBHttpClientConnection extends BHttpConnectionBase
 
                     @Override
                     public void write(final byte[] b, final int off, final int len) throws IOException {
+                        if (sslSocket != null) {
+                            checkTLS(sslSocket);
+                        }
                         if (responseOutOfOrderStrategy != null) {
                             checkForEarlyResponse(totalBytes, len);
                         }
@@ -246,6 +260,9 @@ public class DefaultBHttpClientConnection extends BHttpConnectionBase
 
                     @Override
                     public void write(final int b) throws IOException {
+                        if (sslSocket != null) {
+                            checkTLS(sslSocket);
+                        }
                         if (responseOutOfOrderStrategy != null) {
                             checkForEarlyResponse(totalBytes, 1);
                         }


(httpcomponents-core) 02/03: HTTPCLIENT-2328: Better control over the TLS layer of blocking connections. TLS layer no longer automatically closes the underlying network socket. Connections close the network socket manually after TLS session termination.

Posted by ol...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

olegk pushed a commit to branch HTTPCLIENT-2328
in repository https://gitbox.apache.org/repos/asf/httpcomponents-core.git

commit 3277ffe85c76be0f0c6cefeec4d1b1412d5e256d
Author: Oleg Kalnichevski <ol...@apache.org>
AuthorDate: Sun Jun 2 22:08:12 2024 +0200

    HTTPCLIENT-2328: Better control over the TLS layer of blocking connections. TLS layer no longer automatically closes the underlying network socket. Connections close the network socket manually after TLS session termination.
---
 .../classic/LoggingBHttpClientConnection.java      | 11 +++++-
 .../LoggingBHttpClientConnectionFactory.java       | 22 +++++++++--
 .../classic/LoggingBHttpServerConnection.java      | 11 +++++-
 .../LoggingBHttpServerConnectionFactory.java       | 20 ++++++++--
 .../core5/testing/classic/LoggingSocketHolder.java |  7 ++++
 .../core5/http/impl/bootstrap/HttpRequester.java   | 12 +++---
 .../core5/http/impl/bootstrap/RequestListener.java | 11 +++---
 .../hc/core5/http/impl/io/BHttpConnectionBase.java | 39 ++++++++++++++----
 .../http/impl/io/DefaultBHttpClientConnection.java |  9 +++++
 .../io/DefaultBHttpClientConnectionFactory.java    | 22 +++++++++--
 .../http/impl/io/DefaultBHttpServerConnection.java |  9 +++++
 .../io/DefaultBHttpServerConnectionFactory.java    | 25 ++++++++++--
 .../apache/hc/core5/http/impl/io/SocketHolder.java | 46 +++++++++++++++++++---
 .../hc/core5/http/io/HttpConnectionFactory.java    | 13 ++++++
 14 files changed, 216 insertions(+), 41 deletions(-)

diff --git a/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingBHttpClientConnection.java b/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingBHttpClientConnection.java
index 7fcdd4afc..87fbed832 100644
--- a/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingBHttpClientConnection.java
+++ b/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingBHttpClientConnection.java
@@ -33,6 +33,8 @@ import java.nio.charset.CharsetDecoder;
 import java.nio.charset.CharsetEncoder;
 import java.util.concurrent.atomic.AtomicLong;
 
+import javax.net.ssl.SSLSocket;
+
 import org.apache.hc.core5.http.ClassicHttpRequest;
 import org.apache.hc.core5.http.ClassicHttpResponse;
 import org.apache.hc.core5.http.ContentLengthStrategy;
@@ -46,8 +48,8 @@ import org.apache.hc.core5.http.message.RequestLine;
 import org.apache.hc.core5.http.message.StatusLine;
 import org.apache.hc.core5.io.CloseMode;
 import org.apache.hc.core5.util.Identifiable;
-import org.slf4j.LoggerFactory;
 import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class LoggingBHttpClientConnection extends DefaultBHttpClientConnection implements Identifiable {
 
@@ -105,6 +107,13 @@ public class LoggingBHttpClientConnection extends DefaultBHttpClientConnection i
         super.bind(this.wire.isEnabled() ? new LoggingSocketHolder(socket, wire) : new SocketHolder(socket));
     }
 
+    /**
+     * @since 5.3
+     */
+    public void bind(final SSLSocket sslSocket, final Socket baseSocket) throws IOException {
+        super.bind(this.wire.isEnabled() ? new LoggingSocketHolder(sslSocket, baseSocket, wire) : new SocketHolder(sslSocket, baseSocket));
+    }
+
     @Override
     protected void onResponseReceived(final ClassicHttpResponse response) {
         if (response != null && this.headerLog.isDebugEnabled()) {
diff --git a/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingBHttpClientConnectionFactory.java b/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingBHttpClientConnectionFactory.java
index 40ed703fa..cb1a5d172 100644
--- a/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingBHttpClientConnectionFactory.java
+++ b/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingBHttpClientConnectionFactory.java
@@ -30,6 +30,8 @@ package org.apache.hc.core5.testing.classic;
 import java.io.IOException;
 import java.net.Socket;
 
+import javax.net.ssl.SSLSocket;
+
 import org.apache.hc.core5.http.ClassicHttpRequest;
 import org.apache.hc.core5.http.ClassicHttpResponse;
 import org.apache.hc.core5.http.ContentLengthStrategy;
@@ -85,9 +87,8 @@ public class LoggingBHttpClientConnectionFactory implements HttpConnectionFactor
         this(null, null, null, null, null, null);
     }
 
-    @Override
-    public LoggingBHttpClientConnection createConnection(final Socket socket) throws IOException {
-        final LoggingBHttpClientConnection conn = new LoggingBHttpClientConnection(
+    LoggingBHttpClientConnection createDetached() {
+        return new LoggingBHttpClientConnection(
                 http1Config,
                 CharCodingSupport.createDecoder(charCodingConfig),
                 CharCodingSupport.createEncoder(charCodingConfig),
@@ -95,8 +96,23 @@ public class LoggingBHttpClientConnectionFactory implements HttpConnectionFactor
                 outgoingContentStrategy,
                 requestWriterFactory,
                 responseParserFactory);
+    }
+
+    @Override
+    public LoggingBHttpClientConnection createConnection(final Socket socket) throws IOException {
+        final LoggingBHttpClientConnection conn = createDetached();
         conn.bind(socket);
         return conn;
     }
 
+    /**
+     * @since 5.3
+     */
+    @Override
+    public LoggingBHttpClientConnection createConnection(final SSLSocket sslSocket, final Socket socket) throws IOException {
+        final LoggingBHttpClientConnection conn = createDetached();
+        conn.bind(sslSocket, socket);
+        return conn;
+    }
+
 }
diff --git a/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingBHttpServerConnection.java b/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingBHttpServerConnection.java
index 94ed2f38e..b275a0559 100644
--- a/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingBHttpServerConnection.java
+++ b/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingBHttpServerConnection.java
@@ -33,6 +33,8 @@ import java.nio.charset.CharsetDecoder;
 import java.nio.charset.CharsetEncoder;
 import java.util.concurrent.atomic.AtomicLong;
 
+import javax.net.ssl.SSLSocket;
+
 import org.apache.hc.core5.http.ClassicHttpRequest;
 import org.apache.hc.core5.http.ClassicHttpResponse;
 import org.apache.hc.core5.http.ContentLengthStrategy;
@@ -46,8 +48,8 @@ import org.apache.hc.core5.http.message.RequestLine;
 import org.apache.hc.core5.http.message.StatusLine;
 import org.apache.hc.core5.io.CloseMode;
 import org.apache.hc.core5.util.Identifiable;
-import org.slf4j.LoggerFactory;
 import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 public class LoggingBHttpServerConnection extends DefaultBHttpServerConnection implements Identifiable {
 
     private static final AtomicLong COUNT = new AtomicLong();
@@ -105,6 +107,13 @@ public class LoggingBHttpServerConnection extends DefaultBHttpServerConnection i
         super.bind(this.wire.isEnabled() ? new LoggingSocketHolder(socket, wire) : new SocketHolder(socket));
     }
 
+    /**
+     * @since 5.3
+     */
+    public void bind(final SSLSocket sslSocket, final Socket baseSocket) throws IOException {
+        super.bind(this.wire.isEnabled() ? new LoggingSocketHolder(sslSocket, baseSocket, wire) : new SocketHolder(sslSocket, baseSocket));
+    }
+
     @Override
     protected void onRequestReceived(final ClassicHttpRequest request) {
         if (request != null && this.headerLog.isDebugEnabled()) {
diff --git a/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingBHttpServerConnectionFactory.java b/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingBHttpServerConnectionFactory.java
index 8e9a2aa7d..0a97e4861 100644
--- a/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingBHttpServerConnectionFactory.java
+++ b/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingBHttpServerConnectionFactory.java
@@ -93,9 +93,8 @@ public class LoggingBHttpServerConnectionFactory implements HttpConnectionFactor
         this(null, null, null, null, null, null, null);
     }
 
-    @Override
-    public LoggingBHttpServerConnection createConnection(final Socket socket) throws IOException {
-        final LoggingBHttpServerConnection conn = new LoggingBHttpServerConnection(
+    LoggingBHttpServerConnection createDetached(final Socket socket) {
+        return new LoggingBHttpServerConnection(
                 scheme != null ? scheme : (socket instanceof SSLSocket ? URIScheme.HTTPS.id : URIScheme.HTTP.id),
                 http1Config,
                 CharCodingSupport.createDecoder(charCodingConfig),
@@ -104,8 +103,23 @@ public class LoggingBHttpServerConnectionFactory implements HttpConnectionFactor
                 outgoingContentStrategy,
                 requestParserFactory,
                 responseWriterFactory);
+    }
+
+    @Override
+    public LoggingBHttpServerConnection createConnection(final Socket socket) throws IOException {
+        final LoggingBHttpServerConnection conn = createDetached(socket);
         conn.bind(socket);
         return conn;
     }
 
+    /**
+     * @since 5.3
+     */
+    @Override
+    public LoggingBHttpServerConnection createConnection(final SSLSocket sslSocket, final Socket socket) throws IOException {
+        final LoggingBHttpServerConnection conn = createDetached(socket);
+        conn.bind(sslSocket, socket);
+        return conn;
+    }
+
 }
diff --git a/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingSocketHolder.java b/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingSocketHolder.java
index 06dbd78a0..350a65625 100644
--- a/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingSocketHolder.java
+++ b/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/LoggingSocketHolder.java
@@ -32,12 +32,19 @@ import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.Socket;
 
+import javax.net.ssl.SSLSocket;
+
 import org.apache.hc.core5.http.impl.io.SocketHolder;
 
 class LoggingSocketHolder extends SocketHolder {
 
     private final Wire wire;
 
+    LoggingSocketHolder(final SSLSocket sslSocket, final Socket baseSocket, final Wire wire) {
+        super(sslSocket, baseSocket);
+        this.wire = wire;
+    }
+
     LoggingSocketHolder(final Socket socket, final Wire wire) {
         super(socket);
         this.wire = wire;
diff --git a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/HttpRequester.java b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/HttpRequester.java
index 6c7fd18c1..51e60b7c0 100644
--- a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/HttpRequester.java
+++ b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/HttpRequester.java
@@ -238,7 +238,7 @@ public class HttpRequester implements ConnPoolControl<HttpHost>, ModalCloseable
         }
     }
 
-    private Socket createSocket(final HttpHost targetHost) throws IOException {
+    private HttpClientConnection createConnection(final HttpHost targetHost) throws IOException {
         final Socket sock;
         if (socketConfig.getSocksProxyAddress() != null) {
             sock = new Socket(new Proxy(Proxy.Type.SOCKS, socketConfig.getSocksProxyAddress()));
@@ -264,7 +264,7 @@ public class HttpRequester implements ConnPoolControl<HttpHost>, ModalCloseable
         sock.connect(targetAddress, socketConfig.getSoTimeout().toMillisecondsIntBound());
         if (URIScheme.HTTPS.same(targetHost.getSchemeName())) {
             final SSLSocket sslSocket = (SSLSocket) sslSocketFactory.createSocket(
-                    sock, targetHost.getHostName(), targetAddress.getPort(), true);
+                    sock, targetHost.getHostName(), targetAddress.getPort(), false);
             if (this.sslSetupHandler != null) {
                 final SSLParameters sslParameters = sslSocket.getSSLParameters();
                 this.sslSetupHandler.execute(sslParameters);
@@ -279,13 +279,14 @@ public class HttpRequester implements ConnPoolControl<HttpHost>, ModalCloseable
                 if (sslSessionVerifier != null) {
                     sslSessionVerifier.verify(targetHost, session);
                 }
+                return connectFactory.createConnection(sslSocket, sock);
             } catch (final IOException ex) {
                 Closer.closeQuietly(sslSocket);
                 throw ex;
             }
-            return sslSocket;
+        } else {
+            return connectFactory.createConnection(sock);
         }
-        return sock;
     }
 
     public ClassicHttpResponse execute(
@@ -313,8 +314,7 @@ public class HttpRequester implements ConnPoolControl<HttpHost>, ModalCloseable
         try {
             HttpClientConnection connection = poolEntry.getConnection();
             if (connection == null) {
-                final Socket socket = createSocket(targetHost);
-                connection = connectFactory.createConnection(socket);
+                connection = createConnection(targetHost);
                 poolEntry.assignConnection(connection);
             }
             if (request.getAuthority() == null) {
diff --git a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/RequestListener.java b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/RequestListener.java
index 4b6302d5a..f37fabb5a 100644
--- a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/RequestListener.java
+++ b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/RequestListener.java
@@ -78,7 +78,7 @@ class RequestListener implements Runnable {
         this.terminated = new AtomicBoolean(false);
     }
 
-    private Socket createSocket(final Socket socket) throws IOException {
+    private HttpServerConnection createConnection(final Socket socket) throws IOException {
         socket.setSoTimeout(this.socketConfig.getSoTimeout().toMillisecondsIntBound());
         socket.setKeepAlive(this.socketConfig.isSoKeepAlive());
         socket.setTcpNoDelay(this.socketConfig.isTcpNoDelay());
@@ -92,7 +92,7 @@ class RequestListener implements Runnable {
             socket.setSoLinger(true, this.socketConfig.getSoLinger().toSecondsIntBound());
         }
         if (!(socket instanceof SSLSocket) && sslSocketFactory != null) {
-            final SSLSocket sslSocket = (SSLSocket) sslSocketFactory.createSocket(socket, null, -1, true);
+            final SSLSocket sslSocket = (SSLSocket) sslSocketFactory.createSocket(socket, null, -1, false);
             sslSocket.setUseClientMode(false);
             if (this.sslSetupHandler != null) {
                 final SSLParameters sslParameters = sslSocket.getSSLParameters();
@@ -105,13 +105,13 @@ class RequestListener implements Runnable {
                 if (session == null) {
                     throw new SSLHandshakeException("SSL session not available");
                 }
-                return sslSocket;
+                return this.connectionFactory.createConnection(sslSocket, socket);
             } catch (final IOException ex) {
                 Closer.closeQuietly(sslSocket);
                 throw ex;
             }
         } else {
-            return socket;
+            return this.connectionFactory.createConnection(socket);
         }
     }
 
@@ -119,8 +119,7 @@ class RequestListener implements Runnable {
     public void run() {
         try {
             while (!isTerminated() && !Thread.interrupted()) {
-                final Socket socket = createSocket(this.serverSocket.accept());
-                final HttpServerConnection conn = this.connectionFactory.createConnection(socket);
+                final HttpServerConnection conn = createConnection(this.serverSocket.accept());
                 final Worker worker = new Worker(this.httpService, conn, this.exceptionListener);
                 this.executorService.execute(worker);
             }
diff --git a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/BHttpConnectionBase.java b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/BHttpConnectionBase.java
index edfbbcd42..8e88f22d9 100644
--- a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/BHttpConnectionBase.java
+++ b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/BHttpConnectionBase.java
@@ -233,15 +233,34 @@ class BHttpConnectionBase implements BHttpConnection {
     public void close(final CloseMode closeMode) {
         final SocketHolder socketHolder = this.socketHolderRef.getAndSet(null);
         if (socketHolder != null) {
-            final Socket socket = socketHolder.getSocket();
-            try {
-                if (closeMode == CloseMode.IMMEDIATE) {
+            final SSLSocket sslSocket = socketHolder.getSSLSocket();
+            final Socket baseSocket = socketHolder.getBaseSocket();
+            if (closeMode == CloseMode.IMMEDIATE) {
+                try {
                     // force abortive close (RST)
-                    socket.setSoLinger(true, 0);
+                    baseSocket.setSoLinger(true, 0);
+                } catch (final IOException ignore) {
+                } finally {
+                    Closer.closeQuietly(baseSocket);
+                }
+            } else {
+                // Close TLS layer first.
+                try {
+                    if (sslSocket != null) {
+                        try {
+                            if (!sslSocket.isOutputShutdown()) {
+                                sslSocket.shutdownOutput();
+                            }
+                            if (!sslSocket.isInputShutdown()) {
+                                sslSocket.shutdownInput();
+                            }
+                            sslSocket.close();
+                        } catch (final IOException ignore) {
+                        }
+                    }
+                } finally {
+                    Closer.closeQuietly(baseSocket);
                 }
-            } catch (final IOException ignore) {
-            } finally {
-                Closer.closeQuietly(socket);
             }
         }
     }
@@ -250,9 +269,13 @@ class BHttpConnectionBase implements BHttpConnection {
     public void close() throws IOException {
         final SocketHolder socketHolder = this.socketHolderRef.getAndSet(null);
         if (socketHolder != null) {
-            try (final Socket socket = socketHolder.getSocket()) {
+            try (final Socket baseSocket = socketHolder.getBaseSocket()) {
                 this.inBuffer.clear();
                 this.outbuffer.flush(socketHolder.getOutputStream());
+                final SSLSocket sslSocket = socketHolder.getSSLSocket();
+                if (sslSocket != null) {
+                    sslSocket.close();
+                }
             }
         }
     }
diff --git a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpClientConnection.java b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpClientConnection.java
index 6b0f338c9..7cbf8b3ea 100644
--- a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpClientConnection.java
+++ b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpClientConnection.java
@@ -35,6 +35,8 @@ import java.nio.charset.CharsetDecoder;
 import java.nio.charset.CharsetEncoder;
 import java.util.Iterator;
 
+import javax.net.ssl.SSLSocket;
+
 import org.apache.hc.core5.http.ClassicHttpRequest;
 import org.apache.hc.core5.http.ClassicHttpResponse;
 import org.apache.hc.core5.http.ContentLengthStrategy;
@@ -176,6 +178,13 @@ public class DefaultBHttpClientConnection extends BHttpConnectionBase
         super.bind(socket);
     }
 
+    /**
+     * @since 5.3
+     */
+    public void bind(final SSLSocket sslSocket, final Socket baseSocket) throws IOException {
+        super.bind(new SocketHolder(sslSocket, baseSocket));
+    }
+
     @Override
     public void sendRequestHeader(final ClassicHttpRequest request)
             throws HttpException, IOException {
diff --git a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpClientConnectionFactory.java b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpClientConnectionFactory.java
index 85d02b267..2f4ab30e8 100644
--- a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpClientConnectionFactory.java
+++ b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpClientConnectionFactory.java
@@ -30,6 +30,8 @@ package org.apache.hc.core5.http.impl.io;
 import java.io.IOException;
 import java.net.Socket;
 
+import javax.net.ssl.SSLSocket;
+
 import org.apache.hc.core5.annotation.Contract;
 import org.apache.hc.core5.annotation.ThreadingBehavior;
 import org.apache.hc.core5.http.ClassicHttpRequest;
@@ -114,9 +116,8 @@ public class DefaultBHttpClientConnectionFactory
         this(null, null, null, null, null, null);
     }
 
-    @Override
-    public DefaultBHttpClientConnection createConnection(final Socket socket) throws IOException {
-        final DefaultBHttpClientConnection conn = new DefaultBHttpClientConnection(
+    DefaultBHttpClientConnection createDetached() {
+        return new DefaultBHttpClientConnection(
                 this.http1Config,
                 CharCodingSupport.createDecoder(this.charCodingConfig),
                 CharCodingSupport.createEncoder(this.charCodingConfig),
@@ -125,10 +126,25 @@ public class DefaultBHttpClientConnectionFactory
                 this.responseOutOfOrderStrategy,
                 this.requestWriterFactory,
                 this.responseParserFactory);
+    }
+
+    @Override
+    public DefaultBHttpClientConnection createConnection(final Socket socket) throws IOException {
+        final DefaultBHttpClientConnection conn = createDetached();
         conn.bind(socket);
         return conn;
     }
 
+    /**
+     * @since 5.3
+     */
+    @Override
+    public DefaultBHttpClientConnection createConnection(final SSLSocket sslSocket, final Socket socket) throws IOException {
+        final DefaultBHttpClientConnection conn = createDetached();
+        conn.bind(sslSocket, socket);
+        return conn;
+    }
+
     /**
      * Create a new {@link Builder}.
      *
diff --git a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpServerConnection.java b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpServerConnection.java
index 7a72842da..03a3693e7 100644
--- a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpServerConnection.java
+++ b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpServerConnection.java
@@ -33,6 +33,8 @@ import java.net.Socket;
 import java.nio.charset.CharsetDecoder;
 import java.nio.charset.CharsetEncoder;
 
+import javax.net.ssl.SSLSocket;
+
 import org.apache.hc.core5.http.ClassicHttpRequest;
 import org.apache.hc.core5.http.ClassicHttpResponse;
 import org.apache.hc.core5.http.ContentLengthStrategy;
@@ -130,6 +132,13 @@ public class DefaultBHttpServerConnection extends BHttpConnectionBase implements
         super.bind(socket);
     }
 
+    /**
+     * @since 5.3
+     */
+    public void bind(final SSLSocket sslSocket, final Socket baseSocket) throws IOException {
+        super.bind(new SocketHolder(sslSocket, baseSocket));
+    }
+
     @Override
     public ClassicHttpRequest receiveRequestHeader() throws HttpException, IOException {
         final SocketHolder socketHolder = ensureOpen();
diff --git a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpServerConnectionFactory.java b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpServerConnectionFactory.java
index 56d5c8ece..4b84958dd 100644
--- a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpServerConnectionFactory.java
+++ b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/DefaultBHttpServerConnectionFactory.java
@@ -30,11 +30,14 @@ package org.apache.hc.core5.http.impl.io;
 import java.io.IOException;
 import java.net.Socket;
 
+import javax.net.ssl.SSLSocket;
+
 import org.apache.hc.core5.annotation.Contract;
 import org.apache.hc.core5.annotation.ThreadingBehavior;
 import org.apache.hc.core5.http.ClassicHttpRequest;
 import org.apache.hc.core5.http.ClassicHttpResponse;
 import org.apache.hc.core5.http.ContentLengthStrategy;
+import org.apache.hc.core5.http.URIScheme;
 import org.apache.hc.core5.http.config.CharCodingConfig;
 import org.apache.hc.core5.http.config.Http1Config;
 import org.apache.hc.core5.http.impl.CharCodingSupport;
@@ -94,10 +97,9 @@ public class DefaultBHttpServerConnectionFactory implements HttpConnectionFactor
         this(scheme, http1Config, charCodingConfig, null, null, null, null);
     }
 
-    @Override
-    public DefaultBHttpServerConnection createConnection(final Socket socket) throws IOException {
-        final DefaultBHttpServerConnection conn = new DefaultBHttpServerConnection(
-                this.scheme,
+    DefaultBHttpServerConnection createDetached(final Socket socket) {
+        return new DefaultBHttpServerConnection(
+                scheme != null ? scheme : (socket instanceof SSLSocket ? URIScheme.HTTPS.id : URIScheme.HTTP.id),
                 this.http1Config,
                 CharCodingSupport.createDecoder(this.charCodingConfig),
                 CharCodingSupport.createEncoder(this.charCodingConfig),
@@ -105,10 +107,25 @@ public class DefaultBHttpServerConnectionFactory implements HttpConnectionFactor
                 this.outgoingContentStrategy,
                 this.requestParserFactory,
                 this.responseWriterFactory);
+    }
+
+    @Override
+    public DefaultBHttpServerConnection createConnection(final Socket socket) throws IOException {
+        final DefaultBHttpServerConnection conn = createDetached(socket);
         conn.bind(socket);
         return conn;
     }
 
+    /**
+     * @since 5.3
+     */
+    @Override
+    public DefaultBHttpServerConnection createConnection(final SSLSocket sslSocket, final Socket socket) throws IOException {
+        final DefaultBHttpServerConnection conn = createDetached(sslSocket);
+        conn.bind(sslSocket, socket);
+        return conn;
+    }
+
     /**
      * Create a new {@link Builder}.
      *
diff --git a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/SocketHolder.java b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/SocketHolder.java
index b189dc594..114034d42 100644
--- a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/SocketHolder.java
+++ b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/io/SocketHolder.java
@@ -33,6 +33,9 @@ import java.io.OutputStream;
 import java.net.Socket;
 import java.util.concurrent.atomic.AtomicReference;
 
+import javax.net.ssl.SSLSocket;
+
+import org.apache.hc.core5.annotation.Internal;
 import org.apache.hc.core5.util.Args;
 
 /**
@@ -43,18 +46,46 @@ import org.apache.hc.core5.util.Args;
  */
 public class SocketHolder {
 
-    private final Socket socket;
+    private final SSLSocket sslSocket;
+    private final Socket baseSocket;
     private final AtomicReference<InputStream> inputStreamRef;
     private final AtomicReference<OutputStream> outputStreamRef;
 
+    /**
+     * @since 5.3
+     */
+    public SocketHolder(final SSLSocket sslSocket, final Socket baseSocket) {
+        this.sslSocket = Args.notNull(sslSocket, "SSL Socket");
+        this.baseSocket = Args.notNull(baseSocket, "Socket");
+        this.inputStreamRef = new AtomicReference<>();
+        this.outputStreamRef = new AtomicReference<>();
+    }
+
     public SocketHolder(final Socket socket) {
-        this.socket = Args.notNull(socket, "Socket");
+        this.baseSocket = Args.notNull(socket, "Socket");
+        this.sslSocket = null;
         this.inputStreamRef = new AtomicReference<>();
         this.outputStreamRef = new AtomicReference<>();
     }
 
     public final Socket getSocket() {
-        return socket;
+        return sslSocket != null ? sslSocket : baseSocket;
+    }
+
+    /**
+     * @since 5.3
+     */
+    @Internal
+    public Socket getBaseSocket() {
+        return baseSocket;
+    }
+
+    /**
+     * @since 5.3
+     */
+    @Internal
+    public SSLSocket getSSLSocket() {
+        return sslSocket;
     }
 
     public final InputStream getInputStream() throws IOException {
@@ -62,7 +93,7 @@ public class SocketHolder {
         if (local != null) {
             return local;
         }
-        local = getInputStream(socket);
+        local = getInputStream(getSocket());
         if (inputStreamRef.compareAndSet(null, local)) {
             return local;
         }
@@ -82,7 +113,7 @@ public class SocketHolder {
         if (local != null) {
             return local;
         }
-        local = getOutputStream(socket);
+        local = getOutputStream(getSocket());
         if (outputStreamRef.compareAndSet(null, local)) {
             return local;
         }
@@ -91,7 +122,10 @@ public class SocketHolder {
 
     @Override
     public String toString() {
-        return socket.toString();
+        return "SocketHolder{" +
+                "sslSocket=" + sslSocket +
+                ", baseSocket=" + baseSocket +
+                '}';
     }
 
 }
diff --git a/httpcore5/src/main/java/org/apache/hc/core5/http/io/HttpConnectionFactory.java b/httpcore5/src/main/java/org/apache/hc/core5/http/io/HttpConnectionFactory.java
index e1e68b02c..ce12f68db 100644
--- a/httpcore5/src/main/java/org/apache/hc/core5/http/io/HttpConnectionFactory.java
+++ b/httpcore5/src/main/java/org/apache/hc/core5/http/io/HttpConnectionFactory.java
@@ -30,6 +30,8 @@ package org.apache.hc.core5.http.io;
 import java.io.IOException;
 import java.net.Socket;
 
+import javax.net.ssl.SSLSocket;
+
 import org.apache.hc.core5.http.HttpConnection;
 
 /**
@@ -41,4 +43,15 @@ public interface HttpConnectionFactory<T extends HttpConnection> {
 
     T createConnection(Socket socket) throws IOException;
 
+    /**
+     * Create TLS connection with a {@link SSLSocket} layered over a plain {@link Socket}.
+     * @param sslSocket the SSL socket. May be {@code null}.
+     * @param socket the plain socket SSL socket has been layered over.
+     *
+     * @since 5.3
+     */
+    default T createConnection(SSLSocket sslSocket, Socket socket) throws IOException {
+        return createConnection(sslSocket != null ? sslSocket : socket);
+    }
+
 }


(httpcomponents-core) 01/03: More flexible TLS layer initialization by the classic HTTP server bootstrap

Posted by ol...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

olegk pushed a commit to branch HTTPCLIENT-2328
in repository https://gitbox.apache.org/repos/asf/httpcomponents-core.git

commit 884f280140f116fda5ee7b1eb9a01317d4d5867b
Author: Oleg Kalnichevski <ol...@apache.org>
AuthorDate: Sun Jun 2 22:00:48 2024 +0200

    More flexible TLS layer initialization by the classic HTTP server bootstrap
---
 .../core5/testing/classic/ClassicTestServer.java   |  4 +-
 .../testing/classic/ClassicTLSIntegrationTest.java |  4 +-
 .../hc/core5/http/impl/bootstrap/HttpServer.java   |  6 ++
 .../core5/http/impl/bootstrap/RequestListener.java | 67 +++++++++++++++++-----
 .../core5/http/impl/bootstrap/ServerBootstrap.java | 15 ++---
 5 files changed, 67 insertions(+), 29 deletions(-)

diff --git a/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/ClassicTestServer.java b/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/ClassicTestServer.java
index 2e94c7754..0a5938855 100644
--- a/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/ClassicTestServer.java
+++ b/httpcore5-testing/src/main/java/org/apache/hc/core5/testing/classic/ClassicTestServer.java
@@ -31,7 +31,6 @@ import java.io.IOException;
 import java.net.InetAddress;
 import java.util.concurrent.atomic.AtomicReference;
 
-import javax.net.ServerSocketFactory;
 import javax.net.ssl.SSLContext;
 
 import org.apache.hc.core5.function.Decorator;
@@ -115,11 +114,12 @@ public class ClassicTestServer {
                     httpService,
                     null,
                     socketConfig,
-                    sslContext != null ? sslContext.getServerSocketFactory() : ServerSocketFactory.getDefault(),
+                    null,
                     new LoggingBHttpServerConnectionFactory(
                             sslContext != null ? URIScheme.HTTPS.id : URIScheme.HTTP.id,
                             http1Config != null ? http1Config : Http1Config.DEFAULT,
                             CharCodingConfig.DEFAULT),
+                    sslContext,
                     null,
                     LoggingExceptionListener.INSTANCE);
             if (serverRef.compareAndSet(null, server)) {
diff --git a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicTLSIntegrationTest.java b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicTLSIntegrationTest.java
index aa1b0e4d6..f25b38027 100644
--- a/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicTLSIntegrationTest.java
+++ b/httpcore5-testing/src/test/java/org/apache/hc/core5/testing/classic/ClassicTLSIntegrationTest.java
@@ -66,7 +66,7 @@ import org.junit.jupiter.api.extension.RegisterExtension;
 
 public class ClassicTLSIntegrationTest {
 
-    private static final Timeout TIMEOUT = Timeout.ofMinutes(1);
+    private static final Timeout TIMEOUT = Timeout.ofSeconds(1);
 
     private HttpServer server;
 
@@ -272,7 +272,7 @@ public class ClassicTLSIntegrationTest {
         for (final String cipherSuite : weakCiphersSuites) {
             server = ServerBootstrap.bootstrap()
                     .setSslContext(SSLTestContexts.createServerSSLContext())
-                    .setSslSetupHandler(sslParameters -> sslParameters.setProtocols(new String[]{cipherSuite}))
+                    .setSslSetupHandler(sslParameters -> sslParameters.setCipherSuites(new String[]{cipherSuite}))
                     .create();
             Assertions.assertThrows(Exception.class, () -> {
                 try {
diff --git a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/HttpServer.java b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/HttpServer.java
index 410d6bed2..8c17d1b62 100644
--- a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/HttpServer.java
+++ b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/HttpServer.java
@@ -36,6 +36,7 @@ import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
 
 import javax.net.ServerSocketFactory;
+import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLParameters;
 import javax.net.ssl.SSLServerSocket;
 import javax.net.ssl.SSLServerSocketFactory;
@@ -74,6 +75,7 @@ public class HttpServer implements ModalCloseable {
     private final ServerSocketFactory serverSocketFactory;
     private final HttpService httpService;
     private final HttpConnectionFactory<? extends DefaultBHttpServerConnection> connectionFactory;
+    private final SSLContext sslContext;
     private final Callback<SSLParameters> sslSetupHandler;
     private final ExceptionListener exceptionListener;
     private final ThreadPoolExecutor listenerExecutorService;
@@ -92,6 +94,7 @@ public class HttpServer implements ModalCloseable {
             final SocketConfig socketConfig,
             final ServerSocketFactory serverSocketFactory,
             final HttpConnectionFactory<? extends DefaultBHttpServerConnection> connectionFactory,
+            final SSLContext sslContext,
             final Callback<SSLParameters> sslSetupHandler,
             final ExceptionListener exceptionListener) {
         this.port = Args.notNegative(port, "Port value is negative");
@@ -103,6 +106,7 @@ public class HttpServer implements ModalCloseable {
                 this.serverSocketFactory instanceof SSLServerSocketFactory ? URIScheme.HTTPS.id : URIScheme.HTTP.id,
                 Http1Config.DEFAULT,
                 CharCodingConfig.DEFAULT);
+        this.sslContext = sslContext;
         this.sslSetupHandler = sslSetupHandler;
         this.exceptionListener = exceptionListener != null ? exceptionListener : ExceptionListener.NO_OP;
         this.listenerExecutorService = new ThreadPoolExecutor(
@@ -152,6 +156,8 @@ public class HttpServer implements ModalCloseable {
                     this.serverSocket,
                     this.httpService,
                     this.connectionFactory,
+                    this.sslContext != null ? this.sslContext.getSocketFactory() : null,
+                    this.sslSetupHandler,
                     this.exceptionListener,
                     this.workerExecutorService);
             this.listenerExecutorService.execute(this.requestListener);
diff --git a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/RequestListener.java b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/RequestListener.java
index c09ce11c0..4b6302d5a 100644
--- a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/RequestListener.java
+++ b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/RequestListener.java
@@ -32,11 +32,19 @@ import java.net.Socket;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.atomic.AtomicBoolean;
 
+import javax.net.ssl.SSLHandshakeException;
+import javax.net.ssl.SSLParameters;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+
+import org.apache.hc.core5.function.Callback;
 import org.apache.hc.core5.http.ExceptionListener;
 import org.apache.hc.core5.http.impl.io.HttpService;
 import org.apache.hc.core5.http.io.HttpConnectionFactory;
 import org.apache.hc.core5.http.io.HttpServerConnection;
 import org.apache.hc.core5.http.io.SocketConfig;
+import org.apache.hc.core5.io.Closer;
 
 class RequestListener implements Runnable {
 
@@ -44,6 +52,8 @@ class RequestListener implements Runnable {
     private final ServerSocket serverSocket;
     private final HttpService httpService;
     private final HttpConnectionFactory<? extends HttpServerConnection> connectionFactory;
+    private final SSLSocketFactory sslSocketFactory;
+    private final Callback<SSLParameters> sslSetupHandler;
     private final ExceptionListener exceptionListener;
     private final ExecutorService executorService;
     private final AtomicBoolean terminated;
@@ -53,34 +63,63 @@ class RequestListener implements Runnable {
             final ServerSocket serversocket,
             final HttpService httpService,
             final HttpConnectionFactory<? extends HttpServerConnection> connectionFactory,
+            final SSLSocketFactory sslSocketFactory,
+            final Callback<SSLParameters> sslSetupHandler,
             final ExceptionListener exceptionListener,
             final ExecutorService executorService) {
         this.socketConfig = socketConfig;
         this.serverSocket = serversocket;
-        this.connectionFactory = connectionFactory;
         this.httpService = httpService;
+        this.connectionFactory = connectionFactory;
+        this.sslSocketFactory = sslSocketFactory;
+        this.sslSetupHandler = sslSetupHandler;
         this.exceptionListener = exceptionListener;
         this.executorService = executorService;
         this.terminated = new AtomicBoolean(false);
     }
 
+    private Socket createSocket(final Socket socket) throws IOException {
+        socket.setSoTimeout(this.socketConfig.getSoTimeout().toMillisecondsIntBound());
+        socket.setKeepAlive(this.socketConfig.isSoKeepAlive());
+        socket.setTcpNoDelay(this.socketConfig.isTcpNoDelay());
+        if (this.socketConfig.getRcvBufSize() > 0) {
+            socket.setReceiveBufferSize(this.socketConfig.getRcvBufSize());
+        }
+        if (this.socketConfig.getSndBufSize() > 0) {
+            socket.setSendBufferSize(this.socketConfig.getSndBufSize());
+        }
+        if (this.socketConfig.getSoLinger().toSeconds() >= 0) {
+            socket.setSoLinger(true, this.socketConfig.getSoLinger().toSecondsIntBound());
+        }
+        if (!(socket instanceof SSLSocket) && sslSocketFactory != null) {
+            final SSLSocket sslSocket = (SSLSocket) sslSocketFactory.createSocket(socket, null, -1, true);
+            sslSocket.setUseClientMode(false);
+            if (this.sslSetupHandler != null) {
+                final SSLParameters sslParameters = sslSocket.getSSLParameters();
+                this.sslSetupHandler.execute(sslParameters);
+                sslSocket.setSSLParameters(sslParameters);
+            }
+            try {
+                sslSocket.startHandshake();
+                final SSLSession session = sslSocket.getSession();
+                if (session == null) {
+                    throw new SSLHandshakeException("SSL session not available");
+                }
+                return sslSocket;
+            } catch (final IOException ex) {
+                Closer.closeQuietly(sslSocket);
+                throw ex;
+            }
+        } else {
+            return socket;
+        }
+    }
+
     @Override
     public void run() {
         try {
             while (!isTerminated() && !Thread.interrupted()) {
-                final Socket socket = this.serverSocket.accept();
-                socket.setSoTimeout(this.socketConfig.getSoTimeout().toMillisecondsIntBound());
-                socket.setKeepAlive(this.socketConfig.isSoKeepAlive());
-                socket.setTcpNoDelay(this.socketConfig.isTcpNoDelay());
-                if (this.socketConfig.getRcvBufSize() > 0) {
-                    socket.setReceiveBufferSize(this.socketConfig.getRcvBufSize());
-                }
-                if (this.socketConfig.getSndBufSize() > 0) {
-                    socket.setSendBufferSize(this.socketConfig.getSndBufSize());
-                }
-                if (this.socketConfig.getSoLinger().toSeconds() >= 0) {
-                    socket.setSoLinger(true, this.socketConfig.getSoLinger().toSecondsIntBound());
-                }
+                final Socket socket = createSocket(this.serverSocket.accept());
                 final HttpServerConnection conn = this.connectionFactory.createConnection(socket);
                 final Worker worker = new Worker(this.httpService, conn, this.exceptionListener);
                 this.executorService.execute(worker);
diff --git a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/ServerBootstrap.java b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/ServerBootstrap.java
index c8d97b7a6..4dc4cb021 100644
--- a/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/ServerBootstrap.java
+++ b/httpcore5/src/main/java/org/apache/hc/core5/http/impl/bootstrap/ServerBootstrap.java
@@ -384,18 +384,10 @@ public class ServerBootstrap {
                 this.connStrategy != null ? this.connStrategy : DefaultConnectionReuseStrategy.INSTANCE,
                 this.streamListener);
 
-        ServerSocketFactory serverSocketFactoryCopy = this.serverSocketFactory;
-        if (serverSocketFactoryCopy == null) {
-            if (this.sslContext != null) {
-                serverSocketFactoryCopy = this.sslContext.getServerSocketFactory();
-            } else {
-                serverSocketFactoryCopy = ServerSocketFactory.getDefault();
-            }
-        }
-
         HttpConnectionFactory<? extends DefaultBHttpServerConnection> connectionFactoryCopy = this.connectionFactory;
         if (connectionFactoryCopy == null) {
-            final String scheme = serverSocketFactoryCopy instanceof SSLServerSocketFactory ? URIScheme.HTTPS.id : URIScheme.HTTP.id;
+            final String scheme = serverSocketFactory instanceof SSLServerSocketFactory || sslContext != null ?
+                    URIScheme.HTTPS.id : URIScheme.HTTP.id;
             connectionFactoryCopy = new DefaultBHttpServerConnectionFactory(scheme, this.http1Config, this.charCodingConfig);
         }
 
@@ -404,8 +396,9 @@ public class ServerBootstrap {
                 httpService,
                 this.localAddress,
                 this.socketConfig != null ? this.socketConfig : SocketConfig.DEFAULT,
-                serverSocketFactoryCopy,
+                serverSocketFactory,
                 connectionFactoryCopy,
+                sslContext,
                 sslSetupHandler != null ? sslSetupHandler : DefaultTlsSetupHandler.SERVER,
                 this.exceptionListener != null ? this.exceptionListener : ExceptionListener.NO_OP);
     }