Vendor https://github.com/marianobarrios/[email protected]

Modified to conform to driver style and compile at Java 6 language level

JAVA-3038

Author: jyemin

THIRD-PARTY-NOTICES

@@ -104,3 +104,47 @@ https://github.com/mongodb/mongo-java-driver.
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      See the License for the specific language governing permissions and
      limitations under the License.
+
+7) The following files (originally from https://github.com/marianobarrios/tls-channel):
+
+       AsynchronousTlsChannel.java
+       AsynchronousTlsChannelGroup.java
+       ExtendedAsynchronousByteChannel.java
+       BufferHolder.java
+       ByteBufferSet.java
+       ByteBufferUtil.java
+       TlsChannelImpl.java
+       TlsChannelCallbackException.java
+       Util.java
+       BufferAllocator.java
+       ClientTlsChannel.java
+       NeedsReadException.java
+       NeedsTaskException.java
+       NeedsWriteException.java
+       TlsChannel.java
+       TlsChannelBuilder.java
+       TlsChannelFlowControlException.java
+       TrackingAllocator.java
+       WouldBlockException.java
+
+     Copyright (c) [2015-2018] all contributors
+
+     MIT License
+
+     Permission is hereby granted, free of charge, to any person obtaining a copy
+     of this software and associated documentation files (the "Software"), to deal
+     in the Software without restriction, including without limitation the rights
+     to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     copies of the Software, and to permit persons to whom the Software is
+     furnished to do so, subject to the following conditions:
+
+     The above copyright notice and this permission notice shall be included in all
+     copies or substantial portions of the Software.
+
+     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+     SOFTWARE.

config/checkstyle-exclude.xml

@@ -21,6 +21,9 @@
         "http://www.puppycrawl.com/dtds/suppressions_1_1.dtd">
 
 <suppressions>
+
+    <suppress checks="VisibilityModifier" files="com[\\/]mongodb[\\/]internal[\\/]connection[\\/]tlschannel[\\/]"/>
+
     <suppress checks="MethodLength" files="QuickTour"/>
     <suppress checks="Regexp" files="QuickTour"/>
 

driver-core/src/main/com/mongodb/internal/connection/tlschannel/BufferAllocator.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Original Work: MIT License, Copyright (c) [2015-2018] all contributors
+ * https://github.com/marianobarrios/tls-channel
+ */
+
+package com.mongodb.internal.connection.tlschannel;
+
+import org.bson.ByteBuf;
+
+/**
+ * A factory for {@link ByteBuf}s. Implementations are free to return heap or
+ * direct buffers, or to do any kind of pooling. They are also expected to be
+ * thread-safe.
+ */
+public interface BufferAllocator {
+
+    /**
+     * Allocate a {@link ByteBuf} with the given initial capacity.
+     */
+    ByteBuf allocate(int size);
+
+    /**
+     * Deallocate the given {@link ByteBuf}.
+     *
+     * @param buffer the buffer to deallocate, that should have been allocated using
+     *               the same {@link BufferAllocator} instance
+     */
+    void free(ByteBuf buffer);
+
+}

driver-core/src/main/com/mongodb/internal/connection/tlschannel/ClientTlsChannel.java

@@ -0,0 +1,229 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Original Work: MIT License, Copyright (c) [2015-2018] all contributors
+ * https://github.com/marianobarrios/tls-channel
+ */
+
+package com.mongodb.internal.connection.tlschannel;
+
+import com.mongodb.internal.connection.tlschannel.impl.BufferHolder;
+import com.mongodb.internal.connection.tlschannel.impl.ByteBufferSet;
+import com.mongodb.internal.connection.tlschannel.impl.TlsChannelImpl;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.SSLSession;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.ByteChannel;
+import java.nio.channels.Channel;
+import java.util.Optional;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+/**
+ * A client-side {@link TlsChannel}.
+ */
+public final class ClientTlsChannel implements TlsChannel {
+
+    /**
+     * Builder of {@link ClientTlsChannel}
+     */
+    public static final class Builder extends TlsChannelBuilder<Builder> {
+
+        private Supplier<SSLEngine> sslEngineFactory;
+
+        private Builder(final ByteChannel underlying, final SSLEngine sslEngine) {
+            super(underlying);
+            this.sslEngineFactory = new Supplier<SSLEngine>() {
+                @Override
+                public SSLEngine get() {
+                    return sslEngine;
+                }
+            };
+        }
+
+        private Builder(final ByteChannel underlying, final SSLContext sslContext) {
+            super(underlying);
+            this.sslEngineFactory = new Supplier<SSLEngine>() {
+                @Override
+                public SSLEngine get() {
+                    return defaultSSLEngineFactory(sslContext);
+                }
+            };
+        }
+
+        @Override
+        Builder getThis() {
+            return this;
+        }
+
+        public ClientTlsChannel build() {
+            return new ClientTlsChannel(underlying, sslEngineFactory.get(), sessionInitCallback, runTasks,
+                    plainBufferAllocator, encryptedBufferAllocator, releaseBuffers, waitForCloseConfirmation);
+        }
+
+    }
+
+    private static SSLEngine defaultSSLEngineFactory(final SSLContext sslContext) {
+        SSLEngine engine = sslContext.createSSLEngine();
+        engine.setUseClientMode(true);
+        return engine;
+    }
+
+    /**
+     * Create a new {@link Builder}, configured with a underlying
+     * {@link Channel} and a fixed {@link SSLEngine}.
+     *
+     * @param underlying a reference to the underlying {@link ByteChannel}
+     * @param sslEngine  the engine to use with this channel
+     */
+    public static Builder newBuilder(final ByteChannel underlying, final SSLEngine sslEngine) {
+        return new Builder(underlying, sslEngine);
+    }
+
+    /**
+     * Create a new {@link Builder}, configured with a underlying
+     * {@link Channel} and a {@link SSLContext}.
+     *
+     * @param underlying a reference to the underlying {@link ByteChannel}
+     * @param sslContext a context to use with this channel, it will be used to create a client {@link SSLEngine}.
+     */
+    public static Builder newBuilder(final ByteChannel underlying, final SSLContext sslContext) {
+        return new Builder(underlying, sslContext);
+    }
+
+    private final ByteChannel underlying;
+    private final TlsChannelImpl impl;
+
+    private ClientTlsChannel(
+            final ByteChannel underlying,
+            final SSLEngine engine,
+            final Consumer<SSLSession> sessionInitCallback,
+            final boolean runTasks,
+            final BufferAllocator plainBufAllocator,
+            final BufferAllocator encryptedBufAllocator,
+            final boolean releaseBuffers,
+            final boolean waitForCloseNotifyOnClose) {
+        if (!engine.getUseClientMode()) {
+            throw new IllegalArgumentException("SSLEngine must be in client mode");
+        }
+        this.underlying = underlying;
+        TrackingAllocator trackingPlainBufAllocator = new TrackingAllocator(plainBufAllocator);
+        TrackingAllocator trackingEncryptedAllocator = new TrackingAllocator(encryptedBufAllocator);
+        impl = new TlsChannelImpl(underlying, underlying, engine, Optional.<BufferHolder>empty(), sessionInitCallback, runTasks,
+                trackingPlainBufAllocator, trackingEncryptedAllocator, releaseBuffers, waitForCloseNotifyOnClose);
+    }
+
+    @Override
+    public ByteChannel getUnderlying() {
+        return underlying;
+    }
+
+    @Override
+    public SSLEngine getSslEngine() {
+        return impl.engine();
+    }
+
+    @Override
+    public Consumer<SSLSession> getSessionInitCallback() {
+        return impl.getSessionInitCallback();
+    }
+
+    @Override
+    public TrackingAllocator getPlainBufferAllocator() {
+        return impl.getPlainBufferAllocator();
+    }
+
+    @Override
+    public TrackingAllocator getEncryptedBufferAllocator() {
+        return impl.getEncryptedBufferAllocator();
+    }
+
+    @Override
+    public boolean getRunTasks() {
+        return impl.getRunTasks();
+    }
+
+    @Override
+    public long read(final ByteBuffer[] dstBuffers, final int offset, final int length) throws IOException {
+        ByteBufferSet dest = new ByteBufferSet(dstBuffers, offset, length);
+        TlsChannelImpl.checkReadBuffer(dest);
+        return impl.read(dest);
+    }
+
+    @Override
+    public long read(final ByteBuffer[] dstBuffers) throws IOException {
+        return read(dstBuffers, 0, dstBuffers.length);
+    }
+
+    @Override
+    public int read(final ByteBuffer dstBuffer) throws IOException {
+        return (int) read(new ByteBuffer[]{dstBuffer});
+    }
+
+    @Override
+    public long write(final ByteBuffer[] srcBuffers, final int offset, final int length) throws IOException {
+        ByteBufferSet source = new ByteBufferSet(srcBuffers, offset, length);
+        return impl.write(source);
+    }
+
+    @Override
+    public long write(final ByteBuffer[] outs) throws IOException {
+        return write(outs, 0, outs.length);
+    }
+
+    @Override
+    public int write(final ByteBuffer srcBuffer) throws IOException {
+        return (int) write(new ByteBuffer[]{srcBuffer});
+    }
+
+    @Override
+    public void renegotiate() throws IOException {
+        impl.renegotiate();
+    }
+
+    @Override
+    public void handshake() throws IOException {
+        impl.handshake();
+    }
+
+    @Override
+    public void close() throws IOException {
+        impl.close();
+    }
+
+    @Override
+    public boolean isOpen() {
+        return impl.isOpen();
+    }
+
+    @Override
+    public boolean shutdown() throws IOException {
+        return impl.shutdown();
+    }
+
+    @Override
+    public boolean shutdownReceived() {
+        return impl.shutdownReceived();
+    }
+
+    @Override
+    public boolean shutdownSent() {
+        return impl.shutdownSent();
+    }
+
+}

driver-core/src/main/com/mongodb/internal/connection/tlschannel/NeedsReadException.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Original Work: MIT License, Copyright (c) [2015-2018] all contributors
+ * https://github.com/marianobarrios/tls-channel
+ */
+
+package com.mongodb.internal.connection.tlschannel;
+
+import java.nio.channels.ByteChannel;
+import java.nio.channels.Selector;
+import java.nio.channels.SocketChannel;
+
+/**
+ * This exception signals the caller that the operation cannot continue because
+ * bytesProduced need to be read from the underlying {@link ByteChannel}, the channel is
+ * non-blocking and there are no bytesProduced available. The caller should try the
+ * operation again, either with the channel in blocking mode of after ensuring
+ * that bytesProduced are ready.
+ * <p>
+ * For {@link SocketChannel}s, a {@link Selector} can be used to find out when
+ * the method should be retried.
+ * <p>
+ * Caveat: Any {@link TlsChannel} I/O method can throw this exception. In
+ * particular, <code>write</code> may want to read data. This is because TLS
+ * handshakes may occur at any time (initiated by either the client or the
+ * server).
+ * <p>
+ * This exception is akin to the SSL_ERROR_WANT_READ error code used by OpenSSL.
+ *
+ * @see <a href="https://www.openssl.org/docs/man1.1.0/ssl/SSL_get_error.html">
+ * OpenSSL error documentation</a>
+ */
+public class NeedsReadException extends WouldBlockException {
+
+    private static final long serialVersionUID = 13846137963119227L;
+}