Add SslOptions

src/main/java/redis/clients/jedis/DefaultJedisClientConfig.java

@@ -20,6 +20,8 @@ public final class DefaultJedisClientConfig implements JedisClientConfig {
   private final boolean ssl;
   private final SSLSocketFactory sslSocketFactory;
   private final SSLParameters sslParameters;
+  private final SslOptions sslOptions;
+  private final SslHostnameVerifyMode sslHostnameVerifyMode;
   private final HostnameVerifier hostnameVerifier;
 
   private final HostAndPortMapper hostAndPortMapper;
@@ -28,6 +30,7 @@ public final class DefaultJedisClientConfig implements JedisClientConfig {
 
   private final boolean readOnlyForRedisClusterReplicas;
 
+  // TODO:
   private DefaultJedisClientConfig(RedisProtocol protocol, int connectionTimeoutMillis, int soTimeoutMillis,
       int blockingSocketTimeoutMillis, Supplier<RedisCredentials> credentialsProvider, int database,
       String clientName, boolean ssl, SSLSocketFactory sslSocketFactory, SSLParameters sslParameters,
@@ -43,12 +46,33 @@ private DefaultJedisClientConfig(RedisProtocol protocol, int connectionTimeoutMi
     this.ssl = ssl;
     this.sslSocketFactory = sslSocketFactory;
     this.sslParameters = sslParameters;
+    this.sslOptions = null; // TODO:
+    this.sslHostnameVerifyMode = null; // TODO:
     this.hostnameVerifier = hostnameVerifier;
     this.hostAndPortMapper = hostAndPortMapper;
     this.clientSetInfoConfig = clientSetInfoConfig;
     this.readOnlyForRedisClusterReplicas = readOnlyForRedisClusterReplicas;
   }
 
+  private DefaultJedisClientConfig(DefaultJedisClientConfig.Builder builder) {
+    this.redisProtocol = builder.redisProtocol;
+    this.connectionTimeoutMillis = builder.connectionTimeoutMillis;
+    this.socketTimeoutMillis = builder.socketTimeoutMillis;
+    this.blockingSocketTimeoutMillis = builder.blockingSocketTimeoutMillis;
+    this.credentialsProvider = builder.credentialsProvider;
+    this.database = builder.database;
+    this.clientName = builder.clientName;
+    this.ssl = builder.ssl;
+    this.sslSocketFactory = builder.sslSocketFactory;
+    this.sslParameters = builder.sslParameters;
+    this.sslOptions = builder.sslOptions;
+    this.sslHostnameVerifyMode = builder.sslHostnameVerifyMode;
+    this.hostnameVerifier = builder.hostnameVerifier;
+    this.hostAndPortMapper = builder.hostAndPortMapper;
+    this.clientSetInfoConfig = builder.clientSetInfoConfig;
+    this.readOnlyForRedisClusterReplicas = builder.readOnlyForRedisClusterReplicas;
+  }
+
   @Override
   public RedisProtocol getRedisProtocol() {
     return redisProtocol;
@@ -110,6 +134,16 @@ public SSLParameters getSslParameters() {
     return sslParameters;
   }
 
+  @Override
+  public SslOptions getSslOptions() {
+    return sslOptions;
+  }
+
+  @Override
+  public SslHostnameVerifyMode getSslHostnameVerifyMode() {
+    return sslHostnameVerifyMode;
+  }
+
   @Override
   public HostnameVerifier getHostnameVerifier() {
     return hostnameVerifier;
@@ -151,6 +185,8 @@ public static class Builder {
     private boolean ssl = false;
     private SSLSocketFactory sslSocketFactory = null;
     private SSLParameters sslParameters = null;
+    private SslOptions sslOptions = null;
+    private SslHostnameVerifyMode sslHostnameVerifyMode = null;
     private HostnameVerifier hostnameVerifier = null;
 
     private HostAndPortMapper hostAndPortMapper = null;
@@ -168,14 +204,12 @@ public DefaultJedisClientConfig build() {
             new DefaultRedisCredentials(user, password));
       }
 
-      return new DefaultJedisClientConfig(redisProtocol, connectionTimeoutMillis, socketTimeoutMillis,
-          blockingSocketTimeoutMillis, credentialsProvider, database, clientName, ssl,
-          sslSocketFactory, sslParameters, hostnameVerifier, hostAndPortMapper, clientSetInfoConfig,
-          readOnlyForRedisClusterReplicas);
+      return new DefaultJedisClientConfig(this);
     }
 
     /**
      * Shortcut to {@link Builder#protocol(redis.clients.jedis.RedisProtocol)} with {@link RedisProtocol#RESP3}.
+     * @return this
      */
     public Builder resp3() {
       return protocol(RedisProtocol.RESP3);
@@ -252,6 +286,16 @@ public Builder sslParameters(SSLParameters sslParameters) {
       return this;
     }
 
+    public Builder sslOptions(SslOptions sslOptions) {
+      this.sslOptions = sslOptions;
+      return this;
+    }
+
+    public Builder sslHostnameVerifyMode(SslHostnameVerifyMode sslHostnameVerifyMode) {
+      this.sslHostnameVerifyMode = sslHostnameVerifyMode;
+      return this;
+    }
+
     public Builder hostnameVerifier(HostnameVerifier hostnameVerifier) {
       this.hostnameVerifier = hostnameVerifier;
       return this;
@@ -273,6 +317,7 @@ public Builder readOnlyForRedisClusterReplicas() {
     }
   }
 
+  // TOOD:
   public static DefaultJedisClientConfig create(int connectionTimeoutMillis, int soTimeoutMillis,
       int blockingSocketTimeoutMillis, String user, String password, int database, String clientName,
       boolean ssl, SSLSocketFactory sslSocketFactory, SSLParameters sslParameters,
@@ -284,6 +329,7 @@ public static DefaultJedisClientConfig create(int connectionTimeoutMillis, int s
         false);
   }
 
+  // TODO:
   public static DefaultJedisClientConfig copyConfig(JedisClientConfig copy) {
     return new DefaultJedisClientConfig(copy.getRedisProtocol(),
         copy.getConnectionTimeoutMillis(), copy.getSocketTimeoutMillis(),

src/main/java/redis/clients/jedis/DefaultJedisSocketFactory.java

@@ -1,12 +1,15 @@
 package redis.clients.jedis;
 
+import java.io.IOException;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.Socket;
+import java.security.GeneralSecurityException;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLParameters;
 import javax.net.ssl.SSLSocket;
 import javax.net.ssl.SSLSocketFactory;
@@ -24,6 +27,8 @@ public class DefaultJedisSocketFactory implements JedisSocketFactory {
   private int socketTimeout = Protocol.DEFAULT_TIMEOUT;
   private boolean ssl = false;
   private SSLSocketFactory sslSocketFactory = null;
+  private SslOptions sslOptions = null;
+  private SslHostnameVerifyMode sslHostnameVerifyMode = null;
   private SSLParameters sslParameters = null;
   private HostnameVerifier hostnameVerifier = null;
   private HostAndPortMapper hostAndPortMapper = null;
@@ -49,6 +54,8 @@ public DefaultJedisSocketFactory(HostAndPort hostAndPort, JedisClientConfig conf
       this.ssl = config.isSsl();
       this.sslSocketFactory = config.getSslSocketFactory();
       this.sslParameters = config.getSslParameters();
+      this.sslOptions = config.getSslOptions();
+      this.sslHostnameVerifyMode = config.getSslHostnameVerifyMode();
       this.hostnameVerifier = config.getHostnameVerifier();
       this.hostAndPortMapper = config.getHostAndPortMapper();
     }
@@ -89,25 +96,8 @@ public Socket createSocket() throws JedisConnectionException {
       socket = connectToFirstSuccessfulHost(_hostAndPort);
       socket.setSoTimeout(socketTimeout);
 
-      if (ssl) {
-        SSLSocketFactory _sslSocketFactory = this.sslSocketFactory;
-        if (null == _sslSocketFactory) {
-          _sslSocketFactory = (SSLSocketFactory) SSLSocketFactory.getDefault();
-        }
-        Socket plainSocket = socket;
-        socket = _sslSocketFactory.createSocket(socket, _hostAndPort.getHost(), _hostAndPort.getPort(), true);
-
-        if (null != sslParameters) {
-          ((SSLSocket) socket).setSSLParameters(sslParameters);
-        }
-        socket = new SSLSocketWrapper((SSLSocket) socket, plainSocket);
-
-        if (null != hostnameVerifier
-            && !hostnameVerifier.verify(_hostAndPort.getHost(), ((SSLSocket) socket).getSession())) {
-          String message = String.format(
-            "The connection to '%s' failed ssl/tls hostname verification.", _hostAndPort.getHost());
-          throw new JedisConnectionException(message);
-        }
+      if (ssl || sslOptions != null) {
+        socket = createSslSocket(_hostAndPort, socket);
       }
 
       return socket;
@@ -122,6 +112,57 @@ public Socket createSocket() throws JedisConnectionException {
     }
   }
 
+  /**
+   * ssl enable check is done before this.
+   */
+  private Socket createSslSocket(HostAndPort _hostAndPort, Socket socket) throws IOException, GeneralSecurityException {
+
+    Socket plainSocket = socket;
+
+    SSLSocketFactory _sslSocketFactory;
+    SSLParameters _sslParameters;
+
+    if (sslOptions != null) {
+
+      SSLContext _sslContext = sslOptions.createSslContext();
+
+      _sslParameters = sslParameters != null ? sslParameters : new SSLParameters(); // TODO:
+
+      if (sslHostnameVerifyMode == SslHostnameVerifyMode.HTTPS) {
+        _sslParameters.setEndpointIdentificationAlgorithm("HTTPS");
+      } else if (sslHostnameVerifyMode == SslHostnameVerifyMode.DISABLE) {
+        _sslParameters.setEndpointIdentificationAlgorithm("");
+      }
+
+      _sslSocketFactory = _sslContext.getSocketFactory();
+
+    } else {
+
+      _sslSocketFactory = this.sslSocketFactory;
+      _sslParameters = this.sslParameters;
+
+    }
+
+    if (_sslSocketFactory == null) {
+      _sslSocketFactory = (SSLSocketFactory) SSLSocketFactory.getDefault();
+    }
+
+    SSLSocket sslSocket = (SSLSocket) _sslSocketFactory.createSocket(socket,
+        _hostAndPort.getHost(), _hostAndPort.getPort(), true);
+
+    if (_sslParameters != null) {
+      sslSocket.setSSLParameters(_sslParameters);
+    }
+
+    if (hostnameVerifier != null && !hostnameVerifier.verify(_hostAndPort.getHost(), sslSocket.getSession())) {
+      String message = String.format("The connection to '%s' failed ssl/tls hostname verification.",
+          _hostAndPort.getHost());
+      throw new JedisConnectionException(message);
+    }
+
+    return new SSLSocketWrapper(sslSocket, plainSocket);
+  }
+
   public void updateHostAndPort(HostAndPort hostAndPort) {
     this.hostAndPort = hostAndPort;
   }

src/main/java/redis/clients/jedis/JedisClientConfig.java

@@ -72,6 +72,19 @@ default SSLParameters getSslParameters() {
     return null;
   }
 
+  /**
+   * {@link JedisClientConfig#isSsl()} and {@link JedisClientConfig#getSslSocketFactory()} will be ignored if
+   * {@link JedisClientConfig#getSslOptions() this} is set.
+   * @return ssl options
+   */
+  default SslOptions getSslOptions() {
+    return null;
+  }
+
+  default SslHostnameVerifyMode getSslHostnameVerifyMode() {
+    return null; // TODO: SslVerifyMode.HTTPS
+  }
+
   default HostnameVerifier getHostnameVerifier() {
     return null;
   }

src/main/java/redis/clients/jedis/SslHostnameVerifyMode.java

@@ -0,0 +1,8 @@
+package redis.clients.jedis;
+
+public enum SslHostnameVerifyMode {
+
+    HTTPS,
+
+    DISABLE;
+}